From 79800ddb17c427288ed87603bce2b487ad42e367 Mon Sep 17 00:00:00 2001 From: Petra Vidnerova Date: Sun, 10 Nov 2024 14:08:05 +0100 Subject: [PATCH] visualization fixed transformation changed --- lessons/pydata/homework_revisited/index.ipynb | 362 ++++++++++-------- 1 file changed, 203 insertions(+), 159 deletions(-) diff --git a/lessons/pydata/homework_revisited/index.ipynb b/lessons/pydata/homework_revisited/index.ipynb index fc82691..7923668 100644 --- a/lessons/pydata/homework_revisited/index.ipynb +++ b/lessons/pydata/homework_revisited/index.ipynb @@ -19,6 +19,17 @@ "np.random.seed(42)" ] }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "from sklearn.exceptions import ConvergenceWarning\n", + "warnings.filterwarnings(\"ignore\", category=ConvergenceWarning)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -28,7 +39,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -194,7 +205,7 @@ "[123 rows x 7 columns]" ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -216,7 +227,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -235,7 +246,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -254,7 +265,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -278,73 +289,83 @@ " \n", " \n", " \n", - " Length1\n", - " Length2\n", - " Length3\n", - " Height\n", - " Width\n", - " Species_Bream\n", - " Species_Parkki\n", - " Species_Perch\n", - " Species_Pike\n", - " Species_Roach\n", - " Species_Smelt\n", - " Species_Whitefish\n", + " onehotencoder__Species_Bream\n", + " onehotencoder__Species_Parkki\n", + " onehotencoder__Species_Perch\n", + " onehotencoder__Species_Pike\n", + " onehotencoder__Species_Roach\n", + " onehotencoder__Species_Smelt\n", + " onehotencoder__Species_Whitefish\n", + " remainder__Length1\n", + " remainder__Length2\n", + " remainder__Length3\n", + " remainder__Height\n", + " remainder__Width\n", " \n", " \n", " \n", " \n", - " 11\n", + " 0\n", + " 1.0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", " 28.7\n", " 31.0\n", " 36.2\n", " 14.3714\n", " 4.8146\n", - " 1.0\n", + " \n", + " \n", + " 1\n", " 0.0\n", " 0.0\n", " 0.0\n", " 0.0\n", + " 1.0\n", " 0.0\n", " 0.0\n", - " \n", - " \n", - " 45\n", " 20.5\n", " 22.5\n", " 25.3\n", " 7.0334\n", " 3.8203\n", + " \n", + " \n", + " 2\n", + " 1.0\n", " 0.0\n", " 0.0\n", " 0.0\n", " 0.0\n", - " 1.0\n", " 0.0\n", " 0.0\n", - " \n", - " \n", - " 26\n", " 32.0\n", " 35.0\n", " 40.6\n", " 16.3618\n", " 6.0900\n", - " 1.0\n", + " \n", + " \n", + " 3\n", " 0.0\n", " 0.0\n", + " 1.0\n", " 0.0\n", " 0.0\n", " 0.0\n", " 0.0\n", - " \n", - " \n", - " 87\n", " 20.0\n", " 22.0\n", " 23.5\n", " 5.6400\n", " 3.5250\n", + " \n", + " \n", + " 4\n", " 0.0\n", " 0.0\n", " 1.0\n", @@ -352,21 +373,11 @@ " 0.0\n", " 0.0\n", " 0.0\n", - " \n", - " \n", - " 74\n", " 13.8\n", " 15.0\n", " 16.0\n", " 3.8240\n", " 2.4320\n", - " 0.0\n", - " 0.0\n", - " 1.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", " \n", " \n", " ...\n", @@ -384,79 +395,79 @@ " ...\n", " \n", " \n", - " 123\n", + " 81\n", + " 0.0\n", + " 0.0\n", + " 1.0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", " 39.0\n", " 42.0\n", " 44.6\n", " 12.8002\n", " 6.8684\n", + " \n", + " \n", + " 82\n", + " 1.0\n", " 0.0\n", " 0.0\n", - " 1.0\n", " 0.0\n", " 0.0\n", " 0.0\n", " 0.0\n", - " \n", - " \n", - " 29\n", " 33.5\n", " 37.0\n", " 42.6\n", " 18.9570\n", " 6.6030\n", - " 1.0\n", + " \n", + " \n", + " 83\n", " 0.0\n", " 0.0\n", " 0.0\n", + " 1.0\n", " 0.0\n", " 0.0\n", " 0.0\n", - " \n", - " \n", - " 130\n", " 32.7\n", " 35.0\n", " 38.8\n", " 5.9364\n", " 4.3844\n", + " \n", + " \n", + " 84\n", " 0.0\n", " 0.0\n", " 0.0\n", - " 1.0\n", " 0.0\n", " 0.0\n", + " 1.0\n", " 0.0\n", - " \n", - " \n", - " 153\n", " 11.4\n", " 12.0\n", " 13.2\n", " 2.2044\n", " 1.1484\n", + " \n", + " \n", + " 85\n", " 0.0\n", " 0.0\n", + " 1.0\n", " 0.0\n", " 0.0\n", " 0.0\n", - " 1.0\n", " 0.0\n", - " \n", - " \n", - " 101\n", " 25.0\n", " 26.5\n", " 28.0\n", " 7.1680\n", " 4.1440\n", - " 0.0\n", - " 0.0\n", - " 1.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", - " 0.0\n", " \n", " \n", "\n", @@ -464,71 +475,94 @@ "" ], "text/plain": [ - " Length1 Length2 Length3 Height Width Species_Bream \\\n", - "11 28.7 31.0 36.2 14.3714 4.8146 1.0 \n", - "45 20.5 22.5 25.3 7.0334 3.8203 0.0 \n", - "26 32.0 35.0 40.6 16.3618 6.0900 1.0 \n", - "87 20.0 22.0 23.5 5.6400 3.5250 0.0 \n", - "74 13.8 15.0 16.0 3.8240 2.4320 0.0 \n", - ".. ... ... ... ... ... ... \n", - "123 39.0 42.0 44.6 12.8002 6.8684 0.0 \n", - "29 33.5 37.0 42.6 18.9570 6.6030 1.0 \n", - "130 32.7 35.0 38.8 5.9364 4.3844 0.0 \n", - "153 11.4 12.0 13.2 2.2044 1.1484 0.0 \n", - "101 25.0 26.5 28.0 7.1680 4.1440 0.0 \n", + " onehotencoder__Species_Bream onehotencoder__Species_Parkki \\\n", + "0 1.0 0.0 \n", + "1 0.0 0.0 \n", + "2 1.0 0.0 \n", + "3 0.0 0.0 \n", + "4 0.0 0.0 \n", + ".. ... ... \n", + "81 0.0 0.0 \n", + "82 1.0 0.0 \n", + "83 0.0 0.0 \n", + "84 0.0 0.0 \n", + "85 0.0 0.0 \n", + "\n", + " onehotencoder__Species_Perch onehotencoder__Species_Pike \\\n", + "0 0.0 0.0 \n", + "1 0.0 0.0 \n", + "2 0.0 0.0 \n", + "3 1.0 0.0 \n", + "4 1.0 0.0 \n", + ".. ... ... \n", + "81 1.0 0.0 \n", + "82 0.0 0.0 \n", + "83 0.0 1.0 \n", + "84 0.0 0.0 \n", + "85 1.0 0.0 \n", + "\n", + " onehotencoder__Species_Roach onehotencoder__Species_Smelt \\\n", + "0 0.0 0.0 \n", + "1 1.0 0.0 \n", + "2 0.0 0.0 \n", + "3 0.0 0.0 \n", + "4 0.0 0.0 \n", + ".. ... ... \n", + "81 0.0 0.0 \n", + "82 0.0 0.0 \n", + "83 0.0 0.0 \n", + "84 0.0 1.0 \n", + "85 0.0 0.0 \n", "\n", - " Species_Parkki Species_Perch Species_Pike Species_Roach \\\n", - "11 0.0 0.0 0.0 0.0 \n", - "45 0.0 0.0 0.0 1.0 \n", - "26 0.0 0.0 0.0 0.0 \n", - "87 0.0 1.0 0.0 0.0 \n", - "74 0.0 1.0 0.0 0.0 \n", - ".. ... ... ... ... \n", - "123 0.0 1.0 0.0 0.0 \n", - "29 0.0 0.0 0.0 0.0 \n", - "130 0.0 0.0 1.0 0.0 \n", - "153 0.0 0.0 0.0 0.0 \n", - "101 0.0 1.0 0.0 0.0 \n", + " onehotencoder__Species_Whitefish remainder__Length1 remainder__Length2 \\\n", + "0 0.0 28.7 31.0 \n", + "1 0.0 20.5 22.5 \n", + "2 0.0 32.0 35.0 \n", + "3 0.0 20.0 22.0 \n", + "4 0.0 13.8 15.0 \n", + ".. ... ... ... \n", + "81 0.0 39.0 42.0 \n", + "82 0.0 33.5 37.0 \n", + "83 0.0 32.7 35.0 \n", + "84 0.0 11.4 12.0 \n", + "85 0.0 25.0 26.5 \n", "\n", - " Species_Smelt Species_Whitefish \n", - "11 0.0 0.0 \n", - "45 0.0 0.0 \n", - "26 0.0 0.0 \n", - "87 0.0 0.0 \n", - "74 0.0 0.0 \n", - ".. ... ... \n", - "123 0.0 0.0 \n", - "29 0.0 0.0 \n", - "130 0.0 0.0 \n", - "153 1.0 0.0 \n", - "101 0.0 0.0 \n", + " remainder__Length3 remainder__Height remainder__Width \n", + "0 36.2 14.3714 4.8146 \n", + "1 25.3 7.0334 3.8203 \n", + "2 40.6 16.3618 6.0900 \n", + "3 23.5 5.6400 3.5250 \n", + "4 16.0 3.8240 2.4320 \n", + ".. ... ... ... \n", + "81 44.6 12.8002 6.8684 \n", + "82 42.6 18.9570 6.6030 \n", + "83 38.8 5.9364 4.3844 \n", + "84 13.2 2.2044 1.1484 \n", + "85 28.0 7.1680 4.1440 \n", "\n", "[86 rows x 12 columns]" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sklearn.preprocessing import OneHotEncoder\n", + "from sklearn.compose import make_column_transformer\n", "\n", "categorical_columns = [\"Species\"] \n", "\n", - "encoder = OneHotEncoder()\n", - "encoder.fit(X_train_raw[categorical_columns])\n", - "column_names = encoder.get_feature_names_out()\n", - " \n", - "def transform_species(X_raw):\n", - " X_res = X_raw.drop(columns=[\"Species\"])\n", - " X_res = X_res.reindex(columns=list(X_res.columns)+list(column_names))\n", - " X_res[list(column_names)] = encoder.transform(X_raw[categorical_columns]).toarray() \n", - " return X_res\n", + "transformer = make_column_transformer(\n", + " (OneHotEncoder(sparse_output=False), [\"Species\"]),\n", + " remainder=\"passthrough\"\n", + ")\n", "\n", - "X_train_onehot = transform_species(X_train_raw)\n", - "X_test_onehot = transform_species(X_test_raw)\n", - "X_train_onehot" + "X_train_onehot = transformer.fit_transform(X_train_raw)\n", + "X_test_onehot = transformer.transform(X_test_raw)\n", + "\n", + "pd.DataFrame(X_train_onehot, columns=transformer.get_feature_names_out())" ] }, { @@ -540,7 +574,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -590,7 +624,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -600,7 +634,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -631,7 +665,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -658,19 +692,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/petra/pydata-course/podzim_2022/venv/lib/python3.9/site-packages/sklearn/linear_model/_coordinate_descent.py:648: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations, check the scale of the features or consider increasing regularisation. Duality gap: 1.667e+03, tolerance: 1.127e+03\n", - " model = cd_fast.enet_coordinate_descent(\n", - "/home/petra/pydata-course/podzim_2022/venv/lib/python3.9/site-packages/sklearn/linear_model/_coordinate_descent.py:648: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations, check the scale of the features or consider increasing regularisation. Duality gap: 3.308e+05, tolerance: 1.127e+03\n", - " model = cd_fast.enet_coordinate_descent(\n" - ] - }, { "data": { "text/html": [ @@ -710,18 +734,18 @@ " \n", " \n", " 1\n", - " 65.457444\n", - " 7999.732745\n", - " 67.698824\n", - " 7481.296957\n", + " 65.461029\n", + " 8000.189809\n", + " 67.699174\n", + " 7481.774269\n", " lasso_var1\n", " \n", " \n", " 2\n", - " 65.143581\n", - " 7723.470509\n", - " 66.929641\n", - " 7734.792363\n", + " 65.162065\n", + " 7730.766645\n", + " 66.984117\n", + " 7743.530561\n", " lasso_var2\n", " \n", " \n", @@ -747,13 +771,13 @@ "text/plain": [ " MAE_train MSE_train MAE_test MSE_test model\n", "0 65.075967 7438.347512 64.076083 7327.508225 linear_regression\n", - "1 65.457444 7999.732745 67.698824 7481.296957 lasso_var1\n", - "2 65.143581 7723.470509 66.929641 7734.792363 lasso_var2\n", + "1 65.461029 8000.189809 67.699174 7481.774269 lasso_var1\n", + "2 65.162065 7730.766645 66.984117 7743.530561 lasso_var2\n", "3 14.885810 1083.558622 29.440300 1983.156024 SVR_rbf\n", "4 15.792914 1263.177350 37.137981 3351.282774 SVR_poly" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -778,7 +802,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -813,7 +837,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -823,13 +847,13 @@ "y_real_test = test_data.pop(\"Weight\")\n", "X_real_test = test_data \n", "\n", - "X_real_test = transform_species(X_real_test)\n", - "X_real_test_scaled = scaler.transform(X_real_test)" + "X_real_test_transformed = transformer.transform(X_real_test)\n", + "X_real_test_scaled = scaler.transform(X_real_test_transformed)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -837,7 +861,8 @@ "output_type": "stream", "text": [ "MAE 37.263\n", - "MSE 4050.929\n" + "MSE 4050.929\n", + "R2 0.972\n" ] } ], @@ -845,12 +870,13 @@ "y_pred_test = best_model.predict(X_real_test_scaled)\n", "\n", "print(f\"MAE {mean_absolute_error(y_real_test, y_pred_test):.3f}\")\n", - "print(f\"MSE {mean_squared_error(y_real_test, y_pred_test):.3f}\")" + "print(f\"MSE {mean_squared_error(y_real_test, y_pred_test):.3f}\")\n", + "print(f\"R2 {r2_score(y_real_test, y_pred_test):.3f}\")" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -917,17 +943,17 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ - "is_bream = X_real_test[\"Species_Bream\"] == 1 \n", + "is_bream = X_real_test[\"Species\"] == \"Bream\"\n", "bream = X_real_test[is_bream][\"Length3\"]\n", "\n", "bream_weights = y_real_test[is_bream]\n", "predicted_bream_weights = best_model.predict(X_real_test_scaled[is_bream])\n", "\n", - "is_roach = X_real_test[\"Species_Roach\"] == 1\n", + "is_roach = X_real_test[\"Species\"] == \"Roach\"\n", "roach = X_real_test[is_roach][\"Length3\"]\n", "roach_weights = y_real_test[is_roach]\n", "predicted_roach_weights = best_model.predict(X_real_test_scaled[is_roach])" @@ -935,12 +961,31 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "result_bream = pd.DataFrame()\n", + "result_bream[\"length\"] = bream\n", + "result_bream[\"weight\"] = bream_weights\n", + "result_bream[\"predicted\"] = predicted_bream_weights\n", + "result_bream = result_bream.sort_values(\"length\")\n", + "\n", + "result_roach = pd.DataFrame()\n", + "result_roach[\"length\"] = roach\n", + "result_roach[\"weight\"] = roach_weights\n", + "result_roach[\"predicted\"] = predicted_roach_weights\n", + "result_roach = result_roach.sort_values(\"length\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGzCAYAAAAFROyYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAABYgUlEQVR4nO3deVhTV94H8G8SVsWEokLABXEZMXWrG8bdSgXXOtJaHS22Wp2x0FatVu1bF7Qt6nSmVevgLI7oqO2oVYu2xbpirYjbYEUsVQeLCwGVIQEVxOS+f6TcEvYgkJvw/TzPfTT3nntzTpbDL+fcc45MEAQBRERERBIit3UGiIiIiEpjgEJERESSwwCFiIiIJIcBChEREUkOAxQiIiKSHAYoREREJDkMUIiIiEhyGKAQERGR5DBAISIiIslhgEJERA3GsWPHIJPJsGvXLltnharAAIXKiI2NhUwms9i8vb0xdOhQfPPNN7bOHhFJXOk6xMnJCS1atMArr7yCW7du2Tp7ZCecbJ0Bkq7ly5cjICAAgiAgKysLsbGxGDlyJPbt24fRo0fbOntEJHHFdUhBQQFOnTqF2NhYnDhxAikpKXBzc7N19kjiGKBQhUaMGIFevXqJj6dPnw4fHx989tlnFQYojx8/hslkgouLS31lk4gkqmQd8tprr6FZs2ZYtWoV4uLiMGHCBBvnjqSOXTxUbZ6ennB3d4eTkzmuvX79OmQyGT766CN88sknaNeuHVxdXZGamgoA+PHHH/HCCy/Ay8sLbm5u6NWrF+Li4iyumZOTg3nz5qFLly7w8PCAUqnEiBEjcOHCBYt0xf3GO3bsQFRUFFq0aIEmTZrghRdegF6vR2FhIWbPng1vb294eHjg1VdfRWFhYf28MERULQMHDgQAXLt2Tdx35MgRDBw4EI0bN4anpyeef/55XL582eK8n3/+Ga+//jo6duwId3d3NG3aFC+++CKuX79e5jlyc3MxZ84ctGnTBq6urmjZsiXCw8Nx9+5di3QmkwkffPABWrZsCTc3NwwbNgxXr16t/UJTjbEFhSqk1+tx9+5dCIKA7OxsrFu3Dvn5+ZgyZYpFuk2bNqGgoAAzZ86Eq6srvLy8cOnSJfTv3x8tWrTAwoUL0bhxY+zYsQPjxo3DF198gd/+9rcAgP/+97/Yu3cvXnzxRQQEBCArKwt//etfMXjwYKSmpsLPz8/iuaKjo+Hu7o6FCxfi6tWrWLduHZydnSGXy/G///0Py5YtE5uSAwICsGTJknp7vYiocsUBxVNPPQUAOHToEEaMGIG2bdti2bJlePjwIdatW4f+/fvj/PnzaNOmDQDgzJkzOHnyJCZOnIiWLVvi+vXriImJwZAhQ5CamopGjRoBAPLz8zFw4EBcvnwZ06ZNQ48ePXD37l3ExcXh5s2baNasmZiXlStXQi6XY968edDr9Vi9ejUmT56MpKSken1NqBICUSmbNm0SAJTZXF1dhdjYWDFdenq6AEBQKpVCdna2xTWGDRsmdOnSRSgoKBD3mUwmoV+/fkKHDh3EfQUFBYLRaLQ4Nz09XXB1dRWWL18u7jt69KgAQOjcubPw6NEjcf+kSZMEmUwmjBgxwuIaWq1W8Pf3f6LXgYhqprgOOXTokHDnzh3hxo0bwq5du4TmzZsLrq6uwo0bNwRBEITu3bsL3t7ewr1798RzL1y4IMjlciE8PFzc9+DBgzLPkZiYKAAQtmzZIu5bsmSJAEDYvXt3mfQmk0kQhF/rkk6dOgmFhYXi8TVr1ggAhIsXLz75C0C1gl08VKH169fj4MGDOHjwILZu3YqhQ4fitddew+7duy3ShYWFoXnz5uLjnJwcHDlyBBMmTEBeXh7u3r2Lu3fv4t69ewgJCcGVK1fEO/ldXV0hl5s/hkajEffu3YOHhwc6duyI8+fPl8lTeHg4nJ2dxcdBQUEQBAHTpk2zSBcUFIQbN27g8ePHtfZ6EJF1goOD0bx5c7Rq1QovvPACGjdujLi4OLRs2RKZmZlITk7GK6+8Ai8vL/Gcrl274rnnnsPXX38t7nN3dxf/X1RUhHv37qF9+/bw9PS0qCe++OILdOvWTWyhLUkmk1k8fvXVVy3ulSvufvrvf//75AWnWsEuHqpQnz59LG6SnTRpEp555hlERkZa3CQbEBBgcd7Vq1chCAIWL16MxYsXl3vt7OxstGjRAiaTCWvWrMFf/vIXpKenw2g0immaNm1a5rzWrVtbPFapVACAVq1aldlvMpmg1+vLvQ4R1b3169fjN7/5DfR6Pf75z3/i+PHjcHV1BWC+rwQAOnbsWOa8Tp064cCBA7h//z4aN26Mhw8fIjo6Gps2bcKtW7cgCIKYVq/Xi/+/du0awsLCqpW30nVJcbfT//73P+sKSXWGAQpVm1wux9ChQ7FmzRpcuXIFjRs3BmD56wYw33wGAPPmzUNISEi512rfvj0A4MMPP8TixYsxbdo0rFixAl5eXpDL5Zg9e7Z4nZIUCkW516tof8mKjIjqV8kfOePGjcOAAQPwu9/9DmlpaVZd54033sCmTZswe/ZsaLVaqFQqyGQyTJw4sdx6ojpYZ0gfAxSySnGXSX5+vhiglNa2bVsAgLOzM4KDgyu93q5duzB06FBs3LjRYn9ubq7FDW1EZN8UCgWio6MxdOhQfPrpp5g6dSoAlBus/Pjjj2jWrJlYx+zatQtTp07Fn/70JzFNQUEBcnNzLc5r164dUlJS6q4QVK94DwpVW1FREb799lu4uLigU6dOFabz9vbGkCFD8Ne//hWZmZlljt+5c0f8v0KhKPOLZefOnZxtksgBDRkyBH369MEnn3yCp556Ct27d8fmzZstAo2UlBR8++23GDlypLivvHpi3bp1Fl3CgPl+uAsXLmDPnj1lnpstI/aHLShUoW+++QY//vgjAPM9I9u3b8eVK1ewcOFCKJVK5OTkVHju+vXrMWDAAHTp0gUzZsxA27ZtkZWVhcTERNy8eVOc52T06NFYvnw5Xn31VfTr1w8XL17Etm3bxFYYInIs8+fPx4svvojY2Fj88Y9/xIgRI6DVajF9+nRxmLFKpcKyZcvEc0aPHo1//etfUKlU0Gg0SExMxKFDh8rcXzZ//nzs2rULL774IqZNm4aePXsiJycHcXFx2LBhA7p161bPpaUnwQCFKlRyDhE3NzcEBgYiJiYGv//976s8V6PR4OzZs4iKikJsbCzu3bsHb29vPPPMMxbXfffdd3H//n1s374d//73v9GjRw989dVXWLhwYZ2UiYhsa/z48WjXrh0++ugjpKWlIT4+HkuXLsWSJUvg7OyMwYMHY9WqVRY3369ZswYKhQLbtm1DQUEB+vfvj0OHDpW5x83DwwPfffcdli5dij179mDz5s3w9vbGsGHD0LJly/ouKj0hmcB2LyIiIpIY3oNCREREksMAhYiIiCSHAQoRERFJDgMUIiIikhwGKERERCQ5DFCIiIhIcuxyHhSTyYTbt2+jSZMmZVaoJKL6IQgC8vLy4OfnJ65ILXWsO4hsy5p6wy4DlNu3b5dZvZaIbOPGjRt2MwkW6w4iaahOvWGXAUqTJk0AmAuoVCptnBuihslgMKBVq1bi99EesO4gsi1r6g27DFCKm2aVSiUrGSIbs6euEtYdRNJQnXrDPjqOiYiIqEFhgEJERESSwwCFiIiIJMcu70GpDkEQ8PjxYxiNRltnheqZQqGAk5OTXd0bQdJhNBpRVFRk62yQDTg7O0OhUNg6G/QLhwxQHj16hMzMTDx48MDWWSEbadSoEXx9feHi4mLrrBCAmJgYxMTE4Pr16wCAp59+GkuWLMGIESMAAAUFBXj77bfx+eefo7CwECEhIfjLX/4CHx8f8RoZGRmYNWsWjh49Cg8PD0ydOhXR0dFwcqq9aiw/Px83b96EIAi1dk2yHzKZDC1btoSHh4ets0JwwADFZDIhPT0dCoUCfn5+cHFx4S/pBkQQBDx69Ah37txBeno6OnToYDeTiDmyli1bYuXKlejQoQMEQcDmzZvx/PPP4z//+Q+efvppzJkzB1999RV27twJlUqFyMhIjB8/Ht9//z0Ac6vGqFGjoFarcfLkSWRmZiI8PBzOzs748MMPayWPRqMRN2/eRKNGjdC8eXPWGw2MIAi4c+cObt68iQ4dOrAlRQoEO6TX6wUAgl6vL3Ps4cOHQmpqqnD//n0b5Iyk4v79+0Jqaqrw8OFDW2fFYVX2PayOp556SvjHP/4h5ObmCs7OzsLOnTvFY5cvXxYACImJiYIgCMLXX38tyOVyQafTiWliYmIEpVIpFBYW1kqei+uOBw8e1Kg8ZP8ePHjAeqOOWVNvOOxPS/5qbtj4/kuX0WjE559/jvv370Or1eLcuXMoKipCcHCwmCYwMBCtW7dGYmIiACAxMRFdunSx6PIJCQmBwWDApUuXKnyuwsJCGAwGi60qbDlpuPjeS4vDdfEQUc0YTQJOp+cgO68A3k3c0CfACwp57VXYFy9ehFarRUFBATw8PLBnzx5oNBokJyfDxcUFnp6eFul9fHyg0+kAADqdziI4KT5efKwi0dHRiIqKqrUyEFE5TEbg55NAfhbg4QP49wPkT95FxgCFiBCfkomofanI1BeI+3xVblg6RoPQzr618hwdO3ZEcnIy9Ho9du3ahalTpyIhIaFWrl2RRYsWYe7cueLj4mm2iaiWpMYB8QsAw+1f9yn9gNBVgGbsE12a7eBUZ2QyGfbu3Vvt9MeOHYNMJkNubm6d5YnKik/JxKyt5y2CEwDQ6Qswa+t5xKdk1srzuLi4oH379ujZsyeio6PRrVs3rFmzBmq1Go8ePSrzvmdlZUGtVgMA1Go1srKyyhwvPlYRV1dXcVp7Tm9vP1h32InUOGBHuGVwAgCGTPP+1LgnujwDFIkYMmQIZs+ebets1KrMzExxGGltWbZsGbp3716r12zIjCYBUftSUd6g2uJ9UftSYTTV/rBbk8mEwsJC9OzZE87Ozjh8+LB4LC0tDRkZGdBqtQAArVaLixcvIjs7W0xz8OBBKJVKaDSaWs+bPWHdUT2sO2qZyWhuOams9ohfaE5XQ+ziqUBd98fXhCAIMBqNtTrvQ12q7JctScPp9JwyLSclCQAy9QU4nZ4DbbumNX6eRYsWYcSIEWjdujXy8vKwfft2HDt2DAcOHIBKpcL06dMxd+5ceHl5QalU4o033oBWq0Xfvn0BAMOHD4dGo8HLL7+M1atXQ6fT4b333kNERARcXV1rnK+6wLrjybHusAM/nyzbcmJBAAy3zOkCBtboKdiCUo74lEwMWHUEk/5+Cm99noxJfz+FAauO1FpTd2mvvPIKEhISsGbNGshkMshkMly/fl1stvzmm2/Qs2dPuLq64sSJE3jllVcwbtw4i2vMnj0bQ4YMER+bTCZER0cjICAA7u7u6NatG3bt2lVhHj799FN07txZfLx3717IZDJs2LBB3BccHIz33ntPfPzll1+iR48ecHNzQ9u2bREVFYXHjx+Lx0s30548eRLdu3eHm5sbevXqJT5HcnKyRV7OnTuHXr16oVGjRujXrx/S0tIAALGxsYiKisKFCxfE1yk2NrYarzBVJDuv4uCkJukqPD87G+Hh4ejYsSOGDRuGM2fO4MCBA3juuecAAB9//DFGjx6NsLAwDBo0CGq1Grt37xbPVygU2L9/PxQKBbRaLaZMmYLw8HAsX778ifJV21h3sO5oMPKzqk5jTbpyMEAppb7640tas2YNtFotZsyYgczMTGRmZlrcyLdw4UKsXLkSly9fRteuXat1zejoaGzZsgUbNmzApUuXMGfOHEyZMqXCmxIHDx6M1NRU3LlzBwCQkJCAZs2a4dixYwCAoqIiJCYmihXZd999h/DwcLz11ltITU3FX//6V8TGxuKDDz4o9/oGgwFjxoxBly5dcP78eaxYsQILFiwoN+3//d//4U9/+hPOnj0LJycnTJs2DQDw0ksv4e2338bTTz8tvk4vvfRStV4PKp93E7daTVeRjRs34vr16ygsLER2djYOHTokBicA4ObmhvXr1yMnJwf379/H7t27y/yK9vf3x9dff40HDx7gzp07+OijjyTVIsC6g3VHg+LhU3Uaa9KVQzrfbgmoqj9eBnN//HMada022apUKri4uKBRo0blNm0uX77cojKvSmFhIT788EMcOnRI7MNv27YtTpw4gb/+9a8YPHhwmXM6d+4MLy8vJCQk4IUXXsCxY8fw9ttvY82aNQCA06dPo6ioCP369QMAREVFYeHChZg6dap4/RUrVuCdd97B0qVLy1x/+/btkMlk+Pvf/w43NzdoNBrcunULM2bMKJP2gw8+EPO4cOFCjBo1CgUFBXB3d4eHhwecnJzYBFxL+gR4wVflBp2+oNzPvQyAWmXupqCKse5g3dHg+Pczj9YxZKL8+1Bk5uP+/Wr8FGxBKcGa/vj61KtXL6vSX716FQ8ePMBzzz0HDw8PcduyZQuuXbtW7jkymQyDBg3CsWPHkJubi9TUVLz++usoLCzEjz/+iISEBPTu3RuNGjUCAFy4cAHLly+3uH7xr7jy1kBKS0tD165d4eb26y/xPn36lJuXkr/0fH3NQ1xL3hxJtUchl2HpGPNNpqX/bBY/XjpGY/N7KKSOdQfrjgZHrjAPJQZQYe0RuvKJ5kNhC0oJ9dUfb63GjRtbPJbL5WUWMyu5+mp+fj4A4KuvvkKLFi0s0lV2Q+GQIUPwt7/9Dd999x2eeeYZKJVKseJJSEiw+PWUn5+PqKgojB8/vsx1SlYkNeHs7Cz+v3hmR5PJ9ETXpIqFdvZFzJQeZeZBUdfyPCiOjHUH644GSTMWmLClgnlQVj7xPCgMUEqor/748ri4uMBorN5wrObNmyMlJcViX3Jysvjl1Gg0cHV1RUZGRrlNshUZPHgwZs+ejZ07d4r9xUOGDMGhQ4fw/fff4+233xbT9ujRA2lpaWjfvn21rt2xY0ds3boVhYWFYkV35syZauetmDWvE1VfaGdfPKdRS270ib1g3cG6o8HSjAUCR9XJTLLs4imhuD++oipZBvPsmnXRH9+mTRskJSXh+vXruHv3bqVR/7PPPouzZ89iy5YtuHLlCpYuXWpR6TRp0gTz5s3DnDlzsHnzZly7dg3nz5/HunXrsHnz5gqv27VrVzz11FPYvn27RSWzd+9eFBYWon///mLaJUuWYMuWLYiKisKlS5dw+fJlfP755xZ36pf0u9/9DiaTCTNnzsTly5dx4MABfPTRRwCsW/+iTZs2SE9PR3JyMu7evYvCwsJqn0uVU8hl0LZriue7t4C2XVMGJ1Zg3cG6o0GTK8xDibu8YP63FoITgAGKBVv2x8+bNw8KhQIajQbNmzdHRkZGhWlDQkKwePFivPPOO+jduzfy8vIQHh5ukWbFihVYvHgxoqOj0alTJ4SGhuKrr75CQEBAhdeVyWQYOHAgZDIZBgwYAMBc8SiVSvTq1cuiuTgkJAT79+/Ht99+i969e6Nv3774+OOP4e/vX+61lUol9u3bh+TkZHTv3h3/93//hyVLlgCwrlk3LCwMoaGhGDp0KJo3b47PPvus2ucS1RXWHaw7qPbJhNIdknbAYDBApVJBr9eXmbq6oKAA6enpCAgIqHF/Zn2sS0LAtm3b8Oqrr0Kv18Pd3b1Wr10bnwOqXGXfQ6li3eEY6qruYL1R96ypN3gPSjnYH183tmzZgrZt26JFixa4cOECFixYgAkTJtR6cEJkK6w76gbrjoaJAUoFivvjqfbodDosWbIEOp0Ovr6+ePHFFyucnInIXrHuqH2sOxomBihUb9555x288847ts4GEdkZ1h0Nk9U3yebl5WH27Nnw9/eHu7s7+vXrZzHkSxAELFmyBL6+vnB3d0dwcDCuXLlicY2cnBxMnjwZSqUSnp6emD59ujj+noiIiMjqAOW1117DwYMH8a9//QsXL17E8OHDERwcjFu3bgEAVq9ejbVr12LDhg1ISkpC48aNERISgoKCX28amzx5Mi5duoSDBw9i//79OH78OGbOnFl7pSIi65mMQPp3wMVd5n+fYJl0IqInZVUXz8OHD/HFF1/gyy+/xKBBgwAAy5Ytw759+xATE4MVK1bgk08+wXvvvYfnn38egPnmJh8fH+zduxcTJ07E5cuXER8fjzNnzojTMK9btw4jR47ERx99BD8/v1ouIhFVKTWugtkgVz3xbJBERDVhVQvK48ePYTQaywy/cnd3x4kTJ5Ceng6dTofg4GDxmEqlQlBQEBITEwEAiYmJ8PT0tFgjIjg4GHK5HElJSeU+b2FhIQwGg8VGRLUkNQ7YEW4ZnADmRcB2hJuPExHVM6sClCZNmkCr1WLFihW4ffs2jEYjtm7disTERGRmZkKn0wEAfHwsl1f28fERj+l0Onh7e1scd3JygpeXl5imtOjoaKhUKnEruZw4ET0Bk9HcclLhOrwA4heyu4eI6p3V96D861//giAIaNGiBVxdXbF27VpMmjQJcnndTUq7aNEi6PV6cbtx40adPRdRg/LzybItJxYEwHDLnI6IqB5ZHVW0a9cOCQkJyM/Px40bN3D69GkUFRWhbdu2UKvVAICsrCyLc7KyssRjarW6zPLXjx8/Rk5OjpimNFdXVyiVSouNnkybNm3wySefiI9lMhn27t37RNesjWtQPcvPqjqNNenIobHeoPpU42aPxo0bw9fXF//73/9w4MABPP/88wgICIBarcbhw4fFdAaDAUlJSdBqtQAArVaL3NxcnDt3Tkxz5MgRmEwmBAUFPUFRalkDG9GQmZmJESNGVCvtsmXL0L179ye6BkmEh0/VaaxJRw2q7mC9QXXJ6onaDhw4AEEQ0LFjR1y9ehXz589HYGAgXn31VchkMsyePRvvv/8+OnTogICAACxevBh+fn4YN24cAIiLT82YMQMbNmxAUVERIiMjMXHiROmM4LGTEQ2PHj2Ci4tLrVyrotar+r4G1TP/fubPtiET5d+HIjMf9+9X3zmzT3ZQd7DeIHthdQuKXq9HREQEAgMDER4ejgEDBuDAgQNwdnYGYJ7x74033sDMmTPRu3dv5OfnIz4+3mLkz7Zt2xAYGIhhw4Zh5MiRGDBgAP72t7/VXqmehA1HNAwZMgSRkZGIjIyESqVCs2bNsHjxYhSv59imTRusWLEC4eHhUCqV4twxJ06cwMCBA+Hu7o5WrVrhzTffxP3798XrZmdnY8yYMXB3d0dAQAC2bdtW5rlLN7PevHkTkyZNgpeXFxo3boxevXohKSkJsbGxiIqKwoULFyCTySCTyRAbG1vuNS5evIhnn30W7u7uaNq0KWbOnGkxId8rr7yCcePG4aOPPoKvry+aNm2KiIgIFBUV1eKrSpWSK8x/PAFUuA5v6MpaWz7dodmo7mC9wXrD1owmAYnX7uHL5FtIvHYPRlPtrEFsdQvKhAkTMGHChAqPy2QyLF++HMuXL68wjZeXF7Zv327tU9e9Kkc0yMwjGgJH1VmFvXnzZkyfPh2nT5/G2bNnMXPmTLRu3RozZswAAHz00UdYsmQJli5dCgC4du0aQkND8f777+Of//wn7ty5I1ZWmzZtAmD+Qt++fRtHjx6Fs7Mz3nzzzTL3AZWUn5+PwYMHo0WLFoiLi4Narcb58+dhMpnw0ksvISUlBfHx8Th06BAA81Dy0u7fv4+QkBBotVqcOXMG2dnZeO211xAZGSlWTABw9OhR+Pr64ujRo7h69SpeeukldO/eXSwv1QPNWGDClgp++a+UzC9/SbNx3cF6g/WGrdTlCt5ci6cka0Y0BAyskyy0atUKH3/8MWQyGTp27IiLFy/i448/Fr94zz77LN5++20x/WuvvYbJkydj9uzZAIAOHTpg7dq1GDx4MGJiYpCRkYFvvvkGp0+fRu/evQEAGzduRKdOnSrMw/bt23Hnzh2cOXMGXl5eAID27duLxz08PODk5FRp0+z27dtRUFCALVu2oHHjxgCATz/9FGPGjMGqVavEoehPPfUUPv30UygUCgQGBmLUqFE4fPgwK5r6phlr/uP580nzDbEePuZuHbacVI+N6w7WG6w3bCE+JROztp4vE5br9AWYtfU8Yqb0eKIgpe7GBtsjCYxo6Nu3L2SyX5vatVotrly5AqPRfKNdyQnuAODChQuIjY2Fh4eHuIWEhMBkMiE9PR2XL1+Gk5MTevbsKZ4TGBgIT0/PCvOQnJyMZ555RqxkauLy5cvo1q2bWMkAQP/+/WEymZCWlibue/rpp6FQ/PpH0NfXt9JfaVSH5ArzH88uL5j/ZXBSfTauO1hvsN6ob0aTgKh9qZXNoISofalP1N3DFpSS7GBEQ8kvLmBuVv3973+PN998s0za1q1b46effrL6Odzd3WucP2sV37tUTCaTwWQy1dvzE9UKidcdrDeotp1Oz7Ho1ilNAJCpL8Dp9Bxo2zWt0XOwBaWk4hENZW4WLCYDlC3qdERD6en+T506hQ4dOlj8WiipR48eSE1NRfv27ctsLi4uCAwMxOPHjy2GdaelpSE3N7fCPHTt2hXJycnIyckp97iLi4v4y6winTp1woULFyxuuvv+++8hl8vRsWPHSs8lsjs2rjtYb1B9y86rODipSbryMEApSQIjGjIyMjB37lykpaXhs88+w7p16/DWW29VmH7BggU4efIkIiMjkZycjCtXruDLL79EZGQkAKBjx44IDQ3F73//eyQlJeHcuXN47bXXKv21M2nSJKjVaowbNw7ff/89/vvf/+KLL74Q11Nq06YN0tPTkZycjLt376KwsLDMNSZPngw3NzdMnToVKSkpOHr0KN544w28/PLLZZZCILJ7Nq47WG9QffNu4lZ1IivSlYcBSmnFIxqUpW7sUfqZ99fxiIbw8HA8fPgQffr0QUREBN566y1xWGB5unbtioSEBPz0008YOHAgnnnmGSxZssRiTplNmzbBz88PgwcPxvjx4zFz5swy6yGV5OLigm+//Rbe3t4YOXIkunTpgpUrV4q/xsLCwhAaGoqhQ4eiefPm+Oyzz8pco1GjRjhw4ABycnLQu3dvvPDCCxg2bBg+/fTTJ3h1iCTMhnUH6w2qb30CvOCrcquszRC+Kjf0Caj5PUkyoXiwvB0xGAxQqVTQ6/Vlpr0vKChAeno6AgICyqy6bBWTsd5HNAwZMgTdu3e3mEqaaqbWPgdUocq+h1LliHUH643aw3rDOsWjeADLAfbFQUt5o3isqTd4k2xFikc0EBFZg3UHNRChnX0RM6VHmXlQ1JwHhYiIiGwptLMvntOocTo9B9l5BfBuYu7WUcgr6vypPgYoEnLs2DFbZ4GI7AzrDbI1hVxW46HEleFNskRERCQ5Dhug2OG9v1SL+P5TTfGz03DxvZcWhwtQimcYfPDggY1zQrZU/P6XnnGSqCLFw2EfPXpk45yQrRS/9xVNcEf1y+HuQVEoFPD09BTXZWjUqJHFGhXk2ARBwIMHD5CdnQ1PT09WNFRtTk5OaNSoEe7cuQNnZ2fI5Q73+40qYTKZcOfOHTRq1AhOTg73p9EuOeS7ULxaJheParg8PT0rXTWVqDSZTAZfX1+kp6fj559/tnV2yAbkcjlat27NH7US4ZABSnFF4+3tjaKiIltnh+qZs7MzW06oRlxcXNChQwd28zRQLi4ubDmTEIcMUIopFAr+oSIiq8jlcs4iSiQBDBWJiIhIchigEBERkeQwQCEiIiLJYYBCREREksMAhYiIiCSHAQoRERFJDgMUIiIikhwGKERERCQ5DFCIqM5FR0ejd+/eaNKkCby9vTFu3DikpaVZpBkyZAhkMpnF9oc//MEiTUZGBkaNGoVGjRrB29sb8+fPx+PHj+uzKERUTxx6JlkikoaEhARERESgd+/eePz4Md59910MHz4cqampaNy4sZhuxowZWL58ufi4UaNG4v+NRiNGjRoFtVqNkydPIjMzE+Hh4XB2dsaHH35Yr+UhorrHAIWI6lx8fLzF49jYWHh7e+PcuXMYNGiQuL9Ro0YVLvL47bffIjU1FYcOHYKPjw+6d++OFStWYMGCBVi2bBlcXFzqtAxEVL/YxUNE9U6v1wMAvLy8LPZv27YNzZo1Q+fOnbFo0SI8ePBAPJaYmIguXbrAx8dH3BcSEgKDwYBLly6V+zyFhYUwGAwWGxHZB7agEFG9MplMmD17Nvr374/OnTuL+3/3u9/B398ffn5++OGHH7BgwQKkpaVh9+7dAACdTmcRnAAQH+t0unKfKzo6GlFRUXVUEiKqSwxQiKheRUREICUlBSdOnLDYP3PmTPH/Xbp0ga+vL4YNG4Zr166hXbt2NXquRYsWYe7cueJjg8GAVq1a1SzjRFSv2MVDRPUmMjIS+/fvx9GjR9GyZctK0wYFBQEArl69CgBQq9XIysqySFP8uKL7VlxdXaFUKi02IrIPDFCIqM4JgoDIyEjs2bMHR44cQUBAQJXnJCcnAwB8fX0BAFqtFhcvXkR2draY5uDBg1AqldBoNHWSbyKyHXbxEFGdi4iIwPbt2/Hll1+iSZMm4j0jKpUK7u7uuHbtGrZv346RI0eiadOm+OGHHzBnzhwMGjQIXbt2BQAMHz4cGo0GL7/8MlavXg2dTof33nsPERERcHV1tWXxiKgOsAWFiOpcTEwM9Ho9hgwZAl9fX3H797//DQBwcXHBoUOHMHz4cAQGBuLtt99GWFgY9u3bJ15DoVBg//79UCgU0Gq1mDJlCsLDwy3mTSEix8EWFCKqc4IgVHq8VatWSEhIqPI6/v7++Prrr2srW0QkYWxBISIiIslhgEJERESSwwCFiIiIJIcBChEREUkOAxQiIiKSHAYoREREJDkMUIiIiEhyGKAQERGR5DBAISIiIslhgEJERESSwwCFiIiIJIcBChEREUkOAxQiIiKSHAYoREREJDkMUIiIiEhyGKAQERGR5DBAISIiIslhgEJERESSwwCFiIiIJIcBChEREUkOAxQiIiKSHAYoREREJDkMUIiIiEhyGKAQERGR5DBAISIiIslhgEJERESSwwCFiIiIJIcBChEREUkOAxQiIiKSHAYoREREJDkMUIiIiEhyGKAQERGR5FgVoBiNRixevBgBAQFwd3dHu3btsGLFCgiCIKYRBAFLliyBr68v3N3dERwcjCtXrlhcJycnB5MnT4ZSqYSnpyemT5+O/Pz82ikRERER2T2rApRVq1YhJiYGn376KS5fvoxVq1Zh9erVWLdunZhm9erVWLt2LTZs2ICkpCQ0btwYISEhKCgoENNMnjwZly5dwsGDB7F//34cP34cM2fOrL1SERERkV2TCSWbP6owevRo+Pj4YOPGjeK+sLAwuLu7Y+vWrRAEAX5+fnj77bcxb948AIBer4ePjw9iY2MxceJEXL58GRqNBmfOnEGvXr0AAPHx8Rg5ciRu3rwJPz+/KvNhMBigUqmg1+uhVCqtLTMR1QJ7/B7aY56JHIk130GrWlD69euHw4cP46effgIAXLhwASdOnMCIESMAAOnp6dDpdAgODhbPUalUCAoKQmJiIgAgMTERnp6eYnACAMHBwZDL5UhKSir3eQsLC2EwGCw2IiIiclxO1iReuHAhDAYDAgMDoVAoYDQa8cEHH2Dy5MkAAJ1OBwDw8fGxOM/Hx0c8ptPp4O3tbZkJJyd4eXmJaUqLjo5GVFSUNVklIiIiO2ZVC8qOHTuwbds2bN++HefPn8fmzZvx0UcfYfPmzXWVPwDAokWLoNfrxe3GjRt1+nxERERkW1a1oMyfPx8LFy7ExIkTAQBdunTBzz//jOjoaEydOhVqtRoAkJWVBV9fX/G8rKwsdO/eHQCgVquRnZ1tcd3Hjx8jJydHPL80V1dXuLq6WpNVIiIismNWtaA8ePAAcrnlKQqFAiaTCQAQEBAAtVqNw4cPi8cNBgOSkpKg1WoBAFqtFrm5uTh37pyY5siRIzCZTAgKCqpxQYiIiMhxWNWCMmbMGHzwwQdo3bo1nn76afznP//Bn//8Z0ybNg0AIJPJMHv2bLz//vvo0KEDAgICsHjxYvj5+WHcuHEAgE6dOiE0NBQzZszAhg0bUFRUhMjISEycOLFaI3iIiIjI8VkVoKxbtw6LFy/G66+/juzsbPj5+eH3v/89lixZIqZ55513cP/+fcycORO5ubkYMGAA4uPj4ebmJqbZtm0bIiMjMWzYMMjlcoSFhWHt2rW1VyoiIiKya1bNgyIVnMuAyPbs8Xtoj3kmciR1Ng8KERERUX1ggEJERESSwwCFiIiIJIcBChHVuejoaPTu3RtNmjSBt7c3xo0bh7S0NIs0BQUFiIiIQNOmTeHh4YGwsDBkZWVZpMnIyMCoUaPQqFEjeHt7Y/78+Xj8+HF9FoWI6gkDFCKqcwkJCYiIiMCpU6dw8OBBFBUVYfjw4bh//76YZs6cOdi3bx927tyJhIQE3L59G+PHjxePG41GjBo1Co8ePcLJkyexefNmxMbGWowiJCLHwVE8RFQjT/I9vHPnDry9vZGQkIBBgwZBr9ejefPm2L59O1544QUAwI8//ohOnTohMTERffv2xTfffIPRo0fj9u3b4npfGzZswIIFC3Dnzh24uLjUaZ6J6MlxFA8RSZperwcAeHl5AQDOnTuHoqIii5XQAwMD0bp1a4uV0Lt06WKxGGlISAgMBgMuXbpU7vNwJXQi+8UAhYjqlclkwuzZs9G/f3907twZgHmVcxcXF3h6elqkLb0SenkrpRcfK090dDRUKpW4tWrVqpZLQ0R1hQEKEdWriIgIpKSk4PPPP6/z5+JK6FQnTEYg/Tvg4i7zvyajrXPkkKya6p6I6ElERkZi//79OH78OFq2bCnuV6vVePToEXJzcy1aUbKyssRVztVqNU6fPm1xveJRPlwJnepNahwQvwAw3P51n9IPCF0FaMbaLl8OiC0oRFTnBEFAZGQk9uzZgyNHjiAgIMDieM+ePeHs7GyxEnpaWhoyMjIsVkK/ePEisrOzxTQHDx6EUqmERqOpn4JQw5YaB+wItwxOAMCQad6fGmebfDkotqAQUZ2LiIjA9u3b8eWXX6JJkybiPSMqlQru7u5QqVSYPn065s6dCy8vLyiVSrzxxhvQarXo27cvAGD48OHQaDR4+eWXsXr1auh0Orz33nuIiIhgKwnVPZPR3HKC8ga+CgBkQPxCIHAUIFfUc+YcE1tQiKjOxcTEQK/XY8iQIfD19RW3f//732Kajz/+GKNHj0ZYWBgGDRoEtVqN3bt3i8cVCgX2798PhUIBrVaLKVOmIDw8HMuXL7dFkaih+flk2ZYTCwJguGVOR7WCLShEVOeqM92Sm5sb1q9fj/Xr11eYxt/fH19//XVtZo2oevKzqk5jTTqqEltQiIiIquLhU3Uaa9JRlRigEBERVcW/n3m0DmQVJJAByhbmdFQrGKAQERFVRa4wDyUGUDZI+eVx6EreIFuLGKAQERFVh2YsMGELoPS13K/0M+/nPCi1ijfJEhERVZdmrHko8c8nzTfEeviYu3XYclLrGKAQERFZQ64AAgbaOhcOj108REREJDkMUIiIiEhyGKAQERGR5DBAISIiIslhgEJERESSwwCFiIiIJIcBChEREUkOAxQiIiKSHAYoREREJDkMUIiIiEhyGKAQERGR5DBAISIiIslhgEJERESSwwCFiIiIJIcBChEREUkOAxQiIiKSHAYoREREJDlOts4AERGRPTGaBJxOz0F2XgG8m7ihT4AXFHKZrbPlcBigEBERVVN8Siai9qUiU18g7vNVuWHpGA1CO/vaMGeOh108RERE1RCfkolZW89bBCcAoNMXYNbW84hPybRRzhwTAxQiIiIAMBmB9O+Ai7vM/5qM4iGjSUDUvlQI5ZxWvC9qXyqMpvJSUE2wi4eIiCg1DohfABhu/7pP6QeErgI0Y3E6PadMy0lJAoBMfQFOp+dA265p3ee3AWALChERNWypccCOcMvgBAAMmeb9qXHIzqs4OCmpuumoagxQiIio4TIZzS0nlXXexC+Ed2Pnal3Ou4lbrWWtoWOAQkREDdfPJ8u2nFgQAMMt9FH8CF+VGyoaTCyDeTRPnwCvOshkw8QAhYiIGq78rGolU9zPxtIxGgAoE6QUP146RsP5UGoRAxQiImq4PHyqnS60sy9ipvSAWmXZjaNWuSFmSg/Og1LLOIqHiIhsyqYzs/r3A5R+EAyZkJVzH4oAGWRKP3M6AKGdffGcRs2ZZOsBAxQiIrIZm8/MKlfgP08vRLeTb0IAUDLOME9pIiD56QV4Rq4Q9yvkMg4lrgfs4iEiIpuQwsysRpOA18+3xKyi2dDB8gZXHZri9aLZeP18S07AZgNsQSEionpX1cysMphnZn1Oo67T7pPiCdgy0QcHC3uhj/xHeCMX2fDEaVMgTJADnIDNJhigEBFRvZPKzKwlJ1YzQY5TJk2V6ah+sIuHiIjqnVRmZq3uxGqcgK3+MUAhIqJ6J5XAoE+AFydgkygGKEREVO+kEhgo5DJOwCZRDFCIiKjeSSkw4ARs0sSbZImIyCaKA4PS86Co63MelBJ54QRs0sIAhYiIbEZKgQEnYJMWBihERGRTDAyoPAxQiIioXth0zR2yO7xJlojq3PHjxzFmzBj4+flBJpNh7969FsdfeeUVyGQyiy00NNQiTU5ODiZPngylUglPT09Mnz4d+fn59VgKehLxKZkYsOoIJv39FN76PBmT/n4KA1YdqZfp7Mk+MUAhojp3//59dOvWDevXr68wTWhoKDIzM8Xts88+szg+efJkXLp0CQcPHsT+/ftx/PhxzJw5s66zTrVACmvukP1hFw8R1bkRI0ZgxIgRlaZxdXWFWq0u99jly5cRHx+PM2fOoFevXgCAdevWYeTIkfjoo4/g5+dX63mm2iGVNXfI/rAFhYgk4dixY/D29kbHjh0xa9Ys3Lt3TzyWmJgIT09PMTgBgODgYMjlciQlJVV4zcLCQhgMBouN6pc1a+4QlcQAhYhsLjQ0FFu2bMHhw4exatUqJCQkYMSIETAajQAAnU4Hb29vi3OcnJzg5eUFnU5X4XWjo6OhUqnErVWrVnVaDipLKmvukP1hFw8R2dzEiRPF/3fp0gVdu3ZFu3btcOzYMQwbNqzG1120aBHmzp0rPjYYDAxS6plU1twh+8MWFCKSnLZt26JZs2a4evUqAECtViM7O9sizePHj5GTk1PhfSuA+b4WpVJpsVH9ksqaO2R/GKCQQzKaBCReu4cvk28h8do9GE3l3aJHUnXz5k3cu3cPvr7mqc61Wi1yc3Nx7tw5Mc2RI0dgMpkQFBRkq2xSNUhpzR2yL1YFKG3atCkzV4FMJkNERAQAoKCgABEREWjatCk8PDwQFhaGrKwsi2tkZGRg1KhRaNSoEby9vTF//nw8fvy49kpEDV58SiYGrTyINRv/icM7/oI1G/+JQSsPciijDeXn5yM5ORnJyckAgPT0dCQnJyMjIwP5+fmYP38+Tp06hevXr+Pw4cN4/vnn0b59e4SEhAAAOnXqhNDQUMyYMQOnT5/G999/j8jISEycOJEjeOwAF+OjmrDqHpQzZ86IN60BQEpKCp577jm8+OKLAIA5c+bgq6++ws6dO6FSqRAZGYnx48fj+++/BwAYjUaMGjUKarUaJ0+eRGZmJsLDw+Hs7IwPP/ywFotFDVV8Sib2bt+Anc5b4Ofy66iA24VeWL49HPjdH1gZ2sDZs2cxdOhQ8XHxfSFTp05FTEwMfvjhB2zevBm5ubnw8/PD8OHDsWLFCri6uornbNu2DZGRkRg2bBjkcjnCwsKwdu3aei8L1Uyla+6YjMDPJ4H8LMDDB/DvB8gVts4y2ZhMEIQat33Pnj0b+/fvx5UrV2AwGNC8eXNs374dL7zwAgDgxx9/RKdOnZCYmIi+ffvim2++wejRo3H79m34+PgAADZs2IAFCxbgzp07cHFxqdbzGgwGqFQq6PV69imTyGgS8H8ffogPi1YDAEq2GBf38Lzr/A4+ePddNifXAnv8Htpjnh1eahwQvwAw3P51n9IPCF0FaMbaLl9UJ6z5Dtb4HpRHjx5h69atmDZtGmQyGc6dO4eioiIEBweLaQIDA9G6dWskJiYCMM9l0KVLFzE4AYCQkBAYDAZcunSpwufiXAZUHaev3cGbRf8AYBmclHz8ZtFGnL52p55zRkTlSo0DdoRbBicAYMg070+Ns02+SBJqHKDs3bsXubm5eOWVVwCY5ylwcXGBp6enRTofHx9xngKdTmcRnBQfLz5WEc5lQNVhvP49/GQ5ZYKTYnIZ4Ce7B+P17+s3Y0RUlslobjmpcI5ZAPELzemoQapxgLJx40aMGDGiXm5QW7RoEfR6vbjduHGjzp+T7I+3LLdW0xFRHfr5ZNmWEwsCYLhlTkcNUo0ClJ9//hmHDh3Ca6+9Ju5Tq9V49OgRcnNzLdJmZWWJ8xSo1eoyo3qKH3MuA3pS7dq2q9V0RFSH8rOqTmNNOnI4NQpQNm3aBG9vb4waNUrc17NnTzg7O+Pw4cPivrS0NGRkZECr1QIwz2Vw8eJFiwmXDh48CKVSCY1GU9MyEAEAFG3646G7GhVNeWISgIfuaija9K/fjBFRWR4+VaexJh05HKsDFJPJhE2bNmHq1Klwcvp1lLJKpcL06dMxd+5cHD16FOfOncOrr74KrVaLvn37AgCGDx8OjUaDl19+GRcuXMCBAwfw3nvvISIiwmI4IVGNyBVwH/NHyGQymEodMgGQyWRwH/NHDl8kkgL/fubROpXNMatsYU5HDZLVAcqhQ4eQkZGBadOmlTn28ccfY/To0QgLC8OgQYOgVquxe/du8bhCocD+/fuhUCig1WoxZcoUhIeHY/ny5U9WCqJimrGQTdgCmdLy3iiZsgVkE7Zw2CKRVMgV5qHEACqcYzZ0JX9QNGBPNA+KrXAuA6oSJ36qc/b4PbTHPDu8cudBaWEOTviDwuFY8x3kasbkmOQKIGCgrXNBRFXRjAUCR/EHBZXBAIWIiGyLPyioHFzNmIiIiCSHLSjk8IwmofwFyoiISLIYoJBDi0/JRNS+VGTqC8R9vio3LB2j4arGREQSxi4ecljxKZmYtfW8RXACADp9AWZtPY/4lEwb5YyIiKrCAIUcktEkIGpfamXLkCFqXyqMFU07S0RENsUAhRzS6fScMi0nJQkAMvUFOJ2eU3+ZIiKiamOAQg4pO6/i4KQm6YiIqH4xQCGH5N3ErVbTERFR/WKAQg6pT4AXfFVulS1DBl+VecgxERFJDwMUckgKuQxLx2gAVLgMGZaO0XA+FCIiiWKAQg4rtLMvYqb0gFpl2Y2jVrkhZkoPzoNCRCRhnKiNHFpoZ188p1FzJllqeLiiN9k5Bijk8BRyGbTtmto6G0RPxKolG1LjgPgFgOH2r/uUfkDoKvPqwUR2gAEKEZHEWbVkQ2ocsCMcKD1NoSHTvH/CFgYpZBd4DwoRkYRZtWSDyWhuOalsDuX4heZ0RBLHAIWISKKsXrLh55OW3TrlnWW4ZU5HJHEMUIiIJMrqJRvys6p34eqmI7IhBihERBJl9ZINHj7Vu3B10xHZEAMUIiKJsnrJBv9+5tE6lc2hrGxhTkckcQxQiIgkyuolG+QK81Bi8Wjp1ABCV3I+FLILDFCIiCSqRks2aMaahxIrSw0/VvrZfoixyQikfwdc3GX+l6OJqBKcB4WISMKKl2woPQ+KuqJ5UABzEBI4SlozyXLyOLISAxQiIokL7eyL5wKb48ekA3j4v1twf6oFAoMGQ+FUSRUuVwABA+svk5Xh5HFUAwxQiIikLjUOivgFeLpk60OSnbQ+VDl5nMw8eVzgKN4bQxZ4DwoRkZQVtz6UnoCtuPUhNc42+aouTh5HNcQAhZ6I0SQg8do9fJl8C4nX7v06oyURPTlHmLqek8dRDbGLh2rMqgXMiMh61rQ+SOV+k9I4eRzVEFtQqEasWsCMiGrGEVofOHkc1RADFLKa1QuYEVHNOELrAyePoxpigEJWs3oBMyKqGUdpfZDy5HEkWbwHhaxm9QJmRFQzxa0PO8JhDlJKtkraWeuDFCePI0ljgEJWs3oBMyKqueLWh3JnYV1pX60PUpo8jiSPAQpZrXgBM52+oNz7UGQwT8MtLmBGRE+GrQ/UAPEeFLJajRYwI6InU9z60OUF878MTsjBMUChGilewEytsuzGUavcEDOlB+dBISKiJ8IuHqqx0M6+eE6jxun0HGTnFcC7iblbhy0nRET0pNiCQk9EIZdB264pnu/eAtp2TRmcULmOHz+OMWPGwM/PDzKZDHv37rU4LggClixZAl9fX7i7uyM4OBhXrlyxSJOTk4PJkydDqVTC09MT06dPR35+fj2WgojqEwMUcnwmI5D+HXBxl/lfKa9b4qDu37+Pbt26Yf369eUeX716NdauXYsNGzYgKSkJjRs3RkhICAoKfh2qPnnyZFy6dAkHDx7E/v37cfz4ccycObO+ikBE9UwmCILdTfdpMBigUqmg1+uhVCptnR2SstS4CoZn2sEy9RJX0++hTCbDnj17MG7cOADm1hM/Pz+8/fbbmDdvHgBAr9fDx8cHsbGxmDhxIi5fvgyNRoMzZ86gV69eAID4+HiMHDkSN2/ehJ+fX53mmYhqhzXfQbagkOOy92XqG4j09HTodDoEBweL+1QqFYKCgpCYmAgASExMhKenpxicAEBwcDDkcjmSkpIqvHZhYSEMBoPFRkT2gQEKOSZHWKa+gdDpdAAAHx/L9WR8fHzEYzqdDt7e3hbHnZyc4OXlJaYpT3R0NFQqlbi1atWqlnNPRHWFAQo5JmuWqSeHtWjRIuj1enG7ceOGrbNERNXEAIUckyMsU99AqNVqAEBWluV7kZWVJR5Tq9XIzs62OP748WPk5OSIacrj6uoKpVJpsRGRfWCAQo7JEZapbyACAgKgVqtx+PBhcZ/BYEBSUhK0Wi0AQKvVIjc3F+fOnRPTHDlyBCaTCUFBQfWeZyKqe5yojRxT8TL1hkyUfx+KzHxc6svUO4j8/HxcvXpVfJyeno7k5GR4eXmhdevWmD17Nt5//3106NABAQEBWLx4Mfz8/MSRPp06dUJoaChmzJiBDRs2oKioCJGRkZg4cWK1R/AQkX1hgEKOyZGWqXcAZ8+exdChQ8XHc+fOBQBMnToVsbGxeOedd3D//n3MnDkTubm5GDBgAOLj4+Hm9utSCtu2bUNkZCSGDRsGuVyOsLAwrF27tt7LQkT1g/OgkGMrdx6UFva3TL0E2eP30B7zTORIrPkOsgWFHBuXqScisksMUMjxFS9TT0REdoMBCkmO0SRwhWQiogaOAQpJSnxKJqL2pSJT/+sicb4qNywdo0FoZ18b5oyIiOoT50EhyYhPycSsreeRpX+AvvJUjJWfRF95KrL1DzBr63nEp2TaOotERFRP2IJCkmA0CYjal4rh8tNY6rwFfrIc8dhtwQvLi8IRtc8Nz2nU7O4hImoA2IJCknA6PQdd844jxvkTqJFjcUyNHPzF+RN0zTuO0+k5FVyBiIgcCQMUkoRsw30sdd4CACjdQFL8eKnzv5BtuF/POSMiIltggEKS0P7BRfjJcsoEJ8XkMsBPdg/tH1ys34wREZFNMEAhSejU5EGtpiMiIvvGAIUkQd5EXavpiIjIvjFAIWn4ZfVhAeX38QiQmdfQ4erDREQNAgMUkoZfVh82rztsGaQIkJn3cPVhIqIGgwEKSYdmLDBhC2RKyxljZUo/YMIWrj5MRNSAcKI2khauPkxERGCAQlLE1YeJiBo8dvEQERGR5DBAISIiIsmxOkC5desWpkyZgqZNm8Ld3R1dunTB2bNnxeOCIGDJkiXw9fWFu7s7goODceXKFYtr5OTkYPLkyVAqlfD09MT06dORn5//5KUhIiIih2BVgPK///0P/fv3h7OzM7755hukpqbiT3/6E5566ikxzerVq7F27Vps2LABSUlJaNy4MUJCQlBQUCCmmTx5Mi5duoSDBw9i//79OH78OGbOnFl7pSIiIiK7JhMEQahu4oULF+L777/Hd999V+5xQRDg5+eHt99+G/PmzQMA6PV6+Pj4IDY2FhMnTsTly5eh0Whw5swZ9OrVCwAQHx+PkSNH4ubNm/Dz86syHwaDASqVCnq9HkqlsrrZJ6JaZI/fQ3vMM5EjseY7aFULSlxcHHr16oUXX3wR3t7eeOaZZ/D3v/9dPJ6eng6dTofg4GBxn0qlQlBQEBITEwEAiYmJ8PT0FIMTAAgODoZcLkdSUlK5z1tYWAiDwWCxERERkeOyKkD573//i5iYGHTo0AEHDhzArFmz8Oabb2Lz5s0AAJ1OBwDw8fGxOM/Hx0c8ptPp4O3tbXHcyckJXl5eYprSoqOjoVKpxK1Vq1bWZJuIiIjsjFXzoJhMJvTq1QsffvghAOCZZ55BSkoKNmzYgKlTp9ZJBgFg0aJFmDt3rvjYYDAwSCGiOmE0CTidnoPsvAJ4N3FDnwAvKOTlrxFFRHXHqgDF19cXGo3GYl+nTp3wxRdfAADUavNKs1lZWfD1/XW68qysLHTv3l1Mk52dbXGNx48fIycnRzy/NFdXV7i6ulqTVSIiq8WnZCJqXyoy9b/e1O+rcsPSMRqEdvat5Ewiqm1WdfH0798faWlpFvt++ukn+Pv7AwACAgKgVqtx+PBh8bjBYEBSUhK0Wi0AQKvVIjc3F+fOnRPTHDlyBCaTCUFBQTUuCBHRk4hPycSsrectghMA0OkLMGvrecSnZNooZ0QNk1UBypw5c3Dq1Cl8+OGHuHr1KrZv346//e1viIiIAADIZDLMnj0b77//PuLi4nDx4kWEh4fDz88P48aNA2BucQkNDcWMGTNw+vRpfP/994iMjMTEiROrNYKHiKi2GU0CovalQgAghwl95akYKz+JvvJUyGACAETtS4XRVO1Bj0T0hKzq4unduzf27NmDRYsWYfny5QgICMAnn3yCyZMni2neeecd3L9/HzNnzkRubi4GDBiA+Ph4uLm5iWm2bduGyMhIDBs2DHK5HGFhYVi7dm3tlYqIyAqn03OQqS9AiPw0ljpvgZ8sRzx2W/BCVFE4Duj74HR6DrTtmtowp0QNh1XzoEgF5zIgsj17/B5WlOcvk2/h6x1/Q4zzJwCAkvfEFjeazCqajZETZuL57i3qMcdEjqXO5kEhInJE3o2dsdR5CwDL4KTk46XO/4J3Y+d6zhlRw2VVFw8RkSPqo/gRihLdOqXJZYAf7sFH8SMA7wrTEVHtYQsKETV4ivvZVSeyIh0RPTkGKEREHj5Vp7EmHRE9MQYoRET+/QClH4CKZoyVAcoW5nREVC8YoBARyRVA6KpfHpQOUn55HLrSnI6I6gUDFCIiANCMBSZsAZSlprRX+pn3a8baJl9EDRRH8RARFdOMBQJHAT+fBPKzzPec+PdjywmRDTBAISIqSa4AAgbaOhdEDR67eIiIiEhyGKAQERGR5DBAISIiIslhgEJERESSwwCFiIiIJIcBChEREUkOAxQiIiKSHAYoREREJDkMUIjI5pYtWwaZTGaxBQYGiscLCgoQERGBpk2bwsPDA2FhYcjKyrJhjomorjFAISJJePrpp5GZmSluJ06cEI/NmTMH+/btw86dO5GQkIDbt29j/PjxNswtEdU1TnVPRJLg5OQEtVpdZr9er8fGjRuxfft2PPvsswCATZs2oVOnTjh16hT69u1b4TULCwtRWFgoPjYYDLWfcSKqE2xBISJJuHLlCvz8/NC2bVtMnjwZGRkZAIBz586hqKgIwcHBYtrAwEC0bt0aiYmJlV4zOjoaKpVK3Fq1alWnZSCi2sMAhYhsLigoCLGxsYiPj0dMTAzS09MxcOBA5OXlQafTwcXFBZ6enhbn+Pj4QKfTVXrdRYsWQa/Xi9uNGzfqsBREVJvYxUNENjdixAjx/127dkVQUBD8/f2xY8cOuLu71/i6rq6ucHV1rY0sElE9YwsKEUmOp6cnfvOb3+Dq1atQq9V49OgRcnNzLdJkZWWVe88KETkGBihEJDn5+fm4du0afH190bNnTzg7O+Pw4cPi8bS0NGRkZECr1dowl0RUl9jFQ0Q2N2/ePIwZMwb+/v64ffs2li5dCoVCgUmTJkGlUmH69OmYO3cuvLy8oFQq8cYbb0Cr1VY6goeI7BsDFCKyuZs3b2LSpEm4d+8emjdvjgEDBuDUqVNo3rw5AODjjz+GXC5HWFgYCgsLERISgr/85S82zjUR1SWZIAiCrTNhLYPBAJVKBb1eD6VSaevsEDVI9vg9tMc8EzkSa76DvAeFiIiIJIcBChEREUkOAxQiIiKSHAYoREREJDkMUIiIiEhyGKAQERGR5DBAISIiIslhgEJERESSwwCFiIiIJIcBChEREUkOAxQiIiKSHAYoREREJDkMUIiIiEhyGKAQERGR5DBAISIiIslhgEJERESSwwCFiIiIJIcBChEREUkOAxQiIiKSHAYoREREJDlOts4A2TmTEfj5JJCfBXj4AP79ALnC1rkiIiI7xwCFai41DohfABhu/7pP6QeErgI0Y22XLyIisnvs4qGaSY0DdoRbBicAYMg070+Ns02+iIjIITBAIeuZjOaWEwjlHPxlX/xCczoiIqIaYIBC1vv5ZNmWEwsCYLhlTkdERFQDDFDIevlZtZuOiIioFAYoZD0Pn9pNR0REVAoDFLKefz/zaB3IKkggA5QtzOmIiIhqgAEKWU+uMA8lBlA2SPnlcehKzodCREQ1xgCFakYzFpiwBVD6Wu5X+pn3cx4UIiJ6ApyojWpOMxYIHMWZZImIqNYxQKEnI1cAAQNtnQsiInIw7OIhIiIiyWGAQkRERJLDAIWIiIgkhwEKERERSQ4DFCIiIpIcBihEREQkOQxQiIiISHIcdh4Uo0nA6fQcZOcVwLuJG/oEeEEhr2jtGCIiIpISq1pQli1bBplMZrEFBgaKxwsKChAREYGmTZvCw8MDYWFhyMrKsrhGRkYGRo0ahUaNGsHb2xvz58/H48ePa6c0v4hPycSAVUcw6e+n8NbnyZj091MYsOoI4lMya/V5iIiIqG5Y3cXz9NNPIzMzU9xOnDghHpszZw727duHnTt3IiEhAbdv38b48ePF40ajEaNGjcKjR49w8uRJbN68GbGxsViyZEntlAbm4GTW1vPI1BdY7NfpCzBr63kGKURERHbA6gDFyckJarVa3Jo1awYA0Ov12LhxI/785z/j2WefRc+ePbFp0yacPHkSp06dAgB8++23SE1NxdatW9G9e3eMGDECK1aswPr16/Ho0aMnLozRJCBqXyqEco4V74valwqjqbwUREREJBVWByhXrlyBn58f2rZti8mTJyMjIwMAcO7cORQVFSE4OFhMGxgYiNatWyMxMREAkJiYiC5dusDHx0dMExISAoPBgEuXLlX4nIWFhTAYDBZbeU6n55RpOSlJAJCpL8Dp9BxrikxERET1zKoAJSgoCLGxsYiPj0dMTAzS09MxcOBA5OXlQafTwcXFBZ6enhbn+Pj4QKfTAQB0Op1FcFJ8vPhYRaKjo6FSqcStVatW5abLzvs1OJHDhL7yVIyVn0RfeSrkMJWbjojIERlNAhKv3cOXybeQeO0eW47J7lg1imfEiBHi/7t27YqgoCD4+/tjx44dcHd3r/XMFVu0aBHmzp0rPjYYDOUGKd5N3AAAIfLTWOq8BX6yX1tKbgteiCoKxwFTHzEdEZEjik/JRNS+VIsWZV+VG5aO0SC0s68Nc0ZUfU80D4qnpyd+85vf4OrVq1Cr1Xj06BFyc3Mt0mRlZUGtVgMA1Gp1mVE9xY+L05TH1dUVSqXSYitPnwAvTPRIRozzJ1DDshtHjRzEOH+CiR7J6BPgZW1RiUgi1q9fjzZt2sDNzQ1BQUE4ffq0rbMkKRwoQI7iiQKU/Px8XLt2Db6+vujZsyecnZ1x+PBh8XhaWhoyMjKg1WoBAFqtFhcvXkR2draY5uDBg1AqldBoNE+SFQCAAiYsdd4CACg95Unx46XOW6Ao0d1DRPbj3//+N+bOnYulS5fi/Pnz6NatG0JCQizqlIaMAwXIkVgVoMybNw8JCQm4fv06Tp48id/+9rdQKBSYNGkSVCoVpk+fjrlz5+Lo0aM4d+4cXn31VWi1WvTt2xcAMHz4cGg0Grz88su4cOECDhw4gPfeew8RERFwdXV98tL8fBLuD3VlgpNichng/lAH/HzyyZ+LiOrdn//8Z8yYMQOvvvoqNBoNNmzYgEaNGuGf//xnuemre4O9o+BAAXIkVgUoN2/exKRJk9CxY0dMmDABTZs2xalTp9C8eXMAwMcff4zRo0cjLCwMgwYNglqtxu7du8XzFQoF9u/fD4VCAa1WiylTpiA8PBzLly+vndLkZ1Wdxpp0RCQZjx49wrlz5yxGCsrlcgQHB4sjBUur7g32jqK6AwA4UIDsgVU3yX7++eeVHndzc8P69euxfv36CtP4+/vj66+/tuZpq8/Dp+o01qQjIsm4e/cujEZjuSMBf/zxx3LPqe4N9o6iugMAOFCA7IFjrcXj3w9Q+gGGTKDcXliZ+bh/v/rOGRHZgKura+10H9uJPgFe8FW5QacvqKgGhFrlxoECZBccazVjuQIIXfXLg9I3ovzyOHSlOR0R2ZVmzZpBoVCUOxKwslGADYlCLsPSMeYBBxXUgFg6RsOFU8kuOFaAAgCascCELYCy1Fh/pZ95v2asbfJFRE/ExcUFPXv2tBgpaDKZcPjwYXGkIAGhnX0RM6UH1CrLbhy1yg0xU3pwHhSyG47VxVNMMxYIHGUerZOfZb7nxL8fW06I7NzcuXMxdepU9OrVC3369MEnn3yC+/fv49VXX7V11iQltLMvntOocTo9B9l5BfBuYu7WYcsJ2RPHDFAAczASMNDWuSCiWvTSSy/hzp07WLJkCXQ6Hbp37474+PgyN86SubtH266prbNBVGOOG6AQkUOKjIxEZGSkrbNBRHXM8e5BISIiIrvHAIWIiIgkhwEKERERSQ4DFCIiIpIcBihEREQkOQxQiIiISHIYoBAREZHkMEAhIiIiybHLidoEwbxOp8FgsHFOiBqu4u9f8ffRHrDuILIta+oNuwxQ8vLyAACtWrWycU6IKC8vDyqVytbZqBbWHUTSUJ16QybY08+fX5hMJty+fRtNmjSBTFY7i18ZDAa0atUKN27cgFKprJVr2pojlglwzHLZY5kEQUBeXh78/Pwgl9tHb3HpusMeX/fyOEI5HKEMAMtRFWvqDbtsQZHL5WjZsmWdXFupVNr1h6o8jlgmwDHLZW9lspeWk2IV1R329rpXxBHK4QhlAFiOylS33rCPnz1ERETUoDBAISIiIslhgPILV1dXLF26FK6urrbOSq1xxDIBjlkuRyyTPXCU190RyuEIZQBYjtpklzfJEhERkWNjCwoRERFJDgMUIiIikhwGKERERCQ5DFCIiIhIchigEBERkeQ4ZIASExODrl27ijPgabVafPPNN+LxIUOGQCaTWWx/+MMfKr2mIAhYsmQJfH194e7ujuDgYFy5cqWuiyKqrEzXr18vU57ibefOnRVe85VXXimTPjQ0tL6KVMbKlSshk8kwe/ZscV9BQQEiIiLQtGlTeHh4ICwsDFlZWZVex9bvVWmly5WTk4M33ngDHTt2hLu7O1q3bo0333wTer2+0utI7f2SmujoaPTu3RtNmjSBt7c3xo0bh7S0NIs0Uv88VVUGe/nsVOe9sId6uKpy2EvdW9XfRMl+LwQHFBcXJ3z11VfCTz/9JKSlpQnvvvuu4OzsLKSkpAiCIAiDBw8WZsyYIWRmZoqbXq+v9JorV64UVCqVsHfvXuHChQvC2LFjhYCAAOHhw4f1UaRKy/T48WOLsmRmZgpRUVGCh4eHkJeXV+E1p06dKoSGhlqcl5OTUy/lKe306dNCmzZthK5duwpvvfWWuP8Pf/iD0KpVK+Hw4cPC2bNnhb59+wr9+vWr9Fq2fq9KKq9cFy9eFMaPHy/ExcUJV69eFQ4fPix06NBBCAsLq/RaUnq/pCgkJETYtGmTkJKSIiQnJwsjR44UWrduLeTn54tppP55qqoM9vLZqc57YQ/1cFXlsJe6t6q/iVL9XjhkgFKep556SvjHP/4hCIL5i1Hyj2BVTCaToFarhT/+8Y/ivtzcXMHV1VX47LPPajur1VayTKV1795dmDZtWqXnT506VXj++efrIGfWycvLEzp06CAcPHjQ4r3Jzc0VnJ2dhZ07d4ppL1++LAAQEhMTy72WlN6rispVnh07dgguLi5CUVFRhWmk8n7Zi+zsbAGAkJCQIAiCfX6eSpehPPbw2SmvHPZYD1fn/bCXurf474eUvxcO2cVTktFoxOeff4779+9Dq9WK+7dt24ZmzZqhc+fOWLRoER48eFDhNdLT06HT6RAcHCzuU6lUCAoKQmJiYp3mvzwVlanYuXPnkJycjOnTp1d5rWPHjsHb2xsdO3bErFmzcO/evbrIcqUiIiIwatQoi9cXMJejqKjIYn9gYCBat25d4esupfeqonKVR6/XQ6lUwsmp8vU7pfB+2Yvibg8vLy8A9vl5Kl2GitJI/bNTUTnsrR6u6v2wh7q39N8PKX8v7HI14+q4ePEitFotCgoK4OHhgT179kCj0QAAfve738Hf3x9+fn744YcfsGDBAqSlpWH37t3lXkun0wEAfHx8LPb7+PiIx+pDZWUqaePGjejUqRP69etX6fVCQ0Mxfvx4BAQE4Nq1a3j33XcxYsQIJCYmQqFQ1FUxLHz++ec4f/48zpw5U+aYTqeDi4sLPD09LfZX9rpL5b2qrFyl3b17FytWrMDMmTMrTSeF98temEwmzJ49G/3790fnzp0B2N/nqbwylGYPn52KymFv9XB13g8p170V/f1ITk6W7PfCYQOUjh07Ijk5GXq9Hrt27cLUqVORkJAAjUZj8WXu0qULfH19MWzYMFy7dg3t2rWzYa4rV1mZij18+BDbt2/H4sWLq7zexIkTxf936dIFXbt2Rbt27XDs2DEMGzasTspQ0o0bN/DWW2/h4MGDcHNzq/Pnqy/WlMtgMGDUqFHQaDRYtmxZpWlt/X7Zk4iICKSkpODEiRO2zkqNVVUGe/nsVFQOe6uHq3o/pF73VvT3Q8octovHxcUF7du3R8+ePREdHY1u3bphzZo15aYNCgoCAFy9erXc42q1GgDK3NWclZUlHqsP1SnTrl278ODBA4SHh1t9/bZt26JZs2YVvg617dy5c8jOzkaPHj3g5OQEJycnJCQkYO3atXBycoKPjw8ePXqE3Nxci/Mqe92l8F5VVS6j0QgAyMvLQ2hoKJo0aYI9e/bA2dnZquep7/fLXkRGRmL//v04evQoWrZsKe5Xq9V283mqqAzF7OWzU1U5SpJyPVydcki97q3o74eUvxcOG6CUZjKZUFhYWO6x5ORkAICvr2+5xwMCAqBWq3H48GFxn8FgQFJSUrn3gNSX8sq0ceNGjB07Fs2bN7f6ejdv3sS9e/cqfB1q27Bhw3Dx4kUkJyeLW69evTB58mTx/87Ozhave1paGjIyMip83aXwXlVVLoVCAYPBgOHDh8PFxQVxcXE1akGq7/dL6gRBQGRkJPbs2YMjR44gICDA4njPnj0l/3mqqgzFzy/1z051ylGaFOtha8phT3Uv8OvfD0l/L2rtdlsJWbhwoZCQkCCkp6cLP/zwg7Bw4UJBJpMJ3377rXD16lVh+fLlwtmzZ4X09HThyy+/FNq2bSsMGjTI4hodO3YUdu/eLT5euXKl4OnpKXz55ZfCDz/8IDz//PP1OnS1sjIVu3LliiCTyYRvvvmm3GuULFNeXp4wb948ITExUUhPTxcOHTok9OjRQ+jQoYNQUFBQL2UqT+k7+//whz8IrVu3Fo4cOSKcPXtW0Gq1glartThHau9VeUqWS6/XC0FBQUKXLl2Eq1evWgw1fPz4sXiOPbxfUjJr1ixBpVIJx44ds3hNHzx4IKaR+uepqjLYy2enqnLYSz1cnc+UIEi/7q3q74dUvxcOGaBMmzZN8Pf3F1xcXITmzZsLw4YNE9+IjIwMYdCgQYKXl5fg6uoqtG/fXpg/f36Z8fcAhE2bNomPTSaTsHjxYsHHx0dwdXUVhg0bJqSlpUmiTMUWLVoktGrVSjAajeVeo2SZHjx4IAwfPlxo3ry54OzsLPj7+wszZswQdDpdXRelUqUDlIcPHwqvv/668NRTTwmNGjUSfvvb3wqZmZkW50jtvSpPyXIdPXpUAFDulp6eLp5jD++XlFT0mpb8bEj981RVGezls1NVOeylHq7OZ0oQpF/3VvX3Q6rfC9kvT0xEREQkGQ3mHhQiIiKyHwxQiIiISHIYoBAREZHkMEAhIiIiyWGAQkRERJLDAIWIiIgkhwEKERERSQ4DFCIiIpIcBihEREQkOQxQiIiISHIYoBAREZHk/D9WhtzGyk4S/wAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGxCAYAAABIjE2TAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACcjUlEQVR4nOzdd3hUVfrA8e9Meg8JqRAgdEJC76KgdARUVER0FcvqKrIblUWxARYQ7AuKqz9XUASsKFhoUhQRqQFCILQAISSEkF4nmbm/P25mwpA2A5PMJHk/zzNP7sw9985JSA7vnPIejaIoCkIIIYQQDkRr7woIIYQQQlxJAhQhhBBCOBwJUIQQQgjhcCRAEUIIIYTDkQBFCCGEEA5HAhQhhBBCOBwJUIQQQgjhcCRAEUIIIYTDkQBFCCGEEA5HAhRRydKlS9FoNGaPoKAghg4dyo8//mjv6gkhHNyVbYizszNhYWFMnjyZ48eP27Vup0+fRqPR8Oabb9q1HqJ2zvaugHBcn376KZ07d0ZRFNLS0li8eDHjx49nzZo1jB8/3t7VE0I4OGMbUlxczB9//MFrr73Gli1bOHr0KM2aNbN39YSDkwBFVCs6Opo+ffqYno8ePZpmzZqxcuXKagMUvV5PWVkZbm5u9VVNIYSDurwNGTp0KHq9ntmzZ/P999/zwAMP2Ll2wtHJEI+wmLu7O66urri4uAAVXaULFy7k1VdfJTIyEjc3N7Zs2QLAnj17mDBhAgEBAbi7u9OzZ0+++uors3tevHiRxx9/nKioKLy9vQkODuamm27i999/NytnfK833niDBQsW0KZNGzw8PBg6dCjHjh2jtLSUZ599lvDwcPz8/LjttttIT0+vnx+MEMIixmDlwoULptfWrFnDwIED8fT0xMfHhxEjRvDnn3+aXXfixAkeeOABOnTogKenJy1atGD8+PEcOnSo0ntkZ2fz9NNP07ZtW9zc3AgODmbs2LEcPXq0Utm3336byMhIvL29GThwIDt37rTxdyyuhfSgiGoZe0MUReHChQu88cYbFBQUMGXKFLNy//nPf+jYsSNvvvkmvr6+dOjQgS1btjB69Gj69+/Phx9+iJ+fH6tWreKuu+6isLCQqVOnApCZmQnA7NmzCQ0NJT8/n9WrVzN06FB+/fVXhg4davZe77//Pt26deP99983NUTjx4+nf//+uLi48L///Y8zZ84wY8YMHn74YdasWVMfPyohhAWSkpIA6NixIwArVqzgnnvuYeTIkaxcuZKSkhIWLlxo+vsfPHgwAOfPnycwMJDXX3+doKAgMjMzWbZsGf3792f//v106tQJgLy8PAYPHszp06d55pln6N+/P/n5+fz222+kpqbSuXNnU13ef/99OnfuzLvvvgvAiy++yNixY0lKSsLPz68efyqiWooQV/j0008VoNLDzc1N+eCDD0zlkpKSFEBp166dotPpzO7RuXNnpWfPnkppaanZ6+PGjVPCwsIUvV5f5XuXlZUppaWlyrBhw5Tbbrut0nt1797d7Np3331XAZQJEyaY3Sc2NlYBlJycnKv+OQghro6xDdm5c6dSWlqq5OXlKevWrVNCQ0OVG264QSktLVX0er0SHh6uxMTEmP1N5+XlKcHBwcqgQYOqvX9ZWZmi0+mUDh06KE8++aTp9ZdfflkBlI0bN1Z7rbEtiYmJUcrKykyv79q1SwGUlStXXuN3L2xFhnhEtT777DN2797N7t27+eWXX7j//vuZNm0aixcvNis3YcIE07APqN2xR48e5Z577gGgrKzM9Bg7diypqakkJiaayn/44Yf06tULd3d3nJ2dcXFx4ddff+XIkSOV6jR27Fi02opf2y5dugBw8803m5Uzvn727Nlr/CkIIa7WgAEDcHFxwcfHxzSH7YcffsDZ2ZnExETOnz/P3/72N7O/aW9vb26//XZ27txJYWEhoLYh8+bNIyoqCldXV5ydnXF1deX48eNm7cQvv/xCx44dGT58eK11u/nmm3FycjI979atGwBnzpyx1bcvrpEEKKJaXbp0oU+fPvTp04fRo0fz3//+l5EjRzJz5kyys7NN5cLCwsyuM44vz5gxAxcXF7PH448/DkBGRgagjgE/9thj9O/fn2+//ZadO3eye/duRo8eTVFRUaU6BQQEmD13dXWt8fXi4uJr+AkIIa6F8UPO5s2befTRRzly5Ah33303AJcuXQIqtx8A4eHhGAwGsrKyAHjqqad48cUXufXWW1m7di1//fUXu3fvpnv37mbtxMWLF2nZsqVFdQsMDDR7bpzYX1W7I+xD5qAIq3Tr1o3169dz7NgxgoODAdBoNGZlmjdvDsCsWbOYOHFilfcxjhkvX76coUOHsmTJErPzeXl5tq66EKKeGT/kANx4443o9Xr+7//+j2+++YauXbsCkJqaWum68+fPo9VqTUuRly9fzn333ce8efPMymVkZODv7296HhQUxLlz5+rouxH1TXpQhFXi4uIAtSGoTqdOnejQoQMHDhww9cBc+fDx8QHU4ObKJckHDx6sNItfCNHwLVy4kGbNmvHSSy/RqVMnWrRowYoVK1AUxVSmoKCAb7/91rSyB6puJ3766SdSUlLMXhszZgzHjh1j8+bNdf/NiDonPSiiWvHx8ZSVlQFqd+x3333Hxo0bue2224iMjOT06dPVXvvf//6XMWPGMGrUKKZOnUqLFi3IzMzkyJEj7Nu3j6+//hqAcePG8corrzB79myGDBlCYmIiL7/8MpGRkab3FkI0Ds2aNWPWrFnMnDmTFStWsHDhQu655x7GjRvHo48+SklJCW+88QbZ2dm8/vrrpuvGjRvH0qVL6dy5M926dWPv3r288cYblYZzYmNj+fLLL7nlllt49tln6devH0VFRWzbto1x48Zx44031ve3LK6BBCiiWpcnUvLz8yMyMpK3337bNI+kJjfeeCO7du3itddeIzY2lqysLAIDA4mKimLSpEmmcs8//zyFhYV88sknLFy4kKioKD788ENWr17N1q1b6+LbEkLY0fTp01m8eDEvv/wyR44cwcvLi/nz53PXXXfh5OTEgAED2LJlC4MGDTJd89577+Hi4sL8+fPJz8+nV69efPfdd7zwwgtm9/bx8WH79u3MmTOHjz76iLlz59KsWTP69u3LI488Ut/fqrhGGuXyvjUhhBBCCAcgc1CEEEII4XAkQBFCCCGEw5EARQghhBAORwIUIYQQQjgcCVCEEEII4XAkQBFCCCGEw2mQeVAMBgPnz5/Hx8enUpp1IUT9UBSFvLw8wsPDzTZ7c2TSdghhX9a0Gw0yQDl//jwRERH2roYQAkhOTrZ4gzZ7k7ZDCMdgSbvRIAMU4z4uycnJ+Pr62rk2QjRNubm5REREmP4eGwJpO4SwL2vajQYZoBi7Zn19faWREcLOGtJQibQdQjgGS9qNhjFwLIQQQogmRQIUIYQQQjgcCVCEEEII4XAa5BwUSyiKQllZGXq93t5VEfXMyckJZ2fnBjU3QjgOaTuaLmk7HEujDFB0Oh2pqakUFhbauyrCTjw9PQkLC8PV1dXeVRHAkiVLWLJkCadPnwaga9euvPTSS4wZMwZQg4K5c+fy0UcfkZWVRf/+/Xn//ffp2rWr6R4lJSXMmDGDlStXUlRUxLBhw/jggw9susRZ2g4hbYfjaHQBisFgICkpCScnJ8LDw3F1dZVouAlRFAWdTsfFixdJSkqiQ4cODSaJWGPWsmVLXn/9ddq3bw/AsmXLuOWWW9i/fz9du3Zl4cKFvP322yxdupSOHTvy6quvMmLECBITE03LEWNjY1m7di2rVq0iMDCQp59+mnHjxrF3716cnJyuuY7SdjRt0nY4IKUBysnJUQAlJyen0rmioiIlISFBKSgosEPNhKMoKChQEhISlKKiIntXpdGq6e/QEs2aNVP+7//+TzEYDEpoaKjy+uuvm84VFxcrfn5+yocffqgoiqJkZ2crLi4uyqpVq0xlUlJSFK1Wq6xbt84mdZa2QyiKtB11zZp2o9GGhxL5Nm3y7++49Ho9q1atoqCggIEDB5KUlERaWhojR440lXFzc2PIkCHs2LEDgL1791JaWmpWJjw8nOjoaFOZqpSUlJCbm2v2qI387jRt8u/vOBrdEI8Q4urpDQq7kjJJzysm2MedfpEBOGltM8xx6NAhBg4cSHFxMd7e3qxevZqoqChTgBESEmJWPiQkhDNnzgCQlpaGq6srzZo1q1QmLS2t2vecP38+c+fOtUn9hRDVMOjhzA7IvwDeIdB6EGivfdhVAhQhBADr4lOZuzaB1Jxi02thfu7MHh/F6Oiwa75/p06diIuLIzs7m2+//Zb777+fbdu2mc5fOd9DUZRa54DUVmbWrFk89dRTpufGNNtCCBtJWAPrnoHc8xWv+YbD6AUQNeGabi19WTXQGxT+PHmJH+JS+PPkJfQGxd5VanA0Gg3ff/+9xeW3bt2KRqMhOzu7zuokKlsXn8pjy/eZBScAaTnFPLZ8H+viU6/5PVxdXWnfvj19+vRh/vz5dO/enffee4/Q0FD1va7oCUlPTzf1qoSGhqLT6cjKyqq2TFXc3NxMae3rK729tBvXTtqNBiJhDXx1n3lwApCbqr6esOaabi8BSjXWxacyeMFm7v54J/9aFcfdH+9k8ILNNmmoqzN06FBiY2Pr7P72kJqaalpKaitz5syhR48eNr1nU6Y3KMxdm0BV/40aX5u7NsHm/9EqikJJSQmRkZGEhoayceNG0zmdTse2bdsYNGgQAL1798bFxcWsTGpqKvHx8aYyjkDaDduQdqMBMOjVnpOaWo51z6rlrpIEKFWoj0+TV0spTyLVUISGhuLm5mbvaoga7ErKrPS7fjkFSM0pZldS5lW/x3PPPcfvv//O6dOnOXToEM8//zxbt27lnnvuQaPREBsby7x581i9ejXx8fFMnToVT09PpkyZAoCfnx8PPfQQTz/9NL/++iv79+/n3nvvJSYmhuHDh191vWxJ2g3bkXajATizo3LPiRkFclPUclepSQQoiqJQqCuz6JFXXMrsNYdr/DQ5Z00CecWlFt1PUSz71Dl16lS2bdvGe++9h0ajQaPRcPr0aVPX5fr16+nTpw9ubm78/vvvTJ06lVtvvdXsHrGxsQwdOtTs+164cCFt27bFw8OD7t27880331Rbh0WLFhETE2N6/v3336PRaHj//fdNr40aNYpZs2aZnq9du5bevXvj7u5O27ZtmTt3rllDeGVX7Y4dO+jRowfu7u706dPH9B5xcXFmddm7dy99+vTB09OTQYMGkZiYCMDSpUuZO3cuBw4cMP2cli5dasFPWFQnPa/64ORqylXlwoUL/O1vf6NTp04MGzaMv/76i3Xr1jFixAgAZs6cSWxsLI8//jh9+vQhJSWFDRs2mG3J/s4773DrrbcyadIkrrvuOjw9PVm7dq1NcqBURdoNaTdEDfIv2LZcFZrEJNmiUj1RL623yb0UIC23mJg5Gywqn/DyKDxda/8xv/feexw7dozo6GhefvllAIKCgkyZN2fOnMmbb75J27Zt8ff3t+i9X3jhBb777juWLFlChw4d+O2337j33nsJCgpiyJAhlcoPHTqUf/3rX2RkZNC8eXO2bdtm+jpt2jTKysrYsWMHTz75JADr16/n3nvv5T//+Q/XX389J0+e5JFHHgFg9uzZle6fl5fH+PHjGTt2LCtWrODMmTPVdk0///zzvPXWWwQFBfGPf/yDBx98kD/++IO77rqL+Ph41q1bx6ZNmwD107W4esE+7jYtV5VPPvmkxvMajYY5c+YwZ86casu4u7uzaNEiFi1adNX1sIa0G9JuiBp4Vz/366rKVaFJBCgNgZ+fH66urnh6epomDV7u5ZdfNn3atERBQQFvv/02mzdvZuDAgQC0bduW7du389///rfKhiY6OprAwEC2bdvG7bffztatW3n66ad55513ANi9ezfFxcUMHjwYgNdee41nn32W+++/33T/V155hZkzZ1bZ0HzxxRdoNBo+/vhj3N3diYqKIiUlhb///e+Vyr722mumOj777LPcfPPNFBcX4+Hhgbe3N87OzlX+nIT1+kUGEObnXu0wjwYI9VOXHAvHIu2GOWk36lHrQepqnWqHeTTq+dZXP0esSQQoHi5OJLw8yqKyu5Iymfrp7lrLLX2gr0UNtoeLbbqf+/TpY1X5hIQEiouLKzVOOp2Onj17VnmNRqPhhhtuYOvWrQwbNozDhw/zj3/8gzfffJMjR46wdetWevXqhbe3N6B2p+7evZvXXnvNdA+9Xk9xcTGFhYV4enqa3T8xMZFu3brh7l7xSbxfv35V1qVbt26m47AwdYlreno6rVq1suKnICzhpNUwe3wU/1i+r9I54wLe2eOjbJYPpaGQdqOCtBuiEq0TjHgFvn2oipPlbcXo168pH0qTCFA0Go1F3aUA13cIIszPnbSc4irHk42fJq/vEFSvDbaXl5fZc61WW2mcurS01HRsMBgA+Omnn2jRooVZuZomnw0dOpSPPvqI33//ne7du+Pv788NN9zAtm3b2Lp1q9lYtcFgYO7cuUycOLHSfS5vTIyqyllR3Vi7i4uL6dh4jfF7ErbXLsi7ytdDbZgHpaGRdkPaDVGLSyfUrxotKJf9nH3D1eDkGvOgNIkAxRrGT5OPLd+HBvMFVHX9adLV1dXiLd6DgoKIj483ey0uLs70BxoVFYWbmxtnz56tslu2Osbx5G+++cbUqAwZMoRNmzaxY8cO/vWvf5nK9urVi8TERNMGcLXp3LkzX3zxBSUlJabGbs+ePRbXzcian5OwzMpdyQAM7xLMQ4Pb1kkm2cZM2g1pN5qcrDOwXR3GY+LH6lwTG2eSbRKreKw1OjqMJff2ItTPPJoP9XNnyb296uzTZJs2bfjrr784ffo0GRkZNUb+N910E3v27OGzzz7j+PHjzJ4926zh8fHxYcaMGTz55JMsW7aMkydPsn//ft5//32WLVtW7X2N48lffPGFqaEZOnQo33//PUVFRaZxZICXXnqJzz77jDlz5nD48GGOHDnCl19+yQsvvFDlvadMmYLBYOCRRx7hyJEjrF+/njfffBOonEW0tp9TUlIScXFxZGRkUFJSYvG1orLiUj3f7T8HwD39WzOwXSC39GjBwHaBEpxYQdoNaTealPXPQVkxtLkeom+HyOsh5g71qw2CE6Dx7mZsi50oy/QGZceJDOX7/eeUHScylDK94ZrvWZPExERlwIABioeHhwIoSUlJypYtWxRAycrKqlT+pZdeUkJCQhQ/Pz/lySefVJ544gllyJAhpvMGg0F57733lE6dOikuLi5KUFCQMmrUKGXbtm011uP2229XnJycTD9fg8GgBAQEKH369KlUdt26dcqgQYMUDw8PxdfXV+nXr5/y0Ucfmc4DyurVq03P//jjD6Vbt26Kq6ur0rt3b2XFihUKoBw9elRRFKXK73f//v2mn4eiqDvd3n777Yq/v78CKJ9++mmletny96Cx+37/OaX1Mz8qA+dtsup3/Fp3M7aH+mg7pN1ouO2GokjbYZHjmxRltq+izGmmKGmHrbrUmnZDoygWLrh3ILm5ufj5+ZGTk1MpdXVxcTFJSUlERkZWOZ4pHMsXX3zBAw88QE5ODh4eHja7r/weWG7yR3+y81Qm/xrWgSdHdLT4upr+Dh2VtB2NQ121GyC/B7Uq08GSQXDpOPR/DMa8btXl1rQbMgdF1KvPPvuMtm3b0qJFCw4cOMAzzzzDpEmTbN7ICMskZRSw81QmWg1M6iub6AnHJO2GA/nrQzU48QqCoc/W6VtJgCLqVVpaGi+99BJpaWmEhYVx5513mi03FPVr1e6zAAzpGEQLf2nshWOSdsNB5KbCtgXq8fA54OFfp28nAYqoVzNnzmTmzJn2roYAdGUGvt2rTo6d3E/yRAjHJe2Gg9g0G3T50KIPdJ9S529n9SqevLw8YmNjad26NR4eHgwaNIjduysSFCmKwpw5cwgPD8fDw4OhQ4dy+PBhs3uUlJQwffp0mjdvjpeXFxMmTODcuXPX/t0IISy26cgFMvJ1BPm4cVPnYHtXRwjhyM78CQe/BDQw9g3Q1v0iYKvf4eGHH2bjxo18/vnnHDp0iJEjRzJ8+HBSUlIAWLhwIW+//TaLFy9m9+7dhIaGMmLECPLy8kz3iI2NZfXq1axatYrt27eTn5/PuHHjZI26EPVo5S51eGdSn5a4OJU3BQY9JP0Oh75Rv17DVulCiEbCoIef/60e97oPWvSql7e1KkApKiri22+/ZeHChdxwww20b9+eOXPmEBkZyZIlS1AUhXfffZfnn3+eiRMnEh0dzbJlyygsLGTFihUA5OTk8Mknn/DWW28xfPhwevbsyfLlyzl06JBpEychRN1Kzixk+4kMAO7qUz68k7AG3o2GZePU9NXLxqnPE9bYsaZCCLvb8z+4cAjc/WDYS/X2tlYFKGVlZej1+kpLrzw8PNi+fTtJSUmkpaUxcuRI0zk3NzeGDBnCjh07AHUfhtLSUrMy4eHhREdHm8pcqaSkhNzcXLOHEOLqfbk7GUWBwe2b0yrQUw1Cvrqv8sZfuanq6xKkCNE0FVyCza+qxze9CF7N6+2trQpQfHx8GDhwIK+88grnz59Hr9ezfPly/vrrL1JTU0lLSwMgJMR8e+WQkBDTubS0NFxdXWnWrFm1Za40f/58/Pz8TI+ICFkOKcTVKtMb+Hqvmtr+7n6t1O7bdc9AlbvIlL+27lkZ7hGiKdr8MhRnQ0gM9H6gXt/a6jkon3/+OYqi0KJFC9zc3PjPf/7DlClTcHKqSG1b1cZOtaUkrqnMrFmzyMnJMT2Sk5OtrbYQotyWxItcyC0h0MuVEVEhcGZHDVumAyiQm6KWE0I0HSn7YG/5FgdjF4JT/S78tTpAadeuHdu2bSM/P5/k5GR27dpFaWkpkZGRhIaGAlTqCUlPTzf1qoSGhqLT6cjKyqq2zJXc3Nzw9fU1e9SLRjxhsE2bNrz77rum5xqNhu+///6a7mmLe4i6Z5wce3vvlrg6a9UNvixhabmmrhG3GyBtR5NhMMAvMwEFYiapGwDWs6sOh7y8vPDy8iIrK4v169ezcOFCU5CyceNGevbsCYBOp2Pbtm0sWKAmd+nduzcuLi5s3LiRSZMmAZCamkp8fDwLFy60wbdkIwlr1G7vyz9Z+obD6AXXvIW0I0pNTa007FadOXPm8P333xMXF3fV9xD2kZpTxNbEdAAmGzPHelf9waASS8s1ZU2s3QBpOxqtAyvh3G5w9YYRL9ulClYHKOvXr0dRFDp16sSJEyf497//TadOnXjggQfQaDTExsYyb948OnToQIcOHZg3bx6enp5MmaImdfHz8+Ohhx7i6aefJjAwkICAAGbMmEFMTAzDhw+3+Td4VYwTBq8ckzdOGJz0mUM0NjqdDldXV5vcy9j7Ze97iLr11e5zGBToHxlA2yBv9cXWg9T/RKsd5tGo5+3wCapBaSDtBkjbIWpRnKMmZQMYMhN862Yn7tpYPcSTk5PDtGnT6Ny5M/fddx+DBw9mw4YNuLi4AGrGv9jYWB5//HH69OlDSkoKGzZswMfHx3SPd955h1tvvZVJkyZx3XXX4enpydq1a83msdiUooCuwLJHcW5Ft1blG6lf1j2jlrPkflbsxTh06FCeeOIJnnjiCfz9/QkMDOSFF17AuJ9jmzZtePXVV5k6dSp+fn78/e9/B2DHjh3ccMMNeHh4EBERwT//+U8KCgpM901PT2f8+PF4eHgQGRnJF198Uem9r+xiPXfuHJMnTyYgIAAvLy/69OnDX3/9xdKlS5k7dy4HDhxAo9Gg0WhYunRplfc4dOgQN910Ex4eHgQGBvLII4+Qn59vOj916lRuvfVW3nzzTcLCwggMDGTatGmUlpZa/DMTltMbFL7ac9nkWCOtk/oJv0rl88JGv267LdQbigbSboC0HdJ22NjW16HgIgR2UDcErIXeoPDnyUv8EJfCnycvoTfYZg9iq3tQJk2aZBqaqYpGo2HOnDnMmTOn2jLu7u4sWrSIRYsWWfv2V6e0EOaF2+hmivpJ83ULVxI9dx5cvSy++7Jly3jooYf466+/2LNnD4888gitW7c2NShvvPEGL774Ii+88AKg/iGPGjWKV155hU8++YSLFy+aGqpPP/0UUP+Yk5OT2bx5M66urvzzn/8kPT292jrk5+czZMgQWrRowZo1awgNDWXfvn0YDAbuuusu4uPjWbdunSlvjZ+fX6V7FBYWMnr0aAYMGMDu3btJT0/n4Ycf5oknnjA1SgBbtmwhLCyMLVu2cOLECe666y569Ohh+n6F7fx2/CIp2UX4ebgwOvqKT6xh3aq+yDdcDU4c5JN/vWpA7QZI2yFth42kH4G//qsej1kAzjX3tK2LT2Xu2gRSc4pNr4X5uTN7fBSjo6+t50X24nEwERERvPPOO2g0Gjp16sShQ4d45513TH90N910EzNmzDCVv++++5gyZQqxsbEAdOjQgf/85z8MGTKEJUuWcPbsWX755Rd27txJ//79Afjkk0/o0qVLtXVYsWIFFy9eZPfu3QQEBADQvn1703lvb2+cnZ1r7Jb94osvKCoq4rPPPsPLS21oFy9ezPjx41mwYIFpQnSzZs1YvHgxTk5OdO7cmZtvvplff/1VGpk6sKp8cuzEXi1wd7miN+Tg1+rXyCFww7/VCbHeIeqwTlPrOWmgpO2QtuOaKYqaMVbRQ+dx0H5YjcXXxafy2PJ9lfoN03KKeWz5Ppbc2+uagpSmEaC4eKqfSCxxZgd8cUft5e75xrIxeRdPy9633IABA8yWWw8cOJC33nrLtA1Anz59zMrv3buXEydOmHW9KoqCwWAgKSmJY8eO4ezsbHZd586d8ff3r7YOcXFx9OzZ09TAXI0jR47QvXt3UwMDcN1112EwGEhMTDQ1Ml27djUb2gsLC+PQoUNX/b6iaum5xfx6RP3ke/eVGwMqChxcpR53vxsir6/n2jmoBtRugLQd0nbYQML3cPp3cHaHUTXvFq03KMxdm1DtoKYGmLs2gRFRoThpa04zUp2mEaBoNJZ3l7a7qXzCYCpVjyeXTxhsd5NdPlle/kcLYDAYePTRR/nnP/9ZqWyrVq1ITEwEKuemqYmHh8e1VZKa89pc/rpx7tLl5wwGwzW/vzD39d5zlBkUerXyp2OIj/nJ8/vg0glw9oAu4+xTQUfUiNoNkLZD1EJXAOufV4+vi4VmbWosvisp02xY50oKkJpTzK6kTAa2C7yqKtX9doQNjdmEwSv/SOp+wuDOnTsrPe/QoUO1E4h79erF4cOHad++faWHq6srXbp0oaysjD179piuSUxMJDs7u9o6dOvWjbi4ODIzM6s87+rqWuvGjlFRUcTFxZlNuPvjjz/QarV07NixxmuFbRkMCl/urmJyrNGBL9WvXcaBm0/l86J2dm43QNoOcY1+f1tNyOjfCgbH1lo8Pa/64ORqylVFApSqRE1QlwReubTKN7zOlwomJyfz1FNPkZiYyMqVK1m0aBH/+te/qi3/zDPP8OeffzJt2jTi4uI4fvw4a9asYfr06QB06tSJ0aNH8/e//52//vqLvXv38vDDD9f4Sefuu+8mNDSUW2+9lT/++INTp07x7bff8ueffwLqioCkpCTi4uLIyMigpKSk0j3uuece3N3duf/++4mPj2fLli1Mnz6dv/3tb9Um5BN1489TlzibWYiPmzM3d7vid1pfCvHfqsfd7qr/yjUmdmw3QNoOcQ0unYQd/1GPR80Hl9p7woJ93GstY025qkiAUp2oCRAbD/f/CLd/on6NPVTnjcx9991HUVER/fr1Y9q0aUyfPp1HHnmk2vLdunVj27ZtHD9+nOuvv56ePXvy4osvEhZW0Uh++umnREREMGTIECZOnMgjjzxCcHBwtfd0dXVlw4YNBAcHM3bsWGJiYnj99ddNn8Ruv/12Ro8ezY033khQUBArV66sdA9PT0/Wr19PZmYmffv25Y477mDYsGEsXrz4Gn464moYM8fe0jMcT9crRnVPbobCDPAKhrY32qF2jYyd2g2QtkNcg3WzQK9ThyA732zRJf0iAwjzqz740KCu5ukXefXzkTSKYuWCeweQm5uLn58fOTk5ldLeFxcXk5SURGRkZKVdlx3d0KFD6dGjh1kaaXF1GvLvgS1dyi9hwPxfKdUr/PTPwXQNv2JZ59cPwOHvYMDjMHq+Vfeu6e/QUUnbIWrTkH8PrkriOlh5F2hd4PE/oXkHiy/98eB5nlixv9LrxkHOqlbxWNNuSA+KEI3Yd/tSKNUrdGvpVzk4Kc6FxJ/V427V5zYSQjRSpcXqTuUAAx6zKjgBSM9Vh+iuXKQT6ud+zUuMoams4hGiCVIUhZW71eGdyX2rmBx7ZA2UFUPzThDWo34rJ4Swvz8XQ1YSeIeqKe2tkFmg491NxwB4+ZZo2gV5k55XTLCPOqxztUuLLycBigPZunWrvasgGpFdSZmculiAp6sTE3pUkRH1gDH3yV3qklrRYEnbIayWcw5+f0s9HvmK1Sv43t6YSG5xGV3CfLm7XyubBCRXkiEeIRqpVeVLiyd0D8fb7YrPIjnn4PR29TjmznqumRDC7ja8oG7n0Gqg1W3AkdRcVvyl9s7OHh9VJ8EJNOIApQHO/RU21NT//bMLdfx0KBWAyVXlPjn0NaBA68Fq3gNh0tR/d5q6JvHvf2obHF4NGi2MfcOqHlRFUXh5bQIGBcbGhDKg7dUlYbNEowtQjNkFCwsL7VwTYU/Gf/8rs002Fav3p6ArM9A51IfuLa+YHKsoFcnZZHKsibQdAppA26EvhV+eUY/7PAShMVZdvv7wBf48dQlXZy2zxlS/L5MtNLo5KE5OTvj7+5t23PT09LQqVbNo2BRFobCwkPT0dPz9/avNotmYKYrCql3q8M6U/q0q//6nHYKLR8DJDaJusUMNHZO0HU1bk2k7dn2s/v17BMCNz1l1aXGpnnk/HwHgkevbEhFg/Z5R1mh0AQpg2imzpm3BRePm7+9f446pjdn+5GwSL+Th7qLllh4tKhc4WN570mkMePjXa90cnbQdolG3HfnpsLU839Hw2eBpXRK1//2RxNnMQkJ83XhsaLs6qKC5RhmgaDQawsLCCA4OprS01N7VEfXMxcWl8X76scCq8syxY2PC8PO4opvaoC+ff4Kktq+CtB1NW6NvOzbNgZJcCO8JPf9m1aXpucW8v/kEAM+M7ozXlRPv60CjDFCMnJycGvcvmxBXyCsuZe0BdXJslRsDntoK+RfU7t32w+u3cg2ItB2i0UneBXFfqMdj37R648qF6xMp0OnpEeHPrVX1zNaBRjdJVoim7Ie48xSV6mkf7E2f1s0qFzAO70RPBGfX+q2cEMI+DHr4+d/qcY97oWUfqy4/kJzNN3vPAeqyYm0dLSu+kgQoQjQiq0yZYyMqT/AsyYcja9XjbpPruWZCCLvZ9xmkxoGbrzr3xAqKovDyjwkATOzZgp6tqvjgU0ckQBGikTh0Lof4lFxcnbRM7NWycoGjP6mJmQLaWv0JSgjRQBVmwq8vq8c3Pgfe1e9GXZU1B86z90wWHi5OzBzduQ4qWD0JUIRoJIz77oyODiXAq4rhG+PwTjdJbS9Ek7HlNSjKhKAu0Pdhqy4t1JXx+i9HAZh2YztC/ep3d2cJUIRoBApKylgTdx6Ayf0iKhfIS4NTW9RjSc4mRNOQehD2/E89HrsQnKxLPvfhtlOk5hTTwt+Dh69vWwcVrJkEKEI0Aj8ePE9+SRltAj0ZWFXq6UPfgGKAiP7qEI8QonFTFPhlpvp33/U2iLzBqstTsov477aTADx/cxfcXep/VZsEKEI0AivLM8dO7ldF5li4bHhHek+EaBIOfQ1n/wQXTxj5qtWXz//5CCVlBvpFBjAm2j6J6yRAEaKBO5qWS1xyNs5aDbdXNTk2/QikHQStC3SdWP8VFELUr5I82PCienz90+BXRbtQg11Jmfx4MBWNRl1WbK8tHyRAEaKBM+67MyIqhCAft8oFDqxSv3YYaXVqa1uZP38+ffv2xcfHh+DgYG699VYSExPNykydOhWNRmP2GDBggFmZkpISpk+fTvPmzfHy8mLChAmcO3euPr8VIRzftoWQn6YO5w6abtWlBoPCyz8eBtR0BV3D/Wq5ou5IgCJEA1Zcque7fep/0JOryhxrMFSktu9uv9T227ZtY9q0aezcuZONGzdSVlbGyJEjKSgoMCs3evRoUlNTTY+ff/7Z7HxsbCyrV69m1apVbN++nfz8fMaNG4der6/Pb0cIx3XxGOz8QD0evQCcq/jQUoNv9p4jPiUXHzdnnh7ZqQ4qaLlGnepeiMbu50Op5BaX0cLfg+vbN69c4Mx2yE0Bdz/oMKr+K1hu3bp1Zs8//fRTgoOD2bt3LzfcUDF5z83NrdqN2nJycvjkk0/4/PPPGT5cTdO/fPlyIiIi2LRpE6NG2e/7E8IhGCfGGsqg42joONKqy/OKS1m4Xl1W/K/hHWjubV1wY2vSgyJEA2Yc3pncN6Lq9NPGybFRt4JL/eYwqElOTg4AAQHmQ05bt24lODiYjh078ve//91sV+G9e/dSWlrKyJEVjW54eDjR0dHs2LGjyvcpKSkhNzfX7CFEo3X0RzWdgJMrjJ5v9eWLt5wgI19H2+Ze3Dewje3rZyUJUIRooE6k57HrdCZaDdzZp4rcJ6VFkLBGPe7uOKntFUXhqaeeYvDgwURHR5teHzNmDF988QWbN2/mrbfeYvfu3dx0002UlJQAkJaWhqurK82amafaDgkJIS0trcr3mj9/Pn5+fqZHREQVPychGgNdIax7Tj0e9E+r0wmczijgf9uTAHhhXBdcne0fHsgQjxANlLH35KbOIVVneEz8Wd1a3b8VRAyofN5OnnjiCQ4ePMj27dvNXr/rroo5MtHR0fTp04fWrVvz008/MXFi9auPFEWpdpXBrFmzeOqpp0zPc3NzJUgRjdMf70HOWfBtCdc/VXv5K7z28xFK9Qo3dAzixk7WpcOvK/YPkYQQVisp0/Nt+eTYu6vKHAtw8Cv1a8wk0DrGn/r06dNZs2YNW7ZsoWXLmpc+hoWF0bp1a44fPw5AaGgoOp2OrKwss3Lp6emEhIRUeQ83Nzd8fX3NHkI0OlmnYfs76vGoV8HVy6rLtx/PYGPCBZy0Gl4a18Vuy4qv5BitlhDCKusPXyCrsJRQX3eGdAyqXKAgA05sUo+72W/1jpGiKDzxxBN89913bN68mcjIyFqvuXTpEsnJyYSFhQHQu3dvXFxc2Lhxo6lMamoq8fHxDBo0qM7qLoTDW/886EvUbLFRt1p1aZneYFpW/LcBrWkf7FMHFbw6MsQjRAO0ape6MeCkvhE4O1XxOSP+W3Umf3hPCOpYz7WrbNq0aaxYsYIffvgBHx8f05wRPz8/PDw8yM/PZ86cOdx+++2EhYVx+vRpnnvuOZo3b85tt91mKvvQQw/x9NNPExgYSEBAADNmzCAmJsa0qkeIJufEJnVyrMYJxiy0eiPQFbvOcuxCPs08XXhyuP3bistJgCJEA3PmUgE7Tl5Co4FJfaoZJjGltneMybFLliwBYOjQoWavf/rpp0ydOhUnJycOHTrEZ599RnZ2NmFhYdx44418+eWX+PhUfKJ75513cHZ2ZtKkSRQVFTFs2DCWLl2Kk1P97xMihN2V6eCXZ9Tj/v+A4C5WXZ5dqOPtjccAeGpER/w8rdtMsK5JgCJEA7Nqtzo59oYOQbRs5lm5QMZxSNmrfqKKvr2ea1c1RVFqPO/h4cH69etrvY+7uzuLFi1i0aJFtqqaEA3Xzg/g0gnwCoahz1h9+bubjpNdWEqnEB/urirRo53JHBQhGpBSvYGv91g4Obb9MPCuYn6KEKLhyz0Pv72hHo+YqyZjtMKxC3l8vvMMAC+Nj6p6qNjOHK9GQohq/XrkAhn5JTT3dmNYlypWrijKZcM79p8cK4SoIxtfAl0+tOxn9VCuoii88mMCeoPCyKgQrqsqC7UDkABFiAZkZXnukzv7tMSlqk88Z3dC9hlw9YFOY+u5dkKIenH6j/I9tjQw9g2r0wj8eiSd349n4Oqk5fmbrZu3Up8kQBGigUjOLOS34xcBNbV9lUyp7SeAaxXzU4QQDZu+TN1vB6D3VAjvYdXlujIDr/6UAMCDgyNpHWhdzpT6JAGKEA3E13uSURS4rn1g1Y1KWQkcXq0ey/COEI3Tnv/BhXhw94dhL1l9+dIdSZy+VEiQjxtP3NTe9vWzIQlQhGgAyvQGviqfHDu5bzWz7Y9vgOJs8AmHNoPrr3JCiPpRkAFbXlWPh70IngE1l7/CxbwSFv16AoB/j+qEt5tjL+SVAEWIBmBr4kXScotp5unCyK5Vp3XnwCr1a7c7QSt5QYRodH6dC8U5EBoDvR+w+vK3NiSSV1JGTAs/7uhV81YTjkACFCEagFW71cyxd/RuiZtzFcFHYSYcK88j4iDJ2YQQNpSyF/Z9rh6PfdPqDyHxKTl8uUedZD97fBRarWPst1MTCVCEcHBpOcVsPpoOwF3VDe8kfA+GUgiJgZCo+qucEKLuGQzw878BRZ1f1sq63ckVReHltQkoCkzoHk6fNtYNDdmLBChCOLiv9yRjUKBfmwDaB3tXXehA+eqd7jI5VohG58AKtQfF1RtGvGz15T8fSmPX6UzcXbQ8O6ZzHVSwbkiAIoQDMxgUU2r7ydVljs1MguSdoNFC9B31WDshRJ0ryoaNs9XjIc+AT6hVlxeX6pn38xEA/jGkHeH+HjauYN2RAEUIB/b7iQxSsovwdXdmbExY1YUOfa1+jRwCvtWUEUI0TFtfh8IMaN5R3RDQSh//doqU7CLC/dx59IZ2dVDBuiMBihAObNUudXLsxF4tcXepYlKcolSs3ukuk2OFaFQuHIZdH6nHYxaAs6tVl6fmFPHB1pMAPDu2Cx6uDWt1nwQoQjioi3klbEy4ANQwvJOyDzJPgosndB5Xj7UTQtQpRYGfZ4Kihy7jod1NVt9iwS9HKSrV06d1M8Z3a3i9qxKgCOGgvtl7jjKDQs9W/nQO9a260MHy3pPO48Ctmgm0QoiG5/B3cGY7OLvDqHlWX773TBbfx51Ho4HZ47ui0Tj+suIrSYAihAMyGBS+LM99cnd1S4v1pRD/rXosq3eEaDxK8mH9C+rx4KfAv5o2oBoGg8LLaw8DcGfvlsS09LN1DeuFBChCOKCdpy5x+lIh3m7OjOteTdfsiV+h8BJ4BUPk0PqsnhCiLv3+FuSdB//WcN0/rb589f4UDpzLwdvNmRmjOtVBBeuHBChCOKCV5UuLb+kRjqdrNftlGId3Yu4EJ8feU0MIYaFLJ2HHIvV49HxwsW5ZcEFJGQvWHQXgiZvaE+zjbusa1hsJUIRwMJkFOtbHpwFwd79qunaLc+Doz+pxt0n1VDMhRJ1SFPjlGTUrdPvh0Gms1bf4YOsJ0vNKaB3oyQPXtbF9HeuRBChCOJjv9p1DpzcQ3cKX6BbVjB0nrAF9CQR1hrDu9VtBIUTdOLYOTmwErQuMXgBWTmxNzizk49+TAHh+bJeq9+1qQCRAEcKBKIrCyvLcJ5OrmxwLcLA8tX23u6xuxIQQDqi0GNY9qx4PnAbN21t9i3k/H0FXZuC69oGMiKpm1/MGRAIUIRzInjNZnLxYgIeLE7f0CK+6UHYynP5dPY65s/4qJ4SoOzsWQdZp8AmDG/5t9eV/nrzEL/FpaDXw0riGuaz4ShKgCOFAjL0n47uH4ePuUnUhY2r7NteDfzUJ3IQQDUd2srpyB2Dkq1bnNNIbFOaWLyu+p39rOoX62LqGdiEBihAOIqewlJ8OpgIwubrJsYpy2fCOTI4VolHY8DyUFUHr6yD6dqsvX7X7LEfT8vDzcOGpER3roIL2IQGKEA7i+7gUSsoMdA71oWeEf9WF0g7CxaNqdsmoW+q1fkKIOnBqKyT8oO5GPmah1XPKcopKeWvDMQCeHN6BZl7W7dfjyCRAEcIBmE+Ojah+/PhAee9JpzHg3jCzQwohyulL1f12APr+HUKjrb7Ff349TmaBjvbB3twzoLWNK2hfEqAI4QDikrM5mpaHm7OW23q2rLqQvgziv1GPu0lqeyEavL/+CxmJ4BkIN86y+vIT6fks23EagBfHReHi1Lj+S29c340QDdSqXWrm2LExYfh5VjM5Nmkr5F9QG7P2w+uvckII28u7AFtfV4+HzwGPZlbf4rWfEigzKAzrHMyQjkG2rZ8DkABFCDvLLylj7cHzQA2ZY6FieCf6dnCqJogRQjQMm2aDLg/Ce0GPe62+fEtiOlsSL+LipOH5m7vUQQXtTwIUIexsTdx5CnV62gV50bdNNZ+iSvLh6I/qsQzvCNGwnf0LDqxUj8e+CVrr/isu1Rt45ccEAKYOakPbIOuWJTcUEqAIYWeXZ46tdnLs0R+htBAC2kGL3vVYOyGETRn08PMM9bjnvdDS+r/nz/48w6mLBQR6uTJ9WAcbV9BxSIAihB3Fp+RwKCUHVyctt/euZnIswIHynYsltb0QDdu+ZWq6ADc/GDbH6ssv5Zfw7iZ1WfGMUZ3wrS6hYyNgVYBSVlbGCy+8QGRkJB4eHrRt25aXX34Zg8FgKqMoCnPmzCE8PBwPDw+GDh3K4cOHze5TUlLC9OnTad68OV5eXkyYMIFz587Z5jsSogFZtVvtPRnZNYSA6vIX5KZC0jb1WJKzCdFwFWbCry+rxzc+B97WT2x9e+Mx8orLiArzZVKfxp1J2qoAZcGCBXz44YcsXryYI0eOsHDhQt544w0WLVpkKrNw4ULefvttFi9ezO7duwkNDWXEiBHk5eWZysTGxrJ69WpWrVrF9u3byc/PZ9y4cej1ett9Z0I4uEJdGd/vt2BybPw3oBggYgAERNZT7YQQNrf5VSjKguAo6Puw1ZcfSc01DQnPHh+Fk7Zx96Y6W1P4zz//5JZbbuHmm28GoE2bNqxcuZI9e/YAau/Ju+++y/PPP8/EiRMBWLZsGSEhIaxYsYJHH32UnJwcPvnkEz7//HOGD1eXSi5fvpyIiAg2bdrEqFGjbPn9CeGwfjyYSn5JGa0DPRnYNrD6gpLaXoiG73wc7Pmfejz2DXCy6r9fFEXh5bUJGBS4OSaM/jW1GY2EVT0ogwcP5tdff+XYMXX868CBA2zfvp2xY8cCkJSURFpaGiNHjjRd4+bmxpAhQ9ixYwcAe/fupbS01KxMeHg40dHRpjJXKikpITc31+whREO3qvyT0F19I9BW90noQgKkHQInV+h6Wz3WTghhM4oCv8wEFDVNQJvBVt9i/eEL/HnqEm7OWp4d09n2dXRAVoVwzzzzDDk5OXTu3BknJyf0ej2vvfYad999NwBpaWkAhISEmF0XEhLCmTNnTGVcXV1p1qxZpTLG6680f/585s6da01VhXBoiWl57DubjbNWwx01TY49WD45tsNI8Ayon8oJIWzr4JeQ/Be4eMGIV6y+vLhUz2s/q8uKH7mhLREBnrauoUOyqgflyy+/ZPny5axYsYJ9+/axbNky3nzzTZYtW2ZW7sqlkoqiVL980oIys2bNIicnx/RITk62ptpCOBzjOPKwLsEE+7hXXchggINfq8eS+0SIhqk4Fza8qB7fMAP8Wlh9i//9kURyZhGhvu48NrSdjSvouKzqQfn3v//Ns88+y+TJkwGIiYnhzJkzzJ8/n/vvv5/Q0FBA7SUJCwszXZeenm7qVQkNDUWn05GVlWXWi5Kens6gQYOqfF83Nzfc3Nys+86EcFDFpXpW708Bapkce/p3yDuvbgrYUeZmCdEgbVsABelqDqOB06y+/EJuMYs3nwDgmTGd8HS1bu5KQ2ZVD0phYSHaKzLeOTk5mZYZR0ZGEhoaysaNG03ndTod27ZtMwUfvXv3xsXFxaxMamoq8fHx1QYoQjQm6+LTyCkqpYW/B9d3qGGZoXFybNfbwFkCdCEanIuJ8NeH6vGYBVf1d7xwXSKFOj09W/lzS3fre18aMqtCsfHjx/Paa6/RqlUrunbtyv79+3n77bd58MEHAXVoJzY2lnnz5tGhQwc6dOjAvHnz8PT0ZMqUKQD4+fnx0EMP8fTTTxMYGEhAQAAzZswgJibGtKpHiMZsRfnwzqQ+EdUvE9QVQsIa9bjb5HqqmRDCZowTYw1l0GksdBhh9S0OJGfz7T41R9js8V2rn0zfSFkVoCxatIgXX3yRxx9/nPT0dMLDw3n00Ud56aWXTGVmzpxJUVERjz/+OFlZWfTv358NGzbg4+NjKvPOO+/g7OzMpEmTKCoqYtiwYSxduhQnJyfbfWdCOKCTF/PZlZSJVgOT+tYwOTbxZ3UjMf9W0GpA/VVQCGEbR9bAqa3g5Aaj5ll9uaIozF2rJjmd2KsFPSL8bVu/BkCjKIpi70pYKzc3Fz8/P3JycvD19bV3dYSw2Lyfj/DRb6cY1jmYT6b2rb7gF5Pg+Hq44d9w0wv1V0ErNMS/w4ZYZ9EA6Qrh/X6Qkww3zISbnrf6Fj/EpfCvVXF4ujqxZcZQQnyrmUzfwFjzNyh78QhRT0rK9HyzV+2unVzT5Nj8i3Bik3osq3eEaHi2v6MGJ34RMPhJqy8v1JUx/+ejAEy7sX2jCU6sJQGKEPVkY8IFMgt0hPi6cWOnGibHxn8Lih7Ce0HzxrtTqRCNUmYS/PGeejzqNXC1PmfJh9tOkZZbTMtmHjw0uOlubyEBihD1ZNUuNX/PpD4RODvV8KdnXL3TXSbHCtHgrH8O9CUQOQS6TLD68nNZhfx320kAnh/bBXeXpjs3UwIUIerB2UuFbD+RgUZDzTuQZhyH8/tA46SmxG4k5s+fT9++ffHx8SE4OJhbb72VxMREszKyE7po8I5vVCe4a51hzEKoJUFpVV7/5SglZQb6RwYwOjq0DirZcEiAIkQ9WLVbXVo8uH3zmtNUHyhPbd9+OHg1r4ea1Y9t27Yxbdo0du7cycaNGykrK2PkyJEUFBSYyshO6KJBKyuBX55Rj/v/A4Kt3y9nV1ImPx5MRauBl8ZH1ZqBvbFrOinphLCTUr2Br8snx06paXKswQCHvlKPuzeuybHr1q0ze/7pp58SHBzM3r17ueGGG2QndNHw/fk+ZJ4E7xAY8ozVl+sNFcuKJ/drRddwP1vXsMGRHhQh6tjmo+lczCuhubcrw7qEVF8weSdknwVXHzWxUyOWk5MDQECAugGi7IQuGrScFPjtTfV4xMvgbv0S9m/2JnP4fC4+7s48PaKjjSvYMEmAIkQdM24MeHvvlrg6WzA5NuoWcPGoh5rZh6IoPPXUUwwePJjo6Gig5p3Qjeeudid0Pz8/0yMioob5P0JcrY0vQmkBRPS/qtQAecWlvLFenZP1r2EdCPSWrS1AhniEqFMp2UVsO3YRgMl9axjeKS2Gw6vV40Y2vHOlJ554goMHD7J9+/ZK5+piJ/SnnnrK9Dw3N1eCFHHtDHo4swPyL0B+upoaAA2MfeOqJsYu3nyCjHwdbZt7cd/ANjavbkMlAYoQdeir3ckoCgxsG0hkc6/qCx5fD8U54NsCWg+uvwrWs+nTp7NmzRp+++03WrasSPUvO6GLBiNhDax7BnLPm7/e7kYI62717ZIyCvjfH0kAvDguquZe1iZGfhJC1BG9QeGrPWruk8n9avnUfrB8cmzMnaBtfH+WiqLwxBNP8N1337F582YiI82TT8lO6KJBSFgDX91XOTgBOLmlYoNPK7z20xFK9QpDOgZxY+dgG1Sy8ZAeFCHqyLZj6aTmFNPM04VRXWvIZ1CYCcfWq8eNNDnbtGnTWLFiBT/88AM+Pj6mOSN+fn54eHjITujC8Rn0as8JNWxft+5Z6HwzaC1Lrvb78YtsOnIBZ62GF8d1sU09GxEJUISoIyvLM8dO7NWy5myQh1eDoRRCYyC4cTZSS5YsAWDo0KFmr3/66adMnToVkJ3QhYM7s6PqnhMTBXJT1HKR19d6uzK9gZfXJgDwt4GtaR/sU8sVTY8EKELUgQu5xWw+mg7A3bUO75Sv3unWOHtPQB3iqY1Go2HOnDnMmTOn2jLu7u4sWrSIRYsW2bB2Qlgg/4JNy33x11mOp+fTzNOF2GGyrLgqjW+wWwgH8PWeZPQGhT6tm9X8ySjzFCT/BRotxNxRfxUUQljHu4YcRlaWyyrQ8fbGYwA8NbITfp4u11KzRksCFCFszGBQ+LJ8cuzdNWWOBTj4tfq17VDwadr7bgjh0FoPAt9woLplxJryVXi1T9h+d9MxcopK6Rzqw919Zdl7dSRAEcLG/jiZQXJmET7uzoyNCau+oKLAwfK9dxrx8I4QjYLWCUYvqOZkedAy+vVaJ8geu5DH8r/U5I0vjYuqeWfzJk5+MkLYmDFz7G09W+DhWkNjdW6POsTj4qnO/BdCOLaoCXDzW5Vf9w2HSZ+p52ugKAqv/JiA3qAwqmsIg9o3ng1B64JMkhXChjLyS9iYoE6SqzFzLFRMju0yHty867hmQgib0OvUryHRMPhJdc5J60EWLS3+9Ug6vx/PwNVJy/Njo+q4og2fBChC2NC3e89RqlfoHuFPVHgNG4aV6crTY3NVe3cIIezk6E/q1x5TrJrYXlKm59Wf1GXFD10fSatAz7qoXaMiQzxC2IiiKKzaXT45traJbyd/haJM9dNX5JB6qJ0Q4poVZqp5TsDqHceX7TjN6UuFBPm4Me3G9nVQucZHAhQhbGTnqUySMgrwcnVifPfwmgsfKJ8cG3MnOElHphANwrH1oOjV4Z2AyNrLl7uYV8J/fj0BwMxRnfB2k795S0iAIoSNrNqtTo6d0KMFXjU1QEXZkPiLeizDO0I0HInlwztW9p68tSGR/JIyurX04/ZeLWu/QAASoAhhE1kFOn6JV/eXqTVz7JE1oC+BoC5qenshhOMrLYITv6rHVqy6i0/JMeVFmj0+Cq22ujwq4koSoAhhA9/tT0FXZiAqzJeYFn41Fz5Qvnqn+12gkcZKiAbh1FYoLQTflhDW3aJLFEVh7trDKArc0iOc3q0D6raOjYwEKEJcI0VRWFWe++Tu/q3Q1BR0ZJ+FM9sBjTr/RAjRMBhX73Qea/EHi58OpbL7dBbuLlqeGd25DivXOEmAIsQ12nc2i+Pp+Xi4OHFLj1omxx4qT23fZjD4yVi0EA2CQV8xb8zC4Z3iUj3zfz4KwGND2hPu71FXtWu0JEAR4hqt+EsdX765Wxi+7jVs+qUolw3vSGp7IRqM5F1QmAHuftD6Oosu+ei3U6RkF9HC34NHbmhbxxVsnCRAEeIa5BSV8tOh84AFGwOmHoCMRHB2hy41p8QWQjgQ4+qdDqPAqfadh1Nziliy9SQAz47pXPOWF6JaEqAIcQ3WxKVQXGqgY4g3vVr511zYmNq+01hwryHLrBDCcSgKHPlRPbZweGfBL0cpKtXTt00zxnWrYcNQUSMJUIS4SoqisGKXOrwzuW8tk2P1ZXDoG/VYcp8I0XBcPApZSeDkCu2H1Vp875ksvo87j0YDs8d3rbldEDWSAEWIq3TwXA5HUnNxddYysVeLmguf2goF6eDZ3KJGTgjhIIyrd9oOBTefGosaDAovrz0MwKTeEUTXlnJA1EgCFCGukjFz7NjoUPw9XWsufLA8tX307RaNYQshHIRpeXHtwzvf7U/hwLkcvN2cmTGqUx1XrPGTAEWIq5BfUsaaOHVy7OTaJseW5FWMYcvwjhANR+55OL8P0EDHMTUWzS8pY+E6dVnx9JvaE+TjVg8VbNwkQBHiKqw9cJ4CnZ62zb3oH1lLdsgjP0JZEQS2hxa96qeCQohrl/iz+rVlX/AJqbHoB1tOkJ5XQutAT6Ze16bu69YESIAixFUwZo6d3C+i9klwxuGdbpMltb0QDYmFwztnLxXyf9uTAHjh5ijcnGVZsS1IgCKElQ6fz+HAuRxcnDS170yamwqntqnH3SS1vRANRnEOJP2uHtcSoMz7+Qi6MgOD2zdneJfgeqhc01DDnvBCiKqsKl9aPDIqlEDvWsaZD30NKNBqIDRrU+d1E0LYyPGNYCiF5h2heQezU3qDwq6kTNLzirmYV8K6w2k4aTW8OC5KlhXbkAQoQlihSKfn+7gUwILMsVCRnK3bpDqslRDC5ozDO53Gmr28Lj6VuWsTSM0pNnv9+vbN6RRa8zJkYR0Z4hHCCj8dSiWvuIyIAA8GtQusuXBaPFyIVxM8db2tfioohLh2ZSVqDwpA53Gml9fFp/LY8n2VghOAbccusi4+tb5q2CRIgCKEFVYaJ8f2bYVWW9vk2PLek46jwKNZHddMCHHNDHp13smWeaDLA69gaNEbUId15q5NQKnh8rlrE9AbaiohrCFDPEJY6NiFPPaeycJJq+HO3rVMjjXoJbW9EA1JwhpY94ya+8RIlw9Hf4SoCexKyqyy58RIAVJzitmVlMnA2npXhUWkB0UICxknxw7rHEywr3vNhU//Dnnnwd0fOoys+8oJIa5ewhr46j7z4ASgtFB9PWEN6XnVByeXs7ScqJ0EKEJYoLhUz3f7zwEWTo49UD68Ez0RnCWjpBAOy6BXe05qGrxZ9yzBXpZtURHsU8uHF2ExCVCEsMD6w2lkF5YS7ufODR2Dai6sK4Qja9RjGd4RwrGd2VG558SMArkptCk4gFMN8840QJifO/1qyywtLCYBihAWME6OndQ3osZGClDTY+vywb81RPSvh9oJIa5a/gWLii1eu73aCbDGFmH2+Kja2wdhMQlQhKjFqYv57DyViVYDk/pE1H7BAWNq+7sktb0Qjs675j12jE4WedM51IfXJ8YQ5mc+jBPq586Se3sxOjqsLmrYZMkqHiFq8eVudXLskI5BhPt71Fw4Px1OblaPu0+u45oJ0Xhcnp012EcdKqmX3ojiPNQ+kKp7RwwKpBGIoeUAvpw6AD9PF+7sE2GfujYxEqAIUQNdmYFv9loxOTb+W1D00KIPBLar49oJ0ThUlZ01zM+d2eOj6rZXYtfH8MtMQEFR1BDl8jjDOKLzqc+jLHt4EB6u6iaATlqNLCWuBzLEI0QNNh25wKUCHcE+btzU2YJNwEyp7WVyrBCWqC47a1pOMY8t31c32VkNBtjwAvw8AxQDa7TDmFY6nTTMJ7imEchjpbH8WNoHV2f577K+SQ+KEDUwTo69s09LnJ1qaaAuHoPz+0HrrC4vFkLUqKbsrArqwMvsNYfpHOpLmcFAcamB4lI9JWXmX4tLDZSU6as4r6ek1EDxZV8NuiKmZb/BYN0fACxiMm8Vjgc0rCvpTz/tUYLJJh1/dhk6Y0ALkoDNLiRAEaIayZmF/H48A4C7+liyMWD55Nj2w8GreR3WTIjGwZLsrBdySxj65labvF8AuXzs+ha9tcfRKU78u/RRfjAMNp03oGWnIarKayUBW/2TAEWIahgnx17foTmtAj1rLmwwwMGv1WMZ3hHCIpb+p+/ipMHbzRk3ZyfcXbQVX12ccHPW4n7ZV7Pz5V/dXZwILElmyO5n8S44S6mLL8eHfsj9EYMYmJbHs98dqrUOkoCt/kmAIkQVyvQGvtqjBiiT+1rQe3L2T8g5C26+0GlMHddOiMbB0v/0P3uw/7UNr5zdCSvvg6JM8G+Fyz3f0DWoEwDdW/rz3q/HScsprnKoSYO6jFgSsNU/mfUjRBU2H00nPa+EQC9XRkRZkCfBOLwTNQFcalmKLIQAoF9kAKF+1QcpNsnOeng1LJugBifhPeGhTVAenIC6Imf2+CjT+135/iAJ2OxFAhQhqrCqfHjnjt4ta5+9X1oMh39Qj7tJ7hMhLOWk1XB7rxZVnrvm4EBR4I/34OupoC+BTmNh6k/gU/kDx+joMJbc26tSsCQJ2OxLhniEuML57CK2JqYDcFdfCzLHHlsHJTng2xJaX1fHtROi8TAYFLYcvQiAl6sTBTq96VzoteRB0Zep+U32fKI+7/cojJ4PWqdqLxkdHcaIqFBJwOZAJEAR4gpf7UnGoED/yADaBnnXfsHBr9Sv3e4ErXRKCmGpn+NTSUjNxdvNmS0zhnIiPf/ag4OSfPjmQTi+HtDAqNdgwOMWbTshCdgciwQoQlxGb1D4qnx4Z0p/CybHFmbC8Q3qsQzvCGGxMr2BtzccA+Dh6yMJ8nEjyMft2m6alwYrJkHqAXB2h4kfQdQtNqitsAcJUIS4zG/HL3I+pxh/TxdGdQ2t/YL4b8FQCqHdILhz3VdQiAbOuOfOmgMpnMoowN/DmYcGR177jdOPwBd3Qk4yeAbC3V9CRN9rv6+wG+mPFuIyq8ozx97WswXuLtWPV5sYh3dkY8Aa/fbbb4wfP57w8HA0Gg3ff/+92fmpU6ei0WjMHgMGDDArU1JSwvTp02nevDleXl5MmDCBc+fO1eN3Ia7VuvhUBi/YzN0f72TlLrWnUq/AHycyru3Gp7bBJ6PU4CSgHTy8SYKTRkACFCHKpecWs+mIOjnWoo0BL52Ec7tAo4XoO+q4dg1bQUEB3bt3Z/HixdWWGT16NKmpqabHzz//bHY+NjaW1atXs2rVKrZv305+fj7jxo1Dr9dXc0fhSKrbcye/uOza9tyJWwnLb1cnqkcMUIOTgLY2qLGwNxniEaLc13vPoTco9G7djI4hPrVfcKg8c2zbG6tcuigqjBkzhjFjak5g5+bmRmho1cNqOTk5fPLJJ3z++ecMHz4cgOXLlxMREcGmTZsYNWqUzessbMeSPXfmrk1gRFSo5RNjFQW2LYCt89XnXW+DWz8EF8n42lhID4oQqMsdjantJ1uytFhR4EB5cjYZ3rGJrVu3EhwcTMeOHfn73/9Oenq66dzevXspLS1l5MiRptfCw8OJjo5mx44d1d6zpKSE3Nxcs4eof5bsuZNaviGfRcp08MO0iuDkun/B7f+T4KSRkQBFCGDHyUuczSzEx82Zm7tZkHfh3G7ISgIXL+h8c91XsJEbM2YMX3zxBZs3b+att95i9+7d3HTTTZSUlACQlpaGq6srzZo1M7suJCSEtLS0au87f/58/Pz8TI+ICAuCT2Fzlu65Y1G54hz44g6I+0IdXr35bRjxsizxb4RkiEcIYOVudXLsrT1b4OlqwZ/FwS/Vr13Gg6tXHdasabjrrooNFqOjo+nTpw+tW7fmp59+YuLEidVepygKmhryW8yaNYunnnrK9Dw3N1eCFDuwdM+dWstlJ6srdS4eUT8c3LkUOo6s+RrRYEnIKZq8S/klbDisfgqf3M+C/7zKdOryYoDusnNxXQgLC6N169YcP34cgNDQUHQ6HVlZWWbl0tPTCQmpfv6Pm5sbvr6+Zg9R//pFBhDm515prxsji/bcOR8H/zdcDU68Q+GBnyU4aeQkQBGNlt6g8OfJS/wQl8KfJy+hN1Q1RQ++3XeOUr1Ct5Z+dA33q/3GJzZCUZbaSEYOsXGtBcClS5dITk4mLEwdbuvduzcuLi5s3LjRVCY1NZX4+HgGDRpkr2oKCxk35Ktut2CoZc+dYxvg07GQnwZBXdSVOuE96qi2wlFYFaC0adOmUq4CjUbDtGnTALW7dc6cOYSHh+Ph4cHQoUM5fPiw2T0kl4GoD+viU7nh9Y2898n/+PWrD3jvk/9xw+sbKy1lVBTFtDGgRUuLoWJ4J+aOGvf2EBXy8/OJi4sjLi4OgKSkJOLi4jh79iz5+fnMmDGDP//8k9OnT7N161bGjx9P8+bNue222wDw8/PjoYce4umnn+bXX39l//793HvvvcTExJhW9QjHNjo6jFt6hFd6vdYN+XZ/AivvgtIC9QPBQ+vBX4bpmgKr5qDs3r3bLOdAfHw8I0aM4M477wRg4cKFvP322yxdupSOHTvy6quvMmLECBITE/HxUZdtxsbGsnbtWlatWkVgYCBPP/0048aNY+/evTg5SWMvrt26+FS+X/EhX7t8RrhrxaqA8yUBvLziPpjyD1NjuCspk1MXC/B0dWJ898qNZyVF2ZC4Tj2W1TsW27NnDzfeeKPpuXFeyP3338+SJUs4dOgQn332GdnZ2YSFhXHjjTfy5ZdfmtoNgHfeeQdnZ2cmTZpEUVERw4YNY+nSpdJuNCD5xWUA/G1Aa/q0aWa+545BD2d2QP4F8A5Rc5pseUXdkRigxz0w7l1wdrXfNyDqlUZRlKr7vS0QGxvLjz/+aBonDg8PJzY2lmeeeQZQe0tCQkJYsGABjz76KDk5OQQFBfH555+bJsWdP3+eiIgIfv75Z4tzGeTm5uLn50dOTo6MKQszeoPC8/PmMa90IQCX9xgbR3iec5nJa889h5NWw5NfxrF6fwqT+0bw+u3dan+Dvctg7T8hOAoe22HRBmSNVUP8O2yIdW4sFEWh96ubyCzQ8d3jg+jV6rIVWQlrYN0zkHu+4jVndygrX9Uz9DkYMrNJ/701Ftb8DV71HBSdTsfy5ct58MEH0Wg0JCUlkZaWZpanwM3NjSFDhpjyFEguA1HXdp28yD9L/w8wD04uf/7P0k/YdfIi2YU6fjqkDvlMtnZ4p9td0lgKYYUzlwrJLNDh6qSla/hl/zElrIGv7jMPTqAiOOn3KAx9Rv7emqCrDlC+//57srOzmTp1KoApF8GVM+ovz1MguQxEXdOf/oNwTWal4MRIq4FwzSX0p/9g9f4UdGUGuoT50r2lBZNjs87AmT8ADcTcadN6C9HY7U9WV2BFt/DFzbl8WM6gV3tOqpw+W+7oj2o50eRcdYDyySefMGbMGMLDzcftr8xJUFueAkvKzJo1i5ycHNMjOTn5aqstGrlgTbaF5bJYtcs4OTai1t9RoCK1feT14NfiKmsoRNO070w2AD0vH9o5s6Nyz8mVclPUcqLJuaoA5cyZM2zatImHH37Y9JpxD40re0Iuz1MguQxEXWvXtp1F5fReoSReyMPdRcstPSwINhTlsuEdmRwrhLX2nVXbfbO5J/kXLLvY0nKiUbmqAOXTTz8lODiYm2+uSPEdGRlJaGioWZ4CnU7Htm3bTHkKJJeBqGtOba6jyCOUalKeYFCgyCOUT5PVgPrmmHD8PFxqv/H5/ZBxTJ2412W8DWssRONXqCvjaFoeAL1a+1ec8LZwk01Ly4lGxeoAxWAw8Omnn3L//ffj7FyxSlmj0RAbG8u8efNYvXo18fHxTJ06FU9PT6ZMmQJILgNRD7ROeIx/o8r5dAbU31Nl9OusPaRuRHe3JZljAQ5+pX7tfDO4Sw+eENY4eC4HvUEh1NedMD+PihOtB4FvONSUY9a3hVpONDlW78WzadMmzp49y4MPPljp3MyZMykqKuLxxx8nKyuL/v37s2HDBsllIOpVcYeb2W7ozXDtXrPXNb4t0Ix+nW9zu1NUGk/7YG96t25WzV0uoy+D+G/UYxneEcJqpuGdy3tPQE10OHqBuoqnkvKgZfTrkhCxibK6B2XkyJEoikLHjh0rndNoNMyZM4fU1FSKi4vZtm0b0dHRZmXc3d1ZtGgRly5dorCwkLVr18qqHGFTe05nEU6G6blOceLNsLfQxB6CqAms2qVuDDi5r4WTY09tgYKL4Nkc2t1Ye3khhJn9Z7MB6BlRxQeCqAnqbsRX8g2HSZ+p50WTJLsZi0Zn75FE/qU9Y3ruqtGzubAdM7ROHDqXw+Hzubg6abm9V0vLbnhglfo15g5wsmC+ihDCRFEU9lfXg2LkUR64hMTA4Fh1zknrQdJz0sRJgCIaneLELQDke7fBO/80ABezslAUhZW71d6T0dGhNPOyIGV2SR4c/Uk97japLqorRKN2LquIjHwdLk6a6jfjvBCvfo28Qf0gIASym7FoZDLyS2iTsxsAbecxKMZxbF0hyZlF/LA/BYDJlk6OPbIWyoogsAOE96qLKgvRqBnnn0SF++HuUk2PSNoh9WtodNXnRZMkAYpoVP44fpHBTmpj59l5OBpXL/VYU8LMbw5QoNPTOsCDgW0DLbuhcXinu6S2F+Jq7DtjzH/iX3UBRYG08h6U0Jj6qZRoECRAEY3KkcNxtNBcokzjAq0GUaJxB8CTEnYmqTsbZxaWsv5w9VsrmOSeh6Tf1OMYGd4R4mrsT84Grsgge7nss1CSA1oXaN6p/iomHJ4EKKLRUBQFbdJWAPKDe7PuWA5pReqvuAclpnJ5xWU8tnwf6+JTa77hoa8BBVoNgmat66jWQjRexaV6Es6rm7tW24NinH8S1BmcLZgXJpoMCVBEo3EiPZ9uujgAPDsPY+7aBApxU59rSiqVn7s2AX11KWcBDpSntu9+l62rKkSTcCglhzKDQrCPGy38PaouJPNPRDUkQBGNxu+JaQzSHgYg0bMPqTnFFBkDFIrNyipAak4xu8qHfSpJi4f0w+DkClG31GW1hWi0jPNPerbyrz7nkClAkfknwpwEKKLRSEnYga+mkBJnH065tgegUFEDlMuHeC6Xnldc5escLJ8c23F0RY4GIYRVqtwg8ErGACVEelCEOQlQRKNQUqbH5/wf6nHLwQT7qqt3iiifJFvFEA9AsI975RcNejhkTG0vwztCXA1FUdhnzCBbXYBSnAvZ5UkVpQdFXEECFNEo7DuTzQAOAuAdNZx+kQGE+blXzEG5ogdFA4T5udMvMqDyzZJ+g7xUteekw8i6rroQjVJKdhEX80pw1mro1rK6BG3qkCy+LcGzir9F0aRJgCIahb8Sz9JLcwwAbbsbcdJqmD0+iqIqhniMI+Gzx0fhpK1iXPxg+eTYrhNlVYEQV8nYexIV7isJ2sRVkQBFNArZR7fhqtFT4BEOAW0BGB0dxoDOasbYy4d4Qv3cWXJvL0ZHh1W+ka5AzR4LMrwjxDUw7r/TM8K/+kIXZIKsqJ7sxSMavKwCHS0z/wJn0LYbapbxtU1YEJyA27o2o0WXHgT7qMM6VfacABz9GXT50KwNRPSrl/oLUScMejizA/Iv2GXzPWMPSq/WMkFWXB0JUESD98fJDK7TqsmePDoPNz/p4glAmKeeW3q0qP1mxtU73SS1vXAseoPCrqRM0vOKaw+0E9bAumfUbMhGvuEwegFETajzuqoJ2nKAGlbw6Msg/Yh6LD0oogoSoIgGLy7hGOO06i7FRA4xP1m+Fw+6wtpvlJ8OJzerxzK8IxzIuvhU5q5NIDWnYll8mJ87s8dHVR6qTFgDX92Hmu3nMrmp6uuTPqvzIOXw+RxK9QrNvV1p2ayaBG2XTkBZMbh6Q7PIOq2PaJhkDopo0BRFoezkVgDy/LuAV3PzAuU9KJRaEKAc+gYUA7TsC4HtbFtRIa7SuvhUHlu+zyw4AUjLKa68ZYNBr/acXBmcQMVr655Vy9WhfWeyAXV5cbUJ2owp7kO6glb+KxKVyW+FaNCSMgqIKtoHgPuVwztwWQ9KQe03u3x4RwgHoDcozF2bUFO4Yb5lw5kd5sM6VV2Vm6KWq0P7kysyyFYrTU0LIPNPRHUkQBEN2vbjF7nOSf0k5tL+xsoFLO1BST8KqQdA66wuLxbCAexKyqzUc3K5Sls25F+w7MY/PQ1bF8DpP6Cs6iSG18LYg1JzBtnyHhSZfyKqIXNQRIOWeDiO+zSX0GtccGo1sHIB1/IApbY5KMbcJx1GglegbSspxFWqdiuG6sp5h1h244xE2DpPPXZ2V4c121wPbQZDyz7g7HYVtVWl5hSRlluMU00J2kD24BG1kgBFNFilegMe534DDRSF9cXbGIxczqV8iKe0hiEegwEOfa0ed5tk+4oKcZWq3IqhpnIFl2opqQHvYLjh3+owz+ntUJAOp39XH3DNAYux96RzqA+ertX8F5N3QX1fjRaCoyy+t2haJEARDVZccjb9DAfACTyrmn8ClvWgnN0BOcng5gsdx9i+okJcpX6RAQR5u3IxX1fleQ1q4sF+kQFw8GtY/egVZ5UrngNj31RX8fT7OygKZBwvD1C2WxawtOgNLtUHThZtEGhM0BbQruJvVIgrSIAiGqztx9J4SJsAlCdoq4olc1AOlE+OjbqlxoZXiPqmAXw9XKoMUMy2bIhbDmumAwp0nwIdR8H6WVXkQXndfImxRgNBHdVH34csC1ic3NQkhm0Glwcsfcz+bkwZZKubIGvQQ0J5tmafUPV5PSaQEw2HBCiiwUo78ie+miJKXHxxC+tRdSHjKp7SQnUo58rljKXFkPCDetx9cp3VVYirsfyvM5y8WICrsxY/Dxcu5plv2TB7fBSjC9bCL/9WX+zzIIx9S/097zLe+kyyVQUsl06YByz5F6oNWHQRgziWkgU4V92DcmUCudO/w7vR9ZZATjQsEqCIBimnqJSQizvAGQytr6++4XW5rPu4tBDcvM3PH/sFSnLBLwJaDaq7CgthpXNZhSz45SgAz4/twr39WvLmx5+Sknyazh3a8+jf/obTX+/DxpfUCwZMg1GvVWRA1jpB5PXXVgmNBpp3UB99Hqw1YHEF9jq7cNClI60PHVTf39jD4gAJ5ETDIgGKaJD+rCm9/eVqC1AOlK/eiblTkkUJh6EoCs+tjqdAp6dP62b8ze8A2v+M4Znc8+AKnAHeeBFK8tQLrp8BN71Q99sz1BKwFB7bhqcug74chm2HYdvrag9Ly76QdoDqE8hp1ARynW+W4R5hIi2yaJD+OnqWnprj6pO2Q6svqNVWBClXJmsruAQnNqrHMrwjHMh3+1L47dhFXJ21LO55Du3X91dOwGYMTqLvgGEv2mfvKGPA0udBuON//Lv1V9xU8iZbOzwH0berQ0v6EjizvaK+VaqfBHKiYZEeFHFNrNrAzIYKjv+Gq0ZPkVdLPGrbx8PFU+09uXKi7OHvwFAGYT0gqFOd1VUIa6TnFfPyj+rk7yeHtSV0x61U3fNQ7uyfDjPRNC45hxQlHNf+t0H75hU9LH+8B/s/r/0GliaaE02CBCjiqlm1gZkNnb1USMeCveAMzh1uqv2To6snFFJ5qbExOZukthcOZM6aw+QUldI13Je/t7oA22pKXU9Fz8O1zje5Rhdyi0nJLkKrge4R/uqLxh6WbndZFqBYmmhONAkyxCOuilUbmNnY7ycumuafVJne/kpVJWu7dBLO7QaNE8TcUQe1FMJ66+JT+flQGk5aDQvv6IZzYbplFzpAz8O+M+ry4k6hvni5XfHZt/UgdZkz1X2Y0IBvC7WcEOUkQBFWs3oDMxs7kHCMLtpkFDQQOaT2C6pK1mbsPWl3o5pZUwg7yyks5YXvDwPwjyFt6RruZ3mPggP0POxPzgaqyX+idVKXEgOVg5Ty56Nfd4hhKuE4JEARVrN6AzMbKtMb0J7ZBkBRYFfL9s25Mlmbolw2vCOTY4VjeOWnBDLyS2gX5MX0mzqoL7YeBD41DZc6Ts+DsQel2gyyURPUpcS+V3w/vuGyxFhUSeagCKtZvYGZDR1MyaF32QFwBvdOwyy7yJiszbiKJ3kXZJ0GV291WaMQdvbbsYt8s/ccGg0svKMb7i7lPQkarfofeF7lIVMFjdr34AA9D7oyA4dScgDoVV0GWVCDkM43W59ATjRJEqAIq1m9gZkNbT92kTud1Pkn1aa3v9KVPSjG3pMu42UfEGF3BSVlzPpO3Zvm/oFt6N06oOLkX/+FlL3qXCnPACi4aDpV4hmK+7iFDtHzcCQ1l5IyA/6eLkQ296q5sC0SyIkmQQIUYbV+kQEE+7iRflna7SsF+7ipG5jZ2Mmj+wnTZKLXuuLUaqBlF7lelgelTKcuLwZZvSMcwhvrE0nJLqJlMw/+Peqy5e7n9sKGF9Tj0fOh78NwZgfvr/2D39OcuGPcJO6Iam2fSl/BuEFgzwh/NPbIxyIaJZmDIqymKAp+Hi41lnHSaMgrLrXp++YVlxKQpiZyKm3RH1w8LLvQ5bL9eI5vgKIsdVw/8gab1k8Ia+05ncmyP08DMH9iTMXql6Is+GYqGEqhywTo94ip5+FEyGh2GqK4VFBmt3pfaf/ZbAB61rSDsRBWkgBFWO3tjcc4np6Pm7OWIG9Xs3PBPm74e7iQmlvMQ8v2UKTT2+x9d57KZJBG7Qp373iT5RdevorHOLwTc4eMewu7Ki7VM/PbgygKTOrTkus7BKknFAV+eAKyz0KzNnDLYrNcP83L/+YuFVTe4dhejD0o1U6QFeIqyBCPsMqWo+l8sPUkAG/e2Z2xMWGVMsmeSM/nzg93sPdMFtNX7uPDe3vj7HTtsfCOY6k8pVUzbNLOgvwnRsYelLzzcGydeiyrd4Sd/efX45y6WECQjxvPj42qOLFzCRz9EZxc4c6l4O5ndl2gtxsAGTUMsdan9LxizmUVodFA9wi/2i8QwkLSgyIslpJdxJNfxQHwtwGtGd89HCethoHtArmlRwsGtgvESauhU6gPn0zti5uzlk1H0nlu9SEU5dpzolw8thMfTRE6V38I7Wb5hcYelMR1oNdBcFcIjb7m+gjL/fbbb4wfP57w8HA0Gg3ff/+92XlFUZgzZw7h4eF4eHgwdOhQDh8+bFampKSE6dOn07x5c7y8vJgwYQLnzp2rx+/CduJTcvjvb6cAePXWaPw8y4dMz+2t2J141DwI71np2kAvtQclw0F6UIzDOx2DffBxr3noVwhrSIAiLKIrMzDti31kF5YS08KPF8Z1qbF83zYBLLq7J1oNfLXnHG9tOHZN75+SXUTbnN0AaCJvsG54xrl8NZG+/BNntzuvqS7CegUFBXTv3p3FixdXeX7hwoW8/fbbLF68mN27dxMaGsqIESPIy6vYYC42NpbVq1ezatUqtm/fTn5+PuPGjUOvt90wYn0o1RuY+c1B9AaFm2PCGNU1VD1RlAVfT1XnnUTdqk6KrUJzH8fqQTEN77T2t29FRKMjAYqwyPxfjhCXnI2vuzMf3NMLN+faA4SRXUOZd1sMAIu3nGDpH0lX/f7bj1/kuvLlxS4drJh/krAGNr9i/trOD9XXRb0ZM2YMr776KhMnTqx0TlEU3n33XZ5//nkmTpxIdHQ0y5Yto7CwkBUrVgCQk5PDJ598wltvvcXw4cPp2bMny5cv59ChQ2zatKm+v51r8tFvp0hIzcXf04U5E7qqLyoKfD8Ncs5Cs0iY8J9q95hq7qUGKJcKHCNAMU2QjZD5J8K2JEARtfrlUCqf/nEagLcm9SAiwPLcIZP7teLpER0BmPtjAj8erGXjs2r8lXiWXprj6pO2Qy27KGENfHWf+sn0cvkX1NclSHEISUlJpKWlMXLkSNNrbm5uDBkyhB071FVbe/fupbS01KxMeHg40dHRpjJVKSkpITc31+xhTyfS83nvV/X3+KVxUQSV94aw8wNI/KnaeSeXCzROks3X2WTo9FqU6g0cPJcNSA+KsD0JUESNTmcUMPObgwA8ckNbRkRZv+fHEze1576BrVEUePLLOP44kWHV9XqDQunJ33HR6CnxjoCAyNovMuhh3TNUvU19+WvrnlXLCbtKS0sDICTE/HcrJCTEdC4tLQ1XV1eaNWtWbZmqzJ8/Hz8/P9MjIiLCxrW3nMGg8My3B9GVGRjaKYjberZQT5zbc8W8kx413scYoJQZFHKKbLuU31pHU/MoLjXg6+5M2+bedq2LaHwkQBHVKi7V8/gX+8grKaNP62bmSaSsoNFomD2+K2NjQinVKzz6+V7iy9NiW+Lw+Rx6lB4AwNnS5cVndkBuTb01SsU29cIhXJngS1GUWpN+1VZm1qxZ5OTkmB7Jyck2qevV+OzP0+w9k4WXqxOv3Raj1rsws3zeSRl0va3aeSeXc3N2wsddXYCZkW/fibL7k9XeyR6tmqHVSoI2YVsSoIhqzV17mITUXAK8XFk0pScu17BU2Emr4e1JPRjQNoD8kjKmfrqbM5cKLLr29+MZDNaq+U+cLF1ebOn28w6wTX1TFxqqThK9sickPT3d1KsSGhqKTqcjKyur2jJVcXNzw9fX1+xhD8mZhSxcnwjAs2O70MLfo3zeyeOQk6zOOxlf/byTKwWVLzW+lG/feSgVGwT627UeonGSAEVU6bt951i5KxmNBt69qwdhfhZmba2Bu4sTH93Xhy5hvmTkl3Df/3Zx0YKVCIeOHqWT9hwKGogcYtmbNaBt6pu6yMhIQkND2bhxo+k1nU7Htm3bGDRI3aW3d+/euLi4mJVJTU0lPj7eVMZRKYrCc6sPUajT0y8ygHv6tVJP/Pk+HPsFnNxg0jJwtzx4Mg7z2L8HJRuQDLKibkiAIio5fiGP51erK2am39SBGzoG2ezevu4uLHugLxEBHpy5VMgDS3eRX1J9yu5CXRleKX8AoAuKUTdMs0TrQeousFT3idRxtqlvCvLz84mLiyMuLg5QJ8bGxcVx9uxZNBoNsbGxzJs3j9WrVxMfH8/UqVPx9PRkypQpAPj5+fHQQw/x9NNP8+uvv7J//37uvfdeYmJiGD58uB2/s9p9s/ccvx/PwM1Zy+sTY9ShkOTdsGm2WmD0fAjrbtU9Ax1gJU9GfglnLqkbcPaI8LdbPUTjJQGKMFNQUsZjX+yjqFTPde0D+dewDjZ/j2Bfdz57sD+BXq7Ep+Tyj8/3oiszVFn2r8vS27tak95e6wSjF5Q/uTJIKX/uANvUNxV79uyhZ8+e9OypJh576qmn6NmzJy+9pE4OnTlzJrGxsTz++OP06dOHlJQUNmzYgI+Pj+ke77zzDrfeeiuTJk3iuuuuw9PTk7Vr1+Lk5Lj/hum5xbzyo5r9+MkRHWkb5H3FvJOJ0OdBq+/b3Mf+PSjG5cUdgr1r3ZtLiKshAYowURSF51cf4kR6PsE+brx7V0+c6mjiW2RzLz59oC+erk5sP5HB018fwGCovOLm92MXuU6r9uZoLF1ebBQ1ASZ9Br5h5q/7hquvO8A29U3F0KFDURSl0mPp0qWAOkF2zpw5pKamUlxczLZt24iONs/26+7uzqJFi7h06RKFhYWsXbvWrqtyLPHSD4fJLS4jpoUfDw+OBIMBvn8Mcs9BQDsY/57F804uZ+xBybDjHJT9xh2MZf6JqCOyF48wWbkrme/jzuOk1bDo7p4VORrqSLeW/nx4b28eXLqbtQfO09zblZfGRZmtyjhzbD+hmiz0WjecWg20/k2iJkDnm9XVOvkX1DknrQdJz4mocz8fSmXd4TSctRoW3N5N3Y/qj/+o+0E5uZXnO7m6SbumDQPtGKDIBoGirkkPigDUvUHmrFX3PpkxshP92wbWy/ve0DGItyap4++f/nGaD7edMp1LyykmIusvAAwRA8DF/erepHybemLuUL9KcCLqWFaBjpd+UHv+Hh/ajqhwXzj7F2yaoxYY8zqEWbGf1BWam1bx2GeIp0xv4OA5NVVAr9YSoIi6IQGKILe4lGkr9qErMzCsczCP3tC2Xt//lh4teOFmdW+fBeuO8vWeZPQGhaU7TpuGd5zaWzH/RAg7e+WnBDLydXQI9mbaTe3VeSffPAiKHqJvh94PXNP9TTsa26kHJfFCHoU6PT5uzrQPkgRtom5IgNLEKYrCzK8PcuZSIS38PXhrUne7JFx6+Pq2PDpEDYye+fYgfV7dyP9tS2SA9ggAD/zmybr41HqvlxDW2pKYznf7UtBoYMEd3XDTamD1P6553snlLk93bw/7yifI9mjlLwnaRJ2RAKWJ+98fp1l3OA0XJw3v39MLf09Xu9Xl2dGd6R8ZgEGBnMISpmh/xUdTRK7izh95ITy2fJ8EKcKh5ZeU8fx36qqzBwZFqvMz/lwEx9eru2pPWgZuPrXcpXbGIZ68kjKKS+t/uwbTBFlZXizqkAQoTdi+s1nM/1ntoXh+bBe75zIwKHDmUiGjtLvY7vZPXnZdBoCvppjf3GIZpd3F3LUJ6KtY7SOEI1jwy1HO5xQTEeDBjFEd4exO2DRXPTlmAYTG2OR9fN2dcXFSey4uFdR/L4ppB2OZfyLqkAQoTVRWgY4nvthHmUHh5pgw7h/Uxt5VYldSJt3zf2OJy7uEkml2LpRMPnB5l255v7ErKbOaOwhhP7uSMvl85xkAXp/YDc/SnIp5JzF3Qq/7bfZeGo2mIllbPc9DySrQkZShblMhPSiiLkmA0gQZDApPfhXH+ZxiIpt78frtMbVuylYf0nMLmO3yGQBXDmsbn892+Zz0XMv28BGivhSX6nnmW3XX78l9I7iubQB8/w91Q8rA9jDunWued3IlY7K2+p6HYtwgsG2Ql12HhEXjJwFKE7Rk20m2Jl7EzVnL+1N64ePuGFkg2xceIlyTWSk4MdJqIFxzifaFh+q3YkLU4t1Nx0nKKCDE141ZY7vAjvfg+AZ13smdtpl3ciVjD8rFeu5B2XcmG5D8J6LuSYDSxPx58hJvbVB3VX35lq5qfgYH0cWn0KblhKgPh87l8PHvav6eV2+NwS99D/z6inpyzEIIja7h6qtnr5U8xh4UySAr6poEKE1Iel4x01fux6DA7b1aMqmPY6UJ1/qE2rScEHWtVG/g398cQG9QGNctjBGtnS+bdzIJet1XZ+8dZIdcKHqDQlz5BFnpQRF1TQKUJkJvUPjnyv1k5JfQMcSbV27t6hDzTsyU70Bc3RodRXYgFg7mw60nOZqWRzNPF+aM7wKrH4G88xDYoU7mnVwu0A7p7o9dyKNAp8fL1YmOIbYfthLichKgNBHvbDzGzlOZeLo68cE9vfF0dcBtmMp3IK6qSVfQqK/LDsTCQRy/kMeizScAmD2+K83jlsCJTZflO6nbDKumdPf1uMzYuLy4e4R/nW0kKoSRBChNwJbEdBZvURvS+RNjaB/swKmpoyZAUOdKL2tkB2LhQPQGhZnfHkSnN3BT52BuaXYaNr+qnhz7BoR0rfM6GNPdX8yrvx4U2SBQ1CcH/BgtbOl8dhFPfRkHwL0DWnFLjxb2rVBtirIh47h6PPFj0GhlB2LhcJbtOM3+s9l4uzkzb2QompUj1Hkn3SZDz7/VSx0CvcqHeOq1B0UmyIr6IwFKI6YrMzBtxT6yCkuJbuHLCzdH2btKtTu5WW3om3eEbpPsXRshKjl7qZA31qsr4WaN6Ujor/+CvFT1d/bmt+p03snlgnzUHpTMAh0Gg1Lne+JkF+o4ebE8QZv0oIh6IEM8jdiCdUfZfzYbH3dnPpjSG3eXBtADcXyD+rXDSPvWQ4gqKIrCrNUHKSrV0z8ygLt138HJX8HZozzfSf0NnzYrT5KmNyhkF5XW+fvtT84GILK5FwFekqBN1D0JUBqpdfFpfLI9CYA37+xOq0BPO9fIAgYDHN+oHnccZd+6CFGFr/Yk88eJS7g5a3l3QCHaLeXzTm5+E0Lqt4fS1VmLn4eaZLE+VvKY9t+R9PainlgdoKSkpHDvvfcSGBiIp6cnPXr0YO/evabziqIwZ84cwsPD8fDwYOjQoRw+fNjsHiUlJUyfPp3mzZvj5eXFhAkTOHfu3LV/NwKAM5cK+PfXBwD4+/WRjOraQPKGnN8HhRng5gutBtq7NkKYuZBbzKs/lW+uObQ5YZumgWKA7ndDj3vsUqfm5UuNM+ohWZtp/olsECjqiVUBSlZWFtdddx0uLi788ssvJCQk8NZbb+Hv728qs3DhQt5++20WL17M7t27CQ0NZcSIEeTl5ZnKxMbGsnr1alatWsX27dvJz89n3Lhx6PX1v214Y1NcqufxL/aRV1JG79bNmDm68ooYh3Vsvfq13Y3g5Bjp94UA9YPXC9/Hk1dcRo8WPtx7fl75vJNO9Trv5EqB9ZSszWCWoM2/Tt9LCCOrJskuWLCAiIgIPv30U9Nrbdq0MR0risK7777L888/z8SJEwFYtmwZISEhrFixgkcffZScnBw++eQTPv/8c4YPHw7A8uXLiYiIYNOmTYwaJV371+LlHxM4fD6XZp4uLJ7SExenBjSKZ5p/Ir8DwrH8dCiVjQkXcHHS8HHb39Du3qzOO5m0DFy97Fav5vWUrO3ExXzySsrwdHWikyRoE/XEqv+91qxZQ58+fbjzzjsJDg6mZ8+efPzxx6bzSUlJpKWlMXJkxQRHNzc3hgwZwo4dOwDYu3cvpaWlZmXCw8OJjo42lblSSUkJubm5Zg9R2ff7U1jx11k0Gnh3ck/C/DzsXSXL5aVBapx63GGEXasixOUyC3TM/kEdpn6tZw5Be95ST9z8FgR3sWPN6i9Z274z6vBOt5Z+ODekDz2iQbPqN+3UqVMsWbKEDh06sH79ev7xj3/wz3/+k88++wyAtLQ0AEJCQsyuCwkJMZ1LS0vD1dWVZs2aVVvmSvPnz8fPz8/0iIhwrD1kHMGJ9DyeW63u8jv9xvYM6Rhk5xpZyTg5NrwneAfbty5CXOaVHxO4VKCjX1AZd56eo8476XEP9LTPvJPLGXc0rushHtMEWVleLOqRVUM8BoOBPn36MG/ePAB69uzJ4cOHWbJkCffdV7Ep1pV7vCiKUuu+LzWVmTVrFk899ZTpeW5urgQplynUlfHY8n0U6vQMahfIv4Z3tHeVrHe8fP6JDO8IO9MbFHYlZZKeV8z5rCJW70/BWWPg/3w+RnM+Tc10PPYNe1cTqNiPp64nyUoGWWEPVgUoYWFhREWZL6Xr0qUL3377LQChoepqkbS0NMLCwkxl0tPTTb0qoaGh6HQ6srKyzHpR0tPTGTSo6k3g3NzccHNzs6aqTYaiKLywOp7j6fkE+bjx3uSeDW+PjDIdnNyqHneU/CfCftbFpzJ3bQKpOcVmr78Rsgnf87+Di6ea78SO804uZxriqcMelJyiUo6n5wOSQVbUL6uGeK677joSExPNXjt27BitW7cGIDIyktDQUDZu3Gg6r9Pp2LZtmyn46N27Ny4uLmZlUlNTiY+PrzZAEdX7cncy3+1PQauBRXf3NGWXbFDO7gBdHngFQ1hPe9dGNFHr4lN5bPm+SsHJQO1hJmQtU5/c/DYEO87KuPpYZnygPEFbqwBPU0AkRH2wqgflySefZNCgQcybN49Jkyaxa9cuPvroIz766CNAHdqJjY1l3rx5dOjQgQ4dOjBv3jw8PT2ZMmUKAH5+fjz00EM8/fTTBAYGEhAQwIwZM4iJiTGt6hGWOXw+h5fWqJP3ZozqxIC2gXau0VU6Zly9MwK0MgFP1D+9QWHu2gQUQIuBftqjBJNNCS684vI/nDQKP2pvYky3yThSPubAeuhBqRje8a+z9xCiKlYFKH379mX16tXMmjWLl19+mcjISN59913uuadistjMmTMpKiri8ccfJysri/79+7NhwwZ8fCqWpr3zzjs4OzszadIkioqKGDZsGEuXLsXJyZH+9B1bbnEp077Yh67MwI2dgvjHDe3sXaWrJ+nthZ3tSsokNaeYUdpdzHb5jHBNptn5FEMgM4r/RmBSJgPbOc4HAWMPSoFOT5FOj4er7dtQmSAr7MXqzQLHjRvHuHHjqj2v0WiYM2cOc+bMqbaMu7s7ixYtYtGiRda+vUCdd/Lstwc5famQFv4evD2pR51vFFZnMk/BpeOgdVYTtAlhB+l5anCyxOXdSucUBcI1lxiiPUB6Xv/6r1wNvN2ccXXWoiszkJFfQkSAbbe0MBgUUwZZmSAr6pv0pzdAS3ec5udDabg4aVg8pSfNGvLGXcbhnVYDwd3PvnURTVawlwuzXdR0CVfG+hoNKMBsl88J9nKsDMcajYagOsyFciojn9ziMtxdtHQOkwRton5JgNLA7D+bxbyf1f1AnhvbpeF3u5qWF8vwjrCffk5HCddkVgpOjLQatReln9PR+q2YBUxLjfNsPw9lX/nwTrcW/g0rK7VoFOQ3rgHJKtDxxIr9lOoVxkSHMnVQG3tX6dqU5MPp7eqx7F4s7MipIN2m5epTYHkP6qUC2wcoFRsE+tv83kLURgKUBsJgUHjqqzhSsotoE+jJgju61Zr8zuElbQO9DvxbQ/MGmFxONB7eIbWXsaZcPWpu2jDQ9kM8pgmyEQ28p1Y0SBKgNBAf/naSLYkXcXXW8v49vfB1d6yx8Kti3L244yi77QYrBACtB4FvOFDd76EGfFuo5RxMXe1onFdcSuIFdRf6XtKDIuxAApQGYOepS7y5Xk2Q9/KErnQNbwSTSRWlYv8dSW8v7E3rBKMXlD+5Mkgpfz76dbWcg6nY0di2PSgHknNQFGjZzINgH3eb3lsIS0iA4uAu5pXwz5X7MSgwsWcL7urbSPYguhAPeefV1OFtBtu7NkJA1ASY9Bn4hpm/7huuvh41wT71qkXFjsa27UExzT9p6BPxRYNldR4UUX/0BoV/rdpPel4JHYK9efW26IY/78TIOLwTOQRc5NOZcBBRE6DzzXBmB+RfUOectB7kkD0nRhWreGzbgyIZZIW9SYDiwN7bdIwdJy/h6erEknt74enaiP65jl+W3l4IR6J1gsjr7V0LiwV62b4HRVEU9pfvwSMJ2oS9yBCPg9p27CKLtpwAYP7EGNoHN6IkSYWZcG63eiz5T4S4Js191B6UzAIdeoNik3smZRSQXViKm7OWLmG+NrmnENaSAMUBpeYU8eSXcSgKTOnfilt6tLB3lWzrxCZQDBDcFfwbyZwaIewkwFMNUAwKZBXaZpjHmKAtpoUfrs7y34SwD/nNczClegNPrNhPZoGOruG+vDQuyt5Vsj3T8mLpPRHiWjk7aWnmqaYdsNVKnooJsv42uZ8QV0MCFAezcN1R9p7JwsfdmQ/u6YW7i+NOzrsq+jK1BwVkebEQNmJayWOjXCjGHhSZfyLsSQIUB7LhcBof/54EwBt3dKd1oJeda1QHzu2G4mxw94eWfe1dGyEaBeNKnos2CFDyS8pITMsFoFdrCVCE/UiA4iDOXirk6a8PAPDQ4EhGR4fauUZ1xLh6p/1wcGpEq5KEsKOKHpRrH+I5eC4bgwLhfu6E+EoKAGE/EqA4gOJSPY+v2EtecRm9Wvnz7JjO9q5S3TEtL5b5J0LYii2TtZn235HeE2FnEqA4gFd/SiA+JZdmni4sntKr8W5rnnNOzSCLRu1BEULYhHFHY1skazNNkI3wv+Z7CXEtGun/hA3HD3EpLN95FoB37upBuL+HnWtUh4y9Jy37glegfesiHMqcOXPQaDRmj9DQimFORVGYM2cO4eHheHh4MHToUA4fPmzHGjuW5j626UFRFKVigqz0oAg7kwDFjk6k5zPru0MAPHFje4Z2CrZzjerYsfIARZYXiyp07dqV1NRU0+PQoUOmcwsXLuTtt99m8eLF7N69m9DQUEaMGEFeXp4da+w4jD0oF69xDsqZS4VkFuhwddLSNVwStAn7klmKdlKk0/P4F3sp1OkZ2DaQJ0d0tHeV6lZpMSRtU49lebGogrOzs1mviZGiKLz77rs8//zzTJw4EYBly5YREhLCihUrePTRR6u9Z0lJCSUlFb0Kubm5tq+4Awi00TLj/cnq8E7XFr64OTeyFAeiwZEeFDtQFIUXvo/n2IV8mnu78d7dPXDSNpJNAKtzejuUFoJPOITG2Ls2wgEdP36c8PBwIiMjmTx5MqdOnQIgKSmJtLQ0Ro6s6Hlzc3NjyJAh7Nixo8Z7zp8/Hz8/P9MjIqJxZi4OstEqnn1nsgHJfyIcgwQodvD1nnN8u+8cWg0sursnwT5NYCnf5ZsDNpYdmYXN9O/fn88++4z169fz8ccfk5aWxqBBg7h06RJpaWkAhISEmF0TEhJiOledWbNmkZOTY3okJyfX2fdgT8Y8KEWlegpKyq76PsYeFMkgKxyBDPHUsyOpubz4QzwAT4/sxMB2TWCyqKLAcWN6exneEZWNGTPGdBwTE8PAgQNp164dy5YtY8CAAQBorghsFUWp9NqV3NzccHNzs32FHYynqxPuLlqKSw1cytfh5WZ9016oK+NIqjqnR3pQhCOQHpR6lFdcyuNf7KOkzMDQTkE8NqSdvatUPzKOQ9ZpcHKFyCH2ro1oALy8vIiJieH48eOmeSlX9pakp6dX6lVpqjQajSkXSsZVruQ5eC4HvUEh1Ne9ca8mFA2GBCj1RFEUnv32EEkZBYT7ufPOpB5oG/u8EyNj70nr68DN2751EQ1CSUkJR44cISwsjMjISEJDQ9m4caPpvE6nY9u2bQwaNMiOtXQsxomyGXlXF6CYErTJ8I5wEDLEU08++/MMPx1KxVmrYdGUXjQrXxbYJByT4R1RsxkzZjB+/HhatWpFeno6r776Krm5udx///1oNBpiY2OZN28eHTp0oEOHDsybNw9PT0+mTJli76o7jOblbcqlgqubKLuvPEGbDO8IRyEBSj04kJzNqz8lADBrbBd6N6UESMU5cPZP9VjS24tqnDt3jrvvvpuMjAyCgoIYMGAAO3fupHXr1gDMnDmToqIiHn/8cbKysujfvz8bNmzAx8fHzjV3HNeyo7GiKKYMsr1a+9uyWkJcNQlQ6lh2oY7Hv9hHqV5hdNdQHryujb2rVL9ObgFDGQS2h8AmMudGWG3VqlU1ntdoNMyZM4c5c+bUT4UaIONKnoyrWGp8LquIjHwdLk4auob72bpqQlwVmYNShwwGhae/OkBKdhGtAjxZeGe3WlcdNDqm5cUyvCNEXTLNQbmKHhTj8E5UuB/uLpKgTTgGCVDq0Ee/n+LXo+m4Omv54J5e+Lq72LtK9ctggOPlExslvb0Qdap5eQ/K1SRrM02QlQ0ChQORAKWO7ErK5I31iQDMGd+V6BZNsNs0NQ4K0sHVG1rJagsh6lJzG/SgyAaBwpFIgFIHMvJLmL5yH3qDwq09wrm7X+NMr10r4/BO26Hg3IRWLQlhB6ZJslau4iku1ZNwXt2jqJcsMRYORAIUG9MbFGJXxXEht4T2wd68dltM05t3YiTLi4WoN8ZJslmFOsr0BouvO5SSQ5lBIcjHjRaSoE04EAlQbOw/vx5n+4kMPFycWHJPr6tKOd0o5KfD+X3qsSwvFqLONfN0RatRd5bILLS8F2XfGWP+E/+m+2FKOCQJUGzo9+MX+c/m4wDMmxhNh5AmnKPBODk2rDv4hNq3LkI0AU5aDQFe1k+UrcggK/NPhGORAMVG0nKKiV0Vh6LA3f0iuK1nS3tXyb6M6e1lebEQ9SbQy7qJsoqiSAZZ4bAkQLGBUr2B6Sv3calAR1SYL7PHd7V3lexLX6omaAOZfyJEPQq0cqlxSnYR6XklOGs1xDTFlYbCoUmAYgNvrk9k9+ksfNyc+eCeXpLo6OxOKMkFz0AI72nv2gjRZFi71Ng4vNMlzBcP1ybebgmHIwHKNdqYcIH//nYKgIV3dKNNcy8718gBGId32o8ArTR6QtQXa9PdVwzv+NdVlYS4ahKgXIPkzEKe/ioOgAeua8OYmDD7VshRHCvPfyLZY4WoV9ZuGLhPJsgKByYBylUqKdMzbcU+covL6BHhz6wxXexdJceQdRoyEkHjBO2G2bs2QjQppnT3FiRrUxO05QAyQVY4JglQrtJrPx3h4Lkc/D1deP+eXrg6y48SqOg9aTUAPPztWhUhmhprVvEcPp9DqV6hubcrEQGSoE04Hvlf9SqsPXCez/48A8A7k3pI9sXLmZYXy/COEPXNmlU8xgmyPSKaSYI24ZAkQLHSyYv5PPvtQQAeH9qOGzsH27lGDkRXAEm/q8eyvFiIenf5Kh5FUWosW7FBoH9dV0uIqyIBihWKdHqmfbGPAp2e/pEBPDWio72r5FiSfgd9Cfi1gqDO9q6NEE2OsQelpMxAfklZjWX3nckGZP6JcFwSoFjhpR/iOZqWR3NvNxbd3RNnJ/nxmTEN74wA6TIWot55ujrjWZ7PpKZhntScItJyi3HSaujWUhK0Ccck/8Na6Ks9yXy99xxaDfzn7h4E+7rbu0qORVEuW14swztC2ItpqXFB9RNljb0nnUN98HRtohuaCocnAYoFjqbl8tIP8QA8Obwjg9o1t3ONHFB6AuSeA2d3aHO9vWsjRJNlHOa5mFd9D8r+8vknPSVBm3BgEjrXIr+kjMeX76O41MANHYOYdmN7e1fJsRj0cGYH7Pmf+rzN9eDqad86CdGEWdSDIhsEigZAApQaKIrCs98e5FRGAWF+7rx7Vw+0WplbYZKwBtY9A7nnK147t0t9PWqC/eolRBPWvJalxiVleuJTcgEJUIRjkyGeGizfeYYfD6birNWweEpPArxc7V0lx5GwBr66zzw4ASjOVV9PWGOfegnRxNWWrC3hfC46vYEAL1daB0pvp3BcEqBU4+C5bF758QgAz47pTO/WAXaukQMx6NWeE6rKs1D+2rpn1XJCiHpVWw+Kaf+dCH9J0CYcmgQoVcgpLOXxL/ah0xsYGRXCQ4Mj7V0lx3JmR+WeEzMK5Kao5YQQ9SrQu+YeFJkgKxoKmYNyBUVRePrrA5zLKqJVgCdv3NldPmUY5ZyDk1tg3zLLyudfqNv6CCEqMa7iqT5AyQZk/olwfBKgXOHj30+x6cgFXJ20fHBPL/w8XOxdJfspyYPTf8DJzXBqC2Qcs+5675C6qZcQolpBplU8lYd4LuQWk5JdhFYD3SL867lmQlhHApTL7DmdyYJ1iQC8ND6K6BZNLMOiQQ/n4yoCkuS/wHBZumyNFlr0hsghsHcpFF6i6nkoGvANh9aD6qfeQggT4xBPdmEppXoDLpdlvDYO73QM8cHbTZp/4djkN7TcpfwSnlixH71B4ZYe4dzTv5W9q1Q/ss5UBCSntkFxtvl5/9bQ7ib1EXk9eJR3C4d1V1froME8SCkfDhv9Omid6r7+Qggz/h4uOGk16A0KmQU6Qi7Lem2cINurtQzvCMcnAQqgNyjEfhlHWm4x7YK8mHdbTOOdd1Kco27qd2qLGphknjI/7+anBiLtboJ2N0JA26rvEzUBJn1WOQ+Kb7ganEgeFCHsQqvVEODlysW8EjLyS8wDlDPlE2RleEc0ABKgAIs3n+D34xm4u2hZcm9vvBpT16e+DFL2VgQk5/aActnyX40TtOxbEZCE9wInC7//qAnQ+WZ1tU7+BXXOSetB0nMihJ0FmgKUinkoujIDh1JyAOlBEQ1DI/qf+Or8cSKDd39VJ3++dmsMHUN87Fyja6Qoaq/IqS3qipuk36Ak17xMQLuKgKTNYHC/hrk2Wie1x0UI4TDUdPd5XLpsJc+R1FxKygz4ebjQtrmX/SonhIWadIByIbeYf63aj6LA5L4R3N67pb2rdHWKstRA5ORmNSjJPmN+3t0f2g5VA5K2N0Kz1vaopRCinlSVrO3y/CeNdghbNCpNNkAp0xuYvmI/Gfk6uoT5MmdCV3tXyXL6Uji3uyIgOb8PFEPFea0LRPSHdkPVnpKwHjLsIkQTUlWytn2S/0Q0ME02QHlzwzF2nc7E282ZD+7phbuLA/8Hrihw6URFQHL6d9Dlm5dp3kntIWl3E7S+Dty87VNXIYTdVSRrq+hBkR2MRUPTJAOUX49c4MNtJwFYeEc3Ih1xPLbgEiRtVQOSk1sg95z5ec/A8mGbm9RhG78W9qilEMIBNTcla1N7UNLzijmXVYRGA90jmlh+J9FgNbkAJTmzkKe+OgDA1EFtGBsTZucalSsrUROjnSxfbZN6ALP8Ik6u0GpARUAS2g20spWSEKKy5lekuzemt+8Y7IOPexPOji0alCYVoOjKDDyxYh85RaV0j/DnubFd7FcZRYGLRysCkjN/QGmheZngqIqApPUgcJWt0YUQtTP1oJQP8RgDFNkgUDQkTSpAmffzEQ6cy8HPw4X3p/TE1bmeeyDyL8KprRWZW/NSzc97BVestGk7FHwdpHdHCNGgBF4WoCiKIvNPRIPUqAMUvUFhV1Im6XnFnLpYwNIdpwF4567utGxWD70RpcVw9s+KgCTtkPl5Z3e1Z6Rt+eTWkK4gy/+EENco0Esd4tHpDWQVlnLwXDYAvVr7269SQljJqgBlzpw5zJ071+y1kJAQ0tLSAFAUhblz5/LRRx+RlZVF//79ef/99+natWIJb0lJCTNmzGDlypUUFRUxbNgwPvjgA1q2tG0OknXxqcxdm0BqTrHZ66O6hnBT5zraZVdR4MLhioDkzA4oM39/QmMqApJWA8DFo27qIoRostxdnPBxcyavpIztJzIoLjXg6+5M2+ayuk80HFb3oHTt2pVNmzaZnjs5VSzPXbhwIW+//TZLly6lY8eOvPrqq4wYMYLExER8fNQMrbGxsaxdu5ZVq1YRGBjI008/zbhx49i7d6/Zva7FuvhUHlu+r8p9djccvsC6+FRGR9to+CQvTZ1HYszcWpBuft4nrCIgaTsEvINt875CCFGDQG9X8krK2JhwAYAerZqh1UoPrWg4rA5QnJ2dCQ0NrfS6oii8++67PP/880ycOBGAZcuW/X979x4T1bXvAfw7w2PwAaNYZEBgii1qpqCJoDBYS496AGN9pEnBx7G0tY2ttZGoqY+eBtp4gRtzW62N1KaK2qbRNGhir32AV4W2o8VQqWCVEM9csFfGiVgYrGXgML/7xzgD856xDLP39PdJSGTvNYv922vtNT/33mtvxMbG4vPPP8f69evR09ODgwcP4tNPP8WiRYsAAJ999hkSExNx5swZ5OXl/clwzJd13vnyF6fJicU7X/6Cv6sUCHmYg7X/vvnMiOXdNvpfbNeHjTU/h8TyKPmYGXzZhjE26iaNl+F/u+7j/HXzf5r4BYFMbHxOUNra2hAfHw+ZTIbMzEyUlZVh6tSp0Gq10Ol0yM3NtZaVyWTIycmBRqPB+vXr0djYiIGBAZsy8fHxSE1NhUajcZmgGI1GGI1DT0Q0GAxOywFAg/auw2Wd4QhAZ08fGrR3oX5skueATSZAd2UoIem4CAz2DysgAeJmDSUkiZlAqMxzvYwx5keWqca9xn8D4BcEMvHxKUHJzMzE0aNHMW3aNNy+fRu7du1CdnY2rl69ar0PJTbW9v6O2NhYtLeb3w2j0+kQHh6OiRMnOpSxfN6Z8vJyh3tfXNH3DiUnUpgwV3odk9ENPSagwTQDJkgdyjno+b+hhORf54H7XbbroxIePLX1b0Dy08A4LxIdxhgbRRMf3ChrkTaFH9DGxMWnBGXx4sXWf6elpUGtVuOxxx7DkSNHkJWVBQAOL6EiIo8vpvJUZseOHdi8ebP1d4PBgMTERKdlJ0dGAADypA0oCTuKeMld67pbFI13Bp7Ht6a51nIAAOM983NILI+Sv9NqW2n4eODR+UOPkp/0OF+2YYwJ1jctnfjvn2/ZLFvywXcoWaoaufvvGPOzPzXNeNy4cUhLS0NbWxtWrFgBwHyWJC5u6ADQ6/XWsyoKhQL9/f347bffbM6i6PV6ZGdnu/w7MpkMMpl3l03mJkdj5fgmlA3scVinwF1Uhu3BP8O2Ym64Aqg/BNw4b36Cq2lgqKBECsTPHkpIpmQAoeEO9THGRt/+/fuxe/dudHZ24oknnsCePXswf/78QG+WYLiaJKDr6cNrn/2Eyn/M5iSFicKfelKZ0WjEtWvXEBcXh+TkZCgUCtTW1lrX9/f3o66uzpp8pKenIywszKZMZ2cnWlpa3CYovgiBCSVhRwEA9vfASiWABMB//Pu/EHJwAXB2F9D+vTk5mZAEpL8AFBwF3vwX8Mr/AAv+aX5OCScnjAnC8ePHUVxcjLfeeguXL1/G/PnzsXjxYnR0dAR60wTB3SQBy7J3vvwFgyZ30wgYEwafzqBs3boVS5cuRVJSEvR6PXbt2gWDwYCioiJIJBIUFxejrKwMKSkpSElJQVlZGcaOHYvVq1cDAORyOdatW4ctW7Zg0qRJiI6OxtatW5GWlmad1fOntWsw5g+dORNxwnxlhsyzbSw3tk79GxA9lS/bMCZw7733HtatW4eXX34ZALBnzx58++23qKysRHl5uUN5X26wDwYjPkmAsQDyKUH59ddfsWrVKty5cwcxMTHIysrCxYsXoVQqAQBvvvkm/vjjD2zYsMH6oLaamhrrM1AA4P3330doaCgKCgqsD2o7fPjwiD0DBfdue1fumT3ArMKR+ZuMMb/r7+9HY2Mjtm/fbrM8NzcXGo3G6Wd8ucE+GLi9+f8hyjEWSD4lKMeOHXO7XiKRoLS0FKWlpS7LREREYN++fdi3b58vf9p74718SmxUvH/+PmPML+7cuYPBwUGnMwVdzQL05Qb7YGBz8/8IlGMskILvXTzKbHPyYegEnF6JlZjXK0fmnhfG2OjyZaagLzfYB4O5ydGIk0dA19PnavSDQh6BucnRo71pjPlslF/nOwqkIUD+fz74xX7QevB7foW5HGNMNB555BGEhIQ4nC0ZPlPwry5EKkHJUhUAl6MfSpaqHu4p2oyNsuBLUABAtcw8GyfKbipdVLx5uWpZYLaLMfbQwsPDkZ6ebjMLEABqa2tHbBZgMMhPjUPlP2ZDIbe9jKOQR/AUYyYqwXeJx0K1DJixxPzenHu3zfemKLP5zAljIrZ582asXbsWGRkZUKvV+Pjjj9HR0YFXX3010JsmKPmpcfi7SoEG7V3oe/swOdJ8WYfPnDAxCd4EBTAnI8n8ACfGgkVhYSG6urrw7rvvorOzE6mpqfjqq6+sMwnZkBCphKcSM1EL7gSFMRZ0NmzYgA0bNgR6Mxhjfhac96AwxhhjTNQ4QWGMMcaY4HCCwhhjjDHB4QSFMcYYY4LDCQpjjDHGBIcTFMYYY4wJDicojDHGGBMcTlAYY4wxJjiifFAbkfk9nQaDIcBbwthfl+X4sxyPYsBjB2OB5cu4IcoEpbe3FwCQmJgY4C1hjPX29kIulwd6M7zCYwdjwuDNuCEhMf335wGTyYRbt24hMjISEsnIvPzKYDAgMTERN2/eRFRU1IjUKQTBGBfHJAxEhN7eXsTHx0MqFcfVYvuxQ4z73RmOQziCIQbAf3H4Mm6I8gyKVCpFQkKCX+qOiooSdadyJRjj4pgCTyxnTixcjR1i2++ucBzCEQwxAP6Jw9txQxz/7WGMMcbYXwonKIwxxhgTHE5QHpDJZCgpKYFMJgv0poyoYIyLY2IjJVj2O8chHMEQAyCMOER5kyxjjDHGghufQWGMMcaY4HCCwhhjjDHB4QSFMcYYY4LDCQpjjDHGBIcTFMYYY4wJTlAmKJWVlZg5c6b1CXhqtRpff/21df0LL7wAiURi85OVleWx3urqaqhUKshkMqhUKpw8edKfYdjwFJN9PJaf3bt3u6zz8OHDTj/T19c3GiE5KC8vh0QiQXFxsXUZEaG0tBTx8fEYM2YMnn76aVy9etVjXYFsK3v2cQ0MDGDbtm1IS0vDuHHjEB8fj+effx63bt1yW4/Q2ktoysvLMWfOHERGRmLy5MlYsWIFWltbbcoIvT95ikEsfcebthDDOOxNHGIYez19fwj2uKAgdOrUKTp9+jS1trZSa2sr7dy5k8LCwqilpYWIiIqKiig/P586OzutP11dXW7r1Gg0FBISQmVlZXTt2jUqKyuj0NBQunjx4miE5DGm4bF0dnbSoUOHSCKR0I0bN1zWWVVVRVFRUQ6fDYSGhgZ69NFHaebMmbRp0ybr8oqKCoqMjKTq6mpqbm6mwsJCiouLI4PB4LKuQLfVcM7i6u7upkWLFtHx48fp+vXrdOHCBcrMzKT09HS3dQmpvYQoLy+PqqqqqKWlhZqammjJkiWUlJRE9+7ds5YRen/yFINY+o43bSGGcdibOMQw9nr6/hDqcRGUCYozEydOpE8++YSIzAfG8uXLffp8QUEB5efn2yzLy8ujlStXjtQm+mx4TPaWL19OCxYscPv5qqoqksvlftgy3/T29lJKSgrV1tZSTk6O9YvcZDKRQqGgiooKa9m+vj6Sy+X00UcfuaxPKG3lKi5nGhoaCAC1t7e7LCOU9hILvV5PAKiuro6IxNmf7GNwRgx9x1kcYhyHvWkPsYy9lu8PIR8XQXmJZ7jBwUEcO3YMv//+O9RqtXX5+fPnMXnyZEybNg2vvPIK9Hq923ouXLiA3Nxcm2V5eXnQaDR+2W53XMVkcfv2bZw+fRrr1q3zWNe9e/egVCqRkJCAZ555BpcvX/bHJrv1+uuvY8mSJVi0aJHNcq1WC51OZ7PfZTIZcnJy3O53obSVq7ic6enpgUQiwYQJE9yWE0J7iUVPTw8AIDo6GoA4+5N9DK7KCL3vuIpDbOOwp/YQw9hr//0h5ONClG8z9kZzczPUajX6+vowfvx4nDx5EiqVCgCwePFiPPfcc1AqldBqtXj77bexYMECNDY2unysr06nQ2xsrM2y2NhY6HQ6v8di4S6m4Y4cOYLIyEg8++yzbuubMWMGDh8+jLS0NBgMBuzduxfz5s3Dzz//jJSUFH+FYePYsWP46aefcOnSJYd1ln3rbL+3t7e7rFMIbeUuLnt9fX3Yvn07Vq9e7fatoUJoL7EgImzevBlPPvkkUlNTAYivPzmLwZ4Y+o6rOMQ2DnvTHkIee119f1gSCiEeF0GboEyfPh1NTU3o7u5GdXU1ioqKUFdXB5VKhcLCQmu51NRUZGRkQKlU4vTp0247lkQisfmdiByW+ZO7mIY7dOgQ1qxZg4iICLf1ZWVl2dyUNm/ePMyePRv79u3DBx984JcYhrt58yY2bdqEmpoat9v6MPs9kG3lbVyA+abHlStXwmQyYf/+/W7LBrq9xGTjxo24cuUKvv/+e4d1YulP7mIAxNN3XMUhtnHYU3sAwh57XX1/WAjxuAjaBCU8PByPP/44ACAjIwOXLl3C3r17ceDAAYeycXFxUCqVaGtrc1mfQqFwyAz1er1DBulP3sT03XffobW1FcePH/e5fqlUijlz5rjdDyOpsbERer0e6enp1mWDg4Oor6/Hhx9+aL1bXqfTIS4uzlrG034PdFt5istoNCIkJAQDAwMoKCiAVqvF2bNn3f4P2JnRbi+xeOONN3Dq1CnU19cjISHBulyhUAAQR39yFYOFWPqOpziGE/I47E0cQh97XX1/bNu2DYAwj4ugvwfFgohgNBqdruvq6sLNmzdtGseeWq1GbW2tzbKamhpkZ2eP6Hb6wllMBw8eRHp6OmbNmvVQ9TU1NbndDyNp4cKFaG5uRlNTk/UnIyMDa9asQVNTE6ZOnQqFQmGz3/v7+1FXV+d2vwe6rTzFNTw5aWtrw5kzZzBp0iSf/85ot5fQERE2btyIEydO4OzZs0hOTrZZn5ycLPj+5CkGAKLoO97EYU+I47AvcYhp7LX8TaPRKOzjYsRutxWQHTt2UH19PWm1Wrpy5Qrt3LmTpFIp1dTUUG9vL23ZsoU0Gg1ptVo6d+4cqdVqmjJlis2UqrVr19L27dutv//www8UEhJCFRUVdO3aNaqoqBjVqavuYrLo6emhsWPHUmVlpdM67GMqLS2lb775hm7cuEGXL1+mF198kUJDQ+nHH3/0ezyu2M92qaioILlcTidOnKDm5mZatWqVw/Q3obWVM8PjGhgYoGXLllFCQgI1NTXZTDM0Go3Wz4ihvYTktddeI7lcTufPn7fZp/fv37eWEXp/8hSDWPqOpzjEMg5706eIhD/2evr+EOpxEZQJyksvvURKpZLCw8MpJiaGFi5caG2I+/fvU25uLsXExFBYWBglJSVRUVERdXR02NSRk5NDRUVFNsu++OILmj59OoWFhdGMGTOourp6tEJyG5PFgQMHaMyYMdTd3e20DvuYiouLKSkpyVpnbm4uaTQaf4bhkX2CYjKZqKSkhBQKBclkMnrqqaeoubnZ4TNCaitnhsel1WoJgNOfc+fO2XxG6O0lJK72aVVVlbWM0PuTpxjE0nc8xSGWcdibPkUk/LHX0/eHUI8LCRHRyJ2PYYwxxhj78/4y96AwxhhjTDw4QWGMMcaY4HCCwhhjjDHB4QSFMcYYY4LDCQpjjDHGBIcTFMYYY4wJDicojDHGGBMcTlAYY4wxJjicoDDGGGNMcDhBYYwxxpjgcILCGGOMMcH5f2eRIn8Bq2H3AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -951,17 +996,16 @@ ], "source": [ "import matplotlib.pyplot as plt \n", - "%matplotlib inline\n", "\n", "fig, ax = plt.subplots(1, 2)\n", "\n", - "ax[0].scatter(bream, bream_weights, label=\"true weight\");\n", - "ax[0].scatter(bream, predicted_bream_weights, label=\"prediction\");\n", + "ax[0].plot(result_bream[\"length\"], result_bream[\"weight\"], label=\"true weight\", marker=\"o\");\n", + "ax[0].plot(result_bream[\"length\"], result_bream[\"predicted\"], label=\"prediction\", marker=\"o\");\n", "ax[0].legend()\n", "ax[0].set_title(\"Bream\")\n", "\n", - "ax[1].scatter(roach, roach_weights, label=\"true weight\");\n", - "ax[1].scatter(roach, predicted_roach_weights, label=\"prediction\");\n", + "ax[1].plot(result_roach[\"length\"], result_roach[\"weight\"], label=\"true weight\", marker=\"o\");\n", + "ax[1].plot(result_roach[\"length\"], result_roach[\"predicted\"], label=\"prediction\", marker=\"o\");\n", "ax[1].legend()\n", "ax[1].set_title(\"Roach\");" ] @@ -983,9 +1027,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.12.6" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 }