{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Quick intro\n\n\n## Competition description\nImagine one day, your breathing became consistently labored and shallow. Months later you were finally diagnosed with pulmonary fibrosis, a disorder with no known cause and no known cure, created by scarring of the lungs. If that happened to you, you would want to know your prognosis. That’s where a troubling disease becomes frightening for the patient: outcomes can range from long-term stability to rapid deterioration, but doctors aren’t easily able to tell where an individual may fall on that spectrum. Your help, and data science, may be able to aid in this prediction, which would dramatically help both patients and clinicians.  \n\nCurrent methods make fibrotic lung diseases difficult to treat, even with access to a chest CT scan. In addition, the wide range of varied prognoses create issues organizing clinical trials. Finally, patients suffer extreme anxiety—in addition to fibrosis-related symptoms—from the disease’s opaque path of progression.\n\nOpen Source Imaging Consortium (OSIC) is a not-for-profit, co-operative effort between academia, industry and philanthropy. The group enables rapid advances in the fight against Idiopathic Pulmonary Fibrosis (IPF), fibrosing interstitial lung diseases (ILDs), and other respiratory diseases, including emphysematous conditions. Its mission is to bring together radiologists, clinicians and computational scientists from around the world to improve imaging-based treatments.\n\nIn this competition, you’ll predict a patient’s severity of decline in lung function based on a CT scan of their lungs. You’ll determine lung function based on output from a spirometer, which measures the volume of air inhaled and exhaled. The challenge is to use machine learning techniques to make a prediction with the image, metadata, and baseline FVC as input.\n\nIf successful, patients and their families would better understand their prognosis when they are first diagnosed with this incurable lung disease. Improved severity detection would also positively impact treatment trial design and accelerate the clinical development of novel treatments.\n \n \n### What should I expect the data format to be & what am I predicting?\nEach row in the dataset contains a Patiend_ID, and a week; you must predict the FVC and a confidence. To avoid potential leakage in the timing of follow up visits, you are asked to predict every patient's FVC measurement for every possible week. Those weeks which are not in the final three visits are ignored in scoring.\n\n\nThe final submission-file should contain a header and have the following format:\n\n```      Patient_Week,                 FVC,    Confidence\nID00002637202176704235138_1, 2000,   100\nID00002637202176704235138_2, 2000,   100\nID00002637202176704235138_3, 2000,   100\n```\n\n","metadata":{}},{"cell_type":"markdown","source":"# Update history:\n\n## New Notebook for CV-backed Random Grid Hyperparameter Search, click [here](https://www.kaggle.com/chrisden/6-82x-cv-backed-hyperp-gridsearch-quantile-reg)\nV39: Optimized Wording, Hyperparameters, reduced NFOLDs  \nV33: Improved logging\nV30, 31: enhanced model-explanations (q1 and q_adjust layers) and outputs.\nV24-29: Minor adoptions, testing multiple hyperparameters, correcting \"MONITORING\" during training: now correctly monitoring 'val_score' instead of 'score', which improves OOF score.  \nV23: Minor optimizations, wording, hyperparameters\nV19: Introduced plotting & evaluation of results  \nV18: Introduced usage of tensorflow.addons (tfa): WeightNormalization  \nV16: [Code optimizations](https://www.kaggle.com/c/osic-pulmonary-fibrosis-progression/discussion/179033), see \"third approach\" in the Data-Wrangling section   \nV13&14: small corrections, edited some links  \nV12: Corrected bug for saving models correctly (see comment-section) & enhanced readabilty  \nV11: Introduced model checkpoints/saving  \nV10: Introduced configurable Learning-Rate-Schedulers  \nV8&9: Introduced GroupKFolds to get leak-free cross-validation strategy to evaluate models & training\n","metadata":{}},{"cell_type":"markdown","source":"## Domain knowledge\n\n### Some domain knowledge can be gained from watching the following video and from reading [here.](https://www.kaggle.com/c/osic-pulmonary-fibrosis-progression/discussion/165727)","metadata":{}},{"cell_type":"code","source":"from IPython.display import HTML\nHTML('<center><iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/AfK9LPNj-Zo\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe></center>')","metadata":{"_kg_hide-input":true,"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Load all dependencies you need\n<span style=\"color:darkgreen ;font-family: Impact; font-size:13;\"> from  </span> coffee  <span style=\"color:darkgreen ;font-family: Impact; font-size:13;\"> import  </span> ***** ","metadata":{}},{"cell_type":"code","source":"import numpy as np\nimport random\nimport pandas as pd\nimport pydicom\nimport os\nimport matplotlib.pyplot as plt\nfrom timeit import timeit\nfrom tqdm import tqdm\nfrom PIL import Image\n\nfrom sklearn.metrics import mean_absolute_error\nfrom sklearn.model_selection import KFold, GroupKFold, StratifiedKFold\n\n#color\nfrom colorama import Fore, Back, Style\n\nimport tensorflow as tf\nimport tensorflow.keras.backend as K\nimport tensorflow.keras.layers as Layers\nimport warnings\nwarnings.filterwarnings('ignore') #Ignore \"future\" warnings and Data-Frame-Slicing warnings.\n","metadata":{"_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","_kg_hide-input":true,"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Let's start seeding everything to make results somewhat reproducible. Anyway, in keras it is quite hard to get 100% reproducible results.","metadata":{}},{"cell_type":"code","source":"def seed_everything(seed): \n    random.seed(seed)\n    os.environ['PYTHONHASHSEED'] = str(seed)\n    np.random.seed(seed)\n    tf.random.set_seed(seed)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# First glimpse at the data","metadata":{}},{"cell_type":"code","source":"ROOT = '../input/osic-pulmonary-fibrosis-progression'\n\ntrain_df = pd.read_csv(f'{ROOT}/train.csv')\nprint(f'Train data has {train_df.shape[0]} rows and {train_df.shape[1]} columnns and looks like this:')\n","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df.sample(10)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"To get an idea of the meaning of the weeks column, let's check some of their values.","metadata":{}},{"cell_type":"code","source":"train_unique_df = train_df.drop_duplicates(subset = ['Patient'], keep = 'first')\ntrain_unique_df.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"As we can clearly see, some patients took the first measure of FVC before and some after their baseline CT images.\n> the relative number of weeks pre/post the baseline CT (may be negative)","metadata":{}},{"cell_type":"code","source":"# CHECK FOR DUPLICATES & DEAL WITH THEM\n# keep = False: All duplicates will be shown\ndupRows_df = train_df[train_df.duplicated(subset = ['Patient', 'Weeks'], keep = False )]\ndupRows_df.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"We can eighter drop all except the first or last duplicate or average them.As there are only a few duplicates, we can drop them without a bad conciousness for loosing to much data for our first apporach.","metadata":{}},{"cell_type":"code","source":"train_df.drop_duplicates(subset=['Patient','Weeks'], keep = False, inplace = True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(f'So there are {dupRows_df.shape[0]} (= {dupRows_df.shape[0] / train_df.shape[0] * 100:.2f}%) duplicates.')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_df = pd.read_csv(f'{ROOT}/test.csv')\nprint(f'Test data has {test_df.shape[0]} rows and {test_df.shape[1]} columnns, has no duplicates and looks like this:')\ntest_df.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Data Wrangling","metadata":{}},{"cell_type":"markdown","source":"## Getting the format right","metadata":{}},{"cell_type":"markdown","source":"In this section we are going to do all the Data-Wrangling and pre-processing. For this we are going to define some functions and transformations, which then are applied to the data.\nIt's good practice to concatinate all tabular data (train, test, submission), to ensure all data get's the same & correct treatment.\nIf you don't do that, you need to be careful with some steps, e.g.: \n* Standardization or Normalization (e.g. MinMax Scaling) in ```test_df``` will not have the same range of values (e.g. min/max values) and therefore scaling than in ```train_df```.\n* The categorical features might have different categories in ```test_df``` than in ```train_df``` (e.g. ```test_df``` only contains male, Ex-smokers).\n\nSo let's concatinate all our data first and then start with the transformations.","metadata":{}},{"cell_type":"code","source":"## CHECK SUBMISSION FORMAT\nsub_df = pd.read_csv(f\"{ROOT}/sample_submission.csv\")\n\nprint(f\"The sample submission contains: {sub_df.shape[0]} rows and {sub_df.shape[1]} columns.\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"sub_df.head()","metadata":{"_kg_hide-input":true,"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"We need to get this into a format which we can easily use for making our predictions, so let's split up the ```Patient_Week``` column into a ```Patient``` and a ```Weeks``` column to align it with the train & test data-format.\nThen we merge our info from the test data to the ```submission_df```: that's the fastest way of getting the correct format for predictions and submissions later on.","metadata":{}},{"cell_type":"code","source":"# split Patient_Week Column and re-arrage columns\nsub_df[['Patient','Weeks']] = sub_df.Patient_Week.str.split(\"_\",expand = True)\nsub_df =  sub_df[['Patient','Weeks','Confidence', 'Patient_Week']]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"sub_df = sub_df.merge(test_df.drop('Weeks', axis = 1), on = \"Patient\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# introduce a column to indicate the source (train/test) for the data\ntrain_df['Source'] = 'train'\nsub_df['Source'] = 'test'\n\ndata_df = train_df.append([sub_df])\ndata_df.reset_index(inplace = True)\ndata_df.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"\nThe first big challenge is data wrangling: \nWe could see that some patients take FVE measurements only after their baseline CT-Images, and some took measurements before that.\nSo let's first find out what the actual baseline-week and baseline-FVC for each Patient is.  \nWe start with the baseline week:\n","metadata":{}},{"cell_type":"code","source":"def get_baseline_week(df):\n    # make a copy to not change original df    \n    _df = df.copy()\n    # ensure all Weeks values are INT and not accidentaly saved as string\n    _df['Weeks'] = _df['Weeks'].astype(int)\n    _df['min_week'] = _df['Weeks']\n    # as test data is containing all weeks, \n    _df.loc[_df.Source == 'test','min_week'] = np.nan\n    _df[\"min_week\"] = _df.groupby('Patient')['Weeks'].transform('min')\n    _df['baselined_week'] = _df['Weeks'] - _df['min_week']\n    \n    return _df   ","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"data_df = get_baseline_week(data_df)\ndata_df.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"What we can see here, is that the Patient with ID ending on \"430\" had his first FVC measure 4 weeks before the first (baseline) CT images ( = \"Weeks\" column -4) were taken. Then the patient took the next FVC measurement 9 weeks later. \nIn the next step we need to baseline the FVC values. Note, that the **BASELINE-FVC it not the minimum FVC**, but the first measurement, meaning the measurement taken in the \"min_week\" or ```baselined_week = 0```.\n\nFor getting the baselined FVC I first wrote the following straightforward function:","metadata":{}},{"cell_type":"code","source":"def get_baseline_FVC_old(df):\n    # copy the DF to not in-place change the original one\n    _df = df.copy()\n    # get only the rows containing the baseline (= min_weeks) and therefore the baseline FVC\n    baseline = _df.loc[_df.Weeks == _df.min_week]\n    baseline = baseline[['Patient','FVC']].copy()\n    baseline.columns = ['Patient','base_FVC']      \n    \n    # fill the df with the baseline FVC values\n    for idx in _df.index:\n        patient_id = _df.at[idx,'Patient']\n        _df.at[idx,'base_FVC'] = baseline.loc[baseline.Patient == patient_id, 'base_FVC'].iloc[0]\n    _df.drop(['min_week'], axis = 1)\n    \n    return _df","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"This apporach works fine, but as it contains a lot of look-ups, its slow and didn't feel right.  \nBtw: there is an even worse approach: Using ```for row in df.iterrows()``` is roughly 8 times slower than using ```for idx in df.index```.  \nSo I looked up how other people solved it and I found a rough equivalent to the following function:","metadata":{}},{"cell_type":"code","source":"def get_baseline_FVC(df):\n    # same as above\n    _df = df.copy()\n    base = _df.loc[_df.Weeks == _df.min_week]\n    base = base[['Patient','FVC']].copy()\n    base.columns = ['Patient','base_FVC']\n    \n    # add a row which contains the cumulated sum of rows for each patient\n    base['nb'] = 1\n    base['nb'] = base.groupby('Patient')['nb'].transform('cumsum')\n    \n    # drop all except the first row for each patient (= unique rows!), containing the min_week\n    base = base[base.nb == 1]\n    base.drop('nb', axis = 1, inplace = True)\n    \n    # merge the rows containing the base_FVC on the original _df\n    _df = _df.merge(base, on = 'Patient', how = 'left')    \n    _df.drop(['min_week'], axis = 1)\n    \n    return _df","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"The second apporach is using ```transform```, which is not as known as ```apply```, but faster for basic-operations not involving multiple columns of a dataframe. Here is an interesting post about it for those, who want to learn more:\n[Apply vs transform.](https://stackoverflow.com/questions/27517425/apply-vs-transform-on-a-group-object)\n\nIt still wasn't perfect and I found a **third, super-clean approach** [here](https://www.kaggle.com/c/osic-pulmonary-fibrosis-progression/discussion/179033):\n    \n","metadata":{}},{"cell_type":"code","source":"def get_baseline_FVC_new(df):\n    _df = (\n        df\n        .loc[df.Weeks == df.min_week][['Patient','FVC']]\n        .rename({'FVC': 'min_FVC'}, axis=1)\n        .groupby('Patient')\n        .first()\n        .reset_index()\n    )\n    \n    return _df","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"\nI wanted to know how much this speeds up the processing, you can find the results in the following:","metadata":{}},{"cell_type":"code","source":"def old_baseline_FVC():\n    return get_baseline_FVC_old(data_df)\n    \n\ndef baseline_FVC():\n    return get_baseline_FVC(data_df)\n\ndef baseline_FVC_new():\n    return get_baseline_FVC_new(data_df)\n    \n\nduration_old = timeit(old_baseline_FVC, number = 3)\nduration_baseline = timeit(baseline_FVC, number = 3)\nduration_new = timeit(baseline_FVC_new, number = 3)\n\nprint(f\"Taking the first, old & non-vectorized approach took {duration_old / 3:.2f} sec, while the 2nd, vectorized approach only took {duration_baseline / 3:.3f} sec. That's {duration_old/duration_baseline:.0f} times faster!\" )\nprint(f\"Taking the 3rd, newest, shortest and cleanest approach took {duration_new / 3:.3f} sec. That's {duration_old/duration_new:.0f} (!!) times faster!\" )","metadata":{"_kg_hide-input":true,"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Clearly, the third approach works best and I have learned a very clean way of processing data. ","metadata":{}},{"cell_type":"code","source":"data_df = get_baseline_FVC(data_df)\ndata_df.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Not the data has the format we need to work with.\nIn the next section, we go trough two possibilities on how to normalize, standardize and prepare the data for the neural Network.","metadata":{}},{"cell_type":"markdown","source":"## Preparing the data for the Neural Network","metadata":{}},{"cell_type":"markdown","source":"### The first apporach is using sklearn, as it is super famous and used frequently.","metadata":{}},{"cell_type":"code","source":"# import the necessary Encoders & Transformers\nfrom sklearn.preprocessing import OneHotEncoder\nfrom sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler\nfrom sklearn.compose import ColumnTransformer\n\n# define which attributes shall not be transformed, are numeric or categorical\nno_transform_attribs = ['Patient', 'Weeks', 'min_week']\nnum_attribs = ['FVC', 'Percent', 'Age', 'baselined_week', 'base_FVC']\ncat_attribs = ['Sex', 'SmokingStatus']","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"To get a ColumnTransformer which outputs the whole DataFrame compatible format, we can create a class that takes attributes that we don't want to change, and simply passes them through.\nThis class needs a ```fit``` and a ```transform``` method, so that the ColumnTransformer itself can use ```fit_transform``` like for the numerical and categorical attributes.\n\nAs I learned in a comment from @frederiklaubisch, sklearns' ColumnTransformer has a 'remainder' parameter that can be set to 'passtrough', which would eliminate the need for the NoTranformer.","metadata":{}},{"cell_type":"code","source":"from sklearn.base import BaseEstimator, TransformerMixin\n\nclass NoTransformer(BaseEstimator, TransformerMixin):\n    \"\"\"Passes through data without any change and is compatible with ColumnTransformer class\"\"\"\n    def fit(self, X, y=None):\n        return self\n\n    def transform(self, X):\n        assert isinstance(X, pd.DataFrame)\n        return X","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"## GET TRANSFORMED DATAFRAME\n\n# create an instance of the ColumnTransformer\ndatawrangler = ColumnTransformer(([\n     # the No-Transformer does not change the data and is applied to all no_transform_attribs \n     ('original', NoTransformer(), no_transform_attribs),\n     # Apply MinMax to the numerical attributes, here you can change to e.g. StdScaler()   \n     ('MinMax', MinMaxScaler(), num_attribs),\n     # OneHotEncoder all categorical attributes.   \n     ('cat_encoder', OneHotEncoder(), cat_attribs),\n    ]))\n\ntransformed_data_series = []\ntransformed_data_series = datawrangler.fit_transform(data_df)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Okay, now we encoded all the data and want to have a look at it. But wait, we only get back a series element? How to put that in a Dataframe again?\nSadly, not as easy as I had hoped. We need to use ```pd.DataFrame(data, columns=column_names)``` function, for which we need the column names. But we used OneHot-Encoding. So the number of columns now depends on how many different values/categories a categorical value has, because for each unique value we get a separate column: e.g. If for the column \"SmokingStatus\" we only have the values \"Smoker\" and \"Never-Smoked\", we have two resulting columns if there are additional possible values like \"Ex_Smoker\" we get more columns. And we also should not get things wrong and mix the columns up. The following code is getting our data back to a Dataframe and preserving the correct order.","metadata":{}},{"cell_type":"code","source":"# get column names for non-categorical data\nnew_col_names = no_transform_attribs + num_attribs\n\n# extract possible values from the fitted transformer\ncategorical_values = [s for s in datawrangler.named_transformers_[\"cat_encoder\"].get_feature_names()]\nnew_col_names += categorical_values\n\n# create Dataframe based on the extracted Column-Names\ntrain_sklearn_df = pd.DataFrame(transformed_data_series, columns=new_col_names)\ntrain_sklearn_df.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Okay wow, that was not as easy as I expected. The upside is, it's easy to add some additional features and pump them through the Pipeline or to change the Pipeline itself (e.g. exchanging MiNmaxScaler with StdScaler, RobustScaler etc).\nThe downside is: it's not intuitive (at least not for me) and takes quite some lines of code.\nDoes anybody have an idea on HOW to improve this? ","metadata":{}},{"cell_type":"markdown","source":"### The 2nd approach is doing all the legwork ourselfs.\nThe good thing is: we dont need a NoTransformer here, as we simply can work in the DataFrame itself and not change any data which we want to preserve.\nDownside is, we need to implement the MinMaxScaler by hand. Make sure to not call it MinMaxScaler and shadow the already important MinMaxScaler from Sklearn!\n","metadata":{}},{"cell_type":"code","source":"def own_MinMaxColumnScaler(df, columns):\n    \"\"\"Adds columns with scaled numeric values to range [0, 1]\n    using the formula X_scld = (X - X.min) / (X.max - X.min)\"\"\"\n    for col in columns:\n        new_col_name = col + '_scld'\n        col_min = df[col].min()\n        col_max = df[col].max()        \n        df[new_col_name] = (df[col] - col_min) / ( col_max - col_min )","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def own_OneHotColumnCreator(df, columns):\n    \"\"\"OneHot Encodes categorical features. Adds a column for each unique value per column\"\"\"\n    for col in cat_attribs:\n        for value in df[col].unique():\n            df[value] = (df[col] == value).astype(int)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"## APPLY DEFINED TRANSFORMATIONS\nown_MinMaxColumnScaler(data_df, num_attribs)\nown_OneHotColumnCreator(data_df, cat_attribs)\n\ndata_df[data_df.Source != \"train\"].head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# get back original data split\ntrain_df = data_df.loc[data_df.Source == 'train']\nsub = data_df.loc[data_df.Source == 'test']","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Okay, so the second apporach (using our own implementation) was more straightforward and less code.  Downside: if you want to replace the MinMaxScaler with another scaling method (RobustScaler, StdScaler), you need to implement it first.","metadata":{}},{"cell_type":"markdown","source":"# Model & Loss\nIn this section we are going to define the loss & a first model.\nFirst we are taking care of the loss. We are trying to minimize the following:\n\n![image.png](attachment:image.png)\n\nThe global minimum of this function is achieved for delta = 0 and sigma = 70, which [results in a loss of roughly -4.59.](https://www.kaggle.com/c/osic-pulmonary-fibrosis-progression/discussion/168469).\n\nGetting our model to predict the Confidence and FVC values (which is what we need!) is not working fine so far, as you can read [here](https://www.kaggle.com/c/osic-pulmonary-fibrosis-progression/discussion/167764).\nCurrently the way to go seems to be pinball loss. \n","metadata":{},"attachments":{"image.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"# <font color='blue'>CONFIG Section </font>","metadata":{}},{"cell_type":"markdown","source":"In this section you can configure the following:\n* Features used for training\n* Basic training setup: BATCH_SIZE and EPOCHS,\n* Configuration for the loss function\n* Optimizers, Learning-Rate-Schedulers incl. Learning Rate start- & endpoint\n* Custom Logging Callback\n* Checkpoint-Saving Callback\n\nThe Learning-Rate scheduler below is inspired by Chris great [Melanoma-detection notebook](https://www.kaggle.com/cdeotte/triple-stratified-kfold-with-tfrecords).  \nFeel free to experiment with the scheduler and it's max/min and decay values.\n\n**Ever wondered why lr_max is scaled by BATCH_SIZE and therefore bigger for larger batches?** The reason for this is the following: the larger the BATCH_SIZE, the more averaged & smoothened a step of gradient decent is and the bigger our confidence in the *direction* of the step is. As there is less \"randomness\" in a huge averaged batch (compared with for example Stochastic Gradient Decent (=SGD) with batch size = 1) and our confidence in the direction is higher, the learning rate can be bigger to advance fast to the optimum.","metadata":{}},{"cell_type":"code","source":"######## CONFIG ########\n# be careful, the resulsts are very SEED-DEPENDEND!\nseed_everything(1989)\n\n\n### Features: choose which features you want to use\n# you can exclude and include features by extending this feature list\nfeatures_list = ['baselined_week_scld', 'Age_scld', 'base_FVC_scld', 'Male', 'Female', 'Ex-smoker', 'Never smoked', 'Currently smokes']\n\n### Basics for training:\nEPOCHS = 1500\nBATCH_SIZE = 128\n\n\n### LOSS; set tradeoff btw. Pinball-loss and adding score\n_lambda = 0.8 # 0.8 default\n\n\n### Optimizers\n# choose ADAM or SGD\noptimizer = 'SGD'\n\n### Learning Rate Scheduler\ndef get_lr_callback(batch_size = 64, plot = False):\n    \"\"\"Returns a lr_scheduler callback which is used for training.\n    Feel free to change the values below!\n    \"\"\"\n    LR_START   = 0.001\n    LR_MAX     = 0.0001 * BATCH_SIZE # higher batch size --> higher lr\n    LR_MIN     = 0.000001\n    # 30% of all epochs are used for ramping up the LR and then declining starts\n    LR_RAMP_EP = EPOCHS * 0.3\n    # how many epochs shall L_RMAX be sustained\n    LR_SUS_EP  = 0\n    # rate of decay\n    LR_DECAY   = 0.993\n\n    def lr_scheduler(epoch):\n            if epoch < LR_RAMP_EP:\n                lr = (LR_MAX - LR_START) / LR_RAMP_EP * epoch + LR_START\n\n            elif epoch < LR_RAMP_EP + LR_SUS_EP:\n                lr = LR_MAX\n\n            else:\n                lr = (LR_MAX - LR_MIN) * LR_DECAY ** (epoch - LR_RAMP_EP - LR_SUS_EP) + LR_MIN\n\n            return lr\n    \n    if plot == False:\n        # get the Keras-required callback with our LR for training\n        lr_callback = tf.keras.callbacks.LearningRateScheduler(lr_scheduler,verbose = False)\n        return lr_callback \n    \n    else: \n        return lr_scheduler\n    \n# plot & check the LR-Scheulder for sanity-check\nlr_scheduler_plot = get_lr_callback(batch_size = 64, plot = True)\nrng = [i for i in range(EPOCHS)]\ny = [lr_scheduler_plot(x) for x in rng]\nplt.plot(rng, y)\nprint(f\"Learning rate schedule: {y[0]:.3f} to {max(y):.3f} to {y[-1]:.3f}\")\n\n\n# logging & saving\nLOGGING = True\n\n# defining custom callbacks\nclass LogPrintingCallback(tf.keras.callbacks.Callback):\n    \n    # defining a class variable which is used in the following\n    # to ensure LogPrinting, evaluation & saving is consitent\n    # choose between 'val_score' and 'val_loss'\n    optimization_variable = 'val_loss'\n    \n    def on_train_begin(self, logs = None):\n        #print(\"Training started for this fold\")\n        self.val_loss = []\n        self.val_score = []        \n        \n    def on_epoch_end(self, epoch, logs = None):\n        self.val_loss.append(logs['val_loss']) \n        self.val_score.append(logs['val_score'])\n        if epoch % 250 == 0 or epoch == (EPOCHS -1 ):\n            print(f\"The average val-loss for epoch {epoch} is {logs['val_loss']:.2f}\"\n                  f\" and the score is {logs['val_score']}\")\n            \n    def on_train_end(self, logs = None):\n        # get index of best epoch\n        monitored_variable = self.val_loss if LogPrintingCallback.optimization_variable == 'val_loss' else self.val_score\n        best_epoch = np.argmin(monitored_variable)        \n        # get score in best epoch\n        best_result_loss = self.val_loss[best_epoch]\n        best_result_score = self.val_score[best_epoch]\n        print(f\"Best model was found and saved in epoch {best_epoch + 1} with val_loss: {best_result_loss} and val_score: {best_result_score} \") \n        \n        \ndef get_checkpoint_saver_callback(fold):\n    checkpt_saver = tf.keras.callbacks.ModelCheckpoint(\n        'fold-%i.h5'%fold,\n        monitor = 'val_score',\n        verbose = 0,\n        save_best_only = True,\n        save_weights_only = True,\n        mode = 'min',\n        save_freq = 'epoch')\n    \n    return checkpt_saver","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Loss Function","metadata":{}},{"cell_type":"code","source":"# create constants for the loss function\nC1, C2 = tf.constant(70, dtype='float32'), tf.constant(1000, dtype=\"float32\")\n\n# define competition metric\ndef score(y_true, y_pred):\n    \"\"\"Calculate the competition metric\"\"\"\n    tf.dtypes.cast(y_true, tf.float32)\n    tf.dtypes.cast(y_pred, tf.float32)\n    sigma = y_pred[:, 2] - y_pred[:, 0]\n    fvc_pred = y_pred[:, 1]\n    \n    sigma_clip = tf.maximum(sigma, C1)\n    # Python is automatically broadcasting y_true with shape (1,0) to \n    # shape (3,0) in order to make this subtraction work\n    delta = tf.abs(y_true[:, 0] - fvc_pred)\n    delta = tf.minimum(delta, C2)\n    sq2 = tf.sqrt( tf.dtypes.cast(2, dtype = tf.float32) )\n    metric = (delta / sigma_clip) * sq2 + tf.math.log(sigma_clip * sq2)\n    return K.mean(metric)\n\n# define pinball loss\ndef qloss(y_true, y_pred):\n    \"\"\"Calculate Pinball loss\"\"\"\n    # IMPORTANT: define quartiles, feel free to change here!\n    qs = [0.2, 0.50, 0.8]\n    q = tf.constant(np.array([qs]), dtype = tf.float32)\n    e = y_true - y_pred\n    v = tf.maximum(q * e, (q-1) * e)\n    return K.mean(v)\n\n# combine competition metric and pinball loss to a joint loss function\ndef mloss(_lambda):\n    \"\"\"Combine Score and qloss\"\"\"\n    def loss(y_true, y_pred):\n        return _lambda * qloss(y_true, y_pred) + (1 - _lambda) * score(y_true, y_pred)\n    return loss","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Neural Network Model\nIn this section we build an initial neural Network. The code of this section is derived from [Ulrich's](https://www.kaggle.com/ulrich07) great [notebook](https://www.kaggle.com/ulrich07/osic-multiple-quantile-regression-starter), which also inspired me to change my loss to the above coded version. Please support the original Notebook creators! The chosen quartiles are simply derived by testing; using 0.25 and 0.75 leads to worse results.\n\nFor the architecture: It's good practice to use numbers of units following the schema 2^x, with x element of N (= resulting in 1, 2, 4, 8, 16, 32, 64, 128,..).  \nWe are going to use dropout for regularization and not a too broad and deep network, as the training data is very limited.\n\n### Normalization & Regularization\nWe are going to use weight-normalization (link to the paper, click [here](https://arxiv.org/abs/1602.07868)) from ```tensorflow_addons``` to support faster convergence. \nThe authors describe the method like this:\n> Weight normalization: a reparameterization of the weight vectors in a neural network that decouples the length of those weight vectors from their direction. By reparameterizing the weights in this way we improve the conditioning of the optimization problem and we speed up convergence of stochastic gradient descent. Our reparameterization is inspired by batch normalization but does not introduce any dependencies between the examples in a minibatch.\n\nAdditionally we gain more robustness for the choosing of the hyperparameter learning rate. Cited from page 3:\n> Empirically, we find that the ability to grow the norm ||v|| makes optimization of neural networks\n> with weight normalization very robust to the value of the learning rate: If the learning rate is too\n> large, the norm of the unnormalized weights grows quickly until an appropriate effective learning rate\n> is reached.\n\n### Activation function\nAs the given task without the usage of images is not very compute-intensive (you don't need a GPU, CPU will do), we will change the activation-function from 'relu' to 'elu'.\nFor more info you can read [here.](https://mlfromscratch.com/activation-functions-explained/#elu), below you can find a short summary:\n\n**Pros**\n* Avoids the \"dead ReLu\" problem: ReLus provides activation-values & gradients of 0 for negative input values\n* Produces activations for negative inputs instead of letting them be zero when calculating the gradient.\n* Produces negative outputs, which helps the network nudge weights and biases in the right directions for negative inputs, too.\n\n**Cons**\n* Introduces longer computation time, because of the exponential operation included.\n* Does not avoid the exploding gradient problem.","metadata":{}},{"cell_type":"code","source":"import tensorflow_addons as tfa\n\ndef get_model(optimizer = 'ADAM', lr = 0.01):\n    \"Creates and returns a model\"\n    # instantiate optimizer\n    optimizer = tf.keras.optimizers.Adam(lr = lr) if optimizer == 'ADAM' else tf.keras.optimizers.SGD(lr)\n    \n    # create model    \n    inp = Layers.Input((len(features_list),), name = \"Patient\")\n    x = Layers.BatchNormalization()(inp)\n    x = tfa.layers.WeightNormalization(Layers.Dense(160, activation = \"elu\", name = \"d1\"))(x)\n    x = Layers.BatchNormalization()(x)\n    x = Layers.Dropout(0.3)(x)\n    x = tfa.layers.WeightNormalization(Layers.Dense(128, activation = \"elu\", name = \"d2\"))(x)\n    x = Layers.BatchNormalization()(x)\n    x = Layers.Dropout(0.25)(x)\n    # predicting the 3 quantiles\n    q1 = Layers.Dense(3, activation = \"relu\", name = \"p1\")(x)\n    # generating another output for quantile adjusting the quantile predictions\n    q_adjust = Layers.Dense(3, activation = \"relu\", name = \"p2\")(x)\n    \n    # adding the tf.cumsum of q_adjust to the output q1\n    # to ensure increasing values [a < b < c]\n    # tf.cumsum([a, b, c]) --> [a, a + b, a + b + c]\n    preds = Layers.Lambda(lambda x: x[0] + tf.cumsum(x[1], axis = 1), \n                     name = \"preds\")([q1, q_adjust])\n    \n    model = tf.keras.Model(inputs = inp, outputs = preds, name = \"NeuralNet\")\n    model.compile(loss = mloss(_lambda), optimizer = optimizer, metrics = [score])\n    \n    return model","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### What about those mysterious quantiles (q1) and quantiles_adjustment (q_adjust) layers?\nThe idea of the q1 layer is to actually predict the 3 quantiles. As you can see in the loss function and in the neural network output: we expect 3 values, one value for each of the defined quantiles.\n\nThere are 2 reasons for the q_adjust layer:  \n* First: With adding the cumulative sum on top of q1, we ensure (or at least very strongly support) that the output (preds) are in increasing order.\nLet's consider two arrays/vectors: ```q1 = [a, b, c]``` ```q_adjust = [e, f, g]```. Then our output preds are ```q1 + tf.cumsum(q_adjust) = [a + e, b + e + f, c + e + f + g]```\n* Second: We can see q_adjust as a *baseline* which is added to the q1 layers. It adds additional degrees of freedom (more neurons == more trainable weights), which provides better results. Theoretically we could also use only q1 and add tf.cumsum(q1), then we would guarantee that we have an increasing order, but we have less degrees of freedom and the OOF-Score and LB score is worse.","metadata":{}},{"cell_type":"code","source":"# create neural Network\nneuralNet = get_model(optimizer, lr = 0.01)\nneuralNet.summary()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"## GET TRAINING DATA AND TARGET VALUE\n\n# get target value\ny = train_df['FVC'].values.astype(float)\n\n\n# get training & test data\nX_train = train_df[features_list].values\nX_test = sub[features_list].values\n\n# instantiate target arrays\ntrain_preds = np.zeros((X_train.shape[0], 3))\ntest_preds = np.zeros((X_test.shape[0], 3))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Training\nIn the following we want to create leak-free folds to get a robust **cross-validation strategy** in order to evaluate all our models & our training. The idea is to avoid having the same patient (= PatientID) in training- and in validation-Data, as this might lead to evaluate a higher CV-score for a model which is luckily learning/memorizing the data for a particular patientID which is also frequently occuring in the validation-data.  \n\n\nThe idea on how to do that is coming from @PAB97 [Pierre's great notebook (CHECK IT OUT!)](https://www.kaggle.com/rftexas/osic-eda-leak-free-kfold-cv-lgb-baseline#kln-440)\nPlease note, that we still don't use propoer stratification based on 'Age', 'Sex', 'SmokingStatus'.","metadata":{}},{"cell_type":"code","source":"## Non-Stratified GroupKFold-split (can be further enhanced with stratification!)\n\"\"\"K-fold variant with non-overlapping groups.\nThe same group will not appear in two different folds: in this case we dont want to have overlapping patientIDs in TRAIN and VAL-Data!\nThe folds are approximately balanced in the sense that the number of distinct groups is approximately the same in each fold.\"\"\"\n\nNFOLDS = 5\ngkf = GroupKFold(n_splits = NFOLDS)\n# extract Patient IDs for ensuring \ngroups = train_df['Patient'].values\n\nOOF_val_score = []\nfold = 0\n\nfor train_idx, val_idx in gkf.split(X_train, y, groups = groups):\n    fold += 1\n    print(f\"FOLD {fold}:\")\n    \n    # callbacks: logging & model saving with checkpoints each fold\n    # callbacks = [get_lr_callback(BATCH_SIZE)]  # un-comment for using LRScheduler\n    reduce_lr_loss = tf.keras.callbacks.ReduceLROnPlateau(monitor = 'val_loss',\n                                                          factor = 0.6,\n                                                          patience = 150,\n                                                          verbose = 1,\n                                                          epsilon = 1e-4,\n                                                          mode = 'min',\n                                                          min_lr = 0.00001)\n    \n    callbacks = [reduce_lr_loss]\n    \n    if LOGGING == True:\n        callbacks +=  [get_checkpoint_saver_callback(fold),                     \n                     LogPrintingCallback()]\n\n    # build and train model\n    model = get_model(optimizer, lr = 0.005)\n    history = model.fit(X_train[train_idx], y[train_idx], \n              batch_size = BATCH_SIZE, \n              epochs = EPOCHS, \n              validation_data = (X_train[val_idx], y[val_idx]), \n              callbacks = callbacks,\n              verbose = 0) \n    \n    # evaluate\n    print(\"Train:\", model.evaluate(X_train[train_idx], y[train_idx], verbose = 0, batch_size = BATCH_SIZE, return_dict = True))\n    print(\"Val:\", model.evaluate(X_train[val_idx], y[val_idx], verbose = 0, batch_size = BATCH_SIZE, return_dict = True))\n    \n    ## Load best model to make pred\n    model.load_weights('fold-%i.h5'%fold)\n    train_preds[val_idx] = model.predict(X_train[val_idx],\n                                         batch_size = BATCH_SIZE,\n                                         verbose = 0)\n    \n    # append OOF evaluation to calculate OFF_Score\n    OOF_val_score.append(model.evaluate(X_train[val_idx], y[val_idx], verbose = 0, batch_size = BATCH_SIZE, return_dict = True)['score'])\n    \n    # predict on test set and average the predictions over all folds\n    print(\"Predicting Test...\")\n    test_preds += model.predict(X_test, batch_size = BATCH_SIZE, verbose = 0) / NFOLDS","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Evaluation & submission\n\n### Check loss and accuracy\nOkay, we made it! Let's evaluate our model, check our stats (Out-Of-Fold log-loss) and submit it! Let's start with some plots.\nThose plots can tell us, whether our model training is working as expected, or if it strongly overfits.  \nThe below **EXAMPLE-IMAGE** is an example of a strongly overfitting model:\n![image.png](attachment:image.png)\nLong before we hit the 10th epoch, the validation loss is increasing again, while the training loss keeps decreasing. We can also clearly ovserve that there is no improvement in our accuracy anymore. \n\nWhat can we do against strongly overfitting models?\nWe could do the following:\n\n* Collect more training data or use augmentation to generate new data: Sadly I have no brilliant idea on how to do this for this specific Kaggle competition.\n* Reduce the network’s size (width andor/ dept) by removing layers or reducing the number of neurons in the hidden layers\n* Use regularization like LASSO (=Least Absolute Shrinkage and Selection Operator; aka L1 regularization) or Ridge (aka L2 regularization) which results in adding a cost-term to the loss function\n* Use higher dropout-rate in the Dropout-Layers, which will randomly remove more connections by setting them to zero and forcing the network to generalize better (=avoid relying on a limitied number of strong-influence neurons).\n\nBut now check our model's result and evaluate it:","metadata":{},"attachments":{"image.png":{"image/png":"iVBORw0KGgoAAAANSUhEUgAABjsAAAGxCAYAAAA0zAT6AAAgAElEQVR4Aeydd3RV15X/549ZK1mTrJk1yfg34xlnjTOJUyeesZM4ieOxEzvYxtjGlWaDbWx6Fd10gei992qa6c00UUSRRJWoEqKD6UgCNZrK/q3PEUe6XF7Xk9AT+6x1ee/dd+4p33Oe2Ht/z97770SLIqAIKAKKgCKgCCgCioAioAgoAoqAIvCII1BUVCRFIpKfXyC5ebfkWvp1SUk7JfsPpUnyweJr3/5USdh9QLYnJAV0UZdnkg8eNW3RZm7eTSkoKHzE0dbpKwKKgCKgCCgCioAiEH4E/i78TWqLioAioAgoAoqAIqAIKAKKgCKgCCgCikDkIAD5AAmRnZNXQnLs25/yILGRmCxbduyRxSs2yoy5K2XMlAXSp9tgGTpwvHnPZ64J0xfJ8jVxsg1SJDHZECPFxEeKIT0yMrOkoKDAkCuRg5KOVBFQBBQBRUARUAQUgcqNgJIdlXt9dHSKgCKgCCgCioAioAgoAoqAIqAIKALlhACeHJAOkA+px04bDwyn9wZkRWzcLpk6Z7khNaLaxUjztn1lUMO2Mu2d+rLyTy9L2hM/lvhfPWve85lryYvVpVfTztIqqq8hQtbGxhcTHwlJEr/rgBxOPWFIFfXyKKeF1WYVAUVAEVAEFAFF4JFEQMmOR3LZddKKQOVBgHABN27ckEuXLkl2drbk5+cHNbicnBy5cuWKaePu3btBPRsplVHAwYfr5s2bAmYVUegnKytLLl68aF5ZGzC265Wbm+tzLKzN5cuX5fr16+a5cIyZMWRkZMiFCxfkzp074WhS21AEFAFFQBFQBBSBRxQB681BaCnIB0gIE54qMdkQE3MXrZHBMWOldZto+apGLUNqZH3v+yJ/93cBX3nf+a4hQjq17GlIjw1bEk3b8bv2m/BWhMmCaMkvKHhEV0GnHU4EkJXT09Pl6tWr4k9W99QvcjvPIsejg1TFgg5x/vx5uXbtmty+fdunPhPO+YMna4N+BL6FhYWm/8zMTKPn+dJt0MtYG55FPwtWZ/Y0D9pEt0PHRJ+uquvtae56TxFQBKo2Akp2VO311dkpApUeAYS6RYsWSefOnWX16tVGAAx00AiI33zzjURHR5s2ENQqiggIdIzhqIdxv3v37tKtWzfZu3dvWITbQMaFEL1s2TJp27atLF261AjBEB/z58+Xjh07yvbt242Q7q2tjRs3Ss+ePWXevHny7bfflnltWFuUkjFjxkizZs0kLS3NW9d6XxFQBBQBRUARUAQUAZ8IQC5AMkA24MkB+YAXB9ekCXMED47R9ZrI7p//JmBiwx8JgvfHl616ysxZS00/ECvWy8MQHvlV07jscyH0y7AigN4wevRo6du3r2zdulVu3boVcPsYvqdPny4DBgyQ9evXG+N6wA9HUMVTp05Jo0aNjE6BPoFOWREFsmLs2LFGp0NPysvLk9TUVJkyZYp06NBBjh496nUYEBGzZ8826xqszuytUXQ9dLROnToZfZoDbVoUAUVAEagKCCjZURVWUeegCJQTAhi6+/TpU3L16tXLGK979+5t7vE6btw42b17d8jCMEIWBvzFixfLwYMHzSmXQKeD8fvQoUOycuVK0wanXKpi4QRPnTp1pHbt2hIXF2dOADnnifB75swZQ/yA47lz55xfm/fUQfmZOXOmrFq1KqATQSg8kydPlho1asikSZNMu3jfsN4QVMeOHfNJYFDn448/luHDh8uJEyd81nUPmHWdOnWq7NmzRzjtZAunoDZt2iRfffWVOdlk71fkK1gyrqFDhxp8lHSpSPS1L0VAEVAEFAFFoOwIWKLD6c0BybF6/Xbp2XmALK5WU4L14PBHdNjv8fSY+v4nMnHE1BJyBcID0oWQVhXjv1t2DLWF4BBAhkUOR59Cv+KwFoeC+Mx7q3NBNhw5csR4ZQTXQ3FtvDmQlTGII6MizwdakHF37Ngha9asMWPAo7wqFvD985//bIz8ycnJD5AdHMZLSUkxh77QM9F/3AWC5OTJk4aoiI+PN973/kgTvDq6dOli9LqFCxeadjmsxwEyPqPzeSuszeDBg+Wzzz4z+4jnAi3ozKwrupVzbzFeCBh0NuZZkett9xqH2Nin4fBUCRQPracIKAJVHwElO6r+GusMFYGQERg2bJi8+eab8tZbb0n16tXlZz/7mTz22GPy3HPPyeuvvy5vvPGGNG3a1AjTuL46SzAeFtRF2ArmGdsXz9jL3qtqr2Bbt25dIxh7IzsOHDggkE+1atUSTgpRnHhCBCUmJpo1Q8iGQPAnVKIccdKIPQDpYUkU2g1kvRCc69evHxLZsWTJEvnrX/9qhHKIHGex/TvvVeR7sIPA+fd//3d59tlnjXIClk68K3I82pcioAgoAoqAIqAIBI6Ak+hI2HWghHDAm6NX865y8vEfhc2TwxIcnl6XVnu7hPDAwwPvEsJpYQTUUvUQQH5EBkeHQrf629/+ZmTJH/3oR8bwzuEiZG68pzFMY4QOtSCT2ivYNuxzVVmuxeD/wgsvmMgCnsgOPC62bdsmrVq1kgYNGjxwaAts8IJA16lWrZrRlwIJGQbZ8eWXXxq9zpIdrA/t+SNK+H7IkCHSsGHDkMiOESNGyMsvvyzLly83nvLOfUHb/vp31g/He/RMbA1PP/20OYhHODEtioAioAiECwElO8KFpLajCFRBBDiBRNggPALOnj0rUVFR8sc//lHmzJkjp0+fLokHi/COizRCCsIhwh7GX4Qm5z2+o55biaMu9azBmOcQgLjHxTO0yfOctHEK3zzDPeeztj37PM/ZZ92CnHOMdny0x8UYnH25l5jvqMcpGDs+3rufs31QlzFRh754teO2bdMm9+ycqYN7MZ4dXJ7IDp6hfwTuF1980QjcNg6sbRfPCoTcd999VyZOnBjQ2jAPN9lBX3ZtnOvIHJmfxZrxL1iw4AGyw2JBPYsZdZmzLbwn9BUnrjjtg0JCffqlT155hrZsca+FXQdnHZ61a+BvHWy77lfa279/v7Rp00b+4R/+QZ544gnp37+/IYKcePCce0zMgX6d9WjP4ubEgzoWa/dcaZtnuGw92w7tc9+9x8DM3qMf3lOPPtzF7j+7Rrausw/eOwvt0DeXpzaddfW9IqAIKAKKgCLwsBDwRHRs2bFHenYZZLw57v7931cI0WHJj4WvvyeTx80yhEvC7uKk5Zq/42HtjvLtF9kJAzn5MCAy8GKG4Pjggw/MwTFO6vOd/R75j8vKbch8nmQ0ZC+nXIYc5klOtPIz9ZHtbLu06ZTdqOeWMbln5TzGhIxIG9x3PguCjNPWoR7vaY/n6ctXYR7UszKofd79HJ+pZ9ulnq1L/87C+BinnTPj4ZCYL7KD9lmrfv36yV/+8hfZsmXLfdEH6CMpKcmEo/rwww8lNjb2vnlbmZ4xOtfGE9nB9xZfZ10nFnZ+gwYNuo/sYG5OvJ39Whyow5x5ljmjY3GQzK6f7QcsnWtp79O3p71CXXCya+BcN/qz/TvXwvmeOUPe/PrXvzZeJTzvrdCPXT/GQ113+4HgQDuMjflYrNzz9jYGva8IKAKRhYCSHZG1XjpaReChIYBgQc6I//u//zMCCQIC3gJ4EZDTgXBWxCBt2bKlMarv27fPnIIZNWqUtG7dWr744gtzOoYYsLt27TLPMhkEjHXr1hm3XAz5CP8kn16xYoXExMSYdnHZbdKkiWmHWKW4DCOsIGTxDP3SBgIkz65du9YIdMSr5WrRooUZF94JuCTTJ4U58XnkyJHGeE09hFo7F/JUeItdigCIMoLASJxTxoeXS9euXc2JGb6jDoU+EDAJBcVYyU9CzgliszJPyCTmwsVzGzZsMK7sxJLl9A/PvPLKK1KvXj2PZIfpRMTgSqgr2ifUlJ0n33NCDK8P1gKs8NKgXYz2rA3rRmxf6tk5I4S6yQ7GRxgs5kMoJ+ZIPeLN4nZPO1wIr8yPPiFZIFsQUlk7cOA75te8eXODOfsIF3HGzEmqzz//3Jx2e/75500bYAxWYAnmuPwTb5eCwMt7XLOpxzrQPqScDbVFu2DCGBkPcwfbxo0bm1N2KCmsg79CX3PnzpVPP/3UEEt4n7CWuPszP1t4z5xnzJhhxgLGYE+/nCCjHdYbZQuM+Q2xh9iDeI0Qs5ffF3PGYwdy0RbmwtzYz6wB60V9QnsNHDjQ4As+5Hn5+uuvDWbEXeb3C97g3r59e3MqDBLT7lNeIS4JfcBvj3VkTJxCxNOGRI78/uz47P5CuSCXC8QUvyV+h8xNiyKgCCgCioAiUJkQyM8vztFB6Crr0QHRMajbYDn01K8qlOSwZAevgxq2lcUrNhYTHrschIfm76hM2yfsY0Gu4hASIV8JY4Q8hR6DzIVHAfIh8jayOjIfsuDOnTtNPg1kT2TYdu3aCbrW4cOHjRGXQaJLzZo1y8icyL7IpIQJQn4mXBaHngiZhayNjIesafMeol8REpc6VidAdudAFWMZP358Sf/IrngnMC4r99lwtxwEQubkoBzPTZgwwehkmzdv9kp4IIceP37c1KVt5odczFh5zoYrBidykaBrTJs2zcilyLX0R1gw9Aj0VAp10XmYE3NFHkfXQxd45plnvHp22Pkg87/33nsmdC26jr2PDMyhLtYP3Y9QzByGYq5W1mYOeC5wH52T4onsAF/kdXRkq9uwZoR5Rq5GrwFH5GzG/8knn5R4djBP+kY2t/o2+4V+eZ52qMOeeuedd+Rf//VfjXcHOiV6H/oXuhL1ad+G6+IZ9hR7i75ZC7Blr7BHwYE5oT+xT8GTuqwDeobV9+06mMm7/gmE7GD90HPol/7RSxgPfWFPYH4Uxs1vgznx27G6LfVsuGF0HKtXgSl1GC+5KDncyXi0KAKKQNVBQMmOqrOWOhNFoFwRQFhxkx3EFYUY+I//+A8jCGJoRmjAoIsRlhMvGFwR+hBWMRC//fbbRshEQKFwugJBjpNNCKwI2wiTGHj/93//13gGYLxHKEHYJE4p9fBcoGC8RmBDmMFwizGcXAp/+tOfzEkp2z+nbvCMQNi2Rm08BniO51E0EBIx8DJGXMtRCLzFTkUZoD/GzvwQrBAEa9asadoh7imYIQxCyLz66qtmjtTBEM8rfSAII5Rj/EZopC7uyYR/QghDoAO7X/7yl8IcOFlEXU+FUzoYuTkhBkZWAKQ+gtzPf/5zI8hiGOc0GXXt2oArLvXcI+4sxU124GGCQI5ygQs+OV2og+COkMu4wZE2GTdY4C4NWcVzCKsI/CgZ4MW8mOP7779vSIqEhASjyBBui/XGawIyAfdxBFyS0UMU4N4PCQKhRqFtBG3mgAJA/7SLEgexAkGDEAx5xfe0yVqjIPKZvQfxwTpYJcY07OEf2qEupBJYMRb2CySDJYloA8EaQZ95gAv7irWmHgotdSFDUE4YtyU6GDtKHYoL46YNPFzsXBkS+4Sxo0ywBuxRFFL6Yt+zt/gdsn9RTnkWBZcxcKEg81tg7ty3Sgv7hX2LMshvgvZYJ+ZIjGmUWdbuo48+Msot605hn6N02rUn7Jo/HD1Aq7cUAUVAEVAEFAHz/wd0ucerDEQ67ZEPg7wY5MewicgH9xklO3/9zEMjOiA7yOHRs1V3WRsbb8al+TsejR+Cm+xAt0CPQXf54Q9/aPQmZDD0IPQd5EYOdCHjIUMjMyJ7YcRGH7PJrdGlMHgjr2HkRmdCTkT25RQ9ciA6G/IpuhUyKDI2Mj1GfORbZFMO1iBjQpgwBrz7uY8+iJxNv7SBrIlRGtkPgzPyJ3Iyeh+yL/KqDX+MvG4Py7hXmf7RHXmeMSKzIssjZ1sSA4yoh1yKjoGuQT3kYsbGPWRVDhNZQzlEAroEuhVzpS7t/ud//qfB0lMYKzs2dBPqo4NxGM0WDOcY1n/729+aQ1DI0hwWAlfWhfWhT3QrdEX0LoonsgOdGExfe+01Q1BQj7UGB9YXeZ05oltx+A3cmT/rjE6LDM6eoU8ucIeEQV9Dn0B3Qb5H3yIEL6GpmT/fQyKBOeNE9reyPZigT9M/a8x68Ap+hMGCUKMupBjYMC70W9abtWdfQXixn70V1pEx+PLsgIRgbzJ39jPzQz9Bj7H6EiQZ40UXZbyMEbzY7+wFMGAvQP4wD/YB7aDj8DtBZ0bH9aZfexu/3lcEFIHKjYCSHZV7fXR0ikClQcAb2cEpEARyckogjCAoYDRFsMb4jgCHMIaQgbCBIRUBDIGEAtmB9wXCKqfgqYuhGKHvySefNMINbSBUYdjFkI+wxklyCsIeQgvj4OQORAmCE+QAghyGc4yvCKgIY1z2tD+GXuKsciKHevRBPQS+//mf/zFCrC+yA2M0pA59IrjTDyeeEMAQdBF8KRjR6QfXYYzdjJ2xIrgjEEIGIDRjTOZkza9+9SvjpUDfYMgpIQRyjPKQHd6UBE48cXKJUFYI5lZghZShD9pgjRB6EepQSFC0WBvm0KNHDyNA0x+CI0IoSonN2cEznDhijNzjdAx9YkxHiUH45D1ryEkh5gaOCLs8Z/cEwibzon3GhrKA4I5h364rigleRAjRCPwoUIyT8aL4MUeEcwpCN+NBYEVoh0hgz6AcILhzj7VB0Gf//O53vzN7DbzZC6wJexKhnnl7K4wXYgVvFdpFuUDBQ7GiL+bEOMGX++xB9hZjYZ+zv9jb4MjeYN+DEWvFOHiOPUUdXlk/1uKll14qmStjg+wAA/BmDdgnEFQoNxCECPYovPwOqct6cDoLook++C3jnUN9lFXwYU+BLfeYH4I/n2mDV8YErjyHko0yxz0Ka4YihwIBmcgzWhQBRUARUAQUgUAQ4P9NS2zgeQEhkZ2T6/Hiu4IC7/9P++qPtsmHQV4M8mNAdowaME42P/fiQyU6rIcHeUL6dO4veJo483cwbi1VEwHkK+RPDLQchMGQjzzOoZrvfe97xnCMrM595DlkOIzH1qsXeQsdg0MuyG54WVCQ+5AtMbajOyF/IydSjwNq6ATIicjGyPnoJ/RJPeRBjMjIh+hJyJj0h7EZozT6Gc8iyyKrc4CIvpAtkXWRpZGLeWUuGOPR1SBKkOvxwvakx/B3gPu0i06GnoROif7AeJgfego4II/jzcy46QvvC+RmsGGOkB7IsdRF98TwjSzt1FuQo3/wgx+Y73yRHYwDr5r//u//Nq/MkbFCXtAXOoX1oECWhxhCp2PszAPZGN0Tz2gKsj1YozfbnB08g06InocexTowVrDlPu2CC8QVIbXAEfKLdUYP43t0ItaKvcJ8MOSjY4A3Y0aHYk3Qn9AVqUsBS7xp0MPRpxkfddFn0V05fEjb9MOY0JFZb+bM/gEb6jGm1atXG/2G79ATIKnYf94KffsjO5gLvw/WlDXnN8D+Ywzojhxq4x5eNqwH42VtmAN6C3XRv9iHHPxj/uix7Bd0PjBkjVkzntGiCCgCVQcBJTuqzlrqTBSBckXAG9mBF8f/+3//z5AXCA4UhEAECJ5BEEJwQkhCYEVQI7E5QiYFAcwT2cFpFk7LINjwLO1hTEaQQWBFeEGgw03bTXZwWp7T8HhtMAaEFwyyGMPxsMD4jGCEgEWydcI6IRAxbozvnI7h1AuhfKwwaAbr+McK5cyNefM8dVFWOC2C8Z35UjCKI8BinCbcEeNBkMUgDinCSRjagMjg5BRkCSeJmDOCIEIw82FM1jDtGErJW+oj4IEvAi7KCfeYH0oKChVCNGNHAXCuDYZ/yAAER07CMEb69kV2UJ/nOPlF26wjihfrgmCJMsVaQSZAEtAe3zNXuydQ9BD2MbKDhcXMkjb0z7rbAklgyQ6EafpiD6JE4blBu8yPVwgwhGOINfrHUM+pJBQMBHeUKtbNElxgD17eCuuLYsdaUtcqGGAN5qwtyg3KHQoFY4KIYQ9SaJv9Dg4oFpB2nD5iXODCuMGdOnZsYBco2cHJOfYIiq9VJGmTMbEerDevXOwNSCaUFuYEXpz643mUMIR/24ZdN7Bm3Pxu2N8oznyHhxQ4owDbe2bC+o8ioAgoAoqAIuBCgP+XPJEbWdm5hoxISTsl+w+lSfLB+y/upR47LRmZNyRYAsDp1UFeDIgO8mSQL8OSDZXhNfZPL8vooZPM+BgnWEDwMH4tVQ8BX2THY489ZozS6AsUKyMieyKPWnkOGQxZGW9xvDso3sgO5HuM89ZLHJkTnQijOuQGzyEzuskOa7ymD2RtZD8uDiMhEyMDYozHaMzJfggInkGeZdzInOhvGL8hIax8aQbr+Ac52eonnOhHRqddDmpxyAjyBv3N6n/I3hzAQbdhLsi5HLqhLw5QYcDG2M5n5m4P6SCX0+aPf/xjv2QHY8Xr/je/+Y2RcyEWuAcRxEEn2rZ6CmNjbeiX9UEfQE9F90QnoiBv+yI7wI1xostyQMuJN21DniCrW7IDLNgj6FYY9BkDz7MneB59GkwpGPnRKcAEfCng5iQ7rG7I4UQIDHQDuwdpl/Y4TIjux/6lH9YGHNCh2Re0zfjYVxBd3gp1fZEd7B0Oz0GyoQ/Zw2/MEf0KvRHdnnEwJ7BhndHr2MvsH9aBObIm2CCYP/oKB8C4x8X8wJH+tCgCikDVQUDJjqqzljoTRaBcEUAwRDhA8MHIzWeELoTK//qv/zInKtxCAt9jSOU5jLoYtBG88DDgM/U9kR0QGXgDIBwisNhCnwg1f/jDH0ryHngiOyA5EL45wWELwjvj4EQMhAFGdU7LEA4JRcEWBCPmhKssZAfCkreCgRqXZQQwTtAg/PEcp+sZIwIxBSEZAR8BEYGcwrxRNiAhEM7oB/IDogQB0wrk1OU7TtxARDB25uKtIKSiaIAz2CCQc+qecSHkoohQELYhFDglBQmDosKpKQR/lAmryCDEYtjm5A4KB7hZzw6M9HgMIKjyDKdqnIWTVpAgfI+AiiCJ0IlAiiLFvOmXeYGZ9bqhDbDg9I2NUcw99ouT7IAEQrDHk8EZ1oq6YMQ+ZW6QSZz2Yryc7gIfBHJbD4GXObKGzNtbYZ+w/xDq7Qkt8KV/1od9wHgw+EOYMXfG6KnQ1tNPP23WH2XIXZgrwrw3soMTU+Dn9Oxg/KwDSouzMCeUJ34XKIWQIhA+KCEobygi4MF+4Hdjva6cbdj34Mrvir8D/LbZTygiKA+QS/x+fBFGth19VQQUAUVAEXh0EOD/NMxITs8NT+QGXhcY+fFssFfcjj2yeHms8Ep4JwgPQwAEYZhye3Vs2JIoHVv3knAkI7/0g8eEK1xkSa+mnWX5mjj17ngEfh7eyA70E3QrvDrcBf0AwgB5DgMzch8yLPI78jYFvcGTZweyI4ZyZHdbkOvRt9ATeI9+4iY7ICvQoTjcg4xrC3IqB3eQi5GzOYXPmDhIgw5oC+2iU1GPsfvSYzDaoyfYULvoCfT7i1/8wuhS6BHoE8iu9I3MysErCt9h0EbHZLy0hYc4RA66CzqSLXh8kLMDPcyXZwf10UvpC53CHlBCV+OwHboWsj+Fg1WMi0NZdm3QcYhUwHwo/sgO9AYIKAgR2nDizd9R1oZDcZbsQOZmH3E4EG9y5m73BCQB80N/5llLdkCggA0FLJ1kB4cD+Yy+hMcGup8tPMP88LSAjEF3QE8EF/YsRByFPQQZwUE98KdvT8Uf2UE76Cb/9m//VqLT0g7PsX6sMVigb7NGeHmwX5g/Y0I/48Ah47LP8BuApEIXog66CzoSxds4PY1d7ykCikDlR0DJjsq/RjpCRaBSIOCN7ECwIFwPxmkrJCB4IWgjcFrDKoIRwioC+eOPP26IAepBGLg9OxBYMPIiLJP4zLbLyRQM1XhjIJjwrCeyg/aIFYox1haM0higITsgUDC+I5ghiHkiOxgvQpJTWLdt8YqAj/cFwi7zoj4GZEgGwlA9++yzRvBijpAdGMNpD8M6hbFDdjAfBFOESzBEuHSTHXyHsMzFM8zFW2FcGKPxYMAwj8DKK0QGAjTGaIRVhHWM5YyZsSMsMkbc27lHH1yBkB2cVkJwdOLN+JxkBwoA88DFmTnSn+0XxYs9xPwsyRMo2YHSAK6so/VaoW8EZIgABFlLdkB+gAWCrpPsIK4v+xKiyRu2KAMQW3hrcGKNNUKQB2tw5D77gHlyCoq9xh5EYfFU/JEd7Bt+c9Y7xpJkdm4oLyhvluygT+6hGFmSjboI93ixoABDJqHMcjE2CCLyuKAwQVqgUPCbgxzzVVAcaINTczzD3wDCmPF716IIKAKKgCKgCDgRIOxUcWiqvAc8Nx4gNxKTjVfDklWbZML0RdKn22Bp3ravdG/SWcZNmivbE5Ml+eBRE+LKs/nM2XPxe2RI+sdLwnp1jBoxVWJ/H1r4KgiS+F89K5ASjaNipEuH4ov3XZt3lbinnysTiZL8k19K/+gRD3p3eDEYPjhjvRMpCHgjOwjFgy7hlCGRT/EgwHiMzG3lOWQ7PC6Q39GdKMjbbrIDOREDOgdxnGQHRAG5IpD90RnQtTyRHehMGPedxnd0DvQensX4jKyKHMoBL/RAW5CN/ZEd/E4hDdATOLGPnsAceaW9n/zkJ4aooQ6yLUZ35o53t5Xp7YEqxoCcbj09ykp2MBd0S4zokBbMB5mfcSJzgwOkAPI0B/vs2qB7IR+zNugFFLwefHl2QCw5yQ7WzRZ0A9YGvAn9zDqzfuhbHLizupXdEz/96U+NzhUM2cGhMkt2QIJ5IjuYn5PsQK9jfdExKZBZ6CfoGRwgxLPCU2Ed0U+85eywZAd2Aw6ZWR3NEhdgypyxG9AHOiSH5Nj77FXINd7j8c73eHCgu7OWNswXWKJrQdahm2tRBBSBqoOAkh1VZy11JopAuSLgj+zA6GlJCYQRa8hHIOcECcISggT1SKKM4IngESrZgTDoj+xwehowJkt2cBIdgz9KAcQJY0UAYvwIeXhgYPxGcPNEdlAPsgThCIGPvAoIWJxcIowVgi6eHcw3GLIDYofTQAhoEBP0A0YQJHg54K7tK4wVGwABEyEVIZBp6lcAACAASURBVJ9kcQh9CIII5KwhOKCoQADQDxixNngXQAZwQp850Q51fZEd1GfOCNyceEKg5RnGTF8YzfEeAGeEcU6oYZBHWSCGLPcYKyQJxnfaQGClsE94ljZRKih2fdxhrPBYAG9c0hG0qYdbMnNH+LeeJQjeoZId7BfmSWI/FFBIM7wgUGJYG07gsZcgtpgnewICxoa2YvzsBfDhFeUIYoF1gXwDb+6DHXUQ5HnlxBFrwt6w99mT/K4Q0FkDPnsjO1BaUQQhv8Ce+MGsN6949RDOgDVmfpAYEE/cBz/GAJYQPXbczIO9zkk6SB4u2uWEoacTiGbh9B9FQBFQBBSBRxIBPCoIO4U3BiSFN3Jj9frtMnnmUmPkbx4VIzFftJclL1aXtCd+bDwmeIX4wNuD8FbZOXnm/6dAQIUUoT7983xZvDoOPfUriWoTLUMHji/2vkhMLvFAgYhhHiOGTZGuLbuXydujxLsjBHInEEy0TuVAwBvZgR6CAdhJdiDfIhujPyF7YbTloApeCRw6wUsBr3iKJ8+O8iY7OMSDvI4RGfIF8gPZkcIYMYhzqMlbGCtkTXQfe1ofTwV0BC4OaCFzI6MGQ3ZwIAodA8zQe6w+gf6ILgiBwrj8eXagI3LIDtmbcUC0oCeCN+OG7EDH4PAah/yQpyFgwIC6hGXG64ISCNmB/oiOCVnC3K1+gGwOvuiDECvorOgZ6Dr0jUcM9+iXPYEeRX2r4yK7c4/wwVa/ZfxgzIE39ELuM0YOhuHFjb5tw2Ch+3LQCZ2CeaFPoEOEi+xgXdA77MW8169fLz/72c9KohPwHXivXbvW6HT0jT7JPPiNsD+YAxhaDNATIcKYB6/MD5wI/YwOw7qil6ILaVEEFIGqg4CSHVVnLXUmikC5IhAs2YHQh9CEAMbJcgoGdYQnDMPcf1hkhyUM8ArBUM0JKk73Y9yFrEAY95WgHEGLU1EY3TnZg8DHPYQshD6M3Ai2zBdBLRDPDoQuhE2ESFy1EfLBHIEM0gAX6EDIDvpD4MPQT5gkPA6coYn4jhweEDIIdxi9KdbT5amnnjInYQIhO1hj5oyRG28HPCMgKxCqIVQgTcARzwuEfnDnHn0jnFM4lcT3jNXp2UHbnDSDqLAEiK1vyQ7r7YAXCK7WKDKMBeUKAZY9hqKAQIzihydGqGQHChh5OiA6WCPIB9rlYl4oMSRKJFcHdYnlixLFCTB7go5xcSqPOaMgoMhw+op2UXhZO9acOgjj7Cli4rJHcT0HQwR4yENOS7Gu/sgO2mN/Q3hxGoz9RD/sAQgmPDvYs5yeQmmGQGFPQ4KhVFF4hdSyyg7u4JySYj/yPMonJ66YkxZFQBFQBBQBRQAE+D8MjwqIDsJPmbBU9zw31sbGy4y5Kw1pENWu2CNifrWagleDp9BS3Gvdtq/Exe81hAmJxgPN23FfCKvEZAnVq2P7s89LTLfBEhu3y3hdxO/ab8Zic4tA5HCPfCDMr3e7PgI5Ekp4q8NPPiUxPYY5yJ1czdtRBX9WwZAdyGJ4dSA3csAEQz6/MeRt5GpkTuRTysMgO5DV0QkgAJBbyR+CXIl8CeGA3Irx3FuCcnRC5Gk8spFF0Z2YHxiRYw59ArkzULID2RqjOEQGRAAHhzhchAyMIRxShQTl6C7+yA6eQYZH/0BHoy08WmxCePrhQBTyM+QCcj4FogAvE9aG/ijI4b48O9BtwBFvafDi4B3tMW8OdaFvoW9YsgN5HaKCSAHMgwLZAQmAjM780AUorAneGjzLHqGAMTqgJTsYH2uB7sk8ObDG2qI/gh/1aBuyDZ0EfTMcZAcePZYcMwO79w8kE95IhKeC7GNs7CswZCx4afBbQE/B3gB2FNpCR+KAJXPgGeaBbs562Toc8EJHggiymJgv9R9FQBGIeASU7Ij4JdQJKAIVgwCCkjXoYojmM0IOgjfClDOMFQIRxmYbOgfBD2ENYysnKHCr5VSIJTs4cYGLshW+EEYQ2Dk1g2CFIEbB2IqxmtPo1rMDooFwSAg7CDIIMbSHYOTM2YHQg6CJ4IYwzRgRChHKMfozRsaH8MRYOJXEd874rk6kEYgwaCN8QepgUEYYR2iiD8JYOT07aBMM3GGsmA+CMGQHmDJf3G4RzBkLbSLAgjHGacYOEeGv0A7G8H/6p38y8+MEEwWBHXzBCyIAzwLIBk6RQRYgxKNkWLIDIZZ2OB2DMRthEoM+9yAPIIjYB8wNcgGBF1d3cIC8QOHBy4Hn7NowP+bM3Lh4BiUIodWGsWJ98U4BWzDCO4GTUuwre9rIkh3gjFDOniIxHQQDc2E83EdRwkAPScD3KCsQBxTmCdHFfMDCk6BNPYz5KDGcDkPApx4nkLjYx+BNf9RBGaFNfi8oGbhQgy84jx8/3hAyKC3MhT3Gc9Rl3FzsX9aItULI53kEcXBgj7LXwJW++C2CPyf22CecKHOGsWJ+rBO/O/YPmNInvwUUZsgb1pZ1ZC78ZsCOeVKHcfNbRFG1J56YL4QMxBUKHIoTpw95XosioAgoAoqAIgACxR4VucUeFYnJhgDA64GwT51a9pRp79Q34aCyvvf9gAiBQQ3byuIVG00oqhSbuNtPaCfkR2cIK4gKPDM8ESq+SIktzz4vg/uMMkQGpA3kzeHUE3L1WqZkZeeai/fcS9hVnACdvgZ1Gxwy4TG6XhOZt2jtPU8WJTuq4q8K+RRZGXmKw1boJsjKyHmEd3V6dqADIX8iLyK/Ic8heyM3IlNzkAw5k4KOgtyHDI3syyEk5ESeoT97CIe6nIpHjkPO5NAV/SD7IZsSHgkZE5kcuR59yx3GCq9snkV+h9iApEB/gYCBlGGMyK/0gV6HrudJ1kbmxeiOQR79BD2IcSD3IrejV+FNbckOyAUIBzygrUzPQSHmiyyMrsBcMISjK6LbIOczD9oFsyeeeKKEJKB/fwWdiANtP/zhD0379jAf8wYj1oIxIUej3/AZPQBZmXWjQCawDmCGbI3hnUNSjAsyB92Gv1vsAwgb9EzWkraQyyE7LI6QIDzLfGgPXRYZHz0MDCCInGQHB534jN4LpqwFh8TQWdBTWV/wonAYDuzpHz2E/tGh2BfoCugEzAU7AG0yX0s0WN2DA3foPegNngq6B4e5/uVf/sV49zMmsOFi/Tj4x37i4Bd9Myd+G+wvxgoe4E777G/sDtyjDhigF6HP2ENveIkwTqfOBRbUZb78TrQoAopA1UFAyY6qs5Y6E0WgXBFAkMP1GGEDYZvPnDLCvRaBFkO0LQhpCJgIUAgsCOUIfwgxEASc2kEgQbBEIEIwJcQUQhhCLKQF9RBYMPZasoO6CMG4byNUIyxjZEaww3UXYgKBl/YQXAhPZQsKBONHYITk4DNCDeQDwhxCE0Z4BCMEYIQf4pFaA69tx74ioGHAx5jOsxiSEcI4sYSQxRgZC2OnD+aH0IYgT2Hs3Gc+9IPASEGpwDiNYAlhg7BPHwjolixh7P4KBm+eQzEgFJRVBBgPRmkEdMaEQoGiQn8oNZaYYn5cGO4RKjlxAxYI1pxkQlBE4WENmQuCMkZ6hG0UCoR2BErWASIMMgeBnnrgA9bsCYgOFBUEdeqy9hYHhFP2m1V6OL3EaSU8EVgnlDIK82E/gCNrwH5DuGXeEArMmTGiSEKaYNy3p3fAErd25ggB5A1b+kbp4FQRc3EXlEUIEcaL1wdztaQSJAxridLJ6SIUE34/YIcii6DfoEEDgwfYgQVKDt/zGwMHcGKPsR8YJ/gzX4R76jBP9hJtOT0saANlGkWB3ymYs7dZG3Bnn7K2VhFhH/KbRkFlLNSnDs/bPcrc+Z2CB+G8UIToQ4sioAgoAoqAImARKCU70oyHAqGf5r7ydsjhnVb8uVpx3g4Tyoq8HXl+vR1Kx3DU5PuYu2iNQCL4Ijbc30HGfNm2t/HogOTAgwOyJSMzy/zfSR9c/D/KPTfh0T0qWtL/8Z8D7jPvO9+VFS+9Lp3aRsvChauV7LAbqgq+Ilch+0JSIMchsyGvY5xHtkIWtIXv0FuQ2SAPIC2QpTFCozMhayLHU5DRMDJzWAXZFzmZ9tFRkM+RWW1BHsawjFyILIeuhTyLnsZBKWRMZGwM4+hbzjyHtEv/PIvsid4A4YD3Lzofh3KQPRkvRnLmhDyJTO4uVlZHP0FPQPbnQi9Bf0JPQadEvkZWR2ekHjqTPZgGPswXWRhigrnwu0TOB1P0T+RxxoaOBGbUQzejf38FgzjzhZTA88LKxawNei86KXomfSBDo8faMFpgT+HwFe/BDD0VDFlnyBt0EXtgiQNwyPjM0cru4I/uhi7B/CEmwBsdnDmh/4AZZAvzQpZH1kfnoHBQifGgK6H7UQ89j0Njdh8yPgpYooMzTvQGxsBasMfQ1cCLtWA/opfYiAQ8yz5AR0R34VAW+HgqrCN6FQcMufDotxce++jntINubHVU5ojOxHfMG5wo6Fbgwm+CuTFedGeIGXRX5kN9dBf2JWtEW3wm2gB70ts4PY1d7ykCikDlR0DJjsq/RjpCRaBSIIBQg0CGYIMQQ+EeAhQnOdyCK99Rj/oIygjeCFDU59UKJ7TDPeohlPIcgqm7LwsCwiTPW6M0/SLA0AZCCs/a9txjcrdpx8jzCIu0C4GBsRnhHMGecXsrVrjlWerxSh+0R1uMhWJx4Dt7j/vMgfmAhRWwGBM48Dxtgq2dM+1a7L2Nyd63bYM9z9v2+d7O27k29MP46Jd+bGEs1ANTuzae8HX2R588Qztc1GfePE897lnM7PxsXYsPdVk/xkN71KMdnrfj5L2dD88xT9sur3x21gE77nHZfnieOoyX+96KnTN4OLG09blnx2X3Mfdo0zkm5ulcQ96z/raOxc45bjcO1Ge8vPI8/VDf09wYH98zfjCkffqy8wVfvrPF4s73dkx2b9COLdxDOYcIgUDy9Tuxz+irIqAIKAKKwKODQCnRUEp2kNjbTSYE+rkkb0dicsChrPg/rThfR/EYRo6aIRufeT6oMUx9/xOZOWupIWwgOi5fSZfcPOSa0v8T7armeyA8SLY+sFF7v94kTpJj3LjZhlwhD8j+Q+QoUc8Oi3FVekWusvKvlQ2RT5HLkM+sLGjnzH526ghWnkP+tLIadamHTOiUOWmLesh3znYZA/eoa2Vj6iFjIn/Sln2WOs5n+c6O3z5LezxHm8ictMPBHg4DQTZg/LZztfNyvtI+bfKs1YOsDE6b9EkBB+rxnZVP+Y6+mTtzsHX53mIEQQC21LGYOefkHIv7PeO2Y6Nf276tZ+dtdULGa9eS/ik8w3vasThYfKlvx0I9Z3+sNc9Qh7FbXcPW477FjPnRh61rxwkOjIe2qMv8+Uyf1KV9W9e2yz1v+gB1GIcbb+bJ2N06hsXJ+Ur/4MW6uC/GRDv0w3xoz2LLuOz+tP05x2r3Ds8xb9qw62Nxog59ONtxjk3fKwKKQGQjoGRHZK+fjl4RUATKgABCE+QGJ5l4j9C3adMmc+KDE0icqEFI0qIIKALFCKAsoJhwCo2wC5y04+QX97QoAoqAIlDZEeBvGIYPDHP24rO34qk+95zFU3vuOny2/fHqqU93O+42nH2G4z3tM5P7LtfcytIP7WKkJ6cFoZ/w7CgL2QEp0rpNtCEBEnYfMN4VhKjyhZM7X0e3Tv3l3GOPB0x2QEBEte0rW3bscYTPetDI6cTpPsJjd3FIK195QjySHAlJpr99+1Mk7cRZybvpu09n//peEXhYCPBbxGCNJwUeIxif+Yw3B2Gs8B7Aw5u/gVoUAUVAEVAEFIHyREDJjvJEV9tWBBSBSo0AJAchgnC/xZ0Zt2fcj3FrJUQQbq8qkFfqJdTBVSACGOIIr0DCP9zqiRnM7wai0JPhrgKHpl0pAoqAIhAQApziJAwL4RUJa0LYPshbTnZ6KtQnJCehNqhPyA/CtXASFsMexjxCFxJGBoMeITMITYJ8YY3wvBI+hL6oQxgRDlNw4tnW4WAF4+LU86xZs0x/hEKk/XAV+rLEBiQARAFkhPPCqB4uuac8yA5CUBGKCo+H5IOEsvLu8cB83fk6IEsC9SShHgnT+0ePMP3h1RFoYnQwpC7PQPRAlnSM6ivO/CT+SA5CZdEGcwjXmoRrL2k7ioAnBPjNEWKWcMLIh1zk7cMLmNBC/N3lNL39u+epDb2nCCgCioAioAiEAwElO8KBorahCCgCEYkAxgjyT5AL4be//a0888wz8tZbb92XIDoiJ6aDVgTKAQGMe8S7JV8KCdLJG4IRUIsioAgoApGAAAY2cmVhfIOs5e8Ycb058MApZLcBjvAZJPIlrrmtTzxwCA3qY4Amh5P9njjuNWrUMLmViOcOUQERTAgQCA6Mfa+88orJpcXBCnJQEf6DApE8dOhQI4+89NJLJlkshy6Isx9qYT6eyI2s7FxjRMeYTogkPC+4eI8XgfGWCLVTx3PlQXYQgopQVBAIjNnk7fDijVLaf3G+jtkLVsuEDxoGRXZ8VaOWTJ2z/F5/geUJAQL6tkQLeT62JSTJlGkLZd7r70ngJAfhZQpMWw5Y9a0iUGkR4G8OOSdIWo0nBwmySSyOJzB5QDhEpkURUAQUAUVAEagIBJTsqAiUtQ9FQBGolAgQZ5Sk2xgz9u3bZy7eY7zQ8FWVcsl0UA8RAZRYjHYkcsRgSIJLTj1rUQQUAUUgEhDg/3USw9apU8ecMCaO/KhRo0zSVYhcpxcFf+8Ic0nSVWLN47lBclqMeJxSJhEtBDByBMldk5OTDTFBYl6SwpKYFo8R/kaS/JTEsoMHD5a4uDjTFt5xkCwk/iUM4Pr16w1JMmHCBElISDAHMRgn/dNPICUYcgOPA0JBQRqUXCYXRkrA3gv+xlRKNoQvjBUhqAhFhWeHP08Ld/9jpiyQlX96OSiyI+aL9kLOjUDDZjkxgagoSVi++4Dx7ujQPsYkHi/JyeEIV1XqyaEkhxNHfR85CPA3iL+zkBqQuYQ5Rb/CS40k4t486CJnhjpSRUARUAQUgUhBQMmOSFkpHacioAgoAoqAIqAIKAKKgCKgCASNgA3D169fP8E7AyKDsnnzZuncubNMmTLF3LMh+TDaQYD06tVLhgwZYkgJ6kNmvPPOOzJ9+nQThso9EAiTTp06SaNGjYyRj3j1AwcONPmNaA9yBC8Onv/kk08M+cFnSJSOHTua8Fa0SSiY2rVrG28PDmDYcbn74zNGfWdYKk+eGw+QG4nJJvcF3g4jhk2RsSOnG++D+4z6njoL4p6bbAhHzo5g8na4+w8lOXmnlj1l3cYEv8SKN1hKw1mlGIJmXWy8bIzbZQgmsCYnh5Ic3tDT+4qAIqAIKAKKgCKgCISGgJIdoeGmTykCioAioAgoAoqAIqAIKAKKQAQgQEiq3bt3S0xMjCEVOGVMIUwUHhbR0dGyZ8+eElIBIzXx5Vu0aGHizxO2isJp5bp168rYsWNNKCvuQYxATuDBQb6Npk2bmvYgVDIzM6Vly5amHZvHA0+OdevWSbVq1UwOJE4+9+3bV8aMGWO8QWiT/tq1a2dCbvE94/dUGCfhksjt4AxL5YncIG/EgqXrTRgovCPIX0FYp7inn5PhDVqa7/DysB4TtF2W4iYbwkV2MGZIGn95O8LRf/O2fSVuxx6/IbO84cQYWB/Cg7lDhinJ4Q01va8IKAKKgCKgCCgCikDZEKgSZAcukSgQJP87d+6cXoqB7gHdA7oHdA/oHtA9oHtA90DE7wFkWxJia/iPsik8eFSQOBzPjj59+pgQlrRIfPlJkyYZ7w6ShlsPCgz9JBP//PPPDTGBhwaFJOJ4bRD+CjKD+tQlRweeGNWrV5f69eubZwlhxUUbhL6C+KBAjuBR8sILLxgihbBVhL3Cu+TkyZOmzuXLl6Vnz57GK2T79u0e1592bmRly779R2TjlnhZvW6LrFi9UZauWC/LV2+UFd9skhlzl8ng0TOkW4cYwXA/rH4LIe8F4aCcibr5/GWHGPMM7WzZliiHDqfK6dOh61Znz52To2nHJHZzvBlX/z4jJf5Xz97Xr3MMgb6nDdpirrR9NO248ZZx64Du/nt1GSBpT/w4qP4bR8U4+jkmtOnux99nfsPHjp8wWICHvdKOHTf4+moTrx++v+86ezboMfgbo34f/LoqZoqZ7gHdA7oHdA/oHqi4PYA8hbdzoOFdqwTZgbLxxRdfmKSAKBq1atXSSzHQPaB7QPeA7gHdA7oHdA/oHojYPYBM+/bbb8unn35aEnbJWML1n6ARgOzYuHGjITsgPK5du2baIAcRJAOhpyAVnGQHCXU/++wziY2NLSEqIDvw3Bg5cqTx5qA+pAMx6olPv3LlSmnbtq3xIIGkguBo2LChITuysrJKxk3ujueff96QJJAsXbp0MaGt0GnwBrh85Yr0jo6WAQMGmHBansgu6qUeTZNRYydLo2ZRUv+zZlLv0+ZS79PW0rJRR2napo/0bNDK5Kk4+fiP/Br5x79VVz7/oridjz9tKvXqN5TadepKrVB1q9q1pU7devJRg0ZS/9Om0qJJx7CQHen/+M/SskV3M9+PP2ksdevVl1q1POh/rv5bN+ksgeDgJF0gOxg7c2AuIWPB32FwdF6+/jYbzGsb/OnXeZk18fWsfhexf/PVhqE2HN0Dugd0D+ge0D3geQ+8/vrrEhUVVeJZXSJUe3lTJcgOEgO+9dZbRvngdBau5XopBroHdA/oHtA9oHtA94DuAd0DkboHSFbNYZ5XXnnFJMH2Isvr7QAQIAwUHhSEsfryyy9Nslweg7wYN26c8aIgYbmT7FiwYIHRLVasWFFSnzBWeG4QcsqGpXJ2D7nBd/SBJwkn0GwYK7w1IEYYCwnOX375ZVm2bJns2r3bEBtjxoyVAwcPSXZOrpw4eUo6dOwkAwYOEsbljew4e+5bmb9whfTuN1JatImWrp+3kzkvvymHn3xK7v793/slOJyG/azvfV/atuwp0f2HSZ9+w6TfwBEyfMRoYVyh/IbGjB0rI0eNlv6DRpr2urSPDgvZwZjbN+smvfoOk74DhsvAISNl1OgxBnfnON39t2ndSyBKnHP29x6yAyyYA3OhTWcf4XjPfqFdc40Za+YyctQYgz1z6z9ohOmfMfDe23zDMRZtI/zrq5gqproHdA/oHtA9oHsg9D2AnD5+/HgTRpZQsni9BlKqBNlx9OhR41K+atUqo0CgEOilGOge0D2ge0D3gO4B3QO6B3QPRPIewOCOh0daWlogcr3W8YIAoaYIWdW/f38TVur06dOGeMCbg3wdKKHoE5bs4BWPjq5duwqkEzk5KPHx8fLBBx/I1KlTjdcGxAXu9Pa5GzduGE8Rkp4vXbrUhCAjHwcn0cgJkpeXJ+cvXJC58+ZJ3br15Js1aw3BMXzEKOneo7csXbFGkg8elXWx2+Tzxi2lT7/BkpJ61GPODjw7srJzTI6Nr5esk0EN2wZlyPdk6F/2cg0ZO3KabN62W7Yl7JODR45J5vUbcjsE3YpnMjKvy56kI7Jl224ZMmBc2MiOae/Ul2lfLZct2/fInqTDph/3GN39R7WLEQgdT/P2do/QX5u2Jpo5MBd3H6H8bcHLiHa48vJuGnxpOz3july8dNVgzpx27T1k1gDsSq6S+Ya2JqGMV5/R/0N1D+ge0D2ge0D3gO6Bh70H8MRu1aqVka29iPv33a4yZEfjxo1l/fr1901OPygCioAioAgoAoqAIqAIKAKRigC5IOrUqaNkRxgWEKJhyJAh8tprrxlvidzcXPnqq69MmDCSi0NUQFrgfcGVmppqvD7It7F161YhDNXChQvlww8/lMWLFwvPZ2RkmIuk4zyLJ0ePHj2kSZMmJi/H1atXZf6CBdKte3eZMGGinDx1WjbEbpTe0X0NubFqTazs3HNAJk6ZLZ80bCajx0+T9Rt3yKw5i+X92p+Yk/yZ17NMaCs3BJAdeIEkH0wzSbSj2vaVvO98NyhjvtvIjzdIx9a9ZMOWRHEmK8/PDz5ZuXN8tBWuBOWMmbwdtEe7zD87J8+smRMjd/8d2scE7dnRqWVPWRcb77UPZ3/e3pv9RK4WEQFHEpazblnZub4Tyycmy7aEJLMWM+aulMkzl5qk7DaBfChr4m2Mel8RUAQUAUVAEVAEFIHKjMDMmTOldevWjybZsW7dusq8Njo2RUARUAQUAUVAEVAEFAFFIGAEMKor2REwXD4r4oFBaCm8NZo3by4tWrQwYarI4YHXx+HDh2XTpk2ybds2uX79ukkujicHXhnk6YD0QMki7BD1IUf2798vgwcPlo4dO5q8H9Rt06aNTJs2Tc6fv2BO7R8+kiKTJk+VRo2bSbOWUdK4WRtp276rzJqzSGK3JMi2+H2ycMk30qlrH2ncooM0bf2lNG3dTTp06S3zvl4uV69lGiO5e3JuY37/6BGS/JNflonsgEjY8uzzMnLwRGNoT9h9QFLSThkDPf0FU9zjCyfZQTgqyIvticnGs+Va+vUHMHL336fb4KATlPdq2llWrN3qtQ9veFiCIyhyIyHJzCc2bpfMXbRGRgybIl06xEi71r0FT5bOLbrL8jVxct+aFAW7Kt5GrPcVAUVAEVAEFAFFQBGovAjMmDFDyY7Kuzw6MkVAEVAEFAFFQBFQBBQBRSAwBJTsCAynQGphgMbTAsJj4MCBJin4qFGjTGLynJwcE6oKDw5ye9hk4iQyx7vG1ifcFXk78OTAU4TwYhMnTpQ+ffpIr169TE6QOXPmyKFDh+XqtQxJPXZakg6kytIV6yRmwHDp1DVavuweI8NHTZK1sdtla/w+WbB0vYwYM1O6REVLy1a9ZNiHDc3rpOnzZcPm+FKywWXYLjXmHzVGck7+z/vb22UmOyA8MPJjWC+Ld0fp+NJMO+EkO5xj9Gb8d/cf02OYyWXCs4Feo+s1McSDtz487TtCpuXdvGW8TSBhIIv2H0oz3iF4ZdAWuJorMVm27Nhj9sCYCXOkAsGm1AAAIABJREFUW6f+0rpNtNBv3NPPyaUfPFYy1vnVapZ4dxDqDO8QpTo8rYDeUwQUAUVAEVAEFIGqhoCSHVVtRXU+ioAioAgoAoqAIqAIKAKPJAJKdkTeskOqEKoIoiN+1/2GbcISQSJMmL5IML6TAHt4g5ay9vcvysnHf1Ri2J7wQUOZvWC1ITG8GbZtPxjTMaDTbo/GHUvaCNSg76keHiJ4ijDe+wz9QSyHm2wIN9nhz/gfjv6XvFjdrBUeJN7WwQkJawLRkXbirCE4PJEbYLp4xUYZM2WB4G1CXhC7B8499rjX9bNr4it0l3Ms+l4RUAQUAUVAESgvBPj/Do9ZcpfppRiEaw9wYMRbUbLDGzJ6XxFQBBQBRUARUAQUAUVAEYggBJTsiKDFujfUUiN7sccFYYmmzlluyINWUX2N1wRG9MNPPuXVsB1ITgq6I0wS3gMY1THIt2zbp8x5Oyz5Yb0anN4dvpRQ90qV4lA+nh3+jP/u/vGcgFSy8wvk9cF18O1NYfvEk4P14HITXM2jYkwy+ZV/ejmosFrkY2H/0Kbm7XDvNv2sCCgCioAiUFEIGA/GvDy5dOmSyZ9w9uxZ0etRweBMua31t99+a/LgQZxAprmLkh1uRPSzIqAIKAKKgCKgCCgCioAiEIEIKNkReYtmDd4kzoYowMg+tF5Tk08j0ATigeSkABmUQZJz2756dOkflrwdEAF4GRBWyXp3HE49IRmZWQ/kxvC2Qm4cwu3Z4c/47+4fTwoIhkBIDlsHb5uenQeYdfSWCN05f2efJDbHO8ZNcJEE3rYf7KsNL3aft40Hg4BzTPpeEVAEFAFFQBEIJwK5ubly5coVOX/+vAkPmpGRYYzU+lqFcUhPl4xrVyXj2hXJyEgvl/WGPLt48aIQQhavIXdRssONiH5WBBQBRUARUAQUAUVAEVAEIhABJTsib9FKDd7Fnh0km8ZLIljDdqeWPWVtbPz9YaRchm13XwNHTpUZr70XdF/exjb7rboybeZiQ3gQkiuYZOWlYysfzw7G7Mv4X9p/8TrMmLvSJPr2NldP9/0RKu7dWdpnmsxbtFb6fdombJ42jG/Jy2/KhMnzjXdHIGG13OPTz4qAIqAIKAKKQFkRyMzMNKf7r1+/bkJYlbU9fT4CECi8K3LrhsjNDJGCO+UyYPLhXb58WU6dOmVy47k7UbLDjYh+VgQUAUVAEVAEFAFFQBFQBCIQASU7Im/R8LYgZ4fNpUEYK5JOezKm+7o37Z36goGesEXeDNvuviZNmy9RTb4Mui9v48j63velY1Rfk0TbGc6K8Fn+itPwz7OBeHaQlDsYzwdfxn83NuQ0gRzxNldv930RKm4MnHOO27FHWrftG9R8vI3B3k974scmzwd4BuJp4h6fflYEFAFFQBFQBMqKQHp6upw5c0Zu377tMdxQWdvX5ysZAkVFUnQzUwozTkjhtaNSdPM6rsVhHyRyG0Ta8ePH5ebNmw+0r2THA5DoDUVAEVAEFAFFQBFQBBQBRSDyEFCyI/LWjBG7c2mQiBpDtTVaB/L6YL6IPI9GBWdfs+YukZYtugthsALpI5A6y16uIeNHzygJZxWod4fT8B8o2dGlceegcPJn/HdiExe/NyTyIRDSye5S95xDWXdfawIRBIHCXDRvh0VdXxUBRUARUAQqEgHCDEF2eAo1VJHj0L4qAIGiQikquCOFWeel8MphKbp+WuROTrl1jLfQsWPHlOywCB89elQaN24s69ats7f0VRFQBBQBRUARUAQUAUVAEYhoBJTsiMzl43SaM5fGuElzZcWfqwVFQOBVEdUuxm9Camdfs+YslmaN2gtEiS+jeTDfYWDv2LqXbNiSaHJXBGpkdxv+A/Hs6NyyR1A4+TP+O7GBcCEHCblIgpl/oKQTO9U951DW3d/YBjVsK4tXbPQZ3iwyfzU6akVAEVAEFIFIQCBSyA5kgDt37khCQoJMmTJFxo8fL6NGjZLhw4fLyJEjZdy4cebemjVrJCcnMAM+3iwkY9++fbukpaVJYWGh3yWjzq5du2TDhg2SnZ3tt34oFUgaz7okJibKxo0bhbwqYSmF+VKYc1UKr6YZrw65mSlS+GA+jbD0JSJKdriQVLLDBYh+VAQUAUVAEVAEFAFFQBGIeASU7IjMJSw1ehfni8A4jZHanyHb/X0gIZScfc2cs1g+bthGprz9UdB9uft2ft7x9HMyrP+4oLw7SscVeM4O8pQEi5Mv4797DCNHzZCNzzwfFDaXfvCYdOngn3Rip5b2V7Z1d2Lvfg9pBolSHMrqqCHV6FeLIqAIKAKKgCJQEQhECtkByUA4pGXLlklUVJQ0a9ZMqlevLi+88IJUq1ZNPv/8c2nRooUhPEiuHkjJy8uTQ4cOyddff20IDEgGf4U6q1atkmnTppnE3v7qh/I9JExqaqohcrp06WISyIfSzn3PEKrqTp4UZpyUwitHpOj6WZGCu/dVCfcHJTtciCrZ4QJEPyoCioAioAgoAoqAIqAIlB2Be1bEh2VMVLKj7Ev4MFrgNKEzb8eWEPM3zK9WUybPXBpw3o7Z85ZInY8bS4fm3YMy6LsN6p4+W+IFI3sg3h2lhv/gyI7mQea58GX8Lx1D6EnKwYKcK+ReSdjtSNLuIV51uNbdE/72XknorsTkgNbhYex/7VMRUAQUAUWg6iIQKWQHK8D/yyS+zsrKEnKNTJ8+Xbp162Y8OwiXxH28ICAkuKynBs/Z4n5/9+5dQ6LgNcJ3zsv26XyGe4wBooT2bX1b19mP+zn72T5jX+0z9hWy48iRIzJo0CBp166dSfRtv3O+2va453xv6zjvFRXclcKcK1Jw+ZAUpB+Xols3pKio1JPF21hsW6G8KtnhQk3JDhcg+lERUAQUAUVAEVAEFAFFwCMCqC/3XUXFefbuFhRK9s18uZJ1W85cy5WjF7Ml+Wym7DqZIWfScyW/oNA857HRcrqpZEc5AVsBzTrzRZBkPJT8Dck/+aX0jx5x7xR/WvEpfocCbqdh+5q/cIXUqtdQotpGhzVvB4b2w08+JTE9hgXs3VFKNARHdnTuPND0ZY37/l59Gf9RxJ2kU6hJyid80FBmL1jtk3RyrwWEEOvO+rGO3uaR953vev3O0zOE7ooKkHyxY9JXRUARUAQUAUUgXAhEEtnhnDNEAx4Z/fr1k2HDhhmPDpJeT5o0SQYPHmxet23bJnFxcTJgwAD58ssvDTEydOhQ480BWcG1b98+Q5rEx8fL+fPnZfXq1cZrg/BYvXr1kg4dOsjEiRMlOTlZIEYgUeiXEFqXL1+WS5cuyYoVK8w4aJtnunbtKozl22+/NUMm3NWePXuE7/HUYMyE4hozZowsX77chOdyzs2SHcyjffv2D5AdjIG2eZb+8HSBGCGEF3NCXiIsF6G9evToIe3at5eY6B6yesE0yTy+U84e3iWLFswz42R+tAFuzD+cRckOF5pKdrgA0Y+KgCKgCCgCioAioAgoAvchcD3vrpy4kiM7T2TI9qNXZfORy7LuwCVZnXxelu0+J18nnJFZcSdl4sbjMmrtURm4IkWiFx+SngsPyDdJ5w0RUlBYetLrvsbL6YOSHeUEbAU0i+JY1rwdGMJbRfUNOG/HgkUrpVbdz6R39IigwzV5Mqy7742u10TmLlpzX+4OFGhPJVSyY/iEOYJHi7tvb5/9Gf8tEWTJB/AMlmAIPm9HniQfPGpwwjPHOR9ysez++W+ExOeE7WocFSMnH/9RwPMFh5J1SEw2/WTn5FY4EetpzfWeIqAIKAKKQNVHIFLJDhKqL1iwwBAHkAdNmzaVTz75RFq1aiVDhgyRr776Snbs2CEQHuT0oA5eIB07djTkBmQAniCEpGrevLnMmzdPUlJSzLMff/yxaY9nqE9O6REjRphcIPRLOx9++KFJvo1HCWTBSy+9ZIiFmJgYE2KLsFpbtmwx5Ag27oEDB0qbNm3Ms9HR0aZOrVq1DBFDeC5n8Ud2QJ4sWbJE2rZtK507dzb90nb37t3lwIEDcuHCBfnmm2/ko48+ko4dO0jvHt1kSN+u8s3cCZJ1/ohsWLVEWrduZciO3r17m7FNnTrVPOccR1nfK9nhQlDJDhcg+lERUAQUAUVAEVAEFAFFwCCA0bWgqEj2nMyQCbHHpdWsvdJw8i6pMzZB3hm2TV4bsEleit4gf+6xXv7cc7282GuDvNR7g/w1OtZcbwzcLBNij8m17DuSX6Bkh26rwBAoNfYXh1AK1avAho/yFULJ9rVgUbFnx+CRU4xB3BtBEOp9knuT5HtbQpIJ6XQ49YRkZGYJhIK72DElHwzOswMyhTkHM0Zfxn836RSKh02gyeLBwJM3SecW3Q3h0bV5V5N0fnDMWJkxd6WsjY03+TeCTV5P3hHyjxTn7fDu8eNeE/2sCCgCioAioAiUFQE32XG3oEiyb92V63l3JDO3Yi4OMOXdyQ+K6HeTHU2aNBHIg/79+5vE2OCCJ8aNGzdMsu+rV6/K/v37jddGo0aNDMlByCtPZEfNmjWN5wakA89BKnzwwQfGw4I2nWTH8ePHDSFC7pCdO3eakFh4k9SrV08sgYC3yBtvvCFz5841hAkeFJAUECZ4nQRDduDRcvr0aRPeivkS7ooC+cG86JP+J0+eLO+++67s2LFd7uSmy+2LKZJ7NlmkIEcmThgn77/3nhw8eNB4gjjDcpV1PzmfV7LDiYaIKNnhAkQ/KgKKgCKgCCgCioAioAgYBPLuFMixSznSd+kh+XDkdqkzZoc0nLxTms3YK1FfJUmX+ful15KDMmDFERm17qhM2XRc5u44LUt3fytr9180XiCnr+bKnYJCqWDHDlHPjsjdxG6jNwRBKF4FJTkpfJzit30tXrZaatX7TCZMnWvyTARDGFA3EI+Hea+/J1OmLTSER/wuRw4L11KFSnZAAASLky/jv3scJPcOllwAG4+kk2vO9qPbmwRiAg+P1eu3Gy8dwltxsSdCSV5vSSfaCCR/ih2XvioCioAioAgoAmVFwEl2EFnz2OVsmbr1pAxclSLRSw9Jn2Xle9HH8LVHZe2Bi3I7vzSHhL95uckOvDMIVbVy5UpDKPA8HhDbt28XvBdIaF6/fn1566235C9/+YvxCiHkk5vsIHwVoaNIhI63a05OjvTs2dN4SZw8edKQA3hQOD078AChbYgPxrV7925DRowfP968xwOF7zdt2mTaJIH6woULjacH5EwwZAcETGJioiFcGIcNPWXDZDHWzZs3m1BbeJt82aWjLJgxTvbGLpJrJ5OlqOiuLFu6VPBewWuFcFsJCQkmCTpth7Mo2eFCU8kOFyD6URFQBBQBRUARUAQUAUXAIHD2Wq6MXJcmH4zcLg0nJsqChDOyOvmibDpyRbanXZVdJ9Il6UymHDmfJccv58jZ9Dy5dOOWpOfckexb+XI7v0CKw1cVBXWCLBzwK9kRDhQfXhtuo7e//A2eyImSnBQJSYKXBKGxIDfchb42xG6WD2o3kKkzFxgPDIzintr0dI+cHP3rt/JbHy+HjlF9haTrvpKVu0mGoQPHC+GgPPVt7xHWCbIjWJx8Gf9Lx1HsYbNk1SaJ+aK9z3HY8ThfS0inABK0F/d5L5QVxEZCkrnwzoGcYB33JqcIZFGoyesDTZru3if6WRFQBBQBRUARKAsCluwoyM83h4CSz2RKj8UH5TO8psfES92x5XvRR7MZe2Tm9tNy6+6DnqXe5uYmO1q0aGHCMZF7wxrt9+7da0JY4UUxevRokyeDEFKQHbNmzTLEhZvsIFxVnz59ZOPGjUY+w+uB0FSQFYS+whvESXZwj1wc9G9zdCQlJRkygj4hHmbPni2EtWJsFEgYiA/ydwRLdjAe2mQM5PTA84RCCC68OSBqtm7dasbK5+ED+0r3ds3MNX/WZLl29bLxDMEThLkyN/J64GFy6tQp01a4/lGyw4Wkkh0uQPSjIqAIKAKKgCKgCCgCioDcyLsrq/adlzcGxUnt0Ttk5tZTHg3FlRUqJTsq68oENq77jN4JSeZ0vzN/g9OY7u09OSlat+0rcfF7fZ7ihwDZvGWrvF+rvkydMd+EOcLjwVu77vt4dZA/wlcybfvMNy9Uk7Ejp5eEs0pJO2USgTNfW0pJhuDCWEF2uPNc2H59vXoz/luvF8YI2RCqh40lVGwIr5I5eyCe6DPv5i1JO3FW9h9KM+QGrzxzLf263MjKkctX0g3hgXdGKKG1fIXusmugr4qAIqAIKAKKQLgRcJId/Bd46kqOzE04I6PXp8mQb1JlaDlf9DFx03FzaOlOGTw7WrZsaYz/hJKyZAceFeTwIBk48yRHB54f1atXNx4NeFS4yQ7ye0AAQHZQnGRHamqq8fRwkx0kSKcfJ9lBHcgO8oYwjrp160psbKxpExKAHCGM2RfZQe4RvC/wBLEFmQQSB6IEEufixYvmKzw7yAtC/hDeFxYWSP7tPDmUGCsTh0bLJ/U+lM8bfib7kpJMfTCC3CC5OvlOfvGLX5jwV7afcLwq2eFCUckOFyD6URFQBBQBRUARUAQUgUcYAZSv/IJC2ZZ6VTrPS5bX+m+S0euOSuqFrHtkh9MsW3mBUrKj8q5NICNzG9pDzdsxqGFbE+7IX96OzVvi5P1aH8uUGfNNInEM4r4IAvd3hGrq1ayLQLC4v3N+5vuOrXvJhi2JXr07ykJ2QHjg5eHs0997X8Z/t4dNIF4mnvrDIwTPkOJcGUeLvWy8bARCWUB4kDzcXrl5N01+E/ZFVnauIUFoizBXwRBTjC2YpOlehqi3FQFFQBFQBBSBoBGwZAeeEpS7BYWSdfOuZFZQzo6M3DvmMFPe7QLxcN7A63zcnh2eyI7ly5dLp06dZMyYMYYgsN4U5NeYOXOmCR9VXmQHeT0gO8iLAXFCDo+JEyeaHBuWrIAA8ZWzAyKEPByExSJPB+TEmTNnTBuQGiRkx8vj3LlzxlMFwgVi5fDhw3Lu7GlJSd4lh+PXyLbV82RY/2hp1qSx7N23V9LT000ic2zvhw4dMvlJ/vCHPxiPEGSacBUlO1xIKtnhAkQ/KgKKgCKgCCgCioAi8AgjwEkv8mwMWZUiH47YLlGz90ri8WtBxfatDPBVZrID5Qb1puQKo7JTGbAP1xjchvaodjFCKChPxnRv95whlJIPejaysx5b4rbKex/Wk2mzFoQUHol+8O6I/f2Lfse389fPyOA+o7x6d5SF7MB7okP7GEn/x3/2Ow6LmS/jf/FY7oWVSkiS2QtWy4QPGgbc9gN9BJgrw9tvxI1NKOMBGzDSvB3h+qVqO4qAIqAIKAKBIOAmOwJ5pjLUgezAO4KQU1x4J0AOkH8CbwwKnhiEanrzzTeldu3axvuCer///e9NonI8O/BsaNy4sXz11VeGRMBLg1BX1guDtvgMMUGoKHJ44FVB8u9jx46ZnNOEkyInCKQDZd++fcbrYtSoUaZNSAryd5Ano06dOobAoD5kBf3Z8ZqHRYxnConH27VrJz/96U/llVdeMXPAI+Wjjz4y+TjI+YHXByQKicq5T24S+uJauGC+fFT7fan3wZvyQc035NMG9WX8uHFy6dIlWb9+vXzxxRdmTjzfoEED6dChg5mLHUM4XpXscKGoZIcLEP2oCCgCioAioAgoAorAI4wAOTembD4hdcfES8OJO2X9wUuSnnsn4hCpTGSH03CLAZ9T6vbEOq+cYuc0u5b7EQA38myQp4FT/KF4FZTk7fBjZN++fYfUfOd9mTVnkTGCBxseiX46dxpgvDb8eXdAANik3czLnSjbbdAPZN42ZwdkRyD1LQnBqy/jP2vAfiWMFN4xoebJAJOoNtESG7fLtEN7tMtcgylubEJJUs6cLV6+PH6CGZfWVQQUAUVAEVAE/CEQqWRHYWGh8U7As2HLli2GtCBXBYSD9VIhATnEA6QDeTXInQG5MWHCBHP/7t27hhDBA2T//v0mSTcJzWnzxIkTBjra4jPkAvkx7ty5Y8iCuXPnGg8J8Nu2bZsJj3Xjxg3zzIULF0wdm/ibPB8QL3iTECYLggNyISoqytyzYbfsWiF/0xcht/DgIKeGfR00aJBJUI6nB/PFa4UE6VOnTjUhs5jTjYxrkrB5jQzt1V4G9ekmA/vHyIyZMw3xwvfJyckybtw4E/aK0FfTpk0Twn8R5iucRckOF5pKdrgA0Y+KgCKgCCgCioAioAg8oghk37wrGw5dkvrj4+XDkdtlfOxxycy9I4UR6HnwsMkOS3A4yQ3C75B3AEOvMx8B+QlCMfxW9W1aatguTpA9Y+5KmfZO/aC9CrzlpHDiRyLLt2u+K7PnLjbEyrhJcwVvDScp4Os9xnzyg4wbN1sWV6vp9zlLwjyQx+Kexw8kWDAkjzXe014oONnnPRn/3R42wZIpFrd5r78nU6YtvC98V7AkX+meKCbAQiU72EfghHdHscdPbtDEi3P/6HtFQBFQBBQBRcAfApFKdjAviAiM91yQELxCgtiC3EsdPCe4IBWox3tLiPB/Pvf4zLO2PacswD2e5XvadH62z9AG31HsPdsmZAdeIJAfcXFxsnTpUpNIHAIGWY/23IU2aBPCxnnhjUK7jI/nmAv3eDXtFBVJYV6m3LlyTHLP7pO89HNyMzfLjJ/nnJjwHBdz41k7fvdYQv2sZIcLOSU7XIDoR0VAEVAEFAFFQBFQBB5RBFLO35AOc5Pkxd6x0nvxQTl2MSeomL6VCbaKJjtQWlC7uEoJjrwHyA1O8WNQ5kS/uYzHQYqpx3NaShEAU6dXQSj5KDC0+8pJYXuLT0iQt2u+I7PnFnt2hGJEJz/IgqXrpWNU34DCbZWMy+HdgULNvMtCdoSCky/jfzHBUBrKijkOb9DSL6FjSQ77SggysME7hN/A4dQTkpGZZX4vdh38vRaPpZQICmWdGI+v0F3+xqDfKwKKgCKgCCgCoSAQyWRHKPN9GM/g6TF9+nQTxupvf/ubvPrqq+Y9nhsQIWElGQrzpejGt1J05YhI5kmRu3kPY8qmTyU7XNAr2eECRD8qAoqAIqAIKAKKgCLwiCGQX1gkJy7nyLgNx6T2qB3SZtY+2XT4suTeLk6gGIlwVCTZUVBQaIzyGKizHN4bnBj3RG5w+p6E21PnLC8x/JaE9YlAL5ry3B9ur4Jg81Fg2CaBNYmsIZfwliA0llvZ5bTfW2/XlHlfLw05XJPNDzJt5mKZ/VZdv2TAuccel14d+pXsAWv8h/AINnyX9cxgb3EFi5Mv47+bdIKsCJTQsUSHfbXeHYwxftcB4+UUjFdTMRFUGtps8sylMj8ATxrbv331FbqrPPeztq0IKAKKgCLw6CKgZEf5rz2eGWlpaSYcFgnR16xZYzw6Ll68+IDsV6bRFN6VopsZUngtTQqvHZWi3AyRgge9RsrURxAPK9nhAkvJDhcg+lERUAQUAUVAEVAEFIFHDIFr2bdlfsIZaTA+0eTpWLr7nFzJuh2R4avs0lUU2YExPiPzhqQeO10Smuo+giMx2RifOW0PuTE4ZqyQaJucDT0addJQOnbBvLy6jduhhFCCVOjWqb/PhNSEO6hR401ZtXqtIagIbxRK3g6ewZBPf/RrjeveXj0a/3NvGtIs1DBW9A+5A8njrV/3fX/GfzfpNHrMLFnzp5cDbt/25/TucOYrcYaw8LIVzG3qXb2WWbJG/aNHSPJPfhn0OBiPzZviKXSXrzHod4qAIqAIKAKKQCgIKNkRCmqhPYP86LxCa8XLU7R9N08KM09LwdVUKbx+Rory78jDdIdXssO1Vkp2uADRj4qAIqAIKAKKgCKgCDxCCNwpLJLEY9ek1Yw98tc+G2Xo6lT5NvNmxCNQEWQHShSn0iE6OKXuDE21YUuizF6w2iSL5pQ9J++/qlFLdv/8NyUhjnydpo/4BQjTBErDFhXn7QDTCR80DNq47S9vhyE73nxT1q7bYHI4sJYTJs+XJS+/GVRftp+5i9aY8FnWyO/t1ZPx/8q1DMm8nhVyzg7IjkD7d47Ll/HfHcqK/d2xdS8hV4mzjUDer3rxdRk3bIohhe4LZ1XgO4xbfgHEYpYJf8VzeJhEte0red/5btBjYJx4hOAZonk7wvRj1WYUAUVAEVAEfCKgZIdPeCLnS8JX5WVIwaWDUnjtmBTlpT/0sSvZ4VoCJTtcgOhHRUARUAQUAUVAEVAEHhEE8gsL5Vx6nvRdeljeHrpVWs/cK/tOZ8rt/NKEg5EKRYWQHSL3cisUG+IJTcWJ+i4dYqRd697GKA+hwal5T0Zgf6fpIxX7cI7bEkqE+cLAHRu3SyAUPOHp6x4ECUSJN8N2sWdHDVm3foMJrURfrCcEgK923d/ZPBwQDjE9hsnhJ5/y+3zs71+UUSOmlhj/U9JOy6Ur6ZJ08Kgh0ALxZnGHsQoFJ1/Gf/c6ML+yeFWM/ri5zJ+/snjOu0rzd5icJY4NZE5lipjkoCVEx64D5rlQ83XYNcMjhDn4Cm/mGIq+VQQUAUVAEVAEyoSAkh1lgq/SPFx0O9t4dRReOihF2RdFCm7dy9r38IaoZIcLeyU7XIDoR0VAEVAEFAFFQBFQBB4RBCA6Zm49JXVHx0uTqbtlVdIFuXHzTpWYfcWSHWklRukpb9SWSz94zK+B2xpcfZ2mrxILEYZJuEMoBRoiymLMqz8vGkt2bNy4ySSLJxQZxEirqOA8B2x+EMiAQMkSvCPwksBbAsP73uQUOXXmvOzdn2LGEAjZQXJ0jP/0a69gcfJn/L9vHYKYn3Md7Hu8MXq26i6Ed2O8CfcIj2vp1yU375bgxcGF5xT5SwhdRU4T6tn59ew8QE4+/qOAf2u2b/vKGFhf1pn1pm/mqEURUAQUAUVAESgPBJTsKA9UK7jNwgIpzLkkhVdTpDD9uBTduiFS9PAPiSnZ4doHSna4ANGPioAioAgoAoqAIqAIPAIIZN+8K2uSL0qdMfFSe/QOmbH1pFzPuysFhQSsifxSsWRHsWfHjLlqJiRLAAAgAElEQVQrZdo79YMyvvo6TR/5qxCeGXC635mwO9h8FBi3/XnRWLJj8+bN9/UVrPeCzQ9iDfKD+4ySnb9+xu+esEQDz+3YuV927TtsXvkcKtkRLE7+jP/8ZYB8sF42jC1YfCzRwCtYdY+KltXrtxsCI37XfkM60P7V9Exz8T754FFzn+8trsP6jxPCYTnbC+W9ko3h+Y1qK4qAIqAIKAL+EVCywz9GlboG4atu3ZDCjBNSeOWIFOVeESmoHIfElOxw7RwlO1yA6EdFQBFQBBQBRUARUASqMAJFRWIIDfJ09F58UF7tv1kGr0qRg+dumER+VWXqFUJ23MvZYY2/nFInnFAwRldr5NZQOt53njtvRyj5KFgTG+qJEFWsGYZ7iBSKJTs2GbIjtzhvR2KyyekAIRXMmtq8HRjmg8ltYQ3v1qBvX0MlOxYsXS/DG7QMaux2DJ4wAqdweneAKSRU3+ZdS7xS+B3QN94tXLznHt4X4IH3CkngNz/3YlDz8rZ+5GQhN4u38Gbed6V+owgoAoqAIqAIBIdApJEd2dnZwpjz8vJMOEk7W2SnW7duSWZmprnu3r1rv3rglbo3btyQq1evyu3bt6WwsFBoNyMjQ7w9x32M91w846/QB/UYU35+folsx2faYPzcD6ngtVGYL3L3phTdzJTCzFOG6CjMOGnu3b1zW7KysuTKlSty587DIz6U7HCtrpIdLkD0oyKgCCgCioAioAgoAlUYgbsFhXIt+7YM+yZV3h+xTT6ZkCjbj16Vm3eqVviWiiA72Cb3GX8Tk4Vk5N5ydHgyuPo7TV9eWxHFEDN/0Nc9cqC8xuWpXcbq9CgIJR8F2ON1g/eNJ8N2CdmxadN9fQUaisq5tjY/iCUryMdBXg5nHU/vCclEaCb7nH0NhuxweoWQwLt1275BJRH3Z/xnv9i1iL8XUmr86Bmy7OUafufnac7c4zdAGC5IjCWrNpn5s0aW4AAH1o2wXNRLe+LHAfUV9/RzfudOW/SrZKOnX57eUwQUAUVAEQgnApFGdqxdu1aGDx8uO3bsMKSBxQLiYP/+/TJjxgyZPXu2fPvtt/arB14hIZDJhw4dKikpKYZ4oN1p06bJhQsXDPnhfujs2bOyYMECc/EMBImvQh9HjhwxY7p8+XIJMXP48GH5+uuvzYEWyJagS2GByO1sKcq+JJAbBVdSpfDigdKk5EWFcu7cOVm+fLkMGDBATp06FXQX4XpAyQ4Xkkp2uADRj4qAIqAIKAKKgCKgCFRRBDAan7mWK/MSTsvH4+Ll47E7ZOHOs3I12/+pqUiDpKLIDjB1hlgKxDDtNvr6O00fTuwxVkPQYLDOzskN+uI5njckSQUSH25SCQN1oEZvi7evvB2W7CCMlbuvqHYxkvW97wdkYKcv248lKyBnvmzbO6A2nAnO7fOB7Cmbs4M8H858H8HiFIjxH3xKkoXvPiCQKr069DNhqSzWobzSd8wX7aVxVIwhfRg75CGfIaoIexVou9TlOX8kE/lSIITi4vdq3o5w/qHRthQBRUARUAQeQCDSyA6M+FFRUTJs2DA5fvx4yXwgF+bMmSONGzeWSZMmycWLF0u+c7+5efOmDBkyROrXr29IE7w69u3bJ+vXrzfeHcjR7oKdun///tKvXz+Jj4/3S3bgObJw4UKZNWuWIT0KCooPcEGabNu2zZAs1Am4FN0VuZMlcuuaSM45kYy0Ym+Oa8ek6PpZkbyMkvBVqampMnLkSKldu7YhWwLuI8wVlexwAapkhwsQ/agIKAKKgCKgCCgCikAVQuBOQaGk59yWk1dzJPH4NZked1I+Ghcv9cbGy6h1R+Vq9i3B26OqlQojO0QMYUBeAU6ih5K3w99p+nCsTSnJccskYiaM0/5DaZJ8MPCL+jxHImcIHoiPggraO25SadykubLiz9UCNn5jJIewgLhgndwJqZ1kh7uvQMgGpxHe5gexZAWvU6YtlHmvv+d3vCS3796+ryEQ7POB9G/IjuWxJvzWhUtXi8NwJSRJsDgFavzHkMA+MInc7yUrj2na2a8nhRMnX+/xcoH8CMZLytneVzVqyahJ8wMKK2eJIm+hu8Lx+9M2FAFFQBFQBBSBSCM7MOSPHTtWPv74Y0NUWGICwzpERL169SQuLk7S0tLkwIEDsmfPHtm9e7dgZ05PTzcLDtkxYsQI+fzzz42HBWQHHhDUz8nJMSGnuHfy5EnZu3evaWPlypXSq1cv4y2xc+dO4w1y6dIlOXjwoGmfeocOHTJ9II9AxHTt2lUaNWpkyBdkOjw5IGHwDDl//rxpg/BYrAHP0i7tMPacrBsi+Xck9/o1SdqdIId2b5XUnetl97r5snv9fDmdvFluXT0hRZAc+bdFiiBTikka5gpGkDmMz12YP54v9LVr1y5DiJw5c8aE3KIuIbYYP98nJiZKcnKy8H1ubq75DsKGe4wXfOmP79xFyQ4XIkp2uADRj4qAIqAIKAKKgCKgCEQ4AojfJBq/k18oF67flHUHL0rfZYel/vgEeb3/Jvm/3huk/4ojknQ6sySubYRP+YHhVxjZEYYQS4Gcpn9gggHe8ERy7NvvyIVAPoQgLgzCGLghd1KPnTYn/PPvnaALcEghVWMeeKJYUoncDRipnQbuQN5786K5j+xw9RUKgWXzg1jCAu+HLlF9AjLeQ4pAjthngyE7kg4elQsXITvSDKkTCk6BGP9Zj3CHswpk/QKpA6nVMaqYMAokgTqkGaQQJBj7i33G/LQoAoqAIqAIKALhRCDSyA4M9cuWLZPf/e53snTpUpNjA3LhxIkT0qZNG2nQoIEx8E+fPl0aNmwob7/9ttSoUUM6dOggsbGxBjqM+ZbswJhPfouJEycajxGIBkJUJSUlGfLk3XffFS7IlU8//VT69OljDPyEu0Kub9asmemjZs2ahthYt26dyRmCl0j16tXlySeflD/+8Y9Sq1Yt4zmCZwpt8CwEAnlCVq9ebdqpVq2avPfuu/Jlly6yf0+C5F8/Lym7Nsq7b74mTT+rI51bfSFvvf6yvPXGqzJ6+BD59swpIT+Hu/gjO8Bq8uTJ8t5778lrr71m5kZIL8ZDOXbsmPTo0UPeeecdYUwfffSRIU8gQMBnzJgxhlR69dVXTR1IHfp0FyU7XIgo2eECRD8qAoqAIqAIKAKKgCIQwQjcKSiSSzduSVzKFZm48Zh0mpskn45PkJrDtkr9CQnSc/FBmZ9wRg5/e0NybnlPKBjBEJihVxTZQWfusEfkFggm5E6gp+mDXRO8LjBIcwIfjwwnyYEhHQM8hvyRo2aYvAWtovqa0D+E/3FeXTrEyIhhU2T2gtVCSCaMwhAk5Gw4nHqiQggPThNa4zqESyj5KDCUk2x88sylDxi27yM7XH2Fknje5gexhAWvgSZWx1hP2Cuw5rlgyY5Ll9MlJe20Se4dCk4lxv+EpHvG/zyPxv/yCmcVCKHhq44dP9gFQvbs/vlvXHk7lOwI9m+N1lcEFAFFQBHwj0CkkR3MiDBS/5+9N4+q6szThe8fd6171/q+9a1777r9R/XtWl39VedWdXUn3anu5Haq+0t1pTpdmc1gYkyMiWbQGCcconFWcBZREVHBWRTneUZAERCUQUEQFQEHJpmnM5/nW8972IfN5gBnHwFBf3utvfY+Z+/9Ds/7Hjjn97zP73nrrbcQGRmJoqIipSo4duyYIjToU0H1BP076MNx8uRJHDhwABMnTlReH7xGcoNpnqjs0MiOJUuWqKA+lRD02KB/B1UiJAVIrvD6G2+8gR9//FGRHQzkU41x/vx5VQd9OKZPn67aRLUDVSJMt8VUUmwTlSGsm2QH27J161ZFEDCl1TfffKPu2b93F9aHr8SE70ciYvl85KWcROb5/XjlpRcx7NPB2LBuDfbt3Yv58+Zj2rQfVZqsWh+psDojO0ji0LA8JiZGETPsG3+bkOgYOnSoIo9IhJCwGTNmDCIiIlTf+JoKECpjeE4Sh9eIOYmahIQEr2pGP+OE7NCjAagBZ541giibICAICAKCgCAgCAgCgsAAQ8DthtXhRGmtBZkltTiR9RDrz93C1JhM5csxNDwZ47dcxcIjNxCTUoy0wmpUN9lgdzzda5f7kuwwpj0ieRD34u9MqQ78WU1vZmZSbUFfBV8kR+zBMyqATq8CBuXZVqpLaBTtK4jM1Eo0e6bxNoPwetVBSh8SHkZSyawfBfuW9cu/AVf7Gw2p9WQHcTbWZdZ43ujboZEe/hJh9JqgsblZsoOKjpraelQ8qvakmErNQsjsUOT+4jmfY+trvL1KIx/pvoxz0JjO6viZJASPmdHpXPJVX0++5ysNmBFzkkkcH859KnA4thsjtnUgwIx9ldeCgCAgCAgCgsDjINCe7HDD3VQJV0kynLdOw3nzGJw3j/fyfgzOwvPKfwIuh19dYSorqgmokKCvGfvAFFZMM0VFRU1NjVInnD17VhEdO3bswMcff4yxY8eqlFO830h2LFu2TKlCmJ6Jaa9IblC1QZUD1SRUhZAQ+Omnn9R1prtimiuSHSRDoqOjFYFAgoOKE6Z6oi8IFRIkA7Q0T4xzT5o0SXl5UD2ya9duvPXWmzhx5AAc9WW4lZmIVQtnYvL3X+H4ni3IuHgK/9/v/hnTfpyKzMwMML0W+zV16lTVfxIzxq0zsoMps5g+i30dNWqUUsPQ64TkEftK43eSLyQwqGSh9wlN1vkM6+X3qyNHjuDll1/GunXrFA5Ug5DU4DXjJmSHARFRdhgAkZeCgCAgCAgCgoAgIAgMAATccMNmd6K2yYabD+tx8Mp9zNp3HYNXJeHf5sfhrSXx+DYqDeFnCpBy6xHqmh1wu7QMswOgg4/ZxD4lOwxpj/xdwa8P8mqr0T1BeKbS8b2a3h9YNKKDqguqL1gmg+YHjp1Xgd2Vw8eqYC8VJfo2+HPOQDHTLFHtwVXzLLevCA8jqWTWj4L9I6FDBYvRt8NIdhjr8kddocePONEfRCM5tCPHgCbc+nt9nXNsZoydBapK/KlbkWXKs6MA9Q1NqKtv9KT8SslUShYqWnzV4+s9TWlEVUh3Pha+0lkdPpmIJaOn9TnhwbEl0ULCRcObRyqSFn05HvTxmDFmhhoXYkpV0+m4FG8aN35WmJqNCiKOv2yCgCAgCAgCgkBPItBGdjjBL+XO+2mwHRsH6/a3YYn+N1g2/aF39+jfw7r7E9hTIwB7i19dq6ioUAqJcePGqfRT9Ntg+ioG8emjwX3Xrl3KrJwprJiK6Te/+Y1SWTCQT4WFL7Ljyy+/VEblmpJjzZo1YF3cqNQgmUKTcpIhJBkY+KcC4p133sEf//hHlVqLqZ9IfFBxQsXEnDlzlIcIU2dx08gOKjvoLcJ7P/9sCNITTwANd1FVkIzT+7Zi1Mjh2LI5GlevXMGrr76qlBQ0NCdhwbaQ7Jk8eTKYTsu4dUZ2kLShzwaVJiEhIYoU4rNUczCN1/z58xWpQxUHiR3iwT5QIcN6SIxcunRJKWCYIoz3k9hhfRaLxdgMRYJoZJHx4pYtWzB+/HjlHWK85uv1f/L15kB7T8iOgTZi0l5BQBAQBAQBQUAQeNYRcLndqGu2I+VWJVaduolRm9LwcVgSPgq7iG+i0rD8eD5OZZci70EdymotaLDYlYfHs4Rbn5IdhrRHTD80fsJ8v4PLDDibWU3f1TjqiQ6SEAz2Mmi9dtVmFWQP1PDZGBTnCvoVIyZg9+6jPgkPBov5I5E/yPiDjz/aKOnXNk3ez+vazvv19zgcDvWcdr3FQnP1aqRn5OBCcgYYVKcHh7Ft3b325dvBlXb8kc5Vi9wY6tZ7hATi26HVow+889wfHwn2QVOhBEJ2NDW1KFUPyYpAcFrz2SiVdssfH4t26axa59yTIDzWDBvjnY/JadlIz8jFpcvZav6vCd+G6J2HFRGipWFr858pQHZOgSI6qmvqlKpHm6dyFAQEAUFAEBAEegqBDmTHgyuwnZwEa8wHsGz9D1i2/qmX99dh3fs57Gkb/CY7+P2NZALTUDFgTtUFPTGYeooKAxprMzXUzJkzVZoqvp42bZpKH8U0Ugzcd0V2kMSgsoP3aGQH02JRpUEFSUZGhip3xIgRCA0NxYULFxQJwHP6hlD14A/ZcSE+HtEbIvHZx4OQdmYP0FCEquJcnDp2EKNHfadSXWlkB8kIqkn4vZSptqgwoYrEDNnB764kakh2UBVDvxBu9OJgWipNKUNihveRyOC9TLs1a9YsZUqupe9iCiuaoLO/JHyYusu4ibLDgIiQHQZA5KUgIAgIAoKAICAICAL9FAEGYK0OF26XNyjfjSk7M/F5eDK+WJeKGbHZ2Hj+Nk5fK8WNB3WoabLhWV6c3JdkB6eLMe3RnGmLUfizn/sdiOdq+qAJ85VPQ3er6Tubnr6IDioDZk0Oxol/fd3vtnRHFmjX2WYGmLe1mmnrFR4VlZU4ceIEVq9ejeDgYNC8kqkQ+OOPOYz5gzE2NlbJ+Llyj3J+/uDlikESJSQ6SEBQ1s+VbkxPwPsWBIdgyfJVOHj0jCI8xk5cYFpBcOC1dxC5cXe7tEXJKSntyY4eILA0fxAj2UEiIGT0NBA/DcvOjiRMfpoVqpQ4nd3D9/XKDqqC2qWXSs1SapbO0pT5KpepzZiOzZjuy8zc0wgPEmO+6uip99gvzsP1rWm/OA9z8u6g+F6pN5UX+8G9jeC4qcgg+tlQCUNii4oO+tzIJggIAoKAICAI9AYCbWQHU0i54W4sg6swHs4bB+HI2dMnuzP/GNylWfA3jRW/kzEtFAkMmocz6P/tt98q1QQXqDBtFN+n0oPpl5jWiioIkiMM4DMtU2dkB9NYUf1AsoPKEZIWJBhY5hdffKEUFSQ+SLBQzUGFAsunWoRqCVoykOxgeicqQ6jsYKqrDsqOLZtwJSkOOzeuwtuv/xvOHNgGNFWg+HY+1kWsVamujh07qogVKjv43ZN9ZlvoFUJ/EJIQXZEdVLvwXm3j91im19JSdPGc382o5CBpRLKGfed3YhIrLJttJ8FDvxJ+h+Z3ZvaX10i60OidHh68xk2vQhWyQ0O+9ShkhwEQeSkICAKCgCAgCAgCgkArAiQLGq0O3K9uxoOaZqWQeJLgPGqw4mphlUpNNXRNMt5akoAfNl9BdEIhMotr0NDiX/7dJ9mHvqq7r8kO/uBgkJmeCQyqBpJiycxqeiOOvlbXU2EyK2g+ejvYHP3xyHaER+a1PMQnXMTYsePU6j+mGfjqq6/Uj0eSGfwBmZubq1YBMk8x5fs0puRqNRIg/LHMH3hMbTBlyhRwNR+f/9Of/oQXX/wtBr3/EbbH7FeKkhlTg5UCwkzg3KuiUQbcBWrcjMoO4msksIzeD93VqSkzSHZQYZDWqjTga/px0JejuzJodE+zeHpMdHVve7KjSf0A1s9Hf9UkWh2sl/01pvsyzjv9a19kGwkPkm37Xx/kF7mj1e/vkYTiT+PmeBUdbYRbnSIxCu6UKNUGP5dUb9DDhgQHsSG5wTEmiaz2Z5kd1g+knAsCgoAgIAj0CgLtyY5eqaJXCmXgnkoOGpX/+te/VotPuICFwXuajjMFE83E6W/B1FX83kffDn4Xv3//vlrQwu9xTBlKw3ISAPz+xxRRJC5ILvB+mnlTYUtyhOmwSJqQEElKSlJpsbjohampSKLweT5DxQMJFT5LUoIkAsugwTeNyieMG4ctG8KRl3oacfs34bOPP8DKJQsRd+YUdsbEKBKDRAm/l7KuV155RRmfa2QHSQZ6dpCMYT3GjThwUQ7JmKioKKU8IWlBBQpTVtHYnfgw1VdcXJxq7+DBg5XheUFBAbgzxRb7SPzCw8NVv+iHwu/MVMeQ/CHOKg3X558r8oftELLDOBq610J26MCQU0FAEBAEBAFBQBAQBACV8qnB4kDRoyaczSlD2OmbKl3UmWuluFfVrAgQp4vhsd7fmLKqxeZESVUT9l4uwcRtVzFo+QV8uS4Fa88U4Eqr4bjF7lTt7ptW9X6/H7eGPic7DGmP6GfBALS/QVveZ3Y1vYYRx5yBWwZy6TvAYDpTV82dshAMWptpQyD3UqGw5NvJyhOE6aUOHDmDFWFrMWFiEE6eOqVW6u3cuVMRFvzhyRVs/HHLVAd5eXkqFzNX7lGezx+2/H3ClW78ockfq8zVzNQGzLn83ahRWLR4KY6fOo/EpCtYsGQddr72jqk+sr00Z09MvqpW/jP4nZR0qZ2yg9gaCSyzxvN6fxASHXk376rUSiQQziakYur4uX4RABveH470Xz3fZR99kx1NHt+O1CzTvh2cB0zFRsLMjNJIT3hofjGcixsid2LumBmmjNK7mosk8OjBQQUVseScbyM66lUAhiqN5haLUm1QuaGpN7wEh5Ab2p8QOQoCgoAgIAj0AQIDlezQFAkM+v/ud78D0ypRScCNnh0kJ6hs4OIUqhao/Jg3b54iJvgdjupekiE0Ced3QKaJ4vc9BvqpnqDagSpgEiJMicUyeJ3lkmygcoNkC70rSHKQeCCxQbXJ9u3bVVv4PZKqCBIgNAC/kBiPo4f2Y8Gsqdi3eTXuXo1DaX469sfuxKSJEzD0009Ve6kG4fdRpuvi908+T2KC6hCSPHxv6dKlyjPDl0E5jdOpYv7Hf/xHtSiHRM+7776r8CBRQdKDhAyx+fzzzzF69GilgmG5TG1F1Qr7y37xOs93796t+kzPDipkiC2vERsSMyRBjJsoOwyIEGBKf8iOySYICAKCgCAgCAgCgsCzjoDN6UJpTQuOZj7AgoM5+CIiGe8tT8S7yxIwPCIZiw7n4uz1MlTW04Og99FiOqrkW48QcjgXwyNS8H7oRUzZmYVjmfdRVNmkiJDeb8XAq6HPyQ5D2iMGeBlQ9ydVkRbUDWQ1PUemnQKhlehYOnMZcp77TZcBcq3enjjSC4QqkrMJlxG1eRemTJuDsFXhKCi4pSYPlRMffvihWpVGST5/VGo/JHkD3+MPYxIe/NGrpSDQzzyujhsyZAiOnziJy1eycTElA6Hhm/DTyCDT/VTkwJE4byA/IfFCR7LDQGAFYjyv+XYw8H8l6wauZuWpOhmcJwFAxUN3+Pszh3yRHRoBRrKC6cx+HDun27r0bQlUaaQRHiTfMrLzQf8M9pfG4SGzQxUJmPjCyzDrH0PTdz5Hk/HpU0JADw6WSyUV8c3Nv4Pqmnqwfm0jYaVUG6Le0CCRoyAgCAgCgsATQmCgkh38X0pFBtUPVBlwAQoJEG5cnMLgO5UHVCfwOxxJDcaaSQ7w+x7JCqZ4ouk3CQTeTxKDxAc3lk1zbQb3uZN8YF1URvAZqn2Zyolpn0gesA5e5870UCRMWBZVFryecikJpcUFeHAzHTcuHcX9a/FoKr8DR3MtKivKVLoq9oPfTW/cuOFtB8tg2VSjsH/sN98jKcOy2RfjxoU59OGgKoPEBXeesx1sG7/fMj0X+0UFB8snQUI/O2LBxT/sF69xZ9+JL+vikW1kWbzG+1gW8TBuQnYYEBGywwCIvBQEBAFBQBAQBASBZxIBh8uNu5VNyvNi5Yl8jFyfqoiFLyJSMXvPNcyMzcawiBQMCr2A7zelI/LcLSTdrER5fccvnD0BoNXhxM3SesSmFCNoZwbeXJqg2sS2pdx69MRTavVEH3uzjL4mO9iXdqRDahYWzFymjMf1AeTuzs2upucPMX1Qm8HfqE17seuND00Ftrtrlz/XM371PBbPCcXKNRsxeuxkbN62C8Ul91SwmT9yuWqNK9KYBoDt1jae88ceV/2R7OAPT/541jb+4KysrFS5mCn9J4FSVv4Il69cR8SGbfhhzEzTgfMj//K6SjXGQHnW9Zu4mJSMd95912tQzrqN2AZiPO/1B0nJVEQHfSToJ0ECgoTY1KBgMIjvD75d3dOB7PAxH6dMDjGFE4mFsNAov307tPHikaoKzkuqZkhCaCoPqlqoemK5bA/JoAOvvolTL72qPitMMabtVLMcfeU1rBw+Vt0XNClEPUfSpL3JeJ5SNRmJDn175FwQEAQEAUFAEHjSCAxUsuNJ42a6flcLUFcCVBcAtXeA5grA0WK6mIH0gJAdhtESssMAiLwUBAQBQUAQEAQEgWcGAZX+x+pQConkgkqsPXsLYzal44OVF/DVumSl7Dia+RB3Khpxq7QBh64+wKy915TCYvCqJEzemYmY5GJkF9egot4CqkIed3M43Sira8GlgkqEnsjDiA2XoeqKycShK/dQUtUMu9MFpreSrXMEngTZweC43iehL3w7OAs8dd5UQelAA+hMC8TAMncGns2uutcC8VQDzF24Ct+MmoDN22Jx+06RIoFIYFBNzpQEXNFGU0tuxIyr3pgSgWkHmMeZsn79xlVzXIH3008/qbzJDBawz1cyb2DL9r0Y9/20bj0ttPZpRwbU505fjN37jmHfwRNYvyEaf/zjvytzSH3dRgLLrG+H0R+kprYeFY9qPMbZKZnYtHU/tr87tFfIDuN8XLFknSmcOAdISJjx7dBjx7lJoookRP6tIkUqUelBoockE/cjpy4gcvM+hEfuVOQgCUJtXxayFuFRsYg9eEbdpz3D51kOSSrNg4PEipiL69GXc0FAEBAEBIH+hoCQHb04Ii4X3A4LXM2P4Kq6A1fFDbiq78DdVAE4bYD78X+j9WLrH7toITsMEArZYQBEXgoCgoAgIAgIAoLA04+A2w2H06XUERlF1VhzugBfrEvBm4vj8cnqJMzaex1nr5ei+FETmqwO5YVB5UejxYFb5Q04dOU+xtE7I/QCBq24gAnbrmLfZQ8RYbW74KKfR1dcROtl3kbSgjs9QFrsTjyoacHulBKM2pSOt5bE44t1qVh9qgB5D+pR12yDU0gOv+bnEyE7DGmPAvHtMLua3hiMN6vqoKqAwXamBWJgWe2RO1WQ+9Brb5sOwjMV15QJc/HN6InYuDkG6RnX1Qp/phoYNWqUymusJzso46dEnzmJF+BgJ+AAACAASURBVCxYoOT9TEeg3+jbQcPJGTNmgN4fDY2Nyn8hIzsPZ84nY9W6HYgeNMxUW5kaasK4ufjm+0n4YsRovPfBJ/inl14GDSH1m5EwMEtgsR69P0jFo2rU1TeqID2D9lTimCVQNMJGf/Sl7PAQYW2+HVtijmLT+1+Ywompr5gCi20lsUBSgZiY2TSVBwkqKj1YDs3CaRpuJD80QkN/bCM3ujYZN9MmuVcQEAQEAUFAEOhrBITseFzEtd9X/B7C89bd5YTb1gJ3fSlcFflwlefAXVsEt6UWcLb/Tvm4LeivzwvZYRgZITsMgMhLQUAQEAQEAUFAEHjqEahttuFiQaUiOb6PTlPKiSFrkhF8KAeHrt5H7oM61LXYfaonSEo8arDialENtl28i0k7MhXh8Vl4slJ9HEj3eGlQodHZxkvNVofy/bhb2Yic+3VIuV2Fg1cfYMGB6/gs/BI+DLuIOfuu42jGA/Aeuyqv8zI7q+tZff+JkB0+UkqNCwoGjar1gemuzs2spmfQ2ZjCiql+/E2LxPtokk11gfI+SM3ypAdKzVKv167ajG3vf+5327V+hQ35BqPH/4TwdZuRcPGyUmFcu34dn332GcLDw5WZJdvOPT4+XplMMoVVXFyc8urg+/qNuZNpzDh37lyV4op5jLV+0w/i5NlLpv0o2NbVQ7/D0rCNKhXW/JBl+OO/v46z587pq1acJY2tqSLQUjCRWND66s9RERE6f5D6hiZUVrWpOwLxAjHW65PsMMyPQHw7SI6QJGHfiQGxaD867eDq9IUa79bUWhw7lkMcjOQHCRD9TlJEU2/wfj7H50nysR3GudJpA+SCICAICAKCgCDwhBEQsuMxB8DlBBxWuG1NishwN1XCVf8QrpqiNjVHZR7c9Q8AayPgcjxmhQPncSE7DGMlZIcBEHkpCAgCgoAgIAgIAk8lAlRP1DbZQSXHtqS7+Ck2CyQoaEA+a282tiUVIbukFjVNdrVQqCsQGItleQ9rWxB/owJhJ29i7JYrGLrmEkZFp2PN6ZtKGXKlsBrphdVgiqz43HKcvlaGY1cfYF9qCbZfvIv1cbcQdjIfCw/mYvrubPXs4LAkjIpKQ/jpAqTdqUZ1o63b9nTV1mf1mhmyQwvEquCpZ61YwIFUo9Ji0fwwZP3yb0wFx/1dTc/26gPxh08mKm8DYyC8s9eRQ77BjphDitggaeBJDVSgvCXosUAChIbSub94zlT7qe4IGjsLc4OX4+iJOBXQPn8+HvTb2Lx5MxoaGpS5Ynp6OpYuXYrx48fjxIkTyojROF9pVM773n33XaxcuVI9y/EizuUVVUi7mqPaadaPgpjEvfg7rFq9BReTM7B77xG8N+iDdp4dbAvr0ogVKgwCMZ43+oNQ2dHU1NJO3RGIv4t+XCMHj8SOPccVUaAnJIzz0SxOyb/5LZj+ikoLkhD6so1j5e9r/eeN7dPID5bta29HbgjB4S/Mcp8gIAgIAoJAP0NAyA4/B8Tt9KSesjfDbW3wEBvNVXA3VsBV/wCu2hKVospVdQuuyptwVebB9ajAk7aqoQywNT/1aauMSArZYUBEyA4DIPJSEBAEBAFBQBAQBJ46BKjGYAqolIIqzN53HW8sPo93lyaqVFFbLt5Ffmk9rA6XaVKBwWaHy4XaFjvO55Zj/oEcfBB6AX9a5Ek/NSUmG5N2ZuH7zVdUOqoPw5Lw1pIE/MfC83g95Dz+tPA83lwUj7cWJ+DtJfH4MPQCgnZk4ljGQ1Q1WsHUWbIFhkB3ZIcWcO0q2BpIkNVDQDR7lAApmdi49SB2vz7IFFng72r6NrKjQAWjzdSleUmQ0GAQPze/EJWPalSKJZIIJD4Y4D6bkIqfxs0xpU5hEH7+iIkYNW4aIjZsxZm4C9gYFY2vvvpKkRo0H3/48KFSdAwfPhwhISFKsUGTcqasslgs3hX79+7dU6mraG6+a9cu72Tg+JWVVyIuIQVHjsdhcfBqU34UbCNJGaaQomqBZMeg9z9CXNx5bx3aiZEwMEtMaFhr3hfE2WazKxJIw9ksUaUnOnjOObM15mgHQoI46X1kSO6Q5DE+39lrr9KoB8kODVftqH0WOZ997galj/acHAUBQUAQEAQEgYGEAL/jFBcXgwpV/u+TTUOgLR2VSjtF5UbzI6XQcFXfhauqAK7KXDjLr7fuOXBW5MJVWQBXTaEiQNwkQ2xNz5Saw4teq//d7du3wfSwxm3Lli1qYRGV0v5s/8mfm/r7PUJ29PcRkvYJAoKAICAICAKCwOMgQAUGfTCOZjzEmM3p+GDFRaWg2JVchGsltahssMJid5omOvRtYh31FptKN3UupwwLDuZiaHgy3g+9gCGrL2F4ZCpGbbqiiIyfYrMRcjgXq04XYFNiofL6OH2tVBmSZxfXorCyCTVNNji7SIOlr1vOfSPQGdnBn5ZtBEdHDwEthU536XN819pRCRBIELvjavpmnz+K2ReuhGebSUyYUZGQgCE5wucYcGc6IZpJ88d3U7NFqQ40dUf0ln3Y+vYQvwPkDJxTzTAuaDaGj/genwz9El9/8x22btsG/tCiIfn58+fxhz/8Ac8//zzeeOMNlaZqxIgRSumRmZnp/bGWkZGBefPmITg4GCkpKV7Y+ZkruHUbayM34ftxUzFi1CSsGDzCVBvZzvET5uNcYhq27zqADz/+DKfPnO2AtZEwCMS3I6i1njbvC0sHdYeZ8TOSE52SHd454knDFUjKrBljZuDEmaQORIp3MOREEBAEBAFBQBAQBLpFgN9/SkpKUF1drQgPF021W9N6PrNHZSxuh8vaCFdjOZzVd+GsyIezPBeOshw4y3LhrLgJZ9UdOKnoaCiFq6kKLks9XCRF7C1w261wO2xwOx1wu58tTDmHGhsbUV5erog0LhgybkJ2GBGR14KAICAICAKCgCAgCAxgBKjouFlar7w1vt+Ujk9WJWH23msguVBS1QSbw9WjvWMAln4gGUU1OHz1AXanFGN/2j3lu3HmejkS8yuRersK2SU1yH/YgLuVTSits6C6yYYWm1OZlPdog57hwoxkRxvJYfH6BNCDgIF+BqAZ9DfufJ/XSSboyQ8qPmi63NlmVAL0lm+HkewwU8+az0aBge+24HuL14uBpEd1TR1y8u6A6a3ik9IRNNGc90jZ//gzTJk4D8vDIrF42WrsjIlFQcEtUNXB1FS3bt3Cpk2bsHbtWpXaiumt+GPs9OnTKhCgmZQ/ePBAESNMZVVRUeGFnD/uSsvKceT4GYSFb0TwktUYO26uabJDw2Hrzv346JNhOHX6jBcHrbI2nAP37dDq0XtfEGeSTJq6gyoaeqjQ1NxIZnT3ulOyw5CGi8QOCZ7uyuN1toMp2BaMmIjoHYeF7NAmhBwFAUFAEBAEBIEAEOCqe6o7qG6lmpUB6mdnr/D0taK1z2WlKH94D+X37qKs+CbKCq+j7NZVlBWkoexmOspuZaL8djbKC3NQXpSP8pJbKL9fiPKHJSgve9BaFsvU9mcJy/Z95VwqKysDU1k5HB19SoTsCODDKo8IAoKAICAICAKCgCDQHxEgeUCiY93ZAny5LlWlj5q3/zrS7lShizh1f+yKtCkABPRkB4kJEhSaGXJGdl4bwdFqxn3g2HlE7zyM8KhYtW+PPQ6+x+C0RoJ4yI88pXqorqmHw+n02TKjEmBZyFqk/+p5vwLMWhCaq+mPn0lqT0YYUh60BeE9yo7vgkL8rmPu6Gk4cuqCCrQzrZKm6tBULzW1DSi+V4r0jFyFQVhoFBJfeNnv8tkPf/rgE0A/3zSSSkxJxdRUGob+HDUVzTZFdnyBU6d9Kzs4f2iUzTlA3w6z5I/mD8K55PG+8Kh19OUypdjqsGice+lVU31gPzsjOwilGZyYcuvoK68h5JvJGBMUotRCVAAlJl99LINyP4dUbhMEBAFBQBAQBJ5aBPj9kCvvSXBQ6cqUVgNqLylBcck9FJfcb9vv3Udxdzvvv1uEorxM3M04i7sXY1B4dh0KT4Wh8NRqFMZvQmHKIdzNvoiivAwU3c5DUeFtFBcVobi4xLAPMMz6YIy5MIiqIe27vPEDJGSHERF5LQgIAoKAICAICAKCwABDgPHgJptDkRrzD+YoNcdXkZex6tRN5D+sVwoKBok7LN8eYP2U5nZEQKUAaB3affv349OhQ5Gfnw8SEwxU60kOBpZPnUsGg/gM6jK4u+PtT1Sgl8FeGj7zvaBJIeoe3stnGKxmeqfc/DuqXF+ERxsJ4VECbIk5qoLR/gTftXu8aaZSszoNMrfVU4DT55JBY3Pt+e6OvJfPMPBOYoOG2fR20Aghql6uZufh0uVs1e/9R+KwdOREv8tn/QdeeweRG3crzFgey1efvY5DF9A7RlLJrB8F26h5UmyLOYDBQ4bj2PFTihwwNshIGJhNOaX3B9HShnHucDeqO2aPn4P6/+v/NoV1V2RHVzixXadeehUrh4/FmInBoB8JCT8j0cc5n3+rSJGGLE82QUAQEAQEAUFAEDCHAP9/UpnKoDRX4A+43doCe1MN7I2PYG/gXqnbK2Bv0O315bCrvQz26hJY719Fy5XNaDryPRo3voLGVf8bjeEvoGn722g+MwPW3COwVRfDbmkE1b12u00dHXb7wMOpj8eW86kzooMzVMgOc59TuVsQEAQEAUFAEBAEBIF+hYDHO8MO+mZMj83Ge8sT8f3mdOxIKsLdikZYHb5X4verTkhj/EaAPxoZduWuKRLoYcF91+5YDP1sGNLSMxQxwWAtiQoSFgzkMljNgD/VCl2lDWLQmffw3rWrNit/B5aR0gXhwXbpV+yTKDFDRDAIz/RBbKNRCaAHh/3WPDuOnEwE1RrdkRzadU3ZQUKDCg6SQR3SerWqXthfqkzGTwpR5IBWRndHozE3g/ocp57a2vofuB8F+8Cx2bBpNz75bAR27TnoM6DvqevxjOc1f5B2qcN0c0XzSInatBe73vjQ77FkH7okO7zzpA2noHFzVTorqmHCI3ci9uAZpd7gfOPuUTG1pXAj0cHUZj05fj01D6QcQUAQEAQEAUFAEOhlBBxWuCpy4cjcAUfaOjhS18CRuhqO5FVwJK+E49IKOJKWw5G0FI6LS+C4sAiOxEVwxC+A4/ho2Ha9BevGl2BZ+//CGvVb2A6NgCMlDK6C43CVZiozcjhors1vXLL1JAJCdvQkmlKWICAICAKCgCAgCAgCfYgAFxuX1VpwJOMBfth8RZmDj9tyBQfT7+NBTXMftkSq6k0ENIJDT27UNzR5FQn01qBaYd2GrRj25Xc4fipe+U4wYM89asMupdggmdBdsN54/cS/vo55kxYoRUh3hAfb512xn5qFKZPNEQXN/+W/gh4cTKPlVQIYiIK2YH8B9h8+Z0p5oXlIULnBVFX05lCB7laCg/4RVKSsWLJOqVuYkooB+K6IISNevHf8xGCV9skY4O+JOWIklehHQSNwM23UiIJlqzbhk89GYnvMPkUgGX9qG+sKxHhew1zv28F6OFeoPqJaSEuTNTUo2JS6o0uyo5VQIWGhkX6cL3GJaZ4x90FukPzi/OVni4QaybuufGp6YjylDEFAEBAEBAFBQBDoZwhwYZG1Ec6Ck7Cdmgzrxt/BsuFFWDb8PSzrf9t+j/xHWNa37jyP/CdYIn8LS/j/hjXib2Dd+SZsJ76DMz0czpJkuJse9bPOPp3NEbLj6RxX6ZUgIAgIAoKAICAIPOUIWOxO3K1sRGxqCUZuvKyIjll7riExrwJVDVY4Je3KgJ4BHQmOtnRLGrlBQoCBYm1l+uq10Rg+4nvsP3xakRwkJ7Zt2ovoj0eaJjn0QXwab88ZNwsMdncgPHRkBNvMtE0kXtgmkgb0h9CX1d051RespzOi4HHIDi1NFvvAnUQBDcuZ1mv6lBBMGj9PqQXYZrMplfT9YnokqgaMAf6empBGUolpmKgo0behu3P2cf7s5fhk6Ahsj9nvSbfl42+GsS4zhvBsg+YPwvmg9+0gFkw/4CXHUjLVWJAc6a7t2vWuyA6W7yFU6kDCQ/vMsA3c+doXucFnOMfU7gOPnhpDKUcQEAQEAUFAEBAE+iECThvcNXfguLEH1thBsET8Lawb/gnWmD/CFvsWbLHvwrb3fdj2fgjbvsGw7RsC2/6hsB0YBtvBL2A7+CVsh0bCdmICHMmhcBbGtyk4nHbA7eqHnX76miRkx9M3ptIjQUAQEAQEAUFAEHjKEbDaaUTegKiEQny+NhnvLEvE4sM3cPVuNRqtdjC1lWwDFwEGgZtbLB38JIzkBoPpDNqTHIjcvA9zpi/C8K/HYN+hU+r9niA6tMAyVRckPDQfD66WZ7CYq9+12cajJ8VU7/l2tNVRgIPH4pViRWtjd0em5pofslalMGIqI6ZYYnCd75PQ6e55f693NOZu8mLUE7PSSCpFbIjBkX953VT76dsRNHG+UnZs27lPkQ4M9Bs3Y11mfTs0fxBfah2OpT71GeeyP4brnIvpv3oe876ehB17jreSKL4xpjKDdXBeGne+L+SGccTltSAgCAgCgoAg8Iwi4LTD9egW7KmrYNn4Aixh/xPWPe/AmbsXrvIsuKtvwV19W5EhJETcNYWevfYu3GovgruWezHc9ffhbn4E2FsA+V3W5xNKyI4+h1wqFAQEAUFAEBAEBAFBIHAE7E4nLt9+hCVHbuCjsIv4NDwZkedu4caDOjRbHYEXLE/2CwQYXCbRUXCnRK0+b0dwtJIb9JKI3nlY+VtwpT3VEAdefRPBX07AV98FKbKDigUzq+T9CeSTEGBKKyoiuFLfmGqKbdcHr5kWimoJf8rW7vF6XvhQAnCA9GSHWYNytn/l52OUOTVNqrU6e/roNeb29sF3ID7QCdeGgYdUCsRInX2e/d1UfDp8NDZti20jrgw/yI11cd7R1N4MZvQHIUnmS61DskGv7vDVF6boyv3Fc9j174PUXOecXxayVn0G/FHPcF6yHx12Q18DHQ95ThAQBAQBQUAQEAQGNgJuewucRZdgPzUZlg0voSXs57CdGA3n7RNwW2oHdueewdYL2fEMDrp0WRAQBAQBQUAQEAQGHgIM11XUWZFwoxwLDuTgs7XJ+CoyFdEJhbhT3gi7U2TRA29UO7ZYCy4zzQ4DudxJGmyPPa7SQtEHg14SDDjTg4Or3LXAM1MG/TBqqiI75kxbjMKf/dx7TbvncY+XXngZoYsiPOms0juqO9oFr1Oz/Fqpr2+T5nmRmHy1A5lCtDR8mIoo8dIVjJkY3ON91LfH33MtIE/SKeSbyZg8dbEihDypm3qY7DCQSgmXriifELbB3/byvl3//h6++DoIUVt2K6N2Kh+Ir34zEliBGM8z3RS9UHwRE6xPT5BR3UH1CNUxisD7ehJGTwzGhAmLMH9VDA6eSPR8LlpNxakwYpoqlsG2yiYICAKCgCAgCAgCgoDfCLhdcDWWw5l3ELYj38Gy/iVYN/8B9nMz4Lp/WXl3eL59+l2i3NgPEHjiZIfL5YLFYsGjR49w7949tfOc73W18bmWlhaUlpaivLxcnfM9f7abN2/iu+++w+nTp/25Xe4RBAQBQUAQEAQEAUHgiSHA+J3L5UZ1ow0ns0sxfmsG3l9xAd9Fp2F3agkq6y2StuqJjQ6V6Z2sGtdWkpsMwOqD+VRPzJ6xTKkjIgePVP4HTAvUWUCbxMfYH+Ygats+tQK+s/se932vJ0Un6g69b8eq1VtU4NpMnUtHTgRX+PtSAhjx+S4opFM8zNQZyL1UoRx95TVlkj4mKAQhs0NVOrEDx857iSqSVr5IhMedskZSKRDfDpJlY76djGhFdrCdzT4JA2NdZo3nO/p2tCdV2pWfkgkql+bPWq6wjNp9EsND9uHrJfuxNjYeNJenokjz3SDRUV1Tp9JRPS6m8rwgIAgIAoKAICAIPEMIOK1w1z+E4/puWHe+A8vKv4Rly2uwXw6Hu6EccIlifqDOhidOdpCwyMzMxKJFi/DRRx9hyJAhWLp0Ka5evdolpo2Njeqe0aNHY8KECbhy5Qqampq6fEa7KGSHhoQcBQFBQBAQBAQBQaC/I+BQRIcV2y8W4duNaXhrcQJm7rmGczllqGmygddl61sENIKDQVquKDd6Aehf8zrv4yj5s/LcGMw3G1hePORbTJmxDOdeerXXSACad08NCgYVBe0IiXbKC0+KpUDSadF/gj4UHlPrm54gfOsQG/Hxx+MhECLD1zNMT3XqpVdBsoeKEhIM4VGxiphRKpxWtQExYUCeRAfTkTEtmT9jb2YWe3CgGfxNhVPkxt048No7psac5Nj34+YiemusTxWN1h62XU9gmTWe9/p2dJLWi33R1B1UanDctf3QuTR8segQRi4/ho2HU3A9v1Clvapv8Hhw8Dn6csgmCAgCgoAgIAgIAoKA3wg4HXBV5MKeMBeWdX8Ly5rnYD08Ao78I4oAgZ+L6f2uT27sUwSeONnx8OFDzJs3D9OnT8eKFSsQFhaG8ePHY8OGDaiurgYNGo0bv3AXFBRg/vz5eP311zFixAicP38e9fX1xlt9vhaywycs8qYgIAgIAoKAICAI9DMErHYX8h7WIzrhDr5efxlfRKQg+EAOEvMrUNVo7Wetffqbw6BsG8HRrIKuNOlmUJsrzY073+d1ehIwWKwnPjpDyxjMDwuNUgbavoLvvt7jKnoG4klI+LreU+/teuNDRG3aq4LSeu8OfeCaQX/6e9AI3Ey9Xt+O1KwOQXgjPmYD72baQY8PplOi9wn7QGIlPHInYg+eAdNsaQF5jdzQ1Ab6MSfR4ev3TGfj7+/7/D2kEQSsnyb19G4x0z/e+9PIIKxat7U9aWVQI7VhHrjxPNt25GRip2bi/FxRoUGlhvZ54jEuNRefr4zDl+EXsOfSLdQ2NLWRh34SiP5iKvcJAoKAICAICAKCwNOPgLvpEZx342E/PRHWjf8Ay7q/ge30JDhvn4O7uQpwyyKKgT4LnijZ4XA4kJWVhTfffBOrV69GXV2d2ufOnYtp06YhIyPDp1qjtrYWJ0+exKeffqrUICRK4uLihOwY6LNR2i8ICAKCgCAgCAgCCgHGGi12J/Ie1Cnz8XeXX8DHYUlYfiwf1+/VocXWcTGIQNe7CHD1OIPLJC4YzOaKegb5GWjWgt6+jm2B8Jte4qOr1ejGwLJZZQRX6zM9ka+gNz0dSIbsfn0Q6KPAc7M+D1q5nao73G4VjPaaTj+Gb0cH5UhryjAqZ5SiITULG7ceVP3R2vU4RyoQEl94GUwZRmP16VNCwDRcHIO4C+necW4b0wIVmNfIDb3awIyaJ9CZyzr0ONO4W+/h4g8We159A8GLwn36aWjtMhIr/vh2aPOQ3jL0mJk4KQQnziR1SnawLu0zpldG5RRV4vM1SRgemYL9V+7B5pC/fdq4yFEQEAQEAUFAEBAEzCGg0lbdOAzb4W9gWfPXsEY+D3vcdLjKc+CWtFXmwOzHdz9RsqOqqgqnTp3C0KFDsWfPHmg+HLt37wYJjx07digvDz1+/LJ98eJFrF27FuHh4Zg4cSLmzJljiuygKkQ8O/SoyrkgIAgIAoKAICAI9BcESHTUt9iRVVyLhYdz8VHYRXwcdhGbL9xFQWkD7A43XB1shPtL65++dpB84Mr86pp6RVZkZOe1ERypWSqVE/0lGHRnYJypjVR6o8idylScgWEtxZEnSJ6nymF5jk4UzPoV+4EoI3wFuRnInzF2ljI5Z1tpGE1VBN9jeiZfz3T3XqfqDkPaI6akYmqq7srTX6eagiSD0dTaGHinPwYNwfXP+ntOwoaED4mfH8fOAVOGUUlDM/hziZfbkRtXs/KQef2mCtbnFRSh4lE16uobQYKjqdmj3mDbOF947IuN9ejTS9HYuzOiqzNMqKKZOSVY9ZXKlEB9OzRyg0QaVRwkXtie6J2HlQeH+gykZilyiGRGZwh5MWxNiXarrB7D1yZj+LoU7E+/B7ukrOqLqSV1CAKCgCAgCAgCTw8CLjvcljq4aotgTw2HbcdbsIT+JWw734EzcwvQWAY4LOJD/vSMOJ4o2XH//n1FcowaNQonTpxQsNpsNmUcvmDBApXSqqyszAs3lSBUfzDFFa9fu3YNixcv7pbs4JdmEin8ocrjjRs38O2334pBuRdZOREEBAFBQBAQBASB/oAAA4C1zXaczy3HjNhsfLjyIkZHp2NfagkKK5qU2qM/tPNZaYO20pyr53Pz70DzE7iYkomzCamIiNiuvCtoqM0gL1MeMXjMnd4OVAgwiL4sZK1KM8TnqP5gOSxPER4+VqobV+w/ri8F0zHNnjgXJF5UG1KzFInAc74XMiU4IMKjK3WHXn1BMogYdRZw9/U+sSR5RLyMQXg9PkwnxbRdvsro7D3iMfP7GQiaFKIIHxI/p+NS2pEbehNsKjfKK6pQVlGFh6WVKCuvQk1tvSI6SHZ4CA+dN0troF4RH71IfrB8Pc6BqFyo7Bk3YYFKy6VPR2b8jBuJFaV4+eN7OPDqm4ps0sgNtoEptTSCj+OnKWGYlsqsh8md8kZ8uS4FwyNTsTdNyA7juMhrQUAQEAQEAUFAEPCBABeeuBxw25rgLM2GI30dbIeGwLLht7Cufxm2g1/DmXcYaCht/dbmowx5a8Ai8ETJjqKiIqXeGDduHM6ePatAJNkRHx+vyIwlS5agtJQTz7MxfdXx48excuVKxMbGgvdGREQo747ExESfKa/4JAkSpsTat28ftm7dioULF+K9995TqbC0suUoCAgCgoAgIAgIAoLAk0agvM6C45kPMTUmE28uSVBEx8H0e8qIvI8Wiz9pCHqlfuNqcW8QWh+UNgDMgDo9BBjoZhA4OS1bEQUkB6iImDp+Lo78/g2/vDHSf/U8QkZPQ9SGXaoMkgwkPFg2VRxsj37zFVhm8L+z4H1375NoIOHgqTcbVClw1/pE9cisoPmg+qO7sozXmaaIq/c9pESrmbjBxojcCwAAIABJREFUT4LpqMZPDDaVMotqE5I8DJobg/BGfOZMW4zCn/3c77ZrhtnEQxsL4mH03CCJQTKhqalFERoFt4vVPZrCg/d39gyf0/b+7tux6Mtxan6QlPDOScPnwUisUFETPGclIjfvA899kRtGbKgaMYsFyY4R61PxxbpU7LlcIsoO/R8KORcEBAFBQBAQBAQBnwi4m6rgLLoAZ9pq2A59BWvUP8Oy8mewbv5X2M/NhLP4EmBt8vmsvDnwEXiiZEdJSQmYsmr06NFe4oEEBokPKjdIauiVHcXFxSr91JQpU9RzFy5cwKRJkzBy5EhERUWhsLAQdru9w6iUl5fj2LFjSgEyZswYlTbrtdde86pJOjwgbwgCgoAgIAgIAoKAINCHCDicbhQ/asLulGKM3pSu/Dkm78zE2ZwyRXS4DIHHPmzagK1KIzhIWpBQ0ALPnR15D+/ViBAtlZRezbF791HMGTcrIK8LrqCPeftjhIasUQF2kgPGIL4GtjGwbNa3Q09IaKQBg/oMZufmF6oUTEzDRHVJSto11Z5A1Besx6eZuNOpUnTp/SSY2ov36tvW3TlNwUnEGIPwRnwiN+7GgdfeMVU2fSSOn0lSQXoSHVRteMkNw1ygOtzTl7x2QX2OobZr6gWNANGOgagZtHngz1GvciHhwFRcZkmrw7/7dzDVGJ+nFwo/I8RYv/HzxM8EDcS1z4SvvrO/JEyIl088Tf4tK6xoxNcb0/BFZIr6+2hziGmoflzkXBAQBAQBQUAQEASUjBawNcNdUwxnySXY09fDemAYLBG/hiX8r2Hd8gfYj/8AZ85euKrvKNUHTH4nEZwHDgJPlOyorKxUJMSwYcOU6oJfoi0WC/bu3as8O9i4R48eedG8c+cOBg8ejFdffRVvv/22Umc8//zzeO655/D+++/j0KFDqKmp8d6vnZAAqa6uBskVEiLnzp3D8OHDlV+Ido8cBQFBQBAQBAQBQUAQ6GsEGFBk8O5eVTMiz93G8IgUvL/iIoIP5uBKYTUaLY4+y//f133vrfqIaRvB0ew1FGcQVgtAG4/6AC39F2w2Oyof1SgyggFdEgVUZawZNsa0AbQxoH/w9fewPixaldkuiK8DRAssM2jMewJRRmj1nnzlNawJ36aC8npyRfMhUYRHuofwWLVsPRJ+a15BQjNvpvVq1x+Dn0Rv+nZQbcN0YVqf/TnSQ0QL8JPsqKyqaSO7dD9+jWNB8mXBvFUImR2K8KhY5dVCosiYukkjAkggcH75IhB0Qx7wKdun9+2g6og+JP5goN3jJay8KcM6kh1sID9XVDuR8NA+T/rPjk9y4zHTeJHs+DYqDcPWpSImuVj9vQwYLHlQEBAEBAFBQBAQBJ4eBPh9jabiDgvcDaVwlVyCLSEE1u1vwLL6l2gJ/zUs2/4D9oT5cN0+DXdtkfLugKvjIvmnBxTpCRF4omQHVRzp6en405/+hHXr1qGlpUWlogoJCcGPP/6I1NRU9Z42VPX19Ur1wXRUJERoYP7ll1/igw8+wKJFi5CdnQ2r1ard3umRpAl9Qk6fPt3pPXJBEBAEBAFBQBAQBASB3kbA7nIhq6QWS47m4ZNVSfgs/BJWnshHVnENrHZZwWwWf73HBokCrlJngJ9BeG/wWbcaX/8e76H5OJ+7/7ACOXl31HMkOnbEHELkkG9MBZC1QLKvI8timaxfT0Do+2tcsR+IMoJ103ybnhTtiIjWitoUC/mqLSQsmJ6LKhRf7e7svc5SWTHAzzFgwD8Q5UjiCy8rw3DiRIJKb55txGf6lBDQi6OzNhrf79RvRD8IrWnOPGTCTYURVTbLho9D7i+ew9FXXlNeLUwTRlPu74JClDE3x4o+LSRDTp9Lbm27bwLBUJ3pl0aVC8eaY27sr6/XxIAp1qLfHYqJk0JU/zw4d95W7TPGsdV2oyqKBExPbXcrmzAqOh3DIlKx41KRkB09BayUIwgIAoKAICAIDHAE3E47XDXFcOTshe3UZFg3/xssa/4aloi/hS12MOyXVsB5+yxcNXcBe8sA76003wwCT5TsYEPv3buHqVOnYubMmSoV1ebNm0EPj9WrV6trt27dUobi9O7gDzJ+eabJOPempiaV6orPMvUVvTn82W7evKnSYQnZ4Q9aco8gIAgIAoKAICAI9DQCzVYnSqqaEZdbjkWHczFoxUV8F5WGqPg7yCuth9WHaXVPt+FpK8/h5KrzekVWkLTwEhypWUpFEXvwjAo+L5ofBgajuWur8+k5QFKDQXX6WKRn5Hr9LBikXzFigmkCwFdwWXvPn0C7ccV+IMoI1rdy+FjsOXTWJ6nCkLSWrot4EYPVYdE499KrfgXLtf54lQE6fw1+bzeWTRPr5v/yX/0uW/PWIFliJIV6Ap81n40CyQs96cR26ze+9qp8UrOUGoSqEK3vxiP7RzxIIoR+/LUyWe+OQNDXZ/acOOhx7krlwrZl/fJvFEFDcmbCxAUY880ULAzdoIzq/VWhsE7OHe/eg+SGsf8kO8ZsvoJhESnYdlHIDiM+8loQEAQEAUFAEHjWEOD3EFfVbThz9ij/DeuON2BZ/w+wbPhn2PYNgf3iQjjvxMFd/9Cj/OiQnPNZQ+zZ6+8TJzsaGxuRnJys/DRoGs50VHPmzEFKSopKPUUSY9euXbhy5YoyJNcPEZUhNBxftWqVUoGQ/PBnE7LDH5TkHkFAEBAEBAFBQBDoKQQYFHRwoYbVgYp6CzKKarDlQiHGbErHoBUXMGxtCvak3sP9qhY4XbxbNl8IdAiytgZcGZAm0cGUTJqfAAP3VCpERGxH0KQQFfTnSnwGexmM5q6tzg/5ZjKoDNgee1wF/Pksd6aPmjtlIeh7YQxqP+7rXW98iKhNe9sF2qlW0DbOgsdVRrCNypz88DmlLmCaIWKo39opJFIyVTomBsLN9I9KkCAf/hocF71vB4km4m+mbKanYgC/nTKlNdiux4f+G/ThMFM2lSCzJgercWb5nD+cR2w3cdLPK40MMmOGrhQvOw73qrKDY9luDHW+HRwXzvEDr74JznGSTRyDjVsPqnHeFnMAnwwdgegtuxW+JAkL7pQoE3HjPNHPmb48L6pswtitVzBsXQq2XLwryo6+BF/qEgQEAUFAEBAE+hkCbocV7roHsCeHwbL597CE/gKWiL+Gde8gONKi4CrLgdtaDzjtEE+OfjZ4fdicJ052aAoN+mnk5OSoneckLhwOh/LgoMF4Q0NDhx9n/BJeUVGBhw8fquv8QeLPJmSHPyjJPYKAICAICAKCgCDQUwjwO8ujBgsS8iuw9FgevlqfireXJuCDlRcxc891nL9RgbJaITqMeBM3hua5M6DLFexa6hztyAA+V97rzbZJUoQuigC9JI78/g1QSdFdEJyB78jBI5Xag74MJDtIRpCU6O7ZQK6zTSRhWI8xkE8c2Hf9iv1AfTuoXti1/1QHZYSGNbHV18P2zPxxkWmCR0uXRXWA1+Ta6yfhSQHFIPvu1weZwtNnuT7wYbup1GFw38x47H99EDZE7vSMQ5qH8OB88jWv6MthhgjivUdOJvY62cG5YvTtmPftFIwJClGYRG7eB6qXODZUsXDnnNu99wg++uQL7Ni132sqzrng728qbQ715rHoUSPGbbuKzyJSsClRyI7exFrKFgQEAUFAEBAE+jUCrYoO29mfYFn3d7CE/wa24xPhzN0LV2UO3E2PAKetX3dBGtc3CDxxsqNvutm+FiE72uMhrwQBQUAQEAQEAUGg5xHgAvoGiwM3S+txLPMBVp3Mx9gtV/D52mSM3HAZ8/Zdx/akIqTdqUJNkw12Z/sV9z3fov5fYmfkBgPPVAjQT0MzRtabjDPFEdNPMeBNFQDVGJdeeNlU0FsLkDNYHjIlGCQ8SEb4Q5Roz5o9KtXFkTgVhPYSBLphMq7YD8S3QyMLfBEqWlXt6knJROTG3Tjw2jum8KNig6oBBtK9aZsMhI1ZsoB40mybpttt5TZ7F0AZ282UVCR3zIwD1Q9MU8Z0ZZw/nEecT+yDfl6RbFr401KlCPK3/DETg5F46UobHhrgPXzkXw6Sf/xskNCIS0zD/sPnvMSGRm5o/dJMxc+ei8e7772PU6fPKMKLePa3v0LFj5owcXuGIjuiEwpF2dHDc0eKEwQEAUFAEBAE+j8CHiNyV3kO7AlzYVn7a1ij/w/scbPguncZ7qYqwOXf4vf+31dpYU8gIGRHT6AoZQgCgoAgIAgIAoKAINCKANNQ1TXbcbu8Aedzy7H61E18vfEyBoVewMerLmJKTCa2XryL3Pt1aLQ6WnULzzZ8DLAy0KopN3yRGwzUMmDPwG2HvdWXg6vX54ybZVqVYAxeM8XVtKmLTAfOjeV097qrQD5nhCeI3ewx+U7JVOmHzCojmMKIK/vbKS4M04316NUdXfk+dNYnr7+Gl+zwkBLtCInULJVKqcd8OwztDlSVQkIr+Pvp2L37qCI8lAKCKojWeUWSRhE5v/2d30RK4c9+Dqa8aiNpOjf9NgyH6ZckCZtbLCoFlS8yUCM3SBjys0VihOOdlHQJb7/zDs7Hx3sJJNOV9/IDJDsm7cjE5xGp2BhfCKvD1cs1SvGCgCAgCAgCgoAg0K8QcLTAXXEDjsQFsEZS0fFL2M7PhqvihvyO6lcD1X8aI2RH/xkLaYkgIAgIAoKAICAIDGAEHC638uRgjvmT2Q8xe182hqxOwhuLzuPjVUmYdyAHp6+VoehRExosdticLrgM/gkDuPsBN50pcxh4NSo3OpAbOkKDwXumLGJQngFuTdExY9wcUwbYnQXu+T6VIUxt1dU9j3uNQf8grv5PvuozzRSD2HoSIhBlROILLyMsNKrboLuRlJgyOQQkMMz0kWnDziVebtcX9kGfYmlZyFpl3m2m3M58Ozjp2rU7JRNbYo6CahYz5fNejsWaYWMUQREeFavM7HmkmobpqMx6jSi/jp2HuySZAv7Q+HiQnyMSHlp6N+OR84hYkdhSu9utPBLffvttxMfH+yixf7xVXNWMyTEkO1Kw4fwdITv6x7BIKwQBQUAQEAQEgb5BwGmHUnScCYIl7OewRP4dHKkr4X5UADisfdMGqWXAISBkx4AbMmmwICAICAKCgCAgCPQnBEhY1FvsyLlfhx2XijB77zWMjEzBh2EXMXrTFYSdzMfpaw+Rc78WVY1MVyUrk7Xx069IpzlyO+WGblU9vR5IbigPgm8mK8Pl2NfexZrwbV6yI5AUT2YD4tr9DIzT64FpqLgzdZLZYLhWlpbKqrM0U+2C+QEoI6hSITZtCoO2NFDaOPBoJCVIkJAo0drpz5E4MJWUsS8MvDNNF5USgZARVLNwDvhSpxhVKY9rKk9FBo3stZ34+dN3/T1UikwNajM+Z/o1kg3EuDc3lu8lMzRSQzv6qDslJQX9newoqWrGj7uzVBqrdXG3hezozQkkZQsCgoAgIAgIAv0GATdgb4Gz4jpspyfCGv5LWDb8HRyXlsFFosMpREe/Gap+2BAhO/rhoEiTBAFBQBAQBAQBQWBgIGCxOVFQ2oiDV+5jwYHrSsHxYVgSvt14GcuO3sDRjIcorGgQgqOT4WRgloFwzWuACo3jZ5IQvfMwqAAYFxSsVtUz2E0vDforaEFlLW0Sn9m67SCiP/rSe027pzeOVHz8NG6OMrWmzwN3Bvjnz1qOjF89b7oNR/7ldURsiPEZyCdsRhKC6ZTMECskZogjiQKqZaigIYFi3LSx0EiJQPwvTr30KsIjd7bvi0GdEkiKrI5+IO0Jm3aEUEomqIAJGT2t3XzpjbnQWZk0tae5PQmmrjA3jkFfvx4oZMf02GwMjUhBxDkhO/p6jkh9goAgIAgIAoLAE0HAYYHrQRrsZybAsvavYFn/t7AnhcBVdQeepR1PpFVS6QBBQMiOATJQ0kxBQBAQBAQBQUAQ6D8ItNideFDdjAt5FVh6NB/D16XggxUXMCIyBaEn85GQV46qRiusdqcnVVXvLujuP8CYbElbgL1ABYZpRD1jzAwwBVD6r57vNiVVCFUex873upG4FtRm0J2kxtmE1HbeDiRcAlUUdKe8aMPIo4ygwsGsbwfTMJEAMCou9MNFUkWfMot9ZFoqre/+HJW5++xQnYrE41PRjoxIzYLZFFndETbESN92jsfaVZtx4l9fN9V+f/rY3T1UhiyYtkjNh3Z468HuJ+cDgey4V9WMmXuuK7Jj7dnbsNpFGddPpo80QxAQBAQBQUAQ6HkEqER1WuG6dwn202NhCf1vsEb/A+yXQ+Gufwg47T1fp5T41CEgZMdTN6TSIUFAEBAEBAFBQBDoCoFOU734SPOiL4chNqagqm2y4crdKqw9ewvfRl3Gu8sSMSIyFStP3kTanSrcq/J4cjwNfhydYqWlxvF17AZHPaZtgXwP2bFq9RbEvei/CfS5l17F9DkrsXL42D4JamukAYPpyWnZuJqVp3ae871AVAtUq4zvZd+OrtJA6cfjcUkJepxMnxLSgewwqlNIatGcvTviQH9dw74dgaCba+3a3ko+zZoc3Ou+K/o2Um00f8JcRYb1d1UHx30gkB33q5sxa991DF2bgjWnCxSBrJ+zci4ICAKCgCAgCAgCTwkCbhdgqYOrNBO2Y1/BEv6/YIl8Do4ra+GuLQLcHZXJT0nPpRs9jICQHT0MqBQnCAgCgoAgIAgIAv0LAX3AngFRrgA3mvfyNc19afLb2dZicyH3QT2i4u9gzOZ0DFpxAZ+uuYRFh2/gZFYp7pQ3wuFk+H5gbxpeXWHlCz/tPeLLZ4kEy+pqayM7PKoFs6mT6I3wXVCIacNrfYDa33MtlRJJDQbcc/MLUfGoWu0853u8Foh3iFnfDrPKCKpkmBbMrG+HWTNxEjf0VWmrx6PsMI5zT/t2cI6xDk3dkZzmGQuSTwvHzzZttO7vnNDfR/UJU2dRQeMhw67B69XR1YfgCV4bKGTHnAM5iuxYdUrIjic4XaRqQUAQEAQEAUGgVxFw25rhLEqE7cDHsKz5c1g3/xMcV9fDpYiOrn9T9GrDpPABh4CQHQNuyKTBgoAgIAgIAoKAINAVAlqwnl+J9QH7+oYm5VfAACQ9IrKut+18XXCnRAVL9V+lWVaTzYm8h/U4fPUBQg7lYlhEiiI5psZkYdvFIuQ/bECj1RPc76pd/fmahlkbXs2dYqXHzXhOHIkvfSEaGpsVns4uDNkVvs0t6hmSBecS0zB+wnxTK/4ZyNd7eegD0D15TsPq8KhYFcjX+zAQM/aX7zHIH0gg3+vbkZKpjLyJnXEe8j3izTrMKiO6SwOlzU3WSdJKqydy8z5lBm8GR6a+OpeQqspgWSzTOM6BKGA6pshq79vBPnAsqmvqkZt/Byl9SHgwddWccbOwZ+9xRXSwbraBbWGb+us2EMiOBzUtmHcwF0PXJiPs1E1Y7P0Xz/46ztIuQUAQEAQEAUGgfyPghtvWCOed07Ad+xaWFf8d1h1/gD19LdxNlZK6qn8PXr9snZAd/XJYpFGCgCAgCAgCgoAg4C8CWqCeQdW2YH0TNHLjen4hLmfmITUjD8lXcpGQkoXzF6+qPT7pKuIvXkX8pQxczriBsopqtFgdSqHRbHXifnULUu9UYdlxjy/He8sSVeqqyLjbuFZcg7pmG5wufVja31b3n/tIRnjULm0EB02qGbwnAcHgupmdz/BZlpF/q8gT8O1CMdOOLEjNwpxpi8HgsZkAu697SYAc+f0boGrix7FzlNG52dRJ+nI3vf+FIjLYv7yCIjQ1WzyBfJ2iQCNsgibMN0XA3Puzn2Hmj4s6NRFvIyE8CphACBXN38TT/rsdiD3OSGM9ZpU2xIv1HDwW347sYNnGcWZ/2W89xl2dczy7SvelfaIcTt+Ex4Lxc3pkXunbyDbRF4QeHSRwlOpHT3R0Me+19j7J44AgO6qbEXz4Bj5dSz8kITue5HyRugUBQUAQEAQEgZ5BwA24nIC9BW5LHdx1JXDdjYftyJewrPlLWKP+CY6szXA1lnHFTM9UKaU8UwgI2fFMDbd0VhAQBAQBQUAQGPgIdEduaMqNzOsFuJqdh5OJV7Hl0AVs2J+IqIMXsGFPHJZvOIDghZGYNCkY4yYtRMzRizgcl46EK/m4/aAG5bUtSLpZiRUnbuLTNUl4a0kCvohIQfiZAly+XYWKegtsA3yFMX86MG0XV5+TlOhAcKRmKZPl/UfilKKBagKmaGLaKF87Ux5tj/WsbE9KzVIECdMJeVe4dxL45XjqVQsRG2JApYM+qGz2nCmnpo6fi4iI7WD7GYhmeiH24eDr7wVUNsmOrbuOIT0jF/cfVsBmazNINAbyA0llRUULlS3tyIjWH3g9oYzQq0f0yhT9XwRjPcfPJCnDeDP4Rw4eiR17jncgO4zjbNafhW3oLt2X1hdfhAf7QiJt/+uDTBFRvvpOkoN+MZxjNEKnOT0JQX/mu9bG/nAcCGTHw5oWLDx8A0PCkxXpLMqO/jBzpA2CgCAgCAgCgsDjIOCGu6UartIsOK7vhu3sTFg3vQJL2F/Atu0PcN48AndDKUAPD9kEgQAQELIjANDkEUFAEBAEBAFBQBDoOwQYJGVgnrsv5YZGbjD1jl6NkHApA7EnUrAg+gR+WLgNP/y0BhPGz8eEsXMR/sFXSHzhZZXLP3TIt5iweAemhB/D9PVnMC/2KkIO5WDCtgwMW5uM4REpWHQ4F0eu3kdBaT2arI6+63wv1aSpOZh+iWQEg7RKvZGapVanxx48o4iBoInBKsDMFE5URRT8xV91ShQwnRQD3eOCgrE6LFoFgP1Z6c5x9aRO8qgWSE4wqO0ryOzPe1QLTJuyUJlEe7wTshVBcemyx0Q8NGQNkn7rvwm6Vmd7ZUerMkJHRjwuYbPms1GgkoJEEYknLQWUNgWMhIpZ3w5NPaLGRKlT2vehs3pIbGkY+HNUpFDM0Y5kh2GcA1GN6AkbD0bt031pfeBRT3ho85t93xC5E3PHzFCff3q++NMn7R7O/x1vf6JIDs7xswmp6nNDgiojO0+lY1Opqzoh9vTt6w/nA4XsWHI0D5+GJ2PpsTxJY9UfJo60QRAQBAQBQUAQ8BcBlwPullq4HuXDWRgPR/YOOJIWw34qCLZ9n8Gy9Y+wbHgRlnV/B+uBYXBe2wF3SxXgGvi/t/yFSO7reQSE7Oh5TKVEQUAQEAQEAUFAEHgMBAIlN7RgPVdZ7z5wBstXb8OUiSH4Ydw8rPjkW8S9+DuU/Y8/6xDc5PujflyF4SF78fnCw/gk9Dw+CqX5eBImbruKrRfvIu9BPawDXMmhDYkWBCZJRHIoOc1DAjAQHLVpL4ImhWDl8LGK3KDXgxbo9ffIZ7jqnal9qFRQwXW9wsPgYWBUE3D8mK6Iq+f9rVN/n0YaaPXm5N1B8b1SXM3KU4Fplj81KBhmA93eQLsPMqInCBvOQ6odOI9J3CnfDp1036iMMOvbQYzmthpoe+ogodKRLDDW02NkB/1vHtOfhWQDVTMkhDpTp2jznMf2cz3Pm5aNKo+w0Cg110mskfhk2cad75Po4z30ImHd0TsP+yQ5SByyf1151Ojb1h/OBwLZUVrbgmXHPGTHEiE7+sO0kTYIAoKAICAICAKdI6DIjTq4qwuVcsNVGAfntRjYE4NhO/gVrFv+AEvE38Gy5tewRPy9UnRYY9+G7cwUOG6fg7ulrnWJW+dVyBVBoDsEhOzoDiG5LggIAoKAICAICAK9joBGcJhRbmjkBoPaB46dV6mWGIwcMzEYocPH4tRLr/qVo58r3n+cHIL1+y5g46EUxCTkY3dyEeJyy3CztB6NVgecTrcyWe51IHq5Ai34q1dzED+qKeihsOuND02TAHqiQX9O342QKcFeLwOurifBwoAwyQH9ZlQtBJIGinUb1QueFFp1qKtv9Jqgs79clU9CRt/e7s6ZGmvR/DAdGeEx32Y/eoKw0dreWSDfSKgEooxgn9l3rY7KRzUqlZl+LHqL7GAdxnEO1LeDhJWvdF/6fmjnehWTh+BrIz2IA+c+iQ/OOePO91dv2IVd+07i6Ml4xCWkIuFiuiIINSWHh+SwqL45XS60tLSgvr4etbW1aGxshMPhWZlIXJk2rqmpSV2vq6tTR97P97XNbrere3hd21mOzWaDy+VJ58Cy+LqhoUHVw/r017WyujsOBLLjYY0Fy4/fVMqORUduiLKju0GV64KAICAICAKCwJNCwO2Eu7EUzoJTsMXNhnXXB7Cs+wdYQv8XLMv/HC2hfw5L5Auw7v0MtvhgOHL2KUKEz7it9YDDKh4dT2rsnrJ6hex4ygZUuiMICAKCgCAgCAwEBBisY/CWexvB0WaQnZ1ToFa369NS6ckN+i9Ebt6HkNmhGBMUokyRuQKbK7O7C1r7uk6/hMNnUnD6wlUkZ+bjTmktqhqs/TawpsdPw9F71KkB9HOBODPFDgmAlLRrSnGhAv+LI9TKdQbbfWHzOO+xzPkT5npXwne2Gp/9edw0UGwnU21R8WAM5pPkYVCa9XMecf5Q5WCmb1X/z38HU0d5VBEdlRfGQH4ghI0Z3w6qZni/mT5QzUJVi0YWeMigevUZ1OaKsR89pexg+cZxXhO+DSdfec1UH6g6Ypo1jrGvdF9aP/THtr8zFjUPSHp08KhJyVRjq/7OpGTiYnIGjp9KwProHZgybQ5+GD8VM+csxNYde3A1K1eVQ5N64qU+e243ysrKsGPHDsyaNQvjxo3DsmXLkJ6ersgLq9WK4uJirF+/Hj/99BOCgoIwffp08MdYbm6uIjxIjFy5cgWrVq3C2LFjMXnyZEybNg2hoaGqHJIf3GpqanDy5EksWLAA48ePV/WdOXMGpaWl+m53ez4QyI7SWosyJqdnB707xLOj22GVGwQBQUAQEAQEgSeAgBvupgo40lfDuv0PsES+CMvGf4Zlx9uwHfwa9oT5cGREw1lwHK77l+F6dBPuxnJlUi4m5E9guJ7yKoW+GeTEAAAgAElEQVTseMoHWLonCAgCgoAgIAj0BwT0wXkGB7m6n54E9Q1NXQcfWz0kmHZm49aDamU9PSEYqD7w6pvI/cVzAac70geJtdRHZgKofY2rhqEeP2Jo3JtbLO1WirOdDMZqKYSosCDJwYD3sgWrEf+yOYWDHjd/zi+98DJCF0V40lnpvSJ0ALJ97AcD0BwDKnVCvplsKgjOtnSWCkrffyoC2P/pU0J8pjXrqk8kF+IupPtMoeTpQ7OnDymZiNy4Gwdee8dUHzRfkM7moZGIMKuMYN+o3mG6MmLQpraxKCLCiBM9KZi+qStMjNeUifjhcx08O7R5qB/nQPxZOo5xm8JGN6V8nrJ/bZ+fjuQq04dpO4kxEhtjJ0zBxKApmPrjdHw/5gfMmDkLWdnXYLXa1OdKq4hKjsTERPzwww+KgJgyZQomTpyoCA+SGVR05OfnIywsDDNnzsTcuXMV6fH9999jw4YNqK6uVqqQQ4cOYfTo0Xj//ffx448/IiQkRBEkWVlZSglCdUd2drYiQcaMGYOpU6eqeiZNmoTz589rzfHrOBDIjrK6Fqw6VaAMyoMP5aDF1qaC8auTcpMgIAgIAoKAICAI9D4C9hZFZFi3/R6W0D+Dbe9gOC6EwHFtF5zFl+CuLfIQG73fEqlBEFCLibgg6P79+36h8Z/8uquf33Tz5k189913OH36dD9vqTRPEBAEBAFBQBAY+AhoaWQY5NSTGz7VG63kxqlzydgScxTLQtaqvPozxszA7tcHgamEAvGRMAZkja87BlCbn3jaKo3cMBOgJaYFd0pAwoPPaxvT5OiVDSQ6ls5chst/+6KpQLYRN39fqwD4kTi1ct6XuoNt1cgYjYwgqWV2rKnuCY+K1akv2gLhRqKA/hgcd3/7wPu0fvhKoWTsQyDqEa8yxU/fjkD6QHXHTxPnKT8Vqhg4HuUVVWhqaoHNZgdTW2kKGCooqKQwgxHJkXMJqb7JDsM4cx6a9WfxpvvyYtQ2xtp87+6ofbbaiI/2pGF9QyMelpZh2fIVeP+DD3H5choam5oQu2cPRn//PQ4fPoyqqirvZ4zlXb9+HatXr1ZqjOTkZEVukLgYMmQI9u3bp1JOVVZWoqCgAOXl5Sq9VUlJiSIqSJCQEGE6KpYdHBysCBAqNVRbqYRzu1Uaq0ePHqnyvv76a3Uv1R5Uj7z77rtYu3Ytmpv9/9s1IMiOWgvWnL6FIWuSseCgkB3dzW25LggIAoKAICAI9DkCLjtc5TdgOzIKlpW/gG3PYLjupwKOFsDtBNxMw+mWFFV9PjDPboWi7Hh2x156LggIAoKAICAI9DoCDCZW19Qh/1YRfJIbTB2TmqXSHG2PPa5SEDFV0I9j54Cr3NN/9XyPeUh0FbD1BlD9ND7uLeB8BWH1BFF3qXeIJXEmsaRRHZ4xaE1f1apqWDwnFBm/et5UELsr/Lq7RmP4WZPb0id5vTt0hIyRjKA/Bsmt7srWX6dPS3jkTp9kB/HwpMq6qa4H4nnhNSlXgfaOBt/GPpglbLypsjqZh54+tClgAukD8SLJRVWPpu4gucExuf+wAjR01wgnelbQpFuPcVfnJKfY57ZUX23zUPvMGDEKNN1XXGKaT0JFq8ffo/aZI7bazrRnefn5CFm4UC2Q0laFkRyg0oLqjBs3bnjJDpKJp06dUkqM6OhoFBUVqerT0tIwePBgbNy4UZEj9ONgOivNo4PExfz581VKK6avYnoqkh18b82aNbh9+7Y3BZZGdly7dk3Vz3ZcvXpV1UPShOTH8uXL1TOaT0h3GAwIsqPOgoizt/HpmkuYd+C6KDu6G1S5LggIAoKAICAI9CUCbidcNXdhT1kFa9Q/w7rtP+DI2gF3S3VftkLqEgTaISBkRzs45IUgIAgIAoKAICAI9BQCDM5xtT6JDqbL0XLhMyBPvwEGarkynemEuBo8cvBI5bnAgG9XAdXeusY2MG2Pr1X7PYVJV+UwAEpFBgPyVGEw+OyTIGpVv7CtVL/Qo4IEEbE0BpmNY8Dg9o6YQ4gc8k2fY+xNFdYJUWAkI5i2jGoeM+NtxkQ8EM+L7kgx4q33HgmEsCHRR2WTr3mojSfnBq8H0gcNz23vf47N0XsU4cF5k5yWjfSMXHXkPOH8mjp+rqk0cTSlnzNtcYd5qJ/3RowiNsSAJJLWrq6OxJ9qnKBxc7G/k1RZ+roCPafZ96VLlxSxwZRTVGRwy8vLw7p161QaqtTUVKW04Pv87O7evRujRo3CiRMnvPdTrfHll18qxce9e/e85IjWLpIU9PagzL6wsFAZmlMNQgX6G2+8ocpbsmQJjh49qpQhJDEuXLiAOXPmqNRWJEO4VVRUKP8P3nv58mVlVq7V0dWRZMk777yD+Pj4rm57otcq6qxYF3dHpbGas++akB1PdDSkckFAEBAEBAFBwICAtRHO3D2wRv8fWNb9PRwXl8Jd/7BVzWG4V14KAn2EgJAdfQS0VCMICAKCgCAgCDxrCBhXoTOAy1X39Bmg9wGD3wxcctV/VwHOvrrWnV9Cb44fA8AkOpiCigQHV9ozmG0kiKh+4Wp7jSBim5n6aPmwMYr4MHo9GAkEBseZwoipjPoKV60eqnSYloxtZP9I6HCVv7YZA/mBpIHiXCI2baRP+5Q+RlVBIJ4XXZqIG7xHAiFsupuHxj4EoozQxiT645FYu2qz8m8hwaHt/KwumLYIOc/9xtQ8oUcJvUqM81AbYx6Nfxe68u3geFJZQiKUuHO8SOrxGdZhVDHp63mcc6ov6H+xcOFCRXhQgcGN5EJUVJRScCQlJbUjO2hMPnLkSJw7d075b/B+qj9IgNBw/M6dO977eY2prLZt2wb6blDF0dDQACo/SFYwHRYNzGlQPmHCBGVAfvbsWWWATl8QGpxv2rQJd+/eVe0i2UE1CMkOkiEka3xtTJNFwoZlHTt2DCtWrMDvf/971WZf9/eH9yrqLdgQX6jSWM3eK2RHfxgTaYMgIAgIAoKAIKAQcDnhKroA26EvYFnxP2E7+h1cDzyqU0FIEHiSCAjZ8STRl7oFAUFAEBAEBIGnGIG2oGaBCj5zBfeKT74FV2drwdb+ciz4i7/C6g++ROjKaF2gvGMKHjPDxeA9MfDuupRNxnI0rBi8ZRCXO/0MNPWLRhAx6Mvgr5Eg8qkGaDVj9np1pGZhdVg0zr1kzpCcShsGselXwYDzmInBKvhsdhzt//k/K38G9suXaoGYGAP5ZtNAcT6xfYnJVzslVPTKi0A8L7wKldQsZUauTxnWE4SNWd8OM8oIX5+3E//6OqYHLQBVKMSD5AnnE1Uavu7v6j2f89Aw740YcT4ETfT4s3Cusf8kfKi0InFFco8kH43hNfKP8ycjO8+nP43xsxXIa5IdJBWYKmrevHlepQb9NmgmTrKBKaBoFs6Nyo6YmBh88803Kp0V/Ty4kezgeyQvSEzwfvaf5MnJkyfVtZUrVyInJ0d5ePAZGpXTq4NqEt7H9FhUl9DwnN4cVJzwNUkXEijcSJzMnj0bS5cuVdfZfl8b03Ht3btXESgjRozAoEH/P3tvHh3VlaV79h9vre7VmV39qnrV685Vla+zXpbLOTkz7Xx2esimspwmPVV6NjbY2AZjG2ODEWBjYzMYxGhmJCSQmOd5EqMEEppnCSE0gAYkEJLQPN6Yv17fEVeEriKkCCk077tWOCJu3Dj3nN+5gXX3d/b+XsYf/vAHnD9/3tXhg2JfZaOG0KgivLU+Ft/uz5TMjkExK9IJISAEhIAQGPEEbFaVwWEJ/wZawAMwbf0jbHknxIR8xF8YgwOAiB2DYx6kF0JACAgBISAEhh0BPYBPnwkG77tawd1VALUvPmMgl/4ONF/+2M9fBXhpbM3SPb1ZMa4LHAzas4QXA+H6g+9p1u5q4/ecg/Ahm/aqoL2e/dKVsNCezWDImCB/o+m33wx/r7I6wp94WgXCuVqf88fMEAanGXz2n7XIa+Gqu6wFIweW6GLw25trYP7k2WBWiCtBxRfXZHdm9kbBxlvm7b4XhvnUrxtfjMHIkyIDS4BxbBT+jJ978p7fo1DC34+rzB29/3w2MlqycB1mTJ2vyrFxzlmeLTwq0SBu5CqPDgqCLONFEa/tN3U/O8j5HL15zQwLlnii2MEMC4oJ3DIzM5VfBg3E+bkudvD56NGjqiTV4cOHlVjB4+mvMWbMGGUczuwLXt88lqWqmPExf/58JWDoHh78jt6mOiGg2tq9ezdef/11JUqkp6erjBMKKBRTuFEcYQYIxQ72kf13tVEE4Vgo2vC7e/fuxTPPPKOyWFwdPxj23W3QsPVyEd5aF4s5+zJE7BgMkyJ9EAJCQAgIgRFPwNF8F9a0bTCFjoIW/AdYUjbC0XBrxHMRAIODgIgdg2MepBdCQAgIASEgBIYdAQb2nIPtDJJPm77IKw8AT4Ksnhyj1/qneMDsBPoKsKTW/qPnVXC2pyvGOUYGn/m4L3B09txggJbeJTW1DaD5sXEzBn+9Ka/UMfh+3zS7t0Hxw6NfxtoVwUrcIB+jp0NPSmJ1m7VgKAPFoDcFEk/mWD9m14tjELr7uJpXCm1dZV705JrktcT5cRfU73PBZhD9rnTmfG7PeHHjyeJ8zbddmy0qM4YcwyMTcPp8TLfiRkNjm3jIf1f4m2E7fbFRcCgrK8PSpUvx1ltvITc3V2VeMMuCpaVYfop+G5xrbjxeNy9n6SuKHBQwWC6KIsXOnTvR0tKiHtzHklPM1IiOjkZ9fX37ENiepmnqoe/My8tDYGAg3n33XURGRqp+bd26VYkwLLVFAYPCxZtvvglmiTAjxCiY6G0Zn+k78uKLLw5qz46qRhO2x7RldnyzNwMt5s7/fhrHJe+FgBAQAkJACAiBviPgMDXCVngJpt1/g7bpcVjOTIe9Kh8Oq9Z3J5WWhYAXBETs8AKWHCoEhIAQEAJCQAh4R8AYxO+Nv4BzYLW711yprtf6ZzkcvdY/y0J1Lofj+Ypx1+JGMxiE1U3FGWDv5LmhxIIryM4t6CR4sE1nUchb02lmp1C0MWYy3Bc72sqIsRwQmXTHjp/rAX16ONBcnuPhavpbZZW4mlOgzsXP1m/YgTNPPO1Rm2y326wFAwt6R7A0kid91o/pbFLetW9HT65Jb3w7eiLY0Jidfh8UAoyCDX+BA/W70hkbnxN//TBWLFynPD+M16GrfzF4zTt71GRk5ausDT47Z264Ejd4XfP7fb3R92L79u0YN26cEjciIiJU5gQNxePi4lQ2BctCMauCggNf79+/X3lwhIaGqiwMenXweIoUFDFYdooeHa+++qry/aDwkZSUpHw06urqlNcGsy5YqornoIDCPrBs1ZIlS0DDc2Zt0FB88uTJStxgCSq9nzRJ91ToID+2P+jFjiYTdsUWq8yO2XvSRezo6wtf2hcCQkAICAEh4JaAQ63wspenw3LxO2irfgLTwbGw5Z+Bw251+y35QAj0NwERO/qbuJxPCAgBISAEhMAIIsCgpHN5pt76CxiDrPp7Gm7rtf4ZHJ81836tf0/K4bgKqhqniSWoKEowU8BZ3GBwlkHaDgJHQoYK/LIsFoPdLAFFcSA+qbPgcV+U8L7cl+6D4cqj4n67bWIHs1k89WFoz46IT1fjqqisRnNzK8xmC+5W1ap9DMT3RIzoqswUmRsD+ZxLilf6XHf37Img0ttrkt4pLOXlSowwilc9YdSdYNNfv6vuWPNz/vbmTpvXVgLu3vViNJ83/pb4npkPFDz0Mm/Oz86ZG/0lbhj7SNGAGR0bNmxQgsDjjz+usic2b96sSkFRpGB5qUOHDqlsCo6HQsWcOXPwwgsv4I9//CPeeecdVbKKHh58nDt3Dk899RQefPBBZQw+evRoPP/88/j666+VMTn9OihYfPDBB3j22WfBz1955RXVJoUOZodwY9ZJQEAAXnvtNTz55JP429/+huDgYFy/ft04jC7fDwmxo9GE3XEUO2LwlYgdXc6nfCgEhIAQEAJCoG8J2OGwtMASvxJawL8prw5rxlY4zPz7pO8XovTt2KT14URAxI7hNJsyFiEgBISAEBACg4zA/YC794H8rgKtDGgzILzjhTfxzadzQF8Evdb/uYj4HpXD6SqoygB8TW29KkXlUtyIT1eBb2ZlMHuEWRQ0V2ZWCcswrZzwBQ4cDHMpeLQFrpuVYMJyUd4IQu0+Cap0UL4Sltget/vs28QOb7wj5kyZg7DzMU7ZIppaTc+2KfRQ3GFfKeB4K0Z0l7VgDOQPRt+O7spx9blgYyj3RY8Sikhd/WZcfeaNiOTq+/wdOl/bzAJiBhDFirarsOt/kDjX6nd373ptf90PmRtd96wte6S5uVllY7BcFA3FY2JilNE4sz5oHl5YWIibN2+2l53i8VlZWcoD4/Tp0yo7o7y8XGVjMPuDIgUzMU6dOqVKXIWHh4MZI/T/YHtst7i4WGV28DNmftAonW02Nja2Z23oWSKXL19W/WKmBw3QeX5vtqEgdlQ3mbE3/qYSO77clYZmTVaOejPHcqwQEAJCQAgIAV8RcJgaYMs+CtPeV6AF/BKWqEWwV2bzjyYRO3wFWdrxCQERO3yCURoRAkJACAgBISAEXBFgMNO5RBM9EvymL1LljFwFT7val/2zB7D3mZfxzaQvMeWLhZg9ewU2bD2CU+dilNDA4DtL6DDDwpflcPQx0HODwVyeRz3uZW+whBT9P1gqi+WN6F3AclE0DtfHw6DwsnvG2Z0yPKy2DgLCku/XKCFH/25Xz10JB7zt4Gp5soiISlJG7CefeFq1TZHE1UMPfk+Zvgh6tggzORi8p9dIc4sGZnmkZuQo5hyLt2JEt1kL7f1uE8iYQcFMiq44GD/rkouLa9JbLxlyosjDzA5eb8ZMhj4XbAxj4DxM9fPud8VSZV9MW+Bxto+RMa/veVO/c521ZBVfBVf/Hg62fUNB7KhpMuNAQgneXh+LWbvS0CRix2C7jKQ/QkAICAEhMAIIOGxm2MszYTr8HrSgR1T5KvudTJXpMQKGL0McYgRE7BhiEybdFQJCQAgIASEw1AgYV7l7E8zXA6wUOqb5LcKnC7bgre924Lvg0zgRkYjouDQngSNPrSpn4NlVWSq15qgHK8bviwZtwXeuog/aegj0evjYzx/0zDj76Cjlc6H319Uzy/0snPqdKv3kLHhUVtWg3ElA8CZo3VVJKL3fzEShcME+bwjZD/Jn3109GMDnmHgMBR0KJbV1jaqEle5JwuA+RR+OQYkdG3aC4oKrMbvaR+GHgpcuprgSCpwFMm89THhOXi/+c1e1j4FlqyhA6JsvrkmWS2OJKlceFTp7+m1QEOmJYHPiqdEqy8dVqSyOwxdjYObR7FmLEeuhlwvZ8jqmT8uCGQs7Xcs1tQ1KFNM5y/PgJjA0xA4TDieVYtyGWMzcmYr6FrOsHh3cl5X0TggIASEgBIYhAXttASxxP0Bb+3OYd74A65X9cJi9yygdhlhkSIOUgIgdg3RipFtCQAgIASEgBIYLgbbAb4syWmYAncbL3gTHGWBlgPyz6Qvx3uJD8Ft3AjtOxCEuJVu1ybI5DJgzoN0Xtf7vB67zERWbgllfLsW258eozAhXwfyu9nE1PIPEDOBTKIhLylRZEsyUoIDgTTkiT7ILdBPotMwcFZRvz0rRs1NcPd/LWGGQPTUzBzdL7yAnvxjObbDvLNdFcYRlujg/XY3b+NnyidNVRoAroYDXvTGQz6wZZiIY23H3visvE7bvi2uS46YfiysxQs8G4rXJMfZEsOmqRJm7Mex95iWPGZEdxxC6+zhWLQlUZbBYnsvdXFJAYoYNy6HRmJ5j4vXE6zY7twAidAy9f7GHhthhxtGUW3gnIA4zdqahptmMtuJnQ4+39FgICAEhIASEwJAjwMVC5mbYsnbBtPUxVb7KGrMMjsY7gMM+5IYjHR4ZBETsGBnzLKMUAkJACAgBITBgBIyBX28C+s7BbJav+mDhbqzdexHRSVdVNgQzODoIHE6r93014PtiR9sqfa7mXzxtrlem2c7joEn4wtlLwJJeFA0YLOeDrxk8ZwDa+Xh3r7vzjeD4aZpMPnpWhu43wowNV4/0rDykZFxDbGKm6g+fk9OylSjDwDb7yLJdFB9Yrksve+Wuj+72t2ctqOyRvDavEacJM5aBWrtuGyIeftIjLvo5uxJUfHFNdse/zwUbQykr/q6++2iWV4z0MXBe+X2WJGNmEdnpD/q3MNuHmTLMUFHXbHvJuByVTSVCh9PFO4ReDgWxo7bZjBNptzA+IB4zdqaiqskEex/8Oz+Epk26KgSEgBAQAkKg/wjYbbAXRcF8aAy0Nf8N5rPTYC9LkSzL/psBOVMPCIjY0QNo8hUhIASEgBAQAkLAOwLGwK83pZr04PXuv7wEv8XbcfBMvArUU+hg0JqPvtz0wLju2cFgb28Fj7QHH8LSeatU4Jjt6Q9v/C+4yp7BZ1eZBc48SIf8KXrQw8P1owW1dQ1KQCq6eRtJadntAozet8MnIlTpK5bt8ibLQp8/5+f2rAV3nhcG3w5mkVBccW6ju9fdCSq9vSY9yaxhthFFJQpFvhZsOMfGMXz2xfduMzNc8dLHoM8xn3k9HT4e3v44fT5G9V/PCmrzxWkTOSii8bqy2WRln/Nvbqi8HgpiR12zGafSy/D+xnhM356KygYNNrtcb0PlGpN+CgEhIASEwBAm4HDAXlUAy7lZ0AJ/DdPu0bAVRQDmpiE8KOn6SCAgYsdImGUZoxAQAkJACAiBASZAwcA58NsT3w4aW3/37Q+4GJ2qAshGH4a+HCKDyly9znI98ff8KnoreFx6bBTWLQ1sFzoYaPamXBPN0FlKyF0pKCMPJQzdW4dFAaT94XCooHlNbb0qV8WSWnpmB/vEFf+cL670p0jhKmju7T69zBSzW1z1XxeYfFIGyp2g4oNr0hPPFN23oy8EG+Pv6ruvl4DZGt7Mh+49wrlmSSrOv6usH+5jZpBeNo5m9fxd9K3UaLyK5b0vCQwJsaPFjLCMMnwQlIAvtqeivK4VVhE7fHkZSFtCQAgIASEwUghwgZjdCofVBIe5BQ5TI6DVw9FSA0dzJRyN5XA03IajvgSOumLYy9NgTdgAU8ifYNry/8GSEgxHk5SvGimXy1Aep4gdQ3n2pO9CQAgIASEgBIYIAQZEmVGgB3576tvxud8itfKcJtlGY+u+RmG1dRY8ws7HYNGUOV6tpncORB987jVsDtyhBA9vfB1YCmve7KU+YeE8Lga79XJV7I/u5UChybnfvnjNDBGWxHKXmWLMWqChujdiS7eCiuGapHfFrhfHeDVOes/wWnY1hn4RbAxjWLBkA4JffNurMTh7j1DoqKisBrOmXGcAdSwb19e/OWm/bwkMDbHDgrNZ5ZgQnIBp21Jwq6YFFskk6tsLQ1oXAkJACAiB4UmAGfGtdbDXFMNWlglbURSsuSdgSdsBS/x6mC8thPnMdJiPvgfT3mdhCnkI2uqfQlv9P2A56wd7TZH4dAzPK2PYjUrEjmE3pTIgISAEhIAQEAIdCVhtDtjsA7v+2hj4ZVYEV5R7GzTvyoeh46h79o79bM94YPaDoUSWszCgZ3gw82HZ5Nk9FjxC35yIHVsOqsA/BQBPmHRXosnT0bsaD1f4b99xFF9N/x6xv33Mo/540mfjMfTgYGkniivMGjBm6pC9czZQ4KY94LiN7XT1nqWvmFHhiRjRk2uSIhCzXtyNwSjYUKCiUNVVn50/o2Dj10UGj/F39cOaTfD75BuP2+e5kh98CCv8A9rH0F4ezjn7x/m14Tfh6bUmxw0+AkNB7KhvseB8VjkmbkrAtO0puFndLGLH4LuUpEdCQAgIASEwmAnYLLDdToE1cQMsZ6bDcmwiTIfGwbT3FWg7n4UWOgpayB+hhfxPaCFPqocp5HGYQh+FafszsJz7CrbCS4BVG8yjlL4JgXYCIna0o5AXQkAICAEhIASGFwGz1Ya7DSakFtUgr6wRJottQI1djYHfWTP9vTa4bg/yJ2SoLBGuPu+NjOMsbrB/Rl8LV34ErgSC3ggeDGivfX8qFiwO9DiY7wvRx9U4mKnCDIrQ19/vsXjjHKzv6jV9P1i2i0KEq0wdYzYQPUM47q7aNH7WnaDS22uy5X/935Sht9sx9LFgw3+xnMewLnALPv/sO69+V92NYXj9qyijcSYwJMSOVgsisiswaVMipm5LQdHdJvD/bbIJASEgBISAEBACHhCwaLCXZ8Ec/i204Megrf8FtMDfw7TpjzCFPgXT1j/DvP0ZmPc+D/PhV2E++REs57+EJcof1vi1sGbugv1OBmBuvrf0xYNzyiFCYIAJiNgxwBMgpxcCQkAICAEh0FcEaOR6KuM2Jm1KwJJj2SitboHZOnDGrsaV+t6YcetB7HZjazfZAN2xdCducDU7y2LRj4C+BLo/AU3J6WXBgLLz5koo6I3gwYDzgkkzPVr174vgtKv+Hzl1EfM/+9arUlH6vOjP7Jv+2pPnrnxHjFkL9PeYNn0RKA550jaP6VZQMYgRPbkmvfHt8I1g01Hgc/5drQsIxWeffOm1b0dXY3C+7uX18CIwFMSOhlYLLl2rwEebk/D51mQUVDQp4X54zYSMRggIASEgBIRAHxCw2+GoKYL53NfQNvwG2oZfwXz2S1jTt8N2/RzspYlw3M1XXh1orQXMDYC5sU3YsLQAFg2wmgBHx/ugPuipNCkEfEpAxA6f4pTGhIAQEAJCQAgMDgJcFZ95sw4zdqXhr4sjMDEoEUdTbqGu2TJgHTSu1N+25yToF+Bp4JrH6T4MUXGpLrMBjIPzRtxgdgHNslmSSH/Qw4KCBzM82Jbz5kowOHAwTGVpeBOQ92b8PLa70knOfXT1msKN0Wy9t94jFBWYdTFt2gKvxIiuykyx785ZC8ye8Na3g7y6FFQMnhc9uSa98e3wRrDJ/tkDODLqeSz4+CtQhLlfKj0/V1gAACAASURBVMsgdjiNgZkdEz6ZhdCX3/Xqd9XVGFxdQ7JveBAYKmJHVO5dfByShM+2JiP/TgM0iwRdhscVKKMQAkJACAiBPiNgt8Nelg7rpYUwMaNj+2hYLi9V+xz1t+BoqYJDa2gTNOw21u7ts65Iw0KgvwmI2NHfxOV8QkAICAEhIAT6gUCDZsXxlFv46+JL+NP8C3hheSS+O3gFpTVMQR6YzbhSvyceCQxed1fCSRc4GCjXy1K5ytzoJG4kZIDBaJpmbwjaDQoXrrwenOkNhODhbChNw3dvSnnxNoZMmMFCIYf+HJyHxdPmelX6SBdoGn70YwS9MVGVo2LWgrdiRNyvHjEE8ls6iEptAllLm7F9fDqCNu/Dkaf/06tAfleCii+uSYoS/nNXOYkRHcfgqWBDL4+zj45S1/fHfv6qzaCth8CMG16HfDDryDjfzmNYv3ELxk/8DFOnLfCKUW8FNOffhLweOgSGgtjRqFkQnXcXn1Ds2JKEnLJ6aGYRO4bOVSY9FQJCQAgIgX4nYLfBXpkDS+RimDY9Bm3z47BELYH9bq4YjPf7ZMgJB4KAiB0DQV3OKQSEgBAQAkKgjwlcuVWPpSeu4U/zLuC1NTF4cUUk3lgdjZTCmgEtZWUM/PbKt0OVsmKwvy24zMD4fYGjpVNZKlfiBoP9DCZvCNmvAvVTpi8CTcL3/OUl9f7+avqOAWzn6etvwYPG7hQomIVC0cJV1olz/5xfd+Afn47wqCT4z1qkyj3pAoYnz8xcOTz6ZXzptwg794cp0YQsvTURr/67vwevAQbyXfp2OBzt4gzHy1JhLLnkSR/1Y7oTVDowScjA17P8Uf4P/+jxObrLNqIY4cpondkw9BShGMPrjublFNkoGilx416GEcdNNhQ68gtK0NKqdRCEOL/6GAKDt+G9iVPw9Uzv5pTlx/ymL4KnGVPO15S8HroEhobYYUXc9Sp8uiUJU0KTcPVWPVrN1qELXXouBISAEBACQqAvCditsNeVwBy1GNrmJ6Gt+zdYLi2C/W5OX55V2hYCg4qAiB2DajqkM0JACAgBISAEekeAAX+b3YEDCSWYuDkJb66NQcjFQsw9eAXPLr6IrZcLcaumtXcn6cW3jYHfNatCEPXbxzwOLDOA3e7bkZCB1IwcVFRWg5kbztkbzHhwJ24wYL55+1G1cn4KV9BPmomTTzzdwauiuwC2EYE7wWPV+9O8GpseoHf33J04YOyX83vnDAAG0ClO9MSjgkLA/ClzsClot8qE0bMO2F5PPCm6E2/0QD7nk+ea6rfIK/P07pgZr8m167YpEcLdHLja31W2UVt2SnNbdkpChhLXmLlBc3aea8+hM0pk0Eun6eKG7htDQYt+MhRMKHTYbJ1Xtetj2LhpO96b8CmWLtvo0zE4X0fyevgQGApiR5NmRcKNKkzZkoxPQ5NxpaQeLSYRO4bPVSgjEQJCQAgIAZ8RcNhU9oYlZpUSOkyh/w5LxFzYK7LhsAzc/Z/PxicNCQEPCYjY4SEoOUwICAEhIASEwFAgQAPystpWLDx6FW+tj8OyUznIKqnHruhiPLfsEmbsTkNqUe2ADcUY+GWglyvbXQWQ3e2jEOH3xfcqK4GlmCh4MDDMRweBIyGjvUxT6O7jWOEfAL8Z/iozgB4FLD/Ettydp6sAtiuArgSPHVsOIvTNiW7P4e7c7vYzE4ABck8yTox9NLK/EJmAL6fN75KBsR9XH/gVvpu5CPT4oLgRl5Sp+HMOOBfeeFLobXdXlksP5HN+Oe4l369RviX69z157kpQMXLpyTV54qnRKquFYoyxtJguMtH7hYx0UUN/diduULxjySpm7lDwYT/ZlqtNH8PGTdswfsKnCAzZ6/Xvqn0MzhlTrk4m+4YNgSEhdpisSCqoxudbU5TYkVlch2YRO4bNNSgDEQJCQAgIAd8RcNQVwxq7GhpLVwX+HpaI72CvvAbYBs6z0Xejk5aEgOcEROzwnJUcKQSEgBAQAkJg0BOobbbgRFoZJgQnKEPXuBtVqG2x4HJeJSZvTcbYDXE4lnJLGby6iZv26Rj1wC9XqzPIyzJKNJD2JGDtfIzuw8CAu3PJH75mEJ+llZi1wBJJDHTvenEMkh98CPSYcG6nq9c9Cf72teChj7t3YkebaOCt/wXZzZ02T/El9/ikK8jOLUBlVQ3KK6uV6EH+fePbcT8zglk5FKu6mjvjZ10JKr64JtuzjZRQ0NlXg2JFTW09KHiwHJUuzvG1nrnhUtzoQuBw/qHqY9gUugPvTfwUew+Fef27ah+Dm5JizueT18ODwFAQOyhsUKCftj1V+XakF9WB2R6yCQEhIASEgBAQAvcI2G1w1JfCkrABpm2joa37Bcznv4L9doogEgIjkoCIHSNy2mXQQkAICAEhMFwJ3ChvxDf7M/HGmhgsPX4NdS1mWO0OFN1tRsilAoxZG4sVp3JwvaIJFpt9QDAYyxLN+WqJ154ReoYDg+7MJuBqfGY80G9hxrQFyjSbXg0sYWQMfHv6np4KLDXEAD4zRlhKiH3vbusrwUMvrcXxetsn9llf/d/TDAl6mdC83VnoqKltUEwYqNfb9da3g34RLE3lbkx6IF8XyPrDt4Pzzvnv6lrhfDA76Mio51W20Nw5K5wybpoVb+drxWazqywNZms4Pzpkbngobji3q7/mtblr9z6M/+ATHD5+TnmA0PS8qzE4f+Z8fVGIJG9v/GD0fsjz0CEwFMQOlqxKu1mHL7an4uPNSUgurEGjiB1D5yKTngoBISAEhEDfEqDQUVsMS/ImmLb9BVrwYzCfmQl7WTogpav6lr20PmgJiNgxaKdGOiYEhIAQEAJCwDsCLSYbIq5W4JWV0Zi0OREn024r/w62YrLakFJYjXcD4zFxUxKOp5VBMw+M2MHgtW7YHB2Xjh9Wb/HaX4CB6Okz/FVAl+bOzHigAOKNsbRzoNfda2adMPvE2+CvK8Fja+gB7HjlHY+Dz8Y+6eILxQYlODgHpD24VIxiB0t6eZrpYgyEM6NDCR02myqtxOC9LnZs23MSzKQw9r+r9zQdp4jhjrNRIPPW2J7j5Hi7ElT0a5JZM+58O5j9QH8XljhTfi9zVyFo6yHVd7bNB7M1yMNVwSle+9zf4eGjFCu2vXffAbz7/sc4fOys12bxnB+9dBvHYSzH5cElJocMMQJDQuww25BZUo/pO9rEjoSCajS0SjmOIXapSXeFgBAQAkKgjwg4miphTQmFtvkJaGt+DnPYF7BXSOmqPsItzQ4RAiJ2DJGJkm4KASEgBISAEOiOQEFlE1aezsUziy9ixalrKKxo6hBwvVXTgrmHsvDa6mgsP5WDygZTd0169bkewO3uSzyuLTieh/DoVCwLPoyVYz7yKjjOwCyNzb1Zud5VsN3dZ+1lo3oQ/HUleASvCcXR0S95PVa9f/wu26DYwaC8nnHiyrTaOA/3uecjPDJBZcDo7Xb37FziiP4cd6tr242yndtln3piUs6yVCxP1VaeK0+JYWxX35wFMh7TE2P1rgSV+2PIU4KFPgYKTGcfHQVmtVBUY4muDSH71RiVuHFvHijScC4odOQXlCgjcfa5Pzeebe++/Xj3/Y9UZoc+hu7m1vnzM088jfUbdnSZodKfY5Jz9S2BoSB2tJptuHqrHjN2puGjTYmIvV6FehE7+vbCkNaFgBAQAkJg8BPgApqGUljTt0Lb+Ty0wIdgDvsMtuIY8egY/LMnPexjAiJ29DFgaV4ICAEhIASEQF8TYEzVarcjIqtc+XSMWReLE2m30WrpWHKpocWK/YkleHtdLCaHJCGtqAZmH5SyMlttuFXdgtSiGsTl30V6ca0KTl0vb8TNqhbcqdNQ3WRSpUdMFhtsdjuaWlpxLa8QRy4kYta64/j8c++Msp0DtH35Wi+X1RaEd79i390c97XgwSC7c5aFu35w//2Afj7OhccpLxNP2bkSOzg21a5Tpg459aTMlHP7uoDjXDLsft/bxIieZI+0CyouhCsKEyzZpJfKYqmwqTMXqzJmG4J2q/JdUXGpSgTgGHVxg9kszr4bzA5padXahaCu5sPXn3EM+/Yzs2MSjp483yOzeD17qKfXu6/HJO31LYGhInZcu92AmbvSMWlTIqLz7qK+RTI7+vbKkNaFgBAQAkJgUBNg6aqGMlgydkLb81Kb0HFiMuwUOizaoO66dE4I9AcBETv6g7KcQwgIASEgBIRAHxKgJ8edulYEXsjHG6ujseRENrJvN8BuWFludwC5dxpU7fO/rYjE9ugi1DSbe92zu40aQiMLMS4gFv++MByvrYnGRyFJ+OZAJtacy8OeuJu4cPUOMkvqcKe2Fa1mKzSTBTdKqxB0OBbj/Q9h+nR/MODtafC9v45jWSz6gPQm+NtB8Ei+orIyepvhEfrmROzYcrCzf8Y9AcLVpN4XDLwXO+h9wtJRncpnORwqsH+3qlZlNjDb4cipi/CfNNPruaTXCs3lO5SyujcQoxhx1kuxhtdLxs9/iSXfr3E7l/dLZeWo7A7Ouf5wJ264NBU3/O5czUVf7Tt48BDGvfMews5eUmPw1iyenFi6LSIqSZUlc1eOq6/6L+32L4EBFTscdsBuA+xdl1PULDbk3mnErN3p+HBTAqJyKlEnYkf/XihyNiEgBISAEBhcBEwNsF47AtP20Whd9n/BfHg87LdTAf6/VTYhIAQgYodcBEJACAgBISAEhjiBFrMNZzLL8EloMt4PikdEdgUaNQtcxVyrG01Yfy4fr66Kxjf7MlFY2dSr0Te0WhGbdxcfhySq8ljjNybg49AUTNyUiHEBcSqLZOz6WEwITsDkkGRM356Cb/ZmwP9oFubvT8Unq8LwzqIDmL0kBCeeGu11gLyvRQ8G+b/44nuVCcFV/D0N/rLMlLMgQNGAgXcG4Hs6Bm8FD2exg8FsBrW9ObcuRlAAYPYFx2MymZV3B7NLKAhwXCxHxSwKb9rmsbteHIPQ3ceVwOAqu+O+GJGrAvne+na0G6HHp7sM5JMPsztYhorZGpxvY+aGS3GjF6bivfrxufjy4cOHMXbcuzh9LlJx9MQsnoIeS8KxZBuviXlfL1dlznpzvbvomuwahAQGSuxwtFTDmr4dlpgVsOWebBM93PCh2HG9ohFf7UnHh8EJuHStErU+EOndnE52CwEhIASEgBAY1AQcWgPsxZEw7XsZWuDvYDryHmyFl+AwNQzqfkvnhEB/EhCxoz9py7mEgBAQAkJACPQBAWZ1LD+Rg5dWRuG7g1dQUtXs9iysf34+qxyTtyTj/cB4XLpWjmaztYO3h9svGz6g1fKV0losPXENL/0QiTn7M3EouRRHU25jd2wxNoZfxw+ncrDgUBa+2p2Oz7Ym44PgBIzdEIu3N8TitZXheMv/CPzWn0TAjlPKHNnbALmvj2dAnAIEA+9zpsxR2QxrVwSDJYx6Y9jMzARnA2yKAswY6a2hujeCh7PYQcHC2/OHPzoK6+75hVDYuJpTgNLbFcjOLUR8UpvQwfJPX/stBEUib+dGL2XVKXvk3nVnZOiJbweN1TmfFF/o2TFr1pIusxYoSrEMFUUt5wdFEIotZKgerpREw+9jIN4eUmLHOzh9ri2zw5Vvhy5uBL0xUfm28DpYsyoEew6dQcTl5LZslm6M1gdibHJO3xMYMLGjvhTmM34wbfsPWMK/AWzuMwxZ+vBGRRNm70nHxKAEhF+tELHD95eCtCgEhIAQEAJDgoAD9rIUWM5Nh7bun2A68BpseWfgMLu/9xsSw5JOCgEfExCxw8dApTkhIASEgBAQAv1JgJ4bCTeqMTE4Aa+uuoyDSaXKG8NdH+iXUVrdgnVn8jBmTQzWnctHQUVTp5JX7r6v72eSdGOrBdsvF+H55ZF4b2M8Iq6W6x93eG7SrCiuakZSYQ3CMsuwPboYK8Ku4cudiZi95SK2Ho/BmUuJmDZ9ERic9jZI3pvjeb7snz2AI6OeV8HwqX6LVMYFMwzCzse0lzOKS7qC3OvFauU/g+7ebkahoSdlmNyN01PBw9gHbzNLyOrLafNVqSkKEnFJmUhOy1bPfM9H4KoQnBr1XI/n0Jg9UlVdp0QG8r7f/zbfDgbnmY1g5ELRhPPJUlpT/PzVfDLbhF4iylS8m0A+55fn6vDowZx7e4344vhDhw5h7Lh3cOFidHumDa9pZm5seWW88mnRxY2d+8MQHpXotlTXQBmt+4KDtOEZgQETOxpuwXxhDrSg38FybDxgaXHbYZPVjqLKZnyzNxMTghJwLusOaprciyNuG5IPhIAQEAJCQAgMaQIOOLR6WONXQ1vzU5g2/QK2rO33/2Ad0mOTzgsB3xIQscO3PKU1ISAEhIAQEAL9SqCyQVNlqV5ZeVnVNM+/0wgbzTncbIzZmq12hKWX4b2gBEwKScLF7ApYvDAqZ+vMEOEK2xm70pXIQv+Pmy4yShg4psDC1bmNmlV5hFQ2mFBW24rC8kZkFdxBTHI2Lsenoyf+AsZAtyfvC3/yU5x84mmVScJguP/cVQjaeuh+MPyeV8N9n4Y8JXTU1Na3B97d4HW7mxycMzsopjB7xJP+enLM+nenYN++k116eHDemK3A8kTM7OCYKQp40r5+TPgTT2PFwnUIj0pS59JFDvp0rPAPwNHRL3nVnt6u/mzMHqFhOLMqlABhMBFnH1h2ifN59tFRWP3e5/jYz19dR2pspy62i1Ucrz6fLFE1XAP5LGP19ttjkZzSVmqM4k5g4E4wC4am7uci4t2KG2RNcUkv1TVQRutuf0Tygc8JDJjY0XwX1uQQaJseh3nvS3A0lgN2q8vxUewoqW7GnH2Z+CAoAacz76BaxA6XrGSnEBACQkAIDFcCDpW9Yc0+CtO+N6GtfxDWmGWw380drgOWcQmBXhEQsaNX+OTLQkAICAEhIAQGjoDFbseVkjpMDk3CW+tjse1yIRpaLR51KKu0Dt8evIIXl0dia2QBappMHn2PB1ltdtyqbcGCw1l4a10s/HalK0N0BqW82YwCgCf+AnpQ3Jvn0n/8CSIeflJlAUyZvgjzZi/FhpD9YIkftdK/k7iRrzwb9OAvRQoG3G1eCEJGDka/CW+zKrobL7Mu1r4/FQcOhrkVPO6LHW2ZEa5KHHV3Hn4e88iTSmSgOMUHMwWYRZH84EO9EjrYtnP2COfGWDrMyHHB3FVt8xm0G/uPnvd4PodrIF+JHWPHIiMzS7Hz5PrWxY2hUqrL+NuS9z0nMFBiB7Q62K6fh2nHX2He/hfYy9LgMLv2j6I4X1rTgm/3t4kdpzLKUOXF/696Tke+KQSEgBAQAkJgkBCwmWCvyofp6AfQgh6G6cCYtv93WrVB0kHphhAYXARE7Bhc8yG9EQJCQAgIASHgEQEGrm/XtWJXbDFeW31ZeXVklNSprA1PGrjbaMLe+Jt4YeklzNmXgfSbtbB7qFVU1ms4mnILb6yJxoebE3Es7TZYqsrbzRh8Z3YAg+aeBNy7OoZ+ESzbo3sSfPvVEqxdt015EtB7g6v8nVf6e2RC3YsyRhR1GEimeMLsAvpa9EXJru4ED2M/mJXhN8MfDT/6cY+Ys1wUH935jjCDJfKRJz0+h57dwTkymmS3XTMtnQL5/Tmf3l7n/Xl8W2bH28i6mt3BaJ3ZLLp4J+JGf87I4D7XQIkdDmsr7FW5MB8cC9PmJ2C7dhiOpgqXsJh1eLtWw3cHMvH+xgScSLuNqkbPxXmXjcpOISAEhIAQEAJDiICj7iasSRugrX8Apm1/hvXKXjhMjUNoBNJVIdC/BETs6F/ecjYhIASEgBAQAj4hwABQZE4lpmxNwdgNcTiUWIIWsxVdVLDqcF6WukorqlE10N8NjMeeuJuq1FSHg1y84Srb6Ly7+HRrMt5YG42N4fmgcGL1VClxatNV8J3+AjQJ70rMcPUZswp0T4JZM9sMl7vzJOiv4K9R1OlpRoWrcRv3dSV40HzbarOpUkVpmbkqC4LG1BSGjO346j2FFL/pi5RXhKdtUqxiearwyITOYofDoQzEWYaKAXyKIR6JVfTg6IVg5XTZDuqXutiRm5vbyWhdMjcG9dQNSOcGSuyA3QZojbCc+hTaxkdgiV4Je02hSwb8f115nYa5B69gfEA8jqaUgqUQZRMCQkAICAEhMOwJ0EfO3ALbtSMwbfkTtMBfwhI5D/bmu27LPw57JjJAIeABARE7PIAkhwgBISAEhIAQGGwE6lrMCL1UgKcXRuCrvczMqPO6iywNsuTENbyyKlqVpKprNitT5q4aulHRhLVn8/Dskosq+JRYUN3td7pqz1iWqCflnWgwPmvWEuVJQONvZix4vdK/D4PhDLI7+3Ws37ADZ554us8Ehq4ED/Lmyn6WhyIjmnbPnzy7z/qiZ2l0Na/sL+dw3+iXVV+YbUL/j4iopE5iB68lijYsQ0X/EeeHBPMBXezIz89v8zlxNlofAWJPV//WyGedCQyY2MGuOBywRsyGtvEhmE5Mgb3iaucOsmyi3Q56U80/lIXxAXE4nESxQ8p2uIQlO4WAEBACQmDYEbDdSoL55GRoy/8bLKc/g60kbtiNUQYkBHxNQMQOXxOV9oSAEBACQkAI9DEBBxxIvFGNL/ek4xn/COyLL1HZFd6etr7FgvNZFZgYnIhPQpIQf6MKjZprzw+ek6Wq9sXfxIebEpVXR1hGGap7WTu9Q1mi+HRs3n5UBb09zQLgccwEYUaIbpYdl3QFzFzor8yN7rgbBR2W1aKPSHdjpAhAAYDP3R1r/JxMlk2ercQMcolPuoLs3ALQZL2+oam9pBY/60qIMLbrzXtmdXwzfYEyMzeKKrpJPMuW6SbxnHse1+4zkZChsjcoaPA6cd4oIHFfh4cE8zuIHc685LUQcEVgQMUOChkJq2EKfQLajr/CfivRVRdhtTtQ3WzC94ez8G5AHA4klKCiXsQOl7BkpxAQAkJACAwfAnarKvFovrwY2uYnYNoyCvbcE3Bo3i9wGz5QZCRCwDMCInZ4xkmOEgJCQAgIASEwKAg47A60mm0IjijAuA1xSnjILKlVASFvO2ix2nGrpgXfH8nCuxvisO5cPkqqWlw202y2IbWoBjN3pykz9B/CclF0t6nXpYGMpayMQXFPg+vMTtAD5akZOaiorEZziwYKDe0B8QEIhhvHx8yTrz6f55F4QT+M6TOXIOitSR4db2TlTvCorKpFeWW1EoSY3RF2Pgbzp8zpkahiPKfz+/XvTsG+fSfbRSiKPCsmfAFnk3j6tLSLGxRlktuEKr00FctVMYuDHGXrnoBzZkf3R8sRI53AgIsdV/bBtOtFaBsehK0w3OV0sOQiMxkXHsnCOwFx2BtfgnIRO1yykp1CQAgIASEwfAg4WqphzT4E0/ZnYNr0GKwxP8BRW6wyI4fPKGUkQqBvCIjY0TdcpVUhIASEgBAQAn1CwGy14U5tK77YkYI318Yg4Px10DC8p5vd4cCOmCK8ExiP8RvjkFFU6zKwXFrdgiUnr+G5ZZfgtzMVOWX1Hnl8eNIvY+ZDT3w7jjz9nwjavE+VZmKgnKWaBkOAnCH6thJWbWWjtu05qbxFnEUBd69PPDUagZv2IGTTXux58U2fCR5XcwpQersCfGbGB7M7du051mNRxdh/ZqKsen8admw52FZSLCFDzcu58DgcOHYeUbEp6r0npcYodLBslWyeERCxwzNOclQbgYEWO2w3wmE6+C5al/wdbDlH4XDxW6fY0dBqgf/Rqxi3IRa7Ym/iTl3P/58ncy8EhIAQEAJCYCgQsN/JgGn/y9BW/APMR9+BnUIHPa9kEwJCoFsCInZ0i0gOEAJCQAgIASHQNwS4WL3D415Znq7OVlbbiv0JNzF2fazKssgoqUOzydrVV7r9LOFGFb49kInnl0XiSFJpp5JYtc1mnEorA43MPwhOUKWs6lstPhMTKEo4e1rQr4GG48YgelfvmQWx8NsV7WIH2xsMYodRyPGmZNTyidNBM3OKEYGrQnBq1HNeMdF5ucrwuJJ9HTcKS1WZqLikTHWO9Ss34eBzr/XoHPq5WLrKf/JsHDgYptpk2ywpphuJOz/TYHywlBrr9kcyRA4QsWOITNQg6eZAix0M5JjPzkSr/49hTQ5uM1w1sKEgzxKKiyl2rI/Fjphi3KlrNRwlb4WAEBACQkAIDB8CjtoiWC4vgbb+32Da9Tys2YcBs+vs++EzahmJEPAdARE7fMdSWhICQkAICAEh4BEBk8WGkqpmXLpWibNZd3DxWgXirlch42Yt8u40oqS6BVWNZrSYrLDZ7e1tUhjJKK7DZ9uSVdAnOPwGWsw8pnclfsrrW7HtciH+uvgilhzPRvrN2vZzsl56WnEtvjt4BS+vjMbKsBzVx96es/0E9wQe+jIo0+yEDGU0vuWV8V4F3ZlNMG36IkTFpargelV1nSph5Xye/n5NsYWm2QzoszwTRQtvslamffG98rvg9/hY5b8eMY886RUXXYSg4LFoyhxVsoptsT8UG/Ju3ERSWrYSibh/c+AOhL45ERQt9O968szjT/z7c5g7bV4nn5C7VbUq08bZTFx/Labivr0qRezwLc/h3tpAix2O+lJYYlYoscNyaQHsd/M6IafY0WK2YemxbCXyb4suAkV/2YSAEBACQkAIDD8CDkCrhzX7IEw7noNp4x9gjV0FR90twHH/nnD4jVtGJAR8S0DEDt/ylNaEgBAQAkJACHRJwGy143pFI3bGFGFsQBxeXhWNcYHxmLItBd8dysKas/nYGVOMM5l3kFxYjevlDSirbUFVgwllNa04mFiCP82/gC92pimxpMuTefHh5dwKvLEmBu8HJeBIcqn6JsWVu40mbIksxEs/ROHDzUm4nHsXVicBxotTuD3UKAp442vhHIjXMyEYyKfAwED6QGZ3tJWwui/iMEuDfXTus7vXNDCnx4UudPA5MjYFy79dgasP/MqjNoxtV//d32PxtLkgX7ZHI3cKHQkp2cBbJAAAIABJREFUWUhOy4ae4cHyU1/6LcLe517r1kg9+2cPIOiNifCb4Y/AwJ24EJmghBO23WaI3qDKUJGFywcvMtl8RkDEDp+hVA1ZrVY0Nzfjzp07KC0tRUVFhXpvd/NvIEuu1dXVtR9fWVkJTWvznOG/RWazGVVVVbh9+zZu3bqlnmtra9V+nlD9W9jcjLt376rPeQzPzTb1cm48prW1tf0cbKusrAw8V0uLd6s+B1zsMDfDmrENrf4/gvnkJ7DdjO00gRyvZrFh6fFsvL0uBlsuF+K2iB2dOMkOISAEhIAQGAYEbGbYbyXCfOIjaGt/DvPJKbCXpYvQMQymVobQvwRE7Ohf3nI2ISAEhIAQGKEEmAlR3WhWWRwLDmcpc/G31sdiUmgyPtmagveCEjBmXSzeWBONt9bGqBWs4wPiMCEoAZ9uScZXezMwe18mJmxKxKj5F7A9qgi3a7wLbHWFPresQWV1vL46GqvCclDbYlamsCfSbiuR453AOBxSJa76xizaWO5p1kx/MDhvDNh39V73uKAXBLNEVCmrrgbdg88YeHMZtL8XqHRuksc6l+ei/wb72NUY9M8iHn4Sa9dtU6KEMvBOyFCvKXjMn7W4WxFCb8f4bBQ82HZqZg5ult5RHh4UKciP5wnZclAJLswwoUjj/JgzZQ4+9vOH/9xV2Lm/rWTVfQ+OHCU21dQ2wOqiBr8zI3ntWwIidviOJwWNoqIi7NmzB5MnT8bYsWMxY8YMHDp0CBQojBuPv3nzJtavX99+/OzZs3Hp0iXU19crgeLGjRtYvnw5Pv74Y7z//vv46KOPsGrVKiQlJYHCisViwcWLF/H9999j4sSJmDBhAqZOnYoNGzagpKREiSI8Jjo6GuPHj8err76KSZMm4bPPPsPixYuRnJxs7FaX7wda7GAdR1veUbT+8H/CtP8V2HKOd+ov/7212OxYfvwa3lobi02XCnC7RjI7OoGSHUJACAgBITC0CfAeo74E1ouzoa3/HzDteha262fhYPkqWRw0tOdWet/vBETs6HfkckIhIASEgBAYaQRYhoMrUffE3cTk0GS8tjoaU7amYE9cMSKyK3DxWiVOZ5ThUEIJtkUVYv3ZfGXG+tWedCV00CdjXGACXlkdrR4TgxOQcKMazBLx1VbdZEJEdjnGrY/BFztSEZVbicSCasw9eAUv/XAZi49dw43yRnAsfbEZhYGVyzYi7lePeCQM6AH9dt+OhAyflbJyFjcoyDBbRC/BZHw2mmkbBRxmajBjQ+9vV8/rx32CPYfOqOyL1Iwc8KFnXoRHJeE7v++9FoP08zkLHm3CUD5q6xpRU1uvRIq0zBxV5oqf8RERlYTDx8M7PE6fj1Gf6ccwm4bf0z04yMlm89312RfX3HBsU8QO380qxQfy/PDDD5VAsWnTJnzzzTeYNWsWMjMzlTDhfDZmY4SFheHTTz+Fv78/goKCsGDBAnz77bdKzGCGSEFBAXbs2AG2tWvXLgQEBKjjf/jhB5SXl6sskMjISISGhmL79u3qmIULFyqRZf/+/Srbg2LH6dOn8cwzz+Dzzz9XYszBgwdx/vx5JbY496m71wMudgCwFV+Ctvl30Lb9Gda0EJddttsd+OHkNby1LhZBFwtwy4dCv8sTyk4hIASEgBAQAv1MwGFqhDVzF0xbnoS24d9gSVgHe1N5P/dCTicEhgcBETuGxzzKKISAEBACQmCQEqCxavatemyJLMC4gHi8sCwSM3el41R6GZrNtk69ttocqGo2o6CyCSlFNQi/WoGDiaXYdLEAy0/mYPWZXBxOLkV5vdbpu73ZYbXZVR30GTvTVD/nH85S53t7XSwmBCcg8lql8gfpzTm6+i4lFIoHvvDtYFZCT0tZuRM3GhqbQR8QBvPpdeFstM3X3JdfUAIKHqoNg18HBQpmSOiCQ3fPPDbicrISOcorq1FZVaPKQsUntXl/sBTVwqnfee2toZ9XFzzOhcepsTADhWVyKFJ0NU7juPWx3xc5NOWV0jeSWFdXkHxGAiJ2+OY64G+4pqYGS5cuxd/+9jfk5uaqhk+ePKmyNg4cOKBKWvE4bnxOTU1VogizOa5cuaL2nzt3TmVfMDukoaFBtcmyUyxDxY3noHjyySefICMjQ5WhYrksHqNvFCTmz58PtpuWlqYyQNjuO++8gzNnzuiH9eh5MIgd9rJUmA6OhbbpEVijF7sehwNYefIaxqyJQWD4DZSK2OGak+wVAkJACAiBoUnAYoLtTgZMB96Gtu6XMB/7UPlYOeyd7xWH5gCl10KgfwkMuNjBmwPWsmWd2eLiYvXga/0mwBkH08NZi5afM02cD6Z0s/Yta+C6q5/r3AZf5+XlqfRx3ijIJgSEgBAQAkLA1wQY/mLZjapGEyKvVWDh0at4ddVlvBcYj/Xn85Thd32rxWWWBEvB0xScWRusU05j1kbNivoWC2qbzahrNqNJs6hjfNlv9rnJZEVwxA1VUuu5ZZfw0srLeCcgHsEXb+Bug6lP/S/49wAD7QyaU6joqW+HnhHB8kxtpayaVdkpd6x4Xo6dD+fMDVfiRlpmboeMB2Y1hEcmICo2BTwfBQ8KNnp7bSWs8lQGxLY9J+Gp6TqFCJbxYvsUE9gX9o1loeiDoQsex89EYdnk2aD5uC5idPXMdpktw3589fk8fD3LHwcPht0TO5rbRBoDB2P2irv3nDv2kWOXbeAIiNjhG/bM6sjKylKloZg9oYsPLBO1YsUK9aCgod97UCg8deoUZs6cqbIxeH/CjQLImDFjEBwcrO5XeBzb1r/Hexpmf/j5+aljef+jH8N/m7jxnMz8+Prrr9vFjrNnz+K1117Dxo0b1f0QfT0aGxtV2+pLHv5nUIgdlbmwhM+BFvhrWM75AXary9rkK8Ny8OaaGKw/n4/Sat+VcPQQlRwmBISAEBACI4kA/x9sNcHRWgNHy13A3AT0lfDgsMFeeRWWy4uhbfwdTPvfhC3nJKA1jiTiMlYh4FMCAy52UOi4du2auml4/fXX1Q0Ba9fqK6KcR8v0b940cJXVuHHj1OODDz5QKeCsqWsymZwPd/taxA63aOQDISAEhIAQ8AEBOxyqzMbO6GJMDk3C88sjMWFTAg4nlaKkqhkmy+As70OBJiavCl/uzsDvZ5/GqO/DsexkDnLvNCrxxgdoumyiN2Wf9CC/7nWhCwXKt8Op9FavxI2EDDBDgx4Va1aFKLFgyvRFWLsiuF2Y0M9nHIs3ZbkoSPD4+2NoEyLof2EUPA4cDMPa96fC8l/+SyfBgyJI8oMPYdeLY0CPDQoobJfCy7mIeNW+UaTRJ8iZky7edPnsxFhvQ577n4CIHb5hzkVUly9fVuWomFXBElXc8vPzlXDBclZxcXHtogUFCmZv0IuDQgQXYnHLzs5W3hvr1q1TooQuYPAzCh7Xr19XmSJffPGFMkBnO8bt6NGjqlwVS17R84NlrCisPP744+rx3nvvqawPen3o5zW24e49vUJefPFF5Svi7pi+3u+oK4E1JQSmjQ/DfGwi7I3lcFjNnU67+nQOxqyNwdqzebhZ1dzpc9khBISAEBACQsBnBOwWOKqvw5qxE9bEANiKI+ForfNZ884NqfJVqYHQAh+AtvG3sCZvhEOrF58OZ0jyWgh4SWDAxQ6uRGJdW65o+u6779TqJpoAbt68WZn56SufOC6udmIaOevSrl69Whn6cTUUV1GtWbNGpZN7Mn4ROzyhJMcIASEgBISAtwQY72U2RnJRDdady8PYDbGgCfk3+67g3JU7qGzwTJT39ry+Ot5hByrqTSq7469LLim/EHqKmG32fvHFYyCwLRsiXwXiadBN8UIXMjx5picGvTEYxGcmxt2qWrVSmm1TgGAGArMTGlyUpeqUuZGQoYy69x89r8zC2S7LSwW9MRFRv30M5f/wj8o3Q2VhOPmEMGDpnKUSHZ+OqX6LPM7AYOYFBQlX2SmuBI9de44h6K1JSvDI+PkvsW/0y5g/ebY65wr/AITuPo4wemwkZCiubf4auSqjw1h+y1fXkrQzMARE7PANdy6gioiIUJkdNP7WRQR6boSEhOCrr75SJuH6fQp/8zt37lTCRnh4eLuBORd08b5m7dq1SqjQj+e/RyxXxf00IKc/B7PXnTcKLlz8tWjRIuXrkZiYqEphMTOEIgrvhfjZsmXL1D3U9OnTldBCMcRZVHFus7q6GgkJCeANILNCOI6nnnoKFy5ccD6sX187WmpgK4iAKeQpmPa9BltpEhzmzmLG2jO5eGtdDFafyUOxiB39OkdyMiEgBITAiCFgt8JeUwBr5m6YT06GFvoktKCHYdr7CiyxP8BWEnfv/1G9y2VWC4haqmErjoYlZglMWx9H6/L/A5bzfnBUtJXCHDHMZaBCoA8IDKjYwT/WafD38ssvqz/2y8rKQPGDK6ho5peent7hD3/eIFDw4M0AM0L4minmXF3FVG6udvJkE7HDE0pyjBAQAkJACHhDwGS143ZNKyJzKrDgaJYSOd7bGK9WoaYU1kAz21yWrfLmHP1xLD1D4vLvKm+QYym3+7U2Ov/wpxCh+3bQoJtlqTwROZyPoSDBDAwG9bNzC5Xg4am4QWHi8IkIbAjajXmzl4KZG6vf+1yJLu7MxVkSimW32n1CmluVmKKP48ipi/CfNNPjcXRqr6W1Q/DSleARsmkvpvj5Y8n3a7B5+1GwxJUubjBD5L7AkdduIk4m5G00Vu+P60zO0TcEROzwDVcKDTExMUrsmDdvXntmBxdd0Xic9yksAaWLFxQ79u7di48++kiZh+uZIBQlJkyYAOfMDgoRLHNFw3FmgnCBV2FhoRJl9d7zPodZJCxfRa8OGpbX1dWpfwf0+yH6fbB0FQWMS5cuqQwNLv7ifr1fenv6M++z6Dsyd+5cUBxhpvyjjz6qzM31Y/r92dIKR1U+TDuegbb9P2C9ehAOraZTN9afzVP/X10Zlouiu53FkE5fkB1CQAgIASEgBDwhwNVqLFlVWwhbwQVYLs2HacdfYQp4CKaQx2HaOgqmwN9D2/wozCc+hO3qAdjLM+HQmOnBbH0vhA+bFY6mu7DfSYE1PURlNGrBj8AU9GuYDo+B/WYUmOkhmxAQAr0jMKBiB/84Z6r322+/DRr9ceNKKt4s8MZi165d7SupnIfJmwQ+eCNCsYSrkl599VURO5whyWshIASEgBDoFwL6n7e3alpxILEE7wTEYfSSCHy0OQkn02+rclYUEIbSRr8Q+ncwS8Xej+WJ+P9254wIb029dcFD9+2gcBGXlKkyPOh94Spzg8dQjAjaeggLv12Bj/38sXzidJx9dBQKf/JTjwQKYyYGRYT6hiaVOUGhIXDTHpx4arRHbTX86Mfwm+HfnplCs3BmpBg3Z8EjLulKW0mq+PT25/viRpt5um4gzswZZ38NXpnkLtvwICBih2/mkQuymFXB7HNmXpSXl6uGaRC+cuVKVVKXhuK6qMDnEydOKAGB9zG3bt1Sx3Ph1htvvKGyKJgdogsVvMcZP368aisnJ6e9Hb33LM+7ZcuWdr8PCh36uXiM8TdLH0OWs1q+fDmYfcL+u9ooynDRGNujKEL/wueeew4sgTVgG1MKTY0w7/9PaJsehiV6FRxNFZ26s+FcHt5eH4Nlp66h8G5Tp89lhxAQAkJACAgBrwk47HBYTbDXFsISswJayONoXfK/Q1v//8J8cgps18/BVpoAS9xqmEIfQeuyH0Fb/S8wh02DrfhyW5aHzfX/czv2xaH8qBwN5bBmH4P58GtoXfP/oHXpP8C09S+wxK2E7W4eYGn1TjzpeBJ5JwSEwD0CAyp28EaAIgdXNYWFhakuUcCgAPL999+r0lT6zYXzjHE1FOvXckXS2LFjMWXKFOzbt0/90e58nLvXktnhjozsFwJCQAgIAW8JmCw2pBbXYs2ZPHwQlIBXVl3GoqPZiMypVKbeFqsEkr1havS6YOkodxkVurhhfNZ9Oyhk8KEyHFjCKSFDvWfWA7MfmAXBbAhmXRwZ9Tzy//lfPBIkjOejLwbLRekeG7X1jaisqlXiCs9JEcXTtlmGiv3S29I9QFwx1AWP3OvFyhydgg4fLE2lixsN97I3OggcIm64wjks9onY4ZtppJjA7AyKB8wev3r1qlpkdfz4ceWfwawMZknoogOf6StI83JmfVAU4T3N6dOnldhBPw9mazATg/c+zNZgdgUFFefyVRQjmOnOslaTJk3Cpk2bwPsW543t0sdQFzRYtoqiCr032N+KiooOwojzd42vWRproD07VJ+sGswnP4EW/CjMpz4DfTyMW8D5fIxdH4ulJ0XsMLKR90JACAgBIdADAnY77OVXYE1aB/P+F2EKehha0CMwHxkPa3ooHOUZKnuDpRUdtUWw5R2DJfwrmEJHQQt8CNq2J2G+OAu2okttBubuumCzwE5/quxDMId9Ci30KWgBv4Rp52hYoxbDduOsat9hM3uVJOLudLJfCAgBqJKt06ZNa1+A1B2T/6W7A7z5nKuQdu/erW4azp8/r77KP+C5umjhwoXqD3beSBg33gTwePp1UCihqV9XYgdvLJhGztVLFEmYSs4blzNnzhiblvdCQAgIASEgBDwm0KRZkXCjCouPZePdgHhMCE5UZauSC2vQbLL2i8+Fx50dIgcyaNhb3w56aXw9y18JGxQ76FdB3woKEvTOoJ8FfS0oLLgy9jaKGd29pxE426WwkZqZg5uld3A1p0CVjvI2O2X3c68rIYZtsQwWy0x1JZfZbPZ2HxIeqz86iBsuVoIPkctBuuklARE7vATWxeG8Jzl06JASHZjNwUwLChlffvmlEjaKi4vV/QXLTVF8qKysVMbhn3/+ufLRoLcH72f4HYoKPIaiCTM6Ro8erXw4KGpwzqKiopR40tTUBAoq77zzDv74xz8qTw5mgRw7dkyV1aIAU1tbCxqL83sUXfg5y1dNnDhR+RqyzK8uwnQxPPURS3ENCrHDZoYlciG0zY/DtOtZZQpr7HvghesYuyEO/ieuoaBSMjuMfOS9EBACQkAIeEbAYW6BvSoftuzDsJz7EqZto6Ct/xeY9r4ES5Q/bEWRcLRUdzYIt2iwV1yFNWUzzMc+gBb0a/UwH58Ea2oI7HfS4NBq73fCqsHRUApb/hlYohbDtOclaEG/g7b1zzCHfa58QezVhYBVu/8deSUEhIBPCAxoZgczNJjq/dlnn6lsDo6INxY0yePNAW8sXIkdziNn7Vya873//vtuy1jdvn1b3Qiwji7/oP/zn/+szPi42ko2ISAEhIAQEALeEmDwmR4cqUU1mHPgCmjm/V5gPHbEFKGmySzpx94CdTqebBmw1/0uaA5Oz4zuBAfj5/S9WLY4EDQPnzNlDna9OAbMwKAwYTzWF+8poDBjJDYxE8lp2ap8FoWWnfvDlKG5u3NU/93fK7Nzmp7PmLYA875ejguRCff9Pwx+HU6o2l8ysEluHR6SvdHOZyS9ELHDd7PN3xUFjR07dih/QRp5U6jQF1glJyerRVtkrnt00HR8yZIl6vgnn3xSCRBcxMWFVyxjxcVaFDr+8Ic/qPJRzz77LJ5//nl8/fXXSsBgOzQcHzVqFPj9Z555Rh33+uuvK09DiiXMemefWAb46aefBtugOMJ7Ki4k82YbPGKHFdaUUGhb/gQt4AHYyzM6DWNj+A2MDYjHwmPZuFEhYkcnQLJDCAgBISAEuibAclOmBthup8IS8wO0oN9DW/lP0AJ+A/OJj9tEDrMH/39x2GC/ew2W6KXQQp6Etuqfoa39F5jPfAFbQQTQfBdoqYa98iosaaEw7XwW2g//hNaV/wTzvpdhubIb9obbqqxV1x2WT4WAEOgpgQEVO/gH/alTp/Duu++q1Um8qaBnB1dR0aR869at7TcP+gDVDb3TDTxrzlIU4Y0Ca+e62tgmz8Uatlx9xYwOnpPlsmQTAkJACAgBIeANAf4vqK7FggtXy+G3Kw1vronG9J2pOJF6C2W1rbDaGXKWracE+P95Z9+OyNgUTJu+yOsMDGZtxP3qEVBMcCc0+HI/M0VYGksvnaU/r1y2UfVDPxc9OSi60OeDggzFmDWrQpQoEh6V2Oa5kZCBtMwcuPPr6Clb+d7wJyBih2/nWL+H4OKqrKwstbCK9xQsIcUsDAoY9L7QS0rxeJbpdT6+vr5emY/zGN63XLt2TXkO8pkPenZQpGB7PIaLtChq8KEfw1JWFFJY8oplq5hFwnsa/fPr16+rvvD83myDRuxwWGHNC4Np78vQ1vwMtsLwTitdgyNuYFxAPBYcycb1cg+CUd6AkGOFgBAQAkJgeBLgjZvdAmj1sN/JgDl2FUx7X4EW+GtoAf8KS9insF49DEdNIRxaPRyOzj55ncE4AEsLHA1lsBdFwRI5H6aQ/wlt/QMwbX8G5vOzYb7wDUwH3oIp4JfQNv4rTIffgjV1Cxx30uFoqQJs/P+13DN2Zit7hIBvCAyo2MHatXqt2KCgIJXezZVPXNHEFU7R0dFqnz5U3gAwdZvf0zfWpaUwwmwN1r31ZLtx4wY++eQTVdbKk+PlGCEgBISAEBACJECzbgodJ1JvY+qOVLy88jK+3puJs5l3UNGgyZ+sPrpMjL4d3nhe6KJCfz/rXhu6yKE/02w86rePqbJZzDDhe5bT2rbnJM6Gx7X5icSnq0wOGqjrnhv5BSVK9JHbIB9dVCOkGRE7RshE+2iYg0fssMNelgbz8YnQVvwE1sxdcDRXdxjl5osFeCcwHvMOXRWxowMZeSMEhIAQEALuCDha62AvTYQ1YR3MR95Fa+BvoAU/AvPBsbAmrYG9NA6Olhp3X+92v8OqqQwOW+YOmE9+DC3kT9DW/Su0dT+HtvH3qnSVJXohbAXn4Wgsl2yObonKAULANwQGVOzgEFjKisLDN998o+rO8ibt008/VQZ/XBnFlU5FRUWorq5GQ0MDmDLOdPCIiAj1zDq19OygSbmnqdtiUO6bi0daEQJCQAiMJAJ2uwMV9RpOZ5Thk9BkPLvsEmbuSkPktUrlzzGSWPT1WJnd4ezbEbhpD048NbpfMjR6KpLovh26yMFnlqOaPmupMhxn1ge9Q+jFQfNxPuKTrygTc5bsMhqKt7RqajV4X7OW9ocXARE7htd89vVoBo/Y4VArZC0XvkTr0v8Ky+VlsNcWdRh+yKUCvLsxHt8euor8O40dPpM3QkAICAEhIATaCbC8a2sN7HfSYc3YAfOxSdACfwtt9T9D2/QwLOe/hK0wErB7ksXR3mq3L+x3smCJWQHzzr/AvP3PMJ+ZClveWZUx0u2X5QAhIAR8SmDAxQ5mckRGRmLevHkYM2YMxo4dqzI1YmJilMBx6dIlVdaKJaqYsn3y5Ell9EePjgkTJoA+HCtWrFB1bpn+7ckmYocnlOQYISAEhIAQIAGurLfY7LhZ1YyDiSV4b2M8xqyNwfdHriK5oAZ1LWaV8SG0fEeAzJ19Ow6fiMDyidMHrdhR+JOf4uyjozBl+iKVrUGhw1nU6Cxu5CPzan67wEFhRwzFfXf9jOSWROwYybPv/dgHjdjBrltaYIlZitZl/xXmsGmwl2d2GFBoZAHGb0zA1weykCdiRwc28kYICAEhIATsqvyho7lKlauypW2F+fB7MAU/ojItTNv/A5aIb2ErvARHfSlgae5sQN5TiCoN2wFYTXA0Vyo/D3tlNhx1JXCYmwG7tacty/eEgBDoIYEBFzvsdrsy7aMAERcXB/7RzRq0zOJgTVqWqWL2h16+ioblLFeVkJCgSmClpKSgsLAQra2tYFuebCJ2eEJJjhECQkAICAESoNBRWtMKBlrGBcTh+eWRWHU6F5k369Bqtknpqj64THzl29HTLI3uvlf6jz9BxMNPYv24T5TAMW/2UmwI2q0MyjtmbOSrslR6aSpj9kYHgcPJj6wPkEqTI4SAiB0jZKJ9NMxBJXbYrbCmhkBb+68wH3wb9uLoDqPccrkQ44MTMHtfJvLKJLOjAxx5IwSEgBAY4QQoKtjLr8Aavxbm/a9B2/Bv0Fb/d5h2Pgfr5cWwFYTDXlMAWFr7nhT/ppe/6/ues5xBCHRBYMDFji761mcfidjRZ2ilYSEgBITAsCKgWezIKWtA4IXreDcwHq+ticaaM3nIKqlTIsiwGuwgG8xg8u2gyTl9N4LemIgZ0xbg26+WYO26bdhz6Ayi4lINZaly2jM2GhqbVYYKs1T46CBuMGtIboQG2VU39LsjYsfQn8P+HMGgEjscNlivHYUW+ieYtj4FW97xDii2XS7C+8GJ+HJvhvr/cocP5Y0QEAJCQAiMSAL027CXxMFCT46j46Ft/C20gF9D2/4XsDSi7doR2OtLaLw4IvnIoIXASCUgYsdInXkZtxAQAkJACLglQCPyZpMV6cW1CLhwHW+ujcYHQfEIuJCPosomldHh9svygU8ItJWyagH9LJgtQc+LfaNf7pdSVg0/+jGSH3wIW14Zj68+n4dZM/2xZlUIdu4PQ3hUokHcuG8qrmduNLdooFjDMXR4iLjhk2tDGnFPQMQO92zkk84EBpfYYYetKBKmg29BC/oFrBlb7nW4LUC1I7oYHwQnYsbudOTcbug8GNkjBISAEBACQ5uA3QaHzQSHtRUOUxMcWh0cLdVwNFUoXydHXSkctUVwVF+H/W4ubCVxsKaGwnR0ArSQx2Ha+BuwXJX5/GzYcsPgaCxTJRLhsEmmxdC+MqT3QsBrAiJ2eI1MviAEhIAQEALDnQDLU6XfrMOS49fw0ooovLE2BjtjinCnrhU2m2clE4c7o74en7GU1fEzUZg/eXafiB00F8/4+S+VmDJnyhz4zfDHCv8AbNtzUnlw6P4b9w3FO3pu6Bkczpkbfc1H2hcCrgiI2OGKiuxzR2CwiR32O1dgPv8VtIBfwRq3Cg5LC1SQCsDO2GJ8sCkRX+xMw7VbIna4m1PZLwSEgBAYUgS4EMhmgUNrgKPOEG6qAAAgAElEQVSxHPaaQtjLr8J+K1GZiFvzwmDN2g9r2lZY4gNgubwcloi5sJyeDtOuF6Ct+Rm05X8P05ZRMF/6HrZbibA33lH+HUOKg3RWCAgBnxIQscOnOKUxISAEhIAQGOoEGjUrLudU4tv9mXhzXSw+CknC4aRSlFQ1wy4p0P06vcZSVlP9FoHCRHeeGp58nv2zB3Bk1PPwnzQTbHfJ92tU9kjY+ZgO5uL3BY68TuWpnMUNlcEhmRv9en3IyToTELGjMxPZ457A4BI7HMrM1ZK4EabA36qVufbaYsBuUQPYHXcTEzcnYuqOVGSL2OF+UuUTISAEhMBQIeBwwN5YBtvVg7Cc+AjmPS/CvPsFmHb8FaZt/wFtyyhom5+AFvwotI2/h7bhN9DWPQht/b+qhyn4YZj2vgJL9FLYrp+Bo/oGHP3hyTFU+Eo/hcAIJiBixwiefBm6EBACQkAI3CfAYLXZakdWaR0WHb2K19dEY+r2VBxMLEFlvQarCB33YfXTK2Z3NDaxlFW+Kh1FQYIZGJ6IGcZjCn/yU5x9dBSWT5yOj/384T93FYK2HsKRUxfdiBsdszfYDxE3+mni5TQ9JiBiR4/RjcgvDiqxg2X/TA2w5Z2CKehhmI+8D1tJAmA1qbnZE0+xIwmfbafYUT8i50sGLQSEgBAYPgQcoN8GPTVMNBRf/wuYNv4Opi1/hmn7aJh2PQ/Tnpdh3v8GzAffhvnIeJiPT4TlxMewnJ4My7mpsEYvgS3nmBLKYdXuFY8dPoRkJEJACPScgIgdPWcn3xQCQkAICIFhRICB9bLaVmy/XITXV0VjQnAiTqaXoclkHUajHFpDoQBFY2/l25GQ4ZVvR+k//gQRDz+J9eM+wZTpizBv9lJsCNqNwyciPBI3XJWmEkPxoXX9jMTeitgxEme952MebGIHuMq3LBXa5seg7XwO1uxjbfXWAeyLv4kPNyfh020puFoqYkfPZ12+KQSEgBAYBARsZthK42A+PgHaD/83tF0vwHx5GaxZB2DNPQVrwSXYShNgK8+CvboAjsYKOEyNquQVHPY2Dw6VUd3m6zQIRiRdEAJCYBARELFjEE2GdEUICAEhIAQGjoBmseFC1h1M2pyEt9bFYk9sMe42aFK6auCmBN74dlT/3d8j6rePIeiNiZgxbQG+/WoJ1q7bhj2HziAqLrVbU3GX4gbXiElpqgG8AuTU3hIQscNbYiP7+EEndvDf3Oo8mHa/AC3kSVgTAwBzk5qk/QklmBSShI+3JCNLxI6RfeHK6IWAEBjaBGxWOGqKYDk7Fdr6/65MxW3XjsLRcBuOlio4WmvhMNW3mZSbW+Bg1obNAtgpcoh34tCefOm9EOgfAiJ29A9nOYsQEAJCQAgMYgI2uwO5ZQ1YduIaXl11GYuOZuParXouMpVtgAkYfTtmzfQHhY2GH/0YyQ8+hC2vjMdXn88D969ZFYKd+8MQHpUo4sYAz5ucfmAIiNgxMNyH6lkHpdhRXwLzsQ+hBf4GlgtfAqZahfdAYgk+Ck3CR6HJyCqpG6rIpd9CQAgIgRFOwAFH/S1YY1fBtPkRaCGPwJq8EY6GshHORYYvBISALwmI2OFLmtKWEBACQkAIDEkCTZpFlch4NyAO4wPjcSGrHE2alK8aDJPJzApn346VyzZixtT58JvhjxX+Adi25yTOhse1l6a6byje0XNDMjcGw2xKH/qagIgdfU14eLU/KMWOpgqYw+cq81nL0XFAU6WCfjipVGV10LcjU8SO4XUhymiEgBAYOQRa6dNxFKbNj0Pb+BAsEd+ojA7YbSOHgYxUCAiBPicgYkefI5YTCAEhIASEwGAmYLbYce12PWbvycArq6LxQ1gublY1D+Yuj6i+6b4dmVfzlaAREZWE0+dj2jM3YuLTcV/gyENOfhGqqusg4saIukxksPcIiNghl4I3BAal2KHVwpIYBG3Db2De/QJQla9qsx9JvoXJW5LxwaYkZJS0ZXt4M1Y5VggIASEgBAaSgAMOmwm2/NMwH3kf2roHYD4zHbZbiYDNNJAdk3MLASEwDAmI2DEMJ1WGJASEgBAQAp4TuF3biqCIG3h7XSy+2JGCpIJqtJpldZHnBPv2SGZ2tLRqyC8oAQWPjKyOD+7TBQ5mgDS3tIKlryiSqIfUIuvbCZLWBxUBETsG1XQM+s4MSrHD0gJr7glom5+AFvon2IujVCDsaGoZJm9JwXvBici4KWLHoL+4pINCQAgIAWcCFDoq/3/23js+quvc+71/3/e99z1vuafmnPgcJ45bnDi2Eyd2HMeJS9wLGFwwNrZxAXcbNww2YEyXUAMkIUTvVVRR1FEFFZAQqKPe++y+f/fzLFkO2GAkUJkZ/dbnI2tmz9prPeu7tvDM/Pbz/E7C2PcetKDroK99HPbp3YDBG8zOxcTHJEACA0OAYsfAcOQoJEACJEACPkigW7eQWNiAF5ekqvJVK+JL0O4x6dXhZXtp27YSPDo6u3Chn/MEDoobXrZ7DGcoCVDsGEravj+XN4odUsrEqc6Csep+aCG/hJW7FtDbseN4LV5fkYnnw47iWFmz78PnCkiABEhgpBBwHThtZ2HEfQFt2S3Qlt4KK2cN3M66kUKA6yQBEhhiAhQ7hhg4pyMBEiABEvAeAgVV7QjcV4iH5sVh1o6TqjSGmJWzeR8ByfD4LlujN2uj9zcFDu/bMEY0LAQodgwLdp+d1CvFDvl3vbUCxuanoQVcDTN5AdDVgF3ZdXgzOgvPhqRQ7PDZK46BkwAJ+AwB14Grd8BtLYfbWQ/XuvxSU057NazcVdCWXQst/GaYR6bD6agGXGbS+8z1wEBJwMcIUOzwsQ1juCRAAiRAAgNAwHVh2g42HK3A2KBkjAlKxt7camiWMwCDcwgSIAESGB4CFDuGh7uvzuq1Ykd3I8w9b0AL/C+Y+94H2ioRk1OPSdFZGBucjKxSZnb46jXHuEmABHyDgKu1walIg5W0AHbuBjiNhXCNbvQYiffjxjDHgn06BvrqB6At+AcY+yfDaTgFOKZvgGCUJEACPkmAYodPbhuDJgESIAESuBICmmEjt6IFUzfm4PEFCVi8/zSK6jquZEieSwIkQALDToBix7BvgU8F4LVih9YGM+FraGE3wdg8Bmguwp68JkyOzsLoxUkUO3zqKmOwJEACPkfAcWEXH4SxfQK0kBuhL70VxuZnYaWFwKnNhWtpfVuSY8KpOApj50RogVfD2DYOdvGBHkNyZmX3jSF7kQAJXBYBih2XhY0nkQAJkAAJ+CoBx3VR2+pBSOxpvLjkKCZFZSK9pEl5dfjqmhg3CZAACQgBih28DvpDwFvFDhidsI5HQ4/8E4yV98CtO459efV4KzoLowITkVna1J9lsi8JkAAJkEBfCdgGnLoTMA98DC34BugRd0KP/CP0ZTdDi7oDxt63YR1fCacqA25387eZHhcYXMZpLIRx8DNoEX+AvvJ+2Pnb4XbVX6AzD5EACZDAwBKg2DGwPDkaCZAACZCAlxPo0i1kFDdhXGgKng1JxpJDRRQ6vHzPGB4JkEDfCFDs6Bsn9uoh4LVih+mBfeYA9LWPQ192G5zSI9iXXYW3V2bhiYBEZJRQ7OA1TAIkQAIDTkB8OjrrYCbNVwKHFvprmKnBsLKiYex9A9qSn0Gb/8/Qw26Guedt2Gf2wm0pg2t0AI51XjhuRw2srAj1b7i27HcwUwLgdtSe14dPSIAESGCwCFDsGCyyHJcESIAESMArCYgp+fyYU3hwThxmbT+B/Kp25d/hlcEyKBIgARLoBwGKHf2Axa7wVrHDtQ3YtbkwYt6EtuQ3sHNW4UB6Pt5ZmYXHF1Hs4KVLAiRAAoNBQIzIrYLt0JffBW3Z7TAOfg6n8Qzc7ia4LSWwz+zpydSI/B20xf8BfdktMHa+BuvEJrhtlYCYmLsOJDvPLoyBvvIeaIt/DuPAFDiNRT8QRAZjDRyTBEiABIQAxQ5eByRAAiRAAiOCgJSG7dQsbMuoxAuhqXhxSSq2Z55Ft27BZd3YEXENcJEk4O8EKHb4+w4P7Pq8VewQA1xH7i6OnwE99CZYCV8jNiEF767KwqMLEpBezMyOgb0SOBoJkMDIJuDCtXTYRXuhb3oCWvA10GPegFWZcZ4/h6u1w6nJgZUTDXPf29Ci/wot7JfQV90LY9/7MHPXw6nNUb4cxvZx0IKugvx2SuN7hJCRDZmrJwESGEICFDuGEDanIgESIAESGD4Clu0ip6IVX27Jw0Nz47B4fyEKa9qHLyDOTAIkQAIDTIBixwAD9fPhvFbskBsQbBNW5lJooTfA3PUGYg/sxvurMvDIvHikFzf6+c5weSRAAiQwhARcR/l0GAfehmfef4O+5m+wT+2AKyGo/5wfixxymophHouCvnkU9LAboC26CtqKv8A8MEUZkWsB/wZj1V2wC7cBpuf8AfiMBEiABAaZAMWOQQbM4UmABEiABIafgHxv0txpIDT2DJ4JTsGrEWnIKmtBt2EPf3CMgARIgAQGiADFjgECOUKG8Vqx41v+dv4G6OE3w1j7CA7uXK3EjgfnxiOtiGLHCLlEuUwSIIHBJuDaQGctzLivoC37FfRl18POWwOn80f8NVwXUm4QWivc5mJYuetgbH8F+pKboAX8Jzzz/gla+G9hH4+CK+Mwg36wd5HjkwAJfI8AxY7vAeFTEiABEiAB/yMg5asSCxvxWmQGXgg7iqj4EjR06Hzv7X9bzRWRwIgmQLFjRG9/vxfv7WKHUxKr7jAWk/JDGwPw4aoMPPANxY5+bzRPIAESIIGLEeisg3UsGnrkndAiboeZ/A2clhK47vmG4xc7XTw63K4GONVZsHNWwoiZBGPTszBTFsJpLgJETGEjARIggSEmQLFjiIFzOhIgARIggaEnUNbYhbm78lX5i6kbc3Gquh2m5Qx9IJyRBEiABAaRAMWOQYTrh0N7vdhRlQlj2wRoi36KIyu/wJRVqbjv6zgcPdPgh7vBJZEACZDAEBMwNdhFsdDXPgYt6HoYu9+G01AISNbG5TSjC071cdil8arM1WWPczlz8xwSIAESOIcAxY5zYPAhCZAACZCA/xHo8FjYk12DcaEpeGHJUWxO7zEl97+VckUkQAIjnQDFjpF+BfRv/V4vdjSchnHgE2jz/hFJkZPxWfQR3DvrMFJOU+zo306zNwmQAAmcT0DKUDkiKO97F9riX8DY9Bzs03uv0EjcBRxLeS7BkYyOCxh+nB8Gn5EACZDAoBCg2DEoWDkoCZAACZCANxCQ7I2s0mZ8vikXjy9IQPCB0yht6ILD997esD2MgQRIYIAJUOwYYKB+Ppy3ix1uRw3M1CBoC36CjCXjMCNiK/4y4yCSC+v5JZqfX5tcHgmQwCASsG04LeUwE2dCD70WWuQfYOWuBTytgzgphyYBEiCBoSNAsWPoWHMmEiABEiCBISTgui5K6jsQdOA0RgUk4c0VWUg81QDdZO3YIdwGTkUCJDCEBCh2DCFsP5jK68UOoxN2/lbogT/DiaCHsCAsHH+dcQBJhQ1wecewH1yBXAIJkMBwEHA9zbDTQqAtvRHakp/DSguE21ZFI/Hh2AzOSQIkMCgEKHYMClYOSgIkQAIkMFwEug0bZU1dOHSyFov3F2J82FE8F5KCVUllqG7RhisszksCJEACg06AYsegI/arCbxd7IDrwqlIhBZ6HYoX/R5Lgr7BX7/ah4RTDXBcpmj61cXIxZAACQwNAb0d1qmd0Nc8BC34v2Dsnwy34QR6yk4NTQichQRIgAQGmwDFjsEmzPFJgARIgAQGnYBkcRiWjeYuAzkVrYhOLMWEiHQ8Oj8BTwUk4ptd+Siq62D5qkHfCU5AAiQwnAQodgwnfd+b2+vFDilWVZ8LffltqFp4I6IXfIC/frUXcfn1sBzH94AzYhIgARIYTgKWAac6G/q2CdAWXwNj42g4FcmA6RnOqDg3CZAACQw4AYodA46UA5IACZAACQwlAbm5s0u3UFjTjoi4EkyKysSj8+PxREAiZmzNw/6cGpxt6oZusXzVUO4L5yIBEhh6AhQ7hp65L8/oE2JHcxGMLc+iafFN2PjNC7j3y904fLIOpk2xw5evPcZOAiQwxAQkU64uH0b819BCfgljzSOw8tbD1ejTMcQ7welIgASGgADFjiGAzClIgARIgAR+SEBMwm338qtu94oceZVtWH+0AtM25+H5kBSMD0vFJxuysSalDFklTWjq1Fnu4of4eYQESMAPCVDsGLxNlQzC/rT+9u/P2APV1yfEjrZKGAenojvkJsTMuB/3Td+BgydqoVsUOwbqOuA4JEACfk7AdeB21sJKD4Ye8XtoEXfASg3p8elweDOYn+8+l0cCI5IAxY4Rue1cNAmQAAkMHwHbcVHTqiGnogVJhfVIL25SpacKazpQ1tiN2lYNLd0mPKYt5bov2DyGjdKGLhzJr8OcXfkYF5aKh+fGY8KyNATvP430oiaIdwf9Sy+IjwdJgAT8lADFjoHdWI/Hg8rKSqSkpODw4cPIzMxEVVUVLMu64ESapuHMmTPf9T927BiamppUf9u20dHRgby8PCQnJyM+Ph5JSUk4deoUWltbca440tDQoOaSPjK39NF1/bs5DcNQcaWnpyMuLk71qa6uhszfn+YTYkdXPczMCBjLbkXs9N/h0WnrcDCvCrpJsaM/e82+JEACI5SAfJjSO2EVbIWx7iF45v8jzANT4NQVjFAgXDYJkMBIIECxYyTsMtdIAiRAAl5AQESOdo+JM3UdWB5XjDeXZ6hyU88EJ+O15Rn4ZEMO5u0uQFRCKXYdr0JaUROK6zqV+NHcqaOt21Tn17drSC1qxMI9Bcp4/MG5RzBhaRoC9hYis7QZDR2a+hJEzEsvJpZ4AQ6GQAIkQAIDToBix8AhFfGhoKAAoaGheOaZZ/DQQw9hwoQJWL58Oerr688TJ2RWEUBOnz6Nr776SvX/29/+htdeew07d+5EY2MjRDgR0eKLL77A2LFj8cQTT+Dpp5/G1KlTceTIESVUyJwiiMg5L730Eh5//HGMHj1anVNYWPidmCGCy7Jly/Diiy/i4YcfxrPPPouIiAg1f38I+ITYobXBLtoPa9V9SJx2C8ZPC0Zcbgnkpgc2EiABEiCBSxDQ2uFUpkJf/3CPIfnGx+FUZcK1/i6gX2IEvkwCJEACPkeAYofPbRkDJgESIAHfIiCCg2W7KG/swrasSny8Phtjg5LxbHAKXl+egTdWZODl8HQ8E5yC0YFJGLs4GS+EpmBieBreXpGJT9ZnY/bOk1hyqAgrEkoxN6YAbyzPwNjFSRi/NBULdhfgYF4NSuo70aVLNshF0kF8CxujJQESIIF+E6DY0W9kFz1BsidWr16NcePGITIyErt378bs2bPxzjvvIDU1VYkX554sAsTmzZsxadIkLFmyBDExMVi4cCHee+89JCYmorOzE2VlZUrI2LFjh8oU6e0/Y8YMnD17Vo2ZkJCAefPmYdq0adi6dSvCwsLw+eefqxhKSkpgmqbKCnnzzTdVPxFGROh44YUXsGnTJjj9MO72BbFDjHOd+nzYm8cgc/qNmDJ9GpJzTimvrnP58zEJkAAJkMD3CDgW7PIkGDtehhZ0FYyNj8M+HUOfju9h4lMSIAH/I0Cxw//2lCsiARIgAa8i0NShI7GwHoF7C5Wocf83cZgUlYFlh4tw6GQ9DuTVYmtGJaLiS1WfmdtO4KO1x/F6ZIbK3BgVmISnApMwOigZowOT8eC8eCWKfLEpF5vSzqKorgOayTs8vWrTGQwJkMCwEKDYMTDYRTCoqalR4sZTTz2FoqIiNfD+/fvx7rvvYuXKlUqc6BUWRGQX4WDWrFmYOXMm8vPzVX8pfSUZHNHR0Whra0N7e7vK8ugtSdXS0oJPP/1UCSRS8qq5uRkBAQH48MMPIXNJNojMvXTpUkycOFGVv5JyVZJd8vbbb6sSVjKRZJQ8+eSTSlyRLJLeuC5FwxfEDlfqyWttsGJeRd6XVyNg+uvIzM5Gh+fCpcQutWa+TgIkQAIjhYBTdwJG7CfQFvwE+sp7YB2Pgmt0Af0QxUcKK66TBEjAvwhQ7PCv/eRqSIAESMArCEgJKSk7daq6HZvSKvBWdBaeCkjC+LCjmLHtBBJONaC+XYfluCrrQzI/TNtRd2pKmaqC6nYkn27EzmNVqqzVwr2FmLo5F++tOoZPN+RgZWIZ8qvalS8Hy1V5xZYzCBIgAS8gQLFjYDZBsidEfBDxQsSN2tpaNXB2djYWLVqkjh8/fvw7UUH8OLZv364EiI0bNypfDzlB+o8ZM0aVwpLSVyJCiDDSm4Eox6SslWR/5OTkKCFEHr/11lsqC0TG7erqUlklUhZLsktkTMkwEVHk5MmTKi4RQET8mDt3LnJzc1X2R19IpKWlqfJcUkbLq5vrQov9GKdm/RwbvnoSuceOos1jenXIDI4ESIAEho2AbcJtq4QZ9zW0yDuhhf0aVkY4nNayYQuJE5MACZDAUBKg2DGUtDkXCZAACfg5AceFEi3q2jXEnqjDl1vyMGZxMh6ZH48p67KxPfMszjZ1KVFD+l6oiXhh2I4SMsTjo7nTQF2bhqqWblQ0daGq2YPmLgOGRXPSC/HjMRIggZFLgGLHwOy9lLASc/Cvv/5aeXBItoQ0yaCQLItPPvlEZVn0ZlCIKLF27Vq88sorKiNDTMmliRghxxYvXqzEi16RQ16T7A4RVF5//XV8/PHHygdEsj+k/xtvvKGyPKSfnCNixJ133olt27apElri8yGlq4qLi9U8vaLJnDlzVFy9mSPqxXP+I/HKa1JSS7xBDh06BBFRvF7sANCZuBBFC25Fwow/IC/9IBo7WW/+nK3lQxIgAV8jIMK3Y0FK9UGyLSwNcCVT/SIfkPqxPhE6rMxw6JF3QQ//gxI9nMZCQOZjIwESIIERQIBixwjYZC6RBEiABIaKQIdm4VhZCwL2FeLFsFQ8PC8er0ZkICq+BFllLWjqMIYqFM5DAiRAAiOOAMWOgdlyEQRECBCxQ356xQ4RF8S/Y8qUKUhKSjovs0NKW4mp+MGDByHlqaRJOSsRMwIDA1U5ql5xRAQMEU7Ei+ODDz5QPh6STSIihIwhYoeUvOptIrz8/ve/Vx4eycnJSmyJiopSAor0EbFDjNFF7BDPDxFrLtSkNJdkh0yfPl3N+/zzz+O2225DbGzshbp71bGOzNWoCvsLzsz4dyQc2IjC6g6vio/BkAAJkEC/CDgWnKZiWHmbYB4Ngn1iM9zOuh4BpF8Dnd/Z9bTAOrEZWtTd0EJuhLH3AzgNpwHrwv9fOP9sPiMBEiAB/yBAscM/9pGrIAESIIFhI+A4Lrp1Gyer2rEl/SzES2NscDLGL0nFjK0nEHOsGjWtHpj2ld+pNGyL5MQkQAIk4AMEKHYMzCaJ8CCigpSx+uyzz9DQ0KAGLigoUCWppPSUlIDqFS8ks2PDhg147bXXlDG5iA/STpw4gfHjxyMoKAiVlZXflbASEURMzEXUWLdunfIHkf4idog4IubjdXV1qr/EIgLK3XffDTE2T09PV2KFnH/mzBk1j/SV7BApYyWvX0zskHWIj0hvKS6Z//bbb/cJscNz+gDa1j2Duhn/A2uWL8DhnHK1dr6zUBj4HxIgAV8gYBlwW8phlyUo/wzzwBRoq+6HFn4LjDUPwIyfCbssDk5XTzZhv5YkmSJ6J+wze2BseR5a4M+hb38FdskRQLyP2EiABEhgBBGg2DGCNptLJQESIIGBIqBKTZmO8uU429SN9JImzIspwLjQo3hwThzeWJ6BNSllKK7vhMewv6tPPlDzcxwSIAESIIEfEqDY8UMml3PEsiyIsCFZHSJgiFAhTQQO8csQsUBKVPWKHfJ77969+Oijj3BuxkVGRgZGjRqFZcuWqWwPEUVECJHnEyZMQHh4uCpF1VveSvw5xLD8nXfeUUKJZJhIVsnmzZuV0fmBAwdUXAsXLlRxSBksObe8vByvvvoq5s+frwQQif9CTeIUIaS7u1t5gUj5Kl8pY2XX5sI48BFaZvwDgme9hQ0HUqAZDuSGCzYSIAES8EoCrgM4JlytDW7bWdiVaTDTw6Bvfk75aGiBV0MLuQbakl9AC74KnkX/Bn3XRNgFu+B2NcC1dKll2KelifG4fTYVRsxEaEE/g776Idin9wBGd5/OZycSIAES8CcCFDv8aTe5FhIgARIYAgLylrtbt3C6tgMb0s7i8025GBOYiL/NOYyXlqQiJPY0jpe1KK8Ny6GvxhBsCacgARIgAUWAYsfAXQjinzFv3jw88sgjEDNyj8cDMR+fOHGiyrAQEULEAxEb5EeyOKRclRiMHz16VIkJYlouYoecJxkara2tCAsLU2KGCCklJSVKfOgVOzRNg3w4E8FDymKJMCICi8QhPiEibkhcMp6IJZLpIeWuRFR56KGHEBwcrOLsHe9SNFJTU33DoFyq2HtaYWUsRdvM/4H1X/wNqzesQXZFh3o/cql18nUSIAESGHoCLlzLA6f1LKy8DdB3TYC27FoogWPhf0Bf8WeYh6fDOXMATkUSrIww6FJ6KugX0Jb/UWV5uA2nAPvC4vV563FsOPUnYeyeAG3R/4Ee/SfYp2KUyALws9h5rPiEBEhgRBCg2DEitpmLJAESIIErJyClqiRT4+DJOoQfKVblql4OT8NzIUcxMTwDc3fmY2fWWZyu6YDHsPp6I9KVB8YRSIAESIAEFAGKHQN3IUh2xL59+/Duu+8q8UE8MeSx+F2IsCGeGyIWZGVlKbNv8emQElGSlSGeHtJPSkuJj0ZeXp4qUZWZmYmnnnpKmY2LX4ZkiYhAIvsmwodkXPSWuJo8ebIa48MPP1TjiNeGlKsSgUXEFxFE3n//fXz55Zeq1JZ4f4jPSF+FDiElooyIJL5gUA7XUXcpd4b+BpkzfoVVIVMRHleGxg4alQ/cVc+RSIAErpiAErRngkAAACAASURBVDjKYJ85AOtoAIxdr0JfeS+0pTdDi/wt9O0vwUycDTt/K5zaPEDvACwdbksZ7JObYcRMhh55O7Sw62HufR124S7l5dFjXn6B6BwHTkspzLjp0MJ+Bi3iJlgZIXA7awbE7PwCM/IQCZAACXg9AYodXr9FDJAESIAEho+AYTnqi4RTNR04fLIOYbFnMGlFFp4KSMITCxPwyrI0fL39JLZmVqGorqdk1fBFy5lJgARIYGQToNgxcPsvooEYeu/atUsJGOPGjVOiggggkk0hZaxEgBBz715DchEjxMD87bffhogZ06ZNU5kZkhUiGRkpKSkqM2TMmDHKm0NKZIlvRkBAAHJzc1VWhpS6kn5iXv7yyy9j0qRJKhtExpbXpMl8MTExSlR54YUXlAgjZbRqa2v7BcCnxA4ATk029O0TUb/gaqyZNRYfrEhBSW0bb67o166zMwmQwGAQkJJTbmsZ7OIDMFMWQt/8NLQlv4K26Cpo4b+FsWUcLDEiP5sKVwSOCzXHVqWujMOfQ1t6A7Sgn8DYPApW9iq4jYWAbX7vLBduWyWsY5HQlv4GWtg1MOOnwmkt73P5q+8NyKckQAIk4BcEKHb4xTZyESRAAiQwcARsx4Vm2mjtNnGysh0bUiswZV02ng5MwoPfHFFCx/trjmNlYhlyKlrR1GGg27Bh2T3lPAYuEo5EAiRAAiTQHwIUO/pD69J9RVwQoULKTzU3NyvBQkpNSXaFlKWSx73PZTQ5Lr4bvf1FFBGPDBFO5DXx4BChoqmpSf2WfvJcjMllvN4m/UQckdd6X+8VOnrnkXmlj8Ql48jzc/v0jvVjv31O7Givgpm9El2hv8a2qX/COwuiEZ9XjtbuPpR5+TEQfI0ESIAELpeA+HJoLbCrs1TpKT3yDmgLfwpt8U+gr7wD5qHpsIpi4bSdVQbirmX8eMaFiCbtVbAKtkNf/wS0gKughf0GRuxnsGuyAaMTkummmtYG63g09Ig7oIVcB/PwF3AbClWmyOUuh+eRAAmQgD8QoNjhD7vINZAACZDAABAQLw75Qqa8sRv7c2uxcO8pvLfqGJ4POYrRgUmYvCILgXsLsft4NbLLW1DV7FEiR99s8wYgQA5BAiRAAiTwowQodvwoHr74PQK+Jna4RreqS+9Z+WccnX4DFs7+CMt2p+FUdef3VsanJEACJDDIBERwsDQ4jWdgpS+BsXEM9LBfQV92C8ydE2FlhMIuPQCnsRCu1grX7cnM61NUjg23uxF28SGYsZ9Ci7gL2pLfQN84ClbuWpVBAjEkz98KY+PT0AJ/BmPvO3AqUr4VOvjprE+c2YkESMBvCVDs8Nut5cJIgARIoH8EDNtBVYsHqxJL8UZUJh6an4BnglPw/upjCNl/Bvtya1Fc36WyPvo3MnuTAAmQAAkMBQGKHUNB2X/m8DWxA3Dh6u3Qd72Cs/Ovwa6v/oKPwrbj4MkG/9kUroQESMAnCDitFbALtsDY+wa08N9BW3wtjDUPw0yeo0pRQWu78nU4Fpy6AlipwdDXPQJtwT/2GJsf+VKZnhsbRkML/TWMtY/BLjnck/Vx5bNyBBIgARLweQIUO3x+C7kAEiABErhyAo7r4mxTN1YnleHFJal4YmEiPlp3HKuTy5Bb0YouzYJpu5B+vFfoynlzBBIgARIYDAIUOwaDqv+O6XtiByB18a30peiOvAPZX/wEk2YFIyruNBo7DUgZTjYSIAESGDQCKuOiGU7NcWU+rq/6C7SF/xt6+G0w938Aq/gQXE/zt2WmBujfI/ns1d0E+8xumFufgx58LbTAX0APv1P5gehrH4N1YjNcT8ugLZsDkwAJkICvEaDY4Ws7xnhJgARIYBAINHYYiDlWjWeCUjA2KBmL9p5CaUMnmjp0ZnIMAm8OSQIkQAKDQYBix2BQ9d8xfVHsgBj4lqfA2DoOxVP/F2Z++SFmrTmM+MImvl/x30uVKyOB4SUgJagsD5zmYli561TpKH3pLdBCb4Kx5RnYeevhNhXBVX4aAyRynLti11GlsJz6E7AS50CPvhfaop9CX/EXWJnL4Hpagf6UyTp3bD4mARIgAT8kQLHDDzeVSyIBEiCBvhJwXag7IY+crMdb0Zn404xDmBdTgPyq1r4OwX4kQAIkQAJeQoBih5dshI+E4ZNih7rLuRFW3FQ0fPV/Y+usp/DBgigsji1Fe/ffTd59ZAsYJgmQgJcTEOlCxATrzD7li6Ev+zU88/5f6GsfgpUSAKcqs0dsGKJ1OK3lsE/tgpH4DeyCHXBby4doZk5DAiRAAr5DgGKH7+wVIyUBEiCBAScg5alSixrx+cYcPBWQiE835iC9uAm62Q8TvQGPigOSAAmQAAlcDgGKHZdDbeSe45Nih2yXY8HOWYHO0OuQO+c2fDD9K7y9Ogf5lW2q5ObI3VGunARIYMAIiLDqaYVTmQozbTH09U9BX3ILtIjfwogZD+vkRrhtlQM2XX8Gco0uOG1n4eqdzOjoDzj2JQESGDEEKHaMmK3mQkmABEjgfAKm5eJEZRs+35SLh+fH491VWcgsaUKHxjsjzyfFZyRAAiTgGwQodvjGPnlLlD4rdrgunPIkWDsmoGbe1fj684kYH3wYW9LL0dLF9zDecn0xDhLwSQKuA5jdcFvKYJ3aDTPmTWhLboQW+DOIIbiZsQySXQGj61tvjmFapcRJJ8Vhgs9pSYAEvJ0AxQ5v3yHGRwIkQAKDRKCyuRvzdxfg3q8P4+VlqdifU41O3Rqk2TgsCZAACZDAYBOg2DHYhP1rfJ8VO+DCba+CkxWB1kXXYctXj+Dtecvx1eYslDd2+9cmcTUkQAJDR8AFXEuDXZ0J88Cn0JbcCm3hf0CPvBPW0UA4lenKLBxKaBi6sDgTCZAACZBA/whQ7OgfL/YmARIgAZ8n4Lguyhu7sCKxBOPDUvHiklSsTipDdYsHrph4sJEACZAACfgkAYodPrltwxa074odAEwP3PJkdEX8ESfn3Y75sz/Fa2FHEF/QiG7D5v3Ow3ZVcWIS8EEC8vHH0uFUH4OZHgJj89PQltwMLeJOGLvfgp27Dm5zMVyTYqoP7i5DJgESGIEEKHaMwE3nkkmABEY2gYYOHZvSKpTI8WxICiLiilHW2AXLptAxsq8Mrp4ESMDXCVDs8PUdHNr4fVrskAIuLaXQt45HW+CNWD9jNMbN246wg8UobeiC3NjBRgIkQAKXJGBpcNvOwik+CDP2U2gRt0ML+Hfoq++BmTQPdk02YBqXHIYdSIAESIAEvIcAxQ7v2QtGQgIkQAKDSkA+9uuWg/15NZgUlaHKV83bXYCiug41L78WGFT8HJwESIAEBp0AxY5BR+xXE/i82NHdBPPoYuhhv8LhL36L1+dE4fXIVBzOr4dlSz17NhIgARK4CAExILc8cGpzVYkqPVJEjquUCbmx/yPYFclwtVbAFh8gfkq6CEUeJgESIAGvJECxwyu3hUGRAAmQwMATaPdYOF7WjM825GBUQCI+XJuNjJJmeEx74CfjiCRAAiRAAkNOgGLHkCP36Ql9XexQZWfKEmCsvB9nZv4MYQFfYvScGITHlaKhXffpvWHwJEACg0RAsr4sDU5zCcxj0TC2vwx92W3QQq+DsXMi7Jw1cOpPwtXbKXIM0hZwWBIgARIYbAIUOwabMMcnARIgAS8gYFgOcspbMGPrCTy5KBFvr8xCXEE9OnUKHV6wPQyBBEiABAaEAMWOAcE4YgbxebFDvopsr4S56zW0LbgKhxc/hyenrcZH608is7QZtuMDd2P7QIgj5g+CCx0RBJyuethFe2Ae+gha+O3QQn4JfeW9MOOmwylLgKv1ZLyPCBhcJAmQAAn4KQGKHX66sVwWCZAACZxL4ExdB0JiT+PuGQcxMTIdMcerlEeHL3wPcO46+JgESIAESODiBCh2XJwNX/khAX8QO6B3wDwaBDP8Fpxc8Ae8OSsMz4YcRXRCqTIq/+GqveCImKu3lsCpSIJTlQ63q94LgmIIJODHBKRkld4Jtz4fVtZy6BsegxbwL9BCroER8zqsUzt7SlY5vAnMj68CLo0ESGAEEaDYMYI2m0slARIYeQRMy0FLp47ww0V4LuQonlyYiM3pFahr00YeDK6YBEiABPycAMUOP9/gAV6eP4gdrqXDKjkMa+szOLvgl1geMgvjFuzB1A05qGzuhuV4iXeHlM5xLLhaG5zyJBiHPoYedQv09Y/APrULsK0B3l0ORwIkoAjI351kc5zerYQNfdmt0MJ+BX3DU7CPR8Opy+0ROlwv+beC20YCJEACJHDFBCh2XDFCDkACJEAC3kugqVPHmuQyPB9yFGMXJ2NFQinKG7sgn7nZSIAESIAE/IsAxQ7/2s/BXo0/iB1wHDidNbATZqJ10c+RF/Uq3luwChPCUnAgrwat3cZgY+zb+K4Dt7USVkY49A2joS36V2gz/i945vxPmHEz4HZUAy7vKu8bTPYigb4TcLsaYOUsh77qDngC/xnairtgxs+CXRoPt7sFoMjRd5jsSQIkQAI+QoBih49sFMMkARIggb4Q0Ewb1S0enKhsQ+KpekTFF2NsUDKeCUrBwt2ncLapG7rBO5f6wpJ9SIAESMDXCFDs8LUdG954/ULsEISODfvEBnjCb0PL0tuxYNFsPLM4HjO2n0RxXefwQpbyOV0NsEtiYcZNhRZ5B7Qlv4ax+j4YGx+FFvATGBuehF0UC1ie4Y2Vs5OAPxEQgbGzDlZ2FLTVd0ML+Efomx+DlbMCTkux+nfDn5bLtZAACZAACfydAMWOv7PgIxIgARLwKQKW7ap61K1dJmrbNJTUdSKtqBFrU8rUB/yJyzMwKiARD8+Nw7yYAmSV9Jh1MqvDp7aZwZIACZBAnwlQ7OgzKnYE4Ddih+gdZ9NgbHkO3QH/hC1BkzAx5ADGBKUgqbAeciPIkDcROYwuuE1FsHM3wNgyFlrQv0MLuwHG3rdgFx2EXRYHfe1f4Qm9HmbCbLjdjUMeJickAb8kYFtw26thnVgHfc2foQX+C4ytz6i/OVdvp9Dhl5vORZEACZDA3wlQ7Pg7Cz4iARIgAZ8i0NZtqAyOrRmVmL0zH69GpOPxBXF4YPZh/HXWYYxanIwp63OwMrEU+VVt0Ixh+LDvU0QZLAmQAAn4NgGKHb69f0MdvT+JHW5bJayU+dAW/QdORT6LwOjNuO/rg4iKL0V5U9dQo1X+HPbZVJh734cechO0gP+EvupeWDmr4TSeAmwDbkcNzMPT4Fn8XzA2joLTWAiwzOjQ7xVn9DsCTmcDzLy10MJ/CS3gn2FsfwF2VRqgD8O/BX5HlwsiARIgAe8nQLHD+/eIEZIACYxwAvK517BsZSqeW9GKA3m1SsCYH1OAj9cex4RlaXgu9CheWJqKt6Iz8c32k1geV4KYY1VIK2pCeWM3uih0jPCriMsnARIYCQQodoyEXR64NfqT2AFTh316D7Ql16M1/I/YsXIhHpkTiw/WZSOuoGHgoF1qJEuDU38SVmYojC2joC25Cfryu2EemAL71E4lcMA21Siu2QX79D7oUXdBD/8trNwNgNZ6qRn4OgmQwMUIOBacznpYx8Khr/kLtMB/g7nrZdglBwGjEzQtvBg4HicBEiAB/yJAscO/9pOrIQES8AMCtuuiU7eUuFFS34mcihbE5ddjXUoF5uwqwFvRWRgTnIxRgUl4NigZr0WkY9qWXITHFePgyTqcqe1Et2Yrvz2WrPKDC4JLIAESIIE+EqDY0UdQ7KYI+JXYAcCtPwFj3QMwl1yL1OVv4M1lh/F0UDKWx5dANx04g/mmSMrmdDfALktQ5sf68tuhBV0Ffc29MFOD4NSdUNke5116rgOntRzGrtehBd8AY89kOM1F53XhExIggT4SsC047VWw8tZAX3tvT+mqLWNhFx/61g+HaVN9JMluJEACJODzBCh2+PwWcgEkQAK+TkA+e4v/hmE56FYihwdZZc3YkFqBmTtOqsyNh+bG4S8zD+Gvsw7hsYUJmBSdhcX7TmN/bi1K6zvR0m2omtSGbcNxHN645OsXBeMnARIggcsgQLHjMqCN4FP8TuzoqIIZ/w3M0OtRsuQBRO+Ox6iFcfhiUy5O13ZCM53B2W3HBNqrYOeth77mEXgWXgVP4DUw9rwNKWXlam0X9QgQXw8rYwm0iNugR/4GTnnCRfsOTvAclQT8g4ArGR35m6CF3wgt4J+gbx4NpyYLrmR0sJEACZAACYwoAl4hdriuC8uyYJqm+rG//bLuQjshX+Kd21fOkf4yRl9bYWEhJk6ciP379/f1FPYjARIggQEjIP9ayd2Fpu2g3WOiuK4TcQX1WJtSgfm7T+HjdcfxekQ6ng9JwdjgZLy0LBUfrDkGKVu1LqUch/PrcLy8BZL10dihQ7ccOCzyPGD7w4FIgARIwFcJUOzw1Z0bnrj9TuzQ22EVH4ax6n40L/0Dcg+uxOvB+9R7qYD9hep9k7z3GpjmAq4Nt7sZdvFBmAfegx55C7TQ66Fvfg5WZgSc2hy4WjtUqu3FJrVNJYgYO1+FHnIdrLRguK0VkqdysTN4nARI4FwCjgW3qwFWdiT0NXdDC/xXGLsmwC6JhTIjdwfqb/7cSfmYBEiABEjAmwkMu9ghwkV9fT1iY2OxdOlShIeH48iRI6iurv4BN13XUVJSgj179iAyMlL9rF69GvJGvaOjQ4kePzjpAgcodlwACg+RAAkMGQGP4aCothP7cqsRFVeC2dtP4u3oLDwXclSVphoblKJKU32+IRuB+wqx/mg5jhTU4VR1O5q7DH4AHrKd4kQkQAIk4FsEKHb41n4Nd7T+JnZAvvTsqIGx6zVoS25G864PEbl1P8aHpeKJRYmIjC9BSX3HwGC3DTh1ebAyl8HYPFaJHOIXYu59C/bpGLhdTX2bx3XgelqUyKGFXA99y/OwS47QW6Bv9NhrpBNwXbgddbBylkNfc4/K6DC2Pwe7aD9c08PPTCP9+uD6SYAERiyBYRc7WltbsXXrVrz11lt44IEH8PDDD2Py5MmIiYlRWR7nZmy0tbXhwIED+Pjjj/HUU0999zN16lQkJyejs7NvKYoUO0bs9c6Fk8CwEpBsDsnEENPwwH2nlan4fbOP4MFv4jAqIBETlqZi2uY8rEgoRUJhA842dUGz7GGNmZOTAAmQAAn4DgGKHb6zV94Qqd+JHQLVdWCmzIcWfhu6lv8ZRVmxCIstxGPzEzA6MAlRCcWoaumGdbkZHrYJt7MOdnkCjAMfQgu7EZ6A/4S++kGYaSFwW8vRa0Detz3uyeCwi2Ohr7wHWsgNsNJDAUvr2+nsRQIjlYAIHZ11sE6uhxZ1K7RF/wRj81NwKtN6zMhHKheumwRIgARIAMMqdoiQUVRUhBdeeAGzZs1SgoW86f7ggw8wc+ZMlJWVQbI5eltXVxeOHTuG1NRUZGdnIz8/H9u3b8eUKVPwzjvvoKJCUn4v3Sh2XJoRe5AACQwcAdtx0W1YyltjVVIZ3lqRhacDkzB+aSqmb82DHIvPb8CpqnZUNHajoV1Hh2YpDw8WMRi4feBIJEACJODvBCh2+PsOD+z6/FLsgAvr9F7oG8fCs+in6Dq2BgXFFYiKL8VzISl4LiwFoQfPoLShE6bV1/I2rvLRcM1uOLW5sFKDoa+5H1roNdAjfgPj8DTYJYfVF6+wjcuqQOU0FMA8NBXawv+AuedtuE1F9O4Y2Mudo/kTAcniEtExbzX0VX/qKV214wXYZXHApUrH+RMHroUESIAESOCCBIZV7JBMjMTERDz66KOIiopSXhyapiE0NBSfffaZKlclmR+9TUpetbS0oLu7u/cQampqMH36dNx7770QEaMvjWJHXyixDwmQwEARaOwwcCS/HtO35GFUQBKeWJiIqZtyEXOsCvlV7ahr15W5+EDNx3FIgARIgARGJgGKHSNz3y931f4pdgBOSynMI19B++Z/wxIBoSoX5Y3diIgrVv4dj8yPR2jsGVQ0dfUZndvdCCt/C4ztE6CF3gRt8TUwtj4LOzcaTuMpwLzCTAytHfbpPdCCfg591X2wT279tgxPn0NkRxIYOQSk9FtOFPTo30Nb9P/BEKGj9DBg/v17opEDgyslARIgARL4PoFhFTtEqJDMjBdffBE7duxQsRmGgV27duGrr75CWFgY6urqvh/zec9FuJg2bRqefvpplSVy3osXeSLZJK+99hoNyi/Ch4dJgAQGhkCXbqGgqh3rksvx3qpjeGhePF5Zlobg/YXIKG1Gt24NzEQchQRIgARIgAQAUOzgZdAfAv4qdriWATtvHTyBP4e+9jHYBdtguUBpQxeWHirC04uTMDY4RYkfxfWdMOyL59GKwbiUxbGOBkJfdQ+0oJ9BX/4nmAc/h10aBxjy5erFz+/7frhwm87AWP8YtKW/hrnvXbhdjQM0dt+jYE8SGFIClga3oxZOQ6HywHFqsuFUZcE5mwanPBlOWTycksOwiw/APrMHduEO2Cc3wkqZD32VmJH/M4xtY2GXHgGMvouXQ7pGTkYCJEACJDDkBIZV7JCyU2vXrsWkSZO+Ex5E7Dh06BBmzJiB+fPnq8yNC1FxHAfi4bFmzRpVxmrhwoWora29UFfl/SEZIpWVlarU1eHDhzF+/Hjs27fvgv15kARIgAQul4DrArrpoKbVg5TTDZi5PR8vhKWqOtFT1mVjb041alo80C0H53oSXe58PI8ESIAESIAEeglQ7Oglwd99IeCvYoes3SlPhL7mEWhhN8NMmgNYBuRzZnFdO5bHFeH5kBQ8HZSEJYeKcKauA7p97vsyB1KySvw3rFM7Yex6Q42jBV0FfesoWCc2wG2t6PHVkDd+A9W6G2EmL4QWeTv0lXfBqcuFa4nJMhsJ+AkBF3BtA66nRf19OWUJsDIjYB76Asa+92HETIKxcyKMbRNgbB4HY+NYGOuegL7mYegr74Me9Sfo4bdBC7kOWsjPYWx9piejQ+8EBvJv0U9wcxkkQAIkMFIJDKvYIZ4cq1evVubksbGxag/kTeiRI0eU2DF37tyLih0dHR3Ku2PixIn4/PPPf+Dvce6GVldXY/369cr4/Mknn8R9992HO++8U5XJOrcfH5MACZDAlRJw5M7B+k5ExpXghdCj+POMg3g5PA3L44pxprYdnbo5IPf/XWmcPJ8ESIAESMD/CFDs8L89HcwV+bPY4TaehnlkJrSga2HsmAinuUTd+W1ZJiqburEquRxPBBzF/fOTMX9/Mc62Wfgu39Z14NTmwDz4KbTQG+GZ/2/Qo/4M62gAnNpsuHr7oGRcuKYGuzITxuZnoQVfDzMrCk7b2cG8BDg2CQw5AaetGnb+NiUi6st+B23ev8Dzzf+E55v/B565/w3agv8BLeDfoC3+eU/JuCW3Qo+4A/ryP0NfeX+P8LFhDMz4WbDPpgEidLCRAAmQAAmQwDkEhlXskDJWW7duxcsvv4ydO3eqsMSQPCYmRpWxEu+OC5WxEqEjISFBmZJ/+eWXOHjwoPL7uNhd0u3t7Th+/LhK7Y+Ojsbs2bOVT8jevXvPQcGHJEACJHD5BBzXVdkc+3Jr8PX2kxi/JBVjgpIxc1seYo5XobSxC/aPlEm4/Jl5JgmQAAmQAAn0EKDYwSuhPwT8WuzwtMAuPgh96W3Qgq+DvnU8zD2TYe57D92738WZNa9j6zfPYPm00TgQ9CJqdrwLz8EpMI98DPPg+zA2j4W+9GboS38NY89kWHkb4TaXAfZ3kkh/UPetr2PD1dpgxX0FLfhG6Fueh332aN/OZS8S8FYCjgO3sx52eRKsjECYuydCX/UAtLCboC//I/Qt42Ae/gJm0tewjs6GlTYXVkYQrKxlsLKjYOWsUdlUVv5WlWllnd4Lu/gwnIZTPaWrXMdbV864SIAESIAEhonAsIodIkJIFsdTTz2FVatWqdRiMR+PiIjA1KlTlZ+HGJL3NhEzTNNEWloa5s2bh3HjxqnyV2J0fqkmZa9s21Y/+fn5ePXVV78rnXWpc/k6CZAACVyMgGRMd2gmCmvasf5oOd6KzsJTAYl4NSIdwQdO40RlKzo0g5nVFwPI4yRAAiRAAgNGgGLHgKEcEQP5s9gBEQ7aq2HEvKY8MLSQG6F+gm9QWROexdehK/AatC38Oarm/CdOf/UTFM/6d9Qt+Cm6g/4LnuDrYKy6D1bCDDjVxwBj6Mrk2HnroUffCy3kBli5a+Ba+qBkkoyIi5yLHB4Ckuqut8NtLkFPqapwGDtfhxZ+K7TQa6FH3gFjy7MwUxbBrjgKt7sFsE3Asc75sSF/x9/9uLbUwAJE3FA/A1hCbngocVYSIAESIIFBIjCsYoes6dSpU/jb3/6Gb775RvlpiK/GBx98gI8//hhnzpyBiB+WZUHECilxJb4cUrZq9OjR2L17t/Lh0DRNvXaxzI7vsxNTcyl/tX///u+/xOckQAIk0C8C4s9xrKwFM7edwP3fHMH9s4/gkw05OJxfh3aPCdtxWbaqX0TZmQRIgARI4HIJUOy4XHIj8zy/FjtkS20TTmU6rJy1MJMDYSYthJkwF2b816rElXHoS7Tt/hS50ZOx/uvnsfrLMUgOfgGNWyZDi5utDJJds6vny9chfDdn12TDiP0Enrn/CPPwdLgtpfQjGJl/or63ahEhRLDQWmBXpMCMmwkt8g545kiZqv8BbemtMPd/APvMPrgdNYCp9YgZ9Nvwvb1mxCRAAiTgxQSGXexobGzE8uXLlcAhAsQbb7yhylNt3rxZ+XUkJydDyk0VFBQooUMMyR955BHcfPPNePHFF/Huu+/i/fffx+LFiy9Y8upC7Cl2XIgKj5EACfSXgGbaOHG2VZWtkmyOiZHpWJlQguPlLWjq0OHIXU1sJEACJEACJDBEBCh2DCxouZFKbriSG696f+T5xZr0l0zy3r7y+Ps3Y/WOJ9nq0u9ir/eOce7v3r7yW473jiGPLzTXxeLsPe73gHBDhQAAIABJREFUYofrqLJQbkcVnOZS5dvhNBWh5+c0nMZTsOoKUFt0HEcS4/F5yDq8NT8aAdFbUHjiODztTcOSUeF2N8PKWwct4F+hb3gcdsGObwWX3p3jbxLwBgLiNq4cxwFlOt6qsqCsY8th7p4MY9X90Jb8EtqyW2Fseb4ni+P0Hjh1J+B2NQGO6Q2LYAwkQAIkQAJ+SGDYxQ7x6BCj8g0bNiifjlmzZkGEDjkm5anEayMuLg5FRUUQYUSEjwULFmDatGmYM2eO+vn6668hC5HX+9IodvSFEvuQAAn8GAHLcVFS34nF+05jVEASJixLw+a0s6hs7ob4d7CRAAmQAAmQwFAToNgxsMSl5G5eXh7kZqulS5cqr0EphyvZ5hdq4isoN2r19t+xY4fKXO/t7/F4kJqairVr10K8CeXzT0VFxXdDiWiRnZ2tPgvJZ5uoqCh1U5iU+N24ceN3fUtLS7F69WosWbJE9ZHH4nkox/vT/F7s6CMM3QYqmjSEx5XipWUZeGxhIoJji5Bd3grNsPs4ykB2c+BUZ0JfdQ+0ZbfAPDL9W2+CgZyDY5HAlRFwReBor4R9NlWJc2biTBjbX1E+HFrwL6BF/AHG1mdgJs2BXXQQbntNTxbHlU3Ls0mABEiABEjgkgSGXey4ZISD0IFixyBA5ZAkMMII1LR5sPZoGR6ZH4+xwSnKr6NDG0TTyhHGl8slARIgARLoPwGKHf1ndrEzJHtCbrqaPXs2Hn74YfzpT39SPoMBAQGorq7+QUaGZFmcOHFCZZw/9NBDuOuuu/Dss88q4UP6SxMvwoULF6os9WuvvRZ33HEHDhw48F0IUpp33bp1eOWVV/Doo4+qeaXPDTfcgPvuu095HUpmyK5du3Drrbfipptugsw1atQoNW9CQsJ3Y/XlAcWOv1OSZNy6dg3RCaV4KiABD82Lx+yd+cgsbUZbt/mD/f77mYPzyG2rhJk4H9qSm2FseBxO4xlAeXcMznwclQQuSUBu5jK64HY1wGkphl0WBys9BPq2F5UvjmfOf4dn3j9BD70e+qYnYR2LUp4dyl/jkoOzAwmQAAmQAAkMHAGKHQPHkiORAAmMAAKStdHmMbAprQIvLUvD04FJiIovQXlTF6wfKW0xAtBwiSRAAiRAAsNMgGLHwG2AZGGEh4djzJgx2L59uxI+QkJCMHnyZJV1LhnovU2EkZKSEqxatQpvv/02Nm3ahGPHjqnzX3vtNeUTKGWmRMyQzA8Zb+7cuUqoOFfskHGamprUWHJzlngbSvbGSy+9hC+//FKJKZL9sW/fPjz++OMIDAxUpX7F57C8vBySWdKfRrHjXFouTNtBaUMntqSfxcTIDIwOTMR7q7KwLbMSVc3d6vWhSt51jU44FanQ1z4Cfdlv1RfH6Kw9N2A+JoHBJSCfa2wdrggcnmY4TadhF2yHGT8L+ubR0Jb/DnrYr6CFXgMt6g8wdr4C82gg7KIDcBoL4XbVw7W0YSkFN7hgODoJkAAJkIC3E6DY4e07xPhIgAS8ikC3biE2rxaTV2TikfkJWLC7AAXV7cqI3KsCZTAkQAIkQAIjjgDFjoHZcsmeEPFAyus+99xzqryujCyldT/99FMsW7YMxcXFys9DjotIIa9Jmd1FixZBxAdpSUlJSpQQf0IRR2Tc1tZWVFVVKcHjiSeeOC+zQ530vf/IuZIhImWq6uvrVQmt/fv3q7ikvO+VNIodP6QnZUob2jXsz63BlHXZeGRePMaHHUXIgdM4NZTv98To2dMCc+970IJ+AWPrs3AbCn4YMI+QwCARcPWOHg+O7DUwYj+Evu5h6MtugyfwJ/AEXQV95Z9h7H4TVupC2Ke2wq4+Bre9GjD1QYqIw5IACZAACZBA3whQ7OgbJ/YiARIgAXTpFo6XteDDtdl4OjAZU9YeV2bk3cNSz5kbQgIkQAIkQALnE6DYcT6Py30mJakyMjKU2PHRRx8pkUHGkjJVwcHBKstCXhfxQppkbYjn4KRJk5SIUVdXp46L38czzzyjzqmt/ftd+W1tbdi5cyd+TOzoFUa++uor1U+yPMT7Q/wO9+zZgwceeAAff/yx8jMUUUUEFMkc6U9LT09XpbKOHDnSn9NGRF+PaSP5dANmbT+BMYuTlD/bnJ35SCtq+ras1RBgcGzYx6KgLb8TetiNsM/sZSmrIcA+oqdwXbhaK5yqdFhZ4TB2vQ59xV3wBF0NLeAq6BG3w9jwIMyDH8DK2wCn/gRgekY0Mi6eBEiABEjA+whQ7PC+PWFEJEAC3kbABUzbRU5FKwL2nsKTC5Pw4Zrj6q6/Ts3CUJU08DYsjIcESIAESMC7CFDsGJj9EEFBMjW+/vprzJgxAw0NDWpgydiQrA4RGaQc1blih5iSv/zyy6pklZSikiZm5q+++qoqNyVlrnr7S3aHmJf/mNjRa2YumSRSGktikAwSiU3ECfHpEC8RmfPdd99VRuUiiEifizURS5qbm3H27FllZr5t2zblBXL48OGLnTJij4uHh2baOF3bjhUJpXg1PB2PLUjAlHU52J9Xg6qWbmhmj9g1aJBcB05VJoyYN6AF/BRmwjdwWsoGbToOPEIJyL8ZrgPXaFflp6yTW2BsfxHastugh9wIbfktMLaOhZk0H/bpvXCbTgPdTYDRqcpc0ZNjhF43XDYJkAAJeDEBih1evDkMjQRIwDsIyI2btW0aIo4U47F58Xgu5Ci2ZlSiS4QO7wiRUZAACZAACZAAKHYMzEUggsKhQ4eU2CGCR2NjoxpYSldFRERgypQpqkRVr3ghmR0rV65U3hoHDx5UgoKcIGLH66+/rsSOoqKifokdYmYeFhaGzz77TM3Z6xEic4nwkZWVhezsbJWBEh0drUzPJTbJ7riY4FFRUQHpO378eFVe65577sGvf/3rS5bSGhiqvjmK7biob9dw+GQd3l11DPfNPowxgUnqPeGZur/7tgza6vR22BnB0Bf9K4z1T8AuZRbOoLEeyQObGuziw9B3vQlt8TXQ5v4v6Cv+1OPBUR4Pt6UYblcjszhG8jXCtZMACZCADxGg2OFDm8VQSYAEhp6AGJI3duhYm1KGV8PT8FRAEqKTSlHe0DX0wXBGEiABEiABEvgRAhQ7fgROP16SMlbiZyGeHZ988sl3ZaxOnjwJMSmfPn26EhnOFTvElPyNN95QGRvirSFNyliNGzdOlbGqrq7+ToToS2aHlKWSrA3xARGzcxFgpImQIYKH/EiT3zk5OXj00UcxZ84cyDy9r6kO5/xHBJS0tDRlpC4ZKpI1cscddyA2NvacXnz4fQIuXLR2G0gqbMDsnfl4enEyxoWmYF5MPhJPNaBDMwcvy1dKWRXHQl99P7Slt8LMCFOG0YM34fdXz+d+TUBrh1MaDzNhJvS190MLuwla5B9h7nsXVv5GuC3lgGP6NQIujgRIgARIwP8IUOzwvz3likiABAaQQFOngYMnajExMh1jg1Iwd1cBSuu7YNqDXLpgANfAoUiABEiABEYGAYodA7PPIhZIJsbs2bNVtkZZWZkSGRISEpTQERoaisLCwu8yNUT0kEyQzz//HPJar0F5SkqKKjcVGRkJ8enobZcSO0TYkKwNKVM1b948ZWp+rrAiYkzvc/ktsYwdOxZz586FZG9YltU71Xm/e4USeV3GSExMxIMPPqjKYp3XkU9+QEDKWhmWg5OVrQiJLcKEZWl4LjgFH6/LRmxeDSqbumHY9nkZv8LbcVzYjqPeN+qWDfEC6dZtdGgW2j2Wemx96/3yg0nlgIzRXAIzfja00F/CiHkTTn0+YPML6Avy4sE+EHDgelqV34aVtw7GrtegLbkJWsgvYGweDSsjHE7jKcDyqPJWfRiQXUiABEiABEjAqwhQ7PCq7WAwJEAC3kRASthmljbjzRWZuHvGIXy55QSK6jphUOjwpm1iLCRAAiRAAt8SoNgxcJeCeGYsWLAA999/P1JTU9HR0aFKVUkJqH379inxQkQRERvkS20RHKTslGR3iN+HCBobNmzA008/DfHG6M22kP7i6bF161Y89thjymBcXpMxeltNTY0qSTZmzBisXr2697D63d3dDcnQkPhEtJC4RLS4++67lTAiosq5Y5138veeyLoeeughih3f4/JjT2Wb2jwmdmdX460VmbhreixGBSZhTXI56to0JWpI6SsROAzLRrdhobVbR32bB5XNXShu6EBBdTtyK1pxvLwFp2ra0dShK284EUYko1hZKJwbhGPCKUtQ5tB6xO9hZa8C9PZze/AxCfSRgKt8NpzyRBi734Rnwb/AM/f/QIv4A8yURXAbCwHbEJWtj+OxGwmQAAmQAAl4HwGKHd63J4yIBEjACwhYtovjZS2Yue0kHl+QgE835CC+oB5duqU+iHpBiAyBBEiABEiABM4jQLHjPBxX9ESEBBERJFtDfDcmTpyofqRUlGR9nDhxQpV/io+PV8KGeGqIePD++++rfq+88gomT56sBBDJ9BABQoQJEUA+/PBDPPDAA7j66quV14aIKnJuV1dPiUzJ6hCvEJlbskl6m4xRW1uLXbt24YsvvlDG5GJO/s4776jn0lcyNvoqdkipLoodvXT7/tuxxcdDR8KpBizYU/BtWauj+GD1MUzblIepG3Pwybrj+GjNMby/6hjeW5mFd6Iz8VZUJiYtz8Aby9PxWkQ6Joan4c3IDLy38hi+3HwCQQdOY93RChw8WYecs62obvGo951KPGksgr7jFXiCroax8yU4DfmAY6nMj75Hzp4ji4AYj/eYjysDck8r7PJkmEdmwFj7MPTQG6BF3g7z0LQe4/GWMsDsptAxsi4SrpYESIAE/JIAxQ6/3FYuigRI4EoIWI6rMjgW7yvEM0FJeC0yHXtzaiAlrc658fJKpuC5JEACJEACJDDgBCh2DBxSEQzEmFwEj4ULF6ryVZK5IQKBiBJiVp6cnKw8MNrbe+6yl4yNnTt3qv7itSG+GGJSLlkY0uS83bt3q4wR8QIRYUR8M8LDw1XZqt5+paWlKhvk8OHDEO+O3iYxyRwSU1BQkPIUkVJb4iMicfUaqff2v9Rvih2XIvTjr3dqJk5UtSHs4BlMisrEmMVJeCY4Bc8EJ2NsUDKeDUnG8yFHMT7sKCYsTcWr4el4PSIdby7PwFsrsvB2dBZej8zAuNBUjAlKwTMhKXhhSSreis7EtM25CNxbiJUJJdh5rAZxx88gL2YRGhZfDyP0v2Ae+gT2qRi4zSUsafXj2zQyX7VNuN0tcFvK4NTkwhZfjoxQ6NtfgBZyPbTw22FsHQc7cwns+hNwLW1kcuKqSYAESIAE/JIAxQ6/3FYuigRI4HIJiJghhuQrk0p7PrQGJWPd0XI0dPQYg17uuDyPBEiABEiABAabAMWOwSbsX+NT7BiY/RSD8sMn6xB6sAghB4sQfqQY0YmlWHu0HJvTK7HjWDX25dTg0Mk6lQ2SWtyErNIWlUGcUNiATemVWLC3EO+tPq7eez74TRz+MuMQ/jg9Fnd9dRB/mxuPl5am4JuorTi4cDTOTvsHtM36B+hR98BOWQinOgtudyNFj4HZTt8ZxbHgmh64ejtcTzPczlq4bRVwmwrhnE2Flb8VZupiGHs/gLZhFLTAn8LzzX+HFvoLmAlfw6nL9521MlISIAESIAES6AcBih39gMWuJEAC/k1A6iQ3derYfbxa3Wn39OJkBO8/g9KGTvyoeaR/Y+HqSIAESIAEfIQAxQ4f2SgvCZNix5VvhNwkI+8R27oN1LZp6ke8O6TMldwoI1nBzV0GWrsMtHWbaPf0/HRqFjp1MSk30dRhoLpFQ1ljFwpr25Fe1Izdx6oReaQEs3fm47012T2G6AGxGDcjCrNnTkHSwsfQsOgGdAdfC331/TDjZsAuS4TbVQ9YOuDaV744juBdBGRPLQ1ud7MyrbcrUmEV7ICZuVTtv7l7EowNj0Jf8Xvo4b+DvuQW6KG/ghZyA7Swa6Cv/CvMQ5/DLjsCt7UMripZJUukP4d3bTSjIQESIAESuFICFDuulCDPJwES8BsC8oEzoaBBlRZ4bGEiZmw7gZOVbcps0m8WyYWQAAmQAAn4LQGKHX67tYOyMIodg4L1igcV3zgRRiqbPSioakd6cbPKHNmcVoFpm/Pw4qI9+HBOKHZHTkPlilHQw34FLeBq6Kv+CvPIZ7BL4uBqrVccBwfwMgLdTbCKY2Ee+RLGxtHQo/8KbdnvoIVcBy3gp0rU8Cz5DbTIO6GvfRzGjldgHvwUVspC2McjYJ/ZA6dBDMhNL1sYwyEBEiABEiCBgSVAsWNgeXI0EiABHyQgd+XJ3XWJp+rx+YZc/G1OHD5cexxHixohppBsJEACJEACJOALBCh2+MIueU+MFDu8Zy/6EokLF3mV7fh6ZyEeX5SMyZEp2LVjM2pjpkJf8RfoUqYo6GfQN46FlREM52wK3M56mpj3Ba639pFSVR01cMqTYKYGQV//BLTF18Cz4CdK3NAjfg995V9URoexZxLMhDkwj6+CfWY/nJpsuO3VgGV46+oYFwmQAAmQAAkMCgGKHYOClYOSAAn4CgERM+TuuaTTjfhiUy4emR+P91YdQ1x+nRJAXMdXVsI4SYAESIAERjoBih0j/Qro3/opdvSP13D3lnKrhuXgeHkLZm4/iUfnHsEHK1KwJ+kYms+kQIufA33d4z0G1Euvh7F5NKyMpbCrMuC2V6oSV+Lt4Xpa/3/23ju6iivd9v37jjvGe/e8N864p+853X3a3e3c7bbdDm23Uzti04AxtjFgY4MxNu0cMM4BjMmSUJZQAGWBhIRAICGUc8455xy3duWad3yrJIxtsIURKH17jEJi79pVq36rqrT3muubU+Q8QLEBlPlAYdYGfeCd6gQfE6APyIYOU9dg6gpMss4iiyWD7LOmup2ZJjpL9092VYpNCBV6awbUTEfIIcshud0E2eUaKMFLoSZthVZ2BHpLGozeKiGIiNwW+yBMeRSmarPszHTN6qtZeqjcLCbABJgAE2ACl4MAix2XgypvkwkwgTlDgDyTKSTyzYP5eGJXMl71yUVGdS+G7dqcOQZuKBNgAkyACTABIsBiB58HF0OAxY6LoTV71pU1HcUtQ3g3sBCL96Tidb88ZNV0Y6i3DejIhZbjCjngcUg0+3/vryD73Qn15LtQMxyhFvhBK4+EXn8Gels+jL5amKPdMFXp4g6QyqJJKKHB9ZFOmIPNMPrrYSpjF7cdXvvHBFQJRns+1MRtkH3vhbTz3yHt+Q/IIU9Bz/eG0VloiRvyGKBz1caPAfIzTIAJMAEmsNAJsNix0M8APn4msEAJ0Jwzm6whpaoXn4aVCKHj3cACxJV2irDIBYqFD5sJMAEmwATmMAEWO+Zw581A01nsmAHo07TLcbJfre7F5uAiLNubgg9DipFa248xu2xVBFSfgHrmS8iBj0NyvQaS6/WQKM/B62+QfB+AHPAElNAVUCJegHLsFSixb0M7vQVa8mfQMnZBy3GBlusGLWu/9f+0r6AlfwIt8RNrvVMfQDn5FpTjm6BEvQLl6EtQIl+EEv8utAIvGB2FosJgmg53/m/GNGCOdUNvSISatkNkckguf4Lk/hcoIU9CTd0GvS4OsPXOfxZ8hEyACTABJsAELpEAix2XCJDfzgSYwNwjYExYV6VX9+KriFJhXfXWoQKcLO7AqKRCVPLPvcPiFjMBJsAEmMACJ8BixwI/AS7y8FnsuEhgs2h1srSSNQNxZZ14L7AQi3Yk4puj5ciq7cO4okLXZJijHdBrT0JJ+gLK0dWQQ5cK8UM++Ahkv39A9rkHstffIHv8FZLrX0QGhOR2HSSv2yD53APJ5z5IB+62/u95IyT3qyG5XgfJ5UZILn+G5HYzJPdbIXveBtnrdsiet0NyvRqS/z2WeFISAKM9G8Zoh6gCAVWDzMeHYcAk26nRLhiDTTAGG2AMNlq/D7XAGGqFMdwGg6zERtutqozRLiFuGOI9jTCaU4W4JB9eA8nrdkhuf4Ic+BjUpK9hNCbDHO8HdJktqebj+cPHxASYABNgAtNOgMWOaUfKG2QCTGC2E7ApOkpah8WXw0e/TcRa9yyk1fZhRFJne9O5fUyACTABJsAELkiAxY4LouEXzkOAxY7zQJljT43JGpKrerHKOQOP70zEF4dL0dhrg6RNhM4ZmsjSANlLySOiMsCkwfiOfGFlpZVHQM0/ADV1N9T4j6Ec2wT58CrIgUtE9YccvBxy+GooEeuhxGyCEvselNOfQk3eBjVtH9RsN2hkjVUcBK3oEJSo9aCKBPvW/wH7nv8fUsgyEZhNg/8iKHsmBA/aJ2WMiGUaBJfJ7dHsKMrEkMegd1dALYuAmuFksUzdY/2e5QY1xwNqnjfUAl9oRQHQSkKglYZDq4gUP5WUXZAPPQL7zv8F+7b/AcnvAajpe6wsDmlYZKPMsdOSm8sEmAATYAJMYEYJsNgxo/h550yACVxpAuOKjozaPnwUWoylu5OF4BFf2oW+MRkUVs4PJsAEmAATYAJzlQCLHXO152am3Sx2zAz36dyrbproGZZwsrgT//LNw1P7UrHtaDnKWoeh6BOCx7k7pAF/ChSnSgQKKh/rgTncCmOgAUZfFYzuEpEXYbRmwmjJgNGWY/2/oxBGdymMngoYfdUwBupgDDTCGGqBOTJRrTDSAaOrCHpFBNSkryAHLoLkZlWAyGHLhT2T3pwGk6yYLioQ/dwD+LnfSdiYWAwNpjwGk9rZWQijqxTGYAsgjVgixbkCiBBh6HvA+b4LTG7TgCmNimwSvSEBGolEpz+EcmQ55EMPQ/a8E5LrTULsEZUv9DtVzFAFjNstVhWMx22QPagK5g5RVSN53gFp//XidTnsGWiZDtDr40V/iBwV0a6fO2Z+nQkwASbABJgAEziXAIsd59Lg35kAE5i3BOi7As1+o/L+rZGWddUb/vmIKWjH8LjCQse87Xk+MCbABJjAwiHAYsfC6evpOFIWO6aD4sxvQ9cNDNoUhGU24xXvHCzenQznuBpUd46CrFuv9Hi5qdpg9NdCKw2FErcFEoWlu/9F2DMpR9ZAy9gDozYO5mATcLHB6BfAbZJtl60XRl8NjJZMaNUx0Ir8oKbvhhq3GeqxV6Ee/xfU+C3QUrdDy9kPrdgXesUR0RYh7HQWw+ivE3ZUpjwsMkfMsS4Y3WXQ6xOglQRAy9gN9dT7UA6vhOz/D0geZOV1IyS/+yCHrYAatR5qzKtQjr0KJfoVKFEbRLWLcnSdlWkSuRZKxPMgDkr4KmuJWAMt8UvRZnOs07KrusBx8tNMgAkwASbABJjAzxNgsePnGfEaTIAJzAMCdrKuahnGF0dK8di3iXjBLROnS7s4jHwe9C0fAhNgAkyACVgEWOzgM+FiCLDYcTG0Zv+6vaMKQjJasHh3EpbtTYV3Uh26hu0zOqGHKiH05gwocR9Ccr8Z9u3/D6Q9/wn50OPQsl1gtGZ/VxkyRjkWPTBtfTDtAzClIZhk4ySPAYoNUMctSy5NEs+JdUY7YQ7WiwoUrSwcSsp2yEdfguR7HySH38O+/X/Bvv3fYN/577Dv+HfYv/3/YP/mf0La8f9CcvytlTUS8ARkCmqP3QwlbQ/U4gCRdSIEjuIgKPEfQw5eCsn595B2/hvs3/4bpF2/gux6HeSgx6EkfAatJAxGdzkgjwK6AVPXYaoyTGXcEk3sgzDH+2CMdcOgCpihtrP5HpT1ATomfjABJsAEmAATYALTQoDFjmnByBthAkxgthKg2Wzjiob8hgF8frgUS3an4A3/PMSVdKJvVIamn69cfbYeDbeLCTABJsAEmMCFCbDYcWE2/MqPCbDY8WMmc/kZsq1q6rMhOKMJL7pnYqVzOjzO1KF1YBwUaD4jD2ElNQpzsBF6czq0TCfI4c9CcrkGsusNkP0eEBkhSvQGKCfehHLqAygJn0JN2iZyK9QsN2j5vtBKgqBVRECrPg6t+gS0woMiN4TeJwc8CMn7VshkFUXh6a5/hHzgDiihT0M5/ibUtN3QCv2gFfiIbSrxH0GJfhVy2EpIhxZB8qZg9WsgOV8vgtdlt5she9wqgtvpd8nlOkju1wmrKqrYoO3pFZEgqy+zrwrmSKsl0CjjAGWkkBWWsMjSrbwNyvWgxVBgkoUYLVSJokliIVsxsf6MdBDvlAkwASbABJjA/CPAYsf861M+IibABM4hYFc0FDYPiIqOJbuTsdEnFzGFHRiwKVe8rP+cZvGvTIAJMAEmwASmnQCLHdOOdF5vkMWO+de9qm6itX8cXmfq8bRjGp7dnw7/1EYxwWfGj5aEj+E2iLyLbEdRTSH5PgBJ5FjcBsn9Fkhuf4Lkei2k/VdDcr7Wyr9wuwWy5+2QD9wN2ec+yD73CyFCcr4BkuufIXndBingUWEXpZ75DFqOI/SyYBj1CTAoa2SwSVhcmbYeGIPNMLorYLTlQm9MhF4dA700AFqeG7SMvVDPfA7l+BtQjjwPJXylsKLSkr+EXuABveYYjPZciLB1eRTmTAlIM96R3AAmwASYABNgArObAIsds7t/uHVMgAn8QgIUNk7+xdl1fdgeVY5FO5OwzjMbUfntGBpXf+FW+W1MgAkwASbABGYvARY7Zm/fzMaWsdgxG3vl0ttkmEBd1yj2xFRi6e4UvOCWhSO5regYsoMCzWfFQ1eht+ZAy/eBmvgl1PgPocS+DiX6RSgRKyCHLhYB5/KhRyH7P2iJHN53Q/a6AxIJHz73Qg5ZJqpB1AxHaJVR0DsLRYXFLz4+w4A53g+jtwZ6Sxb0xhQRag778C/eJL+RCTABJsAEmAATuPIEWOy48sx5j0yACUwjAZpVpWiGCB8fGFPQNSShoWcMhU0DiMxtw4chRVi6JwWv+eTiWGE7+sbYumoa8fOmmAATYAJMYBYRYLFjFnXGHGgKix1zoJN+YRMpq66sdQiOsdVY5ZyO592ycCCpAdUdIxiXNREVPf/xAAAgAElEQVRc/gs3PT1vI5sn1Q5THrHyOez9ItOCqi9MWzcoGNwc7YA51AKjv0aIDlSNYTSlQm9MhtFZBGOY7KN6rWwPZczKvSAbqV8q6FCb6P2aLNpG7YMuf2dNNT1HzlthAkyACTABJsAELjMBFjsuM2DePBNgApeXAAkdbf12pFb3ISC9Gd9EV+B1vzysdEzDkl3JeGjbGbzokYXY4g70jkrkossPJsAEmAATYALzkgCLHfOyWy/bQbHYcdnQzooN02fkirZhOJ2sxuJdSSA71y8jypDfOIgRaY5VORsGoKtCiKCsC5j6rGDMjWACTIAJMAEmwARmHwEWO2Zfn3CLmAATuAAB+tLWOWRHSeswEsq7EZbZAte4GnwZXoJ/+eThOecMPOWUhpX7M7DOI1tUddCMtlMURj4mw6S6fn4wASbABJgAE5inBFjsmKcde5kOi8WOywR2Fm1WUg1UtA/DJ6kO6z2zsGxvKt4LKERETqsIM59FTeWmMAEmwASYABNgAkxgWgiw2DEtGHkjTIAJTBcBE5Yt1fC4KoSN+h4bytqGkVXXh1NFnfBNbsC2qHK8cbAAL7pn4VmndKx2zsAGr2y8fagA26Iq4JPcgNjiTpS0DKF7WIKsGaAMD34wASbABJgAE5jPBFjsmM+9O/3HxmLH9DOdbVukT780WahnREJUfhs+CCoU9q6bfPPglViP8vZhDI8rMH6p9dNsO2BuDxNgAkyACTABJrDgCbDYseBPAQbABGaQgAnx5YqECFpU3YBN1tA2MI7Mun6EZLVgx/EqvO6fjxWOqXhoawL+8TUtp7F4ZzI2+ubi22OVCM1uRV7DALqGJYzaNZBPMX2xY4FjBvuWd80EmAATYAJXnACLHVcc+ZzeIYsdc7r7Lrrx9Pm4qHkIW49W4Kl9aXhiZxLeDy5Cdl2f+Px90RvkNzABJsAEmAATYAJMYBYSYLFjFnYKN4kJLAQCmm5g0KagqnMUyZXdCMtqwf5TNfj8cCne9M/HOvcsrNyfjuX7UrHKJQOv+uTho9Bi7D9VjcPZLUiq6EFh0yDqukbRNWzHmKSBizcWwpnDx8gEmAATYAIXIsBix4XI8PPnI8Bix/mozOfnTCFq1HSOIjC9CW/65WPRjkTxuTssuwWt/eNi4tF8JsDHxgSYABNgAkyACcx/Aix2zP8+5iNkArOKwLiio6ZrBCeLOnAgsR7bo8uFd/AG7xysccvCatdMrPPMxlv+efg8vAR7Yirhl9KImMJ2YWVV1z2GISq3Z2VjVvUrN4YJMAEmwARmngCLHTPfB3OpBSx2zKXemt62tg7YcLywHR+FFonJRWQH63G6DrkNA1zlMb2oeWtMgAkwASbABJjAFSbAYscVBs67YwILmYCs6ihvG4ZzXC2edUrDfV/F4+FtCXhiRyJWOWfg7cAC7DtZjYjcNuQ3DqB7yA5d56yNhXzO8LEzASbABJjA1Amw2DF1VrwmwGLHwj4LFNUAVXl8E1WOxbuSsOjbJHxxpExYww7bVejGwubDR88EmAATYAJMgAnMTQIsdszNfuNWM4E5RUDTTYxKGhLKuvFJWAmW7UnFix5Z2Hq0HBG5rcio6UNVxwha+mwid2PApohZZZS7wXmJc6qrubFMgAkwASYwgwRY7JhB+HNw1yx2zMFOm8Ymm6YJSdHR0DOG4MxmvO6fh6cd0rDeKxuBGU1o7B2DrBkcXj6NzHlTTIAJMAEmwASYwOUnwGLH5WfMe2ACC5oAhYQ399oQnNGMTb55eMYxDW8dzEdIZjNKWobQMyJDUnnq2II+SfjgmQATYAJMYFoIsNgxLRgXzEZY7FgwXf2TB0qf1TsH7Ygv7cLXkWVYvDsZq10ysCumEgnl3egekVjw+EmC/CITYAJMgAkwASYwmwiw2DGbeoPbwgTmGYFxRUNVxyh8kxqwwjENi3YmYUtwMRLKu0Q4+Tw7XD4cJsAEmAATYAIzSoDFjhnFP+d2zmLHnOuyy9pgRTdQ2DyInccq8IxjKpbsTsa/fHMRlNGEktZBKzOPS64vax/wxpkAE2ACTIAJMIFLJ8Bix6Uz5C0wASbwAwKUHd43KiOtugfboypE8OHTTmlwiK1GYfMQxmQNNIuMH0yACTABJsAEmMD0EWCxY/pYLoQtsdixEHp56sdIOgZNVOocsiMqvx0fhZTg6X2peMYpHR8GF+NoXitqukYwYleh8ef4qYPlNZkAE2ACTIAJMIErSoDFjiuKm3fGBOY/AfruQ1+CwrNb8bpfHh7fkYSXvXMQnt2C5j4b7GxZNf9PAj5CJsAEmAATmBECLHbMCPY5u1MWO+Zs113WhtN0pEGbIuxmQ7Na8Lp/PpbuScXTDqn4NLwUscVd6B2VeeLSZe0F3jgTYAJMgAkwASbwSwmw2PFLyfH7mAAT+BEBWdNR2T4M78R6rPPMwvJ9qXg3oADRBe3oH5V/tD4/wQSYABNgAkyACUwfARY7po/lQtgSix0LoZd/+THSBKb+MQVJlT1wPFmN9Z7ZQvR42TMH+09Wi+fpdX4wASbABJgAE2ACTGA2EWCxYzb1BreFCcxRAlTKTjPAsur6sPdEFZbtS8Vat0zsiK5ARk0fhsdVmOzxO0d7l5vNBJgAE2ACc4UAix1zpadmRztZ7Jgd/TCbW2GYJhTNQGu/DbHFHfgqohTPu2bgGcc0vBdYhJCMZhQ1D6J7WOJKj9nckdw2JsAEmAATYAILiACLHQuos/lQmcClEqCydgMmdAPQdAMqLZqJnhEZZyp7RBXHoh1JeHJvCg6lNaGhZ0x8QbrU/fL7mQATYAJMgAkwgZ8nwGLHzzPiNb4jwGLHdyz4t58mQKKHpOpoHRhHVF4b3gkswOJdSXh0eyLeOVSAo3lt6B2RxTo0CYrW53lOP82UX2UCTIAJMAEmwAQuDwEWOy4PV94qE5iXBFTNQP+YjLruMeQ2DOBUaReCs1qw63gVXnTPxFMONMurEKdKOtHSb4NCqgg/mAATYAJMgAkwgStCgMWOK4J53uyExY5505VX7EB000DfmIzC5kEEpTfhjYMFeGpfGl5wzcRn4aUIzmgS3xGo0oMmRfGDCTABJsAEmAATYAJXmgCLHVeaOO+PCcxiAoZhinDx9iE7arpGRVl6em0f4su6EFXQLr7UeCTUYldMBT4NL8abB/Pwslc2nnfPxCrndHxztBxnKroxJmlcyj6L+5mbxgSYABNgAvOTAIsd87NfL9dRsdhxucjO/+1S9UbnoB0JZd3Yd6Iam/zysMIxDS975YjvCG7xNTic04ykym6Utg6hfXAcdkXjao/5f2rwETIBJsAEmAATmHECLHbMeBdwA5jAzBKg8EEqSx8aV0Q1RmZtH8KzW+EcX4vPI0rx+sECrHbPxD93peChbQl4cGsCHvvmDBbvSMTS3clY7ZKB94ML4XmmXggk9OWHH0yACTABJsAEmMCVJ8Bix5VnPpf3yGLHXO692dN2sq+KK+3CR2ElWLU/HY/vSMRD287giV1JWOeVjW1HKxCe3YLCpkG0DYyjf1TBqKyBKsbJ7oofTIAJMAEmwASYABOYTgIsdkwnTd4WE5gjBOh7BYkSkmqIQMGs2j54nKnDu4GFWO2cgaf2pYrcDcreWOWagY2+edgcUozt0eXwSKjDkZwWJFZ0o6RlELVdI0IkodwOu2rwjK05cg5wM5kAE2ACTGD+EWCxY3r71DRNqKoKu90Om80mfmoazU4//wAtPa8oytn1JUmCrutnG/XD12m7575OK9L/6X3j4+NnF/r/ufu92HadbcAPfmGx4wdA+L+/iADZVQ3bFbT2j6O0ZRCnijvhdroWH4YUC3urJ/ekYMW+VKx2Tseb/vnYfaIKEbmtKG4ZQM+wJPL9WPT4Rej5TUyACTABJsAEmMB5CLDYcR4o/BQTmNcETKBvRBazq8JzWrE7phJv+uVhlXMGVrtk4q2D+dgRVQGvM3UIzWzGsYJ2JJR3I6u+X5Sh1/fY0DUsYdSugmyv+MEEmAATYAJMgAnMDgIsdkxfP5Cg0NfXh9TUVOzZswefffYZXF1dkZGRIUSI8+2pv78f0dHRZ9f38PBAeXm5EC9ofRJMTp06hb1792LLli3Yt28fqqqqzm6KBI2ysjL4+/vjiy++wNatW7F9+3Z4enqiuLgYo6OjYl36Se1ydnYW61H7SLgYGBg4u62p/MJix1Qo8ToXQ0AzDAzaVJHvl13fj+OF7fBLqsf2qHK87peHNa6ZeM45Ay+5Z+H9gALsPl6JyNxWEXyu6vy94mJY87pMgAkwASbABJjA+Qmw2HF+LvwsE5h3BEYkFY29NuTW9wsR48uIMqx0ycTiXclYsS9FCB5Op2qEsEHrjcvavGPAB8QEmAATYAJMYD4TYLFj+nrXMAykpaXho48+wpo1a/Dcc8+Jn9u2bUNjYyPo9XMfVImRk5ODN954A6tXr8YzzzyDdevWCYGkvr5erDo8PCz+T9u78847cddddwnxY3I7sizj6NGjeOmll3DvvfeK7bzyyiv4/PPPRVsGBwfFfkkgoedoPytXrhTtIjEmKytrclNT+slix5Qw8UqXSEBWddR1j4oMQM8zdfg0rBgve2bhqb2peGJnMlY6p8M/tRGV7SOi6hxg0eMSkfPbmQATYAJMgAksaAIsdizo7ueDn68EqBRc0QwRFE72UnXdY4gt7sSu41XCO/cZp3Q87ZiG9Z7Z2BFTiRPFHajrHsGgTYZd0UHl6PoFLBrmKzM+LibABJgAE2ACc50Aix3T04NU1TE2NiYqJ5YvX47k5GS0tbWBvji99tprQqAYGho6a2dF61dXV4MqOd555x3Ex8ejtbUVQUFBeOGFF0S1B9lhkZhRVFQktkfrLlmyBHFxcWcbPSl2fPnll3BwcBBVH1StQfui18jiigSPqKgobNiwAcHBwWhqasKZM2dA7aQKELK8ovZM5cFix1Qo8TqXSoC+l6iaKb5jUGV497CEivZhxBS0Y9vRMjztkCa+l3wbXYGsun70j8nQuXr8UrHz+5kAE2ACTIAJLFgCLHYs2K7nA59PBOg7LX2tpUXXTQzaFBEWHlfWBdf4OrxzsEAEBj65NxXPuWTgs8MlCEpvQm5dPxp6xkQ4OX+pmE9nBB8LE2ACTIAJLEQCLHZMT6+TqFBbW4tvvvlGVFmQcEGP9PR0kBBB9lEkbkyKClTlcfr0aVEF4ubmhslKDhITSITw9vYGVXXQemRl1dXVJSo4nnzyyfOKHVQ94uXlhZ6enu8dEL2fbLGcnJyEfVVubq54nQSPtWvXYvfu3UL8+GEOyPc2cs5/WOw4Bwb/ekUJ0MQq+r5S3jaMkMxmrPPMBn1PefNgPiLy2oQgckUbxDtjAkyACTABJsAE5g0BFjvmTVfygSxEAlR9QdUYtd1jIF/cE0WdCEhthENsFT4JLcbLXjl4yiFNfHl4zScHu45V4HBuKwqaBtA3Ki9EZHzMTIAJMAEmwATmLQEWO6anaylknIQAEh0+/vhj9Pb2ig1XVFQIGyqyjMrOzj5rZUXiQlhYGF599VXExMScFSkof+P555/H/v370d7eflYcIeGDqjPOJ3ZERkbi9ddfx6pVq0Rmx8GDB4XIQjZZtB+y1qI8DxJVampqRLu6u7uxefNm7NixAySAUPun8sjLy8PixYuRmJg4ldV5HSYw7QSo6qN3VEZUfhveDSzEP3en4GWvbHgn1qO6cwQK53hMO3PeIBNgAkyACTCB+U6AxY753sN8fPOGAPnd0gyo1v5x1HSOorBpAIkV3QjNaoJDbDW2hJRgg3euCP171ikda5wzsNE7B1uCi+CeUIvkqh60D44LL1zNMMHV4fPm1OADYQJMgAkwASYgCLDYMT0nAllGkQBAlR0UEk5B5fSgag+quPjwww+F6DCZ20EiREBAgMjoIAuryaBwEkc2btwIR0dHNDQ0nBVHyJbqfGIHiRQUPE6h5OvXrxfiCQkfJLqQ+EIB6GSpRQLMgQMHxDapXVQBQgIIiR30/guJHSSYtLS0gEQOyvegbfzjH/9AQkLC9IDjrTCBiyRAVekkeJC9VVp1L7ZHV+B510ys3J+O3TGVyK7rx4BNYVuri+TKqzMBJsAEmAATWMgEWOxYyL3Pxz77CZiAYZiwyZrI3Ygv64II9gsvxUseWXhqXwoW70zC498mYsmeFKxxy8IHwcWgoPGo/HYUNA2ird+O4XEVkqqLLxOz/6C5hUyACTABJsAEmMAvIcBixy+h9uP3TIodJDKQ2DFZ2TEpdmzZskVUW5xP7KAMjkmxgyynKGCcbKfODTW/kNhB26N9NTc3i4wQygmJiIjABx98gE8//RQFBQVCzJgUO2ib9JgUO3bu3CnaRe0/34PsuAIDA/Hyyy+LAPVHHnkEN9988/estM73Pn6OCVwJArJqCHtd/5QmrHHJxKPfJuK9wEIklHeL6g+23L0SvcD7YAJMgAkwASYw9wmw2DH3+5CPYB4TID/bhh4bAtOb8UFwEZ7bn4Yn96UKayoSNt4+VIgd0RU4mNKA2KIOZNX2oaxtGM194+gfU0BfGvjBBJgAE2ACTIAJLAwCLHZMTz9TmHhOTo6oqHj//ffP2lKVlpYK4eLrr78W1RHnih3EnqowyIaKMjnoUVJSgueeew4uLi7iucmMjwuJHfQeqhKZ3C79n/I4KPPj2WefFbkg+fn5QoCh3JCqqiqxH9ofBaOT2EEB6NT+8z0odJ0EG6oOoQoUste6//77ubLjfLD4uRkhoBmGqGI/UdSBdwMKsGxvKtZ5ZMM3qQFVHSMz0ibeKRNgAkyACTABJjC3CLDYMbf6i1u7QAgomo6WfhsSyrqw90QV1nvlYLVLBt7wzcM3R8vgfroWoVmtOFPRjbLWYXQN22FXNYig8omw8gWCig+TCTABJsAEmAATmCDAYsf0nAokNpDd07fffos1a9agrq5OCBAUQk5VHWT/RFUVk+IFrZ+SkiLCy/fs2YPKykrRkKSkJKxYsQL0hYuEhsnHhcQO2h5VZdAyuW0KOyfrLBJNyFqL2uXp6SkyOmifJGxQdgdlfOzduxcdHR1CMJnc1w9/0nYnl4yMDDzxxBOc2fFDSPz/GSUwmUmYVNmNrUfLhaXVes9sOJysRlZdv7D1NdmPd0b7iHfOBJgAE2ACTGA2E2CxYzb3DrdtQREgoYLKs0ftGmo6RxCU3ozXfHLx8PZEPOuYhl0xlcis6xO+tVTxQf62tND7+MEEmAATYAJMgAkwARY7pu8ckCQJ7u7uIkScQsfJkooqNMiWikQMspsi0WJkZEQIDiR+UJj4pk2bQP1AVSBUkUHZGydPnhRiCYkilP9BweUeHh54+OGHhRBCNlQkhpBwQVZTJJbQ9qiq4+jRo8LC6qOPPhJVG5THQdt76aWXhAhSXFyM6Oho0U76YkeVIVN9UA4Iix1TpcXrXWkCZOVb1TkCx1M1eG5/Bp7cmypCzFOqetA6MC6+E43YVWH3K2sGNAoz5+9FV7qbeH9MgAkwASbABGYdARY7Zl2XcIMWIgESLBTNQOeQHVH5bXg/qBBP7UvFs/vT8enhUpwp70Zznw3jMlkb8Kf4hXiO8DEzASbABJgAE/g5Aix2/Byhqb9OokFhYaEI/aaqiiVLluD5558X1k8kSFB+BllWnThxQgSHkwhBtlUUXk6WU4sXLxbZGJSR0d7eLnY8PDwsRI61a9fi9ttvx69//WvcddddokqDBBQSQkjceOutt0SlBlVrUGUJZXRQoDiJK/SgsHOq4li9ejWWLl16tqqD9n8xDxY7LoYWrzsTBChzsH1gHEfz2vF+YBEW7UzCWvcsfHa4FO4JdQjLasHpsm6RU9jUZ8PwuAJJNcT3KpocRgIITSbjCWIz0Xu8TybABJgAE2ACM0OAxY6Z4c57ZQJnCZB00TsiIbmqB46xVXj1QA6edkrDO4cK4ZfcgLyGAQzaVBgcv3GWGf/CBJgAE2ACTIAJ/JgAix0/ZvJLnyGrJxInSEAIDQ2Fj4+PEDeoKsNutwu7KKreqKiowPj4uNgNrZ+WlnZ2/WPHjokKjcnAcHofCQwhISGiaoQqRciSitYjqyyq7qAKkqioKAQEBIglPDxcbJOEjsksD9oftYvCy319fREWFibeR/u/mAeLHRdDi9edKQJka9U1JOF0WRd2RFfiJY8cPOeSgTVuGVjrnolNPrl4P7AAn4WX4tuocjifqoZvSiMOZ7fiZEkH0mv6UN4+gr5RBarGX6hmqh95v0yACTABJsAErhQBFjuuFGneDxM4D4ExSUNN1yjCs1vwbmABFu9KwkqnNHx1pAwJ5d3oH5XP8y5+igkwASbABJgAE2ACPybAYsePmfAzFybAYseF2fArs4+AXdXF96aD6U34JroCm4MK8dqBXLzklonn9qfjyb0peGJnEhbvTsYKhzSsccvEKwdy8H5gIXYeq0BoZjMya/tAFSCjkjr7DpBbxASYABNgAkyACUwLARY7pgUjb4QJ/DQBKp+mMmryk6VybBI5OoYkJFb04KuIMjyzP13YVpF9VWRuG9r6xzGuaKLs+qe3zK8yASbABJgAE2ACTMAiwGIHnwkXQ4DFjouhxevONAFy8lV0Q3yPGh5X0Tcqo7V/HKWtQ0iu7EFEbisOJNVj9/EqfBJejNf987HWLRPPOqVj+d4UsWzwzsGeE9U4XdqFpl4bhmyq+G7GGYgz3bu8fybABJgAE2AC00eAxY7pYzm7tkSf2ExjYuGMh8vROUSVLA7IA5bKq0nQOHfRDFP4xdKH8Y4hO+p7xlDSOozMun7EFHbAIbYGGw/kYNneFDHr6EBSA/IbB9A7KrPIcTk6bMrbFD1LvTuxTPmNvCITYAJMgAkseAKTn79m5rMXix0L/gS8KAAsdlwULl55FhKg72E0mWzEronvUO2DdjT0jKGqYwTFLYPIqevHmfIuBKY147PwEqxxzcRyh1S85J6FLSHF8E9pRF4jWQYrUHX6XscZ57Owm7lJTIAJMAEmwAQuigCLHReFa+6sbI60w+gohNFbCSiWj/Dcaf3sbylVaQzYFBEaXtI6hMy6Ppyp6MGJok5E5rUiOLNZ5G14nK6Fw4kq4R/7xeFSbA4qwpv++XjeNRP/3J2C55wz8GVEKWKLO0Afzjl7fBb0vWaHKQ3BlMdgGtosaBA3gQkwASbABOYMAU2C0VsFjHbNSJNZ7JgR7HN2pyx2zNmu44ZfBAETJvptiggxp0Dz7VHleMUrB0v3puIZp3S8F1AI9/haxJd2obZ7TFTXX8TmeVUmwASYABNgAkxglhFgsWOWdcglNUcehTFQD6MxAWrGXijH34AatwV6aRDMzgKYtm6AB2+nhJhmCZEv7NC4KgLxmvtsqO4aRUnLkJghFF/aKXxfXeJq8XVEOT4ILsIbBwvwik8uXvTMxirXTDzjlIbl+1LwtEMqVjqlY7VzBta6ZmKdRxZe8crGB0GFOJTWhKrOUdgVXVSIzMw80CkhmR0rTVYsGTow1UVXAc0OSCMwx/tgjHTAGGyC0VcDo7sURkcejNZ0cd3o1dHQSwKh5XtBK/SDVn4Eel0sjKYEax1at6tYiIjiWhtuhTnaBdPeD1MeAdRxQFdgcpr87DhfuBVMgAkwgStAwDQNmLZeGB350MuCoCZ8Cr0yGtAkq8L2CrRhchcsdkyS4J9TIcBix1Qo8TpznQB9vxKV+IYJSTGE9VV8WRccYqvxpl8+Vu1Px9MOaXjVJxf7YqsRW9yJsrZhdA5J4vvgXD9+bj8TYAJMgAkwgYVGgMWOud7jhgFTtYtBXL0xGWriV5D97oHk/EdIe38LyeG3kN2uhRy5BlpRAMz+ekAehWko5ME0149+2tpPM3403RCiw7BdQ8fgOKhi43RZF4IymuF4shafhJfiNb88rHK28jWW7UnBkl3JWLIrCU85pGK1awZe9s4RosfmkGKRxbH7eCXcEuoQkNYksjjogzUF45W1DqKlb0z4xFLJ9Kx9UNPIDs3QYOoqTE2GSYM3NKivjIlzCdIgMN5vLfYhgAb95VFAsQGqXQz20PtAogOJbcJebfKIxQ4Ak8SLiX3otA87oNom9jECUKXFeC/M4XaYg00wBxqmvBi91TA6CqDXJ0AvC4ea6wklZTuUUx9AOfoylNAnxTUju/8JsvO1kJ2ugeR0NaT910Defy1kl2she9wI2e9eyCFPQol8CcqJt6Cc+QJqugPUfF9oFZHQGhJgtOXA6CmHOdgMc7QbsA+KtkP+AReqtiKGdJyaJJgSV2uh45dhEgcSTgRzxfqd/k8cidflun7P9jntg6zwJvuKf84oASH0mRMin3aea2lGW8c7ZwILkIAJ09Bh0meqkVZopWFQotZBcrkKkss1UJO/tsRw48qG4LLYsQBPxUs4ZBY7LgEev3XOEiDbYZts2V6Vtw8hLLsFH4eV4mnHNCzdnYxnndLwXlARDqY1iTyQoXEFsqYL2+I5e9DccCbABJgAE2ACC4gAix1zuLPFmORIF/SqaCgnN4nBWMnpWkiuf4IS8QK0lG+gxm+BdPBBSI5/gOR6E5SwJ6FlOcBoz7cGlOfw8U9n00lwKGsbQnBGEz4/XIK3DubjZc8sIWws35eKpXtS8ZRjOta4ZWGjTx62hBRhd0wlfJMbEJXfhoSyLqTX9CKnvh+FzUNiNlB15ygae8fQOjCO7mEJ/WMKRiQNkmrAoEHkOfAQ46vyiBi8NzqKoNcnQi87Ai3XE1rKt1BOvQMl8nkoYcughCyFErkGSuzrUBK/gpq1H1pRILSqGOjNKTC6SmAOtQiLqHMH6skqyrT1wRyoE+elXn/6rCihpu6AEv8BlGjaxxLIgYshH1oE+dBjU18OPgLZ7wHIXn+D7HYzpP3Xwe54FexOv4Hkej0kz9sh+dwLidYLXQGZBJATb0KJ2SSuIzloKST/ByEduBeS152Q3G6C5HwVJCXj1u0AACAASURBVMffWdeV8w2Q3G+B5P03yL73QfZ/CHLAIijBS6CEL4cS+SyUmA1Q4t63BJK0XVCzXaAV+EErCbGqRyqOiutYrz4OveYk9Np4S5ypT4LelAKjOR1Ga7a1dJfBHOu6bCKEuK+M98Mc6RDVKiQE8mN2EBDC12gHzL5qmP11MJUx7p3Z0TXcigVKwBhohF7oCzlyBST3v0Byvg6Sz9+hJn0BvSUNJonauLJ/71nsWKAn4y88bBY7fiE4ftu8IUAZi72jEsrbhhFX2gXnuBps8svH0r0peNoxFa/55GBfbBVOl3ejZ1QGF2/Pm67nA2ECTIAJMIF5TIDFjrnWuTTuqIzC6KmAVnkYatJnkEOXQ6JZ6T5/g3Lkeajpu2E0JFqzy3vKoZUGQzn1HpSAxyB53ATJ5x4ox16BlusKvTEFxkibmDU+11BcantpEHfQJgtrqsjcNmw7Wo4N3jl42ikNL7hlig+3HwQW4MsjJdhzvBJeCXUIzWrByZIuZNX1i+C7rmEJ47IG+qBMYeWTk6/Fz+mKuCZhRLGJqgaqUtC7SqC3F0BvzYbelAa94Qz02jjo1THQKyKhl4ZAL/GHXugJPd8Nep6b9ZN+L3CDXugGvcgberEv9JJDwuZMLw2FXh4OveII9MoI6KXB0Au9oJFgMSGaKcdeg3x4NeTAJ4R4IPncD8n7Lkiet0HyuNVaPP8qBv0l3/tBi3zwUchBT0I+8jyU4/8S4puWsg16lhP0PBdouc7QMvZCI3GEztHoDZDDn4Mc8DhkEhhoOwf+DsnrVsiet0D2ugvygXsh+9w39YXa4f8wlKAlUMJWWpUZMa9CiXsDavIXUDMdoRX4Qis7DL32FPSWDFEJYrTlwmhMhl51XMzY1fJ9oGY5Qk3ZBvX0e1BPbIIStUEIIkroM1CCllpCjN+DVhtJGCEunrdA8rrDEkuIGQkv/sTmfsiHHoUcsBhy4BKQqCIHL4ccsgJy2DMWh8OrLHYRa6EcXQfl6Hoox1+HeuYz6LlO0CvCLTGkpxLGWLeoArmo60JThHCi91SI7VD/031BTfoSasInUFO3QyvwhF4VaZ1rYj9dVsUOneT8mD4CdJ2rkmWFM9AgxEG9OQNG7UnoZSHQ8l2hZey2+iX2Hagn34WW+i20fE/r2q0/DaM9DwaJILZegKqpWAqZvv7hLc0yAkKWvfLnOAXXKjZhgahXhECN3wyZPlu5/AGK/wNQTr4FrTgABgmSQui48thY7LjyzOfyHlnsmMu9x22fTgIkYkiqjrqeMcSVdcH1dK2Y3EbfCcmK+J2AArjF1+JkSQcq2ocxPK6AMhz5wQSYABNgAkyACcw+AjMudhiGAUmS0N3djYaGBjQ2Norf7Xb7j2jRYLKqqujv7xfr1dTUoKurC+db90dvPueJ6upqvPLKKzh16tQ5z87yX8muiqwShluhNyZBTdoK2e9OSA6/grT/Wighy6BlOcHoLrHsgyZtbmgATVeAsR7oNbFQTr5rDU7v+zUk52sgH3kBaqGf+OJujvdYFkXzfBBT102MSiraB8dxprwb26MqsNwhDYt3JeMljyx8HVmGgLRmJJR3i1k+VJVBgoaqG+JDLZU+G7SQuDHdpw0llKsyTGlYDFiawy0weyuFKKUV+kOhSofTn0GJfRfKsVchR66FHLZSCArSoccg+dxnVSq4XQfJ6Tew7/sV7Hv+D+x7fwW7w3/A7vgfsO//35Cc/xuS67WQ3G6E5HELJM87LOHC5++WwOB5K6T9v4e05z8h7f0NpH1UxfBHYe0k3uf9V0s8iNoANf5jqCk7oKbuhhL/idUuGqz3vwey+5/F+SmRNRRVF9F29v0G9t3/Kdom7fsVpD3/BWnfbyHtuwqSE+2D2nUd5AN3QAn+pxjgV099AKry0HI8oOX7Qys8NPWlOEjYTOlNyTC6ykRmh7DaIgspujaEvdaExRblgNA1c3aZzAYh2yB1Yn16j2zZUNkHha2W0VkCvTkVWs2JCWHEF2qms+CinP4USuw7UKI2Qj78HOSgxZD974LsdSMktxsgudwAyfn6ieU66/iJwf6J34Wt1oS1FtlrOf7eYujwvyEduFNcw0rSNrFfvT0bxmAdTJr9bx8AyC5LJ+swiOM0ZZuVL0JVG6KSJgdaaSiUpK/FdkgItTv8GhLdH/b+N6S9dJ+4GhJZeEW8CCVpq6hGoYwTs69KWLcIezGyLqPB9bM5KprFVVPE86ZiFwOEIvSd7mN0fpM1GfGzD0ws9Pug9Ty9JtYZtqpLqLpILKPWfZC2cb7tUEXKeJ917dh6YJIANNYFc6wT5minyC0y6XlaR+yX9je5jzGYwl6MLNQmbNdE+61jICGCbNloHWuxWSH2oi10PD88pom2kP0a7dN2blvaYZLIPNIKcY1TX/SUwmjJFIKjluUCcd4cXQcpaIkQ++xOdC3StfLfkByuguTwO6t/6JrxvtMSyY6/DTV9H/SywzDasmFQHw03WwzoeOUxgI5pnt/jp/u2vCC2J7QDskmjzwzfv37FuS/Oe9v3r2Nx7o98d62evabpWqbzf/Ia6LNsCG3nXguT10OXdW3SPWtk4rqgv3t03g41wRxqhDlYD3OwBuZAlbXQed1bDrOnDGZvBcyBGphDDda1JK7zHmv/4tomO0XJuh9d0nlvWpMORtthNKdBSfoS0oFbIe35D8juN0OJWCsqEqnNll3jtH86mPJpyGLHlFHxigBY7ODTgAl8nwD9qaDvemOyitK2YfinNOHtQwV4al8qHvs2EWs9MrHreCWSK3vQ0DMm8h1Vjar2Z+6+//0j4P8xASbABJgAE2ACMy52kFBRUFCAr7/+GsuWLcNTTz2F7du3Izc3V8yUP7eLFEVBZ2cn3N3dsXz5ctx9993ifYWFheeu9rO/zzmxgzyhx3qgVR2HcmITJK8/iywOsquSo9ZBKwkSA2ViNi99qT/fZy0hlozAGGoGDfqqKd9COrRIDJpK+/8gbHfU9D3QO/KtvIVJseRnac6dFcSHV91Ez4iMkyWd+PRwCZ51SgdlbzzvlgXXhDqRp9E5ZMeATcGopEO63B9eqVE0sE6DxJTRQAHaXUXQyo6IPqJ8CNnvfsiuN0Jy+MPEAPRvJgY9fwXJ6beQXK+zBCwSOg4+BjlwGeTQZ0RFAFkyydEbIUdtgHx0HeSIFyAfWW1VDYQ9aw2QBj8JOXAp5IAnINP7/R+GHPBPq4ojhqoIvrJsl0rDhLWSmD1OuRQDtdZgFA1SiUHlbsv6iAapaMC9txJmVwmMlizotSfEeapmOYvtySfeghy5DkrUyyI7Q4gled7QyiNgNCaKygoxiNVP+2i0BsFoHzRIPT45OD7VnxMD2pQxMjkgP12nLV1rNDBIuRpUfUMh6HbKFxmwBtxpoJ2EheE2mEPEpR5mfw3MvgoYvaVWQDox6igWFl5Ga44Y8KbBNIPEmcYz0OvjodedhF5zAnrVMWiFB6EkbhX9K/ncBbp+hTBBoghliwTS7OJ3oOV5gnJ8xOCbPAZjoAF63WmoWa5QYt+CEvAoZPfrIe2/GtKe3wgxS6aqr8PPQ034AmrqTihxH1limvdfITn+H2ugnQbX3a+D7H+3qMRRU3dBK4+E0VlsZaqMdor7jNFfC6O7zMpLac0UbdHrTkGrPCbOb60o2KqoyfOClucDLd8PWsEhy/qMBKqSUGhl4RM2X5HQK6PE8QurL7JGqzgKrTQcWlGQeK+a6wU12xVqhoMQ3tTkb4RtmBDg4j6EErcFSsLnUFO2C0FAzXafsBILhUbbpgqKxmTLKoz6pLfKCrHvrYDRRUH2BeI1vTld3EOF3RpZjlGfUGYLtYXaXeAP7WxbHKGm7YaavF2c91ZbNkOJfRtKzOtWJRNdk4EPQvK6CZLLjZaguO/3lpDh8F9WNR7Zth1ebV0r6Xuh5XlBzXET4qIcsdaqgnK9ZkKk+h2EuOh6I2Tfe6EcWS3Wo6wareYUDLouSVQiwU5k6EwIfOf9wzFdF8pc2A7diyfuxyJDyMoREozOiqDn++N6pY/t3HaSMEv9NynKnvtzIteF+vh7Cwm7EwsJvST40v2LhNDxQZE1ZAw3w7p+y2F0FELclybP+7OVhCeg07VM5z5dp8XB0AoDrGsqzxtqjrt1PWbut643ug5SdlrXQtLX1rVJQjAJ5HR9nnzXsg889pqoYpOPrLEq3EKWQA542BKIfW6F7HUTZI+bILv92Vo8/gLZ9w7IIZYwTllM4nrLcYdWEm5VPVKV3kA9TFu/FRj+PZF7Uuie5DTBcJKrmDCiifwoyn2iKlnZ66+WMO/2JyHu6+VHhHhMAq74e3ClT4kf7I/Fjh8A4f/+JAEWO34SD7+4kAmYgKToGBxTUNs1ilMlXdgWVSG+Mz6xM1HkNW4OLkJQZjNqusZgk7TLMxFuIfcBHzsTYAJMgAkwgV9IYMbFjvb2dnz++ef4+OOP4eTkBBcXF7z55ptwc3PDwMAANE07e2gkdlAFSHR0NDZv3ozFixeL96WlpZ1dZyq/zCmxg4SOgTpoyZ8K+yDJ/WbQAKd8bKMYTCA/f5qxLGanT+XgqRqBLBh6q6BXHoWa8jXksKetwXLv26EcWQU1eRv0qhiY/bVWgPK0DoLRdBnNmglKg89i1jkNIJ1vmcoBTW0dmnHT2DOGE0WdwpLqdb9cPOOUho0HLB/WE0XtqOkcxqhduUBbzte+CzwnZvb8xGs0cEYzxMd6YXaXWQPQhX5QU7dBjX0DCs3+P/gwZK9bIXnfDtn3AcjBT4JspNTTn0JL2Q4tfQ+0rH3Q85yhF3hBLz4EvSwMemUk9Jrj1gBPQxLEwCzNFm/OgN6UKipEdHqewrrr4i3bptoT0GtirMwIyo6oiIBefQx6/RlhlSUGrAcbYYz1iIwAMXA2NezfVRRIIzBGu2AMNogBcL0tx2oPDaDRIDINLA+3WjOBaXb9FfY4n+rhXLb1xCArDbKp34WSk6URCSiUy3BOFYMx0iFs7GhgXi8LhU7WWqc/FvZccsCjkGggzvNmCOEi+EmoR9dBjX0d6tGXLKst77she98JyftuSGSjFbkO6ulPoGftt7bXkGSJMGSZJnJaKEMlAHrWHmGhpESthxT4OCTfuyB7/hWy913CrozOWzXqZajHXoF6dD1Ust6igfbwlVDCnoZC4e5B/xTCquxPOSoPQva5F/KBe86xJnsAst8/rNf8HrKEN8pSOfQolEOLoAQ8DiXwCfFT5LaQMEfrk62Z9z1WLovXHWIwUvaiHBVabres1cQx3yauK9n7DsjEwed+yLQfEhOC/mm1MewZKIdXQY14wTqGiBegkNAQ/hwUei30KSghywVLJWjxD9ryIGSyTRNtoeqd79oie1vXs7B+I2u2A/dYWTGUF+P7d0j+D0Cm7Uath3LqfajJW6FlO0Av8oNeFSUq+si+TgxCD7dYwnVnMcT1TPZzBR7Q0ynj5kPRp1LgPyH5PiCqPiTPv4jzgTJvhNUhnQ/JX1mCWOVRIbCZ/fVCBBHC6/fux+ee9XRfo8fk/e3c3yef+5mfonJAsWbJk+gihNIeS2Snvwdntz25L2uP0/fvOe2j647uxbZ+mHRv6iqG0ZQi/v7RJAISlLRcd+gloZYQRtZE0uBE5dfkdqavZT/e0uQ+rGB6UyU7wzbL4oyu/2oSHKKse3ZZOPSSEOhFAdAL/aHn+0DP84Sa6ybEarLrUzP2CGs6NeVLqElboCa8CzXubaixb0E9/gbUmE1Q6bNF1HqokXT9rrGuX7LpC3kKSjCd98vEdaxQfhLZDdI9hP5e0XVEf6vEtXgvZK+/W7aDnnQN3D5xTZJYcTNk75shnb0e/gbpAC13W9cEZSORcE+Wf3T++v4Dkh/Z/90Lyf8+6zqh/YnspkUia0nynXzPvaJCUeyP7kt+k/aFz0KNfBFqzGtQT70F9fQ7UBO3iABxNf1bqJkOUHNcoed5QS/wh14SZFnDEVtiXBIorP2UsBWQqeqR7nvHXoWa6wG9NVNMRplN1VIsdvz4SuJnLkyAxY4Ls+FXmMAkAc0w0D+qCOvj6Px2OJysxr9887DaNRMvumfh87AS+CY3Iq26F52DdtD3Tn4wASbABJgAE2ACM0dgRsUOsqSiqoxFixbB2dkZo6OjGBkZwVdffYUPP/wQeXl5sNlsZ+nouo6xsTFR3ZGcnCyqOnbt2oXU1NSz60zll7q6OmzcuHFO2FjRTHG9Ogqy8+9FNYcSPGFXRbOo1R9bfU3l+M+uQ8LH+AD0mlNQ4z+E4n/vhI3Q1cJqRyPRo/qYGJymAOlL+jIvj1qzvdtzodfS7HQ/aDRAX3lE/N9oiBeDTGIGaUeRGMwVAbw0G17YUvRNCCS2idn534lgZ4/nPL+Mq0DLoIz0ukF4JDbiVZ88/HPnaax1OIVPfE8jIiET9VWFIBsikAVQUxKMhpMwGmJhNJyCaFfDaRhNZyaWJKudFLjdkjaxZMCgnAf6P4VJU2UCvachDkb9cRh1x8Qx6jXHoFdHW4JEWSg0mvkavwVy+DPWQA8Fmzr8Xszulg/cDTnoUSgn/gU1cz/EbPauMhHkLWxoznOs/NQCJWDqMGy9IAGJAs/VpK+gRjwL+eA/ILvdYtmPkf2R09WQPW4TA5NK1EtC1NSoWqct1zqvhEj30wwNW4+o/qIKHMoGUmI2WgIGCScuf7IqChyvtiy4qErB9c/C4kX2+CtkGvSkAcgDf7eC3EV2yUPWQCkNXh4kcePBCaHjAWvglALfafG5x1qEMHI3xPVBv5OwQGIHvffgI6JaRQlaBCVkEZTQx6EcXgolciWUKMo8eQHKkRVQQp+AEvSYlScj9kcDtPdY4ge1kXJW3P5iVVnQMbn+WYTSk1UNvSYYigHcv313PPT+ybZQQD21hQSawMm2LIJyeMlEW160uJ14Q+TU0D2AqmgosJ6sBvX2PJhDLb/M719XYYx2ij7VyqOsQe64dyEfXgL54INCfBGWaWSB5XytyJKRAx8XGU4kcmsFB2BUR8NoThUD6mI2/GCTlf800AiD7Lb66yYqXqpgUIZLT4VVwUPVMCQWkHjZkQejLUvY/Vj31DjodSTCHrOEm4rD0IsDoeUfgJbjCi3bFXpxgBBcjaZEK3uE7Ino/k8WYGS/RSLxVB+0LtnUkfWZrU9UVxmDTSJHge71Rmu2VTVF7aF7ca6HqAZQTr5viYZBy8R5KHndCZkWEtUiXoSa+CW0Ah/odSesbfTVwBylDJvvPqdMtYkXXI9sxqg6bKTd4txVBKMlFXrtcTEIr2bug3JqM0RFT/CTlvBIIqe4fh6yrgcSHQ6QAPh3S9T0pPyg2yC532Kdzy7XQnL+LSTH/4RE1UN7yUbwd9bfn7PX7w0T5/5fIHvcAtnzNusaJh7ef/vuGhTn/n0ix0lcv+ee/wGPQQlYBHFNBtM1ObGEPwHlyDIoEc9AOboaSvQLUKLXQ4l5TVQ9qXGboSZ8Kuw66dpQM/ZBzXaGmuNlVU4VBwmrNspZ0ooDrQoSypY69T6UqBehhFJ+0sPWNen1N+u4999gWSnSvZCq1Pb/FhJxcLsJkgcJxHRMdB1TphLdUx6x2NK5QOKLA1k//gly0BKoad9a1ylV0s7CB4sds7BTZnGTWOyYxZ3DTZuVBEj46Bi0I7akEzuPVeJlzyws3ZOCFY7peC+oEIFpTchvHMSATRaZjrPyILhRTIAJMAEmwATmOYEZFTv6+vpw4sQJrFq1CmFhYcK2imytQkND8cUXX+DgwYOgdSYflNlBGR8kelRUVGDr1q0gsSMlJWVylfP+pOoQElJ6e3tFxgdVgrz44otzQuww+mqhpu+C5PQHEUxMFkJiZinZT5C9wqU8aHCT7K1oUMjWC6M9F2RlJQc9AsllIj/B41Yo0a9AKzoEg6yLaOCJRJaf2zfZRNBsdNpuX40IzyZbGTn0SWGBIzlODqzQ4P7vRPi05PcgJLJUOvI8ZKpioAEPyiLIdoZWdNCavVoXJwbizI58YZOEgUZgpEV43xvkpT3aCW2kC8pID+zDPahqaEJoQj7ecT+BNdtDsHarL7a5eON0pDdaE5wxcvob2E68Z82EDl4GyefvkD1ugOxxPWTPP4Nmh8vef4VM2Qg+dwtbGJlmYIvBEJoRTgHTi6xZpjRbXcxs/Ttkqsgguw33ayC7XgXJmaxlroLkSF77tPzeyl5w/APszn+A7HMblIjnoZ75WtiB6K1ZMIdagXHKXRgTzE2RLUEDftTvl2vW86WcUPzeGSEgrmNdhJOLQFx5GLB1C7simpWsZrlATfhMiGtUzWMONFgzkcnPnnz4aXCVZttP5ZQydavyhIJ3KaeDciCGmmC0ZgqhRQh4JOJR4DtZOpUftgS+ulOiMsFozrQGwrtLxX1BDGaTxRd59Aubr0YIkZMGkXtoML18YiC9GEZnIYyOfIjgeAri7pwQRftqRW4KZWBgrFvcyzDeC7HY6WcfYO8XbRU/6f90HxvphEkVS1RVRNtuzbKstmpOWtY8ZKNF1jylYdCo2qkq2rISI1uxxiQR2E7vMdrzLQuvngqY1JYBsl2jtnSdpy0T7ZAGAKoQINsbadgalKfrXLNbIfPCXmrCruiiTioTpqmJPhX3aaqeo+oJW4+oCKFKQLqXq4lboRzdMCGIUTbMH6yBYMerhLAuBq3JZi7+E6iJX0NN/Arq6c+hxH88YTn0HpQTb0GJ2SRmuMtRr0A+ut4agD+8GnLo05ACSWB5xKre8bwZktsfvrsPivvf5D7pp3U/lF2ugUyViyEroMT8Swx2k7igkQhEdkqDjVb+CmU/0LlHmRD0O9nFjbaLnAdR+dJRCL0hUVQvakX+QjBWEr8W2TkyWQMGLYV84G+QXX4/cV+eaAtl4jhdA9nlesg+d0AOJnu/xyB73wZZ5A7R+v8Nyf1qyMFLoMS+By3bHTr9XeqvsoR5atNkxsxkjsvZLIuJNp+bKzOZ5UIZLgO1QjinzBU1w9ESNY68APE3h/KVznK7GjLZz1GejvvVkDyugeR1I+QDt0H2vccSDandVEkVvFzYGirhq0SuhLAOPLbJ6j+qIDp9rqjgCGHvlk/Xb6BlT0XVDcSfznuqCiRBvyUTRluOJWx1FsPoLofZWw2TrKIGm0X1CajilK5HuhZtE9fj5HVJP+19wHi/tUxen3Rd2OmamFjoHjO5KKOATLk6NiEE0r1O3L9IaKLzXBqx3kfbouubKgW7K6C3pEGrjhEZT8RUJSu7U5uhnHhbVEsqEeughNM5u0JUzwqR2Jf+fv8Jkhsxvgay203ibz0JLnTfEZ9tyBJxSjfNi7qAp2VlFjumBeOC2QiLHQumq/lAp4kAjUfouiHCzHtHJRQ1D+BAUj1e98/Dsj2pWLY3FW/45yMit0Vkethk7ZLmC05Ts3kzTIAJMAEmwAQWFIEZFTva2tqEsEFVFiR60IOsqig4nDI89u3bJ8SJ8/UIWVFt27ZtSmJHT0+P2CZlgbz33ntC6HjooYfO7vN8258tz4kgzKiXRVi0muNy6dUcP3FgNDhm0uzX1lRoRT5QTr4FCiyWaZaz122QQx6DmvQFtLo4MVNWhH6S6DG50GxaEjnG+8XgoV4cBPX0ZmsmNYkILtdDcr3Bmll+dAOU6NeswZfQ5SB7FYlmUtIMSq/bILlRYPM11uxqsu7ytKxo7Afugd3nfth9H4Ld/1HYDy3CeNDjGAtbguHw59AX/jLawv6F2pB3UBS4GcnebyPW4UXEbHsC8V/ehbSvbkP5jtvQs/92jLv/FTLN2qaAaI+bIJG1zMFHJwaIllgDXcFLrP+TZUfgExO2HWTdMTkznOx4Ju12HrWep+wLCqGm99ISsgxK6AooYc+KQRXlyForqyL2HeHnr5UGWZUgNCOarGTGeqzw65/oK36JCfwcARLHKJuB7MGMvjorN4QGX0nYmM6HaViDj2RzNkwDzm3WoC/ZE00MSovBSxI/xUClZAkmdL/4XjUJia+WXY+wSiO7OzoGXRH5EiblCpC1F92naKH/C9H3h9u5iIOj6jaDxAHaNgk4oxOZK/3iOqRrURwDDWBT4LsYiKUB2NEJEXL8+20RxzTNfC/icH5qVZPaRoLKWJe4z1DGClVwULWZWuADJXmryB+gAXK674vqlv1UAXAjJOcbrGU/3ZevheRyDSTXP1oChjtlxdA9lO7Tf4XkfQckqigQM+Qfse6ZZJ8VvNS6D5IlGAkp0ZuE+KDGbYFKmQ2ULUSWivR3gGbjT/69oGok+jvk/zAUupdGrxe2bSL/gfJX4rdAOf4vKJHPQaZqHqomoEoMqrShCjlP+ntyM2RxDNdB8rhF2IcJGySyByR7t5NkG/aNsK3SS0Ng1ByH0ZggRDyjNR1G3UloxQGiGorEAknYxd0OmWb607Z974ES9AiUmJetvIgCX6j5vlAnslXUTCeo6XtFBQ8J+GriF1DIeu7UB1BOvg3l+CYoEashU8URCel0/FRxQNVR7rdComMJoiql9eJ9otqvNNiqvKynKkSqRoyD0ZRgVSeKysN0GK0ZVoVNe45VLUN/Y6hShDJoussncmlqRZ4FVb6IiiK6fkkI/F5GEokP55z3JJKK61CauA5JMKXMC/o8MBXV9KfO1Gl8je4PdM5P2KUZQy3iXmj0Vk8IqZSXVGQJliTeEC9iRxyJZ10sjNoTMEjMakm3rBZnaTXHudRY7DiXBv/+cwRY7Pg5Qvw6E7gwAfqLN67oaBsYR17jAEIyW/BhSBGedkzDKud0bI0sw8mSDvSOylB140d5pBfeMr/CBJgAE2ACTIAJXAqBGRU7mpqaEBAQgDfeeAPx8fHiOEjsSExMFGLHjh07hGXV+Q7wYsSOwcFB0Id5X19fODo64qOPPsLjjz+O2NjY8216Vj1HwZ+i4sHrNmhVkVesbWQboncWQiv0F9YQVL1gd/qdEAbIp1s9vUX497dPWAAAIABJREFUgxs0Q3usG2IQoSULWrEf1MSPRZUCDTRJzlS58EdhoUL2EmrKVujkLd6aLaxWdBpsq42DXh4pBpO0PA9oGbuhJX8G7fT70E+9BZzYCOnwavT5L0Wz60Oo2ft3lH5zK/K/uAHZH12FrI/+Czkf/yfyPv0t8j6+Cnmf/EEsOR//HrmfXIWqr/6Ivn3XQ3b7E4wDt0M/9BA0yg8gT/6YTdDiN0NL2wYt1xVaSTC0ymhoFDpMS2WUNcu7/Ig1y7U01JrBTrPWiwNExQnZzxAnmjFNPu9aWZgI2hbvpSBlCjGmfAzKwCCf9aZ06C3Z0GnAiWa/0iARP5gAE2ACM0RA5DgNNUNvy4NedRxavrfIDFFPUZ7D21Ap8D7uPWhxH0A7vRlawmZoiR9CS/oQWsrH0FK/gJb2DbT0ndAy90LLdhHbEPfE0hDoFZHQq2Ot+2BDMvTmTOjt+dAng+B7Kq2/B3Vx1j00ywnamU+gkohBlX4kNpNV2qQA4Eqz7v8Myf0vQsiQXG+GRIHsrtdDIhsysiM69JiVrXJkDdTojSKXQju9BVradmh57qJiR9ybKc+IBv6puojELBKFzvMgQYzWob9dVOmjUQZG/Gbxd0Q+9AhkqrwgIcj1z7C73wa7x62we9wMuzv9n0QLau/NlqWSOz1/C+xkM+dGbf+LZZFEodu+91vtptybuPehpe2AVuBr5ShR/lJvjWU7x383ztNL/BQRYLGDz4OLIcBix8XQ4nWZwE8TGLQpyKjtg8upGqx1y8KT+1Kx0TsHngl1yKkfwBD5K/ODCTABJsAEmAATuOwEZlTsaG1tRUhICF599dWzwgOJHXFxcdNa2WGVm+qgjBCytCorK8OGDRtmt40VTRUxNGHhJO2/AUrYShhNFxfEfklnz4Q1DgWf08xwsrCgLAAK0JXdb4K0/xrIfvdBOfkO1CwnqCnfQol8EdKBO2AnaxDy6ve9G8qRleI1vToGBtnnKDYrTN2kMGZaaDbo5KKKgGYKaYahQJNt6OvpRG1NJVLTUnDkaAS8D/rC2d0FDg674bBnK5x2fQzPPR8gxPEdxLq+iXTPTSjx2YD6g2vReWgleoOew3DkRkjxn0LNcIBaeBBa1XHoZMNBYbNURSHaJFvtEvuebM+5P1UrTF1YSZ3TTvr/ucsF3z+5rcnjptnokzPSZ9FM2Es6afjN/5e994yO8sr2vN9v83U+3DWzZq1+5/Z7Z+5Mz009fW+H28F2t93dbtsYZ5IDxhgnMMaAszEGG2xyzsEkY5MzJoOQhCQQSSBAAoSIEkooV6lKVf93/Y770RWyBMqqsM9aRYmq5znhd556wv6fvbcRMAJRSYDzPR56nJNJEo5HDSv3PU8XQgnVVLlk3iJ8T23DV833Xn149tW9/nqedOdM7/zHu3fe986Bf/UOrPucc2qNy7nB+TlUcMaJxIQTCxya4bw6aja9pJo1T6lmXS+X58F5hxwYo2DKjO+F59NrVXthtxMm2J+wYmFCIwV939fNeZpxumsP/fA8FDkXN3U+/isjd+0KuNxRiCPhwnOqzd7hwsTV7BiqmtU95Hd5Kx6Qf9kD8q94QP5v/qyaVd1Vs7bn97ljSEJPfoptgxX4bpgCuz5QYP+Y70PNETaKnCKEg8KbwvGGZVAK8/K8J5rqZ1QegdbpdiRgYkc7woyDqkzsiINJtiF2CgF3BxGW8+DIv+XT1mPXNXLNSfWZnuRyeny8+qRIbn4hv0IVvkBEOUJ2CiBrxAgYASNgBIxAJxLoUrGDfBxbt251OTtWr17t8nH4fD6Xv+PTTz/VkiVLbsvZUZ9LSzw76u/H39nZ2XrllVciXOwIuVWmgd0fyTfx/xXv4ZuZDYfSOf8nTn+g8vvwJ3h7HF/mwjD55v/L9/HLCXXiYp3/2MVbr9k0QIG0WaolUXfR+boEsy6Myl16TAAYf1Cq8Id08WalNqZf04jVJ9R31kE9M2G3nhq/U70m7NSAGXv07pIETViXoqU707Uj5ZSOZ57TjSs5Ki/IVU1xroLFOaolJj+xu8vzFCZOOgYv4n4TigLjUZOGrbt01L42AkbACBiBjiWACOOElyqX28Tl6Ci/4XJzhEsuKnwr5/vcDHxGyDFyQOCdQc4MrllO3GiH/FZ3GiVh0AjPVlXskoq7nDjkr0BML8pSuDhL4RLyylz4vr+3Ln2fo4brEiJM2bW/hn2j/8XfC0z0G/HHihFoBQETO1oBLY53MbEjjiffht5hBELhsMp9QZ29XqZvD13WgAVpempKop6flawxGzOVnFWo4oqav4a26rBuWMVGwAgYASNgBOKWQJeKHXhapKen68EHH9TMmTNVVVWliooKl3j83XffVWpqqkhY3ljJyckRYa7I68GNeksKQknEix21NQrlnVTNxv4uoTVhkjDYd3khPn9VsUvSWXtmlQL7R7gkn4Edw10YqFriW+edcMYbkfi4haW0OqCkrALN3pWtIUvT1Xt6sh4ad0AvzkvTZxsytTwpV1uP3VDC2UIdybmlzOsVyinyKb88qDJ/WAFb7NpC4ra5ETACRsAIGAEjECsETOyIlZnsnHGY2NE5nK2V+CQQDIV1s8ynlPOFmrEzSy/NS9GDY/d9H9pq73mdvFIqfzAyc73F54zZqI2AETACRiBWCHSp2AFEkpS///77Lo/G7NmzNW/ePJfDY8aMGbp8+bLOnj2rjIwMXb9+3YWhIsxVSkqKxo0bpyeffFI9e/bUe++9p82bNzfpBdJwsqJB7AjXVLm8Dy4p9ux/UuhSggsr0nAsXff/sAsJ4larXjus8M1Tkq/k+9BMLfCWqA2FVVYd0JlrpdqVcUML957Xu18fU+8Zyeo5PVlvL0vXpK1nnYcHN4TF5X75g7XO9de5C3cdAGvZCBgBI2AEjIARMAIRRcDEjoiajojvjIkdET9F1sEoJ8DzKs+72XnlWnf4ij5efULPzUzW87MOadS6U9p09Jou3Kxwic6jfKjWfSNgBIyAETACEUOgy8UOvDnw4CBs1WOPPeYEjNGjRystLU3FxcXavXu3Vq5c6TxA8PLA82P69On605/+pN/85jfudc899+j1118XIkZzSlSIHb5SBRLHy7/w16pZcq/CxdkRFXKJNSjVgZCKyn3KK6rQ9eIK3bhVrfxSv26W+VVYUaPiCr9I1IaYQWzSSl9Q1TUh+WpqVVUTVHFljc7nV+hA5k1N2nZW/eel6pFx+/XU5IN6bdFhzdiVrUPZuPn6FQiG3I0iUU2sGAEjYASMgBEwAkbACPyQgIkdP2RinzRNwMSOptnYN0agPQkQ2qrKH3SiBwnLee59dPwB9Z2Torl7z+vwxSLdKPWp0l+r2pB5e7Qne6vLCBgBI2AE4o9Al4sdoVDIharCcwMRIisry3lxIIKQTLy0tNR5bFRWVrqcHrW1tcrLy9OZM2eUmZnpXqdPnxZhrZoKedVwWqNC7KgqVM2m/vLN/5UCm19TuPx6w2F02f8RHKprapVxpVRLEnI0cu0pvf/tSX2y9pTGbj6jKd9lac7e81qamKPVqVe05dh17T6dp+SsAh29VKKTV27pSE6xlhzM0dDlR/XkpAQ9/MU+9ZqW7OrafOyazt4odYJJVY2XxLvLhmsNGwEjYASMgBEwAkYgKgiY2BEV0xQxnTSxI2KmwjoSDwQIjFAbcqGtDp0v1KRt59RjWpL+8sU+vTg7ReO3nFFiVoEKyv0KhWyFXzwcEjZGI2AEjIAR6BgCXS52dMyw7lxrxIsdoVqFii/Kv/wv8i+6T4Hkqd8nXr3zsDr0W9aX4F1xqaBSe07na+6ebH34zQm3GqX3zGT1nZuivvNS1Xduql6Yk6IX5hzSC7MPqd+cFA2Yn6Y3Fh3WW0vSNXz5Mb274riGLjuqF+emODfewUvSNW17ljalX3NiSEGZ390IduiArHIjYASMgBEwAkbACMQYARM7YmxCO3g4JnZ0MGCr3gg0QiDsEpgHlHm1VGtSr+jTdRl6aV6q+sw4JJ6LJ28/6xYLZudXOE+PRqqwj4yAETACRsAIGIE7EDCx4w5wuuqrsL9ctbmJ8s/7ufwruit4brvC/oou6k5YJA0/n1+uxHM3tWDfBQ1emq7HJx/U01MS9fqiwxq1/pTz5pi4/ZzGbDytEWtO6r2Vx/X20nQNXHxYry04rJfnparf7BS9MPOQnp2epD7TkzRo8RFN3HpWOzLydKW4WsFaW8HSRZNszRoBI2AEjIARMAIxQMDEjhiYxE4cgokdnQjbmjICjRCo9AfroiUM//qYekxNdM/ZAxakacauLO09ne+ew0urAgq1IC9mI03ZR0bACBgBI2AE4oaAiR0RONXh0isKHlko34yfqGZjf9UWZikc9HdqTwO1IZX7ArpWUqVdGXkauylTPacnqduE/Xpy8kENXnrUhanKvFqmkqoalfuDLi9HuS+o8uqAyqoCKq2qUUGZT5cLK3XuRpmO597SoaxC7c/M177MfJ27Xua28QeITRp2Scc7dZDWmBEwAkbACBgBI2AEYoiAiR0xNJmdMBQTOzoBsjVhBO5AgKV+PHcjelwqrNTmY9f18aoM9ZiWqIe/2K/eM5I1esNp9zx+tajK5f0IWoirOxC1r4yAETACRsAISCZ2ROBREMrLUM13w+Sb9t8V2POOwoEqKdzxicq4bwrUhsXKkZO5JVqRdEkfrzqhl+amqOe0JBeqCtFjw5GrOpFbomsl1aoO1N6RIDdw3JD5gyQlr3XJyklazst3l33vWLF9aQSMgBEwAkbACBgBI3AbARM7bsNh/7kLARM77gLIvjYCnUiA5/DC8hqdvlaqbceva+K2M3p5QZqemZaol+ak6NO1GVqddkVnbpSpwh90URFIfG7aRydOkjVlBIyAETACUUHAxI4InKbQpQPyr3hYvtn/oEDq5E7pIUnQrt/yKfFcoZYcyNEH3xxX7xlJemxigl6Zn6ZxmzO19vAVnbpaKrw3rBgBI2AEjIARMAJGwAhEFgETOyJrPiK9NyZ2RPoMWf/ilQALCs/llWtj+jV9uSlTL89L0eOTDurZmYc0al2GVh66pMRzBcrKL9etqkC8YrJxGwEjYASMgBFolICJHY1i6coPw6o9s1a+Wf8g//JHFDy9tsM6EwrJhZzKLaxSSnahFidc1JBlR12YqicnJejV+amasO2sS0h+/Va1ampDYvVI2FJrdNicWMVGwAgYASNgBIyAEWgtARM7WksuPvczsSM+591GHR0EXNSFYNhFU9jpwkqfVr85h/Tk5AT1mJakQUvTXf7LdWlXlHaxSGdvlLltET9qgh0fFSI6KFovjYARMAJGIB4JmNgRSbOOilBToUDaLPkm/XcFNg9UKDe5/XoYlnNzDQRDqvAFRdzPPafzNHHbWQ1YkOoSjhMfdMjyo1qScFFHLxYLkQNPDnJqWDECRsAIGAEjYASMgBGIXAImdkTu3ERiz0zsiMRZsT4ZgdsJEBKaXJqXiyqUmFWg2Xuy9ebSdD0zNVFPTT7okpo/P/uQ3v3mhGbuztL2E9eVea1UheV+98zvq6l1oapZtGg5zm9na/8zAkbACBiB2CRgYkckzWs4pFBRtmp2fSDfxB8pmDRZ4ZKcdu0hCdAyr5fpm0O5GrHqpJ6fmaxHJx5Qr+nJGrXulNYdvqxjl0qUd6tawVpbEdKu8K0yI2AEjIARMAJGwAh0IAETOzoQbgxWbWJHDE6qDSmmCfgCIV0prlJ6TrF2nryhxQcuulwe/eal6smpiXp0wgE9M+WgXl+UppFrMrRg30XtPpWv7LwKlwQ9puHY4IyAETACRsAI/JWAiR2RdCiEahW8uE/+tc/KN/VHqs1cI/nL29xDBA48NNIuFGt1ymWNXn9K/eenumRnryxI02frTznx43juLZVWB2zBR5uJWwVGwAgYASNgBIyAEeh8AiZ2dD7zaG7RxI5onj3rezwTwEmDyAv5pT4dv3xLW49f14L9F/T5+tMasjTdhbvqOT1Jz81O0ZtLjmrsxkx9k5yrE7m3hG3AwlLH89FjYzcCRsAIxD4BEzsiaY5rAwoe/Uq+JffJP/cnCl1OUGvvRGpDIVX5g8q75VPG5RJ9eyhX7317Qj2nJuqJSQnqPy9Vn2/M1Hcn83SpsFK+QK2CtWETOiLpeLC+GAEjYASMgBEwAkagBQRM7GgBLNtUJnbYQWAEopsAoakIc+UP8uxfq/wyn47nlmjt4Ssav+2sC3fVZ0aynpiY4MJejdmYqTPXSl3eThM8onvurfdGwAgYASPQNAETO5pm0/nfBP0K7v1Ivrk/Vc3qngrnZ7SqD+FwWKVVNUq9WKRJ2865lR0PjtmnR8Yf0OuLj+irhEs6fKHIhaqq8AdVa3c6reJsOxkBI2AEjIARMAJGIJIImNgRSbMR+X0xsSPy58h6aARaSoDk5GXVAd0s8+lSYYXSLhRpWeIlvTD7kLqNP6BhXx9zYav9wdqWVm3bGwEjYASMgBGICgImdkTKNIVDCpfnq2ZTf/nn/qsC+0YpfCu3xb1jZceNW9VanXpZw1Yc1bMzD+nFOSn6aNVJfXUgRwfOFii3sEqIHFaMgBEwAkbACBgBI2AEYoeAiR2xM5edMRITOzqDsrVhBLqOAGsaK/1BXS6q0qrUy3p7+VE9/OV+jV6XoYPnClRdUyuXuLzrumgtGwEjYASMgBFodwImdrQ70lZWGKxW6PpR+b9+VL6F9yiYsUrhqqIWVeZyc5RUa/3hyxqwIFWPjNuvIcvStXDfRR29VKKSykBro2K1qB+2sREwAkbACBgBI2AEjEDnEzCxo/OZR3OLJnZE8+xZ341AywjcLPNrU/o1DZibqicmHdQnazKUdr5QpVXYCMItq8y2NgJGwAgYASMQwQRM7IiQyQlXFTuBwz//V/Kv6Kba68ekoK/ZvWNFxrXiaq07fFU9pyeq+8QEfb7htDKvlbmYnHh82KqNZuO0DY2AETACRiDKCfDgHgqFVFtbay9jEFPHAMd1U8XEjqbItO5zWPt8Pt26dUtFRUUqLS2V3+9v0jDI9pWVlbdtHwj8hyGR76uqqlRSUlJXH997hfMW9ZeVlam4uNi9aJs6vXlnm5qamro22I762IfPW1JM7GgJLdvWCEQ3AWwBheU1Oni2QG8sPqyHvtinwUvSlXK+UJW+oOXujO7ptd4bASNgBIxAPQImdtSD0ZV/hsuuKnDgM/lm/h/VrH9O4fIbzU5OHgiGdKWoSssOXtJLc1P19JRETd2epZOXb6mypta8ObpyYq1tI2AEjIAR6HQCGAMxUGKcvH79uq5du2YvYxATx8CNGzecYRujNsd5w2JiR0Mirf8/fDl3bN68We+//75ef/11jRo1St99950TFhrWzPbMDw9XbP/aa69pzJgxSklJUXl5uduc99WrV7vv+/btq3fffVfHjx+vqwrhIzk5WZMnT9aQIUPc6+OPP9aSJUuUl5enYDAotjl8+LD7rn///ho6dKirb+rUqbfVVVfpHf4wseMOcOwrIxCDBFgAWVJRo50ZNzR8xTE9Mn6/3lt5TPsz83WrKqBQ6IfXlRjEYEMyAkbACBiBGCdgYkeETHC46Kxq1j4t38y/V2D3+5L/+4eiu3UvWBvW5aJqLT5wUf3mpurRCQc0adtZZVwpVa3drNwNn31vBIyAETACMUiAldGe0IHxMT8/317GICaOAYzvCHis5K/vEeD9jE3s8Ei0/R2vsG3btmngwIF65513NGLECA0aNEgffvihzpw547yF6reCB8bevXv1xhtvOAHio48+0rBhwzR27FidPHnSbYrYsWzZMlffE088ofvuu087duyoqwYRa+fOnZo4caITSr788ku9/fbb7rV161Z3DDPvW7Zs0b333qtevXpp/PjxQuhYvny5zp07V1dXc/4wsaM5lGwbIxB7BEqrA9p1Kk9Dlx9V9wkHNHT5Me3KyFNxRcu8w2KPjI3ICBgBI2AEYoGAiR2RMIuE2rh2SP6F/yrf/J8rcGShFKy+a88QOi7erNDyxEt6ZmqiekxN1LjNZ3ShoEI1waZDHNy1YtvACBgBI2AEjECUEmB1NeFccnNzneDR0rAuUTps63acEKiurtbNmzd19epVFw6p4bBN7GhIpHX/5zxCyKoJEyaoe/fuOnbsmGC/Zs0a57GxYcMGFRYW1nnXsD2CBqLD8OHDlZqa6rbftGmTnnnmGa1atcqFmEKoyMrKcvV9/fXXeuyxx5y44fUSgeX8+fPKzs524awIXYWAgncHYsuJEyecdwcCSe/evbVu3Tpv11a9m9jRKmy2kxGIegJhhVXhC+hQdqGGrTimB8fu05tLjmjnyTyX59M8PKJ+im0ARsAIGIG4JmBiRyRMf02VajPXyzfrn+Rf+YRqz++SQv8Rv7exLiJmXLxZqcX7L+rZGUl6ZmqSZu7M0vm8clUHLHRVY8zsMyNgBIyAEYh9AhgdWfWek5OjioqKOmNk7I/cRhgPBDB+Y4RHzOP4blhM7GhIpHX/J1wU3huEoXr11VeduERNiBh4ahBm6vTp03V5NBAptm/f7jw2Fi1apEuXLrmG09LSnNgxb948l3+D+cPzDMEKwQTvDjw5vML5i+95eSU9Pd15ehDyir/pG2IHIsrSpUtd7g48RhB2vbwe3r53ezex426E7HsjELsEyOFRXh1QUlaB3lt5XN0nJOitJUed4JFf6hMhr6wYASNgBIyAEYhGAiZ2RMCshUqvKZA0Sb4p/1OB7W8pVJglhZv2zAjWhnThZqVm7sxWr+nJenzSQS3cd0FZN8otzmYEzKd1wQgYASNgBLqOQH2xg5XYVoxArBFA5MCYbmJHx80swkFiYqI+//xz51FRUFDgGjt79qzmzJnjQlkhFHjiAmLHypUr9corr7jQV972CCIvvviipk2bpsuXL9eJrwhWGzdu/IHY0diIEFHIyzFp0iTRPmIHeUR+9atf6YEHHnC5O7744gshrFBvSwriSbdu3bRv376W7GbbGgEjEEMEKvxBHblYpE/WnFT3iQnqNydFG45cFYKHFSNgBIyAETAC0UjAxI4ImLXaGydUs2WQfFP/TsGkcQpXlzTZK38gpDPXyjRnd7Z6z0jWs7MOadbubOUUVCoQtNUXTYKzL4yAETACRiAuCESj2IGhtLi4WLt27XLJi0lgjOGUMDeEvyF0DqvAydfA+O5W2IZQXoTCIfxOVVXV3XZx37PPgQMHnFdMs3Zow0aMmVBMGFnJRUDyZSvNI2BiR/M4tWUrPCsIH4VnBy9CVlEIMbVgwQKXWBwxpL7YQc6Ml156Sbt373a/Z7bPzMx0niGEt7pw4ULd9uT3uJvYQcgr2iMnB8nR9+/f77zW+O0gUpA75K233tIHH3xQl1MkISHBiSFNnSf4jSPAkIuEEFjkBCH3B322YgSMQHwS4K6CqBFpF4o0at0pPTRuvwZ+la41qZeVd6tahM62YgSMgBEwAkYgmgiY2BEBs0XYKv/X3eSb+1MFTy6Van8YwgrbRnVNrc5eK9Pc3efVZ3qSek5P0pw92bpSVCm8PawYASNgBIyAEYh3AtEodrBS++LFiyKh8QsvvKCnnnpKv/vd7/Sb3/zGxfTnM1aMHzlyxCVFbsqQ6c09BliEBELdEObGM9R63zf1jpjCCnEMph1dWDmPsbdnz5566KGHtGfPHheGp6Pbbar+uzFtar+u+NzEjo6njtiB8Idnx6effirPU4ME4HPnzm3UswNx8uWXX9Z3333n8gXRS4QFPsOzA28c7zi7m9iB0IEnCF4k5AAhbFZRUZETS/h9cwyQqJ7fNr9bvD8efvhh1w6ChifCNCTFeQExdciQIerfv78ef/xx/du//dttobQa7mP/NwJGID4I+AK1OnqpWCPWZOiJyQf1xqLDWpN2RTkFFS5MdnxQsFEaASNgBIxALBAwsaOrZzEcVvDEV/LN+T/yr3hEtRf2SKHaH/SqNhTWmWulmrztnB6bmOBydCw9mKOrxVWyxRY/wGUfGAEjYASMQJwSiEaxgz5jXL1y5YoTPRAp3nvvPb399tvOMElCYwylXlguz2B6pylGTCCkDQZSVoI3p7DPjRs3RPz/ji54m5D8+Sc/+YnuuececUOKIbYpI21H9yea6jexo+NnCwHy6NGjTuzgd5ifn+8aJUH4lClT3Od87x2vvK9fv15vvvmm88RCiKCwfY8ePTRr1qw6wYTP7yZ2IGB8++23TgxEKOH/d/odI5Y+//zzzlODv+l/Y4XfOOcEzid4jeA19qc//cl5sTS2vX1mBIxAfBFgceX5/AqN2XhaT0w6qCcmJWjGrmyduV4WXyBstEbACBgBIxDVBEzs6MrpC4cUqi5SIGms/LN+oprtQxTKy/hBvg5uOo7nlmjy9rPqMz1Z/ealasnBi7pUUKGAeXR05Qxa20bACBgBIxBhBKJR7GiIkNXjrOTGy2L+/PkulBVeEIsXL3aeGqwcP3XqlLZs2eLi+BPLH4MoYW4Ih4Whk7BQrEwnYTWr0km2vGnTJn3zzTciWTKhcVg1jhcHCd0p7INRltj/GEVpg3Ba9IF9aIe/MfLCmRfiCOG36C+hepYtW+aMtBhqES8aK/SPkD4jRozQgw8+qEGDBumzzz7TwYMH64y0Pp/PrYpnzBiXCbdD3Qg/rHonwTPjZdwTJ07UzJkzXagvjMwYmAn7dfLkSVVWVrouYNylDbxjEAsILwSLhQsX1o2PscCeNhkPYsySJUvceD0BiH7Bhc9hCBM4EjLs+PHjrj+MzTM2w5YV/4Tq8upojElLPjOxoyW0Wrct4gXHA8cdYgW/H+aU8E/kzyBkFce3JzyyPTk8CHnFccaxx/b8Np5++ml37NYPJ9eU2EE9/F4RIRBOOLYJRef93hgNv02ET0/8oJ2MjAznBTZu3DjXb++7u40+JSVFjzzyiOXsuBso+94IxAmBsMJww/K8AAAgAElEQVSqqQ3pWG6Jpu/M0rMzk9V3Voo+33Bae07nq7jcbzlC4+RYsGEaASNgBKKZgIkdXTl7oaBqb55SzdZB8s/6qYJpsxUqz5fqxeNGzMi5WaFpO865m40+s5K1OOGirhUTf9viZ3bl9FnbRsAIGAEjEHkEMApiYM7JyanzhKj01brcVqeulOrk5Vud8sq8Wqbcokr5gi0PM0kSYozoiB3vvvuuywPw6quvOiMrn2E8T05OdrkDBg8e7IyihMrBMMvnGEIJn4PBnlj/CAQY2zGeEhKLdz7v16+fi/WP8R5u7HPfffc5AQDDLCvVMfQ+88wzbjv6gOF29uzZjjHeKAgv9JGQOPSFHALPPfecS8qMKNJYQYBgP3IOIHgQauu1115z3h3USYEBQsSAAQNcX2l77NixToghTA9Cx8cff+zyITCWYcOGOcGD1eqIGPQDg7EXwguj7o9//GNndEYoQfhhbM8++6zrxyeffKLc3FwnhowaNcqF+XnjjTccK9pltTyF42r69OlOoKFPsHznnXecQRrxqXv37k6EYvU8BaZwHj16dF1oI/dFG/4xsaMN8FqwK6ICAhvHCAIYQgfHAsc5xxPeFhwzvCOC8c4xx3FDqCt+c/yOCRmFqIiQgVCHoMbxT3gsQtXxm0agQ2zkt0H+DMLWEcpuxowZLsQUv2uOJby1ePE34iCCJoLKokWL1KtXLyfC8dulreYUBBoTO5pDyrYxAvFFgKgSZ2+Uad6+C3p1QZqemZKowUvTtfX4dRdCmxwfVoyAETACRsAIRCoBEzu6cmaCPtWe2yb/8u7yzf+las/v+EG+jptlfm08ctW5kPaZmaxliTkqqqhRqJ4g0pVDsLaNgBEwAkbACEQSgcbEjuy8crdCcfCyo3pt8ZFOeQ1feVwL9l9QfpmvxXjqix0Y0hEPMGRi2MSQiWGVleGsAMdAiiF+586dLlEx3gZ4d+C5gKEVEQGxA0MtyZP79u2rpKQk592AKEAIKb5jdTgGVJIVk4CZdvDOuP/++11ILfIHEGYLQy8iBR4SrHznb/rHynL6gycIfSWkTlNiB9uxYh2BgVwdGHoRURAEEDJYlY4HCUZjBA88JegPnhFeCB6Mzgg3eFMgbsEDYYNtVqxY4frZUOz427/9W2e8pn2SMzM28qQQoggBgUL7rNhnbIyXfsAE9tSNoIH4wzhpj3bZH4GJviCU4OHC2Klz8+bNThjhhpt5a49iYkd7ULx7HQgGCBN4O5EP49///d/d3HNMIpjhAYWHB8cZ/2d7xDZEOASEX/3qV+63wTHAb5LCsYrHULdu3VwIt//23/6b/vEf/9GJhQggHHd4h/z85z/XP//zPzvxkTBT5NZAGOR3xjaILxyHv//97/XHP/7R/Y33Fb91zoHNLSZ2NJeUbWcE4o9AbTisMl9Au07lafiKY/r96N3qNT1RSxJydKmg0iU1jz8qNmIjYASMgBGIBgImdnThLIX95QqmzpZ//r/Lv+IhhW7cvgKSZ5XkrEK9s/KEi5k5Z895XSmqUsCSdHThrFnTRsAIGAEjEMkEmhI7pu44pze+OqKXF6Z1yuvtFUc1d9955d9quYG7vthBcmLCPOG1gSGTghiAQR4jK4ZVVo6/+OKL+sMf/uD+xpjfUOxglTnhdxAJMMhSEEgwpBLqCgN6Q7EDQaBPnz7OkwNjPsZ+VqEjUiCQEF7n/fffd7lFECEQTA4fPqyRI0e6pMzp6emunYb/IM4gwiAMEF4KbwnGyFiok7b4G28RjM31RQLEiH379rlQQRiFGStzjqEZLuzbHLGDsGCs2EfYqW8chgFGY7xVyNWApwZ5RRB+EGW4caavrLSn0C7jpg4M3his8SrBK4axwQsBKjU11a3qb8iiNf83saM11Fq+D3OKyMY84kWBxwUeHQh/eH0gYODZwW/R80hie357iYmJzuMCQQQxjGOEgmcHv2/q41jhd8k72yFccqzzPSIg7eHBhNBGfXhg4dXBNvxmOAb5LbANogV9of2WFBM7WkLLtjUC8UcgpLAKyv1KyS7U1O/O6blZh1y0CcJa7T9zU2XVAVuEGX+HhY3YCBgBIxDxBEzs6MIpClcXK7BzmHzT/141W15VuOT7EAl0iZUUt6oCWnzgoh6fmODcRlPOfx8SoQu7bE0bASNgBIyAEYhoAhgoG4ax4kH94LkCrTtyVatSr3TKa9PRazp0vlAVvkCLedUXOwjPhHcHoasIk0PB2I2HAWFwMMhj9Ec4eOihh1zYJ4yrjYkdeDHgqYBxlkJoHVaYY8jHcFtf7CCcDoIAIaJoGyGBz8iNQU4C9mF/PDsQNzwjK14YrIRHzGhM7MBQi3GW1eislvdyk/zlL3+pC8PD/CEY4ImCeFG/ILggznz++efO64P/1y/U74kdbFc/jNWPfvSjujBWrLYfOHCgq4v9GR9eGuxLaCp4IlIQRotV9qykxwBNCC+EGPg2LBi0EXIIb8V2GKsRoVavXu2OSYSR9igmdrQHRasDAiZ22HFgBIxAcwj4A98nLl+4/4JempviFmIO//qY1h+5qqslVc520Zx6bBsjYASMgBEwAp1BwMSOzqDcWBsk9rx1STVrnlb1tP9PgcQJCpfn1W1JHMy0i8V6b+VxdRu/X8uTLulqye0P/HUb2x9GwAgYASNgBIyAI9CY2BFtaBoTO1atWiWSb1NYAY5wgdEd4QCDP94aeBxgnOf7psQOQvB4ogkrxhE7CGfVmNhBXgsEAUI2NSZ24K3w3nvvOTHGEx1IzIz3CP1oKHYwN6yKRwzBo+SXv/ylE2gQOggphQCCeEOYHupF7CCUFG17hXZYCU/IK8IBIVDUL6ywhxX1INLgccL+5DX4L//lv7icBnhgIHYQkgvvFQoiCX2HKZ4yiCSIE3hokMeEG2ZW4+MJwvcNx+b1AY4IJXi/8CIvCGHD2rOY2NGeNOO7LhM74nv+bfRGoKUEiiv92nj0mgYvSddjExLUa0ayliTmKDuvTL5A+wj6Le2TbW8EjIARMAJGoCEBEzsaEums/wf8qs1JkH/Zn+Wb9wsFM9cp7CtzrWMMKK7wO1fRZ2cm641Fh3X6aqnFxeysubF2jIARMAJGIGoJxKLYQUilhmIH8fvx7MB7IDs723laPProoy70U0vFDsSMlogdCA2IAHgx0A8ScBPiCTEGLwZECjwaCElVvyAeEAYIkYHwToTRQtg5c+aME2cYD+IAQg2JmRFv8LRgfHh70EdECP4/btw450FBG4gXhLPiHSFg7969rl9sQ+gfvE3Io/Gf//N/dqJFY2IHHiRezg1ChxEmiPBFCCr/43/8D+cRQ7t41JArBM8WOFMX4hFeLxTqQSQiBBf5UBCl2K89i4kd7UkzvusysSO+599GbwRaSoDE5beqapR6oUhTtp1Vz2lJ7vXFpkylni9WUaVfwVoTPVrK1bY3AkbACBiB9iVgYkf78mx+bdUlCqQvkm/uL1Sz/GGF8jLqkpNX+oM6nluiAfNT9cKcQ1qw/6JKKmuaX7dtaQSMgBEwAkYgTgnEgtiBsZ8cHYgKhFTCk6B+GCu8GzC2E2KKJMXk4iDUFcZ18lBghMfITx0IDwgKGODZZu7cuXVhrBAF8KZYtmyZ84Ag+THeFnPmzHHGewQNPDT43vPsQDRA4CBEFAIDoa4QJRA8EDEIP0US9FdeecUJIPUPQ7wu6DdJldkfb4r6hXZ69uzpvC0QQggFRV2EhSIsFuMhtwF5C/DuYNwvv/yy48DY8BhBoGD8S5YsUe/evd346S/iw3/6T/9JixYtcjkUNmzY4OpEnKEQggoxhbE/9dRTrk1ED/rz05/+1IXMQsxB4KEfjA82jBkxioTkHHsIOnivkFz9X/7lX9w4EWras5jY0Z4047suEzvie/5t9EagtQT8wZDO3ijT18m5enFOih6dcECDFh/W2sNXdM2iUbQWq+1nBIyAETAC7UTAxI52AtnSakJlV1Wz6wP5Zv2Lajb2V7giv66KnIJKkYycXB0jVp/Uqaul8gf/I4RD3Yb2hxEwAkbACBgBI3AbgVgQOwjjhDEfLwK8LhAIMPJ7IZsQHjC6Y7j3cnYsXbrUeSEQpgoxAG8D6uBGD+M/XgskNCfPhmd8RwQhZwbeFngmkMuD/B+Et0KIwGsCAYLvMeIjVuBJgsCBcZ99MOwjHHhhm0hYjvhBLg88NuoXkjOTaBkPDsSYhoU6ESnoI/XiLTJp0iTnHYGwMX36dCHIUA+Mtm/f7oQXxAZCR8GAzynkH2FfwmFNmzbNCScIECR1Jsk5PPAaOXLkyG3dgDPeHNRJOK6JEye6ejAKwxUG9HPKlClCDGGcMKM9r5AzhXbJocI4YdeexcSO9qQZ33WZ2BHf82+jNwJtIYCXR0GZX+sPX9XQ5cfUbcJ+vbowTQv2XXD2i3JfsC3V275GwAgYASNgBFpNwMSOVqNrw45hKVRwVv5VPZxnR+DAaMlfpjArC2tD2peZr37zUtVzRpK+TrokVk6E+NKKETACRsAIGAEjcEcCsSB2IGYQDokXggIvjOz1jeZ4ImD0RrjACM82GPH5jO28Ovg/f9fU1Lgk4vXrQTTAS4TP4MZ2nkGf/7OP1zbQ+QwRhGTkfEc7eHcgaiAAIIqQwBxDPzeYXo4Rb8LYn7Zog7YblvrtMT7+z5gQeRgnfWU/r6/w4TteHgPGQGE7b1/244Xnhjd+ry3e65f6bbK/9/L287jwOX3y2qY92DBmvFIQfT744AMX5qp+/e3xt4kd7UHR6oCAiR12HBgBI9AWAggeZb6gkrMK9fmG0yIEd5+ZhzRybYYOnr2pG7eqv8/lYbaMtmC2fY2AETACRqCFBEzsaCGwdtkcg8K1VPnm/6v8Sx5Q7YmvpUC1WPd3tahKs3dl6y9f7NNnG07p6KX2DX3QLv23SoyAETACRsAIRCgBjNEYocm5gDHcSscRQFjwPDWefPJJPfzwwy7hOZ4beI0gWMRTYcx4k3Tv3t15fWBI7ohj0MSOeDqqOnasJnZ0LF+r3QjECwFfoFa5hZVamZyrAQvSdO+oXXp+5iEt3H9BF29WKGwrN+PlULBxGgEjYAQigoCJHV0wDeGqEgVPr5F/1j+oZl1f1eYmS7U1CobC2nb8ugZ9dURPTTmorceuq6jC3wU9tCaNgBEwAkbACEQnARM7Om/eYE2OjF27drnwU4TVIrdIamqq8wjpvJ5ERkt4uRw8eNAxIBQXXh+ep0l79tDEjvakGd91mdgR3/NvozcC7UkgFArrSnGVvjtx3S3a7D0jWX1nH9Ln609rx8kbyi/zCU8QK0bACBgBI2AEOpqAiR0dTfgH9YcVKsxS4OAX8k3/iQJ7RyhcekVB4k+X+PTF5kz1nJak9789oawb5Qrb/cAPCNoHRsAIGAEjYASaImBiR1NkOuZzeHthszDs86ofbqtjWo3MWuuz6EgGJnZE5vxHY69M7IjGWbM+G4HIJYDtotIfUOa1Us3adV6vLEjTk1MOavDSdK1KydWZ62Uqrbo9fGTkjsZ6ZgSMgBEwAtFKwMSOzp45QljlJqpm/UvyTf9fCqbPJwq2SqtrtCMjT/3mpKj/vFRtP5GnW5V2I9DZ02PtGQEjYASMQHQTMLEjuufPen93AiZ23J2RbdE8AiZ2NI+TbWUEjEALCYTDKq0KaN+Zm3rvmxP605i9enDMXn22/rRSzhfJFwjaos4WIrXNjYARMAJGoPkETOxoPqv22TIcUi0hrBbfL9+ie1R7dqOr9+LNco1af0pPTD6ozzac1pWiSgVDZPGwYgSMgBEwAkbACDSXgIkdzSVl20UrARM7onXmIq/fJnZE3pxYj4xArBAgrBUhuY/nlmjxgQvOy4MIFkOWHdWihBxl55WrqqbWRI9YmXAbhxEwAkYgggiY2NHZkxEKKJg6Xb5p/1P+NX1UezlJFcGwi2PZZ0ay+s1N0cb0q/IHaju7Z9aeETACRsAIGIGoJ2BiR9RPoQ3gLgRM7LgLIPu62QRM7Gg2KtvQCBiBVhKoDYd0tbhKG9Ov6aNVJ9RnZrJ6TE/WhK2Z2peZr5tlPlnk7lbCtd2MgBEwAkagUQImdjSKpYM+DIcVri5RcPcHqh73Nwrs/lihgjM6m1+tsRtPq9u4/Zq07axyCioUsmQdHTQJVq0RMAJGwAjEMgETO2J5dm1sEDCxw46D9iJgYkd7kbR6jIARuBsBPD1OXSnVtB3n9PSURD3w+R69uSRd6w5fUU5BpW5V1cgfDJnwcTeQ9r0RMAJGwAjclYCJHXdF1I4bhIIKXT+qwIb+8k35sYLHvlJF0VVtPnZDL8w+pBfnkqvjhqr8wXZs1KoyAkbACBgBIxA/BKJR7PD7/SotLRXvDRNbB4NBVVVVqbKyUvx9p+Lz+dx2gUBAcKipqVF5ebnbj/83LCQTr66udvWzT3MK2/FiX69O+kU9jfW/OXW2ZBvaZJzwKisr+wGvltQVrdua2BGtMxd5/TaxI/LmxHpkBGKVAHchhK26VFipnRk39P43x/XsjCQ9NzNZI9ZkaNnBSzqUXajcwkqXu7TKX+uiXQRD4RYLINwr1IbCCtSGXB20i43FF6gVoosVI2AEjIARiG0CJnZ04vyGg9UKnlgp/1f3yz/9f8qfk6DTuTc1esMpPTEpQdN3ZCnnZoXFrezEObGmjIARMAJGILYI8IBbUlKinJwcZ4CPhtGlpqZq7NixSklJcUb8+n2+ePGiNm/erCVLlujSpUv1v/rB33v27HHbnTlzxo2demfMmKHc3NxGhZK8vDxt3bpVGzZsUGZm5g/qa/gBosaFCxd07tw5FRQU1Iko9Gvjxo3CcFpYWFgngjTcvz3+j+izb98+x2vixIlO8GiPeqOpDhM7omm2IruvJnZE9vxY74xALBJg7UW5L+Byeczbe14DFqTpkfEH9NiEBL0w65CGrTiqiVvPak3aFR3OKVZ+ma/FGJBH8BS5cLNCKReKtPnYda09fFXJ2YUucXqLK7QdjIARMAJGIKoImNjRmdMV9Ks2a4dqvhuq4JZXVHbjgr5OzlXvGckaMD9NyVkF8gcsKXlnTom1ZQSMgBEwArFFINrEDvr73XffqU+fPpo+fbrOnj1724Rs27ZN77//vj7//HNlZ2ff9l39/1DPzJkz9dprr2n//v1OBDh8+LDmzp2rK1euOE+M+tvzN8LF+PHjNWrUKCGUUMedCh4ViBqrV6/WqVOn6gSUy5cvO9GE9oqKiu5URZu/Q2T5+OOP9X//7//VQw89pNOnTzuPkjZXHEUVmNgRRZMV4V01sSPCJ8i6ZwRinMCV4kptPXZd4zZnasjSdOfl8djEBD0+OVEvzDnkvD/m7D6vTelXlZxVqDPXy5RXWq2qmqDz2ij3BZVf6tPFm5XKuHJLKeeLtPd0njYcvqJF+y+4et/5+phemp+m5+ek6MNvT+jAmZu6VY0HbIzDteEZASNgBOKYgIkdnTn54ZDL2RG6eVo1l9N0LjffXXC7TzygKd+d07Xiqs7sjbVlBIyAETACRiDmCESb2MEEIHAgdLz99ttOdPAmhZBWs2bN0quvvqrdu3c7cQJh4fz58+7va9euOVHDEykQNt58800lJCS4z/Pz85WRkeFyPLANYa1u3rzpvF7wfGE7RJTPPvvMeUvguUF4qKtXr9a1QXuEiyJsFfuy7fDhw7Vs2TJXN140vPBAwVMEQYRtMcgjstBXvqNOvDIohMHi/9R9/fp11x+EHOqnj00VxkBdzz//vP7t3/7Nva9Zs8bV5e3DGIqLi50XDGIO9Xr9Yn/CbcHFY4hXCt4ohOBCSOE7+u4xvXXrlrKystx+9JuxMi76DkPGQZuIPNRFm9TNuKjHC0vGvl6/6jOBF+1SJ33w2qWfeOQwH/CsX0zsqE/D/m4LARM72kLP9jUCRqCtBIKhkKprgiqu8Cs7r9wlLF+4/6I+WZuhVxakqc/0JPWYmqie0xL12qIjLiLGssQc7T9zU6nnC7XzZJ5WJF7S5G3n9PHqDA1ckq7nZyer17RE9ZiSqN7TEl2orH5zU/TcrGQXTWPE6pNKOFegCgsd3tbps/2NgBEwAhFLwMSOrpiaUK1Kyiu1MinHXbhfnpeqlPOFLoZkV3TH2jQCRsAIGAEjECsEMBZHWxgrRICDBw/q8ccfFzdmFAzcGNo/+ugj9evXzxnXV6xYoddff12PPPKIunXr5kSHXbt21Xk21Bc7yNWxfv16ty9eGNSHYX727Nnq0aOHHn30UT333HPq37+/PvnkEyd20B4hsxBd8Jro3r278xRBaMGYn5SU5Nr++7//e/385z93faBPBw4ccB4ia9eudW0gjhCS66233nL1PPHEE847Bc8PCkLAu+++q0GDBmnEiBF6+umn9ac//UlTpkxx+zc07rud/pqYm7ZeeOEFvfjii06o+fDDD3XkyBFvEzf33377rduGMT7wwANuOxhwbJw8eVKEv3rwwQfdWJ599lnNnz/fiSi80wcMwIgTFDxZ6Nvx48edaMIYGdfAgQPVq1cvNweIJYQZQ4Tx5oZxwQAxg4KQw7548PzlL39xc009hA9j3gYPHuzEDU8cOXHihAYMGODaR9yoX0zsqE/D/m4LARM72kLP9jUCRqA9CXCNJqdGSWWNrpdUK+tGufaeztfcPec1dMUxPTU1UX8YvUf3j96jh77Yp0e+3K8Hx+zTH0bt0T0jd+lPY/eqx/Qkvbb4iEauzdDsPdnamH7N2Vku5H8vpLzx1RH98fO9+mz9KWXlV7i8Hu05BqvLCBgBI2AEIoOAiR1dMA/B2rDOXi/TsOVH1XNakqZsP+fcL7ugK9akETACRsAIGIGYItCY2BEuz1Mo6zsF0xcpeHhu57yOL1Powl6FfbeaxZfV/n379nWGeLwLEB4QFxAFCDPF/9PS0vTNN984QWTOnDkaOnSo87TAowDj/Lx58+o8OxA7FixYoN/+9rfOeI/3AEIGXiKffvqpFi1apJEjR+rhhx924gZ5MEiEfvToUSeScINIWKx33nnHeZ0gVOAl8sYbbzgRZMiQIc5Ij9BACCwM9xjt8Ww4duyYPvjgA/dCPEBcwHBP//ge74zevXs7wYXvyCvC/uyDINDQuO8BZJy0wXZLly7VqlWrnLiwZcsWtwn9R5xAaCD0F/2HE2HC4IvgMG3aNCcsTJ061dW1ePFi5+GCF8Xo0aP13nvvOS8az8MEDj/60Y/cXCAWsd/999/v+gBDmCJWJScnuz5RH944w4YNc3ODsIPHBv3iMzxp+B5hZeXKlU7cYZ9XXnnF9RPvD+rbtGmTE4F49wQTj4OJHR4Je28rARM72krQ9jcCRqAjCZRXB3WxoFKp54u05eh1Ldp3UWM3ZGrosqMa9NURffDNCReqat6eLK08lOtCYiWeK3D5QC4WVKiw3C9/8HvvyLKqgPv+hdmH1Gt6kmbuyta1kiphm7FiBIyAETACsUXAxI4umE/iSq4/fEXPTEnU28uOaf+ZAvksV0cXzIQ1aQSMgBEwArFGoDGxI5R/SoFdH8u3/BH5vvpjp7z83z6jwIGxCpdebRZiDPEYwj0vC0IkYVjH+I4A4IU1QvAgJwcGfvJz4JmQmJjoDOQY0L0wVogdGOPvu+8+Z4jHowHhAbGCxOWEXtq7d6+efPJJIVwgdmCUJ5wSggchrkhcTvvUSZ4OjP2IE4gk27dvrwuxhAcDhnzEDEJyYdjHm4N9MN4T8oncIIgQfEdoKc87g3YQd2gfEYYXnhKNlfT0dCfMIGDQDgLDH/7wByf+IACwH/3lhVCEhwnjRCyAL/1EIPLEIz5HWIAtYhAhuvAUQbzxxA5ElR//+MeuLcKGTZ482Xlm4DXD/tRPQcChP4wDAeTll192DOgz4//iiy+coIGHCO3xon8wZz7GjRvnGJH8nbBZCCL0hf05pusXEzvq07C/20LAxI620LN9jYAR6GgCXP1C4bBCobATJSqqgzqfX+Hyd+zLvKljucXKLapUeXXA5fCoDYWdt4bbJxy+LS9HKCzdLPNp8YELLh/I87OSte7wFV0rqb5tu44ek9VvBIyAETACHU/AxI6OZ3xbCzyvJmcXaujXx/TYhANalpCjsuqgQpaX/DZO9h8jYASMgBEwAq0h0LTY8dFfxY4H5Puqo19/lP+blokdGN0RFwghhUEd7wgEAQz3hDrCKL5jxw4nTOCt8ctf/lJ/93d/57wMPFEBT46GYsfvf/97J4bg3YAxH88GvBgoZ86cceIK4gVGevqAcII3x+9+9zv94he/0D/+4z+6UFB4SSCE0DfEAsJn4UkBb0/swOuCv8nnQZgpDKkUhBcEGsQO2segz/fUg8iAaIDnBQZ/PDwQPxorjIHQWggm7ENoKrxh6BN/0z9CS02YMOEHAgEeFog/tAmvhgWh5G5iB2IPY8Q7xgvJRT2EnmLu+PzXv/61m5u//du/dUITnhmISghZY8eO/YGQ4x2vCFowIZwZSemZAzxXbty48YOxmNjRcPbs/60lYGJHa8nZfkbACHQVAQQQbCoIGg3WAty1S4gh+WU+zdmd7cJg9ZqRrO0nbigYvH1RwV0rsg2MgBEwAkYgogmY2NGJ08MFmRiUXyVc1OMTE/T2imNKzi6Su2B3Yj+sKSNgBIyAETACsUrAMx7jGcHqeUrYX6bQzTOqvZqi2suHOuUVunZEocJshQPf9+FuvMlTgbcCeSzI/YDxmxweeERg/MergNBMGMERPfCsIMQVeTcwiiMaNEfsIBG6J3YgoiB04E2B2MHneHkgCGCkx0Phyy+/dF4KnkjiiR07d+504khDsQPjKWIHeUbqix3k2qgvdvD9mDFjXHguhBw8IxA7EGsaih2wwehP33/2s5+50FuEfSIU1r/+67+6dwQMT+zA+4R+1S/sv3DhQheqiqTmDQs5SRAjyJGCkINnB3UQYqp+GCvPewYxioJABDow1jsAACAASURBVEc8cgivxb6IMowD7xZEEFg1JXZQB94hiBx46pADBS6MDy8QL3dI/f6a2FGfhv3dFgImdrSFnu1rBIxAtBHg1iBYG9LRS8Uu/FW38fv14bfHdeDMTdXU2urTaJtP668RMAJGoCkCJnY0RaYDPg/UhpR2sUjvf3Ncf/lin5YnXdL1W80zgnRAd6xKI2AEjIARMAIxR6AxsSNaBknIJwQBckIgauClQF4HEq6fPn3aeXogRDBGcnggRDz11FMuj8edxA5COuFxgZiAQR5RhYJ3AgnKaQuxA6M9ybgRNPDawNsBTwY8DgipRTgmBAdyW2DQx7uCUt+zg3BZiC8kHWcbjPWMiwTeH3/8sRNCPM8OxIXS0lLnteKJHYg9DcUO6iDcFV4uiDuEzKIPiDSMh1Bc/B+xA8EA4YH66ic6J4wVHhPDhw93Y/G+gyUvxA4EHepDaKJNxg+z//pf/6vzeMGzA0EJQcgTOxgbnhuEB0NkobAffYAlYgd5TRA72A8Rziv1hQxCV+FZwjY9e/Z0c4JA01gxsaMxKvZZawiY2NEaaraPETAC0U6grDqgpKwCDVx8RM/OTNZn6zN0Lq9cvprv83tE+/is/0bACBiBeCdgYkcnHgG+QK02pl/V0BVHNfCrI8q6UaYgwSOtGAEjYASMgBEwAu1CIJrFDjxRli9f7ozkv/rVr5xhnpwNCAKIHaz2x/PAyw+BCPGb3/zGCQgY2PE6GDhwoPCiIHQUngyEo8KgiVCBlwI5PjDmY3SnLXJ6vP76685gjwiBNwmeBfyNSIIR/8EHH9SkSZNczg5yWCC4IIIQOgpjP6GvMNLzGfWS8wKDPcII+T/4Hk8HxA3yU5CzA+8VBABP7CBxOXktaK+h2IHwQg6Ll156yXmc4E3hFUJIEfqLBOj0GcGBvBzkD0F4oV7GjnBAgnOEEgQVxAoEBoQfRBLGgTCB2MH44Y1HBm3+zd/8jfO8QOyA8eDBg9246ANCFLwZP2IF4bgQjvr06eO8TvCQycvLc/1HqKENRCX6ShgxxkYhf8e6detE2LF7773XiUN81lgxsaMxKvZZawiY2NEaaraPETACsUCgtDqgDenX1H9eqp6anKD5+y7oUkFli0NjxQILG4MRMAJGINYImNjRiTNKGKvCcp9LpJV4rlCsKLCraSdOgDVlBIyAETACMU8gmsUOQifhBYCx/o9//KMQFhAxCHOEeIF3BeGfeCEeIHYgDmAkZzvEC0JdYcDEIE5IpEcffdQZ5jGqnzhxwnlA4M2BcILRnzwTiA4IEniHIFjgHYFhnjYw4iOGkBSc7xEQ8HbAowSBwctJgQhD+CoEBUJu4d1B/g1yatAeAgGhtxAqCJeFKEPCdC9JN58hjuC9QTv1C4IIQgJ10b6XFJy5xkODfCKIFIgMjJ2+0iZCBXlP+B5hATEJbxO8LhBb2AahBO8Z+OH9gZjB2BkbniMw/ulPfyoSw5P3gzEy1oyMDNdF+oJXCHlCvP2oE7GD9vH6oP8IHDNmzHD1UieMEY0QWiiMhbBV5CShz4gx9T0/6vMwsaM+Dfu7LQRM7GgLPdvXCBiBaCbAotOiihotPpCjF2YdUq/pSVqTeln5ZX4z0UTzxFrfjYARMAKSTOzogsMAD48KX9Al1eqC5q1JI2AEjIARMAIxSyCaxQ76jmEcbw5CLiEA1A+3hDcAXhPr1693eTtI+k0oKrbzknzzfzwjMJTjZUAOCYzx1I2RHCM9dSNSUBchqBAQ8D5gH8QKRAO8P8gNkpyc7AQExALaoA62x0OBnB54RuDxgEhDe4gy1EMf8Hhguy1btjgvEc9jA8GDevEMQeBhjNSLNwWighceyztIyenBuOhXY94OeGjQPh4c8MNzhL6TyJxxUCcMKLzjbYJAxPeIH/TDa5Mx8Bl8EIBgzBgQYOg339MWniBewbuEvntt7t6927HFkIxHCTy8+UHwYf5gB5/640HgwPMGMaZ+/V473ruJHR4Je28rARM72krQ9jcCRiDaCWTnlWvWrmz9eew+vbH4sEtYXhMMmeAR7RNr/TcCRiCuCZjYEdfTb4M3AkbACBgBIxBbBKJZ7IitmbDRNJcAQhOiCqHCCLOFuIJA0lQxsaMpMvZ5SwmY2NFSYra9ETACsUagNhTWqaul+uDbE+o+MUHDvz6mIznFqrb8HbE21TYeI2AE4oiAiR1xNNk2VCNgBIyAETACsU7AxI5Yn+HYGh9eLXh0EBqM0FaEySK0lefR09hoTexojIp91hoCJna0hprtYwSMQCwRCIelcl9AaReKndDx+OQEfbo2Q6evlipQG2r2UGvDYeER4g+E3H6WmrXZ6GxDI2AEjEC7EzCxo92RWoVGwAgYASNgBIxAVxEwsaOryFu7rSHA8UroL0KREX6LMFsIHXzeVDGxoyky9nlLCZjY0VJitr0RMAKxSIBLboW/VluPXdeA+al6+Mv9mrkrW9dKqps9XF8wpBu3qpVTUKmCcr8CoeYLJc1uxDY0AkbACBiBZhEwsaNZmGwjI2AEjIARMAJGIBoImNgRDbNkfWwLARM72kLP9q1PwMSO+jTsbyNgBOKZAILH9ZJqLTmYo94zkvXS3BStTbusq8VVulVdo7xSn8jvcSy3RInnClxujzVpV7QkIUezdmZp/OZMjVydoQ+/PaFRazM0d0+2thy75ra/WeYTCdFbW9i1uNKvzGul2n0qXyuSLrk8I7sy8nStuPmCTGvbt/2MgBEwAtFGwMSOaJsx668RMAJGwAgYASPQJAETO5pEY1/ECAE8QUgkj+jRsJCQvVevXiJpuxUjcDcCJnbcjZB9bwSMQDwRIGzVuetlmrYjS72nJ+ntpelasO+C1qRe1tKEHE3/7pw+W39K76w8rkFL0tV/QZqem5WintOS1Gtaop6fmawXZh9yf/eZmazXFh92269IytH+M/kuN8jlokqVVtU4z4+m5A/CYZVU1ii3sEoZV0t18OxNrUrJ1fgtZ/TWsqPqPTNZ3cbt1+Cl6VqXdlWF5TUKmidJPB2qNlYjYATuQsDEjrsAsq+NgBEwAkbACBiB6CHgiR0XL15UVVVV9HTcemoEmkGA47usrMzEjmawsk3uTsDEjrszsi2MgBGILwKhcFhnr5fpg29O6I9j9uq3I3bqnpG7dM9I732X/jB6jx6fdFD95qVp2Irj+mJTpubvu6D16Ve19fgNLU7I0fBvjuvJKQf1u5G7dN/Ineo2PkEDl6Rr7r4LSr1QpMIyn2oCIZEgnTZDobDz/iDnBx4miecKNWfPeb25JF2PTkjQ70ft0u9G7NQj4/arz8xD6jcvRX8es1dvLD6sbSeuq6wqEF8TZaM1AkbACNyBgIkdd4BjXxkBI2AEjIARMALRRQBjcGlpqcuBUFxcrJqamugagPXWCDRBgGPb5/OpoKDAJTFvTMwzz44m4NnHjRIwsaNRLPahETACcU6gvDqg1PNFmrEjyyUrH7f5jObsydbKQ7naevS6EjJvKuV8kY7l3tLpq2U6n1+hy0VVyi/1qaDM50JfZV4r08FzBVqTdlnjt2Rq4JIj6jkj2XmB9JuTouErjmrKd+e08eh1HcouVMLZAq04dNkJJ0OWpevF2SnqMTVJvWYk6fXFRzR2Y6a+TrqkfZn5Ss8p1qHzhfpo1Un1mp6kNxYdFiGtSirsnjfOD10bvhEwAn8lYGKHHQpGwAgYASNgBIxATBHwDMI3btxQfn6+ED3sZQyi/RggeTnHM8c1fwcCP1zFaWJHTJ3KOnwwJnZ0OGJrwAgYgSgkQP6OSn+t8/A4nFOsjKu36hKPV/lrxeKD5hTCYpVU1Sjjyi2X44OQWITBQpx4dmay+sw6pFcXHNa7Xx/TsBXH1HdOivrMTHLvby05ojHrT7kwWtuOX9fx3BInpBDiisL7gTMF+mDVCXUbf8DlCjlw5qYqfAG1IT1Ic4Zl2xgBI2AEIp6AiR0RP0XWQSNgBIyAETACRqAlBLwV8Hl5ecrJydH58+ftZQxi4hggVweeHXgsNWZsMbGjJWeKu28bDAbrPMU4j1y9elXkTGmMPbUhQBUWFjrPMra/du2aC6fnbV9bW+uEqtzcXHc8XrlyRZWVlT/oCJ/RFuH4vDlnX6/wNx5s7H/hwgXXHv2ivy0pJna0hJZtawSMgBFoO4GCCr+Ssws1d+95DVl+VI9NOKAHx+zVI1/uV89pifpo9QktS7qk9EslulV5Z0+NYG1Y+zJv6tWFh/XQl/v0yZqTOpJTrCp/y64FbR+V1WAEjIARiCwCJnZE1nxYb4yAETACRsAIGIF2IBAKhZzh0e/3y17GIJaOAQzqnvG84U/FxI6GRFr/f84hiA3Lli3TgAED1LNnT7311ltatWqV8xRrWDPbI0xMnjxZr7zyinr06KHhw4dr9+7dKikpcZuTb4WHL75/+OGH1bdvXyE4eIU6CE+2a9cu19bzzz+v/v37a/z48U649cLy4eGzYsUKDRo0yCWkf/XVV7Vy5Uq3jVdXc95N7GgOJdvGCBgBI9A+BHAIwduj3BfUzTK/cgoqXEiq3afynGhBrpArRVUqrPCr0h9UsDakOzmR8B2eIwfO3nTJyp+clKARq0/qyMUiVdUE1Tz/k/YZm9ViBIyAEYgkAiZ2RNJsWF+MgBEwAkbACBgBI2AEjEArCZjY0UpwjeyGl8Tq1avVr18/TZo0yYkUH330kYYOHapjx479IB8QAsTmzZv1+uuva9y4cVq0aJFGjx6tDz74QCkpKU6gwmNj/fr1mjhxotvugQce0I4dO+paR8hKTU11gglCybx58zR27Fi9++67TszAkwOvDup78803NXLkSNcO9b300kvatGlTk0JYXSP1/jCxox4M+9MIGAEj0AUEEDQQPxA3WltKqwPafvy6Xl2Q5kJajdlwSqeulsn/15BXra3X9jMCRsAIRCsBEzuideas30bACBgBI2AEjIARMAJGoB4BEzvqwWjDn3jOEI4KoaF79+7KyspytW3ZskVvvPGGvvnmGxEmz/Ow4f3IkSP68ssv9eGHHyojI8Ntv3PnTj3++ONavny58zBDQEGwyM7O1rp169x3bOMVvDpmzJihd955Rxs2bHBeHmfOnNH06dOdFwfiBGHM8DbBmwOvEdpmm27dujmRhPBWeIg0p5jY0RxKto0RMAJGIPIJlFUFtDbtip6ffUhPTErQlO1ZOnO9TP6A+XdE/uxZD42AEWhvAnEtdtR/uGhvsFafETACRsAIGAEjYASMgBHoTAImdrQPbUSJkydP6vPPP3ciA0nhKQgaEyZMcJ4bJ06cqBMV8LbAq+Ptt9924aUQNCjp6ekunNWcOXOceIIwQd0IKYgZTzzxhOo/j1RUVLjQV4MHD3YCC9siXuCx8eijj2r79u06deqUC2tFP+gDdZLfA48Swl1lZmY2mrzedajBP3iIPPLII9q/f3+Db+y/RsAIGAEjEE0EasNSUXmN1h2+qgEL0vT45IOasTNbZ66VKVAbtpBW0TSZ1lcjYATaTCBuxQ5WQxEP14oRMAJGwAgYASNgBIyAEYgFAoRI6tWrV50nQiyMqSvGQG6MhIQEjRkzRp9++qkTJ+gHHh5z5851oamSk5NvEzu+/vprl9vju+++c0nI2f706dMu58a0adNcPg/P4wIBY+PGjT8QO0gy/vLLLzvvkeLiYjd09tm3b5/uueceFwILgeLjjz/WggULXHJyNiKEFp/hWZKUlOS8SNzOd/mHuvAIOXDgwF22tK+NgBEwAkYgGggUVtRo7eGrenpash6bnKjpO7OUV+oXYogVI2AEjEC8EFiyZIlYPMSCoOaU/6c5G0X6Np6rN8kBZ82apalTp3bqi7i6rMaaMmVKp7bb2eO09po+roj9zDFAEksegI1V06xikQ1zztx7x0AsjtHG1Pxj2rsmGLPmM4s1VlwTWJFt9wXxewzUvya09r6A8EfklyAPBKv7rbSeAAnt9+zZ48QOBA88MSgXLlxwIgM5NA4ePHib2EFoKfJm1E9Izjy89tpr7j7v/PnzddvfunWrSbGDOcRLg2TmXkGM+PWvf+1CXyFmvP/++1q8eLETUNjm5s2bGjVqlBM7EGm8RObe/t57UVGREhMTXS4QzqM8BP7v//2/nbjC8dPZ51bOfVwDO7tday9yzrV2/Yucueiq30V7XP+6qu+R1u60qVM1ecoUvfPpWN3/wnD97MnB6j7gA306ZrwmTYpc2xP3v/ZcHN/nAu8YsHuC+D4OOKd69wVcG1pzjuU5ivCvPXv2dAvALl++7N0G3/E9JsQOXMuJhYt3Bw8rJADszBcu6zywEPOXfnRm29ZW5851U7x79+6t3/72t+6h+L333rNjoJN/g03NS2d9zpxjzPjd736n559/3s4DcTb/9Y8zrkGsqr3//vtd+JP639nfkXG+7ox5eOaZZ/Tzn/9cLMLoivuSzhijtdH08cy9YN++fd01gffW3hdQD0byYcOGqbk39ne864/jLxELEAUIYzVixAiXJwMcZ8+eFSGp8KLAK8Lz1CCMFXk8BgwYoK1bt9Ztj2cH13sevHJzc+tyfNxJ7OA8wDMCuTkohLJCeLnvvvtc6Ku0tDTXJzxMEFAoeHaQCJ3E6PSrKbGDPCP0D28VfpMDBw50D4O019nnHu/6hzhH0nc7RzR9johlNj169NAvf/lL91xuz8XxeQy88MIL7rmY99Ze/2L5N9KasQ0dNlxvvT1Ug98eqiFDh2lYBD9rMedcO++9914X9rE147V9ovvcwf0A9yPYSMmTZvcE0T2fbf09Yiv92c9+5jyjW3tvyv1E//79NXr06Lr7aXfDfId/YkLs4IEEN3FcyDv7VVJS4hIPPv30027VXWe3b+11/pw3ZM4D7urVq9WnTx8XNoCVew23sf93/Tx15Bww54SkQOggDndHtmV1R/axxLFAAlxu8DBs2XxF9nx1xPxwTVi0aJH+/Oc/u/j+dk2Iv2OA42rHjh167rnn3HtbjwHucbnXtdJ6Al7ODrw6Bg0a5JKRUxs5OFh9Srgocnp4YgfvXM/J2UE4Ky9nx7Fjx8Q9/+zZs+WFpaKepsQOcnYgVuFxgZBBPzgeyAeCMO7l7EDUoB9eIvRr167dlrOD/RorHBc+n++25yD60hHntrvV6V3/3nrrLbv+dcEz6d3mp7O+J6Y2x/bRo0e75DjsrHFaO01f27n+EX6REIBtvf4Z5+85w5FX+V/fyyL4HEM/U1NT3cKA5cuX23kggueqo35fHAMsJuF+iXsbvGk7qi2rt+lzcaSwWbVqlRM/WXTEsdHafnF/y321d6/e2H1x/c9iQuyoP6Cu+BujBmpVc2OHdUUfrc2OJbBt2za3ipMbeyvxSeDw4cMuLvfevXvjE4CNuo4AbrusYAkEAnWf2R/xReDbb7/Vww8/bHkW4mvabxstoYkIgcS7la4nQNJvHrYRFR5//HEnKhDaipwoiB8sWsGbgu0ovHNPx0P6hx9+6BKZsz1eFDy8r1y58rY8Gix+8hKUY+jz6qmurnY5QQhTRRuEnUIwwY0fIQWvDvqFoIIXD+JHVVWVjh8/rscee8x5kPBQ6NXX9STv3AOuf6zqtevfnTnF8rcc50Q98LyUYnmsNrbGCXDdYwEYhi0r8UnAC/nINdZKfBK4ceOGs5GSZqCpBRvxSSb+Rs29M1EvTpw40amDN7GjjbhRlRYuXOhWL3irvtpYpe0eZQR4AOUHTKgKVghaiU8CGCxwrSM0hZX4JkA8SoxYGMasxB8BrgmEv0HsOHfuXPwBsBE7Ahh5EDvM2BM5BwShoDC8EFYK0YPwVYSKwjiPuHDx4kUngpALsLKy0uXN4P4OMYTwV3hzEC7qk08+EQsceAbAq+LQoUMu3waho376059qyJAhbkUz+UCoh3tDxA1EcGIOf/bZZ65NVrqxUAojAKtguW4QTot28DQhN8iWLVuiRuhgprn+EaLArn+Rc9x3dk84rhEUs7OzO7tpay9CCHDdQ+wgD5KV+CRAyEdCzK9bty4+AdiohYcqC8JnzpzZZChOwxQfBLiXRezgXrszi4kdbaTNgw7ueS+//LKuX7/extps92gkgGFr586dLmxNZ6uV0cgrVvvMClBCN5BI1Ep8E8BQ9dFHH9mNXZweBlwTeLgjiZqtbI3Tg0ByeRbefPNNZ8SOXwqRNXJ+m+Q+WbFihfPO+P3vf+8EKVai45lx5MgR57GBh4aXwBwxYvz48W57cmxgvNm/f78LG8Xo2A8D/1NPPeXy9PzTP/2Ty1eAUIGHB14ZhJoiyTkLIh588EG36h3BA0OAF56M9ugXMe55ICTvAf2KNq9xVnCOHDnSxI7IOvQ7tTcIioTwQ+yzEp8EyDPEOTA5OTk+AdioXQgjBHyMnFbikwCeHeRuWbBggT0Tx+chUDdqbKWeV3Xdh53wh4kdbYTMgxOrsZYtW+bi9baxOts9CglwDOCqSUiDaHsojULcEdtlDCiErsnKyorYPlrHOofAgQMHtHHjRnPZ7RzcEdcK1wTEz/nz5zc7gVrEDcI61GYCeAng4cO7lcghgHcHoaQQIoknnZOT43Jv4F2BFwZ5OIgJ7IVcYHse2L3tL1265OINeyIF74S/4nvuBcm5wTvJyz2hg3MCMYppi3sEtmWBFKGe+I5Ce/SLbegX2/D/phKTRw7R23uCEEQ+Eo/f7d/a/+KBACs3CfFM3jIr8UmA6x6h+ez6F5/zz6jz8vKcYG8LQeP3GOAeiEXheHrZPUH8HgeMnPtiFoN2tq3UxI42Hnc8pPAwwsNPtD2QtHHotns9AjzEYuwmzrKV+CTA3HMMkEjWSnwT4AGfFbueESu+acTn6FntzUM+IW6sxCcBEuhxTeDdihGIFwJc/xBy7PoXLzP+w3Fy/UO0s1BmP2QTL59w3UPwtetfvMz4D8fJ/S8h3jF4W4lPAizowEbKfYHdE8TnMeCNGlspi3g621ZqYoc3A/ZuBIyAETACRsAIGAEjYASMgBEwAkbACBgBI2AEjIARMAJGwAhEJQETO9owbSiUqNY3b950ShWrOHHZww3e1Ms2gI3QXVmhxPwSg5YXK7dRrL2CZw+hDDgOeOGmVV1dbceCBygG3vld44ZJbG1WKnAcMNesYsSjgxw+FP5mRS/feysaCHVh54UYOAgkN8+EOWHlIvPPPLN6ifAn3jyzcoHPvPMBYVBslWNszH9jo+B44DfPnHvnfS/8jXeMcJ4wT4/G6EXvZ8w1q1e9awFzzTnfW8nIMcA9once4PjgHtG7VkTvyK3nRuA/CHDd476H3wIr9zgX4vVe/x75P7a2v2KBAPcz3Ndw7mPOeT7iOKBwr2vXv1iY5TuPgXnmN841jvth7zrIcYFHB99zreN66D0TsR3nBu9YuXML9m00EGCeef7xnom43+Feh/tib545HrCLcIywHceMhTWKhtlteR/5zXtRb+o/+3K/zDHg3Q/bM1HL2Ub6Hjzjeud6b575vXN/yHmC3zz3CnzHuQBbakd7epjY0Yajhgv86dOnNW3aND3zzDN69tln9eWXXyotLc1CWrWBa6Tuys38xIkT1bt3b5eI8oMPPnA3+vSXEzs/5kmTJrmkfCTme//993Xs2DEzcEbqhLaiX57QsWTJEpdwq0+fPnr++eddMs69e/e6kznb7Nq1S0OGDBHfk5hr3rx5dnPfCt6RugsP+du2bXOJbfv27evmmSR8xOfnoY6HfBLdDh061CWbJeHs2LFj3YXdjJyROqtt69fatWv1xhtvaNiwYS5mP/cHGL2Zd84RnAtGjRqlM2fO1D38ta1F2zsSCHAP+Morr7hk0swzv3USWJOIj8JN/4wZM9zn3BdwniBhKw99VoxArBAgbBHHPOfAJ598Um+++abLZciDrJXYJMAzEc+8PXr00KOPPur+JkwFhXsg7/rn3SN9+umnOnXqlAm9MXQ4cJ+DwXLOnDnuOsh9Dtc57nuI0Y/hCyP31q1b3TmB71966SV3buCcYffD0X8wYMBE0FizZo2bW+6BeA0fPlzr1q1ziwPZ5uDBg3rnnXecDaV///7OdsYCURM8ov8YaDgCFvRgJ3nxxRf1+eefu0UQzPPJkyedbYxrAvfLn3zyiT0TNYQX5f/nGff111939wWcB5jrfv36uesB1wuEDmypfI499aOPPnI5LjvyWmBiRxsOKi7gkydPdg+vGDE+++wzd7GfMGGCu/h35MS1odu2aysJoELOnDnTXcC7desmXggcFJTrVatWOePme++9507gAwcO1Ny5c11CHi70VqKfACdq5nr16tUaM2aM+/2PGzfOndg//PBDkZQRsRPRi4d+bvgxeCN8YRy3ZI3RfwwwAh7kDx8+rKlTp2r69OnOmPnuu++6a0F6err7DoGLG3pu5viOiz/HDRd6K7FDgId5kq4xzw888IAefPBBd1OHoWfFihXumODcMHLkSCeALl682K2CtfuD2DgGEC5+8YtfuAc37v0QNkhMT0JOjDnr16939wxcBzgGXnvtNbcN39t9QWwcAzYKuWse975c67g3YjEQhk2SlZuwF5tHCM9E3P9wbvvDH/7g7ndYzUvh2YjrH4t+uP5xfXzrrbdc0nJWc9r1LzaOCe6FEfSXLVvmxK4pU6Zo/PjxTtgYMWKEM2QmJCS4Z6FBgwY5OwlCKNdCxFFW+1qJbgKe2JGUlOQEDO6BOA44L/Dic56XOFfwXIytDNEDMWTDhg11i0ajm4L13iPgPR+z8OvXv/61uzfOyspyi/2++uorvfzyy/r444/ddYGFQVwnOIdYiQ0Chw4d0v333+8W+uIMwPkA2+nZs2edVw+2Uo4N7hdHjx7trhXYSvne8wJrbxImdrSSqLdqE2MWN/YYMXHNwrjJDR0n9452y2ll1223VhJgxRKrODFoc7F+6qmnnFpNdampqe7izcWcbXgI+Prrr92xgIGzJBQ4KAAAEX1JREFUo37ArRyK7dZKAsyjF66GizOGTh7uEDdYpcAqFs4HPNzxN99hDOPmnxs7jg0r0U+Am3vmngc13rkesKqJVQybNm1yN/UYfXgAZPUjq1m46HNcIIZZiR0CrGr0RHAErccff9yJHXh6cSOP4fvcuXPOpR+hgwf9jRs3WniXGDkEuLG/9957nRGP8z0Pery4VrCKmd88q5jw8kQA40afa8Hy5cttRWOMHAPxPAyuhRzveDWyUg/DJtfFAwcOuHtkznneoqB45hSLY8eLFaGfcxvGSxZ4eWLHnj17nGGT6x/bENKGYwHjp13/Yudo4N4XUZ9nXry4uB8mnBGLwHgmwqODld2In/zNYjHOEV988YUQQ7CbWIl+AvWfibgeYC/h947gvXLlSrEQhEV/XCcIX+UtFsPTlQViVmKDAMcBC/pmz57trgkIGyzwQeBmwSfPxQsWLHDPRBi32Y5zA89LVmKDAM9E2EeJdsBCFyJhcE5ggQPfEe1k1qxZ7vkIzy6ehbCbYzPl+tERxcSOVlLl4s4FG2PGwoULXS2IGxg4USxx3+KEbiV2CHAS50fLvOLRU1/s2Lx5s55++mlt2bLFbcN2GRkZ6tmzpzN0mJtm7BwHnLAxZHkr05hrVitg6OSd44AHP27+OWa48cfo/ec//9mJoLFDwkbC/HIx59zPhZpQhjzQsWoBV32EDr7nAs7DP+79nCOsxAYBbuAIV8bNPCE6uIHj90/4BlYr3XfffW5lM+cI70ave/fuTvjiMyvRT8ATO3iA48ad3zsGIAr3iNwDIIRyDuB44aGPB0C8gb3top+CjSBeCXAMs/CDc9/gwYPdfQ8sWMnJoiCMnggfVmKPgPdMhAEbzw1W7ntiB/dDf/zjH93cc3/E9S8lJcWdD1n4Yde/2DgeOAa8ZyL+pvC8i8iFfYRnHwzeGDQRNvgOQzhGTsLdsRDESuwQ4FjgXocFwKzWJkwNxwD3PIihhLjhOEEoxasDb2gv5GfsUPj/27t7XamqNoDjN0KlhQkm4gdR1GhoCIKFsTGUWJHIFRi9ADoihFBZkFAYaVWMJl6BSk9FY8VFHPNbbxYZCFicw847e5//SiYzzGHOmf1faz3r+d7H80rMq/ZVEvok9MxKZ45seq9uBxIC+camXexM8B6Hd2MbBNhEZLvELokv5prctz4kg545c+bgl19+GX4T70mWYCexoa2fJUbBjkNSlc0pO0WWigk1CHjRSVkM2puUsXBIuHv8MQe5Q/zZYIc1wJm9a9TJcvnss8/GBi7YsceTeoSvRlALftnzspgEvcw5Z7eAqGHuBUFPnz598Mcffxzhr/XRfSNAxpt7BzUnt8wlWayeBT4c9GSG8ddff42sf47PxjYIMNSd9Qx3QSzBTvfvEuzg/D516tSY93m1MlwZd9YMfaGxfgKMtQ8//PDg008/Hca8vS+jSSazAOeFCxeGYj+vVGWgDHjGYMGOSaXntRIQwFO5qLqVw3vaPQIgZKB2NfSixjYJSPyRyftssMPca++nXd8czj/BftXPBTsmlW09TxtZexI20f3790fvduei1t9zSBLV+qxq90lk/c/s4YcPHz5pYcgmIv91N5D85d5ms42vdUI/Yhd3Pqx/7l2BOVWlw74h/3/99dcR4NDKUPInHcGaEBy3VgzrReKwQEhjGwR0ujl37tzwd+hkIIghyGHef/jhh4PXXnvtqcRfPhN6Ab/Z7hnxMmkU7DgkTQo9B7eSLD2ZDcqbGzBpZSWiydhtbIsAxf55wQ6lmXrUcXLNIcvTfT2U6ubUmFS29Sw7xf6XuWDfy/L+/PPPRxB0Cm2HugyWN998cyh32yJwvK/GHqfUqeRRmsmgU83h0L506dLIaJiEZLO4iecMjs/3e14fAUq9vS/Awckjk0VJtorOWdkhq+3kyZPDETivULbz2bNnR5/Sgh2TyrqfGXFkv0oNrTmsB4EM5wLF/tnMRZlLMtm0b+AobkRgzQTYPfQerTo5OeYNydlIsjXpv/SfxjYJSOZ5XrCD8+rtt98erSrmlTv/BIU5wjv/JpXtPLN1VPZoW0QnJhM4P2X368++O+daHH300UdPrY/tkDieV2L+Hz169KSNrzbv5D+/iMAXG2lWfiHkfk4SgiQON9ZPgD1M55UEzheqiocdNIMd5AH/yO4a0NrVe7dv314/gK5gEBC8MNfO+dmuUNWnag4tn1955ZVR5Tlx8ZXzlfKjTb/Z/NnLei7YcUiSFHrZe5xang0HubYFslZk/s8Mp0P+iT62hwReFOwg4JVsE/BziGKKVnJ+FOyYVLbzrDRPuabINcVe5r5sRs5Oh71SbYNjlOOL4Vdfyu3M/7wSCr45lrkwD3Ql2ww8jk0/N2S/qvop2DHJrfeZPLffKXQSHpz7ste0bJHJb7/72RtvvPFUZquAiKC49i67hv96SfTNrYXHjx+P+eT4Ve3DqJfRaA0Ibu22aVDtJdhBdyzY0fpZOwFrniyU4CXgN4MdDFiVbvZBzqy1z/KLv/+Lgh3aGL3zzjujZcn8NNnIqdH5N4ls65nN436lzjeywD2rtK9R5SzYsXsf0++//360+fR/GtsjwGkp6KW9s6A3h7bKDsmiBrtIp4O33npr2E7bI3C8rogNLOmLc1s7y99//334wzi8v/zyy2Ef8YVpb7Tb4l+ykPcERRrbIMCu0dnEM58p2/jixYtjbbiH4auvvjrem1crQEovkABWsGNS2ZNnkUkleLNPv6/F+cnhZUM7yEU5G9siYONybMw2Vpzbhsw1N6YVuaT8c4CIan/xxRfDAea9xnYIcFRqX0I4M+Z/++23sf8pcsp1ZfZaGxQ6GeD6F3Ny7gbDtkPj+F2JeZ1BjHn1Al8UO5kLehRrVWMNcAY59LW4EwBxRjTWTcD+t+e/+uqrsa9lqwpyKMk/ceLEMPbNtcxFWW3OA8aANeL/Oj+si8b6CZADznfz67UzwA3JZbkLglPy6QfWgAfFXsajc8O/GxFYMwFrWCbfzZs3R5KH14b2FIJ9nB8leax5hv/7u7OJ2LrsXske7lFncHAK9HJ+O+vIRzcl1uax8++/ma7xp+QAn4jsXG1LZO07FwU/3dNMsEMCoPUiCYhzUzKgBJDG+gk8axOZezYPuSAJiN5LX3YukAWSPrSvIiO0O2qsm4B9bT4l+nzwwQdD7/3kk09GR4vXX399tHjVrkrLZ3ueDcUuVhXqXpZ37txZN4C+/RMC9veuz1O3C0EOhQB0BHYy+5leQG7oekEvICu6Z8cTjPvxwiQpyb18+fJQ6GUsCIBQ4hz2Dv2lIlT7QeB4fgubeDfYwXFhcGjZxEq3leUp65bdS8lzcy4HQWMbBAjnmcFgzh3w08AT2CDQtTOiwJELehaTC9bCbv/ibdA4fldh/gW2HcrTiEdBlpLgl/s3MOycA2QAA0/2Ctmg4ofx31g3AYocp56MfYFMiro9LnNNn3LObv9Wuu9nspzpB9odqvpRCUjRb6ybgHPdPHrQDTzs92+++WZktl6/fn3IfQFQRj6n4M8//zxkA3mwaxCsm0Tf/rgScB46C+m5Avwc2vaFZBBBf07NbkK83dVBhu0GO2aLEolf7GPrgp00zz8OT9WtnX/bWRMCHRzbAvyyugU35zrwLOAp8C8A4p5VKsE4wOnL04beDo3jdyX0nl2bCAH7W5tXNjJdWCsj1azsZYEO9+9hK3GOOysa6yZAD+DUdo8eMl+bOnYQnUDCjwRwyQ/kA/uHTSQZUOtfcsDnGusnQB/gF7H/rQnDfZnsc+eDlr/0Qu2/+UVUA7qn7ZUrVw7cx4kcWWLUxuoIVDk2RasI8Lt3746HSo9vv/12OLxzcB8B7h5+lJLmxjsENSX+3XffHZuT4iZjl1HHySnDzab12g2ZGH+Ugcb6CRDkgl1KtN2U1kHusFayyYnNqGfkEehff/31wY8//jiUeq/JiNniYf0kju8VOMCV4ZIFMrY5LwW2GG8Mea8p+RR8ih0l78aNG8PBSS4Ihja2R0CA2x5Xki0YKhnCvAt8Ohu0dPGaA1zQM/1g/WuAUk9hJ/N/+umnIQsEtyj2AhzWAaV+6gIMQG3PyArnRXrB+tdAV/A/AhyZ7B86771798b5pzWBvcG51dgeATYRGSfgL2v3/Pnzo3WN1kSqmMlAsu/WrVvD+eX8++6770ZLz86/bawH86hlt0QerZxVLQpmydydepBqZtUeqhnpSNqYuZcD+2gmim2DxvG8CsEuAU/zrWUhx7U5V+kuyc9r+hG9hwzQ3so5QTbQiwt4bXPd/PPPP09uUK6dnQAX/xi7WLKP+3R47bmEiG2sARU75pofhG+E/meutXfn/xAIN998YtaC88BrbVD5SsmSJUbBjiNQFbnSi4xj00SKVsnoc8jv9qY8wp/oo3tEQGamDBU3HtaeRCmWHvwzoPH3338PJU77EmtBZreKD0GxGeHco8vpqxyCAEGuBFOA87333ht9SJVgehDY9r6MBU5wSp61IjDG8e19zrHGugnYy+aSU1NvYg/7XQaTw1wgxJ7n/LEGrI15NrhvRxmN657/F317Gf32PeVdAJwOwOkj+UHParKAcScwLnulM+FFJNfzvvNA0MJ9m1TxeJD3jHqKO3mvneW1a9eGDLAOOIRVBHEUNiKwFQKCvZycKtc4vmXqcWwzfJN1W5nlp6+DTSRbU7ve999//+DMmTMj2C+4IRlEewo28e75J4ub3GxsgwA958GDByPA//HHH4/5n+cg3cf9zKwTgQ2Vr+xjOjGHl+QvCWSNdRPgoGQTSeyQAOjBLuIDkeVvnlX/CYJcvXp16MJ+zncmWSR5sO75f963FwQ176rZdbugB7B7+EzZSNMu5kvRyirfyPMorus9ep7zgN9TJde0ifhBVPXwf0h8UQEkEGoNsIvnDe2XtIsLdhxhLZlYrapsYhFtyp3oJCM25f4IYPf0ozYpRzdlXdaSB8E959xhTqnjzPLg6FKiVfbmnk7oIb6WA9ycKssz/xxaHtYEQS67heKnb7vsbe//+eefo+VNSv0hgO/pRxzKspHmXp/zL5PFGiH/nQPWhP9jjZATBcH3dEJfwteirNv/spfICMM6Me/WgDXC8V17y5cAe09+hb2u0k+iA/3PPDPctDib88yQpyNOWUEmyGZNL9iTSexrvBQC9Bt6j71AL/bMAZYj66Xg3ctfwiZyprF/d20izgz6j/OPzUT/IR/936p89nIqD/2lnIHmWsBD4N9cz7NOsMv5SAbQjfwf68AZqYUNmZGv5NDo9+aD5tBep/c8O/+C4DNbW0sza4IubA2QE7vtbvbmgvoiRyZgTdj3ksDov9P2ZRvxjc11wl6auvKR/2i/4P9OYNpEU9aT93RBHS2sAevCnucrtQbIAv40CaJLjoIdS9Ltd0cgAhGIQAQiEIEIRCACEYhABCIQgQhEIAIRiEAEIrA4gYIdiyPuD0QgAhGIQAQiEIEIRCACEYhABCIQgQhEIAIRiEAEIrAkgYIdS9Ltd0cgAhGIQAQiEIEIRCACEYhABCIQgQhEIAIRiEAEIrA4gYIdiyPuD0QgAhGIQAQiEIEIRCACEYhABCIQgQhEIAIRiEAEIrAkgYIdS9Ltd0cgAhGIQAQiEIEIRCACEYhABCIQgQhEIAIRiEAEIrA4gYIdiyPuD0QgAhGIQAQiEIEIRCACEYhABCIQgQhEIAIRiEAEIrAkgYIdS9Ltd0cgAhGIQAQiEIEIRCACEYhABCIQgQhEIAIRiEAEIrA4gYIdiyPuD0QgAhGIQAQiEIEIRCACEYhABCIQgQhEIAIRiEAEIrAkgYIdS9Ltd0cgAhGIQAQiEIEIRCACEYhABCIQgQhEIAIRiEAEIrA4gYIdiyPuD0QgAhGIQAQiEIEIRCACEYhABCIQgQhEIAIRiEAEIrAkgYIdS9Ltd0cgAhGIQAQiEIEIRCACEYhABCIQgQhEIAIRiEAEIrA4gX8BGi/mT77kW2AAAAAASUVORK5CYII="}}},{"cell_type":"code","source":"## PLOT results\n# fetch results from history\nscore = history.history['score']\nval_score = history.history['val_score']\n\nloss = history.history['loss']\nval_loss = history.history['val_loss']\n\nepochs_range = range(EPOCHS)\n\n# create subplots\nplt.figure(figsize = (20,5))\nplt.subplot(1, 2, 1)\nplt.plot(epochs_range, score, label = 'Training Score')\nplt.plot(epochs_range, val_score, label = 'Validation Score')\n# limit y-values for better zoom-scale. Remember that roughly -4.5 is the best possible score\n# plt.ylim(0.8 * np.mean(val_score), 1.2 * np.mean(val_score))\nplt.legend(loc = 'lower right')\nplt.title('Training and Validation Score')\n\nplt.subplot(1, 2, 2)\nplt.plot(epochs_range, loss, label = 'Training Loss')\nplt.plot(epochs_range, val_loss, label = 'Validation Loss')\n# limit y-values for beter zoom-scale\nplt.ylim(0.3 * np.mean(val_loss), 1.8 * np.mean(val_loss))\n\nplt.legend(loc = 'upper right')\nplt.title('Training and Validation Loss')\nplt.show()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### OOF Evaluation","metadata":{}},{"cell_type":"code","source":"np.mean(OOF_val_score)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"In the next section we are going to use the ```train_preds``` to calculate the optimized sigma, which is a measure for certainty or rather uncertainty. We can do that, as we have both: the model's estimate and the real data. We subtract the lower quartile from the upper quartile (defined in the loss function) and average it.","metadata":{}},{"cell_type":"code","source":"## FIND OPTIMIZED STANDARD-DEVIATION\nsigma_opt = mean_absolute_error(y, train_preds[:,1])\nsigma_uncertain = train_preds[:,2] - train_preds[:,0]\nsigma_mean = np.mean(sigma_uncertain)\nprint(sigma_opt, sigma_mean)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"sub.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"## PREPARE SUBMISSION FILE WITH OUR PREDICTIONS\nsub['FVC1'] = test_preds[:, 1]\nsub['Confidence1'] = test_preds[:,2] - test_preds[:,0]\n\n# get rid of unused data and show some non-empty data\nsubmission = sub[['Patient_Week','FVC','Confidence','FVC1','Confidence1']].copy()\nsubmission.loc[~submission.FVC1.isnull()].head(10)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"submission.loc[~submission.FVC1.isnull(),'FVC'] = submission.loc[~submission.FVC1.isnull(),'FVC1']\n\nif sigma_mean < 70:\n    submission['Confidence'] = sigma_opt\nelse:\n    submission.loc[~submission.FVC1.isnull(),'Confidence'] = submission.loc[~submission.FVC1.isnull(),'Confidence1']","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Okay, we made it! Let's finally check our stats and submit it!","metadata":{}},{"cell_type":"code","source":"submission.head()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"submission.describe().T","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"In the following last step we overwrite our predictions with the known data from the orginal submission file to not waste known data.","metadata":{}},{"cell_type":"code","source":"org_test = pd.read_csv('../input/osic-pulmonary-fibrosis-progression/test.csv')\n\nfor i in range(len(org_test)):\n    submission.loc[submission['Patient_Week']==org_test.Patient[i]+'_'+str(org_test.Weeks[i]), 'FVC'] = org_test.FVC[i]\n    submission.loc[submission['Patient_Week']==org_test.Patient[i]+'_'+str(org_test.Weeks[i]), 'Confidence'] = 70","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"submission[[\"Patient_Week\",\"FVC\",\"Confidence\"]].to_csv(\"submission.csv\", index = False)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## <font color='blue'>Thanks a lot for reading, I hope you could gain as much insights from reading this as I got from writing it.","metadata":{}},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}