{"cells":[{"metadata":{},"cell_type":"markdown","source":"**W**elcome to the CHAMPS competition.  In this competition, we're given a suite of several hundred thousand molecules whose structure has been previously computed by density functional theory.  This comes from a standard library of molecules used for large data / high throughput chemical calculations.  From the geometry, we're asked to predict the magnitude of magnetic coupling between proton and nitrogen atoms, proton-proton coupling, and carbon-proton couplings.  This data could be experimentally collected by Nuclear Magnetic Resonance (NMR) experiments, the data provided instead is a theoretically computed value for the coupling.  As a physical chemist myself, that's an important distinction becuase a lot of my practical intuition has certain concepts baked in that simply don't apply here.  For example, I automatically think that certain interactions will be wiped out by spatial movement and ensemble averaging, which won't be the case for this competition.  \n\nAs a chemist, I think the most interesting part of this machine learning exercise is not the problem as given, per se, but rather the inverse problem. Given an NMR spectrum, with measured couplings, can machine learning accurately predict molecular structure.  This would be a huge advance allowing a very common and relatively inexpensive technique to to predict structure without human intervention.  This is a common task learned by anyone who's ever taken an organic chemistry lab, and taking the human element out of it was be a game changer.  With that concept in mind, let's first look at the data, and see what we're working with"},{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load in \n\n#Let's load some libraries that we'll need to take a look at our data\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\nimport os\nimport multiprocessing as mp\nimport time\nimport matplotlib.pyplot as plt\nimport matplotlib as mpl\nimport random","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"##Setup some matplotlib details\nfont = {'family' : 'serif',\n        'weight' : 'normal',\n        'size'   : 16}\n\nmpl.rc('font', **font)","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","trusted":true},"cell_type":"code","source":"#Input the data\ntrain=pd.read_csv('../input/train.csv')\ntest=pd.read_csv('../input/test.csv')\nstructures=pd.read_csv('../input/structures.csv')\ntrain.head()\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Let's take a quick look at the data we're given.  For each entry in the training and test files we're asked to predict, we'll see that we have a molecular file name, the two atoms involved in the coupling, and the type of coupling,  For every molecule in the structures.csv file, we have a list of the atoms and their X, Y, and Z coordinates"},{"metadata":{"trusted":true},"cell_type":"code","source":"train.head()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"structures.head()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"One of the things that I'll point out is that the structural information as given **DOES NOT** directly show any \"chemical\" information.  It doesn't list which atoms are bonded to which, or what the distances and angles are between atoms.  All of that information will need to be inferred or computed by the people persuing this competition.  \nLuckily, chemists have been studying molecules for a long time, and there are some handy tools for converting a molecule  in what we call an \"xyz\" format to something with more implied information.  Personally, in my modeling sets I've used openbabel and its child pybel a lot.  These are completely opensource python (and c++) modules that apply standard chemical knowledge to learn such structural information, and it can neatly solve some other questions, such as is there a ring in the molecule.  Some types of coupling, particularly the 1JHN and 1JHC are paritcularly sensitive to ring strain and what the chemist would call the s- and p- character of the bond involved.  To learn more about openbabel, visit https://openbabel.org "},{"metadata":{},"cell_type":"markdown","source":"Effectively, this competition boils down to 8 separate competitions and the total score is just the average of how well you do on each one.  Let's look at the largest and the smallest of the two competitions, the type 1JHN, looking at proton-nitrogen nearest neighbor couplings and the type 3JHC, Carbon Hydrogen coupling which is a much larger dataset due to the high number of carbon and protons in these molecules."},{"metadata":{"trusted":true},"cell_type":"code","source":"#We're giong to start separating our data by type sets: 1JHN and 3JHC\ntrain1JHN=train[train['type']=='1JHN']\ntest1JHN=test[test['type']=='1JHN']\ntrain3JHC=train[train['type']=='3JHC']\ntest3JHC=test[test['type']=='3JHC']\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print('There are {} unique atoms'.format(structures['atom'].nunique()))\nprint('Those atoms are {}'.format(structures['atom'].unique()))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def element_to_atomic_number(ele):\n    \"\"\" Given an input string that is an element's symbol, output its atomic number\"\"\"\n    ele_to_atomic_number={'C':6, 'H':1, 'N':7, 'O':8, 'F':9}\n    return ele_to_atomic_number[ele]\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print('The largest value for X is {} and the smallest value is {}'.format(structures['x'].max(),structures['x'].min()))\nprint('The largest value for Y is {} and the smallest value is {}'.format(structures['y'].max(),structures['y'].min()))\nprint('The largest value for Z is {} and the smallest value is {}'.format(structures['z'].max(),structures['z'].min()))\n#These numbers are important if we end up using conv or capsule nets for regression on the potential\nxspread=structures['x'].max()-structures['x'].min()\nyspread=structures['y'].max()-structures['y'].min()\nzspread=structures['z'].max()-structures['z'].min()\nprint('The smallest box that would hold all molecules in the data set is: ({0:.2f}x{1:.2f}x{2:.2f}) Angstroms'.format(xspread,yspread,zspread))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#We'll build a list of the molecule names in each type we want to explore\ntrain1JHN.describe()\nmol1JHN=train1JHN['molecule_name'].unique()\nmol_test1JHN=test1JHN['molecule_name'].unique()\nmol3JHC=train3JHC['molecule_name'].unique()\nmol_test3JHC=test3JHC['molecule_name'].unique()\nstructures1JHN=structures[structures['molecule_name'].isin(mol1JHN)]\nstructures_test1JHN=structures[structures['molecule_name'].isin(mol_test1JHN)]\nstructures3JHC=structures[structures['molecule_name'].isin(mol3JHC)]\nstructures_test3JHC=structures[structures['molecule_name'].isin(mol_test3JHC)]","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def get_info(struct):\n    \"\"\"get_info(struct) takes in a pandas dataframe object from structures.csv of all structures with a given molecular name \n        and outputs the number of atoms, the total # of electrons, and the molecule's spread in X,Y,Z,\"\"\"\n    n_atoms=len(struct)\n    spread_x=struct['x'].max()-struct['x'].min()\n    spread_y=struct['y'].max()-struct['y'].min()\n    spread_z=struct['z'].max()-struct['z'].min()\n    spread=np.array([spread_x,spread_y,spread_z])\n    electrons=0\n    for i in range(n_atoms):\n        electrons +=element_to_atomic_number(struct.iloc[i]['atom'])\n    return n_atoms, electrons,spread\n        ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"sample=5000\nn_atoms1JHN=np.zeros((sample,1)).astype(int)\ntotal_electrons1JHN=np.zeros((sample,1)).astype(int)\nn_atoms3JHC=np.zeros((sample,1)).astype(int)\ntotal_electrons3JHC=np.zeros((sample,1)).astype(int)\nspread1JHN=np.zeros((sample,3))\nspread3JHC=np.zeros((sample,3))\nfor i, name in enumerate(np.random.choice(mol1JHN,sample,replace=False)):\n    struct=structures1JHN[structures1JHN['molecule_name']==name]\n    n_atoms1JHN[i],total_electrons1JHN[i],spread1JHN[i,:]=get_info(struct)\n    if ((i+1)%1000 ==0) and (i !=0):\n        print('Currently on the {}th name out of {} train1JHN samples'.format(i, sample))\nfor i, name in enumerate(np.random.choice(mol3JHC,sample,replace=False)):        \n    struct=structures3JHC[structures3JHC['molecule_name']==name]\n    n_atoms3JHC[i],total_electrons3JHC[i],spread3JHC[i,:]=get_info(struct)\n    if ((i+1)%1000 ==0) and (i !=0):\n        print('Currently on the {}th name out of {} train3JHC samples'.format(i, sample))\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"n_atoms_test1JHN=np.zeros((sample,1)).astype(int)\ntotal_electrons_test1JHN=np.zeros((sample,1)).astype(int)\nn_atoms_test3JHC=np.zeros((sample,1)).astype(int)\ntotal_electrons_test3JHC=np.zeros((sample,1)).astype(int)\nspread_test1JHN=np.zeros((sample,3))\nspread_test3JHC=np.zeros((sample,3))\n\nfor i, name in enumerate(np.random.choice(mol_test1JHN,sample,replace=False)):\n    struct=structures_test1JHN[structures_test1JHN['molecule_name']==name]\n    n_atoms_test1JHN[i],total_electrons_test1JHN[i],spread_test1JHN[i,:]=get_info(struct)\n    if ((i+1)%1000 ==0) and (i !=0):\n        print('Currently on the {}th name out of {} test1JHN samples'.format(i, sample))\n\nfor i, name in enumerate(np.random.choice(mol_test3JHC,sample,replace=False)):        \n    struct=structures_test3JHC[structures_test3JHC['molecule_name']==name]\n    n_atoms_test3JHC[i],total_electrons_test3JHC[i],spread_test3JHC[i,:]=get_info(struct)\n    if ((i+1)%1000 ==0) and (i !=0):\n        print('Currently on the {}th name out of {} test3JHC samples'.format(i, sample))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"f=plt.figure()\nf.set_figheight(5)\nf.set_figwidth(12.5)\nax1=plt.subplot(1,2,1)\ntmp=plt.hist(n_atoms1JHN,density=True,bins=(n_atoms1JHN.max()-n_atoms1JHN.min()),alpha=1,label='1JHN Training Data')\ntmp=plt.hist(n_atoms_test1JHN,density=True, bins=(n_atoms_test1JHN.max()-n_atoms_test1JHN.min()),alpha=.5, color='green',label='1JHN Test Data')\nplt.legend(loc='upper left')\nplt.xlabel('Number of Atoms in Molecule')\nplt.ylabel('Frequency')\nplt.title('# of Atoms in 1JHN Molecules')\n\n#Plot # of atoms for 3JHC\nax1=plt.subplot(1,2,2)\ntmp=plt.hist(n_atoms3JHC,density=True,bins=(n_atoms3JHC.max()-n_atoms3JHC.min()),alpha=1,label='3JHC Training Data')\ntmp=plt.hist(n_atoms_test3JHC,density=True, bins=(n_atoms_test3JHC.max()-n_atoms_test3JHC.min()),alpha=.5, color='green',label='3JHC Test Data')\nplt.legend(loc='upper left')\nplt.xlabel('Number of Atoms in Molecule')\nplt.ylabel('Frequency')\nplt.title('# of Atoms in 3JHC Molecules')\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"g=plt.figure()\ng.set_figheight(5)\ng.set_figwidth(12.5)\n\n#Plot Z or # of electrons for 1JHN\nax1=plt.subplot(1,2,1)\ntmp=plt.hist(total_electrons1JHN,density=True,bins=(total_electrons1JHN.max()-total_electrons1JHN.min()),alpha=1,label='1JHN Training Data')\ntmp=plt.hist(total_electrons_test1JHN,density=True, bins=(total_electrons_test1JHN.max()-total_electrons_test1JHN.min()),alpha=.5, color='green',label='1JHN Test Data')\nplt.legend(loc='upper left')\nplt.xlabel('Number of Electrons in Molecule')\nplt.ylabel('Frequency')\nplt.title('# of Electrons in 1JHN Molecules')\n\n#Plot Z or # of electrons for 3JHC\nax2=plt.subplot(1,2,2)\ntmp=plt.hist(total_electrons3JHC,density=True,bins=(total_electrons3JHC.max()-total_electrons3JHC.min()),alpha=1,label='3JHC Training Data')\ntmp=plt.hist(total_electrons_test3JHC,density=True, bins=(total_electrons_test3JHC.max()-total_electrons_test3JHC.min()),alpha=.5, color='green',label='3JHC Test Data')\nplt.legend(loc='upper left')\nplt.xlabel('Number of Electrons in Molecule')\nplt.ylabel('Frequency')\nplt.title('# of Electrons in 3JHC molecules')\nplt.show()\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"So by examining the distributions of the smallest (1JHN) and the largest (3JHC) datasets, we can see that these training data do a pretty reasonable approximation of data we'll be trying to predict.  They have the same mean to within about 1 part per thousand.  They  have the same number of atoms / molecule and the same atomic distributions.  Next we'll just double check that they have roughly the same size by comparing the average height,width, and depth and associated standard deviation of molecules in the train and test sets"},{"metadata":{"trusted":true},"cell_type":"code","source":"f=plt.figure()\nf.set_figheight(5)\nf.set_figwidth(20)\nax1=plt.subplot(1,3,1)\nh=plt.hist(np.vstack((spread1JHN[:,0],spread_test1JHN[:,0])).T, density=True, bins=30,label=['X Spread Train1JHN','X Spread Test1JHN'])\nplt.legend(loc='upper left')\nplt.xlabel('Spread in X')\nplt.ylabel('Frequency')\nax1.text(6,0.3,'<X> = {0:.2f} train \\nand {1:.2f} test'.format(spread1JHN[:,0].mean(), spread_test1JHN[:,0].mean()))\nax1.text(6,0.23,'<$\\sigma_X$> = {0:.2f} train\\n and {1:.2f} test'.format(spread1JHN[:,0].std(), spread_test1JHN[:,0].std()))\nax2=plt.subplot(1,3,2)\nh=plt.hist(np.vstack((spread1JHN[:,1],spread_test1JHN[:,1])).T, density=True, bins=30,label=['Y Spread Train1JHN','Y Spread Test1JHN'])\nplt.legend(loc='upper left')\nplt.xlabel('Spread in Y')\nplt.ylabel('Frequency')\nax2.text(6,0.3,'<Y> = {0:.2f} train\\n and {1:.2f} test'.format(spread1JHN[:,1].mean(), spread_test1JHN[:,1].mean()))\nax2.text(6,0.23,'<$\\sigma_Y$> = {0:.2f} train\\n and {1:.2f} test'.format(spread1JHN[:,1].std(), spread_test1JHN[:,1].std()))\nax3=plt.subplot(1,3,3)\nh=plt.hist(np.vstack((spread1JHN[:,2],spread_test1JHN[:,2])).T, density=True,bins=30,label=['Z Spread Train1JHN','Z Spread Test1JHN'])\nplt.legend(loc='upper left')\nplt.xlabel('Spread in Z')\nplt.ylabel('Frequency')\nax3.text(6,0.3,'<Z> = {0:.2f} train\\n and {1:.2f} test'.format(spread1JHN[:,2].mean(), spread_test1JHN[:,2].mean()))\nax3.text(5.5,0.23,'<$\\sigma_Z$> = {0:.2f} train\\n and {1:.2f} test'.format(spread1JHN[:,2].std(), spread_test1JHN[:,2].std()))\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"f=plt.figure()\nf.set_figheight(5)\nf.set_figwidth(20)\nax1=plt.subplot(1,3,1)\nh=plt.hist(np.vstack((spread3JHC[:,0],spread_test3JHC[:,0])).T, density=True, bins=30,label=['X Spread Train3JHC','X Spread Test3JHC'])\nplt.legend(loc='upper left')\nplt.xlabel('Spread in X')\nplt.ylabel('Frequency')\nax1.text(6,0.3,'<X> = {0:.2f} train \\nand {1:.2f} test'.format(spread3JHC[:,0].mean(), spread_test3JHC[:,0].mean()))\nax1.text(6,0.23,'<$\\sigma_X$> = {0:.2f} train\\n and {1:.2f} test'.format(spread3JHC[:,0].std(), spread_test3JHC[:,0].std()))\nax2=plt.subplot(1,3,2)\nh=plt.hist(np.vstack((spread3JHC[:,1],spread_test3JHC[:,1])).T, density=True, bins=30,label=['Y Spread Train3JHC','Y Spread Test3JHC'])\nplt.legend(loc='upper left')\nplt.xlabel('Spread in Y')\nplt.ylabel('Frequency')\nax2.text(6,0.3,'<Y> = {0:.2f} train\\n and {1:.2f} test'.format(spread3JHC[:,1].mean(), spread_test3JHC[:,1].mean()))\nax2.text(6,0.23,'<$\\sigma_Y$> = {0:.2f} train\\n and {1:.2f} test'.format(spread3JHC[:,1].std(), spread_test3JHC[:,1].std()))\nax3=plt.subplot(1,3,3)\nh=plt.hist(np.vstack((spread3JHC[:,2],spread_test3JHC[:,2])).T, density=True,bins=30,label=['Z Spread Train3JHC','Z Spread Test3JHC'])\nplt.legend(loc='upper left')\nplt.xlabel('Spread in Z')\nplt.ylabel('Frequency')\nax3.text(6,0.3,'<Z> = {0:.2f} train\\n and {1:.2f} test'.format(spread3JHC[:,2].mean(), spread_test3JHC[:,2].mean()))\nax3.text(5.5,0.23,'<$\\sigma_Z$> = {0:.2f} train\\n and {1:.2f} test'.format(spread3JHC[:,2].std(), spread_test3JHC[:,2].std()))\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"So it looks like the training set is a fair proxy for the test set, spatially as well.  There are other tests that one could do to check for specific things that I expect are highly correlated with NMR shift such as number of ring density and stastical planarity, but at this point I'm satisfied that the training and test sets have roughly the same distributions"},{"metadata":{},"cell_type":"markdown","source":"**T**he next step in processing this data would be to start modelling it, and looking for patterns in how the scalar coupling constant (J) varies based on the features in our training set.  The only problem, our features at this point are nigh useless.  The only info we have immediate access to is the location of each atom and the atom type.  So while one could make a few plots of J vs the number of atoms in the molecule, or the number of oxygens, or the spatial extent, we won't actually learn much other than show some ugly barely correlated blobs.  Given the high level of precision I expect to see winning the competition, our feature set as given is completely unaccessable.  \nSo there are two approaches as I see it:\n1.   Feature Engineering.   There are a ton of geometric features one could use.  For example, one could use the distance between the two coupled atoms.  That definitely shows a correlation with J, but it is non linear.  Looking up some physics shows that one might expect dipole-dipole interactions to scale like 1/R_6, so we could have a separate feature for each molecule that calculates the inverse 6th power of the bond length.  Of course, that's just the classical interaction.  Quantum mechanically I might expect to see a perturbation series containing all of the even powers of 1/R.  So maybe we calculate the first 20 or so and add that to our features.  And then maybe it depends strongly on the angles (and dihedral angles for the 3JHN,3JHH,3JHC).  It does, but again its a non-linear non-trivial function.  So we could throw in a bunch of trig functions (sine, cosine, tan, cos^2, etc) as features. To illustrate this, I've plotted the coupling constant vs bond length and a specific bond angle for 5000 molecules from the 1JHN training set. As you can see, there is a correlation between these features, but a lot of scatter.  That scatter is **NOT** noise, but caused by correlation to other features that we're not plotting.   Which features are important and critical? Noone knows, that's why need ML to help us out.  Once we've come up with an exhaustive list of features, really throwing everything under the sun at it, we could use a nice gradient boosting model to help us find the best approximation.  While the gradient boosting will find non-linear solutions of our features, its ability to predict will be highly depdendent on what features we tell it are possible.\n![image.png](attachment:image.png)\n2.  Neural Networks.  The other way to approach this problem is to say not only do I not know what features are important, I don't think anyone does.  Instead, lets see if the computer can learn the rules on its own.  So I have some kernels which take the atomic level inputs, calculate a 3D image of the corresponding potentials, and then use neural networks and image processing to calculate the corresponding rules to map a given potential to a coupling constant J\n\nAt first glance, both of these seem like they could be highly prone to overfitting.  But here I want to make a critical distinction between this data and most datasets.  There **IS** mathematical function that takes the molecule's geometry and then outputs the coupling constant.  It may be a highly complicated, non-linear, non-local function, that is non analytic but these data were achieved via a computer doing a well specified set of tasks (I'm not sure of exactly how they were calculated, but almost certainly it involves building Coulomb's potential for this molecule, expressing the electron density as a sum of atom-centered gaussian functions, iterating the Kohn Sham equations with some functional that approximates the energy as function of the density by adjusting the density until selfconsistency is achieved, and then looking at derivatives of the resulting potential with respect to a magnetic field or orbital occupations).  That process is involved, but it is a one-to-one and onto mapping. Moreover, it is also not subject to random error.  If the procedure says that the coupling is J, then it is J plus or minus some small number to account for numerical accuracy (in this case 10^-9 as we're told).  So before worrying about traditional overfitting, realize that it is okay if the models gives lots of weight to some oddball configurations.  If another molecule is in an arbitrarily close location in chemical configuration space, it will have a similar coupling constant J.  Of course, this also means that if your training set has enough data, a K-nearest neighbors approach could also be highly accurate.  I think that may work well for the datasets where you have over a million training examples, but for smaller sets such as 1JHN I'd be suprised if we have enough data there.  \n\nAlright, that's about it for my EDA on this project.  It's time to start making some models which will appear in different kernels.  I'm effectively new to approaching this type of project from a data science viewpoint, so I'd love to hear any comments or questions you might have on how I'm thinking about and approaching this compeition.\n\nCheers,\nJames","attachments":{"image.png":{"image/png":"iVBORw0KGgoAAAANSUhEUgAABaAAAAFoCAYAAAChVFwCAAAgAElEQVR4AeydCbQdRbW/696bG0jCkIBhHsIkSAgECMKTv0BAEQUCBEJEROSpOKLwAA1PlKA8CaIyiPrAh4iCEIYAwTwUhaDrRQMETcAog0gIIkIwhCEDd/yvX4c6qdu3q0+foc/p7vPVWpfurq5pf9Xh7Nq9e1dbf39/vyFBAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABOpMoL3O7dEcBCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQCAggAGaBwECEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAARSIYABOhWsNAoBCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIYoHkGIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAIBUCGKBTwUqjEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQggAGaZwACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAARSIYABOhWsNAoBCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIYoHkGIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAIBUCGKBTwUqjEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQggAGaZwACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAARSIYABOhWsNAoBCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIYoHkGIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAIBUCGKBTwUqjEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQggAGaZwACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAARSIYABOhWsNAoBCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIYoHkGIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAIBUCGKBTwUqjEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQggAGaZwACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAARSIYABOhWsNAoBCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIYoHkGIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAIBUCGKBTwUqjEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQggAGaZwACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAARSIYABOhWsNAoBCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIYoHkGIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAIBUCGKBTwUqjEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQggAGaZwACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAARSIYABOhWsNAoBCECgWASWLFli2traTE9PTyYE01j++te/ZmIsaQ3i/e9/v7n++uvTap52IQABCEAAAhAoAIFPfepT5utf/3oBJElXhB//+Mfm//2//5duJ57WP/rRj5rzzz/fc5dsCEAAAq1BAAN0a8wzUkIAAikSuOqqq8yECRPMeuutZ6RguilsuI1SQKPKyMD60EMPlZqSsVV5aSUtXjbYYIPgb+jQoaazs7N0LUNonlJXV5c5++yzzTbbbBPIsMMOO5izzjorUyJoLkeMGBGMb9NNNzWHHXaYmTlz5oAx3nPPPebUU08dkBd10QrG+Ci5yYMABCAAAQj4CBRBN5Ns06dPD/S/W2+9tSSqnAH02y/9Uem///u/zVe+8pXg/IEHHgj0n1LhjJ8ccsghZv311w/0oY033tgcdNBB5rHHHmvaqFeuXBmM5QMf+EDTxkDHEIAABIpKAAN0UWcWuSAAgYYR2GqrrQKvhn//93+vW5+bbLJJQz0ltHh54403gr///M//NFOnTi1dyxBaaWqmp/TFF19sFixYEBjwX3/9dTN37lyz9957VypC6uUXLVoUMH7iiSeCFxef+9znzIUXXph6v3QAAQhAAAIQKDqBIuhmdo6kE371q181vb29NqumYzN1tKiB62WBdNB//etfRgbpU045JapYQ/Juu+22wKHk3nvvNS+88EJD+qQTCEAAAq1CAAN0q8w0ckIAAqkRmDx5sjn22GONPFnrleT5+uijj5rf/OY3ZZucMWOGOeGEEwaU+8IXvmA+//nPB3n65HDHHXc0G264oZE38I033jigbCUXqrvddtuZt73tbea//uu/SlXloaMxfPjDHzYbbbSRUZ9vvvmmOfPMM40WgfrTufKUoj6DdD15tQg5+uijg7b222+/wBgf/mzy17/+tdlll13MqFGjzGc/+1nT398ftP3www+b4447LuhTbY4ZM8Z85CMfKY1V1zJS77777kHd0047zaxZsya4/8orr5ijjjrKjB49Orin87///e+lusuXLzcqL3nUr+bdpp///Odm/PjxZuTIkeZd73pXMH/2XtxRLLXY+sEPfhCMS7IraRH2P//zP8G5POAPPvhgI+8gldcLAiV5CinttddegceOvKjLyaB25Sl14IEHBs/E4Ycfbl5++eWgHf3n//7v/4LxS45tt902mCvla+7OOeecYP4333xzI6/51atXl+pxAgEIQAACEMgKgSLpZkcccYTR12k33HBDJF77dZ28d/XV2j/+8Y9AJ9CXbTqvVEdTJ9/85jfNlltuGeg70kVcHS1OH7Ae2N/+9rfNZpttFrRx3XXXRY47nDlkyBDzwQ9+0Pz5z38u3YrTJcv1JX1q0qRJgS75zne+0zz99NOldn0nCn0m/WbPPfccpC9Lf/zWt74V3JM+Jl3M6o9qL45ZuL84nfGSSy4xW2+9daCj7brrrua+++4LV+caAhCAQC4JYIDO5bQxaAhAoOgEhg8fbuSJ/OUvf7msqCeddJL53//9X/Paa68FZeUhc8stt5gPfehDRosRGaLlxSxv4N/97neBkbRso54CMk7KY1fK8Ne+9jXzl7/8pVTyrrvuCozQK1asMCeffHJgoJ4/f75ZuHChkbevQopcdNFFpfJxJzIoK0TFP//5zyAOclQsZCnvMjarbcn7y1/+MmjygAMOMN/5znfM97///eAzTmuYdvuTIV3ltRh58sknS+Pq6+sLDMzPPvusWbp0qRk2bJiRZ7JNMhSvWrXKLF682Lz00kul0B5/+MMfjDzgr7766sCD55Of/GSw6LEGd1s/7njMMccEMbbd0Cu2vAzGMhTLuCyD+BlnnBHc+u1vfxscrTe1FkPlZFCFn/3sZ0YLQsmgkCVaUClJZi1e1f6yZcuCuZNRXelLX/pSwErzKYP4888/HzwDwU3+AwEIQAACECg4gWbpZjL+KsazvpLq7u72UpbeJH1PL8ntV206V6pER/vFL34R6FF60a/f+7AzRDl9QLrbq6++GugJ1157beAkIP2lXJI+Iv1MepxNcnaI0yXj+pIuqfAe8mT+0Y9+FPzZdqOO0oFk1JYOq7+f/OQng4pJ3xSfZ555JnA0kEOFUjlmbkNxOqN0bHmES7+V3i5dVYZvEgQgAIEiEMAAXYRZRAYIQCBXBGTsk3ep/ZOXRVSSEVPKcLkQGNtvv73ZZ599zJ133hk0c//99xstkqwC397ebv70pz8F3qryZhk7dmxUd4nyLrjggsAoK49b/cnwadO//du/BR7B6k+GWy0i9MmoPGDkUay6P/3pT21x71EG9Ntvvz1YaEkOeSpHxUKeNm1awFAe2RMnTgyMpWr0vPPOC4yl6l+xueVFEjZgy6gs71591ioj/0033RSMR17sxx9/fMBPHuO6ZxdeWsBoLhSuRN7PipMtr2SlH/7wh0bztf/++5uOjo5gvIoJrkVT0qT25N0sL+tw0j0ZxeXJpMVU2BvcLR8ngy0nL+63v/3twTydeOKJJXZi9p73vMfopYb6VFsyQMuILxkvu+yygJnY6AXJzTffbJvkCAEIQAACEMgtgazrZvLklS5lv4yqFHQlOpqMrNITpC9KD5P+ZlMSfUD6g/Q/HRVLWZ7YMqz6khwlpBOrnIyvbn/ldElfX1aXlLOEDPN77LFHpC7pjkkGZ+nk0julB8nZ4I9//KNbJHDqkFFf+qO+1NNLeaU4ZgMaKKMzSoeU84K8wPWyQcbnnXbaKdwE1xCAAARySQADdC6njUFDAAJ5JqAwBvIStn8KtRGVZMCU56v+orx43TrydrZGVHm36lpJSrfCMshoKuPzkUceaR5//HG3akXnW2yxRam8FiXysLFJBl03yVgq47hNOldeuSTPW8UndNtzz21931ikvMvrZd68eQFjGZHlnex6a7vtueOSd7MMycpTKBGFuNA8aSHz3HPPBQsOGZ/DScZhfW5qXyroqPJJ5LVtaaEh2bWoCSd91qlnQJ+QakEoTx5fipPB1vGx05ijFjoal9rdd999SzLqk2DlkyAAAQhAAAJ5J5AH3Uxfkckj2A37kJS7q/eoTpyOpntuefc8iT6gl9cKp2FTWF+0+fZ45ZVXBrqW5NLXbQrpZnXjuHGqvq8vjTOsS7o6qe3bPcoALc9nJRmZ5WQQdmDw6U9xzNw+dB6nM+68887m8ssvD8KmyIFDIUnUNgkCEIBAEQhggC7CLCIDBCBQWALyQNFnjHfccUesjFOmTAk+G1R4BpW1BmhVet/73md+9atfBZ8g7rbbbuYTn/hEbFvV3tQnom6S8i4l2yZ5c9tPQWUYl0HTJn1CaZM8fLRwcWMvyzBaTZIntozRMhq7MQXd9txxyYgsL50HH3wwCGliQ1zI+KsFmLyTZZAOJ92Todu+VNBR8smDJmnS57GSW0bmcNKCRx7IWoQozMdnPvOZ4LPYcDldx8kQVd7NkxxRMRLlmS2W8gayMuq5dF9AuO1wDgEIQAACECgqgWbpZu9973uNDJQKMeZLYV3Mlgvnx+locljw6WBp6gP6gu7d7353IKM2AVSKG6eVLepodcmwvhdVVnkKUffUU08Fe3FI59KfdEE5dyTZtDGOWbjPcjqjdHiFvJMOrXlTyBMSBCAAgSIQwABdhFlEBghAoKkEpJjKa0NesvrTeRJlNcmgZZDU5jHakCQuSdHW5nJaFGmjwXe84x1B8RdffNHMnj07iAUtj2p93igP4UYkGV/lrSMvFG1yp88gtUmhksJ3yJipTxfFSzLapPFp8yDlyYgrj+2oOHy2fPgozxHF8NMGeZoHea8ojt7ee+9dKvq9730vWFzJoPyNb3yjtKmfysnQKg9m3VO8RZu0uFB8ZBl/FctQHsvWQC2jvrzMtViRsVqxt+fMmRP0a+v7jupHn5jKUK5Fhrx5wunWW28tLQZlTNeCxM6jNgT829/+VqoSJ0OpkOdEnj+K+ahPScVOG/hojrQolIxnnXVWEDda1RUD2sbd9jRHNgQgAAEIQKApBPQbVkTdTB7Q+irKl6QT6LdbL4njUpyOptBc2idCX45JD5P+ZlPa+sDvf//7wGHAhouLG6cdU9QxrEvKCSHszezW0z0Z+FVOeo/+FL5O8pcLhad24pi5/eg8TmeUE4RC6SkMh0KuSSe1+l64Ha4hAAEI5I0ABui8zRjjhQAEMkdARlYpiDNmzAh2KNd5eLO9sOdJJUJI+Zbxs1ySx4SMh673szakk0esPEgU2kHxjOM8Z8r1Ucn9888/P4jBrHh648aNC+JUK09J8YcVH1DxhnfZZZdBMY0VA1CLJ3mgaOM/MZABPUkS/7PPPjuoK08dGZsVU3rHHXcsVRcjbeqnPP3ZcZ155pmB4Vr1FENbYSbcpBjWijcoT3J9Giljt5JiTctDWbGlZSCWh5LdmMat757LCK8XAiqrmI6Kr+wu8tyy2oxG8aVVXnEgr7jiiuBFg8rIUK8Y2TKay3BcTga33fC54mlrQ0s9M3peFP/ZxvnWSxCNVVwUnkRzFxfTMdw21xCAAAQgAIFGESiqbnbggQdGfilluUo/kc4k3UZ6gS98Q5yOppftisus/TX0u6/40UpWD6u3PiDdSfqN/qTzae40BqW4cQYFYv4jXVJfakmX/OhHPxo4aUQV14sK6U/agNl6P+sohw6NJ85wbdsrx8yW0zFOZ5ThWXucSA/VGLRZtBwlSBCAAASKQKCtv1xg0SJIiQwQgAAEmkRAMexsHOEmDaEQ3cozWGE6kiwCygmsDV1k8JUBlQQBCEAAAhCAQGsRQDerbL7lCa1N/GQcdWM7V9ZKa5WGWWvNN9JCAALJCOABnYwTpSAAAQhUTEDex/KokKcDqTICCruhBaLekT700EPm2muvNccdd1xljVAaAhCAAAQgAAEIOATQzRwYMafaT6SrqysIOSYngKOPPhrjcwwv3YJZGUDchgAEWp4ABuiWfwQAAAEIpEVA4Qx+8YtfBKEV0uqjqO0qjrHiQGuzQsXVU0iNY445pqjiIhcEIAABCEAAAg0ggG6WDLI2PNb+IjvttFMQg/gHP/hBsootXApmLTz5iA4BCCQiQAiORJgoBAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAApUSwAO6UmKUhwAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAgUQEMEAnwkQhCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQqJTAkEorUB4CWSbwtre9zYwZMybLQ2RsEIAABCAAAQjUQGDJkiXm5ZdfrqEFqqZBAB0sDaq0CQEIQAACEMgOAXSw7MxFHkeCATqPs8aYvQRkfF6wYIH3PjcgAAEIQAACEMg3gQkTJuRbgIKOHh2soBOLWBCAAAQgAIG3CKCD8SjUQoAQHLXQoy4EIAABCEAAAhCAAAQgAAEIQAACEIAABCAAAQh4CWCA9qLhBgQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCNRCAAN0LfSoCwEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAl4CGKC9aLgBAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACtRDAAF0LPepCAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEICAlwAGaC8abkAAAhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgEAtBDBA10KPuhCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIOAlgAHai4YbjSRw2WWXmbFjx5o99tjDnHTSSWbNmjXmmWeeMfvvv7/ZZZddzNSpU01XV1cjh0RfEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAQI0EMEDXCJDqtRN4/vnnzZVXXmkWLFhg/vSnP5ne3l5z8803my996UvmrLPOMk899ZQZNWqUufbaa2vvjBYgAAEIQAACEIAABCAAAQhAAAIQgAAEIACBhhHAAN0w1HQUR6Cnp8esXr3a6Lhq1Sqz5ZZbmvvvv9+ccMIJQbVTTz3V3HnnnXFNcA8CEIAABCAAAQhAAAIQgAAEIAABCEAAAhDIGIEhGRsPw2lBAltvvbU555xzzHbbbWeGDRtmDj/8cLPvvvuakSNHmiFD1j6i22yzjZGnNGkdgTv/+Ly59JdPmH+sWG22GjnMnPu+Xc2xe2+9rgBnEIAABCAAAQhAAAIQgAAEIACBghJgTVzQiUWsQhLAAF3Iac2XUK+88oq56667gpjPMjpPmTLF3HPPPYOEaGtrG5SnjGuuuSb40/myZcsiyxQl0/7APr9itRGN/rcE0/V5sx4LrjBCF2W2kQMCEIAABCCQbQKtpINleyYYHQQgAIHWI6C1sdbAq7t7A+G1Jj5z5kIzffZiM33SWJyzWu+RQOKMEyAER8YnqBWG9+tf/9rssMMOZvTo0aazs9NMnjzZ/O53vzMrVqwIQnKIwd///nez1VZbReI4/fTTg/jRiiGtNoqa7A+sfliVrPHZyqsfXnlEkyAAAQhAAAIQgEAjCLSKDtYIlvQBAQhAAAKVEdDa1xqf3ZorVncHhmmtn0kQgEB2CGCAzs5ctOxIFHpj/vz5Qezn/v5+c99995ndd9/dTJw40dx2220Bl+uvv94cc8wxLctIgvt+YF0oCsdBggAEIAABCEAAAhCAAAQgAAEIFJlA3NoX56wizzyy5ZUABui8zlyBxr3//vsHmw3us88+Zty4caavr8/Io+aSSy4x3/nOd8zOO+9s/vWvf5mPfexjBZK6clHifmBtayOHd9pTjhCAAAQgAAEIQAACEIAABCAAgUIS0D5Iccl+ORxXhnsQgEDjCBADunGs6SmGwIUXXmj056Ydd9zRPPTQQ25WS5/rB7bcj2h/OC5HSxNDeAhAAAIQgAAEIAABCEAAAhAoIoFz37frgBjQYRk7PHtIhctxDQEINIYAHtCN4UwvEKiZgH5gh3V2xLbz6uru2PvchAAEIAABCEAAAhCAAAQgAAEI5J3AsXtvbS6ePM4rRi/eWV423IBAMwhggG4GdfqEQBUE7A/s1jGfGpX7DKmKbqkCAQhAAAIQgAAEIAABCEAAAhDIHAGtkX3rY19+5oRgQBBoEQIYoFtkohGzGAT0Aztv2qHm8qnjB3lDyztaXtIkCEAAAhCAAAQgAAEIQAACEIBAKxCI+lKYtXErzDwy5o0AMaDzNmOMFwLGGBmilS795RNGmxPK81k/vDYfSBCAAAQgAAEIQAACEIAABCAAgaITsGtg1sZFn2nkyzsBDNB5n0HG37IE9ENrf2xbFgKCQwACEIAABCAAAQhAAAIQgEBLE2Bt3NLTj/A5IUAIjpxMFMOEAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIJA3Ahig8zZjjBcCEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAQE4IYIDOyUQxTAhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACeSOAATpvM8Z4IQABCEAAAhCAAAQgAAEIQAACEIAABCAAAQjkhAAG6JxMFMOEAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIJA3Ahig8zZjjBcCEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAQE4IYIDOyUQxTAhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACeSOAATpvM8Z4IQABCEAAAhCAAAQgAAEIQAACEIAABCAAAQjkhAAG6JxMFMOEAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIJA3Ahig8zZjjBcCEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAQE4IYIDOyUQxTAhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACeSOAATpvM8Z4IQABCEAAAhCAAAQgAAEIQAACEIAABCAAAQjkhAAG6JxMFMOEAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIJA3AkPyNmDGC4FWJnDnH583l/7yCfOPFavNViOHmXPft6s5du+tWxkJskMAAhCAAAQgAAEIQAACEGhZAqwRW3bqERwCuSKAATpX08VgW5mAFIvzZj1mVnf3BhieX7E6uNYFRuhWfjKQHQIQgAAEIAABCEAAAhBoRQKsEVtx1pEZAvkkQAiOfM4bo25BAvJ8tsZnK76ulU+CAAQgAAEIQAACEIAABCAAgdYiwBqxteYbaSGQZwIYoPM8e4y9pQgo7EZUkie03nyTIAABCEAAAhCAAAQgAAEIQKD4BLT+O3DG/UZrwajkWztGlSUPAhCAQCMIEIKjEZTpAwJVEJBS4cZ73nhYp1mxujuyJYXmUCIURyQeMiEAAQhAAAIQgAAEIAABCBSCQDjsRpRQ2i+IBAEIQCBLBDBAZ2k2GEtLE3ANziOHd5o31vSY7r7+gInebHd2tJnO9rZSngvLhuLAAO1S4RwCEIAABCAAAQhAAAIQgEA6BNz1WyM3iI8Ku+FKqDWjNqsnQQACEMgSAQzQWZoNxtKyBMJvsV9ZNdjTubt3rTHaB4nPrHxkyIcABCAAAQhAAAIQgAAEIFA/AuH1WyM3iC+37ttg/SF8GVu/qaYlCECgTgQwQNcJJM1AoBYC5d5iJ2k7/JlVs97IJxkrZSAAAQhAAAIQgAAEIAABCOSVQNT6rVFfpWrd54v9LJ5yZnrvdx4wq7r6jIzVjfTOzut8Mm4IQCB9AmxCmD5jeoBAWQLl3mKXbcAYM2bTdXG+7Bt5KSbym7Zv5JVPggAEIAABCEAAAhCAAAQgAIHqCfjWb7786nsaXFPhNYZ1dgy+4eQ89dLKYA3IWtCBwikEINBUAnhANxU/nUNgLYFyb7GTcJr39HKzw7Q5wRvulW/2GL2Bd1Oj3si7fXIOAQhAAAIQgAAEIAABCECgaAR86zflp53svj9nzlyYuCvWgolRURACEEiJAB7QKYGlWQhUQiDJW+wk7dk33CtWD44hrfqNeCOfZJyUgQAEIAABCEAAAhCAAAQgkFcCUes3bRovRyA5BR04436T9tenbRXCYy1YITCKQwACdSWAB3RdcdIYBKojYN9iX3j34iBmV3WtlK8V9UaeWNHluVECAhCAAAQgAAEIQAACEICAJWDXb4oFLcPu8KEdZmVXr7GOQDYEosrbsrZuPY7qN36L+sG9tLe1BUbxNMYzuDdyIAABCAwkgAf0QB5cQaCpBNZ096XavxsnWh0RKzpV3DQOAQhAAAIQgAAEIAABCBSUgAy586Ydai6bOt6s6hoY/lAi27AXaYhfjTdzb3+/OW/WY6l7ZqchL21CAAL5J4AHdP7nEAkKQECG4LNmLqz4LXalov/u6eUD3no3c/fmSsdOeQhAAAIQgAAEIAABCEAAAo0i4H4pOnJ4p+nvN+bV1d3BnjsKwWE9iafPXuxdx1VjKE4iny8Gdbm61ihux16uPPchAAEI1IsAHtD1Ikk7EKiSgBSbs29d5FVabLMjh3WazvZKI33Z2muP+kxLCpJNPoXIl2/rcYQABCAAAQhAAAIQgAAEIFBUAuEvRV9Z1R2E17B77mgDwPEX3mvOv/OxUtiNKBYbD+sM4kHXOy50VAzqqP6j8ljrRVEhDwIQSJsABui0CdM+BP23GqAAACAASURBVMoQkBdyb1/5CF7dvX2mO0G5Mt0FCpIUKqWomNDK1xt+EgQgAAEIQAACEIAABCAAgVYkEPWlaJiD4j3fOH9pOHvA9cquHqN40NZwXa8QGPJgvnjyODOqinVbeA2otaE2Tay3kXwACC4gAIGWJ4ABuuUfAQA0m0DSN9Da1KJeSQqVkt6ca7fmcHpjTQ+xwcJQuIYABCAAAQhAAAIQgAAEWoJA0jVaOTei7t6BJWwIjHpAlBH6j189vKKmhnV2BGtAWyns6W03T7QOS7YcRwhAAAK1EsAAXStB6kOgRgLhN9CVNtc22H5ctgmrUElpGTF0cCh4eVpbI3XZxigAAQhAAAIQgAAEIAABCECgQARqXaPFobBrsbgyldzbeuSw2OK6ryWjjvKaduM/R3l619NIHjswbkIAAi1FAAN0S003wmaRgLyQOxLEdh7W2W70xjqcNl6/01w+dbwZ3pn8n7OrUGkjjahUb8Uoqg/yIAABCEAAAhCAAAQgAAEIZI2A70vRpOPUV6bawycquWuxqPuV5mmsvqQQHfOmHWqemXFkcHSNz6rjW/P58n39VJpP2I9KiVEeAvknkNxilX9ZkSCjBJ544gkzfvz40t9GG21kLr/8crN8+XLz3ve+1+yyyy7B8ZVXXsmoBLUNS0rAt6fsZUYMHWxcdltev7MjMs6XYo8pltjkfbcxUXbscIiN8GdXPgXIl++OiXMIQAACEIAABCAAAQhAAAJFI+D7UjQsp9ZWHz5guwHGZhl9Lz1hLzN90thBDkThtVi4vWquNVaNIZy0Drzg6LHh7AHXvjWfL39A5SovCPtRJTiqQSDnBDBA53wCizD8XXfd1SxcuDD4e+SRR8zw4cPNcccdZ2bMmGEOO+ww89RTTwVHXRc1SWlY/LUjzJIZRwafR0XJqZ2XfWEx9JnU3MeXme+cOD74tEr1O96KzaEQG1KCfJ9d6Y152LM6DcUoSibyIAABCEAAAhCAAAQgAAEIZJGA70tRjdVdW1107LjA2GxDXQx/K8Sh1ngKeWHzo0Jg1EtujUFfxbp9yQiuMcSlRq4FrdfzmTMXGq1f3UTYD5cG5xAoJoHBwV+LKSdS5YTAfffdZ3baaSez/fbbm7vuuss88MADwchPPfVUc8ghh5hLLrkkJ5JUN0z9KLe3tZne/oGbVdjWtCmEL+meVTDkEW1/1OUhLYPyZVPHl+67bdg6Mm7rUyu97ZYiYvPdspxDAAIQgAAEIAABCEAAAhBoBQJaF0Wtv+Tco+Wa7smY+uU7HjNdPX1G++go2fwL714ceCArBEYjktZvla7hbPm014LW69muUaN4pB32I6pP8iAAgcYRwADdONb0lIDAzTffbE466aSg5Isvvmi23HLL4FzHl156KUEL+S1if5R9xuckko2/8F4jx+fwD7uupRxNn704uL9iVfcAQ3M1ykqS8VAGAhCAAAQgAAEIQAACEIBAHgnIKcd17JEMCmvx6qpu0+cItLJroDevvaUvWFVfyRp6da51nwy+MlTrq1Wt/+xRHsw+ZyBbr95OQ41YC0re8BrVcrLHNMN+2D44QgACzSNACI7msafnEIGuri4ze/ZsM2XKlNCd+MtrrrnGTJgwIfhbtmxZfOEM303yo1xu+PJ2lqLjS/a+3s1L4ZFCJEWGBAEIQAACEIAABColUBQdrFK5KQ8BCLQGARlmwyE0FN7QNT6XIyGj69m3LCqtuazTkdZiStb5yB6Vf9bMhWbMtDnmwBn3R9bL41qunHczISDLPUnch0D+CeABnf85LIwE99xzj9lnn33M5ptvHsik4wsvvBB4Qeu42WabRcp6+umnG/0pyRCd11TuRzkNuaQQyfDtvpFPox/ahAAEIAABCECgeASKooMVb2aQCAIQqBeBsHfwDtPmVNy0jMvWEzqJ05ENxmgdhtRhVL08reV84UwkW5zXd8WwqQABCGSWAB7QmZ2a1hvYTTfdVAq/IeknTZpkrr/++gCEjsccc0yhoTTrk6NmGL4LPZEIBwEIQAACEIAABCAAAQgUkkC1azYZi/9z1qPBV6iVgLFGZt+azZdfSR+NKOvb7PDDB2wXdC+vb9fjuxFjog8IQKCxBDBAN5Y3vXkIrFq1yvzqV78ykydPLpWYNm1akLfLLrsER10XOUX9KDdC3mqVqEaMjT4gAAEIQAACEIAABCAAAQhkhYDWbJ3tbZHD6SxjXVnVXUnwjnVdyBN642Gd6zKcsyyv5RRuREZleY3Lg/v4fbcOvJ1FT17Pur79kecDo7wNKyJD9Pl3ro2b7YjJKQQgUAAChOAowCQWQYThw4ebf/3rXwNE2XTTTc199903IK/IF/q8a8Gzy80N85c2TExibTUMNR1BAAIQgAAEIAABCEAAAjknYEMXnjfrUbM6ZFAe0tFh3rnDxmbe08vrKqUMtiu7ega1KUO4DOJZTDbWtTy4lWREl7FZMbUtQxmn7X0rgwzRN85faiZsv0mpnL3HEQIQyDeBMu/o8i0co4dA3gjMefSFhg155LDOAQpAwzqmIwhAAAIQgAAEIAABCEAAAjklIAPqJiPWGzR6GVPrbXxWJzLKdvfayNDrut1g/SGZNdLGxay2EvjCh0jS6bMX22IcIQCBghDAAF2QicyCGIcddtigYUTlDSpERonAK6u6S+dpn0S9RU+7T9qHAAQgAAEIQCD7BKL0t6i87EvCCCEAAQikQ8BnPE2nt+hWVzRw7Rg9An+uj4+b7wsrolZXrO428qImQQACxSFACI7izGXTJFmzZo1RDOeXX37ZvPLKK6a/f+3b2ddee8384x//aNq46DiegN6iX3j34sy+NY8fPXchAAEIQAACEKg3AXS6ehOlPQhAoKgEFHtZYSWambIc/9nHx45ZxuVyDlHyorbhOirhrLZVV8Zu9acwJdW0U0mflIUABMoTwABdnhElyhC4+uqrzeWXXx4Ym/fdd9+SAXqjjTYyn/3sZ8vUbu3b7o9j3BvgtCg10uM6LRloFwIQgAAEIACB+hBAp6sPR1qBAATyScBdm5UzXMqoeebMhU0VNKvxnwVFYztv1mMDYjy7+w/JQBwVVsQF6npLu/lx55pDt1+9JNC1EkboOHLcg0D6BNr6rbtq+n3RQ8EJfPe73zVnnHFGU6WcMGGCWbBgQVPHkLTz8I9j0nr1LrdkxpH1bpL2IAABCEAAAqkRyNNvfWoQUm64Gp2OeUl5UmgeAhBIlYBvbTZqeKe54OixkcbLvb92r2mWQ4/G9cevHp4qk1objzPo7zBtThDbOq6PrUcOM/OmHRpXZNA9bWwY5ZleTVuDGifD8FvPQ1ALATyga6FH3QEEZHz+3e9+Z5YsWWJ6etbt0vuRj3xkQDku1hKI2pih0WyGdbYb/UjzeVKjydMfBCAAAQhAILsE0OmyOzeMDAIQSIeAb20mA7PPg1aG6WZ4QXd2tAVG8XRI1K9VeRz7vI59ITps7663tPLijNm2jo4+r2lfvluXcwhAIF0CGKDT5dtSrZ9yyinm6aefNuPHjzcdHR2B7G1tbQYDdPRjkIUfwdXdfaU3xHyeFD1P5EIAAhCAAARajQA6XavNOPJCAAJRXrOWyuru3iCmcNiYqmvtqRPlBS0P5ah822a1xxFDO8x/HTfOa9ittt1G14sK0dFmTOAVLW9l3be8w97pcetWn2Fb+VlKSQ3qWRozY4FArQQwQNdKkPolAgp98ec//9nI6EwqT8D341i+ZnUlhna0ma7etRtE+lqQcqW3+PIAcH/0feXJhwAEIAABCECgeATQ6Yo3p0gEAQjEE+hoazO9/f61ks95SF7Qbsxh9SLv3bX5jxo5/NQjxYUCqUf7abXhM7Ra47LWnWKrtbFv/Tl99uIBsaQ1Vt9LgSjDdtibOi1Zk7ZbiUE9aZuUg0AeCGCAzsMs5WSMe+yxh/nnP/9pttxyy5yMuLnDjPpxTHNEw4cOMaPXG1LyeI7rK+6tclw97kEAAhCAAAQgkH8C6HT5n0MkgAAEBhPwGUNVMs74rPthD1q3LW0mv35nu1mxqnuAIfWsOm5SqLWcNdoOliybOeUMrZKnnExqY8Xq7kgBwy8F7JzIOG1fKIS9qSMbanBmVLgXn0G9wUOjOwikSgADdKp4W6vxl19+2ey+++7mne98p1lvvfVKws+ePbt0zsk6AvbH1r71NW3GxLx0X1exyjP9cPt+vKOa5Ecwigp5EIAABCAAgeITQKcr/hwjIQRajUA5Y6gMlb4wHGEP2nBbWmPpG+CTD9jOXHTsuBLaen7xGja2qhNrcC3nQVwaUINP6mFoVYgTX3JfCoTnRC8U7LzZdbevnUbnR82lxuDLb/T46A8CaRHAAJ0W2RZsd/r06S0odW0iu2999aOpt+T+D79q66ua2vwIVkONOhCAAAQgAIF8E0Cny/f8MXoIQGAwgXLGUN/XqVGhL2QUlbOOm7SGu3H+0iBr7uPLAmN2PSNTusZWdRI2uGbxC1bfWtKX7/K0MsbF0dac2eSb37NvWRSsscVP5bNgjPa9mAjPsZWNIwSKQgADdFFmMgNyHHzwwRkYRX6HoB/DBc8uDxSXrBih9SOY9Tfr+Z1xRg4BCEAAAhDIJgF0umzOC6OCAASqJ+Azetp8a5i0X6f6DJZaG/mMotYIbddy9fy61TW2ioLP4Kp8K0v1tOpTs1ZDq2TxpfbQtlN2HsPlbWiVLBnoo152WG/t8Pi5hkCRCLQXSRhkaS6B+fPnm/32289ssMEGZujQoaajo8NstNFGzR1UznrXJ1uXTR1v9KY9C2n5yjfNubctCt7gS5GyP9xSvEgQgAAEIAABCBSTADpdMecVqSDQygR83qVuvgy386Ydap6ZcWRwjDLkxhlFxdcan9Nm7TO4+vLTHk9U+zK0yrDqpkoMrXGy9PWbYPNHuy5159Htzz23ISbdvGac67m6ePI4o7AvsqPrqOuo560Z46NPCKRFAA/otMi2YLuf+9znzM0332ymTJlitHv6T37yE/PUU0+1IInaRNYPjzyhb3jrE67aWktee+SwTqPPxNw3+lG7Ntsfbn4gk7OlJAQgAAEIQCBPBNDp8jRbjBUCEEhCIMrrVMY/OdjsdN7/BpsQai1kvZa1Npo+aWzQtIzOMob6PHqT9F9rmfNmPRY0YddgvrEkMcTWOpak9e1YXX6aB5tfrh2fjLaeuy6Nml9bzj3GGbXdcmmfi0FSDmmPhfYh0CgCeEA3inSL9LPzzjub3t7ewPv5tNNOMw888ECLSF4/MfUW18YPq1+r5Vsau9WGRrsrJ0lp/HBL7gNn3G92mDYnONq32UnGQxkIQAACEIAABOpLAJ2uvjxpDQIQaC4BGfus16kdifVWtmEarPFZ97Wx4H/cstCce+vAr0Ft3UYfrbHV9lurd7Ftp5nHcus/yRiKtDFouHZd6s6v6nR4AnBnyUA/SBgyIFBwAsmsTQWHgHj1ITB8+HDT1dVlxo8fb774xS+aLbfc0qxcubI+jbdQK3pDbJWhRor9u6eXJ+633j/cUj70Vl+KlZIN9aFz3gw38imgLwhAAAIQgIAx6HQ8BRCAQJEIaK1hvXBHVhDqUGEe+lyrdJOhWGOrhmHXSFYurc8q8S5OWxQxnz57cWDIt325azzllVv/ScYzZy601SOP7W1tgQOTlV8MxER9hVNne1vAKJzPNQQg0BgCGKAbw7klevnpT39q+vr6zFVXXWUuu+wy89xzz5lZs2a1hOz1ElI/1FE/lvVqP66dpEbvSuJ2xfXn3pOSYI3PNt++5bfKlc3nCAEIQAACEIBAugTQ6dLlS+sQgEDjCIQdXdxwg40bRX16sk5ArkFdedpDKEtrpjBzV3q7xlNekvWf4iPHrY+t97rKaO8ieVR1681BRFK+jOJKWeIVMVSyIFBIAoTgKOS0NkeoO++806y//vrBxoMXXHCB+c53vmN+/vOfN2cwOezV/lBneej6nOn4fesfr8p9m+/K78t3y3AOAQhAAAIQgEB9CaDT1ZcnrUEAAs0jEOXo0rzRVN+znIAm7jbavOMr9wRewTK4ysyqozyJtZbMSirHXGs83zpP8igso5UnKtSI5GyPiM3R3dvvNT5bNgqtkjVedmwcIVB0Ahigiz7DDZTv+uuvH9Tbj3/840F5ZEQTKPdDHV2rsblScuY+vqzundq3+eGGlS/lg9jQYTJcQwACEIAABNIjgE6XHltahgAEGkvAZ+hs5Cg6oqylFQxA8Yz32W5jM/Oh50zcJvEVNJlq0XLMtcbzrf80MNeoLk9lOUDZmM46fviA7UqbRVYjiOuFXU196kAAAtURIARHddyo5RC46aabzM9+9jPzzDPPmEmTJpXuvPbaa2bTTTctXXMST6DcD3V87cbdTWOcerPtxgCTNPYtv5tvlRHd57Opxs05PUEAAhCAQGsQQKdrjXlGSgi0AgE5sSjcQnQwhsYSGNrRZtZff4ipNvyHwkyU268njTVatZRkXNa6LSrJcVlrPyV3nRcu6xqJb3/keWNDbeio642HdQ6ILx2uX+46S7zKjZX7ECgKAQzQRZnJJsrxrne9K9hw8OWXXzZnn312aSQbbrih2XPPPUvXnMQT0IYY1Sol8S2Xv6sNGfRj7gmXNaCBuLfVbkEpffLq1o+76kjR8BmNbX64fJRXuFVGbB23z3qfVyJDvfumPQhAAAIQgECjCaDTNZo4/UEAAmkQkA5/7q2LvOEYOjvazIihQ2oyYFYybnktR3kuV9JGOUN60jVaJX0mLXv+nY+Zmx58LlhPykP5gB1HeQ3QksNdx2m95zNWK//sWxaVjM92PFoPrt/ZHjgs6dwmzWtcDGhbTsdm8nLHwTkEWokABuhWmu2UZN1+++2N/n7961+bYcOGmfb2dvPkk0+axx9/3IwbNy6lXovVrJSkFau6mybUO3cYZaZM2G7ATsUjhnaYrp6+QYrbyjd7grAYruIQHrjkcd9oJ/FcVnvhNs/y7HrciDfW1cgQ5sA1BCAAAQhAIE8E0OnyNFuMFQIQ8BGQUdO3EZ0MpJeesFew7thh2pxMeEj75Kgk33oVV1KnkrJaG4WdhbR2k/H5hvlLS03JqWne08vNekPazZs9faV8e6JNBW2y6z+FW/QZoa3ns61jj9ZxS/OpMmrXMrDjlJd0d2+fWdm1zkit+vrS1pa17XGEAATSJ0AM6PQZt0wPBx10kFmzZo15/vnnzWGHHWauu+4689GPfrRl5K9WUGvoLPdWu9r2k9STknDerEdNV8+6H+ehQ9rN1Hdua0YN7xzQRJKNG/Sj776NVgPWc3lAY2UufG+mffllmqvodr1kqKhTCkMAAhCAAAQyQACdLgOTwBAgAIGKCWhdFWfMVIN9/f0lp5dGrCkqFqKKCmkYdSxLGenHX3ivOfe2RYGRWGtW61ykMvJ8jkpRxmef4VfGYN2rJsn4bNsNOzONWG+IOW6frc3IYevWs1rbXjx5XOkZqKZP6kAAAtURSOP/VdWNhFq5J9Df32+GDx9uZs2aZc444wxzxx13mD//+c+5lyttAaIMnWn3GdW+Pgtb1b3uLbXeKs98+LnIDR7KGZN9Hsq+/KjxKC9KGbEKhq9OvfJ9Y/Xl16tf2oEABCAAAQg0mwA6XbNngP4hAIFKCVinHp8nrW2vva0t+JpT11prKCZxHpLWQNp8LyppBac1Zb2Sy1IGZzkgdfcOdJfSevDCuxcPCo/hG4O+rvUZfmU41j3XO9rXTlS+XZuGx61nQd7ZGr9Na5z1rs3jCAEINIYABujGcG6JXrRY+f3vf29uvPFGc+SRRwYy9/T0tITstQiZZYOmFA33B9uVM27cPm8CX77brnvuKiNSDqWU+BQXt149zn1j9eXXo0/agAAEIAABCGSBADpdFmaBMUAAApUQSOrUI49ZhQqUsVJrjYFm1Up6TL+sQhq7a6AJ22/i7TRubeat5LmRlKUNg+FpZkB2OAzGgJtvxYWeN+1QrxFaoTbiXhZIfm06KWN0XLLG6rgy3IMABNIhQAzodLi2ZKtXXHGFufjii81xxx1nxo4da/72t7+ZiRMntiSLSoSWQbPcm/pK2mtU2ThDrLwJ3BjQGlO1nstSDPXX6FRPGRo9dvqDAAQgAAEI1EIAna4WetSFAAQaTUDG5ErWU64RUkbNLBqhd9lshPnVfxwyAKXCi/hS3NrMV8eXX09jttuHNoZUilvb+dZg1gnJF2JF8Z59jlPuGHSelnzhfriGAAQGEmjrl4sDCQIFITBhwgSzYMGCXEljPxUq97a2WUIpTpY+VXLHJ2Py8ftubeY+viz4AZfCI2XBVSYkl96e6wc+6n6z5Kmk3yLIUIm8lIUABCCQBwJ5/K3PA9dax8i81EqQ+hCAQDUEallLdba3eTcrrGYs9apz+dTxA9ZVtt24TRN9dWxdu66Rod5u3NfeppjYa0soTvJRe20ZrO8qMebb9pMe9UWrPJ3jkh1r1Doyar61Nl2/s90k9chOMoa48bXyPX7rW3n2a5cdD+jaGdLCWwSefPJJ861vfcssWbLEuKE37r/f/6YWeOveACuGVtIfzUZxk1KiV1QyPltFRT/YE3cbbW5/5PmSUVpKijyelawRWkd73qjx1rufIshQbya0BwEIQAACxSeATlf8OUZCCBSFQNJwEVHydlvra9TNJubZNVTYEOvz8h3W2T5o3eXWHTm807yxpqdkbFcYEiVXfHkPK15y2knrRnkxh52X3H7j1mCWTdjR6ayZC90mvOfVfpXrbZAbEIBAYgIYoBOjomA5AlOmTDGf+tSnzMc//nHT0VHdLrbl+ijqff2Q6kc0awZoKSX2UyZ3h+EoRc9+yiZZXIUnr97P7rNWNHlc2TiHAAQgAAEIhAmg04WJcA0BCGSVQNHCKcgTWUnrDzekoQy3nR1tRpt4rds2fu2saDP53b9yj/nG5D0DQ3S4btbWmFHOS0mer/Ca7DLHU1zrU7UbTtr8cOTwobn+KjcsE9cQyCsBDNB5nbkMjnvIkCHm05/+dAZHlo8h5UF5kpFZmzu86uwk7NKVDGGFp1oFw223medFk6eZLOkbAhCAAATyQQCdLh/zxCghAAEThPqLMjzmlc30SWODoUc5/GiDeH2hGhW0elV3nzlz5kKjr2rtF6zNYOAZ3qChuM5Lg25GZEStyeT1LJmjvtBVE/J2Pm6ftWEjI5okCwIQaDABDNANBl7k7o4++mjz/e9/P9iEcL311iuJuskm/t16S4U4yY3yJI9ofealN+3hpM/CopSlShWMcLvNvC6aPM1kSd8QgAAEIJAPAuh0+ZgnRgmBViJgvV9lbA6HBmxE6IhGsJa3rg0x4XNOcsNmRI2p2d7OlWwwVsmLg6g1me1L7Sg8ZHiPojGbDjM3zl9asterXDhsZBRD8iAAgXQIYIBOh2tLtnr99dcHcl966aUl+dva2szf/va30jUnfgKKg6WdgbMai8wdeZTxWfdXdvWUQna45XXuU6LC5bJ27Ru3Lz9r42c8EIAABCAAgUoJoNNVSozyEIBAmgTC3q82hrEMij97MP24xWnK5ra9qqu3dKkwhlEGWmt8LxXM8YlkSZI0/1Es3LpyeJr7+LLSBoeqIw9pa6S2ZVVOXuLW0G/zOUIAAukTwACdPuOW6eGZZ55pGVnTENT+COozorwmfRbmU4qkROUx+ZS/vMqTxzlgzBCAAAQg0FgC6HSN5U1vEIBAPIEo71dbo5xHsC2Xh6O7vpBzkhsDWuNXSAl5+RbF49u+SIibG/vyIa6Mvec6COmZCRufbTl5iatdu/62+RwhAIF0CSiGPQkCdSHQ3d1trrzySnPCCScEf1dddZVRHikZAf0I6ocy78luVujKkefdhqX8afxuyrM8rhycQwACEIAABKIIoNNFUSEPAhBoFgHXsNisMTSi31VdPYFhVH3JOHrx5HFBfGP5CSvOsa4nbL9JsBFhufEM7UjmXVyunbTvaw0cl+JePoTruQb8cs9MEdbdYfm5hkDWCWCAzvoM5Wh82oDwkUceMZ/5zGeCP52zKWGyCbRvdst9WpSsteaWssqRjq6yVO83zGJ24Iz7zQ7T5gTHcspLtVR8yl+95al2fNSDAAQgAAEI1JsAOl29idIeBCBQCwHXsFhLO1mvK89cfQ2799fuLXnozpt2qLls6vhg6AopcfYti8zgnXgGSqaNCrt6ff6/A8s2+6qcIbicIdmOP+wgVO6ZSdqubZ8jBCBQOwFCcNTOkBbeIvDwww+bRYsWlXgceuihZq+99ipdc+InUMmbXX8rjb8jA7Or2tgffhlnwwZaGYglp37spRDIszhcJqkE1mCvGF5KMtynuaFElDxJx0o5CEAAAhCAQN4IoNPlbcYYLwSKTSAqHEWRJZYh2q5tJKcbiqNc2IpRwzvNilX5+QrZZwi2a0d3rembczk+hdeW5Z6ZcgZqX1/kQwAC1RPAAF09O2qGCHR0dJinn37a7LTTTsEdbT6oPFJ5Ar4f3vI1m1dCxubwTsP2h98qDNbYPHG30cHOxPUyGEcZ7NW28qs1ajePJD1DAAIQgAAEskUAnS5b88FoINDqBKx+n+e9ciqdQ61t/uOWhabSGNcyXucpyRDsrh03HtZpunv7zEpnQ8Y4eeQQZdegbjn7zGjDwTCTzva2oI5bnnMIQCB9Ahig02fcMj1ceumlZuLEiWbHHXc0/f395tlnnzXXXXddIvlXrFhhPv7xj5s//elPpq2tzfzoRz8yu+66q5k6dapZsmSJGTNmjLnlllvMqFGjErWXt0L64c1T+I2RwzrN9EljI429Ud7JN85fOsBTWvNTi8HYZ7D35efteWC8EIAABCAAgWYSqEWna+a46RsCECguARkU5WySZM2kEBQKgdxdLlZFxnFVanzOuDiDhqd4sGM2HWYUWsR6Oq9YXZkBXfV8TkjWCH32rYtMrwMz54/FII5kQCAvBDBAhh1o9QAAIABJREFU52WmcjDOww47zDz11FPmiSeeCAzQu+22m1lvvfUSjfwLX/iCOeKII8xtt91murq6zKpVq8w3vvENozanTZtmZsyYEfxdcsklidrLW6FynwhlTZ43e9b9bLtvrGVIX/lmT2BcdsdsFQo3T+fVGox9BnvlkyAAAQhAAAIQqI1ALTpdbT1TGwIQgICfQNSaSd6sG6w/JAg7Ie/ZtjYTnK8N1OdvizvNJ9A5pN3Me3p5zQPRSwmtSa3B2W1QHtCu8Vn3dP3lOx6rW3hItz/OIQABP4G2frmqkiBQA4EbbrghMDifcsopA1r54Q9/aEaMGGE+9KEPDcgPX7z22mtBrGiF7JD3s03ygH7ggQfMlltuaV544QVzyCGHBMZtez/qOGHCBLNgwYKoW5nPO//Ox8wN85dmfpx2gIq1pdAaUd7Ntky5o2KU/fGrh5crNuh+2MtaBRQSRDtDRykegxogAwIQgAAEcksgz7/1WYdei07HvGR9dhkfBIpBIOz8YsMvRK0PiiExUiQh4L6IkFOSfS7GTJuTpDpryUSUjOG3PiEoikUSwAM6EguZlRD49re/bX77298OqqLwGQrJUc4ALcPz6NGjzWmnnRZsYrjvvvuaK664wrz44ouB8VkNywj90ksvDeqjSBk/X/RCrsTRm+ZaDebVvv6yRmZ9bmXjTFslI1cQGSwEIAABCEAgQwRq1ekyJApDgQAECkpA6wC7FnBF1LrA7jfj5nPeGgS6+/pLsZ61TnU3cUxCoJbwkEnapwwEIGAMBmiegpoJ9Pb2mg033HBQOxtttJHp7i4fw6mnp8f84Q9/MN/97nfN/vvvbxSOQyE3kqZrrrnG6E9p2bJlSatlrlyl8a4yJ0AVA3q1whhfbhc+5dMtwzkEIAABCEAAAskJVKrTFUUHS06IkhCAQFYJVBvaL6vyMK7aCFiDsvYuSrrO5hmqjTm1IVCOgOK+kyBQEwEZmVeuXDmojddffz2I5zzoRihjm222MfqT8VnphBNOCAzSm2++eRB6Q3kKwbHZZpuFaq69PP3004OwGwq9IU9qUvMJKLSGQnQooIqOuo5KxGyOokIeBCAAAQhAoDkEKtXp0MGaM0/0CgEIDCbAumIwk1bPkSf0UXttaZIavXiGWv2JQf60CST9t5j2OGg/xwQ+9rGPBUbjJUuWlKTQ+Qc/+EGje+XSFltsYbbddttSfOf77rvP7L777mbSpEnm+uuvD6rreMwxx5RrKtf3fUbaPAr1yqq1nu+XTR1v5k071Fxw9NggrpYri2I2K2wGCQIQgAAEIACBbBCoVafLhhSMAgIQaEUCWldofUGCgEtg5kPPmWFDyz8XcpxibeqS4xwC9SdACI76M225Fs855xyzwQYbmIMPPti88cYbwUaC2nxw2rRp5tOf/nQiHgq/cfLJJwce0zvuuKO57rrrTF9fnznxxBPNtddea7bbbjtz6623Jmorr4VkpD1z5sK8Dn/QuPXG+ayZC82CZ5ebi44dF9wnZvMgTGRAAAIQgAAEMkOgHjpdZoRhIBCAQEsRsHGh7Xqjv6Wkb01hO9raTF9/v9k4JsyGYkN3d/WWBaTnxT5Dvo0uyzZCAQhAIJZAW39/tduAxbbLzRYlIAO0HqmomNCNQJL3XVmT7tLbCJb16kNvk08+YDsz9/FlwYaBUhDa2oxZsarbuDsU16s/2oEABCAAgWITyPtvfV5mp1KdjnnJy8wyTgi0BoEirqtaY+aSSdnZ3mYunbJXyWhcj/lW6MiJu402tz/y/IANLeVZf/HkcaW+ko2wmKX4rS/mvDZKKjygG0W6RfqRJzSpegJ6i9ubw3dC+rGWx3NU0tvkG+cvNdYLwd0Ewt2h2L5xjmqDPAhAAAIQgAAEGksAna6xvOkNAhCojEA5L9VKNp+rrGdKZ4HA0CHtJYPw+Xc+VpchaW3qrltto9rQUF8qy7teYTpYt1oyHCFQGQFiQFfGi9IQSJXASftvm2r7aTRuYznLCO1L1vgcdd/uUBx1jzwIQAACEIAABCAAAQhAAAIuARmfz5v1WOAAo3WGdWpRvk3TJ4018pIlFZPAyrfCamjOb5i/tG5Cxq1bo56zunVMQxBoAQIYoFtgkhExPwQUK3l4Z77+WcqAfPYti7we0Eno/8PjPZ2kLmUgAAEIQAACEIAABCAAgdYhIE9UrUHcFHZqkZeqQjTUmoZ1tptdNhtRazPUT4mAnoVqkjzkq0nh56yaNqgDgVYlQAiOVp35FOSeNWvWoFY33nhjM27cOLPZZpsNukfGYAJ6g7teZ4dZ1d03+GaGc+LChsjvIO5NssRSLGgSBCAAAQhAAALZIIBOl415YBQQgEA0AZ/zSjg/MEL/8omqHWU6O9rMxZP3DEIuKMzDTQ8+l8twidEU85+rtbO8kitN8oxf2dXjrVZu/ao+D5xxP+E4vAS5AYFoAhigo7mQWwWBa6+91vz+9783EydODGo/8MAD5oADDjBPPvmk+epXv2pOOeWUKlptnSr6AdWnZOG3+XkkYHcklmE5aiMHVyYbwsPN4xwCEIAABCAAgeYRQKdrHnt6hkBaBLTWkLeojLRZ3wi83Fg1/ijDY5RTi2L2VrPGUvSOS09Yt8mdvlSdsP0mJYbyjM6b01Baz1az2j1r5sJgc/tKt1Dq7vO7R2ltus2o9c1TL62MFcuG41AhYkLHouImBEoEMECXUHBSK4H29nbzl7/8xWy++eZBUy+++KL59Kc/bR588EFz0EEHYYAuA/jCuxcXwvgsMeURvWTGkSWJrbKmH2r3jfKo4Z3mgqPH8qNdIsUJBCAAAQhAoPkE0OmaPweMAAL1JBB2dJFOLuOdNlbTPi5Z2lgtaqwyICtZQ5/PqLyqq8eovi1n6yx4dnlFcYLlIavwHWrHGsPD6xiMz/V8QqtrKzAj+23JVTV68eRxwb+NJJVtOA73eUtSjzIQaFUC+Qo226qzlBO5lyxZUjI+a8gKuyHv50022cR0dlYXYyknotc8TCk2r6zqrrmdrDQgD2g36UdZiqLeKLs6wpqchRpxZeIcAhCAAAQgUFQC6HRFnVnkalUCUTGTrU5uPTm1HslCihqrNfTZ8WltIUNhOI6v1lMyVodlmfv4Mls10dE1Pqs9MVKyzBI1QqHcEdDLGD1blcxzOOxLEqH1fCqExw7T5gTH8POapA3KQCCPBPCAzuOsZXTM7373u81RRx1lpkyZEozw9ttvDzyfV65caUaOHJnRUWdjWNVunpCN0Q8eRVRM6DhlkrfGgxmSAwEIQAACEGgWAXS6ZpGnXwikQ6CckcwaeLOgk/vGGs7XWLW+WLF6oBNPlCzhunGUrRFSZaLWL3F1q7mnL0JfXd1tYqJCVNMsdSokUG1YyKiwL3Fdy9jshoSxL4BUp9Z/f2pbz6ye96yH2YljxL3iEsAAXdy5bbhk3/ve94yMzvPmzTP9/f3mIx/5iDn++ONNW1ubmTt3bsPHk6cOK1GK8iCXFLdw8snoyw/X5xoCEIAABCAAgcYQQKdrDGd6gUCjCPhiJrv9Z0Un9401ytDnG3M439emK78911ebNoXbsfn1OmqTQ8UvxvhcL6LVtRMOQzNiaIdZ2dVbtrFqjNZRLzWiXpqU7TxUIE3DdqgrLiFQNQEM0FWjo2KYgAzNJ5xwQvAXvsd1PIFKlKL4lrJx11Xc7Ih8MkYpk7aOjrzJdWlwDgEIQAACEEifADpd+ozpAQKNJOCLmeyOYeTwzkzo3VFj9Rn6kq4vtCn6DfOXuuJ6z10vVF/73soJbsjjecWqbiPeb6zpGeTBnaAJitSRgOZj3rRDB7T4X8eNC+KjD8h860KhJvv6+6v2MPa91PDlR40hKi8tw3ZUX+RBoFoCxICulhz1BhGYNWuW2WWXXczGG29sNtpoI7PhhhsGx0EFyRhEQIqWFKsiJP2Iu4qblSlKRp8yaevYN7n6NEmxuOwnSsonQQACEIAABCCQDgF0unS40ioEmkVAurliJkd9pWjHtKa7NwgN0Gy92x2rdpXRmDX2atYXWjOMv/DexMbncEzpqPWL5VXNUdvkyPhsHXC6cX2uBmNd6yhueDges561Dx+wnRm4q5EJ1uvfPnEv88yMIwOjddQzWW5wdu7D5Xz54XK+a58B25fva4d8CKRJAA/oNOm2WNtf/OIXzd13323e8Y53tJjktYtrf7xszKZKNj6ovff6tnDB0WMjGwzLqB9ZKXU2P6oSb3KjqJAHAQhAAAIQSJcAOl26fGkdAo0icP6dj5mbHnzOaH8WeW6etP+25sb5SyM3WVsdsTl4PUIDVCOr1gdxawTbpi1j11Du+sI6skiGJKmzvc1MnzRwHWPbv/DuxYM2jJdxstI1m8JtKMnIT8oOATsf1tlJI7vo2HFmwvab1D2msta/bgxo9aVnSX3LEF5ufeyjpmffyuGWqdWw7bbFOQRqJYABulaC1C8R2HzzzTE+l2hUfuIqWmOmzam8gYzUsIpa1HBcGaPuh/N8b2x9+eH6XEMAAhCAAAQgUDkBdLrKmVEDAlkjIOOzG3ZCRmhdD+tsN1HGZt/4s6x3y8gcZXyWLFGOLD4Zg/JT9oo0emv9orbkKesm2ZL15afCaODJ7JLJ97n70qXStWsSye1aWc+UDMbuiwzXAG7LJWlTZaIM2+W+Nk7aNuUgUC8CGKDrRZJ2zIQJE8zUqVPNsccea9Zbb70SkcmTJ5fOOUlGoFLFMFmr6ZdqD3+nFNFlnKIYLs6b3DARriEAAQhAAALpE0CnS58xPUAgCYFK9OZwe/J8jkpv9vRFZXvzsupBGfZwDhvvKjGcK8xHnMHP15bCaVw2dbw5b9ajFRn1vbCNMZ3txkQ4o8dV4V6dCehZ2um8/w2+GJAndFSq5d+mNWzL41l9uck1gLv55c7t8+t7IVOuPvch0AgCGKAbQblF+njttdfM8OHDzb333luSWJvYYIAu4Uh8cvy+2wzwWEhcsckFy4Ux8ymKC55dbuY+vsxIuZOSaz894k1ukyeU7iEAAQhAoCUJoNO15LQjdMYI+PRmDdMam+KGLI/nqFROX3fryLdE+ngWU5SHs2u88zmyhGVJ4iXqa2udcT6BF064Y881xmcPmAZn2y8G1K01Qlujs4zGlXou27ruetf3YsOXXw6BNWyXK8d9CDSLAAboZpEvYL/XXXddAaVqjkgyxhYx+RRFNxZd2HtBHHiTW8SnAZkgAAEIQCCrBNDpsjozjKuVCPj0ZuUnMUAr5rPPCJ2Uo0zYSfpK2l49y/mMdDY/ypFF/Q/vbDfrdXYEmwGOHN5pZKc/a+bCYL1hnWBUTgbD6bMXmxWrB4besDJYw3XUPNky7tE1WLr5nGebgNapigUdjgMefr3jvvwIS+R7mbTxsM7I52vdi41wS1xDIN8EMEDne/4yMfpvfvObRpvVnHHGGUYez+F05ZVXhrO4LkPAKk5limXudnjn6PAAfXLF/YDzJjdMkWsIQAACEIBAOgTQ6dLhSqsQqIaAT2/25Yf70IaDbgzo8P0k14pxnNVUzitZawh9ZRnehNH1ZnU3g3OdYCTzubcu8sZ2FhdtvK4+ZLwul2SsPn7frYMvPsMhF8rVbdX7He1tprcSd/2UQGmd6j4ncd34/m1GvaSQwXr9znajZ0PnNtkXG/aaIwSKRAADdJFms0myvOMd7wh6VrxAUn0I+BSq+rSeXivyEIjbvbcSuXw/4OmNnpYhAAEIQAACrU0Ana615x/ps0XApzcrP0myhlbXACuD18qudcaucu286RjGypVt9P0oD2fXeCev09sfeb7kBS5vcF3Lm1WGY59RUPlKcRsLakNCW843T5aH4ku7ntVRcX9tWY5rCcipaeWbPSb5k5ouOddAHNeT79+mb11rY4jrWVIZ1Xeflbi+uAeBPBLAAJ3HWcvYmI8++uhgRKeeemrGRpbf4UQpVHmRxvUekHLnpii5fJ+j+X7A3fY4hwAEIAABCECgfgTQ6erHkpYgUCuBKL3ZNbAmaV9GaGuIVvkx0+YkqVYqsyrDAYntOsNnvFN+2HCoa4VSUF2fJ7LPWFiC8taJXfPIs9kNJ+iWk6f0vGmHlrJkFJdhlbSOQLsxxt0WU8+4PqqOewGwrnZ2zuL+bfpeUihfz6J9lrMjDSOBQDoEMECnw7WlWtViJSr0hoUwe/Zse8oxIQH7IyTFyaccJWyqKcWk3GnsVg47CHvtKooTdxsdeCO4CmLcD7htiyMEIAABCEAAAvUlgE5XX560BoFaCETpzbV4R8r46XP8qGWcadXVeN01Q5TsYmQ5hcfhMyTLe/n8Ox8LFy9dWyeYJGswrV+0d8/JB2wXGe7kjTU9QSxpjVHyJA3lUBpMC5zIK3/UiPUGeACfmSCsSaPQyBju2c9zwBAunjzO+yzW42XSgM64gEBOCWCAzunEZWnY55xzTpaGU5ixWIVKykqWfoSTAvYpfVYutx19CldOwXTLcw4BCEAAAhCAQP0JoNPVnyktQqAWAlF6c6XtWUNuEoNquO1y+7uEy9frOmystd7Gal9MkiSf16nqymPZl2QsVIqLAe3W1ZpHXuY/X/TCoA3l5MVrnXJ0dB1u3DZa+Vxe9n92vMTF4uxbFpVCpzSbjYzPco6KmzuFWYl7Lu091rvNnk36bzYBDNDNnoEC9H/wwQeXpOjq6jKPP/544BG96667mqFDh5bucVIdAf1g/cctC00G9mCoSADt6ps0SUb7w5y0DuUaT8AuYKRoS6mP8kRp/KjoEQIQgAAE6kUAna5eJGkHAs0nIL1N4Sbk8VtN6mxvM9Mnja2mas11ooy1MgBaY26SDqSn+px4whugu+1ZI+HI4Z1mTXevWV0mDIn1mH51dTRn65Rjj25fnEcTULzurCQbw1vPhV6EhL8iSPrlLuvdrMwo42gmAQzQzaRfsL7nzJljPvWpT5mddtrJ9Pf3m2eeecZcffXV5v3vf3/BJG28OHkzPouQPlciFYdAPTxRikMDSSAAAQgUmwA6XbHnF+mKTyCst1UqcUdbm7l0yl5NcxDxGWt9+ZXKF1feeorLcC/jorzAtdG6L1mPaZ/HtTVQ++772m2VfMXJDicZfe08hO+ldd3+lmU5HI/aOtxYZykcctKaAdptBQIYoFthlhsk49lnn23mzp1rdt5556DHp59+2hx55JEYoOvAvxk/wkmGrXFJEYx6R61dfUnFIVAPT5Ti0EASCEAAAsUmgE5X7PlFuuITiNLbKpH6pP23bZrxWeP0GWutMTeJLGIQlayPTNT6JVxeXteKURz2erXlZDy1hkkZKsMxnl3vWN0/a+bCyHWTba8VjxccPdjLPoplGmw0f3/86uGlpn3GZV9+qSInEIBAIgLadJQEgboQ2GyzzUrGZzW44447GuWRaiegH2EpMFlKUsQ0Lp8i6MvPkgyMJTkBn8eJLz95y5SEAAQgAIGsEUCny9qMMB4IVEagVv1MG+vFJRnkDpxxv9lh2pzgqOt6pqi1j2vMTdKXj4EMz0mMz7YPOdVok8Fw6uxoM2HjqYzVNslz2t2YTobqSvq17RT5OKyzvWTAd+UUK7GTs5OSPPLTSGGHKfU7b9qh5pkZRwZHXevZ1osFeWRr/nTUdb2f+TTko00IZI0AHtBZm5Ecj2fs2LHmAx/4gDnxxBODGNC33nqr2W+//cysWbMCqSZPnpxj6Zo7dP34KdnYU80dzdre9QNsxxV+268SK99ct+tzFsbLGGojUA9PlNpGQG0IQAACEGgUgazpdFroSweSQUm/RzJOWR2kUUzoBwJZIhD+NzFxt9FGRmP7b0R7scSFjSgni894q3rWIGc3ZbMGOd2r179L204t/+59uquMmlqnJOWjdrRh+syHnjPaVLCUnNMwE5V5s8cN5rC2Vla/ai3J1OCTnr7+4Hmy8+12r7xw/phpc9wiNZ9rbsslPYP2WbdlK41HbutxhECrE1j3iq7VSSB/zQTWrFljNt98c/Ob3/zGPPDAA2b06NFm+fLl5u677zY///nPa26/1RvQD7DeyC6ZcWQmUNg30hqX3lCH43dJqePtcCamqi6DqIcnSl0GQiMQgAAEIJA6gSzpdNawg/dZ6tNOBzkhEPVv4ob5Swd4aK7s6jHaRLDaFLeZeJxBLml/kqGcB7Vd+7jeqEnbV7ko3VX5y1e+aV5/s2dQUzKMyKvZTdbrWjIPMD4bE1wrXykpE42plnlxx5blc60Lk3y9293bH2wUqWdBz0S5FF5v2vLVPOp2bm0bvqPvZYwv39cO+RCAgDF4QPMU1I3AddddV7e2aCj7BKRA2SQFUYpXeJdt3g5bQvk/ao6VNM/Wu0bPgM3Pv4RIAAEIQAAClkCWdLo4ww6/QXbGOLYSgah/E2H5ZdiTsS6sm4fL+a7jIh74DG++/HAf1oBuvUrT8KBWn/b/DxfevXgAh9Xdgz2TVX7j4Z1BSI0oXffMmQvDYgTXVmZ7DBdSvuR125z6zm2NXhgUOSm0xWVTxw+QW/PsS0mfAYU8Ofe2RUbPt016aeBe2/zwUf8e+vuNeXV1d0Vf0vg86ZN4T4fHwDUEWp0ABuhWfwLqKP9pp50WhN4IN/mjH/0onMV1AQhYpc6KEqd42TIc801Acx6e93xLxOghAAEIQCCKQJZ0OvSLqBkir5UJ+P5NhJmE49uG78ddx9Wt1SAXZUBPy2lFeqv6S2KIl8xRuq4MyPKLXmfyXEfOGiF9TFTH3XhQhtbbHynv6buuh3yeiUeY5d5fuzd2HpI8A3Yd4hr05RCja5+BW4Znd6PBSomq/XC4yaTe05X2RXkIFJ0ABuiiz3AD5TvqqKNKvenTzTvuuMNstdVWpTxO6kfApwTVr4f4lqI+f/IpXlYxi2+RuxCAAAQgAAEIZIVAlnQ69IusPBWMIysEfP8mwuNTuUpiHbv14/T3Wg1yPgO6DIgKxaD76r/cl3Zhz+JwHGzVV/IZJl15de6TWcbNKOOz1mO2jygmtv1wXev5be/n6ZhkDeozzsr7uFzyPRtuvbBh297zeanHvUyxdeOOPqO3zY+ryz0IQGAgAQzQA3lwVQOB448/fkDtk046ybznPe8ZkMdFfQhoJ+Zmfrr1xprBGwxGKV5SUqQMkiAAAQhAAAIQyA+BLOl0UfqFz8CRH8KMFALVE4j6NxFuzf034jPMhevYa7euzXOP1vAW9kK1+W7ZqHMZeqOMwlo32Hwd5XWqFNVuVBgPd22k+grVEGk5jhiUwjiIa1TyGUVlT7Vj03HBs8vNjfOXJu0yqqvM50nmDx+wXeDF7RrSrWFaewSJo+XiCpRk00ffSwC3nahz9Td99uLIjSWrbdPtR+1HyeSW4RwCEChPgE0IyzOiRJUEnnrqKbN0abHjW1WJpuZqFx07znQ28V+vNuGQ0ukm/Sgfv+/WwSdqNl9Kij4zk5JIgkAjCeiZK7e5TSPHQ18QgAAE8kygmTqd9AttdizDhowcOuoaY0CenyjGXguBqH8TMgpG/Ru5dUFlazF95Zjk35fGoM3Rq9kgUAZKGbndZA2Ybp4NyeDm2XOtQ1wDqM13j4oLHN440L3vnqus2oxas/gMmOLtprmPLyu08dnKKjnD/09WvOclM44Mnomo/zeLq+Y4LpV78RFXV/emTxo76Lmqtc1yfXIfAhCojAAe0JXxonQMgQ033DCIAd3f3x8ct9hiC3PJJZfE1OBWLQR6ovfPqKXJiurKs2CHaXMGfCIXpXhZ5TFKGamoQwpDICEBKblurLZyXjQJm6UYBCAAgZYhkDWdTjoEekTLPH4ImoBAkn8T0ofmPb08QWvrimiTt7T/rdn2XQ9q6WpRyed97MuPaiNpnk9fjPI4jzJspjGmpGNvZDnJmeT5c8ekuY6LwCFjvs9z2m0n7jzquaq1zbj+uAcBCFROAAN05cyo4SHw+uuve+6QnQYB3+drafTla1OKhKus+RQvX76vXfIhUAuBKK8YXoTUQpS6EIBAqxFAp2u1GUfePBKQgdk14oaNbbpXaYoLe1FpW3HlwwZMfbUWZYT2eR+ntQ6K0heTGjbTGlMcx2bc881J3Fji1oLynK5XCj9X9WqXdiAAgfoQwABdH4608haB2bNnm9/+9rfB1SGHHGLcTWyAVF8CUjIrjelW3xGsa80qaz7FqxpFZV3rnEGgMgI+JdeXX1nrlIYABCDQGgTQ6VpjnpEynwTKfe2l+1EG3XLSWp3eGl3Lla/Xfa1r3K/X1G6Ul7HtL6q8vVfrMUpf9Bk27UsAsW4rF2Oi1oFloH7cnMQNz7dGDIcxiWuDexCAQP4JYIDO/xxmRoJp06aZhx9+2Jx88snBmK644gozb948c/HFF2dmjEUaiBShC+9ebF5Z1Z0JsaR4HbjTJmb5yq4BMdmqVVQyIRSDyCUBn5LLi5BcTieDhgAEmkAAna4J0OkSAhEErIFTRlHpMdbLOe5rLzVjPZkjmiybFWWALVupxgLW4B3n0e12ofLa9O+mB58zvf1xwR3W1YqKM73u7rqzcvqinZPA6GzW7XOYcBjrOsrZWUdbW7Dfj+borJkLBzyP5USJemHAGrEcNe5DoHgE2voVsJcEgToQ2HPPPc3ChQtNe/va3fF6e3vN3nvvbR599NE6tJ6siQkTJpgFCxYkK1yAUlKAwt4CzRZLRugl/1ptwopys8dF/61DIOrfhZTcJJvqtA4lJIVAfgm02m99M2aqGp2OeWnGTNFnkQnE6TMyAEYt4mVk9b2IT8pKXqnaYDDLKYqNb7xWHtVxDdwTdxsdbJYur2+byumLlfRr2yzSUXwq4eXKHuZvX6a4ZTjPPgF+67M/R1keIR7QWZ6dHI5txYoVZpNNNglG/uqrryaWYMyYMUYb3nR0dJghQ4YERuTly5ebqVOnmiVLlhjdv+WWW8yoUaMSt9kKBV1vgWo+s0uD0fy/vWKevvgDaTRNmxBIRMD9d8GLkETIKARHfq7tAAAgAElEQVQBCEBgEIFqdbpBDZEBAQhURSDOy9lnZPblJx1AXrxSo9hEySiDvAydStIPrY5oy07YfpMBRulyRtGk/dr283gc3tluVnVH73bvGp8lWyUhW6L455EPY4YABKongAG6enbUDBE477zzAo/niRMnGjnWKxZ0JeE35s6da972treVWp0xY4Y57LDDjD4D1bn+LrnkktJ9TtYScH/Md5g2J9IbopGskn4G18gx0VfrEXD/XbSe9EgMAQhAoDYCtep0tfVObQhAQAR8ziV6uX7Z1PGDvoK0xuOzb1mUOCzFqOGdZvjQIbn7cjFpmBB5iYeNzu7TVam+mLRft4+8nXf39pvOjjajY5LUCkyScKAMBCBQngAG6PKMKJGQwEknnWS08aDiQMsALWPxFltskbD24GJ33XWXeeCBB4Ibp556atA2BujBnGyOPmtKpibYGukcFR+MBAEIQAACEIBAfgnUW6fLLwlGDoHmEJBe74tZ3P6Wrq3QYvLIlaFa+rf1Rk3qDCIj4wVHj4010DZH+uhe3RAOYpBUTjnoyDPc9W522wrfi+59bW6tHuZxbWflXndfvxk5rNO8vqYnEWMxIUEAAhBIQgADdBJKlIkl8Mtf/tK8/vrr5oQTTjBbbrmlmTRpUlD+xhtvNJtttpl573vfG1tfN9va2szhhx8eHD/5yU+a008/3bz44otBe7qvdl966aWy7bRyASmgWUhv26AzC8NgDBCAAAQgAAEIVEigHjpdhV1SHAItTcBnCJVe73MskeFVe8DIAC2jqrsfjM9rOgryiKFDcmV8duVManyW3OIoLqpvk9uWe8/nLW3nSWV9LwZs20U4vro62Sb31uu+CDIjAwQgkD4BDNDpMy58DxdccIG5++67B8mp8BnHHXdcIgP0vHnzzFZbbRUYmWWw3m233Qa158u45pprjP6Uli1b5itW+PysfP704utd5vw7HzMXHTuu8MwREAIQgAAEIFAkApXqdOhgRZp9ZGk0ARk1fYbQcoZk6+2sMYfj8iaVI6mRMWl7aZbzxV6W53dSY7Q4XXj3YvPa6sGevZZnlAE6PE/uiwH1f8COo8y8p5enKX7D27ZezXHPoTZ3dL3KGz5IOoQABHJHoD13I2bAmSOwatUqM3r06EHjUviNlStXDsqPypDxWUke0zJaP/TQQ2bzzTc3L7zwQpCvo+5FJXlLL1iwIPiLGkdUnSLmWUUhC7Ld9OBzWRgGY4AABCAAAQhAoAIClep06GAVwKUoBEIEooyq1hDaniCinZxPanFAydLaIYRm0KXPECrj8+VTxw8q78t4ZVW312DtYxk1T7Z99f+Hpa+aYZ35NauEHzXr1SzjssK0hFNne1vAfN60Q3PjQR+WgWsIQKA5BPL7f8rm8KLXCAJr1qwxPT09g+50d3eb1atXD8oPZ8hIrRAeSjq/9957zR577BGE8rj++uuDfB2POeaYcFWuHQJSEqQwZCGV80SQJ8GBM+43ismmo65JEIAABCAAAQg0l0CtOl1zR0/vEMgXAZ9RVfl9rputRywZkKs1IsuwqLVDXlLcHjMyENcj+Vj6DNO2T700WN3dZy9zd3zXTpsYeTPL1KyjQrvYzRkvPWEvo40qbVJs6Eun7IXh2QLhCAEIVESAEBwV4aJwFIHJkyebT3ziE+aqq64yI0aMCIrIkPz5z3/e6F65pFjP8npWkiH7Qx/6kDniiCPMfvvtZ0488URz7bXXmu22287ceuut5Zpq6fv2kzEpYVKUNh7WaVYkjN9Vb3Bx+xCGP2OTkm1jslkZ6j0e2oMABCAAAQhAoDyBWnW68j1QAgKtSUD6r9XRZeicuNtobyxheT+XM0C7BmQ3jIfoyiHl+H23NnMefcHI4zecZFDM0+aDGn+cc4vPkB+WO+7aev1GlRk5vDOSY1TZPObJg9sancPjt4bocD7XEIAABKohgAG6GmrUGUDgoosuMueff77Zfvvtgz/dXLp0qfnYxz5mvv71rw8oG3Wx4447mkWLFg26temmm5r77rtvUD4ZfgJhJUGxmG+Yv9RfIaU7w4b4P66I+ozNfm6IATqlCaFZCEAAAhCAQAICtep0CbqgCARajkCU88WN85d6NxksZ3wWwPAGgq5x28blLdJ+LPLMrYehOerhk3e1zwCr8v0JvNGj2s1LntZh02cvHvCCxD5DeZGBcUIAAvkggAE6H/OU6VEOGTLEzJgxw2jjmr/+9a/BWHfeeWczbNiwTI+7FQYnxfP2R/7e8M/C4j5D833G5stvhXlCRghAAAIQgEAWCKDTZWEWGEPRCEQ5X9Rq03Q3EAw7oBSNn+SRQTTs6V2pnAof8WZP34BNG+X5HGd8Vh8u60r7TLu8ZNL49OWrvkBdsarb+2Ijbiz6atZ+OcvXqXGkuAcBCNRCAAN0LfSoO4CADM7jxo0bkMdF8wlcPHlPc+bMhQ0dSHtbWxDXOcqjWZ8dRnkw+OKuNXTgdAYBCEAAAhCAQOBEgE7HgwCB+hBIw8mi1fRmu6aQMT9qHVFuprRx3vRJY4NiUd7icfV9a5e4Oo24J69wbQQYTtpfpxpGbjt8nerS4BwCEKgXAQzQ9SJJOxDIKAEpbI02QCtO21kzF5oFzy434c//ojwY4uKuZRQrw4IABCAAAQhAAAIQgEBZAmkYMGVglKGxaKESwrGyXfmsp7fKVLq22WD9IaWN86wxu+zEvVUgau2StG5a5WRQ17iUwszGbDos2A+oVi/7NF6cpMWDdiEAgXwQwACdj3nK/Cj7+/vN3//+d7PttttmfqytMkBXGWmGzFJ6bPxp1whtlb5KvQ+aIQN9QgACEIAABFqNADpdq8048qZNIMqAKecLbTa4squ36u5lhC7SRt5au7hhNnzyaS2hmMU2ZEQSgApNoeSuj/RiwDVw+9px1y61ehb7+qg0v10e3bMXB4b4NsWpfqsBjS/JGBX3uq+/34jBqq6eyE0WdY8EAQhAoJ4E/DuF1bMX2io8gba2NnPssccWXs68CGgVOCkgViFp1thlhNZ43CRFTp+MPTPjyOBoFTu3DOcQgAAEIAABCDSeADpd45nTY7EISO+Vd/IO0+YER0mnOMMKmSBjoeL2rt/ZHhifde0mGaYrSTZUQiV1slo2Kla2Tz6F06iElYyp4fWR1kkyeIfXKWE+un/h3YsTGXbDddO6Vixra4CvZq0n47Ndh11w9GCWfJ2a1szRLgRamwAG6Nae/7pKf8ABB5iHH364rm3SWHUEohS46lqqTy29oSdBAAIQgAAEIJAPAuh0+ZgnRpk9AjJWnnvbosBYKcOgjJy6VpLzxWVTxwcb4b3ylkeuylgjtAzUMlSPGt5ZkWB5D5UgZnFxi6Pkk/OKNeqXg2WNqVHrI5+B27Zp59POl83P+9H1bnZZ6lm0zyEOQnmfZcYPgewRIARH9uYktyOaO3euufrqq832229vRowYYfQJp7xoHn300dzKlNeBRylqzZTFvqFv5hgq7VsKJ2FCKqVGeQhAAAIQKAIBdLoizCIyNIPAl+94zHT3DvRJ1bU8aGXQizKCqrTdUE76Z6XGTteY2AyZa+lT8rphN6LaipLP1dPlUR631pChWuy1P01Uils3ab7C8xnVRp7yrEHeHbP4YHB2iXAOAQikQQADdBpUW7TNe+65p0Ulz57YUtSSxP9q5MilKDZDsXEVVHFJEustrAzbT/TEqxkyNHKe6AsCEIAABCCATsczAIHKCUh/9MV0tkZln7HT5lf61WCUMbHykTevRpRB3h1NlHxhPT3O+CzDvtXdfeujsIHbXTsMfJXgjixf5zLSv7q6O4j5nGQtlC/pGC0EIJAXAhig8zJTORinPJ+VXnrpJbNmzZocjLi4Q4za7KTZ0p5769rPD60S2IjxhBXUpIbkKGXYfqLXyPE3ghF9QAACEIAABMIE0OnCRLiGQHkC0h/LpXJG0Dhjqm1bRlUZrJM6Vth6WTxaw3vU2LRRntW/dd/q4FF6uu4rfIRrMA4br6PWR6qj9YFCgOi+UjmP7KBQTv4j+U4+YDvjbgifk6EzTAhAoIAEiAFdwEltlkizZ882u+yyi9lhhx3MwQcfbMaMGWPe//73N2s4Ld2vFDR9bibFLSupu68/2K25keOJUlBdRdY3Fp8y7Mv3tUM+BCAAAQhAII8E0OnyOGuMudkE4vREeaAqycgpw6ibwoZS91743IbqsBvIWaNsuFxersPex+64e/vXmpNlIJYjixxLlHycVVqctfoRJxt6w7Zp10e6p6Ry1mBtnVTkga61QlZStSs51VMs8Y2HdZob5y8NDOyWX1ZkYxwQgEDrEcAA3XpznprEX/nKV8z8+fPN29/+dvPMM8+Y++67zxx44IGp9UfD8QSkZGmH4ywleXW4u4KnrQj5FFRfvmXlU4Z9+bYeRwhAAAIQgEARCKDTFWEWkaHRBOL0xKP22jIYjmsEjTKUxvmOdHa0lbx0Gy1bWv1FGeSj+nIdWeI4v9nTF2z0qA0fo4zzytM9GaHDqyQZnpN4oEeNL6289TsrN9dINm12uaa7L5BHcloDe9prr7Q40C4EIFAMAoTgKMY8ZkKKzs5Os+mmm5q+vr7gb+LEieZLX/pSJsbWqoMYObwzciOT9jZj+sJaV4MgSQFSsorQgmeXm7mPL6vLp4RSquT1LAOzlFO99Y9SJOMUV40t6hO9SrxTGoSSbiAAAQhAAAKpEECnSwUrjRacQJT+aEW+/ZHnzYTtNwmMojKCRhlHVTbOd+TSE/by1rP95O1oObj6u10rhGWxOn0cZ/ulo21XbYTXB6pfzhkl3Hezrld391XUtV2v+L4ClYe3y6aixikMAQhAoEYCGKBrBEj1dQRGjhxp3njjDXPQQQeZk08+2Wy22WZmyBAesXWEGn/mU2I3Wr/TjFhvSNM3KpSSqM/CrC1cCqd2qJZRutJYZVIu3ZhtakueIp3tbUZeEzZZxcxeRx2tYuYqw1JWbX5UHfIgAAEIQAACRSGATleUmUSORhKweuLZtywyNnyE7T/KMGrvuUd5r0YZYJVv23fLF+FccrmyjZk2J1YsW/bMmQsjy7nG5aj1gdYLPicdha1Ysaq7tDaJ7CCjmXpG7HpF66moJCO+mFiGUWXIgwAEIJAWgcq/6UhrJLSbewJ33XWXGTZsmLnsssvMEUccYXbaaSdz9913516uPAug3Y6jkvJd5SyqTKPy1pmG1/aoaxmlpRxVkqLe9Hf39psN1h8SfGYX9ZljXPtSzPSJXtIYexpvI8OLxI09S/fgkqXZYCwQgAAEkhFAp0vGiVIQCBOQ/ugLgZdE95YBUc4SbkriPOGWz/u5jMC+JF3bGlBlcI1K7peOUesDvQyQk04U5wuOHps747PWOEtmHBmsW6xh2WUQZqQXJJWus8JtcA0BCECgGgK4p1ZDjTqRBEaMGFHKP/XUU0vnnDSPgJSPKC8Kq5RE3UtrtMM7282qhJ+RyQgthdEqUUnG5FPq5cXwx68enqSJqstIiQt7X+taqRIZqh5ARivCJaMTw7AgAAEIlCGATlcGELch4AntIL2vnP4dB8/qja38FZ6MwOfetsjIkSSctHaxOraM9a7+rbJhY71vfSBnHMVJjuKsvEaukcIyVnotSjLMW+9n1de5z0Nc3vnVfnFa6dgoDwEIQMAlgAHapcF5VQQ23HBD0xaxY0Z/f3+Q/9prr1XVLpVqJ1BOMQsrbbX36G+hp69/UDgMvbEfrFqubSNKYZRB0yqKiu/c1dNb1qitT+zSThqTvCnclPRTS7dO0c7hUrQZRR4IQKDoBNDpij7DyFcvAnEv2cvp3+XGICO0NUSXK1vE+1Z2nyHY6tj6UlHJrg1k+HeNsJqj9ra2QeFQVEfrCFtPa4WVb/YEBlsbPiVujZJF5jKYu0ZlMbzw7sWRewFp/Fp/6YtTG5c8izIxJghAoHgEMEAXb04bLtHrr7/e8D7pMBkBV4GTQTesmKkV39vxZD0kL9UV8mLQZ3MTdxs9IAa025r10rZ5YUXfbkRi7/uOvjjYvvLV5EcZy9WOL7+aPvJYxye/Lz+PMjJmCEAAAkUigE5XpNlEljQJxL1kL2cYTXNcRWlbaxj97TBtTqSzivVQtuXCctt1QzgWt8ppf5iVXT2ljcpfWbUuZOH/b+9d4K2o6v7/dQ4cFLwhBUlegVAUuRiomJW3NHs074imRWmZpU+PaCTmDU3/UJrm8/TYxdQsyUg0QjH17616SPKKGeUlRVG8gCBeuB4483t9Fq7NnDkz+zqz98ye93q9zpnZa9as9V3vNXvPd77zXd/lygcdZLJgkA4aleVJXszZSOV1HbvnxSBDPkMAAhCImwAG6LiJUp9ZvHixWb16dYHEDjvsUNhnp/4EiilmUjoakVpbNkwNcwqPfyFCyROcPqe8MEW/HNmj4mCXc265ZWqZalluG1ksB5csjhoyQwACENhIAJ1uIwv28kVABkzpnnppHubAEfUy3eVH6d/5olh7b6N0SdV8wcynIxctj3pu6NbSYteH8Rudy5EyaJAu55xGlPEbld1zlvPqDpPHXa9hx8iDAAQgEDcBFiGMm2iO65s1a5YZPHiwGTBggNlvv/3MTjvtZD73uc/lmEh6u+68Apz3QL0l7fCMmTxrvm32sqOG2Rhs8oiWd4G2U44Z1uVtfLUKkhTXpJOm+4UtZKL8PCe45Hn06TsEIJBlAuh0WR49ZK+VgF9PlkFP+rI8SZXvUpR+GZXvzmNbGYFiuvQtf3slsrKo5wYtEKn1YZo5+fsuI/QPjx9hn7HC+sz1GkaFPAhAICkCGKCTIpvDei+88EIzd+5cs/POO5sFCxaY+++/3+y77745JJH+Lkd5BdRTcn8IDSlHUjClBElpknx+JV9yVaMghXlSJ9FHyS+jeSkjehJtp7lOuKR5dJANAhCAQDQBdLpoNhxpfgJherKLO+x6z0t2RyLZrXTJqOTCZYQdj3puUH7UsbB6spgX1r9N27qafer1nJRFhsgMAQgkQ4AQHMlwzWWtbW1t5kMf+pDp6OiwfwcccIA599xzc8kizZ2WYbdRns9RXJyniVvIz3maqLxTPKXoa3GNcqfAyZv62FH1W8RFcjpZo/qZx3y45HHU6TMEIJB1Auh0WR9B5K+FgN+D1F+PP9/pfDJWK19GP+mqLt9/Hvu1EVDYjDBjs/KjksYiGP/Yb3ANHouqJ2v5/j5K9o3PWB2durJ1rzajGNFcr52w8AECEEiYAAbohAHnqfrevXub999/33z60582J510kunXr5/p3p1LLE3XgFNC0iCTdEbJI8WnmKeJU4y0rWTBRBmqb3t8Eas7p2GwkQECEIAABDJFAJ0uU8OFsDETkDE5zFkj6Fkq3dTpqTGLQHU+Aifuvb25ee5CX86GXeVHJTcuxV4Q6JjGWc8k9Vi0PErWuPJ792wzk4/YYFTWM5brX1j9vXp059oNA0MeBCCQKAGsg4nizVflf/jDH0zPnj3N1VdfbaZNm2beeecdc9FFF+ULQsp7G2bobZTIUvRkUL7kjvkmaiEQv6eJ5FSIi7AHgqg+uOmSTgmNKkc+BCAAAQhAAAIbCaDTbWTBXv4IlPKezR+RxvZY68UoKeazPKHl+Szjs8uPkq7YCwL3bNBsntDql3M4cjNLw/gEn7H8ZZzxGs9+PxX2IQCBOAhggI6DInVYAlopvX///mbTTTc148ePN6tWrTJvvvmmDcsBonQQKKZsNErCKOOz5Al6moQ9EJSSO419LiUzxyEAAQhAAAKNJIBO10j6tN1oAs44Wcx7thwZMeSVQ6lzmShmMjaXMjh3rqn0Jy2IXsxIW7qGdJXQ+jr7Tn3ArFizrmS/gs9YridB43VYWERXli0EIACBSglggK6UGOUjCYwdO9b89a9/LRzv1q2bUd6jjz5ayGOnsQSiphQ2Vqrw1oMxzFTKPRCc87unQmPBhdUUpWCFlSUPAhCAAAQgAAFj9Td0Oq6EPBOQzun0zmo4VGrIizK8VtN2Gs8pp3+VMqukn8H2DxjS1/gXRK+krjSXLWemaNgzlutT2GxZZpQ6OmwhAIFaCXRdDrXWGjk/twTWrVtnevToUei/9teuXVv4zE7jCciDWEpHWpNbTERbp+xIYfQnPQx0lBmorZiC5a+TfQhAAAIQgAAENhJAp9vIgj0IVEOgmCEvWJ8zvMp4qDVMtFWYupOuezhYNJOfw/qn0BdBHb8SZgKh8+XxO2DSbLsN1udghbUfFlPalW/mrRYfnHLMsMiXK1EzR6Pym5kVfYMABOIngAE6fqa5rbFv375m1qxZhf4rfuCHP/zhwmd2Gk9AxlspHYqlnMakuG4yGruVrt20r6BCuVXPtlDxe7a12r5pTWz1sZiCFVoBmRCAAAQgAAEIGHQ6LgII1EYgymAXlh9meFXrc15YZi6Y+XRtgqTg7LD+OUcTv3hhbHQ8LD/MqBxm1Nb5Ye37283TfqnFB6Nmjkbl54kdfYUABGonQAiO2hlSwwcEfvrTn5qTTjrJnHnmmcbzPLP99tubX/3qV/BJGQE3pVDeAvKySFNyns9+mZyC6p8GqdWqw9Kmbd3MnEkHhh2qS56UYSm5UpSlqMnj3C93XYSgEQhAAAIQgECNBNDpagTI6bknID0wLByC8oP6Ylg5B1AL78Ud+9jVXa9tmAFZbavf8mB2erMcTMLCYoQZP8OMynpmUJi+CdPnddLDo9qvV//T1E4pFmHr7TCjNE0jiCwQyDYBDNDZHr9UST9o0CAzd+5c8/7771sD9BZbbJEq+RCmM4Eoxbhzqfp9knIjxTEsBZWl5Svbw4qZqPzQwjFnOk8M1wfnva1mMELHDJvqIAABCEAgUQLodInipfIcEIgy5Cn2sDx1/fqi/CqinEI0K9BvpHXODUEjtstPI9qoZw712xnftW3r1mLaWltMe8dGGlHGz+Czget3cBal8qPad+fkaRtmzPf33z2z4FDjp8I+BCAQFwFCcMRFMsf13HHHHebll18uELjqqqvMJz/5SXPEEUeYBQsWFPLZSRcBKaoRjsR1F7R3zw3xyKJCgzhlScq2lPCNamlnUV25zrn1+RTliaF8EgQgAAEIQCALBNDpsjBKyJgFAjLkubB30rddaLgHn1lSMD67fkTpte64jLMq45wbFJZDRuxgvvTkNCY9c8iQ7E9hRvf29Z7ZfNPuZYXTK0fnl5FfenhY+zJ2580QIuO+WJRKunY1o3TB1MPs1hmlS53HcQhAAAKlCOTtd7cUD45XQeD888+3sQJ16p133mluvvlmc8MNN1gD9Omnn15FjZxSDwJSJkopvPWQQ21stsmGyRgr167r0qTzfHAexlK2w5IrF3asHnlRnhhR+fWQiTYgAAEIQAAClRBAp6uEFmUhUJxAmCGvVr1QRlWF5XAe1E4CZ2x1n9O0FYegMT7qGUSzGcsxfoYZlcP6rOcGGaGPHbVtJ8P2FceNMF8Ys0PYKU2T1+rzNJKzzxVjRzArs2lGl45AIJsECMGRzXFLldQtLS2mV69eVqbbb7/dnHrqqWbUqFH279prr02VrAjTmYC8MaIMup1LJvtJMvinI7rWpCwdPqK/VRyLyal+SBFt5Bt6eWKEyViOh4brL1sIQAACEIBAIwmg0zWSPm2njUBcYS789bS2tBQW2/b3V+uguPAR/vyw/ahytRq3w9qKK086ul9P14zGWvRmV5eMy+p3FFfJr3Zue3yRNYLr83m3/92cNX1eXF1LXT09urVY5x4Z89PwjJQ6QAgEAQg0jAAe0A1D3zwNa8FBxX3u6Ogw999/vznooIMKnVu9enVhn530ESjXe6Aekgc9OVybUhjDFFR3XC/35SnhFFGXX+9tGMtGe2XXmwHtQQACEIBAtgmg02V7/JA+PgL+mXf+8BfKryQF64kyHo8ZuHXZ1cpYHZay5PQQh94s3d95S//w+BFdwnz4Gek545I75puzp88zq9o7/Ieabn/tes+8vbK9U9iWSq/bpoNChyAAgVQQwACdimHIthBnnXWWGTlypBk9erTZdddd7VY9evLJJ03//v2z3bkml16Km5sSl8auaiXsKMO0kzctyrafpR4LXKy/RhvGHSe2EIAABCAAgVIE0OlKEeJ4XgjIszaog+qz8itJYfWEnf/S0vAQc8Gycm44ce/tuxhbs+b0ELferPoUZiPKOC+OMso2t+k5eLVs+FzNdRteE7kQgAAEaiNACI7a+HG2MeaUU04xn/3sZ83ixYvNiBEjCky22WYbc+ONNxY+s5NOAlLY9DfovLvKnvqXlp6kTdl2LNPCBzkgAAEIQAAClRBAp6uEFmWbmUBUOIuo/CgW5ZYvNtvP1e0PpzB6xz7WGK765YzR6FB0TsZKtnHqzfLw1azJKA/zSuRqxrLlXofN2Hf6BAEIpIcABuj0jEWmJdl2222N/vwJ72c/jfTvZ01hc0q4yCqOXJYV8PRfHUgIAQhAAAJ5IdAsOp0MUi4+bFYNdHm55tLWT107UTGFK515p/LlGJfLYbB85VozedZ8M2H6vMwZnWv9PpY6v5SnuZxWNuneajS7Mo+p0us2j4zoMwQgkDwBDNDJM6YFCGSCQCWLnzS6Qz8aN9J6bUsZ9S9eKAVfn5XkVUGCAAQgAAEIQCB/BKrRD0oZuPJHMZ89dtdOmGNGNTPv5Jns11Vrobpi7XpjjP42LKyXFZ3XMXUhTSrV10udr+PFjPx+pxXFgG6mMBy92lpNj+7dihrWq7lua7lOORcCEIBAFAFiQEeRIb/uBNavX2/22GMPc/jhh9u2FyxYYPbee28zePBgM27cOLN27dq6y5SnBhVPLgtp615tBeNymLcDcc6yMIrICAEIQAACEEiOQKX6gTNwyYhVy4JzyfWImutFIOzaUdty1NC6KZU6OKi8zuvdsy32LmRF5w1jWonsUeef87unzE6TZluP8Ci4Mj67xUJF640AACAASURBVMo1FleNG2l6tjWPCWSTtm5m3sWHGDnnqK9ah0bXmp6XWJMm6qogHwIQaBQBPKAbRb6J2l22bFnR3vTp06focXfwmmuusYsYvvvuuzbr3HPPNRMmTDAnnHCCOf300831119vvvGNb7jibGMmcNlRw8zNcxfGXGu81ekN/sWfH1qoNCqeWVR+4UR2IAABCEAAAhDoQiAuna5LxXXOiNIDovKjDFzKr9TgWOeu0lzMBKKukQ7Pq+ha0EsNXT+qr3evNrNizbqYJd1QXZS8iTRWZaVRMkblB5uJKue81PXSKCx1a22xsbH9x/R91l9a177Ri45tttq0qEe3vz/LV24IKeL65T/GPgQgAIG0EcAAnbYRyaA8o0aNMi0tLcbzPPP666+bj370o3ZfXVH+iy++WLJXr776qpk9e7Y5//zzzVVXXWXPf+CBB8xvfvMbe+748ePN5MmTMUCXJFlbAb05LzaFrbbaazvbTZ/zPwhGxdUjzlltrDkbAhCAAATySSAOnS4N5CrVD6J0n6j8NPQRGZIhUOm1EyaF86h3ISfe/sBIGFa21jwZX7UWSj0XIfQb18WrVNu1Mo06vxS7jo7olwbOeF2qjnof14xULTBZbtgWsSFBAAIQyAqB5pl/khXiTSinQmXIyKztrrvuWth3+eV0+ayzzjI/+MEPTGvrhkty6dKlpnfv3qZ79w3vSLbbbjuzaNGicqqiTA0EpEC2tWrCVrqSJHLT5/ySSV55RQeTvEykHJMgAAEIQAACECifgNPdatHpym8tuZJh+kFbtxbrhTpg0mxrsPPrCfI6DEtR+WFlyWsOAmHXTqUxdMM86pOkoxclMlj6r+mk2lMbakttlhuuplamYeeX0z9nnPdz0b4M9mlMJ4/ZwWhGqpxtFLZFYTSKpUqvy2J1cQwCEIBAPQhggK4H5Ry1IY/nStOdd95p+vXrZ+R145K8qYMpqu6f//znZvTo0fZvyZIlwdP4XAEBKTybb5q+iRFRb/ejFDStcF0vRbwCvBSFAAQgAAEIZIZAlN7l70BadTCnH7iYqNaQ4xm7UFeY0SzKGzIq38+A/eYiELx2dA1VGvu5EZ7zlcRUrmXEwozrpdoul6kzDgdfEgXPr+TFkN847zee18IgiXPVJxmfXVKfe/WIfiar5rp0dbOFAAQg0CgC0b9qjZKIdnNHYM6cOWbWrFnmrrvuMqtXrzaKAS2P6OXLl5t169ZZL2iF6FBoj7B02mmnGf0pyRBNqo2AiyVWWy3xnV3q7b4UNCnDwemNThnWcRIEIAABCEAAAvETSLMOpvu/0wHk8RimJ2gRswnT59kF5sKMzTLykPJHwH/tVNp7GTnljtPVlabSmiovHxUrufKaos+IaiMq39VUiqkzDruwJc5wrPPdue77HCzr2ojaqs5L7phvDbqu/qiyjcoP+/2JYupmhjZKVtqFAAQgUC0BDNDVkuO8AgHFbHZp8eLFNoaz+6zt2Wef7f/YZX/KlClGf0oPPfSQufLKK820adPM2LFjzYwZM+wihDfddJM58sgju5xLRvwEqo2zFr8kG2osx+skSkGLyk9KVuqFAAQgAAEIZJlArTpdI/ouY5Rb7E06jKbrK/nzojxSndHHbf3yl3oB7i/LPgQcAV13jTA+q/2oGYNOtji2Uc8JtbYtbkHjsD4r3xmenfzus/uOl8NbL6CCL6FcfWnYhr3sSop1GvqLDBCAQD4JEIIjn+Mea6/fe+894/6+9rWvFfZdXrWNff/737fG7I997GNGMaFPPfXUaqvivAoIHDCkbwWlky961vR5XWI1BluNUnqj8oPn8xkCEIAABCAAAdNJh4tTp0uKrYzPE2c81Ske7Tm3PmXO/t28Tnnltq9p8PIuZHp7ucQoFyTQSOeHeujwYfGY43hZE8UtKl9GaK0Ps2DqYfb7GhyHsM+VB4oMqyX+vCh+SbGOvwfUCAEIQKA8AnhAl8eJUkUIXHzxxUWOVnZo//33N/pTGjhwoHnkkUcqq4DSNRHQg9z0R1+pqY4kTg5Owwu2IQUtuFp0lDIXPJfPEIAABCAAAQhsIBCnTlcPpppW376+s//j+o7OnyuRo8PzrEGrknMoCwE/gSivVX+ZpPZve3yRGb1jny4ew3G2F/Q+Vn+lh7v8sLaCsxRkKH/wmSVGxmV3fhQ35ZdKal8OK6VS9b8MpWqu/riM4seO2hguyF+TY+o8vR0rl+8vyz4EIACBLBDAAJ2FUUq5jJdeemmkhFrA5sILL4w8zoF0EZCCE3yQS4uEmoanWI2Pvbysi9LqFDEUtLSMFnJAAAIQgEAWCWRNp6t0Sr0WI9RaF60tLSYs7IbyZSxzekUWxxCZG0sgzCmiXhJFhayIu319P8r9juj75HcSkVPJzXMXFkRyTiYywsqA7g/DUa4ziWTRy6hKfw8KQiS8oynnHRFtyCguY3xUqoR1VB3kQwACEEgLAQzQaRmJDMux2WabdZF+xYoV5vrrr7ehMzBAd8GT2oyoaW5pEVgPi0GlVR4PUjov/vxQOxUvLbIiBwQgAAEIQCBrBJpdp5OBSmE2wozPGivly1jmEi+2HYn8bIPeuqW8e4NkZDCUs4RfXw2WSfJz2nR5fYf8RuWwvuu4jLBa96Xa79xhw/ubaXMXRsbfbuvWYnp0azUr1q4PEyGRPHk3nzRmB+uVrn5FxaJP25glAoNKIQABCBhjMEBzGdRM4JxzzinUobjP11xzjbnxxhvt4oH+Y4VC7KSWQNT0t9QK/IFgeqB0D4zlemSkvU/IBwEIQAACEKg3Ab/elnad7oKZGw3FlXCKMj67OmQMmzxrvlmzrqNgOHNemiqDnuFIZX8bNDYrNITfC7fYuAfP9Ruqi3m0Jk2tnJAVScvgr79c46rKVePtq3Eo5f2smQ8yUE9/pH5hBk8es4O57KhhBRTq275THwg1QqdtzApCswMBCEAgZgIsQhgz0LxWt2zZMnPBBReY4cOHm3Xr1pknnnjCaBHBfv365RVJJvst5VkeAllMemCUdwEJAhCAAAQgAIHqCaRdp5PBaehFdyfqYbp8VXvB+OxIomc4Es2x1XUk5wUZmRUGQVt50Gqc/Sls3MPOVV3KVyrX6OpvJ479ckNWxNFWuXWUa1wtt5y/XTcOxUJvyPisWZJ6KdBeQ3x4f7ul9n80bmQn47Mrr+csjZE/pXHM/PKxDwEIQCBOAhig46SZ07omTpxo9txzT7PFFluYp59+2kyePNlsvfXWOaWR7W7r7fwVx40wUtaymIop/FJS5XkwYNJsu3UPCVnsJzJDAAIQgAAEkiCQdp1O9+6JM56q6zR6P+dieoa/HPvpJyCnhaCxOWqRuuC4h53rN1T3jlmP1gO7jJryqm2N8BOR7q4QFmnz0A8zugavjmqNsGHjEKxbxmn9ZugFQ72SQrCEJY2Nxmjb3j2NhlHbNI5ZmOzkQQACEIiDACE44qCY8zp++MMfmk022cRcdtll5vLLLy/Q8DzPaBHCd999t5DHTvoJSDlyyqse9MpZVTotvYrynlA/5JniHjSKTalMS1+QAwIQgAAEIFBvAmnX6WRwqsdiyTLmhXlVRukZ9R4n2qudQNCoXKzG4LhHnevyvShLdrFGih1r2RD6Rfq5PHnDjKm9enQv6O/Fqqr3MfdMoe+u+IilQp2oH+6zP3xJJfI53qXO0W9Gsdjvpc6v9Pgtf3sl1ANa9fifsyqtl/IQgAAEsk4AA3TWRzAF8nd0RK3rmwLhEKEmAlKSsmSAlgIblsI8JJynilOMw84jDwIQgAAEIJAnAmnX6co1ONU6Zpqy739xrfqq9dKsVRbOT4aADKFhhlx5pvrtx27c5czgjKitEQtZOkP1O6vaYxXaHzki6jsQlu+XWbJVa+ittTNRRlcn34Tp8yzbSuWLGsMweRX7XWPpnFHCysSVVyrOfFztUA8EIACBrBEgBEfWRgx5IVBnApoelvUUppSrT1H5We8v8kMAAhCAAASakYAz8CXdNxnMmCqfNOXG1i9jpwyS/tTW2tJpLZSWFmOOHbWtLeKPFx1mYHSGahXeqme8oezkvetS1HcgmO9m/8nI7mJc++NUu/oatY1DvrAxjOqPC3dRj+ca/3hFyUM+BCAAgTwSwACdx1GnzxCogEAlyl0F1SZSVJ4pYSmolLsyUfnuOFsIQAACEIAABNJBQAarlWvXJS6MWwdDRug5kw40C6YeZrfMmEocfV0bCL5k6N2zzciwvHb9Rv9nhdKY/ugrZvKs+UU9Z/3xl3WdrijzOtV55RgrT9x7+wKbML3cb/x2BYvN/nNlGrmNQ77gGIpnmHFDC6yLm/tOa6yTTP7xSrId6oYABCCQNQKE4MjaiCEvBOpMwD1wXXLH/NB4iHUWp2hz8vI46bqHzbSv7dOpnJROptJ2QsIHCEAAAhCAQGYIOG/JekyfV/gNUj4IOB1XxtCwcByioPjBy0uE1PDHX1Zd5cQpl7e1u9aCOqqjL+O0jJmXHTXMZRXiPKsdzeSTM4UzrhYKFZnll5bZf1FyROX7++bf1xi6cVS+fiv0wsCNmYzS4uzK6Lg75q8nrv19B/XpNF5x1Us9EIAABJqBAAboZhhF+gCBhAk45U5Km1N4tcK3FLjYF1qpsS9zXljWxQjtlE4ne5SyXmPTnA4BCEAAAhCAQAIEdP+uh/FZnpFOZ0igG1QZAwG/LlqtPnfBzKeNFooLC6VRjYh+o6l/P6qunm2tZsoxwztda5XoqE4vj6pf+WITZlRXfhpSUvIVY6NrR8b+JJJ+OyYfsdHQnUQb1AkBCEAg6wQwQGd9BJEfAnUkEFTqpMhNnPFUWZ4edRTTyAgdTEHZg8f5DAEIQAACEIBAOgmUY9SrVXKFMZABiZQsgVoMyM6A6F5GyMA68danjGbpLV/ZHukN7O+RjM83z13oz6p532/UjTKsqhHFHw7zVk5CR0377L9GyFfuiyyF7Bi35/Zm2tyFnRakDLtQWluMuer4kZ1eJoSVIw8CEIAABIzBAM1VAAEIVE1ACrN/mlvVFXEiBCAAAQhAAAIQiCBQzKgXcUpF2Qp1oEUHpdeQkiMQZkB2HqnlsA8zILZ3eIUQcTJIh9XnN3pvjPAcXz9lTHUpyrBa7+vL8azEs9r1oR7bRshXzousYMiOUkboLTdl1kQ9rhfagAAEmoMABujmGEd6AYGGEUgyjlotndLDhlNua6mHcyEAAQhAAAIQaBwB3c+TXHxQns/1Ng42jmZjWw4zIMubWfnl6GzlGBCD9QWN3tUS0EuKsJAdvdpaO8nu+pEGw69kcfJU2+8kz6u3fFEvsjS2Pzx+RBdWir09esc+9voMC2ciNu+UiA+eJD/qhgAEIJA1AhigszZiyAuBlBGIUsgbLaY8s9OsdDeaD+1DAAL5JeD3BtQDuTz2+L3M7/WQ5p7HZTyM6qOMh/8fns9ReGLPjzIgR+UHBYgyIAbLqT73OxdlOAyeU+yzXlIcO2pbM/3RV7qEndOCg2rL/xtab8NqMdmb/ZgbZ415qftZNd7pbiz3nfpAqmNqN/s40z8IQKA5CLQ2RzfoBQQg0CgCYd4gjZLF3648s6UsSjElQQACEIDABgL6TdQUdRllNBXdTVnnt5IrJI0Ewjxm45Rz68026WQ4jLNu6upKQAbCsBSVHywrA6KMwaXSVj3bCr9zpcqWOq64zfKQlzfsZj26+m4pBIicHkj1J1Dp/UzGZI2lxrTlg5jc5c5+CLv2dC0qnwQBCEAAAuUR6HoXLe88SkEAAhCwBKTExeFdkgROZ1hR3X7PlCTaok4IQAACWSAQZtALTlnPQj+QMR8EyvWMrZZG0vVXK1e9z5Mhrx4hI6I8UMs14jldzskqQ/OKtes6eSXLKNjSYoxbqLAWlieP2cEanl0dUeEW5PQghk4+V55tsgSquZ9pjKoZJ3eOu/ZKeVsn23NqhwAEIJBNAhigszluSA2B1BAIe5hIjXBmwwOIlEWnOKZJNmSBAAQgUG8CUQa3qPx6y0d7EPATkJEnyZfc5Xre+mVqtn3nReoMtkm+vHe6WC1GPNXh6tFYhBnPJ0yfV/Mw7Tuoj43/q9l0+n3UtSKDd9TaJ+iaNSOvuIKo+1ZUfsUNBE4IXnuBw3yEAAQgAIESBDBAlwDEYQhAoDgB9xBwVgzKfvGWqj+alCJavUScCQEIQKAxBKIMehjiGjMetFqcQJIvuRWHsFzP2+JSZvuoDKfO+Ox6kuSsiLiNeGH1qU+1vLiQ8Xn+a++ZOT7dVvW1dVPghvCErhnOJclc7mdJ0qVuCEAAAvETIAZ0/EypEQK5I+CM0GntOIaVtI4MckEAAvUmIINbMIYqcSzrPQq0Vy4B6Rf+mK0KrRBX2qpXWydP2rjqzVo9UYbTqPws9O+AIX1rEnPOC8tCPZ214GBrxDWomPqsPVIT9opP5n5WMTJOgAAEINBQAnhANxQ/jUMAAkkTwLCSNGHqhwAEskTAvTCsZQp8lvqLrNkn4PdwHTBpdmwdentle2x1ZbmicrxIw8JcuN+SNPb9wWeWJCZWh2fsS7yg17gaTDJ8SWIdynDF7hrkfpbhQUR0CEAgVwQwQOdquOksBJIjIIcQeX+kLZW7unXa5EYeCEAAAkkR8Bv0kmqDeiGQBIFiMXiraY+F4zaEITnv9qc7heHwv7wPixF99u/mGX/oNYWsmPa1faoZgkTOSdJ7W4tvy/M2KsxHkuFLEoGV8Uq5n2V8ABEfAhDIFQEM0LkabjoLgWQIXDDz6VQan11v/QvI6KHBeUy442whAAEIQAACEEg/gThDcKi3MiLmXSdw/Y/yIlV+0NtXXsD+pJAVB1/1kPn/z97fn12X/TDv7LhfVPg74tcj/UZ4f5kkDeD+dtiHAAQgAAEIZIkABugsjRayQiClBKbNXZhSyYzRSujuOYmpkakdJgSDAAQgAAEIlCQQd9iMvBoKw4y2cyYdGMq/XEbPL15h6u1RHuWdHTSQh3asxkwZ5qMSa49EkSEfAhCAAATyTIBFCPM8+vQdAjERcAbemKqLtZqgbG5qZKyNUBkEIAABCEAAAokSkLEx7pRHQ6Ez2uqlvHQk93I+im8ljIoZZeMeO9VXjnd23O26PhYzzMtLmgQBCEAAAhCAQGcCGKA78+ATBCCQAwLBhwY9dClMhxY3YgXzHFwAdBECEIAABDJFQKG+NKMp7pRHQ2GY0bbYy3kxUkzoclJQvyrnnFrKxNGe1jCpJLk2owzzW/dqy31Yl0p4xlUWXT4uktQDAQhAIDkChOBIji01QyA3BDbr0c2sWLs+M/3VQ4MUVT2EyfPHv4Ci8wRSZ1xcxMx0DEEhAAEIQAACTUZAxuebEwr1lcf7vPScsKT8sDUzHCOnM4Wd6/LkUa06/HGS3bEkttLnovpTTnu9e7aZw0f0N7c9vqhTnGsZ3Dfp3mqWr2rvUo0zPKuPYYs3Xvz5oV3OISNZAtLp/WOBLp8sb2qHAAQgUC0BPKCrJcd5EIBAgcDlRw8zrZW6kBTOru9OW2uLOWBIX6uouocWwnTUdwxoDQIQgAAEIFAOARmW0rzORDl9SFuZbkVWcpRe5MJyaIG9nSbNtn9usb2Tx+xgSj08OuOfxi7pVIl3dlAWGZ/nXXyIueyoYWbKMcPMtr17WocEbfV58hFDu3h+yzCtNpVkmA87zxnsg+3xOTkClXr1JycJNUMAAhCAQDECeEAXo8MxCECgLAJO2f7u7X83K9s7yjqnUYV6dG81Dz6zpJOnS5gsbopl2DHyIAABCEAAAhBInoAMS8GXxHG1qlAJeUzrveqIyrBcrie6C+nh9MOkOLv6z/ndU6ZYv+Qk4V+YUIZkGZhdUj2uLpfntroGpRPK8zno2V3sPHc+2+QJROnsUfnJS0QLEIAABCAQRgADdBgV8iAAgYoJSAmXkr4yYmpnxRUmdIJChaxYGz791N+km2Lpz2MfAhCAAAQgAIH6EUjKgNTWrcXkNVSCPKCLGWvjGt2kxi4onzMcT7z1KdPutzJ/UFAvGg4b3t86H0imMENysE73GQOzI5HurcbUzWr0S4ou76fBPgQgAIHGE8AA3fgxQAIINA2Bej1sJA3MP8Uy6baoHwIQgAAEIACBcAJRhqXw0sVz3XoPCrEQ9GQtfmZzHa2H8VnE6m78iwgF9/bKdhvjWeEynLG6uUaU3uj77I8BLSLo8lwXEIAABNJHAAN0+sYEiSCQWQJxPijWGwIPpvUmTnsQgAAEIACB4gRkWHLxh4uXLH306nEjMUAaY2Mdh3mLliZYfol6G/80A699fXRokXqFBCmfECXjJOBeLBQLlxJne9QFAQhAAALVEcAAXR03zoIABEII6EFxwvR5icVrDGkyliw3HVVbPZRJgVVyCm0sjVAJBCAAAQhAAAIVEdB9OI71Jdpauac78FqIWQs7RptrXcnqtnqhf+yojTGVL5j5tLnlb6/YsB/Ss07ce3u78F91tYefVc4MvHLKhNdObhYI6LcCvT0LI4WMEIBAngmUWsg4z2zoOwQgUCEBKX6fGNSnwrMaW1wPSm46qtvKCD1xxlOmHiu4N7b3tA4BCEAAAhBIN4FVMSxuXMQ5Nt2dj1k66TW3Pb4oMeOzxJVhW4s9K8n4rIULnX6lrT4rP85UTriPcsrEKRN1QQACEIAABCDQmQAG6M48+AQBCNRI4KWlpRf4q7GJWE+P8gDSVM6zfzcPI3SstKkMAhCAAAQgUD4BGUyj7tPl12JMyNp0lZzeNGU1w0vhKGpNWthPsbSjkgvx8Zu/LQwtEpUfWriMTM3AU9iPqFTvkCBRcpAPAQhAAAIQyDMBDNB5Hn36DoEECDTTFEc9sGpREzyhE7hQqBICEIAABCBQhIDuvRNvfapIifIPKfQDyZi4dLTlK9vtQo5RTB3vKMN/VH5UfaXyNQNPiwzKKK6RloG8d882u688FiAsRZDjEIAABCAAgeQJEAM6eca0AIFcEcjyQoRhA8XCNWFUyIMABCAAAQgkS2DyrPmmPSZLpeIOk4yJS0fr3avNvqCPYupCbkQdTyKfGMBJUKVOCEAAAhCAQHwE8ICOjyU1VUlg9erVZq+99jIjRowwQ4cONRdffLGtacGCBWbvvfc2gwcPNuPGjTNr166tsgVOqyeBUtMg6ylLXG3F5TEUlzzUAwEIQAACEGh2AstXtcfSxX0H9Yl90btYBGtAJXHoaApn4XmmaCiPYuE5GtBtmoQABCAAAQhAIAUEMECnYBDyLsImm2xiHnjgAfPUU0+ZefPmmbvvvtvMnTvXnHvuuWbChAnm+eefN1tvvbW5/vrr844qE/0PToPcrEd0TL5MdMhs8BjKiqzICQEIQAACEIDABgK92lrNtK/tA44PCPh1tGqgKLzFsaO2Ne8UeTngj7esUBhhKSo/rGxUnkK07Dv1ATNg0my7JVxaFCnyIQABCEAAAukggAE6HeOQaylaWlrM5ptvbhm0t7cb/SlPRunjjjvO5o8fP97MnDkz15yy1Hk94MyZdKBZMPUwM//SQ82Pxo20sfiy1Acnq/9ByuWxhQAEIAABCEAgWQJxGCl7dM/+S/C4KT/28jLzxjurq6pWC0I++MwSG8ojrALFfvbHW77480NNW7fO8bf1Wfm1JBmbtUaHFjuUTNqyZkctRDkXAhCAAAQgkDwBDNDJM6aFMgisX7/ejBw50vTr188cfPDBZtCgQaZ3796me/cNYcq32247s2jRojJqokgaCcggvdkm2Qk57xaxYeGaNF5NyAQBCEAAAnkgUKuRUoziCuPRLLwvmPm0uXnuQlNLjGaFJQsL5aEX9j88foSRzueS9q84bkRhcUDpVfrsL+PKVrK94p5nu4QAcWt2VFIPZSEAAQhAAAIQqB+B7FiE6seElhpAoFu3bjb8xvLly83RRx9t/vWvf3WRQl7RYennP/+50Z/SkiVLwoqQlwICWYmjrIcjeW+TIAABCEAAAhAoTiBJHUxGyrOmzysuQImj4ZpjiZOa+PAtf3ul5t5pAUJnAJbHs4zZ0p1klA4zLCsvLL8WQaJ0yqj8WtriXAhAAAIQgAAE4iGAB3Q8HKklJgLyet5///1tDGgZo9etW2drfvXVV81HP/rR0FZOO+0089hjj9m/vn37hpYhs/EEtPJ6FpIeoEgQgAAEIAABCJQmkLQOJsNmLUnhGUgbCdTi+exqeX/1OhvyQp9VnwtVFreR2bUXto3SKaPyw+ogDwIQgAAEIACB+hLAAF1f3rQWQkBeyzI2K61atcrcd999ZtdddzUHHHCAmTFjhs2/6aabzJFHHhlyNllZIRA2XTNtsstTqp4PUGnrP/JAAAIQgAAE0kRAukNbK37McY2JPJZrSTq7vaOzWb8RoS/CdEpnCK+lf5wLAQhAAAIQgEByBAjBkRxbai6TwOuvv260yKDiQHd0dJjjjz/eHH744Wa33XYzJ5xwgrngggvMHnvsYU499dQya6RYGgk4w+4ld8w3b69sT6OI5hOD+qRSLoSCAAQgAAEI5JZADTbTOBYyzBp3LdCnEBkKRyGPYBlrnQ524t7b2xjQwT7tO6iPeWnpqoJnc/C4PsvAK2NzWCo39EUx2cLqjcpz/YnqZ9R55EMAAhCAAAQg0DgCGKAbx56WPyAwfPhw8+STT3bhMXDgQPPII490yScjuwT0wKA/LYIzbe5Cu3J5Lb3p3bPNLm7oHrJWrl1Xk3H7iYXvGD0cuQebWmTjXAhAAAIQgAAEaiMgA2P7+s4et+XW2NatxcSxkGG57aWhnHSY825/umAoXrR8lf0s2aTbXHbUMCumYkErfIY8omWUdvk6KB3NHXd9cjGeNR6qM5jKCX1RSrZgnaU+O52yVDmOQwACEIAABCCQDgIYoNMxDkgBgVwR0IPO6B37dPHQEYRKFhx6Z1W7mXfxIQV2wYebwoEyd9w0UgzQZQKjGAQgAAEIQCBBAuV6tddvfwAAIABJREFU1joRerW1mlXtHV08f93xZt/KQBz0Ug7qNtLB/AbnIJNSx/0Gbp1bbuiLcmQLysJnCEAAAhCAAASahwAG6OYZS3oCgUwRiPJcqSRER9DjxhmOozx0ygFU6cNuOXVSBgIQgAAEIACBygnoPh/mcRusyXnoOj0geDwvn6N0mKh8cdHLe+lNKhMM2RHk5viWW95/fpQMUfn+c9mHAAQgAAEIQCD7BDBAZ38M6QEEmoqApstOmD6vZHiOKI8bZ9jed+oDZT20BuH17tUWzOIzBCAAAQhAAAINIKD4xcVmRik89NXjRhI664OxiTLYB1/Yu6EMzhwLhuxw5fxbp2f588rZr1S2cuqkDAQgAAEIQAAC2SHQmh1RkRQCEMgDAT3YnDRmh6JdlafTlGOGFX3gDFshXfEg21qLr2bkVRdqsqi8HIQABCAAAQhAoHIC0gm03kNUkr6gMqQNBMJ0n6gX9jqjWFiMuJlWKlvc7VMfBCAAAQhAAAKNJYAHdGP50zoEIBBCwMUmDC5UqIeoUoZnV517IA1OE9Vx5UVN6VVcaRIEIAABCEAAAukgMPmIoZ0W1pNUepUs47PTF9IhaeOliNJ9XH5QwqjwF1H5wfMr+exkCOplLr+SuigLAQhAAAIQgED2CGCAzt6YITEEckFAD5VhCxVW8qCismHllRcVoiNqmmouoNNJCEAAAhCAQMoIuPs4hsvyBiZK9wk7u95hMSqRLUxe8iAAAQhAAAIQyC4BDNDZHTskh0DTE0jyQUVTQYMruQvoijXr7II87oG36SHTQQhAAAIQgEDKCSSpD6S864mKF6YLKVyZdKEBk2aXXJQwUeGoHAIQgAAEIACBpiKAAbqphpPOQAAC5RJwBuZL7phv3l65MezG8lXt1jCtelyZcuukHAQgAAEIQAACEMgKAafnOO9yLcT8/up1RrqQUjmLEmalr8gJAQhAAAIQgEBjCbAIYWP50zoEINBAAnrw6tWj63u4Ve3rbZzoBopG0xCAAAQgAAEIQCBxAtKF5kw60CyYepjVido7Oq/GjE6U+BDQAAQgAAEIQCAXBDBA52KY6SQEIBBFIGqhnaj8qHrIhwAEIAABCEAAAlkmEKX7ROVnua/IDgEIQAACEIBAfQlggK4vb1qDAARSRiBq0cGo/JSJjzgQgAAEIAABCEAgFgJRuk9UfiyNUgkEIAABCEAAArkggAE6F8NMJyEAgSgCWoCnZ1u3Tof1WfkkCEAAAhCAAAQgkBcC6ER5GWn6CQEIQAACEKg/ga7BT+svAy1CAAIQaBiB4AI88vLRA5jLb5hgNAwBCEAAAhCAAATqSMDpPm5RQnSiOsKnKQhAAAIQgECTE8AA3eQDTPcgAIHSBPTA5R66SpemBAQgAAEIQAACEGhOAuhEzTmu9AoCEIAABCDQaAKE4Gj0CNA+BCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIEmJYABukkHlm5BAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEGg0AQzQjR4B2ocABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQg0KQEMEA36cDSLQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACjSaAAbrRI0D7EIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAASalAAG6CYdWLoFAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIQKDRBDBAN3oEaB8CEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAQJMSwADdpANLtyAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEINJoABuhGjwDtQwACEIAABCAAAQhAAAIQgAAEIAABCEAAAhBoUgIYoJt0YOkWBCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFGE2jxPM9rtBC0D4G4CHz4wx82O+20U1zVxVLPkiVLTN++fWOpK2+VwK76EYcd7KonUN2ZXHPVcdNZsKuM3UsvvWTeeuutyk6idOIEGqGD5eG7k4c+6uLMQz/z0EfGMvGf2ro2kIdrNg99jPN7iQ5W169g0zWGAbrphpQOpY3A6NGjzWOPPZY2sTIhD+yqHybYwa56AtWdyTVXHTedBbvq2XFmvgnk4buThz7m5XeQsWye3yvGkrHMGoG8XLNZG5e8yUsIjryNOP2FAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIFAnAhig6wSaZiAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEI5I1At8mTJ0/OW6fpLwTqTWDUqFH1brJp2oNd9UMJO9hVT6C6M7nmquOms2BXPTvOzDeBPHx38tDHvPwOMpbN83vFWDKWWSOQl2s2a+OSJ3mJAZ2n0aavEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAATqSIAQHHWETVMQgAAEIAABCEAAAhCAAAQgAAEIQAACEIAABPJEAAN0nkabvsZK4JRTTjH9+vUzu+++e2i9nueZb33rW+ZjH/uYGT58uHniiScK5W666SYzePBg+6f9vKVq2c2bN8/ss88+ZujQoZbp9OnT84bOVMvOgXr33XfNtttua84880yXlZttLewWLlxoDjnkELPrrrua3Xbbzbz00ktw+4BAsd+673znO/b7Km76PVTZPKVS19wzzzxjf9M22WQTc+WVV3ZCc/fdd5tddtnF3kOmTp3a6RgfIJBHAsuXLzfHHXecGTJkiP0tfvjhh82yZcvMwQcfbPUpbd9+++1Mo3n22WfNyJEjC39bbrml+dGPftR0/bz66qvtvUE69IknnmhWr15tFixYYPbee287luPGjTNr167N9FhK+GuuucY+J0hv1TgqZf2aDbuvRfWpmH6Q9sEN6+ett95qr9vW1lbz2GOPderClClT7P1a9+177rmn07E0fwjr58SJE+3vrJ5fjz76aKPfXpey2M+wPl544YX2WVK/t9LvX3vtNdvFZrtm3bhJx2xpaTFvvfVW5vvp+sQ2owQ8EgQgUBWBP/3pT97jjz/uDR06NPT82bNne4ceeqjX0dHhPfzww95ee+1lyy1dutQbMGCAp+2yZcvsvrZ5StWye/bZZ73nnnvOolq0aJG3zTbbeG+//Xae0HnVsnOQvvWtb3knnniid8YZZ7is3GxrYbfffvt59957r2X13nvveStWrIDbBwSifuvmzJnjfeITn/DWrVtn/8aMGeM9+OCDueGmjpa65t58803vkUce8b773e96V1xxRYGNmA0cONB74YUXvDVr1njDhw/35s+fXzjODgTySOBLX/qSd91119mu63uh+//EiRO9KVOm2Dxtv/Od7zQNGv0OfOQjH/Feeumlpurnq6++6u20007eypUr7ViNHTvWu/HGGz1tb7nlFpv39a9/3bv22mszPZZPP/20fUaQvtDe3u4ddNBBVofN+jUbdl+L6lOUfpCFgQ3r5z//+U/vmWee8aQTPvroo4Vu6P6s+/Tq1au9F1980d6/9f3NQgrr5z333GOvWcmv31T3u5rVfob18Z133ikMzzXXXOPpN0ep2a5Z9WnhwoXeIYcc4u2www7ekiVLMt9P2wH+ZZYAHtAZfXGA2I0n8OlPf9r06dMnUpA//OEP5ktf+pJ92zhmzBj79vj111+3b8XlpaNzt956a+u5I0+3PKVq2e28887WM0asPvrRj1oP9CVLluQJnamWnSA9/vjj5s0337Rv+nMF7YPOVsvun//8p1m3bp39rqqqzTff3PTq1Ss3CKvlJk8LebXJi23NmjWmvb3dfOQjH8kNN3W0FDvNotlzzz1NW1tbJy6PPPKI9aQaOHCg6dGjhznhhBOM7ikkCOSVgGbv/PnPfzannnqqRaDvRe/eve33Yvz48TZP25kzZzYNovvvv98MGjTI7Ljjjk3XT91TV61aZe+tK1euNP379zcPPPCA9XDXADbDWP7rX/8y0v+lL3Tv3t3st99+5ve//33mxzLsvqb7U9j3MOpZKAtf0rB+ajaXPJyDSf3UfVqzmQYMGGDv37qPZyGF9VMewbpmlXQNv/rqq3Y/q/0M66Nml7i0YsUK+7yuz812zapPEyZMMD/4wQ8Kfcx6P924sc0mAQzQ2Rw3pM4AgUWLFpntt9++IOl2221nlBeVXyjITlmMpNjJsKWHM9JGAlHXV0dHhznnnHPMFVdcsbEwe50IRLF77rnnrKHjmGOOMXvssYfR1MT169d3OjfPH6K4KVzOAQccYA0LMi589rOftdPm88yq3L5HMS33fMpBoNkIvPjii6Zv377mK1/5iv0d/upXv2pkNNBLVf2+KGm7ePHipun6b3/7WxueQh1qpn4qDNi3v/1ts8MOO9gx22qrrcyoUaPsfdYZvZzOnOXBVHgRvTRZunSpkZH9rrvuMq+88kpTjaUbn6jrMy/3smbu5w033GA+97nP2aFutn6ef/759ll92rRp5tJLL23KPs6aNcuGXhwxYoT7ujZlPzt1jg+pJoABOtXDg3BZJhAW61QegVH5We5r3LKXYiRP8i9+8YvmxhtvNIrDRtpIIIrdtddea/7jP/6j00uRjWexJwJR7OSp9Ze//MXG6H300UeNDCG//OUvgfYBgShu//73v408wOQ5o4cWebfpYZxUmkAU09JnUgICzUlAv8NaS+Mb3/iGefLJJ81mm21mmjk2ul6wy3AwduzYphtQxemWl6FiPivuql4k/PGPf+zST+nMWU7ylj333HPt7KlDDz3UyADkDOxZ7lclsuflXtas/bz88svtNXvSSSfZYW+2fqp/eimk/v34xz9uuj7qxZf66Izr/u9us42lv2/sp5sAlpt0jw/SZZiAvDd0U3NJRhiFjYjKd+XYmqKMNA33sMMOM5dddpmdFgavzgSiri8t1iTlaqeddrKeR7/61a/MpEmTOp+c809R7JQvz2eFQ9DD41FHHdVpUdGcY4v8vmqqsaZuKmSJ/uRBM3fu3LzjKqv/UddiWSdTCAJNSEDfCf1pkTolLUYog7TC+uiltJK2CmvTDEkG2Y9//OOFsEXN1M/77rvPhimQR7vCD2l20V//+lcbqk4vGpSczpz1sVTIGF2nevmq0HtagLyZxtKNT1Sf8nIva8Z+3nTTTebOO+808g52L4OasZ+6hr/whS+Y2267zV7OzdTHF154wb7o08svPf/pd1X3lTfeeCNSd3ffabYQSIoABuikyFJv7gkcccQRRkY+vWGU0UVTDN009Hvvvdeu1C4vEO1rajppI4EodvII0mrMiq3djF5BGwlUvxfFTgrkwoULzUsvvWQ9ecWwmb3HqiEYxU4xevVddfHG5cm72267VdNEU54TxU3Tq//0pz/ZGJ+K/6x9eYSRShPQNff888/bBwf97mkqvjiTIJBXAttss42dwfPss89aBIqPrN9hfS9kKFHS9sgjj2wKRLfccksh/IY61Ez91L1BerG886Qju7FUyKYZM2Y01Vi6kDDSv26//XY7ps00lu7LFtUn5Yc9C7nzmmWrfuo+rfUu5Nmv+/dee+2V2e5pbaLvf//7dhaGf82TZuqnxsglzTYZMmSI/dhM1+ywYcNsWCo9++lPxnW9ENP9tJn66caRbUYIZHb5RASHQIMJnHDCCd4222zjde/e3dt22229X/ziF95PfvIT+yfROjo6vG9+85t2JeTdd9+902rJ119/vTdo0CD7d8MNNzS4J/Vvvlp2v/71ry3vESNGeO7vySefrH8HGthitez8Imu1+TPOOMOflYv9Wtjde++93rBhwzx9l8ePH++tWbMmF8zUyWq5aQX40047zRsyZIi36667ehMmTMgNM9fRUuxef/11e//YYostvK222sruu5XZtRL74MGD7T3ksssuc1WyhUBuCeh+P2rUKPtbfOSRR3rLli3z3nrrLe/AAw/0Pvaxj9nt0qVLM89nxYoVXp8+fbzly5cX+tJs/bzooou8XXbZxRs6dKh38skne6tXr/ZeeOEFb88997S68XHHHWfzCgAyuvPJT37S3v+GDx/u3XfffbYXWR/LsPtaVJ+KPQulfUjD+nn77bfb+3SPHj28fv36eYccckihG7pPDxw40Nt55529u+66q5Cf9p2wfuoZdbvttis8a339618vdCOL/Qzr4zHHHGN/f6TbH3744d6rr75q+9hs12xh4DzP23HHHb0lS5Zkvp/+PrGfPQItEjkjtnLEhAAEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAgQwRIARHhgYLUSEAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIZIkABugsjRayQgACEIAABCAAAQhAAAIQgAAEIAABCEAAAhDIEAEM0BkaLESFAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIJAlAhigszRayAoBCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAIEMEMEBnaLAQFQIQgAAEIAABCEAAAhCAAAQgAAEIQAACEIBAlghggM7SaCErBCAAAWNMt27dzMiRI82IESPMxz/+cfPXv/41Fi4PPfSQOfzww7vUpfytttrK7LHHHmaXXXYxn/70p82dd95ZKPfTn/7U/OpXvyp8Du7o/LhkDNZd6vNjjz1mvvWtb5Uq1uX4k08+aVpaWsw999zT5VitGcuXLzfXXnttrdVwPgQgAAEIQKApCPz+97+399xnnnmmpv788pe/NGeeeWZNdbiTTzzxRDN8+HBz9dVXu6yi20bqOkUFq9NBsX/ttdcqau2ll14yu+++e5dzlP+b3/ymS36xDJ0jve1//ud/CsV0LUgupYsuusjcd999dv9HP/qRWblyZaFc1neqYZ/1PiM/BCCQTQIYoLM5bkgNAQjkmEDPnj3NvHnzzFNPPWWmTJlizjvvvMRpfOpTnzIyyj777LPmv//7v+0D3v3332/bPf30082XvvSlSBka+VA2evRoK2+kcBEHbrnlFvPJT37SaBt3KmaAXr9+fdzNUR8EIAABCEAg1QTcPfe3v/1tKuR844037Ivzv//972bChAllydRIXacsARMuFKcRtBoDtLrXr18/c80115i1a9d26e2ll15qPvOZz9j8YgborOlhkjdO9l3AkQEBCEAgRgIYoGOESVUQgAAE6k3g3XffNVtvvbVt1vM8M3HiROtNMmzYMDN9+nSbr4ei/fff3xx33HFmyJAh5qSTTjIqq3T33XfbPBlbb7/9dptX6p+8r+VJ8uMf/9gWnTx5srnyyivtvozTu+22m/UaOuGEE4weIuQhLQ8infeXv/zF3HHHHWbvvfe2HtV6GHjzzTcL9ZxyyilW1oEDB3YyHMvDWp5I8vr+4he/aMsvWbLEHHvssWbPPfe0f3PmzLH5/n/qu/PqlpxR9fvPEZsZM2ZYhf7ee+81q1evtofVl1133dV87WtfM0OHDjWHHHKIWbVqlT326KOPWvn22WefwhjowPz5881ee+1l+y75n3/+eTNp0iTzwgsv2DyNl2Q84IADzBe+8AWjcVO66qqr7DjKM0gPSkpqX+P31a9+1R7TOMqbZ9999zWDBw82jzzyiC3HPwhAAAIQgEBWCLz//vtG9+/rr7/e+A3QxXSXu+66q6C7aJaTu8/7+1yOjqD7+1e+8hV779UsrwcffNBWofv74sWLC3qLv94wHSZM13n55ZfNQQcdZHUDbRcuXGir+fKXv2y+8Y1v2Pu+dJ0//elPVjeRfqFjSjIqal86gPSCMC9s6U5HH3201YukG7mZZlH6Q5T+Iv3w3HPPtbrKzjvvbPU0J4N0FOlY0l9+9rOfWdn07wc/+IGVS+1Kp5HOpBln0kuk60k3evzxx81+++1nRo0aZT772c+a119/3Z6vfJ0nfel///d/C3X6d1Sn9EXVpb5HjZP/HO337dvXMr/pppuChyxPySk9VZ7a0rv0p7T55ptbvVa66cMPP2zkYKHrQeylN65Zs8aWi7ruVqxYYcuJlc77wx/+YMvLMHzMMceYQw891Opp3/nOd2y+/98f//hHc/zxxxeydN1//vOft5+lg4qTZjuOHTvW6LuitNNOOxkZ1J2jRDns161bZ8dS9SvJeeX888+3+/yDAAQgUDcCHgkCEIAABDJFoLW11RsxYoS3yy67eFtuuaX32GOPWflnzJjhfeYzn/HWrVvnvfHGG97222/vvfbaa96DDz5oy73yyive+vXrvTFjxnh/+ctfvFWrVnnbbbed99xzz3kdHR3e2LFjvcMOO6wLC50fzH/yySe9IUOG2LIXX3yxd8UVV9j9/v37e6tXr7b7b7/9dpfjyli2bJltT/vXXXedd/bZZxfK7bPPPvb8JUuWeH369PHWrl3r/eMf//B23nlnT3lKS5cutdsTTzzR9kMfXn755YI89uAH//yyS86w+v3ltS82Bx54oM1WG7fddpvdX7BggdetWzdPfVcSr1//+td2f+jQod6cOXPs/rnnnuvps9KZZ57p3XzzzXZ/zZo13sqVKz3V447rgGTs1auX9+KLL9pyGs/dd9/de//997333nvP22233bwnnnjCnqf2//73v9tx/PjHP+595StfsSxnzpzpHXnkkfZ8/kEAAhCAAASyQkD30VNOOcWKq3v0448/bvdL6S7unnnCCScUdJQbb7zRO+OMM+z55egIV155pfflL3/Zlv/Xv/5l9SbpRsH7tC3wwb9iOozThVT08MMP9375y1/as66//vrCPXr8+PHeuHHjCvfuLbbYotN9XTqG9ADpcy45fcp91vb444/3rr76apslvW/58uX2vGL6Q5j+st9++xX0sNmzZ3sHHXSQrfNnP/uZ973vfc/uS68bNWqU1VPuuusuq0utWLHCHnM6mep59NFHbZ50N43l4sWL7eff/va3Vl/Rh2HDhnkPPfSQzf/2t7/dSR+ymR/oRX69M2qcXHlt3ZjpupB+LCa6FnRNKIn7rbfeavd33HHHgk6pDGOMN336dHvM6cbPPvus/fzFL37Rcnb5YdfdeeedV9AHNVaDBw+2OpzaHjBggB0bnb/DDjt4CxcutPW6f+3t7fa6k86ndPrpp9u6pPN+6lOfsvUof+rUqd4ll1xiy0j+73//+3Zf/8plL31auvu9997rjRw50pNeSoIABCBQTwLd62bppiEIQAACEIiFgAvBocrkqaHwF//4xz/M//3f/xnFLFSM6I985CPW80SeuVtuuaX1bNluu+1s+/IokbeOPD4GDBhgvTJ04OSTTzY///nPy5LReVAHC8tLRh4wRx11lP0LHtfnV1991YwbN856w2iapGRw6bDDDjObbLKJ/dNUSnn4PPDAA9Z7+8Mf/rAt1qdPH7uV9+8///lPd6qRN/h7771ntthii0JecCesfsfFldVUYHlvK2n761//2nqw6LNkFT8lefWIo0JqqN1PfOITNl+ezC5GtjxXLr/8cttnecHIUzksyUvacdA4yqtps802s0V1njyBjjjiCFvGeUnLC1teVYp5qDzJQoIABCAAAQhkiYDuuWeddZYVWfdcfZbHp5Luje4e7ddd5Dns7pnSe8J0l3J0BN1v//M//9O2pRlGO+64o3nuuees3mQzQ/4V02H8xaWfuZllmrnl936Vh6u7d0tf89/XdS+X5/CLL75oZZPeIo/sYJJu5NbfkN6ntTpK6Q9B/cXVKT1Dyek12pf3rUKQyGtY6Z133rGzuMRVXuO9evWy+U4nsx8++KdwbdJLDz74YJsjj+7+/fvbOqQzqX9K4iIP4FIpapykcwaTrgtdN5XEkBY/zahTkuyqQ97gSuPHj7ee2vIUj7ruxGrWrFmF2YDy2HYe79LTNDZKmiEoz/jtt9/efta/7t27Ww9pedZrpuLs2bOth7k846XjapabkvRl6ZQuSY8OS1HsVVZ6o5jr+tP12aNHj7AqyIMABCCQGAEM0ImhpWIIQAACyROQMvrWW28ZTTWNMgpLChl1XZKiral4SnoAqiYpHrSmcwaTFOc///nPVhH/3ve+Z0NQBMvoYe/ss8+2BlVNBVRoDJfC5FS/wuTs6OiwCrQM8uWmsPr95+oh6bbbbrPyy3CstpcuXWoNzCoXPF/TTItxlzFaUzrFRVNQf/GLX9gHGH+b2nfGZu0Xq8/ffmtra0Ee7bsxDdbNZwhAAAIQgEAaCej+KkOqjJW6z+serK1CPCj573lOdyl2j/T3sRwdody6/PUW02H85YL7fj3G9ct/H1d5dy9XaDWt86GFkBWm4ne/+5254YYbglV2+VysP65NnSSWLoSYPrtjjrHyVJcW9JPu4k8K3ebvi/+Y29e5MnbKyOlPMj6XOtdf3u0X65cr499+97vftcZcLZpdTtp0000tE5WNaisq350j3VELdfvT3/72twJb5fv5+svJmKxxljFfYTzkSKH2ZMDXC5mw5Ncb/cd1Xhh7V+bpp582vXv3LoS/c/lsIQABCNSDADGg60GZNiAAAQgkREArxuuB7UMf+pCRoq24z/osg7QMwfICiUry9lmwYIGNR6wyUUpu8Hx5xMi4fMYZZ3Q6pIe9V155xcbU08OjHjQUr06KtDyEXZIXzbbbbms/hsXpc+XcVt4jevjSg6rSsmXL7FYeQS4OtTK0MGOtSZ49ik2ofsgLSZ4q8oqZOXNmZNV6UFQf586da8v4Y1jKg0keM4pRKQ9msQvyCFascVR7WqFdcQV///vfGy0CSYIABCAAAQg0EwF512oWl+61uufq3ivvU3m8RiXpLrq3ulk/br2LYPlydATdb6dNm2ZPleezvFaDRsRgvVE6TPDerllRTh9QG4rXW26SY4F0Kukf0reeeOKJLqdKN/rJT35i86X3aRZYnPqDDM+qv7293bYhPtJJxFXGcOkoSk4n8/dfDKWHOgO06tCaGDJ8Ok9tnevY24p8//x1KbvScdI1Im9jNxvNV7XdDdbvP65zdW39+9//ttmaBSeP7WLXnVjJWO+M1HLSqCTJu1pjfN1119lzJyGqAAAEiElEQVQZgjp3zJgxNja6k0O8NQZhyd+fKPY6Tx750qX1fCC9VHo6CQIQgEA9CWCAridt2oIABCAQAwF5rWgapf7kNSEjrrwqFLZB0xFlQD3wwAOtB9E222wT2aI8PjRtVdM79WCkqadRSSEgtLCKFFsZnrWIix5+/EkPQArjoamkKquV4/Wwoal+MqJKXtUjj2ctpiKjqgur4a8nuC9PDi2UogcA9U3e00qSQQuvqM960NBih7UmGeHF0Z/0AFhqKqcWTzrttNPs9Eg9gLjplnow1iJC6rteFuhBWy8LNKVS+VrgJ5g09ViLD+nlgbynteigeJIgAAEIQAACzUSgmnuuZj1de+21NmyBdBeFsHD3XD+bcnSEb37zm/alvfQW6VNaNM55A/vr8u9H6TBBXUft33jjjVZHkRHzmmuu8VdTdH/RokV2QWbpDtIHpkyZ0qW86tOiiZJdoTNk4I1Tf5DuId1KdUpf+frXv25nWmlBPb1QHz16tNVt3CLUkvP000+3edIH9XJBixtKb1M/3CKJYiI9UjP4omawSa9TaAqdq0UIqxkn6Y0KlxKWpK997nOfKyxC6C8j3VgySk8VW3mlq1/FrrsLL7zQGuolt1jpcyVJOrwW0lQ4EregphZU1PWoEDOqVwZp6ZFhqRz2eqmhxR2lryq8yJlnnmn+67/+K6w68iAAAQgkRqBFAacTq52KIQABCEAAAjkgIE9vxdRWmjp1qo1vXcnDZg4Q0UUIQAACEIBALATcPVePsTJman0FvfQmQSBJAlx3SdKlbghAIA8E8IDOwyjTRwhAAAIQSJSAYjzLw0eeL/LyvuCCCxJtj8ohAAEIQAACeSWgUAW652qGlEJiyDuXBIGkCXDdJU2Y+iEAgWYngAd0s48w/YMABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQg0CACeEA3CDzNQgACEIAABCAAAQhAAAIQgAAEIAABCEAAAhBodgIYoJt9hOkfBCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIEGEcAA3SDwNAsBCEAAAhCAAAQgAAEIQAACEIAABCAAAQhAoNkJYIBu9hGmfxCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEGkQAA3SDwNMsBCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIFmJ4AButlHmP5BAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEGgQAQzQDQJPsxCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEmp0ABuhmH2H6BwEIQAACEIAABCAAAQhAAAIQgAAEIAABCECgQQQwQDcIPM1CAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEGh2Ahigm32E6R8EIAABCEAAAhCAAAQgAAEIQAACEIAABCAAgQYRwADdIPA0CwEIQAACEIAABCAAAQhAAAIQgAAEIAABCECg2QlggG72EaZ/EIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQaRAADdIPA0ywEIAABCEAAAhCAAAQgAAEIQAACEIAABCAAgWYn8P8ASM4z/uvsZS8AAAAASUVORK5CYII="}}},{"metadata":{},"cell_type":"markdown","source":""},{"metadata":{},"cell_type":"markdown","source":""}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.6.4","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat":4,"nbformat_minor":1}