{ "cells": [ { "cell_type": "code", "execution_count": 79, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "RangeIndex: 162313 entries, 0 to 162312\n", "Data columns (total 5 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 category 162313 non-null object \n", " 1 sub_category 162313 non-null object \n", " 2 href 162313 non-null object \n", " 3 items 162280 non-null object \n", " 4 price 162282 non-null float64\n", "dtypes: float64(1), object(4)\n", "memory usage: 6.2+ MB\n" ] } ], "source": [ "import pandas as pd\n", "import seaborn as sns\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('/mnt/c/3curse/mii/AIM-PIbd-31-Medvedkov-A-D/data/jio_mart_items.csv')\n", "df.info()\n", "df = df.sample(n=10000 , random_state=42)" ] }, { "cell_type": "code", "execution_count": 80, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['Dining' 'Toys, Games & Fitness' 'Fragrances' 'Bags & Travel Luggage'\n", " 'Girls' 'Home Decor' 'Boys' 'Stationery' 'Beverages' 'Staples' 'Men'\n", " 'Mobiles & Tablets' 'Personal Care' 'Dairy & Bakery' 'Mom & Baby Care'\n", " 'Snacks & Branded Foods' 'Women' 'Books' 'Auto Care' 'Electrical'\n", " 'Furnishing' 'Accessories' 'Pets' 'Home Care' 'Mops, Brushes & Scrubs'\n", " 'Furniture' 'Computers' 'Kitchen Appliances' 'Home Appliances' 'Cameras'\n", " 'Make-Up' 'Garden & Outdoor' 'Disposables' 'Carpentry & work accessories'\n", " 'Mom & Baby' 'Kitchenware' 'Power & Hand Tools' 'Pooja Needs'\n", " 'Bathroom & Laundry Accessories' 'Office Products' 'TV & Speaker'\n", " 'Personal Care & Grooming' 'Hair' 'Skin Care'\n", " 'Paint, Wall Treatments & Supplies' 'Industrial & Scientific Supplies'\n", " 'Infants' 'Kitchen & Bath Fixtures' 'Home Safety & Automation'\n", " 'Fine Jewellery' 'Fruits & Vegetables' 'Apparel' 'Premium Fruits'\n", " 'Phones' 'Bathroom & Laundry' 'Junior Boys' 'Tools & Appliances'\n", " 'Smart Devices' \"Men's Grooming\" 'Gaming' 'Health Care Devices'\n", " 'Handloom & Handicraft' 'Hardware & Plumbing' 'Wellness' 'Treatments']\n" ] } ], "source": [ "print(df['sub_category'].unique())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Как бизнес-цели выделим следующие 2 варианта:\n", " 1) Регрессия - предсказание цены по категории (для аналитических систем или улучшения алгоритмов ценообразования)\n", " 2) Классификация - определение категории продукта по его подкатегории (для логистических или аналитических систем)\n", " \n", "Однако данный датасет весьма плоо подходит для подобных задач." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Выполним подготовку данных" ] }, { "cell_type": "code", "execution_count": 81, "metadata": {}, "outputs": [], "source": [ "# df.fillna({\"category\": \"NaN\", \"sub_category\": \"NaN\", \"href\" : \"NaN\", \"items\" : \"NaN\", \"price\" : \"NaN\" }, inplace=True)\n", "df = df.dropna()\n", "data = df.copy()\n", "\n", "value_counts = data[\"category\"].value_counts()\n", "rare = value_counts[value_counts < 100].index\n", "data = data[~data[\"category\"].isin(rare)]\n", "\n", "data1 = pd.get_dummies(data, columns=['category', 'sub_category'], drop_first=True)\n", "\n", "# label_encoder = LabelEncoder()\n", "# data1['sub_category'] = label_encoder.fit_transform(data['sub_category'])\n", "# data1['category'] = label_encoder.fit_transform(data['category'])\n", "# data1['items'] = label_encoder.fit_transform(data['items'])\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Определить достижимый уровень качества модели для каждой задачи. На основе имеющихся данных уровень качества моделей регрессии будет низким, поскольку цена слабо коррелирует с категорией (кроме некоторых исключений)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Построим конвейер." ] }, { "cell_type": "code", "execution_count": 82, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Index(['href', 'items', 'price', 'category_Electronics', 'category_Fashion',\n", " 'category_Groceries', 'category_Home & Kitchen', 'sub_category_Apparel',\n", " 'sub_category_Auto Care', 'sub_category_Bags & Travel Luggage',\n", " 'sub_category_Bathroom & Laundry',\n", " 'sub_category_Bathroom & Laundry Accessories', 'sub_category_Beverages',\n", " 'sub_category_Books', 'sub_category_Boys', 'sub_category_Cameras',\n", " 'sub_category_Carpentry & work accessories', 'sub_category_Computers',\n", " 'sub_category_Dairy & Bakery', 'sub_category_Dining',\n", " 'sub_category_Disposables', 'sub_category_Electrical',\n", " 'sub_category_Fragrances', 'sub_category_Fruits & Vegetables',\n", " 'sub_category_Furnishing', 'sub_category_Furniture',\n", " 'sub_category_Gaming', 'sub_category_Garden & Outdoor',\n", " 'sub_category_Girls', 'sub_category_Hair',\n", " 'sub_category_Handloom & Handicraft',\n", " 'sub_category_Hardware & Plumbing', 'sub_category_Health Care Devices',\n", " 'sub_category_Home Appliances', 'sub_category_Home Care',\n", " 'sub_category_Home Decor', 'sub_category_Home Safety & Automation',\n", " 'sub_category_Industrial & Scientific Supplies', 'sub_category_Infants',\n", " 'sub_category_Junior Boys', 'sub_category_Kitchen & Bath Fixtures',\n", " 'sub_category_Kitchen Appliances', 'sub_category_Kitchenware',\n", " 'sub_category_Make-Up', 'sub_category_Men',\n", " 'sub_category_Men's Grooming', 'sub_category_Mobiles & Tablets',\n", " 'sub_category_Mom & Baby', 'sub_category_Mom & Baby Care',\n", " 'sub_category_Mops, Brushes & Scrubs', 'sub_category_Office Products',\n", " 'sub_category_Paint, Wall Treatments & Supplies',\n", " 'sub_category_Personal Care', 'sub_category_Personal Care & Grooming',\n", " 'sub_category_Pets', 'sub_category_Phones', 'sub_category_Pooja Needs',\n", " 'sub_category_Power & Hand Tools', 'sub_category_Premium Fruits',\n", " 'sub_category_Skin Care', 'sub_category_Smart Devices',\n", " 'sub_category_Snacks & Branded Foods', 'sub_category_Staples',\n", " 'sub_category_Stationery', 'sub_category_TV & Speaker',\n", " 'sub_category_Tools & Appliances', 'sub_category_Toys, Games & Fitness',\n", " 'sub_category_Wellness', 'sub_category_Women'],\n", " dtype='object')\n", "\n", "Index: 9995 entries, 52893 to 146053\n", "Data columns (total 69 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 href 9995 non-null object \n", " 1 items 9995 non-null object \n", " 2 price 9995 non-null float64\n", " 3 category_Electronics 9995 non-null bool \n", " 4 category_Fashion 9995 non-null bool \n", " 5 category_Groceries 9995 non-null bool \n", " 6 category_Home & Kitchen 9995 non-null bool \n", " 7 sub_category_Apparel 9995 non-null bool \n", " 8 sub_category_Auto Care 9995 non-null bool \n", " 9 sub_category_Bags & Travel Luggage 9995 non-null bool \n", " 10 sub_category_Bathroom & Laundry 9995 non-null bool \n", " 11 sub_category_Bathroom & Laundry Accessories 9995 non-null bool \n", " 12 sub_category_Beverages 9995 non-null bool \n", " 13 sub_category_Books 9995 non-null bool \n", " 14 sub_category_Boys 9995 non-null bool \n", " 15 sub_category_Cameras 9995 non-null bool \n", " 16 sub_category_Carpentry & work accessories 9995 non-null bool \n", " 17 sub_category_Computers 9995 non-null bool \n", " 18 sub_category_Dairy & Bakery 9995 non-null bool \n", " 19 sub_category_Dining 9995 non-null bool \n", " 20 sub_category_Disposables 9995 non-null bool \n", " 21 sub_category_Electrical 9995 non-null bool \n", " 22 sub_category_Fragrances 9995 non-null bool \n", " 23 sub_category_Fruits & Vegetables 9995 non-null bool \n", " 24 sub_category_Furnishing 9995 non-null bool \n", " 25 sub_category_Furniture 9995 non-null bool \n", " 26 sub_category_Gaming 9995 non-null bool \n", " 27 sub_category_Garden & Outdoor 9995 non-null bool \n", " 28 sub_category_Girls 9995 non-null bool \n", " 29 sub_category_Hair 9995 non-null bool \n", " 30 sub_category_Handloom & Handicraft 9995 non-null bool \n", " 31 sub_category_Hardware & Plumbing 9995 non-null bool \n", " 32 sub_category_Health Care Devices 9995 non-null bool \n", " 33 sub_category_Home Appliances 9995 non-null bool \n", " 34 sub_category_Home Care 9995 non-null bool \n", " 35 sub_category_Home Decor 9995 non-null bool \n", " 36 sub_category_Home Safety & Automation 9995 non-null bool \n", " 37 sub_category_Industrial & Scientific Supplies 9995 non-null bool \n", " 38 sub_category_Infants 9995 non-null bool \n", " 39 sub_category_Junior Boys 9995 non-null bool \n", " 40 sub_category_Kitchen & Bath Fixtures 9995 non-null bool \n", " 41 sub_category_Kitchen Appliances 9995 non-null bool \n", " 42 sub_category_Kitchenware 9995 non-null bool \n", " 43 sub_category_Make-Up 9995 non-null bool \n", " 44 sub_category_Men 9995 non-null bool \n", " 45 sub_category_Men's Grooming 9995 non-null bool \n", " 46 sub_category_Mobiles & Tablets 9995 non-null bool \n", " 47 sub_category_Mom & Baby 9995 non-null bool \n", " 48 sub_category_Mom & Baby Care 9995 non-null bool \n", " 49 sub_category_Mops, Brushes & Scrubs 9995 non-null bool \n", " 50 sub_category_Office Products 9995 non-null bool \n", " 51 sub_category_Paint, Wall Treatments & Supplies 9995 non-null bool \n", " 52 sub_category_Personal Care 9995 non-null bool \n", " 53 sub_category_Personal Care & Grooming 9995 non-null bool \n", " 54 sub_category_Pets 9995 non-null bool \n", " 55 sub_category_Phones 9995 non-null bool \n", " 56 sub_category_Pooja Needs 9995 non-null bool \n", " 57 sub_category_Power & Hand Tools 9995 non-null bool \n", " 58 sub_category_Premium Fruits 9995 non-null bool \n", " 59 sub_category_Skin Care 9995 non-null bool \n", " 60 sub_category_Smart Devices 9995 non-null bool \n", " 61 sub_category_Snacks & Branded Foods 9995 non-null bool \n", " 62 sub_category_Staples 9995 non-null bool \n", " 63 sub_category_Stationery 9995 non-null bool \n", " 64 sub_category_TV & Speaker 9995 non-null bool \n", " 65 sub_category_Tools & Appliances 9995 non-null bool \n", " 66 sub_category_Toys, Games & Fitness 9995 non-null bool \n", " 67 sub_category_Wellness 9995 non-null bool \n", " 68 sub_category_Women 9995 non-null bool \n", "dtypes: bool(66), float64(1), object(2)\n", "memory usage: 956.6+ KB\n" ] } ], "source": [ "print(data1.columns)\n", "data1.info()" ] }, { "cell_type": "code", "execution_count": 83, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Best parameters for Linear Regression: {}\n", "Best parameters for Random Forest Regressor: {'model__max_depth': None, 'model__n_estimators': 300}\n", "Best parameters for Gradient Boosting Regressor: {'model__learning_rate': 0.01, 'model__max_depth': 7, 'model__n_estimators': 300}\n", "Model: Linear Regression\n", "Model: Random Forest Regressor\n", "Model: Gradient Boosting Regressor\n" ] } ], "source": [ "X_reg = data1.drop(['href', 'items', 'price'], axis=1)\n", "y_reg = data1['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": 84, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy: 0.991495747873937\n", "Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 0.99 0.90 0.94 131\n", " 1 0.99 1.00 0.99 241\n", " 2 1.00 1.00 1.00 307\n", " 3 0.98 1.00 0.99 573\n", " 4 1.00 1.00 1.00 747\n", "\n", " accuracy 0.99 1999\n", " macro avg 0.99 0.98 0.98 1999\n", "weighted avg 0.99 0.99 0.99 1999\n", "\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Кодирование категориальных данных\n", "label_encoder = LabelEncoder()\n", "data['sub_category_encoded'] = label_encoder.fit_transform(data['sub_category'])\n", "\n", "# Определение признаков (X) и целевой переменной (y)\n", "X = data[['sub_category_encoded']] # Используем закодированный sub_category\n", "y = label_encoder.fit_transform(data['category']) # Кодируем category\n", "\n", "# Разделение данных на тренировочную и тестовую выборки\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n", "\n", "# Создание и обучение модели\n", "classifier = RandomForestClassifier(random_state=42, n_estimators=100, max_depth=10)\n", "classifier.fit(X_train, y_train)\n", "\n", "# Предсказание на тестовых данных\n", "y_pred = classifier.predict(X_test)\n", "\n", "# Оценка качества модели\n", "print(\"Accuracy:\", accuracy_score(y_test, y_pred))\n", "print(\"Classification Report:\\n\", classification_report(y_test, y_pred))\n", "\n", "# Матрица ошибок\n", "cm = confusion_matrix(y_test, y_pred)\n", "plt.figure(figsize=(10, 8))\n", "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=label_encoder.classes_, yticklabels=label_encoder.classes_)\n", "plt.xlabel('Predicted')\n", "plt.ylabel('Actual')\n", "plt.title('Confusion Matrix')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Модель классификации показывает неплохие результаты, что логично, учитывая структуру датасета." ] }, { "cell_type": "code", "execution_count": 85, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABBgAAAQ9CAYAAADzgP7sAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xl4TGf7wPHvTJKZyR5bNoKI2IOi0thbqahU3xS1176W2mpt7bW0VJUWqbbo22qLVr39oSqCKlK7Ei0VtZNYk5F9mfP7Y5rDSJCQ3f25rnPJOeeZc+4zk3hm7nnO/WgURVEQQgghhBBCCCGEeALawg5ACCGEEEIIIYQQxZ8kGIQQQgghhBBCCPHEJMEghBBCCCGEEEKIJyYJBiGEEEIIIYQQQjwxSTAIIYQQQgghhBDiiUmCQQghhBBCCCGEEE9MEgxCCCGEEEIIIYR4YpJgEEIIIYQQQgghxBOTBIMQQgghhBBCCCGemCQYRJFy7tw5NBoNq1atKuxQxBPo06cPlStXLuwwSgyNRsP06dMLO4xC16pVK1q1aqWuF8X/L+6PUYiipij+3Yjck37WbPr06Wg0mhy1LYi+VPqAnJM+veSSBIMoMKtWrUKj0XDw4MHCDiXfZHZ0mYuNjQ2VK1dmxIgRxMbGFnZ4Ali6dCkajQZ/f//HPsaVK1eYPn06R48ezbvAiridO3dm+d2uUqUKvXr14p9//ins8HJl7969TJ8+Xf4mRYkj/WxsYYf31Mr83ctcrK2tKV++PH369OHy5cuFHZ64j/TpIj9ZF3YAQtyrUqVKJCUlYWNjU9ihPJFly5bh4OBAQkIC4eHhfPzxxxw+fJjdu3cXdmgF4rPPPsNkMhV2GNlavXo1lStXZv/+/URFRVG1atVcH+PKlSvMmDGDypUrU79+/bwPsggbMWIEzz77LGlpaRw+fJjly5ezadMmjh8/jqenZ4HG8rj/X+zdu5cZM2bQp08fXFxc8ic4IYoo6WdLhqLaz86cORNvb2+Sk5P5/fffWbVqFbt37yYyMhKDwZDn55s8eTITJ07M8+M+LaRPF/lBRjCIIkWj0WAwGLCysirsUB4oMTHxkW06depEz549GTx4MGvXrqVLly7s2bOH/fv3F0CEd5lMJpKTkwv0nAA2Njbo9foCP++jnD17lr179/Lhhx9Srlw5Vq9eXdghFTvNmzenZ8+e9O3bl48//pgPPviAW7du8eWXXz7wMQkJCfkSS3H4/0KIoqY4/N1IP/toRbWffemll+jZsycDBgzg888/Z+zYsZw5c4affvopX85nbW2dL4mLp4X06SI/SIJBFCnZ3X/Vp08fHBwcuHz5MiEhITg4OFCuXDnGjh1LRkaGxeNNJhMfffQRtWvXxmAw4ObmxuDBg7l9+7ZFu//9738EBwfj6emJXq/Hx8eHd999N8vxWrVqRZ06dTh06BAtWrTAzs6Ot99+O9fX1bx5cwDOnDljsX3fvn20bdsWZ2dn7OzsaNmyJXv27Mny+J07d9KoUSMMBgM+Pj58+umn2d53qNFoGD58OKtXr6Z27dro9Xq2bNkCwOXLl+nXrx9ubm7o9Xpq167NihUrspzr448/pnbt2tjZ2VGqVCkaNWrEN998o+6/c+cOo0aNonLlyuj1elxdXXnxxRc5fPiw2ia7e0MTEhJ466238PLyQq/XU716dT744AMURcn2GjZs2ECdOnXUWDOv414nT57kwoUL2T3l2Vq9ejWlSpUiODiYTp06PTDBEBsby+jRo9VrrFChAr169eLGjRvs3LmTZ599FoC+ffuqwwszf2crV65Mnz59shzz/vv4UlNTmTp1Kg0bNsTZ2Rl7e3uaN2/Ojh07cnw9mWJiYrC2tmbGjBlZ9p06dQqNRsMnn3wCQFpaGjNmzMDX1xeDwUCZMmVo1qwZYWFhuT4vwAsvvACYkzdwd/jyn3/+Sffu3SlVqhTNmjVT23/99dc0bNgQW1tbSpcuTdeuXbl48WKW4y5fvhwfHx9sbW1p3Lgxv/32W5Y2D7pf8+TJk3Tu3Jly5cpha2tL9erVeeedd9T4xo0bB4C3t7f6+p07dy5fYhSiqJF+VvrZ/Oxn7/eg1+XkyZN06tSJ0qVLYzAYaNSoUZYkRE76q+xeo5SUFEaPHk25cuVwdHTklVde4dKlS1lie1Adi+yOuXLlSl544QVcXV3R6/XUqlWLZcuW5eg5eNTrfT/p01dZbJc+vfiRWyREsZCRkUFQUBD+/v588MEHbNu2jQULFuDj48PQoUPVdoMHD2bVqlX07duXESNGcPbsWT755BOOHDnCnj171GFXq1atwsHBgTFjxuDg4MD27duZOnUqRqOR+fPnW5z75s2bvPTSS3Tt2pWePXvi5uaW6/gz/6MrVaqUum379u289NJLNGzYkGnTpqHVatUO7LfffqNx48YAHDlyhLZt2+Lh4cGMGTPIyMhg5syZlCtXLttzbd++nbVr1zJ8+HDKli1L5cqViYmJ4bnnnlPfVJQrV46ff/6Z/v37YzQaGTVqFGAecjlixAg6derEyJEjSU5O5tixY+zbt4/u3bsDMGTIEL7//nuGDx9OrVq1uHnzJrt37+avv/6iQYMG2cakKAqvvPIKO3bsoH///tSvX59ffvmFcePGcfnyZRYuXGjRfvfu3axfv5433ngDR0dHFi9eTMeOHblw4QJlypRR29WsWZOWLVuyc+fOHL0Oq1evpkOHDuh0Orp168ayZcs4cOCAmjAAiI+Pp3nz5vz111/069ePBg0acOPGDX766ScuXbpEzZo1mTlzJlOnTmXQoEHqm6cmTZrkKIZMRqORzz//nG7dujFw4EDu3LnDF198QVBQEPv378/VrRdubm60bNmStWvXMm3aNIt9a9aswcrKitdeew0wd8Zz585lwIABNG7cGKPRyMGDBzl8+DAvvvhirq4B7r5pvPd1AXjttdfw9fVlzpw56pvb2bNnM2XKFDp37syAAQO4fv06H3/8MS1atODIkSPq0MYvvviCwYMH06RJE0aNGsU///zDK6+8QunSpfHy8npoPMeOHaN58+bY2NgwaNAgKleuzJkzZ/i///s/Zs+eTYcOHfj777/59ttvWbhwIWXLlgVQ/54KIkYhiiLpZ6WfzYt+9n7ZvS4nTpygadOmlC9fnokTJ2Jvb8/atWsJCQnhhx9+4NVXXwUev78aMGAAX3/9Nd27d6dJkyZs376d4ODgx4o/07Jly6hduzavvPIK1tbW/N///R9vvPEGJpOJYcOGPfBxOXm97yd9+l3SpxdTihAFZOXKlQqgHDhw4IFtzp49qwDKypUr1W29e/dWAGXmzJkWbZ955hmlYcOG6vpvv/2mAMrq1ast2m3ZsiXL9sTExCznHjx4sGJnZ6ckJyer21q2bKkASmhoaI6ucdq0aQqgnDp1Srl+/bpy7tw5ZcWKFYqtra1Srlw5JSEhQVEURTGZTIqvr68SFBSkmEwmi7i8vb2VF198Ud3Wvn17xc7OTrl8+bK67fTp04q1tbVy/58woGi1WuXEiRMW2/v37694eHgoN27csNjetWtXxdnZWX0+/vOf/yi1a9d+6DU6Ozsrw4YNe2ib3r17K5UqVVLXN2zYoADKrFmzLNp16tRJ0Wg0SlRUlMU16HQ6i21//PGHAigff/xxlutt2bLlQ2PJdPDgQQVQwsLCFEUxvwYVKlRQRo4cadFu6tSpCqCsX78+yzEyX6sDBw5k+T3NVKlSJaV3795Ztrds2dIi1vT0dCUlJcWize3btxU3NzelX79+FtsBZdq0aQ+9vk8//VQBlOPHj1tsr1WrlvLCCy+o6/Xq1VOCg4Mfeqzs7NixQwGUFStWKNevX1euXLmibNq0SalcubKi0WjUv+vMv4Fu3bpZPP7cuXOKlZWVMnv2bIvtx48fV6ytrdXtqampiqurq1K/fn2L52f58uVZXu/s/r9o0aKF4ujoqJw/f97iPPf+nc2fP18BlLNnz+Z7jEIUJOlnpZ8trH4283dv27ZtyvXr15WLFy8q33//vVKuXDlFr9crFy9eVNu2bt1a8fPzs/g9MJlMSpMmTRRfX191W076q8zfh0xHjx5VAOWNN96waNe9e/csfen9z+GDjqko2f8+BwUFKVWqVLHYdn9fn5PXOzvSp5tJn148yS0SotgYMmSIxXrz5s0tKt2uW7cOZ2dnXnzxRW7cuKEuDRs2xMHBwWLoua2trfrznTt3uHHjBs2bNycxMZGTJ09anEev19O3b99cxVq9enXKlStH5cqV6devH1WrVuXnn3/Gzs4OgKNHj3L69Gm6d+/OzZs31VgTEhJo3bo1u3btwmQykZGRwbZt2wgJCbEotlO1alVeeumlbM/dsmVLatWqpa4risIPP/xA+/btURTF4rkJCgoiLi5OHXbp4uLCpUuXOHDgwAOvzcXFhX379nHlypUcPx+bN2/GysqKESNGWGx/6623UBSFn3/+2WJ7YGAgPj4+6nrdunVxcnLKUtlYUZRcjV5wc3Pj+eefB8xDRLt06cJ3331nMWT3hx9+oF69euo3KPfK6VRYOWFlZYVOpwPMQ45v3bpFeno6jRo1shgGm1MdOnTA2tqaNWvWqNsiIyP5888/6dKli7rNxcWFEydOcPr06ceKu1+/fpQrVw5PT0+Cg4NJSEjgyy+/pFGjRhbt7v97Xb9+PSaTic6dO1v8Drq7u+Pr66v+fR48eJBr164xZMgQ9fkB81BWZ2fnh8Z2/fp1du3aRb9+/ahYsaLFvpy8dgURoxBFmfSz0s8+ST+bedxy5crh5eVFp06dsLe356effqJChQoA3Lp1i+3bt9O5c2f19+LGjRvcvHmToKAgTp8+rc468Tj91ebNmwGyPA+ZI0ge172/z3Fxcdy4cYOWLVvyzz//EBcX98DH5eT1zo706dKnF2dyi4QoFgwGQ5ahiqVKlbK45/P06dPExcXh6uqa7TGuXbum/nzixAkmT57M9u3bMRqNFu3u7yjKly9v8R9OTvzwww84OTlx/fp1Fi9ezNmzZy06p8yOoHfv3g88RlxcHMnJySQlJWU708GDZj/w9va2WL9+/TqxsbEsX76c5cuXZ/uYzOdmwoQJbNu2jcaNG1O1alXatGlD9+7dadq0qdp23rx59O7dGy8vLxo2bEi7du3o1asXVapUeeC1nD9/Hk9PTxwdHS2216xZU91/r/s7Esj6eudGRkYG3333Hc8//7x6XyGAv78/CxYsIDw8nDZt2gDm4YEdO3Z8rPPk1pdffsmCBQs4efIkaWlp6vb7X8OcKFu2LK1bt2bt2rW8++67gHkopbW1NR06dFDbzZw5k//85z9Uq1aNOnXq0LZtW15//XXq1q2bo/NMnTqV5s2bY2VlRdmyZalZsybW1lm7kvuv4fTp0yiKgq+vb7bHzRxWnfm7cH+7zCm0HibzjXGdOnVydC33K4gYhSiqpJ+VfvZJ+tlMS5YsoVq1asTFxbFixQp27dplUYwyKioKRVGYMmUKU6ZMyfYY165do3z58o/VX50/fx6tVmuRPAFzQupJ7Nmzh2nTphEREZGlCGlcXNwDP4jm5PXOjvTp0qcXZ5JgEMVCTirKmkwmXF1dH1i4L/ONU2xsLC1btsTJyYmZM2fi4+ODwWDg8OHDTJgwIcu0T/e+YcmpFi1aqPeBtW/fHj8/P3r06MGhQ4fQarXqOebPn//Ae+0dHBweqzL1/fFmnqtnz54PfKOV2RHVrFmTU6dOsXHjRrZs2cIPP/zA0qVLmTp1qlpsqHPnzjRv3pwff/yRrVu3Mn/+fN5//33Wr1//wG97cutBr7dyX6GqnNq+fTtXr17lu+++47vvvsuyf/Xq1WqC4Uk9KKuekZFhcV1ff/01ffr0ISQkhHHjxuHq6oqVlRVz587NUgwrp7p27Urfvn05evQo9evXZ+3atbRu3Vr9XQTz7+aZM2f43//+x9atW/n8889ZuHAhoaGhDBgw4JHn8PPzIzAw8JHtsvs91Gg0/Pzzz9m+vg4ODjm4wvxVHGIUIr9IP5tz0s8+WOPGjdVvv0NCQmjWrBndu3fn1KlTODg4qM/V2LFjCQoKyvYYmYmdJ+2vHuVh/fW9zpw5Q+vWralRowYffvghXl5e6HQ6Nm/ezMKFCx86XWhOXu8HkT79yRSHGEsqSTCIEsPHx4dt27bRtGnTh75Z2blzJzdv3mT9+vW0aNFC3X7vN9t5ycHBgWnTptG3b1/Wrl1L165d1cy6k5PTQ/9jd3V1xWAwEBUVlWVfdtuyk1lFOSMjI0ediL29PV26dKFLly6kpqbSoUMHZs+ezaRJk9SpoDw8PHjjjTd44403uHbtGg0aNGD27NkPfONTqVIltm3bxp07dyy+XckcJlupUqUcXcvjWr16Na6urixZsiTLvvXr1/Pjjz8SGhqKra0tPj4+REZGPvR4DxuaV6pUKWJjY7NsP3/+vEUm/Pvvv6dKlSqsX7/e4nj3F3TKjZCQEAYPHqwOqfz777+ZNGlSlnalS5emb9++9O3bl/j4eFq0aMH06dPz5A3bg/j4+KAoCt7e3lSrVu2B7TJ/F06fPq1WswZzpeyzZ89Sr169Bz428/l93NevIGIUojiTfjZ70s9mLzNp/vzzz/PJJ58wceJE9f9pGxubHD1Xue2vKlWqhMlk4syZMxajFk6dOpWl7cP663v93//9HykpKfz0008WIz9yOutTTl7v7EifLn16cSU1GESJ0blzZzIyMtShZPdKT09XO5HMLOa9WfrU1FSWLl2ab7H16NGDChUq8P777wPQsGFDfHx8+OCDD4iPj8/S/vr162qsgYGBbNiwweJezKioqCz3Uz6IlZUVHTt25Icffsj2P+nMc4G5kve9dDodtWrVQlEU0tLSyMjIyDK01dXVFU9PT1JSUh4YQ7t27cjIyFCnVcq0cOFCNBrNY38jk5Pps5KSkli/fj0vv/wynTp1yrIMHz6cO3fuqNNjdezYkT/++IMff/wxy7Eyf2fs7e0Bsn1j4uPjw++//05qaqq6bePGjVmmRMru93Dfvn1ERETk4Mqz5+LiQlBQEGvXruW7775Dp9MREhJi0eb+19jBwYGqVas+9PXLCx06dMDKyooZM2Zk+YZMURQ1rkaNGlGuXDlCQ0MtnsNVq1Zl+3zfq1y5crRo0YIVK1Zk+b2495wPev0KIkYhijPpZ7P3tPezD9OqVSsaN27MRx99RHJyMq6urrRq1YpPP/2Uq1evZmn/sOcqJ/1V5nUuXrzYYvtHH32Upa2Pjw9xcXEcO3ZM3Xb16tUs/X92v89xcXGsXLnygXE86Bruf70fRvp06dOLKxnBIArcihUrsp1reeTIkU903JYtWzJ48GDmzp3L0aNHadOmDTY2Npw+fZp169axaNEiOnXqRJMmTShVqhS9e/dmxIgRaDQavvrqqyceFvgwNjY2jBw5knHjxrFlyxbatm3L559/zksvvUTt2rXp27cv5cuX5/Lly+zYsQMnJyf+7//+DzBPQbR161aaNm3K0KFD1TcQderU4ejRozk6/3vvvceOHTvw9/dn4MCB1KpVi1u3bnH48GG2bdvGrVu3AGjTpg3u7u40bdoUNzc3/vrrLz755BOCg4NxdHQkNjaWChUq0KlTJ+rVq4eDgwPbtm3jwIEDLFiw4IHnb9++Pc8//zzvvPMO586do169emzdupX//e9/jBo1Ksu9kjmVk+mzfvrpJ+7cucMrr7yS7f7nnnuOcuXKsXr1arp06cK4ceP4/vvvee211+jXrx8NGzbk1q1b/PTTT4SGhlKvXj18fHxwcXEhNDQUR0dH7O3t8ff3x9vbmwEDBvD999/Ttm1bOnfuzJkzZ/j666+zXOPLL7/M+vXrefXVVwkODubs2bOEhoZSq1atbN8M51SXLl3o2bMnS5cuJSgoSJ2CKVOtWrVo1aoVDRs2pHTp0hw8eFCdDi0/+fj4MGvWLCZNmsS5c+cICQnB0dGRs2fP8uOPPzJo0CDGjh2LjY0Ns2bNYvDgwbzwwgt06dKFs2fPsnLlyhzdC7l48WKaNWtGgwYNGDRoEN7e3pw7d45Nmzapfy8NGzYE4J133qFr167Y2NjQvn37AotRiPwm/az0swXZzz7KuHHjeO2111i1ahVDhgxhyZIlNGvWDD8/PwYOHEiVKlWIiYkhIiKCS5cu8ccffwCP11/Vr1+fbt26sXTpUuLi4mjSpAnh4eHZjkbp2rUrEyZM4NVXX2XEiBEkJiaybNkyqlWrZlFsuU2bNuh0Otq3b8/gwYOJj4/ns88+w9XVNdskyb0e9Xo/ivTp0qcXS/k4Q4UQFjKnMHrQcvHixQdOn2Vvb5/leNlNI6Qo5mllGjZsqNja2iqOjo6Kn5+fMn78eOXKlStqmz179ijPPfecYmtrq3h6eirjx49XfvnlFwVQduzYobZr2bJlrqYXyozp+vXrWfbFxcUpzs7OFtPdHDlyROnQoYNSpkwZRa/XK5UqVVI6d+6shIeHWzw2PDxceeaZZxSdTqf4+Pgon3/+ufLWW28pBoPBoh3wwKmtYmJilGHDhileXl6KjY2N4u7urrRu3VpZvny52ubTTz9VWrRoocbj4+OjjBs3TomLi1MURVFSUlKUcePGKfXq1VMcHR0Ve3t7pV69esrSpUstzpXd1E937txRRo8erXh6eio2NjaKr6+vMn/+fIuphh52DdlN/0gOpg9q3769YjAY1KnLstOnTx/FxsZGnV7s5s2byvDhw5Xy5csrOp1OqVChgtK7d2+L6cf+97//KbVq1VKnMbv3d3bBggVK+fLlFb1erzRt2lQ5ePBglqmrTCaTMmfOHKVSpUqKXq9XnnnmGWXjxo3ZPnfkYJrKTEajUbG1tVUA5euvv86yf9asWUrjxo0VFxcXxdbWVqlRo4Yye/ZsJTU19aHHzZzSat26dQ9t97C/AUVRlB9++EFp1qyZYm9vr9jb2ys1atRQhg0bppw6dcqi3dKlSxVvb29Fr9crjRo1Unbt2pXlOczu/wtFUZTIyEjl1VdfVVxcXBSDwaBUr15dmTJlikWbd999Vylfvryi1WqzTG+VlzEKUZCkn5V+tjD6WUV5+BSpGRkZio+Pj+Lj46Okp6criqIoZ86cUXr16qW4u7srNjY2Svny5ZWXX35Z+f7779XH5aS/yu53NCkpSRkxYoRSpkwZxd7eXmnfvr1y8eLFbPvSrVu3KnXq1FF0Op1SvXp15euvv872mD/99JNSt25dxWAwKJUrV1bef/99ZcWKFVn6j/v7gEe93o8ifbr06cWRRlHyMZ0shMg3ISEhTzQ1kRBCCCEeTPpZIYTIPanBIEQxkJSUZLF++vRpNm/eTKtWrQonICGEEKIEkX5WCCHyhoxgEKIY8PDwoE+fPlSpUoXz58+zbNkyUlJSOHLkyAPn9xVCCCFEzkg/K4QQeUOKPApRDLRt25Zvv/2W6Oho9Ho9AQEBzJkzR970CCGEEHlA+lkhhMgbMoJBCCGEEEIIIYQQT0xqMAghhBBCCCGEEOKJFWqCYdeuXbRv3x5PT080Gg0bNmyw2K/RaLJd5s+fr7apXLlylv3vvfeexXGOHTtG8+bNMRgMeHl5MW/evCyxrFu3jho1amAwGPDz82Pz5s0W+xVFYerUqXh4eGBra0tgYKBUFRZCCCGEEEIIIf5VqDUYEhISqFevHv369aNDhw5Z9l+9etVi/eeff6Z///507NjRYvvMmTMZOHCguu7o6Kj+bDQaadOmDYGBgYSGhnL8+HH69euHi4sLgwYNAmDv3r1069aNuXPn8vLLL/PNN98QEhLC4cOHqVOnDgDz5s1j8eLFfPnll3h7ezNlyhSCgoL4888/MRgMObpek8nElStXcHR0RKPR5OxJEkIIIYoRRVG4c+cOnp6eaLVFf6Ck9M1CCCFKugLtm5UiAlB+/PHHh7b5z3/+o7zwwgsW2ypVqqQsXLjwgY9ZunSpUqpUKSUlJUXdNmHCBKV69erqeufOnZXg4GCLx/n7+yuDBw9WFEVRTCaT4u7ursyfP1/dHxsbq+j1euXbb7991KWpLl68qACyyCKLLLLIUuKXixcv5rh/LEzSN8siiyyyyPK0LAXRNxebWSRiYmLYtGkTX375ZZZ97733Hu+++y4VK1ake/fujB49Gmtr86VFRETQokULdDqd2j4oKIj333+f27dvU6pUKSIiIhgzZozFMYOCgtRbNs6ePUt0dDSBgYHqfmdnZ/z9/YmIiKBr167ZxpySkkJKSoq6rvxbT/PixYs4OTk93hMhhBBCFGFGoxEvLy+L0YRFWWac0jcLIYQoqQqyby42CYYvv/wSR0fHLLdSjBgxggYNGlC6dGn27t3LpEmTuHr1Kh9++CEA0dHReHt7WzzGzc1N3VeqVCmio6PVbfe2iY6OVtvd+7js2mRn7ty5zJgxI8t2JycneRMjhBCiRCsutxtkxil9sxBCiJKuIPrmYpNgWLFiBT169MhS7+DekQd169ZFp9MxePBg5s6di16vL+gwLUyaNMkivszMkRBCCCGEEEIIUdIU/epLwG+//capU6cYMGDAI9v6+/uTnp7OuXPnAHB3dycmJsaiTea6u7v7Q9vcu//ex2XXJjt6vV79RkS+GRFCCCGEEEIIUZIViwTDF198QcOGDalXr94j2x49ehStVourqysAAQEB7Nq1i7S0NLVNWFgY1atXp1SpUmqb8PBwi+OEhYUREBAAgLe3N+7u7hZtjEYj+/btU9sIIYQQQgghhBBPs0K9RSI+Pp6oqCh1/ezZsxw9epTSpUtTsWJFwPxBft26dSxYsCDL4yMiIti3bx/PP/88jo6OREREMHr0aHr27KkmD7p3786MGTPo378/EyZMIDIykkWLFrFw4UL1OCNHjqRly5YsWLCA4OBgvvvuOw4ePMjy5csB870qo0aNYtasWfj6+qrTVHp6ehISEpKPz5AQQgghhBBCCFE8FGqC4eDBgzz//PPqema9gt69e7Nq1SoAvvvuOxRFoVu3blker9fr+e6775g+fTopKSl4e3szevRoi7oHzs7ObN26lWHDhtGwYUPKli3L1KlTGTRokNqmSZMmfPPNN0yePJm3334bX19fNmzYQJ06ddQ248ePJyEhgUGDBhEbG0uzZs3YsmVLlpoQQgghhBBCiLxjMilcjk0iITUde5015V1s0WqLRyFZIZ42GiVz7kSR74xGI87OzsTFxUk9BiGEECVScevrilu8Qjxtoq7d4ZfIGM5cjyc5PQODtRU+5RwIquNGVdfiMR2uEIWtIPu6YjOLhBBCCCGEEOLpEXXtDiv3nONWQioezgbsdLYkpqYTeSWOK3FJ9G1aWZIMQhQxxaLIoxBCCCHyQWoqJCYWdhRCCJGFyaTwS2QMtxJS8XV1wNFgg5VWg6PBBl9XB24lpLL1RAwmkwzGFqIokQSDEEII8bRRFPj+e6hVC959t7CjEUKILC7HJnHmejwezgY0Gst6CxqNBg9nA1HX4rkcm1RIEQohsiMJBiGEEOJpEhEBTZvCa6/BmTOwZo15JIMQQhQhCanpJKdnYKfL/o5uW50VKekZJKSmF3BkQoiHkQSDEEII8TQ4cwY6d4YmTcxJBjs7mDYNjh0Dna6woxNCCAv2OmsM1lYkPiCBkJSagd7aCvsHJCCEEIVD/iKFEEKIku7776F7d0hLA40G+vWDmTPB07OwIxNCiGyVd7HFp5wDkVficNBbW9wmoSgKV+OS8SvvTHkX20KMUghxP0kwCCGEECVds2bmUQovvADz5kHduoUdkRBCPJRWqyGojhtX4pI4fc1ci8FWZ0VSagZX45Ipba+jTW03tFrNow8mhCgwkmAQQgghShJFgXXrYOdOWLrUvM3dHSIjoXLlwoxMCCFypaqrI32bVuaXyBjOXI8nxpiM3toKv/LOtKntJlNUClEESYJBCCGEKCn27IGxY+H3383rr70Gzz9v/lmSC0KIYqiqqyNVWjlwOTaJhNR07HXWlHexlZELQhRRUuRRCCGEKO6ioqBTJ/OtEL//Dvb2MGMGNG6c60Pt2rWL9u3b4+npiUajYcOGDRb7+/Tpg0ajsVjatm2b5TgDBgzAyckJFxcX+vfvT3x8vMX+Y8eO0bx5cwwGA15eXsybNy/LMdatW0eNGjUwGAz4+fmxefNmi/2KojB16lQ8PDywtbUlMDCQ06dP5/qahRBFm1arwau0HTXcnfAqbSfJBSGKMEkwCCGEEMXVnTswahTUrAk//ABaLQwcCKdPw9Sp5kRDLiUkJFCvXj2WLFnywDZt27bl6tWr6vLtt99maXPy5EnCwsLYuHEju3btYtCgQeo+o9FImzZtqFSpEocOHWL+/PlMnz6d5cuXq2327t1Lt27d6N+/P0eOHCEkJISQkBAiIyPVNvPmzWPx4sWEhoayb98+7O3tCQoKIjk5OdfXLYQQQognp1EURSnsIJ4WRqMRZ2dn4uLicHJyKuxwhBBCFHcpKVCjBpw7By+9ZC7gWKdOnh1eo9Hw448/EhISom7r06cPsbGxWUY2ZDpw4ACNGzdmx44dtGrVCoAtW7bQrl07Ll26hKenJ8uWLeOdd94hOjoa3b9TZE6cOJENGzZw8uRJALp06UJCQgIbN25Uj/3cc89Rv359QkNDURQFT09P3nrrLcaOHQtAXFwcbm5urFq1iq5du+boGqVvFkIIUdIVZF8nIxiEEEKI4kJRYMMGSP93Xni9HkJDYetW2Lw5T5MLD7Nz505cXV2pXr06Q4cO5ebNm+q+/fv3A9CgQQN1W2BgIFqtln379gEQERFBixYt1OQCQFBQEKdOneL27dtqm8DAQIvzBgUFERERAcDZs2eJjo62aOPs7Iy/v7/aJjspKSkYjUaLRQghhBB5QxIMQgghRHHw22/w3HPw6qvwxRd3twcFwYsvFlgYbdu25b///S/h4eG8//77/Prrr7z00ktkZGQAEBMTk+Ux1tbWlC5dmujoaACio6Nxc3OzaJO5/qg29+6/93HZtcnO3LlzcXZ2VhcvL68cX7sQQgghHk5mkRBCCCGKsr//hokT4ccfzev29pCaWmjh3HvrgZ+fH3Xr1sXHx4edO3fSunXrQosrpyZNmsSYMWPUdaPRKEkGIYQQIo/ICAYhhBCiKLpxA0aMgNq1zckFrRYGDzbPGPHmm4UdnapKlSqULVuWqKgoIOuIAoD09HRu3bqFu7s7AO7u7llGOmSuP6rNvfvvfVx2bbKj1+txcnKyWIQQQgiRNyTBIIQQQhRF/frBxx+b6y0EB8OxY+Z6Cw/58FwYLl26xM2bN/Hw8ACg8b9TYx45ckRts337dkwmE/7+/gAEBASwa9cu0tLS1DZhYWFUr16dUqVKqW3Cw8MtzhUWFkZAQAAA3t7euLu7W7QxGo3s27dPbSOEEEKIgiUJBiGEEKIoMJng3ukVp02DBg1g2zbYuNE8kqEAxMfHc/ToUY4ePQqYiykePXqUCxcuEB8fz7hx4/j99985d+4c4eHh/Oc//6Fq1aoEBQUBUL16dQBGjBjB/v372bNnD8OHD6dr1654enoC0L17d3Q6Hf379+fEiROsWbOGRYsWWdy6MHLkSLZs2cKCBQs4efIk06dP5+DBgwwfPhwwz3AxatQoZs2axU8//cTx48fp1asXnp6eFrNeCCGEEKLgSA0GIYQQorD9+iuMHQstWsCCBeZtDRvCwYOg0RRoKAcPHuT5559X1zM/9Pfu3Ztly5Zx7NgxvvzyS2JjY/H09KRNmza8++676PV6i+NUq1aN1q1bo9Vq6dixI4sXL1b3OTs7s3XrVoYNG0bDhg0pW7YsU6dOZdCgQWqbJk2a8M033zB58mTefvttfH192bBhA3XumSlj/PjxJCQkMGjQIGJjY2nWrBlbtmzBYDDk19MjhBBCiIfQKIqiFHYQTwuZa1sIIYSFU6dgwgT43//M62XKwLlz4OBQqGE9ieLW1xW3eIUQQojcKsi+Tm6REEIIIQra9eswfLj5tof//Q+srGDoUDhxolgnF4QQQgjxdJNbJIQQQoiCtGULdOkCRqN5vX17eP99qFmzcOMSQgghhHhChTqCYdeuXbRv3x5PT080Gg0bNmyw2N+nTx80Go3F0rZtW4s2t27dokePHjg5OeHi4kL//v2Jj4+3aHPs2DGaN2+OwWDAy8uLefPmZYll3bp11KhRA4PBgJ+fH5s3b7bYrygKU6dOxcPDA1tbWwIDAzl9+nTePBFCCCGeHvXqQUaGuYDj9u3w00+SXBBCCCFEiVCoCYaEhATq1avHkiVLHtimbdu2XL16VV2+/fZbi/09evTgxIkThIWFsXHjRnbt2mVRJMpoNNKmTRsqVarEoUOHmD9/PtOnT2f58uVqm71799KtWzf69+/PkSNHCAkJISQkhMjISLXNvHnzWLx4MaGhoezbtw97e3uCgoJIvrfitxBCCHG/nTvNdRYyeXhARAQcOAD3FFMUQghRsEwmhYu3EjkZbeTirURMJilNJ8STKjJFHjUaDT/++KPF1FJ9+vQhNjY2y8iGTH/99Re1atXiwIEDNGrUCIAtW7bQrl07Ll26hKenJ8uWLeOdd94hOjoanU4HwMSJE9mwYQMnT54EoEuXLiQkJLBx40b12M899xz169cnNDQURVHw9PTkrbfeYuzYsQDExcXh5ubGqlWr6Nq1a46uUQpJCSHEU+TkSRg/Hv7v/8zr27c/FQmF4tbXFbd4hRB5I+raHX6JjOHM9XiS0zMwWFvhU86BoDpuVHV1LOzwhMhTUuTxHjt37sTV1ZXq1aszdOhQbt68qe6LiIjAxcVFTS4ABAYGotVq2bdvn9qmRYsWanIBICgoiFOnTnH79m21TWBgoMV5g4KCiIiIAMxzgEdHR1u0cXZ2xt/fX22TnZSUFIxGo8UihBCihLt2Dd54A+rUMScXrKxg2DBzQUchhBCFLuraHVbuOUfklThc7GyoUtYBFzsbIq/EsXLPOaKu3SnsEIUotop0gqFt27b897//JTw8nPfff59ff/2Vl156iYyMDACio6NxdXW1eIy1tTWlS5cmOjpabePm5mbRJnP9UW3u3X/v47Jrk525c+fi7OysLl5eXrm6fiGEEMVIcjLMmQNVq8KyZeY6C//5j3lmiE8+gfv6KyGEEAXPZFL4JTKGWwmp+Lo64GiwwUqrwdFgg6+rA7cSUtl6IkZulxDiMRXpWSTuvfXAz8+PunXr4uPjw86dO2ndunUhRpYzkyZNYsyYMeq60WiUJIMQQpRky5fDnTvQqBF88AG0bFnYEQkhhLjH5dgkzlyPx8PZgEajsdin0WjwcDYQdS2ey7FJeJW2K6QohSi+ivQIhvtVqVKFsmXLEhUVBYC7uzvXrl2zaJOens6tW7dwd3dX28TExFi0yVx/VJt799/7uOzaZEev1+Pk5GSxCCGEKEF274b0dPPPBgN8/DGsXg379klyQQghiqCE1HSS0zOw02X/PautzoqU9AwSUtMLODIhSoZilWC4dOkSN2/exMPDA4CAgABiY2M5dOiQ2mb79u2YTCb8/f3VNrt27SItLU1tExYWRvXq1SlVqpTaJjw83OJcYWFhBAQEAODt7Y27u7tFG6PRyL59+9Q2QgghniJ//gkvvwzNm8OKFXe3t28P3buDtlh1r0II8dSw11ljsLYi8QEJhKTUDPTWVtg/IAEhhHi4Qn0HFB8fz9GjRzl69ChgLqZ49OhRLly4QHx8POPGjeP333/n3LlzhIeH85///IeqVasSFBQEQM2aNWnbti0DBw5k//797Nmzh+HDh9O1a1c8PT0B6N69Ozqdjv79+3PixAnWrFnDokWLLG5dGDlyJFu2bGHBggWcPHmS6dOnc/DgQYYPHw6Yh0uNGjWKWbNm8dNPP3H8+HF69eqFp6enxawXQgghSriYGBgyBPz8YNMmsLaGq1cLOyohhBA5VN7FFp9yDlyNS+b+yfQUReFqXDJVXR0o72JbSBEKUbwVamru4MGDPH/PlF2ZH/p79+7NsmXLOHbsGF9++SWxsbF4enrSpk0b3n33XfR6vfqY1atXM3z4cFq3bo1Wq6Vjx44sXrxY3e/s7MzWrVsZNmwYDRs2pGzZskydOpVBgwapbZo0acI333zD5MmTefvtt/H19WXDhg3UqVNHbTN+/HgSEhIYNGgQsbGxNGvWjC1btmAwGPLzKRJCCFEUJCbChx/C++9DfLx526uvwnvvQbVqhRubEEKIHNNqNQTVceNKXBKnr5lrMdjqrEhKzeBqXDKl7XW0qe2GVqt59MGEEFlolPtTdyLfyFzbQghRTHXpAmvXmn9+9llYsMB8e4TIorj1dcUtXiFE3oi6dodfImM4cz2elHTzbRFVXR1oU9uNqq6OhR2eEHmqIPs6ublICCGEyE56uvkWCICxY+HAAfM0lJ07S40FIYQo5qq6OlKllQOXY5NISE3HXmdNeRdbGbkgxBOSBIMQQghxr8hIGD8eateG+fPN2559Fv7++27CQQghRLGn1WpkKkoh8ph8BSOEEEIAREfDoEFQrx78/DOEhkJc3N39klwQQgghhHgoSTAIIYR4uiUkwMyZULUqfPYZmEzQsSMcPgzOzoUdnRBCCCFEsSFfxwghhHh67d5trqmQOdWkv7+5gGPTpoUblxBCCCFEMSQjGIQQQjy9fHzMt0FUrgzffQcREZJcEEIIIYR4TJJgEEII8fQ4fhxmzbq77uEB27bByZPmqSg1Uj1cCCGEEOJxSYJBCCFEyXflCgwYAPXrw5Qp8Ouvd/cFBIBeX2ihCSGEEEKUFJJgEEIIUXLFx8P06eDrC198YS7g2KkTeHkVdmRF1q5du2jfvj2enp5oNBo2bNig7ktLS2PChAn4+flhb2+Pp6cnvXr14sqVK1mO4+zsjEajUZf33nvPYv+xY8do3rw5BoMBLy8v5s2bl+UY69ato0aNGhgMBvz8/Ni8ebPFfkVRmDp1Kh4eHtja2hIYGMjp06fz5okQQgghRK5JgkEIIUTJk5EBn39uTizMmAGJifDcc7BnD6xbB1WqFHaERVZCQgL16tVjyZIlWfYlJiZy+PBhpkyZwuHDh1m/fj2nTp3ilVdeydL2nXfe4erVq+ry5ptvqvuMRiNt2rShUqVKHDp0iPnz5zN9+nSWL1+uttm7dy/dunWjf//+HDlyhJCQEEJCQoiMjFTbzJs3j8WLFxMaGsq+ffuwt7cnKCiI5OTkPH5WhBBCCJETGkVRlMIO4mlhNBpxdnYmLi4OJyenwg5HCCFKruRkqFEDzp83JxPee888ckFqLOSKRqPhxx9/JCQk5IFtDhw4QOPGjTl//jwVK1ZU+7q5c+cyceLEbB+zbNky3nnnHaKjo9HpdABMnDiRDRs2cPLkSQC6dOlCQkICGzduVB/33HPPUb9+fUJDQ1EUBU9PT9566y3Gjh0LQFxcHG5ubqxatYquXbvm6BqlbxZCCFHSFWRfJyMYhBBClAwnTkB6uvlngwE+/NC8/PknvPaaJBfySVxcHBqNBhcXF4vtCxcupEyZMjzzzDPMnz+f9MzXBoiIiKBFixZqcgEgKCiIU6dOcfv2bbVNYGCgxTGDgoKIiIgA4OzZs0RHR1u0cXZ2xt/fX22TnZSUFIxGo8UihBBCiLwhCQYhhBDF2+XL0K8f+PnBypV3t3foAKNHSwHHfJScnMyECRPo1q1blm9EVqxYwY4dOxg8eDBz5sxh/Pjx6r7o6Gjc3Nws2meuR0dHP7TNvfvvfVx2bbIzd+5cnJ2d1cVL6nEIIYQQeca6sAMQQgghHkt8PMyfDx98YK6xAHDsWOHG9BRJS0ujc+fOKIrCsmXLsuxv3rw5Tk5O1K1bF51Ox+DBg5k7dy76Qk74TJo0iTFjxqjrRqNRkgxCCCFEHpERDEIIIYqX9HT47DOoWhVmzjQnF5o0gb174eOPCzu6p0JmcuH8+fOEhYU98n5Of39/0tPTOXfuHADu7u7ExMRYtMlcd3d3f2ibe/ff+7js2mRHr9fj5ORksQghhBAib0iCQQghRPEyeDAMGgQxMeDjA99/D7t3Q0BAYUf2VMhMLpw+fZpt27ZRpkyZRz7m6NGjaLVaXF1dAQgICGDXrl2kpaWpbcLCwqhevTqlSpVS24SHh1scJywsjIB/X2dvb2/c3d0t2hiNRvbt26e2EUIIIUTBkgSDEEKIou/eCY8GD4YyZeCjj8wFHDt2lAKOeSg+Pp6jR49y9OhRwFxM8ejRo1y4cIG0tDQ6derEwYMHWb16NRkZGURHRxMdHU1qaioA+/fvB+D48eP8888/rF69mtGjR9OzZ081edC9e3d0Oh39+/fnxIkTrFmzhkWLFlncujBy5Ei2bNnCggULOHnyJNOnT+fgwYMMHz4cMM9wMWrUKGbNmsVPP/3E8ePH6dWrF56eng+d9UIIIYQQ+UemqSxAMhWWEELk0qVLMHkyuLubp5rMlJQEtraFF1cJtnPnTp5//vks23v37s306dPx9vbO9nE7duygVatW7Nq1i5YtW+Ls7ExKSgre3t68/vrrjBkzxqL+wrFjxxg2bBgHDhygbNmyvPnmm0yYMMHimOvWrWPy5MmcO3cOX19f5s2bR7t27dT9iqIwbdo0li9fTmxsLM2aNWPp0qVUq1Ytx9crfbMQQoiSriD7OkkwFCB5EyOEEDl05w68/755msmkJPNMEJcuQdmyhR2ZeITi1tcVt3iFEEKI3CrIvk5ukRBCCFF0pKfDp5+aCzjOnm1OLjRrBr/+KskFIYQQQogiTqapFEIIUTQcOQI9esBff5nXq1aFefMgJERqLAghhBBCFAMygkEIIUTR4OoK58+bCzguXgwnTsCrr0pyQQghhBCimCjUBMOuXbto3749np6eaDQaNmzYoO5LS0tjwoQJ+Pn5YW9vj6enJ7169eLKlSsWx6hcuTIajcZiee/eQmCYC0k1b94cg8GAl5cX8+bNyxLLunXrqFGjBgaDAT8/PzZv3myxX1EUpk6dioeHB7a2tgQGBnL69Om8ezKEEOJpc/EiLFp0d718ediwAaKi4M03QacrtNCEEEIIIUTuFWqCISEhgXr16rFkyZIs+xITEzl8+DBTpkzh8OHDrF+/nlOnTvHKK69kaTtz5kyuXr2qLm+++aa6z2g00qZNGypVqsShQ4eYP38+06dPZ/ny5WqbvXv30q1bN/r378+RI0cICQkhJCSEyMhItc28efNYvHgxoaGh7Nu3D3t7e4KCgkhOTs7jZ0UIIUo4oxHeeQeqVYNRo8z1FTK9+CK4uBRWZEIIIYQQ4gkUmVkkNBoNP/7440Pnrj5w4ACNGzfm/PnzVKxYETCPYBg1ahSjRo3K9jHLli3jnXfeITo6Gt2/34ZNnDiRDRs2cPLkSQC6dOlCQkICGzduVB/33HPPUb9+fUJDQ1EUBU9PT9566y3Gjh0LQFxcHG5ubqxatYquXbvm6BqlUrUQ4qmWng6ffQbTpsH16+ZtLVqYb4eoV69wYxN5prj1dcUtXiGEECK3ZBaJB4iLi0Oj0eBy37db7733HmXKlOGZZ55h/vz5pKenq/siIiJo0aKFmlwACAoK4tSpU9y+fVttExgYaHHMoKAgIiIiADh79izR0dEWbZydnfH391fbZCclJQWj0WixCCHEU0dR4P/+D/z84I03zMmFatXMt0Ps3CnJBSGEEEKIEqLYzCKRnJzMhAkT6Natm0XWZcSIETRo0IDSpUuzd+9eJk2axNWrV/nwww8BiI6Oxtvb2+JYbm5u6r5SpUoRHR2tbru3TXR0tNru3sdl1yY7c+fOZcaMGY95xUIIUUKkpsLw4XDhgnmqyenTYdAgsLEp7MiEEEIIIUQeKhYJhrS0NDp37oyiKCxbtsxi35gxY9Sf69ati06nY/DgwcydOxe9Xl/QoVqYNGmSRXxGoxEvL69CjEgIIQrIxYvg6QlWVqDXw/z55mkoJ04EZ+fCjk4IIYQQQuSDIn+LRGZy4fz584SFhT3ynhF/f3/S09M5d+4cAO7u7sTExFi0yVx3d3d/aJt799/7uOzaZEev1+Pk5GSxCCFEiRYXB5Mmga8vrFp1d3vnzjB3riQXhBBCCCFKsCKdYMhMLpw+fZpt27ZRpkyZRz7m6NGjaLVaXF1dAQgICGDXrl2kpaWpbcLCwqhevTqlSpVS24SHh1scJywsjICAAAC8vb1xd3e3aGM0Gtm3b5/aRgghnmppabBkCVStCu+9BykpsG1bYUclhBBCCCEKUKHeIhEfH09UVJS6fvbsWY4ePUrp0qXx8PCgU6dOHD58mI0bN5KRkaHWOyhdujQ6nY6IiAj27dvH888/j6OjIxEREYwePZqePXuqyYPu3bszY8YM+vfvz4QJE4iMjGTRokUsXLhQPe/IkSNp2bIlCxYsIDg4mO+++46DBw+qU1lqNBpGjRrFrFmz8PX1xdvbmylTpuDp6fnQWS+EEKLEUxT46ScYPx7+/tu8rUYNmDcPXn65cGMTQgghhBAFqlCnqdy5cyfPP/98lu29e/dm+vTpWYozZtqxYwetWrXi8OHDvPHGG5w8eZKUlBS8vb15/fXXGTNmjEX9hWPHjjFs2DAOHDhA2bJlefPNN5kwYYLFMdetW8fkyZM5d+4cvr6+zJs3j3bt2qn7FUVh2rRpLF++nNjYWJo1a8bSpUupVq1ajq9XpsISQpQ4o0fDRx+Zfy5XDmbOhAEDwLpYlPgR+aC49XXFLV4hhBAitwqyryvUBMPTRt7ECCFKnH374PnnYcwY8ygG+b/tqVfc+rriFq8QQgiRWwXZ1z3xV0xGo5Ht27dTvXp1atasmRcxCSGEKIpiY82FGvV680gFAH9/uHQJSpcu1NCEEEIIIUThy3WRx86dO/PJJ58AkJSURKNGjejcuTN169blhx9+yPMAhRBCFLLUVPj4Y3MBx3nzzMuVK3f3S3JBCCGEEELwGAmGXbt20bx5cwB+/PFHFEUhNjaWxYsXM2vWrDwPUAghRCFRFPjxR6hTB0aMgJs3oWZN+OEH8PAo7OiEEEIIIUQRk+sEQ1xcHKX//bZqy5YtdOzYETs7O4KDgzl9+nSeByiEEKIQnDoFLVpAhw5w+jS4ukJoKBw7BsHBoNEUdoRCCCGEEKKIyXWCwcvLi4iICBISEtiyZQtt2rQB4Pbt2xgMhjwPUAghRCFwcIDDh8HWFiZPhqgoGDxYZocQQgghhBAPlOt3iqNGjaJHjx44ODhQsWJFWrVqBZhvnfDz88vr+IQQQhSE27dhwwbo29e8Xr48rF4NjRpBhQqFGpoQQgghhCgecp1geOONN2jcuDEXL17kxRdfRKs1D4KoUqWK1GAQQojiJjUVli0zzwpx65a5kOO/dXYICSnU0IQQQgghRPGS61skABo1akRwcDCXL18mPT0dgODgYJo2bZqnwQkhhMgnimIu1lirFowaZU4u1KoltRUEu3bton379nh6eqLRaNiwYYPFfkVRmDp1Kh4eHtja2hIYGJhtDaYBAwbg5OSEi4sL/fv3Jz4+3mL/sWPHaN68OQaDAS8vL+bNm5flGOvWraNGjRoYDAb8/PzYvHnzY8UihBBCiIKR6wRDYmIi/fv3x87Ojtq1a3PhwgUA3nzzTd577708D1AIIUQe+/13aNYMOnWCM2fAzQ2WL4c//jBvF0+1hIQE6tWrx5IlS7LdP2/ePBYvXkxoaCj79u3D3t6eoKAgkpOTLdqdPHmSsLAwNm7cyK5duxg0aJC6z2g00qZNGypVqsShQ4eYP38+06dPZ/ny5WqbvXv30q1bN/r378+RI0cICQkhJCSEyMjIXMcihBBCiAKi5NKIESOUhg0bKr/99ptib2+vnDlzRlEURdmwYYNSv3793B7uqRIXF6cASlxcXGGHIoR4WqWmKkrFiooCimJrqyhTpyqK0VjYUYkiClB+/PFHdd1kMinu7u7K/Pnz1W2xsbGKXq9Xvv32W0VRFGX//v0KoOzYsUNt8/PPPysajUa5fPmyoiiKsnTpUqVUqVJKSkqK2mbChAlK9erV1fXOnTsrwcHBFvH4+/srgwcPznEsOSF9sxBCiJKuIPu6XI9g2LBhA5988gnNmjVDc89Q2tq1a3PmzJm8ynsIIYTIK7dvQ0aG+WcbG5g7F/r1M08/OWMGODoWbnyi2Dh79izR0dEEBgaq25ydnfH39yciIgKA/fv3A9CgQQO1TWBgIFqtln379gEQERFBixYt0Ol0apugoCBOnTrF7du31Tb3niezTeZ5chJLdlJSUjAajRaLEEIIIfJGrhMM169fx9XVNcv2hIQEi4SDEEKIQpaSAgsXgo8PrFp1d3v37vDFF+aZIoTIhejoaADc3Nwstru5uan7YmJisjzO2tqa0qVLq22io6OzPca953hQm3v3PyqW7MydOxdnZ2d18fLyesgVCyGEECI3cp1gaNSoEZs2bVLXM5MKn3/+OQEBAXkXmRBCiMejKLBunblo45gx5hEMa9YUdlRCFAmTJk0iLi5OXS5evFjYIQkhhBAlRq6nqZwzZw4vvfQSf/75J+np6SxatIg///yTvXv38uuvv+ZHjEIIIXJq714YOxYyh4i7u8OsWdCnT6GGJUoGd3d3wDxKwcPDQ90eExND/fr1gawjCgDS09O5deuW+nh3d/csIx0y1x/V5t79j4olO3q9Hr1e/8hrFUIIIUTu5XoEQ7NmzTh69Cjp6en4+fmxdetWXF1diYiIoGHDhvkRoxBCiJyYOROaNjUnF+zsYPp0c52F/v3ByqqwoxMlgLe3N+7u7oSHh6vbjEYj+/btU0cxNm7cGIAjR46obbZv347JZMLf3x+AgIAAdu3aRVpamtomLCyM6tWrU6pUKbXNvefJbJN5npzEIoQQQoiClesRDAA+Pj589tlneR2LEEKIJ9GmjTnJ0LevuXijp2dhRySKofj4eKKiotT1s2fPcvToUUqXLk3FihUZNWoUs2bNwtfXF29vb6ZMmYKnpychISEAVK9eHYARI0bw2WefkZaWxvDhw+natSue//5Odu/enRkzZtC/f38mTJhAZGQkixYtYuHChep5R44cScuWLVmwYAHBwcF89913HDx4UJ3KUqPRPDIWIYQQQhSsXCcYLly48ND9FStWfOxghBBC5FBKCnzyifnft982b3vuOTh7FqRonXgCBw8e5Pnnn1fXx4wZA0Dv3r1ZtWoV48ePJyEhgUGDBhEbG0uzZs3YsmULBoPB4jjVqlWjdevWaLVaOnbsyOLFi9V9zs7ObN26lWHDhtGwYUPKli3L1KlTGTRokNqmSZMmfPPNN0yePJm3334bX19fNmzYQJ06ddQ2OY1FCCGEEAVDoyiKkpsHaLXah84WkZE5FZrIwmg04uzsTFxcHE5OToUdjhCiOFIUWLsWJk0yJxP0evj7b5DkrigiiltfV9ziFUIIIXKrIPu6XI9guPeeSoC0tDSOHDnChx9+yOzZs/MsMCGEEPfZvdtcwHHfPvO6hwfMni3TTQohhBBCiCIh1wmGevXqZdnWqFEjPD09mT9/Ph06dMiTwIQQQvzr4kUYNQrWrzev29vDhAnmKSjt7Qs1NCGEEEIIITI9VpHH7FSvXp0DBw7k1eGEEEJk0mjg559Bq4UBA8wFHP+dok8IIYQQQoiiItcJBqPRaLGuKApXr15l+vTp+Pr65llgQgjx1EpONicUXn3VvF6hAnz2GdSvD7VrF2poQgghhBBCPEiuEwwuLi5ZijwqioKXlxffffddngUmhBBPHZMJ1qwxF3A8fx5++w2aNTPv69GjcGMTQgghhBDiEbS5fcCOHTvYvn27uuzcuZM///yTM2fOEBAQkKtj7dq1i/bt2+Pp6YlGo2HDhg0W+xVFYerUqXh4eGBra0tgYCCnT5+2aHPr1i169OiBk5MTLi4u9O/fn/j4eIs2x44do3nz5hgMBry8vJg3b16WWNatW0eNGjUwGAz4+fmxefPmXMcihBCP7bffzNNMdu9uTi6ULw/3jRgTQgghhBCiKMt1gqFly5YWS/PmzalRowbW1rkv55CQkEC9evVYsmRJtvvnzZvH4sWLCQ0NZd++fdjb2xMUFERycrLapkePHpw4cYKwsDA2btzIrl27LObRNhqNtGnThkqVKnHo0CHmz5/P9OnTWb58udpm7969dOvWjf79+3PkyBFCQkIICQkhMjIyV7EIIUSu/f23+VaIFi3gwAFwcIBZs8zb27Ur7OiEEEIIIYTIMY2iKMqjGv300085PuArr7zyeIFoNPz444+EhIQA5hEDnp6evPXWW4wdOxaAuLg43NzcWLVqFV27duWvv/6iVq1aHDhwgEaNGgGwZcsW2rVrx6VLl/D09GTZsmW88847REdHo9PpAJg4cSIbNmzg5MmTAHTp0oWEhAQ2btyoxvPcc89Rv359QkNDcxRLTshc20IICxkZUK0a/PMPWFnBwIEwfTq4uRV2ZEI8tuLW1xW3eIUQQojcKsi+LkfDDjI/9D+KRqMhIyPjSeJRnT17lujoaAIDA9Vtzs7O+Pv7ExERQdeuXYmIiMDFxUVNLgAEBgai1WrZt28fr776KhEREbRo0UJNLgAEBQXx/vvvc/v2bUqVKkVERARjxoyxOH9QUJB6y0ZOYslOSkoKKSkp6vr9BTKFEE+h5GSwsTEnFKyszAmFtWvh/fehVq3Cjk4IIYQQQojHlqNbJEwmU46WvEouAERHRwPgdt83eW5ubuq+6OhoXF1dLfZbW1tTunRpizbZHePeczyozb37HxVLdubOnYuzs7O6eHl5PeKqhRAllskEq1dD9erw3//e3d6zJ/zf/0lyQeSp2NjYwg5BCCGEEE+hXNdgEDk3adIk4uLi1OXixYuFHZIQojD8+is0bmxOJly4AJ9+Cpl3p903K48QufX++++zZs0adb1z586UKVOG8uXL88cffxRiZEIIIYR42uS+MiPm4oy//vorFy5cIDU11WLfiBEj8iQwd3d3AGJiYvDw8FC3x8TEUL9+fbXNtWvXLB6Xnp7OrVu31Me7u7sTExNj0SZz/VFt7t3/qFiyo9fr0ev1ObpeIUQJdPIkTJgAmXVsHB3NU1COGiWJBZFnQkNDWb16NQBhYWGEhYXx888/s3btWsaNG8fWrVsLOUIhhBBCPC1ynWA4cuQI7dq1IzExkYSEBEqXLs2NGzews7PD1dU1zxIM3t7euLu7Ex4ern6INxqN7Nu3j6FDhwIQEBBAbGwshw4domHDhgBs374dk8mEv7+/2uadd94hLS0NGxsbwPwGrHr16pQqVUptEx4ezqhRo9Tzh4WFqdNu5iQWIYSwsHgxjBljLuRoZQWDB8O0aXDfbV1CPKno6Gj1FryNGzfSuXNn2rRpQ+XKldW+UAghhBCiIOT6FonRo0fTvn17bt++ja2tLb///jvnz5+nYcOGfPDBB7k6Vnx8PEePHuXo0aOAuZji0aNHuXDhAhqNhlGjRjFr1ix++uknjh8/Tq9evfD09FSLTtasWZO2bdsycOBA9u/fz549exg+fDhdu3bF09MTgO7du6PT6ejfvz8nTpxgzZo1LFq0yKKo48iRI9myZQsLFizg5MmTTJ8+nYMHDzJ8+HCAHMUihBAWnn3WnFx45RWIjIQlSyS5IPJFqVKl1FvwtmzZohYkVhQlT2sjCSGEEEI8kpJLzs7OysmTJ9Wf//zzT0VRFOX3339Xqlevnqtj7dixQwGyLL1791YURVFMJpMyZcoUxc3NTdHr9Urr1q2VU6dOWRzj5s2bSrdu3RQHBwfFyclJ6du3r3Lnzh2LNn/88YfSrFkzRa/XK+XLl1fee++9LLGsXbtWqVatmqLT6ZTatWsrmzZtstifk1geJS4uTgGUuLi4XD1OCFHEZWQoyn//qygLFlhuP368cOIRT5Vhw4YplSpVUgIDA5UyZcqofeC3336rPPPMMwUeT3Hr64pbvEIIIURuFWRfp1GUzEpjOVOuXDn27t2Lr68v1apV4+OPPyYoKIiTJ0/SsGFDEhIS8jgFUnLIXNtClEA7dsDYsXD4MOj18PffULFiYUclniJpaWksWrSIixcv0qdPH5555hkAFi5ciKOjIwMGDCjQeIpbX1fc4hVCCCFyqyD7ulzXYHjmmWc4cOAAvr6+tGzZkqlTp3Ljxg2++uor6tSpkx8xCiFE0fPXXzB+PGzcaF53coK334Zy5Qo3LvHUsbGxYezYsVm2jx49uhCiEUIIIcTTLMcJhoyMDKysrJgzZw537twBYPbs2fTq1YuhQ4fi6+vLihUr8i1QIYQoEm7cgClT4LPP7hZwHDoUpk6V5IIoMD9lzkySA6+88ko+RiKEEEIIcVeOEwzly5enT58+9OvXj0aNGgHg6urKli1b8i04IYQocpKTYdUqc3LhP/+B99+H6tULOyrxlMlpgWGNRiOFHoUoxkwmhcuxSSSkpmOvs6a8iy1arUxzLIQounKcYBg2bBhffvkl8+fPp0mTJvTv35/OnTtjZ2eXn/EJIUThMplg50544QXzeoUK8PHH4OsLLVsWamji6WUymQo7BCFEPou6dodfImM4cz2e5PQMDNZW+JRzIKiOG1VdHQs7PCGEyFaOp6mcMmUKUVFRhIeHU6VKFYYPH46HhwcDBw5k3759+RmjEEIUjvBwaNgQWreGPXvubh8wQJILQggh8k3UtTus3HOOyCtxuNjZUKWsAy52NkReiWPlnnNEXbtT2CEKIUS2cpxgyNSqVSu+/PJLoqOjWbBgAX/99RcBAQHUrl2bDz/8MD9iFEKIgvXnnxAcDIGBcPSouYDjhQuFHZUQD5SQkMDmzZsJDQ1l8eLFFkt+qFy5MhqNJssybNgwtY2zs7PFviFDhlgc48KFCwQHB2NnZ4erqyvjxo0jPT3dos3OnTtp0KABer2eqlWrsmrVqiyxLFmyhMqVK2MwGPD392f//v35cs1CFBSTSeGXyBhuJaTi6+qAo8EGK60GR4MNvq4O3EpIZeuJGEymXE0EJ4QQBSLX01RmZ9OmTfTq1YvY2Fi51/MhZCosIYq4mBiYNs1cwNFkAmvruwUcy5Yt7OiEyNaRI0do164diYmJJCQkULp0aW7cuKF+cP/nn3/y/JzXr1+36O8jIyN58cUX2bFjBw0aNMDZ2ZnevXvz3nvvqW3s7OzUvi8jI4P69evj7u7O/PnzuXr1Kr169WLgwIHMmTMHgLNnz1KnTh2GDBnCgAEDCA8PZ9SoUWzatImgoCAA1qxZQ69evQgNDcXf35+PPvqIdevWcerUKVxdXXN0LdI3i6Lm4q1EFob9jYudDY4Gmyz77ySnEZuYxugXq+FVuvjeqiz1JYQoOEV6mspMiYmJrF27lpUrV7J79258fHwYN25cXsYmhBAFR1Hg+efN008CvPoqvPceVKtWuHEJ8QijR4+mffv2hIaG4uzszO+//46NjQ09e/Zk5MiR+XLOcvfNmPLee+/h4+NDy5Yt1Zmm7OzscHd3z/bxW7du5c8//2Tbtm24ublRv3593n33XSZMmMD06dPR6XSEhobi7e3NggULAKhZsya7d+9m4cKFaoLhww8/ZODAgfTt2xeA0NBQNm3axIoVK5g4cWK+XLsQ+S0hNZ3k9AzsdLbZ7rfVWRFjTCYhNT3b/cWB1JcQouTK9S0Se/fuZcCAAXh4eDBs2DAqV67Mjh07+Pvvv6UzF0IULxkZ5pEKABoNTJgAzz4Lu3bB+vWSXBDFwtGjR3nrrbfQarVYWVmRkpKCl5cX8+bN4+23387386empvL111/Tr18/NJq73z6uXbuWsmXLUqdOHSZNmkRiYqK6LyIiAj8/P9zc3NRtQUFBGI1GTpw4obYJDAy0OFdQUBARERHqeQ8dOmTRRqvVEhgYqLbJTkpKCkaj0WIRoiix11ljsLYi8QEJhKTUDPTWVtjrHvt7wkIl9SWEKNlynGCYN28eNWvWpHnz5hw/fpz58+cTHR3Nl19+SYsWLfIzRiGEyHthYdCgAfz3v3e3vf46/P47NG9eeHEJkUs2NjZotebu3NXVlQv/1gtxdnbm4sWL+X7+DRs2EBsbS58+fSy2L1++nB07djBp0iS++uorevbsqe6Ljo62SC4A6np0dPRD2xiNRpKSkrhx4wYZGRnZtsk8Rnbmzp2Ls7Ozunh5eeX6moXIT+VdbPEp58DVuGTuv5NZURSuxiVT1dWB8i7Zj3AoyqS+hBAlX45Tn/Pnz6dnz56sW7eOOnXq5GdMQgiRfyIjYdw42LLFvP7BB9C7t3kEgzbXg7qEKHTPPPMMBw4cwNfXl5YtWzJ16lRu3LjBV199VSD99RdffMFLL72Ep6enxfbAwECcnJzw8/PDw8OD1q1bc+bMGXx8fPI9poeZNGkSY8aMUdeNRqMkGUSRotVqCKrjxpW4JE5fi8fD2YCtzoqk1AyuxiVT2l5Hm9puxbJeweXYJM5cN1/TvSOeADQaDR7OBqKuxXM5NqlY15cQ4mmW4wTDlStXsLHJWmhGCCGKhatXzQUcv/jibgHHYcNgyhRzckGIYmrOnDlq3YPZs2fTq1cvhg4diq+vLytWrMjXc58/f55t27axfv36h7bz9/cHICoqCh8fH9zd3bPM9hATEwOg1m1wd3dXt93bxsnJCVtbW6ysrLCyssq2zYNqPwDo9Xr0en3OLlCIQlLV1ZG+TSurdQpijMnora3wK+9Mm9rFt07B01BfQoinXY4TDJJcEEIUW//9L7zxBiQkmNc7doS5c8HXt3DjEiIPNGrUSP3Z1dWVLZmjcwrAypUrcXV1JTg4+KHtjh49CoCHhwcAAQEBzJ49m2vXrqmzPYSFheHk5EStWrXUNps3b7Y4TlhYGAEBAQDodDoaNmxIeHg4ISEhAJhMJsLDwxk+fHheXaIQhaaqqyNVWjmUqJkW7q0vkd0MGcW9voQQ4jGKPAohRLFTtao5ueDvD7t3w/ffS3JBiCdkMplYuXIlvXv3xtr67oeBzGkxjxw5wrlz5/jpp5/o1asXLVq0oG7dugC0adOGWrVq8frrr/PHH3/wyy+/MHnyZIYNG6aOLhgyZAj//PMP48eP5+TJkyxdupS1a9cyevRo9Vxjxozhs88+48svv+Svv/5i6NChJCQkqLNKCFHcabUavErbUcPdCa/SdsU6uQAlu76EEMJM0oNCiJJn61Y4cwaGDjWvN2kCv/0GTZvK7RCixPH29s5yL/O9Mj/w57Vt27Zx4cIF+vXrZ7Fdp9MB8Oqrr5KYmIiXlxcdO3Zk8uTJahsrKys2btzI0KFDCQgIwN7ent69ezNz5ky1jbe3N5s2bWL06NEsWrSIChUq8Pnnn6tTVAJ06dKF69evM3XqVKKjo6lfvz5btmzJUvhRCFE0lOT6EkIIM41yf/pQ5Buj0YizszNxcXE4OTkVdjhClDzHj5sLOP7yCxgM8PffIMXbRAm3aNEii/W0tDSOHDnCli1bGDduXIFPIV3c+rriFq8QJUHUtTtqfYmUdPNtEVVdHQq8voTJpJSoW1CEeJCC7OtyNIIhN3NES+cshChwV67A1KmwcqW5gKONjXn0goNDYUcmRL4bOXJkttuXLFnCwYMHCzgaIYR4tKJQX+LeJEdyegYGayt8yjkQVKf4FtEUoijI0QgGrVb70OGX98rIyHjioEoq+ZZEiDwWH2+eZnL+fEhMNG977TVzAcdCngpPiML2zz//UL9+/Vx9SZAXiltfV9ziFUI8uahrd1i55xy3ElLxcDZgp7MmMTVdvU2jb9PKkmQQJUqRG8GwY8cO9edz584xceJE+vTpo1ZyjoiI4Msvv2Tu3Ln5E6UQQmTn9m14/31ITjbXWfjgA/j3/yUhnnbff/89pUuXLuwwhBCiSDGZFH6JjOFWQiq+rg7ql6iOBhsc9NacvhbP1hMxVCnrILdLCPEYcpRgaNmypfrzzJkz+fDDD+nWrZu67ZVXXsHPz4/ly5fTu3fvvI9SCCEAFAWOHIEGDczrXl4wbx54eJinnpQCjuIp9Mwzz1iMMlQUhejoaK5fv87SpUsLMTIhhCh6Lscmcea6ucDk/SO0NRoNHs4Goq7Fczk2Ca/SdoUUpRDFV65nkYiIiCA0NDTL9kaNGjFgwIA8CUoIIbL44w9zAcewMNizxzxiAeDNNws3LiEKWUhIiMW6VqulXLlytGrViho1ahROUEIIUUQlpKaTnJ6BnS77qTBtdVbEGJNJSE0v4MiEKBlynWDw8vLis88+Y968eRbbP//8c7ykWrsQIq9dvgxTpsCqVeYRDDqdOdmQmWAQ4ik3bdq0wg5BCCGKDXudNQZrKxJT03E02GTZn5RqntXCXpfrj0lCCECb2wcsXLiQjz/+GD8/PwYMGMCAAQOoW7cuH3/8MQsXLszzACtXroxGo8myDBs2DIBWrVpl2TdkyBCLY1y4cIHg4GDs7OxwdXVl3LhxpKdbZiV37txJgwYN0Ov1VK1alVWrVmWJZcmSJVSuXBmDwYC/vz/79+/P8+sVQvzrzh3zzBC+vubZIRQFunaFkyfNM0QI8RQzGo05XoQQQtxV3sUWn3IOXI1L5v5a94qicDUumaquDpR3yX6EgxDi4XKdmmvXrh1///03y5Yt4+TJkwC0b9+eIUOG5MsIhgMHDljMTBEZGcmLL77Ia6+9pm4bOHAgM2fOVNft7O7eL5WRkUFwcDDu7u7s3buXq1ev0qtXL2xsbJgzZw4AZ8+eJTg4mCFDhrB69WrCw8MZMGAAHh4eBAUFAbBmzRrGjBlDaGgo/v7+fPTRRwQFBXHq1ClcXV3z/LqFeKopCrzwAmROsdesmbmAo79/4cYlRBHh4uIiszsJIcRj0Go1BNVx40pcEqevmWsx2OqsSErNUGeRaFPbTQo8CvGYcjRNZVEyatQoNm7cyOnTp9FoNLRq1Yr69evz0UcfZdv+559/5uWXX+bKlSu4ubkBEBoayoQJE7h+/To6nY4JEyawadMmIiMj1cd17dqV2NhYtmzZAoC/vz/PPvssn3zyCQAmkwkvLy/efPNNJk6cmKPYZSosIR4i87+izA9Nq1bB7NnmIo4hIVLAUYh7/Prrr+rPj5rdqaCLLxe3vq64xSuEyBtR1+7wS2QMZ67Hk5Juvi2iqqsDbWq7yRSVosQpctNU3u+3337j008/5Z9//mHdunWUL1+er776Cm9vb5o1a5bXMapSU1P5+uuvGTNmjMU3N6tXr+brr7/G3d2d9u3bM2XKFHUUQ0REBH5+fmpyASAoKIihQ4dy4sQJnnnmGSIiIggMDLQ4V1BQEKNGjVLPe+jQISZNmqTu12q1BAYGEhER8cB4U1JSSElJUddlqKoQD3DkiLmAY69e5gXg9dehe3dzzQUhhAWZ3UkIIZ5MVVdHqrRy4HJsEgmp6djrrCnvYisjF4R4QrmuwfDDDz8QFBSEra0thw8fVj9Ax8XFqbcc5JcNGzYQGxtLnz591G3du3fn66+/ZseOHUyaNImvvvqKnj17qvujo6MtkguAuh4dHf3QNkajkaSkJG7cuEFGRka2bTKPkZ25c+fi7OysLlIEU4j7XLoEvXtDw4YQHg4zZ4LJZN5nZSXJBSFyICIigkaNGmXZ3qhRI6kVJIQQQogClesRDLNmzSI0NJRevXrx3XffqdubNm3KrFmz8jS4+33xxRe89NJLeHp6qtsGDRqk/uzn54eHhwetW7fmzJkz+Pj45Gs8jzJp0iTGjBmjrhuNRkkyCAHmAo7vvw8LFkBysnlbt24wZw5oc533FOKpJrM7CSFE7t17i0RyegYGayt8yjkQVEdukRDiSeQ6wXDq1ClatGiRZbuzszOxsbF5EVO2zp8/z7Zt21i/fv1D2/n/WwQuKioKHx8f3N3ds3yDExMTA4C7u7v6b+a2e9s4OTlha2uLlZUVVlZW2bbJPEZ29Ho9er0+ZxcoxNPif/+DQYPg2jXzevPm5gKOjRsXblxCFFMLFy6kY8eO/Pzzz2ofuH//fk6fPs0PP/xQyNEJIUTRE3XtDiv3nONWQioezgbsdLYkpqYTeSWOK3FJ9G1aWZIMQjymXH9V6O7uTlRUVJbtu3fvpkqVKnkSVHZWrlyJq6srwcHBD2139OhRADw8PAAICAjg+PHjXMv8MAOEhYXh5ORErVq11Dbh4eEWxwkLC1OLZel0Oho2bGjRxmQyER4errYRQuRQ2bLm5IKvL/z4I/z6qyQXhHgCmbM7tW/fnlu3bnHr1i3at2/P33//Tbt27Qo7PCGEKFJMJoVfImO4lZCKr6sDjgYbrLQaHA02+Lo6cCshla0nYjCZilUdfCGKjFyPYBg4cCAjR45kxYoVaDQarly5QkREBGPHjmXKlCn5ESMmk4mVK1fSu3dvrK3vhnzmzBm++eYb2rVrR5kyZTh27BijR4+mRYsW1K1bF4A2bdpQq1YtXn/9debNm0d0dDSTJ09m2LBh6uiCIUOG8MknnzB+/Hj69evH9u3bWbt2LZs2bVLPNWbMGHr37k2jRo1o3LgxH330EQkJCfTt2zdfrlmIEuPwYTh+3FxrAaBpU9i4Edq0ARubwo1NiBLCy8sr3+sgCSFESXA5Nokz183TU94/3a9Go8HD2UDUtXguxybhVdqukKIUovjKdYJh4sSJmEwmWrduTWJiIi1atECv1zN27FjefPPN/IiRbdu2ceHCBfr162exXafTsW3bNvXDvpeXFx07dmTy5MlqGysrKzZu3MjQoUMJCAjA3t6e3r17M3PmTLWNt7c3mzZtYvTo0SxatIgKFSrw+eefExQUpLbp0qUL169fZ+rUqURHR1O/fn22bNmSpfCjEOJfFy/CO+/AV1+BwQCtW0OFCuZ9jxiJJIR4uGPHjlGnTh20Wi3Hjh17aNvMhLsQQghISE0nOT0DO51ttvttdVbEGJNJSE0v4MiEKBk0iqI81vif1NRUoqKiiI+Pp1atWjg4OOR1bCWOzLUtngpGI7z3HixceLeAY48eMG8e3FOgVQjx+LRaLdHR0bi6uqLVatFoNGTXnWs0GjIyMgo0tuLW1xW3eIUQT+birUQWhv2Ni50NjoasIynvJKcRm5jG6BeryQgGUWIUZF+X6xEM/fr1Y9GiRTg6Oqo1DAASEhJ48803WbFiRZ4GKIQoJtLS4LPPYPp0uH7dvK1FC/NMEdlMoSeEeHxnz56lXLly6s9CCCFypryLLT7lHIi8EoeD3triNglFUbgal4xfeWfKu2Q/wkEI8XC5HsFgZWXF1atXcXV1tdh+48YN3N3dSU+X4UQPIt+SiBLt4kWoVs08aqF6dfOIhfbt4b77G4UQJVtx6+uKW7xClBTp6SYOX7zNzYRUytjraOBVCmvrgpmqOnMWiZvxqTgarLHSasgwKdxJTqeMg05mkRAlTpEcwWA0GlEUBUVRuHPnDgaDQd2XkZHB5s2bsyQdhBAl3D//QObsMV5eMGMGODjAwIFSwFGIAvLll19StmxZdZal8ePHs3z5cmrVqsW3335LpUqVCjlCIYSwFP5XDKv2nOPczQTSMkzYWGmpXMaePk0r07pm/tc3q+rqyAs1XFm15xwnrsRZxPBaowqSXBDiCeQ4Teji4kLp0qXRaDRUq1aNUqVKqUvZsmXp168fw4YNy89YhRBFxfnz0LMnVK0KERF3t48fD2+8IckFIQrQnDlzsLU1D+WNiIjgk08+Yd68eZQtW5bRo0cXcnRCCGEp/K8Y5v58kr+v3cHRYE35UrY4Gqz5+9od5v58kvC/YvI9hqhrd9h+8hp2OivqlnemvpcLdcs7Y6ezYvvJa0Rdu5PvMQhRUuU4wbBjxw7Cw8NRFIXvv/+e7du3q8vu3bu5cOEC77zzTn7GKoQobHFxMHGi+RaI1atBUWDnzsKOSoin2sWLF6latSoAGzZsoFOnTgwaNIi5c+fy22+/5cs5p0+fjkajsVhq1Khh0eatt96iTJkyODg40LFjR2JiLD80XLhwgeDgYOzs7HB1dWXcuHFZbrPcuXMnDRo0QK/XU7VqVVatWpUlliVLllC5cmUMBgP+/v7s378/z69XCJE30tNNrNpzjjvJaVQsZYujwQZrrRZHgw0VS9lyJzmNL/eeIz3dlG8xmEwKv0TGcOFWIsakNM7cSCDqejxnbiRgTErjwq1Etp6IwWR6rDr4Qjz1cnyLRMuWLQFzMamKFStmmTdWCFGCpaXBp5+ab4G4ccO8rVUr+OADaNiwUEMT4mnn4ODAzZs3qVixIlu3bmXMmDEAGAwGkpKS8u28tWvXZtu2beq6tbXlW4otW7awbt06nJ2dGT58OB06dGDPnj2A+dbK4OBg3N3d2bt3L1evXqVXr17Y2NgwZ84cwPx+Izg4mCFDhrB69WrCw8MZMGAAHh4e6jTSa9asYcyYMYSGhuLv789HH31EUFAQp06dkts2hSiCDl+8zbmbCZSx16HRaEhJyyBDUbDSaNBZayljr+PsjQQOX7xNY+8y+RLD5dgkjly8zfU7yaRnKDgYrLGxsiYtw8T1+BSstBoOX7jN5dgkmUVCiMeQ61kktm/fjoODA6+99prF9nXr1pGYmEjv3r3zLDghRBERFAQ7dph/rlHDXMDx5ZelgKMQRcCLL77IgAEDeOaZZ/j7779p164dACdOnKBy5cr5dl5ra2vc3d2zbI+LiwNg9uzZvPDCCwCsXLmSmjVr8vvvv/Pcc8+xdetW/vzzT7Zt24abmxv169fn3XffZcKECUyfPh2dTkdoaCje3t4sWLAAgJo1a7J7924WLlyoJhg+/PBDBg4cSN++fQEIDQ1l06ZNrFixgokTJ+bbtQshHs/NhFTSMkyggSuxSSSlmTApClqNBlsbLU52NqRlmLiZkJpvMdxJTuPCzUQyTCbKOOjVL0311lbo7LXcjE/h4q1E7iSn5VsMQpRkuS7VOnfuXMqWLZtlu6urq/qtgxCihHn9dShXDpYtg+PHZXYIIYqQJUuWEBAQwPXr1/nhhx8oU8b8rd+hQ4fo1q1bvp339OnTeHp6UqVKFXr06MGFCxcAOHr0KACtWrVS29aoUYOKFSsS8W/NloiICPz8/HBzu1vMLSgoCKPRyIkTJ9Q2gYGBFucMCgpSj5GamsqhQ4cs2mi1WgIDA9U22UlJScFoNFosQoiCUcZeB8DV2GQSUjOwsTInFmysNCSkZnA1NtmiXX6IT0knKS0DvY1VlhHZGo0GvY0ViakZxKfIzHhCPI5cj2C4cOEC3t7eWbZXqlRJfXMhhCjGzp2Dd96Btm3NiQWAXr2gY0eQKdyEKHJcXFz45JNPsmyfMWNGvp3T39+fVatWUb16da5evcqMGTNo3rw5kZGRXLt2TY3rXm5ubkRHRwMQHR1tkVzI3J+572FtjEYjSUlJ3L59m4yMjGzbnDx58oGxz507N1+fGyHEg9Uv74Le2orbiamUtrNBqzV/wLfSgMFaw63ENJxtbalf3iXfYnAwWGOrsyIlzYSDXrFIMiiKQkqaCTudFQ6GXH9MEkLwGCMYXF1dOXbsWJbtf/zxh/qtiRCiGIqNhQkTzLdAfPMNTJ4MmQXXrKwkuSBEEfbbb7/Rs2dPmjRpwuXLlwH46quv2L17d76c76WXXuK1116jbt26BAUFsXnzZmJjY1m7dm2+nC8vTZo0ibi4OHW5ePFiYYckxFMjJj4FTxcDBmsrjMkZpKSbb5FISTdhTM7AYG2Fh7OBmPgUi8eZTAoXbyVyMtrIxVuJT1SA0VFvQ8XSdlhbabgZn4IxOY34lHSMyWncjE/B2lqLV2k7HPUyI5YQjyPXqblu3boxYsQIHB0dadGiBQC//vorI0eOpGvXrnkeoBAin6WmQmgozJwJN2+at73wgrmAo7Vk74Uo6n744Qdef/11evToweHDh0lJMb8xj4uLY86cOWzevDnfY3BxcaFatWpERUXRpEkTAGJjY3G6JzEZExOj1mxwd3fPMttD5iwT97a5f+aJmJgYnJycsLW1xcrKCisrq2zbZFcbIpNer0ev1z/mlQohnkRCajql7HU09y3LsUtxxCalkZSqYKXVUMZBh195Z7Vdpqhrd/glMoYz1+NJTjcnIXzKORBUx42qro65jqG8iy3PeJXidkIq1+4kcz0+lQyTOQZnW2tc7HQ0qFiK8i62eXbdQjxNcj2C4d1338Xf35/WrVtja2uLra0tbdq04YUXXpAaDEIUNzt2QO3aMHKkOblQqxZs2gTbtsEzzxR2dEKIHJg1axahoaF89tln2Njc/catadOmHD58uEBiiI+P58yZM3h4eFC/fn3A/OVDplOnTnHhwgUCAgIACAgI4Pjx4+rtFABhYWE4OTlRq1YttU14eLjFecLCwtRj6HQ6GjZsaNHGZDIRHh6uthFCFC32OmsM1la4Ohn4T/3ytKntRqvq5WhT243/1CuPm5MBvbUV9jrzFxxR1+6wcs85Iq/E4WJnQ5WyDrjY2RB5JY6Ve84Rde1OrmPQajXU8HAkLjmd1HQFNyc9FcvY4uakJzVdIS45nerujurtG0KI3Mn115M6nY41a9bw7rvv8scff2Bra4ufnx+VKlXKj/iEEPnJxgaiosDNzTyCoV8/GbUgRDFz6tQpdUThvZydnYmNjc2Xc44dO5b27dtTqVIlrly5wrRp07CysqJbt27q6IB33nmHChUq4OTkxJtvvklAQADPPfccAG3atKFWrVq8/vrrzJs3j+joaCZPnsywYcPUxw8ZMoRPPvmE8ePH069fP7Zv387atWvZtGmTGseYMWPo3bs3jRo1onHjxnz00UckJCSos0oIIYqW8i62+JRzIPJKHL6uDpR3uTsNpKIoXI1Lxq+8M+VdbDGZFH6JjOFWQiq+rg5qrQRHgw0OemtOX4tn64kYqpR1yFUywGRSOHn1Dh7OBsrZ67idlEZ6hgkrrZYq5eyxttJyKvoOz1d3lSSDEI/hsT9JVKtWjWrVquVlLEKI/Hb2LBw8CJnTzDZrBqtXm2eFcMz9MEMhROFzd3cnKioqy5SUu3fvpkqVKvlyzkuXLtGtWzdu3rxJuXLlaNasGb///jvlypVTZ2UICgqiY8eOpKSkEBQUxNKlS9XHW1lZsXHjRoYOHUpAQAD29vb07t2bmTNnqm28vb3ZtGkTo0ePZtGiRVSoUIHPP/9cnaISoEuXLly/fp2pU6cSHR1N/fr12bJlS5bCj0KIokGr1RBUx40rcUmcvhaPh7MBW50VSakZXI1LprS9jja13dBqNVy8lciZ6+Y22c324OFsIOpaPJdjk/AqbfeAM2Z1OTaJM9fj8XV1wEFvzZ3kdFIzTOistDgarIlPSX+s4wohzDSKojyySsqYMWN49913sbe3Z8yYMQ9t++GHH+ZZcCWN0WjE2dmZuLg4i/tShch3t2/D7Nnw8cfmgo1//w0VKhR2VEKIPDB37ly+/vprVqxYwYsvvsjmzZs5f/48o0aNYurUqbz55psFGk9x6+uKW7xClAT31lVISc9Ab21FVVcH2tS+W1fhZLSRxeGnqVLWAatsRhKkm0ycu5HAm619qeGe87/d/DquEEVZQfZ1ORrBcOTIEdLS0tSfH+T+7KIQopClpsLSpebbH27fNm8LDITk5MKNSwiRZyZOnIjJZKJ169YkJibSokUL9Ho948aNY8CAAYUdnhBCZFHV1ZEqrRy4HJtEQmo69jpryrvYWtySkFmvITE1HUdD1hkdklIzLOo15FR+HVcIYZajv5wdO3Zk+7MQoohSFFi/3jzt5Jkz5m21a5tnhggKAkkGClFiaDQa3nnnHcaNG0dUVBTx8fHUqlWLTz/9FG9vb6Kjows7RCGEyEKr1Tz0FoR76zU46K0tvsi8v15DbuTXcYUQZrmeRUIIUQxcvQo9epiTC+7u8NlncPQotG0ryQUhSoiUlBQmTZpEo0aNaNq0KZs3b6ZWrVqcOHGC6tWrs2jRIkaPHl3YYQohxGPJrNdQ2l7H6Wvx3ElOI91k4k5yGqevxVvUaygKxxVCmOWoBkOHDh1yfMD169c/UUAlmdznKfLVtWvg6np3/d13ISMDxo4FB4fCi0sIkS8mTJjAp59+SmBgIHv37uX69ev07duX33//nbfffpvXXnsNKyurAo+ruPV1xS1eIZ42OanXUJSOK0RRVORqMDg7O6s/K4rCjz/+iLOzM40aNQLg0KFDxMbG5ioRIYTII7duwaxZsGQJ/Por/DsNHFOmFG5cQoh8tW7dOv773//yyiuvEBkZSd26dUlPT+ePP/6QmkhCiBIjJ/UaHve4lVvYc/jibW4mpFLGXkcDr1JYW8sAbyGeRI4SDCtXrlR/njBhAp07dyY0NFT9ZiQjI4M33nhDMv9CFKSUFHNS4d13IXOu+/Xr7yYYhBAl2qVLl2jYsCEAderUQa/XM3r0aEkuCFGCmExKnn+wLo4eVa/hcURdu8OW49EcvxxHQlo69jbW7C9/i7Z+7jKCQYgnkOvyqCtWrGD37t0Wwy6trKwYM2YMTZo0Yf78+XkaoBDiPooC69bBxIlw9qx5m58fzJ9vLuAohHgqZGRkoNPp1HVra2sc5HYoIUqMe4fwJ6dnYLC2wqecA0F1ZAj/k4q6doePtp3m75g7ZJju3i1+9mYCJ2PuMCrQV55jIR5TrscApaenc/LkySzbT548iclkypOgMk2fPh2NRmOx1KhRQ92fnJzMsGHDKFOmDA4ODnTs2JGYmBiLY1y4cIHg4GDs7OxwdXVl3LhxpKenW7TZuXMnDRo0QK/XU7VqVVatWpUlliVLllC5cmUMBgP+/v7s378/T69ViBx77TXo0sWcXPDwgC++gCNHJLkgxFNGURT69OlDhw4d6NChA8nJyQwZMkRdz1yEEMVP1LU7rNxzjsgrcbjY2VClrAMudjZEXolj5Z5zRF27U9ghFlsmk8I3v1/gj4uxZJgUHA02lLbX4WiwIcOk8MfFWL7ddwGT6ZFl6oQQ2cj1CIa+ffvSv39/zpw5Q+PGjQHYt28f7733Hn379s3zAGvXrs22bdvUdWvruyGPHj2aTZs2sW7dOpydnRk+fDgdOnRgz549gPnbneDgYNzd3dm7dy9Xr16lV69e2NjYMGfOHADOnj1LcHAwQ4YMYfXq1YSHhzNgwAA8PDwI+vcD25o1axgzZgyhoaH4+/vz0UcfERQUxKlTp3C9t6ieEAWhXTvYsgXGj4e33gJ7+8KOSAhRCHr37m2x3rNnz0KKRAiRl0wmhV8iY7iVkIqvq4N625OjwQYHvTWnr8Wz9UQMVco6PDW3S+TlrSIXbyfy+9lbaDUaytjr1OdXb61BZ68jxphCxD+3uHg7kUpl5D2WELmVo1kk7mUymfjggw9YtGgRV69eBcDDw4ORI0fy1ltv5WnF6unTp7NhwwaOHj2aZV9cXBzlypXjm2++oVOnToB5FEXNmjWJiIjgueee4+eff+bll1/mypUruLm5ARAaGsqECRO4fv06Op2OCRMmsGnTJiIjI9Vjd+3aldjYWLZs2QKAv78/zz77LJ988on6HHh5efHmm28yceLEHF+PVKoWuXbzprnGgr8/dOtm3paRAdevm6efFEKIIqa49XXFLV5R8l28lcjCsL9xsbPB0WCTZf+d5DRiE9MY/WK1PK9LUBTl9a0iO09d4+0fj1POQY/eWktquokMRcFKo0FnrSU53cTN+BRmv+pHq+ryRaIoePlRe6XIzSJxL61Wy/jx4xk/fjxGoxEgX4M8ffo0np6eGAwGAgICmDt3LhUrVuTQoUOkpaURGBiotq1RowYVK1ZUEwwRERH4+fmpyQWAoKAghg4dyokTJ3jmmWeIiIiwOEZmm1GjRgGQmprKoUOHmDRpksVzEBgYSERExENjT0lJISUlRV3PfL6EeKTkZPjkE/PsEHFx4OUFHTqAXg9WVpJcEEIIIUqohNR0ktMzsNPZoigKd5LTSc0wobPS4miwxlZnRYwxmYTU9EcfrJjLvFXkVkIqHs4G7HS2JKamE3kljitxSfRtWvmxkgwaBZLT0rkZbyIpLQOToqDVaLC1scJOL7NIiMJTEmqv5DrBAOY6DDt37uTMmTN0794dgCtXruDk5JSnBab8/f1ZtWoV1atX5+rVq8yYMYPmzZsTGRlJdHQ0Op0OFxcXi8e4ubkRHR0NQHR0tEVyIXN/5r6HtTEajSQlJXH79m0yMjKybZNdLYp7zZ07lxkzZuT6usVTTFFgzRqYNAnOnTNvq1sXPvjAnFwQQgghRIlmr7PGYG3FldhEouNSuJWYSrrJhLVWS2k7He7OevTWVtjrHuttfLGRX7eKVClrj0FnxeXYZGy0GnQ2VlhptGQoCgkpacQmKbg5GahSVm6PEAUrvxJqBS3X/zOdP3+etm3bcuHCBVJSUnjxxRdxdHTk/fffJyUlhdDQ0DwL7qWXXlJ/rlu3Lv7+/lSqVIm1a9dia2ubZ+fJL5MmTWLMmDHqutFoxMvLqxAjEkXaoUPwxhuQWUDU0xNmz4bXXzePWhBCCCFEiVfexRYXOxvC/oxBZ6XB0dYGGytr0jJMxBiTuHg7kRdruVHepei/F34Sl2OTOHM9Hg9nQ5bpdzUaDR7OBqKuxXM5NilXt4p4OtviYmvDldgkrO9LTChAhkmhlJ0Nns4l+/kVRUtJqr2S6zFAI0eOpFGjRty+fdviQ/6rr75KeHh4ngZ3PxcXF6pVq0ZUVBTu7u6kpqYSGxtr0SYmJgb3f4ePu7u7Z5lVInP9UW2cnJywtbWlbNmyWFlZZdvG/RHD1PV6PU5OThaLEA+UmGhOLtjbw8yZ8Pff0KePJBeEEEKIp01mhbT7Plhnrhftjxd54+6tItl/H2qrsyIlPSPXt4pcNSZTyl6Hu5MBrVZDSpqJxNR0UtJMaLUa3J0MuNjpuGpMzovLECJHcpNQK+pynWD47bffmDx5ssXc2wCVK1fm8uXLeRZYduLj4zlz5gweHh40bNgQGxsbi6TGqVOnuHDhAgEBAQAEBARw/Phxrl27prYJCwvDycmJWrVqqW3uT4yEhYWpx9DpdDRs2NCijclkIjw8XG0jxGO5cQM2b7673rw5LF0KUVEwZYrMDiGEEEI8hS7HJhGblMazlUvh6qjnTlI6McZk7iSl4+qo59nKpbidmFYsPmg8icxbRRIfkEBISs14rFtFElLT0VlrCfApS3U3R8rY63CytaGMvY7qbo4851MGvbX2qahxIYqO/EqoFYZc3yJhMpnIyMjIsv3SpUs4OubtPSFjx46lffv2VKpUiStXrjBt2jSsrKzo1q0bzs7O9O/fnzFjxlC6dGmcnJx48803CQgI4LnnngOgTZs21KpVi9dff5158+YRHR3N5MmTGTZsGPp/72cfMmQIn3zyCePHj6dfv35s376dtWvXsmnTJjWOMWPG0Lt3bxo1akTjxo356KOPSEhIyJdpOcVTIDkZPv7YfPtDaiqcPg3ly5v3DR1auLEJIYQQolBlftBwsbUBxTyYIXNBAYONFXFJacXig8aTKO9ii085ByKvxOGgt7b4VldRFK7GJeNX3jnXt4pkJi4MNlqerVw6SxHN+BTzaIaSXuNCFC33JtSymz3mcRNqhSHXEbZp04aPPvqI5cuXA+YhG/Hx8UybNo127drlaXCXLl2iW7du3Lx5k3LlytGsWTN+//13ypUrB8DChQvRarV07NiRlJQUgoKCWLp0qfp4KysrNm7cyNChQwkICMDe3p7evXszc+ZMtY23tzebNm1i9OjRLFq0iAoVKvD5558TFBSktunSpQvXr19n6tSpREdHU79+fbZs2ZKl8KMQD2Uy3S3geP68eVv9+uapKDMTDEIIIYR4qtnrrElNN3H4wm3SMxScbK2xsdKSlmHiery56KNXabti8UHjSWi1GoLquHElLonT18xDx211ViSlZnA1LpnS9jra1HbL9f3o9yYufF0dcLK9+2HuSRIXQjyJ/EqoFQaNoijKo5vddfHiRdq2bYuiKJw+fZpGjRpx+vRpypYty65du3B1lfliH0Tm2n6K7doFY8fCgQPm9fLl7xZw1Mp0SEKIkqO49XXFLV5R8qWnm+i76gB/X7tDxVK2aO95n2AymbhwO4nqbo6s6P0s1tYl/z3EvdP2paSbv8Wt6upAm9qPP23f/dX6709cFJdq/aJkyc/fy4Ls63Kd+vTy8uKPP/5gzZo1/PHHH8THx9O/f3969OhRLGZ2EKLAXb8ObdpASgo4OMDEiTB6NNjlvOKxEEIIIZ4OV43J6G20uNjacDsxDQfD3REM8cnpuNjp0FlruWpMztXsCUWNyaRwOTaJhNR07HXWlHexzXY0QlVXR6q0cshR25yq6upI36aV1cRFjDEZvbUVfuWdnyhxIcSTKCm/l7lKMKSlpVGjRg02btxIjx496NGjR37FJUTxFh9vTiYAlCsHb70Ft27B9Okgt9YIIYQQ4gEyixA2rFSaszcSuJ2YSnxKOtZaLa5OBiqVscNYzGswRF27w5bIaI5fjiMxNR07nTV+5Z1pW8c92w9RWq0mz5Mp+ZG4yGs5TcKIkqM4/F4+Sq4SDDY2NiQny5QtQjxQUhIsWgTvvQdbtsC/BUeZNSvrVFNCCCGEEPexLEJYqsQVIYy6doePtp3m7+g7ZCiZ5Ss1nL2ewMnoO4wK9C2wb2rzI3GRV+69NSQ5PQODtRU+5RwIqlN8vskWj6co/17mRK5v3Bo2bBjvv/8+6enFN2sqRJ4zmeDrr6F6dXMRx7g4WLHi7n5JLgghhBAiBzKLvV2NS+b+UmmZxd6qujoUi2Jv9zOZFL7Zd4E/LsaSYTLhaLCmtL0eR4M1GSYTf1yM5Zt9FzCZclUirsTJvBc/8kocLnY2VCnrgIudDZFX4li55xxR1+4UdohCPFCuEwwHDhxg/fr1VKxYkaCgIDp06GCxCPHU2bkTGjc2F2y8eBEqVID//hdCQws7MiGEyBdz587l2WefxdHREVdXV0JCQjh16pRFm+DgYDQajcUyZMgQizYXLlwgODgYOzs7XF1dGTduXJYvMHbu3EmDBg3Q6/VUrVqVVatWZYlnyZIlVK5cGYPBgL+/P/v378/zaxaioGTOnmCl1fDLnzHsOn2d3/+5ya7T1/nlzxistJrHmj2hKLh0O5Hf/7mJlQbKOOjRW1uh1WjQW1tRxkGPVgP7/rnJpduJhR1qoTGZFH6JjOFWQiq+rg44Gmyw0mpwNNjg6+rArYRUtp6IeeqTMKLoyvXYKhcXFzp27JgfsQhR/AweDP9O2Yqjo3n0wqhRIAVPhRAl2K+//sqwYcN49tlnSU9P5+2336ZNmzb8+eefFu0GDhxoMTW03T3FbTMyMggODsbd3Z29e/dy9epVevXqhY2NDXPmzAHg7NmzBAcHM2TIEFavXk14eDgDBgzAw8NDnU56zZo1jBkzhtDQUPz9/fnoo48ICgri1KlTMrOVKP7+/QypQUFBo64XV//cSCAuMY0yjjqLafgANBoNznY23IxP5Z8bCVQsY19IURauy7FJnLlunpYzu+fIw9lA1LV4LscmFeth9KLkynWCYeXKlfkRhxDFU+PG8MUX5kTDtGkgb2aFEE+BLVu2WKyvWrUKV1dXDh06RP369dXtdnZ2uLu7Z3uMrVu38ueff7Jt2zbc3NyoX78+7777LhMmTGD69OnodDpCQ0Px9vZmwYIFANSsWZPdu3ezcOFCNcHw4YcfMnDgQPr27QtAaGgomzZtYsWKFUycODHLeVNSUkhJSVHXjUbjEz0XQuS1zG+wM0wKQbXdiE/JUGswOOitiLqewNYTMVQp61AsRzEoGtDwoLiL3/XktYTUdJLTM7DTZf9lla3OihhjcrEu8ilKthzfImEymXj//fdp2rQpzz77LBMnTiQpKSk/YxOiaElKgrlzYd26u9v69IE//4QlSyS5IIR4asXFxQFQunRpi+2rV6+mbNmy1KlTh0mTJpGYeHfYc0REBH5+frjdM7NOUFAQRqOREydOqG0CAwMtjhkUFERERAQAqampHDp0yKKNVqslMDBQbXO/uXPn4uzsrC5eXl5PcOVC5L17v8HWarU42dpQ1kGPk60NWq3W4hvs4sa7rD0utjpiE9OyrS8Rl5iGs60O77JP5+gFuFvkMzE1HUVRMCalcSM+BWOS+TlLSs1Ab21VbIt8ipIvx7+Zs2fPZvr06QQGBmJra8uiRYu4du0aK+4tZCdESWQywerV8M475hoLXl7w8svm2yCsrKBatcKOUAghCo3JZGLUqFE0bdqUOnXqqCMCOnXqRI0aNfD09OTYsWNMmDCBU6dOsX79egCio6MtkguAuh4dHf3QNkajkaSkJG7fvk1GRka2bU6ePJltvJMmTWLMmDHqutFolCSDKFJK8jfYXqXseM67NGF/xXAzIRVHgzU2VlrSMkzcSU7HpCgEVCmNV6mnd+h/ZpHP3/+5SbrJxO3ENNIzTFhbaSllZ4O1VkuAT5liWeRTPB1ynGD473//y9KlSxk8eDAA27ZtIzg4mM8//xytNte1IoUoHrZvh7Fj4cgR83rFijBnDuj1hRuXEEIUEcOGDSMyMpLdu3dbbO/bty9OTk4A+Pn54eHhQevWrTlz5gw+Pj6FESoAer0evfwfLoqwe7/BdjTYZNlfnL/B1mo1dH+uItfiU/g75g53ku8mSay0Gup5udDNv2KxvPUjr2i1Gmp4OPLj0cvcSU6jjL0OZzsbklIz+OdGAo4GG6q7Oz7Vz5Eo2nKcGbhw4QLt2rVT1wMDA9FoNFy5ciVfAhOiUP39N7RvD61bm5MLTk7w3ntw8iT06AGSVBNCCIYPH87GjRvZsWMHFSpUeGhbf39/AKKiogBwd3cnJibGok3membdhge1cXJywtbWlrJly2JlZZVtmwfVfhAiv5hMyv+zd99hUlTZw8e/1blnenImDkmCJAFBVJKiiKzKrgExgbBGWMUMrooZc1hXxd+7Cu6uOaELiCJBQTAgIJKDDHESE3tCx7rvH80000xmZpjg+TzPPDDVt6tuddX0rTp177kcyC1he0YhB3JLTjjLf2uephKga2IEM0Z346K+KbSNthNlN9M22s7FfdswY3Q3uiZGNHUVm5SuK7anO0mJstE5LhxdQWGpF11B5/hwUqJs7MhwyiwSotmqdejT5/Nhs9lClpnNZrxeb4NXSogml54OCxeCyQS33AIPPggJCU1dKyGEaBaUUvztb3/js88+Y+XKlXTq1KnG92zcuBGAlJQUAIYOHcoTTzxBVlZWcLaHpUuXEhkZSa9evYJlFi9eHLKepUuXMnToUAAsFgsDBw5k2bJljB8/HggM2Vi2bBnTp09viF0VolZ2Zzn5anMme7KLcPn82ExGuiQ4OO/UROxmE8UeH+EWE22j7TU+eS6bpvJwQSm7sgK5GOwWI6UeP+kFLmLDLS12msryNDTsZiM6CrvZ2NTVaTbKcnB0S3TgsJpwunzBJJ8RNhNFbp/MIiGatVoHGJRSTJ48OaRbocvl4uabbyY8/FgilrKxlUK0KCUlsG4dDB8e+H3ECHj6aRg/XnIsCCHEcaZNm8a7777L559/TkRERDBnQlRUVLDMM888w5///Gfi4uLYtGkTd9xxB8OHD6dv374AnH/++fTq1Ytrr72WZ555hoyMDB544AGmTZsWvNa4+eab+ec//8m9997LlClTWL58OR9++CGLFi0KbufOO+9k0qRJDBo0iMGDB/PSSy9RXFwcnFVCiMa2O8vJvO/TyC32kBJlI8xip8Tj44ffc/h6awYJEVYsJkMw6DCmd1KNT+m7JkZw/VmpwaBFZqELq8lIn7ZRnH9qze9vzsp/Xm1j7IRZTJR4fGxJLyS90MX1Z6WetP3z+XTWH8gjp9hDXLiFAe1jMJmatpdq+RwcmqYRaQ8dJtOSc3CIP4ZaBxgmTZpUYdk111zToJUR4qTTdfjPfwIJHPPyYNcuaNMm8Nq99zZt3YQQopl6/fXXARg5cmTI8nnz5vGXv/wFgJUrV/L6669TXFxM+/btufTSS3nggQeCZY1GIwsXLuSWW25h6NChhIeHM2nSJB599NFgmU6dOrFo0SLuuOMOXn75Zdq1a8e//vWv4BSVABMmTCA7O5uHHnqIjIwM+vfvz5IlSyokfhSiMZRNKZlb7KFbogNNC/Qq8PoVeSUesovcmIwaZ3SKo9TrZ/PhAg4XlIbcROu64lB+aYVeDl0TI+g80lHpay1VVZ9XhM2Mw2piV1bRSZuCc9m2TOZ/n0ZaTjFev47ZaCA1LpzJZ6Vybs+m+/5ozTk4xB+Dpo4f3CUaTWFhIVFRURQUFAQTX4kmtGxZIIHj0W67dOwI770HR7veCiGEqLuW1ta1tPqK5uVAbgkvLt1JdJg5eDOolOLntDyynS7CrUbcPsXQznFE2s0opdiVVUSftlHcPKILvx8pqnRoRW16ObRElX1e5TldXvJLvNxx3imN2v1/2bZM5ny5PZhEsWwISmBmCzOzxvZosiCDriteX7mHzYcLQoIwQIXzpyUHm8TJdTLbOslUJ/54tmyBceNg9OhAcCEqCp59NpDAUYILQgghhKilY93Zjz1Ndrp85JV4cNjMWExG/LqOx68DoGkaKVE2dmcV8f2eI8z7Po3NhwuIDjPTOd5BdJiZzYcLmPd9GruznE21W42mss+rPLvFiNvnb9Tu/z6fzvzv03C6vHSIsRNhC0z9GGEz0yHGjtPl5e01afh8eqPVoTplOThiwy3syirC6fLi03WcLi+7sopaTQ4O0XpJ3xrxx5KfD4MHB3IumEwwbVoggWNcXFPXTAghhBAtTGXd2T1+HZ9fx2wz4fH58etQ5PIFk/TZLUYyCkpZtq3moQKpseGkHx1v3xqGSDSH7v/rD+SRllNMXLgFw3GzghkMBuLCLew9Usz6A3kM7tQ014etOQeHaP0kwNCC+Xw66/bnsjPTSbE7EOkNs5iICbfQOSGcKJslpCGqaoxfY6rLNsvKOl1eitw+HDYTDosJBZR6/bWus64rDuSVsPdIMQCdI820S4oOvC86OhBU+P13mDMHunUDmmeSn6bQFOeIEEII0VKVTSm5+XABDqsJTdOwGA2YjAacpV6ynG4MBo0thwswGQ3EhFlIibLi1yG9wEXbaHtIF3g41sth/f48nvlqB0eK3K1m+ETbaDud48P5eV8ubaPtWE1GImyBz61sCs4+baMadQrOnGIPXr+O3VL5zBV2i5HcYg85xZ5Gq0NttMYcHOKPQQIMLdSybZm8tmI3OzKdFLv9lE+kYdQCEfCeKRGc3TWBMb0DY8hO9hi/qqZsqmybZWU3HMhjf04JpV4/RoOGUQOr2US8w0K8w1pjnXdnOXn3h/38sDeXwuJSxq5fSu9v3uatB//ByGvHBd731FNQLmLdXJP8nGx1OV5CCCGEqGpKSQMGDfbmlGA2arSJDHTD9/oVWU4XB/NKGNQxBpdPr3KogMvrZ2emE5fXzylJEcGZKSpLEtmS/H6kiCNFLnZkONl4IJ9wi5F2MXbaxYRR6tVPSvf/uHALZqOBUo8fh1XD49PxK4VR07CYAsvNxkBPhqZmMGgyFaVocSTA0AIt25bJI//bSmahC69f5/gsnX4VSJKz+VAhHp/OtozCwHJdhUyf1JiNVFVTNlW2zbKy+3NLyHa68Os6FpNGltONUhBp09E0iHdYqq3z7iwnL32zi18P5DN41y9M//INOh3eA0DH//w/Xko5hRmju4W8r6okPzuznMz5cjvAHyLIUJfjJYQQonLSC+yP6fju7C6vD7dPx2wyEGUzYTOXPSlXcDS3usmoYcNQ6VABpRQ7Mpz4/IquCY7g600x00JD2p3l5LGFW9l8qJBSjw+vX6fI7eNIkYe0nBIu6tuGiUM6NPr1xoD2MaTGhbM1vZACkweXT6ErhUHTsJk0XD7FqW0iGdA+plHrIURrJQGGFsbn05m3ei85RW5QOnoVc4AoBS6fn6xCFwWlHgyagTGnJgXHmjVmI1WXKYgg0LMip8iDz6fj8yviHFYO57swahqaQcOggcvjI6PQzcAO0ezOLq5QZ11XLPktA8/GX3n+i7kM3vETAEVhEXw6dhLvDvoTekbgCX3nkYH3HZ/k59hnYyDcYmR/Xilvr0ljRLeEVj1cojlNGSWEEC2V9AL7YyvfnX1PdhHv/bSfvm2jyChwkel049N1TAYDSZE2UqJs+PyKhAgrB/JKg0MryhSWekkvcJESbSPSHhp80DSN5Egrvx7M57td2XRJcLSIQJauK15bsZt1aXkAhFlNmA0aLp+Oy+unyOUnt9gTvDZsTCaTgfNPTeLXg/kUufzYzEZMRg2fX+eIy4/VbOS8Xkmt+tpPiMYkAYYWZv2BPPZkF2HQqDK4EKQUOcUeosPM2C0aRW4/kfZjX5blMxkfyi9tsC5YZY1rSpStynGFZdsE2JNdRKTNRFpOMQ6bCY9Pp9Qb+IIHKPXqRNjN5BZ7KHL7K63zofxSurz0JLcs+jdGpeMzmvhqxKV8euFkihxR2Hx+nC4fmw7lB9/XEpL8nAx1OV7STU8IISqSXmACjnVnL/b4MBo07BYTaKABqKP/AlazkcJSL4M6xVLsyS43tCLQi3J3dhEmo0b3pMBUcoWlXjx+HYvRgNevszuriAN5Jfxr9e8kOmwtIpC1P7eYVbuOoJQiym4OBkTCLEZsJgP5pV6+33OE/bnFpFYSZGjI3kG6rigs9dEu1s6hnBKKPT6UAk2DcIuRtrF2nC4fuq6afeBGiOZIAgwtTE6xJzjVkaopwAD4lcKvQEMF31ee3WIk82h24oZybAqiyhP0HL9Nl89PpM2MT9cxG024vH50pTBqBkDhPdptze334/HrRIeZK9S52OPjUGwyRqWzdsAo3ht/C5mJ7YKvm42BdZV4jk191FKS/DS2uh4vIYQQx0gvMHH8zW+Y2YjHp/PLvlz8uiLCbsZs1PD6FdlON7nFHtrHhtEzOZLO8eEVZgro1SYSm9mIy+tjXVoxuSUefLqOX1eUuP0YDWC3mOgc58Bk1FpEIOvntDyK3D7CLMYKfwcGg0aYxYjT5ePntLwKAYaG7h10KL+UDQfy8PsVsQ4L0Tr4URjRMBjA71es35/XLB6syLAr0RI1674/c+bM4fTTTyciIoLExETGjx/Pjh07QsqMHDkSTdNCfm6++eaQMvv372fcuHGEhYWRmJjIPffcg88XerO0cuVKBgwYgNVqpWvXrsyfP79CfV599VVSU1Ox2WwMGTKEn376qcH3uSZx4RYsxsBh02rx/WLUAokSFVrwfeU1xnRA5acgqkz5bZaV1XWFyRCIzBs1DYOmHQuOaBq6CrxuOZqUx2aAxA/fgQULgtv8ZeQl3Hrbazw95bGQ4AKA168DgQasbF/LJ/mpqp7NJclPY6rL8RJCCBGqrr32ROuyO8vJ6yv38OLSnfxj2S5eXLqTzzccIq/YQ36pl5gwMyiFy+sHpYgJM5Nf6sXj00mJtNE1MYJbRnbhjvNO4W/nduOO807h3vN70CE2jJ/T8sgsLMVmNhBjt+Dy+IMzbUXYTESHmYmwmemW6CC32MPXWzLRa+ze2jRcXj9KBa5LyygFPr8K5BNTgdwTLm/oNVlZ76DNhwuIDjPTOd5BdJiZzYcLmPd9GruznHWui9PtZX9uCSVuPx6fTqHLR2Gpj0KXD49Pp8Tt50BuCU63t977XR+VnVuvr9xzQvssxMnUrAMM3377LdOmTeOHH35g6dKleL1ezj//fIqLi0PK3XDDDaSnpwd/nnnmmeBrfr+fcePG4fF4WLNmDW+//Tbz58/noYceCpbZu3cv48aNY9SoUWzcuJEZM2bw17/+la+++ipY5oMPPuDOO+9k9uzZrF+/nn79+jFmzBiysrIa/4MoZ0D7GLokONAV1BjA1DTiwi2EWYwYNQ2HNfRJfdl0QF0THQ06HVDZlE3pBS7Ucd0sjt9mWdlCl48YuzkwT7TJgN1sxO0NfPHbzQY8Xj+x4RYcViPRq1Zw/9+vIvb2W+H228EVmObp1A5x7E7thdPlDdmuUgpnqRejptG3bXRwX8uS/OQUe9D10N4duq6TU+yhU3x4q0/yU5fjJYQQItSxXmCVB2HtFiNun196gbVCVd38rtufR0ahC5NBY8+RYvbllnAwr5R9uSXsOVKM3WzEYjKQXugCjg2t6JEcSfvYsMAT6rLm+OgNudvnp9QbSBwJGm6fzpFiN4WlgZvg5h7I6pbkCMzQcDTQ4PUrnC4vhS4vhaU+Ckq9KKWF9Co9vndQhM2M0aDVO6hS5PJRWOqlwOUlp9hDkdtLidtHkTvwe4HLS0GplyJX0/3NNkZgRYiTpVk/klyyZEnI7/PnzycxMZFffvmF4cOHB5eHhYWRnJxc6Tq+/vprtm7dyjfffENSUhL9+/fnscce47777uPhhx/GYrEwd+5cOnXqxPPPPw9Az549Wb16NS+++CJjxowB4IUXXuCGG27g+uuvB2Du3LksWrSIt956i5kzZzbG7lfKZDJw/dmd2H90FgkDOhUHPgTaI5vJSGKkjZSjN4a7s4tDxvilF7gaZTqgyqdsqnqbZWXLxizmFLmxmjUKXAqlK3RlxGYxcVrePsa+cge9fvshsKGYGJgxAwwGDAaNC/oksz3Tya8H8sksdBMVZgYUBSVedAX92kQwpvex7ZpMBiaflcqcL7ezP680ZBaJnGIPkTYzk85MbfVJfup6vIQQQhxTvhfY8bMBgPQCa62qGxrTNtrO5kOFKBXoPanrCoVCQwtMwW0ITI1YFnQ6vhu8rhT5pV5OT40hvcBNXomHEo8Pn64TbjHi1xWH8kop8fiwm03EhllIjQ8LCWS5XD4+WL+fQ3ku2sbYmDCgAzZb052DgzrE0i3Rwdb0QpwuLz5dBR+W6SpwJWu3GPklLY/+7aPpmhjRaDmiwixGSj2BGSxCYhMKvLrC4/dh0AK9XpuCDLsSLV2Lau0KCgoAiI2NDVn+zjvv8N///pfk5GQuuugiHnzwQcLCAl80a9eupU+fPiQlHZtqcMyYMdxyyy1s2bKF0047jbVr1zJ69OiQdY4ZM4YZM2YA4PF4+OWXX5g1a1bwdYPBwOjRo1m7dm2V9XW73bjd7uDvhYWFJ7bjxymbNvG1FbvZkemkxO0PCTIYtcCXUM+UCIZ1S+D8UwPljx/j16dtFOef2jhJgY6fsqm6bZYvu+FAHvtzSyj1+IkLt2LUIKUknxs+msew7xdiUAplNqP97W/w979DuXOha2IEM0Z3490f9vPD3tzATBtAtN3MkM5xXFXJ1Edln+X879NIyykmt9iD2Wige1IEk85M/UNMUQl1O15CCCGOKesFtvlwQYXZAMp6gfVpGyW9wFqZym5+lVI4XT6K3IFggNvnJ8pmxqcr/DpHcycYKfX4yClyE2Y2VppfINJu4kiRm77tomkTZWfPkSKOFLkp9QR6dkLgQZLDGsjtkOV0kVPspn1sGOEWE89/vYN/r9lHkdsbvIl/4evdXHdmR+46v3uTfF4mk4FbR3Xlkf9tCfSY1BUGA+hKQxHoZTusWxz5pd7gzXNj5Ygqcvtw+/zB4IJ29Ecd/dFVYEhHkbtpejCUP7cgNMlnhM0kybf/AHw+nfUH8sgp9hAXbmFA+5gW9cCzxQQYdF1nxowZnHXWWfTu3Tu4/KqrrqJjx460adOGTZs2cd9997Fjxw4+/fRTADIyMkKCC0Dw94yMjGrLFBYWUlpaSl5eHn6/v9Iy27dvr7LOc+bM4ZFHHjnxna7GuT2TGNEtgXX7c9mZ6aT46JdgmMVETLiFzgnhRNksIclgyqZPOlmJYspP2VTTNsuXLRtf6LCZcFhMWFZ/R/Ls/wGgLrsc7ak50KVLldt84E+9OJBXwt4jgaE0nePDaRcTVuW+ln2WLfkPuSHU5XgJIYQIkF5gf0zH3/zmFLvZcrCA9AIXLp+PIlfgBjbH78FkCCSa9usaR5xujAYDdouJvTmBabePn31kT3YRB3JL8Pp1DuaWkFfiPRqwCNwRR9qMmIxGzAYNq8mIOUxjf14pST6d93/ax/+t2otPV1gMGkYD+HUodHuZ++0egCYLMpzbM4kjRW6e+2oHxW4fikBOhthwC/07RNMp3oHT5Q3ePDdW76CiUl8w8XngyBwbkWIAdAK5u4pKmybAUHZuubxGtqXnkVfiwefXMRkNxFTSW0W0Lsu2ZQYffHr9OmajgdS4cCaf1XIefLaYAMO0adPYvHkzq1evDll+4403Bv/fp08fUlJSOPfcc9mzZw9dqrgJPVlmzZrFnXfeGfy9sLCQ9u3bN9j6TSYDZ3SO54zO8bUqXzbG72SqyzaDZX0+2LQJBgwIvHDJ2EBvhXHj0IYOrdV6OsaF0zEuvNb1NJkMrXoqytpqinNECCFaOukF9sdT/uY32+li5Y5sitx+js8G4NPBoOmYDQZ0Ajf7ul+nxO1j2basSrvB920bxa7MIn5OywVFSHBKAQUuP2EWxZEiF0aDAZPBQHSYBaMG/1m7D5+uCDNpwSm4jQYw6TolPsV/1u5j2vAuTTZcol/7aAZ2jCHMbMLl9xNmNpISZQvWtXyvhFMSIxqld9DvR4qD04ZqWmhOM6VAU4F/fz9SXOU6GlO4xRQyC4nDZsZsMx2dhcRFbrneKqJ1WbYtkzlfbsfp8oYM3d6Z5WTOl4GH2i0hyNAizszp06ezcOFCvvvuO9q1a1dt2SFDhgCwe/duunTpQnJycoXZHjIzMwGCeRuSk5ODy8qXiYyMxG63YzQaMRqNlZapKvcDgNVqxWq11m4nReDbfMkSuOce2LsXdu2CNm0Crz3+eNPWTQghhKiG9AL7YykbGrN8eyabDxXg9ledaNDjB5+uYzJo2MwG/LqiyOVj75Eiuh0NPpXvBh9uMeLy+vHpR2cDM2igFD6OPWkv8eiUeAJDQa1GjT7tosh0uily+7EYjwUXyhgMBiwGHafLywfr9zPpzM6N8bHUKNxiIsxSNgNGxQca5XslNFbvIJvFgKYR/FwVRwMLR4MNBkMgb4bN0jQ9WVMibbi9OvmlXjrE2IPH0mrSMIeZg71VUiJtTVI/0Th8Pp3536fhdIUe9whb4Dthf14pb69JY0S3hGbfy7pZ104pxfTp0/nss89Yvnw5nTp1qvE9GzduBCAlJQWAoUOH8ttvv4XM9rB06VIiIyPp1atXsMyyZctC1rN06VKGHn1abrFYGDhwYEgZXddZtmxZsIyop40b4fzz4cILYcsWsNlg69amrpUQQghRa5XOBiBaJYNBo1uig52ZzmqDC2V0BT5d4fPrgRtYpSj1+HF5dX5Oy2Pt7zn8+HsOa3/PYfmOLJwuL0YNrKaj0zkqKiT1NmlgMQZmZNh0sICsQndg2EEVV/dGQ6Aeh/Jc9d7/E1XXmavKegf1bhNFfomXtCPF5Jd46dM2iuvPSj2h3kGnJEVgNxuDvUOMBg3T0X/LZvCwm42cktQ0PY/SC11YzQZiwszkFnsoPDp0uNDlJbfYQ7TdHDILiWgd1h/IIy2nmLhwS6UBwrhwC3uPFLP+QF4T1bD2mnUPhmnTpvHuu+/y+eefExEREcyZEBUVhd1uZ8+ePbz77rtceOGFxMXFsWnTJu644w6GDx9O3759ATj//PPp1asX1157Lc888wwZGRk88MADTJs2Ldi74Oabb+af//wn9957L1OmTGH58uV8+OGHLFq0KFiXO++8k0mTJjFo0CAGDx7MSy+9RHFxcXBWCXGCDh2CBx6At98OtKAWC9x2G9x/f2CWCCGEEEKIZmZ7eiHPLd2O0+2v9Xt0BaU+hVkPTGvq01Wl3eAP5pXg1QMBBNDw6wpdVQxiBIIJBkyaTqlfUXR0TH5ZQsnj+fXAE/q2MU335PtEeiU0dO+gQR1i6Z4cwaZDBfj8CqUCn2VwyIRBo0dKBIM6xNa0qkZR7AlM2d4lwcFvBwvILirFryuMBo1ou5keKY5gOdF65BR78Pr1kKlay7NbjOQWe8gp9pzkmtVdsw4wvP766wCMHDkyZPm8efOYPHkyFouFb775Jniz3759ey699FIeeOCBYFmj0cjChQu55ZZbGDp0KOHh4UyaNIlHH300WKZTp04sWrSIO+64g5dffpl27drxr3/9KzhFJcCECRPIzs7moYceIiMjg/79+7NkyZIKiR9FHRQVQZ8+kHc0EnfllfDkk1CLnipCCCGEEE1h2bZMHv3iN/bluWsuXAmfDpqmMBm0SrvBOyxGjhDoteDzVjYZeYBfQalXRyMwg5jSFTazhsunMOl6yFNQXdfx6Ioom5kJAzqcUL0bSud4Bxf0TuabrRnszipCV4pwi4m+7aIY0zu50l4JDZkjymQyMP60tmzPcFLq92MwBAILSoGug9Vo4JL+bZusG3pZDoYDuSWYTQbaRdvRDKB0cPt1dmcVSQ6GVigu3ILZaKDU4yfCVvHcK/X4MRsDPRmau2Z9Zh7fdep47du359tvv61xPR07dmTx4sXVlhk5ciQbNmyotsz06dOZPn16jdsT1dB1KGvwHA6YOhV++AGeew6O5s8QQgghhGiOdmYW8uCC3zhccGLBBQg8LXd5FT5dERNmJq/Ei8Nmwmw04PXrwekT67I+XYGmFKd3jOXHvXmU+BQWgx6cRcKjK8wGjWuHdmyyBI8Au7OcLPktg7W/53Agt5hitx+LyUDbGHud9/tE6bqisNRHj+QIMgtLyS/xBXoIGDWiw8wkRdpwunzoumqSYU5V5WAACNd1ycHQSg1oH0NqXDg7s5yEmQ0Ue/SjuVsMhFsM5BR76J4UwYD2zb+Hd7MOMIjq+Xw66/bnsvVwAb8eyMerFO2jwzi7azwxDgslbj8Oq4kImzmkK5muqwZNQlWr9SkFX34J996L/uZbHOrWO1D+rr/TNiESw9G+fDWtq6HrXu/9qkd5IYQQQrQcuq54+PMt9QoulPH4dfKKPZzZJY60nBKynO7glHSx4WYO5JVWmJGi2roReMJ9+aD2nNYhln+v2UeR24vHHxgWEWUzc+3Qjk02RSUEggsvfbOLTQfyju5vYHiCBhS6vGQ7PezIdDJjdLdGnXnlUH4pe7KL6Nc+mnBLHOkFLkq8x2a0KPb4g1NlNsXMWuVzMBwffCpy+UJyMMjMX62HyWRg8lmpPLBgM5sOFaKOJiANDN3RiHdYmXRmarNP8AgSYGixlm3L5LUVu/ntUD6e44b/vfHdXmwmjegwC5E2Mx3iwjitfQxjegeGc5RNo+Xy+bGZjHRJcDCm94lNo7U7y1nz+jZsCMwMcTRJ5r477+eV256rUL6mutVqWw2krts6mXUTQgghxMm3aMtB1vye2yDr0hXkFnvILfagjiZ8dPsCMygoXa9TcKGMAmLDLdx1fjtuOqsTzy/fwcFcF+1ibdx1TnccTdi1WtcV7/6wn7W7j5Bf6qV8XkwNcHl18ord/Hogn3d/3M8D43o12kOaYo8Pl89PmCXwIKhtTOhNut1CcKrMplCWg2FAhxjSjpSQW+Kh2O3DaDCQGGkjNS6MglKv5GBoxdTRHxQo7diylkICDC3Qsm2ZPPK/rRzOK8FXxdnm8inySzyYDRoH80pw+3S2ZRQC4NcVKVE2wix2Sjw+Nh8u4HBBaZ2z8e7OcjLv+zRyiz2Vru+GVBOpLz0F//lPYBogi4VVF17NgguuIzrMHFK+prqd0yOR5duzqtzWiWYSPpH9On5bdS0vhBCiYb366qs8++yzZGRk0K9fP1555RUGDx7c1NUSrcj0d9ezcFN6g66zyO3nh725uL1+fMHxAV58VaddqJYG7D1SjMeXybzVe4/OcKHz6wEDuzKKuf7sTpzbs2lyhx3IK2HptkwKXKHBBQjcOPkVlPp0HLrOj7/ncDCvhA5x4Y1Sl3CLCZvJSMnRHqfphaWUevzYLUZSIu0hU2U2hbL62cxGBnaMqVC/Yo8Pl1eXHAytTNk0lbpS9GsbSbFHx6vrmI8OkTiQ72ox01TKmdnC+Hw681bvJbuwtMrgQhmXLzAdkten4/X52ZHhQgPGnJpUbm5VMw6riV1ZRXy9JZPO8Y5aRYx1XfHV5kxyiz10S3SgaVrI+jrMn0u7T16Ho3M0q4lX8Z8/3cBaPaJC+XCLka+2ZIIGY3pVrNvOzCLmf59GuDUwZdDx26pr3euzX8dvq67lhRBCNKwPPviAO++8k7lz5zJkyBBeeuklxowZw44dO0hMTGzq6olW4O+f/tbgwQUI3FgXlPrQaLink5sOFvD6yt85UuQO5DJTUKzBj2m57DlSDNAkQYbd2U4yC13V5lnw+hUWYyDx5e9HihstwFA2VebyHZlkFrgCPSrKzdKQFGXj3B5JwakyT7ay+v2wNwefTyev1Bsci38otxSTycDQznFNVj/ROMpPU2k0Gom0h84mUX6aysGd4pqolrUjAYYWZv2BPPZkF1HbznMFLh/RDitZTg8+PTC2r8jtJ9J+LPKlaRopUbY6jTcrG7+WEmUL3lSXX58tJgqTx43rzLOxvfQCB7ucysalO0mJMFcoX+T24z/aCFZWtwibiS2HCzijc2yl26pr3euzX8dvq67lhRBCNKwXXniBG264ITht9Ny5c1m0aBFvvfUWM2fOrP2KiovBWMn0YEYj2Gyh5apiMIDdfmJlS0oC+Yoqo2kQFnZiZUtLAwmWqxIefmJlXS7wVzNFY13KhoUF6g3gdoOvmq7fdSlrtx9LLO3xgNdb57IlJV4Wrd2Fvdxjd7fJjG4InCtmvxdTNftWvqzJ78Psr7q+HpMZ/wmUNep+LL5AfTdu3Y+z0ItFgckIGhoeoxEXJrIKXbz05RZGtAmr+gmoxQJmc+D/fn/g2FXFbA6Ur0XZvQfz8PkVOqApHZu38qn2tGI/JnO5oRy6Hjgvq2IywdFp51Eq8LdRQ1mDQSPSZmT//iOUHh1mUPaXn18E7gITUT3jQx8MVfe33MDfEQagV5SBRUcKyPEHZg2IspvRi4o5nF9ApNVMz/4JGErL7at8R5xY2Qb4jqiUzXasPall2ZxiD7rHQ7RVx+SuWGej0inw+I9NU+n1BtZdFas1cM5D4DOo7rxsYBJgaGFyij14/Dq1HXbl8el4vX6K3T78CmwmRW6JhwibKeSG2G4xklnoorDEy08FOWQXufHrOmEmE/mlXuIcFjonOGgfE4bBoIWMX0MpOv24EqVpbOp7Fh6/Tv45l5AWHsvoOybRIyWK4ozCY+UJ9BRILyylxOOnsNSL2+vDYDCQW+TG7fPj8elYTAasJiOaBi6vH6fLR2Gpt8q6l41F8/l01h/II6fYQ1y4hQHtY2rdlShkvypx/LbqUr42SSDLyjhdXorcPhw2ExFW8wknjKxL4snKygInlLiyMRJeShJN0ZLI+XpyeDwefvnlF2bNmhVcZjAYGD16NGvXrq30PW63G7f7WJK+wsLAED3atKl8IxdeCIsWHfs9MbHqm5gRI2DlymO/p6bCkSOVlx00CH7++djvvXrBvn2Vl+3VC7ZsOfb76afD1q2Vl+3YEdLSjv0+fDisW1d52fh4yM4+9vvYsVDV7FxhYaEXqJdeCtXN0FX+5ubaa+Hjj6suW1R07Gbjppvg7berLpuVBQkJgf/feSe89lrVZffuDRwDgL//PTBjVVU2b4ZTTw38/8kn4ZFHAAgDNh5X9OLrXmBTyikAXL/uC+5fOa/K1V458Ul+6NAXgIm/LuGxpXOrLDvlstks73I6AOO3ruS5xS9VWfbWS2ayuMfZAIzZuZbXPn+qyrJ3XziDT/qMRilI+XEVprvOrbIs//wnTJsW+P+qVTBqVNVln3kmkGMLYP16qGZY0unX34ZKPB+ArkcOsPStaVWW/XjUlXS6ZVjgl/37q5++/NZb4dVXA/8/ciTw91mVSZNg/nx8Pp0vf9zDz0+Nr7Lomq9G4vtp2bHrR4ej6vU2wnfEKKBjx578/f43ySvxUlDq5Z05k0jKywgUuP+4N8h3xDEn+TuiUj/9FDgGAC+/DPfeW3XZFStg5Ejiwi1c+sti7vz8lSqL3jv5CeLCBwV+eecdOBpYr9SHH8Lllwf+/9lncMUVVZdtYBJgaGHiwi0Uury17krnU7D7SAkGLTA2z6BprN+XR1ahm66JDmKPJvwp9fjJLfbw8P+2cCCvJHDT7wv0kzAZNKymQGKZEd0SuOqMDsHxYVFbf+WCt5+n/a8/kR2XzFv3/ZtSgxkFWNueRr8iDz0IHe92pMjNxv35wWCJrlRw9sr8Em+wq6DJqGE3G/H5FU6Xj98O5ZOWU0JsmIUuieHEhluDdS8bK7dsWybzv08jLac4mI05NS6cyWel1qpLYPl6RtjMFV4/flxebcsfcbpZtjWr2iSQZYkiNxzIY39OCaXewHi7DrHHknTWNUdGbRNPVlY22m4GLXBM6pK4sjESXkoSTdGSyPl68hw5cgS/309SUuj3e1JSEtu3b6/0PXPmzOGR6i4MhWgiges0GmW6xmCGhwZceX6Jh8haTuVosxhrfe0aF26m/XGJFxvSL/tz2ZHhrLaM0+Xjl/25DOkc32j1qInVbOD01FicLh8ev47V3LzH3Yv6GdA+hm1H722qkhRpaxHTVGpKVdV/RjS0wsJCoqKiKCgoIDIy8oTWcd2bP/LdriqehtTACGgGiLSZcdhMRNkt9G8fTUyYme/3HGHvkRJQOj49cGPsU8emD7KZtcA8rDYzgzrGcGd3K96Zf6f7N58D4DFZ+GT4ZSwYdz1+u50jTjcWk5FBqbFMOTuVzvEOXl+5h+U7MtmTVRQIXqijczfrOt6jva0MgNEA4VYTugK3z4+uK8wmA7F2C3ERFordgRvvQN0t7Moqok/bKE5JcvDUkh04XV7iwi3YLUZKj3YlirCZmTW2R41BBl1XvL5yD5sPF4TkVABQSgW3dfOILsEcDDWVT4my4fL6ySvxHk0CaaLE4yO9wEVsuIXrz0oFYN73aezPLSHb6cLr07Gajbi9OiajRmKEjQ5xYbVOGFkx8WTFbZYPbBxf9nB+CT+n5QFwemoMbaLDqnz/iW63thpjnUI0FjlfG6atq63Dhw/Ttm1b1qxZw9ChQ4PL7733Xr799lt+/PHHCu+prAdD+/btKTh8uPL6yhCJysv+Qbo//3P5Dl5dsTekaEMPkSi7Py8b9qCrEx8iURmv0YTPaAqWvePsdkw/t4rpKqsZIrEny8k3W7PYe6QYl8+P2WYlNeXoA5C4sGqHSCzddYQb398cmHavmiESEVYDF5/eifvH9wsELnSdPfuyQrZrMxnpFB/O6F6JdGkTU+chEv/+fi+zv9iCzevGbNQoHx5RBHJB6AYDf/9zf64762jviZM4RGJHZiGvr9hDakIEqlxZk6sUlMKvdPYdKeHmUV3onnT0O0u+I06sbDMaIgGwfNNBnvpiE3nFHoyaBlpgGgm/UsSGW7jvkn6c06dt4H11HCJRmJ1NVJs2J6Vtlh4MLUhhkfuEgwsAaBBuMVLq9aNpgeDBlsP5JIRbOZTnAqWwmQzklHjRlUIDTAbw64Efq1HDUlTIWW++RYdVH2M62jh8M/A8/u+869E7dMCnK4pKvETYzfRrF0VOsYevt2Ry8wgH5/ZI5D8/7KPU48doAJ+uMBgCkfqyiL0OmDQNv67w6zo+v8JqNhBpM+FViiKXD4fNTJHLy9b0QhIcNuIcFs7pkcgTi7bhdHnpEGMvlyjSQLjFyP680lplXjUYNMb0TuJwQWkwOFAWqCi7QTj/1KRgtL6m8jF2M85SL+mFLromOHBYTUfzShxLAvnV5gwUkFPkwecL7HOcw4qmaTisitziQP6MnCJ3lQkjy3fHtpuNLNmcUavEk0CFJJVKKdIL3FhMBlCKjEI37WLCakxc2RgJLyWJpmhJWuL52tKHcsTHx2M0GsnMzAxZnpmZSXJycqXvsVqtWK2VPCUKDw+94K1KbcqcSNmwOjyxrUtZe+VD+OpdtvwNVUOWtVqP3TA2ZFmL5Vi+gDqUnXJuH175IRO3v/KbKq/RjNdYsQdjZXzlbvSPZwDKZ3usruzx/AYjpZZK8odUUdYWHVW7c9NoDJbbneVk3sZscou9pMRGEn80eFrbGbPyvTnB/yvNQKml8nOiZ7socr0Ec1ftPlJc6XY35rnYvzGb68PD6Zp49BzQtFrtV0ahC6VpuC02/MaK33dluSIyCssFTBrr776SsmHRGgaHg0LNRPlP1GcL/H06XV40h4Gw6CgIr+K7QL4j6l72BL8jGrJsh+QoUtrEkXOogGKvP/CgVwO72Uhymyg6JJULDJjNx4KBNTGZ6nZe1pMEGFqQR7+sYixVbanA2FTl81NQ6qPEo1NY6iWyoxkIRMaOFHmCAU+jFkhUaDAofLpCM2iccmg3E5e/C4Dr7OFsu/NBXthvwe3TMZR6g3P0dkkIDGGwmIzBJIeFbi+gsJmNON0+UODTA22pkWPtqiIwHzKAxWzAYjQSE27F5fUTabdQ6vXjV5BV6GZgxxiuGNSe3GJPMPNqWXChjMFgqFPm1a6JEVx/Vmqwi3NmoQuryUiftlGcf2rFLs5VlW8TZaPQ5eOHvbkYDRpHijzEhFmCQ1PKkkBuOlgAGkTZzKTlFOMol2NC0zQcNhN5JV7axdgrTRh5fHdsv19xIK+EHskR1JR4EqiQpNLp8pFX4jk65CMQ4HC6fETazdUmrmyMhJeSRFO0JC3tfG0NQzksFgsDBw5k2bJljB8/Hgj0ilu2bBnTp09v2sqJViEszMxlg9rx3k/7G2XoQhkdTtpE94Wuap6mVqIhgqc+Vbv05EZDoPdqWe6qxgjaJkZZg9ecfn/gYZcicB2q68f+nxhVyxvTBlY2i8TmwwXBB1NlAg+BXPRpGyWzSLQyZee7rkOX+DAO5Llw+3WsRgPtY2zoOs3uIUVVJMDQghzMrSaTby34gWK3jzCzAY9fI9xqwu3TOZRXSqnXT7jVgNfvD0ZudQUondS8w+yNbYvPr7MutQ8fnvUXDp52BhfefyN2TaNj8S4SHFb8SmExGkKSMNotRjIKAhfdu7OKcPl0QGHQAjkWlFJ4/IGGtazhMR39ozFqGg6bEY9PYdA0jAaNnikRWE1GSr0+MgtdjD+tLZ3jHazds48Sj48ouxmlVIWLe7vFSG6x51jm1eMEkyu6vYFeElYTF/VLQUHgs6nhyV7XxAg6j3QEnwRmO918+VsG6QWlGA0Q57Dg1yHb6aLI7aN/+2hijw7jKPEGum7FhFmOzvQR+mcZmPnDh9GgUeLxBRNMQmXdse0czCshp9jD9gwnCgizmEKOi91iJL3AxY+/55Bf6uVwQSnJkccixx6/js+vY7aZAI1id2DsX/nPsnyiyzJ1TZBZGw2dRFOIxtQYfwONpbLvjro8jWxO7rzzTiZNmsSgQYMYPHgwL730EsXFxcFZJYSoryf+3AeAj9cdrLInw4mIsBhx+f3oemjehcaOM2QUuGsuVE5DBE8LS2v3vffboQLODrMSbjGFbFfXFXuOOCly+3FYjXSJd5xw0LZHciR2s4FSr46fQC/dkH0C7GYDPZIbtxt5Veram1a0DofyS9lwIC+YC6/se8Dl09mdXUKk3Yx1v6HZPKSojgQYWpB2MTbYW3O56nj8Cs/RMU4lR4c4FLl96Crw5Lp8A9c7fRcPrHiT3hm7GXnj/5GjxWI2aLw47hb6to3mcmugW47dbMRk1IixVez+k55fSlpOKe/9tJ/8Eg/FLi9o2tGAgQG/0lH+0Ka01KtjIBCAcHkD5XSlMBkCs0oEnqRDTJiV3CIPr2/bw497cyjx+DmQW0KEzRy8eQ+u0+PHbAz0ZDheSHLF3BJKPX7sZiMd4o4lV6zNH7LBoNE+NgxdVyzbmkVeiYeuCQ6OFHnw6wqryYgl3EJusYc92UXEhMVQ6vETZjaBFghymAwGvH4dq+lY3b3+wNzHZesoSzBZVWQ/JsxCmNnI4fxSsp1uouxmTEZDMDlmRoGLjQfy2bg/D6+uKHH72J9TwqDUGDrFO7AYDZiMBrz+QH8So8GAxXisV8jxiS7L1DVBZm00ZBJNIRpbY/wNNIaWOJSjOhMmTCA7O5uHHnqIjIwM+vfvz5IlSyokfhSiPp74cx/+PqYH/7dmDzsP57N4a07Nb6rGiFPiuW5oKo/8byvZzlLKZwIo8TZcEKMyKdF1ezLfEMFTcy1n83L5YGdGISmRNnYfCbTpe7LdbNiXR5HnWJdxh+UIp3WIwWEz1TloO6hDLKnx4YEHMZVEczQNOiWEM6hDbJ3W25Dq2ptWtHxOt5ddWUWB/AtHE+yXDSF3+3Ryiz3szirC6a5bD6SmIAGGFmTKWal8vP5ww6/46JdrWXChbUEW93z3NuO3BqahcZksnHZ4B1+fMhSPX+F0+WkbbQt2zaqqG1dOkZuf0/Kwm420ibKT4LCy6WABbq+OwRCYQtNfRX9DnUCSHafLR7zDgsfrJynKToTNFOwelhJlY/Fv6eSVeOkcH87e7CJyij0Uub14/DrJkYGIr67r5BR76J4UUSHzatlTvP05JWQ5Xfj9igibCbfXz8G8Etw+vc5P88pH3B1WE7FhFrKcLizhhuCQh9xiD4WlXjKdbvq2i0IBmw8VEmM3k13kDpZVR/NOJERYcbp89G0XHTJ9ZGVPFLx+nRKvH7dPATphFhMGA2Q5XRzMKyG7yIPBAB1i7NgtRg7klpJT7Oa7nYFpiFLjwok5WmeUCn7uUH3XvMbo0lebdZY/D1r6k1jRsrWUbq0tbShHbUyfPl2GRIhGFxZmZsboHlW+/lPaIa6cu5HqwgOnOuC9GaOJdBy7yZ+3ei97sovw+HUsRgMDOzpYtbvuAYx2UVbSC934q+kCYTLAkM7VDxU9XoMET+uQU/5gnou9uUWBXgx5pWw+VBCyT0pBodvP6t1H6N02qs5BW4NBo3tyBHuyi3H7Kh4ti9FA96TIJg+wHt87Vnpntm6FpV7yiz0opbCbjcH22agFetQ4XT7yjt4/NHcSYGhBDEYjZgM0dGC77Ds7wl3MtLUfcv26L7D6vehofNZ7FM8Nu5b0yISQd6ij321VdeMqcfv4KS0XgMGdYoi0mzlS5CY6zExOkRufDnotGhtFYKxgdJiFjnFhFLmPZmMPs4CCvBJv8AncaR1jWL3rCG6fjl/3caTIRbTdQk6Jh0ibmUlnpoYkeCx7iheoTyDYEeewHE2uGAgC+Pw6OUWeOj3NKx/p1zSNLonhON1ecos9OGwmjAYNl9fP7uwiOsaFM6Z3IBFZekEg+m80aOQUuY/NImEyYDIYiHNYQ7rEVfZEQSnFnuxirEYDDqvxaKDBT6TdTJjFxL7cQpSC7vHhOI72OEmJCry/0OVlXVou7aLDSImycjAvkIk5OTIw/KXU7au2a15jdOmrcZ2VnAfQcp/EipatpXRrbUlDOYRoSQantuX3p9rW6T3n9kxiRLcE1h/II6fYQ1y4hQHtYzCZDKTOXFTr9XSMDeONawZy50cb2Z7hrDRfhEGD7skRDO5YtwBDQwRPPdXNEHAcHfh43QHuOKc7uzKdVQZM/Ap2ZTpJCKtlsr2jDuWX4nT5CLcYKw0whFmMFLq8LSrIKlq+Uo8fXamjs8ocf52gYSBw71Tqqf3fUlORAEMLEm4xkRJtY389czEcTwFWn4ev/3UrKUWBiPmaDn15YtQUtiR3DSkbaTcRaTNxON8V/OKtrBuXz68wGzR6p8YQ5wiM77cYDUTZLdjMRrIKXRR7Ko+UGI5m3lEEhkmEWUzEO6wUlnpxe3X6tI2iT7soPlt/KOQJXKejsyJs3J9PbomH3GJv4GY6KYJJZ6ZWmKKy7ClehM1EWk4JDpu5iuSKYXV6mnd8pD823Er/9tHsySomt8SDy+vDr8OpbaK4fFC74NP1ss+wbKiG0+UjzGKkfYydAR1iKnSJq+yJQlmCxliHFZfXhyry4PMr8ko8eHw6GmAxGTAbjw3BsFuMwSBDfomX9QfyaBNl5/xeSaijy9KOFNeqa15jdOmrbp2VnQdlWuqTWNGytYRurS1lKIcQfxQmk6HSBNRpT43jmx2/89d524LLHv1zZ47kayzanI7T5SPCZuJPvdtw0Wlt6JoYwV3nd+eBBZs54nShq2MJCw0aJETYuPO87tXOplWZhgiert5Vtx4Z69Ny+Wp7Ro3DRUq8Ol9tz+CS/u1qvW6ny8vWw4UUVPEkuKA08LqzjskwG1prSMQraq8sT5rPr1Pq9WMxGTBqgSkqPT4do1HDajRUuN5tjuTqoQVpG23n7K7xvPvTwQZft9tk4X89hzPq93U8OWoKKzoPOjaH7FEGLZCAsbDUy65MJ7lOd/Cm7fhuXBkFLj74+QBtoo/d1EXYTMSEWch2uugQG8ae7GI0wK8UJoOGrivMJgN2sxEFuL1+IuxmusSH89fhnUmOsgW7h+3Mclb6BK5TvIOOsWEcynORllvMxMEd+HP/tpU2pmVP8SJt5nJJDY8xGw0UV5FcsTqVRfpjw63EpFooLPWyO7uIXm0iuef80Ea+/GfodHkpcvtw2ExEWM2VdomrbDtlCRpNViM+v6JbooPuSRF4dcXh/BKyC12YjYEvq/LsFiPtY+3szy1ldM8kxpyaHDIUoy5d8xqjS19V66zqPCi/X/IkVpxszb1ba0sZyiGEgNHdO5P2VOeQZbquuPz0DpV+v5Q9THlr1e/szCrC69cxGw10T3Jw/dmdKzxsqa36Bk/91Y3bqESG082anZk1FwTW7MysU4Ahv9RDVqGr2p4RWYUu8ksrTwx+MrSmRLyidjrHhxPvsJJf6kVTUBzs0aARbjWilCImzELn+JM33eSJkgBDC2IwaIzt06ZBAgz9Du/g/pXzeHzUVH5L6QbAC8Ou5umRk/EbAk+3y18KKwI5GnKKA9HcAlcJ17z5E5PPTuWu87tXyODfKT4cuzn0CZmmaXRNdFDkDowhMhk0NA2UP7B+s8lIuNWI2WjApyv8euAmP9xqpkuCI+QJdHVP4AwGA9HhZlK1cM7oHFdlpL5sHX5dDyY1tJpCcxkYK0muWJPqIv2ZTjcd48K5YlD7SutVlijyRLdj0AKf5RGnmwi7ma6JDqKOdh10+/wYjQZ0FZih43gur47dbKRvu6iQOpzIk/+67Ed91ilPYkVz1Rh/Aw2lpQzlEEJUrqbvl+qGXdRHfYKnPVIcrN2bV+ttRVhNrNtfUKuytS1XJi2nGF8N8Q6fCpQ7s0tC9QUbQWtLxCtqp11MGGd0jmPxb+m4vf7gMCddBRKyW81GhnSOo11M87y2KE+uuluYs7rEM6Ctg/WHik7o/e3yM7j3u39z8bbvALh71X+YdMWjALjMtpCyNcWanR4fr6/czZ7sItpF28l2unH7dWwmI50Twom2mzmcX0pypMKrB6awjAkz069dFD/uzSXcZ6LE4w9uKcwSCC4oFei9YDBoWE2BG97qEgqGW4wUuf3B5EgOq7HaJ3Dlp6SMd1jYl1NCTJiZbKcbS3jZzXggW2u8w4Kz1Evf9tEh66ppSsST1U36+O24vD6sJiM+TaNfuyhiw48lkUqOsGE1GXH5/Bx/jVFdIszmKHgMXV7iHVb25xZzSpI8iRWitlrCUA4hxImrathFfZ1o8PSuc3vw9poD1SbALO/0TrF8vaV2PRhK6jgmfU9WcYOWa2jlE/FCIPlf2TVuhM0kwz9bKYNB46yu8XyzLSswPb2moWkKpTS8uiLSZOSsrvEtIqgkAYYWZmeGk19PILgQ6Spi2toPmfzLF1j9PnQ0Pul9Ls8Pu6bO6yp/Wvt0+PK3DFIiraRE2+meHIHNbGTL4UJKjg6V2HSwAIvJgMVkwGExYjQY6JYYTp92bVmz+wjbMpyUenx4vDq6Uvh8gXmJHRYT3ZMjGNM7ucqEgtsyCvlqa2bIbBRGg8YpSRGVPoE7fjybx6eT7XRjMmoYDRrpBS7cXj/FHh+apuH26egKLk+OCK6rtmPiTlY36eO3k+108+VvGeQUe7CYjCFPJvu0jeL3I8UcyHcRd3Qqz1KPn5ziyhNhNkdVHcNit59uSQ55EitELTX3oRxCiNbDEW7hwr4pLNyUXmNZDbhndA9+2ZdHemHNwxTiHHVL8mg11lymLuUaWtkQXpfXwLb0QrKc7uBQl8QIK53iw3H7/DL8s5XRdcX2dCcdY8NoE2Ul2+nBq+uYDYHjbjIa2JHhZFT3xGbfTkuAoQXRdcU1b/5AXXOHXr5pKfeveIsYlxOA1R378eSoqWxN6lzDOytnIJDht+yWXgFogaQ4mw4W0C3JgUGDnZlFWIwGkqNsFLt9OF1e0vNLMRoM6ITjP5BPnMPKwA4mdmU5yXa6KfHomAwaSZE2Rp6SwMQhHWp+kna0IhoKhVZl14uqxrO5vTqFLi82s5GMAhcev47VZCA6zEKcw0KY2cTy7Vl0jAtEiesyJu5kdZMuv50eyZASZavyyeS+nBLmf59GWk4xucWeo2MzK0+E2dxUeQx9OoWlXvbnlmA1GeRJrBC11JyHcgghWpd/XjUAWF9jkGFc3xQc4RauGdqBmZ9srXG91wztUKd6bD6Q26DlGlq4xYTHp7NmTw55RS5K/TpKB80ARwpLSS9w0TXRIcM/W5mynivdkhw4rCacLl9Iz5Uit6/F9FyRM7MF2XYonyPFdc9oa9L9xLic7IzrwJOjprCy88AKCRzrorIAh8eviLMYOZRXSnpBaWCYg0/HZjZwWodoNOC3w4WYjQa8uiKrwBWYy9Xlw2Iy0K9tFNeflYrdbCLOYaFzgoP2MWFVRujKxqf5dcWYU5MqDJHYnV0cMj6tuvFsp3WIZkdGIbklXk5tE0lKlB2rOXCTGnE08eOurCK+2pyBghYxJq66J5NdEyMaZWxmY6v2GLaPZmdmER3i7Iw/rW2ViTGFEEII0XT+edUAnrrEw59eXUXacbOiGTUY2yflaCAC/tKvAw9/vg1XNQkTbCaNv/SrW4Bh3X5ng5ZraCmRNvKKPRzIKQm95tbB49MpcpcQ57CQEmmrahWiBTp+mvtIe2husZaUuFwCDC3InCXba1Wu/+EdhHtK+T61PwAf9j2PErOVhT2HBxM4NrQSt49DeaX4dYUCDJqGzWzA5dX57VB+IAGfUoEpLgtclHr9hFtM6LpOfrGP1buPcCi/lNtHn8KoHjU/RS8/Ps1gMBBpD705Pn58WvnylU1nGGk3szXdydDOcaRUMl4/JcrGpoMFoAXyP7SEKRGrezLZWGMzG1NNx7BNtI0jTg8RVnOz+PyFEEIIUZEj3MLKe8+lqNjD88t3cDDXRbtYG3ed0x1H+LHhDhaLkb+P68XDX2ypdMYHowZ/H9cLi6Vu17Y+VbsZLWpbrqEdLihlZ6azyh7LfgJDpg8XlNIhrvnPKCBqpzUlLm/ejyyboVdffZXU1FRsNhtDhgzhp59+Omnb3ptVWO3r7fMzeOXzp1nwn7t4askrWHyB3g5+g5HPTx3VaMEFCMwwUeLxE3b0S15XCqPhaJDB4+dgXikOq4m8Eh9ev47Pr3D7dMwmIxE2M0aDxuECF/9YtoudmdXvJ5SP8lX+R2a3GEPGp9VU3mjQ8Pr1Kp942y1GSrw+Sjy+Wm9TNKy6HnMhhBBCNF+OcAuzL+rD/5t0OrMv6hMSXChz7dBUHr74VNpGWoI3LQagXaSFhy8+lWuHptZ5u51iapf4ubblGtrWw/k43dUPiHa6/Ww9nH9yKiROirIE9ukFLtRxwa2yxOVdEx0tInF58w+BNCMffPABd955J3PnzmXIkCG89NJLjBkzhh07dpCYmNjo2z/krPzGKarUyfS1HzDpl4VY9EACx7Ud+mDzufGYKkbAGprVqAXnafXqgX9B4fbqRNjNhFuMFOSX4vL5KfX68PkDvRzsZgMmg4Y6+t7YcAvZTjef/HKI+y6IqLZ7e12jfDWV9+sKs9GArlcerS71+Akzm0CjVUQWW6LWFNkVQgghRO1cOzSVCQPb8/X2DDIK3CRHWTm/R3Kdey6UeXvqYM54+ttalWsKizdn1LrcBX3aNnJtxMnSmqaQlivxOnjhhRe44YYbuP766wGYO3cuixYt4q233mLmzJknvT4Wn5drNyzib2veJ9oVmFliVcf+PHnOFLYlnlgCx7qKDQvc6DldPhQ6bq+fMKsRjy/QiyHGbkbTAhmBXV4/Xv/RKStNBoyGQCzarwJd3G0mAx6ToVbDDMpPU+mw1jw9YU3lnS4fqfHhFLp8JCtV6fr6totCAVsOF9Zqm6Jh1fWYCyGEEKJ1sFiM/Klvw9xMJ8c4SIm0VDtDRUqkheQYR4Nsr67SckoatJxoOVrLFNISYKglj8fDL7/8wqxZs4LLDAYDo0ePZu3atZW+x+1243a7g78XFtbc9b8u+qfv4MHl/wJgR3wHnhw1lW87DahXAsfaMmqQGGElKcpGidtPsduHTwczEGYxkRJlptjtp9Trx2zUsJiMuLw6Xr8fDQgzG9G0wI2hx6cTbjGhaWAxGdCVXmM397pG+WoqH+ewcnmPRJZvz6pyfWN6JwOQXuBq8ZHFlqg1RXaFEEII0XTW3n8eQ59cWmmQISXSwtr7z2uCWgVEWmt3e1bbcqJlaQ1TSMuZWUtHjhzB7/eTlBSagDApKYnt2ytPvjhnzhweeeSRRqvTT+17837f89nQpjsf9xndqDkWjBqYjQYMR2eBTI0PJ9puJq/Ei1/XMRs17BYTZ3aJJSnSToTNRF6Jl91ZTvbllARnY3B5Tbi8PjQUPj0QXDAbDcSEBQISUWFmou2WWnVzr2uUrzblO8aF1bi+1hBZbKlaS2RXCCGEEE1r7f3nkZFXxPVvryPL6SExwsK8SYOarOdCmfED2rB6T81TZI4f0OYk1EY0hZY+hbQEGBrRrFmzuPPOO4O/FxYW0r59+wbdxsyxtzXo+sozADpgNkBMuIUwi4nMQhcWk4EeSRGkRNvJdrpJLyilY7wDu9mArgIdKPxKYTZqRNnNnN4plnF9UrBbjCzbmsmCjYcpcPmwm02EWwNTQZZ6/djMRsLMJrolRdS6m3tdo3w1la/N+lpDZLElk89fCCGEEA0hOcbBlzNGNnU1Qlzcpx2zP99GsafqRI8Oi5GL+7Q7ibUSovYkwFBL8fHxGI1GMjMzQ5ZnZmaSnJxc6XusVitWq7XB6vDA+GQeX1C7xC8nSgNsZgNhFiNKgdEAFpMRk0HD49PpEBtGrzaRaGjsyynGajJyZpd4zj810LPj+CfLfdtFhzxZPqtLPD3bRPLm6r3kl3gwGTR0BVFhZsLMJjrEhdW5m3tdo3w1la/N+lp6ZLGlk89fCCGEEK2RxWJk5tgePLpwC95KYgxmI9w3tscJJ7kUorFJgKGWLBYLAwcOZNmyZYwfPx4AXddZtmwZ06dPPyl1+OsZA3l8waIGWZeRQO+EsjkTjBo4LCbO6BLL1Wd0xOXVWZeWR1ZhKQUuLwbNQNdEB5cObEvXhIgqnx7X9GTZYNCYcHoHTusQzcfrDrEnuwhd6UTbLXRLipBu7kIIIYQQ4g+tbPrNuSt2kun04leBa/XkSAs3jex2QtNzCnGyaOr4iTZFlT744AMmTZrEG2+8weDBg3nppZf48MMP2b59e4XcDJUpLCwkKiqKgoICIiMjT7geqTNrH2QwEUhWE+2w0b9DJP07xBAdZkEjMGvDgdwSspxukqNsDEqNpWNseDAgoOuqUbuhN/b6hRBCnHwN1dadLC2tvkKIPw6Px99g03OKlqMx7pFOZlsnPRjqYMKECWRnZ/PQQw+RkZFB//79WbJkSa2CCw0p7alx/OuHXyodLnHdGe3olBDBwNQYYuzWep2Qjd0NXbq5CyGEEEIIUbmGnJ5TtAy7s5zBIecunx+byUiXBAdjerecXt7Sg+EkkqckQgghWruW1ta1tPoKIYRonXZnOZn3fRq5xR5SomyEWUyUeHzB6divPyv1hIMMJ7OtMzTq2oUQQgghhBBCCFElXVd8tTmT3GIP3RIdRNjMGA0aETYz3RId5BZ7+HpLJrre/PsGSIBBCCGEELWSlpbG1KlT6dSpE3a7nS5dujB79mw8Hk+wzL59+wCIiopC07Tgzw8//BCyro8++ogePXpgs9no06cPixcvDnldKcVDDz1ESkoKdrud0aNHs2vXrpAyubm5XH311URGRhIdHc3UqVMpKipqpL0XQgghGseh/FL2ZBeREmUDoLDUy5EiN4WlXgBSomzsziriUH5pU1azViTAIIQQQoha2b59O7qu88Ybb7BlyxZefPFF5s6dy/3331+h7Oeff056enrwZ+DAgcHX1qxZw8SJE5k6dSobNmxg/PjxjB8/ns2bNwfLPPPMM/zjH/9g7ty5/Pjjj4SHhzNmzBhcLlewzNVXX82WLVtYunQpCxcu5LvvvuPGG29s3A9BCCGEaGDFHh8unx+X189Pv+fwzbbM4M9Pv+fg8vpx+/wUe3xNXdUaSQ6Gk0jGeQohhGhtnn32WV5//XV+//13AH777Tf69u3LqlWrOPvssyt9z4QJEyguLmbhwoXBZWeccQb9+/dn7ty5KKVo06YNd911F3fffTcABQUFJCUlMX/+fK688kq2bdtGr169+Pnnnxk0aBAAS5Ys4cILL+TgwYO0adOmVvWXtlkIIURTO5BbwiP/28K29EKOFLnx+RVKgaaByagRF26lV5tIZl906gklyZccDKJWdF1xILeE7RmFHMgtaRFjcoQQQrQuBQUFxMbGVlg+ceJEEhMTOfvss/niiy9CXlu7di2jR48OWTZmzBjWrl0LwN69e8nIyAgpExUVxZAhQ4Jl1q5dS3R0dDC4ADB69GgMBgM//vhjlfV1u90UFhaG/AghhBBNKSXSxuH8UtLzXbh9Cr8CHfArcPsUGQUu0gtKSYm0NXVVayTTVLZQrWEKEyGEEC3b7t27eeWVV3juueeCyxwOBwBvv/02ERERfPLJJ4wfP54FCxZw8cUXA5CRkVFhiuekpCQyMjKCr5ctq65MYmJiyOsmk4nY2NhgmcrMmTOHRx555ER2VwghhGgUB/JLSDtSjF7F6zqwN7uYA/kldIp3nMyq1Zn0YGiByqYw2Xy4gOgwM53jHUSHmdl8uIB536exO8vZ1FUUQgjRgsycOTMkIWNlP9u3bw95z6FDh7jgggu4/PLLueGGG4LL4+LiABg0aBCnn346Tz31FNdccw3PPvvsSd2nqsyaNYuCgoLgz4EDB5q6SkIIIf7gfth7hBJvVeGFgBKvzg97j5ykGp046cHQwhw/hYmmaQBE2Mw4rCZ2ZRXx9ZZMOsc7MBi0Jq6tEEKIluCuu+5i8uTJ1Zbp3Llz8P+HDx9m1KhRnHnmmfzf//1fjesfMmQIS5cuDf6enJxMZmZmSJnMzEySk5ODr5ctS0lJCSnTv3//YJmsrKyQdfh8PnJzc4Pvr4zVasVqtdZYZyGEEOJkWZ+WX+tyE09v3LrUlwQYWpjyU5iUBRfKaJoWMoXJiSQAEUII8ceTkJBAQkJCrcoeOnSIUaNGMXDgQObNm4fBUHNnyI0bN4YECoYOHcqyZcuYMWNGcNnSpUsZOnQoAJ06dSI5OZlly5YFAwqFhYX8+OOP3HLLLcF15Ofn88svvwRnqFi+fDm6rjNkyJBa7YsQQgjRHPj81fdeqGu5piQBhhambAqTMIu90tftFiOZha4WMYWJEEKIluXQoUOMHDmSjh078txzz5GdnR18razXwLvvvgvAzp07cTgcfPrpp7z11lv861//Cpa9/fbbGTFiBM8//zzjxo3j/fffZ926dcHeEJqmMWPGDB5//HG6detGp06dePDBB2nTpg3jx48HoGfPnlxwwQXccMMNzJ07F6/Xy/Tp07nyyitrPYOEEEII0RyckhwBpNeyXPMmAYYWJtxiwmYyUuLxEWEzV3i91OPHajISbpFDK4QQomEtXbqU3bt3s3v3btq1axfy2vGzXo8YMQKTyUSPHj344IMPuOyyy4KvnXnmmbz77rs88MAD3H///XTr1o0FCxbQu3fvYJl7772X4uJibrzxRvLz8zn77LNZsmQJNtuxDNrvvPMO06dP59xzz8VgMHDppZfyj3/8o5H2XgghhGgcY3ol8+I3u/D4qp4V0GrSGNOr6iGAzYWmjr8iEI2mIeYf1XXF6yv3sPlwQUgOBghc3O3KKqJP2yhuHtFFcjAIIYQ46U7mXNsNoaXVVwghROuj64ob/vMzK7Zno1dyd27Q4JweifzftYNO6B7vZLZ1MotEC2MwaIzpnURsuIVdWUU4XV58uo7T5WVXVhGx4RbOPzVJggtCCCGEEEII0QIYDBqzxvZkQIcYbCYNA6ARuFm3mTQGdohh5tgeLeIeT/rRt0BdEyO4/qxUvtqcyZ7sIjILXVhNRvq0jeL8U5Pomtj8x+YIIYQQQgghhAjomhjBU5f2YfGmdFbvPoLT5SPCZuLsrvFc2DelxdzjSYChheqaGEHnkQ4O5ZdS7PERbjHRNtreIqJaQgghhBBCCCFCdU2MYPo5Dv48oF2LvceTAEMLZjBoMhWlEEIIIYQQQrQSLf0eT3IwCCGEEEIIIYQQot4kwCCEEEIIIYQQQoh6kwCDEEIIIYQQQggh6k0CDEIIIYQQQgghhKg3SfJ4EimlACgsLGzimgghhBCNo6yNK2vzmjtpm4UQQrR2J7NtlgDDSeR0OgFo3759E9dECCGEaFxOp5OoqKimrkaNpG0WQgjxR3Ey2mZNtZRHDK2AruscPnyYiIgINK3+c5kWFhbSvn17Dhw4QGRkZAPUsHmT/W3dZH9bvz/aPv9R93f//v1omkabNm0wGJr/SMyGbpsbUms5h2Q/mpfWsB+tYR9A9qO5ac37oZTC6XSelLZZejCcRAaDgXbt2jX4eiMjI1v0H0Fdyf62brK/rd8fbZ//aPsbFRXVova3sdrmhtRaziHZj+alNexHa9gHkP1oblrrfpysXoXN/9GCEEIIIYQQQgghmj0JMAghhBBCCCGEEKLeJMDQglmtVmbPno3Vam3qqpwUsr+tm+xv6/dH22fZX1FfreUzlf1oXlrDfrSGfQDZj+ZG9qNhSJJHIYQQQgghhBBC1Jv0YBBCCCGEEEIIIUS9SYBBCCGEEEIIIYQQ9SYBBiGEEEIIIYQQQtSbBBiEEEIIIYQQQghRbxJgaKFeffVVUlNTsdlsDBkyhJ9++qmpq1TBnDlzOP3004mIiCAxMZHx48ezY8eOkDIjR45E07SQn5tvvjmkzP79+xk3bhxhYWEkJiZyzz334PP5QsqsXLmSAQMGYLVa6dq1K/Pnz69Qn8b+zB5++OEK+9KjR4/g6y6Xi2nTphEXF4fD4eDSSy8lMzOzRe5rmdTU1Ar7rGka06ZNA1r+8f3uu++46KKLaNOmDZqmsWDBgpDXlVI89NBDpKSkYLfbGT16NLt27Qopk5uby9VXX01kZCTR0dFMnTqVoqKikDKbNm1i2LBh2Gw22rdvzzPPPFOhLh999BE9evTAZrPRp08fFi9eXOe61Gd/vV4v9913H3369CE8PJw2bdpw3XXXcfjw4ZB1VHZOPPXUUy1ufwEmT55cYV8uuOCCkDKt5fgClf4ta5rGs88+GyzTko5vc/LEE09w5plnEhYWRnR0dKVlTtZ3YW3aotr6I50Pzem6qzldb9RFS2pT67MfzantqEptrtFbwnVra7nXeP311+nbty+RkZFERkYydOhQvvzyy+DrLeFYhFCixXn//feVxWJRb731ltqyZYu64YYbVHR0tMrMzGzqqoUYM2aMmjdvntq8ebPauHGjuvDCC1WHDh1UUVFRsMyIESPUDTfcoNLT04M/BQUFwdd9Pp/q3bu3Gj16tNqwYYNavHixio+PV7NmzQqW+f3331VYWJi688471datW9Urr7yijEajWrJkSbDMyfjMZs+erU499dSQfcnOzg6+fvPNN6v27durZcuWqXXr1qkzzjhDnXnmmS1yX8tkZWWF7O/SpUsVoFasWKGUavnHd/Hixervf/+7+vTTTxWgPvvss5DXn3rqKRUVFaUWLFigfv31V3XxxRerTp06qdLS0mCZCy64QPXr10/98MMPatWqVapr165q4sSJwdcLCgpUUlKSuvrqq9XmzZvVe++9p+x2u3rjjTeCZb7//ntlNBrVM888o7Zu3aoeeOABZTab1W+//VanutRnf/Pz89Xo0aPVBx98oLZv367Wrl2rBg8erAYOHBiyjo4dO6pHH3005JiX/5tvKfurlFKTJk1SF1xwQci+5ObmhpRpLcdXKRWyn+np6eqtt95SmqapPXv2BMu0pOPbnDz00EPqhRdeUHfeeaeKioqq8PrJ/C6sqS2qiz/K+dDcrruay/VGXbWkNrU++9Gc2o6q1OYavSVct7aWe40vvvhCLVq0SO3cuVPt2LFD3X///cpsNqvNmze3mGNRngQYWqDBgweradOmBX/3+/2qTZs2as6cOU1Yq5plZWUpQH377bfBZSNGjFC33357le9ZvHixMhgMKiMjI7js9ddfV5GRkcrtdiullLr33nvVqaeeGvK+CRMmqDFjxgR/Pxmf2ezZs1W/fv0qfS0/P1+ZzWb10UcfBZdt27ZNAWrt2rVKqZa1r1W5/fbbVZcuXZSu60qp1nV8j7+I0HVdJScnq2effTa4LD8/X1mtVvXee+8ppZTaunWrAtTPP/8cLPPll18qTdPUoUOHlFJKvfbaayomJia4v0opdd9996nu3bsHf7/iiivUuHHjQuozZMgQddNNN9W6LvXd38r89NNPClD79u0LLuvYsaN68cUXq3xPS9rfSZMmqUsuuaTK97T243vJJZeoc845J2RZSz2+zcW8efMqDTCcrO/C2rRFdfFHOR+a23VXc7neqI/m3KbWZz+Uaj5tR10cf43eUq9bW9O9RkxMjPrXv/7VIo+FDJFoYTweD7/88gujR48OLjMYDIwePZq1a9c2Yc1qVlBQAEBsbGzI8nfeeYf4+Hh69+7NrFmzKCkpCb62du1a+vTpQ1JSUnDZmDFjKCwsZMuWLcEy5T+PsjJln8fJ/Mx27dpFmzZt6Ny5M1dffTX79+8H4JdffsHr9YbUoUePHnTo0CFYh5a2r8fzeDz897//ZcqUKWiaFlzemo5veXv37iUjIyNku1FRUQwZMiTkmEZHRzNo0KBgmdGjR2MwGPjxxx+DZYYPH47FYgnZvx07dpCXlxcsU91nUJu6NIaCggI0TavQ5fupp54iLi6O0047jWeffTaki15L29+VK1eSmJhI9+7dueWWW8jJyQnZl9Z6fDMzM1m0aBFTp06t8FprOr7Nxcn6LqxNW1RXrf18aK7XXU19vdHQmlOb2hCaQ9tRF8dfo7fU69bWcK/h9/t5//33KS4uZujQoS3yWJjqVFo0uSNHjuD3+0NOIICkpCS2b9/eRLWqma7rzJgxg7POOovevXsHl1911VV07NiRNm3asGnTJu677z527NjBp59+CkBGRkal+1r2WnVlCgsLKS0tJS8v76R8ZkOGDGH+/Pl0796d9PR0HnnkEYYNG8bmzZvJyMjAYrFUuBFLSkqqcT+a475WZsGCBeTn5zN58uTgstZ0fI9XVr/Ktlu+7omJiSGvm0wmYmNjQ8p06tSpwjrKXouJianyMyi/jprq0tBcLhf33XcfEydOJDIyMrj8tttuY8CAAcTGxrJmzRpmzZpFeno6L7zwQrCuLWV/L7jgAv7yl7/QqVMn9uzZw/3338/YsWNZu3YtRqOxVR/ft99+m4iICP7yl7+ELG9Nx7c5OVnfhbVpi+rij3A+NMfrruZwvWG32xt0n5pTm1pfzaXtqK3KrtFb4nVrS7/X+O233xg6dCgulwuHw8Fnn31Gr1692LhxY4s7FhJgECfFtGnT2Lx5M6tXrw5ZfuONNwb/36dPH1JSUjj33HPZs2cPXbp0OdnVrJexY8cG/9+3b1+GDBlCx44d+fDDDxu8IW6O3nzzTcaOHUubNm2Cy1rT8RXHeL1errjiCpRSvP766yGv3XnnncH/9+3bF4vFwk033cScOXOwWq0nu6r1cuWVVwb/36dPH/r27UuXLl1YuXIl5557bhPWrPG99dZbXH311dhstpDlren41tfMmTN5+umnqy2zbdu2kOR7LUFd9kvOh6bxR7/eaO5aWttR1TV6S9PS7zW6d+/Oxo0bKSgo4OOPP2bSpEl8++23TV2tEyJDJFqY+Ph4jEZjhcyhmZmZJCcnN1Gtqjd9+nQWLlzIihUraNeuXbVlhwwZAsDu3bsBSE5OrnRfy16rrkxkZCR2u73JPrPo6GhOOeUUdu/eTXJyMh6Ph/z8/Crr0JL3dd++fXzzzTf89a9/rbZcazq+ZeuubrvJyclkZWWFvO7z+cjNzW2Q417+9Zrq0lDKggv79u1j6dKlIb0XKjNkyBB8Ph9paWnBurak/S2vc+fOxMfHh5y/re34AqxatYodO3bU+PcMrev41tVdd93Ftm3bqv3p3LlzrdZ1sr4La9MW1We/WuP50BKuu5rieqOhNac2taE1VdtRG1Vdo7e069bWcK9hsVjo2rUrAwcOZM6cOfTr14+XX365xR0LkABDi2OxWBg4cCDLli0LLtN1nWXLljF06NAmrFlFSimmT5/OZ599xvLlyyt09arMxo0bAUhJSQFg6NCh/PbbbyFfxGU3Nb169QqWKf95lJUp+zya6jMrKipiz549pKSkMHDgQMxmc0gdduzYwf79+4N1aMn7Om/ePBITExk3bly15VrT8e3UqRPJyckh2y0sLOTHH38MOab5+fn88ssvwTLLly9H1/VgAzd06FC+++47vF5vyP51796dmJiYYJnqPoPa1KUhlAUXdu3axTfffENcXFyN79m4cSMGgyHYHbQl7e/xDh48SE5OTsj525qOb5k333yTgQMH0q9fvxrLtqbjW1cJCQn06NGj2p/y46erc7K+C2vTFtVnv1rj+dASrrua4nqjoTWnNrWhNVXbUZ2artFbynVra77X0HUdt9vdYo5FiDqlhBTNwvvvv6+sVquaP3++2rp1q7rxxhtVdHR0SObQ5uCWW25RUVFRauXKlSFTw5SUlCillNq9e7d69NFH1bp169TevXvV559/rjp37qyGDx8eXEfZtCvnn3++2rhxo1qyZIlKSEiodNqVe+65R23btk29+uqrlU670tif2V133aVWrlyp9u7dq77//ns1evRoFR8fr7KyspRSgSlmOnTooJYvX67WrVunhg4dqoYOHdoi97U8v9+vOnTooO67776Q5a3h+DqdTrVhwwa1YcMGBagXXnhBbdiwIThrwlNPPaWio6PV559/rjZt2qQuueSSSqfUOu2009SPP/6oVq9erbp16xYyFVV+fr5KSkpS1157rdq8ebN6//33VVhYWIWpqEwmk3ruuefUtm3b1OzZsyudxq2mutRnfz0ej7r44otVu3bt1MaNG0P+pssyFK9Zs0a9+OKLauPGjWrPnj3qv//9r0pISFDXXXddi9tfp9Op7r77brV27Vq1d+9e9c0336gBAwaobt26KZfLFVxHazm+ZQoKClRYWJh6/fXXK7y/pR3f5mTfvn1qw4YN6pFHHlEOhyN4HJxOp1Lq5H4X1tQW1dYf6XxobtddzeV6o65aUpt6ovvR3NqOqtR0ja5Uy7hubS33GjNnzlTffvut2rt3r9q0aZOaOXOm0jRNff311y3mWJQnAYYW6pVXXlEdOnRQFotFDR48WP3www9NXaUKgEp/5s2bp5RSav/+/Wr48OEqNjZWWa1W1bVrV3XPPfeEzE2rlFJpaWlq7Nixym63q/j4eHXXXXcpr9cbUmbFihWqf//+ymKxqM6dOwe3UV5jf2YTJkxQKSkpymKxqLZt26oJEyao3bt3B18vLS1Vt956q4qJiVFhYWHqz3/+s0pPT2+R+1reV199pQC1Y8eOkOWt4fiuWLGi0nN40qRJSqnAtFoPPvigSkpKUlarVZ177rkVPoecnBw1ceJE5XA4VGRkpLr++uuDNxVlfv31V3X22Wcrq9Wq2rZtq5566qkKdfnwww/VKaecoiwWizr11FPVokWLQl6vTV3qs7979+6t8m96xYoVSimlfvnlFzVkyBAVFRWlbDab6tmzp3ryySdDLqpayv6WlJSo888/XyUkJCiz2aw6duyobrjhhgqNbGs5vmXeeOMNZbfbVX5+foX3t7Tj25xMmjSp2r8dpU7ed2Ft2qLa+KOdD83puqs5XW/URUtqU090P5pb21GVmq7RlWoZ162t5V5jypQpqmPHjspisaiEhAR17rnnBoMLSrWMY1GeppRSdevzIIQQQgghhBBCCBFKcjAIIYQQQgghhBCi3iTAIIQQQgghhBBCiHqTAIMQQgghhBBCCCHqTQIMQgghhBBCCCGEqDcJMAghhBBCCCGEEKLeJMAghBBCCCGEEEKIepMAgxBCCCGEEEIIIepNAgxCCCGEEEIIIYSoNwkwCCFaDU3TWLBgQaNuY+TIkcyYMaNRtyGEEEKcLJMnT2b8+PHB35uqnVu5ciWappGfn9+o2zkZ1wpC/JFJgEEIUWdr167FaDQybty4Or83NTWVl156qeErVYOLLrqICy64oNLXVq1ahaZpbNq06STXSgghhKho8uTJaJqGpmlYLBa6du3Ko48+is/na/Rtf/rppzz22GO1KnuyggIej4f4+HieeuqpSl9/7LHHSEpKwuv1Nmo9hBA1kwCDEKLO3nzzTf72t7/x3Xffcfjw4aauTq1MnTqVpUuXcvDgwQqvzZs3j0GDBtG3b98mqJkQQghR0QUXXEB6ejq7du3irrvu4uGHH+bZZ5+ttKzH42mw7cbGxhIREdFg62sIFouFa665hnnz5lV4TSnF/Pnzue666zCbzU1QOyFEeRJgEELUSVFRER988AG33HIL48aNY/78+RXK/O9//+P000/HZrMRHx/Pn//8ZyDQ7XLfvn3ccccdwSczAA8//DD9+/cPWcdLL71Eampq8Peff/6Z8847j/j4eKKiohgxYgTr16+vdb3/9Kc/kZCQUKG+RUVFfPTRR0ydOpWcnBwmTpxI27ZtCQsLo0+fPrz33nvVrreyrpbR0dEh2zlw4ABXXHEF0dHRxMbGcskll5CWlhZ8feXKlQwePJjw8HCio6M566yz2LdvX633TQghROtjtVpJTk6mY8eO3HLLLYwePZovvvgCODas4YknnqBNmzZ0794dqLm98fv93HnnnURHRxMXF8e9996LUipku8cPkXC73dx33320b98eq9VK165defPNN0lLS2PUqFEAxMTEoGkakydPBkDXdebMmUOnTp2w2+3069ePjz/+OGQ7ixcv5pRTTsFutzNq1KiQelZm6tSp7Ny5k9WrV4cs//bbb/n999+ZOnVqna8VKuuBsXHjRjRNC6nP6tWrGTZsGHa7nfbt23PbbbdRXFwcfP21116jW7du2Gw2kpKSuOyyy6rdFyFaMwkwCCHq5MMPP6RHjx50796da665hrfeeivk4mTRokX8+c9/5sILL2TDhg0sW7aMwYMHA4Ful+3atePRRx8lPT2d9PT0Wm/X6XQyadIkVq9ezQ8//EC3bt248MILcTqdtXq/yWTiuuuuY/78+SH1/eijj/D7/UycOBGXy8XAgQNZtGgRmzdv5sYbb+Taa6/lp59+qnU9j+f1ehkzZgwRERGsWrWK77//HofDwQUXXIDH48Hn8zF+/HhGjBjBpk2bWLt2LTfeeGMw+CKEEEIA2O32kJ4Ky5YtY8eOHSxdupSFCxfW2N4APP/888yfP5+33nqL1atXk5uby2effVbtdq+77jree+89/vGPf7Bt2zbeeOMNHA4H7du355NPPgFgx44dpKen8/LLLwMwZ84c/v3vfzN37ly2bNnCHXfcwTXXXMO3334LBAIhf/nLX7jooovYuHEjf/3rX5k5c2a19ejTpw+nn346b731VsjyefPmceaZZ9KjR496XytUZs+ePVxwwQVceumlbNq0iQ8++IDVq1czffp0ANatW8dtt93Go48+yo4dO1iyZAnDhw8/4e0J0eIpIYSogzPPPFO99NJLSimlvF6vio+PVytWrAi+PnToUHX11VdX+f6OHTuqF198MWTZ7NmzVb9+/UKWvfjii6pjx45Vrsfv96uIiAj1v//9L7gMUJ999lmV79m2bZsCQuo7bNgwdc0111T5nnHjxqm77ror+PuIESPU7bffXu02o6Ki1Lx585RSSv3nP/9R3bt3V7quB193u93Kbrerr776SuXk5ChArVy5sso6CCGE+GOZNGmSuuSSS5RSSum6rpYuXaqsVqu6++67g68nJSUpt9sdfE9N7Y1SSqWkpKhnnnkm+LrX61Xt2rULbkup0HZux44dClBLly6ttJ4rVqxQgMrLywsuc7lcKiwsTK1Zsyak7NSpU9XEiROVUkrNmjVL9erVK+T1++67r8K6jjd37lzlcDiU0+lUSilVWFiowsLC1L/+9a9Ky9d0rVBZ/Tds2KAAtXfv3mC9b7zxxpD1rlq1ShkMBlVaWqo++eQTFRkZqQoLC6ustxB/JNKDQQhRazt27OCnn35i4sSJQKBXwIQJE3jzzTeDZTZu3Mi5557b4NvOzMzkhhtuoFu3bkRFRREZGUlRURH79++v9Tp69OjBmWeeGXz6sXv3blatWsXUqVOBQNfRxx57jD59+hAbG4vD4eCrr76q0zaO9+uvv7J7924iIiJwOBw4HA5iY2NxuVzs2bOH2NhYJk+ezJgxY7jooot4+eWX69SzQwghROu0cOFCHA4HNpuNsWPHMmHCBB5++OHg63369MFisQR/r6m9KSgoID09nSFDhgTfYzKZGDRoUJV12LhxI0ajkREjRtS63rt376akpITzzjsvWA+Hw8G///1v9uzZA8C2bdtC6gEwdOjQGtc9ceJE/H4/H374IQAffPABBoOBCRMmAA1zrXC8X3/9lfnz54fsy5gxY9B1nb1793LeeefRsWNHOnfuzLXXXss777xDSUnJCW9PiJbO1NQVEEK0HG+++SY+n482bdoElymlsFqt/POf/yQqKgq73V7n9RoMhgpjQI/PBD1p0iRycnJ4+eWX6dixI1arlaFDh9Y5sdXUqVP529/+xquvvsq8efPo0qVL8MLp2Wef5eWXX+all16iT58+hIeHM2PGjGq3oWlatXUvKipi4MCBvPPOOxXem5CQAAS6d952220sWbKEDz74gAceeIClS5dyxhln1GnfhBBCtB6jRo3i9ddfx2Kx0KZNG0ym0Mv28PDwkN9r097U1Ym06UVFRUBgyGTbtm1DXrNarSdUjzKRkZFcdtllzJs3jylTpjBv3jyuuOIKHA4HUPdrBYMh8Ky1fDt+/PVHUVERN910E7fddluF93fo0AGLxcL69etZuXIlX3/9NQ899BAPP/wwP//8M9HR0fXaXyFaIunBIISoFZ/Px7///W+ef/55Nm7cGPz59ddfadOmTTAZYt++fVm2bFmV67FYLPj9/pBlCQkJZGRkhDTwGzduDCnz/fffc9ttt3HhhRdy6qmnYrVaOXLkSJ3344orrsBgMPDuu+/y73//mylTpgTzHXz//fdccsklXHPNNfTr14/OnTuzc+fOateXkJAQ0uNg165dIU8uBgwYwK5du0hMTKRr164hP1FRUcFyp512GrNmzWLNmjX07t2bd999t877JoQQovUIDw+na9eudOjQoUJwoTI1tTdRUVGkpKTw448/Bt/j8/n45Zdfqlxnnz590HU9mDvheGU9KMq367169cJqtbJ///4K9Wjfvj0APXv2rJDf6IcffqhxHyHwoGD16tUsXLiQNWvWBHshQt2vFcoCL+Xb8eOvPwYMGMDWrVsr7EvXrl2D+28ymRg9ejTPPPMMmzZtIi0tjeXLl9dqf4RobSTAIISolYULF5KXl8fUqVPp3bt3yM+ll14aHCYxe/Zs3nvvPWbPns22bdv47bffePrpp4PrSU1N5bvvvuPQoUPBRn/kyJFkZ2fzzDPPsGfPHl599VW+/PLLkO1369aN//znP2zbto0ff/yRq6+++oSerDgcDiZMmMCsWbNIT08PZrwu28bSpUtZs2YN27Zt46abbiIzM7Pa9Z1zzjn885//ZMOGDaxbt46bb745ZJqsq6++mvj4eC655BJWrVrF3r17WblyJbfddhsHDx5k7969zJo1i7Vr17Jv3z6+/vprdu3aRc+ePeu8b0IIIf64ampvAG6//XaeeuopFixYwPbt27n11ltDZlA4XmpqKpMmTWLKlCksWLAguM6yIQodO3ZE0zQWLlxIdnY2RUVFREREcPfdd3PHHXfw9ttvs2fPHtavX88rr7zC22+/DcDNN9/Mrl27uOeee9ixYwfvvvtupbNSVWb48OF07dqV6667Ljj0sUxdrxXKgh4PP/wwu3btYtGiRTz//PMhZe677z7WrFnD9OnT2bhxI7t27eLzzz8PJnlcuHAh//jHP9i4cSP79u3j3//+N7quB2f2EOKPRgIMQohaefPNNxk9enTIU/cyl156KevWrWPTpk2MHDmSjz76iC+++IL+/ftzzjnnhDylePTRR0lLS6NLly7BJwc9e/bktdde49VXX6Vfv3789NNP3H333RW2n5eXx4ABA7j22mu57bbbSExMPKF9mTp1Knl5eYwZMyZkuMcDDzzAgAEDGDNmDCNHjiQ5OZnx48dXu67nn3+e9u3bM2zYMK666iruvvtuwsLCgq+HhYXx3Xff0aFDB/7yl7/Qs2dPpk6disvlIjIykrCwMLZv386ll17KKaecwo033si0adO46aabTmjfhBBC/DHV1N4A3HXXXVx77bVMmjSJoUOHEhEREZxKuiqvv/46l112Gbfeeis9evTghhtuCE7R2LZtWx555BFmzpxJUlJS8Kb7scce48EHH2TOnDn07NmTCy64gEWLFtGpUycgMLTgk08+YcGCBfTr14+5c+fy5JNP1mo/NU1jypQp5OXlMWXKlJDX6nqtYDabee+999i+fTt9+/bl6aef5vHHHw8p07dvX7799lt27tzJsGHDOO2003jooYeC1w/R0dF8+umnnHPOOfTs2ZO5c+fy3nvvceqpp9Zqf4RobTR1/OBhIYQQQgghhBBCiDqSHgxCCCGEEEIIIYSoNwkwCCGEEEIIIYQQot4kwCCEEEIIIYQQQoh6kwCDEEIIIYQQQggh6k0CDEIIIYQQQgghhKg3CTAIIYQQQgghhBCi3iTAIIQQQgghhBBCiHqTAIMQQgghhBBCCCHqTQIMQgghhBBCCCGEqDcJMAghhBBCCCGEEKLeJMAghBBCCCGEEEKIepMAgxBCCCGEEEIIIepNAgxCCCGEEEIIIYSoNwkwCCGEEEIIIYQQot4kwCCEEEIIIYQQQoh6kwCDEEIIIYQQQggh6k0CDEIIIYQQQgghhKg3CTAIIYQQQgghhBCi3iTAIIQQQgghhBBCiHqTAIMQQgghhBBCCCHqTQIMQgghhBBCCCGEqDcJMAghhBBCCCGEEKLeJMAghBBCCCGEEEKIepMAgxBCCCGEEEIIIepNAgxCCCGEEEIIIYSoNwkwCCGEEEIIIYQQot4kwCCEEEIIIYQQQoh6kwCDEEIIIYQQQggh6k0CDEIIIYQQQgghhKg3CTAIIYQQQgghhBCi3iTAIIQQQgghhBBCiHqTAIMQQgghhBBCCCHqTQIMQgghhBBCCCGEqDcJMAghhBBCCCGEEKLeJMAghBBCCCGEEEKIepMAgxBCCCGEEEIIIepNAgxCCCGEEEIIIYSoNwkwCCGEEEIIIYQQot4kwCCEEEIIIYQQQoh6kwCDEEIIIYQQQggh6k0CDEIIIYQQQgghhKg3CTCIJjd58mRSU1ObuhpCiCqkpaWhaRrz589v6qo0udTUVCZPnhz8feXKlWiaxsqVK5usTsc7vo7ij03aWCEaT23/vk5WOyrf/7Un7XnjkQDDH8j8+fPRNC34YzKZaNu2LZMnT+bQoUNNXb1m4/jPqfzPzJkzm7p6lXryySdZsGBBrcqWNXJlPwaDgdjYWMaOHcvatWsbt6ICgHvvvRdN05gwYcIJr2Pr1q08/PDDpKWlNVzFmrnj/zZtNhunnHIK06dPJzMzs6mrVyeLFy/m4YcfbupqiAYkbWztSBsrGsPDDz8c8rmbzWZSU1O57bbbyM/Pb+rqieNIe966mZq6AuLke/TRR+nUqRMul4sffviB+fPns3r1ajZv3ozNZmvq6jUbZZ9Teb17926i2lTvySef5LLLLmP8+PG1fs/EiRO58MIL8fv97Ny5k9dee41Ro0bx888/06dPn8ar7B+cUor33nuP1NRU/ve//+F0OomIiKjzerZu3cojjzzCyJEj/3BPJ8t/h61evZrXX3+dxYsXs3nzZsLCwk5qXYYPH05paSkWi6VO71u8eDGvvvqqXJS0QtLG1o60saIxvP766zgcDoqLi1m2bBmvvPIK69evZ/Xq1Y2yvf/3//4fuq43yrr/CKQ9b50kwPAHNHbsWAYNGgTAX//6V+Lj43n66af54osvuOKKK5q4ds1H+c+pIRUXFxMeHt7g662rAQMGcM011wR/HzZsGGPHjuX111/ntddeO6l1aS6fSW25XC4sFgsGQ907ga1cuZKDBw+yfPlyxowZw6effsqkSZMaoZat1/HfYXFxcbzwwgt8/vnnTJw4sdL3NNY5ZjAY5KZRhJA2tnakjT15mstnUlv1aWMvu+wy4uPjAbjpppu48sor+eCDD/jpp58YPHhwQ1cVs9nc4Ov8I5H2vHWSIRKCYcOGAbBnz57gMo/Hw0MPPcTAgQOJiooiPDycYcOGsWLFipD3lnUFfO655/i///s/unTpgtVq5fTTT+fnn3+usK0FCxbQu3dvbDYbvXv35rPPPqu0TsXFxdx11120b98eq9VK9+7dee6551BKhZTTNI3p06fz0Ucf0atXL+x2O0OHDuW3334D4I033qBr167YbDZGjhzZoN3Jly9fzrBhwwgPDyc6OppLLrmEbdu2hZQp67K3detWrrrqKmJiYjj77LODr//3v/9l4MCB2O12YmNjufLKKzlw4EDIOnbt2sWll15KcnIyNpuNdu3aceWVV1JQUBD8DIqLi3n77beDXc1OZLxWZecBQH5+PjNmzAgei65du/L0009XiNjn5ORw7bXXEhkZSXR0NJMmTeLXX3+tMOZw8uTJOBwO9uzZw4UXXkhERARXX301ALqu89JLL3Hqqadis9lISkripptuIi8vL2Rb69atY8yYMcTHx2O32+nUqRNTpkwJKfP+++8zcOBAIiIiiIyMpE+fPrz88sshZX7//Xcuv/xyYmNjCQsL44wzzmDRokUhZcrG5L3//vs88MADtG3blrCwMAoLC/F6vWzfvp309PRaf87vvPMOvXr1YtSoUYwePZp33nmn0nKHDh1i6tSptGnTBqvVSqdOnbjlllvweDzMnz+fyy+/HIBRo0YFj3vZuEFN0yqNpB8/li83N5e7776bPn364HA4iIyMZOzYsfz666+13p8y69atQ9M03n777QqvffXVV2iaxsKFCwFwOp3MmDGD1NRUrFYriYmJnHfeeaxfv77O2wU455xzANi7dy/QMOeYUorHH3+cdu3aERYWxqhRo9iyZUuFbVc1ZvPHH3/kwgsvJCYmhvDwcPr27Rs8/yZPnsyrr74KENJFtExD11E0LWljT4y0sdLGnkgbe7yqPvcff/yRCy64gKioKMLCwhgxYgTff/99SJnatFWV5WDIz89n8uTJREVFBY9VZcM0Ro4cyciRIyssr2ydzz33HGeeeSZxcXHY7XYGDhzIxx9/XOP+e71eHnnkEbp164bNZiMuLo6zzz6bpUuXVvkeac9XhiyX9rzupAeDCF4QxMTEBJcVFhbyr3/9i4kTJ3LDDTfgdDp58803GTNmDD/99BP9+/cPWce7776L0+nkpptuQtM0nnnmGf7yl7/w+++/B6O7X3/9NZdeeim9evVizpw55OTkcP3119OuXbuQdSmluPjii1mxYgVTp06lf//+fPXVV9xzzz0cOnSIF198MaT8qlWr+OKLL5g2bRoAc+bM4U9/+hP33nsvr732Grfeeit5eXk888wzTJkyheXLl9fqcykoKODIkSMhy8qi4t988w1jx46lc+fOPPzww5SWlvLKK69w1llnsX79+goNw+WXX063bt148skngxdwTzzxBA8++CBXXHEFf/3rX8nOzuaVV15h+PDhbNiwgejoaDweD2PGjMHtdvO3v/2N5ORkDh06xMKFC8nPzycqKor//Oc//PWvf2Xw4MHceOONAHTp0qVW+1heZedBSUkJI0aM4NChQ9x000106NCBNWvWMGvWLNLT03nppZeAwBfoRRddxE8//cQtt9xCjx49+Pzzz6t8Mu/z+RgzZgxnn302zz33XLAb3E033cT8+fO5/vrrue2229i7dy///Oc/2bBhA99//z1ms5msrCzOP/98EhISmDlzJtHR0aSlpfHpp58G17906VImTpzIueeey9NPPw3Atm3b+P7777n99tsByMzM5Mwzz6SkpITbbruNuLg43n77bS6++GI+/vhj/vznP4fU+bHHHsNisXD33XfjdruxWCwcOnSInj17MmnSpFolbnK73XzyySfcddddQKAL7fXXX09GRgbJycnBcocPH2bw4MHk5+dz44030qNHDw4dOsTHH39MSUkJw4cP57bbbuMf//gH999/Pz179gQI/ltbv//+OwsWLODyyy+nU6dOZGZm8sYbbzBixAi2bt1KmzZtar2uQYMG0blzZz788MMKx/2DDz4gJiaGMWPGAHDzzTfz8ccfM336dHr16kVOTg6rV69m27ZtDBgwoE77AMcuHOPi4oLL6nOOATz00EM8/vjjXHjhhVx44YWsX7+e888/H4/HU2N9li5dyp/+9CdSUlK4/fbbSU5OZtu2bSxcuJDbb7+dm266icOHD7N06VL+85//VHj/yaijOHmkja2ctLHSxpbXEG1sbT/35cuXM3bsWAYOHMjs2bMxGAzMmzePc845h1WrVgV7OpxIW6WU4pJLLmH16tXcfPPN9OzZk88++6zePRVffvllLr74Yq6++mo8Hg/vv/8+l19+OQsXLmTcuHFVvu/hhx9mzpw5wXO4sLCQdevWsX79es4777xK3yPt+THSnp8gJf4w5s2bpwD1zTffqOzsbHXgwAH18ccfq4SEBGW1WtWBAweCZX0+n3K73SHvz8vLU0lJSWrKlCnBZXv37lWAiouLU7m5ucHln3/+uQLU//73v+Cy/v37q5SUFJWfnx9c9vXXXytAdezYMbhswYIFClCPP/54yPYvu+wypWma2r17d3AZoKxWq9q7d29w2RtvvKEAlZycrAoLC4PLZ82apYCQstV9TpX9lN+XxMRElZOTE1z266+/KoPBoK677rrgstmzZytATZw4MWQbaWlpymg0qieeeCJk+W+//aZMJlNw+YYNGxSgPvroo2rrHB4eriZNmlRtmTJlx+yRRx5R2dnZKiMjQ61atUqdfvrpFbb12GOPqfDwcLVz586QdcycOVMZjUa1f/9+pZRSn3zyiQLUSy+9FCzj9/vVOeecowA1b9684PJJkyYpQM2cOTNknatWrVKAeuedd0KWL1myJGT5Z599pgD1888/V7mPt99+u4qMjKhtg04AAQAASURBVFQ+n6/KMjNmzFCAWrVqVXCZ0+lUnTp1Uqmpqcrv9yullFqxYoUCVOfOnVVJSUmln2VtP/uPP/5YAWrXrl1KKaUKCwuVzWZTL774Yki56667ThkMhkr3Udd1pZRSH330kQLUihUrKpQB1OzZsyss79ixY0hdXS5XcD/L75PValWPPvpohf0sfxwrM2vWLGU2m0O+C9xut4qOjg753oiKilLTpk2rdl2Vqew77P3331dxcXHKbrergwcPKqXqf45lZWUpi8Wixo0bF/y8lVLq/vvvr3C8y86PsuPg8/lUp06dVMeOHVVeXl7Idsqva9q0aSHfKY1ZR3FySBsrbaxS0saWOdltbNm5sGPHDpWdna3S0tLUW2+9pex2u0pISFDFxcVKqcD3cLdu3dSYMWNCvjtLSkpUp06d1HnnnRdcVpu2atKkSZX+fT3zzDPBZT6fTw0bNqzCsRoxYoQaMWJEjessq195Ho9H9e7dW51zzjkhy49v5/v166fGjRtX7T5URtpzac/rQ4ZI/AGNHj2ahIQE2rdvz2WXXUZ4eDhffPFFyFMOo9EYTHKi6zq5ubn4fD4GDRpUabenCRMmhESHy7qk/f777wCkp6ezceNGJk2aRFRUVLDceeedR69evULWtXjxYoxGI7fddlvI8rvuugulFF9++WXI8nPPPTfkacaQIUMAuPTSS0OS55UtL6tTTV599VWWLl0a8lN+XyZPnkxsbGywfN++fTnvvPNYvHhxhXXdfPPNIb9/+umn6LrOFVdcwZEjR4I/ycnJdOvWLdhNtuyz+uqrrygpKalVvWtr9uzZJCQkkJyczLBhw9i2bRvPP/88l112WbDMRx99xLBhw4iJiQmp5+jRo/H7/Xz33XcALFmyBLPZzA033BB8r8FgCD7xqswtt9wS8vtHH31EVFQU5513Xsi2Bg4ciMPhCH4m0dHRACxcuBCv11vpuqOjoykuLq62C+DixYsZPHhwSHdah8PBjTfeSFpaGlu3bg0pP2nSJOx2e8iy1NRUlFK1frLyzjvvMGjQILp27QpAREQE48aNCxkmoes6CxYs4KKLLqp0fHL5rnf1ZbVag2Nc/X4/OTk5OBwOunfvfkLdGydMmIDX6w150vX111+Tn58fMmNGdHQ0P/74I4cPHz6hepf/DrvyyitxOBx89tlntG3bNqTciZ5j33zzDR6Ph7/97W8hn/eMGTNqrNuGDRvYu3cvM2bMCJ6rZWpz7E5GHUXjkjZW2liQNrYp2liA7t27k5CQQGpqKlOmTKFr1658+eWXwafeGzduZNeuXVx11VXk5OQEP4fi4mLOPfdcvvvuu+DwlBNpqxYvXozJZAr5/I1GI3/7299qvY7KlP9s8vLyKCgoYNiwYTW21dHR0WzZsoVdu3bVaXvSnkt7Xh8yROIP6NVXX+WUU06hoKCAt956i++++w6r1Vqh3Ntvv83zzz/P9u3bQxqZ47M+A3To0CHk97ILobIxRvv27QOgW7duFd57/M3Mvn37aNOmTYXM+mXdv8vWVdW2yy4Y2rdvX+ny48c9VWXw4MGV3uCVbb979+4VXuvZsydfffVVhQQ0x39mu3btQilV6ecBx5IGderUiTvvvJMXXniBd955h2HDhnHxxRdzzTXXhFxEnogbb7yRyy+/HJfLxfLly/nHP/6B3++vUM9NmzaRkJBQ6TqysrKAwGeSkpJSIeNv2Y308UwmU4Vuu7t27aKgoIDExMRqtzVixAguvfRSHnnkEV588UVGjhzJ+PHjueqqq4Ln8a233sqHH37I2LFjadu2Leeffz5XXHEFF1xwQXB9+/btC14Ql1f+PCuf0byy874u8vPzWbx4MdOnT2f37t3B5WeddRaffPIJO3fu5JRTTiE7O5vCwsKTkk1d13VefvllXnvtNfbu3Rty/Mt3T6ytfv360aNHDz744AOmTp0KBLpTxsfHB8dVAjzzzDNMmjSJ9u3bM3DgQC688EKuu+46OnfuXKvtlH2HmUwmkpKS6N69e4VkYPU5x6r6vkpISAi5yatMWffOEz1+J6OOonFJGyttLEgbe7Lb2DKffPIJkZGRZGdn849//IO9e/eG3JyX3WhXN2ShoKCAmJiYE2qryo6Vw+EIWV7Z+VwXCxcu5PHHH2fjxo243e7g8ppudB999FEuueQSTjnlFHr37s0FF1zAtddeS9++fat9n7Tn0p7XhwQY/oDKN+rjx4/n7LPP5qqrrmLHjh3BL8T//ve/TJ48mfHjx3PPPfeQmJiI0Whkzpw5FRLlQCA6Wxl1XMKoxlDVtpuyTsc7Piqv6zqapvHll19WWs/yDdPzzz/P5MmT+fzzz/n666+57bbbmDNnDj/88EOFL9y66NatG6NHjwbgT3/6E0ajkZkzZzJq1Kjg+aHrOueddx733ntvpes45ZRTTmjb5Z+cl9F1ncTExCqTHpZdgGmaxscff8wPP/zA//73P7766iumTJnC888/zw8//IDD4SAxMZGNGzfy1Vdf8eWXX/Lll18yb948rrvuukqTFtXG8cewrj766CPcbjfPP/88zz//fIXX33nnHR555JF6baMmx1/cPvnkkzz44INMmTKFxx57jNjYWAwGAzNmzDjhabcmTJjAE088wZEjR4iIiOCLL75g4sSJmEzHmpsrrriCYcOG8dlnn/H111/z7LPP8vTTT/Ppp58yduzYGrdR1Y1JefU5x5pSS6ijqJ60sdLGgrSxdVXfNrbM8OHDg7k8LrroIvr06cPVV1/NL7/8gsFgCLZtzz77bIVcJ2XKzo/6tlU10TSt0r+X49vqVatWcfHFFzN8+HBee+01UlJSMJvNzJs3j3fffbfabQwfPpw9e/YEz+9//etfvPjii8ydO5e//vWv1b5X2vP6aQl1bCwSYPiDK7ugGTVqFP/85z+ZOXMmAB9//DGdO3fm008/DYmOzp49+4S207FjR4BKu2jt2LGjQtlvvvkGp9MZ8oRl+/btIetqKmXbP77eEKhjfHx8jdPndOnSBaUUnTp1qtUFRJ8+fejTpw8PPPAAa9as4ayzzmLu3Lk8/vjjQMN0m//73//O//t//48HHniAJUuWBOtZVFQUvEiqSseOHVmxYgUlJSUhT1jKP6mvSZcuXfjmm28466yzanWhccYZZ3DGGWfwxBNP8O6773L11Vfz/vvvBxtMi8XCRRddxEUXXYSu69x666288cYbPPjgg3Tt2pWOHTtWeQzL9qkhvfPOO/Tu3bvSv6E33niDd999l0ceeYSEhAQiIyPZvHlzteur7pjHxMRUyFjt8XgqZOL++OOPGTVqFG+++WbI8vz8/OAFWl1NmDCBRx55hE8++YSkpCQKCwu58sorK5RLSUnh1ltv5dZbbyUrK4sBAwbwxBNPNMhFW1Vqe46V/74q/xQmOzu7xqezZcnfNm/eXO3fTVXH72TUUZw80sbWnbSxFUkbe2IcDgezZ8/m+uuv58MPP+TKK68MfkdH/n/27jy+qTJr4PgvS9OkOwW6YYGyb2URpFYUYaxUQWaqOArqCIiiDCCbbC6IiqIggijLoCOoo4PiwquoSEGQQSqyikWBFoEidAG6pE2bNst9/4i9NLRAq23T5Xw/n2jvvU+SkwC9ybnPc05AwBXfd6j6uapVq1Zs2bKFgoICt0RWRe9FkyZNKlxSdPEsoo8//hij0cjXX3/tNhtq9erVV4wfIDg4mNGjRzN69GgKCgro378/c+fOrVSCQc7ncj7/I6QGg2DAgAH07duXJUuWYLVagQtXJspmVnft2kVSUtIfeo7w8HB69uzJ22+/rbZ+Ald11ovX4Q0ePBiHw8Hrr7/utn/x4sVoNJoa/YVVGWVfS9kvccnJyWzatInBgwdf8THuuOMOdDodzzzzTLnstaIonD9/HnBVGrfb7W7Ho6Oj0Wq1blPkfH19K2yBVBVBQUE8/PDDfP311xw4cABwZaaTkpL4+uuvy43Pzc1VY4uPj8dms/HGG2+ox51Op9q6pzLuuusuHA4Hzz33XLljdrtdfX05OTnl3rPSqxCl70np+1dKq9Wq0wFLxwwePJgffvjB7e+0xWJh1apVtG7duty65YpUtoXWqVOn2L59O3fddRd33nlnudvo0aNJTU1l165daLVaEhIS+Pzzz9mzZ0+5xyp97aUfsCv6c2/btq26drfUqlWryl0V0el05d7LdevWcfr06Su+9kvp3Lkz0dHRfPDBB3zwwQeEh4fTv39/9bjD4XD7HQAQEhJCRESE29/pmlDZv2NxcXF4eXnx2muvub0/pRXdL+fqq68mKiqKJUuWlPuzKftYl/rzq40YRe2Sc2zVyDnWRc6xlT/HXs69997LVVddpXa76N27N23btuXll1+moKCg3PizZ88Cf/xcNXjwYOx2OytWrFD3ORwOXnvttXJj27Zty+HDh9XnBPjxxx/LtcvU6XRoNBq3c/iJEydYv379ZV65y8V/Vn5+frRr165S51s5n8v5/I+SGQwCgOnTp/P3v/+dNWvW8Mgjj3DbbbfxySefcPvttzNkyBCOHz/OypUr6dKlS4W/kCtj/vz5DBkyhOuvv54HHniA7OxsXnvtNbp27er2mEOHDmXgwIE88cQTnDhxgh49erBp0yb+7//+j8mTJ/+h9lDVbeHChdx6663ExsYyZswYtYVWYGAgc+fOveL927Zty7x585g9ezYnTpwgISEBf39/jh8/zqeffsrYsWN57LHH+Oabb5gwYQJ///vf6dChA3a7nXfffRedTsewYcPUx+vduzebN2/mlVdeISIigqioqArXPl7JpEmTWLJkCS+++CJr165l+vTpfPbZZ9x2222MGjWK3r17Y7FY+Omnn/joo484ceIEzZo1IyEhgb59+zJt2jRSU1Pp1KkTn332GdnZ2UDlrv7ceOONPPzww8yfP58DBw4waNAgvLy8SElJYd26dbz66qvceeedvP322yxfvpzbb7+dtm3bkp+fzxtvvEFAQID6wfPBBx8kOzubv/zlL1x11VWcPHmS1157jZ49e6rrP2fNmsV///tfbr31Vh599FGCg4N5++23OX78OB9//HG56XgVqWwLrffff19tDVeRwYMHo9free+994iJieGFF15g06ZN3HjjjYwdO5bOnTuTnp7OunXr2LFjB0FBQfTs2ROdTsdLL71EXl4e3t7e/OUvfyEkJIQHH3yQRx55hGHDhnHzzTfz448/8vXXX5eblXDbbbfx7LPPMnr0aK677jp++ukn3nvvvUqvnbyUu+++mzlz5mA0GhkzZozbe5mfn89VV13FnXfeSY8ePfDz82Pz5s3s3r27wqUj1amyf8eaN2/OY489prbjGzx4MPv37+err7664swOrVbLihUrGDp0KD179mT06NGEh4dz+PBhDh06pH6R6N27NwCPPvoo8fHx6HQ6hg8fXisxiton59iqkXOsnGOh8ufYy/Hy8mLSpElMnz6djRs3csstt/Dmm29y66230rVrV0aPHk2LFi04ffo0W7duJSAggM8///wPn6uGDh1Kv379mDVrFidOnKBLly588skn5b6IAzzwwAO88sorxMfHM2bMGLKysli5ciVdu3bFbDar44YMGcIrr7zCLbfcwj333ENWVhbLli2jXbt2HDx48LKvv0uXLgwYMIDevXsTHBzMnj171LaSlSHnczmf/yG10apC1A2lLWEqaj3kcDiUtm3bKm3btlXsdrvidDqVF154QWnVqpXi7e2t9OrVS9mwYUO51jmlLYQWLlxY7jGpoFXexx9/rHTu3Fnx9vZWunTponzyyScVtuPJz89XpkyZokRERCheXl5K+/btlYULF7q1byl9jovb41wqptL2M1dqR3W596mszZs3K/369VNMJpMSEBCgDB06VPn555/dxpS2TTp79myFj/Hxxx8r119/veLr66v4+voqnTp1UsaPH68cOXJEURRF+fXXX5UHHnhAadu2rWI0GpXg4GBl4MCByubNm90e5/Dhw0r//v0Vk8l0xZY2l/szUxRFGTVqlKLT6dRWZfn5+crs2bOVdu3aKQaDQWnWrJly3XXXKS+//LJSUlKi3u/s2bPKPffco/j7+yuBgYHKqFGjlO+++04BlLVr16rjRo4cqfj6+l4yvlWrVim9e/dWTCaT4u/vr0RHRyszZsxQzpw5oyiKouzbt08ZMWKE0rJlS8Xb21sJCQlRbrvtNmXPnj3qY3z00UfKoEGDlJCQEMVgMCgtW7ZUHn74YSU9Pd3tuY4dO6bceeedSlBQkGI0GpW+ffsqGzZscBtzub83lW2hFR0drbRs2fKyYwYMGKCEhIQoNptNURRFOXnypHL//ferLe7atGmjjB8/3q213RtvvKG0adNG0el0bq2VHA6HMnPmTKVZs2aKj4+PEh8fr6SmplbYpnLatGlKeHi4YjKZlH79+ilJSUnlWmdVtk1lqZSUFLXt3I4dO9yOFRcXK9OnT1d69Oih+Pv7K76+vkqPHj2U5cuXX/FxK/tv88/+HVMU13v4zDPPqO/NgAEDlOTk5HLv4cVtrUrt2LFDufnmm9XX2L17d+W1115Tj9vtdmXixIlK8+bNFY1GU67FVXXGKGqHnGPlHKsoco4tq7bOsYpy+b8LeXl5SmBgoNt5bf/+/codd9yhNG3aVPH29lZatWql3HXXXcqWLVsURan8uaqif1/nz59X/vGPfygBAQFKYGCg8o9//ENtiXrxefQ///mP0qZNG8VgMCg9e/ZUvv766wof89///rfSvn17xdvbW+nUqZOyevVq9TWXdfHv/3nz5il9+/ZVgoKCFJPJpHTq1El5/vnn3f5uXY6cz+V8/kdoFMUD1XiEEI3C+vXruf3229mxYwf9+vXzdDhCCCFEgyHnWCFEXSQJBiFEtSgqKnIrYuNwOBg0aBB79uwhIyOj2ipECyGEEI2NnGOFEPWF1GAQQlSLiRMnUlRURGxsLMXFxXzyySfs3LmTF154QT74CCGEEH+CnGOFEPWFzGAQQlSL999/n0WLFpGamorVaqVdu3aMGzeu0oWEhBBCCFExOccKIeoLSTAIIYQQQgghhBDiT7tyj5gatH37doYOHUpERAQajaZcP1eNRlPhbeHCheqY1q1blzv+4osvuj3OwYMHueGGGzAajURGRrJgwYJysaxbt45OnTphNBqJjo7myy+/dDuuKApz5swhPDwck8lEXFwcKSkp1fdmCCGEEEIIIYQQ9ZhHEwwWi4UePXqwbNmyCo+np6e73d566y00Go1bb2KAZ5991m3cxIkT1WNms5lBgwbRqlUr9u7dy8KFC5k7dy6rVq1Sx+zcuZMRI0YwZswY9u/fT0JCAgkJCSQnJ6tjFixYwNKlS1m5ciW7du3C19eX+Ph4rFZrNb8rQgghhBBCCCFE/VNnlkhoNBo+/fRTEhISLjkmISGB/Px8tmzZou5r3bo1kydPZvLkyRXeZ8WKFTzxxBNkZGRgMBgAmDVrFuvXr+fw4cMA3H333VgsFjZs2KDe79prr6Vnz56sXLkSRVGIiIhg2rRpPPbYYwDk5eURGhrKmjVrGD58eKVeo9Pp5MyZM/j7+6PRaCp1HyGEEKI+URSF/Px8IiIi0Go9eh2jUuTcLIQQoqGr1XOzUkcAyqeffnrJ4xkZGYper1fee+89t/2tWrVSQkNDleDgYKVnz57KggULFJvNph7/xz/+ofztb39zu88333yjAEp2draiKIoSGRmpLF682G3MnDlzlO7duyuKoijHjh1TAGX//v1uY/r37688+uijl4zZarUqeXl56u3nn39WALnJTW5yk5vcGvzt1KlTlzw/1iWnTp3y+HslN7nJTW5yk1tt3Grj3Fxv2lS+/fbb+Pv7c8cdd7jtf/TRR7n66qsJDg5m586dzJ49m/T0dF555RUAMjIyiIqKcrtPaGioeqxJkyZkZGSo+8qOycjIUMeVvV9FYyoyf/58nnnmmXL7T506RUBAQGVethBCCFGvmM1mIiMj8ff393QolVIap5ybhRBCNFS1eW6uNwmGt956i3vvvRej0ei2f+rUqerP3bt3x2Aw8PDDDzN//ny8vb1rO0w3s2fPdouv9A82ICBAPsQIIYRo0OrLcoPSOOXcLIQQoqGrjXNz3V8cCfzvf//jyJEjPPjgg1ccGxMTg91u58SJEwCEhYWRmZnpNqZ0Oyws7LJjyh4ve7+KxlTE29tb/cAiH1yEEEIIIYQQQjRk9SLB8O9//5vevXvTo0ePK449cOAAWq2WkJAQAGJjY9m+fTs2m00dk5iYSMeOHWnSpIk6pmzhyNIxsbGxAERFRREWFuY2xmw2s2vXLnWMEEIIIYQQQgjRmHl0iURBQQGpqanq9vHjxzlw4ADBwcG0bNkScH2RX7duHYsWLSp3/6SkJHbt2sXAgQPx9/cnKSmJKVOmcN9996nJg3vuuYdnnnmGMWPGMHPmTJKTk3n11VdZvHix+jiTJk3ixhtvZNGiRQwZMoS1a9eyZ88etZWlRqNh8uTJzJs3j/bt2xMVFcVTTz1FRETEZbteCCGEEEIIIYQQjYVHEwx79uxh4MCB6nZpvYKRI0eyZs0aANauXYuiKIwYMaLc/b29vVm7di1z586luLiYqKgopkyZ4lb3IDAwkE2bNjF+/Hh69+5Ns2bNmDNnDmPHjlXHXHfddbz//vs8+eSTPP7447Rv357169fTrVs3dcyMGTOwWCyMHTuW3Nxcrr/+ejZu3FiuJoQQQgghhBBCCNEYaRRFUTwdRGNhNpsJDAwkLy9P6jEIIYRokOrbua6+xSvqL6dT4XRuEZYSO74GPS2CTGi19aMYqhCifqvNc1296SIhhBBCCCFEfZSalc/XyZkcO1uA1e7AqNfRtrkf8d1CaRdSP1q6CiFEZUiCQQghhBBCiBqSmpXP6u9OkG0pITzQiI/BRGGJneQzeZzJK2J0v9aSZBBCNBj1oouEEEIIIYQQ9Y3TqfB1cibZlhLah/jhb/RCp9Xgb/SifYgf2ZYSNh3KxOmUFctCiIZBEgxCCCFEY2SzwZIlcFGbZiFE9TmdW8SxswWEBxrRaNzrLWg0GsIDjaRmFXA6t8hDEQohRPWSJRJCCCFEY7N1K0ycCIcOQceOcPAgGAyejkqIBsdSYsdqd+BjMFV43GTQkWm2Yimx13JkQghRM2QGgxBCCNGYPP44/OUvruRC06YwbRro5XqDEDXB16DHqNdReIkEQlGJA2+9Dl+D/BsUQjQMkmAQQgghGpObbgKtFv75Tzh6FB56yLUthKh2LYJMtG3uR3qelYs7wyuKQnqelXYhfrQIqniGgxBC1DeSLhVCCCEaso0bIT0dRo92bd90E6SmQlSUZ+MSohHQajXEdwvlTF4RKVmuWgwmg46iEgfpeVaCfQ0M6hqKVqu58oMJIUQ9IJcshBBCiIbo+HFISIBbb3XVWzh9+sIxSS4IUWvahfgzul9rukUEklto48Q5C7mFNqJbBEqLSiFEgyMzGIQQQoiGpKgIXnrJdbNaQaeDsWPBX77ECOEp7UL8aTPAj9O5RVhK7Pga9LQIMsnMBSFEgyMzGIQQQoiGQFHg//4PunSBZ55xJRcGDoQff4RXXoGAgEo9zPbt2xk6dCgRERFoNBrWr1/vdnzUqFFoNBq32y233FLucR588EECAgIICgpizJgxFBQUuB0/ePAgN9xwA0ajkcjISBYsWFDuMdatW0enTp0wGo1ER0fz5ZdfXvSSFebMmUN4eDgmk4m4uDhSUlIq9TqFqG1arYbIYB86hQUQGewjyQUhRIMkCQYhhBCiITh1Cv7+dzhxAq66Cj74ALZsga5dq/QwFouFHj16sGzZskuOueWWW0hPT1dv//3vf8uNOXz4MImJiWzYsIHt27czduxY9ZjZbGbQoEG0atWKvXv3snDhQubOncuqVavUMTt37mTEiBGMGTOG/fv3k5CQQEJCAsnJyeqYBQsWsHTpUlauXMmuXbvw9fUlPj4eq9VapdcshBBCiOqhUS4uaStqjNlsJjAwkLy8PAIqeSVJCCGEuCS73b3F5FNPgcPhakXp5/enH16j0fDpp5+SkJCg7hs1ahS5ubnlZjaU2r17N3379mXr1q0MGDAAgI0bNzJ48GB+++03IiIiWLFiBU888QQZGRkYDAYAZs2axfr16zl8+DAAd999NxaLhQ0bNqiPfe2119KzZ09WrlyJoihEREQwbdo0HnvsMQDy8vIIDQ1lzZo1DB8+vFKvUc7NQgghGrraPNfJDAYhhBCivlEU1wyFtm1h374L+597Dl54oVqSC5ezbds2QkJC6NixI+PGjeP8+fPqsR9++AGAq6++Wt0XFxeHVqtl165dACQlJdG/f381uQAQHx/PkSNHyMnJUcfExcW5PW98fDxJSUkAHD9+nIyMDLcxgYGBxMTEqGMqUlxcjNlsdrsJIYQQonpIgkEIIYSoTw4dcrWaHD4c0tJcxRxr0S233MI777zDli1beOmll/j222+59dZbcTgcAGRmZpa7j16vJzg4mIyMDAAyMjIIDQ11G1O6faUxZY+XvV9FYyoyf/58AgMD1VtkZGSlX7sQQgghLk+6SAghhBD1QV6eq3jj0qWuZRBGI8yaBTNm1GoYZZceREdH0717d9q2bcu2bdu46aabajWWP2L27NlMnTpV3TabzZJkEEIIIaqJzGAQQggh6rp166BjR1i82JVcSEiAn3+Gp58Gk8mjobVp04ZmzZqRmpoKlJ9RAGC328nOziYsLAyAsLCwcjMdSrevNKbs8bL3q2hMRby9vQkICHC7CSGEEKJ6SIJBCCGEqOvOnYPMTGjfHr76Cj79FKKiPB0VAL/99hvnz58nPDwcgL59+wKwf/9+dcw333yD0+kkJiYGgNjYWLZv347NZlPHJCYm0rFjR5o0aaKO2bJli9tzJSYmEhsbC0BUVBRhYWFuY8xmM7t27VLHCCGEEKJ2SYJBCCGEqGuys6HMF3TGjoVVq+Cnn+CWW2r0qQsKCjhw4AAHDhwAXMUUDxw4QFpaGgUFBUyfPp3vv/+eEydOsGXLFv72t7/Rrl074uPjAejYsSMAjz76KD/88APfffcdEyZMYPjw4URERABwzz33YDAYGDNmDIcOHeKDDz7g1VdfdVu6MGnSJDZu3MiiRYs4fPgwc+fOZc+ePUyYMAFwdbiYPHky8+bN47PPPuOnn37i/vvvJyIiwq3rhRBCCCFqj9RgEEIIIeoKhwPeegtmzwZ/f9cyCJMJdDp46KFaCWHPnj0MHDhQ3S790j9y5EhWrFjBwYMHefvtt8nNzSUiIoJBgwbx3HPP4e3t7fY4HTp04KabbkKr1TJs2DCWLl2qHgsMDGTTpk2MHz+e3r1706xZM+bMmcPYsWPVMddddx3vv/8+Tz75JI8//jjt27dn/fr1dOvWTR0zY8YMLBYLY8eOJTc3l+uvv56NGzdiNBpr6u0RQgghxGVoFEVRPB1EYyG9toUQQlzSrl0wYQLs2ePa7toV1q+Hdu08GlZV1bdzXX2LVwghhKiq2jzXyRIJIYQQwpOysmDMGLj2WldyISDAVcxx//56l1wQQgghROMmSySEEEIITzl9Grp1g9xc1/bIkfDii3CZLghCCCGEEHWVJBiEEEIIT2nRAm68EdLS4PXX4brrPB2REEIIIcQfJkskhBBCiNpy5gw8+CBkZFzYt3o17N4tyQUhRI1zOhVOZRdyOMPMqexCnE4pxSaEqF4eTTBs376doUOHEhERgUajYf369W7HR40ahUajcbvdclF7ruzsbO69914CAgIICgpizJgxFBQUuI05ePAgN9xwA0ajkcjISBYsWFAulnXr1tGpUyeMRiPR0dF8+eWXbscVRWHOnDmEh4djMpmIi4sjJSWlet4IIYQQDVtJCbz8MnTsCP/+N8yadeFYkyauLhFCCFGDUrPyWbHtGIsTj7J0SwqLE4+yYtsxUrPyPR2aEKIB8WiCwWKx0KNHD5YtW3bJMbfccgvp6enq7b///a/b8XvvvZdDhw6RmJjIhg0b2L59u1ubK7PZzKBBg2jVqhV79+5l4cKFzJ07l1WrVqljdu7cyYgRIxgzZgz79+8nISGBhIQEkpOT1TELFixg6dKlrFy5kl27duHr60t8fDxWq7Ua3xEhhBANzubN0KMHTJ8OBQUQE+PqFiGEELUkNSuf1d+dIPlMHkE+XrRp5keQjxfJZ/JY/d0JSTIIIapNnWlTqdFo+PTTT0lISFD3jRo1itzc3HIzG0r98ssvdOnShd27d9OnTx8ANm7cyODBg/ntt9+IiIhgxYoVPPHEE2RkZGAwGACYNWsW69ev5/DhwwDcfffdWCwWNmzYoD72tddeS8+ePVm5ciWKohAREcG0adN47LHHAMjLyyM0NJQ1a9YwfPjwSr1GaYUlhBCNSFoaTJ0KH3/s2m7eHF56yVXIUdtwVyjWt3NdfYtXiKpyOhVWbDtG8pk82of4odFo1GOKopCSVUB0i0AeubEtWq3mMo8khKivpE1lGdu2bSMkJISOHTsybtw4zp8/rx5LSkoiKChITS4AxMXFodVq2bVrlzqmf//+anIBID4+niNHjpCTk6OOiYuLc3ve+Ph4kpKSADh+/DgZGRluYwIDA4mJiVHHVKS4uBiz2ex2E0II0UgsXepKLmi18OijcPQojB7doJMLQoi653RuEcfOFhAeaHRLLoDrAl94oJHUrAJO5xZ5KEIhRENSpz/l3HLLLbzzzjts2bKFl156iW+//ZZbb70Vh8MBQEZGBiEhIW730ev1BAcHk/F7Aa2MjAxCQ0PdxpRuX2lM2eNl71fRmIrMnz+fwMBA9RYZGVml1y+EEKKeKVsD6Kmn4I47YP9+ePVVCAryWFhCiMbLUmLHanfgY6i4eZzJoKPY7sBSYq/lyIQQDVGdblNZdulBdHQ03bt3p23btmzbto2bbrrJg5FVzuzZs5k6daq6bTabJckghBAN0bFjMHky5OfD1q2g0UBg4IXlEUII4SG+Bj1GvY7CEjv+Rq9yx4tKHHjrdfheIgEhhBBVUadnMFysTZs2NGvWjNTUVADCwsLIyspyG2O328nOziYsLEwdk5mZ6TamdPtKY8oeL3u/isZUxNvbm4CAALebEEKIBqSw0DVToWtX2LABvvsODh70dFRCCKFqEWSibXM/0vOsXFx6TVEU0vOstAvxo0WQyUMRCiEaknqVYPjtt984f/484eHhAMTGxpKbm8vevXvVMd988w1Op5OYmBh1zPbt27HZbOqYxMREOnbsSJMmTdQxW7ZscXuuxMREYmNjAYiKiiIsLMxtjNlsZteuXeoYIYQQjYiiwCefQOfOMG8eFBfDzTfDTz+5OkYIIUQdodVqiO8WSrCvgZSsAvKtNuxOJ/lWGylZBQT7GhjUNVQKPAohqoVHEwwFBQUcOHCAAwcOAK5iigcOHCAtLY2CggKmT5/O999/z4kTJ9iyZQt/+9vfaNeuHfHx8QB07tyZW265hYceeogffviB7777jgkTJjB8+HAiIiIAuOeeezAYDIwZM4ZDhw7xwQcf8Oqrr7otXZg0aRIbN25k0aJFHD58mLlz57Jnzx4m/N5GTKPRMHnyZObNm8dnn33GTz/9xP33309ERIRb1wshhBCNwNmzEB8Pw4a5OkW0bOlaCvH119Cpk6ejE0KIctqF+DO6X2u6RQSSW2jjxDkLuYU2olsEMrpfa9qF+Hs6RCFEA+HRNpXbtm1j4MCB5faPHDmSFStWkJCQwP79+8nNzSUiIoJBgwbx3HPPuRVbzM7OZsKECXz++edotVqGDRvG0qVL8fPzU8ccPHiQ8ePHs3v3bpo1a8bEiROZOXOm23OuW7eOJ598khMnTtC+fXsWLFjA4MGD1eOKovD000+zatUqcnNzuf7661m+fDkdOnSo9OuVVlhCCNEA2O3QqxekpMCMGTBrFvj4eDqqOqO+nevqW7xC/BlOp8Lp3CIsJXZ8DXpaBJlk5oIQjUBtnus8mmBobORDjBBC1EOlyyFuuw28vV379u+HgABo29azsdVB9e1cV9/iFUIIIaqqNs919aoGgxBCCFGrDh6EAQPgzjvhlVcu7O/VS5ILQgghhBAXkQSDEEIIcbHcXJg0Ca6+GrZvB5PpwuwFIYQQQghRIWl4K4QQQpRyOuHtt2HmTFcxR3DNXli0yFXMUQghhBBCXJIkGIQQQohSM2fCyy+7fu7UCV57DeLiPBuTEEIIIUQ9IUskhBBCiFJjx0LTpq4kw48/SnJBCCGEEKIKZAaDEEKIxsnhgDfegOPH4aWXXPvat4dTp1w1F4QQQgghRJXIDAYhhBCNz86dcM01MG4cLFwIBw5cONbIkwvbt29n6NChREREoNFoWL9+vXrMZrMxc+ZMoqOj8fX1JSIigvvvv58zZ86Ue5zAwEA0Go16e/HFF92OHzx4kBtuuAGj0UhkZCQLFiwo9xjr1q2jU6dOGI1GoqOj+fLLL92OK4rCnDlzCA8Px2QyERcXR0pKSvW8EUIIIYSoMkkwCCGEaDwyMmDUKOjXD/bvh8BAWLoUunXzdGR1hsVioUePHixbtqzcscLCQvbt28dTTz3Fvn37+OSTTzhy5Ah//etfy4194oknSE9PV28TJ05Uj5nNZgYNGkSrVq3Yu3cvCxcuZO7cuaxatUods3PnTkaMGMGYMWPYv38/CQkJJCQkkJycrI5ZsGABS5cuZeXKlezatQtfX1/i4+OxWq3V/K4IIYQQojI0iqIong6isTCbzQQGBpKXl0dAQICnwxFCiMbDZoNly+Dpp8Fsdu0bMwZeeAFCQjwbWx2m0Wj49NNPSUhIuOSY3bt307dvX06ePEnLli3Vc938+fOZNWtWhfdZsWIFTzzxBBkZGRgMBgBmzZrF+vXrOXz4MAB33303FouFDRs2qPe79tpr6dmzJytXrkRRFCIiIpg2bRqPPfYYAHl5eYSGhrJmzRqGDx9eqdco52YhhBANXW2e62QGgxBCiIYvPx/mzXMlF/r0ge+/hzfflORCNcjLy0Oj0RAUFOS2f/HixTRt2pRevXqxcOFC7Ha7eiwpKYn+/furyQWA+Ph4jhw5Qk5Ojjom7qIim/Hx8SQlJQFw/PhxMjIy3MYEBgYSExOjjqlIcXExZrPZ7SaEEEKI6iFFHoUQQjRMWVnQvDloNBAcDK++CoWF8MADoNN5OroGwWq1MnPmTEaMGFHuishbb71FZGQkO3fuZPbs2aSnp/PKK68AkJGRQVRUlNv40NBQ9ViTJk3IyMhQ95Udk5GRoY4re7+KxlRk/vz5PPPMM3/g1QohhBDiSmQGgxBCiIaluNjVFaJNG/j00wv7770XHnpIkgvVxGazcdddd6EoCitWrCh3/IYbbqB79+488sgjLFq0iNdee43i4mIPROpu9uzZ5OXlqbdTp055OiQhhBCiwZAEgxBCiIbj66+he3eYNQssFli3ztMRNUilyYWTJ0+SmJh4xfWcMTEx2O12Tpw4AUBYWBiZmZluY0q3w8LCLjum7PGy96toTEW8vb0JCAhwuwkhhBCiekiCQQghRP134gTcfjvccgscPQqhofDOO/D++56OrMEpTS6kpKSwefNmmjZtesX7HDhwAK1WS8jvNS9iY2PZvn07NptNHZOYmEjHjh1p0qSJOmbLli1uj5OYmEhsbCwAUVFRhIWFuY0xm83s2rVLHSOEEEKI2iU1GIQQQtRvq1bBpElgtbqWP0yaBHPmuFpQiiorKCggNTVV3T5+/DgHDhwgODiY8PBw7rzzTvbt28eGDRtwOBxqvYPg4GAMBgM//PADAD/99BPh4eEkJSUxZcoU7rvvPjV5cM899/DMM88wZswYZs6cSXJyMq+++iqLFy9Wn3fSpEnceOONLFq0iCFDhrB27Vr27NmjtrLUaDRMnjyZefPm0b59e6KionjqqaeIiIi4bNcLIYQQQtQcSTAIIYSo31q3diUXBg6E116Drl09HVG9tmfPHgYOHKhuT506FYCRI0cyd+5cPvvsMwB69uzpdr+tW7cyYMAAtTPEkCFDKC4uJioqiilTpqiPA65uD5s2bWL8+PH07t2bZs2aMWfOHMaOHauOue6663j//fd58sknefzxx2nfvj3r16+nW7du6pgZM2ZgsVgYO3Ysubm5XH/99WzcuBGj0Vjt74sQQgghrkyjKIri6SAaC+m1LYQQ1SAlBZKTXUsiSv3vf3D99a6OEcKj6tu5rr7FK4QQQlRVbZ7rpAaDEEKI+sFigccfh27d4P77IT39wrEbbpDkghBCCCGEh8kSCSGEEHWbori6QUybBr/95tr3l79AmQKBQgghhBDC8yTBIIQQou46dAgmToStW13brVvDkiXw17/KjAUhhBBCiDpGEgxCCCHqpvPn4ZproKgIjEaYNQtmzACTydORCSGEEEKICkiCQQghRN3UtCn8859w7Bi88gpERXk6IiGEEEIIcRlS5FEIIUTdcOAA3Hgj/PjjhX0vvQSffirJBSGEEEKIekASDEIIITwrOxvGj4fevWH7dpg588Ixnc5zcQkhhBBCiCqRBIMQQgjPcDrhjTegQwdYvty1fffd8Oabno5MCCGEEEL8AR5NMGzfvp2hQ4cSERGBRqNh/fr16jGbzcbMmTOJjo7G19eXiIgI7r//fs6cOeP2GK1bt0aj0bjdXnzxRbcxBw8e5IYbbsBoNBIZGcmCBQvKxbJu3To6deqE0WgkOjqaL7/80u24oijMmTOH8PBwTCYTcXFxpKSkVN+bIYQQjcnu3XDttTB2rKuYY9eu8M03sHYtXHWVp6MTQgghhBB/gEcTDBaLhR49erBs2bJyxwoLC9m3bx9PPfUU+/bt45NPPuHIkSP89a9/LTf22WefJT09Xb1NnDhRPWY2mxk0aBCtWrVi7969LFy4kLlz57Jq1Sp1zM6dOxkxYgRjxoxh//79JCQkkJCQQHJysjpmwYIFLF26lJUrV7Jr1y58fX2Jj4/HarVW87sihBCNwA8/uJIMAQGweDHs3w8DB3o6KiGEEEII8SdoFEVRPB0EgEaj4dNPPyUhIeGSY3bv3k3fvn05efIkLVu2BFwzGCZPnszkyZMrvM+KFSt44oknyMjIwGAwADBr1izWr1/P4cOHAbj77ruxWCxs2LBBvd+1115Lz549WblyJYqiEBERwbRp03jssccAyMvLIzQ0lDVr1jB8+PBKvUaz2UxgYCB5eXkEBARU6j5CCNEg2O1w6tSFYo12O8ydCxMmQFiYR0MT1au+nevqW7xCCCFEVdXmua5e1WDIy8tDo9EQFBTktv/FF1+kadOm9OrVi4ULF2K329VjSUlJ9O/fX00uAMTHx3PkyBFycnLUMXFxcW6PGR8fT1JSEgDHjx8nIyPDbUxgYCAxMTHqmIoUFxdjNpvdbkII0ej873+uAo5xcVA660uvh3nzJLkghBBCCNGA1JsEg9VqZebMmYwYMcIt6/Loo4+ydu1atm7dysMPP8wLL7zAjBkz1OMZGRmEhoa6PVbpdkZGxmXHlD1e9n4VjanI/PnzCQwMVG+RkZFVfdlCCFF/pafDffdB//5w8CDk5ECZpWdCCCGEEKJh0Xs6gMqw2WzcddddKIrCihUr3I5NnTpV/bl79+4YDAYefvhh5s+fj7e3d22H6mb27Nlu8ZnNZkkyCCEaPpsNli51LYEoKACNBh56CJ5/Hpo183R0QgghhBCihtT5BENpcuHkyZN88803V1wzEhMTg91u58SJE3Ts2JGwsDAyMzPdxpRuh/0+NfdSY8oeL90XHh7uNqZnz56XjMXb29vjSQ4hhKhVOTnQrx/88otrOyYGXn8d+vTxbFxCCCGEEKLG/eklEmazmfXr1/NL6YfJalSaXEhJSWHz5s00bdr0ivc5cOAAWq2WkJAQAGJjY9m+fTs2m00dk5iYSMeOHWnSpIk6ZsuWLW6Pk5iYSGxsLABRUVGEhYW5jTGbzezatUsdI4QQAmjSBNq2hebN4a23YOdOSS4IIYQQQjQSVZ7BcNddd9G/f38mTJhAUVERffr04cSJEyiKwtq1axk2bFilH6ugoIDU1FR1+/jx4xw4cIDg4GDCw8O588472bdvHxs2bMDhcKj1DoKDgzEYDCQlJbFr1y4GDhyIv78/SUlJTJkyhfvuu09NHtxzzz0888wzjBkzhpkzZ5KcnMyrr77K4sWL1eedNGkSN954I4sWLWLIkCGsXbuWPXv2qK0sNRoNkydPZt68ebRv356oqCieeuopIiIiLtv1QgghGjyrFZYsgQcegN8Tu/zrX2AyuZINQgghhBCi8VCqKDQ0VDlw4ICiKIry3nvvKe3atVMsFouyfPlypWfPnlV6rK1btypAudvIkSOV48ePV3gMULZu3aooiqLs3btXiYmJUQIDAxWj0ah07txZeeGFFxSr1er2PD/++KNy/fXXK97e3kqLFi2UF198sVwsH374odKhQwfFYDAoXbt2Vb744gu3406nU3nqqaeU0NBQxdvbW7npppuUI0eOVOn15uXlKYCSl5dXpfsJIUSdtGGDorRtqyigKGPGeDoaUUfUt3NdfYtXCCGEqKraPNdpFEVRqpKQMJlMHD16lMjISO6//34iIiJ48cUXSUtLo0uXLhQUFFRb8qOhkV7bQogG4dgxmDIFPv/ctR0eDosWwYgRno1L1An17VxX3+IVQgghqqo2z3VVrsEQGRlJUlISFouFjRs3MmjQIABycnIwGo3VHqAQQog6orAQ5syBrl1dyQW9HqZPhyNHJLkghBBCCCGqXoNh8uTJ3Hvvvfj5+dGyZUsGDBgAwPbt24mOjq7u+IQQQtQV8+fDvHmun+Pi4LXXoFMnz8YkhBBCCCHqjConGP75z3/St29fTp06xc0334xW65oE0aZNG+aVfvAUQgjRMDid8PvveaZNg40bYdYsuOMO0Gg8G5sQQgghhKhT/lCbyj59+jBkyBBOnz6N3W4HYMiQIfTr169agxNCCOEh+fkwYwYMHgylpXqCguCHH2DYMEkuNGDbt29n6NChREREoNFoWL9+vdtxRVGYM2cO4eHhmEwm4uLiSElJKfc4Dz74IAEBAQQFBTFmzJhyNZoOHjzIDTfcgNFoJDIykgULFpR7jHXr1tGpUyeMRiPR0dF8+eWXfygWIYQQQtSOKicYCgsLGTNmDD4+PnTt2pW0tDQAJk6cyIsvvljtAQohhKhFigL//a9r6cPChfD117B9+4Xjklho8CwWCz169GDZsmUVHl+wYAFLly5l5cqV7Nq1C19fX+Lj47FarW7jDh8+TGJiIhs2bGD79u2MHTtWPWY2mxk0aBCtWrVi7969LFy4kLlz56rtoQF27tzJiBEjGDNmDPv37ychIYGEhASSk5OrHIsQQgghaklV2048+uijSu/evZX//e9/iq+vr3Ls2DFFURRl/fr1VW5T2dhIKywhRJ128KCi9O/vajsJrhaUn3/u6aiEBwHKp59+qm47nU4lLCxMWbhwobovNzdX8fb2Vv773/8qiqIoP/zwg1tLaUVRlK+++krRaDTK6dOnFUVRlOXLlytNmjRRiouL1TEzZ85UOnbsqG7fddddypAhQ9ziiYmJUR5++OFKx1IRq9Wq5OXlqbdTp07JuVkIIUSDVpvfQ6s8g2H9+vW8/vrrXH/99WjKXMnq2rUrx44dq668hxBCiNpiscCkSdCrl2u2gskEzz0Hyclw222ejk7UIcePHycjI4O4uDh1X2BgIDExMSQlJQHwww8/AHD11VerY+Li4tBqtezatQuApKQk+vfvj8FgUMfEx8dz5MgRcnJy1DFln6d0TOnzVCaWisyfP5/AwED1FhkZ+YfeCyGEEEKUV+UEw9mzZwkJCSm332KxuCUchBBC1BMGA2zeDA6Hq77CL7/Ak0+CtB4WF8nIyAAgNDTUbX9oaKh6LDMzs9z99Ho9wcHB6piMjIwKH6Psc1xqTNnjV4qlIrNnzyYvL0+9nTp16jKvWAghhBBVUeUEQ58+ffjiiy/U7dKkwptvvklsbGz1RSaEEKLm7N8PJSWun728YNUq2LQJPvoIWrXybGxC1CBvb28CAgLcbkIIIYSoHlVuU/nCCy9w66238vPPP2O323n11Vf5+eef2blzJ99++21NxCiEEKK6nD8Pjz8Ob7wBL77o6hQBIF2ARCWEhYUBrlkK4eHh6v7MzEx69uwJlJ9RAGC328nOzlbvHxYWVm6mQ+n2lcaUPX6lWIQQQghRu6o8g+H666/nwIED2O12oqOj2bRpEyEhISQlJdG7d++aiFEIIcSf5XDAypXQoYNrtoKiwK+/ejoqUc9ERUURFhbGli1b1H1ms5ldu3apsxj79u0LwP79+9Ux33zzDU6nk5iYGABiY2PZvn07NptNHZOYmEjHjh1p0qSJOqbs85SOKX2eysQihBBCiNpV5RkMAG3btuWNN96o7liEEELUhKQkGD/etSwCIDoaXn8d+vf3bFyiTiooKCA1NVXdPn78OAcOHCA4OJiWLVsyefJk5s2bR/v27YmKiuKpp54iIiKChIQEADp27AjAo48+yhtvvIHNZmPChAkMHz6ciIgIAO655x6eeeYZxowZw8yZM0lOTubVV19l8eLF6vNOmjSJG2+8kUWLFjFkyBDWrl3Lnj171FaWGo3mirEIIYQQonZVOcGQlpZ22eMtW7b8w8EIIYSoZkuWwJQprp8DA13dIcaNA/0fyi+LRmDPnj0MHDhQ3Z46dSoAI0eOZM2aNcyYMQOLxcLYsWPJzc3l+uuvZ+PGjRgvKgraoUMHbrrpJrRaLcOGDWPp0qXqscDAQDZt2sT48ePp3bs3zZo1Y86cOYwdO1Ydc9111/H+++/z5JNP8vjjj9O+fXvWr19Pt27d1DGVjUUIIYQQtUOjKIpSlTtotdrLdotwOBx/OqiGymw2ExgYSF5enhSVEkLUjiNHoHt3uO8+mD8fKugCJER1qm/nuvoWrxBCCFFVtXmuq/IlrLJrKgFsNhv79+/nlVde4fnnn6+2wIQQQvwB27bBrl0wc6Zru2NHV62FFi08GpYQQgghhGj4qpxg6NGjR7l9ffr0ISIigoULF3LHHXdUS2BCCCGq4LffYPp0WLsWNBq4+Wa4+mrXMUkuCCGEEEKIWlDlLhKX0rFjR3bv3l1dDyeEEKIyiovhpZegUydXckGrddVYaN3a05EJIYQQQohGpsozGMxms9u2oiikp6czd+5c2rdvX22BCSGEuIKvv4ZHH4WjR13bsbGwbBn06uXZuIQQQgghRKNU5QRDUFBQuSKPiqIQGRnJ2rVrqy0wIYQQl2E2w4gRkJMDoaGwYIGrkKO22iamCSGEEEIIUSVVTjBs3brVbVur1dK8eXPatWuHXtqeCSFEzSkuBoPBVWMhIMC1NOKXX+Dpp10tKIUQQgghhPCgKmcEbrzxxpqIQwghxKUoCnz+OUyeDIsXw9/+5tr/0EMeDUsIIYQQQoiyKpVg+Oyzzyr9gH/961//cDBCCCEukpICkybBV1+5tl9++UKCQQghhBBCiDqkUgmGhISESj2YRqPB4XD8mXiEEEIAWCzw/POwaBGUlICXF0ybBk884enIRD2Qm5tLUFCQp8MQQgghRCNTqWpgTqezUjdJLgghRDX46itX28n5813Jhfh4SE52bfv5eTo6Uce89NJLfPDBB+r2XXfdRdOmTWnRogU//vijByMTQgghRGMj5caFEKKu0Wjgt9+gdWtYv96VcOjQwdNRiTpq5cqVREZGApCYmEhiYiJfffUVt956K9OnT/dwdEIIIYRoTP5QgsFisfDll1+ycuVKli5d6nariu3btzN06FAiIiLQaDSsX7/e7biiKMyZM4fw8HBMJhNxcXGkpKS4jcnOzubee+8lICCAoKAgxowZQ0FBgduYgwcPcsMNN2A0GomMjGTBggXlYlm3bh2dOnXCaDQSHR3Nl19+WeVYhBDiDzGbYfv2C9u33ALvvQc//+yqt3BRa2AhysrIyFATDBs2bOCuu+5i0KBBzJgxg927d3s4OiGEEEI0JlVOMOzfv5927doxYsQIJkyYwLx585g8eTKPP/44S5YsqdJjWSwWevTowbJlyyo8vmDBApYuXcrKlSvZtWsXvr6+xMfHY7Va1TH33nsvhw4dIjExkQ0bNrB9+3bGjh2rHjebzQwaNIhWrVqxd+9eFi5cyNy5c1m1apU6ZufOnYwYMYIxY8awf/9+EhISSEhIIDk5uUqxCCFElSgKvPsudOwIQ4dCZuaFY/fcAyaT52IT9UaTJk04deoUABs3biQuLg5wJcZl6aIQQgghapVSRTfeeKPy0EMPKQ6HQ/Hz81OOHTumpKWlKf3791c+/vjjqj6cClA+/fRTddvpdCphYWHKwoUL1X25ubmKt7e38t///ldRFEX5+eefFUDZvXu3Ouarr75SNBqNcvr0aUVRFGX58uVKkyZNlOLiYnXMzJkzlY4dO6rbd911lzJkyBC3eGJiYpSHH3640rFUxGq1Knl5eert1KlTCqDk5eVV5a0RQjRE+/crSr9+iuJKMyhK+/aKsm+fp6MS9dD48eOVVq1aKXFxcUrTpk2V/Px8RVEU5b///a/Sq1evWo8nLy+vXp3r6lu8QgghRFXV5rmuyjMYDhw4wLRp09Bqteh0OoqLi9VlB48//ni1JT6OHz9ORkaGeiUGIDAwkJiYGJKSkgBISkoiKCiIPn36qGPi4uLQarXs2rVLHdO/f38MBoM6Jj4+niNHjpCTk6OOKfs8pWNKn6cysVRk/vz5BAYGqrfSKaxCiEYsOxsmTIDeveG778DHx1W88aefoFcvT0cn6qHFixczYcIEunTpQmJiIn6/FwJNT0/nn//8p4ejE0IIIURjUqk2lWV5eXmh1bryEiEhIaSlpdG5c2cCAwPVKZrVISMjA4DQ0FC3/aGhoeqxjIwMQkJC3I7r9XqCg4PdxkRFRZV7jNJjTZo0ISMj44rPc6VYKjJ79mymTp2qbpvNZkkyCNGYFRRA165Q+nvj7rth4UKQ3wviT/Dy8uKxxx4rt3/KlCkeiEYIIYQQjVmVEwy9evVi9+7dtG/fnhtvvJE5c+Zw7tw53n33Xbp161YTMdZb3t7eeHt7ezoMIURd4efnSiokJsLrr8PAgZ6OSNRTn332WaXH/vWvf63BSIQQQgghLqh0gsHhcKDT6XjhhRfIz88H4Pnnn+f+++9n3LhxtG/fnrfeeqvaAgsLCwMgMzOT8PBwdX9mZiY9e/ZUx2RlZbndz263k52drd4/LCyMzLKF035/jLLPcakxZY9fKRYhhCjn7Fl44gmYOBGio137XnjBNWvBy8uzsYl6LSEhoVLjNBqNFHoU5TidCqdzi7CU2PE16GkRZEKrlW41Qggh/rxK12Bo0aIFs2bNIiAggIG/X3ULCQlh48aNmM1m9u7dS48ePaotsKioKMLCwtiyZYu6z2w2s2vXLmJjYwGIjY0lNzeXvXv3qmO++eYbnE4nMTEx6pjt27djs9nUMYmJiXTs2JEmTZqoY8o+T+mY0uepTCxCCKGy22HZMujQAd54Ax591FXKEVw1FyS5IP4kp9NZqZskF8TFUrPyWbHtGIsTj7J0SwqLE4+yYtsxUrPyPR2aEEKIBqDSCYbx48fz0Ucf0blzZ2644QbWrFlDYWHhn3rygoICDhw4wIEDBwBXMcUDBw6QlpaGRqNh8uTJzJs3j88++4yffvqJ+++/n4iICPXKTefOnbnlllt46KGH+OGHH/juu++YMGECw4cPJyIiAoB77rkHg8HAmDFjOHToEB988AGvvvqqW22ESZMmsXHjRhYtWsThw4eZO3cue/bsYcKECQCVikUIIQDYsQP69HEVcszNhZ49Yd480MjVQSGEZ6Vm5bP6uxMkn8kjyMeLNs38CPLxIvlMHqu/OyFJBiGEEH+aRlFKL6tVzrZt21i9ejUff/wxOp2Ou+66iwcffFCdMVDVxxpYwRrkkSNHsmbNGhRF4emnn2bVqlXk5uZy/fXXs3z5cjp06KCOzc7OZsKECXz++edotVqGDRvG0qVL1SraAAcPHmT8+PHs3r2bZs2aMXHiRGbOnOn2nOvWrePJJ5/kxIkTtG/fngULFjB48GD1eGViuRKz2UxgYCB5eXkEBARU5a0SQtR16ekwYwb85z+u7SZN4PnnYexY0Ok8G5to8CwWC99++y1paWmUlJS4HXv00UdrNZb6dq6rb/H+UU6nwoptx0g+k0f7ED80ZZKeiqKQklVAdItAHrmxrSyXEEKIBqY2z3VVTjCUKigoYO3ataxZs4adO3fSuXNnxowZ4zYzQLhrLB9ihGiUli6FSZNcMxUeesiVXGjWzNNRiUZg//79DB48mMLCQiwWC8HBwZw7dw4fHx9CQkL49ddfq/05W7duzcmTJ8vt/+c//6m2aL7Yww8/zMqVK9XttLQ0xo0bx9atW/Hz82PkyJHMnz8fvf5Ceaht27YxdepUDh06RGRkJE8++SSjRo1ye9xly5axcOFCMjIy6NGjB6+99hp9+/at9GtpLOfmU9mFLE48SpCPF/7G8su08q02cgttTLm5A5HBPh6IUAghRE2pzXNdpZdIXMzPz48HH3yQHTt28Pnnn5ORkcH06dOrMzYhhKjb8vIu/PzPf8L998OuXfCvf0lyQdSaKVOmMHToUHJycjCZTHz//fecPHmS3r178/LLL9fIc+7evZv09HT1lpiYCMDf//53dczIkSPdxixYsEA95nA4GDJkCCUlJezcuZO3336bNWvWMGfOHHXM8ePHGTJkCAMHDuTAgQNMnjyZBx98kK+//lod88EHHzB16lSefvpp9u3bR48ePYiPjy9XAFqApcSO1e7Ax1BxfW+TQUex3YGlxF7LkdU/TqfCqexCDmeYOZVdiNP5h67VCSFEg/SHZzAUFhby4Ycfsnr1anbs2EHbtm154IEHmDVrVnXH2GA0lqskQjR4aWnw2GOwfz8kJ4O0oxUeFBQUxK5du+jYsSNBQUEkJSXRuXNndu3axciRIzl8+HCNxzB58mQ2bNhASkoK+fn5BAYGMm7cOJYvX17h+K+++orbbruNM2fOEBoaCsDKlSuZOXMmZ8+exWAwMHPmTL744guSk5PV+w0fPpzc3Fw2btwIQExMDNdccw2vv/464Cp+GRkZycSJEyv9eaSxnJtlBkP1SM3K5+vkTI6dLcBqd2DU62jb3I/4bqG0C/H3dHhCCFGhOj2DYefOnTz44IOEh4czfvx4WrduzdatWzl69KgkF4QQDVtxsavNZOfOsG4d/PorfPutp6MSjZyXlxdaret0HhISQlpaGgCBgYGcOnWqxp+/pKSE//znPzzwwANu6/o//PBDmjVrRrdu3Zg9e7ZbYeikpCSio6PV5AJAfHw8ZrOZQ4cOqWPi4uLcnis+Pp6kpCT1effu3es2RqvVEhcXp46pSHFxMWaz2e3WGLQIMtG2uR/peVYuvrakKArpeVbahfjRIsjkoQjrPimSKYQQV1bxPLkKLFiwgNWrV3P06FH69OnDwoULGTFiBP7+kq0VQjQCX37pqrGQmuravuEGeO01qMb2vEL8Eb169WL37t20b9+eG2+8kTlz5nDu3DneffddunXrVuPPv379enJzc8vVRli1ahXt27fn4MGDzJw5kyNHjvDJJ58AkJGR4ZZcANTtjIyMy44xm80UFRWRk5ODw+GocMzlZm3Mnz+fZ5555g+91vpMq9UQ3y2UM3lFpGQVEB5oxGTQUVTiID3PSrCvgUFdQ6XA4yU4nQpfJ2eSbSlxK5Lpb/TCz1tPSlYBmw5l0qaZn7yHQohGrdIJhoULF3Lfffexbt26WvnAIoQQdUJhIQwfDp9/7toOD4eXX4YRI6T1pKgTXnjhBfLzXVdOn3/+ee6//37GjRtH+/bteeutt2r8+f/9739z6623qu2hS8XFxREQEEB0dDTh4eHcdNNNHDt2jLZt29Z4TJcze/Zst4LUZrOZyMhID0ZUe9qF+DO6X2t1in+m2Yq3Xkd0i0AGdZUp/pdzOreIY2ddiRnNRb/7NRoN4YFGUrMKOJ1bJEtMhBCNWqUTDGfOnMHLq/yaPSGEaNBMJrDbQa+HyZPhqaegAa/TFvVPnz591J9DQkLU+gS14eTJk2zevFmdmXAppa2sU1NTadu2LWFhYfzwww9uYzIzMwEICwtT/1+6r+yYgIAATCYTOp0OnU5X4ZjSx6iIt7c33o24bkq7EH/aDPDjdG4RlhI7vgY9LYJMctX9Ci4Uyax4CYnJoCPTbJUimUKIRq/SNRgkuSCEaBQUBT79FM6dc21rNLBsGRw8CAsXSnJBiDJWr15NSEgIQ4YMuey4AwcOABAeHg5AbGwsP/30k1u3h8TERAICAujSpYs6ZsuWLW6Pk5iYSGxsLAAGg4HevXu7jXE6nWzZskUdIyqm1WqIDPahU1gAkcE+klyoBF+DHqNeR+ElEghFJQ689Tp8L9GlQwghGgv5LSiEEKWOHIFHH4VNm2DsWFe7SYCoKM/GJcRlREVFlZuyXdavv/5aI8/rdDpZvXo1I0eORK+/8HGi9Pn2799Pq1atOHjwIFOmTKF///50794dgEGDBtGlSxf+8Y9/sGDBAjIyMnjyyScZP368OrvgkUce4fXXX2fGjBk88MADfPPNN3z44Yd88cUX6nNNnTqVkSNH0qdPH/r27cuSJUuwWCyMHj26Rl6zaLxKi2Qmn8nDz1vv9m+utEhmdItAKZIphGj0JMEghBD5+TBvHixeDDYbGAwQFuaazSB1FkQdN3nyZLdtm83G/v372bhxI9OnT6+x5928eTNpaWk88MADbvsNBgMAt99+O4WFhURGRjJs2DCefPJJdYxOp2PDhg2MGzeO2NhYfH19GTlyJM8++6w6Jioqii+++IIpU6bw6quvctVVV/Hmm28SHx+vjrn77rs5e/Ysc+bMISMjg549e7Jx48ZyhR+F+LMaSpFMp1OR5TFCiBqlUS7uVSRqTGPptS1EvaEosHYtPPYYnDnj2jdkCCxZAu3aeTQ0If6sZcuWsWfPHlavXl2rz1vfznX1LV7hWalZ+WqRzGK7a1lEuxC/elEks2zsVrsDo15H2+Z+xHer+7ELIf6c2jzXVSrBUJUe0XJyvjT5ECNEHfPKKzBtmuvnNm3g1Vfhtts8G5MQ1eTXX3+lZ8+eVTqHV4f6dq6rb/EKz6uPswBSs/JZ/d0Jsi0lhAca8THoKSyxq7MvRvdrLUkGIRqw2jzXVWqJRFBQ0GXXd5blcDj+VEBCCFFrRo1yzVYYO9Y1i8Fo9HREQlSbjz76iODgYE+HIUSDU1oks75wOhW+Ts4k21JC+xA/9TO9v9ELP289KVkFbDqUSZtmfnU+USKEqPsqlWDYunWr+vOJEyeYNWsWo0aNUqs0JyUl8fbbbzN//vyaiVIIIf4spxPeeQc2b4Z333XVVggOhpQUaMQt60T916tXr3IF5zIyMjh79izLly/3YGRCiLrgdG4Rx8666kZcfMFQo9EQHmgkNauA07lF9SpxIoSomyqVYLjxxhvVn5999lleeeUVRowYoe7761//SnR0NKtWrWLkyJHVH6UQQvwZe/fChAnw/feu7eHDLyyFkOSCqOcSEhLctrVaLc2bN2fAgAF06tTJM0EJIeoMS4kdq92Bj6HiDhcmg45MsxXLJVpwCiFEVVS5i0RSUhIrV64st79Pnz48+OCD1RKUEEJUi/Pn4YknYNUqV0FHPz94+mkYNMjTkQlRbZ5++mlPhyCEqMN8DXqMeh2FJXb8jV7ljheVuIpV+hqkuZwQ4s/TVvUOkZGRvPHGG+X2v/nmm0RGRlZLUEII8ac4HLByJXToAP/6lyu5cM89cOSIq9bC7230hKivzGZzpW9CiMatRZCJts39SM+zcnFtd0VRSM+z0i7EjxZBFc9wEEKIqqhyqnLx4sUMGzaMr776ipiYGAB++OEHUlJS+Pjjj6s9QCGEqDKHw1W8MTsboqPh9dehf39PRyVEtZHiy0KIytJqNcR3C+VMXhEpWa5aDCaDjqISh9pFYlDXUCnwKISoFlVOMAwePJijR4+yYsUKDh8+DMDQoUN55JFHZAaDEMJzMjOhSRPX7ASDAZYtg0OH4J//BL1M+xQNixRfFkJURbsQf0b3a83XyZkcO1tAptmKt15HdItABnUNlRaVQohqo1Eunislaoz02haiBtjtrmTCnDmu27Rpno5IiFp100038eCDD7oVXwZ4//33WbVqFdu2bavVeOrbua6+xSvEn+F0KpzOLcJSYsfXoKdFkElmLgjRCNTmua7KNRgA/ve//3Hfffdx3XXXcfr0aQDeffddduzYUa3BCSHEZW3bBr16weTJYDbDF1+46i0I0YgkJSXRp0+fcvv79OnDDz/84IGIhBB1lVarITLYh05hAUQG+0hyQQhR7aqcYPj444+Jj4/HZDKxb98+iouLAcjLy+OFF16o9gCFEKKc336DESNg4EBIToamTV2dIhIToZLr0oVoKKT4shCispxOhVPZhRzOMHMquxCnU5LyQojqVeWFyfPmzWPlypXcf//9rF27Vt3fr18/5s2bV63BCSFEOevWwejRYLG4kgmPPALz5kFwsKcjE8IjpPiyEKIyUrPy1RoMVrsDo15H2+Z+xHeTGgxCiOpT5RkMR44coX8F1dgDAwPJzc2tjpiEEOLSunaF4mKIjYU9e2D5ckkuiEattPjy0KFDyc7OJjs7m6FDh3L06FEGDx7s6fCEEHVAalY+q787QfKZPIJ8vGjTzI8gHy+Sz+Sx+rsTpGblezpEIUQDUeUZDGFhYaSmptK6dWu3/Tt27KBNmzbVFZcQQricOAHffAMPPODa7tIFkpLg6qtB+4fKyAjR4ERGRsoyRSFEhZxOha+TM8m2lNA+xE9tcetv9MLPW09KVgGbDmXSppmf1GQQQvxpVf50/tBDDzFp0iR27dqFRqPhzJkzvPfeezz22GOMGzeu2gNs3bo1Go2m3G38+PEADBgwoNyxRx55xO0x0tLSGDJkCD4+PoSEhDB9+nTsdrvbmG3btnH11Vfj7e1Nu3btWLNmTblYli1bRuvWrTEajcTExEjxLCFqUlERPPssdO4MDz0EP/544VifPpJcEI3awYMHcTqd6s+XuwkhGrfTuUUcO1tAeKBRTS6U0mg0hAcaSc0q4HRukYciFEI0JFWewTBr1iycTic33XQThYWF9O/fH29vbx577DEmTpxY7QHu3r0bh8OhbicnJ3PzzTfz97//Xd330EMP8eyzz6rbPj4+6s8Oh4MhQ4YQFhbGzp07SU9P5/7778fLy0u92nP8+HGGDBnCI488wnvvvceWLVt48MEHCQ8PJz4+HoAPPviAqVOnsnLlSmJiYliyZAnx8fEcOXKEkJCQan/dQjRaigKff+7qDHH8uGvfwIFgNHo0LCHqkp49e5KRkUFISAg9e/ZEo9FQUddpjUbjdg4VQjQ+lhI7VrsDH4OpwuMmg45MsxVLib3C40IIURUapaJPJJVQUlJCamoqBQUFdOnSBT8/v+qOrUKTJ09mw4YNpKSkoNFoGDBgAD179mTJkiUVjv/qq6+47bbbOHPmDKGhoQCsXLmSmTNncvbsWQwGAzNnzuSLL74gOTlZvd/w4cPJzc1l48aNAMTExHDNNdfw+uuvA+B0OomMjGTixInMmjWrUrFLr20hriAlBSZNgq++cm23aAGLFsFdd0l3CCHKOHnyJC1btkSj0XDy5MnLjm3VqlUtReVS38519S1eIarqVHYhixOPEuTjhb/Rq9zxfKuN3EIbU27uQGSwTwWPIISo72rzXFflOcYPPPAA+fn5GAwGunTpQt++ffHz88NisfBA6RrpGlJSUsJ//vMfHnjgAbcpXu+99x7NmjWjW7duzJ49m8LCQvVYUlIS0dHRanIBID4+HrPZzKFDh9QxcXFxbs8VHx9PUlKS+rx79+51G6PVaomLi1PHVKS4uBiz2ex2E0JcQnEx3HCDK7ng5QWzZsHhw3D33ZJcEOIirVq1Us+DrVq1uuxNCNG4tQgy0ba5H+l5VpxOJ+YiG+cKijEX2XA6naTnWWkX4keLoIpnOAghRFVUOcHw9ttvU1RUfo1WUVER77zzTrUEdSnr168nNzeXUaNGqfvuuece/vOf/7B161Zmz57Nu+++y3333acez8jIcEsuAOp2RkbGZceYzWaKioo4d+4cDoejwjGlj1GR+fPnExgYqN6kH7kQFyk7gcrbG558EuLjITkZ5s+HWpoZJUR99vbbb/PFF1+o2zNmzCAoKIjrrrvuirMbhBBVZ7c7+eH4eb5KTueH4+ex252eDumytFoN8d1C0Wk1fH0ok+0pZ/n+13NsTznL14cy0Wk1DOoaKgUehRDVotI1GMxmM4qioCgK+fn5GMush3Y4HHz55Zc1Xovg3//+N7feeisRERHqvrFjx6o/R0dHEx4ezk033cSxY8do27ZtjcZzJbNnz2bq1KnqttlsliSDEKV+/hkmToQpU+C221z7/vlPGD9eZiwIUQUvvPACK1asAFwz8l5//XWWLFnChg0bmDJlCp988omHIxSi4djySyZrvjvBifMWbA4nXjotrZv6Mqpfa27qHHrlB/A0DaCU/nDhf0IIUV0qnWAICgpSuzR06NCh3HGNRsMzzzxTrcGVdfLkSTZv3nzFD0oxMTEApKam0rZtW8LCwsp1e8jMzARcLTdL/1+6r+yYgIAATCYTOp0OnU5X4ZjSx6iIt7c33t7elXuBQjQWZjM88wwsXQp2O2RmwpAhrqSCdIYQospOnTpFu3btANdMvzvvvJOxY8fSr18/BgwY4NnghGhAtvySyfyvDpNvtdHU14DJoKOoxMHRrHzmf3UYoE4mGUrbVDqcCoM6h5BhLqbQ5sDHS0dYgDfHzhVKm0ohRLWp9Kf5rVu3smXLFhRF4aOPPuKbb75Rbzt27CAtLY0nnniixgJdvXo1ISEhDBky5LLjDhw4AEB4eDgAsbGx/PTTT2RlZaljEhMTCQgIoEuXLuqYLVu2uD1OYmIisbGxABgMBnr37u02xul0smXLFnWMEOIKFAXefRc6doRXXnElFxISXB0jZMaCEH+Yn58f58+fB2DTpk3cfPPNABiNxgqXNFaHuXPnlmsR3alTJ7cx06ZNo2nTpvj5+TFs2LBySXppIS3qE7vdyZrvTpBvtdGyiQl/oxd6rRZ/oxctm5jIt9p4e+eJOrlcorRNpclLy760PJLPmDmamU/yGTP70vIweWmlTaUQotpUegbDjTfeCLhaOpZWrq4tTqeT1atXM3LkSPT6CyEfO3aM999/n8GDB9O0aVMOHjzIlClT6N+/P927dwdg0KBBdOnShX/84x8sWLCAjIwMnnzyScaPH6/OLnjkkUd4/fXXmTFjBg888ADffPMNH374odua1qlTpzJy5Ej69OlD3759WbJkCRaLhdGjR9fa+yBEvfXTTzBuHHz3nWu7fXvXDIZbbvFsXEI0ADfffDMPPvggvXr14ujRowwePBiAQ4cO0bp16xp73q5du7J582Z1u+z5GWDjxo2sW7eOwMBAJkyYwB133MF3v/8OkBbSor7ZdyqHE+ctNPU1oNFoKLY5cCgKOo0Gg15LU18Dx89Z2Hcqh75RTT0drhtLiZ1zBcWctxRTbHPiZ9TjpdNjczjJyreSZy2hqa+3tKkUQlSLKs9H/uabb/joo4/K7V+3bh1vv/12tQR1sc2bN5OWllauS4XBYGDz5s0MGjSITp06MW3aNIYNG8bnn3+ujtHpdGzYsAGdTkdsbCz33Xcf999/P88++6w6Jioqii+++ILExER69OjBokWLePPNN9UPMAB33303L7/8MnPmzKFnz54cOHCAjRs3liv8KISoQFqaK7ng4+Mq3vjTT5JcEKKaLFu2jNjYWM6ePcvHH39M06auLzd79+5lxIgRNfa8er2esLAw9dasWTMA8vLyAHj++ef5y1/+Qu/evVm9ejU7d+7k+++/B1wzLX7++Wf+85//0LNnT2699Vaee+45li1bRklJCeBqKR0VFcWiRYvo3LkzEyZM4M4772Tx4sVqDK+88goPPfQQo0ePpkuXLqxcuRIfHx/eeuutGnvdonE6bynB5nCCBs7kFnEqp4jfclz/P5NbBBqwOZyct5R4OtRyfLx0nCsoxmK1E+xrwFuvQ6vR4K3XEexroMBq53xBMT5eOk+HKoRoACo9g6HU/Pnz+de//lVuf0hICGPHjmXkyJHVElhZgwYNQilbbf53kZGRfPvtt1e8f6tWrfjyyy8vO2bAgAHs37//smMmTJjAhAkTrvh8QjR6TqerxeTvy5AYMgQWLIARI+CqqzwbmxANTFBQEK+//nq5/TVZFwkgJSWFiIgIjEYjsbGxzJ8/n5YtW6pLFcvWf+jUqRMtW7YkKSmJa6+99pItpMeNG8ehQ4fo1avXJVtIT548GbjQQnr27Nnq8cq2kC4uLla3pYW0qIymvgYA0nOtAHjrtWg1GpwKWEocWEoceP8+k6GucX2C1qBcsqKj61j5T9pCCFF1VZ7BkJaWRlRUVLn9rVq1Ii0trVqCEkLUY7t3w7XXwnXXQZnaJ0yfLskFIWrI//73P+677z6uu+46Tp8+DcC7777Ljh07auT5YmJiWLNmDRs3bmTFihUcP36cG264gfz8fLXmUVBQkNt9yrZ2lhbSor7p2SIIb72OwhI7Rr0GndZVe0Sn1WDUa1z7vXT0bBHk6VDLKbI5aOZnwM+oJ9tSQrHdgVNRKLY7yLaU4GfU08zPQJHN4elQhRANQJUTDCEhIRw8eLDc/h9//FGdlimEaITOnoWHHoKYGFeSQVHgxx89HZUQDd7HH39MfHw8JpOJffv2qVfn8/Ly1HoG1e3WW2/l73//O927dyc+Pp4vv/yS3NxcPvzwwxp5vuo0e/Zs8vLy1NupU6c8HZKoBzILiokIMmLU6zBbHRTbnb9/SXditjow6nWEBxrJLCi+5GM4nQqnsgs5nGHmVHYhTmftzBnwNehp5udNx1A/mvl5Yy6yk2G2Yi6y09z/wn5fQ5UnNgshRDlVTjCMGDGCRx99lK1bt+JwOHA4HHzzzTdMmjSJ4cOH10SMQoi6zG6HZcugQwd4801XYmHkSDhyBH6vZi+EqDnz5s1j5cqVvPHGG3h5ean7+/Xrx759+2olhqCgIDp06EBqaqpaXDE3N9dtTNnWzpdqD1167HJjSltIN2vW7A+3kA4ICHC7CXEllhI7TXwN3NC+GU19DZTYnZiL7JTYnTT1M3B9+2YE+xouWSgxNSufFduOsTjxKEu3pLA48Sgrth0jNSu/xmNvEWSibXM/zuaXwO8LJTQKaABFUTibX0K7ED9aBJlqPBYhRMNX5QTDc889R0xMDDfddBMmkwmTycSgQYP4y1/+UmNXSoQQdVRJiWs5xIQJkJsLPXvCjh2wZg1c5gO+EKL6HDlyhP79+5fbHxgYWO5Lfk0pKCjg2LFjhIeH07NnTwC3GklHjhwhLS1Nbe0sLaRFfeNr0GPU6wgJMPK3ni0Y1DWUAR2bM6hrKH/r0YLQACPeel2FswBSs/JZ/d0Jks/kEeTjRZtmfgT5eJF8Jo/V352o8SSDVquhU7g/6WYrx88X4u2lpXmAN95eWo6fLyTdbKVjmD9arbSMFkL8eVVOMBgMBj744AMOHz7Me++9xyeffMKxY8d46623MBjqXmEbIUQNMhggNhaaNIHly2HPHujXz9NRCdGohIWFkZqaWm7/jh07aNOmTY0852OPPca3337LiRMn2LlzJ7fffjs6nY4RI0YQGBgIwBNPPMHWrVvZu3cvo0ePJjY2lmuvvRZwbyH9448/8vXXX1fYQvrXX39lxowZHD58mOXLl/Phhx8yZcoUNY6pU6fyxhtv8Pbbb/PLL78wbtw4aSEtakTpLID0PCsaDbQI8qFdiD8tgnzQaCA9z1rhLACnU+Hr5EyyLSW0D/HD3+iFTqvB3+hF+xA/si0lbDqUWaPLJZxOhcPp+YQHGmnT1BenAuYiG04F2jTzJTzQyJGM/FpbsiGEaNj+8GKrDh060KFDh+qMRQhR19ls8NprEB8PXbu69s2bB08/Db+3qBNC1K6HHnqISZMm8dZbb6HRaDhz5gxJSUlMmzaNOXPm1Mhz/vbbb4wYMYLz58/TvHlzrr/+er7//nuaN2+udmWIj49n2LBhFBcXEx8fz/Lly9X7l7aQHjduHLGxsfj6+jJy5MgKW0hPmTKFV199lauuuqrCFtJnz55lzpw5ZGRk0LNnT2khLWqEVqshvlsoZ/KKSMkqIDzQiMmgo6jEQXqelWBfA4O6hpabBXA6t4hjZ13jNRr3YxqNhvBAI6lZBZzOLSIy2KdGYi+NoX2IH37eevKtdkocTgw6Lf5GPQXF9hqPQQjReGiUivo/XmTq1Kk899xz+Pr6MnXq1MuOfeWVV6otuIbGbDYTGBhIXl6erPkU9c+WLTBxIvzyC/zlL7B5M2hkOqUQnqYoCi+88ALz58+nsLAQcNUZmD59OrNnz8Zkqt111fXtXFff4hWelZqVz9fJmRw7W0Cx3YG3Xke7ED8GdQ2lXYh/ufGHM8ws3ZJCm2Z+6CpYgmB3OjlxzsLEm9rTKaxm/v7VhRiEEJ5Vm+e6Ss1g2L9/PzabTf35Ui7OzAohGoBTp2DaNFi3zrXdvDnce69nYxJCqDQaDU888QTTp08nNTWVgoICunTpwr/+9S+ioqIu27JRCFE17UL8aTPAj9O5RVhK7Pga9LQIMl2yfkFp7YbCEjv+Rq9yx4tKHJes3VBd6kIMQojGo1K/SbZu3Vrhz0KIBqy4GBYtguefh8JC0Gph/Hh45hlXzQUhhEcVFxczd+5cEhMT1RkLCQkJrF69Wq2JULZegRCiemi1mkovJSit3ZB8Jg8/b73bxThFUUjPsxLdIrBGOzjUhRiEEI2HpCqFEBVbswaeeML18w03wOuvQ/fuHg1JCHHBnDlz+Ne//kVcXBw7d+7k73//O6NHj+b7779n0aJF/P3vf0en03k6TCEatT9au6GhxSCEaDwqlWC44447Kv2An3zyyR8ORgjhYQ4HlH4heeAB+OgjGDUK7rlH6i0IUcesW7eOd955h7/+9a8kJyfTvXt37HY7P/74oyxZFKIOaRfiz+h+rdXaDZlmK956HdEtAi9Zu6GmYtiYnMFPp/MoLHHgY9DRvUUQ8d1qJwYhRONQqQRDacspcE2l+vTTTwkMDKRPnz4A7N27l9zc3ColIoQQdUhhIbz0Evzf/8EPP7jaT3p5QWKipyMTQlzCb7/9Ru/evQHo1q0b3t7eTJkyRZILQtRBVa3dUGMU101x/YdK1HoXQogqqVSCYfXq1erPM2fO5K677mLlypXq1EuHw8E///lPqb4sRH2jKLB+PUyZAidPuvZ99JFrxoIQok5zOBwYDAZ1W6/X4+fn58GIRH3hdCqe/6LbCFWldkN1S83KZ/V3JzhfUEyASU8TXwMOp5PkM3mkm62M7tdaZjEIIapFlWswvPXWW+zYscNtXadOp2Pq1Klcd911LFy4sFoDFELUkCNH4NFHYdMm13ZkJCxeDDITSYh6QVEURo0ahbe3NwBWq5VHHnkEX19ft3GydFGUVbbNotXuwKjX0ba5n0yTb8CcToWvkzNJO1/oakl5vhC7w4lep6WJjxeWYgebDmXSppmfJJqEEH9alRMMdrudw4cP07FjR7f9hw8fxul0VltgQogaYre7ijcuXgw2m2s5xIwZMHs2+HjmyooQoupGjhzptn3fffd5KBJRX5Rexc62lBAeaMTHYKKwxE7ymTzO5BXJVewG6nRuEftP5ZCVb8XhVPAzeuFl1GNzKJzNL0an1bAvLYfTuUUem2EhhGg4qpxgGD16NGPGjOHYsWP07dsXgF27dvHiiy8yevToag9QCFHNdDo4cMCVXBgyBJYsgXbtPB2VEKKKyi5fFOJKSq9iZ1tKaB/ip9bq8Dd64eetJyWrQK5i1zBPLU3JL7aRll2Iw6HQ1M+g/tl76zUYfA2cLyjhVHYh+cW2Go9FCNHwVTnB8PLLLxMWFsaiRYtIT08HIDw8nOnTpzNt2rRqD1AIUQ2SkyE8HJo2dXWDeO01OHoUbrvN05EJIYSoBadzizh21tWi8OJCoBqNhvBAI6lZBXIVu4Z4cmlKgdVOUYkDf6PrY3+xzYFDUdBpNBj0Wry9tORb7RRY7TUahxCicup7nZwqJxi0Wi0zZsxgxowZmM1mACnuKERdlZsLc+fC66/DQw/BihWu/R06uG5CCCEaBUuJHavdgY/BhKIo5FvtlDicGHRa/I16TAYdmWYrlhL5klndPL00xc9bj8lLR77VhrnIRpHNiVNR0Go0mLy0aDTgY9Dj513lrwVCiGrWEOrk/KHfJHa7nW3btnHs2DHu+b3a/JkzZwgICJAK1kLUBU4nvPMOzJwJWVmufefPu/ZrtZ6NTQghRK3zNegx6nWcyS0kI6+Y7MIS7E4neq2WYB8DYYHeeOt1+BrkS2Z1qgtLU/yNXjT1M/DzGSt2p4LJoMOo12JzKOQU2tBrNVzVxAd/o1eNPL8QonI8nYysLlU+i5w8eZJbbrmFtLQ0iouLufnmm/H39+ell16iuLiYlStX1kScQojK2rcPJkyApCTXdqdOsHQp3HyzZ+MSQgjhMS2CTAT5eJH4cyYGnQZ/kxdeOj02h5NMcxGncgq5uUsoLYJMng61QakLS1PCA4zotVr0Oi1+3hqsdgWrzYlWoyHIpMdqV/DSaQkPMNbI8wshrqwuJCOrS5UvZU6aNIk+ffqQk5ODyXThJHT77bezZcuWag1OCFFF778Pffq4kgt+frBwIfz4oyQXhBBCgPL7/y/6olu6Xbc/stZPF5amVHxNz2TQUWx31OjSlHSzFW8vLc38DBgNekL9vYkIMhLq743RoKeZvzcGvZZ0s7XGYhBCXF5VkpF1XZVnMPzvf/9j586dGAwGt/2tW7fm9OnT1RaYEOIPGDQImjSBW26BBQugRQtPRySEEKIOOJ1bRG6RjWtaNyE9z0qWuRib04mXVktIgDfhgUZyCm1S5LGalS5NKSyxV7gEoajEUeNLUywldgx6Lb1bBXP8nIWcwhLsdtfymNAAI62a+mAuskn9DSE8qGydnIrUpzo5Vf5t5nQ6cTgc5fb/9ttv+PvX/TUhQjQo338P69bByy+7rkA1awaHD0Pz5p6OTAghRB1S+uE1yOQFimsyQ+kNBYxeOvLkS2a1axFkom1zP5LP5OHnrXe7MqkoCul5VqJbBNbo0pTSJIfRS8s1rZuUK/BZUGyn2OaU+htCeFBdSEZWlyovkRg0aBBLlixRtzUaDQUFBTz99NMMHjy4OmMTQlxKZiaMHg2xsfDKK/B//3fhmCQXhBBCXMTXoKfE7mRfWg5nC4oJMOkJCzASYNJztqCYvSdzKLbLl8zqptVqiO8WSrCvgZSsAvKtNuxOJ/lWGylZBQT7GhjUNbRG11SXJjnS81xLIAJMXjTz8ybA5PoSk55npV2In9TfEMKDyv47VRTF7VhpMrK+/Dut8lnk5Zdf5pZbbqFLly5YrVbuueceUlJSaNasGf/9739rIkYhRCm7HZYvhzlzIC/Pte+BB+C66zwblxBCiDotPMBIsc1JTqGNlk1MaH/vKOSt1+HloyEtp4hQu1MK/VVCVXvUtwvxZ3S/1mrruUyzFW+9jugWgQzqWvOt50qTHGfyikjJcq3xNhl0FJU4SM+z1kqSQwhxeQ3p32mVZzBERkby448/8sQTTzBlyhR69erFiy++yP79+wkJCanW4ObOnYtGo3G7derUST1utVoZP348TZs2xc/Pj2HDhpGZmen2GGlpaQwZMgQfHx9CQkKYPn06drv79L9t27Zx9dVX4+3tTbt27VizZk25WJYtW0br1q0xGo3ExMTwww8/VOtrFeKKvv0WevWCSZNcyYXevV1LJP79b6jmf3tCCCEaltJCf0EmL3IKbRTbHTgVhWK7g5xCG0E+Bin0VwmpWfks35bKvC9+5vkvfmbeFz+zfFsqqVn5l71fuxB/xg1oy5SbOzDxpvZMubkDj9zYttZazpUmObpFBJJbaOPEOQu5hTaiWwTWm9Z3l+N0KpzKLuRwhplT2YU4ncqV7yREHdNQ/p1WaQaDzWajU6dObNiwgXvvvZd77723puJSde3alc2bN6vbev2FkKdMmcIXX3zBunXrCAwMZMKECdxxxx189913ADgcDoYMGUJYWBg7d+4kPT2d+++/Hy8vL1544QUAjh8/zpAhQ3jkkUd477332LJlCw8++CDh4eHEx8cD8MEHHzB16lRWrlxJTEwMS5YsIT4+niNHjlR7UkWICjkcMHYsHD0KwcEwfz6MGQM6nacjE0IIUQ9UVOivoNiOXqslRAr9VUpqVj5LNqdwNCMfh1JawULD8bMWDmfkMzmu/WW/AGi1Go8W0GwX4k+bAX5Vmn1RH6Rm5auzQ6x2B0a9jrbN/YjvVvOzQ4Sobg3h36lGuXiRxxW0aNGCzZs307lz55qKSTV37lzWr1/PgQMHyh3Ly8ujefPmvP/++9x5550AHD58mM6dO5OUlMS1117LV199xW233caZM2cIDQ0FYOXKlcycOZOzZ89iMBiYOXMmX3zxBcnJyepjDx8+nNzcXDZu3AhATEwM11xzDa+//jrgKnQZGRnJxIkTmTVrVqVfj9lsJjAwkLy8PAICAv7o2yIai5IS0GqhNKm2cSN89hk89xw0berZ2IQQ4hLq27muvsX7R53KLmRx4lGCfLzwNehIz7NSaHPg46UjPNCIpcRBbqGNKTd3kC4SFXA6FeZ98TOJP2di0GnwN3nhpdNiczjJL7JR4lC4uUsoTw7pUq++CNR3qVn5rP7uBNmWEsIDjfgY9BSW2NUp5fXpqq8QNak2z3VVXiIxfvx4XnrppXLLDGpKSkoKERERtGnThnvvvZe0tDQA9u7di81mIy4uTh3bqVMnWrZsSVJSEgBJSUlER0eryQWA+Ph4zGYzhw4dUseUfYzSMaWPUVJSwt69e93GaLVa4uLi1DGXUlxcjNlsdrsJUSmbNkH37vB7UgtwtZ5cvlySC0IIj5s/fz7XXHMN/v7+hISEkJCQwJEjR9zGDBkypNwyx0ceecRtjCxjrD2lBcRSMgvYczKH5DNmjmbkk3zGzJ6TOaRkFtSbAmKe8FtOId//eh6dBpr6eeOt16HVaPDW62jq541WA7t+Pc9vOYWeDrXRcDoVvk7OJNtSQvsQP/yNXui0GvyNXrQP8SPbUsKmQ5myXEKIWlblBMPu3bv55JNPaNmyJfHx8dxxxx1ut+oUExPDmjVr2LhxIytWrOD48ePccMMN5Ofnk5GRgcFgICgoyO0+oaGhZGRkAJCRkeGWXCg9XnrscmPMZjNFRUWcO3cOh8NR4ZjSx7iU+fPnExgYqN4iIyOr/B6IRubkSRg2DOLj4cgRWLHCtTxCCCHqkG+//Zbx48fz/fffk5iYiM1mY9CgQVgsFrdxDz30EOnp6eptwYIF6rHSZYwlJSXs3LmTt99+mzVr1jBnzhx1TOkyxoEDB3LgwAEmT57Mgw8+yNdff62OKV3G+PTTT7Nv3z569OhBfHw8WVlZNf9G1CNarYZO4f6km638es6CVgOBPl5oNfDrOQvpZisdw/zl6vsl/HrOQl6hjQAfL7dWk+DqqBbo40VukY1fz1ku8Qiiup3OLeLYWVcxvIr+TMIDjaRmFXA6t8hDEQrROFW5i0RQUBDDhg2riVjKufXWW9Wfu3fvTkxMDK1ateLDDz/EZKr7GfbZs2czdepUddtsNkuSQVTMaoWFC+GFF1w/63QwcSLMnSt1FoQQdU7pEsJSa9asISQkhL1799KzZ091v4+PD2FhYRU+xqZNm/j555/ZvHkzoaGh9OzZk+eee46ZM2cyd+5cDAYDK1euJCoqikWLFgHQuXNnduzYweLFi9U6Sa+88goPPfQQo0ePBlxLIb/44gveeuutKi1jbOicToXD6fmEBxpp7msgp8iGuciGTqulTTNf9DotRzLyGdgxRJIMl6BoQMOl3ht5z2qbpcSO1e7Ax1DxdwKTQUem2Sp1RYSoZVVOMKxevbom4qiUoKAgOnToQGpqKjfffDMlJSXk5ua6zWLIzMxUP8yEhYWVmyZZ2mWi7JiLO09kZmYSEBCAyWRCp9Oh0+kqHHOpD02lvL298fb2/kOvVTQiO3bAyJHw66+u7QED4LXXoFs3j4YlhBCVlfd729zg4GC3/e+99x7/+c9/CAsLY+jQoTz11FP4+LjW919qGeO4ceM4dOgQvXr1uuQyxsmTJwMXljHOnj1bPX6lZYzFxcUUFxer241l+WLp1d72IX74eevJt9opcTgx6LT4G/UUFNvVq71Sg6G8qGa+BJkM5BbaCA3Qul0xVxSFvEIbgSYDUc18PRhl4+Jr0GPU6ygsseNv9Cp3vKjEgbdeh6+hyl93hBB/QqWXSDidTl566SX69evHNddcw6xZsygqqt0pRwUFBRw7dozw8HB69+6Nl5cXW7ZsUY8fOXKEtLQ0YmNjAYiNjeWnn35ymyaZmJhIQEAAXbp0UceUfYzSMaWPYTAY6N27t9sYp9PJli1b1DFC/ClBQa6lES1awNq18M03klwQQtQbTqeTyZMn069fP7qV+d1155138p///IetW7cye/Zs3n33Xe677z71uKeWMTbW5YsXrvbq0Wg0BJi8aObnTYDJNeXfZNBRbHfI1d5LiGziw7VRwTgVhfOWErc2n+ctJTgVhdg2wUQ2keRMbSmtK5KeZ8XpdGIusnGuoBhzkQ2n00l6nlXqigjhAZVO6T3//PPMnTuXuLg4TCYTr776KllZWbz11ls1Ftxjjz3G0KFDadWqFWfOnOHpp59Gp9MxYsQIAgMDGTNmDFOnTiU4OJiAgAAmTpxIbGws1157LQCDBg2iS5cu/OMf/2DBggVkZGTw5JNPMn78eHVmwSOPPMLrr7/OjBkzeOCBB/jmm2/48MMP+eKLL9Q4pk6dysiRI+nTpw99+/ZlyZIlWCwWdTqmEFViscC2bTBkiGu7WzdYv941c8HPz4OBCSFE1Y0fP57k5GR27Njhtn/06NFqpero6GjCw8O56aabOHbsGG3btvVEqEDjXb4oV3v/HK1Wwz3XtiSroJijmfnkWy8kYnRaDT0igxgR01KWl9QirVZDfLdQfskw8/XPmTjKFHPUaTV0CPVnUNdQ+TMRopZV+izyzjvvsHz5ch5++GEANm/ezJAhQ3jzzTfRaqtcK7JSfvvtN0aMGMH58+dp3rw5119/Pd9//z3NmzcHYPHixWi1WoYNG0ZxcTHx8fEsX75cvb9Op2PDhg2MGzeO2NhYfH19GTlyJM8++6w6Jioqii+++IIpU6bw6quvctVVV/Hmm2+qazsB7r77bs6ePcucOXPIyMigZ8+ebNy4sdwVEyEuS1Hg449h6lQ4cwb274foaNex227zbGxCCPEHTJgwgQ0bNrB9+3auuuqqy46NiYkBIDU1lbZt23psGWNdWr7odCq11uu89Gpv8pk8/Lz15ab4p+dZiW4RKFd7L6NdiD+T49rz1U/p7D6RQ0GxHT9vPX1bB3NLdJi0Q/Sk33MLGhQUNOq2EKL2VTrBkJaWxuDBg9XtuLg4NBoNZ86cueKHij9q7dq1lz1uNBpZtmwZy5Ytu+SYVq1a8eWXX172cQYMGMD+/fsvO2bChAlMmDDhsmOEuKSff4ZHH4XSpTatW0NOjkdDEkKIP0pRFCZOnMinn37Ktm3biIqKuuJ9Dhw4AEB4eDjgWqL4/PPPk5WVRUhICFDxMsaLz+GXWsaYkJAAXFjGWNfP2alZ+XydnMmxswVY7Q6Meh1tm/sR3y2UdiH+1Z58KL3aeyaviJQsV+V9k0FHUYmD9Dwrwb4GudpbSRo0mLx0OFEweUkhZk8pbVPpcCrEdw2loNih1hXx89aRetbCpkOZtGnmJ3+vhahFlU4w2O12jEaj2z4vLy9sNlu1ByVEg2E2w7PPwquvgt0O3t4waxbMnAn1oBOKEEJUZPz48bz//vv83//9H/7+/mq9g8DAQHXMggULuP3222natCkHDx5kypQp9O/fn+7duwONexljalY+q787QbalhPBAIz4GE4UldpLP5HEmr4i/dArhcHr+JZMPf1S7EH9G92utJjYyzVa89TqiWwQyqOufe+zGoOyfW4smJnwMegpL7BxKN5NutjK6X+s6/x7a7U72ncrhvKWEpr4Gro5sgl5fMzORa1rZNpVarZYAk/vrKNumUgqXClF7Kp1gUBSFUaNGuU0rtFqtPPLII/j6XqiY+8knn1RvhELUVw4HxMTA4cOu7b/9DV55Bdq08WxcQgjxJ61YsQJwzQAsa/Xq1dxxxx0AbNu2jRUrVmCxWIiMjGTYsGE8+eST6tjGuoyx9KprtqWE9iF+6lIFf6MXft569qflsnRLCuGBJiKCyicfLvUltrIzHtqF+NNmgF+tLc1oKK7055aSVVDnr5Zv+SWTNd+d4MR5CzaHEy+dltZNfRnVrzU3da6b/14uR9pUClE3VTrBMHLkyHL7ylaDFkJcRKeDRx6BZctcMxhuvdXTEQkhRLVQlEsvcC5t+/jll1+qRR4vpTEuYyx71bVsHYRShSV2zuYX0ysySC3GeKUvsVdabnExrVYjV3Sr6HJ/bhqNps5fLd/ySybzvzpMvtVGU1+DujzmaFY+879yXQipb0kGKVwqRN1U6X9xq1evrsk4hKj/cnJgzhwYPPhCMmH8eFeSoY4UFBNCCOFZl7vqmm+1k19sx6DXYHO6J3Eu9SX2Ssst6sO0/fqgPl8tt9udrPnuBPlWGy2bmNTi7P5GLb4GHWk5Rby98wQ3tm9er5ZLSOFSIeqm+vNbRIi6yumEf/8bOnSA1193FXO0//4BQ6+X5IIQQghV2auuFytxOCmxO/HW6/DSajAX2ThXUIy5yIaiKJgMOortDvVL7MXT9v2NXui0GvyNXrQP8SPbUsKmQ5k4L0pWOJ0Kp7ILOZxh5lR2YbnjorzL/blB3b5avu9UDifOW2jqayjX+U2r1dLU18Dxcxb2napfxadLC5cG+xpIySog32rD7nSSb7WRklUghUuF8JC691tQiPpk927XLIXdu13bXbrAa6+5EgtCCCHERS531dVLq6HE7sTHW8eRzHxyCm3YHU70Oi1NfAyEB3q7fYn9I9P2q7qcojErW9fCx0tHm2a+HEo317ur5ectJdgcTkyGijtemAw6si0lnLeU1HJkf54ULhWi7pFvQUL8EWfPwuOPu2YuKAr4+8Mzz8CECeBVfh2gEEIIAZdvF5lhtuJv1JNtsVFsc+Jv9MLLqMfmUMjKt/JbTiGDuoSqX2KrOm1fllNUXmpWPl/9lM7uEzkUFNvw8/aiTTMfdFpNvWvz2dTXgJdOS1GJA39j+cnLRSUOvHSumQz1kRQuFaJukQSDEH9EUhK8+abr5/vvh5degrAwz8YkhBCiXrjcVVeTQceeEzmu5DUKoHH9//fCmmUXM1SlyF1D6IJQW1Kz8nluw88knzZTbHegKAoajYZDZ8xENfOle4tAcgtt9eZq+dWRTWjd1JejWfn4GnTYHAoORUGn0eCl03DeUkLHUH+ujmzi6VD/MClcKkTdIQkGISrr3Dlo1sz189ChMHUq3HEH9Ovn2biEEELUOxVddVUUhSWbU7imdRPSc61k5hdjdzrRa7WEBhgJDzSSW2hTlzxUpchdZZZTpGTms+dkNgEmr0Z7FdjpVFi+NdWV5ME1C8RL6yq6WVTi4Jd0M5FNTEy+uQNFNke9eJ/0ei2j+rXmmc9/5peMfHQaDRqNK2flUBSa+noz8rrW9arAoxCi7pIEgxBXkp4OM2fCF1/A4cPQvDloNLBokacjE0IIUY9dfNX1cIYZq91BkMkAGtfcBZTf/w94e+kwF9nUJQ+XW25x8bT9ssspFEUh32qnxOHEoNPib9RjtTk4lG7mX9/+ireXttHWZkjLtvC/lHMoikKgyUtNHHhrNXhpNeQW2fju2DkmxbWnU9jl27DWJa2a+hDVzAeL1UaR3YGiuD7KmPQ6WjfzoVVTufovhKgekmAQ4lJsNlfBxrlzIT/fdSbeuBH+8Q9PRyaEEKIB8jXoKbE72XsyG4dTwd/khZdOg82hcDa/mGxLCZHBPm6dCipb5K50OcWZ3EIy8orJLixRZ0cY9Vpyi2yU2J0E+3oRGtB4azO4ai7Y8THoys1K0Go1+Bh05Fvt7D6RQ+tmflV67LJFI2tz5kPp8hinE9o29+G3HCvFDifeOi1XNTHidFLvl8d46r0VQpQnCQYhKrJlC0ycCL/84tru29fVgvKaazwblxBCiHrtcl+EwgOMFNuc5BbZaNnEhM2hYLU50Wk0NPHxIi2niFC7k/AAo9tjVqbIXYsgE0E+XiT+nIlBp/k9eaHHZndyMtuC1eakY6g/4YEmNBpNo63NYLW5ru7rNBW/Vq1G8/vykyIOZ5gr/WXWk907TucWsf9UDqdyCskrsuFwKiiAzeEg5WwhgSYvvNO0bt1G6hPpjCJE3SIJBiHKcjrh3nth7VrXdrNmrgKOo0aBVtYmCiGE+OOu9EUo3WzF20uLyUvHsXOW0rqOgGsSXYDRC4NeS7rZWu6LYKWK3JU+XpkvzyV2J3aHgl6rubAWQx1WcavLhqx9qB8GvZYimwO9Tlv2rUJRXJ07FEXD7uM5HM7Ir9SXWU9378gvtpGSVcC5/GKcioKiKOoSCY3G1Rq1dFx94+n3VghRniQYhChLq4UmTVz/Hz/e1XqySf2tqiyEEKJuqMwXIbtTocTudH3ZV1yzHRQUNGjQaV23ErtTrcFQ1pWmiJ/OLSK3yOYqIJlXTE5hCQXFdhwOBS+dlmb+BqwlDs7kFeGt16m1GS5udVkRq9XOB/vSOJ1jpUUTI3df3RKjsX5+xOzTMpj2IX78nG6msMSOt5cOnUaDQ1EoLLar7UPbNvfFz+h1xS+zdaF7h7nIxvmCYkocTjS4ZmFoNK4OJQ6ngh2FcwXFmIvqV4KhLry3Qojy6udvfyGq08aNEBUFHTu6tufNg4cfhh49PBuXEEKIBqGyX4QGdwvjXEExhTYHJoOOwhIHDqdrdoKreKOd8wXF+Hjp3B6/MlPES4s8tmnmR0SgiWPnCigotqPVaEjPLUKDhqyCYvaeyEGn06DXagn2MRAW6K22uqzIok1HeGfnSQqKbTgV0GrglU2p3H9dK6YN6lizb2wN0Ou1/HNgO575/GeyLcUoJQ40GtefodXuxKDXckP7pgT6GIArf5mtTPeOmp4hYim2U2J34nC4prA41aksCqVzM0twYim+dBKpLir73oIrkVK2cGljm30jRF0hCQbReB0/DlOmwP/9H8TFwaZNrvmCwcGumxBCCFENKvqS6XQ6OZNnJdtSgt2hsD8th14tAym2O8kvsqHTatDrtOi1GhRcXxLtTgWTQU+ZlROVniJeWuTxSIaZw+lmcgpda/FLV/85nAo6rQZTgBFfbz02h5NMcxGncgq5uUsoLYJM5V7Xok1HWPntMexOBYNWg04LDieYi22s/PYYQL1MMtzUORSA1TuOc+xsATaHE61Oi9Ggo/tVgbRp7j5L4XKJgrLdOypSmRkif1aOxZX8cZbG+/tN4cI+p+IaV5+UvrdWm45f0nPIKSzB7nCi12lp4mOgdTMfiu2OGn1vhagJdruTfadyOG8poamvgasjm9SrNrKSYBCNT1GRq67Ciy9CcTHo9dCzJ9jt4OXl6eiEEEI0MBe3iDx0Jo99J3PIt9px/r4WXqfVkFdYQlGJA6fi+oBZZHO4vgVqXNPatRrXlPbSK81VmSLeIsiEgsKO1HPYHU40Gg0aDTgcYHO4iv75eWtRFCgssaM4ofRraEWTy61WO+/sPIndqeCj16D9PVOh04Le6aTQrvBu0knG929bL5dL3NQ5lBvbN1c/5BdY7Wz5JfOS6/kvlSgoTewUltjxN5b/jFFU4rjsDJHqEGTywvl7QQ8trr9SpUkqLa4kg6IoBJnq12egi7uu+Bm98DLqf++6YiXbUlyu64oQdd2WXzJZ890JTpy3YHM48dJpad3Ul1H9WqvJz7pO/sWJxkNRXLMVpkyBEydc+266ydWKsnNnj4YmhBCi4SrbInL/qVxOnitUrxwDaBRQnAoHfstFUUCv0+B0ur74aQAUUDSu5QdWm4OC3xMMVZl+Hx5g5EhGPiUOJ9rfazpoNa6ZC6WKSxycPG/BoSjoNBqa+hroGO5PTqGt3JX5D/alUVBsw6C9kFwopdVqMWid5FttfLAvjZHXtanmd7R26PVa+kY1BeBUdiFJx85XOVHQIshE2+Z+JJ/Jw89b7/bn5OpGYSW6RWCFM0SqS6Hdrs5aAFcSqJTTeWF/ob1+Xem/uOtK6d9Db70Gr8t0XRGirtrySybzvzpMvtVGU1/D70vjHBzNymf+V4cB6kWSof7MtRDiz/rwQ7j9dldyITISPvoIEhMluSCEEKJGhQcY0Wnh26PnOHnePbkAv09VV36fTeCEIpuCzaFg//0GCjoU7E7Xto/BVYPhwswIPYqiYC6yqcX6FEXBZNCpU8T3pGVzOqcIo16Ht16DorhmLjiVC1PmbQoU2ZzY7a5ik2cLijmaWcC5guJyV+ZP51hxKu5fVsvSaV2v6XSOtZrfTc8oTRSk51lRyrb34EKioF2IX7lEgVarIb5bKMG+BlKyCsi32rA7XcmXlKwCgn0NDOoaWqNFCHVaLd5613IbVz0J11IWp9M1e0av1eCt16KrZ92ySruuNPHxIttSgtlqo6DYjtlqI9tSQpDpQtcVIeo6u93Jmu9OkG91Jcz8jV7otVr8jV60bGIi32rj7Z0nsNsvPoPUPTKDoR6z253sScvmaGa+Ol3Sx6Cnia+BNs19CTQa3KpIX6nCdE2oynOWjs3//QThZ9Tj9/ta0yKbo9IxO50Kp3IKOX7OAkCbZr5c1cQH7e23uwo33nYbzJ4Nvr7qfer7Wqfq4om/I0II0ZClZuWz8acM9p7MIbuwhIu+m7pxlPm57EdIu7O0RgKAQmGJa2TZmRGlnSHKrkEPL1Ogcc+JbIrtTkwGHXaHE6fi/D0Wxe25dBrw0mlxomCzK5zJtaIoYLqosGSLJsbfZ0BUnGRwOF0zLlo0aRhXj0sTBWfyikjJcs0aKb26mJ5nvWyioF2IP6P7tVYLcWaarXjrdUS3CGRQ10u3t6wuzf28CTB5kW+1U2x3lGt/atC7iiI29/Ou0Tiqm6XEjkGvpW1zP376LY+zBUVqLZEgkxedwv3UcULUdftO5XDivIWmvoYKZ4U19TVw/JyFfady1JlVdZUkGOqpLb9ksnxrKkcy87EUO9wKPuk0rvWXncP9ub5dc+K7uabSXKnCdHWrTFXri8fuP5VD2vlCimwOV0suDXh76WnmZ6CZn3elek2//30a3/96nt4/bGLo7o1MeOQl+nQI456YlrTbs8dVc6GMhrDWqTpU5c9LCCHElaVm5fPm9l/Zn5bN6dzCyyYXLkXBtcJPA2gVV0GG0hkMLYJMBJm8SPwl8/cviRfWoGflW/ktp5BBvxdoNOp1KCgUWF0F/9Q+AhfF5FDA+Xs7Q50WbE6FbEsJjouumt19dUte2ZSKudiG3ul0+0DsdDopcSoEGr24++qWVX/RdcTFSfc2zfwY3a81G3/K4KfTeRTa7Ph46el+VSDx3cIue65sF+JPmwF+HkniXx3ZhBZBJpLP5KEFtLoyz6ko2J1OWjQxcXVk/WrLXVqD4VR2IV56LVcFmdBoQXFCscNJalaB1GAQ9cZ5Swk2hysJXBGTQUe2pYTzlpJajqzq5F9cPbTll0ye+fxnMs1WbA4nF39e+X/27js8iqrtA/BvZvtms5veICSBhB5AgvTeQhHFFxUR6QIiiNjFBthAEEURwQq83wuCgKIC0kFAEKSE3hITSkgjvW2d8/2x7JBNNsmG1A3PfV25YGeemTlTds/MmVMsDMjVm3AuMQdGs4CLyTnW6QIrs4fpquRsr9ZFY69nFCAtVw+LIEAu5ZCaawBjgFYpgOMAH428zDTHpuZiye6ryPnnFD787Us88G8MAKDPod/ws/kRpOYaMKt/hN1y9aWtU2VV5HwRQggpnyAwfLjlHP68klGiScS9YLDWZDALgliDAcDdBvTM1nXfnfEB7pQc2O4R2gd7gOc4GO70uSAu5mA7tkIHC7O2pTVaLDh5IwuN/e/mA0qlFGO7hmDFn3EoMDPIeUEcRcIoMMh4DmO6hLhkB4/A3ZonZxOzkW8yw00mRWQDHVoEaWHXoQFX8hiWhue5Whkukec5hHipcSk5F4xjUMgkkHDW82swWcBxHEK91C5XY7G0PhgAwE0QqA8G4lK83eSQSXgUGi1wkwN5BgvMggApz0OjsD6fyCTWmgx1nWv+6t/HzGYBKw/FIz3PADABQim5GmOA3mxBao4e2YVG8ByP6Fb+4o9veeM2V0ZFerUGrDUr0vOMMJsFmC0M3hoFbmXpIeE4cHc6odIbzUjOMSCqkQdi0/JLpFkQGPYeuYq+X8/HI4d+hkQQYJApsHnwWBzvOxxyA3Al2fqGvnFv63LF2zrdPTY83OQSXM8sxOrDCegV4Vuvm0tU5Hy52s0HIYTUlmdW/4N9VzKqdJ0MQIFRQHq+AYC1k8esAhMeDPVEcrYBGQVG5BvMkPA8/HUqBGgVyLrTQSMv4SAp2sFgBbZpEYACU8lq5rYhKP97+BryDCYYLdZmETqlDGO6hLjkEJXA3RcWl5NzYDBbm5JwHHApOQfsBIcQbxUCtSp4quUQBIZziTlIytbX2cL4xKxCgOPQpYkXLifnIbvQBOOdpgQ+7go09deAgSvRkWddV7QPhswCEzRKKWQSHiaLgDy92a4PBlfaL3J/ah/siVBvN5xJzAYTBOiL/PYopTw4nkfbhjqXqGlEBQwu5uSNTMSl5YHnUGrhgogxpOcb4aGWQSXnkGewQKu6+6Bc1rjNlVGRXq0BIC4tD1qlFAnp+dAordXdCk0WKO609yw0CXBXWTvwyTNYSqaZMWQu/xZPvjkb2hzrzdzfD/TG/z32PG57BwIA3HkLcvVmnEnMEperT22dKqMi54syaEIIKV1BgQnfHI7D3gupOHMrt1q2YbQI+PNyGqJbBoqdPFqHoVQjKacQhUYLVHIJArUqCGBIuJ2PfKMZt7IKS3RO6Iw73TSUOoThywObYVr3xvjmcBxuZujR0EuJKV2bQK12rSEPbQSBYe3f13E8IRMGsxlmC2CtEQIYBesNv9FsRlqOAWbGIOV5eKpkyDea62xhvO06aR6gQ4sALZKy9SgwWaCWSRCoU0IAxOvEldj6YGjfyBMJtwvsCtj8tEqEequRXWhyuf0i9yeplEe7Rh74Oz4dZoFBznOQSqwFvLlGC6S8gLbBHi7x0pMKGFxMer4RRou1sqUz9wkWxmBhAAcmLldUaeM2V0bR8b4dKb5NvdkCrVIGsyBAJpFCb7JAYAwSzjpas4kxa7VOiwVGiwAPtaxEmpXr1sAtJwPXfYOx+skXca5VZ7ttyiTWdRUYLeJy9amtU2VU9HwRQkhds2zZMixatAjJyclo27Ytli5dio4dO9ZoGt765Sw2Hr8Jg4O8tqrtu5SKxKxC+04es/RIzCqE0SJALuHRwEOFQA+l2Mljep4R+aZ7SxsDoJQ5zitjU3Pxx5kknEzIRq7RhNQcA75HPAa3CayTb/PLcyOzAH9eTUNOoREWxsR7LcYAs8DAANzOM8JLrYCnSgaTxTrahoTncPJ6Zp0sjLddJwVGMzQKKdyVMihkEsglPDiOQ6HB7HCIzbrOtl9KmQQdQj2RqzeL17+7Uoo8gxl6k+By+0XuT2azgJjrWXCTS2GxWGCwMJgs1hoMGrkEEp7H6RtZMJuFOl/IUKdTN3/+fDz44INwd3eHn58fhg8fjsuXL9vF9O7dGxzH2f09++yzdjHXr1/H0KFDoVar4efnh1dffRXmYmP97t+/H+3bt4dCoUB4eDhWrVpVIj3Lli1DaGgolEolOnXqhGPHjlX5PpfH200O+Z3umjknCsglnLWjRAZOXK6o0sZtroyiGZkjRbdpixUE61sAk0WAhOPAc9zdwhGOg3DnLYH8TtskT30eNIV51hVyHHIWfoZNTzyPyS9/jxPNSt5UmizW0cTV8rv7WrStU2npdJW2TpVRkfNFCCF1zfr16/HSSy9hzpw5OHnyJNq2bYvo6GikpqbWWBre+uUsfjx2vUYKFwAgJdeI2zl6ayePahkOXL2NUzcycSu7ELfzDLiVXYhTNzJx4OpteKhlaOChglx2Dz1M3sEBiL9dUGJ6bGou3t9yAauOJOD49QxcSsrF8esZWHUkAe9vuYDY1OqpxVGd/r2dh6SsQhiLDBNqsjCxcAGwvlE033n5oZBK4OUmh9li7WwwV2+q1fQ7Yhti82pqHo7Fp+PAlTQcuJqGA1fScCw+HVdT8xwOsVnX3evQoYTURbaa1UEeSrQI0qGJrwYhPmo08dWgRaAWQR5KsWZ1XVennxj+/PNPTJ8+HQ8++CDMZjPefPNNDBw4EBcuXIBbkSEGJ0+ejPfee0/8rFbfLTm2WCwYOnQoAgICcPjwYSQlJWHs2LGQyWT46KOPAADx8fEYOnQonn32WaxZswZ79uzBM888g8DAQERHRwO4ewOzYsUKdOrUCUuWLEF0dDQuX74MPz+/Gjoi1vY5TXw1OHUjC+XWwOM4eLvJoZDx4DkOGoX92wfbj29kA12V/vjafvDP3cqGRiG1q3bvaJtNfDU4m5gNT5UMaXkGeLnJoZJJkGcwgeM4uMklMJos8Nep4C4F/DeuxX82LYfy6VHAsmUAAP9ODyBpijvYmVvI1Zsgd5OL22WMIbfQBAnPo00DD3G7trZOV1Jz4SaXlOgBOz3fiGb+7i7R1qkyKnq+CCGkLvn0008xefJkTJgwAQCwYsUKbN26FT/88APeeOMN51eUnw9IHLyll0gApdI+roiCAhO2Ho6FwiJA4DgYZHeH+lMZ9aVurnis0qQHV1q/ShyglyntYn87fAVtvVsj+dZt6LNywQsMsiKxFoHBVGBCcnI6kJ+P3w9edZieQvnd9SpMhjsjVZSkMdsvKxQU4rttZ3H2cipMFgukuNvFpBHAMaOA5ftisejxduCNBsDiuDAfAKBW331rYjAA5jJqzFUkVqUCbHm70QiYynj4vxOblmOAYDBAbraI+wPY91lhkMpQYDBBIeWhsJih4gRoBTPyCs0oyMwGdEVur5XKu9eVyWRNR2kUirsjXVUk1my2HotS8HI5mge6Y/3xG8jKKYDUZBDbdmff5uGtkaNFO1/whQWAXA7I7jRvsVgAfenXMGQya3xFYwUBKCysdCwPIDrCAxeTc7DjfAosggClsRCAtb+RcH93RIc2sO4XYD1eijvfOcaAgpKFZqJyvvf3HMvz1mvtXmILCkqvvsxx1u/GvcQWFlqPc2mKPHNVKFavL/t7X5HYOvQb4VRs0e+9k7Hp+UYIRiM8FAKkRjOUPO5UBRAAoxlSJiDbaLlbs7qivxFlXWtVrE4XMGzfvt3u86pVq+Dn54cTJ06gZ8+e4nS1Wo2AgACH69i5cycuXLiA3bt3w9/fH+3atcP777+P119/HXPnzoVcLseKFSsQFhaGxYsXAwBatGiBQ4cO4bPPPhMLGKrsBqaSpFIeE7qH4fqdUSR4CA57p7Z2CCKBn1aJwDsPhrFp+RUat/leVXSsaFtsvtEMCc8hPc8AhYxDtp6BCQwCk0Apl6JTymUMn/8xQuIvWjd0+LD1h0OhAM9zGBQZgEspuTh9IwspOQbo1DIADNkF1iG52ga5I7r13e1KpTzGdwvF/D8u4Xpmod0oEun5RmiVMozrGlrnqyFVVmXG9iaEkNpkNBpx4sQJzJ49W5zG8zz69++PI0eOOFzGYDDAUORhLCfHOtISgoIcb2TIEGDr1ruf/fzsHkzUAGLu/P/v4NZ48qkF4rxDKybCuzDH4WpPB0TgkXGfiZ93f/ccGuY4rnVxxbsRBj7zlfj5t9Uvoemn1wEAXxWLvan1Q/dpP4DB2p/A9LmTwU+5gu8crDddpUXUzLXi59Ub5qDzjXMO02BZobLbb/0jw7Fg904scBgNNH59C/ZdTsO1jHyETZsAbNxYSiSAvLy7DxtTpwKrV5cem5oK+Ppa///SS8BXxY9AEfHxQGio9f9vvQV88knpsefOAa1aAQx49vBPmPXXj6WGPjz2U8QpmyPfKGDcXxswa2eRo/tuseB9+4Deva3//+YbYMaM0tOwZQswdKj1/2vWAHfuOR366Sfg8cet///lF+CJJ0oNFb7/AX/5dERWgREdLv+DHzbOKxn0zp1/v/wSmD7d+v+DB4E+fUpPw8KFwKuvWv9/8iRQVrOkOXOAuXOt/794EWjduvTYV14BFi2y/v/6dSAsrNRQnwnPAP2nARygy8/Gz3MfLX2948YBthrKBQWARlN67GOPARs23P1cVmw5vxF2evUC9u+/+zk0FLh923Fshw7AP//c/dyyJXDtmuPYli2B8+fvfn7wQeDCBcexISFAQsLdzz17AsePO4718QHS0u5+HjwY+PNPx7Fqtf1D7IgRwLZtjmMB+wKQMWNc5zcCAD76CJjn4Htkc+yY9RwAwOefA6+9Vnrsnd8Ibzc5RpzYhpd+XVpq6GvjP4S3Wwfrhyr8jahqLvXklJ2dDQDw8vKym75mzRr4+PigdevWmD17NgqKfKmPHDmCyMhI+PvfHWowOjoaOTk5OH/ni3jkyBH079/fbp3R0dHizYntBqZoTHk3MID1JiYnJ8furyr0a+GPOcNaonWQFmqFpMRJlHDWEQBaN9CiXwt/zOofgVn9I9A6SIesAhMSbucjq8CEyAa6auvxONzPHRO6hTq1TVts5zBvBHupIZHwMJoZvN0U8HdXIMSSj9d/WogX3hmPkPiLsGh1wBdfWH90FQq79czqH4EBLfzhppAiPc+A9DwjNAopBrT0LzFEpe1Yzh7cHE393JGrNyMxsxC5ejOa+bvjjcHN74shKoGKnS9CCKkrbt++DYvFYpfHA4C/vz+Sk5MdLjN//nzodDrxLzg4uCaSWiusI0Dce9OIooq/tMwuLLspgHAn5nhC1Y6kUdS9dFpZ7jpLq0ZSIvBOz+4VKHsXqiG9zsgoMGLbuSTk6s1Ojx7iKm6kF8IiMES39EeXxvW3Q25S/7UP9oS3m6LMGH+t0iVqVnOsOn6dq4EgCHj44YeRlZWFQ4cOidO/+eYbhISEICgoCGfOnMHrr7+Ojh074ueffwYATJkyBdeuXcOOHTvEZQoKCuDm5oZt27Zh8ODBaNq0KSZMmGD3BmTbtm0YOnQoCgoKkJmZiQYNGuDw4cPo0qWLGPPaa6/hzz//xNGjRx2mee7cuZjnoHQrOzsbWq220sfEbBZw/HoGrqTkIt9grf6jlkvh6SZHY1836JRyNPBQ2Q3lmJhlrSngJpfazasuFdmmLTZXb0KewQyNUgrvvw/Cd/zT4HOshUts/HhwH39sLR0uY5s3MgsQf9taitrYxw0NPcse39lsFnDyRibS843wdpOjfbBnva+54EhtXCOEkPolJycHOp2uyvK6sty6davC+bOjGgzBwcHIvnXLcXrLqf785d7LWLYvHhyszR70NdREQsUDk3o2wbJ9cQDuvDHiisQy60O+wmTA870bi3HFOdtEoltjD3w3o5/4edm2M/hy99VS98+23pf6h2Nm95Aqr/4cm5qLXSev41pKDvRmC5RSCcJ83NC/pR+a2ArF76H680//XMfbP52EpIz0GqQyqJQyKKQSyCxmaHgL9GaGFoFarBgdZX//cKf6c2xqLnbF3MS1pKzS01tNTST2XM3A5PVnIDBACQsUlrvHlzEGk2B9OfXFkw+gb7tgl2kicTOjAJ//GQ93nRvclTKAMUj1d2PzDCZkF5gxo284GnqpqYlEabHURML6/1puIgEAe8/cxKdbzyFXb4JWKYVEwsNiEZCjN0OrlOHFhyLRN7KBdbkK/kbkpKVBFxRUI3lznW4iUdT06dNx7tw5u8IFwFqAYBMZGYnAwED069cPcXFxaNKkSU0n087s2bPx0ksviZ9tNzFVRSrl0bmxDzo39nEqnue5Gu/ZuCLbdBjbvZN1UO327YFly8B17ux44WLrCfF2Q4i3W7mxNlIpX6+HonRWbVwjhBByr3x8fCCRSJCSkmI3PSUlpdSmkwqFAgqFg7dEbm72N7ylKRYzsV8klv6d4rCDx6IP7+UpWoDgTGzrYHfkSRXiNkqUBXMAGGCQKeziylK0wKO4G0b7DfBKlVPrlPG8/cNXeRQKu9qJjsSm5mLlXwnIyDci0EsLH7kUBUYzYjL1uB6Thgnd3ErWvJPL7z60lsHTTQajRAZIyh5m010ugZtKDg5yCIxBI+EBNzWSLBIE6+zz0XtKr0x290G/PFLp3QcJB04kX4PArIVQgkSKQol9rNnCIAA4nq5H36LblEic+05UNJbnqyQ2L9eCfE4Cf1sn1BwHs+rusZcqBOQa85EnU5RcB8c5nwagbsSqK3B/VpHYooUYVRlbke99Ff9G3FOsk78R1Rnbt01DJOab8d2Bf3E11wALs0DCcfDXuuGJHo3vFi4AFf+NqMi1Vkku8Yp2xowZ2LJlC/bt24eGDRuWGdupUycAQGxsLAAgICDA4Y2HbV5ZMVqtFiqV6p5uYADrTYxWq7X7I+W4dcu+/ZOvL/DXX9a2TE4ULhBCCLl/yOVyREVFYc+ePeI0QRCwZ88euxoN1UmtluGxDg3L73i5iq14ugMCdHdvnAWGuz0Rsjuf7ygad6/4Ym0BLKyMt433EOcsQWDYcS4FGflGRPhp4K6UQcJzcFfKEOGnQUa+ETvPp0C4x6YheQbnhmROzzfhVmYhkrP1MJkFhPtpoJDyJYZ0ru70OoPD3XPnaLQFR3GugEbBIvVNbGoujsZnQCoBtCop3JVSaFVSSHngaHyGy4zMU6cLGBhjmDFjBn755Rfs3bsXYWV08mITExMDAAgMDAQAdOnSBWfPnrUbrmrXrl3QarVo2bKlGFP05sQWY7s5qQs3MPWe0Wjt0KdZM2uHQVu23J3XsqXjnr0JIYTc91566SV8++23WL16NS5evIhp06YhPz9f7JS5Jnz4aCRGdWwEhYPhoKtDQ3cePjo1mgdooZbx4mOhAGvBgq0uBQdALePRPKDyLzh0avtCimsZZVSHv4c4ZyVmFSIuzdohMVes0IPjOATqlIhNzUNiVhlV8MtwI8O55RgDLGAwMwE5ehPO38qBwSyUeJgtml7GgMSsAsSm5iIxqwCModLpdUazQHfrkOUcYBashR62P7NgnS7hrHGuhIapJPWJIDCs/fs6jidkIKPADJOFgTHAZGHIKDDjeEIGfjx6vVoLI6tKnS7Smz59OtauXYtff/0V7u7uYodNOp0OKpUKcXFxWLt2LYYMGQJvb2+cOXMGL774Inr27Ik2bdoAAAYOHIiWLVtizJgxWLhwIZKTk/H2229j+vTpYhXJZ599Fl9++SVee+01TJw4EXv37sVPP/2ErUV6hH3ppZcwbtw4dOjQAR07dsSSJUtq/Aam3tq1C3j+eeDyZevnLl2AcmqqEEIIIQAwcuRIpKWl4d1330VycjLatWuH7du3l+j4sbp9+Ggk3opujm8Ox+F6eiEYY/glJqlatnXorcEAgA6NvNAiUIsziVkQBPtaCzxnrV3eMkiLDo284M4BuZW4L+3f0v54KmTOFaY4G+esfKMZerMFarnjh0aVXIKUHH2JmgTOYk52g2gGALM1Vm+yoMBYAB+NHIFa+6retvSm5lhw+mY2MvONsDAGCcfB002ONg11Ylx1GdQiEAu0l5GUbS3sMRfZRQ4AGOCvU2JQi8BqS0N1oFGwSH1yI7MAf15JQ57BApmEg0LKg+esv+sGs4A8gwX7L6dhbNeCCjUDrw11ugbD8uXLkZ2djd69eyMwMFD8W79+PQBrzYLdu3dj4MCBaN68OV5++WWMGDECv//+u7gOiUSCLVu2QCKRoEuXLnj66acxduxYvPfee2JMWFgYtm7dil27dqFt27ZYvHgxvvvuO3GISsB6A/PJJ5/g3XffRbt27RATE1MrNzD1yrVr1iFsBg60Fi74+VmHDzp0CGjXrrZTRwghxEXMmDED165dg8FgwNGjR8XmkjVNrZZhVv/m+HTkA/jsyfb496MhWDOpPSrfQOHO+qVAwoKh4meplMdzfcIRqFNDLuWgkvHin1zKIUinxrTe4ZBKeWx9ufs9b1ch4fD0gyF20x4M9Sq3Qj13J64qVXe1+JB77IfIJAAJt/ORmG1fE8FNLkVmvhH7r6ThVlYhCk0WGEwCCk0W3MoqxJ9X0pCRb6zWavxyuQQjohpCwnMlik8YAAnPYURUQ8jlrldblEbBIvVFXFoeUnP11r49ZTwkPAeO4yDhrb/tPA+k5eoRl5ZX20ktV52uwVDeABfBwcH4s7SxWIsICQnBtrLGYQXQu3dvnDp1qsyYGTNmYEZZ4xcT5zEGDBsGnD1rbf7w/PPW8ZF1utpOGSGEEFIleJ5Dt4hAXC5SKOCs67ez8eQ3x5BZaIanSop1UzqikU/JPNI2nPLKQ/GIS8uD0SJALuER7qfB+G5h4vxGPjq4KyTINVSsTwSeA6b0agKl0v6WcXDLQHyguYi0vNJ7Mfd1l2Nwy6p9K26rFn/uVjY0CqldMwlbtfjIBrp7rhZfmRaZt/NNuJKaY/d20V+jwLX0fOQVP+53bnHzDBZcT8+Hv6aqiqFKEgSGfIMZGoUUWQ6GF9UopMg3mCEIzCXf9of7uSO0pxuNBkZcWnqeEWaBQS3lHTb/kvEcCswC0sv4za0r6nQBA6mHGLP23MtxwPz51g4dly4FWreu7ZQRQgghdUYjHx0OvznAqdh+LfzRK8K33Aess/MGIXLOdoeFDDIeUMskyDFYwGCtfaBVSjC2axheHtisRLxcLsHMfhGY/8clFBotdm/GOVibKjzfN6LK34pXd7X4XedTyw8qw+GraRhQpKnByZuZSMstfQhJAEjNNeDkzUynRwWrqJuZBfj733RwHCCXcDBa7p4tuYQDxzEc/TcdNzML0KiOV712JDY1FzvOpSAuLU8cAvSf+ExEt/anGgzEZfho5JDyHExmAQqpBEXLGBgDTGYBMp6Dj8bJ0StqERUwuDCzWcDx6xm4cCsbp29kwcQYgj3U6B7uA0+NHAUGCzQKKdyVMjTwUImZrSAwJGYVIt9ohptcajfvXji1vthYYNYsIDoawvQZ1vioHnDb2BsNPNViW53y1lXVaa/0flUinhBCCKkqzg63fHbeoFJrR+j1Zqw/eR2JmXo08FRiZPtGJWouFDWmSygA4NsDcUjJMYh9CwTolHimR2NxflWzVYu3PVSm5OihkEoQ2UCHga0q91CZnF12YUB5/rxy2+7z+VtZMJUcwdSOSbDGVVcBw7+385GYWYhcgxnF+4czWhjMhWYIQiH+vZ3vcgUMdkOA6pRQy1UoMJpx7lY2bmUXUjMJ4jKa+Grgp1UiJUePAqMZUglvG20YZosAAYC/VokmvppaTmn5qIDBRe25mIKv9sXibGIWjMVeRHx9IB5KKQcPtRxapQyNvNV4INgT0a2t1SSLl/I28dXccymvo1Jju/Xl51trKixaBBiNMP99FN9F9MWVbFOJ+PLSVu62qlBFt1WTaSOEEEIqo7TaEUqlFOO6Nq7QusZ0CcXIqGDsvJSM5GwDAnQKDGweUO3t+cP93NG4t6bKC/Yr+3awsNhN2Yl/051a7sS/6ZjUPbxS2y6NSbAgV29GaeUcAgNy9WaYhKodUrS6FR8C1Fat3F0pg0YhxdXUPOw8n4LGPhp64UPqvIaeavRq6ovfTt9Cnt4Ei9Ei1vyWcIBGKUOvpr5o6Hlv/cTUJCpgcEF7LqZg3u8XcCuzwK4n4KL0ZoasAiNkPIebmQUwmAVcTM4BAFgEViWlvGWWGmcVYEbmaQTOewu4cQMAUNC7L74e8QKu3NaXiC8vbX2b+2HvpdQaKaGuaGk4lZ4TQgi5n8nlEjzUpkGNb5fnOQTfY6eMpRnZsSG2nUu55+XDfOxrAJy55dy49c7G3Ysb6YWlFi7YCHfiXEnRIUABIKfQJPZB4q6U2g0BWtXXCSFVjec5dAv3we6LqSg0WSADgDsN1hisHcZ2C/dxicIyKmBwMWazgJWH4pGWU1hq4YKN3sxgtggwmQWYzBZcTtaDAxDdyh88b22UcK+lvGWVGje8fRNd3n0XgeePWYNDQiB8+hlW6lrjSlJOiXg3uQQ7zqcAHBDdsmTarqTkYdVfCXBTSNDU371aS6grWhpOpeeEEEJI/dGtsR8C3OVIzr23jtTeHNrc7rPFyTHrnY27F+n5zjX7cDaurrANAao38biYlIPUXANMFgEyCQ8/dwXCfNxgMFuqdQhQQqqKIDBcSspFiJcaQToF0nKNMAkCZLz1epZKeFxOzkWfZn51/pmCuld1MSdvZCIuLQ+Ck+M0Z+vNkMskSM01wmC2wMJYiZ6MOY6zK+V1RtFS4+I9ncoMBjS7eBwmmRzZr70JXLiAxN7RiLud7zA+z2BNl0VwnDZ3pRQJ6flwV0od9qpa0bTf63452lZF4wkhhBBSd0mlPD78Txu4l9H3RGmCdEq0DPS0m9YmSOvUss7G3QtjgXP3IM7G1RVucimMZgGH49JxKSkHabkGZBUYkZZrwKWkHByOS4fBLFTrEKCEVBXbM0WEvwYdw7zRs6kvekT4omdTXzwY5oUIf43LPFPQN87FpOcbYbQIcLYw1mgWYDJZkG8ww8IApZQho8BY4mFdJZcgJUePnAITjmWnIy3PAIsgQC21DmnkrZGjsa8GwZ5q8Dwnlhqr5SqAMfjFXkBKeEvk6s247R+GX6e9i5ON22L0U32hU6uRn5NzNx7WUrqknEIUGC3IKTTBYDKD53lk5BlgMFtgNAuQS3mxF1W9ydp+MKfQVGrabSXUZrNwz0MV2e2XA8W3VZF4ZzqBtMXk6k3IM5ihUUrhrpDdc7vSinQ86SgWwD21b62ODi+pE03iSuh6JcR19WvhjyUj2+HbP6/ifFKe+FY8zFuF+PRCh6Nw+LjJ8N9JHUt8zz8e0RY7PtxT7jY/HtG2ytJf3LpTyU7HvfVotSWjygVqlcjMNyIpuxCChUFgEEdA4TmgwGSBt0aOQK2ytpNKSLmKPlNwHAetSmY3v/gzSF1GBQwuxttNjhy9ycn6C4CZAbG3C8Bzth9cDievZSI1x4BwPw283KydGRUaLcjIN2Lu7+dxI7PA+tBvttaTkPIcFFIeflolekX44qnOjeAml0IplcD98jkM/XYBAi+cwhvv/BdnPRrCbBHwd1gvKCQSDMw1oHkAxPgCoxm38wyIuZ4lFpYIjEEQAJ4HsgpMYo+pUgkHlUwCs4UhV2/G2cQsJKQXwEstRxM/N3i5KcS0K6QSuMml2HMxBav+SkBCer54QxDq7Ybx3ULFscDLUjSd7kpZiflFt1WR+Nu5Buy5kFpmJ5C2jiJP3cjE9fQCFJosUMklaOR1t5POivaR4WzHk45iPVQygLOek4p0XFkdHV5SJ5rEldD1SojrK23oz4SMfPx64jo2nbqFPIMFGoUEIx4IwiNRjRx+vz3clegQ4oHj17JK3VaHEA94uFffQ3BheW1qKxhXV9zKLkRqjh4GB+m2MABmhrRsPW5lF7rc6Bjk/lPRZ5C6rO6nkNj5cm8sTPfQya/AAAkAxjHkG8xIzCpAnsGMdsEe8FTLcPpmFuJvFwBMgFkATBYGAXfGXbUwSHgBqTl6bDufjNQ8A2ZFeWP8uk/R+tc14JkAvVwJXdwlKDuHQKqwPlCbOQ5/nE1GoE6Jxj4aNPHVYO/lFMSl5lkLL5i1wAOMwQLAIgB5ejMkPOCmkMJsYbhtMEAQGGRSHhzjoJBySM3VI9dgupN2OZKy9YhsoMPl5Bws2H4ZuXoTvN3k4rjYV1JzMf+PSwBQbiFDAw8VmvhqcO5WNjQK+5oSjDFxW7a3+87EB+qU2HY2CZkFplI7gQSAlX8l4HpGAdJy9bAIAtyVUhhMAm5kFMBgEirUYWRFOp50FHsrqwC7Llo7uXow1BONfTROdVxZHR1eUieaxJXQ9UpI/eFo6M9wP3e8GN0ST3QKc7qG0sZp3fDY8r8cFjJ0CPHAxmndqjrpdjRyCbL05d88aqp55I+qFpuWh6RsfZkxt7L1iE3LowIGUudV9BmkLqMCBheSk2fAgau3yw8sDQdoFFIYzALkZmuziQtJ2fBRy5GYqQcYg1LKI73ABIExcACkvPXB3yIACgkHk9GEsF/XocFz30GVnQkA2N+uD74cPBUIbggIDFkFZrirZGjbUIf0fCN2nk/Bs7006NfcD//39zUUGi2QSjiYBQYJby1l5jlrIYgAQMpxsAgMFkGA2cKgkPHQKqUwMYY8vRkapQx5ehMuJOXAV6OEt0aOvs398OHWi8jVm9DIU1Wko0gebnIJrmcWYvXhBPSK8C2zuQTPc4hu7Y9b2YW4mmrtW8FWUJGUrYeXmxwDW/mLNxLlxqvlAAMyC0yldgK541wyGID0PCPMZus+e2sU4DgOGgVDRr4RZkFAep7BqQ4jK9LxJIASsdYfMQPkUh5gDMk5BjT0VJfbcWV1dHhJnWgSV0LXKyH3h3sZvWLjtG7IytVj9q9nkZipRwNPJeY/ElmtNRfubrsj+n92xKk4V1LWaGo2ZmaNI6Suq+gzSF1GBQwu5L0/LlRqeQ6Ap1qOPIMZuXoLwACj2YIgDxUABi83OW7nGcHu/FhLOGtHhTzPYBYYOA748r9vocu/JwEApmYtcOnND7Aw0wcGswC+0AQJb21K0cTX2oRBLpWIHZLkGEwAGNwUUuQZ7vSXINxpDsFb/29rP6c3WQdUkst4yCUSeLopoDdZoFXJUWiywMKA1BwDokI88USHYGTkG5GQng9vN7lYuGDD8zy83eSIv52PkzcyS7yNKC7czx0TuoWKVZxTcvRQSCWIbKDDwFYlqziXFd+qgRZr/74OlVyCXL3Zrv8IWyeQZ25mAxygU8qQkJ4PTbEYjVKKzAITGnqqSh1uqWh775xCE2JTc53ueLJ4J5W5ejMyC4x3qmdZCzhy9WZoVbISyxdNR0U6vHT2xqw61klIdXHF65X6iiCk5ni4K7H86QdrfLvh/l6QSwBjGZUY5BJrnCs5Gp/udNzTXcKqOTWEVF5Fn0HqKipgcCE3M8quBlYWHtbmDjl6ExizDodkYYCMAwJ01r4M5FIeAmNgzNpRDgdrlRx2Z1kLA/4Kj0KbxEvY/MgziPrkXchkMoTsvgpfjQIWxsSxh2031yq5BMnZ1pvu2NQ8mAUGnUqKPKMZHKw3twIDOOFuOtUyiVigoVFIYDQz8BwHCc+hRaA7FFIJCk1mpOToMfyBBmjso8GRuGsoMJqhU8nAGCtxc6+SS5CRb0R6vuNhp8TOFQ0may0JhRTD2gaCASg0Wcq98Q73c0fj3hq7G/VCowVrj13D2VvZUMkkkEl4eKrldn1fqOQSFJishS2eajnMggCZxP5rKZPwyDOYIeE5FBjNJTp3Kd7e29asIirUE4zBbkxojuOgkkuQlK3H0X/TkVVowq3sQgQU6QDJaBFgtgiQKaUAOOQbzDBa7o6gXVonMxXtINMZVd2JJiHVqTq+A9WJ+oog5P5x5cOhaPrWVoeFDHKJdb6rSc5xblhNZ+MIqQscPVO42j0tFTC4kIZeSiD+3pa1PR7m6s3gwGARgFyDCTl64LdTSdCbLcjTm2C2WHCn8gAEiwVPxWzHv14NcDi0HQpNZqxsPwz7ovqjYfPG6OlmvYlWySSQSjh4KuUltpuUVYiE9EL8eOw6sgtNyNObkKs3QxAAmYSDRAIIzFrYYavlZhEESHgOPMfBLFjf/AmMQcpbR5WwvkkHPNUKZOQZsfxiHI7Gp6PAaMGNjAK4K2XwutMHg02h0QKZxFqToTi7zhUzClBotEAlk6CR993OFZ1521i0ymRsai5WH0nAzcwCqGQSuCkk4Dkeabl6se8LLzc5Co0WqGVSgLMWckh5HiaLAIX0btpNFgFSnodFYCU6d3HU3jslpxBnbhqx63wK3FVSSHgOUp4XO8dMztYj5kYWYq5nwiQwFBjMuJ5egA6hngjz0UAu4SGV8DBZGAAGCc9DLrlbK6S0Tmaqo3OaquxEk5Dq5kodNFFfEYTcf658OBSxKRl4bPkx5Bkt0Mgl2Dito8vVXLDx1SiqNI6QuuJemmHVJbV/l0Oc9vagFth44lal1mG03G2sZjFZ/5+WZ4DAgOzCu2/Vom5ewHu7VqBV6r+I82qAQRO/hBkyMF6Cm3IdOnkoxU5GSuuQJD3PgH8SMqGSSRCkU6GxtxvOJ2Yjz2ABz1n7dZBwd5tF2OQZBUg4QCHlYDAL8FLLYDRZ4K9TwV0pddh5YmMfN8Sn5SE934g8gwlGi4AArbXtkiAISM83opm/O9oH249PbbvJvp5egNRcPSwWdqdzRQtuZhbAYK5Y54qAfTvsNg10MJkZUnP18HKTwMtNjox8I+LS8uCh8kBSth5tGurAAJxLzIGnSoa0PAPkbrzYH0Ke3gxfdwVy9Wa0aeghHvfS2nsrpBLwHIcsvRFSCRDs6QaTICA1V4+bmQVIyzOC54FGniqo5BLcyChEer4BB66kAQBCvd3gqZYjNdfaL4ftuANldzJTHZ3TVFUnmvSgRGqCq3TQRH1FEHL/Cvf3QszcQbWdjCrxZMdgbDuX4lQcIaTmlN7bHalzck0ClNKqu9mzPdQXvX/0zcvE4q2fYtOa19Aq9V9kK9ywMuphWDgeDNbaBjIpD3D2nRx6uclxNTUPuXoTzIKAnEIjjiVkAAA6hnlCq5JBbxagU8kgk1i3bREY9GbmcMhNCwP0ZgaThSHPKEAqlSDEW408gxlXU/NKdJ6oU8vxQIgnlDIJTBaGQqMZt/P0yC004XpmIbRKGcZ1DbXr4NF2k52eZ4BZEGARGLw1crgrZfDWKGC2MJgtAtLzrB1VCoJzwzcVbYfN8zya+LmJTTSMFgFqhRQpOXqcScyGl5sc0a0DMKh1ALw1ckilPCQ8h/Q8A3L1JqTnGSGR8JDyPLw1CrvOXRy192aMIS4tHwopD41CinyDtTNPmYSHWi5FUo4eJouAUC8VtCo5ZBIJAnUqaJUyFJosOJ6QAbOFIVCngNEswGhhCNBam7/k6k3WY19KJzOlXQvlLVeWctdZ7DpwV8og4Tm4K2WI8NMgI79i546QyqiO70B1qEhfEYQQUld1beyLAG3JmqlFBWjl6NrYt4ZSRAgBqIDBpeQbzVBXQ9VaiwBILWZM+mcz9n47BSPO7YUADj+2GYg+U77B/9oPhcBbq+yrZRL4uSuQmW8Ubz5tHZK0DtIhq8CEhNv5uJWlh4zn8GCoJ7w11vb9RosApUyCEG83qOUSu2YRRRW9KKUSQKeUoqGHEjmFJmQVmBDZQIdBkQHIKjTZ3SCH+WjQPcIH3m5yMAAZ+SZkFlhrLrwxuHmJISptN9nudzpR1ChlDjtXdFdKK3SzfbcdtvVcebkp0C7YA37uSuhNAvINJuhNFjT20Yhv123HsHOYN4K91JBIeOTqzZBKOAR7qtCliXeJN/HFtwPc7aDRS6NAoE4FuZRHocmCzAIjsgqN4AAopDxkkrtNMFTyu4UMWQUmnLyRCYDDwJb+GNDSHwCHhNv54rEvq0aAo2vBmeXKUtY6HV0HNvSgRGpDdXwHqpqj346iVHIJDGZLnekrghBCHJFKeXz4aBtolY5/y7RKKT58tE2Zo4cRQqoeNZFwIW5yKdRyCTIKTFW2TtsDfveEU3hn73cAgJjACMzp/yxOBzWzi5XygJ9WAbPAkFVosrv5LN4hSXK2Huv/uYEgj7vth2xt+5UyCcJ8JLiakgcGBsudvgcAa20GN7kEDBxMZuuoEc0CNJjcswm0KpnY0cmV1FyHnamF+WgQ4qVGYqYeCRn5GNWxER5t18Bh5mK7ydYqZUU6NbxLJuGRX0bniqVx1A7by00Bz1C5WABQaLJgQrdQu3GZix7DXL0JeQYzNEop3BUyh527ONpO8Q4afTQKRDbQQSGT4FZWAdJy9JBJOFiYfdGOSi5BsJcK1zMK0b+FP6JbBYjVuCvayUx1dE5T2jpLuw6K7ldd6lSP3B/qegdNrtRXBCGElKVfC398NrIdvjsQi3O3cmGyCJBJeEQGaTGpZ5MSL5cIIdWP7h5cSAMPFfq38MOqI9erZH0yiwkmifXmcn/jDvilZW8cadQGG9r0B+N4lLgVZkBuoRkGs3WISykrWUXe1iGJm1wKlcz+BtZdKYWnWo60XD14DuB5gAMPQICEByyMg4LnoJRJAHAAY5DwHPRmAVqVDM0DtOK2yrpB5nkeHm4yhHJu6NzYu9SSa9s6LIIgdmqoKNIExWQRICmlc8WylNYOm+M4uCulSM7Ro21DDzT0LNl5S0U6dXG0HbGDRrOAPIMZflolgjxU4DgOBrMFEgkPgQESruSDjt4kQCWToE1DnV0a7qWTmeronMbROulBidRVdbmDJlfpK4IQQpzRr4U/ekX44uSNTKTnG+HtJkf7YE+quUBclquPjEZ33S6E5zk81SkUa/6+DlMlmpTLzSY8888veCrmDzw0/nNkqbQAx+HFYa+UugwDYGZA2p1hHnNS8/CfFYcxrlsoXh7YrMQXIVCrLHEDy3Ecwv00yNWbkJyjh4y3DYsJmO/UYlDKJeA4DmaBgYEDxwFqmbTEA2JV3CDb1nE2MQueahnScg2Qu8lL6VzR+ZttWzvsW9mFuJpqbeeskktQaLQgKVtfZe2wHW+Hh5tcgptZhfDVyNHE1008NgHuSiikEujNFhTPc8vqCLMuowclQiqupn6jCCGkpkilPDqGedd2MgiptPowhDQVMLiYpgHu+E9UA6w/nnhPy/f69wTm7P4ajTOto1E8cWYXvuk0wmFsWWUYHIAcgxnL98ciLi0PDT1USMs1wGARxC9C80B3JGYV4PTNLHiq5XBXSiHlOXiq5ZDwHPL0JruxidVyCWQSHowBBpMFPM9BIZU4fLgveoN8JSUX7krrcIwWgSFXby7RIWJRRQtD2gTrrP83WO50rmiEQsojz2ACz1sLOrwd3GyXV7Joa4dt+4FIydFDIZUgsoEOA1tV3Q9E8e0YzBZ4uslhFhi0KhlkEh5mQRAfHCIb6PDv7XzcyNLD+85QnoVGC9LzjQ47wqyrih7/tsE6JGYV0IMSIRVQU79RhBBCCHFOfRlCmgoYXMylWznYdKLihQsNs5Lx7t7vMPDq3wCAVDdPfNhnIn5t2bvC6xKf1RhgFoA/ziYjUKtAoIcKzQLcoZRJcO5WNi4m50Am4ZCWa0BsSh7AAVqlDJENtHi6SyMUGCz4+eRNXEzORaHRDKNJgMAYzGYBFgAauRTNAtwR3TrA4QNiuJ87+jb3w6q/EnD+Vo7Y7i7Uxw2PN/dz+AV0VCrooZIhwl8DhYxHbGoebmYVgjFAJeeRb7BAUeyB29mSxZpqh+1oO4VGC3ZdcPzgcC29AKv+SkBCej4y8o2QSXg083fHuK6hLtFW0eE5VMsQqJUgq8BED0qEOOlefqMSEhLw/vvvY+/evUhOTkZQUBCefvppvPXWW5DLrb25X7t2DQCg0+nslj1y5Ag6d+4sft6wYQPeeecdJCQkICIiAh9//DGGDBkizmeMYc6cOfj222+RlZWFbt26Yfny5YiIiBBjMjIy8Pzzz+P3338Hz/MYMWIEPv/8c2g0mio5RoQQQkhNKDqEdLivG/IM1k7a5RIe4b5uiE3Ld5khpKmAwYUIAsPT3/8Nc0WaRzCGmYfXYfqRn6CwmGDiJVgZ9TC+6DYKeYqKtw/mYB3loegIEOzOjOxCE87czEaEvwY8B5y4lgl3hRTdmvjAwhgSswoQl5aPYwmZSMoxQC2XwFujQFQjKa6m5iIt14ACowApz8Ffq0Tvpr4Y1alRqQ+Isam52HspFW4KKbo09gbPcxAEhhy9GXsvpSLEW223bGmlgknZeniqZRjQ0h8yCYeMfCMCtEroVHJIeCApR4+VfyVgQrdQAKhQyWJNtcN2tJ1wP8cPDuF+7i7bVrHscyjHo+0bwNdd4ZLt1QipDRX9jbp06RIEQcDXX3+N8PBwnDt3DpMnT0Z+fj4++eQTu9hff/0VHTt2FD97e9+tvnz48GGMGjUK8+fPx0MPPYS1a9di+PDhOHnyJFq3bg0AWLhwIb744gusXr0aYWFheOeddxAdHY0LFy5AqbSOTjR69GgkJSVh165dMJlMmDBhAqZMmYK1a9dW5rAQQgghNco2up1KxuN4QiZScg0wCQJkPA9/dwUCPe6OjFZX+3iy4RhjNEB8DcnJyYFOp0N2dja0Wm35CxRz/kYmhi47XOHlPtr+JZ46vR2HQtpibv+piPVpVOF1lMdHI0egTonEzEJw1v4ZYTALUMp49GzqC41ChpgbWSgwmlFoskACQCblkaM3Qy7l0baBDl3DvaGSSeGtkaOxrwbBnupSHxAFgWH5/jicu5WNCD9Nibb3V1PzENlAh2d7NRELHsqKv5KSi3yjBW5yKZr6O15f6yAtGIDzt3Kc2iapWhU954SQmrFo0SIsX74c//77LwDg7NmzaNOmDQ4ePIju3bs7XGbkyJHIz8/Hli1bxGmdO3dGu3btsGLFCjDGEBQUhJdffhmvvGLtHyg7Oxv+/v5YtWoVnnzySVy8eBEtW7bEP//8gw4dOgAAtm/fjiFDhuDmzZsICgpyKv2VzZsJIYSQyrqUnIOPtl7ErawC3M4zwmxhEGB9sSuVcPDRyBHkocabQ1vYdXzvrJrM6+r+K0simr/9klNxYRmJCM5KFj8v7DUW0x55A0+P/KBaChcAoMBgRmJmISwCg8nCIDBAKeOhNwk4czMLZxOzUGg0Qy3jYTBZkF5gRK7eDEEQkJVvxKHY29hw/CY83eTo09wfId5uZT4k2kr5AnVKuwdNwDpaQ6DubimfM/HuSikSbudDq5SWur4zN7NxNjHb6W2SqlXRc04IqRnZ2dnw8vIqMX3UqFHw8/ND9+7d8dtvv9nNO3LkCPr37283LTo6GkeOHAEAxMfHIzk52S5Gp9OhU6dOYsyRI0fg4eEhFi4AQP/+/cHzPI4ePVpqeg0GA3Jycuz+CCGEkNqklkmQmFmAm1mFyNWbkW+0oMBoQb7Rgly9GTezCnErswBqmaS2k1ouKmCooGXLliE0NBRKpRKdOnXCsWPHamzbNzLyy5yvNhbitT9XYcf30/HBzq+s1QgAZKm0+KN5d8DB0IRVRWBAgdECtVxy57N1iEmljIfeaMHNzEJoFFJkFphhsggwWxgMZgEyqQTuShkkPIdb2Xp8secqrqSUf7OXbzRDb7ZAXcrwgyq5BAazBflGs1PxEp6DySKUWqihkktQYDKjwGh2epukalX0nBNCql9sbCyWLl2KqVOnitNs/R+sXr0aW7duRffu3TF8+HC7Qobk5GT4+9v3+eLv74/k5GRxvm1aWTF+fn5286VSKby8vMQYR+bPnw+dTif+BQcHV3S3CSGEkCplYQxpeUboTaxEU3QLA/Qm63yLCzQ+oAKGCli/fj1eeuklzJkzBydPnkTbtm0RHR2N1NTUGtn+tUyD4xmM4aGLB7Dn22fx3N8bIRfMEDgOKlMp8VVMIeEg3LnYTQIDz3HgOcBgEqCSS6FRyqA3WaA3W1BoMsNsYWAAVDIeUp6DhAd4joOXmxxpuQZsOpEIQSj7y+Mml0IplaCglIfJQqMFCqlEHN6yvHiLwCCT8KVut9BogVomhVoudXqbpGpV9JwTQpz3xhtviMMJl/Z36ZJ9LbrExEQMGjQIjz/+OCZPnixOt/W10KFDBzz44INYsGABnn76aSxatKhG96k0s2fPRnZ2tvh348aN2k4SIYSQ+9y/t/OQZyj7JVmuwYx/b+fVUIruHd2JV8Cnn36KyZMnY8KECQCAFStWYOvWrfjhhx/wxhtv1EqamqYlYN7ur9Hl+lkAwHWdP+b1n4I9TTpWa40FGy+1DACQqzeDQYDBZIFaIYHRbK3F4KmSgeOsnUPqTRaYLAwmgUEu5SHhreVbFmat4q6U8jBKeac6MGngoUITXw3O3cqGRiEt0R7fNiSjbXjL8uJz9WaE+rghR29GAGMO19emoU7sg8GZbZKqVdFzTghx3ssvv4zx48eXGdO4cWPx/7du3UKfPn3QtWtXfPPNN+Wuv1OnTti1a5f4OSAgACkpKXYxKSkpCAgIEOfbpgUGBtrFtGvXTowpXsBvNpuRkZEhLu+IQqGAQqEoN82EEEJITbmUlINy3q9CYNa4fs1Lz+PqAipgcJLRaMSJEycwe/ZscRrP8+jfv7/YHrQ4g8EAg+FuLYKqbufZNSEG//3pXUiZAL1UjmWdH8c3nUbAIJVX6XYckXCAn7sC/jolCgwW5BvMMAuADIBaLkWgToZ8gwWFJgtkEg5yqQR6kwCTxQIO1nZG1s4gGYxmAW5yKTgOkEt5CEwot5o7z3OIbu2PW9mFuJpqbZevkktQaLQgKVsPLzc5BrbyF5s8lBfvrVHg8eZ+2HsptdT1Rbe2fpmTsvVObZNUrYqec0KI83x9feHr6+tUbGJiIvr06YOoqCisXLkSPF9+ZciYmBi7goIuXbpgz549mDVrljht165d6NKlCwAgLCwMAQEB2LNnj1igkJOTg6NHj2LatGniOrKysnDixAlERUUBAPbu3QtBENCpUyen9oUQQgipC67ddq4PMWfjahMVMDjp9u3bsFgsDtuDFq82ajN//nzMmzev2tJ0vGErXPMMxBWfEHzYdxJu6vzLX+geSThAJuHBc9a2QKE+bvBQyZBZYIJFECCTcFDJpejaxAv+WhXclVJkFpgQm5qLa+kFcFdaLzW9SQq9yQwODGbBWrggk/DwVFsLJHRqGTxUcqequYf7uWNCt1DsOJeCuLQ8pOTooZBKENlAh4Gt/EsMb+lMfIi3utz1VWSbpGpV9JwTQqpWYmIievfujZCQEHzyySdIS0sT59lqDdiGiLxy5Qo0Gg1+/vln/PDDD/juu+/E2BdeeAG9evXC4sWLMXToUKxbtw7Hjx8Xa0NwHIdZs2bhgw8+QEREhDhMZVBQEIYPHw4AaNGiBQYNGoTJkydjxYoVMJlMmDFjBp588kmnR5AghBBC6gKFzLkXZM7G1SYqYKhGs2fPxksvvSR+zsnJqdLOpIxSGR4dsxg5Sk2VrbMoHoAAQMYDnm5yqOVSpOToIZfyaO7vjkAPFdJyDUjKLkSIjwYqGQ+BWVtmWBiDTMJBp5LhwTAvDI0MhEouwZ4LKdgccwvZejNUMincFBK4K6UoNFmglEmglkkR4e/udDX3cD93NO6tQWJWIfKNZrjJpWjgoSr1LXZ58c6sr6LbJFWLjj8htWfXrl2IjY1FbGwsGjZsaDev+KjXvXr1glQqRfPmzbF+/Xo89thj4ryuXbti7dq1ePvtt/Hmm28iIiICmzdvRuvWrcWY1157Dfn5+ZgyZQqysrLQvXt3bN++HUqlUoxZs2YNZsyYgX79+oHneYwYMQJffPFFNe09IYQQUj2iQr3wv79voKxWEtyduLqOY8XvCIhDRqMRarUaGzduFN+eAMC4ceOQlZWFX3/9tdx1VHb80cg3tiK3wktVDAfr8JJquQSMARIekEslkPIcTBYGd6UULYO04MDBYLZ2qhfup8HAVtbaE7Y3y8Xn2d4sCwLDhhM38P2heGQVGKGSSaCQWQsZ1DIpGnmrMaFbKL2JJoQQF1WTY21XBVdLLyGEkPrHaLSg28I9SMszlRrjp5Hh0Gv9IJdXfKjKmszrqAaDk+RyOaKiorBnzx6xgEEQBOzZswczZsyokTScXTAUoW9srZZ18wDcFVJ0buKF0Z1DoDcJOJ6QidScQmTrTeA5HuF+GoyIaoBwX/dS3x6X92aZ5zmMfLARHmjkgY3HExGXlgeBCfBQyRHh707V3AkhhBBCCCH3Fblcgpn9mmL+tksoNFnsajJwAFQyCZ7v1/SeChdqGhUwVMBLL72EcePGoUOHDujYsSOWLFmC/Px8cVSJmpBQiUIGdznQPECDwW0bQCOXQ2AMmflGmCwCAj1U6BDqhRAvN7FAoH8L/1ILC0ob4YHnuTJHf7Bp6q/FG4NLL6gghBBCCCGEkPvFmC6hAIBv/4xDcq4BAmPgOQ4BWgUm92wizq/rqIChAkaOHIm0tDS8++67SE5ORrt27bB9+/YSHT9Wt4QFQ8ttLtFAK0W4vw7juoWgsY879HdGaqjIQ7yzhQX3qrrXTwghhBBCCCGuYkyXUIyMCsbOS8lIzjYgQKfAwOYBLlFzwYb6YKhB1M6TEEJIfedqeZ2rpZcQQgipqJrM68ofvJoQQgghhBBCCCGkHFTAQAghhBBCCCGEkEqjAgZCCCGEEEIIIYRUGhUwEEIIIYQQQgghpNJoFIkaZOtPMycnp5ZTQgghhFQPWx7nKn1IU95MCCGkvqvJvJkKGGpQbq51YMng4OBaTgkhhBBSvXJzc6HT6Wo7GeWivJkQQsj9oibyZhqmsgYJgoBbt27B3d0dHMdVen05OTkIDg7GjRs37ouhtWh/6zfa3/rvftvn+3V/r1+/Do7jEBQUBJ6v+y0xqzJvvt/OeUXQsXGMjkvp6NiUjo5N6ejYOMYYQ25ubo3kzVSDoQbxPI+GDRtW+Xq1Wu199QWi/a3faH/rv/ttn++3/dXpdC61v9WRN99v57wi6Ng4RseldHRsSkfHpnR0bEqqqVqFdf/VAiGEEEIIIYQQQuo8KmAghBBCCCGEEEJIpVEBgwtTKBSYM2cOFApFbSelRtD+1m+0v/Xf/bbPtL/3HzoGpaNj4xgdl9LRsSkdHZvS0bGpfdTJIyGEEEIIIYQQQiqNajAQQgghhBBCCCGk0qiAgRBCCCGEEEIIIZVGBQyEEEIIIYQQQgipNCpgIIQQQgghhBBCSKVRAQMhhBBCCCGEEEIqjQoYXNSyZcsQGhoKpVKJTp064dixY7WdpBLmz5+PBx98EO7u7vDz88Pw4cNx+fJlu5jevXuD4zi7v2effdYu5vr16xg6dCjUajX8/Pzw6quvwmw228Xs378f7du3h0KhQHh4OFatWlUiPdV9zObOnVtiX5o3by7O1+v1mD59Ory9vaHRaDBixAikpKS45L7ahIaGlthnjuMwffp0AK5/fg8cOIBhw4YhKCgIHMdh8+bNdvMZY3j33XcRGBgIlUqF/v374+rVq3YxGRkZGD16NLRaLTw8PDBp0iTk5eXZxZw5cwY9evSAUqlEcHAwFi5cWCItGzZsQPPmzaFUKhEZGYlt27ZVOC2V2V+TyYTXX38dkZGRcHNzQ1BQEMaOHYtbt27ZrcPRNbFgwQKX218AGD9+fIl9GTRokF1MfTm/ABx+lzmOw6JFi8QYVzq/Nc0V8uXKqEt5XG1zpbyhprnS72pNcuaeuD7eJzrjfnteuC8w4nLWrVvH5HI5++GHH9j58+fZ5MmTmYeHB0tJSantpNmJjo5mK1euZOfOnWMxMTFsyJAhrFGjRiwvL0+M6dWrF5s8eTJLSkoS/7Kzs8X5ZrOZtW7dmvXv35+dOnWKbdu2jfn4+LDZs2eLMf/++y9Tq9XspZdeYhcuXGBLly5lEomEbd++XYypiWM2Z84c1qpVK7t9SUtLE+c/++yzLDg4mO3Zs4cdP36cde7cmXXt2tUl99UmNTXVbn937drFALB9+/Yxxlz//G7bto299dZb7Oeff2YA2C+//GI3f8GCBUyn07HNmzez06dPs4cffpiFhYWxwsJCMWbQoEGsbdu27O+//2YHDx5k4eHhbNSoUeL87Oxs5u/vz0aPHs3OnTvHfvzxR6ZSqdjXX38txvz1119MIpGwhQsXsgsXLrC3336byWQydvbs2QqlpTL7m5WVxfr378/Wr1/PLl26xI4cOcI6duzIoqKi7NYREhLC3nvvPbtzXvQ77yr7yxhj48aNY4MGDbLbl4yMDLuY+nJ+GWN2+5mUlMR++OEHxnEci4uLE2Nc6fzWJFfJlyujruRxdYEr5Q01zZV+V2uSM/fE9fE+0Rn32/PC/YAKGFxQx44d2fTp08XPFouFBQUFsfnz59diqsqXmprKALA///xTnNarVy/2wgsvlLrMtm3bGM/zLDk5WZy2fPlyptVqmcFgYIwx9tprr7FWrVrZLTdy5EgWHR0tfq6JYzZnzhzWtm1bh/OysrKYTCZjGzZsEKddvHiRAWBHjhxhjLnWvpbmhRdeYE2aNGGCIDDG6tf5LX6jJAgCCwgIYIsWLRKnZWVlMYVCwX788UfGGGMXLlxgANg///wjxvzxxx+M4ziWmJjIGGPsq6++Yp6enuL+MsbY66+/zpo1ayZ+fuKJJ9jQoUPt0tOpUyc2depUp9NS2f115NixYwwAu3btmjgtJCSEffbZZ6Uu40r7O27cOPbII4+Uukx9P7+PPPII69u3r900Vz2/1c1V8+WKqCt5XF1Tl/OG2laXf1drW/F74vvlPtEZ9f154X5ATSRcjNFoxIkTJ9C/f39xGs/z6N+/P44cOVKLKStfdnY2AMDLy8tu+po1a+Dj44PWrVtj9uzZKCgoEOcdOXIEkZGR8Pf3F6dFR0cjJycH58+fF2OKHg9bjO141OQxu3r1KoKCgtC4cWOMHj0a169fBwCcOHECJpPJLg3NmzdHo0aNxDS42r4WZzQa8b///Q8TJ04Ex3Hi9Pp0fouKj49HcnKy3XZ1Oh06depkd049PDzQoUMHMaZ///7geR5Hjx4VY3r27Am5XG63f5cvX0ZmZqYYU9YxcCYt1SE7Oxscx8HDw8Nu+oIFC+Dt7Y0HHngAixYtsqui6Gr7u3//fvj5+aFZs2aYNm0a0tPT7falvp7flJQUbN26FZMmTSoxrz6d36rgyvlyRdV2HucK6lLeUFfVhd/V2lb8nvh+uE901v3wvFDfSWs7AaRibt++DYvFYvcFAgB/f39cunSpllJVPkEQMGvWLHTr1g2tW7cWpz/11FMICQlBUFAQzpw5g9dffx2XL1/Gzz//DABITk52uK+2eWXF5OTkoLCwEJmZmTVyzDp16oRVq1ahWbNmSEpKwrx589CjRw+cO3cOycnJkMvlJR7E/P39y92PurivjmzevBlZWVkYP368OK0+nd/ibOlztN2iaffz87ObL5VK4eXlZRcTFhZWYh22eZ6enqUeg6LrKC8tVU2v1+P111/HqFGjoNVqxekzZ85E+/bt4eXlhcOHD2P27NlISkrCp59+KqbVVfZ30KBB+M9//oOwsDDExcXhzTffxODBg3HkyBFIJJJ6fX5Xr14Nd3d3/Oc//7GbXp/Ob1Vx1Xy5oupCHqdSqapp76pOXcob6qK68rtamxzdE98P94nOuB+eF+4HVMBAasT06dNx7tw5HDp0yG76lClTxP9HRkYiMDAQ/fr1Q1xcHJo0aVLTyayUwYMHi/9v06YNOnXqhJCQEPz0008ucVNUWd9//z0GDx6MoKAgcVp9Or/kLpPJhCeeeAKMMSxfvtxu3ksvvST+v02bNpDL5Zg6dSrmz58PhUJR00mtlCeffFL8f2RkJNq0aYMmTZpg//796NevXy2mrPr98MMPGD16NJRKpd30+nR+ScXc73kcqRr38++qTWn3xOT+eF64H1ATCRfj4+MDiURSolfZlJQUBAQE1FKqyjZjxgxs2bIF+/btQ8OGDcuM7dSpEwAgNjYWABAQEOBwX23zyorRarVQqVS1dsw8PDzQtGlTxMbGIiAgAEajEVlZWaWmwZX39dq1a9i9ezeeeeaZMuPq0/m1rbus7QYEBCA1NdVuvtlsRkZGRpWc96Lzy0tLVbEVLly7dg27du2yq73gSKdOnWA2m5GQkCCm1ZX2t6jGjRvDx8fH7vqtb+cXAA4ePIjLly+X+30G6tf5vVeumC9XhdrI41xBXcobXEFt/a7WltLuiev7faIz7tfnhfqIChhcjFwuR1RUFPbs2SNOEwQBe/bsQZcuXWoxZSUxxjBjxgz88ssv2Lt3b4nqbI7ExMQAAAIDAwEAXbp0wdmzZ+0yG9tDTcuWLcWYosfDFmM7HrV1zPLy8hAXF4fAwEBERUVBJpPZpeHy5cu4fv26mAZX3teVK1fCz88PQ4cOLTOuPp3fsLAwBAQE2G03JycHR48etTunWVlZOHHihBizd+9eCIIgZo5dunTBgQMHYDKZ7PavWbNm8PT0FGPKOgbOpKUq2AoXrl69it27d8Pb27vcZWJiYsDzvFjl1ZX2t7ibN28iPT3d7vqtT+fX5vvvv0dUVBTatm1bbmx9Or/3ypXy5apUG3mcK6hLeYMrqK3f1ZpW3j1xfb9PLMv9/rxQL9VuH5PkXqxbt44pFAq2atUqduHCBTZlyhTm4eFh13NqXTBt2jSm0+nY/v377YaVKSgoYIwxFhsby9577z12/PhxFh8fz3799VfWuHFj1rNnT3EdtmFnBg4cyGJiYtj27duZr6+vw2FnXn31VXbx4kW2bNkyh8POVPcxe/nll9n+/ftZfHw8++uvv1j//v2Zj48PS01NZYxZhx9q1KgR27t3Lzt+/Djr0qUL69Kli0vua1EWi4U1atSIvf7663bT68P5zc3NZadOnWKnTp1iANinn37KTp06JY6asGDBAubh4cF+/fVXdubMGfbII484HIrsgQceYEePHmWHDh1iERERdsNtZWVlMX9/fzZmzBh27tw5tm7dOqZWq0sMtyWVStknn3zCLl68yObMmeNwWL/y0lKZ/TUajezhhx9mDRs2ZDExMXbfaVsPzYcPH2afffYZi4mJYXFxcex///sf8/X1ZWPHjnW5/c3NzWWvvPIKO3LkCIuPj2e7d+9m7du3ZxEREUyv14vrqC/n1yY7O5up1Wq2fPnyEsu72vmtSa6SL1dGXcnj6gJXyhtqmiv9rtak8u6JGau/94nlud+eF+4HVMDgopYuXcoaNWrE5HI569ixI/v7779rO0klAHD4t3LlSsYYY9evX2c9e/ZkXl5eTKFQsPDwcPbqq6/ajWvLGGMJCQls8ODBTKVSMR8fH/byyy8zk8lkF7Nv3z7Wrl07JpfLWePGjcVtFFXdx2zkyJEsMDCQyeVy1qBBAzZy5EgWGxsrzi8sLGTPPfcc8/T0ZGq1mj366KMsKSnJJfe1qB07djAA7PLly3bT68P53bdvn8NreNy4cYwx63Bk77zzDvP392cKhYL169evxHFIT09no0aNYhqNhmm1WjZhwgSWm5trF3P69GnWvXt3plAoWIMGDdiCBQtKpOWnn35iTZs2ZXK5nLVq1Ypt3brVbr4zaanM/sbHx5f6nd63bx9jjLETJ06wTp06MZ1Ox5RKJWvRogX76KOP7G4cXWV/CwoK2MCBA5mvry+TyWQsJCSETZ48ucRNRn05vzZff/01U6lULCsrq8TyrnZ+a5or5MuVUZfyuNrmSnlDTXOl39WaVN49MWP19z6xPPfb88L9gGOMsSqpCkEIIYQQQgghhJD7FvXBQAghhBBCCCGEkEqjAgZCCCGEEEIIIYRUGhUwEEIIIYQQQgghpNKogIEQQgghhBBCCCGVRgUMhBBCCCGEEEIIqTQqYCCEEEIIIYQQQkilUQEDIYQQQgghhBBCKo0KGAgh9QbHcdi8eXO1bqN3796YNWtWtW6DEEIIqSnjx4/H8OHDxc+1lc/t378fHMchKyurWrdTE/cKhNzPqICBEFJhR44cgUQiwdChQyu8bGhoKJYsWVL1iSrHsGHDMGjQIIfzDh48CI7jcObMmRpOFSGEEFLS+PHjwXEcOI6DXC5HeHg43nvvPZjN5mrf9s8//4z333/fqdiaKhQwGo3w8fHBggULHM5///334e/vD5PJVK3pIISUjwoYCCEV9v333+P555/HgQMHcOvWrdpOjlMmTZqEXbt24ebNmyXmrVy5Eh06dECbNm1qIWWEEEJISYMGDUJSUhKuXr2Kl19+GXPnzsWiRYscxhqNxirbrpeXF9zd3atsfVVBLpfj6aefxsqVK0vMY4xh1apVGDt2LGQyWS2kjhBSFBUwEEIqJC8vD+vXr8e0adMwdOhQrFq1qkTM77//jgcffBBKpRI+Pj549NFHAVirXV67dg0vvvii+GYGAObOnYt27drZrWPJkiUIDQ0VP//zzz8YMGAAfHx8oNPp0KtXL5w8edLpdD/00EPw9fUtkd68vDxs2LABkyZNQnp6OkaNGoUGDRpArVYjMjISP/74Y5nrdVTV0sPDw247N27cwBNPPAEPDw94eXnhkUceQUJCgjh///796NixI9zc3ODh4YFu3brh2rVrTu8bIYSQ+kehUCAgIAAhISGYNm0a+vfvj99++w3A3WYNH374IYKCgtCsWTMA5ec3FosFL730Ejw8PODt7Y3XXnsNjDG77RZvImEwGPD6668jODgYCoUC4eHh+P7775GQkIA+ffoAADw9PcFxHMaPHw8AEAQB8+fPR1hYGFQqFdq2bYuNGzfabWfbtm1o2rQpVCoV+vTpY5dORyZNmoQrV67g0KFDdtP//PNP/Pvvv5g0aVKF7xUc1cCIiYkBx3F26Tl06BB69OgBlUqF4OBgzJw5E/n5+eL8r776ChEREVAqlfD398djjz1W5r4QUp9RAQMhpEJ++uknNG/eHM2aNcPTTz+NH374we7mZOvWrXj00UcxZMgQnDp1Cnv27EHHjh0BWKtdNmzYEO+99x6SkpKQlJTk9HZzc3Mxbtw4HDp0CH///TciIiIwZMgQ5ObmOrW8VCrF2LFjsWrVKrv0btiwARaLBaNGjYJer0dUVBS2bt2Kc+fOYcqUKRgzZgyOHTvmdDqLM5lMiI6Ohru7Ow4ePIi//voLGo0GgwYNgtFohNlsxvDhw9GrVy+cOXMGR44cwZQpU8TCF0IIIQQAVCqVXU2FPXv24PLly9i1axe2bNlSbn4DAIsXL8aqVavwww8/4NChQ8jIyMAvv/xS5nbHjh2LH3/8EV988QUuXryIr7/+GhqNBsHBwdi0aRMA4PLly0hKSsLnn38OAJg/fz7++9//YsWKFTh//jxefPFFPP300/jzzz8BWAtC/vOf/2DYsGGIiYnBM888gzfeeKPMdERGRuLBBx/EDz/8YDd95cqV6Nq1K5o3b17pewVH4uLiMGjQIIwYMQJnzpzB+vXrcejQIcyYMQMAcPz4ccycORPvvfceLl++jO3bt6Nnz573vD1CXB4jhJAK6Nq1K1uyZAljjDGTycR8fHzYvn37xPldunRho0ePLnX5kJAQ9tlnn9lNmzNnDmvbtq3dtM8++4yFhISUuh6LxcLc3d3Z77//Lk4DwH755ZdSl7l48SIDYJfeHj16sKeffrrUZYYOHcpefvll8XOvXr3YCy+8UOY2dTodW7lyJWOMsf/7v/9jzZo1Y4IgiPMNBgNTqVRsx44dLD09nQFg+/fvLzUNhBBC7i/jxo1jjzzyCGOMMUEQ2K5du5hCoWCvvPKKON/f358ZDAZxmfLyG8YYCwwMZAsXLhTnm0wm1rBhQ3FbjNnnc5cvX2YA2K5duxymc9++fQwAy8zMFKfp9XqmVqvZ4cOH7WInTZrERo0axRhjbPbs2axly5Z2819//fUS6ypuxYoVTKPRsNzcXMYYYzk5OUytVrPvvvvOYXx59wqO0n/q1CkGgMXHx4vpnjJlit16Dx48yHieZ4WFhWzTpk1Mq9WynJycUtNNyP2EajAQQpx2+fJlHDt2DKNGjQJgrRUwcuRIfP/992JMTEwM+vXrV+XbTklJweTJkxEREQGdTgetVou8vDxcv37d6XU0b94cXbt2Fd9+xMbG4uDBg5g0aRIAa9XR999/H5GRkfDy8oJGo8GOHTsqtI3iTp8+jdjYWLi7u0Oj0UCj0cDLywt6vR5xcXHw8vLC+PHjER0djWHDhuHzzz+vUM0OQggh9dOWLVug0WigVCoxePBgjBw5EnPnzhXnR0ZGQi6Xi5/Ly2+ys7ORlJSETp06ictIpVJ06NCh1DTExMRAIpGgV69eTqc7NjYWBQUFGDBggJgOjUaD//73v4iLiwMAXLx40S4dANClS5dy1z1q1ChYLBb89NNPAID169eD53mMHDkSQNXcKxR3+vRprFq1ym5foqOjIQgC4uPjMWDAAISEhKBx48YYM2YM1qxZg4KCgnveHiGuTlrbCSCEuI7vv/8eZrMZQUFB4jTGGBQKBb788kvodDqoVKoKr5fn+RJtQIv3BD1u3Dikp6fj888/R0hICBQKBbp06VLhjq0mTZqE559/HsuWLcPKlSvRpEkT8cZp0aJF+Pzzz7FkyRJERkbCzc0Ns2bNKnMbHMeVmfa8vDxERUVhzZo1JZb19fUFYK3eOXPmTGzfvh3r16/H22+/jV27dqFz584V2jdCCCH1R58+fbB8+XLI5XIEBQVBKrW/bXdzc7P77Ex+U1H3kqfn5eUBsDaZbNCggd08hUJxT+mw0Wq1eOyxx7By5UpMnDgRK1euxBNPPAGNRgOg4vcKPG9911o0Hy9+/5GXl4epU6di5syZJZZv1KgR5HI5Tp48if3792Pnzp149913MXfuXPzzzz/w8PCo1P4S4oqoBgMhxClmsxn//e9/sXjxYsTExIh/p0+fRlBQkNgZYps2bbBnz55S1yOXy2GxWOym+fr6Ijk52S6Dj4mJsYv566+/MHPmTAwZMgStWrWCQqHA7du3K7wfTzzxBHiex9q1a/Hf//4XEydOFPs7+Ouvv/DII4/g6aefRtu2bdG4cWNcuXKlzPX5+vra1Ti4evWq3ZuL9u3b4+rVq/Dz80N4eLjdn06nE+MeeOABzJ49G4cPH0br1q2xdu3aCu8bIYSQ+sPNzQ3h4eFo1KhRicIFR8rLb3Q6HQIDA3H06FFxGbPZjBMnTpS6zsjISAiCIPadUJytBkXRfL1ly5ZQKBS4fv16iXQEBwcDAFq0aFGif6O///673H0ErC8KDh06hC1btuDw4cNiLUSg4vcKtoKXovl48fuP9u3b48KFCyX2JTw8XNx/qVSK/v37Y+HChThz5gwSEhKwd+9ep/aHkPqGChgIIU7ZsmULMjMzMWnSJLRu3drub8SIEWIziTlz5uDHH3/EnDlzcPHiRZw9exYff/yxuJ7Q0FAcOHAAiYmJYqbfu3dvpKWlYeHChYiLi8OyZcvwxx9/2G0/IiIC//d//4eLFy/i6NGjGD169D29WdFoNBg5ciRmz56NpKQkscdr2zZ27dqFw4cP4+LFi5g6dSpSUlLKXF/fvn3x5Zdf4tSpUzh+/DieffZZu2GyRo8eDR8fHzzyyCM4ePAg4uPjsX//fsycORM3b95EfHw8Zs+ejSNHjuDatWvYuXMnrl69ihYtWlR43wghhNy/ystvAOCFF17AggULsHnzZly6dAnPPfec3QgKxYWGhmLcuHGYOHEiNm/eLK7T1kQhJCQEHMdhy5YtSEtLQ15eHtzd3fHKK6/gxRdfxOrVqxEXF4eTJ09i6dKlWL16NQDg2WefxdWrV/Hqq6/i8uXLWLt2rcNRqRzp2bMnwsPDMXbsWLHpo01F7xVshR5z587F1atXsXXrVixevNgu5vXXX8fhw4cxY8YMxMTE4OrVq/j111/FTh63bNmCL774AjExMbh27Rr++9//QhAEcWQPQu43VMBACHHK999/j/79+9u9dbcZMWIEjh8/jjNnzqB3797YsGEDfvvtN7Rr1w59+/a1e0vx3nvvISEhAU2aNBHfHLRo0QJfffUVli1bhrZt2+LYsWN45ZVXSmw/MzMT7du3x5gxYzBz5kz4+fnd075MmjQJmZmZiI6Otmvu8fbbb6N9+/aIjo5G7969ERAQgOHDh5e5rsWLFyM4OBg9evTAU089hVdeeQVqtVqcr1arceDAATRq1Aj/+c9/0KJFC0yaNAl6vR5arRZqtRqXLl3CiBEj0LRpU0yZMgXTp0/H1KlT72nfCCGE3J/Ky28A4OWXX8aYMWMwbtw4dOnSBe7u7uJQ0qVZvnw5HnvsMTz33HNo3rw5Jk+eLA7R2KBBA8ybNw9vvPEG/P39xYfu999/H++88w7mz5+PFi1aYNCgQdi6dSvCwsIAWJsWbNq0CZs3b0bbtm2xYsUKfPTRR07tJ8dxmDhxIjIzMzFx4kS7eRW9V5DJZPjxxx9x6dIltGnTBh9//DE++OADu5g2bdrgzz//xJUrV9CjRw888MADePfdd8X7Bw8PD/z888/o27cvWrRogRUrVuDHH39Eq1atnNofQuobjhVvPEwIIYQQQgghhBBSQVSDgRBCCCGEEEIIIZVGBQyEEEIIIYQQQgipNCpgIIQQQgghhBBCSKVRAQMhhBBCCCGEEEIqjQoYCCGEEEIIIYQQUmlUwEAIIYQQQgghhJBKowIGQgghhBBCCCGEVBoVMBBCCCGEEEIIIaTSqICBEEIIIYQQQgghlUYFDIQQQgghhBBCCKk0KmAghBBCCCGEEEJIpVEBAyGEEEIIIYQQQiqNChgIIYQQQgghhBBSaVTAQAghhBBCCCGEkEqjAgZCCCGEEEIIIYRUGhUwEEIIIYQQQgghpNKogIEQQgghhBBCCCGVRgUMhBBCCCGEEEIIqTQqYCCEEEIIIYQQQkilUQEDIYQQQgghhBBCKo0KGAghhBBCCCGEEFJpVMBACCGEEEIIIYSQSqMCBkIIIYQQQgghhFQaFTAQQgghhBBCCCGk0qiAgRBCCCGEEEIIIZVGBQyEEEIIIYQQQgipNCpgIIQQQgghhBBCSKVRAQMhhBBCCCGEEEIqjQoYCCGEEEIIIYQQUmlUwEAIIYQQQgghhJBKowIGQgghhBBCCCGEVBoVMBBCCCGEEEIIIaTSqICBEEIIIYQQQgghlUYFDIQQQgghhBBCCKk0KmAghBBCCCGEEEJIpVEBAyGEEEIIIYQQQiqNChgIIYQQQgghhBBSaVTAQAghhBBCCCGEkEqjAgZCCCGEEEIIIYRUGhUwEEIIIYQQQgghpNKogIEQQgghhBBCCCGVRgUMhBBCCCGEEEIIqTQqYCBVYvz48QgNDbWbxnEc5s6dWyvpqY/oeBJXkZCQAI7jsGrVqtpOSq0LDQ3F+PHjxc/79+8Hx3HYv39/raWpuOJpJHUT5bPVj44nqQmOvsuO1FReSnmA8yhPdw4VMLi4+Ph4zJgxA02bNoVarYZarUbLli0xffp0nDlzpraTV+3Wrl2LJUuWOB0fGhoKjuPEP6VSiYiICLz66qvIyMiovoQ6adu2bXXu5saWwdn+eJ6Hl5cXBg8ejCNHjtR28u4Lr732GjiOw8iRI+95HRcuXMDcuXORkJBQdQmr41atWlXi+960aVPMmDEDKSkptZ28CqmLvw33C8pnKZ+tbpTP1o65c+faHXeZTIbQ0FDMnDkTWVlZtZ08Ugzl6a5DWtsJIPduy5YtGDlyJKRSKUaPHo22bduC53lcunQJP//8M5YvX474+HiEhITUSvoKCwshlVbvJbZ27VqcO3cOs2bNcnqZdu3a4eWXXwYA6PV6nDhxAkuWLMGff/6JY8eOVVNKnbNt2zYsW7bM4Y9OTRzPsowaNQpDhgyBxWLBlStX8NVXX6FPnz74559/EBkZWWvpqu8YY/jxxx8RGhqK33//Hbm5uXB3d6/wei5cuIB58+ahd+/eTr05qU/ee+89hIWFQa/X49ChQ1i+fDm2bduGc+fOQa1W12haevbsicLCQsjl8gotV9ZvA6k+lM9SPluTKJ+tHcuXL4dGo0F+fj727NmDpUuX4uTJkzh06FC1bO/bb7+FIAjVsu77AeXpdR8VMLiouLg4PPnkkwgJCcGePXsQGBhoN//jjz/GV199BZ4vu5JKfn4+3NzcqiWNSqWyWtZbWQ0aNMDTTz8tfn7mmWeg0WjwySef4OrVq4iIiKjF1JWuto9n+/bt7Y5bjx49MHjwYCxfvhxfffVVjaalOq/b6qDX6yGXy8v9Pjqyf/9+3Lx5E3v37kV0dDR+/vlnjBs3rhpSWX8NHjwYHTp0AGD9vnt7e+PTTz/Fr7/+ilGjRjlcprquMZ7na/27TJxD+ey9o3z23lA+e+8qk88+9thj8PHxAQBMnToVTz75JNavX49jx46hY8eOVZ1UyGSyKl/n/YTy9LqPmki4qIULFyI/Px8rV64scdMDAFKpFDNnzkRwcLA4bfz48dBoNIiLi8OQIUPg7u6O0aNHAwAOHjyIxx9/HI0aNYJCoUBwcDBefPFFFBYWllj35s2b0bp1ayiVSrRu3Rq//PKLwzQ6asuYmJiIiRMnwt/fHwqFAq1atcIPP/xgF2Nrz/TTTz/hww8/RMOGDaFUKtGvXz/ExsaKcb1798bWrVtx7do1sbrUvb6ZDQgIAIASby727t2LHj16wM3NDR4eHnjkkUdw8eLFEsufOnUKgwcPhlarhUajQb9+/fD333/bxZhMJsybNw8RERFQKpXw9vZG9+7dsWvXLgDW87Ns2TLx2Nn+bIofT1vVvtjYWIwfPx4eHh7Q6XSYMGECCgoK7LZdWFiImTNnwsfHB+7u7nj44YeRmJhYqfamPXr0AGC9CS8qKysLs2bNQnBwMBQKBcLDw/Hxxx+XKK1PT0/HmDFjoNVq4eHhgXHjxuH06dMl2huWdd0KgoAlS5agVatWUCqV8Pf3x9SpU5GZmWm3rePHjyM6Oho+Pj5QqVQICwvDxIkT7WLWrVuHqKgouLu7Q6vVIjIyEp9//rldzL///ovHH38cXl5eUKvV6Ny5M7Zu3WoXY7t+161bh7fffhsNGjSAWq1GTk4OTCYTLl26hKSkJKeP85o1a9CyZUv06dMH/fv3x5o1axzGJSYmYtKkSQgKCoJCoUBYWBimTZsGo9GIVatW4fHHHwcA9OnTR7y2bG0GS7sOirfjy8jIwCuvvILIyEhoNBpotVoMHjwYp0+fdnp/bI4fPw6O47B69eoS83bs2AGO47BlyxYAQG5uLmbNmoXQ0FAoFAr4+flhwIABOHnyZIW3CwB9+/YFYK36DlTNNcYYwwcffICGDRtCrVajT58+OH/+fIltl9Ze8+jRoxgyZAg8PT3h5uaGNm3aiNdfeb8NVZ1GYkX5LOWzlM/eH/lscaUd96NHj2LQoEHQ6XRQq9Xo1asX/vrrL7sYZ/IrR30wZGVlYfz48dDpdOK5ctRMo3fv3ujdu3eJ6Y7W+cknn6Br167w9vaGSqVCVFQUNm7cWO7+l/c9coTy9P120+/3PJ1qMLioLVu2IDw8HJ06darQcmazGdHR0ejevTs++eQTsSrRhg0bUFBQgGnTpsHb2xvHjh3D0qVLcfPmTWzYsEFcfufOnRgxYgRatmyJ+fPnIz09HRMmTEDDhg3L3XZKSgo6d+4MjuMwY8YM+Pr64o8//sCkSZOQk5NTovrlggULwPM8XnnlFWRnZ2PhwoUYPXo0jh49CgB46623kJ2djZs3b+Kzzz4DAGg0mnLTYTKZcPv2bQDWEu9Tp07h008/Rc+ePREWFibG7d69G4MHD0bjxo0xd+5cFBYWYunSpejWrRtOnjwp/pCfP38ePXr0gFarxWuvvQaZTIavv/4avXv3xp9//imeo7lz52L+/Pl45pln0LFjR+Tk5OD48eM4efIkBgwYgKlTp+LWrVvYtWsX/u///q/c/bB54oknEBYWhvnz5+PkyZP47rvv4Ofnh48//liMGT9+PH766SeMGTMGnTt3xp9//omhQ4c6vQ1HbG35PT09xWkFBQXo1asXEhMTMXXqVDRq1AiHDx/G7NmzkZSUJLbjFQQBw4YNw7FjxzBt2jQ0b94cv/76a6lv5ku7bqdOnYpVq1ZhwoQJmDlzJuLj4/Hll1/i1KlT+OuvvyCTyZCamoqBAwfC19cXb7zxBjw8PJCQkICff/5ZXP+uXbswatQo9OvXTzxuFy9exF9//YUXXngBgPX67dq1KwoKCjBz5kx4e3tj9erVePjhh7Fx40Y8+uijdml+//33IZfL8corr8BgMEAulyMxMREtWrTAuHHjnOq0yWAwYNOmTWJV41GjRmHChAlITk4Wb9YB4NatW+jYsSOysrIwZcoUNG/eHImJidi4cSMKCgrQs2dPzJw5E1988QXefPNNtGjRAgDEf53177//YvPmzXj88ccRFhaGlJQUfP311+jVqxcuXLiAoKAgp9fVoUMHNG7cGD/99FOJ875+/Xp4enoiOjoaAPDss89i48aNmDFjBlq2bIn09HQcOnQIFy9eRPv27Su0D8Ddm0Zvb29xWmWuMQB499138cEHH2DIkCEYMmQITp48iYEDB8JoNJabnl27duGhhx5CYGAgXnjhBQQEBODixYvYsmULXnjhhXJ/G2oijfcjymcpn7WhfLb+5rPOHve9e/di8ODBiIqKwpw5c8DzPFauXIm+ffvi4MGDYk2He8mvGGN45JFHcOjQITz77LNo0aIFfvnll0rXVvz888/x8MMPY/To0TAajVi3bh0ef/xxbNmypcxrs7zvkSOUp99FeToARlxOdnY2A8CGDx9eYl5mZiZLS0sT/woKCsR548aNYwDYG2+8UWK5onE28+fPZxzHsWvXronT2rVrxwIDA1lWVpY4befOnQwACwkJsVseAJszZ474edKkSSwwMJDdvn3bLu7JJ59kOp1OTMO+ffsYANaiRQtmMBjEuM8//5wBYGfPnhWnDR06tMR2yxISEsIAlPjr1q1biXS1a9eO+fn5sfT0dHHa6dOnGc/zbOzYseK04cOHM7lczuLi4sRpt27dYu7u7qxnz57itLZt27KhQ4eWmb7p06ez0r6WxY/nnDlzGAA2ceJEu7hHH32UeXt7i59PnDjBALBZs2bZxY0fP77EOh2Jj49nANi8efNYWloaS05OZgcPHmQPPvggA8A2bNggxr7//vvMzc2NXblyxW4db7zxBpNIJOz69euMMcY2bdrEALAlS5aIMRaLhfXt25cBYCtXrhSnl3bdHjx4kAFga9assZu+fft2u+m//PILA8D++eefUvfxhRdeYFqtlpnN5lJjZs2axQCwgwcPitNyc3NZWFgYCw0NZRaLhTF29/pt3Lhxie+V7ViOGzeu1O0UtXHjRgaAXb16lTHGWE5ODlMqleyzzz6zixs7dizjed7hPgqCwBhjbMOGDQwA27dvX4mY0q6DkJAQu7Tq9XpxP4vuk0KhYO+9916J/Sx6Hh2ZPXs2k8lkLCMjQ5xmMBiYh4eH3XWt0+nY9OnTy1yXIytXrmQA2O7du1laWhq7ceMGW7duHfP29mYqlYrdvHmTMVb5ayw1NZXJ5XI2dOhQ8Xgzxtibb75Z4nzbrg/beTCbzSwsLIyFhISwzMxMu+0UXVdpvw3VkUZC+Szls1aUz9bvfNZ2fi9fvszS0tJYQkIC++GHH5hKpWK+vr4sPz+fMWb9LY6IiGDR0dF2v58FBQUsLCyMDRgwQJzmTH41btw4u+/U5s2bGQC2cOFCcZrZbGY9evQoca569erFevXqVe46bekrymg0statW7O+ffvaTS+e1zvzPXKE8nTK022oiYQLysnJAeD4LULv3r3h6+sr/tmq4BQ1bdq0EtNUKpX4//z8fNy+fRtdu3YFYwynTp0CACQlJSEmJgbjxo2DTqcT4wcMGICWLVuWmWbGGDZt2oRhw4aBMYbbt2+Lf9HR0cjOzi5RNWrChAl2nabYqqz9+++/ZW6rPJ06dcKuXbuwa9cubNmyBR9++CHOnz+Phx9+WKyqatvX8ePHw8vLS1y2TZs2GDBgALZt2wYAsFgs2LlzJ4YPH47GjRuLcYGBgXjqqadw6NAh8Xx5eHjg/PnzuHr1aqXSX9yzzz5r97lHjx5IT08Xt7t9+3YAwHPPPWcX9/zzz1doO3PmzIGvry8CAgLQo0cPXLx4EYsXL8Zjjz0mxmzYsAE9evSAp6en3Tnu378/LBYLDhw4IKZJJpNh8uTJ4rI8z2P69Omlbr/4dbthwwbodDoMGDDAbltRUVHQaDTYt28fAOtxB6xvI00mk8N1e3h4ID8/v8zqf9u2bUPHjh3RvXt3cZpGo8GUKVOQkJCACxcu2MWPGzfO7nsFWJscMMacfquyZs0adOjQAeHh4QAAd3d3DB061K6ZhCAI2Lx5M4YNGya2SSyqaLW7ylIoFGL7VovFgvT0dGg0GjRr1uyeqjaOHDkSJpPJ7i3Xzp07kZWVZTdihoeHB44ePYpbt27dU7r79+8PX19fBAcH48knn4RGo8Evv/yCBg0a2MXd6zW2e/duGI1GPP/883bH25lO8U6dOoX4+HjMmjVLvFZtnDl3NZHG+xHls5TPFkX5bP3NZwGgWbNm8PX1RWhoKCZOnIjw8HD88ccf4lvvmJgYXL16FU899RTS09PF45Cfn49+/frhwIEDYvOUe8mvtm3bBqlUanf8JRJJha+f4ooem8zMTGRnZ6NHjx7l5tf3+j2iPJ3ydBtqIuGCbD3I5+XllZj39ddfIzc3FykpKXYdBdlIpVKH1SyvX7+Od999F7/99luJNj7Z2dkAgGvXrgGAw86ZynvASEtLQ1ZWFr755ht88803DmNSU1PtPjdq1Mjus62qWvH0VZSPjw/69+8vfh46dCiaNWuGxx57DN999x2ef/55cV+bNWtWYvkWLVpgx44dyM/PR25uLgoKCkqNEwQBN27cQKtWrfDee+/hkUceQdOmTdG6dWsMGjQIY8aMQZs2bSq1P2UdJ61Wi2vXroHnebtqqQDEh1ZnTZkyBY8//jj0ej327t2LL774AhaLxS7m6tWrOHPmDHx9fR2uw3aOr127hsDAwBK9/ZaWJkfX7dWrV5GdnQ0/P78yt9WrVy+MGDEC8+bNw2effYbevXtj+PDheOqpp6BQKABYbwp/+uknDB48GA0aNMDAgQPxxBNPYNCgQeL6rl275rCqtK2ZwbVr19C6dWtxevHjXVFZWVnYtm0bZsyYYdcmulu3bti0aROuXLmCpk2bIi0tDTk5OXbbri6CIODzzz/HV199hfj4eLvzX7RqorPatm2L5s2bY/369Zg0aRIAa1VKHx8fsU0lYG0LP27cOAQHByMqKgpDhgzB2LFj7R42yrJs2TI0bdoUUqkU/v7+aNasWYmOwCpzjZX22+jr62tXxdYRW9XOez1/NZHG+xHls5TPFkX5bP3MZ202bdoErVaLtLQ0fPHFF4iPj7d7OLc9aJfVZCE7Oxuenp73lF/ZzlXxAk1H13xFbNmyBR988AFiYmJgMBjE6eU96N7r94hHUYeJAADkv0lEQVTydMrTbaiAwQXpdDoEBgbi3LlzJebZfphLG+u+6BtIG4vFggEDBiAjIwOvv/46mjdvDjc3NyQmJmL8+PFVMpSObR1PP/10qT/QxX+4JBKJwzjGWKXTU1y/fv0AAAcOHKh0iXFpevbsibi4OPz666/YuXMnvvvuO3z22WdYsWIFnnnmmXteb00dp4iICPGG8aGHHoJEIsEbb7yBPn36iG/OBUHAgAED8NprrzlcR9OmTe9p246uW0EQ4OfnV2qnh7abL47jsHHjRvz999/4/fffsWPHDkycOBGLFy/G33//DY1GAz8/P8TExGDHjh34448/8Mcff2DlypUYO3asww6LnFH8rUpFbdiwAQaDAYsXL8bixYtLzF+zZg3mzZtXqW2Up/iN7UcffYR33nkHEydOxPvvvw8vLy/wPI9Zs2bd8+/EyJEj8eGHH+L27dtwd3fHb7/9hlGjRtl1BPfEE0+gR48e+OWXX7Bz504sWrQIH3/8MX7++WcMHjy43G107NjRYe2OoipzjdUmV0ijK6J8lvLZoiifrZ/5rE3Pnj3FUSSGDRuGyMhIjB49GidOnADP8+J3a9GiRWjXrp3DddgKByqbX5WH4ziH113x/PrgwYN4+OGH0bNnT3z11VcIDAyETCbDypUrsXbt2jK3UZnvEeXpleMKaXQGFTC4qKFDh+K7776rkiF0zp49iytXrmD16tUYO3asOL14NTbbON+Oqkxdvny5zG34+vrC3d0dFovF7q1GZVVV9W+z2Qzg7tsq27462q9Lly7Bx8cHbm5uUCqVUKvVpcbxPG/Xw7iXlxcmTJiACRMmIC8vDz179sTcuXPFH+yqrM5uExISAkEQEB8fb1fSWfSt+L1466238O233+Ltt98Wq4c2adIEeXl55Z7jkJAQ7Nu3DwUFBXZvVyqSpiZNmmD37t3o1q2bUzcZnTt3RufOnfHhhx9i7dq1GD16NNatWycee7lcjmHDhmHYsGEQBAHPPfccvv76a7zzzjsIDw9HSEhIqefZtk9Vac2aNWjdujXmzJlTYt7XX3+NtWvXYt68efD19YVWq3X4IFRUWdeWp6dnid6qjUZjiV64N27ciD59+uD777+3m56VlSXenFXUyJEjMW/ePGzatAn+/v7IycnBk08+WSIuMDAQzz33HJ577jmkpqaiffv2+PDDD6vkhq00zl5jRX8bi76BSUtLK/dNcJMmTQAA586dK/N7U9r5q4k03q8on7WifLZ8lM9auVo+64hGo8GcOXMwYcIE/PTTT3jyySfF32mtVuvUd6ui+ZVtKNy8vDy7WgyOjoWnp6fDJky2N9o2mzZtglKpxI4dO8RaJACwcuXKctMPlP89Kg3l6ZSnAzRMpct67bXXoFarMXHiRKSkpJSYX5FSdVvJfNFlGGMlhg4KDAxEu3btsHr1arE6J2C9QSreLs7RNkaMGIFNmzY5fBBKS0tzOr1Fubm52aXlXv3+++8ArNW7APt9Lfrgde7cOezcuRNDhgwBYN2vgQMH4tdff7V7m5WSkoK1a9eie/fu0Gq1AKzDRRWl0WgQHh5uV23NNkavo6GJ7pWt197iY2gvXbq0Uuv18PDA1KlTsWPHDsTExACwlkofOXIEO3bsKBGflZUl3mBGR0fDZDLh22+/FecLguCwLXNpnnjiCVgsFrz//vsl5pnNZvEYZmZmlvg+2N5A2I598XPD87z4ps8WM2TIEBw7dgxHjhwR4/Lz8/HNN98gNDS03PbRAJwePuvGjRs4cOAAnnjiCTz22GMl/iZMmIDY2FgcPXoUPM9j+PDh+P3333H8+PES67Lte1nXVpMmTcR2uzbffPNNiTciEomkxLHcsGEDEhMTy9330rRo0QKRkZFYv3491q9fj8DAQPTs2VOcb7FYSnzH/fz8EBQUZPfdqQ7OXmP9+/eHTCbD0qVL7Y6PrTf3srRv3x5hYWFYsmRJiXNTdF2lnb+aSOP9ivJZK8pny0f5rOvls2UZPXo0GjZsKI52ERUVhSZNmuCTTz5x2GzK9t261/xqyJAhMJvNWL58uTjNYrE4vH6aNGmCS5cu2X2fT58+XWK4TIlEAo7j7PLxhIQEbN68uYw9t3Lme1QaytMpTweoBoPLioiIwNq1azFq1Cg0a9YMo0ePRtu2bcEYQ3x8PNauXQue550a1qp58+Zo0qQJXnnlFSQmJkKr1WLTpk0OS8Dmz5+PoUOHonv37pg4cSIyMjKwdOlStGrVyuGPblELFizAvn370KlTJ0yePBktW7ZERkYGTp48id27dyMjI6PCxyEqKgrr16/HSy+9hAcffBAajQbDhg0rc5nExET873//A2B9S3v69Gl8/fXX8PHxsau2uWjRIgwePBhdunTBpEmTxOGzdDqd3ZjWH3zwAXbt2oXu3bvjueeeg1Qqxddffw2DwYCFCxeKcS1btkTv3r0RFRUFLy8vHD9+XBymp+j+AMDMmTMRHR0NiUTisOS3osdoxIgRWLJkCdLT08Xhs65cuQKgcm9zXnjhBSxZsgQLFizAunXr8Oqrr+K3337DQw89hPHjxyMqKgr5+fk4e/YsNm7ciISEBPj4+GD48OHo2LEjXn75ZcTGxqJ58+b47bffxGvAmTT16tULU6dOxfz58xETE4OBAwdCJpPh6tWr2LBhAz7//HM89thjWL16Nb766is8+uijaNKkCXJzc/Htt99Cq9WKN7DPPPMMMjIy0LdvXzRs2BDXrl3D0qVL0a5dO7Ht5xtvvIEff/wRgwcPxsyZM+Hl5YXVq1cjPj4emzZtKlEVzxFnh89au3YtGGN4+OGHHc4fMmQIpFIp1qxZg06dOuGjjz7Czp070atXL0yZMgUtWrRAUlISNmzYgEOHDsHDwwPt2rWDRCLBxx9/jOzsbCgUCvTt2xd+fn545pln8Oyzz2LEiBEYMGAATp8+jR07dpSolfDQQw/hvffew4QJE9C1a1ecPXsWa9ascbrdZGlGjhyJd999F0qlEpMmTbI7lrm5uWjYsCEee+wxtG3bFhqNBrt378Y///zjsOlIVXL2GvP19cUrr7yC+fPn46GHHsKQIUNw6tQp/PHHH+XW7OB5HsuXL8ewYcPQrl07TJgwAYGBgbh06RLOnz8vPkSU9ttQE2m8X1E+a0X5rHPHiPJZ18pnyyKTyfDCCy/g1Vdfxfbt2zFo0CB89913GDx4MFq1aoUJEyagQYMGSExMxL59+6DVavH777/fc341bNgwdOvWDW+88QYSEhLQsmVL/Pzzzw4L9iZOnIhPP/0U0dHRmDRpElJTU7FixQq0atVK7HQUsNbA+vTTTzFo0CA89dRTSE1NxbJlyxAeHo4zZ86Uuf/OfI/KQnk65ek0TKWLi42NZdOmTWPh4eFMqVQylUrFmjdvzp599lkWExNjFztu3Djm5ubmcD0XLlxg/fv3ZxqNhvn4+LDJkyez06dPOxxqbtOmTaxFixZMoVCwli1bsp9//tnh8DhwMDRTSkoKmz59OgsODmYymYwFBASwfv36sW+++UaMsQ35UnRYJsYcD32Xl5fHnnrqKebh4eFwCK/iig+fxfM88/PzY6NGjWKxsbEl4nfv3s26devGVCoV02q1bNiwYezChQsl4k6ePMmio6OZRqNharWa9enThx0+fNgu5oMPPmAdO3ZkHh4e4nn68MMPmdFoFGPMZjN7/vnnma+vL+M4zm4Im+LH0za8Ulpamt12bMP4xMfHi9Py8/PZ9OnTmZeXF9NoNGz48OHs8uXLDABbsGBBmcfMdtwXLVrkcP748eOZRCIRj19ubi6bPXs2Cw8PZ3K5nPn4+LCuXbuyTz75xG5f09LS2FNPPcXc3d2ZTqdj48ePZ3/99RcDwNatWyfGlXXdMsbYN998w6KiophKpWLu7u4sMjKSvfbaa+zWrVuMMeu5GTVqFGvUqBFTKBTMz8+PPfTQQ+z48ePiOjZu3MgGDhzI/Pz8mFwuZ40aNWJTp05lSUlJdtuKi4tjjz32GPPw8GBKpZJ17NiRbdmyxS6mtOu36LEsb/igyMhI1qhRozJjevfuzfz8/JjJZGKMMXbt2jU2duxY5uvryxQKBWvcuDGbPn263RB03377LWvcuDGTSCR2wypZLBb2+uuvMx8fH6ZWq1l0dDSLjY11OEzlyy+/zAIDA5lKpWLdunVjR44cKTFslrPDVNpcvXpV/E4eOnTIbp7BYGCvvvoqa9u2LXN3d2dubm6sbdu27Kuvvip3vbbvQllDpzFW+WuMMesxnDdvnnhsevfuzc6dO1fiGBYf0srm0KFDbMCAAeI+tmnThi1dulScX9ZvQ1WnkdijfJbyWcpn618+y1jp55cx61C1Op3OLm87deoU+89//sO8vb2ZQqFgISEh7IknnmB79uxhjDmfXzn6Lqenp7MxY8YwrVbLdDodGzNmDDt16pTD34f//e9/rHHjxkwul7N27dqxHTt2OFzn999/zyIiIphCoWDNmzdnK1euFPe5qOJ5gDPfo7JQnk55OsdYNfTkQwip82JiYvDAAw/gf//7H0aPHl3byQEAbN68GY8++igOHTqEbt261XZyCCGEkHtG+Swh5H5EfTAQch+wjTte1JIlS8DzvF3buJpUPE229oZarRbt27evlTQRQggh94LyWUIIsaI+GAi5DyxcuBAnTpxAnz59IJVKxSGipkyZYtf7dk16/vnnUVhYiC5dusBgMODnn3/G4cOH8dFHH1XZ0FOEEEJITaB8lhBCrKiJBCH3gV27dmHevHm4cOEC8vLy0KhRI4wZMwZvvfWW3djENWnt2rVYvHgxYmNjodfrER4ejmnTpjndiRAhhBBSV1A+SwghVlTAQAghhBBCCCGEkEqr1T4YDhw4gGHDhiEoKAgcx5UYm5XjOId/ixYtEmNCQ0NLzF+wYIHdes6cOYMePXpAqVQiODjYbkgjmw0bNqB58+ZQKpWIjIzEtm3b7OYzxvDuu+8iMDAQKpUK/fv3x9WrV6vuYBBCCCGEEEIIIS6sVgsY8vPz0bZtWyxbtszh/KSkJLu/H374ARzHYcSIEXZx7733nl1c0TGWc3JyMHDgQISEhODEiRNYtGgR5s6di2+++UaMOXz4MEaNGoVJkybh1KlTGD58OIYPH45z586JMQsXLsQXX3yBFStW4OjRo3Bzc0N0dDT0en0VHxVCCCGEEEIIIcT11JkmEhzH4ZdffsHw4cNLjRk+fDhyc3OxZ88ecVpoaChmzZqFWbNmOVxm+fLleOutt5CcnAy5XA4AeOONN7B582ZcunQJADBy5Ejk5+djy5Yt4nKdO3dGu3btsGLFCjDGEBQUhJdffhmvvPIKACA7Oxv+/v5YtWoVnnzySaf2URAE3Lp1C+7u7uA4zqllCCGEEFfCGENubi6CgoLA83V/sCrKmwkhhNR3NZo3szoCAPvll19KnZ+cnMykUilbs2aN3fSQkBDm7+/PvLy8WLt27djChQuZyWQS548ZM4Y98sgjdsvs3buXAWAZGRmMMcaCg4PZZ599Zhfz7rvvsjZt2jDGGIuLi2MA2KlTp+xievbsyWbOnFlqmvV6PcvOzhb/Lly4wADQH/3RH/3RH/3V+78bN26Umj/WJTdu3Kj1Y0V/9Ed/9Ed/9FcTfzWRN7vMMJWrV6+Gu7s7/vOf/9hNnzlzJtq3bw8vLy8cPnwYs2fPRlJSEj799FMAQHJyMsLCwuyW8ff3F+d5enoiOTlZnFY0Jjk5WYwrupyjGEfmz5+PefPmlZh+48YNaLVaZ3abEEIIcSk5OTkIDg6Gu7t7bSfFKbZ0Ut5MCCGkvqrJvNllChh++OEHjB49Gkql0m76Sy+9JP6/TZs2kMvlmDp1KubPnw+FQlHTybQze/Zsu/TZTqxWq6WbGEIIIfWaqzQ3sKWT8mZCCCH1XU3kzXW/cSSAgwcP4vLly3jmmWfKje3UqRPMZjMSEhIAAAEBAUhJSbGLsX0OCAgoM6bo/KLLOYpxRKFQiDcsdONCCCGEEEIIIaQ+c4kChu+//x5RUVFo27ZtubExMTHgeR5+fn4AgC5duuDAgQMwmUxizK5du9CsWTN4enqKMUU7jrTFdOnSBQAQFhaGgIAAu5icnBwcPXpUjCGEEEIIIYQQQu5ntdpEIi8vD7GxseLn+Ph4xMTEwMvLC40aNQJgfZDfsGEDFi9eXGL5I0eO4OjRo+jTpw/c3d1x5MgRvPjii3j66afFwoOnnnoK8+bNw6RJk/D666/j3Llz+Pzzz/HZZ5+J63nhhRfQq1cvLF68GEOHDsW6detw/PhxcShLjuMwa9YsfPDBB4iIiEBYWBjeeecdBAUFlTnqBSGEEEIIIYQQcr+o1QKG48ePo0+fPuJnW38F48aNw6pVqwAA69atA2MMo0aNKrG8QqHAunXrMHfuXBgMBoSFheHFF1+06/dAp9Nh586dmD59OqKiouDj44N3330XU6ZMEWO6du2KtWvX4u2338abb76JiIgIbN68Ga1btxZjXnvtNeTn52PKlCnIyspC9+7dsX379hJ9QhBCCCGEEEIIIfcjjjHGajsR94ucnBzodDpkZ2dTfwyEEELqJVfL61wtvaRuEwSGxKxC5BvNcJNL0cBDBZ53jQ5PCSH1V03mdS4zigQhhBBCCCF1VWxqLnacS0FcWh70ZguUUgma+GoQ3dof4X6uMWwrIYRUFhUwEEIIIYQQUgmxqblY+VcCMvKNCNQpoZarUGA049ytbNzKLsSEbqFUyEAIuS+4xCgShBBCCKkGqalAenptp4IQlyYIDDvOpSAj34gIPw3clTJIeA7uShki/DTIyDdi5/kUCAK1SiaE1H9UwEAIIYTcb8xmYOlSoGlT4LXXajs1hLi0xKxCxKXlIVCnBMfZ97fAcRwCdUrEpv4/e/cdH0WdPnD8szWbuqGlYegdIqhojCjqEYnKecfZQaVjOUABRcCCWFE4RDjBnOcJ3J0VCz8FRRBFTomA9IBBQDCUFCBlk022zvz+GLJkTYAEkmzK83699m5n5rszz25kZ+eZ7/f5FnO0oDRAEQohRN2RBIMQQgjRlPzvf3DZZfDww1BYCDt2gMMR6KiEaLDsLg8Oj5cQc+Ujj4PNBpweL3aXp44jE0KIuicJBiGEEKIpWbMGdu6EZs3gjTdg40aQKZeFOG+hZiMWo4GSMyQQSl1egowGQs+QgBBCiMZEvumEEEKIxszlgpwciI/XlqdNA6cTpkyBli0DG5sQjUDryGA6tgoj/VghYUFGv2ESqqqSVeggobWV1pHBAYxSCCHqhvRgEEIIIRqrr7+G3r3hL38Br1dbFxICr7wiyQUhaoheryOlVzTNQ83syy2myOHGoygUOdzsyy2meaiZgT2j0et1596ZEEI0cJJgEEIIIRqbzEy4/Xa44QbIyNCW9+8PdFRCNFqdosIZ2a8dveKsFJS4OXTCTkGJm4TWVpmiUgjRpMgQCSGEEKKxcDhg7lx48UUoLQW9HsaNg+eeg8jIQEcnRKPWKSqcDteFcbSgFLvLQ6jZSOvIYOm5IIRoUqQHgxBCCNEYHD4MvXrBU09pyYVrroFt22DBgmolF9avX88tt9xCXFwcOp2O5cuX+20fMWIEOp3O73HjjTdW2M+YMWOIiIggMjKS0aNHU1xc7Ld9586dXHPNNVgsFuLj45k9e3aFfSxbtoxu3bphsVhISEjgiy++8NuuqiozZswgNjaW4OBgkpOT2bdvX5XfqxA1Ta/XEd88hG4xEcQ3D5HkghCiyZEEgxBCCNEYtG6t1VWIjYV33oHvvoOLL672bux2O71792bhwoVnbHPjjTeSlZXle7z33nsV2mRkZLBmzRpWrFjB+vXruf/++33bbDYbAwcOpG3btmzZsoU5c+Ywc+ZM3nzzTV+bDRs2MGTIEEaPHs22bdsYPHgwgwcPJj093ddm9uzZLFiwgNTUVDZu3EhoaCgpKSk4ZNpNIYQQIiB0qqqqgQ6iqbDZbFitVgoLC4mIiAh0OEIIIRqykhKYPx8mTICwMG3dwYNakiG8ZsZ763Q6Pv30UwYPHuxbN2LECAoKCir0bCizefNmrrjiCr799luuu+46AFatWsXNN9/MkSNHiIuL44033uDJJ58kOzsbs9kMwLRp01i+fDkZGRkA3HXXXdjtdlasWOHb95VXXkmfPn1ITU1FVVXi4uJ49NFHeeyxxwAoLCwkOjqaJUuWcPfdd1fpPcq5WQghRGNXl+c66cEghBBCNCSqCp98At27wxNPaPUWyrRvX2PJhbNZt24dUVFRdO3alYceeoiTJ0/6tm3atAmASy+91LcuOTkZvV7Pxo0bAUhLS6N///6+5AJASkoKe/fuJT8/39cmOTnZ77gpKSmkpaUBcPDgQbKzs/3aWK1WEhMTfW0q43Q6sdlsfg8hhBBC1AxJMAghhBANRUYGpKTAbbdpM0PEx8MVV9RpCDfeeCP//ve/Wbt2La+88grfffcdN910E95T02Dm5ORUeI3RaKR58+ZkZ2cDkJ2dTXR0tF+bsuVztSm/vfzrKmtTmVmzZmG1Wn2P+Pj4Kr93IYQQQpydzCIhhBBC1HdFRfD88zBvHng8YDbD44/D9OkQElKnoZQfepCQkMDFF19Mx44dWbduHQMGDKjTWM7H9OnTmTx5sm/ZZrNJkkEIIYSoIdKDQQghhKjvpkyBOXO05MIf/wi7d2sJhzpOLlSmQ4cOtGzZkv379wMVexQAeDwe8vLyiImJASAmJqZCT4ey5XO1Kb+9/Osqa1OZoKAgIiIi/B5CCCGEqBmSYBBCCCHqo/I1mJ98UpsR4vPPtUenToGL63eOHDnCyZMniY2NBeCKU0M2tm3b5mvzzTffoCgKiYmJACQlJbF+/XrcbrevzZo1a+jatSvNmjXztVm7dq3fsdasWUNSUhIA7du3JyYmxq+NzWZj48aNvjZCCCGEqFuSYBBCCCHqk4ICeOQRGDbs9Lr4eNi+Xeu9UMuKi4vZvn0727dvB7Riitu3byczM5Pi4mKmTJnCjz/+yKFDh1i7di1//vOf6dSpEykpKQB07doVgIcffphNmzbxww8/MH78eO6++27i4uIAGDp0KGazmdGjR7N7924++OAD5s+f7zd04ZFHHmHVqlXMnTuXjIwMZs6cyU8//cT48eMBbYaLiRMn8sILL/DZZ5+xa9cuhg0bRlxcnN+sF0IIIYSoO1KDQQghhKgPFAWWLoWpU+H4cW3d449DQoL2XKerkzB++uknrr/+et9y2UX/8OHDeeONN9i5cydLly6loKCAuLg4Bg4cyPPPP09QUJDffrp06cKAAQPQ6/XcdtttLFiwwLfNarWyevVqxo0bx2WXXUbLli2ZMWMG999/v6/NVVddxbvvvstTTz3FE088QefOnVm+fDm9evXytXn88cex2+3cf//9FBQUcPXVV7Nq1SosFkttfTxCCCGEOAudqpbvgylqk8y1LYQQolI//QTjx8OpaRzp1g0WLIAbbghsXOehoZ3rGlq8QgghRHXV5blOhkgIIYQQgVJYCA88oE01uXEjhIVpxRx37GiQyQUhhBBCNG0yREIIIYQIFIMBVqzQCjrecw/Mng2n6hQIIYQQQjQ0kmAQQggh6tK2bdC7N+j1Wo+Ff/1Lm26yf/9ARyaEEEIIcUFkiIQQQghRF7KzYcQIuPRS+Pe/T6+/8UZJLgghaoWiqBzOKyEj28bhvBIURUqvCSFqV0ATDOvXr+eWW24hLi4OnU7H8uXL/baPGDECnU7n97jxxhv92uTl5XHPPfcQERFBZGQko0ePpri42K/Nzp07ueaaa7BYLMTHxzN79uwKsSxbtoxu3bphsVhISEjgiy++8NuuqiozZswgNjaW4OBgkpOT2bdvX818EEIIIRovtxteew26dtVmiQDYsyegIQkhGr/9uUW8se4A89b8woK1+5i35hfeWHeA/blFgQ5NCNGIBTTBYLfb6d27NwsXLjxjmxtvvJGsrCzf47333vPbfs8997B7927WrFnDihUrWL9+vd80VzabjYEDB9K2bVu2bNnCnDlzmDlzJm+++aavzYYNGxgyZAijR49m27ZtDB48mMGDB5Oenu5rM3v2bBYsWEBqaiobN24kNDSUlJQUHA5HDX4iQgghGpV167QeC5Mmgc0Gl10GP/6o1VoQQohasj+3iMU/HCL9WCGRISY6tAwjMsRE+rFCFv9wSJIMQohaU2+mqdTpdHz66acMHjzYt27EiBEUFBRU6NlQ5ueff6ZHjx5s3ryZvn37ArBq1Spuvvlmjhw5QlxcHG+88QZPPvkk2dnZmM1mAKZNm8by5cvJyMgA4K677sJut7NixQrfvq+88kr69OlDamoqqqoSFxfHo48+ymOPPQZAYWEh0dHRLFmyhLvvvrvS+JxOJ06n07dss9mIj4+XqbCEEKIpmDkTnn1We96iBcyaBaNGaYUdG7GGNu1jQ4tXiHNRFJU31h0g/VghnaPC0Ol0vm2qqrIvt5iE1lYevLYjer3uLHsSQjQWMk1lOevWrSMqKoquXbvy0EMPcfLkSd+2tLQ0IiMjfckFgOTkZPR6PRtPzSWelpZG//79fckFgJSUFPbu3Ut+fr6vTXJyst9xU1JSSEtLA+DgwYNkZ2f7tbFarSQmJvraVGbWrFlYrVbfIz4+/gI+CSGEEA1KSoqWTPjrX+GXX2Ds2EafXBBCBN7RglIOHC8m1mrxSy6AdkMv1mphf24xRwtKAxShEKIxq9cJhhtvvJF///vfrF27lldeeYXvvvuOm266Ca/XC0B2djZRUVF+rzEajTRv3pzs7Gxfm+joaL82ZcvnalN+e/nXVdamMtOnT6ewsND3OHz4cLXevxBCiAbkq68gNfX0clIS/PorLFwIzZsHLi4hRJNid3lweLyEmCufLC7YbMDp8WJ3eeo4MiFEU1Cvp6ksP/QgISGBiy++mI4dO7Ju3ToGDBgQwMiqJigoiKCgoECHIYQQojYdOqTVWFi+HIKCYOBA6NBB29amTSAjE0I0QaFmIxajgRKXh3CLqcL2UpeXIKOB0DMkIIQQ4kLU6x4Mv9ehQwdatmzJ/v37AYiJiSE3N9evjcfjIS8vj5iYGF+bnJwcvzZly+dqU357+ddV1kYIIUQTU1oKzz0H3btryYWy4RAtWgQ6MiFEE9Y6MpiOrcLIKnTw+1JrqqqSVeigU1QYrSODAxShEKIxa1AJhiNHjnDy5EliY2MBSEpKoqCggC1btvjafPPNNyiKQmJioq/N+vXrcbvdvjZr1qyha9euNGvWzNdm7dq1fsdas2YNSUlJALRv356YmBi/NjabjY0bN/raCCGEaCJUFT77DHr2hGeeAYcDrr8eduyAV18FqzXQEQohmjC9XkdKr2iah5rZl1tMkcONR1EocrjZl1tM81AzA3tGS4FHIUStCGiCobi4mO3bt7N9+3ZAK6a4fft2MjMzKS4uZsqUKfz4448cOnSItWvX8uc//5lOnTqRkpICQPfu3bnxxhsZO3YsmzZt4ocffmD8+PHcfffdxMXFATB06FDMZjOjR49m9+7dfPDBB8yfP5/Jkyf74njkkUdYtWoVc+fOJSMjg5kzZ/LTTz8xfvx4QCuIM3HiRF544QU+++wzdu3axbBhw4iLi/Ob9UIIIUQTkJMDd90FBw9C69bwwQewdq2WcBBCiHqgU1Q4I/u1o1eclYISN4dO2CkocZPQ2srIfu3oFBUe6BCFEI1UQKepXLduHddff32F9cOHD+eNN95g8ODBbNu2jYKCAuLi4hg4cCDPP/+8X7HFvLw8xo8fz+eff45er+e2225jwYIFhIWF+drs3LmTcePGsXnzZlq2bMmECROYOnWq3zGXLVvGU089xaFDh+jcuTOzZ8/m5ptv9m1XVZVnnnmGN998k4KCAq6++moWLVpEly5dqvx+ZSosIYRooFwuKDcbEbNmgc0GTz4J5c43ouGd6xpavEJUh6KoHC0oxe7yEGo20joyWHouCNEE1eW5LqAJhqZGfsQIIUQDo6qwbBk89hi8/z5cdVWgI6r3Gtq5rqHFK4QQQlRXXZ7rGlQNBiGEEKLO7NkDycnacIjDh2HOnEBHJIQQQghRr0mCQQghhCjPZoNHH4XeveGbb8BigZkz4d13Ax2ZEEIIIUS9JhPgCiGEEGU+/hjGjdMKOQIMHqzNDNG+fUDDEkIIIYRoCCTBIIQQQpSx27XkQufOsGAB3HhjoCMSQgghhGgwJMEghBCi6crLg/374YortOV77wWvF4YOhaCgwMYmhBBCCNHASA0GIYQQTY+iwFtvQdeu8Je/QFGRtl6vh5EjJbkghBBCCHEeJMEghBCiadm0Ca68EsaOhRMnoFkzOHYs0FEJIYQQQjR4kmAQQgjRNBw/DmPGQGIibN4MEREwbx5s26b1ZBAArF+/nltuuYW4uDh0Oh3Lly/3bXO73UydOpWEhARCQ0OJi4tj2LBhHKskQWO1WtHpdL7Hyy+/7Ld9586dXHPNNVgsFuLj45k9e3aFfSxbtoxu3bphsVhISEjgiy++8NuuqiozZswgNjaW4OBgkpOT2bdvX818EEIIIYSoNkkwCCGEaPxyc6FLF/jXv7Tl4cNh716YOBFMpoCGVt/Y7XZ69+7NwoULK2wrKSlh69atPP3002zdupVPPvmEvXv38qc//alC2yeffJKsrCzfY8KECb5tNpuNgQMH0rZtW7Zs2cKcOXOYOXMmb775pq/Nhg0bGDJkCKNHj2bbtm0MHjyYwYMHk56e7msze/ZsFixYQGpqKhs3biQ0NJSUlBQcDkcNfypCCCGEqAqdqqpqoINoKmw2G1arlcLCQiIiIgIdjhBCNC1Dh8LPP8Prr0O/foGOpkHQ6XR8+umnDB48+IxtNm/ezBVXXMFvv/1GmzZtfOe6WbNmMW3atEpf88Ybb/Dkk0+SnZ2N2WwGYNq0aSxfvpyMjAwA7rrrLux2OytWrPC97sorr6RPnz6kpqaiqipxcXE8+uijPPbYYwAUFhYSHR3NkiVLuPvuu6v0HuXcLIQQorGry3Od9GAQQgjR+GRlwahRkJl5el1qKvz0kyQXalhhYSE6nY7IyEi/9fPmzaNFixZccsklzJkzB4/H49uWlpZG//79fckFgJSUFPbu3Ut+fr6vTXJyst8+U1JSSEtLA+DgwYNkZ2f7tbFarSQmJvraVMbpdGKz2fweQgghhKgZkmAQQgjReLjdMHeuNhxi8WKYMuX0togIMBgCF1sj5HA4mDp1KkOGDKlwR+Ttt9/m22+/5YEHHuCll17i8ccf923Lzs4mOjrar33ZcnZ29lnblN9e/nWVtanMrFmzsFqtvkd8fHx13rIQQgghzsIY6ACEEEKIGvH11/Dww9owCNCKOZZPMIga5Xa7ufPOO1FVlTfeeKPC9muuuYaIiAguvvhizGYzDzzwALNmzSIowFOATp8+ncmTJ/uWbTabJBmEEEKIGiI9GIQQQjRsmZlwxx1www1acqFVK62Y44YN0LdvoKNrlMqSC7/99htr1qw553jOxMREPB4Phw4dAiAmJoacnBy/NmXLMTExZ21Tfnv511XWpjJBQUFERET4PYQQQghRMyTBIIQQomH75z/ho49Ar4cJE7TZIUaN0pZFjStLLuzbt4+vv/6aFi1anPM127dvR6/XExUVBUBSUhLr16/H7Xb72qxZs4auXbvSrFkzX5u1a9f67WfNmjUkJSUB0L59e2JiYvza2Gw2Nm7c6GsjhBBCiLolQySEEEI0PEVFEB6uPZ82DX75BZ58Ei6+OLBxNQLFxcXs37/ft3zw4EG2b99O8+bNiY2N5fbbb2fr1q2sWLECr9frq3fQvHlzzGYzmzZtAmDXrl3ExsaSlpbGpEmTuPfee33Jg6FDh/Lss88yevRopk6dSnp6OvPnz2fevHm+4z7yyCNce+21zJ07l0GDBvH+++/z008/+aay1Ol0TJw4kRdeeIHOnTvTvn17nn76aeLi4s4664UQQgghao9MU1mHZCosIYS4QAcOwKRJkJ0NP/4ovRRqwbp167j++usrrB8+fDgzZ86kffv2lb7u22+/5brrrmP9+vVce+21WK1WnE4n7du357777mPy5Ml+9Rd27tzJuHHj2Lx5My1btmTChAlMnTrVb5/Lli3jqaee4tChQ3Tu3JnZs2dz8803+7arqsozzzzDm2++SUFBAVdffTWLFi2iS5cuVX6/cm4WQgjR2NXluU4SDHVIfsQIIcR5KimBl1+G2bPB6QSjUauxcPnlgY5M/E5DO9c1tHiFEEKI6qrLc53c+hFCCFF/qSp88gl07w7PP68lF5KTYdcuSS4IIYQQQtQzUoNBCCFE/ZSXB3ffDWvWaMvx8TBvHtx6K+h0gY1NCCGEEEJUID0YhBBC1E+RkVBQAGYzPPUUZGTAbbdJckEIIYQQop6SHgxCCCHqB1XVppu8+WYIDdUKOL79Nlgs0KlToKMTQgghhBDnID0YhBBCBN6uXXDddXDnnVoxxzK9eklyQQghhBCigZAEgxBCiMApKIBHHoFLLoH16yE4GKSSvxBCCCFEgxTQBMP69eu55ZZbiIuLQ6fTsXz5ct82t9vN1KlTSUhIIDQ0lLi4OIYNG8axY8f89tGuXTt0Op3f4+Xyd7/Q5tq+5pprsFgsxMfHM3v27AqxLFu2jG7dumGxWEhISOCLL77w266qKjNmzCA2Npbg4GCSk5PZt29fzX0YQgjRlCgKLF4MXbrAggXg9cLtt2t1FqZMCXR0QgghhBDiPAQ0wWC32+nduzcLFy6ssK2kpIStW7fy9NNPs3XrVj755BP27t3Ln/70pwptn3vuObKysnyPCRMm+LbZbDYGDhxI27Zt2bJlC3PmzGHmzJm8+eabvjYbNmxgyJAhjB49mm3btjF48GAGDx5Menq6r83s2bNZsGABqampbNy4kdDQUFJSUnA4HDX8qQghRBMwYwaMGgXHj0O3brB6NSxbBm3aBDoyIYQQQghxnnSqqqqBDgJAp9Px6aefMnjw4DO22bx5M1dccQW//fYbbU79CG3Xrh0TJ05k4sSJlb7mjTfe4MknnyQ7Oxuz2QzAtGnTWL58ORkZGQDcdddd2O12VqxY4XvdlVdeSZ8+fUhNTUVVVeLi4nj00Ud57LHHACgsLCQ6OpolS5Zw9913V+k92mw2rFYrhYWFREgXYCFEU5aZCZdfrvVWePhhbaYI0Sg0tHNdQ4tXCCGEqK66PNc1qBoMhYWF6HQ6IiMj/da//PLLtGjRgksuuYQ5c+bg8Xh829LS0ujfv78vuQCQkpLC3r17yc/P97VJTk7222dKSgppaWkAHDx4kOzsbL82VquVxMREX5vKOJ1ObDab30MIIZocrxdSU6Fc7zLatIHffoPHHpPkghBCCCFEI9Fgpql0OBxMnTqVIUOG+GVdHn74YS699FKaN2/Ohg0bmD59OllZWbz66qsAZGdn0759e799RUdH+7Y1a9aM7Oxs37rybbKzs33tyr+usjaVmTVrFs8+++x5vmMhhGgE0tJg3DjYtk1bvuceuPJK7bnFEri4hBBCCCFEjWsQCQa3282dd96Jqqq88cYbftsmT57se37xxRdjNpt54IEHmDVrFkFBQXUdqp/p06f7xWez2YiPjw9gREIIUUdycmDqVFi6VFu2WuGFF6Bv38DGJYQQQgghak29HyJRllz47bffWLNmzTnHjCQmJuLxeDh06BAAMTEx5OTk+LUpW46JiTlrm/Lby7+usjaVCQoKIiIiwu8hhBCNmscD8+drs0OUJRdGj4ZffoHx48HYIPLaQgghhBDiPFxwgsFms7F8+XJ+/vnnmojHT1lyYd++fXz99de0aNHinK/Zvn07er2eqKgoAJKSkli/fj1ut9vXZs2aNXTt2pVmzZr52qxdu9ZvP2vWrCEpKQmA9u3bExMT49fGZrOxceNGXxshhBBAaSm88grYbHDZZfDjj/DWW3DqO1kIIYQQQjRe1b6VdOedd9K/f3/Gjx9PaWkpffv25dChQ6iqyvvvv89tt91W5X0VFxezf/9+3/LBgwfZvn07zZs3JzY2lttvv52tW7eyYsUKvF6vr95B8+bNMZvNpKWlsXHjRq6//nrCw8NJS0tj0qRJ3Hvvvb7kwdChQ3n22WcZPXo0U6dOJT09nfnz5zNv3jzfcR955BGuvfZa5s6dy6BBg3j//ff56aeffFNZ6nQ6Jk6cyAsvvEDnzp1p3749Tz/9NHFxcWed9UIIIZqE7GyIjgadDsLD4e9/h5MntZ4LBkOgoxNCCCGEEHVFrabo6Gh1+/btqqqq6jvvvKN26tRJtdvt6qJFi9Q+ffpUa1/ffvutClR4DB8+XD148GCl2wD122+/VVVVVbds2aImJiaqVqtVtVgsavfu3dWXXnpJdTgcfsfZsWOHevXVV6tBQUFq69at1ZdffrlCLB9++KHapUsX1Ww2qz179lRXrlzpt11RFPXpp59Wo6Oj1aCgIHXAgAHq3r17q/V+CwsLVUAtLCys1uuEEKJecjpV9eWXVTU0VFX/859ARyPqiYZ2rmto8QohhBDVVZfnOp2qqmp1EhLBwcH88ssvxMfHM2zYMOLi4nj55ZfJzMykR48eFBcX11jyo7GRubaFEI3G6tXatJO//KIt33YbfPRRYGMS9UJDO9c1tHiFEEKI6qrLc121azDEx8eTlpaG3W5n1apVDBw4EID8/HwsMuWYEEI0bocOwa23QkqKllyIjoZ//xuWLQt0ZEIIIYQQIsCqXYNh4sSJ3HPPPYSFhdGmTRuuu+46ANavX09CQkJNxyeEEKK+ePttGDcOHA6ttsLDD8Mzz2hTUAohhBBCiCav2gmGv/71r1xxxRUcPnyYG264Ab1e6wTRoUMHXnjhhRoPUAghRD3RtauWXLj+eq2QY8+egY5ICCGEEELUI+c1IXnfvn25+OKLOXjwIB07dsRoNDJo0KCajk0IIUQg7dsHW7fCXXdpy/36QVoaJCZqM0YIIYQQQghRTrVrMJSUlDB69GhCQkLo2bMnmZmZAEyYMIGXX365xgMUQghRx+x2eOIJ6NULRozQ6i6UufJKSS40cuvXr+eWW24hLi4OnU7H8uXL/barqsqMGTOIjY0lODiY5ORk9u3bV2E/Y8aMISIigsjISEaPHl2hCPTOnTu55pprsFgsxMfHM3v27Ar7WLZsGd26dcNisZCQkMAXX3xxXrEIIYQQom5UO8Ewffp0duzYwbp16/yKOiYnJ/PBBx/UaHBCCCHqkKpqxRq7dYNZs8DlglN1dkTTYbfb6d27NwsXLqx0++zZs1mwYAGpqals3LiR0NBQUlJScDgcfu0yMjJYs2YNK1asYP369dx///2+bTabjYEDB9K2bVu2bNnCnDlzmDlzJm+++aavzYYNGxgyZAijR49m27ZtDB48mMGDB5Oenl7tWIQQQghRR6o7r2WbNm3UtLQ0VVVVNSwsTD1w4ICqqqq6b98+NTw8vOYm0GyEZK5tIUS9tXu3qv7hD6qqpRlUtV07Vf2//1NVRQl0ZCKAAPXTTz/1LSuKosbExKhz5szxrSsoKFCDgoLU9957T1VVVd20aZMKqN9++62vzZdffqnqdDr16NGjqqqq6qJFi9RmzZqpTqfT12bq1Klq165dfct33nmnOmjQIL94EhMT1QceeKDKsVSFnJuFEEI0dnV5rqt2D4bjx48TFRVVYb3dbkcn3WaFEKLhKSzU6ip88w1YLDBzJuzZA3/6kwyHEH4OHjxIdnY2ycnJvnVWq5XExETS0tIA2LRpEwCXXnqpr01ycjJ6vZ6NGzcCkJaWRv/+/TGbzb42KSkp7N27l/z8fF+b8scpa1N2nKrEUhmn04nNZvN7CCGEEKJmVDvB0LdvX1auXOlbLksqvPXWWyQlJdVcZEIIIWqPqp5+brXC5MkweLCWWHjmGQgODlhoov7Kzs4GIDo62m99dHS0b1tOTk6F1xmNRpo3b+5rk52dXek+yh/jTG3Kbz9XLJWZNWsWVqvV94iPjz/LOxZCCCFEdVR7FomXXnqJm266iT179uDxeJg/fz579uxhw4YNfPfdd7URoxBCiJq0fTs8/DDMnq0VbQQtqaCvds5ZiAZn+vTpTJ482bdss9kkySCEEELUkGr/mrz66qvZvn07Ho+HhIQEVq9eTVRUFGlpaVx22WW1EaMQQoiakJ8P48fDZZfB//4HU6ee3ibJBVEFMTExQMVeCjk5Ob5tv+9RAODxeMjLy/O1iYmJqXQf5Y9xpjblt58rlsoEBQURERHh9xBCCCFEzTivX5QdO3bkn//8J5s2bWLPnj3897//JSEhoaZjE0IIURMUBd56C7p0gYULteW77oJ33gl0ZKKBad++PTExMaxdu9a3zmazsXHjRt8wySuuuAKAbdu2+dp88803KIpCYmIiAElJSaxfvx632+1rs2bNGrp27UqzZs18bcofp6xN2XGqEosQQggh6la1h0hkZmaedXubNm3OOxghhBA17Kef4K9/hc2bteWePeHvf4frrw9sXKLeKi4uZv/+/b7lgwcPsn37dpo3b06bNm2YOHEiL7zwAp07d6Z9+/Y8/fTTxMXFMXjwYAC6du0KwMMPP8w///lP3G4348eP5+677yYuLg6AoUOH8uyzzzJ69GimTp1Keno68+fPZ968eb7jPvLII1x77bXMnTuXQYMG8f777/PTTz/5prLU6XTnjEUIIYQQdavaCYZ27dqddbYIr9d7QQEJIYSoQbt2acmFiAh49lkYNw5MpkBHJeqxn376ievLJaDK6hUMHz6cJUuW8Pjjj2O327n//vspKCjg6quvZtWqVVgsFr/9dOnShQEDBqDX67nttttYsGCBb5vVamX16tWMGzeOyy67jJYtWzJjxgzuv/9+X5urrrqKd999l6eeeoonnniCzp07s3z5cnr16uVrU9VYhBBCCFE3dKpavpT4ue3YscNv2e12s23bNl599VVefPFFbr311hoNsDGx2WxYrVYKCwtlzKcQonZ4PHDwIHTurC0rCrzwAtx/P5xlXLoQNaWhnesaWrxCCCFEddXlua7aPRh69+5dYV3fvn2Ji4tjzpw5kmAQQohA+f57rYjjyZPw888QFqYVb5wxI9CRCSGEEEKIJqDGyoZ37dqVzWVjfIUQQtSdrCy47z645hrYsQPsdkhPD3RUQgghhBCiial2Dwabzea3rKoqWVlZzJw5k85lXXKFEELUPrcbFiyAmTOhuBh0Ohg7Fl58EVq2DHR0QgghhBCiial2giEyMrJCkUdVVYmPj+f999+vscCEEEKchc0GV16pDYUASEyE11+Hvn0DG5cQQgghhGiyqp1g+Pbbb/2W9Xo9rVq1olOnThiN1d6dEEKI8xERAQkJcOIEvPIKDB+u1VsQQgghhBAiQKqdEbj22mtrIw4hhBBn43TCq69qtRYuukhb9/e/g9kMkZEBDU0IIYQQQgioYoLhs88+q/IO//SnP513MEIIISrxxRfwyCOwfz/s3Anvvaetj4oKbFxCCCGEEEKUU6UEw+DBg6u0M51Oh9frvZB4hBBClDlwACZNgs8/15ZjY+GWWwIbkxBCCCGEEGdQpQSDoii1HYcQQogyJSXw8sswe7Y2NMJo1BINTz8N4eGBjk40AAUFBUTK0BkhhBBC1DGpCCaEEPXNq6/C889ryYXkZNi1S0s2SHJBVOKVV17hgw8+8C3feeedtGjRgtatW7Njx44ARiaEEEKIpua8Egx2u50vvviC1NRUFixY4PeojvXr13PLLbcQFxeHTqdj+fLlfttVVWXGjBnExsYSHBxMcnIy+/bt82uTl5fHPffcQ0REBJGRkYwePZri4mK/Njt37uSaa67BYrEQHx/P7NmzK8SybNkyunXrhsViISEhgS+++KLasQghxHkrP7xs4kS46ir4+GNYvRq6dQtYWKL+S01NJT4+HoA1a9awZs0avvzyS2666SamTJkS4OiEEEII0ZRUexaJbdu2cfPNN1NSUoLdbqd58+acOHGCkJAQoqKiePjhh6u8L7vdTu/evRk1ahS33nprhe2zZ89mwYIFLF26lPbt2/P000+TkpLCnj17sFgsANxzzz1kZWWxZs0a3G43I0eO5P777+fdd98FwGazMXDgQJKTk0lNTWXXrl2MGjWKyMhI7r//fgA2bNjAkCFDmDVrFn/84x959913GTx4MFu3bqVXr15VjkUIIaqtqAheeAF+/BG+/VabajIsDH74IdCRiQYiOzvbl2BYsWIFd955JwMHDqRdu3YkJiYGODohhBBCNClqNV177bXq2LFjVa/Xq4aFhakHDhxQMzMz1f79+6sff/xxdXfnA6iffvqpb1lRFDUmJkadM2eOb11BQYEaFBSkvvfee6qqquqePXtUQN28ebOvzZdffqnqdDr16NGjqqqq6qJFi9RmzZqpTqfT12bq1Klq165dfct33nmnOmjQIL94EhMT1QceeKDKsVRFYWGhCqiFhYVVfo0QopFSFFV9911VjYtTVdAeq1YFOirRAMXGxqo//PCDqqqq2qVLF/XDDz9UVVVVMzIy1PDw8DqPp6Gd6xpavEIIIUR11eW5rtpDJLZv386jjz6KXq/HYDDgdDp9ww6eeOKJGkt8HDx4kOzsbJKTk33rrFYriYmJpKWlAZCWlkZkZCR9+/b1tUlOTkav17Nx40Zfm/79+2M2m31tUlJS2Lt3L/n5+b425Y9T1qbsOFWJpTJOpxObzeb3EEIIdu2C666DoUPh2DHo2FGbKSIlJdCRiQbo1ltvZejQodxwww2cPHmSm266CdB6HHbq1CnA0QkhhBCiKal2gsFkMqHXay+LiooiMzMT0C64Dx8+XGOBZWdnAxAdHe23Pjo62rctOzubqN/NA280GmnevLlfm8r2Uf4YZ2pTfvu5YqnMrFmzsFqtvkdZF1YhRBNVWqrVV7jkEli/HoKDteER6enwxz8GOjrRQM2bN4/x48fTo0cP1qxZQ1hYGABZWVn89a9/DXB0QgghhGhKql2D4ZJLLmHz5s107tyZa6+9lhkzZnDixAn+85//+OoVCM306dOZPHmyb9lms0mSQYimzGyG//1PK+h4++0wdy60aRPoqEQDZzKZeOyxxyqsnzRpUgCiEUIIIURTVuUEg9frxWAw8NJLL1FUVATAiy++yLBhw3jooYfo3Lkzb7/9do0FFhMTA0BOTg6xsbG+9Tk5OfTp08fXJjc31+91Ho+HvLw83+tjYmLIycnxa1O2fK425befK5bKBAUFERQUVKX3K4RopLZtg65dISQEDAb4xz8gPx9uuCHQkYkG7LPPPqty2z/96U+1GIkQQgghxGlVTjC0bt2aESNGMGrUKF/Ng6ioKFatWlUrgbVv356YmBjWrl3ru4i32Wxs3LiRhx56CICkpCQKCgrYsmULl112GQDffPMNiqL4KmcnJSXx5JNP4na7MZlMgDaNV9euXWnWrJmvzdq1a5k4caLv+GvWrCEpKanKsQghhJ+TJ+Gpp7SEwowZMHOmtr5czRghztfgwYOr1E6n0+EtPwWqEEIIIUQtqnINhnHjxvHRRx/RvXt3rrnmGpYsWUJJSckFHby4uJjt27ezfft2QCumuH37djIzM9HpdEycOJEXXniBzz77jF27djFs2DDi4uJ8P6y6d+/OjTfeyNixY9m0aRM//PAD48eP5+677yYuLg6AoUOHYjabGT16NLt37+aDDz5g/vz5fkMXHnnkEVatWsXcuXPJyMhg5syZ/PTTT4wfPx6gSrEIIQSgDX/4xz+gSxdITdXmhzhyRPt/IWqIoihVekhyQfyeoqgczishI9vG4bwSFEW+m4QQQtQcnapW71fvunXrWLx4MR9//DEGg4E777yTMWPGnNdc2+vWreP666+vsH748OEsWbIEVVV55plnePPNNykoKODqq69m0aJFdOnSxdc2Ly+P8ePH8/nnn6PX67nttttYsGCBr8gVwM6dOxk3bhybN2+mZcuWTJgwgalTp/odc9myZTz11FMcOnSIzp07M3v2bG6++Wbf9qrEci42mw2r1UphYSERERHV+aiEEA1BWhqMHw9bt2rLF18Mf/879O8f2LiEqEMN7VzX0OK9EPtzi/gqPYcDx4txeLxYjAY6tgojpVc0naLCAx2eEEKIWlKX57pqJxjKFBcX8/7777NkyRI2bNhA9+7dGT16tF/PAOGvKf2IEaLJWbQIxo3Tnlut2uwQDz4IxmrX0hWi2ux2O9999x2ZmZm4XC6/bQ8//HCdxtLQznUNLd7ztT+3iMU/HCLP7iLWaiHEbKTE5SGr0EHzUDMj+7WTJIMQQjRSdXmuq/Y0lWXCwsIYM2YM33//PZ9//jnZ2dlMmTKlJmMTQoiG4+abtUKOo0bBL79oPRkkuSDqwLZt2+jUqRNDhgxh/PjxvPDCC0ycOJEnnniC1157rVaO2a5dO3Q6XYXHuLIkG9r01eW3Pfjgg377yMzMZNCgQYSEhBAVFcWUKVPweDx+bdatW8ell15KUFAQnTp1YsmSJRViWbhwIe3atcNisZCYmMimTZtq5T03ZIqi8lV6Dnl2F52jwgi3mDDodYRbTHSOCiPP7mL17hwZLnGKDCMRQojzd96/fktKSvjwww9ZvHgx33//PR07dpQEgxCi6fjuO1i3Dp55Rltu1w4OHIBTs84IUVcmTZrELbfcQmpqKlarlR9//BGTycS9997LI488UivH3Lx5s199h/T0dG644QbuuOMO37rhw4fz8ssv+5ZDQkJ8z71eL4MGDSImJoYNGzaQlZXFsGHDMJlMvPTSS4BWl2nQoEE8+OCDvPPOO6xdu5YxY8YQGxtLSkoKAB988AGTJ08mNTWVxMREXnvtNVJSUti7dy9RUVG18t4boqMFpRw4Xkys1YJOp/PbptPpiLVa2J9bzNGCUuKbh5xhL02DDCMRQogLU+0hEhs2bODtt99m2bJleDwebr/9dkaPHk1/GWN8Tk2lG6YQjdrRozBlCrz3nrb8/ffQr19gYxJNWmRkJBs3bqRr165ERkaSlpZG9+7d2bhxI8OHDycjI6PWY5g4cSIrVqxg3759FBUVYbVaeeihh1i0aFGl7b/88kv++Mc/cuzYMaKjowFITU1l6tSpHD9+HLPZzNSpU1m5ciXp6em+1919990UFBT4ZrBKTEzk8ssv5/XXXwe04pfx8fFMmDCBadOmVSn2pnBuzsi2sWDtPjq0DMOg11XY7lEUDp2wM2FAZ7rFNM7PoCpkGIkQorGql0MkZs+e7ZtBYteuXcyZM4fs7GyWLl0qyQUhROPncsHs2dC1q5Zc0Ovhr3+F7t0DHZlo4kwmE3q9djqPiooiMzMT0IYoHD58uNaP73K5+O9//8uoUaP87o5/+OGHtGzZkl69ejF9+nS/mafS0tJISEjwJRcAUlJSsNls7N6929cmOTnZ71gpKSmkpaX5jrtlyxa/Nnq9nuTkZF+byjidTmw2m9+jsQs1G7EYDZS4PJVuL3V5CTIaCDU33WFdMoxECCFqRpXPJHPmzOHee+9l2bJl9OrVqzZjEkKI+mX1apgwQautAHDVVfD663DJJYGNSwjgkksuYfPmzXTu3Jlrr72WGTNmcOLECf7zn//Uyfl6+fLlFBQUMGLECL/1b775Jp07d2bnzp1MnTqVvXv38sknnwCQnZ3tl1wAfMvZ2dlnbWOz2SgtLSU/Px+v11tpm7P12pg1axbPPvvseb3Xhqp1ZDAdW4WRfqyQsCCjXyJIVVWyCh0ktLbSOjI4gFEGlgwjEUKImlHlBMOxY8cwmUy1GYsQQtQ/JSUwbBjk5EB0tNaL4b77QFexm7EQgfDSSy9RVFQEwIsvvsiwYcN46KGH6Ny5M2+//XatH/9f//oXN910E3FxcX7rk5OTiYiIICEhgdjYWAYMGMCBAwfo2LFjrcd0NtOnT/eb8cpmsxEfHx/AiGqfXq8jpVc0xwpL2ZerXUQHmw2Uury+7v8De0ajr2T4RFNhd3lweLyEmCtPsgSbDeTYHNjP0AtECCGEpsoJBkkuCCGaDIcDgoK0JEJICMydC1u2aAUdrdZARyeEn759+/qeR0VF+eoT1IXffvuNr7/+2tcz4UwSExMB2L9/Px07diQmJqbCbA85OTkAxJwqlBoTE+NbV75NREQEwcHBGAwGDAZDpW1izlJsNSgoiKCgoKq9wUakU1Q4I/u18xUwzLE5CDIaSGhtZWBPKWBYfhhJuKXib14ZRiKEEFVz3tNUCiFEo6Oq8Pnn0LMnvP/+6fX33AOvvirJBSF+Z/HixURFRTFo0KCzttu+fTsAsbGxACQlJbFr1y5yc3N9bdasWUNERAQ9evTwtVm7dq3fftasWUNSUhIAZrOZyy67zK+NoiisXbvW10b46xQVzkPXdWTSDV2YMKAzk27owoPXdmzyyQU4PYwkq9DB7+uflw0j6RQV1qSHkQghRFVIGlYIIQD27YOJE+GLL7Tl116Du++WoRCi3mvfvn2FMePl/frrr7VyXEVRWLx4McOHD8doPP1zoux427Zto23btuzcuZNJkybRv39/Lr74YgAGDhxIjx49uO+++5g9ezbZ2dk89dRTjBs3zte74MEHH+T111/n8ccfZ9SoUXzzzTd8+OGHrFy50nesyZMnM3z4cPr27csVV1zBa6+9ht1uZ+TIkbXynhsDvV4nNQQqIcNIhBCiZkiCQQjRtNnt8NJL8Le/aTNFmEzw2GPwxBOSXBANwsSJE/2W3W4327ZtY9WqVUyZMqXWjvv111+TmZnJqFGj/NabzWYA/vKXv1BSUkJ8fDy33XYbTz31lK+NwWBgxYoVPPTQQyQlJREaGsrw4cN57rnnfG3at2/PypUrmTRpEvPnz+eiiy7irbfeIiUlxdfmrrvu4vjx48yYMYPs7Gz69OnDqlWrKhR+FKIqGuMwEkVROVpQit3lIdRspHVksCRJhBC1Sqf+vh9YJaozhVNjnUO6JjSFubaFaFBWr4bRo+HIEW05JQUWLIAuXQIblxA1YOHChfz0008sXry4To/b0M51DS1eUfsay0X5/twiX7LE4fFiMRro2CqMlF4NM1kihDh/dXmuq1IPhsjIyLN2vyzP6/VeUEBCCFFnLBYtudCunTYk4k9/kl4LotG46aabmD59ep0nGIRo6BrDMJL9uUUs/uEQeXYXsVYLIeZgSlwe0o8VcqywlJH92kmSQQhRK6qUYPj22299zw8dOsS0adMYMWKEr4hSWloaS5cuZdasWbUTpRBC1ASbDTZvhgEDtOX+/WHZMhg0CIKlcJdoXD766COaN28e6DCEEHVMUVS+Ss8hz+6ic1SY7yZhuMVEWJCRfbnFrN6dQ4eWYQ2yZ4YQon6rUoLh2muv9T1/7rnnePXVVxkyZIhv3Z/+9CcSEhJ48803GT58eM1HKYQQF0JV4Z13YMoUKCyEjAxo00bbdvvtgY1NiAt0ySWX+PUyVFWV7Oxsjh8/zqJFiwIYmRAiEI4WlHLguFao8vc9kHU6HbFWC/tzizlaUNrge2oIIeqfahd5TEtLIzU1tcL6vn37MmbMmBoJSgghasz27TBhAnz/vbbcuTPk5p5OMAjRwA0ePNhvWa/X06pVK6677jq6desWmKCEEAFjd3lweLyEmCvvmRdsNpBjc2B3eeo4MiFEU1DtBEN8fDz//Oc/mT17tt/6t956i/j4+BoLTAghLkh+Pjz9NLzxBigKhIRoy5Mmwalp8IRoDJ555plAhyCEqEdCzUYsRgMlLg/hFlOF7aUuL0FGA6FmmUxOCFHzqv3NMm/ePG677Ta+/PJLEhMTAdi0aRP79u3j448/rvEAhRCi2hwOSEiAo0e15bvu0qahvOiiwMYlRA2R2Z2EEGfSOjKYjq3CSD9WSFiQscIQqqxCBwmtrbSOlNpDQoiaV+0Ew80338wvv/zCG2+8QUZGBgC33HILDz74oPRgEELUDxYLDB8Oy5fD66/D9dcHOiIhapTM7iSEOBO9XkdKr2iOFZayL1erxRBsNlDq8pJV6KB5qJmBPaOlwKMQolboVFVVAx1EUyFzbQtRS44fhyeegLFj4YortHUOBxgMYKrYPVSIhu67777zPT/X7E51XXy5oZ3rGlq8QlTV/twivkrP4cDxYpwebVhEp6gwBvaMlikqhWhi6vJcd14Jhv/973/84x//4Ndff2XZsmW0bt2a//znP7Rv356rr766NuJsFORHjBA1zOOBf/wDnnoKCgq05MKPP0IV7+wK0RgMGDCAMWPG+M3uBPDuu+/y5ptvsm7dujqNp6Gd6xpavEJUh6KoHC0oxe7yEGo20joyWHouCNEE1eW5Tl/dF3z88cekpKQQHBzM1q1bcTqdABQWFvLSSy/VeIBCCFGp77+Hvn1h/HgtudCnD7z6qiQXRJOTlpZG3759K6zv27cvmzZtCkBEQoj6Qq/XEd88hG4xEcQ3D5HkghCi1lU7wfDCCy+QmprKP//5T0zluh7369ePrVu31mhwQghRQVYW3HcfXHMN7NgBzZrBokXw00/Qr1+goxOizpXN7vR7MruTEEJRVA7nlZCRbeNwXgmKIiOjhRC1q9pFHvfu3Uv//v0rrLdarRQUFNRETEIIcWYrV8J//6v1VBg7Fl58EVq2DHRUQgSMzO4khKhM+RoMDo8Xi9FAx1ZhpPSSGgxCiNpT7R4MMTEx7N+/v8L677//ng4dOtRIUEII4Scv7/TzUaO0xMLGjVr9BUkuiCaubHanW265hby8PPLy8rjlllv45ZdfuPnmmwMdnhAiAPbnFrH4h0OkHyskMsREh5ZhRIaYSD9WyOIfDrE/tyjQIQohGqlq92AYO3YsjzzyCG+//TY6nY5jx46RlpbGY489xtNPP10bMQohmqrDh+HRR7Vkws8/Q0gI6PXw5puBjkyIeiU+Pl7qIAkhAG1YxFfpOeTZXXSOCvNNaRtuMREWZGRfbjGrd+fQoWWY1GQQQtS4avdgmDZtGkOHDmXAgAEUFxfTv39/xowZwwMPPMCECRNqPMB27dqh0+kqPMaNGwfAddddV2Hbgw8+6LePzMxMBg0aREhICFFRUUyZMgWPx+PXZt26dVx66aUEBQXRqVMnlixZUiGWhQsX0q5dOywWC4mJiVI8S4ja4nTCSy9Bt26wbBkcOQLffBPoqISoN3bu3ImiKL7nZ3sIIZqWowWlHDheTKzV4ksulNHpdMRaLezPLeZoQWmAIhRCNGbV7sGg0+l48sknmTJlCvv376e4uJgePXoQFhZWG/GxefNmvF6vbzk9PZ0bbriBO+64w7du7NixPPfcc77lkJAQ33Ov18ugQYOIiYlhw4YNZGVlMWzYMEwmk+9uz8GDBxk0aBAPPvgg77zzDmvXrmXMmDHExsaSkpICwAcffMDkyZNJTU0lMTGR1157jZSUFPbu3UtUVFStvHchmqQvvoBHHoGyoVjXXAOvvw4XXxzYuISoR/r06UN2djZRUVH06dMHnU5HZbNO63Q6v3OoEKLxs7s8ODxeQszBlW4PNhvIsTmwuzyVbhdCiAtR7QTDqFGjmD9/PuHh4fTo0cO33m63M2HCBN5+++0aDbBVq1Z+yy+//DIdO3bk2muv9a0LCQkhJiam0tevXr2aPXv28PXXXxMdHU2fPn14/vnnmTp1KjNnzsRsNpOamkr79u2ZO3cuAN27d+f7779n3rx5vgTDq6++ytixYxk5ciQAqamprFy5krfffptp06bV6HsWoklyOuGOO+Dzz7Xl2Fj4299gyBCZelKI3zl48KDv/Hjw4MEARyOEqE9CzUYsRgMlLg/hFlOF7aUuL0FGA6Hmal8GCCHEOVV7iMTSpUspLa3Ypaq0tJR///vfNRLUmbhcLv773/8yatQovy5f77zzDi1btqRXr15Mnz6dkpIS37a0tDQSEhKIjo72rUtJScFms7F7925fm+TkZL9jpaSkkJaW5jvuli1b/Nro9XqSk5N9bSrjdDqx2Wx+DyHEGQQFgdkMRiM89hjs3QtDh0pyQYhKtG3b1ncebNu27VkfQoimpXVkMB1bhZFV6EBRFGylbk4UO7GVulEUhaxCB52iwmgdWXkPByGEuBBVTl3abDZUVUVVVYqKirBYLL5tXq+XL774otaHCixfvpyCggJGjBjhWzd06FDatm1LXFwcO3fuZOrUqezdu5dPPvkEgOzsbL/kAuBbzs7OPmsbm81GaWkp+fn5eL3eSttkZGScMd5Zs2bx7LPPnvf7FaJRU1VYvhwSEyEuTlv32mvw/PPQvXsgIxOiQVm6dCktW7Zk0KBBADz++OO8+eab9OjRg/fee0+SDEJUk8ejsPVwPiftLlqEmrk0vhlGY7XvyQWMXq8jpVc0P2fb+Gp3Dl5VBVRAh0Gno0tMOAN7RkuBRyFErahygiEyMtJXRLFLly4Vtut0ulq/mP7Xv/7FTTfdRFzZxQhw//33+54nJCQQGxvLgAEDOHDgAB07dqzVeM5l+vTpTJ482bdss9mIj48PYERC1BN798LDD8Pq1XDPPfDf/2rrL7oosHEJ0QC99NJLvPHGG4DWI+/111/ntddeY8WKFUyaNMmXcBdCnNvan3NY8sMhDp204/YqmAx62rUIZUS/dgzoHn3uHdQ3OrTcArrTy0IIUYuqnGD49ttvUVWVP/zhD3z88cc0b97ct81sNvt6EdSW3377ja+//vqcP5QSExMB2L9/Px07diQmJqbCbA85OTkAvroNMTExvnXl20RERBAcHIzBYMBgMFTa5ky1HwCCgoIICgqq2hsUoikoLtZ6KMybB263NiSifXutN4MMhRDivBw+fJhOnToBWk+/22+/nfvvv59+/fpx3XXXBTY4IRqQtT/nMOvLDIocblqEmgk2Gyh1efklt4hZX2o9VhtCkqFsmkqvojKwexTZNiclbi8hJgMxEUEcOFEi01QKIWpNlRMMZUUVDx48SJs2bSpMe1PbFi9eTFRUlK8L6Jls374dgNjYWACSkpJ48cUXyc3N9Q3hWLNmDREREb4ilUlJSXzxxRd++1mzZg1JSUmAlkC57LLLWLt2LYMHDwZAURTWrl3L+PHja+otCtF4qSp88AE8+igcO6atGzRIGxJx6sJICHF+wsLCOHnyJG3atGH16tW+nnMWi6XSmklCiIo8HoUlPxyiyOGmTbNg9HptSES4RU+o2UBmfilLNxzi2s6t6v1wibJpKoNNerZmFpJX4sKjKBj1eo4VmImxBvmmqYxvHnLuHQohRDVU+xvym2++4aOPPqqwftmyZSxdurRGgvo9RVFYvHgxw4cPx2g8nRM5cOAAzz//PFu2bOHQoUN89tlnDBs2jP79+3PxqSntBg4cSI8ePbjvvvvYsWMHX331FU899RTjxo3z9S548MEH+fXXX3n88cfJyMhg0aJFfPjhh0yaNMl3rMmTJ/PPf/6TpUuX8vPPP/PQQw9ht9t9s0oIIc5i0SJtNohjx6BDB22miBUrJLkgRA244YYbGDNmDGPGjOGXX37h5ptvBmD37t20a9euVo45c+ZM37DJske3bt382jz66KO0aNGCsLAwbrvttgq9ADMzMxk0aBAhISFERUUxZcoUPB7/afPWrVvHpZdeSlBQEJ06dWLJkiUVYlm4cCHt2rXDYrGQmJhYodeiEFWx9XA+h07aaRFqRqfT4XR7KXF5cLq96HQ6WoSaOXjCztbD+YEO9ZzsLg8nip3szSkit8iBxaSnWYgZi0lPbpGDvTlFnCh2yjSVQohaUe0Ew6xZs2jZsmWF9VFRUbz00ks1EtTvff3112RmZjJq1Ci/9Wazma+//pqBAwfSrVs3Hn30UW677TY+L5vmDjAYDKxYsQKDwUBSUhL33nsvw4YN47nnnvO1ad++PStXrmTNmjX07t2buXPn8tZbb/mmqAS46667+Nvf/saMGTPo06cP27dvZ9WqVRUKPwohKnHffdCxozY8Yvdu+OMfAx2REI3GwoULSUpK4vjx43z88ce0aNECgC1btjBkyJBaO27Pnj3JysryPb7//nu/7atWrWLZsmV89913HDt2jFtvvdW3zev1MmjQIFwuFxs2bGDp0qUsWbKEGTNm+NocPHiQQYMGcf3117N9+3YmTpzImDFj+Oqrr3xtPvjgAyZPnswzzzzD1q1b6d27NykpKeTm5tba+xaN00m7C7dXAR0cKyjlcH4pR/K1/z9WUAo6cHsVTtpdgQ71nEJMBi2B4PDQPNRMkNGAXqcjyGigeaiZYoeHk8VOQkyGQIcqhGiEdKqqqtV5gcViISMjo8JdkUOHDtG9e3fpjnkWNpsNq9VKYWEhERERgQ5HiNqhKPCf/8Bnn8FHH52ureB2g6nifNxCiIZn5syZLF++3DcssbzDhw/Tpk0bli5dyrBhwwDIyMige/fupKWlceWVV/Lll1/yxz/+kWPHjvkS9ampqUydOpXjx49jNpuZOnUqK1euJD093bfvu+++m4KCAlatWgVodZcuv/xyXn/9dUDr8RgfH8+ECROYNm1apbE7nU6cTqdvuawAs5ybm7ZNB0/y8HvbcHoUAIKMevQ6UFT81i0YcglXtG8RyFDP6beTdh7671bsTg/REUF+w5pVVSXH5iQ0yMgb915K2xahAYxUCFFX6vI6tNo9GKKioti5c2eF9Tt27PDdNRFCNFFbt8LVV8OIEfDJJ1qCoYwkF4SoNf/73/+49957ueqqqzh69CgA//nPfyr0KqhJ+/btIy4ujg4dOnDPPfeQmZkJnK6FVL7AZLdu3WjTpg1paWmANttFQkKCXy/AlJQUbDYbu3fv9rVJTk72O2ZKSopvHy6Xiy1btvi10ev1JCcn+9pUZtasWVitVt9DZncSAH1aRxJkNFDi8mAx6jDotaE/Br0Oi1GnrTcZ6NM6MtChnlOp20vLMDNhFiN5dhdOjxdFVXF6vOTZXYRZjLQMM1Pq9gY6VCFEI1TtBMOQIUN4+OGH+fbbb/F6vXi9Xr755hseeeQR7r777tqIUQhR3508CQ89BH37QloahIXBnDnw5z8HOjIhGr2PP/6YlJQUgoOD2bp1q+/ufGFhYa0NXUxMTGTJkiWsWrWKN954g4MHD3LNNddQVFTkG54QGRnp95ro6Giys7MByM7OrjDEsGz5XG1sNhulpaWcOHECr9dbaZuyfVRm+vTpFBYW+h6HDx+u/gcgGp2cYidxkRYsRgM2hxenRzl1Ua5gc3ixGA3EWi3kFDvPuh9FUTmcV0JGto3DeSUoSrU6CteIULORlmFBdI0Oo2VYELZSD9k2B7ZSD63CT68PNVe51rsQQlRZtb9Znn/+eQ4dOsSAAQN8BRcVRWHYsGG19kNGCFFPeb3w1lvwxBOQl6etGzoUZs+G1q0DG5sQTcQLL7xAamoqw4YN4/333/et79evHy+88EKtHPOmm27yPb/44otJTEykbdu2fPjhh7VyvJokU0iLythdHpqFmrmmc0t2HimkoNRNqUvFoNfRIsxMQmurr92Z7M8t4qv0HA4cL8bh0ZISHVuFkdIrmk5R4XX1VmgdGUzHVmH8+OtJQEUH6FTQoQ2ROF7kIqljC1pHBtdZTEKIpqPaCQaz2cwHH3zA888/z44dOwgODiYhIYG2bdvWRnxCiPpMVeGNN7TkQkICvP469O8f6KiEaFL27t1L/0r+3VmtVgoKCuokhsjISLp06cL+/fu56qqrACgoKPAb55mTk0NMTAwAMTExFWZ7KJtlonyb3888kZOTQ0REBMHBwRgMBgwGQ6VtyvYhRFWFmo1YjAYiQ0z8uU8YWbZSSl1egs0GYiOCsbs8FJS4z3jXf39uEYt/OESe3UWs1UKIOZgSl4f0Y4UcKyxlZL92dZZk0Ot1dIsN59PtRylyuGkRaiYy1ESpy8vBkyWEW0x0jQlHr6/bKeeFEE3DeU/k26VLF+644w7++Mc/SnJBiKYkJwfKirkajdoUlAsWaPUXJLkgRJ2LiYlh//79FdZ///33dOjQoU5iKC4u5sCBA8TGxtKnTx8AvvvuO9/2vXv3kpmZSVJSEgBJSUns2rXLb7aHNWvWEBERQY8ePXxt1q5d63ecNWvW+PZhNpu57LLL/NooisLatWt9bYSoqrK7/lmFDnQ6aB0ZQqeocFpHhqDTQVahg05RYZXe9VcUla/Sc8izu+gcFUa4xYRBryPcYqJzVBh5dherd+fU2XAJRVHJyCoi1mqhQ4tQFBVspW4UFTq0DCXWamFvdlFAhm8IIRq/KvVgmDx5Ms8//zyhoaFMnjz5rG1fffXVGglMCFHPeDxaMmHGDHj0UXj6aW39VVdpDyFEQIwdO5ZHHnmEt99+G51Ox7Fjx0hLS+PRRx/1m/axJj322GPccssttG3blmPHjvHMM89gMBgYMmSIb/jBk08+yUUXXURERAQTJkwgKSmJK6+8EoCBAwfSo0cP7rvvPmbPnk12djZPPfUU48aN873+wQcf5PXXX+fxxx9n1KhRfPPNN3z44YesXLnSF8fkyZMZPnw4ffv25YorruC1117DbrczcuTIWnnfovHS63Wk9IrmWGEp+3KLibVaCDYbKHV5ySp00DzUzMCe0ZXe9T9aUMqB49prys/YAKDT6Yi1WtifW8zRglLim4fU+nspi6dzVBhhQUaKHB5cXgWzQU+4xUix01On8QghmpYqJRi2bduG2+32PT+T33+pCiEaie++g/HjoWy6uNWr4cknQX/enaCEEDVk2rRpKIrCgAEDKCkpoX///gQFBTFlyhTGjBlTK8c8cuQIQ4YM4eTJk7Rq1Yqrr76aH3/8kVatWmGz2QBtxofbbrsNp9NJSkoKixYt8r3eYDCwYsUKHnroIZKSkggNDWX48OE899xzvjbt27dn5cqVTJo0ifnz53PRRRfx1ltvkZKS4mtz1113cfz4cWbMmEF2djZ9+vRh1apVFQo/ClEVnaLCGdmvna+OQo7NQZDRQEJrKwN7nrmOgt3lweHxEmKuvKZBsNlAjs1x1voNNal8PDqdjohg/1mc6joeIUTTolNVVfpH1ZG6nH9UiBpx9ChMmQLvvactN28Os2bB6NFgMAQ2NiGEH5fLxf79+ykuLqZHjx784x//YM6cOWedUaE2NLRzXUOLV9Q+RVE5WlCK3eUh1GykdWTwWesVHM4rYd6aX4gMMRFuqTglc5HDTUGJm0k3dKmTHgP1LR4hRODV5blObj8KISr36afQtauWXNDptGkof/kF7r9fkgtC1ANOp5Pp06fTt29f+vXrxxdffEGPHj3YvXs3Xbt2Zf78+UyaNCnQYQrR4Oj1OuKbh9AtJoL45iHnLIZYvn7D7+/bqap61voNtaG+xSOEaFqqNETi1ltvrfIOP/nkk/MORghRj/TurdVdSErSZoe49NJARySEKGfGjBn84x//IDk5mQ0bNnDHHXcwcuRIfvzxR+bOncsdd9yBQZKBQtS6C6nf0BTiEUI0LVVKMFitVt9zVVX59NNPsVqt9O3bF4AtW7ZQUFBQrUSEEKKe+e03+OILracCQIcOsHGjNv2k1FoQot5ZtmwZ//73v/nTn/5Eeno6F198MR6Phx07dkhNJCHq2PnWb6jteFalZ7PraCElLi8hZgMXt44kpVfdxyOEaDqqlGBYvHix7/nUqVO58847SU1N9d0Z8Xq9/PWvf5Wxi0I0RA4HzJmj1VYoLYVLLoFTld7p3TuwsQkhzujIkSNcdtllAPTq1YugoCAmTZokyQUhAqRTVDgdrgurVv2GWqdqD1X7nwpDJoQQoqZVKcFQ3ttvv83333/v1+3SYDAwefJkrrrqKubMmVOjAQohatHnn8PEifDrr9rydddBuR5LQoj6y+v1YjabfctGo5GwsLAARiQaguoWMBTVU1a/IdD25xax+IdDnCx2EhFspFmoGa+ikH6skCybg5H92kkvBiFErah2gsHj8ZCRkUHXrl391mdkZKAoSo0FJoSoRfv3a4mFsvnkW7eGuXPhzju1go5CiHpPVVVGjBhBUFAQAA6HgwcffJDQ0FC/dlIbSZTZn1vk68Lv8HixGA10bBUmXeYbGUVR+So9h8yTJXgUhUMnS/B4FYwGPc1CTNidXlbvzqFDyzBJLgkhaly1EwwjR45k9OjRHDhwgCuuuAKAjRs38vLLLzNy5MgaD1AIUcM8HvjDH+DwYTCZ4NFH4cknQe58CtGgDB8+3G/53nvvDVAkoiEou6OdZ3cRa7UQYg6mxOUh/VghxwpL5Y52I3K0oJRth/PJLXLgVVTCLCZMFiNur8rxIicGvY6tmfkcLSitF70thBCNS7UTDH/729+IiYlh7ty5ZGVlARAbG8uUKVN49NFHazxAIUQNKBtzqdOB0QjPPgsffAALFkCXLoGNTQhxXsrXRxLibMruaOfZXXSOCvPV6Qi3mAgLMrIvt1juaNeQ+jAEpcjpJjOvBK9XpUWY2ff3DjLqMIeaOVns4nBeCUVOd53GJYSomvrwPXIhqp1g0Ov1PP744zz++OPYbDYAKe4oRH32888wYQLcf782BAJgxAjtIcMhhBCi0TtaUMqB49p0hb8vAqrT6Yi1WtifWyx3tC9QfRmCUuzwUOryEm7RfuY73V68qopBp8Ns1BNk0lPk8FDs8NRZTEKIqqkv3yMXotoJBtDqMKxbt44DBw4wdOhQAI4dO0ZERIQUmBKivrDZ4LnnYP58bVjEb7/B7bdrU05KYkEIIZoMu8uDw+MlxBxc6fZgs4EcmwO7Sy44z1d9GoISFmQk2GSgyOHGVuqm1K2gqCp6nY5gkx6dDkLMRsKCzusyQAhRS+rT98iFqPY3y2+//caNN95IZmYmTqeTG264gfDwcF555RWcTiepqam1EacQoqpUFd59F6ZMgVPDmPjzn+HVV7XkghBCiCYl1GzEYjRQ4vIQFmSkyOHB5VUwG/SEW4yUurwEGQ2EmuWC83zUtyEo4RYTLcLM7DnmwKOoBJsNWIx63F6V/BI3Rr2Oi5qFEG4x1XosQoiqqW/fIxei2meSRx55hL59+7Jjxw5atGjhW/+Xv/yFsWPH1mhwQohqSk+Hhx6C77/Xljt31now3HRTYOMSQggRMK0jg+nYKowfD57E41HIL3XjURSMej3Ngk0YjXqSOrSgdWTlPRzE2dW3ISixERaMej1Gg56wIB0Oj4rDraDX6YgMNuLwqJgMemIjLLUeixCiaurb98iFqHaC4X//+x8bNmzwm3sboF27dhw9erTGAhNCnIfjx7XkQkgIPPUUTJ4Mp6awE0II0TTp9Tq6xYbz6fajFDnctAg1Yw02Uery8utJOxEWE11jwuv9XbH6qr4NQcmyOQgy6WkZZsajqFiD9ej0oCrg9CqEBesxG/Vk2Rz1/kJFiKaivn2PXIhq95dWFAWv11th/ZEjRwgPr/9jQoRoVBQFdu06vXz99VqPhYwMmD5dkgtCCCFQFJWMrCJiIyx0aBmKokJhqRtFhQ4tQ4mJsLA3uwhFUQMdaoNUfghKZep6CIrd5cFs1HNZ2+ZEhVtQAKdHQQGiIyxc2iaSIKO+QVyoCNFU1LfvkQtR7QgHDhzIa6+9xptvvgloXTaKi4t55plnuPnmm2s8QCHEGWzeDOPHw+7dWkLhoou09Q8/HNi4hBBC1CtlXW87R4cRajaQVeigxO0lxGQg1mrB7vI2mK639VHZEJT0Y4WEBRn9ujerqkpWoYOE1tY6G4JSdqFiMem5vF2zCjU3ip0enG6lQVyoCNFU1LfvkQtR7W+Wv/3tb9x444306NEDh8PB0KFD2bdvHy1btuS9996rjRiFEOWdOAFPPAFvvaUVdAwPh507TycYhBBCiHLKut463HoysorIK3H5ajAcK3DQrmUITo9X7mifJ71eR0qvaI4VlrIvVxtDHWw2UOryklXooHmomYE9o+tsCEr5C5XOUWFEBJ8u5tjQLlSEaCrq2/fIhaj2EIn4+Hh27NjBk08+yaRJk7jkkkt4+eWX2bZtG1FRUTUa3MyZM9HpdH6Pbt26+bY7HA7GjRtHixYtCAsL47bbbiMnJ8dvH5mZmQwaNIiQkBCioqKYMmUKHo//CXTdunVceumlBAUF0alTJ5YsWVIhloULF9KuXTssFguJiYls2rSpRt+rEOfk9cKiRdClC/zzn1pyYdgw+OUXkN5DQgghziDUbMTlUdiamU9ukQOLSU+zEDMWk57cIgdbfsvH6ZE72mUUReVwXgkZ2TYO55VUaehIp6hwRvZrR684KwUlbg6dsFNQ4iahtbXOp5Yru1BpHmpmX24xRQ6tqGeRw82+3OIGdaEiRFNSn75HLkS1ziRut5tu3bqxYsUK7rnnHu65557aisunZ8+efP31175lo/F0yJMmTWLlypUsW7YMq9XK+PHjufXWW/nhhx8A8Hq9DBo0iJiYGDZs2EBWVhbDhg3DZDLx0ksvAXDw4EEGDRrEgw8+yDvvvMPatWsZM2YMsbGxpKSkAPDBBx8wefJkUlNTSUxM5LXXXiMlJYW9e/fWeFJFiEp5vXDVVVCW2OrTB15/Hfr1C2hYQggh6r/YCAtOt0J+iZs2zYLRn5qyOMhowBSiIzO/lGiPIrMKoM1Dvyo9m11HCylxeQgxG0lobeXGXjHn/HHfKSqcDteFcbSgFLvLQ6jZSOvI4IBcyJddqHyVnsOB48Xk2BwEGQ0ktLYysGd0g7lQORdFUevF5y1ETalP3yPnq1oJBpPJhMPhqK1YKmU0GomJiamwvrCwkH/961+8++67/OEPfwBg8eLFdO/enR9//JErr7yS1atXs2fPHr7++muio6Pp06cPzz//PFOnTmXmzJmYzWZSU1Np3749c+fOBaB79+58//33zJs3z5dgePXVVxk7diwjR44EIDU1lZUrV/L2228zbdq0OvokRJNmMGgFHH/5BV58ER54QFsnhBBCnEPZrAKRwSbyS9yEWYyYDHrcXoVih4fIELPMKoCWXHjt6338kl2EV1UBFdBx8LidjOwiJiZ3PueFuV6vqzefYWO4UDmb/blFvgSKw+PFYjTQsVUYKb0aTwJFNE316XvkfFR7iMS4ceN45ZVXKgwzqC379u0jLi6ODh06cM8995CZmQnAli1bcLvdJCcn+9p269aNNm3akJaWBkBaWhoJCQlER0f72qSkpGCz2di9e7evTfl9lLUp24fL5WLLli1+bfR6PcnJyb42Z+J0OrHZbH4PIarE7YZ582DLltPrnnpKSzD89a+SXBBCCFFl5WcVaBVuweFWyC9x4XArRMmsAoB2J/zdjZnsOFyAV1EItxhpHhpEuMWIV1HYcbiAdzdmNriZNsouVLrFRBDfPKRRJRcW/3CI9GOFRIaY6NAyjMgQE+nHCln8wyH25xYFOkQhmqxqD7bbvHkza9euZfXq1SQkJBAaGuq3/ZNPPqmx4BITE1myZAldu3YlKyuLZ599lmuuuYb09HSys7Mxm81ERkb6vSY6Oprs7GwAsrOz/ZILZdvLtp2tjc1mo7S0lPz8fLxeb6VtMjIyzhr/rFmzePbZZ6v9vkUT9803MGEC7NkDV14JP/wAej2EhWkPIYQQohrKzyrQt21kpbNINPVZBY7kl/Djrycx6KBFWJCvgnuQ0YA5TE+OzcHGX09yJL+ENi1Cz7E3UZsUReWr9Bzy7C46R4X5/lbhFhNhQUb25RazencOHVqGNZqEihANSbV7MERGRnLbbbeRkpJCXFwcVqvV71GTbrrpJu644w4uvvhiUlJS+OKLLygoKODDDz+s0ePUlunTp1NYWOh7HD58ONAhifrs8GG46y4YMEBLLrRsCWPHBjoqIYSoYNasWVx++eWEh4cTFRXF4MGD2bt3r1+bQYMGVSjU/OCDD/q1kULMdaNsVoF9OcX89Fs+6cds/JJdRPoxGz/9ls++nGI6RYU16VkFfj1hp7DETUSIyW96ONCmZLeGmCgodfPrCXuAIhRlyqZdjbVaKv1bxVotvmlXhRB1r9qp6sWLF9dGHFUSGRlJly5d2L9/PzfccAMul4uCggK/Xgw5OTm+mg0xMTEVfmSUzTJRvs3vZ57IyckhIiKC4OBgDAYDBoOh0jaV1YYoLygoiKCgoPN6r6IJcTrh1VfhhRegpETrrfDXv8Jzz0GzZoGOTgghKvjuu+8YN24cl19+OR6PhyeeeIKBAweyZ88ev3Zjx47lueee8y2HhJweUyqFmOuOXq+jW2w4n24/SpHDTYtQM9YQE6UuL7+esBNuMdE1JrzJ3+1VdaDjTJ9B0/5s6pOyaVdDzJUnxILNBnJsjiY95EeIQKpyDwZFUXjllVfo168fl19+OdOmTaO0tG4zg8XFxRw4cIDY2Fguu+wyTCYTa9eu9W3fu3cvmZmZJCUlAZCUlMSuXbvIzc31tVmzZg0RERH06NHD16b8PsralO3DbDZz2WWX+bVRFIW1a9f62ghxQT74AJ54QksuXH01bN0Kf/+7JBeEEPXWqlWrGDFiBD179qR3794sWbKEzMxMtpSvG4OWUIiJifE9IiIifNvKCjH/97//pU+fPtx00008//zzLFy4EJfLBeBXiLl79+6MHz+e22+/nXnz5vn2U74Qc48ePUhNTSUkJIS33367bj6MBkBRVDKyioi1WujQIhRFBVupG0WFDi1DibVa2Jtd1ODqC9Sk9i1DiQw2U1DiRlX9PwdVVSkscWMNNtO+pQyPCLSyIT8lZ0gglLq8BBkNTXrIjxCBVOUEw4svvsgTTzxBWFgYrVu3Zv78+YwbN642Y+Oxxx7ju+++49ChQ2zYsIG//OUvGAwGhgwZgtVqZfTo0UyePJlvv/2WLVu2MHLkSJKSkrjyyisBGDhwID169OC+++5jx44dfPXVVzz11FOMGzfO17PgwQcf5Ndff+Xxxx8nIyODRYsW8eGHHzJp0iRfHJMnT+af//wnS5cu5eeff+ahhx7Cbrf7ZpUQotrKdwG+5x744x/hv/+F9euhd+/AxSWEEOehsLAQgObNm/utf+edd2jZsiW9evVi+vTplJSU+LYFqhBzUyzAXNalvHNUGJe3b05ShxZc0b4FSR1acHm75nSOCmvyXcrjm4VwZfvmKKrKSbsLp8eLoqo4PV5O2l0oqkpSh+bEN2u4ld0bi7IhP1mFDhRFwVbq5kSxU0uaKQpZhY4mP+RHiECqcmrv3//+N4sWLeKBBx4A4Ouvv2bQoEG89dZbvvmUa9qRI0cYMmQIJ0+epFWrVlx99dX8+OOPtGrVCoB58+ah1+u57bbbcDqdpKSksGjRIt/rDQYDK1as4KGHHiIpKYnQ0FCGDx/u112zffv2rFy5kkmTJjF//nwuuugi3nrrLV/XS4C77rqL48ePM2PGDLKzs+nTpw+rVq2qUPhRiHMqLYVXXtF6LWzdCsHB2owQn38e6MiEEOK8KIrCxIkT6devH7169fJdsN9+++1069aNuLg4du7cydSpU9m7d6+vGHSgCjE3xQLM5buU63Q6IoJNftulS7k2jGTolW3ILXbyS04RRY7Tn4VBr6N3fCRDEts0+WEk9YFeryOlVzQ/Z9v4ak8O3nI9bwx6HV2iwxnYM1r+VkIESJUTDJmZmdx8882+5eTkZHQ6HceOHeOiiy6qleDef//9s263WCwsXLiQhQsXnrFN27Zt+eKLL866n+uuu45t27adtc348eMZP378WdsIcUaqCv/3fzBpEhw6pK177z0YNSqgYQkhxIUaN24c6enpfP/9937rR44c6RsSkZCQQGxsLAMGDODAgQN07NgxEKECWgHmyZMn+5ZtNhvx8fEBi6culO9SHm4xVdguXco1naLCmZjcmS93ZbH5UD7FTg9hQUauaNecGxNi6BQVHugQxe+dyi3oUFHR+ZaFEIFT5TOJx+PBYrH4rTOZTLjd7hoPSohGZe9eeOQR+OorbTk+HubNg1tvDWxcQghxgcaPH8+KFStYv379OW82JCYmArB//346duwYsELMgSjArCgqRwtKsbs8hJqNtI4MrtO7q2VdytOPFRIWZPSrvK+qKlmFDhJaW6VL+Sk6dASbDCioBJsMgQ5H/E7ZNJVeRSWlZzTFTi8ur4LZoCcsyMD+43aZplKIAKpygkFVVUaMGOF3UnY4HDz44IOEhp4ueFPW9VGIJs/rhSef1GaIcLvBbIYpU2D6dAiVIlFCiIZLVVUmTJjAp59+yrp162jfvv05X7N9+3YAYmNjAa3I8osvvkhubq5vtofKCjH/vhfimQoxDx48GDhdiLm+9Drcn1vEV+k5HDhejMPjxWI00LFVGCm9on13xGs7AVHWpfxYYSn7crXp/YLNBkpdXrIKHTQPNUuXcrS/1eIfDpFnd9G6WTAhZiMlLg+7s2xk2RyM7NdOejHUA+WnqdTr9UQE+w/VLj9NZXxzqZkhRF2rcoJh+PDhFdbde++9NRqMEI2KwaD1XnC74eabYf586NQp0FEJIcQFGzduHO+++y7/93//R3h4uK9mgtVq9bWZPXs2f/nLX2jRogU7d+5k0qRJ9O/fn4svvhjwL8Q8e/ZssrOzKy3E/Prrr/P4448zatQovvnmGz788ENWrlzpO87kyZMZPnw4ffv25YorruC1116rN4WYy1+wxlothJiDKXF5SD9WyLHCUkb2awdwzgRETegUFc7Ifu18x8qxOQgyGkhobWVgz5o9VkNUdlc8z+6ic1SYr5dHuMVEWJCRfbnFDfKuuMejsPVwPiftLlqEmrk0vhlGY+3UTqsrMk2lEPWbTv39XDyi1thsNqxWK4WFhX5TdYlGJD0dWraEsq65hw7Brl1wyy0BDUsIIWpS+S725S1evJhbb70Vq9VKv379+Pnnn7Hb7cTHx/OXv/yFp556yu/899tvv/HQQw+xbt06XyHml19+GaPx9P2PdevWMWnSJPbs2cNFF13E008/zYgRI/yO+/rrrzNnzhxfIeYFCxb4hmScS22dmxVF5Y11B0g/Vuh3wQpaD5B9ucXEWS2UuhXyS8oSENod87JeBWV3zGuyh0Ogh2vUV4fzSpi35hciQ0yV1qkocrgpKHEz6YYuDeau+Nqfc1jywyEOnbTj9iqYDHratQhlRL92DOjecAuVN8a/lRC1rS6vQyXBUIckwdCIFRbCzJnw979r004uXRroiIQQIiAa2rmutuI910WQrdTFxoP5tAo30/uiyEoTEAmtrSR3j2bNntrv4dDUZWTbWLB2Hx1ahmGoJOHiURQOnbAzYUBnusXU//+u1/6cw6wvMyhyuGkRavYNiTlpdxFuMTH9pm4NNslQleRdQmsrD17bUZJnQpxSl+fmpl0uWIgLpSjwn//A449Dbq62zm4HjweM8s9LCCGaqnN14/YoKoWlLrpGh1XoEaLT6Yi1Wtiamc/e7CJcXuWMQywkyVAzGtNMGx6PwpIfDlHkcNOmWbBvOvlwi55Qs4HM/FKWbjjEtZ1bNcjhElJTRIj6reF9qwhRX2zdCldfDSNGaMmFrl21mSI++kiSC0II0cSVv2CtTJHDA6o2xl9VVWylbk4UO7GVulFVFYtJz+G8Ek7anXSOCiPcYsKg1xFuMdE5Kow8u4vVu3NQFOmIWhPKZtrIKnTw+869ZTNtdIoKaxAzbWw9nM+hk3ZahJp9yYUyer2eFqFmDp6ws/VwfoAivHBlNUV6xVkpKHFz6ISdghI3Ca2tkngTIsDkKkiI8/HRR3DnnaCq2owQzzyjTUVpNgc6MiGEEPXAuaaGzC9xERliosjhZl9uMfklLjxeBaNBT7MQMxEWAyUuL3HW4DP2cDifSvlSg8Gfy+VldUY22YVOLCY9Vouhwd8VP2l34fYqBJsrn2Iz2Gwgz+7ipN1Vx5HVrE5R4XS4Lkz+exainpEEgxDn44YbIDoa/vAHmD0bWrcOdERCCCHqkXN1424dGUyLUDObD+VjNuoJt5gwWYy4vSq5RQ5+PeEh2GSgVXhQpfs/n0r5VZkysyn5T9oh3vrfQY4XOfCqKgadjsgQEz1iIygocTfYmTZahJoxGfSUuryEBelweRTf+zMbtfUmg9aToaHT63VSyFGIekYSDEJUxY8/arUWXn8ddDqwWrUZI1q0CHRkQggh6qmzTQ2Z3COK9zcd1hqqKqACOu3/VRU9YNDrKHF5iQiuOKK1ujUBqjJlZkO5gK4J/0k7xJyv9uL0eAkxGwky6nB6VE7aXWw6lM+Ya9ozsGdMg7wrfml8M9q1CGVPlo1CowuHR0VRVfQ6HRajDodHpWdcBJfGNwt0qEKIRkgSDEKcTW4uTJsGixdry/36wdCh2nNJLgghhDiHM3XjPlpQSkGJm8vbNSOrwEFOkROPomDU64mOsBATEcTeHDu/niiudJaJrEIHCa2tVaoJoCgqX6XnkGd3+aruq6qKqkKzEBNH8kv4Kj2HDteFNagL6fPlcnl5638HcXq8NA8x+eoUhJjBYtSRV+Lmk61HefCajpjPMMygPjMa9QzsGc2OIwUUO7xYTAaMBh0er8IJh5cgk4EbekQ3yAKPQoj6TxIMQlTG44FFi2DGDG0KSoCRI2HAgMDGJYQQosGprBt32SwTkcFm0Gl9F1BP/T9gMRtpGWYmNMh4wTUBjhaUcuC4tg+AzDw7vx63U+z0lPWZ4HjRMXrHW7m6c6uafOv10uqMbI4XOQgxGystghhiNpJrc7A6I5s/Xly9IZD1ocaFoqjYSj1c1DyYIye0v7Oqah0wQ816LmoeTJHDg6KoDT6hVB8+byGEP0kwCPF7330HEybArl3a8qWXwsKFcOWVgY1LCCFEoxFqNuLyKGz5LQ+vohIebMJk0OH2qhwvcpJndxHfPIQhV7Rh5+HCCkMsqlMToCyZ4XDr2fqbNsOA26tiNuoJMRsIDdKK/r27KZMYq6XRD5XILnTiVVWCjJVfiJoNOuxOlZ2HC+l9UbMqX7TWlxoXRwtK2XY4nxKnF4PRQDA6VFR06DAY9JQ4vWzNzK92gdD6pr583kIIf5JgEKI8RYGHH9aSC82bw6xZMHo0GBpeF0khhBCBc647q7ERFpxuhYJSN22aBeP2qjjcCgadjmYhJjLzS4n2KCS1b0G/ji0v6C7t6WRGPseLnagqRAQbUVQocXlxuL1EWEzYnR5W786hQ8vGPVQixhqEQafVXAj5XZ1Dt1ebMtSrqGw6lMeJYleVLlrrU42LIuepmUnsLq3ugsmATqeiqjo8ikqe3cX+3GKKnO46iac21KfPWwjhTxIMQrhOTdNkNoNeD3//O7z3HrzwgtRZEEIIUW1VubOaZXMQZNITbDJw4IRdq/N4ik4HERYTZqOeLJuD+OYhF3SnuSyZcdLuAlXFYjagQweqikEHdpeXULOR9i1C2J9bzK85xfxw8DhH8x20bmbhrkvbYLE0np+MA7vFMCf8F7JtpViMOt8wCbdXpajUhdOrEmY2kNS+BU6vcs6L1spqXACEW0yEnRriUpeJG1upmwK7C6+ioqBQ4lJ9QyTMBh0qOvLtLmylDTPBUN8+byGEv8ZzthDifKxZow2HGDYMnnhCW9e/v/YQQgghqqmqd1btLg8uj4JRrwNVu2jydWPXaw+XR8Hu8lzwOPOyZEZYkJHjRU5Awe5RcCsKigo6nQ6b00NeiZs9x2wMfmMDpW4Pigp6Hby6ej/DrmrLowO71t4HV4fMZgNjrmnPnK/2klfiJsRsxGzQYSt14/SqmPQ6+rZrhtlkwGwynPOitXyNi/LFOEH7bGOtFvbnFtfZkIRSlxe3ouJ0e1FUrcZGGbdXRa8Di0mr59EQ1bfPW4ia5vEobD2cz0m7ixahZi6Nb9agirJKgkE0Tb/9BpMnwyefaMtvvQVTpoDJFNi4hBBCNFjVubMaYjJwothJidtLsNlAkcODVwGDnlPFHD2cLHaSa3Owdk/uBY0zt7s8mI16Lr4okvX7jlPkcKPCqWkL9ZgMepwehe/2HqfQ4QEgyKDDoAevAjanm9TvDgA0miTDfUntAHjrfwc5XuTA7lTxKlrPhb7tmnHxRaencDzXRWtZjYsQc+UzegSbDeTYHNhdnlp7P+WpgFdR8J7KLOjwTYCqbVPBoyh+iYeGpPznraoqRQ4PLq+C2aAn3GKs889biJq09ucclvxw6FStHAWTQU+7FqGM6NeOAd2jAx1elUiCQTQtDgfMmaPVVigt1WorTJgAM2dKckEIIcQFqezOqqIoHCt0kGd34fGqbMvM50h+CSrg9CgU2N14FeVUexWvouNEkRODXo9Br+ejLUdwe9ULGmceajZiMRpQFAWvx4tHAT2g6lUURUFnNGA26Mgv1S7Igo1gNGh3ywx6MCoKJR6V/6T9xrj+HRvNcIn7ktpx12XxrM7IZufhQjYdyiOpfQvMpop1l8520Vr2+Za4PIRbKv6WKHV5CTIaCDXXzedm0evxnMou6DmdWChbVgCPV8Wibzh3RMsr+7yPFZSQVegkv8SFx6tgNOhpFmIm1hpUp5+3EDVl7c85zPoygyKHmxahZt/MQb/kFjHrywyABpFkkH95oulIS4N774Vff9WWr70WXn8devUKbFxCCCEahd/fyT54opiNv57UkguKdhfZoNd6Otx5RbzWld2rAGDUaz0KFFXrNeD1eCkocXGy2MVlbZtd0Djz1pHBRIaY+HTbUYpd2p1rL9px3IpKidvlN6NCZVM3mvUKRQ43H2zNZPhVHWrsMws0s9nAHy9uTe+LmnGi2IXTq1SaYDhbkqB1ZDAdW4WRfqyQsCCjX7d9VVXJKnSQ0NpK68jKezjUtCOFpcDpKU8N5f6cinJ6fVm7hqZ1ZDCRwSbW/JyD2agn3GLCZDHi9qrkFjk4kl/CwB7RdfZ5C1ETPB6FJT8cosihFf4t+x4Ot+gJNRvIzC9l6YZDXNu5Vb0fLiEJBtF0tGwJR45A69Ywdy7ceadW8UgIIYSoAeXvZJ8odvL1nlxK3KfHuatoF3jr9x3nWEEp+SUujAYw6PW4vVoXfZ1Oh8Wkx+1VcLi9WIO1O+K2UrdfN/DqjjPPzLNjOzU0oqy7fPm4HB7/O96/Z9CDywtH8x3n+enUbxeSJNDrdaT0iuZYYSn7crUeLGV3HrMKHTQPNTOwZ3SdFRx0eRWtjodOh9eroqqnizzq9LpTdT9UXKeSWw3SqY9SVRScHi9urw5FVVEV7T011OEfounaelibQrhFqLnSJG+LUDMHT9jZejifK9rX7yL0kmAQjZfdDqtXw1/+oi137gyffQb9+kFYWGBjE0II0ei0jgymQ6tQNh08yY4jhX7JhfLcCmTkFANaEUU9XnR6KLv0VxRt3L+qqtidHjYfyq/QDbxdyxCcHm+Vxpln5tnZcbgQo06HgnrWiy+F03e4y/MqWqytm1nOebyG6EKTBJ2iwhnZr51v9pAcm4Mgo4GE1lYG9qx6vYya0CkqjGCTAbdXwWzW4/IovgRDkFGPV1ExGQ10imqYv4WOFpRSUOKma0wYv2QXcyK/FK+iYtDriAw20TUmjIIStxR5FA3KSbsLt1ch2FyxBxVow7Ty7C5tNqB6ThIMDZjHo/BTZh6/5BRhd2o/MELMRpqFmunQKhSrxexXafpCq1Cfj+ocs6xtkcNNsdNDmMVImNmICpS6vVWOWfEqnPz3u4Q/OY2g7GPkfPUtUQP6a69LSan0NQ29WmtNCcR/I0II0Vj8eqKYvGIXe7NsFJae/cK/7CLfq2rDFfCC2aDdaXYqKnqdDp0ODpywYzHqCSvXDfx4kYM8u5P45iFVGme++VA+xU4PoUEGXCXnTkgoXgW98fSPXEVRcCkqVouJuy5tc87XN1RlSYJVu7LZdbSQEreHEJORiy+yktIr5pxJgk5R4XS4Lizg59G+bZrTKSqM9GM2vB7/JJfL4wWdnh7RYfRt07xO46op9lM9hE7aXZiMei6KDEanB1UBp1chq9CJy6NKkUfRoLQINWMy6Cl1eQkL0mYR8qoqBp0Os1FbbzJoPRnqO0kwNFBrf85h0bf72ZtThN3p9bsbYdBpYzS7x4ZzdadWpPTSioGca07umlaVecB/33bb4XwyT5ZQ6vae6t4HQSYjLcPMtAwLOmfMv33/E95xE+iw80cAsiKjmf9/2whxtGRoYptKX9cYqrXWhOr8vYQQQvgrm54yt7CU8+14XjZroEkPXkWbTtDh8hIbEeTrMhtk1GEKMZGZX0q0RyE24tw9ChxuL6p66v+rEEepF4JQfLNIuBRt6sb7kto2mgKPZX6fWFfKunCU5QR01etur9frAn7X3GjUM/iS1mRkF+FwazHp9Zyq76ESbNLx5z6tG+yNlGCTgRPFLuxOD9ERQX7DWcJUlRybE1XV2gnRUFwa34x2LULZk1VIoVFPiet0giHErMfhUegZZ+XS+Gbn3lmANa6zRBOx9uccnv18Dzk2B25vxWmGvCoUOdykH7Xh8ij8nG3T1isXVoW6Oqo6D3j5tpl5JRwvcuBVFMxGHblF2gkiwqKg00HLMPOZY7bZyJ/2FBe9uQiD14vTaOKTG+7l4+QhnPAY8O7JIbfIycTkzn6vayzVWi9Udf5eQggh/JVNT5l24DiHTpx/gqGM+9QsDwaDnvBgI/klbsIsRkwGrTZDscNDZLAJs1FPls1xzgvaztFh6HVQ4j77pXLZ5WaQUYfLq+LyasMirBYT9yW1bTRTVJbZn1vElzuz2HwonyKXGwPa+7aGGImNCKZZiBlFUUk/aiOr0NFgzoWKomIr9dAtJpwcWykFJR5tWIRBR2S4iegIC0UOD4qiNsheilrEKrozpn60bQ3vnYmmzGjUM7BnNNsOF1BQ4sRQbn5ZmwOCzUZu6BHdIBKDkmBoYDwehcXfH+RksRNUBeUM362qCg6Pl1ybg8JSF3qdnpSe0eUqkla/CnVVVWcecNB6VpwsduHxKHi8Ki3CgjhW4MCg06HT607dwfGQbXNyWZtI9h+3+8esqqjXXEOznTsB+KHnVbx310SOR12EAYhSVU4WO/klW7tD3+E67XWNqVrrhajO36sh/hARQojadrSglHc2/saxwporgKgAqqrQLSacghI3uUVOXy+76HAL7VqGUFjqrlI38D5xkZUXVqjkmHodTL+pG3mlLo7kObiouYX7r+pISEjjmsp5f24Rz6/Yw64jhTg8XhRFK7KpqBAaZOBIWCkGvQ6jXk+zYBN2l6fBnAvLpkvtHR9JqLkFWYUOStxeQkwGYq0W7C5vtQqE1jclbi8tw4I4qYM8u6tC8i3MYqRFaNAZa6AIUR8pisrBE3YsJj0erw6vCmXFU0x6sJj0HDxhbxCJwXp91TRr1iwuv/xywsPDiYqKYvDgwezdu9evzXXXXYdOp/N7PPjgg35tMjMzGTRoECEhIURFRTFlyhQ8Hv8T8rp167j00ksJCgqiU6dOLFmypEI8CxcupF27dlgsFhITE9m0aVONv+dz2Xo4nwPHi9HrOGNywUdVOWl3UeLy4lVVip3+X7Q6nc6vCnVNqWwe8DMds6xthMVIfql2h8blUSh1ewkyGbQxR25tyqg8u4tip7dizDod+aMeICc6numjZzHnodkcj7rI75jhwSa8qsrOowW+11WnWmtjVp2/lxBCiIpWpR+r0eRCGbcXip0eVFWl1OXF7vRQ6vKiqNoME2eaNvH3th8rqHI/f0WFHZn5bD1UyIETxWw9VMi/Nhxkf27Rhb2ZekRRVBZ9s59NB/Mocnhwe7TkgkfReoHaHNoUoc2CzVhMeo4XO8m1Odiamd8gzoWnp0s1otfrad0shM5R4bRuFoJeryfYbKhygdD6KNRspGVYEF2jw4kKt+BwKxSUuHC4FaIiLHSNDqdlWFCV/m0IUV8cyS/hx19PEmbWisN2ahVG25ahdGoVRkJrK6FmAxt/PcmR/JJAh3pO9TrB8N133zFu3Dh+/PFH1qxZg9vtZuDAgdjtdr92Y8eOJSsry/eYPXu2b5vX62XQoEG4XC42bNjA0qVLWbJkCTNmzPC1OXjwIIMGDeL6669n+/btTJw4kTFjxvDVV1/52nzwwQdMnjyZZ555hq1bt9K7d29SUlLIzc2t/Q+inJN2l29aIbUKPxa8qopXBR2VT0dUGyeZ8ie2ypQ/ZllbvV6HR9HuzHhVFeXUmCODTpseSq/Ttru8CpHOYv70r1noP/nYt8/cO4YydeZ/2dT9SkyGilk9k0GbeKvEdfq9VqVaq9urNIhqrReiOn8vIYSojwJ5A8DjUVi07kCt7FsBtmcWsP1wAblFDgpL3eQWOdh+uID1+04QGWKqdNrE39ufW0yJu+oDN778OZefMvPIyCrip8w8lqQd4vkVexpNkuG3PDvf/nIcl0dBUbXkglvxz8HYSj24PFoSp3moGY9X4XBeCUUOd8Dirqry06VqNSZK2J9bxNGCEhRFS1ZVNTlVH5VNKVrqVri0TSS9WkfQJTqcXq0juDQ+klK3QqeosCr92xCivvj1hJ3CEjcRISb0ej0RwSZahAYREawtW0NMFJS6+fWE/dw7C7B6/c2yatUqv+UlS5YQFRXFli1b6N+/v299SEgIMTExle5j9erV7Nmzh6+//pro6Gj69OnD888/z9SpU5k5cyZms5nU1FTat2/P3LlzAejevTvff/898+bNI+XUrAOvvvoqY8eOZeTIkQCkpqaycuVK3n77baZNm1Ybb79SLULNmA3alEO6309kXQnfRTo6zIaK+aTaOMmUP7GFWyp2qfz9MS1GA4qiYtRr3dsMOh16nQ7vqQyKTqfNbWwCEr/5lAH/fo1QWz6ePRvgvjshKIhQi5mgkBCwF+P2qgQZ/ZMMbq9WtSnEfPq45au1hlsq/2waSrXWC1Hdv5cQQtQnZTcAUlNTSUxM5LXXXiMlJYW9e/cSFRVV68ff/Fse+VWYmeF8FTm9/P5071VU3CVuDued+4emx6OwL7egWscsdSkY9doxdYDLo7DpYD5vfLufOXf0qffdc89l08E8bKVuFPX0e/w9rwrHi51EhWsV3INMBoocHoqd9T/ZXnYB/s3eHHIKHRSUuv2mcYy2WhjQLbrBXoCXTSn6c7aN1XtyTv1e1P6SBp2OLjHhZ51SVIj6StWB7ozj2RrOf88N6oqhsLAQgObN/afVeeedd/jvf/9LTEwMt9xyC08//TQhIdqYsrS0NBISEoiOPl2oLyUlhYceeojdu3dzySWXkJaWRnJyst8+U1JSmDhxIgAul4stW7Ywffp033a9Xk9ycjJpaWlnjNfpdOJ0On3LNpvt/N54OZfGN6NjqzC2HS7gnN+bOh0tQs0EmfTodTrCgvzv1KuqSlahg4TW1ho9yZSd2NKPFRIWZPTrdl/ZMTu2CmPX0UKaBZs4XuykeaiZYJOBYqcbnU5HqNlA+193M/mz1+l0aA8AeW07EflWKgQF+Y6Z0NrKwZN2ihxuzKFm33FVVaWo1I1Br+fi1pG+45ZVa/0lt4hQs8FvmISiaD0XukaHN4hqrReiun8vIYSoT2rsBoDdDoZKerQZDGCx+Lcr5+V3vyP4VEc3RafDaQrybQt2nXnYxO/bWtwOdGeqq6QDh+l0DEFuB3oVdu/LJvNwLu1O1TRSFJVjhQ6KjWZCzUb2Ztt4d91ethw8QfAZhqOXmsvv14n+VHK/fNq97CL8273H+S3PTvuWYeBwgLfynSqKylG3/vRUjRYdevUsPShCQqDs3ON0gucsF/HVaRscDGXndpcL3FrvgxM5JzE7/f82DpMZVae1NXndGL1eSvKdHC8pwWLUo9fraGYyEK44tfdd9t9Kuf1WymI53dbt1tqfSVAQGI3Vb+vxaJ/FKXqgOS4yM09Q6vLgNhjxGLS2LocLZ2Exzbo2Q19aSVdrsxlMp242eL3a3/lMTCatfXXbKgqUnmWoSRXa6ux2zI5STF4XXr0JbboPFYvbgdlhRGe3g/13N4+MRt/vRlQVSs7S1fwc/+7Pu61er/13eT5tS0rO3H1Zp9P+bZxP29JS7XM+k9DQ82t7lu+Iaret4++IC25b/t99Fdu2bxlKC7MeR4GNiPCgCr/HC4qcNAsJpn3LU59bdb8jzvbfWg1rMAkGRVGYOHEi/fr1o1evXr71Q4cOpW3btsTFxbFz506mTp3K3r17+eSTTwDIzs72Sy4AvuXs7OyztrHZbJSWlpKfn4/X6620TUZGxhljnjVrFs8+++z5v+lKGI16Rl7dnsxTs0joUSqtVq3TaT0DoiIsxJ66MNx/3E6s1eKbKSGr0EHzUHONZ3nLMsvHCkvZl1t8zmOWtbW7PBj0Ok4WOwky6Sh0qFiLC5jy3b+55acv0asqpZZQvr37Ibq8MJ3mrZv7HfPGhBgycorYcbiAHJsTa4gJUCks0e5S9I4LJ6XX6eMajXpG9GvHrC8zyMwv9ZtF4qTdRYTFxPCr2jXqAo9Q/b+XEELUF+dzA+CMyf+4uMoPcvPNsHLl6eWoKL8Lk/8r1/TH+F7cPfRl3/L3qaNoUVr5zYUdMZ358/B5vuWv3/orF9kqH3b5S4s2DByzyNeT4bOlk+lyMlPb+OLpdnogpGUsL732Ofl2F7/kFPPv1PH0PPZLpfs9GRzBZQ+/61teuuwZrjycXmnbElMQCY9+zE+H8rQEw223wRdfVNpWD8x7f5tvyuO/LppOp/WrKm0LQHHx6YuNBx6ApUvP3DY3F1q10p5PngyLFp257cGD0K6d9vzJJ+FvfwNg3KlHeTeMWsi+Vm217WkfMvGH9yrf53Rg0ya4/HJtef58ePzxM4agrP0G/R+u1xbefBPGjz9zvCtWwKBB2vN33oFTSbNKffgh3HGH9vzTT+HOO/02Dzn1AHjs5ol8lKDdSOv/61YWf/QsvEzlXn8dxp36dP73P7j++jPHMHs2TJmiPd+6Fa644sxtn3kGZs7Unv/8M5T7LV/BY4/BnDna88xMaN++QpOOwKvA9j8O4f/GPqkNoS0uYMqwP5x5v8OHQ1mNtZISCAs7c9vbb4dly04vn63tOb4j/Fx7Laxbd3q5XTs4caLytn37wubNp5d79IDffqu8bY8esHv36eXLL4c9eypv27YtHDp0erl/f/jpp8rbtmwJx4+fXr7pJvjuu8rbhoT4X8Se5TsC8E+A3HcffPTRmdvW8XdEpdLToWdP7flLL8HZrvGq8R3Bt9/CddcR3yyEh/au5eY3Xzxj0/eeXkh8s+u0hQv8jvj/9u48PIoi/QP4t3vuK5P7JAchyBlOJQblUFBQ1gXFlWVBQVlQF0TFA9kfiou7C14r6iq6K5cHiu4quqBo5BARBDkCAiGQkHCEXOSamcw9Xb8/hmkyySSZIeeE9/M8eSDdNd1V3ZOu7uqqt9pS0DQwzJ07F0ePHsWuXbu8ls+ZM0f8f3p6OuLi4jBmzBjk5+ejR48e7Z1NL4sWLcKCBQvE3w0GAxITE1u8Xc+0iW9vz0NuqRFmm8urkUHCuWcA6BOnw4ieUbi1nzv9t0dLkV9uQqnBCoXUHUDk1n4xbTLlUlq0DvffkOLXPuumPXSuCmcrzbDYXYjQKHDdhXOY+Iv74vTLiAk4Nv/PuHFkus88p0Xr8NjYnlj/81n8XFDpnmkDQKhKhozUCPwhI6nB5zzHcu1PhSisqEVlrR0yCY9eMTrMGJ5yVUxRCQR2vgghpLO4ePFiwC8A2qLxvz142niba+rleQ4p4Wpkn62Cyda68QJcDCj2M8hhqFomTnlcY+n8cQvaypfZF5De39ih9SgPuIe8+BnoM6hwHEJU7h4XKmfXmumEXF14nsN13ZvuNT2qV1RQvPDjGOv8l5t58+bhyy+/xM6dO9HdRytmXbW1tdBqtdiyZQvGjRuH5557Dl999RWys7PFNAUFBUhNTcXBgwcxePBgjBw5EkOGDMGKFSvENGvWrMFjjz2Gmpoa2O12qNVq/Oc//8GkSZPENDNmzEB1dTW+/LLu+4vGGQwG6PV61NTUICQkJJBD4JPTKWD/2UqcLDWi9tKYQLVcijCNHKlRGuiVciSEqsQvojvQj+Vyl8U669pKIPv0pDWfK0JNSDi0Sim0cin0f3se1aPGgh8xwq88CwLDuSozCi4FQUmN1KBbmLrJzzmdAg6eq0JFrR0RGjmGJIZ1+Z4LvnTEd4QQ0rW0dl3XlAsXLiAhIQG7d+9GZmamuPzpp5/GDz/8gL179zb4jK8eDImJiai5cMF3fpvp/tzn2ctv5ttqiATHew+RUDqs8Iw4+OONKdAqZDhebECPaA04jscZC8N3x0shl3CQ2m2oaSJYcWNDJBpL+8y4a/DQTT0bdGkWBIZ/7zwt5sOlutz9mbdZcbrEgH7xIfjjiNSG9Uo7d3/emlOCeeuzvZL6GiIRpZUhRCmDAHecqG7havz5tj7oFh/eoPtzfpkRH/x8BlW1DsTqFVDLpTDbnThnYQjTqXD/DSlIC1O2yxCJ9XsK8devT4ABkEk4OOsMkeAFFzibHRyAxbf3xh8yU7y3GwRDJHJLDVi5PR/dIzXgpDK4PGkZg9RqgYsJOHPRjIdu6oFeMXX+pmmIhO+0NETC/f8OHiIBAHlFlXjxqyM4VmSAzekCE9zXf4VUgn4JIVg4cSDS4i81QgR4jTCUl0MfH98udXOn7sHAGMMjjzyCL774Ajt27Gi2cQGA2JAQFxcHAMjMzMTf/vY3lJWVicGesrKyEBISgr59+4ppvq7XhScrK0u8WZHL5Rg6dCi2bt0qNjAIgoCtW7diXlNd3dqYVMrj+tRIXJ8a6Vd6nufafb7jQPbJl5YgceFCYONG4MQJIC7CveIfL0Mf4D6TIzRIjtA0n/gSqZTHsO4RAeyla+qI7wghhFypyMhISCQSlJaWei0vLS1tNPizQqGAQqFouEKj8b7hbUy9NHUf0Otral19dRsQfOE9gRAYYJZeTivRaZBbaUVETBhclwL1mg1GuAQGmVwCQaWCxeFfg3ndBo/GaJSXbpqV3vktqjQj1yR45cNDUCgRESPBCaMDRQ6+6XpGobj8ENicQNLK5eJDq0mqaPLcOCQyOCQyXHAAleAQppZjQGKo+7MyhXesDrkcglSGLQXFKHVJ0TMp1B2cGoBSDaTpGU6VmfDdsVKkjuoBXuPnW3aZ7PKDfnOk0ssPEgDOO3iY5UrwAFz1ZtYSeAmcciWES+ma/M5LJP79TQSalm9mv82kVYdy4LVa1PAy6OR1jhHHwalSw2h1gNPyUIfqAU0j3zWO8z8PQOdIqw7g/iyQtHUbMVozrdL/619AadvhGtERaQWBYf2BYpwwCFDotVDViw13wiDg4wMX8H+xoe5G2kCvEYF811qoU7+inTt3Lj788EOsX78eOp0OJSUlKCkpgeVSS2Z+fj5eeOEFHDhwAIWFhfjqq69w3333YeTIkRgwYAAA4NZbb0Xfvn1x77334vDhw/j222+xePFizJ07V7zBeOihh3D69Gk8/fTTOHHiBN5++218+umnePzxx8W8LFiwAP/+97+xbt065OTk4OGHH0Ztba0YVIq0gMMBvPYa0KsX8MEH7nFW33zT0bkihBDSydV9AeDheQFQt0dDW/r0oUHtsh8BgMAgDonkAKhlPOJC1Q2mGlbLJJDwHByCe8rn1pRT4nuqymCa8rja4vArHrvAACcTYLA6cOyCATan4HNGpaJqC/LL3TGMuHrHm+M4xOmVyCszocjP4SUtFa1XiPE6XC4Gdmn6b8aY+3e4vz/Rej8fvDoZT3Dq4hor6nfE9gSnpmkqSbA5V2XGzwWV7lmCXAzVZgcqa+2oNjvgcLmn091zuhLnqproedNJdOoeDCtXrgQAjB492mv5mjVrMHPmTMjlcnz//fdYsWIFamtrkZiYiMmTJ2Px4sViWolEgk2bNuHhhx9GZmYmNBoNZsyYgaVLl4ppunfvjs2bN+Pxxx/H66+/jm7duuG9994Tp6gEgClTpqC8vBzPPfccSkpKMGjQIGzZsqXBuE8SoG3bgEceuRyI5rrr3AGGmgoURAghhFyyYMECzJgxA9deey2GDRsm3hO01wuAYSkJALLbbPsSAODcD7sePOd+sds3PgQZ3cOx93Sl11TDcXolQlUyVNTawbfyTMtCI72Yg2nKY6u9iS7edQgArA4Gq8MFs92MSK0ccSEN37ReblxRweUSkH/RBJPNBa1Cgh6RWqjkEpQarO3WuNI7NgQqGQ+LQ4ALgKtecTkAKhmP3rFt2026rVBwatIVFVysRbnJCkEABMagkLpnARQYUGt3geM4XDRZUXCxNqBe2h2h46/yTWguPERiYiJ+aCySaR3JyckNhkDUN3r0aBw6dKjJNPPmzevQIRFdCmPAffcBH37o/j0yEli+3B0Nle/UHWsIIYR0Ip3hBUDh8glIeWZz8wkD1C9eB6PVhXKjxWtudAaGaJ0KD49OQ1K4psFUwzzPY1BSKH48dRE11tYNsNgrznewwmCa8rh7hBqBBiBzCEDhxVoU1Vga3Nx7GlcOnKnE0aJqmGyC2EtAqyhH/4RQxOlV7da4cm1SOFIiNThRYvQ5DJ/jgO5RGlybFN5wZZCg4NSkqxEYg83uAngOWrlEvIZKOHeDoMnugtPp7o3U2XXqBgbShXEcEBvrbkz405+ApUuBsKYjpxJCCCG+dIYXAIXLJ2BfYRHueSe7VbY36ppIrHsgA1tzSrFmVwHyy02wuwTIJTzSorWYeUN3caYjX29zI7UKpEZpUFRlgclkg8m/l/ZN0ikkmDo0yee6YHqrbLrCngQXax04WWZo0MCQEKqCweLA3tOVXrN6MQBGm4C9pytxc5/odmtc4XkOvWJ1yC+vhc3Z8MTLJTx6xYR0inPREmnROqSO1lJwatIlaOQSgOPABE/zZF3u5TzHudN1ctTAQNrPN98ACQnApfgYeO45YNo0YNCgDs0WIYQQ0hqGpSSgcHlCwJ8zmGxY+s1xnK+0olu4Es/d1hchWvf4+DF9YjCqZ1STMx019jZ3TO8Y3Nw7GgarA/e8+3Oz+QhRSlFrd4pd6j3j+AFAynOYeUN3KJWN3zoGy1vlw2crr/izu0+V45Y+cV7LnE4B+wor0FgbjgBgX0EFnE4B8nZ4OCiqtsBodUIp5X02MCikPAxWB4qqLRTYmZBOQqeUIVwjR4XJBovdCblMAgnHwcUY7A732LQwjdznELTOhhoYgphnmsrjF2pw+Fw1HIwhMVSNG9MiEaaVw2xzQauQQqeUtel0lc1u7/Rp4PHHga++AoYPh7DzRxTVWFFrZ9AkXYMEgfmdt/acRjHQfdEUj4QQQq5EiFaBV343uNH1/sx01Nzb3OaGcTx6UxruGByPL7Mv4P3dhTBanWBwRwPXqaS4LzMFT9zaq9myBMNb5eONBKr0xw8nLzZYtvnYBRisTUyxB8BgdWHzsQu4c3DiFe/bX0arA4fPVcNg9d1Tw2B14vC5ahhbefhMe8srM4qNWVanC0qpBD2itBjXv/M0ZhHiL51ShrRoLQDAYHHAYneBgYEDBynPIUIrR1q0lhoYSNvZmlOKt7fn4deiatjr1Wnv7iyAUsohVC1HiFKGpAg1BieGYVx/d1fK1rwYN3lx10mBF190x1aw2QCpFFUDh+KTrBycqnE0SN9c3tqzIgl0X1TJEUII6WjNTTVcuHwCDp4txj1vH4QT7gCSL9/TG9elxImNAE/c2gtzR/bAhoNnUVRlRUKYElOGJDXZcyHQfHQ0reLKb38t9W+6AGT9WuTXZ7N+LWqXBoZKsw0VJnujcSYYgAqTHZVmW5vnpa3klRmx5qdCVNbaEadXQi1XwWx34uiFGlyoseD+G1Lo/osElYRQFQYnhqHKbIfTJaDa4oBLYJDw7jgvEVo5hiSFdYo4Ns2hBoYgtDWnFH/533FcqDLD2UjtYXUyVJvtkPEczleZYXMKyCkxAABcAmuVi3GjF/eiaui/24zk9a9Bdu6MO/GYMTizZBn+dVGJyovWBvtvLm83947GthNl7VKRBFppUSVHCCEkWAxJikPe8glNplEqpZgxPLWdctT+bugZie25FVf02e6RDaO3/3Kmxq/P+puupY6cr2l0uIaHcCndjWnR7ZGlViUIDN8eLUVlrR1pURqYbC5Ume3u+CRRGuSV1+K7Y6VIjdR2qp4zhDSF5zn0jtPhi+wiOFzu5yGphIfTJcBgccJgcaJXrC4ovtMUrj/IOJ0C1uwqQLnB0mjjgofVyeB0CXA4BTicLuSWGHGyxIi0KA10ShkkPAedUoae0VpU1trx3bFSCIJ/kUnrXtx7Xuqu49ne+Py9mP7iY5CdOwOWmAh89hmEb7/DJkeYz/RpURqcLDHiZKnvvFWY7Fj7UyEqTLYGn72SvF9puXztK9D0hBBCCOlY069NgVJ2ZbfAf57Qu8EyjvNvW/6ma6niamurputsiqotyC83QSXjsf9MFXaeKsePp8qx81Q59p+pgkrGI6/MhKJqS0dnlRC/CQLDiWIj4kKUSI3SQMLzcLgESHgeqVEaxIYokVtiDIpnCurBEGQOnqtCfrkJgp8TLNVYnQjVKlBmtMMpCJBJeJhsLoSoLldyHMchTq8UL8b+dGv0XNzj9EqvqagAoOD6m3H+mgHI6Xsd+ryxDN0So1BUaW40vcnmgosxgMFn3nRKKY5dqMH1qeENPnsleb/ScvnaV6DpCSGEENKxlEopZo9IxVvb8xDIvXq8Xom+cQ1nvOoVo0GZyd7s53vFtM/c9Vq+6XgQgabrbGrtTlw02XCh2oIKkw0uBuDSxKCVJhvKjDYkhKpQe4WzhRDSETzPFD1jtNAqpDBaneLMQTqlFCabM2ieKaiBIchU1Nphdwnw95ppdwpwOFyotTnhYoBSylBptkOn9J6jWiWXoNRghcHswL6aCpSbbHAJAtRSKaotDkRo5UiN0iIxTA2e51Brd8LqdEEtU+Ka7Zsx8H/r8fnf30MVk8LuEvCvv6/DRYsTiTJ3FGwxvdw9bkgQGIoNFpjtLhgsDtgcTvA8j0qTDTanC3anALmUh0IqAccBVocLRqsTBouj0bx7KhKnU2gy2nZT6uezvvr7CiS9P0EgPWmMVgdMNie0Sil0CtkVB8gKJPCkr7QArihQV1sEvKQgmiSY0PeVkM7NE7By3U8FMNpczb62idTI8P6sYT7/jl+fMhhD/r6t2X2+PqXxQJ6t6YsjpX6nW/jbNs5MG1DLJCiqtqC42gKHS4AgeJoX3LOfe2bOUMs6/3R+hHjUfabgOA4hKu9gjvWfQTozamAIMhEaOQxWh5/9FwAnA/IumsFzly68HIeDZ6pQZrAhLVqLcI0cgDtoUWWtHc//7xjOVZndD/1Odz8JKc9BIeURHaLEqJ5R+MP1SdDIpUgpLsDdy19EytH9AICw91fj6xsmw+lyf04hlaDcaEPvWHdwEqVUAvOlVufss9ViY4nAGATBXSlUmx3itFhSCQeVTAKni8FodeLXomoUVpgRrpajR7QG4RqFmHeFVAKNXIqtOaVY+1MhCitq4XC5e2ykRGgw84YUcb7wptTNp68orXX3FUj6i0Ybth4vazIIpCdQ5KFzVThbYYbF4YJKLkFS+OUgnYHGyPA38KSvtKEqGcC5z0kggSvbIuAlBdEkwYS+r4QEB18BLYcmh+PbI0X476ELMNlc0CokmDw4HhOHJjX69xseokK/eB2OXWh8dop+8TqEh7RPcLYKs38PIP6m62wExlBZa4fZ0TDShEsAHIKAqlo7BNb5u5IT4hHoM0hn1vlzSLz8c1seHFfQo01g7mjRjGOotTlRVG2GyebEoMRQhKllOHy+GgUXzQAT4BQAh4tBAMCY+/8SXkCZwYqvj5XAWHoRf/5lA55c9S/wggsOuQIbxk7H+qEToJRJIFW4H6idHIdvfi1BnF6J1EgtekRpsS23FPllJnfjBXM3eIAxuOCuFExWpztaqkIKp4vhos0GQWCQSXlwjINCyqHMaIXR5riUdzmKa6xIT9Ajt8SA5VtyYbQ6EKGRQyWXwGJ34WSZEcu+OQEAzTYyJISq0CNKi6MXaqBVePeUYIyJ+/K83fcnfZxeia9/LUaV2dFoEEgAWPNTIc5WmlFutMIlCNAppbA5BJyrNMPmEAIKGBlI4ElfaS9Um5GV434Dcl1KGFIjtX4FrmyLgJcURJMEE/q+EhJcfAW07Bunxz0Z3QPqgbR5/khMeGOnz0aGfvE6bJ4/slXz3RSFlIfD3lyYR3e6YHT6Yi2M5qan2DSYHTh9sRYpkdp2yhUhLRPoM0hnRg0MQcRgsmHnqYbzL/uNc0/NZHMKkDvdwyaOF9cgUi1HUZUVYAxKKY8KswMCY+AASHn3g79LABQ8cOsvW/B41iqEmaoAAMcybsbyW2bjrC4GUTo5nAJDtdkJnUqGgd30qLgU5PChUVqM6R2ND34+A4vdBamEg/PS1CsuBvCcuxFEACDlOLgEBpcgwOliUMh4hCilcDAGk9UJrVIGk9WB48UGRGmViNDKcXPvaPxtcw6MVgeSwlTgeXelqVPy0MglOFtlwbrdhRjVM6rJ4RI8z2Fc/xhcqLHgVJk7toKnoaK4xopwjRy39osRbzSaTa+WAwyoMjvQM1orXix0Shm0CilOlZnw7dESccoop9Nd5gitAhzHQatwt9I7BQEVJptfUZHrB570tU/PdgA0SOu+iNkgl/IAYygx2NAtTO3z83XzEch+/e0q3hbbJKSt0PeVkK7hSqfZ3Dx/JCoNFjz+n8O4UG1FfKgSr909sN16Lnjcf0Mi3tx+xq90wehClRnN9b1wXkpHSLAI9BmkMwvOpsur1NJvjrfo8xyAMLUcarkERqsLZpsDpTVWyOUSAAzhGjnMDgZPjzIJ5w5UyPOAU2DgJDxuPrYLYaYqlMQmofyzjaj64BNURMZDKuFQY3HA6hAQHaLEoMRQRGiVXkEODTYHAAaNQgqHi4EBcF4aNyfl3Y0MgPt3q0OAwwXIZTzkEgnCNAqo5RKEqOSwOQW4GFBmsCEpQoX7b0iBwepAYUUtIjRysXHBg+d5RGjkKLhYi4Pnqpo9TmnROtx/Qwr6x+tRbXag8GItqs0OpCfofb59bCr9rf1jUFRtgULKw2h1gtXprucJAnnkfA1+LapBiFKKKosD2joxJjiOg1YpRZXZHXuisajIgsBwrtKMEyUG7D9Tibwyo1+BJ30FqTRanagy26FTyqBTyVBZa4fR6vT5+boCCXjpr7bYJiFtJRi/r3WvHecqzUERnZqQziw8RIV1D1yPrAWjse6B69u9cQEA5o5qONNFS9J1NnsL/Jti1N90hHQWgT6DdFbUgyGInK+88umEeLiHOxisDjAGdw8BBsg4IFbvjmUgl/IQGANjDAJzN0jozTVgACqVIXAJDC+Pn4OcHunYO/FePHPjQEQCSI7QIEqrgIsxMdKp5+ZaJZegpMZ9051XZoJTYNCrpDDZneDgvrkVGMAJl/OplkncDRocoFVIYHcy8BwHCc+hT5wOCqkEFocTpQYrJg1OQGqkFnvyz8Bsd0KvkoEx1uDmXiWXoLLWjopa31GexeCKNoe7l4RCijsGxoEBsDhczXaRTIvWIXW01iuom8Xuwvp9Z/DrhRqoZBLIJDzC1HKv2BcquQRmh/vhPUwtvzTTh/efpXvmDyckPAez3dkguEv98d6eYRVDU8LAGLwi0HIcB5VcguIaK/aerkC1xYELNRbEhijF7dldApwuATKlFACHWps7im3dY+kryEygATL90dpBNAlpS23xN9CWKFYEIV2TUinFIzen4c1teY2meeTmNCiVwfkYUGKwtWo6QjoTX88UwXZPG5xXlqtUt3AlUHBln/U8HhqtTnBgcAmA0eaAwQp8dagYVqcLJqsDTpcLDgHgBRfuOfIdnvrhfWT1zMDTtz8Gi8OJPF0s3h9xDwaoVGKQEZVMAqmEQ5hS3mC/xdUWFFZY8PG+s6ixOGCyOmC0OiEIgEzCQSJxB+txuWepBAC4BAESngPPcXAK7jd/AmOQ8u5ZJUJUMnAcEKZWoNJkx8qcfOwtqIDZ7sK5SjN0ShnCL8Vg8LDYXZBJ3D0Z6vMKrlhphsXugkomQVLE5eCK/nSVrNulMq/MiHV7CnG+ygyVTAKNQgKe41FutIqxL8I1cljsLqhlUoBzN3JIL815q5BezrvDJUDK83AJrEFwF1/jvUsNFhw5b0fWsVLoVFJIeA5SnheDY5bUWJF9rhrZZ6vgEBjMNifOVphxbUoYukdqIZfwkEp4OFwMAIOE5yGXXO4V0liQmbYITtOaQTQJaWvBFKCJYkUQ0rV5ZslY9UMezHVid6klwKxRaeL6YBSlVbRqOkI6mysdptVZdPxdDvHb4vF98J8DF1q0DbvrcvdXl8P9/3KTDQIDaizut2pDinLwl6x3kF6aDwBIL8mDwmGDHQpIeAazzYWEUKUYZKSxgCQVJht+KayCSiZBvF6F1AgNjhXVwGRzgefccR0kl2Iv1O2Ua7ILkHCAQsrB5hQQrpbB7nAhRq+CTin1GTwxNVKDgnITKmrtMNkcsLsExIa4xy4JgoCKWjt6xegwJNF7/mrPTfbZCjPKjFa4XOxScEUXzleZYXMGFlwR8B6HPSBBD4eTocxoRbhGgnCNHJW1duSXmxCqCkVxjRUDuunBABwtMiBMJUO5yQa5hhfjIZisTkTpFDBanRjQLVQ87o2N91ZIJeA5DtVWO6QSIDFMA4cgoMxoxfkqM8pNdvA8kBSmgkouwblKCypqbdh5shwAkBKhQZhajjKjOy6H57gDTQeZaYvgNK0VRJMelEh7CJYATRQrgpCrg69ZMqYMSQrangsevx+WiK+PNj8V5++HBWeMCUKCXXBfYa4yRocApZSD1dk6Y2TFOYMvPeRH1lZh4Y51+N3R7wEABrka/xgxHR8MmQAX736jLjD3jA7gmg5yaLY5sa+wEgAwrHsYQlQyGCwO6FUy2JwuOAX3MA1HvcYFDxcDrE4GnnM3OGhVciRHqGGyORsNnjg4OQy7Tl10x2gQnLhosiJUJUeF2Y4QpQwzhqd4BXj03GRXmGxwCgJcAkOEVn4puKLUHVzRJaDCZA/oZrvuOGye59EjWgOjzYHKWju0SinUCilKDVYcKapBtzA1xvWPBQAU17i7Tkt4DhUmGxQyCWwOAVIpDynPI0Kr8Aru4mu8N2MM+eW1UEh5aBVS1NrcwTw1SinUcinOVBrAGNArUgPtpR4ncXr3w47B6sD+wkp0C1UjTq/A+UvBkWJD3MNfLJ5j30iQmbYITtMaQTTpQYm0l2AJ0BRIrIhgfoNCCPE9S0awG54ahdgQOUoMvoe9AkBsiBzDU6PaMVeEEA8K8hhEau1OqNuga61LADLO/opt/35IbFz4rP9Y3DznXay99rdi4wLgjo8QrVOgqtYuBirzFZDkQrUVMp7DdSlhiNC6x/fbXQKUMgmSIzRQyyVewyLqqvullEoAvVKKbqFKGCwOMdDJ+PRYVFscXjfI3SO1uLFnJCI0cnfciFoHqszungvP3Na7wRSVnpts3aUgilqlLODgir5cHoftPlfhGgUGJYYiWqeE1SGg1uaA1eFCaqRWfLvuOYbXd49AYrgaEok7KKRUwiExTIXMHhEN3sTX3w9wOUBjuFaBOL0KcikPi8OFKrMd1RY7OLinpZJJLp9TlVyCOL0KIUoZqs2OS4EwOdzaNwa39I0BwPkdZKYtgtM0tU1f3wOPzhpUj3RtwRCgyde1oy6VXAKb09VpYkUQQkhdUimPv905ACGN9MQIUUrxtzsHNDlrGCGk7VAPhiCikUuhlktQ2czcv4HwPODnRHeHXSLFrzE9sOSWh3AwoU+DtFIeiA5RuKeitDi8bj7rByQpqbFiwy/nEB96+e2XZ2y/UiZB90gJTpWawMDguhR7AHDPLKGRS8DAweF0IUQlR69YLWaP7IEQlUwMdHKyzOgzmFr3SC2Sw9UoqrKisLIWU4cl4c5BCT4rGc9NdohSVieo4WUyCY/aJoIrNsbXOOxwjQJhKXKxAcDicOH+G1KQFKHxeQyNVgdMNie0Sil0CpnP4C6+9lM/QGOkVoH0BD0UMgkuVJtRbrBCJuHgYt5NOyq5BInhKpyttGBsnxiM6xcrduMONMhMWwSnaWybjX0P6parMwXVI1eHzh6gKZhiRRBCiC9j+sTgtSmD8N7OPBy9YITDJUAm4ZEeH4JZI3s0eKlESDAJ9sDldPcQRBJCVRjbJxpr95xt8bZijBdx969b8VbmPQDHwaDU4p4/vIjCsDgIl3osNPgaM8BoccLmdAEMkLKGXeQ93Wk1cilUMu8bWJ1SijC1HOVGK3gO4HmAAw9AgIQHXIyDgueglEnce2cMEp6D1SkgRCVD79gQcV9N3SDzPI9QjQwpnAbXp0Y02oLt2YZLEMSghgrp5TI5XAIkjQRXbEpj47A5joNOKUWJwYqB3ULRLaxh1+NAgrr42o8YoNEpwGRzIjpEifhQFTiOg83pgkTCQ2CAhGt4kbI6BKhkEgzopvfKw5V0kW6L4DS+tkkPSqSz6swBmoIlVgQhhDRlTJ8YjOoZhYPnqlBRa0eERo4hiWHUc4EEta4wwxPddQcRnufwh4wUfPTzWTiuMAyDzOXAA/u/xPyfPoHGYcWZsDhs6jMSAHA6optX2vq7cDKg/NI0j4YyE+5c+RPuGtoNUzOSoJJJwAEwX5rSMS5EiR5RWvxaVI3YEAaH4J7CskeUBkarAyUGK2S8Z1pMwHmpF4NSLgHHcXAKDAwcOA5Qy6QNHhDr3iBr5BKYbC5xOkatQtLkDXLdKSkjtXKcqTAjTC1DudEG+aVZJmxOAZW1dkRq5TBaHBiQGOq1raZaFttrHLbv/fDQyCU4X21BlFaOHlEa8eEhVqeEQiqB1elC/bq3qUCYnZF4Dq0ORGoVOFtZi2ti6EGJEH8ES6wIQghpjlTKY1j3iI7OBiGtoqvM8EQNDEHmmlgddCopKs2Bd/keUXAQz3//L/SoPA8AOBjfCwXhCVecF6Pdhff3nMH2E2XQKmUAGCK1CkRqFegRpUWISoriGiuOnK+BXMpDLuWhU0ihkPJICFXBZHV4zVGslksgk/BgDLA5XOB5Dgqp+416/QdEzw1yTokB3x4vhUu43Bwi4TlcE6PzeYNcv1XQ7hRQbrRBKuEg4TkU11hhc7jHHrvf+gsQGPC7WJ24LX9aFj3jsD3pSg1WKKQSpCfocWu/1muBrL8fm9OFMI0cToEhRCWDTMLDKQjig0N6gh6nL9biXLUVEZem8rTYXaio9R0IszNq7BzW2lzoGaOlByVC/NBe1yhCCCGENK8rzfBEDQxB5vbXfwi4cSGhpgyLt72H207uBgCUq0Px4uiZ+G//m8G4wB8mPV9pdunnfLUFiWHu5RUcEKmV4+fTFSg2WKFXSRGnV8Jkcw+tuGBxIFQtx5TrEqFXyfD5wfPIKTHCYnfC7hAgMAanU4ALgFYuRa9YHcb1j236D4l58uXu9eAzciQabxW0OQQYrA4oZRKU1FhhdwlQSHmEquWI0Mqhlkmx7UQZkiPc3Z39bVlsr3HYvvZjsbuQddz3g8OZCjPW/lSIwopaVNbaIZPw6BWjw4zhKZ1+zGKj59ApwGBx4GylGQopTw9KhPihs8eKIIQQQq4WdWd4AgCDxSH2ztYppUE1wxM1MASRSoMFx4tNgX2IMbz15TIMKj4FJ8fj/SG/wYob/wCDUtuivNR9hheYuzt6jF6Filo7Ci7WwsUYqs12RGnkuDYlHCabE+UmG4qqzCg12LB+71mkRKqhkkvRM1qLoiozqswOmO0CpDyHmBAlRl8ThakZST4fED2tfC6BYVy/mAZDJPLKa71a+ZpqFRycFIrcEgMqzQ70iw9BnF4Fhcz9kKq7FPjxVJkJ3x4tuTQ7hf8ti+01DtvXftKifT84pEXrgnLMYpPnMDEUJ0tNSIpQYdLghEYDYxJCvAV6jSosLMQLL7yAbdu2oaSkBPHx8Zg+fTr+7//+D3K5e4jZmTNnAAB6vd7rs3v27MH1118v/v7ZZ5/h2WefRWFhIXr27IkXX3wRt99+u7ieMYYlS5bg3//+N6qrq3HDDTdg5cqV6Nmzp5imsrISjzzyCP73v/+B53lMnjwZr7/+OrTaltVxhBBCSHvyBJ+3OngcO1+Ns1UW2FwCFBIeSWEq9IjRBc0MT9TAEEQe/+yw32k5Jrh7J3AcXhx1Px79aT2W3PIQcqNSWpwPXx0EzA4BVocLZpsTpTVWCGCQ8TxOlZsQG6qEViHDmQozLHYnVHIeZUYrSg1W2JwCeB6IVMtxffdwDEoKQ9/4EKRGaZEYpm70AbFuKx/P8whReT8c12/la27e9xCVDMeLjchMjUCcj/H6cXoljpyvATh3/IdgmDu+qQeHYByz2Nw5jA9V4qLRDp1C1imOPyFd0YkTJyAIAt59912kpaXh6NGjmD17Nmpra/HKK694pf3yyy8xbNgw8feIiMvXnN27d2Pq1KlYtmwZfvOb32D9+vWYNGkSDh48iP79+wMAXnrpJbzxxhtYt24dunfvjmeffRbjxo3D8ePHoVS63/BMmzYNxcXFyMrKgsPhwP333485c+Zg/fr17XA0CCGEkNahkUthdwr4PqcUFSY7XHUeuMqMNpyuMGNgYmhQBC7v/DkkosIKc7Npkqsu4Lmt/8b+bn2x8vrfAQD2JA/AnqR0wMfMAa3FbHPifJUFjDGAAyQcD7mUg9nuwpHz1dApZe7GBRmP89VWmGxOKKUS6JQS2FwMNTYXckqMUMilGNc/Fsl1pm/05fI87v5NT9hcegnPweESGm3QUMklMDvc22pq7niaErHtBHrOCSGtb/z48Rg/frz4e2pqKnJzc7Fy5coGDQzh4eGIjY31uZ3XX38d48ePx1NPPQUAeOGFF5CVlYV//vOfeOedd8AYw4oVK7B48WJMnDgRAPD+++8jJiYGGzduxO9//3vk5ORgy5Yt+OWXX3DttdcCAN58803cfvvteOWVVxAfH98Wh4AQQghpdXEhShSUm1BmtDdY52JAucmOwosmxIUoOyB3gencfaI7obfeegspKSlQKpXIyMjAvn372m3fLqul0XUquxVP7PwA3636E8bk/4IH9/4XKrv1coI2bFwA3MMkzHYXZFIeUp6HlOPAwEEp42G1u3C+ygKtQuoeBmFzggMHjUICuVQClUwCKe9+436y1Ihvj5ZAEJqeJqPu9IS+1J+esLn0LoFBJuEb3a/F7oJaJoVaLvV7n6R1BXrOCSHto6amBuHh4Q2WT506FdHR0bjxxhvx1Vdfea3bs2cPxo4d67Vs3Lhx2LNnDwCgoKAAJSUlXmn0ej0yMjLENHv27EFoaKjYuAAAY8eOBc/z2Lt3b6P5tdlsMBgMXj+EEEJIRzpTVYtzlU2/TD5bYcGZqtp2ytGVowaGAGzYsAELFizAkiVLcPDgQQwcOBDjxo1DWVlZu+z/vK/vHGO47cQufP/ew3hkzwYoXE7sTBmMu6a/Aou8fVq4FBLOPd0kGGwOARqFBGo5D4vdBaVMAq1SBqvDBavTBZPNCYEBchkPCe/++kk4gDFAJZPAJTAcOV+DourGG1OAy9NUFtdY3b0m6vBMT5gWrRVnn2guvdHqREqkBgars9HtDeimR3qC3u99ktYV6DknhLS9vLw8vPnmm3jwwQfFZZ74B+vWrcPmzZtx4403YtKkSV6NDCUlJYiJ8Q4qGxMTg5KSEnG9Z1lTaaKjo73WS6VShIeHi2l8WbZsGfR6vfiTmJgYaLEJIYSQVvXdsRLYhabT2AWG7441Xr91FtTAEIB//OMfmD17Nu6//3707dsX77zzDtRqNVavXt0h+UmuuoAPNyzGyi+XI8FYjvMh0Xjwzj/jvnuW4nREt3bJg14lhVohhcAYXC4GngN0ChkkvDtIooTnxPHyJqs72j/HAWqZROxU4WLuMfSKS0EGzQ5ns93cPdNUhmvkOFVmgtHqgFMQYLQ6cKrM1GB6wubSR2gVmDk8BRHaxrc3rn8sxveP9XufpHUFes4JIf575plnwHFckz8nTpzw+kxRURHGjx+P3/3ud5g9e7a43BNr4dprr8V1112H5cuXY/r06Xj55ZfbtUyNWbRoEWpqasSfc+fOdXSWCCGEXOVOlhhbNV1Hor7EfrLb7Thw4AAWLVokLuN5HmPHjhW7a9Zns9lgs9nE31u7GybPGIadOwabRIZ3Mu7Gyusnwypru14LdaenVEg5dI/QABwHg8WBWpsT4ACVXApwQLdwNSK1CpQbbSg1WMADsDoEKKU8XAziQyBjDHanAI1cKjY4qGVSv7q5BzqPuz/pkyPUzW6P5o7vOIGec0KIf5544gnMnDmzyTSpqani/y9cuICbbroJw4cPx7/+9a9mt5+RkYGsrCzx99jYWJSWlnqlKS0tFWM2eP4tLS1FXFycV5pBgwaJaer3IHQ6naisrGw09gMAKBQKKBSKZvNMCCGEtBeZxL/3/v6m60jUwOCnixcvwuVy+eyuWf+tjseyZcvwl7/8pc3yVBCegKdvfxQHEvrgXGjjN1MtIefdDQqenggc3L/3iQvBDT0iYbI5YXU4sSe/EuAYMlMjoJRJoVNKwXEcksNVOFLEYWC3UDgFhhMlBpQZbLDZnYBMCrtLgEzCI0wtg8nmgoTnMKCb3u9u7oHO495cen+2R3PHdyw6/oS0vqioKERFRfmVtqioCDfddBOGDh2KNWvWgOebv9nJzs72aijIzMzE1q1b8dhjj4nLsrKykJmZCQDo3r07YmNjsXXrVrFBwWAwYO/evXj44YfFbVRXV+PAgQMYOnQoAGDbtm0QBAEZGRl+lYUQQgjpDAYnh+LTA0V+pevsqIGhDS1atAgLFiwQfzcYDK0+1nNjv5tadXseEg7gOffwBQnPQa+Si1H65VIeyeFqCGDgOKDa4kT/bu75zqstTsTJpXAxBovNieIaK7qFqXH/DSkAgPV7z+LbYyWorLXDLjigU8qgV8lgsDohMIaBiaEY1z82oIfFQOdxby69P9sLdJ+kddHxJ6RjFBUVYfTo0UhOTsYrr7yC8vJycZ2n14BnisiTJ09Cq9Xi888/x+rVq/Hee++JaR999FGMGjUKr776KiZMmIBPPvkE+/fvF3tDcByHxx57DH/961/Rs2dPcZrK+Ph4TJo0CQDQp08fjB8/HrNnz8Y777wDh8OBefPm4fe//z3NIEEIISSoZKZGQiuXwGR3NZpGK5cgMzWyHXN1ZaiBwU+RkZGQSCRNdumsr7W7YRYun4CUZza32vZ84TkgXCODlOdgdzJIeEAulVz6XUBSuBp940PAgUPhxVqv7ukAmu26vnhCX9zcOxr/OXAeR4tqYLY7UWtzQq+SIzM1HFMzkqibOyGEdFJZWVnIy8tDXl4eunXzjvVTP/jqqFGjIJVK0bt3b2zYsAF33323uG748OFYv349Fi9ejD//+c/o2bMnNm7ciP79+4tpnn76adTW1mLOnDmorq7GjTfeiC1btkCpvDwU8KOPPsK8efMwZswY8DyPyZMn44033mij0hNCCCFtIylcg1v7xWDTkWLYXQ1ntZNLONzaLwZJ4ZoOyF1gOFb/joA0KiMjA8OGDcObb74JABAEAUlJSZg3bx6eeeaZZj9vMBig1+tRU1ODkJCQK85HSxsZOLijewqe/3OAXMojPkyF+29IwYi0KJwoMWJ/YRXKDBbUWB3gOR5p0VpMHpqAtChdo93TBYH51XVdEBjOV5lx+qJ7qpXukRokhqmpmzshhAS51qrr2kuw5ZcQQkjXlFdmxAubjuPX89WotbsgCAw8z0EjlyC9Wyie/U3fK34R2551HTUwBGDDhg2YMWMG3n33XQwbNgwrVqzAp59+ihMnTjSIzeBLa55YfxsZ4jVAfIQOWoUc6Ql6pMZoEaKSgQMHpZTHuSoL7E4B18RoMTQpHFLp5bG0/jYWEEIIIR7B9sAebPklhBDSdeWVGfHNr8X4pbAKJpsTWoUUw1LCMT49tkW9vNuzrqMhEgGYMmUKysvL8dxzz6GkpASDBg3Cli1b/GpcaG2Fyye0+T5onDshhBBCCCGEtI+0aB3m3hTcwcypB0M7orckhBBCurpgq+uCLb+EEEJIoNqzruv8E2kSQgghhBBCCCGk06MGBkIIIYQQQgghhLQYNTAQQgghhBBCCCGkxaiBgRBCCCGEEEIIIS1Gs0i0I088TYPB0ME5IYQQQtqGp44LlhjSVDcTQgjp6tqzbqYGhnZkNBoBAImJiR2cE0IIIaRtGY1G6PX6js5Gs6huJoQQcrVoj7qZpqlsR4Ig4MKFC9DpdOC4ls9lajAYkJiYiHPnzl0VU2tRebs2Km/Xd7WV+Wot79mzZ8FxHOLj48HznX8kZqB189V2XluKjpf/6FgFho6X/+hYBaYrHi/GGIxGY7vUzdSDoR3xPI9u3bq1+nZDQkK6zJffH1Tero3K2/VdbWW+2sqr1+uDqrxXWjdfbee1peh4+Y+OVWDoePmPjlVgutrxaq9ehZ3/1QIhhBBCCCGEEEI6PWpgIIQQQgghhBBCSItRA0MQUygUWLJkCRQKRUdnpV1Qebs2Km/Xd7WVmcrbNV0t5WwtdLz8R8cqMHS8/EfHKjB0vFqGgjwSQgghhBBCCCGkxagHAyGEEEIIIYQQQlqMGhgIIYQQQgghhBDSYtTAQAghhBBCCCGEkBajBgZCCCGEEEIIIYS0GDUwBKm33noLKSkpUCqVyMjIwL59+zo6Sw0sW7YM1113HXQ6HaKjozFp0iTk5uZ6pRk9ejQ4jvP6eeihh7zSnD17FhMmTIBarUZ0dDSeeuopOJ1OrzQ7duzAkCFDoFAokJaWhrVr1zbIT1sfs+eff75BWXr37i2ut1qtmDt3LiIiIqDVajF58mSUlpYGZVk9UlJSGpSZ4zjMnTsXQPCf3507d+KOO+5AfHw8OI7Dxo0bvdYzxvDcc88hLi4OKpUKY8eOxalTp7zSVFZWYtq0aQgJCUFoaChmzZoFk8nklebIkSMYMWIElEolEhMT8dJLLzXIy2effYbevXtDqVQiPT0dX3/9dcB5aUl5HQ4HFi5ciPT0dGg0GsTHx+O+++7DhQsXvLbh6zuxfPnyoCsvAMycObNBWcaPH++VpqucXwA+/5Y5jsPLL78spgmm89tWgqH+bU2dqW7rjIKpnuhowXTN7Wj+3EN3xfvKK3W1PXN0eowEnU8++YTJ5XK2evVqduzYMTZ79mwWGhrKSktLOzprXsaNG8fWrFnDjh49yrKzs9ntt9/OkpKSmMlkEtOMGjWKzZ49mxUXF4s/NTU14nqn08n69+/Pxo4dyw4dOsS+/vprFhkZyRYtWiSmOX36NFOr1WzBggXs+PHj7M0332QSiYRt2bJFTNMex2zJkiWsX79+XmUpLy8X1z/00EMsMTGRbd26le3fv59df/31bPjw4UFZVo+ysjKv8mZlZTEAbPv27Yyx4D+/X3/9Nfu///s/9vnnnzMA7IsvvvBav3z5cqbX69nGjRvZ4cOH2W9/+1vWvXt3ZrFYxDTjx49nAwcOZD///DP78ccfWVpaGps6daq4vqamhsXExLBp06axo0ePso8//pipVCr27rvviml++uknJpFI2EsvvcSOHz/OFi9ezGQyGfv1118DyktLyltdXc3Gjh3LNmzYwE6cOMH27NnDhg0bxoYOHeq1jeTkZLZ06VKvc173bz5YyssYYzNmzGDjx4/3KktlZaVXmq5yfhljXuUsLi5mq1evZhzHsfz8fDFNMJ3fthAs9W9r6ix1W2cVTPVERwuma25H8+ceuiveV16pq+2Zo7OjBoYgNGzYMDZ37lzxd5fLxeLj49myZcs6MFfNKysrYwDYDz/8IC4bNWoUe/TRRxv9zNdff814nmclJSXispUrV7KQkBBms9kYY4w9/fTTrF+/fl6fmzJlChs3bpz4e3scsyVLlrCBAwf6XFddXc1kMhn77LPPxGU5OTkMANuzZw9jLLjK2phHH32U9ejRgwmCwBjrWue3/s2QIAgsNjaWvfzyy+Ky6upqplAo2Mcff8wYY+z48eMMAPvll1/ENN988w3jOI4VFRUxxhh7++23WVhYmFhexhhbuHAh69Wrl/j7PffcwyZMmOCVn4yMDPbggw/6nZeWlteXffv2MQDszJkz4rLk5GT22muvNfqZYCrvjBkz2MSJExv9TFc/vxMnTmQ333yz17JgPb+tJVjr35boLHVbMOjM9URn05mvuZ1R/Xvoq+W+8kp19WeOzo6GSAQZu92OAwcOYOzYseIynucxduxY7NmzpwNz1ryamhoAQHh4uNfyjz76CJGRkejfvz8WLVoEs9ksrtuzZw/S09MRExMjLhs3bhwMBgOOHTsmpql7PDxpPMejPY/ZqVOnEB8fj9TUVEybNg1nz54FABw4cAAOh8MrD71790ZSUpKYh2Ara312ux0ffvghHnjgAXAcJy7vSue3roKCApSUlHjtV6/XIyMjw+uchoaG4tprrxXTjB07FjzPY+/evWKakSNHQi6Xe5UvNzcXVVVVYpqmjoE/eWkLNTU14DgOoaGhXsuXL1+OiIgIDB48GC+//LJX98JgK++OHTsQHR2NXr164eGHH0ZFRYVXWbrq+S0tLcXmzZsxa9asBuu60vkNRDDXvy3V0XVbsOpM9USw6AzX3M6o/j301XBf2RJXwzNHZybt6AyQwFy8eBEul8vryw8AMTExOHHiRAflqnmCIOCxxx7DDTfcgP79+4vL//CHPyA5ORnx8fE4cuQIFi5ciNzcXHz++ecAgJKSEp9l9axrKo3BYIDFYkFVVVW7HLOMjAysXbsWvXr1QnFxMf7yl79gxIgROHr0KEpKSiCXyxs8iMXExDRbjs5YVl82btyI6upqzJw5U1zWlc5vfZ78+dpv3bxHR0d7rZdKpQgPD/dK07179wbb8KwLCwtr9BjU3UZzeWltVqsVCxcuxNSpUxESEiIunz9/PoYMGYLw8HDs3r0bixYtQnFxMf7xj3+IeQ2W8o4fPx533XUXunfvjvz8fPz5z3/Gbbfdhj179kAikXTp87tu3TrodDrcddddXsu70vkNVLDWvy3VGeo2lUrVRqVrW52pnggGneWa29n4uoe+Gu4rr9TV8MzR2VEDA2kXc+fOxdGjR7Fr1y6v5XPmzBH/n56ejri4OIwZMwb5+fno0aNHe2ezRW677Tbx/wMGDEBGRgaSk5Px6aefBu3NUSBWrVqF2267DfHx8eKyrnR+yWUOhwP33HMPGGNYuXKl17oFCxaI/x8wYADkcjkefPBBLFu2DAqFor2z2iK///3vxf+np6djwIAB6NGjB3bs2IExY8Z0YM7a3urVqzFt2jQolUqv5V3p/BL/XO11G2k/V/M1tymN3UMT366GZ47OjoZIBJnIyEhIJJIGUWJLS0sRGxvbQblq2rx587Bp0yZs374d3bp1azJtRkYGACAvLw8AEBsb67OsnnVNpQkJCYFKpeqwYxYaGoprrrkGeXl5iI2Nhd1uR3V1daN5COaynjlzBt9//z3++Mc/NpmuK51fz7ab2m9sbCzKysq81judTlRWVrbKea+7vrm8tBZP48KZM2eQlZXl1XvBl4yMDDidThQWFop5Daby1pWamorIyEiv729XO78A8OOPPyI3N7fZv2ega53f5gRj/dsWOqJuC1adqZ4IRh11ze1MGruH7ur3lVfqan3m6GyogSHIyOVyDB06FFu3bhWXCYKArVu3IjMzswNz1hBjDPPmzcMXX3yBbdu2Neiy5kt2djYAIC4uDgCQmZmJX3/91atC8TzU9O3bV0xT93h40niOR0cdM5PJhPz8fMTFxWHo0KGQyWReecjNzcXZs2fFPARzWdesWYPo6GhMmDChyXRd6fx2794dsbGxXvs1GAzYu3ev1zmtrq7GgQMHxDTbtm2DIAhixZaZmYmdO3fC4XB4la9Xr14ICwsT0zR1DPzJS2vwNC6cOnUK33//PSIiIpr9THZ2NnieF7u1BlN56zt//jwqKiq8vr9d6fx6rFq1CkOHDsXAgQObTduVzm9zgqn+bUsdUbcFq85UTwSjjrrmdgbN3UN39fvKQF3tzxydTsfGmCRX4pNPPmEKhYKtXbuWHT9+nM2ZM4eFhoZ6RT3tDB5++GGm1+vZjh07vKaEMZvNjDHG8vLy2NKlS9n+/ftZQUEB+/LLL1lqaiobOXKkuA3PlDG33nory87OZlu2bGFRUVE+p4x56qmnWE5ODnvrrbd8ThnT1sfsiSeeYDt27GAFBQXsp59+YmPHjmWRkZGsrKyMMeaeTigpKYlt27aN7d+/n2VmZrLMzMygLGtdLpeLJSUlsYULF3ot7wrn12g0skOHDrFDhw4xAOwf//gHO3TokDhrwvLly1loaCj78ssv2ZEjR9jEiRN9Tj82ePBgtnfvXrZr1y7Ws2dPrym1qqurWUxMDLv33nvZ0aNH2SeffMLUanWDKbWkUil75ZVXWE5ODluyZInPaf2ay0tLymu329lvf/tb1q1bN5adne31N+2Jrrx792722muvsezsbJafn88+/PBDFhUVxe67776gK6/RaGRPPvkk27NnDysoKGDff/89GzJkCOvZsyezWq3iNrrK+fWoqalharWarVy5ssHng+38toVgqX9bU2ep2zqrYKonOlowXXM7WnP30Ix13fvKK3G1PXN0dtTAEKTefPNNlpSUxORyORs2bBj7+eefOzpLDQDw+bNmzRrGGGNnz55lI0eOZOHh4UyhULC0tDT21FNPec1JyxhjhYWF7LbbbmMqlYpFRkayJ554gjkcDq8027dvZ4MGDWJyuZylpqaK+6irrY/ZlClTWFxcHJPL5SwhIYFNmTKF5eXliestFgv705/+xMLCwpharWZ33nknKy4uDsqy1vXtt98yACw3N9dreVc4v9u3b/f5HZ4xYwZjzD0F2bPPPstiYmKYQqFgY8aMaXAcKioq2NSpU5lWq2UhISHs/vvvZ0aj0SvN4cOH2Y033sgUCgVLSEhgy5cvb5CXTz/9lF1zzTVMLpezfv36sc2bN3ut9ycvLSlvQUFBo3/T27dvZ4wxduDAAZaRkcH0ej1TKpWsT58+7O9//7vXzWGwlNdsNrNbb72VRUVFMZlMxpKTk9ns2bMb3CB0lfPr8e677zKVSsWqq6sbfD7Yzm9bCYb6tzV1prqtMwqmeqKjBdM1t6M1dw/NWNe9r7wSV9szR2fHMcZYq3SFIIQQQgghhBBCyFWLYjAQQgghhBBCCCGkxaiBgRBCCCGEEEIIIS1GDQyEEEIIIYQQQghpMWpgIIQQQgghhBBCSItRAwMhhBBCCCGEEEJajBoYCCGEEEIIIYQQ0mLUwEAIIYQQQgghhJAWowYGQgghhBBCCCGEtBg1MBBCugyO47Bx48Y23cfo0aPx2GOPtek+CCGEkPYyc+ZMTJo0Sfy9o+q5HTt2gOM4VFdXt+l+2uNegZCrGTUwEEICtmfPHkgkEkyYMCHgz6akpGDFihWtn6lm3HHHHRg/frzPdT/++CM4jsORI0faOVeEEEJIQzNnzgTHceA4DnK5HGlpaVi6dCmcTmeb7/vzzz/HCy+84Ffa9moUsNvtiIyMxPLly32uf+GFFxATEwOHw9Gm+SCENI8aGAghAVu1ahUeeeQR7Ny5ExcuXOjo7Phl1qxZyMrKwvnz5xusW7NmDa699loMGDCgA3JGCCGENDR+/HgUFxfj1KlTeOKJJ/D888/j5Zdf9pnWbre32n7Dw8Oh0+labXutQS6XY/r06VizZk2DdYwxrF27Fvfddx9kMlkH5I4QUhc1MBBCAmIymbBhwwY8/PDDmDBhAtauXdsgzf/+9z9cd911UCqViIyMxJ133gnA3e3yzJkzePzxx8U3MwDw/PPPY9CgQV7bWLFiBVJSUsTff/nlF9xyyy2IjIyEXq/HqFGjcPDgQb/z/Zvf/AZRUVEN8msymfDZZ59h1qxZqKiowNSpU5GQkAC1Wo309HR8/PHHTW7XV1fL0NBQr/2cO3cO99xzD0JDQxEeHo6JEyeisLBQXL9jxw4MGzYMGo0GoaGhuOGGG3DmzBm/y0YIIaTrUSgUiI2NRXJyMh5++GGMHTsWX331FYDLwxr+9re/IT4+Hr169QLQfH3jcrmwYMEChIaGIiIiAk8//TQYY177rT9EwmazYeHChUhMTIRCoUBaWhpWrVqFwsJC3HTTTQCAsLAwcByHmTNnAgAEQcCyZcvQvXt3qFQqDBw4EP/5z3+89vP111/jmmuugUqlwk033eSVT19mzZqFkydPYteuXV7Lf/jhB5w+fRqzZs0K+F7BVw+M7OxscBznlZ9du3ZhxIgRUKlUSExMxPz581FbWyuuf/vtt9GzZ08olUrExMTg7rvvbrIshHRl1MBACAnIp59+it69e6NXr16YPn06Vq9e7XVzsnnzZtx55524/fbbcejQIWzduhXDhg0D4O522a1bNyxduhTFxcUoLi72e79GoxEzZszArl278PPPP6Nnz564/fbbYTQa/fq8VCrFfffdh7Vr13rl97PPPoPL5cLUqVNhtVoxdOhQbN68GUePHsWcOXNw7733Yt++fX7nsz6Hw4Fx48ZBp9Phxx9/xE8//QStVovx48fDbrfD6XRi0qRJGDVqFI4cOYI9e/Zgzpw5YuMLIYQQAgAqlcqrp8LWrVuRm5uLrKwsbNq0qdn6BgBeffVVrF27FqtXr8auXbtQWVmJL774osn93nffffj444/xxhtvICcnB++++y60Wi0SExPx3//+FwCQm5uL4uJivP766wCAZcuW4f3338c777yDY8eO4fHHH8f06dPxww8/AHA3hNx111244447kJ2djT/+8Y945plnmsxHeno6rrvuOqxevdpr+Zo1azB8+HD07t27xfcKvuTn52P8+PGYPHkyjhw5gg0bNmDXrl2YN28eAGD//v2YP38+li5ditzcXGzZsgUjR4684v0REvQYIYQEYPjw4WzFihWMMcYcDgeLjIxk27dvF9dnZmayadOmNfr55ORk9tprr3ktW7JkCRs4cKDXstdee40lJyc3uh2Xy8V0Oh373//+Jy4DwL744otGP5OTk8MAeOV3xIgRbPr06Y1+ZsKECeyJJ54Qfx81ahR79NFHm9ynXq9na9asYYwx9sEHH7BevXoxQRDE9TabjalUKvbtt9+yiooKBoDt2LGj0TwQQgi5usyYMYNNnDiRMcaYIAgsKyuLKRQK9uSTT4rrY2JimM1mEz/TXH3DGGNxcXHspZdeEtc7HA7WrVs3cV+Meddzubm5DADLysrymc/t27czAKyqqkpcZrVamVqtZrt37/ZKO2vWLDZ16lTGGGOLFi1iffv29Vq/cOHCBtuq75133mFarZYZjUbGGGMGg4Gp1Wr23nvv+Uzf3L2Cr/wfOnSIAWAFBQVivufMmeO13R9//JHxPM8sFgv773//y0JCQpjBYGg034RcTagHAyHEb7m5udi3bx+mTp0KwN0rYMqUKVi1apWYJjs7G2PGjGn1fZeWlmL27Nno2bMn9Ho9QkJCYDKZcPbsWb+30bt3bwwfPlx8+5GXl4cff/wRs2bNAuDuOvrCCy8gPT0d4eHh0Gq1+PbbbwPaR32HDx9GXl4edDodtFottFotwsPDYbVakZ+fj/DwcMycORPjxo3DHXfcgddffz2gnh2EEEK6pk2bNkGr1UKpVOK2227DlClT8Pzzz4vr09PTIZfLxd+bq29qampQXFyMjIwM8TNSqRTXXntto3nIzs6GRCLBqFGj/M53Xl4ezGYzbrnlFjEfWq0W77//PvLz8wEAOTk5XvkAgMzMzGa3PXXqVLhcLnz66acAgA0bNoDneUyZMgVA69wr1Hf48GGsXbvWqyzjxo2DIAgoKCjALbfcguTkZKSmpuLee+/FRx99BLPZfMX7IyTYSTs6A4SQ4LFq1So4nU7Ex8eLyxhjUCgU+Oc//wm9Xg+VShXwdnmebzAGtH4k6BkzZqCiogKvv/46kpOToVAokJmZGXBgq1mzZuGRRx7BW2+9hTVr1qBHjx7ijdPLL7+M119/HStWrEB6ejo0Gg0ee+yxJvfBcVyTeTeZTBg6dCg++uijBp+NiooC4O7eOX/+fGzZsgUbNmzA4sWLkZWVheuvvz6gshFCCOk6brrpJqxcuRJyuRzx8fGQSr1v2zUajdfv/tQ3gbqSOt1kMgFwD5lMSEjwWqdQKK4oHx4hISG4++67sWbNGjzwwANYs2YN7rnnHmi1WgCB3yvwvPtda916vP79h8lkwoMPPoj58+c3+HxSUhLkcjkOHjyIHTt24LvvvsNzzz2H559/Hr/88gtCQ0NbVF5CghH1YCCE+MXpdOL999/Hq6++iuzsbPHn8OHDiI+PF4MhDhgwAFu3bm10O3K5HC6Xy2tZVFQUSkpKvCr47OxsrzQ//fQT5s+fj9tvvx39+vWDQqHAxYsXAy7HPffcA57nsX79erz//vt44IEHxHgHP/30EyZOnIjp06dj4MCBSE1NxcmTJ5vcXlRUlFePg1OnTnm9uRgyZAhOnTqF6OhopKWlef3o9Xox3eDBg7Fo0SLs3r0b/fv3x/r16wMuGyGEkK5Do9EgLS0NSUlJDRoXfGmuvtHr9YiLi8PevXvFzzidThw4cKDRbaanp0MQBDF2Qn2eHhR16/W+fftCoVDg7NmzDfKRmJgIAOjTp0+D+EY///xzs2UE3C8Kdu3ahU2bNmH37t1iL0Qg8HsFT8NL3Xq8/v3HkCFDcPz48QZlSUtLE8svlUoxduxYvPTSSzhy5AgKCwuxbds2v8pDSFdDDQyEEL9s2rQJVVVVmDVrFvr37+/1M3nyZHGYxJIlS/Dxxx9jyZIlyMnJwa+//ooXX3xR3E5KSgp27tyJoqIisdIfPXo0ysvL8dJLLyE/Px9vvfUWvvnmG6/99+zZEx988AFycnKwd+9eTJs27YrerGi1WkyZMgWLFi1CcXGxGPHas4+srCzs3r0bOTk5ePDBB1FaWtrk9m6++Wb885//xKFDh7B//3489NBDXtNkTZs2DZGRkZg4cSJ+/PFHFBQUYMeOHZg/fz7Onz+PgoICLFq0CHv27MGZM2fw3Xff4dSpU+jTp0/AZSOEEHL1aq6+AYBHH30Uy5cvx8aNG3HixAn86U9/8ppBob6UlBTMmDEDDzzwADZu3Chu0zNEITk5GRzHYdOmTSgvL4fJZIJOp8OTTz6Jxx9/HOvWrUN+fj4OHjyIN998E+vWrQMAPPTQQzh16hSeeuop5ObmYv369T5npfJl5MiRSEtLw3333ScOffQI9F7B0+jx/PPP49SpU9i8eTNeffVVrzQLFy7E7t27MW/ePGRnZ+PUqVP48ssvxSCPmzZtwhtvvIHs7GycOXMG77//PgRBEGf2IORqQw0MhBC/rFq1CmPHjvV66+4xefJk7N+/H0eOHMHo0aPx2Wef4auvvsKgQYNw8803e72lWLp0KQoLC9GjRw/xzUGfPn3w9ttv46233sLAgQOxb98+PPnkkw32X1VVhSFDhuDee+/F/PnzER0dfUVlmTVrFqqqqjBu3Div4R6LFy/GkCFDMG7cOIwePRqxsbGYNGlSk9t69dVXkZiYiBEjRuAPf/gDnnzySajVanG9Wq3Gzp07kZSUhLvuugt9+vTBrFmzYLVaERISArVajRMnTmDy5Mm45pprMGfOHMydOxcPPvjgFZWNEELI1am5+gYAnnjiCdx7772YMWMGMjMzodPpxKmkG7Ny5Urcfffd+NOf/oTevXtj9uzZ4hSNCQkJ+Mtf/oJnnnkGMTEx4kP3Cy+8gGeffRbLli1Dnz59MH78eGzevBndu3cH4B5a8N///hcbN27EwIED8c477+Dvf/+7X+XkOA4PPPAAqqqq8MADD3itC/ReQSaT4eOPP8aJEycwYMAAvPjii/jrX//qlWbAgAH44YcfcPLkSYwYMQKDBw/Gc889J94/hIaG4vPPP8fNN9+MPn364J133sHHH3+Mfv36+VUeQroajtUfPEwIIYQQQgghhBASIOrBQAghhBBCCCGEkBajBgZCCCGEEEIIIYS0GDUwEEIIIYQQQgghpMWogYEQQgghhBBCCCEtRg0MhBBCCCGEEEIIaTFqYCCEEEIIIYQQQkiLUQMDIYQQQgghhBBCWowaGAghhBBCCCGEENJi1MBACCGEEEIIIYSQFqMGBkIIIYQQQgghhLQYNTAQQgghhBBCCCGkxf4fmvwcAB7NDEEAAAAASUVORK5CYII=", "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()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Модель регресии демонстрирует ужасные результаты ввиду недостаточной корреляции между целеовй характеристикой и строковыми значениями." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.3" } }, "nbformat": 4, "nbformat_minor": 2 }