diff --git a/02_activities/assignments/assignment_2.ipynb b/02_activities/assignments/assignment_2.ipynb index 29d661c57..25c26d771 100644 --- a/02_activities/assignments/assignment_2.ipynb +++ b/02_activities/assignments/assignment_2.ipynb @@ -97,18 +97,49 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "# Load the libraries as required." + "# Load the libraries as required.\n", + "import pandas as pd\n", + "import os\n", + "import sys\n", + "from glob import glob" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 517 entries, 0 to 516\n", + "Data columns (total 13 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 coord_x 517 non-null int64 \n", + " 1 coord_y 517 non-null int64 \n", + " 2 month 517 non-null object \n", + " 3 day 517 non-null object \n", + " 4 ffmc 517 non-null float64\n", + " 5 dmc 517 non-null float64\n", + " 6 dc 517 non-null float64\n", + " 7 isi 517 non-null float64\n", + " 8 temp 517 non-null float64\n", + " 9 rh 517 non-null int64 \n", + " 10 wind 517 non-null float64\n", + " 11 rain 517 non-null float64\n", + " 12 area 517 non-null float64\n", + "dtypes: float64(8), int64(3), object(2)\n", + "memory usage: 52.6+ KB\n" + ] + } + ], "source": [ "# Load data\n", "columns = [\n", @@ -118,6 +149,22 @@ "fires_dt.info()\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Get X and Y\n", + "\n", + "Create the features data frame and target data." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -131,8 +178,23 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(1090.84)" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "target = \"area\"\n", + "X = fires_dt.drop(columns=[target])\n", + "y = fires_dt[target]" + ] }, { "cell_type": "code", @@ -178,12 +240,38 @@ "+ Categorical: one-hot encoding." ] }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.pipeline import Pipeline\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.preprocessing import StandardScaler, PowerTransformer\n", + "from sklearn.impute import SimpleImputer, KNNImputer\n", + "from sklearn.model_selection import train_test_split, cross_validate\n", + "from sklearn.naive_bayes import GaussianNB" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "from sklearn.preprocessing import OneHotEncoder\n", + "numeric_features = X.select_dtypes(include=[\"int64\", \"float64\"]).columns\n", + "categorical_features = X.select_dtypes(include=[\"object\"]).columns\n", + "\n", + "preproc1 = ColumnTransformer(\n", + " transformers=[\n", + " (\"num\", StandardScaler(), numeric_features),\n", + " (\"cat\", OneHotEncoder(handle_unknown=\"ignore\"), categorical_features)\n", + " ],\n", + " remainder=\"drop\"\n", + ")\n" + ] }, { "cell_type": "markdown", @@ -199,10 +287,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "preproc2 = ColumnTransformer(\n", + " transformers=[\n", + " (\"num\", Pipeline([\n", + " (\"scaler\", StandardScaler()),\n", + " (\"power\", PowerTransformer(method=\"yeo-johnson\"))\n", + " ]), numeric_features),\n", + " (\"cat\", OneHotEncoder(handle_unknown=\"ignore\"), categorical_features)\n", + " ],\n", + " remainder=\"drop\"\n", + ")" + ] }, { "cell_type": "markdown", @@ -227,20 +326,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "# Pipeline A = preproc1 + baseline\n" + "# Pipeline A = preproc1 + baseline\n", + "from sklearn.linear_model import Ridge\n", + "baseline = Ridge(random_state=42)\n", + "Pipeline_A = Pipeline([\n", + " (\"preprocessing\", preproc1),\n", + " (\"regressor\", baseline),\n", + " ])" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ - "# Pipeline B = preproc2 + baseline\n" + "# Pipeline B = preproc2 + baseline\n", + "Pipeline_B = Pipeline([\n", + " (\"preprocessing\", preproc2),\n", + " (\"regressor\", baseline),\n", + " ])" ] }, { @@ -249,18 +358,27 @@ "metadata": {}, "outputs": [], "source": [ - "# Pipeline C = preproc1 + advanced model\n" + "# Pipeline C = preproc1 + advanced model\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "advanced = RandomForestRegressor(random_state=42, n_jobs=-1)\n", + "Pipeline_C = Pipeline([\n", + " (\"preprocessing\", preproc1),\n", + " (\"regressor\", advanced)\n", + "])" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ "# Pipeline D = preproc2 + advanced model\n", "\n", - " " + "Pipeline_D = Pipeline([\n", + " (\"preprocessing\", preproc2),\n", + " (\"regressor\", advanced)\n", + "]) " ] }, { @@ -276,31 +394,137 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'alpha': 1.0, 'copy_X': True, 'fit_intercept': True, 'max_iter': None, 'positive': False, 'random_state': 42, 'solver': 'auto', 'tol': 0.0001}\n", + "{'bootstrap': True, 'ccp_alpha': 0.0, 'criterion': 'squared_error', 'max_depth': None, 'max_features': 1.0, 'max_leaf_nodes': None, 'max_samples': None, 'min_impurity_decrease': 0.0, 'min_samples_leaf': 1, 'min_samples_split': 2, 'min_weight_fraction_leaf': 0.0, 'monotonic_cst': None, 'n_estimators': 100, 'n_jobs': -1, 'oob_score': False, 'random_state': 42, 'verbose': 0, 'warm_start': False}\n" + ] + }, + { + "data": { + "text/plain": [ + "{'regressor__alpha': 500}" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.metrics import make_scorer, mean_squared_error\n", + "from sklearn.model_selection import GridSearchCV, KFold\n", + "import numpy as np\n", + "rmse_scorer = make_scorer(mean_squared_error, greater_is_better=False)\n", + "cv = KFold(n_splits=5, shuffle=True, random_state=42)\n", + "param_grid = {\"regressor__alpha\": [0.1, 1, 10, 100, 250, 500, 750, 1000]}\n", + "print(baseline.get_params())\n", + "print(advanced.get_params())\n", + "\n", + "gs_A = GridSearchCV(\n", + " estimator=Pipeline_A,\n", + " param_grid=param_grid,\n", + " scoring=rmse_scorer, \n", + " cv=cv,\n", + ")\n", + "\n", + "gs_A.fit(X, y)\n", + "gs_A.best_params_ " + ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "{'regressor__alpha': 250}" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gs_B = GridSearchCV(\n", + " estimator=Pipeline_B,\n", + " param_grid=param_grid,\n", + " scoring=rmse_scorer, \n", + " cv=cv,\n", + ")\n", + "\n", + "gs_B.fit(X, y)\n", + "gs_B.best_params_ " + ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'regressor__max_depth': 5, 'regressor__n_estimators': 200}" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "param_grid = {\n", + " \"regressor__n_estimators\": [100, 200],\n", + " \"regressor__max_depth\": [5, 10]\n", + "}\n", + "\n", + "gs_C = GridSearchCV(\n", + " estimator=Pipeline_C,\n", + " param_grid=param_grid,\n", + " scoring=rmse_scorer, \n", + " cv=cv,\n", + ")\n", + "\n", + "gs_C.fit(X, y)\n", + "gs_C.best_params_ " + ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'regressor__max_depth': 5, 'regressor__n_estimators': 200}" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gs_D = GridSearchCV(\n", + " estimator=Pipeline_D,\n", + " param_grid=param_grid,\n", + " scoring=rmse_scorer, \n", + " cv=cv,\n", + ")\n", + "\n", + "gs_D.fit(X, y)\n", + "gs_D.best_params_ " + ] }, { "cell_type": "code", @@ -318,6 +542,31 @@ "+ Which model has the best performance?" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pipeline_A: -4014.2216910254297\n", + "Pipeline_B: -4008.8558718647955\n", + "Pipeline_C: -4884.5908470184995\n", + "Pipeline_D: -4884.5908470184995\n" + ] + } + ], + "source": [ + "print(\"Pipeline_A:\", gs_A.best_score_)\n", + "print(\"Pipeline_B:\", gs_B.best_score_)\n", + "print(\"Pipeline_C:\", gs_C.best_score_)\n", + "print(\"Pipeline_D:\", gs_D.best_score_)\n", + "\n", + "# Pipeline B has the best performance" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -329,10 +578,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "import pickle\n", + "best_model = gs_B.best_estimator_\n", + "\n", + "with open(\"best_model.pkl\", \"wb\") as f:\n", + " pickle.dump(best_model, f)\n" + ] }, { "cell_type": "code", @@ -358,17 +613,69 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "import shap\n", + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y, test_size=0.2, random_state=42\n", + ")\n", + "best_model.fit(X_train, y_train)\n", + "data_transform = best_model.named_steps['preprocessing'].transform(X_test)\n", + "\n", + "explainer = shap.explainers.Linear(\n", + " best_model.named_steps['regressor'], \n", + " data_transform,\n", + " feature_names = best_model.named_steps['preprocessing'].get_feature_names_out())\n", + "\n", + "shap_values = explainer(data_transform)" + ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "shap.plots.waterfall(shap_values[1])\n", + "\n", + "# rain, dmc, coord_x, ffmc were the strongest" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2IAAAHxCAYAAAAPwg9WAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQAA/9pJREFUeJzs3Xd8FVXawPHfzC256ZWQUELvUsQgIgoqFpSihiIgUnRRULDx2nZVgrquXdeyyK4CIouKFAV0xQqClSrSmwKBBEgjPbfMvH/clHtz5wYIqfB8P58oc2bmnDNz2zxzyii6rusIIYQQQgghhKg1al1XQAghhBBCCCHONxKICSGEEEIIIUQtk0BMCCGEEEIIIWqZBGJCCCGEEEIIUcskEBNCCCGEEEKIWiaBmBBCCCGEEELUMgnEhBBCCCGEEKKWSSAmhBBCCCGEELVMAjEhhBBCCCGEqGUSiAkhhBBCCCHqjeTkZEJCQk5rnaIovPTSS2dcRlX3q07mOi1dCCGEEEIIIarop59+okWLFnVdjSqRQEwIIYQQQgjRIF1yySV1XYUqk66JQgghhBBCiAapYhdDXdd56qmniIuLIyQkhKSkJD7//HMURWH16tVe+2qaxowZM2jcuDExMTFMnDiR/Pz8Wqu7BGJCCCGEEEKIesfpdPr8aZpW6T5vvPEGycnJTJgwgaVLl9KuXTsmT55suO2bb77Jvn37eO+993jiiSdYuHAhTz/9dE0ciiHpmiiEEEKIc4LD4WDu3LkATJw4EYvFUsc1EkIAoCQZp+tL/e6Sn5/v9zMcHBxsmO5yuXjuueeYOHEizz33HADXXnstx44d47333vPZPi4ujv/+978ADBw4kPXr17N48eKyfWuatIgJIYQQQggh6pXAwEDWr1/v8zdp0iS/+6SkpJCamsrQoUO90m+88UbD7a+99lqv5c6dO5OSknL2lT9N0iImhBBCCCGEqEHKGe+hqiqJiYk+6StXrvS7T2pqKgCNGjXySo+NjTXcPiIiwmvZarVSXFx8hjWtOmkRE0IIIYQQQjR48fHxAJw4ccIr/fjx43VRnVOSQEwIIYQQQghRgxQ/f9WrWbNmxMXF8emnn3qlf/LJJ9VeVnWQrolCCCGEEEKIGlT9QZcRk8nEY489xv3330/jxo258sor+fbbb/nuu+8Ad3fH+qR+1UYIIYQQQgghqmjatGnMmDGDOXPmcPPNN7Nz506ef/55AMLDw+u4dt4UXdf1uq6EEEIIIcTZkunrhainlJHG6fqiWin+8ccf55VXXiEjI4PAwMBaKfN0SNdEIYQQQgghxDlh586dLFiwgEsvvRSr1crq1at56aWXmDJlSr0KwkACMSGEEEIIIcQ5IigoiJ9//pm3336bnJwcmjZtykMPPURycnJdV82HBGJCCCGEEEKIGlQ7k3UAtGjRgm+++abWyjsbMlmHEEIIIYQQQtQyaRETQgghhBBC1KDaaxFrSCQQE0IIIYQQQtQgCcSMSNdEIYQQQgghhKhl0iImhBBCCCGEqEHSImZEWsSEEEIIIYQQopZJi5gQQgghhBCiBkmLmBEJxIQQQgghhBA1SAIxI9I1UQghhBBCCCFqmbSICSGEEEIIIWqM7qdF7HxvJ5MWMSGEEEIIIYSoZRKICSGEEEIIIUQtk0BMCCGEEKKeKN58jNz/7sBxKKeuqyJENVL8/J3fZIyYEEIIIUQ9cHzKl+S8/Zt7waTQ6O1rCf9Lt7qtlBCixkggJoQQQpylb/c5eX51MRn5OiO7W5jez4pJlbu9Rn5fmsKOlUcxBahcOCqBNv1j67pK9ULRpmPlQRiASyf9wW8JHd0RNdha6/VxLtyA41/rQAfz5L5YbutV63UQ5w6ZrMOYBGJCCCEaDE3X+eEIBJjg4vj68RO+NdXFwHfzcbjcyxuPuMgt1nn6OlvdVqwe2rrkMN+9sKts+cjmLG5+vScJF0fXYa3qh+JNx3zS9FwHzpQ8rB2iarUuzsVbKL71/bJl+49/oFhNmG/pWav1KLNxP+QVQd+OYDbVTR2EqAEyRkwIIUSDkJKr02Wui34fuuj9Xxd9/uvkZLFe19Vi3vrisiCs1Oyfi+umMvXc70tTvBN0+P2TI3VTmXpGt7sM05WA2r9Uc7y9zjdt1g+1Xg/yi+DKJyHxIbjiCegwFQ6k1X49RDWQMWJGJBATQgjRIDz5g8auzPLln1PhlQ1a3VWoxO5032AwV+IwQ/npvifm5OGCOqhJPaQb31Tw16WrJul/ZvqmHfJNq3GzvoDV28qXDxyDRxfUfj1ENZBAzIgEYkIIIRqEbw76Xqh+9Wfdt4iZDK4lXHUfH5Y5klJM+glHXVcDAM1l8Hr5CUDOO2Y/F6XFxi1lNcrodTJKq2lf/uab9t3vtV8PIWqIjBETQgjRIBQZXI/m2Gu/HhW5DAKJ+jBPR2aGk9dfPsrhg+6T1OuSEP4ypTFmfxf8tUAxKFrisBJO4xOhBNT+mCjd6HWq9VoAJw1aS+3O2q+HOGt10bLbEEiLmBBCiAarPvy0GwUS9SG2WPxBelkQBrD+5zzWranbZ1MZnpc6fhHzdmSz495f2DpxHelfH63byhipi0jVsMg6qIfRe8MomheigZIWMSGEEA2CVh+iGwNmg+av+lDX7b/7tiZs3ZLPFQPC66A2JQzOS11eV+ftzOanPp/jyne3shx9/wDdFlxOk1Gtar8yFuN747q99vu5KorvS6UYNZPVNKOmZa0e9fsVZ0ACaCPSIiZENUtMTCQ5ObmuqyHEOcdoLFZ9+G03Gg9WH7omOgy6uuXn1cF4Iw+KwVWHXod9Ew/N3lMWhJX648VtfrauYX4CLsVWB10TjdLq4orR6I6GKpeuDZHu5+98Jy1iQgghGoT6O89DvaiEL8Or6bqNEI1fr7qrU84W35kAC//Mq4Oa4PfWuF4HzauKbvD2qYu3udEbpq6am9fugCU/QeMIuGMAxEbUTT3EOUUCMSGEEA1DPY13DHtP1YO6Gl3DGrVI1ap6cF68GLxQup9JM2qcv5aeOuiaWG8Yfbjq4u7LnG/gjrfKl2etgk0vQUxY7delwaoH3QTqobr+ShaiQSkokOfdCFFXTAa/WPXhp10zqIVhN8paZnhdX8eBkGJwYV2ncy8YnY+6ujKq+FTwEnXSNdHoNamT82JQEXMdVOSpRd7Lh9Phve9qvx7inCOBWAO0YsUKEhMTWb9+PfPmzePGG2+kT58+JCUlsXLlyrLtjh49SmJiIrNnz/bJY/bs2SQmJnL0aPkMUcnJySQmJpKdnU1ycjIDBgygX79+TJ8+nfT0dACWLl3K8OHDufTSS0lKSuK772r2i2jXrl088sgjXHvttfTp04dBgwbx17/+lZSUFK/tli9fzm233Ubfvn3p168fd911Fz///LNhnt9//z1/+ctf6NevH5dddhnjxo3jiy++8NnuzjvvZMiQIaSkpPDwww9z1VVX0a9fv7L1W7duZdKkSfTt25cBAwbw5JNPkpWVVaXj/Pjjjw1fq8zMTK677jpuuukm8vPzq5S3EOcKw66JtV8NH0bXrPWhRcyoDnXcM9FwPFhddi81LLuu6mMxDrh0Zx20iBkVWRfPEasvXROPZPimbTpQ+/VowHQUw7/znXRNbMDefPNN7HY7SUlJWCwWlixZQnJyMs2aNaNHjx5VznfatGnExcUxefJkUlJS+PDDD5k+fToDBgzgk08+YejQoVitVj766CMeffRRlixZQrNmzarvwEqsXbuWhx9+mKCgIIYOHUrz5s3JyMjgp59+Yt++fWVlvvXWW8ydO5dOnToxZcoUiouLWb58OdOmTeOpp57i+uuvL8tz6dKlPPvssyQkJDBhwgQsFgv/+9//ePzxxzl69Ci33367Vx0KCgq466676N69O3fffTeZme7xBNu2bWPKlCkEBAQwduxYIiMjWbNmDdOmTavSsY4YMYJff/2Vd999l8TERC666CJ0XefJJ5/k5MmTvPrqqwQHB1fxTApx7qoH8Q5Gtaiv9VLqSc3qC0WpP4GhUWshYBwU1TDDWRNrvxrG6qKnpmHLab05Iw2EnC8j0iLWgDkcDubPn8/48eMZM2YMs2bNwmKxsGjRolPvXIlu3brx4osvMmLECB544AFGjx7N9u3bWbRoEQsWLGDChAmMGTOGl156CZfLxbJly6rpiMoVFRUxc+ZMQkJC+Oijj7jvvvtISkpi0qRJzJkzp6xl6uDBg8ybN48LLriAd999l7Fjx3LHHXfw3nvvERUVxYsvvkhhYSEAubm5vPrqqzRp0oT58+dz++23c9tttzFnzhzatWvH7NmzSUtL86rHyZMnGTp0KM8++yzDhw/nzjvvBOCVV17B6XTy73//mylTpjBq1CjeeustGjVqVOVjfvLJJ4mLi+OJJ54gOzub9957j59//pmpU6fSuXPnKudb3TIzMykuLi5bzsvLIzc3t2zZbreTkeF99zA1NbXS5bS0NK875VKGlGFUhtG01Z7XQnV1HEY36Eu7Jtbl62H88GSlWss40+MwqpNSklgdZRw/ftxr+VTHoRlFXap3Wm2dK73Y+EHFilWt9c+gbhBk6KpS+98lBm8YrULwXBvvXWeLaJ96OC5qXa1l1MZxiPpHArEGbMSIEVgslrLl2NhYEhISOHz48FnlO2rUKK/l7t27AzBo0CCCgoLK0tu1a0dwcPBZl2fkp59+Ijs7m1tvvZWYmBif9WrJ4Ic1a9ag6zrjxo3DarWWrY+IiGDEiBHk5OSwYcMGAH755RcKCwsZOXIkISEhZdvabDbGjh2Ly+VizZo1PmXdeuutXsuZmZls3bqVyy67jLZt23rVacKECVU+5tDQUP7+97+TkZHB/fffz6xZs+jbt69P+XUtKiqKgICAsuWQkBBCQ0PLlq1WK9HR3j9a8fHxlS7HxcWVXYxJGVKGvzKMZprwvI6uq+MwGg9WGpzV5euhG/RDLE2pq3NlNANg6cVndZQRGxvrtXyq41ANLoMqPi+rts6VYvXTNdGu1f5n0OiZDJpe+98lBoGyWuH1qY33rvnFid6DVDs3x3L71dVaRm0cR12SronGpGtiA9a0aVOftPDwcJ9WnTPVpEkTr+XSD77RBzosLIyTJ0+eVXlGDh06BLiDvcocOXIEgNatW/usKw2SSrcpHVfWpk2bU25bKjIy0ito89ymVSvfB34a1eNMdO3aldtvv53//Oc/REVFkZyc7PXFLMT5rL5+FAwvJuptXeta/ToxukHXxLrqm+i32Do4ZYri24m13nz+6qIeSZfAttfg01/d09eP7AtBAafaS4hTkkCsAVP9THVbenexsgt4l8v/Qz1NJuO7cv7Sa+JhnKebZ2XbnUm9/G1rs9n87mN0fs82aHI6nfz0008A5OTkcPToUSIjI88qTyHOFUZDMurDxWFlXRPrUr0cD2YU+NQhxeCqXjGanrM22P3MmuhnEo8aZfTBqosHKRvVo64+XB2buf9EFdWDL8V6SLomnsPCwtzPt8jJyfFZV7Hlp75p2bIlAHv27Kl0u9IJOw4c8J29aP/+/V7blP6/NN1T6f6nM+nI6ZRZVW+99Rbbtm1j6tSphIWF8be//U1mSxSiRH19oLPJILgw6tlV2wy7Jtb1tVBdT9tYgbWR7802NbAOAh8Af10T/Ywdq0m6wXhMvS7e1Eaf77qYRVKcNemaaEwCsXNYcHAw0dHRrF+/3qvFJyUlhdWrV9ddxU7DJZdcQkREBAsXLiybOt9T6fFcccUVKIrCggULcDgcZetPnjzJ4sWLCQsL46KLLgKgd+/eBAYG8vHHH5OXl1e2bXFxMQsWLMBkMnlNT+9PZGQk3bp1Y926dezbt68sXdM05s2bV9VD5qeffmLBggUMHDiQCRMm8NRTT3HkyBGee+65KucphKh5hrFgPbi+MBm0HNR5IFbX5VfQ+OYEn7TYoc3roCb4v6tQF8/NMnqd6uS1M5pMpZ69iYQ4C9I18Rw3cuRIZs2axb333kv//v1JT09nyZIltGnThh07dtR19fyy2Ww88cQTPPLII9xyyy3ceOONNG/enKysLH7++WfGjBnDFVdcUTYN/dy5c7njjju49tprsdvtfPrpp2RkZDBz5kwCAwMB91i3+++/n3/84x+MGzeOoUOHYjab+fzzz9mzZw933303cXFxp1W/Bx98kLvuuos777yTkSNHEhERwZo1a7xmNDoT6enpzJgxg2bNmvHYY48B7mB07NixvP/++/Tu3ZvBgwdXKW8hzhX19frL6K5ufahqdCMzKYfsXmkJLet2XIth9+06PFlNxrYmZ3Mmh2fvRrNrNBrYlA7P9qybyvh5Tpffae1rkKKqBmPE6sm9+zq/myBE9ZFA7Bw3fvx48vLy+Pzzz9m4cSOtWrXiiSeeYOfOnfU6EAPo378/77zzDnPnzuXTTz+loKCAqKgoevTo4TVb4T333EOzZs34+OOPmTVrFqqq0qlTJx599FH69OnjleewYcOIiYlh/vz5vPPOO+i6Tps2bXjmmWcYOHDgadftggsuYNasWbzxxhu8//772Gw2+vbty7PPPss111xzRsepaRpPPvkkubm5/POf//R6Xtg999zD5s2beeGFF+jatSstWrQ4o7yFOJeEWOB4hbRI/8M4a43RdXJ9eKDzDUMi+fdbx8qWbTaFK68Or8MaYThrYl1GYoqi0OmVXrR7qgdasQtrdB2+oQL8dU30P6a7xhg+DbwO3tRGH6760O9XiGqi6DUx04IQQghRzaZ+7eKtLd4/Wc9drvJI77q9Uz/o3Tw+3+19sWw1QfE/6jboAdi1vYCffsglMFDliqvDiYu3nnqnGvTv61ZTmO3wSmvUIZQx8y+plvwdDgdz584FYOLEiV6PeKnvsv+1mfR7vvZJTzgwCWuriFqtS36rmfBnZoWKRBJ8MLlW60Hfx+DH3d5pkcGQ+X7t1kOctSLlbsN0m/6vWq5J/SItYkIIIRqEp/qq/J7u4nv3kyi4sa3CfRfVz25K9aVWHbsE0bFL0Kk3rCVh8TafQCyqVbCfrc8zfu6L18kjTOpLF9IuzX0Dsaa+D1cWDUF9+VasXyQQE9UmKyur0mnxwT09u9lc+dvOZrP5PLuroTqdcxIUFOT1oGwhhLGoQIU1o8zsy9KxmiAhrH78sEcE+tajvo5nq2s9Rrdg1ZPbypZVk0L34XU0OUY942+a+rromqiEWH3HiAXXwfjCKQPhvdVg95g58sEhtV8PIWqIBGKi2owbN47U1NRKt+nZsyebNm2qdJvBgweTnJxcjTWrO6dzTiZNmsRdd91VSzUSouFrG1m/opyr21lYuMV7ivG+reTn1UjH6+KxBprYsfIoJqtK9xEJxHeNqOtq1Qu6v+eI+Rk7VpNM13bE+XtqhbQOtV4PLmwN3z8Dr38G+cVwW38Y1ufU+4l6R6aqNya/FKLaPP300xQXF1e6TVhYmOFzzTw1atSoOqtVp07nnDRt2rSWaiOEqAlje1pYudPB0m3uYKx5hMJrQ+rBLCL1VOt+sbTuF1vX1ah3zPF+umjWwQOMrY9dg7ZmH9qGwwCoPZth/du1tV4PAHq3h/+2r5uyhahhEoiJatOjR4+6rkK9I+dEiHOfxaSwZFwwO465yCjQ6ZNgwlwHF8+iYQu6oTWmJiG4jpY/5zLoupZYmofVel2U6GAC1/8frvUHQQfTxTJjrzhb8p1oRAIxIYQQohp0blz7XcjEuUMNtNDs+1FkzvwR+/YMAq9sTtSTl9ZpnUy9JAAT1UO6JhqTQEwIIYQQoh6wtImk8fxBdV0NIUQtqSePSRdCCCGEEEKI84e0iAkhhBBCCCFqjHRNNCYtYkIIIYQQQghRy6RFTAghhBBCCFGDpEXMiLSICSGEEEIIIUQtkxYxIYQQQgghRI2RMWLGJBATQgghhBBC1BgJxIxJ10QhhBBCCCGEqGUSiAkhhBBCCCFELZNATAghhBBCCCFqmYwRE0IIIcS5xQG/vbaT4z+nE9YqlG5TOxHWMuTUu+U42PvyNjJ+OE5op3DaP9yVoObBp9wvZ/0JDj//O/ZjhTQa1pKm93ZGUX3HxORvPEHq85txHC0gMqkVje/rimKq2j3xwnUpZL20Hi2riJDRnQi/qzuK4ltmwZKd5M/eBIpCyJSLCLypQ5XKE+JsyBgxYxKICSGEEOKcYl4ZwvZdewA4sSmTo98f4+bvBmIJrvyyZ8OEtZz4JhWArPXppK9O48oNQzAFmPzuU7D3JL/1/xyt0AVAzrpjONKLaPXMRV7bFf+Zw67+n6LlOwHI+yENx7FCmj9/yRkfX/HvJzgyYBG63V1m4fcpaCeLiXqkt9d2hUt3kTl8Sfl+Xx4gevlIAoe0P+MyhTg7EogZka6JQgghhDh3FCiouyxeSYUnijj89dHKdzuUVxaElaflc+LbVD97uB1fsL8sCCuV+u/dPttlLNhbFoSVOjF7R6V5+5Mz9/eyIKzUydm/+WyXN3uTT1r+vzdXqUwhRPWTFjEhhBBCnFsUQK+QZNBV8HTWn2o/jNafTdrpMNjPsJ7VWaYQZ0G6JhqTFjEhhBBnzeHS2ZWhk2/XT71xHcmz6+xK1zmRr7E3UzujffdlaGQU1O6xOV06f6Y5KSx2l5uTr3H4mNPv9icynGRkufyur6+cdo2MP/NxFpfXPe9EEbnHik47D82hkb0/F2ehC4J0tE52r/WBjW1EtAsrL7PASc7eHDRn+fsgsFkwsVfHe+0X3DqURld5p1UUe1sb1CDv+9pxE9pSuD/HKy36tvaYwqze+97dBceJQooPnPSbv/NYPvY/TmLfm4Ur031OAge0QLGVdpfUAZ2wSV299tMdLmxD23nHowqETPHuMum5vXPXCfQCu+H6ilx7T6Bl5J/WtoblHTiBfjzn1BtWdOwk/HG8yuXWa7oOu49AdtXPq2hYFF3X6++vphBCiHrv20MaYz/TSM2HMCu8dqXKxK716z7f2xtdPPyti9zi8p+8rrEKS4dbaBvl/07tgUyNpA+K+S1Nx2KCab3NvHy91e/21WX9bjtPzDtJ+kmNYJvCRa3MbN5VjNMFrZuaeXZyJE0buS/+8wo0XpiVzpYdxSgK9OkZyIOTorFa6v8d6H1rT/Dlc7spzHZgCzNz1QPtOPDtMfatPg46tLgkmuv/3o2AEP8deFLWHWP1IxspPFGMJdSM/bJMlFAnwcujceQ6QQFVB9WlE90jihYDm7Lz1e0485wExgfS+81LiL00lj2vbWfXC7+jFbgw20zEDWrOBX/viS0u0G/Zeb9nsm3YdxTuPYmqKthahWBLCCb3+1Rw6QT3jKbTsmuwJbgnCjlw+3dkvLcHNB1LfBCh/RpzcvF+cOkEXRxL62U3YG3inhxEd2qk3vk12fN2gF7SnmBRMUdY0U8UgEnBEheIdiIf7BpqlI1Gs64lZGRHClftJ2P8CrRj+SjBFiztozAnhBEy5SJs17XxOQ77N/vJuW0JWmouSriNkNeuJ3BCT8Nj1g5kUJD0HtpvR8FiwjqtL7aXh572a66nncSZNBv9pwNgUlEn9sH09q2nnrTE6YK/vAPvrwNNh8vaw5L7IDb8tMuu17YdhGEvwp6jYLPCX5PgiZF1Xatqk608bJgeob9QyzWpXyQQE+IMbdiwgcmTJzNjxgyGDBlS19URok7ZXToJs10cKyhPMynw550mmoXWj0DgQJZOu1kONM33525AS4Wvx/oPrAa+V8Sqfd6tZ5+OsTK0U8317Hc4dQY/nk5GjrtcVdcJqPBTndjRyqv3RwPwzodZLP8qz2v9+GHhDLshjPrMnu9k9k0/Yi8obwkzKzo4vFv1eo5pweX3GU8u4bK7WHj5FxRllbfi6IqG1eZEyfGYYEPXMWmg6DoWp/e5DIwP5NJ/92HttV95pYd1juCqdTdUegzrL1pO3qaMsmUFHTPe75eoG1vQ+ZNryP7fIfbe8HmFHHRMHttHjGxL64+uAyDrP7+Teuc3GHXqUtFQ0Ev+X04JNJOwbxJp3f6DllFYvsJqoumhqZga+84cqdudpDd/Cf24RyuMWSX64HRMTXzfQ/kD/4NrlfcYuMDlE7EM6eKzrRHnre+iLVzvlWaaMw7TxEsr33H2NzB5rnfahMth7l2nVW691+sh2LDfO+2HZ+HSjnVTn2qWrTximB6hP1/LNalf6tctSyGEEA3K7ky8gjAAlw4/HKk/9/jWHtYwiMEAWHOo8nqu+dO3C6NRWnU6eMxZFoSBOxCraPOe8sBj2+5in/Xb9vim1TfH9+Z5BWGAV1fBUimbs/zmkbU31ysIA1A0xTsIA1AUdAUUg5e7MLWQoytTfNJzdmRjz/bfTc+Z6/AKwsAdiFV0crV7so/cNZVPFgKQt+ZI2b/zV6fgM9CtRGloVjFA0wud5C/e7R2EAdhdFP90BCOuXeneQRiAU8PxwyHj7dfs901b7Zvmj7Zmr0+avmbPqXdcs+v00hqigmLfIAxg9bbar4uoVRKICSGEqLIWYRBs8U3vHF0/WsMAOsf4r0tl6wA6x/qu7xxbsz+dcVEmAgPKy9UNng3Vqkl5i1zzJr4vQPN4gxelnoloFohqqnBsBi9HdCv/z/EKbRaEyeY7tbwe4BvQKTroBvmbQ8xEJ8b4pNviA7GE+T+PphAzthanfjZZUJcIAAI7R55yW1vnqLJ/B3SJxv+U37rHfz2oCgH9mqPYfFtsLZ19jxFAbRkBQb7Hae7cyHj7zo1907rE+amnL6Wz75g7ozQfnZueXlpDFGiFlrG+6V0Sar8uNUT383e+k0BMCCFElYUFKPz9MsXrcnHahQpdGxlfQO7M0Jnxg4sXftVIy/f9Gf7moMYja1y8tcnF6xtdPPq9i+8Pu7crcurM+d29/svTbJX6Yr/G4t0alzX3XRdoBquic8V7dlbtM57k4tXrrV7XqH0TVG7t5n3hf+SkxnOri0n+qpg9J/zXq8ihM/fXYh5ZUcCqXQ6f9U6Xzsr1Rcz6Ip8urS1oCmiAE4gKLzmfuo5FhfZNzOw9ZOerH/KxWBWCg8rPd+NGJm4eGOq3HmdLc+n8vi6L/809wu8/ZGEvdrH5q3S+fDeFPeuNJ5048UcB3/3nT5Y+uZMvX9/PwS3ZhMQE0Of2Fl7b9bglgbB4W9lyUJSV3n9pDcCfa47x06s72b0iBZfDfZ4Dwq1c/H9dvOIVvYUd54ACFI8gT9F0FF3HZFUJ6xZZfgGoQPcnexA/qBkxl3tcCJsUuj2XiD29iAOvbmfPzC3kbs8i++cT7H1sI4fe3Ikr10G713ujBpgovay0tQ0jsFtk2bJiVWg0ti3pC/eSvzUTW7co9NJ1FoWA1qFl26qBJho/dGFZFaLu6U7ABe7up56fFEWlrD3M1CLc69gjHu2NrUdjwv9xpUe6TkDfZhQu2oHzYLbPa6OG2Qh54TqvfGz3XIy5i2/ABWB7dahX4Gbq2xLLrb7jyfQTuThe/gbHEytxbTyEa/7POB5ZhjK4K0R4jLvrEo86uZ9hWV6mXgPdPQKTqGBoFQNPL4UDxyrfd+uf8PhCePlTSC+ZICQjF15dAX/7L2w+UL7t/jR4ahH8fTEcOnHqepX6bAM8Mh/mfwd23893pRQFXr8DrB4B9A09YbDxxCri3CHT14sztmLFCmbOnMmsWbPYvn07y5Yt4/jx48THx3P77bczePBgAI4ePcrQoUOZNGkSd93l3Yd79uzZ/Oc//2H58uU0adIEgOTkZFauXMnXX3/Na6+9xtq1a3E4HPTq1YvHHnuMmJgYli5dysKFCzl69ChxcXFMmzaNK6+8ssaOdfny5SxYsIDDhw8THR3NkCFD6NGjh99z8tZbb7F161Y+/fRTsrKyaNu2LdOnT6dbt25s3LiRf/3rX+zevZvg4GCGDRvGpEmTUCrc7d61axdz585l8+bN5ObmEhUVRffu3bn77rtp1qxZjR2rEFWh6zqf7vO+UDS4uQ7A1wc1blii4b6G1nlpPfw61kTLkiDj7z9rPL7ON5B5/lcXL1+hsGSPzo8lvbteWK8zo49Ocl//D9r92xonz/6old969fisXdIEfj6ssyHVXZc1B528PlBn2sXeP4uHT+oUeFxTHc3RKHSCreQY96Zr9H4rn6ySnmDPrbHz1R2BXN7KOx9N07l2dh5rD7hnPXzhu2L+drWNZ24ovyC9750cvv3djlnXS36cFVDgwrYW8rOcgAsUBYdLZ9UvhXzzSyFmTUPVdUx6+XV0bp6L/AKNyHD/5+ZsfPzqQX5bU9JdUNcJDzORn+U+SesWp3HZiDiuvb38u+rA+iw+/ttOtNKxWbrOxmWpXHVXS7JTvGdGzDpUQFFu+cyQ9nwnhVkOti3cwW8L/ihL3/PZEYa8XfLwYh08h2WpBwNQ0lV0V/m7MjDSiiOjGM2ukbkjG0xgcrlbyfL+zCPtiyOkr/WYic+lk/7DMXZO+4XiNPeLe+DZrages4IeenMXl6wfTOKWofzW/3Mcx4so2pcLClijbGiZRWDXOHj3Wo8YR8dsVsCpg0PDcbQA1ayCU0MvdHJw7Jd0+GUEAW0j0E4W4zheQOlc/Druro+qRz9bV0ahV3dLx1736xJ2/8UEDm5LwYfbyXv2Bxw/HMbxw2FyX/iJRuvGY+3mHWS59mZ4fYi1/f67g+qHT+L5oXAdzYECOwSUv+f11JMUJb4IR0+6X6Bn/ufRbVNH9Wyx23sCfcNBlKtOMRYqIhg2PgNf/Q7bUyB5Mby5yr3u+eWw5km4qLXvfp/+CsNeAFfJm+TVFfDFkzDoGTiU7k57bhl89CAkNIIrn3R3FQR44RP44e9wQQvffD393zx4eXn58vtr4Kvkyvep6M/jYPeYFfVwhns5sGY+x7VNpq83Ji1iosrefPNNVq1aRVJSEtOmTUNRFJKTk9myZctZ5Ttt2jTy8/OZPHkyN998M+vWrWP69OnMnz+fBQsWMHjwYKZOnYrL5eLRRx8lJcW3b391+OCDD3jqqacAmDJlCsOGDWPVqlW88cYbfvd58803+f777xk9ejSTJk3i6NGjTJs2jdWrV/Pwww/Ts2dP7r//flq2bMm///1vPvvsM6/9165dy8SJE9mwYQODBg3ioYce4qabbiItLY19+/bVyHEKcTa+PaTz3WHvlq1XN+pkFfm2dj39U2kQ5naiEN7c7E4odOj84xf/rUkzfigPwkq9sF4nz890+SeLdF6uJL9fjvruN3ONb6vYjG+972z/kQ3zNpdfLL26zl4WhAEUO+HZ73zHFX21x1kWhJV6eXUROSXnadtBB9/+bndPKlFh39/32jlywqNuioIL93WzU1FQde8ObAWF8MmXuT51qA7HDxeVB2G4A5nSIKzUz58cozCv/Fh/eP9weRBWUv/S9G3/S/Pa9+CP6dg99nUWa/zyzn5+//BPr+0O/5RO6uZMNJfO5jd2okDZH+AzUYc9o8KYuZIxYwB739nD73/b6HOsf7y7l6K08hdXqfBeK9idQ+rCA2R+noLjuEdAqYM901624PnaqOjuIKx0bZHL69y4Mos5/pr7wcyZb/2Gdry0fPfReeemQ573ey3/490Ub3O34ljaRuHcehy9sPx86rl28l78yWsf7VgehW/+4pVm/2Ivjp+Mx4gVzVjlnfBHJvZ5G7ySnLPWlQRhpbXXvf9d5PGesTtx/f1/hmX5MKkwsDts+RPyPM55frE7GDMy86PyIAzgSCbc/255EAagaTBzETy3tDwIA8gp8A6wjKTnwOsVJmH5eit8v/20DgkAl8tdvqffD8LHP55+HvWe4ufv/CYtYqLKHA4H8+fPx2Jx3xq++uqrufHGG1m0aJFhq9Hp6tatGw899FDZsqIoLFiwgIyMDBYtWkRQUBAAvXr1YvTo0Sxbtoxp06ad1bFUlJuby1tvvUXz5s2ZN29eWZnDhw/nlltuqXTfuXPnYja7P1pt2rThgQce4JFHHuG9996jY0f3Hb8bb7yRwYMHs3jx4rIWxKKiImbOnElISAgffPABMTHl/fknTZqEptXsBAGnKzMzk+DgYAICAgDIy8tD13VCQ91doex2O7m5uURHR5ftk5qaSnx8vN/ltLQ0GjduXNY6KGU0nDLSDB53Y3fBrkPH6dO+/K57amoqafm+Y05SS/Y/dDybfIf/7nR5Dnd7gKdCJ5wshhCr73FkFUGxcW9DoPTy2PvCOs8OGRkZ3ucqR/MpNzW3fL8/TxRS8af0qMdEG6XnKi3Xd2bGIidkFWjkZx3nRI57bJDRpUlllyq+Z8Xt2AnvyRqq6zXPyzaqgTenQ6cw10V27gni4+PJyzTupmUvcJ3WRUjeiWLvQK5EQXoxRw8fpTjn1N3AKjuHml2jOMs3ePZsUcPPBNPFqYUUZ1bhWVie5VR4LzpS80lLS8OVVuB/pxJGx+VKzYcLGpGamoopLc9gvTut9DXX0vO9A5US+QdOYLog0ue7xJLmG+Trqe5zUPq+0tM8z8mpRwLpqSe9yjjl91Vatm8mqe60iu9dLTXLp9XBeTTT972XmgWhBo8qSM2q/PORkQsO3+f75e45TGi/8pkkK/0MOlzomXk+r6fzcHpZPavju13UP9IiJqpsxIgRZUEYQGxsLAkJCRw+fPis8h01apTXcvfu3QEYNGhQWUAE0K5dO4KDg8+6PCO//PILRUVFjBgxwqvM0NBQhg8f7ne/YcOGlQVhnnXv2rVrWRAGYLFY6NKli1fdf/rpJ7Kzs7n11lu9grBSqlo/Pq5RUVFlP3AAISEhZT8MAFar1euHAfD5Iai4HBcX59VFU8poOGVc11KhwrNs6dYIryCstIykdr6XjaVpHZpG0reScff9mylUnH/g4jho6jFFvudxtIxQuLCx/8vvaJtvWp/mis+5GtbFN1S4uVN5a8uYRN/JGoZdUP69WHquBna0EFihy2bPZiZaRJmIj4/n4vZWwoOUir3sAAgMUqk4X0fpt4EJ0AwOs/8l3s9Wqq7XPKFjMKGRHl3QDCYSiWsdSFR8QFkZHS6P9tkGIKFHOKGNArzSLMG+57vDdXFEtg7x2a7ZJTE0a9mUZpcbjWXyboHzmaRD18u69IV3CqfZEN9BhEHNg8svjBUFveJXsKoQe1MCzUb7dqmr0G7l8W/f81VxpsWIYW2Ii4sj9Gbf531VDGoqhjhqoyBsl7u7hcbHxxOY5Fu30rTS19zUORZTB+/fHCUsgLAhXQy/Syw3X+CTpzmpa1mZAKak7n6P0OgcqEkXepXhyfC9e3MvnzxIuhjwfe+qSZf41nfiAIP9L4GbexumV/r56NAUulR4/4TYCB122amPo5TNijLwQq/1mFTMw/qUZ1kN3+11SS9p0a34d76rH1d2okFq2tT3qik8PJyTJ40Ha5+u0jFjpUq/eIy+UMLCws66PCOl3R1btWrls651a4M+6CUq1j0szP0MltOp+6FD7m4g7dq1O/MKC1FHYoIUViSpdGsEZhWuaaGw7EbjMQ3Jl6rc00MhxAKNg+DF/irD2pf/DH042MSg1goWFZqHQpMQsKhwU1uFD4eY+ORGlQti3OUMbKmwaEjlYyeWJJm5tpWC2QStIiAiAMomUUDngkblF8wXxsGKW3yDgDcGWxnb3YTNDC0iFObcbKVPQnm5Yy+08PfrrDQKVggNgPv7WnjsSt/Wr8ahKp/eHkLXeBNmFa7rYGbJhPLZAIMDFGZNDueCFhY0FYJsCiYVOjQz072lmYAABYsZVAVsZgi2KvTpGkCbJiZUE8REm7AFKISFqIy5KYyrLzv1bH5VYbaojHuyDQkdg1FNkNA5hCH3tqBxK/cMiG0uDGPU42299uk3MYELh8ZhsiruiSYUaHdpFEP+1p4B09sREOo+79ZgE1c/1pHek1pjC7dgCTQREm1l83t/EJIQQtyFkahmhZiOYQx6I5GAUHdk2/+Fi2h6WWzZi6mHuNBaOMCqoikKQU2D6P1yL+L6NUYxK4QkBBPWPATVrNC4X2P6zrmMbi/0IqJH+ayG5nALl3x0BZ1eTCQgPhBTsJn4iW2JHd4CNUAlsHUIXd+/jMCWwRz9zx6UUAuKVUWxqoQmRmNpZAWzAmaV0KuaEtQjGsWsYusciSnG5g5grSYa3duV2GldUUMtmBsFEv/sJUSN6QBA2E1tafxKP0yNAt0P51PA2iGSwKsSUGxm1JhAlNggsJrcsyVeHEf8Z8NQbWacf2Rz4qaPOfnMD6gtwlHCAlCjAgl9/DKCp3hPAKEoCuGfjsFyZSswq5gvjCd85VjUMIO7FUDAC4NQ25e0bltMWO65FPMl3mOoTAM7Y3ljODQJh6AA1BsuQOnWFMwq6oCOqA9dA43DICQAdeoVmJ4cdGZvxCnXwOM3Q1SIe+zYI0Ph3oHG274wDu4YAEEB0DQK3poED90EsydD8xj3jIXjr4SXJ8CDQ+Dhm9x5RofCkyNh0jWnrs8nj8KAbmA2QY9WsOKvEHmGn8F5U93BoNUM7eLhwweho4wLP9dJ10RRZf5aaEqfEV5xEgpPLpf/PkMmk/HFlb/0mnwmeWXHYMTfOfFXd0/ybHXRUF2VoPLb+FPf1wswK7x5tYk3rzZe3yxUYWWS/89KXCuF61qd/v3DVhEKq0a5L9Zf+snJQ9+Uf++kF7r/vhtn4YqW/vMMtym8PzyA9/03hPPXKwP465UB/jcocU0HC1sf8j8d+oWtLXz8sPcU5/e/nsn6HaXd5hRsVoUPn4ohuoYm4jgdTdsGMflF7wcs97reeKpzALNVZeD9bRh4v3cLj+bSWf36PopLJuew57tY89YB/vLxJXQf1pz3hn5PwTF3t8M/16XT9KJIJm/0fcByYHQA18/tC5R0mU/6GHV7AFpJO0z+8SJiLoym7QjfG2ulClLyydlV3p3OedLB9pmb6fPBFbSa1snvfr8nfUP6svKxVKoZ8jd4z7QXObQlTe+7gILfM9h+4WL3g/YA3a6h5TpoMedKmr9uPGtg9AM9iX7Ad0bCwrUppPT/wKvHZMDlzbH1ikfXdU4M/gjHDvcYKC2jEDU2mPg/70Gt2CxbwtyhEZHf3u73OD0VJ3+FtqfkGB0uHLN+wnpHb0wXet+cNU/tj3lqf/8ZvTDstMozpCjw9Ej336kE2+Cde9x/nu681v1X0fPj3H9nom08fJ18ZvtUFBsBSx4+uzzqMWn9MiYtYqLGlLYG5eT49p8/csT4wZL1RenshAcOHPBZZ5RWHVq2bAnAnj2n8WBLIcQZ+WC78RjLj3ZUMpCsjp3M01i/03vsUpFdZ93W+v+w5tORtjOHk0e9Z03MO17M0a0n+WPtCRwVHvZ8ZGMW+emVH7uu6Sg7vVskdafOn19U/puT+lkKWpF3ece+PIoj1//4M1eBk/RPK3SNd/q+n0586P7NyFy0vywIK5X54ek/CNlT7ke7fPol5n3ofrixY+vxsiCslHY8n+LvDlaprIocH2z2TtB0HIt+q5a8hTjfSCAmakxwcDDR0dGsX7/eq7UnJSWF1atX113FTkPv3r2x2Wx8/PHHFBSUD5jOzc1l8eLFNVLmJZdcQkREBAsXLiQ9Pd1nvbSYCVF1UQZj8AEibfX3Lq3VAgEGDRihQefGT7ct1Lh1JiDUUtZd0ZPJqmI5xVTeiqqAzfe7MiDMt7uoJ2uk73pzsBnV6v9cK1YVU0jFevq+n8wleZujfFtNTQblng5TpG+3QbUkTY20Gc7ioRrsUxVKVJBvWqSfD5gQolLnxre5qLdGjhzJgQMHuPfee1m8eDFvv/02EydOpE0bo0HI9UdoaChTp07l8OHDTJgwgfnz5zNv3jzGjx9PVFRUjZRps9l44oknyM3N5ZZbbuH1119n2bJlzJkzhzvvvJM1a9bUSLlCnA8e7mPGVOHiNDwA7upZf5/RExigMvKqYK+01k3MXNbt1N0gG4KoFkG06+/dpbH1pdHEtguh5WWNiOngPYtmt5EJWA0m86hI6+M9Y2RI0yBa32TwRG8PTYY0J6RdmFdam7s7Ygrw//5QzSoJD3f1SrMmhKB6zF6jWFSaPdQNgJhxHbA083494//q2+3wdITd2Q1TjEfwo0DkY+6JJswJ4QSNrVCv/gkE9Kme8UYBf/We6EJpEoZlosHkGUJ4kMk6jMkYMVGjxo8fT15eHp9//jkbN26kVatWPPHEE+zcuZMdO3bUdfUqNWrUKIKCgnj//feZNWuW1wOd77nnnlNnUAX9+/fnnXfeYe7cuXz66acUFBQQFRVFjx49aNu27akzEEIYuqa1yq+3W3juRxf7szQuaaryyKVmEsLr94XA5JtC6djCwq87imkWa2boZYFYLfW7zmdi0FOd2fG/NFJ35BDXMYzO18cBYLKoDPv3xWz/JIWsg/k0vziatlcbzY7oS+tVhB7topPaldCmIXQY1eqULWKmQDMRPaLI2+vuSq/aVKJ6+c5eW1HLv3UnpFskGZ+lYGsZQpM7O+A4Ucixd3ejOXQaj29HSA/3zHbmaBtdNgzjxL93Yk/NJ/LmVoRfU3mA6I+leRjNN40j5z9bcWUWETqqI4GXlQdaUbMGYt+chrPkmWLOXRnYtx7zeZBzVVjvvAS1TTSOJVtR40KxTLoEtVHNTA4jxLlO0aW/kxBCCCHOAQ6Hg7lz5wIwceJEr0esVObE92n8cNO3XmlBLYK5ZtPQM560qT7Inb2JrMneD0m2Xd2K2K/G1FGNxPnuuPKEYXqs/nQt16R+ka6JQgghhDivZf+W5ZNWcDAfx8lTPyy6PnJsTvNJsxukCVF7FD9/5zfpmijOGVlZWZVOiw/gdDq9HrhsxGazERIi3SyEEOJ8YdQNMaRdGNaIqk2mUdesfZrBbO/ZDa2XVPLEdCFEnZBATJwzxo0bR2pqaqXb9OzZk02bNlW6zeDBg0lOTq7GmgkhhKjPoi9pRLv7OrPvzZ3oLp2AWBsXvt67rqtVZcG3XkDRqgMUfLAdAHP7KCJfO40HEwtRQ2QclDEJxMQ54+mnn6a4uPJnzISFhRk+18xTo0b+H0wqhBDi3NRlRg/a3NWBgpR8IrpFolrr74yap6KYVWIW3oTz71egZRZiuTDOPbW/EKJekUBMnDN69OhR11UQQgjRgNniArHFnTvPxDK3ioBWEXVdDSFkqno/JBATQgghhBBC1BgJxIzJrIlCCCGEEEIIUcukRUwIIYQQQghRg6RFzIi0iAkhhBBCCCFELZMWMSGEEEIIIUSNkTFixiQQE0IIIYQQQtQYeY6YMemaKIQQQgghhBC1TFrEhBBCCCGEEDVGuiYak0BMCCGEEEIIUYMkEDMiXROFEEIIIYQQopZJi5gQQgghhBCixkjXRGPSIiaEEEIIIYQQtUwCMSGEEEKctuMpRezdkoujWDNcr7l0Dv6WQ+re/FquWe2wH8olZ9VBnFlFdV0VIRoM3c/f+U66JgohhBDilDRNZ/Ebh9n4bRYAQaEmxv+tFS07BZdtk3mkiIWP7iQ7rRiAlheGcctTHbDYTHVS5+qWNuNnjj2zATQdJdBMwntXEzGiXV1XS4h6T7omGpMWMSGEEEKc0q4NOWVBGEBBrotls1K8tvn2nUNlQRjAn5tz2PTZ8VqrY00q2pHJsafWg+a+j68XOkmZvBqtyFnHNRNCNFQSiAkhhBDilI7sL/RJSztYhMtZ3sEodW+ezzbnShfFwk2+AaUrswj7Hzl1UBshGhYdxfDvfCeBmBBCCCFOqXn7IJ+0Jq0DMZnLL6aadgzx3aZDsE9aQxR0cWOfRyGZGwVibR1eNxUSQjR4MkZMCCHEOU/XdRbu1Fl5QKdlGEzurrBiP6w7otOtkcLUCxXCAqr37uz/9rr4YJuLCJvC1ItNtI+u//c+N/6cy5b1eUREmul6YRBbf8mlMN9FWJiJrLQigqMs5GU5QIfQCBNdeoWy6PkDRDYO4JKhsXS5Kob9G05SnO8CIDI+gLa9Ik67/JSfT7B7xRGswSa63NKSqDahlW6vuTT++PAPjq09RmibMJoOaULQ11ZMJ1QOWf8g9uJGHHx3H4UHclGcOrb4QEK7RJCx/DDFR/IJvziGFk90J3dtGqlv70TLdxJ5fTOaP9oDS4wNV76DY6/8RvbH+wENc9sI7PtOoug6ikUhoEME2e/tJPKOziimyl9fV3oBuW+sx7k7k4A+TdGyCnDtyiDgihYE/aUnitl4f92lYX93Pc5v92HqFIt1Wl/UKO+g2PXNbpzvr0cJtmK++3LULvFo24/i+tcayCvGdFtv1Ks7nfbrYGh/GvxjCfy4GxqFwd0D4ZbLzi5PcR6R1i8jiq7rMmmJEEKIc9pf17r4xy/lP3eBZij0GNqT2Bh+HWtCUarnYmHOZid3LC8vICwANt1ppU1U/Q3GVn2aybIP0t0Luo5V17ymNTM7nZg9LhkaN7WS/Ud5t8PQcBOO7GI0p4ZSspkCBEdZuPM/3QkKt1Ra/t7Pj/D1o5vLyws0MWzhZZUGYxse3cC++fvLllWzgrnA5b7k03QCNB29WEN1eHSC0nXMmlbWJchsBcXu8so3sF0YPX8fxp5rlpO/NhWlZI43z3eHgo6p5ARF/qULzf4zwG899WInqd3fwbk7w2N/DbVk/6AJ3Ymce6PhvgWTFmN/Z335MXaOJXTL/SgW9wQozkWbsN8yr3yHICsBH4zDOfpdKLCXJZs/vAPTLYl+61ipQyeg+4OQXaGb6TNj4G/Dq5anOK/8oTxnmN5Kf7SWa1K/1N9fBCGEEKIaOFw6r2/yvudYWGF+hQ3HYM3h6rsv+fJP3hf2OcXwn00uP1vXD19/Vj4Rh0nXfeaWdpm8Zz48dqTYa5PCzGI0l46iuwOw0qAlP9PBtq/TT1n+b/MPeC07C13s+Pig3+3tJ+0c+OAPrzTNqaOVFGxy6ugOHcVVYSSKouBSSy9/dLD7vi6Fe3NIfe33kiCsZLcK23hOv501byfODN8xdGX5rdznFYS591fK9i+YvxXXcd+xdFpGPva5G73TdhzH+fmusmXny99571Rgx/n4Cq8gDMD18td+63dKc77xDcIAXl5e9TyFEBKIifPXihUrWLhwYV1XQwhRw1w6nM7EdnmO6iszz+4b1OXZDTasR4r9PBeslO8RGbQe+ulkYy86dRDqKPTdxiitlGbX0BwGdVYqXTxtzuxTvWAeOTs19OJK6mr44nvsr+nohQZvwCInuHyPUc8vz0/PK/ZZXzEIA8Bou9OV5+eZaQXFoFX+vhECZLIOfyQQE+etFStW8MEHH9R1NYQQNcxmVhjRwfsHv+KPX5MQuLqFexuHS8fhOrvWsXHdPFqPdPclx1iPtELHmefv0nTsJTMU6rpOUUmwZ3fouLTy/BxOHecp6u9y6Tid3tv0vjys7N+aongHXrqOqcIFd3CI6tXdTw0wgUHXTpNFoVO/KJzFGi6n+6+srh4BWvtBTdHwCPgUaHNtHI6C8gBFc+m47O79bY1sNO7X2CdAVEuy10zuuuiqb51UTS/Zz+hiUEcNNRM3pROWFqFl+fs+gLZ0T53gK5tiaRKCrutoHgGVruu4CuzYrmmFEmHz2he0spKt/VtgbhHhnXuBHSUyEPOAtl7pSlQQlkEd3dsUOTCN9e1uqE653Oe1UG/tVVYnvdA7UKu47GPM5WBwHrmtPxRVcgfD4XT/gTtgK6rndyOEqGUyWYcQQohz3ow+CuuO6KTkgtUEw9rCqoOQWQTBFph5qYJZhalfu3h3m/ty+44LFF67SsVsdAF6CslXmMkthn9vdFLohJhAOJKjs2qvk3tW2NmfqdOzicqcm610jz/1w45nflHIK6uLKLDrXNXCRE6mi6NZGpGBCs4CF+GBCuOvCiLjuIMvfynEYla4uX8Qk28O9Rr3pmk6Cxdl8dU3ubg0ncsuDeGOcdFYLAoDb4xk59Z80o87UUwKqklBs2tY0N0PMFZAsaju1h9dp1GzAMLa2di/8SQuBwRGWOjcO4btXx2nOM8dYCm6jkWF9+/chCPPiQqoFpU2l0aRcyCHjP35RLYIonG7EPZ/lYZuNqHrOoFBKlYT/O8vP4OuExpvI+GSWP787DDOIhfNr4xDLXCS+uNxVJsJnBo4NGzBJjSnCzQFXQU1yoqWbUcDdxdFXccSYEIvKA3EdDRAtZlQNR0cLtBBKXCyqcVCFHTMNjOKy+VeV0KxmVA1F9g1TCoUfXeY/R3mQk4xrrR8Ai9rSujwtmQ//QNaRhGgY+0UjalpCK6d6e7zCehWE4FD2hPx9qCyvB2/HCZ37CK0fZmAjhobjBpug5NFEGgh4PGr0O0uCge/g+vznRAdhHnQBeg/7IeThe43+PF8lKQe6Mu2uJ97ZlJwPf4pLNsEqVkoR7Ph0raoD18HM5fC5oPobRvDv8ajXNPV9w24fAMEWKHQ7g7ISoPy/34P73wN3VvCO3dDYknQ6HDCve/C3G/d2/duB78fgsw8uP5CmDsVYiNO78MkzgnS+mVMJusQPlasWMHMmTOZNWsW27dvZ9myZRw/fpz4+Hhuv/12Bg8eDMDRo0cZOnQokyZN4q677vLKY/bs2fznP/9h+fLlNGnSBIDk5GRWrlzJ119/zWuvvcbatWtxOBz06tWLxx57jJiYGJYuXcrChQs5evQocXFxTJs2jSuvvLLajzEx0XjAsmd9d+zYwZw5c9i8eTMFBQXEx8czaNAgxo8fj9lcfg/jzjvvJDU1ldmzZ/PKK6+wYcMGFEWhf//+PPzww9hsNubNm8cnn3zCiRMnaNWqFQ899BAXXnhhWR4bNmxg8uTJzJgxg/z8fBYtWkRaWhqNGzdm5MiRjB49utrPgRDnkys/crG6kjFgwRZ4KFEh+SfvbV7sr/J/varWeeTCt4vYklaen1kFs6Z5dZNsFamw74FA1EqCvUWbi7nlPff4HJOu00T3vqRRdZ2Qkp/yYJcLi8chPHJbOIP7ls+w9/V3ubwzz3usUtKN4YxMimTWS0f4bUO+u/VLd7fWmFyae7yYB5PL5W5R1HWCFK2shQpANSmYih1e9TM5nZicLtQK+aguFyZNQ9E0VM8WPF3HXGT3vmzTdRSXhrlkvJfZaVAvhwuL07sroqLpWDy6XJqLXJgq9KRTcaGiY/ZooSopFLWkA5UZdxBZcb2FknOBjslgfzOe3RU1LLioeElq7hxD3PYp7j3sTjITXkQ/lueVj1f+VhPWa1rj+myH9/Hj9Bh1pqFSsctg6eQgpf/XUaw6it3jDRkcACn/RInweOTARz/AqFcq5GXwWWoaBX/OBrMJnlsKjy3w3abUzb1h6SP+14tzzj7lRcP0tvpDtVyT+kVaxIRfb775Jna7naSkJCwWC0uWLCE5OZlmzZrRo0ePKuc7bdo04uLimDx5MikpKXz44YdMnz6dAQMG8MknnzB06FCsVisfffQRjz76KEuWLKFZs2bVd2DAU089xZw5c8jOzubBBx8sS4+MjARg3bp1PPTQQzRv3pyxY8cSFhbG77//zuzZs9mzZw/PP/+8V36FhYVMnjyZiy66iKlTp7Jr1y4++eQTiouLiYiIYPv27YwcORKn08mCBQt48MEHWbFiBSEh3s/c+eijj8jIyCApKYmgoCBWrVrFyy+/zMmTJ5k8eXK1ngMhzhf5dr3SIAwg3wGL9vhus3K/VqVA7EiO7hWEgbvRxllhGNEfWTrbj+t0jfMfiH22o7zrlw3fMU+aoqDpOirgUBQsHgHKD1uLvAKxzVsKfPLftKWQkUmR/L7ZHex5dtarGDwB6IriDox0cFUYo6W5dFRFQfHYT6+w7JUP4BMv6Ab3zhXF3bJSErAZ1UvRFZSKnQdVBV2hbBZH1eBtUNI2ZXC/XkFHRymZeqRi3p6vhPFoF/ceFSf7qLidc0c6zj+yMLeKxLn+SIUgzGAPuwvXl7t9StNQymZx9K1raT66x/8rBGEA+cXw3U642eNm5coNBnkZOJIJmw7Axe1Ovc/KjZWvF+I8IWPEhF8Oh4P58+czfvx4xowZw6xZs7BYLCxatOis8u3WrRsvvvgiI0aM4IEHHmD06NFs376dRYsWsWDBAiZMmMCYMWN46aWXcLlcLFu2rJqOqNwNN9xAVFQUgYGB3HDDDWV/gYGBFBcX89RTT3HBBRewcOFCJk6cyLBhw0hOTua+++7jm2++YcMG7x+Z7OxsRo4cyYwZMxg+fDiPP/44V111FV9//TXbt29nzpw5jB07lgkTJvDEE0+Qm5vLF1984VOvQ4cOMW/ePCZNmsStt97Ku+++S+fOnZk7dy6pqanVfh6qIjMzk+Li8kHfeXl55Obmli3b7XYyMrzvuFese8XltLQ0PBvnpQwpozrLsJkh1vdZxD4SQnwvXhtZvCcpON3jiLRBiPXUZVpMoBQcr7SMKEv5bHyGc47onoGT96q4KJNXntHRvvdfY6JNpKWlERVdOr18+YV/ZeGr7i92NOpoU1mvpIrrKo5PK+UxDs5ova4YRVnesz9WejyVVs2wRK9Q7PRyNCgjyMJxZw4AavNw47FYFXOO9X1I9pl3/PJznlvEAB6fwRaNTi87k8oxS8k79FT7JFQoo0R9/y5p6GXUJd3P3/lOAjHh14gRI7BYyp/7EhsbS0JCAocPHz6rfEeNGuW13L17dwAGDRpEUFD51VK7du0IDg4+6/LO1C+//EJmZiaDBg0iLy+P7Ozssr++ffuWbePJZDIxcuRIr7Tu3buj6zpJSUleXRlLuySmpKT4lD1w4EAaN25ctmyxWBgzZgwul4vvv/++2o7xbERFRREQEFC2HBISQmho+XN+rFYr0dHRXvvEx8dXuhwXF+c1jkXKkDKqswyTqvD3y1SvC9UmFa5jExvD3/qYiPSYTyHSBjP7e294uscRZFWY0d876Lm6tUpSJ++f3Ycus3BB67hKy3hkYDQJke79ioHiClfcASWBWHykiuejuqLCVEYOCPbKc/D1YYSHldch0KaQNDSCuLg4bhoVg6J4XyC5VNXrYsls9miNUhXaXhzuVZeWF4RgNpfkoesomobicvlM/mGyKJhc7uZBXVUwWb3Pi2KrMG5O1wkIMpe9hrrNhKJ6r1d0yqauL6U6vZ8fpim+E26UHqEaVjFyLp+MI6BluEF7mHdgWLFhz9om3Os9pwNqh2iffEIfv4wm7VoAYEqIwHZ3b596qB7dHs0D2xP42s3g8QBppXU0SnD5+02PCYP4MK88FDRQ3M8vKz0CruziXdTI3ig9WwIen8F7rofmMZS9M/xFfPcNovGFJQ+NfiwJwj3ufng+7NqkwrO3epdRor5/lzT0MkT9I10ThV9Nmzb1SQsPDyctLe2s8i0dg1Wq9IvF6AsjLCyMkydPnlV5Z+qPP9zPpXnmmWd45plnDLepeBcqJiYGq9X7RzwszP0jWPF4S9ONjqtVq1Y+aa1btwaMAzchxOn5SzeVXnEKn/+h0zIMhrVXWPWnzu1faKQXup8jdsNSjUVDVPaUPE5rVAeF2OCqDzD/v74W+rUw8dUBFx2iVW7qqKIqsHK3i9+PaVzewkS/VqeeqCMuTGXrw2F8tNlOTpHOzV0t7DnqYl+aizaxKmnpLiKCVQZeFEB+gc63GwuxmhUG9AokLNg7wIltZOGlfzTlx5/zcTp1+vQOJirSfSmQeGkoTRKsbN2YT2iYCbOqk53hpElCACdSigiwqWz5NpNDu93dG1UFeg5sxOXDGnNoex4hEWa+f+8QLhcouoaptAXLZKJxh2Ba9wxH0XSCo6x0GBBL5oE8Un/PplH7UOK7hrNjaQppv2UR0yGUC0a0IPtALruXHEJ3abQb2pzG3aP447PD2POctLy+KXqxi5RVR7DF2AiKtZG1JZOgNsF898W3BGw3065TG05+d5yiw+4ul2qAibibWpD56SG0AncQaI4KIKp3FCe/OIwrp7wLqIJOYMsQIi5vTNSotoRf15x9135K3rdHytZH3tYRW9sIVDOgQ/CVzXAdycW+N5vga1sQ0L0R+Yt3U7B8H2pkAKG3d8PaozEFS3dT9MkulDArweO7E9DHu+t9yBtDsN7UmeKFW8CpYR1xAWp0IK5vD6B2isVyY2cUk4q6LQ7np9tQ48Iwj+gOWQW4Fm2CADPqNR1xXP9GeaYBFtRJl6JO7oeyMxV9dxrKNZ1RLm6NvmYnrNsD3RPghu6+b8D4SPjx73DpX+FwuruV0WqGWy+HHq0gtwgu7QBXekzycUEL2PWGe3yZqsCNF8PqbXA0y/3vTtU73EA0BDJZhxEJxIRfqmrcYFradK4YTFNcyuXy/zwVk8n4wsNfem3PJ1Na3tSpU+nUqZPhNo0aeXe78HeuKltndFxG5/R0zrcQ4tS6xyp0jy3/HG0+ppPu8QzeXDu8skHnyxGnDo5O18XNVC5u5v0dMLSTmaHGXy1+hQeq3HlpeXNdm0ZmMLhmDgqAW64O8V3hITTExHVXhxmua9IsgCbNAnxXJIayeU1WWRAG7onzVs5J5dH/dKJVtzA+e+0AeZlO91T2mvf3W+rufAbc3ZrmXcvLDY6KonliVNlyzwmtvY8lOoAmvWK80jqM9t6m893l+cVdEY/D4cCe6sTe3UnIiWCOHS5/CLFm18j68mhZEAbgzCwm9/tU7znzSxT9mU/sh10J7R1Lwabj5H97xKsrYtbiA1xwdCLmCIPzVSJkdGdCRnf2Sgse2YngkZW/AawD2mAd0MYrzdKnpdeyqWNjTB3Le1AQZMX8wFXu45qxAvZ7PES72Im2Nx1zl6bQpan3hCb9O0H/U7whl/7iDsJK2Z2w7TDMmeZ/n7hIuG9w+fK46p94SzQcMmuiMQnERJWVtuzk5OT4rDty5EhtV+eM+QtsWrRwdxGx2Wz07l2xi0jNOnDggE9aaQudUQulEKLq9mb73gzZmyWjFvxJT/V9IHDWcTsup47JrJB5pHw8ndG3a1ZKoVcgVtMK9uf6pLlO+j7HSsv3/7Tvwj0nCe0dS/Fe3x4MeqETR0pepYFYXdH3Hj+ttNO296hv2h6DNCHEGZExYqLKgoODiY6OZv369V6tOykpKaxevbruKnaagoKCyM3N9WmZ6tOnD1FRUbz//vtkZ2f77FdUVER+fr5PenX44osvOHbsWNmyw+Fg4cKFmEwm+vXrVyNlCnG+uraFb7hwTUu5a+tPu+6hPmltuoZgMrvPWeuLyseL+YynUqHFheHUpuir4nzSbG0rHoOCtUXFFsSSXghmhfCr3F3LQ/o3Qakwjs3SPARbp8jqqm61Uq/tbJB2hs2wnq7tcXppQvihl8wtWvHvfCeBmDgrI0eO5MCBA9x7770sXryYt99+m4kTJ9KmTZtT71zHunTpQl5eHi+++CL/+9//WLVqFYWFhdhsNmbOnEl2djbDhg3jn//8J8uWLWP+/Pk89dRTXH/99ezcubNG6pSQkMCECRN45513WLhwIXfccQc7duxg4sSJMuhWiGo2trPC/RcpBJjcLTg3tFJ4vp/8LPrTslMwgybGExDkPkfN2wUxfFr5WJ9LhsXT7eoYFJOCZlaxBru7eAZFWBj0cDvC42yG+daU+JEtaDW1I2qAu76NrmnChSsHED3Q3btADVBJeKAzF3x2LcHdSrpIqu7J6q2xgbR77woCmronO7HEBdNiwbWYG7snoAhoF06rRQNRTPXz/aKO643p3ishwAyKgjroAsz/uKnqGQ7pBY8Pd/d9BbjyAnjjL9VSVyHOZ9I1UZyV8ePHk5eXx+eff87GjRtp1aoVTzzxBDt37mTHjh2nzqAOjRkzhsOHD7Nq1So+/vhjdF1n+fLlBAYG0qdPH9577z3ee+89vvjiC7KysggLC6NZs2bceuuttGvXrkbqdMstt5Cfn89HH31EWloacXFxTJ8+XR7oLEQNUBSFV6808XRfnWIXRAfK3dlT6XdTLH1uiKGowEVohMVrncmicuPDbbnunpaggy3ETF6GncAwMyZL7QcsiqLQ+flE2j/RHa3IhTXGHQhe+L+rsacXodpMmEPcx9DztyTsqQWYowJwZhZjjrGhVqhz5Ii2RNzUCueJQszxwfV63K6iqpj/ORLTM0PB7kSJrnzc4Gl5egw8Ngzyi6BR7bZuioZPOn0bU/TanglBCOFjw4YNTJ48mRkzZjBkyJC6ro4QQjRIDoeDuXPnAjBx4kSvR7AIIerOTuVVw/RO+gO1XJP6pX62qQshhBBCCCHEOUy6JooGIysrq9Jp8QGcTqfXw5ON2Gw2QkKqoZuGEEIIIYQ4JZmYw5gEYqLBGDduHKmpqZVu07NnTzZt2lTpNoMHDyY5ObkaayaEEEIIIcSZkUBMNBhPP/00xcW+z7HxFBYWZvhcM08VH8ZcHyQmJrJhw4a6roYQQgghRLWTCSmMSSAmGowePXrUdRWEEEIIIcQZkq6JxmSyDiGEEEIIIYSoZdIiJoQQQgghhKgx0iJmTFrEhBBCCCGEEKKWSYuYEEIIIYQQosbIZB3GJBATQgghhBBC1BjpmmhMuiYKIYQQQgghRC2TFjEhhBBCCCFEjZEWMWPSIiaEEEIIIYQQtUxaxIQQQgghhBA1RibrMCaBmBBCCCGEEKLGSNdEY9I1UQghhBBCCCFqmbSICSGEEKJByfsjl82PbyJjQzoRXSLp8dSFRFwQ6bPd8V05fP/PPaTvyyW+awRXTO9AeNOgMypr0+YClizJIiPTyYUXBnHbrdEEBVXtPvanO508+a2DI7k6N3Y08epAK2E2aSkQ5wN5nxuRQEwIIYQQDYau6awd+z15+3MBOPHjcb4ftZpB64d4XdU4ilx8ct8mCrMdAPz5QzrLjxQy9sM+KMrpXRQePWrnn68fw+VyL69dm4e9WGfa1Ngzrvf24xrDPrLj0tzLcza5KHLa+e/wgDPOS4iGRromGpOuiUIIIYRoMLK3Z5cFYaWK04s5/uNxr7QjG7PKgrBSmX/mk74v77TLWr+hoCwIK0/Lx+U686kHlmx3lQVhpT7e7kLXZRoDIc5X0iImhBBCiFrlzCgkd9EedJdO2Ih2mBsHn/a+1nCLu5dThfglILK8ZUnPMXHkp3QUpwvdpEJpC5gCtjDLKctwOXW2rM/jyL4CVE1DU8vvWwcHq6hVuI0dbdAjMtKG39a5bw5qrE+Di+PhqgS5by4aNrndYEwCMSGEEELUGvu+bP689ENcJwoBOPHEj7T4fiS2rjGntX9wQghh7cLI2ZNTlmZrbCOqZzQOhwM9xYq2IpqdroMoFjO6R6AT3TqE0Ma2SvN3OXVeffow+3e56xcEFJtNOEwmALpeEHjaXRs9JXU28eAXDuweLWzXtzMZbjvlKxdv/1Z+6XpPD503rzbeVgjRcMktFiGEEELUmowXN5QFYQBadjEZf//ltPcvPFZIboWuiUXHiji5M9ud3y+h4FLQFAXN7B28ZP2ZT35GcaX5/7YxrywIA3fjm9XpgpIuhLt2F512XT19sVfzCsIAVv+p+Wy3P1tn9m/e7Qf/2qLzR7a0KYiGS0cx/DvfSSAmhBBCnM90vSzI8F2lG/67su1Ota/jzxyfbe0GaaX7VMy78GgBusEYrfzD+e5/5JQEXwatVppLJ+94kd86A2Qct/ukeV4sZWW5cDh8A6iKeVbM/89s330On9RxVRg4djBH9+nGpQOHchGiwdL9/J3vpGuiEPXAnXfeSWpqKitWrKjrqgghzhe/H4RJ/4Jf9rqDlrBgeHIEPDgEff4P6I8vgaPZaO0aox3NB4cLdcKlqK/dgmJ1Xz64NqVQOGUprl8Po17YlMC3bsKZVkDeQ1/iOpCF+fIWOE1WitccwtQinMgXriL4+hbkf3nQqyrBA1uW/duZXcy+u9aRsfRPFIsJh13HGWDGVXL3XAs0garjOVDLFGiiyKGz7PrvMKdr6KoT3WICq9k7IFPgv/f8RnDjQDIyXQRFWOg3rhk9BzVmz295fDLnKKmH7WApH0fmUFWKzabyfMwwYsoRLupmY+r4KCLDTWw+6OCxRflsPeykQ1MzjiATPx1y0SJS5YVBNoZ3t3JDOxNPrXZ6HXdYkIr57w46xUC3OJX//QlODayqgt0jPgsPgN7xZ/FaCyHqJQnEhBBCiPONywVD/wF/lsw0qOtwMg+mz0M3m9HvX1TWSqbsSkVFQcOCNmsNNArFNHMousNF/pC56EfdrVna5iPkD5pDUY4CJS1WBd8fQS9pT3L9kU36qGUEPn6FT3VUa3lQtX/qj6Qv+sNdLacTTVFxFHvcPy/WsAap2D2e5aWpCqsf2ojm0FBQUDQdk92Fo8IEGboOLrtGTkoBislEXiZ8/tofhDSyMvfVI9iL9fINFQWXolDkGYQBDidoZlj/WxH/nJPJo1NjGP/vHNJz3fv+eEzDXlK1PzI1Rv23gF1NTVhMivccIyaV7GJ3vjvTYWe6BmbFXZZZ9yrTpIAqvbhEA6ZJN0RD0jVRCCGEON/89md5EFbRe2sMuiqWB0Lap1sAcK0/XBaElckqRHU5PfaocJnh0sn9cLdPkXkr/ij7d8Yn3q1lTsX3UsVs965fsV1Dq9BdUDerPt0TFUApOTZVK99+w8oTZUGYSy3fz6kqPnmYdMrOz+btRfy8114WhGmAvcKUii4NVu5wsHyX07srltGEH3ppJb3XZRbBz0d9NxdCNGzSIiZEHSooKCAoyGBOYyHE+auwGP77PexNhWt7wIBu5es+3whrtkPn5jD6MrBWMhX79kPw0Q8QGgjjroDGEeXrQgLdF/tG46SaRMKmNKA09KoQMMSF4/xgI67V+3CHHorXNqXhjTum0DzycG9jbhJM8e5srywdJwo5fN9aAlqFYY0LpMhjMg5F132qoFWIzZQKw690BTSDQEcHdMU9kYfLbELHvV12lhPVpaGpCiZNw6W4p6xXDU6PZ1JYqEqzqPIJQRTA5tIoqhDA/XhYw1k6Fq80XdMwnAffz8CZJiHl//5sv8b3KTpdYhQGtoQPd0Navs5NbVUujvc+7lV/aHx7SKdjlMLoTgo2s7RMiNonE3MYk0BM1LkVK1Ywc+ZMZs2axfbt21m2bBnHjx8nPj6e22+/ncGDBwNw9OhRhg4dyqRJk7jrrru88pg9ezb/+c9/WL58OU2aNAEgOTmZlStX8vXXX/Paa6+xdu1aHA4HvXr14rHHHiMmJoalS5eycOFCjh49SlxcHNOmTePKK6+skeMcMmQI8fHxPPjgg7z55pv8/vvvhIeHs3z58rJtjh07xquvvsovv/yCw+GgR48ePPTQQ7Ro0aJG6iSEqGecLrjySfe4LYAXPoFnxsDfhsPD8+HFT8q3nb8avk42bln5YhMM+Yc7P4CXl8OGF6BZDOQXQdLzxkGYqqI/MAi+3Itud+HZccYdVKk4jxWhjZlfkmbyavVyh2UKGqBjKumK55FHkJmwu7qR/92RsjQdyN+fQ+7rW915hHpPL2/RXTj18lYqHXBavAOYkGgLDtWMI9+Jpiq4rCYURUFxudBN5YGSpqq4TCacFvfYMafJhMtk4siBIrC4uyCqgM3lxKGr6Jh9niPmVMqDrK4dAmgbZyYhWuVQhrvzlUXXKSptxVMAs8rH20peB7NHvTXdfcZUj21LX0rdu2ti63BoG+le/r/VLl7eUPra6QSaobBk6Nlzv7iYd73KuC7uPJ9c5+Lpn8u3nbMN1owyoVZh+n0hzoZMzGFMuiaKeuPNN99k1apVJCUlMW3aNBRFITk5mS1btpxVvtOmTSM/P5/Jkydz8803s27dOqZPn878+fNZsGABgwcPZurUqbhcLh599FFSUlKq54AMHDt2jLvvvpv4+Hjuu+8+Ro4cWbausLCQO++8E4vFwj333MOIESPYuHEj06dPx+VyVZKrEOKc8dnG8iCs1HNL4UgGvLbSO/3b392tY0ae+rg8CAM4lg1vfeH+90c/wPbDFXYoiQI0HeWVleh2JxWboUrHN2lb3H3kjLoeli7pqOgoPuNC9AInubM2++Rr9rhMc+R6f9+ZALOueW1vLXJhLnahlnRHzEu348h3RyOapTxoM9udmIsdoGk4zGZcZjOukjFfOiXdEHG3imkVWqfMmoam+85gaPaYZXLrzmL2pDo5lKGVnZM8k0c+qkrZeTTo5ugOxko2MXmsr7DdgZOwJ1MnvUDn9U0VZpH0mP9DB2b84K5Lrl3nxQ3e2647Al/9KZfEQtQXEoiJesPhcDB//nzGjx/PmDFjmDVrFhaLhUWLFp1Vvt26dePFF19kxIgRPPDAA4wePZrt27ezaNEiFixYwIQJExgzZgwvvfQSLpeLZcuWVdMR+Tpy5Aj3338/f/vb30hKSmLs2LFl67Kzs0lKSuLpp59m+PDh3HfffUyZMoU///yTX3/9tcbqdKYyMzMpLi5/Dk9eXh65ueXdiOx2OxkZGV77pKamVrqclpbmNdWzlCFlnLdlpGXhI68I/VC6e5aIilKzDMtwHc0w3Na3DAX3pYBHc0xqtse6ipQK//bdRkH36IZkMIX8sXyDfMtV7MKkA6rntPAl/zFpYHK6gyLdpBjur+AeC6a6NPSSQKv0Ac+6R8uWbnCoCqAplO3nmV4qN19jz+Fsr7p5PkD6tHpj6bp3kOZnn0PZdjKKwM/M+WVSS07v7kPHKTJ6y5Ssb5CfDynjrMqoS/IcMWMSiIl6Y8SIEVg8pgyOjY0lISGBw4cr3rk9M6NGjfJa7t69OwCDBg3yGp/Vrl07goODz7q8yoSHh5d1taxIVVWfuvbq1QuAQ4cO1VidzlRUVBQBAQFlyyEhIYSGhpYtW61WoqOjvfaJj4+vdDkuLg7F4+JFypAyztsyBl3knnLdU9+OKH06QNcKXZSDbXBdD8MyTMP64GPYJe7/33ix8dikUndcWRITeLec6KX/DbJ4pPhuo5V0TnSHaRVaX8wqwaM7+xSpeVyOqJS3LjlRcZYEiiZNw2UCR5CKK9CEpoAjwN36ZQtQUUrGPimab6SiqwoWux1F08om6VB0vWziDpPm+yw1DQULCkF2R9l2AE6PyTQu6mrjmgujiQ1TSuoOVs/yNd3730bdQSuO1fOYDKRUTCD0a2GlQ5RCF++3j49h7d11SWzbmMTG3utsZri+lXt9g/x8SBlnVYaofyQQE/VG06ZNfdLCw8M5efLkWeVbOmasVOkXmdEXVFhY2FmXV5mmTZui+rkAatSokdeXLriPH6jROgkh6pFmMbDsEfdkHBazOzD78EH3umWPwNXdwGyC7i1hxWMQFWqcz99vhcnXuYO1+Eh4dSIMcd/YoUsCfPAAJMSUbFzSIhMTCm/cARe2KYmv3CO9ykKwwABM919NwJdTUHsloJhVVPcUgmVbaagl97k1FDRUXO5gTFUwd4gi5uMk9BDv7zkd0EzuQMqaEEJgN3e9tLI75u5p3826jmKiLAhSdbCUNg85NHRnafBi0EpXMt+HRXMRZNKIaRqAxaoQFa7QqGkAJhM0aWQiJt6KqoJLUSg2uwNik64T6NEaGWBRMJuhT89A7p0YRYBFYf5d4VzU0oxZhUam8gAPTQeXRogVImz4BFiRge5hY11jFG7rohAdCBEBYFG8t7W73LMvAnxyk4kBCQpmFXrEwqMXK7QMgwATjOmk8NaA8t+Yj4eauK6le9sLYuDTm1QaB0srhKh90iJmTCbrEPWGvwCltKleqdi33kNlY6hMHgO1TyddN7pjWU1sNpvfdf6OH2q2TkKIeuaGi9x/FbWJg6+STy8PmxVm3eX+MzKyr/vPgD7D3T3b/Y1bcvWvKJjz3kQp+Z4y/zod5w9/kH/Zvzy2Lb3YMpWET6XtXC4apT2C2igYgPRrl3iVpwDhidG0+nk0AD8Gzysp2fc73+zUcXpMFKlogK6jFWuYVRdOs8mrm2L5dhpgAk1nzBvdie0YZnxegK9WZLJ0wQmvNJPHjIeaXWfRnGaYPWYf7NbczIoHI8gu1Ih8Isc7FtR0nhpgIcuh8vQa776C2UXgnGFF9XhI2LeHNAYs0rzyyLHDL6k6VyQotI1U+Hqk9+/XP/oZH0vLcIUvhhv/1glRm+Qqxpi0iIkGIyzM/cOZk5Pjs+7IkSM+aUIIIc6c0rqRb2KL6LIgrJTaItLnKcM+XREBJToIJby8FczSJsJnG2vr8LJ/21qHluTlS6uY6NFNsHS6ekXzrUPpuC3VrBDS2P8NMYBGjb0fCaABRR4TcERHm7yCME8hVoVGBi1OraNMtInyveRqGaF4BWEALcMUn2NXFWgVLq0HQtSlXbt2MXr0aOLj47FarWzatAmAmTNn8t1331UpTwnERIMRHBxMdHQ069ev92ohSklJYfXq1XVXMSGEOJfccjH0bl2+bFJRXhjps5naLALrg95NMbY7e2G9pk15gqIQ8uzVKB7j3qIfTsQUVz4+1xRlI+bx3mXLLZ/rhWJRS8aKlX/X21qHEnRxTNmy5zT2tlgbTa9ydzdXnZpXtz5dUdDM7lahyBbBBEVaKz389l2CsFjLp8ovsFpwmM1lAV+H9v4DObNJ4blBNq9JD69qa2ZwZzPXtlWxVmic6tfC9zKsdYTC1Au9g65pFyq0kEBMNGANvWvili1b6NWrF2vWrOGKK67w6omVl5fH22+/XaV8pWuiaFBGjhzJrFmzuPfee+nfvz/p6eksWbKENm3asGPHjrqunhBCNHiKzQpr/wqfboYjWTCoO0rbxobbBr44GMvNF+D6+SCmi5ph7t+GQJeG/fM9OPdlEnBtW8xdYr32sbYKp82uCeQu3ovu1Agd3g5zdGDZ+qhBCVy0ZwSZyw+CVcVVrGOJCqDRsJYoFpU/5+1jy2MbcKlKWYtc0fEi+kxuT/tRCXz10XeojZx0Cu/Fb4tS0Ezl09lnHMgjJ62QsLhA/Nm6IQ+H3R3IOVTVexZEYOvWQnRd99td/vaLA+jTwswXux20jjIxuLMZk6qwZIcTe4Ve9J/vNe5W//oAEyM66KxP07k4TuGyZg3nglWIc9Gjjz5Kt27d+Oqrr7BarXz00Udl6y6++GKWLFlSyd7+SSAmGpTx48eTl5fH559/zsaNG2nVqhVPPPEEO3fulEBMCCGqiWIxw/Bep7Wt+dKWmC9tWb6vSSVgSEcC/O+CKTyAiDsu8Lve1jKUJvcar4+8pBEus29LkjPHQbP+jeFAIQoQ3z6azUsrTN+tgz3PYE53DwX55bMeGk1rX1ikoWngZ5gxAJ0am+jU2HuDrELf7bKL8BvUXd5M4XIJwMQ5oiG1fhn54YcfWLBgAUFBQT7zEjRu3Ji0tLQq5avoMguAEEIIIRoIXddZ1e9/5O4tHy9si7Vxw/ohaKrG3LlzAbhtzDjeH/4LhVn2su2i24Rw638vqXTyp8x0B8n3/4HDoaMpkG+xeD1g+ZJLgpl6d6zf/f3ZeUKj21tFOD1mtx/b3cT7wyoLWYU4N6xW5himX6HfXss1qZqQkBA+/vhjrr/+elwuFxaLhQ0bNtCzZ08+/fRTJkyYQFaWwXMgT0HGiAkhhBCiwVAUhcsX9KPJwKYExATQ+Io4+n10BaYA7xYoc4CJm1/vScLFUQRGWmnTvxFDX+pRaRAGEBVj4e5Hm9KqnY2IMBMXdrLSsoWV8HATV14Zyh0TYyrd359OjVQ+GR1AYhOV+FCFyb3MzBpc+Xg1IUT90K1bN5YtW2a47osvvuCiiwxmuj0N0jVRCD+ysrIqnRYfwOl0YjZX/jGy2WyEhIRUZ9WEEOK8FtwihL7zLj/ldo3ah3LzG2d+gdTxgmA6PhNclapValAHE4M6yHTy4vzT0Lsm3nfffYwZM4bg4GBuu+02AA4dOsS3337LnDlzWLx4cZXylUBMCD/GjRtHampqpdv07NmzbPpSfwYPHkxycnI11kwIIYQQQtSWW265hf3795OcnMzrr78OwLBhwzCbzcycOZMhQ4ZUKV8JxITw4+mnn6a4uLjSbcLCwgyfa+apUSODZ/IIIYQQQpwnzoUJKf76178ybtw4Vq1axbFjx4iJieG6666jRYsWVc5TAjEh/OjRo0ddV0EIIYQQosFr6F0TSzVr1ow77rij2vKTQEwIIYQQQggh/Dh06NApt0lISDjjfCUQE0IIIYQQQtSYht4i1rJly1POuHqqCd6MSCAmhBBCCCGEEH7MmTPHJxBLT09n+fLlpKSk8Pjjj1cpXwnEhBBCCCGEEDVGO/Um9dqECRMM06dPn86IESM4fPhwlfKVBzoLIYQQQgghaoyuKoZ/54IJEybwzjvvVGlfCcSEEEIIIYQQogqcTifZ2dlV2le6JgohhBBCCCFqjH5uNH55cTgcbN26lRkzZtC9e/cq5SGBmBBCCCGEEEL4oaqq31kTIyMjWbVqVZXylUBMCCGEEEIIUWMa+niwJ5980icQs9lstGzZkhtuuIHQ0NAq5SuBmBBCCCGEh+LUArQiF4GtqnZxJYTwpjfwWSmSk5NrJF8JxIQQQgghAM2hsXvC95z4YD/oEHZ5Y7osvRpLjK2uqyaEOAdJICaEEEKIeuPEcQe/bcknMtJM9wuDMZtrr0tT6ts7ObFwf9lyztpj/PHYetr/5/Jaq4MQ5yLd1PC6Jj711FOnva2iKDzxxBNnXIYEYkIIIYSoFzauz2PWm2m4XO7lNm0DeOSvTbFYa6dfU9aXR04rTQhx7juT7ogSiAkhhBCiXkvLcvHeNwWkpLu4rIuV4X0DMXkM4v9oYXpZEAawf18xv/ycx2X9wmqlfs6sYp80rdhlsKUQ4kxoDXCyDk3TarwMCcSEEEIIUePyCjVufTmL49nui5vV2+wcSHPx2Aj3hBi6rnPihNNnv0MHfYOjGmM2aHlz6bVXvhDnqIY+WUdNkUBMCCGEEDXuqy3FZUFYqcU/FPLAjSHYrAqKoqCqUPEmtMsgEMrPdvDF63+w99dsIhoHcOXtzenQN6psvfZ7MAsHfY8j30m765vQ96HOmANMZeuLjhfy2/9t4Pg3RwlKCKHzk92Jv76ZcdDVAO/kCyEaBolPhRBCCOHXpmM629MrbxX6I0vj58Mazkpaj45l+3bzsTtBK9lF13WM9jZ6iOqKF/ezc20mzmKN9EOFLHl6LxkphQBoBwPQvo8g/1gR9jwn2z8+xC9v7PY+pik/kbryMK5CF7m7T/LrhHXk/5GLbhBz6bq0iAlxtnRVMfxrSL7//nuGDx9Oly5daN26tddfmzZtqpSnBGJCCCGE8JGap3PhfCcXve/ignkurl7kIs/uHZRoms6EpXbavFZMn/8U0+a1Yn4/ZjyuQjEMs8Cllafrhrt6JzqKXOxbn+29hUtnz49Z7jz2BfrksPeLo2X/duY5OP5dmtd63aGR+r8jhkEfNKyLRSFE9Vu3bh0DBgzg5MmT7Ny5k44dO9K0aVMOHTqE2WymX79+VcpXAjEhhBBC+HjyB40tx8uXvzmk8/om72Bq6U6N97a4KG00OnRSZ+pKh2F+mp+GpYCSQRKKomAy+a7XNO9AyGRRMYqXCnPd48v0At9LG1dxeTCnBpgMr37sJ+2+/SIBpcJd+/y1Rzie/BMnP9iF7nBP5KE7XBR8uJ2Tyd9TtOagb+ZCnOd0xfivoZgxYwYTJ07kiy++AOCZZ55h7dq1bNq0iby8PJKSkqqUrwRiQlSDxMTEGnvqek3mLYQQ/nx7yDdy+vaQd6Cy5k/fGQV/PGzcImbyc8VRaHf/X9d1rxkTS1V8jpjTrhm2nKmlQZziW2/NWZ6xs8BZsZHNvb9ZQTGqpEcEeeLZXznY72PSZ/7CkTFfcHDgJ2gujRODPiJj9CfkzFzLiSsWcPKptb75CHEea+hdE7dt28bNN99c1mruKvmy6tatG0888cQZPXPMkwRiQgghxHli7u8aAxa5uHGZi9WHKp+a2W4QFOXaKywbTGhoNPEggNOgOAUIDCj5d8lkHT77Ob0DK7NVRTGa3LB0O4Pp2VSPSpmCjFvEdIeGXslkHVqenRPP/OK1quDbw5x86VeKv/rDKz33uR/Rctwnx/V7KvljPiC339sUvbQG3elCzy7A8fAyivu+jOPuD9GPZpfX46Of0a99Hn3QS+j/+82d+P5quDoZhjwLX//mW8eyChXDjA/hsr/CHW/BgTT/2wohTltBQQEhISGoqkpAQADp6ell6zp27MiOHTuqlK/MmihENfjhhx8wGfWpEUKIKnCUBAQW0+nfMba7dFQFzH7uMr+5SWPat+XR0Od/6Pw4WqFXvPH2RjFJxS3Nqu9GDj+P3TKqlw4UO8BqdreIGT22p+JXq8th3CJmKj1XBnXSPOqkFWmGLWKKWTUO0FzujV1ZxVDoe3DFW0/47lPoRMsohNwici+bBaVB2do/0FJOYtpyAH3NXnfajwfQvt2DddvfYNEvcOus8oz+txX9/gEor37qkbYJ1jwNfTtBkd198koj2HH/hCU/u//9wy74YjPseROCbb4HBu6Tb1Z9T7IQ1UxrOI1fhhISEjh27BgAnTt35rPPPuP6668HYM2aNURHR1cpX2kRE6IaBAQEYDbLfQ0hxNlxaTr3f+si/A0Xoa+7mPyVqywo8yffrnPb5y6C/+ki6k0XT6wzjoRm/eYdfTg1eHeb/1ax07lA0A0GefjrbaQZzD6oAOaSAMpfi1jF3RRVMZw/o2w7w6kXyxNVs3EFdV033Ld0jJhi8xOs+BnoogSasX/4W1kQVso++xe0kiCsLIvdx9BW74V/fVOxUjC3QppLg3+uhOuegqDREH8H/PtLOHESlnq32HE0E1Zs8K1cdj4Me8G9f8wEeH6p8bEJUU0aetfEK664gtWrVwMwadIk/vWvfzFgwABuuOEGnnnmGUaPHl2lfCUQE6e0YsUKEhMTWb9+PfPmzePGG2+kT58+JCUlsXLlyrLtjh49SmJiIrNnz/bJY/bs2SQmJnL0aPnMVcnJySQmJpKdnU1ycjIDBgygX79+TJ8+vazJd+nSpQwfPpxLL72UpKQkvvvuuxo5xqeffppLL72U4uLyH8xt27aRmJhIv379cDrLHzK6adMmEhMT+fTT8juURuO4StO2bNnCX/7yF/r27cuAAQN4+umnKSgo8KnD1q1bmTRpUtl2Tz75JFlZWdV/sEKIeuvNzTr/3KRT6IRiF8z+TefF9ZUHYk/8oLFgh45Tc3cdfOZnnf/u8A2wjuX77nsg23/epzNpu/F086ex4xnxzlBR/BRcyrAlzyMPxTiQO3U1/ARwfrcHLeWkb7pRn0+AAjukZPim5xX6pn29Fb7c4g7Ujp+Eu96G3/70jVoBsvJ80x6cC0t/dk9Okp0Pjy6Azzf6OxIhznszZ87k3nvvBWDy5Mm89NJLZGdnc/z4cR5//HGeeeaZKuUrgZg4bW+++SarVq0iKSmJadOmoShKWaBxNqZNm0Z+fj6TJ0/m5ptvZt26dUyfPp358+ezYMECBg8ezNSpU3G5XDz66KOkpKRUzwF56NWrF3a7nd9+K+97v2HDBlRVpaCggG3btpWlr1+/vmyfU9mzZw/Tp0+na9euPPjgg/Tu3ZtPP/2UV1991Wu7bdu2MWXKFPbv38/YsWOZNGkSJ06cYNq0adV0hEKIhuCzA74X0isPVD6Wy3gfg+55p9HV8FQqxiKqwcQYLj/VVQ0CGR1wlIzt8tc1UalQhuavhbB0O8NWtfJ9NLtmHKwpimFznl5y4vQC49kg/Z1EvcBp3DzoZ/pI3aVh2CRoJMsgqv7sDAKplQatZEZpQlSThj5rYkxMDO3bty9bfvDBB9m4cSMbNmwgOTkZi8VSpXwlEBOnzeFwMH/+fMaPH8+YMWOYNWsWFouFRYsWnVW+3bp148UXX2TEiBE88MADjB49mu3bt7No0SIWLFjAhAkTGDNmDC+99BIul4tly5ZV0xGVS0xMBMqDrNJ/X3LJJYSHh3ulb9iwgaZNm9KkSZNT5rt3715ee+017rvvPoYNG8azzz5L3759Wb58uVer2CuvvILT6eTf//43U6ZMYdSoUbz11ls0atSoGo+yemRmZnq1HObl5ZGbm1u2bLfbycjwvqubmppa6XJaWprXhZKUIWWcr2UkhOEj1lJcaRlNg3xbWBqZi3zKMJoQsDSmMTqOigGQ5/alx2E0AYfFVF6mp+yTuT7bKoCt5PolPz/fcKiSR4cEUlNT/U7Wobvg+PHjKIYzKrp3yMvLI9+Zb3j1ozk0w4Fxesl5UEOtvjsB9iKDGUsAJdRiPEOJnysvxWKCHi18Vxhc4OlW367weU3CISjAd/928UCF16OF729LQUxwvf98SBlnV4aoujfffLNGeilJICZO24gRI7wi/tjYWBISEjh8+PBZ5Ttq1Civ5e7duwMwaNAggoKCytLbtWtHcHDwWZdnJCYmhlatWvHrr78C7qDzt99+o3fv3mXdMgGKiorYtm3babWGAXTt2pWuXbt6pfXq1QuXy1XWTTMzM5OtW7dy2WWX0bZt27LtVFVlwoQJ1XB01SsqKoqAgPIf+5CQEEJDQ8uWrVarz6DV+Pj4Spfj4uK8HqQqZUgZ52sZD/dSifZ4HnF4ADx1RVClZTx1uZVAj+vypiHwSN/y787SMozm/Qiz+j8Oo/FfpXmUHofFIHAq7XlX8VxFhIf4bKtTPn19cHCw4fT1Fkt5PeLj43EU+5msw6wQGxtreJddK2mmCwkJIcgUZDx9vVUFg+NRSzJ0nTQOuKzBvg+QBtBP2lFCfIM3RXMZN6I5NXj8Rgj1mFgjNgzCffNXOjb1bj27sBUhUwfDjJHeG17bAwZ0Ayq8Hk+PBovHm6ZtPEH33VjvPx9SxtmVUZd0RTH8ayjuvfdemjRpwi233MKqVau8guazIbMLiNPWtGlTn7Tw8HDS0s5uetyKLUulXzRGXyBhYWGcPGnQ574aJCYmsnTpUvLy8tizZw9FRUX06tWLgIAAXn75ZYqKitiyZQsOh+O0AzF/5wwoO44jR44A0KpVK59tW7duXdXDEUI0QO2jFHZONPHhLh1Nh1s6KsQFV36xclkzhV23m/h4t06wBUZ1VIiw+e5zVYLCB7u8Lx4GtPB/P/Z0etUZzZBo8ZOly2DaNEWBoIDyyTpMJnyCMZfR9PWK73CoskeFGURing9lNgeZ3U1xFfbXnRoYDd8qiT4tzUMxNwvBmeI95ip0RHuy3t/svUuTEEwtwtH7t6b4We+xzeqFzeHAYTjpMfbLrKL2aoHSNAJ91wvu2RMtJhh1Ccr/zYN5FcZHj7sCBl7onoijaRSMuBRsVnj4ZujfxT2GrGNTuPFi47FtA3vCjn+6x4lFh8ItfSHEOKAUojo09FkTd+7cyZw5c/jvf//L4sWLiY+PZ/z48UyYMIF27dpVOV9pEROnTfXTd730roBSyZ0Nl9FtzhL+pn33l15ddyEqKm2p2rhxI+vXryciIoJ27dqRmJiIw+Fgy5YtZS1jpV0ZT6WyKe0rHofR+avsnAohzk2NghSm9VS57yL1lEFYqYQwhem9VCb3UA2DMIAX+qt08+iRltROYVI3//mfzpgyo2eGGfXGA+PhT7oOxY7yMWJGPxUVuyG6nLrhnBSVPdBZ9zgYrdhlPMOGScWw2bDkeBSTStP3rsMU4w5YFKuJ2GcvJWRIW8Kfvwqs7gqo0YFEzRuCYlaxXNse6319y55mrTQPJ/Dd4Vjmji1v6Qq0YH5jJErTCPc2TSJR7h+Ics81KNGh8Oyt0NPjptyQRLjneuiSAI8mwW1XuIOwUr3bw9+Gw7A+YK5kWvq28e7A7Y6rJQgT4hQ6dOjA888/z6FDh1ixYgWXXnopr7zyCh07duTyyy9n7ty5VcpXWsREtQkLcw9uyMnJ8VlX2upTnyUmJqKqKuvXr2fXrl306tULRVFo2bIlsbGx/Prrr2zYsIHWrVtX+XkRRpo1awbAgQMHfNbt37+/2soRQpzfmoUq/DbezG/HdUKs0Cai8iDPqEWs4r0h3aCTndFYNPfGxjfRPAM0o5auikX4vT9VyZwmni1ifufX1/3U0WPz4Kua0y7lDop/S8fSKgxzI3cX0LCH+xB8e3ecB7KwdmuMYiu/vAp6bSi2h69AO5qDqUc8itkEFzZFvbYT+rajKO0bo0QGVSy1XHwUbHwJtv7pHgPWtv50NxPidDWkqeoro6oqN9xwAzfccAPZ2dksXLiQ5557jkmTJjFx4sQzz68G6ijOU8HBwURHR7N+/Xqv1p6UlJSyZy/UZ2FhYbRr144ffviB7du3e3U/TExMZM2aNezevZuLL764WsuNjIykW7durFu3jn379pWla5rGvHnzqrUsIYToHqucMggDaBXum9Yhynu/NpG++UT5aVzxM1kgptLndPmbHr5CgKWolU+Rr0T4NquFNC4fd6WY/Exfr+uGwVzFaqsBZgIvjisLwkqZYoIIuLipVxBWtk+TMMyJzdxBWGk9ggNQe7eqPAjz1K2lBGFC1BM5OTksWrSI999/n5SUFGw2Pw9NPwUJxES1GjlyJAcOHODee+9l8eLFvP3220ycOJE2bdrUddVOS69evTh8+DAOh8Mr4OrVqxcHDx7E5XKddrfEM/Hggw9iNpu58847efvtt/nwww+55557OHHiRLWXJYQQp+PBRNUrXrGa4J4e3pcN4y80+wReD15q3NnGbNTtDyjy6Jpo2OWwYtdEh/F2Skn+apd8MHtHVN1vK+/a569roqIqxldF/iJIIcRpa+jT15f65ptvGDt2LPHx8UyePBlwPyu3qjNUStdEUa3Gjx9PXl4en3/+ORs3bqRVq1Y88cQT7Ny5kx07dtR19U6pV69eLFiwgLi4uLIug6Xp4B7zddFFF1V7uRdccAGzZs3ijTfe4P3338dms9G3b1+effZZrrnmmmovTwghTuWmdipfjYC523RsZpjSXeWiOO8rp6ZhCr/eFcA/f3KSlgfDu6iMvMD40qJ9E9/0mDCVEFvlk3U4KyxbAlRCYizkpXs/1yuudbA7n0gnpuEnaO+4CEe+RvsbmtCyf+Oy7czBZgIa2yg+5j3Ff3jXSIqWH/Spo+K3r6UQ4nQ1pBkSjcyYMYP33nuPw4cP07hxY6ZOncrEiRPp2LHjWeWr6DU184EQQgghRAmXpjP17ZOs2+Ger96kwjO3hTG4l7tLj67r3H6b77jY6wdHMHJUjFfajjUZLHt2b1m3xVY9wxn9bEdcmrNs0PzEiRP9PmT18OI/2TTlJ/SS54bFXhVPn4/6s3XA/zi5xnsmYEsjG32O31r1AxdC8N+Ejw3Tbz00opZrUjUBAQEMHjyYiRMncv3111c6GduZkBYxIYQQQtQ4k6rwrynh/LTLTkq6Rp9OVprHeIyZUhQ6dgpk185Cr/0u6Oo7hqpz/2iadAhm/4aTRDQOoPVF4SiqgquSCTs8NR/ekqjEGI5/l0pQQjCxV8ajqEpZYOZFGsSEOGsNffr6I0eOEBMTc+oNz5AEYqLBysrKqnRafACn04nZXPnb3GazERLi+6BRIYQQ1UtRFC7tFOB3/YQ7GvHmP9NIOWzHYlG4flAEnbsYT2YREWfjosFVGyAPENwyhFYTvZ//E9A82Gc7S5T/+gohzg81EYSBBGKiARs3btwpB0f27NmTTZs2VbrN4MGDSU5OrsaaCSGEqIrGcVae/kcCx487CAlRCQqqnu4/p13+uHac+MD7USKNJ7av1ToIcS5q6GPEaooEYqLBevrppykuLq50m7CwMMPnmnlq1KhRpeuFEELUrthY47FdNS1qYDM6vN+fI69uw5XvpPGEdjSb3rVO6iLEuaQhzpBYGyQQEw1Wjx496roKQgghzjGNx7al8di2dV0NIcR5QAIxIYQQQgghRI3RpGuiIZkLSAghhBBCCCFOQ2FhIUeOHMHpdJ51XhKICSGEEEIIIWqMrhj/NSTfffcdffr0ITQ0lBYtWrB161YA7rnnHpYuXVqlPCUQE0IIIYQQQtQYXVEM/xqKb7/9lmuvvZaioiL+7//+D00rf2hhTEwM8+bNq1K+EogJIYQQQgghhB9PPvkkN9xwA5s3b+aZZ57xWte9e3e2bNlSpXxlsg4hhBBCCCFEjWlIrV9GNm/ezMcffwy4H0zvqVGjRhw/frxK+UqLmBBCCCGEEEL4YTabcTgchuuOHz9OaGholfKVQEwIIYQQQghRYxr6ZB29evXi/fffN1y3ePFi+vTpU6V8pWuiEEIIIRqsvD9y2ffOXoozioi7oUldV0cIYUBXG1DUZeDRRx/luuuu4+abb2bcuHEoisIvv/zCnDlzWLx4Md99912V8pVATAghhBANUkFKPl9d+QWuQhcAh5cdImCgheK+xl2IhBCiKq6++mree+897r//fj799FPAPW19REQE8+bN47LLLqtSvhKICSGEEKJB2vbS72VBWKnAb2wSiAlRzzTkyTpcLhf79+9n8ODBDBs2jB9//JFjx44RExND3759CQ4OrnLeEogJIYQQokE6sdZ3pjJFYjAhRDXSdZ3OnTuzYsUKrr/+egYMGFBteUsgJoQQQogGyVXorOsqCCFOQ0MeI2Y2m4mLi/N6iHN1kVkThRBCCNEw6dWbnf2XFHIe+pK859fhOp5XvZkLcT5TFOO/BmLUqFHMnz+/2vOVFjEhhBBCnPcK/ruVk7ctLQvu8l76kUbb7sbUOKRuKyaEqHM9evTgo48+4qqrriIpKYn4+HifBzsnJSWdcb4SiAkhhBDivJcz7XOvFjY9vYC8v39P+Os3nFlGx7Phy98gPhKu6tqg7voLUVMactdEgHHjxgFw5MgRVq9e7bNeURRcLpdP+qlIICaEEEKIWlFQqPHNNzkcTrHTob2N/v1CMZvrxwWanlXkk1a0cs+ZBWJfbYHBz4K9ZOxa347w7UywWqqnkkKIOlHV54SdigRiQgghhPDy4S6NmT9oZBbD2E4Kz16uEnCWAZOm6cx86ihHjrinNfzxx3y2bi3kgfsbVz3TGo7htJziM9vh1tfKgzCAH3bBO1/D3ddXa72EaGga8vT1AP3796+RfGWyDiGqWWJiIsnJyXVdDSGEqJK1KRqjV2rsyoLjBfDKRp17vj7zLjcVbf29sCwIK7VxUwEZmVWf+VDXq3m2jgrO+NLxRI5v2vzV1VATIRo2XVEN/8530iImhBBCiDIz1vlO0Tx/B7wz8Ozy3fJbgWH6HweKiI46hyfESMuu6xoIIc7SVVddVel6RVH45ptvzjhfCcSEEEIIUWZHpm+aoxoen1NcZNyqpp1Fo5ZSw30T9WqZH79mW+2EaAga+mQdmqb5zJKYnp7O7t27iY2NpX379lXKVwIxIc5AQUEBQUFBdV0NIYSoMfaz74Xoh/GFWE13Lzwr51Mc9u3v8OUWaBMHt/aDoIC6rpEQ9YbRTIkAe/bs4cYbb2TGjBlVylc6ZzZAK1asIDExkfXr1zNv3jxuvPFG+vTpQ1JSEitXrizb7ujRoyQmJjJ79myfPGbPnk1iYiJHjx4tS0tOTiYxMZHs7GySk5MZMGAA/fr1Y/r06aSnpwOwdOlShg8fzqWXXkpSUlKNzSJTateuXTzyyCNce+219OnTh0GDBvHXv/6VlJQUr+2WL1/ObbfdRt++fenXrx933XUXP//8s2Ge33//PX/5y1/o168fl112GePGjeOLL77w2e7OO+9kyJAhpKSk8PDDD3PVVVfRr1+/svVbt25l0qRJ9O3blwEDBvDkk0+SlZV1xsfocDi45ppruP322w3XL1iwgMTERL/HI4QQ1aqmAocaGKxf0zFOxTvg56znlsKAGfD8MrhzFlzxBDiqPnZPiIp0RTH8a+jat2/PQw89xMMPP1yl/aVFrAF78803sdvtJCUlYbFYWLJkCcnJyTRr1owePXpUOd9p06YRFxfH5MmTSUlJ4cMPP2T69OkMGDCATz75hKFDh2K1Wvnoo4949NFHWbJkCc2aNau+Ayuxdu1aHn74YYKCghg6dCjNmzcnIyODn376iX379pWV+dZbbzF37lw6derElClTKC4uZvny5UybNo2nnnqK668vn61q6dKlPPvssyQkJDBhwgQsFgv/+9//ePzxxzl69KhPMFRQUMBdd91F9+7dufvuu8nMdPfZ2bZtG1OmTCEgIICxY8cSGRnJmjVrmDZt2hkfp8ViYfDgwbz//vv8+eeftGzZ0mv98uXLadKkCb179z7jvIUQ4kzV1LWRrhn3bzyb8mr8Mq46CqjvF5tFdnh2iXfa+n2wcgPcfEnd1Emce+r5x+BstGzZkm3btlVpX2kRa8AcDgfz589n/PjxjBkzhlmzZmGxWFi0aNFZ5dutWzdefPFFRowYwQMPPMDo0aPZvn07ixYtYsGCBUyYMIExY8bw0ksv4XK5WLZsWTUdUbmioiJmzpxJSEgIH330Effddx9JSUlMmjSJOXPmlLVMHTx4kHnz5nHBBRfw7rvvMnbsWO644w7ee+89oqKiePHFFyksLAQgNzeXV199lSZNmjB//nxuv/12brvtNubMmUO7du2YPXs2aWlpXvU4efIkQ4cO5dlnn2X48OHceeedALzyyis4nU7+/e9/M2XKFEaNGsVbb71Fo0aNqnS8N998MwCffPKJV/q2bds4cOAAQ4cOrTd3ZjMzMykuLp/SOS8vj9zc3LJlu91ORkaG1z6pqamVLqelpXl1T5IypAwpo+7KMG5l0s+6jKJi3+d0Aeha1Y/D6aq81aYq58qrbvqZvx4VaZqrfr/m+cWQW+hT76I/0xrce1fKqLwMUTOWLFlCkyZNqrSvtIg1YCNGjMBiKX9IZGxsLAkJCRw+fPis8h01apTXcvfu3VmwYAGDBg3yGh/Vrl07goODz7o8Iz/99BPZ2dlMnTqVmJgYn/Wq6r6HsGbNGnRdZ9y4cVit1rL1ERERjBgxgrfffpsNGzZw+eWX88svv1BYWMhdd91FSEj5DF02m42xY8cyY8YM1qxZwy233OJV1q233uq1nJmZydatW+nfvz9t27b1qtOECRNYu3btGR9vQkICF110EZ999hlTp07FbHZ/ND/99FNUVWXIkCFnnGdNiYqK8lr2PJcAVquV6Ohor7T4+PhKl+Pi4qQMKUPKqEdl+FIIDQ09qzICbTbAd+ZERXFffFblOMwmM3bsfmtdlXNV0Zm+HhWpqlq/X/PoULi8M6zd4ZGhGduwvtjO8jU/Vz8fDbWMutTQuyEaDR8pLi5m69at7NixgxdeeKFK+Uog1oA1bdrUJy08PNynVedMVYzqS398jT7QYWFhnDx58qzKM3Lo0CHAHexV5siRIwC0bt3aZ11pkFS6Tem4sjZt2pxy21KRkZE+X36l27Rq1conH6N6nK6kpCT+9re/8f3333PVVVdRWFjIl19+SZ8+fWjc+CweeCqEEPWCnwuxs3iWUIMYI9YQJuv44AGYPBtWbYG2cfDCOEioWg8PIYw09FkTv/32W5/vA5vNRsuWLXns/9u77+goqreB49/Zll5IAiQQekdEOoh0EZGmVAGVjoIUu2Il4Kv+BAQLiihNmop0EFSQoiJKF6QjHRIgJKQnW2beP5Ys2ewmJJBCwvM5Zw/snTv33plsNvPMLfP66/Tv3/+WypVArAhL7xXKLL1rO7s/IDZb1sti6fX6XKXnx4pXOS0zu3y5aVdWeT09PbPcx935vZ0/2u3atSMwMJCVK1fSrl07Nm7cSFJSEo899tgtlymEEHc67TaWxs/vSzvtdhp3o5DbLyO/lQ2GNW8UdiuEuGOdPn06X8qVOWLFmL+/PwDx8fEu2zL3/Nxp0hesOHbsWLb50hfsOHnypMu2//77zylP+r/p6Rml75+TRUdyUuetSF+046+//uLSpUusWrWK4OBgWrZsectlCiFEbpVy84SOvAh4Aku4v/fr5XMblyL5HonlQRlFvCdAiLxQ1FdNnD9/fpbzSWNiYpg/f/4tlSuBWDHm4+NDcHAwO3fudOrxOX/+fJbPQ7hTNGvWjMDAQBYvXuxYOj+j9ONp06YNiqKwcOFCLBaLY3tcXBxLly7F39+fhg0bAtC0aVO8vLz44YcfSExMdORNS0tj4cKF6PV6p+Xps1KiRAnq1q3LH3/8wYkTJxzpqqoyb968Wz1kwL5oh6qqTJ8+nX379tG5c2fHfDEhhCgI/Wu5XhxVK3H75TZv5uOSptNB1cpZjzy4KS2fL+Ty4kLRw3TzPEKIO9rgwYOzvNl+6tQpBg8efEvlyhVeMdenTx9mzJjB2LFjad26NdHR0SxbtowqVapw6NChmxdQSDw9PXn77bd57bXXePzxx3n00UcpV64csbGx/PXXX/Tv3582bdo4lqGfO3cuQ4cOpUOHDpjNZlatWsXVq1eZMGECXl5egH2u2/PPP88HH3zAgAED6NatGwaDgXXr1nHs2DGeffbZHExYt3vxxRd55plnePrpp+nTpw+BgYFs3brVaUWjW1GhQgUaNmzI+vXrAXj00UdvqzwhhMitlxvrWHXCxp7L9ve+RljQyf3Q9NwoV86D9g/6sfHXG9+TT/QPwtv7duaI5cHQwWzkOgzTKaBm6kZ7oEZeNUeIIqso9X65k910l9TU1Cyn79yMBGLF3MCBA0lMTGTdunXs3r2bSpUq8fbbb3P48OE7OhADaN26NbNmzWLu3LmsWrWK5ORkgoKCqFevntNqhaNGjSI8PJwffviBGTNmoNPpqFWrFuPGjeP+++93KrNnz56EhIQwf/58Zs2ahaZpVKlShf/7v/+jY8eOOW5bnTp1mDFjBp999hkLFizA09OTBx54gPfff5+HHnroto67e/fu7N69mwYNGlChQoXbKksIIXLL26iw8yk9m89qXE2BjpUU/D3y5iJq0MAQ2rX159x5M9WqeVCqpPHmO2Unny/uFGMuL64GtoG5m2+8N+jhrd552iYhiqKiGIidPXvWaW7Y3r17SU11fgxHSkoKX331FeXLl7+lOhQtP1ZaEELcso0bNzJu3DgmTJhA586dC7s5Qghxx1pVazmWGOfl6zU0Yt9NYPDgwU6PeLmZSH0EmTvYjK0qELI1F0OOLFb433L44U/7Ahjv9IH7pUdMiKnNN7lNf/HPdgXckpybMGECEyZMyHYhtvQw6pNPPmHMmDG5rkN6xIS4wyxZsoSAgAAefPDBwm6KEELc0fLyHrtH1xqkrTrqlOb7Zi4XSzIa4O0+9pcQwqEo9oj16dOHOnXqoGkaffr04f3333d5rJKHhwd16tRxLDKXWxKIiTwTGxub7bL4AFar9aaLT3h6ero8u6uoysk58fb2JjU1lR07drBv3z727NnDqFGjsl06XwghBHk6NDHwm+5ce3o1acsOowR44jehDZ4dqt50PyFE8VSrVi1q1aoFwNy5c+nSpctNHwCfWxKIiTwzYMAAIiMjs83ToEED9uzZk22eLl26EBERkYctKzw5OSfDhw+nYcOGvPXWW/j5+dGzZ0+eeuqpAmqhEEIIAF2AJ0Hf90HTtLx5kLMQwqEo9ohlNHDgwHwpVwIxkWfeffdd0tLSss3j7+/v9rlmGZUsWTIvm1WocnJOypYtS3h4OLt27SqgVgkhRPHgEWzCfDX779jckiBMiLxX1AMxsD8vbPHixRw+fJiUlBSnbYqiMHv27FyXKYGYyDP16tUr7CbcceScCCFE/infoyIH/3fAKU0NkDXIhBB56+zZszRu3Jjk5GSSk5MJCQkhJiYGm81GiRIlCAgIuKVy5YHOQgghhCiSqj1Tg4A6gY73Og8dSb1Sst5BCFEoNJ3i9lVUjBs3jnvuuYdLly6haRrr168nKSmJzz77DE9PT3788cdbKld6xIQQQghRJBm8DbT/pQOXtl4i7WoqIa1Lsmjl4sJulhCimNm+fTuTJk1yLKSmaRomk4lRo0Zx6dIlXnnlFdauXZvrciUQE0IIIUSRpeh1hLYLA8BisRRya4QQ7hT1OWKXLl0iLCwMnU6HXq93Wu+gdevWfPrpp7dUrgxNFEIIIYQQQuQbTVHcvoqK0qVLExMTA0DFihWdFlg7ffr0TR/NlBXpERNCCCGEEEKILDRr1oy9e/fSrVs3evTowcSJE0lLS8NkMjF58mTatWt3S+VKICaEEEIIIYTIN0Wp98udl19+mdOnTwPwzjvvcPjwYcaPH4+mabRq1YpPPvnklsqVQEwIIYQQQgghstCwYUMaNmwIgI+PD6tXryY+Ph5FUfDz87vlciUQE0IIIYQQQuSbot4j5o6/v/9tlyGLdQghhBBCCCHyTVFfrAPgyJEj9OvXj7CwMEwmE3v27AFgwoQJbN68+ZbKlEBMCCGEEEIIIbKwb98+GjduzNatW2nTpg02m82xLTExkS+//PKWypVATAghhBBFTmKshZR4a2E3QwiRA0W9R2zcuHHUrVuXEydOsGDBAjRNc2xr0qQJO3fuvKVyZY6YEEIIIYqM1CQryz84wYmdcSg6uO+hknR5rhI6fdG5qBNCFC3btm1j4cKFeHt7O/WGgf0ZY1FRUbdUrvSICSGEEKLI2DzvPCd2xgGgqbDv5yvs/vFSIbdKCJEdTXH/Kio0TcNkMrndFhsbi4eHxy2VK4GYEEIIIYqMU/vi0AAVBc2RFl+YTRJC3ERRH5pYt25dVqxY4XbbTz/95FjaPrdkaKIQQgghigTVppGUpGHT6e0JmoZOUwkO9yrchgkhirXnnnuO/v374+Pjw1NPPQXA2bNn2bRpE3PmzGHp0qW3VK4EYkIIIYQoEo78dY2E2AwLdCgKikFPsx6hhdcoIcRNFaXeL3cef/xx/vvvPyIiIvj0008B6NmzJwaDgQkTJtC1a9dbKlcCMSGEEELcsa5GW9i2OY60VA3rxUSsOvusCr2qogA2G/z22XESTidiS0jDqgSib5zg2F/TNKKWnyXm90v41g4g/Mkq6L1v7fJH0zTU5XtRNx9DVzMU3eD7UXyuzw05cAYWbAWTAQa3gyoSHApRnLzxxhs89dRT/PLLL1y6dImQkBAefvhhKlSocMtlKlrG9ReFEEIIIe4QVy6Zef+tsyQlquhtNvxT03DcV9c0DDYbRqsN/7gETBm3GTR6f9eCktUCOfjCDs7MOOoos8T9JWm26WGUW7hDb31pKbapvzreK00qYvzzFZTfD0GHiWC53lvn6wnbP4A6t36BJkRxMv4R98u7T1jfuIBbknOvvvoqY8eOJTw83JGmqio6Xd4tsSGLdQghhBDijrTllziSElUAPC1WnEInRUFVdHilpGKwWJy3WRX+/e4MaVdSOfv1MacyY7df4erm3C81rcUmYZu+1Tltx2nUXw7BhytuBGEAianw8dpc1yFEcaWhuH3dyT766CMuXrzoeG+z2TAajezZsyfP6pChiUJkYcWKFSxatIgLFy5gsVhYtGgRNWrU4MSJE0ybNo3Dhw8THx9Pv379eOmllwq7uUIIUSi+3KfyzUEVH6PCi40UOlW+cY937QmVj3eqJFthYB2FZ+rbF9nYetLGpN/MHIy0omkaFQN1lDWoJMTaqF1Wz3OdfCgTpCcx8cbzenRuBvDoVBt6VQVNw6bT2eeMqSqKpnFi6VmuzDqKF6B66FA00FtUFA2ODv+dqw+UxBCXjOV8Iv6PVCBkYHXiP9iOeVcker2KzmZDMenQW9PQl/TB84n7wHwj2FKwocMKYxegWeJcLyn3noSWb4JeB6Megd7N8/K0CyHymbtBg3k9kFACMSHc2LNnD++99x6tW7dmwIABGAwGwsLCsFqtvPrqq6SlpfH000/j7+9PpUqVCru5QghRKD7do/LcJvX6O43N5zS2PK7QMlxhyxmVbkttjiXmt1/QsKrQuiw8NCcFi0UF1b71bKwNNI2yZhuHz1vZ+Z+FX94Komy568/t0TQUNxdAHmYziqqCYg/CADS9Hmw2bGkqWqqKatRdbx1YdToMKTZsJ+O5fDIePTa8sJCy5zLmT7dDQhoGLCiopB+VBQ0TkVg3/Yenjzf6pGQUbOgx24OvE5fQSHYNxPacuvH/rQdh9evQ9c4dhiVEfirqi3XkFwnEhHBj+/btAIwfPx5/f39H+pkzZzh79iwvvPACffv2LazmCSFEobPYNGbtV53SVA3m/qvSMlzP7H9UnEInTeOrfVZORmlYbDiCMAdFIV6vw9Nq42y0yl/HzURdNAP2hTnQ6bCqKjrNPqBJVRSMZiuKTXUEYY6qdDpQwMOsutRhUFRH0GRDj4oFEzZISMM+gCrTPtifWaZXNaxJGnrsvWEZasv0Pguzf81ZIGa1gaqCTQVPk8uxCSGKDwnEhHAjOjoawCkIA7h69arbdCGEuFtYVY3nNqnM+Vcjzeq6/Uy8xvyDKktOaGBQ7AGFVQMV9l/Q2H8BMOrsAUcmGUOzNz+L4f5gGzZFwaBq9vBIp0MFFMAzLQ1Nr8syUNHbshpClDG/hgboMgRfFjxQUDFgwYTZaVt6kKZiAszosM9b0/AEUrKf8fLHYTh+EaqVcb9d0+DNRfDJj5CSZj8Z4cHwyVDo0Sy7koW44xXVHrGjR49iMNjDJZvN/p115MgRt3kbNGiQ6/Jl1USRK2vWrGHChAnMmDGDgwcPsmLFCi5fvkxYWBhDhgyhS5cuAFy8eJFu3boxfPhwnnnmGacyZs6cyddff83q1aspU8b+BykiIoK1a9eyceNGPv74Y37//XcsFguNGzfm9ddfJyQkhOXLl7N48WIuXrxIaGgoY8aMoW3btnl6fOntziz9l8vdBM3Vq1cDOI63cuXKzJ07lzNnzlCyZEmGDBlCt27diIqKYurUqezatQur1UrLli15/fXX8fX1dSovOjqauXPn8scff3D58mV8fX2pVq0aAwYMoFkz+WMshChck3aovPaba69RRvbg5DqrCpZMlxqaBilW52BM0zCoGhUsVtA0ws0Wyien4mGz4ZNmdlldLCAhEe+UVHQ2FaPZebEOxWbDLy4F/2tpzvtpGoYUG75me3kKGgZsBBGHMdPSAQoqviQ4pZk8zBjTklGwYsCSqUVp6EjL9rzQoDLsnuJ+2zebYdBnrulGA/z3BZQLyb5sIe5gb3bZ6zb9vbX1C7glOafT6VxWV9U0Lcu09EAtN6RHTNyS6dOnYzab6dGjB0ajkWXLlhEREUF4eDj16tW75XLHjBlDaGgoI0aM4Pz583z33Xe89NJLPPjgg6xcuZJu3bphMpn4/vvvGTduHMuWLXNaVvR2lShRgokTJ7JixQr27t3LxIkTAQgKCgLgvvvuY+7cuXTv3p369es79omNjQXgjz/+YPny5fTq1Qt/f39Wr17NxIkTMRgMzJgxg8aNG/Pss89y6NAhVq9ejclkYvz48Y76L168yNChQ4mJiaFz587UqlWLlJQUDhw4wI4dOyQQE0IUuh9PZh+EgXPPFln1THno7cMTNdWxk1Wx76soCjYUjJqGXtVQFcXec6XdCJYsBr19AQ+dgtVkQGezL9Khs9qDMIPVhk7V0Fk1NL1yfdv1Cyadgl61oQM0dCgoKM6tRkOHih59hmGHtjQw4tyDdoMBMGc+emd7TkJkDIQFuW5bu8v9PhYr/LwXhj2UdblCiDw3d+7cfK9DAjFxSywWC/Pnz8doNALQvn17Hn30UZYsWXJbgVjdunV55ZVXHO8VRWHhwoVcvXqVJUuW4O3tDUDjxo3p168fK1asYMyYMbd1LBl5eXnRqVMnduzYwd69e+nUqZPTdoPBwNy5c6lbt67TtvRA7PTp0/zwww+Ehtof5Pnwww/TuXNnxo8fz4svvki/fv0c+yQkJLBu3TpeeeUVx3H973//48qVK0yfPt0l6FLVm1/8FISYmBh8fHzw8LA/xDQxMRFN0/Dz8wPAbDaTkJBAcHCwY5/IyEjCwsKyfB8VFUXp0qUdd5mkDqlD6rhz6yjv79TfdXM6xXU+GNeL0CmA3t5DptpQuDFwUKdcf4CyAqkm+98aRdPwMlvQATrVPqxQwT4nzHb92T6+iakYbNeHEOrAYNNQMgWDipa+nLbmEoBlbGDm+WI6HaDiZtltFYUUbnpe/L0h0Mf9z6NCySx3iy/hiUdaWrH+XEkd+V9HYdKK4MjEgQMH5nsdEoiJW9K7d29HEAZQqlQpypcvz7lz526r3MwLYNx3330sXLiQzp07O4IVgGrVquHj43Pb9eW1Nm3aOIIwgMDAQMqXL8/Jkyfp2bOnU9569eqxefNmLl68SNWqVYmLi2P79u3cf//9bnu+8vIBgrcjvXcwXeahlSaTyekPA+DyhyDz+4znTOqQOqSOO7uOcU10/HjSRmwqblUNgBBv+CvyeoIeyDiXTNPsgZlVvfH+euAUfH2ooo9NtV+geOkh+UZwoykKaQYDXhYLBqsVVa9Db7sRLOktVnQWq6NXzexhQG+xYLDeKMNgs2HQ7CGcChixYkWPHg1dhkBKj9UpSFPC/TFcvQQpoGJwzA8DUEhzXeTDqMe+KkkG4/uAlwdhXm5+Hs91gW//gIsxzvs8dB/+PVo4zYUrjp8rqSP/6xB3HgnExC0pW7asS1pAQABRUbl/SGZG6XPG0qXf+XH3ZeLv709cXNxt1ZfXMrcf7McQEhKCyWRySk9f8CP9GM6dO4emaVSrVi3/GyqEELfonhCFw4P1fHtY5YUtrj1AfWoqjG+u44ejKqtOaFxO1FGthEYZLzgSrVHSS8FTp3EpQSHQE05dsWLU6+lURU9KgpFLl8ykxdloco831w7Dru2JTuWrCninpKLq9aTqFDxS0jBZrCiqhs5iQdPrMBtUDBYVk6phM+pAp2Gw2PA0WzE4jS5QCHuhLh6lPLAcuAQX41G3nESHig4NMx7oseH5RF18XmyKteEHjv2seKLDhq55RZTjJ+BKpr9HrWrDIw3g0HkoHQCPNYUm2Xy/lwuBfz+G7/6AIxfAZIBm1eHRJrJyoijyVPkMuyWBmLglWfXOpK/9knkiY0bZTWbU6/W5Sr/T1prJ6rxk15t1px2DEELcTGkfhecb6Vlw2MqeS87b7i+jYNIrPFFbzxO1b6V0H8f/NlqsLoGYT1oaJk21j0lUdKR5e+IRG49e1UCvB70ejxSLfal6m2qfB6ZXUNFhTHXutTKGelH2w+bo0p81ZlW5XPFj1AsJ13Mo2DDg9VILdHVKQWl/uBTv2KZiQD9zEMqnq+HrDc6H0bI2vPRo7g69hC+M7Ji7fYQoAorqqon57c4Y6ySKnfTenvj4eJdtFy5cKOjmFAnlypVDURSOHTtW2E0RQogc+bK9ntLXR40rwNB7FTpXzrsLrtbtA7jnvhvD0j0M4JuaaWVCRSHNy8PxNs3TiNnDfvMu1UPvGFxo0ymkmgyOKx+9v5FqX7d0BGEAikFHwKxuKAHXy9Mr+LzRAmP9MBSjHsOsJ8HP8/o2HfrxndHVKQsTHoe6FW60qVVteNF1BV4hhMhIesREvvDx8SE4OJidO3c6LfV5/vx5tmzZUriNu0MFBATQvHlztm3bxl9//eUyT8zdkqlCCFGYGocpnH1Gz18XoawfVAnM2+8oo0nHc+PCuXAujdQUlUpVPfl0wD7ir5id8qkZRx0oComlPen7ZRPiDsQTUNkXW5wF2zUzwS1Lo6gaKcfj8GtUEr2vkcw8O1al1IUXsey8iKFqEPrwG8+N1He5F93FD9B2nUWpVgqlbKB9Q1gQ7JsKO0/YhxTWq5Sn50GIok56xNyTQEzkmz59+jBjxgzGjh1L69atiY6OZtmyZVSpUoVDhw4VdvPuSK+++ipDhgzhueeeo0uXLtSqVYvU1FQOHjxIWFgYY8eOLewmCiGEE5NeoVW5/K2jbDl7D1XSNQuJ8a7D241m52d66SokE1gjgJJ13D97y6Osj9t0x/4+JjzaVHS7TfH1RGlT3c0GJfs5YELcxWSOmHsSiIl8M3DgQBITE1m3bh27d++mUqVKvP322xw+fFgCsSyULVuWBQsWMGvWLLZt28aPP/6Iv78/1apVo3v37oXdPCGEKFQHtsZgNqc/+ev6nGSDjjbDK7B3wRnSEq0oFRIxNIst5JYKIcTNKZqsFCCEEEKIImDb8ih+/urc9Qc7Xw/E9DreXNMInQ7SUs3MX/ANAIMHD3Z6zIoQovC81OOA2/SPlt9bwC25s8hiHUIIIYQoEu5tFYTRALrrj1RWAGwqR7fFoCgKeoNc1gghig4ZmiiKhdjY2GyXxQewWq0YDNl/5D09PV0emiiEEOLO4B9iokRJEzEXnZ8mfei3GGq3Cs5iLyFEYdOQOWLuSCAmioUBAwYQGRmZbZ4GDRqwZ8+ebPN06dKFiIiIPGyZEEKIvORfyjUQ8w6Uyxkh7mSyWId78s0lioV3332XtLS0bPP4+/u7fa5ZRiVLlszLZgkhhMhjLfqW4ey/CahW+xwxT189TR8LLeRWCSFE7kkgJoqFevXqFXYThBBCFIDK9QMYPr0OBzZFYzDpqNehJIGlPW6+oxCi0MhzxNyTQEwIIYQQRUrpSt6UHlq+sJshhBC3RQIxIYQQQgghRL6RHjH3JBATQgghhBBC5BtV4jC35IEbQgghhBBCCFHApEdMCCGEEEIIkW9kaKJ70iMmhBBCCCGEEAVMesSEEEIIIYQQ+UZFesTckUBMCCGEEEIIkW9kaKJ7MjRRCCGEEEIIIQqY9IgJIYQQQggh8o0sX++e9IgJIYQQQgghRAGTHjEhhBBCiBzYf1mj50orJ6+BUQ/D6ip82l6PTua/CJEtVX5H3JIeMSGEEEKIm0izarRabOXENVCBNBt8vlfj411qYTdNiDuepihuX3c7CcSEEEIIIW5i6zmNuDTX9LkHJBATQtwaGZoohBBCiEKjRSeiLtkFGuj6NEQp6ec2X9Kms1ybexBNr8NWwoeUEwn4Ng/FWDuIpCPxBN5fCr/7g/KtncFe1+/ea87pIV5yV1+Im5HFOtyTQEwIIYQQhUI7GoXlgclwNQkA2ztrMP7xMkqtMKd8l17cQuy0PY73aRhIxpPYtedQgQSdBygK5V+oCdXyp60NQxUqBsDpeCB9SJWm0bxs/tQnhCj+ZGiiEEIIIQqF7YOfHEEYADFJ9rQMLBcSiP1kj1OaB1Z02IcE6gCTZgPg3KdH0cXlT1stNo0rydwIwrD//6v9+VOfEMWJhuL2dbeTQEwIIYQQBUe7MbZPO33VdfP1NO16PsvZePvqGJnGBKYHYgDK9W2aTcMQq4AGqpqzuVuapuUoPd4MSRbXfFdTwKq6L0MIYacqitvX3U6GJgpRCHbt2sWIESMYP348Xbt2LezmCCFE/otJgGe+hJU7oHQATOiL8kgdtK3HnbJZq5QhqdY0bEevoPp6kpoABjxQr987VtGhoWBFjxWFFJ0RVbFvS/HUYVtSAvQG5n1s71nTAj24t28lmo+pjqK7ceG3Z08S334bw+VLFmrX9mLosBBCQows2GXmzfUpXIzX6FLLwFe9vSnlpyPYS6FyIJyMv16AAmhg0mtEJUG4+6ltQgiRJekRE0IIIUT+e/YrWLodrDa4EAPDvoBI5x4xFYXkhYewHbliX7wjIRULRjR0KNhjHx0qSZjQgCSdyRGEARgsGlaDAS1DwMW1NPbMP8X+JWcdSdHRVj779BKXoixoGhw8mMLn0y+z74KVgd8lc+6ahk2FVQetDP8hGbD3eiVbADQcI6oU+zL2XZbb8uOMCVFsSI+YexKICSGEECL/rdzhkqSt+MfpvQ0jWNUM7xVsmQbvpAdkFvTO87UA1aBzSVMAxaZycutlR9r+f5KxZYqd/vsvjSW7zWQeqbj2kBWrTWPvJXvPV+byURT+uQKxqTI8UQiROzI0UQghhBB5Iy4J5m+ByFjoWB+OXoT/osDfCww6cHoOlx7FYsF5JpeN9Gn9wPV+MA3IHFypGLFiU3VYFP2NB8PaVPQWK4oGqk5B1euwGfSkenty7mQa276/QEKawunTZkwWCza9HlUBKwppXkZOnTW7HJJeBx/9YSHOqrMHiTrXYM9DDz7G2zpzQhRrsny9exKIiUKxZs0aJkyYwIwZMzh48CArVqzg8uXLhIWFMWTIELp06QLAxYsX6datG8OHD+eZZ55xKmPmzJl8/fXXrF69mjJlygAQERHB2rVr2bhxIx9//DG///47FouFxo0b8/rrrxMSEsLy5ctZvHgxFy9eJDQ0lDFjxtC2bdt8O9bVq1ezcOFCzp07R3BwMF27dqVevXpu81osFhYvXszPP//MmTNnMBgMlC9fni5duvD444/nWxuFEOK2xSVB41fheKT9/QfLb7KDihJ5GfAlPdDSo2Iizd4zhn0RDg/SSMPTsZcNHToUvLCi18Cq6UjUeWDTK8SV9sRou75wh6ph1SAx0A+byUhKmsbvM04S7+tDqsGAzccLFPvQICMayRaVSwdS8PbyIFl/Y8CQRdEx7mcz6BR7tJU5LtSgSgCY9HKlKURWVFkh0S0JxEShmj59OmazmR49emA0Glm2bBkRERGEh4dnGazkxJgxYwgNDWXEiBGcP3+e7777jpdeeokHH3yQlStX0q1bN0wmE99//z3jxo1j2bJlhIeH592BXfftt9/y0UcfUblyZUaOHInNZmPNmjX8/vvvLnktFgujR49m9+7d3H///XTq1Amj0ciJEyfYvHmzBGJCiDvbgq03grAc0dDQkzGqUQCDUyAGRmwopJGCB2kYsV3fx57XhooOk2YjxsfTaW6YAuhtKl6JKSR4mhxpnqlpXAnxcerVUgB/q5VrJhMNUtLY7etJil5n7/1KLzN9ZUQV+8qP6Z11OjgcoxCZqBHmKxebQoickzliolBZLBbmz5/PwIED6d+/PzNmzMBoNLJkyZLbKrdu3bpMnjyZ3r1788ILL9CvXz8OHjzIkiVLWLhwIYMGDaJ///5MmTIFm83GihUr8uiIbkhISODzzz+nXLlyzJs3jwEDBjB48GC++eYbYmJiXPIvXryY3bt3M2TIED777DOefPJJHn/8cd58802++OKLPG/frYqJiSEt7cb4osTERBISEhzvzWYzV686T8CPjIzM9n1UVJTTUtFSh9QhdRS9OhJOnCf3XAMXJdNgRQUVPSo2dNeDMDsVeygHoGgqNjc9Ugqgy7SMvU5TbwxlzJRXAXuYp2Afk6jLlE/L8K96470GXEmx//9O+XlIHVJH5veFSVMUt6+7nfSIiULVu3dvjMYbA+tLlSpF+fLlOXfu3G2V27dvX6f39913HwsXLqRz5854e3s70qtVq4aPj89t1+fO33//TWpqKr1793aq08/Pj169erkEVz/99BO+vr4MHTrUpSyd7s65ZxIUFOT03tfX1+m9yWQiODjYKS0sLCzb96GhoVKH1CF1FPE6/J5sB5/+jMtqF9nQYSXzeoMZF+ewxzt6R2hmxIYGJODpWM4eINlkQDO4XtSpioL5em9YujSjEU+LhSS9h1O6RdGhKgqnjXpSbBqoVnsgZsywKEjmKq6/L+EB94bY/3+n/DykDqkj83tx57lzru7EXals2bIuaQEBAcTFxd1WuelzxtL5+dkf8OLuS8nf3/+263Pn/Hn73eFKlSq5bKtcubJL2tmzZ6lQoQIeHh4u24QQ4o7XqCp8MwYqlQYPI7SqDdXL2AOZEj438imAnxeUCAQ333fK9X4uFYU0PNCAZLzQ0KMAKZhQHUMa7S8v1T5fzJRmA82+v01RSPM0YPEw2oNDTUPxNaJ6e+CPDcP1ZRM1wNNPT3KwJ7EmHWdMxht36lUNLDYCPCE4QA827UagmV49Cg9VBEXu7guRJVVx/7rbSY+YKFRZ9fSkd89n94fNlnnt4Qz0en2u0rVc3MHNLfnjLIS4azzVxv7KIfXlZfDRRqc0HTa06/eJTViwhvpijbpxuWLB9XvcaLV/hxttGsYU+9+Ga34mDFaVUL2ZJ7Y+mKP2PLs0mf1/Oi3tSLAXRL/jy9GrGjVnWa+Pd3T+Xt8ZlaPihbhryTPD3JMeMXFH8/f3ByA+Pt5l24ULFwq6ObmSvvjHyZMnXba5S6tQoQJnzpxxGhMuhBDFmVI5xCVNy3RpYqwS6PReh+uNs8x31lUFtOtpfuHeLvmzUjnY9bKoyvW0UF/chIDX9wuQi0whRO5JICbuaD4+PgQHB7Nz506nXqvz58+zZcuWwmtYDjRt2hRPT09++OEHkpOTHekJCQksXbrUJX/Hjh1JTExk9uzZLtvys8dOCCEKi9Kxtv35YtdpgMU/8EYGHxO+kx7Gr1dVR/jlRRo4BWMaiRnmgWlAiqcBFAWdSUfjF+/JcXuGNTNRq/SN9nga4L1OXgAEeCiU9cNlnphBBxMfkMspIbKjorh93e1kaKK44/Xp04cZM2YwduxYWrduTXR0NMuWLaNKlSocOnSosJuXJT8/P0aPHs2UKVMYNGgQXbp0QVVVVq9eTVBQEJcvX3bK369fP37//XfmzJnD4cOHadq0KR4eHpw8eZIzZ87cUSsnCiFEXlB/2GN/SPJ1CmAK0PD4rDdaQhqmHvegC/PH90gicUv/QwP0aPiRTKrOg2TVSBoGlFTw1CyoeoWrHWxYrSr1H7yPWo9XxifUK8ftCfTSsedFf5bvt3A1WeWxOibKlbAHWbsiVc4m4jIs0ahAg9J5cDKEEHcdCcTEHW/gwIEkJiaybt06du/eTaVKlXj77bc5fPjwHR2IgX31Rm9vbxYsWMCMGTOcHug8atQop7xGo5Hp06ezcOFCfv75Z7744gtMJhPly5ena9euhXQEQgiRj2KTXZKUuBQ8BjRwSrPFppGxK0oHeGMmRucNyvVnilk0sGhwjxmtXBr3Da7utCpvTnkaFfo3NLmkx6a6z59qgzSbvfdMCOGeTTq/3FI0GfMkhBBCiEKg7jmLpfH/bjwsGdA93QLjzCec8plPxXG81gK0tBuLNPk9WpmTu1JJi0pxpHnX9OfImMugwODBg28pEMtKmlWjwpdWLqXg9DDoRyrBup4ShQmRnS7D3D9ncO2s8AJuyZ1FBjULIYQQolDoGpTHsPRplPrloEwA+jFtMHzc2yWfqVIAFdZ2w6tpKIZQbwKH1CZ8XgcarW9P8ENhmEp5UqpbOeotb+3uGdF5wsOg8OvjBhqXVjAqGh566FFNYWGnrJbwEEKI7MktHCEyiI2NzXZZfACr1YrBkP2vjqenp8vDF4UQQrjSd6+Hvnu9m+bzbV8e3/blndL8Aj1ovP4hx3uLxQJb8riBGdxTUmHHALl0EiK35Jlh7sm3iRAZDBgwgMjIyGzzNGjQgD179mSbp0uXLkRERORhy4QQQgghRHEigZgQGbz77rs3fY6Xv7+/2+eaZVSyZMm8bJYQQgghRJElS9W7J4GYEBnUq1evsJsghBBCCFGs2BQJxNyRxTqEEEIIIYQQooBJj5gQQgghhBAi38hiHe5JICaEEEIIIYTINzaZI+aWDE0UQgghhBBCiAImPWJCCCGEEEKIfGOTDjG3pEdMCCGEEEIIIQqY9IgJIYQQQggh8o0qy9e7JYGYEEIIIYQQIt/Ic8Tck6GJQgghhBBCCFHApEdMCCGEEEIIkW+shd2AO5QEYkIIIYS4K6Sl2Niz4SpXzqVSpZ4f9zxQorCbJIS4i0kgJoQQQohiz2bTmD3uOBdPJAOwY100LXok0XFoeCG3TIjiT+aIuSdzxIQQQghR7B3fFcfF40mgaY7XX2uukJpsK+ymCVHsWRX3r7udBGJCCCGEKPZiL5lRNA3d9ZeiaVjNKuYUCcSEEIVDhiYKIYQQoti7fCqZjDfgFcA/2IB/sKmwmiTEXcOKdH+5Iz1iQgghhCg+4nTolvix+L61rOr2K5F/XQHg8tkUNOwPllUVhUQPE2etHrw89DgrFl1BVbXCbbcQ4q4jgZgQQgghig39Cj90p0zY0lSuHrzGhuHbSI1No1QFbzRFAUUh1WgkxcMDq6qQlKjyy+oYNq6JKeymC1FsWRT3r7udDE0UQgghRMH5dT8s2Gr/v94EKRbo2gD6Nb+tYlOvpPLvlAN4nwaLXiXNQ4dq0JOiGFk5ZjcpHh6YzGZUvR6zp4fL/nt3JNLh0eDbaoMQwj2LrJrolgRiQgghhCgY3/8BfadmSvSAb7fD0UiI6HlLxdpSrGzpupHEU4kYAaPNBjqFayW80HQ6Lh1PApLwNhgwe3pgtNqwGOQSSAhRuGRoohAF4Omnn6Zr16653m/Xrl00atSINWvW5EOrhBCiAOw4bg/ALl+Dqa7fZRo2NHSoH65F/fEAalIaltUHsaw7TNpvJ0l4YyPJ3+zDGpXItZn/EPXsr1z+YAfmk3EAxP15iX+f3U7q4TgUW4Z5Xjr7JY5is9mXqwcMVisq4Juais7mvFqiqmpsP5DK/J8TWbsjhbgkNctDsqkav5xSWXFMJdmicTlJ47sjKjsjZZ6ZEO5Ysnjd7eR2kBBCCCHynqZB349gyZ/2954mKOnvnAUPNDztb1I1rF0+IdVQAqwaGpCCNxr663khDh+s2Fc5jHrjL8y1yhB7JBGbTocn9qDO7K3H7KUnxcuAwWy9vq8Nm9EAeh1pJhOaTkdgSiqJHh6YjQYswG/XjPwwIw6LTrne3AQ+eyaQZjWcV1W8lqrR5jsb/9jXACHQA5JtYL4e1/WtqbC4sw5FhmIJIW5C0TRNbt8Ikc8sFguapmEy5W6ZZFVVsVgsGAwG9Hp9PrVOCJFvUtLAy3U+UrGVkmYPuBQFftoDj/yf8/YAb4hLBkBDQcMPMixrrQHJlEBDhxkjFjyctqdhJAHf6//XE48XZp3eXl+GMmJCPYkL9nGqWgOSfL2JDwxwpKlArLcXUT5eRHl6kmjQ2QPI6+VVCdXzw+tBqKp2vb0weafG+D+uR13p9WaKuX7upaNDRRl0JES6wOeuuk2/9sndPS9TesSEKABGo/GW9tPpdHh43EUXcUIUF3v+g6FfwL5TUC0Mvnga2t9X2K3KPwfOwJDpsOs/qFwaPhsGB8+55rsehNnpyRzB2N/ZsGFAQcNEKip6rBgBBQM3hhPa0KOhOAVh6WWoetcgSAFsJiOeaWmYjUZUnQ4dYNBUAtPMRHl6YFJVLIpC+j3q/6Js+IxPxKLoQK8DRcGoBxQdmBR7oZrmchwHrkCHijk4b0LcJVKkg9gtuV0jCtWaNWto1KgRO3fuZN68eTz66KPcf//99OjRg7Vr1zryXbx4kUaNGjFz5kyXMmbOnEmjRo24ePGiIy0iIoJGjRpx7do1IiIiePDBB2nVqhUvvfQS0dHRACxfvpxevXrRvHlzevTowebNm/PtON3NEfvvv/8YN24cnTp1olmzZrRv355hw4axZcsWRx6ZIyZEEWSzwWMf2oMwgOOR0P1DiEsq3HblF02DHpPsQRjAyUvQazIE+rjm9ch4/9eGvZ8qQ1GADRMaOhTs4Y0eG3rsQwwtGe4fG7GhQ3PM/3KUoYDB6jz/C8Cm16PpdOg0DQ+zGTQNm6KgKQreNhshKWmYdTrHEvcoClbAwo0gDMBiA6wZ5o+5GYJYwd8lSQghXEiPmLgjTJ8+HbPZTI8ePTAajSxbtoyIiAjCw8OpV6/eLZc7ZswYQkNDGTFiBOfPn+e7777jpZde4sEHH2TlypV069YNk8nE999/z7hx41i2bBnh4eF5d2BZuHbtGiNHjgSgZ8+ehIaGEhcXx5EjR9i/fz9t2rTJ9zYIIfLJ/jNwLto5LTEVthyER5sUTpvy05ELcCLSOS3FDL8ddM2bZnX8V0FDxd6bpJAehBnsvVyZ6FCxAGaMGLChomBAwxMzqmbCgh5Vr2D20mM16dBbNYwpZiyeRlAUbDodyX7egH04YqqHCbNBj0Wvx4aCDvBQXRfncAwIdzffy6aBwf1t/nMJbpOFuGuZ3fxeC+kRE3cIi8XC/PnzGThwIP3792fGjBkYjUaWLFlyW+XWrVuXyZMn07t3b1544QX69evHwYMHWbJkCQsXLmTQoEH079+fKVOmYLPZWLFiRR4dUfb++ecfYmJiePXVV3nmmWd49NFHGTBgAO+//z5jx44tkDbcqpiYGNLS0hzvExMTSUi4cdVhNpu5etV5LHhkZGS276Oiosg4XVXqkDqKdB3BPmBwM6ezQsmidRw5rSM0EDxch1/Hl3XtFtK8nefJKqjX+7sM2DACOvRu1lLT0EjCB9ChQ8OAih4VT6wEaMlYPBSSA4xYPfWgswdWPklmPBPTwGIjIdAP2/Xl6hO9vUn18EDV69EDnjYbqqIjc+8cgE3BHoS5m06fzWIc+6JunLti+TOXOopkHeLOI4GYuCP07t3baR5VqVKlKF++POfOuZljkAt9+/Z1en/fffY5Gp07d8bb29uRXq1aNXx8fG67vpzy8/MDYNu2bSQmJhZInXklKCjIad6ar6+v43gATCYTwcHOk2/DwsKyfR8aGuq0wpjUIXUU6TrKl4YXMj2uom8LqFepaB1HTuso4QuvdXc+3sea4P/uAGhe40aaoqC80M0pm0IqOlRwDEQEI6lkDIo0IA1PtEyXLHo0QMOMEc2gg+urHWqAVW8vT1XA7O3pCJqsOh3WTEGyXtPQqSoeqoaSMeDSNFTD9SAscxymA/RZB2J/Xbrx96xY/syljiJZR6FSsnjd5WRoorgjlC1b1iUtICCAqKio2yq3TJkyTu/Tv8TcfTn5+/sTFxd3W/XlVIMGDejatStr1qxh/fr11K5dmyZNmtC+fXuqVq1aIG0QQuSjSQOgUwPYdgTuq2j/f3E2oS88dB9sPQh1ykOXhqDXw+aJsPxvOBkFjzSAEH94bxn2SEZBQY+eNBSsaOix4I2KARNpWDGghQailgzCfMD1u1lRoPK6rqREWzGtP8/pjVH2Je899diuL9ah00BvsaLTNHtvQza9WCYFjBqomn3pfB3Qt4kHXuEG/onSUHUKAZ46KgYpvPKbCqp2/WLStUybmw40Ie5q8jgHtyQQE3cEnc5952x6N312z2OxZXooZ0ZZLfmeVXpBPs1h/PjxPPXUU2zbto19+/axePFi5syZw5gxY3jqqacKrB1CiHzSpo79dbdoUcv+yshktPcGZtSxPvy0D66vhJi+IIcVPSr2niQFMCo2POf3RqsRRnztWZDkvDqhb89qBHSsSABgDfTg9MYorHrFEYSll+OdmEpSoC+KTofRZkNvtWHL0CtmUxRURSE4UIei3pgXZjRAn5ZeVAt3HXa59KSVv7MZ9TX8XhlwJIS4OQnERJHg72+faxAfH++y7cKFCwXdnDxTuXJlKleuzFNPPUViYiLDhw/n888/p2/fvre85L0QQtzRvn8R3l0K6/dBohVK+KBWLYN2KQ19TCqaYoCwAIxjWqJ/yD60sezW/lx9Yyspe6LB04j/k7UIfruZo8jUSykAqDo3C31oGj5xiaT6+WA2GvBKSyXO4APXAzCz3v4cshI+Ol7u6Mcvu1MJ8FF4qr2P2yAM4Mceeib8qfJXpEb9UgrtKyh8c1DjWppG/5o6RtaTu/9CiJuTQEwUCT4+PgQHB7Nz5040TXP0kJ0/f95pufeiIi4uDj8/P6eeQF9fX8LDwzl+/DhJSUkEBgYWXgOFECK/+HvD5AH213W666+sbj95NAylzM+PZ1lk6dahoICiuo5qUHUKRqsNz9ImziXZa9CrKkmenk75jEaFvm296dvW26WMzIK9FD590HlkRe8aWWQWQogsSCAmiow+ffowY8YMxo4dS+vWrYmOjmbZsmVUqVKFQ4cOFXbzcuXHH39k8eLFtG3blrJly2Iymdi3bx+bN2+mRYsWEoQJIUQu+FX1p8HkxuyYsA9USB/EqCoKFqOe6l3LciLFE47aHyjtZbZg0+lINRodc1fMZtfl64UQeUTmiLklgZgoMgYOHEhiYiLr1q1j9+7dVKpUibfffpvDhw8XuUCsYcOGHDt2jD/++IMrV66g1+sJDQ1l9OjRLis9CiGEuLnKT1XB5qvjj5f2OGaSKZpGYAkDbd+vz+lxRx15FcAvNQ2jxUqCj70HLKysh2uhQoi8IXGYW4pWkKsTCCGEEELkk7SUNBZ2Wo7ujP15ZYpBofXHTajUKZxZLx/h7EHnx4WY9XrifLzx9dPzYkQ5wsIlGBMiPygvX3Obrk0JLNB23GmkR0wIIYQQxYLOoMPWNwH1pJHmdVpQvm0Z/MJ9APDwdl0tt1wVTx7rEcp9jX3xcrNdCJFXpEvMHQnEhHAjNjY222XxAaxWKwZD9r9Cnp6e+Pr65mXThBBCZEcBrYqF6n0rOq0+27RLSU7siiN9HJCig4cHlqFqg4BCaqgQ4m4ngZgQbgwYMIDIyGweEoP9ocx79uzJNk+XLl2IiIjIw5YJIYS4FdWbBPLUu9XYtT4aRQeNHilJlfr+hd0sIe4O0iHmlgRiQrjx7rvvkpaWlm0ef39/t881y6hkyZJ52SwhhBC3oWrDAKo2lB4wIQqcBGJuSSAmhBv16tUr7CYIIYQQQohiTAIxIYQQQgghRD6SLjF3dIXdACGEEEIIIYS420iPmBBCCCGEECL/SIeYWxKICSGEEEIIIfKRRGLuyNBEIYQQQgghhChg0iMmhBBCCCGEyD/SIeaWBGJCCCGEEEKI/COBmFsyNFEIIYQQQgghCpj0iAkhhBBCCCHykXSJuSOBmBBCCCGKjJPXND7bq3IpCXpWV+hZXQb3CCGKJgnEhBBCCFEkXEzUaLLIxtUU+/tvj2h81AZebCTBmBB3NOkQc0u+uYQQQghRJMz7V3MEYene+F3ln8ta4TQolybvUKn4lZVyM628u11F04pGu4W4bYri/nWXk0BMCCGEEIXmYqLGP5c11BwEJUkW1zxpNui4zEaqNfdBzeUkjb2XNGxqzvc9GK1xJi73dc37V+XV31TOxMP5BHhnm8r0vRKICXE3k0BMCCGEEAVO0zRGbrBRbqaNevNt1Jxj48jV7AOTfjUVtyOcopLgt/O5C2pe22qj7EwbDRbYqPy1jT2Xst//QoJGg/lW6syzUfFrG31W2zDbcl7n4sOqS9oiN2lCiLuHBGJCCCGEKHArT2h8+Y9GemfU8Vh4cp0t232OxUJWoU+wp/thTpqmseG0yv/+Vtly1h74bD2nMWmnhvV6HHQ2AbqvtJFozjqweu03lb2Xb7z/4ZjGrP05D8SiklzTjsfCiuNqrnrkhBDFhwRiQgghhChwf15wDT52X4IP/866l2ibm30AagVBw1D3gdjwX1Q6LFV5/XeVtktUXthsc1vO2QSo+42N6GT3dfx6xjV949mc92h5u1keLSYVeqxS6bxc5ouJYk7J4nWXk0BMCCGEEAWubkn3V2Fv/qHSdYWVn0+5Bjn3lXK/z8VESHMzR+zIVY3ZB5zTP96t8c2/7gOoU3EwM4teLndT0Lachdd/sxGbevMg6oGyWV91/nxaY6ObQE+I4kMiMXckEBNCCCFEnslpz07fmgp1QlzTbRqs/Q8eWabyU6ZgrFmY5vbCJc4McWmu6Wfi3bfl2LWs23U6i4U4vNz0aMWmwf92aHRcmv2QSoBmZbK/6Dwdf9MihBDFjARibqSlpTFt2jS6du1KkyZNaNOmTWE3KV9cvHiRRo0aMXPmzMJuikNUVBSvvPIKHTp0oFGjRrz00kuF3SQhhBA5MP+gSvmZVoxTbXRfaeNKFkP80hn1CmPqZx2caMDne+2B2JGrGq2+s1Jjjoa7vqyaJaCUj2tZD5RV8DPl5iigc2X3bcoqHWBHFOyKyv54v81mYQ6DDjpUkN4BUYxJh5hbuX6gc0xMDAsWLGDbtm1ERUWhKApBQUHUrFmThx56iHbt2uVHOwvU/PnzWbRoEU8++STVqlXDZMr6WzwtLY1169bx+++/c/z4cWJiYggJCeGee+5h+PDhVKpUyWUfTdNYsmQJy5Yt4/z58/j5+dGqVStGjRpFYGBgnh/PzJkzqVGjRpEIKCMiIjh69CiDBw8mJCSE0qVL52t9W7Zs4ejRozzzzDP5Wo8QQhRney5pDFqvOhbSWHlCA1RWPKa/rXKPx8KG0zZGbtT471rW+SKTYP9llcgEMGt6TIq9h8rXpPBxG4Whv+Ssl+6d+xUeq+b+HrVRl30ZVlXj70jQNGgaBkqmZyT9F+d+v3A/mNpGR4UAuSoV4m6Tq0AsKiqKgQMHkpSUxCOPPEKvXr0AOHfuHNu2bSMlJaVYBGLbt2+nWrVqPP/88zfNGxkZyXvvvUfdunXp2rUrpUqV4sKFCyxbtozNmzfz2Wef0ahRI6d9PvnkExYuXEjLli3p168fFy9eZPHixezfv5958+bh5eWVp8fz9ddf06VLlzs+EDObzezevZvHH3+cAQMGFEidW7ZsYe3atRKICSHEbVh13OaymuHqE/Zng+lu46Gtx2Khw9KbB1FxZrhvvgooeNOXkd4bHdvqldYBNx86CDCuSdYDhRYfznq/e0Ng1EaVPddXVaxXCn7uqXfupXNzGBX84eRw/W2dIyGKBPmIu5WrQGzBggVcvXqVqVOn0qpVK6dtL730EpcuXcrTxhWWq1ev5rgnJjAwkIULF1KzZk2n9EceeYQnnniCTz/9lPnz5zvST506xeLFi2nVqhVTp051pNesWZPXXnuNRYsWMWzYsLw5kDuM2WxGp9NhMLj/2MXExKBpGn5+fgXcsvyhqipmsxlPT8/Cbsqdb89/sOwvKOkPA9pAUB59BlLNsPh3OHoBHqwLHerlTblCCCfRqQqZIw29DpcAw6pq/HBUY+9ljfvLKDedT3Yry1ck48Gi1Af4ADgWozH3QM6CMB3g4ebP09ZzGqtO2Lia6rrNpLMHXdVKwKIMgdq+y/De3yoj79Px7REVb4OC2c3IxGup8PTPKgEeGm3L6+hSRWaMiOJKIjF3FC0X66WOGTOG7du389tvv+Ht7X3T/I0aNaJLly5EREQ4pa9Zs4YJEybw5ZdfOnqLZs6cyddff82SJUtYsWIFv/zyC0lJSdx777289tprVKxYkU2bNjF79mxOnz5NiRIlGDRokKNX7mZSU1OZM2cOGzZsICoqCh8fHxo3bsyIESOoUKGCU7syGz58+C31mDzxxBOcOnWKP//805H25ZdfMmvWLGbOnEnDhg2d8nfr1g2j0ciyZcvy5Hh27drFiBEjXPYNCwtjzZo1XLx4kW7dujF8+HBq1KjBrFmzOHnyJH5+fnTq1IlRo0a5BE1nz57l66+/ZseOHcTFxVGyZEnat2/P008/7dSTFxERwdq1a9mwYQOffvop27ZtIzY2llWrVlGmTBmXNqXnzyzjZ+Tvv/9m/vz5HDx4ELPZTPny5enVq5fLZ+Cvv/5i1apVHDp0iOjoaIxGI/fccw9DhgxxOuddu3YlMjIyyzq7du1KWFgYX331ldP29PM6fvx4unbtCtz47Hz++eccOHCANWvWEBUVxVtvvUXXrl3RNI1ly5axcuVKTp06hV6vp1atWgwfPtylx/THH3/k+++/59y5c5jNZgIDA6lbty4vvfQSISFuZrYXdd//Af0/BvX6VUrFUrBrMgTfZjCmqtD6bfgjw9XR271hYr/bK1cI4eKFTVY+3uOabnvJubenxyobK47fuOxoWQZ+v5g/bVr3mEb3NQppOYvDAEh6To+38UZ7p+5SeWnLzZeo1ymQ+VFglQPgfCKYr9dvUNyvvJjRCw0Vpra9veGcQtyJlHdS3KZrE/N2FFhRk6sesbJlywKwYsUK+vfv7zL+OS+MHz8eX19fBg8eTFxcHAsXLmT06NGMHDmSzz77jJ49e+Lv78+qVav43//+R+XKlWnQoEG2ZVqtVsaOHcuePXto27Yt/fr1IzIykh9++IHt27czd+5cKlWqRP369Zk4cSJTp04lMDCQIUOGAFCtWrVcH4eqqly9epUSJUo4pR88eBCdTse9997rss+9997Lzz//TGJiIr6+vrd9PJUqVWLixIm888471K9fn+7duwO4BNHbtm1j6dKl9OzZk8cee4ytW7eyYMEC/Pz8HOcA4PDhw4wYMQI/Pz969OhBqVKlOH78ON999x3//PMPX331lUvgNmrUKEJCQhg6dCgpKSlZBvA9evSgevXqTJ06lbZt29K2bVsAxxy75cuX88EHH3DvvfcyZMgQvL29+fvvv/nf//7HhQsXeO655xxlrVmzhoSEBLp27UpISAiXL19m1apVPPvss3z55ZfUr18fsPfiLlq0iL179zJx4kTH/u7m9eXUJ598gtVqpXv37vj4+DiC4nfeeYeff/6ZBx98kK5du2KxWFi/fj2jRo1i0qRJtG7dGoB169Yxfvx46tevzzPPPIOnpyeXLl1i+/btXLlypXgGYuO/vxGEAZy+DHN+hVceu71yf97nHIQBTFllL9fv7v7iFyKvmVXXHjFjph6xvZc0pyAM8i8IU9D4eA+5CsL0Cnhm+BNmsWm8uz1nzwlz9zzmyKQbQRjcPAgD+GyvxutNNUp6S++BKGbkI+1WrgKxJ598kvXr1zNt2jQWL15M/fr1qV27NvXr16dWrVp50qBSpUoxZcoUR5AXGBjI5MmTmTRpEkuWLHEMGezQoQOdO3fmhx9+uGkgtnbtWvbs2UO/fv2cVuFr3bo1w4YNY8qUKXz++eeEh4cTHh7OjBkzCAoKolOnTrd8HEuXLiU6OpqhQ4c6pV++fJnAwEC3C4CUKlXKkSe7QCynxxMcHEynTp145513KFu2bJbHc/LkSZYsWeLoqerZsyePP/4433//vVMgNnHiRIKDg1mwYAE+Pj6O9MaNG/PKK6+wfv16Rw9RumrVqrntZcysbt26hISEMHXqVKpWrerU1ujoaKZMmcJDDz3E+++/70jv1asXU6ZMYdGiRfTs2ZPw8HAA3nrrLZd5dj179qRPnz7MnTvXEYi1adOGLVu2sHfv3tv6WWeUlpbGokWLnIYjbtq0ifXr1/P666/Ts2dPR3rfvn0ZPHgwH330Ea1atUJRFDZv3oyPjw8zZsxwCmrvpDlsMTEx+Pj44OHhAUBiYqLTkFKz2UxCQgLBwcGOfSIjIwkLC3P/PirWpY7UU5EoaWm3Vce1I6cJzFxwihmuJYGfV94fB/Z5tKVLl3Z8f0kdUsfdUodRcY0yLKrzHLFD52OAAJd8+UEDIpNzt49NswdOsVfs5ybVBtfcLImfn6wqRKeALf7O/5lLHUWvDnHnydVg5PDwcL799lt69+6Npmn89NNPTJ06laeeeoq+ffty+HA2M1lzqE+fPk49bffddx8ArVq1cpq3VaJECSpUqMD58+dvWubmzZtRFMUlKKpXrx6NGzdm586dJCYm3nbb0+3bt4+PP/6YqlWrMnjwYKdtqampGI1Gt/ul/7KlproZiJ5BXh9PmzZtnIYLKopCo0aNuHr1KsnJ9r9kJ06c4Pjx4zz88MNYLBauXbvmeNWrVw8vLy/++usvl7KfeOKJHLcjKxs3bsRsNtOtWzeneq9du0bLli1RVZUdO3Y48mcMwpKTk7l27Rp6vZ46depw8ODB225Pdnr16uUyJ2z9+vV4eXnRpk0bp7YnJibSsmVLLl68yNmzZwHw9fUlNTWVP/74I8fP4iloQUFBjs8q2NuccV6fyWRy+sMAuPwhcHrfo5lLHZ79Wt92HYH92oJnphsejatCuZD8OQ4gNDTU6ftL6pA67pY6VDe3u/WK4pTavW4QQZmmzAZ5kC+q6S/RvWru9lGwDzFMPzd+JoX2t7GkfIuyud+nVhDUDCoaP3Opo+jVIe48uV6+vkyZMrz22mu89tprREdHs3//ftauXctvv/3G888/z5IlSwgIuPU7XunDH9P5+/s76s3Mz8+PqKiom5Z54cIFgoKC3C4NX7VqVXbu3ElkZOQtDUHM7PDhwzz//POEhITw8ccfu1yUe3p6Ehvr2gMA9t6U9DzZyevjyXzOAcfPMC4uDm9vb06dOgXYV2D8+uuv3ZYTExPjkla+fPkctSE7p0+fBmD06NFZ5slY9/nz5/n888/566+/SEhIcMqXH8NpMypXrpxL2unTp0lJSeHhhx/Ocr+YmBgqVKjA0KFD2bdvHy+//DIBAQHUr1+f5s2b06FDh2x7SYu0j4eATYUlf0Ipf/s8rpa1b7/c0BKwahy8NA+OXID2deHLO6dnUYjipIK/69BE70z3HL2NCut66hnzq429l+H+MtC2nMLE7dnfdGpQCsdqhO4YFWhQGv6OAtCoqLvC016beLZRP+ItCl/9o5Fsvfkx6HAdPbWgk44RG1TWndSoGABVAmDreUi5SXlBnrC6u45Xt2rMO6jhZYBSXvDv1az3aV4G5nbU5/vfKSEKhXys3cp1IJZRSEgI7dq1o127drz55pv8/PPPbNu27abDvGy2rAdt63TuO+mySs9Jr0F2efKy1+HIkSOMGjXKMbQsNDTUJU+pUqU4deoUZrPZZXji5cuXHXmyk9fHk9W5zVhe+r/9+vWjRYsWbvOmB80Z5cWKgel1jx8/Pstzkx5MJiUlMWzYMFJTU+nXrx9Vq1bFx8cHRVGYN28eO3fuzHG9Wf0xzO7z6+54NU0jICDAaVhlZlWqVAHsvc5Llixh165d7Nixg927d/P+++8zc+ZMZsyYQeXKlXPc/iLD3xu+GWt/5bUO9eDAx3lfrhDCyRO1Fd7/G2IyDOgY20Bx+R5tGqaw48kblx5f789+ElfdkrB7gIGeq2wsP+7+75tFg1ea6OhZXYfFYmHuXPvCT0Y9TGur54laGo0X3nyymJfR/pDpjEJ9FFZmehbalrMqbZdkP3ds4gM6PA06Pn0QPn3Qnrb5rEr7H1S388kABtXRUT1IrlaFuJvcViCWUfpCE+nBBNh7VeLiXJ9geOHChbyqNkfCw8P5888/uXbtmksv0smTJ9HpdLfdfZsehHl5eTFz5ky3vUwAtWvXZvv27Rw4cMBl1cQDBw5Qvnz5m/Z8FMTxZJbes6XT6WjatGmelp3TugMCAm5a986dO4mOjuadd96hW7duTttmzJjhkj+7O4/+/v7Ex8e7pOf281u+fHnOnDnDPffck6NeLaPRyP3338/9998P3Fil8ZtvvsnRfDshhChooT4Kfz2h56NdKucT4LGqCkPvvXlQcS37kfg0Km0vY1FnHR/v1lhwSOWQm16lMb+qPFrVfX3+ppzdoFQ1+42z7P4ubL+oMX2v+yCsUyUw6BT611J4vKbrDc625XVs6qPw6R4by4+77p+ag147IYos6el1K1dzxHbt2uV2/pKqqvz+++8ATnfsy5cvz4EDB5z2iY+PZ/Xq1bfa3lvStm1bNE1j3rx5Tun79+9n586dNGnS5LaGfaUHYZ6ensycOdOxaIQ7HTp0QFEUFi1a5JS+adMmLl68mKNFI3J7PN7e3m4DityoUaMGVatWZcWKFZw7d85lu9VqdRt054X27dtjMpn46quv3H7+EhMTMZvNAOj19juXmXsG//rrL/7991+XfdPnk7k7P+XLl+f06dNONxfMZjM//PBDrtrfqVMnNE1j+vTpbnssr169cVVx7do1l+01a9ZEp9Pd9s9QCCHyU7USCl8+pGdtDz3D6upuOsTucpLG+39nHSSV9IJxTe2XKZ4GhXFNdfz9hJ4ybv5cRybZF7lwJy4tZxeAydbshxyuPK7S4lsby9wEUQAvNtKxqrvebRCWrnU5hWlZLE+vI2crNAohio9c9YgtXLiQf/75hxYtWlCrVi18fX25evUqmzZt4vDhwzRq1Mhp2FqfPn14++23GTFiBJ06dSIhIYGVK1cSFhbmdPGZ37p06cK6detYuHAhFy9epHHjxo7l3n18fJxWHsytyMhIRo0aRXx8PI8//jj79+9n//79Tnnatm3ruOCvUqUKffv25dtvv+WFF16gdevWXLhwgcWLF1OpUiX69++f58dTp04dduzYwfz58yldujReXl4uD+S+GUVRmDBhAiNHjqR///5069aNypUrk5qayvnz59m0aROjR492WTUxL5QuXZpx48bxf//3f/Tq1YvOnTsTFhZGbGwsJ06cYMuWLfzwww+UKVOGevXqERwczMcff0xkZCSlSpXi2LFjrFu3jqpVq3LixAmnsuvUqcOSJUv48MMPad68OQaDgcaNGxMUFESfPn345ZdfePbZZ+nZsycWi4V169blerhl+/bt6dq1K0uXLuXYsWO0bNmSwMBALl++zP79+zl//jyrVq0C7Mv9+/r60qBBA0qXLk1iYiI//vgjqqrSuXPnPDunQghR2L45qLldlbCEJ/yvpULvGjpKeDoHUb4mhYfKwzeHnPdRAD+j+6Aupz1iOgU8snmE1/92ZD2s0NsADUvfPOD76h+VT/e4D7jU3N0bF0IUA7kKxIYOHcrGjRvZu3cvf//9N3FxcXh5eVGpUiWef/55+vTp4zTf6JFHHuHKlSssWbKEadOmUbZsWYYNG4ZOp3PbO5FfDAYDn376KbNnz2bDhg389ttv+Pj40KJFC5555hkqVqx4y2VfuHDB0ROU+cG/6VavXu20kt8LL7xA2bJlWbp0KR9++CH+/v6OByjn5EHZuT2eV199lQ8//JBZs2aRnJxMWFhYrgMxsPeKLVq0iLlz5/Lbb7+xbNkyfHx8CAsLo2vXrjRu3DjXZeZUt27dKF++PAsXLmT58uUkJCQQGBhIhQoVGDlypGPlID8/P6ZPn86nn37K999/j81mo2bNmnzyySesWrXKJRB7+OGHOXz4ML/88gsbNmxAVVW+/PJLgoKCqFevHhEREcyZM4dPPvmEUqVK0bNnT2rXrs3IkSNz1f7x48fTqFEjVqxYwbx587BYLAQHB1OzZk1GjRrlyNe7d282bNjA8uXLiY+Px9/fn2rVqjF27FjHUEUhhCgOYtNcoxoFWPGontbl3Ac1B65oLHCzQLMGpNkUTG6ualJtORwSpdmXj9dnEQ/FZjGMMtADZj6kI9Az+3q+P6LyzIase7183S+oLETxICMT3VK0O3WNbCGEEEIUW/suazRaYMOW4Spk6L0w6+Gs7xG/8buND9wMZ+xQUeHnXvrri3XMBWDw4MEYjUY0TaPOPJvT3LIAk30ooiVDXNSzmsLSR7PuEovYZmNCphUev2ivY+A9Ct7Gm19ldllu48eT7i+5fI1warieEHmQsyimlInu72Ro79z+om5FmfSDCyGEEKLA1SulsLSbjvqloIwvjK6v8Gm7bMYGAhcSXNN0CizqlPXljKIorO2u57GqCqW87UHbb/30rO2ho2kYhPrA0HsVZnfM/pLorft1vNFUoZwf1A6GOQ/rGFlPl6MgDMDP5Jpm0kHLcPi5lwRhorhTsnjd3fJs1UQhhBBCiNx4rJqOx6rl/J6wQee+R+lmQUylQIUVmZahr1tSoUPF3NSt8F5LPe+1zPEuTp5roGP5cRvm6yvp6xVY11PHgxXknrgQdysJxIQQQghRJJhtrg+Ozm6BjTtJszIKf/XX8/V+FZsGQ+7V0TRMegTEXUI+6m5JICaEEEKIIiHIyzXNVoRmutcvrfDFQ0UkchRC5DvpDxdCCCFEkfBIJdfb6g9XlFvtQoiiSQIxIYQQQhQJHSvpGH+/gvf18TwPlIUZ7eVSRog7nqzV4ZYMTRRCCCFEkRHxgJ5XGmskWCDUR67khBBFlwRiQgghhChSfEwKPm6WgxdCiKJEAjEhhBBCCCFE/lGk99odGVgthBBCCCGEEAVMesSEEEIIIYQQ+Uc6xNySHjEhhBBCCCGEKGASiAkhhBBCCCFEAZOhiUIIIYQQQoj8I0MT3ZIeMSGEEEIIIYQoYNIjJoQQQgghhMhH0iXmjgRiQgghhBBCiPwjcZhbMjRRCCGEEEIIIQqYBGJCCCGEEEIIUcAkEBNCCCGEEEKIAiZzxIQQQgghhBD5R+aIuSU9YkIIIYQQQghRwCQQE0IIIYQQQogCJkMThRBCCCGEEPlHhia6JT1iQgghhBBCCFHAJBATQgghhBBC3DEiIiLw9fUt7GbkOxmaKIQQQgghhMg/ioxNdEd6xIQQQgghhBCigEkgJoQQQgghhMg/ShavW/Tvv//SsWNHfH198ff359FHH+XEiROO7UOHDqVVq1aO97Gxseh0Oho0aOBIS0lJwcPDg4ULF956Q26TDE0UQuSYpmkkJCQUdjOEEMIti8VCSkoKAPHx8RiNxkJukRB3Fj8/P5QiPkzw3LlztGzZkooVK/LNN99gs9kYP348LVu2ZP/+/ZQsWZJWrVqxaNEiUlNT8fT05Pfff8fDw4N//vmHa9euERgYyPbt2zGbzU4BW0GTQEwIkWMJCQkEBAQUdjOEEOKmnn/++cJughB3nLi4OPz9/Qu8Xu3lvAs5pk2bhtls5pdffqFkyZIANG3alGrVqvH5558TERFBq1atSEtL46+//qJNmzb89ttvdOvWjS1btvDHH3/QpUsXfvvtNypUqED58uXzrG25JYGYECLH/Pz8iIuLK+xmFIjExEQ6d+7Mjz/+eFes3CTHW3zdTccKcrzF3d10vPlxrH5+fnlSTmH6/fffadeunSMIA6hQoQLNmzfn999/B6BSpUqUK1eOrVu3OgKxQYMGoaoqW7dudQRihdkbBhKICSFyQVGUQrmTVhh0Oh16vR5/f/9i/8ce5HiLs7vpWEGOt7i7m473bjrW3IiNjaVevXou6aGhoRw9etTxvlWrVvz2228kJiayd+9e5syZg81mY+HChVgsFv766y8+++yzAmy5K1msQwghhBBCCFEkBAUFcenSJZf0qKgogoKCHO9btWrF9u3b2bJlCwEBAdxzzz20atWKPXv2sHnzZlJSUgq9R0wCMSGEEEIIIUSR0KJFC3799VeuXr3qSDt37hx//vknLVu2dKS1atWKlJQUpkyZQsuWLVEUhbp16+Ln58f7779PaGgo1apVK4xDcJChiUII4YbJZGL48OGYTKbCbkqBkOMtvu6mYwU53uLubjreu+lY3bHZbCxdutQl/bnnnmPu3Ll06NCBN99807FqYlBQEKNGjXLkq1mzJqVKlWLr1q1MnToVsE+xaNGiBWvWrKFPnz4FdixZUTRN0wq7EUIIIYQQQggBEBERwYQJE9xumzt3Lg0bNuTll1/mjz/+QKfT0bZtWz766COXHq7evXuzdOlSdu3aRcOGDQH46KOPePnll5k+fbpT4FYYJBATQgghhBBCiAImc8SEEEIIIYQQooBJICaEEEIIIYQQBUwW6xBCiBywWq0sXLiQNWvWOJbIbd26Nc8880yxeEBmZqmpqcyePZv169dz9epVQkJC6Nq1K08//XRhNy1fHT58mIEDB+Lh4eF4MGhxkv4MnW3btnHy5ElsNhtVq1Zl+PDhNGnSpLCbd1vOnDnDlClT2Lt3L15eXjz88MOMHj0aT0/Pwm5antu4cSPr16/nyJEjxMXFER4eTq9evejRowc6XfG+x56cnEyvXr24fPky8+fPp3bt2oXdpHyzcuVKvv/+e86cOYOPjw916tRh2rRphd0skYckEBNCiByYNWsWc+fO5ZlnnqFu3bqcOnWKzz//nAsXLhS7P4w2m40XXniBS5cuMWLECMLCwoiKiiIqKqqwm5avNE1j0qRJlChRguTk5MJuTr5IS0tj7ty5dOnShaeeegqDwcCaNWsYNWoUU6dOdVr6uShJSEhg5MiRhIaGMmnSJGJiYpg2bRpxcXG8++67hd28PLdw4ULCwsIYO3YswcHB7Nq1i8mTJ3PhwgWee+65wm5evpo1axY2m62wm5HvZs6cyeLFixkyZAh16tQhPj6eP//8s7CbJfKYBGJCCJEDP/30Ex07dmTIkCEANGrUiOTkZD7//HNSUlLw8vIq5BbmnVWrVnHkyBGWLl1KcHBwYTenwKxevZpr167RrVs3vvvuu8JuTr7w8PBg9erV+Pv7O9KaNWvG2bNnWbhwYZENxJYtW0Z8fDyLFy8mMDAQAIPBwFtvvcWQIUOoVKlS4TYwj02bNo0SJUo43qd/Hy1ZsoSRI0cW2+XOT58+zQ8//MDzzz/PBx98UNjNyTenTp1izpw5fPLJJzRr1syR3rZt20JslcgPxbv/Wggh8ojVasXX19cpzc/PD03TKG6Lz65atYr27dvfVUFYQkIC06dP58UXX8RgKL73KPV6vVMQBvbn6lSvXp0rV64UUqtu359//kmTJk0cQRhAu3btMJlMbNu2rfAalk8yBmHpatSoQVpaGvHx8YXQooIxefJkevbsSYUKFQq7KflqzZo1lC1b1ikIE8WTBGJCCJEDPXr0YN26dfz9998kJydz6NAhFi5cSJcuXfD29i7s5uUZi8XCkSNHKF26NG+//TYPPPAArVu35s033+TatWuF3bx888UXX1CrVq0i2yN0O1RVZf/+/UW61+jUqVMu7TeZTISHh3Pq1KlCalXB2rdvHwEBAW6DtOJg48aNHD9+nGHDhhV2U/Ldv//+S5UqVZg1axYPPfQQzZo14+mnn+bo0aOF3TSRx4rvbT8hhMhDQ4YMwWq1Mnr0aEcPWNu2bXnzzTcLuWV5Ky4uDpvNxvz582nYsCEfffQR0dHRfPLJJ7zxxht88cUXhd3EPHf06FFWr17NokWLCrsphSJ9MYA33nijsJtyy+Lj490umuPn51ese4jSHTp0iNWrVzN8+HD0en1hNyfPpaamMm3aNEaNGuUyMqE4io6O5siRI5w8eZLXX38do9HI119/zahRo1ixYkWxXCDqbiWBmBDirpSYmEh0dPRN85UpUwaTycT333/P4sWLef7556lVqxZnzpzhyy+/5N1332XChAkF0OJbl5tjVVUVsF/ATpo0CaPRCIC3tzevvvoq//77L3Xq1MnX9t6u3Byv0Whk0qRJ9OrVi4oVK+Z/4/JBbj/LGe3evZtPP/2UJ598kgYNGuRXEwtNcRs27E50dDSvvvoq99xzD4MGDSrs5uSL2bNnExwcTNeuXQu7KQVC0zSSk5OZNGkSVapUAaBWrVp069aN5cuXM3DgwEJuocgrEogJIe5KmzdvzlEAtWjRIkqXLs0nn3zC2LFj6du3LwANGjSgRIkSvPzyy/Tr14+aNWvmd5NvWW6ONX3uRd26dR1BGEDjxo0BOHny5B0fiOXmeE+fPs2pU6f4v//7PxISEgAwm82Afd6YyWTCw8MjX9t7u3JzvDVq1HC8P378OC+99BJt2rRh7Nix+dnEfOfv7+/4+WWUmJhYpIdc3kxiYiJjx47F09OTqVOnFsv5jZGRkSxcuJDJkyeTlJQEQEpKCmBfyj45OblYDQ8H++c5ODjYEYQBhISEULFiRU6ePFmILRN5rfj9xgohRA507do1x3dX//33X8xmM9WrV3dKT7+oPX/+/B0diOXmWAHCwsKy3FYUnlGUm+PdsmUL8fHxbvO3bduWgQMHMmbMmLxuYp7K7c8X7J/Z0aNHU7NmTSZOnIiiKPnUuoJRqVIll7lgZrOZ8+fP061bt0JqVf5KS0vjxRdfJCYmhrlz5zotVFKcXLhwAYvFwvPPP++ybcSIEdSpU4d58+YVeLvyU6VKldw+LkTTtCLxHSxyTgIxIYS4ifTA5PDhw07Dtw4dOuS0vbho0aIFW7duxWw2O4ay/f333wBUq1atMJuW57p27UrDhg2d0tauXcuGDRv45JNPCA0NLaSW5Z/o6GhGjRpFcHAwU6ZMcer5LKqaN2/O7NmzuXbtmiMg2bx5M2azmQceeKBwG5cPrFYr48aN49ixY3z99dfF7jsooxo1avDll186pR07doypU6fy+uuvc8899xRSy/JPixYtWLt2LSdOnKBq1aoAXL58mdOnT981wzPvFhKICSHETQQHB9OuXTtmzpyJzWajdu3anD59mpkzZ1K3bl1q1apV2E3MUwMGDGD9+vW8/PLLPP7441y5coXp06fTpk0bp6FtxUGZMmUoU6aMU9ru3bvR6XQ0atSokFqVf1JTUxk7diyxsbG88MILLr1I9957byG17Pb07NmTJUuW8NJLLzFs2DDHA50feeSRYjk08cMPP+T3339n7NixpKamcuDAAce2SpUqFasFLfz8/LL8XaxVq9YdPRrhVrVt25aaNWvy6quvMnLkSMdiHSVKlKB79+6F3TyRhxTtbpjJKoQQtykpKYnZs2ezefNmLl++THBwMPfffz8jRowolstFHz58mGnTpnHw4EE8PT1p164dzz//PD4+PoXdtHw3c+ZMFi5cyO+//17YTclzFy9ezHao3q5duwqwNXnrzJkzTJ48mX379uHp6cnDDz/MmDFj8PT0LOym5bmuXbsSGRnpdtuXX35ZLG8iZLRr1y5GjBjB/PnzqV27dmE3J1/ExMQwdepU/vjjD6xWKw0aNODFF18ssosKCfckEBNCCCGEEEKIAiYz/oQQQgghhBCigEkgJoQQQgghhBAFTAIxIYQQQgghhChgEogJIYQQQgghRAGTQEwIIYQQQgghCpgEYkIIIYQQQghRwCQQE0IIIYQQQogCJoGYEEIIIYQQQhQwCcSEEELckSIiIlAUhdOnTxd2U7h8+TIBAQF89dVXjrTTp0+jKAoRERGF1zBxx6hYsSJt2rS55f3btGlDxYoV86w9xcXo0aOpVasWVqu1sJsiRJ6TQEwIIQrQ5cuXefXVV6lTpw5+fn4EBARQrVo1+vbty/Lly53ytmnTBk9PzyzLmjJlCoqisGXLFrfb4+Li8Pb2RlEU5s2bl2U5FStWRFEUx8tkMlGxYkWGDRvGuXPnbuUwi523336boKAgBg8eXNhNKTARERGsXLmysJshCtC+ffuIiIgo8JsfW7ZsISIigmvXrrlse+ONNzh9+jRffvllgbZJiIIggZgQQhSQc+fOUbduXT7//HOaN2/O//73P95//326dOnCnj17mDNnTp7Wt3jxYlJTU6lSpQqzZ8/ONm9YWBgLFixgwYIFfPLJJzRt2pQ5c+bQtGlToqOj87RdRc2FCxeYM2cOo0aNwmg0OtIrVKhASkoKb731ViG2Lv9MmDBBArG7zL59+5gwYUKhBGITJkxwG4iVKVOGxx9/nPfff196xUSxYyjsBgghxN1i8uTJXLp0idWrV9O1a1enbdOmTeP8+fN5Wt/s2bNp1aoVjz/+OM8++yxHjx6lRo0abvP6+/vz5JNPOt6PHDmSUqVKMX36dObMmcOrr76ap20rSr766is0TeOJJ55wSlcUJdseSyFE3njqqaf45ptvWLlyJb169Srs5giRZ6RHTAghCsixY8cAaNu2rdvt4eHheVbX/v372b17N4MGDaJfv354eHjkusft4YcfBuC///7LMs/69etRFIWpU6e63d6yZUuCg4Mxm80A7Nixg0GDBlG9enW8vb3x8/PjgQceYMWKFTlq06BBg1AUxe02RVEYNGiQS/r3339PixYt8PPzw9vbm6ZNm7J06dIc1QewZMkS6tWrR1hYmFO6uzliGdPS9/Py8qJq1arMnTsXgLNnz9KrVy+CgoLw8/Ojf//+xMXFuT3OK1euMGDAAIKDg/H29qZdu3bs3r3bpY1ffPEFHTp0oGzZsphMJsLCwnjyySez7NnYvHkznTt3Jjg4GE9PTypXrszQoUOJjo5my5YtjnP8zTffOIas5mT+0tWrVxk7dizly5fHZDJRpkwZhg0bRmRkpFO+9DrmzZvHrFmzqF27Nh4eHlSoUIFJkybdtB7Iu3MN8O+//9KzZ09CQkLw8PCgRo0aTJw4kbS0NJe8hw8fpnPnzvj6+hIYGMijjz7KyZMns2znxo0b6dChA4GBgXh6elK3bt08GWY3d+5cGjVq5Pg9atu2Lb/88otLvqx+L+bNm+c0tHnQoEGOobdt27Z1/NzTP9/pczYPHjzI2LFjCQ0NxdPTkyZNmrBhwwansrObP5l57mebNm2YMGECAJUqVXLUm3E4dZs2bfDx8eH777/P3UkS4g4nPWJCCFFAKleuDMDXX3/N888/n2VAkVlWQwOTk5Oz3GfWrFn4+PjQq1cvfH196datG/Pnz+e9997DYMjZV//x48cBCAkJyTJPhw4dCAsLY/78+bz44otO206dOsW2bdsYOXIkJpMJgBUrVnDs2DH69etHeHg4V69e5ZtvvqFHjx4sWrSI/v3756htOfXWW2/x3nvv0bFjR9599130ej0rVqygd+/eTJ8+nVGjRmW7/+XLlzly5AjPPvtsrupdu3YtM2fOZOTIkQQFBTFnzhyGDBmC0Wjkrbfe4sEHH+T9999n586dzJkzB09PT7eBcseOHQkKCiIiIoKoqCimT59O69at+fPPP6lbt64j30cffUTz5s156KGHCAwM5N9//2XWrFls2rSJAwcOEBwc7Mib3q5y5crx7LPPUr58ec6ePcuaNWs4f/48tWrVYsGCBTz11FO0bNmSp59+GgBfX99sjzk+Pp4WLVpw9OhRBg4cSJMmTfj333+ZOXMmv/zyCzt37qR06dJO+8yYMYPLly8zbNgwAgICWLhwIa+99hrh4eE5/izc7rnes2cPrVq1QqfTMWrUKMLDw/n5558ZP34827dv58cff0Sns9+3PnXqFC1atCA5OZlnn32WypUr8+uvv9K2bVu3v49fffUVI0aMoFmzZrz55pv4+vqyYcMGRo4cyX///cfkyZNzdIyZvfHGG3zwwQc0bNiQd999l9TUVGbPnk3Hjh1ZsGCBS+9tTjzzzDN4eHjw1Vdf8cYbb1CrVi0Ap88ZwIABA9Dr9bz22mskJCQwc+ZMHnnkEdatW0eHDh1yXe+bb75JUFAQK1asYNq0aY7vm+bNmzvy6PV6GjduzNatW9E0LcffnULc8TQhhBAF4r///tP8/f01QCtXrpzWv39/bdq0adquXbvc5m/durUG3PS1efNmp/1SU1O1oKAgbcCAAY60H3/8UQO0VatWudRToUIFrWrVqtqVK1e0K1euaCdPntTmzJmjBQQEaHq9Xvvnn3+yPa6XX35ZA1zyRUREaID2999/O9ISExNd9k9KStKqV6+u1apVyyl9/PjxGqCdOnXKkTZw4EAtqz9dgDZw4EDH+127dmmANm7cOJe8jz76qObn56fFx8dne2ybNm3SAO2jjz5y2Xbq1CkN0MaPH++S5uPjo509e9aRfuXKFc3T01NTFEX7+OOPncrp3r27ZjAYtISEBJfj7N69u6aqqtMxKYqitW/f3qkMd+d148aNGqB9+OGHjrRz585pJpNJq127thYXF+eyj81mc/w/8/m8mTfffFMDXI5v4cKFGqANHz7ckbZ582YN0MLCwrTY2FhHelJSkhYSEqI1a9bspvXl1bl+4IEHNJ1Op+3evdsp7/DhwzVAW7RokSOtX79+GqCtX7/eKe+oUaM0QGvdurUj7eLFi5qHh4fWt29fl7aPHTtW0+l02okTJxxprVu31ipUqHDT4z569KimKIrWtGlTLTU11ZEeHR2thYaGaiVKlHD6PGT1c5w7d67L94e7tHTpv49NmjTR0tLSHOnnzp3TfHx8tGrVqjk+q+5+NzKXk/H32l1aZkOHDtUALSoqKss8QhQ1MjRRCCEKSOXKlfnnn3949tlnUVWVxYsX88ILL9CoUSPq1q3rdsiZ0Whkw4YNbl/pPRWZrVixgpiYGKfhSA8//DBhYWFZLtpx4sQJSpYsScmSJalcuTJDhgyhRIkSLFu2zOWOeGYDBw4EYP78+U7pCxcupGbNmjRp0sSR5uPj4/h/cnIyV69eJTk5mXbt2nH48GHi4+OzrSs3Fi9eDNjv4EdHRzu9unXrRkJCAtu3b8+2jCtXrgAQFBSUq7ofe+wxypUr53gfEhJC9erV0el0jBgxwilvy5YtsVqtbocRvvrqq053/xs2bMhDDz3Epk2bnM5V+nlVVZW4uDiio6O57777CAgI4O+//3bk++GHHzCbzbz99tv4+/u71Jfe83MrVqxYQVBQkEvvYf/+/alatarb4aeDBw8mMDDQ8d7b25tmzZo5emNz4nbO9ZUrV9i2bRudO3emQYMGTnnffvttAMdqpqqqsmbNGu677z46duzolPeNN95wadfSpUtJS0tj8ODBLp+/rl27oqoqv/76a46PM92qVavQNI1XX30VDw8PR3pwcDDPPvsssbGxbN68Odfl5tQLL7zg6OEG+5DqJ554guPHj3Pw4MF8qze9V/fy5cv5VocQBU2GJgohRAGqWLEin3/+OZ9//jmRkZFs376db775htWrV9OlSxcOHjzodNGv0+lo376927L27dvnNn327NmULFmS8PBwTpw44Uh/6KGHWLx4MVFRUYSGhjrtU65cOcdwrfQ5RlWrVs3REKA6depQv359Fi9ezIcffoher2fbtm2cOHGCDz74wCnv5cuXeeutt1i1apXbC6pr1665DRBuxeHDhwGoXbt2lnkuXbqUbRnpx69pWq7qrlSpkktaiRIlCAsLc7p4Tk8H+/yqzNKHh2VUu3ZtfvnlF06dOsV9990HwKZNm5g4cSJ///03qampTvljY2Md/08PcNL3y0snT56kXr16TitLgv0c3nPPPaxatYr4+Hinn2/6cN2MgoOD3Z6LrNzOuU6f23XPPfe4lFGuXDkCAgIceS5fvkxiYqLbn0mZMmUICAhwSkv//KXPtXTnZp8/d7Jr87333uuUJz9k9ZkE+3zSOnXq5Eu96b+DMixRFCcSiAkhRCEJCwujR48e9OjRg/79+/Ptt9+ybt06p9ULc+v06dP8+uuvaJpG9erV3eb55ptveO2115zSvL29swz4cmLgwIE8//zzbNiwgY4dOzJ//nx0Op3TsaiqykMPPcSRI0cYO3YsjRs3JiAgAL1ez9y5c1m8eDGqqmZbT1YXYe6WtU6/cFu3bp1LcJDO3cVsRiVLlgScg5mc0Ov1uUqHnAd7mS9Id+zYQYcOHahatSr/+9//qFSpEl5eXiiKQt++fZ3OaW4DyrySVb3ZnY+cup1zfSvnI6eBQHrZc+fOzXIhHneBaE7Lze22zG51KXh3x5/5M5ndObrVemNiYoAbv5NCFAcSiAkhxB3g/vvv59tvv+XChQu3Vc7cuXPRNI2ZM2e6HU43ceJE5syZ4xKI3a7+/fvzyiuvMH/+fNq2bcuSJUto166d0wXogQMH2L9/P++8845jlbR0s2bNylE96ccUExPjdHzuegCqV6/OTz/9RHh4uKOnILfuueceFEVx6lksSIcPH6ZZs2YuaTqdzrGK4bfffovNZmP9+vVOvUNJSUkuAWT64wv27dvntmfjdlSuXJljx45hsVhcAt9Dhw4REhKSZ72deaVKlSoAbofUnT9/nri4OEeeUqVK4evry6FDh1zyXrx40WU1xvQbIcHBwbd1kyO7Nmd+HEX6caTnAfvvTHoQk5G735mcBJmHDh1yGa6c3vuXHlhm/D3Nq3rTh0+XKlXqpnmFKCpkjpgQQhSQzZs3k5KS4pKePvcEsh9GdzOqqjJv3jxq167N008/Ta9evVxeTzzxBMeOHeOPP/645XrcKVmyJI888ggrV65k0aJFXLt2zTF3LF16D0Xmu/b//vtvjpevT7+43bhxo1P6Rx995JI3vTfujTfecHsXPidzTUqWLEnt2rXZsWNHjtqX1yZNmuR0vvbs2cPGjRtp166dI6jJ6ry+//77Lj2MvXr1wmQy8X//939u5+NlLMPX1zdXPYHdu3cnJiaGmTNnOqV/9913nDhxgh49euS4rIJSsmRJHnjgAdatW+cy1Pe9994DcLRbp9PRrVs3/vnnH3766SenvO+//75L2b1798bDw4OIiAi3KyrGxcW5XR7/Zh577DEURWHKlCmOx0KAPej54osvKFGiBG3atHGkV69ene3btzu1ITY21rHEf0bpK2Nm93OfNm2aU73nz59n8eLFVK9e3dHD7OfnR2hoKJs2bXL6TJ08edLtQ8JvVq/NZmPXrl20atVKhiaKYkV6xIQQooB89NFHbNu2jS5dutCwYUMCAgKIiopi2bJl7N69m7Zt29K5c+dbLn/Dhg2cPXuWd955J8s8PXv2ZNy4ccyePZsWLVrccl3uDBw4kNWrV/PCCy/g6+vrcuFdq1Yt7rnnHiZNmkRycjI1atTg2LFjzJw5kzp16rBnz56b1tGvXz/eeOMNnn76aY4cOUJwcDDr1693u8R/48aNmTBhAuPHj6devXr06dOHMmXKEBkZye7du1m3bp3TBWVWevfuzbvvvktkZKTLs8Ty25kzZ3j44Yfp1q0bkZGRTJ8+HS8vL6fAs3v37kybNo1OnTrx9NNPYzKZ2LBhA/v373d59EB4eDgff/wxo0aN4t5772XAgAFUqFCBCxcusGrVKubMmUO9evUAaNq0KRs3bmTy5MmUK1cOHx8flweRZ/Tqq6+ydOlSxo4dy969e2ncuLFj+frw8HAmTpyYL+fodn366ae0atWK1q1bM2rUKMqWLcsvv/zC6tWrefjhh3n88ccdef/v//6Pn376ie7duzNq1CjH8vW7du1ye65nzJjBsGHDqFWrluNcX7lyhQMHDrBy5UoOHTqUo+ezZVStWjXGjRvHBx98wAMPPEC/fv0cy9dHRUUxf/58p0VxRo8ezZNPPkm7du146qmnuHbtGl9//TUVKlQgKirKqexGjRqh0+n44IMPiI2Nxdvbmzp16jjN+7JarbRs2ZJ+/fqRkJDAl19+SUpKCp999plTkDR69GjeeustHnnkER577DEuXrzIl19+SZ06ddi5c6dTvU2bNgXg9ddfdzz3sGnTpo4e3i1btpCUlESfPn1yda6EuOMV6BqNQghxF9u+fbv24osvao0aNdJKlSqlGQwGLSAgQGvWrJn20UcfOS1FrWn25aw9PDyyLG/y5MlOS0337t1bA7T9+/dn2466detqPj4+jqXbK1SooNWoUeP2Dk7TtLS0NC0oKEgDtEGDBrnNc/r0aa1Xr15aSEiI5uXlpTVu3Fhbvnx5rpa0/uuvv7TmzZtrHh4eWnBwsDZ8+HAtNjY2y2W6165dq3Xo0EErUaKEZjKZtPDwcK1jx47aF198kaPjunDhgmYwGLQpU6Y4pWe3fL27ZbuzWp7c3ZLh6cvXX758WXvyySe1oKAgzcvLS2vbtq3bxx2sWLFCa9Cggebt7a0FBwdrjz/+uHbmzBmtQoUKTkuqp/v555+19u3ba/7+/pqHh4dWqVIlbdiwYVp0dLQjz5EjR7R27dppvr6+GpCjpdWjo6O10aNHa+Hh4ZrRaNRCQ0O1oUOHahcuXHDKl758/dy5c13KyO4RBRnl1bnWNE07cOCA1r17dy0oKEgzGo1atWrVtIiICJffSU3TtEOHDmmdOnXSfHx8NH9/f61bt27af//9l+W5/uOPP7THHntMK1mypGY0GrWwsDCtTZs22pQpU7SUlJSbtjkrs2fP1ho0aKB5enpqPj4+WuvWrbWffvrJbd5JkyZp5cuX10wmk1azZk1t9uzZWZ6L2bNna9WrV9cMBoPT+U3/ffz333+10aNHa6VLl9Y8PDy0xo0ba7/88otLnRaLRXvllVe00NBQzcPDQ6tfv762evXqLH+v33vvPa18+fKaXq93+WwMHDhQCw0N1cxmc47PjxBFgaJphTRzVwghhCgiRowYwS+//MLRo0ezXPgjLw0aNIhvvvmm0BbXECKziIgIJkyYwKlTp3Ldi3c7IiMjqVKlCh9++CFjxowpsHqFKAgyR0wIIYS4iYkTJ3L16lW382qEEPnn/fffp0KFCowcObKwmyJEnpM5YkIIIcRNlCpVymVVPCFE/vvss88KuwlC5BvpERNCCCGEEEKIAiZzxIQQQgghhBCigEmPmBBCCCGEEEIUMAnEhBBCCCGEEKKASSAmhBBCCCGEEAVMAjEhhBBCCCGEKGASiAkhhBBCCCFEAZNATAghhBBCCCEKmARiQgghhBBCCFHAJBATQgghhBBCiAL2/yfyjCJpsrPEAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "shap.plots.beeswarm(shap_values)\n", + "\n", + "# coord_x, dmc, temp" + ] }, { "cell_type": "markdown", @@ -423,7 +730,7 @@ ], "metadata": { "kernelspec": { - "display_name": "env", + "display_name": "dsi_participant", "language": "python", "name": "python3" }, @@ -437,7 +744,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.13.5" } }, "nbformat": 4,