├── LICENSE ├── README.md └── With_GoogleNet.ipynb /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2023 KobeWang-supreme 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Music-genre-classification-with-different-CNNs 2 | Using different CNN models to train on GTZAN Dataset 3 | You can download the whole dataset from: https://www.kaggle.com/datasets/andradaolteanu/gtzan-dataset-music-genre-classification 4 | 5 | Results up to now: 6 | 1. GoogleNet : Test Accuracy: Around 55% - 60% 7 | 8 | 3. Newly Designed CNN: 9 | 10 | With only Mel n_feature = 128: Test Accuracy(10 genres): Around 70% - 80% (baseline: 10%) Test Accuracy(5 genres): Around 85% (baseline: 20%) 11 | 12 | 13 | With Mfcc n_feature = 128: Test Accuracy(10 genres): Around 82%, which is almostly equal to the accuracy with both Mel and Mfcc 14 | 15 | 16 | With Mel and Mfcc(added together) n_feature = 128: Test Accuracy(10 genres): Around 83% (baseline: 10%) Test Accuracy(5 genres): Around 91% (baseline: 20%) 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | Confusion Matrics: 26 | 27 | 28 | 1 29 | 30 | 31 | 32 | 33 | 34 | 35 | Let's test on a Reggae Song: 36 | 37 | 96_degrees 38 | 39 | Result: 40 | 41 | ![result](https://github.com/KobeWang-supreme/Music-genre-classification-with-different-CNNswith-different-CNN/assets/78716482/124f157c-52c1-4a21-98d3-9604116a8389) 42 | 43 | 44 | 45 | 46 | Findings: 47 | 1. Actually, some musics belongs to not only one genre. Such as songs from Norah Jones, many songs of her belongs to both jazz and blues. Our model can only return one genre(with highest score). However, it is also clear that by visualizing scores for every genre, we can see jazz and blues have much higher scores than other genres. 48 | 49 | 3 50 | 51 | 52 | Let's take "Don't know why" as an example: 53 | 54 | 55 | 2 56 | 57 | 58 | 59 | 60 | 61 | 62 | -------------------------------------------------------------------------------- /With_GoogleNet.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "We are using the dataset called \"GTZAN\", which is widely used in Music Genre Classification.\n", 8 | "Our goal is to use audios' mfccs to make the classification. This data_deal.ipynb will show how mfccs are generated." 9 | ] 10 | }, 11 | { 12 | "cell_type": "code", 13 | "execution_count": 159, 14 | "metadata": {}, 15 | "outputs": [], 16 | "source": [ 17 | "import numpy as np \n", 18 | "import pandas as pd \n", 19 | "import librosa\n", 20 | "import os\n", 21 | "import tqdm\n", 22 | "import matplotlib.pyplot as plt\n", 23 | "import random\n", 24 | "import librosa.display\n", 25 | "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", 26 | "import torch\n", 27 | "import torchvision\n", 28 | "from torchvision import transforms\n", 29 | "from torchvision.datasets import ImageFolder\n", 30 | "from torch.utils.data.dataloader import DataLoader\n", 31 | "from torch.utils.data import random_split\n", 32 | "from torchvision.utils import make_grid\n", 33 | "import torch.nn as nn\n", 34 | "import torch.nn.functional as F\n", 35 | "from sklearn.model_selection import train_test_split\n", 36 | "from torch.utils.data import Dataset, TensorDataset\n", 37 | "from sklearn.metrics import classification_report\n", 38 | "from sklearn import metrics" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": 160, 44 | "metadata": {}, 45 | "outputs": [], 46 | "source": [ 47 | "def seed_torch(seed):\n", 48 | " random.seed(seed) # python seed\n", 49 | " os.environ['PYTHONHASHSEED'] = str(seed) # 设置python哈希种子，for certain hash-based operations (e.g., the item order in a set or a dict）。seed为0的时候表示不用这个feature，也可以设置为整数。 有时候需要在终端执行，到脚本实行可能就迟了。\n", 50 | " np.random.seed(seed) # If you or any of the libraries you are using rely on NumPy, 比如Sampling，或者一些augmentation。 哪些是例外可以看https://pytorch.org/docs/stable/notes/randomness.html\n", 51 | " torch.manual_seed(seed) # 为当前CPU设置随机种子。 pytorch官网倒是说(both CPU and CUDA)\n", 52 | " torch.cuda.manual_seed(seed) # 为当前GPU设置随机种子\n", 53 | " # torch.cuda.manual_seed_all(seed) # 使用多块GPU时，均设置随机种子\n", 54 | " torch.backends.cudnn.deterministic = True\n", 55 | " # torch.backends.cudnn.benchmark = True # 设置为True时，cuDNN使用非确定性算法寻找最高效算法\n", 56 | " # torch.backends.cudnn.enabled = True # pytorch使用CUDANN加速，即使用GPU加速\n", 57 | " \n", 58 | "seed_torch(seed=32)" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "First we should read the data." 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 161, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "def data_read(directory=r\"F:\\music\\archive\\Data\\genres_original\"): # change the directory if you like \n", 75 | " data = [] # Store all data (read from music)\n", 76 | " labels = [] # Store corresponding labels\n", 77 | " srs = []\n", 78 | "\n", 79 | " x = 0\n", 80 | "\n", 81 | " for dirname, _, filenames in os.walk(r\"F:\\music\\archive\\Data\\genres_original\"):\n", 82 | " for filename in filenames:\n", 83 | " # Get name and skip the broken\n", 84 | " if x == 554: # skip the broken one \n", 85 | " x += 1\n", 86 | " continue\n", 87 | " filename = os.path.join(dirname, filename)\n", 88 | " \n", 89 | " y, sr = librosa.load(filename)\n", 90 | " # print(filename)\n", 91 | " label = filename.split('\\\\')[5]\n", 92 | "\n", 93 | " # Append them to the final data\n", 94 | " data.append(y)\n", 95 | " labels.append(label)\n", 96 | " srs.append(sr)\n", 97 | " x += 1\n", 98 | " #print(x) # counting\n", 99 | " #print(len(data))\n", 100 | " \n", 101 | " return data, labels, srs" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": 162, 107 | "metadata": {}, 108 | "outputs": [], 109 | "source": [ 110 | "data, labels, srs = data_read() " 111 | ] 112 | }, 113 | { 114 | "cell_type": "markdown", 115 | "metadata": {}, 116 | "source": [ 117 | "Get one random sample to show whether we read the data successfully." 118 | ] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": 163, 123 | "metadata": {}, 124 | "outputs": [ 125 | { 126 | "data": { 127 | "image/png": "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", 128 | "text/plain": [ 129 | "
" 130 | ] 131 | }, 132 | "metadata": {}, 133 | "output_type": "display_data" 134 | } 135 | ], 136 | "source": [ 137 | "def check(): \n", 138 | " fig, axi = plt.subplots(1,1) # initialize\n", 139 | " ind = random.randint(0, len(labels)-1) # randomly choose one index\n", 140 | " times = [sample/srs[ind] for sample in range(len(data[ind]))] # get time axis \n", 141 | " axi.plot(times, data[ind])\n", 142 | " axi.set_ylabel('Normalized Amplitude')\n", 143 | " axi.set_xlabel('Time /s')\n", 144 | " axi.set(title = \"one example from \" + labels[ind].capitalize())\n", 145 | "\n", 146 | " plt.show()\n", 147 | "\n", 148 | "check()" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": {}, 154 | "source": [ 155 | "Then we need to extract mfccs features from \"data\"" 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": 164, 161 | "metadata": {}, 162 | "outputs": [], 163 | "source": [ 164 | "def get_mfcc(data, srs, num_mfcc):\n", 165 | " '''\n", 166 | " input: data : array like data structure\n", 167 | " src : sampling rates\n", 168 | " num_mfcc: how many mfcc features you want\n", 169 | "\n", 170 | " return: mfccs\n", 171 | " '''\n", 172 | " mfccs = []\n", 173 | " for i in range(len(data)):\n", 174 | " mfcc = librosa.feature.mfcc(y=data[i], sr=srs[i], n_mfcc=num_mfcc).T\n", 175 | " mfccs.append(mfcc) # every sample we get one array of mfccs and append it.\n", 176 | " \n", 177 | " return mfccs # contains every music's mfcc" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": 165, 183 | "metadata": {}, 184 | "outputs": [], 185 | "source": [ 186 | "mfccs = get_mfcc(data, srs, num_mfcc=40)" 187 | ] 188 | }, 189 | { 190 | "cell_type": "markdown", 191 | "metadata": {}, 192 | "source": [ 193 | "Then we need to pad mfccs to make them have the same length" 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": 166, 199 | "metadata": {}, 200 | "outputs": [], 201 | "source": [ 202 | "max_length = len(max(mfccs, key=len)) # get the max length\n", 203 | "def pad_mfcc(mfccs, max_length):\n", 204 | " 'pads'\n", 205 | " mfccs_padded = []\n", 206 | " for mfcc in mfccs:\n", 207 | " mfcc_padded = np.pad(mfcc, pad_width=[(0,max_length-mfcc[:,0].shape[0]),(0,0)])\n", 208 | " mfccs_padded.append(mfcc_padded)\n", 209 | " return mfccs_padded" 210 | ] 211 | }, 212 | { 213 | "cell_type": "code", 214 | "execution_count": 167, 215 | "metadata": {}, 216 | "outputs": [], 217 | "source": [ 218 | "mfccs_padded = pad_mfcc(mfccs, max_length)" 219 | ] 220 | }, 221 | { 222 | "cell_type": "markdown", 223 | "metadata": {}, 224 | "source": [ 225 | "Next, we put the mfccs_padded into dataloader" 226 | ] 227 | }, 228 | { 229 | "cell_type": "code", 230 | "execution_count": 168, 231 | "metadata": {}, 232 | "outputs": [ 233 | { 234 | "name": "stdout", 235 | "output_type": "stream", 236 | "text": [ 237 | " labels\n", 238 | "0 blues\n", 239 | "1 blues\n", 240 | "2 blues\n", 241 | "3 blues\n", 242 | "4 blues\n", 243 | ".. ...\n", 244 | "994 rock\n", 245 | "995 rock\n", 246 | "996 rock\n", 247 | "997 rock\n", 248 | "998 rock\n", 249 | "\n", 250 | "[999 rows x 1 columns]\n", 251 | " labels\n", 252 | "0 0\n", 253 | "1 0\n", 254 | "2 0\n", 255 | "3 0\n", 256 | "4 0\n", 257 | ".. ...\n", 258 | "994 9\n", 259 | "995 9\n", 260 | "996 9\n", 261 | "997 9\n", 262 | "998 9\n", 263 | "\n", 264 | "[999 rows x 1 columns]\n", 265 | "[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", 266 | " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", 267 | " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1\n", 268 | " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", 269 | " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", 270 | " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n", 271 | " 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n", 272 | " 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n", 273 | " 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3\n", 274 | " 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3\n", 275 | " 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4\n", 276 | " 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4\n", 277 | " 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4\n", 278 | " 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5\n", 279 | " 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5\n", 280 | " 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5\n", 281 | " 5 5 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6\n", 282 | " 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6\n", 283 | " 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 7 7 7 7\n", 284 | " 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7\n", 285 | " 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7\n", 286 | " 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n", 287 | " 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n", 288 | " 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n", 289 | " 8 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9\n", 290 | " 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9\n", 291 | " 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9]\n" 292 | ] 293 | } 294 | ], 295 | "source": [ 296 | "# convert data to numpy array\n", 297 | "X = np.asarray(mfccs_padded) \n", 298 | "# Mapping labels \n", 299 | "codes = {\n", 300 | " 'blues':0,\n", 301 | " 'classical':1,\n", 302 | " 'country':2,\n", 303 | " 'disco':3,\n", 304 | " 'hiphop':4,\n", 305 | " 'jazz':5,\n", 306 | " 'metal':6,\n", 307 | " 'pop':7,\n", 308 | " 'reggae':8,\n", 309 | " 'rock':9\n", 310 | "}\n", 311 | "\n", 312 | "df_map = pd.DataFrame (labels, columns = ['labels'])\n", 313 | "print(df_map)\n", 314 | "df_map['labels'] = df_map['labels'].map(codes)\n", 315 | "print(df_map)\n", 316 | "y = df_map['labels'].to_numpy()\n", 317 | "print(y)" 318 | ] 319 | }, 320 | { 321 | "cell_type": "code", 322 | "execution_count": 169, 323 | "metadata": {}, 324 | "outputs": [], 325 | "source": [ 326 | "# To split train_data, valid_data and test_data\n", 327 | "def train_val_test_split(x, y, test_size, val_size, random_state=None, stratify=None):\n", 328 | " x_t, x_test, y_t, y_test = train_test_split(x, y, test_size=test_size, random_state=random_state, stratify=stratify)\n", 329 | " if stratify is not None:\n", 330 | " stratify = y_t\n", 331 | " x_train, x_val, y_train, y_val = train_test_split(x_t, y_t, test_size=val_size, random_state=random_state, stratify=stratify)\n", 332 | " \n", 333 | " return x_train, y_train, x_val, y_val, x_test, y_test\n", 334 | "\n", 335 | "def to_Dataloader(x_train, y_train, x_val, y_val, x_test, y_test, batch_size, test_batch=1,shuffle=True):\n", 336 | " \n", 337 | " train_dataset = TensorDataset(torch.Tensor(x_train),torch.Tensor(y_train).type(torch.LongTensor)) # create train_dataset\n", 338 | " val_dataset = TensorDataset(torch.Tensor(x_val),torch.Tensor(y_val).type(torch.LongTensor)) # create val_dataset\n", 339 | " test_dataset = TensorDataset(torch.Tensor(x_test),torch.Tensor(y_test).type(torch.LongTensor)) # create test_dataset\n", 340 | "\n", 341 | " train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle) # create your train_dataloader\n", 342 | " val_dataloader = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle) # create your val_dataloader\n", 343 | " test_dataloader = DataLoader(test_dataset, batch_size=test_batch, shuffle=shuffle) # create your test_dataloader\n", 344 | " \n", 345 | " return train_dataloader, val_dataloader, test_dataloader" 346 | ] 347 | }, 348 | { 349 | "cell_type": "code", 350 | "execution_count": 170, 351 | "metadata": {}, 352 | "outputs": [ 353 | { 354 | "name": "stdout", 355 | "output_type": "stream", 356 | "text": [ 357 | "finished\n" 358 | ] 359 | } 360 | ], 361 | "source": [ 362 | "x_train, y_train, x_val, y_val, x_test, y_test = train_val_test_split(X, y, test_size=0.15, val_size=0.15, random_state=42, stratify=y)\n", 363 | "\n", 364 | "train_dataloader, val_dataloader, test_dataloader = to_Dataloader(x_train, y_train, x_val, y_val, x_test, y_test, batch_size=64, test_batch=1,shuffle=True)\n", 365 | "\n", 366 | "print('finished')" 367 | ] 368 | }, 369 | { 370 | "cell_type": "markdown", 371 | "metadata": {}, 372 | "source": [ 373 | "We then define a class called \"early stop \"\n", 374 | "It is from : \"https://github.com/Bjarten/early-stopping-pytorch/blob/master/pytorchtools.py\"" 375 | ] 376 | }, 377 | { 378 | "cell_type": "code", 379 | "execution_count": 171, 380 | "metadata": {}, 381 | "outputs": [], 382 | "source": [ 383 | "class EarlyStopping:\n", 384 | " \"\"\"Early stops the training if validation loss doesn't improve after a given patience.\"\"\"\n", 385 | " def __init__(self, patience=7, verbose=False, delta=0, path='checkpoint.pt', trace_func=print):\n", 386 | " \"\"\"\n", 387 | " Args:\n", 388 | " patience (int): How long to wait after last time validation loss improved.\n", 389 | " Default: 7\n", 390 | " verbose (bool): If True, prints a message for each validation loss improvement. \n", 391 | " Default: False\n", 392 | " delta (float): Minimum change in the monitored quantity to qualify as an improvement.\n", 393 | " Default: 0\n", 394 | " path (str): Path for the checkpoint to be saved to.\n", 395 | " Default: 'checkpoint.pt'\n", 396 | " trace_func (function): trace print function.\n", 397 | " Default: print \n", 398 | " \"\"\"\n", 399 | " self.patience = patience\n", 400 | " self.verbose = verbose\n", 401 | " self.counter = 0\n", 402 | " self.best_score = None\n", 403 | " self.early_stop = False\n", 404 | " self.val_loss_min = np.Inf\n", 405 | " self.delta = delta\n", 406 | " self.path = path\n", 407 | " self.trace_func = trace_func\n", 408 | " def __call__(self, val_loss, model):\n", 409 | "\n", 410 | " score = -val_loss\n", 411 | "\n", 412 | " if self.best_score is None:\n", 413 | " self.best_score = score\n", 414 | " self.save_checkpoint(val_loss, model)\n", 415 | " elif score < self.best_score + self.delta:\n", 416 | " self.counter += 1\n", 417 | " self.trace_func(f'EarlyStopping counter: {self.counter} out of {self.patience}')\n", 418 | " if self.counter >= self.patience:\n", 419 | " self.early_stop = True\n", 420 | " else:\n", 421 | " self.best_score = score\n", 422 | " self.save_checkpoint(val_loss, model)\n", 423 | " self.counter = 0\n", 424 | "\n", 425 | " def save_checkpoint(self, val_loss, model):\n", 426 | " '''Saves model when validation loss decrease.'''\n", 427 | " if self.verbose:\n", 428 | " self.trace_func(f'Validation loss decreased ({self.val_loss_min:.6f} --> {val_loss:.6f}). Saving model ...')\n", 429 | " torch.save(model.state_dict(), self.path)\n", 430 | " self.val_loss_min = val_loss" 431 | ] 432 | }, 433 | { 434 | "cell_type": "markdown", 435 | "metadata": {}, 436 | "source": [ 437 | "After doing all things above, it is time to build our model to train this dataset!" 438 | ] 439 | }, 440 | { 441 | "cell_type": "markdown", 442 | "metadata": {}, 443 | "source": [ 444 | "For the first model, we try to Reproducing GoogleNet:" 445 | ] 446 | }, 447 | { 448 | "cell_type": "code", 449 | "execution_count": 172, 450 | "metadata": {}, 451 | "outputs": [], 452 | "source": [ 453 | "# A class to define the Inception\n", 454 | "class Inception(nn.Module):\n", 455 | " def __init__(self, in_channels, c1, c2, c3, c4, **kwargs):\n", 456 | " super(Inception, self).__init__(**kwargs)\n", 457 | " self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1)\n", 458 | " #1X1 kernel\n", 459 | " self.p2_1 = nn.Conv2d(in_channels, c2[0], kernel_size=1)\n", 460 | " self.p2_2 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1)\n", 461 | " #1X1,3X3 kernel\n", 462 | " self.p3_1 = nn.Conv2d(in_channels, c3[0], kernel_size=1)\n", 463 | " self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_size=5, padding=2)\n", 464 | " #1X1,5X5 kernel\n", 465 | " self.p4_1 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)\n", 466 | " self.p4_2 = nn.Conv2d(in_channels, c4, kernel_size=1)\n", 467 | " #maxpool, 1x1 kernel\n", 468 | " def forward(self, x):\n", 469 | " p1 = F.relu(self.p1_1(x))\n", 470 | " p2 = F.relu(self.p2_2(F.relu(self.p2_1(x))))\n", 471 | " p3 = F.relu(self.p3_2(F.relu(self.p3_1(x))))\n", 472 | " p4 = F.relu(self.p4_2(self.p4_1(x)))\n", 473 | " # Sequentialize\n", 474 | " return torch.cat((p1, p2, p3, p4), dim=1)\n", 475 | " \n", 476 | "\n", 477 | "class GoogleNet(nn.Module):\n", 478 | " def __init__(self):\n", 479 | " super(GoogleNet, self).__init__()\n", 480 | " self.num_conv_layers = 5\n", 481 | " b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),\n", 482 | " nn.ReLU(),\n", 483 | " nn.MaxPool2d(kernel_size=3, stride=2, padding=1))\n", 484 | "\n", 485 | " b2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=1),\n", 486 | " nn.ReLU(),\n", 487 | " nn.Conv2d(64, 192, kernel_size=3, padding=1),\n", 488 | " nn.ReLU(),\n", 489 | " nn.MaxPool2d(kernel_size=3, stride=2, padding=1))\n", 490 | "\n", 491 | " b3 = nn.Sequential(Inception(192, 64, (96, 128), (16, 32), 32),\n", 492 | " Inception(256, 128, (128, 192), (32, 96), 64),\n", 493 | " nn.MaxPool2d(kernel_size=3, stride=2, padding=1))\n", 494 | "\n", 495 | " b4 = nn.Sequential(Inception(480, 192, (96, 208), (16, 48), 64),\n", 496 | " Inception(512, 160, (112, 224), (24, 64), 64),\n", 497 | " Inception(512, 128, (128, 256), (24, 64), 64),\n", 498 | " Inception(512, 112, (144, 288), (32, 64), 64),\n", 499 | " Inception(528, 256, (160, 320), (32, 128), 128),\n", 500 | " nn.MaxPool2d(kernel_size=3, stride=2, padding=1))\n", 501 | "\n", 502 | " b5 = nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128),\n", 503 | " Inception(832, 384, (192, 384), (48, 128), 128),\n", 504 | " nn.AdaptiveAvgPool2d((1,1)),\n", 505 | " nn.Flatten())\n", 506 | " #seq = [b1, b2, b3, b4, b5]\n", 507 | " self.fitter = nn.Sequential(b1, b2, b3, b4, b5, nn.Linear(1024, 10))\n", 508 | "\n", 509 | " def forward(self, x):\n", 510 | "\n", 511 | " x = x.transpose(1,2)\n", 512 | " x.unsqueeze_(1)\n", 513 | " out = self.fitter(x)\n", 514 | " return out" 515 | ] 516 | }, 517 | { 518 | "cell_type": "code", 519 | "execution_count": 173, 520 | "metadata": {}, 521 | "outputs": [], 522 | "source": [ 523 | "# Then we wanna define a resnet\n", 524 | "class MusicGenreModel(nn.Module):\n", 525 | " def __init__(self, classes=10):\n", 526 | " super().__init__()\n", 527 | "\n", 528 | " self.classes = classes\n", 529 | " self.linear1 = nn.Linear(20, 200)\n", 530 | " self.linear2 = nn.Linear(200, 100)\n", 531 | " self.output = nn.Linear(100, self.classes)\n", 532 | "\n", 533 | " def forward(self, x):\n", 534 | " x = x.view(x.size(0), -1)\n", 535 | " x = self.linear1(x)\n", 536 | " x = torch.relu_(x)\n", 537 | " x = self.linear2(x)\n", 538 | " x = torch.relu_(x)\n", 539 | " \n", 540 | " return F.softmax(self.output(x), dim=1)\n" 541 | ] 542 | }, 543 | { 544 | "cell_type": "code", 545 | "execution_count": 174, 546 | "metadata": {}, 547 | "outputs": [ 548 | { 549 | "name": "stdout", 550 | "output_type": "stream", 551 | "text": [ 552 | "cuda\n" 553 | ] 554 | } 555 | ], 556 | "source": [ 557 | "# check the device\n", 558 | "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", 559 | "print(device)" 560 | ] 561 | }, 562 | { 563 | "cell_type": "markdown", 564 | "metadata": {}, 565 | "source": [ 566 | "Build functions which used for training and predicting" 567 | ] 568 | }, 569 | { 570 | "cell_type": "code", 571 | "execution_count": 175, 572 | "metadata": {}, 573 | "outputs": [], 574 | "source": [ 575 | "def training_loop(model, train_dataloader, optimizer, device=device):\n", 576 | "\n", 577 | " model.train() # Sets model to train mode\n", 578 | " batch_losses = []\n", 579 | "\n", 580 | " for x_batch, y_batch in train_dataloader:\n", 581 | " # Move batches to device\n", 582 | " x_batch, y_batch = x_batch.to(device), y_batch.to(device)\n", 583 | " \n", 584 | " # Clear gradients\n", 585 | " optimizer.zero_grad()\n", 586 | "\n", 587 | " yhat = model(x_batch) #predictions on x\n", 588 | " \n", 589 | " # Forward pass\n", 590 | " loss = loss_function(yhat, y_batch)\n", 591 | " \n", 592 | " # Backward and optimize\n", 593 | " loss.backward()\n", 594 | "\n", 595 | " # Update parameters\n", 596 | " optimizer.step()\n", 597 | "\n", 598 | " batch_losses.append(loss.data.item())\n", 599 | "\n", 600 | " train_loss = np.mean(batch_losses)\n", 601 | "\n", 602 | " return train_loss # Return train_loss and anything else you need\n", 603 | "\n", 604 | "def validation_loop(model, val_dataloader, device=device):\n", 605 | "\n", 606 | " model.eval() # Sets model to val mode\n", 607 | "\n", 608 | " batch_losses = []\n", 609 | "\n", 610 | " for x_batch, y_batch in val_dataloader:\n", 611 | "\n", 612 | " x_batch, y_batch = x_batch.to(device), y_batch.to(device)\n", 613 | " \n", 614 | " yhat = model(x_batch) #predictions on x\n", 615 | " \n", 616 | " loss = loss_function(yhat, y_batch)\n", 617 | "\n", 618 | " batch_losses.append(loss.data.item())\n", 619 | "\n", 620 | " val_loss = np.mean(batch_losses)\n", 621 | "\n", 622 | " return val_loss\n", 623 | "\n", 624 | "def train(model, train_dataloader, val_dataloader, optimizer, epochs, device=\"cuda\", patience = None, temp=100):\n", 625 | "\n", 626 | " train_losses = []\n", 627 | " val_losses = []\n", 628 | "\n", 629 | " print(f\"Initiating training.\")\n", 630 | " \n", 631 | " # Check if early stop is enabled:\n", 632 | " if patience is not None:\n", 633 | " # Initialize EarlyStopping\n", 634 | " early_stopping = EarlyStopping(patience=patience, verbose=False, path='checkpoint.pt')\n", 635 | "\n", 636 | " for epoch in range(epochs):\n", 637 | " # Training loop\n", 638 | "\n", 639 | " train_loss = training_loop(model, train_dataloader, optimizer, device)\n", 640 | " train_losses.append(train_loss)\n", 641 | "\n", 642 | " # Validation loop\n", 643 | " with torch.no_grad():\n", 644 | "\n", 645 | " val_loss = validation_loop(model, val_dataloader, device)\n", 646 | " val_losses.append(val_loss)\n", 647 | "\n", 648 | " if patience != -1:\n", 649 | " early_stopping(val_loss, model)\n", 650 | "\n", 651 | " if early_stopping.early_stop:\n", 652 | " print(\"Early stop. Going back to the last checkpoint.\")\n", 653 | " break\n", 654 | "\n", 655 | " if epoch % temp == 0:\n", 656 | " print(f\"[{epoch}/{epochs}] Training loss: {train_loss:.4f}\\t Validation loss: {val_loss:.4f}.\")\n", 657 | "\n", 658 | " if patience != None and early_stopping.early_stop == True:\n", 659 | " print('Loading model from checkpoint...')\n", 660 | " model.load_state_dict(torch.load('checkpoint.pt'))\n", 661 | " print('Checkpoint loaded.')\n", 662 | "\n", 663 | " print(\"training finished.\")\n", 664 | " \n", 665 | " # visualize the loss as the network trained\n", 666 | " fig = plt.figure(figsize=(10, 8))\n", 667 | " plt.plot(range(1, len(train_losses) + 1), train_losses, label='Training Loss')\n", 668 | " plt.plot(range(1, len(val_losses) + 1), val_losses, label='Validation Loss')\n", 669 | "\n", 670 | " # find position of lowest validation loss\n", 671 | " minposs = val_losses.index(min(val_losses)) + 1\n", 672 | " plt.axvline(minposs, linestyle='--', color='r', label='Early Stopping Checkpoint')\n", 673 | "\n", 674 | " plt.xlabel('epochs')\n", 675 | " plt.ylabel('loss')\n", 676 | " plt.ylim(0, max(val_losses + train_losses)) # consistent scale\n", 677 | " plt.xlim(0, len(train_losses) + 1) # consistent scale\n", 678 | " plt.grid(True)\n", 679 | " plt.legend()\n", 680 | " plt.tight_layout()\n", 681 | " plt.title('Validation and Training Loss of CNN')\n", 682 | " plt.show()\n", 683 | "\n", 684 | " return model\n", 685 | "\n", 686 | "\n", 687 | "def predict(model, test_loader, n_features, loss_function, device=device):\n", 688 | " # Make predictions using model\n", 689 | " preds = []\n", 690 | " true_values = []\n", 691 | " loss = 0\n", 692 | " model.eval() # prep model for evaluation\n", 693 | " \n", 694 | " with torch.no_grad():\n", 695 | " for x_batch, y_batch in test_loader:\n", 696 | " # move to device\n", 697 | " x_batch, y_batch = x_batch.to(device), y_batch.to(device)\n", 698 | "\n", 699 | " # Make predictions\n", 700 | " pred = model(x_batch)\n", 701 | " \n", 702 | " preds.append(np.argmax(pred.cpu().numpy(), axis=1)[0])\n", 703 | " true_values.append(y_batch.cpu().numpy()[0])\n", 704 | " loss += loss_function(pred, y_batch)\n", 705 | "\n", 706 | " #Calculate Accuracy\n", 707 | " accuracy = sum(np.array(preds) == np.array(true_values))/len(true_values)\n", 708 | " \n", 709 | " return preds, true_values, accuracy" 710 | ] 711 | }, 712 | { 713 | "cell_type": "markdown", 714 | "metadata": {}, 715 | "source": [ 716 | "Initialize the model" 717 | ] 718 | }, 719 | { 720 | "cell_type": "code", 721 | "execution_count": 176, 722 | "metadata": {}, 723 | "outputs": [ 724 | { 725 | "data": { 726 | "text/plain": [ 727 | "GoogleNet(\n", 728 | " (fitter): Sequential(\n", 729 | " (0): Sequential(\n", 730 | " (0): Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3))\n", 731 | " (1): ReLU()\n", 732 | " (2): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", 733 | " )\n", 734 | " (1): Sequential(\n", 735 | " (0): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n", 736 | " (1): ReLU()\n", 737 | " (2): Conv2d(64, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 738 | " (3): ReLU()\n", 739 | " (4): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", 740 | " )\n", 741 | " (2): Sequential(\n", 742 | " (0): Inception(\n", 743 | " (p1_1): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1))\n", 744 | " (p2_1): Conv2d(192, 96, kernel_size=(1, 1), stride=(1, 1))\n", 745 | " (p2_2): Conv2d(96, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 746 | " (p3_1): Conv2d(192, 16, kernel_size=(1, 1), stride=(1, 1))\n", 747 | " (p3_2): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n", 748 | " (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", 749 | " (p4_2): Conv2d(192, 32, kernel_size=(1, 1), stride=(1, 1))\n", 750 | " )\n", 751 | " (1): Inception(\n", 752 | " (p1_1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n", 753 | " (p2_1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))\n", 754 | " (p2_2): Conv2d(128, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 755 | " (p3_1): Conv2d(256, 32, kernel_size=(1, 1), stride=(1, 1))\n", 756 | " (p3_2): Conv2d(32, 96, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n", 757 | " (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", 758 | " (p4_2): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))\n", 759 | " )\n", 760 | " (2): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", 761 | " )\n", 762 | " (3): Sequential(\n", 763 | " (0): Inception(\n", 764 | " (p1_1): Conv2d(480, 192, kernel_size=(1, 1), stride=(1, 1))\n", 765 | " (p2_1): Conv2d(480, 96, kernel_size=(1, 1), stride=(1, 1))\n", 766 | " (p2_2): Conv2d(96, 208, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 767 | " (p3_1): Conv2d(480, 16, kernel_size=(1, 1), stride=(1, 1))\n", 768 | " (p3_2): Conv2d(16, 48, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n", 769 | " (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", 770 | " (p4_2): Conv2d(480, 64, kernel_size=(1, 1), stride=(1, 1))\n", 771 | " )\n", 772 | " (1): Inception(\n", 773 | " (p1_1): Conv2d(512, 160, kernel_size=(1, 1), stride=(1, 1))\n", 774 | " (p2_1): Conv2d(512, 112, kernel_size=(1, 1), stride=(1, 1))\n", 775 | " (p2_2): Conv2d(112, 224, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 776 | " (p3_1): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1))\n", 777 | " (p3_2): Conv2d(24, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n", 778 | " (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", 779 | " (p4_2): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))\n", 780 | " )\n", 781 | " (2): Inception(\n", 782 | " (p1_1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n", 783 | " (p2_1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))\n", 784 | " (p2_2): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 785 | " (p3_1): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1))\n", 786 | " (p3_2): Conv2d(24, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n", 787 | " (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", 788 | " (p4_2): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))\n", 789 | " )\n", 790 | " (3): Inception(\n", 791 | " (p1_1): Conv2d(512, 112, kernel_size=(1, 1), stride=(1, 1))\n", 792 | " (p2_1): Conv2d(512, 144, kernel_size=(1, 1), stride=(1, 1))\n", 793 | " (p2_2): Conv2d(144, 288, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 794 | " (p3_1): Conv2d(512, 32, kernel_size=(1, 1), stride=(1, 1))\n", 795 | " (p3_2): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n", 796 | " (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", 797 | " (p4_2): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))\n", 798 | " )\n", 799 | " (4): Inception(\n", 800 | " (p1_1): Conv2d(528, 256, kernel_size=(1, 1), stride=(1, 1))\n", 801 | " (p2_1): Conv2d(528, 160, kernel_size=(1, 1), stride=(1, 1))\n", 802 | " (p2_2): Conv2d(160, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 803 | " (p3_1): Conv2d(528, 32, kernel_size=(1, 1), stride=(1, 1))\n", 804 | " (p3_2): Conv2d(32, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n", 805 | " (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", 806 | " (p4_2): Conv2d(528, 128, kernel_size=(1, 1), stride=(1, 1))\n", 807 | " )\n", 808 | " (5): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", 809 | " )\n", 810 | " (4): Sequential(\n", 811 | " (0): Inception(\n", 812 | " (p1_1): Conv2d(832, 256, kernel_size=(1, 1), stride=(1, 1))\n", 813 | " (p2_1): Conv2d(832, 160, kernel_size=(1, 1), stride=(1, 1))\n", 814 | " (p2_2): Conv2d(160, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 815 | " (p3_1): Conv2d(832, 32, kernel_size=(1, 1), stride=(1, 1))\n", 816 | " (p3_2): Conv2d(32, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n", 817 | " (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", 818 | " (p4_2): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1))\n", 819 | " )\n", 820 | " (1): Inception(\n", 821 | " (p1_1): Conv2d(832, 384, kernel_size=(1, 1), stride=(1, 1))\n", 822 | " (p2_1): Conv2d(832, 192, kernel_size=(1, 1), stride=(1, 1))\n", 823 | " (p2_2): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", 824 | " (p3_1): Conv2d(832, 48, kernel_size=(1, 1), stride=(1, 1))\n", 825 | " (p3_2): Conv2d(48, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n", 826 | " (p4_1): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)\n", 827 | " (p4_2): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1))\n", 828 | " )\n", 829 | " (2): AdaptiveAvgPool2d(output_size=(1, 1))\n", 830 | " (3): Flatten(start_dim=1, end_dim=-1)\n", 831 | " )\n", 832 | " (5): Linear(in_features=1024, out_features=10, bias=True)\n", 833 | " )\n", 834 | ")" 835 | ] 836 | }, 837 | "execution_count": 176, 838 | "metadata": {}, 839 | "output_type": "execute_result" 840 | } 841 | ], 842 | "source": [ 843 | "model = GoogleNet()\n", 844 | "model.to(device)" 845 | ] 846 | }, 847 | { 848 | "cell_type": "code", 849 | "execution_count": 177, 850 | "metadata": {}, 851 | "outputs": [], 852 | "source": [ 853 | "learning_rate = 0.0001\n", 854 | "weight_decay = 1e-4\n", 855 | "\n", 856 | "\n", 857 | "loss_function = nn.CrossEntropyLoss()\n", 858 | "optimizer = torch.optim.Adam(model.parameters(), lr = learning_rate, weight_decay = weight_decay)" 859 | ] 860 | }, 861 | { 862 | "cell_type": "code", 863 | "execution_count": 178, 864 | "metadata": {}, 865 | "outputs": [ 866 | { 867 | "name": "stdout", 868 | "output_type": "stream", 869 | "text": [ 870 | "Initiating training.\n", 871 | "[0/1000] Training loss: 2.3035\t Validation loss: 2.3023.\n", 872 | "[5/1000] Training loss: 2.1136\t Validation loss: 2.0317.\n", 873 | "EarlyStopping counter: 1 out of 15\n", 874 | "EarlyStopping counter: 2 out of 15\n", 875 | "[10/1000] Training loss: 1.8832\t Validation loss: 1.9136.\n", 876 | "EarlyStopping counter: 1 out of 15\n", 877 | "EarlyStopping counter: 1 out of 15\n", 878 | "[15/1000] Training loss: 1.7949\t Validation loss: 1.9552.\n", 879 | "EarlyStopping counter: 2 out of 15\n", 880 | "EarlyStopping counter: 3 out of 15\n", 881 | "EarlyStopping counter: 1 out of 15\n", 882 | "[20/1000] Training loss: 1.6279\t Validation loss: 1.8498.\n", 883 | "EarlyStopping counter: 2 out of 15\n", 884 | "EarlyStopping counter: 3 out of 15\n", 885 | "EarlyStopping counter: 4 out of 15\n", 886 | "EarlyStopping counter: 1 out of 15\n", 887 | "[25/1000] Training loss: 1.5665\t Validation loss: 1.7585.\n", 888 | "EarlyStopping counter: 2 out of 15\n", 889 | "EarlyStopping counter: 1 out of 15\n", 890 | "[30/1000] Training loss: 1.5914\t Validation loss: 1.6470.\n", 891 | "EarlyStopping counter: 1 out of 15\n", 892 | "EarlyStopping counter: 2 out of 15\n", 893 | "EarlyStopping counter: 3 out of 15\n", 894 | "[35/1000] Training loss: 1.4190\t Validation loss: 1.6658.\n", 895 | "EarlyStopping counter: 4 out of 15\n", 896 | "EarlyStopping counter: 5 out of 15\n", 897 | "EarlyStopping counter: 1 out of 15\n", 898 | "[40/1000] Training loss: 1.4399\t Validation loss: 1.6641.\n", 899 | "EarlyStopping counter: 1 out of 15\n", 900 | "EarlyStopping counter: 2 out of 15\n", 901 | "EarlyStopping counter: 3 out of 15\n", 902 | "[45/1000] Training loss: 1.3014\t Validation loss: 1.6467.\n", 903 | "EarlyStopping counter: 4 out of 15\n", 904 | "EarlyStopping counter: 5 out of 15\n", 905 | "EarlyStopping counter: 6 out of 15\n", 906 | "EarlyStopping counter: 7 out of 15\n", 907 | "EarlyStopping counter: 8 out of 15\n", 908 | "[50/1000] Training loss: 1.2805\t Validation loss: 1.5588.\n", 909 | "EarlyStopping counter: 9 out of 15\n", 910 | "EarlyStopping counter: 1 out of 15\n", 911 | "[55/1000] Training loss: 1.2732\t Validation loss: 1.6181.\n", 912 | "EarlyStopping counter: 2 out of 15\n", 913 | "EarlyStopping counter: 3 out of 15\n", 914 | "EarlyStopping counter: 4 out of 15\n", 915 | "[60/1000] Training loss: 1.1238\t Validation loss: 1.3764.\n", 916 | "EarlyStopping counter: 1 out of 15\n", 917 | "EarlyStopping counter: 2 out of 15\n", 918 | "EarlyStopping counter: 3 out of 15\n", 919 | "EarlyStopping counter: 1 out of 15\n", 920 | "[65/1000] Training loss: 1.0934\t Validation loss: 1.4616.\n", 921 | "EarlyStopping counter: 2 out of 15\n", 922 | "EarlyStopping counter: 3 out of 15\n", 923 | "EarlyStopping counter: 4 out of 15\n", 924 | "EarlyStopping counter: 5 out of 15\n", 925 | "EarlyStopping counter: 6 out of 15\n", 926 | "[70/1000] Training loss: 1.2725\t Validation loss: 1.3733.\n", 927 | "EarlyStopping counter: 1 out of 15\n", 928 | "EarlyStopping counter: 2 out of 15\n", 929 | "EarlyStopping counter: 1 out of 15\n", 930 | "[75/1000] Training loss: 1.0698\t Validation loss: 1.2997.\n", 931 | "EarlyStopping counter: 2 out of 15\n", 932 | "EarlyStopping counter: 3 out of 15\n", 933 | "EarlyStopping counter: 4 out of 15\n", 934 | "EarlyStopping counter: 5 out of 15\n", 935 | "EarlyStopping counter: 6 out of 15\n", 936 | "[80/1000] Training loss: 0.9480\t Validation loss: 1.4509.\n", 937 | "EarlyStopping counter: 1 out of 15\n", 938 | "EarlyStopping counter: 1 out of 15\n", 939 | "EarlyStopping counter: 2 out of 15\n", 940 | "[85/1000] Training loss: 0.9552\t Validation loss: 1.8327.\n", 941 | "EarlyStopping counter: 3 out of 15\n", 942 | "EarlyStopping counter: 4 out of 15\n", 943 | "EarlyStopping counter: 5 out of 15\n", 944 | "EarlyStopping counter: 6 out of 15\n", 945 | "EarlyStopping counter: 7 out of 15\n", 946 | "[90/1000] Training loss: 0.8089\t Validation loss: 1.3086.\n", 947 | "EarlyStopping counter: 8 out of 15\n", 948 | "EarlyStopping counter: 9 out of 15\n", 949 | "EarlyStopping counter: 10 out of 15\n", 950 | "EarlyStopping counter: 1 out of 15\n", 951 | "[95/1000] Training loss: 0.9292\t Validation loss: 1.2831.\n", 952 | "EarlyStopping counter: 2 out of 15\n", 953 | "EarlyStopping counter: 3 out of 15\n", 954 | "EarlyStopping counter: 4 out of 15\n", 955 | "EarlyStopping counter: 5 out of 15\n", 956 | "[100/1000] Training loss: 0.7520\t Validation loss: 1.1526.\n", 957 | "EarlyStopping counter: 1 out of 15\n", 958 | "EarlyStopping counter: 2 out of 15\n", 959 | "EarlyStopping counter: 3 out of 15\n", 960 | "EarlyStopping counter: 1 out of 15\n", 961 | "[105/1000] Training loss: 0.6597\t Validation loss: 1.3155.\n", 962 | "EarlyStopping counter: 1 out of 15\n", 963 | "EarlyStopping counter: 2 out of 15\n", 964 | "EarlyStopping counter: 1 out of 15\n", 965 | "[110/1000] Training loss: 0.6098\t Validation loss: 1.2427.\n", 966 | "EarlyStopping counter: 2 out of 15\n", 967 | "EarlyStopping counter: 1 out of 15\n", 968 | "EarlyStopping counter: 2 out of 15\n", 969 | "EarlyStopping counter: 3 out of 15\n", 970 | "[115/1000] Training loss: 0.8273\t Validation loss: 1.1345.\n", 971 | "EarlyStopping counter: 4 out of 15\n", 972 | "EarlyStopping counter: 5 out of 15\n", 973 | "EarlyStopping counter: 6 out of 15\n", 974 | "EarlyStopping counter: 1 out of 15\n", 975 | "[120/1000] Training loss: 0.6367\t Validation loss: 1.3711.\n", 976 | "EarlyStopping counter: 2 out of 15\n", 977 | "EarlyStopping counter: 3 out of 15\n", 978 | "EarlyStopping counter: 4 out of 15\n", 979 | "EarlyStopping counter: 5 out of 15\n", 980 | "EarlyStopping counter: 6 out of 15\n", 981 | "[125/1000] Training loss: 0.4742\t Validation loss: 1.1495.\n", 982 | "EarlyStopping counter: 7 out of 15\n", 983 | "EarlyStopping counter: 8 out of 15\n", 984 | "EarlyStopping counter: 9 out of 15\n", 985 | "EarlyStopping counter: 10 out of 15\n", 986 | "EarlyStopping counter: 11 out of 15\n", 987 | "[130/1000] Training loss: 0.7824\t Validation loss: 1.1804.\n", 988 | "EarlyStopping counter: 12 out of 15\n", 989 | "EarlyStopping counter: 13 out of 15\n", 990 | "EarlyStopping counter: 14 out of 15\n", 991 | "EarlyStopping counter: 15 out of 15\n", 992 | "Early stop. Going back to the last checkpoint.\n", 993 | "Loading model from checkpoint...\n", 994 | "Checkpoint loaded.\n", 995 | "training finished.\n" 996 | ] 997 | }, 998 | { 999 | "data": { 1000 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAMqCAYAAACfWSInAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3ib5dXH8a+WZ2wnsWNn770nYSchYUPL3rPQlgJdtNBSoEChUEb7AoVCW/beq+xABishJCSB7L3jxBmOty1Zev+49UhesmVbsiTn97muXHqsecdRbJ3nnPscm8/n8yEiIiIiIiIiEWeP9QJERERERERE2isF3SIiIiIiIiJRoqBbREREREREJEoUdIuIiIiIiIhEiYJuERERERERkShR0C0iIiIiIiISJQq6RURERERERKJEQbeIiIiIiIhIlCjoFhEREREREYkSBd0iIu3I6aefTmpqKoWFhSHvc+GFF+Jyudi1a1fYz2uz2bjtttsCX8+ZMwebzcacOXOafOxll11G3759w36tmv71r3/x9NNP17t+06ZN2Gy2Bm9rT/r27ctll10W8vbLLrsMm83W5J/GniMcrf1+N/X3iKa+fftyyimnxOS1o2Hfvn2cd9555ObmYrPZOO200xq9v9fr5bnnnmPGjBnk5OTgcrnIzc3llFNO4X//+x9erxcI/hvbbDZefvnles9z2223YbPZ2LNnT+A66/03YsQIqqur6z3GZrNx7bXXtu4vLCLSDjhjvQAREYmcK664grfffpsXX3yRq6++ut7tBw4c4K233uKUU04hLy+vxa8zfvx45s2bx/Dhw1uz3Cb961//Iicnp17A1q1bN+bNm8eAAQOi+vrx7pZbbuGqq64KfP3dd99xzTXXcNdddzFt2rTA9V26dGnV67T2+/3WW2+RmZnZqjWIcccdd/DWW2/x5JNPMmDAADp37hzyvhUVFZx22ml88sknnHfeeTz66KN07dqVgoICPvroI84++2xeeeUVfvzjH9d63E033cSZZ56Jy+UKa00rVqzg6aef5oorrmjV301EpL1S0C0i0o6ceOKJdO/enSeffLLBoPull16ivLy81R+OMzMzOfTQQ1v1HK2RnJwc09ePFwMGDKgVCFdUVAAwaNCgRr8/5eXlpKSkYLPZwnqd1n6/x40b1+LHSm3Lli1jwIABXHjhhU3e97rrruPjjz/mmWee4ZJLLql12xlnnMH1119PeXl5retPPPFEPvzwQx577DF++ctfNvka6enpjB8/nltvvZULLriA1NTU5v2FREQOAiovFxFpRxwOB5deeimLFi3ihx9+qHf7U089Rbdu3TjxxBMpKCjg6quvZvjw4XTo0IHc3FyOOeYYvvjiiyZfJ1R5+dNPP82QIUNITk5m2LBhPPvssw0+/vbbb2fy5Ml07tyZzMxMxo8fzxNPPIHP5wvcp2/fvixfvpy5c+cGyl6tMvVQ5c5ffvkl06dPJyMjg7S0NA4//HDef//9emu02WzMnj2bX/ziF+Tk5JCdnc0ZZ5zBjh07mvy7L1y4kPPOO4++ffuSmppK3759Of/889m8eXOLX8ftdnPDDTfQtWtX0tLSOPLII1mwYEGTawmHtY5PPvmEn/zkJ3Tp0oW0tDQqKytZt24dl19+OYMGDSItLY0ePXpw6qmn1nvvNPT9tsqNly9fzvnnn09WVhZ5eXn85Cc/4cCBA7UeX7e83Hr/vPTSS9x00010796dzMxMZsyYwerVq2s91ufzcdddd9GnTx9SUlKYOHEiM2fOZOrUqUydOjUi36OKigpuvPFG+vXrR1JSEj169OCaa66pt01j1qxZTJ06lezsbFJTU+nduzdnnnkmZWVlgfs8+uijjBkzhg4dOpCRkcHQoUP505/+1OQa9u3bx9VXX02PHj1ISkqif//+3HTTTVRWVgLBf4NPP/2UlStXBv5PhNrikZ+fz+OPP87xxx9fL+C2DBo0iNGjR9e67phjjuH444/njjvuoLi4uMl1A9xzzz1s376dBx98MKz7i4gcbBR0i4i0Mz/5yU+w2Ww8+eSTta5fsWIFCxYs4NJLL8XhcLBv3z4Abr31Vt5//32eeuop+vfvz9SpU8Paq13X008/zeWXX86wYcN44403uPnmm7njjjuYNWtWvftu2rSJn//857z66qu8+eabnHHGGfzyl7/kjjvuCNznrbfeon///owbN4558+Yxb9483nrrrZCvP3fuXI455hgOHDjAE088wUsvvURGRgannnoqr7zySr37X3nllbhcLl588UXuvfde5syZw0UXXdTk33PTpk0MGTKEBx54gI8//ph77rmHnTt3MmnSpFr7XZvzOj/96U+5//77ueSSS3jnnXc488wzOeOMM9i/f3+T6wnXT37yE1wuF8899xyvv/46LpeLHTt2kJ2dzd/+9jc++ugjHnnkEZxOJ5MnT64X/IZy5plnMnjwYN544w3++Mc/8uKLL/Lb3/42rMf+6U9/YvPmzTz++OP85z//Ye3atZx66qm19gffdNNN3HTTTZxwwgm88847XHXVVVx55ZWsWbOmRd+Hunw+H6eddhr3338/F198Me+//z7XXXcdzzzzDMccc0ytoPfkk08mKSmJJ598ko8++oi//e1vpKenU1VVBcDLL7/M1VdfzZQpU3jrrbd4++23+e1vf0tpaWmja6ioqGDatGk8++yzXHfddbz//vtcdNFF3HvvvZxxxhlAsMR/3Lhx9O/fP/B/Yvz48Q0+5+zZs3G73U3u+W7IPffcw549e7jvvvvCuv9hhx3G6aefzj333BP4uSIiIjX4RESk3ZkyZYovJyfHV1VVFbjud7/7nQ/wrVmzpsHHeDwen9vt9k2fPt13+umn17oN8N16662Br2fPnu0DfLNnz/b5fD5fdXW1r3v37r7x48f7vF5v4H6bNm3yuVwuX58+fUKutbq62ud2u31/+ctffNnZ2bUeP2LECN+UKVPqPWbjxo0+wPfUU08Frjv00EN9ubm5vuLi4lp/p5EjR/p69uwZeN6nnnrKB/iuvvrqWs957733+gDfzp07Q661IR6Px1dSUuJLT0/3Pfjgg4Hrw32dlStX+gDfb3/721r3e+GFF3yA79JLLw17Lda/y2uvvVZvHZdccklYf5eqqirfoEGDaq2noe/3rbfe6gN89957b63nuPrqq30pKSm1/h379OlT6+9hrfOkk06q9dhXX33VB/jmzZvn8/l8vn379vmSk5N95557bq37zZs3zwc0+N6oq0+fPr6TTz455O0fffRRg3+PV155xQf4/vOf//h8Pp/v9ddf9wG+JUuWhHyua6+91texY8cm11TXY4895gN8r776aq3r77nnHh/g++STTwLXTZkyxTdixIgmn/Nvf/ubD/B99NFHYa3B+je+7777fD6fz3fhhRf60tPTA+9T69+7oKAg8JhLL73Ul56e7vP5fL5Vq1b5HA6H73e/+13gdsB3zTXXhPX6IiLtmTLdIiLt0BVXXMGePXt49913AfB4PDz//PMcddRRDBo0KHC/xx57jPHjx5OSkoLT6cTlcvHZZ5+xcuXKZr3e6tWr2bFjBxdccEGtfcJ9+vTh8MMPr3f/WbNmMWPGDLKysnA4HLhcLv785z+zd+9edu/e3ey/b2lpKd988w1nnXUWHTp0CFzvcDi4+OKL2bZtW73M7Y9+9KNaX1tltnXLxOsqKSnhD3/4AwMHDsTpdOJ0OunQoQOlpaUNft+aep3Zs2cD1Nuje8455+B0Rq71yplnnlnvOo/Hw1133cXw4cNJSkrC6XSSlJTE2rVrw34PNPT3q6ioCOvfsanvzfz586msrOScc86pdb9DDz20xR3x67IqMeo26zv77LNJT0/ns88+A2Ds2LEkJSXxs5/9jGeeeYYNGzbUe65DDjmEwsJCzj//fN55550GKx9CrSE9PZ2zzjqr1vXWmqw1tKU777wTt9vN7bffHtb9hwwZwhVXXMHDDz/Mli1borw6EZHEoqBbRKQdOuuss8jKyuKpp54C4IMPPmDXrl21Gqj94x//4Be/+AWTJ0/mjTfeYP78+Xz77beccMIJ9ZorNWXv3r0AdO3atd5tda9bsGABxx13HAD//e9/+eqrr/j222+56aabAJr92gD79+/H5/PRrVu3erd179691hot2dnZtb5OTk4O6/UvuOACHn74Ya688ko+/vhjFixYwLfffkuXLl0afGxTrxPqe+d0Ous9tjUa+t5cd9113HLLLZx22mn873//45tvvuHbb79lzJgxYf87tPT7GM5jre9NQ532W9N9v6a9e/fidDrrdXi32Wx07do1sIYBAwbw6aefkpubyzXXXBNoYldzH/PFF1/Mk08+yebNmznzzDPJzc1l8uTJzJw5s8k1dO3atV5ju9zcXJxOZ733bjh69+4NwMaNG5v9WDD78K+++moef/xx1q5dG9ZjbrvtNhwOB7fcckuLXlNEpL1S0C0i0g6lpqZy/vnn89FHH7Fz506efPJJMjIyOPvsswP3ef7555k6dSqPPvooJ598MpMnT2bixIlhN0+qyQqe8vPz691W97qXX34Zl8vFe++9xznnnMPhhx/OxIkTm/2aNXXq1Am73c7OnTvr3WY1LcvJyWnVa4AZufbee+9xww038Mc//pHp06czadIkRo0a1eK9rKG+dx6Pp0XBVigNdSp//vnnueSSS7jrrrs4/vjjOeSQQ5g4cWLYGdpos743Dc2Ub+i91tLX8Hg8FBQU1Lre5/ORn59f631z1FFH8b///Y8DBw4wf/58DjvsMH7zm9/Ummt9+eWX8/XXX3PgwAHef/99fD4fp5xySqMVFNnZ2ezatatWI0GA3bt34/F4WvTenTZtGi6Xi7fffrvZj7XcfPPNpKWlhdUIDsyJnd/85jc8//zzfP/99y1+XRGR9kZBt4hIO3XFFVdQXV3NfffdxwcffMB5551HWlpa4HabzRbILFq+//575s2b1+zXGjJkCN26deOll16qFThs3ryZr7/+utZ9bTYbTqcTh8MRuK68vJznnnuu3vMmJyeHlTFNT09n8uTJvPnmm7Xu7/V6ef755+nZsyeDBw9u9t+rLpvNhs/nq/d9e/zxx2s1/2oOqwP3Cy+8UOv6V199FY/H06LnDFdD74H333+f7du3R/V1wzV58mSSk5PrNcKbP39+k9sAwjV9+nTAnICo6Y033qC0tDRwe00Oh4PJkyfzyCOPAGY+el3p6emceOKJ3HTTTVRVVbF8+fJG11BSUlIvQLa6/ze0hqZ07do1UI0RaorA+vXrGw2Os7Oz+cMf/sDrr78edjf9P/zhD3Tu3Jk//vGPzV6ziEh7pTndIiLt1MSJExk9ejQPPPAAPp+v3mzuU045hTvuuINbb72VKVOmsHr1av7yl7/Qr1+/Zgd7drudO+64gyuvvJLTTz+dn/70pxQWFnLbbbfVK5s++eST+cc//sEFF1zAz372M/bu3cv9999fL/gDGDVqFC+//DKvvPIK/fv3JyUlhVGjRjW4hrvvvptjjz2WadOm8fvf/56kpCT+9a9/sWzZMl566aWwZ1I3JjMzk6OPPpr77ruPnJwc+vbty9y5c3niiSfo2LFji55z2LBhXHTRRTzwwAO4XC5mzJjBsmXLuP/++8nMzGz1mhtzyimn8PTTTzN06FBGjx7NokWLuO++++jZs2dUXzdcnTt35rrrruPuu++mU6dOnH766Wzbto3bb7+dbt26YbeHlzvIz8/n9ddfr3d93759OfbYYzn++OP5wx/+QFFREUcccQTff/89t956K+PGjePiiy8GTP+DWbNmcfLJJ9O7d28qKioCEwJmzJgBmC70qampHHHEEXTr1o38/HzuvvtusrKymDRpUsj1XXLJJTzyyCNceumlbNq0iVGjRvHll19y1113cdJJJwWev7n+8Y9/sGHDBi677DI+/vhjTj/9dPLy8tizZw8zZ87kqaee4uWXX643Nqym3/zmNzzyyCN8+OGHYb1mZmYmN910U9gd7EVEDgYKukVE2rErrriCX//61wwfPpzJkyfXuu2mm26irKyMJ554gnvvvZfhw4fz2GOP8dZbb7VoZJgV1N9zzz2cccYZ9O3blz/96U/MnTu31vMdc8wxPPnkk9xzzz2ceuqp9OjRg5/+9Kfk5ubWOzFw++23s3PnTn76059SXFxMnz592LRpU4OvP2XKFGbNmsWtt97KZZddhtfrZcyYMbz77ruccsopzf77hPLiiy/y61//mhtuuAGPx8MRRxzBzJkzOfnkk1v8nE888QR5eXk8/fTTPPTQQ4wdO5Y33niD8847L2LrbsiDDz6Iy+Xi7rvvpqSkhPHjx/Pmm29y8803R/V1m+Ovf/0r6enpPPbYYzz11FMMHTqURx99lJtuuinsEx2LFi2qtbXCcumll/L000/z9ttvc9ttt/HUU0/x17/+lZycHC6++GLuuuuuwMmgsWPH8sknn3DrrbeSn59Phw4dGDlyJO+++26gR8FRRx3F008/zauvvsr+/fvJycnhyCOP5Nlnn623Z7ymlJQUZs+ezU033cR9991HQUEBPXr04Pe//z233npr879pNZ73/fff54UXXuCZZ57h5z//OUVFRXTq1ImJEyfy5JNPcuqppzb6HGlpadx222387Gc/C/t1r776ah566KEW7ycXEWlvbL66G4hERERE4tjGjRsZOnQot956a9j7jUVERGJFQbeIiIjEraVLl/LSSy9x+OGHk5mZyerVq7n33nspKipi2bJlEetiLiIiEi0qLxcREZG4lZ6ezsKFC3niiScoLCwkKyuLqVOn8te//lUBt4iIJARlukVERERERESiRCPDRERERERERKJEQbeIiIiIiIhIlCjoFhEREREREYmSg66RmtfrZceOHWRkZGCz2WK9HBEREREREUlAPp+P4uJiunfvjt0eOp990AXdO3bsoFevXrFehoiIiIiIiLQDW7dupWfPniFvP+iC7oyMDAA2btxI586da93m/f41Kov24C7bT3VpIb6KQig/AJUHSCnbRVpVAV5sPOY9g0erTsBXozr/+BF5/P2csW34N5FIc7vdfPLJJxx33HG4XK5YL0fijN4fEoreGxKK3hsSit4b0iC3m+onnmDlypUMuftuXGlpsV6RNKGoqIhevXoFYsxQDrqg2yopz8jIIDMzs/aNR14R+oHuCvjg97D4Of7Im1w7vJQ5w/7C/B1unp+/hS82l+JKSSc1yRHF1Us0ud1u0tLSyMzM1C9AqUfvDwlF7w0JRe8NCUXvDWlQaSn84Q8cDrj/7/9w1Y1VJG41tW1ZjdTC5UqBHz8Mpz4EjmQ6bPyYU+afzx2H2ujRMZUKt5cv1+2J9SpFREREREQkjijobq4Jl8JPPoKsXrBvA7YnjuW3XZcCMHNFfowXJyIiIiIiIvFEQXdL9BgPP5sL/aeBu4yzNt3GRY6ZfLZyN9VeX6xXJyIiIiIiInFCQXdLpWfDRW/AIT8H4FzXF+wtreK7LftjvDARERERERGJFwq6W8PugEmm+dog+3bAx8wVu2K7JhEREREREYkbCrpbq3N/sLtI8ZbTgz3MXLELn08l5iIiIiIiIqKgu/UcLsgZBMBw5w427illfUFJjBclIiIiIiIJJTkZz9tvM//mmyE5OdarkQhS0B0JXYYCMD3H7Of+RCXmIiIiIiLSHE4nvpNOYtfEieB0xno1EkEKuiMhdxgAk9JNsP3JcgXdIiIiIiIioqA7MroMAaC3ZzMAS7YWsruoIpYrEhERERGRROJ2Y3v2WXp99hm43bFejUSQgu5I6GIy3a59axnbMxOAT1fujuWKREREREQkkVRV4bzySsb/859QVRXr1UgEKeiOhM79wZEE7lLOGGA6l89ckR/jRYmIiIiIiEisKeiOBIcTsk0H8+nZ+wD4av1eSio9sVyViIiIiIiIxJiC7kjJNR3Mu1dtpk92GlUeL5+vKYjxokRERERERCSWFHRHin9smK1gFccOywNgpkaHiYiIiIiIHNQUdEeKP+imYCXHjegKwKxVu3FXe2O4KBEREREREYklBd2R4p/VTcFqJvTOonN6EgfK3Xy7aV9s1yUiIiIiIiIxo6A7Ujr183cwL8NRtJVjhuYCKjEXEREREZEwJCfjefFFvr3+ekhOjvVqJIIUdEeKwwk5g83x7lUcO9zs6/5k+S58Pl8MFyYiIiIiInHP6cR31lnsOOIIcDpjvRqJIAXdkdRliLksWMVRg3JIdtrZXljOyp3FsV2XiIiIiIiIxISC7kjqYu3rXkVakpOjBuUAKjEXEREREZEmeDzYXn+d7l99BR5PrFcjEaSgO5L8s7rZvRKAGf7RYbNWKegWEREREZFGVFbivOACJt13H1RWxno1EkEKuiPJynTvWQNeb6CZ2tJtB9hdVBHDhYmIiIiIiEgsKOiOpE59wZEM7jIo3ExuZgqje2YBMHv17tiuTURERERERNqcgu5IcjghZ5A5LlgFwPShpsT805UKukVERERERA42CrojrYt/X7cVdA8zJeZfrt1Dhbs6VqsSERERERGRGFDQHWmBZmom6B7RPZOumSmUu6uZt2FvDBcmIiIiIiIibU1Bd6QFxoaZDuY2m41j/NnuWSoxFxEREREROago6I60XCvoNh3MAab7u5h/tnIXPp8vVisTEREREZF4lZSE5/HH+e6Xv4SkpFivRiJIQXekWR3MPeVQuAmAIwbmkOKys+NABSt3Fsd0eSIiIiIiEodcLnyXXMLW6dPB5Yr1aiSCFHRHmt0BOYPNccFqAFJcDo4YkAPArFW7YrUyERERERERaWMKuqMh0ExtZeCq6cM0OkxERERERELweLB98AF5CxeCxxPr1UgEKeiOhjpjwwCO8e/rXrqtkILiylisSkRERERE4lVlJc7TTuPQO++ESsUL7YmC7miwmqnVyHR3zUphZI9MfD6YvVrZbhERERERkYOBgu5osDLde9aAtzpw9fShpsT8s5Xa1y0iIiIiInIwUNAdDZ36gjMFPBWwf1Pg6un+ed1frN1Dpae64ceKiIiIiIhIu6GgOxrsDsgZZI79HcwBRnbPIjcjmbKqauZv2BejxYmIiIiIiEhbUdAdLV38+7oLgvu67XZbINs9SyXmIiIiIiIi7Z6C7mgJjA1bVevqY4YGR4f5fL62XpWIiIiIiIi0IWesF9BuBcaGrax19ZEDc0h22tleWM7qXcUM7ZoZg8WJiIiIiEhcSUqi+sEHWb58OcOSkmK9GokgZbqjJdDBfG2tDuapSQ4OH5ANwGcrNTpMREREREQAlwvvL37BxpNOApcr1quRCFLQHS0hOpgDTB+m0WEiIiIiIiIHAwXd0WJ3QM5gc7z8TSgLdiu3mqkt3lpIQXFlLFYnIiIiIiLxpLoa29y5ZP/wA1RrvHB7oqA7mrqOMpez7oR7+8G/DoP3f0e3rR8wrXs1Ph88O29TTJcoIiIiIiJxoKIC57HHcuQtt0BFRaxXIxGkRmrRNPWP4EyGTV/BntWwe4X58+3jPAV8n9SPn351G1ce1Z+sVO3bEBERERERaW8UdEdTx95wyv+Z49I9sGUebP4aNn+FL/8HRts3MqLqB57+agS/njEotmsVERERERGRiFN5eVtJz4Fhp8IJd8PPP8c28iwAhtq28ORXGymucMd4gSIiIiIiIhJpCrpjJW8EABNTd3Cg3M2z8zbHeEEiIiIiIiISaQq6YyVvJAATU3YA8MSXGymr8sRyRSIiIiIiIhJhCrpjxZ/pzijdzKDOTvaVVvHC/C0xXpSIiIiIiIhEkoLuWMnoCqmdsfmquX68DYB/f76BCrdm8omIiIiIHHRcLqrvvpvll14KLk02ak8UdMeKzRbIdh/TuYAeHVPZU1LJSwuU7RYREREROegkJeH93e9Yd/rpkJQU69VIBCnojiX/vm5nwQqunjYAgMfmrle2W0REREREpJ1Q0B1L/kw3u5Zx1oSedMtKYVdRJa8t2hbbdYmIiIiISNuqrsa2cCEd166FaiXh2hMF3bEUCLqXk+x0cNUUf7Z7znqqPN4YLkxERERERNpURQXOww9nyvXXQ0VFrFcjEaSgO5a6DAVsUFoAJbs5d1IvumQks72wnLcWK9stIiIiIiKS6BR0x1JSGmSb7Da7lpHicvDzo/sD8Oic9fh8vhguTkRERERERFpLQXes1SgxBzj/kN64HDY27S1jy76yGC5MREREREREWktBd6z5O5hbQXd6spNRPbIAWLBxX6xWJSIiIiIiIhGgoDvWanQwt0zq1xmAbzcp6BYREREREUlkCrpjzQq6C1ZDtRuAQ/paQff+WK1KREREREREIkBBd6xl9YakDKiugr3rAJjYpzM2G2zcU0pBcWWMFygiIiIiIlHnclF9882sOvdccLlivRqJIAXdsWa3Q95wc+zf152V5mJIXgYAC1ViLiIiIiLS/iUl4f3zn1l9/vmQlBTr1UgEKeiOBw3t6/aXmC9Q0C0iIiIiIpKwFHTHgzpjw0DN1EREREREDipeLyxfTsaWLeZY2g1nrBcg1BsbBsFmait2FFFc4SYjRfs6RERERETarfJyXOPGcQzgvvhiSE6O9YokQpTpjge5w8xl0XYoM5ntrlkp9OqcitcH320pjN3aREREREREpMUUdMeDlCzo2Nsc714RuNra1/3tRpWYi4iIiIiIJCIF3fGikRJzNVMTERERERFJTAq640VDHcz9zdSWbC2k0lMdi1WJiIiIiIhIKyjojhcNdDDvn5NOTockqjxefth2IEYLExERERERkZZS0B0vcv1B9+6V4DVZbZvNxsQ+KjEXERERERFJVAq640Xn/uBMAXcZ7N8UuDowr1vN1ERERERE2i+Xi+rrrmPtaaeBS+OC2xMF3fHC4YQuQ81xjX3dVjO1hZv3U+31xWJlIiIiIiISbUlJeP/2N1ZcdhkkJcV6NRJBCrrjSQMdzId1yyA9yUFxhYfV+cUxWpiIiIiIiIi0hILueNJAMzWnw874Pp0A+Fb7ukVERERE2ievFzZtInXXLnMs7YaC7njSwNgw0LxuEREREZF2r7wc1+DBHPfzn0N5eaxXIxGkoDueWEH3/k1QWRK42mqmtnDTPnw+7esWERERERFJFAq640l6DnToao53rwxcPbZXR1wOG7uKKtm6T2e9REREREREEoWC7njTQIl5isvB6J4dAZWYi4iIiIiIJBIF3fGmgWZqAJP6al63iIiIiIhIolHQHW8aGBsGcEg/dTAXERERERFJNAq6442V6c7/AdzB/dsTenfGZoMNe0opKK6M0eJERERERESkORR0x5vcYZDVC6qK4YfXAldnpbkYkpcBmC7mIiIiIiLSjjidVF91FRtPPBGczlivRiJIQXe8sTvgkJ+a4/mPQY0RYda+7q/W74nFykREREREJFqSk/E+9BDf//znkJwc69VIBCnojkfjLwFXGuxeDpu+CFx91KAcAJ6fv4UXvtkcq9WJiIiIiIhImBR0x6PUTjDmfHM8/7HA1ccOz+Oyw/sCcNNby3jiy40xWJyIiIiIiESczwcFBSQdOFCr2lUSn4LueDX5KnO5+gPYtwEAm83GracO56opAwC4470VPDJ7XaxWKCIiIiIikVJWhqtHD0689FIoK4v1aiSCFHTHqy6DYeAMwAcL/hu42maz8YcThvDbGYMBuO/j1dz/8Wp8OhsmIiIiIiISd2IadN99991MmjSJjIwMcnNzOe2001i9enWTj5s7dy4TJkwgJSWF/v3789hjjzX5mIQ0+Rfm8rvnoKIocLXNZuPXMwZx44lDAXh49jrufH+lAm8REREREZE4E9Oge+7cuVxzzTXMnz+fmTNn4vF4OO644ygtLQ35mI0bN3LSSSdx1FFHsXjxYv70pz/xq1/9ijfeeKMNV95GBhwDOYPN+LAlL9a7+edTBnD7j8xc7ye+3MjNby/D61XgLSIiIiIiEi9iOgDuo48+qvX1U089RW5uLosWLeLoo49u8DGPPfYYvXv35oEHHgBg2LBhLFy4kPvvv58zzzwz2ktuW3Y7TP45vP87WPBvOORn5roaLj28L6kuB39483te+GYLQ7pmcMlhfWOzXhEREREREaklrqauHzhwAIDOnTuHvM+8efM47rjjal13/PHH88QTT+B2u3G5XLVuq6yspLKyMvB1UZEp03a73bjd7kgtPXqGn4Xzs79g27cBz6oP8A06vt5dTh/blYLicu77ZC0vzN/MeRO6Y7PZYrDYxGa9HxLifSFtTu8PCUXvDQlF7w0JRe8NaZDbjStw6Aa9P+JeuP+H4ybo9vl8XHfddRx55JGMHDky5P3y8/PJy8urdV1eXh4ej4c9e/bQrVu3Wrfdfffd3H777fWeZ/bs2aSlpUVm8VE2PPMIBlV8wP4P/srXg6obvE9nD7hsDlbvKuHfr31I7w5RXJDPh93nxmtPiuKLxM7MmTNjvQSJY3p/SCh6b0goem9IKHpvSE2OigpO8R/PmjWL6pSUmK5HmlYWZpf5uAm6r732Wr7//nu+/PLLJu9bN4trNRBrKLt74403ct111wW+LioqolevXkybNo3s7OxWrrqNHBiF75GP6FKygpMm9oPcYQ3e7auK73nvh3x2pvblqpOGR2059u+exvHh7/Gc/Ry+wSdG7XXamtvtZubMmRx77LH1KiZE9P6QUPTekFD03pBQ9N6QBlVW4rnwQnbs2MExxx2Hq0M0s2gSCVYVdVPiIuj+5S9/ybvvvsvnn39Oz549G71v165dyc/Pr3Xd7t27cTqdDQbRycnJJCcn17ve5XIlzg+5nP4w7FRY8Q6uRY/Djx5q8G7nHdKH937I573v8/nzqSNJcTmis56lpqmbc80HMOJH0XmNGEqo94a0Ob0/JBS9NyQUvTckFL03pBaXC/dTT7H4gw84qUMHvTcSQLj/RjHtXu7z+bj22mt58803mTVrFv369WvyMYcddli9UpxPPvmEiRMntu83pjU+7PtXoHRvg3c5fEA2PTqmUlTh4ePlNU5MfPF3eO4MKNvX+nWU74cdi81x/g+tfz4REREREZF2LKZB9zXXXMPzzz/Piy++SEZGBvn5+eTn51NeXh64z4033sgll1wS+Pqqq65i8+bNXHfddaxcuZInn3ySJ554gt///vex+Cu0nd6HQrcx4KmARU81eBe73cZZE0ylwGsLt5kr966HWXfC+s9g9l9bv46NnwP+sWQFq8BT2ejdRUREREQkDD4flJbiqKgwx9JuxDTofvTRRzlw4ABTp06lW7dugT+vvPJK4D47d+5ky5Ytga/79evHBx98wJw5cxg7dix33HEHDz30UPsbF1aXzQaHXm2O5/8LKhreP2AF3V+t38O2/WUmy+3zmhsXPgm7lrduHetnB4+9HhN4i4iIiIhI65SV4erUiVPOOw/CbNAliSGme7p9YZzBefrpp+tdN2XKFL777rsorCjOjTzLBNF71sC8h2Han+rdpVfnNA4fkM3X6/cy86sFXL70ZXNDtzGwcyl89Ee45F0TxLfEBn/Q7UwFT7kpMe82poV/IRERERERkfYtppluaSaHE465xRx//TCU7G7wbudM7AVA58WPgK8aBhwD5zwHjmRTHr7q/Za9/r6NsH8T2J0w+hxznfZ1i4iIiIiIhKSgO9EMOxW6jwd3KXx+f4N3OWFkVwalFHKi5zNzxdE3QKc+cPgvzdef3NSyvdhWlrvnJOhzuDne+X3zn0dEREREROQgoaA70dhsMOM2c7zwSZN5riPF5eCO7E9JslWzNm0s9DnM3HDkbyGjm3nM/H81/7Wt/dz9p0HXUeY4/wfwepv/XCIiIiIiIgcBBd2JqP8UUzLudcPsu+rfXrSTQwpNCfkdxadSVOE21yd3gBm3m+PP74fi/PqPDcVb7e9cDgyYBjmDwZEEVcVQuLkVfxkREREREZH2S0F3opr+Z3P5/auQv6z2bV8/hL26kmWOYXzuHsr/lu4I3jbqbOgxEapK4LO/hP96O5dARSEkZ5nydocLcoeZ27SvW0REREREpEEKuhNV93Ew4nTAB7PuCF5fUgALzRzvraOuBWy8as3sBrDb4cR7zPGSF2D7ovBezyot73eUaegGtUvMo8XngyqNTBARERGRds7hwHvGGWw//HBwOGK9GokgBd2J7JhbwOaANR/B5nnmunn/NKO8uo9n0vSzcNptLN1ayJpdxcHH9ZwIY843xx/+0QS2Tdkwx1z2nxq8rqt/VFg0g+4lL8Bd3eCH16P3GiIiIiIisZaSQvXLL7PwhhsgJSXWq5EIUtCdyLIHwPhLzPGnt0HpXljwuPl6yh/IyUjhmKG5ALy2cGvtx06/FVzpsG1B0wFtVSlsmW+O+08LXh/IdEexg/nqD83lN49F7zVERERERESiREF3opvyB3Cmwtb58MqFZpRY19Ew+HggOLP7ze+2c6DMHXxcZjc46jpzPPPPUFkS+jU2f22atmX1MoG+JW+EuSzabgL+aNi90lxu+xYKt0TnNURERERERKJEQXeiy+wGh15ljrf4S8yPvt6MFgOmDulCbkYye0urOOreWfx77noq3NXmfoddC536QvEOmHtP6NeoWVruf14AUjKhUz9zvCsKJebuCti/Mfj18rci/xoiIiIiIvGgtBRXUhI/Pu00KC2N9WokghR0twdH/BpSssxx7nAYekrgJqfDzr8vnsCQvAyKKjzc/eEqjrl/Dq8v2ka1IxlOvNfccf6/glnluqwmagOm1b8tms3U9q4FX40Z4MvejPxriIiIiIiIRJGC7vYgtRMcfxekdITj7jQdymsY17sTH/z6KO4/ewzds1LYcaCC37+2lJMf+oLZ3nH4hpwEXg+8/7v6TdWKd8Hu5YAN+k2t/9pdR5vLaATdBavNZc5gsNnN2LK96yP/OiIiIiIiIlGioLu9GHcR/HEzDJze4M0Ou42zJvRk1u+ncuOJQ8lMcbIqv5jLn/6WW92X4HOmwuavzNzvmqzS8m6jIT27/hN3i2bQvcpc9jkc+h1tjlViLiIiIiIiCURB90EmxeXg51MG8PkN0/j50f1x2m08u8LLjjHXmjt8cjOUFwYfsMFfWt6/gdJyCJaXF6wGd3lkF2uVu3cZCiPOMMfL347sa4iIiIiIiESRgu6DVMe0JG48aRg/HtsDgAdKj4fsQVC6G2bfZe7k8zW+nxsgoxukZYOvOvSe8Jayysu7DIVhp4LdaRq27Vkb2dcRERERERGJEgXdB7mLDu0NwDvL9lA8/W/mym//CzuWmKC3JB+cKdDr0IafwGaLTjM1TyXs22COuwyFtM7BbLsaqomIiIiISIJQ0H2QG9urIyO6Z1Ll8fLSnn6mjNvnNU3V1n9m7tT7MHClhH6SaATde9eZ7HlyFmR0NdeNON1cLlfQLSIiIiLtjMOB98QTyZ8wARyOWK9GIkhB90HOZrNx0aF9AHjhmy14j70TkjrA9oXB2d2hSsst0ehgbjVRyx0anA0+9GRwJJnbdq2I3GuJiIiIiMRaSgrV77zDN7fcAimNJLwk4SjoFn48tjsZyU427y3jy91JMO1P5oaKA+YyVBM1ixV071oGXm/j9w3Xbn/Q3WVI8LrUjjDA351d2W4REREREUkACrqFtCQnZ4w3DdWen78ZDvk55I7w35gDeSMbf4LsgWbfd1UJ7N8YmUVZme4uQ2tfP9LfxXzZm/VniouIiIiIiMQZBd0CwIX+EvNPV+5iZ4kbTn0QUjrCxMvB3sTbxOGE3OHmOP/7yCwoVNA95EQT4O9bH7nXEhERERGJtdJSnB07cvK550JpaaxXIxGkoFsAGJyXwSH9OuP1wUsLtkKvSfCHTXDMzeE9QSSbqXmqYO96c1w36E7OgEHHmmN1MRcRERGRdsRWVoazsjLWy5AIU9AtAVZDtZcXbMFd7Q02MAtHJIPufev9ncszIbN7/dtH+EvMl7+lEnMREREREYlrCrol4IQRXcnpkMTu4ko+XbGreQ+OZAfz3SvNZZchDQf+g48HVxoUboYd37X+9URERERERKJEQbcEJDntnDOxFwDPf7O5eQ/OGwHYoHgnlBS0biEFq81lzc7lNSWlw+ATzLFKzEVEREREJI4p6JZazj+kNzYbfLVuLxsKShq8T3GFm0Wb9+P11ijtTu4A2QPMcWsbnBVYme5hoe8z4nRzufztyI0pExERERERiTAF3VJLr85pTBuSC8AL32ypddu63SX8+Z1lHHrXZ5z56Nc89fWm2g+O1L7uQKZ7aOj7DDoWkjpA0TbY9m3rXk9ERERERCRKFHRLPRcd2huA1xdto6zKw6crdnHxE98w4x9zeXbeZkqrqgF4beHW2g+MRNBd7Ya968xxbiNBtysVhpxkjle83fLXExERERGJB3Y73qOPZs+IEU2P7JWEon9NqWfK4Fx6dEzlQLmbw+6exZXPLuSLtXuw2eDY4Xn85+IJuBw2VuUXs2ZXcfCBkWimtnc9eD0mi53Zo/H7jjjNXK54RyXmIiIiIpLYUlOp/vRTvvrrXyE1NdarkQhS0C31OOw2LvRnuw+Uu8lKdfGzo/vz+fXT+O8lEzluRFeOHtQFgPeW7gg+0Mp0710LVWUte/GCVeYyVOfymgZMh6QMKNoO2xe27PVERERERESiyBnrBUh8+skR/Sit9NCzUxqnje1BapKj1u2njunOZ6t28973O/ntsYOx2WyQ0RXSc6F0N6z7FIb/qPkvHAi6G2miZnGlwJAT4IfXTEO1Xoc0//VERERERESiSJluaVCKy8H1xw/l/EN61wu4AWYMzyPZaWfDnlKW7ygK3jD6HHP53m+hOL/5L1wz0x2O4aeZS5WYi4iIiEgiKy3F2b07J1xyCZSWxno1EkEKuqVFOiQ7OWao6XL+3vc7gzcccwvkjYSyPfDWz5sfCO/2B925YWS6AQZOD3YxV4m5iIiIiCQw2549JBcVNX1HSSgKuqXFTh3THYD/Ld2Bz+ef2e1KgbOeBFcabJgDXz8Y/hPW7FwebqbblQqDTzDHy98O/7VERERERETagIJuabFpQ3JJS3KwvbCcxVsLgzd0GQIn3mOOZ90J28LMQO/bCF43uNIhs2f4C1EXcxERERERiVMKuqXFUpMcHDs8D4D3lu6sfeO4i2HE6Wb81+s/gYoDTT9hwUpz2WVI82YTDpxRo8R8UfiPExERERERiTIF3dIqp4w2Jebvfb+Daq8veIPNBqc+CB17Q+Fm01jN5wvxLH4Fq81ll6HNW0TNEvMVbzfvsSIiIiIiIlGkoFta5ejBOWSkONldXMm3m/bVvjElC858EmwOWPYGLH6+8Sfb7c905zYz6IbaJeZNBfciIiIiIiJtREG3tEqy08EJI7oCJttdT69JcMxN5vjDG6BgTegna2mmG4Il5ge2qsRcRERERBKP3Y53wgT2DxzYvK2WEvf0rymtdoq/i/kHP+TjqW6gkdkRv4V+U8BdBq9dBpXF9e9T7YG9a81xuJ3La3KlwuDjzfHyt5r/+KbMfwyePAEKt0T+uUVEREREUlOpnjePz++/H1JTY70aiSAF3dJqhw/IpnN6EvtKq/h6/d76d7Db4Yz/QHoX2L0cXr3EjAeraf9GqK4yo8ayerdsIcNPM5fRKDH/6gHYMg/euUYd0kVEREREJGwKuqXVXA47J45spMQcIKMrXPCKCarXz4J3f1k7MC5YZS5zBre8nGbQsWbcWKRLzIt3QbG/O/vGz2HhE5F7bhERERERadcUdEtEWF3MP1qWT6WnuuE79ZgAZz9jGqstfcnM8Lbs9gfdLdnPbYlWifnOJebS5jCXM/8Me9dH7vlFRERERMrKcA4axLE//SmUlcV6NRJBCrolIg7p15ncjGSKKjx8sWZP6DsOPg5OfcAcf3E/LHzSHFuZ7pZ0Lq8p0MX83ciVmO9YYi5Hngl9jzJ701VmLiIiIiKR5PNh27yZtIICTeNpZxR0S0Q47DZOGtUNaKTE3DL+EpjyR3P8/u9g1Qet61xe08BjTQn7gS2w/bvWPZfFynR3Hwc/fth0Sd8yD755NDLPLyIiEgv7NsCSF8EbokJNREQiQkG3RMyp/i7mM1fsYndxReN3nvpHGHcx+Lzw+k+Cme7WBt1JacES8xURKjG3Mt3dx0KnvnDcHebrz/4Ce9Y2/BifzzR0e/xYmK/gXERE4tAHN8Dbv4CNc2O9EhGRdk1Bt0TM+N4d6dU5ldKqaqbcO4f7Pl7FgXJ3w3e22eCU/zOZaU85eN3gTIWOLexcXtOI083l8gh0MS/ZDcU7ABt0HW2um3A5DDgGPBXmw0rdDEHBanjuNNOlfdsCmHmracYmIiIST0p3m8uS3bFdh4hIO6egWyLGZrPx2EUTGNOrI+Xuah6ZvZ6j753No3PWU17VQOmawwVnPw3dxpqvuwwGu6P1Cxl4LDhTTIm5VbbeUlaWO2cQJHcwxzYb/OifkJwJ276Frx8y11cUwSc3w6OHw4Y54EiGjO5QXQkL/t26dYiIiESa21+VVlUa23WIiLRzCrolokZ0z+Ltqw/nsYsmMCi3AwfK3dzz0SqOvm82z83bRJWnTvOx5A5w4esw/lKY/ufILCIpDfocbo7Xz2rdc1n7ua0TA5asnnDC3eZ49l3w1YPw8CT4+p/g9cCQk+Cab+Cke819vn0CKktatxYREZFI8pSbS7e6JIuIRJOCbok4m83GCSO78tFvjubvZ4+hZ6dUCoorueWd5Zzz73l4qusE3h26wI8egoEzIreI/tPMZWuD7pr7uesaeyEMPgGqq8wYsZJ86NwfLngNzn8JOvczwXfnAVBRCIufa91aREREIimQ6VbQLRIXbDZ8w4ZR1KuXqayUdkNBt0SNw27jzAk9+ex3U/jLj0eQkexkydZC3l3aRHfzSBhwjLnc9CV4Klv+PKEy3WB+GJ76IHTIMx3Tp/8Zrp5vxqJZ7A44/FpzPO8RqA6xx11ERKSteaygW5VYInEhLQ3P0qXM/uc/IS0t1quRCFLQLVGX7HRwyWF9+cW0AQA8PGsd1d4ozx7MGwHpuaZ0bsv8lj1HSQEUbQds0G10w/fJ6ArXfgu/Ww1H/Q6cyfXvM+Z8SMuBA1th+dstW4uIiEikuVVeLiLSFhR0S5u55LC+dExzsWFPadOzvFvLZgtmuzfMbtlzWFnu7IGQnBH6filZkJIZ+nZXKky+yhx//WDrO6qLiIi0VrXHTA4BlZeLiESZgm5pMx2SnVxxRD/AZLu90c52W0F3S/d1N7afu7kmXWFK0PN/MJ3NRUREYslqogbgVvdykbhQVoZzzBim/fKXUKaTYe2Jgm5pU5ce0ZeMFCdrd5fw0fL86L5Y/6nmcudSKN3T/Mc3tp+7udI6w7iLzbE1YkxERCRWrCZqoEy3SLzw+bCtXEnm1q2qjGxnFHRLm8pMcfETf7b7oc/WRjfbnZEHeSPNcUuyy5HMdAMcdjXY7CbzvvP7yDyniIhIS9TKdCvoFhGJJgXd0uZ+ckQ/OiQ7WZVfzMyVuxq97+a9pTwyex37Sqta9mIDWjg6rHQPFG0zx11DNFFrrk59YcTp5vjrf0bmOUVERFqiVqZb5eUiItGkoFvaXFaai8sO7wuYbLcvRPnMsu0HOP1fX3Pfx6u5/rWlLXuxwL7u2c0r07Gy3NkDG2+S1lyH/8pcLnsDCrdG7nlFRESao2amW0G3iEhUKeiWmLjiyH6kJTlYvqOIWat217v9mw17Oe8/8wMZ7s9W7ebzNQXNf6Heh4EzBYp3QMHq8B+3c7G5jMR+7pq6j4V+R4OvGuY/GtnnFhERCVfNTLfKy0VEokpBt8REp/QkLjmsL1A/2z1r1S4ueXIBJZUeJvfrzPmH9ALgzvdX4Kn2Nu+FXKnQ53Bz3JwS80jv567p8F+by0VPQ/n+yD+/iIhIU5TpFhFpMwq6JWauPKofqS4HS7cdYK4/i/3Oku387NlFVHq8zBiWyzM/OYQ/njCMjmku1uwq4aVvW1CS3b8F+7p3+svZI53pBhg4HXJHmBEti56JzHNWlcKnt5syehERkaYo0y0Sf2w2fH36UNalC9hssV6NRJCCbomZnA7JXHRobwAe/Gwtz83bxG9eWYLH6+P0cT149KIJpLgcZKW5uO7YwQD845PVHCh3N++FrH3dm74ET2XT9y/bCwf8wX23CDVRq8lmg8k/M8c/vNb656t2w6uXwpf/gHeu1YgJERFpWs1Md3UVVHtitxYRMdLS8Kxdy8z//hfS0mK9GokgBd0SUz89uj/JTjuLtxRyyzvL8fng0sP68Pezx+ByBN+eFxzSm0G5Hdhf5uafn61t3ovkjYD0XPMBY8v8Ju9us7LcnQdASlbzXitcw34EdifsWgYFa1r+PD4fvPsrWDfTfF20DXavjMwaRUSk/aqZ6QZTfSUiIlGhoFtiKjcjhfMP6R34+lfHDOS2H43Abq9dUuN02Ln5lOEAPP31JjYUlIT/IjZbMNu9oenya1u+P+iOxn5uS1rnYNn78jdb/jyz7oClL4LNYUaSAaz9pNXLE4m4ag+snak+BiLxomamG6BKJeYiItGioFti7tfTB3HGuB7cc+YorjtuCLYQe1imDO7CtCFd8Hh93PXBqua9SGB0WNP7um3R3M9d08gzzOWyN1tWEr7gv/DF383xqQ/CoVeb43WfRmZ9IpG08h144Sz49LZYr0REANx1gm7t6xaJvfJyHIcdxtG//z2Ulzd9f0kYCrol5jqlJ/GPc8dy7qTeTd73ppOH47Db+HTlLr5atyf8F+k/1VzuXAqljT+uTTLdAENPBkcS7FkNu1c077Er3oUPrjfH026C8RfDwBnm6y3zoKIosmsVaS1rZN/e9bFdh4gYdYPuqmZUkIlIdHi92BctotO6deBt5sQeiWsKuiWhDMztwMWH9gHgjvdWUO0NM0OckQd5I83xhjkh7+byFGMLNFEb04qVhiElCwYea46XNaPEfPPX8MaVgA8mXA5H+4Pv7AFmH7rXAxvnRny5Iq1SvNNclu2N7TpExPDU2dOt8nIRkahR0C0J5zczBpGV6mJVfjGvNGeE2ICmR4d1LNtkDjr3j14TtZqsEvPlYZaY714JL50H1ZUw5GQ4+e+1R0oM8gfxa2dGfq0irVG8y1w2UWkiIm2kXnm5GqmJiESLgm5JOB3TkvjtjEEA/P2T1RRVhDlCLLCve3bIADcQdEd7P7dl8AngTIV9G4KzwUOpLIEXzoGKA9BrMpz1BNgdte8zsEbQrdFhEk9qZrpVMicSe8p0i4i0GQXdkpAuPLQP/XLS2VtaxYc/7AzvQb0PA2cKFO8I7i+to2P5JnMQ7f3cluQOMPg4c9xUF/OvHoQDW6Bjbzj/ZXCl1r9P3yOCf8fm7hMXiabifHPpq4aKwpguRURoYGSYgm4RkWhR0C0JyeWwc+b4HgB8uCw/zAelQp/DzXGIEvOsso3moK0y3QAjrBLzt0Jnpwu3wtcPmePj/mpGjjXElQp9jzLHKjGXeFHtgdKC4Ndl+2K3FhEx6o0MU3m5iEi0KOiWhHXCyG4AfLVuDwfKwywxt2Zjz/6raUa24p3gB42yfaRX+febRruJWk2DjgNXOhRuge2LGr7Pp7eZUsA+R8KwU5t+PtDoMIkfpbuBGieUyrSvWyTmlOkWiUu+nBwqMzNjvQyJMAXdkrAG5nZgUG4H3NU+Zq3aFd6DRp5hyrOrSuCH1+DVS+DeAfDyhdjnPQiAr1M/SO0YvYXXlZQGQ040xw11Md/yDSx7HbDBCXfVbpzWkEEaHSZxprjOFhA1UxOJPSvT7Uozl8p0i8ReejqeHTv46NlnIT091quRCFLQLQntxJFdAfjwhzBLzLN6wq+WwhUz4fBfQqe+5oPHqvdwzH8EAF/X0VFabSNG1igxr9lkyuuFj/5ojsdfHF4GvnP/4OiwRsajibSZ4jr/P5XpFok9K9Odlm0uFXSLiESNgm5JaFaJ+dw1BZRWesJ7kN0OvQ6B4+6EXy2Bq76EKX/A12UoPmx4h58WtfWGNHAGJGeaBmhbvwle/8OrsOM7SMqAY24J//ms0WHrtK9b4kDdoFuZbpHYszLdVo8QlZeLiESNgm5JaMO6ZdAnO41Kj5c5qwuafkBdNht0HQXT/oTnZ1/y7tin8A1tYs90NDiTYejJ5tjqYl5ZYvZyAxz9O+iQG/7zBUaHfarRYRJ79TLde2OzDhEJsuZ0p+WYS40ME4m98nIcM2ZwxE03QXl50/eXhKGgWxKazWbjBKvEfFmYo8MafcIY/pewupiveAe81WZEWPFO6NgHJv+iec/V9wgz/7t4B+xaHvm1ijSHtac7OctcKtMtEnuBoNtfXu5WeblIzHm92D//nJzly2tvN5SEp6BbEt6J/hLz2at2U+GujvFqWqH/VEjpCCW74PtXaowIuxNcKc17Llcq9POPDlOJucRaib/RYd4Ic6lMt0jseeru6VamW0QkWhR0S8Ib0zOL7lkplFZV88Xats2g+Xw+/vzOMm54fSlVnlaekXQmwfAfmeN3fxX+iLBQapaYN1fZPnjyRHjyBKgOcxxbPJn3CDwwGvZtiPVKBIKZ7q4jzaUaqYnEntVILd3KdCvoFhGJFgXdkvBsNhvHR7LEvBm27Cvj2XmbeXXhNu54b0Xrn9AqMfe6CXtEWCjW6LCt85s3Oqy8EJ47HbZ8bcaObVvYstePFU8VzL0XCjebbvASe9aebivTXapMt0jMeeqUl1eVxG4tIiLtnIJuaResEvNPV+xqfca5GRZvKQwcPzd/My8v2NK6J+x7VLCpzbiLwhsRFkrn/pA9sHmjwyqL4YWzYOeS4HUbZrd8DbGw7lOoKDTHOxbHdCmCqZSw9nDn1ch0q8GfSOx4q6G6yhyrvFxEJOoUdEu7MKFPJ3I6JFNU4WHehrbLoi3ZWghAXmYyALe8s4xFm/e3/AkdTjjxHhh+Gsy4vfULDJSYf9L0fatK4YVzYNu3kNop2LxtfYIF3T+8FjzerqA75kp2Az6wOyFnsLnOU6GZwCKxZO3nhhqN1BR0i4hEi4JuaRccdhvHj8gD4KM2LDFfvMUE2H86aRgnjuyKu9rHVc8vIv9ARROPbMSos+CcZ4L77FrDKjFf91njmUV3Obx0vikpT86Ci9+Cw642t21fBBUHWr+WtlBZDKs/DH5dtM0f9EnMWKXlHfIgOQOc/qaA2tctEjvuBoJunQgTiQu+tDQ8ycmxXoZEmIJuaTesEvNPlu+i2hv90tUKdzXLd5i90uN7d+L+s8cwJC+DguJKfv78ovjopN7nyKZHh3kq4ZWLYeNcSOoAF70B3cdBx97QeQD4qmHjF2277pZa9b7Zp5g9EHKGmOtUYh5bJf6gO6Or6U9gbZ9QB3OR2LH2c9td5mQYKNMtEg/S0/EUFvL+K69AenqsVyMRpKBb2o3J/TvTMc3F3tIqFmzc1+B9KtzVvPjNFtbtbn3DmOU7DuDx+sjpkEzPTqmkJzv5zyUTyEp1sXRrIbe8vQxfrPetulKCo8OeOdV0JH/nWjMDfNX7sHsVvHa5GSvmSoMLX4Nek4KPHzDNXIa7JzzWrNLyUWdDj/HmePt3sVuPBDuXdzDNDgMVHGqmJhI7VqbblWp+9oPZ413tid2aRETaMQXd0m64HHaOHWZKzD9enl/v9iVbCznpoS/401s/cN2rS1r9elYTtbG9OmLzdxjvk53OwxeMw26D1xZt45mvN7X6dVpt/CVmP235PlM+vvg5mPlnePkC+NdkWP0+OJLh/Jegz+G1H9vfCroTYF93SUFw//mos022HpTpjrXiGpluqJHpVnm5SMxYmW5nCiTVyKa5VWIuIhINCrqlXTlxlPlg/9GyfLz+EvMqj5f7P17NGf/6ig0F5gPF99sOsKekslWvZQXd43p3rHX9UYO6cOOJwwC44/2VzFsf44zesFPhD5vgZ3PgzCdgyh9h5FnQbawpJ3elw3kvQP+p9R/b7yiwOWDvOijc2rbrbq7lb5lS+O7jIXuAuQTY8Z06ZceSlenOMNs/AvtHSxV0i8SM2x90u1LAkWR+zoP2dYvEWkUFjh//mMl33AEVregPJHHHGesFiETSEQNzyEh2kl9UwZJthaQ4HVz36hJW5RcD8OOx3Vm+o4h1u0v4at0efjy2R4tfy+pcXjfoBrjyqH6s2FnEW4u3c82L3/HutUfQs1Nai1+r1ZIzTObXyv5afD4zOsYR4kdBShb0mADbFphs9/hLor/WlqpZWg7QdaTJ8JcWwIFt0LFX7NZ2MCveZS6tTHe6Mt0iMRcIutNMr4WkdKgs0tgwkVirrsb+4Yd0BdzVcdAbSCJGmW5pV5KdDo4ZlgvALW8v48ePfMmq/GI6pyfxrwvH8+B545juv/3zNS3/0L+rqILtheXYbTC6Z8d6t9tsNu4+YxQje2Syr7SKnz27iPKqOPzhabOFDrgt1r7ueB4dtm+jOTFgs8PIM8x1rlTINRUHKjGPoXrl5drTLRJz1sgwa5qAta9b5eUiIlGhoFvanRNHmg/3y3cU4a72cdzwPD7+zdGcNMqUtx49qAsAX6wtaHGjM6u0fHBeBh2SGw5aU1wO/n3xRLLTk1ixs4gb3vg+9o3VWsLa171xLni9sV1LKMteN5f9jg4Gd1C7xFxiI1BeXjfTraBbJGYCme5Uc2nt61amW0TijTcOk1YtoKBb2p0pg3Pp3TmNjBQn/zhnDP++eAJdMoLzDif06USKy87u4krW7GpZF/PFW8187nG9OzV6vx4dU/nXheNx2m38b+kO/v35hha9Xkz1nAhJGSZIyv8+8s/v88HLF5rO6p6qlj3++zql5Rarg7ky3bFR7Q6WkQf2dKu8XCTm6ma6k5TpFpE4tOwNuLsXrPk41itpNQXd0u6kJjn46DdHsejmYzljfM9AZ3FLisvB5H6mxPWLtQUteo1QTdQaMrl/NreeOhyAez5axZzVu1v0mjHjcEHfI81xNLqYF26BVe+Zzupbv2n+43ctgz2rTQf2YafWvq1mB/NErDJIdCX+/dx2J6R2NsdWpluN1ERip26m26VMt4jEoQ1zzMnATV/GeiWtpqBb2qW0JCdJztBv76MGmQ/+n69t/gd/T7WXH7YdAGBcr45hPeaiQ/tw3qRe+Hzwq5cWs2lPgmUTormve9u3weOWzAO3GqgNPt40fqspd7gJxisOwL4ErDKIhMoSePVS+PKBtn9taz93h65g9/9/tPZ0q7xcJHZCZroVdItIHKkoMpft4GeTgm45KB092Ozr/mbDXirczdsrsnpXMeXuajKSnQzo0iGsx9hsNm7/8QjG9+5IUYWHnz67kJJKT7PXHTPWvu4t84MZkkipmd1ubtDt9cIPb5jjuqXlYLL0XUeZ44O1xHzO3bDibZj9V3C38fiRuk3UIBh0VxaBp3Vj+0Skhepluv1Bd1XLtlyJiERFpRV0R/izZwwo6JaD0qDcDuRlJlPp8bJw0/5mPdYqLR/buyN2u63xO9eQ7HTw2EUTyMtMZu3uEq57ZUlglnjcyxkEGd2huhI2fx3Z5966IHi84zuTlQ7XlnlQtA2Ss2DQcQ3fx9rXvf0gbKaWvwzmP2qOq6vavqFc3SZqACkdgzOBle0WiY16mW6Vl4vEhfR03FVVvPP225CeHuvVxJ6V6a5KsArRBijoloOSzWbjKH8X88+bua87sJ87zNLymnIzU3jsogkkOex8smIXLy7Y0uzniAmbLVhiHsl93VWlkP+DOU7LBp+3eft2rNLy4aeCK6Xh+3Q/SJupeb3w3m/BV6OSI9InTJrSUKbbbleJuUishcp0t4MSThFpRypVXi6S8AL7utc0M+gOs3N5KON6d+K64wYD8L+lO1r0HDFhlZivnxO559yx2ASFGd1hxOnmunBLzD1VpmwaYNQ5oe9nNVPbubTdjJ0Iy+LnzOzypA5wxK/NdVvmte0aShoIukHN1ERiLWSmO/GzSSLSjgQy3Qq6RRLWkQPNB/9V+cXsLgpvr+uBMjcbCsyHkrEtyHRbTvbPDF+4eT9FFe4WP0+b6j/VXO76AUoi1IHd2s/d6xDoN8Ucb5gb3mPXfwbl+02TLqu7ekNyBpnA010KBatbt96G1MzWx4vSvfDpreZ46o0w8kxzvHVB2554qNlIrSZlukViy8oaueoE3e0gmySS0CoqcJx3HhPvvRcq2rgPSzwKZLoT/4Sggm45aGV3SGZkj0wAvlwXXsZtybZCAPrlpNMpPanFr92rcxoDuqRT7fXxVQs6qMdEhy6Q529KFm5g3JSt/s7lvQ6BfkcBNjP+qyiMCoClL5vLkWeC3RH6fnYHdBtrjqNRYv7+7+GxI2Htp5F/7paa+WdzQiJvJEy+ylwmZ5pfXruWtd06AuXl3WpfbwXdynSLxIbVVNEqKw80UlPQLRJT1dXY33yTHl9/DdUHUXVeQ6rdwROBaqQmktisfd1fhBn4Lt7iLy1vRZbbMnVILgCzE2lu94Cp5jIS+7p9PlP+DNBrMqR2CpaCNxXUl++H1R+a4zHnNf1a3ceay0g3EvNUwcp3zfHq9yP73C21eR4sed4cn/wPcDjNiYdeh/hvb8N93Q01UoNgeXmZgm6RmAhVXt4Oskki0k5YpeXQLk4IKuiWg5q1r/uLtXvC6iRes3N5a03zB91zVhfg8yVIF/P+NeZ1t3bN+zaY8mJHMnQd7X9+f4n5xiaC7uVvm07quSOCI8EaE60O5lvnB0fstHWTsoZUu+H968zx+Euh9+TgbX0ON5dttU5PVbB8vG7QnaY93SIxFXJkmIJuEYkTlTWm2bSDE4IKuuWgNqFPJ1JdDvaUVLJ6V+PzSb1eH0u2FgIwrlfLmqjVNKlfJ9KSHOwurmTFzqKmHxAP+hxuguTiHbBnbeuey9rP3X0cOP2l+ta+8Q1zGg/qrdLyMeeZzupNsTqY71pmgsFIWVejpLxgVeyDyPn/gt0rTPn2jNtq39bbH3Rvmdf6EybhKNllLu0uSO1c+7ZAplt7ukViol6mW+XlIhJnlOkWaT+SnQ4OG2D2l365vvGAaePeUg6Uu0l22hnaLSMir334ABN8zFndvA7qMeNKhd6HmuPWlphb87mtsmeAXoeaD4HFO2HPmoYft2+DyTDb7DDq7PBeq1NfU75eXQW7l7dq2bUE9nH7A/9YZrsLt8Kcv5njY++AtDqBbo/x5oRJaQHsXR/99dQcF2av86tGjdREYqteplvl5SISZyprBN2ecjMKNYEp6JaDnlVi/uW6xgMAq7R8dM8sXI7I/NeZOsTsKZ+TUPu6/SXm61rZOKyhoNuVUiOon9Pw45a+Yi77T4PMbg3fpy6bLbhfPFLN1A5sNwG8zR4cdxbLoPvjP5mGI70Ph7EX1L/dmQw9JpjjLW2wzlDjwkAjw0RiLeTIsMTPJolIO1FRpwrUk9jN1BR0y0HPaqa2cHMhVY00ilzSyvncDbGC7kWb93OgLEFGhw0+0Vyu/QS2LWzZc1QcMGXQAD0PqX1bY6PDfD5Y+pI5HnN+816ze4T3dVsnHXpMgGGnmOPNX0XmuZurvBBWvWeOT74/dMl9n8PM5eY2mNcdGBeWV/+2QKZbQbdITNTNdFvl5RoZJiLxorJO0J3gJwUVdMtBb0CXdLpnpVDl8bK+OPT+YCvTHYnO5ZaendIYlNsBrw++WJcgJea5Q2Hsheb4g+tbVu6zfRHgg459IKNOUGbt6970BVR7at+2ZT4UbjZzt4ee3LzXjHSm2wq6Bx4LfY4wx/k/mBMKbW3zV+DzQvYgyBsR+n6Bfd1tkOkOdC5voBrBaqRWtq9t54aLiFE3022Vl6uRmkhspaXh3r+f915+GdLSYr2a2Kqb6U7w7S8KuuWgZ7PZAtnuVYUNB91lVR5W5RcDkc10A0wb6h8dtipBgm6A6bdCUoYZwWVlnptja41RYXV1GwMpHc0ZzroBsvVaw08LZmbCZXUw372y9WdLq93B8vdBM0wJdecBgM+cGGiNvevh8WObN/d74+fmst/Rjd+v1yGmHH7/Jija2eIlhqXY30itofLywH5znxn/JiJtS5lukfhks0F6OtUpKeE1im3PlOkWaX+OGmwyb6GC7h+2HaDa66NrZgpds1Ii+tpTB5uAf+6agrDGlsWFjDyYcoM5/vS2+mcjm9LQfm6L3QH9jjLHG+cEr3eXm1FhEN5s7royu0OHruCrNhnp1ti6wPwySMuGbv4MemAkVytLzBc/Z+aXz/1b+I+xSvGtkWuhpGQGR6xFO9sdakY3gMNlTqyA9nWLxEK9TLc/6K6uMicVRURirW7loFt7ukUS3hEDcrDZIL/cRn5RRb3bF1ujwiIwn7uuiX07k55kxpYt35Ego8MAJl8F2QOhdDd8fm/4j/N6g3vBGwq6ocbosBr7uld/aGY2ZvUKlnM3V6DEvJX7utfNNJcDpgc7c1tram0ztfxl5nLbwvAC0uJdULASsEHfo5q+f+82mtdd3EgjNdDYMJFY8XqDQXcg050evF0l5iKxU1mJ44orGPfgg1BZGevVxFbdTHeCl5c7Y70AkXjQKT2JUd0z+X57Eef+ZwEpSQ58PvD6fFR7fewvNbOdoxF0JzntHDEwh09W7GLO6t2M6pkV8deICmcSnPA3eOEsmP8YjL8McgY2/bg9q03w7EqH3BD7j/v7O6Rv/caUEyWlBWdzjz63/giqcPUYD2s+bP2+bms/96Bjg9f19QfdOxabD601P8Q2xy5/0I0P1s6EsU00jNv0hbnsOqr+mLCG9DkMvnk0+s3UAt3LQ3SYT8uBvevUTE2krXlqnFi2gm5HEtgcphLIXQapHWOyNJGDnseD/bnn6A24PZ4m796u1c10q7xcpH04brhp6LXjQAUbCkrZuKeUzXvL2La/nNKqauw2mDI4NyqvHdjXnUijw8AEnYOOB68bPr4xvMds/cZc9hgPjhDn/Tr3Nxnt6irYMg9KdgcD3ZaUllusTHdrOpgX5/vL020w4Jjg9R17mzV7PcHy+eYq3RssywZY+3HTj7H2lje1n9vS29/BfPeK6O2n9lQGM9gdmsh0q7xcpG3VDLqd/qDbZjMNKiHhP9iKSDvRzhqpKdMt4nflkX2p3rmSCYccisvpxG63YbeZRmsOm43czGS6ZaVG5bWt0WFLthayv7SKTulJUXmdqDjhblg/y4wQW/MxDD6+8ftv/dZchiotB/MBsN8UWPK8CSoLVpsMTI+JkDOo5Wu1xobtXQuFW0yg3Ey2DbP8zzUuGDha+hwO379iSreteebNYWW57S5zImPdLLO/0uEK/RiriZpVkt+UDrlmW8DedbDlGxhyQvPX2ZQSfxM1uyt09t26XuXlIm3L2hdpd9Y+8ZmUZqqQEvyDrYi0E/XKy7WnW6RdcNht9M2Ayf06M7l/NpP6dmZCn86M792JMb06Ri3gBuiWlcrQrhl4ffD52gTqYg6QPQAOu9ocf3QjeKoav7+V6W6oc3lNgX3dc2rM5m5FlhsgPTu49/rdX5m5381kX/+ZOahZWm4J7OtuYTM1K+gedKxp0lZ5IPj9asj+TWaEmt0ZzGCHw7pvY83UfL5gB/LmKq5RWh6q+2paFDPdB7bD82eak0AiUlugiVqd32lWMzVlukUkHliZbuvzQoL/bFLQLRInpviz3XNXJ1jQDXD09dAhD/atN/uFQynbZ7LMAD0nNf6cVifu/O/NH7sLRp7Z+rWe+pDp2LthNix6ulkPtfmqsVkd1Qc2EnRvWwju+g35mrRrubnsOhoGzjDHjQWOVpa7x0RI7hD+6wQ6rYfY113tgZcvgL8Phk9vb/7JiUDQnRf6PoFGalEIule8Y7YjzHsk8s8tkugC48LqTOIIjA1TpltE4oCV6bZ6wyT4zyYF3SJxYtoQs697TiKNDrMkZ8CM28zx3HuDQVdd2/yl5dmDmm761SEXcocHvx58fHiNwpqSM9DMGQf45GbYvznsh3YqXY+t4gCkdgrO/a4pewCk50J1Zcs6pFujzLqOhEHHmeO1n4S+v9XdPdz93BYr6N6xuH65ls8H718Hqz8wX3/5D3jvt+CtDv/5m+pcDsEz19EoLy/c4r8M/99W5KARMtPtb/6Y4NkkEWknrEx3pj/oTvCfTQq6ReLEhD6dyEh2sq+0iu+3H2j6AfFm9Hkm41pVAs+dAfs21r9PY/O5G1Jzn/KYJrp4N8fkq8zorKoSeOcaM0InDLlF35uDAceYeeJ12WzBgHZTM0vMq91QsMoc542EgdNNN+GCVQ2fGPD5auznbmI+d10d+0BGd7Nv3BrfZvn8fvjuGbDZYcLlgA0WPQVvXNn01gFLYEZ3iM7lYEr9wTSPi7RA0L3VZO1FJKipTLdGholIrFW7weP/WWWdwHcr6BaRCHA57Bw5yGT/5iRaF3MwY7x+9E+T6d29HP4zNdhx3BLYzx1u0O1vRpbaKZj5jQS7HU57xOxh3PQFLHwirIflWUF3Q6Xllr5Hmsvm7uveu850a0/qYILi1E7Bfe8NZbsLVpkZ6c7Upkv167LZzOgwqD2ve/ELMPtOc3zivXDqA3DWk6a0f/mbpuQ8nDPNViO1Do2Ul6dFsbzcCrp91VC0LfLPL5LIApnuOkG3S+XlIjGXloZ7+3Y+fOYZSEuL9Wpip2bn8g4KukUkwqwu5rMTcV83QN5w+Plck/GuKIQXzoYv/89kZas9wVFdPcMMugcdC8feAec8a+aCR1Ln/nDsX8zxzD/Dvg2N379kNx3LN5njgdND38/KdG9dYM7Uhivf30Qtb0RwDvlg/4mGhvZ1W1nu3oeCMzn817HUbaa27jP436/M8RG/gUN+ao5HngHnv2yC+3Uz4bnTobyw8ecOJ9OdZmW697SooV2jrKAbTLM5EQkKZLrrlJcnqbxcJOZsNujShaqsrNCNSA8Glf6KT1e62cIICf+zSUG3SByZ6t/X/f22QvaWVMZ4NS2U2R0u/wDGXwI+L3x6G7x2KWxbYDIoyZnQZWh4z2WzwRG/av6e5XBNvAL6HmXOnr7deJm5bcNsAHxdR5v95qF0GWay1O5S2Pl9+GvZ5d/PnTcyeN0g//i1TV/U/2XT0v3clsDJgW/NyZBXLzEzxkedHdzzHljHDLjkbUjOgq3z4elTzOz0UMLZ0201UvO6648FaY3ywuAva1DQLVJXqEy3FXQneDZJRNoBK9Odkhk8QZjgVTgKukXiSF5mCiO6Z+LzwWNz14f9uH2lVfzypcW8tnBrFFfXDM5kU2p+ygOmNHnFO2aEE0DPicFMbqzZ7fDjR0xJ95av4ZvHQt91vSmV9w6Y0fRz9ra6g38Z/lqszuV5I4LX5Q6DrN7mQ7KV2QZTNbDJ/9zN3c9t6TIMUjqaX2LPnGr2t/c9ynw/Gvr36X0oXP6+2T6w6wd46sTa5V811RwZFoorNdi4KZJjww7U+T8Qr0H3zFvh31Ois6ddpDFWUO2qU7rq0p5ukZirrMT+q18x+t//hsoETb5EQoX/5HlyZrupwomTT74iYvndcYMBePzLjSzavK/J+/t8Pq5/bSn/W7qD2/+3grKq6DaO8vl8fL1uD/kHwhiJNfFyuOx9s7fX+qDX1HzuttapDxx3hzn+7HbYvbJ+ubM3OCrMN+CYpp8zMJKrkTnYdVnl5V1HBa+z2YIl5mtrlJjnLzXZ3OQs6DY2/NeoyW43gTSYgDt3OJz7fOOl6l1HwU8+gsyeZg/6F3+vfx9PJZT737eNZboh2EytrOn3edhqlpZD/Abdi5+DnUtg0ZOxXokcbKxxhvUaqSnTLRJzHg+Oxx6j34cfgucgbgRaWTPTbfWbKA99/wSgoFskzhwzNI+zJvTE54Pfv/Y95VWNj2p65utNfLbKlPqWVHp4//udUVvbxj2lXPDfb7jg8W/4xQuLwntQ78nws7nQ61DTjXvwCVFbX4tNuNx0SvdUwL8Ohb92hX+MMJnI58+EVy/BVr6fKkcavh4Tm36+mnOwwxm1VboHSvzZ4Zpj0iBYYr7mk+DJAKu0vO+RDXdRD1ffo8xlRne48DVI7dj0Y7IHwMn+YHv+v+p3qbey3I4kU2bfmGg0U7OCbiuLHo9Bt6cqOCpt4dPqsC5ty+oIXG9kmJXpVtAtIjFmVdLVzHSrvFxEIu2WU4bTNTOFjXtKuf+T1SHvt3zHAe76wIyZGtE9E4BXvo18iXmVx8vDs9Zy/AOfM2+DCRa+33agyRMCAZndTIb0D5ug+9iIr6/VbDb40cPBgNdTYbpe71xiOrCveg+A3RmjwO5s+vm6joakDJONtsrGG7PLn+Xu1A+SO9S+rd9R5sNx0TbYvcJcZ5Wat3av+8SfwHF/NXvws3qG/7jBx5vO8tVVpgldTVbn8oyuTTeBsfZ1R7K83Aq6rSx+PAbdpTX2wxdtq13FIBJtTWW6q0radj0iInUFMt1ZwT3dCX5CUEG3SBzKSnVx95mmzPjJrzayYGP98tuyKg+/fGkxVdVeZgzL48nLJuGw21i4eT/rdhdHbC2LNu/n1H9+yf2frKHK4+XowV3ITk+i2utj+Y5mzBO32UyZULzq2Auungd/2gG/XgpXzoLzXzF7nGfcTvWRv2dFj3PDey6H02T4IbwS80Bp+cj6t7lSg8H1mo9N+faW+ebrlu7ntiSlweHXQud+zXuczQbH32Vmea98N7i/HIKdyzs0UVoOwQ7m0ch09/Nn8cv3N91tva0V76r99bePx2YdcnBqKtOt8nIRibWKhsrLE/tnk4JukTg1bUgu507shc8H17++tN5e7dveXc6GglK6ZqZw31mjyctMYZq/+3kkst1FFW5ueXsZZz32Nat3FZOdnsSD543lmcsnMa63KRtesrWw1a8Td5LSoVNf6DkBhpwA4y6CI3+Dd8ofKU/KCf95AiXmYczrtjLdeQ0E3VBjX/cnsO1b86E5PTf8LvDRkDfclOUDfHRjsIw+nM7llppjwyKlcLO5zB0O6V1qXxcvrK0EGd0BG6yfBXvDb5wo0iohM90qLxeROFHZQHl5gjd5VNAtEsduOmUY3bJS2Ly3jHs/CpaZv7t0B68u3IbNBv937lg6pZsZ1udO6gXAm99tp8oTevxVY7xeH68t3Mr0v8/lufmb8fngrAk9+fS6Kfx4bA9sNhtjemYBpsRcQuhzpLnc/HXTc6ibCrqtfd1bvzGd4MFkv2M9w3Pan0wzt/zvYcmL5rpwZnRbrPLysgh28LYy3R17m5MnEH8l5taJie5jYZD/hMpCNVSTNhIq053k39qS4PsmRaQdsLqXq5GaiLSFzBQX95w5GoCnv97E/A172bqvjJveNDOdfzltIIcNyA7cf9qQLuRmJLO3tIrPVu5q8Dkb8+2mffz4ka+4/vXvKSiupG92Gi9eOZn7zx4TCOwBxvTqCJh54hJC93HmF0XZHjMHO5RqNxT4T6g0VF4OpvQ9d7iZe77wKXNdtGaXN0d6Dkz9gzn+7C9QWRwsnc7Ia/rxaREOuisOBH9RZ/WK36Db2vfeIQ8mXWmOFz+vDKO0jVCZbjVSE5F4Ech0ZwUz3dWV4TWnjVMKukXi3NGDu3D+ISaDff3rS7n2pcUUV3qY0KcTv5o+qNZ9nQ47Z00wDbFebkaJ+dZ9ZVzz4nec/dg8fth+gIxkJ386aSgf//ZoDh9Yv6R6tD/TvWlvGYVlVS39q7VvziQYerI5XvJC6PvtWWMakiVlmJncoVgZUa/bXLZ2P3ekTPopdB5gmoN98Y+WZbojVV5e6H/Pp2WbhnTxGnRbme4OeTBwOnTsAxWFsPzNmC5LDhKBTHeI8vIE3zcpktBSU3GvWcMn//43pKY2ff/2qtae7hrfhwQuMVfQLZIA/nTSMHp0TGXrvnKWbi0kM8XJg+eNxemo/1/4nIkmQP98bQHbCxsvxSmt9HDfx6uY/o+5vP/9Tuw2OP+Q3sy+fio/O3oAyc6Gx1F1TEuib7b5gKYS80aMvdBcLns9dFmU1d08b4SZnR3K4OODxzVLp2PNmQTH/9Ucz3sk+PcJa093hEeGWaXlWeb/QNwG3SU1qgHsDph0hflaDdWkLQQy3XUbqbWPfZMiCc1uh759Kc/La/wzQXtnVa0lZ/pPEPq30yXwScGD+F9TJHFk1CgzB/jbmaPp2Smtwfv2zUnnsP7Z+Hzw2sLQ2e6yKg8X/Hc+j8xeT5XHy2H9s3nvl0dx9xmjyOmQ3OSaRvfsCKjEvFH9ppgAsOIArHq/4fvkm60CIUvLLT0PgZSOweeNJ4NPMHPOqyuD47DC6l7e2VyWRqi8vOZ+boj/oNv6Ho29CBzJsGMxbF8Uu3VFQsEaWPZm030MJHY8/qA7VKZbQbeIxFpljUy3zVZjVreCbhGJsiMH5fDwBeN44NyxnDSq8dLd8/zl6K8t3Ea1t/6H32qvj1+9tJil2w7QKc3Fvy+ewIs/nczw7uGP9LJKzJdsVaY7JLsdxl5gjhc/3/B9ama6G+NwwqizzfGI0yKyvIipOULMEk6m2yovd5dGpkFK3aC7Y5/g9fG0D6zuvvf0bBh5hjn+9onYrClS3rgCXr+88T4GElvWh1ZXnRO31tdet+k1IRLPvF546yr48v9ivZLIqqrC/sc/Mvzpp6HqIN6+V1Gjezm0i54TCrpFEsgpo7tz2rgeTd7v+BFdyUp1sb2wnC/X1S7d9fl83P6/5Xy6cjdJTjuPXzqR40d0xdbMTthj1UwtPFbQvWFOcM9xTYHO5aOafq7j7zIzxAfOiNjyIiZvBEy4zBw7kiG1U9OPSc4Eu8scR2JftzUazAq2M7ub5/d6oGh7658/ErzehqsBrIZqy96Asn1tv65I8FQGTyLtXRvbtUhoIUeGpQePle2WeLdnDSx9yfQSaU/cbhz/+AeD3n4b3Afxya9AptskeNpDzwkF3SLtUIrLwen+4PyVb7fUuu3xLzby7LzN2GzwwLljmdCnc4teY0T3LBx2G7uLK8k/UNHqNbdbnfpC36MAn/mAUFNJgb/U2Aa5w5p+LmdS/Ozlbsi0m8zJgzHnhjfOzGarMTYsAkH3Af9JDSvTbXcEj+OlxLxsrzkJgA065Aav7zEBuo0xpb+NNd6LZwWrweevKDiwLbZrkdBCjQxzJIHdaY4T+IOtHCTK/ScnK4u1naW98VQFt8Gk1M10J+4JQQXdIu2U1VBt5opd7C2pBOCDH3by1w9WAvCnE4c1WabemNQkB4NyzVzXJVsLW7fY9m7cxeZy8fMm02mxstyd+5lu24kuPQd+8SX86J/hPyaSY8PqlpdD/O3rLvF3Lk/LBocreL3NFsx2f/tE7fdJoti9MngcL5UFUl+oTLfNVqOZmoJuiXPlhf4DX8LPb5Y6rCw31C8vT+ATggq6Rdqp4d0zGd0zC3e1j7cWb2fR5n385pUlAFxyWB+uPKpfq19DJeZhGnaq+cVRuBk2fxW8PlBa3kQTtfYs3T9nvrXN1CqKoHy/Oe7YK3h9IOje3Lrnj5TAfu4G9ryPPMvMJN2/ETbMatt1RcLu5cHjAwq641aoTDfUKOFM3GySHCQqCoPHCZz9lAZYncuTOpiKNajxsylxT7Ao6BZpx86dZIKPp7/exJXPLKTK42XGsFxuPXVEs/dwNyTYwVzN1BqVlBZslFWzdDhfQTdp/qC7teXlVml5aidIzgheH6+Z7g559W9LSoNx/jFzCxJwfJgy3YkhVKYb2kWzIjlIWCdZAapKYrcOibzKOk3UoF2MNFTQLdKO/WhMd1JdDrbtL2d/mZvRPbN46PxxOOytD7gh2MF86bZCvA10SZcaxl5kLpe/HezKaTWdampcWHtmlZe3tpFaQ6XlEH9Bd7E/6A7V3d1qRrduptnXlkh2rQgeK+iOTz5feJnuBP5gKweJQHk5er+2NxU1xoVZXP6fVyovF5F4lJHi4uTRZt92j46pPH7pRNKSnBF7/iFdM0h22imu8LBpr37pNarnRMgZYj7wLn/LBFQFq8xtB3OmO1KN1BIl6A7M6G4g0w2QMxiSMkyztX0b2m5drVVxAIpqNE8r369saTzyVAaPG8x0W7Nw9fNc4pzKy9uvhjLd7eCEoIJukXbuhhOGcPXUAbz000PJzWjgQ1YruBx2Rvhney/Vvu7G2WzB0uHFz5txJ163+aVSN1A8mKRFaE93IOjuU/v6Tv6vy/aYLrexVtxIeTmY90mXwebYOimTCKzS8sweZh8eKNsdjzw19kM2munWCROJc7Uy3e2ovDw1Fffixcx66CFIbeD/6MHA2tOd0kB5ufZ0i0i8ys1I4YYThtI7Oy0qzz/G30xt6Vbt627S6PPA5oBtC0y2G8x86wjsr09Y6RHqXh4q052SBan+sXjx0EzNynRnhAi6AboMNZd71kR/PZGy219anjvcBN6gsWHxyNrPbbPX7p5vcamRmiSIWnu629H71W6HESMo7t3bHB+MKhrJdKu8XEQOVmMCzdQKY7qOhJCRB4OOM8fzHjaXB3NpOdQYGRah8vKsXvVvi6cS80B5eYg93WBKzMHMvU4U1n7u3GGQ5Q+6lemOPzX3czd0ss+qUlCmW+KdysvbL6u8PCUreJ0aqYnIwc5qprZ8RxHu6gScLdzWrBJzjz/jlDcidmuJB4Hy8ijt6Yb4Cbp9vhojwxrLdA8xl4kUdFvl5XkjamS6FXTHHas00xWibLUdZJPkINFey8urqrD/5S8MeeklqEqwZpqRokZqIiL19c1OJzPFSaXHy+r8ONgzG+8GHR/M7gJ0HRW7tcQDq7y8ohCq3S17jspiKN9njjvGcaa7siiYaWws020F3XvXgrc6+utqLZ8vOKM7d1gw6C5SeXncCYwLCxF0uxK/WVFcqTgQ7OMgkdVeM91uN44772ToK6+Au4W/ExNdpX+7YoON1BR0i8hBym63aV53cziTYPS5/i9sJkg5mKV2AvxlrmX7WvYchf4Z3Skda5ejWeIl6Lay3MmZwQ8QDenYBxzJphrCyuDHs5JdZn+lzW469Gcp0x23AuXlIZpqJiV+CWdceeI4+OeEYOZOIsPn08iw9qyikfJyZbpF5GAWmNe9tTC2C0kUEy41H3p7Hxr8kHuwsjsgzd/orKX7uhsrLYf4CbpLmuhcbrE7IGeQOU6EEnNr3nznAWYMVSDTvSN2a5KGBTLdIYJul8rLI6babSYQVJVAYRw0cWxPqkrN9I+aX0v70djIsAT+2aSgW0RaLdDBXM3UwtNlCFy7EC54JdYriQ9prexgfsCf6W4q6C7cDN4Y9h0I7OdupLTcYjVT25MAQbfVuTxvuLnM6mku1Ugt/tRspNYQZbojp2YmtqVVPNKwmqXl0L72dEvje7pVXt4yn3/+Oaeeeirdu3fHZrPx9ttvN3r/OXPmYLPZ6v1ZtSqBZpmKtENWB/O1u0soq/LEdjGJomOvhkuhD0bWvu6WNlOzskihgu7MHmB3QnUVFO9s2WtEQriZbgiODStIgLFhVhO1XH/QbWW6K4tUVhtvlOluOzVHWtU8ltareUIDdJKovWko0x0oL0/cf+uYBt2lpaWMGTOGhx9+uFmPW716NTt37gz8GTRoUJRWKCLh6JqVQm5GMtVeH8t36EO2NJMVdFsZ0+Zqqrzc4QyOEotlibnVUCmcTHcXa2xYApxUtsrLraA7uUPwhJKy3fEl7Ey3gu5WqxV0K9MdUfUy3YkbiEkDKvz9gVIaKi8vb/v1REhMg+4TTzyRO++8kzPOOKNZj8vNzaVr166BPw6HI0orFJFwBUrMta9bmmvYj8zlgv8Ef9k2R1NBN8THvu7AjO4wMt05/g7me9aYpkHxylsd3HduBd0Amf4SczVTiy9NZbqTEj+bFDdqBtoqL4+seplulZe3KxWNZLoT+ISgM9YLaIlx48ZRUVHB8OHDufnmm5k2bVrI+1ZWVlJZWRn4uqjI/EO63W7cB2srfmmQ9X7Q+6JlRnbLYOaKXSzZsr9dfg/1/oiiwafgzBmCbc9qqr9+BO9R1zfr4c7CLdgAd4fuIUes2LN64wCq967HG+F/w3DfG46indgBT2o2vqbWkNkbp82BrbII9/6tkNEtQquNsH3rcXnK8TlT8WT0DHz/HRndsO9ejmf/5qb/ru1YvP3csFeW4AC8jmSqG1iTzZ6EE/BVleKJkzUnKlvJnsCH7OrSPfV+7sTbeyORWN9bn82OzefFW1nS4Ps5ITkcVH/+Od988w2THI6Db2yYpxJXtYnb3I604N/floQL8Lnj72dTuP+HEyro7tatG//5z3+YMGEClZWVPPfcc0yfPp05c+Zw9NFHN/iYu+++m9tvv73e9bNnzyYtrZGRLXLQmjlzZqyXkJAqCm2Ag/lrdvLBB+13Pq/eH9HRvcMMJu1Zjferf/LJ/r54nOF1dXdUV3KKvwHbJ9+sxONseMTWwF0VjAB2LJ/Hd6UfRGrZtTT13jhm1wYygG9WbGbP1qbXMD2pCx0q8/n2/ecoyBwZoVVGVrfChRwCHHDlMfejjwPXjymspi+w/ru5rNqZE+rhB414+bkxeOcPDAO27Chg6Qf134NZZRuZClQU7eOTBm6X8A3Y/RXW/9rta39gcVXD3894eW8kkgG75jMSqHBmkereT+n+Xcxqb+/XQYOYOWtWrFfR5pLcRZzoP/5g1pdmFCXg8pRyEmDzevjwvXfx2eMnhC0rCy/7Hj8rDsOQIUMYMmRI4OvDDjuMrVu3cv/994cMum+88Uauu+66wNdFRUX06tWLadOmkZ2dHfU1S+Jwu93MnDmTY489FpfLFevlJJwjyt08unI2eyptHD71WDqmxe57+ORXm3j8y00cOSiHs8Z3Z1KfTthstlY9p94fUeY7Ad9/Z+EqWMkJWevxTvljeI8rWA3fgy85k+N+dHbIu9lWuuHNV+iR5qbrSSdFaNFGuO8N58pfAnDIMT8yHeyb4Ch9CdZ8yOQBnfBOiuyaI8X+xXLYCJmDDuWkGt9X+5crYe5sBuWm0T/C3+9EEm8/N+yzF0E+9Oo/mB7HNfDvsmctrL6VFEd1rX9PaT77nCXg313Rs3Ma3ep8P+PtvZFI7HOWwA5Izh0A2xfSIcnWrt6vB/V7Y996WAa+pA6cdPIpweurq+CHXwBw4vSjIbVjbNbXAKuKuikJFXQ35NBDD+X5558PeXtycjLJycn1rne5XAffG1nCovdGy+S4XPTNTmPT3jJW7irl6MFdYrIOn8/HE19tpqCkircW7+CtxTvok53GWeN7cuaEnnTvGKKBEFDhribZaW80QNf7I4qm3QivXoJjwb9xHH5NcH53Y0rMLGhbxz6N/7vkDADAXrgZe5T+/Rp9b7jLA/vVXZ16QDhryB0Gaz7EsW8djnh9z/lHmtm7jqz9fe1k9tfbS3ZG7fudSOLm54a/bNORnN7weyrN7KG0VZXFx3oTWWVh4NBeURjy/0HcvDcSSZUJcuxZPWH7QmxVpe3ne1hVhf2hhxi4ahWuGTPaz98rXB6TNbalZNX+u7tcZgqJ14MLd3i/Q9tIuP9GCR90L168mG7d4nSvm8hBZkyvjmzaW8a3m/bFLOhelV/M7uJKUlx2fjymB+99v4PNe8v4+8w1/OPTNRw5MIeJfTqzr7SSgpJKCoqDf0qrqpk+NJfHL53Y6sy4tMDQUyFvFOz6AeY9AtNvafoxTY0Ls1iN1Ep3m063SeGVr0eM1UTNkQwpHcN7jJUNL4jjWd1Wx/ncYbWvt8aGqZFafLE6/7pCnHy0RoZ53VDtBkf8fLBNOOpeHj1WI7Usf8PG9tS93O3GceONjADcDzwQ69W0vYbGhVlc6VB5IGGbqcW0e3lJSQlLlixhyZIlAGzcuJElS5awZYvZk3fjjTdyySWXBO7/wAMP8Pbbb7N27VqWL1/OjTfeyBtvvMG1114bi+WLSB1HDTKB9hNfbmTL3tj8UJy7pgCAw/pnc89Zo/n25hn8/ewxHNq/Mz4ffLF2D//36RqembeZD37I59tN+9m0t4zSqmoAPlu1m4+X58dk7Qc9ux2m+svKv3kMSvc2/ZhwOpcDpHYKjrHav7nla2ypYn/QnZEH4Z7QyfGPDdsTp0G3uwL2rjfHuSNq32Z9GC7aHt/d1w82Hn/3cmeo7uUdgsctCWSqPbBtkbk82JWpe3nUWCc0rJ8zXjd4qmK3Hokcq3N5SgNBd2BsWGKeZIlppnvhwoW1Oo9be68vvfRSnn76aXbu3BkIwAGqqqr4/e9/z/bt20lNTWXEiBG8//777Wofh0giO2NcD15buJVvNu7j968v5eWfHord3rYZ47mrTdA9xZ9pT0tycuYEU1q+ZW8Zby7exo7CcrpkJNOlQzJdMlLMcUYyr3y7lcfmrueuD1YxbWguyU6NI2xzQ0+GrqMh/3uY90+YcVvj9w836AaT7d651IwNyxve1L0jq8R/IqdDGDO6LVbQXVpgPrSHU27flvasAV+1ydzXnT2e2d1cusvMB+R4W/vBqqlMtzMpUMKJu6z5+yYXPwfv/QYGnwjnvWhOpB2sama6KwrB6z24vx+RZM3ptipqwIwNc+rnTMJrNNPt/7mVoJnumAbdU6dOxdfIGfCnn3661tc33HADN9xwQ5RXJSItZbfbuO+sMZzw4Ocs2LiPp77exBVH9muz1y+p9LBws8koTBmSW+/23tlp/GbG4JCP/+UxA3nzu21s2VfG019t4udTBkRtrRKCzQbT/gQvnQff/AcOuxbSG+l+3ZKguzBEpnvNJ1CwCiZfZYKPSKqZ6Q5XcgfI6gUHtpoS8z6HRXZNrbV7pbnMG1E/e+9KhbRsKNtrst0KuuNDU5luaF0JZ8Eqc7nmQ5h9J0z/c/Ofo72oGXT7vCZQ1P+DyLDKy9NzzJad6kpTmaHvb+JrLNNtzep2J2bQrVNuIhJRvbPTuOlks7/z3o9Wsb6gpM1ee976vbirffTunEbf7OaPBExPdnL98WYf7T9nrWNPSWWklyjhGHwCdB9nSsi+erDx+waC7l5NP6+1r3v/pvq3ffcsvHg2zLwFXr4g8mfSW5LphvguMd+93FzW3c9t0b7u+NNUphtaV8JZuid4/MXfYdkbzX+O9qJm0N3Q19JyVqY7pWOwP0d72tfdXrkrmt4G4G842mCmO/CzSUG3iAgAFxzSm6MG5VDp8fK7V5fiqfa2yevOXbMbMKXlLW2Edub4nozskUlJpYd/zFwTyeVJuGw2mPonc7zgv1Cyu+H7VZVBmf9DfriZbqgfdC96Bt79pf+17bBuJjx/RjCbEgktyXRDjWZqcfhetDLduSFK9a2gu2hb26xHmhZWptv/wbYlQUyZvw9Djv99+/Y1sGNJ858n0XmqTLkzQFKGuVTQHRk+X/Bnc2qnYB8CBd3xzVMJD0+Efx/deJ+PysYy3dbPJgXdIiIA2Gw27jlzNBkpTpZsLeTfn2+I+mv6fD7m1NnP3RJ2u40/n2KaQr28YAur8sObv5io9pRU4vXGYaOrQcdCj4ngKQ+d7T6w1VwmZ4bXEbyhoHvR0/C/X5njyVfB5R9CchZsmQfPnAIlBS1bf10tzXQHgu5VkVlHJO2yOpeHCLqzrKB7R9usR5rm9gfdrkaC7qRWfLC1gu5j/wIDZ5j/vy9fGPrEWXsVCLBtwZ87aqYWGZXFppcEmJ4DgUx321XVSQsUrPZvlVoJxTtD3y9QXp5V/zZXYjdSU9AtIlHRvWMqt55qgtcHPl0T9eB1455Stu0vJ8lh57AB2a16rkP6deakUV3x+uCO91Y02nsikT3x5UYm3vkp938Sh6XLNpuZ2w3w7eOwfVH9+9Tczx1OZUPNoNvng4VPwf9+ba6b/As44W/Q+1C4/H1I7wL5P8BTJ0Dh1tb+bYIjwzo0M9NtZQz3xFmmu7wwmMFWeXni8PjLy52NlJcH9k22ItPdoQuc+QRkDzTvk1cuPri6S1tBd2pHSPf/PtLYsMiwSssdyWabRHsrL09JwTNzJl/ecQekNHJyLNHU/B1mTb1oSGUY5eXKdIuI1Hbm+B7MGJaHu9rHda8spcoTvTJza1TYpH6dSE9ufY/IP54wjCSHna/W7eWzle0vS/PRsnzufN9kKl9ftC0+s90DpkP/aaYk9tnTYMv82reHO6PbktXLlI97KmDuPabLMsChV8MJdwcD966j4CcfQ1Zv2LsOnjy+9eXdrS0vP7AVKluYydm/CTZ+3rLHhmJl3jN7hO5wXXNsmMSHaGa6fb5g0J2WY94X579sPjxvnQ8f/P7gGR9nBdipnc0fUKY7UgKl5R3NZXsLuh0OfFOmsHfUKHC0owkqNau19jUSdIeV6S6P3LrakIJuEYkam83GXWeMpGOaixU7i3h41tqovZYVdLemtLym3tlp/MTfef2uD1ZG9YRBW1u6tZDfvLI48Pl3d3El328/ENtFNcRmg3Ofgz5Hmn1ez50BG78I3t6czuUADlcwEJxzt7k89Bo4/q76mfLsAfCTj0wjs6LtJuPd0r2p1R4z9guaX16e1tlk3aHl2e5XL4FnToXN81r2+IbsspqoNTJ6LZDp1p7uuGFlul2NNJpMamGmu6o0uGc8zZ/dzRlkMt7Y4LtnTNXKwSCQ6e4U7KitTHdk1GyiBsE93QlacnzQKKhRUddopruRkWEt/dkUJxR0i0hU5WakcOdpIwF4ePY6TnzwC3710mIenrWWj5bls76gpNWN1irc1czfYDIsUwbXHxXWUtdMG0BOhyQ27CnlhQURKDGOA9v2l3HFMwupcHuZOqQLJ4wwQeDMFfkxXlkIyRlw4Wsm4+0uhRfOgnWfmdusoDsrjM7lFqvEHMw4suP/Gro0PauH2ePdbazJ4D37Y9jXgv4EpQWAz2TZGxt/FkprSswrisyYNIClLzX/8aEExoU1EnTX3NN9sGQ4452VIWpqZBg0P9NtZbkdycEPxwCDj4MZt5njD/8QfO+0Z1ZWO02Z7oireUID2l+m2+3G/uij9PvgA3C7Y72ayKn5+6ux36ONjgxTebmISKNOGd2d8w/pjdcHK3cW8e7SHdz/yRquen4R0/8+l+F//pjpf5/DJU8u4MY3f+CR2et4e/F2Fm7ax84D5U3uqV6wcR8Vbi9dM1MYnNchYuvOSHHxu+NMwPPw7PWUJvjvv6IKNz95+lv2lFQytGsGD18wnhNHmaD7k+W7Yry6RiSlmTLVwSeYTNpL58HqD4N7rcPNdAP0OtRcHnYtHHdn03vB03Pg0v9B9/Emw/LS+cEPBeGymqil54K9BeWCXfxjwwpasPd+17Lg8Yp3IrevdncTTdQAMroDNjNDt+YoKTGqPW37ej5fM0eGtTDoTs+p///qiF9D36NMA6ya1SrtlTLd0dPey8urqnD8+teM/s9/oKqd9EGo9tTObrc002393ErQTHfrNz6KiITh7jNGcdWU/qzdVcLa3SWs3V3Mut0lrN1VQrm7mvUFpawvaPgH6cmju/HP88ZhtzccINUsLW/pqLBQzpnYi2e+3sSq/GIeWu6g8+DdHD+qe8RfJ9rc1V6ueeE71uwqIS8zmacun0SHZCdTh+TitNtYu7uEjXtK6ZeT3vSTxYIrBc55Dt64Ala+C69cBHb/r7DmBN1Tb4Txl4Q319uSkgnnvQj/mWr2pb35M/O1Pczz1i3dz23pMtRctiTo3vl98LiiENbPgiEntGwdFp8vvKDbmQQdck0TuaJtprmWGMvfhrd+Dqc9CiPPaJvXrK4C/CcwwxoZ1sweAoH93J3r32azQfexsOmLxvdzthfa0x099crL1b087u3fCN4aWYt9G8Drbfh3aGOZ7kB5ufZ0i4g0qk92OjOG5/GLqQP4xzljeffaI1l++/F8ccM0XrhyMveeOZpfTR/EmeN7cmj/zvTqnIrdBu9/v5MXFmwJ+byBoHtI5D/UO+w27j5jFFmpTvLLbVz14hLOemweCzYmzgcon8/Hn99Zxhdr95CW5OCJSyfRLcucMc5KdXFof7P/Mm5LzC3OJDjrKRh1Nng9wf2jzQm67fbmBdyWzG5w3gumdHbNhzD7r+E/tqXjwiw5/kz3nhYE3fn+oNvqVr3s9ZatoabifJPJszmCawsls7u5VAfz2n54zbx/ra0SbaHmB9VGM92tLC9PC7GFovMAc9mSLRqJRpnu6KmX6dac7rhnNVHrOsqcLK+uDE6/qMldYW6DEJlulZeLiLSY3W6jV+c0jhiYwzmTenHdsYP5+zljePlnh/HFDcdwyykmk3b3ByvZuq/+D9pt+8tYt7sEh93GEQNbsF82DON6d+Kz3x7FjB5eUlx2Fm3ezzn/nsflTy1gxY74n+P9n8838NKCrdht8M/zxzGyR+2uoMcONxnYmSviuMTc4nDC6f+GsReZr1M7B/f2RVvPifCjh8zxF/fDsjfCe1yrM93+Pd37NoKnsnmPtfZzH/oLc7nqg9Z/OLWy3NkDGu+CDcFmaprVHeTzwbZvzfGB0CcTI846SYUNHEmh7+dqYXm5tYUgLcTIxmx/0N1YaWl70dCebitYlNaxMt3tdU93e2RVaeUOD/ZVaejnQGWNz1PJGfVvVyM1EZHoufSwvhzSrzNlVdVc//rSeqOtPl9jPuiN69WRrFRX1NaRleri1N5ePv3NkVw4uTcOu43Zqws4+Z9f8NtXllBa2cb7M8O0bX8Zf/vInGX+8ynDmT6sfuBnBd0LN+9nT0kzg7pYsDvgR/+EUx+Es58Kb0Z3pIw5z+wHB3j7mvA6mrc2053RzZz191U3L2BxVwQzDBMvNx923KVmP3xrBErLQ8znrikwNkwdzAMKNwfntrdlZ/ea+7kb+z/T0iCm5p7uhliZ7sLNbb+fva3VzHRbGVmVl0eG9b1VeXnisJqodRkC2QPNcUPbTCpq7OduqP+JVaGjTLeISOTZ7TbuP2sMqS4H8zfs4/lvNte6fe4aM0M7UqPCmpKXmcJfTx/Fp9dN4ZTR3fD54K3F27nv4xaU/raBZduL8PlgeLdMLjuiX4P36d4xlZE9MvH5YFYMZpIfKHczd01Bkw3zarHbYcJl0H9qtJYV2rF/gYEzzPilly+Ekia+Z63NdNtsLSsx373ClOGndjYd3keeaa4PN0MfinWiIW9k0/cNjA1TeXnA1m+Dxwe2m72NbcHKdDe2nxtqZJNaWl4eItOd0c1sc/B6TODdngWC7o7B8nJ3afMrVaQ+lZcnHivTnTMkePJtbwPbTCr9o0sbKi2HllfhxAkF3SIS93pnp3HjSaaZ1N0frGLzXvPL1V3t5at1/lFhUdjP3Zh+Oek8fMF4Hr9kIgDPzd/M6vziNl1DODbsMWf/BzXR1f244f4u5jHY133/x6u59MkFvL4oQbKhdoeZPZw9EIq24XjjcmzeRjJ3VlazpZluCJaYFzRjbJi1n7vbaBO4jzzLfL12ZjAoaC6fDzZ/ZY57H9b0/QNjwxR0B2z9JnhcXQllbdTZPZzO5dDyfZONNVIDc6Ksc39z3N73dQeC7s6QnGXGBYKy3ZEQspGagu645PXCnrXmuMsQyLZ+BjSS6W6oiRq0/IRgnFDQLSIJ4aLJfTi0f2fK3dVc//r3eL0+vtu8n5JKD53TkxjZPavpJ4mCGcPzOH5EHtVeH7f/b3nzsrVtYIO/I3z/nMaDbqvE/Iu1eyiratvSz2U7zNntz9cm0Fip1I5mjFlyJvZt3zBsZyMNygJBdwsz3VAj6F4V/mOs/dzdxpjLvOFmT53XDSv/17J17NsAxTvNnuCeE5u+f6a/vFyZ7qBtC2p/bY2+i7ZmZ7pbWF4eqpEaQGd/tU1739dds7zcbg/uP1YztdZr7yPDkpPxvP0282++GZKTY72a1ivabn6W2F3QqV+NTHcje7qbynSrvFxEJHrsdhv3nTWGtCQHCzbu45l5mwJdy48elBNynFhbuPnk4SQ77Xy9fi8fLYuvDuAbCkymu3+XxkeBDe2aQa/OqVR6vIF98m1l6z6Tgft24764O2nRqJxB8ONHAOi7Z3bDZ999vmDQ3dLycjBleRDcGxcOa1xY19HB60b5s90/tLCL+Sb/jOWek5rOmEIw0128A7zVLXvN9qSqFPL9s9Oz/F30D7RR0N3sTHczg5imGqlBsJlaex4b5q4I/iywsv4aGxY5NU9oQI3y8nayp9vpxHfSSeyaOBGc7WCys1Vanj3ANEK1fgbs31S/t0OTmW6Vl4uItIlendO48STTvOmej1bx7lLTEbmtS8vr6tU5jZ9PMb9I7nx/JeVV8RNcbNjjz3Q3EXTbbDaOHWbKn9uyi3l5VXWgeVt+UQXbCxNs/ubQU/B17IPLW45t1Xv1by/f75+PTCsz3dae7rXhBa/VHtjlD+66jQ1eb+3r3vRFcK95c2zyl5b3PTK8+3foakprvZ6m974fDLZ/ZxriZfaAXoeY69qqmZqV6W4q6E5qZXl5qEZq0HiWq72wgkKbI5ix09iwyPB6ocK/71fl5YnB6kNi9SXJ7GlGb3rd9U84hp3pLjUntBOMgm4RSSgXHtKbIwZmU+H2sm2/CdCOGhTboBvgF1MG0D0rhe2F5Tw2Nz4+UO4rraKwzA2YPehNOW6ECQo/W7ULT3XbNHfaXlj7g/3CTS3caxwrdjve0eebw6Uv1L+92F/5kNoJnK0oFezYx3xQqa4MrwnV3rUmyErqENxHC6aDec9J4PPC8reatwafDzZ9aY7DDbodTtNAC7SvG4Kl5T0nBTu7t3Wmu6nyclcLysu91cFg82DPdFuBdWqnYJd4Zbojo7II8AdbgfLyFlZmxCu3G9uzz9Lrs8/A7Y71alrPynR3MX15TG8H/zaTuj8Hmsp0W0E3vhojEBOHgm4RSSh2u417zhxNepIZJzGqRxY5HWK/7yk1ycFNJ5uZ4o/NXd/gTPG2ZpWWd89KIS2p6TK1iX060THNRWGZm4Wb2yb4tUrLLd9uSrwPpd4x5+PDhn3zV/UbRLV2XJjF7ghmCgrC6GBu7efuOsp8yKnJaqj2w2vNW8O+DaZM3JFkgsZwZXY3lwq6Yas/6O51SI3y8jbKdIdbXt6STHf5foLBUKfQ9wuMDdsCnqrwnz+R1C1/BmW6I8VqouZMDZ7EtMrL3WXtYwtLVRXOK69k/D//CVXt4P9IzXFhFmtsWN2Kl6Yy3Uk1kgfuBKuKQ0G3iCSgnp3SuOO0kTjtNs6Z1CvWywk4aVRXDuufTaXHy10frIz1coJN1Lo03kTN4nTYmT7UZLvbqsR8637zwT7VZU6iJFymGyCzB7szRpnjxc/Xvq2148Jq6tKcoLuB/dyWEaebku/tC2HfxvBf38py95gY3n5ui8aGGT4fbPOPC+s1ue33dDe3kZrXDdVhZtqs0vKUjuBwhb5fRleTSfd5TeDdHlnZ7Jpd3K0AXJnu1qnbRA3qBGKxP9ktdRTUKS+HYPVV3aA7sHUgRNBtd5iKL0jIygYF3SKSkM4Y35OVd5zAxYf2ifVSAmw2G7f+aDgOu40Pl+Xz1bqWNSTbtr8sIuXd4e7nrsnqYv7Jivw2aWpmVQQc7y9tX72rmANliVdStyX7aHOw5MXazWEilemGYDO1cILuwLiwMfVvy8iDvkeZ4+bM7N7czP3cFquM+mDPdO/bYIJTR7I5GWJ9X9qqe3nYjdRq/LwI94NtOE3UwJRbB8aGRbHEvNrTdhUEdTWa6U7Ak4rxpKHvrTMlOJItAQOxdq10j7+6w2Yaj1pCbTMJBN2NTKNJ4GZqCrpFJGG5HPH3I2xo18zAiYDb3l2Ou5nB81uLt3HkPbN56LO1rV5LoHN5GPu5LUcPziHZaWfrvnJW74r+3HFrX/6YXh0DJwcWbUm8bFB+1jh8qZ3NOK31nwVviGSmu6s/m77pC9NQKBSfL5jp7tZAphtg1NnmMtygu9Z+7iPCe4wlkOlOkDns0WLN5+4+DpxJ0NGf6S7f1zbBQriZbmcS2P3bUcL9YBtOEzVLW4wN++B38H8jYMs3Td830gJ7umtmuhV0R0TdGd1gTuQEOpgr6I4r1ojLjr1rn+wL1VAxUF7eSNDd0ukKcSD+PrGKiCS4384YTKc0F2t3l/DcvDCaXvlVe3089Nk6AD5a3vrRY8FMd3jl5QBpSc5AY7pPlke/xNwqL+/VKY1JfcwH028TsMTca3fhtQLZ754N3hDJTPeAaZCUYcqRtzYSTOzfBJUHzN5rq3lNXcNONbfvXgG7VjT92vs3mky13QU9D2neuq2xYQd7pjuwn9u/Hz4lK7h3sS1K78PNdEMw2x3uB9vAjO4mMt3QNs3UtvrL+Hcsjt5rhNJQNlbl5ZHRUHk51Ohg3k7GhrUXgSZqQ2pfn12jt0PNLSxNNVKDYNCtPd0iIpKV5uL6402w83+frmFfaXjNUD5duYuN/kB5za4S9of5uIZ4qr1s3tv88nKA44a33b5uq5Faz86pTOxrPpguTMBmagDeMReZgzUfQYmZIR/RTLcrFYadYo6XNTJn22qiljs89P7a1I4w8Nimn8tijQrrOTFY3heuTKtLt4JuwOzntrRlB/NwM93Q/I7QZVZ5eefG7wdtMzbM+n4W74zea4QS2NOtRmoR11CmGzQ2LF411EQNzEQLV5oZn7i/RmKiqUZqoPJyERGp7dxJvRjeLZPiCg+PzlkX1mP+83ntztet6eS9bX857mofKS473bOa0fQKmD4sF7sNfth+gB1RnJtdVOHmQLk5y92rUxqT+poPpku3HqDCnYBdaHOHQY8JZib19y+b60r8QXckMt0Q7Dy+/O3QTa7ymygtt4zyz+z+4bWmu/42d1RYTVamuyS/9n73g0llsakqgNqVAm0ZdDcr093MD7aBQDOM8vJoZ7rLC4Mf3otbXzHU/NdvKNOtkWEREch01+mQr6A7PgWaqNUJukP1dggr0524/9YKukVEosBht3HDCeYXzTPzNjcZvC7avI9Fm/eT5LAzY5jJirYm6N6wx5TZ9c1Ox263Neux2R2SmdDHfKh5Z8mOFq+hKdv8We7O6UmkJzvpk51GTodkqqq9LNt+IGqvG1XjLjaX3z1n9kEHgu4IZLoB+k8xgU3ZHtgwt+H7WJnuhpqo1TT4RFPiXLgFVr0f+n4193P3aeZ+boD0XLNH2OeNTeYxXJ5KWD87KicGbDu+A3xmb2PNqoe2HBvWokx3mEF3uI3UIJjpPrDNfM8jrWZX9OII/vw6sN38X2hKU43U2qBBZbsV+N52rH19YE93ApWXu8sb3uOfnIznxRf59vrrITn241BbJVSmGxruYB5Opts6aahMt4iIWKYM7sLkfp2p8nh58NPGG6P993Mzuum0cd05ebTJii5oxd7m4Liw5pWWW86d1BuAJ7/aGLWsc3A/t/klarPZmOQvMU/Efd0AjDzTZAn3rIYNs4MfAiNRXg6mXHzEaea4obJwn6/GjO4mgu6kNJj0U3P81QOhg4H9m6Bom9nP3auZ+7nBzAnPsGZ1R+8kTqt99RA8dxrMvCXiT23b1kBpOdTIdLdB0N2cTHdg9nEz93SH00itQ655fp+3dmlppNSsGohUpnv5W/B/w+Hz+5u+byAwbKCRmq862KFZmq+9lJf7fPDC2fD3YcEtSBanE99ZZ7HjiCPA6YzN+iKhoijYx6PmuDBLYFa3vxLQXQHV/i11jWW6m7v1JY4o6BYRiRKbzcYNJ5i93a8t2sq63Q2fhd+4p5SPV5gPhz89qn+gzHr59gOUVbUs67beCrpzwm+iVtOPxnSne1YKBcWVvPlddPbiWuPCenYK7hGe6P+7J+q+blIyYfhp5vjzv5tLVzokZ0TuNawS85Xv1W8mU5wPpQVmhE7eiKafa/JVJvO5fVEwm12XNSqsx4TaM3GbI9BMLY47mFtd5799POJjvGzbFpqDuk3orEx3W4wNszLdzSkvDzfTXdaMTHe0x4YVRiHoXvepuWysgaGloUy3KyX4PdW+7pZrspFaggRi2xeZKRSe8uC2k/Zmjz/R0CGv/r8X1N9mYmW5sZmGoaFY5eVt3Uhtw1xY9xmU7m3xUyjoFhGJogl9OnHs8Dy8Pvj7Jw3PV37iyw34fHDM0FwG5WXQs1Ma3bNS8Hh9LN5S2KLXDYwLa2GmO8lp58qjzAfjf3++nmpv5EsirXFhPTsHgwAr071w8368UXjNNjHeX2K+2R/ERirLbek12QRrVcWw5uPat1n7uXMGh9fwrEMXGHuhOf7qgYbv09JRYTUFxobFaTM1TxVs/84cV1fB5/dF7rl9Xmzb/d2061YKWGPDwt3TvWct7F7VsnVY5ZjOcDLd1p7ucDPd1p7uMIJuaLi0NFJqfi8ri6AyAiXH1gi+mqXrDfH5anwv6jSVC+zrTtAqnnjQZKY7QcrLFz0VPLb+ThaPB9vrr9P9q6/Ak8A9MPZY+7kbyHJDjYaK/l421n7u5AxTHRVKrBqpzboDnj8jeBK6BRR0i4hE2fXHD8Fmgw+X5bN0a2Gt2/aWVPLaQpP9+9nR/QPXT+pnPqAt2NiyrEhLxoXVdd4hveiY5mLz3jI+XBb5vbjbaowLswzrlkmqy8GBcjfrChLkA1RdvQ8LfqCAyDVRs9jtMPIMc1y3xDzc/dw1Hf5Lkxlf9ynk/1D7tlrzuVvQRM0S72PD8n+A6kpw+PdQLn4+YgFhRsVObJVFJtOZN7L2jVZ5edGOppvZuSvg8enw+IyWZXncVqY7jD3dgWZFzZzTHW7QHc1manUD45JWTmHwVMHulcHnbmxPtrvcvI+gfrMvq5u5Mt0tF7KRWgLN6a44AMveDH5dd193ZSXOCy5g0n33QWUUeh60lcC4sBBjK62fAQe2mp9N1raLlEZmdEPs5nQX+T8DWSeQW0BBt4hIlA3Oy+CMcebD9b0f185SPTd/M5UeL6N7ZjG5XzAzYpWYt6SZWnGFm4Ji88u6pZluMDO7Lzu8LwCPzlmPL8INgALjwjoFM28uh51xvTsCrWskF1M2G4y7KPh1pDPdANZM8DWf1N4jGtjP3UTn8po694MRp5vjLx+ofVvhZvOhyO6svx+5OTLbcO9yS1hlwwOmmVFqvmqYe29EnrpTmX/PYo8J4KizR7NDV7A5wOtuOjgsWGX+rauKm864NsTjD9Sbk+kO54NtVVkw6xR2pjuKY8Pqfm9a27yvYKX59/l/9u47TK663AP490zd3kt2s7vpvTdSgEBIQu9FkaqCiHpFReRer+gVsV31WhCl2ABRFARBSEAIJBAgAdJ7L7vZ3WzvZeq5f/zmNzO7O+XMzJmym+/neXh22J05c3Yz2cx73gaIn2FPU/D7yoDaYPYFghInmMduJJSX73puYJZWfk8jTaghagCQWewpI1fF3BCb59+xUEPUgMg3K+jB7fL9Hskpj/owDLqJiBLgq6smwWI04P0jLXjvsOh/7He48PQmMUjoc+eOh6L4poyf5QnAt1e3w+FyR/Rcctd3UZYVOWlB9jRrdPvSsUg3G7G3rhMbPeetB1VVfYPUCgaWQfv6uodxGebcm0QwBeif6QZExrRoisiq7X/V93nvurAIMt0AcPZXxMe9L4o3QNIJHfq5gdTPdHsHnZ0FXPAtcXvX36Mv5fZT0O3pbaxYNPSLRpPvTVy4CxL+VQjRrBiLKNMdQXm5zHIbLdpnF3gz3cdC3y8a8mcjs6GdMQbdsrRcCnXBw7+f2+/3OYCBE8wpcm6XLzAbruXlqgpsfVLclhndkfp6aApTXq4oQKHfbAct68IAv/LyBPZ0dzeKC7GKUQyCjBKDbiKiBKgsyMDNS8RE8P99/QBUVcUL206htceOivx0XDJzYGA2sTgLeRlm9DlcEa/PinVyub/8TAs+dZY470c36JeVaut1oNcuymlH5w3MvPkmmA/jjFD2KGDyxeJ2wTj9j68owCzPQDVZYt7b6gsIRs2K7Hhlc4AJF4iJ0h884vt8LKvC/KV6T3eNJ+iuOAsonwdMvRyACmz4YcyHLpCZ7mCVArka+7ob9vhuR1Mx4F0ZpiXTHUF5uf8QtcGBZjD+a8PkxQA92Ht8FwHkRY5YM92nBwfdISauB+vnBnyZbpaXR8e/oifoyrAUz3TXbhN/j41W33rJwT3dI4GjH2gTG1mCZrqBgRUvWtaFAcnZ0y23bmSPAgzGqA/DoJuIKEH+Y8VEZFqM2F3bgVd31eP3G8U/SnecMw4m48BfxwaDgoVjoisxl0PUJugQdAPAneeOg8mgYNOxFmyv1ueqvJxcXppjRZp54D9i86ryYVDEoLX6Dn2vZjtcblS3JKgs7cqHgUt+6ntzpbeZ14mPx94RV+JlJjR/bOBpseGc/VXxcfszvr3LevRzA2I/tWIAehoHZubD2fok8OMq4A8XAuseBA6vA2xdsZ3LYB2nRAZeMQKj54vPrfhvAAqw72VfyX40+tqQ3e95wxYo0w1oXxs2INMdRdDtXRkWSaZbS9AdYT83IFaLWXMgSkuPa39cOPLnYs3xvdmPdYK5/POXP5NQa84CTS6X5OdYXh4dGZyaM8XqRH96lZd3nY7t73s4W/8oPs64RvyeBiLLdHfWAX+8WJSop7LWo+ICrjVXTC8PRq4NiyrTncDy8i7P7/AYSssBBt1ERAlTmGXF5zzD0v7rhV043tyD3HQzPrGwMuD9zxon3qR9dDyyQPeoHKIW5bqwwcrz0nH1PJGpfOwdfbLdsrTcf12YlGU1YXq5+IdX7xLzh986jOU/XY9XdyVgX3RmEbD4Lm1TxKNROAEony/K3va+FF0/t79xy0WW19kHfPi4CC46qmPv5wZE5m/xF8Ttl76grZf36Hrg1XtFhqvmQ+C9nwN/uQ748RjgiRXAGw8Ax9+N7bwAX5Z71Czfm/fSGb6LGuujz3YrtVsBAGrBeCAzSFAqg+5Qa8NUFTitV6ZbQ9AdSRAT6eRyYNDaMB1LzOXPMLfStxs+lky32+X7uU9c5XmOUOXlnp9FeoBMdwYz3TEJdUFDr6D7L9cDj58Xn/3x/gPUFnza931E0tN9ZB1QvQnY9Ej4+yaTd4ja5NDVL4XRZLo9lTpahzzqoZNBNxHRsHPnueNRkGlBj6e0+pYlVci0mgLeVw5T23KyNaL1WXqWl0t3nyfeIP97bwOONMaeaZTrwirzA5e6yiy/3vu639grhlX9/eME7EVOBP8S82j7uSVFAc75mrj90RPA4TfE7fL5gFWHCzirHwQql4g3V8/dFvpNU8tR4PnbxQWFWTcAV/0GmHOTyJirLqBuG/DBr4GnrgCqN8d2XjV+/dz+zv+myH4feh2o+TiqQ8tVYerg/dz+vGvDQgTS7dW+ftZw9w3Gm+mOoLxcSzapx6+8PBLxWBsmS7/zKoGcMnE7lkx36zHR125KByau9DyHxp7uwThILTbBhqgBfuXlMfR097V7qklUoOVw9McJZvfz4u9T0RSgaonv+4gk6JavncYDgMuh9xnqJ9wQNcm/vFxrptu7pzuR5eWetqhsBt1ERMNGltWE/1ghSqosRgNuXzo26H1njs5FutmI9l7t67PcbhXHm+WObn0y3QAwsSQbq6eLMrHH34k9MyXLywcPUZN809v1y3R39jtwyHPBYNPRFnT0pvCbFq1mXAtAEZngo+vF56INugHRy1wwQZRyvvU98blY9nP7M5qBG/4kptY27AHW3hd4/VJfO/DXT4rMUMVZwJWPiGnw1zwKfHU38NU9wDVPiOFugMjyx8I7RG1QNr9oIjD3U+L2+u9HdWjllCfoHr0w+J1yNQTdsrTc4LlAF+kgNZdDXKwAtGW6vWt5IigvzyyK7JzisTaswz/TLYPuGDLdsnqkdAaQ75nNECro9mb9AwTdzHTHJtiObkCfTLd/+0Z3iAn10VBVYMuT4vaCT4sLnGme18jgnm6LBc7f/x7bvvxlwGIZ+DX52nHZgOY4XBjQi3eIWpigW/4O6KoDuj0Xx8JlupMxSI2ZbiKi4emWJWNwxznj8KNrZ6EkJ/gbYP/1WVr3ddd39qPf4YbZqATNIkfrC+eLfyBf2lGLuvbY/sGr8Wa6AwfdCz3D1A6c7kRnvz7B8c6adm+M53SreHN/jPt7U0FOma/fWg60iiXoNhiBs+8Rt2W5X6z93P5yyoHr/iD6u3f8Bdj29MCvu5zAPz4rMk05FcAnnxnag5xXCcz5JHDOveL/D64JvTs5FEefL7AK1HO9/H6x/unYBuD4xsiO7XZBqRPl5e5QmW5vT3eIYE4OUata6rlvLeCOYKuB/xvUSDLdWjKHvdFmuuOwNkyWl+dViaFHgAi6o319+O+9z6vyPEd18J99sD3SgF+me4ROq463kJluPYJuv4F5PY3RHyeQ2m1Aw24xQG3OjeJz3kz3oNeD2Qz1tttQs3IlYB7Uu+5fJeE/WDHVaM10ZxT4LqLIv2taM90JLS+PfV0YwKCbiCjhLCYDvn35dFy3oCLsfWXGV2vQLYeoVRVkDBnOFqv5VflYPK4ADpeKP7wX2/CjU62ypztwAFCak4aqggy4VbE2TQ/bTorjGA2ix+z1PTFONU4VssQcEOvJYlhpAgCYfaNv+I1iFCXhehp/HnDBt8Xttd8A6nb4vvbmt4Gjb4lM66f+GnrH+YQVImvbXh39G9C67YDbKX5uMqjylz8GWHC7uL3+B5EFbw17odh74DCkhc74yKC7v8NXYjmYzMJNutC31zuSwMDpNyE8kkx3vAapAfFZGyYz3XmVvlV9zv7oJ0R7WzZmiz8nxSCyjMF+9qHKy5npjo38MwxZXh5DIOY/QK1b56B765/ExxlX+14H8jVi79ZeKu4foPtn5lOJ2+XLwgdbF+Zv8O8Ba27o+3sz3UkoL5dbOKLEoJuIKIXJfd0fn2iFquENv6+fW7/Scn8y2/3sR9Xo6IsuA+12qzjlyZQHKy8HfNluvfq6t3omr8vBde8ebka3zanLsZNq2pUiGwuI4CBW5jRgiWfoWcVCffq5Bzv7q8DkS0QA89ytIoOz9Slg82/F1695LHzG3pIp1pwBwIG10Z2Ht597UfCBP+feJwLV6k3AsfXaj73jLwCA5qxpodfMWLN92Z5ge8zlG+zyudr3evuTwbMpXdtaL0sk5eVRDFIDfJnuzlr9slbeQWpV4nUsA5to+rpV1beje9Rs0R4h33QHKzEPNUjNP8hy2iM/nzOdDDhDlpd3x1DV4Jfp1jPo7u8E9rwgbi/4tO/zaX7BpX9ft9MJZe1alG7ZAjgH/fs0HDLdbSfE73VTWuALmYPJ3wNSWpigO9GD1FSV5eVERGeCeVV5MBkU1Hf0e4ePhSIz3eOL9Bui5u+8ycWYUJyJXrsLGw5G98akqdsGu9MNo0FBWW7wrJuvrzv2oNvtVr3rzm46qwpjCzNgd7qx/oDOGY1kyCgAJq0Wt8vn63PMpf8BXPQj4Ipf6XO8wQwG0aOdP1YEMH+5HljzdfG1Fd8Cpl+l7ThTLhUfD0SwhsxfTZB+bn85Zb43y+9r/Hn0d4jVawCOF68Kf3/Z1x1ognl/h29AWOlMv3L0CPq65S5sLevCgMiGFUU7SC2jwPcGW4+1YU67r39bDqeLpa+7s1YE0QYTUDLdc1y/EvNAQmW60/JEphxgtjsaWsrLVRfgtEV+bHsv0HzQ9/96lpcPGKC21Pd5g9GX1fWvxLDZYLr6aiz5/vcB26Dvxf91czpFg25ZWl44SdtO68LBQbfG8nJnX2QtNtHqbRUXEQDf75MoMegmIkphGRYTZowW/zBrCT6PNes/udyfoihYPV2Ubb4dZcAqh6iV5aaFLIFf5Ml076hph90Z2z+uR5u60dXvRLrZiGll2bh4pvjH8/U9Me7wTRWX/hRY/g1fhjpWRjOw9ItAyTR9jhdIej7wiadFn2PtVlEyPeMa8X1oNeUSEcic3hV65VYgqhp8iNpgS78kyrqPbRhYDh/MtqcBezfU4qloyp4Z/v6hAumGveJjToUIVLWsGBvM6blgZ9I458ESQd9ktIPUFEXfvu7OUwBUkWHLLBaf8/Z1R/H3XJYbF0/1XayQQXfbicCP8Wb9A2S6DQZfljaS3cwkhBqkZvarmIqmr7txn9grLemV6VZVX2m5HKDmL1hfdzD+me6eRv3L4PXgXRcWpp9bkru6Ja2D1ADf77V4ktVHmcWAyRL6vmEw6CYiSnFneYJPTUF3nMvLAWDlNNEzvOFgE5yuyINh347u0AHAhOIs5GeY0e9wx1xivs2T5Z5dkQuT0YBLZoo34+sPNqLf4Yrp2CkhtwK44IHAWaBUVjYHuPznABSRpb/qt9rKn6XMIl/AfPC1yJ677TjQ0wQYLeFL2fOqfHu7P3g49H1dTrHnHIBr0ee1fT+h1obJ0vJRs8RHb4AeSXl5hJlu+cbW7Qjdb+p2+7JvkWa6Ab9d3ToE3f47uuXPPJZd3f6l5VLeGM9zBch0q2roTDfgC8a5NixyoYbUGYx+E/ejWBsmL7DITKZewWzdNvH313+Amr9I1oapqu/vmiVbfEzFvm6tQ9Qk+TtACpfp9r9wmIgS8y59hqgBDLqJiFKe1mFq/Q4Xaj290vEqLweAeZV5yMswo6PPgW1RDDk71Rp6crmkKAou9GTVX95RF/Hz+JND1OaPEW/YZlfkojw3Db12F949pPN6GIrMvFuAr+wE7nhzYBZDq2hLzGVpedlcwGQNf3851X3vP4NnOgHgwCsiY51RCHXm9cHv5y9UIK1H0B1pptvs9/vD1hX8fv3tvgxhNEG3nsPU/IeoSTLT3RlF0O0/RE0KVV5u7xYXKYDAPd2AL2BkeXnkQg1SA2KbYC6D7omeVpDeFnHxLFa7nhMfp18VuPrB+3rQkOm2dYmhj4BvjWMqBt3edWEahqgBQ8vLw2W6DQa/QY8JGKam0xA1gEE3EVHKk0H30aYetHQH71c77iktz003oyAztjKoUExGA86fLMo33zoQ+dotmekONURNumqeuLq8dk89bM7oM9Iy0z2/SrzJURQFF3my3SOmxHw4yx8DGE3RPXbqZeLjyfcjK9v19nOHWOflb9QsYMJKEWRu+k3w+23yDINbeIe29VxA6PJyb9DtKVP37vWOY0+3yeIr0Q7Vby1Ly625oiUhUt7ych2CbhkI5wYIumPJdPtXQYQKuuVrz2gN/ueezkx31GQ2OC1IFUEsQbe8wDL+fE/fvepbhRcLeTFp3LmBvy5L5bVM15cXakxpYsAlkJrD1OTfjYJx2u6flgtkyNYUxTeJPpREDlOTQ9Ri7OcGGHQTEaW8/EwLJpWIf4g+PhE8qPCVlmdCiaRENworp4lVTm/vj7wMr8aT6Q5XXg4AS8YVYlROGrr6nVh/ILqMdEefA4cbRcmh3HsOAJd4+rrX7W+IuWeckqhwgui7dTuBw29qf1ykQTcAnPNV8XHbn30DxAYc82PRJ260AIvu1H7c3CDl5S4n0Lhf3E5kphsQP1MAaDwQ/D7eIWpBMrvheDPdOpaXD8h0y0FqEV5Y62nx9IhDDK+T8j3l5R01Q4c4+fdzB/v9m4y1YbYu4N2fAYfeSNxzxkOoQWqA39qwCMvLXQ6gYZ+4PXq+LwDUo8RcXuwJFrBFkumWr6/0Al/LQ6oNU3P6rdPLCb8S1Uv+HrDmiEx2ON5Bj4no6dZncjnAoJuIaFhY5Lc6LBjf5PL49XNLyycXw2hQcLixG9UtkV1tPtWuPdNtMCi4cq74x+7lHUHWKYWxo6YdADC2MANFWb4y4gVj8lGUZUFnvxObjrVEdWxKETLbfWCNtvvbuoBGz4CyigiC7rHnAuXzRBD70e+Gfn2zJwM+8/rQO8YHk0F3Z93AstaWw2JyriULyBvrua/nzWxfq/asXqSZbsA3sbtxX/D7RDtETZL9nF310WUo/cnMf67fmqJog+7TO33n599jml0uBuq57ED3oGOG6+cGEp/pPvga8JvFwNsPAf/6cmKeMx5cTsDuaXMINEgNiD7T3XRQ/B2z5oi/Y1liZokuE8xlW4OsuBgskp7uPr+LOvJCUPMh39/tVCADVFNaZBfiZMVLuH5uKZG7ur1BN8vLiYjOCGdpWJ8V78nl/nLTzd7p4pGUmDtdbtS1izcJ4Xq6pas8QfdbBxrR2R/5bvCtJweWlktGg4ILZ8gS8yjKTyl1TPEE3UfWaVsZVLtVlInnVomVYFopCnD2V8Ttj54Y+Aa/vQbY9y9xe+kXtR8TALJKxa511TWwFFpmskpn+jJAabm+vscOjReivJnuSIJuz+R6mWkPRJbgRtPPDYg35jJIjbWvW5a1+u8GlsFO9+nI1gsFGqIGiBaI3CC7ukPt6JYyEtTT3dUAPHc78OyNvp7U7tOJ222st/4O3+1ge5yjDbplafmoWeLvmGyriDXT7bT7/n5Ekum2WOD61a+w6667AItfm1iv30WdnHLxUXUBTSEqURLNv/85kmq7Qs/Ft3D93JJ3aF4Cy8uZ6SYiOjPITPfeuk702AIPeJGZ7gkJCLoBYOVUT4l5BKvD6jv64XKrsBgNKMnWMLwKwPSyHEwqyYLd6Y6q/1ru5543ZmgGSk4xf2NvA1xuNeJjU4oonwdkjRKlpcffDX//aErLpWlXAvnjROC0/S++z3/0uHgTPG65rxRcK4PB96bOv2zcGxAMWjsW6a5ub6Y7gkF1MugO9aZeZrozosx0A/qsDXO7fG/4/cvLs0oBKKL1IJIeXe8QtQBT7YNNMPdmuvOCH9eb6Y7TyjBVBbY+BfxmEbDvJZGVP/srvtLrzuiqhZJO/mytOcFnP3iD7gjLywf37md5KlRiDbq7PRejDebgF6Vk0O3f0202w/2FL+D4pZcCZr85CfJnINsXZLY7lfq6ow1QS2aIj8EqAgZL6CA1Bt1ERGeU0XnpGJ2XDpdbxbr9QzPLqqomZF2Yvws8q8M2H2tBd5ALAYPJIWqj89NhMGi7Eq4oijfbHWmJudutYodnwvp8v35uacn4QuSmm9HSY9e0ko1SlMEATJVTzDWUmMcSdBuMwDJPqe6mX4vSV1s3sPVp8bklX4r8mEDgvu7Bk8tD3TcUmemOpLxc9nR31gYvfw21l1orPdaGddWLwNpgGphVNJp85cKRDFOT06zLZg/9mjfoPjnw870aysvj2dPdegx46grglXtEZrhsLnDXemD196IbvpdKQu3olrw93REGYvLPWlY1ZHky3T0xbrWQLQ3ZZcGzvpHsbR9cSSF/J6TSBHP5+yg3gn5uAJh8EXD5L4BL/lfb/b3l5SF6upsOxXYhDwD6O31tDRykRkR05lg9XVyBv+/5nUOCz6ZuG7psThgUYExhFGuXojC+KBNjCzPgcKl477C2Nyin2rQPUfN31VxR0vnB0RY0dGrvYTvc2I0umxMZFiOmlGYP+brZaMAqz1A4TjEf5mSJ+cG1oUuJ3W4x7AyILugGgLk3iexue7XIKO74C2DrAAonApMujO6Y3l3dngyqqoYIuiMcpuaIYpBaep6vj1GuARqsJ8bycsA3RCmWCeZyiFpOubgo4s87wVzj329bt+/N+qhAmW5P+XrboKDbPxMZTDx7uv92M3Bio/gzvvD7wJ1v+bK38vXSHkHQbesGTm6KrCw/XrxD1IKUlgPRlZe73b6/Y/Jnlem5SNOtvW0qoC459TpE9tZbXt7u+5zLBeWdd1C4ezfg8tvYMfgCl8x0p9IwtWjXaxmMwMLPAkWTtN0/XHm5vQf43QXA71eJQXnRkhfq0nIBa+zJDAbdRETDxH9dMhWXzSqDw6XiK3/bgSfePQpVFSXRMstdkZ8Bq8kY6jC6URQFF3hKzN/SOMX8VKv2IWr+KgsysGBMPlQVeGWn9p3dclXYnIo8mIyB/8m7xG91mJsl5sPXuHMBS7Z4s1y3Lfj9Wg6LTKApfeBk6kiY04HFd4vb7/8S2PyouL34bm3TdwMZHEh3N4iSaMXgG2o25L6RlpdHkOkG/CaYBxmmFusgNcBXXh5LT7d3R/eYoV/zDlPTmOlu2ANAFUPTZNbTX7C1YVoGqcUr023r8v0Z3f2eqMTwL8OOZuL9Gw8Af7pY7J1PNk2Z7ijKy9uOi0ymKc23V1qv8nJvpjtU0J0nPvpnuvv7YVq9Gud8+9tAv98F5mCZ7obd4gJdKtCxFDsk+WcdrLy8+ZD4c+1rja2lQscd3QCDbiKiYSPNbMSvPzUPnz1b7L/84doDeOjV/XC71QHrwhJplafEfP3BRk0Ba40n0611iJq/q70l5hEE3Z4hagsC9HNL50wqQqbFiNOd/dh5qj3i86IUYbICk1aJ26FKzGs+FB9HL4hut7S06A6RcTm9W7x5T8sTGfBoDQ6MZAarcNLQvc/RlpdHkukGwg9Ti3WQGuAbohRLeXmgHd1SpJlub49vgNJyIETQrWGQmvxaX5u+gVLbCfExoxAomjj063kRvl4AX9m1/JhMWi5oRFNeLr+3kum+ixS6lZeHWRcGDOzpDvd68K4M8zymeIpop+jviOzPNZ6iLS+PVLhMd/MR3+3Bf08joeOOboBBNxHRsGIwKPjOFdPxrUvFm+E/vn8cX/7bdhw43QkgMevC/C0cW4BsqwnN3Xbsqu0Ie/9Tnp7uSMvLAeCy2eUwGRTsru3A0SZt2QyZ6Z4/Ji/ofdLMRqyYKi4esMR8mJuiYXWYDLqjLS2XMgqA+bf7/n/Bp30ZmGgMDqSDDVEDEpfplhn2pmBBt46D1LobtPW2BuLNdAcKuiPMdA/u8R3Mu6v7lBjgJkWS6XY7Ix/4FYoMuvPHBv56ND3dsmc9lqBFL+F2dAPRlZcHGpinW3m559+SUNsRZObeZQccYSZx9w0qLzdZgaIp4naqDFPTOTMclLwIGexn1nzId1uPoFunzD2DbiKiYehzy8fjVzfOhdmoYM2uejy9SbxBGpfgTLfFZMDyySIz8HaAAW+D1bR6Mt0RlpcDQEGmBedOEm/uX94evmSsvdeOo54KgHmVId4IA7hkpnhj9Nqe096SfRqGJq0W2Z/mgwOzHf5qPhYfYw26AWDplwCjRfx31l2xHUsGRu01Iusl30gHmoTuDbprtfXcRp3pluXlwYJuHQappecBxZ6M+t5/RneMkJluT9DTqTHoPh1iiJo8nsEEuB0DA3ktPwtzum9tm54l5q3HxcegQXeEF2lsXb4LKoN715MhovLyKDLd/n/Wsry8t1UMSYyWlky3JVNMNwfC7+ruDVBJMSqF+rodfb7XTG6cg25veXmigm6WlxMRndGumjsaT33mLGRZfb17E4oSG3QDwAWeLPG6MH3dNqcLDV1yR3fkmW4AuHqe+MfvpR11YYPj7Z6p5eOLMpGfaQl53/OnFMNqMqC6tRcHTndFdW6UAtLzgLHniNsH/bLdqiqGflVvFgE5AFToEHTnVQKfeR347Ouxv9GUj7d3iZJROeCpNEDQnV0mer3dDqBHQ+9prD3dPU2+oWn+x5TZ2ljKywFg3i3i47ano3t8u06ZbqcdaPSsSAu0LgwQQ5+8g8n83tBryXQD3qBJ0XOYmjfTPS7w1yO9SOMfaA+e0p4MWjLd5gh7ulXVbx+73591RoH4uwU1sjVzg8mLPKF6uhUlcF93IIEG9XnXhqXABHMZoJozQl8c0UO48vIWncvLmekmIqJlE4vw3OeXojTHimyrCTPKQ0x3jZPzpxRDUYB99Z2o7wi+wqO2rQ+qCqSbjSgIEwQHs3p6KTIsRlS39mJHTXvI+8rS8nlVYd4EA8i0mrBsgggcNhyMsZePkmvq5eLjh48DT10JPDwf+MEo4KcTgD9eJL5WMAHIjDFQlCoWiP7wWFkyfVms5sO+N46BMt1Gkxj0BWjr54w2023J9A0nG5ztllktg0lM943FnBtFxq9ue+QrkFTV9zOQ/db+IunpbtovLmSk5QXOmkuD+7pV1S/oDpP1z/Dr69ZLW5hMd3a57yKNlrJp/0C7uyH0aqZEiEemu6veM6jQCJT6DSo0GH3tErGUmPuvDAsl0K7uwVwOwNbpuX+gTHcqBN1+peXBVqTpxbsyLMCftdsdh6CbmW4iIgIwvTwH73xjBTb+5wrkZsQwGCpKhVlWzKvMAwC8fSB41k2uC6ssSIcS5T/KGRYTLvSsTgs3UE1LP7e/86eIjP07h2KcWkvJNeUSEWB01gLH3xEDupz9ABTxBrhiEbDqu8k+y8BkpvbwG4DqBjKLgezSwPeNpGQ42kw34OvrHhJ0+w1Ri/VNdmYRMNXTj7/tz5E9tqfZc1FBAXICDHCSQU9PU/j1Qf7lxqG+J++ubs8belsnoHr6u8NmuuWaqHhkuscG/nqkF2nk8aRIVo3FgzfTHWqQWoRBt/yzLp4ydFChd4J5lBdg7T1ihSAQPujWsqvb+zVlYLZfVsG0Hhcr3vR2aov2i0MdnqA73qXlQOhMd0eN5/e9R0xBt7yQwEFqRETkkWY2Ii8juuyxHlZ6dl2/HaLEvMYzRC2ayeX+rvKUmL+6qw5OV+BSSZdbxQ5Pefl8DZluADjP05u+5UQbuvpj2O1JyZVbAXzyGWDFA8DVjwGfXgN8ZSfwQCPw9QPAneuA6Vcm+ywDk9nVg6+Jj4Gy3N77RrAGKtpMN+A3wXzQ2jA9hqj5m3+r+Ljr776LBFrIvebZowBTgN+BGYUiGw81/Boob7lxkH5uSQbdsgxbloqbM8Jf2PBkuhW9Mt1uly+wKAhSXg5EdpFmcB93soepeasI8oLfJ9Lp5d4p9QHaCLwTzKO8ACuz3OZMwJod+r6Dd3WbzXD96EfYe/vtgNlzEV2+vtJyB+6hzyoGskYBUIOv9YvWjmeB368E1nxd2/07Pb+HAl340psMugNVYDQfFh9ly0tnbXS7uh19vgtjLC8nIqJUsdKzOuy9I83os7sC3ieWIWr+zplYhIJMC5q77XjvSOCeu0MNXeixu5BlNWFyaZg3PR5jizIxtjADTreKD462xHSOlGRTLwPO+wYw91Oixzt/bOCALNXIwEj2aIYKuiNZA+XNdMcQdDcdGPh5PYao+Ru/Qlx06G8HDryq/XGhhqgBYm96lsYSc+8067mh7+ctL/cEp1r7uQG/tWE6Zbo7Tolp6EZL6KxqJK+XIZnuE4HulTjx2NN9OsQFllgnmHf59XOHqwIZ3NNtscD99a/jyDXXABbP76zBk8v9xaPE3NEHvPU9cfvUx9oek6gd3UDoPd1yiFrVUsBoFRVD0ezqln+GOvaoM+gmIqKYTSnNxui8dNicbmw6FjgQjmVdmD+z0YDLZ4s3l89vORVwP7gsLZ9bmQejQXvpqywxZ183JcXgwDHQEDXvfaPIdMcSdDfuG7hLuMevvFwPBiMw92Zxe9tT2h8XaoiaJMtDu0K0pLhdvinQwSaXS4N7urXs6Jb07umWAXLemIFZ0MEiyXTLiwlyJVXSM93t4qOeK8MCTS6XsmTQHeW/A1r7uQFtPd2h5gV4h6npOMH8w8d8f1faa7RVnqRKeXmLJ9NdPMX3OyGa16//RQSdetQZdBMRUcwURfFOMX8rSIl5jaenuyLG8nLAN8V8ze56XP7r97D+QOOAaebbTrYDAOZX5UV0XFli/u6hJq4Oo8TLHVSaGbK8PILdy7IM0xRFT3fhJDFsqr9jYKZYlpdn6lReDgDzbgagAMffBVqPaXuMd0d3gCFqkpZhai1HRebMnAEUTgz9nHJXd2etWCulJSiU5PRyvTLd4YaoSVov0qiqr7x83HLPcyRxgrnL4ctoasl0u2zhy4l7W32vm0B/x2TQHXV5uYbJ5dLgnm6XC8qWLcg7fBhwuXznCwTJdHvOX6+1Yb2twMZf+H1C9b3GQvH2PyegvNw7SC1A0C3Ly4smD704FgkZdGu5cKIRg24iItLFBZ4S8+e21OAHa/aho3fgG59TrZ6e7oLYMt2A6NN+4LJpyLKasK++E5958mPc8NgmfHhMBALeyeVjtPVzS0vGF8JiMqC2vQ9HGuMwmIYoFP9Mt9EaOvjzrq2KZJBaFH/3zGlAwXhx279vtFfnTDcg3iRPWCFub/+LtsfI7z/UtHEta8NOvic+ls8LnTEGRLm6wSzKurvq/HYoa/h94810t4e/rxbhhqhJuZ4AJNxFmu5G32C6sWeLzyVzbZj356SEnpIve7qB8NlumeXOHxf4mDGXl3su7mgZwDW4p7u/H6Zly3DeN74B9Hv+3oaqpPBmuvdqWwcXzsb/E0PgSmf52iz8p4EHIy/mJKK83JvpDlFeXjQpxqDbbxq7Thh0ExGRLs6dWIQLp5fC4VLxu43Hsfyn6/H7jcdgc7rQY3OipccOQJ9MNwDcee54bLx/BT6/fDysJgO2nGzDJ5/YjJt/vxnHm8U/xvMrIwu60y1GLB4n3ti8c4gl5pRg/pnu0uli6nS4+/a1hg8ynDFkugG/EnO/CeZ6D1KT5t8mPu74i8gih6NXpvv4u+LjuPPCP6fBMLB0NdAO5WD07umWQXeoIWqA9os0MsDOrfBd9Elmebn82ablhL4YYrKICyFA+L8P3t79IG0EMZeXy0y3lqA7T3wM1W4Q6qJO4URxgc7Roy0jHUrbSeCjJ8TtVd8V2WLAlz0Oxt7jK49PZHn54EFq/R2+CyWFsQbdnj9DHS8iMOgmIiJdmIwGPH7rAjz5mUWYUpqNjj4Hvr9mP1b9/B388T3xZiAnzYTcdP3WmuVnWvDNS6fh3ftX4NYlY2AyKHj/iAgGJhRnRrVCjX3d+nO5Vfxo7X489s7RZJ9KasssFm+gAV8GK5i0XMCaI253hBgU5HKKjCwQXaYb8K0Na/IPunUepCZNuVRkz7vqgaNvhb9/uEFqQPhMt9vtF3Qv13ae/mvDIhmkpvf08tYIy8v72wFbV/D7+feIy6CltyU+K6m00DJETdLa1x1qcjkQe3l5ZwTl5Zp6ukP8XTOafHvGYx2mtv4HgMsu/g5MXOm76NIS5ve2LMW2ZIeuRtCLfyuB229wa7MnI581SlykGbzaLxLeTDeDbiIiSkGKouD8KSVY+5Vz8ZPrZqM0x4qa1j7835ui5CvWyeXBlOak4aGrZ2L9fefjuvkVMBkUXLcgut4y2df90fFW9No1ZNoorD+9fxyPv3sMP37tANp77ck+ndRlMPgyReHWVgHahmM5/bJBUWe6p4qP/pluvQepSSYrMPtGcXvb06Hv29cudmQDoQephct0N+4TgaU5Exi9QNt5+mfRIhmkpveebm95eZhMd1qOLyAKdZFG9m/njxX3l8FusrLdkfTLe9eGhblAIMvLRwUJumV5eW9LdOumIsl0a9nTHa59QY9havW7gF3PidurvyeGhxVOEP8frrxclpYnIssN+DLdwMALLP6l5YA+Pd0MuomIKJUZDQo+sagS6+87H19fPRmZFlEWOKE4K8wjY1NZkIH/+8QcHPnhpfji+WGGIQUxoTgTFfnpsLvc2MTVYTE70tiFn/z7oPf/99Z1JvFshoFJF4o3lRNXhr+vluFY/pOHow66PZm0xgO+vtF4DFKT5M7ug68BXSH6auXFhoxCX/YrEBn8dAaZXn78HfFxzDLtq+XkG/q2k1GtDFNsXVDUGC/q9bX5MqRyuFsoWobvyfVg8njyY7L6uuX3p+VnqyXTbev2BZHBysszCsTwQMB3cUkrVY1uenmoHv9w7Qt6DFNb910AKjDzOjHXAPDLdIcJuhO5LgwQF+YUTwjrP0xNTi4fHHRHs6ubQTcREQ0nGRYTvrxyEjZ8YwW+c/l03H/xlGSfUliKoniz3ezrjo3T5cbXn9sJu9M34GdvXUcSz2gYuOR/gf886csyhaIl6JaZbqNVZNKjUTBe7IF29IiAze326+nWOdMNiB7yikWA6gJ2Phv8flqGqAG+4Ke/fWgfKBB5aTkwsHQ1klL79DwAYgWRxalxvVUwMsudWRL6ooOkpTJCZrrl9xdLtlAP3p7uvPD31RJ0N+wFoIrXhCwjH8xg9F1MirTEvL/D93dOU3l5nu9xwQah9YappIg1031sg2jlMJiBCx7wfV4G3b3NoTPxcRg6FpKi+PV1+wXd3ky3pxc9syS6Xd0uh683nIPUiIhoOCnOtuKz54zTbYhavPn3dXN1WPQee+codp7qQE6aCbcuEW/imenWQGu2NZJMtznKLDcAGM1iMBEgSsxtHSIgBuITdAO+gWrb/zxwP7g/7xC1MEF3Wi5g8vSzDy4xdzmBE++L2+M1DFGT8qPs6TYYvWXeFmeMfdJah6hJWl4v/uXlgC/4TtbasIjKy2XQHeLn6i0tD9O+4Z1gHmHQLUvL0/K0zVDwXkxQxd+rQEL1dANA6QzxsaMm8v3vbjfw5nfE7YWf9W0qAABrlu+CVUuIFX7e8vIErAuTAu3qlgPf5O+qwQMPtepuAKCKixA6Dopk0E1ERDTI0gmFMBsVVLf24kRLgF2gFNbeug786i3xJujBq2Z4V8ox6NaRljVQ3snlMa7q804w3wf0eLLclmxR6hkPM64VPbotR4DqTYHv4x2iFmJyOSAyY8H6uuu2A/YuETCXhtiLPpi3dPUU0OOpiNHS0w14gyezK8agW+sQNclbXh4k6HY5xPcD+C4q5KVIebmmTLfs6Q6R6Q43uVzKijHo1rrf2WQRswQAETCbzXA98AAOfPKTgNksLjiFy3Sn5/n+DkRaYr73RXEhwpINnHf/0K9rKTFPdKYbGLqr2+UEWj0XBmR5ORBdpYb/ju5oq4MCYNBNREQ0SJbVhEVjxRucDQejnGB7BrM5Xfj6czvhcKm4aEYprp47GjPKxaTto03dHFCnl4gy3ToF3U0H/ErLdZ5c7s+aBcy4Rtze/GjgbLd8Ix1qXZgUbIL58Q3i49hzI3uD7V+6Koe5acl0A97gSbdMd7ghalK4tWEdNeL7MaUBWaWeYyc56I4q0x0i6JaTuIunhj5WtBPMvf3cGkrLJf++bosF7u98Bwc/9SnAYhFZe7enHznU37dRnhLzI29qf15bN/DW98Tts+8JPJ9ByzC1RPd0A74LFfLPuv2kmLxuShvYbhJV0K3/5HKAQTcREVFA509hX3e0Hn7rMA6c7kJBpgU/uGYWFEVBSXYairOtUFVgf32IlUWknQyiOmuD94PKTLdeQbec9A3EZ4iav4WfER/3/wt46QuAc9Dke63l5UDwTHc0/dzAwNJVSWvQ7QmeLLFmutt0znT793Mriu82ALQlqadb70Fq3p9ZmAsVmeL3f9SZ7kgCtlC7umWW22gdOLV7sJnXiY/vPwwcfTv8c6oq8PIXRbCaXQYs/VLg+3kz3SF2dctp+AktL/f8PpOZbm9p+cSBF8+8QXeY/fT+4rCjG2DQTUREFNB5k0WmY9PRFvQ7XGHuTdL26jY8ukFkk75/9UwUZfnKj2d6st37OExNH9llYoqvyx48IycHh0U7uVzyZroP+YYMxaufWxq9ALjyETFJeuezwF8/AfT7tSdoHaQG+GW6/SaYO/qA6g/F7fHnR35+MiAFRGmz1l583TPdY7XdX14k6KwduN94yPH8vi/5GFtH6Anb8RLRIDVPebkjSNBt7/UFxeH64GWmP9KgO5Id3ZL/rm63G9i7F9nV1eK2/+RyeSEkkFnXA/NuBaACL9wZuvoFAN77ObDvZdG3fMNTwQfxhSsvt3X5etGTUl7u+f02eHK5FM2ubma6iYiIEmdyaRbKctNgc7qx+RhXh2nR73Dh68/vhFsFrppbjktnDexrnFEuBkjtqWVfty6MJiDb88Yw2Jtsh06Z7ryxoi/cZQNqt4jP6ThkKKj5twI3/V2Ukx5bDzx5qQhs7L1iqjKgLdOdI4Nuv0x3zYfi+8ku8wUXkfAva9fazw34Mt2xBN0uh+/PXOsgtaxSwGASQ/AGl9kDvhJy/yDekunL+iajxFzP8nJ5USEtN3xrRNTl5RH2dMvzAUSA3dcH87x5uOCee4C+vsh2wF/6UzEgrrcFeO72oZUh0uE3gbce8jzmJ0DV4uDH9AbdRwO3eMgsd1quaAlJlMHl5YMnl0ux9HTrfBGBQTcREVEAXB0WuV+sO4RjTT0oybbiwStnDPm67OveW89Mt27CrYFyenq6Y810GwxAsWfl34n3xMd49nT7m7Qa+PSrIvg7vRv4w2rgyDrxNUu2tixodoCg21tafl7oLGIwA4JuDefgva8Og9Taqz391+m+rGw4BqMvexfoIo0MSv0z+MDAneSJJoNOPVaGaS0tB2IoL4+xp3uwSNbRmdOBTzwtAuDaLcAb3xp6n5ajwAt3AFCB+beLieWh5I0RlSaO3sAXapIxRA0YOkit2ZOJLxyc6fbf1a1xlog36I7gwokGDLqJiIiC8PZ1H2TQrcXa3eJN2f9cMQN5GUNLbWeOFhmdQ6e7B+zuphiEG6amV6YbAEqmi48yOIt3ebm/0fOBO94ECiaICwzP3y4+n1elLWD29nT7BQ7H3hEfI1kV5m9A0K2xnxsAMsR9Y8p0+5eWR3LBwDvxPlDQLTPdg4PuKEp0JbdLVCX0tUdenm7r8rUyDD6nQMKtDJPT3v3XYgUTbXm5N+jWqafbu44uT9uxCsYB1/5O3P7oCWDX876v2bqAv90sdoJXnCUy4+GYLL7Kh0Al5skKur0rwwZnugcF3d6Bhy7tu7qZ6SYiIkqsZROLYDIoONbcg2quDgvJ7VZxukNkVedW5QW8T0V+OnLSTLC73DjcyGFquggXdOuV6QaAkkETn+M9SG2wgnEi8K44S2R5AW2l5cDQTHd/B1C3TdyOdIia5F+GHUnW3xOgxzRILdJ+bsk7wTxAAB2ovBzwK9ENk+l29AF/ugz48RjgB2XAgwXA9wqAH5YB/ztG/Lfx59rPVQZ5mcUaB6mFWRkmV0ppKceX5eV9raKUXwu3G+iOIdMth8b5C7cuLJDJFwHLvyFuv3IP0LBPlIa/9EWgaT+QNUpkxLWu+wvV1+0dopakoNvRJ35GstVkcJuIwRD6NT+Y2x3dMDwNGHQTEREFkZNmxvwx4g3RO4e4OiyU5h4bHC4VigKUZAd+M6coCqbLEnPu69aH5ky3HkH39IH/n8hMt5RZCNz2MjD1cvH/ZXO1PU5mLu3dIuN38gMRuBdMiH7qcrSZbj0GqUU6uVwK9nqxdfmm0g8uL8/XmOk+vhE4+Z4IHh29Irs42MHXtJ+rnEg9uE83GD3Ly9MLRFk14NvDHk5vM+B2AlB8QbsWsnQ+UCVAXwTl5f7O/6YYDujoBZ67FXj7IbEFwGAGPvnnyEqn/fu6B5N73ZNZXi4vBuSMDtxXHklfd2+zWNGmGLS3bWjEoJuIiCiEVOrrPt7ck7KT1GWWuyTbCrMx+NuLmZ5havsYdOvDuwYqQE+3qgINe8RtOXgoFnKCuZSIQWqBWDKAT/wZ+Py7wPL7tD3GmgVYxQUfdNZHvyrMX2axr4IgkkykJ+ueYW8Sk+ejITPdWoeoSXlB1obJ0vL0AiAtZ9Bjxgy8TzAnPb3+M64FvrITuHc/8I1jwDdPAXd5SvmbDgYeyBWIN+ieFPp+kp7l5QZD5H3dMkOaWQwYzdoeA/j1dIdYGRbJ6wsQ/fvX/UEEoi1HgI3/Jz5/2c+AyrMiO1aoXd1xKsUOy3+QWrDScimSoFuWoGeWRPZnqAGDbiIiohBkX/f7R5K7OuyVnXVY8bMN+M7Le5J2DqHUtYuge1Ru6N7hGaNlppvD1HQRLIgCgC1/APb+U2Rtpl8V+3PljPYFrkByMt2SwQCUzYnsjbG3xLw+9n5uQPRSyzf0kWS6iyZDzSiCyW2Hcurj6J679YT4GHWme9BFmkDrwiT/nu5QAfPJD8THSReK88opF5UJ1mxxwUYxiPVSg3elByODqcHDsYIJVV7ucviCLs3T3j1Bt9ZMt/y+Ih3A5e3pbh/6tWgz3YBo/7jhKZHdBoAFnwEWfDry48hMt7wI4i9Z5eX+me5wr5OIgm55EUHf0nKAQTcREVFI08tyMConDX0OFzYlaXVYj82J76/ZBwB491BzUs4hnNMdooy5PDd0GfMMv0y3260x40XBySCqt0UMrJJOfgC89p/i9sr/AcaeHftzKQpQ7NfXnZnEoDsass/29G6gca+4Pfbc2I4pJ7pHUqJuMEAdJ4J95diGyJ9TVWPo6Q5ykUb2aw8uLQd8F3YcPb4S9MHsPUDddnF7zLKhXzdZfRnmpgPazlVmVvUoL++oEeXupjTR06xFpqdEXA5zCyeadWHAwEy32QzXvffi8NVXA2Zz9JluqXIRcMsLwOrvAZf8JLpjyKC77cTA/nZV9RukFmWLRrTkYEh7r29yebDXSSSDABl0ExERJYeiKFg5Tbz5WrdP45svnT264SgaOm0AgNOd/WjqsiXlPEKp75SZ7tBB9/iiTFhNBvTYXTjREqT3krRLy/Urm/a8Ae44BTx3m+gvnXEtcPZX9Hs+WWKuGAFrrn7HTQQZDO1+TnwsnRX7MLiLfghc+Qgw5dKIHuYevwIAoBxfH/lz9rYCds8gwkBBcijy4oCtUwyTk9qCDFEDRMAsf3bBSsxrPhKvt9zK4JPG5QWbpoPhz9Pt8gu6Iy0vD/B7pdWvn9ugMfyJdIJ5pwy6IxiiBvh6uvvbAYsF7h//GPs+/WnAYokt0y2NP0/8DjAN3SihSXaZGFymugb++fd3+Er54xCkhiTLy/0z3bqUl8evXJ5BNxERURirpok3X28faISqtR9RJzWtvXhio5i6azWJf7b31KZeaXa9p7y8PEx5uclowLQyDlPTlX/JsKNPrAXqaRJB5VWPRLeDOhgZdGcUaA9eUoUMhup3io+x9HNLeVXA/FsjDmi8me76nb5splZyIFh2eeQD8iyZvqypf7Y7VHk54JctDBJ0n3xffAyU5ZZkVYCWTHdHjZi8b7QOHFgXin95uXvQSsJIJpdLEZeXx5jpdvQCzkEXVHvlyrAYgu5YGQxi4CAwsK9bBqjp+b5y70SRz9ff4fv7EC7o1rKrO047ugEG3URERGEtnVCIdLMR9R39CQ8Uf7h2P+xON5ZNKMQlM0XQsDsFg245SC1cphsAZngmmO9hX7c+vCtxaoBXvgrU7xBv0m/8iy/7p5fyeeKj1kAolQwOhmLp545Vdhk600ZDgQpEWmIe7RA1yf/1IgVbFyblhwu6Pf3cY0K0MchMt8xMhiJLhgsniKFgWnhf6yrg7Bv4Ne9FhQh+ZhGXl0exLgzwVKp4Loz1tAInTiC9oQFw2kUPPBBbplsPgYapJau0HPCtDGs6KCoszJnBd6NnlQJGi7Zd3XHcO86gm4iIKIw0sxHnThJlqOv2J67EfNPRFry25zQMCvCdK6Zj5mhRzpuKQXed7OnO0xJ0c4K5rmQQ9f4vgV1/E6XfNzwZPGsZi8rFwLW/A676jf7Hjjf/YEgxhs7KJkBj9kxx4+jbkT3QWyo9NronHjzxXlV9ZcPBytVDleg6+oFTW8TtUEG37LnVkun2DseaGPp+/szp8Aavg0vMvZPLI8l0R1he7s10R1hqbTD4hqm11sM8eTIu/PzngdZ6331kCXqyyCyyf9AtKyUSPUQN8F1gcXj+nAsnBK+8MRh8r/lwJeZx2tENMOgmIiLSRJaYv7U/Mfu6XW4VD74ihj3dvHgMpo7KwSxP0J1q5eVut4qGTm3TywFg5mhfeXmiy/VHJBl0yxLai34QvyyuogCzPzF0fdhw4P9GevQCMVU7iZpyZokbR9drX6MFRD9ETRo88b670ZMZVnzByZDHhFgbVrsFcNlEkCozooEUTRbP0dsC9IQZCNkS4Y5uQLw2vSXmg9aGJaS8PMpMN+ALqm1+v9v72z1fywWMpsiPqSfvru4A5eWJ7ucGfIPUpHCvEy193arKQWpERETJtmJqCRRFZJllKXU8/e3jahw43YXcdDPuXS3eUMwYnQtFAeo7+tHcnTrD1Jp7bHC4VCiK2NMdzuTSbBgNClp77KhPwM9yxPMPlOZ8Clh8d/LOJZX5B0PJLC33aMmaAtVoATpPBd6BHEw0pdL+Bq8NkyXjuRXBe9NDBS3e0vJloecHWDJ8xwmX7W6OIugGAg9TGzDtPU7l5S6HLziPtKcb8Jtg3u79lNKXAv3ckjfoPur7XBxLscMyD2qb0SPo7m8XffVAdH+GYTDoJiIi0qA424q5lXkAgLcOxLfEvKPXgZ/9W0z4/dqqScjPFG+Es6wmjCsSbzZSqcRcXoQoybbCbAz/1iLNbMSkEpGR4jA1HVQsBAwmoOIs4PJf6Ds4bSSR5cKAPkPUYuQyWKFWLhb/E0mJeVus5eUy6PZkumVAGmoSurenu3rokLIT74mPoUrLJe8E83BBt5xIHUF5ORA46O46LTL5ijGyWQTy9dLXNnBVViDdDQBUsRM7mv31srxcZrfl8wKR7YCPF7nurasOsHmqCLzl5Uno6R48uC3c60RL0O0dDFcwNJOuAwbdREREGiWqxPxXbx1GW68Dk0qycPOSgW+EZYn53hQKuuvatZeWS7Kvey+HqcWuYDzw9UPAZ16Ly5vFEcNkBRZ8Bph0IVC5JNlnAwBQx4nVYZqDbke/LziIepCaJwDxBt1yiFqIoDtnNKAYRBm5f+bXaRfrwgCNQbecYB5imFp/h+85CjWuC5O8QbdfebksLc+rBIxm7cdKzxeBOhC+xNy/tDyaqf4BMt3eADzZQ9TkOciLCa2ebLc3052M8vLBQXe4TLeGXd1y5VucMvcMuomIiDSS+7rfP9KMXnuY1SNROtLYhac3nQAghqcNzhzPSsFhaqflEDUNk8sl7wTzWma6dZFZmPy+z+Hgil8CNz8f/c5inbnHny9uHN8oAthw2qsBqKJ3OZqMKuDLTHbViwyulh5xo9k3pdo/cKnfIbLI6QW+LHYoWjLdcnJ5dhmQlhP+mP7814ZJ3sqACC9SGAxApqevO1yJeVeUO7ol765u3+91Re7oToXycmBgX/eA/uckDlIDACi+lWbBaMp0x/ciAoNuIiIijaaUZqMiPx02pxvvHQ4zCChKD726H063ilXTSnHupOIhX5/pHaaWOsFqfQTrwiQZdO9jppvOZKUzgYwiMYX51Mfh7+8fIEfbRpBZ7Fmh5BaBk+zpDlVeDgReG+a/n1tLhteb6T4Y/D7RTC6XApWXe4eojY/8eFmyrztMprszxqBbZrr723yfS6VMNzCwr7uvzdf/nIyg22gWLTWAmGkRbk+4ll3dcsZBHHZ0Awy6iYiINFMUJa4l5tur2/DOoSaYjQq+dVng6dAyWK1t70Nrj4bMWALIoLs8gvLy6Z7vo66jH20p8n0QJZxiAGS2W0uJeayTywERHMtAqeOUX3l5mGN6s4V+QfcJGXRrKC0HfGXA3ad9PcuDRTO5XAoYdEexLkySQXdPmN/33kx3lAGb7Om2d8F19904fsklUOQk85TJdPvt6pZZ4YwiwKz9Yquu5DC1Ig0tCOF2dTvtwM6/idtlc3U7RX8MuomIiCIgS8zfOtAIt1vfdVdPbxJvZq+cM9o7MG2w7DQzxqfYMLV6T3l5JJnu7DQzxhaK7ASHqdEZbcIF4qOmoDvGIWqSXBvWdlxMTwfC73UfvDbM7QKqN4vbYzUG3Wk5voA/WF+3d4hahP3cQOCVYdGWlwPaJ5jHsi4M8GW6nZ1wP/wwdn3+84DT83sx5TLdR4COJPZzSzK7reV1Em5X985nRaY7a5TYABEHDLqJiIgisHhcIbKsJjR327DzVLtux23utmHNLpEtuW1p6De/M1NsX7c3050XWcZDDlPbwxJzOpNN8AxTq9sO9LaGvq/MdEc7RE2SAcjJTaLM3JQ2cLp7IIP7Yk/vAuxdgDVXlMlrJUvMm4OUmMue7qiCbk8glujycm+mO8og1NvT3e77nLenOwWmlwO+oXYtR3wXapIxuVwyRxB0A8H7ul0OYOP/idtn3xO3zH1UQfdTTz2FNWvWeP///vvvR15eHpYtW4aTJ0+GeCQREdHwZjEZcN5k0WutZ4n53z+ugd3lxpzKPMzxrCYLZuZoUZq9+1Tyg1W3W0VDZ+TTywFfiTkz3XRGyyn3DBhTgePvhL5vq06ZbhksndgoPuaNCd8jPrinW+7nrloCGIzan9s7TC1A0O1y+qZj61Fe3tvqG04Wzc8s4vLyGDPdva1AUxMsHR1Q5AWYVMl0F4wDoIifZ/0u8blk9HNL8jVcPl/b/YMF3bufF6/pzGKx3SBOogq6f/jDHyI9XfzDumnTJjzyyCP4yU9+gqKiInzta1/T9QSJiIhSjSwxX7dfn33dTpcbz2wWb2RvD5PlBnyZ7lQoL2/uscHhUmFQxJ7uSMjvg2vD6IynpcRcVf16unXKdMsAOlxpOeArL+84JUrLT/gNUYuEDKYDTTBvPwm47IAp3TctPRKDV4bJ0vKsUeGHbQXiLS9PUE93ZxvMo0fjkttvBzpbPF9LkaDbnO573ciLQ7lJDLqvfQK4/VVgdAxBt9sFvPszcXvpf0T3GtEoqqC7pqYGEyeKuv6XXnoJ119/Pe666y786Ec/wsaNG3U9QSIiolSzYkoJDApw4HQXatv7Yj7euv2NqO/oR0GmBZfOCv+mTQarte19SR9CdtpTWl6cbR2y3iwcORTueHMPemzxWcFGNCx4g+71IrgOpLtRrOdS/PpTozW4LFhLFjh7FGAwA26nCLyrPZnusedE9tyhMt0tntLywonR7bsevDLMO0QtitJywK+8PETQbe/1ZdNjzXT77+mWt1Ml0w34hqnJiz/JzHRnjwLGnav9/oF2de95UVRWpBcAi+7U9/wGiSrozsrKQkuLuPryxhtvYNWqVQCAtLQ09PXF/uaDiIgoleVnWrBwjHgj9PaBML1+Gsi93DcuqkSaOXyZZo7fELJkZ7vr2kXQXRZhaTkAFGVZUZpjhaoC++tZYk5nsDHLxHTljhpf4DmYzNrmVMS+Z3xw0B5uXRggSsjlALbDb4jp4+ZMoGxOZM8te7o7agBb18CveYeoRbEuDBhaXh7L5HJAW3l5t2eImjkDSMuN7nlkT7fq8n5KcXkuqKZKphsYusYtmUF3pAZnut1u4N2fittLvwhYs+L69FEF3atXr8add96JO++8E4cOHcJll10GANi7dy/Gjh2r5/kRERGlJFli/vbB2ILuww1d+OBoCwwKcPMSDW98PVKlxPy0Z3J5WQSTy/3NLJcl5gy66QxmyQQqF4vbR9cHvo93iNrY2J9vcFmwlvJywBe47Pir+Fh5ltiZHImMAl/ZdvOgCebeoDuKfm5gaNAdy+RywHeefW1irVQg/pPLo92dbk4HjAHacwxm3/eUCgYH3cksL4/U4F3d+18Ww/zScoGz7or700cVdP/mN7/B0qVL0dTUhBdeeAGFhYUAgK1bt+JTn4rPmHUiIqJUsmq6mPT74fFW9MdQGf1nTy/3qmmlGJ2nPVs8K0UmmMvJ5ZGsC/MnS8yT/X0QJV24vm69hqgBIsjLLPb9v9Zjyox43TbxUet+7sFktnvw2jDv5PJog+5BK8O8k8ujDLrT8wGDSdzuCXKBtbNOfIy2nxsQwbrs6/aXURB9IB8Pg4PuWL7nRPPf1d1R4+vlXvyF6CsUImCK5kF5eXl45JFHhnz+wQcfjPmEiIiIhoMJxVkYV5SJ4809ONAR3Zuirn4HXtgqVq/cvmxsRI+dlSKZbu+6sCjKywFgVkUeAGDTsRaoqgolld5gEiXShAuAtx4UE8VdDpFBVlXg9G7g4Fpgx1/E/fQIugHR1y0DSS3l5cDQjLjW/dyDFU8V3+fgYWoy0z04uNNK7/Jyg0FcnOiqFyXmgTK7se7oltLzAZwe9LkUKi0HfD3dgKgCMEU2PDOp5K7u1qPAh48DDXsASzaw5O7EPH00D3r99dfx3nvvef//N7/5DebOnYubbroJbW1tup0cERFRKls5VZQebmmKLlB8cVsteuwuTCjOxLIJhRE9doYn6D7V1of23uQNU6v3lJdHm+k+Z2IRMi1GnGrrw/aadh3PjGiYGTUbyCgUWdoPHwPWfgP45Szg8XOBDT8S2TmjBRh3nj7PJ/u60wuAtBxtj/EPzo1WYPSC6J7bm+n2G6bW2wr0NovbegTd9h5fv3Us095lRUCwYWqxTi6XZF+3v1QaogaIEm2jZ57AcCotl+RMgo8eFx8X35WwPehRBd3f+MY30Nkpeq92796Nr3/967j00ktx7Ngx3HvvvbqeIBERUaq6dn4FDAqwu82Atw5EtrNbVVXvALXblo6NOMObm27GGM8wtT21yeuH9ma686ILutMtRqz2lOq/srNOt/MiGnYMBmD8+eL2Gw8AHz0hAm1TOjDlMuCq3wBf2wdULNTn+WTQrbWfGxgYdFcsij7T6Q26/TLdcoBcTkX0Q638y8tlD3xaXmzBa5b4/RQ86JaZ7hiD7vR8wAC4L1uG1qVTRZSWoIBQM4PRNwl+OA1Rk2Rft+oWQwCXfClhTx1V0H38+HFMnz4dAPDCCy/g8ssvxw9/+EP89re/xWuvvabrCRIREaWq6eU5uOPssQCA7/xrPzr6HJof+8HRFhxt6kGmxYhr50f35iXZw9TcbhUNnbKnO7rycgC4Yk45AODVXfVwuYOsSyI6E8y5SXzMLAHm3wZ86m/Afx4HPvVXYN4tQFZx6MdHQpYKF03R/hgZtADRl5YDvrVhbScAh2fzUayTy4GBme5YS8ulcBPMvZnuWMvL8wCTAvX+a9Fw+xLApKRephvwVSEM56AbABbdAWRGVmEWi6iCbovFgt7eXgDAunXrcOGFFwIACgoKvBlwIiKiM8E9F0xASZqKxi4bfrBmn+bHPfXBCQAiW56dFuH0X49kD1Nr7rHB4VJhUICS7Oh7+86dVIzcdDOaumz48HiLjmdINMxMWgX8Vw3w9YPAlb8Gplwihp7Fw5wbgUt+AlzwgPbHZJWIzDsg1pxFK7PYk8VVfRnu5sPiY7RD1ABf0O12+rLosZSWA4krL/fb1W1xegbBpVpPNwBMXAUoRmDc8mSfSeRkpYYpHVj25YQ+dVRB9znnnIN7770XDz30ED766CPvyrBDhw6hoqJC1xMkIiJKZWlmIz41wQVFAZ7bcgrvHgq/Qqy2vQ/r9jcAAG5bGkFp5yDJHqZ22lNaXpxthdkY1VsKAIDFZMAlM0WW6JWd9bqcG9GwlZYjSs3jzZIJLP68r89VC0UBVv0PMP92YMw50T+3oviy3bKvWwbdhZOiP67Zb71Wwx7xUZZDRytUebmq6jdILS1PHK+9CdaednE7FTPdCz8D/HctMO3yZJ9J5CZfJC4aXPoTXwVDgkT1N/qRRx6ByWTCP/7xDzz66KMYPVqUF7z22mu4+OKLdT1BIiKiVDc+B7h1sShb++aLu9FtC71D7OlNJ+BWgWUTCjGpNDvq55U7rqtbe9HRq720XS917SLoLouhtFy60lNi/tqeetid7piPR0RxsuQLwJUPA8aoliD5DO7rbpGZ7hiCbqMJMHnmS5yWQbde5eUBLqjaOgGHqP7VJdPtAIw3Po6K/1wHOJCamW4gftUX8ZaWC9zygmjdSLCo/rZUVVXh1VdfHfL5X/ziFzGfEBER0XD09dUTsf5QE2pa+/C/rx3AQ1fPHHKfXrsTP1p7wLubO5YsNwDkZphRVZCB6tZe7KnrwNkTi2I6XqROeyaXl0U5udzf4vGFKMqyornbhvePNGPF1MRmIYgowYr8gm6Xw7dTO5byckBk8J39vrJ1vcrLO2sBey9gyfB9TWa503IHfj4agYampWKmm6IS9SUql8uFl156Cfv374eiKJg2bRquuuoqGI1GPc+PiIhoWMiwmPDja2fj5t9/iD9vPonLZpdhyXjfkJbt1W2497mdON4s9sd+9uxxuHB6jOWIECXm1a292F2b+KBbTi7XI9NtNCi4fHYZnvzgBP61s45BN9FI5782rO2E6MM2ZwI55bEd15IJ9LYA8Axl1Ku8vPUY8MMyEYTnVXmGcnm2TsSa5QbEILUhn2PQPVJEFXQfOXIEl156KWprazFlyhSoqopDhw6hsrISa9aswYQJE8IfhIiIaIQ5e2IRPnVWFZ79qBr/+cIuvP6V5TAZFfz6rcP4zYajcLlVjMpJw09vmI1zJ+kzhXjm6Fys2V0fVV+3w+WGQVFgNES3Z9wXdMee6QbEFPMnPziBN/aeRr/DhTQzL+QTjViyp7v1GNCwV9wumij6vWNh8Vs3ZkqPvde6aBIw9XLg2DuAvUuUmfc0AbVbfffRY5I3M90jWlRB9z333IMJEyZg8+bNKCgQL4aWlhbccsstuOeee7BmzRpdT5KIiGi4+OalU7HhYCNOtvTimy/uwtGmHm9AfNXccnzvypnIzYhuWnkg0U4wb+m24cpH3ke3zYmr55bjE4sqMcPTI65VvSwvj3JH92Dzq/IwOi8dte19ePtAIy6dpUP2iIhSU045YMkWgeyhf4vPxVpaDvgmmANA/tjYg3iDEbjxL2KwWX870F498L+eJuCsu2J7DkAMUhss1fZ0U9SiCrrfeeedAQE3ABQWFuLHP/4xzj47hp19REREw1xOmhk/vGYWPvPkx3hpRx0AIC/DjO9fPROXz46xbDKAmaNzAAAnW3rR0edAbrq2gP4Ha/ejtl0EzU9tOomnNp3EzNE5+OSiKlw5p1zTcfTOdCuKgivmlOOxd47ilZ11DLqJRjJFESXmtVuAg2vF52KZXC75B92xlpb7UxQRBKfnA2Vz9DuuFCjAZtA9YkQ1vdxqtaKrq2vI57u7u2GxWGI+KSIiouFsxdQS3LhIrOE5b3Ix/v3V5XEJuAEgL8OCygLRU71XY7b7gyPNeHFbLRQFeOiqGbhsdhnMRgV7ajvx7Zf24KwfrMPX/r4DdZ6gPBC3W0VDp3493dIVc0Sg/faBRnT1J34ie6TW7WvAun0NyT4NouFJ9nX3t4uPsUwul/zLy2OdXJ5IaQMrjVRrFmDUryqKkiuqoPvyyy/HXXfdhQ8//BCqqkJVVWzevBl33303rrzySr3PkYiIaNj50bWzsOG+8/HkZxahNEefTHAwssT8+a2noKpqyPv2O1x44CWxSufWJWNw69Kx+M1N8/Hhf6/Cty+fjiml2bA53fjn9lp87e87gh6nuccGh0uFQRF7uvUyvSwHE4ozYXO68WaKB7PN3TZ8/pmtuPuZrWjvtSf7dIiGHxl0S7oE3YPKy4cLo0nsaJ9uEv+xn3tEiSrofvjhhzFhwgQsXboUaWlpSEtLw7JlyzBx4kT88pe/1PkUiYiIhh9FUTC2KBNKrP2EGtyyZAwMCvDP7bX43cZjIe/76IajONbcg5JsK+67yPeGtyDTgjvOGYfXv3ou/nbXEgDARyda0dJtC3ices+O7uJsK8zGqN5OBCRLzAHglZ11uh03HjYdbYHLrcLpVrG3rjPZp0M0/MhhagAABSjQYRhzvMrLEyE7H7ghA7ghA2pOYfj707AR1b+SeXl5ePnll3Ho0CH84x//wPPPP49Dhw7hn//8J/Ly8nQ+RSIiIgpl2YQifPvy6QCAH712IGi589Gmbjy64SgA4H+umIGctKGli4qiYMn4Qswoz4GqijLvQPRcFzaYDLo3Hm5GW0/qZpA3HWvx3t5bF/n0eKIznn+mO68y9l3XwKCgexiVlwMD14ZxXdiIonmQ2r333hvy6xs2bPDe/vnPfx71CREREVHkPr1sLI40duMvH1bjK3/bjn98YRmmleV4v66qKr71z92wu9xYMaUYl84KvUZn5bRS7K3rxFv7G3HDwsohX/dOLtdpiJq/CcVZmFGeg711nXhtz2nctLhK9+fQw6ajvqB7Ty0z3UQRy60Sa72cffoMUQN8Pd2KEcgd+rsrpQ0IujlEbSTRHHRv375d0/0SUUZHREREAymKgu9eOQMnWnrw/pEW3PnUFrz0pbO9/dYvbKvF5mOtSDMb8L2rZob993rVtBI8/NZhbDzcBJvTBatp4M7s03HMdAMi2723rhOv7KxLyaD7dEc/jjf3eP9/DzPdRJEzGIDiyUD9Tn3WhQG+THde1fAbRKZkAQ+KC3jq89lJPhnSk+age/369fE8DyIiIoqR2WjAb29agGt++z6ONffgrj9vwbOfW4Jeuws/WLMPAPDVVZNRWRC+hHNmeS5Ksq1o7LJh87FWnDe5eMDX9V4XNtjls8vw49cOYPPxFjR09sd9GF2kNh1rBgBUFqSjprUPx5t70G1zIssa1TZWojPX6IUi6B49X5/jySnghTr0hyea/67uQHu7adjSb/IJERERJV1uhhm/v30hctPN2F7djvv/sQs/XLsfbb0OTB2VjTvO0dbjaDAoWDmtBADw1v6hPeLe8vK8+ATDFfkZWDAmH6oK/OLNQ3C7Q09lT7QPjojS8ktnlWFUThpUFdhfzxJzooitfhC47V/AzOv0Od6Uy4B5twLLv6HP8RLJP9BmefmIwqCbiIhohBlfnIVHb54Pk0HBv3bW4R9bTwEAfnDNrIgmja+cWgoAeGt/45BVZPHOdAPA584Vk4f/9nEN7nt+Jxwud9yeK1JyiNrS8YWYOVr0zmvdk05EfqzZwPjzAIMx/H21yCwErnoEqFqiz/ESKd23q1vNyEveeZDuGHQTERGNQMsmFuHBq2Z4///mxVVYMCayzMnZE4tgNRlQ296HA6e7vJ93u1U0dMa3pxsALp45Cr/85FwYDQpe3F6LLzyzFf0OV9yeT6ua1l6cauuDyaBg0dgCTC8Xb5T3cG0YEcXCP7udxunlIwmDbiIiohHq5sVjcP/FU3DRjFLcf/HU8A8YJN1ixDkTiwAMLDFv7rHB4VJhUIASz6C2eLl63mg8cesCWE0GrNvfiNv/+BG6+h1xfc5w5NTyOZV5yLSaMLNcZLr3MNNNRLGw+jLd3t50GhEYdBMREY1gXzx/Ih6/VfR4R2PVdFFivm6/b193fbvIcpdkp8EUQbl6tFZOK8XTnz0L2VYTPjzeipt+9yFaum1xf95g/EvLAWDmaPHm+HBjd0pk4olomPJbGaayp3tEYdBNREREQa2cKoap7ahpR2OXCLZlP/eoOPZzD7Z4fCGevWsJCjMt2F3bgRse34S69r6EPb+kqio+OComly+bIILustw0FGRa4HKrONTQFerhRETBZRYAk0ziv6yiZJ8N6YhBNxEREQVVkpOG2RUik7v+gMh2y8nl5XGaXB7MzNG5eO7upSjPTcOxph7c8NgmtPfaE3oOx5t70NBpg8VowHxPj7yiKJjhLTFnXzcRRamwErgpA85b8oEcBt0jCYNuIiIiCklOMZcl5qdlpjsnfkPUgplQnIXnv7AMFfnpqG3vw5rd9Ql9fllaPq8qD2lm37TlGd5hauzrJqIo5ZTBdfFPsG3MXYCiJPtsSEcMuomIiCgkua/7vcPN6He4UJeAdWGhjM5Lx6fOqgLgy74nygeeIWrLJgzMQnFtGBHpwb3gs6jPW5Ts0yCdMegmIiKikGaU56AsNw19Dhc2HW3BaU95eVmCy8v9rZgiLgS8f6RF8/Cyth47Pv2nj/C3j6qjek5VVbHZE3Qv9fRzSzM9me79p7tSap84EQ0jPT0w5eXhsk9+EujpSfbZkI4YdBMREVFIiqLgAs9AtXX7G7yD1JKV6QaAaWXZGJUjLgR8eLxV02P+vqUGGw424dsv78HRpu6In/NQQzdaeuxIMxswp3LgOp+qggxkW02wO91RHZuICACU3l6YbMnbzkDxwaCbiIiIwlo1TfR1v7W/EQ2dMuhOfE+3pCgKVkwtBqC9xHzNLtH/7XCp+O6/9kJV1Yiec5NnavmisQWwmowDvmYwKJjGYWpERBQAg24iIiIKa+mEQqSbjTjd2Q+HS4VBAUqyrUk9p/M9JeZvH2gMG0BXt/Rid20HjAYFFqMBGw834997T0f0fHKI2pLxhQG/LkvM97Cvm4iI/DDoJiIiorDSzEacM8k3PKwkOw0mY3LfRpwzsQhmo4Lq1l4caw7d/yinnC8dX4jPnzceAPDQq/vRZ9fWD+52q9h8TJSxD+7nlrzD1DjBnIiI/DDoJiIiIk1WeaaYA8CoJPZzS5lWExaPEwFwuBLzNbvrAACXzS7DF8+fiNF5YuXYb9Yf0fRc++o70dHnQJbVhNmjcwPeZ6bn8/vqOuF2R1a6TkREIxeDbiIiItJkxVRf0F2exMnl/uQ5rT8YPOg+0dyDPbWdMBoUXDRjFNItRnzniukAgCfePYbjYbLkALDZU1q+aGx+0Az/+KJMWE0G9NhdONHCycNERCQw6CYiIiJNSrLTMLcyDwAwKid5Q9T8rZgihql9dLwV3TZnwPvI0vJlEwpRkGkBAFw4vRTnTS6G3eXWNFQt2H5ufyajAdPKPMPU6jhMjYgiZDDAvXw5mmfMAAwM00YS/mkSERGRZnctH4+CTAsumlGa7FMBAIwvzsLYwgw4XCreO9wc8D5rPUH3ZbPKvJ9TFAXfvXIGLEYD3jnUhDf2NQR9DqfLjY+Oh+7nlrx93RymRkSRSk+Ha906vP+DHwDpqXFhk/TBoJuIiIg0u3RWGbZ9ezUWB5ngnQxyivmGACXmx5t7sLfOV1rub1xRJj63fBwA4Huv7As6VG13bQe6bU7kpJm8mexg5ATzvcx0ExGRB4NuIiIiGtYu8OvrHlwmvtavtDzfU1ru70srJqI8Nw217X14dMPQoWqqquL9IyKDvmR8IYwGJeS5yGFqe+o6It4DTkREI5Mp2SdAREREFIuzxhUg3WxEQ6cN++o7MaPcN118zS4RdF8+uyzgYzMsJnznium4+5lteOzdY6hp60NLjx2tPTa0dNvR0mOH3ekGEL60HAAmlWbBZFDQ3utAXUd/xN+Ly62is88R8AIBEY1wPT0wjR2Li+124ORJIC8v2WdEOmGmm4iIiIa1NLMRZ08UA878V4cda+rGvvpOmAwKLpw+KtjDcdGMUTh3UhHsTjf+ub0W7x5qwp7aTtR39HsD7vLcNFwyM3Dg7s9qMmJyaTaA6ErM73t+JxZ8/0389N8H4HC5I348EQ1vSnMzrJ1sTxlpmOkmIiKiYW/F1GKs29+A9Qeb8B8XTALgV1o+sShk5lhRFPz8E3Pxlw9PIt1sREGmBYVZFhRmWr23Myza3zLNHJ2DffWd2FffhckRfA8Olxv/3nsabhX4zfqjeO9ICx6+cS7GFGZGcBQiIko1DLqJiIho2FvhGaa2vboNbT125Gda8KosLZ8VPkNdnG3FV1dFEiIHN3N0Lp7bcgp76zoxOYJ5c7tOdaDX7kKmxQijQcHOmnZc+quNePCqmbhu/mgoSuh+ciIiSk0sLyciIqJhrzwvHVNHZcOtAu8ebsLRpm4cON0lSssTvN5sRrmYcL6vviuix20+JnaBnzupGK9/dTkWjytAj92F+57fiS8/ux0dfQ7dz5WIiOKPQTcRERGNCCs8U8zfPtCItZ4s9zmTipCXkdihZNPKcqAoQGOXDZ127Y+TQffSCYUoz0vHXz+3BN+4aApMBgWv7qrHpb/aiI9PtMbprInObI2d/dh9qiPZp0EjFINuIiIiGhFkifk7h5rwyq46AGKveKJlWEyYUJwFADjVo60k3O50Y8uJNgC+KelGg4IvrZiIf3xhGcYUZqC2vQ+3/eEjNHXZ4nPiRGewO57agqt+8x5qWnuTfSo0AjHoJiIiohFhflUectJMaO914FBDN8xGBReFmFoeTzM9JeanerTdf9epdvQ5XCjMtGBSSdaAr82tzMOae87FzNE56HO48OxH1XqfLtEZr7q1F24VONwYWVuIrgwGuBcsQNvEiYCBYdpIktQ/zXfffRdXXHEFysvLoSgKXnrppbCPeeedd7BgwQKkpaVh/PjxeOyxx+J/okRERJTyTEYDlk8u9v7/OROLkJthTsq5yF3hNRoz3ZuOitLyJeMLAw5My7Ka8LlzxwMAntl80rvKjIj00Wt3AgDq2vuTdxLp6XBt2oR3f/YzID09eedBuktq0N3T04M5c+bgkUce0XT/48eP49JLL8W5556L7du347//+79xzz334IUXXojzmRIREdFwcIGnrxtITmm5NK8qDwBwuEOBTUOAvOmYDLoLgt7nkpllKM62orHLhtf21OtynkQE2JwuOFwqAKC+oy/JZ0MjUVJXhl1yySW45JJLNN//scceQ1VVFX75y18CAKZNm4YtW7bgZz/7Ga677ro4nSURERENF+dNLkaa2QCDouDCJJWWA8C8qnyUZlvR0GXDe4ebcfHs0UHva3O6sPXkwH7uQCwmA25ZPAa/WHcIT31wAlfNDX5MItKu1+by3q5PZqabRqxhtad706ZNuPDCCwd87qKLLsIf/vAHOBwOmM1DS8hsNhtsNt/Akc7OTgCAw+GAw8HVG+QjXw98XVAgfH1QMHxtpJYcqwHP3nEWDAYgw5zcP5eLpxfjqQ9P4V8767ByWknQ+2050Qqb042iLAuq8qwhz/mG+WV4ZP1hbKtux9bjzZhdkRuPU6c44++N1NLe4wu0a9t7k/fn0tsL4+zZWN3XB8e+fUAu/36nOq2vlWEVdJ8+fRqlpQN3bZaWlsLpdKK5uRllZUPLyH70ox/hwQcfHPL59evXIyMjI27nSsPXm2++mexToBTG1wcFw9dG6jmxPbnPX9gLACas29+Af76yFlZj4Pu9XqMAMKLS2o/XXnst7HHn5BuwpdmAH7+wCbdMYm/3cMbfG6mhzvN3FQCO1rdi7dq1STkPY38/Lq+uRgaAV996C660tKScB2nX26tt2v2wCroBDBkuoqpqwM9L3/zmN3Hvvfd6/7+zsxOVlZVYsWIFCguDl3DRmcfhcODNN9/E6tWrA1ZN0JmNrw8Khq8NCsZut+PpQ+vRbFNgGjMPl84O3GP+1z9+DKAN15w9A5cuqgx73IpTHbju8Q+xo82Ih5evQFGWVeczp3jj743Usr26Hdj5EQCgy2nEJZdcGDS2iKse37qDCy64AOa8vMSfA0VEVlGHM6yC7lGjRuH06dMDPtfY2AiTyRQ0gLZarbBah/5jZDab+UuOAuJrg0Lh64OC4WuDAplfpOKNWgVr9zTg2gVVQ77e73Bhe00HAODsSSWaXkMLxhVhbmUedtS04/lt9bhn5STdz5sSg783UkO/r6UbNqcbXXYVhVmWxJ+I32uBr43hQeuf0bBaALd06dIhZThvvPEGFi5cyBclERERpZz5RaL8+51DTWjvtQ/5+vbqdtidbpRkWzG+KFPzcT9z9lgAXB9GpAe5Lkyq7+AwNdJXUoPu7u5u7NixAzt27AAgVoLt2LED1dXVAERp+G233ea9/913342TJ0/i3nvvxf79+/HHP/4Rf/jDH3Dfffcl4/SJiIiIQirLAKaUZsHhUvH6ntNDvu5bFRZ4P3cw/uvDXt879LhEpF233/RyAKhr59ow0ldSg+4tW7Zg3rx5mDdvHgDg3nvvxbx58/Cd73wHAFBfX+8NwAFg3LhxWLt2LTZs2IC5c+fioYcewsMPP8x1YURERJSyLp8lVpf9a2fdkK9t9gTdoVaFBWIxGXDzYlGu/uT7x2M8Q6Iz2+BM9+lOZrpJX0nt6T7//PO9g9ACefLJJ4d87rzzzsO2bdvieFZERERE+rls9ij837oj2HSsBY2d/SjJEROJ+x0u7KhuByAy3ZG6aXEVfrP+CLZVt2NnTTvmVObpeNZEZ45u28Cguy5Zu7oVBeq0aejq7kZ6Mga5UdwMq55uIiIiouGmMj8D86ryoKrAq7vqvZ/fdrINdpcbo3LSMLYw8jWmJdlpuHx2OQDgqQ9O6HW6RGecXk95uYxz6zuSVF6ekQHnzp1Y/+tfA1xtPKIw6CYiIiKKsyvniODYv8R8k19pebTriW5fNhaACOabumyxnSTRGUpmuqsKRKBbn6xMN41YDLqJiIiI4uyy2WUwKMCOmnZUt/QCADYdlUPUCqI+7tzKPMytzIPd5cazH1WHfwDpqrGrH+v2NcDtDt4uSamvxxN0TyzOAgDUJSvTTSMWg24iIiKiOCvJTvMOS3tlVx167U7sPNUOAFg6viimY3/ak+1+bktNyFk5pK8NBxtx0S/exZ1Pb8HaPfXhH0Apq9cuyssnloigu6GzPzkXUnp7YZozByu+/GWgtzfxz09xw6CbiIiIKAG8JeY76rD1ZBscLhXluWmoLEiP6bgXziiF1WTAqbY+HDjdpcepUggut4qfv3EQn3nyY7T1OgAAH3iqFmh4kuXl44oyYVAAh0tFc08S2jVUFcr+/cipqQF4AW1EYdBNRERElAAXzyiD2ajgYEMXnvrgJABgSQz93FKGxYRzJ4ls+Zv7GmI+TwquuduG2/74IR5++whUFZhXlQdADMWj4UuuDMtJN6MkW2wXYF836YlBNxEREVEC5GaYcd7kEgDAuv0iOF4axaqwQC6cLnaBRxJ0bzragh+u3T9kXRIF9tHxVlz6q414/0gL0s1G/OrGuXjslgUAgEMNXfw5DmPdnunlmVYTyvI8QTf7uklHDLqJiIiIEuTKueUD/j+a/dyBXDCtBIoC7K7tQF17+GDB7VZx3/M78cS7x/DQK/t0OYeRSlVVPP7OUXzqd5vR2GXDxJIs/Os/zsZVc0ejNCcNo/PS4VaBnTXtyT5VipIcpJZlNaI8V7R7JG1XN41IDLqJiIiIEmTVtBKkm40AgIr8dFQW6LOLtyjLigVV+QB8WfRQNh1rQa0nOP/7lhq8e6hJl/MYadxuFd96aQ9+9NoBuNwqrp5bjpe/dDYmlWZ77zN/jPi5s8R8+JLl5RkWE8pyRab7dCeDbtIPg24iIiKiBMmwmLB6eikA/bLc0oUzxHG1lJg/v6UGAJBtNQEAvvnibpZHD+J2q3jg5T3464fVUBTgoatm4BefnItMz89Mmi/7uqsZdA9X3d5MtwmjPEG3looRIq0YdBMREREl0H9eMhU3L67CV1ZO0vW4qz193ZuOtqCjzxH0fp39Dry+9zQA4LFbF6CyIB217X348Wv7dT2f4cztVvFtv4D755+Yg1uXjg049G6+p8JgW3U793UPQy63in6HGwCQYTGiPE+Ul9d3JCHTrShQx4xBb3ExEOOARUotDLqJiIiIEmh0Xjp+cM0s3UrLpXFFmZhYkgWnW8WGg41B77dmVz36HW5MKM7EsgmF+N9rZwMAntlcjU1cfQVVVfGdf+3BXzwB9//dMAfXzKsIev9pZTmwmgzo6HPgWHNPAs+U9NBj91V4ZFp95eX1ych0Z2TAefgw3vzd74AMfX8/UHIx6CYiIiIaIS6cHr7EXJaW37CwEoqiYNnEIty0uAoA8J8v7PL2t56JVFVkuJ/ZLALun10/B9fODx5wA4DFZMDsilwALDEfjno9k8tNBgVWk8Gb6W7ossHFygXSCYNuIiIiohFC9otvONgEm9M15OtHm7qxrbodRoOCa+eN9n7+m5dMRXluGqpbe/Gzfx9K2PmmElVV8Z2X93oD7p9ePwfXLQgdcEtymNp2Bt3DjuznzrAYoSgKirKsMBkUuNwqmrpsST47GikYdBMRERGNEHMq8lCSbUW3zYnNx1qHfP0fW08BAM6bXIySnDTv57PTzPjhtbMAAH/64Di2nBj62JFMVVU8+Mo+/HnzSSgK8JPrZuN6jQE34NfXfbI9TmdI8dLjN0QNAIwGBaWevxt1id7V3dcH49KlWH7ffUAfB7mNJAy6iYiIiEYIg0HBKm+J+ekBX3O5Vby4TQTdgQLK86eU4PoFFVBV4P5/7EK/Y2imfKTadaoDT35wAooC/O91s3HDwsqIHi+D7kONXejsDz7EjlKP7OnO8JtK7+vrTvAwNbcbhq1bkX/kCOB2J/a5Ka4YdBMRERGNIKv9+rr9p2lvPNyEhk4b8jLMWDmtJOBjv33ZdJRkW3GsuQe/WHfmlJlv8ezYvmBKCT4RYcANAMXZVlQWpENVthf64QAAa5ZJREFUgZ017TqfHcVTj6en238VXJl3gjmzzaQPBt1EREREI8iyCYXItBjR0GnD7toO7+ef95SWXz13NKwmY8DH5maY8YNrRJn57zceR+0ZsqtYBspzK/OiPobMdm89yb7u4UQODsy0+P5OlHt3dSdhbRiNSAy6iYiIiEYQq8mI86eITLacYt7ea8ebe8XtcL3Kq6eXYun4QrjcKv72UXV8TzZF7DrVDgCYo0PQva26PfYTooSRg9QyA5WXM9NNOmHQTURERDTCyBLzNzx93a/srIPd5cbUUdmYUZ4T9vG3LBkDAPjbxzVwuEZ2b2l7rx0nWnoBwLv6KxoL/CaYu7lqatiQK8Oy/ILuUbmyvJyZbtIHg24iIiKiEWbFlBKYDAoONXTjZEuPt7Rc7uYOZ/X0UhRlWdHUZQu583sk2HlKlOCPK8pEXoYl6uNMHZWNdLMRXf1OHG3q1uv0KM78V4ZJ5XnMdJO+GHQTERERjTC5GWYsHl8AAHjk7SPYdaoDJoOCq+eWa3q8xWTAjYvEQLG/fHgybueZCmQ/dyxZbgAwGQ3eY2zjvu5hY/DKMAAo82S6G7tsCa/0UIuKYMsJX41CwwuDbiIiIqIRaPU0UWIus9wXTC1BYZZV8+NvPKsSigK8f6QFx0Zw5lYG3XMq8mI+1vwx2vZ1O0d4yf5w0mMX5eUZFl/QXZhpgcVogKoCDZ0JLDHPzISzrg6vP/00kJmZuOeluGPQTURERDQCrZ4xasD/R7p7uiI/Ays8A9n++uHIHKimqip26jBETfINUwue6T7W1I3lP3sXTx7i2/BU0OMdpOYrLzcYFIzyDlNjXzfFjn/biYiIiEag0Xnp3qFpRVkWnD+lOOJj3LKkCgDwj22n0O9w6Xp+qaCuox/N3XaYDIqmAXPhzKvKAwAcbuxGR59jyNedLje+/vxONHXbsadV4cC1FOBdGeZXXg6AQTfpikE3ERER0Qh1zbzRAIBPnVUFszHyt33nTS7B6Lx0tPc6sHZ3vd6nl3SytHxqWTbSzIF3l0eiKMuKsYUZAMQU88Ge2HgM2z0rxRyqgoYuW8zPSbEJtDIM8O3qrk/krvq+PhhXrcLZ3/oW0MchbiMJg24iIiKiEeqzZ4/DP7+4DF9dNTmqxxsNCj51lihLf2bzyBuopmc/txRsX/eB0534xZuHAAAmg5ggf6KlR7fnpej02uXKsIEXXcrykrA2zO2G4d13UbR3L+Bm3/9IwqCbiIiIaIQyGBTMq8qH0RB+TVgwn1hUCZNBwbbqduyr69Tx7JJvhwy6dejnlub57euW7E437v37TjhcKlZNK8XZEwoBACdbmM1MNt/KsMCZ7rpEZrppxGLQTURERERBlWSn4SLPULa/fjRyst0ut4rdtWJHt76ZbnGsHdXt3p7tR94+jH31ncjPMOOH187EGE8J+snWXt2el6ITaGUY4Fsbxp5u0gODbiIiIiIK6ebFYqDaP7fVejODw92Rxm702l3IsBgxsSRLt+NOKc1GhsWILpsThxu7sbOmHb/ZcBQA8P2rZ6EkO83b932yhUF3svXa5MqwgeXlHKRGemLQTUREREQhLZ1QiPFFmeixu/Dyjtpkn44u5KqwWaNzYyq/H8xkNHgz55uONuPrz++Ey63iijnluGx2GQD4Mt0MupNKVVX02ANnuss9Pd3N3TbYnCNvcj8lFoNuIiIiIgpJURTc5Ml2P7O5Gqo6/FddySFqc3Xs55bmjxHH/N/XD+JIYzeKs6343pUzvF8fU+ArL+fasOTpd7ghf/yDp5fnZ5hhNYlQqaGDU+YpNgy6iYiIiCis6xdUwGIyYH99J7Z7AtbhTGa69RyiJi3wDFPr8+w2//G1s5CfafF+fXReGgyKCpvTjYYuli8ni3+rRPqglXGKoniz3XUdiRumpmZkwGm1Juz5KDEYdBMRERFRWHkZFlzuKY/+yesHUDOMh4D1O1w4UN8FID5B97zKfO/tTyyswMpppQO+bjIaUOCJq040D9+f43Anh6hlWowwBGgxKPP2dSco6M7MhLO9HWv+/ncgMzMxz0kJwaCbiIiIiDT5zLJxMBkUbD7WihU/24D//McuVA/DvuS9dZ1wulUUZVm8q6H0lJ9pwc2Lq7BsQiG+ffn0gPcpThN1zdzVnTyynztjUGm5xGFqpBcG3URERESkyayKXDx391KcO6kITreKv2+pwYr/24BvPL8TJ4dR8Cj7uedU5EFR9Bui5u8H18zCXz+3BNlp5oBfL/bE+gy6k6fHM7l88BA1qVyuDWtn0E2xCfwKIyIiIiIKYH5VPv58x2JsPdmKX647jI2Hm/H81lN4cXstrpxTjqIsCzr6HOjoc6C9V3zs7HMgzWLEk58+C1Weyd3JtCuO/dxaFXky3SdZXp403kz3oHVhUllegsvL+/thvPZaLG5sBC64ADAHvmBDww+DbiIiIiKK2IIxBZ7guw0Pv3UY7xxqwj+3h14n9sTGo/j+1bMSdIbB7TzVASC5QTcz3cnn7ekOk+muS1Sm2+WC4bXXMAqAw8U1ZSMJg24iIiIiitqCMfl46rNnYXt1G/61sw5mowG56WbkpJuRm25GXroZ9R19+M8XduOf22rxX5dMC1rOqxeXWw26e7u9147jzSLQnVORG9fzCKXIr6dbVdW4lblTcL1hyssTnummEYtBNxERERHFbF5VPuZV5Qf8mqqqePzdYzjW1IOXttfiliVj4nYeP37tAJ7edAIP3zgPq6aXDvn6Lk+We2xhBvIyLEO+niiFVsBoUNDvcKOh0+Yd2kWJI1eGBS0vzxGZ7rZeB/odLqSZA9+PKBwOUiMiIiKiuFIUBTcvFoH2M5tPQlXVuDxPR68Df3r/OHrtLnz52e3egWn+5OdmV+TF5Ry0MhrEvm6AJebJIsvLg2W6c9JN3oCcE8wpFgy6iYiIiCjurp9fgTSzAQdOd2Hryba4PMcL207B5nQDAPocLtzx1MdD9onvTIEhatKYAjFUbjhNfh9JeuyivDzDEjjoVhTFt6u7nSXmFD0G3UREREQUd7kZZlw5pxyAyHbrTVVV/OVDcdz/umQqppfloLnbjtv/9BHae+3e++yoEeXlcyuT188tjfVMcj/OCeZJ4ct0By8bL8/zDFNjpptiwKCbiIiIiBJC9nKv3X0aLd02XY+9+Vgrjjb1IMNixM2Lq/CnzyxCeW4ajjX14HNPb0G/w4X6jn40d9tgNCiYUZ78oFuuT2OmOznkyrBg08sBMNNNumDQTUREREQJMbsiD3MqcmF3ufHcllO6Hltmua+eNxrZaWaU5qThT585C9lWEz4+0Yb7nt+J7dXtAICpo7JTYiiWLC+X09QpsWSmOyNE0D3KszasvjMBme7MTDjsdrz80ktAZmb8n48ShkE3ERERESXMzZ5s918/Ogm3W5+Bak1dNvx772kAwE1nVXk/P2VUNh6/dQHMRgWv7qrHg6/sBZAa/dyAr7z8ZEtv3IbLUXC9drkyLER5OTPdpAMG3URERESUMFfMLkdOmgk1rX1453CTLsd8bksNHC4VcyvzMHP0wLLxZROL8L/XzQYANHaJkvZk7uf2NzovHQZFDH1r6tK33J7C860MC1Fe7unp5vRyigWDbiIiIiJKmHSLETcsrAQAPLMp9oFqLreKZz+qBoCg+7+vnV+Br6+e7P3/VMl0W0wGVOSzxDxZwq0MA3yZ7tq2vvhXI/T3w3jjjVj4k58A/QzyRxIG3URERESUUDcvFiXgbx9sxKm2wJO7u21O/PG94/j4RGvIY717qAmn2vqQk2bC5bPLgt7vPy6YiPsvnoIvnj8BU0qzoz95nY3xKzGnxOqxyZVhwcvLqwozYDYq6LI5caotziXmLhcML76I0R98ALhc8X0uSigG3URERESUUOOLs3D2xEKoKrxZaklVVby8oxYr/28DvvfqPtz0u83YcLAx6LHkALXrF1SGHI6mKAq+eP5E3H/xVCiKos83ooOxhWJg1glOME84Ob08VKbbajJi6qgcAMDu2o6EnBeNPAy6iYiIiCjhbvWUgv/94xrYnW4AwMHTXfjU7zbjK3/bgYZOG9LNRjhcKj7/563YdLRlyDFq2/vw9gERkN+8pGrI14eDsUUMupOl15PpDrUyDIB3TgCDbooWg24iIiIiSrhV00pRmmNFc7cd/9h6Cg+9ug+XPrwRm4+1Is1swNdXT8bHD6zCqmklsDnduOOpj7H1ZNuAY/zto2q4VWDp+EJMKM5K0ncSGznB/EQzy8sTye50w+4SF3syQwxSA4BZMug+xaCbosOgm4iIiIgSzmQ04MZFIjv93//cjT+8dxwut4qLZpTiza+dhy+vnIQsqwmP3DQf504qQq/dhU//8SPs8WQbHS43/vZxDYDgA9SGA/9MN9eGJU6vp7QcADJCrAwDgNkVvkw3/4woGgy6iYiIiCgpPnVWFUwG0V89rigTT332LDx+60JUFmR475NmNuLxWxdg0dh8dNmcuPUPH+Lg6S68ua8BTV02FGVZsXp6abK+hZhV5Iu1Yb12F5q6uTYsUeS6MIvJALMxdEg0uTQbFqMBHX2O+A9ToxEpdC0FEREREVGcjMpNw+9vX4jTHf24Zv5oWE2BM44ZFhP++OlFuOX3H2LnqQ7c/PsPMSrXCgD45KIKWEzDN49kNRlRnpeOU219ONnSi5LstGSf0hlBTi4PNURNspgMmDIqG7trO7DrVMeAi0JEWgzf31BERERENOydP6UEN55VFTTglrLTzHjqs2dh6qhsNHfbsKe2E4oisuXD3ThPiTl3dSeOnFweal2Yv1kVCRimlpEBR1sbXv3b34AMBvYjCYNuIiIiIhoW8jIseObOxZhQLILUFVNKUJE//IMT365uBt2J0mMLvy7MnxymtieeQbeiAJmZcKWlids0YrC8nIiIiIiGjaIsK569awme/bAG1y0YnezT0YV3VzcnmCdMj8Z1YdKs0QOHqaXSrndKfQy6iYiIiGhYKclOw1dWTUr2aejGG3Qz050wMtOttbzcf5haTWsfqgrjUGFhs8H4uc9h3qlTwMqVgNms/3NQUrC8nIiIiIgoicYWyfLyXt1XUh1v7kF7r13XY44Esqdba3m5xWTA1LJsAMCu2vb4nJTTCcOf/4yq9esBpzP8/WnYYNBNRERERJRElQUZUBSxxqq5W78Aua69Dxf94l1c/MuNaOzq1+24I4EsL8+waC/89S8xp+Ryu1Xv2rfhgEE3EREREVESWU1GlOemA9B3mNr26nbYXW6c7uzHl/6yDXanW7djD3e+QWraysuBBA1TI03ue34nFjz0Jmpah8ccBAbdRERERERJJkvMT7ToF0QcON3pvf3xiTb8YM0+3Y493Mnycq2D1ABgpsx0n+rQvQ2AIrPlZBtsTje2nmxL9qlowqCbiIiIiCjJfBPM9ct076/vAgBcMLUEAPDUppN4Yesp3Y4/nMlMdyRB9+TSbFhMBnT2O1E9TDKsI1Vrj2jDYKabiIiIiIg0iccEc5np/vzy8bhnpZj2/t//3M3yaAA9ds/KMI3TywExTG3aKDFMjX3dyWNzurz93DVtDLqJiIiIiEiDsUX6Bt2d/Q6causDAEwdlYOvrpyEC6aWwOZ04/N/3urNFJ6pvCvDIsh0A8CsCl+JOSVHe6/De7umtS+JZ6Idg24iIiIioiQb69n7fLJZn7Vhh06L0vLy3DTkZphhMCj4xSfnYmxhBmrb+3DPs9vhdJ25g9V8g9QiDLrjOcE8IwOO2lq89tRTQEYc9oCPEC1+E/6Z6SYiIiIiIk3k2rAum1OXLPR+T9A9tSzH+7ncdDMev3UhMixGvHekGT9942DMzzNc+VaGaS8vB/yGqdXGYZiaogDFxbDn5orbFFCb3975uvY+OIbBxSMG3URERERESZZm9q0N06PE/EC96Oee4ulBlqaMysZPrp8NAHj8nWP4997TMT/XcCSnl0ea6ZbD1Lr6nTip46R50s7/opRbBerbU38HPYNuIiIiIqIUMMZTYn6iOfZg7oDMdA8KugHg8tnl+OzZ4wAAf950MubnGo5kpjuS6eUAYDYaMM1TPaB7ibnNBsM992D2448DNpu+xx5B/DPdwPAoMWfQTURERESUAvQapuZ2qzjoCbqn+ZWX+7tuwWgAwM6adrjdZ97Oae/KMEtkQTcAzBodp6Db6YTxsccw7rXXAKdT32OPIP493cDwWBvGoJuIiIiIKAWM9wTd++o6YzpObXsfum1OWIwGjPMcc7AppdlINxvRZXPiWHN3TM833LjcKvocMtMdWU83AMwenQeAE8yThZluIiIiIiKKyrIJRQCA9482o8+zRzoasrR8YkkWzMbAb/dNRoN3Evf26vaon2s46rX7ssiRlpcDvmFqe+o6zsgqgWSTPd1luWkAhsfaMAbdREREREQpYFpZNspz09DvcOP9I81RH0cOUZtaNrSf29/cqjwAwI6a9qifaziS/dxGgwKrKfJwaFJplm+Y2jAobR5pZNA927MznZluIiIiIiLSRFEUrJpeCgBYt78h6uPITPe0UYH7uaW5lXkAzrxMt5xcnmkxQoliNZfZaMD0eA1To7B8QXceAGa6iYiIiIgoAqumiaD7rQONUZcu7z+tLdM9z5PpPtjQFVM5+3DjHaIWRWm5JEvzd59q1+OUKAKyp3uOJ+hu7ral/OuXQTcRERERUYpYPL4AWVYTmrps2BVFFrXP7sKJZjH9fGqYTHdZbjpKc6xwudUzKmMb7bowf7M8pc1n0s8tFaiqirYeBwBgXHEmsj1/hqdSvMScQTcRERERUYqwmow4b3IxAGDdvshLzA83dsGtAkVZFhRnW8PeX5aY76hpi/i5hivfurDIJ5dLMtO9t7ZTv2Fq6elwHDqENx5/HEhP1+eYI0y3zQm7yw0AKMiwoKJA7LZP9b5uBt1ERERERClk5bQSANH1dR+oF/3cU0aFLi2X5lbmAzizhql5e7pjyHRPKsmC1WRAl80Z8151L4MBGDsWfaWl4jYNIbPc6WYj0i1GVOaLixOp3tfNP00iIiIiohSyYkoJDIoYiFYT4XRsbz93mNJy6UwcpibLyzMs0QfdJqMB08s5TC3RWj393AWZFgBApcx0p/gUeQbdREREREQpJD/TgoVjCwAAb0WY7ZaZ7qkaM92zK3JhUID6jn40dPaHvf/Xn9uJy3+9ER29jojOK5XI8vIsa/Tl5YCvxHyPXkG33Q7Df/0Xpj/5JGC363PMEaatZ1DQLTPdLC8nIiIiIqJIrJ4mV4c1an6Mqqo44Ml0TyvTlunOtJowuVQE6OGy3cebe/DCtlPYU9uJpzad0HxeqUaP8nIAmOkNujtjPicAgMMB489/jkkvvQQ4hu9FjXhq8QTd+UMy3SwvJyIiIiKiCMh93R8eb0Fnv7YArLHLhrZeBwwKMLEkS/NzydVh4fq6X91Z5739x/ePezPGw40eK8MA3x70gw1dUFWdhqlRSN5Md4YZAFDFQWpERERERBSNcUWZGF+cCYdLxbuHmjQ95sBpUVo+vjgLaWbtpdNaJ5i/sksE3UaDgvZeB579qFrzc6SSHs9O58wYeroBYFJpFgwK0NpjR1O3TY9TozBkT7fMdFfki6C7q9+Z0i0PDLqJiIiIiFKQt8Rc4+qwA/VyiJq2fm5pXpWYYL7rVAdcQdZfHTjdiUMN3bAYDfivi6cCAH638RhsTldEz5UKfJnu2Hq608xGjC3MBAAc9FzwoPhq7RZBd6En6E63GFGUJVbjpXK2m0E3EREREVEKkiXm6w82wenZTRyKzHRr7eeWJhRnIctqQq/dhUMNgYPHVzyl5edNKcbty8aiLDcNDZ02vLitNqLnSgV6lZcDvtVsDLoTY3CmGwAqC+TaMAbdREREREQUgflV+cjPMKOjz4EtJ0OXfgPA/igz3UaDgtkVYihYoL5uVVXxys56AMCVc8phMRnwuXPHAwAee+eopgsCqcS3Miy2TDfgC7oPMOhOCF9Pt1/QnZ/6fd0MuomIiIiIUpDRoOCCqdpKzO1ON442dQMApkaY6Qb8+roDTDDfeaoD1a29SDcbsXJaCQDgxrMqUZBpwcmWXqzZXR/x8yWTnF6epUOmeyoz3Qk1eE834Mt0VzPTTUREREREkVrlCXLX7W8IOSH7WHM3HC4V2WkmlOemRfw8vmFq7UO+9q8dorR89fRSZHiGj2VYTPjMsrEAgEc3HB1W07v1LS8XFzgONXQF7YfXLD0dju3b8fbDDwPp6TGf20jU2hMg6M5P/bVhDLqJiIiIiFLUuZOLYTEacKKlF0ebeoLe70C9yLROHZUNRVEifp65nrVhhxq70OW3oszlVvGqZ2r5FXPKBzzmtqVjkWU14cDpLrx9QPs+8WST5eWxTi8HxMqqNLMBNqcbJ1uC//loYjAAM2agq6pK3KYBnC43OvrEa3NgTzfLy4mIiIiIKEpZVhOWTigEILLdwew/Lfu5Iy8tB4CS7DSMzkuHqgK7T3V4P//R8VY0dtmQk2bC8slFAx6Tm2HGLUvGAAAeWX9k2GS7ZXl5rNPLAdECMLmUJeaJ0NHngHyJ5aWbvZ+Xme5TbX1wx1ptECcMuomIiIiIUpicYh6qr9ub6S6LbIiaP5nt3u5XYi53c188cxSspqFB6h3njIPVZMD26nZsPtYa9XMniqqqupaXA8CUUp2GqdntMHzve5jy7LOA3a7DmY0sbZ5+7rwMM0xGXxhblpcGgyLmGqTqvnQG3UREREREKWzlVNHXvbW6DS1BgooDMWa6AWDeoL5uh8uN13bLqeWjAz6mONuKTy6qBAD8dsORIV93uVXsqe3AP7aeCnruidTvcEMmQ3ULuvUapuZwwPj972Pq3/8OOBzh73+GaekeOrkcAMxGA8pyU3ttmD6vNCIiIiIiiovyvHTMKM/B3rpOfPEv2/B/n5iDCk9JLSDWKDV0ioB2SoTrwvzJYWrbq9uhqireO9KMtl4HirKs3hL3QO5aPh5//bAaGw834+MTItv90fFWfHS8FdtOtqHLk1meX5WHf9y9DAZD5D3nepGl5QCQYY69vBzwXeg4GGTHOemjLcCObqmyIB217X2oaevFwrEFiT61sJjpJiIiIiJKcfdfPBUZFiM+PN6KS365ES9uO+XtoZZlzVUFGTGtwZo5Ohcmg4Lmbhtq2/vwyk5RWn7ZrFEwhgiUK/IzcNVckQm/4bFNuOGxTfjpvw/inUNN6LI5kWU1wWIyYFt1O17cXhv1+elBlpZnWIy6Bf/yQseJlh702V26HJOGau3xDFHLCBB0p/gEcwbdREREREQp7rzJxXjtK+diflUeumxO3PvcTvzHX7ejrcfuV1oefZYbANLMRkzz7Pj+8Fgr3tgresivnFse6mEAgC+cPwEWkwgtirIsuGTmKHzn8ul49cvnYOf/XIh7V08GAPz4tf3o7E9e6bR3crlOpeWA+H4LMi1QVeBwI7Pd8dLaI6o5CgNmumXQzfJyIiIiIiKK0pjCTDz3+aV47J2j+OW6w1izux4fn2hFeZ7oZ51aFn0/tzS3Mg+7azvwyPoj6LY5MTovHfMq88M+bmJJFt669zzYXW6ML8ocsrbss2ePw3NbanCsqQe/fPMwvnPF9JjPNRreyeUWfUrLAUBRFEwpzcamYy04cLoLsyvydDs2+Xgz3UHKy4HUXRvGTDcRERER0TBhMhrwHxdMwotfXIbxxZlo7LJ5B59NizHTDfj6uo83i53Tl88p01yGXVmQgQnFWQH3hFtMBnz3ihkAgKc2nUjaei29J5dLug1To6BkT3dBpnnI11heTkREREREuppdkYc1Xz4Xty8Ve7IVRfRkx0quDZOumB2+tFyr5ZOLcfGMUXC5VfzPv/YkZa+3t7zcom/QPZVBd9y19sig2zrka7K8vL6jDw6XO6HnpQXLy4mIiIiIhqF0ixEPXjUTV84tR3uvwxt4xGJcYSZy083o6HNgfHEmZpTHXrLu74HLp2H9wUZsPtaKV3bV48o5+gX1Wvgy3fqVlwO+THdMu7rT0uD84AO8//77WJaWptOZjRy+oHtoprs4ywqLyQC704369n5UFcb+d0FPzHQTEREREQ1jC8YUYOW0Ul2OZTAomO/Jdl8xuzxgqXgsKvIz8KUVEwEAP1izzxsE62n3qQ702gMf19vTrXN5+eRSEXQ3d9ui30duNEJduBDtkyYBRn0vCowEMugONL3cYFBQkZ+6fd0MuomIiIiIyOu/L52GL18wEZ8/b3xcjn/X8vGoKshAQ6cNv377iK7H/tfOOlzxyHv4n5f3Bvy6N9Otc3l5ptWEKk+lAUvM48PX0z006Abg/fmn4gRzBt1EREREROQ1qTQbX79wCjJ0DkylNLMR37lcTC//w3vHcLSpW7djP7P5JADg9b2nA/b29tj1XxkmxVpifrqpE3/75FfR/PhLqGvs0PPUhr1+hwu9nj+7YEG3d5gaM91ERERERHSmWzW9FBdMLYHDpeK7/9qry1C1mtZefHS8FQDQ1e/EtpNtQ+4Tr55uILZhajWtvbj18Y249Z+/xR2vPYkbfvM+Xt5Rq/cpDluytNxsVJAV5IKJd21YCk4wZ9BNREREREQJ953Lp8NiNGDj4Wa8sa8h5uO9uG1gkLr+YNOQ+3inl8cz090QWdB9pLEL1z/2AU619ns/19XvxFf+tgNffnY7Onodup7ncOTfzx1szgAz3URERERERH7GFmXiruWib/x7r+xDv8MV9bFUVcWL208BAM6fUgwA2HCwccj94rWnG/Blug83dMHt1pa531PbgU88vhkNnTZMKsn0fv6L54+D0aDglZ11uPhX7+KDI826n+9wEq6fG/CtDWOmm4iIiIiIyOOLKyagPDcNte19eHTD0aiPs/VkG0629CLDYsQPr5kFgyJ6q+vaBwZg3unlFv3Ly8cWZsJiMqDX7tKUbd16shWf+t1mtPbYMbsiF099drH3a3cvH48XvrAM44oyUd/Rj5t+/yEeejW2CxPDmW9dWIig25Ppbu62BZ1enywMuomIiIiIKCkyLCY84Bmq9ug7R1HdEl1p8AvbRJb7kpllKM9Lx7yqfADAhkEl5vHMdJuMBkwszgIQfpjae4ebccvvP0JXvxNnjS3AX+5cjPxBAeXcyjysuecc3Ly4CgDwh/eO43NPb4EzwIC4kc5bXh4i6M7NMCM7Tfy5nmpLrWw3g24iIiIiIkqaS2aOwjkTi2B3uvG9V/dF/Ph+hwuv7qwHAFy3YDQAYIWnxHz9oBJzb093nCazaxmm9tb+Bnz2yY/R53Bh+eRiPPXZs5CdZg543wyLCT+4Zhb+cPtCpJuN2Hi4GT9942Bczj2VtclMd4Ad3f68fd0ptjaMQTcRERERESWNoij47pXTYTIoWLe/AesPDO3FDuWNfQ3osjkxOi8dS8YVAgDOn1ICAHj/SDNsTl9Jtre8PA7TywHfMLVgQXdtex/ueXY77C43Lp4xCr+7bQHSNZS6r5xWip/eMBsA8Pg7x/DKzjr9TnoYaNXQ0w34TzBn0E1EREREROQ1sSQbnz1nHADgwVf2DgiUw3nRU1p+7fzRMBjEZOvpZTkozrai1+7Cx8d9q8PiWV4O+O/q7hzyNVVV8c0Xd6PH7sLCMfl45KZ5sJr8Au60NDjffBPvPfQQkJY25PGXzy7H588Tg+fu/8cu7K8f+hwjlZaebsB/gjnLy4mIiIiIiAb48gUTUZJtxYmWXvx+43FNj2ns7Me7h0Tf9jXzRns/bzAoOH/y0Cnm8VwZBgBTR+UAAE609A4ZevbCtlq8e6gJFpMB/3v9bJiMg0IxoxHqeeehZdYswBg4+33/RVNx7qQi9DlcuOvPW9DuyQCPdFp6ugH/CebMdBMREREREQ2QnWbGf186DQDwyNtHhkweD+SlHbVwq8D8qjyM9wwxk1ZMFSXmsq/b7nTD7hlClhWnnu7SHCty081wuVUcaez2fr6xsx/fe2UvAOBrqyZjwqBz1cpoUPDrT81DZUE6alr78OVnt8OlcT3ZcNbWI3aVh+3pluXlzHQTERERERENddXccpw1tgB9Dhd+sHZ/yPuqqooXttYCAK5bUDHk6+dMKoLRoOBoUw+qW3oHrJHKiFNPt6IoQ/q6VVXFAy/tQWe/E7NG5+Jz544L/GCHA4ZHH8W4tWsBhyPoc+RlWPD4LQuRZjZg4+Fm/OwMGKzWEmF5eXVLj6aLNonCoJuIiIiIiFKCoih48KoZMCjAml31eP9Ic9D77q3rxMGGLlhMBlw+q3zI13PSzFg4xrM67FAjeuyi3NtiMsA8uLRbR94J5g0i6F6zux5v7GuAyaDgJ4HKyiW7HcavfAWzn3gCsIcuG59enoOfXD8HAPDohqNYs6tev28gxaiqijbNg9QyUJJtRY/dhdU/fwdPvn88JSoBGHQTEREREVHKmFaWg9uWjgUAfPvlPTjZ0hPwfnI39+pppcjNCLxyS04xX3+g0TdETcO08Fj4hql1obXHjv95WZSVf2nFREwry9Htea6cU467lovBavc9vxNHGkPvBh+uOvud3sA5L8ifs5RmNuIvdy7GgjH56LG78N1X9uH6xz4IONgukRh0ExERERFRSvna6skoyrLgWFMPVv7fO/ifl/egudvm/brD5ca/doi1WXI3dyArpophah8cbUFLt8iWxmuImuTb1d2JB1/Zi5YeO6aUZuNLKybq/lz3XzQFyyYUos/hwm83HNX9+KlA7ujOtBiRZg5/wWRSaTae//xSPHTVDGRZTdhe3Y7LH34PP/v3wSHD7RKFQTcREREREaWU3HQz/nbXEpw3uRhOt4qnNp3EeT9Zj1+tO4wemxMbDjahpceOoiwLlk8qDnqcKaXZKMtNg83pxlv7GwAAmXEaoiZNLhVBd0OnDS/vqINBAX5y/WxYTPqHXiajAd+4aAoAYO3uenT0Be8FH668/dxZoUvL/RkMCm5dOhZv3rscq6eXwulW8cj6I7jkVxuxry7xWW8G3URERERElHImlmTjqc+ehb/euRizK3LRY3fhF+sO4byfrsfP/i2Gh101d3TwHmmIHnFZYr52t+h7zozTEDUpO82M0Xnp3v//3PLxmFOZF7fnm1uZhyml2eh3uPHyjtq4PU+yyEx3uMnlgZTlpuN3ty3EY7fMR0m2Fcebe/A//9qj9ymGxaCbiIiIiIhS1rKJRXj5S2fjkZvmYUxhBpq77d4hZdfNHzq1fLAVU0QmvK6jH0D8y8sBX4n5uKJMfG3V5Lg+l6IouPGsSgDAsx/VQFWTPzhMT6292nZ0h3LxzDL8+Y7FAIB9dZ0J/xkx6CYiIiIiopSmKAoun12Odfeeh4eumoGK/HRcOmsUppeHH0x29sQimI2K9//jXV4OALcvG4uFY/Lx8I3zNPUhx+qaeaNhMRmwv74Tu2s74v58idSmcV1YOOOLM2EyKOixu1DvuQCTKPF/xREREREREenAbDTg1qVjcatnurkWmVYTFo8rxHue9WOJyHQvn1yM5ZOD95oHZLXC+dJL2LJlCxZYrRE9NC/DgktmjsLLO+rw7Ec1mF2RF9lzp7DWGMrL/ZmNBowtysSRxm4cbuxGuV8LQLwx001ERERERCPa+VN8AXC8e7qjZjJBvfRSNCxcCJgivzBw46IqAMC/dtR616ONBDLojqW8XJpUkgUAONLYHfOxIsGgm4iIiIiIRjQ5TA1ITKY7GZaML8C4okz02F1Ys6s+2aejm7ZefcrLAWCiN+hO7E5zBt1ERERERDSiTSjORGWBKCfOStWg2+GA8vTTqHzrLcAR+eovRVHwyUWegWofV4e8r83pwjdf3I3v/mtvymfFW3Tq6Qb8g25muomIiIiIiHSjKAqumScmnU8ry07y2QRht8N0552Y/+tfA3Z7VIe4bn4FTAYF26vbcfB04Gyuqqp44J978OxH1XjygxO46jfv43BDYjO/kdBrkBrgC7oPN3YndII5g24iIiIiIhrxvrpyErY8sAoXTC1N9qnETXG2Faumie/v2Y8CZ7v/9P4JPL/1FAwKUJRlxZHGblz5yPv45/ZTiTxVzbw93TEOUgOACcVZUBSgvdfhzaAnAoNuIiIiIiIa8QwGBUVZkU0FH47kzu5/bq9Fv8M14GvvHmrC99fsAwB867LpeP2r5+KciUXoc7jwtb/vxDdf3D3kMcnkcLnR2S/K3wt1yHSnmY2ozM8AkNgScwbdREREREREI8S5k4oxOi8dHX0O/Hvvae/njzf34D/+ug1uFbh+QQU+e/ZYFGVZ8dRnz8JXVk6Coojs+HWPfoCTLT1J/A585BA1gwLkpJt1OaZ/iXmiMOgmIiIiIiIaIYwGBTcsFP3rssS8s9+BO5/6GJ39TsyvysMPrpkJRVG89//a6sl46jNnoSDTgr11nbj81+9h09GWpH0PUluPGCiXl2GB0aDocky5Nuwog24iIiIiIiKKxicWVsKgAJuPteJIYze+8ux2HG3qQVluGh67dQGspqG7ypdPLsaae87BgjH56Op34kev7U/CmQ/k6+fWJ8sNABO8me7EDY9j0E1ERERERDSClOel47zJxQCA2/7wIdYfbILVZMATty5ESXZa0MeV5abjkZvmAQD21HagO8nrxGR5eWGmfr34k5KwNoxBNxERERERUbJZrXD+9a/4+BvfAKyxB5mfXFQFAKjr6AcA/PSGOZhVkRv2cWW56Ridlw63Cuyobo/5PGIhJ4znZ+qf6W7otKGzP/J96NFg0E1ERERERJRsJhPU669H3dlnAyZTzIdbOa0EJdkieP/Sigm4ck655scuGpsPAPj4RGvM5xELPXd0SzlpZpTmiJ9LorLdDLqJiIiIiIhGGLPRgD/cvgg/uX42vr56SkSPXTSuAACw5WRyg249d3T7m1SSDYBBNxERERER0ZnD6YTyj3+g/P33Aac+vdSzKnLFULUIJ38vGiuC7m0n2+FwuXU5l2i0xiHTDfjWhjHoJiIiIiIiOlPYbDDddBMW/fSngM2W1FOZWJyF3HQz+hwu7KvrTNp5yEFqDLqJiIiIiIhoxDAYFCwck/y+bm95eZyC7kStDWPQTURERERERAMs9JSYbznRlrRzkIPUCnUOuuXasFNtfeizu3Q9diAMuomIiIiIiGiAs8aJTPeWk61QVTXhz6+qqm9lmM6D1AqzrMjPMENVgaNN8S8xZ9BNREREREREA8wcnQuLyYDmbjuON/ck/Pn7HC7YnGKIm9493YBvgjmDbiIiIiIiIko4q8mIuRV5AJJTYi77uS0mAzIsRt2PP0H2dTcw6CYiIiIiIqIkWDg2ecPU2nocAEQ/t6JEtvJMi0ROMDfF/RmIiIiIiIgoNIsFzt//Hrt27sQsi/7l1NEQ+7qPYsvJxGe6W3rE2jS9+7mlSQmcYM5MNxERERERUbKZzVBvuw01K1cCZnOyzwYAMH9MPhQFON7cg8au/oQ+d7x2dEsy032ypRcOlzsuzyEx6CYiIiIiIqIhctPNmFIqBo5tTXBfd6unvFzvHd1SWW4aMi1GON0qTrbEd1Acg24iIiIiIqJkczqhrF2L0i1bAKcz2Wfjtcizr/vjhAfdorxc7x3dkqIo3mx3vIepJT3o/u1vf4tx48YhLS0NCxYswMaNG4Ped8OGDVAUZch/Bw4cSOAZExERERER6cxmg+nqq7Hk+98HbLZkn42XHKa25WRih6ntq+sEAJTnpcXtOSZ61obFe5haUoPuv//97/jqV7+Kb33rW9i+fTvOPfdcXHLJJaiurg75uIMHD6K+vt7736RJkxJ0xkRERERERGcOmeneW9eJHltiMvC9difeP9oCADh/Skncnseb6R7JQffPf/5z3HHHHbjzzjsxbdo0/PKXv0RlZSUeffTRkI8rKSnBqFGjvP8ZjfrvbSMiIiIiIjrTleelY3ReOlxuFdur2xPynO8faYHd6UZFfrp3yng8TErQ2rCkrQyz2+3YunUr/uu//mvA5y+88EJ88MEHIR87b9489Pf3Y/r06XjggQewYsWKoPe12Wyw+ZVndHaKMgWHwwGHwxHDd0AjjXw98HVBgfD1QcHwtUHB8LVBwfC1QQE5HDB7bzqAFHp9LKjKQ217Hz481oTFY3Pj/nxv7q0HAKyYUgxnHPvbxxaI0vWjTd3ot9lhNES2D1zr3+GkBd3Nzc1wuVwoLS0d8PnS0lKcPn064GPKysrwxBNPYMGCBbDZbPjzn/+MlStXYsOGDVi+fHnAx/zoRz/Cgw8+OOTz69evR0ZGRuzfCI04b775ZrJPgVIYXx8UDF8bFAxfGxQMXxvkz9jfj8s9t99++2240uLXyxwpa5cCwIh/bzuCif2H4vpcbhV4fZcRgIKsjuNYu/ZYXJ/LpBhhc7rxl5deQ1GEP/Le3l5N90ta0C0pysCrCaqqDvmcNGXKFEyZMsX7/0uXLkVNTQ1+9rOfBQ26v/nNb+Lee+/1/n9nZycqKyuxYsUKFBYW6vAd0EjhcDjw5ptvYvXq1TCnyG5ESh18fVAwfG1QMHxtUDB8bVBAPb61VRdccAHMeXnJO5dBJjZ04flHNuFUnxmrL1oBszF+Xcq7azvQuflDZFqM+NInVsFqim9H9OPHP8CBhm5UzFiEC6YUR/RYWUUdTtKC7qKiIhiNxiFZ7cbGxiHZ71CWLFmCZ555JujXrVYrrFbrkM+bzWb+kqOA+NqgUPj6oGD42qBg+NqgYPjaoAH8Xgup9tqYVp6P3HQzOvocONzUhzmVeXF7rncOiynp504qRlb60DhObxNLs3GgoRsnWvoi/plrvX/SBqlZLBYsWLBgSFnNm2++iWXLlmk+zvbt21FWVqb36RERERERESWOxQLXr36FXXfdBVjis5s6WgaDgoVjxOqwj0/Ed3XYWwcaAAArp8Vvarm/SQlYG5bU8vJ7770Xt956KxYuXIilS5fiiSeeQHV1Ne6++24AojS8trYWTz/9NADgl7/8JcaOHYsZM2bAbrfjmWeewQsvvIAXXnghmd8GERERERFRbMxmuL/wBRxfuxbTUijLLS0cW4C3DjRiy4k23HlufJ7jdEc/9tR2QlGAFVMTE3QnYm1YUoPuT37yk2hpacH3vvc91NfXY+bMmVi7di3GjBkDAKivrx+ws9tut+O+++5DbW0t0tPTMWPGDKxZswaXXnppsr4FIiIiIiKiEW/RWJHp3nKyNeQcrli8faARADC3Mg9FWfEvLQeASaUi6D7a2B237yvpg9S++MUv4otf/GLArz355JMD/v/+++/H/fffn4CzIiIiIiIiSiCXC8o776Bw927goosG9HinglkVubCYDGjutuNESy/GFWXq/hxvy9LyBGW5AWBsYSaMBgVdNicaOm0Ylav/1Pik9XQTERERERGRR38/TKtX45xvfxvo70/22QxhNRkxp0Ls6P733sArnmPR73DhvSPNAIALpmofrB0ri8mAMYVilXS8+roZdBMREREREVFYF04fBQD439cP4JnNJ3U99gdHm9HvcKM8Nw3TyrJ1PXY4E4tFifmhhq64HJ9BNxEREREREYV1xznjcOuSMVBV4IGX9uC3G47odux1+0U/9wXTSuLSVx2KXIH2580n0e9w6X58Bt1EREREREQUlsGg4HtXzcCXVkwAAPzk9YP48WsHoKpqTMdVVRVve4LuldMSV1ou3bZ0DEqyrTje3IPH3zmm+/EZdBMREREREZEmiqLgGxdNxTcvmQoAeOydo3jgpT1wuwMH3l39Dqw/0Ig9tR1Bj7m3rhOnO/uRbjZi6fjCuJz3/7d352FV1vn/x1+Hw44CiguYK4kL7oI2LqWOuKGWo4WViabWV3NJzaXRLLVcZ2wcNW1sSqup0cxlmiQTt9xzCzNlFBXFSmNwAQFZz/37w+H8OrKIxvEoPB/XdV/XOff9uT/3+z684eJ97s/9uYtS3t1F03oFS5Le2XFa55LSSrR/h89eDgAAAAB4sPxfh4fl7eGiKeuP6ZNvE3Q9I0cLIprJYhj6LuGa9p5O0u7TSTr6Y7JyLYbMTib96cmm6tuyer6+8h4V1j6oktxdzPf6VCRJvZoG6LNDF7QrLknT/vWDPhrSusSGuVN0AwAAAADu2DOta6qcm7PGrY7RF0d/1rGfknUpOUM3brkv2s/LVZfTsjT+s6O6nJqlFx4LtNm+NfbePyrsViaTSTOfaKxuC3dqV1ySNh67qF5Nq5VI3wwvBwAAAABHc3FR7pw5Oj5o0H33jO6i9G5WTe9FhsrN2UnxSWm6kZ2rSuVc9Xizaprfr6l2T+6kg1PDNLR9HUnSrKhYzYmKtd4Hnng9Q0d/vDn0/PcOLLolqU4lL73U8eb96jP/fULXM7JLpF+udAMAAACAo7m6yvLKKzodFaV6rq6OjuaOdGpQRWtHtNV3F66pVe0Kql+1fL6h2a/1bKjK5d0096v/6G87zyopNUtz+zXR9v8NLW9a3UdVvN0dEb6N4R0e1obvftK5y+lasPmUpj/e6Df3SdENAAAAAPhNGj/ko8YP+RS63WQyaXiHh+Xn5apX1x3T2iM/6kpapnL/N/9a5wb3ftbygri7mPVmn8Ya+P4BfbTvnJ4MqV7keRUHw8sBAAAAwNFyc2U6dEi+cXFSbsk/K/p+8VRoDS0fGCJ3FydtP/lf7Tz1X0lS54aOHVr+a48GVVbvZtVkMaSp648pt5CZ2YuLohsAAAAAHC0jQ85t26rDxIlSRoajo7Grzg2r6pNhj8jH4+a961W93dSomreDo7I1rWdDlXdz1tEfk/XpgYTf1BdFNwAAAADgngqpVVFrhrdR+7qVNLFbgxJ7PFdJqeLtrgnd6kuS5m/6jxKv3/0XIRTdAAAAAIB7rl7V8vrHsEf0ZEj+Z3ffD577XS01echH1zNyFPX9xbvuh4nUAAAAAAC4hdnJpDl9m+i/qZnqVP/u7zmn6AYAAAAAoAC/deZyieHlAAAAAADYDUU3AAAAAAB2wvByAAAAAHA0Fxflvvaa4uLi9LCLi6OjQQniSjcAAAAAOJqrqyyvv66Tzzwjubo6OhqUIIpuAAAAAADshKIbAAAAABzNYpGOH1f5hISbr1FqcE83AAAAADjajRtyadFCv5eUPXCg5Obm6IhQQrjSDQAAAACAnVB0AwAAAABgJxTdAAAAAADYCUU3AAAAAAB2QtENAAAAAICdUHQDAAAAAGAnPDIMAAAAABzNxUW548fr7Nmzqu3i4uhoUIIougEAAADA0VxdZZk7VyeiolTb1dXR0aAEMbwcAAAAAAA7oegGAAAAAEezWKRz5+Txyy83X6PUYHg5AAAAADjajRtyqVdPXSVlR0RIbm6OjgglhCvdAAAAAADYCUU3AAAAAAB2QtENAAAAAICdUHQDAAAAAGAnFN0AAAAAANgJRTcAAAAAAHbCI8MAAAAAwNGcnZU7fLgSzp9XdWfKtNKEnyYAAAAAOJqbmyyLFun7qChV5xndpQrDywEAAAAAsBOKbgAAAABwNMOQ/vtfuSYn33yNUoPh5QAAAADgaOnpcnnoIfWQlP3445Krq6MjQgnhSjcAAAAAAHZC0Q0AAAAAgJ1QdAMAAAAAYCcU3QAAAAAA2AlFNwAAAAAAdkLRDQAAAACAnfDIMAAAAABwNGdnWQYO1I8//qgAZ8q00oSfJgAAAAA4mpubct9/X99FRSnAzc3R0aAEMbwcAAAAAAA7oegGAAAAAEczDCktTeaMjJuvUWowvBwAAAAAHC09XS4VKqiXpOyrVyVXV0dHhBLClW4AAAAAAOyEohsAAAAAADuh6AYAAAAAwE4ougEAAAAAsBOKbgAAAAAA7ISiGwAAAAAAO+GRYQAAAADgaGazLH376uKlS6piNjs6GpQgim4AAAAAcDR3d+WuWqVDUVEKd3d3dDQoQQwvBwAAAADATii6AQAAAACwE4aXAwAAAICjpaXJpVw5PSEp++pVydfX0RGhhHClGwAAAAAAO6HoBgAAAADATii6AQAAAACwE4puAAAAAADshKIbAAAAAAA7oegGAAAAAMBOeGQYAAAAADia2SxLjx5KTEyUn9ns6GhQgii6AQAAAMDR3N2V+69/6duoKIW7uzs6GpQghpcDAAAAAGAnXOkuRG5urrKzsx0dBu6h7OxsOTs7KyMjQ7m5uY4OB4VwcXGRmSFXAAAAeEBQdN/CMAxdunRJ165dc3QouMcMw5C/v78uXLggk8nk6HBQBF9fX/n7+/NzAgAApUdampyrVFHP3FwZly5Jvr6OjgglhKL7FnkFd5UqVeTp6ck/9WWIxWJRamqqypUrJycn7ry4HxmGofT0dCUmJkqSAgICHBwRAABAyTGlp8tZEuNtSxeK7l/Jzc21Ftx+fn6ODgf3mMViUVZWltzd3Sm672MeHh6SpMTERFWpUoWh5gAAALivUVn8St493J6eng6OBEBR8n5HmXcBAAAA9zuK7gIwpBy4v/E7CgAAgAcFRTcAAAAAAHZC0Y1CdezYUWPHji12+3PnzslkMikmJsZuMQEAAADAg4SiuxQwmUxFLoMHD76rftetW6c333yz2O1r1KihixcvqnHjxnd1vOKiuAcAAECp4+Qky2OPKalRI4lJfUsVZi8vBS5evGh9vXr1ar3++us6efKkdV3ebM95srOz5eLictt+K1aseEdxmM1m+fv739E+AAAAACR5eCh3yxbtiYpS+C3/v+PBxlcot2EYhtKzchyyGIZRrBj9/f2ti4+Pj0wmk/V9RkaGfH199dlnn6ljx45yd3fXP/7xD12+fFnPPPOMqlevLk9PTzVp0kT//Oc/bfq9dXh57dq1NXv2bA0ZMkTly5dXzZo1tXz5cuv2W69A79ixQyaTSVu3blVoaKg8PT3Vtm1bmy8EJOmtt95SlSpVVL58eQ0bNkyvvvqqmjdvflc/L0nKzMzUmDFjVKVKFbm7u6t9+/Y6ePCgdfvVq1c1YMAAVa5cWR4eHgoKCtKKFSskSVlZWRo9erQCAgLk7u6u2rVra86cOXcdCwAAAICyjSvdt3EjO1fBr3/tkGOfmNlNnq4l8yOaPHmyFixYoBUrVsjNzU0ZGRkKCQnR5MmT5e3trY0bN2rgwIEKDAzUI488Umg/CxYs0JtvvqkpU6bo888/14gRI/TYY4+pQYMGhe4zdepULViwQJUrV9bw4cM1ZMgQ7dmzR5L0ySefaNasWVq6dKnatWunVatWacGCBapTp85dn+ukSZO0du1affjhh6pVq5bmz5+vbt266fTp06pYsaKmTZumEydO6KuvvlKlSpV0+vRp3bhxQ5L0t7/9Tf/+97/12WefqWbNmrpw4YIuXLhw17EAAAAAKNsousuIsWPHqm/fvjbrJkyYYH09evRobdq0SWvWrCmy6A4PD9dLL70k6WYh/5e//EU7duwosuieNWuWOnToIEl69dVX1bNnT2VkZMjd3V2LFy/W0KFD9fzzz0uSXn/9dW3evFmpqal3dZ5paWlatmyZVq5cqR49ekiS3nvvPUVHR+v999/XxIkTlZCQoBYtWig0NFTSzSv4kmSxWPTjjz8qKChI7du3l8lkUq1ate4qDgAAAOCOpKXJuXZtdc/Kks6fl3x9HR0RSghF9214uJh1YmY3hx27pOQVmHlyc3M1d+5crV69Wj/99JMyMzOVmZkpLy+vIvtp2rSp9XXeMPbExMRi7xMQECBJSkxMVM2aNXXy5ElrEZ+ndevW2rZtW7HO61ZnzpxRdna22rVrZ13n4uKi1q1bKzY2VpI0YsQI9evXT0eOHFHXrl3Vp08ftW3bVpL07LPPqm/fvqpfv766d++uXr16qWvXrncVCwAAAHAnTElJcpOU7ehAUKIoum/DZDKV2BBvR7q1mF6wYIH+8pe/aOHChWrSpIm8vLw0duxYZWVlFdnPrROwmUwmWSyWYu9jMpkkyWafvHV5insve0Hy9i2oz7x1PXr00Pnz57Vx40Zt2bJFnTt31siRIzV//nw1a9ZMZ86c0ddff60tW7YoIiJCYWFh+vzzz+86JgAAAABlFxOplVG7du3SE088oeeee07NmjVTYGCg4uLi7nkc9evX14EDB2zWHTp06K77q1u3rlxdXbV7927ruuzsbB06dEgNGza0rqtcubIGDx6sf/zjH1q4cKHNhHDe3t7q37+/3nvvPa1evVpr167VlStX7jomAAAAAGXXg38JF3elbt26Wrt2rfbu3asKFSro7bff1qVLl2wK03th9OjReuGFFxQaGqq2bdtq9erV+v777xUYGHjbfW+dBV2SgoODNWLECE2cOFEVK1ZUzZo1NX/+fKWnp2vo0KGSbt43HhISokaNGikzM1Nffvml9byXLl2q2rVrq2XLlnJyctKaNWvk7+8vX+6pAQAAAHAXKLrLqGnTpik+Pl7dunWTp6enXnzxRfXp00fJycn3NI4BAwbo7NmzmjBhgjIyMhQREaHBgwfnu/pdkKeffjrfuvj4eM2dO1cWi0UDBw7U9evXFRoaqq+//loVKlSQJLm6uuqPf/yjzp07Jw8PDz366KNatWqVpJvD8P/0pz8pLi5OZrNZrVq1UlRUlJycGBQCAAAA4M6ZjN9yA+0DKCUlRT4+PkpKSpKfn5/NtoyMDMXHx6tOnTpyd3d3UITo0qWL/P399fHHH9/T41osFqWkpMjb25si+z7niN/V7OxsRUVFKTw8PN/cBijbyA0UhtxAYcgNFCgtTSpXTpKUffWqXBhped/Lqy2Tk5Pl7e1daDuudMOh0tPT9e6776pbt24ym8365z//qS1btig6OtrRoQEAAAD3jpOTLCEhSk5OVjkuAJUqFN1wKJPJpKioKL311lvKzMxU/fr1tXbtWoWFhTk6NAAAAODe8fBQ7r592hkVpXAPD0dHgxJE0Q2H8vDw0JYtWxwdBgAAAADYBeMWAAAAAACwE650AwAAAICjpafLOThYXdLTpbg4ycfH0RGhhFB0AwAAAICjGYZM58/LU1J22XrAVKnH8HIAAAAAAOyEohsAAAAAADuh6AYAAAAAwE4oumHVsWNHjR071vq+du3aWrhwYZH7mEwmbdiw4Tcfu6T6AQAAAID7CUV3KdC7d2+FhYUVuG3fvn0ymUw6cuTIHfd78OBBvfjii781PBvTp09X8+bN862/ePGievToUaLHutXKlSvl6+tr12MAAAAAwK9RdJcCQ4cO1bZt23T+/Pl82z744AM1b95cLVu2vON+K1euLE9Pz5II8bb8/f3l5uZ2T44FAAAA3HdMJhkNGyqlRg3JZHJ0NChBFN23YxhSVppjlmI+KqBXr16qUqWKVq5cabM+PT1dq1ev1tChQ3X58mU988wzql69ujw9PdWkSRP985//LLLfW4eXx8XF6bHHHpO7u7uCg4MVHR2db5/JkyerXr168vT0VGBgoKZNm6bs7GxJN680z5gxQ0ePHpXJZJLJZLLGfOvw8mPHjun3v/+9PDw85OfnpxdffFGpqanW7YMHD1afPn305z//WQEBAfLz89PIkSOtx7obCQkJevbZZ+Xt7S1vb29FRETol19+sW4/evSoOnXqpPLly8vb21shISE6dOiQJOn8+fPq3bu3KlSoIC8vLzVq1EhRUVF3HQsAAADKGE9P5Rw9qu2LF0v36MIX7g2e03072enS7GqOOfaUnyVXr9s2c3Z2VmRkpFauXKnXX39dpv99M7ZmzRplZWVpwIABSk9PV0hIiCZPnixvb29t3LhRAwcOVGBgoB555JHbHsNisahv376qVKmS9u/fr5SUFJv7v/OUL19eK1euVLVq1XTs2DG98MILKl++vCZNmqT+/fvrhx9+0KZNm7RlyxZJko+PT74+0tPT1b17d/3ud7/TwYMHlZiYqGHDhmnUqFE2Xyxs375dAQEB2r59u06fPq3+/furefPmeuGFF257PrcyDEN9+/aVm5ubtm/fLovFopdeekn9+/fXjh07JEkDBgxQixYttGzZMpnNZsXExMjFxUWSNHLkSGVlZWnnzp3y8vLSiRMnVK5cuTuOAwAAAEDpQtFdSgwZMkR/+tOftGPHDnXq1EnSzaHlffv2VYUKFVShQgVNmDDB2n706NHatGmT1qxZU6yie8uWLYqNjdW5c+dUvXp1SdLs2bPz3Yf92muvWV/Xrl1br7zyilavXq1JkybJw8ND5cqVk7Ozs/z9/Qs91ieffKIbN27oo48+kpfXzS8dlixZot69e2vevHmqWrWqJKlChQpasmSJzGazGjRooJ49e2rr1q13VXRv2bJF33//vWJiYhQcHCwnJyd9/PHHatSokQ4ePKhWrVopISFBEydOVIMGDSRJQUFB1v0TEhLUr18/NWnSRJIUGBh4xzEAAAAAKH0oum/HxfPmFWdHHbuYGjRooLZt2+qDDz5Qp06ddObMGe3atUubN2+WJOXm5mru3LlavXq1fvrpJ2VmZiozM9Na1N5ObGysatasaS24JalNmzb52n3++edauHChTp8+rdTUVOXk5Mjb27vY55F3rGbNmtnE1q5dO1ksFp08edJadDdq1Ehms9naJiAgQMeOHbujY/36mDVq1LA5v+DgYPn6+io2NlatWrXS+PHjNWzYMH388ccKCwvTU089pYcffliSNGbMGI0YMUKbN29WWFiY+vXrp6ZNm95VLAAAACiD0tPlHBqqTqmpUseOUgEjQvFg4p7u2zGZbg7xdsRyhxMoDB06VGvXrlVKSopWrFihWrVqqXPnzpKkBQsW6C9/+YsmTZqkbdu2KSYmRt26dVNWVlax+jYKuL/cdEt8+/fv19NPP60ePXroyy+/1HfffaepU6cW+xi/PtatfRd0zLyh3b/eZrFY7uhYtzvmr9dPnz5dx48fV8+ePbVt2zYFBwdr/fr1kqRhw4bp7NmzGjhwoI4dO6bQ0FAtXrz4rmIBAABAGWQYMsXGyvvChWLP7YQHA0V3KRIRESGz2axPP/1UH374oZ5//nlrwbhr1y498cQTeu6559SsWTMFBgYqLi6u2H0HBwcrISFBP//8/6/679u3z6bNnj17VKtWLU2dOlWhoaEKCgrKN6O6q6urcnNzb3usmJgYpaWl2fTt5OSkevXqFTvmO5F3fj/++KN13YkTJ5ScnKyGDRta19WrV0/jxo3T5s2b1bdvX61YscK6rUaNGho+fLjWrVunV155Re+9955dYgUAAADw4KDoLkXKlSun/v37a8qUKfr55581ePBg67a6desqOjpae/fuVWxsrP7v//5Ply5dKnbfYWFhql+/viIjI3X06FHt2rVLU6dOtWlTt25dJSQkaNWqVTpz5owWLVpkvRKcp3bt2oqPj1dMTIySkpKUmZmZ71gDBgyQu7u7Bg0apB9++EHbt2/X6NGjNXDgQOvQ8ruVm5urmJgYm+XEiRMKCwtT06ZN9eKLL+rIkSM6cOCAIiMj1aFDB4WGhurGjRsaNWqUduzYofPnz2vPnj06ePCgtSAfO3asvv76a8XHx+vIkSPatm2bTbEOAAAAoGyi6C5lhg4dqqtXryosLEw1a9a0rp82bZpatmypbt26qWPHjvL391efPn2K3a+Tk5PWr1+vzMxMtW7dWsOGDdOsWbNs2jzxxBMaN26cRo0apebNm2vv3r2aNm2aTZt+/fqpe/fu6tSpkypXrlzgY8s8PT319ddf68qVK2rVqpWefPJJde7cWUuWLLmzD6MAqampatGihc0SHh4uk8mkdevWydfXVx07dlRYWJgCAwO1evVqSZLZbNbly5cVGRmpevXqKSIiQj169NCMGTMk3SzmR44cqYYNG6p79+6qX7++li5d+pvjBQAAAPBgMxkF3axbiqWkpMjHx0dJSUny8/Oz2ZaRkaH4+HjVqVNH7u7uDooQjmKxWJSSkiJvb285OfF91P3MEb+r2dnZioqKUnh4eL75BFC2kRsoDLmBwpAbKFBamvS/R85mX70qF19fx8aD28qrLZOTk4ucPJrKAgAAAAAAO+GRYQAAAADgaCaTjFq1dCM9XS53+BQj3N+40g0AAAAAjubpqZy4OEW/957k6enoaFCCKLoBAAAAALATim4AAAAAAOyEe7oBAAAAwNFu3JD50Uf1WHKy1KmTxMz2pQZFNwAAAAA4msUip8OHVUFStsXi6GhQghheDgAAAACAnVB0AwAAAABgJxTduK3BgwerT58+jg7DrgYPHqw//OEPjg7DymQyacOGDXbr/9y5czKZTIqJibHbMaSykTsAAABAUSi6S4nBgwfLZDLlW7p37+7o0CRJ27dvV6dOnVSxYkV5enoqKChIgwYNUk5OjiRp5cqV8vX1dVh8f/3rX7VixYp7cqxLly5p9OjRCgwMlJubm2rUqKHevXtr69at9+T499Jf//pXrVy58o72sfcXDgAAAMC9xERqpUj37t3zFY5ubm533V9ubq5MJtNvDUvHjx9Xjx49NGbMGC1evFgeHh6Ki4vT559/Lst9MkmEj4+PLBaLUlJS7Hqcc+fOqV27dvL19dX8+fPVtGlTZWdn6+uvv9bIkSP1n//8x67Hv9d8fHwcHQIAAADgUFzpLq60tMKXjIzit71xo3ht74Kbm5v8/f1tlgoVKli3v/3222rSpIm8vLxUo0YNvfTSS0pNTbVuz7va/OWXXyo4OFhubm46f/68zTE++ugj+fn5KTMz02Z9v379FBkZWWBc0dHRCggI0Pz589W4cWM9/PDD6t69u/7+97/L1dVVO3bs0PPPP6/k5GTrFfrp06dLkq5evarIyEhVqFBBnp6e6tGjh+Li4vLFvGHDBtWrV0/u7u7q0qWLLly4YG0zffp0NW/eXH/7299Uo0YNeXp66qmnntK1a9esbW4dXt6xY0eNGTNGkyZNUsWKFeXv72+NKc9//vMftW/fXu7u7goODtaWLVtue5X2pZdekslk0oEDB/Tkk0+qXr16atSokcaPH6/9+/fbtE1KStIf/vAH68iAL774wmb7iRMnFB4ernLlyqlq1aoaOHCgkpKSrNstFovmzZununXrys3NTTVr1tSsWbMKjMtiseiFF15QvXr1rD9zk8mkZcuWqUePHvLw8FCdOnW0Zs0am/2OHTum3//+9/Lw8JCfn59efPFFm5y6dXj57T7X2rVrS5L+8Ic/yGQyWd8DAACUBUalSsr09nZ0GChhFN3FVa5c4Uu/frZtq1QpvG2PHrZta9cuuJ0dODk5adGiRfrhhx/04Ycfatu2bZo0aZJNm/T0dM2ZM0d///vfdfz4cVWpUsVm+1NPPaXc3FybAjApKUlffvmlnn/++QKP6+/vr4sXL2rnzp0Fbm/btq0WLlwob29vXbx4URcvXtSECRMk3SzaDh06pC+++EL79u2TYRgKDw9Xdna2TcyzZs3Shx9+qD179iglJUVPP/20zTFOnz6tzz77TP/+97+1adMmxcTEaOTIkUV+Xh9++KG8vLz07bffav78+Zo5c6aio6Ml3SxS+/TpI09PT3377bdavny5pk6dWmR/V65c0aZNmzRy5Eh5eXnl237r8PoZM2YoIiJC33//vcLDwzVgwABduXJFknTx4kV16NBBzZs316FDh7Rp0yb98ssvioiIsO7/xz/+UfPmzdO0adN04sQJffrpp6patWq+42ZlZSkiIkKHDh3S7t27VatWLeu2adOmqV+/fjp69Kiee+45PfPMM4qNjZV083Pv3r27KlSooIMHD2rNmjXasmWLRo0addef68GDByVJK1as0MWLF63vAQAASj0vL+X8/LM2ffSRVMD/iniAGWVMcnKyIclISkrKt+3GjRvGiRMnjBs3buTfUSp8CQ+3bevpWXjbDh1s21aqVHC7OzRo0CDDbDYbXl5eNsvMmTML3eezzz4z/Pz8rO9XrFhhSDJiYmLy9f3EE09Y348YMcLo0aOH9f3ChQuNwMBAw2KxFHicnJwcY/DgwYYkw9/f3+jTp4+xePFiIzk52ebYPj4+NvudOnXKkGTs2bPHui4pKcnw8PAwPvvsM5uY9+/fb20TGxtrSDK+/fZbwzAM44033jDMZrNx4cIFa5uvvvrKcHJyMi5evGg9x8cff9y4evWqkZuba3To0MFo3769TTytWrUyJk+ebN3f2dnZur9hGEZ0dLQhyVi/fn2Bn8O3335rSDLWrVtX4PZfk2S89tpr1vepqamGyWQyvvrqK8MwDGPatGlG165dbfa5cOGCIck4efKkkZKSYri5uRnvvfdegf3Hx8cbkoxdu3YZYWFhRrt27Yxr167li2H48OE26x555BFjxIgRhmEYxvLly40KFSoYqamp1u0bN240nJycjEuXLhmGkT93bve55h23sM8wT5G/q3aSlZVlbNiwwcjKyrpnx8SDgdxAYcgNFIbcQGHIjQdLXm3567qmINzTXVy/GjKbj9ls+z4xsfC2TrcMLjh37q5DulWnTp20bNkym3UVK1a0vt6+fbtmz56tEydOKCUlRTk5OcrIyFBaWpr1yqurq6uaNm1a5HFeeOEFtWrVSj/99JMeeughrVixwjqRW0HMZrNWrFiht956S9u2bdP+/fs1a9YszZs3TwcOHFBAQECB+8XGxsrZ2VmPPPKIdZ2fn5/q169vvdoqSc7OzgoNDbW+b9CggXx9fRUbG6vWrVtLkmrWrKnq1atb27Rp00YWi0UnT56Uv79/gce/9XMICAhQ4v9+tidPnlSNGjVs9s07VmEMw5CkYt8n/+vje3l5qXz58tbjHz58WNu3b1e5AkZFnDlzRteuXVNmZqY6d+5c5DGeeeYZVa9eXVu3bpWnp2e+7W3atMn3Pm/G89jYWDVr1szmqn27du2sn2tBV9VvPS/J9nMFAAAAShuGlxeXl1fhi7t78dt6eBSv7V2F6KW6devaLHlF9/nz5xUeHq7GjRtr7dq1Onz4sN555x1Jshmq7eHhcduisEWLFmrWrJk++ugjHTlyRMeOHdPgwYNvG99DDz2kgQMH6p133tGJEyeUkZGhd999t9D2eUVqQetvjbGgmIs6j7xtRbVxcXHJt0/exG8FxXA7QUFBMplMNl8YFKWo41ssFvXu3VsxMTE2S1xcnB577DF53JpnhQgPD9f333+f737youSdd1Gfwd1+rgAAAGXWjRsyh4Wp3dSp+eeBwgONoruMOHTokHJycrRgwQL97ne/U7169fTzzz/fdX/Dhg3TihUr9MEHHygsLEw1atS4o/0rVKiggIAApf1v0jhXV1fl5ubatAkODlZOTo6+/fZb67rLly/r1KlTatiwoXVdTk6ODh06ZH1/8uRJXbt2TQ0aNLCuS0hIsDnfffv2ycnJSfXq1bujuPM0aNBACQkJ+uWXX6zrbnf/ccWKFdWtWze988471vP+tV9P7HY7LVu21PHjx1W7du18X7R4eXkpKChIHh4et30M2YgRIzR37lw9/vjj+uabb/Jtv7UY379/v/VzDQ4OVkxMjM257Nmz5zd9rtLNovzWXAAAACj1LBY57dypSsePS1yQKFUoukuRzMxMXbp0yWbJm8364YcfVk5OjhYvXqyzZ8/q448/LvIq8+0MGDBAP/30k9577z0NGTKkyLZ/+9vfNGLECG3evFlnzpzR8ePHNXnyZB0/fly9e/eWdHPW6tTUVG3dulVJSUlKT09XUFCQnnjiCb3wwgvavXu3dTKvhx56SE888YS1fxcXF40ePVrffvutjhw5oueff16/+93vbIZ7u7u7a9CgQTp69Kh27dqlMWPGKCIiotCh5bfTpUsXPfzwwxo0aJC+//577dmzxzqRWlFXeZcuXarc3Fy1bt1aa9euVVxcnGJjY7Vo0aJ8Q7mLMnLkSF25ckXPPPOMDhw4oLNnz2rz5s0aMmSIcnNz5e7ursmTJ2vSpEn66KOPdObMGe3fv1/vv/9+vr5Gjx6tt956S7169dLu3btttq1Zs0YffPCBTp06pTfeeEMHDhywTpQ2YMAA6+f6ww8/aPv27Ro9erQGDhxY6NDy4qhdu7a2bt2qS5cu6erVq3fdDwAAAHA/oOguRTZt2qSAgACbpX379pKk5s2b6+2339a8efPUuHFjffLJJ5ozZ85dH8vb21v9+vVTuXLlbB4JVZDWrVsrNTVVw4cPV6NGjdShQwft379fGzZsUIcOHSTdnMF8+PDh6t+/vypXrqz58+dLujmLdUhIiHr16qU2bdrIMAxFRUXZDFH29PTU5MmT9eyzz6pNmzby8PDQqlWrbGKoW7eu+vbtq/DwcHXt2lWNGzfW0qVL7/r8zWazNmzYoNTUVLVq1UrDhg3Ta6+9JulmgV+YOnXq6MiRI+rUqZNeeeUVNW7cWF26dNHWrVvz3Y9flGrVqmnPnj3Kzc1Vt27d1LhxY7388svy8fGR0//mDZg2bZpeeeUVvf7662rYsKH69+9f6L3TY8eO1YwZMxQeHq69e/da18+YMUOrVq1S06ZN9eGHH+qTTz5RcHCwpJuf+9dff60rV66oVatWevLJJ9W5c2ctWbKk2OdRkAULFig6Olo1atRQixYtflNfAAAAgKOZjMJunC2lUlJS5OPjo6SkJPn5+dlsy8jIUHx8vOrUqVNk4YSbunTpooYNG2rRokUOi2HlypUaO3ZskUOzp0+frg0bNlgnACuMxWJRSkqKvL29rYXrndizZ4/at2+v06dP6+GHH77j/e83JpNJ69evv+2XKo7giN/V7OxsRUVFKTw8PN996SjbyA0UhtxAYcgNFCgtzfro4OyrV+Vyy+Nkcf/Jqy2Tk5PlXcTz1Zm9HHfsypUr2rx5s7Zt2/abr2o+yNavX69y5copKChIp0+f1ssvv6x27dqVioIbAAAAQMmg6MYda9mypa5evap58+apfv36jg7HYa5fv65JkybpwoULqlSpksLCwrRgwQJHhwUAAADgPkLRjTt2rgSfLf5bDR48+LaPK5s+fbqmT59e4seOjIxUZGRkifd7vyhjd54AAAA4nOHpyVNcSiEmUgMAAAAAR/PyUs61a9q4erXk5eXoaFCCKLoLwBU+4P7G7ygAAAAeFBTdv5I3e2R6erqDIwFQlLzfUWZ8BQAAwP2Oe7p/xWw2y9fX1/osY09PT5lMJgdHhXvFYrEoKytLGRkZd/XIMNifYRhKT09XYmKifH19ZTabHR0SAABAycjIkLlvXz2SmCj9/vcSFxdKDYruW/j7+0uStfBG2WEYhm7cuCEPDw++bLnP+fr6Wn9XAQAASoXcXDl99ZX8JWUzmVqpQtF9C5PJpICAAFWpUkXZ2dmODgf3UHZ2tnbu3KnHHnuMYcv3MRcXF65wAwAA4IFB0V0Is9nMP/ZljNlsVk5Ojtzd3Sm6AQAAAJQIh9+4unTpUtWpU0fu7u4KCQnRrl27imz/zTffKCQkRO7u7goMDNS77757jyIFAAAAAODOOLToXr16tcaOHaupU6fqu+++06OPPqoePXooISGhwPbx8fEKDw/Xo48+qu+++05TpkzRmDFjtHbt2nscOQAAAAAAt+fQovvtt9/W0KFDNWzYMDVs2FALFy5UjRo1tGzZsgLbv/vuu6pZs6YWLlyohg0batiwYRoyZIj+/Oc/3+PIAQAAAAC4PYfd052VlaXDhw/r1VdftVnftWtX7d27t8B99u3bp65du9qs69atm95//31lZ2cXeB9uZmamMjMzre+Tk5MlSVeuXPmtp4BSJjs7W+np6bp8+TL3dCMf8gOFITdQGHIDhSE3UKC0NOVlQ/qVK3JhBvP73vXr1yXdfApSURxWdCclJSk3N1dVq1a1WV+1alVdunSpwH0uXbpUYPucnBwlJSUpICAg3z5z5szRjBkz8q2vV6/eb4geAAAAAOzk4YcdHQHuwPXr1+Xj41PodofPXn7r85ANwyjyGckFtS9ofZ4//vGPGj9+vPX9tWvXVKtWLSUkJBT5waDsSUlJUY0aNXThwgV5e3s7OhzcZ8gPFIbcQGHIDRSG3EBhyI0Hi2EYun79uqpVq1ZkO4cV3ZUqVZLZbM53VTsxMTHf1ew8/v7+BbZ3dnaWn59fgfu4ubnJzc0t33ofHx8SGQXy9vYmN1Ao8gOFITdQGHIDhSE3UBhy48FRnAu5DptIzdXVVSEhIYqOjrZZHx0drbZt2xa4T5s2bfK137x5s0JDQ7kfBgAAAABw33Ho7OXjx4/X3//+d33wwQeKjY3VuHHjlJCQoOHDh0u6OTQ8MjLS2n748OE6f/68xo8fr9jYWH3wwQd6//33NWHCBEedAgAAAAAAhXLoPd39+/fX5cuXNXPmTF28eFGNGzdWVFSUatWqJUm6ePGizTO769Spo6ioKI0bN07vvPOOqlWrpkWLFqlfv37FPqabm5veeOONAoeco2wjN1AU8gOFITdQGHIDhSE3UBhyo3QyGbeb3xwAAAAAANwVhw4vBwAAAACgNKPoBgAAAADATii6AQAAAACwE4puAAAAAADspMwV3UuXLlWdOnXk7u6ukJAQ7dq1y9Eh4R6bM2eOWrVqpfLly6tKlSrq06ePTp48adPGMAxNnz5d1apVk4eHhzp27Kjjx487KGI4wpw5c2QymTR27FjrOvKibPvpp5/03HPPyc/PT56enmrevLkOHz5s3U5+lE05OTl67bXXVKdOHXl4eCgwMFAzZ86UxWKxtiE3yoadO3eqd+/eqlatmkwmkzZs2GCzvTh5kJmZqdGjR6tSpUry8vLS448/rh9//PEengXsoajcyM7O1uTJk9WkSRN5eXmpWrVqioyM1M8//2zTB7nxYCtTRffq1as1duxYTZ06Vd99950effRR9ejRw+axZCj9vvnmG40cOVL79+9XdHS0cnJy1LVrV6WlpVnbzJ8/X2+//baWLFmigwcPyt/fX126dNH169cdGDnulYMHD2r58uVq2rSpzXryouy6evWq2rVrJxcXF3311Vc6ceKEFixYIF9fX2sb8qNsmjdvnt59910tWbJEsbGxmj9/vv70pz9p8eLF1jbkRtmQlpamZs2aacmSJQVuL04ejB07VuvXr9eqVau0e/dupaamqlevXsrNzb1XpwE7KCo30tPTdeTIEU2bNk1HjhzRunXrdOrUKT3++OM27ciNB5xRhrRu3doYPny4zboGDRoYr776qoMiwv0gMTHRkGR88803hmEYhsViMfz9/Y25c+da22RkZBg+Pj7Gu+++66gwcY9cv37dCAoKMqKjo40OHToYL7/8smEY5EVZN3nyZKN9+/aFbic/yq6ePXsaQ4YMsVnXt29f47nnnjMMg9woqyQZ69evt74vTh5cu3bNcHFxMVatWmVt89NPPxlOTk7Gpk2b7lnssK9bc6MgBw4cMCQZ58+fNwyD3CgNysyV7qysLB0+fFhdu3a1Wd+1a1ft3bvXQVHhfpCcnCxJqlixoiQpPj5ely5dsskVNzc3dejQgVwpA0aOHKmePXsqLCzMZj15UbZ98cUXCg0N1VNPPaUqVaqoRYsWeu+996zbyY+yq3379tq6datOnTolSTp69Kh2796t8PBwSeQGbipOHhw+fFjZ2dk2bapVq6bGjRuTK2VMcnKyTCaTdTQVufHgc3Z0APdKUlKScnNzVbVqVZv1VatW1aVLlxwUFRzNMAyNHz9e7du3V+PGjSXJmg8F5cr58+fveYy4d1atWqUjR47o4MGD+baRF2Xb2bNntWzZMo0fP15TpkzRgQMHNGbMGLm5uSkyMpL8KMMmT56s5ORkNWjQQGazWbm5uZo1a5aeeeYZSfztwE3FyYNLly7J1dVVFSpUyNeG/1XLjoyMDL366qt69tln5e3tLYncKA3KTNGdx2Qy2bw3DCPfOpQdo0aN0vfff6/du3fn20aulC0XLlzQyy+/rM2bN8vd3b3QduRF2WSxWBQaGqrZs2dLklq0aKHjx49r2bJlioyMtLYjP8qe1atX6x//+Ic+/fRTNWrUSDExMRo7dqyqVaumQYMGWduRG5DuLg/IlbIjOztbTz/9tCwWi5YuXXrb9uTGg6PMDC+vVKmSzGZzvm+DEhMT833riLJh9OjR+uKLL7R9+3ZVr17dut7f31+SyJUy5vDhw0pMTFRISIicnZ3l7Oysb775RosWLZKzs7P1Z09elE0BAQEKDg62WdewYUPrRJz83Si7Jk6cqFdffVVPP/20mjRpooEDB2rcuHGaM2eOJHIDNxUnD/z9/ZWVlaWrV68W2galV3Z2tiIiIhQfH6/o6GjrVW6J3CgNykzR7erqqpCQEEVHR9usj46OVtu2bR0UFRzBMAyNGjVK69at07Zt21SnTh2b7XXq1JG/v79NrmRlZembb74hV0qxzp0769ixY4qJibEuoaGhGjBggGJiYhQYGEhelGHt2rXL92jBU6dOqVatWpL4u1GWpaeny8nJ9t8ps9lsfWQYuQGpeHkQEhIiFxcXmzYXL17UDz/8QK6UcnkFd1xcnLZs2SI/Pz+b7eTGg69MDS8fP368Bg4cqNDQULVp00bLly9XQkKChg8f7ujQcA+NHDlSn376qf71r3+pfPny1m+dfXx85OHhYX028+zZsxUUFKSgoCDNnj1bnp6eevbZZx0cPeylfPny1vv683h5ecnPz8+6nrwou8aNG6e2bdtq9uzZioiI0IEDB7R8+XItX75ckvi7UYb17t1bs2bNUs2aNdWoUSN99913evvttzVkyBBJ5EZZkpqaqtOnT1vfx8fHKyYmRhUrVlTNmjVvmwc+Pj4aOnSoXnnlFfn5+alixYqaMGGCmjRpkm9yTzxYisqNatWq6cknn9SRI0f05ZdfKjc31/q/acWKFeXq6kpulAaOmjbdUd555x2jVq1ahqurq9GyZUvrY6JQdkgqcFmxYoW1jcViMd544w3D39/fcHNzMx577DHj2LFjjgsaDvHrR4YZBnlR1v373/82GjdubLi5uRkNGjQwli9fbrOd/CibUlJSjJdfftmoWbOm4e7ubgQGBhpTp041MjMzrW3IjbJh+/btBf5/MWjQIMMwipcHN27cMEaNGmVUrFjR8PDwMHr16mUkJCQ44GxQkorKjfj4+EL/N92+fbu1D3LjwWYyDMO4l0U+AAAAAABlRZm5pxsAAAAAgHuNohsAAAAAADuh6AYAAAAAwE4ougEAAAAAsBOKbgAAAAAA7ISiGwAAAAAAO6HoBgAAAADATii6AQDAXduxY4dMJpOuXbvm6FAAALgvUXQDAAAAAGAnFN0AAAAAANgJRTcAAA8wwzA0f/58BQYGysPDQ82aNdPnn38u6f8P/d64caOaNWsmd3d3PfLIIzp27JhNH2vXrlWjRo3k5uam2rVra8GCBTbbMzMzNWnSJNWoUUNubm4KCgrS+++/b9Pm8OHDCg0Nlaenp9q2bauTJ09atx09elSdOnVS+fLl5e3trZCQEB06dMhOnwgAAPcXZ0cHAAAA7t5rr72mdevWadmyZQoKCtLOnTv13HPPqXLlytY2EydO1F//+lf5+/trypQpevzxx3Xq1Cm5uLjo8OHDioiI0PTp09W/f3/t3btXL730kvz8/DR48GBJUmRkpPbt26dFixapWbNmio+PV1JSkk0cU6dO1YIFC1S5cmUNHz5cQ4YM0Z49eyRJAwYMUIsWLbRs2TKZzWbFxMTIxcXlnn1GAAA4kskwDMPRQQAAgDuXlpamSpUqadu2bWrTpo11/bBhw5Senq4XX3xRnTp10qpVq9S/f39J0pUrV1S9enWtXLlSERERGjBggP773/9q8+bN1v0nTZqkjRs36vjx4zp16pTq16+v6OhohYWF5Ythx44d6tSpk7Zs2aLOnTtLkqKiotSzZ0/duHFD7u7u8vb21uLFizVo0CA7fyIAANx/GF4OAMAD6sSJE8rIyFCXLl1Urlw56/LRRx/pzJkz1na/LsgrVqyo+vXrKzY2VpIUGxurdu3a2fTbrl07xcXFKTc3VzExMTKbzerQoUORsTRt2tT6OiAgQJKUmJgoSRo/fryGDRumsLAwzZ071yY2AABKO4puAAAeUBaLRZK0ceNGxcTEWJcTJ05Y7+sujMlkknTznvC813l+PQjOw8OjWLH8erh4Xn958U2fPl3Hjx9Xz549tW3bNgUHB2v9+vXF6hcAgAcdRTcAAA+o4OBgubm5KSEhQXXr1rVZatSoYW23f/9+6+urV6/q1KlTatCggbWP3bt32/S7d+9e1atXT2azWU2aNJHFYtE333zzm2KtV6+exo0bp82bN6tv375asWLFb+oPAIAHBROpAQDwgCpfvrwmTJigcePGyWKxqH379kpJSdHevXtVrlw51apVS5I0c+ZM+fn5qWrVqpo6daoqVaqkPn36SJJeeeUVtWrVSm+++ab69++vffv2acmSJVq6dKkkqXbt2ho0aJCGDBlinUjt/PnzSkxMVERExG1jvHHjhiZOnKgnn3xSderU0Y8//qiDBw+qX79+dvtcAAC4n1B0AwDwAHvzzTdVpUoVzZkzR2fPnpWvr69atmypKVOmWId3z507Vy+//LLi4uLUrFkzffHFF3J1dZUktWzZUp999plef/11vfnmmwoICNDMmTOtM5dL0rJlyzRlyhS99NJLunz5smrWrKkpU6YUKz6z2azLly8rMjJSv/zyiypVqqS+fftqxowZJf5ZAABwP2L2cgAASqm8mcWvXr0qX19fR4cDAECZxD3dAAAAAADYCUU3AAAAAAB2wvByAAAAAADshCvdAAAAAADYCUU3AAAAAAB2QtENAAAAAICdUHQDAAAAAGAnFN0AAAAAANgJRTcAAAAAAHZC0Q0AAAAAgJ1QdAMAAAAAYCcU3QAAAAAA2Mn/AwCBFC2kAWi+AAAAAElFTkSuQmCC", 1001 | "text/plain": [ 1002 | "
" 1003 | ] 1004 | }, 1005 | "metadata": {}, 1006 | "output_type": "display_data" 1007 | } 1008 | ], 1009 | "source": [ 1010 | "model = train(model, train_dataloader, val_dataloader, optimizer, epochs=1000, device=\"cuda\", patience = 15, temp=5)" 1011 | ] 1012 | }, 1013 | { 1014 | "cell_type": "code", 1015 | "execution_count": 179, 1016 | "metadata": {}, 1017 | "outputs": [ 1018 | { 1019 | "name": "stdout", 1020 | "output_type": "stream", 1021 | "text": [ 1022 | " precision recall f1-score support\n", 1023 | "\n", 1024 | " 0 0.65 0.73 0.69 15\n", 1025 | " 1 0.78 0.93 0.85 15\n", 1026 | " 2 0.56 0.60 0.58 15\n", 1027 | " 3 0.17 0.20 0.18 15\n", 1028 | " 4 0.75 0.60 0.67 15\n", 1029 | " 5 0.60 0.80 0.69 15\n", 1030 | " 6 0.86 0.80 0.83 15\n", 1031 | " 7 0.82 0.60 0.69 15\n", 1032 | " 8 0.62 0.53 0.57 15\n", 1033 | " 9 0.27 0.20 0.23 15\n", 1034 | "\n", 1035 | " accuracy 0.60 150\n", 1036 | " macro avg 0.61 0.60 0.60 150\n", 1037 | "weighted avg 0.61 0.60 0.60 150\n", 1038 | "\n" 1039 | ] 1040 | } 1041 | ], 1042 | "source": [ 1043 | "preds, true_values, accuracy = predict(model, test_dataloader, n_features=40, loss_function=loss_function, device=device)\n", 1044 | "print(classification_report(true_values, preds))" 1045 | ] 1046 | } 1047 | ], 1048 | "metadata": { 1049 | "kernelspec": { 1050 | "display_name": "Music", 1051 | "language": "python", 1052 | "name": "python3" 1053 | }, 1054 | "language_info": { 1055 | "codemirror_mode": { 1056 | "name": "ipython", 1057 | "version": 3 1058 | }, 1059 | "file_extension": ".py", 1060 | "mimetype": "text/x-python", 1061 | "name": "python", 1062 | "nbconvert_exporter": "python", 1063 | "pygments_lexer": "ipython3", 1064 | "version": "3.9.17" 1065 | }, 1066 | "orig_nbformat": 4 1067 | }, 1068 | "nbformat": 4, 1069 | "nbformat_minor": 2 1070 | } 1071 | --------------------------------------------------------------------------------