code/Georgios_Ioannou/Build_And_Train_CNN_Model.ipynb

{"cells":[{"cell_type":"markdown","metadata":{"execution":{"iopub.execute_input":"2023-12-19T19:14:05.337029Z","iopub.status.busy":"2023-12-19T19:14:05.336669Z","iopub.status.idle":"2023-12-19T19:14:05.344332Z","shell.execute_reply":"2023-12-19T19:14:05.343436Z","shell.execute_reply.started":"2023-12-19T19:14:05.336995Z"}},"source":["---\n","\n","# Georgios_Ioannou\n"]},{"cell_type":"markdown","metadata":{},"source":["## Copyright © 2023 by Georgios Ioannou\n"]},{"cell_type":"markdown","metadata":{},"source":["---\n","\n","<h1 align=\"center\"> Text Emotion System Sentiment Analysis </h1>\n","<h2 align=\"center\"> TESSA </h2>\n","\n","In this notebook, we will be classifying emotion based on text documents. The dataset we will be using is called:\n","\n","<p style=\"text-align: center;\"><a href=\"https://www.kaggle.com/datasets/praveengovi/emotions-dataset-for-nlp\">Emotions Dataset for NLP</a></p>\n"]},{"cell_type":"markdown","metadata":{},"source":["---\n","\n","<h2 align=\"center\"> Remember our main steps motto \"ISBE\" </h2>\n","\n","<h3 align=\"center\"> Main Steps when building a Machine Learning Model </h3>\n","\n","1. **I** - `Inspect and explore data`\n","2. **S** - `Select and engineer features`\n","3. **B** - `Build and train model`\n","4. **E** - `Evaluate model`\n"]},{"cell_type":"markdown","metadata":{},"source":["---\n","\n","<h2 align='center'> GPU Information </h2>\n"]},{"cell_type":"code","execution_count":1,"metadata":{"execution":{"iopub.execute_input":"2023-12-20T08:15:27.660014Z","iopub.status.busy":"2023-12-20T08:15:27.659641Z","iopub.status.idle":"2023-12-20T08:15:28.644849Z","shell.execute_reply":"2023-12-20T08:15:28.643753Z","shell.execute_reply.started":"2023-12-20T08:15:27.659979Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Wed Dec 20 08:15:28 2023       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 470.161.03   Driver Version: 470.161.03   CUDA Version: 11.4     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   35C    P0    27W / 250W |      0MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}],"source":["!nvidia-smi\n"]},{"cell_type":"markdown","metadata":{},"source":["---\n","\n","<h2 align='center'> Libraries </h2>\n"]},{"cell_type":"code","execution_count":2,"metadata":{"execution":{"iopub.execute_input":"2023-12-20T08:15:28.647602Z","iopub.status.busy":"2023-12-20T08:15:28.647274Z","iopub.status.idle":"2023-12-20T08:15:34.349236Z","shell.execute_reply":"2023-12-20T08:15:34.348325Z","shell.execute_reply.started":"2023-12-20T08:15:28.647575Z"},"trusted":true},"outputs":[{"name":"stderr","output_type":"stream","text":["/opt/conda/lib/python3.10/site-packages/scipy/__init__.py:146: UserWarning: A NumPy version >=1.16.5 and <1.23.0 is required for this version of SciPy (detected version 1.24.3\n","  warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion}\"\n"]},{"name":"stdout","output_type":"stream","text":["[nltk_data] Downloading package wordnet to /kaggle/working/...\n","Archive:  /kaggle/working/corpora/wordnet.zip\n","   creating: /kaggle/working/corpora/wordnet/\n","  inflating: /kaggle/working/corpora/wordnet/lexnames  \n","  inflating: /kaggle/working/corpora/wordnet/data.verb  \n","  inflating: /kaggle/working/corpora/wordnet/index.adv  \n","  inflating: /kaggle/working/corpora/wordnet/adv.exc  \n","  inflating: /kaggle/working/corpora/wordnet/index.verb  \n","  inflating: /kaggle/working/corpora/wordnet/cntlist.rev  \n","  inflating: /kaggle/working/corpora/wordnet/data.adj  \n","  inflating: /kaggle/working/corpora/wordnet/index.adj  \n","  inflating: /kaggle/working/corpora/wordnet/LICENSE  \n","  inflating: /kaggle/working/corpora/wordnet/citation.bib  \n","  inflating: /kaggle/working/corpora/wordnet/noun.exc  \n","  inflating: /kaggle/working/corpora/wordnet/verb.exc  \n","  inflating: /kaggle/working/corpora/wordnet/README  \n","  inflating: /kaggle/working/corpora/wordnet/index.sense  \n","  inflating: /kaggle/working/corpora/wordnet/data.noun  \n","  inflating: /kaggle/working/corpora/wordnet/data.adv  \n","  inflating: /kaggle/working/corpora/wordnet/index.noun  \n","  inflating: /kaggle/working/corpora/wordnet/adj.exc  \n","[nltk_data] Downloading package stopwords to /usr/share/nltk_data...\n","[nltk_data]   Package stopwords is already up-to-date!\n","[nltk_data] Downloading package wordnet to /usr/share/nltk_data...\n","[nltk_data]   Package wordnet is already up-to-date!\n","[nltk_data] Downloading package omw-1.4 to /usr/share/nltk_data...\n","[nltk_data]   Package omw-1.4 is already up-to-date!\n"]},{"data":{"text/plain":["True"]},"execution_count":2,"metadata":{},"output_type":"execute_result"}],"source":["# Import libraries.\n","\n","# Use inline so our visualizations display in notebook.\n","\n","\n","%matplotlib inline\n","\n","\n","import matplotlib.pyplot as plt   # Data visualization.\n","import nltk                       # Natural Language Processing.\n","import numpy as np                # Data wrangling.\n","import os                         # Manipulate operating system interfaces.\n","import pandas as pd               # Data handling.\n","pd.set_option('display.max_colwidth', None)\n","import pickle                     # Python object serialization.\n","import plotly.express as px       # Data visualization\n","import plotly.graph_objects as go # Data visualization\n","import re                         # Regular expression operations.\n","import seaborn as sns             # Data visualization.\n","import subprocess                 # To download nltk wordnet in Kaggle.\n","sns.set()\n","import warnings                   # Ignore all warnings.\n","warnings.filterwarnings('ignore')\n","\n","\n","from nltk.stem import WordNetLemmatizer # Lemmatize using WordNet's built-in morphy function.\n","from nltk.stem import PorterStemmer     # Remove morphological affixes from words, leaving only the word stem.\n","from nltk.corpus import stopwords       # Remove stopwaords.\n","from nltk import word_tokenize          # Tokenize.\n","from sklearn.feature_extraction.text import CountVectorizer # Convert a collection of text documents to a matrix of token counts.\n","from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, f1_score, multilabel_confusion_matrix, precision_score, recall_score # Evaluation metrics.\n","from sklearn.model_selection import train_test_split     # Eplit data in training/validating/testing.\n","from sklearn.naive_bayes import MultinomialNB            # Multinomial Naive Bayes classifier.\n","from sklearn.preprocessing import LabelEncoder           # Encode target labels with value between 0 and n_classes-1.\n","from tensorflow.keras.callbacks import EarlyStopping     # Stop training when a monitored metric has stopped improving.\n","from tensorflow.keras.callbacks import ReduceLROnPlateau # Reduce learning rate when a metric has stopped improving.\n","from tensorflow.keras.layers import Activation, BatchNormalization, Bidirectional, Concatenate, Conv1D, Dense, Dropout, Embedding, GlobalMaxPooling1D, LSTM, MaxPooling1D, ReLU # Keras layers API.\n","from tensorflow.keras.models import Model, Sequential # Model achitecture.\n","from tensorflow.keras.optimizers import Adam         # Adam optimizer.\n","from tensorflow.keras.preprocessing.sequence import pad_sequences # Transformsa list of sequences into a 2D Numpy array.\n","from tensorflow.keras.preprocessing.text import Tokenizer         # Vectorize a text corpus.\n","from tensorflow.keras.utils import plot_model                     # Visualize the model and save it.\n","from tensorflow.keras.utils import to_categorical                 # Converts a class vector (integers) to binary class matrix.\n","\n","\n","try:\n","    nltk.data.find('wordnet.zip')\n","except:\n","    nltk.download('wordnet', download_dir='/kaggle/working/')\n","    command = 'unzip /kaggle/working/corpora/wordnet.zip -d /kaggle/working/corpora'\n","    subprocess.run(command.split())\n","    nltk.data.path.append('/kaggle/working/')\n","    \n","\n","from nltk.corpus import wordnet\n","\n","nltk.download('stopwords')\n","nltk.download('wordnet')\n","nltk.download('omw-1.4')\n"]},{"cell_type":"markdown","metadata":{},"source":["---\n","\n","## #3 Build And Train CNN Model\n"]},{"cell_type":"code","execution_count":78,"metadata":{"execution":{"iopub.execute_input":"2023-12-20T08:26:16.599056Z","iopub.status.busy":"2023-12-20T08:26:16.598748Z","iopub.status.idle":"2023-12-20T08:26:16.603940Z","shell.execute_reply":"2023-12-20T08:26:16.602942Z","shell.execute_reply.started":"2023-12-20T08:26:16.599031Z"},"trusted":true},"outputs":[],"source":["# CNN Model Hyperparameters.\n","\n","# Embedding.\n","\n","input_dim = vocabulary_size\n","output_dim = 200\n","\n","# Convolution.\n","\n","kernel_size = 5\n","filters = 64\n","kernel_size = 3"]},{"cell_type":"code","execution_count":79,"metadata":{"execution":{"iopub.execute_input":"2023-12-20T08:26:16.605534Z","iopub.status.busy":"2023-12-20T08:26:16.605169Z","iopub.status.idle":"2023-12-20T08:26:16.793835Z","shell.execute_reply":"2023-12-20T08:26:16.792917Z","shell.execute_reply.started":"2023-12-20T08:26:16.605498Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Model: \"model\"\n","__________________________________________________________________________________________________\n"," Layer (type)                Output Shape                 Param #   Connected to                  \n","==================================================================================================\n"," embedding_2_input (InputLa  [(None, 256)]                0         []                            \n"," yer)                                                                                             \n","                                                                                                  \n"," embedding_3_input (InputLa  [(None, 256)]                0         []                            \n"," yer)                                                                                             \n","                                                                                                  \n"," embedding_2 (Embedding)     (None, 256, 200)             2865200   ['embedding_2_input[0][0]']   \n","                                                                                                  \n"," embedding_3 (Embedding)     (None, 256, 200)             2865200   ['embedding_3_input[0][0]']   \n","                                                                                                  \n"," conv1d_1 (Conv1D)           (None, 256, 64)              38464     ['embedding_2[0][0]']         \n","                                                                                                  \n"," conv1d_2 (Conv1D)           (None, 256, 64)              38464     ['embedding_3[0][0]']         \n","                                                                                                  \n"," batch_normalization (Batch  (None, 256, 64)              256       ['conv1d_1[0][0]']            \n"," Normalization)                                                                                   \n","                                                                                                  \n"," batch_normalization_1 (Bat  (None, 256, 64)              256       ['conv1d_2[0][0]']            \n"," chNormalization)                                                                                 \n","                                                                                                  \n"," re_lu (ReLU)                (None, 256, 64)              0         ['batch_normalization[0][0]'] \n","                                                                                                  \n"," re_lu_1 (ReLU)              (None, 256, 64)              0         ['batch_normalization_1[0][0]'\n","                                                                    ]                             \n","                                                                                                  \n"," dropout_2 (Dropout)         (None, 256, 64)              0         ['re_lu[0][0]']               \n","                                                                                                  \n"," dropout_3 (Dropout)         (None, 256, 64)              0         ['re_lu_1[0][0]']             \n","                                                                                                  \n"," global_max_pooling1d (Glob  (None, 64)                   0         ['dropout_2[0][0]']           \n"," alMaxPooling1D)                                                                                  \n","                                                                                                  \n"," global_max_pooling1d_1 (Gl  (None, 64)                   0         ['dropout_3[0][0]']           \n"," obalMaxPooling1D)                                                                                \n","                                                                                                  \n"," concatenate (Concatenate)   (None, 128)                  0         ['global_max_pooling1d[0][0]',\n","                                                                     'global_max_pooling1d_1[0][0]\n","                                                                    ']                            \n","                                                                                                  \n"," dense_2 (Dense)             (None, 128)                  16512     ['concatenate[0][0]']         \n","                                                                                                  \n"," dropout_4 (Dropout)         (None, 128)                  0         ['dense_2[0][0]']             \n","                                                                                                  \n"," dense_3 (Dense)             (None, 6)                    774       ['dropout_4[0][0]']           \n","                                                                                                  \n","==================================================================================================\n","Total params: 5825126 (22.22 MB)\n","Trainable params: 5824870 (22.22 MB)\n","Non-trainable params: 256 (1.00 KB)\n","__________________________________________________________________________________________________\n"]}],"source":["# Create the neural network.\n","\n","model1 = Sequential()\n","\n","# X_train.shape[1] = 256\n","model1.add(Embedding(input_dim, output_dim, input_length=X_train.shape[1]))\n","\n","model1.add(Conv1D(filters, kernel_size, padding=\"same\", activation=\"relu\"))\n","\n","model1.add(BatchNormalization())\n","\n","model1.add(ReLU())\n","\n","model1.add(Dropout(0.5))\n","\n","model1.add(GlobalMaxPooling1D())\n","\n","model2 = Sequential()\n","\n","model2.add(Embedding(input_dim, output_dim, input_length=X_train.shape[1]))\n","\n","model2.add(Conv1D(filters, kernel_size, padding=\"same\", activation=\"relu\"))\n","\n","model2.add(BatchNormalization())\n","\n","model2.add(ReLU())\n","\n","model2.add(Dropout(0.5))\n","\n","model2.add(GlobalMaxPooling1D())\n","\n","\n","concatenated = Concatenate()([model1.output, model2.output])\n","\n","hid_layer = Dense(128, activation=\"relu\")(concatenated)\n","\n","dropout = Dropout(0.5)(hid_layer)\n","\n","output_layer = Dense(6, activation=\"softmax\")(dropout)\n","\n","model = Model(inputs=[model1.input, model2.input], outputs=output_layer)\n","\n","model.summary()"]},{"cell_type":"code","execution_count":80,"metadata":{"execution":{"iopub.execute_input":"2023-12-20T08:26:16.795801Z","iopub.status.busy":"2023-12-20T08:26:16.795302Z","iopub.status.idle":"2023-12-20T08:26:16.996040Z","shell.execute_reply":"2023-12-20T08:26:16.995115Z","shell.execute_reply.started":"2023-12-20T08:26:16.795765Z"},"trusted":true},"outputs":[{"data":{"image/png":"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","text/plain":["<IPython.core.display.Image object>"]},"execution_count":80,"metadata":{},"output_type":"execute_result"}],"source":["plot_model(model, to_file=\"tessa_cnn_model.png\", show_shapes=True, show_dtype=True)"]},{"cell_type":"code","execution_count":81,"metadata":{"execution":{"iopub.execute_input":"2023-12-20T08:26:16.997636Z","iopub.status.busy":"2023-12-20T08:26:16.997305Z","iopub.status.idle":"2023-12-20T08:26:17.011850Z","shell.execute_reply":"2023-12-20T08:26:17.010989Z","shell.execute_reply.started":"2023-12-20T08:26:16.997605Z"},"trusted":true},"outputs":[],"source":["# Compile the model.\n","\n","model.compile(loss=\"categorical_crossentropy\", optimizer=\"adamax\", metrics=[\"accuracy\"])"]},{"cell_type":"code","execution_count":82,"metadata":{"execution":{"iopub.execute_input":"2023-12-20T08:26:17.023965Z","iopub.status.busy":"2023-12-20T08:26:17.023703Z","iopub.status.idle":"2023-12-20T08:29:03.398140Z","shell.execute_reply":"2023-12-20T08:29:03.397284Z","shell.execute_reply.started":"2023-12-20T08:26:17.023943Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Epoch 1/100\n","125/125 [==============================] - 34s 246ms/step - loss: 1.8218 - accuracy: 0.3157 - val_loss: 1.7550 - val_accuracy: 0.3489 - lr: 0.0010\n","Epoch 2/100\n","125/125 [==============================] - 12s 100ms/step - loss: 1.4742 - accuracy: 0.4173 - val_loss: 1.7166 - val_accuracy: 0.4491 - lr: 0.0010\n","Epoch 3/100\n","125/125 [==============================] - 10s 79ms/step - loss: 1.1949 - accuracy: 0.5494 - val_loss: 1.5526 - val_accuracy: 0.7228 - lr: 0.0010\n","Epoch 4/100\n","125/125 [==============================] - 5s 38ms/step - loss: 0.8035 - accuracy: 0.7090 - val_loss: 1.0935 - val_accuracy: 0.8426 - lr: 0.0010\n","Epoch 5/100\n","125/125 [==============================] - 6s 43ms/step - loss: 0.5121 - accuracy: 0.8186 - val_loss: 0.5975 - val_accuracy: 0.8837 - lr: 0.0010\n","Epoch 6/100\n","125/125 [==============================] - 5s 40ms/step - loss: 0.3512 - accuracy: 0.8810 - val_loss: 0.3515 - val_accuracy: 0.9038 - lr: 0.0010\n","Epoch 7/100\n","125/125 [==============================] - 3s 27ms/step - loss: 0.2613 - accuracy: 0.9125 - val_loss: 0.2569 - val_accuracy: 0.9123 - lr: 0.0010\n","Epoch 8/100\n","125/125 [==============================] - 4s 35ms/step - loss: 0.2107 - accuracy: 0.9296 - val_loss: 0.2266 - val_accuracy: 0.9158 - lr: 0.0010\n","Epoch 9/100\n","125/125 [==============================] - 4s 29ms/step - loss: 0.1716 - accuracy: 0.9413 - val_loss: 0.2115 - val_accuracy: 0.9148 - lr: 0.0010\n","Epoch 10/100\n","125/125 [==============================] - 4s 30ms/step - loss: 0.1457 - accuracy: 0.9526 - val_loss: 0.2046 - val_accuracy: 0.9178 - lr: 0.0010\n","Epoch 11/100\n","125/125 [==============================] - 3s 27ms/step - loss: 0.1298 - accuracy: 0.9562 - val_loss: 0.1997 - val_accuracy: 0.9213 - lr: 0.0010\n","Epoch 12/100\n","125/125 [==============================] - 3s 26ms/step - loss: 0.1067 - accuracy: 0.9651 - val_loss: 0.1931 - val_accuracy: 0.9198 - lr: 0.0010\n","Epoch 13/100\n","125/125 [==============================] - 3s 24ms/step - loss: 0.1014 - accuracy: 0.9658 - val_loss: 0.1914 - val_accuracy: 0.9213 - lr: 0.0010\n","Epoch 14/100\n","125/125 [==============================] - 3s 26ms/step - loss: 0.0824 - accuracy: 0.9724 - val_loss: 0.1946 - val_accuracy: 0.9188 - lr: 0.0010\n","Epoch 15/100\n","125/125 [==============================] - 3s 24ms/step - loss: 0.0779 - accuracy: 0.9738 - val_loss: 0.1909 - val_accuracy: 0.9263 - lr: 0.0010\n","Epoch 16/100\n","125/125 [==============================] - 3s 24ms/step - loss: 0.0674 - accuracy: 0.9771 - val_loss: 0.1904 - val_accuracy: 0.9243 - lr: 0.0010\n","Epoch 17/100\n","125/125 [==============================] - 3s 24ms/step - loss: 0.0591 - accuracy: 0.9796 - val_loss: 0.1905 - val_accuracy: 0.9258 - lr: 0.0010\n","Epoch 18/100\n","125/125 [==============================] - 2s 18ms/step - loss: 0.0550 - accuracy: 0.9809 - val_loss: 0.2021 - val_accuracy: 0.9223 - lr: 0.0010\n","Epoch 19/100\n","125/125 [==============================] - 3s 24ms/step - loss: 0.0496 - accuracy: 0.9836 - val_loss: 0.2010 - val_accuracy: 0.9238 - lr: 0.0010\n","Epoch 20/100\n","125/125 [==============================] - 2s 15ms/step - loss: 0.0485 - accuracy: 0.9841 - val_loss: 0.2068 - val_accuracy: 0.9258 - lr: 0.0010\n","Epoch 21/100\n","125/125 [==============================] - 2s 18ms/step - loss: 0.0427 - accuracy: 0.9864 - val_loss: 0.2018 - val_accuracy: 0.9288 - lr: 0.0010\n","Epoch 22/100\n","125/125 [==============================] - 2s 19ms/step - loss: 0.0426 - accuracy: 0.9864 - val_loss: 0.2074 - val_accuracy: 0.9268 - lr: 0.0010\n","Epoch 23/100\n","125/125 [==============================] - 3s 21ms/step - loss: 0.0394 - accuracy: 0.9868 - val_loss: 0.2104 - val_accuracy: 0.9243 - lr: 0.0010\n","Epoch 24/100\n","125/125 [==============================] - 3s 21ms/step - loss: 0.0345 - accuracy: 0.9876 - val_loss: 0.2064 - val_accuracy: 0.9283 - lr: 0.0010\n","Epoch 25/100\n","125/125 [==============================] - 3s 21ms/step - loss: 0.0317 - accuracy: 0.9893 - val_loss: 0.2069 - val_accuracy: 0.9263 - lr: 0.0010\n","Epoch 26/100\n","125/125 [==============================] - 3s 21ms/step - loss: 0.0306 - accuracy: 0.9895 - val_loss: 0.2066 - val_accuracy: 0.9273 - lr: 0.0010\n","Epoch 27/100\n","125/125 [==============================] - 3s 21ms/step - loss: 0.0292 - accuracy: 0.9898 - val_loss: 0.2093 - val_accuracy: 0.9263 - lr: 0.0010\n","Epoch 28/100\n","125/125 [==============================] - 3s 24ms/step - loss: 0.0229 - accuracy: 0.9927 - val_loss: 0.2106 - val_accuracy: 0.9293 - lr: 0.0010\n","Epoch 29/100\n","125/125 [==============================] - 2s 18ms/step - loss: 0.0235 - accuracy: 0.9921 - val_loss: 0.2187 - val_accuracy: 0.9268 - lr: 0.0010\n","Epoch 30/100\n","125/125 [==============================] - 2s 18ms/step - loss: 0.0255 - accuracy: 0.9909 - val_loss: 0.2182 - val_accuracy: 0.9288 - lr: 0.0010\n","Epoch 31/100\n","125/125 [==============================] - 2s 18ms/step - loss: 0.0237 - accuracy: 0.9920 - val_loss: 0.2207 - val_accuracy: 0.9313 - lr: 0.0010\n","Epoch 32/100\n","125/125 [==============================] - 2s 18ms/step - loss: 0.0191 - accuracy: 0.9935 - val_loss: 0.2239 - val_accuracy: 0.9273 - lr: 0.0010\n","Epoch 33/100\n","125/125 [==============================] - 2s 18ms/step - loss: 0.0209 - accuracy: 0.9931 - val_loss: 0.2277 - val_accuracy: 0.9253 - lr: 0.0010\n","Epoch 34/100\n","125/125 [==============================] - 2s 15ms/step - loss: 0.0185 - accuracy: 0.9933 - val_loss: 0.2234 - val_accuracy: 0.9298 - lr: 0.0010\n","Epoch 35/100\n","125/125 [==============================] - 3s 21ms/step - loss: 0.0183 - accuracy: 0.9939 - val_loss: 0.2268 - val_accuracy: 0.9288 - lr: 0.0010\n","Epoch 36/100\n","125/125 [==============================] - 3s 21ms/step - loss: 0.0181 - accuracy: 0.9945 - val_loss: 0.2370 - val_accuracy: 0.9268 - lr: 0.0010\n","Epoch 37/100\n","125/125 [==============================] - 2s 18ms/step - loss: 0.0163 - accuracy: 0.9944 - val_loss: 0.2357 - val_accuracy: 0.9273 - lr: 0.0010\n","Epoch 38/100\n","125/125 [==============================] - 2s 18ms/step - loss: 0.0174 - accuracy: 0.9949 - val_loss: 0.2384 - val_accuracy: 0.9258 - lr: 0.0010\n","Epoch 39/100\n","125/125 [==============================] - 2s 18ms/step - loss: 0.0170 - accuracy: 0.9940 - val_loss: 0.2397 - val_accuracy: 0.9303 - lr: 0.0010\n","Epoch 40/100\n","125/125 [==============================] - 3s 24ms/step - loss: 0.0151 - accuracy: 0.9950 - val_loss: 0.2393 - val_accuracy: 0.9273 - lr: 0.0010\n","Epoch 41/100\n","123/125 [============================>.] - ETA: 0s - loss: 0.0163 - accuracy: 0.9950\n","Epoch 41: ReduceLROnPlateau reducing learning rate to 0.0005000000237487257.\n","125/125 [==============================] - 2s 18ms/step - loss: 0.0161 - accuracy: 0.9951 - val_loss: 0.2416 - val_accuracy: 0.9248 - lr: 0.0010\n"]}],"source":["# Fit the model.\n","\n","history_callback_object = model.fit(\n","    x=[X_train, X_train],\n","    y=y_train,\n","    batch_size=128,\n","    epochs=100,\n","    callbacks=[early_stopping, reduce_learning_rate],\n","    validation_data=([X_valid, X_valid], y_valid),\n",")"]},{"cell_type":"code","execution_count":83,"metadata":{"execution":{"iopub.execute_input":"2023-12-20T08:29:03.399530Z","iopub.status.busy":"2023-12-20T08:29:03.399258Z","iopub.status.idle":"2023-12-20T08:29:03.474226Z","shell.execute_reply":"2023-12-20T08:29:03.473347Z","shell.execute_reply.started":"2023-12-20T08:29:03.399505Z"},"trusted":true},"outputs":[{"data":{"text/html":["<div>                            <div id=\"c4724154-60ce-4ad4-ad91-e8947cedf54b\" class=\"plotly-graph-div\" style=\"height:525px; width:100%;\"></div>            <script type=\"text/javascript\">                require([\"plotly\"], function(Plotly) {                    window.PLOTLYENV=window.PLOTLYENV || {};                                    if (document.getElementById(\"c4724154-60ce-4ad4-ad91-e8947cedf54b\")) {                    Plotly.newPlot(                        \"c4724154-60ce-4ad4-ad91-e8947cedf54b\",                        [{\"hovertemplate\":\"variable=loss\\u003cbr\\u003eEpoch=%{x}\\u003cbr\\u003eLoss=%{y}\\u003cextra\\u003e\\u003c\\u002fextra\\u003e\",\"legendgroup\":\"loss\",\"line\":{\"color\":\"#636efa\",\"dash\":\"solid\"},\"marker\":{\"symbol\":\"circle\"},\"mode\":\"lines\",\"name\":\"loss\",\"orientation\":\"v\",\"showlegend\":true,\"x\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40],\"xaxis\":\"x\",\"y\":[1.8218319416046143,1.4742143154144287,1.1948846578598022,0.8035116791725159,0.5121167898178101,0.3511632978916168,0.26131293177604675,0.2106773406267166,0.17160068452358246,0.14574413001537323,0.12976795434951782,0.10668826848268509,0.10142124444246292,0.08241536468267441,0.0778808519244194,0.06741150468587875,0.05913509428501129,0.054971300065517426,0.049623314291238785,0.04848610609769821,0.042714882642030716,0.04259609058499336,0.039397526532411575,0.03450101241469383,0.031713858246803284,0.03058350458741188,0.029172725975513458,0.022874901071190834,0.023456301540136337,0.025509992614388466,0.0237149465829134,0.019126052036881447,0.020938418805599213,0.01853082701563835,0.018332015722990036,0.01805656962096691,0.016253473237156868,0.01743045262992382,0.016993479803204536,0.015111522749066353,0.016091566532850266],\"yaxis\":\"y\",\"type\":\"scatter\"},{\"hovertemplate\":\"variable=val_loss\\u003cbr\\u003eEpoch=%{x}\\u003cbr\\u003eLoss=%{y}\\u003cextra\\u003e\\u003c\\u002fextra\\u003e\",\"legendgroup\":\"val_loss\",\"line\":{\"color\":\"#EF553B\",\"dash\":\"solid\"},\"marker\":{\"symbol\":\"circle\"},\"mode\":\"lines\",\"name\":\"val_loss\",\"orientation\":\"v\",\"showlegend\":true,\"x\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40],\"xaxis\":\"x\",\"y\":[1.754959225654602,1.7166489362716675,1.5525965690612793,1.0935262441635132,0.5975338220596313,0.3514995574951172,0.2569139301776886,0.22657276690006256,0.2115381807088852,0.20461419224739075,0.19971328973770142,0.1931377798318863,0.1913883239030838,0.19455242156982422,0.19090184569358826,0.19042284786701202,0.19050735235214233,0.20207780599594116,0.2010292410850525,0.20677068829536438,0.2017516791820526,0.20735761523246765,0.2103513777256012,0.20639896392822266,0.20687870681285858,0.20657995343208313,0.20932967960834503,0.210648313164711,0.21869225800037384,0.21824848651885986,0.22071966528892517,0.22394680976867676,0.22771306335926056,0.2234397679567337,0.2267521768808365,0.23704050481319427,0.23567162454128265,0.23843048512935638,0.2397392988204956,0.23932117223739624,0.24157454073429108],\"yaxis\":\"y\",\"type\":\"scatter\"}],                        {\"template\":{\"data\":{\"histogram2dcontour\":[{\"type\":\"histogram2dcontour\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]}],\"choropleth\":[{\"type\":\"choropleth\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}],\"histogram2d\":[{\"type\":\"histogram2d\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]}],\"heatmap\":[{\"type\":\"heatmap\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]}],\"heatmapgl\":[{\"type\":\"heatmapgl\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]}],\"contourcarpet\":[{\"type\":\"contourcarpet\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}],\"contour\":[{\"type\":\"contour\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]}],\"surface\":[{\"type\":\"surface\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]}],\"mesh3d\":[{\"type\":\"mesh3d\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}],\"scatter\":[{\"fillpattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2},\"type\":\"scatter\"}],\"parcoords\":[{\"type\":\"parcoords\",\"line\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"scatterpolargl\":[{\"type\":\"scatterpolargl\",\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"bar\":[{\"error_x\":{\"color\":\"#2a3f5f\"},\"error_y\":{\"color\":\"#2a3f5f\"},\"marker\":{\"line\":{\"color\":\"#E5ECF6\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"bar\"}],\"scattergeo\":[{\"type\":\"scattergeo\",\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"scatterpolar\":[{\"type\":\"scatterpolar\",\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"histogram\":[{\"marker\":{\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"histogram\"}],\"scattergl\":[{\"type\":\"scattergl\",\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"scatter3d\":[{\"type\":\"scatter3d\",\"line\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"scattermapbox\":[{\"type\":\"scattermapbox\",\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"scatterternary\":[{\"type\":\"scatterternary\",\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"scattercarpet\":[{\"type\":\"scattercarpet\",\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"carpet\":[{\"aaxis\":{\"endlinecolor\":\"#2a3f5f\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"minorgridcolor\":\"white\",\"startlinecolor\":\"#2a3f5f\"},\"baxis\":{\"endlinecolor\":\"#2a3f5f\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"minorgridcolor\":\"white\",\"startlinecolor\":\"#2a3f5f\"},\"type\":\"carpet\"}],\"table\":[{\"cells\":{\"fill\":{\"color\":\"#EBF0F8\"},\"line\":{\"color\":\"white\"}},\"header\":{\"fill\":{\"color\":\"#C8D4E3\"},\"line\":{\"color\":\"white\"}},\"type\":\"table\"}],\"barpolar\":[{\"marker\":{\"line\":{\"color\":\"#E5ECF6\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"barpolar\"}],\"pie\":[{\"automargin\":true,\"type\":\"pie\"}]},\"layout\":{\"autotypenumbers\":\"strict\",\"colorway\":[\"#636efa\",\"#EF553B\",\"#00cc96\",\"#ab63fa\",\"#FFA15A\",\"#19d3f3\",\"#FF6692\",\"#B6E880\",\"#FF97FF\",\"#FECB52\"],\"font\":{\"color\":\"#2a3f5f\"},\"hovermode\":\"closest\",\"hoverlabel\":{\"align\":\"left\"},\"paper_bgcolor\":\"white\",\"plot_bgcolor\":\"#E5ECF6\",\"polar\":{\"bgcolor\":\"#E5ECF6\",\"angularaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"},\"radialaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"}},\"ternary\":{\"bgcolor\":\"#E5ECF6\",\"aaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"},\"baxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"},\"caxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"}},\"coloraxis\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"colorscale\":{\"sequential\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"sequentialminus\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"diverging\":[[0,\"#8e0152\"],[0.1,\"#c51b7d\"],[0.2,\"#de77ae\"],[0.3,\"#f1b6da\"],[0.4,\"#fde0ef\"],[0.5,\"#f7f7f7\"],[0.6,\"#e6f5d0\"],[0.7,\"#b8e186\"],[0.8,\"#7fbc41\"],[0.9,\"#4d9221\"],[1,\"#276419\"]]},\"xaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"white\",\"automargin\":true,\"zerolinewidth\":2},\"yaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"white\",\"automargin\":true,\"zerolinewidth\":2},\"scene\":{\"xaxis\":{\"backgroundcolor\":\"#E5ECF6\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"white\",\"gridwidth\":2},\"yaxis\":{\"backgroundcolor\":\"#E5ECF6\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"white\",\"gridwidth\":2},\"zaxis\":{\"backgroundcolor\":\"#E5ECF6\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"white\",\"gridwidth\":2}},\"shapedefaults\":{\"line\":{\"color\":\"#2a3f5f\"}},\"annotationdefaults\":{\"arrowcolor\":\"#2a3f5f\",\"arrowhead\":0,\"arrowwidth\":1},\"geo\":{\"bgcolor\":\"white\",\"landcolor\":\"#E5ECF6\",\"subunitcolor\":\"white\",\"showland\":true,\"showlakes\":true,\"lakecolor\":\"white\"},\"title\":{\"x\":0.05},\"mapbox\":{\"style\":\"light\"}}},\"xaxis\":{\"anchor\":\"y\",\"domain\":[0.0,1.0],\"title\":{\"text\":\"Epoch\"}},\"yaxis\":{\"anchor\":\"x\",\"domain\":[0.0,1.0],\"title\":{\"text\":\"Loss\"}},\"legend\":{\"title\":{\"text\":\"variable\"},\"tracegroupgap\":0},\"title\":{\"text\":\"Loss vs Epoch\"}},                        {\"responsive\": true}                    ).then(function(){\n","                            \n","var gd = document.getElementById('c4724154-60ce-4ad4-ad91-e8947cedf54b');\n","var x = new MutationObserver(function (mutations, observer) {{\n","        var display = window.getComputedStyle(gd).display;\n","        if (!display || display === 'none') {{\n","            console.log([gd, 'removed!']);\n","            Plotly.purge(gd);\n","            observer.disconnect();\n","        }}\n","}});\n","\n","// Listen for the removal of the full notebook cells\n","var notebookContainer = gd.closest('#notebook-container');\n","if (notebookContainer) {{\n","    x.observe(notebookContainer, {childList: true});\n","}}\n","\n","// Listen for the clearing of the current output cell\n","var outputEl = gd.closest('.output');\n","if (outputEl) {{\n","    x.observe(outputEl, {childList: true});\n","}}\n","\n","                        })                };                });            </script>        </div>"]},"metadata":{},"output_type":"display_data"},{"data":{"text/plain":["dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy', 'lr'])"]},"execution_count":83,"metadata":{},"output_type":"execute_result"}],"source":["# Loss graph.\n","\n","fig = px.line(\n","    data_frame=history_callback_object.history,\n","    y=[\"loss\", \"val_loss\"],\n","    labels={\"index\": \"Epoch\", \"value\": \"Loss\"},\n","    title=\"Loss vs Epoch\",\n",")\n","fig.show()\n","\n","history_callback_object.history.keys()"]},{"cell_type":"code","execution_count":84,"metadata":{"execution":{"iopub.execute_input":"2023-12-20T08:29:03.475642Z","iopub.status.busy":"2023-12-20T08:29:03.475366Z","iopub.status.idle":"2023-12-20T08:29:03.545005Z","shell.execute_reply":"2023-12-20T08:29:03.544130Z","shell.execute_reply.started":"2023-12-20T08:29:03.475618Z"},"trusted":true},"outputs":[{"data":{"text/html":["<div>                            <div id=\"82bcd4a3-5ca0-45cd-97f3-b797c1aff0aa\" class=\"plotly-graph-div\" style=\"height:525px; width:100%;\"></div>            <script type=\"text/javascript\">                require([\"plotly\"], function(Plotly) {                    window.PLOTLYENV=window.PLOTLYENV || {};                                    if (document.getElementById(\"82bcd4a3-5ca0-45cd-97f3-b797c1aff0aa\")) {                    Plotly.newPlot(                        \"82bcd4a3-5ca0-45cd-97f3-b797c1aff0aa\",                        [{\"hovertemplate\":\"variable=accuracy\\u003cbr\\u003eEpoch=%{x}\\u003cbr\\u003eAccuracy=%{y}\\u003cextra\\u003e\\u003c\\u002fextra\\u003e\",\"legendgroup\":\"accuracy\",\"line\":{\"color\":\"#636efa\",\"dash\":\"solid\"},\"marker\":{\"symbol\":\"circle\"},\"mode\":\"lines\",\"name\":\"accuracy\",\"orientation\":\"v\",\"showlegend\":true,\"x\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40],\"xaxis\":\"x\",\"y\":[0.31570371985435486,0.4172828793525696,0.5493796467781067,0.7089861035346985,0.8185862898826599,0.8810001015663147,0.9124577045440674,0.9295651316642761,0.9413460493087769,0.9525629878044128,0.9561975002288818,0.9650958776473999,0.9657852053642273,0.9723649621009827,0.9738062620162964,0.9770647883415222,0.9795714020729065,0.9808873534202576,0.9836445450782776,0.9840832352638245,0.9864017963409424,0.9864017963409424,0.9867777824401855,0.9875924587249756,0.9893470406532288,0.9894723892211914,0.9898483753204346,0.9926682710647583,0.9921042919158936,0.9908509850502014,0.9920415878295898,0.9934828877449036,0.9931069016456604,0.993294894695282,0.9938588738441467,0.9945482015609741,0.9944228529930115,0.9948614835739136,0.9940468668937683,0.9949868321418762,0.9951121807098389],\"yaxis\":\"y\",\"type\":\"scatter\"},{\"hovertemplate\":\"variable=val_accuracy\\u003cbr\\u003eEpoch=%{x}\\u003cbr\\u003eAccuracy=%{y}\\u003cextra\\u003e\\u003c\\u002fextra\\u003e\",\"legendgroup\":\"val_accuracy\",\"line\":{\"color\":\"#EF553B\",\"dash\":\"solid\"},\"marker\":{\"symbol\":\"circle\"},\"mode\":\"lines\",\"name\":\"val_accuracy\",\"orientation\":\"v\",\"showlegend\":true,\"x\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40],\"xaxis\":\"x\",\"y\":[0.34887218475341797,0.449122816324234,0.722806990146637,0.8426065444946289,0.8837092518806458,0.9037594199180603,0.9122806787490845,0.9157894849777222,0.9147869944572449,0.9177944660186768,0.9213032722473145,0.9197995066642761,0.9213032722473145,0.9187970161437988,0.9263157844543457,0.9243108034133911,0.9258145093917847,0.9223057627677917,0.9238095283508301,0.9258145093917847,0.9288220405578613,0.9268170595169067,0.9243108034133911,0.9283208250999451,0.9263157844543457,0.927318274974823,0.9263157844543457,0.9293233156204224,0.9268170595169067,0.9288220405578613,0.931328296661377,0.927318274974823,0.9253132939338684,0.9298245906829834,0.9288220405578613,0.9268170595169067,0.927318274974823,0.9258145093917847,0.9303258061408997,0.927318274974823,0.9248120188713074],\"yaxis\":\"y\",\"type\":\"scatter\"}],                        {\"template\":{\"data\":{\"histogram2dcontour\":[{\"type\":\"histogram2dcontour\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]}],\"choropleth\":[{\"type\":\"choropleth\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}],\"histogram2d\":[{\"type\":\"histogram2d\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]}],\"heatmap\":[{\"type\":\"heatmap\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]}],\"heatmapgl\":[{\"type\":\"heatmapgl\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]}],\"contourcarpet\":[{\"type\":\"contourcarpet\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}],\"contour\":[{\"type\":\"contour\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]}],\"surface\":[{\"type\":\"surface\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"},\"colorscale\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]]}],\"mesh3d\":[{\"type\":\"mesh3d\",\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}],\"scatter\":[{\"fillpattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2},\"type\":\"scatter\"}],\"parcoords\":[{\"type\":\"parcoords\",\"line\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"scatterpolargl\":[{\"type\":\"scatterpolargl\",\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"bar\":[{\"error_x\":{\"color\":\"#2a3f5f\"},\"error_y\":{\"color\":\"#2a3f5f\"},\"marker\":{\"line\":{\"color\":\"#E5ECF6\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"bar\"}],\"scattergeo\":[{\"type\":\"scattergeo\",\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"scatterpolar\":[{\"type\":\"scatterpolar\",\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"histogram\":[{\"marker\":{\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"histogram\"}],\"scattergl\":[{\"type\":\"scattergl\",\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"scatter3d\":[{\"type\":\"scatter3d\",\"line\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"scattermapbox\":[{\"type\":\"scattermapbox\",\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"scatterternary\":[{\"type\":\"scatterternary\",\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"scattercarpet\":[{\"type\":\"scattercarpet\",\"marker\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}}}],\"carpet\":[{\"aaxis\":{\"endlinecolor\":\"#2a3f5f\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"minorgridcolor\":\"white\",\"startlinecolor\":\"#2a3f5f\"},\"baxis\":{\"endlinecolor\":\"#2a3f5f\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"minorgridcolor\":\"white\",\"startlinecolor\":\"#2a3f5f\"},\"type\":\"carpet\"}],\"table\":[{\"cells\":{\"fill\":{\"color\":\"#EBF0F8\"},\"line\":{\"color\":\"white\"}},\"header\":{\"fill\":{\"color\":\"#C8D4E3\"},\"line\":{\"color\":\"white\"}},\"type\":\"table\"}],\"barpolar\":[{\"marker\":{\"line\":{\"color\":\"#E5ECF6\",\"width\":0.5},\"pattern\":{\"fillmode\":\"overlay\",\"size\":10,\"solidity\":0.2}},\"type\":\"barpolar\"}],\"pie\":[{\"automargin\":true,\"type\":\"pie\"}]},\"layout\":{\"autotypenumbers\":\"strict\",\"colorway\":[\"#636efa\",\"#EF553B\",\"#00cc96\",\"#ab63fa\",\"#FFA15A\",\"#19d3f3\",\"#FF6692\",\"#B6E880\",\"#FF97FF\",\"#FECB52\"],\"font\":{\"color\":\"#2a3f5f\"},\"hovermode\":\"closest\",\"hoverlabel\":{\"align\":\"left\"},\"paper_bgcolor\":\"white\",\"plot_bgcolor\":\"#E5ECF6\",\"polar\":{\"bgcolor\":\"#E5ECF6\",\"angularaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"},\"radialaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"}},\"ternary\":{\"bgcolor\":\"#E5ECF6\",\"aaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"},\"baxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"},\"caxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\"}},\"coloraxis\":{\"colorbar\":{\"outlinewidth\":0,\"ticks\":\"\"}},\"colorscale\":{\"sequential\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"sequentialminus\":[[0.0,\"#0d0887\"],[0.1111111111111111,\"#46039f\"],[0.2222222222222222,\"#7201a8\"],[0.3333333333333333,\"#9c179e\"],[0.4444444444444444,\"#bd3786\"],[0.5555555555555556,\"#d8576b\"],[0.6666666666666666,\"#ed7953\"],[0.7777777777777778,\"#fb9f3a\"],[0.8888888888888888,\"#fdca26\"],[1.0,\"#f0f921\"]],\"diverging\":[[0,\"#8e0152\"],[0.1,\"#c51b7d\"],[0.2,\"#de77ae\"],[0.3,\"#f1b6da\"],[0.4,\"#fde0ef\"],[0.5,\"#f7f7f7\"],[0.6,\"#e6f5d0\"],[0.7,\"#b8e186\"],[0.8,\"#7fbc41\"],[0.9,\"#4d9221\"],[1,\"#276419\"]]},\"xaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"white\",\"automargin\":true,\"zerolinewidth\":2},\"yaxis\":{\"gridcolor\":\"white\",\"linecolor\":\"white\",\"ticks\":\"\",\"title\":{\"standoff\":15},\"zerolinecolor\":\"white\",\"automargin\":true,\"zerolinewidth\":2},\"scene\":{\"xaxis\":{\"backgroundcolor\":\"#E5ECF6\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"white\",\"gridwidth\":2},\"yaxis\":{\"backgroundcolor\":\"#E5ECF6\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"white\",\"gridwidth\":2},\"zaxis\":{\"backgroundcolor\":\"#E5ECF6\",\"gridcolor\":\"white\",\"linecolor\":\"white\",\"showbackground\":true,\"ticks\":\"\",\"zerolinecolor\":\"white\",\"gridwidth\":2}},\"shapedefaults\":{\"line\":{\"color\":\"#2a3f5f\"}},\"annotationdefaults\":{\"arrowcolor\":\"#2a3f5f\",\"arrowhead\":0,\"arrowwidth\":1},\"geo\":{\"bgcolor\":\"white\",\"landcolor\":\"#E5ECF6\",\"subunitcolor\":\"white\",\"showland\":true,\"showlakes\":true,\"lakecolor\":\"white\"},\"title\":{\"x\":0.05},\"mapbox\":{\"style\":\"light\"}}},\"xaxis\":{\"anchor\":\"y\",\"domain\":[0.0,1.0],\"title\":{\"text\":\"Epoch\"}},\"yaxis\":{\"anchor\":\"x\",\"domain\":[0.0,1.0],\"title\":{\"text\":\"Accuracy\"}},\"legend\":{\"title\":{\"text\":\"variable\"},\"tracegroupgap\":0},\"title\":{\"text\":\"Accuracy vs Epoch\"}},                        {\"responsive\": true}                    ).then(function(){\n","                            \n","var gd = document.getElementById('82bcd4a3-5ca0-45cd-97f3-b797c1aff0aa');\n","var x = new MutationObserver(function (mutations, observer) {{\n","        var display = window.getComputedStyle(gd).display;\n","        if (!display || display === 'none') {{\n","            console.log([gd, 'removed!']);\n","            Plotly.purge(gd);\n","            observer.disconnect();\n","        }}\n","}});\n","\n","// Listen for the removal of the full notebook cells\n","var notebookContainer = gd.closest('#notebook-container');\n","if (notebookContainer) {{\n","    x.observe(notebookContainer, {childList: true});\n","}}\n","\n","// Listen for the clearing of the current output cell\n","var outputEl = gd.closest('.output');\n","if (outputEl) {{\n","    x.observe(outputEl, {childList: true});\n","}}\n","\n","                        })                };                });            </script>        </div>"]},"metadata":{},"output_type":"display_data"},{"data":{"text/plain":["dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy', 'lr'])"]},"execution_count":84,"metadata":{},"output_type":"execute_result"}],"source":["# Accuracy graph.\n","\n","fig = px.line(\n","    data_frame=history_callback_object.history,\n","    y=[\"accuracy\", \"val_accuracy\"],\n","    labels={\"index\": \"Epoch\", \"value\": \"Accuracy\"},\n","    title=\"Accuracy vs Epoch\",\n",")\n","fig.show()\n","\n","history_callback_object.history.keys()"]},{"cell_type":"code","execution_count":85,"metadata":{"execution":{"iopub.execute_input":"2023-12-20T08:29:03.546453Z","iopub.status.busy":"2023-12-20T08:29:03.546172Z","iopub.status.idle":"2023-12-20T08:29:04.340423Z","shell.execute_reply":"2023-12-20T08:29:04.339473Z","shell.execute_reply.started":"2023-12-20T08:29:03.546428Z"},"trusted":true},"outputs":[{"data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAACvIAAANgCAYAAAD0gW31AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8WgzjOAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3wb9f3H8fedlqc8kjhx9iB7byAQViCDXUYbNmWEVaCUMjqgpYzy62KWUkqgzELZgQBJgEDZEEYGIyF7OMOJbXlp3v3+kCxbsZNYiW3Zzuv5qKu7733v7iv563OQ3/qcYdu2LQAAAAAAAAAAAAAAAAAAAAAtykz1AAAAAAAAAAAAAAAAAAAAAID9EUFeAAAAAAAAAAAAAAAAAAAAIAUI8gIAAAAAAAAAAAAAAAAAAAApQJAXAAAAAAAAAAAAAAAAAAAASAGCvAAAAAAAAAAAAAAAAAAAAEAKEOQFAAAAAAAAAAAAAAAAAAAAUoAgLwAAAAAAAAAAAAAAAAAAAJACBHkBAAAAAAAAAAAAAAAAAACAFCDICwAAAAAAAAAAAAAAAAAAAKQAQV4AAACgFbrhhhs0evToVA8DAAAAAAAAAIA264UXXtDAgQO1ZMmSVA8FAABglwjyAgAA7Gd40yrqhhtu0MCBAxv8Gj58eKqHBwAAAAAAAACo48knn9TAgQN12mmnpXooqKPmbw67+vrqq69SPUQAAIBWz5nqAQAAAACp4na7deutt9ZrdzgcKRgNAAAAAAAAAGBX5syZo27dumnx4sVau3atevXqleohoY4rr7xS3bt3r9fes2fPFIwGAACgbSHICwAAgP2W0+nUiSeemOphAAAAAAAAAAB2Y/369fryyy9133336aabbtKcOXN0xRVXpHpYDaqqqlJGRkaqh9HiJk+ezN3uAAAA9pKZ6gEAAACgdfrmm2904YUXasyYMRo9erTOPffcerfACoVCuu+++3TMMcdo+PDhmjhxombOnKkPPvgg3mfbtm268cYbNXnyZA0bNkyHHHKILr30Um3YsGGX53744Yc1cOBAbdy4sd62v/zlLxo2bJjKysokSWvWrNHPfvYzTZo0ScOHD9fkyZP185//XOXl5U3yOtTcFuyzzz7TTTfdpIkTJ2rMmDG67rrr4mOo68knn9Sxxx4bf66///3v5fP56vX7+uuvddFFF2n8+PEaNWqUjj/+eP373/+u12/Lli267LLLNHr0aB144IG68847FYlEmuS5AQAAAAAAAEBbMGfOHOXk5Oiwww7T1KlTNWfOnAb7+Xw+3X777TryyCM1bNgwTZ48Wdddd5127NgR7xMIBHTvvfdq6tSpGj58uA455BBdccUVWrdunSTpk08+0cCBA/XJJ58kHHvDhg0aOHCgXnjhhXjbDTfcoNGjR2vdunW66KKLNHr0aF177bWSpM8//1xXXnmlDj/8cA0bNkyHHXaYbr/9dvn9/nrjXrlypa666iodeOCBGjFihKZOnaq//e1vkqSPP/5YAwcO1Pz58xt8XQYOHKgvv/yywddjyZIlGjhwoF588cV62/73v/9p4MCBeueddyRJFRUVuu222+Kv3UEHHaTzzz9fy5Yta/DYyap5/R5++GE9+uijOuKIIzRixAidddZZWr58eb3+H330kc444wyNGjVK48aN06WXXqqVK1fW67dlyxb96le/0iGHHKJhw4bpyCOP1M0336xgMJjQLxgM6o477tCBBx6oUaNG6fLLL0+YFwAAAKlERV4AAADUs2LFCp155pnKzMzUhRdeKKfTqWeeeUZnn322nnjiCY0cOVKSdN999+nBBx/UaaedphEjRqiiokJLly7VsmXLNGnSJEnSz372M/3www8666yz1K1bN+3YsUMffPCBioqKGrzNliRNnz5df/rTn/T666/rwgsvTNj2+uuva9KkScrJyVEwGNQFF1ygYDCos846Sx07dtSWLVu0cOFC+Xw+ZWdn7/G5NvRGndvtVlZWVkLbLbfcIq/XqyuuuEKrV6/W008/rU2bNunxxx+XYRiSpHvvvVf33XefDj74YM2cOTPeb8mSJXr66aflcrkkSR988IFmzZqlgoICnXPOOerYsaNWrlyphQsX6txzz42fMxKJ6IILLtCIESN03XXX6aOPPtLs2bPVo0cPnXHGGXt8bgAAAAAAAADQHsyZM0dHH3203G63jjvuOD399NNavHixRowYEe9TWVmpM888UytXrtQpp5yiIUOGqKSkRG+//ba2bNmi/Px8RSIRzZo1Sx999JGOPfZYnXPOOaqsrNQHH3yg5cuXq2fPnkmPLRwO64ILLtDYsWN1/fXXKy0tTZL0xhtvyO/3a+bMmcrNzdXixYv1xBNPaPPmzbrnnnvi+3/33Xc688wz5XQ69eMf/1jdunXTunXr9Pbbb+vnP/+5Jk6cqMLCwvhrsPPr0rNnT40ePbrBsQ0fPlw9evTQ66+/rpNPPjlh29y5c5WTk6NDDjlEknTzzTfrzTff1FlnnaV+/fqptLRUixYt0sqVKzV06NA9vg4VFRX13m83DEN5eXkJbS+99JIqKyt1xhlnKBAI6PHHH9e5556rOXPmqGPHjpKkDz/8UBdddJG6d++uK664Qn6/X0888YRmzpypF154If63hS1btujUU09VeXm5Tj/9dPXt21dbtmzRm2++Kb/fL7fbHT/vrbfeGn+Pf+PGjfr3v/+tW265RXfdddcenxsAAEBzI8gLAACAeu666y6FQiE9/fTT6tGjhyTppJNO0rRp0/SnP/1JTzzxhCRp4cKFOuyww/SHP/yhweP4fD59+eWXuu6663TBBRfE22fNmrXb83ft2lWjRo3S3LlzE4K8ixcv1vr16+O3TFu5cqU2bNigu+++W9OmTYv3a+wt1aqqqnTQQQfVaz/kkEP08MMPJ7S5XC49+uij8TBu165d9ac//Ulvv/22jjrqKO3YsUMPPvigDjnkED300EMyzejNL/r27atbbrlFr7zyik455RRFIhHddNNNKigo0EsvvSSv1xs/h23bCecMBAKaPn26Lr/8cknSzJkzdfLJJ+u5554jyAsAAAAAAABgv7B06VKtWrVKv/3tbyVJY8eOVZcuXTRnzpyEIO/DDz+s5cuX67777ksIvF522WXx915feuklffTRR7rxxht13nnnxftcfPHF9d6fbaxgMKhp06bpF7/4RUL7tddeGw/1StKPf/xj9erVS3/961+1adMmde3aVVI0YGrbtl588cV4W83+UjQMe8IJJ+iRRx5ReXl5vIBFTdGMSy65ZLfjmzFjhmbPnq2ysjLl5OTEx7xgwQIdffTR8fe83333XZ1++um64YYb4vtedNFFjX4d6r6eNdxut5YsWZLQtm7dOs2bN0+dO3eWJE2ePFmnnXaaHnroId14442SpP/7v/9TTk6OnnnmGeXm5kqSpkyZopNPPln33nuv7rzzTknSX//6VxUXF+vZZ5/V8OHD4+e46qqr6n0/c3NzNXv27HhhDsuy9Pjjjye8pgAAAKlipnoAAAAAaF0ikYg++OADTZkyJR7ilaSCggIdd9xxWrRokSoqKiRJXq9XK1as0Jo1axo8Vlpamlwulz799FOVlZUlNY7p06dr2bJl8duZSdFqvG63W1OmTJGkeNXc999/X9XV1UkdX5I8Ho8eeeSRel81b5DW9eMf/zj+hqYUDdU6nU69++67kqIVAkKhkM4555x4iFeSTjvtNGVlZcX7ffPNN9qwYYPOOeechBCvpPgbiHXNnDkzYX3s2LHasGFD0s8VAAAAAAAAANqimkqtEydOlBR9H3XGjBmaO3euIpFIvN+8efM0aNCgelVra/ap6ZOXl6ezzjprl332xs7v40pKCPFWVVVpx44dGj16tGzb1jfffCMpGsb97LPPdMoppySEeHcez4knnqhgMKg33ngj3jZ37lyFw2GdcMIJux3bjBkzFAqFNG/evHjbBx98IJ/PpxkzZsTbvF6vvv76a23ZsqWRzzrRTTfdVO+99oceeqhevylTpsRDvJI0YsQIjRw5Mv4e+tatW/Xtt9/q5JNPjod4JWnQoEE6+OCD4/0sy9KCBQt0xBFHJIR4a+z8/Tz99NMT2saNG6dIJKKNGzfu1fMFAABoSgR5AQAAkGDHjh2qrq5Wnz596m3r16+fLMtSUVGRJOnKK69UeXm5pk6dquOPP1533nmnvvvuu3h/t9uta6+9Vu+9954mTZqkM888Uw899JC2bdu2x3FMmzZNpmlq7ty5kqLVat944w1Nnjw5HuDt0aOHzj//fP33v//VgQceqAsuuEBPPvmkysvLG/VcHQ6HDj744HpfgwcPrte3V69eCeuZmZnq1KlT/E2+TZs2SYpW4K3L7XarR48e8X7r16+XJA0YMGCP4/N4PMrPz09oy8nJSToUDQAAAAAAAABtUSQS0WuvvaaJEydqw4YNWrt2rdauXasRI0aouLhYH330UbzvunXr1L9//90eb926derTp4+czqa7ebHT6VSXLl3qtW/atEk33HCDJkyYoNGjR+uggw6KB4hrimU09v3ifv36afjw4ZozZ068bc6cORo1alS99653NmjQIPXt21evv/56vG3u3LnKy8vTgQceGG+79tprtWLFCh1++OE69dRTde+998bH1xgjRoyo91573ePXaGi8vXv3rvde+67+RlFSUhIPRldUVOzxe15j56B0TaENn8/XqP0BAACaE0FeAAAA7LXx48dr/vz5uv3229W/f38999xz+tGPfqT//ve/8T7nnXee3nzzTV1zzTXyeDy6++67NWPGjHjFgV3p3Lmzxo0bF39z8auvvtKmTZsSKgRI0g033KBXXnlFs2bNkt/v16233qpjjz1Wmzdvbvon3MIcDkeqhwAAAAAAAAAAKfPxxx9r27Zteu2113TMMcfEv66++mpJSgi2NpVdVea1LKvBdrfbnXCXNikaQD7//PO1cOFCXXjhhbr//vv1yCOP6I9//ONuj7U7J510kj777DNt3rxZ69at01dffbXHarw1ZsyYoU8++UQ7duxQMBjU22+/rWOOOSYh0DxjxgwtWLBAv/nNb1RQUKCHH35Yxx57bLwCblu38/eohm3bLTwSAACA+gjyAgAAIEF+fr7S09O1evXqettWrVol0zRVWFgYb8vNzdUpp5yiv/71r1q4cKEGDhyoe++9N2G/nj176qc//almz56tV199VaFQSLNnz97jWKZPn67vvvtOq1at0ty5c5Wenq4jjjiiXr+BAwfqsssu05NPPqknn3xSW7Zs0dNPP70Xz37X1q5dm7BeWVmpbdu2qVu3bpJqP82/atWqhH7BYFAbNmyI9+vRo4ckafny5U06PgAAAAAAAABob+bMmaMOHTro7rvvrvd13HHHaf78+fL7/ZKi70OvWLFit8fr2bOnVq9erVAotMs+NZVad77zW03F2MZYvny51qxZoxtuuEEXX3yxpkyZooMPPlgFBQUJ/ZJ5v3jGjBlyOBx69dVX9corr8jlcmn69OmNGs+MGTMUDoc1b948vffee6qoqNCxxx5br19BQYHOPPNM/f3vf9dbb72l3Nxc/eMf/2jUORpr5/faJWnNmjX13mvf1d8o8vLylJGRofz8fGVlZe3xew4AANAWEOQFAABAAofDoUmTJumtt97Shg0b4u3FxcV69dVXNXbsWGVlZUmSSkpKEvbNzMxUz549FQwGJUnV1dUKBAIJfXr27KnMzMx4n92ZOnWqHA6HXnvtNb3xxhs6/PDDlZGREd9eUVGhcDicsM+AAQNkmmajjp+MZ555JuHN3aefflrhcFiTJ0+WJB188MFyuVx6/PHHEz7B/9xzz6m8vFyHHXaYJGno0KHq3r27HnvssXq37OKT/wAAAAAAAAAQ5ff7NW/ePB1++OGaNm1ava8zzzxTlZWVevvttyVJxxxzjL777jvNnz+/3rFq3ns95phjVFJSoieffHKXfbp16yaHw6HPPvssYXsyxSNqqr/Wfc/Xtm099thjCf3y8/M1fvx4Pf/889q0aVOD46nb99BDD9Urr7yiOXPm6JBDDlF+fn6jxtOvXz8NGDBAc+fO1dy5c9WpUyeNHz8+vj0SidQLLnfo0EEFBQVN/l77ggULtGXLlvj64sWL9fXXX8ffay8oKNDgwYP10ksvJbyHvnz5cn3wwQfx99pN09SUKVP0zjvvaMmSJfXOw/vtAACgLXHuuQsAAADao+eff17/+9//6rWfc845uvrqq/Xhhx/qjDPO0BlnnCGHw6FnnnlGwWBQv/zlL+N9jz32WE2YMEFDhw5Vbm6ulixZojfffFNnnXWWpOin6M877zxNmzZNBxxwgBwOhxYsWKDi4uIGP+2/sw4dOmjixIl65JFHVFlZqRkzZiRs//jjj3XLLbdo2rRp6t27tyKRiF5++WU5HA5NnTp1j8cPh8N6+eWXG9x29NFHJ4SGQ6GQzjvvPE2fPl2rV6/WU089pbFjx+qoo46SFH0TddasWbrvvvt04YUX6sgjj4z3Gz58ePwWZ6Zp6ne/+50uvfRSnXTSSfrRj36kTp06adWqVfrhhx/08MMP73HcAAAAAAAAANDevf3226qsrNSRRx7Z4PZRo0YpPz9fr7zyimbMmKELLrhAb775pq666iqdcsopGjp0qMrKyvT222/r97//vQYNGqSTTjpJL730ku644w4tXrxYY8eOVXV1tT766CPNnDlTU6ZMUXZ2tqZNm6YnnnhChmGoR48eWrhwobZv397osfft21c9e/bUnXfeqS1btigrK0tvvvlmveIOkvSb3/xGM2fO1Mknn6wf//jH6t69uzZu3KiFCxfWe//6pJNO0pVXXilJuuqqq5J4NaNVee+55x55PB6deuqp8bCxFL0D3WGHHaapU6dq0KBBysjI0IcffqglS5bohhtuaNTx33vvvXp3rJOkMWPGxCsPS9FiHzNnztTMmTMVDAb12GOPKTc3VxdeeGG8z3XXXaeLLrpIP/7xj3XqqafK7/friSeeUHZ2tq644op4v2uuuUYffPCBzj77bJ1++unq16+ftm3bpjfeeENPPfVUvLoyAABAa0eQFwAAYD+1q+oBP/rRj9S/f389+eST+stf/qIHH3xQtm1rxIgR+tOf/qSRI0fG+5599tl6++239cEHHygYDKpr1666+uqrdcEFF0iSunTpomOPPVYfffSRXnnlFTkcDvXt21d33XVXo4K2UvTNxQ8//FCZmZnxT9rXGDhwoA455BC988472rJli9LT0zVw4EA99NBDGjVq1B6PHQwGdd111zW47a233koI8t50002aM2eO7rnnHoVCIR177LH6zW9+I8Mw4n1+9rOfKT8/X0888YTuuOMO5eTk6PTTT9c111wjl8sV73fooYfq3//+t+6//37Nnj1btm2rR48eOv300xv1mgAAAAAAAABAe/fKK6/I4/Fo0qRJDW43TVOHH3645syZo5KSEuXl5enJJ5/Uvffeq/nz5+vFF19Uhw4ddNBBB6lz586Soneke+ihh/TAAw/o1Vdf1bx585Sbm6sxY8Zo4MCB8WP/5je/UTgc1n/+8x+53W5NmzZN1113nY477rhGjd3lcukf//iHbr31Vj344IPyeDw6+uijdeaZZ+rEE09M6Dto0CA9++yzuvvuu/X0008rEAioa9eumj59er3jHnHEEcrJyZFlWfEiE401Y8YM3XXXXaqurq537LS0NM2cOVMffPCB5s2bJ9u21bNnT918880644wzGnX8e+65p8H2O+64IyHIe9JJJ8k0Tf373//W9u3bNWLECP32t79VQUFBvM/BBx+sf/3rX7rnnnt0zz33yOl0avz48frlL3+ZcKzOnTvHX7s5c+aooqJCnTt31uTJk5WWlpbMywMAAJBShs39BAAAAIBdeuGFF3TjjTfqueee0/Dhw1M9HAAAAAAAAADAfiocDuvQQw/VEUccodtvvz3Vw0nKhg0bdNRRR+m6666LFwMBAABAlLnnLgAAAAAAAAAAAAAAAEilBQsWaMeOHTrppJNSPRQAAAA0IWeqBwAAAAAAAAAAAAAAAICGff311/r+++/197//XUOGDNGECRNSPSQAAAA0IYK8AAAAAAAAAAAAAAAArdTTTz+tV155RYMGDdIf//jHVA8HAAAATcywbdtO9SAAAAAAAAAAAAAAAAAAAACA/Y2Z6gEAAAAAAAAAAAAAAAAAAAAA+yOCvAAAAAAAAAAAAAAAAAAAAEAKEOQFAAAAAAAAAAAAAAAAAAAAUsCZ6gG0B7Zty7LsVA+j2Zim0a6fH5oW8wXJYL4gGcwXJIP5gmQwX5AM5guSwXxBMtrzfDFNQ4ZhpHoYAJoB740DtZgvSAbzBclgviBZzBkkg/mCZDBfkAzmC5LRnudLY98fJ8jbBCzL1o4dlakeRrNwOk3l5WXK56tSOGylejho5ZgvSAbzBclgviAZzBckg/mCZDBfkAzmC5LR3udLfn6mHA6CvEB7xHvjQBTzBclgviAZzBckizmDZDBfkAzmC5LBfEEy2vt8aez742YLjAUAAAAAAAAAAAAAAAAAAADATgjyAgAAAAAAAAAAAAAAAAAAAClAkBcAAAAAAAAAAAAAAAAAAABIAYK8AAAAAAAAAAAAAAAAAAAAQAoQ5AUAAAAAAAAAAAAAAAAAAABSwJnqAQAAAAAAAACWZSkSCad6GClhWYb8foeCwYAiETvVw0maw+GUaVIvAMCutcVrfFu/Nu8P+P0DAAAAAADaC4K8AAAAAAAASBnbtuXz7VB1dUWqh5JSxcWmLMtK9TD2Wnp6lrzefBmGkeqhAGhF2vo1vq1fm/cH/P4BAAAAAADtAUFeAAAAAAAApExNwCsrK09ut2e/DeI4HEabrPho27aCwYAqKkokSTk5HVI8IgCtSVu/xrfVa/P+gN8/AAAAAACgPSHICwAAAAAAgJSwrEg84JWV5U31cFLK6TQVDrfNqo9ut0eSVFFRouzsPG5zDkBS+7jGt+Vr8/6A3z8AAAAAAKC94F0NAAAAAAAApEQkEpFUG8RB21XzPYxEwikeCYDWgms8WgK/fwAAAAAAQHtAkBcAAAAAAAAp1dZutY76+B4C2BWuD2hOzC8AAAAAANAeEOQFAAAAAAAAAAAAAAAAAAAAUoAgLwAAAAAAALCPbrvtdzr77NNTPQwAAAAAAAAAANDGEOQFAAAAAAAAAAAAAAAAAAAAUoAgLwAAAAAAAAAAQBtk27aCwWCqhwEAAAAAAIB94Ez1AAAAAAAAAID2ZuXKH3T//Xdp8eKv5HA4NH78RF1xxTXq0qVLvM+rr76s//znSW3atFFpaWnq1au3rrzyGg0ePLRR2wEALWPp0sV6/PFH9N1336qyskLdu/fUT35ypqZNOzbep7y8XP/61wN6772FKi0tUceOnXTUUcfokkuuiPf58MP39fjjs7V8+fdyudw64ID+uvLKazRgwCDNnTtHt9/+e7366gLl5ubG9znvvDPUv/8A/frXv5Mk3Xbb7/Tdd9/ossuu1D/+cb/Wrl2tm2++VQceOEkPPHCPPvvsE23dukV5efmaOPEgXXrplcrKykp4Pq+//qqeffYprV27Runp6Ro8eKiuvfZGpaWl6+STp+vnP79OJ5xwcsI+F110rrp0KdQf/vDHpn+BAQAAAAAA9nMEeQEAAAAAAIAmtGXLZl1++UXq1q27fvvbPygYDOif/3xAP/vZxfr3v59WRkamvvrqC/3xj3/QzJln66CDJikUCmjp0qWqqCiXpHrb/X6/vv12WXw7AKDlbN5cpOHDR+qkk06R2+3RkiVf649//INs29b06ccpGAzqqqsuUVFRkc4//yL163eAtm7dosWLv4of46235ul3v/u1DjnkMN18821yuZxavPhrbdu2TQMGDEpqPMXFxbrrrj/r3HMvUOfOXdS5cxf5/X5ZlqWLL75Mubl52rp1ix57bLZuvPEXuvfeB+P7PvXUY/r73+/RccedqIsvvkzhcFiLFn2u0tISDRpUqMmTD9drr72SEORdtWqlvv12mS688JJ9fi0BAAAAAABQH0FeAAAAAAAAtCq2bSsYslJ2frfLlGEYe73/s88+pUgkrL/97T55vTmSpAEDBumss07T3LlzdOqpP9E33yyT15ujyy+/SpLkdJqaOHFS/Bg7b5ekgw8+ZK/HBACtRSqv8Xt7fZ8yZWp82bZtjRw5Wlu3btHLL7+g6dOP0xtvvKbly7/XP/4xW8OGjYj3nT79uPg+999/t8aPP1B33PHn+PaDDtq763p5uU9//vM9Gjp0WEL7tdfeGF8Oh8MqLOyqyy67UOvWrVXPnr1UUVGh2bP/qRNOOFnXXffreN9DDz08vnz88Sfr6qsv05o1q9W7dx9J0muvvaKCgs4aP37iXo0XAAAAAAAAu0eQFwAAAAAAAK2Gbdu644kv9MPGspSN4YDuObrxzDF7Heb9+uuvNGbMuHiIV5J69eqtAw7or8WLv9app/5EAwcOks9Xpttu+52OOWaaRo8eLafTE++/8/bhw0cpLS1tn58bAKRSqq/xe3t99/l8mj37Qf3vf++quHibIpGIJCknJ3qdX7ToU/Xu3SchxFvXunVrtXXrFl1++dX7NP4aOTk59UK8kvTGG6/pmWee1IYN61VdXR1vX79+nXr27KWlSxfL7/fruONO3OWxx44dr65du+m1117R5ZdfpXA4rHnzXteJJ/5Ipmk2yfgBAAAAAACQiHddAAAAAAAA0LrsfTHcVqG83Kf8/A712vPyOsjni4bXxo4dr9/+9hatXr1K11zzM02depT+8Iebdrn92GMTtwNAm9UGr/G33/47LVjwpmbOPEt//et9+te/HtOxx56gYDAoSSorK1OHDp12uX9ZWakkqWPHXfdJRl5e/d8x7777jm699WYNHjxUt9xyhx588FHdfnu0+m8wGJCk+O+Q3Y3DMAwdf/xJevPNuQqHw/rww/dVWlqiGTOOb5KxAwAAAAAAoD4q8gIAAAAAAKDVMAxDN545JmW3XZf2/tbrNbxer0pKdtRrLynZrh49esXXp06doalTZ6i0tFQffvie7rrrL3I6nbrxxpvqbX///YW6556/JWwHgLYm1df4vbm+BwIBffjh+7riip/r1FN/Em+3bTu+nJOTo5Urf9jlMXJyciVJxcXbdj02t1uSFA6HEtrLy331+jb0FN55Z4H69x+g6677dbztyy8XJfSpqRRfXLxNBQWddzmWGTOO17/+9Q99+OH7eu21lzVmzDh17dptl/0BAAAAAACwb6jICwAAAAAAgFbFMAx53I6Ufe1LiFeSRowYpUWLPpPPVxu+WrdujVau/EEjRoys1z83N1cnnHCSxo+foLVr1zS4/bjjdr0dANqSVF7j9+b6HgqFZFmWXC5XvK2qqlLvv/9efH3cuIlas2a1li1b2uAxevbspYKCzpo7d84uz9OpUzRYu2bN6njbmjWrtXXrlkaNMxAIyOl0JbTNm/dGwvqwYSOUlpa223FIUocOHXXwwYfqqace08cff6hjjz2hUWMAAAAAAADA3qEiLwAAAAAAANCETj/9DL322hxdc80VOuecnyoYDOihhx5Q585d4rcmf/jhB1VWVqrRo8cqLy9fa9as1CeffKQf//jMBrevXPlDwnYA+6e1a9fq4Ycf1tdff60VK1aob9++evXVV/e4n23beuihh/TUU09px44dGjx4sG688UaNGjWq+QfdxmVlZWnw4CF64olHlZubK4fDqSeeeFSZmVkqLY1WX586dYZefPG/uu66q3T++Repb98DtG3bVn311Ze6/vpfyzAMXX75Vfrd736tX//6l5o27Vi5XG4tW7ZEgwYN0aRJh2ro0GEqKOise+/9q2bNukKVlRV64ol/Kycnp1HjHD9+ov761zv16KP/0tChw/Xxxx9o0aJP6z2X88+/SA88cK8sy9Khhx4my7L1xRef6+ijp2rQoCHxvieccJJ++curlZWVrcMOO7LpXlAAAAAAAADUQ5AXAAAAAAAAaEKdO3fRfff9U/fff5duueU3Mk2Hxo+foJ/97BplZGRKkgYNGqJnn31ab7+9QFVVlSooKNDMmWfr3HMvaHB7p06J2wHsn1asWKF3331XI0eOlGVZsm27Ufs99NBDuueee3Tttddq4MCBevLJJ/XTn/5UL7/8snr06NHMo277br75Nv3pT7frttt+J683R6ee+hNVV1fpP/95QpLkdrt1110P6J///Lsef/wR+Xw+depUoClTpsaPcdRRx8jjSdNjj83WzTf/Wm63WwMHDtLkyYdLkpxOp26//c/6y1/u0G9/e726d++hn/3sGt13312NGuOJJ/5ImzZt1HPPPaOnnnpcEyYcqJtvvk2zZp2X0O/MM89Vbm6enn32Kb3++qvKyMjQ0KEjlJubn9BvwoSDlJaWpilTpsrj8ez1awcAAAAAAIA9M+zGvtOHXYpELO3YUZnqYTQLp9NUXl6mSkoqFQ5bqR4OWjnmC5LBfEEymC9IBvMFyWC+IBnMFySD+dI4oVBQ27cXqUOHQrlc7lQPJ6WcTrNNz5XdfS/z8zPlcJgpGhnQvliWJdOM/jzdcMMNWrp06R4r8gYCAR188ME688wzdc0110iSgsGgpk2bpsmTJ+t3v/vdXo9nd++Nt4drfFu/Nu+LRYs+01VXXap//etxDRo0ONXD2aXWMs/4tx+SwXxBMpgvSBZzBslgviAZzBckg/mCZLT3+dLY98epyAsAAAAAAAAAQBtQE+JNxhdffKGKigpNnz493uZ2u3X00Udr/vz5TTk8tAPFxdu0YcN63X//3Ro+fGSrDvECAAAAAAC0F5TCAAAAAAAAAACgnVq1apUkqW/fvgnt/fr106ZNm+T3+1MxLLRSL7/8gq688hJJ0g03/DbFowEAAAAAANg/UJEXAAAAAAAAAIB2yufzye12y+PxJLR7vV7Ztq2ysjKlpaXt9fGdzobrhViWsdfHbA0Mo/bRtlM7lpZ0wQWzdMEFs1I9jKQ5HMYu52LLnN9MeAR2h/mCZDBfkCzmDJLBfEEymC9IBvMFyWC+RBHkBQAAAAAAAAAASTNNQ3l5mQ1u8/sdKi42Ux6w3Ff7+x+RWjvLMmSapnJyMvYpkN5UvN70VA8BbQjzBclgviBZzBkkg/mCZDBfkAzmC5Kxv88XgrwAAAAAAAAAALRTXq9XwWBQgUAgoSqvz+eTYRjKycnZ62Nbli2fr6rBbcFgQJZlKRKxFQ5be32OVDGMaIg3ErH2q4q8bU0kYsuyLJWVVam6OpKycTgcprzedPl81YpE2t58R8tiviAZzBckizmDZDBfkAzmC5LBfEEy2vt88XrTG/VBcYK8AAAAAAAAAAC0U3379pUkrV69WoMGDYq3r1q1Sl27dt3nKqa7CulGIm07/VoT3iXE2za0lsB4JGK1inGgbWC+IBnMFySLOYNkMF+QDOYLksF8QTL29/nCPaEAAAAAAAAAAGinxowZo6ysLL3++uvxtlAopHnz5mny5MkpHBkAAAAAAAAAiYq82I2i7ZV67t2VOnvGEHXMcqd6OAAAAAAAAACwX6uurta7774rSdq4caMqKir0xhtvSJImTJig/Px8nXvuudq0aZPmz58vSfJ4PJo1a5buvfde5efna8CAAXr66adVWlqqCy64IGXPBQAAAAAAtE22bSscsRWOWLGvxGVbUnZ5UOXl1YpEbBmGZMiQYUT3NwxDhiQZtcsJ2wzFtse2xfqasU5G/FGxfQ3Ztq2IZcuyoo91l6262yKWInadbdZu9qu7f8RKOJZpGHI5TbkcppxOM76c0BZbd9a077TscpgyTaMJvyeWgmFLwZClUMRSKBRRMGwpFLYUDEcUClnx9VA4ui1YsxyqaY/2jVi2FP2f7Njtimw7umzHzynZsqN3M4q1197hyI5tr7NN0f+zE/rakgwdPLKrpo7r3iSvRVtFkBe7tHT1Dn25vFiZ6T/o4uOHpHo4AAAAAAAAALBf2759u6666qqEtpr1xx57TBMnTpRlWYpEIgl9LrroItm2rdmzZ2vHjh0aPHiwHn74YfXo0aPFxg4AAAAAwJ5Ytq1AMCJ/MPrftaYhmaYhh2nIMKKPZs2X0TQByNagJoQaiQVNw5atSKQ2PBq2apcjEVsRKxqYjViWIpHE7eE6/cKx7TXtDYVuwxFL4XD0nNFHS+GwHXtsuH/Esvf8pNAoDtNICP3uHAKuCf/atl0bug1bCsXCusFQJB7AbcvflcpAmCBvqgeA1qtrx0xJ0or1pakdCAAAAAAAAABA3bt31/fff7/bPo8//ni9NsMwNGvWLM2aNau5hgYAAAAAKWfbtqoDEZVWBFRWGZRt23I6TDlMQw6HIadpyuGIhkFr283YuiGH2XTVMfcntm0rGLLkD4ZVHYyoOhCWPxiRP/ZYHYw9BsLyByLxfv5gWNWx9ZrtgWAkqTBiYsA3WrG1btDXEXusHwZWQp+aCq81lUctu25FUTteidSKlRWtWbZjJUst206oVmrXW6/to9i+0eBubdC2Lav5GXM5TDkcppyO6M9YJGLXVmxV9DXQzlVa7Z0qvkaXal9r1a0Mu3Pf2m2GoXjQu+b7XvPzbdYJgdcNg9csO+u2GYnbah/N2n1jFYBDkWiANhyprWZbd7lmeygWlq5Zt+t8uyOWrUgwooASP5S9LwxJLpcpt9Mhl9OU22nK5XTI7YoFhGPb3LGgsNvpkCu2ze2K9o3+XOxUGdmoUw059n9mQnXk6A41VZLrVWDWzhWXo/s4nIZGD+4ihZvuNWiLCPJil/p0yZYkbdlRpfKqoNLdTBcAAAAAAIDm8sUXn+vKKy/Rv/71mAYN2vPdkebOnaPbb/+9Xn11gXJzc5t/gACAvZbsNR4AAABAolDYUllFQKUVQZVUBFRSHlBpRUClscfoelCB0L4FwaJhQDMW/K0NAsbDvzsHgessu10OedwOpdU8uh1yuxLXPbFlj8uhNLcztm7KYZpN9ErtnmXZCoQitV/BiIIhK2E9YXusLRS2FJHkqwio2l8/iGs3cQ7ViAUE9xRwjcTSnu0x/2casYB5LGQen5PxQHoD83Q3gXVnrPJrTci29svY6XHn9jrLzjrHMU25nNFj71wd2ek0lZeXqZKSSoXDVopewdYrYtUN/toKhSN1lqNVd0M1y5HoNtMwEkK3NSFcVyyQWzesWzec3hY4nabystNUUlKZ6qGkFMlM7FJGmktd8jO0eUeVVhf5NKRXfqqHBAAAAAAAAAAAAAAAgHbCsm1VVIXiwdyShHBuMB7SragONfqY6R6ncrPcMg1DYctWJGJFq17GHsORaCXUcKR+SNS2pXDEUjgiBZryie6B02HGg77xAHCd9Zrwb93tkUhNALd+EDcYD+JaCgTD8T6hZgxVGpLSPE6luR1Kr3l0RwPLaR6H0us+uh21fRtodzvNeBDRsm1ZVvQrYtmy7eijZdVUtrVk2Yr3ibbH+tTZ17JsRWxblqV4n7p961YYNeIVSGPVQ2OVSE1DDWxLrFZq1lQijR8rWnU03jdWjXR3IfGaqq9onxymKYfbVJo71SNBa0KQF7vVt6tXm3dUadUmgrwAAAAAAAAAACAqEPDL40lL9TAAAACwjyzbVjhixUOSCcHHJgxJRiK2fFVBlZYnhnVLK4J7rLpaw+kwlJvlUW62R7lZHuVleZSb7Y4+ZnmUF2v3uB2NOp5tx8YXsWMBXys+1pqgb8Sqs7xTEHjn/WoCtP5gNFDrb2A9XvE2GG23YqVswxFLFdVWUoHlfWFICeFgd6wycFp8uXabx+VQeppT+bkZssMRuZ1mA4Fdp9wus1mqgJqGIdNhSI37tgJAm0SQF7vVt6tXHy7drFWbfKkeCgAAAAAAQKs0d+4c3XnnrXrxxbnKz+8Qb/f5ynTCCVN19dW/1AEH9Nfjjz+i7777VpWVFerevad+8pMzNW3asU06Fp+vTPfdd5c++OA9VVf7NWDAQF1yyRUaNWpMvM/ixV/pwQfv1w8/LJdl2SosLNTMmWdr+vTjGrUdAPYnqbrGFxcX65//vF9ffvmFtm8vVkFBgY44YorOP/8iud21JXssy9Kzzz6lOXNe0qZNG5Wd7dWIEaN0ww2/VVZWliRpzZrV+uc//64vv1ykYDCg7t176qyzztXRR09TUdEmnXbaCfrDH/6oI46YEj/u3Xf/Rf/730I999yc+Otw++2/1z/+MVv/+tc/tHTpYs2YcbyuueZ6Pf30E3rrrXlav36tXC63hgwZqiuu+Ll69uyV8JyWLl2shx9+UMuWLZVt2+rdu48uvvhSjR9/oH7607PUq1dv3XzzrQn7/P3v9+jNN+fqhRdek8PBX+0BAEDbEbEsVQciqvSHVOUPR78CYVX6Q6r2h1UZW6/yh6LL/rCqA2FZli1btmw7WhlWsmWrZjkaPLVtKbppN9vqHMNWtLG2b+22mhBpqhmSsjPdys2KhXKzPfHH3CxPtD3bo6x0V5MGRQ3DkMMw5DCb7JBJse1oKDge7K0J+sYq6PpD4dh6NPxbuz267nCYtWFbtxkP5KbFgrjuOkHcaDC3tr/LmVzo1uk0lZeXqZKSSoWbsaovAOyvCPJit/p09UqSVm/yybbtZvnkDAAAAAAAQF22bUvhYOoG4HQn9R7I5MlH6M9/vkPvvLNAp5zy43j7woVvS5KOPHKKPv30Yw0fPlInnXSK3G6Pliz5Wn/84x9k23aTBWQjkYh+8YsrVVS0UZde+jPl5XXQc8/9Rz//+eV64IHZGjRosCorK3TddVdrxIhR+t3vbpPL5daaNatUXl4uSXvcDgD7KqXX+CSv71LqrvFlZaXyenP0s5/9XNnZ2Vq/fp1mz/6ntm8v1q9+dXO839/+9ie98soLOv30MzR+/ERVVVXqww/fV3V1lbKysrR+/Tpdcsn5KijorKuvvlb5+R20evVKbdmyea/G9fvf/0YnnHCyzjnnp/FqvNu2bdEpp5yuzp27qKqqUi+99LwuvfSnevrpF+T15kiKfkjkqqsu1dChw3X99b9Rdna2vvvum/g4TjjhJN17799UUVERDyBHIhG9+eZcTZ9+HCFeAADQ4iKWpVDYigdwa8K4lf5QwnpVbL0yHtaNBnf9wUiqn8I+MySZplH7ZRhymIZMQwltplnT3lBb4jGy0931KujmZXvkzXTLmao0bQoZhiGX05DLaSor3ZXq4QAAUoggL3arV+dsOUxDZZVBlZQHlO/lNlkAAAAAAKD52Latqlduk7Xlh5SNwdG5v9JP+FWjw15ZWVk68MBJWrDgzYSQ14IFb2rChAPl9eZoypSp8XbbtjVy5Ght3bpFL7/8QpMFeT/66H19++0y/eUv92rixIMkSRMnHqQf//gkPf74bN1225+0fv06VVRUaNasK9Sv3wGSpHHjJsSPsaftALAvUn2NT/b6LqXuGt+v3wG64oqr4+vDh49UWlq6brvtZl1zzfVKS0vTunVr9dJLz+niiy/T2WefH+97+OFHxZdnz/6nnE6XHnjgYWVmRgOy48dP3KsxSdKJJ/5IZ511XkLblVf+Ir4ciUQ0fvxEHXfcMXrnnbd04ok/kiQ98MA96tath+6++4F4KHfChAPj+x199DTdd99dmj//DZ188qmSpI8++kDbtxfr2GNP2OvxAgCA1qemamzEsmXZtqzYY8SyZVv2Tu2xflZtv1DYUihiKRy2Epcj0fVw7LGhfg3133mfcCR6jqaqVOtxO5SZ5lSGx6mMNJcyPE5lpjmVnuZUZmw9Iy325XHKYZqSEQ3RGoahmn+6GoZkqO66IUPaRd8622LLtX2j/QzDiFVYzVC5r1q2ZSeEcGuWAQBAyyDIi91yuxzq1cWrVZvKtGqTjyAvAAAAAABodrE/N7UpU6ZM1c0336jNmzerS5cuKi4u1ldffaHf/Ob3kiSfz6fZsx/U//73roqLtykSiVbmycnJabIxfP31V8rMzIyHeCXJ6XTqsMOO0Pz5b0qSunbtrszMTP35z3fo1FN/ojFjxikvLy/ef0/bAWBfcY1vHNu29d//Pq1XXnlRmzZtUjAYiG/btGmD+vY9QF988Zls29Zxx524y+MsWvSZDj/8qHiId18dfPAh9dqWLl2if/3rAS1f/r18vrJ4+/r16yRJfr9fy5Yt1axZl++ysm5mZpaOPPJovfbaK/Eg79y5czRy5Gj16NGzScYOAEBbZtu2/MGIfFVBlVeGVF4VlK8qKF9VSOWV0eXyqpAq/SGZpqlIxFIT5VD3NLJ42LZ+CDcxpGtZiq+3JaZhKCMtGr6NBm53H8atu57ucbbqKrNOp6m87DQpHFE4bKV6OAAA7NcI8mKP+vfM1apNZVq92adxgwpSPRwAAAAAANCOGYah9BN+lbrbrkt7dev1SZMOUVpaut56602deea5evvt+XK73Tr00MMlSbff/jstXbpY5513ofr06afMzEy9+OJzevvt+U027PJyn/Ly8uu15+V1iAervF6v/va3+/Xww//UrbfepEgkohEjRunnP79O/fodsMftALAvUn6N34vru5Saa/yzzz6l+++/W2eccY7GjBmn7OxsffvtN/rrX+9UMBh9/crKyuRwOBq89tcoKytVx44d93ocO8vL65CwvnnzZl1zzRUaNGiwfvnLG9WxYye5XC798pdXx8PH5eU+WZaljh077fbYJ5xwsi655Kf64YcV6tChoz788H+67rpfN9nYAQBobYKhiMqrQrEQblC+ypDKq6NBXV8sqFsea/NVhhSOtP+gpWFEg7MO05BhGnIkVIeVHKYhp8OUyxn9ii87TDmdOy3X2eZy7tTW0L4N9XOYcrvMvfo3JAAAQDII8mKP+vfI05sfr9WaovJUDwUAAAAAAOwHDMOQXJ5UDyMpHk+aJk8+TG+9NU9nnnmu3nprniZNOlTp6ekKBAL68MP3dcUVP9epp/4kvo/dxFWIvF6vSkp21GsvKdkur7e2KuSQIcP0l7/co0DAry+++Fz333+3brzxF3r22ZcbtR0A9gXX+MZ55523NGnSZF1yyRXxtjVrVif0ycnJUSQSUUnJjl2GeXNyclVcXLzL87jdbklSKBROaC8v9zXYf+cQyyeffKjq6irddtuflJ2dLUkKh8MJlXmzsrJlmqaKi7ftchySNGzYCPXp01evvfaKOnfuLLfboyOOmLLbfQAA2Bu2bcuOVZG1LFsRy6qzHHuMVZONRGqrzNbr09B+dR4jlq1wxFJFdag2qFunkm4gGEl67B6XQ9kZLnkz3fJmuOPL2ekuZWe6lZPlVo43XeXlfkWslql8mxi2jYVwY6Hb+u1GbXt8WfF1ArMAAGB/RZAXezSgZ64kac1mnyzblsk/ngEAAAAAAOqZMmWqfvnLq/XJJx9p2bIlOuuscyVJoVBIlmXJ5XLF+1ZVVer9999r0vOPGDFKTz31uD799GNNmHCgpGiY6r33FmrEiJH1+ns8aTrooEO0ceMG3X33XxQIBOTxeBq9HQD2Jy19jQ8E/AnHlKR5815PWB8zZrwMw9Brr72is846r8HjjBs3QQsXvqXLLvuZMjIy623Py8uX0+nU2rW1IeFQKKSvvvqikeMMyDAMOZ21f256++0FikRqg0np6ekaOnS43njjNf3kJ2fJ4XDs8njHH3+yHnvsYeXm5uuoo45Wenp6o8YBAIBt26r0h1VaHlBpRUAlFQGVVgRVWhGItUWXy6uCCkdaJuDaGE6HoeyaQG6GW9kZbnkzo8tZsTZvZnR7doZbHteuf49KktNpKi8vUyUllQqH238FXwAAgPaCIC/2qGfnbLmdpqoDEW3ZUaXCDvXf7AMAAAAAANjfjR9/oHJycnTHHbcoKytbBx44SZKUlZWlwYOH6IknHlVubq4cDqeeeOJRZWZmqbS0fgXdvXXQQYdo8OChuuWW3+qSS65Qfn4HPffcM9q+vVhnn/1TSdKHH76vV199WZMnH67Onbtox47teu65ZzV8+Eh5PJ49bgeA/VVLX+PHj5+o//73P3r++WfUo0cvvfnmXG3YsCGhT8+evXTiiafooYcekM/n07hxE+T3+/XRR+/rpz+9WJ06Fej88y/Shx/+T5deeqHOPPMcdejQUWvWrJLf79eZZ54r0zR12GFH6Pnnn1X37j2Uk5Or559/VrZtN6oi3tix4yVJt9/+e5144o+0evUq/ec/TygrKzuh3yWX/ExXXXWJrr76Mp188mnKzs7W8uXfKScnV8cdd2K837RpM/SPf9yr0tJS3XDDb/f69QMAtB+2bas6EIkGcuNfwXhgNx7WrQg0SUDXYRpyOGKVYutUj619NBMqzcbbjeh+Ncs12xwOU1npLnkzohVzvTuFdtM9DqrQAgAAgCAv9szhMNWrS7ZWbCjT6iIfQV4AAAAAAIAGOJ1OHX74UXr55Rd03HEnJlRSvPnm2/SnP92u2277nbzeHJ166k9UXV2l//zniSY7v8Ph0J//fLfuv/9u/f3v98jvr9aAAYP017/ep0GDBkuSunfvLtM09M9//l2lpSXyenM0YcKBmjXr8kZtB4D9VUtf48877yKVlpbqX/96UJJ0+OFH6eqrr9X11/88od8111ynrl276pVXXtKzzz6lnJwcjRo1RhkZGZKkHj166oEHZuvBB+/TX/7yR0UiEfXo0TOhgu/VV1+n//u/23TXXX9SRkamZs48Wz179tL//rdwj+Ps1+8A/epXN2v27H/quut+rv79B+jWW+/Ub397Q0K/kSNH6d57H9RDDz2g22//nUzToT59+uqiiy5N6Of1Rse/detWDRs2POnXDQDQNti2rWDIkj8YVlUgrLJ4GLc2lFtaHlBpZXQ9GGp8ZdmsdJdyszzKzXZHH7M8ysuKLWd7lJ3hksvpiIZsdwrjcmdaAAAApIph23bruW9EGxWJWNqxozLVw2gWNbfeuO+ZL/Tmp+t11NjuOvPoAakeFlopbtWCZDBfkAzmC5LBfEEymC9IBvMFyWC+NE4oFNT27UXq0KFQLpc71cNJKafTbNNzZXffy/z8TDkcZopGBqA57e698fZwjW/r1+a2qLKyQiedNEM//enFmjnzrD32by3zjH/7IRnMFySjNcwX27YVjtjyB8MKBCPyhyLyByPR5WA4uhxr88faArtoq9k3GIwo2ZBChsep3GyPcrNqA7q5dQK6uVlu5WR65HLu3//t0RrmDNoO5guSwXxBMpgvSEZ7ny+NfX+cirxolD5dcySt15oiX6qHAgAAAAAAAAAA2pGqqkqtXr1aL774XxmGoWOPPT7VQwKAdsm2bfmDEZVVBuWrDKqsMqiyioB8VUGVVUTbfFWhaPA2FJE/EA3kRqzmqQ1mSErzOJST2UBAN7t2OSfLI4/L0SxjAAAAAFoDgrxolL5dvZKktVsqFI5YclJFBQAAAAAAoNlYliXL2nX1AYfDIYPbvgJAm8Q1vr7vvvtWV155iQoKOuvXv/6dvN6cVA8JANqUQDCisqqgfBXBWEg3kBDWjYd2K4MK7UOVM7fTlMftUJrbIY/LqbSa5dhjmstZu93tUJrLoTSPUx6XY6e+TqW5HHK7zP3udx4AAADQEIK8aJTOeenK8DhVFQhr47ZK9eqSneohAQAAAAAAtFuPPPKQHnnkoV1u/9WvbtaMGVQrBIC2iGt8fWPGjNP773+e6mEAQKti2bZKywPaVh7U+qIylfj88TDuzgHdQDCS1LHT3A7lZLrlzXQnPOZkeZSd7lK6pzaQm+auDeKaJqFbAAAAoDkQ5EWjGIahPoXZWramRKuLfAR5AQAAAAAAmtGJJ/5IkyYdusvthYVdW3A0AICmxDUeACBJobClHeV+7Sjzq9jn1/Yyv3b4Atpes1zuVzhiN/p4bqcZDeRmueXNiIZyGwrrejPd8rgczfjMAAAAACSLIC8arXehNx7kPXx0t1QPBwAAAAAAoN3q2LGTOnbslOphAACaAdd4ANg/VPlD2u4LaHuZPxrOjQV0a5bLKoJ7PIZhSB28afJmRsO53rrVc3cK56a5HTIMKuYCAAAAbRFBXjRan0KvJGl1kS/FIwEAAAAAAAAAAACA1LBsW2UVwdrqub66VXWjQd3qQGSPx3E7TXXISVMHb5ryvWnqkJOmjt405Xs96pCTpk556erYIVslJZUKh60WeGYAAAAAUoEgLxqtJsi7sbhSgWBEHje3XAEAAAAAAPvOtht/u1i0TnwPAewK1wc0J+YXgL1h2bYCwYiqA2H5gxFVB6OP/kBY1YGI/MGwqoPRR3/Nep32yuqQSsoDilh7vgZlpbviQd0OsaBuh1hIt4M3TVnprt1W0XWYZlM+dQAAAACtVKsK8q5du1YPP/ywvv76a61YsUJ9+/bVq6++utt9PvnkE51zzjkNbuvTp4/eeOON3fabMWOG/va3v+374PcDedke5Wa5VVoR1Not5RrQIzfVQwIAAAAAAG2YwxH9kHAwGJDb7UnxaLAvgsGAJMnhaFVvNwJIIa7xaAn8/gH2b5Zta9O2Sq3bWl4btN3p0d9AYDcQ3HOl3MYwDUN52Z7aYG5OtKpux1hgNz87jcJIAAAAABqlVb2zsWLFCr377rsaOXKkLMtq1Cephw4dqmeeeSahraKiQhdddJEmT55cr/8dd9yhvn37xtfz8vL2feD7kT6FXn25olhrinwEeQEAAAAAwD4xTYfS07NUUVEiSXK7PbutRtWeWZahSKTtVRW0bVvBYEAVFSVKT8+SScUwADHt4RrfVq/N+wN+/wD7p4hlad2WCn2/rlTL15dqxYZSVfrDe308h2koze1QmtupdI9DaR6n0twOpbtjj7H1+PbYY7rHqfzsNOVmu6mYCwAAAKBJtKog75FHHqkpU6ZIkm644QYtXbp0j/tkZWVp1KhRCW0vvPCCLMvScccdV69///79NXz48CYZ7/6oJsi7qsiX6qEAAAAAAIB2wOvNl6R40Gt/ZZqmLMtK9TD2Wnp6Vvx7CQA12vo1vq1fm/cH/P4B2rdQOKJVm3xavr5UyzeU6YcNZQqEEqvpelwO9e6SrewMl9LcTqXVDdzGArlpHqfSGwjkOh1mm/uQCQAAAID2qVUFeZvqE9OvvvqqevfurREjRjTJ8fZXkeK1qnr/37L7j5YGHS050tSn0CtJWlNUnuLRAQAAAACA9sAwDOXkdFB2dp4ikb2vptWWORyGcnIyVFZW1SYrPzocTiohAmhQW77Gt/Vr8/6A3z9A+1MdCGvlprJocHddqVYV+RTe6RqcmeZU/+65GtAj+tWzc5acDq4FAAAAANq2VhXkbQrFxcX6+OOPdemllza4/eKLL1Zpaak6deqkY489VldddZXS0tJaeJRtg+XbqsjWVSrdukrG52/IPepY9ep3mCRpa2m1KqpDykp3pXiUAAAAAACgPTBNU6bpTvUwUsLpNJWWlqbq6ojCYSo/Amh/2uI1nmszADS/iuqQVmwojQZ315dq7eYKWXZicDcn0x0P7Q7skauunTJlUkUXAAAAQDvT7oK8c+fOVSQS0XHHHZfQnp2drQsvvFDjx4+Xx+PRxx9/rNmzZ2vVqlV68MEH9/m8Tmf7+6Sno/8EudxO+T99XqHiDQp88qyMpfM1NW+45pf01PqtFRrer0Oqh4lWxBH7xLODTz6jEZgvSAbzBclgviAZzBckg/mCZDBfkAzmCwAAAPYHJeUBrdhQqu9jwd2N2yrr9emYk5YQ3C3IS5dBcBcAAABAO9fugrxz5szR0KFD1adPn4T2IUOGaMiQIfH1gw46SAUFBbrlllu0ePFijRgxYq/PaZqG8vIy93r/Vi1/suyRk1Sx5F2VvPeMwr5izTDe07icbPl+CCt37CkyDP7IhEReb3qqh4A2hPmCZDBfkAzmC5LBfEEymC9IBvMFyWC+AAAAoL2wbVvFZX4tX18b3N1aUl2vX2GHDA2MBXcH9MhVvpc7qQIAAADY/7SrIO+6deu0ePFi3XjjjY3qP336dN1yyy1aunTpPgV5LcuWz1e11/u3Zg6HKa83XXafg5TVbYwCS9+W75MXVaByFaz8j9b98yOlH3ianD2G82lYxOeLz1etSITbzWH3mC9IBvMFyWC+IBnMFySD+YJkMF+QjPY+X7zedKoNAwAAtDK2bSscsRWOWLGvJJbDlsKWHXuMrcf72SqrDGjFhjKVlAcSzmlI6tE5K15tt3/3XHkz3al5AQAAAACgFWlXQd45c+bINE3NmDGjxc8dDre/P7LUFYlYitgOOYcerR2Zw7Xopad1ZPo3Siteq4pX/yxH4SB5JpwqR+cDUj1UtAKR2Js4QGMwX5AM5guSwXxBMpgvSAbzBclgviAZzBcAAAA0lUAooiUrt2vR8m1aubFMoXAsjBsL4EYsu9nH4DAN9S7Mjgd3D+iWo4w0V7OfFwAAAADamnYV5H3ttdc0YcIEFRQUNLq/JA0fPrw5h9Xu9OjWSX8MjNL7gYH6w4E75PhhoSJF36nq5Vvl7DVa7vGnypHfLdXDBAAAAAAAAAAAAPYb1YGwFq/crkXfb9XiVdsVDDX+Q2KmYcjpMOR0mNFHpymnacYejcRHh1nbL+Ex+pXucahv1xz17eqVx+VoxmcMAAAAAO1DqwryVldX691335Ukbdy4URUVFXrjjTckSRMmTFB+fr7OPfdcbdq0SfPnz0/Y95tvvtHKlSt1/vnnN3jsa6+9Vr169dKQIUPk8Xj08ccf69FHH9WUKVMI8ibJ43KoW6dMrd9qa2WXqRo9drqCi15SaPn7Cq/9UuG1X8nZ/2B5xp0kM7tTqocLAAAAAAAAAAAAtEtV/rC+/qFYn3+/VUtW7VA4Uhve7ZiTpnEDCzS8XwdlpjnlcJhyJYRua5dN00jhswAAAACA/VurCvJu375dV111VUJbzfpjjz2miRMnyrIsRSKRevvOmTNHbrdbU6dObfDY/fv315w5czR79myFQiF169ZNl1xyiS6++OKmfyL7gT6F2Vq/tUJrNvs0dmA/pR12gVwjpiv4+QsKr/5c4RUfKLzyY7mGHCn36ONlpntTPWQAAAAAAAAAAACgzauoDunLFdu06PttWrZ6hyKWHd9WkJeu8YMKNG5ggXp2zpJhENAFAAAAgNauVQV5u3fvru+//363fR5//PEG26+//npdf/31u9xv1qxZmjVr1j6ND7V6F3r13tdFWl3ki7c58roq/egrFNm6SoHPnldk4zKFls5X6Lv35B4xVe4R02S4M1I4agAAAAAAAAAAAKDt8VUG9cWKbVr03VZ9t640IbzbtWOmxg3spLEDC9S9UybhXQAAAABoY1pVkBdtR58u0Qq7q4vKZdm2zDpvCDgK+irj2F8qvPEbBT79r6xtqxX84hUFl70lz+jj5BpylAynO1VDBwAAAAAAAAAAAFq90oqAFn2/TYu+36rv15fKrs3uqkdBlsbGwrvdOmambpAAAAAAgH1GkBd7pVunTLmcpqoDYW0tqVaX/PqVdp3dhshx0k0Kr1mk4GfPyyotUuDjZxRcMl/usSfKNeAQGaYjBaMHAAAAAAAAAAAAWp8dPr8Wfb9Nn3+/VT9sKFOd7K56dcnWuIGdNG5ggTo38Lc5AAAAAEDbRJAXe8XpMNWzc5ZWbvRpdZGvwSCvJBmGIVefcXL2Gq3wig8V+PxF2ZU7FHjvEYW+fl3u8afI2Wcct/gBAAAAAAAAAADAfmlbaXU8vLtqky9hW7+uXo0dWKCxAzupU256ikYIAAAAAGhOBHmx1/p08caDvAcN7bLbvobpkGvgoXL2m6jQt+8o+OWrsso2y7/gfpkde8sz4VQ5ug0l0AsAAAAAAAAAAIB2r2h7pT79Zos+/26b1m4pj7cbkvp3z9HYQQUaO6CT8r1pqRskAAAAAKBFEOTFXutT6JUkrS7y7aFnLcPplnv4VLkGTlZwyZsKLn5DVvEaVc/9sxxdB0cDvQX9mmvIAAAAAAAAAAAAQIup9Ie0rbRaW0uqta20Wtt9Aa3ZXK41df6+ZhjSoJ55Gjuwk8YM6KTcLE8KRwwAAAAAaGkEebHX+nSNBnnXbalQOGLJ6TAbva/hTpdn7ElyDTlSwS9fVeibtxXZ9K2qXvqDPIecK/eQI5pr2AAAAAAAAAAAAECTCEcs7SgPaFtpde1XSbW2lfq1rbRaVYFwg/s5TEODeuVp3MBOGj2gk7wZ7hYeOQAAAACgtSDIi71WkJeudI9T1YGwNhVXqmfn7KSPYaZ7lXbwGXIPP0aBT59TeOXHCi56Sa6Bh8hwuJph1AAAAAAAAAAAAEDjVflD2lpaG86t+7W9LCDLtne7f06WW51y09UpJ12d89N1QM989e2SpTSXo4WeAQAAAACgNSPIi71mGoZ6d8nWt2tLtLrIt1dB3vixsjsq7fALVVn0neyqUoVXfirXgElNOFoAAAAAAAAAAACgvohlaYevtqpu3dBucWm1Kv0NV9Wt4XSY6pSbFg3r5qarIPbYKTdNHXPT5akT2HU6TeXlZaqkpFLhsNXcTw0AAAAA0AYQ5MU+6dvVGw/yHjaq2z4dy3A45Rp6lIKfPa/gknly9j9YhmE00UgBAAAAAAAAAACAqIhlafEP2/XOlxv17doSRazdV9X1ZrpjAd3awG7NV06WWyZ/0wIAAAAA7CWCvNgnvbt4JUmri8qb5HjuwUco+MUcWdvXKlL0vZxdBzXJcQEAAAAAAAAAAICyioDeW1ykd7/aqB2+QLw9oapuTro65aUnrHvcjt0cFQAAAACAvUeQF/ukT2G2JGnjtkoFQpGEWwPtDSMtS64BByv07UKFlrxJkBcAAAAAAAAAAAD7xLZtLV9fqne+3KhF32+LV9/NSnfp0BGFOmREoTrnZ1BVFwAAAACQEgR5sU/ysj3KyXSrrDKo9VsqdED3nH0+pmv4MQp9u1DhtV/JKtsiM6dzE4wUAAAAAAAAAAAA+5PqQFgfLt2sd77cqE3FlfH2ft28OnJ0d40b1EkuJ5V2AQAAAACpRZAX+8QwDPUp9OqrH4q1qsjXJEFeR25XOXqMUGT9YgWXzlfapLOaYKQAAAAAAAAAAADYH6zbUq6FX27UR8u2KBCKSJLcLlMHDe2iI0Z3U8/O2SkeIQAAAAAAtQjyYp/1KczWVz8Ua02Rr8mO6R5+jKrXL1bo+//JM+5kGZ7MJjs2AAAAAAAAAAAA2pdQ2NLn32/VO19s1A8by+LthR0ydOSY7jpoaBdlpPGnUQAAAABA68N/rWKf9Sn0SpJWN2GQ19FtqMy8brJKNir0/Xtyj5jeZMcGAAAAAAAAAABA+7CttFoLv9qo/31dpIrqkCTJYRoaM6CTjhzTTQN65MowjBSPEgAAAACAXSPIi33WOxbk3VJSrUp/SJlprn0+pmEYcg0/RoH3HlFw6QK5hh0jw3Ts83EBAAAAAAAAAADQtlmWrSWrtuudLzdqycrtsmPtedkeHT6qqw4d2VW5WZ6UjhEAAAAAgMYiyIt9lpXuUkFuuraWVmtNUbmG9slvkuO6DjhIwU+fk12xXeE1i+TqO6FJjgsAAAAAAAAAAIC2x1cZ1P8Wb9LCLzdpu88fbx/aJ19Hju6mEQd0kMM0UzhCAAAAAACSR5AXTaJ3Yba2llZrdZGvyYK8htMt15AjFPziFQWXzCPICwAAAAAAAAAAsJ+xbVs/bCzTO19s1GffbVXEitbfzUxz6pARhTp8VDd1zs9I8SgBAAAAANh7BHnRJPoUevXpt1u1usjXpMd1DTlSwa/mytrygyJbV8pR0K9Jjw8AAAAAAAAAAIDWpzoQ1sffbNE7X2zQhm2V8fY+hV4dOaabxg8qkNvlSOEIAQAAAABoGgR50ST6FHolqcmDvGZGrpwHTFR4+QcKLn5T6VMua9LjAwAAAAAAAAAAoPXYWFypt7/YoI+WbpY/GJEkuZ2mJg7prCPGdFPvLt4UjxAAAAAAgKZFkBdNolfnbBmGVFoRVEl5QHnZniY7tnvYMQov/0Dh1Z/LqtguM6tDkx0bAAAAAAAAAAAAqWXZthav3K4Fn6/XN2tK4u2d8zN05OhuOnh4F2WmuVI4QgAAAAAAmg9BXjQJj9uhbh0ztWFbpdYU+ZSX3anJju3o2EuOwkGKFH2n0LK35Jl4epMdGwAAAAAAAAAAAKlRHQjr/SVFemvRBm0tqZYkGYY0un8nHTmmmwb3ypNhGCkeJQAAAAAAzYsgL5pM70KvNmyr1OrNPo0e0HRBXklyD5+q6qLvFPx2odxjTpDhSmvS4wMAAAAAAAAAAKBlbC2p0oJFG/T+4iL5gxFJUobHqckju+rIMd3UMTc9xSMEAAAAAKDlEORFk+lb6NX7i4u0epOvyY/t6DVShrezbN8WhZa/L/fQKU1+DgAAAAAAAAAAADQP27b1zdoSLfhsvRav3C471l7YIUNTxnbXwcMK5XE7UjpGAAAAAABSgSAvmkyfQq8kac3mctm23aS3OjIMU+5hRyvw4RMKLp0v15AjZRhmkx0fAAAAAAAAAAAATS8QiuijZZv11ucbtLG4Mt4+ol8HTRnbXUP65Mtswr8pAQAAAADQ1hDkRZPp1ilTToepSn9YW0ur1Tkvo0mP7xp4iAKfvyC7bIsi676Ws9foJj0+AAAAAAAAAAAAmsYOn19vfbFB7321SZX+sCTJ43LokOGFOmpcd3XJb9q/IwEAAAAA0FYR5EWTcTpM9eycpVWbfFpd5GvyIK/hSpNr0GEKLX5dwSXzCPICAAAAAAAAAAC0IrZt64eNZZr/+QZ98f02WbYtSeqYk6YpY7vrkBFdlZHGnycBAAAAAKiL/1JGk+pT6I0GeTeV68AhXZr8+O5hUxRa8qYim75VZPs6OTr0bPJzAAAAAAAAAAAAoPFCYUuffrtFCxZt0NrN5fH2QT1zdfS4Hhp5QEeZppHCEQIAAAAA0HoR5EWT6lOYLUlavdnXLMc3szrI2Wecwqs+VXDJPKUffmGznAcAAAAAAAAAAAC7V1YR0DtfbtTCrzbJVxmUJLmcpg4a2llHje2hHgVZKR4hAAAAAACtH0FeNKk+hV5J0rrN5YpYlhym2eTncA8/RuFVnyr8w8eyJpwqMyO3yc8BAAAAAAAAAACAhq3Z7NP8zzbo02+3KGLZkqS8bI+OHNNNk0d2VXaGO8UjBAAAQFOxbVt2sFq2nZ7qoQBAu0WQF02qc36G0j0OVQci2lRc1SyftHZ0PkBmQT9ZW1cq9M078ow7ucnPAQAAAAAAAAAAgFoRy9IXy4s1//P1+mFDWby9Xzevjh7XQ2MGdJLT0fQFXgAAANA87JBfdrVPVlWZ7KpS2dU+2dVlsquij1ZVWXS9ukyKhFXmcMnIKZDp7SIzp7OMnM4yc7rIzOkiI90rwzBS/ZSAdsm2LMmQDIP/3mrPCPKiSZmGod5dvPp2bYlWF/ma7ZZJ7uFT5X/r7wp987bco46V4eST3QAAAAAAAAAAAE2t0h/Swi836u0vNqqkPCBJcpiGJgwu0JRxPeJ3awQAAGhNbNveL4OldjgYC9/WBHTL6gR0y2RV17YpHEju2JGQ7B0bZe3YWH+jK11mPNjbOWHZ8GQ20bNr22wrLKtsq6ySjbJKiyQrIjnd0cyT0y3D4apdd9RpT9jukUzHfjm39wcJc6RkU+1jWZFkS0ZmrszMfBlZ+TIy8+LLZmZ03UjPkWES9m2rCPKiyfUuzI4HeSeP7Nos53D2GSsjq4Psiu0K/fCR3IMOa5bzAAAAAAAAAAAA7I9s29bH32zRf95aofKqkCTJm+HS4aO76fDR3ZSb5UnxCAEAdrBaVuUO2RU7ZFXuUChQITPHq6DlkuXKlJGWJcOTJSMtU3KlE/xCu2FbkWgF2YodsipLZFdul1VRIruyZn2H7KoyyeWRkZ4jMyMnWjE2PUdGbDnaVvPlleFonREqOxyQ7a+IfgUqY4+x9ZqAbp3QrkLVyZ3A6Y6/Lmad16e2zSsjI0eurBxlu8MqWbtKoR1Fsso2yyrbIqtsi+zyYilULat4jaziNfVOYaR7ZXo7y8jpIjO3TtjX27ldFu6zI2FZvi0NhDE3R8O7+8owJKdn98Hfuttij4Y7PfY7IUuK/W4wPFkyPJkyTMe+jwuNtrdzxK7YrkjFdmnLLjoYDhmZuTuFfPNkZObLzMqXkZlP2LcVa52/hdCm9ekS/eT16iJfs53DMB1yD52iwCfPKLRkvlwDJ/MfHQAAAAAAAAAAAE1ga0mVHp+3XMtW75AkFXbI0IwDe2nC4M5yOfmjLwA0N9u2pWBVPJBoVZbIrtiRsGxV7pBC/nr71m+JMRy1oa20WHBr5zBXPPhbZ7mVhhubim3bsqvLYoHEzbJjj1bZFlnlxdHwW+y1UOw1S3iddm7zZLbLYGJLsq2w7MrS2kBubL7blSWyYj8HdnWZZNt7PliwWnawWpGyzXvu68msH+7NaCAEnJa9V6FH24pEg7iBCtn+SqkmkBtbTwjoBmpDu4qEkj6XHM7484g/pwxvneeVGw/oGq60Rh3ScJpy5WbKZWfJ6Dos8bmFg7LKt0VDvWWbE0O+VaWyq32KVPukLSt2Pmo0aFivim8XGdkdW3241I6Eo881HsTcKKt0k6zSLZK9izCm0yMzr6vMvK4ynB7Z4aAUDkYfIyHZ4YAUDknhgOxIqM62YO2ct20p5Jcd+x3QiJ+EPXNnNHxt2/l3RJ0+cnrIau3BXs0RV5rM3OgcceR1i88XGWb0Ohi/Lsb+jVARvT7aVSWSHZFdsV12xXZZuxqUYcrIyE0M+Wbmy8iKhX8z86PXhlb+89cete9/cSElam6htHFbpYKhiNyu5vnBdg2arMCil2SVbFBk4zdydh/aLOcBAAAAAAAAAADYH4Qjlt78dJ1e+WCNQmFLToepEyb11rSJPeV0EOAFgKZQG9LdOYgTCy3GwroNhXQb5MmM31LbkZkjlxFWwFcmy18eDwdGA2CRWPXOJAtyudKiga5dBVdrwoCxwKDcGa0y2GUHKuNh3ZqAoRULHO7utY5WQy1P7mROd4Oht4TXcafwtDwZMoza37W2FZbCtaG+miBfYuiv7no0+Fc3CLinfRQJq8zplExXrHqnR3K6ZDg9ksOVWN3T6Y5V//TIcLrqV/9sqCporCKoHK74nLAjYdlVJbsMp0fDaGVqVDTRdNRWnYz9DJh1bzefkSuFA9FKtTWVa6vKosHthDZfNFAXqJQVqJRKNu3hxIaM9OzacG9N4DfdKzscSgzj+ivj6wpWJTePdn6uCXMqs97PX7zKcEZOi1fgNpxuOfK6yZHXrd42O1gdrTxa8zNXujm+rGBVvMJoZOOynQ7qiL7OuwyXxn526v48NVNlWTsS2imMGXss2yLZu4hLxsOY3eTIiz6aeV1lZOUn/Kw3egy2LVnhBkO/8Z/xSJ2f9fh6Tb+g7GBVvcrOCsYqOAerotu1tfGDMp0NhH2jj+GMbJVmpstfWa1IOBytMhv7sussy4rItiN72G7FlsOx7Vad7WHJsmRbkegHT9zpMlzp0erD7vTo77D4cm274UqX3Gl1lmPtDlfS3xtpH+ZIXleZud3kyI8+mvndotezXf38ZnXQrmZ4tFJ5WYPX1Zp/c9hVpZJt1f57Y1dPyDBqP9QQ+xBA/crmrfv3fltEkBdNLt/rkTfTLV9lUOu2VuiAbjnNch7DkynXwEMUWvaWgkveJMgLAAAAAAAAAACwl1ZuLNO/3/hOG7ZVSpIG98rTOdMGqnNeRopHBqSWbduyyzYrvGGpwhuWytq+XoY7rTYwFK9o2lBQr3VWNLWtSLRKZahadtAvO1Qdr1qpSCgagsvuJCOrQ6sbe2tmh4P1b3vvL68N0NStpBsONu6gnsz4rbB3vjV2TXjXcHni3Z1OU3l5mSopqVQ4XBvPaXhsdat/1gl11awHKhKqPtoV2xs3ZtNZJ1zolVkn8BMPA6XXhA3TmjT8Y4eD0cBg6ebYY2110N2HcQ0Z2R3rVAONPWZ3km2F6rxeDb+GirdXRgNb4aDscDQk1WiGIbkzosG0cGjXlRqbmN3IqbhvDMkZCwsHqtT4kG5s3mfVme91l9O9jQpEmrmFu91u25YUqIqFe8vi4d7awG9ZbQjYXy7Zdp1Q/IbGvQR1xSuf1g+l1q+OHV1v6p+VlmS40+Xo2FuOjr0T2m3bjv4sxX9eEyv5KhKMVvOtKk3uhO70XQTpG/ggwk6vrx0JRcdRUzm1Jozp27qHMGZiWNfM20MYcy8YhhH9GXK4ZHgym+y48UrR8d8BlTuF0etXibYDFVIkLFnh3X6PqptslI1jhyT5y/etQrHp3EMAOC0eFraryxo5R9LrVddtljliOmRk5UtZ+bsJ+1rR61mdSr7xkG/83yul0Q//1Hxv9/Trf+ff+3UrmyeEgJv+9357w7+60eQMw1CfLtn6euV2rS7yNVuQV5Lcw45RaNnbiqxfrEjpJjlyuzbbuQAAAAAAAAAAANqbKn9Yz7+3Ugu/2ChbUla6Sz856gAdNLQLf2TFfssOVCq88RtFNixTeMOSegFGuzLJA+6pomkDgS650yUlBtRsKywF/bLjIdzqOoHcaChXNct1wrl2yJ/Qt9EhUsOQkZEn09spGnLM7hQN+MaWjczcvaoq2NrVhPrqVdXc+bb3O1XcbPTrGmOkZUfDiJl5MrM61FYRjd/qOi9aGbUJGDXVUjPzGr2PbVvROdNQgLVuuKu6NvCoYFU02FVZG2LdbRzV4a4T7q1TWbSm0l/dtlhg2bbCssuLd6quG33cU9jYyMiNhXSjQV0jp0s0sOvttNdVGBt8zWper12EpXduV8gfDU0HGrq4GA1Wya2tgBvb1lAlXcfOFXNjFXVjlXWdbre8WW6V7ShTOOBvoHpvKHF95wq/kVAD1T/r9I2H2uzoes3PiOmsUz23NqSeGNLNbrHri2GYUlqWHGlZkupXlK3LtqxoQL+hCr/+chkOd2LF5RaqGNsWGYYhIy1b6pItR5f+Cdts24q/tok/S5W7/JmKVzyu+d1Xvq3xgzEdMjyZ8aB2g1zpMvNjgd3cuoHdvDb9b2bDdMhI90rp3kbvY9vRn+nEoG9lwroRrJTbZSoYtmUbpmQ4JDP6ZZi1yzId0erL8XUz1se507pjt8cwDEf0gxdBf8K/jRr776R4ZXYrHJ0HexMIdqfXhrpj1XXN3K6tao4YpikjM0/KzJOjoF+DfeJh36raDzFYO13zatr26fd+nQq/kaxchYaOl4zGz8P2iCAvmkWfQq++Xrlda4qSvC1HksycznL2GqXw2i8VWjJfjkPPbdbzAQAAAAAAAAAAtAe2bWvR99v01ILlKq2IBmsmDe+i0484QNkZ7hSPDmhZtmXJ2rZK4Vhw19q6KrGqmumUo3CAnN2HydG5v+xIaDfhvOi6/BWyg5V7V9FUioZoPVkqT0tXJOCPV8ttUg63DHesspw7I1plznREq7T5iqOBvcodilTukIq+r7+/6ZSR3SEW8O0oI7tAprc28CtPZsqCK7ZtSaFA/bBOsHqPwcpGVwxtiGHWr8ycUEk3rzao6Gzd11rDMKPfwyQqP9qRUDTgWDfcWGfdrvbFK5wqFAuOlhdHg7l7OrgrTYY7Q3ZV2e6r1bozaqvq5napXfZ2jlZWbEYJr5m3oNH7Ra8plbIDVdFwWp3wrUxns/0cOZym3HmZcroqpfAevwNJs62wFA7JDgeij5FgNMCelt1qQm3JMkwzWk06I0dSj1QPp90yjNqwYWPFK8vGAr/a04cxan5fR0KSFYlVWFadMGZtWNfM6yYjI7fNztumZhiG5PJEP2CR1aHBPruqEN9a2ZYlhf21gd9gVYN3LrCD1fEwsOHJiM+P9jRH6oZ998QOB6MfbqiqCfcmVjVv7O/9oKTAl6/Ke/bfmu15tQUEedEsehdGE/KrinZ3e4qm4Rp+TDTIu/wDecafEv2EKgAAAAAAAAAAABq0w+fXE/OW66sfiiVJnfPSdc60QRrcq/FhCaCtsyq2K7xhqSIbliq88Zt6lTDN3EI5ug+LhncLB8WrgSYjsaLpLm5P3VBVwXAgeut2f7nC/gb+3up0y3ClxwK40ds8G+4MyZ0mw9XAbaDdabXrNdvdadFqd7scux0NYJQXyyrfJsu3rXa5vDgaSrbCssu2KFK2peHqa660OiHfTjK9dZazOzX4miYGaepW0tt1kCZecThUd5s/6e9XQ+Pf/W3vE6soG2lZ0de5HYR49pbhcMnI6rDLYFdddjgQD/pYdSr8xSv81gSAq8qkSDAeiJckOdwJlXXN3C7RoG5ul+j3o419DwyHS0ZGrpSRm+qhNCnDdEpuZ7MHqAFp7yrLSrFrUex3sZGW3W7CmEiOYZqSOyP67yk0muF0N/73fihQL9xb80Ef+cvlHTB6zx/qaecI8qJZ9CnMliRt2VGlKn9IGWn7fhuKXXEUDpLZoaes7esU/HahPKOPa7ZzAQAAAAAAAAAAtFWWZWvBog168b1VCoQicpiGZhzYS8cd3EsuJ7d5RvtmhwOKFH2v8PpoeNcq3ZTYwZ0uZ7eh8fCumd1xn8+ZWNG0c+PHGqvO6QhVKSvNVnm1LcvhqQ3vtsBt2Q3DiAcLHZ0PqD9GKxKt3FteLNu3LR7wtcqjgV+7qlQK+WXtWC9rx/qGz5GWHa34FgnVv7V1kz0RRyy4XCfYXKdarmrCuTWB3LphXQdxiuZkOD0yvJ0kbyftbkbbNVWtq8uiQbuMPBmZudGfLwDYR4bTIyNr15VlATQNw+WR4SqQvAX1fu87naZyYhWc92f8yxPNIjvDrY45aSou82vN5nIN6Z3fbOcyDEPu4VPlX/iQQssWyD1y2m4/PQoAAAAAAAAAALC/Wbu5XI++8Z3Wbo5W9+zfPUfnTBukbh0bf8t0JMeOhGVXbK+tYFq+Tf6KYvnDVQobbtnONBmxCqoJIcOadVdabQDRld7ioULbtqO3vw3WqYLaQOXT2vVYxdRIOFbRLkdGuldmRo6M9OiykZEjI80brXrWAuO3SjYosn5ptPLu5u+lSLi2g2HI7NRXzu7D5OwxXGanPi0SkG2MmuqcDme+0vIyVd0Kb0ttmI54ZV11HVxvux0Oyqoolu2rqeK7LRb4ja4rWBW9FXNDFYclyXTEqgzXVBFO26nKcE3V4Z1+huIVh6M/Q3K4qKzYxhmGEf/+AgAAtFekHdFs+hR6VVzm1+oiX7MGeSXJ2W+CjE+ekV1VqvCqz+Q64KBmPR8AAAAAAAAAAEBb4A+G9dL/Vmv+5+tl21KGx6nTjuinQ0d2lUm4bZ/YtiW7sjRegTQeViwvluXbJruqRLLtevuF9vaEDle98GJC0NedLtVpj/d1OKO3sg3VDeTGArix8G08rBuqDewqWC3ZzREeNWSkZyeGe9NzZGZ4Y2050baMnGjl1CSqblr+ckU2LFN4wxJFNiyLVoWte+bMfDl7DJOj+3A5uw2JVcpFczCcbjlyu0q5XRvcbgcqowH3qlLJ6ZbhzojN2WiA3XA03x1fAQAAgNaGIC+aTZ9Crz77bqtWF+3iU5RNyHC45Bp6lIKfv6jgknly9juQT1YCAAAAAAAAAID92tc/FOuJed9ruy8gSZowuEAzj+qvnCxPikfWNti2LQUq4wFdyxetqlsb2N0uWeHdH8ThlpndUUZ2R5nZneTMLVBWx06qLPMp4q+qrWobaiBUW9MeDkaPFQnJrg5J1T7Vjwc3JyMhIJxY+XSnKqmudMl0yPaXy6oqk11dJrvaJzu+XC7JjrZV+xpxajMa9q0J9yYEfqMhYEmKbPxG4Q1LZW1bI9V9dRxuOboOkrP7MDm6D5OZW8jfEFsJw5MphydTUq9UDwUAAABIOYK8aDZ9CrMlSauLGvEf4U3ANfgIBb+cI2vbakW2rJCzy4AWOS8AAAAAAAAAAEBrUloR0FMLVujz77ZKkjp403T21IEa0a9DikfW+tjBalkV22MB3Vgl3Zrl8m1SyL/7AximjKwOMmNBXSO7o0xvp/iykZ6TEBx1Ok1l52UqXFKpcLhx1W5tKyKF/DuFfhMr59rBKtmxPoq128Gq6HIkFA3YutOiVU9jFU9VJ4xruDNqK6HGq/7Glp3upKri7v65WLL95dFQb1U05Fsb+K1ts6vKZAcqJNuSXVUardq6vXHnMPN7yNF9WDS826W/DKe7ScYOAAAAAM2FIC+aTa8u2TIMqaQ8oLKKQLN/uttM98rV/2CFvntPocVvEuQFAAAAAAAAAAD7Fcu29e5Xm/TcwpWqDoRlGoaOGd9DJx7SRx63I9XDa1G2bUuhalkVO2RX7pBVWSK77nLlDlkVO/Yc1JWiYdxYODce2PVGl43MfBlm8762humQPJkyPJnNep6WYJhmtIpuRo60h1y5bYVlV9cJ/VaVyar21Qn8xkK/4aAcnfvL2SNWdTcjt0WeCwAAAAA0FYK8aDZpbqe6dsjUxuJKrS4q16j+zX+bJtewqQp9957Ca7+Q5dsm09up2c8JAAAAAAAAAACQahu2VeixN77XDxvLJEm9u2TrvOmD1LNz9j4d17YtKRSQnC4ZZuv406Jt21KwSlblDtkVJdHHyh2yKqIB3ZqwbmNCupIkd0Y8pFsT0I1W1I21UdE1JQzTKSMzT8rMS/VQAAAAAKBZtY7/2ka71afQq43FlVpV5NOo/h2b/XyO/G5ydB+myIalCi5boLSDZjb7OQEAAAAAAAAAAFIlGIpozodr9MYn6xSxbHncDv1ocl8dNaa7TNPY4/62bcsOVMj2bZNVXiyrfJvs8rrL2yUrHO1smJLTHQ22OlwynJ5owNfpia27JadbcsT6OGvbDIe7dt/4+i6OYdu1VXMrS2RXbI+t1y4rHGjcC+TJlJmZJyMzX2ZmvoysvOhj3WVX2j58BwAAAAAA2DcEedGs+hRm6/0lRVpT5Guxc7qHH6PqDUsV+u5decaeJMOd3mLnBgAAAAAAAAAAaCnfrNmhx978XltLqiVJo/t31JlHD1C+NzGYaof80VCuLxrOjQZ0a5aLG1+51rakkF92rL/dpM9mL3gyY+Hc/NqwblZ+LLQbXTdczX/HSAAAAAAA9gVBXjSr3oVeSdLqIp9s25Zh7PmT3/vK0X2YzNxCWaVFCn3/ntzDpzb7OQEAAAAAAAAAAFqKryqoZ976QR8t2yxJ6pDl0NmTOmlIJ0vWho8USKioWyzbX77HYxoZuTKzO8nI7ijT26l2ObuTjHSvFAnJDgdjjwEpHFsPB2VHYo+7Wg+HpD31iYSiVXbtaDzY8GTJyMqXkZlXJ6wbW4+1G05CugAAAACAto8gL5pVj4IsOR2GKv1hbSvzqyC3+avjGoYp17BjFHj/3wouXSDX0KNlmGaznxcAAAAAAAAAAKA52ZGwvvv0Y33/xSL1tco0PrtCXdOqlR6pkD6zVb27nT2ZMmuCudmdYmHd2HpWBxlO9+5P7nTL8GQ25dOpx7ZtyYpIsmU4XM16LgAAAAAAWguCvGhWToepHgXZWl3k0+pNvhYJ8kqSa8DBCnz2nOzybQqv/UKuPuNa5LwAAAAAAAAAAABNyQ5WK7x+icJrFim49mt1D/vVvW7GNRJ7dLhlejtGQ7p1A7uxCruGOyMVw0+KYRiSgz9fAgAAAAD2L/yXMJpdn8JYkLfIp4lDOrfIOQ2nR+7BRyj41asKLZlHkBcAAAAAAAAAALQZVlWpwmu/UnjNF4ps/EaywpIkU1KZla7ijL4aOHSgnDkFMrOj4V0j3RsNwgIAAAAAgDaFIC+aXZ9Cr6SNWlPka9HzuoYepeDi1xXZvFyRbavl6NSnRc8PAAAAAAAAAADQWFbZZoXXfKHQmi9kbVkpyY5vs7M768OyLvqkvKvcXfrp2plj5HKaqRssAAAAAABoMgR50ex6F3olSWu2lCtiWXKYLfPGkpmZJ2ffCQr/8JGCS+Yp/chZLXJeAAAAAAAAAACAPbFtW1bxGoVXL1J47ReySjYlbDc79ZWz9xjZ3Ubqzrmbtba0XJ3z0vWLU0cS4gUAAAAAoB0hyItmV5ifoTS3Q/5gREXFVepekNVi53YPn6rwDx8pvPJTWRNPl5mZ12LnBgAAAAAAAAAAqMu2wooULY+Fd7+UXbmjdqPhkKPrIDl7j5Gz9xiZmXmyLFv3vbBEazeXKyvdpatPH6msdFfqngAAAAAAAGhyBHnR7EzTUO8u2fpuXalWF/laNMjr6NRbji4DFNm8XKFlb8kz4dQWOzcAAAAAAAAAAIAdCii8frHCa75QeN3XUrCqdqPTI2fPEdHwbo8RMjyZCfv+5+0V+uqHYjkdpq48ZYQ652W08OgBAAAAAEBzI8iLFtG70BsN8m4u16EjW/bcruFTFdm8XMFv35F7zPEynJ6WHQAAAAAAAAAAANivWNU+RdZ+pdCaLxTZuEyKhOLbjLRsOXuPlrP3GDm6DpHhdDd4jPmfr9eCzzdIki48brAO6J7TImMHAAAAAAAtiyAvWkSfQq8kaXWRr8XP7ew1WkZ2J9nl2xRa/oHcQ45s8TEAAAAAAAAAQFNYuXKlbr31Vn355ZfKzMzUiSeeqKuvvlpud8NBwBrl5eX6v//7P82bN09+v18jRozQr371Kw0ePLiFRg60f5GyrQquXKTwmkWKbFkh2XZ8m5HdSc4+Y+XsPVaOgn4yTHO3x/pyxTb9Z8EKSdKph/fThMGdm3XsAAAAAAAgdQjyokX0KcyWJG3YWqFQOCKX09Fi5zZMU+5hRyvw0VMKLZkn1+DDZRi7f4MMAAAAAAAAAFqbsrIynXvuuerdu7fuvfdebdmyRX/84x/l9/t100037Xbfa665RkuXLtUvf/lLdezYUY8++qjOPfdcvfzyyyosLGyhZwC0P7ZtK/DNQm345i0Ft65N2GZ27CVn77Fy9h4jM6+bDMNo1DFXF/n04CvLZEuaPLKrpk/s2QwjBwAAAAAArQVBXrSIDt40ZWe4VF4V0rqtFerXtWVv/+QaeKgCn78oq2yzIuuXyNlzZIueHwAAAAAAAAD21X/+8x9VVlbqvvvuU25uriQpEono97//vWbNmqXOnRuu2PnVV1/pvffe0wMPPKAjj4zesWzixIk66qij9PDDD+s3v/lNSz0FoF2xA5Xyvztb4TWLog2GKUfhQDl7j4mGd7M6JH3M4rJq3f3cYgVDlob1yddZxwxodAAYAAAAAAC0TZQlRYswDEN9Cr2SpDVF5S1/fne6XIMmS5KCS+a1+PkBAAAAAAAAYF+99957Ouigg+IhXkmaPn26LMvSBx98sMv9vvnmGxmGoUmTJsXb0tPTNW7cOL3zzjvNOWSg3Yps+UGVz98UDfGaDuUfcZZyzr9PGcddL/ewo/cqxFvlD+vu/y6WrzKo7p0ydelJw+R08Kc8AAAAAADaO/7rHy2mJsi7apMvJed3D5siGYYiG5cpsmNDSsYAAAAAAAAAAHtr1apV6tu3b0Kb1+tVp06dtGrVql3uFwwGZZqmHA5HQrvL5dLGjRvl9/ubZbxAe2TblgJfvaqqV26XXbFdhrdA2T/6rXIPPllmWtZeHzccsXT/i0u0sbhSuVluXX3aSKV7uLEmAAAAAAD7A94BQIvpU5gtSVqzOTVBXjO7k5y9xyq8+nOFlsyT47CfpmQcAAAAAAAAALA3fD6fvF5vvfacnByVlZXtcr9evXopEonom2++0YgRIyRJlmVp6dKlsm1bPp9PaWlpezUmp7N91gtxxKqgOqiGijqsqjJVvvWgwuuXSpJcBxyozMPPlzM9U9LezxfbtvXI69/r27Ul8rgcuuYno1SQn9Fk40brwvUFyWC+IFnMGSSD+YJkMF+QDOYLksF8iSLIixbTO1aRd/P2KlUHwin5JLlr+NRokPeHD+WecKrM9PpvegMAAAAAAABAezJp0iT17NlTN998s+6880516NBB//znP7V+/XpJkmEYe3Vc0zSUl5fZlENtdbze9FQPAa1E9erF2vry3YpUlspwutXhmAuUPeqohJ+fvZ0vzyz4Xv/7ukimIV1/zjiNHtylqYaNVozrC5LBfEGymDNIBvMFyWC+IBnMFyRjf58vBHnRYrwZbnXwpmm7z681m8s1uFdei4/B0fkAmZ36yNq2WqFv3pFn7IktPgYAAAAAAAAA2Bter1fl5eX12svKypSTk7PL/dxut/72t7/pF7/4hY4//nhJ0oABA3Tuuefq8ccfV25u7l6Nx7Js+XxVe7Vva+dwmPJ60+XzVSsSsVI9HKSQbUXk/+xF+RfNkWTLzO+mrGMuVyS/u0pLo/N/X+bLR0s364nXv5MknTV1oA4ozFZJSWVTPw20IlxfkAzmC5LFnEEymC9IBvMFyWC+IBntfb54vemNqjZMkBctqk9Xr7b7/Fpd5EtJkNcwDLmHT5X/7X8o9M1bco+aIcPhavFxAAAAAAAAAECy+vbtq1WrViW0lZeXa9u2berbt+9u9x02bJjeeOMNrV27VrZtq3fv3rrllls0dOhQuVx7/x5pONz+/sBSVyRitfvniF2zKrbL/9Y/FNmyQpLkGnS4PAfPlO30NDgvkp0vy9eX6qE5yyRJx4zvocNHdWO+7Ue4viAZzBckizmDZDBfkAzmC5LBfEEy9vf5sueoL9CE+hRmS5JWF/lSNgZn33EyMvNlV/sUXvlJysYBAAAAAAAAAMmYPHmyPvzwQ/l8te+vvvHGGzJNU5MmTdrj/oZhqHfv3urTp49KSko0d+5cnXbaac05ZKDNCq35QpXP3xQN8brSlXbUpUqbfJ4Mp6dJjr95R5XufX6xwhFbYwd00ulHHtAkxwUAAAAAAG0PFXnRovp08UqS1qQwyGuYTrmGHqXgp/9VcMmbcvafJMMwUjYeAAAAAAAAAGiMn/zkJ3r88cd1+eWXa9asWdqyZYv+7//+Tz/5yU/UuXPneL9zzz1XmzZt0vz58+NtDzzwgHr16qUOHTpo9erVevDBBzVs2DD96Ec/SsVTAVotOxJS4ONnFFq2QJJkduqj9KMulektaLJz+KqCuuvZr1XpD6tPoVcXHj9EJn+nAAAAAABgv0WQFy2qV5dsGZK2+wIqqwwqJ9OdknG4Bx+u4Bcvy9q+XpGi7+TsOjgl4wAAAAAAAACAxsrJydG///1v/eEPf9Dll1+uzMxMnXrqqfr5z3+e0M+yLEUikYQ2n8+nO++8U9u3b1dBQYFOOOEEXXbZZTJNbtwH1LDKNqt6wQOytq+VJLmGT5VnwmkyHE3357RgKKJ7n1+sraXV6piTpitPHSGPy9FkxwcAAAAAAG0PQV60qHSPU4UdM7WpuFKri3wadUDHlIzD8GTKNeAQhb55W6HlHxDkBQAAAAAAANAm9OvXT48++uhu+zz++OP12q6//npdf/31zTQqoO0LrfhQ/vcfk0J+GZ4spR1xoZw9RzXpOSzb1r9e+1YrN/qU4XHq6tNGpqzgCQAAAAAAaD34qD1aXJ8u2ZKkNUW+lI7DEQvvWiUbUzoOAAAAAAAAAACQGnYooOqFD8v/zj+lkF+OwoHKOPUPTR7ilaTn312pz7/bKodp6IofDVfXjplNfg4AAAAAAND2UJEXLa53oVcfLN2s1UXlKR2HmddVkmSVFsm2bRmGkdLxAAAAAAAAAACAlhPZvl7+t/4uq7RIMgy5R58g95gTZZhNXwfn3a826vWP10mSzps+SIN65TX5OQAAAAAAQNtEkBctrk+hV5K0usiX0gCt6S2QDFMK+WVXlcrI5E0zAAAAAAAAAADaO9u2Ffr2HQU+ekqKhGVk5CrtyFlyxu7k19SWrtqux99cLkk68ZA+mjS8sFnOAwAAAAAA2iaCvGhxPQqy5DANVVSHVFzmV6fc9JSMw3C4ZHg7yS7bIqu0SCZBXgAAAAAAAAAA2jU7UCn/e48ovPpzSZKjxwilHX6hzHRvs5xv/dYK/f2lpbJsWwcP66ITJvVulvMAAAAAAIC2q+nvDQTsgctpqkdBlqRoVd5UcuR2lSRZpZtSOg4AAAAAAAAAANC8IltXqvKFm6MhXtMhz4E/Ufq0q5stxFtSHtBd//1a/mBEg3rm6rzpg1J2l0IAAAAAANB6EeRFSvQpjL4ptqaoPKXjMHOjt6+ySopSOg4AAAAAAAAAANA8bNtS8Ou5qnr5dtnlxTKyOynjhF/LPWKaDKN5/lRWHQjr7v9+rZLygAo7ZOjyHw2X08Gf5QAAAAAAQH3OVA8A+6fehdnSl6mvyBsP8pYR5AUAAAAAAAAAoL2xqn3yL3xIkfVLJEnOvhOUNvk8Ge6MZjtnxLL04CvLtG5rhbwZLl192khlprma7XwAAAAAAKBtI8iLlOhbU5F3c7ksy5ZppuZWUvEgbylBXgAAAAAAAAAA2pPwxm/kf+f/2bvzOLnqMt/j33Oqeu+uqu70viXpJCRBiUHWkDEgggiCKy4zMqK4MDOACMwojg4uw1XA63BfolfxCgMyjjrqjBhEMKCCsimLIJA02Uh3eqle0lXV1XvVOfeP6m6IEEh1nTqnls/79fJFuqrO8zxF//CPU9889R3ZkxHJV6Kykz6gknUnyzCy95mEbdv6z3t26qndoyrxm7rk3A1qCFVkrR8AAAAAAMh/BHnhiZZlVSor8WlmLqmB0Qm1NVR7MsdCkNeeGJM9OyWjlJtpAAAAAAAAAADkM9tKavbx2zX7+FZJtszaVpW/6R/kq2vPeu9f/bFXv3m8T4akj59zpFa1BrPeEwAAAAAA5DfT6wFQnEzT0PLmGknS3oFxz+YwyqpkVKS2A7OVFwAAAAAAAACA/Gbbtqa3fUOzj/9ckq2StVtU+c7PuxLi/eP2sP7r17skSe89dbWOWduY9Z4AAAAAACD/EeSFZ7paUgHavYMxT+dY2MpLkBcAAAAAAAAAgPw2132/EvuekHwlKj/171R+8gUy/GVZ79u974C+ffszsiW98fVtevNxHVnvCQAAAAAACgNBXnhmRcv8Rt5+r4O8rZII8gIAAAAAAAAAkM+s+AHNPPRDSVLZce9SyeoTXek7PDalf735Ec0lLG1YtUx/c9oaGYbhSm8AAAAAAJD/CPLCMyvnN/L2DsU1l7A8m4ONvAAAAAAAAAAA5DfbtjX9u1ukuSmZjatU8tozXOv7f3/2Z0Xjs1reXKO/e/tr5DP5+A0AAAAAABw+7iTAM/XBclVXlChp2do/HPdsDoK8AAAAAAAAAADkt8TOB5TsfUry+VV+8kdkuBSm3bk/qt19MZX6TV323tepvNTvSl8AAAAAAFA4cupuwr59+3TTTTfpySef1M6dO9XV1aU77rjjVa879dRT1dfX95LHn3rqKZWVlS3+HA6HdfXVV+v3v/+9SkpKdPrpp+szn/mMqqurHX0fODyGYWhlS0B/3jOqPf2xxQ29bjNrWyVJVjQs20rIMHPqPwsAAAAAAAAAAPAKrIkxTT/4n5Kk0mPeKd/8fX83bHu0V5L0xmM7VBcoV8LDbyAEAAAAAAD5KacSizt37tR9992n173udbIsS7ZtH/a1Z5xxhi644IKDHistLV3889zcnD760Y9Kkr72ta9penpa1157ra644grdeOONzrwBpG1lS43+vGdUzw/EPJvBqKqV/KVSYlZ2bFjG/IZeAAAAAAAAAACQ22zb1vTvbpVmJ2U2rFTphre41nskMqXHnxuWJJ3zV12u9QUAAAAAAIUlp4K8p556qk477TRJ0pVXXqmnn376sK+tr6/Xxo0bD/n83XffrZ07d+rOO+9UV1fqZkogENBHPvIRPfXUU9qwYUNGs2NpVsxv4d07OO7ZDIZhygy2yBrdp2RkQCZBXgAAAAAAAAAA8kJi10NK9vxJMv0qP/kjMkyfa71//XifbFt6zco6LW8JaGxswrXeAAAAAACgcJheD/Bippm9ce6//36tXbt2McQrSZs3b1YoFNJ9992Xtb54ZSvng7wDIxOamkl4NodZmwrvWpF+z2YAAAAAAAAAAACHz5qMaPrB70uSSl//Nvnq2l3rPT2b0H1Ppj5TOOP4Ttf6AgAAAACAwpNTQd5MbN26Va997Wt19NFH62Mf+5i6u7sPen7Pnj0HhXglyTAMrVy5Unv27HFzVLxIsKpUywJlsiXt83Ar78IWXisy4NkMAAAAAAAAAADg8Ni2rZnff0+amZBZv1ylG89ytf8Dfx7U1ExCTbUV2rB6mau9AQAAAABAYfF7PYATTj31VG3YsEGtra3q7e3Vt7/9bf3N3/yNfvazn6mjo0OSFIvFVFNT85Jrg8GgotFoxjP4/QWTiT6Iz2ce9M9s6GoNajQ2pH1D43rtKm9udll1bZqVZEcHC/Z36QY3zgsKB+cF6eC8IB2cF6SD84J0cF6QDs4L0sF5AQAgfYndjyjx/OOS6VP5yR+VYbr3kZdl27rnsf2SpNOO7ZBpGK71BgAAAAAAhacggryf+9znFv987LHHavPmzTrzzDN100036Qtf+ELW+5umodraqqz38VIgUJG12keuqtcfdwxp/8ikZ/8eZ5ev0oQkOzKgUKhSBjfdMpLN84LCw3lBOjgvSAfnBengvCAdnBekg/OCdHBeAAA4PNZUTDMP/IckqfToc+Rb1uFq/6f3jCp8YFIVZT6d9NpmV3sDAAAAAIDCUxBB3r/U2NioY445Rs8888ziY4FAQPF4/CWvjUajamlpyaifZdmKxSYzqpGrfD5TgUCFYrEpJZNWVnq0hMolSd3PH9DY2ERWerwa26iRDEPWzKQO9PXLrAp5Mke+c+O8oHBwXpAOzgvSwXlBOjgvSAfnBengvCAdhX5eAoEKtg0DABw188BtsmfiMpd1qHTj2a733/ZoahvvGza0qqKsID9qAwAAAAAALiqauwtdXV167rnnDnrMtm3t3btXmzdvzrh+IlF4H7K8WDJpZe09tjdUy5A0Ep3Wgdi0ApWlWenzyvwyahpkx4Y0O9onf1nAgxkKRzbPCwoP5wXp4LwgHZwXpIPzgnRwXpAOzgvSwXkBAODVze35oxJ7/igZPpWf/FEZPnc/6uobmdAzew/IMKQ3HdPuam8AAAAAAFCYCnIVRjgc1mOPPaajjjpq8bEtW7Zox44dev755xcfe+ihhxSJRHTyySd7MCUWVJb71bysUpL0/EDMsznMUGozsxUZ8GwGAAAAAAAAAADw8qzpcc38/nuSpNKNZ8lXv9z1Ge59tFeSdPSaBjWEKlzvDwAAAAAACk9ObeSdmprSfffdJ0nq6+tTPB7XXXfdJUk6/vjjVVdXp/PPP1/9/f3atm2bJOmOO+7Qb37zG5188slqbGxUb2+vvvOd78jn8+nDH/7wYu0zzjhDN954oy655BJdfvnlmpqa0nXXXadTTjlFGzZscP/N4iArmgMaGJ3U3oFxbVhV78kMZqhFyZ4nZY31e9IfAAAAAAAAAAAc2swD/yF7elxmbbtKX/821/vHp+b04NODkqTTj2UbLwAAAAAAcEZOBXlHR0d16aWXHvTYws/f+973dMIJJ8iyLCWTycXn29vbNTQ0pC9/+csaHx9XTU2NTjzxRH3iE59QR0fH4utKSkr03e9+V1dffbUuv/xy+f1+nX766frnf/5nd94cXtHKlho99Myg9rKRFwAAAAAAAAAA/IW55x9TYvcjkmGq/JSPyPCVuD7D/U/2azZhqbOxWkd0hFzvDwAAAAAAClNOBXnb29vV3d39iq+57bbbDvp548aNL3nsUJqamnTDDTcseT5kz8rWgCRp70BMtm3LMAzXZ/CFWiUR5AUAAAAAAAAAIJfY03HN/O5WSVLp686Sr2Gl6zMkkpbufWy/JOn04zo8+RwDAAAAAAAUJtPrAQBJ6mysls80ND45p9HYtCczLGzktScOyJ7zZgYAAAAAAAAAAHCw6Qe/L3sqJjPUqtLXv82TGR5/blhj4zMKVJbo+PVNnswAAAAAAAAKE0Fe5IQSv0/tDdWSpOcHxj2ZwSivllFeI0myIoOezAAAAAAAAAAAAF6Q2PeEErsekgxD5ad8RIa/1JM5tj3aK0k65eg2lfj5eA0AAAAAADiHOw3IGStbA5KkPQMxz2Ywa1slSVak37MZAAAAAAAAAACAZM9MaPp3t0qSSo56i3yNqzyZY09/TLv7YvKZht54dJsnMwAAAAAAgMJFkBc5Y3VbKsjb3RPxbAYz2CJJsiIDns0AAAAAAAAAAACk6Yd+IHsyIiPYrLJj3+nZHPfMb+M94cgmBavLPJsDAAAAAAAUJoK8yBnrOmslSc8PxjQ5nfBkBjNEkBcAAAAAAAAAAK8lep5S4rnfSzJUcfJHZPhLPZljbHxGf9wxJEk6/dgOT2YAAAAAAACFjSAvckZdoFxNdZWybam7d8yTGcxagrwAAAAAAAAAAHjJnp3U9O/+XZJUctSb5Wte49ksv3liv5KWrSPag1reXOPZHAAAAAAAoHAR5EVOWb88tZV3+z6PgrwLG3mjg7KtpCczAAAAAAAAAABQzGYe/qHsiTEZgSaVHfcuz+aYnUvqt0/0S5JOP45tvAAAAAAAIDsI8iKnHDkf5N3hUZDXqF4m+UolKyl7fNiTGQAAAAAAAAAAKFaJ/U9rbsf9kgyVn3yBDH+ZZ7M8/GxY8ak5LQuU6+g1DZ7NAQAAAAAAChtBXuSUtZ0hSdL+4QnFJmZd728YpsxQsyTJigy43h8AAAAAAAAAgGJlz05p+v5/lySVvOZN8res9W4W29a2R3slSW86pl2maXg2CwAAAAAAKGwEeZFTaipL1dFYLUna0ePNVl4z1CJJSo4R5AUAAAAAAAAAwC0zj/yX7PiojJoGlR3/Hk9n2b5vTH3DEyor8WnL61o8nQUAAAAAABQ2grzIOeuX10pK3STzwkKQl428AAAAAAAAAAC4I9H3rOa2/0aSVH7yBTJKyjyd555H90uSNh/VrMryEk9nAQAAAAAAhY0gL3KO90HeVkmSFSXICwAAAAAAAABAttlz05q+/2ZJUsmRp8rfut7TecJjk3py14gk6bRjOzydBQAAAAAAFD6CvMg5R3SEZBqGhsamNBqddr3/4kbesX7Ztu16fwAAAAAAAAAAisnMH34se3xERvUylR3/Hq/H0b2P7pctacOqZWquq/R6HAAAAAAAUOAI8iLnVJT5tbKlRpI3W3nNYJMkQ5qdlD0Vc70/AAAAAAAAAADFItG/Q3PP3CtJKt9ygYzSCk/nmZxO6Hd/Tn1j3+ls4wUAAAAAAC4gyIuctG55rSRvgryGv1RGTb0kyYoMuN4fAAAAAAAAAIBiYM/NaPr+myVJJetOlr/9NR5PJP3+zwOamU2qtb5KR66o9XocAAAAAABQBAjyIicdOR/k3dEzJtu2Xe9vhlokSVak3/XeAAAAAAAAAAAUg5k//kR2bEhGVZ3KTny/1+PIsmzd82ivJOm0Y9tlGIbHEwEAAAAAgGJAkBc5aVVbUH6fqbHxGQ0emHS9/wtBXjbyAgAAAAAAAADgtMTgTs09fY8kqXzLh2WUVng8kfSnXSMaiU6rqtyvTa9p9nocAAAAAABQJAjyIieVlvi0ui0gSdqxb8z1/mZtqySCvAAAAAAAAAAAOM1OzGr6vu9KslWy9g3ydxzl9UiStLiN9+SNbSor8Xk8DQAAAAAAKBYEeZGz1q+okyRt9yLIy0ZeAAAAAAAAAACyYubR/5YdDcuoDKnsxPd7PY4kqSc8rh09EZmGoVNf3+b1OAAAAAAAoIgQ5EXOWr+8VpK0oyciy7Zd7b0Q5LXjo7LnZlztDQAAAAAAAABAoUqGd2nuz3dLksq3fEhGWZXHE6Xc8+h+SdKx6xpUFyj3eBoAAAAAAFBMCPIiZ61orlFZqU/xqTntH4q72tssr5FRXiNJsqKDrvYGAAAAAAAAAKAQ2YlZTd93k2Tb8q/ZLH/nRq9HkiTFJmb18LOpzwJOP7bD42kAAAAAAECxIciLnOX3mVrbEZIkbd835nr/ha28VqTf9d4AAAAAAAAAABSa2cd+JisyIKMiqPJNf+31OIt++6c+JZK2VrYEtKot6PU4AAAAAACgyBDkRU5bv7xWkldB3mZJkhUZcL03AAAAAAAAAACFJDm0R7NP/VKSVPaG82WUV3s8UcpcwtJvHu+TJJ1+XLvH0wAAAAAAgGJEkBc5bSHI290bUSJpudrbDLVKIsgLAAAAAAAAAEAm7OScpu/7rmTb8q8+USUrXu/1SIv+uCOs6MSsQtWlOnZto9fjAAAAAACAIkSQFzmtvbFa1RUlmplN6vnBcVd7m6EWSZI1RpAXAAAAAAAAAIClmn3857LG+mVUBFR+0nlej7PItm1t++N+SdKpr2+X38fHZgAAAAAAwH3ckUBOMw1D6zpDkqTt+8bc7b0Q5I0Oyrbc3QYMAAAAAAAAAEAhsG1Ls8/cI0kq23yejPJqjyd6wc79Ue0Lj6vEb+rkja1ejwMAAAAAAIoUQV7kvPXLayVJ258/4Gpfo7pe8pVIVkJ2fMTV3gAAAAAAAAAAFAJrrF+anZL8ZfKvOMbrcQ5yz6O9kqRNr2lSTWWpx9MAAAAAAIBiRZAXOW/dfJB3V19Ms3NJ1/oapikz2Cxp/kYjAAAAAAAAAABISzK8S5Lka+ySYfo8nuYFI9EpPfbcsCTptGM7PJ4GAAAAAAAUM4K8yHnNdZUKVZcqkbS0uy/qam8z1CJJsiIDrvYFAAAAAAAAAKAQJMM7JUm+ptUeT3KwXz/eJ9tOfStge0O11+MAAAAAAIAiRpAXOc8wDK1fXidJenbfmKu9CfICAAAAAAAAALB0ixt5m9Z4PMkLZmaTuv9PqW/iO/04tvECAAAAAABvEeRFXli/vFaStMOjIG8y0u9qXwAAAAAAAAAA8p01FZMdDUuSfE2rPJ7mBQ8+PaDJmYQaayu0YdUyr8cBAAAAAABFjiAv8sJCkHfvwLimZhKu9X3xRl7btl3rCwAAAAAAAABAvlvYxmvWtsooq/J4mhTLtrXt0f2SpNOOaZdpGB5PBAAAAAAAih1BXuSFZcFyNdZWyLJtPdcbca2vGWqWZEgzE7Knx13rCwAAAAAAAABAvrPmg7y+ptUeT/KCp/cc0OCBSVWU+bT5qBavxwEAAAAAACDIi/yxsJV3+74x13oa/jIZNamv1bIiA671BQAAAAAAAAAg3yUXg7xrPJ7kBfc82itJesOGVlWU+T2eBgAAAAAAgCAv8ogXQV5JMkOpv5FPkBcAAAAAAAAAgMNjJxNKDu+RlDsbeftHJvT03gMyDOlNx7R7PQ4AAAAAAIAkgrzII+s6U0He3qG4xidnXetrhlolEeQFAAAAAAAAAOBwWaP7pGRCRlm1jGCz1+NIku55bL8kaePqejWEKjyeBgAAAAAAIIUgL/JGoKpU7Q1VkqQdPRHX+r6wkbfftZ4AAAAAAAAAAOSz5OAuSZLZtFqGYXg8jRSfmtODf04t7HjzcR0eTwMAAAAAAPACgrzIK+uWp7bybt835lrPF4K8bOQFAAAAAAAAAOBwJMM7JUm+5tUeT5Lyuyf7NZuw1NFYrSM6Ql6PAwAAAAAAsIggL/LKeg+DvPb4qOzEjGt9AQAAAAAAAADIR7ZtKxlObeT1Na3xeBopkbR0z2P7JUmnH9uRExuCAQAAAAAAFhDkRV5Z21Erw5DCByZ1IDbtSk+jvEYqq5Jky4oMutITAAAAAAAAAIB8ZcdHZE9GJMMnX8MKr8fR488Na2x8RjWVJTrhyEavxwEAAAAAADgIQV7klcpyv1Y0ByS5t5XXMIzFrbxWZMCVngAAAAAAAAAA5KuFbbxmfacMf5nH00j3PJraxvvGo9tU4vd5PA0AAAAAAMDBCPIi76xfXitJ2uFSkFeSfKFWSQR5AQAAAAAAAAB4NcnBVJDX17Ta40mkvQMx7eqLymcaeuPRbV6PAwAAAAAA8BIEeZF3FoK823vGZNu2Kz3ZyAsAAAAAAAAAwOFZ2Mjra1rj8STStkd7JUnHr29SsNr77cAAAAAAAAB/iSAv8s7q9qD8PkMHYjMaGptypSdBXgAAAAAAAAAAXp09Ny3rQI8k7zfyjo3P6I/bhyRJpx/X7uksAAAAAAAAh0KQF3mnrMSnVa1BSdL2fWOu9DRrWyVJVnRQtmW50hMAAAAAAAAAgHyTHNoj2baM6mUyq+s8neU3T/Qpadla0x7UiuaAp7MAAAAAAAAcCkFe5KX1y2sluRfkNarrJdMvJedkx0dc6QkAAAAAAAAAQL5JhndJ8n4b71wiqd8+0SdJOv3YDk9nAQAAAAAAeCUEeZGX1q94Ichr2XbW+xmmKTPYLEmyIgNZ7wcAAAAAAAAAQD7KlSDvw8+EFZ+a07JAmY4+ot7TWQAAAAAAAF4JQV7kpZUtAZWV+BSfmlPf8IQrPc3aFkkEeQEAAAAAAAAAeDm2bb0oyLvGwzlsbXu0V5L0pmM65DP5OAwAAAAAAOQu7lwgL/l9ptZ0BCWltvK6wQwtBHn7XekHAAAAAAAAAEA+scYGpNlJyV8qc1m7Z3Ps2Dem/cMTKivx6Q2va/FsDgAAAAAAgMNBkBd5a/3yWkmpG3JueCHIO+hKPwAAAAAAAAAA8kkyvFOS5GvokmH6PZvjnsf2S5JOOqpZVeUlns0BAAAAAABwOAjyIm8dubxOktTdO6akZWW9nxlqlSRZkYGs9wIAAAAAAAAAIN8kw7skSb6m1Z7NMJdI6um9ByRJb9zY5tkcAAAAAAAAh4sgL/JWR2O1qsr9mppJ6vnB8az3M4PNkiR7elzWdPb7AQAAAAAAAACQTxaDvM3eBXn39Mc0l7AUqCpVW0OVZ3MAAAAAAAAcLoK8yFumaWhtZ60kace+saz3M0rKZFQvk8RWXgAAAAAAAAAAXsyaHpcdHZQk+Rq9C/J290YkSes6QzIMw7M5AAAAAAAADhdBXuS19ctTQd5nn89+kFeSzFCLJIK8AAAAAAAAAAC8mDW/jdcMtcoor/Zsju6eiCRpbUfIsxkAAAAAAADSQZAXeW0hyLurL6q5RDLr/QjyAgAAAAAAAADwUsn5IK+vybttvHMJS7v6opK0+I1+AAAAAAAAuY4gL/Jay7JKBatKNZewtLsvlvV+i0Hesf6s9wIAAAAAAAAAIF/kQpB370BMcwlLgcoStSyr9GwOAAAAAACAdBDkRV4zDGNxK+/2fWNZ72eGWiWxkRcAAAAAAAAAgAV2MqHk0B5JktnsXZC3uyf1OcERnbUyDMOzOQAAAAAAANJBkBd5z90gb2ojrz0+Ijsxm/V+AAAAAAAAAADkOmu0R0rOSWVVMoPNns3R3RuRJK3tCHk2AwAAAAAAQLoI8iLvLQR59w7ENDWTyGovoyIglVZKsmVFw1ntBQAAAAAAAABAPkiGd0qSfE2rZRjefPSUSFratT8qSVrXGfJkBgAAAAAAgKUgyIu8Vx+qUH2wXEnL1s75m3TZYhiGzNpWSZIVGchqLwAAAAAAAAAA8kEyvEtSKsjrlecHxjWbsFRdUaLW+irP5gAAAAAAAEgXQV4UhCNXpLbybt93IOu9zGCLJIK8AAAAAAAAAADYtq3k4Asbeb2yo2dMkrS2MyTDMDybAwAAAAAAIF0EeVEQ1i1fCPKOZb2XGVoI8vZnvRcAAAAAAAAAALnMnjggezIiGaZ8jV2ezdHdG5Ekre0IeTYDAAAAAADAUhDkRUFY35kK8vaG44pPzWW1l6+WjbwAAAAAAAAAAEha3MZr1i+X4S/zZIZE0tKu/VFJ0rr5zwsAAAAAAADyBUFeFIRgdZla66tkS+ruye5W3hc28g7Ktq2s9gIAAAAAAACAF9u9e7c+/OEPa+PGjdq8ebOuu+46zc7Ovup1Y2Njuuqqq3TKKado48aNOvvss/WDH/zAhYlR6JLhXZIkX9Nqz2bYNziumbmkqsr9am2o8mwOAAAAAACApfB7PQDglPXLa9U/MqFn943pmLWNWetj1DRIpl9KzsqOj6Z+BgAAAAAAAIAsi0ajOv/887VixQrdcMMNCofDuuaaazQ9Pa2rrrrqFa+99NJLtWfPHl1++eVqaWnR/fffry984Qvy+Xx673vf69I7QCHKhSDvjvkFH2s7a2UahmdzAAAAAAAALAVBXhSM9ctrde9j+7VjX3Y38hqmT2awSdZYn6zIgEyCvAAAAAAAAABc8MMf/lATExP6xje+oVAoJElKJpP64he/qAsvvFBNTU0ve93w8LAeeeQRfeUrX9G73vUuSdKmTZv05z//Wb/4xS8I8mLJ7LlpWaM9krwN8nb3RiRJaztDns0AAAAAAACwVKbXAwBOWdsZkmFIA6OTGhufyWovM9QiSbIiA1ntAwAAAAAAAAAL7r//fm3atGkxxCtJZ555pizL0gMPPHDI6xKJhCSppqbmoMerq6tl23ZWZkVxSA7vlWxLRlWdzOpl3sxgWdq5PypJWtsR8mQGAAAAAACATBDkRcGoKi/R8qbUjehsb+VdDPKOEeQFAAAAAAAA4I49e/aoq6vroMcCgYAaGhq0Z8+eQ17X0tKiv/qrv9K3v/1t7dq1S/F4XHfeeaceeOABfeADH8j22ChgycGdkrzdxrtvMK6Z2aSqyv1qb6z2bA4AAAAAAICl8ns9AOCk9ctr9fzguLbvG9Om1zZnrc9ikDdKkBcAAAAAAACAO2KxmAKBwEseDwaDikajr3jtDTfcoMsuu0xvfetbJUk+n0+f+9zndMYZZ2Q0k99fmPtCfD7zoH/i5U0N7ZYklbSs8ews7NwfkSSt7axVaYnPkxk4L0gH5wXp4LwgXZwZpIPzgnRwXpAOzgvSwXlJIciLgrJ+ea1++UiPtu87INu2ZRhGVvqYoVZJkhUhyAsAAAAAAAAgt9m2rc985jN6/vnn9bWvfU0NDQ168MEH9eUvf1nBYHAx3Jsu0zRUW1vl8LS5JRCo8HqEnGXblqLzQd66IzaozKOzsHtgXJL0+vVNnp9HzgvSwXlBOjgvSBdnBungvCAdnBekg/OCdBT7eSHIi4Kypj0kn2loNDaj4ciUGmsrs9LHDKW2/dpTMdnTcRnlfF0XAAAAAAAAgOwKBAIaHx9/yePRaFTBYPCQ1/32t7/VXXfdpZ///Odau3atJOmEE07Q6OiorrnmmiUHeS3LViw2uaRrc53PZyoQqFAsNqVk0vJ6nJyUPNAnazou+Us1UdqgybEJ92ewLD29e0SS1NlQqTEPZpA4L0gP5wXp4LwgXZwZpIPzgnRwXpAOzgvSUejnJRCoOKxtwwR5UVDKSn1a1RrQc/uj2r5vLGtBXqOkXEZVneyJA7IiA/I1r8lKHwAAAAAAAABY0NXVpT179hz02Pj4uIaHh9XV1XXI63bt2iWfz6cjjjjioMfXr1+vH//4x5qamlJFxdK2niQShfcBy4slk1bBv8elmu1/TpLka1ippG1KHvx72jsQ0/RsUpVlfrXWVXn+u+K8IB2cF6SD84J0cWaQDs4L0sF5QTo4L0hHsZ+XV4/6Anlm3fJaSdL2fWNZ7WOGWiRJVmQgq30AAAAAAAAAQJK2bNmiBx98ULFYbPGxu+66S6ZpavPmzYe8rq2tTclkUt3d3Qc9/swzz2jZsmVLDvGiuFnhXZIkX5N3iy66eyKSpCM6QjJNw7M5AAAAAAAAMkGQFwVn/XyQd8e+Mdm2nbU+C0HeZKQ/az0AAAAAAAAAYMH73/9+VVVV6aKLLtLvf/97/fSnP9V1112n97///Wpqalp83fnnn6/TTz998ectW7aotbVVn/jEJ3T77bfroYce0le/+lX9z//8j8477zwv3goKQHIxyLvasxl29KQWeqztDHk2AwAAAAAAQKb8Xg8AOG1VW1ClflOxyTn1jUyovaE6K33M2lZJbOQFAAAAAAAA4I5gMKhbb71V//qv/6qLLrpIVVVVOvfcc3XZZZcd9DrLspRMJhd/rq6u1i233KLrr79e//t//2+Nj4+rvb1dV155JUFeLIk9HV+8N242rfJkBsuytXN/RBJBXgAAAAAAkN8I8qLg+H2m1nSE9MzeA9q+byx7Qd75jbxWZDAr9QEAAAAAAADgL61atUq33HLLK77mtttue8ljy5cv1//5P/8nO0Oh6Cxs4zWDzTLLazyZoWdoXFMzSVWU+dTZ6M0MAAAAAAAATjC9HgDIhvXLayVJO/aNZa3HQpDXHh+SnZjNWh8AAAAAAAAAAHLJYpC3aY1nM3T3RCRJa9pDMk3DszkAAAAAAAAyRZAXBWkxyNsTUdKystLDqAhKpRWSbcuKDWWlBwAAAAAAAAAAuSYZ3ilJ8jWv9myGhSDvus5az2YAAAAAAABwAkFeFKTlTTWqKPNraiahnnA8Kz0Mw1jcymtFBrLSAwAAAAAAAACAXGJbCSWH9kqSfB5t5LUsW8/1RiRJaztDnswAAAAAAADgFIK8KEimaWjd/M277fvGstdnMcjbn7UeAAAAAAAAAADkCmu0V0rOSmVVMkPNnszQOxTX5ExC5aU+dTZVezIDAAAAAACAUwjyomCtW576Oq3sBnlbJbGRFwAAAAAAAABQHJLhXZIkX+MqGYY3HzN1z2/jXdMeks/koy4AAAAAAJDfuLuBgnXkfJB3Z29EcwkrKz1e2MhLkBcAAAAAAAAAUPiSgzslSb6m1Z7N0N2TWuCx8M18AAAAAAAA+YwgLwpWa32VApUlmk1Y2tMfzUoP34uCvLadnbAwAAAAAAAAAAC5YnEjb/MaT/pbtq3n5jfyHkGQFwAAAAAAFACCvChYhmFo3fxW3u37xrLTI9AgmT4pMSt7Ijs9AAAAAAAAAADIBVZ8VPbEAckw5WtY6ckM+4fimphOqKzUp+VNNZ7MAAAAAAAA4CS/1wO82L59+3TTTTfpySef1M6dO9XV1aU77rjjFa8ZGhrSLbfcogceeEA9PT2qqanRcccdp8svv1xtbW2Lr3vkkUf0wQ9+8CXXn3XWWbr++usdfy/IDeuX1+oP24e0fd+Y3vEG5+sbpl9moElWpF9WZEBm9TLnmwAAAAAAAAAAkAMWtvGayzpklJR7MkP3/DbeNW1B+X3sqwEAAAAAAPkvp4K8O3fu1H333afXve51sixLtm2/6jXPPPOMtm3bpne/+9163etep7GxMX3rW9/Se97zHt1xxx2qq6s76PVf+cpX1NXVtfhzbW2t4+8DuWP9itTvf09/TDOzSZWV+hzvYYZaUkHesX6p/bWO1wcAAAAAAAAAIBcsBHl9Tas9m6G7JyJJWtsZ8mwGAAAAAAAAJ+VUkPfUU0/VaaedJkm68sor9fTTT7/qNcccc4x++ctfyu9/4a28/vWv1ymnnKKf/exnuuCCCw56/Zo1a3TUUUc5OzhyVkOwXMsC5RqNTWvn/ohe2+X8xlwz1CJJsiIDjtcGAAAAAAAAACBXvBDkXeNJf8u29dz8Rt61nSxqAQAAAAAAhSGnvnPINNMfJxAIHBTilaTm5mbV1dVpaGjIqdGQpwzD0PrlqZt52/eNZaUHQV4AAAAAAAAAQKGz52ZkjeyTJPmavQny9g9PKD41p9ISUyuaazyZAQAAAAAAwGk5FeR1yt69ezU6OqpVq1a95LmPf/zjWr9+vbZs2aJrr71W09PTHkwIN61fkQryPpv1IG9/VuoDAAAAAAAAAOC15PBeybZkVNXKqKrzZIbu+W28a9qC8vsK8iMuAAAAAABQhPyv/pL8Ytu2rr76ajU2Nuqtb33r4uM1NTX66Ec/quOOO05lZWV6+OGHdfPNN2vPnj268cYbM+7r9xfmDSPf/I0wXx7fEHtt1zJJUs/guGbmkqqqKHG0vq++TZOS7KmYzMSUzPIqR+vnk0I4L3AP5wXp4LwgHZwXpIPzgnRwXpAOzgvSwXkBAOSDZHiXJMnXtFqGYXgyw46e1MKOtZ21nvQHAAAAAADIhoIL8t5www16+OGH9d3vfleVlZWLjx955JE68sgjF3/etGmTGhsb9aUvfUlPPfWUNmzYsOSepmmotraww5uBQIXXIyxZbW2V2hurtX8ort7RKW06KuRwhyqN19QpOX5AVVZE5bWNDtfPP/l8XuA+zgvSwXlBOjgvSAfnBengvCAdnBekg/MCAMhlyfBOSakgrxds21Z3T0SStI4gLwAAAAAAKCAFFeT9r//6L33zm9/U//pf/0ubNm161defeeaZ+tKXvqSnn346oyCvZdmKxSaXfH0u8/lMBQIVisWmlExaXo+zZGs7Qto/FNcfnu7XuvaA4/WNYLM0fkCRfbtVVtnmeP18USjnBe7gvCAdnBekg/OCdHBekA7OC9LBeUE6Cv28BAIVbBsGgDxn29aLNvKu8WSG/pEJxafmVOo3taKlxpMZAAAAAAAAsqFggrzbtm3TF77wBX3iE5/Queee63r/RKLwPmR5sWTSyuv3uK4zpHsf269nnx/Lyvswgi3S/meVONAvXx7/e3JKvp8XuIvzgnRwXpAOzgvSwXlBOjgvSAfnBengvAAAcpUVHZRmJiRficxlnZ7MsGN+G+/q9qD8/AURAAAAAABQQAriTscjjzyiyy+/XO95z3t00UUXHfZ1v/jFLyRJRx11VLZGQ45Y21krQ6m/sR+Nzzhe3wy1SJKsyIDjtQEAAAAAAAAA8JI1OL+Nt2GlDJ83O2K6eyOSUt/ABwAAAAAAUEhyaiPv1NSU7rvvPklSX1+f4vG47rrrLknS8ccfr7q6Op1//vnq7+/Xtm3bJEm7d+/WRRddpBUrVujtb3+7/vSnPy3Wq6urU2dn6m+G/+M//qOWL1+uI488UmVlZXr44Yd1yy236LTTTiPIWwSqK0rU0VStnnBc23vGdOKRzY7WN0OtkqRkpN/RugAAAAAAAAAAeC0Zng/yNq32pL9t23quZ0xSanEHAAAAAABAIcmpIO/o6KguvfTSgx5b+Pl73/ueTjjhBFmWpWQyufj8k08+qfHxcY2Pj+uv//qvD7r2ne98p6655hpJ0po1a7R161bdfPPNmpubU1tbm/7u7/5OH//4x7P8rpArjlxelwryPp+NIG9qI68dG5adnJPhK3G0PgAAAAAAAAAAXlkM8jav8aT/wOikYpNzKvGbWtkS8GQGAAAAAACAbMmpIG97e7u6u7tf8TW33XbbQT+/613v0rve9a5XrX3hhRfqwgsvzGg+5Ld1y2t11x96tH3fmOO1jcqQVFIuzU3Lig3JV9vmeA8AAAAAAAAAANxmT8dlzX8bnenRRt7u+W28q9uCKvGbnswAAAAAAACQLdztQNFY0x6UzzQ0Ep3WcGTK0dqGYSxu5bXG+h2tDQAAAAAAAACAV5JDuyVJRrBZZnmNJzN090YkSWs7Qp70BwAAAAAAyCaCvCgaFWX+xa/cysZWXjPUKkmyIgOO1wYAAAAAAAAAwAvJ8C5Jks+jbby2bWtHT0SStLYz5MkMAAAAAAAA2USQF0Vl/fJaSdKOrAR55zfyEuQFAAAAAAAAABQIr4O8gwcmFZuYld9nqqs14MkMAAAAAAAA2USQF0VlIci7fd+YbNt2tDZBXgAAAAAAAABAIbGthJJDuyVJvqY1nszQPb+Nd3VbQCV+nyczAAAAAAAAZBNBXhSVVW0BlfhNRSdm1T866Whts/aFIK/TIWEAAAAAAAAAANxmje6XErNSacXiPXC3dfdGJElHdIQ86Q8AAAAAAJBtBHlRVEr8Pq1pD0qSduwbc7S2GWiUDJ+UmJE94WxtAAAAAAAAAADclgzvlCT5mlbLMNz/SMm2be3oSd1vX9dZ63p/AAAAAAAANxDkRdFZvzx1s2+7w0Few/TLDDRIkqxIv6O1AQAAAAAAAABwWzK8S5Lka1rjSf+hsSlF47Py+wx1tQY8mQEAAAAAACDbCPKi6KybD/J294zJsmxHa5u1rZIkKzLgaF0AAAAAAAAAANz2QpB3tSf9F7bxdrUGVVri82QGAAAAAACAbCPIi6KzorlGFWU+TUwn1DM07mhtM9QiiSAvAAAAAAAAACC/WfEDsuOjkmHI19jlyQzdvRFJ0tqOkCf9AQAAAAAA3ECQF0XHZ5pa25Hayrt935ijtQnyAgAAAAAAAAAKQXIotY3XrOuUUVLuen/bttXdE5EkresMud4fAAAAAADALQR5UZTWLc9WkLdVEkFeAAAAAAAAAEB+Sw6mgry+ptWe9B+OTGlsfEY+01BXW9CTGQAAAAAAANxAkBdFaf18kPe53ogSScuxumaoWZJkT0Zkz046VhcAAAAAAAAAADclw/NB3mZvgrw75rfxdrUGVFbi82QGAAAAAAAANxDkRVFqa6hSTWWJZucs7emPOVbXKK2UURmSxFZeAAAAAAAAAEB+shMzskb2SfJuI2/3fJB3bWfIk/4AAAAAAABuIciLomQahtZ1prbybt835mztUIskgrwAAAAAAAAAgPyUHH5espMyKkMyqutd72/btrp7U/fu187fywcAAAAAAChUBHlRtI7oCEmSoxt5JYK8AAAAAAAAAID8lgzvlJTaxmsYhuv9h6PTOhCbkc80tLo16Hp/AAAAAAAANxHkRdFa3lQjSeodGne07mKQd6zf0boAAAAAAAAAALghObhLkuRrWuNJ/+6e1DbelS0BlZX6PJkBAAAAAADALQR5UbTaGqokSZH4rGKTs47VNUOtktjICwAAAAAAAADIP7ZtywrPB3mbV3syQ3dPRJK0tjPkSX8AAAAAAAA3EeRF0aoo86uxtkKS1DsUd6zu4kbe2LBsK+FYXQAAAAAAAAAAss2OhmXPxCWfX+ay5Z7MQJAXAAAAAAAUE4K8KGodjdWSpN6wc0Feo6pWKimX7KSs2JBjdQEAAAAAAAAAyLZkeKckydfQJcPnd73/SGRKo7FpmYah1W1B1/sDAAAAAAC4jSAvitpikNfBjbyGYbywlXdswLG6AAAAAAAAAABkWzK8S5Lka1rtSf/u3ogkaWVLjcpL3Q8SAwAAAAAAuI0gL4paZ2ONJKl3aNzRumawWZJkRQjyAgAAAAAAAADyx0KQ1/QoyLujZ0yStLaz1pP+AAAAAAAAbiPIi6K2sJF3YHRScwnLsbqLG3kJ8gIAAAAAAAAA8oQ9MyFrrE+Shxt5eyKSpLWdIU/6AwAAAAAAuI0gL4paXaBMlWV+JS1bA6MTjtU1a1slSVak37GaAAAAAAAAAABkUzK8W5JkBJpkVgRc7z8andZIdFqmYWh1W9D1/gAAAAAAAF4gyIuiZhjG4lbennDcsbov3shr27ZjdQEAAAAAAAAAyJZkeKckD7fx9o5JkpY316iizO/JDAAAAAAAAG4jyIui19GUCvL2DjkY5A00SYYpzU3Lnow4VhcAAAAAAAAAgGxJhndJknzNazzpv6MnIkla1xnypD8AAAAAAIAXCPKi6C1s5O0dGnespuHzywg0Skpt5QUAAAAAAAAAIJfZVlLJoT2SvNvI+9x8kHctQV4AAAAAAFBECPKi6HU21khKbeS1bduxur5QiyTJivQ7VhMAAAAAAAAAgGywDuyXEjNSSYXM2lbX+x+ITWsoMiXDkNa0h1zvDwAAAAAA4BWCvCh6rfWV8pmGJqYTGhufcayuuRjkZSMvAAAAAAAAACC3JcM7JUm+plUyDPc/PurujUiSljfVqKLM73p/AAAAAAAArxDkRdEr8fvUvKxSktQzFHesLkFeAAAAAAAAAEC+SIZ3SZJ8TWs86d/dMyZJWtdZ60l/AAAAAAAArxDkBSR1NFZLknoJ8gIAAAAAAAAAilBycGEj72pP+nf3RCRJR3SGPOkPAAAAAADgFYK8gKTOxhpJUm943LGaC0Fee2JM9uyUY3UBAAAAAAAAAHCSNTEmOz4qGYZ8jV2u9x8bn1F4bEqGIR3RHnS9PwAAAAAAgJcI8gLKzkZeo6xKRkXqhiNbeQEAAAAAAAAAuSoZ3iVJMuvaZZRWuN6/u3dMUmrpRmV5iev9AQAAAAAAvESQF9ALQd6hsSlNzyYcq7uwlZcgLwAAAAAAAAAgVy0EeX1Nazzp390TkSSt7Qx50h8AAAAAAMBLBHkBSYGqUgWrS2VL2j884VhdgrwAAAAAAAAAgFyXDO+UJPmaVnvSfwdBXgAAAAAAUMQI8gLzFrby9g7FHatp1rZKIsgLAAAAAAAAAMhNdmJW1sg+Sd5s5I3EZxQ+MClD0hEdIdf7AwAAAAAAeI0gLzAvK0FeNvICAAAAAAAAAHJYcuR5yUrKqAjKqKl3vX/3/DbejsZqVZWXuN4fAAAAAADAawR5gXmLQd7wuGM1F4O8sbBsK+FYXQAAAAAAAAAAnJAc3CVJ8jWtlmEYrvfv7o1IktZ21rreGwAAAAAAIBcQ5AXmdTbWSJL2D0/Ism1HahpVtZK/TLKSsmPDjtQEAAAAAAAAAMApVninJMnXvNqT/t09Y5KktZ0hT/oDAAAAAAB4jSAvMK+prkIlflMzc0kNj005UtMwTJmhZklSMjLgSE0AAAAAAAAAAJxg27aS4YWNvGtc7x+dmNXA6KQMSUd0hFzvDwAAAAAAkAsI8gLzfKaptvoqSVLPUNyxumaoRZJkEeQFAAAAAAAAAOQQOxaWPT0umX6Z9ctd77+wjbetoVrVFSWu9wcAAAAAAMgFBHmBF+lsqpYk9Q6NO1bTDLVKkqxIv2M1AQAAAAAAAADI1MI2XrNhhQyf+0Ha7t6IJGldZ8j13gAAAAAAALmCIC/wIh2NNZKk3jAbeQEAAAAAAAAAhS05mAry+prWeNK/uyciSVpLkBcAAAAAABQxgrzAi3Q0zm/kHc5OkNe2bcfqAgAAAAAAAACQiYWNvL7m1a73jk3Mqn9kQpJ0REfI9f4AAAAAAAC5giAv8CLtDakg74HYjOJTc47UNINNkmFIs1Oyp6KO1AQAAAAAAAAAIBP2zISssT5Jkq/R/SDvc70RSVJbQ5VqKktd7w8AAAAAAJArCPICL1JZ7ld9sFyS1DvkzFZew1cio6ZRUmorLwAAAAAAAAAAXksO7ZFkywg0yqwMut6/uyciSVrXUet6bwAAAAAAgFxCkBf4Cx2Nqa28TgV5JckMNUsiyAsAAAAAAAAAyA3J8C5Jkq/J/W28krSjd0yStLYz5El/AAAAAACAXEGQF/gLi0He8LhjNc1QqyTJGut3rCYAAAAAAAAAAEvlZZB3fHJWfcMTkqQjOkKu9wcAAAAAAMglBHmBv9DZVCPJ2Y28vlCLJDbyAgAAAAAAAAC8Z1tJJYd2S5J8TWtc7/9cb0SS1FZfpUBVqev9AQAAAAAAcglBXuAvLGzk7R+dUCJpOVLTJMgLAAAAAAAAAMgR1oH90ty0VFIhs7bN9f7dPRFJ0hGdIdd7AwAAAAAA5BqCvMBfqA+Wq6LMp0TS1sDopCM1F4K89sQB2XPTjtQEAAAAAAAAAGApkuFdkiRf0yoZpvsfFe2YD/Ku66x1vTcAAAAAAECuIcgL/AXDMNTRkNrK2zs07kzN8moZFQFJkhUZdKQmAAAAAAAAAABL8UKQd7XrveNTc9o/HJckHdERcr0/AAAAAABAriHIC7yMjsYaSVLvUNyxmgtbea1Iv2M1AQAAAAAAAABIV3JotyRvgrzP9UYkSS3LKhWsKnW9PwAAAAAAQK4hyAu8jI6m1EbennA2grwDjtUEAAAAAAAAACAdtm3JHh+VJJmhVtf77+gZkySt7ax1vTcAAAAAAEAuIsgLvIyOxlSQt3coLtu2HalJkBcAAAAAAAAA4DV7Oi7ZSUmGjMqA6/2f64lIktZ1hlzvDQAAAAAAkIsI8gIvo62+SoYhxafmFInPOlLTDDZJkqxo2JF6AAAAAAAAAACky55IbcQ1yqtlmH5Xe09Mz6l3KPVNeGs7Qq72BgAAAAAAyFUEeYGXUVriU3NdpSSpd2jckZpmsFmSZMXCjm35BQAAAAAAAAAgHfZkVJJkVIVc7/1cb0S2pOa6SgWry1zvDwAAAAAAkIsI8gKH0NlUI0mL2wEyZdTUS4YpJWZlT0YcqQkAAAAAAAAAQDqsyfmNvJUh13t390QkSWs73e8NAAAAAACQqwjyAofQ0VgtycEgr+mXUdMgSbKig47UBAAAAAAAAAAgHQsbeU2CvAAAAAAAADmBIC9wCE4HeSXJDDZJkqxo2LGaAAAAAAAAAAAcroVvjHN7I+/k9Jx6wuOSpLUdta72BgAAAAAAyGUEeYFDWAjyDh6Y1Mxc0pGaLwR52cgLAAAAAAAAAHCfV0He5/ZHZUtqqq1QbU2Zq70BAAAAAAByGUFe4BCCVaUKVJbItqW+4QlHai4EeW028gIAAAAAAAAAPGB5FOTt7hmTJK3tdLcvAAAAAABAriPICxyCYRiLW3l7h8YdqWkGmyVJFkFeAAAAAAAAAIAH7ImIJMmsCrnat7sn1XdtZ62rfQEAAAAAAHIdQV7gFXQ01kiSeobijtRb2MhrxYZkW5YjNQEAAAAAAAAAOBy2bcmeikpydyPv5HRC+8KphRlrO9zrCwAAAAAAkA8I8gKvoKNpYSOvM0Feo2qZZPolKyE7PupITQAAAAAAAAAADoc9HZespCTJqAi61ndXX0S2LTWGKlQXKHetLwAAAAAAQD4gyAu8go7GVJB3/1Bclm1nXM8wTZnBRkmSFQtnXA8AAAAAAAAAgMNlT85v4y2vkeHzu9Z3R09EknREZ8i1ngAAAAAAAPmCIC/wCprrKuX3GZqeTWokMuVITTPQJEmyooOO1AMAAAAAAAAA4HDYk2OSJKPSvW28ktQ9H+RdR5AXAAAAAADgJQjyAq/A7zPVVp/ayts7FHekphFcCPKykRcAAAAAAAAA4J7FjbyVIdd6Ji1LvUPjkqTVbe4GiAEAAAAAAPIBQV7gVXQ0OhvkNYPNkgjyAgAAAAAAAADcZU0sbOQNudZzaGxKiaSt0hJT9aEK1/oCAAAAAADkC4K8wKtYCPL2hJ0K8rKRFwAAAAAAAADgvoWNvKaLQd6+4QlJUuuyKpmG4VpfAAAAAACAfOH3egAg13U2ZWcjrz0+LNtKyDD5zxAAAAAAAADA4dm9e7euvvpqPfHEE6qqqtLb3/52ffKTn1Rpaekhr3nkkUf0wQ9+8GWfW7lype66665sjYscY09GJLm7kbdvJBXkbWuocq0nAAAAAABAPiFBCLyK9vmNvKOxaU1Oz6myvCSjekZlSPKXSolZ2bERGaFmB6YEAAAAAAAAUOii0ajOP/98rVixQjfccIPC4bCuueYaTU9P66qrrjrkda95zWv0ox/96KDH4vG4Pvaxj2nLli3ZHhs5xFoM8gZd67kY5K2vdq0nAAAAAABAPiHIC7yKqvISLQuUaTQ2o96huNZ21mZUzzAMmcEmWaO9smKDMgnyAgAAAAAAADgMP/zhDzUxMaFvfOMbCoVCkqRkMqkvfvGLuvDCC9XU1PSy11VXV2vjxo0HPfbf//3fsixLZ599dpanRi5Z2MhrVmV2nzsdfcOpb7tjIy8AAAAAAMDLM70eAMgHHY01kqSeobgj9cxA6oa6FQk7Ug8AAAAAAABA4bv//vu1adOmxRCvJJ155pmyLEsPPPBAWrXuuOMOrVixQhs2bHB4SuQq27ZlT0YlubeRdy5haWhsSpLUVk+QFwAAAAAA4OUQ5AUOQ0dj6iu/ep0K8gZTW3itGEFeAAAAAAAAAIdnz5496urqOuixQCCghoYG7dmz57DrjIyM6OGHH2Ybb7GZmZCshCTJqAy50jJ8YFJJy1ZFmU+1NWWu9AQAAAAAAMg3fq8HAPKB80He+Y28UYK8AAAAAAAAAA5PLBZTIBB4yePBYFDRaPSw69x5551KJpOOBHn9/sLcF+LzmQf9sxAkZ+a38ZZVqaTMnVDtwIFJSVJ7Q7VKSnyu9PRCIZ4XZA/nBengvCBdnBmkg/OCdHBekA7OC9LBeUkhyAscho6mVJC3b3hCScuSz8zs/ziMhY280cGMZwMAAAAAAACAdGzdulWvec1rtHLlyozqmKah2toqh6bKTYFAhdcjOGZybFoxSf7AMtd+b6PxWUlSV3uo4M+KVFjnBdnHeUE6OC9IF2cG6eC8IB2cF6SD84J0FPt5IcgLHIaGUIXKSn2amU1qcHRSbQ3VGdVb2Mhrxw/ITszK8Jc6MSYAAAAAAACAAhYIBDQ+Pv6Sx6PRqILB4GHV6Onp0VNPPaXPfOYzGc9jWbZiscmM6+Qin89UIFChWGxKyaTl9TiOmAmnFkvYZQGNjU240nNXz5gkqSFQ5lpPLxTieUH2cF6QDs4L0sWZQTo4L0gH5wXp4LwgHYV+XgKBisPaNkyQFzgMpmGoo6Fau/qi6h2KZxzkNcprpNIKaXZKVmxYvro2hyYFAAAAAAAAUKi6urq0Z8+egx4bHx/X8PCwurq6DqvG1q1bZZqmzjrrLEdmSiQK7wOWF0smrYJ5j4nxVKhWlUHX3tP+4bgkqaWusmD+Pb6SQjovyD7OC9LBeUG6ODNIB+cF6eC8IB2cF6Sj2M/Lq0d9AUiSOhpT4d2eoXjGtQzDkBlsliRZ0cGM6wEAAAAAAAAofFu2bNGDDz6oWCy2+Nhdd90l0zS1efPmw6rxi1/8Qscff7waGxuzNSZylD0ZkSSZlSFX+s3MJTU8NiVJas1wOQYAAAAAAEAhI8gLHKaOptSNxl4HgrySZAabJElWNOxIPQAAAAAAAACF7f3vf7+qqqp00UUX6fe//71++tOf6rrrrtP73/9+NTU1Lb7u/PPP1+mnn/6S65999lnt3r1bZ599tptjI0csBHkNl4K8A6MTsiVVV5QoUFniSk8AAAAAAIB8RJAXOEwLG3kdC/IGUjfW7RgbeQEAAAAAAAC8umAwqFtvvVU+n08XXXSRvva1r+ncc8/VlVdeedDrLMtSMpl8yfVbt25VaWmpzjjjDLdGRg6xXA7y9g1PSJLa6qtkGIYrPQEAAAAAAPKR3+sBgHzRXl8tQ1JsYlbR+IyC1WUZ1WMjLwAAAAAAAIB0rVq1Srfccssrvua222572cc//elP69Of/nQWpkI+cHsjb9/IfJC3ocqVfgAAAAAAAPmKjbzAYSor9amprlKSM1t5zWCzJIK8AAAAAAAAAIDssm17Mchrur2Rt6HalX4AAAAAAAD5iiAvkIaOxtQNR2eCvKmNvPZkRPbcdMb1AAAAAAAAAAB4WTMTUjIhSTIqg6607B9J3Udvq2cjLwAAAAAAwCvJqSDvvn37dNVVV+ntb3+7jjzySJ199tmHdZ1t2/rOd76jU045RRs2bND73vc+/elPf3rJ68LhsC655BIdffTROv744/XZz35W8XjmgUwUDyeDvEZZlYzyGkls5QUAAAAAAAAAZI81GU39oaxKhr806/2mZhIajc1IkloJ8gIAAAAAALyinAry7ty5U/fdd5+WL1+uVatWHfZ1/+///T99/etf14c+9CHdeOONamho0AUXXKDe3t7F18zNzemjH/2onn/+eX3ta1/TF77wBf3+97/XFVdckY23ggK1EOTtcSDIK0nG/FZegrwAAAAAAABA4XjyySe9HgE4iD0ZkSSZrm3jnZAkhapLVV1R4kpPAAAAAACAfOX3eoAXO/XUU3XaaadJkq688ko9/fTTr3rNzMyMbrzxRl1wwQX60Ic+JEk65phj9Ja3vEU33XSTvvCFL0iS7r77bu3cuVN33nmnurq6JEmBQEAf+chH9NRTT2nDhg1ZeU8oLJ1NqQ26g6OTmkskVeL3ZVTPDDbJCu+SFR10YjwAAAAAAAAAOeB973ufli9frre97W1629vepo6ODq9HQpFbCPIalbWu9OubD/K2sY0XAAAAAADgVeXURl7TTH+cxx9/XPF4XGeeeebiY6WlpTr99NN1//33Lz52//33a+3atYshXknavHmzQqGQ7rvvvswGR9FY2B5g2fbijchMmAE28gIAAAAAAACF5qtf/aqWL1+ub33rW3rzm9+s97///frBD36gSCTi9WgoUtZikNedjbz7h1PfatfWUO1KPwAAAAAAgHyWU0HepdizZ48kHRTQlaRVq1apv79f09PTi6/7y9cYhqGVK1cu1gBejWEY6mhM3XjsCcczrmeGmiVJVowgLwAAAAAAAFAozjnnHH3nO9/R/fffr89+9rOSpC9+8Yt6wxveoH/4h3/QXXfdpdnZWY+nRDFZ2MhrVoZc6dc/vwijlY28AAAAAAAAr8rv9QCZisViKi0tVVlZ2UGPBwIB2bataDSq8vJyxWIx1dTUvOT6YDCoaDSa8Rx+f95nol+Wz2ce9E9Iy5trtH3fmPpGJjL/vde1aFqSHQ0XxBnivCAdnBekg/OCdHBekA7OC9LBeUE6OC9IB+cFKFx1dXU677zzdN5556mnp0dbt27V1q1bddlll6mmpkZnnHGG3v72t+vYY4/1elQUOHtxI2/IlX59w6kgb1sDQV4AAAAAAIBXk/dB3lxgmoZqawv7ZlQgUOH1CDljfdcy3fVIj/pHJzP+vVtVKzUuyZ4eV6Dclq+iML5mjPOCdHBekA7OC9LBeUE6OC9IB+cF6eC8IB2cF6CwlZWVqaKiQmVlZbJtW4Zh6N5779VPfvITHXnkkbr22mu1evVqr8dEgbInIpLcCfLGp+YUnUhtnG5dVtifnQAAAAAAADgh74O8gUBAs7OzmpmZOWgrbywWk2EYCgaDi6+Lx+MvuT4ajaqlpSWjGSzLViw2mVGNXOXzmQoEKhSLTSmZtLweJycsqy6VJO3ti+rAgbgMw8ionlFVK3tiTAf27ZG/aZUTI3qG84J0cF6QDs4L0sF5QTo4L0gH5wXp4LwgHYV+XgKBCrYNo2jF43Hdfffd2rp1q/74xz/KMAxt2bJFF110kd74xjfKNE1t27ZN1157rT7zmc/oxz/+sdcjo0BZCxt5q0JZ79U3nPosZlmgXBVlef8xFAAAAAAAQNbl/R2Urq4uSdLevXu1bt26xcf37Nmj1tZWlZeXL77uueeeO+ha27a1d+9ebd68OeM5EonC+5DlxZJJq+Df4+FqDFXIZxqanEkoPDqp+lBm23LMQKOSE2OaOzAgLVvp0JTe4rwgHZwXpIPzgnRwXpAOzgvSwXlBOjgvSAfnBSgc99xzj7Zu3arf/va3mpmZ0VFHHaV//ud/1llnnaXa2tqDXvuWt7xFsVhMX/rSlzyaFoXOtm3Z80Fe04WNvH0jE5Kktga28QIAAAAAAByOvA/yvv71r1d1dbV++ctfLgZ55+bm9Ktf/UpbtmxZfN2WLVv085//XM8//7xWrFghSXrooYcUiUR08sknezE68pTfZ6q1vkq9Q3H1DsUzD/IGm5Qc6JYVDTs0IQAAAAAAAAAvXXzxxWppadGHPvQhvf3tb19cSHEo69at0znnnOPSdCg6s5NSck6SZFQGs96OIC8AAAAAAEB6cirIOzU1pfvuu0+S1NfXp3g8rrvuukuSdPzxx6uurk7nn3+++vv7tW3bNklSWVmZLrzwQt1www2qq6vTEUccoR/84AeKRCL6yEc+slj7jDPO0I033qhLLrlEl19+uaampnTdddfplFNO0YYNG9x/s8hrHY3V6h2Kq2corqOPaMiolhlsliSCvAAAAAAAAECBuPXWW3XCCScc9us3bNjAfWpkjTUZTf2htEKGvyzr/fqG54O89QR5AQAAAAAADkdOBXlHR0d16aWXHvTYws/f+973dMIJJ8iyLCWTyYNe87GPfUy2bevmm2/WgQMHtH79et10003q6OhYfE1JSYm++93v6uqrr9bll18uv9+v008/Xf/8z/+c/TeGgtPZWK0HJfUOxTOuZQSbJElWjCAvAAAAAAAAUAjSCfEC2WZPRiRJZmUo+71sW33DqfvmbfXVWe8HAAAAAABQCHIqyNve3q7u7u5XfM1tt932kscMw9CFF16oCy+88BWvbWpq0g033JDRjICU2sgrSb1D4xnXMgPzG3kjg7JtW4ZhZFwTAAAAAAAAgHeuv/56/fa3v9Xtt9/+ss+/4x3v0GmnnaaLL77Y5clQjBaCvIYLQd7YxKwmphMyDKllWWXW+wEAAAAAABQC0+sBgHzU0VQjSRqOTGtqJpFRLTPQIMmQ5qZkT2ceDAYAAAAAAADgrbvvvltbtmw55PMnn3yy7rzzThcnQjGzJiKS3Any7h+ZkCQ1hipUWuLLej8AAAAAAIBCQJAXWILqihLV1pRJknqH4hnVMvylMqrrJElWNJzxbAAAAAAAAAC8NTAwoM7OzkM+397erv7+fhcnQjFzcyNv33AqyNvWUJ31XgAAAAAAAIWCIC+wRB2NqRuRmQZ5JckMNkuS7OhgxrUAAAAAAAAAeKuyslJ9fX2HfH7//v0qKytzcSIUs4Ugr+lCkLd/JHW/vLW+Kuu9AAAAAAAACgVBXmCJnA3yNkliIy8AAAAAAABQCI4//nj96Ec/Ujj80vt9AwMD+tGPfqQTTjjBg8lQjBY38laFst5rYSNvewNBXgAAAAAAgMPl93oAIF+9EOQdz7jWC0FeNvICAAAAAAAA+e7SSy/Ve97zHr31rW/Vueeeq9WrV0uSdu7cqZ/+9KeybVuXXnqpx1OiWFiTUUmSkeWNvLZtq28kFeRtYyMvAAAAAADAYSPICyxRZ1ONpNSGAcuyZZrGkmuxkRcAAAAAAAAoHF1dXfr+97+vq6++WrfccstBzx133HH67Gc/q1WrVnkzHIqKbduyJ8ckSWaWg7wHYjOank3KZxpqqqvMai8AAAAAAIBCQpAXWKLGUIVKS0zNzlkKj02qZdnSNwyYgWZJkhULy7ZtGcbSQ8EAAAAAAAAAvLdu3Tr9x3/8hw4cOKD9+/dLktrb21VXV+fxZCgqc9NSYlZS9jfy9o3EJUnNdZXy+8ys9gIAAAAAACgkBHmBJTJNQ+0N1drTH1NPOJ5RkNcI1EuGKSVmZU9GZFTVOjgpAAAAAAAAAK/U1dUR3oVnrPltvCopl1FSltVefSMTkqTW+qXfKwcAAAAAAChGBHmBDHQ2poK8vUNxnXBk05LrGKZfRk2D7FhYVnRQJkFeAAAAAAAAIO8NDg7q2Wef1fj4uGzbfsnz73jHO9wfCkXFnoxKkswsb+OVpL7hVJC3rYEgLwAAAAAAQDoI8gIZ6GisliT1DsUzrmUGm5SMhWVFw1Lr+ozrAQAAAAAAAPDGzMyMPv3pT+tXv/qVLMuSYRiLQV7DMBZfR5AX2WZPpDbyGm4Eeec38rbVV2e9FwAAAAAAQCExM7m4v79fjz766EGP7dixQ5/61Kf0yU9+Uvfcc09GwwG5rqOxRpLUMzSecS0zmNroa0UHM64FAAAAAAAAwDv/9m//pm3btumTn/ykbrvtNtm2rWuuuUY333yztmzZonXr1un222/3ekwUgYWNvEZVKKt9LMvWwAgbeQEAAAAAAJYioyDv1VdfrW984xuLP4+MjOiDH/ygtm3bpkcffVSXXHKJfvWrX2U8JJCrFm5IRuOzik3OZlRrIchrR8MZzwUAAAAAAADAO3fffbfe9a536eMf/7hWr14tSWpqatJJJ52kG2+8UTU1Nfr+97/v8ZQoBtZkRFL2N/IOR6c0m7Dk95lqDFVktRcAAAAAAEChySjI+9RTT+mkk05a/PlnP/uZpqendfvtt+v+++/Xpk2bdPPNN2c8JJCrKsr8aqxN3ZTsHYpnVMsMNkuSLIK8AAAAAAAAQF4bHR3Vhg0bJEnl5eWSpKmpqcXnzzjjDG3bts2T2VBc7Pkgr5nlIG//cGobb2t9pUzTyGovAAAAAACAQpNRkDcajWrZsmWLP//2t7/Vcccdp87OTpmmqdNPP1179uzJeEggl3U0VkuSesOZBnlTG3mt2JBsy8p4LgAAAAAAAADeqK+v19jYmCSpoqJCwWBQe/fuXXw+Ho9rZmbGq/FQRGyXNvLuH0kFedvqq7LaBwAAAAAAoBD5M7m4rq5O/f39kqRYLKY//elP+sd//MfF55PJpBKJRGYTAjmuo7Faj3UPq3doPKM6RtUyyfRLVkJ2fFRGoMGhCQEAAAAAAAC4acOGDXr88ccXf37jG9+om266SQ0NDbIsS7fccos2btzo3YAoGpZLQd6+4dSii7aG6qz2AQAAAAAAKEQZBXlPOukk3XbbbaqurtYjjzwi27b1pje9afH5Xbt2qaWlJeMhgVzW2VgjSeodymwjr2GaMgONsiL9smJhmQR5AQAAAAAAgLz0t3/7t7rrrrs0Ozur0tJSXXrppXriiSf0qU99SpLU2dmpz372sx5PiWJgT0YlSWaWg7z98xt5W9nICwAAAAAAkLaMgrxXXHGF9u7dq2uvvVYlJSX61Kc+pY6ODknS7OysfvnLX+qcc85xZFAgV3U0pjYMDIxOai5hqcRvLrmWGWxKBXmjg1L7a50aEQAAAAAAAICLjj32WB177LGLP7e0tOiXv/ylnnvuOZmmqa6uLvn9Gd2eB16VPTslzU1LkozKYNb6JJKWBkYnJUntBHkBAAAAAADSltGdwvr6ev3whz/U+Pi4ysrKVFpauvicZVm69dZb1dzcnPGQQC6rC5SpssyvyZmE+kcmtLy5Zsm1jGCTJMmKhp0aDwAAAAAAAICLpqam9E//9E9685vfrLe97W2Lj5umqXXr1nk4GYrNwjZelZTLKK3IWp+hsSklLVtlpT7VBcuz1gcAAAAAAKBQLX116IvU1NQcFOKVpPLycq1bt06hUMiJFkDOMgxDnU2prby9Q/GMapnBVPCdIC8AAAAAAACQnyoqKvTggw9qenra61FQ5KzJMUnZ3cYrSX0jE5Kk1mVVMg0jq70AAAAAAAAKUUZB3oceekjf/e53D3rsJz/5iU455RSddNJJ+vKXv6xkMpnRgEA+aG90KsjLRl4AAAAAAAAg3x1zzDF64oknvB4DRW5hI69ZGcpqn77h1H3xtoaqrPYBAAAAAAAoVBkFeW+44Qbt2LFj8efu7m59/vOfV11dnY4//njddtttuummmzIeEsh1HYtB3vGM6ixs5LXHh2VbiYznAgAAAAAAAOC+q666So899piuv/56DQ4Oej0OipQ9GZEkGdkO8s5v5G2vJ8gLAAAAAACwFP5MLt69e7fe/OY3L/58++23q7q6Wt///vdVUVGhq666Srfffrs+/vGPZzwokMs6G2skpTby2rYtY4lfH2ZUhiR/qZSYlR0bkRFqdnBKAAAAAAAAAG5429vepmQyqe985zv6zne+I5/Pp9LS0oNeYxiGHnvsMY8mRDGw3AryDqeCvK1s5AUAAAAAAFiSjIK8U1NTqq6uXvz5d7/7nf7qr/5KFRUVkqSjjjpKW7duzWxCIA+01lfJZxqamE5obHxGdYHyJdUxDENmsEnWaK+s2KBMgrwAAAAAAABA3jnjjDOW/Jf9AacsbOQ1sxjknUskFR6blCS11Ve/yqsBAAAAAADwcjIK8ra0tOjPf/6zzj33XO3bt087d+7UBRdcsPh8NBp9yZYBoBCV+E01L6tU3/CEesLxJQd5JckMzAd5o2EHJwQAAAAAAADglmuuucbrEQDZExFJklEZzFqPgdFJ2bZUWeZXqJrPgwAAAAAAAJYioyDvOeeco29+85sKh8PatWuXgsGg3vSmNy0+/8wzz2jFihWZzgjkhY7GavUNT6h3aFwb19QvuY4ZTG3hJcgLAAAAAAAAAFiqhY28RlVt1nr0jUxIktoaqthCDQAAAAAAsEQZBXn/7u/+TnNzc7rvvvvU0tKia665RoFAQJIUiUT0hz/8QR/84AcdGRTIdZ2NNXr4mbB6h+IZ1TGDTZII8gIAAAAAAAD56mc/+9lhve4d73hHVudAcbMWgrxZ3Mjbvxjkrc5aDwAAAAAAgEKXUZDX7/frsssu02WXXfaS50KhkB544IFMygN5paMxdaOyJ8Mgr7G4kXcw45kAAAAAAAAAuO/KK6885HMv3lpKkBfZYs9NS3PTkiSzMosbeYfng7z1VVnrAQAAAAAAUOgyCvK+2MTEhAYHU8HD5uZmVVVx0wbFZSHIOzw2penZhMpLl/af18JGXjt+QHZiVoa/1LEZAQAAAAAAAGTfvffe+5LHLMvS/v379YMf/ED9/f269tprPZgMxcKe38Yrf6lUUp61PvuHU4stCPICAAAAAAAsXcZB3qeeekpf/epX9fjjj8uyLEmSaZo65phj9E//9E866qijMh4SyAeBqlIFq0sVjc9q//CEVrct7evKjPIaqbRCmp2SFRuWr67N4UkBAAAAAAAAZFNb28vf0+vo6NCmTZv08Y9/XP/xH/+hz3/+8y5PhmJhTUYlSUZl7UFboJ00M5vUSDS19be1gSAvAAAAAADAUpmZXPzkk0/qvPPO07PPPqtzzz1Xn/nMZ/SZz3xG5557rp599lmdd955euqpp5yaFch5C1t5e4fiS65hGIbMYLMkyYoNOjIXAAAAAAAAgNxxyimn6M477/R6DBSwhY28ZuXSFk4cjv7RCUlSoLJEgUq+WQ4AAAAAAGCpMtrIe/3116upqUn/+Z//qYaGhoOeu+SSS/TXf/3Xuv766/Xv//7vGQ0J5IuOxmo9veeAesPjGdUxA02yhvfKioQdmgwAAAAAAABArujt7dXs7KzXY6CA2RMRSZJRGcpaj77hVJC3raE6az0AAAAAAACKQUZB3ieffFIXXXTRS0K8klRfX6/3vve9+r//9/9m0gLIK52NNZIy28grSWawSZJks5EXAAAAAAAAyDt//OMfX/bxWCymRx99VLfddpve9KY3uTwViok1v5E3q0HekdR98Nb6qqz1AAAAAAAAKAYZBXlN01QymTzk85ZlyTTNTFoAeaWjMbV5YP/whCzLlmkaS6qzEOS1omzkBQAAAAAAAPLN3/7t38owXnpv0LZt+Xw+veUtb9HnPvc5DyZDsbDdCPIubuQlyAsAAAAAAJCJjIK8Rx99tL7//e/r7LPPVltb20HP9ff36z//8z/1+te/PqMBgXzSVFehEr+pmbmkhiJTaq6rXFIdM9gsiSAvAAAAAAAAkI++973vveQxwzAUCATU1tam6upqD6ZCMVkI8ppVoaz16BtJBXnb6znPAAAAAAAAmcgoyHv55ZfrAx/4gM4880ydfvrpWrFihSRp7969uvfee2Wapq644gon5gTygs801d5Qpb0D4+odimcQ5E1t5LUnI7LnpmWUlDs5JgAAAAAAAIAsOv74470eAUUu2xt5J6fnNDY+I0lqrV/afXAAAAAAAACkZBTkPfLII/XjH/9Y119/vX79619rampKklRRUaE3vOENuvjii1VbW+vIoEC+6Gisng/yjuu4dY1LqmGUVckor5E9PS4rGpavfrnDUwIAAAAAAADIlt7eXu3cuVOnnnrqyz7/61//WkcccYTa29tdngzFwspykHdhG29tTZkqy0uy0gMAAAAAAKBYZBTklaTVq1frm9/8pizL0oEDByRJdXV1Mk1T3/rWt/T1r39d27dvz3hQIF90NNZIGlBPOJ5RHSPYRJAXAAAAAAAAyEPXXXed4vH4IYO83//+9xUIBHT99de7PBmKgZ2YkWZTi1fMymBWeiwEedsaqrJSHwAAAAAAoJiYjhUyTdXX16u+vl6m6VhZIO90NFZLknqHMgvymsEmSZIVHcx4JgAAAAAAAADueeKJJ3TSSScd8vlNmzbp0UcfdXEiFBN7Mpr6g69UKq3MSo++4fkgbz1BXgAAAAAAgEyRuAUc1t6QCvKOjc8oPjW35DpmYD7IGws7MhcAAAAAAAAAd8RiMVVVHTrgWFlZqUgk4t5AKCrWZESSZFQGZRhGVnr0L2zkra/OSn0AAAAAAIBiQpAXcFhluV/1wXJJUm94fMl1zGCzJMmKEuQFAAAAAAAA8klLS4sef/zxQz7/2GOPqbm52cWJUEzsiYgkyayqzVqPvuHUN9K1NbCRFwAAAAAAIFMEeYEs6GhMbSHoHYovuYYZTG3ktQnyAgAAAAAAAHnl7LPP1i9+8Qt973vfk2VZi48nk0ndeuutuvPOO3X22Wd7OCEKmf2ijbzZEJucVWwy9W10rcsI8gIAAAAAAGTKn+4FzzzzzGG/dmhoKN3yQEHobKrREztHnAnyTo/LnpmQUcYNUQAAAAAAACAfXHjhhXrsscf05S9/Wd/+9re1cuVKSdLevXt14MABHX/88fr7v/97j6dEoXohyBvKSv3+4QlJUkOoXGWlvqz0AAAAAAAAKCZpB3nf/e53yzCMw3qtbduH/VqgkDixkdcoKZdRGZI9GZEVDcvX2OXUeAAAAAAAAACyqLS0VDfffLP+53/+R9u2bVNPT48kacOGDXrzm9+sd7zjHTJNvjAP2WFlOcjbN5IK8rbVV2elPgAAAAAAQLFJO8j7la98JRtzAAVlIcjbNzKhRNKS37e0m/JmsEnJyYis6CBBXgAAAAAAACCPmKapd7/73Xr3u9/t9SgoMgsbec1sBXmHUwss2hr4FjkAAAAAAAAnpB3kfec735mNOYCCUh8sV0WZT1MzSQ2MTi4Ge9NlBpuUHOiWFQ07PCEAAAAAAACAbIlEIhocHNS6dete9vnu7m41NzcrGAy6PBmKge3aRl6CvAAAAAAAAE7gu7uALDAMQx0NqfBu79D40usEmiWJIC8AAAAAAACQR77yla/oqquuOuTzn//853Xttde6OBGKiTUZlZSdIK9t2+obTgV5WwnyAgAAAAAAOIIgL5AlHY01kqSecHzJNcxQkyTJihHkBQAAAAAAAPLFww8/rFNPPfWQz7/xjW/UQw895OJEKBZ2YlaaSQVtzaqQ4/Uj8VlNziRkGoZallU6Xh8AAAAAAKAYEeQFsqSjaWEjbwZB3sWNvIOybduRuQAAAAAAAABk14EDB1RbW3vI50OhkEZHR12cCMXCnt/GK59fKnU+aNs3krrf3VRXoRK/z/H6AAAAAAAAxYggL5AlHY0vBHmXGsI1Aw2SDGl2Svb0uIPTAQAAAAAAAMiWhoYGPfvss4d8/plnnlFdXZ2LE6FYWJMRSZJRGZJhGI7X7xtObfttra9yvDYAAAAAAECxIsgLZElbfZUMQ4pPzSkSn11SDcNfKqM6dUPfioadHA8AAAAAAABAlpx22mn66U9/qnvvvfclz91zzz367//+b5122mkeTIZCZ78oyJsNfSOpIG8bQV4AAAAAAADH+L0eAChUpSU+NddVamB0Ur1D46qtKVtSHTPYrGR8VHZ0UGpe4/CUAAAAAAAAAJx2ySWX6KGHHtLFF1+sdevWac2a1H29nTt3avv27Vq9erU+8YlPeDwlCtFCkNfMVpB3fiNvW0N1VuoDAAAAAAAUIzbyAlnU2VQjSeodii+5hhlsksRGXgAAAAAAACBf1NTU6Ec/+pH+/u//XolEQnfffbfuvvtuJRIJXXTRRfrxj38s27a9HhMFKJsbeS3bVj8beQEAAAAAABzHRl4gizoaq/XIs2H1hJ0I8g46NRYAAAAAAACALKusrNQnPvGJgzbvzszM6Ne//rWuuOIK/e53v9Of//xnDydEIbImIpKyE+Q9EJ3WzFxSfp+hxtoKx+sDAAAAAAAUK4K8QBZ1NKa+XsyRjbwxNvICAAAAAAAA+ca2bT300EPaunWrtm3bpomJCdXW1urss8/2ejQUoIWNvGZVyPHa++e38TbXVcrv4wsfAQAAAAAAnEKQF8iizvkgb3hsUjNzSZWV+NKuYQaaJUlWNCzbtmUYhqMzAgAAAAAAAHDe008/ra1bt+oXv/iFRkZGZBiGzjrrLJ133nnauHEj9/mQFfZkVFJ2NvL2zwd52xqqHa8NAAAAAABQzAjyAlkUrC5ToLJEsck59Q1PqKs1kHYNI1AvGaaUmJU9GZFRVZuFSQEAAAAAAABkqre3Vz//+c+1detW7du3T01NTTrnnHO0YcMGXXbZZTrjjDN09NFHez0mCpg1OSYpO0HevuHUN8+11Vc5XhsAAAAAAKCYEeQFsqyjsVrPPD+mnqHxpQV5Tb+MmgbZsbCs6KBMgrwAAAAAAABAznnf+96np556SrW1tTrjjDN09dVX69hjj5Uk9fT0eDwdioGdnJNmUltzzawEeec38hLkBQAAAAAAcBRBXiDLOppq9MzzY+odii+5hhlsUjIWlhUNS63rHZwOAAAAAAAAgBOefPJJtbe368orr9Qpp5wiv5/b73CXPRlJ/cH0S2XOhm0ty1b/6KQkqa2BIC8AAAAAAICTTK8HAApdR2O1JGUc5JUkKzroyEwAAAAAAAAAnPUv//Ivamho0MUXX6zNmzfrqquu0sMPPyzbtr0eDUXCnoxKkozKoAzDcLT2UGRKiaSlUr+p+lCFo7UBAAAAAACKHSsBgCx7cZDXsm2ZS7iBuhDktaNhR2cDAAAAAAAA4IwPfOAD+sAHPqDe3l5t3bpVd9xxh/7rv/5L9fX1OuGEE2QYhuPhSuDFrIkxSZJRGXK8dt/whCSppb5qSfe4AQAAAAAAcGhs5AWyrLmuUn6foZnZpEYiU0uqYQabJUkWQV4AAAAAAAAgp3V0dOgf/uEfdOedd+onP/mJ3vrWt+oPf/iDbNvWF7/4Rf3Lv/yLfvOb32hmZsbrUVFgFjbymtkI8o6kvnGuvb7K8doAAAAAAADFjo28QJb5faba6qu1Lzyu3qG4Gmsr065hBlIbea3YkGzLkmGSwQcAAAAAAABy3Wtf+1q99rWv1ac//Wk9/PDD+vnPf64777xTP/7xj1VRUaEnnnjC6xFRQOzJiKTsbuRtbSDICwAAAAAA4DTSgIALOhqrJUk94fiSrjeql0mmX7ISsidGnRwNAAAAAAAAQJaZpqmTTjpJ11xzjR588EH927/9m0488USvx0KBsRaCvFUhx2v3j6SCvG311Y7XBgAAAAAAKHZs5AVcsBDk7R1aYpDXNGUGGmVF+mVFwzJrGpwcDwAAAAAAAIBLysrKdNZZZ+mss87yehQUmIWNvKbDG3kTSUuDByYlSe1s5AUAAAAAAHAcG3kBF3Q2ZRbklSQz2CRJsqKDjswEAAAAAAAAACgcC0Few+Eg7+CBSSUtWxVlPtXWlDlaGwAAAAAAAAR5AVe0z2/kHY1Na2J6bkk1jMUgb9ixuQAAAAAAAAAAhcGejEpyPsjbPzIhSWqtr5JhGI7WBgAAAAAAAEFewBVV5SVaFkhtKti/xK28ZrBZEkFeAAAAAAAAAMDB7GRC9vS4JMmoDDpae/9wKsjbVl/laF0AAAAAAACkEOQFXNLRWCNJ6llykJeNvAAAAAAAAACAl7KnUtt4ZfpklFc7WnthI29bvbN1AQAAAAAAkEKQF3BJR2PqJmfP4PiSrl/YyGuPD8u2Eo7NBQAAAAAAAADIb/bEmCTJqAjKMJz96KdvOLWcoq2BjbwAAAAAAADZQJAXcElXa0CStHN/dEnXG5UhyV8q2Zbs2IiDkwEAAAAAAAAA8pk1mbrvbFSFHK07O5fU0NiUJKmtniAvAAAAAABANhDkBVyypj0kw5CGIlM6EJtO+3rDMGQGmiRJVmzQ6fEAAAAAAAAAAHnKnoxIkszKkKN1B0YnZUuqrihRoKrU0doAAAAAAABIIcgLuKSy3K/OphpJUndvZEk1zOB8kDcadmosAAAAAAAAAECeWwjyGg4HeftG4pJS23gNw3C0NgAAAAAAAFII8gIuWtcZkiR190SWdL0ZbJZEkBcAAAAAAAAA8IKsBXmHJyRJrQ1VjtYFAAAAAADACwjyAi5a21ErSeruGVvS9WzkBQAAAAAAAAD8JWs+yGs6vpE3FeRtryfICwAAAAAAkC0EeQEXHdERlCEpPDalsfGZtK83FjfyDjo8GQAAAAAAAAAgX2V9Iy9BXgAAAAAAgKwhyAu4qLK8RJ1NNZKk7t70t/IubOS14wdkJ2YdnQ0AAAAAAABA7tu9e7c+/OEPa+PGjdq8ebOuu+46zc4e3r3CcDisT3/60zrxxBO1YcMGnXnmmfr5z3+e5YnhBnsiIkkyKoOO1ZyaSWg0Ni1JamuodqwuAAAAAAAADub3egCg2KztDGlfeFzdPRGdeGRzWtca5TVSSYU0NyUrNixfXVuWpgQAAAAAAACQa6LRqM4//3ytWLFCN9xwg8LhsK655hpNT0/rqquuesVrh4aG9L73vU8rV67Uv/7rv6q6ulo7d+487BAwcpdtJWRPj0uSjKpax+r2j6a28QarS1VdUeJYXQAAAAAAAByMIC/gsrWdIf3qj73q7omkfa1hGDJDzbKG98qKDRLkBQAAAAAAAIrID3/4Q01MTOgb3/iGQqGQJCmZTOqLX/yiLrzwQjU1NR3y2q9+9atqbm7Wd7/7Xfl8PknSpk2b3BgbWWZPRlN/MHwyyp3bnNs3nAryttVXOVYTAAAAAAAAL2V6PQBQbI7oCMmQNHhgUpH4TNrXm4HUzXgrEnZ4MgAAAAAAAAC57P7779emTZsWQ7ySdOaZZ8qyLD3wwAOHvC4ej+uXv/yl/uZv/mYxxIvCsRDkNSqDMgznPvbpH1kI8joXDgYAAAAAAMBLEeQFXFZVXqKOxtSNz+d6I2lfbwZTQV47NujkWAAAAAAAAABy3J49e9TV1XXQY4FAQA0NDdqzZ88hr3vmmWc0Nzcnv9+v8847T695zWu0efNmffWrX9Xc3Fy2x0aWWZMRSakgr5P6huOSpLYGNvICAAAAAABkk9/rAYBidERnSD1Dce3oiej49Yf+uruXsxDktaJs5AUAAAAAAACKSSwWUyAQeMnjwWBQ0Wj0kNeNjIxIkj73uc/pve99ry6++GI99dRT+vrXvy7TNHXFFVcseSa/vzD3hfh85kH/zGXJ6dTv3ldd6+jvo29+I29nU03B/p6dkk/nBd7jvCAdnBekizODdHBekA7OC9LBeUE6OC8pBHkBD6zrrNU9j+5Xd89Y2teawWZJBHkBAAAAAAAAHB7LsiRJJ510kq688kpJ0oknnqiJiQndfPPNuuiii1ReXp52XdM0VFtb2NtaA4EKr0d4VQesCU1KKq+td+z3MT45q0h8VpL0mjUNqiwvcaRuocuH84LcwXlBOjgvSBdnBungvCAdnBekg/OCdBT7eSHIC3jgiI6QJGlgdFLRiVkFq0oP+9qFjbz2ZET23LSMkvRvsAMAAAAAAADIP4FAQOPj4y95PBqNKhgMvuJ1Uiq8+2KbNm3St7/9be3bt09r165Nex7LshWLTaZ9XT7w+UwFAhWKxaaUTFpej/OKJkeHJUlzvmqNjU04UnNhCcWyQLlmpmY1MzXrSN1ClU/nBd7jvCAdnBekizODdHBekA7OC9LBeUE6Cv28BAIVh7VtmCAv4IHqihK1N1Rr/3Bcz/VGdNy6xsO+1iirklFeI3t6XFY0LF/98ixOCgAAAAAAACBXdHV1ac+ePQc9Nj4+ruHhYXV1dR3yutWrV79i3ZmZmSXPlEgU3gcsL5ZMWjn/HpPxVOjWrgg6NmtPOC5Jamuoyvn3n0vy4bwgd3BekA7OC9LFmUE6OC9IB+cF6eC8IB3Ffl5ePerrst27d+vDH/6wNm7cqM2bN+u6667T7Owr/03vRx55RGvXrn3Z/73lLW951ddddtll2X5bwEus7QxJknbMbzZIhzG/ldeKhp0cCQAAAAAAAEAO27Jli/4/e38eHdd93/f/z3tnsAMDgCQ2AgRBUhQlUvtmy0pkV14UOcnXsS23SvrNT7WTWG7V5Fc5+Z00/X5/TrwksdWTnm8rJ3U2V65+TRw3adzIdu3IzqJai23JlmiSEiWTAEGCIAiS2Ih95t7fHzMACREgMSQwg+X5OAdn7vK+F+8BPwJ1Zl58z7PPPsvw8PDssa9//euEYchdd9214HWtra1cffXVPPvss3OOP/vss5SXl18y6KuVLR4bBCCsXHgqc756+nNB3k1VS3ZPSZIkSZIkzW9FTeQdGhriwQcfpKOjg8cee4y+vj4+/elPMzExwcc+9rEFr9uzZw9/8Rd/MefY2bNn+aVf+iXuvvvuC+p/93d/d850gvr6+qV7EtIiXdNex7dePMZr3YN5Xxummoj6fkQ0dGLpG5MkSZIkSZK0Ij3wwAM88cQTPPzwwzz00EP09fXx6KOP8sADD9DU1DRb9+CDD3L8+HGeeuqp2WOPPPII/+pf/St++7d/m7e97W388Ic/5POf/zy/8Au/QGVlZTGejpbITJA3qFy69zp6+kcB2GyQV5IkSZIkadmtqCDvF7/4RUZHR/nsZz9LXV0dAJlMho9//OM89NBDc16IPF91dTU33XTTnGP/43/8D6Io4qd+6qcuqN+5cyfXX3/9Urcv5eXqLXUA9JwaZXhsilRl6aKvDWcm8g47kVeSJEmSJElaL2pra/nCF77AJz/5SR5++GGqqqq4//77L/jUuSiKyGQyc47dc889/If/8B/4gz/4A/78z/+cxsZGfvmXf5kPf/jDhXwKWmJxlCEeHwEgWKKJvHEc03MqG+Rta6hekntKkiRJkiRpYSsqyPv0009z5513zoZ4Ae677z5+8zd/k2eeeYb3ve99i77XV77yFTo6OrjhhhuWoVPpytVUltLaUEVP/yivdQ9y2zWNi742rG0GIBoyyCtJkiRJkiStJzt27ODxxx+/aM0TTzwx7/F3v/vdvPvd716GrlQs8fgwEEMQEpSnluSew2PTnB2fJgBaNjqtWZIkSZIkabmFxW7gfIcPH2b79u1zjqVSKRoaGjh8+PCi73Pq1Cmef/75eafxAnz4wx/m2muv5e677+Yzn/kMExMTV9S3dLmu2ZL9qLOD3YN5XTczkTc2yCtJkiRJkiRJ61Y8NghAUJEiCJfmLZ/j/WcBaKivoLQksST3lCRJkiRJ0sJW1ETe4eFhUqkL/8V4bW0tQ0NDi77P1772NTKZzAVB3pqaGn7xF3+R22+/nbKyMp5//nk+//nPc/jwYf7wD//winpPJldUJnrJJBLhnEctrWu31fOt7x/jtWODea2hxMYWxoB4YoQwPU5YXrV8TebB9aJ8uF6UD9eL8uF6UT5cL8qH60X5cL0oH64XSdLlikcHAQiq6pfsnsdOjQLQumllvO4sSZIkSZK01q2oIO9SefLJJ9mzZw/btm2bc3z37t3s3r17dv/OO++ksbGRT3ziE+zdu5cbbrjhsr5fGAbU16/tF7RSqYpit7Amven6Vj77Vz/k6MmzhCVJaqvLFnllFSPV9WTODlAVDVFe37isfebL9aJ8uF6UD9eL8uF6UT5cL8qH60X5cL0oH64XSVK+otmJvLVLds+e/lyQt2Ftv+8hSZIkSZK0UqyoIG8qlWJkZOSC40NDQ9TWLu5FqO7ubvbu3ctv/MZvLKr+vvvu4xOf+AT79u277CBvFMUMD49d1rUrXSIRkkpVMDw8TiYTFbudNal1UxU9p0b5zg+Pc/s1iw/kBqlGODvA4LEuyio3L2OHi+d6UT5cL8qH60X5cL0oH64X5cP1ony4XpSPtb5eUqkKpw1L0jKJc0HesLJuye55fHYib/WS3VOSJEmSJEkLW1FB3u3bt3P48OE5x0ZGRujv72f79u2LuseTTz5JGIa8+93vXo4WF5ROr703Wc6XyURr/jkWy9XtdfScGuWVzjPcfNWmRV8XpJrg+EHSZ3pJrLA/G9eL8uF6UT5cL8qH60X5cL0oH64X5cP1ony4XiRJ+ZoJ8gZVdUtzvzim59RZwIm8kiRJkiRJhbKiRmHcfffdPPvsswwPD88e+/rXv04Yhtx1112LusdXv/pV7rjjDhobFzfZ9Ktf/SoA119/ff4NS0tg15Y6AF7tHszruiDVDEA01LfEHUmSJEmSJEmSVoNoJsi7RBN5B0YmGZ/MkAgDmjdULsk9JUmSJEmSdHEraiLvAw88wBNPPMHDDz/MQw89RF9fH48++igPPPAATU1Ns3UPPvggx48f56mnnppz/YEDBzh06BAf/OAH573/r/3ar7F161Z2795NWVkZzz//PI8//jjveMc7DPKqaHa11wPQ03+Ws+PTVFeULOq6sDb730Q0bJBXkiRJkiRJktajmYm84RIFeXtOjQLQtKGSZGJFzYKRJEmSJElas1ZUkLe2tpYvfOELfPKTn+Thhx+mqqqK+++/n0ceeWROXRRFZDKZC65/8sknKS0t5d577533/jt37uTJJ5/k85//PNPT07S2tvKRj3yED3/4w8vyfKTFqK0qpWVjJb2nx3jt6CC3XN2wqOvC2pmJvCeI45ggCJazTUmSJEmSJEnSChOPDQFLN5G3pz8b5G3dVLUk95MkSZIkSdKlraggL8COHTt4/PHHL1rzxBNPzHv813/91/n1X//1Ba976KGHeOihh66kPWlZ7Gqvp/f0GAe78wjyphqAAKbGiSdGCCpSy9ukJEmSJEmSJGnFiKOIeDwX5K2qW5J79pw6CxjklSRJkiRJKiQ/F0laAa5prwPgYPfAoq8JkqUE1RsAiIb6lqMtSZIkSZIkSdIKFU8MQxxDEBCUL82gh9mJvA0GeSVJkiRJkgrFIK+0AuzaUgfA0ZNnGZ2YXvR1YW0zAPHQieVoS5IkSZIkSZK0QsWjgwAEFbUE4ZW/3RPFMcdPZ4O8m53IK0mSJEmSVDAGeaUVoLa6jOYNlcTAa0cHF31dWNsEOJFXkiRJkiRJktabeGwQgKCydknud2pogqnpiGQipLG+YknuKUmSJEmSpEszyCutELva6wA42D246GvC1EyQ14m8kiRJkiRJkrSeRLNB3roluV9P/1kANm+sJLEEE34lSZIkSZK0OL4SI60QlxXkrcsFeYedyCtJkiRJkiRJ68nMRN5wyYK8owBsbqhakvtJkiRJkiRpcQzySivEri31AHSfHGFsYnpR14SpZgCioT7iOF623iRJkiRJkiRJK0u8xBN5j5/KBnlbNxnklSRJkiRJKiSDvNIKUV9TRlN9BXEMrx0bWtQ1QWoTBCGkp2ZftJUkSZIkSZIkrX3R6CCwdEHeY7mJvK0N1UtyP0mSJEmSJC2OQV5pBdnVXgfAa92Di6oPwiRBTQMA0dCJZepKkiRJkiRJkrTSxOPZgRDhEgR5M1HEiTNO5JUkSZIkSSoGg7zSCrKrvR6AV7sHFn1NWNsEQDTUtyw9SZIkSZIkSZJWnng0+zpyUFV3xfc6OTBOOhNTVpJgY235Fd9PkiRJkiRJi2eQV1pBdm2pA+BI3wjjk+lFXXMuyOtEXkmSJEmSJElaD+IoIh4fBiBYgom8Pf3ZabybN1USBsEV30+SJEmSJEmLZ5BXWkE2pMpprKsgjuH1Y4OLumYmyBs7kVeSJEmSJEmS1oV4YhjiCAgIKlJXfL+eU9kgb+um6iu+lyRJkiRJkvJjkFdaYXa11wHwavfgourD2mYAomGDvJIkSZIkSZK0HsRjQwAEFTUEYeKK79fTfxaA1oaqK76XJEmSJEmS8mOQV1phZoK8Bxcb5E1lJ/JGQyeJo2iZupIkSZIkSZIkrRTx2AAAQWXdktzv3EReg7ySJEmSJEmFZpBXWmF2bakH4MiJEcYn05esD6o3QpiEKE08enq525MkSZIkSZIkFVk0M5F3CYK80+mIvjPjALQ2VF/x/SRJkiRJkpQfg7zSCrOxtpxNteVEccyPeoYuWR+EIWGqEYBoqG+525MkSZIkSZIkFVk8NghAuARB3hNnxojimMqyJHXVpVd8P0mSJEmSJOXHIK+0Al3Tnp3K+2r3wKLqw9omAKKhE8vWkyRJkiRJkiRpZYhHBwEIququ+F49p84CsLmhiiAIrvh+kiRJkiRJyo9BXmkF2tVeB8Br3YOLqg9mg7xO5JUkSZIkSZKktW5mIm+wBBN5e/pHAWjbVHXF95IkSZIkSVL+DPJKK9CuLXUAdPaOMDGVvmR9WNsMGOSVJEmSJEmSpPUgWoYg72aDvJIkSZIkSUVhkFdagTbVVbAxVU4Ux/yoZ+iS9aETeSVJkiRJkiRp3YjHsq8bh0sQ5D1+KhvkbW2ovuJ7SZIkSZIkKX8GeaUV6pr2OgAOdg9esjZMZYO88Ug/cXTpCb6SJEmSJEmSpNUpjqPZIG9QWXtF95qcztA/OA5Aa4MTeSVJkiRJkorBIK+0Ql2dR5A3qKqDZCnEEfHIqWXtS5IkSZIkSZJUPPHEWYgzwJUHeXtPjxIDNZUlpCpLl6A7SZIkSZIk5csgr7RCXdNeD0Bn7zCTU5mL1gZBODuVNxo6sey9SZIkSZIkSZKKIx4dACAoryEIk1d0r57+UQBaNzmNV5IkSZIkqVgM8kor1KbacjakyshEMT86PnTJ+rB2Jsjbt9ytSZIkSZIkSZKKJB7Lvl4cVNVd8b1mg7wN1Vd8L0mSJEmSJF0eg7zSChUEAbu2ZKfyHuweuGR9WNsMGOSVJEmSJEmSpLUsHhsEIKisu+J79ZxyIq8kSZIkSVKxGeSVVrBr2usAONg9eMlaJ/JKkiRJkiRJ0toX5YK84ZIEec8C0NpgkFeSJEmSJKlYDPJKK9iuXJD38PFhJqczF60NZoO8J5a7LUmSJEmSJElSkSzVRN6xiTRnhicBJ/JKkiRJkiQVk0FeaQVrqKugvqaMTBRzqGfoorVhbTMA8dkzxOmpQrQnSZIkSZIkSSqwpQryHj89CkB9TRmV5SVX2JUkSZIkSZIul0FeaQULgmB2Ku/B7sGL15bXQEkFEBMN9y97b5IkSZIkSZKkwouWKMjb038WcBqvJEmSJElSsRnklVa4a9rrATjYPXDRuiAICGubAIiGTyx7X5IkSZIkSZKkwotHBwEIK2uv6D49p7ITeTcb5JUkSZIkSSoqg7zSCrdrSx0Ah3uHmZrOXLQ2rG0GIB7qW+62JEmSJEmSJEkFFscx8fgQAEFV/RXdq6c/G+RtbTDIK0mSJEmSVEwGeaUVrrG+grrqUtKZmEPHhy9aOzuRd8iJvJIkSZIkSZK01sSTZyHKDnwIKpZmIm9bQ/UV9yVJkiRJkqTLZ5BXWuGCIGBXe3aywsHugYvWngvyOpFXkiRJkiRJktaaeHQQgKC8hiCRvOz7jIxNMTw6BUDLxsqlaE2SJEmSJEmXySCvtArsaq8D4GD34EXrwtpmwCCvJEmSJEmSJK1F8dggAEHllU3jPZ6bxruptpzy0ssPBEuSJEmSJOnKGeSVVoFdW+oAOHR8mOl0ZsG6mYm88dgg8fREIVqTJEmSJEmSJBXIuSBv3RXd51h/NsjbuqnqCjuSJEmSJEnSlTLIK60CzRsqqa0qJZ2JOHx8eMG6oKyKoKwacCqvJEmSJEmSJK010RIFeWcm8rY2VF9hR5IkSZIkSbpSBnmlVSAIAna11wFwsHvw4rV1zQBEwwZ5JUmSJEmSJGktiUcHAQivMMjb038WgNYGJ/JKkiRJkiQVm0FeaZXY1V4PwKvdAxetC1NNAESDJ5a9J0mSJEmSJElS4cRLMJE3jmOO9ecm8m4yyCtJkiRJklRsBnmlVeKa3ETeQ8eHmU5HC9aFtbkgrxN5JUmSJEmSJGlNiWaDvLWXfY+Tg+OMTaZJJkI2G+SVJEmSJEkqOoO80irRvKGSVFUp0+mIzt7hBevC2mYAoiGDvJIkSZIkSZK0lsxM5A2r6i/7HjOvL7c3VZNM+DaRJEmSJElSsfkKjbRKBEHAri11ABzsHliwbmYib2yQV5IkSZIkSZLWjDiOiceGgCubyNvVOwLAtubUkvQlSZIkSZKkK2OQV1pFdrXXAfBq9+CCNWGqEYB4YoR4crQAXUmSJEmSJEmSlt3kKERpAILKusu+TVduIm9HS81SdCVJkiRJkqQrZJBXWkV2tWc/Lu1QzxDpTDRvTVBaMfsibuRUXkmSJEmSJElaE6KxwexGWRVBouTy7hHFHOk7C0BHixN5JUmSJEmSVgKDvNIqsnljJTWVJUylIzpzUxPmE9Y2ARANnShUa5IkSZIkSZKkZRTngrxhZf1l3+P46VEmpzOUlSZo2VC5RJ1JkiRJkiTpShjklVaRIAjYtaUOgFe7BxesC1MzQV4n8kqSJEmSJEnSWjAT5A0qay/7Hl29IwBsbaohDIOlaEuSJEmSJElXyCCvtMrsas9OW3ite2DBmqC2GYBo2CCvJEmSJEmSJK0F0eggAEFl3WXfo/NE9pPetrXULEFHkiRJkiRJWgoGeaVVZld7HQCv9wyRzkTz1oS1TuSVJEmSJEmSpLVkZiJvWFV32ffo6p0J8qaWoCNJkiRJkiQtBYO80iqzeVMV1RUlTE1HdJ0YmbfmXJD3BHEcF7I9SZIkSZIkSdIymAnyXu5E3nQm4ujJswB0GOSVJEmSJElaMQzySqtMGATs2lIHwMHugflrUo1AAFPjxBPzh30lSZIkSZIkSatHdIVB3mP9Z0lnYqrKkzTUli9dY5IkSZIkSboiBnmlVWhXex0AB7sH5z0fJEsJqjcAEA31FagrSZIkSZIkSdJyiceGgMsP8nb2Zoc+dLSkCIJgqdqSJEmSJEnSFTLIK61Cu9rrAXj92BDpTDRvTVjbBEA8dKJgfUmSJEmSJEmSll4cx8Rj2U9oCy87yDsMwLaWmqVqS5IkSZIkSUvAIK+0CrU2VFFVnmRyOsORvpF5a8LaZsCJvJIkSZIkSZK06k2NQSYNQFBZe1m36JqZyNucWrK2JEmSJEmSdOUM8kqrUBgEXL2lDoCD3YPz1+Qm8mbOHC1QV5IkSZIkSZKk5RCNDmY3yqoIkqV5Xz85neH4qVEAtrUY5JUkSZIkSVpJDPJKq9Q17fXAwkHeRMsuADLHXyXOTBeqLUmSJEmSJEnSEovHBgEIL3Mab3ffCFEcU1tdSn1N2RJ2JkmSJEmSpCtlkFdapXa11wHw2rFBMlF0wflw41aCyjpIT5LpPVjY5iRJkiRJkiRJS2YmyBtU1l3W9V29IwBsa3YaryRJkiRJ0kpjkFdapdoaq6kqTzI5laG77+wF54MgINl+AwDp7pcL3Z4kSZIkSZIkaYlEVxjk7TwxDEBHS80SdSRJkiRJkqSlYpBXWqXCIGBnWx0Ar3YPzFuTaL8RgPSRl4jjuFCtSZIkSZIkSZKW0MxE3vByg7wzE3lbnMgrSZIkSZK00hjklVaxa9rrADjYPTjv+WTrHgiTxCP9REO9hWtMkiRJkiRJkrRk4iuYyDs2MU3fmTEAOpqdyCtJkiRJkrTSGOSVVrFd7fUAvH5skEwUXXA+KCkn0bILgEz3ywXtTZIkSZIkSZK0NOKxIeDygrxHTmSn8W6qLaemsnQp25IkSZIkSdISMMgrrWJbGqupKEsyPpmhu+/svDXJrTcBkO7eW8DOJEmSJEmSJElLJRodACCoqsv72s5ckLejJbWULUmSJEmSJGmJGOSVVrEwDNi1pQ6Ag92D89Yk228EINP7GvHUWIE6kyRJkiRJkiQthTiOZyfyhpcxkbezdxiAbS01S9mWJEmSJEmSlohBXmmVu3o2yDsw7/kw1UhY2wxxhvSxfQXsTJIkSZIkSZJ0xabGIDMFQFBZm/flXb25ibzNTuSVJEmSJElaiQzySqvcNVvrAHjt2BBRFM9bk8hN5U13v1yotiRJkiRJkiRJSyDKTeOltIIgWZbXtcNjU5weniAAOpqdyCtJkiRJkrQSGeSVVrn2xhoqyhKMT6Y5evLsvDXJrTcBkOneSxxHBexOkiRJkiRJknQl4rFBAMLKuryv7eodBqB5YyUVZckl7EqSJEmSJElLxSCvtMqFYcDOtjoADnYPzFuTaN4JJRXEEyNE/Z0F7E6SJEmSJEmSdCVmgrzBZQV5RwDoaE4tYUeSJEmSJElaSgZ5pTVgV3sdAK92D857PgiTJNv2AJDufrlAXUmSJEmSJEmSrtSVBHk7cxN5O1pqlrAjSZIkSZIkSFK+ngAAgZ5JREFULSWDvNIacE17PQCvHxskiuN5a5LtNwIGeSVJkiRJkiRpNYlGB4H8g7xxHNN5IjuRd1uLE3klSZIkSZJWKoO80hrQ3lRNeWmC0Yk0x06enbcmseUGICA6dYRodKCwDUqSJEmSJEmSLsvMRN4wzyDvwMgkw6NThEFAe2P10jcmSZIkSZKkJWGQV1oDEmHIzrY6AA52D85bE1bWEjZsAyB9dG+BOpMkSZIkSZIkXYmZIG9QVZfXdZ292Wm8rQ1VlJYklrgrSZIkSZIkLRWDvNIacU17HQCvdi88bTfZfiMAme6XC9GSJEmSJEmSJOkKRWNDAAR5TuTtOjEMwLaWmqVuSZIkSZIkSUvIIK+0RlydC/K+dnSQKI7nrZkJ8qaP7SfOTBeqNUmSJEmSJEnSZYjjmHgsO7whrKzN69rO3myQt6MlteR9SZIkSZIkaekY5JXWiK1NNZSVJhidSNPTPzpvTbipPTu1IT1JpvdgYRuUJEmSJEmSJOVnegLSU0B+E3njOKardwSAbc0GeSVJkiRJklYyg7zSGpFMhOxszU5kONg9MG9NEIQkt9wAQLr75YL1JkmSJEmSJEnKXzw2mN0oKScoKV/0dScHxxmbTJNMhLQ2VC1Pc5IkSZIkSVoSBnmlNWRXex0AB7sHF6xJtN8IZIO8cRwXoCtJkiRJkiRJ0uWIckHeMI9pvACdvcMAtDdVk0z4VpAkSZIkSdJK5qs30hqyq70egINHB4kWCOkmW3dDmCAePkk8dKKQ7UmSJEmSJEmS8jAzkTfIM8jb1TsCwLbm1BJ3JEmSJEmSpKVmkFdaQzqaaygtCTk7Ps3xU6Pz1gSlFSRargEg3f1SAbuTJEmSJEmSJOUjHh0EIKiqy+u6rtxE3o6WmiXuSJIkSZIkSUvNIK+0hiQTITtbawE42D24cF37jQCku/cWoi1JkiRJkiRJ0mWILmMibxTFHOk7C0BHixN5JUmSJEmSVjqDvNIas6u9HoCD3QML1swEeTO9rxFPjRWkL0mSJEmSJElSfuJckDfMI8h7/PQok9MZykoTtGyoXJ7GJEmSJEmStGQM8kprzK72OgAOHh0kjuN5a8LaJsLaZogzpI/tL2B3kiRJkiRJkqTFii9jIm9X7wgAW5tqCMNgGbqSJEmSJEnSUjLIK60x21pSlCZDRsamOX564Wm7idxU3nT3SwXqTJIkSZIkSZKUj2g2yFu76Gs6TwwDsK2lZjlakiRJkiRJ0hIzyCutMclEyFVt2Rd1D3YPLFyXC/Jmjv6QOI4K0pskSZIkSZIkafHisSEAwsr6RV/T1TsT5E0tS0+SJEmSJElaWgZ5pTVo15Y6AA52Dy5Yk2i+GkrKiceHifq7CtKXJEmSJEmSJGlx4qlxmJ4AFj+RN52JOHryLAAdBnklSZIkSZJWhWSxG5C09Ha11wOdHOweII5jgiC4oCZIJEm2XUe68wXS3S+TaNxe+EYlSZIkSZIk5eXQoUN86lOf4gc/+AFVVVW85z3v4d/8m39DaWnpRa+755576OnpueD43r17KSsrW652dQVmpvFSUk5QWrGoa471nyWdiakqT9JQW76M3UmSJEmSJGmpGOSV1qBtLSlKkiHDY9OcODNGy8aqeeuS7TfmgrwvUXbbewvcpSRJkiRJkqR8DA0N8eCDD9LR0cFjjz1GX18fn/70p5mYmOBjH/vYJa+/9957+dCHPjTn2KUCwCqeaGwQWPw0XoDO3hEgO413vgEPkiRJkiRJWnlWXJB3uacJ9PX18alPfYpvf/vblJSU8M53vpPf+I3foLq6esmfi1QsJcmQq1preeXIAK92Dy4Y5E1suQGA6NQRorFBwsq6AnYpSZIkSZIkKR9f/OIXGR0d5bOf/Sx1dXUAZDIZPv7xj/PQQw/R1NR00es3bdrETTfdtPyNaknEuSBvPq/bdvYOA7CtpWYZOpIkSZIkSdJyCIvdwPlmpglMT0/z2GOP8cgjj/ClL32JT3/604u6/t577+Uv/uIv5nydHwCenp7mF3/xF+nq6uL3fu/3+K3f+i2+/e1v86u/+qvL9ZSkotm1pQ6AvT86tWBNWFlL2LANgHT3y4VoS5IkSZIkSdJlevrpp7nzzjtnQ7wA9913H1EU8cwzzxSvMS2LeHYib92ir+mamcjbnFqGjiRJkiRJkrQcVtRE3uWeJvCNb3yD119/na997Wts374dgFQqxS/8wi+wd+9ebrjhhqV6KlLR3X5tI1/+did7D52m78wYTRsq561Ltt/EVH8nme69cM1bC9ylJEmSJEmSpMU6fPgw73//++ccS6VSNDQ0cPjw4Ute/+STT/KlL32JkpISbrvtNn7t136NXbt2LVe7ukJRnkHeyekMx0+NArCtxSCvJEmSJEnSarGigrwLTRP4zd/8TZ555hne9773XfH9d+3aNRviBbjrrruoq6vjH//xHw3yak1p2VjFDTs2svfQaf72e0f5+Xvnf0E+2X4jUy/+Nelj+4gz0wSJkgJ3KkmSJEmSJGkxhoeHSaUuDGjW1tYyNDR00WvvuecebrjhBjZv3szRo0f53Oc+x8/93M/x5S9/mS1btlx2T8nkivrgvyWTSIRzHoshGM/+mSar6xf1cz7cO0wUx9RVl9JQX7Hc7ek8K2G9aPVwvSgfrhflyzWjfLhelA/Xi/LhelE+XC9ZKyrIu9zTBA4fPjwnxAsQBAHbtm1b1P2l1ebeO9rZe+g0z/ywl/fevZ3qigtDuuGmdoKKWuLxITK9B0m2XVeETiVJkiRJkiQtp//7//6/Z7dvu+027rrrLu677z7+9E//lN/6rd+6rHuGYUB9fdUSdbgypVLFC8SOT40AUN3YRM0ifs59PzwBwK6tG9b8n8tKVcz1otXH9aJ8uF6UL9eM8uF6UT5cL8qH60X5WO/rZUUFeZd7msDw8DA1NTWXdf9LceqAVqLrtm9ga3MNR06M8I8v9fCeH98+T1VIydYbmXr1aaJje0l2XP5kateL8uF6UT5cL8qH60X5cL0oH64X5cP1ony4XiQtViqVYmRk5ILjQ0ND1NbW5nWvxsZGbr31Vvbv33/Z/URRzPDw2GVfv5IlEiGpVAXDw+NkMlFRepgaOg3AOBWkB0YvWb//0CkAWjdVMrCIei2dlbBetHq4XpQP14vy5ZpRPlwvyofrRflwvSgfa329pFIVi3rtf0UFea/EckwTWCynDmglu/+enfzen32fb32/h5+7bzelJYkLakr3vJm+V58mc3QvdXWVBEFwRd/T9aJ8uF6UD9eL8uF6UT5cL8qH60X5cL0oH64XSZeyffv2Cz5dbmRkhP7+/gs+ja5Q0um19wbL+TKZqGjPMRodzD6WpRbVw6HjwwBsbapZ838uK1Ux14tWH9eL8uF6Ub5cM8qH60X5cL0oH64X5WO9r5cVFeRd7mkCqVSKs2fPznv/lpaW/BvOceqAVrI9W+vYUFPGmZFJvvbtQ7z1ptYLauL6HRAmSA+c4HTnIRL1l/ffg+tF+XC9KB+uF+XD9aJ8uF6UD9eL8uF6UT7W+npZ7MQBSZd2991387nPfW7Op9t9/etfJwxD7rrrrrzu1dfXx4svvsh73vOe5WhVVyienoTpcQDCyvpL1o9NTNN3Jvs+RUfzhZ9MKEmSJEmSpJVrRQV5l3uawPbt23nttdfmHIvjmM7Ozrxf5HyjtZ4GX++J99Xu7be18d///hBff76bt+xpvnDiblhGouUaMj37mez8AaU1TVf0/VwvyofrRflwvSgfrhflw/WifLhelA/Xi/LhepF0KQ888ABPPPEEDz/8MA899BB9fX08+uijPPDAAzQ1nXtN78EHH+T48eM89dRTAHzlK1/h7//+73nrW99KY2MjR48e5Y/+6I9IJBJ88IMfLNbT0UXEY4PZjWQplJRfsv7IieyQlE215dRUli5jZ5IkSZIkSVpqK2oUxt13382zzz7L8PDw7LErnSZw/fXXz7n/q6++SldX1+yx5557jsHBQd761rdecf/SSvXWGzdTVpqg59Qo+zrPzFuTbL8BgHT3y4VsTZIkSZIkSdIi1dbW8oUvfIFEIsHDDz/M7/3e73H//ffzb//tv51TF0URmUxmdr+trY2TJ0/yO7/zO/zCL/wCv/d7v8eePXv44he/yJYtWwr9NLQIUS7IG1TWXziYYR6duSBvR0tqOduSJEmSJEnSMlhRE3mXe5rAvffeyx/+4R/yy7/8y3z0ox9lfHycRx99lLe97W3ccMMNBX++UqFUlpdw9w2beeqFo3zju91cv33jBTXJ9puYfO7PyfS+Rjw1TlBaUYROJUmSJEmSJF3Mjh07ePzxxy9a88QTT8zZv+mmmy44ppVtZiJvWFm7qPrO3uyAlG0tNcvVkiRJkiRJkpbJigryzkwT+OQnP8nDDz9MVVUV999/P4888sicuotNExgZGaGmpoY3v/nN/Mqv/MqcaQIlJSX8yZ/8CZ/61Kf46Ec/SjKZ5J3vfCf/7t/9u4I9R6lY3nlbG9988SgHugbo7huhvWnuC7phbRNBbTPx0AnSx/ZRsv32InUqSZIkSZIkSetbPDoIQFBZt6j6rt7cRN5mJ/JKkiRJkiStNisqyAvLP02gqamJxx577HLbk1atTXUV3Larke+9epK//d5RfvGndl9Qk2y/kekfniDd/bJBXkmSJEmSJEkqkig3kXcxQd7hsSlOD08QAB3NTuSVJEmSJElabcJiNyCpcH7iTe0AfOdAHwMjkxecT7bfCEDm6F7iOCpob5IkSZIkSZKkrDiPIG9X7zAAzRsrqShbcfNbJEmSJEmSdAkGeaV1ZFtLiqvbaslEMd968dgF5xPNV0NJOfH4MFF/V+EblCRJkiRJkiTNBnnDqrpL1nb2jgDQ0Zxaxo4kSZIkSZK0XAzySuvMvXdkp/L+ww96mJhKzzkXJJIk264DIN39csF7kyRJkiRJkiRBPDYE5DeRt6OlZjlbkiRJkiRJ0jIxyCutMzfu3ERTfQVjk2m+vbf3gvPJ9hsBg7ySJEmSJEmSVCzR2ABw6SBvHMd0nshO5N3W4kReSZIkSZKk1cggr7TOhEHAu27fAsBTLxwliuI55xNbbgAgOtVFlPv4NkmSJEmSJElSYcTpSZgaByCsrL1o7cDIJMOjU4RBQHtjdSHakyRJkiRJ0hIzyCutQ2+5voXqihL6Byf4/mv9c86FlbWEDdsAp/JKkiRJkiRJUqHFY0PZjUQplFZetLazNzuNt7WhitKSxHK3JkmSJEmSpGVgkFdah8pKErzt5lYAvvG97gvOJ9tvBCDTvbegfUmSJEmSJEnSejfzSWlBZS1BEFy0tuvEMADbWmqWuy1JkiRJkiQtE4O80jr19ltaSSYCDvUM86OeoTnnZoK86Z79xJnpYrQnSZIkSZIkSetSnAvyhpV1l6zt7M0GeTtaUsvYkSRJkiRJkpaTQV5pnaqtLuPNe5oB+MZ3507lDTdtJaiohekJMr2vFaM9SZIkSZIkSVqX4tFBAIKquovXxTFdvSMAbGs2yCtJkiRJkrRaGeSV1rF7b98CwPdf6+fk4Pjs8SAISbbfAEC6+6VitCZJkiRJkiRJ69LMRN7gEhN5Tw6OMzaZJpkIaW2oWv7GJEmSJEmStCwM8krrWGtDNddt30Acw1PfOzrnXKL9RgDS3XuL0ZokSZIkSZIkrUvRIoO8nb3DALQ3VZNM+HaPJEmSJEnSauUrO9I6d+8d7QB8e28voxPTs8eTrXsgTBAP9xENnihWe5IkSZIkSZK0rsRjQwCElwjydvWOALCtObXcLUmSJEmSJGkZGeSV1rndW+tpa6hmcjrDP/ygZ/Z4UFpBouUaANLdLxerPUmSJEmSJElaV+KxAeDSE3m7chN5O1pqlrslSZIkSZIkLSODvNI6FwQB996xBYBvvniMdCaaPZdsvwGAdPdLxWhNkiRJkiRJktadKDeR92JB3iiKOdJ3FoCOFifySpIkSZIkrWYGeSXxpt1N1FWXMnR2iu8c6Js9nmy/EYBM72vEU+PFak+SJEmSJEmS1oU4PQWTowCEVXUL1h0/PcrkdIay0gQtGyoL1J0kSZIkSZKWg0FeSSQTIW+/tQ2Ab3y3mziOAQhrmwlqmyDOkD62r5gtSpIkSZIkSdKaF+em8ZJIQunCAd2u3hEAOppqCMOgEK1JkiRJkiRpmRjklQTA225upawkwbH+UQ50DcweT7bfBEC6e2+ROpMkSZIkSZKk9SEeGwQgqKwjCBYO6HaeGAago6WmEG1JkiRJkiRpGRnklQRAVXkJP3ZDC5Cdyjsj2X4jAJmjLxPHUVF6kyRJkiRJkqT1IDovyHsxXb3ZIO+2ltQydyRJkiRJkqTlZpBX0qx33r6FIIB9nWc41n8WgETz1VBSTjw+TNTfVdwGJUmSJEmSJGkNm5nIG14kyJvORBw9mX39tsMgryRJkiRJ0qpnkFfSrMa6Cm65ugGAv/3uUQCCRJJk23UApLtfLlpvkiRJkiRJkrTWxYuYyHus/yzpTExVeZKG2vLCNCZJkiRJkqRlY5BX0hz33tEOwPMHTjB0dhKAZPuNAKSP7i1aX5IkSZIkSZK01kWLCPJ29o4A2Wm8QRAUoCtJkiRJkiQtJ4O8kua4qrWWHa0p0pmYb33/GACJLdcDEPV3zr6QLEmSJEmSJElaWvHoIABhVd2CNZ29wwBsa6kpQEeSJEmSJElabgZ5JV3g3tuzU3n//vs9TE5lCCvrCBu2AZDpdiqvJEmSJEmSJC2HeGwIuPhE3q6ZibzNqUK0JEmSJEmSpGVmkFfSBW65uoGGunJGJ9I8s68XgGT7jQCku18uZmuSJEmSJEmStGZFYwMABJW1856fnM5w/NQoANtaDPJKkiRJkiStBQZ5JV0gDAPelZvK+7ffO0oUxeeCvD37iTPTxWxPkiRJkiRJktacODMNk9mQblhZP29Nd98IURxTW11KfU1ZIduTJEmSJEnSMjHIK2leP3Z9C1XlSU4OjPPSj04RbtpKUJGC6Qkyva8Vuz1JkiRJkiRJWlPisaHsRpiEsqp5azp7RwDY1uw0XkmSJEmSpLXCIK+keZWVJnjbza0AfOO73QRBSGJLbipv98vFbE2SJEmSJEmS1px4bBCAoLKWIAjmrek6MQxAR0tNodqSJEmSJEnSMjPIK2lB99zSRiIMeP3YEIePD5PcmgvyHjXIK0mSJEmSJElLKZoN8tYtWDM7kbfFibySJEmSJElrhUFeSQuqrynjzbubgOxU3mTrHggTxEN9RIMnitydJEmSJEmSJK0d8eggAOECQd6xiWn6zowB0NHsRF5JkiRJkqS1wiCvpIt61x3tALxw8CSnxyDRsguAdLdTeSVJkiRJkiRpqcSXmMh75ER2Gu+m2nJqKksL1JUkSZIkSZKWm0FeSRe1pbGaPR31xDE89cIxkltuBCB91CCvJEmSJEmSJC2VaCbIW1U37/nOXJC3oyVVoI4kSZIkSZJUCAZ5JV3SvbmpvE/vPc508x4AMr0HiafGi9mWJEmSJEmSJK0ZMxN5wwUm8nb2DgOwraWmQB1JkiRJkiSpEAzySrqkPds20NpQxeRUhqc7MwS1TRBlSB/bV+zWJEmSJEmSJGlNiMeGAAgqa+c93zUT5G12Iq8kSZIkSdJaYpBX0iUFQcC7bt8CwDdfOEbYdgMA6e69xWxLkiRJkiRJktaMmYm8QWX9BeeGR6c4PTxJAGxtdiKvJEmSJEnSWmKQV9KivHl3M7VVpQyMTPIj2gHIHH2ZOI6K3JkkSZIkSZIkrW5xJk08MQLMP5G360R2Gm/zxkoqypIF7U2SJEmSJEnLyyCvpEUpSYbcc2sbAF8+mISScuLxYaJTR4rcmSRJkiRJkiStbvH4UHYjTBCUV19wvrM3G/LtaE4Vsi1JkiRJkiQVgEFeSYv2T25upTQZ0nVynLH6qwFIH3mpuE1JkiRJkiRJ0ioXjw0CEFTUEgQXvnXT1ZudyNvRUlPItiRJkiRJklQABnklLVp1RQl33dACwAtnmwBIH91bzJYkSZIkSZIkadWLRgcBCKrqLjgXxzGdJ7ITebe1OJFXkiRJkiRprTHIKykv77p9CwHwtz11AET9nUS5aRGSJEmSJEmSpPzNTOQNK+suODcwMsnw6BRhENDeWF3YxiRJkiRJkrTsDPJKyktTfSU37dzESFzBmZJmADJHf1jkriRJkiRJkiRp9ZoJ8gbzBHk7e7PTeFsbqigtSRSwK0mSJEmSJBWCQV5Jebv3jnYAvjfSBED6yEtF7EaSJEmSJEmSVreLBXm7TgwDsK2lpoAdSZIkSZIkqVAM8krK2862Wra1pNg32QpAumc/cSZd5K4kSZIkSZIkaXWKxoYACCprLzjX2ZsN8na0pArakyRJkiRJkgrDIK+kvAVBwL13bOFoZiMjcQVMT5A58Vqx25IkSZIkSZKkVSkeGwAgrKyfezyO6eodAWBbs0FeSZIkSZKktcggr6TLcuuuBjakKtg/tRmAdPfLRe5IkiRJkiRJklafOI6Jz2aDvG+cyHtycJyxyTTJREhrQ1Ux2pMkSZIkSdIyM8gr6bIkwpB33r6FA1NtAKSPvFTchiRJkiRJkiRpFYoGjxNPnoVECWFdy5xznb3DALQ3VZNM+JaOJEmSJEnSWuSrPpIu24/f0MKRcAvpOCQe7iMzeKLYLUmSJEmSJEnSqpI5tg+ARPPVBMnSOee6ekcA2NacKnhfkiRJkiRJKgyDvJIuW0VZkjtv6uBQuhGAaafySpIkSZIkSVJe0sf2A5Bsu+6Cc125ibwdLTUF7UmSJEmSJEmFY5BX0hV5+61tvJJuA2D4tReL3I0kSZIkSZIkrR5xZppM76sAJNr2zDkXRTFH+s4C0NHiRF5JkiRJkqS1yiCvpCuyIVVOSfuNAIT9rxNNjhe5I0mSJEmSJElaHTJ9P4L0FEFFinBD25xzx0+PMjmdoaw0QcuGyiJ1KEmSJEmSpOVmkFfSFXvLW26iP1NDgogTP/xusduRJEmSJEmSpFUhc2w/AInWPQTB3LdsOnuHAehoqiEMg4L3JkmSJEmSpMIwyCvpirU31dBbvgOAI898gziOi9yRJEmSJEmSJK186Z5skDfZdt0F57pOjADQ0VJT0J4kSZIkSZJUWAZ5JS2JxlvvIRMHNJ09yCtPfbnY7UiSJEmSJEnSihZPnCXq7wIg0br7gvNduYm821pShWxLkiRJkiRJBWaQV9KS2HnDDRxqejsADa//T469ur/IHUmSJEmSJEnSypXuOQDEhPVthFX1c89lIo6ePAtAh0FeSZIkSZKkNc0gr6Qlc9t7/0+6y64iGURE//ifGT4zUOyWJEmSJEmSJGlFyhzbB0Cibc8F5471nyWdiakqT9JQW17o1iRJkiRJklRABnklLZlEIuSWX/gNBkhRH5zlyF//R6bT6WK3JUmSJEmSJEkrShzHpHuyn2qWbL0wyNvZOwJkp/EGQVDQ3iRJkiRJklRYBnklLalUfR3l7/zXTMcJOjJdfP+v/1uxW5IkSZIkSZKkFSUe6iM+exrCJImWXRec7+wdBmBbS02hW5MkSZIkSVKBGeSVtOQ277yGgV3vBeCaM//A97/97SJ3JEmSJEmSJEkrR/rYPgASzTsJSsouON81E+RtThW0L0mSJEmSJBWeQV5Jy2L7W3+S3tobCYOYpn3/jc7DR4vdkiRJkiRJkiStCJme/QAk2vZccG5yOkPPqVEAOloM8kqSJEmSJK11BnklLYsgCNjx3n/JQGIjqXCckb/9A4aGx4rdliRJkiRJkiQVVRylSR9/BYBk63UXnO/uGyGOoba6lPqaC6f1SpIkSZIkaW0xyCtp2SRKy9n0048wSQnbwl6+/5d/SjoTFbstSZIkSZIkSSqazMnDMD1BUFZNuKn9gvOdvSMAbGt2Gq8kSZIkSdJ6YJBX0rKqbGwjftPPA3Bb+kX+7m++VuSOJEmSJEmSJKl4Msf2AZBo3U0QXPg2TdeJYQA6WmoK2pckSZIkSZKKwyCvpGXXcOPdDLX9GAA39P0Nzz6/r8gdSZIkSZIkSVJxpI/tByDZdt2852cn8rY4kVeSJEmSJGk9MMgrqSBa7/0XDFe0UhVOUfv9/8LrR04VuyVJkiRJkiRJKqh4cpSo/zAAibY9F5wfm5im78wYAB3NTuSVJEmSJElaDwzySiqIIJGk+WceYTIopz15miNf+1MGRiaL3ZYkSZIkSZIkFUz6+CsQx4R1LYTVGy84f+REdhrvptpyaipLC92eJEmSJEmSisAgr6SCSdRsourtHwHgTYlXeOq//yXT6UyRu5IkSZIkSZKkwsgc2w9AovXCabwAnbkgb0dLqmA9SZIkSZIkqbgM8koqqIrtNzF97X0A3DP99/z1V54ljuMidyVJkiRJkiRJyy99bB8AybYFgry9wwBsa6kpWE+SJEmSJEkqLoO8kgqu/q4PMLFhJ2VBmpt7/5J/+N7hYrckSZIkSZIkScsqGj5JPNIPQYJEyzXz1nTNBHmbncgrSZIkSZK0XhjklVRwQRiy8d3/mqlkDc2JIfjOf+PVrjPFbkuSJEmSJEmSls3MNN5E0w6C0ooLzg+PTnF6eJIA2NrsRF5JkiRJkqT1wiCvpKIIK2up/Yl/TUTAbWWHeeErf8npoYlityVJkiRJkiRJyyJzbD8Aibbr5j3fdSI7jbd5YyUVZcmC9SVJkiRJkqTiMsgrqWiSm3dRctv9APxkyfP8xV99k8npTJG7kiRJkiRJkqSlFUcZ0scPAJBs2zNvTWfvCAAdzamC9SVJkiRJkqTiM8grqagqbn43UeuNJIOId09+nT/76kvEcVzstiRJkiRJkiRpyUT9nTA1DqWVhJu2zVvT1ZudyNvRUlPI1iRJkiRJklRkBnklFVUQBKTe8WHSFRvZmDjLNcf+mm9850ix25IkSZIkSZKkJZM+th+AZOtugvDCt2biOKbzRHYi77YWJ/JKkiRJkiStJwZ5JRVdUFZF6r5fJgqSXFd6jDPP/w37O88Uuy1JkiRJkiRJWhKZnmyQN9F23bznB0YmGR6dIhEGtDdWF7I1SZIkSZIkFZlBXkkrQmJTBxU/9n8C8O6KH/CNJ5/i5OB4kbuSJEmSJEmSpCsTT42T6fsRAMnWPfPWdPYOA9C6qYrSkkTBepMkSZIkSVLxGeSVtGKUXPNWwqveQiKI+ael/8B/+cvnmZhKF7stSZIkSZIkSbpsmeOvQhwRpJoIUw3z1nSdGAGgo6WmkK1JkiRJkiRpBTDIK2nFCIKAyh9/kLh2M7XhOO+c/Dr/5Sv7ieO42K1JkiRJkiRJ0mVJ9+wDINk2/zReODeRt6MlVZCeJEmSJEmStHIY5JW0ogQlZVTf+8tEiTJ2lvTRdPQpvvb8kWK3JUmSJEmSJEmXJX1sPwCJ1vmDvFEU09mbnci7rdkgryRJkiRJ0npjkFfSihPWtVD5tg8B8M6Kfbz67NPsPXSqyF1JkiRJkiRJUn6ikVPEQycgCEluvmbemq4TI4xPpqksS7KlsbrAHUqSJEmSJKnYDPJKWpFKdryJkj3vAOCfV32bLz35HU6cGStyV5IkSZIkSZK0eOme7DTesHE7QVnVvDX7u84AcO3WesIwKFhvkiRJkiRJWhkM8kpascre/ABBwzaqwil+tvTv+IO//AHjk+lityVJkiRJkiRJi5I5lg3yJlv3LFhzoDMb5N3dUV+QniRJkiRJkrSyGOSVtGIFiSSV73iYuLSK9uRp3jzxNH/ylQNEcVzs1iRJkiRJkiTpouIomp3Im2i7bt6ayakMP+oZAmD3tg0F602SJEmSJEkrh0FeSStaWLOJynseAuDHyw8SHvkuTz7TVdymJEmSJEmSJOkSotNHYHIUSipING6bt+bg0UEyUczGVDmNdRUF7lCSJEmSJEkrgUFeSStesv0GSm/+aQD+WdXzPP/sD/jBa/1F7kqSJEmSJEmSFpY+tg+A5OZrCMLkvDUHus4AsGdbPUEQFKw3SZIkSZIkrRwGeSWtCqW3vpfE5mspC9J8qOYfefwrL9NzarTYbUmSJEmSJEnSvDLH9gOQaLtuwZqZIO/ujg0F6UmSJEmSJEkrz4oL8h46dIgPfvCD3HTTTdx11108+uijTE1NXfSakydP8uijj/Ke97yHm2++mbvvvptf/dVfpaenZ07dd77zHXbt2nXB1yOPPLKcT0nSEgjCkPJ7PgKVtTQnhviZkmf47F+9zNjEdLFbkyRJkiRJkqQ54ukJMn2vA5Bs2zNvzdDZSY71Z4cVXLu1vmC9SZIkSZIkaWWZ/7OcimRoaIgHH3yQjo4OHnvsMfr6+vj0pz/NxMQEH/vYxxa8bv/+/Tz11FO8//3v58Ybb2RgYID//J//Mx/4wAf4yle+woYNc/8l++/+7u+yffv22f36el8gk1aDsLKWirf/K8a+8hluK+vk8OjLfObPknz4p3fT2lBd7PYkSZIkSZIkCYBM70GIMgQ1mwhSTfPWHDgyAEB7UzU1laWFbE+SJEmSJEkryIoK8n7xi19kdHSUz372s9TV1QGQyWT4+Mc/zkMPPURT0/wvdt166638r//1v0gmzz2dW265hbe97W18+ctf5kMf+tCc+p07d3L99dcv2/OQtHySLbsov+MDTH7nL3hf5ff4ozM1fPzxUT7wtqt4+21thEFQ7BYlSZIkSZIkrXPpY/sBSLbuIVjgNcsDXWcA2NOxYd7zkiRJkiRJWh/CYjdwvqeffpo777xzNsQLcN999xFFEc8888yC16VSqTkhXoDm5mY2bNjAyZMnl6tdSUVScsNPkOy4hWQQ8a9S3+TfVD3J4f/9Nf7TF19gYGSy2O1JkiRJkiRJWucyPfsASLTtmfd8HMcc6MpO5N1tkFeSJEmSJGldW1FB3sOHD7N9+/Y5x1KpFA0NDRw+fDive3V2dnL69Gl27NhxwbkPf/jDXHvttdx999185jOfYWJi4or6llRYQRBQ/rZfomTXj0MiyZbkGX6u+jkeGPpjnv2vj/HSD14pdouSJEmSJEnSsjh06BAf/OAHuemmm7jrrrt49NFHmZqayusejz/+OLt27eKhhx5api7Xt2h0gGjgOBCQ3Lx73pre02MMjEySTITsbKstbIOSJEmSJElaUZKXLimc4eFhUqnUBcdra2sZGhpa9H3iOOZTn/oUjY2N/ORP/uTs8ZqaGn7xF3+R22+/nbKyMp5//nk+//nPc/jwYf7wD//winpPJldUJnrJJBLhnEfpYgq6XpJVlLz9l4je8gBTr/wjo3u/SdXYGe4O9xF9dx8H926n/e7/g+qrbiIIXL8rkb9flA/Xi/LhelE+XC/Kh+tF+XC9KB+uF0mLNTQ0xIMPPkhHRwePPfYYfX19fPrTn2ZiYoKPfexji7pHf38/v//7v8/GjRuXudv1K3MsO403bOggKK+et+ZA1xkArt5SS2lJomC9SZIkSZIkaeVZUUHepfLYY4/x/PPP8yd/8idUVlbOHt+9eze7d5/71+933nknjY2NfOITn2Dv3r3ccMMNl/X9wjCgvr7qivteyVKpimK3oFWkoOulvgo2/zPif3I/I6+9yOt/+1fUj/yIzZOHST/1/3DmuUY2vfk+am64h0TF/C+aq7j8/aJ8uF6UD9eL8uF6UT5cL8qH60X5cL1IupQvfvGLjI6O8tnPfpa6ujoAMpkMH//4x3nooYdoamq65D3+/b//99xzzz0cP358mbtdv9I9+wFItl23YM2BrgEAdndsKEhPkiRJkiRJWrlWVJA3lUoxMjJywfGhoSFqaxf30VJf+tKX+P3f/31++7d/mzvvvPOS9ffddx+f+MQn2Ldv32UHeaMoZnh47LKuXekSiZBUqoLh4XEymajY7WiFK/p6adrD9p/fw6FXXuP1v/ufXB+/SuXZk5z55hc48w9/TunOOym7/h0kN20tfG+6QNHXi1YV14vy4XpRPlwvyofrRflwvSgfa329pFIVThuWlsjTTz/NnXfeORvihexr3L/5m7/JM888w/ve976LXv/CCy/wzW9+k69//ev86q/+6jJ3uz7FcUTmWDbIm2jdM29NOhPxanc2yLvHIK8kSZIkSdK6t6KCvNu3b+fw4cNzjo2MjNDf38/27dsvef1TTz3Fb/3Wb/Erv/Ir3H///cvV5rzS6bX3Jsv5MplozT9HLZ1ir5etO6+isf3/zZee2s/U689xd9mrbGaQqVf+kalX/pFE005K9ryd5LbbCBIr6tfgulTs9aLVxfWifLhelA/Xi/LhelE+XC/rQxxFEE1Depo4Mw2Zc4+LORbGaaJUimj7j5EJy4r9dCStYIcPH+b973//nGOpVIqGhoYLXlt/o0wmwyc/+Uk+8pGP0NjYuJxtrmvR6aPEEyOQLCPRdNW8NZ29w0xMZaiuKGFLk58iJkmSJEmStN6tqATb3Xffzec+9zmGh4dJpVIAfP3rXycMQ+66666LXvud73yHj370o3zgAx/g4YcfXvT3/OpXvwrA9ddff/mNS1pxKsqSPPhTN/Liwc38/tdfoXGsh7vLD3JjaTf0vU6m73WCihQl176Nkmv/CWFVfbFbliRJkqQVJY7SkJ4iTk+94XEy+5iZhigz+xXPbMcRROlcuPUN53Pnssei3LGF7nHe/swxAggAwuxjkJvyGgS5cwFB7jF77Pya82rPq4eA4Pxjs/eDOJPOBm8zbwjjpt8QzI0yV/zzngCqwirC7W++4ntJWrvOf+38fLW1tQwNDV302j/7sz9jfHycf/Ev/sWS9pRMrs2J2zOTxPOdKJ7uPQBASes1lJSVzlvzavcgALu3baC0JHH5TWrFuNz1ovXJ9aJ8uF6UL9eM8uF6UT5cL8qH60X5cL1kragg7wMPPMATTzzBww8/zEMPPURfXx+PPvooDzzwAE1NTbN1Dz74IMePH+epp54C4NChQzz88MN0dHTwnve8h5deemm2dsOGDbS3twPwa7/2a2zdupXdu3dTVlbG888/z+OPP8473vEOg7zSGnXrrgZ2tKb4/Nde4fHDTaSCMd7TfJRbw1dhfIip7/8NUz/4CsmOWyjZ83YSLddk38CVJEmSpEWK44h4bIho6ATR8EnioT4mRk4yNjVCJgNxEEKYgDBBkHucu5/MhkznnE+etx/OHrvg+uC8/SCAzHzB2zcEcGf2M/PVTeYep7MBW+UvSECyhCBRAokkJGa2c4/JkguOhSWlVG5sIO64GX/qkpbD6dOn+U//6T/xmc98htLS+cOllyMMA+rrq5bsfitRKlWRV33viVey1+26ldoFfjYzQd479jSv+Z/fepPvetH65npRPlwvypdrRvlwvSgfrhflw/WifKz39bKigry1tbV84Qtf4JOf/CQPP/wwVVVV3H///TzyyCNz6qIoIpM597bGyy+/zMjICCMjI/zsz/7snNr3vve9fPrTnwZg586dPPnkk3z+859nenqa1tZWPvKRj/DhD394+Z+cpKKpqy7jkQ/cyN//oIcv/d2PeKJ3F18uv5Z/ees07YMvkOk9SLrzBdKdLxDWt1Ky5+2UXHUnQen6/gtCkiRJ0jlxHBGPDhIN9xEN9REPnyQa6svtn4TMVLFbXEYBJEsJkqVzHkmUnAsihwkIwgWCyomLnz8/jByGBDP3ywWYZ8PKMxN1iSHOfXHuMT5/f3abOTUXXBfHxLPnyU395VzN+YHbZAkkSuc5dm6fRC5snadkMqS+voqBgVFIR1f0pyVpbUulUoyMjFxwfGhoiNra2gWv+4//8T+ya9cubrvtNoaHhwFIp9Ok02mGh4eprKwkmcz/7YIoihkeHsv7utUgkQhJpSoYHh4nk1nc7+Y4PcV4dzbIO71hZ/b3+huMT6Y5eGQAgG1N1fPWaPW5nPWi9cv1ony4XpQv14zy4XpRPlwvyofrRflY6+sllapY1LThFRXkBdixYwePP/74RWueeOKJOfvve9/7eN/73nfJez/00EM89NBDV9KepFUqCALuuaWNa7fW80dPHuDIiREefSbBnXvew8/9dCWJH/0D068/SzTQw+S3/yuT3/kSJVf/GCV77iFRt7nY7UuSJEkqgGxYdyAX0D2ZC+xmg7rR8CXCukFIUNNAWNtImGokWd9CTVMzo2cnyEynIcoQR9nH7FdEHGXg/GPxhcfiXO3MsXj2+pn686+P5wZuE6VvCOCW5R5LIFm2QF3Z3PMzgVU/uUSSVoTt27dz+PDhOcdGRkbo7+9n+/btC17X2dnJ9773PW6//fYLzt1+++388R//MXffffdl9ZRe4/8AIZOJFv0c08dehcw0QdUGoppm4nmu23/4DFEc01hXQX112Zr/+a03+awXyfWifLhelC/XjPLhelE+XC/Kh+tF+Vjv62XFBXklaTm1bKzi//r5W/mbZzr56nNHeG7/CV47Ws4v/tR7uPqODzD92jNMHfg74qETTO//JtP7v0midTcle95Osv2my5qsJEmSJK1kcSYN0xPEU+PZMGhpOUFp5ZoNb84J6+Ym6sYzwd3hk5CZXvjiIEGQ2kSYaiKsbSJMNc5uBzUbs5Nkc5LJkOr6KqYHRtf1C0+SpKV1991387nPfY7h4WFSqRQAX//61wnDkLvuumvB6/7dv/t3s5N4Z/zO7/wO5eXlfPSjH2XXrl3L2vd6kT62D4BE654F/z/qQNcZAHZv21CwviRJkiRJkrSyGeSVtO4kEyHvu3sH12/fyB8/eYBTQxM8+mc/4Cfe3M57f/wdVF33DjI9B5je/y3S3S+R6TlApucAQdUGkltvJtG4jbBhG2FtC0F46dHnkiRJ0lKK4xgy09ng7fQEce6LqfHL2iZKz/+NwiRBaQWUVhKUVuS+KuG87SB3jtn9N9QkS5fuec8EjtOTxNOTs9vZn8HknG3Sk7nnObOdOzdxlmjkJGQWeM6QC+s2ZEO6tU3nQru1TQTVG/3HfZKkonrggQd44oknePjhh3nooYfo6+vj0Ucf5YEHHqCpqWm27sEHH+T48eM89dRTAFx77bUX3CuVSlFZWcmb3vSmgvW/1mWO7Qcg2bZnwZr9M0HerfUF6UmSJEmSJEkrn0FeSevWzrY6Pv6hO/jzb73Ot/f28r+e72b/4TP80k/vprXtOpJt1xGN9DN94O+ZfvVp4tEzTB/4FtMHcjcoKSexaSthw3YSjdtINGwjqN60JqeWSZIk6fLEUZQNkqYnYToXLk1PzQZNmX7juUlIT805Nyewm9smXoYJr4lSCBPZ+xNDlCaeGIGJEeLLvmfyvGBvLuhbcl44OFl6iTDuuZ8TcWbpnmuYIKxpIJgN6jYS1jYTphoN60qSVrTa2lq+8IUv8MlPfpKHH36Yqqoq7r//fh555JE5dVEUkcks4d+duqRobJDozFEAEq275605MzxB7+kxggCu7TDIK0mSJEmSpCyDvJLWtYqyJB9697XcuGMTX/j6q3SfPMvHH3+BD7xtB2+/rY2wpoGyN/1TSm/9GdLdL5Pp+xFRfyeZU10wPUGm9yCZ3oPMfPhuUF5D2JAN9WYn924nrEgV8ylKkiRpHnEcQ5SBzFQ2WJuZJk5P5/anITOdDdRmpiA9TZyZJh1NM1AC4yMjZCbHc0HTXOh2ZurrTEA3PZXdz0wt7xMpKSfIfVFacW67pDwXmr3YdgVB6Xn1ufBqHEfZEPHUGPHUOPHUGMxuz+yf244n37A/NQ7T49n+Mmni8WEYH778MPAbJZIEyXIoKSMoKYNkee6xLPf8S88dKyknSJad2y6tPC+s66drSJJWpx07dvD4449ftOaJJ5645H0WU6PFy/Rk//V/uHHrgq8HvnJkAICO5hRV5SUF602SJEmSJEkrm0FeSQJu3dXAjtYUn//aK+w7fIY//9br7D10ig/95G7qa8oIkqWUbL+dku23AxBHGaLB40QnO8n0Z7+i00eJJ0bIHN1L5uje2XsH1RtJNGw7N7l3U0f244clSZJWsXh6gujsGeLRM8RnzxCNDmS3J0chCIAAghACctvB7PHgvO15H+fZvuCame04Is5Mw5wQ7lTu2Bv3zwvnZqYhzj9aOn7ZP7EgGzxNlp0XQM0FT5NlkCzNBWrLzgVPc+cpLScoqbhwu6SMIFj6MGoQhLkJupf//6zZMHB2gnA8OXZe+PdcIJipMeLMdO5nkg3enr99QQg3WZp9zqEvZUiSpJUnfWw/AMm2PQvW7O86A8Bup/FKkiRJkiTpPL77JUk5ddVlPPKBG/n7H/Twpb/7Efu7BvjYn36H/9dPXMPt1zTOqQ3CBIkNW0hs2ELJNXcDEKeniM4cJZML90b9nUSDvcRnT5M+exo6X5i5mrCuORvsnZncu2FLNpggSZK0AiwU0o1GzxCfHSAaPQ1Tlx9pXZESpZAsIUiUZEO1F+yXEJSUUVZZyXScIE6U5oK2bwjkzgnpnhfGTZRkw8jrRDYMXElQWgnVG4vdjiRJ0rKK45hMTzbIm2i7bsGaA13Zibx7OjYUrDdJkiRJkiStfAZ5Jek8QRBwzy1tXLu1nj968gBHTozwn7+8j5f2NPPP33k1leUL/9oMkqUkGneQaNwxeyyeGidzqovMyU6i/sNk+juJz54mGuwlGuwl/foz2cIwQbihjUQu3Bs2biOsa/XjfiVJ0pKbE9IdHZjdvqyQbkkFYfUGgqr63OMGgrJqIDfpNo5ymxHEcW4Abu5YHOVq4vO2zztGnLvm/Lpzx2e3CS4RwM3uz4RxSZQSzNkvWXTINpkMqa+vYmBglHQ6WtzPSJIkSWteNNBDPDYIiVISTVfNW9PTP8rw6BSlJSE7WmsL26AkSZIkSZJWNIO8kjSPlo1V/F8/fyt/80wnX33uCM/tP8FrRwd58Cd2cd32xU8UC0orSG6+luTma2ePRePD2VDveZN744kRolNHiE4dYfqVv88WJksJaxoIKmsJKmoJKmsJK+uy+5V1BBW1hJW12Uln62i6myStVXEcQXqaOD0J05PE6SlIT2b305PE0+ftExCUVhCUVEBp+XnbFety8udqEkdpSE9DHBFHGYgyEKUhOm8/zj6eOz/zFWWvjzLZwOs8NXH8hv0oA1PjVx7SrdpAMBvY3XjuWGnF8v7AJEmSpFUgc2wfAImWqxf81K0DXWcAuHpLHSVJ//G+JEmSJEmSzjHIK0kLSCZC3nf3Dq7fvpE/fvIAp4Ym+A9fepndHfXc/7YddDSnLuu+YUWKsP0mku03AdmP1YvPniLT35mb3NtJ5lQXTE8QDfTAQM/Fb5gomQ37ngv6vnG/jqCihiD0176kwoszaQhYU7+D4ihDPDlKPDFCPHEWpsaywdvpbND2XAh3ap5Q7hTxdO7x/NBuZmrpGgwT54K9peXnhXyz+5RUZMO/M8Hf2XO5YPDMdrLsigLB8QUTVBeYwJod05oNM+e2mfm+QUBAcMExeMN2wEWOndue7/nEcUycniKemMj9WU0RZ3KPs3920+f+TDNT5+re+JiZ7/jMGpjOhnRXgpIKwup6gqoNhnQlSZKkK5Tu2Q9Asu26BWv2dw0AsHvrhoL0JEmSJEmSpNVj7aQpJGmZ7Gyr4+MfuoMv/+9O/u77xzjQNcAnHn+BO65t5H1v3UFj3ZWFXIIgIKhpIKxpoGT7HQDEUUQ0fIL47ADx2CDx+BDR2BDx2NB5+4PZiXqZaeKRU8Qjp7j4BzwHBOXVF0z0PX8/KK8hKKskKKtacHqIpPUtjiOYGs8GWMezIdZ4YoRoYmQ21Bqfvz0+AtO56Z8l5dnfL3O+qgnKKqGsmqD8jeey50mWLut02TiKiKdG39D/2Tdszz3G1Niy9QNkn3Oy7NxjSVn293Iy9xjHxNMTxNPjMJV9jKfGYXoie32UIZ48C5Nnia+okSAb7E2UZL/nPOHb2e05gd3c9op2Ltw7UMx+gwSECQjDbAA7nNnPfgXB+fthNhAfJiCYv57g/GO5mpLyOVN1DelKkiRJSydOT5E5fhCARNueeWvSmYiDR7NB3j3bDPJKkiRJkiRpLoO8krQIFWVJfvYdO3nHbW18+X8f5vn9fXz3lZO8eLCft93cyk+/pYNU1dIFX4MwJFG3Geo2X7QuTk9lw725YG88NpgL+w4RjQ+d2x8fzn6Edy5cx5ljl24iUTInTEdpZTZkV3p+wK5ybs3MsTU0dVNabnF6imioLxvAnAneBdmQXpAL4RGEudBeLpQ3uz9TH2aPXeb3nz+AO3zhsZnps/HF/9nAgqYnsuHTs6fzuy5M5n7fVJ/7XTPz+6h8biA4KKsmqKphKion3XeS9Ohwtu/JucHc6LznxOQYlxfiDKCsMvuPIEorzgvcls0N4p5/rOT8c7lQ7pyQbhkkSy7/zzOOshN+p8ZzId/x7M98amZ7nHhq4ty53Plz52b2x86FcafGiRm/rH5Wtjj3x/6GP/sgkfszKp3nsSwbap4TtJ6vLveYKJ0bwJ49XjL73/ZyhtQlSZIkLb9M348gM5X9R/P1bfPWHOoZYmo6IlVZQmtDVYE7lCRJkiRJ0kpn0kqS8tBQV8Ev/fQe7r2jnb/8h0Ps6zzDt148xrd/2Mt9b2rnXbdvoby0cL9ag2QpQaoBUg0kLlIXR1E2xDYb9B3MBX2H5u7nPh6eOM5O+s2Fg/NWUk4wT/CX2SBeJVFFNeONjWQyZcSlNdlgnmEmrWHx5CjRYC/RwHEyg8dnt+ORUyzNJNBgNtQ7GxAMExAEbwgDJwjCkHh6MvvffHry8r5dSXk2wFpenXs8b7vi3HZYXgPl1QQE2d9Dk6PnviZG5+7nzjM5dm47ykCUzgaLx4cX3d7iK89TWnne86heYPu8x9KqbNh6BQmCEEorrnjaahzHkJnKBYAniDPTuTUU5AbZzmwHZA8svB3MXAfn7nF+3fn7BHP+Lohnp/ySfTx/e2Yi8HzHZicHx7mK88+dN303jkkmAmrrqxkezZAm4T9GkSRJkpSXTM9+IDuNd6HXtvZ3Zafx7u7YQOjrX5IkSZIkSXoD36WWpMvQ3lTDR//ZTRzoOsN//4dDHDkxwpf/dyd/9/0e3nNXBz9+42aSiZUT7grCkKAiBRUp2Hjx2uw0x4lswG5qlHg2UDeWC9i9MXg3lvtI+lGYzk1snJm6OXpmwe8zCYzOaTJBUJkiqEgRVNQSVKQIK2vP7ee2w4paQ79aseI4zgbjcyHd6PzA7vjQwheWZqdbE0fZrygDcUwcZXL7EcSZ7OOCod84ex0ZyEzPHFmocq4gMSd8O284d2a7IpUN5yfzn0IelFfnVR/HMaQn3xD+PUs8NZb9nfPGYPB5X0EQEJTXQNkiQ7llVdngswCyv2NnJgRXFrmPbHL4yu5zkXNhMiRZXUUwPUqQvsxp05IkSZLWrfSxfQAkW/csWHOgK/sa2e6ODQXpSZIkSZIkSauLQV5JugK7Ozbw/32wnhdePcn/+MfDnBwc54m/fY2//d5R3v/WHdy6q2HVBU6z0xwrCUorgYa8ro2jTPYj2M8L/l74NQZT2UBwMHWW9NnBbEA4zhCPDhCPDlz6G4WJXMB3JvRbS3h+CHiNhn6zocYp4vQkTE9mH9OTxNPZR4IElJYTlGS/mHlMlKyZn8FKEUcR8Ug/0eBxMgO9ucDucaKB3nOB9nkElXWE9ZsJ61oI6zbPbgcVtYv+M4pnw77nQr/xeeFfzgv/xjPh39nz0WxtkCjJ/jdTXg0lFStyjQRBcG4dV1/iXyGcJ5kMqa+vYmBglLTBTEmSJEnSMonGh4lOdQPZibzzGZ2YprM3+7kxuzvqC9abJEmSJEmSVg+DvJJ0hcIg4I5rm7jl6gb+8aXj/M0znfQNjPMHX97HtpYUH3jbDq7Zuj5epA/CBOQmXl7K+UG76clJ4vHh3NcQ0djQuf2xIeLx7H40PgyTo9ng4uWEfkvKIUxCIpn96PQwkd1OJLPHw5ntBCRKcvuJudckknOPz1wzczxMwsy5KE08PZUN26Ync5OKZwK4U7MB3Hh6Ivd4rjaenoDpqQvDupf1B3N+wLcsF4ysmBP2DUrP2545Xnp+TRlBSUV2O7F+/vchTk8RDfXlQrq56bqDx4mGTkAmPf9FQUCQaiRRNxPYbTkX2C298tGmQRBCEMJ5Q79XXgRXkiRJkqS1L9NzAIgJN7QRVtbNW/PqkUHiGFo2VrIhVV7Q/iRJkiRJkrQ6rJ8kjiQts2Qi5O23tvGW65r5xne7+cZ3j9LZO8yjf/4Dbtixkfe/dQdbGvP7WPn1IkiUEFRvXNTEzTgzPSfkG40vEPodG4KpsfxCv6tJsjT7kfclZdnHZFn2uU5PwPR4Lhw8la2NMzAzEXkpvneYzE36TcLsx94HF2wHc46HuW3O275Y/dztIAyZKEkwPZ3JTiY+3xv3555cfO2cczHR6ADxSP/C1yRKCOuas5N16zYT1uem7NY2ESRKLtKTJEmSJElaCzI9+wFItF23YM2BrjMA7N66oSA9SZIkSZIkafUxyCtJS6yiLMnP/Ph2/sktbfzNM508/dJx9h46zQ8PneYt1zXzMz++nY21Tt+4XJcd+h0fIk5PZaeoZtLEURqiTHY7M53djtLEmTRE59VkFjieu3bha6azgdfzw7ZveAxKsgHc2ceZc+ftZyfongvrZs+VZqeyXur5R9HsxN94ehymJnLbE7npwBPEU+cFf6fPPz9JPD2eO587lpnO3jhKE0+evfT3v2RFfhaYf7v8SisJ6zeTqGuZE9gNqjcRhJf+c5AkSZIkSWtPHMekj2WDvMnWPQvWzQZ5t62PT+ySJEmSJElS/gzyStIyqa0q5efftYt33baF//H0Yb736kme2XeC77xykrff2spP3tlBdYVTO5dTPqHftSgIQyitICitAK78zaI4SucCvrkAcJSL1sYxxBEQ57Zj4vO2WXA7yqZ945h4dnvmPsy5ZxhAVXUZo6NTRJko9wSDizz5888ttm5ubVBRQ1jXQlBRS3Cx7yVJkiRJktadaKiXePQMJJIkWq6et+bU0Dh9A+OEQcCuLQZ5JUmSJEmSND+DvJK0zJo2VPIvf+Y6fqJ3mP/+9z/i1e5BvvHdozz9ci8/eedW3nFrG6UliWK3KV1SECahLElQVlXw751MhtTUV5EeGCWdjgr+/SVJkiRJks6XyU3jTTRfnf0kpXkc6BoAYPvmFJXlvh0jSZIkSZKk+fl50JJUINtaUvx/fvZmHvmnN9LWUM34ZJq//IdD/MYfPc/TLx8nExlOlCRJkiRJklaD9LF9ACRar1uw5kDXGQB2dziNV5IkSZIkSQvzn4BLUgEFQcD12zeyZ9sGnt9/gr9++jCnhyd5/H+9yt9+7yjvf+t2brpqE0EQFLtVSZIkSZIkSfOIM2kyvQcBSLbtmbcmiuPZiby7OzYUrDdJkiRJkiStPgZ5JakIwiDgLde1cPs1jfzd93v4yrNdHD81ymN/9UN2ttXygbddxVVttcVuU5IkSZIkSdIbZE4egukJgvIawo1b5q052neWs+PTlJUm2L45VeAOJUmSJEmStJqExW5AktazkmSCe+9o5zMfuZOfvHMrpcmQ148N8Tv/vxd57K/2cvj4MHEcF7tNSZIkSZIkSTmZY/sASLTuIQjmf5vlwJEzAFyzpY5kwrdiJEmSJEmStDAn8krSClBZXsL737qDe25p439++zD/e28vP3j9FD94/RRN9RW8eU8zb97TRFN9ZbFblSRJkiRJkta19LH9ACTb9ixYc6AzG+TdvW1DQXqSJEmSJEnS6mWQV5JWkPqaMv7Ffdfyrtvb+cpzXXz/YD99A+P8z2938j+/3cn2zSnu3NPM7dc2kqosLXa7kiRJkiRJ0roST5wlOtUJQKLtunlrptMZXjs2BMDuDoO8kiRJkiRJujiDvJK0Am3eVMWHf3oP4+9K84PX+3lufx8Hus5w+Pgwh48P8+fffJ3rtm/gzXuauPmqBspKE8VuWZIkSZIkSVrz0sdfgTgmrNtMWFU/b83rx4aYTkfUVZeyeaOfsCVJkiRJkqSLM8grSStYRVmSt1zXwluua2Ho7CTfeeUkz+8/QdeJEfYeOs3eQ6cpK0lwy9WbuHNPM9d21JMIw2K3LUmSJEmSJK1JmWP7AUi07VmwZn/XGSA7jTcIgoL0JUmSJEmSpNXLIK8krRK11WW86/YtvOv2LfSeHuX5/X08t/8Ep4YmeG5/H8/t7yNVVcod1zZy555mOpprfKNAkiRJkiRJWiJxHJPu2QdA8iJB3gNdAwDs6dhQkL4kSZIkSZK0uhnklaRVqGVjFe+9ezs/8+PbOHR8mOf2n+B7r5xkeHSKb75wjG++cIymDZXcubuJN+9porHej/CTJEmSJEmSrkQ8fJJ45BSECRIt18xbc3Z8mu4TIwBc21FfyPYkSZIkSZK0ShnklaRVLAgCrmqt5arWWn727TvZ13mG5/ef4KXXT9F3Zowvf7uTL3+7kx2tKd68u5nbr20kVVla7LYlSZIkSZKkVSd9LDuNN9F0FUFJ+bw1rxwZIAZaG6qoqy4rYHeSJEmSJElarQzyStIakUyE3HTVJm66ahPjk2m+/1o/z+8/wYEjAxzqGeZQzzBf/Nbr7Nm2gTv3NHPTzk2UlSSK3bYkSZIkSZK0KmR69gOQaLtuwZr9nWcA2L11Q0F6kiRJkiRJ0upnkFeS1qCKsiR3Xd/CXde3MHh2ku8e6OO5A30cOTHC3kOn2XvoNGWlCW69uoE372ni2q31JMKw2G1LkiRJkiRJK1IcZUj3vAJAsnXPgnUHurJB3j3b6gvSlyRJkiRJklY/g7yStMbVVZfxrjvaedcd7fSeHuW5/X08v/8Ep4YmeHbfCZ7dd4LaqlLuuLaJG67ayPaWFBVl/vUgSZIkSZIkzYhOHobpcSirItzUMW/NyYExTg1NkAgDrt5SV9D+JEmSJEmStHqZ1JKkdaRlYxXvu3s77/3xbRzqGea5/Sf43qsnGRqd4qkXjvLUC0cJgM0NVezYXMuOzSl2tNbSvLGSMAiK3b4kSZIkSZJUFOme/QAkW3cTLPDJVge6BgDY0VpLealvv0iSJEmSJGlxfCVJktahIAi4qq2Wq9pq+dl37GTf4TN899U+Xj86xOnhCXr6R+npH+Xpl48DUFmWZPvmFNs3p7iqtZbtm1NUlpcU+VlIkiRJkiRJhZE+tg+ARNt1C9bs7zoDwJ6O+oL0JEmSJEmSpLXBIK8krXPJRMhNOzdx085NAAyeneRQzzCHjw9xqGeIrhMjjE2m2dd5hn2dZ2ava9lYyY7Wc1N7N2+sIgyd2itJkiRJkqS1JZ4aIzp5GIBk6555a6Io5tUj2Ym8uzs2FKw3SZIkSZIkrX4GeSVJc9RVl3HrrgZu3dUAQDoTcaz/LId6hjmUC/f2D07Qe3qM3tNjfHtvLwDlpYnc1N5armrNPlZXOLVXkiRJkiRJq1v6+CsQRwS1TYQ1m+atOdI3wuhEmoqyJB0tNQXuUJIkSZIkSauZQV5J0kUlEyEdzSk6mlO8/dY2AIZHpzh0fIjDx4c51DPE4d5hJqYyHOga4EDXwOy1TRsquWpziu25yb2tDVUkwrBYT0WSJEmSJEnKW+bYfgCSrdctWLM/90lW17TX+fqXJEmSJEmS8mKQV5KUt1RVKTfvbODmndmpvZkooqd/lEO5YO+hniH6BsbpOzNG35kxntl3AoCykgTbWmrY0VrL1VvqeNMNpcV8GpIkSZIkSdIlpXNB3kTbngVrDnRlg7x7tm0oSE+SJEmSJElaOwzySpKuWCIMaW+qob2phn9ycysAZ8ens6HeXLi3Mze199XuQV7tHuSrzx0h+Vd72d2xgZt3buLmnQ2kqgz2SpIkSZIkaeXIDPcTD/dBEJLcfO28NZPTGX7UMwTA7g6DvJIkSZIkScqPQV5J0rKorijhxqs2ceNVmwCIopjjp0Y5dHyIQz3DvN4zRN+ZMfYeOs3eQ6f5r984yM62Om65uoFbrt7EptqKIj8DSZIkSZIkrXfpo/sASDTuICid//Wq148Oks7EbEyV0VTva1qSJEmSJEnKj0FeSVJBhGFAW2M1bY3VvPWmVpLJkLNTEX/33SN879WTHDkxwmtHB3nt6CBf/NbrbG2u4ZarG7j16gY2b6oqdvuSJEmSJElah6aP5YK8bdctWLO/6wwA13ZsIAiCgvQlSZIkSZKktcMgrySpaLY01fB//Ng23v3mrZwaGucHr53ixdf6ef3YIEdOjHDkxAh//fRhWjZW5ib1NtDRXOMbIpIkSZIkSVp2cZQhfewAAMm2PQvWHegaAGBPx4aC9CVJkiRJkqS1xSCvJGlF2FRbwTtv38I7b9/C8OgUL/3oFC8e7OdA1xl6T4/x1eeO8NXnjrAhVcYtOxu4dVcDO9vqCENDvZIkSZIkSVp6k72HiSdHobSCsGHbvDVDo1McPXkWgGu31heyPUmSJEmSJK0RBnklSStOqqqUu2/czN03bmZsIs3ew6f4/sF+9h4+zZnhSb754jG++eIxaipLuHnnJm65uoFrt26gJBkWu3VJkiRJkiStEeOdLwOQ3LybIEzMW/NK1xkA2hurSVWVFqw3SZIkSZIkrR0GeSVJK1pleZI3727mzbubmZrOsL/rDN8/2M9LPzrFyNg0T7/cy9Mv91JemuDGq7Kh3uu3b6C81L/iJEmSJEmSdPlmgryJtj0L1hzoGgBg97YNBelJkiRJkiRJa48pJ0nSqlFakuDmnQ3cvLOBdCbitaODvPhaP99/rZ+hs1N850Af3znQRzIRct22DdxydQM37dxEdUVJsVuXJEmSJEnSKhJPjTNx7DUAkm3XzV8Tx+zPTeTd3VFfsN4kSZIkSZK0thjklSStSslEyO6ODezu2MA/f+fVdB4fzoZ6D/ZzcnCcl350ipd+dIowCNjVXsctVzewtamGqookVRUlVJUnSYRhsZ+GJEmSJEmSVqDp469ClCZMNRCmGuetOXFmjIGRSZKJkKvb6grboCRJkiRJktYMg7ySpFUvDAJ2tNayo7WWD7xtBz39o7z4Wj8vHuznWP9ZXjkywCtHBi64rqIsSXVFkuqKEqrKS7KPuZBvdcW5/erzjlWUJQmCoAjPUpIkSZIkSYWSProfWHgaL8CBruzrTTvbaiktSRSkL0mSJEmSJK09BnklSWtKEAS0NVbT1ljNe35sGycHxvj+a6d4+UenOD08wehEmvHJNADjk9nt/sGJRd8/DAIqzw/65rar5gn9tm6qora6bLmeqiRJkiRJkpbJ9LFskLdky8WCvGcA2N1RX5CeJEmSJEmStDYZ5JUkrWmN9ZX8xJva+Yk3tc8eS2cixibSjE5Mc3Y8+zU6ns4+TkwzOn7e8Ylzx6emI6I4nj23GK2bqri2o57dWzewq72OijL/6pUkSZIkSVrpwqpagvQ4JVuuIzPP+UwU8Wp3diLv7o4NhW1OkiRJkiRJa4ppIknSupNMhKSqSklVleZ13dR0htGJ9BuCvucFgc8LAQ+PTdN3ZoyeU6P0nBrlmy8cIwwCtm2u4dqtG9i9tZ4drbWUJMNlepaSJEmSJEm6XNU/+WvUb6hmcGgC0tEF5zt7RxifzFBVnmRrU00ROpQkSZIkSdJaYZBXkqRFKi1JUFqSoL6mbFH1w2NTvHpkgFeODPBK1wAnB8c51DPMoZ5hvvJsF6XJkJ1b6ti9tZ5rO+ppb6whDINlfhaSJEmSJEm6lCCRJAgTC54/0HkGgGu31vt6jiRJkiRJkq6IQV5JkpZJqrKUO65t4o5rmwA4NTjOgdlg7xmGx6bZ33mG/bk3fqrKk1yztZ7dW+vZ3bGBxvoKgsA3giRJkiRJklaaA13Z13N2b9tQ5E4kSZIkSZK02hnklSSpQDbVVXB3XQV337iZOI7pOTXKK10DHOg6w8Gjg4xOpHnxYD8vHuwHYEOqjGu31rN76wau7ainrnpxk4AlSZIkSZK0fMYn0xw6PgzA7g6DvJIkSZIkSboyBnklSSqCIAhoa6imraGad96+hXQmouvECK90neFA1wCHjg9xZniSZ354gmd+eAKAzZuqssHejnp2bamnsty/xiVJkiRJkgrt4NFBMlFMQ105jXUVxW5HkiRJkiRJq5wJIEmSVoBkIuSq1lquaq3lp+/axuR0htePDeYm9g7Q3TfC8VOjHD81yrdePEYQwLaWVC7Yu4GrWlOUJBPFfhqSJEmSJElr3oGuMwDscRqvJEmSJEmSloBBXkmSVqCykgTXbdvIdds2AnB2fJpXjwzwypEBDnSdoW9gnMPHhzl8fJivPneEkmRIY10FFeVJKsuSVM55LJndf+P5irIkyURY5GcrSZIkSZK0ehzoGgBgt0FeSZIkSZIkLQGDvJIkrQLVFSXcdk0jt13TCMCZ4QkOdA3wypEzHOgaYGh0ip5To5d177KSRDbYOxPyPS8APG8wOLddV11GaYlTgCVJkiRJ0voxMDLJ8VOjBMA1W+uL3Y4kSZIkSZLWAIO8kiStQhtS5fzYDS382A0txHHMiTNjDI5MMjaZZmwizehEmrHJNOMTacYmpxnL7c+cH5tMMzmVAWByOsPkdIaBkcm8+6ivKaOpvoLmDZU01lfStKGCpvpKGuoqKEk66VeSJEmSJK0tB7rOALC1uYbqipIidyNJkiRJkqS1wCCvJEmrXBAEtGysomVjVV7XZaKI8ckMYxPT5wK+E3PDvjNB4LnB4DSjE9NMTUcMjEwyMDLJq92Db+gJNqbKaaqvoHFDJU31lTTVV9C0oZJNteUkE4Z8JUmSJEnS6nOgawCAPds2FLkTSZIkSZIkrRUGeSVJWqcSYUh1RXhZ02PiOObs+DR9A+P0nRmjb2CckwNj9J0Z58TAGJNTGU4NTXBqaIL9uTe4ZoRBwKbachpz03tnAr5N9RVsrC0nERrylSRJkiRJK08cxxw4kp3Iu3trfZG7kSRJkiRJ0lphkFeSJOUtCAJqKkupqSzlqtbaOefiOGZ4dGpOyLcvF/I9OTjG1HTEycFxTg6Os48zc65NhAGb6iqy4d76SppyYd/NDVWkaisL+RQlSZIkSZLmOH5qlKGzU5QmQ65qq730BZIk6f/f3r1HSVGeeRz/VfV1bj0zGJxEQQdYM4CAaIxo0FFB1pD1hN0NupgjYIKKHtAVdSO4C0blHA27JgquWYIQEJOoIRxz4o6YaAiswLpJ1gRjTCQMl4DrQATm3tPdVbV/9GW65wJTMEw1M9/POWNVvfVW8XTnSdnz8Pg2AAAAgB6gkRcAAPQqwzBUWhxSaXFInx5alnPOcRwda4qlGnxbMs2+h462qu5oqxKWnTx3pEXSxznX+kxDZcUhlUdCOisS1qCSkAZFwhoUCWlQSXJbXBCQYRh992IBAAAAAMCAkf7WoQuGling93kcDQAAAAAAAPoLGnkBAECfMQxD5SUhlZeENLLDV1DajqOjDW1dNPgmt5bt6OOGqD5uiOpPqu/y/kG/qfJUk+9Z6SbfDk2/4SAffwAAAAAAgHu/35v8ZqELKwd5HAkAAAAAAAD6EzpZAABAXjANQ2eVhnVWaVijKzucMw3J79Pu/Ud0+GirjjS06UhjNLltiOpIY5sammOKJbJX9O1aYcjfvpJvJKyzslb0HRQJq7wkJL/PPL0vFgAAAAAAnFESlq0/7j8mSRpdWX78yQAAAAAAAIALNPICAIC8Z5qGyksLZA4p07BPRrqcE0/YOppq7v041dx7NLX9uCE53tqWUEtbQi2Hm3TgcFOX9zEkRYqCKikMqjDkUzjkV2HIr4KQX+GQL7NfEPKrIOhXQcjXfhxKHvtMGoEBAAAAAOhPdh+sV1vcUklhQEPOLvY6HAAAAAAAAPQjNPICAIB+IeA3dXZ5oc4uL+x2TmtbIrOC75GG3BV909t4wlZ9c0z1zbGTjiUU8OU2/QY7Nvu2N/0WBP0qCPtVFParOBxQUUFA4aBPhmGc9J8PAAAAAAB61+/3HpUkja4cJJPf2QEAAAAAANCLaOQFAAADRkHIr3MHF+vcwV2vnOM4jhpb4zra0Kam1nhmBd9oatvaZqm1LZH8iSVS55Nj0baEYglbktQWt9QWt1TfdHLNwD7TUHFBQMUFARWF/SpK7WfGutgvCvvl97ESMAAAAAAAp8Pv9x6RJI0+v9zjSAAAAAAAANDf0MgLAACQYhiGIoVBRQqDJ3V9wrLbG32zmn5b2hKKxqxUM3CiyznN0biaWhNKWLYs2zmpVYELQj4VhTs0+4YDKirwd2oEDgd9Mk1DPsNIbs2ut6ZhsDowAAAAAGBAa4kmVPt/DZKSK/ICAAAAAAAAvYlGXgAAgF7i95kqKQyq5CQbgR3HUSxuq6k1nvyJxtWc3m+Nq7k1kdxGs8fiaokm5EipxmBLf6mP9urrMo/X7Gt00fybPSd1bTjoU0lhQMUFwdQ2kHqvAiopCKi4MKBQwEfTMAAAAAAg7/xh/1E5jlQxqFBnlYa9DgcAAAAAAAD9DI28AAAAecIwDIWCPoWCPld/MWjbTqa5t7k10UUDcPt+U2ty9d9Y3JLtOLJsR7ad3DpON/d3HNmWo4TVSy+0GwG/mWzwLQgkm30Lg5km35LUfnYTcFGBXz7TPL1BAQAAAAAGvN/vPSJJurCy3ONIAAAAAAAA0B/RyAsAAHCGM03jlFYCTrOdZFNvurE3u9E3M5baWp3G7OTW6XpuNGapqSWmxpZkQ3FjS0yNrXE1tiR/EpateMLW0cY2HW1s63HMRWF/puE33eRbWhxSaSSsaGtMtu1IWav8pve6WvjX6GKesuYZ6nxR+hK/z1QwYCoU8Ckc9CkU8CnYxb7fR+MxAAAAAJxp3tt7VJI0unKQx5EAAAAAAACgP6KRFwAAAJIk0zBk+gzJ17d/ruM4isXtnObeptYOTb+Z/fZVhh1JzdGEmqMJ1fVtyCfNZxqZpt5gwKdQwFQ44FMw1fDbaT+QXKG5fd9UOOBXOORTUTigwrBfQb+Z04QMAAAAAOg9f6mPqu5IiwxDGnkeK/ICAAAAAACg99HICwAAAE8ZhqFQ0KdQsECfKCvo0TWWbas5mkg29mY3+rbG1RyNyzBNxdoSsmwndUVy6zjt93A67DjqfDJzddapzL2yDhOWrba4rba4pbaYldxm7afjsGxHrW0JtbYlevQ6e8LvM1UU9qsw7FdRQUBFIb8KwwEVFfgzzb7FqW1RarwwHFBR2M8KwQAAAABwAu/t+ViSNPxTERWG+SsVAAAAAAAA9D6qTgAAADjj+ExTkcKgIoVBSUU55/x+U+XlRTp6tFmJhO1NgB0kLFuxuKVoqrE3FrcVjSXUFk+Ot6XOdbXfFrfVlpqbbg5ujSXU3JqQ7ThKWLbqm2Oqb465jisU8KUafNubfjs2+xaFAyoI+RT0J1cFDgbM5OrA/uQ24DdpCAYAAADQb72354gkaXTlII8jAQAAAAAAQH9FIy8AAABwmvl9yWbXwnCg1+7pOI6iMUst0YSao3E1RxNqSW2bo/HkeGv7eFNq2xJNqCWakCNlVg4+2th2SrH4TCPZ4Otvb/QN+n0Kppp90+dCgfbjgL+9Gbj92uQcv8+UaRrymUbu1jC6Hk9tTcOQYRi98wYDAAAAGPBs28k08l44jEZeAAAAAAAAnB408gIAAABnIMMwVBDyqyDk11mlYVfX2o6j1rZEsum3Nd51M3DWeGvMUjyRXD04FrfUltp3nOT9LNtRa5ul1jbrNLxSd8zjNfsaXYz7DIUCfjmOI9OQfD5TvtR5n8+UP7NvyGea3eynjn1Gcn6He/g63CMU8ClSGFBJUVChgM/rtwwAAABAN/b+X4MaW+IKBXwafk7E63AAAAAAAADQT9HICwAAAAwwpmGoKBxQUTgglRWc1D0cx1HCchRLWIrFU02+XTT7xuJ2+5ycucn9tuzrUtt4wpbjOLJsR7ad2nY4TjcRd2Q7jmzLUcL7nuIeCQWTTb2RwqAiRUGVFAYVKQqopDCo0vRxYUCRoqCKCgIyWXEYAAAA6DO/+eCwJKnqvDL5fabH0QAAAAAAAKC/opEXAAAAgGuGYSjgNxTwmypytyBwr7CdZFNvV42+mbGO247NwbYjGVJBQVD1Da2KxW1Zti3LSp63bEeWZcuyHSWy9pPjTnJul/uOEjn3yb1nNJZQQ3NcCctWW8zS4Zilw8eiJ3zNhqGcxt5IYXvjb6QwqJLUWPo42Ier/TpOsrk6/R4nLFuJhK24ZSuesJWwkmPx1FgiYeceW05mfmabudZWPOHkXJd9reNIfl/7Csp+vym/acrv67DvM5M/fkP+1ArKAZ+ZvC77fDf7Pp+hcMgvyzAVjyXkMwwZNFYDAAD0a7/54JAkaXTlII8jAQAAAAAAQH9GIy8AAACAM45pGDJ9hnSKvap+v6ny8iIdPdqsRMLuneB6wHEcRWOWGppjamiJqaE5rsaWWPtxS1wNzbHMWHM0IcdR8nxzTDrcfMI/I73ab0HQL0e5zbaO0/HYkZ011ulYnc9n32sgMg1DhWF/8ieUvQ3kjoX9Kgy1jxWlxgL+vmu07gk71YDtOFLAb8o0aVIGAAADWyxh6b09RyRJF1aWexwNAAAAAAAA+jMaeQEAAACgjxmGoYKQXwUhvyoGFZ5wfsKy1diSavZNN/zmNP/G1dDS3vibsJzMar9eMZRslA74zNTWkN/vS24zY6YC/uSKt8ltcpVcf9Z47jwjcy59X8OQLMvJrPrb/pNcRTluJVdETti2EonUHDu5AnByLLUicHo/tfpyPJFcTTl9r/R9kys3J1d4bmqNq6k1flLvj99nqjCcauwN+VWQafRtb/otCPsV8vtOELOTO5aK07IdxRN26j3o6r3Inp98Pdl8ZnLF7aA/9X77fd0e+487z0wd+7qc4/MZMmQoe3Hj7JWODSOZS+kDI51cqU23czvdUzKyLjRSY9nzMnOMzvcGAAADz5/+XK9Y3FJZcVDnfKLI63AAAAAAAADQj9HICwAAAAB5zu8zVV4SUnlJ6IRzHcdRa5ulxpaY6ptjisYsmWayKdFUamsmmxcNI7k1U9t0Q2XmuMP55Lb9nJk1J/s44DflM41+1wjp95sqKytU3aFGNTTH1BKNq6UtoeZoQq3RhFraEmqJxtWc2k+PNUfjaokm1NqWUEs0IUfJ5uzMCst5yLIdWTFLUQ+bwfNFunnY6ND0m24bzjQQd2oElnxm8v8LvnQDu8+U3zTk92dtfWamcdpnmgr4Dfl8pvymKb/fSG1TjezpfbO9IT77fqZpyHYky7Zl206y6Ty1zd7vfC5rvpMas1Lnnax5Vvt5O/WTeVak35fsZ0PWe2Uaqfcodb59zMi8h+3XpJ8ruWOmKfnNZAN4upk/+b5mvb++3Kb/9Hvb8Vx6/3Q9p5IrmzuybaW27e+dk/VeJ8eTr9U2TZmnJRoAwMnIrMY7bFC/+1wLAAAAAACA/EIjLwAAAAD0I4ZhJFd0DfdstV+4YxiGQkGfys2eNVZ3ZDuOom2WWtram3ubo8kG33QjcPt+QvGEJZ8vuQJxunnR10UzYsd9X9bqxunxzvfpfJ1hSPGEnfMTS9iKJ6wOx+1jsdRPImErljXvhNemVj6WkqsBZy8K7DiSkxqXk57hDScTQ8dAehIVjdD5zpdqhA50+v+NIZ9pJpttnfbG5ezm2+yG5k7NuieZtA/cPF6jzx/Uuy8SAHBSfpfVyAsAAAAAAACcTnnXyLt7924tXbpU77zzjoqKijRt2jTde++9CgaDx73OcRytWrVK3//+93XkyBGNGjVKixYt0vjx43Pm1dXVaenSpXrrrbcUCAQ0ZcoULVq0SMXFxafxVQEAAAAAkFzVON1orVKvo+la+Pi/fnvOcZz2Ftqsht+OjcDZDcId56fnpuc5Wddn7p++zul8vv2+TmZe9lw5kukzVFJSoCNHm9UWs5SwbCUsJ7W1ZVmO4qn99Hh6zOowt6vrcuc4StjJc77Uyry+1I+ZtTVNQz4j2dSdGTeM417TeWtm9tOLEzpO6n1z2t8/J/UPu8P7mjMv/d5l9tPnsv53cpIN8JIyKwsnEsn3Ip79PiZsJWxbiUT2+2YrbjmyUnMTCSdzr7T06tNtfdh0nV7h3GcaMlL/m5imodLikAaVhPssDgDA8SUsW+GgT2OGn+V1KAAAAAAAAOjn8qqRt76+XrNnz1ZlZaVWrFihuro6PfHEE4pGo1qyZMlxr121apWWL1+uBx54QFVVVfre976nr371q/rxj3+soUOHSpLi8bhuu+02SdKTTz6paDSqb3zjG7r//vu1cuXK0/76AAAAAADAqTEMQ5kvtzYy/8g7fr+p8vIiFQdNJRK21+EgxbY7N0jH0/sJO+ecZdsyU022mW1WA3RyXDlN0un97OuSjc/KHHf19ezpfDl6tJl8AYA88bUvX6xwYUghUzybAQAAAAAAcFrlVSPviy++qObmZj3zzDMqKyuTJFmWpUceeURz585VRUVFl9e1tbVp5cqV+upXv6pbb71VkvSZz3xGn//857V69Wp9/etflyS9/vrr2rVrl2pqajR8+HBJUiQS0Zw5c7Rz506NGzfudL9EAAAAAAAAeMQ0DQVNn4IBn9ehAADyXGlxKPMfWQAAAAAAAACnk+l1ANm2bt2qK664ItPEK0lTp06Vbdvatm1bt9f97//+r5qamjR16tTMWDAY1JQpU7R169ac+1dVVWWaeCVp4sSJKisr05YtW3r3xQAAAAAAAAAAAAAAAAAAAADHkVeNvLW1tTlNtlJyxdzBgwertrb2uNdJ6nTtiBEj9OGHHyoajXZ7f8MwNGzYsOPeHwAAAAAAAAAAAAAAAAAAAOhtfq8DyNbQ0KBIJNJpvLS0VPX19ce9LhgMKhQK5YxHIhE5jqP6+nqFw2E1NDSopKTE9f17wu/Pq57oXuPzmTlb4HjIF7hBvsAN8gVukC9wg3yBG+QL3CBf4Ab5AgAAAAAAAADAwJVXjbxnKtM0VF5e5HUYp1UkUuB1CDiDkC9wg3yBG+QL3CBf4Ab5AjfIF7hBvsAN8gUAAAAAAAAAgIEnrxp5I5GIGhsbO43X19ertLT0uNfFYjG1tbXlrMrb0NAgwzAy10YiETU1NXV5/0996lMnHbdtO2poaDnp6/OZz2cqEilQQ0OrLMv2OhzkOfIFbpAvcIN8gRvkC9wgX+AG+QI3yBe40d/zJRIpYLVhAAAAAAAAAAC6kVeNvMOHD1dtbW3OWGNjow4fPqzhw4cf9zpJ2rNnj0aOHJkZr62t1TnnnKNwOJyZ98EHH+Rc6ziO9uzZo4kTJ55S7IlE//tLlmyWZff714jeQ77ADfIFbpAvcIN8gRvkC9wgX+AG+QI3yBcAAAAAAAAAAAaevFoKo7q6Wtu3b1dDQ0NmbNOmTTJN87iNtpdccomKi4v12muvZcbi8bh++tOfqrq6Ouf+f/jDH7R3797M2I4dO3Ts2DFdffXVvftiAAAAAAAAAAAAAAAAAAAAgOPIq0beGTNmqKioSPPmzdNbb72lH/3oR1q2bJlmzJihioqKzLzZs2drypQpmeNQKKS5c+dqzZo1WrdunXbs2KH7779fx44d05w5czLzrr/+el1wwQW6++67tXnzZtXU1Oihhx7SNddco3HjxvXpawUAAAAAAAAAAAAAAAAAAMDA5vc6gGylpaVat26dHnvsMc2bN09FRUWaPn26FixYkDPPtm1ZlpUzdvvtt8txHK1Zs0ZHjhzRqFGjtHr1ag0dOjQzJxAI6LnnntPSpUt13333ye/3a8qUKXrooYf65PUBAAAAAAAAAHAqdu/eraVLl+qdd95RUVGRpk2bpnvvvVfBYPC41z3wwAPauXOnDh06pEAgoE9/+tO66667dOWVV/ZR5AAAAAAAAAC6kleNvJI0YsQIrV279rhz1q9f32nMMAzNnTtXc+fOPe61FRUVWrFixamECAAAAAAAAABAn6uvr9fs2bNVWVmpFStWqK6uTk888YSi0aiWLFly3Gvj8bhuvfVWVVZWqq2tTRs2bNAdd9yh559/XpdeemkfvQIAAAAAAAAAHeVdIy8AAAAAAAAAAOjsxRdfVHNzs5555hmVlZVJkizL0iOPPKK5c+eqoqKi22uffvrpnOPq6mpNnjxZP/7xj2nkBQAAAAAAADxkeh0AAAAAAAAAAAA4sa1bt+qKK67INPFK0tSpU2XbtrZt2+bqXj6fTyUlJYrH470cJQAAAAAAAAA3WJEXAAAAAAAAAIAzQG1trb70pS/ljEUiEQ0ePFi1tbUnvN5xHFmWpcbGRm3cuFH79u3To48+ekox+f39c70Qn8/M2QLHQ77ADfIFbpAvcIucgRvkC9wgX+AG+QI3yJckGnkBAAAAAAAAADgDNDQ0KBKJdBovLS1VfX39Ca/fsGGD/uVf/kWSVFhYqG9961u6+OKLTzoe0zRUXl500tefCSKRAq9DwBmEfIEb5AvcIF/gFjkDN8gXuEG+wA3yBW4M9HyhkRcAAAAAAAAAgAFg8uTJGjlypI4ePapNmzbp3nvv1TPPPKOrr776pO5n244aGlp6Ocr84POZikQK1NDQKsuyvQ4HeY58gRvkC9wgX+AWOQM3yBe4Qb7ADfIFbvT3fIlECnq02jCNvAAAAAAAAAAAnAEikYgaGxs7jdfX16u0tPSE1w8aNEiDBg2SJFVXV6u+vl7/+q//etKNvJKUSPS/v2DJZll2v3+N6D3kC9wgX+AG+QK3yBm4Qb7ADfIFbpAvcGOg58uJW30BAAAAAAAAAIDnhg8frtra2pyxxsZGHT58WMOHD3d9vwsvvFD79u3rrfAAAAAAAAAAnAQaeQEAAAAAAAAAOANUV1dr+/btamhoyIxt2rRJpmlq4sSJru/361//WkOHDu3NEAEAAAAAAAC45Pc6AAAAAAAAAAAAcGIzZszQ+vXrNW/ePM2dO1d1dXVatmyZZsyYoYqKisy82bNn68MPP9TPfvYzSdIvfvELvfLKK7rmmmv0qU99SvX19Xr11Vf11ltv6Zvf/KZXLwcAAAAAAACAaOQFAAAAAAAAAOCMUFpaqnXr1umxxx7TvHnzVFRUpOnTp2vBggU582zblmVZmeOhQ4cqFovpySef1NGjR1VeXq6qqiqtX79el112WV+/DAAAAAAAAABZaOQFAAAAAAAAAOAMMWLECK1du/a4c9avX9/pmmefffY0RgUAAAAAAADgZJleBwAAAAAAAAAAAAAAAAAAAAAMRDTyAgAAAAAAAAAAAAAAAAAAAB6gkRcAAAAAAAAAAAAAAAAAAADwAI28AAAAAAAAAAAAAAAAAAAAgAdo5AUAAAAAAAAAAAAAAAAAAAA8QCMvAAAAAAAAAAAAAAAAAAAA4AEaeQEAAAAAAAAAAAAAAAAAAAAP0MgLAAAAAAAAAAAAAAAAAAAAeIBGXgAAAAAAAAAAAAAAAAAAAMADNPICAAAAAAAAAAAAAAAAAAAAHjAcx3G8DuJM5ziObLv/vo0+nynLsr0OA2cI8gVukC9wg3yBG+QL3CBf4Ab5AjfIF7jRn/PFNA0ZhuF1GABOA2rjQDvyBW6QL3CDfIFb5AzcIF/gBvkCN8gXuNGf86Wn9XEaeQEAAAAAAAAAAAAAAAAAAAAPmF4HAAAAAAAAAAAAAAAAAAAAAAxENPICAAAAAAAAAAAAAAAAAAAAHqCRFwAAAAAAAAAAAAAAAAAAAPAAjbwAAAAAAAAAAAAAAAAAAACAB2jkBQAAAAAAAAAAAAAAAAAAADxAIy8AAAAAAAAAAAAAAAAAAADgARp5AQAAAAAAAAAAAAAAAAAAAA/QyAsAAAAAAAAAAAAAAAAAAAB4gEZeAAAAAAAAAAAAAAAAAAAAwAM08gIAAAAAAAAAAAAAAAAAAAAeoJEXAAAAAAAAAAAAAAAAAAAA8ACNvAAAAAAAAAAAAAAAAAAAAIAHaOQFAAAAAAAAAAAAAAAAAAAAPEAjL7q0e/dufeUrX9H48eM1ceJELVu2TLFYzOuwkIc2btyoqqqqTj//9m//5nVoyAP79u3TkiVLNG3aNI0ePVo33HBDl/N++MMf6vrrr9fYsWP1xS9+UZs3b+7jSJEPepIvM2fO7PKZs3v3bg8ihldee+013XXXXaqurtb48eM1bdo0bdiwQY7j5Mzj2YK0nuQMzxekbdmyRbfccosuv/xyjRkzRpMnT9bjjz+uxsbGnHk///nP9cUvflFjx47V9ddfrx/96EceRQwv9SRfFi5c2OXzZevWrR5GjnzQ3Nys6upqVVVV6d133805x+cYAPAOtXG4QX0c3aE2DjeojcMN6uNwg9o43KA2DjeojeNUUBvvmt/rAJB/6uvrNXv2bFVWVmrFihWqq6vTE088oWg0qiVLlngdHvLUc889p5KSksxxRUWFh9EgX+zatUtbtmzRRRddJNu2OxURJOk///M/tXjxYt155526/PLLVVNTo/nz5+t73/uexo8f3/dBwzM9yRdJuuSSS/Tggw/mjA0ZMqQvQkSeWLt2rc4991wtXLhQ5eXl2r59uxYvXqyPPvpI8+fPl8SzBbl6kjMSzxckHTt2TOPGjdPMmTNVVlamXbt2acWKFdq1a5fWrFkjSfrVr36l+fPna/r06XrooYf03//93/rnf/5nFRUV6fOf/7zHrwB9qSf5IklDhw7t1MwxYsSIvg4XeebZZ5+VZVmdxvkcAwDeoTaOk0V9HB1RG4cb1MbhBvVxuEFtHG5QG4cb1MZxKqiNd81wuvtNAAPWypUr9R//8R/avHmzysrKJEkvvfSSHnnkEW3evJkCFHJs3LhRixYt0o4dOzRo0CCvw0GesW1bpplc/H3hwoX63e9+p1dffTVnzvXXX68xY8boySefzIzNmDFDJSUlWrVqVZ/GC2/1JF9mzpypwsJCrVy50osQkSeOHDnS6d85ixcvVk1NjX75y1/KNE2eLcjRk5zh+YLjefnll7V48WJt3bpVFRUVmjNnjpqbm/Xiiy9m5tx///16//33VVNT42GkyAcd86W7zzUY2Hbv3q3p06frwQcf1MMPP6wNGzZo7NixkvgdCQC8RG0cblEfR3eojcMNauNwg/o43KA2jlNFbRxuUBtHT1Ab757pdQDIP1u3btUVV1yRKVRK0tSpU2XbtrZt2+ZdYADOOOnCU3f+/Oc/a+/evZo6dWrO+Be+8AXt2LGDry0cYE6UL0BaV38xNmrUKDU1NamlpYVnCzo5Uc4AJ5L+3SgejysWi+ntt9/utLrAF77wBe3evVsHDhzwIELkk+x8AbqzdOlSzZgxQ8OGDcsZ53MMAHiL2jiA3kJtHG5QG4cb1MfhBrVxnCpq43CD2jh6gtp49/itAJ3U1tZq+PDhOWORSESDBw9WbW2tR1Eh391www0aNWqUJk+erJUrV3a5BDrQUfqZ0vFf0CNGjFA8Htef//xnL8JCnvuf//kfjR8/XmPHjtUtt9yiX/7yl16HhDzw61//WhUVFSouLubZgh7Jzpk0ni/IZlmW2tra9N577+nf//3fNWnSJA0ZMkT79+9XPB7v9DtT+qug+J1pYOouX9L27dunz3zmMxozZoz+/u//Xm+88YaH0cJrmzZt0gcffKB58+Z1OsfnGADwFrVxnCzq43CLz304GdSu0B3q43CD2jhOhNo43KA2DjeojR+f3+sAkH8aGhoUiUQ6jZeWlqq+vt6DiJDPBg8erLvvvlsXXXSRDMPQz3/+cz311FOqq6vTkiVLvA4PeS79TOn4zEkf88xBR5/97Gc1bdo0VVZW6tChQ1q9erW+8pWvaP369br44ou9Dg8e+dWvfqWamho9+OCDkni24MQ65ozE8wWdXXvttaqrq5MkXXXVVZmv8eEZg650ly9ScpWTsWPH6q/+6q/U2NioH/zgB5o3b56efvrpTqtXoP9rbW3VE088oQULFuT8hVkazxgA8Ba1cbhFfRwni899cIvaFbpDfRxuUBtHT1AbhxvUxtFT1MZPjEZeAKfkqquu0lVXXZU5vvLKKxUKhbRu3TrdeeedOvvssz2MDkB/c8899+QcX3PNNbrhhhv07LPPatWqVR5FBS999NFHWrBggSZMmKBZs2Z5HQ7OAN3lDM8XdPSd73xHra2t+tOf/qRvf/vbuvPOO/Xd737X67CQp7rLF5/Pp9mzZ+fMnTRpkmbMmKHly5dTrByAvv3tb+uss87Sl770Ja9DAQAAvYD6OIC+Qu0KXaE+DjeojaOnqI3DDWrj6Clq4ydmeh0A8k8kElFjY2On8fr6epWWlnoQEc40U6dOlWVZev/9970OBXku/Uzp+MxpaGjIOQ90p7CwUFdffbXee+89r0OBBxoaGnT77berrKxMK1askGkmP9rybEF3usuZrvB8wciRI3XxxRfrxhtv1LPPPqu3335bP/vZz3jGoEvd5UtXTNPUX//1X2v37t2KRqN9HCm8dPDgQa1Zs0b33HOPGhsb1dDQoJaWFklSS0uLmpubecYAgMeojaM3UB9HT/C5D6eK2hWoj8MNauNwg9o43KA2jp6gNt4zrMiLToYPH67a2tqcscbGRh0+fFjDhw/3KCoA/VH6mVJbW5vzfKmtrVUgENDQoUO9Cg1AnotGo5o7d64aGxv10ksvqaSkJHOOZwu6crycAU6kqqpKgUBA+/fv16RJkxQIBFRbW5uz8lb6dyh+Z0J2vgDZDhw4oHg8rjvuuKPTuVmzZumiiy7KfPUcn2MAwBvUxgH0FepXAE4F9XG4QW0cp4LaONygNo7uUBvvGVbkRSfV1dXavn17pqNdkjZt2iTTNDVx4kQPI8OZoqamRj6fT6NHj/Y6FOS5oUOHqrKyUps2bcoZr6mp0RVXXKFgMOhRZDhTtLS06Be/+IXGjh3rdSjoQ4lEQvfee69qa2v13HPPqaKiIuc8zxZ0dKKc6QrPF2T77W9/q3g8riFDhigYDGrChAl6/fXXc+bU1NRoxIgRGjJkiEdRIl9k50tXbNvWpk2bdMEFFygcDvdxdPDSqFGj9Pzzz+f8LFq0SJL0yCOP6OGHH+ZzDAB4jNo4egP1cfQEn/twqqhdDVzUx+EGtXGcKmrjcIPaOLpDbbxnWJEXncyYMUPr16/XvHnzNHfuXNXV1WnZsmWaMWNGjz7YYWCZM2eOJkyYoKqqKknSm2++qZdfflmzZs3S4MGDPY4OXmttbdWWLVskJZfKb2pqyvxL97LLLtOgQYN0991364EHHtB5552nCRMmqKamRjt37tQLL7zgZejwwInyJV1kmDJlis4991wdOnRI3/3ud3X48GE9/fTTXoaOPvbII49o8+bNWrhwoZqamvSb3/wmc2706NEKBoM8W5DjRDmzc+dOni/ImD9/vsaMGaOqqiqFw2H94Q9/0OrVq1VVVaXrrrtOknTXXXdp1qxZ+vrXv66pU6fq7bff1quvvqpvfetbHkePvnaifDl48KAWLlyov/mbv9H555+v+vp6/eAHP9Dvfvc7rVixwuvw0ccikYgmTJjQ5bkLL7xQF154oSTxOQYAPERtHG5RH0d3qI3DDWrjcIP6ONygNg43qI3DDWrjcIPaeM8YjuM4XgeB/LN792499thjeuedd1RUVKRp06ZpwYIFA6K7He4sXbpU//Vf/6WPPvpItm2rsrJSN954o2bOnCnDMLwODx47cOCAJk+e3OW5559/PvMv6h/+8IdatWqVPvzwQw0bNkz33Xefrr322r4MFXngRPnyyU9+Uo8++qj++Mc/6tixYyooKNDFF1+s+fPna9y4cX0cLbw0adIkHTx4sMtzb775Zua/8uTZgrQT5YxlWTxfkPGd73xHNTU12r9/vxzH0bnnnqspU6Zozpw5Ki4uzsx788039dRTT2nPnj0655xzdMcdd2j69OkeRg4vnChfjh07pkWLFun3v/+9Pv74YwUCAY0ZM0Z33HFHztfPYeB6++23NWvWLG3YsCFnpRs+xwCAd6iNww3q4+gOtXG4QW0cblAfhxvUxuEGtXG4QW0cp4raeGc08gIAAAAAAAAAAAAAAAAAAAAeML0OAAAAAAAAAAAAAAAAAAAAABiIaOQFAAAAAAAAAAAAAAAAAAAAPEAjLwAAAAAAAAAAAAAAAAAAAOABGnkBAAAAAAAAAAAAAAAAAAAAD9DICwAAAAAAAAAAAAAAAAAAAHiARl4AAAAAAAAAAAAAAAAAAADAAzTyAgAAAAAAAAAAAAAAAAAAAB6gkRcAAADIsnHjRlVVVendd9/1OhQAAAAAAAAAAPoM9XEAAABv+L0OAAAAAAPPxo0btWjRom7Pv/TSSxo/fnzfBQQAAAAAAAAAQB+gPg4AAICOaOQFAACAZ+655x4NGTKk0/h5553nQTQAAAAAAAAAAPQN6uMAAABIo5EXAAAAnqmurtbYsWO9DgMAAAAAAAAAgD5FfRwAAABpptcBAAAAAF05cOCAqqqqtHr1aq1du1bXXnutxo0bp1tuuUUffPBBp/k7duzQl7/8ZY0fP16XXnqp7rrrLu3evbvTvLq6Oj300EO68sorNWbMGE2aNEkPP/ywYrFYzrxYLKbHH39cl19+ucaPH6958+bpyJEjp+31AgAAAAAAAAAgUR8HAAAYaFiRFwAAAJ5pamrqVPwzDEPl5eWZ41deeUXNzc368pe/rLa2Nq1fv16zZ8/WT37yE33iE5+QJG3fvl233367hgwZovnz5ysajeqFF17QzTffrI0bN2a+nqyurk7Tp09XY2OjbrrpJg0fPlx1dXV6/fXXFY1GFQwGM3/u0qVLFYlENH/+fB08eFDr1q3To48+qqeeeur0vzEAAAAAAAAAgH6N+jgAAADSaOQFAACAZ2699dZOY8FgUO+++27meP/+/frpT3+qiooKScmvG7vxxhu1atUqLVq0SJK0bNkylZaW6qWXXlJZWZkk6brrrtPf/d3facWKFfrGN74hSfrmN7+pv/zlL3r55ZdzvrLsH//xH+U4Tk4cZWVlWrNmjQzDkCTZtq3169ersbFRJSUlvfYeAAAAAAAAAAAGHurjAAAASKORFwAAAJ5ZsmSJhg0bljNmmmbO8XXXXZcpUkrSuHHjdNFFF2nLli1atGiRDh06pPfff1+33XZbpkgpSSNHjtTnPvc5bdmyRVKy0PjGG2/o2muvzSlSpqULkmk33XRTztill16qtWvX6uDBgxo5cuRJv2YAAAAAAAAAAKiPAwAAII1GXgAAAHhm3LhxXRYNs51//vmdxiorK/Xaa69Jkj788ENJ6lTwlKQRI0borbfeUktLi1paWtTU1KQLLrigR7Gdc845OceRSESS1NDQ0KPrAQAAAAAAAADoDvVxAAAApJknngIAAAAMPB1XPkjr+BVjAAAAAAAAAAD0J9THAQAA+hYr8gIAACCv7du3r9PY3r17de6550pqXxlgz549nebV1taqvLxchYWFCofDKi4u1q5du05vwAAAAAAAAAAA9ALq4wAAAAMDK/ICAAAgr73xxhuqq6vLHO/cuVO//e1vVV1dLUk6++yzNWrUKL3yyis5X+v1wQcfaNu2bbr66qslJVcQuO6667R582a9++67nf4cVhIAAAAAAAAAAOQT6uMAAAADAyvyAgAAwDNbt25VbW1tp/FLLrlEhmFIks477zzdfPPNuvnmmxWLxfT888+rrKxMt912W2b+1772Nd1+++36h3/4B02fPl3RaFQvvPCCSkpKNH/+/My8++67T9u2bdPMmTN10003acSIETp8+LA2bdqk73//+4pEIqf/RQMAAAAAAAAABjzq4wAAAEijkRcAAACeWb58eZfjjz/+uC677DJJ0t/+7d/KNE2tW7dOH3/8scaNG6fFixfr7LPPzsz/3Oc+p+eee07Lly/X8uXL5ff79dnPflb/9E//pKFDh2bmVVRU6OWXX9bTTz+tn/zkJ2pqalJFRYWqq6sVDodP74sFAAAAAAAAACCF+jgAAADSDIfvSAAAAEAeOnDggCZPnqyvfe1rmjNnjtfhAAAAAAAAAADQJ6iPAwAADCym1wEAAAAAAAAAAAAAAAAAAAAAAxGNvAAAAAAAAAAAAAAAAAAAAIAHaOQFAAAAAAAAAAAAAAAAAAAAPGA4juN4HQQAAAAAAAAAAAAAAAAAAAAw0LAiLwAAAAAAAAAAAAAAAAAAAOABGnkBAAAAAAAAAAAAAAAAAAAAD9DICwAAAAAAAAAAAAAAAAAAAHiARl4AAAAAAAAAAAAAAAAAAADAAzTyAgAAAAAAAAAAAAAAAAAAAB6gkRcAAAAAAAAAAAAAAAAAAADwAI28AAAAAAAAAAAAAAAAAAAAgAdo5AUAAAAAAAAAAAAAAAAAAAA8QCMvAAAAAAAAAAAAAAAAAAAA4IH/B38eurOqEoQgAAAAAElFTkSuQmCC","text/plain":["<Figure size 3500x1000 with 2 Axes>"]},"metadata":{},"output_type":"display_data"},{"data":{"text/plain":["dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy', 'lr'])"]},"execution_count":85,"metadata":{},"output_type":"execute_result"}],"source":["# Both loss and accuracy graphs side to side.\n","\n","fig, (ax1, ax2) = plt.subplots(1, 2)\n","ax1.plot(history_callback_object.history[\"loss\"], label=\"loss\")\n","ax1.plot(history_callback_object.history[\"val_loss\"], label=\"val_loss\")\n","ax1.legend()\n","ax1.set_xlabel(\"Epoch\")\n","ax1.set_ylabel(\"Loss\")\n","ax1.set_title(\"Loss vs Epoch\")\n","ax1.grid(True)\n","\n","ax2.plot(history_callback_object.history[\"accuracy\"], label=\"accuracy\")\n","ax2.plot(history_callback_object.history[\"val_accuracy\"], label=\"val_accuracy\")\n","ax2.legend()\n","ax2.set_xlabel(\"Epoch\")\n","ax2.set_ylabel(\"Accuracy\")\n","ax2.set_title(\"Accuracy vs Epoch\")\n","ax2.grid(True)\n","\n","fig.set_figheight(10)\n","fig.set_figwidth(35)\n","plt.show()\n","\n","history_callback_object.history.keys()"]}],"metadata":{"kaggle":{"accelerator":"gpu","dataSources":[{"datasetId":605165,"sourceId":1085454,"sourceType":"datasetVersion"}],"dockerImageVersionId":30627,"isGpuEnabled":true,"isInternetEnabled":true,"language":"python","sourceType":"notebook"},"kernelspec":{"display_name":"Python 3","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.12"}},"nbformat":4,"nbformat_minor":4}