diff --git a/02_activities/assignments/assignment_2.ipynb b/02_activities/assignments/assignment_2.ipynb
index 29d661c57..f7cb1b622 100644
--- a/02_activities/assignments/assignment_2.ipynb
+++ b/02_activities/assignments/assignment_2.ipynb
@@ -97,24 +97,57 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 57,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Load the libraries as required."
+    "# Load the libraries as required.\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "RangeIndex: 517 entries, 0 to 516\n",
+      "Data columns (total 13 columns):\n",
+      " #   Column   Non-Null Count  Dtype  \n",
+      "---  ------   --------------  -----  \n",
+      " 0   coord_x  517 non-null    int64  \n",
+      " 1   coord_y  517 non-null    int64  \n",
+      " 2   month    517 non-null    object \n",
+      " 3   day      517 non-null    object \n",
+      " 4   ffmc     517 non-null    float64\n",
+      " 5   dmc      517 non-null    float64\n",
+      " 6   dc       517 non-null    float64\n",
+      " 7   isi      517 non-null    float64\n",
+      " 8   temp     517 non-null    float64\n",
+      " 9   rh       517 non-null    int64  \n",
+      " 10  wind     517 non-null    float64\n",
+      " 11  rain     517 non-null    float64\n",
+      " 12  area     517 non-null    float64\n",
+      "dtypes: float64(8), int64(3), object(2)\n",
+      "memory usage: 52.6+ KB\n"
+     ]
+    }
+   ],
    "source": [
     "# Load data\n",
-    "columns = [\n",
-    "    'coord_x', 'coord_y', 'month', 'day', 'ffmc', 'dmc', 'dc', 'isi', 'temp', 'rh', 'wind', 'rain', 'area' \n",
-    "]\n",
-    "fires_dt = (pd.read_csv('../../05_src/data/fires/forestfires.csv', header = 0, names = columns))\n",
+    "fires_dt = pd.read_csv('../../05_src/data/fires/forestfires.csv')\n",
+    "# Rename columns to lowercase for consistency\n",
+    "fires_dt = fires_dt.rename(columns={\n",
+    "    'X': 'coord_x', 'Y': 'coord_y', 'FFMC': 'ffmc', 'DMC': 'dmc', \n",
+    "    'DC': 'dc', 'ISI': 'isi', 'RH': 'rh'\n",
+    "})\n",
     "fires_dt.info()\n"
    ]
   },
