diff --git a/Lab_4/lab_4.ipynb b/Lab_4/lab_4.ipynb new file mode 100644 index 0000000..dbc23ee --- /dev/null +++ b/Lab_4/lab_4.ipynb @@ -0,0 +1,609 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Вариант: Экономика стран" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 369 entries, 0 to 368\n", + "Data columns (total 14 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 stock index 369 non-null object \n", + " 1 country 369 non-null object \n", + " 2 year 369 non-null float64\n", + " 3 index price 317 non-null float64\n", + " 4 log_indexprice 369 non-null float64\n", + " 5 inflationrate 326 non-null float64\n", + " 6 oil prices 369 non-null float64\n", + " 7 exchange_rate 367 non-null float64\n", + " 8 gdppercent 350 non-null float64\n", + " 9 percapitaincome 368 non-null float64\n", + " 10 unemploymentrate 348 non-null float64\n", + " 11 manufacturingoutput 278 non-null float64\n", + " 12 tradebalance 365 non-null float64\n", + " 13 USTreasury 369 non-null float64\n", + "dtypes: float64(12), object(2)\n", + "memory usage: 40.5+ KB\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.preprocessing import LabelEncoder\n", + "from sklearn import metrics\n", + "from imblearn.over_sampling import RandomOverSampler\n", + "from imblearn.under_sampling import RandomUnderSampler\n", + "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n", + "from sklearn.metrics import ConfusionMatrixDisplay\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.impute import SimpleImputer\n", + "from sklearn.linear_model import LinearRegression, LogisticRegression\n", + "from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor, RandomForestClassifier, GradientBoostingClassifier\n", + "from sklearn.model_selection import train_test_split, GridSearchCV\n", + "from sklearn.metrics import (\n", + " precision_score, recall_score, accuracy_score, roc_auc_score, f1_score,\n", + " matthews_corrcoef, cohen_kappa_score, confusion_matrix\n", + ")\n", + "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error\n", + "import numpy as np\n", + "import featuretools as ft\n", + "from sklearn.metrics import accuracy_score, classification_report\n", + "\n", + "# Функция для применения oversampling\n", + "def apply_oversampling(X, y):\n", + " oversampler = RandomOverSampler(random_state=42)\n", + " X_resampled, y_resampled = oversampler.fit_resample(X, y)\n", + " return X_resampled, y_resampled\n", + "\n", + "# Функция для применения undersampling\n", + "def apply_undersampling(X, y):\n", + " undersampler = RandomUnderSampler(random_state=42)\n", + " X_resampled, y_resampled = undersampler.fit_resample(X, y)\n", + " return X_resampled, y_resampled\n", + "\n", + "def split_stratified_into_train_val_test(\n", + " df_input,\n", + " stratify_colname=\"y\",\n", + " frac_train=0.6,\n", + " frac_val=0.15,\n", + " frac_test=0.25,\n", + " random_state=None,\n", + "):\n", + " \"\"\"\n", + " Splits a Pandas dataframe into three subsets (train, val, and test)\n", + " following fractional ratios provided by the user, where each subset is\n", + " stratified by the values in a specific column (that is, each subset has\n", + " the same relative frequency of the values in the column). It performs this\n", + " splitting by running train_test_split() twice.\n", + "\n", + " Parameters\n", + " ----------\n", + " df_input : Pandas dataframe\n", + " Input dataframe to be split.\n", + " stratify_colname : str\n", + " The name of the column that will be used for stratification. Usually\n", + " this column would be for the label.\n", + " frac_train : float\n", + " frac_val : float\n", + " frac_test : float\n", + " The ratios with which the dataframe will be split into train, val, and\n", + " test data. The values should be expressed as float fractions and should\n", + " sum to 1.0.\n", + " random_state : int, None, or RandomStateInstance\n", + " Value to be passed to train_test_split().\n", + "\n", + " Returns\n", + " -------\n", + " df_train, df_val, df_test :\n", + " Dataframes containing the three splits.\n", + " \"\"\"\n", + "\n", + " if frac_train + frac_val + frac_test != 1.0:\n", + " raise ValueError(\n", + " \"fractions %f, %f, %f do not add up to 1.0\"\n", + " % (frac_train, frac_val, frac_test)\n", + " )\n", + "\n", + " if stratify_colname not in df_input.columns:\n", + " raise ValueError(\"%s is not a column in the dataframe\" % (stratify_colname))\n", + "\n", + " X = df_input # Contains all columns.\n", + " y = df_input[\n", + " [stratify_colname]\n", + " ] # Dataframe of just the column on which to stratify.\n", + "\n", + " # Split original dataframe into train and temp dataframes.\n", + " df_train, df_temp, y_train, y_temp = train_test_split(\n", + " X, y, stratify=y, test_size=(1.0 - frac_train), random_state=random_state\n", + " )\n", + "\n", + " # Split the temp dataframe into val and test dataframes.\n", + " relative_frac_test = frac_test / (frac_val + frac_test)\n", + " df_val, df_test, y_val, y_test = train_test_split(\n", + " df_temp,\n", + " y_temp,\n", + " stratify=y_temp,\n", + " test_size=relative_frac_test,\n", + " random_state=random_state,\n", + " )\n", + "\n", + " assert len(df_input) == len(df_train) + len(df_val) + len(df_test)\n", + "\n", + " return df_train, df_val, df_test\n", + "\n", + "\n", + "df = pd.read_csv(\"../data/Economic.csv\")\n", + "df.info()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Определение бизнес-целей\n", + "\n", + "Задача регрессии:\n", + "Предсказать цену индекса (index price) на основе других факторов, таких как инфляция, цены на нефть, обменный курс, ВВП, доход на душу населения, уровень безработицы.\n", + "\n", + "Задача классификации:\n", + "Классификация по странам, на основе цены индекса, показателей ВВП, инфляции, безработицы, цены на нефть. Это поможет определить, к какой категории относится страна и какие меры могут быть предприняты для ее развития." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Дополнение данных" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Исходный размер датасета: 369\n", + "Очищенный размер датасета: 262\n" + ] + } + ], + "source": [ + "data = df.copy()\n", + "data_cleaned = df.dropna(subset=['index price', 'inflationrate', 'exchange_rate', 'gdppercent', 'percapitaincome', 'unemploymentrate'])\n", + "\n", + "print(f\"Исходный размер датасета: {df.shape[0]}\")\n", + "print(f\"Очищенный размер датасета: {data_cleaned.shape[0]}\")\n", + "\n", + "data1 = pd.get_dummies(data_cleaned, columns=['country'], drop_first=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Определение достижимого уровня" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index(['stock index', 'year', 'index price', 'log_indexprice', 'inflationrate',\n", + " 'oil prices', 'exchange_rate', 'gdppercent', 'percapitaincome',\n", + " 'unemploymentrate', 'manufacturingoutput', 'tradebalance', 'USTreasury',\n", + " 'country_France', 'country_Germany', 'country_Hong Kong',\n", + " 'country_India', 'country_Japan', 'country_Spain',\n", + " 'country_United Kingdom', 'country_United States of America'],\n", + " dtype='object')\n", + "stock index 0\n", + "year 0\n", + "index price 0\n", + "log_indexprice 0\n", + "inflationrate 0\n", + "oil prices 0\n", + "exchange_rate 0\n", + "gdppercent 0\n", + "percapitaincome 0\n", + "unemploymentrate 0\n", + "manufacturingoutput 41\n", + "tradebalance 2\n", + "USTreasury 0\n", + "country_France 0\n", + "country_Germany 0\n", + "country_Hong Kong 0\n", + "country_India 0\n", + "country_Japan 0\n", + "country_Spain 0\n", + "country_United Kingdom 0\n", + "country_United States of America 0\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "print(data1.columns)\n", + "print(data1.isnull().sum())" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for Linear Regression: {}\n", + "Best parameters for Random Forest Regressor: {'model__max_depth': 10, 'model__n_estimators': 300}\n", + "Best parameters for Gradient Boosting Regressor: {'model__learning_rate': 0.2, 'model__max_depth': 5, 'model__n_estimators': 300}\n", + "Model: Linear Regression\n", + "Model: Random Forest Regressor\n", + "Model: Gradient Boosting Regressor\n" + ] + } + ], + "source": [ + "X_reg = data1.drop(['stock index', 'year', 'index price', 'log_indexprice', 'manufacturingoutput', 'tradebalance', 'USTreasury'], axis=1)\n", + "y_reg = data1['index price']\n", + "\n", + "# Разделение данных\n", + "X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(X_reg, y_reg, test_size=0.2, random_state=42)\n", + "\n", + "# Выбор моделей для регрессии\n", + "models_reg = {\n", + " 'Linear Regression': LinearRegression(),\n", + " 'Random Forest Regressor': RandomForestRegressor(random_state=42),\n", + " 'Gradient Boosting Regressor': GradientBoostingRegressor(random_state=42)\n", + "}\n", + "\n", + "# Создание конвейера для регрессии\n", + "pipelines_reg = {}\n", + "for name, model in models_reg.items():\n", + " pipelines_reg[name] = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('model', model)\n", + " ])\n", + "\n", + "# Определение сетки гиперпараметров для регрессии\n", + "param_grids_reg = {\n", + " 'Linear Regression': {},\n", + " 'Random Forest Regressor': {\n", + " 'model__n_estimators': [100, 200, 300],\n", + " 'model__max_depth': [None, 10, 20, 30]\n", + " },\n", + " 'Gradient Boosting Regressor': {\n", + " 'model__n_estimators': [100, 200, 300],\n", + " 'model__learning_rate': [0.01, 0.1, 0.2],\n", + " 'model__max_depth': [3, 5, 7]\n", + " }\n", + "}\n", + "\n", + "# Настройка гиперпараметров для регрессии\n", + "best_models_reg = {}\n", + "for name, pipeline in pipelines_reg.items():\n", + " grid_search = GridSearchCV(pipeline, param_grids_reg[name], cv=5, scoring='neg_mean_squared_error')\n", + " grid_search.fit(X_train_reg, y_train_reg)\n", + " best_models_reg[name] = {\n", + " 'pipeline': grid_search.best_estimator_,\n", + " 'best_params': grid_search.best_params_\n", + " }\n", + " print(f'Best parameters for {name}: {grid_search.best_params_}')\n", + "\n", + "# Обучение моделей и оценка качества\n", + "for model_name in best_models_reg.keys():\n", + " print(f\"Model: {model_name}\")\n", + " model_pipeline = best_models_reg[model_name]['pipeline']\n", + " model_pipeline.fit(X_train_reg, y_train_reg)\n", + "\n", + " y_train_predict = model_pipeline.predict(X_train_reg)\n", + " y_test_predict = model_pipeline.predict(X_test_reg)\n", + "\n", + " best_models_reg[model_name][\"preds_train\"] = y_train_predict\n", + " best_models_reg[model_name][\"preds_test\"] = y_test_predict\n", + "\n", + " best_models_reg[model_name][\"MSE_train\"] = mean_squared_error(y_train_reg, y_train_predict)\n", + " best_models_reg[model_name][\"MSE_test\"] = mean_squared_error(y_test_reg, y_test_predict)\n", + " best_models_reg[model_name][\"R2_train\"] = r2_score(y_train_reg, y_train_predict)\n", + " best_models_reg[model_name][\"R2_test\"] = r2_score(y_test_reg, y_test_predict)\n", + " best_models_reg[model_name][\"MAE_train\"] = mean_absolute_error(y_train_reg, y_train_predict)\n", + " best_models_reg[model_name][\"MAE_test\"] = mean_absolute_error(y_test_reg, y_test_predict)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['United States of America' 'United Kingdom' 'India' 'Japan' 'Hong Kong'\n", + " 'China' 'Germany' 'France' 'Spain']\n", + "\n", + "Index: 262 entries, 0 to 367\n", + "Data columns (total 6 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 country 262 non-null object \n", + " 1 index price 262 non-null float64\n", + " 2 inflationrate 262 non-null float64\n", + " 3 oil prices 262 non-null float64\n", + " 4 gdppercent 262 non-null float64\n", + " 5 unemploymentrate 262 non-null float64\n", + "dtypes: float64(5), object(1)\n", + "memory usage: 14.3+ KB\n", + "gdppercent\n", + " 0.02 55\n", + " 0.03 39\n", + " 0.04 37\n", + " 0.01 30\n", + " 0.05 20\n", + " 0.08 19\n", + " 0.07 14\n", + " 0.06 12\n", + "-0.01 10\n", + " 0.09 6\n", + " 0.10 4\n", + " 0.11 3\n", + "-0.02 2\n", + "-0.03 2\n", + "-0.05 2\n", + " 0.12 1\n", + "-0.04 1\n", + "-0.10 1\n", + "-0.06 1\n", + "-0.08 1\n", + " 0.13 1\n", + " 0.14 1\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "data2 = data_cleaned.drop(['stock index', 'year', 'log_indexprice', 'exchange_rate', 'percapitaincome', 'manufacturingoutput', 'tradebalance', 'USTreasury'], axis=1)\n", + "print(data2[\"country\"].unique())\n", + "data2.info()\n", + "print(data2[\"gdppercent\"].value_counts())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index(['index price', 'inflationrate', 'oil prices', 'gdppercent',\n", + " 'unemploymentrate'],\n", + " dtype='object')\n", + "Best parameters for Logistic Regression: {'model__C': 10, 'model__solver': 'lbfgs'}\n", + "Best parameters for Random Forest Classifier: {'model__max_depth': None, 'model__n_estimators': 200}\n", + "Best parameters for Gradient Boosting Classifier: {'model__learning_rate': 0.1, 'model__max_depth': 3, 'model__n_estimators': 300}\n", + "Model: Logistic Regression\n", + "Model: Random Forest Classifier\n", + "Model: Gradient Boosting Classifier\n" + ] + } + ], + "source": [ + "# Выбор признаков и целевой переменной для классификации\n", + "X_class = data2.drop(['country'], axis=1)\n", + "y_class = data2['country']\n", + "print(X_class.columns)\n", + "# Разделение данных\n", + "X_train_class, X_test_class, y_train_class, y_test_class = train_test_split(X_class, y_class, test_size=0.2, random_state=20)\n", + "\n", + "# Выбор моделей для классификации\n", + "models_class = {\n", + " 'Logistic Regression': LogisticRegression(random_state=42, max_iter=5000, solver='liblinear'),\n", + " 'Random Forest Classifier': RandomForestClassifier(random_state=42),\n", + " 'Gradient Boosting Classifier': GradientBoostingClassifier(random_state=42)\n", + "}\n", + "\n", + "# Создание конвейера для классификации\n", + "pipelines_class = {}\n", + "for name, model in models_class.items():\n", + " pipelines_class[name] = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('model', model)\n", + " ])\n", + "\n", + "# Определение сетки гиперпараметров для классификации\n", + "\n", + "param_grids_class = {\n", + " 'Logistic Regression': {\n", + " 'model__C': [0.1, 1, 10],\n", + " 'model__solver': ['lbfgs', 'liblinear']\n", + " },\n", + " 'Random Forest Classifier': {\n", + " 'model__n_estimators': [100, 200, 300],\n", + " 'model__max_depth': [None, 10, 20, 30]\n", + " },\n", + " 'Gradient Boosting Classifier': {\n", + " 'model__n_estimators': [100, 200, 300],\n", + " 'model__learning_rate': [0.01, 0.1, 0.2],\n", + " 'model__max_depth': [3, 5, 7]\n", + " }\n", + "}\n", + "# Убрал определение параметров поскольку уже был предподсчет данных, но вылетела ошибка. Сохранил лучшие параметры\n", + "'''\n", + "param_grids_class = {\n", + " 'Logistic Regression': {\n", + " 'model__C': [10],\n", + " 'model__solver': ['lbfgs']\n", + " },\n", + " 'Random Forest Classifier': {\n", + " 'model__n_estimators': [200],\n", + " 'model__max_depth': [ 30]\n", + " },\n", + " 'Gradient Boosting Classifier': {\n", + " 'model__n_estimators': [200],\n", + " 'model__learning_rate': [0.1],\n", + " 'model__max_depth': [7]\n", + " }\n", + "}'''\n", + "\n", + "# Настройка гиперпараметров для классификации\n", + "best_models_class = {}\n", + "for name, pipeline in pipelines_class.items():\n", + " grid_search = GridSearchCV(pipeline, param_grids_class[name], cv=5, scoring='accuracy', n_jobs=-1)\n", + " grid_search.fit(X_train_class, y_train_class)\n", + " best_models_class[name] = {\n", + " 'pipeline': grid_search.best_estimator_,\n", + " 'best_params': grid_search.best_params_\n", + " }\n", + " print(f'Best parameters for {name}: {grid_search.best_params_}')\n", + "\n", + "# Обучение моделей и оценка качества\n", + "for model_name in best_models_class.keys():\n", + " print(f\"Model: {model_name}\")\n", + "\n", + " model_pipeline = best_models_class[model_name]['pipeline']\n", + " model_pipeline.fit(X_train_class, y_train_class)\n", + "\n", + " y_train_predict = model_pipeline.predict(X_train_class)\n", + " y_test_probs = model_pipeline.predict_proba(X_test_class)\n", + " y_test_predict = model_pipeline.predict(X_test_class)\n", + "\n", + " best_models_class[model_name]['preds_train'] = y_train_predict\n", + " best_models_class[model_name][\"probs\"] = y_test_probs\n", + " best_models_class[model_name][\"preds\"] = y_test_predict\n", + "\n", + " best_models_class[model_name][\"Precision_train\"] = precision_score(y_train_class, y_train_predict, average='weighted')\n", + " best_models_class[model_name][\"Precision_test\"] = precision_score(y_test_class, y_test_predict, average='weighted')\n", + " best_models_class[model_name][\"Recall_train\"] = recall_score(y_train_class, y_train_predict, average='weighted')\n", + " best_models_class[model_name][\"Recall_test\"] = recall_score(y_test_class, y_test_predict, average='weighted')\n", + " best_models_class[model_name][\"Accuracy_train\"] = accuracy_score(y_train_class, y_train_predict)\n", + " best_models_class[model_name][\"Accuracy_test\"] = accuracy_score(y_test_class, y_test_predict)\n", + " best_models_class[model_name][\"ROC_AUC_test\"] = roc_auc_score(y_test_class, y_test_probs, multi_class='ovr', average='weighted')\n", + " best_models_class[model_name][\"F1_train\"] = f1_score(y_train_class, y_train_predict, average='weighted')\n", + " best_models_class[model_name][\"F1_test\"] = f1_score(y_test_class, y_test_predict, average='weighted')\n", + " best_models_class[model_name][\"MCC_test\"] = matthews_corrcoef(y_test_class, y_test_predict)\n", + " best_models_class[model_name][\"Cohen_kappa_test\"] = cohen_kappa_score(y_test_class, y_test_predict)\n", + " best_models_class[model_name][\"Confusion_matrix\"] = confusion_matrix(y_test_class, y_test_predict)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjQAAAQ9CAYAAABOVNfxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1gUVxcH4N/Awi6wdJAiSJEiSFGxY8GowUbs3SgaS+waK1EUxRJ7id0Y0ERFY9SgiRU7lliAmICIBSGKYqGISN37/eHHxBWQXWR3Ked9nnl0ZmfuuXd2djl7584MxxhjIIQQQgipwtRUXQFCCCGEkE9FCQ0hhBBCqjxKaAghhBBS5VFCQwghhJAqjxIaQgghhFR5lNAQQgghpMqjhIYQQgghVR4lNIQQQgip8iihIYQQQkiVRwkNIaTS8vHxgY+PT4WVZ2trC39//worjwAcxyEoKEjV1SCEEhpCSNlCQ0PBcRxu3Lih6qqU6fLlywgKCkJ6erpC49ja2oLjOH7S0dFB06ZNsWvXLoXGJYSUTKDqChBCSGlOnjwp9zaXL1/GggUL4O/vDwMDA6nX4uPjoaZWcb/jGjRogGnTpgEAUlJS8MMPP2DYsGHIzc3FqFGjKixOZfb27VsIBPSnhKgeHYWEkEpLU1OzQssTCoUVWl7t2rUxZMgQft7f3x/29vZYs2aN0hOaN2/eQEdHR6kxAUAkEik9JiEloVNOhJAKExUVhc6dO0NPTw9isRjt27fH1atXi633119/oW3bttDS0oKVlRUWLVqEkJAQcByHxMREfr2SxtB8//33qF+/PrS1tWFoaIjGjRtjz549AICgoCDMmDEDAGBnZ8efDioqs6QxNOnp6Zg6dSpsbW0hFAphZWWFoUOH4sWLF3K339TUFPXq1cP9+/ellkskEqxduxb169eHSCSCmZkZxowZg7S0tGLrBQUFwdLSEtra2mjXrh1iY2OL1bvoFOD58+cxbtw41KpVC1ZWVvzrx44dQ+vWraGjowNdXV107doV//zzj1Ssp0+fYvjw4bCysoJQKISFhQW6d+8utf9v3LgBX19fmJiYQEtLC3Z2dhgxYoRUOSWNoZHlOChqQ2RkJL755huYmppCR0cHPXv2xPPnz2Xd5YTwqIeGEFIh/vnnH7Ru3Rp6enqYOXMmNDQ0sHXrVvj4+OD8+fNo1qwZAODx48do164dOI5DQEAAdHR08MMPP8jUe7J9+3ZMmjQJffr0weTJk5GTk4O//voL165dw6BBg9CrVy/cvXsXe/fuxZo1a2BiYgLgXaJRkqysLLRu3RpxcXEYMWIEGjVqhBcvXiA8PBz//vsvv72sCgoK8O+//8LQ0FBq+ZgxYxAaGorhw4dj0qRJePjwITZs2ICoqChERkZCQ0MDABAQEIDly5fDz88Pvr6+iImJga+vL3JyckqMN27cOJiammLevHl48+YNAOCnn37CsGHD4Ovri2XLliE7OxubN29Gq1atEBUVBVtbWwBA79698c8//2DixImwtbVFamoqTp06haSkJH7+888/h6mpKWbPng0DAwMkJibi4MGDH90Hsh4HRSZOnAhDQ0PMnz8fiYmJWLt2LSZMmIB9+/bJte8JASOEkDKEhIQwAOz69eulrtOjRw+mqanJ7t+/zy978uQJ09XVZW3atOGXTZw4kXEcx6KiovhlL1++ZEZGRgwAe/jwIb+8bdu2rG3btvx89+7dWf369T9a1xUrVhQrp4iNjQ0bNmwYPz9v3jwGgB08eLDYuhKJ5KNxbGxs2Oeff86eP3/Onj9/zm7fvs2+/PJLBoCNHz+eX+/ixYsMANu9e7fU9sePH5da/vTpUyYQCFiPHj2k1gsKCmIApOpd9H60atWKFRQU8Mtfv37NDAwM2KhRo6TKePr0KdPX1+eXp6WlMQBsxYoVpbbv0KFDZb7njDEGgM2fP5+fl/U4KGpDhw4dpPb11KlTmbq6OktPT/9oXEI+RKecCCGfrLCwECdPnkSPHj1gb2/PL7ewsMCgQYNw6dIlZGZmAgCOHz+OFi1aoEGDBvx6RkZGGDx4cJlxDAwM8O+//+L69esVUu9ff/0Vnp6e6NmzZ7HXOI4rc/uTJ0/C1NQUpqamcHd3x08//YThw4djxYoV/Dq//PIL9PX10bFjR7x48YKfvLy8IBaLcfbsWQBAREQECgoKMG7cOKkYEydOLDX+qFGjoK6uzs+fOnUK6enpGDhwoFQsdXV1NGvWjI+lpaUFTU1NnDt3rthpryJFA6qPHj2K/Pz8MvcFIN9xUGT06NFS+7p169YoLCzEo0ePZIpJSBFKaAghn+z58+fIzs6Gs7NzsddcXFwgkUiQnJwMAHj06BEcHByKrVfSsg/NmjULYrEYTZs2haOjI8aPH4/IyMhy1/v+/ftwc3Mr9/bNmjXDqVOncPz4caxcuRIGBgZIS0uTGsyckJCAjIwM1KpVi09+iqasrCykpqYCAP8H/MP9YGRkVOwUVhE7Ozup+YSEBADAZ599VizWyZMn+VhCoRDLli3DsWPHYGZmhjZt2mD58uV4+vQpX1bbtm3Ru3dvLFiwACYmJujevTtCQkKQm5tb6v6Q5zgoUqdOHan5oraWlmgRUhoaQ0MIqTJcXFwQHx+Po0eP4vjx4/j111+xadMmzJs3DwsWLFB6fUxMTNChQwcAgK+vL+rVq4du3bph3bp1+OabbwC8G+hbq1Yt7N69u8QyShvfIwstLS2peYlEAuDdOBpzc/Ni679/efWUKVPg5+eHw4cP48SJEwgMDMTSpUtx5swZNGzYEBzH4cCBA7h69SqOHDmCEydOYMSIEVi1ahWuXr0KsVhc7nq/7/0epvcxxiqkfFJzUEJDCPlkpqam0NbWRnx8fLHX7ty5AzU1NVhbWwMAbGxscO/evWLrlbSsJDo6Oujfvz/69++PvLw89OrVC4sXL0ZAQABEIpFMp4qK1K1bF3///bfM65ela9euaNu2LZYsWYIxY8ZAR0cHdevWxenTp+Ht7V0sAXmfjY0NgHf74f2el5cvX8rcW1G3bl0AQK1atfhEq6z1p02bhmnTpiEhIQENGjTAqlWr8PPPP/PrNG/eHM2bN8fixYuxZ88eDB48GGFhYRg5cmSx8uQ5DgipaHTKiRDyydTV1fH555/jt99+k7rs99mzZ9izZw9atWoFPT09AO96Mq5cuYLo6Gh+vVevXpXag/G+ly9fSs1ramrC1dUVjDF+nEfRvVhkuVNw7969ERMTg0OHDhV7rbw9BLNmzcLLly+xfft2AEC/fv1QWFiI4ODgYusWFBTw9Wzfvj0EAgE2b94stc6GDRtkju3r6ws9PT0sWbKkxHEvRZdDZ2dnF7tyqm7dutDV1eVPKaWlpRXbB0Xjnko77STPcUBIRaMeGkKIzH788UccP3682PLJkydj0aJFOHXqFFq1aoVx48ZBIBBg69atyM3NxfLly/l1Z86ciZ9//hkdO3bExIkT+cu269Spg1evXn20h+Xzzz+Hubk5vL29YWZmhri4OGzYsAFdu3aFrq4uAMDLywsAMGfOHAwYMAAaGhrw8/Mr8aZzM2bMwIEDB9C3b1+MGDECXl5eePXqFcLDw7FlyxZ4enrKvY86d+4MNzc3rF69GuPHj0fbtm0xZswYLF26FNHR0fj888+hoaGBhIQE/PLLL1i3bh369OkDMzMzTJ48GatWrcIXX3yBTp06ISYmBseOHYOJiYlMPU96enrYvHkzvvzySzRq1AgDBgyAqakpkpKS8Pvvv8Pb2xsbNmzA3bt30b59e/Tr1w+urq4QCAQ4dOgQnj17hgEDBgAAdu7ciU2bNqFnz56oW7cuXr9+je3bt0NPTw9dunQptQ6yHgeEVDjVXmRFCKkKii6xLW1KTk5mjDF269Yt5uvry8RiMdPW1mbt2rVjly9fLlZeVFQUa926NRMKhczKyootXbqUrV+/ngFgT58+5df78LLtrVu3sjZt2jBjY2MmFApZ3bp12YwZM1hGRoZU+cHBwax27dpMTU1N6hLuDy/bZuzdJeMTJkxgtWvXZpqamszKyooNGzaMvXjx4qP7xMbGhnXt2rXE10JDQxkAFhISwi/btm0b8/LyYlpaWkxXV5e5u7uzmTNnsidPnvDrFBQUsMDAQGZubs60tLTYZ599xuLi4pixsTH7+uuvi70fpV1SffbsWebr68v09fWZSCRidevWZf7+/uzGjRuMMcZevHjBxo8fz+rVq8d0dHSYvr4+a9asGdu/fz9fxq1bt9jAgQNZnTp1mFAoZLVq1WLdunXjyyiCDy7bLtq2rOOgtDacPXuWAWBnz54tsW2ElIZjjEZeEUJUb8qUKdi6dSuysrJKHShaE6Wnp8PQ0BCLFi3CnDlzVF0dQiotGkNDCFG6t2/fSs2/fPkSP/30E1q1alWjk5kP9wsArF27FgCKPQKCECKNxtAQQpSuRYsW8PHxgYuLC549e4YdO3YgMzMTgYGBqq6aSu3btw+hoaHo0qULxGIxLl26hL179+Lzzz+Ht7e3qqtHSKVGCQ0hROm6dOmCAwcOYNu2beA4Do0aNcKOHTvQpk0bVVdNpTw8PCAQCLB8+XJkZmbyA4UXLVqk6qoRUunRGBpCCCGEqJStrW2Jj7sYN24cNm7cKFMZ1ENDCCGEEJW6fv06CgsL+fm///4bHTt2RN++fWUug3poCCGEEFKpTJkyBUePHkVCQoLMd/+mHhpCKpBEIsGTJ0+gq6sr1y34CSHVG2MMr1+/hqWlJdTUqt4Fxjk5OcjLy5NrG8ZYse9BoVAIoVD40e3y8vLw888/45tvvpHre5QSGkIq0JMnT+hZNYSQUiUnJ8PKykrV1ZBLTk4O7GzEeJpaWPbK7xGLxcjKypJaNn/+fAQFBX10u8OHDyM9PR3+/v5yxaOEhpAKVHT7/QY950JdQ6S8uPuvKy0WIdWFmkc9pcUqKMzFhX/W8t8RVUleXh6ephbi4U0b6OnK1ruU+VoCO69HSE5Olnp+V1m9MwCwY8cOdO7cGZaWlnLVkxIaQipQUfeouoZIqQmNgNNQWixCqgs19bL/uFa0qnwqWkf8bpJF4f9H5+rp6cn1QNJHjx7h9OnTOHjwoNz1o4SGEEIIIWWSgEEC2a4jknW9D4WEhKBWrVro2rWr3NtSQkMIIYSQMkkggUSOdeUuXyJBSEgIhg0bBoFA/vSEEhpCCCGElKmQMRTKeKcXWdd73+nTp5GUlIQRI0bIvS1ACQ0hhBBCZKDoU06ff/45PuXWeJTQEEIIIaRMEjAUKngMzaeghIYQQgghZVLGoOBPUfVuV1gKW1tbrF27ViFlcxyHw4cPK6TsqiI7Oxu9e/eGnp4eOI5Denq6qqskk3PnzlXq+g79LAo7Jh/E6UU/4vegnfjO/wTqmKYrJbaf/wvsvBaLIw/+wrqjCXBukF1t41LM6hVTFXHd3FIRNP88fv7pMI79sRctWvyr0HiVUdEYGlknZVNpQuPj44MpU6YUWx4aGgoDAwO5yrp+/TpGjx7NzyszCXn+/DnGjh2LOnXqQCgUwtzcHL6+voiMjPzk+igyUZPHzp07cfHiRVy+fBkpKSnQ19cvdd23b9/CyMgIJiYmyM3NVWIti2vZsmWZ9VWlhvZP8GtkfYz6vgcmb+0GgboEa0f/DpFmvkLjtv0iDaPnP8Hu1eYY7+uEB7EiLN7zAPrG1S8uxaxeMVUVVyQqwIOHhti0yUthMSo7iZyTslWbHhpTU1Noa2urJHbv3r0RFRWFnTt34u7duwgPD4ePjw9evnypkvoowv379+Hi4gI3NzeYm5t/9OZQv/76K+rXr4969eqptGcrPz8fmpqaZdZXlab+0BV/3HDGw2dGuJdijEVhPrAwzEI9q+cKjdtr9Asc32OEk/uMkJQgwvpZVsh9y8F34KtqF5diVq+Yqop744Yldu3ywOUrNffRJoX/H0Mj66RsVSKh8ff3R48ePbBy5UpYWFjA2NgY48ePR37+f9n4+z0Ztra2AICePXuC4zh+HgB+++03NGrUCCKRCPb29liwYAEKCgr41xMSEtCmTRuIRCK4urri1KlTH61beno6Ll68iGXLlqFdu3awsbFB06ZNERAQgC+++OKj9bl//z66d+8OMzMziMViNGnSBKdPn+bL9vHxwaNHjzB16lRwHCf1R/nSpUto3bo1tLS0YG1tjUmTJuHNmzf865s2bYKjoyNEIhHMzMzQp0+fj7ajKAkRCoWwtbXFqlWrpOqxatUqXLhwARzHwcfH56Nl7dixA0OGDMGQIUOwY8eOYq9zHIetW7eiW7du0NbWhouLC65cuYJ79+7Bx8cHOjo6aNmyJe7fvy+1XVnvHcdx2Lx5M7744gvo6Ohg8eLFJZ5yioyMhI+PD7S1tWFoaAhfX1+kpaUBAI4fP45WrVrBwMAAxsbG6NatW7F6KJJY9O7hb5nZirvLsEBDAkePbNy6+N8t2BnjEHVRF65eiuu2V0Vcilm9YqoyLnl39195JmWrEgkNAJw9exb379/H2bNnsXPnToSGhiI0NLTEda9ff/dcm5CQEKSkpPDzFy9exNChQzF58mTExsZi69atCA0NxeLFiwG8u6lPr169oKmpiWvXrmHLli2YNWvWR+slFoshFotx+PDhUk+vlFafrKwsdOnSBREREYiKikKnTp3g5+eHpKQkAMDBgwdhZWWFhQsXIiUlBSkpKQDeJUKdOnVC79698ddff2Hfvn24dOkSJkyYAAC4ceMGJk2ahIULFyI+Ph7Hjx9HmzZtSm3DzZs30a9fPwwYMAC3b99GUFAQAgMD+f178OBBjBo1Ci1atEBKSspHb0l9//59XLlyBf369UO/fv1w8eJFPHr0qNh6wcHBGDp0KKKjo1GvXj0MGjQIY8aMQUBAAG7cuAHGGN8eoOz3rkhQUBB69uyJ27dvl3gvg+joaLRv3x6urq64cuUKLl26BD8/PxQWvnvo2ps3b/DNN9/gxo0biIiIgJqaGnr27AmJpOQO1NzcXGRmZkpN5cVxDFO6X0bMQ3M8eGpU7nLKomdUCHUBkP5c+pqAtBcCGJoWlLJV1YxLMatXTFXGJZX/lFOVucrJ0NAQGzZsgLq6OurVq4euXbsiIiICo0aNKrauqakpAMDAwADm5ub88gULFmD27NkYNmwYAMDe3h7BwcGYOXMm5s+fj9OnT+POnTs4ceIE/1CsJUuWoHPnzqXWSyAQIDQ0FKNGjcKWLVvQqFEjtG3bFgMGDICHh8dH6+Pp6QlPT09+Pjg4GIcOHUJ4eDgmTJgAIyMjqKurQ1dXV2q7pUuXYvDgwfz4I0dHR6xfvx5t27bF5s2bkZSUBB0dHXTr1g26urqwsbFBw4YNS23D6tWr0b59ewQGBgIAnJycEBsbixUrVsDf3x9GRkbQ1tbmT998zI8//ojOnTvD0NAQAODr64uQkJBiT1cdPnw4+vXrBwCYNWsWWrRogcDAQPj6+gIAJk+ejOHDh/Prl/XeFRk0aJDUdg8ePJCKu3z5cjRu3BibNm3il9WvX5//f+/evYu1x9TUFLGxsXBzcyvW3qVLl2LBggUf3Seymt7zEuzNX2HMxu4VUh4hhFQkCTgUQrbT9xIZ16tIVaaHpn79+lBXV+fnLSwskJqaKlcZMTExWLhwId+rIhaLMWrUKKSkpCA7OxtxcXGwtraWesJnixYtyiy3d+/eePLkCcLDw9GpUyecO3cOjRo1KrUHqUhWVhamT58OFxcXGBgYQCwWIy4uju+h+Vg7QkNDpdrh6+sLiUSChw8fomPHjrCxsYG9vT2+/PJL7N69G9nZpXfFxsXFwdvbW2qZt7c3EhIS+J4LWRQWFmLnzp0YMmQIv2zIkCEIDQ0t1sNRlOwBgJmZGQDA3d1dallOTg7f41HWe1ekcePGH61jUQ9NaRISEjBw4EDY29tDT0+PPz1Y2nsSEBCAjIwMfkpOTv5o/NJM63kJ3q6PMH6LH55nyPj0t3LKfKWOwgLA4INfs4YmBUh7rrjfOKqISzGrV0xVxiWAhMk3KZtKExo9PT1kZGQUW56enl7sqhQNDemnCXMcV+ppgNJkZWVhwYIFiI6O5qfbt28jISEBItGnjVkQiUTo2LEjAgMDcfnyZfj7+0v1HJRk+vTpOHToEJYsWYKLFy8iOjoa7u7uyMvLK7MdY8aMkWpHTEwMEhISULduXejq6uLWrVvYu3cvLCwsMG/ePHh6eir80uUTJ07g8ePH6N+/PwQCAQQCAQYMGIBHjx4hIiJCat3338+isUElLSt6j2V973R0dD5aRy0trY++7ufnh1evXmH79u24du0arl27BgClvidCoZB/mqy8T5V9h2Faz0to6/YQE7b4IeWVvNvLryBfDQl/aaNhq9f8Mo5jaNAqC7E3FTewXhVxKWb1iqnKuAQo/H8PjayTsqk0nXV2dsbJkyeLLb916xacnJw+qWwNDY1ivQuNGjVCfHw8HBwcStzGxcUFycnJSElJgYWFBQDg6tWr5Yrv6uoqdYVPSfWJjIyEv78/evbsCeDdH+3ExESpdTQ1NUtsR2xsbKntAN6dCuvQoQM6dOiA+fPnw8DAAGfOnEGvXr2Krevi4iJ1iXlR3ZycnKR6xcqyY8cODBgwAHPmzJFavnjxYuzYsQMdO3aUuawPlfXeycrDwwMRERElniZ6+fIl4uPjsX37drRu3RrAu8HXijS91yV83vAeZoX4IjtXA0a673qb3rzVRG6B4j6eB7eZYPraZNyN0UZ8lDZ6jnoOkbYEJ8MUN3ZHVXEpZvWKqaq4IlE+LC2z+HkzsyzY26fh9WtNPH/+8R9S1YU8iUqNS2jGjh2LDRs2YNKkSRg5ciSEQiF+//137N27F0eOHPmksm1tbREREQFvb28IhUIYGhpi3rx56NatG+rUqYM+ffpATU0NMTEx+Pvvv7Fo0SJ06NABTk5OGDZsGFasWIHMzMxif5w/9PLlS/Tt2xcjRoyAh4cHdHV1cePGDSxfvhzdu/83FqKk+jg6OuLgwYPw8/MDx3EIDAws1utka2uLCxcuYMCAARAKhTAxMcGsWbPQvHlzTJgwASNHjoSOjg5iY2Nx6tQpbNiwAUePHsWDBw/Qpk0bGBoa4o8//oBEIoGzs3OJbZg2bRqaNGmC4OBg9O/fH1euXMGGDRukxpmU5fnz5zhy5AjCw8OLjTUZOnQoevbsiVevXsHIqHxfOGW9d7IKCAiAu7s7xo0bh6+//hqampo4e/Ys+vbtCyMjIxgbG2Pbtm2wsLBAUlISZs+eXa76yqp3y1gAwKZx0sd7cJgP/rhR8vtVEc6HG0LfuBBDZzyFoWkBHvyjhTmD7ZD+QqPsjatYXIpZvWKqKq6j4yssX3aGnx8zOgoAcOqUHVavaa6wuJWJhHGQMBnH0Mi4XkVSaUJjb2+PCxcuYM6cOejQoQPy8vJQr149/PLLL+jUqdMnlb1q1Sp888032L59O2rXro3ExET4+vri6NGjWLhwIZYtWwYNDQ3Uq1cPI0eOBACoqanh0KFD+Oqrr9C0aVPY2tpi/fr1H62LWCxGs2bNsGbNGty/fx/5+fmwtrbGqFGj8O233360PqtXr8aIESPQsmVLPlH58CqZhQsXYsyYMahbty5yc3PBGIOHhwfOnz+POXPmoHXr1mCMoW7duujfvz+Ad4OPDx48iKCgIOTk5MDR0RF79+6VGvz6vkaNGmH//v2YN28egoODYWFhgYULF8Lf31/m/b1r1y7o6OiUOD6lffv20NLSws8//4xJkybJXOb7ynrvZOXk5ISTJ0/i22+/RdOmTaGlpYVmzZph4MCBUFNTQ1hYGCZNmgQ3Nzc4Oztj/fr1ZV6m/ilaTB+jsLLLEh5igvAQkxoRl2JWr5iqiHv7thk6dxmotHiVUWXvoeHYpzzakhAiJTMzE/r6+vDqtwjqGoq7l8yH9PaU79QoITWZWgNXpcUqKMzFmb+WISMjoxxj7VSr6HvtzN/WEOvKNvQ267UEn7klK7W9NCScEEIIIWVicpxyYjXtlBMhhBBCqobKfsqJEhpCCCGElKmQqaGQyXbKSRWPPqCEhhBCCCFlkoCDRMbb10lU8HBKSmgIIYQQUiY65UQIIYSQKk++U07UQ0MIIYSQSujdKafK+3BKSmgIUQDd/dch4BR7t9T3Db7zr9JivW/zwj5Kj0n33CEVRRIdq7xYLF9psWoqSmgIIYQQUiYJ1FBIg4IJIYQQUpXRGBpCCCGEVHkSqNFl24QQQgip2goZh0IZH2kg63oVSbZUixBCCCE1WuH/x9DIOsnj8ePHGDJkCIyNjaGlpQV3d3fcuHFDrjKoh4YQQgghZZIwNUhkHEMjkWMMTVpaGry9vdGuXTscO3YMpqamSEhIgKGhoVz1o4SGEEIIIWWSp+elUI4xNMuWLYO1tTVCQkL4ZXZ2dnLXj045EUIIIaRMEvw3jqasSfL/bTIzM6Wm3NzcYuWGh4ejcePG6Nu3L2rVqoWGDRti+/btctePEhpCCCGElKnoKidZJwCwtraGvr4+Py1durRYuQ8ePMDmzZvh6OiIEydOYOzYsZg0aRJ27twpV/3olBMhlYCf/wv0GZsKI9MCPIjVwqa5tREfra2weNnP1BC1Uh9PLohQmKMGcZ0CtFjyCsbuirub6dDPotDW/SFsTNORW6CO24nm2PR7MyQ9N1BYzCLK3r8UU7ExVRVXVW2tLOS7D8279ZKTk6Gnp8cvFwqFxdaVSCRo3LgxlixZAgBo2LAh/v77b2zZsgXDhg2TuX7UQ1PF2draYu3atQopm+M4HD58+JPK8PHxwZQpUyqkPh9z7tw5cByH9PR0hceqaG2/SMPo+U+we7U5xvs64UGsCIv3PIC+sWKSi9wMDicH1oKaAGi3/QW6/f4UXrPSoakvKXvjT9DQ/gl+jayPUd/3wOSt3SBQl2Dt6N8h0lTsLeGVvX8ppmJjqiquqtpamRQ9y0nWCQD09PSkppISGgsLC7i6ukotc3FxQVJSklz1o4RGBUr7Ix8aGgoDAwO5yrp+/TpGjx7Nz1dEEiIrf39/9OjRQ2rZgQMHIBKJsGrVKgDAwYMHERwcrJT6VFW9Rr/A8T1GOLnPCEkJIqyfZYXctxx8B75SSLzYH3ShbVGIFkvTYOKRD7FVISxa5UK3TqFC4hWZ+kNX/HHDGQ+fGeFeijEWhfnAwjAL9ayeKzSusvcvxVRsTFXFVVVbK5OiHhpZJ1l5e3sjPj5eatndu3dhY2MjV/0ooaniTE1Noa1dObo8f/jhBwwePBibN2/GtGnTAABGRkbQ1dVVcc0qL4GGBI4e2bh18b99xBiHqIu6cPXKVkjMf89owdgtDxcnG+FASwv80bMW7u3XUUisjxGL8gAAmdkihcVQxf6lmIqLqaq4qmprZaOo+9BMnToVV69exZIlS3Dv3j3s2bMH27Ztw/jx4+WqHyU0lVhRD8jKlSthYWEBY2NjjB8/Hvn5/3Vxvn/KydbWFgDQs2dPcBzHzwPAb7/9hkaNGkEkEsHe3h4LFixAQUEB/3pCQgLatGkDkUgEV1dXnDp1Sq66Ll++HBMnTkRYWBiGDx/OL/+wN8rW1hZLlizBiBEjoKurizp16mDbtm1SZV2+fBkNGjSASCRC48aNcfjwYXAch+joaH6dP/74A05OTtDS0kK7du2QmJhYrE6//vor6tevD6FQCFtbW77X6P26LFq0CEOHDoVYLIaNjQ3Cw8Px/PlzdO/eHWKxGB4eHnLf3EkeekaFUBcA6c+lh7OlvRDA0LSglK0+TVayAHf3iqFrU4DPfngBxwFvcGOxAR4cUl5izHEMU7pfRsxDczx4aqSwOKrYvxRTcTFVFVdVba1sJIyTa5JVkyZNcOjQIezduxdubm4IDg7G2rVrMXjwYLnqRwlNJXf27Fncv38fZ8+exc6dOxEaGorQ0NAS171+/ToAICQkBCkpKfz8xYsXMXToUEyePBmxsbHYunUrQkNDsXjxYgDvBmT16tULmpqauHbtGrZs2YJZs2bJXMdZs2YhODgYR48eRc+ePctcf9WqVWjcuDGioqIwbtw4jB07lu9uzMzMhJ+fH9zd3XHr1i0EBwcXq0tycjJ69eoFPz8/REdHY+TIkZg9e7bUOjdv3kS/fv0wYMAA3L59G0FBQQgMDCy279asWQNvb29ERUWha9eu+PLLLzF06FAMGTIEt27dQt26dTF06FCwUm4SlZubW+yyxEqPAUaueWjwTSaMXPPh2P8NHPpmISFMeb0003tegr35KwT+3F5pMQkhn0YiR++MrM98KtKtWzfcvn0bOTk5iIuLw6hRo+SuHyU0lZyhoSE2bNiAevXqoVu3bujatSsiIiJKXNfU1BQAYGBgAHNzc35+wYIFmD17NoYNGwZ7e3t07NgRwcHB2Lp1KwDg9OnTuHPnDnbt2gVPT0+0adOGH21elmPHjmH58uX47bff0L69bH+cunTpgnHjxsHBwQGzZs2CiYkJzp49CwDYs2cPOI7D9u3b4erqis6dO2PGjBlS22/evBl169bFqlWr4OzsjMGDB8Pf319qndWrV6N9+/YIDAyEk5MT/P39MWHCBKxYsaJYXcaMGQNHR0fMmzcPmZmZaNKkCfr27QsnJyfMmjULcXFxePbsWYltWbp0qdQlidbW1jLtgyKZr9RRWAAYfPArz9CkAGnPFXMRosi0EPoO0vH06hbgTYpyLnqc1vMSvF0fYfwWPzzPECs0lir2L8VUXExVxVVVWyubojsFyzopGyU0lVz9+vWhrq7Oz1tYWCA1NVWuMmJiYrBw4UKIxWJ+GjVqFFJSUpCdnY24uDhYW1vD0tKS36ZFixYyle3h4QFbW1vMnz8fWVlZMm9ThOM4mJub822Kj4+Hh4cHRKL/xlU0bdpUavu4uDg0a9ZMatmH9Y2Li4O3t7fUMm9vbyQkJKCw8L/Br+/XxczMDADg7u5ebFlp+zwgIAAZGRn8lJycXEqrS1aQr4aEv7TRsNVrfhnHMTRolYXYm4o5BWTaMA+ZD6W/hF8nCqBjqeiuc4ZpPS+hrdtDTNjih5RXemVv8olUsX8ppuJiqiquqtpa2RSCk2tStpqTWlYienp6yMjIKLY8PT0d+vr6Uss0NDSk5jmOg0Qi3+W1WVlZWLBgAXr16lXstfcTh/KoXbs2Dhw4gHbt2qFTp044duxYmYOAK6JNFeX9unAcV+qy0uonFApLvAxRHge3mWD62mTcjdFGfJQ2eo56DpG2BCfDFDO2xMX/NU4MrIW/t+jCpnM2XvyliYT9Omi2ME0h8YpM73UJnze8h1khvsjO1YCR7rvBlG/eaiK3QHFfRcrevxRTsTFVFVdVba1M5HuWk/L7SyihUQFnZ2ecPHmy2PJbt27Bycnpk8rW0NCQ6oEAgEaNGiE+Ph4ODg4lbuPi4oLk5GSkpKTAwsICAHD16lWZY9rY2OD8+fN8UnP8+PFyX9nk7OyMn3/+Gbm5uXyiUDQW6P36hoeHSy37sL4uLi6IjIyUWhYZGQknJyepHq/K4Hy4IfSNCzF0xlMYmhbgwT9amDPYDukvNMreuByM3fPR5vuXiF6tj9ub9CC2KkDjgAzY+b1VSLwivVvGAgA2jTsitTw4zAd/3HBWWFxl71+KqdiYqoqrqrZWJoWAzD0vir0JRMkooVGBsWPHYsOGDZg0aRJGjhwJoVCI33//HXv37sWRI0fKLuAjbG1tERERAW9vbwiFQhgaGmLevHno1q0b6tSpgz59+kBNTQ0xMTH4+++/sWjRInTo0AFOTk4YNmwYVqxYgczMTMyZM0euuNbW1jh37hzatWsHX19fHD9+XOrukLIaNGgQ5syZg9GjR2P27NlISkrCypUrAfzXW/L1119j1apVmDFjBkaOHImbN28WG+w7bdo0NGnSBMHBwejfvz+uXLmCDRs2YNOmTXLXSRnCQ0wQHmKitHhW7XJg1S5HafEAoMX0MUqN9z5l71+KWT3jqqqtlUVl76GhMTQqYG9vjwsXLuDOnTvo0KEDmjVrhv379+OXX35Bp06dPqnsVatW4dSpU7C2tkbDhg0BAL6+vjh69ChOnjyJJk2aoHnz5lizZg1/0yI1NTUcOnQIb9++RdOmTTFy5Ej+Cih5WFlZ4dy5c3jx4gV8fX3LdcWPnp4ejhw5gujoaDRo0ABz5szBvHnzAPx3eqxOnTr49ddfcfjwYXh6emLLli3FBjE3atQI+/fvR1hYGNzc3DBv3jwsXLiw2OBhQgghslHUjfUqCsdKux6VkEpi9+7dGD58ODIyMqClpaXq6nxUZmYm9PX14YPuEHDK64oefOdfpcV63+aFfZQeU2+P7KdDCaksClg+zuE3ZGRklKv3WpWKvtdmX+kMoVi277XcrHx81+KYUttLp5xIpbNr1y7Y29ujdu3aiImJwaxZs9CvX79Kn8wQQkh1Vp6HUyoTJTSk0nn69CnmzZuHp0+fwsLCAn379i3XKTBCCCEVR547AMtzp+CKQgkNqXRmzpyJmTNnqroahBBC3iPPM5rkeZZTRaGEhhBCCCFloh4aQgghhFR5Ejme0STvs5wqAiU0hBBCCClTIeNQKGPPi6zrVSRKaAghhBBSJjrlRAhROFXcDwYAMuoqv1vZoIGr0mNKomOVHpMoXuag5kqLVZifA+z/TWnxFIHJcadgRpdtE0IIIaQykucp2vS0bUIIIYRUShIm+6kkiQqeQUAJDSGEEELKVNkfTkkJDSGEEELKJAEHiYynkmRdryJRQkMIIYSQMtFl24QQQgip8ir7KSflRySEEEIIqWDUQ0MIIYSQMkkgx431aAwNITWTn/8L9BmbCiPTAjyI1cKmubURH62tkFhDP4tCW/eHsDFNR26BOm4nmmPT782Q9NxAIfGK9K//NwbU/we1dV8DAO69MsLmm164mGSjsJhubqno0zsODg5pMDZ+i4XBrXHlipXC4r1Pme9pTYup7Liq+sxUNkyOQcFMBQkNnXIiNQbHcTh8+DAAIDExERzHITo6WqV1AoC2X6Rh9Pwn2L3aHON9nfAgVoTFex5A3zhfIfEa2j/Br5H1Mer7Hpi8tRsE6hKsHf07RJqKiVfkWZYYa642R98DfdD3QB9ce1wbGzodh4PhK4XFFIkK8OChITZt8lJYjJIo+z2tSTFVEVdVn5nKpujRB7JOykYJDakS/P390aNHjworz9raGikpKXBzc6uwMsur1+gXOL7HCCf3GSEpQYT1s6yQ+5aD70DF/KGf+kNX/HHDGQ+fGeFeijEWhfnAwjAL9ayeKyRekXOPbHEhyQaPMgzwKMMA6/5shux8DXiYPVNYzBs3LLFrlwcuX7FWWIySKPs9rUkxVRFXVZ+ZyqZoULCsk7JRQkNqJHV1dZibm0MgUO1ZV4GGBI4e2bh1UZdfxhiHqIu6cPXKVkodxKI8AEBmtkgp8QBAjZOgs0MCtDTyEfPMTGlxlUEV72lNianKuO9TxWemMqAeGkIqmI+PDyZNmoSZM2fCyMgI5ubmCAoKklonISEBbdq0gUgkgqurK06dOiX1+oennAoLC/HVV1/Bzs4OWlpacHZ2xrp16xTeFj2jQqgLgPTn0olV2gsBDE0LFB6f4ximdL+MmIfmePDUSOHxHI1e4sbI7YgevQ3z21zApOOdcD9N8XGVSRXvaU2Jqcq4RZT9malMim6sJ+skj6CgIHAcJzXVq1dPrjJoUDCpknbu3IlvvvkG165dw5UrV+Dv7w9vb2907NgREokEvXr1gpmZGa5du4aMjAxMmTLlo+VJJBJYWVnhl19+gbGxMS5fvozRo0fDwsIC/fr1K3W73Nxc5Obm8vOZmZkV1USlmN7zEuzNX2HMxu5KiZeYboBe+/tBrJkH37r3seSzMxj2W/dql9SQ6kvZn5nKRJ6el/L00NSvXx+nT5/m5+XtQaeEhlRJHh4emD9/PgDA0dERGzZsQEREBDp27IjTp0/jzp07OHHiBCwtLQEAS5YsQefOnUstT0NDAwsWLODn7ezscOXKFezfv/+jCc3SpUultpNX5it1FBYABh/8sjQ0KUDac8V+PKf1vARv10cYu+kLPM8QKzRWkXyJOpIy9QEAsS9M4VYrFV+630bQhbZKia8MqnhPa0pMVcYFVPOZqUwUndAIBAKYm5vLvV0ROuVEqiQPDw+peQsLC6SmpgIA4uLiYG1tzSczANCiRYsyy9y4cSO8vLxgamoKsViMbdu2ISkp6aPbBAQEICMjg5+Sk5PlakdBvhoS/tJGw1av+WUcx9CgVRZibyrq0leGaT0voa3bQ0zY4oeUV3oKilM2jmPQUC9UWXxFUMV7WlNiqi5u5fnMqFJ5xtBkZmZKTe/3aH8oISEBlpaWsLe3x+DBg8v8/v0QJTSkStLQ0JCa5zgOEomk3OWFhYVh+vTp+Oqrr3Dy5ElER0dj+PDhyMvL++h2QqEQenp6UpO8Dm4zQedBr9Ch7ytYO+Rg4nf/QqQtwckwxZyGmd7rEnwbJWD+7vbIztWAkW42jHSzIRQodvzB1GZX4WXxBJa6mXA0eompza6iqeUTHE1wVFhMkSgf9vZpsLdPAwCYmWXB3j4NpqZvFBYTUP57WpNiqiKuqj4zlU15Ehpra2vo6+vz09KlS0ssu1mzZggNDcXx48exefNmPHz4EK1bt8br169LXL8kdMqJVDsuLi5ITk5GSkoKLCwsAABXr1796DaRkZFo2bIlxo0bxy+7f/++QutZ5Hy4IfSNCzF0xlMYmhbgwT9amDPYDukvNMreuBx6t4wFAGwad0RqeXCYD/644ayQmABgpPUW3312BqY6b/A6TxN3Xxpj1NFuuPKv4i6pdnR8heXLzvDzY0ZHAQBOnbLD6jXNFRZX2e9pTYqpiriq+sxUNgyy3wGY/f/f5ORkqR96QqGwxPXfHxLg4eGBZs2awcbGBvv378dXX30lU0xKaEi106FDBzg5OWHYsGFYsWIFMjMzMWfOnI9u4+joiF27duHEiROws7PDTz/9hOvXr8POzk4pdQ4PMUF4iIlSYrWYPkYpcT4UeK6d0mPevm2Gzl0GKj0uoNz3tKbFVHZcVX1mKpvyjKEpb8+1gYEBnJyccO/ePZm3oVNOpNpRU1PDoUOH8PbtWzRt2hQjR47E4sWLP7rNmDFj0KtXL/Tv3x/NmjXDy5cvpXprCCGkplPmfWiysrJw//59vpddFhxjjJW9GiFEFpmZmdDX14cPukPAKbbbXSruIMWdPvmYjLrK/01kcyRd6TEl0bFKj0kUT5mfm8L8HNzcPxcZGRnl6rFQpaLvtTZHxkGgU/Ipow8VvMnFBb9NMrd3+vTp8PPzg42NDZ48eYL58+cjOjoasbGxMDU1lSkmnXIihBBCSJkUedn2v//+i4EDB+Lly5cwNTVFq1atcPXqVZmTGYASGkIIIYTIgDEOTMZERdb1ioSFhZWnSlIooSGEEEJImeR5pIG8jz6oCJTQEEIIIaRMir5T8KeihIYQQgghZVLkKaeKQAkNIYQQQspEPTSEEEIIqfKoh4YQonB6ez7+aAeFxVVF0AauSg+ZHNhS6TEBwDr4skri1hTK/NwUsHylxVIUJkcPDSU0hBBCCKmUGABZb8Wrijv2UkJDCCGEkDJJwIGjy7YJIYQQUpXRGBpCCCGEVHkSxoGjq5wIIYQQUpUxJscYGhUMoqGEhhBCCCFlolNOhBBCCKnyKKEhhBBCSJVHY2gIIYQQUuXRGBpCSJn8/F+gz9hUGJkW4EGsFjbNrY34aO1qF1PZcd3cUtGndxwcHNJgbPwWC4Nb48oVK4XEKtK//t8YUP8f1NZ9DQC498oIm2964WKSjULjAnQcVde2VhbvEhpZTzkpuDIlUFN+SELK5u/vjx49eqi6GkrR9os0jJ7/BLtXm2O8rxMexIqweM8D6Bsr7lbpqoipirgiUQEePDTEpk1eCim/JM+yxFhztTn6HuiDvgf64Nrj2tjQ6TgcDF8pNC4dR9WzrZVJ0RgaWSdlo4SGEBXrNfoFju8xwsl9RkhKEGH9LCvkvuXgO1BxfwBVEVMVcW/csMSuXR64fMVaIeWX5NwjW1xIssGjDAM8yjDAuj+bITtfAx5mzxQal46j6tnWyoTJOSmbTAlNeHi4zBMhFe348eNo1aoVDAwMYGxsjG7duuH+/fv864mJieA4DmFhYWjZsiVEIhHc3Nxw/vx5fp3CwkJ89dVXsLOzg5aWFpydnbFu3TqpOEW9QitXroSFhQWMjY0xfvx45Ocr7heYQEMCR49s3Lqoyy9jjEPURV24emVXm5iqjKtKapwEnR0SoKWRj5hnZgqLQ8dR9WxrZVPZe2hkGkMja9c/x3EoLCz8lPoQUsybN2/wzTffwMPDA1lZWZg3bx569uyJ6OhoqKn9l5PPmDEDa9euhaurK1avXg0/Pz88fPgQxsbGkEgksLKywi+//AJjY2NcvnwZo0ePhoWFBfr168eXcfbsWVhYWODs2bO4d+8e+vfvjwYNGmDUqFEl1i03Nxe5ubn8fGZmplxt0zMqhLoASH8u/VFMeyGAtUNuKVt9GlXEVGVcVXA0eom9vQ5CU70Q2fkamHS8E+6nGSksHh1H1bOtlY48XS+VdVCwRCJRdD0IKVXv3r2l5n/88UeYmpoiNjYWbm5u/PIJEybw627evBnHjx/Hjh07MHPmTGhoaGDBggX8unZ2drhy5Qr2798vldAYGhpiw4YNUFdXR7169dC1a1dERESUmtAsXbpUqlxCACAx3QC99veDWDMPvnXvY8lnZzDst+4KTWoIqek+aQxNTk5ORdWDkFIlJCRg4MCBsLe3h56eHmxtbQEASUlJUuu1aNGC/79AIEDjxo0RFxfHL9u4cSO8vLxgamoKsViMbdu2FSujfv36UFdX5+ctLCyQmppaat0CAgKQkZHBT8nJyXK1LfOVOgoLAAPTAqnlhiYFSHuumIsQVRFTlXFVIV+ijqRMfcS+MMWaa80R/9IYX7rfVlg8Oo6qZ1srHXlON1WFQcGFhYUIDg5G7dq1IRaL8eDBAwBAYGAgduzYUeEVJMTPzw+vXr3C9u3bce3aNVy7dg0AkJeXJ3MZYWFhmD59Or766iucPHkS0dHRGD58eLEyNDQ0pOY5jvtoD6VQKISenp7UJI+CfDUk/KWNhq1evxeToUGrLMTeVMzloKqIqcq4lQHHMWioK+50PB1H1bOtlU3RfWhknZRN7oRm8eLFCA0NxfLly6Gpqckvd3Nzww8//FChlSPk5cuXiI+Px9y5c9G+fXu4uLggLS2txHWvXr3K/7+goAA3b96Ei4sLACAyMhItW7bEuHHj0LBhQzg4OEgNLFalg9tM0HnQK3To+wrWDjmY+N2/EGlLcDJMcacnVBFTFXFFonzY26fB3v7dMWNmlgV7+zSYmr5RSDwAmNrsKrwsnsBSNxOORi8xtdlVNLV8gqMJjgqLCdBxVF3bWplUi0HB79u1axe2bduG9u3b4+uvv+aXe3p64s6dOxVaOUIMDQ1hbGyMbdu2wcLCAklJSZg9e3aJ627cuBGOjo5wcXHBmjVrkJaWhhEjRgAAHB0dsWvXLpw4cQJ2dnb46aefcP36ddjZ2SmzOSU6H24IfeNCDJ3xFIamBXjwjxbmDLZD+guNsjeuQjFVEdfR8RWWLzvDz48ZHQUAOHXKDqvXNFdITCOtt/juszMw1XmD13mauPvSGKOOdsOVfxV76TgdR9WzrZWKPKeSqkJC8/jxYzg4OBRbLpFIFHp5K6lZJBIJBAIB1NTUEBYWhkmTJsHNzQ3Ozs5Yv349fHx8im3z3Xff4bvvvkN0dDQcHBwQHh4OExMTAMCYMWMQFRWF/v37g+M4DBw4EOPGjcOxY8eU3LKShYeYIDzEpNrHVHbc27fN0LnLQKXEKhJ4rp1S472PjqPqF7MyqXaPPnB1dcXFixdhYyN9G+8DBw6gYcOGFVYxUrOlpqbyiXOHDh0QGxsr9Tor4dPi4uLCj6/5kFAoREhICEJCQqSWL126lP9/aGhose3Wrl0rZ80JIaSaqg6Xbb9v3rx5GDZsGB4/fgyJRIKDBw8iPj4eu3btwtGjRxVRR1KDpKWlITIyEufOnZM6pUkIIUS15Bkb8yljaL777jsEBARg8uTJcv2olHtQcPfu3XHkyBGcPn0aOjo6mDdvHuLi4nDkyBF07NhR3uIIkTJixAh8/fXXmDZtGrp3767q6hBCCHmfgp97cP36dWzduhUeHh5yb1uuC+hbt26NU6dOlWdTQj7q0KFDcm9ja2tb4ikoQgghFUfRPTRZWVkYPHgwtm/fjkWLFsm9fbnvCHTjxg3+pmWurq7w8lLe02wJIYQQomTlGEPz4eNghEIhhEJhiZuMHz8eXbt2RYcOHZST0Pz7778YOHAgIiMjYWBgAABIT09Hy5YtERYWBisrK7krQQghhJDKjvv/JOu6gLW19O0K5s+fj6CgoGJrh4WF4datW7h+/Xq5ayd3QjNy5Ejk5+cjLi4Ozs7OAID4+HgMHz4cI0eOxPHjx8tdGUIIIYRUUuXooUlOTpa6g3pJvTPJycmYPHkyTp06BZFIVO7qyZ3QnD9/HpcvX+aTGQBwdnbG999/j9atW5e7IoQQQgipxMqR0MjySJibN28iNTUVjRo14pcVFhbiwoUL2LBhA3Jzc6WesVcauRMaa2vrEm+gV1hYCEtLS3mLI4QQuUiiY8teqYLF/hGt9JgA4BvcQCVxawq1Bq7Ki1WYC/z1m9LiKYSC7hTcvn173L4t/fDW4cOHo169epg1a5ZMyQxQjoRmxYoVmDhxIjZu3IjGjRsDeDdAePLkyVi5cqW8xRFCCCGkClDUnYJ1dXXh5uYmtUxHRwfGxsbFln+MTAmNoaEhOO6/bOvNmzdo1qwZBIJ3mxcUFEAgEGDEiBHo0aOHzMEJIYQQUkVUhzsF0+3fCSGEkBpOiQ+nPHfunNzbyJTQDBs2TO6CCSGEEFJ9cOzdJOu6ylbuG+sBQE5ODvLy8qSWlTWamRBCCCFVUCU/5ST3s5zevHmDCRMmoFatWtDR0YGhoaHURAghhJBqqOiUk6yTksmd0MycORNnzpzB5s2bIRQK8cMPP2DBggWwtLTErl27FFFHQgghhKiarA+m/MQHVJaX3Kecjhw5gl27dsHHxwfDhw9H69at4eDgABsbG+zevRuDBw9WRD0JIYQQokrV7ZTTq1evYG9vD+DdeJlXr14BAFq1aoULFy5UbO0IIYQQUjlUtx4ae3t7PHz4EHXq1EG9evWwf/9+NG3aFEeOHOEfVkkIkY+f/wv0GZsKI9MCPIjVwqa5tREfrV3tYqoqrjJjDm3qimf/ahavw7DnmLD0sUJi8jGq+b5VZVw3t1T06R0HB4c0GBu/xcLg1rhypYY9jFmJl22Xh9w9NMOHD0dMTAwAYPbs2di4cSNEIhGmTp2KGTNmVHgFieL5+/uXeEPEc+fOgeM4pKenK71OH/Lx8cGUKVOklq1btw5CoRBhYWGqqVQFaftFGkbPf4Ldq80x3tcJD2JFWLznAfSNiz9ipCrHVFVcZcdcfywee6P/5qelYfcAAK39MhQSr0hN2LeqjCsSFeDBQ0Ns2uSlsBiVXdFl27JOyiZ3QjN16lRMmjQJANChQwfcuXMHe/bsQVRUFCZPnlzhFSSkJPPnz8e3336L3377DQMGDFB1dT5Jr9EvcHyPEU7uM0JSggjrZ1kh9y0H34GvqlVMVcVVdkwD40IY1Srgp2un9WFhmwuPFlkKiVekJuxbVca9ccMSu3Z54PIVa4XFqPQq+SknuROaD9nY2KBXr17w8PCoiPqQSu7XX39F/fr1IRQKYWtri1WrVkm9bmtriyVLlmDEiBHQ1dVFnTp1sG3bNql1Ll++jAYNGkAkEqFx48Y4fPgwOI5DdHR0mfEZY5g4cSLWr1+PU6dOoVOnTgAAiUSChQsXwsrKCkKhEA0aNMDx48f57RITE8FxHA4ePIh27dpBW1sbnp6euHLlilT527dvh7W1NbS1tdGzZ0+sXr1aoadSBRoSOHpk49ZF3ffayCHqoi5cvbKrTUxVxVVVW4vk53E486shfAe8BKfAHviatG9V/Z6SykumMTTr16+XucCi3htS/dy8eRP9+vVDUFAQ+vfvj8uXL2PcuHEwNjaGv78/v96qVasQHByMb7/9FgcOHMDYsWPRtm1bODs7IzMzE35+fujSpQv27NmDR48eFTuVVJqCggIMGTIEZ86cwfnz56WS6HXr1mHVqlXYunUrGjZsiB9//BFffPEF/vnnHzg6OvLrzZkzBytXroSjoyPmzJmDgQMH4t69exAIBIiMjMTXX3+NZcuW4YsvvsDp06cRGBj40Trl5uYiNzeXn8/MzJRtZ/6fnlEh1AVA+nPpj2LaCwGsHXJL2erTqCKmquKqqq1FLh/XR1amOj7vp9gei5q0b1X9ntZkHOS4U7BCa1IymRKaNWvWyFQYx3GU0FRRR48ehVgsllpWWFgoNb969Wq0b9+e/yPv5OSE2NhYrFixQiqh6dKlC8aNGwcAmDVrFtasWYOzZ8/C2dkZe/bsAcdx2L59O0QiEVxdXfH48WOMGjWqzDpu374dABATE4N69epJvbZy5UrMmjWLP/20bNkynD17FmvXrsXGjRv59aZPn46uXbsCABYsWID69evj3r17qFevHr7//nt07twZ06dP59t3+fJlHD16tNQ6LV26FAsWLCiz7qRmOrHXCE3aZcLYvEDVVSHk01WHQcEPHz6UaXrw4IGi60sUpF27doiOjpaafvjhB6l14uLi4O3tLbXM29sbCQkJUsnP+z0nHMfB3NwcqampAID4+Hh4eHhAJBLx6zRt2lSmOrZq1QpisRiBgYEoKPjvD0RmZiaePHlSYt3i4uKklr1fNwsLCwCQqtuHdSmrbgEBAcjIyOCn5ORkmdrC1/2VOgoLAANT6T94hiYFSHv+SU8mqVQxVRVXVW0FgGf/aiDqoi46DXqp0DhAzdq3qnxPa7zqPoaGVA86OjpwcHCQmmrXrl2usjQ0NKTmOY6DRCL55Dq6u7sjIiICZ8+eRf/+/aWSmvLUjfv/oIZPqZtQKISenp7UJI+CfDUk/KWNhq1ev1cvhgatshB7UzGXoKoipqriqqqtAHAyzBgGJgVo1kG+05DlUZP2rSrf0xqPEhpSXbi4uCAyMlJqWWRkJJycnKCuri5TGc7Ozrh9+7bUuJPr16/LXIcGDRogIiICFy5cQL9+/ZCfnw89PT1YWlqWWDdXV1eZy3Z2di5WF3nqVl4Ht5mg86BX6ND3FawdcjDxu38h0pbgZJhRtYqpqriqiCmRACf3GaFD31dQV1KnQU3Zt6qKKxLlw94+Dfb2aQAAM7Ms2NunwdT0jcJiVjaV/bJt6p8jMps2bRqaNGmC4OBg9O/fH1euXMGGDRuwadMmmcsYNGgQ5syZg9GjR2P27NlISkrCypUrAfzXY1IWT09PnDlzBu3bt0e/fv2wf/9+zJgxA/Pnz0fdunXRoEEDhISEIDo6Grt375a5bhMnTkSbNm2wevVq+Pn54cyZMzh27JjM9Sqv8+GG0DcuxNAZT2FoWoAH/2hhzmA7pL/QKHvjKhRTVXFVETPqgi5SH2vCd4BiBwO/r6bsW1XFdXR8heXLzvDzY0ZHAQBOnbLD6jXNFRa3Uqnkjz6ghIbIrFGjRti/fz/mzZuH4OBgWFhYYOHChVIDgsuip6eHI0eOYOzYsWjQoAHc3d0xb948DBo0SGpcTVnc3d35pKZv377Yv38/MjIyMG3aNKSmpsLV1RXh4eFSVziVxdvbG1u2bMGCBQswd+5c+Pr6YurUqdiwYYPMZZRXeIgJwkNMFB5H1TFVFVfZMb18XuPEk2ilxStSE/atquLevm2Gzl0GKi1epVTJExqOMaaCsIT8Z/fu3Rg+fDgyMjKgpaWl6upIGTVqFO7cuYOLFy/KtH5mZib09fXhg+4QcIr9lUqURxXJCQD4WjZQSdyaQq2B7KekP1VBYS7O/LUMGRkZco+1U7Wi7zW7hYuhJuMPT0lODh7Om6PU9pZrDM3FixcxZMgQtGjRAo8fv3s2yU8//YRLly5VaOVI9bRr1y5cunQJDx8+xOHDhzFr1iz069evUiQzK1euRExMDO7du4fvv/8eO3fuxLBhw1RdLUIIUb2iy7ZlnZRM7oTm119/ha+vL7S0tBAVFcUP7szIyMCSJUsqvIKk+nn69CmGDBkCFxcXTJ06FX379i12N2FV+fPPP9GxY0e4u7tjy5YtWL9+PUaOHKnqahFCCCmD3GNoFi1ahC1btmDo0KFSDwX09vbGokWLKrRypHqaOXMmZs6cqepqlGj//v2qrgIhhFROlXwMjdwJTXx8PNq0aVNsub6+fqV4KjMhhBBCKp48l2NXiadtm5ub4969e8WWX7p0Cfb29hVSKUIIIYRUMtXtxnqjRo3C5MmTce3aNXAchydPnmD37t2YPn06xo4dq4g6EkIIIUTV5LmpXlU45TR79mxIJBK0b98e2dnZaNOmDYRCIaZPn46JEycqoo6EEEIIUbXqNoaG4zjMmTMHM2bMwL1795CVlQVXV9diT2omhBBCSDVS3RKaIpqamnI9J4cQQiqCMm+GVsTXUukhAQAJoV5Kj+nof1PpMVVFEh2rvFgsX2mxFEWRg4I3b96MzZs3IzExEQBQv359zJs3D507d5a5DLkTmnbt2n302TZnzpwp9TVCCCGEkA9ZWVnhu+++g6OjIxhj2LlzJ7p3746oqCjUr19fpjLkTmgaNGggNZ+fn4/o6Gj8/fffdEdVQgghpLpS4CknPz8/qfnFixdj8+bNuHr1quISmjVr1pS4PCgoCFlZWfIWRwghhJAqoDynnDIzM6WWC4VCCIXCj25bWFiIX375BW/evEGLFi1krl+5nuVUkiFDhuDHH3+sqOIIIYQQUtnIeQ8aa2tr6Ovr89PSpUtLLfr27dsQi8UQCoX4+uuvcejQIbnG6pZ7UPCHrly5ApGMT+EkhBBCSBVTjlNOycnJUk/b/ljvjLOzM6Kjo5GRkYEDBw5g2LBhOH/+vMxJjdwJTa9evaTrzBhSUlJw48YNBAYGylscIYQQQqqA8pxy0tPTk0poPkZTUxMODg4AAC8vL1y/fh3r1q3D1q1bZdpe7oRGX19fal5NTQ3Ozs5YuHAhPv/8c3mLI4QQQkhVoOT70EgkEuTm5sq8vlwJTWFhIYYPHw53d3cYGhrKXTlCCCGEVE2KvA9NQEAAOnfujDp16uD169fYs2cPzp07hxMnTshchlwJjbq6Oj7//HPExcVRQkNIBfLzf4E+Y1NhZFqAB7Fa2DS3NuKjtatdTGXHdXNLRZ/ecXBwSIOx8VssDG6NK1esFBLrQ6ravwBgePQpTA48RlrHWngx2FqhsWrCcaTKmJWKAntoUlNTMXToUKSkpEBfXx8eHh44ceIEOnbsKHMZcl/l5ObmhgcPHsi7GSEViuM4HD58uNTXz507B47jkJ6errQ6lVfbL9Iwev4T7F5tjvG+TngQK8LiPQ+gb6y4O4uqIqYq4opEBXjw0BCbNin3jruq2r8AIHzwBvrnniPXWkvhsWrKcaSqmJWOAp+2vWPHDiQmJiI3Nxepqak4ffq0XMkMUI6EZtGiRZg+fTqOHj2KlJQUZGZmSk2EVISnT59i4sSJsLe3h1AohLW1Nfz8/BARESHT9i1btuQz/cqu1+gXOL7HCCf3GSEpQYT1s6yQ+5aD78BX1SqmKuLeuGGJXbs8cPmKYnspPqSq/cvlFMJ860M8G26DQm11hcYCas5xpKqYlY2sT9qW59RURZI5oVm4cCHevHmDLl26ICYmBl988QWsrKxgaGgIQ0NDGBgY0GkoUiESExPh5eWFM2fOYMWKFbh9+zaOHz+Odu3aYfz48TKVoampCXNz848+pqMyEGhI4OiRjVsXdflljHGIuqgLV6/sahNTlXGVTZXtrPVTEt546uNtfdmuKvkUNek4qinHbpkU2ENTEWROaBYsWIA3b97g7Nmz/HTmzBl+Kpon5FONGzcOHMfhzz//RO/eveHk5IT69evjm2++wdWrV/n1Xrx4gZ49e0JbWxuOjo4IDw/nX/vwlFNoaCgMDAxw4sQJuLi4QCwWo1OnTkhJSeG3uX79Ojp27AgTExPo6+ujbdu2uHXrlkLbqmdUCHUBkP5cejhb2gsBDE0Lqk1MVcZVNlW1U3z1FYSPsvGyT22FxXhfTTqOasqxW6ZKntDIPCiYsXe1a9u2rcIqQ8irV69w/PhxLF68GDo6OsVeNzAw4P+/YMECLF++HCtWrMD333+PwYMH49GjRzAyMiqx7OzsbKxcuRI//fQT1NTUMGTIEEyfPh27d+8GALx+/RrDhg3D999/D8YYVq1ahS5duiAhIQG6urollpmbmyt1WSGddiWqIHiZB9M9yXg8wxFMs8JuAE+IFEVe5VQR5LrKqbJ335Oq7969e2CMoV69emWu6+/vj4EDBwIAlixZgvXr1+PPP/9Ep06dSlw/Pz8fW7ZsQd26dQEAEyZMwMKFC/nXP/vsM6n1t23bBgMDA5w/fx7dunUrscylS5diwYIFMrWtJJmv1FFYABh88CvP0KQAac8r7EbeKo+pyrjKpop2ChOzIcgsQJ35cfwyTgJo3c2CQUQq7v3QCFCr2O/vmnQc1ZRjt0xKvg+NvORK5Z2cnGBkZPTRiZBPUdQTKAsPDw/+/zo6OtDT00Nqamqp62tra/PJDABYWFhIrf/s2TOMGjUKjo6O0NfXh56eHrKyspCUlFRqmQEBAcjIyOCn5ORkmesPAAX5akj4SxsNW73ml3EcQ4NWWYi9qZjLQVURU5VxlU0V7cx21cWjRa5IWvjflGOnjdfNjZC00LXCkxmgZh1HNeXYLUtlHxQsV2q5YMGCKnHVCKm6HB0dwXEc7ty5U+a6GhoaUvMcx0Eikci1/vsJ1LBhw/Dy5UusW7cONjY2EAqFaNGiBfLy8kotU5Ynx5bl4DYTTF+bjLsx2oiP0kbPUc8h0pbgZJjifiCoIqYq4opE+bC0zOLnzcyyYG+fhtevNfH8efFTmhVF2e1kWurIs5K+TFuiqYZCsaDY8opUU44jVcWsdCp5D41cCc2AAQNQq1YtRdWFEBgZGcHX1xcbN27EpEmTio2jSU9PlxpHU5EiIyOxadMmdOnSBcC7h6q9ePFCIbHedz7cEPrGhRg64ykMTQvw4B8tzBlsh/QXGmVvXIViqiKuo+MrLF/238UKY0ZHAQBOnbLD6jXNFRITUN3+VbaachypKmalU10SGho/Q5Rl48aN8Pb2RtOmTbFw4UJ4eHigoKAAp06dwubNmxEXF1d2IeXg6OiIn376CY0bN0ZmZiZmzJgBLS3F35wMAMJDTBAeYqKUWKqMqey4t2+boXOXgUqJ9SFV7d8ijwOclRKnJhxHqoxZmXD/n2RdV9lkHkMjz9gGQj6Fvb09bt26hXbt2mHatGlwc3NDx44dERERgc2bNyss7o4dO5CWloZGjRrhyy+/xKRJk6hHkhBCilTyy7Y5RpkKIRUmMzMT+vr68EF3CLga1BWtRGoNXJUeUxIdq/SYAJAQqtxHNgCAo/9NpcesCQpYPs7hN2RkZEBPT/E3PqxIRd9r9b9eAnWhSKZtCnNz8M+Wb5Xa3hp0vRkhhBBCyq26jKEhhBBCSA1Xic/pUEJDCCGEkDJVqzsFE0IIIaSGolNOhBBCCKnqqIeGEEIIIVUf9dAQQgghpKqjHhpCCKlAqronjCqo4p4wGucslB4z3ydF6TFJ9UMJDSGEEELKRqecCCGEEFLlUUJDCCGEkKqOxtAQQgghpOqjHhpCCCGEVHUcY+BkfJ61rOtVJEpoCCGEEFI26qEhhBBCSFVHY2gIIYQQUvVV8h4aNeWHJIR8yM//BXZei8WRB39h3dEEODfIrpYxVRWXYipGYchr5PukSE9fpio0ZpGasH8rm6IeGlknWS1duhRNmjSBrq4uatWqhR49eiA+Pl7u+lFCQ4iKtf0iDaPnP8Hu1eYY7+uEB7EiLN7zAPrG+dUqpqriUkzFvqewFUDwa63/pu9NFBsPNWz/ViZMzklG58+fx/jx43H16lWcOnUK+fn5+Pzzz/HmzRu5qkcJDSmXp0+fYvLkyXBwcIBIJIKZmRm8vb2xefNmZGfXrF8tn6rX6Bc4vscIJ/cZISlBhPWzrJD7loPvwFfVKqaq4lJMxb6nUAc4Y/X/JgPF/1mpUfu3ElFUD83x48fh7++P+vXrw9PTE6GhoUhKSsLNm/I9+oMSGiK3Bw8eoGHDhjh58iSWLFmCqKgoXLlyBTNnzsTRo0dx+vTpcpWbl5dXwTWt/AQaEjh6ZOPWRV1+GWMcoi7qwtVLMYmhKmKqKi7FVOx7CgB4XIj83s+QPzAVBYvSwJ4VKjRcjdu/lUk5emgyMzOlptzc3DLDZGRkAACMjIzkqh4lNERu48aNg0AgwI0bN9CvXz+4uLjA3t4e3bt3x++//w4/Pz8AQHp6OkaOHAlTU1Po6enhs88+Q0xMDF9OUFAQGjRogB9++AF2dnYQiUQAAI7jsHXrVnTr1g3a2tpwcXHBlStXcO/ePfj4+EBHRwctW7bE/fv3+bLu37+P7t27w8zMDGKxGE2aNCmWWNna2mLJkiUYMWIEdHV1UadOHWzbto1//bPPPsOECROktnn+/Dk0NTURERFR4fsRAPSMCqEuANKfS4/PT3shgKFpQbWJqaq4FFOx7ynnqgH12foQLDeC+lR9IKUQBZNegmVLFBazJu3fykje3hlra2vo6+vz09KlSz9avkQiwZQpU+Dt7Q03Nze56kYJDZHLy5cvcfLkSYwfPx46OjolrsNxHACgb9++SE1NxbFjx3Dz5k00atQI7du3x6tX/3XR3rt3D7/++isOHjyI6OhofnlwcDCGDh2K6Oho1KtXD4MGDcKYMWMQEBCAGzdugDEmlXxkZWWhS5cuiIiIQFRUFDp16gQ/Pz8kJSVJ1W3VqlVo3LgxoqKiMG7cOIwdO5YffDZy5Ejs2bNH6hfEzz//jNq1a+Ozzz4rsa25ubnFfoEQUlOoNRNBzUcLXF0NqDUVQv07IyBLAnY2R9VVI4rAmHwTgOTkZGRkZPBTQEDAR0OMHz8ef//9N8LCwuSuHiU0RC737t0DYwzOzs5Sy01MTCAWiyEWizFr1ixcunQJf/75J3755Rc0btwYjo6OWLlyJQwMDHDgwAF+u7y8POzatQsNGzaEh4cHv3z48OHo168fnJycMGvWLCQmJmLw4MHw9fWFi4sLJk+ejHPnzvHre3p6YsyYMXBzc4OjoyOCg4NRt25dhIeHS9WzS5cuGDduHBwcHDBr1iyYmJjg7NmzAIBevXoBAH777Td+/dDQUPj7+/NJ2oeWLl0q9evD2tparv2Z+UodhQWAwQe/8gxNCpD2XDF3VVBFTFXFpZiKfU8/xOmqgbMSgD1WXK9FTd6/qlaeMTR6enpSk1AoLLX8CRMm4OjRozh79iysrKzkrh8lNKRC/Pnnn4iOjkb9+vWRm5uLmJgYZGVlwdjYmE90xGIxHj58KHWqyMbGBqampsXKez+5MTMzAwC4u7tLLcvJyeF7RLKysjB9+nS4uLjAwMAAYrEYcXFxxXpo3i+X4ziYm5sjNfXdZaYikQhffvklfvzxRwDArVu38Pfff8Pf37/UdgcEBEj9+khOTpZ1lwEACvLVkPCXNhq2ev1evRgatMpC7E1tucqqzDFVFZdiKvY9/RDLloA9KQCM1RUWoybvX5VT0FVORT3uhw4dwpkzZ2BnZ1eu6tWc1JJUCAcHB3AcV+weAfb29gAALS0tAO8SDAsLC6lelCIGBgb8/0s7baWhocH/v6h3pKRlEsm7c/XTp0/HqVOnsHLlSjg4OEBLSwt9+vQpNtD4/TKKyikqA3h32qlBgwb4999/ERISgs8++ww2NjYl1hEAhELhR39xyOLgNhNMX5uMuzHaiI/SRs9RzyHSluBkmHwD4ip7TFXFpZiKi1m4KRNcSyE4M3WwlxJIQl4DahzU2osUFhOoOfu3suEk7yZZ15XV+PHjsWfPHvz222/Q1dXF06dPAQD6+vr83xRZUEJD5GJsbIyOHTtiw4YNmDhxYqkJSaNGjfD06VMIBALY2toqvF6RkZHw9/dHz549AbxLqBITE+Uux93dHY0bN8b27duxZ88ebNiwoYJrWtz5cEPoGxdi6IynMDQtwIN/tDBnsB3SX2iUvXEViqmquBRTcTHZ80JIgtOBTAmgrwbOXROCTcbgDBTXQwPUnP1b6SjoTsGbN28GAPj4+EgtDwkJ+WgP+YcooSFy27RpE7y9vdG4cWMEBQXBw8MDampquH79Ou7cuQMvLy906NABLVq0QI8ePbB8+XI4OTnhyZMn+P3339GzZ080bty4Quvk6OiIgwcPws/PDxzHITAwUKrnRR4jR47EhAkToKOjwydIihYeYoLwEMXfkEzVMVUVl2IqhmC+odJifagm7N/KRlHPcmIV9GRuGkND5Fa3bl1ERUWhQ4cOCAgIgKenJxo3bozvv/8e06dPR3BwMDiOwx9//IE2bdpg+PDhcHJywoABA/Do0SN+TExFWr16NQwNDdGyZUv4+fnB19cXjRo1KldZAwcOhEAgwMCBA/lLyQkhpMYrx1VOysSxikqNCKkmEhMTUbduXVy/fl3upCgzMxP6+vrwQXcIuBrUFU2qDY1zFkqPme+TovSYylbA8nEOvyEjIwN6enqqro5cir7XmvkFQ6Ah24+8gvwcXDsSqNT20iknQv4vPz8fL1++xNy5c9G8efNy9/AQQki1VMmftk0JDSH/FxkZiXbt2sHJyUnqXjmEEEIUN4amolBCQ8j/+fj4VNjgNEIIqXbkGRujgu9SSmgIIYQQUibqoSGEEEJI1UdjaAghhBBS1VEPDSGEEEKqPgl7N8m6rpJRQkMIIYSninvCqOLeN0DNuP9NhaJTToQQQgip6jjIccpJoTUpGSU0hBBCCCkbXbZNCCGEkKqOBgUTQgghpOqjMTSEEEIIqeo4xsDJeCpJ1vUqEiU0hBBCCCmb5P+TrOsqGSU0hBBCCClTZe+hUVN6REIIIYSQCkY9NIQQQggpGw0KJoSUxc//BfqMTYWRaQEexGph09zaiI/WrnYxVRWXYlafmIUhryHZmSW90FodGj/VUljMIqr6zFQalfw+NHTKiaiEv78/OI4rNt27d0/VVVO6tl+kYfT8J9i92hzjfZ3wIFaExXseQN84v1rFVFVcilm9YgIAbAUQ/Frrv+l7E8XGgwrbWokU3YdG1knZKKEhKtOpUyekpKRITXZ2dlLr5OXlqah2ytNr9Asc32OEk/uMkJQgwvpZVsh9y8F34KtqFVNVcSlm9YoJAFAHOGP1/yYDxf8pU1lbK5OiHhpZJyWjhIaojFAohLm5udTUvn17TJgwAVOmTIGJiQl8fX0BAKtXr4a7uzt0dHRgbW2NcePGISvrv27n0NBQGBgY4MSJE3BxcYFYLOYTpvf9+OOPqF+/PoRCISwsLDBhwgT+tfT0dIwcORKmpqbQ09PDZ599hpiYGIXuA4GGBI4e2bh1UZdfxhiHqIu6cPXKrjYxVRWXYlavmLzHhcjv/Qz5A1NRsCgN7FmhQsOptK2VCCeRb1I2SmhIpbNz505oamoiMjISW7ZsAQCoqalh/fr1+Oeff7Bz506cOXMGM2fOlNouOzsbK1euxE8//YQLFy4gKSkJ06dP51/fvHkzxo8fj9GjR+P27dsIDw+Hg4MD/3rfvn2RmpqKY8eO4ebNm2jUqBHat2+PV69K/wWWm5uLzMxMqUkeekaFUBcA6c+lh7OlvRDA0LRArrIqc0xVxaWY1SsmAHCuGlCfrQ/BciOoT9UHUgpRMOklWLbi/oKqqq2VTiXvoaFBwURljh49CrFYzM937twZAODo6Ijly5dLrTtlyhT+/7a2tli0aBG+/vprbNq0iV+en5+PLVu2oG7dugCACRMmYOHChfzrixYtwrRp0zB58mR+WZMmTQAAly5dwp9//onU1FQIhUIAwMqVK3H48GEcOHAAo0ePLrENS5cuxYIFC8rTfEJIOag1E/H/5+oCnIsGCgakgp3NAde1Bg3QVQW6yomQkrVr1w6bN2/m53V0dDBw4EB4eXkVW/f06dNYunQp7ty5g8zMTBQUFCAnJwfZ2dnQ1n73Jaatrc0nMwBgYWGB1NRUAEBqaiqePHmC9u3bl1iXmJgYZGVlwdjYWGr527dvcf/+/VLbEBAQgG+++Yafz8zMhLW1tQyt///6r9RRWAAYfPArz9CkAGnPFfPxVEVMVcWlmNUrZkk4XTVwVgKwx4rrKaksbVU1urEeIaXQ0dGBg4MDP1lYWPDL35eYmIhu3brBw8MDv/76K27evImNGzcCkB40rKGhIbUdx3Fg//9QaWlpfbQuWVlZsLCwQHR0tNQUHx+PGTNmlLqdUCiEnp6e1CSPgnw1JPyljYatXr9Xb4YGrbIQe1MxvzZVEVNVcSlm9YpZEpYtAXtSABirKyxGZWmryinwlNOFCxfg5+cHS0tLcByHw4cPy129mpNakirr5s2bkEgkWLVqFdTU3uXg+/fvl6sMXV1d2NraIiIiAu3atSv2eqNGjfD06VMIBALY2tpWRLVldnCbCaavTcbdGG3ER2mj56jnEGlLcDLMqFrFVFVcilm9YhZuygTXUgjOTB3spQSSkNeAGge19qKyN/4EqvrMVCoMsj+jSc4Omjdv3sDT0xMjRoxAr1695K0ZAEpoSBXg4OCA/Px8fP/99/Dz85MaLCyPoKAgfP3116hVqxY6d+6M169fIzIyEhMnTkSHDh3QokUL9OjRA8uXL4eTkxOePHmC33//HT179kTjxo0V0LJ3zocbQt+4EENnPIWhaQEe/KOFOYPtkP5Co+yNq1BMVcWlmNUrJnteCElwOpApAfTVwLlrQrDJGJyB4npoANV9ZioTRZ5y6ty5Mz+OsrwooSGVnqenJ1avXo1ly5YhICAAbdq0wdKlSzF06FC5yhk2bBhycnKwZs0aTJ8+HSYmJujTpw+Ad6en/vjjD8yZMwfDhw/H8+fPYW5ujjZt2sDMzEwRzZISHmKC8BDF3xxM1TFVFZdiVp+YgvmGSov1IVV9ZioNBjnuFPzunw+v/BQKhfyFFxWNY0wFI3cIqaYyMzOhr68PH3SHgKs5v9wI+RQa5yxUEjffJ6XslSpIAcvHOfyGjIwMucfaqVrR99pnnrMgUJctGSkozMWZmGXFls+fPx9BQUEf3ZbjOBw6dAg9evSQq57UQ0MIIYSQskkAcHKsCyA5OVkqgVNU7wxACQ0hhBBCZFCeMTTlufqzvCihIYQQQkjZKvnTtimhIYQQQkjZFJjQZGVl4d69e/z8w4cPER0dDSMjI9SpU0emMiihIYQQQkjZFJjQ3LhxQ+oeYUV3YB82bBhCQ0NlKoMSGkIIIYSUrRyDgmXl4+ODT73omhIaQgghhJSpsj/LiRIaQgghhJSNBgUTQhRNrYGrSuJKomOVHlNVbVUFVexfVVDmDe7elxDqpbRYkrc5wNe/KS2eQkgYwMmYqEgooSGEEEJIZUQ9NIQQQgip+uRIaOR93HYFoISGEEIIIWWjHhpCCCGEVHkSBpl7XmgMDSGEEEIqJSZ5N8m6rpJRQkMIIYSQstEpJ0IIIYRUeXTKiRBCCCFVHvXQEFI5BQUF4fDhw4iOjlZ1VeDn/wJ9xqbCyLQAD2K1sGlubcRHayssnptbKvr0joODQxqMjd9iYXBrXLlipbB471NmW1XVTlXFVfZxpKqYqowLAIZHn8LkwGOkdayFF4OtlRKzUmCQI6FRaE1KpKb8kISU7fnz5xg7dizq1KkDoVAIc3Nz+Pr6IjIyssJiTJ8+HRERERVWXnm1/SINo+c/we7V5hjv64QHsSIs3vMA+sb5CospEhXgwUNDbNqkvDulAspvq6raqYq4qjiOVBFTlXEBQPjgDfTPPUeutZbCY1U6RT00sk5KRgkNqZR69+6NqKgo7Ny5E3fv3kV4eDh8fHzw8uXLCoshFothbGxcYeWVV6/RL3B8jxFO7jNCUoII62dZIfctB9+BrxQW88YNS+za5YHLV5T761LZbVVVO1URVxXHkSpiqjIul1MI860P8Wy4DQq11RUaq1KSSOSblIwSGlLppKen4+LFi1i2bBnatWsHGxsbNG3aFAEBAfjiiy8AABzHYfPmzejcuTO0tLRgb2+PAwcOSJUza9YsODk5QVtbG/b29ggMDER+/n+/4IKCgtCgQQN+3t/fHz169MDKlSthYWEBY2NjjB8/XmqbiibQkMDRIxu3LuryyxjjEHVRF65e2QqLqwo1qa3Kpop9q6r3U5XHUa2fkvDGUx9v6+spNE6lRT00hMhHLBZDLBbj8OHDyM3NLXW9wMBA9O7dGzExMRg8eDAGDBiAuLg4/nVdXV2EhoYiNjYW69atw/bt27FmzZqPxj579izu37+Ps2fPYufOnQgNDUVoaGip6+fm5iIzM1NqkoeeUSHUBUD6c+nhbGkvBDA0LZCrrMquJrVV2VSxb1X1fqoqrvjqKwgfZeNln9oKi1HpUUJDiHwEAgFCQ0Oxc+dOGBgYwNvbG99++y3++usvqfX69u2LkSNHwsnJCcHBwWjcuDG+//57/vW5c+eiZcuWsLW1hZ+fH6ZPn479+/d/NLahoSE2bNiAevXqoVu3bujatetHx9ksXboU+vr6/GRtXYMGCBJSQwhe5sF0TzKejrED06zBfzYlTL5JyWrwO0Mqs969e+PJkycIDw9Hp06dcO7cOTRq1Eiqt6RFixZS27Ro0UKqh2bfvn3w9vaGubk5xGIx5s6di6SkpI/GrV+/PtTV/zs3bmFhgdTU1FLXDwgIQEZGBj8lJyfL1c7MV+ooLAAMPvhlaWhSgLTn1esixJrUVmVTxb5V1fupirjCxGwIMgtQZ34cHEbchMOIm9COz4LB6VQ4jLipkj/epDhKaEilJRKJ0LFjRwQGBuLy5cvw9/fH/PnzZdr2ypUrGDx4MLp06YKjR48iKioKc+bMQV5e3ke309DQkJrnOA6SjwxuEwqF0NPTk5rkUZCvhoS/tNGw1ev3YjI0aJWF2JvKuQRVWWpSW5VNFftWVe+nKuJmu+ri0SJXJC38b8qx08br5kZIWugKqHEKiVvZMCaRa1I2+llEqgxXV1ccPnyYn7969SqGDh0qNd+wYUMAwOXLl2FjY4M5c+bwrz969EhpdZXHwW0mmL42GXdjtBEfpY2eo55DpC3ByTAjhcUUifJhaZnFz5uZZcHePg2vX2vi+XMdhcVVdltV1U5VxFXFcaSKmKqIy7TUkWclfZm2RFMNhWJBseXVGpPjVBLdWI8Q4OXLl+jbty9GjBgBDw8P6Orq4saNG1i+fDm6d+/Or/fLL7+gcePGaNWqFXbv3o0///wTO3bsAAA4OjoiKSkJYWFhaNKkCX7//XccOnRIVU36qPPhhtA3LsTQGU9haFqAB/9oYc5gO6S/0Ch743JydHyF5cvO8PNjRkcBAE6dssPqNc0VFlfZbVVVO1URVxXHkSpiqjJujcfkePQBJTSEvLvKqVmzZlizZg3u37+P/Px8WFtbY9SoUfj222/59RYsWICwsDCMGzcOFhYW2Lt3L1xdXQEAX3zxBaZOnYoJEyYgNzcXXbt2RWBgIIKCglTUqo8LDzFBeIiJ0uLdvm2Gzl0GKi3e+5TZVlW1U1VxlX0cqSqmKuMWeRzgrLLYKiORAFzlfdo2x5gK0ihCPhHHcTh06BB69Oih6qpIyczMhL6+PnzQHQJOeb8W1Rq4Ki3W+yTRsUqPqaq2qoIq9m9NkhCqvDs5S97mIPnrBcjIyJB7rJ2qFX2vtRcPgoDTlGmbApaHiKw9Sm0v9dAQQgghpExMIgGTsYeGBgUTQgghpHKiMTSEVDw6U0oIIUomYQBHCQ0hhBBCqjLGAMg6KJjuFEwIIYSQSohJmFyTvDZu3AhbW1uIRCI0a9YMf/75p1zbU0JDCCGEkLIxiXyTHPbt24dvvvkG8+fPx61bt+Dp6QlfX9+PPnrmQ5TQEEIIIaRMiuyhWb16NUaNGoXhw4fD1dUVW7Zsgba2Nn788UeZy6AxNIRUoKLBygXIl/ligIqgVpirvGDvkbB8pcdUVVtVQRX7tyaRvM1RYqx3x21VvqChgOXK3PNSgHfHbmZmptRyoVAIoVAotSwvLw83b95EQEAAv0xNTQ0dOnTAlStXZK4fJTSEVKDXr989MO8S/lBu4L9+U248VapJbSWK9bXyj6XXr19DX19f6XE/haamJszNzXHpqXzfa2KxGNbW1lLL5s+fX+yO7S9evEBhYSHMzMyklpuZmeHOnTsyx6OEhpAKZGlpieTkZOjq6oLj5HsCb2ZmJqytrZGcnKy0O2tSzOoVU1VxKWbZGGN4/fo1LC0tFVQ7xRGJRHj48CHy8vLk2o4xVux78MPemYpECQ0hFUhNTQ1WVlafVIaenp7Sb41OMatXTFXFpZgfV9V6Zt4nEokgEokUUraJiQnU1dXx7NkzqeXPnj2Dubm5zOXQoGBCCCGEqIympia8vLwQERHBL5NIJIiIiECLFi1kLod6aAghhBCiUt988w2GDRuGxo0bo2nTpli7di3evHmD4cOHy1wGJTSEVBJCoRDz589X6Dlmilm9Y6oqLsUkn6p///54/vw55s2bh6dPn6JBgwY4fvx4sYHCH8OxqnwNGSGEEEIIaAwNIYQQQqoBSmgIIYQQUuVRQkMIIYSQKo8SGqJytra2WLt2rULK5jgOhw8fVkjZ5aXs9mZnZ6N3797Q09MDx3FIT0//aBk+Pj6YMmWKQur3Po7j+PokJiaC4zhER0fzr587d06m+tY0ZR3TtN9UKygoCA0aNFB1NWokSmhIuZT2Ry80NBQGBgZylXX9+nWMHj2an1dmEvL8+XOMHTsWderUgVAohLm5OXx9fREZGSlVHzc3N7nbW1riouz27ty5ExcvXsTly5fRr18/+Pv7S71+4MABiEQirFq1Cm/fvkV0dDR++ukn5OaW/swkf39/9OjRo8LqaG1tjZSUFLi5ufHLWrZsiZSUFEyZMkXmWKXVqzL9kS/ps7Nu3ToIhUKEhYXh6dOnmDhxIuzt7SEUCmFtbQ0/Pz+pe3R8TMuWLRETE4N58+bBwcEBIpEIZmZm8Pb2xubNm5Gdna2AVn2cv78/n8C+P927d0+p9ZDl8/6ppk+fLvN7RSoWXbZNVM7U1FRlsXv37o28vDzs3LkT9vb2ePbsGSIiIvDy5UuFxVR2e+/fvw8XFxe4ublBS0tLKlH54YcfMH78eGzZsgXDhw/Hzz//DHd3dzDGcPjwYfTv318pdVRXV5e6I2h+fj7//Jjqbv78+Vi5ciV+++031KtXD15eXjAwMMCKFSvg7u6O/Px8nDhxAuPHj5fpuTb//vsvfH19YWBggCVLlsDd3R1CoRC3b9/Gtm3bULt2bXzxxRdy1zMvLw+amprlaSIAoFOnTggJCZFa9uFn4VNjlEUZn3exWAyxWFxh5RE5MELKoW3btmzy5MnFloeEhDB9fX1+ftiwYax79+5sxYoVzNzcnBkZGbFx48axvLw8fh0bGxu2Zs0a/v9495xqBoDZ2Njw6x0+fJg1bNiQCYVCZmdnx4KCglh+fj7/+t27d1nr1q2ZUChkLi4u7OTJkwwAO3ToUIltSEtLYwDYuXPnSm1nafW5d+8e++KLL5iuri4DwBo3bsxOnTrFt9fe3l5qu/c/aubm5szOzo6JRCKmrq5erPyNGzcyBwcHJhAImEAgYGpqah9tr4aGBtPU1GQCgYABYP7+/lLv0/vlm5mZse7duzPGGFu2bBkTiUTs4MGD/Po+Pj7M0dGRtWvXjnXs2JHfB4sXL2bDhw9nAJihoSEzMDBgampqrF69eqxhw4asU6dOTENDgwFgHMexrl27MgAsKiqKMcbYpk2bmEgkkqpH0f+L3gcAzMXFhXEcx9TU1Pj11dTUmI6ODlu7di0zNDRkQqGQX19NTY2tXr2apaamsubNm/PLtbS0mIGBAdPU1GT169dna9as4WMVFBSwESNGMFNTU8ZxHOM4jhkaGrKVK1dKHbdaWlqsU6dOTEtLiwFgYrGYbdq0Ser4iIyMZJ6enkwoFDIvLy926NAhqXaXpOizI5FI2IQJE5iBgQGLjIxkjDHWuXNnVrt2bTZnzhxWu3ZtpqmpyTw9PdmxY8dYWloaY4zxbWzatClTU1NjHMcxGxsbdvnyZcYYY02aNGEA2LJly5iVlRXT0NBgAoGAjRo1iqmpqTFtbW3m6+vL4uLi2FdffcVMTEyYjo4OMzQ0ZPr6+kxPT4+1adOGjR49mnl6erLt27czW1tbxnEcH3/Lli2sa9euTEtLi9WrV49dvnyZJSQksLZt2zJtbW3WokULdu/ePb7NvXr1Yubm5qxWrVpMR0eH/7y0bduWjR8/nk2ePJk/zocPH840NTX549rKyoqNHTuWtW7dmo0fP54x9t/3TFhYGAPARCIR8/X1ZU+ePJHa1zt27GCurq5MU1OT1apVS+rznpaWxrdfV1eXtWvXjgFgmzZtYp06dWIikYjZ2dmxX375RarMmTNnMkdHR6alpcXs7OzY3Llzpb7P5s+fzzw9PaWOpbK+A0nFoISGlIs8CY2enh77+uuvWVxcHDty5AjT1tZm27Zt49d5P6FJTU1lAFhISAhLSUlhqampjDHGLly4wPT09FhoaCi7f/8+O3nyJLO1tWVBQUGMMcYKCwuZm5sba9++PYuOjmbnz59nDRs2/GhCk5+fz8RiMZsyZQrLyckpcZ2i+jg7O7ORI0fy9YmOjmZbtmxhwcHBTFdXl82dO5eJRCLWp08fpqenx/z9/ZmZmRkbPHgw09LSYitWrGCMvUuEOI5jPXr0YHfv3mVHjx5lAJi3tzdLSUlhJ0+eZOrq6mzevHlMV1eXLViwgAUGBpba3qZNmzKO49iIESOYq6srA8A0NTVZSEgIY4yxly9fslGjRrEWLVqwlJQUNmDAANa9e3c2c+ZMJhaL2enTp/m23rt3jwmFQubt7c3GjBnDRCIRS0xMZDY2NszIyIht3LiRAWB6enoMAGvRogXr0aMHn2DY2dmxLVu2MHNzc/6PblRUFDt37hz/h7dHjx5s5syZUonc+wkNADZlyhR26tQp1rJlSwaANWjQgHl5efEJjkAgYOPGjWPr169nRkZGTE1Njfn6+rJvvvmGeXp6MgBMXV2deXl5MUdHR/bVV1/xSUlaWhrLy8tjI0eOZGpqamzq1KlsxYoVTFNTU2q/DRs2jHEcx4RCIQsMDGRbt25lGhoajOM4dufOHcYYYxkZGczIyIgNGTKE/fPPP+yPP/5gTk5OMiU048ePZ4MGDWLm5uYsJiaGf684jmNdunRhenp6bO/evezOnTts5syZTENDg929e5cx9l9CY2lpybZt28a+/PJLJhAImJWVFXv69CnjOI5PLFesWMGWLl3K1NXVmUAgYDo6OuzmzZvMxcWFmZubMz8/P3b9+nW2c+dO1rlzZ2ZgYMAuX77MvvrqK6ajo8N0dHRYp06d2K1bt/h6AmC1a9dm+/btY/Hx8axHjx7M1taWffbZZ+z48eMsNjaWNW/enHXq1Ilvs5+fH/P09GS3b99md+/e5T8vzZs3Z2KxmM2YMYNZWloyfX19tnHjRvbtt9+ykSNHMo7jWGhoKHN2dmYdOnRghoaGLCcnh4WEhDANDQ3m5OTELCws2I0bN5iLiwsbNGgQH7MoiV67di2Lj49nly9fZkKhkP+8d+jQgW//3bt32bRp0xgAZmRkxLZv387i4+PZ3Llzmbq6OouNjeXLDQ4OZpGRkezhw4csPDycmZmZsWXLlvGvl5TQlPUdSCoGJTSkXORJaGxsbFhBQQG/rG/fvqx///78/PsJDWOsxCSkffv2bMmSJVLLfvrpJ2ZhYcEYY+zEiRNMIBCwx48f868fO3bsowkNY4wdOHCAGRoaMpFIxFq2bMkCAgL4L+7361O/fv0y21u/fn3WtGlTvr1F7Xq/vV999RUTi8XF2stxHHv79i379ddfmZ6eHvPx8ZGpvT169OB7Uora26NHD+bq6spvN3nyZNa2bVvG2Lv3Q1NTkwFgERERUuV/++23rEePHvx72717dzZ//nxmY2PDhgwZwtd1zpw5TCQSMU9PT3blyhW+p+Tt27eMMcb27t0rldA0aNCAcRzHHB0d+VgzZswoMaFp3rw5v87Zs2f5BKp79+7M0dGRqamp8XVhjLG///6bAWBjxoxhjDHWu3dvqV6a9/8tisUYY4MGDeL3G2OMjR8/njk5OfH7bdiwYUxdXZ0NHjyYX6dPnz5MKBSyzZs3M8YY27x5MzM2NubbzRhj27dvlymhKUqg4uLi+OXXrl3je8AWL14stU2TJk3YuHHj+PcAAPvhhx8YY4xlZWXxy4p6LACwzz//nDH27hgtSvIAsJkzZ7KpU6cyjuOKJfJ169ZlW7duZYWFhXyvX1ESXwQAmzt3Lj9fdAzs2LGDX7Z3714mEon4+aL9WZQk6ejoMD09Pebg4MAaNmzIGGNSxxljjEkkElarVi22efNm9ssvvzBjY2NmaGjI9u3bx7fJ2dmZT/I3btzIzMzM+O0tLS3ZnDlzpOpe9HnX1NRk6urqbMaMGVKfdwCsTZs2Uts0a9aMjR07lpVmxYoVzMvLi58vKaEp6zuQVAwaFEwUrn79+lBXV+fnLSwskJqaKlcZMTExWLhwIX9+WiwWY9SoUUhJSUF2djbi4uJgbW0NS0tLfhtZHmrWu3dvPHnyBOHh4ejUqRPOnTuHRo0aITQ09KPbZWVlYfr06QgICEBGRgbEYjHi4uLw5s2bj7Y3JiYGWVlZmDVrltS5dsYYHj58iI4dO8LGxgbnz59HYGAgRCLRR9v76NEjeHt7S7W3Xr16SEhIQGFhYYl19/DwgK2tLebPn4+srCwAQGFhIXbu3IkhQ4bw6w0ZMoTfDx4eHvxyT09PfixO0W3JjY2N+Sfxfnir8oSEBL59RW1Zv359iXXz9PTk/3/o0CEAQGZmJo4ePYqEhAQAwO3bt2Fvbw89PT00a9YMAGBoaIiEhARcu3aN314ikQAA1q9fDy8vL6k4Fy5cwN9//w1TU1OIxWJs27YNEolEar9pampK1cfS0hICgYB/L+Pj4+Hh4SH1BOKmTZuW2K4PtWrVCmKxGIGBgSgoKADw7hgAgLS0NP49LeLt7Y24uDipZUXviY6ODnR1dfltizRq1Ij/v0gkQkBAANTV1ZGbm4usrCwwxmBsbAyxWAwdHR1oaGjg/v37mDhxIvT09JCXlwdDQ8MSx3y9fzwUvd/u7u5Sy3JycpCZmQng3Zio2rVrw8zMDBzHQSKR4PXr18jNzZV6b4rKPX36NDp06IBXr15h8uTJ+PLLL/Hy5UsMGDAAP/74I9+mhIQEfpD7+5+z1NRUPHnyBO3bt5eqd9HnfdSoUZBIJFi1ahU8PT0hFAr5z+KH419atGghte/37dsHb29vmJubQywWY+7cuUhKSiq2j95XEd+BpGyU0JBy0dPTQ0ZGRrHl6enp0NfXl1qmoaEhNV/0hSaPrKwsLFiwANHR0fx0+/ZtJCQkfPIj7UUiETp27IjAwEBcvnwZ/v7+mD9/vtQ62traUu2dPn06Dh06hM6dO8PCwgLR0dFwd3eHRCL5aHuzsrKgq6uL6dOn8+0AgE2bNqFu3brQ1dXFrVu3oKGhAW9vb9SqVQvGxsa4cOFChbW3du3aOHfuHB4/foxOnTrh9evXOHHiBB4/foz+/fvj/PnzWL9+PQYMGIBHjx4hJydHqk1F/2eMgeM4AICa2n9fJUXLiuTm5kJDQwPdu3fn23zlypWP1jEsLAxbtmzhy/Px8YGJiQkkEglycnKwfft2XLt2TSqB8fPzQ15eHj+/e/duAICJiYnUPgsLC8Pjx4/RsGFDnDx5EtHR0Rg+fDifWLzv/XYXtUveY7ck7u7uiIiIwNmzZ9G/f38UFBTA0dGx2L77mJLqZmFhUWIZQqFQKjHJyckBAP79aNSoEerVq4ft27cjIiIC0dHR0NLSKnYsfyz2x/bVjRs38OLFC6xcuRKXL1/GX3/9BQ8PD0gkEujo6EiVm5iYiG7duvGJ9+jRo7Fx40YAwODBg3Hq1Cm8evUKEokEn332GWxsbPiYRUmhlpZWqftNJBLxP37i4+PRt29fmJiY8J/FLl26lLrtlStXMHjwYHTp0gVHjx5FVFQU5syZI3XclbW/iupaEccRkUYJDSkXZ2dn3Lp1q9jyW7duwcnJ6ZPK1tDQKNa70KhRI8THx8PBwaHYpKamBhcXFyQnJyMlJYXf5urVq+WK7+rqijdv3kjVx8LCQqq9kZGR8Pf3R0FBAerXrw9zc3MkJiZKlaOpqVliO/Lz82FqasrXX0NDA7Vq1eKv7hAIBGjcuDEcHBwQFxeHJ0+eIDExscT22tra8pecFrX3zp07cHJykvpF+KGiXqCnT5+iU6dO2LJlCwYMGIDo6Gg0btwYgwcPRnR0NAYMGIDXr1+Xuc/S0tJKvczbyckJ+fn5uH37Nt+G0n6dxsTE8Pu3fv36AABdXV2IxWK+PR07dkT79u3h4uLC90i8ffsW8fHxcHFx4csq6h0oLCzE3bt3+eWRkZGoVasW8vPz0bBhQzg4OOD+/ft48+ZNmfvtfc7Ozrh9+7ZUu69fvy7TtgDQoEEDRERE4MKFC+jXrx90dXXh6+sLNTU1nD17VmrdyMhI1K1bt8wy9fX1+R6PD+vy/ry9vT2Ad8eag4MDoqOjMXPmTIwcORKtWrWCUCjE27dvZW5LWVJTU1GnTh307NkT7u7uJX5eity8eZPvPdHR0YGxsTGePHkC4F1PR+PGjXH+/Hnk5+djxIgRJZahq6sLW1vbUi+fbtSoEZ4+fQqBQIDmzZsjNzcXDg4OAIB//vlHat2rV6/yx9Xly5dhY2ODOXPmoHHjxnB0dMSjR4/Ks0uIAtBl26Rcxo4diw0bNmDSpEkYOXIkhEIhfv/9d+zduxdHjhz5pLKLvoi8vb0hFAphaGiIefPmoVu3bqhTpw769OkDNTU1xMTE4O+//8aiRYvQoUMHODk5YdiwYVixYgUyMzMxZ86cj8Z5+fIl+vbtixEjRsDDwwO6urq4ceMGli9fju7du0vVR1dXF3fv3sWYMWMwfvx4mJubY8uWLUhNTcW6deswaNCgYr+4bG1tceHCBZiamiI/Px8AMGvWLOzduxe//vorfHx8oKOjA1NTUwQFBcHb2xvnzp1DamoqBg8ejMmTJ+PZs2coLCyEQCBAWFhYsfY+efIEf/75J7766iu+t+KPP/7A1q1by9zP1tbWOHfuHNq0aYMrV67gl19+gZubG/9HxM3NDUOHDkVYWJhM9y4ZPXo0Zs+ejT///JNfxnEcVq5ciS5duuDu3bvo3r07vL29sXLlyhLLuHbtGoKDg6Gvr8//YbGzs0NcXBx/emzfvn3w9fXFixcvEBQUBOBdD4SxsTEePHjAl1XUy7Zt2zappMzR0RFZWVmIiIjA5MmTkZ+fj8jISOTm5mL58uVltrPIoEGDMGfOHL7dSUlJfLtk7Wnx9PTEmTNn0L59e/Tr1w9r165FkyZNEBwcjMzMTPj6+uKXX37BzZs3Zb60eMqUKRgyZAgiIiLw5ZdfolatWsjJycHhw4chkUigrq7On0rr0aMHli9fjjp16uD777/HpUuX0KJFC/z4448QCCruz4Oenh6ePHmC6OhocByHwMDAUnsoHBwckJ+fj++//x65ubmIiYmRSsZGjhyJsWPHAgB69uxZasygoCB8/fXXqFWrFjp37ozk5GR8/fXXmDdvHtzd3dGwYUP4+PggMzMTHTt2xOXLlwEAe/fuRePGjdGqVSvs3r0bf/75J3bs2AHg3bGTlJSEsLAwNGnSBL///jt/apRUAqocwEOqtj///JN17NiRmZqaMn19fdasWbNiA3CLLll83/uDVBkrPig4PDycv2z5/cu2jx8/zlq2bMm0tLSYnp4ea9q0qdSVAvHx8axVq1ZMU1OTOTk5sePHj390UHBOTg6bPXs2a9SoEdPX12fa2trM2dmZzZ07l2VnZxerj7q6OhOJRMzU1JTp6uoyPT09pqmpyaytrdmGDRtY27ZtmYuLC9/eK1euMA8PD34wZhELCwvm5OTExGIx09HRYba2tszY2JgJBAJmbm7O2rZtyw9c1NbWZpqamh9tr0Ag4Ac5AmDDhg0rdX+X9H4EBgYyNTU11qxZM5aRkSE14Ds3N5dxHMd69uzJGPtvwLahoSFzdnZmDx8+ZABYx44dmYeHB7/v8f+BqUVXBP3www9Sg3M/HKhb9P8VK1YwV1dXJhAI+KuaNDQ0mL29PZs9ezZTU1PjLw9XU1PjL1GePXs2O3XqFH8ZPf5/1RUAZm1tzVavXs3HysnJYf7+/kxbW5upqakxNTU1pqenxw+4LtpPWlpaUsfl5MmTmY6ODps/fz6/LDIykm+3l5cX27Nnj1S7S1LSgPrbt2+zWrVqse7du7PExETWpEkT/v3U0NBgzZs3Z2fPnuXfA3ww8LjoyrOzZ8/yg6lbt24tdTWZlZUV09XVZW/evOEvL584cSKztLTkjyE1NTVma2vLfvnlF6avr88sLS2L1f/Dz1TRMfB+fYrqUDQIu3fv3szExIRpaWlJfV5q167N74v3vwdWr17NLCwsGMdxrG7dumzXrl18ea9fv+YHVb+vqE3v27JlC3N2dmYaGhrM3NyceXl5SX3eDQwMmFgsZgKBgFlbWzMAbNGiRaxjx45MKBQyW1tbtm/fPqkyZ8yYwYyNjZlYLGb9+/dna9askboQorTLtt/34XcgqRgcY/8/6UgIIRVk9+7dGD58ODIyMj46nkEWnTp1goODAzZs2FDmuomJibCzs0NUVJRKbj9fke2uaKNGjcKdO3dw8eJFVVflkyQmJqJu3bq4fv261MDnisBxHA4dOlShd8EmykOnnAghn2zXrl2wt7dH7dq1ERMTg1mzZqFfv36f9Ec9LS0NkZGROHfuHL7++usKrG3FUUS7K8rKlSvRsWNH6Ojo4NixY9i5cyc2bdqk6mqVW35+Pl6+fIm5c+eiefPmFZ7MkKqPEhpCyCd7+vQp5s2bh6dPn8LCwgJ9+/bF4sWLP6nMESNG4Pr165g2bZrUmKbKRBHtrih//vknli9fjtevX8Pe3h7r16/HyJEjVV2tcouMjES7du3g5OSEAwcOqLo6pBKiU06EEEIIqfLosm1CCCGEVHmU0BBCCCGkyqOEhhBCCCFVHiU0hBBCCKnyKKEhhBBCSJVHCQ0hpEbz9/eXupGaj48PpkyZovR6nDt3DhzHIT09vdR1OI7D4cOHZS4zKCjok28wmJiYCI7j+Ic3ElJZUUJDCKl0/P39wXEcOI6DpqYmHBwcsHDhwhKfiF3RDh48iODgYJnWlSUJIYQoB91YjxBSKXXq1AkhISHIzc3FH3/8gfHjx0NDQwMBAQHF1s3Ly+OfVv6pjIyMKqQcQohyUQ8NIaRSEgqFMDc3h42NDcaOHYsOHTogPDwcwH+niRYvXgxLS0s4OzsDAJKTk9GvXz8YGBjAyMgI3bt3R2JiIl9mYWEhvvnmGxgYGMDY2BgzZ87Eh/cW/fCUU25uLmbNmgVra2sIhUI4ODhgx44dSExMRLt27QAAhoaG4DgO/v7+AACJRIKlS5fCzs4OWlpa8PT0LHZ32z/++ANOTk7Q0tJCu3btpOopq1mzZsHJyQna2tqwt7dHYGAg/2T3923duhXW1tbQ1tZGv379kJGRIfX6Dz/8ABcXF4hEItSrV69KPyKB1FyU0BBCqgQtLS3k5eXx8xEREYiPj8epU6dw9OhR5Ofnw9fXF7q6urh48SIiIyMhFovRqVMnfrtVq1YhNDQUP/74Iy5duoRXr17h0KFDH407dOhQ7N27F+vXr0dcXBy2bt0KsVgMa2tr/PrrrwCA+Ph4pKSkYN26dQCApUuXYteuXdiyZQv++ecfTJ06FUOGDMH58+cBvEu8evXqBT8/P0RHR2PkyJGYPXu23PtEV1cXoaGhiI2Nxbp167B9+3asWbNGap179+5h//79OHLkCI4fP46oqCiMGzeOf3337t2YN28eFi9ejLi4OCxZsgSBgYHYuXOn3PUhRKVU+qxvQggpwbBhw1j37t0ZY4xJJBJ26tQpJhQK2fTp0/nXzczMWG5uLr/NTz/9xJydnZlEIuGX5ebmMi0tLXbixAnGGGMWFhZs+fLl/Ov5+fnMysqKj8UYY23btmWTJ09mjDEWHx/PALBTp06VWM+zZ88yACwtLY1flpOTw7S1tdnly5el1v3qq6/YwIEDGWOMBQQEMFdXV6nXZ82aVaysDwFghw4dKvX1FStWMC8vL35+/vz5TF1dnf3777/8smPHjjE1NTWWkpLCGGOsbt26bM+ePVLlBAcHsxYtWjDGGHv48CEDwKKiokqNS0hlQGNoCCGV0tGjRyEWi5Gfnw+JRIJBgwYhKCiIf93d3V1q3ExMTAzu3bsHXV1dqXJycnJw//59ZGRkICUlBc2aNeNfEwgEaNy4cbHTTkWio6Ohrq6Otm3bylzve/fuITs7Gx07dpRanpeXh4YNGwIA4uLipOoBAC1atJA5RpF9+/Zh/fr1uH//PrKyslBQUAA9PT2pderUqYPatWtLxZFIJIiPj4euri7u37+Pr776CqNGjeLXKSgogL6+vtz1IUSVKKEhhFRK7dq1w+bNm6GpqQlLS0sIBNJfVzo6OlLzWVlZ8PLywu7du4uVZWpqWq46aGlpyb1NVlYWAOD333+XSiSAd+OCKsqVK1cwePBgLFiwAL6+vtDX10dYWBhWrVold123b99eLMFSV1evsLoSogyU0BBCKiUdHR04ODjIvH6jRo2wb98+1KpVq1gvRRELCwtcu3YNbdq0AfCuJ+LmzZto1KhRieu7u7tDIpHg/Pnz6NChQ7HXi3qICgsL+WWurq4QCoVISkoqtWfHxcWFH+Bc5OrVq2U38j2XL1+GjY0N5syZwy979OhRsfWSkpLw5MkTWFpa8nHU1NTg7OwMMzMzWFpa4sGDBxg8eLBc8QmpbGhQMCGkWhg8eDBMTEzQvXt3XLx4EQ8fPsS5c+cwadIk/PvvvwCAyZMn47vvvsPhw4dx584d/I+9+w6L4vr6AP6dpewCSwcFFClSBAFRUYNYMGqwYe8axR5L7I0YxM5rN8ZeApqoaGxBk9iwY1cgGhCxIEQxWJAiStv7/uGPCSttF9ldyvk8zzy6l5l77p2dhbN37sxMmDCh1HvIWFtbY/jw4Rg5ciSOHj3K13ngwAEAgJWVFTiOw/Hjx/Hy5UtkZmZCV1cXM2fOxLRp07Br1y48evQId+7cwY8//shPtP3mm28QHx+PWbNmIS4uDnv37kVISIhc/bW3t0diYiJCQ0Px6NEjrF+/vtgJziKRCMOHD0d0dDQuXbqEyZMno3///jAzMwMALFy4EEFBQVi/fj0ePHiAu3fvIjg4GGvWrJGrPYSoGiU0hJBqQVtbGxcvXkS9evXQu3dvODk5YdSoUfjw4QM/YjNjxgx8/fXXGD58ODw9PaGrq4tevXqVWu/mzZvRt29fTJgwAQ0aNMCYMWPw7t07AECdOnWwcOFCzJ07F7Vr18akSZMAAIsXL0ZAQACCgoLg5OSETp064ffff4eNjQ2Aj/NaDh06hKNHj6JRo0bYsmULli1bJld/u3fvjmnTpmHSpElwd3fHlStXEBAQUGQ9Ozs79O7dG126dMFXX30FNzc3qcuyR48ejR07diA4OBiurq5o27YtQkJC+LYSUlVwrKTZcIQQQgghVQSN0BBCCCGkyqOEhhBCCCFVHiU0hBBCCKnyKKEhhBBCSJVHCQ0hhBBCqjxKaAghhBBS5VFCQwghhJAqjxIaQgghhFR5lNAQQgghpMqjhIYQQgghVR4lNIQQQgip8iihIYQQQkiVRwkNIYQQQqo8SmgIIYQQUuVRQkMIIYSQKo8SGkIIIYRUeZTQEEIIIaTKo4SGEEIIIVUeJTSEEEIIqfIooSGEEEJIlUcJDSGEEEKqPEpoCCGEEFLlUUJDCCGEkCqPEhpCCCGEVHmU0BBCCCGkyqOEhhBCCCFVHiU0hBBCCKnyKKEhhBBCSJVHCQ0hhBBCqjxKaAghhBBS5VFCQwghhJAqjxIaQgghhFR5lNAQQgghpMqjhIYQQgghVR4lNIQQQgip8iihIYQQQkiVRwkNIYQQQqo8SmgIIYQQUuVRQkMIIYSQKo8SGkIIIYRUeZTQEEIIIaTKo4SGEKIwfn5+sLa2VnUzSAlU/f6EhISA4zgkJCRIla9cuRK2trZQU1ODu7s7AMDa2hp+fn5KbyOpOiihIaQaKPjDULCoq6ujTp068PPzw7Nnz1TdvErj0/1UeJk7d66qm1esZcuW4ejRo3Jtk56ejoULF6JRo0YQi8XQ0tKCi4sL5syZg+fPnyumoRXk1KlTmD17Nry8vBAcHIxly5apukmkilBXdQMIIRVn0aJFsLGxwYcPH3Dt2jWEhITg8uXLuHfvHkQikaqbV2kU7KfCXFxcVNSa0i1btgx9+/ZFz549ZVr/8ePH6NChAxITE9GvXz+MHTsWmpqa+Ouvv7Bz504cOXIEDx48UGyjZfT1119j4MCBEAqFfNnZs2chEAiwc+dOaGpq8uVxcXEQCOg7OCkZJTSEVCOdO3eGh4cHAGD06NEwMTHB8uXLERYWhv79+6u4dZVH4f1Ukd69ewcdHZ0Kr1dWeXl56N27N/7991+cP38erVq1kvr50qVLsXz5chW1rig1NTWoqalJlaWkpEBLS0sqmQEglfR8rry8PEgkkiIxSNVG6S4h1Vjr1q0BAI8ePeLLcnJyMH/+fDRt2hT6+vrQ0dFB69atce7cOaltExISwHEcVq1ahW3btqF+/foQCoVo1qwZbt68WSTW0aNH4eLiApFIBBcXFxw5cqTYNr179w4zZsyApaUlhEIhHB0dsWrVKjDGpNbjOA6TJk3Cr7/+CmdnZ2hpacHT0xN3794FAGzduhV2dnYQiUTw9vYuMg/jc5w9exatW7eGjo4ODAwM0KNHD8TGxkqts2DBAnAch5iYGAwePBiGhoZSCcQvv/yCpk2bQktLC0ZGRhg4cCCSkpKk6oiPj0efPn1gZmYGkUiEunXrYuDAgUhLS+P3wbt377Br1y7+1Fhp80gOHTqE6OhozJs3r0gyAwB6enpYunRpqX1ftWoVWrZsCWNjY2hpaaFp06Y4ePBgkfVOnz6NVq1awcDAAGKxGI6Ojvjuu++k1vnxxx/RsGFDaGtrw9DQEB4eHti7dy//80/n0HAch+DgYLx7947vb0hICIDi59C8ffsWU6dO5Y8lOzs7LF++HBKJhF+n8HG8bt06/jiOiYkpdT+QqodGaAipxgr+UBgaGvJl6enp2LFjBwYNGoQxY8YgIyMDO3fuhI+PD27cuMFPwiywd+9eZGRkYNy4ceA4DitWrEDv3r3x+PFjaGhoAPg476FPnz5wdnZGUFAQXr9+jREjRqBu3bpSdTHG0L17d5w7dw6jRo2Cu7s7Tp48iVmzZuHZs2dYu3at1PqXLl1CWFgYJk6cCAAICgpCt27dMHv2bGzatAkTJkxAamoqVqxYgZEjR+Ls2bMy7Ze0tDS8evVKqszExAQAcObMGXTu3Bm2trZYsGAB3r9/jx9//BFeXl64c+dOkUm0/fr1g729PZYtW8YnZUuXLkVAQAD69++P0aNH4+XLl/jxxx/Rpk0bREZGwsDAADk5OfDx8UF2dja+/fZbmJmZ4dmzZzh+/Djevn0LfX19/Pzzzxg9ejSaN2+OsWPHAgDq169fYr/CwsIAfDyVU14//PADunfvjiFDhiAnJwehoaHo168fjh8/jq5duwIA/v77b3Tr1g1ubm5YtGgRhEIhHj58iIiICL6e7du3Y/Lkyejbty+mTJmCDx8+4K+//sL169cxePDgYmP//PPP2LZtG27cuIEdO3YAAFq2bFnsullZWWjbti2ePXuGcePGoV69erhy5Qr8/f2RnJyMdevWSa0fHByMDx8+YOzYsRAKhTAyMir3PiKVFCOEVHnBwcEMADtz5gx7+fIlS0pKYgcPHmSmpqZMKBSypKQkft28vDyWnZ0ttX1qaiqrXbs2GzlyJF/25MkTBoAZGxuzN2/e8OW//fYbA8COHTvGl7m7uzNzc3P29u1bvuzUqVMMALOysuLLjh49ygCwJUuWSMXv27cv4ziOPXz4kC8DwIRCIXvy5AlftnXrVgaAmZmZsfT0dL7c39+fAZBat7T9VNxSuC+1atVir1+/5suio6OZQCBgw4YN48sCAwMZADZo0CCpGAkJCUxNTY0tXbpUqvzu3btMXV2dL4+MjGQA2K+//lpqm3V0dNjw4cNLXadA48aNmb6+vkzrMsbY8OHDpd4fxhjLysqSep2Tk8NcXFzYl19+yZetXbuWAWAvX74sse4ePXqwhg0blhq/4P0o/L4NHz6c6ejoFFnXyspKaj8sXryY6ejosAcPHkitN3fuXKampsYSExMZY/8dx3p6eiwlJaXU9pCqjU45EVKNdOjQAaamprC0tETfvn2ho6ODsLAwqZESNTU1fu6ARCLBmzdvkJeXBw8PD9y5c6dInQMGDJAa4Sk4jfX48WMAQHJyMqKiojB8+HDo6+vz63Xs2BHOzs5Sdf3xxx9QU1PD5MmTpcpnzJgBxhj+/PNPqfL27dtLjYi0aNECANCnTx/o6uoWKS9oU1k2btyI06dPSy2F++Ln5yf1Dd7NzQ0dO3bEH3/8UaSub775Rur14cOHIZFI0L9/f7x69YpfzMzMYG9vz5/aK9hXJ0+eRFZWlkztLkt6errUfikPLS0t/v+pqalIS0tD69atpY4NAwMDAMBvv/0mdXqnMAMDA/zzzz/Fnp6sCL/++itat24NQ0NDqf3coUMH5Ofn4+LFi1Lr9+nTB6ampgppC6kc6JQTIdXIxo0b4eDggLS0NPz000+4ePFisZMpd+3ahdWrV+P+/fvIzc3lyz+98gcA6tWrJ/W6ILlJTU0FADx9+hQAYG9vX2RbR0dHqT+ET58+hYWFRZE/uk5OTlJ1lRS7IAmwtLQstrygTWVp3rx5sZOCC+I7OjoW+ZmTkxNOnjxZZOLvp/ssPj4ejLFi9wcA/jSdjY0Npk+fjjVr1mDPnj1o3bo1unfvjqFDh0olhvLQ09OTOakryfHjx7FkyRJERUUhOzubL+c4jv//gAEDsGPHDowePRpz585F+/bt0bt3b/Tt25e/EmnOnDk4c+YMmjdvDjs7O3z11VcYPHgwvLy8Pqt9BeLj4/HXX3+VmKSkpKRIvS7u2CbVCyU0hFQjhf9Q9+zZE61atcLgwYMRFxcHsVgM4ONkVT8/P/Ts2ROzZs1CrVq1oKamhqCgIKnJwwU+vQqlAPtkEq8ilBRblW36VOERDeDjqBfHcfjzzz+LbWfB+wAAq1evhp+fH3777TecOnUKkydPRlBQEK5du1Zk/pEsGjRogMjISCQlJRVJ+mRx6dIldO/eHW3atMGmTZtgbm4ODQ0NBAcHS03m1dLSwsWLF3Hu3Dn8/vvvOHHiBPbv348vv/wSp06dgpqaGpycnBAXF4fjx4/jxIkTOHToEDZt2oT58+dj4cKFcrftUxKJBB07dsTs2bOL/bmDg4PU60/fJ1L9UEJDSDVVkKS0a9cOGzZs4G8cd/DgQdja2uLw4cNS37oDAwPLFcfKygrAx2/Mn4qLiyuy7pkzZ5CRkSE1SnP//n2pulSlIP6n7QY+ttHExKTMy7Lr168PxhhsbGyK/FEtjqurK1xdXfH999/jypUr8PLywpYtW7BkyRIA0iMjZfH19cW+ffvwyy+/wN/fX+btChw6dAgikQgnT56UGtkLDg4usq5AIED79u3Rvn17rFmzBsuWLcO8efNw7tw5dOjQAQCgo6ODAQMGYMCAAcjJyUHv3r2xdOlS+Pv7f/Z9kerXr4/MzEw+FiE0h4aQaszb2xvNmzfHunXr8OHDBwD/jW4UHs24fv06rl69Wq4Y5ubmcHd3x65du/jLjYGPl/V+emlsly5dkJ+fjw0bNkiVr127FhzHoXPnzuVqQ0Up3Je3b9/y5ffu3cOpU6fQpUuXMuvo3bs31NTUsHDhwiIjRowxvH79GsDH+S55eXlSP3d1dYVAIJA61aOjoyPVltL07dsXrq6uWLp0abHvZ0ZGBubNm1fi9mpqauA4Dvn5+XxZQkJCkTsVv3nzpsi2BVfHFbS9oJ8FNDU14ezsDMaY1GnO8urfvz+uXr2KkydPFvnZ27dvi+xbUv3RCA0h1dysWbPQr18/hISE4JtvvkG3bt1w+PBh9OrVC127dsWTJ0+wZcsWODs7IzMzs1wxgoKC0LVrV7Rq1QojR47Emzdv+HuQFK7T19cX7dq1w7x585CQkIBGjRrh1KlT+O233zB16tRSL0lWlpUrV6Jz587w9PTEqFGj+Mu29fX1sWDBgjK3r1+/PpYsWQJ/f38kJCSgZ8+e0NXVxZMnT3DkyBGMHTsWM2fOxNmzZzFp0iT069cPDg4OyMvLw88//ww1NTX06dOHr69p06Y4c+YM1qxZAwsLC9jY2PCToD+loaGBw4cPo0OHDmjTpg369+8PLy8vaGho4O+//8bevXthaGhY4r1ounbtijVr1qBTp04YPHgwUlJSsHHjRtjZ2eGvv/7i11u0aBEuXryIrl27wsrKCikpKdi0aRPq1q3L3//mq6++gpmZGby8vFC7dm3ExsZiw4YN6Nq162dPXAY+HtdhYWHo1q0b/Pz80LRpU7x79w53797FwYMHkZCQwF+KT2oIlV1fRQipMAWXv968ebPIz/Lz81n9+vVZ/fr1WV5eHpNIJGzZsmXMysqKCYVC1rhxY3b8+PEil/AWXO66cuXKInUCYIGBgVJlhw4dYk5OTkwoFDJnZ2d2+PDhYi8LzsjIYNOmTWMWFhZMQ0OD2dvbs5UrVzKJRFIkxsSJE6XKSmrTuXPnZLoEurT9VNiZM2eYl5cX09LSYnp6eszX15fFxMRIrVNw2XZJly4fOnSItWrViuno6DAdHR3WoEEDNnHiRBYXF8cYY+zx48ds5MiRrH79+kwkEjEjIyPWrl07dubMGal67t+/z9q0acO0tLQYAJku4U5NTWXz589nrq6uTFtbm4lEIubi4sL8/f1ZcnIyv15x78/OnTuZvb09EwqFrEGDBiw4OJjva4Hw8HDWo0cPZmFhwTQ1NZmFhQUbNGiQ1CXUW7duZW3atGHGxsZMKBSy+vXrs1mzZrG0tDR+nc+5bJuxj8eSv78/s7OzY5qamszExIS1bNmSrVq1iuXk5DDGSj+OSfXCMaaCWXSEEEIIIRWI5tAQQgghpMqjhIYQQgghVR4lNIQQQgip8iihIYQQQohKWVtb809YL7wUPJhWFnTZNiGEEEJU6ubNm1L3P7p37x46duyIfv36yVwHXeVECCGEkEpl6tSpOH78OOLj42W+WzaN0BBSgSQSCZ4/fw5dXV25bllPCKneGGPIyMiAhYUF/wDPquTDhw/IycmRaxvGWJHfg0KhsNgH5haWk5ODX375BdOnT5fr9yglNIRUoOfPn5froYCEkJohKSmpXA8eVaUPHz7AxkqMFyn5Za9ciFgsLnL38cDAwDLvuH306FG8ffsWfn5+csWjhIaQClRwS3f3Xt9DTePzHr4nV9wDN5UWi5DqQuDWQGmx8vKzcfHvdRXy2Adly8nJwYuUfDy5bQU9XdlGl9IzJLBp+hRJSUnQ09Pjy8sanQGAnTt3onPnzrCwsJCrnZTQEFKBCoZH1TRESk1o1DkNpcUipLoQqJX9x7WiVeVT0Trij4ss8v83O1dPT08qoSnL06dPcebMGRw+fFju9lFCQwghhJAyScAggWzXEcm63qeCg4NRq1YtdO3aVe5tKaEhhBBCSJkkkEAix7py1y+RIDg4GMOHD4e6uvzpCSU0hBBCCClTPmPIl/FOL7KuV9iZM2eQmJiIkSNHyr0tQAkNIYQQQmSg6FNOX331FT7n1niU0BBCCCGkTBIw5Ct4Ds3noISGEEIIIWVSxqTgz0EJDSEqNOzLSLR1fQIr07fIzlPD3QQzbPq9BRJfGig8tq/fK/QdnwIj0zw8jtHCpu/rIC5Ku1rGpZjVK6Yq4rq4pKBvn1jY2aXC2Pg9Fi1ujatXq9YN8j6XoufQfK6qd//lElhbW2PdunUKqZvjOBw9elQhdVcVWVlZ6NOnD/T09MBxHN6+favqJsnk/Pnzlbq9jW2f41BEQ4z5sSembO0GdTUJ1o39HSLNXIXGbds9FWMDn2PPGjNM9HHA4xgRlu59DH3j6heXYlavmKqKKxLl4fETQ2za1FRhMSo7iZyLsqk0ofH29sbUqVOLlIeEhMDAwECuum7evImxY8fyr5WZhLx8+RLjx49HvXr1IBQKYWZmBh8fH0RERHx2exSZqMlj165duHTpEq5cuYLk5GTo6+uXuO779+9hZGQEExMTZGdnK7GVRbVs2bLM9qrStB1d8cctRzz51wgPk42xJNQb5oaZaFD3pULj9h77Cif2GuHUfiMkxouwfk5dZL/n4DPoTbWLSzGrV0xVxb11ywK7d7vhytWa+2iT/P/NoZF1UbZqM0JjamoKbW3FD3MWp0+fPoiMjMSuXbvw4MEDhIWFwdvbG69fv1ZJexTh0aNHcHJygouLC8zMzEq92+WhQ4fQsGFDNGjQQKUjW7m5udDU1CyzvZWJWPTx4W/pWYq7y7C6hgT2blm4c+m/W7AzxiHyki6cm2ZVq7gUs3rFVGVc8vHuv/IsylYlEho/Pz/07NkTq1atgrm5OYyNjTFx4kTk5v43vFh4JMPa2hoA0KtXL3Acx78GgN9++w1NmjSBSCSCra0tFi5ciLy8PP7n8fHxaNOmDUQiEZydnXH69OlS2/b27VtcunQJy5cvR7t27WBlZYXmzZvD398f3bt3L7U9jx49Qo8ePVC7dm2IxWI0a9YMZ86c4ev29vbG06dPMW3aNHAcJ/VH+fLly2jdujW0tLRgaWmJyZMn4927d/zPN23aBHt7e4hEItSuXRt9+/YttR8FSYhQKIS1tTVWr14t1Y7Vq1fj4sWL4DgO3t7epda1c+dODB06FEOHDsXOnTuL/JzjOGzduhXdunWDtrY2nJyccPXqVTx8+BDe3t7Q0dFBy5Yt8ejRI6ntynrvOI7D5s2b0b17d+jo6GDp0qXFnnKKiIiAt7c3tLW1YWhoCB8fH6SmpgIATpw4gVatWsHAwADGxsbo1q1bkXYoCscxTO1xBdFPzPD4hZHC4ugZ5UNNHXj7UnoKXeordRia5pWwVdWMSzGrV0xVxiWVX5VIaADg3LlzePToEc6dO4ddu3YhJCQEISEhxa578+bHB/UFBwcjOTmZf33p0iUMGzYMU6ZMQUxMDLZu3YqQkBAsXboUwMe7FPbu3Ruampq4fv06tmzZgjlz5pTaLrFYDLFYjKNHj5Z4eqWk9mRmZqJLly4IDw9HZGQkOnXqBF9fXyQmJgIADh8+jLp162LRokVITk5GcnIygI+JUKdOndCnTx/89ddf2L9/Py5fvoxJkyYBAG7duoXJkydj0aJFiIuLw4kTJ9CmTZsS+3D79m30798fAwcOxN27d7FgwQIEBATw+/fw4cMYM2YMPD09kZycXOozNh49eoSrV6+if//+6N+/Py5duoSnT58WWW/x4sUYNmwYoqKi0KBBAwwePBjjxo2Dv78/bt26BcYY3x+g7PeuwIIFC9CrVy/cvXu32JszRUVFoX379nB2dsbVq1dx+fJl+Pr6Ij//41Nk3717h+nTp+PWrVsIDw+HQCBAr169IJEUf0Y4Ozsb6enpUkt5zex1GbZmbxDwS/ty10EIIYpS2efQVJmrnAwNDbFhwwaoqamhQYMG6Nq1K8LDwzFmzJgi65qamgIADAwMYGZmxpcvXLgQc+fOxfDhwwEAtra2WLx4MWbPno3AwECcOXMG9+/fx8mTJ/mnfC5btgydO3cusV3q6uoICQnBmDFjsGXLFjRp0gRt27bFwIED4ebmVmp7GjVqhEaNGvGvFy9ejCNHjiAsLAyTJk2CkZER1NTUoKurK7VdUFAQhgwZws8/sre3x/r169G2bVts3rwZiYmJ0NHRQbdu3aCrqwsrKys0bty4xD6sWbMG7du3R0BAAADAwcEBMTExWLlyJfz8/GBkZARtbW3+9E1pfvrpJ3Tu3BmGhoYAAB8fHwQHBxd5XPyIESPQv39/AMCcOXPg6emJgIAA+Pj4AACmTJmCESNG8OuX9d4VGDx4sNR2jx8/loq7YsUKeHh4YNOmTXxZw4YN+f/36dOnSH9MTU0RExMDFxeXIv0NCgrCwoULS90nspjR6zK8nJ9i/KbueJkm49Pfyin9jRry8wCDT77NGprkIfWl4n4lqCIuxaxeMVUZlwAScMiHbKfvJTKuV5GqzAhNw4YNoaamxr82NzdHSkqKXHVER0dj0aJF/KiKWCzGmDFjkJycjKysLMTGxsLS0lLqkeWenp5l1tunTx88f/4cYWFh6NSpE86fP48mTZqUOIJUIDMzEzNnzoSTkxMMDAwgFosRGxvLj9CU1o+QkBCpfvj4+EAikeDJkyfo2LEjrKysYGtri6+//hp79uxBVlbJ55ZjY2Ph5eUlVebl5YX4+Hh+5EIW+fn52LVrF4YOHcqXDR06FCEhIUVGOAqSPQCoXbs2AMDV1VWq7MOHD/yIR1nvXQEPD49S21gwQlOS+Ph4DBo0CLa2ttDT0+NPD5b0nvj7+yMtLY1fkpKSSo1fFMOMXpfR1uUJJm3xRfIb2Z9KW155uQLE/6WNxq0y+DKOY3BvlYmY24qbh6aKuBSzesVUZVwCSJh8i7KpNJ3V09NDWlpakfK3b98WuSpFQ0ND6jXHcSWeBihJZmYmFi5ciN69exf5mUj0eZMwRSIROnbsiI4dOyIgIACjR49GYGAg/Pz8Stxm5syZOH36NFatWgU7OztoaWmhb9++yMnJKbMf48aNw+TJk4v8rF69etDU1MSdO3dw/vx5nDp1CvPnz8eCBQtw8+ZNua8ek8fJkyfx7NkzDBgwQKo8Pz8f4eHh6NixI19W+P0smBtUXFnBeyzre6ejo1NqG7W0tEr9ua+vL6ysrLB9+3ZYWFhAIpHAxcWlxPdEKBRCKBSWWmdpZva+jK8aP8ScYB9kZWvASPdjcvbuvSay8xT38Ty8zQQz1yXhQbQ24iK10WvMS4i0JTgVqri5O6qKSzGrV0xVxRWJcmFhkcm/rl07E7a2qcjI0MTLl6X/3qku8uUYoZF1vYqk0oTG0dERp06dKlJ+584dODg4fFbdGhoaRUYXmjRpgri4ONjZ2RW7jZOTE5KSkpCcnAxzc3MAwLVr18oV39nZWeoKn+LaExERAT8/P/Tq1QvAxz/aCQkJUutoamoW24+YmJgS+wF8PBXWoUMHdOjQAYGBgTAwMMDZs2eLTQicnJykLjEvaJuDg4PUqFhZdu7ciYEDB2LevHlS5UuXLsXOnTulEhp5lfXeycrNzQ3h4eHFniZ6/fo14uLisH37drRu3RrAx8nXitSnZQwAYNOEY1Lli0O98cctR4XFvRBmCH3jfAyb9QKGpnl4/LcW5g2xwdtXGmVvXMXiUszqFVNVce3t32DF8rP863FjIwEAp0/bYM3aLxQWtzKhhKYU48ePx4YNGzB58mSMHj0aQqEQv//+O/bt24djx46VXUEprK2tER4eDi8vLwiFQhgaGmL+/Pno1q0b6tWrh759+0IgECA6Ohr37t3DkiVL0KFDBzg4OGD48OFYuXIl0tPTi/xx/tTr16/Rr18/jBw5Em5ubtDV1cWtW7ewYsUK9OjRo9T22Nvb4/Dhw/D19QXHcQgICCgy6mRtbY2LFy9i4MCBEAqFMDExwZw5c/DFF19g0qRJGD16NHR0dBATE4PTp09jw4YNOH78OB4/fow2bdrA0NAQf/zxByQSCRwdi/8DOWPGDDRr1gyLFy/GgAEDcPXqVWzYsEFqnklZXr58iWPHjiEsLKzIXJNhw4ahV69eePPmDYyMyvcNqqz3Tlb+/v5wdXXFhAkT8M0330BTUxPnzp1Dv379YGRkBGNjY2zbtg3m5uZITEzE3Llzy9VeWXnOHKfQ+ksTFmyCsGCTGhGXYlavmKqIe/dubXTuMkhp8SojCeMgYTLOoZFxvYqk0jk0tra2uHjxIu7fv48OHTqgRYsWOHDgAH799Vd06tTps+pevXo1Tp8+DUtLS35CrI+PD44fP45Tp06hWbNm+OKLL7B27VpYWVkBAAQCAY4cOYL379+jefPmGD16dJGraD4lFovRokULrF27Fm3atIGLiwsCAgIwZswYbNiwodT2rFmzBoaGhmjZsiV8fX3h4+ODJk2aSNW/aNEiJCQkoH79+vzkYjc3N1y4cAEPHjxA69at0bhxY8yfP5+f+2NgYIDDhw/jyy+/hJOTE7Zs2YJ9+/ZJTX4trEmTJjhw4ABCQ0Ph4uKC+fPnY9GiRaWeLvvU7t27oaOjU+z8lPbt20NLSwu//PKLzPV9qqz3TlYODg44deoUoqOj0bx5c3h6euK3336Duro6BAIBQkNDcfv2bbi4uGDatGlYuXJludtMCCHVScEIjayLsnHsc57VTQiRkp6eDn19fTTtvwRqGoq7Od6n9PaW79QoITWZwN1ZabHy8rNx9q/lSEtLg56e4if/V6SC32tn71lCrCvbOEhmhgRfuiQptb90jRshhBBCysTkOOXEVHDKiRIaQgghhJSJJgUTQgghpMrLZwLkM9lOOaniWU6U0BBCCCGkTBJwkMh4LZFEBU/bpoSGEEIIIWWiU06EEEIIqfLkO+VEIzSEVAu6B25CnVPs3VILG3L/H6XFKmzfwK+UHlMSFaP0mESxlHn5dGHKPJYkLFdpsRTl4ymnyvtwSkpoCCGEEFImCQTIpzk0hBBCCKnK6JQTIYQQQqo8CQR0lRMhhBBCqrZ8xiFfxjsAy7peRaKEhhBCCCFlypdjDk2+CkZoVPq0bUIIIYRUDRImkGuRx7NnzzB06FAYGxtDS0sLrq6uuHXrllx10AgNIYQQQsqkqBGa1NRUeHl5oV27dvjzzz9hamqK+Ph4GBoaytU+SmgIIYQQUiYJZJ8bI5Gj3uXLl8PS0hLBwcF8mY2NjXyNA51yIoQQQogMCq5yknUBgPT0dKklOzu7SL1hYWHw8PBAv379UKtWLTRu3Bjbt2+Xu32U0BBCCCGkTAX3oZF1AQBLS0vo6+vzS1BQUJF6Hz9+jM2bN8Pe3h4nT57E+PHjMXnyZOzatUuu9tEppyrO2toaU6dOxdSpUyu8bo7jcOTIEfTs2bPcdXh7e8Pd3R3r1q2rsHYV5/z582jXrh1SU1NhYGCg0FiK4Ov3Cn3Hp8DINA+PY7Sw6fs6iIvSVli8rH8FiFylj+cXRcj/IIC4Xh48l72Bsavibs/u4pKCvn1iYWeXCmPj91i0uDWuXq2rsHiFKXv/UkzFxaxpx1FlUp5HHyQlJUFPT48vFwqFRdeVSODh4YFly5YBABo3box79+5hy5YtGD58uMztoxEaFfD29i42AQkJCZH7j/HNmzcxduxY/jXHcTh69OjnNVBGfn5+RZKdgwcPQiQSYfXq1QCAw4cPY/HixUppT1XVtnsqxgY+x541Zpjo44DHMSIs3fsY+saKSS6y0zicGlQLAnWg3fZX6Pb7CzSd8xaa+vKc9ZafSJSHx08MsWlTU4XG+ZSy9y/FVGzMmnQcVTblGaHR09OTWopLaMzNzeHsLP08LycnJyQmJsrVPkpoqjhTU1Noa1eObwg7duzAkCFDsHnzZsyYMQMAYGRkBF1dXRW3rHLrPfYVTuw1wqn9RkiMF2H9nLrIfs/BZ9AbhcSL2aELbfN8eAalwsQtF+K6+TBvlQ3devkKiVfg1i0L7N7thitXLRUa51PK3r8UU7Exa9JxVNkUXOUk6yIrLy8vxMXFSZU9ePAAVlZWcrWPEppKrGAEZNWqVTA3N4exsTEmTpyI3Nz/vhFYW1vzp3Osra0BAL169QLHcfxrAPjtt9/QpEkTiEQi2NraYuHChcjLy+N/Hh8fjzZt2kAkEsHZ2RmnT5+Wq60rVqzAt99+i9DQUIwYMYIv/3Q0ytraGsuWLcPIkSOhq6uLevXqYdu2bVJ1XblyBe7u7hCJRPDw8MDRo0fBcRyioqL4df744w84ODhAS0sL7dq1Q0JCQpE2HTp0CA0bNoRQKIS1tTU/alS4LUuWLMGwYcMgFothZWWFsLAwvHz5Ej169IBYLIabm5vc90KQh7qGBPZuWbhz6b+kjzEOkZd04dw0SyEx/zmrBWOXHFyaYoSDLc3xR69aeHhARyGxVE0V+5diKi6mqtSkvpZGwji5FllNmzYN165dw7Jly/Dw4UPs3bsX27Ztw8SJE+VqHyU0ldy5c+fw6NEjnDt3Drt27UJISAhCQkKKXffmzZsAgODgYCQnJ/OvL126hGHDhmHKlCmIiYnB1q1bERISgqVLlwL4eP6yd+/e0NTUxPXr17FlyxbMmTNH5jbOmTMHixcvxvHjx9GrV68y11+9ejU8PDwQGRmJCRMmYPz48Xx2np6eDl9fX7i6uuLOnTtYvHhxkbYkJSWhd+/e8PX1RVRUFEaPHo25c+dKrXP79m30798fAwcOxN27d7FgwQIEBAQU2Xdr166Fl5cXIiMj0bVrV3z99dcYNmwYhg4dijt37qB+/foYNmwYWAkPWsvOzi4yi18eekb5UFMH3r6Uns6W+kodhqZ5JWz1eTKT1PFgnxi6Vnn4cscr2A98h1tLDfD4SOUY6atIqti/FFNxMVWlJvW1NBI5RmdkfeYTADRr1gxHjhzBvn374OLigsWLF2PdunUYMmSIXO2jScGVnKGhITZs2AA1NTU0aNAAXbt2RXh4OMaMGVNkXVNTUwCAgYEBzMzM+PKFCxdi7ty5/OQqW1tbLF68GLNnz0ZgYCDOnDmD+/fv4+TJk7CwsAAALFu2DJ07dy6zfX/++Sd+++03hIeH48svv5SpT126dMGECRMAfEyG1q5di3PnzsHR0RF79+4Fx3HYvn07P1r07Nkzqf5u3rwZ9evX50dcHB0dcffuXSxfvpxfZ82aNWjfvj0CAgIAAA4ODoiJicHKlSvh5+cn1ZZx48YBAObPn4/NmzejWbNm6NevH98+T09P/Pvvv1L7tEBQUBAWLlwoU78rDQYYNcyB+/SPyZeRcy7S4tURH6oD214159smIUQ+8twBWN47BXfr1g3dunUrT7N4NEJTyTVs2BBqamr8a3Nzc6SkpMhVR3R0NBYtWgSxWMwvY8aMQXJyMrKyshAbGwtLS0s+mQEAT09Pmep2c3ODtbU1AgMDkZmZKfM2BTiOg5mZGd+nuLg4uLm5QSQS8es0b95cavvY2Fi0aNFCquzT9sbGxsLLy0uqzMvLC/Hx8cjP/2+uSOG21K5dGwDg6upapKykfe7v74+0tDR+SUpKKqHXxUt/o4b8PMDgk295hiZ5SH2pmO8bItN86NtJx9Orn4d3ydXv+40q9i/FVFxMValJfS1NPji5FmWjhEYF9PT0kJaWVqT87du30NfXlyrT0NCQes1xHCQS+a5GyczMxMKFCxEVFcUvd+/eRXx8vFTiUB516tTB+fPn8ezZM3Tq1AkZGRllblMRfaoohdvCcVyJZSW1TygUFpnFL4+8XAHi/9JG41b/7TeOY3BvlYmY24o5BWTaOAfpT6R/CWckqEPHovoNnati/1JMxcVUlZrU19Io8llOFYESGhVwdHTEnTt3ipTfuXMHDg4On1W3hoaG1AgEADRp0gRxcXGws7MrsggEAjg5OSEpKQnJycn8NteuXZM5ppWVFS5cuIAXL17InNSUpOD0UeG7SRbMBSrg5OSEGzduSJV92l4nJydERERIlUVERMDBwUFqxKsyOLzNBJ0Hv0GHfm9gafcB3/7fPxBpS3Aq1Egh8Zz8MvAqWhP3tugi46kanhzTQvwBHTgMkW2ErbxEolzY2qbC1jYVAFC7diZsbVNhavpOoXGVvX8ppmJj1qTjqLLJhzyjNMpXc8bKKpHx48djw4YNmDx5MkaPHg2hUIjff/8d+/btw7Fjxz6rbmtra4SHh8PLywtCoRCGhoaYP38+unXrhnr16qFv374QCASIjo7GvXv3sGTJEnTo0AEODg4YPnw4Vq5cifT0dMybN0+uuJaWlvzN7Xx8fHDixAm5RysAYPDgwZg3bx7Gjh2LuXPnIjExEatWrQLw32jJN998g9WrV2PWrFkYPXo0bt++XWSy74wZM9CsWTMsXrwYAwYMwNWrV7FhwwZs2rRJ7jYp2oUwQ+gb52PYrBcwNM3D47+1MG+IDd6+0ih743Iwds1Fmx9fI2qNPu5u0oO4bh48/NNg4/teIfEK2Nu/wYrlZ/nX48ZGAgBOn7bBmrVfKCyusvcvxVRszJp0HFU2ipxDUxEooVEBW1tbXLx4EfPmzUOHDh2Qk5ODBg0a4Ndff0WnTp0+q+7Vq1dj+vTp2L59O+rUqYOEhAT4+Pjg+PHjWLRoEZYvXw4NDQ00aNAAo0ePBgAIBAIcOXIEo0aNQvPmzWFtbY3169fL3Za6detKJTUnT56Uu/16eno4duwYxo8fD3d3d7i6umL+/PkYPHgwf3qsXr16OHToEKZNm4Yff/wRzZs35y8FL9CkSRMcOHAA8+fPx+LFi2Fubo5FixZJTQiuTMKCTRAWbKK0eHXbfUDddh+UFg8A7t6tjc5dBik1ZgFl71+KqTg17TiqTArfME+WdZWNYyVdj0pIJbFnzx6MGDECaWlp0NLSUnVzSpWeng59fX14owfUOeV9cxty/x+lxSps38CvlB5TEhWj9JhEsQTuzmWvpADKPJbyWC7O4zekpaWVa/RalQp+r/lf7QSRWLbfax8ycxHkeUKp/aURGlLp7N69G7a2tqhTpw6io6MxZ84c9O/fv9InM4QQUp0xOZ7lxFRwlRMlNKTSefHiBebPn48XL17A3Nwc/fr1428CSAghRDUq+yknSmhIpTN79mzMnj1b1c0ghBBSiDyPNJDn0QcVhRIaQgghhJRJnodOyvNwyopCCQ0hhBBCykQjNIQQQgip8iRyPHRSnodTVhRKaAghhBBSpnzGIV/GkRdZ16tIlNAQUg1sXtRXJXH/nZqr9Jj2fkoPSRRMVfcWSh+suDsLfyo/9wNw4DelxVMEOuVECCGEkCqPyfHoA0aXbRNCCCGkMip48KSs6yobJTSEEEIIKZOEyX4qSaKChypRQkMIIYSQMtHTtgkhhBBS5UnkeJaTrOtVJEpoCCGEEFImumybEEIIIVUenXIihBBCSJUngRz3oaFTToQQQgipjJgcc2gYJTSEKA7HcThy5Ah69uyJhIQE2NjYIDIyEu7u7qpuGnz9XqHv+BQYmebhcYwWNn1fB3FR2gqJNezLSLR1fQIr07fIzlPD3QQzbPq9BRJfGigkXnEMj7+AycFnSO1YC6+GWCo8njL3L8VUfExlx60Mn5nKoLLfKVj5J7kIKQc/Pz/07NmzwuqztLREcnIyXFxcKqzO8mrbPRVjA59jzxozTPRxwOMYEZbufQx9Y8U8VqCx7XMcimiIMT/2xJSt3aCuJsG6sb9DpKmcxxgIH7+D/vmXyLbUUko8Ze9fiqnYmKqIq+rPTGVRMIdG1kXZKKEhNZKamhrMzMygrq76QcreY1/hxF4jnNpvhMR4EdbPqYvs9xx8Br1RSLxpO7rij1uOePKvER4mG2NJqDfMDTPRoO5LhcQrjPuQD7OtT/DvCCvka6spPB6g/P1LMRUbUxVxVfmZqUwKRmhkXZSNEhpS5Xh7e2Py5MmYPXs2jIyMYGZmhgULFkitEx8fjzZt2kAkEsHZ2RmnT5+W+nlCQgI4jkNUVBQAID8/H6NGjYKNjQ20tLTg6OiIH374QeF9UdeQwN4tC3cu6fJljHGIvKQL56ZZCo8PAGJRDgAgPUuk8Fi1fk7Eu0b6eN9QT+GxANXsX4qp2GO3pn1mKpOC+9DIushjwYIF4DhOamnQoIFcdaj+6ykh5bBr1y5Mnz4d169fx9WrV+Hn5wcvLy907NgREokEvXv3Ru3atXH9+nWkpaVh6tSppdYnkUhQt25d/PrrrzA2NsaVK1cwduxYmJubo3///iVul52djezsbP51enq6XP3QM8qHmjrw9qX0RzH1lTos7bJL2KricBzD1B5XEP3EDI9fGCk0lvjaGwifZiFpvpNC4xSmiv1LMRV77Nakz0xlo+g5NA0bNsSZM2f41/KOoFNCQ6okNzc3BAYGAgDs7e2xYcMGhIeHo2PHjjhz5gzu37+PkydPwsLCAgCwbNkydO7cucT6NDQ0sHDhQv61jY0Nrl69igMHDpSa0AQFBUltV9XM7HUZtmZvMG5jD4XGUX+dA9O9SXg2yx5MkwaGSdWlrM9MZaTohEZdXR1mZmZyb8dvX+4tCVEhNzc3qdfm5uZISUkBAMTGxsLS0pJPZgDA09OzzDo3btyIn376CYmJiXj//j1ycnLKvALK398f06dP51+np6fD0lL2q3bS36ghPw8wMM2TKjc0yUPqS8V+PGf0ugwv56cYv6k7XqaJFRpLmJAF9fQ81AuM5cs4CaD1IBMG4Sl4uKMJIKj4c+6q2L8UU7HHbk35zFRG5UloPh21FgqFEAqFxW4THx8PCwsLiEQieHp6IigoCPXq1ZO5ffRViVRJGhoaUq85joNEIil3faGhoZg5cyZGjRqFU6dOISoqCiNGjEBOTk6p2wmFQujp6Ukt8sjLFSD+L200bpXBl3Ecg3urTMTcVtSlrwwzel1GW5cnmLTFF8lvFD+fJctZF0+XOCNx0X/LBxttZHxhhMRFzgpJZgDV7F+Kqchjt+Z8Ziqj8kwKtrS0hL6+Pr8EBQUVW3eLFi0QEhKCEydOYPPmzXjy5Alat26NjIyMYtcvDo3QkGrHyckJSUlJSE5Ohrm5OQDg2rVrpW4TERGBli1bYsKECXzZo0ePFNrOAoe3mWDmuiQ8iNZGXKQ2eo15CZG2BKdCFXN+fmbvy/iq8UPMCfZBVrYGjHQ/TqR8914T2XmK+ZXAtNSQU1f6Mm2JpgD5YvUi5RVN2fuXYio2piriquIzUxkxyH4HYPa/f5OSkqS+6JU0OlN4SoCbmxtatGgBKysrHDhwAKNGjZIpZs15J0iN0aFDBzg4OGD48OFYuXIl0tPTMW/evFK3sbe3x+7du3Hy5EnY2Njg559/xs2bN2FjY6Pw9l4IM4S+cT6GzXoBQ9M8PP5bC/OG2ODtK42yNy6HPi1jAACbJhyTKl8c6o0/bjkqJKYqKXv/UkzFxlRF3Jr2mSlJeU45lWfkGgAMDAzg4OCAhw8fyrwNJTSk2hEIBDhy5AhGjRqF5s2bw9raGuvXr0enTp1K3GbcuHGIjIzEgAEDwHEcBg0ahAkTJuDPP/9USpvDgk0QFmyilFieM8cpJU5Znvkr7w+BMvcvxax+cSvLZ0bVlHmn4MzMTDx69Ahff/21zNtwjDFW9mqEEFmkp6dDX18f3ugBdU6x31Kl4g7+QmmxCvv3K+XfKdXe77bSY5LqSZmfm/zcD7h94HukpaWVa8RClQp+r7U5NgHqOsWfMvpU3rtsXPTdJHN/Z86cCV9fX1hZWeH58+cIDAxEVFQUYmJiYGpqKlNMGqEhhBBCSJkUOULzzz//YNCgQXj9+jVMTU3RqlUrXLt2TeZkBqCEhhBCCCEyYIwDkzFRkXW9AqGhoeVpkhRKaAghhBBSJnkeaSDvow8qAiU0hBBCCCmTMicFlwclNIQQQggpkyJPOVUESmgIIYQQUiYaoSGEEEJIlUcjNIQQhdPbW/qjHRQXV/kx40OaKj0m3fumelLm5yaPKf+eTTUNJTSEEEIIKROT45QTjdAQQgghpFJiAGR9toAqHkFACQ0hhBBCyiQBB47uQ0MIIYSQqowmBRNCCCGkypMwDhxdtk0IIYSQqowxOebQqGASDSU0hBBCCCkTnXIihBBCSJVHCQ0hhBBCqrzKPodGoPSIhJAifP1eYdf1GBx7/Bd+OB4PR/esahlTlXEBwPD4C9j73YbJniSFx6op72lNOo5UeexWBgVzaGRdlI0SGkJUrG33VIwNfI49a8ww0ccBj2NEWLr3MfSNFXerdFXEVGVcABA+fgf98y+Rbaml8Fg15T2tSceRKo/dyuJjosLJuCi/fZTQkErJz88PPXv2VHUzlKL32Fc4sdcIp/YbITFehPVz6iL7PQefQW+qVUxVxuU+5MNs6xP8O8IK+dpqCo0F1Jz3tCYdR6rqa2UiezIj+1ybiiTTHJqwsDCZK+zevXu5G0NITaOuIYG9WxZCN9TiyxjjEHlJF85NFTOcrYqYqowLALV+TsS7Rvp431APCEtWaKya8p7WpONIlcduZcIg+yMNKu2jD2T9psxxHPLz8z+nPYQUceLECSxZsgT37t2DmpoaPD098cMPP6B+/foAgISEBNjY2GDfvn1Yv3497ty5Azs7O2zcuBFt27YFAOTn52Ps2LE4e/YsXrx4gXr16mHChAmYMmUKH8fPzw9v375Fq1atsHr1auTk5GDgwIFYt24dNDQ0im1bdnY2srOz+dfp6ely9U3PKB9q6sDbl9IfxdRX6rC0yy5hq8+jipiqjCu+9gbCp1lImu+ksBiF1ZT3tCYdR6rqa2VT2a9ykumUk0QikWmhZIYowrt37zB9+nTcunUL4eHhEAgE6NWrFyQSidR6s2bNwowZMxAZGQlPT0/4+vri9evXAD4ew3Xr1sWvv/6KmJgYzJ8/H9999x0OHDggVce5c+fw6NEjnDt3Drt27UJISAhCQkJKbFtQUBD09fX5xdLSssL7T8pP/XUOTPcm4cU4GzBNOsNOyGdhci5K9lmXbX/48AEikaii2kJIsfr06SP1+qeffoKpqSliYmLg4uLCl0+aNIlfd/PmzThx4gR27tyJ2bNnQ0NDAwsXLuTXtbGxwdWrV3HgwAH079+fLzc0NMSGDRugpqaGBg0aoGvXrggPD8eYMWOKbZu/vz+mT5/Ov05PT5crqUl/o4b8PMDANE+q3NAkD6kvFXNXBVXEVFVcYUIW1NPzUC8wli/jJIDWg0wYhKfg4Y4mgKBiv0nWlPe0Jh1HquprpSPP3JjKOkJTWH5+PhYvXow6depALBbj8ePHAICAgADs3LmzwhtISHx8PAYNGgRbW1vo6enB2toaAJCYmCi1nqenJ/9/dXV1eHh4IDb2vz9kGzduRNOmTWFqagqxWIxt27YVqaNhw4ZQU/tv0qi5uTlSUlJKbJtQKISenp7UIo+8XAHi/9JG41YZfBnHMbi3ykTMbW256qrMMVUVN8tZF0+XOCNx0X/LBxttZHxhhMRFzhWezAA15z2tSceRqvpa2VS7y7aXLl2KkJAQrFixApqamny5i4sLduzYUaGNIwQAfH198ebNG2zfvh3Xr1/H9evXAQA5OTky1xEaGoqZM2di1KhROHXqFKKiojBixIgidXw6V4bjuCKntira4W0m6Dz4DTr0ewNLuw/49v/+gUhbglOhRtUqpiriMi015NTVklokmgLki9WRU1dxl2/XlPe0phxHqopZ2VSLq5wK2717N7Zt24b27dvjm2++4csbNWqE+/fvV2jjCHn9+jXi4uKwfft2tG7dGgBw+fLlYte9du0a2rRpAwDIy8vD7du3MWnSJABAREQEWrZsiQkTJvDrP3r0SMGtl82FMEPoG+dj2KwXMDTNw+O/tTBviA3evip+InJVjanKuMpWU97TmnQc1ZRjt1SMk/1UUlVIaJ49ewY7O7si5RKJBLm5NecGQ0Q5DA0NYWxsjG3btsHc3ByJiYmYO3dusetu3LgR9vb2cHJywtq1a5GamoqRI0cCAOzt7bF7926cPHkSNjY2+Pnnn3Hz5k3Y2NgoszslCgs2QViwSbWPqcq4BZ75OyolTk15T2vScaTqY1fVKvvTtuU+5eTs7IxLly4VKT948CAaN25cIY0iRCKRQF1dHQKBAKGhobh9+zZcXFwwbdo0rFy5stht/u///g//93//h0aNGuHy5csICwuDicnHXz7jxo1D7969MWDAALRo0QKvX7+WGq0hhBBShup2ldP8+fMxfPhwPHv2DBKJBIcPH0ZcXBx2796N48ePK6KNpAZKSUnhRwI7dOiAmJgYqZ+zYtJ/Jycnfn7Np4RCIYKDgxEcHCxVHhQUxP+/uMuz161bJ2fLCSGkelLWfWj+7//+D/7+/pgyZYpcv4PlHqHp0aMHjh07hjNnzkBHRwfz589HbGwsjh07ho4dO8pbHSFSUlNTcfz4cZw/fx4dOnRQdXMIIYQUpuDRmZs3b2Lr1q1wc3OTe9tyXUDfunVrnD59ujybElKqkSNH4ubNm5gxYwZ69Oih6uYQQgj5H0WP0GRmZmLIkCHYvn07lixZIvf25b4j0K1bt/h7fDg7O6Np06blrYoQ3pEjR+TextrauthTUIQQQipQOR7m9OnjYIRCIYRCYbGbTJw4EV27dkWHDh2Uk9D8888/GDRoECIiImBgYAAAePv2LVq2bInQ0FDUrVtX7kYQQgghpLLj/rfIui6K3Dk9MDAQCxYsKLJ2aGgo7ty5g5s3b5a7dXInNKNHj0Zubi5iY2Ph6Pjx8se4uDiMGDECo0ePxokTJ8rdGEIIIYRUUuUYoUlKSpK6g3pxozNJSUmYMmUKTp8+/VmPU5I7oblw4QKuXLnCJzMA4OjoiB9//JG/8RkhhBBCqplyJDSyPBLm9u3bSElJQZMmTfiy/Px8XLx4ERs2bEB2drbUI2lKIndCY2lpWewN9PLz82FhYSFvdYQQIhfHde+VHvPP51FKjwkAPhbuKolLSLEUdKfg9u3b4+7du1JlI0aMQIMGDTBnzhyZkhmgHAnNypUr8e2332Ljxo3w8PAA8HGC8JQpU7Bq1Sp5qyOEEEJIFaCoOwXr6urCxcVFqkxHRwfGxsZFyksjU0JjaGgIjvsv23r37h1atGgBdfWPm+fl5UFdXR0jR45Ez549ZQ5OCCGEkCqiHKeclEmmhIbulkoIIYTUcEp8OOX58+fl3kamhGb48OFyV0wIIYSQ6oNjHxdZ11W2ct9YDwA+fPiAnJwcqbKyZjMTQgghpAqq5Kec5H6W07t37zBp0iTUqlULOjo6MDQ0lFoIIYQQUg0VnHKSdVEyuROa2bNn4+zZs9i8eTOEQiF27NiBhQsXwsLCArt371ZEGwkhhBCiarI+mPIzH1BZXnKfcjp27Bh2794Nb29vjBgxAq1bt4adnR2srKywZ88eDBkyRBHtJIQQQggpkdwjNG/evIGtrS2Aj/Nl3rx5AwBo1aoVLl68WLGtI4QQQkjlUN1GaGxtbfHkyRPUq1cPDRo0wIEDB9C8eXMcO3aMf1glIUQ+vn6v0Hd8CoxM8/A4Rgubvq+DuCjtahdT2XFdXFLQt08s7OxSYWz8HosWt8bVq4p9gO6w5s749x/NIuW+w19iUtAzhcam46h69rXSqG6TgkeMGIHo6GgAwNy5c7Fx40aIRCJMmzYNs2bNqvAGElLdte2eirGBz7FnjRkm+jjgcYwIS/c+hr5x0UeMVOWYqogrEuXh8RNDbNrUVCH1F2f9n3HYF3WPX4JCHwIAWvumKTQuHUfVs6+VSnWbFDxt2jRMnjwZANChQwfcv38fe/fuRWRkJKZMmVLhDSSK5+fnV+wdns+fPw+O4/D27Vult+lT3t7emDp1qlTZDz/8AKFQiNDQUNU0qoL0HvsKJ/Ya4dR+IyTGi7B+Tl1kv+fgM+hNtYqpiri3bllg9243XLlqqZD6i2NgnA+jWnn8cv2MPsyts+HmmanQuHQcVc++ViYF96GRdVE2uROaT1lZWaF3795wc3OriPYQIpPAwEB89913+O233zBw4EBVN6fc1DUksHfLwp1LunwZYxwiL+nCuWlWtYmpyriqlJvD4ewhQ/gMfA1OgV9Y6Tiqnn2tdCr5HBqZEpr169fLvJDq7dChQ2jYsCGEQiGsra2xevVqqZ9bW1tj2bJlGDlyJHR1dVGvXj1s27ZNap0rV67A3d0dIpEIHh4eOHr0KDiOQ1RUVJnxGWP49ttvsX79epw+fRqdOnUCAEgkEixatAh169aFUCiEu7s7Tpw4wW+XkJAAjuNw+PBhtGvXDtra2mjUqBGuXr0qVf/27dthaWkJbW1t9OrVC2vWrFHo3DA9o3yoqQNvX0pPZ0t9pQ5D07xqE1OVcVXpygl9ZKar4av+iv0WT8dR9ewrkY9Mk4LXrl0rU2Ucx/Gno0j1c/v2bfTv3x8LFizAgAEDcOXKFUyYMAHGxsbw8/Pj11u9ejUWL16M7777DgcPHsT48ePRtm1bODo6Ij09Hb6+vujSpQv27t2Lp0+fFjmVVJK8vDwMHToUZ8+exYULF6RGBX/44QesXr0aW7duRePGjfHTTz+he/fu+Pvvv2Fvb8+vN2/ePKxatQr29vaYN28eBg0ahIcPH0JdXR0RERH45ptvsHz5cnTv3h1nzpxBQEBAqW3Kzs5GdnY2/zo9PV22nUlqhJP7jNCsXTqMzeiPHqn6OMjx6AOFtqR4MiU0T548UXQ7iIodP34cYrFYqiw/P1/q9Zo1a9C+fXv+j7yDgwNiYmKwcuVKqYSmS5cumDBhAgBgzpw5WLt2Lc6dOwdHR0fs3bsXHMdh+/btEIlEcHZ2xrNnzzBmzJgy27h9+3YAQHR0NBo0aCD1s1WrVmHOnDn86afly5fj3LlzWLduHTZu3MivN3PmTHTt2hUAsHDhQjRs2BAPHz5EgwYN8OOPP6Jz586YOXMm378rV67g+PHjJbYpKCgICxcuLLPtJUl/o4b8PMDgk295hiZ5SH35WU8mqVQxVRlXVf79RwORl3QRsEPxvz/pOKqefa10lPhwyvL47Dk0pHpo164doqKipJYdO3ZIrRMbGwsvLy+pMi8vL8THx0slP4VHTjiOg5mZGVJSUgAAcXFxcHNzg0gk4tdp3ry5TG1s1aoVxGIxAgICkJf33y+W9PR0PH/+vNi2xcbGSpUVbpu5uTkASLXt07aU1TZ/f3+kpaXxS1JSkkx9KZCXK0D8X9po3CqDL+M4BvdWmYi5rZjLQVURU5VxVeVUqDEMTPLQooPiR+3oOKqefa10KvkcmhqUWpLS6OjowM7OTqrsn3/+KVddGhoaUq85joNEIil32wq4urpi9erV6NChAwYMGID9+/dDXV2+Q7hw27j/zdL8nLYJhUIIhcJybw8Ah7eZYOa6JDyI1kZcpDZ6jXkJkbYEp0KNPqveyhZTFXFFolxYWPx3dVHt2pmwtU1FRoYmXr7UUUhMAJBIgFP7jdCh3xuoKem3LB1H1bOvlUolvw8NJTREZk5OToiIiJAqi4iIgIODA9TU1GSqw9HREb/88guys7P5RODmzZsyt8Hd3R3h4eHo0KED+vfvj/3790NPTw8WFhaIiIhA27Ztpdom6+hPQds+bYs8bSuvC2GG0DfOx7BZL2BomofHf2th3hAbvH2lUfbGVSimKuLa27/BiuVn+dfjxkYCAE6ftsGatV8oJCYARF7URcozTfgMVN4lvXQcVc++VibyXI6tisu2KaEhMpsxYwaaNWuGxYsXY8CAAbh69So2bNiATZs2yVzH4MGDMW/ePIwdOxZz585FYmIiVq1aBeC/EZOyNGrUCGfPnkX79u3Rv39/HDhwALNmzUJgYCDq168Pd3d3BAcHIyoqCnv27JG5bd9++y3atGmDNWvWwNfXF2fPnsWff/4pc7s+R1iwCcKCTRQeR9UxlR337t3a6NxlkFJiFdbUOwMnn0cpPS4dR9UvZqVSyUdoaA4NkVmTJk1w4MABhIaGwsXFBfPnz8eiRYukJgSXRU9PD8eOHUNUVBTc3d0xb948zJ8/HwCk5tWUxdXVFWfPnsWVK1fQr18/TJgwAdOnT8eMGTPg6uqKEydOICwsTOoKp7J4eXlhy5YtWLNmDRo1aoQTJ05g2rRpcrWLEEKqrUo+h4ZjjMkd9tKlS9i6dSsePXqEgwcPok6dOvj5559hY2ODVq1aKaKdpBrbs2cPRowYgbS0NGhpaam6OVLGjBmD+/fv49KlSzKtn56eDn19fXijB9S5mjMUrUwCd2elx/zzj71KjwkAPhbuKolLKl4ey8V5/Ia0tDTo6empujlyKfi9ZrNoKQQyfsGTfPiAJ/PnKbW/co/QHDp0CD4+PtDS0kJkZCR/D460tDQsW7aswhtIqp/du3fj8uXLePLkCY4ePYo5c+agf//+lSKZWbVqFaKjo/Hw4UP8+OOP2LVrF4YPH67qZhFCiOpVt2c5LVmyBFu2bMH27dulrhjx8vLCnTt3KrRxpHp68eIFhg4dCicnJ0ybNg39+vUrcjdhVblx4wY6duwIV1dXbNmyBevXr8fo0aNV3SxCCFG9Sn7KSe5JwXFxcWjTpk2Rcn19/UrxEENS+c2ePRuzZ89WdTOKdeDAAVU3gRBCKqXKfpWT3CM0ZmZmePjwYZHyy5cvw9bWtkIaRQghhJBKppKP0Mid0IwZMwZTpkzB9evXwXEcnj9/jj179mDmzJkYP368ItpICCGEEFVj/43SlLVUiVNOc+fOhUQiQfv27ZGVlYU2bdpAKBRi5syZ+PbbbxXRRkIIIYSoWiW/D43cCQ3HcZg3bx5mzZqFhw8fIjMzE87OzkUebEgIIYSQaqS6JTQFNDU14eys/PtBEEKIsqnqfjDxIU2VHtPe77bSY5KqobJPCpY7oWnXrl2pt4I/e/ZsiT8jhBBCCPnU5s2bsXnzZiQkJAAAGjZsiPnz56Nz584y1yF3QuPu7i71Ojc3F1FRUbh37x7dgIwQQgiprhR4yqlu3br4v//7P9jb24Mxhl27dqFHjx6IjIxEw4YNZapD7oRm7dq1xZYvWLAAmZmZ8lZHCCGEkCpAkaecfH19pV4vXboUmzdvxrVr12ROaCrs4ZRDhw7FTz/9VFHVEUIIIaSykfMeNOnp6VJLweOSSpOfn4/Q0FC8e/cOnp6eMjetwhKaq1ev0lOJCSGEkOqqHDfWs7S0hL6+Pr8EBQWVWP3du3chFoshFArxzTff4MiRI3JdfCT3KafevXtLvWaMITk5Gbdu3UJAQIC81RFCCCGkCijPKaekpCSpp20LhcISt3F0dERUVBTS0tJw8OBBDB8+HBcuXJA5qZE7odHX15d6LRAI4OjoiEWLFuGrr76StzpCCCGEVAXlmBSsp6cnldCURlNTE3Z2dgCApk2b4ubNm/jhhx+wdetWmbaXK6HJz8/HiBEj4OrqCkNDQ3k2JYQQQkgVpuz70EgkEpnm3BSQK6FRU1PDV199hdjYWEpoCCGEkJpEgZdt+/v7o3PnzqhXrx4yMjKwd+9enD9/HidPnpS5DrknBbu4uODx48fybkZIheI4DkePHi3x5+fPnwfHcXj79q3S2vQ5fP1eYdf1GBx7/Bd+OB4PR/esahlT2XFdXFKwIPACfvn5KP78Yx88Pf9RWKxPqWr/AoDh8Rew97sNkz1JCo9VE44jVcasVBT4tO2UlBQMGzYMjo6OaN++PW7evImTJ0+iY8eOMtchd0KzZMkSzJw5E8ePH0dycnKRS7IIqQgvXrzAt99+C1tbWwiFQlhaWsLX1xfh4eEybd+yZUskJycXmfNVGbXtnoqxgc+xZ40ZJvo44HGMCEv3Poa+cW61iqmKuCJRHh4/McSmTcp9hICq9i8ACB+/g/75l8i21FJ4rJpyHKkqZmUj65O25Tk1VWDnzp1ISEhAdnY2UlJScObMGbmSGUCOhGbRokV49+4dunTpgujoaHTv3h1169aFoaEhDA0NYWBgQKehSIVISEhA06ZNcfbsWaxcuRJ3797FiRMn0K5dO0ycOFGmOjQ1NWFmZlbqYzoqi95jX+HEXiOc2m+ExHgR1s+pi+z3HHwGvalWMVUR99YtC+ze7YYrVy0VUn9JVLV/uQ/5MNv6BP+OsEK+tppCYwE15zhSVcxKR4EjNBVB5oRm4cKFePfuHc6dO8cvZ8+e5ZeC14R8rgkTJoDjONy4cQN9+vSBg4MDGjZsiOnTp+PatWv8eq9evUKvXr2gra0Ne3t7hIWF8T/79JRTSEgIDAwMcPLkSTg5OUEsFqNTp05ITk7mt7l58yY6duwIExMT6Ovro23btrhz545C+6quIYG9WxbuXNLlyxjjEHlJF85NFTOcrYqYqoyrbKrsZ62fE/GukT7eN5TtqpLPUZOOo5py7JapuiQ0jH1sXdu2bUtdCPkcb968wYkTJzBx4kTo6OgU+bmBgQH//4ULF6J///7466+/0KVLFwwZMgRv3pT8bSkrKwurVq3Czz//jIsXLyIxMREzZ87kf56RkYHhw4fj8uXLuHbtGuzt7dGlSxdkZGSUWGd2dvZnnXbVM8qHmjrw9qX0/PzUV+owNM2Tq67KHFOVcZVNVf0UX3sD4dMsvO5bR2ExCqtJx1FNOXarOrnm0FSF4XtStT18+BCMMTRo0KDMdf38/DBo0CDY2dlh2bJlyMzMxI0bN0pcPzc3F1u2bIGHhweaNGmCSZMmSc3J+fLLLzF06FA0aNAATk5O2LZtG7KysnDhwoUS6wwKCpK6C6alpXJPbRACAOqvc2C6NwkvxtmAaVbYDeAJkaLIOTQVQa7Lth0cHMpMakr7hkxIWQpGAmXh5ubG/19HRwd6enpISUkpcX1tbW3Ur1+ff21ubi61/r///ovvv/8e58+fR0pKCvLz85GVlYXExMQS6/T398f06dP51+np6XIlNelv1JCfBxh88i3P0CQPqS/lvu9lpY2pyrjKpop+ChOyoJ6eh3qBsXwZJwG0HmTCIDwFD3c0AQQV+4W0Jh1HNeXYLZMCL9uuCHK9EwsXLqwSV42Qqsve3h4cx+H+/ftlrquhoSH1muM4SCQSudYvnEANHz4cr1+/xg8//AArKysIhUJ4enoiJyenxDqFQmGpt/IuS16uAPF/aaNxqwxcPaH/v3YxuLfKRFiIcbnrrWwxVRlX2VTRzyxnXTxdIn17+No7E5BjJkJqV7MKT2aAmnUc1ZRjtyzKvrGevORKaAYOHIhatWopqi2EwMjICD4+Pti4cSMmT55cZB7N27dvpebRVKSIiAhs2rQJXbp0AfDxGSSvXr1SSKzCDm8zwcx1SXgQrY24SG30GvMSIm0JToUaVauYqogrEuXCwiKTf127diZsbVORkaGJly+LztGqKMruJ9NSQ05d6cu0JZoC5IvVi5RXpJpyHKkqZqVTXUZoaP4MUZaNGzfCy8sLzZs3x6JFi+Dm5oa8vDycPn0amzdvRmxsbNmVlIO9vT1+/vlneHh4ID09HbNmzYKWluLv5XEhzBD6xvkYNusFDE3z8PhvLcwbYoO3rzTK3rgKxVRFXHv7N1ix/L+rL8eNjQQAnD5tgzVrv1BITEB1+1fZaspxpKqYlU51SWjkmdtAyOewtbXFnTt3sHTpUsyYMQPJyckwNTVF06ZNsXnzZoXF3blzJ8aOHYsmTZrA0tISy5Ytk7oKSpHCgk0QFmyilFiqjKnsuHfv1kbnLoOUEutTqtq/BZ75OyolTk04jlQZszLh/rfIuq6ycYwyFUIqTHp6OvT19eGNHlDnatA3NyUSuDuXvVIFk0TFKD0mAMSHKPcOxwBg73db6TFrgjyWi/P4DWlpaTI/fbqyKPi95jx+GdSEIpm2yc/+gJjN3ym1vzVoejYhhBBCyqtaTQomhBBCSA1VXebQEEIIIaSGq8STVCihIYQQQkiZ6JQTIYQQQqo+OuVECCGEkKqORmgIIYQQUvXRCA0hhFQcVd0TRhVUcU8YjfPmSo+Z652s9JhEfjRCQwghhJCqj0ZoCCGEEFLlUUJDCCGEkKqOTjkRQgghpOqjERpCCCGEVHUcY+BkfJ61rOtVJEpoCCGEEFI2GqEhhBBCSFVHc2gIIYQQUvVV8hEagfJDEkIIIaSqKRihkXWRVVBQEJo1awZdXV3UqlULPXv2RFxcnNzto4SGkErA1+8Vdl2PwbHHf+GH4/FwdM+qljFVFZdiKkZ+cAZyvZOll69TFBqzQE3Yv5UOk3OR0YULFzBx4kRcu3YNp0+fRm5uLr766iu8e/dOruZRQkPK5cWLF5gyZQrs7OwgEolQu3ZteHl5YfPmzcjKqmEf8s/UtnsqxgY+x541Zpjo44DHMSIs3fsY+sa51SqmquJSTMW+p7BWh/qhWv8tP5ooNh5q2P6tRBQ1QnPixAn4+fmhYcOGaNSoEUJCQpCYmIjbt+V79AclNERujx8/RuPGjXHq1CksW7YMkZGRuHr1KmbPno3jx4/jzJkz5ao3JyengltaNfQe+won9hrh1H4jJMaLsH5OXWS/5+Az6E21iqmquBRTse8p1ADOWO2/xUDxf1Zq1P6tTMoxQpOeni61ZGdnlxkmLS0NAGBkZCRX8yihIXKbMGEC1NXVcevWLfTv3x9OTk6wtbVFjx498Pvvv8PX1xcA8PbtW4wePRqmpqbQ09PDl19+iejoaL6eBQsWwN3dHTt27ICNjQ1EIhEAgOM4bN26Fd26dYO2tjacnJxw9epVPHz4EN7e3tDR0UHLli3x6NEjvq5Hjx6hR48eqF27NsRiMZo1a1YksbK2tsayZcswcuRI6Orqol69eti2bRv/8y+//BKTJk2S2ubly5fQ1NREeHh4he9HAFDXkMDeLQt3LunyZYxxiLykC+emihnpUkVMVcWlmIp9TwEAz/KR2+df5A5KQd6SVLB/8xUarsbt30pG3tEZS0tL6Ovr80tQUFCp9UskEkydOhVeXl5wcXGRq22U0BC5vH79GqdOncLEiROho6NT7DocxwEA+vXrh5SUFPz555+4ffs2mjRpgvbt2+PNm/++0Tx8+BCHDh3C4cOHERUVxZcvXrwYw4YNQ1RUFBo0aIDBgwdj3Lhx8Pf3x61bt8AYk0o+MjMz0aVLF4SHhyMyMhKdOnWCr68vEhMTpdq2evVqeHh4IDIyEhMmTMD48eP5yWejR4/G3r17pb5B/PLLL6hTpw6+/PLLYvuanZ1d5BuIPPSM8qGmDrx9KX3BYeordRia5slVV2WOqaq4FFOx7ynnrAG1ufpQX2EEtWn6QHI+8ia/BsuSKCxmTdq/lQ5j8i0AkpKSkJaWxi/+/v6lhpg4cSLu3buH0NBQuZtHCQ2Ry8OHD8EYg6Ojo1S5iYkJxGIxxGIx5syZg8uXL+PGjRv49ddf4eHhAXt7e6xatQoGBgY4ePAgv11OTg52796Nxo0bw83NjS8fMWIE+vfvDwcHB8yZMwcJCQkYMmQIfHx84OTkhClTpuD8+fP8+o0aNcK4cePg4uICe3t7LF68GPXr10dYWJhUO7t06YIJEybAzs4Oc+bMgYmJCc6dOwcA6N27NwDgt99+49cPCQmBn58fn6R9KigoSOrbh6WlZfl2LCFVkKCFCAJvLXD1NSBoLoTa/xkBmRKwcx9U3TSiAOWZQ6Onpye1CIXCEuufNGkSjh8/jnPnzqFu3bpyt48SGlIhbty4gaioKDRs2BDZ2dmIjo5GZmYmjI2N+URHLBbjyZMnUqeKrKysYGpqWqS+wslN7dq1AQCurq5SZR8+fOBHRDIzMzFz5kw4OTnBwMAAYrEYsbGxRUZoCtfLcRzMzMyQkvLxqgyRSISvv/4aP/30EwDgzp07uHfvHvz8/Erst7+/v9S3j6SkJFl3GQAg/Y0a8vMAg0++5Rma5CH1pWJuE6WKmKqKSzEV+55+itMVgKurDvZMcaMWNXn/qpyCrnIqGHE/cuQIzp49Cxsbm3I1jxIaIhc7OztwHFfkHgG2traws7ODlpYWgI8Jhrm5OaKioqSWuLg4zJo1i9+upNNWGhoa/P8LRkeKK5NIPg5tz5w5E0eOHMGyZctw6dIlREVFwdXVtchE48J1FNRTUAfw8bTT6dOn8c8//yA4OBhffvklrKysStwfQqGwyDcQeeTlChD/lzYat8oo1CYG91aZiLmtLVddlTmmquJSTMW+p59iWRKw53mAsZrCYtTk/atqnES+RVYTJ07EL7/8gr1790JXVxcvXrzAixcv8P79e7naV4NSS1IRjI2N0bFjR2zYsAHffvttiQlJkyZN8OLFC6irq8Pa2lrh7YqIiICfnx969eoF4GNClZCQIHc9rq6u8PDwwPbt27F3715s2LChglta1OFtJpi5LgkPorURF6mNXmNeQqQtwalQ+Wb4V/aYqopLMRUXM39TOriWQnC11cBeSyAJzgAEHATtRQqLCdSc/VvpKOhOwZs3bwYAeHt7S5UHBweXOkL+KUpoiNw2bdoELy8veHh4YMGCBXBzc4NAIMDNmzdx//59NG3aFB06dICnpyd69uyJFStWwMHBAc+fP8fvv/+OXr16wcPDo0LbZG9vj8OHD8PX1xccxyEgIEBq5EUeo0ePxqRJk6Cjo8MnSIp0IcwQ+sb5GDbrBQxN8/D4by3MG2KDt680yt64CsVUVVyKqbiY7GU+JIvfAukSQF8AzlUT6puMwRkoboQGqDn7t7JR1LOcWAU9mZsSGiK3+vXrIzIyEsuWLYO/vz/++ecfCIVCODs7Y+bMmZgwYQI4jsMff/yBefPmYcSIEXj58iXMzMzQpk0bfk5MRVqzZg1GjhyJli1bwsTEBHPmzJH7iqMCgwYNwtSpUzFo0CD+UnJFCws2QViw4m9IpuqYqopLMRVDPdBQabE+VRP2b6VT6OolmdZVMo5VVGpESDWRkJCA+vXr4+bNm2jSpIlc26anp0NfXx/e6AF1ruZ8cyPVh8Z5c6XHzPVOVnpMZctjuTiP35CWlib3XDtVK/i91sJ3MdQ1ZPuSl5f7AdePBSi1vzRCQ8j/5Obm4vXr1/j+++/xxRdfyJ3MEEIIUR26yomQ/4mIiIC5uTlu3ryJLVu2qLo5hBBSuSjosu2KQiM0hPyPt7d3hU1OI4SQ6kZRk4IrCiU0hBBCCClbJZ8UTAkNIYQQQspEIzSEEEIIqfoUdGO9ikIJDSGEEELKRCM0hBBCqgxV3BMmPqSp0mMCgOM6+Z4V9DkE+dnAX78pLZ5CSNjHRdZ1lYwSGkIIIYSUjU45EUIIIaSq4yDHKSeFtqR4lNAQQgghpGx02TYhhBBCqjqaFEwIIYSQqo/m0BBCCCGkquMYAyfjqSRZ16tIlNAQQgghpGyS/y2yrqtklNAQQgghpEw0QkMIIYSQqq+Sz6ERKD8kIeRTvn6vsOt6DI49/gs/HI+Ho3tWtYypqrgUs3rFLMzw+AvY+92GyZ4khcZxcUnBgsAL+OXno/jzj33w9PxHofEqpYLLtmVdlIwSGkJUrG33VIwNfI49a8ww0ccBj2NEWLr3MfSNc6tVTFXFpZjVK2ZhwsfvoH/+JbIttRQeSyTKw+Mnhti0STWPaagMCi7blnVRNkpoiEr4+fmB47giy8OHD1XdNKXrPfYVTuw1wqn9RkiMF2H9nLrIfs/BZ9CbahVTVXEpZvWKWYD7kA+zrU/w7wgr5GurKTzerVsW2L3bDVeuWio8VqVFIzSEFK9Tp05ITk6WWmxsbKTWycnJUVHrlENdQwJ7tyzcuaTLlzHGIfKSLpybKmboXhUxVRWXYlavmIXV+jkR7xrp431DPYXHIh9xEvkWZaOEhqiMUCiEmZmZ1NK+fXtMmjQJU6dOhYmJCXx8fAAAa9asgaurK3R0dGBpaYkJEyYgMzOTryskJAQGBgY4efIknJycIBaL+YSpsJ9++gkNGzaEUCiEubk5Jk2axP/s7du3GD16NExNTaGnp4cvv/wS0dHRpfYhOzsb6enpUos89IzyoaYOvH0pPT8/9ZU6DE3z5KqrMsdUVVyKWb1iFhBfewPh0yy87ltHoXHIJ2iEhhD57Nq1C5qamoiIiMCWLVsAAAKBAOvXr8fff/+NXbt24ezZs5g9e7bUdllZWVi1ahV+/vlnXLx4EYmJiZg5cyb/882bN2PixIkYO3Ys7t69i7CwMNjZ2fE/79evH1JSUvDnn3/i9u3baNKkCdq3b483b0oePg8KCoK+vj6/WFrW4OFoQpRA/XUOTPcm4cU4GzBN+hOmVEzORcnosm2iMsePH4dYLOZfd+7cGQBgb2+PFStWSK07depU/v/W1tZYsmQJvvnmG2zatIkvz83NxZYtW1C/fn0AwKRJk7Bo0SL+50uWLMGMGTMwZcoUvqxZs2YAgMuXL+PGjRtISUmBUCgEAKxatQpHjx7FwYMHMXbs2GL74O/vj+nTp/Ov09PT5Upq0t+oIT8PMPjkG62hSR5SXyrm46mKmKqKSzGrV0wAECZkQT09D/UCY/kyTgJoPciEQXgKHu5oAghU8azn6q+y34eG0luiMu3atUNUVBS/rF+/HgDQtGnRqwjOnDmD9u3bo06dOtDV1cXXX3+N169fIyvrv3P12trafDIDAObm5khJSQEApKSk4Pnz52jfvn2xbYmOjkZmZiaMjY0hFov55cmTJ3j06FGJfRAKhdDT05Na5JGXK0D8X9po3CqDL+M4BvdWmYi5rS1XXZU5pqriUszqFRMAspx18XSJMxIX/bd8sNFGxhdGSFzkTMmMIlXyU040QkNURkdHR+qUT+HywhISEtCtWzeMHz8eS5cuhZGRES5fvoxRo0YhJycH2toff3lqaGhIbcdxHNj/PlRaWqVf1pmZmQlzc3OcP3++yM8MDAzk6JX8Dm8zwcx1SXgQrY24SG30GvMSIm0JToUaVauYqopLMatXTKalhpy60p9niaYA+WL1IuUVSSTKhYXFf/P2atfOhK1tKjIyNPHypU4pW1YjDLI/0kDOfObixYtYuXIlbt++jeTkZBw5cgQ9e/aUqw5KaEild/v2bUgkEqxevRoCwcdBxQMHDshVh66uLqytrREeHo527doV+XmTJk3w4sULqKurw9rauiKaLbMLYYbQN87HsFkvYGiah8d/a2HeEBu8faVR9sZVKKaq4lLM6hVTVezt32DF8rP863FjIwEAp0/bYM3aL1TVLKVS5Cmnd+/eoVGjRhg5ciR69+5dnuZRQkMqPzs7O+Tm5uLHH3+Er6+v1GRheSxYsADffPMNatWqhc6dOyMjIwMRERH49ttv0aFDB3h6eqJnz55YsWIFHBwc8Pz5c/z+++/o1asXPDw8FNCz/4QFmyAs2EShMSpDTFXFpZjVK+annvk7KjzG3bu10bnLIIXHqdQYZD+VJOcITefOnfl5lOVFc2hIpdeoUSOsWbMGy5cvh4uLC/bs2YOgoCC56xk+fDjWrVuHTZs2oWHDhujWrRvi4+MBfDw99ccff6BNmzYYMWIEHBwcMHDgQDx9+hS1a9eu6C4RQkjVU445NJ/e1iI7O1thzeMYU8HMHUKqqfT0dOjr68MbPaDOVb9hd0IUIT5ENY8TcFz3Xmmx8vKzcfav5UhLS5P74gFVK/i99qXrHKirCWXaJi8/G2fvLi9SHhgYiAULFpS6LcdxNIeGEEIIIYpRnjk0SUlJUglcwW0xFIESGkIIIYSUTZ7Lsf+3XnluZ1FelNAQQgghpGzlSGiUiRIaQgghhJRNgQlNZmYmHj58yL9+8uQJoqKiYGRkhHr16slUByU0hBBCCCmbBICsN2KW82nbt27dkrpHWMEjZYYPH46QkBCZ6qCEhhBCCCFlUuSN9by9vfG5F11TQkMIIYSQstEcGkKIogncnVUSVxIVo5K4pHpR5v1gClNbl6q0WJJ3OUAXpYWrkSihIYQQQkjZJAzgZBx5kdAIDSGEEEIqIzrlRAghhJCqT46ERt6nU1YASmgIIYQQUjYaoSGEEEJIlSdhkHnkhebQEEIIIaRSYpKPi6zrKhklNIQQQggpG51yIoQQQkiVR6ecCCFl8fV7hb7jU2BkmofHMVrY9H0dxEVpKyyei0sK+vaJhZ1dKoyN32PR4ta4erWuwuIVpuy+UszqFVMVx25+cAYkuzKlCy3VoPFzLYXGrXQq+QiNQOkRCakkFixYAHd3d1U3A227p2Js4HPsWWOGiT4OeBwjwtK9j6FvnKuwmCJRHh4/McSmTU0VFqM4qugrxaxeMVV17MJaHeqHav23/Gii3PiVAcN/SU2Zi/KbRwkNqZRevnyJ8ePHo169ehAKhTAzM4OPjw8iIiIqLMbMmTMRHh5eYfWVV++xr3BirxFO7TdCYrwI6+fURfZ7Dj6D3igs5q1bFti92w1XrloqLEZxVNFXilm9Yqrq2IUawBmr/bcY1MA/nzInM/Lcr6bi1MB3hFQFffr0QWRkJHbt2oUHDx4gLCwM3t7eeP36dYXFEIvFMDY2rrD6ykNdQwJ7tyzcuaTLlzHGIfKSLpybZqmwZRVPFX2lmNUrpko9y0dun3+ROygFeUtSwf7NV3WLlE8ikW9RMkpoSKXz9u1bXLp0CcuXL0e7du1gZWWF5s2bw9/fH927dwcAcByHzZs3o3PnztDS0oKtrS0OHjwoVc+cOXPg4OAAbW1t2NraIiAgALm5/w2Ff3rKyc/PDz179sSqVatgbm4OY2NjTJw4UWqbiqZnlA81deDtS+npbKmv1GFomqewuKqgir5SzOoVU1U4Zw2ozdWH+gojqE3TB5LzkTf5NViW8v9oqxSN0BAiH7FYDLFYjKNHjyI7O7vE9QICAtCnTx9ER0djyJAhGDhwIGJjY/mf6+rqIiQkBDExMfjhhx+wfft2rF27ttTY586dw6NHj3Du3Dns2rULISEhCAkJKXH97OxspKenSy2EkOpF0EIEgbcWuPoaEDQXQu3/jIBMCdi5D6pumnJRQkOIfNTV1RESEoJdu3bBwMAAXl5e+O677/DXX39JrdevXz+MHj0aDg4OWLx4MTw8PPDjjz/yP//+++/RsmVLWFtbw9fXFzNnzsSBAwdKjW1oaIgNGzagQYMG6NatG7p27VrqPJugoCDo6+vzi6WlfOf109+oIT8PMPjkG62hSR5SX1avixBV0VeKWb1iVhacrgBcXXWwZ9VrJKpMEibfomSU0JBKqU+fPnj+/DnCwsLQqVMnnD9/Hk2aNJEaLfH09JTaxtPTU2qEZv/+/fDy8oKZmRnEYjG+//57JCYmlhq3YcOGUFNT41+bm5sjJSWlxPX9/f2RlpbGL0lJSXL1My9XgPi/tNG4VQZfxnEM7q0yEXNbsZfbKpsq+koxq1fMyoJlScCe5wHGamWvXI0wJpFrUTZKaEilJRKJ0LFjRwQEBODKlSvw8/NDYGCgTNtevXoVQ4YMQZcuXXD8+HFERkZi3rx5yMnJKXU7DQ0Nqdccx0FSyuQ2oVAIPT09qUVeh7eZoPPgN+jQ7w0s7T7g2//7ByJtCU6FGsldl6xEolzY2qbC1jYVAFC7diZsbVNhavpOYTEB1fSVYlavmKo4dvM3pUMSlQ2WnAfJvRzkB6QCAg6C9iKFxayUmByjM3SnYEJK5uzsjKNHj/Kvr127hmHDhkm9bty4MQDgypUrsLKywrx58/ifP336VGltlceFMEPoG+dj2KwXMDTNw+O/tTBviA3evtIoe+Nysrd/gxXLz/Kvx42NBACcPm2DNWu/UFhcVfSVYlavmKo4dtnLfEgWvwXSJYC+AJyrJtQ3GYMzqFkjNB+TlMp7Yz1KaEil8/r1a/Tr1w8jR46Em5sbdHV1cevWLaxYsQI9evTg1/v111/h4eGBVq1aYc+ePbhx4wZ27twJALC3t0diYiJCQ0PRrFkz/P777zhy5IiqulSmsGAThAUr70Zdd+/WRucug5QWrzBl95ViVq+Yqjh21QMNlRqv0pJIAI4eTkmIzMRiMVq0aIG1a9fi0aNHyM3NhaWlJcaMGYPvvvuOX2/hwoUIDQ3FhAkTYG5ujn379sHZ2RkA0L17d0ybNg2TJk1CdnY2unbtioCAACxYsEBFvSKEkCquko/QcIypICohn4njOBw5cgQ9e/ZUdVOkpKenQ19fH97oAXVOccPunxK4OystVmGSqBiVxCXVi6qOX7V1qUqLlfsuB2e6bEVaWlq55tqpUsHvtS+1B0Kd05RpmzyWg7NZoUrtL43QEEIIIaRslXyEhhIaQgghhJRNwgCOEhpCKhSdKSWEECVjDICsk4LpxnqEEEIIqYSYhMm1yGvjxo2wtraGSCRCixYtcOPGDbm2p4SGEEIIIWVjEvkWOezfvx/Tp09HYGAg7ty5g0aNGsHHx6fUO7V/ihIaQgghhJRJkSM0a9aswZgxYzBixAg4Oztjy5Yt0NbWxk8//SRzHTSHhpAKVDC3Jw+5Ml8MUBEE+SU/lVyRJCxXJXFJ9aKy4/dd6Y9CqUh5WR9jVeX5f3ksW+aRlzx8/N2Qnp4uVS4UCiEUCqXKcnJycPv2bfj7+/NlAoEAHTp0wNWrV2VuHyU0hFSgjIyPD+q7jD+UG/iv35Qbj5CKpKrjt4vyQ2ZkZEBfX1/5gT+DpqYmzMzMcPmFfL/XxGIxLC0tpcoCAwOL3OD01atXyM/PR+3ataXKa9eujfv378scjxIaQiqQhYUFkpKSoKurC47j5No2PT0dlpaWSEpKUtqNqChm9YqpqrgUs2yMMWRkZMDCwkJBrVMckUiEJ0+elPlw308xxor8Hvx0dKYiUUJDSAUSCASoW7fuZ9VR3qd2U0yKqeq4FLN0VW1kpjCRSASRSDFPFzcxMYGamhr+/fdfqfJ///0XZmZmMtdDk4IJIYQQojKamppo2rQpwsPD+TKJRILw8HB4enrKXA+N0BBCCCFEpaZPn47hw4fDw8MDzZs3x7p16/Du3TuMGDFC5joooSGkkhAKhQgMDFToOWaKWb1jqiouxSSfa8CAAXj58iXmz5+PFy9ewN3dHSdOnCgyUbg09LRtQgghhFR5NIeGEEIIIVUeJTSEEEIIqfIooSGEEEJIlUcJDSGEEEKqPEpoiMpZW1tj3bp1Cqmb4zgcPXpUIXWXl7L7m5WVhT59+kBPTw8cx+Ht27el1uHt7Y2pU6cqpH2FcRzHtychIQEcxyEqKor/+fnz52Vqb01T1jFN+021FixYAHd3d1U3o0aihIaUS0l/9EJCQmBgYCBXXTdv3sTYsWP518pMQl6+fInx48ejXr16EAqFMDMzg4+PDyIiIqTa4+LiInd/S0pclN3fXbt24dKlS7hy5Qr69+8PPz8/qZ8fPHgQIpEIq1evxvv37xEVFYWff/4Z2dklPzDQz88PPXv2rLA2WlpaIjk5GS4uLnxZy5YtkZycjKlTp8ocq6R2VaY/8sV9dn744QcIhUKEhobixYsX+Pbbb2FrawuhUAhLS0v4+vpK3XSsNC1btkR0dDTmz58POzs7iEQi1K5dG15eXti8eTOysrIU0KvS+fn58Qls4eXhw4dKbYcsn/fPNXPmTJnfK1Kx6D40ROVMTU1VFrtPnz7IycnBrl27YGtri3///Rfh4eF4/fq1wmIqu7+PHj2Ck5MTXFxcoKWlJZWo7NixAxMnTsSWLVswYsQI/PLLL3B1dQVjDEePHsWAAQOU0kY1NTWpW5zn5ubyD8Sr7gIDA7Fq1Sr89ttvaNCgAZo2bQoDAwOsXLkSrq6uyM3NxcmTJzFx4kSZHtT3zz//wMfHBwYGBli2bBlcXV0hFApx9+5dbNu2DXXq1EH37t3lbmdOTg40NTXL00UAQKdOnRAcHCxV9uln4XNjlEUZn3exWAyxWFxh9RE5MELKoW3btmzKlClFyoODg5m+vj7/evjw4axHjx5s5cqVzMzMjBkZGbEJEyawnJwcfh0rKyu2du1a/v8A+MXKyopf7+jRo6xx48ZMKBQyGxsbtmDBApabm8v//MGDB6x169ZMKBQyJycndurUKQaAHTlypNg+pKamMgDs/PnzJfazpPY8fPiQde/enenq6jIAzMPDg50+fZrvr62trdR2hT9qZmZmzMbGholEIqamplak/o0bNzI7Ozumrq7O1NXVmUAgKLW/GhoaTFNTk6mrqzMAzM/PT+p9Klx/7dq1WY8ePRhjjC1fvpyJRCJ2+PBhfn1vb29mb2/P2rVrxzp27Mjvg6VLl7IRI0YwAMzQ0JAZGBgwgUDAGjRowBo3bsw6derENDQ0GADGcRzr2rUrA8AiIyMZY4xt2rSJiUQiqXYU/L/gfQDAnJycGMdxTCAQ8OsLBAKmo6PD1q1bxwwNDZlQKOTXFwgEbM2aNSwlJYV98cUXfLmWlhYzMDBgmpqarGHDhmzt2rV8rLy8PDZy5EhmamrKOI5jHMcxQ0NDtmrVKqnjVktLi3Xq1IlpaWkxAEwsFrNNmzZJHR8RERGsUaNGTCgUsqZNm7IjR45I9bs4BZ8diUTCJk2axAwMDFhERARjjLHOnTuzOnXqsHnz5rE6deowTU1N1qhRI/bnn3+y1NRUxhjj+9i8eXMmEAgYx3HMysqKXblyhTHGWLNmzRgAtnz5cla3bl2moaHB1NXV2ZgxY5hAIGDa2trMx8eHxcbGslGjRjETExOmo6PDDA0Nmb6+PtPT02Nt2rRhY8eOZY0aNWLbt29n1tbWjOM4Pv6WLVtY165dmZaWFmvQoAG7cuUKi4+PZ23btmXa2trM09OTPXz4kO9z7969mZmZGatVqxbT0dHhPy9t27ZlEydOZFOmTOGP8xEjRjBNTU3+uK5bty4bP348a926NZs4cSJj7L/fM6GhoQwAE4lEzMfHhz1//lxqX+/cuZM5OzszTU1NVqtWLanPe2pqKt9/XV1d1q5dOwaAbdq0iXXq1ImJRCJmY2PDfv31V6k6Z8+ezezt7ZmWlhazsbFh33//vdTvs8DAQNaoUSOpY6ms34GkYlBCQ8pFnoRGT0+PffPNNyw2NpYdO3aMaWtrs23btvHrFE5oUlJSGAAWHBzMkpOTWUpKCmOMsYsXLzI9PT0WEhLCHj16xE6dOsWsra3ZggULGGOM5efnMxcXF9a+fXsWFRXFLly4wBo3blxqQpObm8vEYjGbOnUq+/DhQ7HrFLTH0dGRjR49mm9PVFQU27JlC1u8eDHT1dVl33//PROJRKxv375MT0+P+fn5sdq1a7MhQ4YwLS0ttnLlSsbYx0SI4zjWs2dP9uDBA3b8+HEGgHl5ebHk5GR26tQppqamxubPn890dXXZwoULWUBAQIn9bd68OeM4jo0cOZI5OzszAExTU5MFBwczxhh7/fo1GzNmDPP09GTJycls4MCBrEePHmz27NlMLBazM2fO8H19+PAhEwqFzMvLi40bN46JRCKWkJDArKysmJGREdu4cSMDwPT09BgA5unpyXr27MknGDY2NmzLli3MzMyM/6MbGRnJzp8/z//h7dmzJ5s9e7ZUIlc4oQHApk6dyk6fPs1atmzJADB3d3fWtGlTPsFRV1dnEyZMYOvXr2dGRkZMIBAwHx8fNn36dNaoUSMGgKmpqbGmTZsye3t7NmrUKD4pSU1NZTk5OWz06NFMSdE7+QAAqalJREFUIBCwadOmsZUrVzJNTU2p/TZ8+HDGcRwTCoUsICCAbd26lWloaDCO49j9+/cZY4ylpaUxIyMjNnToUPb333+zP/74gzk4OMiU0EycOJENHjyYmZmZsejoaP694jiOdenShenp6bF9+/ax+/fvs9mzZzMNDQ324MEDxth/CY2FhQXbtm0b+/rrr5m6ujqrW7cue/HiBeM4jk8sV65cyYKCgpiamhpTV1dnOjo67Pbt28zJyYmZmZkxX19fdvPmTbZr1y7WuXNnZmBgwK5cucJGjRrFdHR0mI6ODuvUqRO7c+cO304ArE6dOmz//v0sLi6O9ezZk1lbW7Mvv/ySnThxgsXExLAvvviCderUie+zr68va9SoEbt79y578OAB/3n54osvmFgsZrNmzWIWFhZMX1+fbdy4kX333Xds9OjRjOM4FhISwhwdHVmHDh2YoaEh+/DhAwsODmYaGhrMwcGBmZubs1u3bjEnJyc2ePBgPmZBEr1u3ToWFxfHrly5woRCIf9579ChA9//Bw8esBkzZjAAzMjIiG3fvp3FxcWx77//nqmpqbGYmBi+3sWLF7OIiAj25MkTFhYWxmrXrs2WL1/O/7y4hKas34GkYlBCQ8pFnoTGysqK5eXl8WX9+vVjAwYM4F8XTmgYY8UmIe3bt2fLli2TKvv555+Zubk5Y4yxkydPMnV1dfbs2TP+53/++WepCQ1jjB08eJAZGhoykUjEWrZsyfz9/flf3IXb07BhwzL727BhQ9a8eXO+vwX9KtzfUaNGMbFYXKS/HMex9+/fs0OHDjE9PT3m7e0tU3979uzJj6QU9Ldnz57M2dmZ327KlCmsbdu2jLGP74empiYDwMLDw6Xq/+6771jPnj3597ZHjx4sMDCQWVlZsaFDh/JtnTdvHhOJRKxRo0bs6tWr/EjJ+/fvGWOM7du3TyqhcXd3ZxzHMXt7ez7WrFmzik1ovvjiC36dc+fO8QlUjx49mL29PRMIBHxbGGPs3r17DAAbN24cY4yxPn36SI3SFP63IBZjjA0ePJjfb4wxNnHiRObg4MDvt+HDhzM1NTU2ZMgQfp2+ffsyoVDINm/ezBhjbPPmzczY2JjvN2OMbd++XaaEpiCBio2N5cuvX7/Oj4AtXbpUaptmzZqxCRMm8O8BALZjxw7GGGOZmZl8WcGIBQD21VdfMcY+HqMFSR4ANnv2bDZt2jTGcVyRRL5+/fps69atLD8/nx/1K0jiCwBg33//Pf+64BjYuXMnX7Zv3z4mEon41wX7syBJ0tHRYXp6eszOzo41btyYMcakjjPGGJNIJKxWrVps8+bN7Ndff2XGxsbM0NCQ7d+/n++To6Mjn+Rv3LiR1a5dm9/ewsKCzZs3T6rtBZ93TU1NpqamxmbNmiX1eQfA2rRpI7VNixYt2Pjx41lJVq5cyZo2bcq/Li6hKet3IKkYNCmYKFzDhg2hpqbGvzY3N0dKSopcdURHR2PRokX8+WmxWIwxY8YgOTkZWVlZiI2NhaWlJSwsLPhtZHlKa58+ffD8+XOEhYWhU6dOOH/+PJo0aYKQkJBSt8vMzMTMmTPh7++PtLQ0iMVixMbG4t27d6X2Nzo6GpmZmZgzZ47UuXbGGJ48eYKOHTvCysoKFy5cQEBAAEQiUan9ffr0Kby8vKT626BBA8THxyM/P7/Ytru5ucHa2hqBgYHIzMwEAOTn52PXrl0YOnQov97QoUP5/eDm5saXN2rUiJ+LU/CcFWNjY4hEIgAo8uyV+Ph4vn8FfVm/fn2xbWvUqBH//yNHjgAA0tPTcfz4ccTHxwMA7t69C1tbW+jp6aFFixYAAENDQ8THx+P69ev89hKJBACwfv16NG3aVCrOxYsXce/ePZiamkIsFmPbtm2QSCRS+01TU1OqPRYWFlBXV+ffy7i4OLi5ufH9BoDmzZsX269PtWrVCmKxGAEBAcjLywPw8RgAgNTUVP49LeDl5YXY2FipsoL3REdHB7q6uvy2BZo0acL/XyQSwd/fH2pqasjOzkZmZiYYYzA2NoZYLIaOjg40NDTw6NEjfPvtt9DT00NOTg4MDQ2LnfNV+HgoeL9dXV2lyj58+ID09HQAH+dE1alTB7Vr1wbHcZBIJMjIyEB2drbUe1NQ75kzZ9ChQwe8efMGU6ZMwddff43Xr19j4MCB+Omnn/g+xcfH85PcC3/OUlJS8Pz5c7Rv316q3QWf9zFjxkAikWD16tVo1KgRhEIh/1n8dP6Lp6en1L7fv38/vLy8YGZmBrFYjO+//x6JiYlF9lFhFfE7kJSNEhpSLnp6ekhLSytS/vbtW+jr60uVaWhoSL0u+IUmj8zMTCxcuBBRUVH8cvfuXcTHx0v9QSkPkUiEjh07IiAgAFeuXIGfnx8CAwOl1tHW1pbq78yZM3HkyBF07twZ5ubmiIqKgqurKyQSSan9zczMhK6uLmbOnMn3AwA2bdqE+vXrQ1dXF3fu3IGGhga8vLxQq1YtGBsb4+LFixXW3zp16uD8+fN49uwZOnXqhIyMDJw8eRLPnj3DgAEDcOHCBaxfvx4DBw7E06dP8eHDB6k+FfyfMQaO4wAAAsF/v0oKygpkZ2dDQ0MDPXr04Pt89erVUtsYGhqKLVu28PV5e3vDxMQEEokEHz58wPbt23H9+nWpBMbX1xc5OTn86z179gAATExMpPZZaGgonj17hsaNG+PUqVOIiorCiBEj+MSisML9LuiXvMducVxdXREeHo5z585hwIAByMvLg729fZF9V5ri2mZubl5sHUKhUCox+fDhAwDw70eTJk3QoEEDbN++HeHh4YiKioKWllaRY7m02KXtq1u3buHVq1dYtWoVrly5gr/++gtubm6QSCTQ0dGRqjchIQHdunXjE++xY8di48aNAIAhQ4bg9OnTePPmDSQSCb788ktYWVnxMQuSQi0trRL3m0gk4r/8xMXFoV+/fjAxMeE/i126dClx26tXr2LIkCHo0qULjh8/jsjISMybN0/quCtrfxW0tSKOIyKNEhpSLo6Ojrhz506R8jt37sDBweGz6tbQ0CgyutCkSRPExcXBzs6uyCIQCODk5ISkpCQkJyfz21y7dq1c8Z2dnfHu3Tup9pibm0v1NyIiAn5+fsjLy0PDhg1hZmaGhIQEqXo0NTWL7Udubi5MTU359mtoaKBWrVr81R3q6urw8PCAnZ0dYmNj8fz5cyQkJBTbX2tra/6S04L+3r9/Hw4ODlLfCD9VMAr04sULdOrUCVu2bMHAgQMRFRUFDw8PDBkyBFFRURg4cCAyMjLK3GepqaklXubt4OCA3Nxc3L17l+9DSd9Oo6Oj+f3bsGFDAICuri7EYjHfn44dO6J9+/ZwcnLiRyTev3+PuLg4ODk58XUVjA7k5+fjwYMHfHlERARq1aqF3NxcNG7cGHZ2dnj06BHevXtX5n4rzNHREXfv3pXq982bN2XaFgDc3d0RHh6Oixcvon///tDV1YWPjw8EAgHOnTsntW5ERATq169fZp36+vr8iMenbSn82tbWFsDHY83Ozg5RUVGYPXs2Ro8ejVatWkEoFOL9+/cy96UsKSkpqFevHnr16gVXV9diPy8Fbt++zY+e6OjowNjYGM+fPwfwcaTDw8MDFy5cQG5uLkaOHFlsHbq6urC2ti7x8ukmTZrgxYsXUFdXxxdffIHs7GzY2dkBAP7++2+pda9du8YfV1euXIGVlRXmzZsHDw8P2Nvb4+nTp+XZJUQB6LJtUi7jx4/Hhg0bMHnyZIwePRpCoRC///479u3bh2PHjn1W3QW/iLy8vCAUCmFoaIj58+ejW7duqFevHvr27QuBQIDo6Gjcu3cPS5YsQYcOHeDg4IDhw4dj5cqVSE9Px7x580qN8/r1a/Tr1w8jR46Em5sbdHV1cevWLaxYsQI9evSQao+uri4ePHiAcePGYeLEiTAzM8OWLVuQkpKCH374AYMHDy7yjcva2hoXL16EqakpcnNzAQBz5szBvn37cOjQIXh7e0NHRwempqZYsGABvLy8cP78eaSkpGDIkCGYMmUK/v33X+Tn50NdXR2hoaFF+vv8+XPcuHEDo0aN4kcr/vjjD2zdurXM/WxpaYnz58+jTZs2uHr1Kn799Ve4uLjwf0RcXFwwbNgwhIaGynTvkrFjx2Lu3Lm4ceMGX8ZxHFatWoUuXbrgwYMH6NGjB7y8vLBq1api67h+/ToWL14MfX19/g+LjY0NYmNj+dNj+/fvh4+PD169eoUFCxYA+DgCYWxsjMePH/N1FYyybdu2TSops7e3R2ZmJsLDwzFlyhTk5uYiIiIC2dnZWLFiRZn9LDB48GDMmzeP73diYiLfL1lHWho1aoSzZ8+iffv26N+/P9atW4dmzZph8eLFSE9Ph4+PD3799Vfcvn1b5kuLp06diqFDhyI8PBxff/01atWqhQ8fPuDo0aOQSCRQU1PjT6X17NkTK1asQL169fDjjz/i8uXL8PT0xE8//QR19Yr786Cnp4fnz58jKioKHMchICCgxBEKOzs75Obm4scff0R2djaio6OlkrHRo0dj/PjxAIBevXqVGHPBggX45ptvUKtWLXTu3BlJSUn45ptvMH/+fLi6uqJx48bw9vZGeno6OnbsiCtXrgAA9u3bBw8PD7Rq1Qp79uzBjRs3sHPnTgAfj53ExESEhoaiWbNm+P333/lTo6QSUOUEHlK13bhxg3Xs2JGZmpoyfX191qJFiyITcAsuWSys8CRVxopOCg4LC+MvWy582faJEydYy5YtmZaWFtPT02PNmzeXulIgLi6OtWrVimlqajIHBwd24sSJUicFf/jwgc2dO5c1adKE6evrM21tbebo6Mi+//57lpWVVaQ9ampqTCQSMVNTU6arq8v09PSYpqYms7S0ZBs2bGBt27ZlTk5OfH+vXr3K3Nzc+MmYBczNzZmDgwMTi8VMR0eHWVtbM2NjY6aurs7MzMxY27Zt+YmL2traTFNTs9T+qqur85McAbDhw4eXuL+Lez8CAgKYQCBgLVq0YGlpaVITvrOzsxnHcaxXr16Msf8mbBsaGjJHR0f25MkTBoB17NiRubm58fse/5uYWnBF0I4dO6Qm5346Ubfg/ytXrmTOzs5MXV2dv6pJQ0OD2drasrlz5zKBQMBfHi4QCPhLlOfOnctOnz7NX0aP/111BYBZWlqyNWvW8LE+fPjA/Pz8mLa2NhMIBEwgEDA9PT1+wnXBftLS0pI6LqdMmcJ0dHRYYGAgXxYREcH3u2nTpmzv3r1S/S5OcRPq7969y2rVqsV69OjBEhISWLNmzfj3U0NDg33xxRfs3Llz/HuATyYeF1x5du7cOX4ydevWraWuJqtbty7T1dVl79694y8v//bbb5mFhQV/DAkEAmZtbc1+/fVXpq+vzywsLIq0/9PPVMExULg9BW0omITdp08fZmJiwrS0tKQ+L3Xq1OH3ReHfA2vWrGHm5uaM4zhWv359tnv3br6+jIwMflJ1YQV9KmzLli3M0dGRaWhoMDMzM9a0aVOpz7uBgQETi8VMXV2dWVpaMgBsyZIlrGPHjkwoFDJra2u2f/9+qTpnzZrFjI2NmVgsZgMGDGBr166VuhCipMu2C/v0dyCpGBxj/zvpSAghFWTPnj0YMWIE0tLSSp3PIItOnTrBzs4OGzZsKHPdhIQE2NjYIDIyUiW3n6/Ifle0MWPG4P79+7h06ZKqm/JZEhISUL9+fdy8eVNq4nNF4DgOR44cqdC7YBPloVNOhJDPtnv3btja2qJOnTqIjo7GnDlz0L9//8/6o56amoqIiAicP38e33zzTQW2tuIoot8VZdWqVejYsSN0dHTw559/YteuXdi0aZOqm1Vuubm5eP36Nb7//nt88cUXFZ7MkKqPEhpCyGd78eIF5s+fjxcvXsDc3Bz9+vXD0qVLP6vOkSNH4ubNm5gxY4bUnKbKRBH9rig3btzAihUrkJGRAVtbW6xfvx6jR49WdbPKLSIiAu3atYODgwMOHjyo6uaQSohOORFCCCGkyqPLtgkhhBBS5VFCQwghhJAqjxIaQgghhFR5lNAQQgghpMqjhIYQUqP5+flJ3XfE29sbU6dOVXo7zp8/D47j8Pbt2xLX4TgOR48elbnOBQsWfPb9eBISEsBxHP+sI0IqK0poCCGVjp+fHziOA8dx0NTUhJ2dHRYtWlTsAyQr2uHDh7F48WKZ1pUlCSGEKAfdh4YQUil16tQJwcHByM7Oxh9//IGJEydCQ0MD/v7+RdbNycnhH+75uYyMjCqkHkKIctEIDSGkUhIKhTAzM4OVlRXGjx+PDh06ICwsDMB/p4mWLl0KCwsLODo6AgCSkpLQv39/GBgYwMjICD169JB6qnN+fj6mT58OAwMDGBsbY/bs2fj0VlyfnnLKzs7GnDlzYGlpCaFQCDs7O+zcuRMJCQlo164dAMDQ0BAcx8HPzw8AIJFIEBQUBBsbG2hpaaFRo0ZFbgb3xx9/wMHBAVpaWmjXrl2JT58uzZw5c+Dg4ABtbW3Y2toiICCAfxBqYVu3boWlpSW0tbXRv39/pKWlSf18x44dcHJygkgkQoMGDar0HYVJzUUJDSGkStDS0kJOTg7/Ojw8HHFxcTh9+jSOHz+O3Nxc+Pj4QFdXF5cuXUJERATEYjE6derEb7d69WqEhITgp59+wuXLl/HmzZsyn5Y8bNgw7Nu3D+vXr0dsbCy2bt0KsVgMS0tLHDp0CAAQFxeH5ORk/PDDDwCAoKAg7N69G1u2bMHff/+NadOmYejQobhw4QKAj4lX79694evri6ioKIwe/f/s3XdYFFcXB+DfLAu7wNJBQEUQKYIUe8OCUYMNe9co9liiJsFCiAWxxN67CZhEQzSWqIldsaHGAkQDItggioJKEVHa3u8PPyasIOwiW4DzPs88urMz99w7M7ucvXNnZixmz56t8DYxMDBAaGgoYmJisHbtWmzfvh2rV6+WWSYhIQF79uzB4cOHcezYMURGRmLSpEn8+7t27cLcuXOxaNEixMbGYvHixZgzZw527typcH0IUSu1PhqTEEJKUPQJxVKplJ08eZKJRCLm7+/Pv29paclycnL4dX766Sfm7OzMpFIpPy8nJ4fp6uqy48ePM8bePel82bJl/Pt5eXmsdu3aMk9DLvo07Li4OAaAnTx5ssR6vv9UacbePcVdT0+PRUREyCw7ZswYNmTIEMYYYwEBAczV1VXm/VmzZhUr630o5enxjDG2fPly1qRJE/71vHnzmJaWFvv333/5eUePHmUCgYAlJyczxhirV68e2717t0w5wcHBrFWrVoyxkp+mTYgmojE0hBCNdOTIEUgkEuTl5UEqlWLo0KGYP38+/767u7vMuJno6GgkJCTAwMBAppy3b9/i3r17yMjIQHJyMlq0aMG/JxQK0bRp02KnnQpFRUVBS0sL7du3l7veCQkJyM7ORufOnWXm5+bmolGjRgCA2NhYmXoAQKtWreSOUejXX3/FunXrcO/ePWRlZSE/Px+GhoYyy9SpUwe1atWSiSOVShEXFwcDAwPcu3cPY8aMwbhx4/hl8vPzYWRkpHB9CFEnSmgIIRqpQ4cO2Lx5M3R0dFCzZk0IhbJfV/r6+jKvs7Ky0KRJE+zatatYWRYWFuWqQ3memp2VlQUA+OOPP2QSCeDduKCKcvnyZQwbNgxBQUHw8fGBkZERwsLCsHLlSoXrun379mIJlpaWVoXVlRBVoISGEKKR9PX14eDgIPfyjRs3xq+//ooaNWoU66UoZG1tjatXr6Jdu3YA3vVE3LhxA40bNy5xeXd3d0ilUpw7dw6dOnUq9n5hD1FBQQE/z9XVFSKRCImJiR/s2XFxceEHOBe6cuVK2Y0sIiIiAra2tggMDOTnPXr0qNhyiYmJePLkCWrWrMnHEQgEcHZ2hqWlJWrWrIn79+9j2LBhCsUnRNPQoGBCSJUwbNgwmJubo1evXrhw4QIePHiA8PBwTJ06Ff/++y8AYNq0afjuu+9w8OBB3LlzB5MmTSr1HjJ2dnYYOXIkRo8ejYMHD/Jl7tmzBwBga2sLjuNw5MgRpKamIisrCwYGBvD398eXX36JnTt34t69e7h58ybWr1/PD7T9/PPPER8fjxkzZiAuLg67d+9GaGioQu11dHREYmIiwsLCcO/ePaxbt67EAc5isRgjR45EdHQ0Lly4gKlTp2LgwIGwsrICAAQFBWHJkiVYt24d7t69i1u3biEkJASrVq1SqD6EqBslNISQKkFPTw/nz59HnTp10LdvX7i4uGDMmDF4+/Yt32Pz9ddf47PPPsPIkSPRqlUrGBgYoE+fPqWWu3nzZvTv3x+TJk1C/fr1MW7cOLx+/RoAUKtWLQQFBWH27NmwtLTElClTAADBwcGYM2cOlixZAhcXF3Tp0gV//PEH6tatC+DduJZ9+/bh4MGD8PT0xJYtW7B48WKF2tuzZ098+eWXmDJlCho2bIiIiAjMmTOn2HIODg7o27cvunXrhk8//RQeHh4yl2WPHTsWO3bsQEhICNzd3dG+fXuEhobydSWksuDYh0bDEUIIIYRUEtRDQwghhJBKjxIaQgghhFR6lNAQQgghpNKjhIYQQgghlR4lNIQQQgip9CihIYQQQkilRwkNIYQQQio9SmgIIYQQUulRQkMIIYSQSo8SGkIIIYRUepTQEEIIIaTSo4SGEEIIIZUeJTSEEEIIqfQooSGEEEJIpUcJDSGEEEIqPUpoCCGEEFLpUUJDCCGEkEqPEhpCCCGEVHqU0BBCCCGk0qOEhhBCCCGVHiU0hBBCCKn0KKEhhBBCSKVHCQ0hhBBCKj1KaAghhBBS6VFCQwghhJBKjxIaQgghhFR6lNAQQgghpNKjhIYQQgghlR4lNIQQQgip9CihIYQQQkilRwkNIYQQQio9SmgIIYQQUulRQkMIIYSQSo8SGkIIIYRUepTQEEIIIaTSo4SGEEIIIZUeJTSEEEIIqfQooSGEEEJIpUcJDSGEEEIqPUpoCCGEEFLpUUJDCCGEkEqPEhpCCCGEVHqU0BBCyuTn5wc7OzuZeRzHYf78+WqpT1VUWbZnSceCKoWGhoLjODx8+FBm/vLly2Fvbw8tLS00bNgQAGBnZwc/Pz+V15GoByU0hGiwBw8eYMqUKXBycoKenh709PTg6uqKyZMn4++//1Z39ZRu9+7dWLNmjdzL29nZgeM4fhKLxXB0dMSMGTPw8uVL5VVUTn/++afGJi2ZmZkICgqCp6cnJBIJdHV14ebmhlmzZuHJkyfqrl6pTpw4gZkzZ8LLywshISFYvHixuqtE1IBjjDF1V4IQUtyRI0cwaNAgCIVCDBs2DJ6enhAIBLhz5w7279+PR48e4cGDB7C1tVV6Xfz8/BAeHi7zq/jt27cQCoUQCoVKi9ujRw/cvn272K/xD7Gzs4OJiQm+/vprvo43btzAjh070KhRI/z1119Kq6s8pkyZgo0bN6Kkr11VbM8PuX//Pjp16oTExEQMGDAAbdq0gY6ODv7++2/88ssvMDU1xd27dwGUfCyoUkFBAfLy8iASicBxHABg9uzZWL58Od68eQMdHR1+2ZycHAgEAmhra6ulrkS1VP/JIYSU6d69exg8eDBsbW1x+vRpWFtby7y/dOlSbNq0CQJB6Z2sr1+/hr6+vlLqKBaLlVLux6pVqxaGDx/Ovx47diwkEglWrFiB+Ph4ODo6qrF2H6au7Zmfn4++ffvi2bNnCA8PR5s2bWTeX7RoEZYuXaqWupVES0sLWlpaMvNSUlKgq6srk8wAgEgkqrC4+fn5kEqlxWIQzUGnnAjRQMuWLcPr168REhJSLJkBAKFQiKlTp8LGxoaf5+fnB4lEgnv37qFbt24wMDDAsGHDAAAXLlzAgAEDUKdOHYhEItjY2ODLL7/EmzdvipV98OBBuLm5QSwWw83NDQcOHCixjiWN+Xj8+DFGjx4NS0tLiEQiNGjQAD/88IPMMuHh4eA4Dnv27MGiRYtQu3ZtiMVidOzYEQkJCfxy3t7e+OOPP/Do0SP+FFJ5x25YWVkBQLHejzNnzqBt27bQ19eHsbExevXqhdjY2GLrR0ZGomvXrjA0NIREIkHHjh1x5coVmWXy8vIQFBQER0dHiMVimJmZoU2bNjh58iSAd/tn48aN/LYrnAq9vz3nz58PjuOQkJAAPz8/GBsbw8jICKNGjUJ2drZM7Ddv3mDq1KkwNzeHgYEBevbsicePH8s1Lmffvn2Ijo5GYGBgsWQGAAwNDbFo0aJSy1ixYgVat24NMzMz6OrqokmTJvjtt9+KLXfy5Em0adMGxsbGkEgkcHZ2xjfffCOzzPr169GgQQPo6enBxMQETZs2xe7du/n33x9Dw3EcQkJC8Pr1a36bhoaGAih5DE16ejqmT58OGxsbiEQiODg4YOnSpZBKpfwyDx8+BMdxWLFiBdasWYN69epBJBIhJiam1O1A1It6aAjRQEeOHIGDgwNatGih0Hr5+fnw8fFBmzZtsGLFCujp6QEA9u7di+zsbEycOBFmZmb466+/sH79evz777/Yu3cvv/6JEyfQr18/uLq6YsmSJXjx4gVGjRqF2rVrlxn72bNnaNmyJTiOw5QpU2BhYYGjR49izJgxyMzMxPTp02WW/+677yAQCODv74+MjAwsW7YMw4YNw9WrVwEAgYGByMjIwL///ovVq1cDACQSSZn1yMvLw/PnzwG8O40TGRmJVatWoV27dqhbty6/3KlTp9C1a1fY29tj/vz5ePPmDdavXw8vLy/cvHmTT57++ecftG3bFoaGhpg5cya0tbWxdetWeHt749y5c/w+mj9/PpYsWYKxY8eiefPmyMzMxPXr13Hz5k107twZEyZMwJMnT3Dy5En89NNPZbaj0MCBA1G3bl0sWbIEN2/exI4dO1CjRg2ZXhM/Pz/s2bMHn332GVq2bIlz586he/fucpV/6NAhAMBnn30md53et3btWvTs2RPDhg1Dbm4uwsLCMGDAABw5coSvxz///IMePXrAw8MDCxYsgEgkQkJCAi5dusSXs337dkydOhX9+/fHtGnT8PbtW/z999+4evUqhg4dWmLsn376Cdu2bcNff/2FHTt2AABat25d4rLZ2dlo3749Hj9+jAkTJqBOnTqIiIhAQEAAkpOTi43XCgkJwdu3bzF+/HiIRCKYmpqWexsRFWCEEI2SkZHBALDevXsXey8tLY2lpqbyU3Z2Nv/eyJEjGQA2e/bsYusVXa7QkiVLGMdx7NGjR/y8hg0bMmtra5aens7PO3HiBAPAbG1tZdYHwObNm8e/HjNmDLO2tmbPnz+XWW7w4MHMyMiIr8PZs2cZAObi4sJycnL45dauXcsAsFu3bvHzunfvXixuaWxtbRmAYpOXl1exejVs2JDVqFGDvXjxgp8XHR3NBAIBGzFiBD+vd+/eTEdHh927d4+f9+TJE2ZgYMDatWvHz/P09GTdu3cvtX6TJ09mH/rafX97zps3jwFgo0ePllmuT58+zMzMjH9948YNBoBNnz5dZjk/P79iZZakUaNGzMjIqNRliho5cmSxffL+8ZWbm8vc3NzYJ598ws9bvXo1A8BSU1M/WHavXr1YgwYNSo0fEhLCALAHDx7I1ElfX7/Ysra2tmzkyJH86+DgYKavr8/u3r0rs9zs2bOZlpYWS0xMZIwx9uDBAwaAGRoaspSUlFLrQzQHnXIiRMNkZmYCKLk3wtvbGxYWFvxUeAqjqIkTJxabp6ury///9evXeP78OVq3bg3GGCIjIwEAycnJiIqKwsiRI2FkZMQv37lzZ7i6upZaZ8YY9u3bB19fXzDG8Pz5c37y8fFBRkYGbt68KbPOqFGjZMYjtG3bFsC7Aaofo0WLFjh58iROnjyJI0eOYNGiRfjnn3/Qs2dP/hRbYVv9/PxkfnV7eHigc+fO+PPPPwG8G4B64sQJ9O7dG/b29vxy1tbWGDp0KC5evMjvL2NjY/zzzz+Ij4//qPq/7/PPP5d53bZtW7x48YKPe+zYMQDApEmTZJb74osv5Co/MzMTBgYGH1XHosdXWloaMjIy0LZtW5l9bmxsDAD4/fffZU7vFGVsbIx///0X165d+6j6fMjevXvRtm1bmJiYyByjnTp1QkFBAc6fPy+zfL9+/WBhYaGUupCKRwkNIRqm8I9LVlZWsfe2bt2KkydP4ueffy5xXaFQWOLpocTERP6Pt0QigYWFBdq3bw8AyMjIAAA8evQIAEocNOvs7FxqnVNTU5Geno5t27bJJFwWFhYYNWoUgHcDN4uqU6eOzGsTExMA7/4gfgxzc3N06tQJnTp1Qvfu3fHNN99gx44diIiI4E9JFLa1pHa5uLjg+fPneP36NVJTU5Gdnf3B5aRSKZKSkgAACxYsQHp6OpycnODu7o4ZM2ZUyKX1ZW2nR48eQSAQyJxOAwAHBwe5yjc0NMSrV68+qo5HjhxBy5YtIRaLYWpqCgsLC2zevJk/tgBg0KBB8PLywtixY2FpaYnBgwdjz549MsnNrFmzIJFI0Lx5czg6OmLy5Mkyp6Q+Vnx8PI4dO1bsGO3UqROA4sfo+9uUaDYaQ0OIhjEyMoK1tTVu375d7L3C8RofumRWJBIVu/KpoKAAnTt3xsuXLzFr1izUr18f+vr6ePz4Mfz8/D74a1kRhWUMHz4cI0eOLHEZDw8PmdfvX6lSiCnhThIdO3YEAJw/f17ungtFtWvXDvfu3cPvv/+OEydOYMeOHVi9ejW2bNmCsWPHlrtcZW+n+vXrIzIyEklJSTKDzOV14cIF9OzZE+3atcOmTZtgbW0NbW1thISEyAzm1dXVxfnz53H27Fn88ccfOHbsGH799Vd88sknOHHiBLS0tODi4oK4uDgcOXIEx44dw759+7Bp0ybMnTsXQUFBH91WqVSKzp07Y+bMmSW+7+TkJPO6aM8T0XyU0BCigbp3744dO3bgr7/+QvPmzT+qrFu3buHu3bvYuXMnRowYwc8vvPqmUOH9bEo6ZRIXF1dqDAsLCxgYGKCgoID/tVsRil4F9DHy8/MB/NfrVdjWktp1584dmJubQ19fH2KxGHp6eh9cTiAQyCQBpqamGDVqFEaNGoWsrCy0a9cO8+fP5xOaimpPUba2tpBKpXjw4IFM71rRK8ZK4+vri19++QU///wzAgICFI6/b98+iMViHD9+XOYy6ZCQkGLLCgQCdOzYER07dsSqVauwePFiBAYG4uzZs/xxo6+vj0GDBmHQoEHIzc1F3759sWjRIgQEBHz0pe316tVDVlZWhR6jRHPQKSdCNNDMmTOhp6eH0aNH49mzZ8XeV+TXeeEv/KLrMMawdu1ameWsra3RsGFD7Ny5U+ZUwcmTJ8u8XFVLSwv9+vXDvn37SuxZSk1Nlbu+Renr68vUpbwOHz4MAPD09AQg29b09HR+udu3b+PEiRPo1q0bgHft+vTTT/H777/L9Io9e/YMu3fvRps2bWBoaAgAePHihUxMiUQCBwcH5OTkyLQHgEzMj+Xj4wMA2LRpk8z89evXy7V+//794e7ujkWLFuHy5cvF3n/16hUCAwM/uL6WlhY4jkNBQQE/7+HDhzh48KDMciXdqbnwEQWF2+j9baijowNXV1cwxpCXlydXe0ozcOBAXL58GcePHy/2Xnp6Op/4ksqJemgI0UCOjo7YvXs3hgwZAmdnZ/5OwYwxPHjwALt374ZAIJDrcur69eujXr168Pf3x+PHj2FoaIh9+/aVOFZlyZIl6N69O9q0aYPRo0fj5cuX/H1BShrTU9R3332Hs2fPokWLFhg3bhxcXV3x8uVL3Lx5E6dOnSrXoweaNGmCX3/9FV999RWaNWsGiUQCX1/fUtd5/PgxP8YoNzcX0dHR2Lp1K8zNzWVONy1fvhxdu3ZFq1atMGbMGP6ybSMjI5l7tyxcuJC/f8qkSZMgFAqxdetW5OTkYNmyZfxyrq6u8Pb2RpMmTWBqaorr16/jt99+w5QpU2TaAwBTp06Fj48PtLS0MHjwYIW3y/vbqF+/flizZg1evHjBX7ZdeGffsnqFtLW1sX//fnTq1Ant2rXDwIED4eXlBW1tbfzzzz/YvXs3TExMPngvmu7du2PVqlXo0qULhg4dipSUFGzcuBEODg4yY4gWLFiA8+fPo3v37rC1tUVKSgo2bdqE2rVr8/e/+fTTT2FlZQUvLy9YWloiNjYWGzZsQPfu3T964DIAzJgxA4cOHUKPHj3g5+eHJk2a4PXr17h16xZ+++03PHz4EObm5h8dh6iJui6vIoSULSEhgU2cOJE5ODgwsVjMdHV1Wf369dnnn3/OoqKiZJb90KWrjDEWExPDOnXqxCQSCTM3N2fjxo1j0dHRDAALCQmRWXbfvn3MxcWFiUQi5urqyvbv31/ipboo4ZLgZ8+escmTJzMbGxumra3NrKysWMeOHdm2bdv4ZQov2967d6/MuoWXyhatT1ZWFhs6dCgzNjYu8dLx971/2bZAIGA1atRgQ4YMYQkJCcWWP3XqFPPy8mK6urrM0NCQ+fr6spiYmGLL3bx5k/n4+DCJRML09PRYhw4dWEREhMwyCxcuZM2bN2fGxsb8flq0aBHLzc3ll8nPz2dffPEFs7CwYBzHyVzC/f72LLxs+/3LnEu6bPn169ds8uTJzNTUlEkkEta7d28WFxfHALDvvvuu1G1WKC0tjc2dO5e5u7szPT09JhaLmZubGwsICGDJycn8ciUdC99//z1zdHRkIpGI1a9fn4WEhPD1L3T69GnWq1cvVrNmTaajo8Nq1qzJhgwZInMJ9datW1m7du2YmZkZE4lErF69emzGjBksIyOj1PbLe9k2Y4y9evWKBQQEMAcHB6ajo8PMzc1Z69at2YoVK/h9VXgsLl++XK5tRzQDPcuJEEKqoKioKDRq1Ag///wzf8doQqoyGkNDCCGVXEmPsFizZg0EAgHatWunhhoRono0hoYQQiq5ZcuW4caNG+jQoQOEQiGOHj2Ko0ePYvz48eW6FJuQyohOORFCSCV38uRJBAUFISYmBllZWahTpw4+++wzBAYGFnsgJyFVFSU0hBBCCFErOzs7/g7eRU2aNKnER7yUhFJ3QgghhKjVtWvXZO5ldPv2bXTu3BkDBgyQuwzqoSGEEEKIRpk+fTqOHDmC+Ph4ue+wTT00hFQgqVSKJ0+ewMDAQCm3uSeEVE6MMbx69Qo1a9Ys9ry1yuDt27fIzc1VaB3GWLHvQZFIJPOIjJLk5ubi559/xldffaXQ9yglNIRUoCdPntBVJYSQD0pKSpLrDt+a5O3bt6hrK8HTlIKyFy5CIpEUu8P4vHnzZO7EXZKDBw8iPT0dfn5+CsWjhIaQClR4e/aGfb6FlvbHPUhPobh7rqksFiFVhcCjvspi5Rfk4Pw/ayrkEQ6qlpubi6cpBXhwwxaGBvL1LmW+kqJuk0dISkrin3cGoMzeGQD4/vvv0bVrV9SsWVOhelJCQ0gFKuwe1dIWqzShEXLaKotFSFUh0Cr7j2tFq8ynovUl7yZ5FPx/dK6hoaFMQlOWR48e4dSpU9i/f7/C9aOEhhBCCCFlkoJBCvmuI5J3ufeFhISgRo0a6N69u8LrUkJDCCGEkDJJIYVUgWUVLl8qRUhICEaOHFmuG0JSQkMIIYSQMhUwhgI57/Qi73JFnTp1ComJiRg9erTC6wKU0BBCCCFEDso+5fTpp5/iY26NRwkNIYQQQsokBUOBksfQfAxKaAghhBBSJlUMCv4Yle92hR9gZ2eHNWvWKKVsjuNw8OBBpZRdWWRnZ6Nfv34wNDQEx3FIT09Xd5XkEh4ertH1HfFJJL6fth+nFv6AP+bvxHd+x1HHIl0lsX39nmPn1Rgcvv831h6Jh3PD7Cobl2JWrZjqiOvmloL5887h558O4uifv6BVq3+VGk8TFY6hkXdSNbUmNN7e3pg+fXqx+aGhoTA2NlaorGvXrmH8+PH8a1UmIampqZg4cSLq1KkDkUgEKysr+Pj44NKlSx9dH2UmaorYuXMnLly4gIiICCQnJ8PIyOiDy7558wampqYwNzdHTk6OCmtZXOvWrcusrzo1sn+CfZcaYNz63pi2tQeEWlKsGf8HxDp5So3bvmcaxs97gl2rrDDZxwn3Y8RYtPs+jMyqXlyKWbViqiuuWJyP+w9MsGlTE6XF0HRSBSdVqzI9NBYWFtDT01NL7H79+iEyMhI7d+7E3bt3cejQIXh7e+PFixdqqY8y3Lt3Dy4uLnBzc4OVlVWpN4fat28fGjRogPr166u1ZysvLw86Ojpl1ledvtzRHX9ed8aDZ6ZISDbDwjBvWJtkoX7tVKXG7Tv+OY7tNsWJX02RGC/Gulm1kfOGg8+Ql1UuLsWsWjHVFff69Zr48UcPRFyuvo82Kfj/GBp5J1WrFAmNn58fevfujRUrVsDa2hpmZmaYPHky8vL+y8aL9mTY2dkBAPr06QOO4/jXAPD777+jcePGEIvFsLe3R1BQEPLz8/n34+Pj0a5dO4jFYri6uuLkyZOl1i09PR0XLlzA0qVL0aFDB9ja2qJ58+YICAhAz549S63PvXv30KtXL1haWkIikaBZs2Y4deoUX7a3tzcePXqEL7/8EhzHyfxRvnjxItq2bQtdXV3Y2Nhg6tSpeP36Nf/+pk2b4OjoCLFYDEtLS/Tv37/UdhQmISKRCHZ2dli5cqVMPVauXInz58+D4zh4e3uXWtb333+P4cOHY/jw4fj++++Lvc9xHLZu3YoePXpAT08PLi4uuHz5MhISEuDt7Q19fX20bt0a9+7dk1mvrH3HcRw2b96Mnj17Ql9fH4sWLSrxlNOlS5fg7e0NPT09mJiYwMfHB2lpaQCAY8eOoU2bNjA2NoaZmRl69OhRrB7KJBG/e/hbZrby7jIs1JbC0SMbNy/8dwt2xjhEXjCAaxPlddurIy7FrFox1RmXvLv7ryKTqlWKhAYAzp49i3v37uHs2bPYuXMnQkNDERoaWuKy1669e65NSEgIkpOT+dcXLlzAiBEjMG3aNMTExGDr1q0IDQ3FokWLALy7qU/fvn2ho6ODq1evYsuWLZg1a1ap9ZJIJJBIJDh48OAHT698qD5ZWVno1q0bTp8+jcjISHTp0gW+vr5ITEwEAOzfvx+1a9fGggULkJycjOTkZADvEqEuXbqgX79++Pvvv/Hrr7/i4sWLmDJlCgDg+vXrmDp1KhYsWIC4uDgcO3YM7dq1+2Abbty4gYEDB2Lw4MG4desW5s+fjzlz5vDbd//+/Rg3bhxatWqF5OTkUm9Jfe/ePVy+fBkDBw7EwIEDceHCBTx69KjYcsHBwRgxYgSioqJQv359DB06FBMmTEBAQACuX78OxhjfHqDsfVdo/vz56NOnD27dulXivQyioqLQsWNHuLq64vLly7h48SJ8fX1RUPDuoWuvX7/GV199hevXr+P06dMQCATo06cPpNKSO1BzcnKQmZkpM5UXxzFM7xWB6AdWuP/UtNzllMXQtABaQiA9VfaagLTnQphY5H9grcoZl2JWrZjqjEs0/5RTpbnKycTEBBs2bICWlhbq16+P7t274/Tp0xg3blyxZS0sLAAAxsbGsLKy4ucHBQVh9uzZGDlyJADA3t4ewcHBmDlzJubNm4dTp07hzp07OH78OP9QrMWLF6Nr164frJdQKERoaCjGjRuHLVu2oHHjxmjfvj0GDx4MDw+PUuvj6ekJT09P/nVwcDAOHDiAQ4cOYcqUKTA1NYWWlhYMDAxk1luyZAmGDRvGjz9ydHTEunXr0L59e2zevBmJiYnQ19dHjx49YGBgAFtbWzRq1OiDbVi1ahU6duyIOXPmAACcnJwQExOD5cuXw8/PD6amptDT0+NP35Tmhx9+QNeuXWFiYgIA8PHxQUhISLGnq44aNQoDBw4EAMyaNQutWrXCnDlz4OPjAwCYNm0aRo0axS9f1r4rNHToUJn17t+/LxN32bJlaNq0KTZt2sTPa9CgAf//fv36FWuPhYUFYmJi4ObmVqy9S5YsQVBQUKnbRF7+fS7C3uolJmzsVSHlEUJIRZKCQwHkO30vlXO5ilRpemgaNGgALS0t/rW1tTVSUlIUKiM6OhoLFizge1UkEgnGjRuH5ORkZGdnIzY2FjY2NjJP+GzVqlWZ5fbr1w9PnjzBoUOH0KVLF4SHh6Nx48Yf7EEqlJWVBX9/f7i4uMDY2BgSiQSxsbF8D01p7QgNDZVph4+PD6RSKR48eIDOnTvD1tYW9vb2+Oyzz7Br1y5kZ3+4KzY2NhZeXl4y87y8vBAfH8/3XMijoKAAO3fuxPDhw/l5w4cPR2hoaLEejsJkDwAsLS0BAO7u7jLz3r59y/d4lLXvCjVt2rTUOhb20HxIfHw8hgwZAnt7exgaGvKnBz+0TwICApCRkcFPSUlJpcb/kK/7XISX6yNM3uKL1Aw5n/5WTpkvtVCQDxi/92vWxDwfaanK+42jjrgUs2rFVGdcAkiZYpOqqTWhMTQ0REZGRrH56enpxa5K0daWfZowx3EfPA3wIVlZWQgKCkJUVBQ/3bp1C/Hx8RCLP27MglgsRufOnTFnzhxERETAz89PpuegJP7+/jhw4AAWL16MCxcuICoqCu7u7sjNzS2zHRMmTJBpR3R0NOLj41GvXj0YGBjg5s2b+OWXX2BtbY25c+fC09NT6ZcuHz9+HI8fP8agQYMgFAohFAoxePBgPHr0CKdPn5ZZtuj+LBwbVNK8wn0s777T19cvtY66urqlvu/r64uXL19i+/btuHr1Kq5evQoAH9wnIpGIf5qsok+VfYfh6z4X0d7tAaZs8UXyS0XXV1x+ngDxf+uhUZtX/DyOY2jYJgsxN5Q3sF4dcSlm1YqpzrgEKPh/D428k6qpNZ11dnbGiRMnis2/efMmnJycPqpsbW3tYr0LjRs3RlxcHBwcHEpcx8XFBUlJSUhOToa1tTUA4MqVK+WK7+rqKnOFT0n1uXTpEvz8/NCnTx8A7/5oP3z4UGYZHR2dEtsRExPzwXYA706FderUCZ06dcK8efNgbGyMM2fOoG/fvsWWdXFxkbnEvLBuTk5OMr1iZfn+++8xePBgBAYGysxftGgRvv/+e3Tu3Fnust5X1r6Tl4eHB06fPl3iaaIXL14gLi4O27dvR9u2bQG8G3ytTP59L+LTRgmYFeKD7BxtmBq86216/UYHOfnK+3ju32YO/zVJuButh7hIPfQZlwqxnhQnwpQ3dkddcSlm1YqprrhicR5q1sziX1taZsHePg2vXukgNbX0H1JVhSKJSrVLaCZOnIgNGzZg6tSpGDt2LEQiEf744w/88ssvOHz48EeVbWdnh9OnT8PLywsikQgmJiaYO3cuevTogTp16qB///4QCASIjo7G7du3sXDhQnTq1AlOTk4YOXIkli9fjszMzGJ/nN/34sULDBgwAKNHj4aHhwcMDAxw/fp1LFu2DL16/TcWoqT6ODo6Yv/+/fD19QXHcZgzZ06xXic7OzucP38egwcPhkgkgrm5OWbNmoWWLVtiypQpGDt2LPT19RETE4OTJ09iw4YNOHLkCO7fv4927drBxMQEf/75J6RSKZydnUtsw9dff41mzZohODgYgwYNwuXLl7FhwwaZcSZlSU1NxeHDh3Ho0KFiY01GjBiBPn364OXLlzA1Ld8XTln7Tl4BAQFwd3fHpEmT8Pnnn0NHRwdnz57FgAEDYGpqCjMzM2zbtg3W1tZITEzE7Nmzy1VfefVrHQMA2DRJ9ngPDvPGn9dL3l8V4dwhExiZFWDEjKcwscjH/X90ETisLtKfa5e9ciWLSzGrVkx1xXV0fIllS8/wryeMjwQAnDxZF6tWt1RaXE0iZRykTM4xNHIuV5HUmtDY29vj/PnzCAwMRKdOnZCbm4v69etj79696NKly0eVvXLlSnz11VfYvn07atWqhYcPH8LHxwdHjhzBggULsHTpUmhra6N+/foYO3YsAEAgEODAgQMYM2YMmjdvDjs7O6xbt67UukgkErRo0QKrV6/GvXv3kJeXBxsbG4wbNw7ffPNNqfVZtWoVRo8ejdatW/OJyvtXySxYsAATJkxAvXr1kJOTA8YYPDw8cO7cOQQGBqJt27ZgjKFevXoYNGgQgHeDj/fv34/58+fj7du3cHR0xC+//CIz+LWoxo0bY8+ePZg7dy6Cg4NhbW2NBQsWwM/PT+7t/eOPP0JfX7/E8SkdO3aErq4ufv75Z0ydOlXuMosqa9/Jy8nJCSdOnMA333yD5s2bQ1dXFy1atMCQIUMgEAgQFhaGqVOnws3NDc7Ozli3bl2Zl6l/jFb+E5RWdlkOhZjjUIh5tYhLMatWTHXEvXXLEl27DVFZPE2k6T00HPuYR1sSQmRkZmbCyMgITQYuhJa28u4l8z7D3eU7NUpIdSZo6KqyWPkFOTjz91JkZGSUY6ydehV+r525bQOJgXxDb7NeSfGJW5JK20tDwgkhhBBSJqbAKSdW3U45EUIIIaRy0PRTTpTQEEIIIaRMBUyAAibfKSd1PPqAEhpCCCGElEkKDlI5b18nVcPDKSmhIYQQQkiZ6JQTIYQQQio9xU45UQ8NIYQQQjTQu1NOmvtwSkpoCFECgz3XIOSUe7fUorTDrVUWq6iC6SYqjymNilF5TKJcmUPVc6ddVd6/ScryVBZLWaQQoIDG0BBCCCGkMqNTToQQQgip9KQQ0FVOhBBCCKncChiHAjnvACzvchWJEhpCCCGElKlAgTE0BWrooZGvZoQQQgip1qRMoNCkiMePH2P48OEwMzODrq4u3N3dcf36dYXKoB4aQgghhKhNWloavLy80KFDBxw9ehQWFhaIj4+HiYliV1FSQkMIIYSQMinrlNPSpUthY2ODkJAQfl7dunUVrh+dciKEEEJImaT4b2BwWZP0/+tkZmbKTDk5OcXKPXToEJo2bYoBAwagRo0aaNSoEbZv365w/SihIYQQQkiZCi/blncCABsbGxgZGfHTkiVLipV7//59bN68GY6Ojjh+/DgmTpyIqVOnYufOnQrVj045EaIBfP2eo//EFJha5ON+jC42fVsLcVF6SolVEPIK0p1ZsjNttKD9Uw2lxCvk5paC/v1i4eCQBjOzN1gQ3BaXL9dWasxCqty+FFO5MUd8Eon27g9ga5GOnHwt3HpohU1/tEBiqrHSYhZSx/bVJIrdWO/dcklJSTA0NOTni0SiYstKpVI0bdoUixcvBgA0atQIt2/fxpYtWzBy5Ei560c9NJWcnZ0d1qxZo5SyOY7DwYMHP6oMb29vTJ8+vULqU5rw8HBwHIf09HSlx6po7XumYfy8J9i1ygqTfZxwP0aMRbvvw8hMibdKtxNCuK/Gf9N6c+XF+j+xOB/3H5hg06YmSo9VlDq2L8VUXsxG9k+w71IDjFvfG9O29oBQS4o14/+AWEe5jxZQy+dUwxQ+y0neCQAMDQ1lppISGmtra7i6usrMc3FxQWJiokL1o4RGDT70Rz40NBTGxsYKlXXt2jWMHz+ef10RSYi8/Pz80Lt3b5l5v/32G8RiMVauXAkA2L9/P4KDg1VSn8qq7/jnOLbbFCd+NUVivBjrZtVGzhsOPkNeKi+oFsCZaf03GSv/q+D69Zr48UcPRFy2UXqsotSxfSmm8mJ+uaM7/rzujAfPTJGQbIaFYd6wNslC/dqpSosJqOlzqmEKe2jkneTl5eWFuLg4mXl3796Fra2tQvWjhKaSs7CwgJ6eZnR57tixA8OGDcPmzZvx9ddfAwBMTU1hYGCg5pppLqG2FI4e2bh54b9txBiHyAsGcG2SrbzAjwuQ1+8Z8oakIH9hGtizAuXFUiN1bF+KqeRj9z0ScS4AIDNbrLQYmtJWdSu8ykneSV5ffvklrly5gsWLFyMhIQG7d+/Gtm3bMHnyZIXqRwmNBivsAVmxYgWsra1hZmaGyZMnIy/vvy7Ooqec7OzsAAB9+vQBx3H8awD4/fff0bhxY4jFYtjb2yMoKAj5+fn8+/Hx8WjXrh3EYjFcXV1x8uRJheq6bNkyfPHFFwgLC8OoUaP4+e/3RtnZ2WHx4sUYPXo0DAwMUKdOHWzbtk2mrIiICDRs2BBisRhNmzbFwYMHwXEcoqKi+GX+/PNPODk5QVdXFx06dMDDhw+L1Wnfvn1o0KABRCIR7Ozs+F6jonVZuHAhRowYAYlEAltbWxw6dAipqano1asXJBIJPDw8Sr25U05OTrFR/IowNC2AlhBIT5Udzpb2XAgTi/wPrPVxOFdtaM02gnCZKbS+NAKSC5A/9QVYtrTslSsZdWxfiqm8mO/jOIbpvSIQ/cAK95+aKi2OJrRVE0gZp9Akr2bNmuHAgQP45Zdf4ObmhuDgYKxZswbDhg1TqH6U0Gi4s2fP4t69ezh79ix27tyJ0NBQhIaGlrjstWvXAAAhISFITk7mX1+4cAEjRozAtGnTEBMTg61btyI0NBSLFi0C8G5AVt++faGjo4OrV69iy5YtmDVrltx1nDVrFoKDg3HkyBH06dOnzOVXrlyJpk2bIjIyEpMmTcLEiRP57sbMzEz4+vrC3d0dN2/eRHBwcLG6JCUloW/fvvD19UVUVBTGjh2L2bNnyyxz48YNDBw4EIMHD8atW7cwf/58zJkzp9i2W716Nby8vBAZGYnu3bvjs88+w4gRIzB8+HDcvHkT9erVw4gRI8A+8OTYJUuWyIzgt7FR7emU8hC0EEPgrQuunjYEzUXQ+s4UyJKCnX2r7qoRohD/Phdhb/USc37uqO6qVAtSBXpn5H2IZaEePXrg1q1bePv2LWJjYzFu3DiF60cJjYYzMTHBhg0bUL9+ffTo0QPdu3fH6dOnS1zWwsICAGBsbAwrKyv+dVBQEGbPno2RI0fC3t4enTt3RnBwMLZu3QoAOHXqFO7cuYMff/wRnp6eaNeuHT/avCxHjx7FsmXL8Pvvv6NjR/m+VLp164ZJkybBwcEBs2bNgrm5Oc6ePQsA2L17NziOw/bt2+Hq6oquXbtixowZMutv3rwZ9erVw8qVK+Hs7Ixhw4bBz89PZplVq1ahY8eOmDNnDpycnODn54cpU6Zg+fLlxeoyYcIEODo6Yu7cucjMzESzZs0wYMAAODk5YdasWYiNjcWzZ89KbEtAQAAyMjL4KSkpSa5tUCjzpRYK8gHj937lmZjnIy1VNRchcgYCcLWFYI+r3i9NdWxfiqmaY/frPhfh5foIk7f4IjVDotRY6m6rplDmow8qAiU0Gq5BgwbQ0tLiX1tbWyMlJUWhMqKjo7FgwQJIJBJ+GjduHJKTk5GdnY3Y2FjY2NigZs2a/DqtWrWSq2wPDw/Y2dlh3rx5yMrKKnuF/69TiOM4WFlZ8W2Ki4uDh4cHxOL/zoc3b95cZv3Y2Fi0aNFCZt779Y2NjYWXl5fMPC8vL8THx6Og4L/xIkXrYmlpCQBwd3cvNu9D21wkEhUbxa+I/DwB4v/WQ6M2r/h5HMfQsE0WYm6oZmwUy5aCPckHzLTKXriSUcf2pZjKPnYZvu5zEe3dHmDKFl8kv1TsM1cemvA51QQF4BSaVK36pJYaxNDQEBkZGcXmp6enw8jISGaetra2zGuO4yCVKjbWISsrC0FBQejbt2+x94omDuVRq1Yt/Pbbb+jQoQO6dOmCo0ePljkIuCLaVFGK1oXjuA/OU2b99m8zh/+aJNyN1kNcpB76jEuFWE+KE2HKGRNQsCkTXGsROEstsBdSSENeAQIOgo7KG1QJAGJxHmrW/C/ptbTMgr19Gl690kFqqr7S4qp6+1JM5cb073sRnzZKwKwQH2TnaMPU4N2g3NdvdJCTr7w/aepoq6ZRpOdFHT00lNCogbOzM06cOFFs/s2bN+Hk5PRRZWtra8v0QABA48aNERcXBwcHhxLXcXFxQVJSEpKTk2FtbQ0AuHLlitwxbW1tce7cOT6pOXbsWLmvbHJ2dsbPP/+MnJwc/n4FhWOBitb30KFDMvPer6+LiwsuXbokM+/SpUtwcnKS6fHSBOcOmcDIrAAjZjyFiUU+7v+ji8BhdZH+XLvslcuBpRZAGpwOZEoBIwE4dx0IN5mBM1budnF0fIllS8/wryeMjwQAnDxZF6tWt1RaXFVvX4qp3Jj9WscAADZNOiwzPzjMG39ed1ZaXHW0VdMUAHL3vKjjuklKaNRg4sSJ2LBhA6ZOnYqxY8dCJBLhjz/+wC+//ILDhw+XXUAp7OzscPr0aXh5eUEkEsHExARz585Fjx49UKdOHfTv3x8CgQDR0dG4ffs2Fi5ciE6dOsHJyQkjR47E8uXLkZmZicDAQIXi2tjYIDw8HB06dICPjw+OHTum8OkXABg6dCgCAwMxfvx4zJ49G4mJiVixYgWA/3pLPv/8c6xcuRIzZszA2LFjcePGjWKDfb/++ms0a9YMwcHBGDRoEC5fvowNGzZg06ZNCtdJFQ6FmONQiPJvbgcAwnmKPcG2oty6ZYmu3YaoJbYqty/FVK5W/hNUFut96ti+mkTTe2hoDI0a2Nvb4/z587hz5w46deqEFi1aYM+ePdi7dy+6dOnyUWWvXLkSJ0+ehI2NDRo1agQA8PHxwZEjR3DixAk0a9YMLVu2xOrVq/mbFgkEAhw4cABv3rxB8+bNMXbsWP4KKEXUrl0b4eHheP78OXx8fBS+hBl4dzru8OHDiIqKQsOGDREYGIi5c+cC+O/0WJ06dbBv3z4cPHgQnp6e2LJlS7FBzI0bN8aePXsQFhYGNzc3zJ07FwsWLCg2eJgQQoh8lHVjvYrCsQ9dj0qIhti1axdGjRqFjIwM6Orqqrs6pcrMzISRkRG80QtCTnVd0drh1iqLVVTBdNX39kijYlQekyhX5lDlnXIsjeFu+U+tf6x8lodw/I6MjIxy9V6rU+H32uzLXSGSyPe9lpOVh+9aHVVpe+mUE9E4P/74I+zt7VGrVi1ER0dj1qxZGDhwoMYnM4QQUpWV5+GUqkQJDdE4T58+xdy5c/H06VNYW1tjwIAB5ToFRgghpOIocgdgRe4UXFEooSEaZ+bMmZg5c6a6q0EIIaQIRZ7RpMiznCoKJTSEEEIIKRP10BBCCCGk0pMq8IwmRZ/lVBEooSGEEEJImQoYhwI5e17kXa4iUUJDCCGEkDLRKSdCiNK92GarlrjPpuepPKajn8pDEiVT5f1gilLl/W8K8t4Ce35XWTxlYArcKZjRZduEEEII0USKPEWbnrZNCCGEEI0kZfKfSpKq4RkElNAQQgghpEya/nBKSmgIIYQQUiYpOEjlPJUk73IViRIaQgghhJSJLtsmhBBCSKVHp5wIIYQQUulJocB9aOiUEyGEEEI0EVNgDA2jhIaQ6snX7zn6T0yBqUU+7sfoYtO3tRAXpaeUWCM+iUR79wewtUhHTr4Wbj20wqY/WiAx1Vgp8UpicuQpzH97jLTONfB8mI3S46ly+1JM5cdUdVxN+MxoAk2/U7DqT3IRoiYcx+HgwYMAgIcPH4LjOERFRam1TgDQvmcaxs97gl2rrDDZxwn3Y8RYtPs+jMyUcxfeRvZPsO9SA4xb3xvTtvaAUEuKNeP/gFhHNXf9Fd1/DaPwVOTY6Koknqq3L8VUbkx1xFX3Z0ZTFI6hkXdSNUpoSKXg5+eH3r17V1h5NjY2SE5OhpubW4WVWV59xz/Hsd2mOPGrKRLjxVg3qzZy3nDwGfJSKfG+3NEdf153xoNnpkhINsPCMG9Ym2Shfu1UpcQrintbAKutD/BslC0K9LSUHg9Q/falmMqNqY646vzMaJLCHhp5J1WjhIZUS1paWrCysoJQqN6zrkJtKRw9snHzggE/jzEOkRcM4NokWyV1kIhzAQCZ2WKlx6rxUyJeexrhTQNDpccC1LN9KaZyj93q9pnRJIX3oZF3UjVKaEil4+3tjalTp2LmzJkwNTWFlZUV5s+fL7NMfHw82rVrB7FYDFdXV5w8eVLm/fdPORUUFGDMmDGoW7cudHV14ezsjLVr1yq9LYamBdASAumpsolV2nMhTCzylR6f4xim94pA9AMr3H9qqtRYkisvIXqUjRf9ayk1TlHq2L4UU7nHbnX6zFQn8+fPB8dxMlP9+vUVKoMGBZNKaefOnfjqq69w9epVXL58GX5+fvDy8kLnzp0hlUrRt29fWFpa4urVq8jIyMD06dNLLU8qlaJ27drYu3cvzMzMEBERgfHjx8Pa2hoDBw784Ho5OTnIycnhX2dmZlZUE1XCv89F2Fu9xISNvZQaR/giFxa7k/B4hiOYDv2OIpWXqj4zmkjZg4IbNGiAU6dO8a8V7UGnhIZUSh4eHpg3bx4AwNHRERs2bMDp06fRuXNnnDp1Cnfu3MHx48dRs2ZNAMDixYvRtWvXD5anra2NoKAg/nXdunVx+fJl7Nmzp9SEZsmSJTLrKSrzpRYK8gHj935ZmpjnIy1VuR/Pr/tchJfrI0zc1BOpGRKlxhI9zIYwMx915sXy8zgpoHs3C8anU5CwozEgqPguanVsX4qp3GO3unxmNJGyExqhUAgrKyuF1ytEP5VIpeTh4SHz2traGikpKQCA2NhY2NjY8MkMALRq1arMMjdu3IgmTZrAwsICEokE27ZtQ2JiYqnrBAQEICMjg5+SkpIUakd+ngDxf+uhUZtX/DyOY2jYJgsxN5R16SvD130uor3bA0zZ4ovkl8ofz5LtaoBHC12RuOC/6W1dPbxqaYrEBa5KSWYA9WxfiqnMY7f6fGY0UXkGBWdmZspMRXu03xcfH4+aNWvC3t4ew4YNK/P7933UQ0MqJW1tbZnXHMdBKpWWu7ywsDD4+/tj5cqVaNWqFQwMDLB8+XJcvXq11PVEIhFEIlG54wLA/m3m8F+ThLvReoiL1EOfcakQ60lxIkw55+f9+17Ep40SMCvEB9k52jA1eDeQ8vUbHeTkK+crgelqIbe27GXaUh0BCiTCYvMrmqq3L8VUbkx1xFXHZ0YTlaeHxsZG9j5T8+bNKzbmEQBatGiB0NBQODs7Izk5GUFBQWjbti1u374NAwODYsuXpPrsCVJtuLi4ICkpCcnJybC2tgYAXLlypdR1Ll26hNatW2PSpEn8vHv37im1noXOHTKBkVkBRsx4ChOLfNz/RxeBw+oi/bl22SuXQ7/WMQCATZMOy8wPDvPGn9edlRJTnVS9fSmmcmOqI251+8x8CIP8jzRg//83KSkJhob/9Wh96Adg0SEBHh4eaNGiBWxtbbFnzx6MGTNGrpiU0JAqp1OnTnBycsLIkSOxfPlyZGZmIjAwsNR1HB0d8eOPP+L48eOoW7cufvrpJ1y7dg1169ZVSZ0PhZjjUIi5SmK18p+gkjhleRyguj8Eqty+FLPqxdWUz4y6laeHxtDQUCahkZexsTGcnJyQkJAg9zo0hoZUOQKBAAcOHMCbN2/QvHlzjB07FosWLSp1nQkTJqBv374YNGgQWrRogRcvXsj01hBCSHWnyhvrZWVl4d69e3wvuzw4xhgrezFCiDwyMzNhZGQEb/SCkFNut7tM3KEtVRarqGefqv7W745+N1Qek1RNqvzcFOS9xY093yIjI6NcPRbqVPi91u7wJAj15RszmP86B+d9N8ndXn9/f/j6+sLW1hZPnjzBvHnzEBUVhZiYGFhYWMgVk045EUIIIaRMyrxs+99//8WQIUPw4sULWFhYoE2bNrhy5YrcyQxACQ0hhBBC5MAYByZnoiLvcoXCwsLKUyUZlNAQQgghpEyKPKNJHc9yooSGEEIIIWVS9p2CPxYlNIQQQggpkzJPOVUESmgIIYQQUibqoSGEEEJIpUc9NIQQpTPcXfqjHZQXV/Ux40ObqDwm3fumalLl5yafqf6eTRWNKdBDQwkNIYQQQjQSAyDvrXjVccdeSmgIIYQQUiYpOHB02TYhhBBCKjMaQ0MIIYSQSk/KOHB0lRMhhBBCKjPGFBhDo4ZBNJTQEEIIIaRMdMqJEEIIIZUeJTSEEEIIqfRoDA0hhBBCKj1NH0MjUH1IQsj7fP2eY+fVGBy+/zfWHomHc8PsKhlTnXEBwOTIUzj63YD5riSlx6ou+7Q6HUfqPHY1wbuEhpNzUn39KKEhGsnPzw+9e/dWdzVUon3PNIyf9wS7Vllhso8T7seIsWj3fRiZKe9W6eqIqc64ACC6/xpG4anIsdFVeqzqsk+r03GkzmNXU8ifzMg/1qYiUUJDiJr1Hf8cx3ab4sSvpkiMF2PdrNrIecPBZ8jLKhVTnXG5twWw2voAz0bZokBPS6mxgOqzT6vTcaSutmoSpuCkanIlNIcOHZJ7IqSiHTt2DG3atIGxsTHMzMzQo0cP3Lt3j3//4cOH4DgOYWFhaN26NcRiMdzc3HDu3Dl+mYKCAowZMwZ169aFrq4unJ2dsXbtWpk4hb1CK1asgLW1NczMzDB58mTk5SnvF5hQWwpHj2zcvGDAz2OMQ+QFA7g2UU53tjpiqjMuANT4KRGvPY3wpoGhUuMA1WefVqfjSJ3HribR9B4auQYFy9v1z3EcCgoKPqY+hBTz+vVrfPXVV/Dw8EBWVhbmzp2LPn36ICoqCgLBfzn5jBkzsGbNGri6umLVqlXw9fXFgwcPYGZmBqlUitq1a2Pv3r0wMzNDREQExo8fD2trawwcOJAv4+zZs7C2tsbZs2eRkJCAQYMGoWHDhhg3blyJdcvJyUFOTg7/OjMzU6G2GZoWQEsIpKfKfhTTngth45DzgbU+jjpiqjOu5MpLiB5lI2mui9JiFFVd9ml1Oo7U1VaNo0jXi6beWE8qlSq7HoR8UL9+/WRe//DDD7CwsEBMTAzc3Nz4+VOmTOGX3bx5M44dO4bvv/8eM2fOhLa2NoKCgvhl69ati8uXL2PPnj0yCY2JiQk2bNgALS0t1K9fH927d8fp06c/mNAsWbJEplyiWYQvcmGxOwmPZziC6dAZdkI+iiI9L5VtDM3bt28rqh6EfFB8fDyGDBkCe3t7GBoaws7ODgCQmJgos1yrVq34/wuFQjRt2hSxsbH8vI0bN6JJkyawsLCARCLBtm3bipXRoEEDaGn9N8bC2toaKSkpH6xbQEAAMjIy+CkpSbGrZzJfaqEgHzC2yJeZb2Kej7RU5dxVQR0x1RVX9DAbwsx81JkXC4fRN+Aw+gb04rJgfCoFDqNvANKK/xlZXfZpdTqO1NVWTVN42ba8k6opnNAUFBQgODgYtWrVgkQiwf379wEAc+bMwffff1/hFSTE19cXL1++xPbt23H16lVcvXoVAJCbmyt3GWFhYfD398eYMWNw4sQJREVFYdSoUcXK0NbWlnnNcVypPZQikQiGhoYykyLy8wSI/1sPjdq8KhKToWGbLMTc0FOoLE2Oqa642a4GeLTQFYkL/pve1tXDq5amSFzgCggq/ldkddmn1ek4UldbNY2mj6FROKFZtGgRQkNDsWzZMujo6PDz3dzcsGPHjgqtHCEvXrxAXFwcvv32W3Ts2BEuLi5IS0srcdkrV67w/8/Pz8eNGzfg4vJu3MSlS5fQunVrTJo0CY0aNYKDg4PMwGJ12r/NHF2HvkSnAS9h4/AWX3z3L8R6UpwIM61SMdURl+lqIbe2rswk1RGgQCJEbm3lXb5dXfZpdTmO1BVT4zBOsUnFFO4r+/HHH7Ft2zZ07NgRn3/+OT/f09MTd+7cqdDKEWJiYgIzMzNs27YN1tbWSExMxOzZs0tcduPGjXB0dISLiwtWr16NtLQ0jB49GgDg6OiIH3/8EcePH0fdunXx008/4dq1a6hbt64qm1Oic4dMYGRWgBEznsLEIh/3/9FF4LC6SH+uXfbKlSimOuOqWnXZp9XpOKoux25pNP1OwQonNI8fP4aDg0Ox+VKpVKmXt5LqRSqVQigUQiAQICwsDFOnToWbmxucnZ2xbt06eHt7F1vnu+++w3fffYeoqCg4ODjg0KFDMDc3BwBMmDABkZGRGDRoEDiOw5AhQzBp0iQcPXpUxS0r2aEQcxwKMa/yMdUZt9DjAGeVxKku+7Q6HUfqPnZJ6RROaFxdXXHhwgXY2trKzP/tt9/QqFGjCqsYqd5SUlL4xLlTp06IiYmReZ+VkP67uLjw42veJxKJEBISgpCQEJn5S5Ys4f8fGhpabL01a9YoWHNCCKmiVHTZ9nfffYeAgABMmzZNoe9ghROauXPnYuTIkXj8+DGkUin279+PuLg4/Pjjjzhy5IiixREiIy0tDZcuXUJ4eLjMKU1CCCHqpchg3/IOCr527Rq2bt0KDw8PhddVeFBwr169cPjwYZw6dQr6+vqYO3cuYmNjcfjwYXTu3FnhChBS1OjRo/H555/j66+/Rq9evdRdHUIIIUUp8bkHWVlZGDZsGLZv3w4TExOF1y/XBfRt27bFyZMny7MqIaU6cOCAwuvY2dmVeAqKEEJIxSlPD837d08XiUQQiUQlrjN58mR0794dnTp1wsKFCxWuX7nvCHT9+nX+pmWurq5o0qRJeYsihBBCiKYrxxgaGxsbmdnz5s3D/Pnziy0eFhaGmzdv4tq1a+WunsIJzb///oshQ4bg0qVLMDY2BgCkp6ejdevWCAsLQ+3atctdGUIIIYRoKu7/k7zLAklJSTI3HC2pdyYpKQnTpk3DyZMnIRaLy107hcfQjB07Fnl5eYiNjcXLly/x8uVLxMbGQiqVYuzYseWuCCGEEEI0mLzjZ4r05Lx/J/WSEpobN24gJSUFjRs3hlAohFAoxLlz57Bu3ToIhUK5H3qtcA/NuXPnEBERAWfn/+7l4OzsjPXr16Nt27aKFkcIIYSQykBJl2137NgRt27dkpk3atQo1K9fH7NmzZJ5vl5pFE5obGxsSryBXkFBAWrWrKlocYQQohDnNW9UHvPokyiVxwQAn5oN1RKXkBIp8kgDBS7bNjAwgJubm8w8fX19mJmZFZtfGoVPOS1fvhxffPEFrl+/zs+7fv06pk2bhhUrVihaHCGEEEIqAU1/2rZcPTQmJibguP+yrdevX6NFixYQCt+tnp+fD6FQiNGjR6N3795KqSghhBBC1EhFdwoGgPDwcIXXkSuhodu/E0IIIdWckk45VRS5EpqRI0cqux6EEEII0WAcezfJu6yqlfvGegDw9u1b5Obmyswrer05IYQQQqoIFZ5yKg+FBwW/fv0aU6ZMQY0aNaCvrw8TExOZiRBCCCFVUOEpJ3knFVM4oZk5cybOnDmDzZs3QyQSYceOHQgKCkLNmjXx448/KqOOhBBCCFG3ctxYT5UUPuV0+PBh/Pjjj/D29saoUaPQtm1bODg4wNbWFrt27cKwYcOUUU9CCCGEqFNVO+X08uVL2NvbA3g3Xubly5cAgDZt2uD8+fMVWztCCCGEaIaq1kNjb2+PBw8eoE6dOqhfvz727NmD5s2b4/Dhw/zDKgkhivH1e47+E1NgapGP+zG62PRtLcRF6VW5mKqO6+aWgv79YuHgkAYzszdYENwWly8r9wG6I5q74tm/OsXm+45MxZQlj5Uam46jqtlWjaHhl20r3EMzatQoREdHAwBmz56NjRs3QiwW48svv8SMGTMqvIJE+fz8/Eq8IWJ4eDg4jkN6errK6/Q+b29vTJ8+XWbe2rVrIRKJEBYWpp5KVZD2PdMwft4T7Fplhck+TrgfI8ai3fdhZFb8ESOVOaY64orF+bj/wASbNjVRSvklWXc0Dr9E3eanJWEJAIC2vhlKjUvHUdVsqyYpvGxb3knVFE5ovvzyS0ydOhUA0KlTJ9y5cwe7d+9GZGQkpk2bVuEVJKQk8+bNwzfffIPff/8dgwcPVnd1Pkrf8c9xbLcpTvxqisR4MdbNqo2cNxx8hrysUjHVEff69Zr48UcPRFy2UUr5JTE2K4BpjXx+unrKCNZ2OfBolaXUuHQcVc22ahQNP+WkcELzPltbW/Tt2xceHh4VUR+i4fbt24cGDRpAJBLBzs4OK1eulHnfzs4OixcvxujRo2FgYIA6depg27ZtMstERESgYcOGEIvFaNq0KQ4ePAiO4xAVFVVmfMYYvvjiC6xbtw4nT55Ely5dAABSqRQLFixA7dq1IRKJ0LBhQxw7doxf7+HDh+A4Dvv370eHDh2gp6cHT09PXL58Wab87du3w8bGBnp6eujTpw9WrVql1FOpQm0pHD2ycfOCQZE2coi8YADXJtlVJqY646pTXi6HM/tM4DP4BTgl9sDTcVQ120oUI9cYmnXr1sldYGHvDal6bty4gYEDB2L+/PkYNGgQIiIiMGnSJJiZmcHPz49fbuXKlQgODsY333yD3377DRMnTkT79u3h7OyMzMxM+Pr6olu3bti9ezcePXpU7FTSh+Tn52P48OE4c+YMzp07J5NEr127FitXrsTWrVvRqFEj/PDDD+jZsyf++ecfODo68ssFBgZixYoVcHR0RGBgIIYMGYKEhAQIhUJcunQJn3/+OZYuXYqePXvi1KlTmDNnTql1ysnJQU5ODv86MzNTvo35f4amBdASAumpsh/FtOdC2DjkfGCtj6OOmOqMq04Rx4yQlamFTwcq91c8HUdVs62ahoMCdwpWak1KJldCs3r1arkK4ziOEppK6siRI5BIJDLzCgoKZF6vWrUKHTt25P/IOzk5ISYmBsuXL5dJaLp164ZJkyYBAGbNmoXVq1fj7NmzcHZ2xu7du8FxHLZv3w6xWAxXV1c8fvwY48aNK7OO27dvBwBER0ejfv36Mu+tWLECs2bN4k8/LV26FGfPnsWaNWuwceNGfjl/f390794dABAUFIQGDRogISEB9evXx/r169G1a1f4+/vz7YuIiMCRI0c+WKclS5YgKCiozLqT6un4L6Zo1iETZlb56q4KIR+vKgwKfvDggVzT/fv3lV1foiQdOnRAVFSUzLRjxw6ZZWJjY+Hl5SUzz8vLC/Hx8TLJT9GeE47jYGVlhZSUFABAXFwcPDw8IBaL+WWaN28uVx3btGkDiUSCOXPmID//vz8QmZmZePLkSYl1i42NlZlXtG7W1tYAIFO39+tSVt0CAgKQkZHBT0lJSXK1ha/7Sy0U5APGFrJ/8EzM85GW+lFPJtGomOqMqy7P/tVG5AUDdBn6Qumx6Diqmm3VOFV9DA2pGvT19eHg4CAz1apVq1xlaWtry7zmOA5SqfSj6+ju7o7Tp0/j7NmzGDRokExSU566cf8f1PAxdROJRDA0NJSZFJGfJ0D833po1OZVkXoxNGyThZgbyrkcVB0x1RlXXU6EmcHYPB8tOil2GrI86Diqmm3VOJTQkKrCxcUFly5dkpl36dIlODk5QUtLS64ynJ2dcevWLZlxJ9euXZO7Dg0bNsTp06dx/vx5DBw4EHl5eTA0NETNmjVLrJurq6vcZTs7OxeriyJ1K6/928zRdehLdBrwEjYOb/HFd/9CrCfFiTDTKhVTHXHF4jzY26fB3j4NAGBpmQV7+zRYWLxWSrxCUilw4ldTdBrwEloq+gFPx1HVbKsm0fTLtqtRXxn5WF9//TWaNWuG4OBgDBo0CJcvX8aGDRuwadMmucsYOnQoAgMDMX78eMyePRuJiYlYsWIFgP96TMri6emJM2fOoGPHjhg4cCD27NmDGTNmYN68eahXrx4aNmyIkJAQREVFYdeuXXLX7YsvvkC7du2watUq+Pr64syZMzh69Kjc9Sqvc4dMYGRWgBEznsLEIh/3/9FF4LC6SH+uXfbKlSimOuI6Or7EsqVn+NcTxkcCAE6erItVq1sqJSYARJ43QMpjHfgMVt0lvXQcVc22ahQNf/QBJTREbo0bN8aePXswd+5cBAcHw9raGgsWLJAZEFwWQ0NDHD58GBMnTkTDhg3h7u6OuXPnYujQoTLjasri7u7OJzUDBgzAnj17kJGRga+//hopKSlwdXXFoUOHZK5wKouXlxe2bNmCoKAgfPvtt/Dx8cGXX36JDRs2yF1GeR0KMcehEHOlx1F3TFXHvXXLEl27DVFJrKKaeL/C8SdRKo9Lx1HVi6lRNDyh4RhjaghLyH927dqFUaNGISMjA7q6uuqujoxx48bhzp07uHDhglzLZ2ZmwsjICN7oBSFXjX65qZCgofynESvK0T93qzwmAPjUbKiWuKTi5bM8hON3ZGRkKDzWTt0Kv9fqLlgEgZw/PKVv3+LB3ECVtrdcY2guXLiA4cOHo1WrVnj8+N2zSX766SdcvHixQitHqqYff/wRFy9exIMHD3Dw4EHMmjULAwcO1IhkZsWKFYiOjkZCQgLWr1+PnTt3YuTIkequFiGEqF/hZdvyTiqmcEKzb98++Pj4QFdXF5GRkfzgzoyMDCxevLjCK0iqnqdPn2L48OFwcXHBl19+iQEDBhS7m7C6/PXXX+jcuTPc3d2xZcsWrFu3DmPHjlV3tQghRP00/ConhcfQLFy4EFu2bMGIESNkHgro5eWFhQsXVmjlSNU0c+ZMzJw5U93VKNGePXvUXQVCCNFIily9VCmucoqLi0O7du2KzTcyMtKIpzITQgghRAk0fFCwwqecrKyskJCQUGz+xYsXYW9vXyGVIoQQQoiGUeQeNJUhoRk3bhymTZuGq1evguM4PHnyBLt27YK/vz8mTpyojDoSQgghRN2q2hia2bNnQyqVomPHjsjOzka7du0gEong7++PL774Qhl1JIQQQggplcIJDcdxCAwMxIwZM5CQkICsrCy4uroWe1IzIYQQQqoQDR9DU+47Bevo6Cj0nBxCCKms1HWDu6Q5rVUe0yY4QuUx1XGzRACQRsWoJW5lpcyrnDZv3ozNmzfj4cOHAIAGDRpg7ty56Nq1q9xlKJzQdOjQodRn25w5c+aD7xFCCCGEvK927dr47rvv4OjoCMYYdu7ciV69eiEyMhINGjSQqwyFE5qGDRvKvM7Ly0NUVBRu375Nd1QlhBBCqiolnnLy9fWVeb1o0SJs3rwZV65cUV5Cs3r16hLnz58/H1lZWYoWRwghhJBKoDynnDIzM2Xmi0QiiESiUtctKCjA3r178fr1a7Rq1Uru+pXrWU4lGT58OH744YeKKo4QQgghmkbBS7ZtbGxgZGTET0uWLPlg0bdu3YJEIoFIJMLnn3+OAwcOKDRWt9yDgt93+fJliOV8CichhBBCKplynHJKSkqSedp2ab0zzs7OiIqKQkZGBn777TeMHDkS586dkzupUTih6du3r2ydGUNycjKuX7+OOXPmKFocIYQQQiqB8pxyMjQ0lEloSqOjowMHBwcAQJMmTXDt2jWsXbsWW7dulWt9hRMaIyMjmdcCgQDOzs5YsGABPv30U0WLI4QQQkhloOL70EilUuTk5Mi9vEIJTUFBAUaNGgV3d3eYmJgoXDlCCCGEVE7KvA9NQEAAunbtijp16uDVq1fYvXs3wsPDcfz4cbnLUCih0dLSwqefforY2FhKaIhacRyHAwcOoHfv3iW+Hx4ejg4dOiAtLQ3GxsYqrVt5+Po9R/+JKTC1yMf9GF1s+rYW4qL0qlxMVcd1c0tB/36xcHBIg5nZGywIbovLl2srJdb7VNnOQQ1uY3CDf1DL4BUAIOGlKTbfaIILibZKiVeUqo+j6rJPNZISe2hSUlIwYsQIJCcnw8jICB4eHjh+/Dg6d+4sdxkKX+Xk5uaG+/fvK7oaIQp5+vQpvvjiC9jb20MkEsHGxga+vr44ffq0XOu3bt2a/2BouvY90zB+3hPsWmWFyT5OuB8jxqLd92FkllelYqojrlicj/sPTLBpUxOllP8hqm7nsywJVl9piQG/9ceA3/rj6uNa2NDlGBxMXiolXiF1HEfVZZ9qJCU+nPL777/Hw4cPkZOTg5SUFJw6dUqhZAYoR0KzcOFC+Pv748iRI0hOTkZmZqbMRMjHevjwIZo0aYIzZ85g+fLluHXrFo4dO4YOHTpg8uTJcpWho6MDKyurUu9qrSn6jn+OY7tNceJXUyTGi7FuVm3kvOHgM0R5f4zUEVMdca9fr4kff/RAxGUbpZT/IapuZ/gjO5xPtMWjDGM8yjDG2r9aIDtPGx6Wz5QSr5A6jqPqsk81UeEpJ3knVZM7oVmwYAFev36Nbt26ITo6Gj179kTt2rVhYmICExMTGBsb02koUiEmTZoEjuPw119/oV+/fnByckKDBg3w1Vdf4cqVK/xyz58/R58+faCnpwdHR0ccOnSIfy88PBwcxyE9PR0AEBoaCmNjYxw/fhwuLi6QSCTo0qULkpOT+XWuXbuGzp07w9zcHEZGRmjfvj1u3ryp1LYKtaVw9MjGzQsG/DzGOEReMIBrk+wqE1OdcVVN3e0UcFJ0dYiHrnYeop9ZKi2OutupStWpraVSYg9NRZB7DE1QUBA+//xznD17Vpn1IdXcy5cvcezYMSxatAj6+vrF3i86HiYoKAjLli3D8uXLsX79egwbNgyPHj2CqalpiWVnZ2djxYoV+OmnnyAQCDB8+HD4+/tj165dAIBXr15h5MiRWL9+PRhjWLlyJbp164b4+HgYGBiUWGZOTo7MKHxFeykNTQugJQTSU2U/imnPhbBxkH90v6bHVGdcVVNXOx1NX+CXvvuho1WA7DxtTD3WBffSSv4sVITqsj+B6tXWUlWVp20z9q527du3V1plCElISABjDPXr1y9zWT8/PwwZMgQAsHjxYqxbtw5//fUXunTpUuLyeXl52LJlC+rVqwcAmDJlChYsWMC//8knn8gsv23bNhgbG+PcuXPo0aNHiWUuWbIEQUFBcrWNEGV6mG6MvnsGQqKTC59697D4kzMY+XsvpSY1pHpR5lVOFUGhMTSVYTwCqdwKE2d5eHh48P/X19eHoaEhUlJSPri8np4en8wAgLW1tczyz549w7hx4+Do6AgjIyMYGhoiKysLiYmJHywzICAAGRkZ/JSUlCR3/QEg86UWCvIBY4t8mfkm5vlIS62wG3mrPaY646qautqZJ9VCYqYRYp5bYPXVloh7YYbP3G8pLV512Z9A9WprqTT8lJNCCY2TkxNMTU1LnQj5GI6OjuA4Dnfu3ClzWW1tbZnXHMdBKpUqtHzRBGrkyJGIiorC2rVrERERgaioKJiZmSE3N/eDZYpEIv5OmIrcEbNQfp4A8X/roVGbV0XqxdCwTRZibijnclB1xFRnXFXTlHZyHIO2VoHSyteUdqpCdWpraTR9ULBCqWVQUFCluAyWVF6mpqbw8fHBxo0bMXXq1GLjaNLT05V2X5lLly5h06ZN6NatG4B3zyB5/vy5UmIVtX+bOfzXJOFutB7iIvXQZ1wqxHpSnAhT3g8EdcRUR1yxOA81a2bxry0ts2Bvn4ZXr3SQmlp8jFZFUXU7v2xxBecT6yA5SwJ97Tz0cIxH85pPMO5IyadKK4o6jqPqsk81UlUZQwMAgwcPRo0aNZRVF0IAABs3boSXlxeaN2+OBQsWwMPDA/n5+Th58iQ2b96M2NhYpcR1dHTETz/9hKZNmyIzMxMzZsyArq6uUmIVde6QCYzMCjBixlOYWOTj/j+6CBxWF+nPtcteuRLFVEdcR8eXWLb0DP96wvhIAMDJk3WxanVLpcQEVN9OU903+O6TM7DQf41XuTq4+8IM4470wOV/lXtpszqOo+qyTzVSVUloaPwMURV7e3vcvHkTixYtwtdff43k5GRYWFigSZMm2Lx5s9Lifv/99xg/fjwaN24MGxsbLF68GP7+/kqLV9ShEHMcCjFXSSx1xlR13Fu3LNG12xCVxHqfKts5J7yDSuKURNXHUXXZp5qI+/8k77KqxjE5R2EKBAI8ffqUemgIKUVmZiaMjIzgjV4QctXol5sKCRq6qjymNCpG5TEBIGlOa5XHtAmOUHlMdexTQLX7NZ/lIRy/IyMjQ+GxdupW+L3mOnExtERiudYpyHmLmM3fqLS9cvfQlDbYkhBCCCFVm6Zftl2NrjcjhBBCSLlVlTE0hBBCCKnm1JCoyIsSGkIIIYSUiU45EUIIIaTyo1NOhBBCCKnsqIeGEEIIIZUf9dAQQgghpLKjHhpCCKlA6rrJnTqo4yZ32uHWKo+Z51199mmlRj00hBBCCKn0KKEhhBBCSGVHp5wIIYQQUvlRDw0hhBBCKjuOMXDyPc9a7uUqEiU0hBBCCCmbhvfQCFQfkhBCCCGkYlEPDSGEEELKRIOCCSGEEFL50SknQkhZfP2eY+fVGBy+/zfWHomHc8PsKhlTXXEppnIUhLxCnney7PRZilJjFqoO21fTFPbQyDvJa8mSJWjWrBkMDAxQo0YN9O7dG3FxcQrXjxIaQtSsfc80jJ/3BLtWWWGyjxPux4ixaPd9GJnlVamY6opLMZW7T2EnhHBfjf+m9ebKjYdqtn01CVNwktO5c+cwefJkXLlyBSdPnkReXh4+/fRTvH79WqHqUUJDyuXp06eYNm0aHBwcIBaLYWlpCS8vL2zevBnZ2dXrV8vH6jv+OY7tNsWJX02RGC/Gulm1kfOGg8+Ql1UqprriUkzl7lNoAZyZ1n+TsfL/rFSr7atBlNVDc+zYMfj5+aFBgwbw9PREaGgoEhMTcePGDYXqRwkNUdj9+/fRqFEjnDhxAosXL0ZkZCQuX76MmTNn4siRIzh16lS5ys3Nza3gmmo+obYUjh7ZuHnBgJ/HGIfICwZwbaKcxFAdMdUVl2Iqd58CAB4XIK/fM+QNSUH+wjSwZwVKDVfttq8mKUcPTWZmpsyUk5NTZpiMjAwAgKmpqULVo4SGKGzSpEkQCoW4fv06Bg4cCBcXF9jb26NXr174448/4OvrCwBIT0/H2LFjYWFhAUNDQ3zyySeIjo7my5k/fz4aNmyIHTt2oG7duhCLxQAAjuOwdetW9OjRA3p6enBxccHly5eRkJAAb29v6Ovro3Xr1rh37x5f1r1799CrVy9YWlpCIpGgWbNmxRIrOzs7LF68GKNHj4aBgQHq1KmDbdu28e9/8sknmDJlisw6qamp0NHRwenTpyt8OwKAoWkBtIRAeqrs+Py050KYWORXmZjqiksxlbtPOVdtaM02gnCZKbS+NAKSC5A/9QVYtlRpMavT9tVEivbO2NjYwMjIiJ+WLFlSavlSqRTTp0+Hl5cX3NzcFKobJTREIS9evMCJEycwefJk6Ovrl7gMx3EAgAEDBiAlJQVHjx7FjRs30LhxY3Ts2BEvX/7XRZuQkIB9+/Zh//79iIqK4ucHBwdjxIgRiIqKQv369TF06FBMmDABAQEBuH79OhhjMslHVlYWunXrhtOnTyMyMhJdunSBr68vEhMTZeq2cuVKNG3aFJGRkZg0aRImTpzIDz4bO3Ysdu/eLfML4ueff0atWrXwySeflNjWnJycYr9ACKkuBC3EEHjrgqunDUFzEbS+MwWypGBn36q7akQZGFNsApCUlISMjAx+CggIKDXE5MmTcfv2bYSFhSlcPUpoiEISEhLAGIOzs7PMfHNzc0gkEkgkEsyaNQsXL17EX3/9hb1796Jp06ZwdHTEihUrYGxsjN9++41fLzc3Fz/++CMaNWoEDw8Pfv6oUaMwcOBAODk5YdasWXj48CGGDRsGHx8fuLi4YNq0aQgPD+eX9/T0xIQJE+Dm5gZHR0cEBwejXr16OHTokEw9u3XrhkmTJsHBwQGzZs2Cubk5zp49CwDo27cvAOD333/nlw8NDYWfnx+fpL1vyZIlMr8+bGxsFNqemS+1UJAPGL/3K8/EPB9pqcq5q4I6YqorLsVU7j59H2cgAFdbCPZYeb0W1Xn7qlt5xtAYGhrKTCKR6IPlT5kyBUeOHMHZs2dRu3ZthetHCQ2pEH/99ReioqLQoEED5OTkIDo6GllZWTAzM+MTHYlEggcPHsicKrK1tYWFhUWx8oomN5aWlgAAd3d3mXlv377le0SysrLg7+8PFxcXGBsbQyKRIDY2tlgPTdFyOY6DlZUVUlLeXWYqFovx2Wef4YcffgAA3Lx5E7dv34afn98H2x0QECDz6yMpKUneTQYAyM8TIP5vPTRq86pIvRgatslCzA09hcrS5JjqiksxlbtP38eypWBP8gEzLaXFqM7bV+2UdJVTYY/7gQMHcObMGdStW7dc1as+qSWpEA4ODuA4rtg9Auzt7QEAurq6AN4lGNbW1jK9KIWMjY35/3/otJW2tjb//8LekZLmSaXvztX7+/vj5MmTWLFiBRwcHKCrq4v+/fsXG2hctIzCcgrLAN6ddmrYsCH+/fdfhISE4JNPPoGtrW2JdQQAkUhU6i8OeezfZg7/NUm4G62HuEg99BmXCrGeFCfCFBsQp+kx1RWXYiovZsGmTHCtReAstcBeSCENeQUIOAg6ipUWE6g+21fTcNJ3k7zLymvy5MnYvXs3fv/9dxgYGODp06cAACMjI/5vijwooSEKMTMzQ+fOnbFhwwZ88cUXH0xIGjdujKdPn0IoFMLOzk7p9bp06RL8/PzQp08fAO8SqocPHypcjru7O5o2bYrt27dj9+7d2LBhQwXXtLhzh0xgZFaAETOewsQiH/f/0UXgsLpIf65d9sqVKKa64lJM5cVkqQWQBqcDmVLASADOXQfCTWbgjJXXQwNUn+2rcZR0p+DNmzcDALy9vWXmh4SElNpD/j5KaIjCNm3aBC8vLzRt2hTz58+Hh4cHBAIBrl27hjt37qBJkybo1KkTWrVqhd69e2PZsmVwcnLCkydP8Mcff6BPnz5o2rRphdbJ0dER+/fvh6+vLziOw5w5c2R6XhQxduxYTJkyBfr6+nyCpGyHQsxxKET5NyRTd0x1xaWYyiGcZ6KyWO+rDttX0yjrWU6MVcxzEmgMDVFYvXr1EBkZiU6dOiEgIACenp5o2rQp1q9fD39/fwQHB4PjOPz5559o164dRo0aBScnJwwePBiPHj3ix8RUpFWrVsHExAStW7eGr68vfHx80Lhx43KVNWTIEAiFQgwZMoS/lJwQQqq9clzlpEocq6jUiJAq4uHDh6hXrx6uXbumcFKUmZkJIyMjeKMXhFw16oomVYZ2uLXKY+Z5J6s8pqrlszyE43dkZGTA0NBQ3dVRSOH3WgvfYAi15fuRl5/3FlcPz1Fpe+mUEyH/l5eXhxcvXuDbb79Fy5Yty93DQwghVZKGP22bEhpC/u/SpUvo0KEDnJycZO6VQwghRHljaCoKJTSE/J+3t3eFDU4jhJAqR5GxMWr4LqWEhhBCCCFloh4aQgghhFR+NIaGEEIIIZUd9dAQQgghpPKTsneTvMuqGCU0hBBCeOq4J4w67n0DVI/731QoOuVECCGEkMqOgwKnnJRak5JRQkMIIYSQstFl24QQQgip7GhQMCGEEEIqPxpDQwghhJDKjmMMnJynkuRdriJRQkMIIYSQskn/P8m7rIpRQkMIIYSQMlEPDSGEEEIqPxpDQwgpi6/fc/SfmAJTi3zcj9HFpm9rIS5Kr8rFVFdcill1YhaEvIJ0Z5bsTBstaP9UQ2kxC6nrM6MxNPyybYHKIxJCZLTvmYbx855g1yorTPZxwv0YMRbtvg8js7wqFVNdcSlm1YoJALATQrivxn/TenPlxoMa26pBCi/blndSNUpoiFr4+fmB47hiU0JCgrqrpnJ9xz/Hsd2mOPGrKRLjxVg3qzZy3nDwGfKySsVUV1yKWbViAgC0AM5M67/JWPl/ytTWVk1S2EMj76RilNAQtenSpQuSk5Nlprp168osk5ubq6baqYZQWwpHj2zcvGDAz2OMQ+QFA7g2ya4yMdUVl2JWrZi8xwXI6/cMeUNSkL8wDexZgVLDqbWtGoSTKjapGiU0RG1EIhGsrKxkpo4dO2LKlCmYPn06zM3N4ePjAwBYtWoV3N3doa+vDxsbG0yaNAlZWf+dRw8NDYWxsTGOHz8OFxcXSCQSPmEq6ocffkCDBg0gEolgbW2NKVOm8O+lp6dj7NixsLCwgKGhIT755BNER0crdRsYmhZASwikp8oOZ0t7LoSJRX6ViamuuBSzasUEAM5VG1qzjSBcZgqtL42A5ALkT30Blq28v6DqaqvGoR4aQhSzc+dO6Ojo4NKlS9iyZQsAQCAQYN26dfjnn3+wc+dOnDlzBjNnzpRZLzs7GytWrMBPP/2E8+fPIzExEf7+/vz7mzdvxuTJkzF+/HjcunULhw4dgoODA//+gAEDkJKSgqNHj+LGjRto3LgxOnbsiJcvP9ylnJOTg8zMTJmJEKI8ghZiCLx1wdXThqC5CFrfmQJZUrCzb9VdNaJmdJUTUZsjR45AIpHwr7t27QoAcHR0xLJly2SWnT59Ov9/Ozs7LFy4EJ9//jk2bdrEz8/Ly8OWLVtQr149AMCUKVOwYMEC/v2FCxfi66+/xrRp0/h5zZo1AwBcvHgRf/31F1JSUiASiQAAK1aswMGDB/Hbb79h/PjxJbZhyZIlCAoKKk/zAQCZL7VQkA8Yv/crz8Q8H2mpyvl4qiOmuuJSzKoVsyScgQBcbSHYY+X1lGhKW9VOwy/bph4aojYdOnRAVFQUP61btw4A0KRJk2LLnjp1Ch07dkStWrVgYGCAzz77DC9evEB29n/nr/X09PhkBgCsra2RkpICAEhJScGTJ0/QsWPHEusSHR2NrKwsmJmZQSKR8NODBw9w7969D7YhICAAGRkZ/JSUlKTQNsjPEyD+bz00avOKn8dxDA3bZCHmhnIuB1VHTHXFpZhVK2ZJWLYU7Ek+YKaltBia0lZ1K7yxnryTqlWj1JJoGn19fZlTPkXnF/Xw4UP06NEDEydOxKJFi2BqaoqLFy9izJgxyM3NhZ7euy8UbW1tmfU4jgP7/4dKV1e31LpkZWXB2toa4eHhxd4zNjb+4HoikYjv0Smv/dvM4b8mCXej9RAXqYc+41Ih1pPiRJjpR5WraTHVFZdiVq2YBZsywbUWgbPUAnshhTTkFSDgIOgoVlpMQH2fGY2ixPvQnD9/HsuXL8eNGzeQnJyMAwcOoHfv3gqVQQkN0Xg3btyAVCrFypUrIRC861Tcs2ePQmUYGBjAzs4Op0+fRocOHYq937hxYzx9+hRCoRB2dnYVUW25nTtkAiOzAoyY8RQmFvm4/48uAofVRfpz7bJXrkQx1RWXYlatmCy1ANLgdCBTChgJwLnrQLjJDJyx8npoAPV9ZjQKg/zPaFKwg+b169fw9PTE6NGj0bdvX0VrBoASGlIJODg4IC8vD+vXr4evr6/MYGFFzJ8/H59//jlq1KiBrl274tWrV7h06RK++OILdOrUCa1atULv3r2xbNkyODk54cmTJ/jjjz/Qp08fNG3aVAkt+8+hEHMcClH+zcHUHVNdcSlm1YkpnGeisljvU9dnRlMo81lOXbt25cdRlheNoSEaz9PTE6tWrcLSpUvh5uaGXbt2YcmSJQqXM3LkSKxZswabNm1CgwYN0KNHD8THxwN4d3rqzz//RLt27TBq1Cg4OTlh8ODBePToESwtLSu6SYQQUvkwKHDZ9rtV3r8KNCcnR2nV4xhTw8gdQqqozMxMGBkZwRu9IOSqUVc0IR9BO9xaLXHzvJPLXqiC5LM8hON3ZGRkwNDQUGVxK0Lh99onnrMg1JJvzGB+QQ7ORC8tNn/evHmYP39+qetyHEdjaAghhBCiJFIAnALLAkhKSpJJ4D72IorSUEJDCCGEkDKVZwyNoaGhynqkKKEhhBBCSNmUeNl2RaCEhhBCCCFlU2JCk5WVhYSEBP71gwcPEBUVBVNTU9SpU0euMiihIYQQQkjZlJjQXL9+XeYeYV999RWAd1enhoaGylUGJTSEEEIIKVs5BgXLy9vbGx970TUlNIQQQggpkzJvrFcRKKEhhBBCSNloUDAhRNkEDV3VXQWVkUbFqLsKpIIVTFfP4wziQ2uqLJb0zVvg899VFk8ppAzg5ExUpJTQEEIIIUQTUQ8NIYQQQio/BRIaRR+3XQEooSGEEEJI2aiHhhBCCCGVnpRB7p4XGkNDCCGEEI3EpO8meZdVMUpoCCGEEFI2OuVECCGEkEqPTjkRQgghpNKjHhpCNNP8+fNx8OBBREVFqbsq8PV7jv4TU2BqkY/7MbrY9G0txEXpKS2em1sK+veLhYNDGszM3mBBcFtcvlxbafHUFbOQqrcvxaxax+77TI48hflvj5HWuQaeD7NRaWy1YlAgoVFqTUokUH1IQsqWmpqKiRMnok6dOhCJRLCysoKPjw8uXbpUYTH8/f1x+vTpCiuvvNr3TMP4eU+wa5UVJvs44X6MGIt234eRWZ7SYorF+bj/wASbNjVRWgxNiAmoZ/tSzKp17BYluv8aRuGpyLHRVUt8tSrsoZF3UjFKaIhG6tevHyIjI7Fz507cvXsXhw4dgre3N168eFFhMSQSCczMzCqsvPLqO/45ju02xYlfTZEYL8a6WbWR84aDz5CXSot5/XpN/PijByIuq+7XpTpiAurZvhSzah27hbi3BbDa+gDPRtmiQE9L5fHVTipVbFIxSmiIxklPT8eFCxewdOlSdOjQAba2tmjevDkCAgLQs2dPAADHcdi8eTO6du0KXV1d2Nvb47fffpMpZ9asWXBycoKenh7s7e0xZ84c5OX998tx/vz5aNiwIf/az88PvXv3xooVK2BtbQ0zMzNMnjxZZp2KJtSWwtEjGzcvGPDzGOMQecEArk2ylRa3ulDH9qWYVffYrfFTIl57GuFNA0N1V0U9qIeGEMVIJBJIJBIcPHgQOTk5H1xuzpw56NevH6KjozFs2DAMHjwYsbGx/PsGBgYIDQ1FTEwM1q5di+3bt2P16tWlxj579izu3buHs2fPYufOnQgNDUVoaOgHl8/JyUFmZqbMpAhD0wJoCYH0VNnhbGnPhTCxyFeoLFKcOrYvxayax67kykuIHmXjRf9a6q6K+lBCQ4hihEIhQkNDsXPnThgbG8PLywvffPMN/v77b5nlBgwYgLFjx8LJyQnBwcFo2rQp1q9fz7//7bffonXr1rCzs4Ovry/8/f2xZ8+eUmObmJhgw4YNqF+/Pnr06IHu3buXOs5myZIlMDIy4icbm2o0QJCQakL4IhcWu5PwdEJdMJ1q/GdTyhSbVKwa7xmiyfr164cnT57g0KFD6NKlC8LDw9G4cWOZ3pJWrVrJrNOqVSuZHppff/0VXl5esLKygkQiwbfffovExMRS4zZo0ABaWv+dG7e2tkZKSsoHlw8ICEBGRgY/JSUlKdTOzJdaKMgHjN/7RWtino+0VLoI8WOpY/tSzKp37IoeZkOYmY8682LhMPoGHEbfgF5cFoxPpcBh9A21/PFWB8akCk2qRgkN0VhisRidO3fGnDlzEBERAT8/P8ybN0+udS9fvoxhw4ahW7duOHLkCCIjIxEYGIjc3NxS19PW1pZ5zXEcpKUMbhOJRDA0NJSZFJGfJ0D833po1OZVkZgMDdtkIeaGci+3rQ7UsX0pZtU7drNdDfBooSsSF/w3va2rh1ctTZG4wBUQcOquomowBXpn6D40hHyYq6srDh48yL++cuUKRowYIfO6UaNGAICIiAjY2toiMDCQf//Ro0cqq6si9m8zh/+aJNyN1kNcpB76jEuFWE+KE2GmSospFuehZs0s/rWlZRbs7dPw6pUOUlP1q0xMQD3bl2JWrWOX6Woht7bsZdpSHQEKJMJi86s0psCdgimhIQR48eIFBgwYgNGjR8PDwwMGBga4fv06li1bhl69evHL7d27F02bNkWbNm2wa9cu/PXXX/j+++8BAI6OjkhMTERYWBiaNWuGP/74AwcOHFBXk0p17pAJjMwKMGLGU5hY5OP+P7oIHFYX6c+1y165nBwdX2LZ0jP86wnjIwEAJ0/WxarVLatMTEA925diVq1jl/yfVApw9HBKQuQmkUjQokULrF69Gvfu3UNeXh5sbGwwbtw4fPPNN/xyQUFBCAsLw6RJk2BtbY1ffvkFrq6uAICePXviyy+/xJQpU5CTk4Pu3btjzpw5mD9/vppaVbpDIeY4FGKusni3blmia7chKounrpiFVL19KabyqPM4KupxgLO6q6B6Gt5DwzGmhqiEfCSO43DgwAH07t1b3VWRkZmZCSMjI3ijF4Sc8n6lvk/Q0FVlsdRNGhWj7iqQCqau4zduuupOF0nfvEXS50HIyMhQeKyduhV+r32iNxhCTkeudfJZLs5kh6m0vTQomBBCCCGVHp1yIoQQQkjZNPyUEyU0pFKiM6WEEKJiUgZwlNAQQgghpDJjDIC8VznRnYIJIYQQooGYlCk0KWrjxo2ws7ODWCxGixYt8Ndffym0PiU0hBBCCCkbkyo2KeDXX3/FV199hXnz5uHmzZvw9PSEj49PqY+eeR8lNIQQQggpkzJ7aFatWoVx48Zh1KhRcHV1xZYtW6Cnp4cffvhB7jJoDA0hFahwsHI+8uS+GKAiCApyVBdMzaQsT91VIBVMXcev9I3qnsEkffOujZX5goZ8liN3z0s+3n1OMzMzZeaLRCKIRCKZebm5ubhx4wYCAgL4eQKBAJ06dcLly5flrh8lNIRUoFev3j2o7yL+VG3gv39XbTxCKpK6jt/PVR/y1atXMDIyUn3gj6CjowMrKytcfKrY95pEIoGNjY3MvHnz5hW7Y/vz589RUFAAS0tLmfmWlpa4c+eO3PEooSGkAtWsWRNJSUkwMDAAxyn26y8zMxM2NjZISkpS2Z01KWbViqmuuBSzbIwxvHr1CjVr1lRS7ZRHLBbjwYMHyM3NVWg9xlix78H3e2cqEiU0hFQggUCA2rVrf1QZhoaGKr81OsWsWjHVFZdilq6y9cwUJRaLIRaLlVK2ubk5tLS08OzZM5n5z549g5WVldzl0KBgQgghhKiNjo4OmjRpgtOnT/PzpFIpTp8+jVatWsldDvXQEEIIIUStvvrqK4wcORJNmzZF8+bNsWbNGrx+/RqjRo2SuwxKaAjRECKRCPPmzVPqOWaKWbVjqisuxSQfa9CgQUhNTcXcuXPx9OlTNGzYEMeOHSs2ULg0HKvM15ARQgghhIDG0BBCCCGkCqCEhhBCCCGVHiU0hBBCCKn0KKEhamdnZ4c1a9YopWyO43Dw4EGllF1eqm5vdnY2+vXrB0NDQ3Ach/T09FLL8Pb2xvTp05VSv6I4juPr8/DhQ3Ach6ioKP798PBwuepb3ZR1TNN2U6/58+ejYcOG6q5GtUQJDSmXD/3RCw0NhbGxsUJlXbt2DePHj+dfqzIJSU1NxcSJE1GnTh2IRCJYWVnBx8cHly5dkqmPm5ubwu39UOKi6vbu3LkTFy5cQEREBAYOHAg/Pz+Z93/77TeIxWKsXLkSb968QVRUFH766Sfk5Hz4+Tp+fn7o3bt3hdXRxsYGycnJcHNz4+e1bt0aycnJmD59utyxPlQvTfojX9JnZ+3atRCJRAgLC8PTp0/xxRdfwN7eHiKRCDY2NvD19ZW5R0dpWrdujejoaMydOxcODg4Qi8WwtLSEl5cXNm/ejOzsbCW0qnR+fn58Alt0SkhIUGk95Pm8fyx/f3+59xWpWHTZNlE7CwsLtcXu168fcnNzsXPnTtjb2+PZs2c4ffo0Xrx4obSYqm7vvXv34OLiAjc3N+jq6sokKjt27MDkyZOxZcsWjBo1Cj///DPc3d3BGMPBgwcxaNAgldRRS0tL5o6geXl5/PNjqrp58+ZhxYoV+P3331G/fn00adIExsbGWL58Odzd3ZGXl4fjx49j8uTJcj3X5t9//4WPjw+MjY2xePFiuLu7QyQS4datW9i2bRtq1aqFnj17KlzP3Nxc6OjolKeJAIAuXbogJCREZt77n4WPjVEWVXzeJRIJJBJJhZVHFMAIKYf27duzadOmFZsfEhLCjIyM+NcjR45kvXr1YsuXL2dWVlbM1NSUTZo0ieXm5vLL2NrastWrV/P/x7vnVDMAzNbWll/u4MGDrFGjRkwkErG6deuy+fPns7y8PP79u3fvsrZt2zKRSMRcXFzYiRMnGAB24MCBEtuQlpbGALDw8PAPtvND9UlISGA9e/ZkBgYGDABr2rQpO3nyJN9ee3t7mfWKftSsrKxY3bp1mVgsZlpaWsXK37hxI3NwcGBCoZAJhUImEAhKba+2tjbT0dFhQqGQAWB+fn4y+6lo+ZaWlqxXr16MMcaWLl3KxGIx279/P7+8t7c3c3R0ZB06dGCdO3fmt8GiRYvYqFGjGABmYmLCjI2NmUAgYPXr12eNGjViXbp0Ydra2gwA4ziOde/enQFgkZGRjDHGNm3axMRisUw9Cv9fuB8AMBcXF8ZxHBMIBPzyAoGA6evrszVr1jATExMmEon45QUCAVu1ahVLSUlhLVu25Ofr6uoyY2NjpqOjwxo0aMBWr17Nx8rPz2ejR49mFhYWjOM4xnEcMzExYStWrJA5bnV1dVmXLl2Yrq4uA8AkEgnbtGmTzPFx6dIl5unpyUQiEWvSpAk7cOCATLtLUvjZkUqlbMqUKczY2JhdunSJMcZY165dWa1atVhgYCCrVasW09HRYZ6enuzo0aMsLS2NMcb4NjZv3pwJBALGcRyztbVlERERjDHGmjVrxgCwpUuXstq1azNtbW0mFArZuHHjmEAgYHp6eszHx4fFxsayMWPGMHNzc6avr89MTEyYkZERMzQ0ZO3atWPjx49nnp6ebPv27czOzo5xHMfH37JlC+vevTvT1dVl9evXZxERESw+Pp61b9+e6enpsVatWrGEhAS+zX379mVWVlasRo0aTF9fn/+8tG/fnk2ePJlNmzaNP85HjRrFdHR0+OO6du3abOLEiaxt27Zs8uTJjLH/vmfCwsIYACYWi5mPjw978uSJzLb+/vvvmaurK9PR0WE1atSQ+bynpaXx7TcwMGAdOnRgANimTZtYly5dmFgsZnXr1mV79+6VKXPmzJnM0dGR6erqsrp167Jvv/1W5vts3rx5zNPTU+ZYKus7kFQMSmhIuSiS0BgaGrLPP/+cxcbGssOHDzM9PT22bds2fpmiCU1KSgoDwEJCQlhycjJLSUlhjDF2/vx5ZmhoyEJDQ9m9e/fYiRMnmJ2dHZs/fz5jjLGCggLm5ubGOnbsyKKioti5c+dYo0aNSk1o8vLymEQiYdOnT2dv374tcZnC+jg7O7OxY8fy9YmKimJbtmxhwcHBzMDAgH377bdMLBaz/v37M0NDQ+bn58csLS3ZsGHDmK6uLlu+fDlj7F0ixHEc6927N7t79y47cuQIA8C8vLxYcnIyO3HiBNPS0mJz585lBgYGLCgoiM2ZM+eD7W3evDnjOI6NHj2aubq6MgBMR0eHhYSEMMYYe/HiBRs3bhxr1aoVS05OZoMHD2a9evViM2fOZBKJhJ06dYpva0JCAhOJRMzLy4tNmDCBicVi9vDhQ2Zra8tMTU3Zxo0bGQBmaGjIALBWrVqx3r178wlG3bp12ZYtW5iVlRX/RzcyMpKFh4fzf3h79+7NZs6cKZPIFU1oALDp06ezkydPstatWzMArGHDhqxJkyZ8giMUCtmkSZPYunXrmKmpKRMIBMzHx4d99dVXzNPTkwFgWlparEmTJszR0ZGNGTOGT0rS0tJYbm4uGzt2LBMIBOzLL79ky5cvZzo6OjLbbeTIkYzjOCYSidicOXPY1q1bmba2NuM4jt25c4cxxlhGRgYzNTVlw4cPZ//88w/7888/mZOTk1wJzeTJk9nQoUOZlZUVi46O5vcVx3GsW7duzNDQkP3yyy/szp07bObMmUxbW5vdvXuXMfZfQlOzZk22bds29tlnnzGhUMhq167Nnj59yjiO4xPL5cuXsyVLljAtLS0mFAqZvr4+u3HjBnNxcWFWVlbM19eXXbt2je3cuZN17dqVGRsbs4iICDZmzBimr6/P9PX1WZcuXdjNmzf5egJgtWrVYr/++iuLi4tjvXv3ZnZ2duyTTz5hx44dYzExMaxly5asS5cufJt9fX2Zp6cnu3XrFrt79y7/eWnZsiWTSCRsxowZrGbNmszIyIht3LiRffPNN2zs2LGM4zgWGhrKnJ2dWadOnZiJiQl7+/YtCwkJYdra2szJyYlZW1uz69evMxcXFzZ06FA+ZmESvWbNGhYXF8ciIiKYSCTiP++dOnXi23/37l329ddfMwDM1NSUbd++ncXFxbFvv/2WaWlpsZiYGL7c4OBgdunSJfbgwQN26NAhZmlpyZYuXcq/X1JCU9Z3IKkYlNCQclEkobG1tWX5+fn8vAEDBrBBgwbxr4smNIyxEpOQjh07ssWLF8vM++mnn5i1tTVjjLHjx48zoVDIHj9+zL9/9OjRUhMaxhj77bffmImJCROLxax169YsICCA/+IuWp8GDRqU2d4GDRqw5s2b8+0tbFfR9o4ZM4ZJJJJi7eU4jr1584bt27ePGRoaMm9vb7na27t3b74npbC9vXv3Zq6urvx606ZNY+3bt2eMvdsfOjo6DAA7ffq0TPnffPMN6927N79ve/XqxebNm8dsbW3Z8OHD+boGBgYysVjMPD092eXLl/mekjdv3jDGGPvll19kEpqGDRsyjuOYo6MjH2vGjBklJjQtW7bklzl79iyfQPXq1Ys5OjoygUDA14Uxxm7fvs0AsAkTJjDGGOvXr59ML03RfwtjMcbY0KFD+e3GGGOTJ09mTk5O/HYbOXIk09LSYsOGDeOX6d+/PxOJRGzz5s2MMcY2b97MzMzM+HYzxtj27dvlSmgKE6jY2Fh+/tWrV/kesEWLFsms06xZMzZp0iR+HwBgO3bsYIwxlpWVxc8r7LEAwD799FPG2LtjtDDJA8BmzpzJvvzyS8ZxXLFEvl69emzr1q2soKCA7/UrTOILAWDffvst/7rwGPj+++/5eb/88gsTi8X868LtWZgk6evrM0NDQ+bg4MAaNWrEGGMyxxljjEmlUlajRg22efNmtnfvXmZmZsZMTEzYr7/+yrfJ2dmZT/I3btzILC0t+fVr1qzJAgMDZepe+HnX0dFhWlpabMaMGTKfdwCsXbt2Muu0aNGCTZw4kX3I8uXLWZMmTfjXJSU0ZX0HkopBg4KJ0jVo0ABaWlr8a2tra6SkpChURnR0NBYsWMCfn5ZIJBg3bhySk5ORnZ2N2NhY2NjYoGbNmvw68jzUrF+/fnjy5AkOHTqELl26IDw8HI0bN0ZoaGip62VlZcHf3x8BAQHIyMiARCJBbGwsXr9+XWp7o6OjkZWVhVmzZsmca2eM4cGDB+jcuTNsbW1x7tw5zJkzB2KxuNT2Pnr0CF5eXjLtrV+/PuLj41FQUFBi3T08PGBnZ4d58+YhKysLAFBQUICdO3di+PDh/HLDhw/nt4OHhwc/39PTkx+LU3hbcjMzM/5JvO/fqjw+Pp5vX2Fb1q1bV2LdPD09+f8fOHAAAJCZmYkjR44gPj4eAHDr1i3Y29vD0NAQLVq0AACYmJggPj4eV69e5deXSqUAgHXr1qFJkyYycc6fP4/bt2/DwsICEokE27Ztg1QqldluOjo6MvWpWbMmhEIhvy/j4uLg4eEh8wTi5s2bl9iu97Vp0wYSiQRz5sxBfn4+gHfHAACkpaXx+7SQl5cXYmNjZeYV7hN9fX0YGBjw6xZq3Lgx/3+xWIyAgABoaWkhJycHWVlZYIzBzMwMEokE+vr60NbWxr179/DFF1/A0NAQubm5MDExKXHMV9HjoXB/u7u7y8x7+/YtMjMzAbwbE1WrVi1YWlqC4zhIpVK8evUKOTk5MvumsNxTp06hU6dOePnyJaZNm4bPPvsML168wODBg/HDDz/wbYqPj+cHuRf9nKWkpODJkyfo2LGjTL0LP+/jxo2DVCrFypUr4enpCZFIxH8W3x//0qpVK5lt/+uvv8LLywtWVlaQSCT49ttvkZiYWGwbFVUR34GkbJTQkHIxNDRERkZGsfnp6ekwMjKSmaetrS3zuvALTRFZWVkICgpCVFQUP926dQvx8fEf/Uh7sViMzp07Y86cOYiIiICfnx/mzZsns4yenp5Me/39/XHgwAF07doV1tbWiIqKgru7O6RSaantzcrKgoGBAfz9/fl2AMCmTZtQr149GBgY4ObNm9DW1oaXlxdq1KgBMzMznD9/vsLaW6tWLYSHh+Px48fo0qULXr16hePHj+Px48cYNGgQzp07h3Xr1mHw4MF49OgR3r59K9Omwv8zxsBxHABAIPjvq6RwXqGcnBxoa2ujV69efJsvX75cah3DwsKwZcsWvjxvb2+Ym5tDKpXi7du32L59O65evSqTwPj6+iI3N5d/vWvXLgCAubm5zDYLCwvD48eP0ahRI5w4cQJRUVEYNWoUn1gUVbTdhe1S9Ngtibu7O06fPo2zZ89i0KBByM/Ph6OjY7FtV5qS6mZtbV1iGSKRSCYxefv2LQDw+6Nx48aoX78+tm/fjtOnTyMqKgq6urrFjuXSYpe2ra5fv47nz59jxYoViIiIwN9//w0PDw9IpVLo6+vLlPvw4UP06NGDT7zHjx+PjRs3AgCGDRuGkydP4uXLl5BKpfjkk09ga2vLxyxMCnV1dT+43cRiMf/jJy4uDgMGDIC5uTn/WezWrdsH1718+TKGDRuGbt264ciRI4iMjERgYKDMcVfW9iqsa0UcR0QWJTSkXJydnXHz5s1i82/evAknJ6ePKltbW7tY70Ljxo0RFxcHBweHYpNAIICLiwuSkpKQnJzMr3PlypVyxXd1dcXr169l6mNtbS3T3kuXLsHPzw/5+flo0KABrKys8PDhQ5lydHR0SmxHXl4eLCws+Ppra2ujRo0a/NUdQqEQTZs2hYODA2JjY/HkyRM8fPiwxPba2dnxl5wWtvfOnTtwcnKS+UX4vsJeoKdPn6JLly7YsmULBg8ejKioKDRt2hTDhg1DVFQUBg8ejFevXpW5zdLS0j54mbeTkxPy8vJw69Ytvg0f+nUaHR3Nb98GDRoAAAwMDCCRSPj2dO7cGR07doSLiwvfI/HmzRvExcXBxcWFL6uwd6CgoAB3797l51+6dAk1atRAXl4eGjVqBAcHB9y7dw+vX78uc7sV5ezsjFu3bsm0+9q1a3KtCwANGzbE6dOncf78eQwcOBAGBgbw8fGBQCDA2bNnZZa9dOkS6tWrV2aZRkZGfI/H+3Up+tre3h7Au2PNwcEBUVFRmDlzJsaOHYs2bdpAJBLhzZs3crelLCkpKahTpw769OkDd3f3Ej8vhW7cuMH3nujr68PMzAxPnjwB8K6no2nTpjh37hzy8vIwevToEsswMDCAnZ3dBy+fbty4MZ4+fQqhUIiWLVsiJycHDg4OAIB//vlHZtkrV67wx1VERARsbW0RGBiIpk2bwtHREY8ePSrPJiFKQJdtk3KZOHEiNmzYgKlTp2Ls2LEQiUT4448/8Msvv+Dw4cMfVXbhF5GXlxdEIhFMTEwwd+5c9OjRA3Xq1EH//v0hEAgQHR2N27dvY+HChejUqROcnJwwcuRILF++HJmZmQgMDCw1zosXLzBgwACMHj0aHh4eMDAwwPXr17Fs2TL06tVLpj4GBga4e/cuJkyYgMmTJ8PKygpbtmxBSkoK1q5di6FDhxb7xWVnZ4fz58/DwsICeXl5AIBZs2bhl19+wb59++Dt7Q19fX1YWFhg/vz58PLyQnh4OFJSUjBs2DBMmzYNz549Q0FBAYRCIcLCwoq198mTJ/jrr78wZswYvrfizz//xNatW8vczjY2NggPD0e7du1w+fJl7N27F25ubvwfETc3N4wYMQJhYWFy3btk/PjxmD17Nv766y9+HsdxWLFiBbp164a7d++iV69e8PLywooVK0os4+rVqwgODoaRkRH/h6Vu3bqIjY3lT4/9+uuv8PHxwfPnzzF//nwA73ogzMzMcP/+fb6swl62bdu2ySRljo6OyMrKwunTpzFt2jTk5eXh0qVLyMnJwbJly8psZ6GhQ4ciMDCQb3diYiLfLnl7Wjw9PXHmzBl07NgRAwcOxJo1a9CsWTMEBwcjMzMTPj4+2Lt3L27cuCH3pcXTp0/H8OHDcfr0aXz22WeoUaMG3r59i4MHD0IqlUJLS4s/lda7d28sW7YMderUwfr163Hx4kW0atUKP/zwA4TCivvzYGhoiCdPniAqKgocx2HOnDkf7KFwcHBAXl4e1q9fj5ycHERHR8skY2PHjsXEiROB/7V390FR1V0cwL93WV522QUUeVtcedt2hRkwQUMaC5lxk5opBiqaooIEZohMIjVwEoQIaTRxJCdxxHhpQLAMxkBpmAaMwMIpZJzCLYgNnXCmKSPR4UX3PH8Y92EFfCBJ2J7z+Yu997e/e3537y5n7j2/ewFER0dPu82cnBykpKTA1dUVjz76KC5evIiUlBRkZ2cjMDAQK1euxLp16/Dnn39Cr9ejvb0dAHD06FGsWrUKa9euRWVlJTo6OnDkyBEAt46d/v5+VFdXY/Xq1WhoaBAvjbIFYD4LeJhl6+joIL1eTy4uLuTo6EihoaGTCnDHpyxONLFIlWhyUfCJEyfEacsTp203NjbSgw8+SDKZjBwcHOiBBx4wmylgMBho7dq1ZGNjQ1qtlhobG+9YFDw8PEyZmZkUHBxMjo6OJJfLSafT0Y4dO+j69euT4rGysiI7OztycXEhpVJJDg4OZGNjQ2q1mg4cOEDh4eHk7+8vjvfMmTMUFBQkFmOO8/DwIK1WSwqFguzt7cnb25ucnZ1JKpWSu7s7hYeHi4WLcrmcbGxs7jheqVQqFjkCoPj4+Gn391SfR1ZWFkkkEgoNDaXBwUGzgu+RkRESBIGio6OJ6L8F24sWLSKdTkd9fX0EgPR6PQUFBYn7Hn8Vpo7PCCopKTErzr29UHf87z179lBAQABJpVJxVpO1tTX5+vpSZmYmSSQScXq4RCIRpyhnZmZSU1OTOI0ef826AkBqtZoKCwvFbQ0PD1NCQgLJ5XKSSCQkkUjIwcFBLLge308ymczsuExLSyN7e3vauXOnuKytrU0cd0hICFVVVZmNeypTFdSfP3+eXF1dKSoqioxGI61evVr8PK2trWnNmjXU3Nwsfga4rfB4fOZZc3OzWEz90EMPmc0mW7p0KSmVSrp27Zo4vfzVV18llUolHkMSiYS8vb3po48+IkdHR1KpVJPiv/07NX4MTIxnPIbxIuwnn3ySlixZQjKZzOz74unpKe6Lib8DhYWF5OHhQYIgkJ+fH1VUVIj9Xb16VSyqnmh8TBMVFxeTTqcja2trcnd3p5CQELPvu5OTEykUCpJKpaRWqwkAvf3226TX68nW1pa8vb2ppqbGrM9t27aRs7MzKRQKeuaZZ2jfvn1mEyGmm7Y90e2/gWxuCER/XXRkjLE5UllZiZdeegmDg4N3rGeYicjISGg0Ghw4cOB/tjUajfDx8UFnZ+e83H5+Lsc915KTk3HhwgW0trbOdyh3xWg0ws/PD2fPnjUrfJ4LgiCgtrZ2Tu+Cze4dvuTEGLtrFRUV8PX1haenJ7q6upCRkYHY2Ni7+qd+5coVtLW1oaWlBSkpKXMY7dz5J8Y9V959913o9XrY29vj1KlTKC8vx/vvvz/fYf1tY2Nj+O2337Bjxw6sWbNmzpMZZvk4oWGM3bXLly8jOzsbly9fhoeHB55++mnk5+ffVZ8bN27E2bNnsWXLFrOapoXknxj3XOno6MDu3btx9epV+Pr6oqioCElJSfMd1t/W1taGiIgIaLVafPzxx/MdDluA+JITY4wxxiweT9tmjDHGmMXjhIYxxhhjFo8TGsYYY4xZPE5oGGOMMWbxOKFhjDHGmMXjhIYx9n8tISHB7EZq69atw2uvvXbP42hpaYEgCPjjjz+mbSMIAurq6mbcZ05Ozl3fYNBoNEIQBPHhjYwtVJzQMMYWnISEBAiCAEEQYGNjA41Gg7feemvKJ2LPtU8++QR5eXkzajuTJIQxdm/wjfUYYwtSZGQkSktLMTIygpMnT+KVV16BtbU1tm/fPqnt6Oio+LTyu7V48eI56Ycxdm/xGRrG2IJka2sLd3d3eHl54eWXX8b69etx4sQJAP+9TJSfnw+VSgWdTgcAuHjxImJjY+Hk5ITFixcjKioKRqNR7PPmzZt4/fXX4eTkBGdnZ7zxxhu4/d6it19yGhkZQUZGBtRqNWxtbaHRaHDkyBEYjUZEREQAABYtWgRBEJCQkAAAMJlMKCgogI+PD2QyGVasWDHp7rYnT56EVquFTCZDRESEWZwzlZGRAa1WC7lcDl9fX2RlZYlPdp/o0KFDUKvVkMvliI2NxeDgoNn6kpIS+Pv7w87ODsuXL7foRySw/1+c0DDGLIJMJsPo6Kj4+vPPP4fBYEBTUxPq6+sxNjaGDRs2QKlUorW1FW1tbVAoFIiMjBTft3fvXpSVleGDDz7Al19+id9//x21tbV33O6LL76Io0ePoqioCN3d3Th06BAUCgXUajWOHz8OADAYDBgYGMD+/fsBAAUFBaioqEBxcTG+++47pKen4/nnn8fp06cB3Eq8YmJi8Pjjj+PcuXNISkpCZmbmrPeJUqlEWVkZvv/+e+zfvx+HDx/Gvn37zNr09PTg2LFj+PTTT9HY2IjOzk6kpqaK6ysrK5GdnY38/Hx0d3dj165dyMrKQnl5+azjYWxezeuzvhljbArx8fEUFRVFREQmk4mamprI1taWtm7dKq53c3OjkZER8T0ffvgh6XQ6MplM4rKRkRGSyWT02WefERGRh4cH7d69W1w/NjZGS5cuFbdFRBQeHk5paWlERGQwGAgANTU1TRlnc3MzAaArV66Iy4aHh0kul1N7e7tZ28TERHr22WeJiGj79u0UEBBgtj4jI2NSX7cDQLW1tdOu37NnD4WEhIivd+7cSVZWVnTp0iVx2alTp0gikdDAwAAREfn5+VFVVZVZP3l5eRQWFkZERH19fQSAOjs7p90uYwsB19Awxhak+vp6KBQKjI2NwWQy4bnnnkNOTo64PjAw0KxupqurCz09PVAqlWb9DA8Po7e3F4ODgxgYGEBoaKi4TiqVYtWqVZMuO407d+4crKysEB4ePuO4e3p6cP36dej1erPlo6OjWLlyJQCgu7vbLA4ACAsLm/E2xtXU1KCoqAi9vb0YGhrCjRs34ODgYNZm2bJl8PT0NNuOyWSCwWCAUqlEb28vEhMTkZycLLa5ceMGHB0dZx0PY/OJExrG2IIUERGBgwcPwsbGBiqVClKp+c+Vvb292euhoSGEhISgsrJyUl8uLi5/KwaZTDbr9wwNDQEAGhoazBIJ4FZd0Fw5c+YM4uLikJubiw0bNsDR0RHV1dXYu3fvrGM9fPjwpATLyspqzmJl7F7ghIYxtiDZ29tDo9HMuH1wcDBqamrg6uo66SzFOA8PD3z99dd4+OGHAdw6E/HNN98gODh4yvaBgYEwmUw4ffo01q9fP2n9+BmimzdvissCAgJga2uL/v7+ac/s+Pv7iwXO47766qv/PcgJ2tvb4eXlhTfffFNc9vPPP09q19/fj19++QUqlUrcjkQigU6ng5ubG1QqFX766SfExcXNavuMLTRcFMwY+1eIi4vDkiVLEBUVhdbWVvT19aGlpQWbN2/GpUuXAABpaWl45513UFdXhwsXLiA1NfWO95Dx9vZGfHw8Nm7ciLq6OrHPY8eOAQC8vLwgCALq6+vx66+/YmhoCEqlElu3bkV6ejrKy8vR29uLb7/9Fu+9955YaJuSkoIff/wR27Ztg8FgQFVVFcrKymY13vvuuw/9/f2orq5Gb28vioqKpixwtrOzQ3x8PLq6utDa2orNmzcjNjYW7u7uAIDc3FwUFBSgqKgIP/zwA86fP4/S0lIUFhbOKh7G5hsnNIyxfwW5XI4vvvgCy5YtQ0xMDPz9/ZGYmIjh4WHxjM2WLVvwwgsvID4+HmFhYVAqlYiOjr5jvwcPHsRTTz2F1NRULF++HMnJybh27RoAwNPTE7m5ucjMzISbmxs2bdoEAMjLy0NWVhYKCgrg7++PyMhINDQ0wMfHB8Ctupbjx4+jrq4OK1asQHFxMXbt2jWr8T7xxBNIT0/Hpk2bcP/996O9vR1ZWVmT2mk0GsTExOCxxx7DI488gqCgILNp2UlJSSgpKUFpaSkCAwMRHh6OsrIyMVbGLIVA01XDMcYYY4xZCD5DwxhjjDGLxwkNY4wxxiweJzSMMcYYs3ic0DDGGGPM4nFCwxhjjDGLxwkNY4wxxiweJzSMMcYYs3ic0DDGGGPM4nFCwxhjjDGLxwkNY4wxxiweJzSMMcYYs3j/AVJpDxOMM/7lAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_models = len(best_models_class)\n", + "fig, ax = plt.subplots(num_models, 1, figsize=(12, 10), sharex=False, sharey=False)\n", + "for index, key in enumerate(best_models_class.keys()):\n", + " c_matrix = best_models_class[key][\"Confusion_matrix\"]\n", + " disp = ConfusionMatrixDisplay(\n", + " confusion_matrix=c_matrix, display_labels=['United States of America', 'United Kingdom', 'India', 'Japan', 'Hong Kong', 'China', 'Germany', 'France', 'Spain']\n", + " ).plot(ax=ax.flat[index])\n", + " disp.ax_.set_title(key)\n", + "\n", + "plt.subplots_adjust(top=1, bottom=0, hspace=0.4, wspace=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_, ax = plt.subplots(3, 2, figsize=(12, 10), sharex=False, sharey=False)\n", + "ax = ax.flatten()\n", + "\n", + "for index, (name, model) in enumerate(best_models_reg.items()):\n", + " model_pipeline = model['pipeline']\n", + " y_pred_reg = model_pipeline.predict(X_test_reg)\n", + "\n", + " # График фактических значений против предсказанных значений\n", + " ax[index * 2].scatter(y_test_reg, y_pred_reg, alpha=0.5)\n", + " ax[index * 2].plot([min(y_test_reg), max(y_test_reg)], [min(y_test_reg), max(y_test_reg)], color='red', linestyle='--')\n", + " ax[index * 2].set_xlabel('Actual Values')\n", + " ax[index * 2].set_ylabel('Predicted Values')\n", + " ax[index * 2].set_title(f'{name}: Actual vs Predicted')\n", + "\n", + " # График остатков\n", + " residuals = y_test_reg - y_pred_reg\n", + " ax[index * 2 + 1].scatter(y_pred_reg, residuals, alpha=0.5)\n", + " ax[index * 2 + 1].axhline(y=0, color='red', linestyle='--')\n", + " ax[index * 2 + 1].set_xlabel('Predicted Values')\n", + " ax[index * 2 + 1].set_ylabel('Residuals')\n", + " ax[index * 2 + 1].set_title(f'{name}: Residuals vs Predicted')\n", + "\n", + "\n", + "plt.subplots_adjust(top=1, bottom=0, hspace=0.4, wspace=0.1)\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "aimvenv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}