{ "cells": [ { "cell_type": "markdown", "id": "ee702cec", "metadata": {}, "source": [ "# Sequential Ensemble Model (Voting, Stacking generalization) of Precipitation Downscaling" ] }, { "cell_type": "markdown", "id": "9299c596", "metadata": {}, "source": [ "### This notebook investigates the model performace of using individual estimators and ensemble approach. Precipition data (processed) from DWD and climate dataset (processed and standardized) from ERA5 is used. \n", "\n", "### 1. Recursive feature selection is used tune the predictors to select the optimized variables. \n", "\n", "### 2. Different estimators are establised using sklearn and tensorflow for the densed models. (I used sklearn wrapper in keras.utils to make both models compatible) ---level 0\n", "\n", "### 3. Ensemble models (voting regressor and stacking regressor) with different final estimators are tested to evaluate its performace on precipitation data --level 1\n", "\n", "### 4. prediction and visualizaiton \n", "\n", "### 5. Model preformance evaluation\n", "\n", "### Note: This example adopts climate data (precipitaition), therefore the focus of the approach is tailored towards regression using advance models.\n", "\n", "#### However, it can be adopted for classification problems or even improve with complex networks like CNN\n", "\n", "### Next: Use future projections data to feed the model for future local predictions" ] }, { "cell_type": "code", "execution_count": 55, "id": "03714017", "metadata": {}, "outputs": [], "source": [ "#@dboateng (13.01.2022)\n", "\n", "#importing models\n", "import numpy as np\n", "import pandas as pd \n", "import matplotlib.pyplot as plt \n", "from sklearn.feature_selection import RFECV\n", "from sklearn.model_selection import TimeSeriesSplit\n", "\n", "from sklearn.linear_model import LassoCV, RidgeCV, BayesianRidge, ARDRegression, GammaRegressor, LassoLarsCV, PoissonRegressor\n", "from sklearn.ensemble import BaggingRegressor, VotingRegressor, GradientBoostingRegressor, StackingRegressor\n", "from sklearn.ensemble import GradientBoostingRegressor, AdaBoostRegressor, ExtraTreesRegressor, RandomForestRegressor, HistGradientBoostingRegressor\n", "from sklearn.svm import SVR\n", "from sklearn.neural_network import MLPRegressor, BernoulliRBM\n", "from sklearn.tree import DecisionTreeRegressor, ExtraTreeRegressor \n", "\n", "from sklearn.metrics import mean_squared_error, accuracy_score, r2_score, explained_variance_score, max_error\n", "from sklearn.metrics import mean_absolute_error, mean_squared_log_error, mean_absolute_percentage_error\n", "\n", "import tensorflow as tf\n", "import tensorflow.keras as keras \n", "from tensorflow.keras.models import Sequential\n", "from tensorflow.keras.layers import Dense, Dropout\n", "from keras.metrics import RootMeanSquaredError\n", "\n", "from xgboost import XGBRegressor\n", "\n", "from sklearn import set_config" ] }, { "cell_type": "code", "execution_count": 20, "id": "4d4df0ca", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(744, 22) (744,)\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
t2mmslv10u10z500z850tpq500q850t500...vo500vo850pv500pv850u500u850v500v850d2mPrecipitation
time
1958-01-01-0.599361-349.7826360.0574580.030403-341.345388-287.1864760.000917-0.0001090.000011-0.024671...0.000002-0.0000041.244580e-07-6.846847e-08-0.2189040.2982430.3199751.885623-0.73918082.3
1958-02-011.573796-493.1679690.6591331.702194-131.800592-299.6899100.0031270.0003990.0001091.271700...-0.000016-0.000014-2.016244e-07-5.969440e-087.09185711.9157900.032295-0.8347101.693005179.4
1958-03-01-4.403323-461.871850-0.570981-0.675173-1185.306200-586.329590-0.000708-0.000709-0.000149-3.920263...0.0000080.0000243.843178e-081.189981e-07-2.7671580.286086-1.069146-3.006988-3.90746727.6
1958-04-01-2.77158327.638861-0.502666-0.029506-529.931263-140.0201770.000243-0.000413-0.000057-3.140417...0.0000050.000009-7.566521e-094.726872e-08-0.809763-1.252618-1.183645-1.840023-1.81798162.5
1958-05-011.45293575.0496470.4930830.678390470.619645135.861848-0.0001610.0004970.0001421.807232...-0.000014-0.0000175.571874e-08-2.804966e-083.1677796.6122311.1087563.5154721.91789177.2
\n", "

5 rows × 23 columns

\n", "
" ], "text/plain": [ " t2m msl v10 u10 z500 z850 \\\n", "time \n", "1958-01-01 -0.599361 -349.782636 0.057458 0.030403 -341.345388 -287.186476 \n", "1958-02-01 1.573796 -493.167969 0.659133 1.702194 -131.800592 -299.689910 \n", "1958-03-01 -4.403323 -461.871850 -0.570981 -0.675173 -1185.306200 -586.329590 \n", "1958-04-01 -2.771583 27.638861 -0.502666 -0.029506 -529.931263 -140.020177 \n", "1958-05-01 1.452935 75.049647 0.493083 0.678390 470.619645 135.861848 \n", "\n", " tp q500 q850 t500 ... vo500 vo850 \\\n", "time ... \n", "1958-01-01 0.000917 -0.000109 0.000011 -0.024671 ... 0.000002 -0.000004 \n", "1958-02-01 0.003127 0.000399 0.000109 1.271700 ... -0.000016 -0.000014 \n", "1958-03-01 -0.000708 -0.000709 -0.000149 -3.920263 ... 0.000008 0.000024 \n", "1958-04-01 0.000243 -0.000413 -0.000057 -3.140417 ... 0.000005 0.000009 \n", "1958-05-01 -0.000161 0.000497 0.000142 1.807232 ... -0.000014 -0.000017 \n", "\n", " pv500 pv850 u500 u850 v500 \\\n", "time \n", "1958-01-01 1.244580e-07 -6.846847e-08 -0.218904 0.298243 0.319975 \n", "1958-02-01 -2.016244e-07 -5.969440e-08 7.091857 11.915790 0.032295 \n", "1958-03-01 3.843178e-08 1.189981e-07 -2.767158 0.286086 -1.069146 \n", "1958-04-01 -7.566521e-09 4.726872e-08 -0.809763 -1.252618 -1.183645 \n", "1958-05-01 5.571874e-08 -2.804966e-08 3.167779 6.612231 1.108756 \n", "\n", " v850 d2m Precipitation \n", "time \n", "1958-01-01 1.885623 -0.739180 82.3 \n", "1958-02-01 -0.834710 1.693005 179.4 \n", "1958-03-01 -3.006988 -3.907467 27.6 \n", "1958-04-01 -1.840023 -1.817981 62.5 \n", "1958-05-01 3.515472 1.917891 77.2 \n", "\n", "[5 rows x 23 columns]" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# reading data\n", "data= pd.read_csv(\"sample_data.csv\", index_col=[\"time\"], parse_dates=[0])\n", "y = data[\"Precipitation\"]\n", "X = data.drop([\"Precipitation\"], axis=1)\n", "print(X.shape, y.shape)\n", "data.head()" ] }, { "cell_type": "code", "execution_count": null, "id": "87c31590", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 21, "id": "9616380e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(516,) (228,)\n" ] } ], "source": [ "# defining training and testing time \n", "train_period = pd.date_range(start=\"1958-01-01\", end=\"2000-12-31\", freq=\"MS\")\n", "test_period = pd.date_range(start=\"2001-01-01\", end=\"2019-12-31\", freq=\"MS\")\n", "full_time = pd.date_range(start=\"1958-01-01\", end=\"2019-12-31\", freq=\"MS\")\n", "print(train_period.shape, test_period.shape)" ] }, { "cell_type": "code", "execution_count": 22, "id": "7aac4a3b", "metadata": {}, "outputs": [], "source": [ "# droping nan\n", "X = X.loc[~np.isnan(y)]\n", "y = y.dropna()\n", "\n", "X_train, X_test = X.loc[train_period], X.loc[test_period]\n", "y_train, y_test = y.loc[train_period], y.loc[test_period]" ] }, { "cell_type": "code", "execution_count": 23, "id": "acb29616", "metadata": {}, "outputs": [], "source": [ "# applying feature selection \n", "estimator = ARDRegression()\n", "scoring = \"r2\"\n", "n_jobs = -1 \n", "min_features = 5\n", "cv = TimeSeriesSplit(n_splits=5)\n", "rfcv = RFECV(estimator=estimator, scoring=scoring, cv=cv, n_jobs=n_jobs, min_features_to_select=min_features)" ] }, { "cell_type": "code", "execution_count": 24, "id": "b922cba4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(516, 13)\n", "Optimal number of predictors: 13\n", "Selected predictors: Index(['t2m', 'v10', 'u10', 'tp', 'q500', 'q850', 't500', 't850', 'r', 'u500',\n", " 'u850', 'v500', 'd2m'],\n", " dtype='object')\n", "Feature selection score: 0.6790316432914921\n" ] } ], "source": [ "#transforming data after feature selection \n", "rfcv= rfcv.fit(X_train, y_train)\n", "X_train_new = rfcv.transform(X_train)\n", "X_test_new = rfcv.transform(X_test)\n", "print(X_train_new.shape)\n", "print(\"Optimal number of predictors:\", rfcv.n_features_)\n", "print(\"Selected predictors:\", X_train.columns[rfcv.support_])\n", "print(\"Feature selection score:\", rfcv.cv_results_[\"mean_test_score\"].mean())" ] }, { "cell_type": "code", "execution_count": 58, "id": "ec08d173", "metadata": {}, "outputs": [], "source": [ "import warnings \n", "warnings.filterwarnings(\"ignore\")\n", "# defining models in level 1 BayesianRidge, ARDRegression, GammaRegressor, MultiTaskElasticNetCV, QuantileRegressor\n", "#lasso\n", "lassoCV = LassoCV(cv=cv, selection=\"random\")\n", "lassoLarsCV = LassoLarsCV(cv=cv)\n", "bayesianRidge = BayesianRidge(n_iter=1000) \n", "poissonRegressor = PoissonRegressor()\n", "ARD = ARDRegression(n_iter=1000)\n", "gamma = GammaRegressor() #gamma regressor do not accept standardized values (negative anomalies)\n", "MLP = MLPRegressor(random_state=42, max_iter=1000, early_stopping=True)\n", "bernoulli = BernoulliRBM()\n", "randomforest = RandomForestRegressor(n_estimators=100, random_state=42)\n", "decisiontree = DecisionTreeRegressor(random_state=42)\n", "extratree = ExtraTreeRegressor(random_state=42)\n", "#svr = SVR(gamma=\"scale\", kernel=\"linear\")\n", "\n", "#defining keras model from tensroflow !!!! This must be improved with detailed design\n", "def build_nn(plot_network=False):\n", " model=Sequential()\n", " model.add(Dense(512, activation=\"relu\", input_dim=13))\n", " model.add(Dense(256, activation=\"relu\"))\n", " model.add(Dropout(0.2))\n", " model.add(Dense(64, activation=\"relu\"))\n", " model.add(Dense(1))\n", " \n", " from ann_visualizer.visualize import ann_viz\n", " if plot_network ==True:\n", " ann_viz(model, title=\"Dense Model\")\n", " \n", " model.compile(optimizer=\"adam\", loss=\"mean_squared_error\", metrics=[\"RootMeanSquaredError\"])\n", " return model \n", "\n", "#++++trick for keras and sklearn compatibility +++(might be drepcated---use scikeras model...in future)\n", "keras_reg = tf.keras.wrappers.scikit_learn.KerasRegressor(build_nn, epochs=1000, verbose=False)\n", "keras_reg._estimator_type = \"regressor\"\n", "\n" ] }, { "cell_type": "code", "execution_count": 43, "id": "c4830131", "metadata": {}, "outputs": [], "source": [ "#plot network\n", "#build_nn(plot_network=True)\n", "#isinstance(gamma, GammaRegressor)" ] }, { "cell_type": "code", "execution_count": 59, "id": "329fe4ea", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "LassoCV 31.1341673611636\n", "R² score: 0.39\n", "ARDRegression 22.456580847098238\n", "R² score: 0.68\n", "GammaRegressor 31.722368930455\n", "R² score: 0.37\n", "MLPRegressor 35.57190810127707\n", "R² score: 0.21\n", "RandomForestRegressor 23.79390147281958\n", "R² score: 0.64\n", "LassoLarsCV 22.547571826766596\n", "R² score: 0.68\n", "BayesianRidge 30.999929781461233\n", "R² score: 0.40\n", "PoissonRegressor 30.241438827301796\n", "R² score: 0.43\n", "DecisionTreeRegressor 33.76214921029533\n", "R² score: 0.28\n", "ExtraTreeRegressor 32.74383094435165\n", "R² score: 0.33\n" ] } ], "source": [ "# checking the performance of the individual models\n", "estimators = [(\"lassoCV\", lassoCV), (\"ARD\", ARD), (\"Gamma\", gamma), (\"MLP\", MLP), \n", " (\"RandomForest\", randomforest), \n", " (\"Dense\", keras_reg), (\"Lars\",lassoLarsCV)]\n", "\n", "\n", "for reg in (lassoCV, ARD, gamma, MLP, randomforest, lassoLarsCV, bayesianRidge, poissonRegressor, \n", " decisiontree, extratree):\n", " reg.fit(X_train_new, y_train)\n", " yhat = reg.predict(X_test_new)\n", " print(reg.__class__.__name__, mean_squared_error(y_test, yhat, squared=False))\n", " print(\"R² score: {:.2f}\".format(r2_score(y_test, yhat)))" ] }, { "cell_type": "code", "execution_count": 30, "id": "299d87d9", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ExtraTree 25.097043545741442\n", "R² score: 0.60\n", "GradientBoosting 22.793677285840143\n", "R² score: 0.67\n", "HistGradientBoosting 24.67749187348157\n", "R² score: 0.62\n", "XGBoosting 25.87956878150102\n", "R² score: 0.58\n", "AdaBoost 23.789250532827243\n", "R² score: 0.64\n", "RandomForest 24.216042350714105\n", "R² score: 0.63\n" ] } ], "source": [ "#combinging level 1 output in level 2 GradientBoostingRegressor, GradientBoostingRegressor, StackingRegressor\n", "# AdaBoostRegressor, ExtraTreesRegressor, RandomForestRegressor, VotingRegressor, XGBoost\n", "\n", "#set display of models \n", "set_config(display=\"diagram\")\n", "\n", "# ensemble types (based on boasting ) voting or stacking generalization\n", "# different types of final estimator \n", "# tree-based \n", "extra_tree = ExtraTreesRegressor(random_state=42, criterion=\"squared_error\")\n", "#gradient boosting \n", "gradient_boost = GradientBoostingRegressor(n_estimators=25, subsample=0.5, min_samples_leaf=25, random_state=42)\n", "#HistGradientBoosting\n", "histgradient_boost = HistGradientBoostingRegressor(random_state=42)\n", "#XGBoosting\n", "xgboost_reg = XGBRegressor(random_state=42)\n", "#adaboost\n", "adaboost_reg = AdaBoostRegressor(random_state=42, n_estimators=100)\n", "\n", "#voting regressor\n", "#voting_reg = VotingRegressor(estimators=estimators) # default estimator: RidgeCV\n", "\n", "#Random Forest\n", "randomforest_reg = RandomForestRegressor(random_state=42)\n", "\n", "for estimator,name in zip([extra_tree, gradient_boost, histgradient_boost, xgboost_reg, adaboost_reg, \n", " randomforest_reg], [\"ExtraTree\", \"GradientBoosting\", \"HistGradientBoosting\", \"XGBoosting\",\n", " \"AdaBoost\", \"RandomForest\"]):\n", " stacked_regressor = StackingRegressor(estimators=estimators, final_estimator=estimator)\n", " stacked_regressor.fit(X_train_new, y_train)\n", " stacked_regressor\n", " yhat = stacked_regressor.predict(X_test_new)\n", " print(name, mean_squared_error(y_test, yhat, squared=False))\n", " print(\"R² score: {:.2f}\".format(r2_score(y_test, yhat)))\n", " " ] }, { "cell_type": "code", "execution_count": 32, "id": "441a898d", "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/html": [ "
StackingRegressor(estimators=[('lassoCV',\n",
       "                               LassoCV(cv=TimeSeriesSplit(gap=0, max_train_size=None, n_splits=5, test_size=None),\n",
       "                                       selection='random')),\n",
       "                              ('ARD', ARDRegression()),\n",
       "                              ('Gamma', GammaRegressor()),\n",
       "                              ('MLP',\n",
       "                               MLPRegressor(max_iter=1000, random_state=42)),\n",
       "                              ('RandomForest',\n",
       "                               RandomForestRegressor(random_state=42)),\n",
       "                              ('Dense',\n",
       "                               <keras.wrappers.scikit_learn.KerasRegressor object at 0x0000026486D4B2B0>),\n",
       "                              ('Lars',\n",
       "                               LassoLarsCV(cv=TimeSeriesSplit(gap=0, max_train_size=None, n_splits=5, test_size=None)))],\n",
       "                  final_estimator=RandomForestRegressor(random_state=42))
Please rerun this cell to show the HTML repr or trust the notebook.
" ], "text/plain": [ "StackingRegressor(estimators=[('lassoCV',\n", " LassoCV(cv=TimeSeriesSplit(gap=0, max_train_size=None, n_splits=5, test_size=None),\n", " selection='random')),\n", " ('ARD', ARDRegression()),\n", " ('Gamma', GammaRegressor()),\n", " ('MLP',\n", " MLPRegressor(max_iter=1000, random_state=42)),\n", " ('RandomForest',\n", " RandomForestRegressor(random_state=42)),\n", " ('Dense',\n", " ),\n", " ('Lars',\n", " LassoLarsCV(cv=TimeSeriesSplit(gap=0, max_train_size=None, n_splits=5, test_size=None)))],\n", " final_estimator=RandomForestRegressor(random_state=42))" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "stacked_regressor" ] }, { "cell_type": "code", "execution_count": 33, "id": "862c77ba", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAv4AAAH6CAYAAAB/HEgyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAC8OklEQVR4nOzdeXxTVfo/8E/SNN1LSZO2tJR9KS1lKZsgCgIqBRdkQP2CMlI3UHGccdcZZVREHNxR3KaO5QcoIrgAdakLoLIIBYGWIqWsLW1Tuq9Jmvz+wFyTNGmzr5/36zWv8d7ce3NyGtrnnvuc54h0Op0ORERERETk18SebgAREREREbkeA38iIiIiogDAwJ+IiIiIKAAw8CciIiIiCgAM/ImIiIiIAgADfyIiIiKiAMDAn4iIiIgoAEg83YBAUlZW5ukm+DS5XI6qqipPN8Nnsf8cxz50HPvQcexDx7D/HMc+dJyr+zAxMdHsfo74ExEREREFAAb+REREREQBwKtTfTQaDQoKCnD06FEcP34cVVVVqK+vR2trKyIjI9GnTx9MmDABkyZNglhs/h7m7Nmz2Lp1KwoKClBdXQ2JRIK4uDiMGjUKM2fORFRUlMX3r6+vx9atW5Gfn4/KykpoNBrIZDKkpaVh5syZSE5OdtVHJyIiIiJyKq8O/E+fPo1ly5aZfa2urg6//fYbfvvtN+Tl5eHxxx9HZGSk0TFfffUV/ve//0Gr1Qr71Go1Tp8+jdOnT+Pbb7/Fo48+ikGDBnW4flFREV588UU0NjYa7a+oqEBFRQW2b9+OhQsX4qqrrnLCJyUiIiIici2fSfWRSCQYPHgwRo4cidjYWKPXjh8/jvfee89o3759+5CdnS0E/RKJBMOGDcPAgQOFYxoaGrB8+XJUV1cbnVtVVYXly5cbBf0DBgzAsGHDIJFcvFdqb2/H+++/j/z8fKd+TiIiIiIiV/DqEX8AkMlkmDVrFiZNmoSwsDAAF1OAsrOzkZeXJxy3Z88eNDQ0ICoqClqtFh988IHwmlgsxtNPP43BgwcDAD777DOsW7cOANDU1ISPPvoI99xzj3D8Rx99hJaWFmF73rx5mDVrFgDg2LFjeOqpp6DT6QAAH3zwAUaOHAmRSOSaDiAiIiIicgKvHvHv0aMHXn31VUyfPl0I+oGLo/e33XYbgoKChH1arRbl5eUAgCNHjkCpVAqvpaWlCUE/AMyYMQMhISHC9i+//ILW1lYAQEtLC3bt2iW8FhISghkzZgjbgwcPRlpamrBdUVGBgoICZ3xcIiIiIiKX8erAPzw8HKGhoWZfk0qlCA8P73A8cDE/31D//v07nNurVy9hW6VSoaSkBABw4sQJqNVq4bVevXpBKpUanT9gwACj7aNHj1rzcYiIiIiIPMarA//OnDhxAg0NDcK2TCZDQkICAKC0tNTo2O7du3c433Sf/hzTRbbMnRsTE2P2XCIiIiIib+X1Of7mNDc3Y/Xq1Ub7Zs+eLaT+NDc3G71mmNZjaV9TU5PR/+uZe+Jgus/0HGfQ6XRoa2tDe3s7AHAOAS6mVbW1tXm6GT7L0/2nnxcTFBSEkJAQfqeJiIjczOcC/9raWixfvhxnzpwR9k2ZMsXmspr6IMSe40z3WQpg8vLyhAnIL7zwAuRyudXvWV5ejpCQEEgkEgZIBszdxJH1PN1/Op0OGo0GGo0GCQkJPvfdlkgkVv87JvPYh45jHzqG/ec49qHjPNWHPhX4l5eXY9myZaioqBD2TZkyBXfddZfRcaa5/+ZGOVUqldF2RESE0f93dq7pPtP305s2bRqmTZsmbFdVVZk9zlRra6sQ8OtH/OniPxKNRuPpZvgsb+k/kUgEkUiEsrIyj9+I2Eoul1v975jMYx86jn3oGPaf49iHjnN1HyYmJprd7zOBf0lJCZYvX466ujph3+zZs3HzzTd3ONb0w5rW6Te3T3+O6bk1NTVWn+ss7e3tPhcQEdkiKCgIbW1t/J4TERG5kU8E/ocOHcLKlSuFkptisRhZWVkW03uGDBlitF1cXGy0rVKpjFKFpFKpUPmnf//+CA4OFir7nDlzBiqVyqiyz4kTJ4yul5qaaucns8zXUiCIbMHvNxERkft5fVWfn376CcuXLxeCfqlUigcffLDTnP6hQ4dCoVAI24WFhUYlPrds2WKU6jNhwgRhwm5YWBjGjx8vvNbW1oatW7cK20VFRSgsLBS24+PjnR74MyiiQMDvORERkXt59Yh/SUkJ3njjDaPJtHK5HDt27MCOHTs6HD99+nSkpaVBLBZj4cKFePHFFwFcnFD4zDPPIDU1FS0tLTh+/LhwTkRERId0oZtvvhm//vqrsHrv+vXrsW/fPoSFhaGwsNCoPQsXLoRY7PX3T0RERGRAqVQiNzcXTU1NiIiIQGZmptGgIZE/8urAv6WlpUMFnbKysg619vVGjRol/Pfo0aOxcOFCfPjhh9BqtdBoNDh06JDR8ZGRkXjssccgk8mM9svlcjz++ONYsWKFUKrT8GYBgHBzkZGRYffnIyIiIvdTKpXIzs5GWloa4uPjoVarkZ2djaysLAb/5Ne8OvB3VGZmJtLS0rBt2zYcOXIENTU1CAoKQnx8PDIyMjBz5kxER0ebPTclJQWvvfYatmzZggMHDqCiogLt7e2QyWRIS0vDzJkzkZyc7OZPRERERI7Kzc1FWloagoODAQDBwcFIS0tDbm4uFixY4OHWEbmOVwf+aWlp2LBhg0PX6NWrFxYtWmTXudHR0Zg3bx7mzZvnUBvIuZKSkszuDwoKQkREBJKTkzFu3DgsWLAAAwcO7HDcf/7zH/z88884deoU6urqIJPJMH78eDz88MPo3bu3q5tvUXNzM7Kzs/HVV1/h5MmTaGlpgVwuFz7LmDFj7L52Q0MD1q1bh2+++QbFxcWoq6uDSCRC9+7dMWjQIEyfPh0333yz2QXrgIuVrN5991189913OHv2LNRqNRISEjBhwgTccccdGDx4sN1tIyJyt6amJsTHxxvtCw4OdsmCnETeRKSzdiUrcpilFCVTzc3NFtcGCGT6OvSWAn9zx69atQrXXnut0f4hQ4YgOjoao0aNQlRUFDZt2oTm5mYkJydjx44dRhWc3KW4uBjz5s1DaWmpxWPuu+8+PP744zZf+/Tp05g7d26n1wYuPuX65JNPOqS+/frrr7jttttQW1tr9jyJRIJnnnkGf/3rX21qly9+z1m72nHsQ8exDx0jl8vx8ssvQyaTCSP+AKBWq1FdXc0RfyvwO+g4T9Xx56xU8nlTpkzBjBkzMH78eKOgXaPR4NFHH0Vzc7PR8atWrcLu3bvx1ltvYcWKFfjHP/4BADh79iyOHTvm1rYDQGNjY4egf8iQIZgyZYrRgnKrVq3C//73P5uvv3TpUqNrh4aG4vLLL8eECRMgkfz50K+oqEiYEK9XWlqKW2+91SjoHzlyJC6//HKhrzUaDZ544glhlWoiIm+XmZmJgoICoXS3Wq1GQUEBMjMzPdwyItdi4E8+7/nnn8d7772HjRs3YsuWLUYjOHV1ddi3b5/R8VOnTjUqJalfl0E//8PdVq9ebRSY33rrrcjLy8OaNWvw9ddfGwX/y5cvR2Njo03X/+WXX4T/FovF+Oqrr7B+/Xp88sknWLNmjdGxe/fuNdpesWIFGhoahO0nnngCW7Zswfr167FhwwajilZPPfVUh8n4RETeSKFQICsrC9XV1SgpKUF1dTUn9lJAYOBPfiUtLa1DXr+51Zf13nvvPaxfvx4AsHjxYsTFxbm0feZ89NFHRtv333+/8N99+/Y1SlVqbGzEli1bbLq+4ah+dHS0Uf+YVqUyvMlobGw0WsMiPDwct99+u7A9ZswYozUvTp8+jZ9//tmmthEReYpCocCCBQuwePFiLFiwgEE/BQSvntxLZA/TUWdzo/harRbPPPMM3nvvPQDAHXfcgccee8zomAsXLnTYZ41LL70Ut912m1XHnjlzBuXl5cJ2XFxch7y8ESNGGN0c7Nmzp8PaE5254oorsHnzZgBAbW0tVq9ejVtuuQUajQavvvqq0bHXX3+98N+//fabsHAecHEOgOnk35EjRxoF+3v37sXEiROtbhsRERG5DwN/8itHjhwxWnMhISEBI0eONDqmpaUFS5YsQW5uLsRiMZ566inceeedHa7V3NyMbdu22dwGw1HzrhQXFxttm7tJMd1nek5XnnrqKZSUlOC3334DADz33HN47rnnjI4JCQnBnXfeiaysLIvvk5CQ0OHapk9IbG0bERERuQ8Dfx8U/dRTCC4s9HQzbKJOTUX9M8+45NpPPPEEQkNDUVNTg/3790Oj0QAAwsLC8PLLLyMkJMTo+Llz5+LAgQMAgKFDh0KpVOL5558HAMyfP9+tJT3r6+uNts1VuQkLCzParqurs+k94uLi8Omnn+LRRx/Fp59+avaYOXPm4LbbbjPK2Tdtm2k7zLXX1rYRERGR+zDwJ5/3/fffd9g3YsQIvPXWW2aDeH3QDwCHDh0yWtF58uTJwjnJycldlsB0NnOTY033GU5Mtsbvv/+OhQsX4tSpUwAuBusjR46EVqvF/v37oVKpsHbtWmzbtg05OTkWV6N2RduIiIjIfRj4+yBXjZz7k4MHD2Lp0qV49913jar8AHB7MN8Z05WjW1paOhxjmGdv7pzOqNVq3H777ULQL5fLsW3bNmEthKNHj+Kaa65Ba2srampq8OCDD+K7776DWCzu8D6m7TDXXlvaRkRERO7FwJ983u7du6FQKLB371787W9/Q2VlJQDgm2++wfPPP4+nn37aruu6Y3Jv//79jbYNJ/rqnT9/vtNzOpOfn4+SkhJh+5prrjFaAG3IkCGYMGGC8NTk999/x5kzZ9CnT58O72PaDnPttaVtRERE5F4M/Mkv6BelevPNNzF37lxhf3Z2NubPn48BAwbYfE13TO7t3bs3EhIShABaqVSitLTUKDg/ePCg0TmXXHKJ1dc3DdbNpeIY5vUDF294+vTpgxEjRiA0NFQY6S8qKkJra6tRZR/DtCkAGDdunNVtI/JFSqUSubm5aGpqQkREBDIzM1kGkoh8Buv4k1+ZMGECpkyZImxrNBq88sorHmxR10xLc7722mvCf584ccKoln5kZCSuueYao+PHjRuHpKQk4X+GTEuDbt261ehmoKioCD/99JOwLRKJ0KtXL+G9Zs6cKbzW0tIilD8FLpbu3LNnj7Ddu3dvTJgwoesPTOSjlEolsrOzIZPJ0K9fP8hkMmRnZ0OpVHq6aUREVhHpuNSm25SVlVl1XHNzs9nqLoFOIpFAo9F0CG53796N5ORkYTs/P99o0SuxWIzvvvsOgwYNcltbbdHY2IgpU6YYzT0YMmQIevTogd27d6O5uVnYv2zZsg5pROPGjcO5c+eEbcPrtLe347LLLsPp06eFfeHh4cjIyEB7e7swuVdv8uTJWLt2rdG1pk6darR678iRIxEVFYXdu3cbnfvhhx9i2rRpVn9uX/yey+VyVFVVeboZPs2X+zAnJwcymcxo3pBarUZ1dTUWLFjgtnb4ch96A/af49iHjnN1H5oO/OlxxJ/8TkZGBiZNmiRsa7VavPzyyx5sUeciIyOxbt06oxuao0eP4vvvvzcK+u+77z6r5w7oBQUF4e2330ZsbKywr7m5GT/99BN27dplFLgPHDgQK1euNDo/KSkJa9asQUxMjLDvwIED2LFjh3BuUFAQli1bZlPQT+SLmpqaOhQLCA4ORlNTk4daRERkG+b4k1/6+9//ju3btwvbW7ZsQVFREVJSUjzYKssGDBiAH374AdnZ2fjqq69QUlKC1tZWyOVyjB07FrfddhvGjBlj17WHDRuGHTt2YN26dfjuu+9w/Phx1NfXQyQSoXv37khJScHVV1+Nm2++ucOaBwAwZswY7Ny5E++88w6+++47nDlzBu3t7YiPj8ell16KO+64A4MHD3a0C4i8XkREBNRqdYcRf1vm9RAReRJTfdyIqT6O0af6kH28rf988XvOx9uO8+U+1Of4p6WlITg4GGq1GgUFBcjKynLrBF9f7kNvwP5zHPvQcUz1ISIi8mIKhQJZWVmorq5GSUkJqqur3R70ExE5gqk+REREVlIoFG6dyEtE5Ewc8SciIiIiCgAM/ImIiIiIAgADfyIiIiIiJ4l4910kJiUh9qabPN2UDpjjT0RERETkoODDh6GYPl3Ybhs3zoOtMY+BPxERERGRnURNTYgbPx5BFy4I+8oPHIA2Ls6DrTKPqT5eiEsrUCDg95yIiHxd9L/+hR6DBglB/4W1a1FWWuqVQT/AEX8iIiIiIpuEfPcdYg1K+zbefjvqn3nGgy2yDgN/LyQSiaDVaiEW84EM+SetVguRSOTpZhAREdlEXFGBhIwMYbs9Ph6VP/0EnY+sRM/A3wtJpVKoVCqEhoZ6uilELqFSqSCVSj3dDCIiIutotZDdeitCf/xR2FX59dfQDB3quTbZgUPKXkgikUCr1aKtrY150ORXdDod2traoNVqIZFw3IGIiLxf+Nq1SExOFoL+umeeQVlpqc8F/QBH/L1WWFgYNBoNmpubAYBpEQBCQkLQ1tbm6Wb4LE/3n/4mViqVcrSfiIi8nuTYMcRNmSJst40bhwsbNgA+PHDluy33cyKRCMHBwQgODvZ0U7yGXC5HVVWVp5vhs9h/REREVmhpQdyUKZCcOSPsqti7F+1JSR5slHMw1YeIiIiICEDU8uVIHDBACPqr//tflJWW+kXQD3DEn4iIiIgCnPSXXyCfO1fYbvq//0Pdf/4D+FmqNQN/IiIiIgpI4upqJKSnC9va8HBU7N8PXXS0B1vlOkz1ISIiIqLAotOh+913GwX9yi++QPnx434b9AM+MOJfUVGB/Px8nDhxAsXFxTh//rxRictVq1YhzmRZ5IKCAvz73/+2+j0UCgXefPNNYbuyshL33XefVee+++67iImJsfq9iIiIiMhzwjZvRneDOK/+scfQuGSJB1vkPl4f+G/fvh0bN270dDOIiIiIyIcFnTyJ+IkThW3V0KGo+vJLIIBKTHt94G8oODgYIpEIKpWq0+Oio6Mxbtw4i6+fOnUKFRUVwnb//v07vd7IkSMt1h1nuU0iIvIFSqUSubm5aGpqQkREBDIzM6FQKDzdLCLXU6mgmDkTwYWFwq6Kn39Ge58+nmuTh3h94J+SkoK7774b/fv3R3JyMp599lkUGvzgzElOTsaDDz5o9jWtVou//e1vRvuuueaaTq93++23d0gnIiIi8hVKpRLZ2dlIS0tDfHw81Go1srOzkZWVxeCf/Frk668jesUKYbvmjTfQMnu2B1vkWV4f+A8bNsyp19u3b5/RaP/gwYMxaNAgp74HERGRN8nNzUVaWprwlDo4OBhpaWnIzc3FggULPNw6IucL3r8fiuuuE7ZbrrsONW+95XflOW3l9YG/s23ZssVou6vRfgDYunUrmpqaoNVq0a1bNwwcOBCjR4+2mP5DRETkTZqamhAfH2+0Lzg4GE1NTR5qEZFriOrqED9qFMQtLcK+8sOHoZXJPNgq7xFQgf+JEydQVFQkbMfHx2PMmDFdnpebm9thX1RUFO6++26MHTvWqW0kIiJytoiICKjVaqN5aWq1GhERER5sFZET6XSIefBBhH/8sbCr6pNPoJowwYON8j4BFfh/+eWXRtszZ86EWGzfUgYNDQ14+eWX8dhjj2HEiBFmj8nLy0NeXh4A4IUXXoBcLrfrvegiiUTCPnQA+89x7EPHsQ8dZ08fzp8/H2+88QaGDBkCqVQKlUqF4uJiLFmyJOB+HvwOOs7b+lD0+ecIvvFGYbv9kUfQ/uyz8OZq/J7qw4AJ/KuqqrBnzx5hOyIiApMnTzZ7bFBQEIYPH44xY8YgJSUFCoUCarUahYWFWLNmDZRKJYCLE4U//PBDi4H/tGnTMG3aNKM2kP3kcjn70AHsP8exDx3HPnScPX0YFBSE+fPnG1X1mT9/PoKCgpz+8/D26kH8DjrOW/pQXFqKBIPMC02fPqjMywPCwgAvaF9nXN2HiYmJZvcHTOCfm5uL9vZ2YfvKK69EaGio2WNjY2Px5JNPGu0LCwvDJZdcgoSEBDzyyCPC/tLSUlRWVrLqDxEReTWFQuHyibysHkRuodEgdu5chOzdK+yq/OEHaFispUv25bn4mNbWVnz33XfCtkQiwfTp0+26Vp8+fRAZGWm0r7a21pHmERER+YXOqgcROUPE++8jsXdvIeivffFFlJWWMui3UkCM+H///fdobm4Wti+99FLIOpnd3d7ejqCgILOvNTU1daiCEB4e7pyGEhER+TBWDyJXkRw5grirrxa2W6dMQfWHHwJ2ztUMVH4f+Gu12g4jDV2V8HzppZfQq1cvTJ061ejRZHNzM1avXg2dTifsi4qKsphHRUREFEhYPYicTdTUhLhLL0XQH/MrAaA8Px9akxtMso7XB/75+fn49NNPhe1z584Zvb5y5UrhF0xMTAwefvhho9f37t1rtGDXsGHD0Lt3707fs7m5GZs2bcKmTZuQmJiIhIQEtLW14eTJk0ZPDgBg9uzZdlcGIiIi8ieZmZlCjn9wcDDUajUKCgqQlZXl6aaRD4p+6ilE/ve/wvaFNWvQNmWKB1vk+7w+8K+vr8fx48ctvn7q1Cnhv81NHNq6davRtjULdokMVnUrKytDWVmZ2WOuvfZazJw5s8vrERERBQKFQoGsrCyjqj6c2Eu2CvnhB8Tecouw3bhwIeqfe86DLfIfXh/4O6K4uBjHjh0TtpOTky2W3jT097//HXv37sWRI0dQVlaG2tpaNDQ0QCqVQi6XY8iQIZg6dSr69u3rwtYTERH5HndUDyL/JK6sRMLIkcJ2u1yOyl9+gY6pYk4j0hkmrJNLmXtyQNbzlrrBvor95zj2oePYh45jHzqG/ec4p/ehVgvZX/+K0O+/F3ZVfv01NEOHOu89vIyn6vgzOZ2IiIiIPCJ83TokJicLQX/d0qUXy3P6cdDvSX6d6kNERERE3kdy/DjiJk8WttvGjMGFjRsBCUNTV2LvEhEREZF7tLYibto0SE6eFHZV7NmD9p49PdiowMFUHyIiIiJyuagVK5DYv78Q9Fe/9x7KSksZ9LsRR/yJiIiIyGWku3ZBPmeOsN18002ofeklwKB8OrkHA38iIiIicjpRdTV6pKcL29rQUFTk50PXrZsHWxXYmOpDRERERM6j06H74sVGQb/y889RfuIEg34PY+BPRERERE4R9tlnSOzZE2FffAEAqH/kEZSVlkI9erSHW0YAU32IiIiIyEFBp04h/tJLhW11aiqUW7cCUqkHW0WmGPgTERERkX1UKsivvRbSI0eEXRU//YT2vn092CiyhKk+RERERGSzyFWrkNi3rxD017z++sXynAz6vRZH/ImIiIjIaqJff0XixInCdsuMGah5912W5/QBDPyJiMgipVKJ3NxcNDU1ISIiApmZmVAoFJ5uFhF5gKi+HvGjR0Pc1CTsKz90CNrYWA+2imzBVB8iIjJLqVQiOzsbMpkM/fr1g0wmQ3Z2NpRKpaebRkTupNOh20MPoceQIULQX/XxxygrLWXQ72MY+BMRkVm5ublIS0tDcHAwACA4OBhpaWnIzc31cMuIyF1Cv/4aiT17ImL9egBAw733QtXWBpVBqg/5Dqb6EBGRWU1NTYiPjzfaFxwcjCaDx/xE5J/EpaVIGDtW2Nb06oXK778HwsIQ4sF2kWMY+BMRkVkRERFQq9XCiD8AqNVqREREeLBVRORSGg1ib7wRIXv2CLsqv/8emsGDPdgocham+hARkVmZmZkoKCiAWq0GcDHoLygoQGZmpodbRkSuEJGdjcTevYWgv/aFF1BWWsqg349wxJ+IiMxSKBTIysoyquqTlZXFqj5+xtsrN3l7+/yBpKAAcVddJWy3TpqE6jVrgKAgD7aKXIGBPxERWaRQKLBgwQJPN4NcRF+5KS0tDfHx8VCr1cjOzvaaGzxvb5+vEzU3I27iRARVVAj7yvfvhzYhwYOtIldiqg8REVGA8vbKTd7ePl8W/fTT6DFwoBD0X8jJuViek0G/X2PgT0REFKCampqMJm8D3lW5ydvb54tCtm9HYlISIt9/HwDQ9Ne/oqy0FG1Tp3q4ZeQOTPUhIiIKUN5eucnb2+dLxEolEkaMELbbZTJU7toFXWSk5xrlp7x5XgpH/ImIiAKUt1du8vb2+QStFrIFC4yCfuVXX6Hi8GEG/S7g7SueM/AnIiIKUPrKTdXV1SgpKUF1dbVXTZz19vZ5u7CPPkJicjJCv/sOAFD31FMoKy2FOj3dwy3zX94+L4WpPkRERAHM2ys3eXv7vJGkuBhxkyYJ26pRo1C1aRMgYdjnat6+4jm/AURERATAu3OTyQqtrVBcdRWCT5wQdlXs3o325GQPNiqwePu8FKb6EBERkdfnJlPnol58EYn9+wtBf/W776KstJRBv5t5+7wUjvgTERFRp7nJTLXxXtLduyH/y1+E7ea5c1H7yiuASOSS91Mqldi4cSOUSiWfCpnh7SueM/AnIiIir89NJmOimhokpKdDpNMBAHQhISjPz4cuJsZl76l/KjRixAhERUVxJWULvHleClN9iIiISMhNNuRNucn0B50OMffeix5DhwpBv/Kzz3C+pMSlQT/w51MhqVQKwPsq1lDXGPgTERGR1+cmExD6+edI7NkT4Z99BgCof+ihi+U5x4xxy/tzJWXfx1QfIiLye6xW0zVvz00OZEGnTyN+wgRhWz14MJS5uUBIiFvboX8qpB/xB/hUyNd4feBfUVGB/Px8nDhxAsXFxTh//jx0fzzaAoBVq1YhLi6uw3k//vgj3nrrrS6vn5iYiFdffdXsa/X19di6dSvy8/NRWVkJjUYDmUyGtLQ0zJw5E8mcKU9E5PX0eclpaWmIj49nXnInvDk3OSCp1ZBfdx2khw4Juyp27kR7v34eaU5mZqaQ43+xeRefCmVlZXmkPWQ7rw/8t2/fjo0bN7r9fYuKivDiiy+isbHRaH9FRQUqKiqwfft2LFy4EFdddZXb20ZERNZjtRryRZFvvYXoZcuE7ZpXX0XL3LkebNGfT4W2b98uVPXhDbRv8frA31BwcDBEIhFUKpVN54WEhAh3p6ZkMlmHfVVVVVi+fDlaWlqEfQMGDEB4eDgKCwuh0WjQ3t6O999/H3K5HBkZGTa1h4iI3IfVasiXBB88CMXMmcJ2S2Ymat57z2XlOW2lUCiwaNEiVFVVebopZAevD/xTUlJw9913o3///khOTsazzz6LwsJCm64RHR2NBx980OrjP/roI6Ogf968eZg1axYA4NixY3jqqaeEdKMPPvgAI0eOhMhL/kESEZExb19JkwgARA0NiB89GmKDTIPyQ4egjY31YKvI33h9VZ9hw4Zh6tSp6NOnD4KCglz+fi0tLdi1a5ewHRISghkzZgjbgwcPRlpamrBdUVGBgoICl7eLiIjsw2o15NV0OnR75BH0SEkRgv6qjz5CWWkpg35yOqeO+Gu1WuTn5+PcuXOIiorCqFGjEOPimrLWaGlpwZo1a1BTU4OgoCDExsYiLS0NQ4cO7TBSf+LECaM6xr169TKavQ5cTPs5cuSIsH306FEMHTrUtR+CiIjswmo15K1CvvkGsQsXCtuNixej/p//9GCLyN/ZFPifOHECGzduRHh4OJYsWWL0WktLC5599lmcOHFC2BcaGoolS5Zg9OjRzmmtnRobG/Hll18a7du0aRN69+6N+++/36g6T1lZmdFx3bt373A905uZ0tJS5zWWiIicjtVqyJuIy8qQYFB7X9OzJ5Q//ghdWJgHW0WBwKZUnz179iA/Px8SScf7hfXr1xsF/QDQ2tqK1157DRcuXHCslS5y+vRpPPPMM6iurhb2mU72Cg0N7XCe6T5OECMiIqIutbcjdu5co6C/8rvvULlnD4N+cgubRvz1k2rHjh1rtL+trQ0//PADgIu5lHPnzkV5eTleeuklXLhwAV9//TXmzZvnpCZbJywsDBMnTsTYsWPRq1cvyOVy1NfXY/fu3Vi/fr2QzlNXV4dNmzbhjjvuMHsdwzUDLO2zNLE3Ly8PeXl5AIAXXngBcrnckY8U8CQSCfvQAew/x7EPHcc+dBz70DGe6j/x229D8re/Cdua11+H9u67EeP2ljiO30HHeaoPbQr8a2pqAKDDglmHDx+GSqVCTEwMFixYALFYjP79+2Pu3Ll4++23cejQIbcH/uPGjcO4ceOM9snlclxzzTUQiUT48MMPhf0HDhwQ/tu0ykNbW1uHa5vuCw8PN9uGadOmYdq0acI2S185Ri6Xsw8dwP5zHPvQcexDx7EPHePu/pMUFiLuyiuF7bbLLsOFtWuBoCDAR3+O/A46ztV9mJiYaHa/TYF/fX09gI5570ePHgUAjBo1CmLxn9lDqampAIDy8nJb3sbl0tPTjbb1NzRAx44yfE3PMDXI3DlEREQU2ETNzYi77DIEGcRA5fv3Q5uQ4MFWUaCzKfDXp7i0tbUhMjJS2F9UVAQAGDJkiNHxUVFRAGDzglvO0N7ebrH8Z2VlpdG24Yh9//79ERwcLKQCnTlzBiqVyqiyj+lcBv0NDhERAUql0qiCTmZmJivoUECJfuYZRL7zjrB94X//Q5vBqD+Rp9g0uVc/0m9YxaaxsRElJSUAgEGDBhkdr18ES38D4E4PPPAAvvnmGzQ3NxvtLy8vx5o1a4z2paSkCP8dFhaG8ePHC9ttbW3YunWrsF1UVGS0gFh8fDwDfyKiPyiVSmRnZ0Mmk6Ffv36QyWTIzs6GUqn0dNOIXE66YwcSk5KEoL9pwQKUlZYy6CevYdOI/6BBg1BZWYkvv/wSQ4cOhVgsxhdffAGtVov4+PgOS6LrbxAcqeWfn5+PTz/9VNg+d+6c0esrV64UVmOMiYnBww8/DODiwlrvv/8+PvjgA/Tu3Rvdu3dHfX09SkpK0N7eLpwfFBSEG264weiaN998M3799VfhxmX9+vXYt28fwsLCUFhYaDS5d+HChUbpTUREgSw3NxdpaWnC7+Xg4GCkpaUhNzeX5TTJb4mrqpAwfLiwrY2JQcWePdAZZEcQeQObAv+rr74aP/30Ew4dOoRFixYhOjoaZ8+eBQBcddVVHY7XL3LVp08fuxtYX1+P48ePW3z91KlTwn+be5Tc3t4uPJEwFRYWhsWLF6N///5G++VyOR5//HGsWLFCKNVp2gaxWIyFCxciIyPD2o9CROT3mpqaOgwCBQcHs+yxF2EqlhNptZBlZSH022+FXcrcXKiHDfNgo4gss3nEf/78+Vi/fj3q6upQV1cHABgzZgxmzJhhdKxOp8Mvv/wCoONkWnd45ZVXsHfvXhQVFUGpVKK2thYtLS0IDQ1FYmIihg8fjmnTpkEmk5k9PyUlBa+99hq2bNmCAwcOoKKiAu3t7ZDJZEhLS8PMmTONFv4iIqKLldHUarUw4g8AarW6Q8U08gx9KlZaWhri4+OhVquRnZ3NlYztEPbxx+j+j38I23X/+heaFi3yYIuIuibSmStU34Xz58/jt99+Q3t7O/r27Ws2x728vBybNm0CANxyyy2Ijo52vLU+znRVYLINy4c5hv3nOPZh1wwDS32hhIKCAiGwZB86zpE+zMnJgUwm63BjVl1dHTCpWI5+B4OKixE/aZKwrRo5ElWbNwMGferv+O/YcT5RzlOvR48e6NGjR6fHJCQk4J577rHn8kRE5KMUCgWysrKMUkk4muw9mIrlgLY2KK6+GsEGqb8Vu3ejnU//yYfYFfgTEZH38ZbcbYVCETCjx76GqVj2iXrpJUS9/LKwXb16NVqvu86DLSKyj92Bv1qtxm+//YaSkhLU19dDrVZj8eLFwusajQatra0Qi8UWV7YlIiLnYO62+3nLjZYtMjMzLaZiUUfSvXshN6j81zx7Nmpffx0QiTzYKiL72RX4f//991i/fr2wkq+eYeBfU1OD+++/HyKRCO+++67Rgl9ERORcLKPpXr56o8VULOuIamqQMHw4RH+U/9YFB6P84EHoHChPTuQNbC5Av2HDBrzzzjuor69HSEgI+vXrZ/Y4hUKBESNGoL29Hfv27XO4oUREZFlTU5NR+gbA3G1X6uxGy9vpU7EWL16MBQsWMOg3pNMh5r770GPoUCHor9q8GedPnWLQT37BpsD/999/FxbTmj17Nt5//308/fTTFo8fO3YsADDwJyJyMX3utiHmbrsOb7T8T+gXXyCxZ0+Eb94MAGj4xz9QVloK1R+xDJE/sCnw149kXHHFFbjpppsglUo7PV6/MNbp06ftbB4REVkjMzMTBQUFQvCvz93OzMz0cMv8k+mNVl1dHbZv346ioiLk5ORAqVR6sHVki6AzZ5CYlATZH+nK6oEDUVZSgoYHH/Rwy4icz6bAv6ioCAAwffp0q46P+eOxWG1trU2NIiIi2+hzt6urq1FSUoLq6mqrc7eVSiVycnKwevVqBq1WMrzRqqurw65duxAfH4+pU6dCJpMhOzub/ejt1GrIZ85E/Pjxwq6K7duh/PFHICTEc+0iciGbJvfqJ/PGxcVZdbxYfPG+QqvV2tgsIiL38MXKLJbYU0bTVyepeprhJNk9e/YgPT0diYmJCPkjYOTEau8WsXo1uj33nLBd8/LLaLnpJg+2iMg9bBrxDw0NBQA0Nzdbdbx+RTJW9CEib6QPemUyGfr16xeQI7W+PEnV0/Q3WkOHDkXfvn2FoB9gvr+3Cv7tN0hDQoSgv+Xqq1F29iyDfgoYNo34JyQkoLi4GMeOHYNcLu/yeP2k3l69etnXOiIiG9kygs8SmNav5OpPT0acjYtieT9RYyPix42D2CD1uPy336C1IpYh8ic2jfhnZGQAAD777LMO1SNMnT9/Hlu2bAEAjB492s7mERFZz9YRfFZmsa4aEJ+MdI4Tq71bt8cfR4/Bg4WgX711K8pKSxn0U0CyKfCfPn06IiMjcebMGfzzn//EyZMnOxyj0Wiwc+dOPPXUU2hpaYFMJsMVV1zhtAYTEVlia9oKS2BaF7QyHahzjkysJtcJ+eYbJCYlISInBwDQePfdKCsthW7aNA+3jMhzbEr1iYiIwN///ncsX74cp06dwmOPPYaoqCjh9SeeeAKlpaVobW0FAEilUvz973/vsuwnEZEzWJu2opeZmSlMbA0ODhaC3qysLHc01ytYs5Krrf0aiOyZWE2uIT5/HgkGmQaaxEQod+yALizMg60KPEwP9E42Bf4AMHToUDz77LNYvXo1zpw5g4aGBuG1EydOCP+dnJyM++67D3369HFKQ4mIumJrrrU1QW8g6CpoZQ47+YT2dsTOm4eQn34SdlV++y00qakebFRgYrUw7yXS6XQ6e08uKCjA4cOHUVZWhubmZoSGhiIuLg7Dhw/H8OHDndlOv1BWVubpJvg0uVwuVIoi2wVC/xn+sTEdwXfGH5tA6ENznNmvgdqHzsQ+7Cj8ww8R88QTwnbtsmVovu02s8ey/xzXVR/m5ORAJpN1GCyorq7mk7E/uPp7mJiYaHa/zSP+htLS0pCWlubIJYiInIYj+K7BfiVvJTl6FHEGOfttl16KC+vXA0FBHmwVMT3QezkU+BMReRvmWrsG+5W8iailBYrLL4fE4El6+b590Pbo4cFWkR7TA72XTVV9iIiIiDwp+rnn0GPAACHov/DBBxfLczLo9xosceu9bBrx3759u91vNGnSJLvPJSIiosAm3bkT8ptvFrabbrkFdS+8AIhEHmwVmcP0QO9lU+D/1ltv2fUmIpGIgT8RERHZTFxVhQSDgiHa6GhU7N0LnUE5cfI+TA/0Tm5J9XGgcBAREREFIq0W3bOyjIJ+5datKD96lEE/kZ1sGvH/+OOPO31dq9WiuroaBw8exKeffgqpVIpHHnkESUlJDjWSiIiIAkfYJ5+g+wMPCNv1Tz6Jxnvu8VyDiPyEU0f8xWIx5HI5pk2bhuXLl6O9vR3Lli1DY2OjM9+GiIiI/FDQiRNITEoSgn7ViBEoO3WKQT+Rk7gs1ScmJgY33ngjLly4gM8++8xVb0NERES+rq0NiilTEH/55cKuil27ULV1K2BQEpKIHOPSOv5Dhw4FAPz666+45ZZbXPlWREREPkGpVBpVO8nMzAzoaieRL7+M6JdeErar33oLrddf78EWEfkvl07ulUqlAIALFy648m2IiIh8glKpRHZ2NmQyGfr16weZTIbs7GwolUpPN83tpL/+isSkJCHob541C2XnzjHoJ3Ihl474FxUVAQBCQkJc+TZEREQ+ITc3F2lpacKKpsHBwUhLS0Nubm7AlD4U1dYiYcQIiP5Y3EknFqP8t9+gk8k83DIi/+eyEf8zZ87ggw8+AAAMHDjQVW9DRETkM5qamoSgXy84OBhNTU0eapEb6XSIuf9+9EhLE4L+qk2bcP7sWQb9RG7i9AW8VCoVzp8/j1OnTgG4WOln1qxZ9rSNiIjIr0RERECtVhsF/2q1GhERER5sleuFbtkC2d13C9sNDzyAhocf9mCLiAKTTYH/9u3bbbp4aGgo7rzzTqSkpNh0HhERkT/KzMxEdna2kO6jVqtRUFCArKwsTzfNJYLOnUP8uHHCtrp/fyi/+QYIDfVgq4gCl02B/5AhQyASiTo9RiqVIiYmBgMHDsQll1yCyMhIhxpIRETkLxQKBbKysoyq+mRlZflfVR+1GvLZsyHNzxd2VW7fDs2AAR5sFBHZFPgvXbrURc0gIiIKDAqFwq8n8ka8/Ta6PfussF3z8stouekmD7aIiPRcWtWHiIiIAkPwoUNQZGYK261XXonq7GxA7NLK4URkA68P/CsqKpCfn48TJ06guLgY58+fh06nE15ftWoV4uLiOpxXXFyMwsJCFBUVoaKiAnV1dWhqakJoaCgSExORkZGBq6++2mwqUmVlJe677z6r2vfuu+8iJibG7s9HRETky0SNjYi75BIE1dQI+8oPHoTW39KXiPyA1wf+27dvx8aNG20+79///jfa2to67G9qasLx48dx/PhxfPXVV3jiiSfQt29fZzSViIgooHR78klE/O9/wvaFdevQNmmS5xpERJ2yGPjbE2x3Zs6cOQ5fIzg4GCKRCCqVyupzRCIRkpOTIZfLoVQqcfbsWeG1uro6rFy5Eq+88oqwyrA5I0eOtPi6aT1mIiKyjlKpNJrkmpmZ6X+TXP1USF4eYv/6V2G78c47Uc95gERez2Lg/8knnzj1jewN/FNSUnD33Xejf//+SE5OxrPPPovCwsIuzwsJCcHVV1+N6dOnQy6XC/u3b9+ON998U9hWKpU4ePAgxo4da/Fat99+u9l0IiIi6siagF6pVAplLePj46FWq5Gdne2fFW78iLi8HAmjRgnb7QkJqNy5E7rwcA+2ioisZTHwNwyWPWnYsGF2nffiiy9CZmYlwEmTJiEvLw/Hjh0T9pWVldndPiIi+pO1AX1ubq5Qyx64+PQ0LS0Nubm5fl3xxme1t0N2yy0I3bFD2FX5zTfQpKV5sFFEZCuLgb/hqLgvMhf063Xv3t1oO7yLkYqtW7eiqakJWq0W3bp1w8CBAzF69OhO04OIiAKRtQF9U1MT4uPjjc4NDg5GU1OTW9tLXQtfswYxjz0mbNc9+yya/HTBMSJ/5/WTe52tra2tQ6pQampqp+fk5uZ22BcVFYW777670xQhIvJ/zFM3Zm1AHxERAbVabTRPSq1WIyIiwi3tpK5JiooQN3WqsN02fjwufPwxEBTkwVYRkSMCKvDX6XR47733UF9fL+wbP348evbsafO1Ghoa8PLLL+Oxxx7DiBEjzB6Tl5eHvLw8AMALL7zgNelTvkoikbAPHcD+c5xpH1ZUVGDt2rUYMmQIpFIpVCoV1q5diyVLlnQIfgOF/qbH8ImoSqWCQqGAXC4X+nD+/Pl44403jPquuLgYS5Ys4fe0Cy7/t9zSguDhwyE6fVrYpSouhig5Gf7wk+HvQsexDx3nqT4MmMC/vb0d77zzDnYY5Cf27dsXixYt6nBsUFAQhg8fjjFjxiAlJQUKhQJqtRqFhYVYs2YNlEolAECr1eLDDz+0GPhPmzYN06ZNE7arqqqc+6ECjFwuZx86gP3nONM+XLt2LQYMGAAAQrWxAQMGYO3atQGbpz5p0iQhxz84OBhqtRoFBQXIyspCVVWV0IdBQUGYP3++0dOS+fPnIygoiN/TLrjy33LU888jyiDVtzo7G61XX31xw09+Lvxd6Dj2oeNc3YeJiYlm9zsU+KtUKlRUVKC5uRnt7e2dHttVOo0rtbW14eWXX8aBAweEff3798eTTz6JsLCwDsfHxsbiySefNNoXFhaGSy65BAkJCXjkkUeE/aWlpaisrGTVH6IAxDz1jhQKBbKysowCekuVehQKRcDeIHkb6U8/QX7TTcJ20/z5qFuxAhCJ3NoOps4RuZZdgf9vv/2Gzz77DEVFRdBqtV0eLxKJ8NFHH9nzVg6rr6/HihUrcPz4cWHf8OHD8eCDDyI0NNTm6/Xp0weRkZFobGwU9tXW1jLwJwpAzFM3jwG97xBfuIAEg+p52shIVPz6K3TR0W5vC0u8ErmezYH/Z599hvXr19t0jk6ns/VtnEKpVGLZsmVG5TonTZqERYsWIaiTyUnt7e0WX29qauowmtdVVSAi8k+ZmZkW01rIdwXEqLNOh+533okwg+IVyi+/hDojw2NNYolXItezKfAvLi4Wgv7rr78el19+OR588EEAwMqVK9He3o4zZ85gx44dOHz4MHr27Il77rkH0R4YOTh9+jSef/551NTUCPtmzZqFefPmdXnuSy+9hF69emHq1KlGv+ybm5uxevVqoxuZqKgoi3lUROTfbElroYsB9caNG6FUKr02oA6EUeewjRvR/W9/E7brH38cjffd58EWXcTUOSLXsynw/+qrrwAA48aN6xBAx8XFISQkBH369MHll1+OH3/8Ee+88w7efvttLFu2zO4G5ufn49NPPxW2z507Z/T6ypUrhdGBmJgYPPzwwwCAp59+Gs3NzcJxkZGROH/+PF566aUO75GWlobp06cL283Nzdi0aRM2bdqExMREJCQkoK2tDSdPnjS6JgDMnj0bYrHY7s9HRL6NaS3W0QfUI0aMQFRUlNcG1P486hxUUoL4yy4TtlXp6aj64gvAS9akYeocuVNAPNkzw6bAX7/arWGlGj3TdJ7Jkyfj9OnT2LZtG7Zt24ZZs2bZ1cD6+nqj/HxTp06dEv7bdHTeUGNjI/bs2WP2Gqa5/iKDyUxlZWVmV/YViUS49tprMXPmzE7bT0REfwbU+tKdhgF1Zmam1/wB9stRZ5UKihkzEHz0qLCr4pdf0N67twcb1RFT58hdAuHJniU2DVXX1tYCMC4RpA+SNRpNh+OvuOIKAMDu3bvtbZ9H/P3vf8ddd92FCRMmoE+fPoiJiUFQUBDCwsKQnJyMq666Ci+88AJuueUWTzeViMgnNDU1GY3kAhcD6gsXLiA7OxsymQz9+vWDTCZDdna2UDbZ3fSjzoZ8edQ58tVXkdi3rxD017z5JspKS70u6Af+TJ2rrq5GSUkJqqurAyIQI/fr7Mmev7NpxF9fwcdwhDw0NBQtLS2oq6tDZGSk0fEymQzAxUVu7DV58mRMnjzZ5vM2bNhg93tGR0d3qMFPRET20wfUhgt7qdVqnDlzBlOnTvWa1Bp/GXUO3rcPiuuvF7ZbrrsONW+95fbynLZi6hy5g18+2bOSTYF/TEwMqqqqUFtbKwT5CoUCZ86cwalTp5CUlGR0fGVlJQB0GD0hIvJlgZob6gh9QK1f8FAfUCclJZl9EuCpP8C+PmFbVFeHhJEjIWprE/adP3wYuj8G4ogosOeT2JTq0/uPR4PV1dXCvkGDBgEA8vLyOhz/5ZdfAgBr3BOR39DnhnpLaoqv0AfUDQ0NRmkccXFxXpdaox91Xrx4MRYsWOAbQb9Oh5gHHkCP1FQh6K/69FOUlZYy6CcykZmZiYKCAuF3j34gIjMz08Mtcz2bRvxHjhyJ/fv34/Dhwxj2x4IfU6dORV5eHgoLC/H000/jkksugVarxb59+1BYWAgAmDBhgvNbTkQBzxMj7/5c9cXVFAoFFi1aZLRMfWepNXyyYp3Qbdsgu/NOYbvh/vvR8OijHmwRkXfz9Sd7jrAp8B89ejTWrVuHI0eOCPv69euHG264AZs3b0ZRURGKioqMzhkwYACuu+4657SWiOgPnqrKEMi5obYyF7jL5XKjYyz9AQYQsFU3rBVUWor4sWOFbU3fvqjMywPsWJWeKNAE6nwSkc5Jy+r+8ssv+Prrr3Hq1CloNBrExcVhwoQJuP76640mcwUyc2VByXpyudxopJBs42/9l5OTA5lM1iFHs7q62mW/zOVyOV5++WW3v68vMrwxMxzJf+ihhzpdOV3P1T9fX36aII+JAS6/HNL9+4V9lT/+CM3AgZ5rlA/xt9+FnsA+dJyr+9DS4rI2jfh3ZsKECUzpISK38dTIu79UfXE1SylRmzdvxpw5c7o835U/X1+u4R3x7ruQ/vvfwnbtypVo/r//82CLiMiXcMlZIvJJnqq3zlrj1rFUt7+xsdGq81358/XFGt7Bhw8jMSkJ3f4I+lunTkXZ2bMM+onIJjaN+H///fe45JJLEB4e7qr2EBFZxZMj7/6SG+rKdBdL5fJM13uxxJU/X1+apyFqakLc+PEIunBB2Kc6fRrVEqc9sCeiAGLTiP8777yDu+66Cy+//DL27duH9vZ2V7WLiKhTHHl3jKvLkloql3fDDTdYdb4rf76+sjpv9D//iR6DBglB/4X/9/9QVloKJCR4uGVE5Ktsmtx70003GW1HRkZi/PjxuOyyyzB48GCnN87fcHKvYziZyDHsP8f5Ux86OnnWmqcF5o4ZMmSIx/vQ0sRjb7lxDPnuO8Qa/Awab78d9c88I2z70/fQE9h/jmMfOs4nJve++eab+Omnn7Bz506cO3cOjY2N+Pbbb/Htt98iLi4Ol112GS677DL06NHDKY0mIiLXcCTdxdrJsa5MiXIkTclba3iLKyqQkJEhbLfHxaHyp5+g87InEUTku+wu53nq1Cns2LEDu3btMlrJFwD69++Pyy+/HBMmTEB0dLRTGuoPOOLvGI4wOIb95zh/6kNHRvwdOdcZfejtI/Y202ohu/VWhP74o7Cr8uuvoRk61Ozh/vQ99AT2n+PYh47ziRF/Q3369EGfPn1w6623oqCgADt37sSePXvQ0tKCEydO4MSJE8jJycGwYcOEmwAiIkf5cv11V7OlbxyZPOvpybH+tHpy+Nq1iHnkEWG77pln0HT77R5sERH5M4fLeYpEIgwdOhSLFy/Ge++9hwceeACjRo2CRCJBe3s7Dhw4gNdee80ZbSWiAOfqCam+zNa+cWTyrKcnx1oqFeqNVXkskRw7hsSkJCHobxs3DmWnTzPoJyKXcmo9sODgYIwfPx7jx49HUVERVq1axT/IROQ0/jTS62z29I29OfieXsTMUqlQb6vKY1ZLC+KmTIHkzBlhV8XevWhPSvJgo4goUDh1Aa/a2lps2bIFjz76KJ5++mkG/UTkVP4w0usq7uwbT5dStVQqNDMz0y3vb6+o5cuROGCAEPRXv/8+ykpLGfQTkds4POLf2tqKPXv2YOfOnSgoKIBWqxVe05f7vPzyyx19GyIi3x7pdTF3940nFzHz1qo8lkh/+QXyuXOF7aabb0bdypWASOTBVhFRILIr8NdqtTh48CB27tyJffv2QaVS/XlBiQQZGRm4/PLLMXLkSEi4uiAROYlhiklzczMOHjwIpVKJjIwMKJVKrw383MHT6Tfu5gurJ4urq5GQni5sa8PDUbF/P3SsdkdEHmJTVH78+HHs3LkTu3btQn19vdFrKSkpuOyyyzBhwgSEh4c7tZFERMCfI70bNmzA4cOHMWLECFxyySUQi8Vm68gHEl8bBfdrOh26L1qEsC1bhF3KL76AetQoDzaKiMjGwP+f//yn0XZiYqKwaBf/uBCROygUCkRFReGaa64xSmvhJF/fGAX3d2GbN6P7ffcJ2/WPPorG++/3YIuIiP5kcx5OdHQ0Lr30Ulx++eXo16+fK9pERNQpT9eRJzIVdPIk4idOFLbVaWlQbtkCSKUebBURkTGbAv/HHnsMw4cPh1js1GJAREQ24SRf32G6qNj8+fMRFBTk6WY5j0oFxcyZCC4sFHZV/Pwz2vv08VybiIgssCmCHzlyJIN+IvI4Xy3nGGjMLSr2xhtv+E2p58jXX0di375C0F/zxhsXy3My6CciL8Uonoh8jqfryJN1zC0qNmTIEOTm5nq4ZY4J3r8fiUlJiF6xAgDQcs01KDt3Di2zZ3u4ZUREnWOtTSLySZzI6v3MzcWQSqUumYthmlKUmZnp9BtBUV0d4keNgrilRdhXfvgwtDKZU9+HiMhVOOJPREQuoZ+LYUilUjl9Loa5lKLs7GznpRTpdIj5xz/QIzVVCPqrPvkEZaWlDPqJyKdwxJ+IiFwyYm5uUbHi4mLMnz/fqW0yl1LkrPKuobm5kN1xh7DdcN99aHj8cYeuSUTkKRzxJyIKcK4aMTc3F2PJkiVW3VDY0qampiajCk+A4+VdxaWlSExKEoJ+TZ8+KCsuZtBPRD6NI/5ERAHOlSPmpnMx5HI5qqqqnNomp5Z31WgQO3cuQvbuFXZV/vADNIMG2X4tIiIvwxF/IqIA54oRc0fZ0iZnlXeNeP99JPbuLQT9tS++iLLSUgb9ROQ3OOJPRBTgvHFBNFvapE8pMpwPYEt5V8mRI4i7+mphu3XKFFR/+CHAdWuIyM8w8CfyEe4oV0iBydwk3IKCAmRlZXlFm7RaLcrKynDw4EGkp6dDqVQK333TfxdXXHEF9u7di40bN3b570TU1IS4Sy9FkMG8gfL8fGhNSpASEfkLDmcQ+QCXlyukgKUPnIODg/Hdd9/h8OHDXrEgmn4U/+zZs/jyyy9x5swZTJkyBb179xa++6b/LiIiIvCf//wHQUFBXf47iX7qKfQYNEgI+i+sWXOxPCeDfiLyYyKdTqcz98JNN93kvDcRifDRRx/ZdW5FRQXy8/Nx4sQJFBcX4/z58zBs8qpVqxAXF2fx/LNnz2Lr1q0oKChAdXU1JBIJ4uLiMGrUKMycORNRUVEWz62vr8fWrVuRn5+PyspKaDQayGQypKWlYebMmUhOTrbps5SVldl0vDv40iiytZMC/VFOTg5kMlmHtIfq6mqrJ18Gcv85i7/1oT5wNjfS76rfA7b2YWfffQBGr507dw4AcOrUKUycONHoWP2/k5AffkDsLbcI12pcuBD1zz3n2IdyM3/7Hrob+89x7EPHuboPExMTze53S6qPhXsLq2zfvh0bN26069yvvvoK//vf/6DVaoV9arUap0+fxunTp/Htt9/i0UcfxSAzE7eKiorw4osvorGx0Wh/RUUFKioqsH37dixcuBBXXXWVXW3zBoZ/9OPj46FWq5Gdne3xkT7qyNwKqJ6efEm+z5XVfJylq+++4WsajQbh4eHQaDQdjhVXViJh5Ehhf3tsLCp37YLOg/MYiIjczWLgv3jxYrP7NRoNPv/8c1RWViImJgajRo1Cz549ERoaitbWVpw7dw779+9HbW0t4uLiMGvWLAQFBTmlscHBwRCJRFCpVF0eu2/fPmRnZwvbEokEqampaGlpwfHjxwEADQ0NWL58OV566SXIDFZfrKqqwvLly9FisCz7gAEDEB4ejsLCQmg0GrS3t+P999+HXC5HRkaGUz6fu/nCH326yBsnX5Lv84Ubyq6++4avSSQSqFQqSCR//mlTt7Xhtg0bkGAwqq/86iuo09Pd9AmIiLyHxcB/8uTJHfZptVosW7YMSqUSN954o8Wgvr29HZs3b8Ynn3yCX375BU8++aTdDUxJScHdd9+N/v37Izk5Gc8++ywKCws7PUer1eKDDz4QtsViMZ5++mkMHjwYAPDZZ59h3bp1AC7+4fvoo49wzz33CMd/9NFHRkH/vHnzMGvWLADAsWPH8NRTTwlPMT744AOMHDkSIpHI7s/oKb7wR58u8sbJl47ypTQzf+ULN5RdffcNX4uJicG2bdswZcoUAEC/H37ApDVrhGvVLV2Kpjvv9MjnICLyBjZN7v3qq69w5MgRTJ8+HX/5y18sjuQHBQVhzpw5yMzMxJEjR5Cbm2t3A4cNG4apU6eiT58+Vj85OHLkiNFkrrS0NCHoB4AZM2YgJCRE2P7ll1/Q2toKAGhpacGuXbuE10JCQjBjxgxhe/DgwUhLSxO2KyoqUFBQYPsH8wL6P/qGvO2PPl1kbgVUX07J4mRl7+Cs+veu1Nl33/S1pqYmPPzww4g5fx4Ls7KEoL9tzBiUnT7NoJ+IAp5NOf47duwAAEybNs2q46dNm4bc3Fzs2LEDM2fOtL11dioqKjLa7t+/v9G2VCpFr169hJQflUqFkpISpKam4sSJE0bBcK9evSCVSo3OHzBgAI4cOSJsHz16FEOHDnX2x3A5fxxF9memK6D6MqaZeQdH699by/DpjkKhwKRJk2x6j86++0avtbYibto0TDl5Uni9Ys8etPfs6VD7iYj8hU2B//nz5wEAMTExVh2vP668vNymRjmqtLTUaLt79+4djjHdV1paitTU1A6Vd8yda/r5Td/PV7jrjz6RKUfSzJgi5FyuvqE0LSIAwCVFBKJeeAFRb7whbFe/+y5a3TjgRETkC+yq6lNWVma2Eo654zyhubnZaNswrcfSPn3AYRp4hIaGdjjXdJ8v58Q7+48+gzKyhr255axE5XtMn+5IpVKnPt2R7toF+Zw5wnbzjTei9uWXAR+cd0VE5Go2Bf69evXC77//jk2bNuHRRx/tdEKrTqfDp59+KpznbawtMWruONN9lvohLy8PeXl5AIAXXngBcrncxlb6loqKCqxduxZDhgyBVCqFSqXC2rVrsWTJkg6ju/aQSCR+34eu5E39N3/+fLzxxhtG35Xi4mIsWbKk0zZu3LgRI0aMENLvpFIpRowYge3bt2PRokUub7c39aGv0Gq1Rjd0IpEIERERqKqqcqwvL1yA1KBOtS4sDOpTpyCJiYG//4T4PXQM+89x7EPHeaoPbQr8p02bht9//x0HDhzAihUrsGDBArMLBJSVleHDDz/EwYMHAQBXXnmlUxprrfDwcKPttra2DseYlgTV/2EyHXE0d67pPtP305s2bZrRfAh/X+xi7dq1GDBgAIA/+3fAgAFYu3atU0b2uGCIY7yp/4KCgjB//nyjp0Pz589HUFBQp21UKpWIiorq8O9XqVS65bN5Ux/6CrFYjKamJqMR/6amJojFYvv6UqdD93vuQdgXXwi7lJ9/DvXo0YBGAwTAz4ffQ8ew/xzHPnScTyzgNWnSJOTn52P37t04cOAADhw4gKSkJCQmJgp1/MvKyoxy3sePH4/LL7/csdbbyPTD6ld47Gyf/hzTc2tqaqw+N9CxPCjZwp40M18oP0nGTIsIqFQqu4oIKJVKnF6+HNd9/LGwr/7hh9H4wANObjERkf+yOcf/b3/7G3r06IEvvvgC7e3tKC0tNTu5NSgoCNdddx1uvPFGpzTUFkOGDDHaLi4uNtpWqVQ4c+aMsC2VSoXKP/379xcq3ADAmTNnoFKpjCr7nDhxwuh6qampTm2/r2JQRq7GSlS+x7SIgH7bljkZdfn5GH7ttRj+x/aFnj2x7Prr8df588GZHURE1rM58BeLxbj55psxffp07Ny5E0VFRVAqlWhtbUVoaCgUCgVSUlJw2WWXWV39x9mGDh0KhUIh1AQvLCxEUVERUlJSAABbtmwxShWYMGGCMGE3LCwM48ePF0qXtrW1YevWrbjhhhsAXCwVariAWHx8PAP/PzAoI1dztBIVJ597huHTHZseb6tUkF97LRINyidvXL4cDfHxSFGrWf6ViMhGIp21s1w9JD8/X5gkDADnzp0zWlW3T58+wghzTEwMHn74YQDAvn378OKLLwrHSSQSpKamoqWlRajfD1wcpX7ppZcgk8mEfVVVVXjwwQeN3mfgwIEICwtDYWEhNBqNsP+xxx5DRkaGVZ/FU1WO3MmVgRVzCh0T6P1nWBHI9MbU2u9ooPehM1jbh5GrViF6+XJhe/udd6Jk/HijY0pKSrB48WKb2+DrN4D8HjqG/ec49qHjfCLH3xPq6+uNAnVTp06dEv7b8Bf36NGjsXDhQnz44YfQarXQaDQ4dOiQ0bmRkZF47LHHjIJ+4OIP4/HHH8eKFSuE/HTTNojFYixcuNDqoD9Q+NMiU+Q7rAnkuGiYbwjOz4fi2muF7ZYZM/DaxImQxcYi2OA4e9MIWRKWiAKZw4F/ZWUl6uvroVKpvC7lJTMzE2lpadi2bRuOHDmCmpoaBAUFIT4+HhkZGZg5cyaio6PNnpuSkoLXXnsNW7ZswYEDB1BRUYH29nbIZDKkpaVh5syZSE5OdvMnIiJT1gZynHzu3UT19YgfNQpig3VYyg8dgjY2FpmdPK2xFW8AiSiQ2RX419bWYtOmTfj555/R2NgI4GJt5o8++kg45vz588jJyUFwcDAeeOABiMViuxo4efJkTJ482a5zgYtrCNhb3zs6Ohrz5s3DvHnz7H5/InItawM5Tj73Ujoduj38MCLWrxd2VX38MVQTJwrbzlxlnDeARBTIbA78i4uLsWLFCtTX1xvtN50q0KNHD1RWVuLcuXMoLCzE0KFDHWspEZEZ1gZynHzuXM7Ikw/9+mvIDPq/4d570fDEE2aPdVYaIW8AiSiQ2TQM39DQgBdeeAH19fVISkrCvffei+UGk69Mjf9jItbevXsdayURkQX6QM6QuUBOP2pcXV2NkpISVFdXuz2vW6lUIicnB6tXr0ZOTo5QeczX6NOrZDIZ+vXrB5lMhuzsbKs/j7i0FIlJSULQr+nVC2XFxRaDfmfKzMxEQUGB8J3R3wBmZma6/L2JiDzNphH/LVu2oKGhAb169cKzzz4rLNpliT7n/9ixY461kojIAltG8j05+dxwLkJoaCgOHjyInTt3IiMjA3PmzPGpiaW25MkbPhmIDA3F3774AgkGg0GV338PzeDBbmu7M9OGiIh8jU2Bf35+PgDgpptuEuredyYhIQHAxQnARESu0FUg5+7SjZbeTx8sNzc3Y8+ePUhLS0NKSgqam5t9rqqMYXpVXV0dDh8+DI1Gg/r6eqP+NbzZmXz4MC5Zt064Ru0LL6D51ls90n5WHyOiQGVTqo8+gB80aJBVx+tvDjp7KkBE5Ch9ILd48WIsWLCgQ+Bpb0qKrTp7v6amJgQHB+Pw4cPCaLlIJIJIJBJGy32FPr2qrq4Oe/bsQd++fTFkyBCkp6cb9W9ubi4ui47GXXffLQT9pWlpWLFsmceCfiKiQGZT4K/Vai+eZGWFHn3FH2ueDhAROVtnKSnufj99sKzRaITXdTodJBKJz1WV0efJHzx4EGlpaZBIJGhoaEBiYqLweUXNzbhn2TLMee454byPXnoJPz7+OBoNFkckIiL3sSnw7969O4CLq+da4/fffwcAxMXF2dgsIiLH6UfZDbkyyO7s/fTBskgkglqthk6nQ0NDAxQKhc9VldGnVzU1NUGtVkOtViM5ORkhISEIDg7G5Zs3o8fAgYj+Y/Dn27/9DR9kZ6Ole3eoVCqf+qxERP7Ephz/IUOGoKKiAt9//z1SUlI6Pba9vR1ffvklACAtLc3+FhIR2cndpRs7ez99sLxhwwbs3bsXI0aMQHJyMsRisdPLirpjXoNCocCoUaMgk8mEz5t45Aiufvll4ZiqG2/EswkJSEtNRTAu9kVxcTHmz5/v1LYQEZF1bBrxv/rqqwEA27dvx+eff27xuNbWVrz++us4deoUxGIxrrrqKsdaSURkB3eXbuzq/RQKBe699148++yzCA8PR2lpqdPLirpzXoP+80ouXMDCrCwh6NfExOD8sWNQvfJKhxKqS5Ys8ZlJzERE/kakM115qws5OTnYunUrAKB3795ITU0V8mVvv/12nDx5Env37hXy++fOnYs5c+Y4udm+qayszNNN8GlyuRxVVVWebobPCtT+c+botzV96O4qQqZycnKMRuGBizcg1dXVzq9ko9Uict48RO/cKez6fd06RE6aZPEUZ38PPd3fnhCo/5adhf3nOPah41zdh4mJiWb327xy76233gqRSIQtW7bg9OnTOH36tPDaf//7X6Njr7/+egb9RBRQPF0q0tqVjB0V9tFH6P7gg8J23VNPoenuuxHphGtbG8wblguNj4+HWq32udKoRETuZFOqDwCIRCLceuutWL58OS677DJhwq9eZGQkJkyYgGXLlmHevHlOaygRka3cXc7TG1i7krG9JMXFSExKEoJ+1ahRKDt9Gk133+2U69vyM3N31SYiIl9n84i/Xr9+/XDfffcBuJjT39zcjNDQUISHhzutcUREjrBlhVl/YctKxjZpbYXiqqsQfOKEsKti9260Jyc72GJjtvzM3PV0g4jIX9gd+BsKDQ1lrX4i8jqBGBh2tZKxni258VEvvoio114TtqvfeQet11zjkvbb8jNzd9UmIiJfZ1Pg/+9//xsikQiPP/54h1rV5mi1Wjz77LMQiUR46qmn7G4kEZE9AjUw7GqegbW58dLduyH/y1+E7eY5c1D76quASOSyttvyM3PZ0w0iIj9lU45/YWEhCgoKhBV8bTmHiMjd3F3O01d0lRsvqqlBj549haBfFxKC8wUFqH3tNZcG/YBtPzP90w3DcqGc2EtEZJlTUn0ssbFSKBGRU1mb9hJoLKbTNDYi5t57Ef7ZZ8L+qs8+g2rMGLe1zdafmaerKBER+RKXBv719fUAgJCQEFe+DXm5QKyzTd6DgWFH5tJpkn/5BQvff1/Yrn/oITT+/e+eaF6Hn5lSqUROTo5dv0P4+4eI6E82l/MELpb07IpWq8VXX30FAPwlG8ACsZwiuYc+GFy9ejVycnL4nbKBYTpNZGUlFmZlYdofQb968GCUlZR4LOg35cjvEP7+ISIy1unKvfpynXr6X5ZyubzT4F+r1aK+vl7I0bzuuuswf/58Z7TXpwXiyr3OXEWUKwU6xp/6z3ByqumkTlcONPhVH5aVIW7WLPQoLRX2VezcifZ+/Vz6vrb2oSO/Q9y6irEb+dP30BPYf45jHzrOK1futTQqYktDBw0ahNmzZ1t9PPmXQCynSK4XiPX5nSnyrbeQuGyZsF3z6qtomTvXgy2yzJHfIfz9Q0RkrNPAf86cOUbbGzduBADMmjULEonlU4OCghAVFYV+/fqhf//+Tmgm+apALadIrlVZWYnjx49Do9FAIpEgPT0d3bp1Y0DXheCDB6GYOVPYbsnMRM277wJiu7I+3cKR3yH8/UNEZKzTwH+uyQiQPvCfPXs2J+ySVVhnm5xNqVTi5MmTyMjIgFQqhVqtxp49e5CRkcGAzgJRQwPiR4+GuLFR2Ff+22/QyuUebJV1HPkdwt8/RETGOs3xN1VYWAgAGDJkiFUTfMlYIOb4A86rqsGcQsf4S//l5OQgIiIC5eXliIqKgkgkgkqlwq5du7B8+XLm+BvS6dDt0UcRsXatsKvqo4+guuwyjzXJnj505HeIP1b18bnvoZdh/zmOfeg4r8zxN5WamuqUxlBgYTlFciZ93nZycjKUSqWQ7pOWlubzAZ0zhXzzDWIXLhS2GxctQv2//uXBFtnPkd8h/P1DRPQnmwJ/lUqFQ4cOAQAyMjIg7iQvVKvVIj8/HwAwfPhwoxxLIiJ76fO2Q0JC0LNnTwDokMftSZ4eYRaXlSHBYMEtTVISlNu3QxcW5rY2EBGRd7JpRtfevXvxn//8B1u3bu006AcAsViMbdu24T//+Q/279/vUCOJyHe4ur6+YQ16AELedmZmplPfxx4erRvf3o7YuXONgv7KvDxU7t1rMejnWghERIHFpsB/9+7dAICJEydadbz+uF9++cXGZhGRL3JH4KtQKJCVlYXq6mqUlJSgurra5fX7rdVZmVFXCv/f/5DYqxdC/vhdW/v88ygrLYVmyBCL53BxKyKiwGNTqs+5c+cAAIMHD7bqeP1xZ8+etbFZROQrDFNbfv/9d0ycONHl9fW9NW/b3XXjJYWFiLvySmG7beJEXFi3DggK6vJcd6yFYC7tSe4DlYSIiPyVTYH/hQsXAADdu3e36viYmBgAQHV1tW2tIiKfYLiCbnx8PE6dOoXy8nIkJycLJX8DacEkd9WNFzU3I+6yyxBUXi7sK9+3D9oePay+hqtvUky/G2q1GtnZ2XjooYcQZMWNiaVr+luFHiIid7Ip1Uef19/W1mbV8frjtFqtjc0iIl9gOmoslUoRGhpqlC4SSAsmuWP+QfQzz6DHwIFC0H/hf/9DWWmpTUE/8OdNiiFn/qwsPVHYvHmzXdcrKirC0qVL0dDQAKlUioiICKYmERHZyKbAXyaTAQCKi4utOl5/nP48IvIsZ0/mbGpqMhrdTk9PR2FhIVpbWwF418Rbd+hs/oGjfS/dsQOJSUmIfOcdAEDTggUoKy1Fm0Gqjy1cfZNi+t0ALgb/jQaLiFlLqVRi5cqVyMjIQHR0NIKDg1FeXo4BAwa4fP4EEZE/sSnVJy0tDWVlZfjiiy8wevToLst5fvnllwAuLvhFZIiP7N2voqLCbOqFIxNjTVNbunXrhoyMDOzbtw9isRgRERFeM/HW1Uy/03PmzBE+t6W0F2v6RqxUImHECGFbGxODit27oYuKcqi9+psUwzY782dlKe0pMjLS5mtt2LABLS0tOHz4MMRiMQYMGICoqCjU1tZCpVI5pb1ERIHAphH/K/8YWTp+/Dhee+01tLS0mD2utbUVr7/+On7//XcAwFVXXeVgM8mfsJqIZ2zevNnpFWfMjRqfO3cOTzzxBBYvXowFCxb4bNBvywh9V99pu6r9aLWQ3XabUdCv3LYN5QUFDgf9evpJ0q74WVl6onDDDTfYdB2lUonDhw9j1KhRSEtLw6BBg1BYWIjGxka0trYGTBoZEZEz2DTi37t3b8ycORNbt27F7t27cejQIYwZMwZ9+vRBaGgoWltbcerUKfz6669obm4GAMyYMQP9+vVzSeM7s2HDBmzcuNHq4ydNmoR7770XAPDjjz/irbfe6vKcxMREvPrqq/Y2MWC5o5oIddTY2Igok4DR0cmcrh419hSlUolVq1ZBrVZDp9NBJBLhxIkTeOqpp8xOTO3qO23rRNqwjz9G93/8Q9iu+9e/0LRokRM/oetZ+m7Ex8fbtEx9bm4uRowYgeDgYNTX1yMyMhJDhw7F0aNHodFosHTpUtd9CCIiP2NT4A8At9xyC7RaLXJzc9Hc3Izt27dj+/btZo+dOXMmbr31VocbSf7F3SUP6aLIyEiXVJzx1tKajtiwYQPq6+uRnp6O4OBgqNVqHD58GB9++CGysrI6HN/Vd9raaj9BxcWInzRJ2FaNHImqzZsBL1mV2FbO+G40NTUhKSkJZ8+eRXR0NJqamqDValFWVoZnn33W528yiYjcyebAXywW47bbbsOll16Kbdu24ciRI6ivrxdej46ORnp6OmbMmIEBAwY4tbG26NmzJ8aNG2fx9UOHDhmlKvXv39/scSEhIRhh8KjdECct28ddJQ/J2A033ICVK1cKI9P61AtzgWygKywsxKhRo4xG8NPT03Ho0CGzx3f1nc7MzBRy/A37/vrrr0dOTg7a6upw73//C7lBOlHFrl1o79XLhZ/SN0REREAsFiM5ORlKpRIhISHQ6XSYMmUKUlJSPN08IiKfYnPgrzdw4ED87W9/A3Axp7+5uRlhYWEIs7A0vLtNmDABEyZMMPtaZWUl7r//fmE7MjISkydPNntsdHQ0HnzwQVc0MWBZCoIYgLpWfHy8X6bluIJEIoFEIulyn15X32lzaS/XX389Pv/8cyw4cQKjtm4VrnVqxQpIb7nFJZ/LFyfVG/Ztz549+fuCiMgBdgf+hkJDQxEaGuqMS7nF1q1bjdYWuPLKK32q/b7OX/PCfYE/puW4QkpKCmpqatC9e3eIRCLodDrU1NQgPT3d7PHWfKdN+/77Z57Ba3+U5gSAE5dcgu9uuw3VNTVwxU/IkcpCnsTfF0REzuOUwN+XNDc344cffhC2JRIJpk+fbvH4lpYWrFmzBjU1NQgKCkJsbCzS0tIwdOhQiEQidzTZLzEAJT39KHRVVRXOnj2LpKQkxMXFeXQ0es6cOXj77bcREhIiBP719fW47777LJ5j7XdaVFODhOHDcUt7OwCgPSgIH736KlQREQgGXDbXxZcn1fP3BRGRcwRc4J+XlycsLgQAEydORPfu3S0e39jYKKxHoLdp0yb07t0b999/P5KTk13WViJ/px+FHjBgAOrq6jBw4EAcOnQIIpEIb7/9NhYtWuSR4F+hUGDRokVGo8yLFi2yuSKNEZ0OMUuWINxg5drPH34Y1QbrnLhyrgsn1RMRkcXAXz+yJRKJ8MYbbxjts5XhNTypvb29Q93sa665xq5rnT59Gs888wxWrFhhcZJvXl4e8vLyAAAvvPAC5HK5Xe9FF0kkEvahA7yx/zZu3IgRI0bg7NmzCA4ORnBwMEaMGIHff/8dffv2xbZt2zw2x0Yul3dYfNDePhRv3AjJ/PnCdvs//4myu+7Cz2+8gSEApFIpVCoViouLsWTJEpf8nPQ3UFKpVNinUqmgUCiE96uoqMDmzZvR2NiIyMhI3HDDDR1uFhzljd9DX8M+dAz7z3HsQ8d5qg8tBv7mFqvx9QWWdu3ahQsXLgjbw4cPRy8zVTPCwsIwceJEjB07Fr169YJcLkd9fT12796N9evXCwvS1NXVYdOmTbjjjjvMvt+0adMwbdo0YdvukUICcDEQYx/azxv7T6lUIioqCnV1dYiJiQFwcRRaq9WiW7du2L9/v1e12dY+DDpzBvHjxwvb6oEDofz6ayAkBEEA5s+fb/RUYf78+QgKCnLJZ540aZLFCchVVVVGcwCioqKgVquxcuVKp+fTe+P30NewDx3D/nMc+9Bxru7DxMREs/stBv5z5syxap8v2WpQOQOwPNo/bty4DqVA5XI5rrnmGohEInz44YfC/gMHDji/oUQBQl8GU6fTQavVQiwWQ61WQywWQ6PRQKPRdHkNr6xUo1ZDPmsWpAcPCrsqtm9Hu0mJY3fmrnc1SdaX5wAQEZF1LAb+c+fOtWqfrzh69ChOnDghbCcnJ2P48OE2X8e0qkdNTY3DbSMKVPpSjZGRkWhoaEBoaCgKCwsxcOBAHD58GKmpqZ2e742VaiJWr0a3554TtmtefhktN93kkbaY6uxGg3MAiIj8X8BM7t2yZYvR9rXXXmvx2Pb2dgQFBZl9rbKy0mg7PDzc8cYRBSj9KPTGjRtx+PBhqNVqyOVyVFRUIDo6GjfeeGOn53vTKHXwb79BMWOGsF00cCA+u+02ZE6ZAlffgtjz1MP0HK1Wy4X1iIj8XEAE/uXl5di3b5+wHRMTg4kTJ1o8/oEHHsC1116LiRMnGgX25eXlWLNmjdGxXDmSvI1Xpr50QqFQYM6cOdBqtSgsLIROp0NycjLmzJnTZbvtGaV2dv+IGhsRP24cxLW1wr6c//wH7bGxkLnhCYQ9Tz3MnXP69GlUVlZizJgxXFiPiMhPBUTgv23bNuh0OmF7+vTpFlfgBC5Wtnj//ffxwQcfoHfv3ujevTvq6+tRUlKC9j9qbwNAUFAQbrjhBpe2ncgWnQWB3lqBwbCkZ2hoKFpbW3HkyBFcccUVXQbL+jkC1o5SOzs1qNvjjyMiJ0fY/igrC/Xjxrn1CYQ9Tz3MnTNy5EicPXsW1dXVXCiLiMhPWYx+33rrLae9iUgkwuLFi512PVs0NTUZLdgVEhKCq666yqpz29vbUVJSYva1sLAwLF68GP3793dKO4mcobMg0LQ0pbfIzc3FgAEDUF5ejqioKEilUmRkZGDlypVYvnx5p4Gnfo6AYaWaAwcOQCaTYfXq1R1G9LsKkq19GhDyzTeIXbhQ2G686y7UP/00ClavRj+DmxD9e7gyT96epx6WzgHAibxERH7MYuC/fft2p76RpwL/b7/9Fm1tbcL2pEmTEBkZ2ek5r7zyCvbu3YuioiIolUrU1taipaUFoaGhSExMxPDhwzFt2jSL9fuJPMWXJmjqg+w9e/ZAIpFg0KBBwmrYUqkUsbGxXY6Um1aqAQCNRoPevXsLNwKGI/qd9Y9VTwNKS5HYr59wbntCAip37oTuj5RAW59AOIM97+mJdrqbr6W8ERG5g8XAf8iQIcIfYVPl5eWorq4GcPEPdI8ePYRH9OfPn4dKpQIAyGQyJCQkuKDZ1ps1axZmzZpl0zlJSUlM4SGf5CsBnWGQnZGRgdbWVhw9ehSpqalCDXmpVGrVDYthpZqcnBwhRx0wn/Zy8uRJiEQiSCQSKBQKiMViREREdP40YP58xM6bB+lPPwnvW/ntt9CYVB0y9wTCFXnyhkGtVqvF6dOnMXLkSKvf013t9BRvrPZEROQNLAb+S5cuNbs/Ly8PH3zwAZKTkzFv3jyMGDECYrFYeF2r1eLgwYNYu3YtysvL8Ze//MVoESsich1fCegMg2yFQoHff/8dqampKC4uxtChQ1FQUICMjAyjOTV6nY3kdjWiX15ejvr6eqSnp0MikeDkyZOor6/HokWLsHHjRrPnpu7YgcTHHxf21S5bhubbbjP7ubqqle8M5oLayspKnD17FgCsek93tNOTvKnaExGRN7Fpcm9RURHef/999O3bF0uXLkVISEiHY8RiMTIyMpCWloalS5fiv//9L3r27MnqN0Ru4CsBnWGAHhISgr59++LEiRNQKpU4efIkMjIycO7cuQ43LF2N5Hb2xCM3NxdjxoxBc3MzDh8+DI1GA5FIhKSkJLPndj93DrOeekq4TtuECRDl5aG5i7U7XL0ol7mgdsyYMaiurrbpfd25eJi7+VLKGxGRO9kU+H/55ZfQ6XSYN2+e2aDfUEhICP7v//4Py5Ytw5dffsnAn8hNfCGgMw2yIyMj0b9/f5w/fx6JiYlob283e8PS1UhuZmYmVq1aJawGLBKJEBwcjPvuu08Y0e/WrZtROV/9BH7905IR/fph4QMPGL1v+a+/QpuYCLmF9T3ciUFt13wl5Y2IyN1sCvyPHz8OAOjbt69Vx/f7YxKc/jwiIsB8SlJxcTGeeOKJTp9OWBP0SiQS9OjRAyKRCDqdDkqlEkDXwaBCocALX3+NsGPHhNdPvvoqQrxsxXIGtV3zlZQ3IiJ3E3d9yJ/0f1ytHVmy9XgiCgz6lKTq6mqUlJSgurraqpQkfdBryDDozc3NxciRI9G3b1/06dMHffv2xciRI5Gbm4vMzEwUFBQI5+uDwczMTISvW4fEpCQh6G9PSEDZuXNeF/QD6PRz0EX2fr+IiPydTSP+sbGxqKiowM8//4zZs2d3efxPf1TAiI2Nta91ROS37ElJ6mokt7MnAubmP9x99dVIHTHC6PjyQ4eg9eLfWb4yjwMwPxHbXQvJ+ULKGxGRu9kU+I8ePRpbt27Fp59+ioSEBEyYMMHisT///DM2bdoEABgzZoxjrSQiQtdBrzXpPAsWLAC0WiQmJxtdu/q//0Xr9Onu+zAO8IWg1tJE7IceeghBXjBXgogoEIl0Op3O2oMbGxvx4IMPora2FgAwcOBAjB07FomJiUId/7KyMuzdu1fI6+/evTtWrlzZ5aJZgaCsrMzTTfBpcrkcVVVVnm6G07lroSF/7T9DhsGm/onAr7/+KqwnEhERgazCQsStWSOc03LVVaj54AOja1j6eQRCHzpLTk4OZDJZh5uw1tZWzJkzx4Mt8338HjqG/ec49qHjXN2HiYmJZvfbNOIfGRmJp59+Gi+88AIqKipw/PjxTifuJiQk4NFHH2XQT2SBNyw05C8rnOo/R3BwML777jskJSUhLCwMEokEycnJSDxzBtcY1OMHgLITJ4DQUKNrePrn4S8spV0xWCAi8hybAn/g4h3EypUr8dVXX2H79u04d+5ch2N69uyJyZMn4+qrr4ZUKnVKQ4n8kbsXGjIN8seOHYvPP//c5wNd04B90KBBKCgoAACMTkvD7XffbXT8B/fdh6tNbgKAwF74ydk3gJbSrjgQRETkOTYH/gAglUpx3XXX4brrrhNWxGxtbUVoaKiwEA4Rdc2dNdkrKio6jGa/8cYbmDBhglcGurYEopYC9kuefBLDDEaYD15zDQ7Mni3U7jfV1NSEmJgYnDt3DhqNBhKJBAqFwuWVyTz91MUVTzosTcR+6KGHnNx6IiKylk3lPM2JiIhAnz59kJKSgj59+jDoJ7JBV+UpnWnz5s0dguPU1FQUFRUZHecNi0HpA1GZTIZ+/fpBJpMhOztbqMlvqqmpyWhkue+ePbjr7ruFoL9dIsEH//0vDsye3WX/njx5EsHBwQgPD0dwcDBOnjzp3A9nwtbP6gqdPemwl6WSmqY3ukRE5D4OB/5EZD931mRvbGw0Co4BIDQ0FCqVymifNywGZWsgqr+BCqutxcKsLEx+5x3htacWLsR/33wTEIm67F+tVotTp05Bo9EAADQaDU6dOgWtVuvkT/gnVwTdtjK9cdK3w9EbQH31ocWLF2PBggU+lT5GROSP7Er1AS4uc//TTz/hxIkTqK+vh0ajwRtvvCG8Xltbi2PHjkEikWDUqFFOaSyRv3FnTfbIyMgOOdcxMTG4cOGCsN+VK5zaks5iawpU5vTpGDx2LEINnp6sueoqDHvxRfwFsLp/xWIxxo8fj8OHDwupPuPHj8eFCxfs+9BWcGe6lyVcDZiIKDDYHPirVCq8++672LlzZ6fHhYSEYPXq1WhpacHrr7/Ox7tEFriiJru5IPuGG27AypUrjXKui4uL8dBDD2Hv3r0uvfGwNYfclkA08pVXkLhypbB9KjkZH91zj9GNhbX9GxERgfDwcEycONHofVtbW63+rLbyhqC7q4XRiIjIP9ic6vPSSy8JQf/QoUMxY8YMs8eFhYXhkksuAQDs2bPHgSYSkS0s5YwDMJtznZKS4vJ0DFvTWaxJgZIUFCAxKQnRBkH/+d9/h3T3brs/hztTrzz5nqYs5eMzNYeIyL/YNOL/008/4eDBg5BKpXjkkUeQnp6O1tZWbNu2zezxI0eOxA8//IDffvsN1113nVMaTESdsxRkb968GXPmzPFItR5b01k6TYFqa0Niv35Gx1dt3gzV2LEOt9OdqVeefE9L7fB0JSciInItmwL/7du3AwDmzJmD9PT0Lo/v3bs3AKC0tNSOphGRPVyxcJIzyk2ePHkSIpFIKJEpFos7TWcxF4h2v+suhG3dKmw3LlyI+uees+3DdMETAbC59/R0iU8iIvI/NgX++rJ248aNs+r4qKgoAEBDQ4ONzSIieyiVSvz+++84deoUpFIp0tPT0a1bN4cWTnK0xrtSqUR5eTnq6+uRnp4OiUSCkydPor6+HosWLbKqDSHffovY224z2ld25gwQFGTPR+rQPm8LsLmCMBERuYJNgX9zczMAIDo62qrj9SXxxGJWDSVyNX2wOHHiRJSXlyM0NBR79uxBRkYGzp07Z9PCSYbB8O+//46JEyfavchXbm4uxowZg+bmZqFajkgkQlJSUpdBrKi6Gj1Mni5W/Pwz2vv0sfqzdMZbA+xAXkGYiIhcx6aIXD9iWFtba9Xx+hQfa28UiMh++mAxMjISycnJAIB+/fph3759Ni2cZDo5WCqVory8HG1tbcIxtpSb1NeI79atGyZOnIjJkydj0qRJXQ4IxI0bZxT01z7/PMpKS50W9APeUUPfHFfV1SciosBm04h/nz598Ntvv+HgwYNITEzs8vgdO3YAAAYOHGhf64gChDPSTQxz+0NCQtCzZ08AF5+42XIt02BYKpUiNDQUSqVSuKYt5SZtLVcZ8d576LZ06Z/HDhwI5Y8/Wt1+W3hDDX1zvKHEJxER+R+bRvz15Tk3bdqE8vLyTo/du3cvfvjhBwAwqolNRMYsld9UKpU2XUcfLBqyJ1g0HW1OT09HYWGhUMve1nKT1parDCouRmJSklHQf76w0GVBP+C8PnM2byjxSURE/semwH/y5Mno1asXGhoa8Nhjj2HLli0oKysTXlepVDh27BjefvttvPLKKwCAlJQUjB492rmtJvIjzko3cVawaBoMd+vWDRkZGSguLrarxnuXNeI1GiQmJSF+0iThnAvr1qGstBS6bt0sXlepVCInJwerV69GTk6OzTdKgPcG2KyrT0REriDS6XQ6W06oqqrCv//9b1RWVnZ5bGJiIp5++mnExMTY2z6/YniTRLaTy+UOlaT0VqtXr0Y/k7r0AFBSUoLFixfbdK3OUoas7T/DCa+mq7g6O/Ds9sgjiFi7Vthunj0btW+84ZI2WuobW9Ks/PU76E7sQ8exDx3D/nMc+9Bxru5DSyn5Ngf+ANDS0oL169fjhx9+gEql6vC6RCLBlClT8H//938IDw+3vbV+ioG/Y/z1F01OTg5kMlmHfO7q6mqnVnCxpf9cXeJSUlSEuKlTjfaVnToFmExotcTWPnPWzYy/fgfdiX3oOPahY9h/jmMfOs5Tgb9Nk3v1wsLCkJWVhfnz5+PYsWMoKytDc3MzQkNDER8fj9TUVISFhTnUYKJAkZmZaTEo9RTDBaWcehPQ0oK4yZMhOXdO2FX5/ffQDB5s02VsnZTL8phEREQ2Bv4ffvghAGD8+PEYNGgQQkJCMGzYMAwbNswljSMKBPp8bsPg2lvyuZ1Z5z7q+ecR9eabwnb1f/+L1unTrW6HYf8AsKnqjbdW7yEiInInmwL/bdu2AQCuvPJKlzSGKFAZjrB7E2eMlEt/+gnym24Stpvmz0fdihWASNThWHNPFwB0uPk4ceIEqqqqMHLkSKuekrA8JhERkY2Bf3R0NOrr67kgF1GAcGSkXHzhAhIMngZqIyNR8euv0Fn4/WHp6UJ0dHSHm48xY8bg9OnTqK6u7vQpif5GoqqqCjt27MAVV1wBuVzuFelURERE7mZT4N+rVy8cOXIElZWVwiq+ROS/7Bop1+nQ/c47EWZQjlT55ZdQZ2R0+l6Wni58++23HaoeBQcHQywWd/rUwfRGonfv3vj+++/Rt29fxMXFeU06FRERkbvYFPhfccUVOHLkCL755hssWrTIVW0iIgOurrDTGXMTjw8cOACZTIbVq1dDq9VCLL64HEhERATmtbej1z//KZxf/9hjaFyyxKr3svR0QaPR2JWmY3ojERkZiczMTKdXSyIiIvIVNi3gNXHiRFx66aX44YcfsG7dOmg0Gle1i4jgvFV97WW6kNTZs2eh0WjQu3dvxMbGori4GCqVCqnBwXjs8ceFoF81dCjKTp60OugHLK+im5qaatciW6YrEAOc0EtERIHNphH/jRs3okePHpDJZPj888/x3XffCY/RQ0JCOj13zpw5DjXUHm+++Sa2b9/e5XHTpk3DXXfd1WH/2bNnsXXrVhQUFKC6uhoSiQRxcXEYNWoUZs6ciaioKFc0m0jg6jKU1jxNMJx4nJOTgzFjxiA4OBiHDx/G8CFDcMc77yCuvFw4/u2HHsJ1f/+7ze/ZVVlTW6secUIvERGRMZsC/08++cRou7GxEXv27LHqXE8E/o746quv8L///Q9arVbYp1arcfr0aZw+fRrffvstHn30UQwaNMiDrSR/ZBgYFxUVYarJQlfOGrW2p1SnYTrOjPx8/CU7W3jtx7vuwslLLkFpSYnd79lZWVNbb3S8cX0EIiIiT7Ip8JfL5a5qh8spFIoOEwT1TPfv27cP2QYBjUQiQWpqKlpaWnD8+HEAQENDA5YvX46XXnoJMpnMdQ2ngGIaGJ89exYnT55E3759hadq1oxamxtVN/33a8/ThIiICHQvKsKsF18U9hUOG4ZP//IX9ExO7rJtXb2nM8uaevP6CERERJ5gU+D/psHiO74mNTUV9957b5fHabVafPDBB8K2WCzG008/jcF/rCz62WefYd26dQAujn5+9NFHuOeee1zTaDLLk5Nd7WFLe00D4xEjRmDXrl0ICQlB3759rRq1Nrx5CA0NxcGDB7Fz505MnDgRM2bMEN7b1lKdoro6PPL00xCrVMK+26+/HvLBg9E3Ls6qtrl6IS1zfc2JvERERBfZNLk3EBw5csRo4mRaWpoQ9APAjBkzjOYz/PLLL2htbXVrGwOZpye72srW9ppOSO3WrRvGjx+Pw4cPo6SkBNXV1V2OWutvHpqbm7Fnzx4MGDAAl112GVQqldF7W5pM22HEXqdDzAMPoEdqqhD0r73zTvzrn/9EQloapFIpSktLrWqb1e9pB1/7bhAREbmbTSP+vuzs2bN4//330djYiNDQUPTo0QMjR45Er169jI4rKioy2u7fv7/RtlQqRa9evYSUH5VKhZKSEqSmprr2AxAA1092dTZb22tuQmp4eDjGjRtn9efTj6ofPnzY6L1FIpHRe1uTAx+6bRtkd94pbDfcfz8aHn0UVwC4wo7+cGXeva99N4iIiNzN4cC/ubkZVVVVaG1tRWhoKORyOcLDw53RNqcqKSlBicmkw7Vr12Ls2LFYvHixMOJYWlpqdEz37t07XMt0X2lpKQN/N3F1qoizddZec2kpY8eOxcqVKxEbGwupVIqUlBScO3fOpsBYf/Og0WiEIFin00EikRj1VWc58EGlpYgfO1a4pqZPH1Tm5QFhYQ71hyvz7n3tu0FERORudgX+Go0GX331FX788UecO3cOOp1OeE0kEqFnz5644oorcPXVV0Mi8e6HCnv37kV9fT2WLl0KsViM5uZmo9fNlSk13cfAwn18rUSjpfYC6FDdZtWqVZBIJMjMzERtbS1aW1vxyy+/YMmSJTYFxvpRdZFIBLVaDYlEgoaGBvTv379DX3WYTKvRQH799ZDu2yfsqvzxR2gGDnSgF4w5cwKvIWd+N3xtHgkREZE1bI7Kz58/jxUrVuD8+fNmX9fpdDh79ixycnKQl5eHRx99FAkJCQ431B6xsbGYMWMGMjIykJiYiOjoaCiVSmzduhV5eXnCcUVFRdi9ezcmTJhg1XUNb3Q6k5eXJ7zPCy+84NNVkbyBRCLB/Pnz8cYbb2DIkCGQSqVQqVQoLi7GkiVLvLJ/LbU3OjoaI0aMgFQqBXAxhUyr1SIhIQEymUyoFDVgwAAcOXIEEydOtPo95XI5HnroIXz44YfYv38/RowYgf79+0MsFnfaV+LXXoPkkUeEbc3bb0O7cCFiHOsCt3HWd6OiogJr1641us7atWuxZMkSSCQSr/ye+RL2oePYh45h/zmOfeg4T/WhSGdtFIuLdfsfeugh1NTUALhYBnPcuHFISkpCaGgoWltbUVpaij179ghpNTKZDCtXrvS6EdkXX3wR+wxGNSdNmoR7770Xr7zyCnbt2iXsX7hwYYcVQleuXIm9e/cK23feeSeuvPLKLt+zrKzMCS0PXHK5HFVVVT43GmuuvRs3buxQRvbHH39Enz590KdPH6P9JSUlWLx4scPvrVAoMGnSpA59FXz4MBTTpwvbrVOmoPrDDwGx7839d8Z3IycnBzKZrMOTg+rqavzjH/9AVVWVs5sdUPT/jsl+7EPHsP8cxz50nKv7MDEx0ex+m0b8N2/ejJqaGkgkEtx99924/PLLOxwzZswYzJo1C9u3b8c777yD6upqbN68Gbfccot9LXeR9PR0o8C/trYWQMeOqq6u7nCu6T5LnUuu4apUEVcx115zaSkikajD0yRH05gM39v0l4yoqQlx48cj6MIFYV/5gQPQxsXZ/X6e5ozvBucKEBGRv7JpSO/XX38FANxwww1mg35DkyZNwuzZs43Oc6f29vZOX6+srDTaDvtj0uKQIUOM9hcXFxttq1QqnDlzRtiWSqUdKv8QdSUzMxMFBQVCvr/+JkCpVBrtKygoEJ44KZVK5OTkYPXq1cjJyXGoTGX0v/6FHoMGCUH/hf/3/1BWWurSoN+Z7XclV5YcJSIi8iSbRvwv/BEkXHbZZVYdf9lll+GTTz4RznOnoqIibNiwAddeey1GjhyJoKAg4bVDhw7hm2++MTo+JSUFADB06FAoFAohKCksLERRUZHw+pYtW6AyWMBowoQJCA0NdfXHIRfyROqQueo29913HwCYrXhjuqKvWq1Gdna2zRVxQr77DrEGI+KNt9+O+meecfrnM+3TsWPH4vPPPzfbftPP7OnULVeWHCUiIvIkmwL/iIgI1NXVWT3ypT/OU+U9jx49iqNHjyIsLAx9+vRBWFgYlEolzp49a3RcbGwsrrjiYlVysViMhQsX4sUXXwRwcSLvM888g9TUVLS0tAj1+4GLn+/mm2923wcip3NWQG0PS2kp5vY5WqNeXFEBaVISYv/YblcoUPnzz9D98W/UmTc/5vp05cqVyMzM7ND+jRs3or6+3iP9b4krS44SERF5kk2pPgMGDAAAnDp1yqrjT548aXSeO4lEIuG/W1pacPToUeTn53cI+uPj4/Hkk08KqT4AMHr0aCxcuBDiPyY3ajQaHDp0yCjoj4yMxOOPPy5UXyHf1FlA7U1MV/QFrMw712ohmz8fCRkZwq7Kr79GxcGDRkG/M1e8NdensbGxwjwaw/YXFRV5Zf/rb8oWL16MBQsWMOgnIiK/YNOI/zXXXIP8/HysX78eTz/9tFCK0ByVSoX169dDJBLhmmuucbihthoyZAiWLl2K/Px8FBcXo7q6GrW1tdBoNIiMjETv3r0xZswYTJ482eznyMzMRFpaGrZt24YjR46gpqYGQUFBiI+PR0ZGBmbOnIno6Gi3fy538bXKOfbylYmc9tSoD1+7FjGG5TlfegmVZp5QOXvFW3N9KpVK0draarTPdJExPVf1f6B8p4mIiCyxKfBPTU3FHXfcgezsbPzrX//C/PnzkZ6ebjS6rtPpcOjQIaxbtw7nzp3DHXfc4ZFVbUUiEVJTUx167169emHRokVObJVv8GT6i7t5ckEwWwJRW/LOJceOIW7KFGG7bdw4XNiwAfKEBMBM6TBn3/yY69OUlBT88ssv6N27t1H7U1NTO+1/ZwXrgfSdJiIissSmOv7//ve/AQDl5eVCScvQ0FAkJCQIdfzLy8uFkT2ZTNbp4l0ikQhPPfWUI+33Kb5Sx7+zOuaeLKPpipq3hgGhaUDtyoDQnvftMghuaUHclCmQGFSdqti7F+1JSQAs95+zf96WPpt+sr9KpYJUKsXdd9+N2NjYTm9oTF/79ddfhd8pttwIOOszsna149iHjmMfOob95zj2oeN8oo5/YWFhh32tra0Wc/6rq6vN1sEn7+Yr6S/O4KmJnLak15gG/HPmzOnQvqjlyxG1apWwXf3++2g1WXjOEmdXsTHXp9dffz0+//xzTJ06VXiPzz//HFlZWRb7Pycnx6iPmpubUV9fjx49eiAxMRFlZWX417/+hfT0dNx4442d/swC6TtNRERkiU2B/+WXX26U1kP+yZPpL57giQXBrA1Eu0pRkf7yC+Rz5wrHN990E2pfegmw4d+pK25+TPvUNIg3vdEx1/+mfXT48GGkp6ejra0NZ8+eRVRUFMaOHYvi4uIu03YC7TtNRERkjk2B/7333uuqdpAXYR1z17M2ELX0ZODHjRvxt+eeE47ThoWhYv9+6Lp1s6s9rr75sWfE3bSPNBoNJBIJamtrIZfLIRKJEBwcDJ1O1+VkZH6niYiIbCznSYFBPwJcXV2NkpISVFdXe/UkSF9ZEdaQuZV7DVfp1etQxlOnw5XvvWcU9Cu/+ALlxcV2B/3uYM9quKZ9JBKJUFNTg9DQUOHJo1qthkQi6fImwte+00RERK5g0+RecoyvTO71VuYmwtg7OdfcRFnAvSvIWlOxxnBSar/duzHp3XeF1+offRSN999v9fvZM5HIFVV1DH9O119/Pfbu3Wvx+obvr9Vqcf78eURHR0MqlUKr1eLUqVOYOHEiwsPD3TL5nBPaHMc+dBz70DHsP8exDx3nqcm9DPzdiIG/Y8z9I7GnWou5IPTXX3+FRCLByJEj3VrdpytKpRJfvPwy/pWTI+w7J5ejOjcXcoN/1F0F6EqlEtu3b4dSqbQ6gHd2xSPTNo4dOxaff/651ddXKpVYtWoVWltb0dDQgODgYGg0GkyYMAHnzp1zy8+Kf+wcxz50HPvQMew/x7EPHeepwJ+pPuTT7FnR1lzevFqthkKh8K4VZFUqpM6bZxT0v/3gg7iQl9ch6M/OzkZERASkUikaGhqwdOlSFBUVGb0eFRVl08q8zlrVWJ+KtXHjRgDAnDlzsGDBAuzdu9em6+fm5mLMmDGYMmUKpk+fjmHDhiE1NRX79u3z+A0aERGRL2DgTz7NntxxczcLOp2uQ8UqT5Z7jHz9dST27YvgP0ro1rzxBspKS3HdP/7RIcDNzc3FgAEDUF5ejuDgYERHRyMjIwMrV64URtnT0tKEFaqtDeDtuakypb/pkMlkHW46bL2+4fEhISHo2bMnBgwYgEGDBjHoJyIisgIDf/Jp1k6SNWTuZkEkEsE0680T5R6D9+9HYlISolesAAC0XHMNys6dQ8vs2RbPaWpqQm1tLaKiooSbF6lUitjYWCG1xp4A3p6bKlOdPTWw9frOaA8REVEgY+BPPs2eai3mbhaCg4OhVCptuoFwJlFdHRL694fiuuuEfeWHD6PmnXe6rMkfERGB1tZWoycWarUaUqkUFy5cwO+//47i4mKcPn0abW1twutdBcz23FSZ6uymw9brO6M9REREgYyTe92Ik3sd48yJMN5Q1QcAoNMh5sEHEf7xx8Kuqg0boLr0UqsvoVQqsXTpUmRkZEAqlQoB8dChQ/Hzzz/jiiuuQH5+PlJTU1FTUwOpVIpjx45hyZIlSElJ6fLajvRJV5Ovbb2+s6oM2YsT2hzHPnQc+9Ax7D/HsQ8dx6o+AYCBv2P87RdNaG4uZHfcIWw33HcfGh5/3OgYawPdoqIirFy5ErGxsZBKpUhJScEvv/yCCRMmQC6XQ6lUYteuXQgKCkJtbS2uvvpqt1TCcXZlIE/zt++gJ7APHcc+dAz7z3HsQ8d5KvC3aeVeIkucMRLr6dFcdwkqLUX82LHCtqZPH1Tm5QFhYUbHGQbN8fHxUKvVyM7O7hA0K5VK7N27FykpKSgtLUVCQgLa29vRt29fyOVyAEBbWxsuueQSAEBhYSHkcjm6devW6Wq3ltjyc9KnYhke76tBPxERka9jjj85rLPKLe68htfTaBA7a5ZR0F/5ww+o/PnnDkE/YF05TcN+S09Px9SpU6FSqZCZmYm4uDghH16j0UAsFgsr3eqvZ2vVInt+TgqFAgsWLMDixYuxYMECBv1EREQewsCfHOaMeu/OqhnvrSLefx+JvXsj5NdfAQC1K1agrLQUmkGDLJ5jTTWezvotMzMTv/76K7Zv346CggLs3bsX+/fvR3p6OgD7KuL4+8+JiIjInzHVhxzW1NSE+Ph4o322jiY74xrewDQN5oa+fTH45puF11uvuALVOTmAuOt7bn35StOJsYbBelf9JpFI0KNHD+h0OtTW1qK0tFS4jj7X3hb+8nMiIiIKRAz8yWHWBKjuuIanGebkJ3Xrhr889hjC6+uF18vz86E1CZo7k5mZaXFirF5n/Zabm4uRI0cKr+l0OnTv3h3bt2/HuHHj7Mq194efExERUaBiqg85zBn11f2hRrs+DWbiJ5/g1nvuEYL+DbfdhrLSUqOgX6lUIicnB6tXr0ZOTo7ZHHlr1ijorN9MU4VCQkLQt29fDB061O5ce3/4OREREQUqjviTw5xRucUfqr/0OHQIf12/XtgunDoVe+bPR0lJCSYaHGf4ZCA0NBQHDx7Ezp07kZGRgTlz5hh9Zv3EWEs66zdrR+dZpYeIiCgwsI6/G7GOv2O8tW6wuLISCSNHCtstUVHYuGIFNKGhRotV6ekXtWpubsaePXuQlpYGiUSC5uZm1NXVCak8ziiPapgqBAAHDx40CtT9rc6+q3nrd9CXsA8dxz50DPvPcexDx3mqjj9TfYjspdVCduutRkH/f26+GWtWrhSCfnNpMPoUnMOHDwsBt0gkgkgkQlpaGjZu3OiU0qamqUINDQ0dAnpW6SEiIgocTPUhskP4unWIefhhYbvu6afRdNdduMokbcbcyLk+BUej0RhNvJVIJAgODkZRURGuvPJKs8G4rYttGaYKmRtdcKRKT6AsuEZEROQvGPgT2UBy/DjiJk8WtlWjR6Pq00+BPxbF6ionH/izWo9IJBIW1GpoaEBycnKHGwI9V5XMtLdKj7WrChMREZH3YKoPkTVaWxE3caJR0F+xZw+qPv9cCPrNMVe9R5+Ck5SUhL1796K5uRnJyckQi8UoKChAamqqUDVHz1UlM+2t0sMUISIiIt/DEX9yOVtTQpRKJTZs2IDCwkJIJBKkpKRgzpw5kMvlbmz1n6JeeAFRb7whbFe/+y5aZ87s8ryuRsXvvfdeoW9KS0uF1CAAXdbvdxZ7q/TYkyLE1CAiIiLPYlUfNwrEqj62Vo1RKpVYtWoV6uvrkZ6eDolEgpqaGtTX1+OJJ55AUFCQ29ou3bUL8jlzhO3muXNR+8orgEhk1fn66j2maTSmVX7McUWQ7MwKArZ+Nn+pHsRKFo5jHzqOfegY9p/j2IeO81RVH474k0t1lhJiLkDMzc2FWq1Genq6cE737t0REhKCzZs3Y45BIG7ImYGyqLoaPdLThW1dSAjK8/Ohi4mx6TqOTJy1Zq6AJ1mzqrAhW78HRERE5HzM8SeXMl09Fug8+G1qaoJOpzM6R1/qsrGx0ew5+tFkR8tfQqdD98WLjYJ+5eef43xJic1BP/DnxFlD1ubqW7OyrydZs6qwIVu/B0REROR8DPzJpWwNfiMiIoRqN3o6nQ46nQ6RkZFmz3HGRNOwzZuR2LMnwr74AgBQ//DDKCsthXr0aKuvYcreibNOu5FxMf1TicWLF2PBggWdPmFx5CaIiIiInIOBPwlcMcpsa/CbmZkpLG6lVquh0+lQU1MDpVKJG264wew5jowmB506hcSkJHS/776L7RsyBGUlJWh84IFOz7Omr2wdFdfzx4o59t4EERERkfMwx58AOK8uu7lce1uqxigUCtx3333YsGED9u/fL1T1WbRoEeLj4y1OhDl58iREIhEkEgkUCgXEYnHno8kqFeTXXgvpkSPCroqdO9Her59Vn9HavrInV9+RuQHeyt7qQUREROQ8DPwJgHMmX3YWENsS/OpLXVr7nuXl5UZVgE6ePIn6+nosWrTI7DmRq1YhevlyYbvmtdfQYmHSsDm29JU9k47tXVTL23n7hGUiIiJ/x8CfADhnlNkTlVtyc3MxZswYlJeX48cffwQAaLVaDBs2rEOAHZyfD8W11wrbLTNmoObdd60uz6lnbV/Z+xTF1oo5jvC32vr+9nmIiIicyW8Df41Gg4KCAhw9ehTHjx9HVVUV6uvr0draisjISPTp0wcTJkzApEmTIBYbT3X48ccf8dZbb3X5HomJiXj11Vdd9AncyxmjzJ5IUWlqakJoaCiOHj2KyZMnC4Hy3r17hVVyRfX1iB81CuLmZuG88kOHoI2Ntes9re0re2+E3JUW46z0Lm/hqs9jeDOhUCgwadIkn+wfIiIiv53ce/r0aSxbtgybNm3C4cOHcf78eTQ1NaG9vR11dXX47bffsHr1avzrX/+yWCYykDhj8qUnKrdERETg4MGDRgG2RCLBiBEjkLttG7o99BB6DBkiBP1VH3+MstJSu4N+wPq+cmTSsS0Vc+zlb5OIXfF5TCssRUVFeWWFJSIiImv47Yi/IYlEgv79+yM8PBxnzpzBhQsXhNeOHz+O9957D3//+9/NnhsSEoIRI0aYfU0mk7miuR7hjFFme1JUHE3NyMzMxM6dO5GSkgLgYunPhoYGXFZdjelvvy0c13DPPWh48kmrr9sZa/vK23P1/W0SsSs+j+nNhFQq5cJjRETks/w68JfJZJg1axYmTZqEsLAwABdTgLKzs5GXlycct2fPHjQ0NCAqKqrDNaKjo/Hggw+6rc2e5OjkS1tvHpyRmqFQKJCRkYHm5maIRCLImprw2EsvCa9revVC5fffA3/8/J3Fmr5yZ66+Pbz9xsRWrvg8/nZzREREgc1vU3169OiBV199FdOnTxeCfuDi6P9tt92GoKAgYZ9Wq0V5ebknmul3bElRcVZqxpw5c9BQU4NF69bhbwZB/7GNG1G5a5fTg35r2VvH3138rba+Kz4PFx4jIiJ/4rcj/uHh4RZfk0qlCA8PR0NDQ5fHt7S0YM2aNaipqUFQUBBiY2ORlpaGoUOHQmRjNRgy5qzR1D5ffolXVq0Str+aNQs9li71igDbm0tY+lttfVd8HtOnNiqVyque2hAREdnCbwP/zpw4ccIo6JfJZEhISDB7bGNjI7788kujfZs2bULv3r1x//33Izk52aVt9We2pGYolUps3LgRSqVSmAvQo7IScVddJRzTevnlqP5//w/DDJ7mOMrfy0N6842JPZz9eUxvJvTb/vQdICKiwBFwgX9zczNWr15ttG/27NlGqT/WOH36NJ555hmsWLHCryb5dsWeQNjSOdbmwOvnAowYMQJRUVHQNTaiz6WXopvBk4Hy/fuhtXDz5shn9adyl2Qfw5sJuVxucfVoIiIibyfS6XQ6TzfCXWpra7F8+XKcPHlS2DdlypQOK7zu2bMHe/bswdixY9GrVy/I5XLU19dj9+7dWL9+vVHO71VXXYU77rjD7Pvl5eUJk4hfeOEFqFQqF3wq96moqMAbb7yBIUOGQCqVQqVS4ejRo1iyZEmHlB1rz6moqMDmzZvR2NiIyMhI3HDDDR2u9fbbbyMqKgohISEYuWYNhnz1lfCaevNm6GbMcMnn1b+vVCoV9qlUKjQ0NFhcFdibSSQSaDQaTzfDp7EPHcc+dBz70DHsP8exDx3n6j40jF0MBUzgX15ejmXLlqGiokLYN2XKFNx1110dFvDqzNatW/Hhhx8K2wqFAm+++aZV55aVlVnfYC+Uk5MDmUzWITWnurraYnqFPeeYWr16NSY2N+Pql18W9h294gqsu/RSLF682M5PY9379uvXr8P+kpISl76vq3C02nHsQ8exDx3HPnQM+89x7EPHuboPExMTze4PiFSfkpISLF++HHV1dcK+2bNn4+abb7b5Wunp6UbbNTU1DrfPV9gzGdfRCbxipRLPPvecsN0aGYlPVqxAi0SCiOpqG1pvO1vnIPjzXAAiIiLyfX5bzlPv0KFDWLp0qRD0i8Vi3HHHHZ0G/e3t7RZfq6ysNNrurHqQv7GntKHd5RC1WsgWLECCweJpXzz1FNa//jpaJBK3lJ20tjyk6equMpmMq7sSERGR1/HrwP+nn37C8uXL0draCuBivtODDz6IqwwqwZjzwAMP4JtvvkFzc7PR/vLycqxZs8Zon37F2EBgT510e84J++gjJCYnI/S77wAAdf/6F347eBCnYmPdWg/f2jr8zlqPgIiIiMiV/DbHv6SkBI8//jgMP15iYqLF8pvTp09HWloaAODGG28EAAQFBaF3797o3r076uvrUVJSYvQ0ICgoCM899xz69+9vVZt8PccfcG5VH1OS4mLETZokbKtGjkTV5s3AHwG1t+YUumougLPTh7y1/3wJ+9Bx7EPHsQ8dw/5zHPvQcczxd7KWlhaY3tOUlZVZDL5HjRrVYV97eztKSkrMHh8WFobFixdbHfT7C3vqpHd5Tmsr4q68EhKDvq7YvRvtPrJGgi1zAazFUqJERETkbH4b+DvilVdewd69e1FUVASlUona2lq0tLQgNDQUiYmJGD58OKZNmxZQ9ftdJerFFxH12mvCdvU776D1mms82CLbWbsegS06Sx/ypwW3nI2TrImIiCzz28A/LS0NGzZssOvcpKQk3HDDDU5ukX9wVmAl3b0b8r/8Rdhu/stfUPvaa4BI5Mzm2s2Wz2m6umtERITDI/OOVkMKRHxKQkRE1Dm/DfzJ+ZwRWIlqapCQng7RH2lYuuBglB88CF1MjAtbbht7Pqc9KVCdcUX6kL/jUxIiIqLO+XVVH3Iuh6rX6HSIuece9Bg6VAj6qzZvxvlTp7wq6Ae8o0qPPdWQAl1TU5PRjRLApyRERESGGPiT1ewNrEI//xyJPXsi/PPPAQD1Dz2EstJSqMaOdVlbHeENAaS1pUTpT3avGUFERBQgmOpDVrM1/STo9GnET5jw57GDB0OZmwuEhLi8rY7wljQbZ6cP+TtXTLImIiLyJxzxJ6tZnX6iVkOemWkU9Ffs2AHl9997fdAPMM3GV/EpCRERUec44k9Ws6Z6TeRbbyF62TJhu+aVV9Dyx4JotjBXVUculzvlc3TFFVV6yD34lISIiMgyBv5kE0uBVfCBA1AY1N9vycxEzbvvAmLbHypZqqrz0EMPISgoyKH2W8v0cyqVSuTk5LA+PBEREfkspvqQQ0QNDUgYPNgo6C//7TfUvP++XUE/YLmqzubNm53SZlvpb0RkMhn69esHmUyG7OxsKJVKj7SHiIiIyB4M/Mk+Oh26PfIIeqSkQNzYCACoWr8eZaWl0DqYkmOpqk7jH+/jbt5Q3pOIiIjIUQz8yWYh33yDxJ49EbF2LQCgcdGii+U5L7/cKde3VJYxMjLSKde3lTeU9yQiIiJyFHP8yWrisjIkjBkjbGsSE6HcsQO6sDCzx5uboGtNXrylsowPPfSQ0z6LLbylvCcRERGRIzjiH+D0k1ZXr16NnJwc83nr7e2InTvXKOivzMtD5a+/dhr025sXb6ksY3x8vN2f0xEs70lERET+gCP+AcxS9RzD0pXh//sfYp58Ujin9vnn0fzXv3Z57c7y4s1VBTL3dMBbyjKyvCcRERH5Awb+Aayz4Dxr9GjEXXmlcGzbxIm4sG4dYGU5zaampg4j9Jby4q25AfE01ocnIiIiX8fAP4CZC87DtFosfv55dGtoEPateuwxXHbzzVDYUEPfXF58Y2Mjfv/9d6xevdoo57+zG5DMzExhpF2hUGDSpEleczNARERE5EuY4x/ATKvnjPn4Y9y6eLEQ9H91zz34IDsb0r59ba5bb5oX39jYiG3btmH06NEdcv4tVc2prKw0micQFRXF+vlEREREdmLgH8D0wXncoUNYmJWFoV9/DQDYO3Ik3n37bZwfPRqAfXXrTSfo/vTTT5gyZQrkf9T4N7ympfKdpaWlRk8CpFIp6+cTERER2YmpPgEsHsBrr78ubLeGhuJ4Xh6+/Oor9JNKjY61p269YV786tWrhaDf9Jpz5swxW74zOTmZ9fOJiIiInIQj/oFIq4XsttuQMGKEsEu5bRuqT5xAbN++FkfgHalb39k1LZXvlMvlTm8HERERUaBi4B9gwj7+GInJyQj99lsAQN0//4my0lKohw8XjnFF3fqurql/OrB48WIsWLAACoWiwzkqlYr184mIiIjsJNLpdDpPNyJQlJWVeey9g4qLET9pkrCtGjECVZ99Bpik0ujZu+puZ+y5puE5rOrjGLlcjqqqKk83w6exDx3HPnQc+9Ax7D/HsQ8d5+o+TExMNLufgb8beSTwb22F4uqrEVxcLOyq2LUL7b16ub8tDuIvGsew/xzHPnQc+9Bx7EPHsP8cxz50nKcCf07u9WPiCxeQMGyYsF29ejVar7vOgy0iIiIiIk9h4O/HRDU1AIDm2bNR+/rrgEjk4RYRERERkacw8Pdj7QMGoKy0VNh2Rd4+EREREfkGVvUJEEql0mgVXMOVc4mIiIjI/3HEP0Dk5uYarYJruHKufpEtX8UnGURERERd44h/gGhqavLLVXD5JIOIiIjIOgz8A4QrVuP1Bp09ySAiIiKiPzHwDxCuWI3XG/jrkwwiIiIiZ2PgHyAUCgWysrJQXV2NkpISVFdXIysry+dz4f31SQYRERGRs3FybwBRKBQ+P5HXVGZmJrKzs4V0H/2TjKysLE83jYiIiMircMSffJq/PskgIiIicjaO+HchPz8f/7+9O4+qqlz/AP5lHgRkOKKiTCKKDKI45YgpOZFmVmalpt1baYPl7WcOXUtKF+p1XFevdSu9jrVu5bJEMSeESNEQEpFBBkUE4YAM54AMcuD3B+vsy4ZzDnAOk5zvZ63Wcr97OO9+effu2Xs/+90XL15EWloa5HI5LCws4OzsjLFjx2Lq1KkwNmYTdrbu+CSDiIiIqK0xalVDoVBg7969iI6OFpXL5XIkJSUhKSkJFy9exLp169CzZ89OqqV6HNueiIiIiBpiqo8aR44cEQX91tbWCAgIQJ8+fYSyO3fuYOvWraitre2MKqrFse2JiIiIqDEG/io8ePAAp0+fFqYdHBywc+dOrFmzBrt27UJAQIAwLy0tDVFRUZ1RTbU4tj0RERERNcbAX4XIyEjU1dUJ00FBQbCxsQEAGBoa4rnnnhMtHxER0aH1a05bjW1fUFCAQ4cOYd++fTh06BCfGBARERE9wRj4q5CcnCya9vDwaDJtYGAgTKelpaGmpqZD6tYSbTG2PdOFiIiIiLoXBv4q5Obmiqbt7e1F06amprC0tBSma2pqIJVKO6RuLdEWX+lluhARERFR98LAX4XGKTFmZmZNljE3NxdNl5WVtWudWqMtxrZvq3QhIiIiIuoaOJxnCzTM91dX1jD1R+n8+fM4f/48AGDz5s2QSCTtU0EVJBIJhgwZovX6yosEU1NToay6uhq9evXq0P1oyNjYuNN+uztg++mObag7tqHu2Ia6Yfvpjm2ou85qQwb+KvTo0QOlpaXCdHV1dZNlqqqqmqzTWFBQEIKCgoTpwsLCNqxl+woMDMT+/fuFdB9lutAbb7zRafshkUieqDbsath+umMb6o5tqDu2oW7YfrpjG+quvdvQyclJZTlTfVRo3FhFRUWi6aqqKlHKi7GxMRwdHTukbh2lLdKFiIiIiKjr4B1/FYYMGSIa2Sc9PR3Dhg0TpjMyMkTLe3p6wti4+zVlr169sHjx4s6uBhERERG1Ad7xVyEwMFCUs3/hwgXIZDIAgEKhwM8//yxa/umnn+7Q+hERERERtVb3u03dBvr27YtZs2bh1KlTAICHDx9i5cqV8PT0RG5uLvLy8oRlPT09MWnSpM6qKhERERFRizDwV2PhwoUoLS1FdHQ0AEAulyMuLk60jJubG1atWgVDQz44ISIiIqKujYG/GkZGRlixYgXGjx+PCxcuID09HXK5HBYWFnB2dsa4ceMwderUbpnbT0RERETdD6PWZowYMQIjRozo7GoQEREREemEOSpERERERHqAgT8RERERkR5g4E9EREREpAcY+BMRERER6QEG/kREREREeoCBPxERERGRHmDgT0RERESkBxj4ExERERHpAQb+RERERER6gIE/EREREZEeMKirq6vr7EoQEREREVH74h1/emKsWbOms6vwRGP76Y5tqDu2oe7Yhrph++mObai7zmpDBv5ERERERHqAgT8RERERkR5g4E9PjKCgoM6uwhON7ac7tqHu2Ia6Yxvqhu2nO7ah7jqrDflyLxERERGRHuAdfyIiIiIiPWDc2RUg/VNTU4Nbt24hOTkZaWlpKCwshEwmQ2VlJaysrODm5oZx48YhMDAQhobia9NLly7hX//6V7O/4eTkhF27drXTHnQNe/fuRWRkZLPLBQUF4a233mpSnp2djVOnTuHWrVsoKiqCsbExHB0dMWLECAQHB8Pa2ro9qt0l/Pe//8WPP/7Y4uUDAwPx7rvvAtCvPpifn4+4uDhkZGQgPT0dDx48QMOHxHv27IGjo6Pa9XXpYzKZDKdOnUJcXBykUilqampgb28PHx8fBAcHw9nZuU33tb1o24bp6elISkpCSkoK8vPzUVpaivLycpibm8PJyQkBAQGYPn06rKysmqwrlUrx3nvvtah+//73v2Fra6v1/nUEbduwLY5Vfe6Ht27dQkhISIt/o1evXti7d68w3Z36oS5xi1JXOR8y8KcOl5WVhU2bNqmcV1paihs3buDGjRs4f/481q5dq/J/bKSbM2fO4D//+Q9qa2uFssePHyMrKwtZWVk4d+4cVq9ejUGDBnViLamzRUZGtuoCqSFd+lhKSgq2bt2KsrIyUXl+fj7y8/MRGRmJpUuXYtq0aVrVrSNp24YhISGoqqpqUl5eXo60tDSkpaXhzJkzWLduHdzd3duiql2WLv1QF+yHpKRr3NKVzocM/KlTGRsbw8PDA5aWlrh37x4ePnwozEtLS8PXX3+NlStXqlzXzMwMw4YNUznP3t6+ParbZfXq1QsDBgxQOa9xeWxsLPbv3y9MGxsbw9vbGxUVFUhLSwMAyOVyhIaGYvv27d2yLfv3748xY8aonZ+QkICKigph2sPDQ+Vy+tQHTUxMYGBggOrq6maX1aWPFRYWIjQ0VNT+AwcOhKWlJZKSklBTUwOFQoFvvvkGEokEAQEBbbiX7as1bahkYGAAZ2dnSCQSFBQUIDs7W5hXWlqKbdu2YefOnTA1NVW7jeHDh6udb2Ji0vId6AK0aUOg9ccq+yFgY2Oj8Tx59+5d5OfnC9PqzpNK3aUftjZu6WrnQwb+1Cns7e0xd+5cBAYGwsLCAkD9o7T9+/fj/PnzwnJXr16FXC5X+QjMxsYGH330UYfVuSvz9vYWUlE0qa2txYEDB4RpQ0NDfPbZZxg8eDAA4MSJEzh27BiA+juL33//Pd555532qXQnGjduHMaNG6dynlQqxYoVK4RpKysrTJ48WeWy3b0Penl54e2334aHhwecnZ3xxRdfICkpSeM6uvax77//XvQ/uVdffRVz584FAKSmpuLTTz8VUhQOHDiA4cOHw8DAoE32tz1o04ZAfaA6ffp0zJgxAxKJRCiPjIwUpVMUFBTgzz//xOjRo9Vu6y9/+YvGlKyuTts2bKi1xyr7IeDs7Ky2zWpra/HBBx+Iyp599lmN23vS+6E2cUtXPB/y5V7qcH379sWuXbswY8YM4eAB6q+ClyxZAiMjI6GstrYWeXl5nVHNbikxMREFBQXCtI+Pj3ACAoBZs2bBzMxMmL58+TIqKys7tI6d7dSpU6LHsc888wzMzc07sUadZ+jQoZg6dSrc3NxEx6UmuvSxiooKXLlyRZhnZmaGWbNmCdODBw+Gj4+PMJ2fn49bt261fsc6kDZtCABbt27FwoULRUE/UP++ScP2BIDc3Nw2qWtXpW0baov9sHmxsbGiu/2DBw/u1qmh2sYtXfF8yDv+1OEsLS3VzjM1NYWlpSXkcnmzy1dUVODw4cMoLi6GkZERHBwc4OPjA19f3y5956U9ZGdn45tvvkFZWRnMzc3Rt29fDB8+HC4uLqLlUlJSRNONH82amprCxcVFePxYXV2NzMxMeHt7t+8OdBGPHj1CRESEMG1sbIwZM2aoXZ59sCld+lhGRgYeP34sLOvi4tIkNWDgwIFITEwUppOTk+Hr69vWu9HpNKWK2dnZiaY1nVOB+ovZ8vJy1NbWomfPnvD09MTIkSM1pgd1N605VtkPmxcWFiaabu5uP/Bk90Nt45aueD5k4E9dSkZGhujgsbe3R58+fVQuW1ZWhpMnT4rKjh8/DldXV6xYseKJGW2hLWRmZiIzM1NUdvToUYwePRrLly9Hjx49AAA5OTmiZRoHEKrKcnJy9CbwP3/+vOgJx4QJE1S2kRL7YFO69LHGd65Vrdt45I/Gv9fdVVVVNUnRaO74DA8Pb1JmbW2Nt99+W2OKUHfSmmOV/VCzjIwMUUDbu3dvjBo1qtn1ums/1BS3dMXzIVN9qMt49OgR9u3bJyqbN29eqx9LZmVl4fPPP0dRUVFbVu+JdO3aNWzZskVIXXn06JFofsNHjOrKysvL26+CXYhCoWjyP6aW3MVSRZ/7oC59rHFfU5Vi1bhMX/onANTV1eHrr7+GTCYTysaOHYv+/fu3eltyuRw7duzAn3/+2YY1fPKoOlbZDzVrfAEVHBysdgjL5jzp/bC5uKUrng95x5+6hJKSEoSGhuLevXtC2ZQpU5oMT2VhYYEJEyZg9OjRcHFxgUQigUwmQ0xMDL777jvhsVhpaSmOHz+Ov/71rx26Hx3JwcEBs2bNQkBAAJycnGBjY4OCggKcOnVK9KJRSkoKYmJi1L7M2pi+fsz7ypUrotEZ/P39m6RKAeyDbaGlfUzVco3L9CWlSqFQ4KuvvkJUVJRQ5u7ujmXLljVZ1sjICP7+/hg1ahS8vLzQq1cvPH78GElJSTh8+LCQc1xbW4uDBw+qHe3mSddWxyr74f8UFhbi6tWrwnSPHj3UDn7Q3fthS+OW5nT0+ZCBP3W6vLw8bNq0SfSi0JQpU1R+dGrMmDFNhheTSCR49tlnYWBggIMHDwrl8fHx7VfpLmDBggVNyvr164e33noLJSUliI2NFcrj4+Mxbty4JnmKqsYJbzzEmzJNqLs7deqUaFrd3X72Qc106WON+5qqdRuXNZff3h1UVVVhx44dov7k4eGBTz75RPSioZKDgwM++eQTUZmFhQWeeuop9OnTBx9//LFQnpOTA6lU+kSPtqKOtscq+6F64eHhUCgUwrSmwQ+6cz9sadzSFc+HTPWhTpWZmYn169eLDp558+Zh2bJlrX506OfnJ5ouLi5ukzo+iRq3RUlJCYD6L1Q2pCoVpXFZ43W6o+TkZGRkZAjTzs7O8Pf3b/V22Ad162ON11XVfvrWP2UyGT7//HNRYOrv74/PPvtMq48burm5NVlPeX7QJ5qOVfZD1SorK3HhwgVhurnBDzR5kvtha+KWrng+5B1/6jQJCQnYtm2b8DKloaEh3njjDY2PyRQKhdqcf6lUKpruzndgNLUD0LQtlHcFhwwZIipPT08XTVdXV4seW5qamjb7UZbuoPEIFbNnz1a7LPugZrr0MQ8PD5iYmAgpGPfu3UN1dbVoJIuGF2hA8y+2PskKCgqwadMm0Ut+gYGBWLZsmcbjX1MfLS8vb5IH3F37qbbHKvuhahcvXhTlrI8fP17j6FPdsR+2Nm7piudD3vGnThEdHY3Q0FDh4DE1NcVHH33UbG7chx9+iLNnzzZ5YSYvLw+HDx8WlXl5ebVtpbuQlJQUfPbZZ4iNjRU9dgXqT0xnz54VlSnbwtfXF7169RLKk5KSRKMzhIWFiR47jhs3rtuPYZ+XlydKi7K1tcWECRPULs8+qJkufczCwgJjx44V5lVVVYlSsFJSUkQj2vTu3bvbBlxZWVn4+9//Lgr6586di3fffbfZAQ+2b9+O77//XjR+OPC/FxEb5gVbW1t327vV2h6r7IdN1dbWtnrwg+7WD7WJW7ri+dCgTl/f5KNOk5mZibVr14oOeicnJ7VDH86YMUP4SMX8+fMB1L805OrqCjs7O8hkMmRmZooCYCMjI2zcuLHb3q2+desWQkJCANSfHNzc3GBhYYGCggJkZ2eLlnVwcMCOHTuEu/6xsbHYunWrMF/V58OB+vzCxp8P747279+PM2fOCNMLFizAvHnz1C6vT30wLi4OP/30kzB9//590Vck3dzcYGJiAqD+gmnVqlUAdOtjhYWF+Oijj0S/4+npCQsLC+ET9Upr1qxp0SfqO5O2bbhkyRJRwGplZSX6WE9DPj4+opSLDRs2CAGBk5MT+vTpg6qqKty5c6dJEPz6668jODhYx71sX9q2oS7HKvvhKtH6MTEx2LFjhzA9dOhQ/P3vf9f4m92pH+oSt3S18yFTfajDVVRUNHkTPTc3V+3XJ0eMGNGkTKFQNBm3XsnCwgLLly9/ogOu5jR8c7+iogLJyckql+vduzdWr14tegFw5MiRWLp0KQ4ePIja2lrU1NQgISFBtJ6VlRXWrFnT7YP+8vJy0Qe7zMzMWjwigz70QZlMJvofU2N3794V/t3wrpYufUwikWDt2rXYsmWLkArQuA6GhoZYunRplw+2AO3bsHFgVFZWJhpNpaHGT+Uanh/UnVsNDAwwe/bsLh1sKWnbhkraHKvsh2ItHfygoe7UD3WJW7ra+ZCBPz1Rdu7ciWvXriElJQUFBQUoKSlBRUUFzM3N4eTkBH9/fwQFBXX7gHXIkCHYsGED4uLikJ6ejqKiIpSUlKCmpgZWVlZwdXXFqFGjMHnyZJVfRZw5cyZ8fHxw+vRpJCYmCl+z7N27NwICAhAcHAwbG5tO2LOOde7cOdGoCIGBgc2+MMk+2DK69DEvLy/s3r0bYWFhiI+PR35+PhQKBezt7eHj44Pg4GC9/DhaS61cuRLXrl1DYmIicnNzUVJSArlcDlNTU0gkEgwZMgRTp06Fu7t7Z1e1Xel6rLIf1ktPT0dqaqow7ezs3KKhN9kP/6crnQ+Z6kNEREREpAf4ci8RERERkR5g4E9EREREpAcY+BMRERER6QEG/kREREREeoCBPxERERGRHmDgT0RERESkBxj4ExERERHpAQb+REStdOnSJcyfPx/z58/v7KrovVu3bgl/C6lU2tnVabUNGzZg/vz52Lt3b2dXhYj0AAN/IiIiIiI9wMCfiIiIiEgPMPAnIiIiItIDDPyJiIiIiPSAcWdXgIios8hkMoSFhSE+Ph5SqRQ1NTWwt7eHj48PgoOD4ezs3KLtSKVSnDhxAjdu3EBJSQl69OgBX19fPP/88xq3kZqail9//RW3b99GcXExDAwMYGNjAzs7O3h7e2PMmDEYOHCgynXLysrw66+/4vr168jLy0NlZSVsbGzg5eWFWbNmYdCgQSrX27t3LyIjI+Ht7Y0NGzbg9u3bOH36NFJTU1FSUoL+/fvjgw8+wN/+9jcAwIoVKzBhwgS1+1BVVYU333wTlZWVeP755/HKK680WSY3NxdnzpzBzZs38fDhQ9TW1sLBwQH+/v6YM2cOJBKJpuZFbGwswsPDkZmZiZqaGjg6OmLs2LGYPXu2xvU0uX//fpvso1wuR3x8PK5fv47MzEwUFxejrq4ONjY28PT0xNSpU+Hv769VHRv/rdR59913UVBQgBdffFHtC+fV1dU4d+4crl27hvv37+PRo0ewsrKCp6cngoKCEBAQoHb79+7dQ3h4OJKTk4W/n7W1NWxtbTF48GCMHDkSfn5+Wu0jEXUsBv5EpJcSExOxbds2PHr0SFSen5+P/Px8XLp0CYsWLUJwcLDG7aSnp2PTpk0oLy8XykpKShAdHY2YmBh88MEHGDNmTJP1fvnlFxw5cqRJeWFhIQoLC5GWlobs7GysWbNGZd137NiBsrIyUXlRUREuX76My5cv44UXXsDLL7+sse5nz57F/v37UVtbKyrv378/3N3dcefOHfz2228ag+I//vgDlZWVAICJEyc2mX/y5EkcO3YMCoVCVP7gwQM8ePAAERER+PDDDzFixAiV2z906BDCwsJEZdnZ2cjOzkZMTIzWIyu11T5+8cUXuHv3bpN1Hj58iIcPHyImJgbPPPMM3nzzTa3q2RaysrKwdetWFBQUiMpLS0sRGxuL2NhYTJ48GcuWLYOhoTgR4Pfff8eePXua/P2KiopQVFSEzMxMJCYmYvv27e2+H0SkOwb+RKR3Hjx4gC1btqCqqgpWVlZYsGABAgICYGJigrS0NHz33XfIzs7GwYMHYW9vj7Fjx6rd1s6dO2FiYoJ33nkHQ4cOBQAkJCTg6NGjKC0txe7du7F161b0799fWCc3NxfHjh0DAPj5+WH27Nno378/zMzMUFxcDKlUimvXrqGmpqbJ72VmZiI0NBSPHz+Gs7Mz5s6dCy8vL1hYWEAqleLXX39FREQEfvrpJ0gkEkydOlVlvXNycnDgwAF4enrixRdfhJubGx4/fox79+4BqA9w79y5g4SEBMhkMtjY2Kjczm+//QYAcHd3F+0jAJw5cwaHDx8GAAQEBGDmzJlwdXWFoaEh7t69i59++gnJycnYsWMHQkND4eLiIlr/woULQtDv4eGBV155BW5ubnj06BF+++03HD9+HIcOHVL7t2lOW+yjnZ0dBg0ahOHDh0MikcDOzg7V1dWQSqWIiopCREQEzp07Bzc3NzzzzDNa11VbhYWFCAkJQVlZGSQSCebNmwdfX19YWVmhuLgYkZGRCAsLw6VLl2Bvb48FCxYI65aXl+Orr76CQqGAu7s7XnjhBbi5ucHS0hIlJSUoLCxEXFwcsrOzO3y/iEg7DPyJSO8cPnwYVVVVMDExwaeffgo3Nzdh3siRIzFkyBCsW7cODx48wIEDBzBq1CgYG6s+XcpkMmzZsgVOTk5C2eTJk+Hp6YnVq1ejuroaR44cEd25v3HjBmpra9GzZ0+sXbtWtG1ra2u4uLhg5MiRKn9v3759ePz4MVxdXbFp0yaYmpoK86ysrLB8+XLY2dnh+PHjOHbsGCZOnChaRqm0tBReXl749NNPRb+vTLuZMGECjhw5AoVCgd9//x0zZ85Uue8JCQkAgEmTJonmFRcXC0F/UFAQ3nrrLdH8oUOHwsfHBxs3bsStW7dw7NgxURtVV1cLF0eurq7YsGEDzMzMAAA2NjZ46aWX4OjoqNP497ruIwCsXbtW5bYlEgm8vb0xYMAAfPPNNzhx4gSCgoJgYGCgdX218e2336KsrAz29vbYvHmz6OLGysoKCxcuhJOTE7788kv88ssvmDZtGuzt7QEAycnJqKyshKGhIdavXw8rKyvRuv3798ewYcM6dH+ISDd8uZeI9EppaSmuX78OAJg2bZoo6Ffq0aMHXnvtNQD1aTvK5VWZMWOGKOhX6tevH6ZPnw4AiI+PR0lJiTBPmTZhY2Oj9oJClcTERGRlZQEAli1bpjKgB4B58+bBzMwMcrkcN27cULu9RYsWqf19W1tbIW87Ojpa5TKXL1+GQqGAoaEhxo8fL5p37tw5PH78GNbW1li6dKnK9Y2MjIRUnfj4eFG6VFxcHORyOQDgtddeE4L+hgIDA+Hh4aF2/5qj6z62RGBgIACgoKAADx480Lqu2sjPz0dcXBwAYMmSJWqfaDz99NPo3bs3ampqEBMTI5QrU8DMzMxgaWnZ/hUmonbHwJ+I9Epqairq6uoAQGMKT0BAgBBYJycnq11u9OjRaucpc/vr6uqQlpYmlLu7uwOoz1U/evSoEOA25+bNmwDqnwo4OTmhsrJS5X+1tbXo168fACAjI0PltqytreHp6anx95R3uNPS0pCXl9dkvjIFxs/PD7a2tirr6uXlBYVCobauynrW1dUhMzNTWD8lJQVAfdCpTKFSRVP7t4Qu+6iUm5uLgwcPYs2aNVi6dCkWLFggfE140aJFouU60s2bN1FXVwcDAwMMGjRI7d+gqqoKrq6uAMT9xdXVFQYGBqioqMCXX36Jhw8fdmj9iajtMdWHiPRKYWGh8O/G+doNGRsbo2/fvsjKyhKt05gycG1uXsMXK318fDBq1Cj88ccf+Pnnn3Hy5El4eHhg8ODB8Pb2hq+vL8zNzZtsTxk4yuVyvP7662p/tyGZTKay3NHRsdl1R48eDXNzc1RWViIqKkr0Im1eXp5wMaPqpV5lXf/44w8sXry41XWVSqUAgL59+zZ54bQhTe3fErrsI1D/gvSBAweavPyqSuMXydub8m9QV1eHZcuWtWidhn+D3r17Y+bMmTh9+jQuXbqEyMhIuLi4YMiQIfDy8sLQoUNF6T9E1PUx8CcivVJRUSH8W1Vw3ZByfsN11C3T3DzlqDBKK1euxOnTp3Hu3Dnk5+cjLS0NaWlpCAsLg5mZGZ5++mksWLBAlGKhTeD4+PFjleWqUmdULTN69GhERUUhOjpaFBQrU2OUyzSma12rqqoAtPxvpC1d9vH27dv49ttvUVdXB1dXV8ycORMDBgyAnZ0dTE1NYWBggLq6OuEirfHoSe2tLfrL66+/DhcXF5w+fRr37t1DVlYWsrKycObMGRgZGWHs2LFYtGgR7Ozs2qraRNSOGPgTkV6xsLAQ/l1ZWakxd1kZrDdcR9Uy6rbRMNhvHKAaGxtjzpw5mDNnDvLy8nD79m0kJSUhLi4OJSUlOHPmDNLS0rBx40YYGRmJtuHh4YHQ0NBm9rRtTJw4EVFRUUIdld8HUKbAKO+YN2Zubo7y8nLMnj1blO7SUsoLk8YXTI01N78ltN3Hs2fPoq6uDo6Ojti4caPKi6nGQ662RktfBFb3tEFZZ2tra3z77bda12HKlCmYMmUKHj58iNTUVKSkpOD69esoKChAdHQ0UlNT8Y9//IPvARA9AZjjT0R6pVevXsK/79+/r3Y5hUIhvIzZcJ3GcnJyWjRP0zb69OmDSZMmYdmyZdi3b58wukxGRoboxeLevXsL9VZ3J7+t+fn5CXdzlXfA09PThbZRlwKjTCVSNcZ9SyjXf/DggcY75Zrav6W03Uflvo0cOVLtExTl8KjaMDExAVA/wpE6NTU1at8RUfYXuVzeJvn5Dg4OGDduHN544w3s2bMHCxcuBFCfxhYREaHz9omo/THwJyK9MmjQIOFOasMRTBqLi4sTAi4vLy+1y127dk3tvKtXrwKov2va3Iu0SkZGRnjppZeE6YaBrfIl16qqKly5cqVF29NVw9FslCPcKO+E29raqn3xVvm12qSkJCFfvzWUbV5VVSUMp6mKpvZvKW33UXnxpenCJCoqSut6KS9GNF383Lp1S+1FYMN6t3VgbmBggDlz5gh3+dviAoyI2h8DfyLSKz179hS+Env27FmVd2QfPXqEo0ePAqgP/NR9VRao/0iVqtFacnJycPbsWQDA8OHDRSPCNHcXOz8/X/i3tbW18G9/f384OzsDqP+ibXOjxEil0jZ5MqAc+UYmkyE+Ph6XL18GAIwfP17ti7fTp0+HiYkJFAoF/vnPfzabktN4XwICAoR9P3r0qJDz31BkZKTaUYtaS5t9VN5Rv3Hjhsp2TkxMxKVLl7Su08CBAwHUf0hL1ZCylZWVKr/+rNSvXz8MHz4cAHDixAmkpqZq/L3S0lJRapJUKlX5ETmlkpIS4f0XvuRL9GRg4E9EemfRokUwMzNDdXU1QkJCcO7cORQWFkImk+H69etYv369EIguWbJE41j7NjY2CAkJQWRkJEpKSoSvoYaEhKCqqgrGxsZCSoTS8ePH8f777+PYsWNISEhAYWEhysvLkZeXh4iICGzbtg1AfZ57w4sOAwMDvPfeezA1NYVMJsPatWvxww8/4M6dOygrK4NMJkNWVhYuXryILVu2YMWKFRpfTG4pNzc34YLjwIEDKC0tBaA+BQaoTwtRvtSampqKVatW4dy5c8jNzUV5eTmKi4uRmpqKkydPYt26ddi+fbtofVNTU7z66qsAgKysLISEhCAhIQFyuRx5eXn48ccf8eWXX7ZodKL22sdx48YBqL+Q27x5M1JSUiCTyZCbm4sff/wRmzdvVvmNh5by8/MTUsT27duHqKgolJaWoqSkBNeuXcP69etRVFSEHj16qN3Gm2++iZ49ewp9/dChQ7h9+zZkMhnkcjnu37+P6Oho7Nq1C++8847oovPSpUtYvnw5Dhw4gLi4OEilUpSXl0MqleLKlSv44osvhOFClW1BRF0bX+4lIr3Tt29frF69Gtu2bYNcLsfXX3/dZBlDQ0MsXry42YBm5cqV2Lhxo8ovyBobG2PFihUqhw0tKCjAiRMncOLECZXbNTU1xfvvv99ktBR3d3esX78eO3fuRFFREX744Qf88MMPKrdhaGiocSjM1pg4cSKOHTsmDEvar18/DBgwQOM606ZNg6GhIQ4cOID8/HyV7ayk/LZBQ1OnTkVOTg7CwsKQnp6OjRs3iuY7Ozvj5ZdfFi6UdNXafZw0aRKuXr2K69ev4+bNm8K3C5QcHBzwf//3f/jwww+1qo+RkRGWL1+O0NBQlJWVYc+ePaL5lpaW+Pjjj7F3717Rx88akkgk2LBhA7Zt2ya0ZVhYmMplDQwMhBfJlUpLSxEeHo7w8HCV6xgaGmLp0qUqP4RHRF0PA38i0ku+vr7YvXs3Tp06hfj4eOTn50OhUMDe3h4+Pj6YNWsWXFxcmt3OwIEDsXnzZpw4cQIJCQkoKSmBlZUVfH198fzzzwt3kRt67bXX4Ofnh8TERNy9exfFxcUoKyuDqakp+vTpAz8/P8yYMQMSiUTlbw4ePBi7d+9GREQEYmNjkZWVhbKyMhgZGcHW1hYuLi4YOXIkRo0a1WYpGBMnTsR3330nfPxM053whoKCghAQEICzZ88iISEBeXl5ePToEczMzODg4ICBAwdi9OjRavPoFy9eDG9vb4SHhyMzMxM1NTWQSCR46qmn8Nxzz7VZqo82+2hoaIhVq1YhPDwckZGRyMnJgZGRESQSCUaOHInZs2eLUrW04evri02bNuH48eNITk5GeXk5bG1tMWzYMMydO7dFTzz69euHbdu2ITo6GjExMcjMzIRcLoeBgQFsbGzg7OyM4cOHY8yYMbC3txfWCw4OhouLC27evInMzEwUFRVBJpPB2NgYjo6O8Pb2xvTp0zV+D4OIuhaDOuUZjoiIiIiIui3m+BMRERER6QEG/kREREREeoCBPxERERGRHmDgT0RERESkBxj4ExERERHpAQb+RERERER6gIE/EREREZEeYOBPRERERKQHGPgTEREREekBBv5ERERERHqAgT8RERERkR5g4E9EREREpAf+Hw2orQqPt0pfAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#prediciton and visualizaiton\n", "plt.style.use(\"ggplot\")\n", "plt.rcParams.update({\"font.size\":22, \"font.weight\":\"bold\"})\n", "from scipy import stats\n", "from sklearn.linear_model import LinearRegression\n", "\n", "#model = LinearRegression(fit_intercept=False)\n", "#model.fit(yhat, y_test)\n", "#reg_line = model.predict(yhat)\n", "#score = model.score()\n", "reg_stat = stats.linregress(yhat, y_test)\n", "reg_line = reg_stat.slope*yhat\n", "\n", "fig,ax = plt.subplots(figsize=(12,8))\n", "ax.scatter(yhat, y_test, edgecolor='k', facecolor='grey', alpha=0.7,)\n", "#ax.plot(yhat, reg_line, color=\"red\", label=\"R²= {:.2f}\".format(r2_score(y_test, yhat)))\n", "ax.plot(yhat, reg_line, color=\"red\", label=\"R²= {:.2f}\".format(reg_stat.rvalue))\n", "ax.set_ylabel(\"predicted values\")\n", "ax.set_xlabel(\"observed values\")\n", "ax.legend(frameon=True)\n" ] }, { "cell_type": "code", "execution_count": 34, "id": "7655edb8", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#residuals plot (To check for overfitting)--including linear models deviates the residuals form normal distribution (which justifies that\n", "# the relation between the large scale and local precipitation is non-linear). Therefore, models like tree-based algorithms, bayesian regression\n", "# and deep learning models are feasible for modeling the transfer function\n", "plt.style.use(\"ggplot\")\n", "plt.rcParams.update({\"font.size\":22, \"font.weight\":\"bold\"})\n", "\n", "from yellowbrick.regressor import ResidualsPlot\n", "model = stacked_regressor\n", "visualizer=ResidualsPlot(model, hist=True, qqplot=False)\n", "visualizer.fit(X_train_new, y_train)\n", "visualizer.score(X_test_new, y_test)\n", "visualizer.show()" ] }, { "cell_type": "code", "execution_count": 35, "id": "f3db5ca5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Explained Variance: 0.64\n", "R² (Coefficient of determinaiton): 0.63\n", "MSE): 24.22\n", "MAE): 17.66\n", "RMSE: 24.216042\n", "NSE: 0.63\n" ] } ], "source": [ "# model evaluaiton (regression meterics) mean_squared_error, r2_score, explained_variance_score, \n", "# max_error, mean_absolute_error, mean_squared_log_error, mean_absolute_percentage_error\n", "\n", "#explained_variance \n", "score = explained_variance_score(y_test, yhat)\n", "print(\"Explained Variance: {:.2f}\".format(score))\n", "\n", "#r2_score \n", "score = r2_score(y_test, yhat)\n", "print(\"R² (Coefficient of determinaiton): {:.2f}\".format(score))\n", "\n", "#mean_squared_error \n", "score = mean_squared_error(y_test, yhat, squared=False)\n", "print(\"MSE): {:.2f}\".format(score))\n", "\n", "#mean_absolute_error \n", "score = mean_absolute_error(y_test, yhat)\n", "print(\"MAE): {:.2f}\".format(score))\n", "\n", "#RMSE\n", "error = y_test -yhat\n", "score = np.sqrt(np.mean(error **2))\n", "print(\"RMSE: {:2f}\".format(score))\n", "\n", "# Nash-Sutcliffe Efficiency (NSE)\n", "score = (1-(np.sum((yhat-y_test)**2))/np.sum((y_test - np.mean(y_test))**2))\n", "print(\"NSE: {:.2f}\".format(score))" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.7" } }, "nbformat": 4, "nbformat_minor": 5 }