diff --git a/Consumer Complaint Dataset/README.md b/Consumer Complaint Dataset/README.md
new file mode 100644
index 000000000..8c4f09bcc
--- /dev/null
+++ b/Consumer Complaint Dataset/README.md	
@@ -0,0 +1,52 @@
+# Consumer Complaints Text Classification
+
+## Overview
+This project is a Natural Language Processing (NLP) task focused on classifying consumer complaints into specific financial categories. The goal is to streamline the complaint resolution process by routing complaints to the appropriate teams using an automated classification model. The project uses a dataset from the Consumer Financial Protection Bureau (CFPB) and applies a Random Forest Classifier to achieve this task.
+
+## Dataset
+
+### Context
+The Consumer Financial Protection Bureau (CFPB) is a federal U.S. agency that helps mediate disputes between consumers and financial institutions. Consumers submit complaints through a web form, and these complaints are then tagged to assist in routing and resolving issues. An NLP model can automate the classification and routing of these complaints, improving efficiency over manual tagging.
+
+### Content
+The dataset consists of complaint submissions from March 2020 to March 2021. Each submission has been labeled with one of nine financial product classes, which we consolidated into five main categories for this project:
+- **Credit Reporting**
+- **Debt Collection**
+- **Mortgages and Loans** (including car, payday, and student loans)
+- **Credit Cards**
+- **Retail Banking** (covering checking/savings accounts, money transfers, etc.)
+
+After data cleaning, the dataset contained approximately 162,400 complaints, with a significant class imbalance (56% in the credit reporting class and the remaining classes distributed between 8% and 14%).
+
+### Acknowledgements
+The dataset was organized by CFPB and cleaned by [halpert3](https://github.com/halpert3).
+
+## Project Structure
+- **notebooks/** - Contains Jupyter notebooks for data processing, training, and evaluation of the model.
+- **data/** - Directory to store the dataset (`complaints_processed.csv`).
+- **src/** - Source code for data preprocessing, model training, and evaluation.
+- **README.md** - Project overview and instructions.
+
+## Model
+We use a Random Forest Classifier to categorize each complaint into one of the five financial classes. The text data undergoes preprocessing, and we create a TF-IDF matrix for feature extraction. The model is then trained and evaluated on this matrix.
+
+### Performance
+The Random Forest model achieves approximately 79.6% accuracy, with a weighted F1-score of 0.80. Performance metrics are slightly varied due to class imbalance, with the model performing best on the majority class (Credit Reporting).
+
+
+## Installation
+1. Clone this repository:
+   ```bash
+   git clone https://github.com/yourusername/consumer-complaints-classification.git
+   ```
+2. Install the required libraries:
+   ```bash
+   pip install -r requirements.txt
+   ```
+3. Download and place `complaints_processed.csv` in the `ML-CaPsule/Consumer Complaint Dataset/complaints_processed.zip` directory.
+
+## Usage
+1. Open the `ML-CaPsule/Consumer Complaint Dataset/Complaint_Classification.ipynb` notebook to view the data processing and model training steps.
+2. Run the cells in the notebook to reproduce the results.
+
+
diff --git a/Consumer Complaint Dataset/Text_Classification_Random_Forest.ipynb b/Consumer Complaint Dataset/Text_Classification_Random_Forest.ipynb
new file mode 100644
index 000000000..31fa063d3
--- /dev/null
+++ b/Consumer Complaint Dataset/Text_Classification_Random_Forest.ipynb	
@@ -0,0 +1,415 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "cf83ab81",
+   "metadata": {},
+   "source": [
+    "# Text Classification Using Random Forest\n",
+    "\n",
+    "In this notebook, we will perform text classification using the **Random Forest** classifier. The data is loaded from a CSV file named **complaints_processed.csv**.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "4a31a634",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[nltk_data] Downloading package stopwords to\n",
+      "[nltk_data]     C:\\Users\\anany\\AppData\\Roaming\\nltk_data...\n",
+      "[nltk_data]   Unzipping corpora\\stopwords.zip.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Import necessary libraries\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import re\n",
+    "import string\n",
+    "import nltk\n",
+    "nltk.download('stopwords')\n",
+    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import confusion_matrix, classification_report\n",
+    "import matplotlib.pyplot as plt\n",
+    "import os\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "2c02e2bc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>product</th>\n",
+       "      <th>narrative</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>credit_card</td>\n",
+       "      <td>purchase order day shipping amount receive pro...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>credit_card</td>\n",
+       "      <td>forwarded message date tue subject please inve...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>retail_banking</td>\n",
+       "      <td>forwarded message cc sent friday pdt subject f...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>credit_reporting</td>\n",
+       "      <td>payment history missing credit report speciali...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>credit_reporting</td>\n",
+       "      <td>payment history missing credit report made mis...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "            product                                          narrative\n",
+       "0       credit_card  purchase order day shipping amount receive pro...\n",
+       "1       credit_card  forwarded message date tue subject please inve...\n",
+       "2    retail_banking  forwarded message cc sent friday pdt subject f...\n",
+       "3  credit_reporting  payment history missing credit report speciali...\n",
+       "4  credit_reporting  payment history missing credit report made mis..."
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Load the data\n",
+    "df = pd.read_csv('complaints_processed.csv', index_col=0)\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "78694eb0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--> There are 162421 rows and 2 columns\n",
+      "\n",
+      "===========================================================\n",
+      "\n",
+      "--> Missing Values:\n",
+      "\n",
+      " product       0\n",
+      "narrative    10\n",
+      "dtype: int64\n",
+      "\n",
+      "===========================================================\n",
+      "\n",
+      "Product Counts:\n",
+      "\n",
+      " product\n",
+      "credit_reporting       91179\n",
+      "debt_collection        23150\n",
+      "mortgages_and_loans    18990\n",
+      "credit_card            15566\n",
+      "retail_banking         13536\n",
+      "Name: count, dtype: int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Display dataset information\n",
+    "print(f'--> There are {df.shape[0]} rows and {df.shape[1]} columns')\n",
+    "print('\\n===========================================================\\n')\n",
+    "print('--> Missing Values:\\n\\n', df.isna().sum())\n",
+    "print('\\n===========================================================\\n')\n",
+    "print('Product Counts:\\n\\n', df['product'].value_counts())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "f4fb7ed8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "For Actual dataset:\n",
+      "\n",
+      " product\n",
+      "credit_reporting       56.136592\n",
+      "debt_collection        14.252729\n",
+      "mortgages_and_loans    11.692558\n",
+      "credit_card             9.584326\n",
+      "retail_banking          8.333795\n",
+      "Name: count, dtype: float64\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Drop missing values as they are minimal\n",
+    "df.dropna(axis=0, inplace=True)\n",
+    "\n",
+    "# Display class distribution in original dataset\n",
+    "print('For Actual dataset:\\n\\n', df['product'].value_counts() * 100 / len(df))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e30ffed1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Sample dataset:\n",
+      "\n",
+      " product\n",
+      "credit_reporting       56.24\n",
+      "debt_collection        15.16\n",
+      "mortgages_and_loans    11.15\n",
+      "credit_card             9.37\n",
+      "retail_banking          8.08\n",
+      "Name: count, dtype: float64\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Sampling the data for faster processing\n",
+    "data = df[['product', 'narrative']].sample(n=10000)\n",
+    "\n",
+    "# Display class distribution in sample dataset\n",
+    "print('Sample dataset:\\n\\n', data['product'].value_counts() * 100 / len(data))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "a6b5f661",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define a function to clean text data\n",
+    "stopwords = nltk.corpus.stopwords.words('english')\n",
+    "\n",
+    "def text_clean(text):\n",
+    "    \"\"\"\n",
+    "    This function performs the following tasks:\n",
+    "    1. Converts text to lowercase\n",
+    "    2. Removes digits\n",
+    "    3. Removes words with fewer than 3 characters\n",
+    "    4. Removes stopwords\n",
+    "    \"\"\"\n",
+    "    clean_words = []\n",
+    "    word_list = text.split()\n",
+    "    for word in word_list:\n",
+    "        word_l = word.lower().strip()\n",
+    "        if word_l.isalpha() and len(word_l) > 3 and word_l not in stopwords:\n",
+    "            clean_words.append(word_l)\n",
+    "    return clean_words\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "197e01ec",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape of Term Document Matrix: (10000, 13197)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Creating the Term Document Matrix\n",
+    "tfidf = TfidfVectorizer(analyzer=text_clean)\n",
+    "x_tfidf = tfidf.fit_transform(data['narrative'])\n",
+    "\n",
+    "# Display shape of matrix\n",
+    "print(\"Shape of Term Document Matrix:\", x_tfidf.shape)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "a5ab2a61-eefe-457d-8eb2-73353d112c36",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate the confusion matrix\n",
+    "cm = confusion_matrix(y_test, prediction, normalize='true')\n",
+    "\n",
+    "# Define the class names as per data\n",
+    "class_names = ['credit_card', 'credit_reporting', 'debt_collection', 'mortgages_and_loans', 'retail_banking']\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "cad6b62d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Confusion Matrix:\n",
+      "\n",
+      " [[  98   54    1    8   15]\n",
+      " [   8 1097    9    4    0]\n",
+      " [   4  176  139    9    2]\n",
+      " [   5   54    4  156    4]\n",
+      " [  13   23    5    2  110]]\n",
+      "\n",
+      "\n",
+      "Classification Report:\n",
+      "\n",
+      "                      precision    recall  f1-score   support\n",
+      "\n",
+      "        credit_card       0.77      0.56      0.64       176\n",
+      "   credit_reporting       0.78      0.98      0.87      1118\n",
+      "    debt_collection       0.88      0.42      0.57       330\n",
+      "mortgages_and_loans       0.87      0.70      0.78       223\n",
+      "     retail_banking       0.84      0.72      0.77       153\n",
+      "\n",
+      "           accuracy                           0.80      2000\n",
+      "          macro avg       0.83      0.68      0.73      2000\n",
+      "       weighted avg       0.81      0.80      0.78      2000\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Train Test Split\n",
+    "X_train, X_test, y_train, y_test = train_test_split(x_tfidf, data['product'], test_size=0.2, random_state=42)\n",
+    "\n",
+    "# Train RandomForest Classifier\n",
+    "rfc = RandomForestClassifier(n_jobs=-1)\n",
+    "rfc_model = rfc.fit(X_train, y_train)\n",
+    "\n",
+    "# Predict on test set\n",
+    "prediction = rfc_model.predict(X_test)\n",
+    "\n",
+    "# Display Confusion Matrix and Classification Report\n",
+    "print(\"Confusion Matrix:\\n\\n\", confusion_matrix(y_test, prediction))\n",
+    "print(\"\\n\")\n",
+    "print(\"Classification Report:\\n\\n\", classification_report(y_test, prediction))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "8ce0544f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6IAAAOACAYAAAAgnM66AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADV+0lEQVR4nOzdd3wT9R/H8XdaaAt0sdqy9x6lFMreW2UpQ0AoW0AEZAiI7Kmy95IpygZBEQUEVPbGnyDIkl02pUVoafv7ozQSmkAb2zSF19PHPSSX7919LpdL+sn3c98zREVFRQkAAAAAABtxSOoAAAAAAACvFxJRAAAAAIBNkYgCAAAAAGyKRBQAAAAAYFMkogAAAAAAmyIRBQAAAADYFIkoAAAAAMCmUiR1AAAAAACQ3Dx69EhhYWFJHYZZTk5OcnFxSeowXohEFAAAAADi4dGjR0rlll568jCpQzHLx8dH58+ft+tklEQUAAAAAOIhLCxMevJQzoUDJUenpA7HVESYrp9YrLCwMBJRAAAAAHjlODrJYGeJaFRSBxBHJKIAAAAAYA2DQ/RkT+wtHguSR5QAAAAAgFcGiSgAAAAAwKYozQUAAAAAaxgkGQxJHYUpOwvHEnpEAQAAAAA2RSIKAAAAALApSnMBAAAAwBqMmmu15BElAAAAAOCVQSIKAAAAALApSnMBAAAAwBoGgx2Ommtn8VhAjygAAAAAwKZIRAEAAAAANkVpLgAAAABYg1FzrZY8ogQAAAAAvDJIRAEAAAAANkVpLgAAAABYg1FzrUaPKAAAAADApkhEAQAAAAA2RWkuAAAAAFjFDkfNTSZ9jckjSgAAAADAK4NEFAAAAABgU5TmAgAAAIA1GDXXavSIAgAAAABsikQUAAAAAGBTlOYCAAAAgDUMdjhqrr3FY0HyiBIAAAAA8MogEQUAAAAA2BSluQAAAABgDUbNtRo9ogAAAAAAmyIRBQAAAADYFKW5AAAAAGANRs21WvKIEgAAAADwyiARBQAAAADYFKW5AAAAAGANRs21Gj2iAAAAAACbIhEFAAAAANgUpbkAAAAAYA1GzbVa8ogSAAAAAPDKIBEFAAAAANgUpbkAAAAAYA2Dwf5KYRk1FwAAAACA2EhEAQAAAAA2RWkuAAAAAFjDwRA92RN7i8cCekQBAAAAADZFIgoAAAAAsClKcwEAAADAGgYHOxw1187isSB5RAkAAAAAeGWQiAIAAAAAbIrSXAAAAACwhsEQPdkTe4vHAnpEAQAAAAA2RSIKAAAAALApElEAwCunatWqqlq1qvHxhQsXZDAYtGjRIpvG0bZtW+XMmdOm27TW0qVLVbBgQaVMmVKenp4Jvv5hw4bJkEzKxWwhqd6TABJYzKi59jYlA8kjSgBAglq0aJEMBoNcXFx05cqVWM9XrVpVRYsWTYLIXm/r1q1TvXr1lCFDBjk5OSlz5sxq1qyZfv7550Td7p9//qm2bdsqT548mjdvnubOnZuo27M1g8Egg8Ggjh07mn1+0KBBxja3bt2K9/o3bdqkYcOG/ccoAeD1QiIKAK+xx48fa9y4cUkdRqLLkSOH/vnnH7Vu3TqpQzErKipK7dq109tvv62goCD17t1bs2fP1gcffKBz586pRo0a2r17d6Jtf8eOHYqMjNSUKVPUtm1bNWvWLMG38emnn+qff/5J8PXGlYuLi9asWaOwsLBYz33zzTdycXGxet2bNm3S8OHD47WMvb8nASCxkYgCwGusRIkSmjdvnq5evZpo24iKikrSBESSsffX0dExSeOwZMKECVq0aJF69eqlQ4cO6ZNPPlH79u01aNAgHTx4UEuWLFGKFIk30P2NGzckKVFKcmOkSJHiPyV7/1XdunUVHBysH374wWT+7t27df78eb355ps2iePJkycKCwuz+/ckgDiKGTXX3qZkgEQUAF5jn3zyiSIiIuLUK/rkyRONHDlSefLkkbOzs3LmzKlPPvlEjx8/NmmXM2dOvfXWW/rxxx9VqlQppUqVSnPmzNGOHTtkMBi0cuVKDR8+XFmyZJGbm5uaNGmi+/fv6/Hjx+rVq5e8vLzk6uqqdu3axVr3woULVb16dXl5ecnZ2VmFCxfWrFmzXhr789fjxcRibnr+ms4ffvhBlSpVUpo0aeTm5qY333xTf/zxR6xtrF+/XkWLFpWLi4uKFi2qdevWvTQuSfrnn380duxYFSxYUOPHjzd7HWXr1q0VEBBgfHzu3Dk1bdpU6dKlU+rUqVW2bFl9//33Jss8+3qPHj1aWbNmlYuLi2rUqKEzZ84Y2+XMmVNDhw6VJGXMmFEGg8FYZvrsv5+VM2dOtW3b1vg4PDxcw4cPV758+eTi4qL06dOrYsWK2rJli7GNuWtE4/ue+u233xQQECAXFxflzp1bS5YsefGL+4wsWbKocuXK+vrrr03mL1u2TMWKFTNbiv7rr7+qadOmyp49u5ydnZUtWzZ99NFHJj+stG3bVjNmzDC+XjGT9O/7bvz48Zo8ebJxP0+cOBHrPXnjxg1lzJhRVatWVVRUlHH9Z86cUZo0adS8efM47ysAJAfcRxQAXmO5cuVSmzZtNG/ePA0YMECZM2e22LZjx45avHixmjRpoj59+mjfvn0aO3asTp48GSvpOnXqlFq0aKH3339fnTp1UoECBYzPjR07VqlSpdKAAQN05swZTZs2TSlTppSDg4Pu3r2rYcOGae/evVq0aJFy5cqlIUOGGJedNWuWihQpogYNGihFihTauHGjunXrpsjISH3wwQdx3u9ChQpp6dKlJvPu3bun3r17y8vLyzhv6dKlCgwMVJ06dfTZZ5/p4cOHmjVrlipWrKgjR44Yk9affvpJ77zzjgoXLqyxY8fq9u3bateunbJmzfrSWH777TfduXNHvXr1ilPvWFBQkMqXL6+HDx+qR48eSp8+vRYvXqwGDRpo9erVaty4sUn7cePGycHBQX379tX9+/f1+eefq1WrVtq3b58kafLkyVqyZInWrVunWbNmydXVVcWLF39pHM8aNmyYxo4dq44dOyogIEDBwcE6ePCgDh8+rFq1allcLj7vqTNnzqhJkybq0KGDAgMDtWDBArVt21b+/v4qUqRInOJs2bKlevbsqZCQELm6uurJkydatWqVevfurUePHsVqv2rVKj18+FBdu3ZV+vTptX//fk2bNk2XL1/WqlWrJEnvv/++rl69qi1btsR6T8VYuHChHj16pM6dO8vZ2Vnp0qVTZGSkSRsvLy/NmjVLTZs21bRp09SjRw9FRkaqbdu2cnNz08yZM+O0jwCQXJCIAsBrbtCgQVqyZIk+++wzTZkyxWybY8eOafHixerYsaPmzZsnSerWrZu8vLw0fvx4bd++XdWqVTO2P3PmjDZv3qw6deoY5+3YsUNSdC/Yzp07lTJlSknSzZs3tXz5ctWtW1ebNm0yrvvMmTNasGCBSSK6c+dOpUqVyvi4e/fuqlu3riZOnBivRNTb21vvvfee8XFUVJQaNGggZ2dnYw9VSEiIevTooY4dO5oM3hMYGKgCBQpozJgxxvn9+/eXt7e3fvvtN3l4eEiSqlSpotq1aytHjhwvjOXkyZOSpGLFisUp9nHjxikoKEi//vqrKlasKEnq1KmTihcvrt69e6thw4ZycPi34OnRo0c6evSonJycJElp06ZVz5499b///U9FixZVo0aNdPToUa1bt05NmjRRhgwZ4hTHs77//nu98cYb8RrkKL7vqVOnTumXX35RpUqVJEnNmjVTtmzZtHDhQo0fPz5O22zSpIm6d++u9evX67333tNPP/2kW7duqUWLFlq4cGGs9p999pnJ+61z587KmzevPvnkE128eFHZs2dXuXLllD9/fm3ZssXkPfWsy5cv68yZM8qYMaNx3oULF8zG16JFCw0cOFD16tXTt99+q127dmn9+vVKnz59nPYRAJILSnMB4DWXO3dutW7dWnPnztW1a9fMtolJEHv37m0yv0+fPpIUqyw0V65cJknos9q0aWNMQiWpTJkyioqKUvv27U3alSlTRpcuXdKTJ0+M855NCu7fv69bt26pSpUqOnfunO7fv/+yXbVo5MiR+u6777Ro0SIVLlxYkrRlyxbdu3dPLVq00K1bt4yTo6OjypQpo+3bt0uSrl27pqNHjyowMNCYhEpSrVq1jOt6keDgYEmSm5tbnGLdtGmTAgICjEmoJLm6uqpz5866cOGCTpw4YdK+Xbt2xiRUkjGRO3fuXJy2Fxeenp76448/9Ndff8V5mfi+pwoXLmyMXYouIy5QoEC89iNt2rSqW7euvvnmG0nS119/rfLly1v8seDZ91toaKhu3bql8uXLKyoqSkeOHInzdt955x2TJPRFpk+fLg8PDzVp0kSDBw9W69at1bBhwzhvC4CNJfVtWrh9CwAgOfv000/15MkTi9eK/v3333JwcFDevHlN5vv4+MjT01N///23yfxcuXJZ3Fb27NlNHsckb9myZYs1PzIy0iTB3LVrl2rWrKk0adLI09NTGTNm1CeffCJJVieimzdv1vDhwzVw4EC98847xvkxSVX16tWVMWNGk+mnn34yDvATs+/58uWLte5nS5ItcXd3lyQ9ePAgTvH+/fffZtdbqFAhk3hiPP96p02bVpJ09+7dOG0vLkaMGKF79+4pf/78KlasmPr166fjx4+/cJn4vqee3w8pel/iux8tW7bUli1bdPHiRa1fv14tW7a02PbixYtq27at0qVLJ1dXV2XMmFFVqlSRFL/324vOh+elS5dOU6dO1fHjx+Xh4aGpU6fGeVkASE4ozQUAKHfu3Hrvvfc0d+5cDRgwwGI7cwPpmPNsT9LzLF0HaWl+zMAtZ8+eVY0aNVSwYEFNnDhR2bJlk5OTkzZt2qRJkybFuuYuLs6fP69WrVqpVq1aGjVqlMlzMetbunSpfHx8Yi2bUKPYFixYUJL0+++/q1GjRgmyzme97HW1RkREhMnjypUr6+zZs/r222/1008/af78+Zo0aZJmz55t8d6dMeL6nkqo/YgpwQ4MDNTjx48t3qomIiJCtWrV0p07d9S/f38VLFhQadKk0ZUrV9S2bdt4vd9edD6Y8+OPP0qK/rHg8uXLiTqaMQAkFRJRAICk6F7Rr776Sp999lms53LkyKHIyEj99ddfxp43KXrgnHv37r30OsiEsHHjRj1+/FgbNmww6R2LKZGNr3/++Udvv/22PD099c0335hcVylJefLkkRQ9iEzNmjUtridm382VpZ46deqlcVSsWFFp06bVN998o08++eSlAxblyJHD7Hr//PNPk3gSQtq0aXXv3j2TeWFhYWZLuNOlS6d27dqpXbt2CgkJUeXKlTVs2DCLiWhSvadSpUqlRo0a6auvvlK9evUsXhP7+++/6/Tp01q8eLHatGljnP/sSMAx4ppMx8XmzZs1f/58ffzxx1q2bJkCAwO1b9++RL19D4D/wB5vl2Jv8VhAaS4AQFJ04vXee+9pzpw5un79uslzb7zxhqToEVafNXHiREmyyT0YYxK0Z3vA7t+/b3aQmbjo0qWLTp8+rXXr1hnLVZ9Vp04dubu7a8yYMQoPD4/1/M2bNyVJmTJlUokSJbR48WKTcs0tW7bEul7TnNSpU6t///46efKk+vfvb7aH76uvvtL+/fslRR+L/fv3a8+ePcbnQ0NDNXfuXOXMmTNO16XGVZ48efTLL7+YzJs7d26sHtHbt2+bPHZ1dVXevHlj3YblWUn5nurbt6+GDh2qwYMHW2xj7v0WFRVldkCvNGnSSFKspD2+7t27Zxx5eMyYMZo/f74OHz6sMWPG/Kf1AoA94uc1AIDRoEGDtHTpUp06dcrklhi+vr4KDAzU3Llzde/ePVWpUkX79+/X4sWL1ahRI5PRTRNL7dq15eTkpPr16+v9999XSEiI5s2bJy8vL4uDLFny/fffa8mSJXrnnXd0/Phxk+sZXV1d1ahRI7m7u2vWrFlq3bq1SpYsqXfffVcZM2bUxYsX9f3336tChQqaPn26pOhb0rz55puqWLGi2rdvrzt37mjatGkqUqSIQkJCXhpPv3799Mcff2jChAnavn27mjRpIh8fH12/fl3r16/X/v37tXv3bknSgAED9M0336hevXrq0aOH0qVLp8WLF+v8+fNas2ZNrJ7d/6Jjx47q0qWL3nnnHdWqVUvHjh3Tjz/+GKsXsXDhwqpatar8/f2VLl06HTx4UKtXr1b37t0trjsp31O+vr7y9fV9YZuCBQsqT5486tu3r65cuSJ3d3etWbPG7DWp/v7+kqQePXqoTp06cnR01LvvvhvvuHr27Knbt29r69atcnR0VN26ddWxY0eNGjVKDRs2fGnMAJCckIgCAIzy5s2r9957T4sXL4713Pz585U7d24tWrRI69atk4+PjwYOHKihQ4faJLYCBQpo9erV+vTTT9W3b1/5+Pioa9euypgxY6wRd18mpjdzzZo1WrNmjclzOXLkMF6r2bJlS2XOnFnjxo3TF198ocePHytLliyqVKmS2rVrZ1ymbt26WrVqlT799FMNHDhQefLk0cKFC/Xtt98ab1vzIg4ODlqyZIkaNmyouXPnavz48QoODlbGjBlVuXJlff755ypXrpyk6FvP7N69W/3799e0adP06NEjFS9eXBs3bkzwXsROnTrp/Pnz+vLLL7V582ZVqlRJW7ZsUY0aNUza9ejRQxs2bNBPP/2kx48fK0eOHBo1apT69ev3wvUn9XvqRVKmTKmNGzeqR48eGjt2rFxcXNS4cWN17949VkL49ttv68MPP9Ty5cv11VdfKSoqKt6J6IYNG7RkyRJNmDDBeN2wFN1DvGXLFgUGBurAgQMmI04DsAP2OEqtvcVjgSHqv4xWAAAAAACvmeDgYHl4eMi5xmgZUrgkdTgmop480uNtg3T//n3jyOz2KHmkywAAAACAVwaluQAAAABgDUbNtRo9ogAAAAAAmyIRBQAAAADYFKW5AAAAAGAVOxw1N5n0NZKI4rUVGRmpq1evys3NTYZkUksPAADwOomKitKDBw+UOXPmBL1PMpIeiSheW1evXlW2bNmSOgwAAAC8xKVLl5Q1a9akDgMJiEQUry03NzdJUoUR65XCJU0SRwNb+LByrqQOATZUIU+GpA4BNhbJrdFfKw8fRyR1CLCBBw8eqGThXMa/2+wOo+ZajUQUr62YctwULmmUIhWJ6OsgtaudfokhUdjzTbyROEhEXy+OJKKvFS6jevVQaA0AAAAAsCl6RAEAAADAGgaD/Y2am0x6j+3sVQMAAAAAvOpIRAEAAAAANkVpLgAAAABYw+Bgh6W5dhaPBckjSgAAAADAK4NEFAAAAABgU5TmAgAAAIA1DAb7G6XW3uKxgB5RAAAAAIBNkYgCAAAAAGyK0lwAAAAAsAaj5loteUQJAAAAAHhlkIgCAAAAAGyK0lwAAAAAsAaj5lqNHlEAAAAAgE2RiAIAAAAAbIrSXAAAAACwBqPmWi15RAkAAAAAeGWQiAIAAAAAbIrSXAAAAACwBqPmWo0eUQAAAACATZGIAgAAAABsitJcAAAAALCCwWCQwd5KYe0tHgvoEQUAAAAA2BSJKAAAAADApijNBQAAAAArUJprPXpEAQAAAAA2RSIKAAAAALApSnMBAAAAwBqGp5M9sbd4LKBHFAAAAABgUySiAAAAAACbojQXAAAAAKzAqLnWo0cUAAAAAGBTJKIAAAAAAJuiNBcAAAAArEBprvXoEQUAAAAA2BSJKAAAAADApijNBQAAAAArUJprPXpEAQAAAAA2RSIKAAAAALApSnMBAAAAwAqU5lqPHlEAAAAAgE2RiAIAAAAAbIrSXAAAAACwhuHpZE/sLR4L6BEFAAAAANgUiSgAAAAAwKYozQUAAAAAKzBqrvXoEQUAAAAA2BSJKAAAAADApijNBQAAAAArGAyyw9LcpA4gbugRBQAAAADYFIkoAAAAAMCmKM0FAAAAACsYZIej5iaT2lx6RAEAAAAANkUiCiRzDYp566s2ftrUpYymNSmqAl6uL2yfxslRH1bOpRXt/LWpaxkteq+EAnJ4/qd1wnY2frNAbWuXUsOS2dWrRV2d+v2wxbabVy9VvzYN1Kx8fjUrn1+fdGwSq/3dWzc0cVAPvVetuBqXyqnB77+rK3+fS+zdQBzNmTVDhfLnUjr3VKpSsawOHtj/wvZr16ySX7FCSueeSqVLFtfmHzaZPP/t+rWq/0YdZcuUQWmcHXTs2NFEjB7xNXf2TBXJn1sZPFKrWqVyLz3e69asUsnihZXBI7XK+Pvqx83/Hu/w8HANHjRAZfx95Z3OTflyZVXn9oG6dvVqYu8G4mjBvFkqVSyfcni5qV71Cjp86MAL229Yt1oVSxVVDi83VS3np60//WDyvI+Hk9lpxpQJibkbgNVIRGF04cIFGQwGHT16VJK0Y8cOGQwG3bt3L0njiovnY39dVM2bXl0q5tTSA5fVZcVxnbv9UOMaFJJnKvNV9ykcDPq8YWH5uDtrxA+n1e6ro5r48zndCgmzep2wnZ0/rNe8z4eqZdc+mrZqi3IXKKLB77+re7dvmm1//MBuVXmjscYuWKsJX32vDD5Z9Gnn5roVdE2SFBUVpZE92+ra5b81ZOpiTVu1VV6Zs+qTjk316GGoLXcNZqxetUIDPu6jgYOGaNe+QypWrLgavlVXN27cMNt+757datu6pdq0ba/d+w6rfoOGerdpY/3xx/+MbUJDQ1W+QgWNHD3OVruBOFqzaoUGftxHAwYN1m97D6poseJqXL+ebr7geLdr00pt2rbXb/sO6a36DdWi6ds68fR4P3z4UMeOHFb/gYP0696DWrZ8tf7667SaN2lkw72CJevXrNSwT/qpT/9P9dMv+1SkaHG1aPymbt40f7wP7Nujrh1aq0Xrdtry637Ve7OB2rVsopMn/j2/j5++aDJNmjFPBoNBbzVobKvdei0ZDAa7nJIDQ1RUVFRSBwH7cOHCBeXKlUtHjhxRiRIlFBYWpjt37sjb21sGg0GLFi1Sr1697DIxfT72uAgODpaHh4eqfL5FKVKlSdwAE8m0JkV16kaopv9yXlL0FQHftPXX+uPXtPxw7F+93yrirWYlM6vdsqOKiDR/6sd3nclJn2p5kjqE/6RXi7rKX9RP3QaNlSRFRkYqsKaf6rfsoGYde7x0+YiICDUrn1/dPhmrGg2b6fKFs+r8VnnNWr9TOfIWNK6zVdWiCuzxieo2eS9R9yexVcmXMalD+E+qVCwrf/9SmjhluqToY5M/T3Z16dZdffsNiNW+Tat3FRoaqjXrNxrnVa1UTsWL+2rqjNkmbf++cEGFC+TW7v2H5etbIlH3w5Yik/GfNNUqlVNJ/1KaMHmapOjjXTBvDr3ftbv69Osfq33ge9HHe/W6f493tcrlVby4r6ZMn2V2G4cOHlDVimV14vR5ZcuePXF2xIZCH0ckdQhWq1e9gkqULKWx46dIij7eJQvnVofO3fRh749jte/ctqUePnyor1auN857o0ZFFS3mq88nzzC7jbYt31HIgxCt3vhjouyDrTwIDla+bBl0//59ubu7J3U4RjF/R6ZtPl8Gp9RJHY6JqLCHuruiY7xfsxkzZuiLL77Q9evX5evrq2nTpikgIMBi+8mTJ2vWrFm6ePGiMmTIoCZNmmjs2LFycXGJ0/boEX0FhYeHJ8h6nJyc5OPjY1e/qoSFhb280WsihYNB+b1cdfjSPeO8KEmHL99TYR83s8uUy5VWJ64/UI8qubSqvb/mtfBVC/8scjBYv07YRnh4mM6cOK4SZSsZ5zk4OKhE2cr689jBOK3j8aN/FPHkiVw9PKPXGfZYkuTk9O8XhoODg1KmdNaJIy8uCUTiCgsL05HDh1Stek3jPAcHB1WrXlP79+41u8y+fXtUrXoNk3k1a9XWvn3m28N+xBzvqs8cPwcHB1WtVkP79+0xu8z+vXtN3h+SVLNmbe1/wfEOvn9fBoNBHp6eCRI3rBMWFqbjRw+rctXqxnkODg6qVLW6Dh4wf/wOHdhn0l6SqtaoZbH9zRtB2vrjD2rZpm2CxY1X24oVK9S7d28NHTpUhw8flq+vr+rUqWOxCufrr7/WgAEDNHToUJ08eVJffvmlVqxYoU8++STO2yQRTSYiIyP1+eefK2/evHJ2dlb27Nk1evRoY0nqihUrVKVKFbm4uGjZsmWSpPnz56tQoUJycXFRwYIFNXPmTJN17t+/X35+fnJxcVGpUqV05MgRk+efLc3dsWOH2rVrp/tPv8QMBoOGDRv20rgfP36s/v37K1u2bHJ2dlbevHn15ZdfSorunenQoYNy5cqlVKlSqUCBApoyZYrJ8m3btlWjRo00evRoZc6cWQUKFIhT7JZiCQ4ONpmSM49UKeToYNDdf0x/eLj7MFxpU6c0u0wmDxdVzpNeDgaDPtn4p5YduKymfpnUqlRWq9cJ2wi+e0eRERFKm960l88zfUbduWX+S+J5CyeOVLqM3vIrV1mSlC1XPmXMlFULp4zWg/v3FB4eplVfTtOtoKu6czMowfcBcXf71i1FRETIy9vbZL6Xl5eCgq6bXSbo+nUz7b0ttof9MB5vr+eOn7e3bgSZPxeDgq7Ly8srVntLx/vRo0ca8ulANW32rl31Kr2O7tyOPt4ZnzveGTN6WTzeN4KuK+NzxztjRsvvjxVfL5Wrq5veqE9ZbqIz2OkUTxMnTlSnTp3Url07FS5cWLNnz1bq1Km1YMECs+13796tChUqqGXLlsqZM6dq166tFi1aaP/+uP+QzUVfycTAgQM1b948TZo0SRUrVtS1a9f0559/Gp8fMGCAJkyYYEzOli1bpiFDhmj69Ony8/PTkSNH1KlTJ6VJk0aBgYEKCQnRW2+9pVq1aumrr77S+fPn1bNnT4vbL1++vCZPnqwhQ4bo1KlTkiRX15cPYNOmTRvt2bNHU6dOla+vr86fP69bt25Jik6us2bNqlWrVil9+vTavXu3OnfurEyZMqlZs2bGdWzbtk3u7u7asmWLJMU79hhjx47V8OHDX9ruVeZgkO79E65J288qMkr662ao0rs6qZlfZi09cDmpw0MiWjl/qnb+sF6fLVwrJ+foHtAUKVPq08kLNGXIR2peoYAcHB3lV7aySlWqIa7aAF4d4eHhatOquaKiojRp2syXL4Bkb/lXi/R2sxZxLpHEq+n5ThdnZ2c5OzvHahcWFqZDhw5p4MCBxnkODg6qWbOm9uwxX5VRvnx5ffXVV9q/f78CAgJ07tw5bdq0Sa1bt45zfCSiycCDBw80ZcoUTZ8+XYGBgZKkPHnyqGLFirpw4YIkqVevXnr77beNywwdOlQTJkwwzsuVK5dOnDihOXPmKDAwUF9//bUiIyP15ZdfysXFRUWKFNHly5fVtWtXszE4OTnJw8NDBoNBPj4+cYr79OnTWrlypbZs2aKaNaPLh3Lnzm18PmXKlCaJYa5cubRnzx6tXLnSJBFNkyaN5s+fLycnJ0nS3Llz4xV7jIEDB6p3797Gx8HBwcqWLVuc9sUe3f/niSIio5Q2lWlPZdrUKXX3ofny7Nuh4YqIjNSzl4devPOP0qdxUgoHg1XrhG24p00nB0dH3X1uYKJ7t28qXQYvC0tFW7NwplZ9OU2j561SrgJFTJ7LV8RX09f8rNAHwXoSHiaPdBnUq0Vd5StSIqF3AfGQPkMGOTo6xurtuHHjhry9zX8Ge/v4mGkfZLE97IfxeN947vgFBcXq5Y7h7e0Tq2TuRlDs4x2ThF66eFHfbd5Kb6gdSJc++njffO5437x5w+Lx9vL2iTVw1c2b5t8fe3f/pjN/ndachcsSLmgkS8//nTt06FCzFY23nlZleD/3fvL29jbp+HpWy5YtdevWLVWsWFFRUVF68uSJunTpQmnuq+bkyZN6/PixatSoYbFNqVKljP8ODQ3V2bNn1aFDB7m6uhqnUaNG6ezZs8Z1Fi9e3OSXsnLlyiVo3EePHpWjo6OqVKlisc2MGTPk7++vjBkzytXVVXPnztXFixdN2hQrVsyYhP6X2J2dneXu7m4yJWdPIqN0+kaISmbzMM4zSPLL6qET1x+YXeaPa8HK7OFiUrGR1dNFt0LD9CQyyqp1wjZSpnRS3sLFdWzfr8Z5kZGROrrvVxX0LWVxuVULpuubORM1cvY3yl+0hMV2adzc5ZEug678fU5n/jimctXqJmT4iCcnJyf5lfTXju3bjPMiIyO1Y/s2BZQta3aZMmXKacf2n03m/bxtq8qUMd8e9iPmeO985vhFRkZq546fFVDG/PdbQNmyJu8PSfr5560KeOZ4xyShZ8+c0YZNPyl9+vSJswOIFycnJxUvUVK/7txunBcZGanfdm5XqdLmz1f/0mX0607T8/uX7dvMtv966UIVL1FSRYr5JmzgMM8ORsiNNWLu0/FdLl26pPv37xunZ3s8/6sdO3ZozJgxmjlzpg4fPqy1a9fq+++/18iRI+O8DnpEk4FUqVK9tE2aNP+O+hoSEiJJmjdvnsqUKWPSztHRMWGDe4GXxb18+XL17dtXEyZMULly5eTm5qYvvvhC+/btM2n37L7B1Jqj1/Rxzbw6dSNUp4JC9LZvJrmkcNTmk9G9Zv1r5tWt0DB9uSc6ud/4vyA1LO6jDyrn1Lrj15XVw0UtS2XRumPX47xOJJ3Gbbpo4qAeylekhPIX9dO3X83V438eqlajdyVJ4wd2V3ovH7X76FNJ0qovp2np9M/18eez5JUlu/Fa0lSp0yhV6ujz6tcfN8gjbXplzJRFF/46qTnjBqts9XoqWaFqkuwj/vVhz4/UuUNb+fmXUqlSAZoxbbIehoaqdZt2kqSO7QOVOXNmjRgVPYpyt+49VKdmVU2ZNEF1672p1auW6/Chg5o2c45xnXfu3NGlSxeN95L863T0pRbe3j5xrnZB4ujeo5fe79hOfiX95V86QDOnTXl6vNtKkjq3D1SmzFk0fNQYSVLXD3qoXq1qmjp5ourUe0NrVq7QkUMHNe3pCMnh4eF6r0VTHTtyRKvWbVBkRISCrkd/1qdNl87kB17Y3vsf9FTPrh3k61dSfv6lNW/mND0MDdW770VXvnV/v50yZcqsQcNGS5I6df1Qjd+ooVnTJqlmnXpav2aljh05pC+mmJZaPwgO1sb1azRs1Oc23yfYn7h2vGR4WpUR9FxVTVBQkMXvhsGDB6t169bq2LGjpOiOo9DQUHXu3FmDBg2Sg8PL+ztJRJOBfPnyKVWqVNq2bZvxYL+It7e3MmfOrHPnzqlVq1Zm2xQqVEhLly7Vo0ePjD2Ley2MxBjDyclJERFxHyq9WLFi0b/o7txpLM191q5du1S+fHl169bNOC+mx/ZFrIn9VbXjzG15pEqptgHZlDZNSp29GaqBG0/q3tPBhrzcnExuZ3AzJEwDNpxUt4o5Ne9dX90KDdPaY9e14vCVOK8TSadKvUYKvntbS6d/rru3bih3wSIaMfsbpX1amnvz2hWTD/7vVyzWk/Awjfmog8l6Wnbtq/c+6CdJunMzSPM+H6p7t28qbUZv1WjQVC269BaSXpOmzXXr5k2NGjFUQdevq7hvCa3f+IOxdOrypYsmx7tsufJauGSZRgwdrGFDBilP3nxavmqdihQpamzz/Xcb1KVTe+PjwPdaSJI++XSIBg0eZpsdg1nvNG2uW7duafSIYQoKij7eazdsMpZeXrp0SYbnjveCxV9pxLAhGv70eH+zaq0KPz3eV69c0abvom/tUj6gpMm2Nv24TZWqVLXJfsG8Ru800+3bt/T5mBG6GXRdRYr56pu13xkHMLpy+ZLJ+V26TDnNnL9En40aqrEjBitXnrxa+PVqFSpc1GS969eslKKi1LhJc5vuD5I3Jycn+fv7a9u2bWrUqJGk6F76bdu2qXv37maXefjwYaxkM6bDK67jTHAf0WRi+PDhmjJliiZPnqwKFSro5s2b+uOPP1SjRg2z98+cP3++evTooXHjxqlu3bp6/PixDh48qLt376p3794KCQlRrly5VLduXQ0cOFAXLlxQz549debMGeO6duzYoWrVqunu3bvy9PQ0jo61detW+fr6KnXq1Eqd+sX3TWrXrp22bdtmHKzo77//1o0bN9SsWTNNnTpVgwcP1sqVK5UrVy4tXbpUU6dOVa5cuXT06FFJ0aPm3rt3T+vXrzeuMy6xx8WrcB9RxE9yv48o4ie530cU8Zec7yOK+EvO9xFF3Nn7fUTTtVwgBzu7j2hk2EPd+bp9vF6zFStWKDAwUHPmzFFAQIAmT56slStX6s8//5S3t7fatGmjLFmyaOzY6CqcYcOGaeLEiZo7d67KlCmjM2fOqGvXrvL399eKFSvitE16RJOJwYMHK0WKFBoyZIiuXr2qTJkyqUuXLhbbd+zYUalTp9YXX3yhfv36KU2aNCpWrJh69eolKXrE240bN6pLly7y8/NT4cKF9dlnn+mdd96xuM7y5curS5cuat68uW7fvm3xgudnzZo1S5988om6deum27dvK3v27MaLmN9//30dOXJEzZs3l8FgUIsWLdStWzf98MMPL1ynNbEDAAAAMK958+a6efOmhgwZouvXr6tEiRLavHmzsQrn4kXTKpxPP/1UBoNBn376qa5cuaKMGTOqfv36Gj16dJy3SY8oXlv0iL5+6BF9vdAj+vqhR/T1Qo/o64Ee0fizpkc0KdAjCgAAAABWMI5Ua0fsLR5LuH0LrPbrr7+a3B7m+QkAAAAAzKFHFFYrVaqUcVAhAAAAAIgrElFYLVWqVMqbN29ShwEAAAAkDcPTyZ7YWzwWUJoLAAAAALApElEAAAAAgE1RmgsAAAAAVmDUXOvRIwoAAAAAsCkSUQAAAACATVGaCwAAAABWoDTXevSIAgAAAABsikQUAAAAAGBTlOYCAAAAgBUozbUePaIAAAAAAJsiEQUAAAAA2BSluQAAAABgBUpzrUePKAAAAADApkhEAQAAAAA2RWkuAAAAAFjD8HSyJ/YWjwX0iAIAAAAAbIpEFAAAAABgU5TmAgAAAIAVGDXXevSIAgAAAABsikQUAAAAAGBTlOYCAAAAgBUozbUePaIAAAAAAJsiEQUAAAAA2BSluQAAAABgBUpzrUePKAAAAADApkhEAQAAAAA2RWkuAAAAAFjD8HSyJ/YWjwX0iAIAAAAAbIpEFAAAAABgU5TmAgAAAIAVGDXXevSIAgAAAABsikQUAAAAAGBTlOYCAAAAgBUozbUePaIAAAAAAJsiEQUAAAAA2BSluQAAAABgBYPssDRX9hWPJfSIAgAAAABsikQUAAAAAGBTlOYCAAAAgBUYNdd69IgCAAAAAGyKRBQAAAAAYFOU5gIAAACANQxPJ3tib/FYQI8oAAAAAMCmSEQBAAAAADZFaS4AAAAAWIFRc61HjygAAAAAwKZIRAEAAAAANkVpLgAAAABYgdJc69EjCgAAAACwKRJRAAAAAIBNUZqL197ydqXl7u6e1GHABtKX+TCpQ4AN3do3LalDgI05OiSPcjQkDI/UKZM6BNiA4Yl9H2eDIXqyJ/YWjyX0iAIAAAAAbIpEFAAAAABgU5TmAgAAAIAVoktz7asW1s7CsYgeUQAAAACATZGIAgAAAABsitJcAAAAALCGHY6aK3uLxwJ6RAEAAAAANkUiCgAAAACwKUpzAQAAAMAKBoPBDkfNta94LKFHFAAAAABgUySiAAAAAACbojQXAAAAAKxgsMNRc+0tHkvoEQUAAAAA2BSJKAAAAADApijNBQAAAAArODgY5OBgX7WwUXYWjyX0iAIAAAAAbIpEFAAAAABgU5TmAgAAAIAVGDXXevSIAgAAAABsikQUAAAAAGBTlOYCAAAAgBUMBoMMdlYLa2/xWEKPKAAAAADApkhEAQAAAAA2RWkuAAAAAFiBUXOtR48oAAAAAMCmSEQBAAAAADZFaS4AAAAAWIFRc61HjygAAAAAwKZIRAEAAAAANkVpLgAAAABYgdJc69EjCgAAAACwKRJRAAAAAIBNUZoLAAAAAFYwGKIne2Jv8VhCjygAAAAAwKZIRAEAAAAANkVpLgAAAABYwSA7HDVX9hWPJfSIAgAAAABsikQUAAAAAGBTlOYCAAAAgBUYNdd69IgCAAAAAGyKRBQAAAAAYFOU5gIAAACAFQwGOxw1187isYQeUQAAAACATZGIAgAAAABsitJcAAAAALACo+Zajx5RAAAAAIBNkYgCAAAAAGyK0lwAAAAAsAKj5lqPHlEAAAAAgE2RiAIAAAAAbIrSXAAAAACwAqPmWo8eUQAAAACATZGIAgAAAABsitJcAAAAALACo+Zajx5RAAAAAIBNkYgCAAAAAGyKRBRI5ubMmqFC+XMpnXsqValYVgcP7H9h+7VrVsmvWCGlc0+l0iWLa/MPm0ye/3b9WtV/o46yZcqgNM4OOnbsaCJGj/h6v1ll/fn9cN3dO0m/LOmrUkVyWGybIoWDBnauqz82DNXdvZO0b8UA1SpfyKTNn98P1z9HpseaJg1olti7gjiYM2uGCufPpfTuqVQ1Hud3evdUCihZXD+aOb8bvFFH2TNlkKuzg45zftuV2bNmqGC+XErrlkqVK5TVgZcd79WrVKJoIaV1S6XSfrE/z9evi/48z+qTQamdHHTs6NFEjB7xNXvmDBXIm1Oeri6qVL6MDux/8fFes3qVfIsWlKeri0qVKBbreEdFRWnEsCHKlS2T0rql0ht1aurMX38l5i5Akgz/jpxrL5OSR2Uuiai9uHDhggwGg44+/ZLYsWOHDAaD7t27l6Rx2cLrtK8JbfWqFRrwcR8NHDREu/YdUrFixdXwrbq6ceOG2fZ79+xW29Yt1aZte+3ed1j1GzTUu00b648//mdsExoaqvIVKmjk6HG22g3EUZPaJfVZn8YaPecHlWv5mY6fvqINMz9QxrSuZtsP61ZfHd+pqN6fr5LfO6M0f/VvWjGhk3wLZDW2qfjeF8pZc6BxeqPLNEnS2i1HbLJPsGz1qhUa+PT8/m3fIRUtVlyNXnJ+t2vdUoFt22vXvsN6y8z5/TA0VOUqVNAIzm+7s3rlCg3o10effDpEu/cdUrHixdXwzRcf78DWLRXYrr327I8+3s2bNNYf/3vueJevoJFjON72ZtXKFerfr7cGfTpUe/YfVvHivmrwZh2Lx3vP7t0KfK+FAtt10N4DR1S/YSM1e6eRyfGeMP5zzZw+VVNnzNYvu/YpTZo0qv9mHT169MhWuwXEiyEqKioqqYNAdCKaK1cuHTlyRCVKlFBYWJju3Lkjb29vGQwGLVq0SL169Ur2yVrVqlVVokQJTZ482Tjv+X21leDgYHl4eOjazXtyd3e32XYTUpWKZeXvX0oTp0yXJEVGRip/nuzq0q27+vYbEKt9m1bvKjQ0VGvWbzTOq1qpnIoX99XUGbNN2v594YIKF8it3fsPy9e3RKLuh62kL/NhUofwn/yypK8O/fG3PvpslaTowQjObB6pWct3avzCLbHan/tptD6b/6PmrPzFOO+b8R31z6Mwtf90idltfNH3HdWrVFRFGw5PnJ2woVv7piV1CP9J1YplVfK587vA0/O7j4Xz+2FoqFY/c35Xq1ROxSyc30Went/FX5HzW5IckkkvgDmVK5SVf6lSmvTM8c6XO7u6duuuvh/HPt6tW76r0IehWvvM8a5SsZyK+/pqmpnjXSh/bu3Zf1i+JUok6n7YUnIZkMWcSuXLyL9UaU2e+u/xzpsrm7p+8KH6mTne77VsroehoVr77XfGeZUrlJWvbwlNmzlbUVFRyp09s3p81Ecf9e4rSbp//75yZPHW3C8XqVnzd22zY4kgODhY3uk9dP/+fbv6ey3m70j/od8rhUuapA7HxJNHoTo0/E27e82eR49oAgsPD0+Q9Tg5OcnHxydBP2TDwsISbF0Jue3E2NfXQVhYmI4cPqRq1Wsa5zk4OKha9Zrav3ev2WX27dujatVrmMyrWau29u0z3x72I2UKR/kVyqaf950yzouKitLP+04poHgus8s4pUyhR2Gmn0n/PApTeb88Frfx7hultfjbPQkXOKxizfm938z5XaNWbe3n/LZ7lo539eo1te8Fn+fVzXyeW3p/wH7EHO/qNWIf7/17zX/+7tu7x+T9IUm1atfRvqftL5w/r+vXr6v6M208PDxUOqCMsQ0SR8youfY2JQckonEQGRmpzz//XHnz5pWzs7OyZ8+u0aNHG8tpV6xYoSpVqsjFxUXLli2TJM2fP1+FChWSi4uLChYsqJkzZ5qsc//+/fLz85OLi4tKlSqlI0dMy+CeLVfdsWOH2rVrp/v37xvfXMOGDXtp3Dlz5tTIkSPVpk0bubu7q3PnzpKk3377TZUqVVKqVKmULVs29ejRQ6GhobGWa9GihdKkSaMsWbJoxowZJuu+ePGiGjZsKFdXV7m7u6tZs2YKCgoyPj9s2DCVKFFC8+fPV65cueTi4qK2bdtq586dmjJlinE/Lly4EKs0d9GiRfL09NSPP/6oQoUKydXVVXXr1tW1a9eM63/y5Il69OghT09PpU+fXv3791dgYKAaNWpk8fV4/PixgoODTabk7PatW4qIiJCXt7fJfC8vLwUFXTe7TND162bae1tsD/uRIa2rUqRw1I07D0zm37gdLJ/05n/t3LrnpHq8V115smeUwWBQ9TIF1bB6CflkMN++QbXi8nRLpa827kvw+BE/1p7fGTm/k6VbT4+3d3w/z72ea+/N8U4OYo63ueN3/bp1398xy8Vqw3sCdoxENA4GDhyocePGafDgwTpx4oS+/vprky+LAQMGqGfPnjp58qTq1KmjZcuWaciQIRo9erROnjypMWPGaPDgwVq8eLEkKSQkRG+99ZYKFy6sQ4cOadiwYerbt6/F7ZcvX16TJ0+Wu7u7rl27pmvXrr2w/bPGjx8vX19fHTlyRIMHD9bZs2dVt25dvfPOOzp+/LhWrFih3377Td27dzdZ7osvvjAuF7N/W7ZEl/5FRkaqYcOGunPnjnbu3KktW7bo3Llzat68uck6zpw5ozVr1mjt2rU6evSopkyZonLlyqlTp07G/ciWLZvZuB8+fKjx48dr6dKl+uWXX3Tx4kWTff7ss8+0bNkyLVy4ULt27VJwcLDWr1//wtdi7Nix8vDwME6Wtg28Kvp+sVpnL97QsbWDFbx/siYNaKolG/YqMtL8FRmBjcrrx10ndO3mfRtHCgAAXjcpkjoAe/fgwQNNmTJF06dPV2BgoCQpT548qlixoi5cuCBJ6tWrl95++23jMkOHDtWECROM83LlyqUTJ05ozpw5CgwM1Ndff63IyEh9+eWXcnFxUZEiRXT58mV17drVbAxOTk7y8PCQwWCQj49PvOKvXr26+vTpY3zcsWNHtWrVSr169ZIk5cuXT1OnTlWVKlU0a9Ysubi4SJIqVKigAQOir1HInz+/du3apUmTJqlWrVratm2bfv/9d50/f96YzC1ZskRFihTRgQMHVLp0aUnRpSdLlixRxowZTfYlderUL92P8PBwzZ49W3nyRJcQdu/eXSNGjDA+P23aNA0cOFCNGzeWJE2fPl2bNm0yu64YAwcOVO/evY2Pg4ODk3Uymj5DBjk6OurGMz3RknTjxg15e5t/fb19fMy0D7LYHvbj1t0QPXkSIa90bibzvdK76/pt8737t+6GqFnveXJ2SqH0Hml09eZ9jerRUOev3I7VNnumtKpepoDe7TsvUeJH/Fh7ft/k/E6WMjw93kHx/Ty/8Vz7II53chBzvM0dP0t/H73s+ztmuRtBQcqUKZPJOl+l68DtkXGkWjtib/FYQo/oS5w8eVKPHz9WjRo1LLYpVaqU8d+hoaE6e/asOnToIFdXV+M0atQonT171rjO4sWLG5M+SSpXrlyixP9sbJJ07NgxLVq0yCS2OnXqKDIyUufPn7cYT7ly5XTy5Elj/NmyZTNJ4goXLixPT09jG0nKkSOHSRIaH6lTpzYmoZKUKVMm40hy9+/fV1BQkAICAozPOzo6yt/f/4XrdHZ2lru7u8mUnDk5OcmvpL92bN9mnBcZGakd27cpoGxZs8uUKVNOO7b/bDLv521bVaaM+fawH+FPInTk5CVVK1PAOM9gMKhaQH7tP37+BUtKj8Oe6OrN+0qRwkGNapTQdzuOx2rTukE53bjzQD/8+keCx474s+b8DjBzfm/ftlUBnN92z9Lx3r59m8q84PN8+8+xP88tvT9gP2KO9/afYx/vgLLm/x4sU7acyftDkrZt3aIyT9vnzJVLPj4+2v5Mm+DgYB3Yv8/YBrA39Ii+RKpUqV7aJk2af0fKCgkJkSTNmzdPZcqUMWnn6OiYsMHFwbOxSdHxvf/+++rRo0esttmzZ0/UbcdHypQpTR4bDAYxwHNsH/b8SJ07tJWffymVKhWgGdMm62FoqFq3aSdJ6tg+UJkzZ9aIUWMlSd2691CdmlU1ZdIE1a33plavWq7Dhw5q2sw5xnXeuXNHly5d1LWrVyVJf52OHhzH29sn3j3ySFhTv/pZ80a01qETF3XwfxfUvWU1pU7lrCXfRg9OMn9ka129cV9Dpm2QJJUumkOZvTx17NRlZfHy1KD335CDg0ETF201Wa/BYFCbhmW17Lt9ioiItPl+wbzuPT/S+x3aqqR/Kfk/c36/9/T87vT0/B7+zPldt2ZVTZ00QXWeOb+nPnd+X37m/D79zPntzfmdpHr0/EidOrRVyZKlVKp0gKbHfJ4HPv08b/f083x09PH+4MMeql3j38/zVSujj/f05z/PL17UtWvPfZ778Hme1Hr06q1O7QPl7//0eE+NPt5tnh7vDm3bKHOWLBoZc7y791TtGlU0edIE1XvmeM+YNVdS9Of4Bz166bMxo5Q3bz7lzJlLw4cNVqbMmdWgYaOk2k3ghUhEXyJfvnxKlSqVtm3bpo4dO760vbe3tzJnzqxz586pVatWZtsUKlRIS5cu1aNHj4y9ontfMsqdk5OTIiIi4r8DzylZsqROnDihvHnzvrDd8/Hs3btXhQoVkhQd/6VLl3Tp0iVjr+iJEyd07949FS5c+IXrTYj98PDwkLe3tw4cOKDKlStLkiIiInT48GGVeIWGpY+LJk2b69bNmxo1YqiCrl9Xcd8SWr/xB+M1zJcvXZSDw7+FD2XLldfCJcs0YuhgDRsySHny5tPyVetUpEhRY5vvv9ugLp3aGx8HvtdCkvTJp0M0aPAw2+wYzFr902FlSOuqIV3flHd6Nx0/dUUNP5hhHMAom086k+s/nZ1TaugHbylXlgwKefhYP+76Qx0GL9H9kH9M1lu9TAFlz5ROi9cz2qY9MXd+r3vm/L5k5vxesGSZRr7g/N703Pnd9un5PZDzO8k1adZcN2/d1MhnP8+/e/HxXrRkmYYPHayhgwcpb958WrF6nYoUNf08f7/jv8e7zTOf558OGWabHYNZTZtFn98jhg8xHu9vv9ts8XiXK19ei5Z+reFDP9XQTz9R3nz5tHLNepPj3afvx3oYGqruXTvr3r17Kl+hojZ8t9mkAg8Jzx5HqbW3eCzhPqJxMHz4cE2ZMkWTJ09WhQoVdPPmTf3xxx+qUaOGyb0/Y8yfP189evTQuHHjVLduXT1+/FgHDx7U3bt31bt3b4WEhChXrlyqW7euBg4cqAsXLqhnz546c+aMcV07duxQtWrVdPfuXXl6emr37t2qUKGCtm7dKl9fX6VOnVqpU6d+Ydw5c+ZUr169jNeDStLx48dVtmxZtW/fXh07dlSaNGl04sQJbdmyRdOnTzcud/fuXQ0aNEiNGjXSli1b1LNnT33//feqU6eOoqKiVLJkSbm5uWny5Ml68uSJunXrJldXV+3YsUNS9Ki569ev19GjR01i6ty5s44ePaqVK1fK1dVV6dKl0y+//GKyr+bumbp+/Xo1btzY2Cs6evRoTZo0SV9++aUKFiyoadOmaenSpapevbrWrVsXp+P6KtxHFPGT3O8jivhJ7vcRRfwl5/uIIv6Syx/b+G/s/T6iASN+sMv7iO4fUs/uXrPncY1oHAwePFh9+vTRkCFDVKhQITVv3tx4vaI5HTt21Pz587Vw4UIVK1ZMVapU0aJFi5QrV/S9/lxdXbVx40b9/vvv8vPz06BBg/TZZ5+9MIby5curS5cuat68uTJmzKjPP//cqn0pXry4du7cqdOnT6tSpUry8/PTkCFDlDlzZpN2ffr00cGDB+Xn56dRo0Zp4sSJqlOnjqToD/5vv/1WadOmVeXKlVWzZk3lzp1bK1aseOn2+/btK0dHRxUuXFgZM2bUxYsXrdqP/v37q0WLFmrTpo3KlStnvNaVX/0AAAAA+0ePKGIx15Nq7yIjI1WoUCE1a9ZMI0eOjNMy9Ii+fugRfb3QI/r6oUf09UKP6OvB3ntEy4y0zx7RfYPtv0eUa0SRLP3999/66aefVKVKFT1+/FjTp0/X+fPn1bJly6QODQAAAMBLUJqbTP36668mt2B5fnrVOTg4aNGiRSpdurQqVKig33//XVu3bjUOqAQAAADAftEjmkyVKlUq1kBACeXChQuJst6ElC1bNu3atSupwwAAAMBrjFFzrUcimkylSpXqpbdgAQAAAAB7RGkuAAAAAMCm6BEFAAAAACtQmms9ekQBAAAAADZFIgoAAAAAsClKcwEAAADACgZD9GRP7C0eS+gRBQAAAADYFIkoAAAAAMCmKM0FAAAAACswaq716BEFAAAAANgUiSgAAAAAwKYozQUAAAAAKzBqrvXoEQUAAAAA2BSJKAAAAADApijNBQAAAAArMGqu9egRBQAAAADYFIkoAAAAAMCmKM0FAAAAACsYZH+j1NpZOBbRIwoAAAAAsCkSUQAAAACATZGIAgAAAIAVHAwGu5ysMWPGDOXMmVMuLi4qU6aM9u/f/8L29+7d0wcffKBMmTLJ2dlZ+fPn16ZNm+K8Pa4RBQAAAIDX2IoVK9S7d2/Nnj1bZcqU0eTJk1WnTh2dOnVKXl5esdqHhYWpVq1a8vLy0urVq5UlSxb9/fff8vT0jPM2SUQBAAAA4DU2ceJEderUSe3atZMkzZ49W99//70WLFigAQMGxGq/YMEC3blzR7t371bKlCklSTlz5ozXNinNBQAAAAArGAz2OUlScHCwyfT48WOz+xAWFqZDhw6pZs2axnkODg6qWbOm9uzZY3aZDRs2qFy5cvrggw/k7e2tokWLasyYMYqIiIjza0ciCgAAAACvmGzZssnDw8M4jR071my7W7duKSIiQt7e3ibzvb29df36dbPLnDt3TqtXr1ZERIQ2bdqkwYMHa8KECRo1alSc46M0FwAAAABeMZcuXZK7u7vxsbOzc4KtOzIyUl5eXpo7d64cHR3l7++vK1eu6IsvvtDQoUPjtA4SUQAAAACwgsFgkMHKUWoTS0w87u7uJomoJRkyZJCjo6OCgoJM5gcFBcnHx8fsMpkyZVLKlCnl6OhonFeoUCFdv35dYWFhcnJyeul2Kc0FAAAAgNeUk5OT/P39tW3bNuO8yMhIbdu2TeXKlTO7TIUKFXTmzBlFRkYa550+fVqZMmWKUxIqkYgCAAAAwGutd+/emjdvnhYvXqyTJ0+qa9euCg0NNY6i26ZNGw0cONDYvmvXrrpz54569uyp06dP6/vvv9eYMWP0wQcfxHmblOYCAAAAgBUcDNGTPbEmnubNm+vmzZsaMmSIrl+/rhIlSmjz5s3GAYwuXrwoB4d/+zCzZcumH3/8UR999JGKFy+uLFmyqGfPnurfv3+ct0kiCgAAAACvue7du6t79+5mn9uxY0eseeXKldPevXut3h6luQAAAAAAm6JHFAAAAACsYZDdjZorOwvHEnpEAQAAAAA2RSIKAAAAALApSnMBAAAAwAoGQ/RkT+wtHkvoEQUAAAAA2BSJKAAAAADApijNBQAAAAArGJ7+Z0/sLR5L6BEFAAAAANgUiSgAAAAAwKYozQUAAAAAKzgYoid7Ym/xWEKPKAAAAADApkhEAQAAAAA2RWkuAAAAAFjBYDDIYLCvWlh7i8cSekQBAAAAADZFIgoAAAAAsClKcwEAAADACgZD9GRP7C0eS+gRBQAAAADYFIkoAAAAAMCmKM0FAAAAACs4GAxysLNaWHuLxxISUQCvjbd6tE/qEGBDc/acT+oQYGOdy+ZM6hBgQw7J429t/EeRkVFJHQISCaW5AAAAAACbokcUAAAAAKzAqLnWo0cUAAAAAGBTJKIAAAAAAJuiNBcAAAAArGAwGGSws1pYe4vHEnpEAQAAAAA2RSIKAAAAALApSnMBAAAAwAqMmms9ekQBAAAAADZFIgoAAAAAsClKcwEAAADACg4GgxzsrBbW3uKxhB5RAAAAAIBNkYgCAAAAAGyK0lwAAAAAsILh6WRP7C0eS+gRBQAAAADYFIkoAAAAAMCmKM0FAAAAACsYDAYZ7GyUWnuLxxJ6RAEAAAAANkUiCgAAAACwKUpzAQAAAMAKDoboyZ7YWzyW0CMKAAAAALApElEAAAAAgE1RmgsAAAAAVmDUXOvRIwoAAAAAsCkSUQAAAACATVGaCwAAAABWSiaVsHaHHlEAAAAAgE2RiAIAAAAAbIrSXAAAAACwAqPmWo8eUQAAAACATcWpR3TDhg1xXmGDBg2sDgYAAAAA8OqLUyLaqFGjOK3MYDAoIiLiv8QDAAAAAMmCgyF6sif2Fo8lcUpEIyMjEzsOAAAAAMBr4j9dI/ro0aOEigMAAAAA8JqIdyIaERGhkSNHKkuWLHJ1ddW5c+ckSYMHD9aXX36Z4AECAAAAgD2KGTXX3qbkIN6J6OjRo7Vo0SJ9/vnncnJyMs4vWrSo5s+fn6DBAQAAAABePfFORJcsWaK5c+eqVatWcnR0NM739fXVn3/+maDBAQAAAABePXEarOhZV65cUd68eWPNj4yMVHh4eIIEBQAAAAD2zvB0sif2Fo8l8e4RLVy4sH799ddY81evXi0/P78ECQoAAAAA8OqKd4/okCFDFBgYqCtXrigyMlJr167VqVOntGTJEn333XeJESMAAAAA4BUS7x7Rhg0bauPGjdq6davSpEmjIUOG6OTJk9q4caNq1aqVGDECAAAAgN1xMBjsckoO4t0jKkmVKlXSli1bEjoWAAAAAMBrwKpEVJIOHjyokydPSoq+btTf3z/BggIAAAAAvLrinYhevnxZLVq00K5du+Tp6SlJunfvnsqXL6/ly5cra9asCR0jAAAAANgdgyF6sif2Fo8l8b5GtGPHjgoPD9fJkyd1584d3blzRydPnlRkZKQ6duyYGDECAAAAAF4h8e4R3blzp3bv3q0CBQoY5xUoUEDTpk1TpUqVEjQ4AAAAAMCrJ96JaLZs2RQeHh5rfkREhDJnzpwgQQEAAACAvTMYDDLYWS2svcVjSbxLc7/44gt9+OGHOnjwoHHewYMH1bNnT40fPz5BgwMAAAAAvHri1COaNm1ak8w6NDRUZcqUUYoU0Ys/efJEKVKkUPv27dWoUaNECRQAAAAA8GqIUyI6efLkRA4DAAAAAJIXRs21XpwS0cDAwMSOAwAAAADwmoj3YEXPevTokcLCwkzmubu7/6eAAAAAAACvtngnoqGhoerfv79Wrlyp27dvx3o+IiIiQQIDAAAAAHvmYDDIwc5qYe0tHkviPWruxx9/rJ9//lmzZs2Ss7Oz5s+fr+HDhytz5sxasmRJYsQIAAAAAHiFxLtHdOPGjVqyZImqVq2qdu3aqVKlSsqbN69y5MihZcuWqVWrVokRJwAAAADgFRHvHtE7d+4od+7ckqKvB71z544kqWLFivrll18SNjoAAAAAsFMxo+ba25QcxDsRzZ07t86fPy9JKliwoFauXCkpuqfU09MzQYMD8HJzZs1Qofy5lM49lapULKuDB/a/sP3aNavkV6yQ0rmnUumSxbX5h00mz3+7fq3qv1FH2TJlUBpnBx07djQRo0d81SmYQTOaFNGy1iU05q0CypshtcW2VfOm06p2JU2mZa1LmLT5oGKOWG0G1cqTyHuBuPpt3VKNal5Z/WsV0pSub+viyWNxWu7Ito3qUzWPFgx632T+8V9+1Jy+gRrcwF99qubRlb9OJEbYsNLc2TNVJH9uZfBIrWqVyr3083zdmlUqWbywMnikVhl/X/24+d/P8/DwcA0eNEBl/H3lnc5N+XJlVef2gbp29Wpi7wbiiO9vvO7inYi2a9dOx45FfxEOGDBAM2bMkIuLiz766CP169cvwQNMTqpWrapevXrFqe2iRYvsMnHPmTOnyX1jDQaD1q9fn6jbHDZsmEqUKJGo23hVrV61QgM+7qOBg4Zo175DKlasuBq+VVc3btww237vnt1q27ql2rRtr937Dqt+g4Z6t2lj/fHH/4xtQkNDVb5CBY0cPc5Wu4E4Kp8rrQIDsmrV0Wvqv+FP/X3nHw2qnVfuLpavsngYFqFOy48bp26r/herzZHL903aTN55IRH3AnF15OfvtGHmGNVu20MfzdugzHkKam6/tnpw99YLl7tz7bI2zhqn3MVLx3ou7NFD5SpWSm92/jixwoaV1qxaoYEf99GAQYP1296DKlqsuBrXr6ebL/g8b9emldq0ba/f9h3SW/UbqkXTt3Xi6ef5w4cPdezIYfUfOEi/7j2oZctX66+/Tqt5k0Y23CtYwvc3YEUi+tFHH6lHjx6SpJo1a+rPP//U119/rSNHjqhnz54JHuDr7FVM0Mwltn379tW2bduSJqBkbtqUSWrXvqPaBLZToUKFNXXGbKVKnVpLFi8w237m9KmqVbuuPurTTwULFdKQYSNVwq+k5sycbmzTslVrDRw0RNWq17TVbiCO3iripW2nb2nHmTu6fP+R5u6+qLAnkaqeL73FZaKionTvnyfG6f6jJ7HahEeYtgkNY/Rze/DLqgUq+2ZzBdRrIp+c+fRO71FK6ZJK+zettrhMZESElo3+SHXa9VS6TNliPV+qdmPVDvxQ+f0rJGbosML0qZPVtn1HtQ5sp4KFCmvK9FlPP88Xmm0/a8ZU1axdR71691XBgoU0eNgI+fqV1JxZMyRJHh4e2rDpJ73dpJny5y+ggDJlNX7SVB05fEiXLl605a7BDL6/Xx0Gg8Eup+Qg3ono83LkyKG3335bxYsXT4h48BpydXVV+vSW/5CGeWFhYTpy+JDJF46Dg4OqVa+p/Xv3ml1m3749qla9hsm8mrVqa98+8+1hP1I4GJQ7fWodv/rAOC9K0vFrD5TfK43F5VxSOmpm0yKa1ayoPq6RW1k9XWK1KeLjqvnvFtOUtwurU7lscnV2TIxdQDw8CQ/T5VP/Uz7/8sZ5Dg4Oyu9fXn+fOGJxuZ+WTJOrZ3qVebOZLcJEAon5PK/6zOezg4ODqlarof379phdZv/evbESjpo1a2v/Cz7Pg+/fl8FgkIcdVmS9Tvj+BqLFKRGdOnVqnKfXRWhoqNq0aSNXV1dlypRJEyZMMHn+8ePH6tu3r7JkyaI0adKoTJky2rFjR6z1rF+/Xvny5ZOLi4vq1KmjS5cuSYou3R0+fLiOHTtm/GVj0aJFL43r3r17ev/99+Xt7S0XFxcVLVpU3333nfH5NWvWqEiRInJ2dlbOnDljxf0yly5dUrNmzeTp6al06dKpYcOGunDhgkmbBQsWGLeRKVMmde/eXVJ02a8kNW7cWAaDwfj4+Z7fyMhIjRgxQlmzZpWzs7NKlCihzZs3G5+/cOGCDAaD1q5dq2rVqil16tTy9fXVnj3mv6xjPH78WMHBwSZTcnb71i1FRETIy9vbZL6Xl5eCgq6bXSbo+nUz7b0ttof9cHNOIUcHg+7/Y9qjef+fJ/JMldLsMlfvP9bM3/7W59vOadrOCzLIoNFvFlC61P+2P3IlWNN//VsjfvxLXx28osI+rhpUK68cksePqa+s0Pt3FRkZIbd0GUzmu6bNoAd3bppd5tzxg9r//So17TvGFiEiARk/z72e+3z29taNoCCzywQFXZeXl1es9pY+zx89eqQhnw5U02bvyt3dPWECh1X4/gaixen2LZMmTYrTygwGg7Fs91XXr18/7dy5U99++628vLz0ySef6PDhw8aEqnv37jpx4oSWL1+uzJkza926dapbt65+//135cuXT1L09RujR4/WkiVL5OTkpG7duundd9/Vrl271Lx5c/3vf//T5s2btXXrVknRZTYvEhkZqXr16unBgwf66quvlCdPHp04cUKOjtG9G4cOHVKzZs00bNgwNW/eXLt371a3bt2UPn16tW3b9qX7HB4erjp16qhcuXL69ddflSJFCo0aNUp169bV8ePH5eTkpFmzZql3794aN26c6tWrp/v372vXrl2SpAMHDsjLy0sLFy5U3bp1jXE9b8qUKZowYYLmzJkjPz8/LViwQA0aNNAff/xhfO0kadCgQRo/frzy5cunQYMGqUWLFjpz5oxSpDD/th47dqyGDx/+0v0EXhWnb4bq9M1Q4+NTN0I0+e3CqlUgg1YcuSZJ2n3+rvH5i3cf6e87/2hG06Iq7OOm/117EGudsE+PHobomzF91LTfaLl6pkvqcGBnwsPD1aZVc0VFRWnStJlJHQ7wSnFQApSYJjB7i8eSOCWiMaPkIlpISIi+/PJLffXVV6pRI7pMYvHixcqaNask6eLFi1q4cKEuXryozJkzS4q+DnLz5s1auHChxoyJ/rU6PDxc06dPV5kyZYzrKFSokPbv36+AgAC5uroqRYoU8vHxiVNcW7du1f79+3Xy5Enlz59fkoy32pGkiRMnqkaNGho8eLAkKX/+/Dpx4oS++OKLOCWiK1asUGRkpObPn2+sPV+4cKE8PT21Y8cO1a5dW6NGjVKfPn1MrhcuXTp6wIyMGTNKkjw9PV+4T+PHj1f//v317rvvSpI+++wzbd++XZMnT9aMGTOM7fr27as333xTkjR8+HAVKVJEZ86cUcGCBc2ud+DAgerdu7fxcXBwsLJli30NVXKRPkMGOTo6xvq1/MaNG/L2Nv/6evv4mGkfZLE97MeDx08UERklj1SmH9seqVLo3j/hcVpHRJR0/vY/8nF3ttjmRkiYgh+Fy8fdmUQ0CaXxSCsHB0c9uGM6MFHI3VtyS5cxVvvbVy7qzvXLWjCws3FeVFSkJKlf9fzqv3SLMmTJkbhBw2rGz/Mbz30+BwXF6gWL4e3tE2tgmxtBsT/PY5LQSxcv6rvNW+kNtQN8fwPRkkvCbFfOnj2rsLAwYwIpSenSpVOBAgUkSb///rsiIiKUP39+ubq6GqedO3fq7NmzxmVSpEhhTNKk6NvheHp66uTJk1bFdfToUWXNmtWYhD7v5MmTqlDBdICKChUq6K+//lJExMsHJzl27JjOnDkjNzc34z6lS5dOjx490tmzZ3Xjxg1dvXrVmJxbIzg4WFevXjUb5/Ovy7PXJWfKlEmSLI42J0nOzs5yd3c3mZIzJycn+ZX0147t/w70FBkZqR3btymgbFmzy5QpU047tv9sMu/nbVtVpoz59rAfTyKjdO72QxXL5GacZ5BULJObTt8ItbzgMxwMUva0qXTvoeXENV3qlHJ1TvHCNkh8KVI6KWuBovrr8G7jvMjISP11aI9yFPaL1d4rex71XbBJvedvNE6Fy9dQHr+y6j1/ozy9MtkyfMRTzOf5zmc+nyMjI7Vzx88KKFPO7DIBZcuafP5L0s8/b1XAM5/nMUno2TNntGHTT4zHYCf4/gaixalHFPETEhIiR0dHHTp0KFb5qaura6JtN1WqVIm2bil6v/z9/bVs2bJYz2XMmFEODrb9XSNlyn+vc4vpoY2MjLRpDEntw54fqXOHtvLzL6VSpQI0Y9pkPQwNVes27SRJHdsHKnPmzBoxaqwkqVv3HqpTs6qmTJqguvXe1OpVy3X40EFNmznHuM47d+7o0qWLxnvN/XX6lKToX9/j2juPxPHdHzf0QcUcOnv7oc7cfKg3i2SUcwoHbf/rtiSpe6UcuvMwXF8fij52TXx9dPpmqK4HP1YaZ0c1KOqtjK5O2nY6ur1LCgc1LZFJe/++q3v/PJG3m7Nal8qi68GPdfRK8r6G+lVQuWl7LR/bT9kKFFP2Qr76ZfVChT16qIB6TSRJX4/pI48MPnqzcz+ldHZWptwFTJZP5Rr9Y9uz8x8G39PdoKsKvh3ds3Lj0jlJklu6jHJPH7unFbbTvUcvvd+xnfxK+su/dIBmTpvy9PO8rSSpc/tAZcqcRcNHRVdVdf2gh+rVqqapkyeqTr03tGblCh05dFDTZsyWFJ2EvteiqY4dOaJV6zYoMiJCQdejrydMmy6dnJyckmQ/EY3v71eHPY5Sa2/xWEIiaoU8efIoZcqU2rdvn7Jnzy5Junv3rk6fPq0qVarIz89PERERunHjhipVqmRxPU+ePNHBgwcVEBAgSTp16pTu3bunQoUKSYr+xSwuPZUxihcvrsuXL+v06dNme0ULFSpkvF4zxq5du5Q/f36L12s+q2TJklqxYoW8vLws9ibmzJlT27ZtU7Vq1cw+nzJlyhfuk7u7uzJnzqxdu3apSpUqJnHGvE74V5OmzXXr5k2NGjFUQdevq7hvCa3f+IO8n5ZyXb500eQHgrLlymvhkmUaMXSwhg0ZpDx582n5qnUqUqSosc33321Ql07tjY8D32shSfrk0yEaNHiYbXYMZu0+f1fuLinU3C+TPFOl1IU7/2j0T2eMt2TJkMZJUVH/tk/j7KguFbLLM1VKhT6O0LnbDzXo+1O6fP+RJCkyKkrZ06VSlbzplMbJUXcehuv41QdafviqnkRGmQsBNuRX/S2F3rujHxdOVvCdW8qSt5A6fb7QOIDRvaBrMhji9wPg/3Zt1YrP+hsffzUi+jKK2oE9VKcdt2BLSu80ba5bt25p9IhhCgqK/jxfu2GTsTT30qVLMjz3eb5g8VcaMWyIhj/9PP9m1VoVfvp5fvXKFW36bqMkqXxASZNtbfpxmypVqWqT/YJ5fH8DkiEqKoq/NqzQtWtX/fDDD1qwYIG8vLw0aNAg/fzzz+rQoYMmT56s9957T7t27dKECRPk5+enmzdvatu2bSpevLjefPNNLVq0SJ07d5afn5+mTp2qFClSGEeXjRn99euvv1bnzp3122+/KWvWrHJzc5Ozs+VruySpWrVqunXrliZOnKi8efPqzz//lMFgUN26dXX48GGVLl3aOFjRnj171LVrV82cOdN4jWjOnDnVq1cv9erVS1L0Lyrr1q1To0aN9PDhQ5UoUUJZsmQxjmr7999/a+3atfr444+VNWtWLV68WF26dNFnn31mHDhp165d+vDDDyVFX5das2ZNDRkyRM7OzkqbNq2GDRum9evX6+jRo5KkyZMna+jQoZo7d65KlCihhQsXauLEicbBii5cuKBcuXLpyJEjxsGh7t27p7Rp02r79u2qWrVqnI5hcHCwPDw8dO3mvWRfpou4CVxm+bYXePWUy+2Z1CHAxjqXzZnUIcCGHJJJrw/+m+DgYGXK6Kn79+/b1d9rMX9Hvr/sgJxSJ17FozXCHoZoTqvSdveaPY9rRK30xRdfqFKlSqpfv75q1qypihUryt/f3/j8woUL1aZNG/Xp00cFChRQo0aNdODAAWMPqiSlTp1a/fv3V8uWLVWhQgW5urpqxYoVxuffeecd1a1bV9WqVVPGjBn1zTffvDSuNWvWqHTp0mrRooUKFy6sjz/+2NgDWbJkSa1cuVLLly9X0aJFNWTIEI0YMSJOAxXFxPvLL78oe/bsevvtt1WoUCF16NBBjx49Mr7JAwMDNXnyZM2cOVNFihTRW2+9pb/++su4jgkTJmjLli3Kli2b/PxiX+ckST169FDv3r3Vp08fFStWTJs3b9aGDRtMRswFAAAAkprBED0Ggz1NyeU3Gqt6RH/99VfNmTNHZ8+e1erVq5UlSxYtXbpUuXLlUsWKFRMjTiDB0SP6+qFH9PVCj+jrhx7R1ws9oq8He+8R7fL1ATnbWY/o44chmt3yFewRXbNmjerUqaNUqVLpyJEjevz4sSTp/v37xtuSAAAAAABgSbwT0VGjRmn27NmaN2+eyailFSpU0OHDhxM0OJhatmyZye1gnp2KFCmS1OEBAAAAr5WkLsO1NCUH8R4199SpU6pcuXKs+R4eHrp3715CxAQLGjRoYHLv0mc9+6MAAAAAANizeCeiPj4+OnPmjHLmzGky/7ffflPu3LkTKi6Y4ebmJjc3t5c3BAAAAAA7Fu9EtFOnTurZs6cWLFggg8Ggq1evas+ePerbt68GDx6cGDECAAAAgN0xGAwy2NnAWfYWjyXxTkQHDBigyMhI1ahRQw8fPlTlypXl7Oysvn37Gu8VCQAAAACAJfFORA0GgwYNGqR+/frpzJkzCgkJUeHCheXqal/DFgMAAAAA7FO8E9EYTk5OKly4cELGAgAAAADJhj2OUmtv8VgS70S0WrVqL6w7/vnnn/9TQAAAAACAV1u8E9ESJUqYPA4PD9fRo0f1v//9T4GBgQkVFwAAAADgFRXvRHTSpElm5w8bNkwhISH/OSAAAAAASA4MhujJnthbPJY4JNSK3nvvPS1YsCChVgcAAAAAeEUlWCK6Z88eubi4JNTqAAAAAACvqHiX5r799tsmj6OionTt2jUdPHhQgwcPTrDAAAAAAMCeORgMcrCzWlh7i8eSeCeiHh4eJo8dHBxUoEABjRgxQrVr106wwAAAAAAAr6Z4JaIRERFq166dihUrprRp0yZWTAAAAACAV1i8rhF1dHRU7dq1de/evUQKBwAAAACSBwc7nZKDeMdZtGhRnTt3LjFiAQAAAAC8BuKdiI4aNUp9+/bVd999p2vXrik4ONhkAgAAAADgReJ8jeiIESPUp08fvfHGG5KkBg0ayPDMiExRUVEyGAyKiIhI+CgBAAAAwM4YDNGTPbG3eCyJcyI6fPhwdenSRdu3b0/MeAAAAAAAr7g4J6JRUVGSpCpVqiRaMAAAAACAV1+8bt9iSC79vAAAAACQyBxkkIOd5UgOsq94LIlXIpo/f/6XJqN37tz5TwEBAAAAAF5t8UpEhw8fLg8Pj8SKBQAAAADwGohXIvruu+/Ky8srsWIBAAAAgGSDUXOtF+f7iHJ9KAAAAAAgIcQ5EY0ZNRcAAAAAgP8izqW5kZGRiRkHAAAAACQrDoboyZ7YWzyWxLlHFAAAAACAhEAiCgAAAACwqXiNmgsAAAAAiGYwSA52NqirnYVjET2iAAAAAACbIhEFAAAAANgUpbkAAAAAYAWDwf5KYe0tHkvoEQUAAAAA2BSJKAAAAADApijNBQAAAAArOBiiJ3tib/FYQo8oAAAAAMCmSEQBAAAAADZFaS4AAAAAWMHw9D97Ym/xWEKPKAAAAADApkhEAQAAAAA2RWkuAAAAAFiBUXOtR48oAAAAAMCmSEQBAAAAADZFaS4AAAAAWIHSXOvRIwoAAAAAsCkSUQAAAACATVGaCwAAAABWMBgMMhjsqxbW3uKxhB5RAAAAAIBNkYgCAAAAAGyKRBQAAAAAYFNcIwoAAAAAVuD2LdYjEcVr70lklJ5ERiV1GLCB/lXzJHUIsKGCmd2SOgTYmO8nm5M6BNjQ/8bVS+oQYAPJZNwdWIHSXAAAAACATdEjCgAAAABWMBjsr9fW3uKxhB5RAAAAAHjNzZgxQzlz5pSLi4vKlCmj/fv3x2m55cuXy2AwqFGjRvHaHokoAAAAALzGVqxYod69e2vo0KE6fPiwfH19VadOHd24ceOFy124cEF9+/ZVpUqV4r1NElEAAAAAsIKDwWCXU3xNnDhRnTp1Urt27VS4cGHNnj1bqVOn1oIFCywuExERoVatWmn48OHKnTt3/F+7eC8BAAAAALBrwcHBJtPjx4/NtgsLC9OhQ4dUs2ZN4zwHBwfVrFlTe/bssbj+ESNGyMvLSx06dLAqPhJRAAAAAHjFZMuWTR4eHsZp7NixZtvdunVLERER8vb2Npnv7e2t69evm13mt99+05dffql58+ZZHR+j5gIAAACAFRwM0ZM9iYnn0qVLcnd3N853dnZOkPU/ePBArVu31rx585QhQwar10MiCgAAAACvGHd3d5NE1JIMGTLI0dFRQUFBJvODgoLk4+MTq/3Zs2d14cIF1a9f3zgvMjJSkpQiRQqdOnVKefLkeel2Kc0FAAAAgNeUk5OT/P39tW3bNuO8yMhIbdu2TeXKlYvVvmDBgvr999919OhR49SgQQNVq1ZNR48eVbZs2eK0XXpEAQAAAMAaBsmKQWoTlxXx9O7dW4GBgSpVqpQCAgI0efJkhYaGql27dpKkNm3aKEuWLBo7dqxcXFxUtGhRk+U9PT0lKdb8FyERBQAAAIDXWPPmzXXz5k0NGTJE169fV4kSJbR582bjAEYXL16Ug0PCFtOSiAIAAADAa6579+7q3r272ed27NjxwmUXLVoU7+2RiAIAAACAFRxkkIM1tbCJyN7isYTBigAAAAAANkUiCgAAAACwKUpzAQAAAMAKBjscNdfe4rGEHlEAAAAAgE2RiAIAAAAAbIrSXAAAAACwgoMherIn9haPJfSIAgAAAABsikQUAAAAAGBTlOYCAAAAgBUcDAY52NkwtfYWjyX0iAIAAAAAbIpEFAAAAABgU5TmAgAAAIAVDIboyZ7YWzyW0CMKAAAAALApElEAAAAAgE1RmgsAAAAAVnCQHY6aK/uKxxJ6RAEAAAAANkUiCgAAAACwKUpzAQAAAMAKjJprPXpEAQAAAAA2RSIKAAAAALApSnMBAAAAwAoOsr+ePXuLx5LkEicAAAAA4BVBIgoAAAAAsClKcwEAAADACgaDQQY7G6bW3uKxhB5RAAAAAIBNkYgCAAAAAGyK0lwAAAAAsILh6WRP7C0eS+gRBQAAAADYFIkoAAAAAMCmKM0FAAAAACs4GAxysLNRau0tHkvoEQUAAAAA2BSJKAAAAADApijNBQAAAAArJY9CWPtDjygAAAAAwKZIRAEAAAAANkVpLgAAAABYwWCInuyJvcVjCT2iAAAAAACbIhEFAAAAANgUpbkAAAAAYAWDwSCDndXC2ls8ltAjCgAAAACwKRJRAAAAAIBNUZoLAAAAAFZwkP317NlbPJYklzgBWDBv9kwVK5BbXp6pVb1SOR06sP+F7detWaVSvoXl5Zla5Ur56qfNm0yeHztquEr5Flam9G7Knim9GrxRWwf370vMXUA8rFwyTw0qFVOFgt5q27iG/jh2yGLbdcsXq1OzeqpeIoeql8ihbu81NGn/JDxc08YN1bt1y6tSkcyqV7aghvZ5XzeDrtliVxAHc2fPVJH8uZXBI7WqVSqng3E4v0sWL6wMHqlVxt9XPz5zfoeHh2vwoAEq4+8r73Ruypcrqzq3D9S1q1cTezcQR+9VyKGdg6rqxLg6WtOjvIpn87DYdlnXMjo74Y1Y0/wOpYxtetTOp5/6V9bvY2rr8MhaWvJ+gHyzW14nbGv2rBkqmC+X0rqlUuUKZXXgJef32tWrVKJoIaV1S6XSfsW1+QfT7++oqCiNGDZEubJnVjr31Hqzbi2d+euvxNwF4D8hEYVZFy5ckMFg0NGjR1/adseOHTIYDLp3716ixwVTa1at0Cf9+6j/oMH6Zc9BFS1eXI0b1NPNGzfMtt+3Z7c6BLZS68D2+nXvIb1Zv6FaNntbJ/74n7FN3rz59MWkqdp98Jh+3PaLsufIocb16+rWzZu22i1Y8NN3azV5zCB17NFfSzfuVL5CRfVh4Nu6c8v8sTm09zfVrv+OZn29UQvWbJF3pizq3qaxblyPTjwe/fNQf/5xTB0+7KelG3fq81lL9fe5M+rTqYUtdwsWrFm1QgM/7qMBgwbrt70HVbRYcTWub/n83rtnt9q1aaU2bdvrt32H9Fb9hmrR9N/z++HDhzp25LD6DxykX/ce1LLlq/XXX6fVvEkjG+4VLHmzRCZ90qCgpv50Rg0m7dKfV4O1qHOA0rs6mW3fbdFhlRm21TjV/fwXPYmI1A/H//0h6fzNUA1b+4feGP+rmk/fo8t3/9HizgFKl8b8OmE7q1eu0IB+ffTJp0O0e98hFSteXA3frKsbLzi/A1u3VGC79tqz/7DeatBQzZs01h//+/f7e+L4zzVrxjRNnT5LO3/bq9Sp06jBW3X16NEjW+0WEC+GqKioqKQOwhYMBoPWrVunRo0aJXUoycKFCxeUK1cuHTlyRCVKlHhh2x07dqhatWq6e/euPD09bRJfQggODpaHh4cuBd2Vu7t7UodjleqVyqmkfymNnzxNkhQZGanCeXOoc9fu6t2vf6z2bd97Vw8fhmrl2o3GeTUql1cxX19NnjbL7DaCg4OVzTutvt30k6pWq5E4O2Ijp689SOoQ/pO2jWuocPGS+nj4F5Kij/dbFYqoWZvOatv1o5cuHxERoRp+OdVv2Od6823zyeYfxw6rbePq2vjr7/LJki1B47e1gpndkjqE/6Ta0/N7wjPnd8G8OfR+1+7qY+b8DnzvXYWGhmr1un/P72qVy6t4cV9NmW7+/D508ICqViyrE6fPK1v27ImzIzbk+8nmpA7Bamt6lNfxS/c0fN0JSdE3pP9tcHUt+e2C5vx87qXLt62UU73q5lO54T/rn7AIs21cnVPo2Jjaaj17n3b/dTtB408K/xtXL6lDsFrlCmXlX6qUJk2ZLin6/M6XO7u6duuuvh8PiNW+dct3FfowVGvX/3t+V6lYTsV9fTVtxmxFRUUpd44s6tmrt3r17itJun//vnJm9dHc+QvVtPm7ttmxRBAcHCyfDJ66f/++Xf29FvN35MJf/1RqV/v6vnkY8kDtKhW0u9fsea98j2hYWFhShwAkirCwMB09ckhVq/+bHDo4OKhq9Ro6sH+P2WUO7NurqtVqmsyrUau2Duzba3Ebi76cJw8PDxUr5ptwwSPewsPC9Of/jiqgQhXjPAcHBwVUqKLfj7y4nCvGo38e6kl4uNw90lpsE/IgWAaDQa7ulO8lpbCwMB05bOb8rlZD+/eZP7/3792ratVNz++aNWtrv4XzW5KC79+XwWCQRzL6EfFVlNLRoKJZ3U2Sw6goaffpW/LLYfl8fVazMtn0/ZFrFpPQlI4GvVsum4L/CdfJq8EJEjesE3N+P3u+Ojg4qHr1mtq31/z5um/fHlWvbvpjcM1atbX/afsL588r6Pp1k3V6eHiodEAZ7bPwmQEktSRNRKtWraoPP/xQvXr1Utq0aeXt7a158+YpNDRU7dq1k5ubm/LmzasffvjBuMzOnTsVEBAgZ2dnZcqUSQMGDNCTJ09M1tm9e3f16tVLGTJkUJ06dZQzZ05JUuPGjWUwGIyPJWnUqFHy8vKSm5ubOnbsqAEDBpj0AB44cEC1atVShgwZ5OHhoSpVqujw4cMm+/Hnn3+qYsWKcnFxUeHChbV161YZDAatX7/e2ObSpUtq1qyZPD09lS5dOjVs2FAXLlwwPr9jxw4FBAQoTZo08vT0VIUKFfT333+/9DU8e/asGjZsKG9vb7m6uqp06dLaunWrSZucOXNqzJgxat++vdzc3JQ9e3bNnTvXpM3+/fvl5+cnFxcXlSpVSkeOHHnptl9kzZo1KlKkiJydnZUzZ05NmDDB5PmlS5eqVKlScnNzk4+Pj1q2bGlSjhJT7rtt2zaVKlVKqVOnVvny5XXq1Cljm2PHjqlatWpyc3OTu7u7/P39dfDgQYsxPX78WMHBwSZTcnb71i1FRETIy8vbZH5GL28FXQ8yu0xQ0HV5eXnFbh903WTe5k3fKXMGd3l5ptbMaZO17rsflT5DhoTdAcTLvbu3FRERoXQZTI9fugxeun3TfCnX86Z9NkwZvH0UULGq2ecfP36k6Z8PVe36TeTqZr+/oL4OLJ3fXt7euhEU9/Pbyzv2+R3j0aNHGvLpQDVt9q5d/2L+OkibxkkpHB1068Fjk/m3Qh4ro5vzS5cvns1DBTK5acW+S7Geq1bIS8fH1NaJcXXVrnIutZmzX3dDwxMsdsTfrafnt7f3c+e3l5fF8zXo+nWznwcx7WP+7xVrnZb/JgCSWpL3iC5evFgZMmTQ/v379eGHH6pr165q2rSpypcvr8OHD6t27dpq3bq1Hj58qCtXruiNN95Q6dKldezYMc2aNUtffvmlRo0aFWudTk5O2rVrl2bPnq0DBw5IkhYuXKhr164ZHy9btkyjR4/WZ599pkOHDil79uyaNcu0fOnBgwcKDAzUb7/9pr179ypfvnx644039OBBdIlfRESEGjVqpNSpU2vfvn2aO3euBg0aZLKO8PBw1alTR25ubvr111+1a9cuubq6qm7dugoLC9OTJ0/UqFEjValSRcePH9eePXvUuXPnON2MNiQkRG+88Ya2bdumI0eOqG7duqpfv74uXrxo0m7ChAnGBLNbt27q2rWrMakLCQnRW2+9pcKFC+vQoUMaNmyY+vbtG4+jaOrQoUNq1qyZ3n33Xf3+++8aNmyYBg8erEWLFpm8JiNHjtSxY8e0fv16XbhwQW3bto21rkGDBmnChAk6ePCgUqRIofbt2xufa9WqlbJmzaoDBw7o0KFDGjBggFKmTGkxrrFjx8rDw8M4ZcuWvMsOE1OlKtX0677D2rL9N9WoXUdt33vX4nVpSB4WzZqkLd+t0RezvpKzs0us55+Eh2tg97aKiorSgJETzKwBr5Lw8HC1adVcUVFRmjRtZlKHg/+oWZls+vNqsI5fuh/rub1nb6v+hN/UdNoe/fLnTU1r7WfxulMA8Wew0yk5SPLbt/j6+urTTz+VJA0cOFDjxo1ThgwZ1KlTJ0nSkCFDNGvWLB0/flwbN25UtmzZNH36dBkMBhUsWFBXr15V//79NWTIEDk4ROfV+fLl0+effx5rW56envLx8TE+njZtmjp06KB27doZt/XTTz8pJCTE2KZ69eom65g7d648PT21c+dOvfXWW9qyZYvOnj2rHTt2GNc9evRo1apVy7jMihUrFBkZqfnz5xuTy4ULF8rT01M7duxQqVKldP/+fb311lvKkyePJKlQoUJxfv18ff8tmRw5cqTWrVunDRs2qHv37sb5b7zxhrp16yZJ6t+/vyZNmqTt27erQIEC+vrrrxUZGakvv/xSLi4uKlKkiC5fvqyuXbvGKYbnTZw4UTVq1NDgwYMlSfnz59eJEyf0xRdfGJPNZxPK3Llza+rUqSpdurRCQkLk6upqfG706NGqUiW6FHHAgAF688039ejRI7m4uOjixYvq16+fChYsKCn6uL/IwIED1bt3b+Pj4ODgZJ2Mps+QQY6Ojrpxw/SXzps3guTt4212GW9vn1gDIdy8ESRvbx+TeWnSpFGePHmVJ09elS5TVn5FC2jJ4gXq0y/2dSuwDc+06eXo6Kg7t0yP351bN5Q+o5eFpaItnTdNi2dP0oyl3ypfoaKxnn8SHq6BH7bV9SuXNHPZRnpD7YCl8/tGUFCsHo8Y5s7vG0Gxz++YJPTSxYv6bvNWekPtwN3QMD2JiFSG53o/M7g66+ZzvaTPS+XkqLdKZNLkH82PjvpPWIT+vv1Qf99+qKMX72nbgCpqGpBNs38+m2DxI34yPD2/g56rbrhx40as8zWGt4+P2c+DmPYx/78RFKRMmTI9s84gFffl0hrYpyTvES1evLjx346OjkqfPr2KFStmnBdTtnDjxg2dPHlS5cqVM+kprFChgkJCQnT58mXjPH9//zht+9SpUwoICDCZ9/zjoKAgderUSfny5ZOHh4fc3d0VEhJi7HE8deqUsmXLZpLgPr+OY8eO6cyZM3Jzc5Orq6tcXV2VLl06PXr0SGfPnlW6dOnUtm1b1alTR/Xr19eUKVN07Vrcbp8QEhKivn37qlChQvL09JSrq6tOnjwZq0f02dfZYDDIx+ffP1hOnjyp4sWLy8Xl316ScuXKxWn75pw8eVIVKlQwmVehQgX99ddfioiIvnbl0KFDql+/vrJnzy43NzdjsvmiuGM+WGPi7t27tzp27KiaNWtq3LhxOnv2xV+qzs7Ocnd3N5mSMycnJ5Xw89fO7T8b50VGRmrn9p9VOsD88Stdpqx27thmMm/7tq0qXabsC7cVGRmpsMcv/mMIiSulk5MKFi2hA7t3GudFRkbqwO5fVMwvwOJyS+ZM0ZfTvtDURWtUuLhfrOdjktCLF85pxtJv5Zk2XaLEj/hxcnKSX0kz5/eOnxVQxvz5HVC2rHZsNz2/f/55qwKeOb9jktCzZ85ow6aflD59+sTZAcRLeESU/nc5WOXz/Xs8DAapXL70OvL33Rcu+4avj5xSOGj9oStx2pbBIDmlSPI//15rMef3s+drZGSktm/fpjJlzX8flylTTtt//tlk3s/btirgafucuXLJ28fHZJ3BwcE6sH+fylj4zACSWpL3iD5fSmkwGEzmxSSdkZGRcV5nmjRpEiY4SYGBgbp9+7amTJmiHDlyyNnZWeXKlYvXIEghISHy9/fXsmXLYj2XMWNGSdE9pD169NDmzZu1YsUKffrpp9qyZYvKWvhAitG3b19t2bJF48ePV968eZUqVSo1adIkVnzmXuf4vKYJKTQ0VHXq1FGdOnW0bNkyZcyYURcvXlSdOnVeGPfz74Vhw4apZcuW+v777/XDDz9o6NChWr58uRo3bmy7nUliH/Topa6d2snP31/+pQI0c/oUhT4M1Xtt2kqS3u8QqEyZs2jYyDGSpK4f9NAbtatp2uSJqlPvDa1ZtUJHDh/UlBmzJUUfm/GfjdEbb9aXt08m3b59S/PnzNS1q1fU6O0mSbWbeKplhw80vG9XFSrmpyK+/vpm4Sz98zBU9Zu0kiQN7fO+MnpnVvePh0qSFs+erDmTx2jUpHnKlDW7bt2M/jU9deo0Sp3GVU/Cw9X/gzb684/jmjR/uSIiI4xtPDzSKqUT5XtJqXuPXnq/Yzv5lfSXf+kAzZw2RQ9DQ9X66fnduX30+T181L/nd71a1TQ15vxeuUJHDh3UtKfnd3h4uN5r0VTHjhzRqnUbFBkRoaDr0deVpU2XTk4c7yS14Jfz+uLd4vr90n0du3hP7SrnUmqnFFq9P/qH9vEtiuv6/ccav+mUyXJNA7Jpy/+CdO+h6XWfqZwc1a1GHm3744ZuPHikdGmc9F6FHPLxcNEPx7hXcFLr0fMjderQViVLllKp0gGaPm1y9PkdGF2l17FdoDJnzqwRo8dKkj74sIdq16iqKZMmqG69N7Vq5XIdPnRQ02fOkRT9N1L3D3vqs7GjlSdvPuXMmUsjhg1RpsyZVb9ho6TazdeCwWCI0+V0tmRv8ViS5IlofBQqVEhr1qxRVFSU8QXetWuX3NzclDVr1hcumzJlSmNvXIwCBQrowIEDatOmjXFezPWjMXbt2qWZM2fqjTfekBQ96NCtW7dM1nHp0iUFBQUZe2+fX0fJkiW1YsUKeXl5vbAXzs/PT35+fho4cKDKlSunr7/++qWJ6K5du9S2bVtj8hUSEmIyCFJcFCpUSEuXLjWWvErSXgujtsV1fbt27YoVZ/78+eXo6Kg///xTt2/f1rhx44ylsS8aZOhF8ufPr/z58+ujjz5SixYttHDhwtcqEX2naXPdvnVLY0YMU1DQdRUrXkJrv91kLN27fOmSsWRdksqUK6/5i77SqOFDNGLoIOXJm09fr1yrwkWiyzUdHR11+tSf+uarJbp9+5bSpUuvkqVK6YetO1WocJGk2EU8o/Zbb+venVuaM2mMbt+6ofyFimnqojXG0tzrVy/L8MzxXrPsS4WHhan/B4Em6+nUo7869xqoG0FX9cvW6MHgWr1ZyaTN7K83yr+s6TzY1jtNm+vWrVsaPSL6/C7uW0JrN/x7fl+6dMnkeJctV14LFn+lEcOGaPiQ6PP7m1X/nt9Xr1zRpu+ib/1QPqCkybY2/bhNlapUtcl+wbzvj15TujRO6lUnvzK4O+nklQdqN2+/bodE/0CbyTOVIp+74V6ujGlUOnc6tZkTe+TsiMgo5fFy1dulsyptmpS6Fxqu45fuq/mMvforKCRWe9hWk2bNdfPWTY0cMVRB16PP7/Xf/WD8W/LSpYsm399ly5XXoiXLNHzoYA0dPEh58+bTitXrVKTov5db9O77sUJDQ9W92/u6f++eyleoqG83/mBS8QbYk2SViHbr1k2TJ0/Whx9+qO7du+vUqVMaOnSoevfubXKympMzZ05t27ZNFSpUkLOzs9KmTasPP/xQnTp1UqlSpVS+fHmtWLFCx48fV+7cuY3L5cuXzzjCa3BwsPr166dUqVIZn69Vq5by5MmjwMBAff7553rw4IHxmteYZLlVq1b64osv1LBhQ40YMUJZs2bV33//rbVr1+rjjz9WeHi45s6dqwYNGihz5sw6deqU/vrrL5ME2ZJ8+fJp7dq1ql+/vgwGgwYPHhzvns6WLVtq0KBB6tSpkwYOHKgLFy5o/Pjx8VrHs/r06aPSpUtr5MiRat68ufbs2aPp06dr5szoATGyZ88uJycnTZs2TV26dNH//vc/jRw5Ml7b+Oeff9SvXz81adJEuXLl0uXLl3XgwAG98847VsedXHXu+oE6d/3A7HPf//RzrHmN32mqxu80NdvexcVFy1asSdD4kLCatemsZm06m31uzjffmzze8OvvL1xX5qw5dODcvYQKDYng/a4f6H0L5/cPW+J3fufImVMPHpm/tQfsw9Jdf2vpLvMj5reatS/WvPM3Q5Wnzyaz7cOeRKrb4sNmn4N96Nqtu7p26272uR+3bo817+0mTfV2E/PntxT9d+eQYSM0ZNiIBIsRSEzJ6iKBLFmyaNOmTdq/f798fX3VpUsXdejQwZj4vciECRO0ZcsWZcuWTX5+0ddJtWrVSgMHDlTfvn1VsmRJnT9/Xm3btjX55ejLL7/U3bt3VbJkSbVu3Vo9evQwGR7f0dFR69evV0hIiEqXLq2OHTsaR82NWU/q1Kn1yy+/KHv27Hr77bdVqFAhdejQQY8ePZK7u7tSp06tP//8U++8847y58+vzp0764MPPtD777//0v2aOHGi0qZNq/Lly6t+/fqqU6eOSpYs+dLlnuXq6qqNGzfq999/l5+fnwYNGqTPPvssXut4VsmSJbVy5UotX75cRYsW1ZAhQzRixAjjQEUZM2bUokWLtGrVKhUuXFjjxo2Ld+Lr6Oio27dvq02bNsqfP7+aNWumevXqafjw4VbHDQAAAMSHg51OyYEhKioq6uXNXh+1atWSj4+Pli5davU6du3apYoVK+rMmTPGUXBhf4KDg+Xh4aFLQXeT/cBFiJvT1x4kdQiwoYKZ3ZI6BNiY7yebkzoE2ND/xtVL6hBgA8HBwfLJ4Kn79+/b1d9rMX9HLv3tlFK72tf3zcOQB2pdsYDdvWbPS1aluQnt4cOHmj17turUqSNHR0d988032rp1q7Zs2RKv9axbt06urq7Kly+fzpw5o549e6pChQokoQAAAABgRnLpuU0UBoNBmzZtUuXKleXv76+NGzdqzZo1qlmzZrzW8+DBA33wwQcqWLCg2rZtq9KlS+vbb79NkBiLFClivOXL85O5UXgTQ5cuXSzG0KVLF5vEAAAAANibmFFz7W1KDl7rHtFUqVJp69at/3k9bdq0idPAQtbYtGmTwsPDzT7nbeGm5gltxIgR6tu3r9nn7Lm7HwAAAIB9eq0T0eQgR44cSR2CvLy8TAZoAgAAAID/gkQUAAAAAKxgeDrZE3uLx5LX+hpRAAAAAIDtkYgCAAAAAGyK0lwAAAAAsILBED3ZE3uLxxJ6RAEAAAAANkUiCgAAAACwKUpzAQAAAMAKDjLIwc7GqbW3eCyhRxQAAAAAYFMkogAAAAAAm6I0FwAAAACswKi51qNHFAAAAABgUySiAAAAAACbojQXAAAAAKxgePqfPbG3eCyhRxT/b+/Ow2O6+zeO35MQSUgiloQQSUiKEPtSdEHtfWrrQmktVUvta9HW1iJordWHtnY/ilarO621FTsRtKg9qF2JSMk2vz/UPJ0mUSIzZzJ5v3Kd68p8z5mZe5xrYj7zXQ4AAAAA2BWFKAAAAADArhiaCwAAAACZwKq5mUePKAAAAADArihEAQAAAAB2xdBcAAAAAMgEk0xycbBValk1FwAAAACAdFCIAgAAAADsiqG5AAAAAJAJrJqbefSIAgAAAADsikIUAAAAAGBXDM0FAAAAgExgaG7m0SMKAAAAALArClEAAAAAgF0xNBcAAAAAMsH0148jcbQ8GaFHFAAAAABgVxSiAAAAAAC7YmguAAAAAGSCi+nO5kgcLU9G6BEFAAAAANgVhSgAAAAAwK4YmgsAAAAAmcCquZlHjygAAAAAwK4oRAEAAAAAdsXQXAAAAADIBJPpzuZIHC1PRugRBQAAAADYFYUoAAAAAMCuGJoLAAAAAJlgkuOtUutYaTJGjygAAAAAwK4oRAEAAAAAdsXQXAAAAADIBBfTnc2ROFqejNAjCgAAAACwKwpRAAAAAIBdMTQXAAAAADLB9NePI3G0PBmhRxQAAAAAYFcUogAAAAAAu2JoLgAAAABkgsl0Z3MkjpYnI/SIAgAAAADsih5R5Hi3ElOUOzHF6Biwg7x5+JOXk5jNRieAve0d18ToCLCjim+uMToC7CDl9k2jI8BG+FQGAAAAAJlg+mtzJI6WJyMMzQUAAAAA2BWFKAAAAADArhiaCwAAAACZ4CKTXBxsmVqXbDI4lx5RAAAAAIBdUYgCAAAAAOyKobkAAAAAkAmsmpt59IgCAAAAAOyKQhQAAAAAYFcMzQUAAACAzGBsbqbRIwoAAAAAsCsKUQAAAACAXTE0FwAAAAAywfTXjyNxtDwZoUcUAAAAAGBXFKIAAAAAALtiaC4AAAAAZIZJMjnaSFhHy5MBekQBAAAAAHZFIQoAAAAAsCuG5gIAAABAJpjkeCNhHS1PRugRBQAAAADYFYUoAAAAAMCuGJoLAAAAAJnB2NxMo0cUAAAAAGBXFKIAAAAAALtiaC4AAAAAZILprx9H4mh5MkKPKAAAAADArihEAQAAAAB2xdBcAAAAAMgEk+nO5kgcLU9G6BEFAAAAANgVhSgAAAAAwK4YmgsAAAAAmWD6a3MkjpYnI/SIAgAAAADsikIUAAAAAGBXDM0FAAAAgMxgbG6m0SMKAAAAALArClEAAAAAgF1RiAIAAABAJpgc9CczPvjgAwUHB8vd3V01a9bUjh07Mjz2448/1uOPPy5fX1/5+vqqQYMG9zw+PRSiAAAAAJCDLV++XAMHDtSoUaO0Z88eVaxYUY0bN9bFixfTPX7jxo168cUXtWHDBm3dulWBgYFq1KiRzp49e9/PSSEKAAAAADnYlClT1LVrV3Xu3Fnh4eGaPXu2PD09NW/evHSPX7JkiXr27KlKlSqpTJkymjNnjlJTU7Vu3br7fk5WzQUAAACATDCZ7myO5G6euLg4q/Y8efIoT548aY5PTEzU7t27NXz4cEubi4uLGjRooK1bt97XcyYkJCgpKUkFChS475z0iAIAAACAkwkMDJSPj49li4yMTPe4y5cvKyUlRf7+/lbt/v7+On/+/H0919ChQxUQEKAGDRrcdz56RAEAAADAyZw+fVre3t6W2+n1hmaFCRMmaNmyZdq4caPc3d3v+34UogAAAACQCaa/NkdyN4+3t7dVIZqRQoUKydXVVRcuXLBqv3DhgooUKXLP+7733nuaMGGC1q5dqwoVKjxQTobmAgAAAEAO5ebmpqpVq1otNHR34aFatWpleL9JkybpnXfe0erVq1WtWrUHfl56RAEAAAAgBxs4cKA6duyoatWqqUaNGpo2bZpu3rypzp07S5I6dOigYsWKWeaZTpw4USNHjtTSpUsVHBxsmUuaL18+5cuX776ek0IUAAAAADLDkcfmPoA2bdro0qVLGjlypM6fP69KlSpp9erVlgWMYmNj5eLyv8G0s2bNUmJiop577jmrxxk1apRGjx59X89JIQoAAAAAOVzv3r3Vu3fvdPdt3LjR6vbJkycf+vmYIwoAAAAAsCt6RAEAAAAgE0x//TgSR8uTEXpEAQAAAAB2RSEKAAAAALArhuYCAAAAQCaYTHc2R+JoeTJCjygAAAAAwK4oRAEAAAAAdsXQXAAAAADIBNNfmyNxtDwZoUcUAAAAAGBXFKJANjfv41mqFhGmID8vNa1fR3t277zn8V998Zkeq1ZeQX5eqlurstb+8L3V/iI+buluH0yfbMuXgfu0dMGHalAzXJVKFlSb/9TVvuhdGR575PCv6te1nRrUDFd4sXxa9PEH6R534dzver1PF9UqV0KVSxVSi6dq6EDMHlu9BDyAj2b/V+VLl1Th/J6q93gt7dq5457Hf7HyU1WtGK7C+T31aLWKWrP6O6v948eOUdWK4SpS0EslihZU82aNtHPHdlu+BDwAznfO0r5WCa0f9qT2j2uoT3s/qgqBPhkeu7h7Df02qUma7aPOVSzHNCrvr3mvVtP2UfX126QmKlvUyx4vA8g0CtFsrFOnTmrZsqXldt26ddW/f//7um9wcLCmTZtmk1x/98+M/zR69GhVqlTJ5jmc1aqVKzT6jSEaNPQt/fDTdpUrX0Evtnpaly5dTPf4ndu36rUuL+vFlzvrx593qOnTzdW53XM6+OsByzH7fou12qZ+8LFMJpP+07yVvV4WMvD9l59p4pjh6jlwuD5bvVllwsurW/uWunI5/fN9688/VbxEiAa+MUaF/PzTPeb6tT/UvmUD5cqVWx/+3+f6esMuvT4yUt4++W34SnA/Vn66XG8MHaRhb47Qz1t3KaJCBbVu3lSXLqZ/vrdv3aJXOrZXh46vaPO23Xr6mRZq90Jr/frL/97foaFhem/qDG3dFaM1635SiaAgtXqmiS5fumSvl4UMcL5zlmYVi2j4M2U0c+1RtZy+RYfO3dDcLtVUIK9busf3XhSt2m+vt2zNJm9Wckqqvt93wXKMh5urdp/8Q+99/5u9Xgak/43NdbQtGzCZzWaz0SFyurp166pSpUoPXBhev35dZrNZ+fPnf+DHCQ4OVv/+/e+7cM2sTp066dq1a1q1alW6++Pj43X79m0VLFjQpjnSExcXJx8fHx05fVle3t52f/6s0LR+HVWqUk2R702XJKWmpqpKeEl16dZTfQa+nub4bp3aKSEhQf+3YpWlrdlTj6l8REVNmpZ+b1mnds8q/ka8Pvt6jU1egz1djU80OsJDafOfuoqoWEVvjZsi6c75rl+9tNp37qGuvQfd874Naoarw6u91KFrL6v2KeNHas/Orfq/L360WW6jFC/gYXSEh1Lv8VqqUrWaJk97X9Kd8102NEjdX+utgUOGpjm+00ttdTPhpj79/GtLW/0naqtCxYqa9v6sdJ8jLi5Oxf199dV3P6huvads80JwXzjfD67qyB+MjpBpn/Z+VPtPX9fbXx6UdOdyGz+9UVeLo07po40n/vX+HR8LUr9GYarzzgb9mZRita+Yr4c2DH9SLaZG6eC5GzbJb08pt2/q+IzndP36dXk70Oe1u58jtx48q3xejpNLkuJvxKlW2WIO92/2T/SI2lhiou0++Pr4+FiK0OwqX758hhShziAxMVH79u7RE3XrW9pcXFz0eN362rVzW7r32b1zu9XxklT3qYYZHn/p4gWtXfO92nXolGW5kTmJiYn6dV+0Hn28nqXNxcVFtR6rp7277z18717W//Ctyleoov7dXtJjFYLVulFtfbpkflZExkNITEzU3ujdqlf/f8WCi4uL6tZ/Sjt2bE33Pju2b1Pdeg2s2p5q2Eg7tqf//k5MTNSCuR/Lx8dHEREVsy48HhjnO2fJ7WpSuWLe2nL0iqXNbJa2HLmiSkH57+sxnqteXN/GnEtThALZCYVoFqtbt6569+6t/v37q1ChQmrcuLEOHDigpk2bKl++fPL399fLL7+sy5cvS7rTY7hp0yZNnz5dJpNJJpNJJ0+eVEpKirp06aKQkBB5eHiodOnSmj59utVz/duw139z48YNvfjii8qbN6+KFSumDz6w7hGbMmWKIiIilDdvXgUGBqpnz56Kj4+37F+wYIHy58+vNWvWqGzZssqXL5+aNGmic+fOZficO3fuVOHChTVx4kRJaYfm3n1N7733nooWLaqCBQuqV69eSkpKshxz7tw5Pf300/Lw8FBISIiWLl16X0ONb9++rbi4OKstO7t65bJSUlJU+B9DLgsX9tPFCxfSvc/FC+dV2M/vH8f7Z3j88qWLlS+fl5o9w7Bco127ekUpKSkqVMj6/BUs7KfLl9I/f/fjTOxJLVs8R0Ehofpo6Zdq2+FVjR85RKtWLHnYyHgIVy6n//728/PXhfPpn+8LF87L7x/vbz8/f124cN6q7fvvvlHRQt4qnN9TH7w/Tau+WaOChQpl7QvAA+F85yy+ed2Uy9VFl29Yd1Zcjr+twl55/vX+FQJ9VLqolz7dccZWEfEATA76kx1QiNrAwoUL5ebmpqioKE2YMEH169dX5cqVtWvXLq1evVoXLlzQCy+8IEmaPn26atWqpa5du+rcuXM6d+6cAgMDlZqaquLFi+vTTz/Vr7/+qpEjR+qNN97QihUrsiznu+++q4oVKyo6OlrDhg1Tv3799OOP/xue5+LiohkzZuiXX37RwoULtX79er3+uvVwz4SEBL333ntavHixfvrpJ8XGxmrw4MHpPt/69evVsGFDjRs3TkOHph1mdNeGDRt07NgxbdiwQQsXLtSCBQu0YMECy/4OHTro999/18aNG7Vy5Up99NFHupjBHJq/i4yMlI+Pj2ULDAz81/vkdMv+b4Fav/Ci3N3djY4CG0lNTVV4+UoaMHy0wstX1AsvvaLn2nXS8sVzjY4GG3niyXravH2PftywWQ0aNVanl9pmOA8R2R/n2/k8V724Dp27oX2nrxsdBXgoXEfUBsLCwjRp0iRJ0tixY1W5cmWNHz/esn/evHkKDAzUb7/9pkceeURubm7y9PRUkSJFLMe4urpqzJgxltshISHaunWrVqxYYSliH1adOnU0bNgwSdIjjzyiqKgoTZ06VQ0bNpQkq/mjwcHBGjt2rHr06KH//ve/lvakpCTNnj1bpUqVkiT17t1bb7/9dprn+uKLL9ShQwfNmTNHbdq0uWcuX19fzZw5U66uripTpoyefvpprVu3Tl27dtWhQ4e0du1a7dy5U9WqVZMkzZkzR2FhYf/6eocPH66BAwdabsfFxWXrYrRAwUJydXXVpYvW35ZfunRRfv7pL0zj518kzQeQS5cupHv8ti2bdfTIb/pwPj1jjiB/gYJydXXV5X8sTHTl0kUVKpz++b4fhf2KqNQjZazaSoWW1o/ffZnpx8TDK1go/ff3xYsX5F8k/fPt718kzZdyFy9ekL9/Eau2vHnzqlSpUJUqFaoaNR9VpfKltWjhPA0aMixrXwTuG+c7Z/njZqKSU1JVyMt6YaJC+fLo0o3b97yvR25XPV2xiKb/cNSWEQG7oEfUBqpWrWr5PSYmRhs2bFC+fPksW5kydz70HTt27J6P88EHH6hq1aoqXLiw8uXLp48++kixsbFZlrNWrVppbh88eNBye+3atXrqqadUrFgxeXl56eWXX9aVK1eUkJBgOcbT09NShEpS0aJF0/zHuH37dj3//PNavHjxvxahklSuXDm5urqm+5iHDx9Wrly5VKXK/5YrDw0Nla+v778+bp48eeTt7W21ZWdubm6qUKmKft60wdKWmpqqzZs2qFr1R9O9T9XqNfXzpvVWbT9tWJfu8UsXz1eFSlVUjrlEDsHNzU3hFSpr2+aNlrbU1FRt27xRlarWyPTjVqn+qE4cs15h8eTxowooViLTj4mH5+bmpkqVq2rjhv+9X1NTU7Vpw3rVqFEr3fvUqPmoNm1cZ9W2Yd1a1aiZ/t+Dvz/u7dv3/vAL2+J85yxJKWb9cjZOtUL/t0aGySTVCi2ovaeu3fO+TSoUkVsuF30V/buNU+J+mUyOuWUHFKI2kDdvXsvv8fHxeuaZZ7R3716r7ciRI3riiScyfIxly5Zp8ODB6tKli3744Qft3btXnTt3tuniR3938uRJ/ec//1GFChW0cuVK7d692zKH9O8ZcufObXU/k8mkfy7EXKpUKZUpU0bz5s2zmuuZkfQeMzU1NbMvxal179VPSxbO1fKli/Tb4YMaOqC3Em7eVNuXOkqSenfvrHGj37Qc3/W1Ptqw9gfNen+qjvx2SO9Gvq2Y6N3q3O01q8e9ERenr1etVPsOr9j19eDeOnXtrc+WLtCqFUt07MghjRnWT3/+maBWbV6SJA3r21VTIkdZjk9MTNTBA/t08MA+JSUl6sL533XwwD6dOvG/L8E6dO2tfXt26sMZ7+rUiWP65osV+nTJfL3YqZvdXx+s9e7bXwvnz9GS/1uow4cOakDfnkpIuKmX/lo8rFuXjho94g3L8a/16qu1P6zR+9Om6LfDhzR+7BhF79mlbj3urJR88+ZNjRn5pnZs36bYU6cUvWe3enbvonO/n1Wr1s8Z8RLxN5zvnGX+zyf1Qo3ialU1QKX88mpMq3LycHPVyl1nJUmT2kRoUJNH0tzv+RrFtPaXi7qWkPbzlI9HbpUt6qVQ/zufQ0P88qpsUS8Vypf+JWEAozE018aqVKmilStXKjg4WLlypf/P7ebmppQU61XPoqKiVLt2bfXs2dPS9m89qA9q27ZtaW6XLVtWkrR7926lpqZq8uTJcnG5831FZuenFipUSJ9//rnq1q2rF154QStWrEhTbN6v0qVLKzk5WdHR0Zae56NHj+qPP/7I1ONldy2ffUFXrlzWpPFv69KF8yoXUVGffP6NZcGLs2dOW86fJFWvWUv/nbNIE8eOUuTbIxRSKlTzl36msuHlrR531coVktmsVs/9ew827Kdpi+d09eplvf/eWF2+dEFlylXQh//3hWVo7rnfrc/3pQvn9Gzj2pbb82dP1/zZ01W91mNa+NlqSVJEpaqaMecTTZ0wSrOmTVDxwCANGzNRz7Tm3Bvt2efb6PLlyxr/9mhduHBeERUqaeWX31mG0p85bX2+a9aqrbkL/k/vjBmpMaPeVKnQMC1d8bnCy915f7u6uuq3w4e09P8W6cqVyypQoKCqVKum1Ws3qWx4OSNeIv6G852zfBdzXgXyuqlvozAV9sqjg7/HqcvcXbry12XGiub3UOo/LrAYUjivqoUUUKePd6b7mPXD/TSxTYTl9rT2lSRJ7/94VO//yFBeOB4KURvr1auXPv74Y7344ot6/fXXVaBAAR09elTLli3TnDlz5OrqquDgYG3fvl0nT55Uvnz5VKBAAYWFhWnRokVas2aNQkJCtHjxYu3cuVMhISFZli0qKkqTJk1Sy5Yt9eOPP+rTTz/Vt99+K+nOcNekpCS9//77euaZZxQVFaXZs2dn+rn8/Py0fv161atXTy+++KKWLVuWYWF+L2XKlFGDBg3UrVs3zZo1S7lz59agQYPk4eEhU3YZh5DFunTrqS7deqa774tv16Zpa97qOTVvde9vw1/u/Kpe7vxqluRD1mrfuYfad+6R7r67xeVdxQKD9OvZ+HSP/bu6DZuqbsOmWZIPWav7a73U/bVe6e777of1adpaPfu8Wj37fLrHu7u7a8nylVmaD1mL852z/N+WWP3flvSnXL38YdrLcp24dFOPvL46naPv+GL3WX2x+2yW5cP9Mf21ORJHy5MRhubaWEBAgKKiopSSkqJGjRopIiJC/fv3V/78+S3fbA4ePFiurq4KDw9X4cKFFRsbq+7du6t169Zq06aNatasqStXrlj1jmaFQYMGadeuXapcubLGjh2rKVOmqHHjxpKkihUrasqUKZo4caLKly+vJUuWKDIy8qGer0iRIlq/fr3279+v9u3bp+kFvl+LFi2Sv7+/nnjiCbVq1Updu3aVl5cXK7sCAAAA2YTJ/M8JfUA2c+bMGQUGBloWV7pfcXFx8vHx0ZHTl+WVzRcuwv25Gm+fOdZwDMULeBgdAYANVR35g9ERYAcpt2/q+IzndP36dYdaaPLu58gdh35XPi/HySVJ8TfiVKNMgMP9m/0TQ3OR7axfv17x8fGKiIjQuXPn9Prrrys4OPieiz8BAAAAWY6xuZlGIeqEfv75ZzVtmvF8r/j4f58z5siSkpL0xhtv6Pjx4/Ly8lLt2rW1ZMmSTC+ABAAAAMC+KESdULVq1bR3716jY9hM48aNLXNZAQAAAGQ/FKJOyMPDQ6GhoUbHAAAAAJya6a8fR+JoeTLCqrkAAAAAALuiEAUAAAAA2BVDcwEAAAAgE0ymO5sjcbQ8GaFHFAAAAABgVxSiAAAAAAC7YmguAAAAAGSC6a/NkThanozQIwoAAAAAsCsKUQAAAACAXTE0FwAAAAAyg7G5mUaPKAAAAADArihEAQAAAAB2xdBcAAAAAMgE018/jsTR8mSEHlEAAAAAgF1RiAIAAAAA7IqhuQAAAACQGSbJ5GgjYR0tTwboEQUAAAAA2BWFKAAAAADArhiaCwAAAACZYJLjjYR1tDwZoUcUAAAAAGBXFKIAAAAAALtiaC4AAAAAZAZjczONHlEAAAAAgF1RiAIAAAAA7IqhuQAAAACQCaa/fhyJo+XJCD2iAAAAAAC7ohAFAAAAANgVQ3MBAAAAIBNMpjubI3G0PBmhRxQAAAAAYFcUogAAAAAAu2JoLgAAAABkgumvzZE4Wp6M0CMKAAAAALArClEAAAAAgF0xNBcAAAAAMoOxuZlGjygAAAAAwK4oRAEAAAAAdsXQXAAAAADIBNNfP47E0fJkhB5RAAAAAIBdUYgCAAAAAOyKobkAAAAAkAkmSSYHGwnrYHEyRI8oAAAAAMCuKEQBAAAAAHbF0FwAAAAAyASTHG8orKPlyQg9ogAAAAAAu6IQBQAAAADYFUNzAQAAACATTCYHXDXXwfJkhB5RAAAAAIBdUYgCAAAAAOyKobkAAAAAkCmsm5tZ9IgCAAAAAOyKHlHkWGazWZJ048YNg5PAXuJvJhodAXYUlyvJ6AgAbCjl9k2jI8AOUm8nSPrf5zY4DwpR5Fh3C9Aq4SEGJwEAAMC93LhxQz4+PkbHSINVczOPQhQ5VkBAgE6fPi0vLy+Zsss7NgvExcUpMDBQp0+flre3t9FxYGOc75yF852zcL5zlpx6vs1ms27cuKGAgACjoyCLUYgix3JxcVHx4sWNjmEYb2/vHPUfWU7H+c5ZON85C+c7Z8mJ59sRe0Lx8ChEAQAAACATWDM381g1FwAAAABgVxSiQA6TJ08ejRo1Snny5DE6CuyA852zcL5zFs53zsL5hrMxmVkLGQAAAADuW1xcnHx8fHQ49pK8HGzO7o24OJUuUVjXr1936PnE9IgCAAAAAOyKQhQAAAAAYFesmgsAAAAAmWD668eROFqejNAjCgAAAACwKwpRAAAAAIBdMTQXAAAAADLD9NfmSBwtTwYoRAEntG/fvvs+tkKFCjZMAsDWUlNTdfToUV28eFGpqalW+5544gmDUgEAcG8UooATqlSpkkwmk8xms0yme38tlpKSYqdUsIdWrVqle85NJpPc3d0VGhqqdu3aqXTp0gakQ1bbtm2b2rVrp1OnTumflwU3mUy8v53Qnj17lDt3bkVEREiSvvzyS82fP1/h4eEaPXq03NzcDE6IrDRjxox02//+N/2JJ56Qq6urnZMBD49CFHBCJ06csPweHR2twYMHa8iQIapVq5YkaevWrZo8ebImTZpkVETYiI+Pj1atWqX8+fOratWqku58cL127ZoaNWqk5cuXa+LEiVq3bp3q1KljcFo8rB49eqhatWr69ttvVbRo0X/94gnZX/fu3TVs2DBFRETo+PHjatu2rVq1aqVPP/1UCQkJmjZtmtERkYWmTp2qS5cuKSEhQb6+vpKkP/74Q56ensqXL58uXryokiVLasOGDQoMDDQ4bc7EyNzMM5n/+RUqAKdSo0YNjR49Ws2aNbNq/+677zRixAjt3r3boGSwhWHDhikuLk4zZ86Ui8ud9ehSU1PVr18/eXl5ady4cerRo4d++eUXbd682eC0eFh58+ZVTEyMQkNDjY4CO/Hx8dGePXtUqlQpTZw4UevXr9eaNWsUFRWltm3b6vTp00ZHRBb65JNP9NFHH2nOnDkqVaqUJOno0aPq3r27unXrpjp16qht27YqUqSIPvvsM4PT5ixxcXHy8fHRkdOX5eXtbXQcKzfi4hQWWEjXr1+Xt4Nl+ztWzQWc3P79+xUSEpKmPSQkRL/++qsBiWBLc+fOVf/+/S1FqCS5uLioT58++uijj2QymdS7d28dOHDAwJTIKjVr1tTRo0eNjgE7MpvNlrnAa9eutXzJGBgYqMuXLxsZDTbw1ltvaerUqZYiVJJCQ0P13nvvafjw4SpevLgmTZqkqKgoA1MCmcPQXMDJlS1bVpGRkZozZ45l7lBiYqIiIyNVtmxZg9MhqyUnJ+vQoUN65JFHrNoPHTpkmS/o7u7OEE4n0adPHw0aNEjnz59XRESEcufObbWfxcicT7Vq1TR27Fg1aNBAmzZt0qxZsyTdmZLh7+9vcDpktXPnzik5OTlNe3Jyss6fPy9JCggI0I0bN+wdDX8xme5sjsTR8mSEQhRwcrNnz9Yzzzyj4sWLWz6U7tu3TyaTSV9//bXB6ZDVXn75ZXXp0kVvvPGGqlevLknauXOnxo8frw4dOkiSNm3apHLlyhkZE1nk2WeflSS98sorlra/L1TGYkXOZ9q0aWrfvr1WrVqlN9980zIs+7PPPlPt2rUNToesVq9ePXXv3l1z5sxR5cqVJd1Z++G1115T/fr1JWU88glwdMwRBXKAmzdvasmSJTp06JCkO72k7dq1U968eQ1OhqyWkpKiCRMmaObMmbpw4YIkyd/fX3369NHQoUPl6uqq2NhYubi4qHjx4ganxcM6derUPfcHBQXZKQmMduvWLbm6uqbpFUf2dv78eb388stat26d5dwmJyfrqaee0uLFi+Xv768NGzYoKSlJjRo1MjhtznJ3jujRM445RzS0uOPPEaUQBZxYUlKSypQpo2+++YZhuDlQXFycJDn0f0IAMicxMTHda8eWKFHCoESwpUOHDum3336TJJUuXZpLcDmAu4XosTNXHLIQLVW8oMMXogzNBZxY7ty5devWLaNjwCCO/J8Pss6xY8c0bdo0HTx4UJIUHh6ufv36WS1uAufx22+/qUuXLtqyZYtVO8OxnVuZMmVUpkwZo2MAWYpCFHByvXr10sSJEzVnzhzlysVb3tlduHBBgwcP1rp163Tx4kX9c9ALH1Kdy5o1a9S8eXNVqlTJcl3YqKgolStXTl9//bUaNmxocEJktc6dOytXrlz65ptvuHZsDpCSkqIFCxZY/qb/swd8/fr1BiUDHh6fSgEnt3PnTq1bt04//PCDIiIi0swL/fzzzw1KBlvo1KmTYmNjNWLECD6k5gDDhg3TgAEDNGHChDTtQ4cOpRB1Qnv37tXu3bvpHcsh+vXrpwULFujpp59W+fLl+ZvuiEx/bY7E0fJkgEIUcHL58+e3rKwJ57d582b9/PPPqlSpktFRYAcHDx7UihUr0rS/8sormjZtmv0DwebCw8O5XmgOsmzZMq1YscJyvVjAmVCIAk5u/vz5RkeAHQUGBqYZjgvnVbhwYe3du1dhYWFW7Xv37pWfn59BqWBLEydO1Ouvv67x48ene+1Y5oY7Fzc3N8slegBnQyEKAE5k2rRpGjZsmD788EMFBwcbHQc21rVrV3Xr1k3Hjx+3XEMyKipKEydO1MCBAw1OB1to0KCBJOmpp56yamexIuc0aNAgTZ8+XTNnzmRYroNiZG7mcfkWIAf47LPPtGLFCsXGxioxMdFq3549ewxKBVvw9fVVQkKCkpOT5enpmaa35OrVqwYlgy2YzWZNmzZNkydP1u+//y5JCggI0JAhQ9S3b18+uDqhTZs23XP/k08+aacksIdWrVppw4YNKlCggMqVK5fmbzrrPBjn7uVbjp91zMu3lCzG5VsAGGzGjBl688031alTJ3355Zfq3Lmzjh07pp07d6pXr15Gx0MWY15gzmIymTRgwAANGDBAN27ckCR5eXkZnAq2RKGZs+TPn1+tWrUyOgZgE/SIAk6uTJkyGjVqlF588UV5eXkpJiZGJUuW1MiRI3X16lXNnDnT6IgAgAeUkJCQ7iiXChUqGJQIyFnu9oie+N0xe0RDAugRBWCw2NhYy9wxDw8PS6/Jyy+/rEcffZRC1AnExcVZ/qOJi4u757GO/B8S7k+VKlW0bt06+fr6qnLlyvccfsvQe+dz6dIlde7cWd9//326+5kjCiC7oBAFnFyRIkV09epVBQUFqUSJEtq2bZsqVqyoEydOsLqqk/D19dW5c+fk5+en/Pnzp1uYsJCJ82jRooXy5Mlj+Z15oDlL//79de3aNW3fvl1169bVF198oQsXLmjs2LGaPHmy0fGQBfiyCTkFhSjg5OrXr6+vvvpKlStXVufOnTVgwAB99tln2rVrl1q3bm10PGSB9evXq0CBApKkDRs2GJwGtjZq1CjL76NHjzYuCAyxfv16ffnll6pWrZpcXFwUFBSkhg0bytvbW5GRkXr66aeNjoiHxJdN2Y1JJodbp9bR8qSPOaKAk0tNTVVqaqpy5brzvdOyZcu0ZcsWhYWFqXv37nJzczM4IbJSbGysAgMD03xwMZvNOn36tEqUKGFQMthCyZIltXPnThUsWNCq/dq1a6pSpYqOHz9uUDLYire3t/bt26fg4GAFBQVp6dKlqlOnjk6cOKFy5copISHB6Iiwk7sjXWCM/80Rvepw017i4uIUElDA4eeIuhgdAIBtubi4WIpQSWrbtq1mzJihPn36UIQ6oZCQEF26dClN+9WrVxUSEmJAItjSyZMn0x1uffv2bZ05c8aARLC10qVL6/Dhw5KkihUr6sMPP9TZs2c1e/ZsFS1a1OB0yGrvvvtuuu0pKSlq166dndMAWYuhuYCTmz9/vvLly6fnn3/eqv3TTz9VQkKCOnbsaFAy2EJG35DHx8fL3d3dgESwha+++sry+5o1a+Tj42O5nZKSonXr1vHFg5Pq16+fzp07J+nOMO0mTZpoyZIlcnNz04IFC4wNhyz37rvvqkCBAurSpYulLSUlRW3bttWBAwcMTIa7TKY7myNxtDwZoRAFnFxkZKQ+/PDDNO1+fn7q1q0bhaiTGDhwoKQ715UcMWKEPD09LftSUlK0fft2VapUyaB0yGotW7aUdOd8//M9nDt3bgUHB7NwjZN66aWXLL9XrVpVp06d0qFDh1SiRAkVKlTIwGSwhW+//VaNGjWSj4+PnnvuOSUnJ+uFF17QoUOHWBMA2R6FKODkYmNj0+0ZCQoKUmxsrAGJYAvR0dGS7vSI7t+/32rYtZubmypWrKjBgwcbFQ9ZLDU1VdKdodg7d+6kAMmhzGazPDw8VKVKFaOjwEaqV6+ulStXqmXLlnJzc9PcuXN19OhRbdiwQf7+/kbHAx4KhSjg5Pz8/CwLW/xdTExMmgVOkH3d/Wa8c+fOmjFjhry8vAxOBHs4ceKE0RFggEWLFundd9/VkSNHJEmPPPKIhgwZopdfftngZLCF+vXra9GiRXr22WdVtmxZbdq0iS+f4BQoRAEn9+KLL6pv377y8vLSE088IUnatGmT+vXrp7Zt2xqcDlkpKSlJixcv1qBBg1S+fHmj48AO+vbtq9DQUPXt29eqfebMmTp69KimTZtmTDDYzJQpUzRixAj17t1bderUkSRt3rxZPXr00OXLlzVgwACDE+JhZXRptcKFCyt//vzq1q2bpe3zzz+3Vywgy1GIAk7unXfe0cmTJ/XUU09ZVs9NTU1Vhw4dNH78eIPTISvlzp1bJUqUSHcVVTinlStXWi1cdFft2rU1YcIEClEn9P7772vWrFnq0KGDpa158+YqV66cRo8eTSHqBP6++NjfNW7c2M5JANviOqJADnHkyBHt3btXHh4eioiIUFBQkNGRYANz587V559/rsWLF6tAgQJGx4GNubu768CBAwoNDbVqP3r0qMqXL69bt24ZlAy2ktE5P3LkiCIiIjjngJ3cvY7oqfOOeR3RoCKOfx1RekSBHCIsLExhYWEZ7vf29tbevXtVsmRJO6ZCVrs7JDMgIEBBQUHKmzev1f49e/YYlAy2EBoaqtWrV6t3795W7d9//z3vZScVGhqqFStW6I033rBqX758+T3/xgOAo6EQBSDpzuqLyP7uXtYDOcPAgQPVu3dvXbp0SfXr15ckrVu3TpMnT2ZYrpMaM2aM2rRpo59++skyRzQqKkrr1q3TihUrDE6HrHbhwgUNHjxY69at08WLF9P8X81UDGRnDM0FIEny8vJSTEwMvShANjNr1iyNGzdOv//+uyQpODhYo0ePtppDCOeye/duTZ06VQcPHpQklS1bVoMGDVLlypUNToas1rRpU8XGxqp3794qWrSoTCaT1f4WLVoYlAx3h+bGnv/D4Ya/xsXFqUQRX4cfmkshCkAShaiz2b17t+VDarly5fiAmgNcunRJHh4eypcvn9FRAGQRLy8v/fzzz6pUqZLRUfAPFKIPj6G5AOBELl68qLZt22rjxo3Knz+/JOnatWuqV6+eli1bpsKFCxsbEFkuOTlZGzdu1LFjx9SuXTtJ0u+//y5vb2+KUicRFxd338c68odOPLjAwECmzsBpuRgdAIBj+OdwH2RPffr00Y0bN/TLL7/o6tWrunr1qg4cOKC4uLg015pE9nfq1ClFRESoRYsW6tWrly5duiRJmjhxogYPHmxwOmSV/Pnzy9fX957b3WPgXKZNm6Zhw4bp5MmTRkdBBkwmx9yyA3pEAUhisSJnsXr1aq1du1Zly5a1tIWHh+uDDz5Qo0aNDEwGW+jXr5+qVaummJgYFSxY0NLeqlUrde3a1cBkyEobNmwwOgIM0qZNGyUkJKhUqVLy9PRU7ty5rfZfvXrVoGTAw6MQBZzc22+/rcGDB8vT09Oq/c8//9S7776rkSNHSrpzuYdixYoZERFZKDU1Nc0HFUnKnTu3UlNTDUgEW/r555+1ZcsWubm5WbUHBwfr7NmzBqVCVnvyyScf+D49e/bU22+/rUKFCtkgEeyF1a/hzFisCHByrq6uOnfunPz8/Kzar1y5Ij8/P5Z+dzItWrTQtWvX9MknnyggIECSdPbsWbVv316+vr764osvDE6IrOTr66uoqCiFh4dbLTi2efNmPfvss7pw4YLREWEQrg0N2NbdxYrOXHDMxYqK+zv+YkXMEQWcnNlsTnf+Z0xMjAoUKGBAItjSzJkzFRcXp+DgYJUqVUqlSpVSSEiI4uLi9P777xsdD1msUaNGVj0mJpNJ8fHxGjVqlJo1a2ZcMBiOfgbnc+vWLcXFxVltQHbG0FzASfn6+spkMslkMumRRx6xKkZTUlIUHx+vHj16GJgQthAYGKg9e/Zo7dq1OnTokKQ71xhs0KCBwclgC5MnT1bjxo0VHh6uW7duqV27djpy5IgKFSqkTz75xOh4AB7SzZs3NXToUK1YsUJXrlxJs59RTcjOKEQBJzVt2jSZzWa98sorGjNmjHx8fCz73NzcFBwcrFq1ahmYELZiMpnUsGFDNWzY0OgosLHixYsrJiZGy5Yt0759+xQfH68uXbqoffv28vDwMDoegIf0+uuva8OGDZo1a5ZefvllffDBBzp79qw+/PBDTZgwweh4kCTTX5sjcbQ8GWCOKODkNm3apNq1a6e7gA2c07p16zR16lQdPHhQ0p0e0f79+9MrCuQgf58zjOyrRIkSWrRokerWrStvb2/t2bNHoaGhWrx4sT755BN99913RkfMsSxzRC866BxRP8efI0qPKOCE4uLiLH94KleurD///FN//vlnusc68h8oPLj//ve/6tevn5577jn169dPkrRt2zY1a9ZMU6dOVa9evQxOiIf11Vdf3fexzZs3t2ESALZ29epVy5cJ3t7elsu1PPbYY3rttdeMjAY8NApRwAn5+vpaVsrNnz9/uosV3V3EiPklzmX8+PGaOnWqevfubWnr27ev6tSpo/Hjx1OIOoGWLVve13G8v3O2l156iS8anUDJkiV14sQJlShRQmXKlNGKFStUo0YNff3118qfP7/R8SDJ9NePI3G0PBmhEAWc0Pr16y0r4nIh9Jzl2rVratKkSZr2Ro0aaejQoQYkQlbjerA5z759++772AoVKkiSZs2aZas4sKPOnTsrJiZGTz75pIYNG6ZnnnlGM2fOVFJSkqZMmWJ0POChMEcUAJxIu3btVLlyZQ0ZMsSq/b333tOuXbu0bNkyg5IByCwXFxeZTKYML8f1d/SCO7eTJ09a5one/dIBxrg7R/TsxWsON/ogLi5OxfzyM0cUgP1l5ttzOIfw8HCNGzdOGzdutKyKvG3bNkVFRWnQoEGaMWOG5di+ffsaFRMP4e/n8N9wjp3DiRMnLL9HR0dr8ODBGjJkiOU9vnXrVk2ePFmTJk0yKiLsJDg4WMHBwUbHwN+YTHc2R+JoeTJCjyjghPj2POcKCQm5r+NMJpOOHz9u4zSwBc5xzlajRg2NHj1azZo1s2r/7rvvNGLECO3evdugZLAVVkJ3THd7RH+/5Jg9ogGF6REFYAC+Pc+5/n7u4Zw4xznb/v370/0yIiQkRL/++qsBiWBLrIQOZ0aPKODk+PY8Z0pMTNSJEydUqlQp5crFd445wd3/zv9tFASytypVqqh8+fKaM2eO3NzcJN15v7/66qs6cOCA9uzZY3BCZKXixYtr2LBhViuhS9IHH3yg8ePH6+zZswYlw90e0XMO2iNaNBv0iLoYHQCAbfHtec6SkJCgLl26yNPTU+XKlVNsbKwkqU+fPpowYYLB6WALixYtUkREhDw8POTh4aEKFSpo8eLFRseCjcyePVtr1qxR8eLF1aBBAzVo0EDFixfXmjVrNHv2bKPjIYvdayX069evG5AIyDoUooCTK1u2rCIjI5WYmGhpS0xMVGRkpMqWLWtgMtjC8OHDFRMTo40bN8rd3d3S3qBBAy1fvtzAZLCFKVOm6LXXXlOzZs20YsUKrVixQk2aNFGPHj00depUo+PBBmrUqKHjx49r7NixqlChgipUqKBx48bp+PHjqlGjhtHxkMWaN2+uL774Ik37l19+qf/85z8GJAKyDkNzASe3Y8cOPfPMMzKbzZYVcvft2yeTyaSvv/6aDy5OJigoSMuXL9ejjz4qLy8vxcTEqGTJkjp69KiqVKmiuLg4oyMiC4WEhGjMmDHq0KGDVfvChQs1evRo5pMC2dDfV8aOi4vTe++9pzp16qS7Evpbb71lVMwczzI097KDDs0t5PhDcylEgRzg5s2bWrJkiQ4dOiTpTi9pu3btlDdvXoOTIat5enrqwIEDKlmypFUhGhMToyeeeIKhXE7G3d1dBw4cUGhoqFX7kSNHFBERoVu3bhmUDLZ05MgRbdiwQRcvXlRqaqrVvpEjRxqUClmFlbGzBwrRh8cKFkAOkDdvXnXr1s3oGLCDatWq6dtvv1WfPn0k/W/hmjlz5li+TYfzCA0N1YoVK/TGG29YtS9fvlxhYWEGpYItffzxx3rttddUqFAhFSlSxGpxKpPJRCHqBBjJgJyCQhTIARYvXqwPP/xQx48f19atWxUUFKSpU6eqZMmSatGihdHxkIXGjx+vpk2b6tdff1VycrKmT5+uX3/9VVu2bNGmTZuMjocsNmbMGLVp00Y//fST6tSpI0mKiorSunXrtGLFCoPTwRbGjh2rcePGaejQoUZHgQPx9vbW3r17VbJkSaOj5Dimv34ciaPlyQiLFQFObtasWRo4cKCaNm2qP/74QykpKZIkX19fTZs2zdhwyHKPPfaYYmJilJycrIiICP3www/y8/PT1q1bVbVqVaPjIYs9++yz2r59uwoVKqRVq1Zp1apVKlSokHbs2KFWrVoZHQ828Mcff+j55583OgYcDDPtkB0xRxRwcuHh4Ro/frxatmxpNWfwwIEDqlu3ri5fvmx0RGSRpKQkde/eXSNGjLjvOUYAspcuXbqoevXq6tGjh9FR4ED+/v877OPuHNHzlx1vHmZcXJyKFPJx+Dmi9IgCTu7EiROqXLlymvY8efLo5s2bBiSCreTOnVsrV640Ogbs6LvvvtOaNWvStK9Zs0bff/+9AYlga6GhoRoxYoQ6deqkyZMna8aMGVYbAPsymRxzy4wPPvhAwcHBcnd3V82aNbVjx457Hv/pp5+qTJkycnd3V0REhL777rsHej4KUcDJhYSEaO/evWnaV69ezXVEnVDLli21atUqo2PAToYNG2YZbv93ZrNZw4YNMyARbO2jjz5Svnz5tGnTJs2cOVNTp061bEy3AJBZy5cv18CBAzVq1Cjt2bNHFStWVOPGjXXx4sV0j9+yZYtefPFFdenSRdHR0WrZsqVatmypAwcO3PdzslgR4OQGDhyoXr166datWzKbzdqxY4c++eQTRUZGas6cOUbHQxYLCwvT22+/raioKFWtWjXNJXr69u1rUDLYwpEjRxQeHp6mvUyZMjp69KgBiWBrrKiK9Jgy2wWGh+aI1+e+m+mf2fLkyaM8efKke58pU6aoa9eu6ty5syRp9uzZ+vbbbzVv3rx0v9icPn26mjRpoiFDhkiS3nnnHf3444+aOXOmZs+efV85KUQBJ/fqq6/Kw8NDb731lhISEtSuXTsFBARo+vTpatu2rdHxkMXmzp2r/Pnza/fu3dq9e7fVPpPJRCHqZHx8fHT8+HEFBwdbtR89epTrBAM5CEu+2J+bm5uKFCmisJBAo6OkK1++fAoMtM42atQojR49Os2xiYmJ2r17t4YPH25pc3FxUYMGDbR169Z0H3/r1q0aOHCgVVvjxo0faFQWhSjgxJKTk7V06VI1btxY7du3V0JCguLj4+Xn52d0NNgIvSU5S4sWLdS/f3998cUXKlWqlKQ7ReigQYPUvHlzg9PBVs6cOaOvvvpKsbGxSkxMtNo3ZcoUg1LBSN9//72KFStmdIwcxd3dXSdOnEjzHnQUZrM5TU95Rr2hly9fVkpKivz9/a3a/f39dejQoXTvc/78+XSPP3/+/H1npBAFnFiuXLnUo0cPHTx4UJLk6ekpT09Pg1PBEXDNOecwadIkNWnSRGXKlFHx4sUl3SlSHn/8cb333nsGp4MtrFu3Ts2bN1fJkiV16NAhlS9fXidPnpTZbFaVKlWMjocs8M9epnu5+8XDY489Zqs4uAd3d3e5u7sbHSPbohAFnFyNGjUUHR2toKAgo6PAgTCMyzn4+Phoy5Yt+vHHHxUTEyMPDw9VqFBBTzzxhNHRYCPDhw/X4MGDNWbMGHl5eWnlypXy8/NT+/bt1aRJE6PjIQtER0ff13HMC0VWKVSokFxdXXXhwgWr9gsXLqhIkSLp3qdIkSIPdHx6uI4o4ORWrFih4cOHa8CAAekuXlOhQgWDksFIXHMuZ7m7rP4/5wsh+/Hy8tLevXtVqlQp+fr6avPmzSpXrpxiYmLUokULnTx50uiIALKhmjVrqkaNGnr//fclSampqSpRooR69+6d7mJFbdq0UUJCgr7++mtLW+3atVWhQgUWKwJwx90Fif6+SI3JZLLMHUjv0g8AnMvJkyeVlJRkdAxkgbx581rmpBUtWlTHjh1TuXLlJN2Z5wUAmTFw4EB17NhR1apVU40aNTRt2jTdvHnTsopuhw4dVKxYMUVGRkqS+vXrpyeffFKTJ0/W008/rWXLlmnXrl366KOP7vs5KUQBJ8fiNQDgPB599FFt3rxZZcuWVbNmzTRo0CDt379fn3/+uR599FGj4yELtG7dWgsWLJC3t7dat259z2M///xzO6WCs2vTpo0uXbqkkSNH6vz586pUqZJWr15tWZAoNjZWLi4uluNr166tpUuX6q233tIbb7yhsLAwrVq1SuXLl7/v56QQBZzc0qVL5e/vr1deecWqfd68ebp06ZKGDh1qUDIYiblFQPY0ZcoUxcfHS5LGjBmj+Ph4LV++XGFhYayY6yR8fHwsf6N9fHwMToOcpHfv3urdu3e6+zZu3Jim7fnnn9fzzz+f6edjjijg5IKDg7V06VLVrl3bqn379u1q27YtPaY5FHNEcxbOd87zySefqHnz5lxPFoDDcvn3QwBkZ+fPn1fRokXTtBcuXFjnzp0zIBFs6e2331ZCQkKa9j///FNvv/225TbXnAOcW/fu3dOsaAkAjoRCFHBygYGBioqKStMeFRWlgIAAAxLBlu4O1funhIQEjRkzxnL7sccey/DC1gCyPwa8OY/PPvtML7zwgh599FFVqVLFagOyMwpRwMl17dpV/fv31/z583Xq1CmdOnVK8+bN04ABA9S1a1ej4yGL3V0N+Z9iYmJUoEABAxLBlhYtWqTbt2+naU9MTNSiRYsstz/88EPLghMAso8ZM2aoc+fO8vf3V3R0tGrUqKGCBQvq+PHjatq0qdHxgIfCHFHAyZnNZg0bNkwzZsywLPnv7u6uoUOHauTIkQanQ1bx9fWVyWTS9evX5e3tbVWMpqSkKD4+Xj169NAHH3xgYEpkNVdXV507d05+fn5W7VeuXJGfnx+XZ8rBmBfsHMqUKaNRo0bpxRdftDqnI0eO1NWrVzVz5kyjIwKZRiEK5BDx8fE6ePCgPDw8FBYWxrBMJ7Nw4UKZzWa98sormjZtmtVKi25ubgoODlatWrUMTAhbcHFx0YULF1S4cGGr9piYGNWrV09Xr141KBmMRiHqHDw9PXXw4EEFBQXJz89PP/74oypWrKgjR47o0Ucf1ZUrV4yOCGQal28Bcoh8+fKpevXqRseAjXTs2FGSFBISotq1ayt37twGJ4ItVa5cWSaTSSaTSU899ZRy5frff+cpKSk6ceKEmjRpYmBCAFmhSJEiunr1qoKCglSiRAlt27ZNFStW1IkTJ5gHjGyPQhQAsrm4uDh5e3tLulOg/Pnnn/rzzz/TPfbuccjeWrZsKUnau3evGjdurHz58ln23e0Bf/bZZw1KB0cQFBTEF1JOoH79+vrqq69UuXJlde7cWQMGDNBnn32mXbt2qXXr1kbHAx4KQ3MBIJv7+zxBFxeXdBcruruIEXMGncvChQvVpk0bubu7Gx0FdnL69GmZTCYVL15ckrRjxw4tXbpU4eHh6tatm8HpkNVSU1OVmppqGfWwbNkybdmyRWFhYerevbvc3NwMTghkHoUoAGRzmzZtUp06dZQrVy5t2rTpnsc++eSTdkoFe9q1a5cOHjwoSQoPD1fVqlUNTgRbefzxx9WtWze9/PLLOn/+vEqXLq1y5crpyJEj6tOnD4vQOZnY2FgFBgam+YLRbDbr9OnTKlGihEHJgIdHIQoAQDZ19uxZtW3bVlFRUcqfP78k6dq1a6pdu7aWLVtm6TWD8/D19dW2bdtUunRpzZgxQ8uXL1dUVJR++OEH9ejRQ8ePHzc6IrIQK2PDmTFHFACyuX379t33sRUqVLBhEthbly5dlJSUpIMHD6p06dKSpMOHD6tz58569dVXtXr1aoMTIqslJSVZVj1fu3atmjdvLunOZT7OnTtnZDTYQEbXho6Pj2dIPrI9ekQBIJu7Oy80ow8sf8e3587Fw8NDW7ZsUeXKla3ad+/erccff1wJCQkGJYOt1KxZU/Xq1dPTTz+tRo0aWVZR3bZtm5577jmdOXPG6IjIAgMHDpQkTZ8+XV27dpWnp6dlX0pKirZv3y5XV1dFRUUZFRF4aPSIAkA2d+LECcvv0dHRGjx4sIYMGWK5bujWrVs1efJkTZo0yaiIsJHAwEAlJSWlaU9JSVFAQIABiWBrEydOVKtWrfTuu++qY8eOqlixoiTpq6++Uo0aNQxOh6wSHR0t6U6P6P79+60WJXJzc1PFihU1ePBgo+IBWYIeUQBwIjVq1NDo0aPVrFkzq/bvvvtOI0aM0O7duw1KBlv48ssvNX78eH3wwQeqVq2apDsLF/Xp00dDhw61XOYFziUlJUVxcXHy9fW1tJ08eVKenp5p5hIie+vcubOmT5/OpbfglChEAcCJeHh4aM+ePSpbtqxV+8GDB1WlSpUMry+K7MPX19dqCPbNmzeVnJxsubzD3d/z5s2rq1evGhUTNpScnKyNGzfq2LFjateunby8vPT777/L29vb6pqycB5Hjx7VsWPH9MQTT8jDw+O+pmIAjo6huQDgRMqWLavIyEjNmTPHMpQrMTFRkZGRaYpTZE/Tpk0zOgIMdOrUKTVp0kSxsbG6ffu2GjZsKC8vL02cOFG3b9/W7NmzjY6ILHT16lU9//zz2rBhg0wmk44cOaKSJUuqS5cu8vX11eTJk42OCGQahSgAOJHZs2frmWeeUfHixS0r5O7bt08mk0lff/21wemQFTp27Gh0BBioX79+qlatmmJiYlSwYEFLe6tWrdS1a1cDk8EW+vfvr9y5cys2Ntbqy8Q2bdpo4MCBFKLI1ihEAcCJ1KhRQ8ePH9eSJUt06NAhSXc+sLRr10558+Y1OB1s4dixY5o/f76OHTum6dOny8/PT99//71KlCihcuXKGR0PWeznn3/Wli1brBavkaTg4GCdPXvWoFSwlR9++EFr1qxJc03gsLAwnTp1yqBUQNagEAUAJ5M3b15169bN6Biwg02bNqlp06aqU6eOfvrpJ40bN05+fn6KiYnR3Llz9dlnnxkdEVksNTU13cswnTlzRl5eXgYkgi3dvHnT6tItd129etVyPVkgu3IxOgAAIGstXrxYjz32mAICAizfmE+dOlVffvmlwcmQ1YYNG6axY8fqxx9/tOohq1+/vrZt22ZgMthKo0aNrOYJm0wmxcfHa9SoUWlWy0b29/jjj2vRokWW2yaTSampqZo0aZLq1atnYDLg4VGIAoATmTVrlgYOHKimTZvqjz/+sPSc+Pr6ssiNE9q/f79atWqVpt3Pz0+XL182IBFsbfLkyYqKilJ4eLhu3bqldu3aWYblTpw40eh4yGLvvvuuPvroIzVt2lSJiYl6/fXXVb58ef3000+cb2R7FKIA4ETef/99ffzxx3rzzTctl/OQpGrVqmn//v0GJoMt5M+fX+fOnUvTHh0drWLFihmQCLZWvHhxxcTE6I033tCAAQNUuXJlTZgwQdHR0VxD1MkkJSWpb9+++vrrr/XYY4+pRYsWunnzplq3bq3o6GiVKlXK6IjAQ2GOKAA4kRMnTqhy5cpp2vPkyaObN28akAi21LZtWw0dOlSffvqpZcheVFSUBg8erA4dOhgdDzaSK1cuvfTSS0bHgI3lzp1b+/btk6+vr958802j4wBZjkIUAJxISEiI9u7dq6CgIKv21atXcx1RJzR+/Hj16tVLgYGBSklJUXh4uJKTk9W+fXu99dZbRseDDXz11VfptptMJrm7uys0NFQhISF2TgVbeemllzR37lxNmDDB6ChAlqMQBQAnMnDgQPXq1Uu3bt2S2WzWjh079MknnygyMlJz5swxOh6ymJubmz7++GONHDlS+/fvV3x8vCpXrqywsDCjo8FGWrZsKZPJJLPZbNV+t81kMumxxx7TqlWr5Ovra1BKZJXk5GTNmzdPa9euVdWqVdNchmvKlCkGJQMensn8z79kAIBsbcmSJRo9erSOHTsmSQoICNCYMWPUpUsXg5MhKwwcOPC+j+VDqvNZt26d3nzzTY0bN041atSQJO3YsUMjRozQW2+9JR8fH3Xv3l01a9bU3LlzDU6Lh3WvlXFNJpPWr19vxzRA1qIQBQAnkZycrKVLl6px48by9/dXQkKC4uPjWcDEyfzzg+mePXuUnJys0qVLS5J+++03ubq6qmrVqnxIdULly5fXRx99pNq1a1u1R0VFqVu3bvrll1+0du1avfLKK4qNjTUoJQD8O4bmAoCTyJUrl3r06KGDBw9Kkjw9PdO9EDqytw0bNlh+nzJliry8vLRw4ULLMMw//vhDnTt31uOPP25URNjQsWPH5O3tnabd29tbx48flySFhYVx+R4ADo/LtwCAE6lRo4aio6ONjgE7mTx5siIjI63mAvr6+mrs2LGaPHmygclgK1WrVtWQIUN06dIlS9ulS5f0+uuvq3r16pKkI0eOKDAw0KiIAHBf6BEFACfSs2dPDRo0SGfOnEl3YYsKFSoYlAy2EBcXZ1WQ3HXp0iXduHHDgESwtblz56pFixYqXry4pdg8ffq0SpYsqS+//FKSFB8fz6rJABwec0QBwIm4uKQd6PL31TRTUlIMSAVb6dChg37++WdNnjzZsnDN9u3bNWTIED3++ONauHChwQlhC6mpqfrhhx/022+/SZJKly6thg0bpvv+BwBHRSEKAE7k1KlT99z/z+uLIntLSEjQ4MGDNW/ePCUlJUm6M1e4S5cuevfdd9P0iAMA4CgoRAHAiURGRsrf31+vvPKKVfu8efN06dIlDR061KBksKWbN29aLtdTqlQpClAnd/PmTW3atEmxsbFKTEy02te3b1+DUgHAg6EQBQAnEhwcrKVLl6a5tMP27dvVtm1bnThxwqBkALJCdHS0mjVrpoSEBN28eVMFChTQ5cuX5enpKT8/P8vKuQDg6JhMAABO5Pz58ypatGia9sKFC+vcuXMGJAKQlQYMGKBnnnlGf/zxhzw8PLRt2zadOnVKVatW1XvvvWd0PAC4bxSiAOBEAgMDFRUVlaY9KipKAQEBBiQCkJX27t2rQYMGycXFRa6urrp9+7YCAwM1adIkvfHGG0bHA4D7xuVbAMCJdO3aVf3791dSUpLq168vSVq3bp1ef/11DRo0yOB0AB5W7ty5Lavj+vn5KTY2VmXLlpWPj49Onz5tcDoAuH8UogDgRIYMGaIrV66oZ8+elkVM3N3dNXToUA0fPtzgdAAeVuXKlbVz506FhYXpySef1MiRI3X58mUtXrxY5cuXNzoeANw3FisCACcUHx+vgwcPysPDQ2FhYcqTJ4/RkQBkgV27dunGjRuqV6+eLl68qA4dOmjLli0KCwvTvHnzVLFiRaMjAsB9oRAFAAAAANgVixUBAAAAAOyKOaIAAADZROXKlWUymdK0m0wmubu7KzQ0VJ06dVK9evUMSAcA948eUQAAgGyiSZMmOn78uPLmzat69eqpXr16ypcvn44dO6bq1avr3LlzatCggb788kujowLAPTFHFAAAIJvo2rWrSpQooREjRli1jx07VqdOndLHH3+sUaNG6dtvv9WuXbsMSgkA/45CFAAAIJvw8fHR7t27FRoaatV+9OhRVa1aVdevX9ehQ4dUvXp13bhxw6CUAPDvGJoLAACQTbi7u2vLli1p2rds2SJ3d3dJUmpqquV3AHBULFYEAACQTfTp00c9evTQ7t27Vb16dUnSzp07NWfOHL3xxhuSpDVr1qhSpUoGpgSAf8fQXAAAgGxkyZIlmjlzpg4fPixJKl26tPr06aN27dpJkv7880/LKroA4KgoRAEAAAAAdsUcUQAAgGyiZMmSunLlSpr2a9euqWTJkgYkAoDMoRAFAADIJk6ePKmUlJQ07bdv39bZs2cNSAQAmcNiRQAAAA7uq6++svy+Zs0a+fj4WG6npKRo3bp1Cg4ONiAZAGQOc0QBAAAcnItLxoPYcufOreDgYE2ePFn/+c9/7JgKADKPQhQAACCbCAkJ0a5du1SwYEGjowDAQ2GOKAAAQDaQlJSkkiVL6urVq0ZHAYCHRiEKAACQDeTOnVv79u0zOgYAZAkKUQAAgGzipZde0ty5c42OAQAPjVVzAQAAsonk5GTNmzdPa9euVdWqVZU3b16r/VOmTDEoGQA8GApRAACAbOLAgQOqUqWKJOm3336z2mcymYyIBACZwqq5AAAAAAC7Yo4oAABANnTmzBmdOXPG6BgAkCkUogAAANlEamqq3n77bfn4+CgoKEhBQUHKnz+/3nnnHaWmphodDwDuG3NEAQAAsok333xTc+fO1YQJE1SnTh1J0ubNmzV69GjdunVL48aNMzghANwf5ogCAABkEwEBAZo9e7aaN29u1f7ll1+qZ8+eOnv2rEHJAODBMDQXAAAgm7h69arKlCmTpr1MmTK6evWqAYkAIHMoRAEAALKJihUraubMmWnaZ86cqYoVKxqQCAAyh6G5AAAA2cSmTZv09NNPq0SJEqpVq5YkaevWrYqNjdX333+vxx9/3OCEAHB/KEQBAACykbNnz2rWrFk6ePCgJKls2bLq2bOnAgICDE4GAPePQhQAACAbuXXrlvbt26eLFy+muWTLPxcxAgBHxeVbAAAAsonVq1erQ4cOunLliv7Zl2AymZSSkmJQMgB4MCxWBAAAkE306dNHzz//vH7//XelpqZabRShALIThuYCAABkE97e3oqOjlapUqWMjgIAD4UeUQAAgGziueee08aNG42OAQAPjR5RAACAbCIhIUHPP/+8ChcurIiICOXOndtqf9++fQ1KBgAPhkIUAAAgm5g7d6569Oghd3d3FSxYUCaTybLPZDLp+PHjBqYDgPtHIQoAAJBNFClSRH379tWwYcPk4sIMKwDZF3/BAAAAsonExES1adOGIhRAtsdfMQAAgGyiY8eOWr58udExAOCh5TI6AAAAAO5PSkqKJk2apDVr1qhChQppFiuaMmWKQckA4MEwRxQAACCbqFevXob7TCaT1q9fb8c0AJB5FKIAAAAAALtijigAAAAAwK4oRAEAAAAAdkUhCgAAAACwKwpRAAAAAIBdUYgCAGBHnTp1UsuWLS2369atq/79+9s9x8aNG2UymXTt2rUMjzGZTFq1atV9P+bo0aNVqVKlh8p18uRJmUwm7d2796EeBwDg2ChEAQA5XqdOnWQymWQymeTm5qbQ0FC9/fbbSk5Otvlzf/7553rnnXfu69j7KR4BAMgOchkdAAAAR9CkSRPNnz9ft2/f1nfffadevXopd+7cGj58eJpjExMT5ebmliXPW6BAgSx5HAAAshN6RAEAkJQnTx4VKVJEQUFBeu2119SgQQN99dVXkv43nHbcuHEKCAhQ6dKlJUmnT5/WCy+8oPz586tAgQJq0aKFTp48aXnMlJQUDRw4UPnz51fBggX1+uuv65+X7/7n0Nzbt29r6NChCgwMVJ48eRQaGqq5c+fq5MmTqlevniTJ19dXJpNJnTp1kiSlpqYqMjJSISEh8vDwUMWKFfXZZ59ZPc93332nRx55RB4eHqpXr55Vzvs1dOhQPfLII/L09FTJkiU1YsQIJSUlpTnuww8/VGBgoDw9PfXCCy/o+vXrVvvnzJmjsmXLyt3dXWXKlNF///vfB84CAMjeKEQBAEiHh4eHEhMTLbfXrVunw4cP68cff9Q333yjpKQkNW7cWF5eXvr5558VFRWlfPnyqUmTJpb7TZ48WQsWLNC8efO0efNmXb16VV988cU9n7dDhw765JNPNGPGDB08eFAffvih8uXLp8DAQK1cuVKSdPjwYZ07d07Tp0+XJEVGRmrRokWaPXu2fvnlFw0YMEAvvfSSNm3aJOlOwdy6dWs988wz2rt3r1599VUNGzbsgf9NvLy8tGDBAv3666+aPn26Pv74Y02dOtXqmKNHj2rFihX6+uuvtXr1akVHR6tnz56W/UuWLNHIkSM1btw4HTx4UOPHj9eIESO0cOHCB84DAMjGzAAA5HAdO3Y0t2jRwmw2m82pqanmH3/80ZwnTx7z4MGDLfv9/f3Nt2/fttxn8eLF5tKlS5tTU1Mtbbdv3zZ7eHiY16xZYzabzeaiRYuaJ02aZNmflJRkLl68uOW5zGaz+cknnzT369fPbDabzYcPHzZLMv/444/p5tywYYNZkvmPP/6wtN26dcvs6elp3rJli9WxXbp0Mb/44otms9lsHj58uDk8PNxq/9ChQ9M81j9JMn/xxRcZ7n/33XfNVatWtdweNWqU2dXV1XzmzBlL2/fff292cXExnzt3zmw2m82lSpUyL1261Opx3nnnHXOtWrXMZrPZfOLECbMkc3R0dIbPCwDI/pgjCgCApG+++Ub58uVTUlKSUlNT1a5dO40ePdqyPyIiwmpeaExMjI4ePSovLy+rx7l165aOHTum69ev69y5c6pZs6ZlX65cuVStWrU0w3Pv2rt3r1xdXfXkk0/ed+6jR48qISFBDRs2tGpPTExU5cqVJUkHDx60yiFJtWrVuu/nuGv58uWaMWOGjh07pvj4eCUnJ8vb29vqmBIlSqhYsWJWz5OamqrDhw/Ly8tLx44dU5cuXdS1a1fLMcnJyfLx8XngPACA7ItCFAAASfXq1dOsWbPk5uamgIAA5cpl/V9k3rx5rW7Hx8eratWqWrJkSZrHKly4cKYyeHh4PPB94uPjJUnffvutVQEo3Zn3mlW2bt2q9u3ba8yYMWrcuLF8fHy0bNkyTZ48+YGzfvzxx2kKY1dX1yzLCgBwfBSiAADoTqEZGhp638dXqVJFy5cvl5+fX5pewbuKFi2q7du364knnpB0p+dv9+7dqlKlSrrHR0REKDU1VZs2bVKDBg3S7L/bI5uSkmJpCw8PV548eRQbG5thT2rZsmUtCy/dtW3btn9/kX+zZcsWBQUF6c0337S0nTp1Ks1xsbGx+v333xUQEGB5HhcXF5UuXVr+/v4KCAjQ8ePH1b59+wd6fgCAc2GxIgAAMqF9+/YqVKiQWrRooZ9//lknTpzQxo0b1bdvX505c0aS1K9fP02YMEGrVq3SoUOH1LNnz3teAzQ4OFgdO3bUK6+8olWrVlkec8WKFZKkoKAgmUwmffPNN7p06ZLi4+Pl5eWlwYMHa8CAAVq4cKGOHTumPXv26P3337csANSjRw8dOXJEQ4YM0eHDh7V06VItWLDggV5vWFiYYmNjtWzZMh07dkwzZsxId+Eld3d3dezYUTExMfr555/Vt29fvfDCCypSpIgkacyYMYqMjNSMGTP022+/af/+/Zo/f76mTJnyQHkAANkbhSgAAJng6empn376SSVKlFDr1q1VtmxZdenSRbdu3bL0kA4aNEgvv/yyOnbsqFq1asnLy0utWrW65+POmjVLzz33nHr27KkyZcqoa9euunnzpiSpWLFiGjNmjIYNGyZ/f3/17t1bkvTOO+9oxIgRioyMVNmyZdWkSRN9++23CgkJkXRn3ubKlSu1atUqVaxYUbNnz9b48eMf6PU2b95cAwYMUO/evVWpUiVt2bJFI0aMSHNcaGioWrdurWbNmqlRo0aqUKGC1eVZXn31Vc2ZM0fz589XRESEnnzySS1YsMCSFQCQM5jMGa2YAAAAAACADdAjCgAAAACwKwpRAAAAAIBdUYgCAAAAAOyKQhQAAAAAYFcUogAAAAAAu6IQBQAAAADYFYUoAAAAAMCuKEQBAAAAAHZFIQoAAAAAsCsKUQAAAACAXVGIAgAAAADs6v8BFrC2y7MvUsQAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 1000x1000 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plotting the normalized confusion matrix\n",
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)\n",
+    "plt.title(\"Normalized Confusion Matrix\")\n",
+    "plt.colorbar()\n",
+    "\n",
+    "# Set tick marks and labels\n",
+    "tick_marks = np.arange(len(class_names))\n",
+    "plt.xticks(tick_marks, class_names, rotation=90)\n",
+    "plt.yticks(tick_marks, class_names)\n",
+    "\n",
+    "# Add text annotations to each cell\n",
+    "for i in range(len(class_names)):\n",
+    "    for j in range(len(class_names)):\n",
+    "        plt.text(j, i, format(cm[i, j], \".2f\"), ha=\"center\", va=\"center\", color=\"white\" if cm[i, j] > 0.5 else \"black\")\n",
+    "\n",
+    "plt.ylabel('True label')\n",
+    "plt.xlabel('Predicted label')\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0efafbf6-5c41-4415-bcf8-9c1ea430e067",
+   "metadata": {},
+   "outputs": [],
+   "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.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Consumer Complaint Dataset/complaints_processed.zip b/Consumer Complaint Dataset/complaints_processed.zip
new file mode 100644
index 000000000..637a2e6ce
Binary files /dev/null and b/Consumer Complaint Dataset/complaints_processed.zip differ