├── README.md ├── Self-Supervised Learning.pdf └── Image_Colorization.ipynb /README.md: -------------------------------------------------------------------------------- 1 | # SS2021-19-08-2021 2 | Repository for Summer School 2021 3 | -------------------------------------------------------------------------------- /Self-Supervised Learning.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Rudrabha/SS2021-19-08-2021/HEAD/Self-Supervised Learning.pdf -------------------------------------------------------------------------------- /Image_Colorization.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Image_Colorization.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "include_colab_link": true 10 | }, 11 | "kernelspec": { 12 | "name": "python3", 13 | "display_name": "Python 3" 14 | }, 15 | "language_info": { 16 | "name": "python" 17 | }, 18 | "accelerator": "GPU" 19 | }, 20 | "cells": [ 21 | { 22 | "cell_type": "markdown", 23 | "metadata": { 24 | "id": "view-in-github", 25 | "colab_type": "text" 26 | }, 27 | "source": [ 28 | "\"Open" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": { 34 | "id": "kA26ItOODFRL" 35 | }, 36 | "source": [ 37 | "**Import Headers**" 38 | ] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "metadata": { 43 | "id": "H3AHwHkD0MJa" 44 | }, 45 | "source": [ 46 | "General Headers" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "metadata": { 52 | "colab": { 53 | "base_uri": "https://localhost:8080/" 54 | }, 55 | "id": "UON2uQnNAuDz", 56 | "outputId": "bbb6de39-2550-4b07-c839-c4e8aaace5d7" 57 | }, 58 | "source": [ 59 | "import os\n", 60 | "!pip install wget\n", 61 | "import wget\n", 62 | "import shutil\n", 63 | "import glob\n", 64 | "import cv2\n", 65 | "import numpy as np\n", 66 | "import random\n", 67 | "from tqdm import tqdm\n", 68 | "import matplotlib.pyplot as plt" 69 | ], 70 | "execution_count": 1, 71 | "outputs": [ 72 | { 73 | "output_type": "stream", 74 | "text": [ 75 | "Collecting wget\n", 76 | " Downloading wget-3.2.zip (10 kB)\n", 77 | "Building wheels for collected packages: wget\n", 78 | " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", 79 | " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9672 sha256=158faad761740dd33e4a2c1c7daaf4d2fe12c818894db0a4f8e438b87490c2f4\n", 80 | " Stored in directory: /root/.cache/pip/wheels/a1/b6/7c/0e63e34eb06634181c63adacca38b79ff8f35c37e3c13e3c02\n", 81 | "Successfully built wget\n", 82 | "Installing collected packages: wget\n", 83 | "Successfully installed wget-3.2\n" 84 | ], 85 | "name": "stdout" 86 | } 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": { 92 | "id": "knrDk5Y_0RaV" 93 | }, 94 | "source": [ 95 | "PyTorch based Headers" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "metadata": { 101 | "id": "6iqW-Yjhk5OL" 102 | }, 103 | "source": [ 104 | "from torch.utils.data import Dataset, DataLoader\n", 105 | "import torch \n", 106 | "from torch import nn\n", 107 | "from torch.nn import functional as F\n", 108 | "from torch import optim" 109 | ], 110 | "execution_count": 2, 111 | "outputs": [] 112 | }, 113 | { 114 | "cell_type": "markdown", 115 | "metadata": { 116 | "id": "5PoEZpF_0WQk" 117 | }, 118 | "source": [ 119 | "**SETTING UP THE DEVICE FOR GPU COMPUTATION**" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "metadata": { 125 | "colab": { 126 | "base_uri": "https://localhost:8080/" 127 | }, 128 | "id": "xkrsI3rEl4A7", 129 | "outputId": "22238fa4-66de-40f6-f5a4-95cde6b4302a" 130 | }, 131 | "source": [ 132 | "use_cuda = torch.cuda.is_available()\n", 133 | "print('use_cuda: {}'.format(use_cuda))\n", 134 | "device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n", 135 | "print(\"Device to be used : \",device)\n", 136 | "!nvidia-smi" 137 | ], 138 | "execution_count": 3, 139 | "outputs": [ 140 | { 141 | "output_type": "stream", 142 | "text": [ 143 | "use_cuda: True\n", 144 | "Device to be used : cuda\n", 145 | "Thu Aug 19 06:03:07 2021 \n", 146 | "+-----------------------------------------------------------------------------+\n", 147 | "| NVIDIA-SMI 470.57.02 Driver Version: 460.32.03 CUDA Version: 11.2 |\n", 148 | "|-------------------------------+----------------------+----------------------+\n", 149 | "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n", 150 | "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n", 151 | "| | | MIG M. |\n", 152 | "|===============================+======================+======================|\n", 153 | "| 0 Tesla K80 Off | 00000000:00:04.0 Off | 0 |\n", 154 | "| N/A 55C P8 29W / 149W | 3MiB / 11441MiB | 0% Default |\n", 155 | "| | | N/A |\n", 156 | "+-------------------------------+----------------------+----------------------+\n", 157 | " \n", 158 | "+-----------------------------------------------------------------------------+\n", 159 | "| Processes: |\n", 160 | "| GPU GI CI PID Type Process name GPU Memory |\n", 161 | "| ID ID Usage |\n", 162 | "|=============================================================================|\n", 163 | "| No running processes found |\n", 164 | "+-----------------------------------------------------------------------------+\n" 165 | ], 166 | "name": "stdout" 167 | } 168 | ] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": { 173 | "id": "A4D25A8gDK4r" 174 | }, 175 | "source": [ 176 | "**Setting up Data Path**" 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "metadata": { 182 | "id": "qM68zdO2IRUH" 183 | }, 184 | "source": [ 185 | "#shutil.rmtree(\"/content/IMAGE_SUPER_RESOLVE_DATA/extracted_data\")" 186 | ], 187 | "execution_count": null, 188 | "outputs": [] 189 | }, 190 | { 191 | "cell_type": "code", 192 | "metadata": { 193 | "id": "jd4gLw6uDV-E" 194 | }, 195 | "source": [ 196 | "parent_folder = \"/content/IMAGE_SUPER_RESOLVE_DATA\"\n", 197 | "\n", 198 | "if os.path.isdir(parent_folder):\n", 199 | " shutil.rmtree(parent_folder)\n", 200 | "os.mkdir(parent_folder)\n", 201 | "\n", 202 | "#Create Folder to download Raw Data\n", 203 | "raw_data_folder = os.path.join(parent_folder,\"raw_data\")\n", 204 | "extracted_data_folder = os.path.join(parent_folder,\"extracted_data\")\n", 205 | "\n", 206 | "if not os.path.isdir(raw_data_folder):\n", 207 | " os.mkdir(raw_data_folder)\n", 208 | "\n", 209 | "if not os.path.isdir(extracted_data_folder):\n", 210 | " os.mkdir(extracted_data_folder)\n", 211 | "\n", 212 | "image_data_folder = os.path.join(extracted_data_folder, \"images\")" 213 | ], 214 | "execution_count": 4, 215 | "outputs": [] 216 | }, 217 | { 218 | "cell_type": "markdown", 219 | "metadata": { 220 | "id": "0n-gyvN7EXMi" 221 | }, 222 | "source": [ 223 | "**Downloading Data**" 224 | ] 225 | }, 226 | { 227 | "cell_type": "code", 228 | "metadata": { 229 | "colab": { 230 | "base_uri": "https://localhost:8080/" 231 | }, 232 | "id": "TBnxcgceFT84", 233 | "outputId": "96b86e32-709d-4da4-f6a1-9d571e1c7efc" 234 | }, 235 | "source": [ 236 | "dataset_link = \"https://www.robots.ox.ac.uk/~vgg/data/pets/data/images.tar.gz\"\n", 237 | "raw_data = os.path.join(raw_data_folder, \"images.tar.gz\")\n", 238 | "print(\"Downloading Data\")\n", 239 | "wget.download(dataset_link, raw_data)\n", 240 | "print(\"Downloading Done\")" 241 | ], 242 | "execution_count": 5, 243 | "outputs": [ 244 | { 245 | "output_type": "stream", 246 | "text": [ 247 | "Downloading Data\n", 248 | "Downloading Done\n" 249 | ], 250 | "name": "stdout" 251 | } 252 | ] 253 | }, 254 | { 255 | "cell_type": "markdown", 256 | "metadata": { 257 | "id": "pndT1J33JG1H" 258 | }, 259 | "source": [ 260 | "**Extracting the Data**" 261 | ] 262 | }, 263 | { 264 | "cell_type": "code", 265 | "metadata": { 266 | "id": "dJgY_Nd3JGCQ" 267 | }, 268 | "source": [ 269 | "shutil.unpack_archive(raw_data, extracted_data_folder)" 270 | ], 271 | "execution_count": 6, 272 | "outputs": [] 273 | }, 274 | { 275 | "cell_type": "markdown", 276 | "metadata": { 277 | "id": "9ys5YOmXK2ZZ" 278 | }, 279 | "source": [ 280 | "**Listing the Dataset Features**" 281 | ] 282 | }, 283 | { 284 | "cell_type": "code", 285 | "metadata": { 286 | "id": "x9_u9N2EKuEd" 287 | }, 288 | "source": [ 289 | "def get_image_address(image_data_folder):\n", 290 | " image_address_list = []\n", 291 | " image_address_list = glob.glob(os.path.join(image_data_folder, \"*.jpg\"))\n", 292 | " print(\"Number of Files : \", len(image_address_list))\n", 293 | " for img_addr in image_address_list:\n", 294 | " try :\n", 295 | " img = cv2.imread(img_addr)\n", 296 | " x = img.shape\n", 297 | " except :\n", 298 | " image_address_list.remove(img_addr)\n", 299 | " os.remove(img_addr)\n", 300 | " \n", 301 | " print(\"Number of Files after removing : \", len(image_address_list))\n", 302 | "\n", 303 | " return image_address_list" 304 | ], 305 | "execution_count": 7, 306 | "outputs": [] 307 | }, 308 | { 309 | "cell_type": "markdown", 310 | "metadata": { 311 | "id": "0MJylShMkZQf" 312 | }, 313 | "source": [ 314 | "**MODULE_1 : Data Loader**" 315 | ] 316 | }, 317 | { 318 | "cell_type": "code", 319 | "metadata": { 320 | "id": "iLBq5_zjkd9u" 321 | }, 322 | "source": [ 323 | "class DataGenerator(Dataset):\n", 324 | "\t\n", 325 | " def __init__(self, image_list):\n", 326 | " self.files = image_list[:10]\n", 327 | " \n", 328 | "\n", 329 | " def __len__(self):\n", 330 | " return len(self.files)\n", 331 | " \n", 332 | "\n", 333 | " def __getitem__(self,idx):\n", 334 | "\n", 335 | " #print(files[idx])\n", 336 | " img = cv2.imread(self.files[idx])\n", 337 | " high_res_img = cv2.resize(img,(512,512))\n", 338 | " high_res_img = np.transpose(high_res_img, (2, 0, 1))\n", 339 | " low_res_img = cv2.resize(img,(512, 512))\n", 340 | " low_res_img = cv2.cvtColor(low_res_img, cv2.COLOR_BGR2GRAY)\n", 341 | " low_res_img = np.reshape(low_res_img, (512, 512, 1))\n", 342 | " low_res_img = np.transpose(low_res_img, (2, 0, 1))\n", 343 | " return torch.FloatTensor(high_res_img/255.), torch.FloatTensor(low_res_img/255.)\n", 344 | "\t\t\n", 345 | "\t\n", 346 | "def load_data(image_list, batch_size=32, num_workers=10, shuffle=True):\n", 347 | "\n", 348 | " dataset = DataGenerator(image_list)\n", 349 | " data_loader = DataLoader(dataset, batch_size=batch_size, num_workers=num_workers, shuffle=shuffle)\n", 350 | "\n", 351 | " return data_loader" 352 | ], 353 | "execution_count": 12, 354 | "outputs": [] 355 | }, 356 | { 357 | "cell_type": "markdown", 358 | "metadata": { 359 | "id": "dFkfUgl1amEk" 360 | }, 361 | "source": [ 362 | "**Checking the dataloader**" 363 | ] 364 | }, 365 | { 366 | "cell_type": "code", 367 | "metadata": { 368 | "colab": { 369 | "base_uri": "https://localhost:8080/" 370 | }, 371 | "id": "2xN3ua4CZh1l", 372 | "outputId": "74058035-4898-48f6-d0e7-d9c88e942375" 373 | }, 374 | "source": [ 375 | "parent_folder = \"/content/IMAGE_SUPER_RESOLVE_DATA\"\n", 376 | "extracted_data_folder = os.path.join(parent_folder, \"extracted_data\")\n", 377 | "image_data_folder = os.path.join(extracted_data_folder, \"images\")\n", 378 | "image_address_list = get_image_address(image_data_folder)\n", 379 | "random.shuffle(image_address_list)\n", 380 | "\n", 381 | "train_img_addr_list = image_address_list[:int(0.7*len(image_address_list))]\n", 382 | "train_loader = load_data(train_img_addr_list, batch_size=1, num_workers=2, shuffle=True)\n", 383 | "check = iter(train_loader)\n", 384 | "\n" 385 | ], 386 | "execution_count": 13, 387 | "outputs": [ 388 | { 389 | "output_type": "stream", 390 | "text": [ 391 | "Number of Files : 7384\n", 392 | "Number of Files after removing : 7384\n" 393 | ], 394 | "name": "stdout" 395 | } 396 | ] 397 | }, 398 | { 399 | "cell_type": "code", 400 | "metadata": { 401 | "colab": { 402 | "base_uri": "https://localhost:8080/", 403 | "height": 221 404 | }, 405 | "id": "Eg9j4kc-aPYj", 406 | "outputId": "1d9257d2-6e0b-4cfc-cde6-7eba87418bbb" 407 | }, 408 | "source": [ 409 | " GT, input_img = next(check)\n", 410 | "input_img = input_img.numpy()[0]\n", 411 | "GT = GT.numpy()[0]\n", 412 | "\n", 413 | "input_img = np.transpose(input_img, (1, 2, 0))\n", 414 | "GT = np.transpose(GT, (1, 2, 0))\n", 415 | "\n", 416 | "input_img = cv2.cvtColor(input_img, cv2.COLOR_BGR2RGB)\n", 417 | "GT = cv2.cvtColor(GT, cv2.COLOR_BGR2RGB)\n", 418 | "\n", 419 | "f, axarr = plt.subplots(1,2)\n", 420 | "axarr[0].imshow(input_img)\n", 421 | "axarr[1].imshow(GT)" 422 | ], 423 | "execution_count": 15, 424 | "outputs": [ 425 | { 426 | "output_type": "execute_result", 427 | "data": { 428 | "text/plain": [ 429 | "" 430 | ] 431 | }, 432 | "metadata": {}, 433 | "execution_count": 15 434 | }, 435 | { 436 | "output_type": "display_data", 437 | "data": { 438 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAC7CAYAAACend6FAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9Scwty5bf9VsRuXP3X/+d7t5zq+o1VD1sbEtIZoqEkAxC8szCTAAh1QTP8YwpU0ZINbAMEwwzECrBoGQLC4FkVJZVovqq9+5797172q/b/c6MWAxWRJ68eXN/59bzbU6VvpDO2fvLnU1EZOZ/rfVfTYiq8tAe2kN7aA/tr1Zz33UHHtpDe2gP7aF9/e0B3B/aQ3toD+2vYHsA94f20B7aQ/sr2B7A/aE9tIf20P4Ktgdwf2gP7aE9tL+C7QHcH9pDe2gP7a9g+0bAXUT+joj8kYj8qYj8w2/iGg/toX0X7eHZfmh/WZp83XHuIuKBPwb+feAz4F8Af19Vf/9rvdBDe2jfcnt4th/aX6b2TWjufxv4U1X9c1XdA/8E+LvfwHUe2kP7ttvDs/3Q/tK0bwLcPwJ+1vr7s7TtoT20v+zt4dl+aH9pWvFdXVhEfhP4zfT93x4MBt3f7zsWVf3C59fUp6/lfPk8IQTqusY5h3MO733zqap474kxIiLUdU1d14QQmn2+rnH9sv3P12/P9aH9/3Va97z3XeuXabvdjrquv7XJ7D7b5WCAKiAgkP5L+6ZPRRC0tVFAFQ7OrZ2wfbwd1Z63d78i+ZD2+TTt9e6oL15Nmn3ebREiEFrPqhOh8B7nHd7Zs+28S/dQCPnZjhHye/Deu/Hu2tIaX7s/fb3Le/Zt727pftOec7evKj19ANDOTZW8j3b3PNyfv/Ae6V7udjuqA8/2NwHuPweet/7+OG37Yt9Ufwv4LYDRaKQff/wxIQSALwCgc+4LL3sGkjag9IHLIcBx7p2x0gXy9rnb1+sTJN3P9v7OOdbrNS9evMA5x/HxMRcXF8xmM4qiYDweMxqNKIoCEaGqKm5vb3nz5g23t7fc3NxwfHzM8fEx3vsvjasP+JxzzfYuMN83H3nf7u9Z6PTNfd/8vQ/gu3Pd18d8ze5xuXXvxaHzd+fh93//a6PEf4lne6iffPSMECJOI947pPBEVcQ5A1Z1OBRxMb2zBuqigscTyQACkO4LESiIKiCKoHjxZFiIaMJxgyWX/glKSOfyQFQQB1EDUIBIY86LCE6tT1EEh0OkYLFZ8erl5xTiOJufcHFxwdFsxMjDeDxmMJrgiyGIZ1/vubu54c3bt1zd3fL27o6j4xPOjuYU4nGiRInWb3FIVKIoXh2a4NY5iCgOQRWi2Ng0SgJcRSXa+NShOJSQxqCoJKAURxGFGJXoFY+gUYlO8Cg+KrWIzX2MeBQVB6IEEZwqgmvuhaCIQlAB8TipQQVRE6Z2VwKoUAMqgrOOIOqIRIQAoji1OyqAqr13NmaoUbzavYwJ1DXa2H7vD//44MP6TYD7vwB+KCK/hj34/zHwn3yVAzOQHwLO3O4DrL4Xv72tDxzaf2eQzNvuA/a+a2ct/O7uDoDZbMbR0RHn5+fMZjNijIxGI0ajEcPhkJOTE66urqiqiuPjY1SV6+trVqsV8/n8S+DeHruINICY+5qF131z0xVo7XG2t9+3T989OHS/8rzm3+6zANrn6N6jvjH1CY2+7V9T+6WebRVwHgSPiCOqkDAZEXu5VR2oJEDzuATKIQGcYBxqEEeCJdsqWZ8MSdP3CdoVUEQKVE0rdSLEDP6ikOYoappfTfaDFogEAy/yMwMikRh23C3uEFVOphNOjo54dHbObD6GsGc4GlGOxxTDY8Znj1m8fcGuqjmqlT0Fb29uWC1XHM2m+ELe9QNncwB4KgP9ZLhEch9tbE4wAE1Aj9iMRQCniNRJaxYkpvnHpseEnuDVtkUBiAasgokFVdTZ9SRZAoU621/BqZ0z4PEozkWEClGoVfJtsfmPPt1nm0vBITGBvotEkmAXQYmI+gT0EYBa0p0UIWACBlVwDlFH19Zqt68d3FW1FpF/APwfmHLwj1T1/3vfcV0tsb09t7Y22dZU2/sdeqm7wNzVdNvg03fMfRp+u++qymKxYL1eM5lMODk54fnz5zx79oz5fI6qstlsmM1mzOdzxuMx8/mcN2/eMJ/P2e12jEYjttst2+220e775ibG2Dv+3HLfYoy9mv2hsfbNYxd4+4RIvla33XdP77tee46752kLt+54u8d9Xe1f59lGfNI6BYg4FOcMmEVpaZoecUmwqQMniEREk4YvEaiTiucSYGQghyAhAbUBCRoYiEFUAJwqXjB0EigMOVDxCQQFkWAaK9GQDJ/AMnC7WFCtVhyNppwen/Ds+Sc8+egp8/kJPu4JqwWDo1PGR+e46Tnj4yPuXn6Om0/Y7lbMhkNW2x27bUU5M+Bz4pJqHVIfCoJGokCBUCgm5DTYfGGAL04gRgqx30lUlmLaLwjBRYpMcghI0pejmBXgiXhNfzsTGmb/CF7TvDnFi1CrJispM2bRtpHnLYG6OgNqERMeYhq4qCatXqmTkFL1KMHuDSZAcBEnStD8HJO+K84MCQIRlfuf72+Ec1fV3wZ++y94TPO9CyT5Re1q1X0aeT6+u60NSO3rHOrLfRREPrYL7AB1XbNYLCjLkrOzMy4uLnj06BGPHz9mPB6jqkynU4qiIIRACIHb21tmsxl1XVNVFUdHR2w2G5bLJZPJhKL44m3K1+yjjLo0Sndeur/3/R1COKjFH5q3riZ/qF9tIdje731af98x7/O7fAOa+y/5bEfA4zS95C6izhHVJQ1PEJcJWkU0Jo01GBWioBINcLDvQR2StLqIknRaAyfNGn0NCE5d0lCFaPofiMMlgZJ56pjoC0UIEhmogZyBf6SqI3eLJYNywPnZCY/OL3j06JLzJ7/CeDzCx8DoV+e4wZBQBULcs11cMzmasa8D5/vAzfyK9XrLannDdHKJLwRNFotL0B1FDfgSYEeNeADxSZ8NeLHnIXgDek3UVESSwNB31o1i400UigI+U4HOANUpEB3BKSqKU9PnJXE6QaJRVgohWQqZfkGw/cjAGxDlnTWg1usokiioaNo/JrhdekacGpDXLuIFiuioACcBp4kOSsKrTNbffe2DyVC9z+xuty5Ad/c9RCH0gXVXy+324xD43Qcay+WSEALD4ZDpdMr5+TnPnz/n8ePHnJ6eNpz7+fl5o3nGGBtAHwwGzX77/f4LY+kTXl2tNmuyh7Tg9ra2sOwKwe4cdMd+iJ7p0/b7fmtTcDHGL4zjkKDIfe5aWd3+5XPcRwF9m82J4ohECagLpuVFjI5QSdBcYLSDQBwgSSuHBL0KJKoikMcKRg5I4oYjkrTCSEQpiAh14ow1WxAohYLgqHHExEs78YlSUIoIJA1XEtjdLXbEEBiVI2aTKacXZzz+lR9y/uQT5mdP8EVBOT5ifvEU5xSJgRhrJsdzdusFfigcn55QlI7tPhKiTz6DPBYlc+QGgUa71CQeXRWnMdkqLs2DURMuUR5e03fnEgUlhtyJvnEiOPEGxiKIAxXj1k1zF7w6wBPS+F2iSrJGL+oSqKfraxK76TYN8Qw0af5RUfWQ+htRnJoHxCF4jSaEBMTZ+YSCWoV98gsUeERMaKsaPbMXoXqP8vLBgDv0a+9tAOruc8jc7wPoPlBub+9ywu1zZ0DpAmk+JgNqCIHVasVgMGAymfD48WM+/vhjzs7OOD4+pixLzs/POT4+bvj2wWCA9575fM5gMGCz2TR8vIh5w9sC5hAdlftyCPi64+4Dvu74ukKkKzTzvPVRIe+jRfq08Py9b4x5jrv3pXvNbr8+BHDPOmRW81Q8TsS0TyJeakQ1OU4d6iJZhzbdU5MmTgJw++4SqIiQgMdAOHO7drls7CuoMbkBb05VMYpGnEfVZflhxzsDJIL1cR8Cq9UdQ19yNLJn+8nz7zE/e8L8+IxhOeDo4mMmJ48YDifMTy4oBiW+KJgenTEqPfv1HePRlHFRIsCm2lk/E7ePMxrDYbyyE0mgB+oUcQb+eR49Dq9Gd7hk9Xi1f8R3+4o6XDSHZdREzRRK7UyTjyRaSLOQMdqsEEFcoqYczf1x2qJ/iCChcZwGB3tnlJKL4NUl4RrxREqVpNWbUHB4iA4hC7qISKBIgsjoukSv4sE5BiLJGd6O7/ly+85CIftaG4T6tO2vShUc4m8PUT+5dUGlS+W0v/edf7/fs9/vOT8/5+nTpzx//pwf/OAHnJ6eMh6PqaqKoiiakMjBYECMkbIsWSwWnJ6est1uAZhMJtR1zXa7ZTqd3juGNjC2/RLd+ekCYx5fBs77nLHda3e3d+ejDbjtKJhuP+7b3mcFtPvRJ0i6wuI+S+/baQYB5iLNcBBw4o2OSNSKa6I6Ak4SRdOMX0C9aa9iJj+Yma9SoLpP1I0jiKPAaKCIxxEoCBRAEKMafNKEJSMnijgTDh5zuipg5oXHUbGv9oRqy9HxBc+ePuLxJz/kya//bY5PzxhPhrAvkEGJuBHilaKcUEXPYDBlt7vm6OyS/XrNcDRgPhlTLTbsNjviZIxL1gMSDeZVDNjJXLrx5JpoLZdoKnMbJK9DplFEcBRJaw2N5TKQRIEV0QQHdqxLNE10yZWdBabNenqumjgWix7KFJcIJPsAiXZdFcy2MrcGziilTO+oJPpLNFkf0Qi1RB0FQKKzuyAG/lFDcsDbtbKTvRDHfbr7BwXu8GXapY8a6WqdfdRJ9/shnrl9ji4IHQLIPiBS1cYZOpvNuLy85NGjR81+0+mU0WhEXdeoKuv1uolt3263rFYryrJkNptxfX3NcDhkOByy2Wy+cJ3uNbu0zaH5OTSOvjntG3tfa5+nfa52BE/3+u3f2hp5H5j3+RHa483g3QX79jm+yji+2ZaeP1GcFIiQdTHEGaWSIh/JqB2TIy9vjw3pUKeIDUWcb0ibIMncT0MNiTaQxEurWLRJlBStQXYapuNRCnzi1gMQQctkMRiw7bcV43LM0WzE5cUTzp58jOgORBjOLxiXA+pQIzGwW99Q1RtivaXa3bBfvKEcuPRs31AOS8oqsNxuiHJGQWWWSRJ2LiFjRHDBQhVFHEUC4iDZnol4hOAN3F00yI7OQgdjGmsRBUSTBfXumfBJqAjgtUgiJDmoXUxavk83xyJnlNjQRo2FlMA2qL4TzM5RqSJEvHrrSdL+aSDanMl2j4x3jwjis+WiaA5FVfPLuHy8iHH+97QPCtwPAcIh+qXv+K/yMrfBoE1jdCmOQ33rA/gM0uPxmMePH/PRRx813LmIMBqNGAwGjSN1s9kQQiDGyGazQVWJMTKfzwG4u7vj7u6OqqoaodHuRxvYDmnD7e+HrJnu333z0de6c92mjdpA3z1/nxBtj+tQf/uu26XQ2vt3nbDfZXMAYiDasApkmilhARGyRt12BhJb+ytBvIXPqcdLZaF9mvj2BDI57l0S9xySkDCdNFoETswx1+bclcRlxxzKhwGOiFJVyn67Yjoa8eTxR5z/yveZnz2iLBxeKobDIcVggI8eQkW9VqgDhIrdamWywsH4+BQVZXF3x93dgrjbs9/t8cPCQgoFE1QqeAdFikE3B2RARb4QK4749Ft6J9Jr6xtY12YcEcGLAI6gEePKs6WigDktIdFBuMSPkwBdceKyTp6MKiWmc3hNHH/cgUvYgloEjLgmtLFxAWBzL9HotfxgFJL9DQ4XLf7d/CGgagLdEVF9p8Hf+9x9KO0+vvYQ/5t/64uR79Pou7xs99r5+yHNvW8fVQtv9N5zcXHB48ePmc1mTCYTyrJkt9vx2WefEUKgKAqWyyWr1eoLXH6mZpbLJTFGxuMxs9msyVQ9pH0f0rb7KJsuMHbn4pBl0B1/m8/u3ou+8Mzuvt3Wvd99YN0VBl3w7/v7Q2kRB7FI0TKKZn43aeg0YwJpuFwaZrkQxYtF0Fi8uqaQSHuBHZlzLrBwyXSPABe1gQDBHLhOnUXnYPHlRimbkzJKilyRCq9KVM9yu8O7gsfnl5w9uWQ6mzCczCjKIXF7y9VPfw8NW4rSs1u9ZLd8SyGBwglRKmRcsri74W51zR5lOBkzmx3hvCMyxFsMEMEZZWE0i1C5SBSlUEehPlEyySmaZlbJmQHCQA34AjRhglGaSUo0TnIza0A1UzTv/BneJXpIDfRrgVpSsKlGvMYUl273ssTuWZAA1FjqkzPNGnN010l8C4KLimhIUU/SxOBLAnBrybJKwox0fzwB0RpNxFmmjg61D0Zz79OM8/e+fdutm03ZRxe0W5922qeJZtDrasndPocQmrj2y8tLTk5OOD4+bqJAVJWqqliv18QYub29pa5r9vs92+2W3W7Hfr9HxLJV37x5g3OO8XhMURQsFovGwdq+bldYdeexu709T33A2wXOPh9E3/kPadnde9G+n4f63wfy+Xu7P13B3aVrPpQmkJKH6qQRO7yksD/NWmB2uGJZkRiVAslppinhBm8aXtY8E48vUqMUOIRB2hY0nSvdFhGzGtQZiIu6lBFrfHuMEFNYXmMJKIQQWa/WHI8mXD664OT0nOnJI1zc4+LeHI6yY7+6Q+OI9dVrqhDYVzu2uwXVZsN+lyKEdltuX78GP2I8GjEsPIvFDZPhEUXSXF0Ki8zgCYBzhBS+SbT77AHUGXftHPuoDNTCTQ0ULT0oEECNgglO0rE5lwDQlAhFbeGGifpRIupAozmrXcSoHUlAremdSlaRV039jinHIMXvk45TtcDUluXh1L6rmo0R0z0qSFp5si4yRYdYpIwo5kh+z7P3wYA7fJkOOfRCd0G53Q5RAl3hcWif9rX7gKQPqDabDSLCxcUFJycnTXLScDhkMpk0wK2q7Pd7NpsNu92O9XrNZrNhOp0SY2S5XJIpnMVigYgwHA5ZLpecnp5SlmUvQB+ycrrj6yu9cN/83WdJdY/p07775hy+7Lh+3zX6znGIX/+qff62mpKCLVxKvGmgw+MMMZrUflJKuuJapjpkrc/i2hULmUyALRZSl0mZIDUQQDxRC9PqJQsZJYoQUjSIRI+avd9YDEZbW6ikOmG1WuGBp+cnnB/Pmc3PGI8mlKOS+eiUsL9Ncx0Iuw3b7YLtbs9+uWC/uWU6m6F6x2K5BXEMR1OWixXiIuOy4Gp5TTibUhRWZ8nCA4GUzRtUCc6AXjQQnUPVhNw7IFUK80gSVDFbKQVCShq8GvduuCoYly0N2NZiVotv5j2aAJSUW+A0USXZhfouBl6b3AFLRMphnNhU4sVjsGyWkCUzmW+gFhCXHarScPcW/mr3SZ1ZAWbamTAJMdNJh9sHBe5djfB95nr3ZW5/tluf9tqniedMzvvO19U2Y4zs93uOj4+5vLzk7OwM7z2DwYDz83PKsmS1WjXx7DmiZrfbEWNkNptxdXXF7e0t3ntevXrVXKMsyyaiZrvdMhgMDlojXf9Be3tXaz/ka+gec2gO++5V+37cR5f0WT7t/mdrp+/6Xa6+GxnUJ5z75urbbILxyGiTIJ/izV3DwUtKQzIAz3RMykpUGpHgRDGeOViYnHo7SvL+EZGIb35LyTMkJ26aC4/xvOo0ORTtHE6iGf9iwB4jVPuK8yN7to/OLxn4SFEOmJ0/Zzh01EuH1Duk3lPtKsJ2T9wuUd0yns25vr7i7uYO7z1XL19Y8o9EBmXJYODRGFlvI2XhGKhp20iKRBED5BBTNI+4BMjB9lGXNN+IF4fX2MTsKxYl41EkOlQ8USKqkVIdTh11cnA6hCJZK+psf4NjA/WQ5ssnE0pSUpJGbUIkaWgSi6EXCSm5SggqOOcJWieh48iFA4yhK6jV7kOUSM6AarJeE22k8s6KqBPvf9/T/UFx7l2KpM90b//r0z67mltb238fqHWFxSFgb/+WKz/mOHXvPScnJ0ynUyaTSUPb5Gvm2jLee+q65vr6mvV63fQtV8csy5LRaNQIoru7uy/QPN35yufvaqttYXVIo2/PWx+10eXtu3PRnftDtE33+O44+oqV9c3/+/p+6P59F82MeFJhKntRrTaKaZcFxuMaUxuafkcxOkeS2q2iSVNTBCtlgFgETJ2AyFEgWoAOQFxKs2/xz1ogmDYanBBdbNAhJuJXgAHgI8RaiVXNyWzMoBRcAUfHj5hMj5lMj5AQifUuhfc56hgZjCe4Ysi+FpZvr9nfLXG6p3CRYeFRqRgMC8ajEoencJHl7Vs0gKo5LIMIkmLFa29UiGoC4gguisWQ00p6chBcAsIkGFzya0SJCDUuWuRKLRCc0Vumeps/Q8Qc1SIWNop7V3Atzz5RKVTwMSU1qWURO1L4phjEi2b3eHKORxikwmx1Or9CU55ABAoVyigUwVOoWQdodq7HJi4npHIG/suVPr7QPhhw73KmbSA+BCLwRQde97es3bV/O0RnvI92OLRPXdecnp7y6NEjxuNxo22XZWkmnfeMx2MAqqpqSgAPh8Pm3DlRaTQacXp6ivee7XZLVVV475lMJsQYGyHRHkM39v6Qht3X90Padx8Q59bOJu2bp77r99EzfQKqT7i3+3rIKjv0bHTH9l21qGaoqzMQjm1qT8zsJoNU5oFVCGkoTeR5NE3V6BhLy880jxLBJZ5YFKU2ABHMvBeLOHGaEp1ELLlHrTCdpu+S9M8ojn1dc35yyqPLx8yGI4aDEjcsGQwHIMLAO8ajCWgkViuod4iUDMq5hem5SLVfoeIpJlPm5+e4omSzrQhVzcDDdDyhBvapwJe6d/STk0yriI1NHNGbNq1pbDF9ZgcrgETB6u6Y0HEU5rx0FmpJY63ksaZZjBCjNolKOZ4+oCDvNPvgQF0kSm1CtJlnAQ0gqbqtGq8uTlFLScaLRSwpsanOKcE0cguFTDVncIhYCKVZCrU5YlOilV3z/uf6gwH3drRGGwDeB8BdTa57jq6G2D3HIYDrfnajSXLb7/fMZjOGw2HDtY9GI46Ojjg6OmIymTAej5vImPF4zNHRUbMtR8RsNhtubm7w3nN8fMxut2O73X7h+O12+yUgy/3vCsLuGA7lD/Rp0u1zH5qTvjm/b976fusD5j5qru+67W33WVsfQnMijf4nyZmGpGgNMcqGSNLxUjge2RzPCG82eUxabC79G9VQUXLGY3JI+igMoia7P1WjTOCfgy7ttCkdX7JQMGECkbANHE2nTIYlk+MjhpOS4WjI5OiC6fEZ5fSEcnKE8wNUhgzGF0yPzymmM9SPGc7P8W7AbrVmcfUWN3AcnxxRb9fsN2vmkyHT8RARz2a/JYpL4GsALUmzds4AU1LEEM5ixgWx7NREdmgGWp/AMRU8iw7qJLaSSwE017IxsI9OCV5NeKRtTsCrpTTlEm2maNtx4hzR2f65JEGuUml9TO+kproySRrle+tJzlXB7p9Ld15poqEqgeDMVS6Syg4nikjkneXV+9x9bU/w19AOAcAh51sGj75j8/c2uNz3ry8785C5n1uu/ZK19ePj4yaJ6fz8nNFo1ABWTl4aDAbMZjNCCIxGI3a7HTc3Nw14X19fU1UV0+n0C2NUtSSp+/rUtX765rU7vm5SUfuYthV1aA76frvPCjp0HuBLgqB9D7qt3be+5+Q+gfxtNsn/HFZaIIG5OesKgnqikIx+l1LOBZfC8rIDUMhcuaa64j7RABYaWZBpCqMH1JMckSm+Wy3eOsVepLKz5gx0kpNjTAiAsK8CooFR6RiUgdnJEcPxEeXRI2aXv4IfT6gxwIrVHhcUPygoj86ooqMYH7HfVayu31C6QFivuXtzw7pSRrMpaDCCSRw+RKpthahQRLV6LBIN7J3gtEBCiURLZErJrACoszlttPzk2QiSuHJxZAzMhdEkxfJHJGG7WqKROnwscNHuQZ1ookTkok4aSkdTTRmvRsmYtq448bhoZRGcvutogeIlgAvJzxFBQxLnAilZSQWCV2pJmati149ivpsgNKGuNNU0+9sH61Dt++2Q2d818dvf2+VuuyDwPq2+e50u4G02G4bD4RdomJyYlEv25uiYEIKtmlJVDU0DNIXCcoTM9fU119fX1HWN9571et0kR7X71C0Z0O5je782cLePa//eHWv7fH11XvqEbbt1/Rrd+9PuZ9+9e5+l1af1H+r/h9DMqZbGlBxvSX18FxLpJNEvEat+WFjoor6rLZJD/6w5qy3e1IePqbTvu7jviO3v3l21paFna4JEgRjMqCqosFmvmQxLxoUwLAsGGol1RQw11faWanOF7pbsN0v2Aer9GsKOYnJieKORYVFydPqIwWTA5m7B8u1bbt68JtY1rvBsVhv2mx2TyZSY0nzUWYRMoSTAteJalUQk0VoKOGdarD2jRt1E1ZTkZGWCJZUUCEk4Flm0uXwvkrMbSQIupKiYlM2rkVzRXVN0jMsLoqglg0ULl0lCXNEYcS7NPSlCStJ9twGSLTdJZSOD5OglKJxrLBez5dJ5xOwtJDZ8ff53qH0w4N4H3n2A2tVmD2nsfefO3w+1PiACeq+V+zAcDjk+Pm7CGXP8eoyRqqrYbDZNyGPW4J1zLJdLrq6umM/nnJycNGGT8/mcH//4x9zd3eGco67rxjGbE5y8970rNLXH2E406ht7d/8+7fvQnHaFRvvcfQLk0H3pbjskRA4JiHbLfWlHPB3i6b/NpqkfuVaKRXsUtvKRGKEQtb2/TyCdLO5c8z0fLZDD6kSS4068RYNgSTEhh/JRNKBO0tpJkRwu1TsXZ8BhWFJb3RkRvHjG5Yjjkzmj2ZxaA66q0N0OQg27JdXmxkoNrO9QLECg9jesF9csrl4wmZ8zPV1RjMcU04rh8Qn1n/wx1XIBPjCqB9Qq7Ci4W20IAQZOGfhknWhKbU11z0RoMkJzVZV3NWgywBq4GlWVREaO6Vd7Z+smgzUBNglfUlVMJ+awLZRkVdXgLIRR1SgYTfkKjSVErvtjwjbTZl59elZNAmii3KKafyHbUpooH6I0NXNAiBKSpWYKQkEBKCGmom/3PHsfFC1zqLVf7C5o9b3Ah7T5vvMeArh8bJ/22K7AeHR0xOnpKavVihACy+WSoigoioIYIzc3N02o43K5ZDgc8vr1a16/fo1zjpubG6bTaVNLxmbCZ/UAACAASURBVDnHyclJ40QdDod47xsH7GazaQCsK9ja1NJ91kwXUEXkC5mw3WP71nNtz3+fj6QrlNv3se8+dFtbO79PU++OqWsdfNeFw3KPjV6x6I5cX0RTNRNM8TRzW5RITdbBJWmGIZMDGolqJYI1OwNFskcvccK2qpE0STLJIZd+8ymLFRcSwCXnHy4tIKI4N+B4Puf47Jjt6haplc3iBjdwFL4kamB18zmrNz9ndfeS9fKaYjTj7uWn3Lz6OeoKFtevKeYXMD7GjeaoHzM9O2E6GeFrwQ/neF8wHI4QIuvdlqDg8ERxVM4oCgW8k3fhgZpj8oXgjIYpEAPvFIsuYFQUnsJZPIsVVstQaq1wNhcqmipMJqpGIsHl0EqzJnLYJD5RZhE00URoKlUg78DZxdRXyRZEJEfG5PwEda4F5Bae6lL/XK71nqgyq3JZ4WJMWcv3P3sfjOYO/Q61/NkH2Pf93cc/d4VBH+VySGvtbosxUhQF0+m0WS91s9lwcXHRFAjbbrcNuGR+PpcgKIqC6+tr5vM50+mU/X7ParUCDKRzwbBcSRKMwsnn6Utm6mv3USZ9ZXH7xn7feqp9VMuhJKVu+ypUW/67rxhZHkPe51C/vstmV7fl1JKfDssoTZqmWGQMalpadqHmFTQFh3OakpvMDWc1vY2+EQ0otaXwp/P7pJGTIj0sMcg4WqOEcgJMYUAU1UIuU5+iOlxRMp2PWa82XP3iU6rlmuNHzxgNx8R6Rb25sdqL6tDNllpqboKjGAwYe+Hm7c8ZH50zmU2p9ju2yzcW6umH7FZ7SzPa7/EDh9ea4cCz29fUkxRWiLdMXiutiIk304Cji6lksk9UTHJqJo1dc71dS/AkJxxpmm/jpkDEU6tV7ETSnKIUApoWOLHEo0BKB7PnKpVOdoLVlxejdxypvACptLBaTL8t1iGoeDQKIWW6elVUbYUn79SybzFqyQrBJUdxOt41JJGJg7p5vvrbBwXufVrmIU62/RJ3F1bugkbfCk5912wfewgscsta9Ww24+7ujvV6zevXr3n27BmDwYAQQgPmORZe1TJUAS4uLpoCYkCToHR9fY2qMhqNeP36NTHGxlkbQuDq6qpJiMoROLlvOUyxG3mUx3Ioff99VFV3Tt/np+i73iHap8/y6hPOXeGb9+smMnWVg75l/77tlpOXYl50IXPemnTB3HcK2yYttjU52kSdhQOS68akcEEEVRtrLTkyx0AelyiMmBx7mgoWJA3TVhISq7qYHIcqkTrCtCyYTuesb65Yr2qu9DXnH/0QP5yg9R7VQB0rNFbUdaCWSNi9RXFMH33MTnfs1ivi9VukLKm95+b1W0SV4WjIzZtX7HGUfsTR6QlbFV5dLywxKCh4i4LBpTDPmMruOpdAzjI5A4qP2eKwqJronTkzcan6TKqzQ3JQkyvpGFUSYkwpZA7VFFApQKJDCs2pRxhXrqR697bYuOSQR6x0cJ2uFWONiOPdKk0h+TWkuQdowAspI9knay6FRkZlkDwxgkvCP/kJMvV2j/b+QYH7ISrl0N/dF/++c+bvhwDpq2rAGTjrumY0GjGfz6nruqn2mOmVnIna1i4zp75er1ksFsxmMzabDS9fvsQ5x36/5/r6mrIsmc/nxBh58eJFE0ufMzizNn/ImdonkO7TaLuC8T6evv1b16nbndeutt09T7cd2q+PaumuOPUh8OuHWpQUS97o8fllz9p0ImAEchUZ4R3w58WV0cKiSBKHr6rvHHlEXA79E9P+iiZ23BZhLlSb5fasuFWiEizw3YBIPLFeMxxPOZpP2O4WrLwn1sJgNKMsp+huC9sdRQDvrJ7LaHrC4Ogpu9WKu8UNxdFTNqvPuX7xEwYSqHZbVlevGZVDZkdHxFjz8vOXbKVmfn6Jd4DuqKo9E19iYYwW7qeaOfYM0cZXq1qNGZeDRsR0fjRagpY6W24v5oUITaAmxd20YHUpNyAVE0uQaI9iEn5igEz2AZi5ZYlf0QSjV1IZCUE1NPROTHWbjUpKAkJzApQSXBZEdj0nnhqlzhE1kSQsYhNS2Yirb3uB7H+d1uWOD2nRuf1FtfEuiHXDH9uRNYdWgMrgl49drVYMh8OGiskLYWeKxnvPL37xi2aN1LIsm3VWB4NBo81vt9uGW9/v9zjnmE6nnJycNAtu5z4c0kb7QLOrOR/yUXTbV92vS5n19ePQebqCt3ts37nvexba27v36btrKbQxmdIuVWM03LDvauu70V6TM6pFcARgkGqpWPy1Sy+11QOvk4ZviawxOU1ds0CEFwOYWi2UL6pFmlgJAwOWGDUVFMslf0tEHPvlDX5cMBrZmqjnH/+I8ugCVq+YP/oE8QVvP/sJw+kjdsHBcE5VB3YvXhPLYwKOzX7PanPDyMG4HLHb73FeGB5NOdkecbvcslvdQaxQhUrTqkWJS09rDqXSvykLQJJfIIGfZaZiwK25To+iEoiWAppEQvZP2PeA4bSLRoGY6DA/RSUZNhUXEg3i7J6ZwWMJRQnDU4RNFjImCCzk3aeIGnP0BgCpTT5ENTouUW6KRQm1Q1Y9zgJznCaayGoVRUcKcT1sdX9w4N59mdvbc+ua6e3WV+O8j7LpK3HbvV73ut77pn9VVSEiTUnfzME759jtdlxeXnJ8fMxqtWoiaJbLJa9fv+b6+roRCmB8/M3NDScnJ031yBxxk7Ne7+7uTFPxvqFl2v3uoy26YzlEdfXNb3uu8rx26a++87XvX/f89wF+331qL2aSraIcEtpVAA5RO999M9D2WTNXc6Q6dQTnUmZiCgjJoI5QJMehccw2Di9GM+CMFzfNVhP3nuLWBQYpkSZSpHNb0ostMm0XNA0SarFjCjGttlahqmr8qMQPh+jmDok7yqKk9kK1W3P25BOmJyesljtmtUN3K1bLFa9fv2B99ZLt8g4/VDwBv1myunqLOzmhqnds10uqfUUMwnA843Q05uZ2gyoMXAG1FcUq1BStgNEVhYDGVMFcaagWi/M37TkiKevTFjWxf+ZoTXGluKjULhE0Ytqz90KM7+LNI5izUi28EpewALW6MYnOyo5O1RyA+i56Rl1hVTYVNIVN5t+iOvZ1JNSR9W5HHWrG5YDJeEgl2ggZVaOecBYBZfldCs7KT8i9jPtXAHcR+UfAfwS8UtW/nradAf8T8KvAT4C/p6rXYm/Yfwv8h8Aa+M9U9Xe/yisAX9bUc7hfH+Vw6Pi+hSDyb/fRDff1p49vzwJCVRutPITAzc0NqvqFKo7Pnj1jt9vx8uVLVqsV+/2+AfKyLHn69ClAw8eLWOlfMMsgC42iKCjLks1m04RHdimR7hi7wq5vDg4JgD7w73Lv91FpfRZVty95e9t6quua1WrF7e1ts2JVCFZ35fT0lMePHzeLoBwSUPfd19bv386zraAur+DjGo06/+bE+FQv9rqmyD+Lx9YEU1oRcM1aqRGPE8u71Gh1Yhx2LmK6P0ScexfiFzLrLErQFM4rVhhXYqIHopUmphBcrJjOZrjzx8SqIlx9hot/i9nZOeWwgCgMP/4V9rst1YtXjFYr4vaY4+Mn1PstMihxHz0Hqdnvdyl5yFNXSxRhs1JcUeC9Y6QwLK3sxmxamlBSx0AcFYE6OTuRHOtiafpRLXnLtGOLIAk4c6qmOY5YJIwBMjhNNXwSTx40pNWs0rqsIihVospSZJwKIjEtGE5KbpLUJ000jHHsqPXLpVIBBXZPKiJVXXO73nJzt2Cz2hLqmjqYonh6dsTTR2cM/DAlpeXFy98lOBXqsEJpdn/va1/FZv3HwN/pbPuHwO+o6g+B30l/A/wHwA/Tv98E/ruvcP4vtD4N8tDfuXXpnL5jDkVVAF/QhPvoiG7ctqpli+52O4bDIY8fP+b73/8+P/jBDyiKgtlsRlmWFEXBcDhku93y8uVLbm5umvoxs9mMoiio65qjoyOePXvWrJuak5p2ux1gqzKBLdWXq0S2x3xI0+7T4vs03kNCrz1Ped/3ZX12z3kfZdMVnDFGFosFn3/+Oa9evWK/3zOZTJhOp0ynU7z3XF9fs1gseu9TVwj1WYGd9o/5hp/tRHEnrjQmusA1GvO79TTfBehlJh0VfKoJ48U1i0AbDNWkBfFMkxdPSCsFBZeyXkWpVdCQHLopm9W+G88cY4q5cJHgA7Uo1W5LvV1SDkecPnnORz/8IZ/8+q/jvGcyO2Uw8rgBlKMB1XbN7ec/Z3P1C0bjMdOLx5SzC8JwwjZGRiePOP/oe0wmc+o6cHR2xnA4Imx3IMrNYgEqjOczBuUQQkBdYQLQOepEP4maPWMFuyyTl+R8zqSXvQuOnI1rUjWk6piOmMr6WpVOuzFRjGqxDFJzLgdI5xF8SMuuSqZ3LPploNEWQkllI0RiXo4W1EolWD2cSHBCpcrtYsMvPn/Lq1fX7PeR0XTCeDpjOp1Resf11Q23y3XyCyi1s3BMG5+HXFiNbIXIPYz7V9DcVfX/FJFf7Wz+u8C/m77/98A/A/6rtP1/UHuj/h8RORGRp6r6+fuu05cJ2f7e5cj7aJpD1EL7PPfxzn2/99EddV03AJtrwWQwnkwmFEXRRMHs93u891xeXlKWJS9fvmwsjO12S4yR9XrdZKpeXV018fCj0Yjtdsvd3R2np6csFotmQe0cUpmjcHLkzKEEovYY+7b1zf2hbV1N/6sK4UOCNQvLvBJVWZbNvnkeVbWpupkprEPn/ipWWTrmW3m2vXNWLCwBtnHGlp4eW892XnzZEheNbrEU9BQpkj41eotRT/SARE9aTslwmryIM00CDKnEQA6V9AncrVSuhQQqQqgCMSZHpR8xOn3EeDQkbtYUsxNkULJdWVRKvQtIUXDy6CmuHPH21U+RGJC4R9d31OoJumcwHDO+uODq7RuWyw3FeEK5q1httizvFrizgps3d8RQMBgOqWpPXUQItpyc91ZeQF1A1CMpNR9xVhs91cIhAzfmhJSc+RvN2imCoD7VbCeSq0KqFKkQmS2A7dRZWQPVJlPU0qRI9FdiyMUAFrWoHRctkic6q7Cv0YT5er/nZrnmbrGjHAwhbhECu/WOppbMYEDpC26uVzyan4HmqCdj5HNxNLNCXFp+T5v73Nd+Wc79ceuhfgE8Tt8/An7W2u+ztO1LL4CI/CamAVEURS9l0NXy8vY+cz9/9oF+H7XS6Uvv310Ns08b3O/3FEXBs2fPWK1WbLdblsslg8GgiYCpqorVatX0JztuT09PUdVmhab1es3JyQkvXrzAe9/Ev+ckohyhk1du8t439ETfmL4K4LXH1bZ8uhEphwRo3z1rr1/aR/O0z5EpmLdv31IUReNcbvejqqomJHQ4HDZhpl3arXvv+gTPV2hf87NteqOqvfAWkphjsx0aLQPTSng7W8wBmv18ApKYeGKvikpNVLVVl1KhFREBtfA8zanqYOCWNH5FEiDm6ocplT4V61J1KdXJMmDr/ZaBL3n87NepFtestxs2ixuKssB5IW431Ps929UNtQpCQYigRcH07AkTdWzWSzRGNqst87Nz3nz+Gc6XDGdzNtVbXKGIOOpKKSclYVexr3YUxQDnFCc1Tm2VqVRKC8TwQjABWKNWF0YtvDEkq4VowjGIxa6bE1qsjIH6VE7AYs1FQILFrlvddwuLxCXhGhWbYkeMxuNbqGYOtnQpesZ8KB5lX0eWq4pXb68oigFhv2K5vUtrvlqkUVXtqKNSlEOGwwka9lRS451P67J6W+6Q1vtDTIuyfMO1ZVRVReQv/Aap6m8BvwUwGo3MSGqBdPuzj3ZonedL8dt9n+3WJxj69m1TGG2gy7VicgneTM045/jZz37Ger1uQiIzT15VFS9evGiqPa7X6+bcGcxCCLx+/ZqjoyNevnzZ1K7J3H0IgdVqxW63I4TA5eUlItJotH28eLvffWDYpa0OzVWfAOyev3vuQ38DzXiurq6aucg0VNsS6evffD4/mLtwSKD9Mu3reLbHo2HqkEVEeLG4DSc5fDE06exWPzzVksE3y95p1tRyzIdY8kwUgxWfHIGSOCALiszUnQF3MhqS5QD5dkW1cEBSAbHdeoeGmioa6VMOpxw9+T7FU3j9sz+kWl+zHQ8ZlkP8YMBwOKaqdtx+/inVbkW9W7BdLRAiQT3r3c604X3NzYuXzI6Oef3yc1abHYNxybAcQKgJNWyXa7a7HXtdUVxeMiwdrvQ4n3lsSU5Sjxd73iUBMCKpHoxYrDzmLHXqksPV/BeCoF6REFMSkkXSWBSLkBfgtjIOafq0SPck5ALsjfA1QZ2oUFWimFW/D8qb6zXL9d7KJ+8T3RIV8YLHo0kgqWhTAfNodkSRHOdmTdh6q14tIc2TC83l5UQOt18W3F9mk1REngKv0vafA89b+32ctv1Sre/l7NIzX/UcbXA7pPG9TxuEd6BUFEUTJZMX3hgOh5yenvKLX/yCqqqaxTfW63VTmuD169dNkpNzjhAC2+2WN2/eMJvNmsU6BoMBd3d3VFVFCKEJocxgmssE58qT7Trrhyye/NkVaHn/bl2Wbmv/3j1X3/6HLIRMw1xdXTXja4+te44M5Hm/0Wj0pTr2fdf9JcH9a362jTbIAKApJYWoqSSsNJy8qFCI8a25/G52pHkMyKLLfsKcr6mQkqMkaZDJ7wgxrUYk8m5hZ9SWipMsEPJ5CmKAUEd8MWK3qyFYzXbqNTIcMT99xM9f/JR9vceLUA4KdqtbqAO75RVv3ryGsqSOe5zzaFjB+gUvX99yNB8yHhgwjnzJYr9mUdVQeYoyEuotdfRE8Tg3sOUnh1M0QqWkyCFBnU9QnMwdiVbgSzwxQkr3MV7agTmkodbYrAKVq0S6JrrFEzQmZ3W6R2oJYZrCEmMTw2L3pKFFSEsiouzF+rnfKq+u79hVgRgqQrXBxaqRsy4qtsSiEp1ZAPZs7xmOZ4iXpuZNTJI4JCYJ59LC5alKzTdAy/yvwH8K/Dfp839pbf8HIvJPgH8HuP0qnCQcfiH7KIUuQLVrrbRB7H0LPB9ywLaP7QJUXddUVcXx8TGDwYDJZNLQI+PxGBHhz/7szxohMBwOm5j2EEJT6fHVq1dNuYHxeMzFxQWvXr1quPVcoiBbCW3wy+GWqhapk/ubhU57qbo+AG47ZNs00yHAbPs8DllPfYKxS5flf6vViqurqyYKph19lD8Hg0FTGTMLz5ws1qaiDgmrPJ5fAuC//mcbSxYi03JCyrHMVR4lUeYWQx0bz5wl5DhnL3sUZ048pylePq/YWaEpucboH00FwGiqJ5oamGKuPU1stUuA5JEERGuOj48YushgdkQYjAjDKePJjJHz1H/6eyyjImHNcDBic/cWNxwSQ2Akge3dNYvPf8J6tUSJDCczLi+PuX7xitnZJcvFAjco8AVG6wTw9cDK/DooHGy2G3ZxRzWZEAc1w8JBVSFlkdZZTZw2gPhkweREpYBPmbkas/jL85WAW3IoqQF4rUkaprhzTaWWJQZzwiY5IUREcxiie7eYh0tBF9GxXO14fX1HVSshRAg7K6MggPcUHgZFSawDzhX4umAfAttY4wclZeEpU7mBqIo4SdEyMcXi2zPkyRnOh9tXCYX8HzEH04WIfAb81+nB/59F5L8APgX+Xtr9t7FQsT/FwsX+86/y8MOXteT30Sl92w9pq30Coe/3vmO718ha9Hw+ZzQacX19zatXr3j27Bl1XTcUyXq9bqJfRISrq6um7G8uXTAej7m9vW3ALkfWlGXJkydPuL29RdVi6jMVkz/zAh45AqdNxbQpjfvmsS0A+sC4O09dh233nIcAN1sFmV/PRdays7QN7Pm47DjOlFT2WYzH4yZEtusLaR/7VWiZb+vZjgm4JVv04hJApLoyQioYlimUVAoATTXgjQWXFNXiNVE7arpkYpITrRBtS1phSVTMuSjYdrFQQWPIE/g5gEgdI+NixNF0xnzoeHXzltPXn3Nx8wq/W+PKEjfwbJcVk2kBYYNzFes3LwkBdpuKoDAeDphMLri7vmG3WHGzv2Y8dKx3K2Q04PH8GevrK9YhsAs1fufZh8Byu6eOkeF4jvqSN3drxkPPPAqFqFWMxOO8p06arxDM6ZmfhRQmGaNl3Eby6kZqvHmuwUPirhVElCIJCUkWkoojJpBv4uVFqNVCNCMBH1OR5hjY14HVYsfdek9dC/v1Aq8VziXFRTwNRx4iI1/ixmMIVuveh4LxaIq4giAFuLT4twIhsxUurepFU6LgPo/qV4mW+fsHfvr3evZV4L983znf19ovbf67+/t9x7aBLvXrC+dtb+ueswtw+ZjML9d1zePHj3ny5Am73Y4/+IM/4MWLF4gI3/ve9/jkk0/Y7/e8fPmS4+PjBtiyll+WJYvFgul0ytu3b7m4uODt27fNsno5nv3i4oLXr1+z3W6bOPfJZEIIgaqqmiSq3KdsNTjnGvDrS9Pv8uTtMXYtmy5A9i3s0VfXp93y+Kuq4urqqrFW8lhzn3N/83XzPOTzZYskh5j2jaV9/T5rotu+nWfbtO4gUIhxw16MrkUtyzAmQDFwMk0fSLmZkiInQorrTotEp/VWoxpUq5NkDViRstCqWW6ZjiYcYtLwReuUFGVcdYzKrq45f/qcyyePCNsb/vgP/pBXL15TUPOr3/sRj3/1r6PbDXcv/hROTnBxR60ON5gxmBb4csNqcct4OuPu7S84vzxj8fot9XZL3HsGDrwvOb244PbsjOXulZWwdQOOJxX7Jexrc6iKE8K+Yl+ZRawKhTO+XFFEvJVNjo5CkoBL1Jao4Fww4BNvdEy0SpvvIk8kUTap1g7a+EEEl/wgZgu4KLbikuZEIrMaoljp3X1V8+b6jsVqC3jqakPhlAJn1SwxCyomwS2F4AuPxkDAURQDvFYMBwWjwtsyiOoJarVkLIkpWSppUfAcWcU9LqEPJkO1rYHBF0GiD5AzTdDl0rv7vI9H7wJb97c2x98G908++YR//s//Ofv9ns8++4x/+k//KavVivl8ztHREVdXVw03HGNswhtzXZiyLLm5uQHgk08+4eLigp/+9KeUZdlotr/xG7/RhD/m5fzy+qrZuToajZpIm9ls1vTzEKi9T2Ae+v2+8/RRI7kf8C4DN2frZmumLZzyOTPtkle3ymWQt9stt7e3jfBq0zx9z8D7gP3bbMbdWuIR7XrfJMpUoE41SixqBlyrSJiNxduiHBqwFHhPIODUJ2pHU1SOWQaSLAWD9KSqkhfxM2ojquBTSn0VI1LVnD/5iOPv/Yh/+c/+N0IVWf/sz/i/f+d/Z7tYUx4/ZXz8CP/2Bjd6xMBVuFixXd5SDodsqhpXDBkOPf56jOK5/LVfY76+5LNPP2U4GLNdLtBQ8/1/869xu1xRa2C3rzmaHUGxZftySww1i9WC8XBK1C3L9Y7j+QgR0Ohs4Yo0nsx724+hKRgmttZecpRi9E3ixr3GVEsm5wNISmxyqZyy7We+kTSHaiRYM4sW4M5uX/H2dsHdsiKEiFYbJK2tWkelChV5xSc/8AycYzQYUgwGjIZj1JVsdxuquzvEg/MQkhM1Cjj1OMznojiiC2gKudRvyKH6jbU+zRu+6EiF/jID7ePz9z7+tcsxd52N7fN1jyuKgsViwb/6V/+Km5sbjo6OGI1GvHr1ij/5kz/hRz/6EcPhkJOTEx4/fsxoNOL29rapw57BeLVa8f3vf5/FYsHjx4/ZbDaNg/T169eICM+fP+ezzz7jJz/5Cc+fP6coCk5PT1kul6zXa0SkCcXMGZy73a7Rbt9X2Ks9X4eEaZ9w7NPO+/5W1QaUs2WSHcnt+c6aePadDAaDBtin0ylgAmIwGDSZu11BfMjH8Es6Vb/+pkCiXpykqn+YxigxpdBnuibXIhBboEGSc9WpAYvFyYfWsnqeSvI6TpoyVaW5sCIQnZ0nVYfMgBgQCEqIDu9LFssFN//y/2J79Tnz+RHD8og3L17z4z/6Q371r/1thqMJx8dnnD3+mPF4wPL2FfV6wR5hMJ5Qhh3r9YZn/8ZvsLpdcvHkKfv1gv1qTTGZcPPqBbjI409+jSc/+5Qff/oznj+3OPmTkx2LxYblZmO2yX6DGwyJQQkyZL/ZMC4LZOCIsUo+g1yXJ5fWTe6FRFM5NecjokhMGbwprLJG0xqpVnIgKI3llDX0IJkpC2mxDo9KIKhjs9tzfbthuw3U9Q7qnZXuRRGt0nNu69OGGHASKcsh5aCkHI0ZTk9RhWpfMyxGsN8D42RVYFo+MQlsQVOIqqY6RKle6MFH7oMB9y7A9mnjh7SxQ9xxn6M1n/O+8x26hvee0WjEmzdvmtow5+fnzOdzXr161SyJd3JywmAwYDqd8ujRI05PTzk9PeX29pa3b982lSRDCI2mPxqNmEwm3N7ecnl5yaeffopzjh/96Ed8+umnfPzxx8QYOT4+5vb2tgmVzE5UEeHm5obJZNJQGt2xdnn4++q0t+eiz6o5BKZ5WxZgb968QVUbX0PXQmj3te2zyGvRZp4+C7M8vr4+5n+HSlB8F00hLYNn/bCIjFzz0SgBA/3E7IoVCbBCVK6J04jpVXZiwBzU4Z02iS1Oc0SNw9bzzLSDXQ+MRpBkKjR1azAw9L5AxjOuXr9kv7xmNCx4cnbC/GjMq5fXbNdb9ts9k5MTBmXBYH7K7MlzxufPGJ8/YXlzw92bzxlfTNj//GeEEJjNp0yPThmOJ3x/NmJ5fcf5o2f84id/AN7xg7/2t/jJTz/j2ScfocEx+eEld7d3fP7qDddbCLHCe6UgsLp+hYxLSlHGfkSlRbNItqoV/lIPmqwi1YDgEyVtjmYvNpeaHbDeESMMku/CsldTQIUAgXSMQ6MnuMTTh8hitefVm7dGgW03ELd4Ii7XoxGHo2BQmH+joqL0joHAZDTgaDxkX6242dQsNhuCCMPpCO89LgbUYYuH4FJIZk3OcFOJqahafsL62wcF7m1++7592iDeId6w0QAAIABJREFU1uj7NPb2cfm3Q5zyIWpC9d0iGzmkMYfkPX36tKkAmRfTyPu9fPmyqQQJ8OjRI0ajETc3N3zve9/jxz/+MUdHR8QYOTs7o6oqVJXj42PA4r6fPXvG5eUlT58+ZTKZMBwO+Rt/42/wu7/7u03p4LIsmUwmzfHZobrZbBqaI4/nULhhF6Tb4+/u157X7u+5lENeRjAvL9i2oHJSVnupwOyXyOeczWZfKJ+c72lfrZy+vvTF338XzQx8Gk3MlDKjVhrKtLWQhKoQkkImCgMxzt0W5wAra+uTNu9s5SKHlasVQfNCzen6Cc6sKo0YreOw2GzjqCOhNp9GFbYsVwuo9kzKMccffw9dXfH4/JRi4Nnvt/jCEeKGxed/hOw3DIYFgxi5eHzBcFSyvHnF8x98nxd/9keML58RteLo/IJYjZAIk5NLIkq9XfL040c8PzvmydNPGE4mDEbH/Ft/6zX6//5LRmtlubilGJaMx2N2YU2NQ7zx6fv1Gj8YooXHpXowdSSl7kfzTUhyVCeNXXKFGvVNjLsi1Cm8sNGDkz8kBdTYWq0CRCVEuFnueXu9YLNZ4zUk2kQonKSVnYSBS5aRmD+jGAzQaKGnk+kJ5WhGIcJmf8cmJZEVTogak2/Ao0ChFrqaF1qpsVQsWxzkfqv0gwH37kvYpWHyPocomz5N7ZCj75D2eehYoOGFMxWSaYI///M/5+nTp1xeXjZRLECTVTmZTDg+Pm7WUs1O1kePHjGbzVgsFk1C1OnpKZPJBKBZAOTy8pK/+Tf/JtPplCdPnlAUBfP5nI8++ojNZsP/T927vFqy7Pl9n4jI58qV67HfVefUedx3ywL3tYza0IMWSLSxEWjQoJklGYMmHtjggYX/Ao0MGhkajLFADbaxjT3wxLjRQAZ3S/e2ULf7Wrrnfeqxa7/WM9+ZER5ERtSq3bvqnEa+95az2LXXXitXrkdG/uIX39/39/2uVivvrepWBHEc+yKm+9yOTgh/lgL6thXR/e/9Idjj8O9DRoyTLobXxdYOO1gPH3crLVdIzfMcIYSHdpIkeU3H/qH3/abz+avabNDuR2EpNZpkMOK7Nst0fAzMYBkswmnROG9Qm5mLsbtUjhmohVesjK8YxaksdU6Bx+Yt5COFHpkWYtRpMeNsYn16Mbbzs20bhqYiCQKeffKnvPfonMXFGaIdmMQpygyIpkUmHck0Jl+cUJUlTbVmNl8gTcPi0XtMZjPKzQY99OihZ748ZTKZMpiIanNLU3Qszx7xox//Olk25ejxEwIVcTWd8OGjJcvGsLkzrMqesK/Ishl935MHCoYG3fZoI61xdyDphrGCoYStbWiLkFs2kmXMCDHyg8SoCyO0nRmNnSGNsQLKQjiX2sHWJkYoq+sMq6qlKBq6piIYpQy01ihjCKWtYZhx0hDCztCD6TCD5eIHKqMHkvkUIyKSqsfs1sTplDBQr3HrhcCu0MaVhivQBOP5tp3Ib97emeB+uL2pqPrnybQfghHuH//w8YeOdfiajt3hMHNnizefz5lOp0ynU+q65vz83MvUJklCWZZEUUSSJL7xyNEY67rmyZMn7HY75vM5SinSNKUoCh49esTTp09RSvHjH/+Yq6srj08vl0sf3M/Pz/n5z3/umThOcbJpGvq+93RKIWwn6324xt1+SJPmTaucN+HYbdtyd3eHMYaqqui67jWc/L7KpxCv+gZcRh/HMUdHR1xcXDCdTtlsNh52clj8myZzB8k8tAr5VW7GqBErBcxYrtM2e3bWbTZrH519xOjraQyMrAhr+uyKh7bYp4ygl6+0wO1DNu9z2Lur2moGrK+qQStGah42+HQNgVSEkync2KRgvy84+c5HzLKMNFvSi5rjiw/QekPdbAm6hKZck8SKSZoQq5yq2pFOUkIBm6rh/MPvUG9uSZcXBIFk6EqqouLkvfd5+VUFQcD3/vJvsn75wmauoWRxtKD64AlH+z3V+Tmf/stPiaZzwihENyX5ckLdxfSdYLVdoyYJuosQUYQKxShBIBmkDcgBllFkg7pjoozKjsJ9c/Z/ZUYfU0c8HbF8g6LsBm5XW3ojqcqCtm+IQkXbdQgMSqpRHmFkQ0lB1w+0fU8oBYFQREnG7PiM08fvMZnO2K82hIE912GkCENhC7VjcJdCgzTokXIJg52ghbUgHJta37i9M8H9oczwcHtbZnl4+z6e/NBj3/Tb3T58Ty7AuK5Rp8XuKIhOE6aqKq8Nc3p66pksjx49Yr1ee/YHWOjh2bNnfP/73/fOTHVdE8cxk8mE1WpF27YcHR3545Rl6eUJzs7OPCS0XC69jIF7z65N32XTLmt2AT4IAh9wXVOUC/T3A/xDkIz729EzN5uN14ZxLlRu9XA/sEdR5JuxHE9/MplwcnLihdgcXfTQ0eow6z883v1xdHjef9UB3hZRbZZuO0JHNstIu7NsudEsG0tzczQ+DKOuiBXzMsLQGWM9OzAWwsGeJzW20oux8xRXnLXsbkBahyIBAxolrNlFoBIEhv1mQ9cOpGGEECCnRwxyymR5wa74lL6+ZfX854ggYH72GDG01MWW48fn7FZ7pmlsDSSEIZ9m3H39BU9++BfZbndM8nM6DHGkydJH7G6v6Jue5dEp9IJ6v6ffr5nO5qgXl6SPPyIuN5yfTlgsl9TNBp1P7CpEB5AnSDllGHo2xZ5Q5AgRoIIILTSRClEqBDRdbd2crF4+4znQmFEHXyIwuh8Lz1aPxjlj9FpS9z3rdUHTDNRNQdfuQWt0YztZA4VdHRiFEJIwDKw8gq6YJBFozWSSMz+9YDY/JogXJNmMzfUNTVczIInEgJKBxevd5KJHq5Kxp63XwvuqWsl+/VZg5ttI/v5StsNM+aEs/T7z4fDvN2Wabzr+Q/c/BDEcBhIHaVRV5Y2vpZRcXl56jfW6rvnyyy9Zr9e8ePGCuq45Pj7m7OzMLinznO12a/HNruPs7Mxjz66Byd12Ad4FwTAMmc1mCCFI05SzszN2u533cX306BFJkvjnZVlGmqZMp1OSJPFSwa4hyhV0nSnIoZTvfYmBw9+HBVPAH3O9Xnu4qq5rv4+TZ3A/wGvvQSlFFEUcHR3xwQcf8P7773N0dETTNFxeXqK15u7uzhdZH8rMD3/uv2fH0PlVblLgnZJsaHft4xamsY2UPv9+JeWL5V7bQqktwo7cl5G6N/jOVssBEa9eUIBQBpAMyDGoDSPOb0Y9edve3piKXkJVFTR1iVAKJeH6xdfIOKauC7p2xfMv/m926yuun31N3bTkpxcsLx6je8jzlHp9gwoFfVexOH9iURKliJOIut4jVESUTIjimGySEYURUtqsdT6fYoQimsw4vnhMtbklia189ul75yRxRBqHZOmULJuQJ5KjScI0CpkGBtU36K6lbRqG3kJBbdswDAITBGg1eo9KYdUlsd+5xlgRrrEAIkzPoF9h5U1vWK1KmtbQdQ1NvbfSEdoWbUMliKSwHH4Npm1p2oZ26JBKouKA+ck5px/9gNMPv8vs9BjT7Fg//5JBw+pug1ARaZxgBtuHII0a6wHj+zPamnYAjDISxmi6rn/r2H5nMnd4uED3UDD+pud/G6z1foPPfSbJ4WTgOkPbtvUYuTFWgna32wFQliWbzYb9fs/NzQ1pmvL8+XO++93v+mKhC8q3t7eeL//hhx96/H6/35NlmQ+MzkfVQRIusDnao5s0Tk9PWSwWPH361DdL7fd78jz3ejduUnCF4UP1xcOs/ZDFchgwD7Hxw8Ddti3b7dZDUUVRvDZJuO/WqWS6v6uq8nz3QyzdTaru2E4WOUmSb3VeDydqN+n8KoP7OJrGDPuVe5Bw+rsu88ZCBZb5YsZ7RlEqY4O6kc5ST4EJHKdmzOgVemxskkIyGIM01ttTOgu9UWtFIseGHehNT900VK1ht9vR6R7DQCQDiu0KA1RFwWa9p9qvWV0/J08i1l/9K97/3l/EDD0yikgnMcd9w+r2kn7QLB895tHHP6BrSqIwpNzvUVmOMS1aG7I8w5gBJTRhGNjJTRt6ahQDp+dnDF3H0ekj8sUp1199ikwEURYyrCuyfEaSbFmIjJAONc2otUAEEwuZtlZOt9EdxmgCE3iYRUqwQjQKoUEp27k6GBiwkse9lnRdy2azp+0ldV1QlptRD18QjcVaJQVBGBJIgYxAypCyatGddV9KghgZxAiVIAcIA+j6mrrvKZqBzkCUGlB61Jkfe2xHnF+MYml4WE+CNui2Y7VeMQz9G8feOxXcv00x7DCjfpt2zOExHsra77NsHsrgD4Od1pqrqyu6rrN0pYNO0BcvXtB1ncfYq6ri13/9173ujNN/ubu7Yzqd8vXXX5OmKS9evGA+n3t9cq01VVX5RiWX1btM35lXOOjGsXLuSxKcnZ0RhiFFUbBarfxxHLyUJAmz2cwLmTkdnCRJ/Oc7hGichaD7Hpx6Y9M0nsPvCs2HsAvwmmOSKxw7rfo4jn2twTV8RVHkVSLbtuX29hYhLAXy/vl726qiqiq2262XOPhVbeM7xAl0CSHGsO0et/jqgI31SlrIQEoB2iLnlq4ofGZufIAS2CKhHo9pu1cxEIyeq3q03EOMxzEW4rFMeWybvTZcXj2j6zSBBCMlQWD7XW9efMHQVMwjRVmU9PuKJ//WXybOckQQkuYLMIbVzYp8OqP/8meEk5zVs6/I5scU65fkiwVmMNTVDhUYurqyr2MkgQrRXUXd1iTZhLrVhGmI6COCqLcuT0YTpyk6SJmdf4QI19S7FZvVFVK0NjNHM1EBIonJFwvi/Y6bq1uM1tZcaqIZWo1WVj440CCNVb+UImLAYttV22KMpK0b7rZ7yrpECoFuazsxCJi4GlAgUFi4rB80jTYkkWISR4RJSrY4gSAiixMCWsLYakUJhO30vblDCME0nSBNMAJzY5esdrUTZc+uAIydeMqyZLsraMqtH2EPbe9McH8IF30IJjnc7rfDvwl/fSjQP/R69/c5PL7zQT18rTRNCYKA1Wrlg0+SJPzGb/wGUWQpXA7OcYG4rmvee+89pJTc3Nx4MTEnIeBclw5ZI4cTSRRFHr5x2L8x1mTbQTXOychxzTebDWmaenu+siy9VrxbvTjcu2kaT1V0k+d9NUjH53eNSW4ycJIIrsPUrTgOC9KOxy6E8HLG77//PmEY0jQN+/3eY/Rt29I0jX8vbxo3h8G96zp2ux2bzca/n1815m7Q1tTByf2+dkFaPNg5JBnj2B6OyWwzcTOyZBhls8xIdhHCIfj2tpAWahFCWRbIyKB3fTFSjfx6bUb64EDfd7RtjzFjU5OGZJIgQ8Xm7ppskjKoiChN+Pg3/wpRlBKnObprGDDEgaIeCuoajj74AUoJ1ldXmOmII3ct8SRjt72lb3qU1BBElnkjFUoFQIiKp1BXBCKiMw0ymaK5pml68kdP2O9KVs8/5+byBj1oyqLhZrsnnWRE5ZYsS2n2BcEsh6Yj6GuUkUSRgq6lKRu6MLK4tbRQlTYaKQOcNk9RdFRNR11XNF1HoGKM1jR9Z/1pA4lMIiIgVQptNH1vJ+MklETS1lCSOCCJFCdPvocKJwzNjnq7A3pCISg7QdHaTlYlbcE9MNbGD6ffaawJiDEGJQxDN7Dd7VhtNgx9h2R469h+Z4I7/Fnmw/0C50P7Hgb9+7/d7bexae7vf7ifCwxd13kc+XCfKIq8ZZ4L/FVV8fjxY6/oKIRgtVpxcnJCkiTc3t4ym80Iw5DpdOqVIJ0sgVN/dMbYh5n6er320Mp8PkdrzXq9pu97bm9vieOYzWbjC791XZOmqW/8UUp5FUaXQTsY6PHjx55Z47j8bnI7rAc0TUNZln4/F1ydJIJTp6yqijzPmUwmTCYTD8M4fZgsy5jNZqRp6umhzpHKQV83Nzd0XcdsNnsNjnLf/2Hx3K1siqJgt9t5yOd+reZXsRkEQsqx0OlY6ON7GwM0PjMfXYdcqzw2QIvRy1MJB9hoe9uo0T5PjFm7GI898qCFctZOSKHH+ywFUBtN0/WUdTt+RxYSCBEkKmaxXJBPE/qmw2hoyz0n7z8hDCLaco+SHfu7K8KzM9Jkwurmisn8iCCQJPmU1csvmR2d0vYVSajQXYvRLdFkggoD4umUti6J4gnF3R0iyTGDIV2e0d1ds1td0Q2G/e1LkjikXl3Rq4DtZkdb70nTlHQ6IdIQxQHdMDaw9S2TKGTIIrQxPH78iO16jzBrukGzLvY0gCEgTCd0dYWUEWXXUpUVPYph6HzDUN2UdP2AUoa+N4iqIc1Sa5GXxvRFQTt0tMYQJDGTyYx8fkyc5uSLEzAtxb4kDgXFbk/TGW5urmm7ntkiQ5uBTmvr12osEyYwFp7rTM/QDZRNy7bcs9vv0N0rmuvbhvY7E9zvM1a+iTVzP2N/KEC77PuwWHj4+EPwzf3n933vi6WHj7lCZpZlLBYLTk5OPIXRMVWWy6XPkh1W7QJllmVeox1sgDpkmbhiqoNd0jT1xyvL0jNdyrJ8DVt21EFHRXQ+r27lkaYp+/2epmlYLpdepsB1gJ6cnDCZTLi+vvbsHnc+nKXfbDajLEsPzzhjb1dbcPi405FpmoYgCJjNZkynUx/EJ5MJFxcXvlB6dnbGy5cvaZrGv3+wPQZlWfqirAvWjkbpVhFt277m0nQ4GfzqNjMKeg1I6ew5rNWC6zY14z9l5Qhts4pwKjBubJvxSBaDFVJaDXI5eAbFYT3VGI3EapuPSenImbE20FoIdN9SNvY8ugYeKRRBMmE6T8knEfnyiOOTU/rtmtPH72OQJPmS+dEJZVEQ5TmDtquHKJF0VUGeHROHCdu+t7o3fU9XbRnareWdy4mtIQ0NbV0STBKyk2PKYk1Z7lBhhFQhZblnaGr2qxUbPbBbrZBhTFNW1INk17VEcYAeevZFQZrmFPsdYdtxvFgQywBtOqqyQEnN6UlGks24ubribl0SRRMGEWKAurf+q9n8iLLYU4sELRuGrhkpqJpIKiZJjDSSbjAMfUvdgoxj8skR02lKXZSocEI6SVk++pAojREasvNzbi+/Yqh27BpN0/eWhto3VGVLIAOCQGJ0Rw+UXU/Td1RtTVXXdG3D0A+IsQmtM758/sbtnQruhxn2t70o708Gh3/fP+6bjn0/+z/E2V2h8D4k4xqUTk9POTs74+zszAd4B7WEYUie555d47BxVyx0vO26rpnNZjRNg5SS/X7PbDbzNEJHY3Qa53me+8KlmxSGYfBc+LquaZqG6+trz0axynqv+Odt2/rAHQQBl5eXTKdTnyWfnZ3x+PFjXzB2mfVut/OsGDdhgA20jkHUNA1hGHqYxK1E3OPOHNzJ+aZp6lcerh/AZfnOovCQBumCuju2mzjfRRrkWCr17BiBzaARr3B3B78MCM+mEYyQoBCjA88I3Rhj9d4dH3qUfLVakOIV5dKy6RmbGzEj/1qP72Ewmmboaaqepu5x0d0Ag9HEyYzF+Xscn59zfnbO4uScfn8LXYMKAkSYks4j2qpAzhe2Bb8fGLSkbRtUHBIGiq5sSOcn9PUGqQT1boeez+n6AW16qmKLkBHEMXqzJsuPqfdrjIjQg6attwyD4OblNVoqhqaibFue3+4gDIjCkFlsjbNFWdB2Hc26I41jBAOhUlw/f0E2nbKYZwjdc352zKP3LthtK4RWtFKyL1vkPmTfCbbtCt1V9F2LwND3LQECJRR10xKGAVIrqm6gNTVZmqJlgJEpkzxEBTFhFGNMS5qcsL+9IYlC0jhGyZhmKOiNoe8ain2FlMLTILtB04/Xp9EaozsGa8k0Vl8EvbAk2sC4sfPw9s4E9/sX5kOQzNuy70MNmYee/7ZVwOFr3i/QOojhUIfFBabJZOKFwb73ve8RRRHn5+fs93uPr7sservdvtaEs91uPUvEZedOAdIVBJ10wDAM3N7eAviC6zAMlt0wZucO9tjv90wmE59V7/d7FouF/34ODadXq5WnWAZBQF3XzOdz9vs9jx8/9hOYw+ddRt51ndeMcfDUISMliiIvG+AwedfM1DQN0+mUk5MTDysVRUGWZd57NggCvyJxLCV45YJ1H2d/aBz96oP6q21A+6YhlyFj8BIA0hicR6ge2RjigEkTCIHCGvD1o+aIwuLwRtru1ZDAl1Xt84WX+tYudcd4ho7QmqE3FFWNMdb9SQpDqEKSICKZppbCeHdL9r1fI44jzh79BardLcPQY+oCFUQ05Z5ifUsUCVQUApL9dkWUxKhQ0g81fbOh2t2MVL+eurIrTxlGDINhe/MCaaCp9ggV0Oue/W5D32nqRlGXFX2v2e32pNOEtumQZqDcViTzGUGaYFTErrL1KoFhdbcmihSLWUIYQFM39Msjmn3J6ZP3MH1PlrVkk5yqVcTJgJAbki5kddtbSWR6sjBg1wtaKdBCkwQhSRzStpquAxWEiHCC7jr6pibMI5YnxxgD9e1zbnYvyaYz6l1BGIWoKKDc17TtQNXUyG4cC2Y/Jn7j+fGTvMB5QY2CFa8YNd8w7t6Z4O62N8Exh9tDxVP3XPf4Q9gsvNlt6BC6cb9dc85hE40rEn744YecnJwQBAFHR0f0fc90OmUYBhaLBS9fvmS5XPrnbLdbJpPJa+qGjurnJgCHl/d9z+XlJcfHxwDUdc12u/UZqnN1cgVJV1B1mu/ORPqwgHmYDTsNHAdZuRXFMAx8+umnr9EWDyURtNa+PnB6euozaNdZq7Xm5OQEYwz7/d4HdSd1fFicfvnypV/ZuPe23+/9Z3USBg6auT8+3hbU36XALmDEzQfLYRaO9ji+/4MgbrCwiPU1tc00r+RebSnWeqOa8bIPENginBw58TgJXMnIiZYelrFikxIhoB8MbTdQt9Zs20r/SqIg4v0PP+bo5IIgiDk+nyH6LZP8mG4wTJfnbF58RX50hMpmSKEpt9eQTOn7iiBQDF3N0JQ0dYkKYurKsN2sQELfDdxefsns+DGmrqirgnJzgzYwGIOKIlrTE6QpYZgi9JquGUXjpilhHNHqEhEoZBRAqDBBjOk6Bg1RqGi6DmEgUYKq0YjOMAwVn33yOVGoQCZIAdOTGSqfEexbUi05n+cUvaE8miGamk4OCBWSxiGJHrg4zTHasCsKRGAlfOMoom9bRJwQCEXYS9YvriBW5PmcSApM21LsdjR1x3pTsCsLiqqk71pLi7VcV79CE+Ps79UtzagQZJwsxThJ8zauzDsU3N+WnR9uD1Ef3/T3m471pqz+IQqky9oP6Y9OL2Y+n7Pdbj1M41YQdV0znU4988Md02XcbrJwf7sA7wI+WJjj7u7OZ9QOonDYv8vwoyji5OTEZ7ku0ALens9h9lVVeREuR7Vsmoau68iyzBdMlVK8fPnSfy4HqbjJxPm9npyc+EJz0zRkWUae55Rl6YXVXOHUfSdSShaLBXmes16vybKM7XZLlmWEYcjz5899kdh9T/fP3X2lzzeNnXdlE8JpnDi9R4UxYtQMESNEY8P3K7sIvLGzHjF0W3cdc39h93WunkLYFxrtsukRCGmbYbRzeZKS0EgGDL2Asi4xekApgVSSSEjyNGUxP2K+yKnX12AmmKGxjViyo6taknxOvb+zQrlqlDAOoatK2sZmnyKI0UNHU9eoWtJ3LV3TYBAMXc/27pIwiKjrEmMG+ralqksGGSL6Dq0DZDolvXifaQtV8xIBRGmGFmua3lAPEtEp0l7TNCVd1yIJqCuryHOzrui6DXkWEgtF0/SIfMH15SVGa46NIErnKBUQpZowmVBfP+doolBHc/Z1QycEadiSZEumsylVUWK6hjBNyLMJs9mMom7JZjOUkOTLBfl0Qbm6ZJZFFJs1anqGiltuXjzjdrumGwa6tgUG2xA1FtMDIQikGTtp3biw40aNhujC2P2llVF7K+7+zgR3eJ3D/iYI5nC/+0XVbwr2h/c9dPzDwO7gB4ehSyl98fTDDz8kSRKKouDi4sJz0Z8+fcpisUAI4Z/ngrCDc9wkcQj3ODlcF4gPsWpX/HRZ8mq18kqTQRCw3W79sRwdcz6fv6bp7iaMMAy9/ozD0B2H3fHRsyzzAmebzYYXL6xN6GKx8KuEw0w9TVOOjo68GubJyQnPnj3j5OTEf695nrNYLHxB1k0qy+USpRQnJyfs93t2u52nWQZB4M3CD8/L4Ri4fw4fUrx8F7L40c/Hfg4DUgx4bowRI+dcgLGu90rIUfbX4uqDAWEMQuoRehkX7AIcd2ac5jCjTIF0zJkxa1dAoK2krRAwdB3lvmAYepSU5OmE8zzjOx98wFHUordXXDw6IpSaMAhYf/FzsuUxWhrqYsMwNCRoZGdZO4GSEIZWlKwfaMstg+no6hodxQx9S9cWSKEZ2gqtB+puS9VUmK6n72uKu2u6YSCMIggyivWexkiKpiTNJmilmC7mBM+uUUGPAqpGUy1ioqBnEkjatmYAdmWN0B1hYKGmQUomYUpRNETzGdv9hurFNT2So+WMOArQpiUUAXkSIWYDkzRgenxO31SoMCU/O+H62efI4yk9CikNaT4nXyY0Q4/WAkHI0OxYLJdEaiA6OaPYNZSbHUWpqWpDEEriwDaeCWmJrMaMzNXxthCgjAZjm5v6UYzM9r5ZSbP+G4b2OxXcH2LA3MdQ72dp99kz3+Y1HroN+MDlMtv9fu/hBPcznU49JJMkiX/eZrN5TV4gCAKPvTtYxGXijr++Wq28UJh7TVfoLIrCwyVlWfoM33HBkyTxln0uMOd5TtM0Hp+fTqfc3t569s0hHdFNOO79uRWFy4zdpOAomq5B61Au4Msvv+T09NQH55OTE3a7HT/60Y/Y7/e+4Ou6YrMsY71ee9imaRo++ugjXM+AMyuJosjTMg+L24fn7E0F9MPbf57C/C96k8Ly2REK41x/MMjRD9WiJ6PFG8IqF460RRv8zWuTgftUDpuXSLR0WfpYWDUjp94YG+QDQSigqns6FjXlAAAgAElEQVR2+z1d39msW1hp2cU05bsfnnJ8uiSOIyQDwjTst7ek+Ry9u0YFIUGQUm031uRZRQil6O+uUaFEBjEMhs3qjmgyoSp3iLKkrXd0bUWUpJaN0tRo3VOVO4be0Fd7qram3hZEaYKIO6rtBhNlICST2ZS66VldbwHFNF/Q3l4z0JOlU3oMQzNgBokZbHdoNwwEgaA2MJQdiAGjAjox0PYt+10J4YZoEtEUNbEEFUecnpwwfPYlZ2dzpufH1Ls987ML9tstyx/9iGq3xsiQflAMuseEU5bTnN1qhWZgW5SUbc37H/8aQg/Ms46y3pImESpKaLal5bEPGjNoBi/0JkYsfRSXGyfmV+rt3hYcgUAJ7af1h7Z3Lrgfbvft4t7EhnHbQ7Z7b8LcXeA5fM4hzc7d7zopkyThyZMnLBYLzzIRQvgMVmvN5eUlaZp6HrvWms1m4wOr0yhvmsZPBG51kCSJb+UHfIBzol8Oo3aB8vb21jNgHMTiVCpdl+rNzY1vdjqkRjqsu6oqT1N0BV945Vfqulx3u52fMBxvves6JpMJ3/ve93zDUdu2XFxc0Pc9P/jBDzzX3u17aHjtzq0rIrtVhXs9t1q5j6HfX2Hdf8z9fucKqwKUGYvBwqo0OkoiI9NFGTDCXurCCLRQSGMQQo0mH1blEOxFb4S28gTCdps6vRgEaOeRKhQBBikVPYZASxABgpAsjpmGEXkY88EHjzidx0ziHikKIglhOmHQBoaW9bMvCLMp2fyYPrTsn2p9RTjNacuSbrokSmL6qiRdHLPb3hL3e+p9SRxPaNuGYnOH2ICKJhTbWzsed3tuXlwi4wjTG2QQUBQ3JOmA1iFdtUMKTVWsCY8uiMOAU9Nxc31HqAa6TlBVJbrtGdqeSZQwC0L2dU3VCrIwYbOpSFVArwSB0HQaVBjTFiXFLmR9PSEyNckkIs4ioq4jm8Q8/sFfIAg1N3WDrivOLj6k62ue/Nq/yX69oq0rut6gJkfEScA6EnRagNZIMdBsVnRGoqKQKEqo9nu2xYa2rUe2kIXa9Aioa2EZTeMsjtYWdNPilcGfwHhtIPP/J1jmfifkmwpn8HoB1O17+Puh7aGVgTumo9q5AOqyXAcpLBYLjo6OOD8/99hznueEYchmswHw2Sfgg7UrdlZVhZTSF1FdYHVKig4OcasF50J0fX3t/VIdJ95BO067PU1TLi8vfTBO05Q4jj3n/FDAK4oizzV3wl1FUbw2WTpYxMFFVgJ2/9o5cJIB7rtzkgeuMUoI4eUXVqsVwzB4iCfLMs9B//zzz6nrmkePHqG1ZjabcXNz41cVh+PgTUXy++fYZfnvTGAf5XaNcGN7FP9Cj3Uxm20PY7FVOvx8VCy0M4NVGNdGjpS4gFELeCy1ajCvrPOkVF5hEBkilJV2MP2ArkroOpZZxvEi5WSWc7accvromDhWRFFMPD8iDCS7zR2gCKYz2qIGsyZKprRdizINTdtRlxWDimi7mqYqKeuKri4oN5d0dU2SL6mKDfVuS9fVpLMjhq5n9fKGfugp9i3ttraQkgqRQtK1e+RkRpRNWD17ThBFiN2OKEuJ4wkq2pNGGb2urHqiAhGlpFlMV6yROmLoYLvvMKZHJAo59FRlTaBCmrpD6Bbd7tmUE6QWTKUgpyGVBjVJQdRIGXB8cUQQ5gRxyiI/RgtBmqUEKuZutSbsK+6+XqMRpHmM6HuEjHn6yafsmp6j9z6i0wmzWUZ4d0slglETxkJkkrEbXLhx4Qi0YwZvxuqKsDIVgyuyfsOi9BuDuxDiCfAPgXNscfZ3jTH/QAhxBPx3wEfAF8DfNMashL3q/gHw7wMl8HeMMT/9ptd5E5b6TY1GLns7zMgPH3/bfYfBXgjxGn+6LEuvzjibzTg5OfFuSC44OcaJw8odZdDBHEVReOaJw5Pda7pA67o9XWHTabA72GK9XnsGSdd1nuOuteb09NTzzl3h1VEkXYHW4eN1XXtOvcPm3WRjjHlNV2Y6nVIUhS/kugzaSSIMw+BXJu64rp7guk4dTXMYBs8mOj09xRjj6Y/umH3f89Of/tTXLhyU4xQxD+sU90XAHlrNuX0P73to+2WMbRu7rYm1NV4QFn4ZMzWJDdB+Gc5ozGHfoQ37Qo4NSYwMisCKiJnB7yfGLN6M2Z/CqktKBAhD32u6oaVveuqyJokCJrFkMc05P5lz8fiCdBoyneSYrkFXFW2kMF1LW7Wo2Rl1W0IgGExHuSsJI4mUNcV2RVVvRpMQUBLiKKQptxg90LU1TT8wdJr9pqDctTRtxe5uQ1PVbLcl1WCYzGc025JhgOOzM4btDtF1EEXsm4522KF3FSLI6VqDUDF5MjBUK0yY0FY1fTrHyAQpOvp2T2s6pnFA03dIpZjlKUWxpa4H9NDR9YZGrFEiIAymiK4jCmeooaMta1Q4hyjFBAHxckmc5jTbK/p2oNUwPzmBriE6P8OYju36lmJfoOkQckD0e/6ff/p/0sQ5IpgzaInsWyaBBBUQKmknM6PpB+eiZcEW5dy6wEJ5CAKgH2x6oP8/4Ln3wH9mjPmpECIHfiKE+N+BvwP8H8aYvy+E+HvA3wP+c+DfA74//vwG8F+Nv7/VdniBPtSUAq8H9cN9Dx9/WyZ/GNQPX9cY4yEMKaX3Nj06OmI6ndp251FPxtEN3WrD0Red9otrQnJUPge3uKDpGoZcwHRMmO126xuE6rr2wd9J9LoiqMvQHbbvcH236pjP515awGH4hw0/DtsXQviCq6MkOp65+16CIGC9Xvts3QX4KIp84bfrOs+qcTo5rvDrsvemaVitVl7T3skEO9XKP/3TP/X8fjdRugn3bZP4/fPuvlP392F38b3tFz62LZdlDPKixxiJEGpEWccobqy1tRxbmHohrIKMEBipLKXRiJHTrhFCYYylTRqf3Qe2OCcsZmvZNE7mwL7G0HV0ZUsgBxbTjFksuVimzKcRSRqSxhlKhqgsZRgaeq0tRj0MrJ9/SRArmrYgy0/ou4a+k8CWYnOH2QiqoqKqG/I8YzLPQQXIIGToStqyoVzt6PqKpjdUtaYsKjCadhjotGBVGTCKptyT7gtEKGmvLe3QBBmNDmiKgnwRMZ0qhIlI4oyy2NGYFm0krdB0rSFMEkIMRTdQGpAqIOh7VBBRld1oamIF0rarWwgSkmRCqzqGoSMLI5adJDI9ND3xYkGIga4kSqe0w5okjkd+/Y66HtisrokTSYRhtyrpuoblYoEh5l/87Ofs2pIgConVlK7paIeWpunA6FGzfyyyj797T4C1NFUpIBAQBraoLqShrP41JH+NMS+AF+PtnRDiZ8B7wN8A/sq4238L/OPxAvgbwD80Ntr+X0KIhRDi0Xict24PFUffhLmP7+cb4ZjDTPn+6uDwNQ7ZNk5+NkkSLi4uePz4MZPJxHdWHnZMOhhnvV6zWq2Yz+ceY3dsFyml52y3bevlgV1Xpitguh+nLOmKnw7ecN6t7vHNZuPZOS4Q5nnucXiXNbvPNZvN2Gw2aK2ZTqe+DuACqJuoHIbvJh2XMQdBwPX1tdfFSdOUly9fMp1OvZLlycmJb2DK85w8z7m7u/MTY1VVXgXzo48+YrfbcXNzQ9M0LBYLdrud15a5fx7vw2r3x4L7fTgRuAL5Q9sva2zbJqVXzUWYAYQz8HD5tbO+sxojI38GK9ELNkjb3E1pGCSv8HphmfTSDGAERopXDU3SvgLjq4SBJhSKPFZcXCx5/P4Z0zQlyecEKqQq1gTSauGoaEKnDbvVDbubLdlyQZSn1NXOOhLtNkgJ+1LTdSVD3VCWFdvVjjS9JYkjdBAwDILOCqrTlQ27uqHpJQyGNEtJVES3r2j7mrosaMqKcLPmaGFtFtuupy7XpPNjahFBrZG9YH58DFqgpeRofsLdtsYMHdl0TlEVTKZT2lVHZ1Nd67/R1CAVKghpes2gbSYcBoKXN9ekwcBiktCkCenVc6bzJ6hA0DR7lvEFcZTZRrzsiHR+yvrmljidE6WGtt6yW10zOTrn9PiCZrPm9vqGXdeRHS1ZPd2x2+3pdT8W18exzej2N6LoxphRmoKxfjLq+RtbWHfesAEKhORN258LcxdCfAT8GPgD4PxgUF9il7ZgL46vD572dLzvtQtACPF3gb8Lr2Rh7z2O41k/5Jn5kA/oQ/e7wt19d6GHfrtGoCzLPHac57kX8XLwhWPSCCG8e5LL0FerFUopH9gdhu4YNcBrGb0LRI5tc1hwdBCPw++zLOPu7s5/tt1u9xq271YMbnK5uLjwmfRkMvHwjNvPdXu64q5biTgJAPedHCo5Nk3ju18dhPTy5UuSJGG5XPpGpOVyyXa75enTp+R5ztnZma81SCl9fWG5XBLHMZeXl7x48eLP6MMcjoe31VMe2s+txB6iSD7wvI/4BYztMFAwyg3oUVZAilH1T4OU5lUGLyzSqkayozG2TWlkqRMY27mqxyGuR/0YM6Z3oz4YjMcwDvYBmrYhkIJskpBFkmUaMstT4jRFJhGD6UnTOU1bUuxWCCRJHtCXNX2rMRK2t3fMgif0g6DebSj2G/q2A23YrnYgoOt62h60iEFDL2o264Jofk4QRQxaMuiArm6QQUiYTtF1Q5wHlHd3lpePYV0WJElM17X0RrFrIFokZCk0VcPZxftEwmC6liSbEEyOKapbqqEiOsrpb55S7Hqyec56u0dr2/0byAAVhGgNbVtiK8cxZoQou8ba5vX9wHy14voyYBKn5MuYcrehDipmR6eUm1uuv/o54fyM+cUH9FVFVxYIZayr1PaO9PiUYBdx9/w5X1/dUnU1g+6cHRQYi6ML6c6bPXfgnHVf9T74blWXlBpNq50v7sPbtw7uQogp8D8C/6kxZnsvazJCiD9X9coY87vA7wIkSWIO7n8QVz+8fRisv22R7SEq5eFt1/DjNMZd0HE8dkdLdEVNB5XUde0Fslw2f319zWw28404VVX5TNIVQJ1mi1MydJK3WmuyLPOGGq57NU1TT1V0gmOO+XKor+72zfOc4+Nj3zW63W59QTNNUx+k3ffgpIPd53QZvOPhH8Ich8Jk2+3WKzuenJxwd3fH8fEx6/Wapmm8S9UwDK81NLn7nz17xs3NzZ9p4nLf8dvO3+H5fSiLv7/fm7Zf5NhOk9gYoRAjnU2IsfNQ2wvbZuM2q7dwikAbS4oTB7RGhbJmDhgUA8qMBtuWNjEKPSqn6G7fhzBWVKzX0La24W0Zc7SckMQJp48uCEJJX+0wYciuby2Dx1hRMdns6IaerpNoGTPEkrurF4SLU/QgqdqBurTBqo0SwjhBiQC92VKrFNO3lPsSGaV0VYEZIJke0YcDbf0SGcRUZUMySVGbHYExECXEvaFsS0Q8wbQNCEnX7KnqPTJNyPOY5ckjBnrmJ4/Zbgvunn5FaHrMJGPXdrRtB9LCV3GS0ANdVdMPdsVUNwW97hE1iDBEqwgjesIgYlf1tG1PvtsyuQkwc0F+OmF9e83y5Iz15hpdVag4huKWum9IpksmiyOqZk+wnNCWO26++oyr2y1ECX3X0reDZTe5VZpbbTpXP+lgmVdjSRk5ykjokSYJRtp+iUNK7EPbtwruQogQO/j/kTHmfxrvfumWpEKIR8DVeP8z4MnB098f73vr9ibe8v2M/HB5fr9Y9hCGfj8wvAnGSZKENE1fUzR0wdG10TuYBF4xezabDbvdznPYnfCXY3w43RUHqxxmyA4rn81m/j25zk5HVyyKwuusuEKmw6SfPXvmJwSHtzvzjMePH/uCryt+5nnObDZjtVp5DN1BOi5b1lp7WMWtHNwxHFXSqUY6Tfo4jjk/P+fFixd88MEHHlZxHrKOPeMMs532zd3dHS9fvvSFZjdR3Yfb3jaJ34drDsfS4fh50/aLHtsGpwEycphHk2oYRvqbslm2a3ISo721sQYfDoc30iAYkEZhjKJzXanjMl0J67RkEAQC5PixpTEkScAsnjFNJBEDtC2T02OE1kgtkWGCHhq0tqweBruC3a+2bLcFt3c1IkwggH3RU998hVEBURSjdYpQEfvVNWZTU2srSqaKhlj2TBZHhINdrXV9g5wckUaa2WxKtd+yqxqabmDQGhVG1rEsm9I9+8I2QA0GlEIPhmK1oiljHj9+j7prGLTgKJyiuh35LGc+m3K93tFsNmiV0amSsiotPdF0DGYgSib0tdWvV4HADIY4sGJfMjJMJgE31zdIFXJzu7JF54uPuXv2ORcff0Sx3dDrnuXZY7SWJNMUQ4jp9qhIkkymVG3P3d0LLq9u2dY1vZSEoaRqtO85MKMwHMKxo9zizRbARxVonLyc61swMDpvjeJxb+G5f6OHqrBXyX8N/MwY818ePPS/An97vP23gf/l4P6/Jez27wCbPw/efoiZ3n/s/sX7TRf8Q8H8oYvdZaxgs9qLiwufuR8Wdl3gN8b4gOUgGqWUhxxcNl+WJZeXlx6qyLLM/4RhSFmW3N3d8fz589f0z6+vrz0OfnJywtHRkf8MTrXRQUhO+fHu7s43OJVlyXq95vb2lru7O66urrxMQJZlvljsCqBN03iqpcvMD+sUjjXkAvRms/EThmuuchz/oii4vr72GjTO4ckxWJx37Hq95rPPPuOLL77g6uqKp0+f+nPwbcaI+9tNSPBKksHt801wzC9jbNvr1sIxGDEusyX4hfZopTdirGYsriqk90dVxozBWroDWpzWCPvYQYeq3TRmtNEbjBWlQ0Caxpw8OmZ5PGcShShpYGyoCpIpEICWJNM5RkrqqrLwo/cmkNTVQK0DNpXhq5d33JQ1VVOQZFOifEqeJcSBoS7X3K5uuXz+lF3TEc+mTCcRm8uX0LbQNBydPOLsKLedmCIgW5yCMTRdy6BiO7aDkNXdNWXbsC23FFXBerNmdXPL/vqG7ctPadtrBiCeLlBSkc+XRJMUoSR9XVHut3S9LUQHgUKYjkAqhBakUUichCh6+q6i2GwIwgA9QDdIdrXg7sXnxFlIVWxZXz1ntjxBdy2ya4jjiEAO6KFhaBsWFx+wWVV8/tmnfP7lV1y+XPPs6VcWOnUiE2Njmng1QMYGJgHGQXfGrqCMhWV6Y+iwicJgoDeugelfjy3zm8B/APyxEOKfj/f9F8DfB/57IcR/BHwJ/M3xsf8NSxX7BEsX+w+/xWs82LDktocy9MMA/7Zl+Jsyv8PnO3bFbDbzrfvL5ZIkSbyPqcNuXXbuePY3Nzc+KLqWfRfgHdTQdR0fffQRVVVxfHxMURQsFguOj4+5urryQdlZ5RljpQGcQ5Gzn3N88SRJvNyAw7EBH0yllH6F4PBtJ7U7DANnZ2esVivfYLVerz0DZjabEUUR6/XaZ9POZNsVVoui8IHfrUjee+89jDF8/fXXPHr06DV7Qfce3YT5k5/8hE8++cTz7N1qw8FObzqX98//YZA/DOSHY+kbMvdf+Ng2gG2YDOxfxsoIYFwuP7JbRm/TcWHuWTbDqD+jjEQYiZF2cS7E+Hml8Ot4Kx6GP6aUCiUEiYRlnjBfTInjkHy5IElS8tkCPQyYrsIMLX0gEFEIMmGQEcP1HW0Pg1Bkiyn7zQ1SakxVE0UpRVtTtSUn3/kO/b7i+PiEYr9jcrRgeXLK6vI5fV1S7PY87zXZJMJoKGvJ+ZOPiQNJLHImgeJW7qiMIkoW9HXFNJ3TVhvKqkAITdc3VMYgZcB+c8fQN6RAXd2BnDLJpui+4ejiEZu7G/YyJE3nbOQdKgwZ+p75fEEUppTtDUiJCkOyLCVKMvpeI4aIcr8lUKGdZJWi2u8Q75/SY7j64lOO33ufUEkm0znGQF/tqauG9OQclQz88R/+Uz795FPazoCK2W4rirqhbZ23wCsY7pX4l/ATvBgL59rYgvm4OBs7WI0N9uPkrt8Kynw7tsw/4c3Tw199YH8D/MffdNzDzeG6h41J97tND/W832S59qZAfz/TP3ivrykXuuYkl6U6LP1QfdFRGYUQ3sLOZd1VVbHb7UjT1GfmLrvdbDY+63YqiWmacnp66iULDo1BiqLg8vKS73//+3z88ce+UckVKZ1omKsBuCLqIY1SCOFhFRcMDwO++9yO7ug47YeSBsYYL5QWxzHPnj3zk4nL8rMsA+DTTz/136M7tptkZrMZ2+2Wly9fIoTwWjPb7dZTMO+fN3f7ISXP+/TX++Pg/nEe2n4ZY9toTVfbVZZjQEg1GnWIESOXzrA6RCuQuh8vYFt0G2P/2OoEzmrPXuECqSy+7uAfM7JnIilJFOSRIIsUcaSI4wApDP1Q0fYJcZxBnILu0cUdbd0yyJqiqLhbVxQVZDNBV23Y7CviNEPFPc1+B7qnHTSb9Zp8vkBjSJKQoWsJ0gR1dkGzukVEAeUAu8pi3bvLOz65Kfju93/Adz7+Ae9FmvjF56y3A9dffkncb9GRwPRWEzOdTAmbhrZrGfqQvtR0dBiV0BnoRYMwLUZPGIKIoiyIQ0kfpbYoHYRoPdD3A9tdQxAkCGEYDKTpgunRnCgKefn1c9qyYuSZokJJOp0iTMDzf/kJYRxxkuQEYUYSh+w3W1rdk85zis2aq8tLkAOLxYShq1gVkkDB0NmGpXFEWFjOOqSjhG9VGiXf9Guguy2nu1t2P4Od0x1M86btnehQdRKwLqC736555fDHPe5+HG7s9nfaLY7t8bbNPccxUmazmZegdRmzy6Ld+3Q4ustGXdHUUQwdDp/nuadBtm3LV199xZMnT8iyzPO/HcyRZRkffPABH3zwAfP5nN1uxx/90R/x85//nJ/85Ce8ePGC3/7t3+aHP/whn332GXd3dx7/dzCLw90PaxWOT+8yd2eft16vyfOc+XwO4OsJQghfpHVqjdPplMVi4b8np4rpcPpDvH0ymfjv43DVIoRgvV77SaXve548ecLV1ZX/Dt1nODw3D52v+3UU91nv11bela3rB55d3SKlLYxKKUAqpFLjfRIlAwJhQIEQAaG0zU4yACEkQkgiKVBBYE2ZfZeTrYEw6rEbIa2CJBAZiKQhCCCNQ/LZhMlsSiwCosBCFhhJU+xAGHTbI6QkiCZ0TUFblJiuZ2j37NZWjtfIiO16z3Q6o9I7lNA0Q8PlF5+hnnyP/L3HiKEiDkfHp6Ygyo7Jv/dv893vfp98MafarPn5H/4Bn37yJ/z0n/2U5y9e8lf/3b/Oo3/jEepf/Snb26f0gyJsGoJJglCKQQsiqah0hzSWbNLWNXI2YV9WBNKw6mqCIkWs92TzI7L5jF4IgjDGDB2IgKppUcFAMrXBOJnNmBydI5VEKUGgArI0oWkbeqNJ4oST83Ounj9lkqX0vWZoemSoaLuerrfH3W3WGBFTl2voCt7/4Am3L68py562N4hAWr4lIw4uXA+qi+MWqHMGLIwWi66AihB2QhjHuYKxbmPemru/E8H9EPM+3N4GsRz+HAb9OI5ZLpfkef5GzP3wuW4Jb4zx2ieAhz8OJXSTJOHu7s6Lejmeu4NtHBfcMWCcDrrL/JfLpadTOsgDbHD9nd/5Hd5//31Pd/zxj3/MT3/6U37/93+fr7/+mt/7vd/jt37rt/jOd75D13X87Gc/85/LBbUkSfz36DBnh/+7LHsYBo6Pj73NnzPscLx4N6m5wqZrhHKTx+npqfdqbZqGuq759NNPvQXg2dkZVVXxJ3/yJ75A7aAsYwyPHj0ijmP+6I/+6DUc/34R9fB8PzQW3Gd86PbbxtAvezPG0Pqx7XksuOZy4TH0cVkuxrEsJEaCdH8HijgKOV1MWWb5iNMaC9MIZXnQMCpCWkaF0QYxqsFHcUocJjYT1BVxukTJmDjJMAKi4wmbu+dUxZa27pBCIeKAYS3QNJhuIIlCinbProxQ01OCYkOe5iRhxHI5J9A9cpKiRI+KIpQ+oovP+Et/6z/h4sMjkplif6n54V/6a3zyh/+Yf/L7/zPPvvqM/+Ef/Tf85m/9NX7w8Q/pux1f/sm/sMwZAZ2wpiOTOKBse9szoDWgaastfafppBUs0/uS2WlClk0QcUK/3hJGCfWutiJiYYRQgqbtwUhmycIyVehAzjk7OWcXBWw3K5q2pq5qPv/kC46OZmxK6+BU1Vs+++d/SJTFRMmMQOUYZTCm5tGj9wg+/hF//M9+SpAkCCnouhq0M90AxCjxO573sfth1BvCA3PDQeB+lbSMWL2xOqDKzghvHHvvRHB/03b/gn3oAj68eF1QiuP4zwT3Q778oT67y/5ns5kvdh4aYTiRMKev4l7DNd50Xeflf12gdRxy18G5Wq04Pj729x8yQpy07ZMnT1gul2w2G49X/+hHP+Lq6ophGFitVvzBH/wBQgiOj485OjryhU1nxO1WHI6X7vxaXfCcTqcAvkHIiZIdMpJc7WG9Xntmi/NsdVx250R1e3vrm48ctANweXlJ9v9S926xlm3nnddvjDFva677vtbtXHPs2McOdtSdkACipSZRQApCiLQSgSCRQC0Eb0i8IcEDL/DCCwjUUj90NxJRKxC1ZaXTAXXSdpokGNNpO7aPz7XOqdpVta/rvuZ9DB7G/GatWq46PijEPhlS1d57rbX3WnPOMb/xjf/3//7/fr8zG0nTlCAIOiimaRpeeumljh+/S7Pcva779ZL9670/D15ULP/0jJ3FSBjM/svOM0+bt54eq09cqkwxCEOm/QEa3Zlie9q0Qkuno1aEWmG0JtKG4bhPPOiTDKZQ+87kIDHEUQpOU9YF680SpUOKomJ2eUGVOWxpSZOE1XaDIsRZx2A0orENJurTlBGLmwXRyRG98QG6zmi2W5wr0QMPaxAF3H1tyOggYnMNPacI0iGf+ckvcnV+n7JpWMxu+L/+5I9QCu4cfYbR0WPWswvCyLDJSpw2BMaQGkUcWHSoieKYKsupakXtNP1hjFVg6xynLNQF9WoBzssyqCDAhCHD0SHr2QU6iokHAzZZjg4h7eUkh4dUcYzrDamvLtcdYxUAACAASURBVCnyNf1JD2sDwrABLPOHD6gGQ8bqmAZD0g+ITUx/ekpZWwqrOX71NR5cXdGLQ2ITkClfS3IIA4pOP2h3OpuWIillUinGO/nfdy915fPGfXzi8qkO7p9kSJD8uE5EeFbOQF4ni0Acx11gkqKhYMCCtUtdQIqAzrkOL07TlMPDw2ealmTRODo6oq5rrq6uGI1GvPnmm5ydefacQB/CfFHK0xKFXfPOO+/w5MmTDu8uy5K3336bn/u5n+PWrVuEYdg1TUnGHsdx9/kE89/Fs6U56urqivF4zGAw6GR4ZbGR49Zac3BwwOXlJVVVcX5+3mXhovIoSpbC9Hnw4AG3bt3qzvHBwUG3G3r8+DFZlrHZbPjwww/54IMPUMpryEvX725NZReG2R/7Af9FVNq/zOPp3FYo5XtcrWqt+JQYddi2scXiDZh8ZhdHCdNBj37sMIEnW9q6xNqCoHG4IiQKG5xtUI2lydY0TU2oQ5SFxWqGMwOiQZ/bJ7fJVnPWqzUUFhUMcJFmcHqPurHMLx8zGw35zBff5OajDzBOkwzHbBYzmjInUBatwWaWZr7BrZd89Pafcv7kIePxlDhJqMqcd9/+Psf/4s8wuf0KgYlYzs8JTECee2elXhQTaU1jHVmW42pHVVucqtBuiLUNRVlxdXFDf3pMPBpjlgvseo1SEJoI4yxxGOOSkOHhCbPLh9iy5vzJmjh4gtKGKD0iDtfURcZ8uWY4TEnTHmcPHnF0+y5O5zTXV4yUIox7FCiysw9ZFxmrTcPjD97l0XvvY7UmHgzR2RaleSrFDCjtV3TPY3ceVsNn78Z1PKr22voSrFFA2+QlK8CnHnOHpzz252Xr+zfsPr4qWbi8drcwu9vstB80iqJgNBoxnU476GKxWHRFQaDTcFFKdXoykrGLVIAEuvF4zGw26z6baMFMp1MmkwlN03B1ddVhz0dHR11DkwiRSSAuioL333+/y8RFZvedd97hu9/9Lm+88UZ3fCLHu9vpK/i1YONSJ9h9TAqsUmSVc2WM4Y033ui0X6TAW5Zll4WLjK8UX4WWGUVRl7mPx+OuHhEEQWcBKB6xURRxcXHRXa9dGuN+YH9RcXx317H/ey9aGH7UQ2v5rPKI6/4XxozrbljVvVACuzEyjw2BaouxKKqWNuHNm9ssTxksUBUlwbDHdHKCqxcYXbOdnxMmI1xkMA7K1YIw7aGUb/TJtyuqLKOoLDSWbLMiTPtEYcZgcsDFfEGlDGiLLjV1WZAeHjOeTHF1xfL8EnREvl4yOuoR9Go2qxLb1DSZQ+cNTlmKasP7998iiEIGcUSv7lNVBfff/i5/9r13+OLrdxg6C2TMLq9BQRQY0H7hUs5hGsu2LKitIo5C8qKgRmOLyvP0bYWtalxdobXz7lBa4ULDyz/5k2xuZtRlTp5v2W6W2Dyn30+IAk1RN5hhjF1ZgiDEmYib8xvCKOLm7IztsM90NKQutuTXVwQhBMMpOh6DLdnkOSZOmF3dgApAaaxrWkfFlsDupIvYdcXRNna3xXZf8PVF17bhqaVHSqPaxxMhP2XB/UUFM/jBotnuTS3F0/3sc3/sB4skSTqNFIFKJOMNgqCDMeQ5kSQQOEIYK7IQXF5eEgQBi8Wiox065zpWjOwCjo+Pmc/nz4iOCU1SjvHx48copXj99ddpmoaPPvqI9XrNaDTi/fff73Dz0WjE9fV1V6R1znUsHxmShUvgjuO4Ewg7PT3tZIfFYk+YPffu3ePs7IzlctnJLQh7Rs6LMGWkG1W8XgXqOjw85PT0lKzlTM/nc+bzeWfXJ7uk53HSJYi/KMjL9d99vTwmO4BPQwavjVDc2sSCtpmlvTVViy87J8fmtWGM1gTGBwDam94Engmj2v/Eas/bfHj2DdrRSyL6gx5xX2ELg7MeVig21wSBIRgMsMrhihKLJYli4v4YezWjybc46wgjTZJE1Drh8mIJYZ/VYkY6SKjJ0daSpCnj07uEUYJtSg5OpmxNABZCpTHljHg+Y3AwYRX4HfD5ow9RSvO5117FNjXvPjhjvS7ojw+5/8HbHB9OOEz69EcTbq7auR0ajAqo6srrvqO9T2oYgDbUGlQQQzqgbCwmDDm5fZf1ckZelpRlRqgV6/kNw9GAk3s/wdWDD1gvVqw2C4yqUZSYXopzS2we0e8PUDjqbY2OI9bLGa6xqDCiHmkGx/c4un1KtV2wWW3Yzi6ZzXPiWDO7uMQ1UGOxTfNMMFZK1DpbiMW1AR+H3oFaAkUX1FFeTdS0BVgDu9nCc8enJrjva3fv39D7Haryml0cXZ7fN92AZ3cEu8wbgUKkaCpZsmSSEngEYxaoQxYEgVV232M8HnfHI5iyCIwtl0uKougak8bjMev1mrfffpvj4+POoGM+n3Pr1i1+/dd/nW9/+9ucnZ11bKB+v893vvMdXn/99U6SWCiX++dxV89dIKVdGEuwcmNM56MqsIsYiUhRVrpgRet9PB5z9+5dVqtVt/jFcczV1RVZlnFzc8OtW7dYLpddU5aIhz18+LBj3eR5/kwg3r2+cr32d237WLyMfZz+Ra/7UY6mls+O337L50d5U+u27dy1d77fRTmM9u1Jgssr7QurjbIY591SLdpbsClHgyXUmlApDBpDA3lGkqYYp3BhSH/cR2lN42ps2VDahjBOmF1fkm9yrFUkvZgir9guM4rymkYtaFwPaxJ6k9tUtvRa8/0BTRiiogGuyVjNL8jLnMPpBO1WjCYjtqs5H771Hcy9V1nPtpiyYDm/4c7xbf6j/+Bv8O0/+xYfnj32C04YkKZD3vqzb/GZ1+4wigKGoylNs6BuGq/FQ41WYLUjTmOs1ZTW4aqGQHtnKW28pUmNQgURJjD0wz4qUGgd0OuNqKuSzWZNnmc0dYkxCts06CCmKGt6kwNO773MdnlD2OTE8QFBPGF59ZBlvsHOAw7zhu18ia1KmrIiTQbkccajh1ek/RRXOTZF6Tthbctul51Xuzh77rrHV1olCa9rL12qPDv3hWfjlGq7ll88tz81wX0/I98f+zerBKRdxgs8zeT3t/GyEMhCIc4/wrCRgqEEG6U8j12EvCS7lsAL3lc0CAKurq46Ozrhj2+3244hI4vHbsORsGYODw9ZLpf84R/+Ia+88gqbzQbgGT2Zq6ur7jjSNOWnfuqn+N73vtfpusjrJLsWiYK6rjs2j1jkSYA+ODigaRouLy9ZLpfdOarrmsFg0B3/rqG3LBJSwFXqqSbPLs9/vV53ejNVVfHRRx8BTw1MhHYqBV353Ps7thexZT6u0Lr/+It6In6Uwx+S20u02ogNHVtGKR/AlQITKDQWa4VJ49BaERnt+S+qNVxzGosmaDM/oxVRoIkigwnAJAlBoIiSHlVRU+QZSkG+WhLECTQOW1eU2w11BZvrK1Ca/sERhGsur2ZsmwYdWLLVNSockm+3mGjEdJpSFxm9XoTbbllstzgXwnSCSYaMj+6yXsz59j/+R/R/4l9muy5Imy3FdkXa61EXFbPzZadL3uv1+MnP/zTvf++PKecXFIkmTiPSMmazWXkYI4hRoaauS3qB9nh3VhAEBh1omrpkeHhCY2uunpyxXl37AGpBVQ29QQ+tA4rNispZ8qrA4bBWUVnNJis9Po/F1Q5XN0SDPmW2ZrXesNhsiNKU8XgCxZLz+0/ANaRJRFNm9JKQ0fCAdZPQbDKWmw3gVTZlAnieuv9eCNtWeckIK4Ydzi/8ygnv3Wfveoc66SWe/38QDvtxj93gv8th383q5Ll9jvt+oBf8dzgc0u/3Oys9cQeSQCaBUqiNeZ4zmUw6iuGuz6cEQMHmBacWfF4kB4RaKHIA1loODw/59re/ze///u/zxS9+sds9XF5e8tWvfpXFYtFBPJPJhNu3b3f6MLvNSGmadrsMMQiRjF5YRKIXs9lsmE6nNE3T6alfXFyglOL09JTlctkpN+5CPOB3WYPB4BlbPGHlyPsIU0hE04TLLjz48/PzriC9e/2el2nvZ+vPe92LMvbd+sundrRYrOuyt5YDbVrCpPUCY8ZolDE4QrRTKGVR2uIcWOcbYowJiNIe6Sill/ZJeglJHGOb2i8izqKbBqcMURhR25xsvaHMtqTTE1+ULFaUNxlYTY2iLBrPrVaKKAkpckW5viEvD7FVQzw4xAUxcX9Jg2OTFWirsI1lfHybd/7Zn/Ltf/g7vPSlv0YThCT9EdeXD/jKV3+X2WpFbb1GysH4iMO7b7C6vsTdvE2x2RJGhjDp0UsTagtBnGIDw3a5oLagLWzKiiBJfbOYadhsl0wPptimZjI9BAWX5+egFdPbd1ktbig2azareTe3Q+M5KbWr6adDVNxjtSnYrFbUWQPFlrzIfSNYGFOXFdu8QLkaW1kIHKqpyauSxxdXzJYbXJC2cBgtR90RIGCc66A1Bd35lS5j7VN4kJ1dW3QFLyKnaY1f1J9Dz/3TNnaD9/6NLBj2bnDfDeySxYmMrRRBRSbXWsvZ2VkXINM0JUmSrt1fGDJiQHH37t0OR1ZKda5IIpsLHodP05Szs7OOarlarZjNZrzyyisdLBMEAd/85jc5Ojri5OSkw9bFT1R495/97Gfp9/u8+eabfOtb33omsxYK5MnJCXVd0+/3O0cnMbt2znVqjtKVKnCPNCHNZrNndOV3i9K7vrOLxaJTjrx9+zbHx8fcv3//GT/YXc9WCf7i3iRF3t0OWhn7GfeLoJbnBfj9prdPfXBvhzEGo33Tkmqpb0p5rW9rwWhFqE3X0NIlNk5htEI7aIoSG4ZEcUA6PaA3HjLoJVhXc/3R+948Oo7ppX3iJCVKUrLsDOccm+WNvyZ1wsErd9isllwt1mi1YbUsKMqcYdOQJCMUluX5hyRpys1H7zDqh6SDPpv1DZubcw5e/Qn600Py9QVh0PDhH/9vjE/ukByfMhyPef/+97jZbCgLrxiaxj1e/+yXCNMT7n7pX+Xi/74hqmZUVeZrFHFCZAKOT25R145tOma9WbEtawalIy9rGny/STmbsTYhjXMYE2FCQ5r2KRvH4nqGaRq2+YIsX2Ft5c+vNtTOkWiN0Y7N/JpN/gRnK4a3j5keHfPgg3dJ4hFlWTFfltTZJUnoGI561GVOWZRs8poo9IvQNq/ANijb0NAGdeUln0GhnG3h9lYWuqvD+KCuWqzOs2a8rpBRmkBrr+WuRTzu+eMvVXCXIAQ/mI0L5i6YsYz9piXxFZ1MJoxGo67paDdTFw0ZgR+kC1MamMT4+dGjR0RR1GXjwhMvW3lVUT8UbrwwUsR7VLRUhLHz5MkTvvGNb/DLv/zLnSepBOfRaMTnPvc5hsNhZyIiIl2LxeIZZ6Yoiuj1ep3Jh0AlMtI0ZTKZkOc5BwcHnc6M2PgJbCVSvbvnUOwBpatXXisQjBSXt9tt5/Yk+jwivyBdu2LeLYF9F0LbXVB2H5PxvNrM/t+ATwcs80mGn9veBlsazT2Doi26KenNwOOtOHzOqTs98CAIiXsx43Gf0ahPbELqYsu2LtDaosMIG1hMYCiyNaiIMEmZ3nqZ5c0TNusti8WWrMjZnD1Gx33i0YA+DmcqVBBSlg39qCFNI4q8QWtDVhRgwDYGnRyibEVeNjilScdHTA8mnD++4v3/87c4/rf/Y6anLxMF/w/LzZIyzxiPJrz2uZ8hHt1BpSPi3mtU2zPs2T+H+QXFZsMg7qOigCCJiHRKPKi95d96i95siADXWPppzODgkCIvGB6esL65IpvNsVXFYHSEUQ4TRqh8jWuatjjtna8ipUiNI1AQ9FO0LukFfQ5GY8qqIUz6gCbbrr11YGIYD3vUS8do1Acc2mjKoiHUAU21AWpvgG1BKV8fETNzo/3Vtc62Ms8eavOQjPfEVQq09UqhSimstljnu5GNErX+549PTXDfp7LBDxZBpXty/ybf/Xm3ULiP4wo8IFmsdJU65zp7NwnwQGcLJ0FTsk6hLEo7v+DZk8mkoyUuFosuyNZ1zXq97kxARqNRp0EjuPndu3epqorHjx/zx3/8x3z+85/ni1/8Iu+++y5BEPDSSy91cgGj0YiTkxMAfu/3fq+z/duFqIRrL01Icq6iKCJJEqLIy6tKBp9lWVcQnU6nXFxc/IDeixRod3cHk8mE09NTLi8vefLkSbdQ7v4TM/CiKJ7xb5XrKR6tco32M+5d5sv+3NidIzIPhNq5u9v4cQ6ljUCmOCd0TxD+hNaKKDSeC+287rvFsyWss55F4zRGG799tz7bk5YX5xw1CpqaINfY1FKVDZWrcXVNkRXEWhHgIAxRVpHnJcvrD7yWehBQFQVVtqUuK1xVYRtLtl6w2VpUEDCZpNTX1zQo1vNLoigh7A9p6ppyOWeY3iHpGaLJLdbLBfTHzFYrRv0hxy+9RlVVzB9+i3e+/g947c1/iZ/+/Bf5/vvfxwQJBy9/geDwJRoVE00POLzdJ+Wv8taDPyUwMWnY4HqGXAXUJNjKoYwjTQdk2xLlDC6oCU2foDckjkKCSLNYzAlMwDLbEEQJ/TAgPTzi+uIxVV23Sj2eIhkor5oZmoTjk3s0dc3RaMLx6W3mF2fcPLpPXXmnJ2MrtA3QTY8iqylzQ1XkDJIEVIBRGhNFKKMp67Zuohyu7UkQxkur8E/QzouWCtGypdq+hrYeoRv/N5T1zltGFajac/5fND4VwV0yQngx5XE/I5exX4Ddx9v3m2K01kwmE+7du9e10ksw2DXIFsxYKdUZV0v2LUFWTKtF9law76qqODw87PRcBPcW67nLy0uUUjx69IiiKDg6OiKKIu7cuYNSiu985zucn5/zpS99iVdeeaV77yzLus7P4+NjLi4uuvMl7J26rjtbO9lJDIdDzs/P/fa3ZahIli1a87L7EC0a0ZAX6qNQOqVDta5r7ty5Q7/f70w/hFkkevQSkIXvLwbc0mgluw5h+AiUItdqF07ZvY77EM7+9d7P8n+sdEil0KZFWp17ypQQChwOY1Sbkctjba8CUjrDb+dDQ9N6aYqvk8bz3DU+E5xOBtx96RaHJ4ckcQTNlkY7H7TrCrvdYiKPGWssTVlgq5q8KMAE9A9GxBhWb79DUzaouiGva1wEYZJSLxdMjw9BR9jaY9TWlVRlwXB0wPz8IbVOKM8eUBdHNEdDkmjAyZ2XMU7x5Fv/O8XZd/nCv/Cv8Mbdn2DpEralQecNcT9mdDJkekdRnU3Q1uFUQ9hP2ZQVTd1wc31Dko68Zn2UEI8mcD7D1hVxGlMVBWVZESYhqq5RJiDuD8E5ktGAbFuQb1bYKkc7S7/XQ7uGfhJzOJkSmgBVZdy6d5dpL6XMay+FUPvAniYhLvB6QDXQVJYqL6gri1YhcRwSGMX6+gmr+ZyqpUF6jNwv8F6PvfVGbQWbtfbCYX6uNu2irbvCuUV7g3VnqXBUzs+Xj4ntn57gLuqE+9mZ/PthgX23WPo8FsXu69brdYe7J0nS8bx3XYCEKSKsHMGGpYAoWLxwvYMg4NGjR53ZhuD2Ar8Ie0SMKcShSWiDk8mkC55Cmfza175Gmqacnp52zJzXX3+d4+NjVqsVw+GQ27dv881vfrMz0x6NRh3GLowY4cAD3bHsLmYSnAWSkoVK+P6SbR8dHXUyvqenp3zmM58hDMNOs14gqjRNOyhqF1MXmEfkDXYhqn3P1N15INdQCt67Gb08vx/w95OEH9fQShEnod9K+7sUVJuRWdti522wlo/a9jMJnm6dAwyRMWilCKSl3hkCnGdYOIezlvl2w1FZEYQJvSRmPV/S5Dl1UaKdw1FRrjfU1hEGmkBDmeU468g3a7LFBp2OCXoDmnJDNOgzCBQPzy4oLZj+mNJFxGFEicJu1/R6MJwOybcbrA5oiox8e8Pq/AH2ldeYTlP6vYjh0ZTa5WxXT/iTr/82qn+L6N6X4Og1kt6Ik8+/wtFtTTVfcS9xXJ/e4nvf+D5ZVrIoCnqTKevKUVU144MD6sbS1I4gSQiVRpuIvNhAoKGylFWBLTK00ugopnYNRV6g4oTV+YYg0AzSlMjBwfEhw0GfoG6Y3rnFa5/9SeIwYfbwAetNQhTGjHsRaT/xbJuiIs82WCwlDfl2Q1PXDMZT5vOF93JNQlzuqBvPeHFCdcRLPovGp7BjPLzmd2NWLPiQpNe/sG7nhUbjXMe3eu74VAR3rb1v6a6I1+62Xm7+/Rt1P7ODp7DM86iQ8ncl0EimKEJeklkKtr/7s9be5Lrf71OWJTc3N1xeXnaNRbdu3WI8HnNzc8NsNuuKsEp5n9XxeNwFfiloinnFw4cPqeua6XRKmqbcu3evY+NcXV2xXC5JkoSDgwPu3r2L1pqvf/3rhGHIzc0NeZ53Zh3iZiTm10EQ8OGHH3aLkHwGCeYCl0imK4weaYwSy0GlFK+88op3yun1ODg4IAgC5vN5Jwn86quvdraEsqhIXeHDDz/sZA5Wq1V3Tnf7E1409gP3J4VbftyBHXx36rAfYhsNSqClxkvQ2gBnHa6p2sBu8ObZIuna0iWdBQKMCVBKPw0SylHr1qpPubYIC8WmQGn/2l6SUDmLKyp0CEHQx4YRdVmgTABBhA4jWG1IBglFabm+ueL6YsZ6vSEdT+jdvstwWnMxW5DdXBFFY/KwxGlFOhzTn0ypG0uQjkiKimJ2SVitccWWywdvU7o7HI1HDPoDTnov0eRbtjczbi7epVp8RNM/Ijt+k/qlgLka8+7vfYWxypjNrsnzisv5nHUJ02hAUVYUm9LrqUcRD+5/QFlkhMNDr/Ee9bx5dBhS5yXbKsNZv6LqOGDQT1lePfaU38mYyXRE5ODeq6+SBIZeGjE+uEUchCxnN8T9AZPRAPvaaxzeeRkVOBpb01S1X/xwnL1/n5uF795dL+fERlFryJrWKamFYWSn5X8SE/N2oVcKbW1Hia2d8tg7CtvKOSvn9wAewheNmU85LANPO1RlOy9whgR8+XnfZxPogvbzaJDy/C67QnYB2+22y8CFriiQA9BllUIplM8h/Pc4jjs2y3vvvdfJ2cqxCD1RFo5dNyQR6JLPdH19zXq95vbt2wyHQ4Ig6LpQZReR5zlf+cpXyPO8y7aFSROGYbdLEIxdNGck6CulOgEzpVRnUC27B2m0kt2Nc64r0ApltN/vd4uQnPOyLDvbPulQLcuyO2/T6ZRer9dpy8s525U82C+Cy3nZv34yZJHefd3HXfcf33C+Q1UrApNgVIR1W7A5tTUoQqgaKmep6pKiKoDWncm1iY5TaO3QXlzEd6M617ItWu5zWxTUWqF1RbFd0E8mhL0hVVWSDEYEgaJpSnCapDfAWcdmucA2PqA0FrbrnCiMiWPNemkpipIP3nuf7WZL01QobdC6Jk5C4sEQ5SKK2mG2JYEzDHpD1mHIYHyXmX5CqSNurpaUiwWnd+4yHA3QgWV4ckw8HLLZZNi6QK2+zwd/778lzzfYfM2lgjz3QlxBmBKrhrpoe00U2DCiyku2VYFJeiilmR4dkY6GGA2b1YrR4YTqqiTb5l4Rs6pwkWK5WeIchDomDXv0+wn9OGSQ9hgdHJOmY980FSSsypKzdYmKp1yvt6i6pK4KVssF2IqD6QFhf8g0iLCuYbVckpfW10saS4BfqBtFK9PbUl1Vy113Lee9DfA4aNB4nyXXOWq1ywBAuyg0O+Yuzx+fmuAuQXF3673biCNDipmStcnvyPe7wX0fp5WveZ6zXC65vLx8RuJ2NBp1ui+7Qdo517FfHjx40AUtCcDCDAnDsNOQEX77drvl8PCwyz7F9Uhoh6vVivF4TJZlLBYLFosFR0dHXWerBCjhyQvtURqXBMIRDvwuNi8dtKItI4VdkVaQACsZtrhQCbwkmLlICUhnrjQ/SfPWRx991EkXLJdLjo6OOqOO7Xbb0SOPj4+7AvSuV62cK6lxfFI45XmBe59B8+MfjrouUTqgcRqlHcZVxKqk0IpQa7QJKVRCWWXUdUFj/e9prbwmCgqjA0+DxN/ojWoIlW/Bx4FrdwVZXjBbbOldXhMGEZEuqfOc/niCwVBkc5wqvZRwEIB1hHFEMujx5P4DsrbFPjUajgZsNo5NURBEhvHggKZ2LcZcEazmTI5OcU2Bc32219eEx4a43yOvK9bLDfFBn2q9pCgWbGfXHB+P6CchxgRY5whdSdgf4KKYsmoIshyVhjRlAbZkvbjBOsV0csC6hE2+JR4MKXIfYOvGEhBQNyXZckFgAtJBy3nXAa5sqIqKyfiIKEy5OvsAV5aYAHAVRjsGozGNdUTpANVkzC4WPL5Zsak1H310Rl4WBMaxXsw5PjwijlNWi4ZqM+P+Bw/pJTGHJ0fky4xNVpIkMYnuMWgU27KkauVAFA6l/WItHqmi+eilJHQL0XjipGvnsG6Lr+KjangqMub+MmTucjNK1rzbgSoZ6C42u5vt7VLmdrtT9xtYdrFb8BCE6KgIDCPdk+KIVFUVBwcHHXYsnZXSpFRV1TOfQQSxxPhDFhjhzEumK4F/1x9VArNY0smCIHx1+ewCSeyye8qy7MyvBU4qiqKDQkRvRpqWtNbP8N6VUs9g9rK4wlM9+iAIul3EkydPOD8/f4bSuFqtePnll/nyl7/Ml7/8ZT744AP+4A/+oIOMzs/Pn6FKAl0Tk/Dnn1csfR7rSR5/3iLw6QnsfigVgPOJiraOvq7oqQajNKHO2JYZDb7o7lqas2klCazCd6cqCI1ug4AlUAFK7ZhvK4eyCtt46l0QadaLKyZDL/TW5BVBL6I3OqQMA+psS13mDI9OqbKCxlWkkwFFu0PcbApfUFUQKG+cXW62hGHMeNSjPxxjXUCjU5L+gKCXEhjtza5Lx3ab0z86wbkQqw3bsmGbbcnzJQfTEaoBR8UoTWnWJVbNqK3FEeJsjQpDslDhkhiXF/QnU1bLFVlTkZqQKs9Y3czBKaqmoskr6sQyVIe4IKSsarQtKescZ2C7XTEcTcjKLc4oQrxEQZAkMRazYAAAIABJREFUxJEmCELy9YayXvPg/Jr7lxuyUqMCQ1U2LIuMuy9/njf+6s/z2b/yczx69z2+83t/n+biPfKi4uLJFXES4ZRhnZW+Mcn4xbextvWr9Qbpcr3avuR2lrSet8rDLwawyvqiKr74Gji7A8l4GuXHjU9NcAe6YCIZuOiT71IYZbyI0/w8tgw8uwBIIVWof+PxmH6/T5ZlXF9fdwuLFB9lIdllvcjCIhZxonYoWLJkuxIoJfiKK9Lh4WHHiXfOdVBMVVVcXl4ym8066Gc2m3U7GFm8ROhLPp+8To5Vgu18Pu+yYzmO7XbbmWKLgYewZkSyWM6t4PbL5bLr0hV/WAnUu25KaZpycnLCrVu3uHPnDo8ePeL8/Jz1es1HH33UUUWlrvEiCOZFNRN57X7h/XlF1k9DQZWWbpdojXY1ga4JtQMTkwSaxlmyImNT1eCMVNx8RqdEk8Tzp5UJWtzWZ3pNe9srWiEprYiCgH4SE0cpcawYTG6RDIZU2znry8doE0KscUFIlReYusQZi60dTeOoi4JABWhXE2pLTUMSRV4a2GjQztMTJ4c024ImUOh8QTwZsNpkhDogPb6FWlxRFV6Mi/CAXhijqgXX54+4nj8mDRRJrJndLKkan2hpY0AZiqpkW9RsixKlFb0o4np+g9U9NIaiqllu1iwW15RNhS0y0BqtQzbbjKKsydZL753aWFzdgInYrhbUdYlzDVpp0uEAEyYslyvy9YaLfMsmL7DhhCAZEeqabOs7tI3S9HtDjo9f4uTWyxzf/SzLj97HDRrW6yUfPjjj4maNAyKjCEwIrdm5UgpFgHM1Gm+fYpVrue+e925bNpUvqNL2MLTXHq+E2dAqEbDT5foxM+9TFdx3s0XJ5AR22S2o7mfj8vOu7+f+a+R3BZJI05T1es1gMCDLss6I4ujoiNVqxePHj6mqqsOhRbtlvV6TJElHD5QAKboxw+GwC8Tn5+ccHR115h+CfcsxHh8f88EHH7BcLgEYDocMh8MOf3fOi3EJRCOQlHOugzKE2bIrfAZ0vq2y+MiiEoZhJz0gNQM5V3IepLYgAXi1WnVaOU3T8Nprr/GLv/iLbDYbvv71r/Pw4cNn6KLCPHrllVe4d+9ex8oRzF0+nzQzAV0Rdr+7+HnF1I+DXZ73Oz/WoTTOKSJKemFNrhUZilDHhMZA7RlEqmXTqDZz734dUE5jguDpnd3lbL5D0bWwTBAmJIMhUToiX60Z90/Ybv18HU1PmR6dsl2tuHr0PlVZYcKQ2jU0RUG2WlMsVvSSmHA4pmJGtsnoh6CKinWm6Y+OaOoKHQZcPX7E8OSOFzhLU6pii4l6EMY0ynB4fJuz97/ParFEY+kNJ5jRS7jra+bLGXNbk0YBaRISGU1ZaqoGahxZ4emXHg5KSGPHVvchgpqAprGs53O0MVhbkm0zvwsKE7LNmsl0StSLWa9W/vwryPKcuJf4fLeuwWhCY8gWa66zGUkYYivLq69/jp/91/89VpstX/un/wdPHt6nqnLqqqEoMuq8wGQrbr12i5OXX6fI38eWBZEC1TQ45SgbC7GhKTOcg0ArtG2w7W5MO4fTug3w1ksBt7BM1+Wg5Oq7biLI80+/+3Nm7kqpBPgaELev/y3n3H+plHoN+E3gEPgm8O8750qlVAz8XeCvANfArzrn7v+w99kvnkpg2ZVvleCwi7fvQzLPaznfLdZK9itdnuPxuAvW0tUpWL/w0EXiNooiJpMJm82mE/aSJh2hTQpcIgXGszPf2v2FL3yhO77VasX5+XlHbxQZBAm+o9GIPM9Zr9ddtiy1AaCrOUiAF4xfNOlXq9UzAmrOPZUmSNO0MwkRpUfpNBVt+l0VSQn+Iun7S7/0S/zKr/wK1tpO8VEWvV11RxFkm0wmKOW7cGWhlMKydLDKeRepA4GtZF7AszWT5y3eu2MX3vk4iOZHNrdpcLbGaeU1YHQPbVIwuqVC5mgXYBuDdRVgvYeqFOKUI9AQmHYbr8BYDcpA4CGcOAgIA0OsNUkvZXL7hN5oSi9JMIOUIB2Q9gYQzhlXlpuztyiLjCSdUEWKMM7pH00olhua1ZJxoqGJWBQNVdNgfIWQ2IQs5jfUYczm7ENUE/LGT/0s1pY0EZSLa5aP7pMdnEIYYuKA/vTId2TGhnh8QJzlbNcblpuyndte+Mw5TWGhsJq8chQ1ZK5kUzb0bYjTa1abFQQhKghw2puHB2FAoGKS3ohoOGC5XmArnxwmvQRtFNvNgrLfo3bQ2IamrlmuV5RuQV5m5GHKX/s3/h3+tV/7T6DWvH4aslgt2KwXbNYrUFu0NjjlCFRDmmgmkyFzSqbDhDjU2KZhVdRgHabM6EWatBcRDg7Y5huva1/mVFWJBqxVoJqW6qrbPgdPc/UOeh66cW2lRbedcP5W0O0mr37RtPtEmXsB/HXn3FopFQJ/qJT6h8B/Bvx3zrnfVEr9T8B/CPyP7deZc+4NpdSvAf8N8Kuf4H1+QARMuOIicyvdoRI8doulkvWLvK4UQHc1Ynbb3iWDleKjFD5F5lYp1bXoC+QgptZSIBXbvbqu6fV6HZNHPp/I4vb7fRaLRfeYBF+hTJ6cnHB5eUme553WTZIkXF1dcX5+3nHRBS7a1auXLF5r3XWCyjkUqqUwS2RxvLy87Iqxcm4loF9eXnY1CeeemoP3ej0+85nP8Bu/8RuMRiMePHjA7/7u73J9fc3R0VGXsUv9YrdQKsqPsshIcN8N4FKDeB7EAs/CNrssm92xv7P7BNj7X/zcdq3bfWBoHChnaFwELsLoiDA2pGmDzULfUepyAt3eCyigRilHGISE2hAFhihKvbRE3CMapARJijIBdVHSU2DCHvmy4Gb9EYN+QrlNMQfHqGJJvlmglWMwPaLM19iqwShFEMVAQ3LcwzpYr9ekQUV5M0f1DGWlqPMtNd7fVW039CeHxJMJ2ewJzgSsS8iWK3RgqW/mxKnh4PYtri6uaTYbRpMR6fiUKDlgfvUR108esqocrmyIA02kLCo0nv1jPUWwKCqUblBm/dRzAaispakKGut3RjoMwDbMzs+pqoKmbgjCgF5/SG011m65On+CsyVOKRoaNtmWzDn6vZTjz/0Mf/0//c+Z9o+4eP+Kr/7OH3I1u+Tw6ISiLKnKkv54igpDNs4wq6CoGt/Fu1lQYQmDEPKaRoGrSwoMjXME1QXrLMO27llSDJXM27syWc+C0t42UaQnLN703EM8EuDpCut/LljG+TtGhEnC9p8D/jrw77aP/x3gv2pvgH+r/R7gt4D/Ximl3Mfsk/fxU+ms3O1KlaxPtveSie/CLHfu3OkyRQmI8/mcy8vLZwJcmqZdJiuFRYEDBHMWb1FZRIQxIxn0bDbrNFuMMZ0hxePHjzsPVFmc5O/1ej2cc92iI+JigtnLTmU2mzGZTBgOh52WjeDgwh/f7f6U8ycLkTQjiZTurpa7FIKlMCqLopwHYdZIsJcCMMAv/MIvdDUQYcbcv3+/g4u01kyn065WIN6vsvuQRUMWqN0+hl1toOfh6zL2A/fzsvPnYfE/trkNOKdwSqNcRaANTWAIjFf10ziSIKIKQ+q6akWhFInRBEEE/SFJf8Stu/eYTsY0WmOLhm2xpp7PqC6fgK2x1IQ6Ik17RNGrBCYF21BVir4eoID1ZklTFpTrpVeHVAHWKFxVE0YxQQAYw3I2Z7tasl1tiHTE4PYp203NxaMnhMqQ9oc0aU0QhZRVQe5mqPQQQ0Wv30PHCUkyBlVTVQ1hPCDQEc6EFJeX9A6O6Q2PSDYZq+U1VZFha0ut8AqYrWZ9ZWtsyw7J8y1NXRMGMVjHZrXCaJ8t26qmNhVZnrHZrthuNjRNDUoRBCFGQVk32KYgigJoXDuHNTavcWh+6t/8VfLeIQWaJgqYb2Y8+OAdiqqgqTzmPjo4IYx6RHGfysH65ppquaIuMlTdoJ0lCnwIrq2ltg2BMzjnFTmNClB4bRjtXMeGkS5kg/XBHI1WrR8uFu0UTcdrVx1DSvHxfR6fCHNXShn89vQN4H8A3gPmzjnZEzwE7rbf3wUeADjnaqXUAr+9vfoE7/OM5ogwPgRyEdEsCdCStQrD5MmTJx1+vcukka/yfZqmHf98t5FHBLh2oQDRShFoZz6fd5myFEElW59MJh3lUB4XTrpQGaXdXrpSX3311a6pSQqlh4eHhGFIXdfcvXsXpVSnsOic4+joiOVy2cEYEhx3ISph+uzCM9LFKgqXMnbNRqSoKwFcHhN9Hfns4uIkeL6wcOQ6jcdjNpsNjx496t5T3lc6e3ezcLlGzyuIPi+T350zu19l7BfbP2bO/YXPbecMqAB0TRQprLEYVdKUW1AVWvcYDUaEvQQTnJL0UnANVVGwyQrWec3F40dsF1c+Y1P+n27zN6cduu1kTNOEfhoTKDCRJi9zyqJmOb+m2Nz4JinXgFVURYmjQusApSPWN9dkeYUxiv5whDERVVHRWMtkOiSJQsq6QYc934hUNpR5Qa8/Jows8/NLSgvleU5/eszxG58jKD2dUWlHWeYMjk8IooSqGXPrrsZqxXoxo85zFIbDk9ssV3PyLKOxHrZyjWt79Q1OK7JsTd0UaG3Q2jsxZfmW9XZLkW1bmMPPh6r03sLWOQITUFa+O9QYT001QUDYG6KCHplTzEuLDWOmt16hrmqyzRZb10ymJ2BSeqMRg8mY7WrN8qP3qNYV67Jmk2VYGtJYkZXW2+dpTeMczvoLJrRH3fYxdDPTeQSm0QblIMDS4PscdAvLKSd4fdulqhTCnXnR+ETB3TnXAF9WSk2A3wY+90l+7+OGUupvAn8Tng3EuwJiQNeiPp1OqaqKs7MzNptNR5mU7b1k1vJ3dr/K9yKuZYzh+PiYw8NDiqLg5uamc1SSLFYp1XG6BW6RgLlerxkOh10AFi9RKTput1uWyyWj0ajjk89ms07pUdQaT09Pmc1mHcdeaIxPnjzp6Jjyun6/37XsZ1n2jPaLnAfgB8S4JPDvUiF3axb7Q56XoCt/R2oQcu5F3uDWrVu8++67pGnKSy+91FFJoyjirbfe4smTJ93uYpfpIwu2XPPdesq+MJwcn+xCdq/v/vHvf//Dxl/03Fb66U1stEE1EJkapwLWtkeSHDKZHFE1DYuHH7C6ucLWBQZH4yxVVWOdIb19Ak632t4+sGvR+yYkihOMUkQ64ODoLgfHU6piy/r6IzaLK2ySELaqk1qHRIOUpKmpy5yqrMmKjKKqyFdz0vHQQwxBj146Yr7akm83BEmP7c2CzTKnPxmRxpYiv6G4ekBw5yXCKCAMRxi94fD2PbbXT6iKktFkzOJmRlk1rB+9RzoeU2QZ2mhOj18mTccsZ1dY59hmBZvtlqpuM1w8TGGUImzvzaapcNa1GooNdV21c9vSWM8n8nC89ID63LixreqikrndoBrv4jR78D6rTUOxLYm2a0aHp9y69RLvv/ttBr2U41e+QNDr05scYpKE8+++xerhWxhX0DhLYPy1KSrPiAl9bPa1hkDRWEXjHI3z/HVDg2dHth3HbRdq0MbrQD0N8E3XxqSoaemxqJYP/+Lx/4kt45ybK6V+H/h5YKKUCtoM5x5w1r7sDHgJeKiUCoAxvvi0/7f+FvC3AMIwdAKRSDARmCTLMpbLZSeSJdnf7kIgP+/rvO9vy/M8Zzgccnx83DFger1elwnvipcJV321WnWPiV67QCciuCWMGBHsEmGxXbNt8VaVICuyuyIxIE5PQMePPzo66nYBEvxkIdqXY9jNeHchFaAL0j+sq3P3vAnkI/oyonUzHo+5d+9eJ8PwpS99ibt37zKbzbp6xPHxMVmW8Sd/8ifdgrdarbpGJflsUggWuGr/mPY/o1zjF8Et+3DOi47zeeMvam4HYeDCwPuhlrUCVzM0MbWK2GQ188Wc84sFztUU2QznGq8a2BYLnQOlW8aF8mU15RxW+SBvFRjnqPKMeDhmcnILa2tcnpP2YsLjW2TzK0wQeM9U6wiiAf3xAZvlDO0MgctxqzkuzwiUYX21QAc9osGQ9ORVquZ9FjdzdDpkMB1RzzdsZgvCuEeUpLgwZju7wdUllDWDdMhgegALx/LiEUE9otos0TjGwx7OQv/4mErmdgA0DbPZFfPVzHeHOotSTUsF1dAWE62tfLDXni9uraOufVHSOtkBit6i7pp8VGuK4az1he3Gsd0WxIEjWpzz9j/6CvH4cxy//DIHqd+hfP5LP8vJSy9xNcsoTY/ByQnD27dY5zkf/JOvwPockj7b7TV53VBVtRf0CjTWwqZsGGgIrDccd2Ks4YzXBlKeEmmdD+qBa921RO+9nbq+RqCw1pdRjWv1hBR8HGPmk7BljoGqnfw94BfxhaTfB34Fzyr4deAftL/ylfbnP2qf/8cfh0mCzyClPV2Cu8AhAgsI1rx/80v29rwCK9BlevKYFD/v3LnTvedqtSLLsg7qkbFYLLrmIXmPNE05ODjooJS6rjujZ4GMxGdVJIHFOFrYI1VVMRgMeO+9954pwvZ6vU546+bmhsFg0HV6CmYtGLkESMmqd7Pf3SC9C9vsBvfdICmP7Z4reW5XGfPs7Izf/u3f5s033+QLX/gCQKcAKcf22muvEUURv/M7v8Pbb7/d7W52HZmEDbX7mfYX5t1r/LzHXwTRfByE85zX/4XPbaMNcTLCGUNVWwJrKYuCIl9hbIAKFY2tqCvPsvD3te2gF9dmrcYYz3F3DqU0FkvjI4G3I8JQVxVJb8KtO6/Q60WYwJEvHXW0Ik5H3jgCi8WwXMwpllde7cR52dt4OGBwklBXNZubNbbO2Vx+CI0jjnvEKPKiBFfg6oxtnWOilGwxI4579KdH5I0iHB9w/vafUtYFZVXQbLaE/T69dEQyGLK8ekJ/OCSOI1aLBassQzUlWnkPWOoGjKJxAZX1nbrGKN/cpPBQDQ7b+qo2sttznltiTNhm/boNqKqV3fVME+t8U1hdFRhCMt0wf/BtvvM//xecfvkXufvlnye0FZO4D+EhKlkzOjrg6LNvQpLwjf/1f2H+Z/8EExmqpqHMNuAURQOFcwSm3SVYi3IOo6MWP/cYutPWp/Voj7BrJYZLvj7ToumqNVLX7eLmF3efyfsZ8HH9qZ8sc78N/J0Wm9TA33fOfVUp9V3gN5VS/zXwz4C/3b7+bwN/Tyn1LnAD/NoPe4NdJspusfB50gHydT8I7VIngWeCfnewLXacZRkXFxckSdJlydJwJJCAQDACfwgbRrD0JEk6JybZcexmqcI3l0YdsaUTWqM0Sx0dHXWcemHhzGYzxuMxzrlnsnQ5T5IBS7b7IhhqV8BrP2t/nhnG/s9ybeCpe1VVVbz11lu8++67nJ6ecvfuXcIw5ODggOPjYx4/fszXvvY13nnnna6mcXFx0TVOyc5FdhMyJKPflXzYz8J3P+Puz88TH/skeDs/grmttCGK+q2uSIBWFdZpnIlQTe0DKw3OVTjdXudWSgDrmRFaSwHW3+SuNU82nvyMcoogiOilfYpsxvXFGXESMxqmKGfpj6bUeYFtfHCvsxV1VZBvZzRlSZz2acoMHcTURUXQGzB59ZRyeY3Whqpy6E2FiWOC9Q2xUWy1QquQSmmS0YgkDKnyDcQjFtePIegzOb5FefaAoqo4PDoFajbXF/SnE7S15LMrnGuolcOakDDsUUU1RWNp6obG1l4LHwXKqyQKt98Yg3W+6Ops/ZQOLvNBeZjEqyc2O3NbTMcVShssmryqicIA6jnLf/47XH/vn9K7+yYHL32GOhkRn77E4PQWV2dnPPjdv8v8O1/DqBoTJFyeP2SRFeRFTVNbSutonO/UBUWtFHnd0DjvCWjaWoBox/g+BsBpfJuSQynrW52cplY+4/dNUED3O15l8uO6VD8JW+ZbwE8/5/H3gZ99zuM58Dd+2N/dHxKIdgOyZHnPC1Dtez2T+e0Gqf0bW2AcCUKCCwtOL5CPUP+EnSN8bfl9+Syr1aqDTJRSXV1A4Jz1es39+/efaSbK87zTlBHanwQ0wdWF0ijUTYFzdmUX5LPsB8Kmabpmpn1K5PPOyy7MsVtE3t1ByTHL96JwCXBzc8OjR49QSnU68VK3iOOYfr/fwUhZlnUBXCn1jMTB/mIux7dvv7cf1HcXd3l899h+GCTzo5nbHuNWTQ4Wah3RKG/k7GxF6Tz265pW8tcpjDfhoXH+VjYmQCt/c2ulu0DmtMdkFV4PfnIw5vDkhHQ8IYkNURhgnPdcrTYLys0alMNEid8lGIVJItDgjMZVlqaylNUCW1555yYVkPR6HBzEqCSlPx16/ZkPzsiaiO1ySW1SymxNrzfCVQ3lckOtSlRVo1XA4elthmmCMoaL7Zo4STE6pAx6lPMrqCq0s7ROcgRK0SjA+ABnAWsdSZKicBRF1ma4mrppzUxkm4MkOo7AeE106/WVn87tpsY5nzE3tsG6GqsN0WjKZJhiXMPm/Btc3P8jGp0SDCY8yreYbE4cOEwvIhkOWV5dMV+t2GYlZV1RWY+nb4sKNMRaEQHYujXE9kbZWnkFSNf4RdriWhSuvZ4alJUeVYVyCkvjoTin/QKhbGuW/eLxqehQlcAkLBSl1A90pe5ym/cxV7lou7oyEizkZwmGkmX2+33AZ9ZJkpDnOVEUdaqKgq/vC4hJU9Muq0Q+69HREdbaZzRjpKAoi4DopcuuQTju4B2Wzs/Pu+OZzWYMBoNOkVE6ZiWDlvMkENBudr+/KD5vJyNBfXdhlMflbwvjRrjoTdN0wf3w8JA0Tbm4uODm5oYgCDrdmrIsub6+5urqqjMK38205T2lN0EasOBpd7KM/Yxcvu7WXPYX84+rLfwoh6OdH0XuJXZ1gG0qnK2wrkE537BUC8bqFLaN355GCYHWGKNaM+wAaNrsLsAaB9qgDURBzOTglEE6QquSIDAkvT5VtiKKY+oyI9+uyJb/L3NvEiPZku55/czsjO7HxxhyzjvU0FXvVrUa+oliULeeEGygBRukRiDEAqm3SAgh9Y4NC1aAhATqHaxagg29bQkQXdJb8Loa3qvh1p3yZt7IzBg8Inw8s5mxsGMnT0blvfUQvLrXpFB4eLgfP36Gzz77f//v/791LJLGqTy2KAxQVyXxOCMIQnRUoqzBNgbZ1IwffIg1DSI/kC5PCSxcvb4gaAJMFCFEiDU1ZV6QpjHp7IjZvUesL19jMYxnc64vnoO1hAHsVlek2YJkPCNME0pdE0QBURXSqIZIOjpvq3E6NMYSCEkUh9hW02pN2zQY4ySShZUI6XB2EI43bgxKBSACXN28SwYQaOOK1VJKrDFUjaVpLfPpEVKUHB3NGY3HXF+8ZLs6w0pF9mCKlIa6tmwvr7laXbM/1OS1xgiwQmIsyE53P1KWKBBURiKdrq8L6J08MwxYT8IirWtkcni86qQLpFN89pLOuE5m6/mQ3zC+E8Ed3rSjv4vnPJQheNeNDvxOgIK3b3AfqHxw8SqIvqHJFz2bpmGz2fRSuh7u8SwPjyFrrXvbPK+W6LN9n5mOx2NOT0/7rky/j8fHxz3rZLVacXx83E8cPpP1E4tv60+SpFeA9Dx0j2P74O15+J6O6SmKdyfCIfzif3xAveuZOlTc9LLBfn88+8h3+dZ1zWg04tWrV6zXa1arVe/Nehf7H648/H4Nz9fXZevD54bZ+d0s/+418K0Na2m1BqWQSoLtcGIR0SqDMs6HVOvKlf9k1wuAddmrtQSB89I0BqRoe0KdMk5gShtDg3ZFWK1pq5JsMSFQkiAMiZIEFQS0TcN+s6KqDtAaQjcjOEZPWRMpCU2F1g3ReE6cJE4hMkkIA0lrFC0tbVEQTzIW1mDac3ZVhQ0TEDA/PWK/L9BNzeHiKxYnTwhMQVPviQNJjaEta1pd0+o9tm2IkxGNkbTrW4IoIbGGotS0RmOMC3ZRlKCiiCCOCNuGNi8wxiKF7+C0LtYJV5N486PAaJela7/yD0CA1i7gSqkIoxijBJVpmMSuT0MKxXS2JE7HNFVFMppy+fIF29sN5zcbLrYHmtZiDGgErdG0xmXnSoIMu/vOGJy9ooPZnJSv877tZIJcAJc+YHf0VgFBB8WYbmLyDJlWuG7nbxrfmeDub/Qha8Y/P4Qkhpn88Gb+ukzPD1/U8yJXPkP3Qd23wfvW/2ELvodHfLNUEATc3t724l3z+bzP2q+vr3u5XaAX3nr16hWr1QprLbPZrNd18TICXtnRf/+hgFcQBJyenvL69Wt2u91bzUDDx9642gfT4fEYBuy7dQmf0ftJ4i5E41/r97Wqqp7jXxQFu92Om5sbrq+vexOUqqr67+C35ydPf7689PHdVdpwv4eBfAjDDPd7CC/d/fm2hwVMqJAmIpAaJSLy1mK0RQmn2+05zNY6RojzThUuK8Wdr279CXQ2bViM7FZkjWZ/KCnyksrWhE1AlEtEFNMqRRrHJKOM8XRBWW4xRiNat9pTUiHDiCw7IRlNCALF9uactq5oSsNkfszs5AnWSLZXL0gmI5qiIhaS5OFTRDBCv3zJ1dUWbSUn80csjlIO2z3WlrT1LSJIMOUGKUNMEHPY76GqkWmKCiWnp6eY169oME6XxUqCrgiJNMhAEYUhgVS0dYtxdUZXTuzgGBfInTkKmO5p28EvrtXfTZDWYdtuwQNoB3kZKEvYN5bxbISOYidVvNtxc3PF7dUNeVEhpCJvajaHnKZ1wdwKCFSIbhoEhkgJlIJxmmB0N7l3cVsIi3Hinu6cSj8nddxJgWNDAQjnt2pVVzPHrep0V1iXv+f6/s4Edz98Buuz3CHk8C5Ywd/sviX/bsbvGRpFUfTNOsaYXpBruL04jntf1clk0jfreE9VT4O01vYaM9baXsnRZ+8+UPoC4lD3Jc9zLi8ve0gjiiIWiwU3Nze91MLl5SVZlvH48eMervKyu8vlsj8OftXhVz2+eOu7T32BeBjQhxmzP77DiWAtoKVyAAAgAElEQVR4bO+ujLxkw+XlJfv9Hq01JycnRFHEZrPpde19PWJouAJv5Jzv1kbuFsaHtZV3BXz/++4qzp+br/tO38YQwmHowliMkFS1RkonOKtNC7juUmgR0quIdMMfk46fDm/8NKUIHGukdQ00Vd26ImLbkkYRcRIjRYuiRdmIIIpZnjwgihOK8YKyKBBhRFs3RFFMU5cEWKQxLGYnFPu1w7qbmt3lC+IkI4wipIyglRRVgxWWpiyhrgipqA81+9dfMDs5JRmNUEnCdHHC9volKk4JRxHm8hXJZMb4/YfQWsq6IooS4jBktryHvj5HSggDQxB2yYuKCFQAGNd92rZUdfnWtS0QrgdAOW6JEBJjup6Otw6q6ZgpXjbXTQgqDMjzA1cX19SbDaKpWN4/geQ+1+vX7IuSqm253e1cwdcYGkPP0mnaDhMXjs8ee1aPNd25dQVca5xInFtrePesrjjasWHwGbt1tE2EQknTWTOCtQZhLNIOvtY7xnciuPsb1euk+zFsaBp6bL6ryHbXO9W/zrf+53nO/fv3WS6XLJfLt7BsT2H0rJY0Tbl//z6r1apnvnhM319QQ7XFy8vLfv99e36WZWRZ1nPrvRyCn7i88Nh6ve7f6/cTHHtkvV73TVEeIvJqjr6T1vPHpZS9MmWvwWHf9AMMA/rwbz953j2uftzV9/Hf2dcWVqsV0+m0L5oO6wDDMVyB+YnJT4LDlcJd5svXYedfh6X3N3v33b7t7F10RbS21RR14YqfVhCikFZjhO4KfN1kZb0JQ9dsIzrGlXCFNYujLWINumnY5Qfyfc6j+084XmQsj44YTcaMx2OiJCFOYwIZYq0hnSwIx0sWD37IZnVOsb1BhQmBjFDSmV0LKQiVom4bimLH9vUZVkJtSsIowpqQeJIQTyxVWTEfT2C5pKxaqqpGBIa8OBCNBIebDQHu+5U3r6l3lcORq5Li+oowSmmKApO4JqDoeEmYhhSHNa0R7HdrqrYGFVMXBXm+p6xKV0y1g3MtBUrIrvjsZB2QAqN93JAY668Fj1zjBL6igCCMGI+n6LpiWxRoG1Lsc766PZDN5qwPB0xpaGVAaTyd0ssBgFQSrV2/qJKSUAqkv/6MM7v21EYpXFXAwSxOWgAvKYDjsTvBONGd844R48g/3fUj8S1c3zS+E8Ed6HHkw+HQY7vAW5ndXdx1mM17+MDf2D6TT9OUR48esVwuee+993oetpcf8KsCXzD0TBilVG9a7c27pXTKiV4Bcb1ec3t7208ink0SBAFVVbFYLDg5OeH+/fvUdc3z58/59a9/3cMVPqufzWY97TLLsr4Q6nF/IUTfrdo0DcfHx71evIdqfHC9q+EyXNkM9eD9sbLWvgVD+QlgODF4j9Q0TTk/P2e1WvUKmVVVcX5+3heWPYw1xO/9EMJ1Cfu6hS/+3jUnf1dAfhfbZ7jd4WvuBvhvu6gahyFoQV6UhEGIMoKx1pRS02Ccrrf1ocJBDdZapzQiJIHqEhhhEUIRKomywDTk3pNTFstTHr33A9778HukYUQ6TjHColuBMAJoMXVB0zYctltMEDFaHBOlKVHshMKUErT7G/L9lrpYk9+cs7m+pRXQtDFCBKTZETJU1GXOdHnK5N6M+cOnPKwLll98wed/8Uu2hxpTV+S6RBcVZpFh6pzqcCCZzglbB1OYsqRqHUOmydfIUNLWFbOTeygF6XzBxatz9rtb9us9Zb6nqkpMxypy17Z7f6AUURQipXLwjAWhnKCYv7axYITq4JrOU1VKRqMx2WxOlKasNrfc3FwQhzHz2ZKmOnD5+rVjquiaRhtCCVZKrDWOhSNEPzGncUgcBOi2JpSWOAqpKtF9HggDDIKy6DjtCIMVHVZjO9IPFku3vzgJAylcI5uSsgv+uGrz14zvRHD3mbD/GVrt+QB19/XDx56/Pp1Omc/nfTOSD8LX19c8f/6cKIp49OgReZ5zfn5OkiS9cbWnKPpsb7vd9uqNPkP22bKXFXj06BHvv/8+ALe3t73Al2/Tj6KIyWTylmDYz372M169ekUURTx//rxvUhrK3+Z53vPk8zx/qzHqbqY7LHz67H5YZPXH0Pu5jsdjhBB9lj9kGg2ZNX747li/qvIyDFLK3kTb4+pDmQE/fJD30JH/7c+bnzTvwmpDZs3dLH74/7vXhN/eEKb6VoO7cDomsQxIEVA3SCsIbMDESrRSGKGdjRrODMMIl5kLJGEQMo0TFpMJ88WcZDTCYLnJa/Ky5fX1jhfPfkUUHPHg0Q+oDzdcn9+SxiOmsyWmnTEaxa5Qag2GlmpzQ7NdIYQiN4bD7pZqn6ONYTRdkEyXjN97wPwHEcJqdjevyDdrdF1w89WX7A5bVvGI0WRBmE1AK8LslB/+rX+Nm7PPCeKQ82dfYIOI5uaWojXEcUqYTSh3OU4PBg6HAwQR5aFCWwu6RbSNow2akMAKpAicRK8xSKUIbCcxIN40d6VRQjoaMxpPEMLpzORlDqYz/Qlkx6zxrfuOsaLCEBVIdNvSlCVNVVEUFUJGrG5W6LZ2CpPWYLSmtYLQQ2ddkHVFX1ewbbUFJZAyQAUSayxSKghjl5GbBu+LKwR9vcVh7rYXBOukaOiVIgX9/6xyk1KiZNcG0XztpfedCO7wJkP3sMaQ53z3xvXMkCRJyLKM6XTKYrHo5XSvrq560Srf0n96etpLzXq9mvF43GeceZ73Qc8zWXzxz2e7Hjq5vLzsi52e9nh0dMR8Pufp06f86Ec/4vr6mi+++AJrLa9fv+49R4VwmjVPnjx5i0p4dnaGtZZnz55hre33LwiCvgHIB9n9ft9PGFmW9RPZ4XAA3mYY+cCeJAlHR0csl0vSNOVwOHB+ft7LGw/ph0OKp/89pC96xcnhuRvCMH6CvjvBDCUHhqYsXgDtXcH6mwLzMNgPP2sI7QxXKt/GELiMLa0141bi7v/A0SO0CxCm0wMUQhAAI6WIJxnxZMpovuR4PqUtC253OfXlDXm+46vXr92ELyX3Tx5yKGusdQElScak4xRtDa1uyHODEIa23FPuN5imom5aV8ALQ6S0tGZLvt+yufgMXWk0luKgyY6PmR3fY7K4x9H7j3nwUcB+9YrXn/05mJrbrz5nfXnJ5dUGo0LiNOPeex8wOX5MPB5xc3HOzYuXaDHi8rPPMBbSOCGdTJBhRJHnVHWOVIpWa5pDQ5xmRNaQTKY0wk0+h0NXfxA4iEJKlFQkcUKaZMyP7zFbHjNKxhzyHRevzygOOxdEraEWDouvGmddp7WrymptQLfOfFyCtobdftMBN66o7S8zi0UGUadtYzpRL4EKpVP7NIa6KomURAYCbSGvajAdVRKD6GQDhHUUSNNBLd4AWwuXyYuux0EgMKYzQXeuHk46WkiC33Ntf6eC+3ApDfRt9n74IDUej8myjKZpuLm54erqiuPj476Y6TPZ4bY8ddEHO2ttDwX5QB7Hca9q6CELeMO7Pjo66tUZD4cDdV33jTyffvopQRD0bkrz+Zw4jjk6OuKP//iPWa1WfPrpp7x48YLtdstvf/vb/jN9ncHDFT6Y+8nDT3S+u9VrsXvJ42HB1BeLhxo9d4W5/DGYTqd9163P+odMGp+Nl2XZG3L77d5l1gyD61DUza9A7q46hn6yw/feHXchl3dRHYe4/BBW+q4wZjAtARItFFK3hAICIWkxBAYCA3EQEKUR4ywjmcypmpbbmzWXV88ojmYEUdj5qnZdybITfDUO5hiNR0gliZMpStdEUQy6xLY1bW0IkwilJNlkjlRd9mhtZ9qtmB3fI19f0VQlxX5HXVdsVtfcfvUZr37zz5BRQjpZMM5OmSyPUOkR45P7fPAvvcfu6ite/eYXvHr+FdvNjs9/+8+oakEUp9RlgRWCtAlo9I5DoWmqlFZYykPuGCsGyrwkjGLq5oC2NSqWBFGKQqGEQlmLNi1xlNDqFoxBBSFKBkgZOFpjl90nUcJ0NnMm3mGE6aSUK+nKmI3QGOtg0bIoSJIRTd3SttrVMrrA/ebaBobXtnX0xyAKnCOSdhOAMQ5bj8cBQknKuqUxridBCm+v0WH1HXyk6GAiCdZ2Op+260TuIBrdTfxKdGwaY7DKoHvHpneP71xwH9L7wGHxQ0xda8319TUXFxdvBeVhYPAZv4c4tNbsdjueP3/O06dPOT09dUubLvP32uPDoDnMRr3uTBAEPY3RZ9BXV1c8evSIuq57Ryav677f7/sMNUkSTk5O+MlPfoK1lj/90z/tpQs848Xj4sMCp99PTw/1DUGe0+6PwTBTPj09Zbfb9S5KHmsPw5DFYtEbn2w2mz74esrlUG5gGKSHxdthhvyu7HkowHZX08Z/jq853O1KHrKXhtv1426Af1cj03BS/raLqq4RSaBECEqh2xqvHROHIdM4pNElVkCjLberG6rLK9qmoWrcClPIWY/t0kkVZElEnheYVnPYrXn5/HPee/o+9+9NUKIhiTNGk2PiOMHqCl0WaB0QRB3LxrhrrD4ciNIJwWTBZHpCmCY0jSY/bFiff8XJexvaMkfvC6xuOZQHbl/9isMux4YpgoAgnjF98Jgnf+Mp1rb8+T/538i3N9RKIaIQ2TZESpIGMWW9gSB07lSBRaZTEqGI04L9viKvayZRTBQGNG1N07Y0BlprQQQc3XvEbrdmv9sSWokKE+ga+yaLY5LJlKDI2WzWxEHojlsYoIKwa3JqURW0bYPFYefaWA7bW9q2cMFTuCYnT190mHdXg1IRCIttnNa8NpYOUscCoQJbtxRC0BgnKBDgoBYpxJss3QrXsGQ7yot9k7EbXxMTXdYObkLpVEAFxj1vvrmP4zsR3Ic3pw8ww85FX8T8uvf57HUY4H0hEOhlaD2n2gfRIbPDY8tD3NgXMP2P567f3t5yfX3duw/5YHt6etoXCv0Ymkp7vfnD4cBms0EI0XuwpmnKfr9nOp2Spmkvcfzq1Stubm6YTqfMZrNeRXE+n/dBdDwec3193Wfl4/G4n9D8cQyCgPl8zmKxYLVaMZvNWC6XfV3BB01v6uELnZ4BVNd1L9XwLp0af8yBvmFrWAQfUh39RHOXBTXMvN/FlvmmQuvdArx//K0Hd+vd6iEMIpQSxDIkUpZaQ1E07OpDx6cA0dmsma4pR6kQhHKCYdIijEKKgCxNEAtI44hsNmOcgbEHRLREBhEI1cEHISoIkaMApSvAoqRCBYq2qdF1hW5ymlqDFWxvL9muzqmrkrqqaIuKMEoZPzilaWEkBYjWyQDsd5RlRy54+Rfsf52T71q2uy1IRbXbEgYB4XjMfndgvFiQpGOyoyVtYzk/O+d2dUs2XTBenmDrKyJhGC+PCWSEUIbxaMxGSOc1GijGoxHoiny3dfZ6QUCkAqaLBdPlCdvLS0bLJdOjUw67W4QMkURYe8C0AVpGECnCWlNrTRCGtPWBOIqR9o3Yl4u3TmYN6/nzUJUlUkmktS5Tl52CozQoIYmVJQoFlpC6aTG2Y9EACumcmBxXE2P1G613C64lzbhiuRcPkx04Yx2sY6zsO5e1/d3ekOH4TgR3cJAL0MMAPhMeUvWGN/jwS3k4wTfFeGMMz3zZ7XZ9g83JyQmnp6e9+5IvFHp3Jg8F3aU/Dml7wwKg14jxj70mu/ciFcLpzrRtyw9/+EOqquo7OLfbbW/+4TVZhno6s9mMLMvw+jZep8bvG9A3E3lZgrZtWa/XvS+p/w5DaMfv21BszTceeZjIQyp+ZXA3U38X5DEsZt7Fv/15GmrqD7H2YZ1gONn4/XxXgdVfE8PPH8IyX7eff8ghEIRxipKKqBKUVUFeuzZ9bSWtcM72SOFMJoST9HU63o4JooQlVZLRKGKcjRGRU27c7A+sdyWX12v2+XNOj55wcnqKlZpQGdq2oSly0pG7H4IwxZqaIHANQYFUyFGLkE6jrDUgZECoQoyAMj84Joi11Ic1+fUlum6JRymttUgZEMdTKh3y8KNHtGXF5csvCdcZh82a9e2evK6QTUMYBLS6ch/StARHJ8STMePgQJIKbNuwv70ljFICFSCsZDSdIYKQKHT2gk3bsru9ZZSOyJIUVIQIw472aKnLijDLMLpBBAEyTBASR5OsS1QywlQF0hrCSNIWDW1TIaXFlobWzae+QwqLdBl1N5xfiOgycN8Q5byTAqEYxZJQuOt1X9a0XQetEBIlu8xfKETHe2yRGIfLuI5k031K19gkB2RH3+gUCOvUQKUTP7Pf0KX6nQju/qb1PPBhq/rwhh1miP6GlVIynU559OgRJycnWGt72MZPEJeXl5RlyenpKUmS9AVLb5zhg9hd2qCHTKbTKV6ywGfm3rnJ6+ForZlOp5ycnBCGYU+h1Fr3rfir1Yovv/ySFy9e9PuslOLq6qrXg/ESwUEQ9BnwZDLpqZt+f4cUyc1m068+mqZht9txenraUxe9h6mnVk6nU6SUnJ+f99ILPqB7JowfHoLyBd1hsftu8Pbnchhwh+8ZTsL+8d3C6ZDGeBc7v1tc/31B+y9TlP2rHkIKtNXk5YFmv8Mapz1eipBCKRqpMdbJ0FrbmTVYx8SOpeVknPL00X2Wp6doFDerW24urjFlzqHIeX11Q1GV3D89RaVjNIJxkhCECaN0ShCFmKZGWwgFiCBERgmogDCISGenWKNpqhbdVkzmAXVZsN/c0BTGNS01EGYzpic/QoUJ4TglSBK0aTjcXrK/OGN//povPv2EFy9eks6nnD7+ACXPuL64RiUxtTEc9jlxFBCGEpMfSKQkHU9QowVGBkzHMSJMMI2hDDW22FPcrrC2IlQKXVfs9xuWDx5xMh6zev2SYrdmj6SqWxpjmcxmRAjWr16ioogojp07E1AXBVIqWuv6CcI4om01dVERqgCsQElFY6yDXvpr250bIWXPp7fCErhWYoSUhEoSCkkcKIKOex8JgaR9I5EgRdfM1CvgYIzolndugre4x7ZbuQkc5dFC594kEFY7DF/w/00V8g8xPMfcZ+k+U/dZ8jBg+MzOc9WzLOv51r/97W97bXQPJ0RR1Csl5nnOL3/5Sx49etRDFz5oeTgEeEuaFui1Wvy2syxzFKw0RUrZQzZD7vqrV68oy7LH6d977z0+/PBDPvzwQ37+85/3E9eTJ0/44IMPMMaw3W75zW9+w4MHD/qA6zPdKIpYrVZkWdZPTD6j9o1P/pgdDgcuLi5YLpdMp9O+2cibhTx8+LDXs/eSB/4cDOmnQ70WT5P0wwfhuzDIMOP3x24YZP3E5yfKIQtnuL0hBj/M2ocsqmFw/zpY5tsexhjqpsZag7Wtw78F7AKJVQHSqE6t26CkIEISxRFxlhJPpyynS4rK8NuPP6OtK8f8MIZYScIkYZTGGCE4HEp++3//kgeP3mM0XtJqQ1XlKDVlPFsQjcZgJW11wDQNbbGmtaZPKuqqAWuJpxkq1CSjgEDOqNuasqycIYZuqetbXr/e0uQWEaZMZzOOPvznWf4wJfvxa/T/8Y/QRmEN3HvyIx5+X6F1y3a75dNf/ZqjB+8RJjOKMkekkXNYSkJurm4IJ8cE6QgRRui6phGafVFhrDMaabG0+w03r14wObrHZLqkPmxZXV+xXa9pm4b7j97j5NETwvEIU9dIFWK1RXfuX4EMaeiol51eS6011mpnWydEpxYsHRXRuiIoHXslDLr+DSAJQ4QAiRMviwJFmsYUjaXSNdoaIiEJhHAm2JjOnUm57lIhkcrl6BiFNKaT+DX9ZwqcqYfrgxBd16s36+sok18zvhPBHegD492MHeiDfRzHzGYzFotFz1Q5Oztjt9sxnU6B39Wc8cHKZ8EvXrzg448/5uTkpNdY98HbS/N6yCNJkt7Qw68CDocD6/X6LcVEr6/iu0P9803TkCQJ2+2W8/PzPhB7uqbH2J88edJj0HEc9+8zxnB2dtavOA6HQ+/eJKXzcB2amvjvb4zpDUS8ds54PO47YIui4NmzZz3MNGTneKzdB9gsy3rJ4XcxZIarqOG5HNoV+nPgayOeejpUgvTbG8IxQ7jG10GGGP6wcHoXjvHPf9sB3lqLqQsKk1OGXQZoG4yQSEKMW2OThYrFJGNytKRoDDc3W66eX5HPcybTMVYIQg8TGAlKueJgIKjKEq1qvvrqU57/+v/i9PRPiI/vEUcOqjNtRbHeEcoAGTjGRZiOSNMMpUKaukSoHc3ulvx6hdWatqkRUtAc9lSbDW2+p6oriqZBqghdtcRJRsWe5y8/wcqQXVFSrg+8Xt3QbLZM5lNO3nufMBghaUiilKZpUamgtZbVVy9Y3HtMkEbs9jnjo2MO6xsKEZJO5+i6dKYX1qKsQiFpreFmdUljLGE8Jgi7+kNeUuUbynzPyy8+weoWbVuqg6SuGqyBKEpoqwKsu26z8YTNdo3RxkEiwmBN1wlsLUr6ANvVPDHUbdc0JSHwdSQpCANH02w15HlJ2/fqdD0pBrSQKDqJDOF0+52hl8Eqp/7peO8K19dqO8ze3UduQuhsP7Sg9ZPA14zvTHAfNtAMb2rPC/ec8NvbW87Oztjv931X42Kx6G/iIdPEB6EoihiPxzx8+JCf/exnfPTRRw4X2+9JkqQPfj7Qe32U/X7Per12RZtOlMsXaf3neBlez6LxXatey8Zvw9vV+UKvL6aWZdm7NGmtexlgvxpI05Sqqliv10gp3zLw3u12bzk0+cKnp3cWRcHx8XFvEuJNrn3w9u5RQjgVS0/J9OfCrxjgTbH064LlcFIddrt6No5f6fimLV+c9tu8G+ThdyGeu8H+bg3Av+bue79NWAagMSUWjQk6LNWGSCFRGEZZxPLkKdF4zPpmx4uzS3aHHWWjcZ6pU/fdjKARBnAwjrYSiSQNI2ajhMcPHvA3/uW/xQ9++s8hg5Bqe4NKYtRkRjrOCKMjZJKgq5xmc02br9leXyLDgCCKUUEA2RwlLLZtsFh0bRBRRry4RxSP2Wyu2K9uyMsKqor9pqC+3bIvdqggAhWQjicEqwuuiy1lteGwuUKlEVobZtOIxX3Xjb0u94SjiLbYs6clkIJyn2O1Rkoot2uqMsfoEiENMlLIWiG0oW4b8iLn0cl9kkiiD3tsYhFBRN0UUIHWLUmaOm57VVBWJdSg25LWeJ+GxPHNO4okxpe1bVdUtSgcawULGqfAGTrSOTJSBBhCFRCnEUmUstnl7Jumy/Tde1QHnQiEg8CEQFrlJChEV5SVblIJ3eyPts5+rwXX0NaJ3VtUD+k4PL/l68Z3IrgPA/FQ5/v4+LgPdGdnZ3zxxRd9Y5G/sYfFt7vYvC9mPn78mOVy2TNvbm5umEwmPRXSG2Hv9/u3gprP2j3U4FcAfhXgsXYfSG9ubnrDj4uLC87Pz1mv132mnWUZ8EYR8fT0FGOcL6oxpteg2e12zGazvmgL9KuCzWbzVpAGevjJNwf5Y+MLtX7i8cF8+B388z57H/YIHB0d9YVuf46GnPm7/PK759Rn234bvm7hz9swc7+Lv/vHfpIY4vzD4qtn9wzH3X35doO742crWkKlQITEEk6Pjlnee0LVWF6enXH57BOa2sn+og0M3YOscHxqFC0SaQ0SQZrGPHzyhPT4Ebo1FPuSw+WK+TglTqYkWYbMptSmpdqvkVvXrKMSJ1EQSIfhyiDpajw5dXmAQDmed5tj2pKq3LFfvaYo95SHA5vzr7h+ecHmds1uvUcqyzjLMISgJJk0BMdLGqvZ3tyirGU0mVM3LfttQ7I4IgwOJDhYo8xL6jJne3FONEpQYUxTN2ANURQQhSMaVRKGTnIAC6Y80NY18fQBMl2BPRCmKVVZ0RY5UgXEyYgWS5HvXKMUgqbjsC+PjknD1GHW1nTdpIJQOl9W2zUZCc9ckRZpnOW2MQaDJFQBWShR1mBaQ02DxunO11b3QVjI7jzioBjhFNzRRmM7i70uwUcIZ9whkOjWEBBipMHb7/lymAhAdUqXXze+E8HdB2Gf6WVZxv3792mahi+//LIvjt5lRsAbDP7u9kajEY8ePSJNU25ubvj5z3/O0dERf/tv/22ePHnSa5Bba1mtVn3x1Btae71yD6X4QOqDlu/iDMOwb1ry9QLfVepx581mg7VO6reu67424IPen/3Zn/HZZ5+9FVy9AqUX6/LmIX7fvD6ND86+WOoxbiFEn/17DNxPnB468mwhv21fuL29vWU0GvHgwQNev37dw2XDzHwIx/gJ1bf7G2MYjUZvnRvfr5Dned+YFUXRWzDLXdmA4RhOFv4z4Y1j1rDg+q4i7bc1pBCkSYYSmjiQZJOE+/cfUFeW5198xeryjKJpQMo+GLQ4XFUqiVCgO3aFtIYAQTRKePj4PvFoyu1qzcf/+z/m5GjOv/gn/zr33n9MNl8QpCMwsL18iRKWMFKEcUKYTImSlDhKEQKawwZdF+haYKxB2gZbVGhhCcMYOcmYLo7QrbO0E8GIotjRtjVWBBxuLtEY4sUjygae/+YXmKogiDOEsPzmT/8Jzz79lKJuQUBjIGlqQqmJs5hKW/Rmja12qDQkGo0ot3vqpiaJEnTrlCetbkhCSYACIalbg8kPhGFArRtUGCCkpKkKmjonTDN0W7HbbSjbktF0wXiUsbu+IB0lPHzwgMtXr9CtxnQSwhhnxS2F8DiM45pbSxi4hEZbGI9iImEIpMPagyhEKsk2b9kVNUIpYikRViNwrCchBIFwhddWiE4wzPHgQSCNRYlOHkE4nF1FAUZbhFa8cV5yXHeFwKhvvq6/E8HdZ7VpmvY48qeffsp6vX6rkDfEWIe0xOFN7HF5b/vm+d8PHjzg4cOHVFXF8+fPe0zcd5X6Vn8/PMtlmDEOlRnTNO0zT/8apVQvgbDf77m4uODVq1e8fv2as7Mz8jzncDj0UI7nsw+Ns71crze+UEqRZdlbqxMfwL02jG++8oHNi3N5Sqnn0fsJx9cEfL3Arxrquu7NQLzE8FCywf8e6s0Ab2Hp/hj6iXr4OmB2PzUAACAASURBVH/Mh9sZvn64CnvXhO3HEJO/2317F6+/i8P/oYcQkslowjiNGc9GNHXJJ588Y3+9xbYVrWk7ZoRz1TTG4b/GWCKpCFAOIpCQxBGT+ZRkPKMtNburZzS25t7jY04e/oCi0rx89gVSBpimppEwnYwYjx3Dik5N0eqWw/oSJXHNTEJgW41UgnRxj+jhglrXIBWBEA4bCAPasuCwXVNucjYvb1idfcnVq694efaKQ16yKw7oqiAOAuJxymI5I00Vy9mYqjWsi4pqt2FUtySjMUkQkI0nSGtprSKWESpOCI0lr5zJhqkKrC7d+RcBcSQIo4CybND1ARkpkjShyCuaxpEeROAg1DLfY7Vmks1oqoqyKsgCyCJFEkUUZd7BH12BHkdVVMHATyJUBEJidEsaSKwQBEiiMCSSlrYx7twpqFvd1wgiJRFB4JQgJSjpmpOMACk74TJwE0gnHoawWKswWjizD2lAujUbWmKspoWuAO848eK7jrkLIZhMJpRlyYsXL3o6pIc8ho0uQ0aNz+SG3Zdeh71pGiaTCUIIrq6uuLi44Pr6usewtdb8+Mc/7rNVn0UPi7geJ/YQjS+i+sKq3y/PpPGuTNvtttc3981XvmjqJwe/YvBshYcPH5LnOb/4xS96yz/f8Qpv7ACHBV+vJLnb7bDWvkXh9Fh5WZZcXV29xYIZ0hG92Yjfhl/1PHjwgKIoet12eIO7e2bNXYEwf7y8nMFwEvOQmP9OQ9zcn79hAfZdq7RhIfXu64ayE8P3fNtDCEE2HaPLLZfPnlPUNY0JqW2NMQWtMS64dsyN1riOSYslkK5YFwdO8z+bTiiLnLauGS2maAWHi1ecX5xztSoZ/wsxVbXHGMsPf/xHTJdzovEUlSYIa5DCmX/YpkIGgjgeE8QZ0WhCqxt03dDkB4r9HqtrEC1V26KrCpWM0cZw2F2x372mLC/Ii1couefRe0uCKCJQgsV8SSMsVzc3yHhE2xqWT55SHEr+4v/8BXVZEU8nHMqKQlgmIkBFCVFqIAhRKkAxo9KaMj+Q77dIowmURISKQIaEYUIrSvZlxc3FJQEhkWiphUFKRRgEKKmoq5zpYkmxvXH8fiHJRinHDx+Q5wW7Q0Fj3KSqhJN2MFpTWydBLHCa6UoJIqXIkpBIgdGGtq5RaUSaxtQt7IuWfdnSGkMgwVqNMBYRQBBEKCk6/B6kMDhhduVCvPVIPxjbOhMX86ajVSnHshHaQXRGW6x0bk7fdJV/J4K7tZaXL1++laEPsVU/i8LbRTXfbLRYLFgul29lvN6g2tMRf/KTn/SBHOhlBpRSXF5e9sHFN0D54p9vttnv929JIPjHPssdj8c988SbZadpyunpaa/26KmIxhhev37NxcVFPxHM53PCMOT4+BhwTJ2XL1+y3+9742yv8e4btTyzxuPsPvgNG8Hquu4nIg8nDWmcQ5kBr6jp6xOezjksWg6Drg+ofrLwqy+gl1r1lFQP3QzplncZNf75u/IFw+vkLsTiV2/D/fHUTf+eb3NYa7j46jWYAiE0tAmhCClkhVUBRreIToIWIVBIjHRQQRyFLJbu2jatpmoagmzGfrfj9rMvqaoCFUT8+K//TSbTlHQcOwZHc0BFKTaIub48JwoUoawZj6eoKCJJM1QyRqiIKs8pdzeoIHAdkLpFyRBDSxiOIDaQZbTGYvd70jhltliQJCOW9x6ikoxwNOdwu8G0NcZYrs5esXr1nM32jN3tlslyShgLjk+OMEIQpSnl2QXNukImcwfXtA357S3JeEKaZWShwAQJdeAsAaVwksiNhsa4WlJbNzT7FbZtMAJ0XREpSNMxQkrqusTULcrCZDZlMhoxW57Q6Jarl8+oyqK7PgSm6w917f2d4qRwOvFRYJiPEsZpgrSaqqgoWotuWkwoQUpaLFXbghQEShAr2zdQBdairEAGdPLNDnbU1tLLw1iFsoJWuJWcRrn/dY4c7truOpi1dROH+eZV6V86uAshFPBnwEtr7d8RQnwA/EPgCPinwH9gra2FEDHwPwJ/E7gG/q619stv2vZQlXHYEepujt8VhvJZ33w+5wc/+AHT6bQ3vfCNUD4Aew2W0WjEw4cPefr0KaPRiKurK16+fEme5z2M4yEPn9F6Jya/Lx5G8Pvg2TVA38zkP288Hvc1g7OzMz777DM++eQTNptN/50XiwVFURBFETc3Nz3eP51OmUwmeM/U5XLJer3mcDj0OjdeudJn60Md96G13d0mIu/t6gvCi8WC7XbbWwVqrbm9veXi4oLb29vfaVLyKwQpZR/Igd7w22ftQ3XP0WjUs3H8hDxcPQwFyzxc5AP5MMMf7sPguuzf53/7z3iXacgf8roGMFrT7HKHpwYhUkuUMEgb0Frh3HVsp9Xt1uhIq1hMR3z4g+8xnWZsb26xUlBVJU3V0JiWQCmCWBEHMVkacf/hEx6+9z3SUcrm8ivOv3pGkR8zn85IshFSaESSIJR0RdN8RxAokK5jUomYMAjRCIQKUUFGEEZIa2mqggCLjRKCMCTOJlSN4dWzjzn/6jkvP/7HPPvNx6x3GxAG3dZMjk4pix0yjbi9uUUlKVESMptmjCZT7t23bDcHpscz9rdX1Nsb6qImHk8p92tqbZ0wWBhTt61r7DENbeNWN0YIlJQIawh8B6gxjLIxUrlMfL48Jl9fsZhNmZ/cx2jD7e2eq4szVrc3GK074wxXz7BCEEmFUJYsdWJlwsI4DlmMR8gopNWGSRhi2IEKiLMxptLkxcExaTqzkCBQhFKhVLefdIXSjl5Jx3e3xtJal5EL6+iRjlHlmpekAIXCis6W0TqGjdYd/PgN197/m8z9PwZ+A0y7v/9L4L+y1v5DIcR/D/xHwH/X/b611n5fCPHvdq/7u9+0Ya+D4oPrkH53V7LVY8qLxYLFYsFms3kLUhgGBR+A7t+/z0cffcR8Pqeua16/fs1kMuHk5KTXnPEGzz5w+MKlD1DeYs5TDb0OjYeNvDVfWZZUVcV2u+Xs7IzPP/+cV69e9Vo0QN/l6jXfl8slcRzz6aefcnV1xWKx4HA4kKZpn/EfDgekdGbUPmD5oqqX+h0qLPrj5xk9YRj2E8lQVsAH+Ol02nfLeqqi354/7sPsOgzDvpnq+PiY5XLJ06dPefHiRS9tPJ/Pe1bPXUx82KzkA7w/b/C7AdzDcUM8/usame7y4b+t6xrA6IZ1cYOwijhMGKsEq1wnpFQKaPD1O4kkjgJOj44YLx+x3dyQ79YY62zkjHCSsUpKpFQk6ZQH9074az/5KZPFnKY5cP36nNFkwfLkEZPphPEocVl6tUcagZSCKEmJkjHCNggpCcIRh8MWW7dY3RJai20L2jrAao2KM9LZMXWxp6wryvUN52fPefnZL7n+6hnr6xW5XmOlpq01oRSU+w1BHDM/vo9KE5799mNuL3YUy1Oy2YF4lDEaZZQ3N9TbA4mAYD4BUwOafL+hbFrKwx7QHGrnaiSEdNK7ShIEEbXWJIGCMieMQsJAoduGVjdIZVguFkymc2QIN5cr1vsN+6akbBuMsWDdtqS7gAiUIAkkWRQSh5KTkyXHiwkPP3jKxRdfcnXldHMW8ykiDClrJ93sqYvGWHRXKI07WV4ZuIk7RLpuU2vpNMAQgUAZ63RijCAQHWHAOqcm2xXXkS7Yqw6jl8JijfrGLqa/VHAXQjwG/k3gvwD+E+Huon8V+Pe6l/wPwH/e3QT/dvcY4H8G/lshhLC/5y7z7A6PXd9VegT64uLp6Smr1Ypf/vKXfRfm3QnA0ymPjo746U9/2htft23LfD5nPp8zm804Pj7GWsvNzQ1ATxv0gdUv8T3jxcM2XiLAa7l4GATo4RApnUyw58377lLPXPEYdJ7npGnKRx99xGq14vLyksvLy34VkWUZYRj20NNsNuvNtn3z0bAOMZwkkyTpC7CeXeOz5qIoyLKM2WzG4XBgtVqR53kPHw0ZMvA27GGtZbfb9ROgF0PLsqyndM7n876wvN1u32p+Gm73LkQznAT8+fT/95OEf/7uNTR87CeBr2PL/CGua4khYce+DSjbhjpsSePYNakIN6FZACWZjSbM7z9mdbXi5Z//gtPFjMlsDF1QFwhCBIEVREJxb7Hkx3/9j5nMZlR5iW5bZtNTposFs9mU6ek9hJFsrs8IbI2aTQjjMUkyJh6P0YCpNfntFWCIsilhOHZSu2GEblp2tyuqMqeuS+eZWjfUnR7L7OiEps457DbMxhF1DE1rEUFKnhcUeUuy3TKJA378k4+4vrzl4uqC1WVOFOaoQDHKxoSxQI0X0FjixT02l6/BtLRVRWuhNS5bdym2IYpjoiBilKTEYYwQkqbekcaWBEOrFHl9YDRZMJ3NyPOC/co18O3WG0rduM5Th4o4+WDpNNMNBo1isy8YJwEnRnDYl+xuc5JsytPZnKaqmS4X5LuC84sV2+0Ko31BtAvMGLSyJMoxZESHuRtjaLEY686nlJZISldEl9apUeJme4mbyNy1ansJAqc1JlHi/58O1f8a+M+ASff3EbC21now/Ax41D1+BHwFYK1thRCb7vWrb/oAT5XzWulVVfVStx4K8IH3yy+/7Jt53sVxllIyn8/5/ve/z7179/os1GPV3klJKcVut+vZKndxWp8tS/lGdnc8HpOmac9WKYridxg7vr3es2F8Zu9lAdbrNXVd9zZ+4/EYgC+//BJPCx36yXrGy/HxMcY46V1jzFtZvC9SDpuJfIbtA7G1Tjrh3r17vRyxL4B6x6q7EhDD4+q36aEXvyq4uroiSZKei+/18kejEY8fP+bevXs9x9+bigwZT/DGgBt4iyHlx7B47v++m7kPJwc/fg8s81d+XWNhKi1R2LKtNbuypmgCZ2CtZMesUMwmM6Ik49UXn7HJdxgDBBIju+YXK1EIlFDM51Oe/rUfsbz/hKJpiKuadJwyzpaMZgvGkzlSBlSbHXEUMl0cYdqDw6WRaBGSH3Yo0VFPRwlSBqTjGdEoAyFp8gNVsUcqg5ASrHTaKklEXRcko4Tp0QnW1CRRzMkhZ/X6nMP1lrppmM/vI7MJaTbBEvDq889BCsZJxL62FEUF0lDULSoMmZ7eo9U5zX5DC0xnc6xZY4XGlq3jgwfKmXZb524VhhEWxWa3RdiWSTbn+N5DtvkOGUjSkRNZq1crttcXtBq0rjFad0GyU1wUjpaohCSWAbZ1/POmNVxcXZPFEYeioa0qojhBGE04Oebo/Q+YPXxImp1h+A23ecXhUKC1K3rqzvlJKkkUKoQVaO0gJmMlwoDFySqowGlGStGZahvbM3hAoDztUVussEgE7e+qY781fm9wF0L8HeDSWvtPhRB/8vte/5cdQoi/B/w9/3dZlj3X3fO2jTE9jDCdTtFac35+/pbI15Ay5//2Wi4+CD548KBnvKRp2ksCVFXVa8rMZrNe4vdwOLDb7frs3BcGkyTpISQPrfhteulfT0uMoojj4+O3TLifPXtGkiR8//vfJwxDrq+v+fLLL/nVr35FlmW9wqSfRLzui/dGHWrADHFvn5H7bHfoR+qLvNvtltls1vPx/THUWrNarfpAe1fOwH/mcPIaUg0nkwlHR0dvTQjeVOT58+dcXFz0OP7R0REfffQRl5eXvHjxotehH3qtDieou1ISHsLxPPjhZ/rXD6G5uzIWf4jrutv2W9f2bSNYRBYZQVM2FLV2VMc4IA4gm83RLVy8/qqjRhoQEVIqMAGiw14DaZnPxtz73occtjmi/Yrl4weEcUA8HpOkE+J0zH6zoS0OjOdzovQe2XRBEJygmy31/pbcaKIoxIZOz8Q2DTKNsLqm3F6hmxohA5JRiiWlrmqaqqWpcoxpCaOY+cl9kvGcMMkIk3OKz37FKImY/fiHiHjE5vKWl5+f8dnlbwhnU4r8ABpkIEkmMbpyDVX7siTfV0gZI3RDpVtE6M5zkiZUTY2OQVmB1ZamrnqxrMYaqvzAdrNlPhuTLRY0pqVtnKSDbhU3F9duhaI1TaNprXHZunBwDKYr1lp3bTujDoXAkE0zjo9myFo79hCGsjgQRQGvvviU25dnlFZyc7tldnzMBw/f5/bijPMvv6TSJbbVtNpgrHByE8opfkrrOmG18p2wAiEVMghIAokwziGqMS3WOolIZ/ptEQoQbgUrzTdbSP5lMvd/Bfi3hBD/BpDgsMn/BpgLIYIuy3kMvOxe/xJ4ApwJJ5wwwxWg3hrW2n8A/IPuZrBlWfZ4us9cvYb4ZDLp5QZ8APNZ+5CxEUURDx48IMsynj9/zuPHj3n69CnHx8c91OO7TLvPBejpi9a+sfnzvPFhU5DHm/3z3ffoA4gvtnqHp7Ise3ZIFEV88MEHbLdbnj9/zscff9y7Q/3RH/0Rn3zySb8KuKtv45ubfNHUryI8hu+55MNj4r9fWZbs9/t+VeKPs/dQBd4Kpj7wC+F46kOxriE84ldTeZ73fQJe38fXHTykdHFxwYsXL/pj5k3Loyji6uqKuq57Fo+vb/jVwbAoOsTr/bnw33UoCz28Jt7Fmf+rvK7fdW1vayf9Og0t8xjq3FDXFWEUkE6X7Lc72qbGWo02LvArCUoGBIAShiSMuPfwPvF0xsUXX/Dg8VPuffA+i5MHJFFMEMcIpaiL3C3vVQhIhKk5bK+RVhMEEmMljdEEYkQUpQhhMLJCCItUFikjojByma31be4QBhYhIsJoiTY1VVmg6xaFIApj7n/vp2TbDedffMLrX/6KRluyScT0/o/44uMvqA+l8xc1EbEMsQjidEJVGlo0RVVCU6CyEUaGNGWFFgoRKITWroM0CLC6cdoqUlGWBflu665XxjRFTaEs+7qlKipisUVIRdsqrAqpq4ZWtygrEEo5top0yUsgHd1RShz1MpDUhxwzTsnSEeNFhrCmu7ad+UgyzVhf3vL52TlhHNHIiCwZ8ejRPVSccLW6QJeV88mVkiBSEHVicdr5sprO5clai7EaYyVKBEhpiKRza2qs05i3QrgJH4kQBpRxDVdfM35vcLfW/n3g73cX6p8A/6m19t8XQvxPwL+DYxb8h8D/0r3lH3V//2n3///19+GSfnjGie+69MHq+vr6rQA7LMb5G3c2m/H+++9zfX3N559/znK55OTkBGOcSuJk4lbem82mLx4OOzt9wDTG9CwQz+YYeqkOf3towlMn/XeAN7iy56zHcdzz472mzdHREVEU8atf/ep3IBUfhD1UYozpO0uHFEMfiP1x8ZND0zTs9/u3+O9lWZLnOVEU9ZII/n8ef/cB/10sJS/H4Cc+/36fwfvJ01NMZ7MZeZ5zdXXVf6fnz5/3K6Usy3j//fc5HA5cX1/3vPih/vxQPXLYTHY3YL8LX/+aoP4Hva4lEGioSqgQZCFUCeQ2QgURt9crF1hF15TedUtKKbob1zKfTnj4vR+yXv0/1L3JjyTZmt33u5NNPoXHHDkPNbx+cz82SQkCmi1CEkAK0E6EVg1tBOg/ILXXQluttCE3EiBIOy0EShQkgJDQbPagesUqvqrKysqsyjlGjwifbL5Xi+vXyjK73yOJZneVDAhkZmSEu7m5+bnfPd/5zjnn7MsvGe9uMT3aA1dRLK8YH91Aupbl/JzBeAelFXU7pywVtR0RmQgpHa1tiaMdhGtQJgad4qol0oFUGoRESL0Zky3RyqBMRpoMsEBdFjgkrdU4BFGRE0cxdTSgWp9Rrk4olmckScTu3j4qGfDVx5+hhad2WicRrvFALjT5xYardpaqbGnrGoMfBtJG07QtEg90ztZIKVBKUtcN6+U1OIsxmshI8rJgXlTISDG/vkBIQ2oMyiTk+QWD4ZgiX1E5H0yN9X7pQvgxoDQxxNIPcwnACLWxi4BsKyOJFEprTKRR64rh1oj1quLk9JIGR1XkvPrmCYMkZrK1w2Q84Pa9DyiWl1zNTqjbihiJkQq0V8mUlaVuhAd4ZxGtwIq249cR0vvFC+Gj94TwER7OIeSmmfoXbaj+muPvA/+TEOK/Bn4J/KPN9/8R8D8IIb4CZsB/9q/zYAEMQ7U+nU67oI3gT9Lfavc52Bs3bnDv3j2+/vprrq+vOyvgqqrY2dnpXCSLouiMtALYBmni1tZWNw4fwL5tW05OTrrdRADVILMMQBSalIEnD8DXl2JGUcRwOGQ2m3FwcMDBwQGz2YyTkxP29vbY3t7uqIqgaQ8UT9hRwLfh0+EahIlPoKMrwqIUpj+D70yfbgr0Tp7nzOdz6rruAsP7u5H+ohNAvW8PcHh4yHQ67ZrL4Xr037PBYMDl5eVbrp/X19ddeIpSiqOjo44qC3QcfEvF9Jux8LZ6JwD6uwvSv6qh+ldxX4OfUWkczBtBFMHeNOZ4JZnPrzbXyYNIi6V1DmcFSvmBmZs39jl6+AGvvnrC1XxONhiTDfcoSsWtu0eMto9oqgV1vmK6e4iOI0ycUq6vWV9eIJxgMtkhijW4Btc0mHQL21Rcv3lGHBuiJPYZpU2Lbbyfv4kShIowUYxQkrZuafIVSIcSGi0NURSjjcQkmngywMw0O0c3sIeG64sLLt88Y+dwyFY74PmzY9aNAaloqpa6zmlc7b1yTIJAoXRM3TqfDYqirEtAIKwjkQJhK5QSSCRKS5TTRHHCuqyZr9dcz6+J4tybczUlxTqmqee0lb+37SYAxToPmKHnAA7XtLRaYMyGCxctN4522NoeEStL2zRInRBHifetiWNaMpLxjPj6isJabxlsa1ZXZ1Tra6YHR0gTsXd0h+X8krwsaCwkRiKERMoIpWpa51OwnLW0DYhNA1ayyU4QeGuEdgP6EoQSviH/G+67fyNwd879U+Cfbv7+FPgbf87PFMB/+m/yuPC2fWzwagkf9H613j8C1XFwcMCnn37aAd1qteLw8JD333+fnZ0drq6uSJKE3d3drsIMw0ZlWTKbzbqM0/F43FW54L1LwnkEBUzQxIcKMlTTwV0yqFjC99M07UB/b2+P6XTKs2fPwvXqdhV7e3u8evWqo4LCAFHwlg9AF0C93/AdDAYMBgO2trZwzr3V9C3LkvPz886aOEzd9m0EpJSd3UKf5glHWFgDT56mKbdv3+bo6Ig0Tdnd3aUoio6/397eJk3Tt5KpAs3SNE2XSXt5edm5bYYgkkBnBXomVPLh/e0PPvWr83f7L/+aUsi/3PsaKPEhHA5DNJlwNDHMq0uurK9oncNXY5tTdQJSo7l7/yG7Rzd49PEnlE2DsI5ikRMdxtz/4EdMdndZXZ2SxDHbu/sMxiN0klGsl8RJTJsvmc+OOX45ZHv/gNFkhNYJ7XoOWESkKco1rWtoqhwlZZfa1DYGLR1NXePKCq0iotEIZxV1uaKt19i2JsmGVEWOWsPW/h2G2xXHX3+BFCXCtmSTMRJNsVfw8tUZKpnilGJVrXBOUbcNolkjpCQSEYIGqpxisZmAlpKtgSYZTplsjTFN6wcRJdSLnLIuOD6/YFkKFqtrkjYmilMkEq0VTWsRsub6aobVGt1Kz8lbb7rpNnm2zkHVeK57mBju3t7j5tEuWZoy3juiKpbMz45x1Iz2bqKzCfXsmrpyJIMBSV3S2oaytZhYY7RjdXGM1Io0y0izMVbHlMWasmmItEFr6XdHUlK0NdjN/ax6qU34fgMapIKWYBUsvR3wX1Ll/pdyhKqvn3Pa95EJhzGGH/3oRwwGAz755JOOOhFCcHh4yIcffoiUsmvUhso5eLMLIbp/X15edo6KwS4gWACHnw0UTkg76oc8h14B0HHsgTYJgBjHcQdewZWyD6BhunYymXSyyqBcCRX4zs5O9//Hx8dv8c8hY3Vvb484jjsfnfV6zfPnzzs+/eLi4q3hp36s32q18uqNTWUfjr5dQDB2C69zd3e3szkO1/3i4oLZbMajR494+fIl5+fnNE1DFEVMJpNuhxauM9C95tFoRBRF3VRt2LG8ey6Bc++rZ95VLfV7Bd/lYYWgEZI4TdEqRilDqpQfbGpbrJVoucnGRJAoxQ9+/APS4ZDPPv5Tv6ihkEKyd7DP/d/6IVIKmnxBnETERpONhmgF7WbgKBpOUUqxnM2oiyXS3CBfzD0FMcy8Oq1c0QpJ2xa4tkJpiWwipE6wTUHbrpEYTJzgNLiq8nx3XaG1Ik4j2jr3thvZCGNSLi+OGYy3sE2Nsw0WS91YXJkznQxY5hVNBaJpoG1IIz+gM93eZbS1TZnnzN68JG8qWmq004xHO4wnY3YODhkYw/atu7RFTrla8frZ11hlqJ3idHaJaxzWgIwMVdPi6obGOebrJThLYgx5G8b9LU27MQcTjiQWTLLBBksyJnu3yGfHLGZn7Bw+4PYP/wbLs+dcX1zy1WeP+ObVOecXF1RNQRJptiZb4Cx1meMixTBLUc6Sr1dUVUk6HpMlWxSLaxrbEhmDdAKp/Nk0OJRQKISPQJQar6fZDLkJH7PnhG/AivY3D+h9b8A9NB3LsuTNmzfM5/Ouony3+jLGcHBwQFVVfPHFF29t1afTKffu3etUGqPRiAcPHnTTk31eOkkSsizrKJkw2Qh07oXh+QKlEJKWQqUeOPdQkQZACdVoWKDCV9DLh2nX7e1trLU8evSI4XCIc65r7sK39sDD4ZDt7W2cc1xeXr7VVAyhIuHcHz58+BaXHgzGAo0UehthVxJ8YMJ1DP/3Lr8e6KX79+8jpeT6+ppnz56xs7OD1prVasWLFy+63YkQgkePHnVVuJTeFTKYkgWbhLDrCL71WZZ1HkBhIQ2N7P5i3zcd6w+7hV1e3ybiuzyEEJgopSpqvjmdsZ7XuKrxxl3uW+snJyDRit2jm9SV46vPf0XtWrziGba2xuy/9yNOT95gW0s9TLn78H0GkxFaRUhXIyU+Qi/NiLOUyfYuyowQrcMYfy3K5TWlaH11a2LausY5cJWgljXOLjBaoqREa4G0LbKpQUlc2yK0JI3GmCoFfHKRwrG8niFdg9EGoyXjnX1q0IupVwAAIABJREFUq3j52Seko4zIKZzOEfOcODU4HaFVzHA4YLy7i3CSk/MTdNOiaTEK4kSTJTGx0QhqDj/8BbFMqNWCal1SrnOwzodlKMirNU4pMj2gata0tqWtClTjiwmpBYnxcwJN24D0E6WxUURGc+fhHTIaVrMZJ0+/ZLK7jdFQ5Mecf10wOrzN/s5dKoZ88egxZVNgjAfofLUiiSKi2N/beVkwzgaMjKEoS1azC+LB0GfQFuHeVkgVYYRGiAbbtrTOgzzCbegb0dmE4TY+RLbdWBn8+uN7A+7hwx6AIOjeA5cdwM4Yw87ODsvlkuVyyWQy6Sq2nZ0dbt26xfHxMXfu3GE8HrO9vU1VVVxeXjIej9/igUMSUxjcCTr4/gRkoCHCoFT/fAK90FeY/HnTkUEbH7JL67p+C7SOj485PDwkz/NOPRLO5fT0tHv+ftJT4KXD4hf0+gHgwjkG46++Gqmu685zp38E3jwoVwIdEs4zcP0vX77kpz/9Kffu3etSowLvHmiu169fI6Xk937v9/joo4+YzWZ/RsseZKbr9bp7vSHxSinVTfyGBTk0bwNNFR7j3eo9HN91xR4OE/n+TVMXuFbRSIsRzlu4Wg/w0gkiLZjs7jNfrFkvH7M1HiCkQgnBdHef/dv3OXv9hrt3bjIajdjemVJVJfYiZzjeI0oUipZsNCIb7qLjmNV6xepqhs5S4uEQJR3SDcA62qrGtpbRZBcpLEpKbF3inN+R6nRM2zaIpvLSQR35iU4BzpZAwyAbkSYDysk2QinKpqRpCqS5BSrh4s1Ttm/sUq5rro/PoWgYZEOyYcbF6SlWWPQkpV1fUecVtlrTioIk1gjpP0PF/JJBLDFujLItbbvC0bBezKnbhqLIUcKSGUNRF5TFCqWNn3liY0thNE1T0zReGaMUaBHube/6KJ3l/Jtn/OjnP+H+vSPaqsRkKYOdXbRKKIuK64tTTl8cU0QT/vp/+Hd59Mf/Dxezc5TSRFoiRUtTW5SJaaxlsV4yzFJGWYZpKvLVilZrhuPhJtvVX89Ia5SASliqxlLaFi3BCG9d4C1/NViBEo4Wz7n/ZTVU/60egR54V+rY/4AGBcb19TVXV1fs7u521dze3h5HR0e8ePGiM+1K07TjdsOoPECWZZ2JWACEsGsI/HWQ4gVJYKhk+46HgVvvA3mfHw+VffgSQnRGYsYYTk5OukDqQFVkWfZWBS2E6KSCgaoIOvrw+OFcwm7g9PSU+XzeDQ4FmWD/NYAPAOlTX+F6Bw+YcD2A7v+HwyH3798niiL29/e76xca0MGi4erqii+++ILhcMhPfvITrq6uePr0afc+hscPzev5fN69X4FOC6Zpgf5614UyVOfAW1V9n575V3nL/OUfgrZpaNvNXIG11M4Rb4QOmwFzlBaMJjvMr1dcXl2zt7e9qdpgb3eP6c07nDx7zPZ0i0FmyLKYeDBCaU2cJKhIIZwhHQ7Ixtsk2QjrPGCrOKEqK6RYk45GKBXjKLGy9o1bo9FKoLTGNhFtkyNsS1uuQSisq70dStNgG7870NoglUYIjVYRrlBMDm6hkhRlDLPjVxTFGi0c0rW4ck08TMhcQSUsQvlkoaIqaKuKq+UVsm4RTU2mtB/qkZq88a7nWmuUUVwfPye/mhONJxuDtRJBizYRWq1IFTRCUKzXqCjxVJe1SK0xQlKUOdZC3rRIKYiwSAdGCQbDhPsPb5NFLVuHNxC2RqgYk/i8ZdssWTcl5/MrPvvi/yUdT/nBz/4mB1evef3ll7TCpzIp25JXFW0jEGnK1TwnSx3DNEEPvBR7tVyRDYa0VYltWoQUWLFZ5IWmbT3l2uoWpaXPTLUOKd3Gi0jhmmBE/+cf3xtw739I+4qNvhIkTdMusi6oNpRSHB4eMplMePToUQc6QSFzdnb2lle7EKLj4IPMLgDkbDZjOBxSFEVX1Qcb36DOCQtFAI1gMBb+3lfSBJ4Z6Cr7YH+7t7fXUSyr1Yrt7e2uUg+2BMEeN4qibgcR6KPAPfd3CsGKoN+UXK/X3SIFdAqe/vUN2v4+vdXXuAcgjeOY4XDYzQ+EXkSwL1itVgghOD4+5vz8vLs2f/zHf8zt27f52c9+xvPnz8nzvNvlFEXBYrHoziEscMFiOc/zjqLp++eHHkJfORTAv/86/rxG/F/t4WjbDTiGQmUzuYjzAB9pRZxlXM6vWa5zEJJIarRU7B8eMdza4fnnHxHrlN2DI4bTfaqq4PLkJdlwSKR2EYlGypY4HmCiiKZcY5vW53rWJZcXFwwHE4blmmE2JIpjTJxuePEG9AClI6I0hWaAFJa6WFAVaxwNdVkjmhKhDCKKfU8pikE42rpECkuWpbhmCHs3kdYxvzynWlzjdvZJh2Mujk/JVwVtvvQTn22DSWKKuoHGEscGax1V6weMlFJE+Ii5oqqxTiOihLJ4SdEWFKscmtZb6bqWSAoSI6lRNDiwNTrOqPEB5VhvwRhFEte03tBLKZxryaKYyTDh6PZNbt17gLISayvS6S7FYs1yfUorIy5eveb8/IqyXLM6XfPpH864eec+H/zidzh+9ohyXRIJTSRhXdQs5ktMpL3cs6pIs5g4S2hbS56vyNKUqshpbYtAIpXyodmNwjYtrbPgNE5KnBNYb4IDwm4Kg19/fG/Avc+XhiNU8MHVsR/kHCrjw8NDxuMxX331Fc45tre3kVJycnLCvXv3mE6nJEnS8bqhau9b/gbJ4Ww2Y7FY8ODBA+BbF8h3t/vhnEJyU9+VMYBiGMMPi1aoUPsN0EDVGGO63Ug4n/5UargmwXkxAHLwsAlN6OVy2SljAggGD/iwiIXFKuwYQmM09Ar6k6uBKhuPx50//t27dzk6Ouoom9BIHg6HrFYrXr58yfHxMW/evGFvb4/5fE5VVZyenpLneTeL0A/IDucTrm1VVZ2lcVhIw66rD9bh/giP05eAhgXp3d3fd3F4LbX7VhXDJo/TgdGaNItZr9bkVbWhPRRGR+wf3SSbbPHs8RfgLNNpCspx+eYFtx68z3hnlzSKGWYT0sGAQZqSjbegbVAmwiqHq0pEU7A6f0l5fUGa/tA35CJPR0gb+eEl55DOQiPQkUFHESaO0dGcMs+xtkWZwcbzZY1JMqxtwHkP9DhJ8OF/gsF4mzgbMJhso03M/OqCxdUJQkU05RPyfE1dzIlFhGsbhIAkyRiOEpy7RkYxbVlRVi06jtBaks9nFNUBV2fHWOUpDJMm3nyttUjlJZ21a7BljVCGsi5ppEQLSdNamrr1q2rtSI2itoLpcICtcybDjDv373Jw4yYajTAKpQeAIh1NWa8WvHn+NS9PZ7w8PmZ3f4/l/JKmyrk6eY5dzbn58EOWZy9YrXKaSOCkoF2VlHmFSBNaW1PUJcNsQBpFDCOFbRu0ib3m3jqsEzgahLTe/bJ2iMb72Rsp0cbLZoTzlgR/oSGmv4ojcMH9bXbYugcgC1Vs+J7Wmjt37jAcDnny5AnWWnZ3dzk8PGS9XjOdTt+yKQi0T6A5+lRLaObu7u522vcQbxcq3QCKgS8PVWKQP4YqMTxXGGoK3wuAEwDIOecDGIZD4jjm9PS0WygC/RHi9IJjZmi+huq9PygVnuP169fdQFZwbuxr8MOuoq9A6sf3GWO6nVHfr2Z3d7ejvm7cuEGaplxcXHSyyxAAvrW1xWw2Yz6fk+c5t27d6irwsDPZ3t5mNBpxcfH2gGd/Qjdw+eGcwkLbt0YIPYfw3obdzbv9iO/ykAIGsR83rxpQgBHQtN5fJDYReV7StA22tTgrMJHi5p3bpMNtnn/1K2zr2N3dY/vGbfLVkp3pBNusUHaIUIbarklbjZBDXFkiI402EUoZJI7IGLb391mvK5ZXF2TDDFsZRJJgIkMURzjbYusC2zQ4nfmRdxOTyDFCyE0jT+CagihVgMDhB2601ggVbUIpjG/OTi3JaIRJYtKTFyRxjDFnREIyGL0heW1YLBqW8xWJbdnZm9JYi4wylNvMvQjfKzLC48HF82dEaYaSfgGPsgyUoqlXFFWJUpJEG1wrvPxUCpoyx0SKYayplCJfh7g/H+yhpGN3Z4u9/T12b95g7+b7pMmAxdkbWhxJMiRfr1E6ZjKdcvWnX3A1X7HKS+7e3sXVNUVeMRwUXJ08Y7y9z2DccnV+srHxFUDBKs99KLqWNPWcIo5JkpgoMmgp0UZhabyZ2EYZJaWgaVqq1lI1Da0QaARx5C3FcL9ZLPC9AffAZfdVKH3uN1AJ4PnWO3fuMBqNePLkSVex7+3t8fLlSz788MOOZggUQxg0CnJGoGuKBs59MBhQFAWz2awLs+hHyQXgDdVuOEJUX99G990mX5A9hgUnPMZgMODmzZtsb29zfHzcAVo/K/X09LSjMa6urgA6h8v+cE/wvQkNymC+1lf5BFqprzrpA324XvCtC+dkMuHOnTscHR1xcHCAtZY4jrtBrNAAvby85OXLlzx8+JDLy0uKouDNmzccHR11Oy+tNWdnZxwcHLC7u8vZ2Vl3neBbaiss6MFfJzTZ+1PCoUp/tw/Sv2d+05TqX8UhBGgNjQWkIJIOI2FRQmvd5jxl5/GtpeDW3fskkx2eP/kcZy1bO7tMD25y8uIFH/zgA7D1hmLw92QUpwgpKcslSnvO1tHStgKUIooysnRMuT5hPjshGQx887SpYZihtUTFGqVibO0zShGyA/hsHNE0FW1dgoyQKiJ0C6RUuKb0hlgInGtomholWgaDMfHNhMnOAeevnxG9eEocp0RpjMoyVos1szcXuI3v+dVsjhOSMi/9dGrrE4sa66WK+fIKWRQM0hF1sSBKBrQ0lLalLkqUUcRpipMV2sFqVfgFqAWn1MbGQeJoiZVgMEzZmoy5dfcme7f22D04oLUtOh6xdSPi+uI1eVEgpWE2W/D1ixn33r/P7HLGvKp5+eacO4d7ZBmsVz77wZ6csH14i8neIRy/QaJosThaiqqiqgTORNjc+1BJJdEmIo40RikEDqUESvgdi9Ea01jKjZNlay3rsiA1Bu3+f6KW6U9aBiDvUwShitRac/fuXfb29vjyyy+7anE6nfL48WOyLOuarUEJE4AyDCH13R8DKPTVGYvFotOIB2Ouvl1uqHbzPO+AMoBNkEUGJ8c+YPa9UvrWBSHJKTx22CUEgLPWMpvNumDpQLUE6gboKvPAjYcwj3COQU7Zp47CNHA/LBu+zUQdDAZsb2/z4MED3nvvva5RLaXs+gxa67cmiR8/fkwURfzu7/4u//yf//PObTLYFofhsdevX7Ozs8N4PO52JmH3E+imcJ7BZygsIv2vvkwyUERh0Quv67us3h1QNN6nRToYq/A9vO1s22BbTzPEUnHjwfuM9o/45tG/RGvH9mSbyXSXZ48+J00zrq/O2N19gDaaPL8iToBY027UFHXTQLn2IRDWK3SklmSTLapqztnrN5TFmmK9QKQJda2otcEkKTrSWFVTlznVuiRKMoQwGAkqkqANrq0pqxqp/Y5QCgeRoW1a2qZGALbOkVKgtSGKByTDia9aFSRJBK5CmYh1XqDqmqvzBetlAcqQpjFSa6p1TtGukULQtC1F4/EhRpEvL2nqhnVRECUZRkWooaZtS7SOaC24ypJEmqZZY3SMrSvvg668Z/pwELOzM+H2w1vc/+CHjKaHJGmGkIZ6fY0TDmGG5BcnrBZXKK345tEX2GzEX//bv8fHf/AH5GXO2eyU8WBEqgSr9QqbJJy9/prx7gGDrTFyfokQGVpIHEuKqqWsKg/wrkU20FQtZS6Q2tsr+JCPBmkkWnrjuMREfsfRWlrbUjcNrfLWwb/u+F6A+7uj7UF/HQaTwgc8jmPu37/PZDLhV7/6Fdvb2yRJwng85sWLFx0dMhqNmEwmnfoifPiD1joAa989sV/NfvbZZx3IBv12qMb7gByqxEAhBXAPXG+gdfoJTkFnHuL+gsQQ/ABX0IyDpykuLy87g7Hnz59jre0i/4LffF3XHT/el2GGhSUAYFVVnaolVOqB8givpw+Uu7u73L17l/fee4+jo6OOew/8fFmWLJdLLi8vef78Oa9fv+anP/0pf/iHf8iXX37JgwcPePr0aceph+ndsOAE//eg7w9fYdfWr77Dgtj30gkA39fh94fg3rUt/i4O5wRNoxHCkqqWgYJFDfnm1Kx1VI0jizS3Hzwk297n6ae/ZHc6Ik1GpNNtXr14RtW2bA98IMxoa5t0MCTJUpQyIDTSRAgtaTfxa23dIPFPEqUpERJrD3n+yT/jSijiKEVpg1gu0Rik8hRFbAxxkmJtg7MtTimsE0ipMdpQOYeWDW1T4pRCaF/JCxqU0jT5CjUYbVwQFW1bI50ljmK2dg4xKsIhyfM1i4tzaAqS4ZKXz17SWIldrJFKk6QjnPM9oTgSaLtpLkpPdUgHCIUyBqkFTZGTJBl16z9PVkGMpFWCJBJU1qKUQSCIEsPu7hZ37t/mzgc/YvfGfYbjHZq6AhFjXUNdrFkvrri6vOLls1e8fHXKB7/4BX/yB3/Al18K7jz8gJdffUbbQpEXDHd2UM4LCGyasL46IxuNSUcTLNckLmMASJmzLmryOicyEVoIhPW7C7G5Jyoh0arGKx01KEViFNkmp9aoTcoYvzlG8nsB7vDtIEpooAVKpn/cv3+f6XTKn/7pn3ZN0oODA16/fv3WQjCdTjvQ1Fp3nHmgG8IuIQRa9MfcjTHcvn2bV69edY+TZVlX9b/r29IflQ8USH8AqD9ZG0A3WAMEMAuVZqg8A/0wm806q2FrLQcHBzx58gTwRmlhejYoiQLoBQljULCEHkWggsI0aL8xDXT8fxzH7O/vc+fOHR4+fMjOzg5AtwiEnU2QPj558oTPP/+c8/NzTk5O+OlPf8ovf/lLlsslH3zwAU+fPqVtW66vr7tBrMD/r1arbkq133sJX/0BqL41cOht9Ieb6rqmLMuOwgk2Dt/1IYQjkS3bBmoEV6Wlf2tL4PbD9xns7PPpH/0zsiRmnGbsHRzx5uVzyo2ZlWsd0+keWhhcXaL0GG1STBKj4hjrNlOkDqLIok2CTgff3ttRxMHdB5y9eMVyZx9tJCJLKesCCoFRwkv5TIQSgiZfU1cFbADfKYXWBqUEtqlpHSClH5HfUDI6SxFC0mwoA9nUWGmJkgaEJTYRUhmuZifYusKkY5z9jL1qi/Xjb8AZkq0jqspz48ooTDbECc8zN2WOU5LlWlEuCiw+9MPbFCcU+Qpb5T4LSbrNve1ljmnkee7d/Sk37z3kxgc/Zmt3H+GUVwrFCav5nKqsaVvHerngmyeP+dVnX/Hm8prJ+RU//Pkv+PxP/4jj65T3futDvv7qKW3bsLi+Zns6Rbo1ZZETSSgWS6LRhIYYIQvS2CBs673aS1+xS2PQwlFtDIiUg1paXNtilECKBomgrgVFodBRRBwZYmO8N873vaEKdFWXEIL1et1V1aEqOzw8JI5jPvroo065cXR0xMuXL7usU6VUp5ap65qdnZ2uIg8e42ERCfRGAP1AoSiluHPnDp988kk38HN4eNhVwX1nwgDQfS4+/D2ATmgAht/r88AB/IPXTb9x2G8QXl9fc3R0RJIkgA+8uLi46JrC/d1F2DkESqtvbzwYDMjzvKt+wQP6zs5OJ3PsJ1SFUJPwHH03yvPzc66vrzk/P+frr7/m1atXnRNlXde8//77PH78mNlsxoMHDzpL4/Pz8867Ps/zrok9GAxYLBZdtR2uQ18RFAC9vysJ1zXQbWFxC4VCkKJ+d4djqBrGxvPv54XbaLcFQoCUit3Dm5h4wK/+5I+oqxYzNGzdfMDzl0+p8hVGK5SUbG8PfX5mXZPs7ZDEvpFf5hXKDEGqjVUwJHGCiVNMlKCM8UZUyrB3/0O++eX/yVmS0VQNezduocQahMBGBpGviW2NchZBjTERUns5pRAGJb223RmJsA24Flrrh610hJQGEIi29pOWcUKxWhAZjdFjSp0ysI6mKmGvYXl9xsGNm6RxhHEVy3nD+fkMkgRjvJnYerWiVRoVRVgnoQZaR1kscSIicwmDYUyVLxFtjhIOgWM0TIl3RsRJxHAwYDTdYbI1Znywz3C0x2AwQesMo5S3Wm5qVJSwPJuxuL7k4vyCr5++4MXrE/LGslg8pWnW3P+t93n2+WPOLnIePLjH4y8fMS9z6pllOMyoVhXFuma6J1ien5AMtikWV744EaC0Jmocpa0pqwoSgxSCumlp+DZAxDkfmO6ERDYNtWwRZUOhJXGSEEfmN4ohvxfgLqUPnQj2vO8C+8HBAXEc8+mnn3bV2t7eHl988QVnZ2dEUcTW1lY3tJOmKVtbWx0VEUA9aKgD4AcaIoB9oG5u3LjBaDTi8ePHXfZpMB3b3t7uuOksyzrQebfJGs4dvh0A6hte9f3RQ2UdQj8C3x70+ePxuLMYcM5xenqKtbbj48MUatgthPMLPjkh7GQ4HPL69euup5EkCTdv3mR/f5/hcIiUkvF4zNbWFqPRiCRJumCS0HRdrVbUdc3x8TEff/wxT58+7eSOYcE7OTnBGMMPf/hDPvnkE/I85+joiOfPn3cSSGMMy+WSPM85ODjo3DdDYtS7ktiwGwkUXrh+4Zr3LR7CV3ie75Ke0QKmsaOxgvMCllUAdi9j2z08Qqcpn/2Lj/xOU0kmhwc8evQZs9NToihmujVkPPCa8jTLGE+nCBVRVwWRGXgTraogzQbESboZdPGDRlr5BCUnJNJIdm+8z9ZEc/H5/8Hy7MeU5V9ne2+PUTFmsrODq9dIhuhsQByPUcJS1yuk2Khl8BFvAssm6wKlIq9/31z31nqw1yic9ba8Mh1Q1xWtXWNMQjIaIY0mm2whsyEmG2BFiTk+RbQ1q7Igl47lYu0fz2loKj8x6yz1Yo62FSMtmY418WjE2etrnAETSZI45ejWIdOjQ9LRCCkNw/GE0XSPbDwhjofk8wW2bihdi2sFxWJBVTvOjl/y6S9/yRdfv2I+X7CuLU3bdDMcWmse/vRHfPbLTyjzib+3X7xk1axom5pYRyxWK+ZFyf7hHtcnx5g4JV+cY/EWv9L5hCVrLUVZ9cKyvUOkV80I6o2xmUSA8BmyVeuomoZSG9rf4C/zvQB38PRGUIDA297pUkqePXvWgUewzg1e5/3Jzj7fGsAgaOP7ARAB5PsqmAD4W1tb/PjHP+702B999BH7+/vcvXuXtm3Z39/vKut+nyDQBgFo+7xwX5bX/zOogwIHHyr5PM+ZTCZdJRqok9CoDVOdYco00FLhHMqy7AKqsyzj/v37HZ3SNA3j8ZjpdMrR0VGXIxt2M2Gh7FMdYfDo+fPnfPzxx8znc05OTnjz5s1bw0VhcXnx4gVpmvL+++/zxRdfcPPmTe7du8fTp0/fiiYMXkLT6bTbVYSp3/4AVb8vEzj4/iRvOPrzEuFafZdTqgKYV4J55aWQEO5tidQKISVvvvmKtvavLRsNmZ+fb+5tqMuKYaq8bFF6ztU1NWpzrxZVQYRAaUPb1thWk8QpUZp4cDcRSntzLpxET/e595PfpT75hyyXr3jyx0suD26x/+A9bFOzu39I23pPdSFyIq3RJsW2LTiLtQ4pNUL4alNJiRTG14/OdgOTzrY4au96mIz9pKsFkzhEvmI02UNsQVUWqChGOkdbeYolziJWlyvydU0SWYraeW/zGqw11NWKwdgbnMWjhFsP32N9vcKVY8rGkm2NmGzvsXvzNlu7Rz6IWkriOGO4vUc62kIKQVvVNOWa9dUahObVs2d8/PGnXM0XnJ285tXJjLJpvGmXVLTW0jSWFy9fk2YZ9z/8gC8/f8TenXvc0jHPnjxmVRSQ+etdliXHr0/Z3tomzyuKRlBU/nOkN9PHEnDO+l6J8JDuWu8m2grrdyEOWh+qiqAF56iEJVftJnP1zz++F+AeqtD+lGr4vrWW169fv0VrhOq1L40E3xSdTCad5wh8C6SBDgm69GBL0AfdvsLiBz/4Af/kn/yTTk2SZRm7u7uE9KG+rh2+Bd3+0My7PxPOp//9AP4BvMJrCbbC4fn6/x9+ZzQaUZYl0+m0a0AHlUwA69Bg3N/f76IGg/Ha7u5uF8ARdguBvunLNcuy5MWLFywWC87Pz/n444+5vr5+qwndl1CGCu6bb77h5z//Offv3+fx48f89m//NvP5nNls9taCHBZopVQ3XxCOwJ/35x+CpDXscsLz9691XyL6XYJ742BWiq7C8ucnsbbBVg2nr15ibbvpNxiw397bAoGTIFEkScx4MqJpC7Q2PrQBi8D3lLRwGK1IByOSbIDWEVICrgHrQx+a2iKV5MaPfo8/+V//R0bmCaJWbGXbTPf3kUaT5wuEVN5ONssQDlzlP09O+XMJGZ6gED73DZwPhfZEgp+gFCJCSd9DqW0NUoJzZNnA57HqmGI19z7mbeMXDWWQOiIdl1RFxWR+SVVUVI1lvchpmxbcECkEJk1QSrN9eBMTnRMNYlQUsXV0i63dGySDIVoYWmu9Lz2SdLCFaBV1UyKEJC8aXj9/yXy55vTsgo/+xcecX6/JUoMQDmcdVjiM0SA2HutYXjx9wtZv/zUe3rvL8y8+58e/+B3Wl5ecX11QVwXDNGNl17i2pS6LTbzgmPaq9NcUiLUkkpKmbTe8v6fpyrKirlpa660prPDXV1gfjt04H7yu2vY33tvfC3Dvc9KhMutvy/sWBP2te/j5AKph4CgAWR9kA+0RAqH7lWp4vr5p2e7uLn/rb/0tPv300075cnZ21tEVgX8ONgFhkKk/+h7+fBfcw/f/PCfDUIEHyWFo+PbBVgjRedFfXl52HHawDO6DY1jUsixjMpmQ596idTKZMJlMSJKkCwYJ1yl4wwQHy+PjY548ecKjR486+WXwe+nHEPY5/9DI/vrrr/nJT35CWZY8efKEhw8fdguRlJLRaNQ9ZmishnmD8B6FRndouAaDsvV63Zmo9Yebwu9Se3aOAAAgAElEQVS9+/3v4rDe82lzjfxOJMjXHK7zBvH3drK5t70NrZDC2/CqTSiMidk5uIeK041qpMGbQEYk2ZgkHWG0RtB698M4QWhPnVA7jJGYWCN37/Hz/+A/4fyX/z2ZOqBpWq5Ojsne28GkQ1rb0DSaIs8p8UotpG+SOiyRFaCsH9JBwmbm1rkmvFikTBDC8++OBuG8wkYiSNIRQkmMiTFGYbGUbYWTCicFaZJRF2uuL89ohwPW6yVlWTGc1rS1D7d2WHTspZp6OGB/ukOxXqCTIaOtfcbjbeIko6krqtIDuTKatiy5vpqxuLrGWcHZ8TNefPmEz758zGVpWZYtddMyX7bEkUKIzWdV+mYzzhIrQRJJXj/9FR/+7K/RlnOeP/6cOx++T/PJirxpEFIzGA0p85yyyBkOUqStGA4GFHne2fgqpUm029zbGm00RdmwXuWUTY1rHI3YjDUIfz8Z62ido3aO33Rrfy/APRwBhEK1HAAtgNVoNGK1Wv2ZhSA0OEPlHhwPAyD0ASIcfRohcPzBijaA049//GOePXtGnuecnp52Dcnwc2HIJo7jt+ikwMP3K/FQWfafPxwB2PsTueF6hH5EoEdC5ZplGXVdk6Ypq9Wq88QJu4+w+KVp2rlShnSqAMJh0eo/d7i24XHfvHnDyclJR6UEm4UAnuAXkPA44fz6WvSXL1/y3nvv8eTJE87Oztjb2+sotfA6+rYD4T1410AN6BbgsPiFhaI/jRyuaZ+b/64PKRXpYICJYqq6Bmdp6trL74DheMx6uew+xGwCGRA+0CJKY4bTCVU+x0iJiYYIggeLQBuF9Jt3QG/04RZX++sSJxFRpHEOrNHc+cl/xPXTP6LKc67PvkCNDijXDzHxgCRSlOslrYYojmkai6D0wzVxihCaxrZIoZHO+Qq3e25vQUD3PjQ412JtC65FRhEgUFJ5milRVMOKulihNglE2WBAU5XobEy5vCYdrSiKNa0V1FVNIwAhSNIJ8cB/ZYMtyrpGCVBRAspQt7W3R7AOR72hPhxRmiFWKy5eP+P8+DXrcoFQlrLwfjz9ezuJJHXrdyVGG4xwGCmRWmAUnD97wp0PfouXj3/F/M1rdve3Ob+Y4WxJNhhgqxJnHVVVMBwMIEoRrqK1DotESr9DwwmqukVHhiyNUMJhKkldWZq2pXE+0FZsdkmNtdQWv5j+muN7A+6hajw6OmI6nXbUR/CTAVitVgDdEE/f5TB84AOoBm+XQMH0OfF3m50B7MLQTACD0Wj0Fnf+9OlTyrLk/v37bG9vvxU8ESijoCMP1WP4sw/y74JNv5rvm3r1fzaEfQQqKRhrhQi7oJAJVXh/AnZvb6+jpIIEsp/EFLJVQ7UcQDf8XugvLJdLVqtVx42H/wtDV+F1hscOi6CUkvl8zq1bt5jNZkynU4wxXfJT0M8DnYQxLPD9yjvslsLrDruXMGQW1EXh2gVt/HcN7kJYtI44OLrHeLq7ubcdxXpBVeSAJV+tAEGcxh74TIxQBm18DmiaZkixeS/KgiSOiIYZaTpAG0NjW4wTPq5OelcyS+O5ZqOJjOeMERLpBIPRIVZOSbiklIKLx/+MKm85fPgTJrv7jLd8LF1VlSBWRFHs3SdbS21zhJQgHMgWyWYMXihfyQvwxIPFOQv4XUtkEm9V67wtg28pSmKTkmRjlI6RUlMlGbZtSQbbXF29Aedo65a6biirgqppAE0ymDLdv4WQBmWMP1dn0VGK0hqpDXVeIFcLD9wIbCuI0jETqbEqpbKKsnZMViuu8ppVUVK1PgyjbR1JZGhshZAOLS2J0sRaYRJNYgxGWPKrc45u32B+ccF4Z4fYRMyuLpFCsDUeUNWNd56MFFEcEUc7tHVBs8lzldaBtVQbC4osSxhEEXnV0FQNZVtR1Q1162WUSIlpHcY1XIpfLxb43oA70A0k9fXuAXjBg18I3QgN1wC8QWceJjEDsAcapU8V9P/sb/37VV8Yvb979y4fffRRt8V/9uwZp6en/OxnP/MNsE3lGZwkA4j3QTpot8P5huNdRUhf5dE/l/B7oUIOPHnYJbybVhSmOftyz3AEWWOgTwKQhuscFtBAvdR1zXA45OjoqKOshBC8evWq+51w3cOuI8wVBClioFGm02m38D548ICvv/76LZVPv08A33rShyo8qHbCItLvV4SfCfr7cM2stVxeXv7buD3/AocgiUdko12cTtGJxtnKW+5GPoHJrivS0c6397bYFBWba5zGGUorhsMJcRSRDsdkowlJmiJci9YKE8WoyGuhlVY4vD+JVpu4NilpHQgl0eMpew8/YPZH/xva3sbYFctv/neeHn/G7d/5OyDeJ80yXF1QmZJsOPJTpjRIo5BOYV1FFA08yG+knR6yw4JswYFtLUIo72hQVzghcZv4CUdodia0bUOSDtHK2wnreIgysY/DAyyKpirI1wVCSkwyJEq8Bh4rUCbBGI0yMdYKTJRQRjlOaYwZ+JkP6yiLhrpStFVDMtxm92aFiBUyGoN4wer1ybdDcYn3abe03r0zMqRRRJpoYpOgjKQqCramN5BjS5GX3Hr4IeLJI6ytUTIUlRaUJIsMVijaWuGcwDpH01qq1hLZZuMpo9FSMFIKEUc0JH5YqvS75lb44SZnLaez8197131vwD1I/ebzebdFD9vtUKWG4Z5+0yz8ezKZkGVZx4EHmWL48AfddACfUOmGRuC7lXWo/t577z1+9atfdTLA4N/y1Vdfdc6Kg8GAu3fvMp/P/wzXHkC0D9Z9iqbfDAwA1ddxh0GsAO79waz+5GugK/ra+dCgDBYBYco39B1CZRxoGPAUyGKxYLVa8fz5c2azWcd1h8CS6+trjo+P3wLS8Pv98+rr/QGurq7Y2tri9PSUxWLBdDrl8vKyez/6EYXhd/u+N2FnFfT77/YtQlHQ3/WEn/nODgFxkhJlGfPlFe31jLpqqOqSpvGNeuoGE6VILb2uGTZe7BonYTDdIRqMKVc55XpFNoiJE43SgtZBpGO0MphIYyKDE84HOm8mOJE+6k/gvMpG+vvz8IN/h6tP/iHGRbjlOVE9p56fcvzlDssClNAMBwk3H9xjMV94mogYRIKkIjIRTnjKAuSmSvegDV4x46t4f0821oFtUdpX8m1TIfVm9iSKiRuvCmuj2A9LaY2Q0NYF0iQ0raK1DXG0wilDMtpC64TF/JrWWqIkIUlStI6o64bGWYTQxMkI3JqBVCwXC/L5gtOvn7K4OMEpRxRHjCZb3JCGq+trXh+fsq5qXNugnWGY+uIpNYpIK7RWSC2Rms2CB8vLC8bTCavTY1aLBZPtbeaXZ2gTYZyjakoQUDUWrRRSGaxrEa1DKEkiJK1TWOsoipocgVEKKcEiMUqQJJnn2IXf+SAFSs1+7a33vQD3MAVa1zXn5+d/5v8Cnx2om1C59Ruih4eHnUQwDN70jcICFwzf8rHwLcXTP/pj8AcHBxwdHXU5q0DXXC2Kgs8//5zf//3fZzabkWVZB/jh3PuVZb/h2l9M4FvKIfxMGL7pa74D5REAL7ymMLQVFqy+FLNvLRD48n7zM1BKQSUUKvurq6tugZBSMhwOO557OBx2FE9/oepbAfSvc7+xGRaj4+Njbt265YMLVqtOU9+Xh/alq/3BrEA9AW/1Vfp9mP61/S517kppksEWZdOSnx378AixcRRVGlvXOCxWg9ERWkqfhCwNSeq9jPYPbqG1Qg9S0tEQrROU0FRFgVYarUbem9yvCjjnY/OiVKKUb3h6jY5/r6zz5lTDwx+R3Pob2LMZbXGFti1SrLk+/RNWRc3jT5/zH/8X/yWXFxcMsoSijFDCa/elEp3MVEiNFHjLApyv0jtjY0drG9q2QiKpnUXLCF+Lt+C0t6+VCh2nyNahne8lCCkRUtFUNQ5B1bbYpkGpCCc0WsWYKCMbSap87a0OhEJKhdEC11RY/L2NSoiGGWOdsrg8J0o0Urc4bUkmU+JshJAXDIdePizqFiEd7cY3XSvpX1co0qzEe6W1WOnAOtZKI0XE2as3HNy9z6o4pV4tSZKY1WJFi8C2FqMlwhioNz5TzmEbS4OlamryyvcvIm08gMtNJ0ME3BAbRZKjbf+CQ0xCiG+AxebdapxzvyOE2Ab+Z+Ae8A3w95xzl8K/+v8W+LvAGvjPnXMf/aueI3Cu/XHyvlokVK5BIhjoDqCjJYwx3dY/AM5oNHqL+wa64ZawtX9XrRMqxrBY/OxnP+Mf/+N/3C0CAbTatuXnP/85JycnpGnK3t5eV7n2K25rbTddGv797vmEcw7n0T+fAPCB5+6fYxhs6j9PMNoKoBZAuD/G3/fECelRV1dXnQ4+UCWhyg/nHlQq/QU2AG7guEMF3l9Qw8+Ga9VXulxcXHRTuv1FYDwec3V19Zb6J1z70B8I90Z3Q/fkqH2a67u6t52Domk8iOmNdFBKjPC5ncYoEIYoTsjSAQiNdQKV+LmHxBgQDh1JtqbbPmMTcEiGYx8xiWtQUuCEpWlrtImQSiCVp8o27DsGgZTC9+CUxKZDbv7i7/Hof/mviJRAGIMWlmFziqr/Jb/1O7/D+fEpaZLh9vdQUYrSEe1yjdYS0LTWksQpEj9s09rKSxrDzrNpsG0DraPFd4uts0jnvPZ+A/JNUyOUD4cGsLYlSsd+DyAKXOswyZCmrZFluQE1QVPVKCcwJkYJgW1a6rYCrXEtNLVfEJaXJ5RFTdVYhIqxbUU8iL03jgUhWqoiJ18XSCm8Bn3z2auahtZJ2rahrC3IGi199qoUIDeUE+czkjQmX+UsnALruJhdksQx63xNY8FZh9ERw0nE1eWCtql989kJ2k1g97pssNYRmxIlFBbfCNZKYpQC4Z3zlfSmar/u+Dep3P9951y/rP4HwP/lnPtvhBD/YPPvvw/8HeD9zdffBP67zZ+/8ehv4wPoBuOvPlALITo3w5B21DQNi8WC/f19gK4SLYqCOI67fM/wf30euw+0Abz7muokSbh//z6Hh4e8ePHiLUAM3i9ffvklZVnywx/+kFu3bnH79u23MkGDbjw8/rsTqwHcwzmFUfr+Ob0L6n273/4OITxGn9LoK0nCz4Tp1lB99b3yLy4uOm1/APcwJQq8BczhCO9J0Ku/W6n31S/T6ZTBYMCLFy+4d+9eN5XcX5TCzwabgnfVRuHxg/onvO53m6d9Y7bfcPwl3tsCqROMUEjjqz+t5ebeHtDijbkmwxFOCsq6YmAMKoopG0lVV+TzS9TeDtIqJBpbNZTFmiiKmezsok20CcqQG5rbx7BZ62jrjXmdkrTC4ayvqSMpiSKDu//v8eLo32X+/P/G6gHi/2vvXGPsuq46/lvnfe/M3Jm5fgwTJ+nEsdM0QxCgqGrUBkWERxUh8qUfqJBAqFK+UKlIIKSIb0hI8IUCAolGQhFIRUBUqlaRorSE8iWUQlBQU+qkTV03juN5+77vPa+9+bD3vj6e2LFDbc/D5y9dzXndO3ufs87aa6+91n/pAX6W0t/aQoq3eO3MBUapsLr6ECfuvodjKydozjRpzDUp0pSZ2Rm00gSBqfWpyhLfD/A8G7pXFFAatkgtAZ74lPkEfBtkoJW10AXfC1BaoUoTXePh4/sRvl+idGbcP+Lj+zGonExpVD5Ba+OnKBAiYDIeUVDi+QlKQ+m48inpbb9LkY1pzDRoNBt4QYRSmmySInqT/nhMWmimol0oUrs2lZU5vg+lEpMB7ItZWNbaRq7AIiGzc4u8ff4Cd993mu5oi2GeoUoYZzlFoVG64KgXM5goRqMCESfXyvjhlUlsyjONeO6dNiX2NMU0VDYQIf9xLfdr4Cngcbv9t8C/YV6Ap4C/0+ZN/A8RWRCRZa31xWv9kHMfuCQbF9kxPz8/pRBwyTduu8rv7si1Wq3WFdTAzWZzygpZzRJ1ygyYuiecu8e1p2o1N5tNHnvsMZ577jna7fY0hf7tt99mZWWFdrvNmTNnePXVVzl37hwPPvggDzzwwBV91Fpfwcjo+ltdzHUKy1np1fqmbkBwlqtzxbjwR3eu+teFebpi3C6axlm+LmwSmCrYXq8HMOWacYuU/X6fTqfDxsYGGxsbU7dIVWk7BV11JVWVrbufWZZx6tQpRqMROzvGZ9jr9aYLr+66Xq9HkiTTJK7di8zu+e1epK5+qsXVPwBummwjQuhHJFFEIzFp+gQB8wttJBCyrCBpNomCiHGeEwchYRyhtCYhNwkxccBsa4FC5YiX4AVCo5mQzM7ieSHiBYgXohBKVSBlRI4gHgShR+B7JpMUk3zkY322QKM5x/2Pf5YX/7rL0rEh3vAcoYw5+8OclfvXuevoMV7/ziW++80OncVFTj/0IMcfXkXLMYTCVBsCkjhEygKtCiQIiKPIuEh8H8G55cxMxiQshUb5U6JKhecFKGXOGZkvyMdDlC7wPR/8EPEis+9DWWhUPibPFV6YUGYFRV6gfUjHY0uLO0RrGA2H5FnOsNdFyIiTgObsAkoVFJMR3d4ldjp91jcusrGxRprlgKXT1TZjNCtMgRXl5M/485HSJJTZzKRJts3JU8fojy6wudMlF59Bf4gf+ORpgcYDFN1ejySOMPkBWOv9cklUseGeItiENZv16+RaC7nITamhqoGviRlivqC1fhZYqgj1GrBkt08A5yvffcceu+IFEJGngafhMreMq1vq3A0uvtsttjpf6/z8PMA0JC5NU3Z2dhgMBlMLstVqTd02VZdP1SqvKgXnBtntf3fK/95772V1dZULFy5M3UAnTpwgz3OOHz/O8vIyGxsbFEXB+vo6Wpv0Yxcy6QYUN0NxirwaqlfNpqxau866r1rKTmG533A+atdmpwzTNGUymUy50Kt9d8rezXx6vd50gdj5250v3w2sbg3DLfZWFy+r8e+7F5CrcGsWCwsLbG1t0W63p5m11b6laTqdObjnVl2/2P27Fdm6wp11HeV+S2Vb/ICkmTDbXCCOEzIUzaRBI2kwKQqSOGQmSZjkJVmqaLdmEFHkStGcaTIY9ejvbJD12uTH2kTREeZaRwjjOZOWnk/MNN33KUoP0T66zNFSoomBEOzzCOyiKjiuEkj8kOMrH+FDP/VxsvNfQ4cLyGzMwr13MSk2WWkNGS4L59cn5Cql9+4F/LIkS08xOXaE+fkJWs1B0SAMTKFtVIHWlq/cE5PTqYqpVe75HlqZqlMKhSpM3Le5eQpNYAmxcnv95YQo39OmVJ6nyNKSyXhCOt7B821uiB+iPU1RavIsoyxKRv1LDLuX8DxNc3aOMI7x/YAyE7wwIoh8yqxPmk3wwsiQeJUmycxE+pgsUs93sukBns3INQGd2ASvvCjZ2lhnbnGBS5vrzB89wvpwaIpZm/nLVLabjZgg8CkKZb+vbZlF85v6MpuPOedk3nmztKmGdS3cqHL/hNb6gogcB74uIm9UT2qttVyeW9wQ7Ev0LEAcx9qFODor3hXXGI/HLC4uvseadT53V9Kt1WoBlxfYqvzhLvrGWcxOcbkwwt1RF7Z9wGU3SRiGPPHEEzz//PN0u90pNe7Zs2dpNpu02216vR5ra2sMBgOKomAwGLCyssLKysoVrJPO9eAWPp3CrMZ0uwHARcEAV5BnOcvdtc8lODk3TJZl0xyBra2t6b10M4fFxUWUUnS73alv3dEJuIiaKseLs/6d66Wq2Kv3rKp030/5djodlpeX2dnZmd6b3fQTboB0CWPV71e3qwPd7nPVRexr4JbKdpTM6JnZI3hhk8zzEU8RNJqMy4LhJOXY/BylhqzUBFFgkpeUZjYM6G5dZNK9yEyrgRZNFCbg+WQTQ5MsqqTUPjrNQQ1MbHccE/iaIJk1hF2CWZxETAgd4vQLPkIgxq//yJNP8doXX2TS6ZPH95AkEevf2+Suxo+4/0jMoNvm3XVN0emQjAYEOzsUDz+IPHASPzRWuu/7ZGlBqQry0rhavXRCEDhXg6moJMqoxiIrIfbRaIp0BJ5nSNU8QeU5Skp88cnSMeJHKA1FrsnTgvF4RJaO6GxsU6ZjxpMJeWnCLltHj1KogmFnk7LQxDMNGkmM9k3BnbDZIk9N9AqBT5EV+GFAIxTyNKPYLduWl0fE0ipYlQ6X9axYv7mH0O10WLrrLjo7O4SBh+djFl/xETErJlrDJM2IYt/6zQUTxmT+n+WGRLsBwZD3WMtfm2JZ2rqIroEbUu5a6wv274aIfBn4KLDupqQisgxs2MsvAPdUvn63PXZNuMU293JX48Ud/4l7SaskXc7qdJa9s/CcK8VFf7jZQLV8nfsdF2bnBgHn0qhGfDgF1263eeyxx3jppZfMzatE7ogIp0+f5pVXXmFxcZHV1dVpYWg3gDjrFphSF7j2uYGtasVXFwar7avSMziL3F3vZjfD4ZDt7W16vd502xVBcd9zfPVuEdVFGVULkVQTnAaDwTT7192f6jOEq/u9K3J0RV/6/f40tr7ZbE5ZLB3czKPKf7/7HlWt8uqgcrUZwzXadEtlWzwP7cekJXieYrYxgw5iCh1ytGkyh33RZExIPJ8oDFFFTpYP0fmYZiOgkcziBRFFaTjU45mWKa4RJQRxjFYFYdIgipskjZggiAnCCK1AGS+AYRdUQux5hJavRGujqHwRZhdPsPL47/GdF/4cBBaCH3LJGyG+h4jiIx+e44V/v4Ra+kkefvQXaHXfYXTuLN0owtPWl16WeLqkLAqC0ZAoCmzMvSEZM76GALwS8QwXueSltexLY6l6vikUjTAZj/C9hFIrvFJRZJo0zxgP+3Q2txh2uwwHI/qbGxDNMcrH4OWM0h5z7SW8IKSYXEIVmsbsPGHsEUVNQxtcarJJj8lgSJYOSXtDRpMSP/DxTJwhLqTTEw8tIB54ysbxg1HGWHtcK6uUQemSYb9DGHmMhgOSxgyj/gg3Imib6DXJMhqNCBHP0FSIxoSbmmczlWzt2mIWVpVtnWFE+zHcMiIyA3ha677d/iXgD4GvAr8J/LH9+xX7la8CnxWRf8AsNnXf1ydp4RRxu92eWtzOOnaKw1nnrqScW7wDppEWzuqvcqI7Kx2Yug3cgmA1melqqepVheH7PidPnuT06dOcO3eOI0eOXBGauLW1NXU59Pt9VldXWVpa4o033mB7e3sad+5mIU6JullFs9mcDhQumccpOKesXCSLc9O48Ea3uAywvb3NYDBgc3OTtbW1ac3StbU1RISlpSVEhO3tbVqt1pR90t07p/CBaVasm2mcP3+ewWAwHRQddm9f7V7u9sMPh0Pm5+cZDocsLi4yGAze41d3z6XKfLn72Vztt6vHroXbI9uCBEIchbTbi7Qas5QEVhkHxheuFI0Fha9yVJ6RpiPGaZ/IL1DiMxr1EVUQ+CZL1MzySooiM26fJMHTJvmlVECWosqCOEoIktDW3tQEgY32Mp02A6U25f8CP2Dp9EdZ+/Av0z/7IsHxFs14DGVJoTPWtnv00fQu9dkeDfiJn/457ls+xsbr36SztWVK+c0miC7ReUoUh0BCmqXoEpKZJuIF1oUkEEf4WlCTkeGK8QJTe9UX8nyC0pBOJqhigh9GZiGSiM7WOpPukN76RTYvvsPWxgatE8t03n4DFUB7+QS+V9DbOs/c/ALNxUWz+Bh5xPEMoReTZX2EkkbSIvQiCpVSFBrvnTUGw6GJ5nEKXkA8sWyMPniCUlJRrk5jK6u7jaU9Gg5pzc8yHIxYWGwzGoxMdJCbaWrDMVSWEEQeWXalrHr2d7TWU0vec9m9Vu1fjw5PbuAFOAl82e4GwN9rrf9IRI4A/wTcC/wIEy62I+bt+kvgk5hwsd/SWr96nf/RB968TlsPE44C104tO1zYD339kNb62O6DtWzfdOyHZ307sR/6e1XZhhtQ7rcDIvKq1vqRvW7H7cKd1N87qa9Xw53U/zupr7D/++td/5IaNWrUqHHQUCv3GjVq1DiE2C/K/dm9bsBtxp3U3zupr1fDndT/O6mvsM/7uy987jVq1KhR4+Ziv1juNWrUqFHjJmLPlbuIfFJE3hSRt8SQNB1oiMg9IvINEfmuiPyviHzOHm+LyNdF5Pv276I9LiLyF7b/3xaRn93bHnxwiIgvIq+JyAt2/z4R+Zbt0z+KSGSPx3b/LXt+ZS/bfStx2OQaatm2+wdGtvdUuYspnf5XGLa9h4BPi8hDe9mmm4AC+F2t9UPAx4Dftn1yTIOngZftPlzJNPg0hmnwoOFzwJnK/p8An9danwIuAZ+xxz8DXLLHP2+vO3Q4pHINtWzDQZLt3Sx6t/MDPAq8VNl/BnhmL9t0C/r4FeAXMYksy/bYMvCm3f4C8OnK9dPrDsIHk4L/MvDzwAuYFL0tINj9jIGXgEftdmCvk73uwy24J4derm2/atnex7K9126Za7HsHQrYqdnPAN/igzMNHhT8GfD7XM6GPgJ0tNauQka1P9O+2vNde/1hw0F/ptdFLdvAPpftvVbuhxYiMgt8CfgdrXWvek6b4f3AhymJyK8AG1rr/97rttS4fahl+2Bgr2uofmCWvYMAMeTTXwK+qLX+Z3v4pjEN7iN8HPhVEXkSSIAWpgzdgogE1oKp9sf19R0RCYB5YPv2N/uW4yA/0/dFLdsHR7b32nL/L+C0XYGOgF/DMO8dWFhyqb8Bzmit/7RyyjENwnuZBn/DRhZ8jBtk0dwP0Fo/o7W+W2u9gnl2/6q1/nXgG8Cn7GW7++ruwafs9QfeyrsKDp1cQy3bB06298GixZPA94AfAH+w1+25Cf35BGZa+m3gf+znSYz/7WXg+8C/AG17vWAiK34AvA48std9+H/2+3HgBbt9EvhP4C3geSC2xxO7/5Y9f3Kv230L78ehkmvbp1q2D5Bs1xmqNWrUqHEIsddumRo1atSocQtQK/caNWrUOISolXuNGjVqHELUyr1GjRo1DiFq5V6jRo0ahxC1cq9Ro0aNQ4haudeoUaPGIUSt3GvUqFHjEOL/AKqMKA4AAAAESURBVIVfS4s+owTlAAAAAElFTkSuQmCC\n", 439 | "text/plain": [ 440 | "
" 441 | ] 442 | }, 443 | "metadata": { 444 | "needs_background": "light" 445 | } 446 | } 447 | ] 448 | }, 449 | { 450 | "cell_type": "markdown", 451 | "metadata": { 452 | "id": "_Tf2iVeJvUDh" 453 | }, 454 | "source": [ 455 | "**MODULE 2 : Model Creation**" 456 | ] 457 | }, 458 | { 459 | "cell_type": "markdown", 460 | "metadata": { 461 | "id": "-E8p0uaux9w_" 462 | }, 463 | "source": [ 464 | "**Conv2D**" 465 | ] 466 | }, 467 | { 468 | "cell_type": "code", 469 | "metadata": { 470 | "id": "zEYELaVgvg5g" 471 | }, 472 | "source": [ 473 | "class Conv2d(nn.Module):\n", 474 | " def __init__(self, cin, cout, kernel_size, stride, padding, residual=False, *args, **kwargs):\n", 475 | " super().__init__(*args, **kwargs)\n", 476 | " self.conv_block = nn.Sequential(\n", 477 | " nn.Conv2d(cin, cout, kernel_size, stride, padding),\n", 478 | " nn.BatchNorm2d(cout)\n", 479 | " )\n", 480 | " self.act = nn.ReLU()\n", 481 | " self.residual = residual\n", 482 | "\n", 483 | " def forward(self, x):\n", 484 | " out = self.conv_block(x)\n", 485 | " if self.residual:\n", 486 | " out += x\n", 487 | " return self.act(out)" 488 | ], 489 | "execution_count": 16, 490 | "outputs": [] 491 | }, 492 | { 493 | "cell_type": "markdown", 494 | "metadata": { 495 | "id": "6bCywTOIyCIo" 496 | }, 497 | "source": [ 498 | "**Conv2D-T**" 499 | ] 500 | }, 501 | { 502 | "cell_type": "code", 503 | "metadata": { 504 | "id": "h8a1mNGRx3lM" 505 | }, 506 | "source": [ 507 | "class Conv2dTranspose(nn.Module):\n", 508 | " def __init__(self, cin, cout, kernel_size, stride, padding, output_padding=0, *args, **kwargs):\n", 509 | " super().__init__(*args, **kwargs)\n", 510 | " self.conv_block = nn.Sequential(\n", 511 | " nn.ConvTranspose2d(cin, cout, kernel_size, stride, padding, output_padding),\n", 512 | " nn.BatchNorm2d(cout)\n", 513 | " )\n", 514 | " self.act = nn.ReLU()\n", 515 | "\n", 516 | " def forward(self, x):\n", 517 | " out = self.conv_block(x)\n", 518 | " return self.act(out)" 519 | ], 520 | "execution_count": 17, 521 | "outputs": [] 522 | }, 523 | { 524 | "cell_type": "markdown", 525 | "metadata": { 526 | "id": "Eahg7WyeyHla" 527 | }, 528 | "source": [ 529 | "**Model**" 530 | ] 531 | }, 532 | { 533 | "cell_type": "code", 534 | "metadata": { 535 | "id": "nAYmhm0RyMJy" 536 | }, 537 | "source": [ 538 | "class Image_Super_Resolve(nn.Module):\n", 539 | " def __init__(self):\n", 540 | " super(Image_Super_Resolve, self).__init__()\n", 541 | "\n", 542 | " self.image_encoder = nn.Sequential(\n", 543 | " Conv2d(1, 4, kernel_size=3, stride=1, padding=1),\n", 544 | " \n", 545 | " Conv2d(4, 8, kernel_size=3, stride=1, padding=1),\n", 546 | " Conv2d(8, 8, kernel_size=3, stride=1, padding=1, residual=True),\n", 547 | " Conv2d(8, 8, kernel_size=3, stride=1, padding=1, residual=True),\n", 548 | " \n", 549 | " Conv2d(8, 16, kernel_size=3, stride=1, padding=1),\n", 550 | " Conv2d(16, 16, kernel_size=3, stride=1, padding=1, residual=True),\n", 551 | " Conv2d(16, 16, kernel_size=3, stride=1, padding=1, residual=True),\n", 552 | " \n", 553 | " Conv2d(16, 32, kernel_size=3, stride=1, padding=1),\n", 554 | " Conv2d(32, 32, kernel_size=3, stride=1, padding=1, residual=True),\n", 555 | " Conv2d(32, 32, kernel_size=3, stride=1, padding=1, residual=True), \n", 556 | " )\n", 557 | " self.image_decoder = nn.Sequential(\n", 558 | "\n", 559 | " # Conv2dTranspose(32, 32, kernel_size=3, stride=2, padding=1, output_padding=1),\n", 560 | "\n", 561 | " # Conv2dTranspose(32, 32, kernel_size=3, stride=2, padding=1, output_padding=1),\n", 562 | " Conv2d(32, 32, kernel_size=3, stride=1, padding=1, residual=True),\n", 563 | " Conv2d(32, 32, kernel_size=3, stride=1, padding=1, residual=True),\n", 564 | " Conv2d(32, 3, kernel_size=3, stride=1, padding=1),\n", 565 | " nn.Conv2d(3, 3, 1, 1, 0)\n", 566 | " )\n", 567 | " \n", 568 | " def forward(self, face_image):\n", 569 | "\n", 570 | " #print(\"Shape : \",face_image.shape)\n", 571 | " face_embedding = self.image_encoder(face_image)\n", 572 | " # print(\"Shape : \",face_embedding.shape)\n", 573 | " decoded_face = self.image_decoder(face_embedding)\n", 574 | " decoded_face = decoded_face + face_image\n", 575 | "\n", 576 | " decoded_face = torch.sigmoid(decoded_face)\n", 577 | " # print(\"Shape : \",decoded_face.shape)\n", 578 | " return decoded_face\n" 579 | ], 580 | "execution_count": 18, 581 | "outputs": [] 582 | }, 583 | { 584 | "cell_type": "markdown", 585 | "metadata": { 586 | "id": "lkhAMdpk9Wmz" 587 | }, 588 | "source": [ 589 | "**Code to check the model shape**" 590 | ] 591 | }, 592 | { 593 | "cell_type": "code", 594 | "metadata": { 595 | "id": "adkY3N__yHGs", 596 | "colab": { 597 | "base_uri": "https://localhost:8080/" 598 | }, 599 | "outputId": "de661625-4e39-41ba-ffe5-9766ff696398" 600 | }, 601 | "source": [ 602 | "model = Image_Super_Resolve()\n", 603 | "data = torch.rand(2, 1, 512, 512)\n", 604 | "print(data.shape)\n", 605 | "decoded_data = model.forward(data)\n", 606 | "print (decoded_data.shape)" 607 | ], 608 | "execution_count": 19, 609 | "outputs": [ 610 | { 611 | "output_type": "stream", 612 | "text": [ 613 | "torch.Size([2, 1, 512, 512])\n", 614 | "torch.Size([2, 3, 512, 512])\n" 615 | ], 616 | "name": "stdout" 617 | } 618 | ] 619 | }, 620 | { 621 | "cell_type": "code", 622 | "metadata": { 623 | "id": "iOBpnH7VnA4f" 624 | }, 625 | "source": [ 626 | "class PSNR:\n", 627 | " \"\"\"Peak Signal to Noise Ratio\n", 628 | " img1 and img2 have range [0, 255]\"\"\"\n", 629 | "\n", 630 | " def __init__(self):\n", 631 | " self.name = \"PSNR\"\n", 632 | "\n", 633 | " @staticmethod\n", 634 | " def __call__(img1, img2):\n", 635 | " mse = torch.mean((img1 - img2) ** 2)\n", 636 | " return 20 * torch.log10(255.0 / torch.sqrt(mse))\n" 637 | ], 638 | "execution_count": 20, 639 | "outputs": [] 640 | }, 641 | { 642 | "cell_type": "markdown", 643 | "metadata": { 644 | "id": "0wg7mYyzll_A" 645 | }, 646 | "source": [ 647 | "**MODULE 3 : Training**" 648 | ] 649 | }, 650 | { 651 | "cell_type": "markdown", 652 | "metadata": { 653 | "id": "jzpzfp66WdvW" 654 | }, 655 | "source": [ 656 | "**SAVE CHECKPOINT**" 657 | ] 658 | }, 659 | { 660 | "cell_type": "code", 661 | "metadata": { 662 | "id": "Bx72WwzNWhC7" 663 | }, 664 | "source": [ 665 | "def save_ckp(checkpoint, checkpoint_path):\n", 666 | " torch.save(checkpoint, checkpoint_path)" 667 | ], 668 | "execution_count": 21, 669 | "outputs": [] 670 | }, 671 | { 672 | "cell_type": "markdown", 673 | "metadata": { 674 | "id": "4nsJKr9QWhrT" 675 | }, 676 | "source": [ 677 | "**LOAD CHECKPOINT**" 678 | ] 679 | }, 680 | { 681 | "cell_type": "code", 682 | "metadata": { 683 | "id": "QYwO7XeWWmOJ" 684 | }, 685 | "source": [ 686 | "def load_ckp(checkpoint_path, model, model_opt):\n", 687 | " checkpoint = torch.load(checkpoint_path)\n", 688 | " model.load_state_dict(checkpoint['state_dict'])\n", 689 | " model_opt.load_state_dict(checkpoint['optimizer'])\n", 690 | " return model, model_opt, checkpoint['epoch']" 691 | ], 692 | "execution_count": 22, 693 | "outputs": [] 694 | }, 695 | { 696 | "cell_type": "markdown", 697 | "metadata": { 698 | "id": "sncpj_TLGqAO" 699 | }, 700 | "source": [ 701 | "**TRAIN EPOCH**" 702 | ] 703 | }, 704 | { 705 | "cell_type": "code", 706 | "metadata": { 707 | "id": "MFbFHbMuBz6S" 708 | }, 709 | "source": [ 710 | "def train_epoch(train_loader, model, optimizer, epoch):\n", 711 | "\n", 712 | " progress_bar = tqdm(enumerate(train_loader))\n", 713 | " total_loss = 0.0\n", 714 | " for step, (high_res_img, low_res_img) in progress_bar:\n", 715 | " # if high_res_img is None and low_res_img is None:\n", 716 | " # continue\n", 717 | " model.train()\n", 718 | " high_res_img = high_res_img.to(device)\n", 719 | " low_res_img = low_res_img.to(device)\n", 720 | "\n", 721 | " optimizer.zero_grad()\n", 722 | "\n", 723 | " pred_img = model.forward(low_res_img)\n", 724 | "\n", 725 | " mse = nn.MSELoss()\n", 726 | " psnr = PSNR()\n", 727 | "\n", 728 | " mse_loss = mse(pred_img, high_res_img)\n", 729 | " psnr_loss = psnr(pred_img*255.0, high_res_img*255.0)\n", 730 | "\n", 731 | " loss = mse_loss\n", 732 | "\n", 733 | " # print(loss)\n", 734 | " loss.backward()\n", 735 | " optimizer.step()\n", 736 | "\n", 737 | " progress_bar.set_description(\n", 738 | " \"Epoch : {} Training Loss : {} \".format(epoch, loss))\n", 739 | "\n", 740 | "\n", 741 | " return model, optimizer" 742 | ], 743 | "execution_count": 23, 744 | "outputs": [] 745 | }, 746 | { 747 | "cell_type": "markdown", 748 | "metadata": { 749 | "id": "-MI5PZkyGx5J" 750 | }, 751 | "source": [ 752 | "**VAL EPOCH**" 753 | ] 754 | }, 755 | { 756 | "cell_type": "code", 757 | "metadata": { 758 | "id": "Im6okWc4BvJn" 759 | }, 760 | "source": [ 761 | "def val_epoch(val_loader, model, optimizer, epoch):\n", 762 | "\n", 763 | " progress_bar = tqdm(enumerate(val_loader))\n", 764 | " total_loss = 0.0\n", 765 | " for step, (high_res_img, low_res_img) in progress_bar:\n", 766 | "\n", 767 | " try :\n", 768 | " if high_res_img is None and low_res_img is None:\n", 769 | " continue\n", 770 | "\n", 771 | " high_res_img = high_res_img.to(device)\n", 772 | " low_res_img = low_res_img.to(device)\n", 773 | "\n", 774 | " mse = nn.MSELoss()\n", 775 | " psnr = PSNR()\n", 776 | "\n", 777 | " model.eval()\n", 778 | " pred_img = model.forward(low_res_img)\n", 779 | "\n", 780 | " mse_loss = mse(pred_img, high_res_img)\n", 781 | " psnr_loss = psnr(pred_img*255.0, high_res_img*255.0)\n", 782 | "\n", 783 | " loss = mse_loss\n", 784 | "\n", 785 | " progress_bar.set_description(\n", 786 | " \"Epoch : {} Validation Loss : {} \".format(epoch-1, loss))\n", 787 | " except :\n", 788 | " continue\n" 789 | ], 790 | "execution_count": 24, 791 | "outputs": [] 792 | }, 793 | { 794 | "cell_type": "markdown", 795 | "metadata": { 796 | "id": "HNpkA_8fG2cH" 797 | }, 798 | "source": [ 799 | "**TEST EPOCH**" 800 | ] 801 | }, 802 | { 803 | "cell_type": "code", 804 | "metadata": { 805 | "id": "Mr6f0cRmBtXi" 806 | }, 807 | "source": [ 808 | "def test_epoch(test_loader, model, optimizer, epoch):\n", 809 | "\n", 810 | " progress_bar = tqdm(enumerate(test_loader))\n", 811 | " total_loss = 0.0\n", 812 | "\n", 813 | " no_img_to_write = 10\n", 814 | " inference_folder = \"/content/IMAGE_SUPER_RESOLVE_DATA/inference_data\"\n", 815 | " if not os.path.isdir(inference_folder):\n", 816 | " os.mkdir(inference_folder)\n", 817 | "\n", 818 | " if not os.path.isdir(os.path.join(inference_folder, str(epoch))):\n", 819 | " os.mkdir(os.path.join(inference_folder, str(epoch)))\n", 820 | "\n", 821 | " for step, (high_res_img, low_res_img) in progress_bar:\n", 822 | "\n", 823 | " try:\n", 824 | " if high_res_img is None and low_res_img is None:\n", 825 | " continue\n", 826 | "\n", 827 | " high_res_img = high_res_img.to(device)\n", 828 | " low_res_img = low_res_img.to(device)\n", 829 | "\n", 830 | " mse = nn.MSELoss()\n", 831 | " l1 = nn.L1Loss()\n", 832 | " psnr = PSNR()\n", 833 | "\n", 834 | " model.eval()\n", 835 | " pred_img = model.forward(low_res_img)\n", 836 | "\n", 837 | " #mse_loss = mse(pred_img, high_res_img)\n", 838 | " #psnr_loss = psnr(pred_img*255.0, high_res_img*255.0)\n", 839 | " l1_loss = l1(pred_img, high_res_img)\n", 840 | "\n", 841 | " loss = l1_loss\n", 842 | "\n", 843 | " progress_bar.set_description(\n", 844 | " \"Epoch : {} Test Loss : {} \".format(epoch-1, loss))\n", 845 | "\n", 846 | " if(step < no_img_to_write):\n", 847 | "\n", 848 | " p_img = pred_img.cpu().numpy().transpose(0, 2, 3, 1) * 255\n", 849 | " gt_img = high_res_img.cpu().numpy().transpose(0, 2, 3, 1) * 255\n", 850 | " inp_img = low_res_img.cpu().numpy().transpose(0, 2, 3, 1) * 255\n", 851 | "\n", 852 | " # cv2.imwrite(os.path.join(inference_folder, str(epoch),\n", 853 | " # \"img_\"+str(step)+\"_pred.jpg\"), p_img[0])\n", 854 | " # cv2.imwrite(os.path.join(inference_folder, str(epoch),\n", 855 | " # \"img_\"+str(step)+\"_gt.jpg\"), gt_img[0])\n", 856 | " # cv2.imwrite(os.path.join(inference_folder, str(epoch),\n", 857 | " # \"img_\"+str(step)+\"_inp.jpg\"), inp_img[0])\n", 858 | " except :\n", 859 | " continue" 860 | ], 861 | "execution_count": 27, 862 | "outputs": [] 863 | }, 864 | { 865 | "cell_type": "markdown", 866 | "metadata": { 867 | "id": "1t3jslWRG6sR" 868 | }, 869 | "source": [ 870 | "**Code to control the Train, Test & Val**" 871 | ] 872 | }, 873 | { 874 | "cell_type": "code", 875 | "metadata": { 876 | "id": "WOj06fhkBfON" 877 | }, 878 | "source": [ 879 | "def train_val_test(train_loader, val_loader, test_loader, model, optimizer, n_epoch, resume):\n", 880 | "\n", 881 | " checkpoint_path = \"/content/IMAGE_SUPER_RESOLVE_DATA/checkpoint.pt\"\n", 882 | "\n", 883 | " epoch = 0\n", 884 | " if resume:\n", 885 | " model, optimizer, epoch = load_ckp(\n", 886 | " checkpoint_path, model, optimizer)\n", 887 | "\n", 888 | " while 1:\n", 889 | " model, optimizer = train_epoch(train_loader, model, optimizer, epoch)\n", 890 | " checkpoint = {'epoch': epoch+1, 'state_dict': model.state_dict(),\n", 891 | " 'optimizer': optimizer.state_dict()}\n", 892 | " save_ckp(checkpoint, checkpoint_path)\n", 893 | " print(\"Checkpoint Saved\")\n", 894 | " # model, optimizer, epoch = load_ckp(checkpoint_path, model, optimizer)\n", 895 | " # print(\"Checkpoint Loaded\")\n", 896 | " with torch.no_grad():\n", 897 | " val_epoch(val_loader, model, optimizer, epoch)\n", 898 | " test_epoch(test_loader, model, optimizer, epoch)" 899 | ], 900 | "execution_count": 26, 901 | "outputs": [] 902 | }, 903 | { 904 | "cell_type": "markdown", 905 | "metadata": { 906 | "id": "DjZ7fZkUWOO4" 907 | }, 908 | "source": [ 909 | "**MAIN FUNCTION**" 910 | ] 911 | }, 912 | { 913 | "cell_type": "code", 914 | "metadata": { 915 | "id": "d80vuRX7nDFM" 916 | }, 917 | "source": [ 918 | "def main():\n", 919 | "\n", 920 | " parent_folder = \"/content/IMAGE_SUPER_RESOLVE_DATA\"\n", 921 | " extracted_data_folder = os.path.join(parent_folder, \"extracted_data\")\n", 922 | " image_data_folder = os.path.join(extracted_data_folder, \"images\")\n", 923 | " image_address_list = get_image_address(image_data_folder)\n", 924 | " random.shuffle(image_address_list)\n", 925 | "\n", 926 | " train_img_addr_list = image_address_list[:int(0.7*len(image_address_list))]\n", 927 | " val_img_addr_list = image_address_list[len(train_img_addr_list):int(\n", 928 | " len(train_img_addr_list) + 0.2*len(image_address_list))]\n", 929 | " test_img_addr_list = image_address_list[len(\n", 930 | " train_img_addr_list) + len(val_img_addr_list):]\n", 931 | "\n", 932 | " print(\"Total Number of Images : \", len(image_address_list))\n", 933 | " print(\"Train : {} Val : {} Test : {}\".format(\n", 934 | " len(train_img_addr_list), len(val_img_addr_list), len(test_img_addr_list)))\n", 935 | "\n", 936 | " train_loader = load_data(\n", 937 | " train_img_addr_list, batch_size=2, num_workers=2, shuffle=True)\n", 938 | " val_loader = load_data(val_img_addr_list, batch_size=2,\n", 939 | " num_workers=2, shuffle=True)\n", 940 | " test_loader = load_data(\n", 941 | " test_img_addr_list, batch_size=1, num_workers=2, shuffle=False)\n", 942 | "\n", 943 | " model = Image_Super_Resolve()\n", 944 | " model = model.to(device)\n", 945 | " optimizer = optim.Adam(\n", 946 | " [p for p in model.parameters() if p.requires_grad], lr=0.01)\n", 947 | " n_epoch = 100\n", 948 | " resume = False\n", 949 | " train_val_test(train_loader, val_loader, test_loader,\n", 950 | " model, optimizer, n_epoch, resume)" 951 | ], 952 | "execution_count": 28, 953 | "outputs": [] 954 | }, 955 | { 956 | "cell_type": "markdown", 957 | "metadata": { 958 | "id": "vwxERyJxWTFz" 959 | }, 960 | "source": [ 961 | "**CALLING THE MAIN FUNCTION**" 962 | ] 963 | }, 964 | { 965 | "cell_type": "code", 966 | "metadata": { 967 | "id": "R8TmBvZEDTp6", 968 | "colab": { 969 | "base_uri": "https://localhost:8080/", 970 | "height": 1000 971 | }, 972 | "outputId": "6d66510d-0a6f-450d-fa5b-b5177bfdffb4" 973 | }, 974 | "source": [ 975 | "main()" 976 | ], 977 | "execution_count": 29, 978 | "outputs": [ 979 | { 980 | "output_type": "stream", 981 | "text": [ 982 | "Number of Files : 7384\n", 983 | "Number of Files after removing : 7384\n", 984 | "Total Number of Images : 7384\n", 985 | "Train : 5168 Val : 1476 Test : 740\n" 986 | ], 987 | "name": "stdout" 988 | }, 989 | { 990 | "output_type": "stream", 991 | "text": [ 992 | "Epoch : 0 Training Loss : 0.07829584926366806 : : 5it [00:02, 2.43it/s]" 993 | ], 994 | "name": "stderr" 995 | }, 996 | { 997 | "output_type": "stream", 998 | "text": [ 999 | "Checkpoint Saved\n" 1000 | ], 1001 | "name": "stdout" 1002 | }, 1003 | { 1004 | "output_type": "stream", 1005 | "text": [ 1006 | "\n", 1007 | "Epoch : -1 Validation Loss : 0.3999069631099701 : : 5it [00:00, 6.73it/s]\n", 1008 | "Epoch : -1 Test Loss : 0.4609988331794739 : : 10it [00:00, 12.86it/s]\n", 1009 | "Epoch : 0 Training Loss : 0.05630511790513992 : : 5it [00:01, 2.62it/s]" 1010 | ], 1011 | "name": "stderr" 1012 | }, 1013 | { 1014 | "output_type": "stream", 1015 | "text": [ 1016 | "Checkpoint Saved\n" 1017 | ], 1018 | "name": "stdout" 1019 | }, 1020 | { 1021 | "output_type": "stream", 1022 | "text": [ 1023 | "\n", 1024 | "Epoch : -1 Validation Loss : 0.15192380547523499 : : 5it [00:00, 6.82it/s]\n", 1025 | "Epoch : -1 Test Loss : 0.3490328788757324 : : 10it [00:00, 13.25it/s]\n", 1026 | "Epoch : 0 Training Loss : 0.047594211995601654 : : 5it [00:01, 2.60it/s]" 1027 | ], 1028 | "name": "stderr" 1029 | }, 1030 | { 1031 | "output_type": "stream", 1032 | "text": [ 1033 | "Checkpoint Saved\n" 1034 | ], 1035 | "name": "stdout" 1036 | }, 1037 | { 1038 | "output_type": "stream", 1039 | "text": [ 1040 | "\n", 1041 | "Epoch : -1 Validation Loss : 0.06959714740514755 : : 5it [00:00, 7.03it/s]\n", 1042 | "Epoch : -1 Test Loss : 0.22591321170330048 : : 10it [00:00, 13.05it/s]\n", 1043 | "Epoch : 0 Training Loss : 0.04837007075548172 : : 5it [00:01, 2.57it/s]" 1044 | ], 1045 | "name": "stderr" 1046 | }, 1047 | { 1048 | "output_type": "stream", 1049 | "text": [ 1050 | "Checkpoint Saved\n" 1051 | ], 1052 | "name": "stdout" 1053 | }, 1054 | { 1055 | "output_type": "stream", 1056 | "text": [ 1057 | "\n", 1058 | "Epoch : -1 Validation Loss : 0.06871086359024048 : : 5it [00:00, 6.72it/s]\n", 1059 | "Epoch : -1 Test Loss : 0.18924197554588318 : : 10it [00:00, 13.37it/s]\n", 1060 | "Epoch : 0 Training Loss : 0.04076924920082092 : : 5it [00:01, 2.57it/s]" 1061 | ], 1062 | "name": "stderr" 1063 | }, 1064 | { 1065 | "output_type": "stream", 1066 | "text": [ 1067 | "Checkpoint Saved\n" 1068 | ], 1069 | "name": "stdout" 1070 | }, 1071 | { 1072 | "output_type": "stream", 1073 | "text": [ 1074 | "\n", 1075 | "Epoch : -1 Validation Loss : 0.037644024938344955 : : 5it [00:00, 6.30it/s]\n", 1076 | "Epoch : -1 Test Loss : 0.17227113246917725 : : 10it [00:00, 13.03it/s]\n", 1077 | "Epoch : 0 Training Loss : 0.034246839582920074 : : 5it [00:01, 2.60it/s]" 1078 | ], 1079 | "name": "stderr" 1080 | }, 1081 | { 1082 | "output_type": "stream", 1083 | "text": [ 1084 | "Checkpoint Saved\n" 1085 | ], 1086 | "name": "stdout" 1087 | }, 1088 | { 1089 | "output_type": "stream", 1090 | "text": [ 1091 | "\n", 1092 | "Epoch : -1 Validation Loss : 0.043083518743515015 : : 5it [00:00, 6.88it/s]\n", 1093 | "Epoch : -1 Test Loss : 0.159893199801445 : : 10it [00:00, 13.27it/s]\n", 1094 | "Epoch : 0 Training Loss : 0.02342107892036438 : : 5it [00:01, 2.61it/s]" 1095 | ], 1096 | "name": "stderr" 1097 | }, 1098 | { 1099 | "output_type": "stream", 1100 | "text": [ 1101 | "Checkpoint Saved\n" 1102 | ], 1103 | "name": "stdout" 1104 | }, 1105 | { 1106 | "output_type": "stream", 1107 | "text": [ 1108 | "\n", 1109 | "Epoch : -1 Validation Loss : 0.03414853662252426 : : 5it [00:00, 6.63it/s]\n", 1110 | "Epoch : -1 Test Loss : 0.14629341661930084 : : 10it [00:00, 13.22it/s]\n", 1111 | "Epoch : 0 Training Loss : 0.03479604423046112 : : 5it [00:01, 2.58it/s]" 1112 | ], 1113 | "name": "stderr" 1114 | }, 1115 | { 1116 | "output_type": "stream", 1117 | "text": [ 1118 | "Checkpoint Saved\n" 1119 | ], 1120 | "name": "stdout" 1121 | }, 1122 | { 1123 | "output_type": "stream", 1124 | "text": [ 1125 | "\n", 1126 | "Epoch : -1 Validation Loss : 0.03475822135806084 : : 5it [00:00, 7.00it/s]\n", 1127 | "Epoch : -1 Test Loss : 0.1355130523443222 : : 10it [00:00, 13.24it/s]\n", 1128 | "Epoch : 0 Training Loss : 0.021552659571170807 : : 5it [00:01, 2.57it/s]" 1129 | ], 1130 | "name": "stderr" 1131 | }, 1132 | { 1133 | "output_type": "stream", 1134 | "text": [ 1135 | "Checkpoint Saved\n" 1136 | ], 1137 | "name": "stdout" 1138 | }, 1139 | { 1140 | "output_type": "stream", 1141 | "text": [ 1142 | "\n", 1143 | "Epoch : -1 Validation Loss : 0.02842155657708645 : : 5it [00:00, 7.17it/s]\n", 1144 | "Epoch : -1 Test Loss : 0.11862193793058395 : : 10it [00:00, 13.04it/s]\n", 1145 | "Epoch : 0 Training Loss : 0.019530709832906723 : : 5it [00:01, 2.60it/s]" 1146 | ], 1147 | "name": "stderr" 1148 | }, 1149 | { 1150 | "output_type": "stream", 1151 | "text": [ 1152 | "Checkpoint Saved\n" 1153 | ], 1154 | "name": "stdout" 1155 | }, 1156 | { 1157 | "output_type": "stream", 1158 | "text": [ 1159 | "\n", 1160 | "Epoch : -1 Validation Loss : 0.024070754647254944 : : 5it [00:00, 6.79it/s]\n", 1161 | "Epoch : -1 Test Loss : 0.09877555072307587 : : 10it [00:00, 12.99it/s]\n", 1162 | "Epoch : 0 Training Loss : 0.017261836677789688 : : 5it [00:01, 2.57it/s]" 1163 | ], 1164 | "name": "stderr" 1165 | }, 1166 | { 1167 | "output_type": "stream", 1168 | "text": [ 1169 | "Checkpoint Saved\n" 1170 | ], 1171 | "name": "stdout" 1172 | }, 1173 | { 1174 | "output_type": "stream", 1175 | "text": [ 1176 | "\n", 1177 | "Epoch : -1 Validation Loss : 0.0100233880802989 : : 5it [00:00, 7.07it/s]\n", 1178 | "Epoch : -1 Test Loss : 0.09105490148067474 : : 10it [00:00, 13.22it/s]\n", 1179 | "Epoch : 0 Training Loss : 0.014956777915358543 : : 3it [00:01, 1.98it/s]\n" 1180 | ], 1181 | "name": "stderr" 1182 | }, 1183 | { 1184 | "output_type": "error", 1185 | "ename": "KeyboardInterrupt", 1186 | "evalue": "ignored", 1187 | "traceback": [ 1188 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 1189 | "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", 1190 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 1191 | "\u001b[0;32m\u001b[0m in \u001b[0;36mmain\u001b[0;34m()\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0mresume\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 32\u001b[0m train_val_test(train_loader, val_loader, test_loader,\n\u001b[0;32m---> 33\u001b[0;31m model, optimizer, n_epoch, resume)\n\u001b[0m", 1192 | "\u001b[0;32m\u001b[0m in \u001b[0;36mtrain_val_test\u001b[0;34m(train_loader, val_loader, test_loader, model, optimizer, n_epoch, resume)\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptimizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain_epoch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_loader\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepoch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 12\u001b[0m checkpoint = {'epoch': epoch+1, 'state_dict': model.state_dict(),\n\u001b[1;32m 13\u001b[0m 'optimizer': optimizer.state_dict()}\n", 1193 | "\u001b[0;32m\u001b[0m in \u001b[0;36mtrain_epoch\u001b[0;34m(train_loader, model, optimizer, epoch)\u001b[0m\n\u001b[1;32m 27\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 28\u001b[0m progress_bar.set_description(\n\u001b[0;32m---> 29\u001b[0;31m \"Epoch : {} Training Loss : {} \".format(epoch, loss))\n\u001b[0m\u001b[1;32m 30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", 1194 | "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/torch/_tensor.py\u001b[0m in \u001b[0;36m__format__\u001b[0;34m(self, format_spec)\u001b[0m\n\u001b[1;32m 558\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mhandle_torch_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__format__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mformat_spec\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 559\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 560\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__format__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mformat_spec\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 561\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mobject\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__format__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mformat_spec\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 562\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", 1195 | "\u001b[0;31mKeyboardInterrupt\u001b[0m: " 1196 | ] 1197 | } 1198 | ] 1199 | }, 1200 | { 1201 | "cell_type": "markdown", 1202 | "metadata": { 1203 | "id": "0nb3p4nMZcue" 1204 | }, 1205 | "source": [ 1206 | "**INFERENCE**" 1207 | ] 1208 | }, 1209 | { 1210 | "cell_type": "code", 1211 | "metadata": { 1212 | "colab": { 1213 | "base_uri": "https://localhost:8080/", 1214 | "height": 167 1215 | }, 1216 | "id": "7cGdz-wLZf0e", 1217 | "outputId": "c59e892f-7840-4e6c-ad3d-ca912353a13a" 1218 | }, 1219 | "source": [ 1220 | "image_folder = \"/content/IMAGE_SUPER_RESOLVE_DATA/extracted_data/images\"\n", 1221 | "checkpoint_path = \"/content/IMAGE_SUPER_RESOLVE_DATA/checkpoint.pt\"\n", 1222 | "\n", 1223 | "img_addr = os.path.join(image_folder, \"Abyssinian_2.jpg\")\n", 1224 | "img = cv2.imread(img_addr)\n", 1225 | "high_res_img = cv2.resize(img,(512,512))\n", 1226 | "low_res_img = cv2.resize(img,(512, 512))\n", 1227 | "low_res_img = cv2.cvtColor(low_res_img, cv2.COLOR_BGR2GRAY)\n", 1228 | "low_res_img = np.reshape(low_res_img, (512, 512, 1))\n", 1229 | "\n", 1230 | "low_res_img = np.transpose(low_res_img, (2, 0, 1))\n", 1231 | "\n", 1232 | "low_res_img = torch.FloatTensor(low_res_img/255.).unsqueeze(0)\n", 1233 | "\n", 1234 | "\n", 1235 | "model = Image_Super_Resolve()\n", 1236 | "model = model.to(device)\n", 1237 | "optimizer = optim.Adam(\n", 1238 | " [p for p in model.parameters() if p.requires_grad], lr=0.01)\n", 1239 | "model, optimizer, epoch = load_ckp(checkpoint_path, model, optimizer)\n", 1240 | "low_res_img = low_res_img.to(device)\n", 1241 | "pred_img = model.forward(low_res_img)\n", 1242 | "\n", 1243 | "p_img = pred_img.detach().cpu().numpy().transpose(0, 2, 3, 1)[0]\n", 1244 | "\n", 1245 | "# p_img = cv2.cvtColor(p_img, )\n", 1246 | "inp_img = low_res_img.cpu().numpy().transpose(0, 2, 3, 1)[0]\n", 1247 | "\n", 1248 | "inp_img = np.reshape(inp_img, (512, 512))\n", 1249 | "#p_img = np.reshape(p_img, (512, 512, 3))\n", 1250 | "\n", 1251 | "high_res_img = cv2.cvtColor(high_res_img, cv2.COLOR_BGR2RGB)\n", 1252 | "p_img = cv2.cvtColor(p_img, cv2.COLOR_BGR2RGB)\n", 1253 | "\n", 1254 | "f, axarr = plt.subplots(1,3)\n", 1255 | "axarr[0].imshow(inp_img, cmap='gray')\n", 1256 | "axarr[1].imshow(p_img)\n", 1257 | "axarr[2].imshow(high_res_img)\n", 1258 | "\n", 1259 | "# print(\"Ground Truth\")\n", 1260 | "# plt.imshow(high_res_img[:,:,::-1])\n", 1261 | "# plt.show()\n", 1262 | "\n", 1263 | "# print(\"Input Image\")\n", 1264 | "# plt.imshow(inp_img[0, :,:,::-1])\n", 1265 | "# plt.show()\n", 1266 | "\n", 1267 | "# print(\"Predicted Image\")\n", 1268 | "# plt.imshow(p_img[0, :,:,::-1])\n", 1269 | "# plt.show()" 1270 | ], 1271 | "execution_count": 46, 1272 | "outputs": [ 1273 | { 1274 | "output_type": "execute_result", 1275 | "data": { 1276 | "text/plain": [ 1277 | "" 1278 | ] 1279 | }, 1280 | "metadata": {}, 1281 | "execution_count": 46 1282 | }, 1283 | { 1284 | "output_type": "display_data", 1285 | "data": { 1286 | "image/png": "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\n", 1287 | "text/plain": [ 1288 | "
" 1289 | ] 1290 | }, 1291 | "metadata": { 1292 | "needs_background": "light" 1293 | } 1294 | } 1295 | ] 1296 | } 1297 | ] 1298 | } --------------------------------------------------------------------------------