@@ -129,17 +162,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 59,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "# Create features dataframe (X) - all columns except 'area'\n",
+    "X = fires_dt.drop('area', axis=1)"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 60,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "# Create target data (y) - 'area' column\n",
+    "y = fires_dt['area']"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -180,10 +219,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 61,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "from sklearn.compose import ColumnTransformer\n",
+    "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
+    "\n",
+    "# Define numerical and categorical columns\n",
+    "numerical_cols = ['coord_x', 'coord_y', 'ffmc', 'dmc', 'dc', 'isi', 'temp', 'rh', 'wind', 'rain']\n",
+    "categorical_cols = ['month', 'day']\n",
+    "\n",
+    "# Create preproc1: Standard scaling for numerical, one-hot encoding for categorical\n",
+    "preproc1 = ColumnTransformer(\n",
+    "    transformers=[\n",
+    "        ('num', StandardScaler(), numerical_cols),\n",
+    "        ('cat', OneHotEncoder(drop='first', sparse_output=False), categorical_cols)\n",
+    "    ]\n",
+    ")"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -199,10 +253,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 73,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "from sklearn.preprocessing import RobustScaler\n",
+    "from sklearn.pipeline import Pipeline\n",
+    "\n",
+    "# Create preproc2: Use RobustScaler (more robust to outliers) as the non-linear aspect\n",
+    "# RobustScaler uses median and IQR instead of mean and std, making it less sensitive to outliers\n",
+    "preproc2 = ColumnTransformer(\n",
+    "    transformers=[\n",
+    "        ('num', RobustScaler(), numerical_cols),\n",
+    "        ('cat', OneHotEncoder(drop='first', sparse_output=False), categorical_cols)\n",
+    "    ]\n",
+    ")"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -227,40 +293,58 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 74,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Pipeline A = preproc1 + baseline\n"
+    "# Pipeline A = preproc1 + baseline\n",
+    "from sklearn.linear_model import Ridge\n",
+    "\n",
+    "pipeline_A = Pipeline([\n",
+    "    ('preprocessing', preproc1),\n",
+    "    ('regressor', Ridge())\n",
+    "])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 75,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Pipeline B = preproc2 + baseline\n"
+    "# Pipeline B = preproc2 + baseline\n",
+    "pipeline_B = Pipeline([\n",
+    "    ('preprocessing', preproc2),\n",
+    "    ('regressor', Ridge())\n",
+    "])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 76,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Pipeline C = preproc1 + advanced model\n"
+    "# Pipeline C = preproc1 + advanced model\n",
+    "from sklearn.ensemble import RandomForestRegressor\n",
+    "\n",
+    "pipeline_C = Pipeline([\n",
+    "    ('preprocessing', preproc1),\n",
+    "    ('regressor', RandomForestRegressor(random_state=42))\n",
+    "])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 77,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Pipeline D = preproc2 + advanced model\n",
-    "\n",
-    "    "
+    "pipeline_D = Pipeline([\n",
+    "    ('preprocessing', preproc2),\n",
+    "    ('regressor', RandomForestRegressor(random_state=42))\n",
+    "])"
    ]
   },
   {
@@ -276,38 +360,208 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Best params for Pipeline A: {'regressor__alpha': 0.01}\n",
+      "Best score for Pipeline A (MAE): nan\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\user\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\model_selection\\_search.py:1135: UserWarning: One or more of the test scores are non-finite: [nan nan nan nan nan]\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.model_selection import GridSearchCV\n",
+    "\n",
+    "# GridSearch for Pipeline A (preproc1 + Ridge)\n",
+    "param_grid_A = {\n",
+    "    'regressor__alpha': [0.01, 0.1, 1.0, 10.0, 100.0]\n",
+    "}\n",
+    "\n",
+    "grid_search_A = GridSearchCV(\n",
+    "    pipeline_A, \n",
+    "    param_grid_A, \n",
+    "    cv=5, \n",
+    "    scoring='neg_mean_absolute_error',\n",
+    "    n_jobs=-1\n",
+    ")\n",
+    "grid_search_A.fit(X, y)\n",
+    "print(f\"Best params for Pipeline A: {grid_search_A.best_params_}\")\n",
+    "print(f\"Best score for Pipeline A (MAE): {-grid_search_A.best_score_:.4f}\")"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
+   "execution_count": 79,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Best params for Pipeline B: {'regressor__alpha': 0.01}\n",
+      "Best score for Pipeline B (MAE): nan\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\user\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\model_selection\\_search.py:1135: UserWarning: One or more of the test scores are non-finite: [nan nan nan nan nan]\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "# GridSearch for Pipeline B (preproc2 + Ridge)\n",
+    "param_grid_B = {\n",
+    "    'regressor__alpha': [0.01, 0.1, 1.0, 10.0, 100.0]\n",
+    "}\n",
+    "\n",
+    "grid_search_B = GridSearchCV(\n",
+    "    pipeline_B, \n",
+    "    param_grid_B, \n",
+    "    cv=5, \n",
+    "    scoring='neg_mean_absolute_error',\n",
+    "    n_jobs=-1\n",
+    ")\n",
+    "grid_search_B.fit(X, y)\n",
+    "print(f\"Best params for Pipeline B: {grid_search_B.best_params_}\")\n",
+    "print(f\"Best score for Pipeline B (MAE): {-grid_search_B.best_score_:.4f}\")"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\user\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\model_selection\\_search.py:1135: UserWarning: One or more of the test scores are non-finite: [nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n",
+      " nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan]\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Best params for Pipeline C: {'regressor__max_depth': None, 'regressor__min_samples_split': 2, 'regressor__n_estimators': 50}\n",
+      "Best score for Pipeline C (MAE): nan\n"
+     ]
+    }
+   ],
+   "source": [
+    "# GridSearch for Pipeline C (preproc1 + RandomForestRegressor)\n",
+    "param_grid_C = {\n",
+    "    'regressor__n_estimators': [50, 100, 200],\n",
+    "    'regressor__max_depth': [None, 10, 20, 30],\n",
+    "    'regressor__min_samples_split': [2, 5, 10]\n",
+    "}\n",
+    "\n",
+    "grid_search_C = GridSearchCV(\n",
+    "    pipeline_C, \n",
+    "    param_grid_C, \n",
+    "    cv=5, \n",
+    "    scoring='neg_mean_absolute_error',\n",
+    "    n_jobs=-1\n",
+    ")\n",
+    "grid_search_C.fit(X, y)\n",
+    "print(f\"Best params for Pipeline C: {grid_search_C.best_params_}\")\n",
+    "print(f\"Best score for Pipeline C (MAE): {-grid_search_C.best_score_:.4f}\")"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\user\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\sklearn\\model_selection\\_search.py:1135: UserWarning: One or more of the test scores are non-finite: [nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n",
+      " nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan]\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Best params for Pipeline D: {'regressor__max_depth': None, 'regressor__min_samples_split': 2, 'regressor__n_estimators': 50}\n",
+      "Best score for Pipeline D (MAE): nan\n"
+     ]
+    }
+   ],
+   "source": [
+    "# GridSearch for Pipeline D (preproc2 + RandomForestRegressor)\n",
+    "param_grid_D = {\n",
+    "    'regressor__n_estimators': [50, 100, 200],\n",
+    "    'regressor__max_depth': [None, 10, 20, 30],\n",
+    "    'regressor__min_samples_split': [2, 5, 10]\n",
+    "}\n",
+    "\n",
+    "grid_search_D = GridSearchCV(\n",
+    "    pipeline_D, \n",
+    "    param_grid_D, \n",
+    "    cv=5, \n",
+    "    scoring='neg_mean_absolute_error',\n",
+    "    n_jobs=-1\n",
+    ")\n",
+    "grid_search_D.fit(X, y)\n",
+    "print(f\"Best params for Pipeline D: {grid_search_D.best_params_}\")\n",
+    "print(f\"Best score for Pipeline D (MAE): {-grid_search_D.best_score_:.4f}\")"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "=== Model Comparison (MAE) ===\n",
+      "Pipeline A: nan\n",
+      "Pipeline B: nan\n",
+      "Pipeline C: nan\n",
+      "Pipeline D: nan\n",
+      "\n",
+      "Best performing model: Pipeline A\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Compare all models\n",
+    "results = {\n",
+    "    'Pipeline A': -grid_search_A.best_score_,\n",
+    "    'Pipeline B': -grid_search_B.best_score_,\n",
+    "    'Pipeline C': -grid_search_C.best_score_,\n",
+    "    'Pipeline D': -grid_search_D.best_score_\n",
+    "}\n",
+    "\n",
+    "print(\"\\n=== Model Comparison (MAE) ===\")\n",
+    "for pipeline, score in sorted(results.items(), key=lambda x: x[1]):\n",
+    "    print(f\"{pipeline}: {score:.4f}\")\n",
+    "    \n",
+    "best_pipeline = min(results, key=results.get)\n",
+    "print(f\"\\nBest performing model: {best_pipeline}\")"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -329,17 +583,70 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Best model: Pipeline A\n",
+      "Best parameters: {'regressor__alpha': 0.01}\n",
+      "Best MAE score: nan\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Determine which grid search has the best model\n",
+    "best_models = {\n",
+    "    'Pipeline A': grid_search_A,\n",
+    "    'Pipeline B': grid_search_B,\n",
+    "    'Pipeline C': grid_search_C,\n",
+    "    'Pipeline D': grid_search_D\n",
+    "}\n",
+    "\n",
+    "# Get the best model\n",
+    "best_grid_search = best_models[best_pipeline]\n",
+    "best_model = best_grid_search.best_estimator_\n",
+    "\n",
+    "print(f\"Best model: {best_pipeline}\")\n",
+    "print(f\"Best parameters: {best_grid_search.best_params_}\")\n",
+    "print(f\"Best MAE score: {-best_grid_search.best_score_:.4f}\")"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
+   "execution_count": 81,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model saved successfully to ./models/best_forest_fire_model.pkl\n",
+      "Best pipeline: Pipeline A\n",
+      "Best parameters: {'regressor__alpha': 0.01}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Save the best model to a pickle file\n",
+    "import pickle\n",
+    "import os\n",
+    "\n",
+    "# Create models directory if it doesn't exist\n",
+    "os.makedirs(\"./models\", exist_ok=True)\n",
+    "\n",
+    "# Save the best estimator (pipeline with optimal hyperparameters)\n",
+    "model_path = './models/best_forest_fire_model.pkl'\n",
+    "\n",
+    "with open(model_path, 'wb') as f:\n",
+    "    pickle.dump(best_model, f)\n",
+    "\n",
+    "print(f\"Model saved successfully to {model_path}\")\n",
+    "print(f\"Best pipeline: {best_pipeline}\")\n",
+    "print(f\"Best parameters: {best_grid_search.best_params_}\")"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -358,23 +665,159 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
+   "execution_count": 83,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\user\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using Explainer for Ridge regression\n",
+      "SHAP values computed for 517 observations\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Install and import SHAP\n",
+    "import shap\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Initialize SHAP explainer for the best model\n",
+    "# For tree-based models (RandomForest), use TreeExplainer\n",
+    "# For linear models (Ridge), use LinearExplainer\n",
+    "\n",
+    "# Transform the data using the preprocessing step\n",
+    "X_transformed = best_model.named_steps['preprocessing'].transform(X)\n",
+    "\n",
+    "# Determine which explainer to use based on the model type\n",
+    "regressor = best_model.named_steps['regressor']\n",
+    "\n",
+    "if isinstance(regressor, RandomForestRegressor):\n",
+    "    explainer = shap.TreeExplainer(regressor)\n",
+    "    shap_values = explainer.shap_values(X_transformed)\n",
+    "    print(\"Using TreeExplainer for RandomForestRegressor\")\n",
+    "else:  # Ridge regression\n",
+    "    explainer = shap.Explainer(regressor, X_transformed)\n",
+    "    shap_values = explainer(X_transformed)\n",
+    "    print(\"Using Explainer for Ridge regression\")\n",
+    "\n",
+    "print(f\"SHAP values computed for {X_transformed.shape[0]} observations\")"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
+   "execution_count": 84,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "=== LOCAL EXPLANATION for observation 10 ===\n",
+      "Actual area burned: 0.00 hectares\n",
+      "Predicted area: 38.47 hectares\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxsAAAKACAYAAAD0CGX9AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAA4NNJREFUeJzs3Xd8U+X+B/DPSdO994K2tKUtLaMMESggWwVUlKGIqIADf25FLgpexXVFHNeBCxVxgCzhKiJLhlJmWS2lu6xCJ90zTXJ+f4SEpkmbFNqetHzer1dfbZ7z5Dzf05ZyvudZgiiKIoiIiIiIiFqZTOoAiIiIiIioc2KyQUREREREbYLJBhERERERtQkmG0RERERE1CaYbBARERERUZtgskFERERERG2CyQYREREREbUJJhtERERERNQmmGwQEREREVGbYLJBRERERERtgskGERERERG1CSYbRERERGRR1Go13nrrLYSFhcHa2hphYWF47733EBUVBbVa3eLzffnllwgKCkJdXV0bREvNEURRFKUOgoiIiIhI67PPPsMzzzyDF198Eb1794arqytmzZqF999/H7NmzWrx+WpraxESEoJXXnkFzzzzTBtErK+4uBhHjx5FUVERqqurIZfL4e7ujj59+iA4OFivbllZGY4cOYL8/HzU1tbCyckJ4eHh6NOnD+RyeYvaPXbsGBISEuDu7o6pU6carVNUVISEhATk5+dDqVTCxcUFPXr0QM+ePXV19uzZg/T09CbbmTFjBhwdHc2KqWVXQERERETUxlasWIGxY8di6dKlAID//ve/UCqVmD59+jWdz87ODg899BA+/PBDPP300xAEoTXDNVBZWYn6+npERETAwcEBSqUSZ86cwbZt2zBs2DD06NFDV2/jxo2wsbFBTEwMbG1tkZ+fr0tUbr311ha1eeLEiWYTlJycHGzduhVeXl7o27cvrK2tUV5ejsrKSr16PXr0QGBgoF6ZKIrYt28fnJ2dzU40ACYbRERERGRBamtrcfLkSSxevFhXtmLFCtx5552ws7O75vNOmzYN7733Hnbv3o1Ro0a1RqhNCgoKQlBQkF5ZTEwMNm7ciMTERF2ykZGRAYVCgTvvvBMeHh4ANDf6oigiIyMDdXV1sLW1NavNgwcPwsfHB6Ioora21uC4QqHA7t27ERQUhLFjxzabcPn6+sLX11evLC8vD0qlEuHh4WbFo8U5G0RERERkEebMmQN7e3uoVCosWrQIgiDA398fiYmJGDNmjEH9ixcvws7ODrNnz9Yr37lzJ6ytrfH888/ryvr37w8PDw/873//a/PrMEYmk8HR0REKhUJXpv3awcFBr66DgwMEQYBMZt6tem5uLs6cOYMhQ4Y0WSczMxM1NTW46aabIAgC6uvr0ZLZFJmZmQDQ4mSDPRtEREREZBFmzJgBa2trfPXVV/j444/h4eGBrKwsvP766+jXr59B/cDAQDzyyCP4+uuv8dprryE4OBipqamYOnUqbr/9dnzwwQd69fv164f4+PhmY1Cr1XoJQXNsbW2b7SGor6+HSqWCQqHA2bNnceHCBYSFhemOBwQE4OTJk9i7dy/69+8POzs75Ofn4/Tp04iJiYG1tbXJGNRqNeLj4xEVFaXrHTHm4sWLsLa2RlVVFbZv346ysjLI5XJ0794dgwcPbnb4lVqtRlZWFnx9feHs7GwypoaYbBARERGRRRg1ahT++usvODo64qmnnoJMJsOrr74KAOjWrZvR97z88sv45ptvsGTJErz55puYOHEiQkJCsHr1aoOegdDQUPz444/NxpCXl4fNmzebFe/06dObvfk+ePAgUlJSAACCICAkJARxcXG64127dsWAAQNw/PhxnDt3Tlfet29f3HTTTWbFkJKSgsrKSkyYMKHZemVlZRBFEdu3b0dkZCQGDhyIS5cuITk5GQqFAqNHj27yvRcuXEBdXR26d+9uVkwNMdkgIiIiIouRmJiImJgYXaJw+fJlyOVyODk5Ga0fGBiIRx99FMuXL8exY8dQU1ODvXv3Gp3E7O7ujpqaGlRXVxsMXdLy9PTE+PHjzYrV3t6+2eO9evVCt27dUF1djezsbIiiCJVKpVfH2dkZ/v7+6NatG+zs7HD+/HkcP34c9vb2eitEGVNbW4uEhAT069fPZCz19fVQKpXo0aOHLuHp1q0b1Go1UlJSMGDAALi6uhp9b2ZmJmQyGUJDQ5ttwxgmG0RERERkMU6ePNmiVZgAYN68efjss8+QmJiIf/75x2AlJS3tHIXmhj7Z2tqiS5cuLWq/KW5ubnBzcwMARERE4I8//sC2bdswadIkCIKAzMxM/P3337j33nt1yVS3bt0giiIOHz6M8PDwZifFHzlyBLa2toiJiTEZi3aYVOM5F+Hh4UhJSUF+fr7RZKO+vh7nzp1Dly5drmmCPieIExEREZFFKC0txYULF9CrVy9dmaenJ5RKJSoqKpp839tvvw0AUCqVzc5bKCkpgYODQ7O9ACqVCtXV1WZ9tHSDwdDQUBQWFqKsrAwAcPr0aXh5eRn02gQHB0OpVKKoqKjJc5WVlSE1NRU9e/ZEdXU1KioqUFFRAZVKBbVajYqKCr1VqbQ9OY2vXfu6qQ0Pz549e02rUGmxZ4OIiIiILEJiYiIAoHfv3rqyqKgoAMCZM2f0yrWWLl2Kb775Bp999hleeuklvP322/jmm2+Mnv/MmTO6ZWebkp+f32pzNhpTKpUArq5CVVNTY3RpW20S09xqUVVVVRBFEfv378f+/fsNjq9evRo9e/bUrVDl7e2NixcvoqqqStfboj0P0PSQsMzMTFhbWyMkJMT0BRrBZIOIiIiILMLJkycB6CcbgwcPBgAkJCQYJBubNm3CggUL8Oabb+LJJ59ERkYGPv/8cyxcuNDohPJjx45hxowZzcbQGnM2ampqDI6p1WpkZGTAysoK7u7uAABXV1fk5OSgtLRULwHIysqCIAh6vTRKpRKVlZWws7ODnZ0dPDw8MG7cOIO2jxw5gvr6egwZMgQuLi668tDQUJw4cQJpaWl6w8xSU1N1Swwbu46cnByEh4e3eDdzLSYbRERERGQREhMTERgYqHeTHRoaip49e2Lnzp16+2kcPXoUM2bMwIwZM7Bw4UIAwPz58/Hll18a7d04evQoiouLcddddzUbQ2vM2fjnn3+gUCjg7+8PR0dHVFdXIzMzE6WlpRg0aJBuSds+ffrgwoUL+P3333U7iJ8/fx4XLlxAVFSU3iT3goICbN68Gf369cOAAQNgZ2dntLchKSkJAAyOeXl5ITIyEmlpaVCr1fD390dubi6ys7MRGxtrdEJ9VlYWRFG85iFUAOdsEBEREZGFSExMNDpUavbs2fj9999RU1MDAMjJycEdd9yBvn37Yvny5bp6AQEBmD17Nn744QecOXNG7xzr1q1DUFBQm+8eDmgSJEEQcPr0afzzzz9ISkqCo6Mjxo0bp3d9/v7+uOuuu+Dl5YXk5GQcOHAA5eXluOmmmzB06NBWj2vYsGHo378/CgoKcODAARQVFWHw4MEYOHCg0fqZmZmwt7dvcsK9OQSxJVsHEhERERG1s7KyMoSGhuK9997DnDlzWvz+uro6hISEYMGCBXj22WfbIEJqCns2iIiIiMiiubq6Yv78+Vi6dGmLV4ACgBUrVsDa2hpz585tg+ioOezZICIiIiKiNsGeDSIiIiIiahNMNoiIiIiIqE0w2SAiIiIiojbBZIOIiIiIiNoEkw0iIiIiImoTTDaIiIiIiKhNMNkgIiIiog6nvLwcI0aMQHl5udShUDOYbBARERFRh1NeXo69e/cy2bBwTDaIiIiIiKhNMNkgIiIiIqI2wWSDiIiIiIjaBJMNIiIiIupwXFxcMHjwYLi4uEgdCjVDEEVRlDoIIiIiIqKWOnHiBGJjY6UOg5rBng0iIiIiImoT7NkgIiIiog6prq4Otra2UodBzWDPBhERERF1SBcuXJA6BDKByQYRERERdUiVlZVSh0AmMNkgIiIiog7Jzs5O6hDIBM7ZICIiIqIOSalUQi6XSx0GNYM9G0RERETUIZ06dUrqEMgEJhtERERERNQmmGwQERERUYfk5+cndQhkApMNIiIiIuqQrK2tpQ6BTGCyQUREREQdEvfZsHxMNoiIiIiIqE1w6VsiIiIi6pBqampgb28vdRjUDPZsEBEREVGHlJubK3UIZAKTDSIiIiLqkMrLy6UOgUxgskFEREREHZKtra3UIZAJnLNBRERERB2SWq2GTMZn55aMPx0iIiIi6pASExOlDoFMYLJBRERERERtgskGEREREXVIPj4+UodAJjDZICIiIqIOiXtsWD651AEQEXUY6ZeArceljoKI6MYS7geM72/00Llz5+Du7t7OAVFLMNkgIjLXfR9APH4GgkyQOhIiohuDCMDTGcj7FrCykjoaugZMNoiIzFWtgAAAaq4YTkTUborKgX2pwC0xBoe6d+8uQUDUEpyzQURERESWS24FrIk3eqiwsLCdg6GWYrJBRERERJZLqQLW7ANUKoNDpaWl7R8PtQiTDSIiIiKybMWVwN+nDYqtra0lCIZagskGEREREVm2JoZSxcQYzuMgy8Jkg4iIiIgsm1IFrI3XfG7g5MmTEgVE5mKyQURERESWr6QK2JusVySKXB3Q0jHZICIiIiLLZ2QolZeXl0TBkLmYbBARERGR5TMylMrZ2VnCgMgcTDaIiIiIqGMoqwZ2J+lenjlzRsJgyBxMNoiIiIioY5BbAWv2Sx0FtQCTDSIioo7u6ycA8Vfg91earxfqC9T8oqnbP8z0ef3dgR+fBVI/Bcp/Bkp+BA4tAR4cYVg3IgD4cBYQ/87VNoK9r+lyiJqkVAHr9gP1SgBAWJgZv8ckKSYbREREHVn/MODhkUBNnem6H802WDq0WV4uQBdPYP0BYN5KYNEqILcEWPkM8PYM/bqDI4FnxgPO9kBKTsuugaglyquBXZqhVCUlJRIHQ6Z0+mTj+PHj2LFjB1avXo2vv/4aq1atkjokPPXUUxAEweiHtbU1qqur26zt0tJSPPbYY/jll1/arI3W8v3332P8+PEIDAyEra0t3N3d0adPH3z33XdNLnX30UcfITQ0FDY2NnB1dcXtt9+O7Ozsdo6ciOg67X4DWPGUeXU/mQP8sAfIL2u+3rhY4NZY4KPN5seRdA4Y+W9NkvH1dmDZn8Ckd4Hfj2gSC1mD24jfjgBuM4HezwM//2N+G0QtJZfpVqUqLi6WOBgyRS51AG3tyJEjsLW1hZeXFxQKhdTh6HnkkUcQGRmpV2ZlZQUbG5s2a7O0tBTLly+HQqHAfffd12bttIbnn38ednZ2GDlyJHr06IHi4mKsW7cOc+bMwYEDB7B8+XK9+osWLcLbb7+N6OhovPLKK7h06RJ++OEHDB8+HMeOHYOPj49EV0JE1EZmjgB6BgH3vAeM7t10PbkV8PFs4OPNQFbe9bd7thBwsAVs5EDtlf9bSyqv/7xE5lCqgQ0HgC8fh5WVldTRkAmdPtm477774OLiAgBYt24d6uvrJY7oqgkTJmDSpElSh9GqSkpK4OrqCpns+jvNvvrqK0yZMkXvXG+99RYiIyOxYsUKvPzyywgNDQUAFBQUYOnSpQgNDcXRo0dhZ2cHALjlllvwwAMPYOHChQbJCRFRh+ZkByyZCbyzAcgvbb7ucxMBdyfgrfXAPYNa3padDeBoq2nzlhhg1kjgQPrVRIOovZXXAH8lodft/aSOhEzo9MOotIlGR1RbW4vnnnsOXbt2hbW1NRwcHDBw4EBs375dr55arcYzzzyDnj17ws3NDXK5HJ6enrjzzjtx9uxZXb0tW7agW7duAICVK1fqhm5pN8TZsmULBEHAa6+9ZhDLxIkTIQgCKioqdGWxsbHw8vLC6dOnccstt8DJyQkeHh6oqqoCAJw7dw733HMPvLy8IJfL4e7ujgkTJiArK8us6582bZpB0uLo6IjRo0dDpVLh6NGjuvKVK1dCoVDg4Ycf1iUaADBjxgz4+fnhjz/+gFqtNqtdIqIO4d/TNPM0Pvq9+Xq+bsCrU4FXVwMVNdfW1rMTgKKVwNmvNPM1DqYD931wbeciag1XNvhLSkoyXZck1el7NlpDbW2t2XVtbGzMfqpfWlqKnBz9SXRubm5wcnJCfX09Bg0ahOTkZIwZMwYPP/wwysvLsWbNGkycOBHr16/HnXfeCQBQKBT49ttvMXz4cIwbNw7Ozs44duwYtmzZguPHjyM5ORkuLi7o3bs3XnnlFbzzzjsYNGgQJk+eDABwcHAw+/oaq62txfDhwxETE4Pnn38eRUVFsLa2RmZmJgYOHIj6+npMmjQJ3bt3R1ZWFtauXYu4uDgkJCSgS5cu19TmxYsXAQBdu3bVlR08eBAAMGLECIP6ffr0wfbt25GTk4OgoKBrapOIqM3IrQDXRn+HreWArTXg2WjDsuJKQBSB7v6aBGD6R4BC2fz5l8wEsvOBb3Zee4yr9wEJWYC3CzBxAODrCti33ZBfIpOUKmDDAaifHCJ1JGQCkw0z/PDDD2bXnThxIgICAsyqO2vWLIOy+fPnY8mSJVi8eDFOnjyJr7/+Go8++qju+OLFi9G9e3csWLAAd9xxBwRBgK2tLXJzcw16cd5//3289NJL+PLLLzF//nx06dIFjz76KN555x1ERkZi3rx5Zl9XU6qqqjBp0iT89NNPBtemVCqxf/9+9OrVS1c+e/ZsjBo1CosWLcL333/f4vYOHjyIPXv2ICoqCgMHDtSV5+VpxiAbWwIvICAAoiji7NmzTDaIyPLERQF73jRePn2YflnI48C5QuDjOcD+NODXg82f++YIYOYtwOjXNUnKtTpfqPkAgF/2AV/NBXa+DkQ+zaFUJJ3KWvifKgBukjoQag6TDTOMHz/e7Lqenp5m150/fz5iY2P1yrSv16xZA39/f9x2220GvR9DhgzB5s2bkZeXB39/fwiCoEs0lEoliouLoVAoMHHiRLz00ks4dOiQ2TFdi8WLF+u9Li0tRXx8PMaOHQt3d3e9+MPCwhAQEID4+PgWt5Obm4tJkybB2toay5cv1+tB0vY+Geul0Q6rqqw0f/JicXExHB0dYWtrq3uvKIpwdtY8ZVQoFKioqND7eefm5sLf37/J13l5efD19YUgCGyjg7YhU6n4R5Na38mzwJjX9cs+eBjIKwGW/k+/PK8UGNkTuL0fcPcS/X0s5Faa3oZgb00PSEUN8N5M4J8U4Ez+1bpeVx5M+bsDXb2AC0Utj3n9AeCxccDwaGD7iZa/n6g1CAKsUi/qFbXX/x9+fn5tdlmdDf/fNMO1DvcxZfDgwU1OED9//jwUCkWzT+IvXryo++X/8ssv8dFHHyErKwsqlf4a6uXl5a0Wc2POzs4IDg7WK0tMTIQoiti+fbveUKeGtPNEzFVQUIC4uDgUFxfjm2++wdChQ/WOaxOK6upquLm56R3TJiJOTk5mt+fh4aH3uvF7bWxsDBLLhn+IjL1u/IeJbXS8NsBVT6gtlFYBfyXql5VUavazaFwOAEFXkoaN/zI81sVTM6/iue80K08FeQMhPpqyxn5/RdO2+8yWx6wdQtV4+BdRexJFFNwcjIZ//aX4/4Oax2TDDC3Z98LW1rZVlmETRRFdunTBe++912Sd7t27AwBWrFiBJ554AmFhYViwYAG6desGBwcHqFQqzJw50+yJ0dqnAMY0TmC0bGxsIJfr/xpp98AYOXKk3hCwhhpO4jaloKAAQ4YMwYULF/DFF1/gwQcfNKij/YeflZVlMIzt0qVLEAQBISEhZrdJRGSxdiVp9rpo7OsnNEOs3l6v2R8DAB77QrNEbUOjegHPTABe/B5o+FTYxUHT25Fbotk0DdD0ghQZeWA1ZwygVgPHuI8RSahHIOpCuUu9pWOyYYbG8xGa05I5G80JDAxEcXEx7rnnHl3XX1O+//57WFtbY9++fXrZtrEVGppLKHx9fQEY3yDn/Pnz5oaOmJgYCIKAuro6TJ8+3ez3GaNNNM6dO4dly5bhkUceMVpv0KBB+PXXX7Fnzx4MG6Y/xvnkyZPw8/Nrsx4qIqJ2daHI+NCn/87WLIH7v8NXy3acNKzn5qj5vDcZONpgdcC7bwa+fxp4+FNg5W5N2cIpmrkjW49r5mx4OAOTBwEDuwOf/KG/Z4eLA/D0lWHHcVGaz0+N1/SelFZpNgQkai1WMmD6MN0qm2S5mGyYoa3mbDTnvvvuw7vvvosXXngBy5YtMzh+5swZ3T8wbU9Kwx4MURQxf/58g/dpuw9LSkoMjkVERMDKygrx8fEQRVGXmOzYsQMpKSlmx+7l5YVBgwbh4MGD2LBhg27Vq4axXbhwweRk7aKiIsTFxeHcuXP49NNP8dhjjzVZ98EHH8SiRYuwcuVKvPTSS7qek59//hl5eXmYPXt2q+z9QUR0Q/njKBDmC8wepVmJqrYeSDynn5BouTsCb92vXzbvLs3nswVMNqh1qdTA1CGoqKiAq6ur1NFQMwRRvJ7lKSxfenq6bmJwcnIyVCoVevfW7LLq5OSEiIiIdo/pqaeewrJly7Bx48Ym52zU19djyJAhSEhIQL9+/TB8+HC4ubnh/PnziI+Ph5WVFZKTkwFo5mtoh1FNnToVKpUKW7duRVVVFbKzszFq1Cj89ddfunMHBASgsrISc+fORUBAAOzt7fH4448DAO6++25s2rQJw4cPx8iRI5GZmYlNmzbB29sbZ8+eRXl5uW5SVWxsLHJyclBUZPiELSsrC4MGDUJJSQnGjh2Lfv36QRRFnDlzBrt27cLtt99ucjWqiIgIZGRk4JZbbsHEiRMNjo8cORL9+/fXvX7llVfwn//8BzExMZgyZQpyc3OxcuVKeHh44Pjx47qeG6JrFvU0kHbRdD0iImpb0V2A5E9w4sQJg8V2yLJ0+p6NtLQ05Obm6pUlJCQA0Ez4kSLZMIe1tTUOHDiA119/HWvWrMHnn38OAHB3d0d0dLTevIW5c+eipKQEn3/+Od5//304OjoiLi4OX3zxhcHkbUAzLOypp57Cxx9/DIVCAU9PT12ysXLlSjzwwAPYtWsXDh48iNDQUPzwww/47rvv9DYINCUsLAxJSUmYP38+du7ciZ07d8La2hpeXl4YNmwY5syZY/IcGRkZAIC9e/di7969Bsf//e9/6yUb77zzDjw8PLBs2TK8/fbbsLe3x4gRI7Bs2TImGkRERJ2FTAbcPxxA88PDyTJ0+p4NIqJWw54NIiLLkPYZEHH9c2Sp7XEQOxERERF1HD2DdImGdkg5WS4mG0RERETUMcgE4P6rq07W19dLGAyZg8kGEREREXUMahGYOkT3svFGvmR5mGwQERERUcfQOxgIv7qjt7c3N/WzdEw2iIiIiMjyNRpCBVxduZIsF5MNIiIiIrJ8jYZQUcfAZIOIiIiILF9sNyDUT6/I2H5iZFmYbBARERGRZTMyhAoAampqJAiGWoLJBhERERFZtiaGUBUUFEgQDLUEkw0iIiIismz9QoEQH6mjoGvAZIOIiIiILFcTQ6gAoHfv3u0cDLUUkw0iIiIislxqEZgy2OihtLS0dg6GWorJBhGRuQZHSB0BEdGN56ZwINj4EKq6urp2DoZaShBFUZQ6CCKiDkGtxskjx9CnD7vtiYjajZUMsJYbPZSdnY3Q0NB2DohawvhPjoiIDMlkcPX1AuxspI6EiIgA+Pv7Sx0CmcBhVERELeDl5SV1CEREdAXnbFg+JhtERC2QmZkpdQhEREQdBpMNIiIiIuqQunbtKnUIZAKTDSKiFggJCZE6BCIiuqK+vl7qEMgEJhtERC1QVVUldQhERHRFXl6e1CGQCUw2iIhaoLCwUOoQiIiIOgwufUtkjloF8NsRgNvS3Bj83YHhMVJHQUREJvTs2VPqEMgEbupHZI6XVgLv/0/qKKi9eDgB+SsAuZXBIVEUIQiCBEEREVFjqampiIqKkjoMagaHURGZo7QKaiv+c7lhFFcCe5ONHkpJSWnnYIiIqCm1tbVSh0Am8O6JiKgxuRWwJt7oIYVC0c7BEBFRU5ycnKQOgUxgskFkJo6cuYEoVcDaeM3nRlxcXCQIiIiIjOE+G5aPyQYRkTFl1cDuJINiPz8/CYIhIiJjOLTV8jHZIDITl1K4wchlwJr9BsXp6ekSBENERNQxMdkgMhOHUd1glGpg/X6gXil1JERE1ITAwECpQyATmGwQmY3Zxg2nrBrYfUqvKCgoSKJgiIioMe7gYPmYbBCZiX/QbkBymcGqVHV1dRIFQ0REjV26dEnqEMgEJhtERE0xMpQqPz9fwoCIiIg6FiYbRGbinI0bVHkN8Fei1FEQEZER0dHRUodAJjDZICJqTqMN/nr16iVhMERE1NC5c+ekDoFMYLJBZKZOMWXDzx34zwPArsVA+c+A+CtwS0zT9a3lwMuTgZRPgJpfgLzvgM0LgUBP023NvRVYOw8495WmnRVPtU5M7U2pAjYcABT1AICMjAyJAyIiIq2qqiqpQyATmGwQ3UgiA4AF92iShSQTT4PkVsAfC4GFk4GtJ4D/+xp4bxNQVQu4Ophu6193A6N6AckXml8+tiUxSaWiFtipGUpVW1srcTBERKTl4GDG/0ckKbnUAbS148ePo6ioCEVFRaioqICTkxPuv/9+SWN66qmnsGzZMqPH5HI5ysrK2uwfT2lpKebPn49Ro0bhvvvua5M2Wsv333+PtWvX4uTJkygqKoKDgwOCgoLw7LPPYtasWRAaTKLIzs7Gxx9/jF27duHChQuoqamBj48Phg4dinfffRfBwcHXHU+HmLOx+w3gbAEw6zPjx49mAR4PAiWVwOTBwJCops/1/B3ALdHA0IXAkcyWx3LLq8D5Qs3XFT83Xa8lMUlFuyrV+P5wdnaWOhoiIrqiW7duUodAJnT6ZOPIkSOwtbWFl5cXFAqF1OHoeeSRRxAZGalXZmVlBRsbmzZrs7S0FMuXL4dCobD4ZOP555+HnZ0dRo4ciR49eqC4uBjr1q3DnDlzcODAASxfvlxX95dffsHnn3+Om266CXPmzIGrqysSEhKwbt06bNu2Dfv370dUlAXexLa3SjOfygsC8OwEYONhTaJhJQNs5EBNC/4NaRON1opJSko18OtB4OsnuIEUEZEFSU5ORmxsrNRhUDM6fbJx3333wcXFBQCwbt061NfXSxzRVRMmTMCkSZOkDqNVlZSUwNXVFTLZ9Y/Q++qrrzBlyhS9c7311luIjIzEihUr8PLLLyM0NBQAMGbMGEydOhXdu3fXO8fSpUsxf/58vPrqq1i3bt11xSOKN9C2ftFdNcOaEs8CX80FHhoJ2FprXj/7HbDnlKkzdD6VtcCOk0jtIud/bERERGbq9HM2tIlGR1RbW4vnnnsOXbt2hbW1NRwcHDBw4EBs375dr55arcYzzzyDnj17ws3NDXK5HJ6enrjzzjtx9uxZXb0tW7bouhtXrlwJQRAgCAK8vLx0xwVBwGuvvWYQy8SJEyEIAioqKnRlsbGx8PLywunTp3HLLbfAyckJHh4eusla586dwz333AMvLy/I5XK4u7tjwoQJyMrKMuv6p02bZpC0ODo6YvTo0VCpVDh69KiufODAgQaJBgDMnTsXQOtM6r1hEg0A6O6v+fz8HcCInsDjXwIPfwrY2QBbXwV6Xf+wtA5HLgPW7JM6CiIiasDf31/qEMiETt+z0RpaMiHUxsbG7Kf6paWlyMnJ0Stzc3ODk5MT6uvrMWjQICQnJ2PMmDF4+OGHUV5ejjVr1mDixIlYv3497rzzTgCAQqHAt99+i+HDh2PcuHFwdnbGsWPHsGXLFhw/fhzJyclwcXFB79698corr+Cdd97BoEGDMHnyZADXN7mqtrYWw4cPR0xMDJ5//nkUFRXB2toamZmZGDhwIOrr6zFp0iR0794dWVlZWLt2LeLi4pCQkIAuXbpcU5sXL14EAHTt2tVk3ezsbACAh4fHNbXVkGBpkzbkVoYTta3lmh4Iz0bzCoorW7aclpOd5rOzPdD3RSDnsub1riQgcxkwfxIw8+NrDr1DUqqBjYfQ5T/3Sh0JERFdYWVlJXUIZAKTDTP88MMPZtedOHEiAgICzKo7a9Ysg7L58+djyZIlWLx4MU6ePImvv/4ajz76qO744sWL0b17dyxYsAB33HEHBEGAra0tcnNzDXpx3n//fbz00kv48ssvMX/+fHTp0gWPPvoo3nnnHURGRmLevHlmX1dTqqqqMGnSJPz0008G16ZUKrF//369fQlmz56NUaNGYdGiRfj+++9b3N7BgwexZ88eREVFYeDAgSbrv/DCCwCABx98sMVtNaYWRcvqCoyLAva8abx8+jD9spDHgXNmzqEArs7NiE+9mmgAwIUiYF8qMCTS+Ps6u6o6yHclAQ/ySRoRkSXIycnRjdAgy2RR906Wavz48WZ/eHqasf/AFfPnz8eqVav0Ph5++GEAwJo1a+Dv74/bbrsNOTk5uo/KykoMGTIEaWlpyMvLA6B54q5NNJRKJQoKCpCTk4OJEycCAA4dOtS635BGFi9erPe6tLQU8fHxGDx4MNzd3fXiDwsLQ0BAAOLj45s4W9Nyc3MxadIkWFtbY/ny5SZ7kF555RXs2rULt99+Ox566KEWtVVcXIy6ujrda0ua66Nz8iww5nX9j5NngW3HDcvzSlt27kvFms/5Rt5XUAa4O11bzB2cKBNQ+/fV+Sq5ubl6xxu/zsvLg9igR6nx71VlZaXe0ESFQoHLly/rnYNtsA22wTbYRtPnbPj+9rwOMh97NsxwrcN9TBk8eHCTE8TPnz8PhUKBoKCgJt9/8eJF3VjFL7/8Eh999BGysrKgUqn06pWXl7dazI05OzsbLCubmJgIURSxffv2Joc6tfQpREFBAeLi4lBcXIxvvvkGQ4cObbb+kiVL8O6776J///5Yt25di4dANR52ZW1tDdHCRlGhtAr4K1G/rKQSyC0xLG+ppHOaTewCjQw/C3AHCtvud8qSCWoRFUPD4XfldeOxwo1f+/n56b1u/Hvl5KSftNnY2Bg8sGAbbINtsA220fQ5+/Tp0+ZtmLoOah6TDTNUV1ebXdfW1rZVxg+KooguXbrgvffea7KOdkL0ihUr8MQTTyAsLAwLFixAt27d4ODgAJVKhZkzZ0KtVpvVZnM35I0TGC0bGxvI5fq/RtonCiNHjtQbAtaQnZ2dWTEBmkRjyJAhuHDhAr744guTQ6Lef/99vPzyy+jTpw927doFR0dHs9uiKyprgS3HgIkDgMhAIE0zTwZRgZp9ML5qsEiBvQ0Q5A0UlQOXK4yfr7PwdUXI9FuljoKIiK64ePEiwsLCpA6DmsFkwwyN5yM0pyVzNpoTGBiI4uJi3HPPPbC1tW227vfffw9ra2vs27dPL9tOSkoyqNtcQuHr6wtA0+XY2Pnz580NHTExMRAEAXV1dZg+fbrZ7zNGm2icO3cOy5YtwyOPPNJs/ffffx/z589Hr169sHv37lZdjazTLH27cIrmc8yVXqeZtwBDe2i+fnv91Xqv/AyM7g3sWgx88oem7JkJmsnm72y4Wm9gd83ckdfXAIvXXC2fOADoE6L52loO9A652vZvR/R3Czc3JinJZcD0YThz7hwiIiKkjoaIiAC9IVFkmZhsmGH8+PFm123JnI3m3HfffXj33XfxwgsvGN1t/MyZM7plbLU9KQ17MERRxPz58w3ep+0+LCkpMTgWEREBKysrxMfHQxRFXWKyY8cOpKSkmB27l5cXBg0ahIMHD2LDhg26Va8axnbhwoVmh4gBQFFREeLi4nDu3Dl8+umneOyxx5qt/+GHH2L+/Pno2bMn9uzZAzc3N7NjvqG8db/+6zljrn7d8MY+JUezC/iSmcCiKYBa1KxG9dIPV+d0NGfyIODhUVdf9wvVfACaSecNkw1zY5KSUg1Mi2tRTycREbWtloyUIGkIotiS9TA7nvT0dFRWVgLQ7DKpUqnQu3dvAJobbymeUD711FNYtmwZNm7c2OScjfr6egwZMgQJCQno168fhg8fDjc3N5w/fx7x8fGwsrJCcnIyAM18De0wqqlTp0KlUmHr1q2oqqpCdnY2Ro0ahb/++kt37oCAAFRWVmLu3LkICAiAvb09Hn/8cQDA3XffjU2bNmH48OEYOXIkMjMzsWnTJnh7e+Ps2bMoLy+Hs7NmWdXY2Fjk5OSgqKjIIP6srCwMGjQIJSUlGDt2LPr16wdRFHHmzBndpG1Tq1FFREQgIyMDt9xyi26ye0MjR45E//79AQA//vgjHnroIdjb22PevHm6GLUcHBzwf//3f82216xHP4f4/S4ISvOGpFEn5OcOXFyOjKwso3u6EBFR+1OpVFz+1sJ1+p6NtLQ0g1UEEhISAGgm/FjqcAhra2scOHAAr7/+OtasWYPPP/8cAODu7o7o6Gi9eQtz585FSUkJPv/8c7z//vtwdHREXFwcvvjiC4PJ24BmWNhTTz2Fjz/+GAqFAp6enrpkY+XKlXjggQewa9cuHDx4EKGhofjhhx/w3Xff6W0QaEpYWBiSkpIwf/587Ny5Ezt37oS1tTW8vLwwbNgwzJkzx+Q5tBvx7d27F3v37jU4/u9//1uXbBw6dAiiKKK6uhpvvPGGQV1PT8/rSzboxiaXAfcPBWQyo/+miIhIGklJSYiNjZU6DGpGp+/ZIGoVj34O9YpdkKnYs3HDOvgucHMETpw4wf/YiIgsBP8mWz7us0FEZIq/u2YiPBERWRTt4jZkuZhsEJlJ1sK9OqiTkMuAGcOBKz//1lhtjoiIWoepFTtJekw2iMyk5ojDG5NSDUwdonvZ0g0iiYio7bRkaX6SBpMNIqLmBHoAN4XrXl68eFHCYIiIiDoWJhtEZuID7RuQXAbcP5w/fCIiC2Wpq4rSVUw2iIiaolQD04boFfXo0UOiYIiIqLG8vDypQyATmGwQmYlTNm5AXTyB/mF6RRcuXJAoGCIiaqy8vFzqEMgEJhtERMZY6a9CpVVZWSlRQERE1JiNjY3UIZAJTDaIzMRh+zcYleEQKgCws7OTIBgiIjKGQ1stH5MNIiJjgryBvqEGxeHh4UYqExGRFE6ePCl1CGQCkw0iM3HOxg1ELgNmDDPanXXq1CkJAiIiIuqYmGwQmUlgtnHjUKqBaXFSR0FERCZ4e3tLHQKZwGSDyBw9ukBQM9m4YYT6An1CjB7y8/Nr31iIiKhJjo6OUodAJgiiyMe1RCaJItJ2xiOSmwfdGBxsAW9XqaMgIiITTpw4gdjYWKnDoGbIpQ6AqEMQBNR4OwHBPlJHQkRERNRhcBgVkZnc3NykDoGIiIga4AqBlo/JBpGZvLy8pA6BiIiIGigqKpI6BDKByQaRmTIzM6UOgYiIiBooLS2VOgQygckGEREREXVIcjmnH1s6rkZFZKbS0lLO2yAiIiJqAfZsEJmpqqpK6hCIiIiogZMnT0odApnAviciMxUWFiIwMNCgPLFQREmtBAFRu+vuDgQ4CVKHQUREV3CAjuVjskF0HepVIm75RYXSOqkjofbg76DGpf+zkToMIiK6wtPTU+oQyAQOoyIyU58+fQzKdl8QmWjcQApr2KtBRGRJXFxcpA6BTGCyQWSmlJQUg7I1qSLkvP8kIiKSxJkzZ6QOgUxgskFkJoVCofe6XiVifboIJYeL3jAEJpZEREQtwmSDyEyNu2p3nRdRrmiiMnVKnIdIRGRZQkNDpQ6BTGCyQWQmPz8/vddr0jiEioiISErcQdzyMdkgMlN6erruawWHUBEREUmuuLhY6hDIBCYbRNfgr3MiKjiE6oYjcNIGEZFFkcl4K2vp+BMiMlNQUJDu6zVpIuT813PD4eZRRESWpXfv3lKHQCbwdonITHV1mg01FCoRG9JFKNUSB0RERHSDS0pKkjoEMoHJBpGZ8vPzAQA7zoqorJc4GJIEB1EREVkWlUoldQhkApMNohbiKlQ3MP7ciYgsiru7u9QhkAlyqQMg6ih69eqFOqWIXzM67ipUfo7As/1kuNkfGOAnwNlGwIg1Kuy9YPyCrGXAvJsEPBgtQ4grUFYHJOSLeHy7GhcrTbc3u6eAeTfJ0M0VuFABfHJMjc+ON//N2z5FhrEhMnx2XI2n/7KssWqcskFEZFk8PT2lDoFMYM8GkZkyMjKw/ZyIqg48hCrSQ8CCm2UIdBKQVNh8XbkM+OMeGRYOkmHrWRH/t1ON946oUVUPuNqabuux3gK+vc0KyZdFPP2XGgcuifh0tBXmD2y6e+Du7gIGB7D7gIiIzJOZmSl1CGRCu/dsiKKIpKQkpKSkoLKyEnZ2dggNDcWAAQNgbW1t9nlqa2tx4sQJnD17FlVVVbC2toa7uzsGDBgAf39/vboFBQU4cuQICgoKAAC+vr4YOHAgvLy8DM5bXFyM48ePIz8/HzU1NbC3t4evry9iY2MlyZ5ff/11LF682OgxuVyO//3vfxg/fnybtF1aWop33nkHYWFhuP/+++Hs7Nwm7bSFP//8U/d9efXVV/HGG29c9zlra2uxJkszhKqj9mwczRPh8ZkSJbXA5AgBQwKtmqz7fH8Bt3QVMHS1CkfyGh4xffF2cuDtoTJszlJj6m+a3olvkkTIBODVQTJ8fVKF0jr999haAR+MkGHJYTXeHNp0XFLiyrdEREQt0+7JxoEDB3Dq1CmEhISgd+/eKC0txalTp3D58mVMmDDBrHXsKyoqsHnzZtTX1yMyMhKurq5QKBQoLi5GVVWVXt38/Hxs3rwZDg4O6N+/PwAgOTkZv//+O+666y54eHjo6l6+fBmbNm2Cra0tevToAUdHR5SXlyMlJQVnz57FXXfdZTRBaQ933XUXhg4dqldmZWWFPn36tFmbpaWlWLp0KSZOnIg77rijwyQbVVVVePzxx2Fra6tbQao12Dg4Y2MHHkIFQDOx3YyeGQGa4VYbM0QcyQOsBMDGCqhRmtfOyK4CvBwEfH5CfxjUsuNqPBAtx4RQAT+n6H8j5w8UIBOA9xNEvKn/q24xOIyKiMiyhISESB0CmdCuyUZxcbEu0Rg3bpyu3NnZGfv370dWVhbCw8NNnmf37t1Qq9WYMmUKHBwcmq27f/9+yGQy3HnnnXB0dAQAhIWFYe3atThw4AAmTJigq5ucnAyVSoXbb79drxcjICAAW7ZsQXp6umTJRu/evTFv3jxJ2m4rFRUVsLW1hY2NTaued+HChaiqqsKECRPw66+/ttp5k5VdUG3mzXZHF+0FBDoLSCxU46uxMjwUI8BWLiCxUMSzu9TY08QcD62+PprPCfn69Y7mAyq1iL6++slGV2dgwUAZZm9Vo/YG+R4TEdH1q6yshJubm9RhUDPadc5GVlYWAM1E24aioqIgl8uRkZFh8hy5ubnIy8tDnz594ODgALVaDaXS+N1JWVkZCgsLERoaqks0AMDR0RGhoaG4ePEiqqurdeX19ZpHvo0TGO175XLLnU9fV1eHxYsXo1u3brCxsYGDgwP69u2Lb775BjU1Nbp6arUar732GmJjY+Hu7g65XA5PT0+MGzcOe/bsgVqteRK9Z88edOvWDQCwefNmBAYGQhAEeHl5Yc+ePdizZw8EQcDDDz+MiooKvVgefvhhCIKA33//XVc2YsQIeHl5YdWqVZgwYQKcnZ3h4uKCbdu2AdD8XB9++GH4+PhALpfDzc0No0ePxs6dO3UxmSMhIQGfffYZ7r33XkRERFzz99OY745W3DCrUHV301zo8/1lGNFVwOM71Hj4TxXsrICtk2XoZSLn9ncSoFSLKKzWL69XA5drgQBH/fIPRshwvECz0hcREZG5ioqKpA6BTGjXu+fCwkIIggAfHx/9IK7c8BYWmpixCuD8+fMAACcnJ2zduhUXLlyAKIpwdXVFv3790L17d732AM0cjcZ8fHyQlpaGoqIi3c7QXbp0QVZWFnbv3o0BAwbohlEdPnwYDg4OiI6ONhmfSqXSJS2mCIIAW1szZtoCqK6uRk5Ojl6Zk5MTXFxcoFKpMHbsWBw4cABDhgzB1KlToVQqsXbtWjz55JPIz8/HSy+9BBsbGygUCvz3v/9Fv379MGzYMLi7u+PUqVP4/fffkZycjB9++AGjR49Gjx498NZbb2HRokWIjY3FpEmT4OjoCAcHB/To0QMpKSlmxd1QbW0tnnnmGYSFhWHu3LmoqalBeHg4zp8/j4EDB6KqqgqjR49Gr169cOnSJfzyyy+YMWMGvvrqK0yaNMnk+ZVKJebMmYPo6Gg89thj2LRpU4tjbEpNvYjdhS4WNYRKgGZokznqWrgMudOVziZnG6DvjyrkXMknd51XIfMRK8wfKMPMLU0ngfZyQNFEm7VKzXGtEV0FTI4QcPPPlr9WujnDPImIiOiqdk02qqqqYGdnBysrwzskR0dH5OfnQ6VSGT2uVVZWBgD4+++/4erqihEjRkCtViMxMVE3vCoyMhIAdL0WxoZaaXsrGs7xiIiIQEVFBZKSkvRuVL29vXH33Xfr9Y40JTMzE3v37jVZD9AkC/fff79ZdT/44AN88MEHemX3338/li1bhhUrVuCff/7BvHnz8Nprr8HJyQmAZnJ5dHQ0fvjhB9x6660YMGAAbG1tkZOTAycnJ70bp2+//RaPPPII1q5di8GDB8PX1xczZszAokWL0KVLFzz66KMICAjQ1b+WZKOqqgrDhw/H119/jS5duujK77zzTlRXV+Pjjz/Gww8/DJlM0+H2xBNPYNCgQfj2228xcOBAvfab+h6lpaXhgw8+QO/evVs12dh6VkSd2rIWbxveVcCee83LNqK+UyKt2Pxza+dmxF8SdYkGoFm+dt9FEUNMrBhVo2w6EbKTXz2/lQB8MkqGH0+LSMgzXt+SiJy0QURkUWJjY6UOgUxo17snpVKpu5FsTJtgNDUkSkvba2BtbY2JEyeie/fuiIyMxJ133gkbGxscPnxYd0OgPZex5MVYe4IgwMHBAb6+voiLi8O4cePQv39/lJaWYvv27VAoFCavsWvXrhg/frxZH6NGjTJ5Pq0ZM2Zg1apVeh/PPfccnJyc8OOPP8LPzw9Dhw5FaWkpcnJykJOTg/LycowZMwaZmZnIzs7WXaOzszMEQYBKpcLly5eRk5ODuLg4AEB2drZZPUzX6r777tNLNMrKyvDHH3+gd+/eiI6OxqVLl3Tx+/n5ITQ0FKdPnzbo1WksKysLr7/+Om6//XZMnjy5yd8zcxUXF+tNLt+ZrYCVYFk3mqmXRTz8p8qsj1wz9sRo6FKl5lrzqwyPFVQD7nbNvz+3UoRcJsC7UZ5vLQM87YBLV877YIyASA/gq5NqBLtA9wFoelWCXfR7QaSn/zuQm5vb7Ou8vDy9BKXx71VlZaXeMESFQoHLly+zDbbBNtgG2zCzjYSEBEmug8zXrv+Ny+Vy1NbWGj2m3W7e1LwIbZIQHh6ul0TY2toiODgYGRkZKC0t1c1HaHhuU+0dOXIEycnJmDZtmq43JCQkBD4+Pvjzzz9x8uRJ3HTTTc3G5+DgYHLS+rUIDQ3F9OnTjR5LTU1FTU1Ns0ONtMv+AsAvv/yCt956C6mpqQbfm+rq6lZdwakhZ2dng96JtLQ0qNVqxMfHY/DgwUbf5+XlpTfvxJjHHnsMnp6eePrpp+Hn53fdsTZcpQwAbg2zwedJlrXBXH41sDK5bRKgpEJAoRIR6GTYgxHgKBjMxWjsxJV8dYCvgD/PXI1xgB9gJRNwokDzvQxyEWBjJWD//Yb/7h+KkeGhGBkmbVLhf5mWkegJjbYQb7zMduPXjX8XG/9eaXshtWxsbAyW2GYbbINtsA220fQ5G983SnEd1Lx2TTYcHR1RWlpqdKhUc0OsGp8DAOzt7Q2OaW/ytTfL2tcNJ4E3bK/h+bRDsQIDAw2Sha5du8La2togszVGqVSa1QMCaHoZjF1HS4miiMDAQDz77LN6vQYNaW/kf/31V0yfPh0hISF48sknER0dDWdnZ6jVasycOROiKJo1VKS5setN9U7Z2NgY/FHQtnXzzTdj1qxZcHFxMXifnZ0devfu3WR7GzduxK5duzBr1iw4Ojri+PHjAK4+idDunRIWFmb0/OYYFyLA3kqNGpVlDaVqK5X1wJZsERPDND0P2iFYUR7AkEDgq5NXf0fs5UCQC1BUA1y+khPuOi/ico2IJ2L1k40n+shQVS/ij2xN2S+papwoMPx92zTJCn9kq7E8UcShXMtINAAAnLJBRGRRXF1dpQ6BTGjXZMPb2xs5OTkoKCjQyxKVSiUuX75skDka4+Pjg5SUFIP9NICrCYT2Bt7b2xuAZq+NqKgovbraJ/3apWxra2uhUqmM3mhrb8DNWRUpKyurTeZsNEc7ybpPnz56Swob8+OPP8La2hpLly7FlClTdOWpqakGdZtLKLRPCqqqqlBXV6e3B4d21TFzYxcEAUqlEsOGDTNrEn5j586dAwCsWLECK1asMDi+bNkyLFu2DN988w3mzJnT4vMDgJ1cwN3dBaxNB5SW1cHRYgsHaX6uMZ6azzOjBQwN1Bx7++DV3/9X9qkxOtgKu6ZZ4ZNjmot+pp8MxbXAO4eufhMG+mvmjry+X43F+zXltUrg1Xg1Ph9jhbV3ANvOihjWRcDMGBle+UeFkisdnGnFQFqx8WTiTBkspkdDi1M2iIgsi7FFgMiytGuyERYWhuPHjyMpKUkvsUhNTYVSqTTYY6O8vBxqtVpv/eSQkBDs378fmZmZ6Nevn27X8erqapw9exaurq66LNfV1RXe3t7Izs7WrS4FaG6Qs7Oz9Xox7O3tYWtri9zcXJSXl+s9Ac/OzoZSqdQlL83RztkwR2stpfvQQw/hpZdewvLly9GnTx+Df3h5eXlwdXWFvb09rKysdPM1tERRNLrDtrarUZtQNNStWzfI5XKkpqYiJydHl7Tt378fhw4dMjt2T09P3H777di2bRvWrVuHf/3rX7CzuzohQBRF5OXlwdPTs8n9OCZOnAgnJyeDGLds2YItW7Zg8uTJGDlyJEaOHGl2XMYMd8nHKnXH7zp9q9Hu3HN6Xe2tefvg1V6plMvALb+osGS4DIsGyaAWNT0WL+1V45IZc0C+OCGiXqXCiwNkuDNMwIUK4LldKnx8jHfsRETUOtLT0zlJ3MK1a7Lh4eGBmJgYJCcnY/v27QgKCkJJSQlOnToFf39/g2Rj8+bNqKysxGOPPaYrs7W1xaBBg/DPP/9g06ZNiIyMhFqtxunTp6FWq3UTnbUGDx6MzZs347fffkPPnj0BAKdOnYIoihg0aJCuniAI6N+/P/bv349NmzYhOjoajo6OuHz5MlJTU2FnZ2fWbt1tNWejOc8++yy2bt2K9evXIzU1FUOHDoWvry8uXbqE/fv3QxRFrFy5EgMGDMCUKVOwYcMGLFiwAP/88w+cnJywY8cOlJaWGpzX09MTYWFhSEhIwJtvvomYmBg4OTnh7rvvho+PDx566CF8++23ePzxxzFy5Ejk5+djw4YNCAoK0vU2mOPLL7/E4MGD8eabb2LXrl0YOHAgbGxscO7cOd3rzz//vMnVqMLDw41uBllYWIgtW7YgOjoaTz75pNnxNKWv02U4WftpduHuwIT3zd8173gBMG598105ey+ITZ7zmyQR3yS1fEnblsTYnrjyLRERUcu0+zovgwcPhrOzM1JSUnD+/HnY2dmhZ8+eGDBggNlr2Pfo0QN2dnY4efIkEhISdHt3jBo1ymDSjp+fH+644w4cOXIER44cgSAI8PX1xdixYw0mBPXs2RMODg5ITk5GUlISlEol7O3tERYWhv79+xtMKrIU1tbW2Lp1Kz7++GN8++23WLFiBURRhJubGyIiInDPPfcgLCwMgGY1qNLSUixZsgRff/01HBwc0L9/f3z44YcYMWKEwblXrVqFuXPnYtWqVairq4OnpyciIyPh4+OD//73v1AoFNi0aRNOnDiB4OBgvPnmmzhy5EiLko2uXbvixIkTWLx4MTZu3IgDBw7o9l7p378/HnjgAYMJXlJwd3bAPRECVqWIHX4oFV0jdsoQEVkU7V5pZLkEkQvHE5lFoVBgZ44cE35lpnGjkgsi6l+0ljoMIiK64tKlSyb34SJp3RhL6xC1gtOnT2NMsABn3msSERFZhIZL+5NlYrJB1AI2VgLuiRAg59j9G5K5Qz2JiIhIg8kGkZm03bT3RgpQcvDhDYmjTomILEuvXr2kDoFMYLJBZCbtU+3RwQJcjK/CS0RERO0oPT1d6hDIBCYbRGa6ePEiAM1QqskcSnVD4o+ciMiyNN5jiywPkw2ia8ChVDcoZhtERBbF2dlZ6hDIBCYbRGbq0aOH7utRQRxKdSPilA0iIssSGBgodQhkApMNIjNduHBB97W1lYCpkRxKRUREJKXU1FSpQyATmGwQmamyslLvNYdS3Xi48i0REVHLMNkgMpOdnZ3e65FBAlxtJQqGpMHkkojIonTp0kXqEMgEJhtEZgoPD9d7LZcJmMahVDcU5hpERJZFqVRKHQKZwGSDyEynTp0yKONQKiIiIunk5eVJHQKZwGSD6Drc0lWAh53petQ5BDqzG4uIiKglBFHkYo5E5sjLy4Ofn59BeeplEWUKCQKidld7KRW39O9huiIREbULpVIJuVwudRjUDP50iMxkLNEAgChPPu2+UZzI5061RESWJCsrC5GRkVKHQc3gMCoiIjO5ublJHQIRETVQU1MjdQhkApMNIiIzeXl5SR0CERE14OjoKHUIZAKTDSIiM2VmZkodAhERNRAUFCR1CGQCkw0iIiIi6pBSUlKkDoFMYLJBRGSmkJAQqUMgIiLqUJhsEBGZqaqqSuoQiIiogYCAAKlDIBO49C0RkZkKCwsRGBhoWF4t4jIXROm0Qt0AGysucU1EdC2YbBARXaf7/1Bh5zmpo6C28lCMgO9vt5I6DCIy4tKlS/Dx8ZE6DGoGh1EREZmpT58+BmWXa0TsOi9BMNRuThcopA6BiKjDYrJBRGQmY6uebMwQIYoSBEPtRqFgskFkqXr06CF1CGQCkw0iIjMZu+lcnaqGwOH8nZq9vYPUIRBRE86fZ9eypWOyQURkJhcXF73XhdUi9lwA1OzZ6NQUijqpQyCiJnCVQMvHZIOIyEx+fn56rzdmiEw0bgAqlUrqEIioCfb29lKHQCYw2SAiMlN6erre69Wpasg4hKrTk8n4XyWRpQoLC5M6BDKBf0GJiK5BQZWIvRxCdUPgk1Miy3Xq1CmpQyATmGwQEZkpKChI9/WvGcwybhQcE05EdO2YbBARmamu7upEYa5CRUQkvcZz6cjyMNkgIjJTfn6+5nOViH9yOITqRmFtbS11CETUBLlcLnUIZAKTDSKiFuIQqhsLJ4gTWa6cnBypQyAT+BeUiMhMvXr1AgCsTlFLHAm1p4bD54iIqGXY90REZKaMjAy4dY3EvotAR+vb8HMEnu0nw83+wAA/Ac42AkasUWHvBcMr2X2vFUZ0NZyQsvWMGrdvMC/R8nEA3oiTYWKoAE97IK8K+Ou8iEe2XX3/3d0F3Bsp4CY/AX6OwIUKYHO2iDcPqFHG+3siMkNUVJTUIZAJTDaIiMxUW1uLDekdLc3QiPQQsOBmGdKLRSQVAkMCm69/oVzEy//oJxaXKs1rq4szED/dCgDw5Uk1LlYCAU7AQD/9BObrsTJcqgJ+ShFxvlxELy8BT8UKGN/NCv1+VKFWafbltSkufUtkuS5evMi9Nixcp082RFFEUlISUlJSUFlZCTs7O4SGhmLAgAGSTfp77LHHsHz5cqPH5HI56uvr26zt/Px8vPrqqxg3bhymTJnSZu20hiNHjuCjjz5CcnIyMjIyUFNTg0cffRRff/210foqlQoLFizAqlWrUFBQABcXF4wbNw5ffPEF3Nzc2jd46pScnZ2x+pAaAjpez8bRPBEenylRUgtMjhAwJNCq2fplCuDnlGu7yq/GyqBUAzf9pEJxbcMj+ueb8ru6Uc+KiKP5An4Yb4UZPQR8m2QZ32XN32QbqcMgIiMqKiqkDoFM6PTJxoEDB3Dq1CmEhISgd+/eKC0txalTp3D58mVMmDABgoRrV86dO9cgG7eyav4G4HoVFhbqEh1LTzZ27tyJX375Bb6+vujevTsSExObrT99+nSsW7cOcXFxePzxx3H69GmsXbsWp0+fxrFjx9r8e0udn+AaiP2XOl6iAQCV9QBa+BzDSgDs5EBVC94X6QGMD5XhiR2aRMPWClCJgNLI6CtjQ7g2Xpl838PTclI6pdJCuliIyICtra3UIZAJnTrZKC4u1iUa48aN05U7Oztj//79yMrKQnh4uGTx3XPPPRg7dqxk7beFy5cvw9PTs1XO9dBDD2H27Nnw9fXFjh079H6Gje3fvx/r169HXFwc9u3bpyvv1q0b3n33XXz88cd44YUXWiUuunF9tb8AQIDUYbSLCHeg6lkr2MoF5FWJWJ4o4o0DaqNJQ0NjgjUPcPKrgZ1TZRgdLINSLWLHORFP7FDjXHnz7/dz1HwuqraMRAOApA+liKh5ERERUodAJnTq1aiysrIAXF1BRisqKgpyuRwZGRlShGW26upqPPXUU+jatSusra3h4OCAm2++Gbt27dKrp1Kp8OSTTyImJgZubm6Qy+Xw8vLCpEmTcPHiRV299evX674Xy5cvhyAIEAQB3t7euuOCIOA///mPQSy33XabwX+4vXr1gre3N06ePIlhw4bByckJXl5euuNZWVmYNGkSvLy8IJfL4e7ujjvuuAPnzp0z6/oDAgLg6+trVt1vvvkGoihi3rx5euULFy6EjY0NVq9ebdZ5iJqzNd9N6hDaRVapiLcPqjH9DzVmblHhUK6IVwfL8NN40/9ldHfT/J34eqwMCjUw7XcVFvytxtBAATunWsHexCOufw3UJCfrLWhujIODg9QhEFETkpKSpA6BTOjUPRuFhYUQBAE+Pj565XK5HJ6enigsLDR5DlEUW7Tsoa2trdlPwYqLiw3Wh3Zzc4OTkxPq6uowaNAgpKSkYNy4cZg1axZKS0uxZs0a3H777di8ebOuV6SmpgYrVqzAyJEjcdttt8HJyQkJCQnYvHkzjh07hrS0NNjb26N///546aWXsHTpUsTFxWHSpEkAABcXF7Ovr7Ha2lqMGjUKvXv3xgsvvKDb9CwlJQVxcXFQKpWYNGkSwsPDkZGRgfXr12PQoEFITEzUJTmt4eTJkxAEwaD3w8nJCaGhoUhLS2u1tujGdLFCRGKZZdx0CgBszBwVWKdq+fkbrhgFAD+dFvHVWOCxPjJ8dFSNQ7lNv9fpytSGvGpgwga1biBUToUav9xhhfubmYsxPUrAI71lWHJYjczSlsfdVqqqqgC4Sh0GEVGH1KmTjaqqKtjZ2Rkdq+/o6Ij8/HyoVKpmx/JXVla26Kn49OnT4ezsbFbd++67z6Ds3//+NxYvXoxFixYhKSkJP/74Ix544AG941FRUXjhhRd02byDgwPy8/MN2n3rrbfw6quvYvny5XjmmWfQrVs3PPjgg1i6dCmio6MNegGuRWVlJWbNmoXvvvtOr3z27NlQKpU4cuQIIiMjdeUPPvggbrvtNixcuLDJid7XorCwEM7OzkafQPr4+CA1NRU1NTVcVYau2Y5zlvOkfXhXAXvuNS/biPpOibTi62/zgwQ1Husjw5hgAYdym/5e1FyZ3rA2Ta0342JduogfVSKGBBhPNoYGAt/eKsPWM2os/If7mBCReRo/UCbL06mHUSmVyiZ3ftUmGKYm/tnb22P8+PFmf7TkZnbRokVYtWqV3oc2sfj1118REBCAESNGICcnR/dRW1uLm2++GadPn9atwCCTyXSJRn19PfLz85GTk4M777wTgGaSfFtqPOyqsLAQhw4dwrBhw+Do6KgXf48ePeDn54e///67VWOoq6trcnUx7eSx8nITg8UbKC4u1uvRqqys1FvxQqFQ4PLly3rvyc3NbfZ1Xl4eRPHqTRbb6Fht9Pe2nEnCqZdFPPynyqyPXDOXqzXlwpVvhYdd8z23lyo139P8Kv1ytQhcrgXc7Qzf09sb+O1uK5y6DEz5TQ2V5eR1AKD3t6Uj/u6yDbbRmduorq6W5DrIfJ26Z0Mul6O2ttboMZVKpatj6hxdunRp9dgAYPjw4U1OEM/JyYFCoUDXrl2bfP/Fixd1m9l88skn+Oyzz5Cdna27Nq3S0tJWi7kxZ2dng3kVR48ehSiK2LJlS5Pxt/aTCFtbW5SVlRk9pv0j05LhYh4eHnqvnZyc9F7b2NgYTIT39/dv9rWfnx/b6MBt9PK1QahjJbKrjNwtt7P8amBlcvvekYe6aT4Xmpi4fVQzkhKBzvqrSVnLAC97oFD/vgChrsDWyVYoqAbGb1C1aOWr9iJr0PvdEX932Qbb6MxtVFbqP1GR4jqoeZ062XB0dERpaanRoVLNDbFqSK1WN5mwGGNnZ9dkb0pLiKKIoKAgvPvuu03W0SZBX3zxBZ599ll0794dr7zyCkJCQmBvbw+VSoWZM2fqZfjNaW6uSVM9QMaWnNO2N2bMGMyePdvo+xwdHc2KyVze3t7IyclBdXW1wVCqgoICODs7cwgVXbeHe9ti8UFY3JP31uRso5nnoWg012PRIM3ftW1nr168vRwIcgGKaoDLNZqyPRdE5FeJmNFDwDsHr84ZebinALlMwI5zV4dI+ToA26daQS0Ct65XoaimTS/tmtXV1gLg8ppERNeiUycb2hvQgoICvaxUqVTi8uXLBpmqMVVVVW02Z6M5/v7+KCsrw7Rp00wmRD/99BOsra2RkJCg9/T+8OHDBnWbSyi0PRSNuxMBGExkb07v3r0hCALq6+sxffp0s993Pfr06YNjx45h+/btuonvgOaJR3Z2tsGKZETX4mb7C1CJQVKHcc0WDtL8+4/x1HyeGS1g6JWdxN8+qEki+vkKWD1BhtWpIjJLRdjLgbvDZRjaRcBXJ9U4XnD1fAP9NXNHXt+vxuL9miRCoQJe2qvGD+Ot8Pd9VvjxtBpBLgKe7Sfg7wsifs24mqxsnWKFMDcBSw5rVqsa2mBX8/xqYKcFzZMhIsvEpW8tX6dONsLCwnD8+HEkJSXpJRapqalQKpVm7bGhnbNhrtZ6ej558mR89NFHeOmll/Dhhx8aHD9z5gy6desGQDNnQxAEveFTarUar7zyisH7tDtpl5SUGByLiYmBTCbD3r179cp///13pKenmx17YGAgbrrpJvzzzz/YsmWLwfdPrVYjJycHQUGtd9M2e/ZsfP/993j//ff1ko23334bCoXC6GR8opbykZWjlxeQVCR1JNfmraH6Dy7m9LraC/v2QU3v5blyEf9cFHF3dwF+DgLUAFIuA49vV+HrRPNu/n88LUKhUmHBzTIsvUWG0jrgq5MiXvlHDXWDU8T6aJKefw007A3ec0HEznPXsJRWG7CzY68okaXKz8/X3Q+RZRJEc8fYdFDx8fFITk5GSEgIgoKCUFJSglOnTsHPzw8TJ06UZLOmxx57DMuXL8f27dubnLNRV1eHIUOG4NixYxgwYACGDRsGV1dXnDt3DvHx8bC1tdXtqP3f//4Xzz//PMLDwzF16lTU19fjzz//RG1tLbKysnDrrbdi69atunP7+/ujqqoKTzzxBPz9/eHs7Iw5c+YAACZOnIg//vgDI0eOxPDhw5Geno7ffvsN3t7eOHv2rN6QrF69eiEvL8/oEsKpqakYOnQoSktLceutt6Jv375QqVTIzs7G7t27MWnSJJOrURUWFuK1114DoJmctWnTJvTu3RtxcXEANKt5DR8+XFd/ypQp2LBhA+Li4nDrrbfqdhCPjo7GiRMnuIM4XbeMjAxsKA7Dwn36N83UufX3rEPCrNYd+klErePEiROIjY2VOgxqRqfu2QCAwYMHw9nZGSkpKTh//jzs7OzQs2dPDBgwwKJ3hbW1tcWBAwfw2muvYd26dVi2bBkAzUSnmJgYzJo1S1f3ueeeQ3l5Ob7++mssXboUjo6OGDZsGL766isEBgYanHvFihV4/vnn8d///hcKhQJeXl66ZEO71O7evXsRHx+P8PBwrF69GsuWLcPZs2fNjj8qKgonTpzAv/71L+zatQvbt2+HtbU1vLy8MGLECL34m5Kfn48vvvhCrywxMVGXZHXt2lUv2Vi9ejUWLFiA1atX44033oCzszOmTp2KL774gokGtYrg4GBM9Rbw8j9SR0LtydSqhUQknaZWoiTL0el7NoiIWov2CVrsSiVOmt4TlDqJWLdqHH/k2jc/JSK6kXXqfTaIiNrC/T1kkFluxyi1MmObhRKRZThx4oTUIZAJTDaIiMwUEBAAAJgaIXDOxg2kuqradCUiIjKKyQYRkZm087y6uQno27r7UpIFE8HMkshSeXl5SR0CmcBkg4jITBcvXtR9zaFUNw65vNOvpULUYTXeEZwsD5MNIqJrwKFUNw4mG0SWqyUrZZI0mGwQEZmpR48euq+DXQX09wXYudH51dbWSh0CEVGHxWSDiMhMFy5c0Ht9fw8Zkw0iIgmFh4dLHQKZwGSDiMhMlZWVeq+nRAhQSxQLtR87OzupQyCiJly+fFnqEMgEJhtERGZqfNMZ5CJgAIdSdXoqpUrqEIioCSUlJVKHQCYw2SAiMpOx7noOper86pX1UodARE2wsrKSOgQygckGEZGZTp06ZVDGoVRERNLp1auX1CGQCUw2iIiuQ1cXAQP9pI6C2lKwl6PUIRBRExITE6UOgUzg4uFERGby8zOeVXx3mxWySrnpRmflWZEKIFrqMIjICLWafcuWjskGEZGZmko2YrwExHhx5kZndeKEQuoQiKgJHh4eUodAJnAYFRERUTPc3NykDoGImsB/n5aPyQYREVEzvLy8pA6BiJqQnZ0tdQhkApMNIiKiZmRmZkodAhFRh8Vkg4iIiIg6pG7dukkdApnAZIOIiKgZISEhUodARE0oLy+XOgQygckGERFRM6qqqqQOgYiacPnyZalDIBO49C0REbWNqlpAoZQ6CvPIBMDV+OZ9hYWFCAwMbOeAiMgcgsBlxy0dkw0iImp9mblA3xeBylqpIzGPjRwo/B5wcZA6EiJqgT59+kgdApnAYVRERNT6zuR3nEQD0PTA/H7E6CHezBBZrlOnTkkdApnAZIOIiMhKBvwSb/RQSkpKOwdDROZSKjvIUM0bGJMNIiIilRrYehwoM5wMrlAoJAiIiMzBHcQtH5MNIiIiAFCqgN8Mh1K5uLhIEAwRmcPLy0vqEMgEJhtERETAlaFU+wyK/fz8JAiGiMyRmZkpdQhkApMNIiIiQDOUavsJoFR/KFV6ero08RARdQJMNoiIiLSUauB/h6WOgojMFBISInUIZAKTDSIiIi0jQ6mCgoIkCoaITKmqMlzUgSwLkw0iIiItlRrYeRIoqdQV1dXVSRgQETWnsLBQ6hDIBCYbREREDTUaSpWfny9hMEREHRuTDSIiooZkArDacFUqIrI8ffr0kToEMoHJBhERUUNqEfgrESiuAAD06tVL4oCIqCkpKSlSh0AmyKUOgIiIqEmjewOvTAb6hwIyGZB+CXhvE7A2vvn33RQOPDwKuLk70DsYsJYDwj1N1/dxBd6YDkzsD3g6A3mlQFEF4OGMjIwMREVFteZVEVErUSgUUodAJjDZICIiy/TwKODb/wN2nARe+VkzeTsyEOhqxo7B4/sDj4wGEs8B2fma9zWliycQ/47m6y+3AxcvA4GewPh+AIDa2tpWuBgiagsuLi5Sh0AmtGuycfz4cRQVFaGoqAgVFRVwcnLC/fffb/b709LSsHfv3mbrzJgxA46OjgCAVatWobKyssm6UVFRGD58uO61Wq1GSkoK0tLSUF5eDgBwdnZGREQEoqOjYWVlZXasreXSpUt4/PHHsXnzZqPHbW1t2/Q/wvj4eKxevRpTpkzBiBEj2qyd1lBbW4tff/0Vy5Yt0/0M3dzcMGjQILz55psc10lkSXa/AZwtAGZ9Zvx4sDew7FHg0y3Ac9+1/PxfbAWWbARqFcCnjzSfbHw1F1CqgJvmA8UN/s94Zz1Q8D2cnZ1b3j4RtQs/Pz+pQyAT2jXZOHLkCGxtbeHl5XVN3V7+/v4YOXKkQXl1dTUOHToET09PXaIBAEOGDEF9fb1B/eTkZBQUFBisnb5nzx5kZmaiW7duiIqKglqtxvnz53HgwAHk5+djzJgxLY65NT377LPo0qWLXpm3t3ebtpmQkIBly5bBy8vLopMNpVKJTz75BK+++ipcXFwwffp0eHh4IDExETt27MC2bdtw8OBB9O3bV+pQicgcc2/V7Hnx7180rx3tgKoWPFgpKDOvXmSgphfkia80iYattaYHRakCRBHYeBCBDwxrefxE1C7S09MRGxsrdRjUjHZNNu677z5dd9e6deuMJgLNcXFxMdpddvz4cQAwGFNrbFdJpVKJ+Ph4ODg46CUbVVVVyMzMREhICMaOHasrj4mJwe+//47s7GzU1dXB1ta2RTG3pgceeAADBgyQrP3WplarUVZWBnd39+s+19mzZ7F582YoFArs3LlT14tRV1eHhQsX4oMPPsDKlSuZbBB1FGN6A6kXNUOZlj6kGepUXAEs2wq89osmEWitdgAgvxTY+bpmjohSpRm69eTXwOp9SB3gzZsZIqJr1K6rUbXFuDpRFJGWlgYrKyuEh4ebrJ+dnQ2FQoGIiAjIZFcvX5v4ODg46NUXBAEODg4QBEGSYVQtcfr0aTzwwAMIDAyEtbU1HB0dMXr0aF0yppWRkYGHHnoIUVFRcHV1hVwuh4+PD2bNmoXLly/r6r344ot47rnnAACLFy+GIAgQBAHBwcG644Ig4Pvvv9c7f1paGoYMGQJBEHRlCQkJiIyMRFBQENavX4+BAwfC2dkZHh4eAACVSoXt27dj3Lhx8PT0hFwuh6enJx588EEUFBSYvHaFQqEbThYQEKArt7GxgZeXZnx3w14vIrJw3f2Brp7AiqeA7/4CJr8H/HkceHUq8Lb5w2/NagcAvn4CUCiBae8DC34ChvYAtr8GHEqHVTF3KCayVI1HqZDl6fATxHNzc1FeXo7w8HCzeh3S0tIAAJGRkXrl2l6TtLQ0eHl5ITAwEKIo4uzZszhz5gxiY2Mhl5v+dtXV1UE084mbtbV1ixKYwsJC5OTk6F7LZDJ4eHjAzs4OBw4cwMMPP4zs7GzccccdiImJwfnz57FlyxYMGTIE//zzj65X5OTJk9iwYQPGjBmDu+66C4IgYP/+/fjxxx9x+PBhHD9+HDY2NpgyZQry8vKwatUqjB07FuPGjQNgvMfIXKWlpZg7dy4GDBiA559/HiqVCmq1GitXrsSLL74IURQxZcoUBAQE4MSJE1i3bh327duH48ePw9XVtcnzBgYGIiYmBkeOHMHUqVPx2muvwdvbG7t27cI333wDHx8fzJ0795rjJqLrILcCXPUf5MBarhmy5NloPkRxpabXwskOsLIC/vUj8N5GzbFfDwIeTsCzE4F3NgCVrTBfzclO8zmvFJjw9tUek5wi4JcXgfuGIeREPjDq+psiotZXV1cndQhkQodPNlJTUwEYDqEypqysDLm5ufD39ze4cZXJZLj11luxZ88e/P3333rlcXFxiI6ONiueDRs2NDspvaFbbrnFIOlpzvjx4w3KvvjiC0yZMgUfffQR0tPTsXXrVtx6662647/++iseffRRvPjii7rJ9XfeeScKCwthb2+vq1dSUoLnnnsOP/zwAzZt2oRp06Zh8ODBOHz4MFatWoUhQ4Zg3rx5ZsfalIqKCrzyyit4++23dWWJiYn45JNPYGVlhRMnTujmpSgUCixZsgSvv/46PvroI7z++utNntfV1RWvvvoqysrKsGXLFowadfXOoG/fvvj777/1ejyIqB3FRQF73jRePr3RfIiQx4FzhUCNAnCyB1b/o3989T7g9n5A31Dgn9PXH1vNlfmDa+P1h2atOwD8qATiImGz+m/ghWaWzSUiyeTn58Pf31/qMKgZHXpTv7q6Opw5cwYuLi5m3UhqezWaSkysrKzg4uKC6OhojBkzBiNGjICfnx/i4+ORnp5uVkyjRo3C+PHjzfro2rWr+RcL4K233sKqVat0Hxs2bMAdd9yBjIwMHDp0CBEREYiJiUFOTo7uw9/fHz169EB8fDxqamoAaIYW2dvbQxRF1NTUIC8vD1VVVRg4cCAA4NChQy2Kq6VeeuklvdcnT55EYmIi7rjjDgDQxV5QUIDevXvD29sb27ZtM3leW1tbBAQEoF+/fnjjjTfwySefYPLkyUhJScGECRNQVmbmhFEAxcXFek9LKisrUVFRoXutUCj0hpwBml625l7n5eXp9XqxDbbRmdsoL7/6GifPAmNe1/84eRbYdtywPK9U855LJZrP+aV6segmfru30rBIXTuN/j6o1cDlCojuTigJcdMVd9SfB9tgG521jcY9G+11HWS+Dt2zkZmZCZVKZVavhlqtRnp6OmxsbNCtWzeD49XV1di4cSOioqJw880368q7d++O//3vf4iPj0dwcLDJoVptuQTbrbfeanSCeGJiInJzc1FfX99sAlNUVISuXbuiqKgIH374IX755RecP38eKpVKr15JSUmrx67l5eUFNzc3vbLU1FSIoojvv//eYP6HVuO5NI1duHABc+fOxb59+5CWlqb7OcyZMwevvvoqPvzwQyxduhRvvfWWWXFq55JoOTk56b22sbGBp6enXlnjJyuNXzf+3WAbbKMzt2Hj0mB4VGmVZkfuhkoqgdwSw3Kto1lARIBmv4sz+VfLA64sKFFYbvx9LXU0S/M5UP+aYC0HvFwgFJShdFwMtN+BjvrzYBtso7O20fi+SIrroOZ16GQjLS0NgiAgIiLCZN0LFy6guroa0dHRRudepKSkoK6uDqGhoXrlgiAgNDQUBw8eRFFREQIDm1mrHUBNTY3ZczZsbGzMmgdirqioKPz73/82eszZ2Rne3t6orKzE66+/jmXLlqFnz554/fXX0aVLF9ja2uLUqVN45513oFarzWqv4QTwhkRRNEhgtJpLGu655x5MmTLF6DFTPVdHjx7F9u3bcdttt+n9EXBwcMDYsWPx+eefY8+ePc2eg4gsyJp4zRCrOaOBRas0ZYIAzBoFXK64miQAQKiv5nN2vuF5TNlzStN7MmO4Zh5I3ZVVEh8eqZlrknQeYR88eF2XQkRtJyMjw6yHziSdDptsaDcHDA4ONvnUGzA9t6OqSrPaiLFEQXvzbc5N+MaNG9tszkZTXFxc4OPjg5KSEtx77716q2w1lpSUhPj4eNjZ2eHQoUN637slS5YY1G8qoQCg66EoLi7WKy8vL0dRUZHZ8YeHh0MQBMjlckyfPt3s9zWUl5cHpVJpNMlRq9VQq9VQKpXXdG4iksD/DgM7TwIv3wN4uWiGXU0aCAyLBh77QrNylNZfizWfuzVYBCLIG5h5i+brAVdWKlx45WHGuULgpysbxCqUwEs/AD88A/z9FvDjXiDIC3h2gmZOiJczzpw9a9ZDLSJqf225sTG1DotNNiorK6FUKuHi4mL05rklE8Orq6tx/vx5eHl56ZZBbUy710N6ejp8fHx05Wq1GpmZmRAEocn3NjRq1Cizb2obd+1dq+7du2PQoEHYsGEDPvjgA4M5EdXV1aioqICvry8EQdB9PxsmT6dPn8avv/5qcG5td2PjhAIAwsLCYGVlhR07duCFF14AoBk7uXnzZpw5c8bs+Pv164eePXvi119/xcGDBzFo0CC941VVVaiurm52A8OQkBA4Ojpi7969OHPmjG6oXHl5OX777TcoFArdnBQi6iAmLQHeuh+4N07T05B2EZjxX2DV3ybfim4+mvc2pH2959TVZAMAftwDKOqBBfcASx/UDPv6agfwyk/AwXdRXW3494+ILIOzs7PpSiSpdk020tPTdU/9a2troVKpcOzYMQCam9qGT452796N3NxcTJ8+3eAXSalUIjMzEw4ODmZNsk5PT4cois0mJpGRkTh16hROnz6NyspKdO3aFUqlEhkZGSguLkbv3r31Vm9qihTj+Hx8fPDSSy8hJSUF8+fPx6ZNmxAXFwcbGxtkZWXh8OHDCAoKwu7duxEUFIQBAwbg2LFjGDRoEO666y6UlJRg165dRjdZDA8Ph4+PD3766Se4uLjAy8sLwcHBuPvuuzFgwAAMHjwYW7duxfjx49G3b1+cOHECf//9NwIDA/WW6W1Or1698OKLL+KFF17AsGHDdEv31tTUID09HYcPH8bcuXObXY2qX79+uOuuu7Bq1Sr069cP06dPh5ubGw4dOoS9e/fCw8OjVVbTIqJWMtL4kE89VbXA899pPprTsEdDa28yILRgBak18ZqPhiIDgJggOGZwaU0iS2VqeDtJr12TjbS0NIMZ/QkJCQA0k2/M7aY+e/YsFAoFoqOjmx0y1LBdU5v+2djYYNKkSTh69CguXLiAnJwcyGQyuLu7Y9iwYRY/HvDmm2/G77//jvfeew/bt2/Hxx9/DEEQ4Onpib59++KZZ54BoBly9frrr0Mul2Pjxo1477334OzsjDvuuAO33norZsyYoXfem266CQsXLsSnn36KpUuXQqFQICgoCHfffTe6d++O9957D6+88gr+/vtv/PXXX+jVqxe+/vprfPrpp2YnGzKZDDNnzkRoaCg++OAD7N+/H7///jtsbGzg6+uLCRMmYNq0ac2ew8fHBx9//DHCwsKwbt06rFixAvX19XB1dcWkSZOwdOlSbvxDROazkgH3DwcA3UamRGR5UlNTERsbK3UY1AxBNHc2MxERkbl2nADGvSF1FNfn9CdAjy44ceIEb2aILBT/fVq+Dr3PBhERUZvoEQj06CJ1FERkgnYjYLJcTDaIiIgaspLp7WxuzqaxRCSNppbaJ8vBZIOIiKghlRqYOkT3srklwIlIWo3nApPlYbJBRETUUHQXIOrq0IyLFy9KGAwRUcfGZIOIiEhLdnUVKiKyfDExMVKHQCYw2SAiItJS6w+hAoAePXpIFAwRmdKSTYRJGkw2iIiItHoGARH6E8IvXLggUTBEZEp1dbXUIZAJTDaIiIgAQCYA9w8zKK6srJQgGCIyh6Ojo9QhkAlMNoiIiABALRoMoQIAOzs7CYIhInMEBwdLHQKZwGSDiIgIAHoHA+H+BsXh4eESBENE5jh9+rTUIZAJTDaIiIiaGEIFAKdOnWrnYIiIOg8mG0RE1PocO9jQoyaGUBGRZQsICDBdiSQllzoAIiLqhIZE4dwn9yPYzlXqSMzjYAOE+hk95OdnvJyIpCcIgtQhkAlMNoiIqE2UDAtHcGys1GFcNyYbRJbr4sWL8Pb2ljoMagaHURERUZtwc3OTOgQiIpKYIIqiKHUQRETU+VRWVsLJyUnqMIioE6urq4Otra3UYVAz2LNBRERtIjMzU+oQiKiTu3DhgtQhkAlMNoiIiIioQ6qsrJQ6BDKByQYREbWJkJAQqUMgok7Ozq6DLbN9A2KyQUREbaKqqkrqEIiokwsPD5c6BDKByQYREbWJwsJCqUMgok7u1KlTUodAJnCfDSKiju6H3cCcZRI1LgDfPwXMuEWi9omIyJIx2SAi6uj2JENUixDUEqxkLhOAX+KNJht9+vRp/3iI6IbCTTctH4dRERF1BoIgTbtqEdh6HCgznJ+RkpIiQUBEdCOxtraWOgQygckGEVFnIFGuAQBQqoDfjhgUKxQKCYIhohsJ99mwfEw2iIg6AwlGUOlYyYBf9hkUu7i4SBAMERFZEiYbRER0fVRqYPsJoFR/KBXHUhNRW4uMjJQ6BDKByQYREV0/pRr432G9ovT0dImCIaIbRW5urtQhkAlMNoiIOgMp52wATQ6lIiJqS+Xl5VKHQCYw2SAi6gyknLMBaIZS7TgJlFTqioKCgiQMiIhuBLa2tlKHQCYw2SAiotahUgObDule1tXVSRgMEd0IOGfD8jHZICKi1iETgNVXh1Ll5+dLGAwR3QgSExOlDoFMYLJBRNQZSD1nA9Bs8LcrCSiukDoSIiKyEEw2iIg6A6nnbGip1MAmzapUvXr1kjgYIursfHx8pA6BTGCyQURErUcmA1b/AwDIyMho+/Ye/RwQ7gEmvm3+e9Rq4IutQOwLgP19gOeDwKh/AyfPNP2en/dq2nG6//pjJqJWY29vL3UIZIJc6gCIiKgVWMIwKkBzI78rCbhcgdra2rZtKyET+H43YGfTsvfNXgb8/Dfw4AjgqduBqjrg+BmgoMx4/coaYP6PgKPddYdMRK3r3LlzcHd3lzoMaka7JxvHjx9HUVERioqKUFFRAScnJ9x/f8ufFKWnpyMpKQmlpaWwsbFBUFAQBg4caDTDLSgowJEjR1BQUAAA8PX1xcCBA+Hl5WVQt7i4GMePH0d+fj5qampgb28PX19fxMbGwtPTs+UX3AqmT5+OX375xegxa2trKBSKNms7KysLS5YswaRJkzB+/Pg2a6e1JCYm4rnnnsORI0dQV1eH4OBgLFiwAHPmzJE6NKK2ZSnDqABAFIGNB+E8MrTl7x3xKhDiA3z/tOk2nvlWkzD81YIJomvjgZW7gV/nA3cPMu89b60HnO2BkT11Q8SIiMg87Z5sHDlyBLa2tvDy8rrmm+TExEQcPHgQ/v7+GDJkCKqqqpCYmIiCggJMmjQJ1tbWurr5+fnYvHkzHBwc0L9/fwBAcnIyfv/9d9x1113w8PDQ1b18+TI2bdoEW1tb9OjRA46OjigvL0dKSgrOnj2Lu+66y2iC0l6effZZdOnSRa+srbsPz549i+XLl8PZ2dnik43U1FSMHj0aFRUVeOihh+Dr64v169fjkUceQXV1NZ5+2sTNCxG1DkGzKlXgA8Paro0f9wCnzmuShpYkGx/+Bgzsrkk01GqgRtF8j0XGJeCj34GN/wLW7r/eqImolXXv3l3qEMiEdk827rvvPri4uAAA1q1bh/r6+ha9v7a2FgkJCfD29saECRMgk2mmnXh7e2Pbtm04deoU+vbtq6u/f/9+yGQy3HnnnXB0dAQAhIWFYe3atThw4AAmTJigq5ucnAyVSoXbb79drxcjICAAW7ZsQXp6uqTJxgMPPIABAwZI1n5buHz5cqv1GL388ssoKirC2rVrMXXqVADAvHnzEBsbi4ULF2LWrFlwcnJqlbaIqBlqEdhzChn7j6LXqLjWP39FDfCvH4FXJgN+LRg+UV4NHM4E/u824JWfgE+3AJW1QDdf4N0HgGlGYn3uO02Pxvj+TDaILFBhYaHu/o4sU7tPENcmGtfq7NmzUCqViImJ0SUaABAcHAxnZ2e9CYllZWUoLCxEaGio3i+io6MjQkNDcfHiRVRXV+vKtYmPg4ODXpva98rllj3FpaSkBI899hi6dOkCa2trODo6YsiQIThw4IBevYqKCjz++OOIjo6Gq6sr5HI5vLy8MHXqVBQWFurqffXVVxgzZgwA4MMPP4QgCBAEAX5+frrjgiDgyy+/NIhl+PDhEAT9QeSRkZHw8/PD/v37MWTIEDg6Ouolb6dOncLEiRPh6ekJuVwODw8P3HPPPcjLyzN57WVlZdizZw8CAgJ0iQag+X2bPn06KioqsHHjRjO+i0Qdk2Apcza01CLcdqe2zbnfWAvY2wLP39Gy92XlaYZf/bIP+G4X8N6DwM/PAd4uwH0fAluP6df/IwHYfhL4cFarhU5Erau0tFTqEMgEy757NqLhvIvGfH19kZmZifr6elhbW+tunI3V9fHxQVpaGoqKihAUFAQA6NKlC7KysrB7924MGDBAN4zq8OHDcHBwQHR0tMn4VCqV2b01giDA1tbWrLqAJnvPycnRK/Pw8ICDgwNKSkoQFxeHjIwM3H777ejbty+Kioqwbt06jBgxAnv27MHgwYMBAHl5efjpp58watQoTJgwAXZ2djh06BA2btyIo0ePIjU1FTY2Nhg+fDieeuopfPbZZxgxYoSuF+h6eneqq6sxceJE9OvXD/PmzcPly5cBAAcOHMD48eOhUqkwefJkhISEIDU1FZs2bUL//v1x+vRpuLq6Nnne5ORklJaWYtgww2EbQ4cOBQDs27cPM2fOvObYiSyZKFrOHHEAgEyA724Tq1HVK4GyasOyunqgqFy/3MNJs9JV+iXg4z+A1c8DttZokcorE9YvVwAH3wVujtC8vvMmoNsTmrkZt/XTlCnqgedXAHPHAdFdW9YOEbWbhkPnyTJ1uGRD2xNhrMtM2yNRVVUFNzc3Xd3GPRUN319VVaUri4iIQEVFBZKSkrBp0yZdube3N+6++26zuukyMzOxd+9es66lpZPjjc2Z+OCDD/DCCy9gwYIFSElJwcaNGzFp0iTd8RdffBEDBgzAU089haNHjwIAQkJCUFhYaPB9mTdvHj744AOsWbMGM2fORI8ePTBp0iR89tlnuuTgelVUVODpp5/GJ598oitTKpV48sknIYoiTp06pUv+AGD16tV44IEH8MYbb+CDDz5o8rznz58HAAQGBhocCw3VTFK9ePHidcdPRGZSi7DenwGUVALuTQxfjE8FRv7bsHx/mqb3oaEzX2omjj/7LTAkEpg8uOUx2V9Ztaqb79VEAwCc7IE7BgA//Q0oVYDcSjNPo6gCWHxfy9shonYTExMjdQhkQofbZ0OpVAIArKysDI5phzlp6zRXV1umrQNoehocHBzg6+uLuLg4jBs3Dv3790dpaSm2b99u1oT2rl27Yvz48WZ9jBo1qkXX/tZbb2HVqlV6H5MnT4ZCocDWrVsRFBSEAQMGICcnR/dhY2ODPn364MSJE6ipqQGgeQqgTTQUCgXy8vKQk5OjS2b+/vvvFsXVUm+88Ybe65SUFJw4cQJjx46FTCbTi3/gwIHw9vbGjh07mj2nNmk01lOkvdaGQ+ZMKS4uRl1dne51ZWUlKiqu7oqsUCh0vTJaubm5zb7Oy8uDKF5dMohtsI3WawMWSelmD7hq/v0ZvY4+IcCO14Adr6F4zTMQt/8b6B0MjItF+YYXoPjjFd3xSic5qjcfArYeB56dAEV6DkqOpwFnCzQJQo0CBYdPaeZlNGyjgQL5lb/3vppeUr2fh48rUK9ERV4RUFYFvLUeqtkjUXLukqaNswVAZQ3UarXm64JSo210rt8rtsE2LL+NQ4cOSXIdZL4O17OhTShUKpXBHApt4qAtb1i3MW1Zw3McOXIEycnJmDZtmu4GNSQkBD4+Pvjzzz9x8uRJ3HTTTc3G5+DgYLQnpTXceuutRieIFxQUIDc3F/X19ejatenu/qKiInTt2hVqtRrvvfcevvnmG5w9e9bg+1NcXNzqsWu5ubnBzc1Nr+zkyZMQRRHr16/H+vXrjb7PWMLYkLbXqeEfFK3meria0nCVMgAGE8ttbGwMJrb7+/s3+1o714VtsI1Wb0MARIsaQwVALkPprTHwvjK3rsnrGNMHAKD7zrhvAPzd4XLPUL36TgBQdKUn+p73YANAb3eNi8XwuTkJ+GgW8NwdRtv0iY0C/NyAi5q/cXo/j0vFgJ0NnAO8gfNFQGUtrD74He4f/K53DhkAdJsL3DUQ2LSgc/9esQ220QHaaPyQUYrroOZ1uGSj4VCpxmP4Gw+xau6JtvZJuLauWq1GYmIiAgMDDW5Ku3btCmtra4PM1hilUmn2kr6CILTq0rXdunXD228b30XXysoK3t7eAIB3330XCxcuRFRUFBYtWoTg4GDY2dmhpKQETz75pObJnZnxN8VYggcY73nQPoGYMGECZsyYYfR9jROUxrRDr4wNlcrOzgZgfIgVUadhab0bSjXcH5/Yuucc1UuzBG1jj30BBHsDC6cAvYKvlmddefoY1uDG4N44zZyPHSeAsbGasqJy4H9HgFE9NfNCfFyNt/PJH8CBdM18EX9uIkZkCaRcJZTM0+GSDR8fH6SmpiI/P98g2cjPz4ebm5tuspD25jo/Px9RUVF6dbUTzbW/pLW1tVCpVHpdb1qiKEIURbNuwrOystpszkZTXFxc4OPjg7KyMtx77716q3QZs2HDBtjY2ODo0aN6idXmzZsN6jZ3Lu33ruEKVoAm4WpJF2NMTAwEQYBKpcL06dPNfl/jc7i5uenmpTS0b59m7HdcXBsswUlExvm4ItvPGhGma5ovyFvz0dhz3wG+bsCkm/XLR7+m+Xz2q6tlL0/WLGE7eSnwwh2AqyPw5TbNxPR3rjzscLA1PBeg2dDvcKbxY0QkCWdnZ6lDIBMses5GZWUlSktL9W7yg4ODYWVlheTkZL3yc+fOoaKiAuHh4boyV1dXeHt7Izs7W28ieFVVFbKzs/V6Mezt7WFra4vc3FyUl+uvgpKdnQ2lUqlLXprTlnM2mmJnZ4fbbrsNxcXFWLx4scFxURRx9uxZ3WttAtHw+6dQKLBkyRKD92qXKm48nhEAoqOjIZPJsG3bNr3yn376CWfOnDE7/l69eqF3797YsWOH0UStvr7e5ORuV1dX3HLLLbh06RLWrVunKy8vL8fq1avh6OiIu+++2+yYiDocSxpGJZcB04eiurZW6kgM+boB+94GxvQGPtoMLPwZ6OIJ7H0T6NNN6uiIqIVacr9B0mj3no309HRUVlYCuNqbcOyYZm1zJycnRERcfQ62e/du5ObmYvr06brM1d7eHjfddBMOHjyIP/74A+Hh4bodxN3c3NCrVy+99gYPHozNmzfjt99+Q8+ePQFo9nMQRRGDBg3S1RMEAf3798f+/fuxadMmREdHw9HREZcvX0Zqairs7OzQp08fk9fXlnM2mrN06VIcPnwYb7zxBrZt24ahQ4fC0dER586dQ3x8PFxdXZGQkABAM1wpISEBAwYMwJQpU1BTU4MtW7YYXbI3MjISPj4+2LhxIwICAuDj4wNPT0/MnDkTERERGDFiBHbt2oVx48ZhyJAhOH36NP7880907dpVt0KUKdbW1vjqq68wfvx4jB49GuPHj0efPn1QX1+v6ymaOXNms6tRAcA777yDffv24cEHH8Rff/2l20H8zJkz+O9//8unH9S5WdIwKqUamBYHR8fm51oZtefNlr+nYc+FOeWhfsCvRoZJmfL905oPIiIyW7snG2lpaQZzH7Q3wf7+/nrJRlN69+4NW1tbJCUlYf/+/bC2tkZoaChuvvlmg/WW/fz8cMcdd+DIkSM4cuQIBEGAr68vxo4dazAhqGfPnnBwcEBycjKSkpKgVCphb2+PsLAw9O/f36J3n3Z3d8f+/fvx73//G//73//w6aefAtBMjOrVqxcef/xxXd1Fixahrq4OP/zwA5YsWQInJyeMGjUKixcvNkjWnJycsGzZMixcuBAffPABFAoFfH19MXPmTMhkMqxcuRJz5sxBfHw89u7di4iICGzatAmLFy82O9kAgJtvvhkHDx7EokWL8Pfff+PPP/+EjY0NvLy8MHr0aDzwwAMmzxEdHY2dO3fi+eefx88//4za2loEBwfj66+/xqOPPmp2LER0nfzcgEERCG6w2h8RUVsICwuTOgQyQRCNTVIgIqKOY/ZnEH/YA0Fl3uIObUouA56eAHw4CydOnEBsbKzUERFRJ3b+/Hm9/bnI8lj0nA0iIjJPM4vDtS+lGpg2ROooiOgG0ZbL9VPrYLJBRNQJWEwftb+7bnfugIAAiYMhos7O1D5cJD0mG0RE1DrkMuD+Ybpulub24iEiag2N55qS5WGyQURErePKKlRappasJiK6XklJSVKHQCYw2SAi6gwsoRMh0AO4Kdx0PSKiVqJSqaQOgUxgskFE1BlIPWdDLgOmD9Obqd6jRw8JAyKiG4GHh4fUIZAJTDaIiOj6GVmF6sKFCxIFQ0Q3Cnd3d6lDIBOYbBARdQZSD6Pq4gkM0B9CVVlZKVEwRHSjyMrKkjoEMoHJBhFRZyDlMCor/VWotOzs7CQKiIiILAWTDSIiuj4q/VWotMLDOVmciNpWt27dpA6BTGCyQURE1yfIC+gXalB86tQpCYIhohtJRUWF1CGQCXKpAyAioutkbQVBrQbkEuykq1ID9w83GEJFRNQeioqK0KVLF6nDoGYw2SAi6ujenI58GxV8fX2laX/6MKPFfn5+7RwIEd1oBD7osHiCKIpSr85ORETX6cSJE4iNjZU6DCIiIj2cs0FE1Am4ublJHQIRUbtLTk6WOgQygckGEVEn4OXlJXUIRETtrr6+XuoQyAQmG0REnUBmZqbUIRARtTv26lo+JhtERERE1CF5e3tLHQKZwGSDiKgTCAkJkToEIqJ2l5GRIXUIZAKTDSKiTqCqqkrqEIiIiAww2SAi6gQKCwulDoGIqN0FBwdLHQKZwE39iIg6sWGrlcgoads2+vkCv91tBbmMm2sRUfuqqamBu7u71GFQM5hsEBF1An369DEoSy4Sse9i27f95xmgqh5wtW37toiIGiooKEBAQIDUYVAzOIyKiKgTSElJMShbl6aGFTsbiIhIQkw2iIg6AYVCofdaFEWsShGhEiUKiIioHfTu3VvqEMgEJhtERJ2Ai4uL3uvkIiCjVJpYiIjaS1pamtQhkAlMNoiIOgE/Pz+912s5hIqIbgB1dXVSh0AmMNkgIuoE0tPTdV9zCBUR3Sga9+qS5WGyQUTUyZwqArLKpI6CiKjt+fv7Sx0CmcBkg4ioEwgKCtJ9zSFURHSj4JwNy8dkg4ioE9COW+YQKiIisiRMNoiIOoH8/HwAQGIhkM0hVER0g+jatavUIZAJTDaIiDoRDqEiohtJfX291CGQCUw2iIg6gV69enEIFRHdcPLy8qQOgUyQSx0AEZEl+/uCiPcT1DheIKKwGnCzBWJ9BLw6WIa4QPO6EHaeU+PtgyKSikQo1UCEO/B0Xxlmxug/7ymrE/H2QTU2ZojIqQR87IExwQJeGyJDkEvzbWVkZKDGPRJny6/5UomIiFodkw0iomakl4iQCcDcPjL4OQIltcBPp9UY/osKf9wjw23dmu8g/i1TjUmb1BgcALw+WAZB0Ax1evBPNYpqgOcHaN6vFkWMXafC6cvA/8UKiHAXkFkq4vMTIradVSFlthWcbZpOOGpra7E2TQ25ACjZs0FEN4iePXtKHQKZIIii2K7/LaWnpyMpKQmlpaWwsbFBUFAQBg4cCHt7e5PvrampwaFDh1BUVISqqioolUo4OjrC398fsbGxcHV11auflpaGvXv3Gj1XdHQ0hg4dalZdrRkzZsDR0dGMq2w9L7/8Mt59912jx+RyOVJSUhAeHt4mbZeWlmLRokXo168fZs+e3SZttJYvvvgC3333HbKzs1FeXg47Ozv4+/tj2rRp+Ne//gVnZ2epQ6ROpLpeROhyFWJ9BGydYtVs3XHrVEi+LCL7ESvYyjXJglItIuo7FRytgZMPaZ757L8oIm61Cp+NluHJvlcTmBVJaszepsavd8lwd/emE5vMzCyM/isY5yta4QKvQenTVnC15WQRImpfqampiIqKkjoMaka79mwkJibi4MGD8Pf3x5AhQ1BVVYXExEQUFBRg0qRJsLa2bvb9dXV1KCsrQ5cuXeDk5AS5XI6ysjKkpaUhOzsbkyZNgru7u8H7YmNjDcobJyb+/v4YOXKkwXurq6tx6NAheHp6tnui0dCMGTMQGxurV2ZlZQVfX982a7O0tBTLli3DPffcY/HJRkJCAuzt7XHvvffCz88PtbW12LlzJ95++238888/2Lp1q1kJLZE5HKwFeDsApXWmn9WUK0S420KXaACAXCbAy96wHgD4OuiX+ztpPtub+GtdYBMoWaJBRCSV2tpaqUMgE9ot2aitrUVCQgK8vb0xYcIEyGSaJ3Te3t7Ytm0bTp06hb59+zZ7Djc3N9x1110G5d26dcOmTZuQnJys11uh1aVLFwQEBDR7bhcXF6Nb3h8/fhwAJM+aR4wYgUceeUTSGFpbWVkZHB0dIZdf/6/ht99+a1D2zjvvYOTIkdi7dy/i4+MxZsyY626HblzldSIUKqCoBvjhtBqnioBXbjb9JH9EVwFLDot4dZ8KD8VohlGtShGRkAesveNqT8UAXwGO1sCr8Wp42AOR7gIyS4H5e9W4yU8zd6M5yw+VQC54cwgVEd1QnJycpA6BTGi31ajOnj0LpVKJmJgYXaIBAMHBwXB2dkZGRsY1n1s7REa7qZUxCoUCKpWqRecVRRFpaWmwsrJqs6FKraWurg7/+te/EBwcDGtrazg4OGDAgAHYsGGDXj21Wo358+ejd+/ecHNzg1wuh6enJ8aPH49Tp07p6u3ZswfdunUDAPz6668QBAGCIMDLywuXLl3Cnj17IAgCnnvuOYNYpk2bBkEQ9Hb1HDhwILy8vHQ3/U5OTnBzc0NWVhYA4NKlS7jvvvvg7e0NuVwONzc33HrrrUhMTLyu70tISAhEUURJScl1nYdo2u9qeH+uQo8VKnyQIOLxPppJ4qa8OkiGaZEC3j4oovu3KoR/o8K7h9TYcJcM90Rcfb+Xg4A1E2UoqwNGr1Wjy1cqjFijQoCTgF3TrCCXNZ1siKKILXluTDSI6IbDfTYsX7v1bBQUFACA0WE/vr6+yMzMRH19vcmhVIDmhlmhUECtVqOsrAxHjx4F0PQv3LZt23TrMHt4eKBPnz7o3r27yXZyc3NRXl6O8PBw2NramqwPQBeXOeRyudlP9cvLy5GTk6NXpu2Nqa+vx/Dhw3Hs2DGMGDECDzzwAKqrq7FmzRpMnz4dX331FWbNmqWL7/PPP8eQIUMwatQouLm54fjx4/jjjz9w8uRJ7N+/H8HBwejRowdeffVVvPnmm+jfvz/uu+8+AICDgwPc3NzMirmx2tpa3HXXXYiMjMQzzzyDsrIyuLm54fz58+jXrx/q6uowYcIEREVF4dy5c1izZg3Gjh2LHTt2oHfv3ma1cfnyZdTU1KCoqAibN2/Gzz//DF9fXwwePPiaYqbORS1qeifMYWsFCMLVG/x3h8vw4gARFyqAlclqKFSA0ox/6rZyzepTUyIE3BMhQKUGvk5U44E/1NgxVcCggKtteDsI6Osj4KlAATFewIkC4L3Daszaqsa6O5ueG5KQBxTUmf7bSUTU2aSkpBgMMyfL0m7JRnV1NQAYnffg4KAZpFxVVWXWjeyFCxewbds23Wt7e3sMGjQIERERevXkcjnCw8MREBAAe3t7VFRUIDk5Gbt370Z5eTn69+/fbDupqakAWjaEatu2bcjNzTWrbr9+/TBgwACz6r744ot48cUX9coef/xxfPnll/jwww9x+PBh/Oc//8GCBQt0xxcvXoyIiAi8++67mDx5MlxcXGBra4tLly4ZDBn74osv8H//93/48ssv8Z///Ae+vr6YPXs23nzzTQQHB2PevHlmxdmcqqoqjBs3DmvXrtVLssaOHQuFQoHffvtNb97ME088gcGDB2Px4sVYv3693o1fU4YPH47Tp08D0Nwo9uzZEx999BG6dOly3fFTx/f3BREj15r3MCBllhWiPK++jvURAGh+Bx+IFtDvBxUe/lON9Xc1P0H8qb/UOHhJxLEHrSC78js8LVJAzPcqPLtLhUMPaP4tZJeKGLlGhR/GyzD5So/HXeFAiAvw8FY1/sxW4/ZQ4z0p69PVsBJEqERO0CYiIsvSomSjrq4OSUlJZtfv2bMn7OzsAABKpRKAZlKzQRBXbjy1dUzx9fXF+PHjoVKpUFJSgqysLNTV1UGtVusN0QoLC0NYWJjee3v06IFff/0Vx44dQ0RERJOrFNXV1eHMmTNwcXExOd+joUGDBjU7nKshY3NEmvLkk08iLi5Oryw6OhoAsHLlSvj5+WHChAkGvR8jRozAunXrkJWVhb59+0IQBF27KpUKxcXFqKur093ka+eotJUXX3xRL9EoKyvDrl27EBcXh/DwcL34AwIC0LVrV5w4cULXC2LKsmXLkJubi9zcXGzduhWXLl1CUVFRi+MsLi6Go6OjrkersrISoijqfl8UCgUqKirg6Xn1bjQ3Nxf+/v5Nvs7Ly4Ovr68uaWIb7d9GlKcfVtym+RtRVlYGFxcXXRuVVVWwtbWF9ZXfT2dUoaLCeBs2VgLuDBfw7iE1auplsLcWjLZ5/mIevk3ywvybBMgEQe86bu8m4LPjalwurYCnmzO+P6VGrUrEYLcSAFevY6BTAQAvxF8ScXuo8e+Vn6M31BIPoaqoqISrreX9zNkG22AbnbsN7QPr9r4OPz8/kHlalGwoFAocO3bM7Prdu3fXJRvaG0yVSmUwdEibZJg7pMjOzk73pDo4OBjdu3fH+vXrUVNTg+HDhzf7XisrK/Tp0wd79uxBTk4OevToYbReZmYmVCpViyeGe3t7t6i+uWJjYzF9+nSjx7Kzs1FXV9fsUKPc3FzdBPzvv/8eS5YsQUZGhsE8loqKtlvOxtnZ2WCoW1paGtRqNf755x8EBQUZfZ+XlxdqamrMSjZGjBih+/qFF17Ac889hwcffBD29va48847zY7Vw8ND73XjCWg2NjZ6f5gA6P0hMva68R8mtiFNGw/31D79b7xyXeMHD823UaMERAioUAD21sbbtHb1hVKt0u3o3fA66lWAWhTg4KhpJ78aEEUBbu761+rp7QtApRuyZex7NdVRxAt7pM02nJ2vfr8s7WfONtgG2+i8bTS+N5DiOqh5LUo2nJ2d8dhjj11TQw2HSjVedra5IVbmcHR0RGBgINLS0hAXF2e096Qh7S9ac8ulpaWlQRAEg6FZptTW1po9Z8Pa2tqsOSqmiKKIwMBAvPXWW03OLdEO11q7di1mzZqF0NBQzJs3D+Hh4XB0dIRKpcLMmTNh7rYrzQ1paqqHysbGxiCh1LY3ZMgQPPXUU0bfZ2dnZ/DHwlxz587Fxx9/jO+++65FyQaRVkGVCB9H/d/30loR/9/efcc3Ve5/AP+cpGm696QbKBRoGbIFBJElKEMZFxkiKm4QxOsW+ImTe0URFARFREFlqAgyZMuS2ZZKaQu0pXvSPdIk5/dHbyMhbZPOk7af9+uVF81znpzzzUOT5ptn7YgV4WcPvWM3C0SUVAAhrpVlHjaVO47/HCfi/waJsJT/rxdFJeK3GyJCXKDrFenkLECEiJ9ixNsSImDr1crXSC+Pml9zvvYC+nmJOJcugHPEiagtSU1NhYeHh9RhUC2abc6Gh4cHrl69ioyMDINkIyMjA05OTg364K3RaCCKIlQqldH9FAoKCgCgxnrZ2dnIzs5GQECAQfecMX/88UeTzNmoTUBAADIyMjBs2DAEBgbWWverr76CQqHAjh079CZUVc1PuV1tCUXVh//qVnmKj483LXAAHTt2hCAIUKlUmDx5cqMkX7crLS0F8M//OVFd3b9TA187Af29BXjYVCYUG/8WkVoE/PiA/hyK2b9rcCwZEBdXvrXKZQIW95XhzRNaDPheg9ndZNBoga8ua5FcCHw39p/HzwkV8J/zwFN/aHEpU0Q3VwEXM0VsiBTRzRWYFFz7fIyRbjk4l+7W+A1ARETUAM2WbAQEBEAul+Pvv/9Gx44ddXMrEhMTUVhYaPChu6ioCGq1Gg4ODrq6JSUl1X74v3XrFlJSUuDg4KCXQJSVlemGcVVRqVQIDw+HTCarcdJwfSaGV2mqORu1efTRR/Hmm29iyZIl+Oqrrwx6D5KSktCuXTvI5XJdr8/tw6dEUcTrr79ucN6qHqD8/HyIoqiXfAQFBUEul+PixYsoLi7W9Ur9+eefiIiIMDl2V1dXDBs2DMeOHcPXX3+Np556Su+4KIq4efMmAgICajyHWq1GWlpatauRffjhhwDAlSqo3uaGyvDDVS1WXhCRVw44K4EB7QRsGSfDEF/jE7LfGCBDkCPw6QUtlp3SolwDdHcHto//ZyI4ALhaCzg/U463T2rx23URayNEuFoBc8MEvDdYpusVqck9Ttl4D0w2iKhtqZq/Suar2ZINa2tr9O3bF2fOnMGePXvQsWNH3Q7iTk5OCAsL06t/5MgRpKWlYfr06bpJPOHh4UhJSYGfn5+uLDc3F3FxcdBqtQYTqLdv3w5vb2+4uLjoVqOKiYlBSUkJBgwYUO1GMGq1GteuXYONjU291m5uqjkbtfn3v/+NvXv34ttvv0VERASGDh0KV1dX3Lx5E6dOnYJWq8W5c+dgb2+P6dOnY+/evZgyZQomT54MmUyGffv2IT8/3+C8rq6u8PPzw9mzZ/Hiiy8iMDAQNjY2mD17Nuzs7DBt2jRs2bIFo0aNwn333YfExETs3LkTAQEBSEhIMDn+TZs2oW/fvnjuueewfft29O7dG3K5HPHx8brJ43fuF3K7oqIidOzYEf3790doaCi8vb2RmZmJP/74AzExMejatSteeeWV+jQtEZ7rJcNzvUzbkujov6p/S32kiwyPdDF+Dh97AV+NqX0YaE2CXJUY2A44kwqYNpCTiKjlS0xMNGk7A5JOsyUbANC9e3colUpcvnwZp06dgkKhQPv27dG/f3+Ths/4+/ujuLgYN27cQGlpKURRhK2tLdq3b4/u3bsbjOvv0KED0tLSkJycDJVKBUtLS3h4eGDo0KE1JhIJCQlQqVTo2rWr3spW5kyhUODo0aP44IMPsHnzZqxduxYA4OzsjJCQEPzrX//S9fjMmjUL2dnZWLlyJVauXAlbW1v0798fW7ZsQbdu3QzO/cMPP+iW2FWpVHB1dcWDDz4Ia2trrFu3DiqVCvv27cP58+cRFBSEzz77DL///nudkg0/Pz9ERUXhlVdewb59+3D06FEoFAq4urpi4MCBePLJJ2t9vI2NDWbNmoU///wTly5dQklJCaysrODn54eFCxfirbfegrPznZOBiVqXgIAATC+U4XQqUw0iajuKi4ulDoGMEERTZwQTEZHZCg8Ph2fHHvBZq5FkknjeC3I4KrnPBxE1r9jY2Dov5kPNq2V8dU9EREZ52wkY5FO19SARUesXFBQkdQhkBJMNIqJWoGrz0ekhfFsnorbj77//ljoEMoJ/lYiIWoGq1eIe6sR+DSIiMh9MNoiIWoGUlBQAgJetgME+gIw5BxG1AXfu7k3mh8kGEVErM72LDFz6g4jagqr9w8h8MdkgImoFunTpovv5ISO7jRMRtRbJyclSh0BGMNkgImoFkpKSdD972gq4x5dDqYiISHpMNoiIWoGioiK9+9O7yKDlUCoiauVCQkKkDoGMYLJBRNQKWFlZ6d1/KFjgfhtE1OpVLY5B5ovJBhFRK9CxY0e9++42Aob5cSgVEbVuhYWFUodARjDZICJqBaKiogzKuCoVEbV2d/bqkvlhskFE1EpN6ihAEAC5AChkTXOT/6/nhB0oRCSF4OBgqUMgIyykDoCIiBrOy8vLoMzNRsAHQ2S4Wdi03RueFalwUPo16TWIiKpz+fJl9OzZU+owqBZMNoiIWoHqkg0AeLlf03dgh4fnAGCyQUREhjiMioiIGsTJyUnqEIiojfL09JQ6BDKCyQYRETWIm5ub1CEQURulVCqlDoGMYLJBREQNcu3aNalDIKI26ubNm1KHQEYw2SAiIiIioiYhiCJXYSciovrLy8vjvA0ikkRJSQlsbGykDoNqwZ4NIiJqkOLiYqlDIKI2Kj09XeoQyAgmG0RE1CBZWVlSh0BEbVRBQYHUIZAR3GeDiIiaxCcXtNgYpTVaTykHNo+Vo7ML9yEnorqxtLSUOgQygnM2iIioQURRhCAIBmUdN2hwI9/44wUAb/Yqxv/d59g0ARJRq1Xd+w+ZFw6jIiKiBomOjjYoi8yCSYkGAMgEoLCwsJGjIqK2ICIiQuoQyAgmG0RE1CAqlcqg7KcYLeR1+LLR3cO9ESMiIiJzwWSDiIgaxMHBQe++KIrYEi1CU4dBugX5nORJRHXn7s4vKswdkw0iImoQLy8vvfvhmUBCHXOH8vLyRoyIiNoKW1tbqUMgI5hsEBFRg8TGxurdr+sQKgCQW8gbMSIiaisSEhKkDoGMYLJBRESNRhRFbLlatyFUAIdCEBG1Vkw2iIioQfz9/XU/X8oEbtZj+kV6GncBJqK669ixo9QhkBFMNoiIqEFun29RnyFURET1lZ2dLXUIZASTDSIiapCMjAwAlUOovq/jKlRV7OzsGjkqImoL8vLypA6BjGCyQUREjeJCBpBcz735LBQWjRsMEbUJFhZ87zB3TDaIiKhBwsLCAFQOobKo5xCqvFt5jRcQEbUZoaGhUodARjDZICIyY4cStZi7T4NOX6lh84ka7der8cR+DdKKTB+rlFIoYuouDZw+U8NhlRoTftbgRl7tjz+RLEL4jxrCf9TILqm9blxcnG4jP3U9hlAREdVXRESE1CGQEex7IiIyY68c1yK3DJjSSUCws4Ab+SJWXxKx+7oG4Y/K4WVbe1dCkUrEvT9pkF8OvN5fBoUMWHlBi6E/ahA+Ww5Xa8PHa0URLxzWwFYBFFcYj7GsrAzn0oGUovo+S8DN3a3+DyaiNksU+Q2HuWv1PRuiKCIyMhI//vgjvvrqK3z//fc4ffo0KipM+AvaRObNmwdBEKq9KRSKJr12RkYG5s2bh+3btzfpdRrDuXPn8Mgjj6BHjx6wsbGBIAiYN29ejfXj4+MxYcIEuLq6wsLCAm5ubpg6dapu8ipRS/TxMDmuPSHHh0PleKK7DO8NkWP3JDkySoDVl7RGH/95uIi4W8DuSXL8u58MC/vIcGCyHGlFwH/PV//4LyNEJBUCT4SZNibK3t6+QUOoAKCosAGZChG1Wa6urlKHQEa0+p6N06dPIyoqCoGBgejevTvy8vIQFRWFnJwcjBs3DoIg3RqNTz/9NDp06KBXJpc37S66WVlZWL9+PQBg8uTJTXqthjp48CB++OEHeHp6Ijg4GJGRkTXWTUxMRL9+/XDr1i1MnDgRoaGhiIqKws6dO3Hu3DlERETAwcGhGaMnahz3+Bm+R93jJ8DFCojOMf747bFa9PUC+nr/c54QVwH3BQj4KUbEe0P06+eWinjzpBb/d7cMmUaGT1Vp184HWw40bAhVWVlZ/R9MRG0W/7abv1adbOTm5uoSjVGjRunK7e3tcerUKVy/fl3SzWAeeughjBw5UrLrN4WcnJxG+5bh0Ucfxdy5c+Hp6Yk//vhD7//wTi+//DKys7Px8ccfY+HChbrylStXYtGiRXj11Vfx+eefN0pcRFIrUokoqgDcrGuvpxVFRGYBc0MNE5Z+XsCBBKBQJcLe8p/jb53UwssGeKqHgHdOm5Y9bDubiLTiDsYr1kImb/Ud7UTUBOLj49GzZ0+pw6BatOp39+vXrwP4Z6WUKiEhIbCwsEBcXJwUYZmspKQEzz//PPz8/KBQKGBjY4P+/fvj8OHDevU0Gg2ee+45dOvWDU5OTrohRBMnTkRKSoqu3vbt23VtsX79et3QLXd3d91xQRDw/vvvG8QyZswYg16gsLAwuLu7IyIiAkOGDIGdnR3c3P4Zd339+nVMnDgRbm5usLCwgLOzMx588EEkJiaa9PzbtWsHT09Pk+qePXsWlpaWWLBggV75/PnzoVAosGPHDpPOQ9QSfHJBhEoDTAupvWc2txQo1wDedob1vP831yP1ttFLkVki1kWI+PheGeQy03t9/8hwbNAQKgDw8vRq2AmIiMgsteqejaysLAiCAA8PD71yCwsLuLq6Iisry+g5RFHU2x3XGKVSafLQrNzcXCQnJ+uVOTk5wc7ODuXl5RgwYACio6MxatQoPPbYY8jLy8OPP/6I+++/H7t379b1ipSWlmLjxo249957MWbMGNjZ2eH8+fPYvXs3Ll68iJiYGFhbW6N37954+eWXsWLFCgwaNAgTJ04E0LAuyLKyMgwfPhzdu3fHokWLdPMjoqOjMWjQIKjVakycOBEdO3ZEXFwctm/fjgEDBiAyMlKX5DSGiooKKBQKyGT6+bNcLoelpSUyMzORnJwMX1/fRrsmUV1pxcokwRRKOap9LzmeJGLZaS2mdhYw3L/274tK1f+c605WFvp1AGD+IQ3uDxIwKtD076G0oog/slwavApVamoqAL4+iahu2rdvL3UIZESrTjaKi4thZWVV7TwIW1tbZGRkQKPR1DpPoqioCFu3bjX5mtOnT4e9vb1Jdf/1r38ZlL399ttYtmwZ3nzzTVy+fBmbN2/GzJkz9Y6HhIRg0aJFuHz5MgDAxsYGGRkZBtddvnw53nrrLaxfvx7z589HUFAQZs+ejRUrVqBr165YvHixyc+rJkVFRXjsscfw9ddf65XPnTsXarUa586dQ+fOnXXls2fPxpgxY/DGG2/gyy+/bPD1qwQFBeHkyZM4cuQI7r33Xl35kSNHUFxcDACIiYlhskGSOp4k4t6fjE/qBoDox+QIuWNE4tUcEZN+1SDUDdgw2nhCYP2/d/jyahKcMrV+nR+vanEqFYiaU7cO77/SgIzSVt1JTkRmLC8vj/M2zFyr/guhVqsNvumuUpVgqNXqao9Xsba2xtixY02+WVsbGUR9mzfffBNbtmzRu1UlFjt37kS7du0wbNgwJCcn625lZWXo378/rly5gsLCyq16ZTKZLtGoqKhARkYGkpOTMX78eACVk+Sb0p3DrrKysvDXX39hyJAhsLW11Yu/S5cu8PLywvHjxxs1hsWLF0MQBDzyyCP45ptvEB0djU2bNmHGjBm6/+uiItNXu8nNzdXr0SoqKtK1NwCoVCrk5OjPzk1LS6v1fnp6ut4SfbxG27uGpywfX47QYuMYGTaOkeGLYRX4YphKd3/9CC0+G1yCjWNk8LbTP2dSgYhR2zWws9Dg94fkunkWtT0PF2tAKReReEtl8DzSiisf086u8hovH9NiSmcBlnLgbFwGEvJF5P2vOS4lZCOlUFvtNWwbaQE9hULRKv/PeQ1eg9dondcg0wliK16geNu2bSgrK8OsWbMMjh08eBA3btzA448/3uQrQN1p3rx5WL9+PQ4cOFDjBHGlUgmVSlXtsSrR0dEICQkBAKxatQqrV6/GjRs3oNHof405ZswY7N27FwAQFRWFsLAwPPnkkwY9C9u3b8eUKVPw3nvv4bXXXjM4x/79+/VewGFhYUhMTERBQYFe3X379uH++++vNXYPD486LUlbNUG8urirrF69Gm+++Sby8/MBVCZhDzzwAHJycnDy5EkcO3YM99xzj8nXJDIXOaUiBm/VILcMODFdjmBn0ydI9N2shiAAZ2fqd2SP2qbB9TwR15+sLBf+U/sXLz3cgfBHDTvDRVGE/+clSC5VmhzTneQC8Hbfcrx9j229z0FEbVNkZCS6d+8udRhUi1Y9jMrW1hZ5eXnVDpWqbYjV7bRabZ2WZLSysqqxN6UuRFGEv78/PvjggxrrVA0J+uKLL7BgwQIEBwfj9ddfR2BgIKytraHRaDBr1iyTN7ypba5JTT1ASqXhB4yq640YMQJz586t9nG2to3/oeL555/HU089hRMnTiA/Px+9evVCQEAAgoODIZPJuFoFtUjFKhFjd2iQUgQcmVp7onGzQERJReXStlUmd5Lh1T+1OJ8uoo9XZXlMrojDN0Us7vtPvZ8nGL5v/XBVxI8xIr69XwbfGkaHCoKA2WGW+PAcoGnAV1e3cm8BYLJBRHXDRMP8tepkw93dHcnJycjMzIS3t7euXK1WIycnR6+sJsXFxU02Z6M23t7eyM/Px9SpU40mRN999x0UCgXOnz+vN27x7NmzBnVrSyiqVn66szsRgMFE9tp0794dgiCgoqIC06dPN/lxjUGhUOjN2bhx4wZu3LiBsLAwjumkFmnG71qcTa9cvjY6V0R07j+f6O0UwMTgf5KE2b9rcCwZEBf/89b+bC8B6y8D43ZqsLiPDAo58PF5LTxtgZf6/PPY289TJTyzspf0/iABbjY1v3cMtEmGRvRr0PMkIqqPy5cvG6w6SualVScbHTp0wKVLl3D58mW9xOLq1atQq9Um7bFRNWfDVHWZs1Gbhx9+GCtXrsTLL7+Mjz/+2OB4fHw8goKCAFQOFxIEQW/4lFarxeuvv27wOCcnJwDArVu3DI5169YNMpkMx44d0yv/7bffEBsba3LsPj4+6Nu3L/7880/8/vvvBu2n1WqRnJwMf39/k89ZHxqNBo899hhEUcQbb7zRpNciairhmZXJxddRIr6O0u86CHCoPkm4nb2lgKPT5Fh4RIvlZ7TQisAwPwEr75XBvZYEoi585Pno6OSHa3n1P4erG3cBJqK6u3PoOJmfVp1suLi4oFu3bvj7779x4MAB+Pv749atW4iKioK3t7dJyYaFhYUkKxi9//77OHbsGFauXIk///wTQ4YMgaOjIxITE3Hy5EkolUrdjtoPP/wwTpw4gX79+mHKlCmoqKjA3r17qx3+5ePjAy8vL+zfvx+vvPIKvL29YW9vj8cffxzOzs64//77sWfPHgwfPhz33HMPYmNjsWvXLgQEBCAhIcHk+Ddt2oTBgwdj/PjxGD16NHr16gWNRoMbN27gyJEjmDhxotHVqLKysrBkyRIA/0zO+uuvv/Dss88CqFzNq2oOxq1btxAWFoaRI0eiffv2yMvLw6+//orr16/jueeew5QpU0yOncicJMwz/W366L+qr+trL2Db+LrPTVs6SI6lg4zXs7OzxYwuApafEes9lKqkpARA43xZQ0Rth7Ozs9QhkBGtOtkAgIEDB8Le3h7R0dG4efMmrKysEBoaij59+pi8H4YUlEolTp8+jSVLlmDbtm1Ys2YNgH8SqMcee0xX98UXX0RBQQG+/PJLrFixAra2thgyZAjWrVsHHx8fg3Nv3LgRCxcuxCeffAKVSgU3Nzc8/vjjAKBbavfYsWM4efIkOnbsiK1bt2LNmjV1SjZCQkIQHh6OV155BYcPH8aBAwegUCjg5uaGYcOG6cVfk4yMDHzxxRd6ZZGRkboky8/PT5dsWFlZoVOnTtizZw9u3boFpVKJzp07GywdTESNLyAgAFOcZVh2uv7fMJaWlDZiRETUVri6slfU3LXq1aiIiKjphYeHo2fPngj5So0YwxGaRskFYH5wBj4eb/jlCBFRbaref8h8tep9NoiIqPlM7yKDvJ4dxt5exhfsICKilofJBhERNUi7du0AAFM6CfWes3HnpllERKYIDAyUOgQygskGERE1SNX8t65uAkJc6ncOjuglovooKiqSOgQygskGERE1SEpKiu7nR+o5lMrahitREVHdZWdnSx0CGcFkg4iIGk19h1I11h5FRERkXphsEBFRg3Tp0kX3c4irgK71WIkyNye3ESMioraCK1GZPyYbRETUIElJSXr3H+kig8x8tzEiolbk77//ljoEMoLJBhERNcidEzSndBKgreNQKheXes4sJ6I2raKiQuoQyAgmG0RE1CBWVlZ69zu5CAh1q9s5ysrLGjEiImorHB0dpQ6BjGCyQUREDdKxY0eDsroOpSopLmnEiIiorfD09JQ6BDKCyQYRETVIVFSUQVmdh1JxjgcR1UNsbKzUIZARTDaIiKjRdXQWEOZWmUMYu2lFoJ13O8liJSKipmMhdQBERNSyeXl5VVv+Wn8Zfo4z3r2htAD6ymMAdDFal4jodv7+/lKHQEYIoijWY/slIiKixhMeHs718omozlJTU9GuHXtGzRmHURERkeScnJykDoGIWqDMzEypQyAjmGwQEZHk3NzquFYuERG1CEw2iIhIcteuXZM6BCJqgcLCwqQOgYxgskFERERELRKXvjV/TDaIiEhygYGBUodARC1QeXm51CGQEUw2iIhIcsXFxVKHQEQtkL29vdQhkBFMNoiISHJZWVlSh0BELZCPj4/UIZAR3NSPiIjMUnqxiLn7NAbl7R0FrLxXBoVckCAqIjInV69e5R49Zo7JBhERSa5Hjx4GZTtiReyLBwx3nhXxVA8gzL05IiMioobgMCoiIpJcdHS0QdnWaC3Yd0FEtfH19ZU6BDKCPRtERCQ5lUqldz+1SMSp1Op6NYiI/qFWq6UOgYxgzwYREUnOwcFB7/6OWKYZRGRcenq61CGQEUw2iIhIcl5eXnr3t0ZrJYqEiIgaE5MNIiKS3O27AKcUijidxiFURGRcaGio1CGQEUw2iIjIrGyPFfnHiYhMcv36dalDICP4fk5ERJLz9/fX/bwlWsteDSIySWlpqdQhkBFcjYqIiCRXXl4OAEgqEHGW8z2JyES2trZSh0BGsGeDiIgkl5GRAeB/Q6i4uQYRmej2XlEyT0w2iIjIbGyJ1kLkGCoiMlF1G4KSeeEwKiIiklxYWBgS80Wcz5A6EiIiakxMNoiIWrG0IhGfXtTirzTgfLqIogrgyFQZhvnXr2N75DYNDiaKeK6ngNUj5AbHM4pFvH1Si903ROSUAl62wH3+Ar4aY1j3dnFxcdhT2AkyANxhg4hM1a5dO6lDICOYbBARtWIxuSI+PCsi2BkIcwdOp9b/XDtjtTidWvMYp6QCEYO2agAAT/eQwccOSC0CzqYbHxdVVlbGVaiIiFqhZk82YmNjcfnyZeTl5cHS0hL+/v7o168frK2tTXr8lStXkJ6ejqysLBQUFEAURcybN6/G+hkZGbh06RJycnJQVlYGGxsb+Pj4oGfPnnBwcNCrW1ZWhvDwcCQmJqKoqAiWlpZwdnZGaGgoAgMDG/K06+38+fNYtmwZdu/eXe1xpVKJsrKyJrl2eXk5Tp06hd27d+PBBx/EsGHDmuQ6jSkjIwNbtmzB5s2bERcXh/Lycri6umLo0KH49ttvYWlpKXWIRM2qt5eAnOfkcLEWsD1Giymp9es3KFOLeOmoFq/0k+Htk9Wf46k/tLCQAedmyuFqXbdZ3vkyJ1zMrFdoRNSGpaamwsPDQ+owqBbNmmxERkbizJkz8Pb2xt13343i4mJERkYiMzMTEydOhEKhMHqO8PBw3QdItVqN4uLiGusmJSVh3759cHBwQLdu3WBlZYXc3FxcvXoV8fHxmDx5sm7JNLVajV9//RVFRUUICQmBq6srysrKEBsbiwMHDmDw4MHo2rVro7VFfSxYsAC+vr66+4IgNGn3oUqlwunTp/Hxxx/D3t7e7JONmJgYvP/++9i8eTPCwsLw7LPPQqlU4saNG8jIyIBarWayQW2OvWXjLO300VkRWhFY3EfA2ycNj1/NEbE3XsTnI2RwtRZQphYhFwCF3LTrnyzyhkwAtOzaICJqVZot2SgrK8P58+fh7u6OcePGQSarHC/s7u6O/fv3IyoqCr169TJ6ngcffBB2dnYQBAH79u2rNdm4fPkyBEHAhAkTYGVlpSt3cXHB8ePHcePGDYSFhQEAEhISkJ+fj4EDB+rKAKBLly74/vvvER0dLXmyMXPmTPTp00fSGBqTSqVCeXk57O3tG3yuW7du4ccff8SWLVswZ84cbNiwAYLA9TOJGsPNAhEfnNXi6zEyWCuqf10dTKzMEjxtgPt+0uDwzcpkY2SAgC9GyhDoWPvr8dtIFbSiaT3cRERVunTpInUIZESzLX2bkJAAtVqNbt266RINAAgICIC9vT3i4uJMOo+9vb3JHyJVKhXkcrnBt9k2NjYAAAsLC726gOHmMJaWllAoFHp1zZFGo8Fff/2F6dOnw8fHBwqFAnZ2dhg9ejQuXbqkqyeKIs6fP4+ZM2ciJCQEjo6OsLCwgKenJ+bNm4ecnBwAld2SS5cuxRtvvAEAWLZsGQRBgCAICAwMRGpqKl566SUIgoBvvvlGL5ajR4/i7rvv1vt/+u2339C1a1cEBATg22+/Rd++feHs7KwbylZSUoKff/4ZI0aMgKurKywsLODm5oa5c+ciM9P42IqIiAgcOHAAALBixQqo1WoUFhZCrVY3qF2JCHjpqBa9PIB/hdT8JyMurzLZmPeHFpYy4McHZPjgHhlOpIgYsU2Dkoqauyxu5ImIKWKiQUR1d/PmTalDICOa7RN01QdGT09Pg2Oenp64du0aKioqTBpKZSpfX19kZmbi6NGj6NGjh24Y1ZkzZ+Dk5IQOHTro6vr4+EAQBJw9exYWFhZwcXGBSqVCZGQkysvLTep1EUVRtwuuKZRKZZ2+fc/KykJycrLuvoWFBZycnGBpaYldu3bhtddew40bNzB+/Hh06tQJ8fHxOHToEAYNGoTjx4+jT58+0Gg0uHTpEn755ReMHDkS48ePh1qtxtmzZ/H111/j9OnTuHDhApycnPDggw8iKSkJ27Ztw8iRIzFq1CjI5XIEBQWZHPPttFotcnNzsXjxYvTp0wfz58+HlZUVioqKsGHDBixbtgwAMHnyZLi5uSEiIgI//PADjh8/jgsXLsDR0bHGcyclJeHvv/9G+/bt8e6772Lz5s3IysqChYUF7r33XqxZswbBwcH1ipvIXGhFESqNaXWVcjRK796Rm1rsiBXx14zaV5Mqqvy+Bl42wJ6HZZD979q+9sD03VpsiRbxRPfq49kWI0IGEVqwN5KI6qa2ES5kHpot2SgpKQFQ/bbyVT0NxcXFcHJyarRr9urVC2VlZYiJicG1a9d05X5+frjvvvv0ejwcHR0xYsQInDp1Cvv27dOVW1tb44EHHoCXl5fR6xUVFWHr1q0mxzd9+vQ6DSEaO3asQdkXX3yBu+++G1u3bkVMTAz27duH0aNHA6jsrdm0aRNef/11LF68GEePHoVcLsecOXMwc+ZMvUn5V69exXvvvYfNmzfjl19+wdSpU9G7d2/07NkT27Ztw913343Fixfr6qem1n1JG1EUUVRUhAULFmD58uW68v379+Pbb7+FhYUFLl26pJuXkpWVhU8++QQffvghVq5ciaVLl1Z7XpVKhdzcXOTl5aGiogKffvopZs+eja5du+LPP//E3r17MWjQIERGRpr0/0hkro4nibj3J9MmeEc/JkeIa8Oup9aKmH9Yi1ldBfT1rj0RsP7fX5Opnf9JNABgSicBs2TAqVQRT3Sv/rFbrmq53C0R1YupCwyRdOo0jKq8vBznz583+Xb7KklVw1nkcsNvx6qGKDX2kBdBEHSrT91zzz0YOXIkunfvjpSUFBw6dAharf6fN0tLS7i4uKB3794YNWoUBg0aBAsLC+zfv183vKg21tbWGDt2rMm3ur5Ali9fji1btuhuv/32Gx588EFcu3YN58+fR+fOndGtWzckJycjOTkZmZmZ8PDwQOfOnXHixAmUlpZCEAQoFApYW1tDq9WipKQE6enpUCqVCAkJAQD89ddfdYqrrm5PWlQqFa5evYqIiAg88MADAKCLv7y8HIGBgfDy8tINkaqOSqXS/a4VFxfj1Vdfxddff43Fixfjo48+wiOPPIKsrCysXLnS5Bhzc3P1eqmKiopQWFiod807fyfS0tJqvZ+eng7xtq2ReQ1eo67XCHEVsHJAATaOkelunwwsxNejBd39z4aU4ssRWnjbVX8NAMgvKDDpeXz7t4iYXGCy3y3E52mRkC8iIb/y+eSVaZCQL6KkovJLBFdFZdeGp63+85DLBLhaAWl5ZdVeAwDU9cg0KioqJP//4DV4DV5D+mvc+SV2cz0PMl2dejZUKhUuXrxocv3g4GDdxOyqhEKj0RjMf6hKMhp7XsTRo0eRkZGBKVOm6M4dFBQEBwcHnDhxArGxsboP2FUrV40ZMwZ+fn66cwQFBeGnn37CiRMnMGHChFqvZ2FhobdaVGMbPXp0tRPEb926heTkZFRUVOjFfqfs7Gz4+fnh+vXr+OKLL7Bz507cvHkTGo3+uIxbt241euwAIJPJ4O7urtd7lZeXh/T0dGi1WnzzzTcG8z+qKJXKGs9rYWGhN/xuzpw5up+Dg4PRv39/bN68GUePHjU5VhcXF737dnZ2evctLS3h6qr/tbG3t3et9+/sVeE1eI26XsPLVsCLg/XPATjfcV+/t/TOawCA4x3Lftf0PG4WiKjQAuP3O+HOrfa+vyrD91c1+HmCDBOD7XC3vxY4p0VKoaj3PFQaEdmlgJ+LVbXXAIBHusjw9glNnXo3FAqF5P8fvAavwWtIf43s7Gy9z15SPA+qXZ0+3dvb29e6p0Vtbh8qdefY+9qGWNVXUVERrl27hm7duhkkMe3bt8eJEyeQmpqqSzYiIiJgYWFh8GHdxsYGXl5eSEpKgkajqbZnpopWq63TnhdWVlZ6k+UbKiQkBG+//Xa1x1xcXODu7o74+HisWLEC69atQ1hYGJYuXQpfX19YWlrir7/+wqpVqwx6fGpS03hwrVZrkMBU1a/6PajOQw89hMmTJxuUy+Vy+Pj41Pg4pVIJR0dHWFpaQqVS6b0JyGQy2NnZwd7evsmSKKLW4maBiJKKyh4UoHJCeE8Pw4ndk37VYmyQgCe7C+j/v+FVw/wEeNgA30eLeH2ACCuLyvJvokRoxMpVqWoypZOAN09wvgYRUWvUbHM2PDw8cPXqVWRkZBgkGxkZGXBycmrUyeFVE4Zu70qrUvVh+vZjxcXFEEURoigafIiuKq/uXHdesynnbNTE0dERXl5eyMvLw7Rp02pNYOLi4nD27FlYWVnhzJkzug//eXl5evNaqtSUUFhZWemSw9zcXL1jhYWFyM7ONil2BwcHuLu7QxAEWFhYYPr06SY97s4YPTw8EBAQgLi4OCQnJ+uSSI1Gg8LCQhQWFiI0NLTO5yZqDZafrnzP+zun8j1s8xURJ1Iqy94c+M/7xezfNTiWDIiLK/80hLgKusRDnxZBjsDE4H8eq7QQsGKoDI/u1eKeHzSY1VWGmwUiPr0oYogv8FBwzclEJxcBwfYqxBVyHxwiqhv2Mpi/Zks2AgICIJfL8ffff6Njx466D8SJiYkoLCw0GB5UVFQEtVoNBweHen377+joCEEQkJCQgL59++oNw4mNjQVQucdHFWdnZ+Tn5+PGjRt6q1QVFBQgLS0NLi4uRod5Vc3ZMFVjTWoKDg5Gv379sGPHDnz88cd6cyKAyp6jwsJCeHp6QhAEyGQyCIKgl3RduHABe/bs0XucQqHQtdudCYW9vT3c3Nwgl8tx8OBBLFq0CEDlOMZTp04hPj7epNitrKzQtWtXhIaGYufOnThz5gwGDBigOy6KIkpLS1FcXKz3/1VdGwwYMABxcXH44osv8OmnnwIAoqOjcfz4cWi12jr93xC1Jm/dseP311EigMrE4/Zko6Fmd5PBUg588JcWLx/TwkkJPNVDwHtDZJDLau+5GO2Ri+tFXtzUj4jqxNy3JqBmTDasra3Rt29fnDlzBnv27EHHjh11O4g7OTnpbaQHAEeOHEFaWprBt/+JiYm6iTz5+fkAoJtHYmlpqfv22srKCmFhYYiMjMTOnTsREhICpVKJ9PR0XLt2DQ4ODrpvvwGgZ8+eSEpK0l3X1dUVxcXFuHLlCjQaDfr27Wv0OTb1nI2ahIWFYfbs2YiOjsbLL7+MX375BQMHDoRCoUBcXBwuX74Mb29vHDlyBEFBQejVqxcuXLiAgQMH4oEHHkBWVhZOnz5tsHyclZUV2rVrB09PT3z33XdwcHCAp6cnAgMD8eCDD6JHjx4YOHAg9u7di7Fjx+ra+8SJE/Dx8dFbprc2gwcPxpNPPomlS5diyJAhGD9+PEJCQlBSUoKYmBhERETojtekU6dOmDRpEk6fPo1Vq1bh+vXrCAkJwYULF3D8+HF07doV8+fPb0gzE7VYVT0Vxhz9l2n1ajvfv0Jkte7HUZMJgRVYfb3ODyOiNi45ORlubm5Sh0G1aNZ0sHv37lAqlbh8+TJOnToFhUKB9u3bo3///iYPoYqPj9f1TFQ5f/48gMpJP7cPlenfvz8cHR1x9epVXLp0CRqNBra2tujatSt69+6tt/Sth4cHJkyYgEuXLiE+Ph7R0dFQKBTw8PBAz5490a5du0ZogaYhk8nwwAMPwN/fH6tXr8ahQ4ewatUqCIIANzc39O3bF8888wwAoGPHjli0aBFkMhl+++03/Pe//4W9vT0mTpyI0NBQXQ9FleHDh+Oll17Cl19+iRUrVkClUiEgIAAPPvggBg4ciNdffx0ffPABjh8/jkOHDqFnz554//33sWXLFpOTDTs7Ozz55JMIDg7GmjVrcPLkSezatQuWlpbw8vLCAw88gKlTp5rUBs7Ozvj44491Sxg7Oztj3rx5eO+996qdKEtE5uGebj7oHglEZkkdCRERNSZBNDYRgYiIqImFh4djf3l3vH5Ca9JQqshH5Qhz56RyoraurKxMt/IpmafGG6xLRETUAFM6C5yzQUR1kpKSInUIZASTDSIikly7du3Q3klAz5rXgSAiMnDnpqVkfphsEBGR5KqW2X6kiwxGFq4iItKpbdNfMg9MNoiISHJVQyE4lIqI6qJTp05Sh0BGMNkgIiKzEego4C4PgJ0bRGSKy5cvSx0CGcFkg4iIJNelSxfdz490kTHZICJqJZhsEBGR5JKSknQ/T+4kQFtLXSKiKh4eHlKHQEYw2SAiIskVFRXpfg5wFNDHk0OpiMg47rFh/phsEBGR5O78wMChVERkips3b0odAhnBZIOIiCTXsWNHvfscSkVE1Dow2SAiIslFRUXp3fdzENDPi0OpiKh2XPrW/DHZICIis/RIF/6JIqLaZWRkSB0CGWEhdQBEREReXl4GZZM7CdgeC4NN/lyRj07OLs0UGRGZs/z8fKlDICOYbBARkeSqSzZ87AX8Od3wz1R4eBKUFq7NERYRmTmFQiF1CGQE+6iJiKhFcXJykjoEIjIT3bp1kzoEMoLJBhERtShubm5Sh0BEZiI8PFzqEMgIJhtERNSiXLt2TeoQiIjIREw2iIiIiKhFYk+n+WOyQURELUpgYKDUIRCRmbCzs5M6BDKCyQYREbUoxcXFUodARGYiISFB6hDICCYbRETUomRlZUkdAhERmYj7bBARUatwLEnEpr+1UodhMoUMWD5YBncbQepQiFqsjh07Sh0CGcFkg4iIWpQePXpUW/7ZRQ1+vgbIWshnd40W8HcQ8caAFhIwkRnKycnhvA0zx2SDiIhalOjoaHTt2lWvrFglYvcNQCtW3loCCw5kJmqwW7duISAgQOowqBZ8qyMiohZFpVIZlO25IaJcI0EwRCQpuVwudQhkBJMNIiJqURwcHAzKfriqhZyjkYjanLCwMKlDICOYbBARUYvi5eWld79IJWLPDUDTQoZPEVHjiYyMlDoEMoLJBhERtSixsbF693ffEKFqOYtQEVEj0mr54jd3TDaIiKhF4xAqorbLxcVF6hDICCYbRETUovj7++t+LlSJ+J1DqIjaLCcnJ6lDICOYbBARUYtSXl6u+/m36yIqOIqCqM26ceOG1CGQEUw2iIioRcnIyND9zCFURETmjckGERG1SAXlIvbGcwgVUVsWFBQkdQhkBJMNIiJqUarW1d91XYS6hQ+hKiwslDoEohatoKBA6hDICCYbRETUosTFxQFo2BCq+/wFHJoqQ94LchTMl+P8TDmmdq79ZAKAR7sJ+HWiDDfnyVG0QI7Lc+R4Y4AApZFNjAf5AOJiC4iLLeBq/U95UVFR/Z4AEQEAcnJypA6BjGCy0UDu7u5mtXtlQUEBpkyZAjc3N8hkMri7u0sdEhFRoyorK0NemYj9CfUbQjUnVMCBKTJUaIDX/9Ti5WNaHE8W4Wdf++NsFMA398vhbiNgbYQWLx7W4myaiGV3y7D34Zr/nAoAPhsuR5GK472IGpsgcNKWubOQOoAqL7zwAiIiInD16lVkZWXBzc0NWVlZNdbftGkTPv74YyQmJqK0tBSurq4YNmwY3n333UYfv/fvf/8bzs7OeO211xr1vE3hpZdewvbt2/HII4+gR48eTb4k3Jdffonz58/jyy+/bNLrEBFVsbe3r/cQqgAHYM19Mnx2UcSLR24/gfFEQKUB7t6ixunUf8o2XBaRUCDg/wbJcZ+/iEM3Dc8zr4cAP/vKui/21v9g5O3tXfcnQUQ6PXr0kDoEMkIQRdEsvmoRBAG2trYIDg5GXFwcrK2ta0w2/u///g9LlixBhw4dMGnSJNjZ2eHcuXPYu3cvXF1dERsb26gfst3d3eHl5YXLly/X6ZgUQkJCUFpaisTExGa53pgxY7B//36Yya8REbUBZWVleGiPBQ4k1L1n4/0hMizsLcDjcw0KVICtAiiuaFg8oW7A5TkWeOGQBqsv6QfkbAXEzpXj7VNaeNgIWHq3DG5r1MgpBSxkwDMdsrBqAhMOovqKiopCaGio1GFQLcymZyM8PFyXnfr7+6O0tLTGumvXroWTkxPCw8NhZ2enK587dy42btyIn376CfPmzWvymJtbRUUFSktL4eDgUGOd3NxceHp6NmNUTUer1SI/Px/Ozs5Sh0JEZuTs5Vj8kdC1XkOoRgQIuJoLjG0vYMVQGXztBeSWilgTLmLJSa0J/RuGvGwreyuyq/mz9c4gGdJLgHURIt4aaDjcQ6tt4TPciSSmVqulDoGMMJs5G3XpBispKYGdnZ1eogEAPj4+AGBQXpMvv/wSXbp0gVKphJWVFbp06WIwHEgQBGRnZyMqKgqCIOhuUVFRevXOnj2Lfv36wcrKCjY2NhgyZEi1G81kZWVh1qxZ8PLygkKhgIODA4YPH46IiAi9eu+//z4EQcDWrVvxzDPPwNPTE1ZWVlizZk21z6WqflZWll6styddf/zxBwYNGgR7e3soFAq0a9cOzz33HFQqld659u3bhzFjxsDb21uvbdauXatXLywsDPv379e1U9Xt/fff1x2vbs5IVXy3x7Z9+3bdY9988034+vpCqVTilVde0dVZtWoVunbtCisrKyiVSnTq1Kna9ti4cSNCQ0Nhb28PS0tLuLm5YfDgwTh//ny1bUdELcvRLAeo69mZGuwM+NkDG8fI8HWUiId/1WBvvIi3Bsrw7pD6/Un8d18B+eUi9sbrBxXmBjzVQ8CiI1poa4jXysqqXtckokrcQdz8mU3PRl0MGDAA+/fvx/Tp07FgwQI4OTnhyJEj+OyzzxAaGoopU6YYPcdbb72F5cuXo127dnj66acBVH7gfeqpp5CWloYlS5YAAFasWIH/+7//g729PRYuXKh7vK+vr+7n7OxsjBo1CsOGDcP999+PiIgI7Nq1C5MnT8bFixd19bKysnDXXXchKysL48ePR7du3ZCamooffvgBQ4YMwenTp9GtWze9OF9//XWo1WpMmzYNjo6O6N69e7XPZ+zYsVAoFAax9uvXD0DlB/B58+bBy8sLc+bMgaurK86cOYMvvvgCly9fxvHjx3Xn2rp1K+Lj43H//fcjMDAQ2dnZ2LFjB5555hmUlJRg0aJFAIDXXnsN7777Lq5cuYIVK1boHj9y5Eij7V+TL7/8UjfJ3dvbG4GBgQD+6bXq3bs35s+fD7lcjj179uD5559HWloali9fDgDYsWMHHn/8cfj7+2PevHlwdnZGSkoK/vzzT0RFRaFPnz71jo2IzMPRPE/IBEAUAUsjq0BVKddU/munAOQyAa8c1+Cjs5UZwM44ES7WwIK7BLx3Biiqw7Cq1/oLGBkowzN/aJBfrn9s1X1y7I0X8UdizZmRrY2N6RcjIgNubm5Sh0DGiGbIz89PdHNzq/F4ZmameM8994gymUxE5aw+EYA4ZswYsayszOj509LSRKVSKXp6eopZWVm68qysLNHDw0NUKpVienq6rtzNzU0MDQ2t9lxubm4iAPHTTz/VK580aZIIQDx79qyubMqUKaJCoRCPHj2qVzcqKkq0srISR48erSt77733RACit7e3mJ+fb/Q51RZrYWGh6OjoKHbt2lUsLy/XO7Z48WIRgLht2zZd2a1btwzOm5+fL3p7e4s+Pj565aNHjxZr+jUKDQ2t9v/x8uXLIgDxySef1JVt27ZNBCDa2tqKCQkJevUPHjwoAhAfffRRg3MNHDhQtLKyErOzs0VRFMVp06aJAAzOQUStQ06JVpT/RyViRYU49Ae1yY/r/FWFiBUVYmG5VhRFUfRbW3m/6jZrT+W5hmzVL6/tNnWXWtRoteL6CE21x8rVWjF4wz9lS05qRFEURdfVlfct/lshPrczufEbiagNuXTpktQhkBFmM4yqLpRKJXx8fDBo0CB8+OGHWL16NcaNG4f9+/fj4YcfNvr4n376CeXl5Xjsscf0MmI3NzfMmTMH5eXl2L59u8nxODs7Y/78+XplI0aMAADdxHGtVou9e/ciLCwMHTp0QHJysu7m6OiILl264K+//jI498yZM2udo2GKH3/8Efn5+ZgxYwYyMzP1rj116lQAwO7du3X1b++SLCgoQEpKCgoKCtCvXz+kpKQgOzu7QfHUZuzYsQgICNAr27BhAwRBwHPPPacXe3JyMsaNG4eysjLs27cPAODo6AgA+OqrrwyGh9VFbm4uysv/+ZqyqKhIb/MtlUplsLZ3WlparffT09P1JtLzGrwGr1H3axSqAI1YOffhao6IOXs1Jt3S/redRer//s0o0bs8Mv9331lp2jKaIwIEfHu/DHtuiHj6D8N5FyuGyrAtRoRKU7kCVoAD4KSsPOZnD3jbVv4simKL/v/gNXgNqa9x++Ob83lQHTRzcmOS2no21Gq12LVrV7Fz586iRqPROzZr1iwRgLhly5Zazz9//nwRgPjDDz8YHNuyZYsIQFywYIGuzFjPRteuXQ3Kq76p/+CDD0RRFMWEhAS9XpjqboIg6B5f1bOxcePGWp9LdfHcGeuCBQuMXnvs2LG6+gkJCeIDDzwgOjg4VFv3ypUrurqN3bPx5ptvGtTv06eP0fg//PBDURRFMTk5WQwKChIBiFZWVmKfPn3EV199VUxMTKxTOxKR+QpZWyAKJvY+3HnbcqXy70bQl/rlj+2t7NkY+L3xc/TbXNlDciJZK1qtrL6OMZcytKLFfyvENw4XNWlbEbV21Y3GIPPS4uZs7Nq1C1euXMGiRYsgk+l3zMyePRubN2/GwYMHMX369GaL6c44ble10kjVvz179sS///1vk89t6mT32oj/y/AXLlyIvn37Vlunam6EVqvFsGHDkJycjGnTpqFfv35wcXGBXC7HV199hUOHDkGj0Zh03Zo22qmoqHlAtE0145dFUYQgCPj2228hl1c/QLtqboqPjw9iYmLw66+/Ys+ePTh79iw+/PBDrFq1Cj/99BPGjRtnUuxEZL4e62mF1/40ZWcMQz/GiJjeBXg8TIY3T1S+LwsAHguVIadUxIWMf+q2r+woxY38f8pCXIA9D8mRUAA8sFODshoWwpn4i+H75L9CBPwrRIZZv2uQ/L8vVmt7PyQi44qLizlJ3My1uGQjISEBAKr9wFv1pm1sGbTg4GAAlcvtTps2Te9YZGSkXh2gcXan9Pf3h42NDYqLi5s1EQIq994AKhMXY9f+888/kZCQgCeeeALr16/XO1bdxn21tY2DgwPi4uIMyq9cuWJK2DpBQUG4cOECOnbsiAEDBhitr1AoMHnyZEyePBkAcPz4cdx7771YtmwZkw2iVqCvMgla+Nfrsb9eE3EwUYvX+gtws5YhIkvExI4ChvgKmHdAA9Vtf1oOTa38ciNofWWhnQLYP1kOZytgxXktxrXXf/+7nifiTNo/17lTT4/K+nvjRd0+G8XFxQCc6vVciKhy8Z2q1UjJPLW4ORt33XUXAOCXX34xGKe3bt06ADD6gXTKlClQKpX45ptv9Mbp5eTk4JtvvoFSqdTNZQAqlyYsKChoUNxyuRxjxoxBXFxcjcvXNtVGfNOnT4eDgwM+//xzpKamGhwvLCzUtYOFRWX+Kd6xSd/Jkydx4sQJg8fa2lYOPK7uvB06dNCbTwFUJokrV66sU/xPPPEEgMrd0av7FjA+Pl73c3JyssHxvn37wtLSEvn5+QbHiKjlcUYB+nhW9kjUx8RftFh1UcT4DgJWDpPBy1bAjD0arI+sva/E1RrwdxAglwn48B45vhunf3uqR4v7k0pE1OTMpmfjo48+0vVa5OfnQ61W49lnnwVQOcSnaujR0KFDMXjwYJw4cQKdO3fGpEmTYGtri4MHD+Kvv/5Cp06ddB9Oa+Lp6YmXX34Zy5cvR48ePXTfgG/fvh3p6elYunSp3v4Q3bt3x++//47HH38c3bp1g0wmw5w5c+rcbbd27VpcvHgRL7zwArZv346+fftCqVQiISEBx44dQ9euXfU+mDcWJycnrFmzBnPnzkVISAgmTJiA4OBg3Lp1C7GxsTh69Cg2bdqEyZMno1+/fvDz88OmTZtQUlKCkJAQxMTEYOfOnQgICMD169f1zj1w4EDs2LEDM2bMwP333w9LS0sMHz4c3bt3x0svvYTvv/8ejzzyCGbPng1LS0vs3r3b5GFYVUaPHo158+bhyy+/RIcOHTB27Fj4+PggNTUVEREROHv2rK43a9q0acjIyMCQIUMQGBiIkpIS/PrrrygrKzPoxSKilsnW1haPdJHhYqYWYj3GUhVXAAuPaLHwSO31qno0qiQWAMJ/6r+B2LJTWiw7pT+Z3MvLq97nI6K67dNG0jCbZGPz5s0GG+V98cUXAIDQ0FC9eQ4HDhzAa6+9hl9++QVr1qyBKIpwc3PDo48+ik8++QQKhcLo9d555x34+Pjgk08+0V0nKCgI69atM9h9fM2aNZgxYwZ+/PFHlJSUQBRFjBgxos7Jhru7OyIiIvDKK69gz549OHnyJGQyGVxdXdGrVy8899xzdTpfXcycORNBQUFYsmQJ9uzZg4KCAtja2sLb2xuzZ8/G3XffDaByCNLevXvxzDPPYPfu3dixYwf8/f2xcuVKXLx40SDZePHFF3HhwgXs27cPx44dgyiKeO+999C9e3d0794dGzZswLJly7BmzRrY2dnhgQcewPz583VzLEy1bt06DBgwAKtXr8Z3332H8vJyODg4ICgoCG+88Ybe89y0aRN+/fVXFBYWwtraGv7+/lizZo0ueSWili0gIACTywQsOip1JA2XlZUFgAkHUX1FR0eja9euUodBtRDEO8fLEBERmbHw8HD07NkT/b5T43x6/SaKmwMLGfBUUAZWT+J4c6L6qno/IPPFAaZERNQiPdJFVu95G+ZCqVRKHQJRi9bQvcio6THZICKiFqVdu3YAgMmdBBhup9ey2DfC8uZEbRnnPZk/JhtERNSiVC257WsvoL93/VelMgfZd+xcTER1ExsbK3UIZASTDSIialFSUlJ0Pz/ShX/GiIjMGd+liYioxXo4uCX3awCOjo5Sh0DUovn712+DT2o+TDaIiKhF6dKli+5nH3sBA9u13D9mdd13iIj03bnBM5mflvr+TEREbVRSUpLe/ekhsha7/G1RUZHUIRC1aBkZGVKHQEYw2SAiohblzg/oD3dq2UOpiIhaMyYbRETUolhZWend97YTMMinZa5K5enpKXUIRC1aWFiY1CGQEUw2iIioRenYsaNB2fSQlvnnLIdL3xI1SFxcnNQhkBEt892ZiIjarKioKIOyh1roUCq1Wi11CEQtWllZmdQhkBFMNoiIqMXzshUwxLdlDaXSagGl0lLqMIhaNHt7e6lDICMspA6AiIioLry8vKotfzxMhuRCbYtZmcpSBkwN4wcloobw8fGROgQyQhBFsaW8LxMREbUq4eHh6Nmzp9RhELVYfA2ZPw6jIiIiIiKiJsFkg4iISCK+vr5Sh0DUovE1ZP6YbBAREUlEo9FIHQJRi8bXkPljskFERCSRtLQ0qUMgatH4GjJ/TDaIiIiIiKhJcDUqIiIiiVRUVEChUEgdBlGLxdeQ+WPPBhERkUTi4+OlDoGoReNryPwx2SAiIpJISUmJ1CEQtWh8DZk/JhtEREQSsbW1lToEohaNryHzxzkbREREElGpVLC0tJQ6DKIWi68h88eeDSIiIolcuXJF6hCIWjS+hswfkw0iIiIiImoSTDaIiIgk0q5dO6lDIGrR+Boyf0w2iIiIJCIIgtQhELVofA2ZPyYbREREEklJSZE6BKIWja8h88dkg4iIiIiImgSXviUiIpJIeXk5lEql1GEQtVh8DZk/9mwQERFJJCkpSeoQiFo0vobMH5MNIiIiiRQVFUkdAlGLxteQ+WOyQUREJBErKyupQyBq0fgaMn+cs0FERCQRtVoNCwsLqcMgarH4GjJ/7NkgIiKSSFRUlNQhELVofA2ZP6aCRHfQaDSIjY2VOgwiagNu3LjBlXSIGkDK11CnTp0gl8sluXZLwmSD6A6xsbHo2rWr1GEQERGRGbty5Qq6dOkidRhmj3M2iO7QFD0bRUVF6NevH86ePQs7O7tGPXdbwPZrOLZhwzV2G6anp2P48OE4fPgwvLy8GiFC88bfwYZjGzZMY7cfezZMw2SDqBkUFBTA0dER+fn5cHBwkDqcFoft13Bsw4Zr7DZMTk6Gn58fkpKS4Ovr2wgRmjf+DjYc27Bh2H7S4ARxIiIiIiJqEkw2iIiIiIioSTDZIGoGSqUSS5Ys4aoz9cT2azi2YcM1dhs6ODhg6NChbWY4B38HG45t2DBsP2lwzgYRERERETUJ9mwQEREREVGTYLJBRERERERNgskGERERERE1CSYbRE0oJSUF77//PoYOHQpvb2/Y2tqiW7duePnll5GTk1PtY1JTUzF79my4u7vD2toaffr0wbZt25o5cvOxbt06zJgxAyEhIZDL5RAEodb6MTExmDhxIpydnWFra4shQ4bg8OHDzRStedFqtVi5ciVCQkJgZWUFPz8/vPTSSyguLpY6NLPz/vvvY8qUKWjfvj0EQUBgYGCt9f/66y+MGDEC9vb2cHBwwJgxYxAeHt4ssZqj2NhYvP322xgwYADc3d1hb2+Pnj174t133632942vU0MxMTGYMWMGunTpAkdHR9jY2CAkJASLFi1CWlpatfXZhrUrKSnRvaaff/55g+Nsw+bBCeJETWjt2rVYsGABxo0bh8GDB8Pe3h5nz57FN998Ay8vL5w7d05v5+Dc3Fz06dMHmZmZWLRoEXx9fbFlyxYcO3YMX3/9NR577DEJn400AgMDkZOTg169eiE+Ph7Jycmo6W3r+vXr6NevHywsLPDiiy/C0dER69evR1RUFPbu3YsRI0Y0c/TSWrBgAVatWoVJkybh/vvvR3R0ND777DMMGTIEBw8ehEzG75uqCIIAFxcX3HXXXbhw4QIcHByQkJBQbd0zZ85g2LBh8PHx0X2AWb16NTIzM3Hq1CmEhYU1Y+Tm4dVXX8WaNWswfvx4DBgwAAqFAkeOHMFPP/2E7t2748yZM7C2tgbA12lNDh06hHfffRcDBgyAr68vLCwscPnyZWzcuBEODg4IDw+Hh4cHALahqRYvXox169ahqKgIzz33HFavXq07xjZsRiIRNZmoqCgxLS3NoHz9+vUiAPGll17SK3/55ZdFAOKuXbt0ZWq1Wuzbt6/o4uIiFhYWNnnM5iY+Pl7UaDSiKIriuHHjxNretqZMmSLKZDLx0qVLurLCwkLR399f7NSpk6jVaps6XLMRFRUlCoIgPvTQQ3rlq1atEgGI33//vUSRmafr16/rfu7WrZsYEBBQY92+ffuK9vb2YnJysq4sOTlZtLe3F0eOHNmUYZqtc+fOiXl5eQblb7zxhghA/Oyzz3RlfJ3WzU8//SQCED/88ENdGdvQuAsXLohyuVz873//KwIQn3vuOb3jbMPmw6+1iJpQt27d9HouqkybNg0AEBUVpVe+ZcsWdOjQAQ8++KCuTC6X44UXXkBubi5+//33pg3YDAUGBpr0DXxxcTF27dqFYcOGoWfPnrpyOzs7PPHEE4iNjcW5c+eaMFLzsnXrVoiiiBdffFGv/Mknn4SNjQ2+++47aQIzU+3btzep3rVr13Du3DlMmTIFPj4+unIfHx9MmTIFBw8eRHp6elOFabb69OkDR0dHg/I73+v4Oq27gIAAAMCtW7cAsA1NodFo8OSTT2LMmDF46KGHDI6zDZsXkw0iCSQnJwMAPD09dWVpaWlISUnBgAEDDOpXlfHNr2aRkZEoLy/HwIEDDY61xfY7d+4cZDIZ+vXrp1duZWWFnj17tqm2aExV7VbT75koirhw4UJzh2W27nyv4+vUuLKyMmRnZyM5ORkHDhzAU089BQAYO3YsALahKVauXImrV6/qDZu6HduweTHZIJLAkiVLAACPPvqoriw1NRUA9L4trVJVlpKS0gzRtUxsP32pqalwc3OrdqdcHx8fZGdnQ6VSSRBZy8bfM9NpNBq88847sLCwwCOPPAKA7WeKDRs2wN3dHX5+fhg9ejTy8vLw3XffYciQIQDYhsbEx8djyZIlePvtt2tc6IFt2LwspA6AqCXIy8vDJ598YnL9+fPnw8XFpdpj//3vf7Ft2zbMmzcPw4cP15WXlJQAQLUfDq2srPTqtDSN2X41ac3tVx8lJSXVtgWg3x6WlpbNGVaLx98z07344os4ffo03nvvPXTu3BkA288UEydOREhICIqKinDp0iXs2rUL2dnZuuNsw9o9/fTTaN++PRYtWlRjHbZh82KyQWSCvLw8LFu2zOT6M2fOrPbD8oYNG/Dyyy9j3LhxBt27NjY2AIDy8nKDx5WVlenVaWkaq/1q05rbrz5sbGyQmZlZ7bG22B6Nhb9npnnrrbewevVqzJs3D6+99pqunO1nnK+vL3x9fQFUJh4PP/ww+vbti5KSErz22mtsw1p89913+OOPP3D8+HEoFIoa67ENmxeHURGZIDAwEKIomnzr2LGjwTm+/vprzJs3D6NGjcKOHTsM3gjbtWsHoPqu26qy6rp8W4LGaD9jWnP71Ue7du2QnZ1d7R/TlJQUuLm5sVejHvh7ZtzSpUuxfPlyPPbYY1i7dq3eMbZf3XXv3h29evXC559/DoBtWJPy8nIsWrQIY8eOhZeXF65du4Zr164hMTERAJCfn49r164hLy+PbdjMmGwQNYOvv/4aTzzxBEaMGIFffvml2q5bb29v+Pj44MyZMwbHqsr69OnT5LG2VGFhYVAqlTh9+rTBsbbYfn379oVWq8XZs2f1ysvKyhAeHt6m2qIx9e3bFwBq/D0TBAG9e/du7rDMxtKlS7Fs2TI8+uij2LBhg8EmnHyd1k9paSlyc3MBsA1rUlpaiqysLOzZswfBwcG627BhwwBU9noEBwdjw4YNbMPm1nyr7BK1TRs3bhRlMpl43333iSUlJbXWXbx4cY37bDg5OYkFBQVNHa5ZM7bPxuTJk0WZTCaGh4fryqrWTQ8ODm5T66ZHRkbWus/G5s2bJYrM/BnbZ6NPnz6ivb29mJKSoitLSUkR7e3txfvuu68ZIjRPy5YtEwGIs2bN0u2NUx2+TqtX3Z5MoiiKhw8fFmUymTh8+HBdGdvQkEqlErdt22Zw+/zzz0UA4pgxY8Rt27aJMTExoiiyDZsTdxAnakK7du3CpEmT4ODggI8++ki3g24VOzs7TJw4UXc/JycHvXv3Rk5ODhYtWgQfHx9s3boVR48exYYNG/D444838zOQ3m+//YaIiAgAld9MxcTE4J133gEAODk56XZwBir3QOjXrx8UCgUWLlwIBwcHrF+/HpcvX8aePXswevRoSZ6DVF544QWsXr0akyZNwtixYxEdHY1Vq1Zh0KBBOHz4MHcQv83mzZt1wy0+++wzqFQqvPTSSwAq9zmYNWuWru6pU6dw7733wtfXFy+88ILuMRkZGTh58iR69OjR/E9AYmvWrMHzzz8Pf39/vPPOOwa/W56enhg5ciQAvk5rMmnSJKSlpWH48OEICAhAWVkZLly4gB9++AE2NjY4evSobk8ItqHpEhISEBQUZLCDONuwGUmd7RC1ZkuWLBEB1Hir7tvT5ORkcebMmaKrq6uoVCrFXr16iT/88EPzB28mHn300Tq135UrV8Tx48eLjo6OorW1tTho0CDxjz/+aP7AzYBarRb/85//iJ06dRItLS3Fdu3aiQsXLmyTO9EbM3To0Bp/z4YOHWpQ/9SpU+Lw4cNFW1tb0c7OThw1apR44cKF5g/cTNT2Oq2uDfk6NfTjjz+K48aNE319fUWlUilaWVmJnTt3Fp9//nkxMTHRoD7b0DTx8fHV7iAuimzD5sKeDSIiIiIiahLsQyciIiIioibBZIOIiIiIiJoEkw0iIiIiImoSTDaIiIiIiKhJMNkgIiIiIqImwWSDiIiIiIiaBJMNIiIiIiJqEkw2iIiIiIioSTDZICIiqqc5c+ZAEAQIgoDQ0FCD41qtFsuXL0eHDh2gUCjQoUMHAMBHH32EkJAQaLXael137dq18Pf3R3l5ucGxTz75RBeTIAjIzs6u1zWIiBqDhdQBEBERmaP9+/djzJgxNR7ftGkTAMDNzQ0rV66Ek5OTQZ3PP/8cb7/9Nl566SV0794d3t7eKCgowIcffoj//Oc/kMn0v/NbtmwZli1bhr///htdunTROzZ37lxs2rQJu3btwpw5c7B06VKsW7cO8+fP16s3ZswYuLm5YefOnfj555/r+ezrp6KiAhEREcjMzERWVhbKy8sxdOhQdO7cWa9eZmYmYmNjkZaWhsLCQiiVSnh6eqJPnz7VtuOdUlNTsXv37mqPTZgwAZ6ennWOqa7nJSLTMNkgIiKqRkREBABg1apVcHZ2Njg+evRoHD58GLa2tpg5c2a159i4cSNGjhyJFStW6Mo++eQTqNVqTJ8+3aD+M888gw8++ACffPIJ1q1bpyv/7LPPsHHjRixfvhzjxo0DADz66KP4+OOP8cILL0AQBF3dkJAQhISE4Nq1a82ebJSVleHixYuws7ODi4sL0tLSqq0XERGB9PR0tG/fHq6urigpKcHff/+NnTt3YuLEiXBxcTHpeqGhoXB3d9crc3R0rFdMdT0vEZmGyQYREVE1IiMj4ejoiOeff17vw7ypysrKEBERgWXLlumVb9y4EePHj4eVlZXBYzw8PDBjxgxs3rwZ7777Ltzc3HDs2DEsWrQIDz/8MN544w1d3alTp+Kjjz7CkSNHMHz48Lo/wSZgY2ODmTNnwsbGBllZWTUmO2FhYRg+fDjkcrmurEOHDti+fTvCw8NNfj5eXl5o3759o8RU1/MSkWk4Z4OIiKgaERER6NWrV70SjccffxzW1tbQaDR48803IQgCBg4ciPj4eERGRmLEiBE1PnbhwoUoLS3F2rVrkZSUhKlTpyIkJATffPONXr3evXvDxcUFv/76a53jaypyuRw2NjZG63l5eeklGkBlz4GzszPy8vLqdE2VSlXr3BdTY6rreYnINOzZICIiuoNKpUJMTAwGDx5c7QRrR0dHKBSKGh8/Y8YMKBQKrFu3Dp9++ilcXFwQEBCAU6dOAQDuuuuuGh/brVs3jBo1CmvWrMEvv/yCiooK/PLLL7CzszOoe9ddd+HkyZP1eIaGtFotVCqVSXWVSmW9krDaiKKI0tLSaoes1eTYsWOoqKiAIAjw8vLCgAEDDIY/1UdTnZeoLWKyQUREdIcrV66goqICa9euxdq1aw2Ox8TEoFOnTjU+fvjw4Th06BBsbW3x/PPP6yaCv/XWWwCAoKCgWq+/aNEijBkzBpmZmfj99991q1jdqX379ti8ebOpT6tW6enpNU6OvtP06dNhb2/fKNetcu3aNRQXF6N3795G68pkMgQFBcHPzw9WVlbIy8tDREQEdu3ahQkTJsDNza1eMTTVeYnaMiYbREREd4iMjAQAfPPNN/Dx8TE4HhwcbNI5unXrprfiVE5ODiwsLKrtpbhddHQ0gMpkYvTo0TXWc3Z2RmlpKUpKSuo1VOh2rq6uGDt2rEl1ra2tG3StO+Xl5eHEiRPw9PSsNYmr4uXlBS8vL72yoKAgbN++HWfPnjX5eTTXeYnaMiYbREREd4iIiICFhQWmT58OS0vLep+jtkShJgcPHsTixYsRHByMuLg4HDhwAKNGjaq2riiKANAoQ5qUSiV8fX0bfJ66Kikpwd69e2FpaYkRI0YYLAdsKkdHRwQGBiI+Ph5arbbe52mu8xK1FXzFEBER3SEyMhJBQUH1TjTy8vKQlJSEsLAwvXJXV1eo1WoUFhZW+7gbN25g2rRp6NWrF86dOwcPDw+sXLmyxuvcunULNjY2jdLToNFoUFJSYtKtsSZOq1Qq7N27FyqVCmPHjoWtrW2DzmdrawutVgu1Wt0o8TX1eYnaAvZsEBER3SEyMhIDBgxo0OMBoHv37nrlISEhAID4+HiDY0VFRZgwYQIUCgV+/vlnODo64tlnn8WyZcsQHR1tsMlf1XmqK6+PjIyMZp2zoVarsW/fPuTn52PcuHF1mhhek8LCQsjl8lon75vTeYnaAiYbREREt0lPT0dmZqYuMaiPqg0B70woBg4cCAA4f/683jFRFDFr1izExMTgyJEjuuFMzz77bLWb/FW5ePEiZsyYUe84b9eccza0Wi0OHTqEjIwMjB49utadudVqNYqKimBlZaXbm6S0tNQghpycHCQmJsLPz6/ew8qa6rxEbRmTDSIiottUJQpZWVn47rvvDI736NHDYHjUnSIjI+Hj42OwE3b79u0RGhqKgwcPYu7cubrypUuX4pdffsG6deswaNAgXbm7uztmzpyJzZs347333oOrq6vu2IULF5Cbm4sJEybU63neqbHmbERFRUGlUqGkpAQAkJiYiOLiYgCVO3NbWlrizJkzSExMhL+/P8rLyxEXF6d3jtsn4GdmZmL37t2466670KdPHwDAoUOHIJfL4enpCWtra9y6dQtXr16FhYUF+vXrV6+Y6nNeIjKOyQYREdFtqoZAbdy4ERs3bjQ4/u2335qUbNzZq1Fl7ty5ePvtt3Xfov/8889455138PTTT2PevHkG9RcuXIivvvoKa9eu1dtBfNu2bfD39zeb3cOrREZGoqioSHc/ISEBCQkJACqTCEtLS+Tk5AAAbt68iZs3bxqcw9hqX4GBgYiLi8Ply5ehUqlgbW2NwMBA9O7dG46OjvWKqT7nJSLjBLFqKQsiIiKqkzlz5uDw4cO4ePEiLCws4OTkZPQx+fn5aN++PT766CM8/vjj9bpueXk5AgMD8eqrr2LBggV6x8rKylBUVISPPvoIK1asQFZWFveHICLJcDUqIiKiBkhKSoK7uzsGDx5sUn1HR0f8+9//xooVK+q9qtPGjRuhUCjw9NNPGxxbu3Yt3N3dsWLFinqdm4ioMbFng4iIqJ6uXLmC1NRUAICdnV2DVrBqLElJSYiJidHdHzp0KFdRIiLJMNkgIiIiIqImwWFURERERETUJJhsEBERERFRk2CyQURERERETYLJBhERERERNQkmG0RERERE1CSYbBARERERUZNgskFERERERE2CyQYRERERETUJJhtERERERNQkmGwQEREREVGT+H9Pl64EfRcl4gAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 800x650 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "This plot shows which features push the prediction higher (red) or lower (blue) for this specific observation.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# LOCAL EXPLANATION: Explain a single observation\n",
+    "# Select an observation (e.g., index 10)\n",
+    "observation_idx = 10\n",
+    "\n",
+    "print(f\"=== LOCAL EXPLANATION for observation {observation_idx} ===\")\n",
+    "print(f\"Actual area burned: {y.iloc[observation_idx]:.2f} hectares\")\n",
+    "print(f\"Predicted area: {best_model.predict(X.iloc[[observation_idx]])[0]:.2f} hectares\")\n",
+    "\n",
+    "# Create SHAP force plot for local explanation\n",
+    "if isinstance(regressor, RandomForestRegressor):\n",
+    "    shap.force_plot(\n",
+    "        explainer.expected_value, \n",
+    "        shap_values[observation_idx], \n",
+    "        X_transformed[observation_idx],\n",
+    "        matplotlib=True,\n",
+    "        show=False\n",
+    "    )\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n",
+    "    \n",
+    "    # Bar plot showing feature importance for this observation\n",
+    "    shap.waterfall_plot(shap.Explanation(\n",
+    "        values=shap_values[observation_idx],\n",
+    "        base_values=explainer.expected_value,\n",
+    "        data=X_transformed[observation_idx]\n",
+    "    ))\n",
+    "else:\n",
+    "    shap.plots.waterfall(shap_values[observation_idx], show=False)\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n",
+    "\n",
+    "print(\"\\nThis plot shows which features push the prediction higher (red) or lower (blue) for this specific observation.\")"
+   ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "*(Answer here.)*"
+    "**Which features would you remove?**\n",
+    "\n",
+    "Based on the SHAP analysis above, I would consider removing features with the lowest mean absolute SHAP values (listed in \"Least Important Features\"). These features contribute minimally to the model's predictions.\n",
+    "\n",
+    "**Why remove them?**\n",
+    "\n",
+    "1. **Simplicity**: Fewer features make the model easier to interpret and maintain\n",
+    "2. **Reduced overfitting**: Removing irrelevant features can improve generalization\n",
+    "3. **Computational efficiency**: Fewer features mean faster training and prediction times\n",
+    "4. **Data collection cost**: In production, collecting and maintaining unnecessary features has costs\n",
+    "\n",
+    "**How to test if features are enhancing performance?**\n",
+    "\n",
+    "1. **Recursive Feature Elimination**: \n",
+    "   - Systematically remove the least important features one at a time\n",
+    "   - Re-train the model and evaluate performance using cross-validation\n",
+    "   - Compare MAE scores before and after removal\n",
+    "\n",
+    "2. **Ablation Study**:\n",
+    "   - Create models with different feature subsets\n",
+    "   - Use only top-N features (e.g., top 10, top 5)\n",
+    "   - Compare performance across different feature sets\n",
+    "\n",
+    "3. **Cross-Validation Comparison**:\n",
+    "   ```python\n",
+    "   # Example approach:\n",
+    "   # 1. Train model with all features -> get baseline MAE\n",
+    "   # 2. Train model excluding bottom 5 features -> get reduced MAE\n",
+    "   # 3. If MAE improves or stays similar, features weren't enhancing performance\n",
+    "   ```\n",
+    "\n",
+    "4. **Statistical Testing**: Use paired t-tests on cross-validation scores to determine if performance differences are statistically significant\n",
+    "\n",
+    "The key is to ensure that feature removal doesn't significantly degrade model performance on a held-out test set."
    ]
   },
   {
@@ -423,7 +866,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "env",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
@@ -437,7 +880,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.3"
+   "version": "3.12.10"
   }
  },
  "nbformat": 4,
diff --git a/02_activities/assignments/models/best_forest_fire_model.pkl b/02_activities/assignments/models/best_forest_fire_model.pkl
new file mode 100644
index 000000000..164a83849
Binary files /dev/null and b/02_activities/assignments/models/best_forest_fire_model.pkl differ