From 4a4d27f05ee7d710d5f8f5f3cbb20932ad242b91 Mon Sep 17 00:00:00 2001 From: Aditya Sharma Date: Sat, 24 Oct 2020 18:47:14 +0530 Subject: [PATCH 1/4] Create Beginner_GAN_Pytorch_Tensorflow --- Beginner_GAN_Pytorch_Tensorflow | 1 + 1 file changed, 1 insertion(+) create mode 100644 Beginner_GAN_Pytorch_Tensorflow diff --git a/Beginner_GAN_Pytorch_Tensorflow b/Beginner_GAN_Pytorch_Tensorflow new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/Beginner_GAN_Pytorch_Tensorflow @@ -0,0 +1 @@ + From 028bea0b1875f7704147d266818637666f607e73 Mon Sep 17 00:00:00 2001 From: Aditya Sharma Date: Sat, 24 Oct 2020 18:47:28 +0530 Subject: [PATCH 2/4] Delete Beginner_GAN_Pytorch_Tensorflow --- Beginner_GAN_Pytorch_Tensorflow | 1 - 1 file changed, 1 deletion(-) delete mode 100644 Beginner_GAN_Pytorch_Tensorflow diff --git a/Beginner_GAN_Pytorch_Tensorflow b/Beginner_GAN_Pytorch_Tensorflow deleted file mode 100644 index 8b1378917..000000000 --- a/Beginner_GAN_Pytorch_Tensorflow +++ /dev/null @@ -1 +0,0 @@ - From aff107122f9d32509fb3ca43fdae577bf8bfe181 Mon Sep 17 00:00:00 2001 From: aditya-ai Date: Sun, 8 Nov 2020 02:33:04 +0530 Subject: [PATCH 3/4] Added DCGAN Codebase --- DCGAN/DCGAN_Anime_Pytorch.ipynb | 598 +++++++++++++++++++++++++ DCGAN/DCGAN_Anime_Tensorflow.ipynb | 686 +++++++++++++++++++++++++++++ 2 files changed, 1284 insertions(+) create mode 100644 DCGAN/DCGAN_Anime_Pytorch.ipynb create mode 100644 DCGAN/DCGAN_Anime_Tensorflow.ipynb diff --git a/DCGAN/DCGAN_Anime_Pytorch.ipynb b/DCGAN/DCGAN_Anime_Pytorch.ipynb new file mode 100644 index 000000000..c2e7edfc3 --- /dev/null +++ b/DCGAN/DCGAN_Anime_Pytorch.ipynb @@ -0,0 +1,598 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "U6zXv_t2jXEa" + }, + "outputs": [], + "source": [ + "%load_ext tensorboard" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Nln2VA_bjYsy" + }, + "outputs": [], + "source": [ + "!mkdir dcgan" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "D54v_DF0jakG" + }, + "outputs": [], + "source": [ + "!mkdir dcgan/images" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!mkdir dcgan/checkpoint-100/" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "yoj6U2rmjiS-" + }, + "outputs": [], + "source": [ + "import os\n", + "import torch\n", + "import numpy as np\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torchvision import datasets, transforms\n", + "from torch.autograd import Variable\n", + "from torchvision.utils import save_image\n", + "from torchvision.utils import make_grid\n", + "from torch.utils.tensorboard import SummaryWriter\n", + "from torchsummary import summary\n", + "import datetime\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "os.environ['CUDA_VISIBLE_DEVICES'] = '0'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "id": "-S2ZtWdajpz3", + "outputId": "dce7d573-ddc8-4e5d-8f8f-d791fe517150" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "torch.manual_seed(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "56IrzS6xmqTk" + }, + "outputs": [], + "source": [ + "writer = SummaryWriter('dcgan/writer')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "xVXC_q2ekuf8" + }, + "outputs": [], + "source": [ + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "batch_size = 128" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "rmKRUtX6kwt1" + }, + "outputs": [], + "source": [ + "train_transform = transforms.Compose([transforms.Resize((64, 64)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])\n", + "train_dataset = datasets.ImageFolder(root='anime', transform=train_transform)\n", + "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def show_images(images):\n", + " fig, ax = plt.subplots(figsize=(20, 20))\n", + " ax.set_xticks([]); ax.set_yticks([])\n", + " ax.imshow(make_grid(images.detach(), nrow=8).permute(1, 2, 0))\n", + "\n", + "def show_batch(dl):\n", + " for images, _ in dl:\n", + " show_images(images)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#show_batch(train_loader)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "0ImLVM7lk2du" + }, + "outputs": [], + "source": [ + "image_shape = (3, 64, 64)\n", + "image_dim = int(np.prod(image_shape))\n", + "latent_dim = 100" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# custom weights initialization called on generator and discriminator\n", + "def weights_init(m):\n", + " classname = m.__class__.__name__\n", + " if classname.find('Conv') != -1:\n", + " torch.nn.init.normal_(m.weight, 0.0, 0.02)\n", + " elif classname.find('BatchNorm') != -1:\n", + " torch.nn.init.normal_(m.weight, 1.0, 0.02)\n", + " torch.nn.init.zeros_(m.bias)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "_gw3SMN7jtOB" + }, + "outputs": [], + "source": [ + "# Generator Model Class Definition \n", + "class Generator(nn.Module):\n", + " def __init__(self):\n", + " super(Generator, self).__init__()\n", + " self.main = nn.Sequential(\n", + " # Block 1:input is Z, going into a convolution\n", + " nn.ConvTranspose2d(latent_dim, 64 * 8, 4, 1, 0, bias=False),\n", + " nn.BatchNorm2d(64 * 8),\n", + " nn.ReLU(True),\n", + " # Block 2: (64 * 8) x 4 x 4\n", + " nn.ConvTranspose2d(64 * 8, 64 * 4, 4, 2, 1, bias=False),\n", + " nn.BatchNorm2d(64 * 4),\n", + " nn.ReLU(True),\n", + " # Block 3: (64 * 4) x 8 x 8\n", + " nn.ConvTranspose2d(64 * 4, 64 * 2, 4, 2, 1, bias=False),\n", + " nn.BatchNorm2d(64 * 2),\n", + " nn.ReLU(True),\n", + " # Block 4: (64 * 2) x 16 x 16\n", + " nn.ConvTranspose2d(64 * 2, 64, 4, 2, 1, bias=False),\n", + " nn.BatchNorm2d(64),\n", + " nn.ReLU(True),\n", + " # Block 5: (64) x 32 x 32\n", + " nn.ConvTranspose2d(64, 3, 4, 2, 1, bias=False),\n", + " nn.Tanh()\n", + " # Output: (3) x 64 x 64\n", + " )\n", + "\n", + " def forward(self, input):\n", + " output = self.main(input)\n", + " return output " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generator(\n", + " (main): Sequential(\n", + " (0): ConvTranspose2d(100, 512, kernel_size=(4, 4), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): ConvTranspose2d(512, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (5): ReLU(inplace=True)\n", + " (6): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (7): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (8): ReLU(inplace=True)\n", + " (9): ConvTranspose2d(128, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (10): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (11): ReLU(inplace=True)\n", + " (12): ConvTranspose2d(64, 3, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (13): Tanh()\n", + " )\n", + ")\n" + ] + } + ], + "source": [ + "generator = Generator().to(device)\n", + "generator.apply(weights_init)\n", + "print(generator)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------------------------------\n", + " Layer (type) Output Shape Param #\n", + "================================================================\n", + " ConvTranspose2d-1 [-1, 512, 4, 4] 819,200\n", + " BatchNorm2d-2 [-1, 512, 4, 4] 1,024\n", + " ReLU-3 [-1, 512, 4, 4] 0\n", + " ConvTranspose2d-4 [-1, 256, 8, 8] 2,097,152\n", + " BatchNorm2d-5 [-1, 256, 8, 8] 512\n", + " ReLU-6 [-1, 256, 8, 8] 0\n", + " ConvTranspose2d-7 [-1, 128, 16, 16] 524,288\n", + " BatchNorm2d-8 [-1, 128, 16, 16] 256\n", + " ReLU-9 [-1, 128, 16, 16] 0\n", + " ConvTranspose2d-10 [-1, 64, 32, 32] 131,072\n", + " BatchNorm2d-11 [-1, 64, 32, 32] 128\n", + " ReLU-12 [-1, 64, 32, 32] 0\n", + " ConvTranspose2d-13 [-1, 3, 64, 64] 3,072\n", + " Tanh-14 [-1, 3, 64, 64] 0\n", + "================================================================\n", + "Total params: 3,576,704\n", + "Trainable params: 3,576,704\n", + "Non-trainable params: 0\n", + "----------------------------------------------------------------\n", + "Input size (MB): 0.00\n", + "Forward/backward pass size (MB): 3.00\n", + "Params size (MB): 13.64\n", + "Estimated Total Size (MB): 16.64\n", + "----------------------------------------------------------------\n" + ] + } + ], + "source": [ + "summary(generator, (100,1,1))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "xPEMXbaJCPsQ" + }, + "outputs": [], + "source": [ + "# Discriminator Model Class Definition\n", + "class Discriminator(nn.Module):\n", + " def __init__(self):\n", + " super(Discriminator, self).__init__()\n", + " self.main = nn.Sequential(\n", + " # Block 1: (3) x 64 x 64\n", + " nn.Conv2d(3, 64, 4, 2, 1, bias=False),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " # Block 2: (64) x 32 x 32\n", + " nn.Conv2d(64, 64 * 2, 4, 2, 1, bias=False),\n", + " nn.BatchNorm2d(64 * 2),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " # Block 3: (64*2) x 16 x 16\n", + " nn.Conv2d(64 * 2, 64 * 4, 4, 2, 1, bias=False),\n", + " nn.BatchNorm2d(64 * 4),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " # Block 4: (64*4) x 8 x 8\n", + " nn.Conv2d(64 * 4, 64 * 8, 4, 2, 1, bias=False),\n", + " nn.BatchNorm2d(64 * 8),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " # Block 5: (64*8) x 4 x 4\n", + " nn.Conv2d(64 * 8, 1, 4, 1, 0, bias=False),\n", + " nn.Sigmoid()\n", + " # Output: 1 x 1 x 1\n", + " )\n", + "\n", + " def forward(self, input):\n", + " output = self.main(input)\n", + " return output.view(-1, 1).squeeze(1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "id": "1HJv-CnSkIuN" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Discriminator(\n", + " (main): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): LeakyReLU(negative_slope=0.2, inplace=True)\n", + " (2): Conv2d(64, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (3): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (4): LeakyReLU(negative_slope=0.2, inplace=True)\n", + " (5): Conv2d(128, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (6): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (7): LeakyReLU(negative_slope=0.2, inplace=True)\n", + " (8): Conv2d(256, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (9): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (10): LeakyReLU(negative_slope=0.2, inplace=True)\n", + " (11): Conv2d(512, 1, kernel_size=(4, 4), stride=(1, 1), bias=False)\n", + " (12): Sigmoid()\n", + " )\n", + ")\n" + ] + } + ], + "source": [ + "discriminator = Discriminator().to(device)\n", + "discriminator.apply(weights_init)\n", + "print(discriminator)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------------------------------------------------------------\n", + " Layer (type) Output Shape Param #\n", + "================================================================\n", + " Conv2d-1 [-1, 64, 32, 32] 3,072\n", + " LeakyReLU-2 [-1, 64, 32, 32] 0\n", + " Conv2d-3 [-1, 128, 16, 16] 131,072\n", + " BatchNorm2d-4 [-1, 128, 16, 16] 256\n", + " LeakyReLU-5 [-1, 128, 16, 16] 0\n", + " Conv2d-6 [-1, 256, 8, 8] 524,288\n", + " BatchNorm2d-7 [-1, 256, 8, 8] 512\n", + " LeakyReLU-8 [-1, 256, 8, 8] 0\n", + " Conv2d-9 [-1, 512, 4, 4] 2,097,152\n", + " BatchNorm2d-10 [-1, 512, 4, 4] 1,024\n", + " LeakyReLU-11 [-1, 512, 4, 4] 0\n", + " Conv2d-12 [-1, 1, 1, 1] 8,192\n", + " Sigmoid-13 [-1, 1, 1, 1] 0\n", + "================================================================\n", + "Total params: 2,765,568\n", + "Trainable params: 2,765,568\n", + "Non-trainable params: 0\n", + "----------------------------------------------------------------\n", + "Input size (MB): 0.05\n", + "Forward/backward pass size (MB): 2.31\n", + "Params size (MB): 10.55\n", + "Estimated Total Size (MB): 12.91\n", + "----------------------------------------------------------------\n" + ] + } + ], + "source": [ + "summary(discriminator, (3,64,64))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "RFxQC7T0laZi" + }, + "outputs": [], + "source": [ + "adversarial_loss = nn.BCELoss() " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def generator_loss(fake_output, label):\n", + " gen_loss = adversarial_loss(fake_output, label)\n", + " #print(gen_loss)\n", + " return gen_loss" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def discriminator_loss(output, label):\n", + " disc_loss = adversarial_loss(output, label)\n", + " return disc_loss" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fixed_noise = torch.randn(128, nz, 1, 1, device=device)\n", + "real_label = 1\n", + "fake_label = 0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "sis4zEVQkLf_" + }, + "outputs": [], + "source": [ + "learning_rate = 0.0002 \n", + "G_optimizer = optim.Adam(generator.parameters(), lr = learning_rate, betas=(0.5, 0.999))\n", + "D_optimizer = optim.Adam(discriminator.parameters(), lr = learning_rate, betas=(0.5, 0.999))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "LQLFEfpgkLjS" + }, + "outputs": [], + "source": [ + "num_epochs = 100\n", + "D_loss_plot, G_loss_plot = [], []\n", + "for epoch in range(1, num_epochs+1): \n", + "\n", + " D_loss_list, G_loss_list = [], []\n", + " \n", + " for index, (real_images, _) in enumerate(train_loader):\n", + " D_optimizer.zero_grad()\n", + " real_images = real_images.to(device)\n", + " \n", + " real_target = Variable(torch.ones(real_images.size(0)).to(device))\n", + " fake_target = Variable(torch.zeros(real_images.size(0)).to(device))\n", + "\n", + " D_real_loss = discriminator_loss(discriminator(real_images), real_target)\n", + " # print(discriminator(real_images))\n", + " D_real_loss.backward()\n", + " \n", + " noise_vector = torch.randn(real_images.size(0), nz, 1, 1, device=device) \n", + " noise_vector = noise_vector.to(device)\n", + " \n", + " generated_image = generator(noise_vector)\n", + " output = discriminator(generated_image.detach())\n", + " D_fake_loss = discriminator_loss(output, fake_target)\n", + "\n", + " \n", + " # train with fake\n", + " D_fake_loss.backward()\n", + " \n", + " D_total_loss = D_real_loss + D_fake_loss\n", + " D_loss_list.append(D_total_loss)\n", + " \n", + " #D_total_loss.backward()\n", + " D_optimizer.step()\n", + "\n", + " # Train generator with real labels\n", + " G_optimizer.zero_grad()\n", + " G_loss = generator_loss(discriminator(generated_image), real_target)\n", + " G_loss_list.append(G_loss)\n", + "\n", + " G_loss.backward()\n", + " G_optimizer.step()\n", + " \n", + " writer.add_scalar('Discriminator Loss',\n", + " D_total_loss,\n", + " epoch * len(train_loader) + index)\n", + " \n", + " writer.add_scalar('Generator Loss',\n", + " G_loss,\n", + " epoch * len(train_loader) + index)\n", + "\n", + "\n", + " print('Epoch: [%d/%d]: D_loss: %.3f, G_loss: %.3f' % (\n", + " (epoch), num_epochs, torch.mean(torch.FloatTensor(D_loss_list)),\\\n", + " torch.mean(torch.FloatTensor(G_loss_list))))\n", + " \n", + " D_loss_plot.append(torch.mean(torch.FloatTensor(D_loss_list)))\n", + " G_loss_plot.append(torch.mean(torch.FloatTensor(G_loss_list)))\n", + " save_image(generated_image.data[:50], 'dcgan/images/sample_%d'%epoch + '.png', nrow=5, normalize=True)\n", + " \n", + " torch.save(netG.state_dict(), 'dcgan/checkpoint-100/generator_epoch_%d.pth' % (epoch))\n", + " torch.save(netD.state_dict(), 'dcgan/checkpoint-100/discriminator_epoch_%d.pth' % (epoch))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "name": "GAN_Pytorch_Fashion-MNIST.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Blogs", + "language": "python", + "name": "blogs" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/DCGAN/DCGAN_Anime_Tensorflow.ipynb b/DCGAN/DCGAN_Anime_Tensorflow.ipynb new file mode 100644 index 000000000..5b41df1df --- /dev/null +++ b/DCGAN/DCGAN_Anime_Tensorflow.ipynb @@ -0,0 +1,686 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#!mkdir dcgan" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#!mkdir dcgan/tf" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#!mkdir dcgan/tf/images" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#!mkdir dcgan/tf/training_checkpoints" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#import the required packages\n", + "import os\n", + "import time\n", + "import keras\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers\n", + "from IPython import display\n", + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "os.environ['CUDA_VISIBLE_DEVICES'] = '1'" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "img_height, img_width = 64, 64\n", + "batch_size = 128" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 63565 files belonging to 1 classes.\n" + ] + } + ], + "source": [ + "train_ds = tf.keras.preprocessing.image_dataset_from_directory(\n", + " 'anime',\n", + " image_size=(img_height, img_width),\n", + " batch_size=batch_size,\n", + " label_mode=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 10))\n", + "for images in train_ds.take(1):\n", + " for i in range(9):\n", + " ax = plt.subplot(3, 3, i + 1)\n", + " plt.imshow(images[i].numpy().astype(\"uint8\"))\n", + " plt.axis(\"off\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(128, 64, 64, 3)\n" + ] + } + ], + "source": [ + "for image_batch in train_ds:\n", + " print(image_batch.shape)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-1" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tf.data.experimental.AUTOTUNE" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "AUTOTUNE = tf.data.experimental.AUTOTUNE\n", + "\n", + "train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "normalization_layer = layers.experimental.preprocessing.Rescaling(scale= 1./127.5, offset=-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.0 1.0\n" + ] + } + ], + "source": [ + "normalized_ds = train_ds.map(lambda x: normalization_layer(x))\n", + "image_batch = next(iter(normalized_ds))\n", + "first_image = image_batch[0]\n", + "print(np.min(first_image), np.max(first_image)) " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "noise_dim = (1,1,100)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def generator():\n", + " \n", + " inputs = keras.Input(shape=(1, 1, 100), name='input_layer')\n", + " x = layers.Conv2DTranspose(64 * 8, kernel_size=4, strides= 4, padding='same', kernel_initializer=tf.keras.initializers.RandomNormal(\n", + " mean=0.0, stddev=0.02), use_bias=False, name='conv_transpose_1')(inputs)\n", + " x = layers.BatchNormalization(momentum=0.1, epsilon=0.8, center=1.0, scale=0.02, name='bn_1')(x)\n", + " x = layers.ReLU(name='relu_1')(x)\n", + " \n", + " x = layers.Conv2DTranspose(64 * 4, kernel_size=4, strides= 2, padding='same', kernel_initializer=tf.keras.initializers.RandomNormal(\n", + " mean=0.0, stddev=0.02), use_bias=False, name='conv_transpose_2')(x)\n", + " x = layers.BatchNormalization(momentum=0.1, epsilon=0.8, center=1.0, scale=0.02, name='bn_2')(x)\n", + " x = layers.ReLU(name='relu_2')(x)\n", + " \n", + " x = layers.Conv2DTranspose(64 * 2, 4, 2, padding='same', kernel_initializer=tf.keras.initializers.RandomNormal(\n", + " mean=0.0, stddev=0.02), use_bias=False, name='conv_transpose_3')(x)\n", + " x = layers.BatchNormalization(momentum=0.1, epsilon=0.8, center=1.0, scale=0.02, name='bn_3')(x)\n", + " x = layers.ReLU(name='relu_3')(x)\n", + " \n", + "\n", + " x = layers.Conv2DTranspose(64 * 1, 4, 2, padding='same', kernel_initializer=tf.keras.initializers.RandomNormal(\n", + " mean=0.0, stddev=0.02), use_bias=False, name='conv_transpose_4')(x)\n", + " x = layers.BatchNormalization(momentum=0.1, epsilon=0.8, center=1.0, scale=0.02, name='bn_4')(x)\n", + " x = layers.ReLU(name='relu_4')(x)\n", + " \n", + " outputs = layers.Conv2DTranspose(3, 4, 2,padding='same', kernel_initializer=tf.keras.initializers.RandomNormal(\n", + " mean=0.0, stddev=0.02), use_bias=False, activation='tanh', name='conv_transpose_5')(x)\n", + " \n", + " model = tf.keras.Model(inputs, outputs, name=\"Generator\")\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "generator = generator()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"Generator\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input_layer (InputLayer) [(None, 1, 1, 100)] 0 \n", + "_________________________________________________________________\n", + "conv_transpose_1 (Conv2DTran (None, 4, 4, 512) 819200 \n", + "_________________________________________________________________\n", + "bn_1 (BatchNormalization) (None, 4, 4, 512) 2048 \n", + "_________________________________________________________________\n", + "relu_1 (ReLU) (None, 4, 4, 512) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_2 (Conv2DTran (None, 8, 8, 256) 2097152 \n", + "_________________________________________________________________\n", + "bn_2 (BatchNormalization) (None, 8, 8, 256) 1024 \n", + "_________________________________________________________________\n", + "relu_2 (ReLU) (None, 8, 8, 256) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_3 (Conv2DTran (None, 16, 16, 128) 524288 \n", + "_________________________________________________________________\n", + "bn_3 (BatchNormalization) (None, 16, 16, 128) 512 \n", + "_________________________________________________________________\n", + "relu_3 (ReLU) (None, 16, 16, 128) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_4 (Conv2DTran (None, 32, 32, 64) 131072 \n", + "_________________________________________________________________\n", + "bn_4 (BatchNormalization) (None, 32, 32, 64) 256 \n", + "_________________________________________________________________\n", + "relu_4 (ReLU) (None, 32, 32, 64) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_5 (Conv2DTran (None, 64, 64, 3) 3072 \n", + "=================================================================\n", + "Total params: 3,578,624\n", + "Trainable params: 3,576,704\n", + "Non-trainable params: 1,920\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "generator.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "generator.save('dcgan_gen.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def discriminator():\n", + " \n", + " inputs = keras.Input(shape=(64, 64, 3), name='input_layer')\n", + " x = layers.Conv2D(64, kernel_size=4, strides= 2, padding='same', kernel_initializer=tf.keras.initializers.RandomNormal(\n", + " mean=0.0, stddev=0.02), use_bias=False, name='conv_1')(inputs)\n", + " x = layers.LeakyReLU(0.2, name='leaky_relu_1')(x)\n", + " \n", + " x = layers.Conv2D(64 * 2, kernel_size=4, strides= 2, padding='same', kernel_initializer=tf.keras.initializers.RandomNormal(\n", + " mean=0.0, stddev=0.02), use_bias=False, name='conv_2')(x)\n", + " x = layers.BatchNormalization(momentum=0.1, epsilon=0.8, center=1.0, scale=0.02, name='bn_1')(x)\n", + " x = layers.LeakyReLU(0.2, name='leaky_relu_2')(x)\n", + " \n", + " x = layers.Conv2D(64 * 4, 4, 2, padding='same', kernel_initializer=tf.keras.initializers.RandomNormal(\n", + " mean=0.0, stddev=0.02), use_bias=False, name='conv_3')(x)\n", + " x = layers.BatchNormalization(momentum=0.1, epsilon=0.8, center=1.0, scale=0.02, name='bn_2')(x)\n", + " x = layers.LeakyReLU(0.2, name='leaky_relu_3')(x)\n", + " \n", + "\n", + " x = layers.Conv2D(64 * 8, 4, 2, padding='same', kernel_initializer=tf.keras.initializers.RandomNormal(\n", + " mean=0.0, stddev=0.02), use_bias=False, name='conv_4')(x)\n", + " x = layers.BatchNormalization(momentum=0.1, epsilon=0.8, center=1.0, scale=0.02, name='bn_3')(x)\n", + " x = layers.LeakyReLU(0.2, name='leaky_relu_4')(x)\n", + " \n", + " outputs = layers.Conv2D(1, 4, 2,padding='same', kernel_initializer=tf.keras.initializers.RandomNormal(\n", + " mean=0.0, stddev=0.02), use_bias=False, activation='sigmoid', name='conv_5')(x)\n", + " \n", + " model = tf.keras.Model(inputs, outputs, name=\"Discriminator\")\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "discriminator = discriminator()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"Discriminator\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input_layer (InputLayer) [(None, 64, 64, 3)] 0 \n", + "_________________________________________________________________\n", + "conv_1 (Conv2D) (None, 32, 32, 64) 3072 \n", + "_________________________________________________________________\n", + "leaky_relu_1 (LeakyReLU) (None, 32, 32, 64) 0 \n", + "_________________________________________________________________\n", + "conv_2 (Conv2D) (None, 16, 16, 128) 131072 \n", + "_________________________________________________________________\n", + "bn_1 (BatchNormalization) (None, 16, 16, 128) 512 \n", + "_________________________________________________________________\n", + "leaky_relu_2 (LeakyReLU) (None, 16, 16, 128) 0 \n", + "_________________________________________________________________\n", + "conv_3 (Conv2D) (None, 8, 8, 256) 524288 \n", + "_________________________________________________________________\n", + "bn_2 (BatchNormalization) (None, 8, 8, 256) 1024 \n", + "_________________________________________________________________\n", + "leaky_relu_3 (LeakyReLU) (None, 8, 8, 256) 0 \n", + "_________________________________________________________________\n", + "conv_4 (Conv2D) (None, 4, 4, 512) 2097152 \n", + "_________________________________________________________________\n", + "bn_3 (BatchNormalization) (None, 4, 4, 512) 2048 \n", + "_________________________________________________________________\n", + "leaky_relu_4 (LeakyReLU) (None, 4, 4, 512) 0 \n", + "_________________________________________________________________\n", + "conv_5 (Conv2D) (None, 2, 2, 1) 8192 \n", + "=================================================================\n", + "Total params: 2,767,360\n", + "Trainable params: 2,765,568\n", + "Non-trainable params: 1,792\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "discriminator.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "discriminator.save('dcgan_disc.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "BATCH_SIZE=128\n", + "latent_dim = 100" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "binary_cross_entropy = tf.keras.losses.BinaryCrossentropy()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "def generator_loss(label, fake_output):\n", + " gen_loss = binary_cross_entropy(label, fake_output)\n", + " #print(gen_loss)\n", + " return gen_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def discriminator_loss(label, output):\n", + " disc_loss = binary_cross_entropy(label, output)\n", + " #print(total_loss)\n", + " return disc_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "learning_rate = 0.0002 \n", + "generator_optimizer = tf.keras.optimizers.Adam(lr = 0.0002, beta_1 = 0.5, beta_2 = 0.999 )\n", + "discriminator_optimizer = tf.keras.optimizers.Adam(lr = 0.0002, beta_1 = 0.5, beta_2 = 0.999 )" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "num_examples_to_generate = 25\n", + "# We will reuse this seed overtime to visualize progress\n", + "seed = tf.random.normal([num_examples_to_generate, 1, 1, latent_dim])" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "# Notice the use of `tf.function`\n", + "# This annotation causes the function to be \"compiled\".\n", + "@tf.function\n", + "def train_step(images):\n", + " # noise vector sampled from normal distribution\n", + " noise = tf.random.normal([BATCH_SIZE, 1, 1, latent_dim])\n", + "\n", + " # Train Discriminator with real labels\n", + " with tf.GradientTape() as disc_tape1:\n", + " generated_images = generator(noise, training=True)\n", + "\n", + " \n", + " real_output = discriminator(images, training=True)\n", + " real_targets = tf.ones_like(real_output)\n", + " disc_loss1 = discriminator_loss(real_targets, real_output)\n", + " \n", + " # gradient calculation for discriminator for real labels \n", + " gradients_of_disc1 = disc_tape1.gradient(disc_loss1, discriminator.trainable_variables)\n", + " \n", + " # parameters optimization for discriminator for real labels \n", + " discriminator_optimizer.apply_gradients(zip(gradients_of_disc1,\\\n", + " discriminator.trainable_variables))\n", + " \n", + " # Train Discriminator with fake labels\n", + " with tf.GradientTape() as disc_tape2:\n", + " fake_output = discriminator(generated_images, training=True)\n", + " fake_targets = tf.zeros_like(fake_output)\n", + " disc_loss2 = discriminator_loss(fake_targets, fake_output)\n", + " # gradient calculation for discriminator for fake labels \n", + " gradients_of_disc2 = disc_tape2.gradient(disc_loss2, discriminator.trainable_variables)\n", + " \n", + " \n", + " # parameters optimization for discriminator for fake labels \n", + " discriminator_optimizer.apply_gradients(zip(gradients_of_disc2,\\\n", + " discriminator.trainable_variables))\n", + " \n", + " # Train Generator with real labels\n", + " with tf.GradientTape() as gen_tape:\n", + " generated_images = generator(noise, training=True)\n", + " fake_output = discriminator(generated_images, training=True)\n", + " real_targets = tf.ones_like(fake_output)\n", + " gen_loss = generator_loss(real_targets, fake_output)\n", + "\n", + " # gradient calculation for generator for real labels \n", + " gradients_of_gen = gen_tape.gradient(gen_loss, generator.trainable_variables)\n", + " \n", + " # parameters optimization for generator for real labels\n", + " generator_optimizer.apply_gradients(zip(gradients_of_gen,\\\n", + " generator.trainable_variables)) " + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "checkpoint_dir = 'dcgan/tf/training_checkpoints'\n", + "checkpoint_prefix = os.path.join(checkpoint_dir, \"ckpt\")\n", + "checkpoint = tf.train.Checkpoint(generator_optimizer=generator_optimizer,\n", + " discriminator_optimizer=discriminator_optimizer,\n", + " generator=generator,\n", + " discriminator=discriminator)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "def train(dataset, epochs):\n", + " for epoch in range(epochs):\n", + " start = time.time()\n", + " i = 0\n", + " D_loss_list, G_loss_list = [], []\n", + " for image_batch in dataset:\n", + " i += 1\n", + " train_step(image_batch)\n", + " print(epoch) \n", + " display.clear_output(wait=True)\n", + " generate_and_save_images(generator,\n", + " epoch + 1,\n", + " seed)\n", + "\n", + " # Save the model every 15 epochs\n", + " if (epoch + 1) % 15 == 0:\n", + " checkpoint.save(file_prefix = checkpoint_prefix)\n", + "\n", + " print ('Time for epoch {} is {} sec'.format(epoch + 1, time.time()-start))\n", + "\n", + " # Generate after the final epoch\n", + " display.clear_output(wait=True)\n", + " generate_and_save_images(generator,\n", + " epochs,\n", + " seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "import cv2\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_and_save_images(model, epoch, test_input):\n", + " # Notice `training` is set to False.\n", + " # This is so all layers run in inference mode (batchnorm).\n", + " predictions = model(test_input, training=False)\n", + " print(predictions.shape)\n", + " fig = plt.figure(figsize=(4,4))\n", + "\n", + " for i in range(predictions.shape[0]):\n", + " plt.subplot(5, 5, i+1)\n", + " pred = (predictions[i, :, :, :] + 1 ) * 127.5\n", + " pred = np.array(pred) \n", + " plt.imshow(pred.astype(np.uint8))\n", + " plt.axis('off')\n", + "\n", + " plt.savefig('dcgan/tf/images/image_at_epoch_{:d}.png'.format(epoch))\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(25, 64, 64, 3)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "train(normalized_ds, 100)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Blogs", + "language": "python", + "name": "blogs" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From b9e118500883302c1382dfdc8a20b992604a284a Mon Sep 17 00:00:00 2001 From: aditya-ai Date: Mon, 30 Nov 2020 10:26:22 +0530 Subject: [PATCH 4/4] Added Autoencoder TensorFlow Code --- .../AE_Cartoon_TensorFlow-checkpoint.ipynb | 805 ++++++++++++++++++ ...r_FashionMnist_TensorFlow-checkpoint.ipynb | 664 +++++++++++++++ .../AE_Cartoon_TensorFlow.ipynb | 805 ++++++++++++++++++ .../Autoencoder_FashionMnist_TensorFlow.ipynb | 664 +++++++++++++++ 4 files changed, 2938 insertions(+) create mode 100644 Autoencoder-in-TensorFlow/.ipynb_checkpoints/AE_Cartoon_TensorFlow-checkpoint.ipynb create mode 100644 Autoencoder-in-TensorFlow/.ipynb_checkpoints/Autoencoder_FashionMnist_TensorFlow-checkpoint.ipynb create mode 100644 Autoencoder-in-TensorFlow/AE_Cartoon_TensorFlow.ipynb create mode 100644 Autoencoder-in-TensorFlow/Autoencoder_FashionMnist_TensorFlow.ipynb diff --git a/Autoencoder-in-TensorFlow/.ipynb_checkpoints/AE_Cartoon_TensorFlow-checkpoint.ipynb b/Autoencoder-in-TensorFlow/.ipynb_checkpoints/AE_Cartoon_TensorFlow-checkpoint.ipynb new file mode 100644 index 000000000..8df29609d --- /dev/null +++ b/Autoencoder-in-TensorFlow/.ipynb_checkpoints/AE_Cartoon_TensorFlow-checkpoint.ipynb @@ -0,0 +1,805 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import imageio\n", + "import glob\n", + "import os\n", + "import time\n", + "import cv2\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers\n", + "from IPython import display\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from tensorflow.keras import backend as K\n", + "%matplotlib inline\n", + "from sklearn.manifold import TSNE\n", + "import matplotlib.pyplot as plt\n", + "from tensorflow import keras" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "#os.environ['CUDA_VISIBLE_DEVICES'] = '0'" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "img_height, img_width = 256, 256\n", + "batch_size = 128" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 100000 files belonging to 10 classes.\n" + ] + } + ], + "source": [ + "train_ds = tf.keras.preprocessing.image_dataset_from_directory(\n", + " '/home/aditya/VAE/cartoonset100k/',\n", + " image_size=(img_height, img_width),\n", + " batch_size=batch_size,\n", + " label_mode=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 10))\n", + "for images in train_ds.take(1):\n", + " for i in range(9):\n", + " ax = plt.subplot(3, 3, i + 1)\n", + " plt.imshow(images[i].numpy().astype(\"uint8\"))\n", + " plt.axis(\"off\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "normalization_layer = layers.experimental.preprocessing.Rescaling(scale= 1./255)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "normalized_ds = train_ds.map(lambda x: normalization_layer(x))\n", + "image_batch = next(iter(normalized_ds))\n", + "first_image = image_batch[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0 1.0\n" + ] + } + ], + "source": [ + "print(np.min(first_image), np.max(first_image)) " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "input_encoder = (256, 256, 3)\n", + "input_decoder = (200,)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def encoder(input_encoder):\n", + " \n", + " \n", + " inputs = keras.Input(shape=input_encoder, name='input_layer')\n", + " x = layers.Conv2D(32, kernel_size=3, strides= 2, padding='same', name='conv_1')(inputs)\n", + " x = layers.BatchNormalization(name='bn_1')(x)\n", + " x = layers.LeakyReLU(name='lrelu_1')(x)\n", + " \n", + " x = layers.Conv2D(64, kernel_size=3, strides= 2, padding='same', name='conv_2')(x)\n", + " x = layers.BatchNormalization(name='bn_2')(x)\n", + " x = layers.LeakyReLU(name='lrelu_2')(x)\n", + " \n", + " x = layers.Conv2D(64, 3, 2, padding='same', name='conv_3')(x)\n", + " x = layers.BatchNormalization(name='bn_3')(x)\n", + " x = layers.LeakyReLU(name='lrelu_3')(x)\n", + "\n", + " x = layers.Conv2D(64, 3, 2, padding='same', name='conv_4')(x)\n", + " x = layers.BatchNormalization(name='bn_4')(x)\n", + " x = layers.LeakyReLU(name='lrelu_4')(x)\n", + " \n", + " x = layers.Conv2D(64, 3, 2, padding='same', name='conv_5')(x)\n", + " x = layers.BatchNormalization(name='bn_5')(x)\n", + " x = layers.LeakyReLU(name='lrelu_5')(x)\n", + " \n", + " \n", + " flatten = layers.Flatten()(x)\n", + " bottleneck = layers.Dense(200, name='dense_1')(flatten)\n", + " model = tf.keras.Model(inputs, bottleneck, name=\"Encoder\")\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "enc = encoder(input_encoder)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "#enc.save('enc.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"Encoder\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input_layer (InputLayer) [(None, 256, 256, 3)] 0 \n", + "_________________________________________________________________\n", + "conv_1 (Conv2D) (None, 128, 128, 32) 896 \n", + "_________________________________________________________________\n", + "bn_1 (BatchNormalization) (None, 128, 128, 32) 128 \n", + "_________________________________________________________________\n", + "lrelu_1 (LeakyReLU) (None, 128, 128, 32) 0 \n", + "_________________________________________________________________\n", + "conv_2 (Conv2D) (None, 64, 64, 64) 18496 \n", + "_________________________________________________________________\n", + "bn_2 (BatchNormalization) (None, 64, 64, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_2 (LeakyReLU) (None, 64, 64, 64) 0 \n", + "_________________________________________________________________\n", + "conv_3 (Conv2D) (None, 32, 32, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_3 (BatchNormalization) (None, 32, 32, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_3 (LeakyReLU) (None, 32, 32, 64) 0 \n", + "_________________________________________________________________\n", + "conv_4 (Conv2D) (None, 16, 16, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_4 (BatchNormalization) (None, 16, 16, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_4 (LeakyReLU) (None, 16, 16, 64) 0 \n", + "_________________________________________________________________\n", + "conv_5 (Conv2D) (None, 8, 8, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_5 (BatchNormalization) (None, 8, 8, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_5 (LeakyReLU) (None, 8, 8, 64) 0 \n", + "_________________________________________________________________\n", + "flatten (Flatten) (None, 4096) 0 \n", + "_________________________________________________________________\n", + "dense_1 (Dense) (None, 200) 819400 \n", + "=================================================================\n", + "Total params: 950,728\n", + "Trainable params: 950,152\n", + "Non-trainable params: 576\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "enc.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def decoder(input_decoder):\n", + " \n", + " inputs = keras.Input(shape=input_decoder, name='input_layer')\n", + " x = layers.Dense(4096, name='dense_1')(inputs)\n", + " #x = tf.reshape(x, [-1, 8, 8, 64], name='Reshape_Layer')\n", + " x = layers.Reshape((8,8,64), name='Reshape_Layer')(x)\n", + " x = layers.Conv2DTranspose(64, 3, strides= 2, padding='same',name='conv_transpose_1')(x)\n", + " x = layers.BatchNormalization(name='bn_1')(x)\n", + " x = layers.LeakyReLU(name='lrelu_1')(x)\n", + " \n", + " \n", + " x = layers.Conv2DTranspose(64, 3, strides= 2, padding='same', name='conv_transpose_2')(x)\n", + " x = layers.BatchNormalization(name='bn_2')(x)\n", + " x = layers.LeakyReLU(name='lrelu_2')(x)\n", + " \n", + " \n", + " x = layers.Conv2DTranspose(64, 3, 2, padding='same', name='conv_transpose_3')(x)\n", + " x = layers.BatchNormalization(name='bn_3')(x)\n", + " x = layers.LeakyReLU(name='lrelu_3')(x)\n", + " \n", + " \n", + " x = layers.Conv2DTranspose(32, 3, 2, padding='same', name='conv_transpose_4')(x)\n", + " x = layers.BatchNormalization(name='bn_4')(x)\n", + " x = layers.LeakyReLU(name='lrelu_4')(x)\n", + " \n", + " \n", + " \n", + " outputs = layers.Conv2DTranspose(3, 3, 2,padding='same', activation='sigmoid', name='conv_transpose_5')(x)\n", + " model = tf.keras.Model(inputs, outputs, name=\"Decoder\")\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "dec = decoder(input_decoder)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"Decoder\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input_layer (InputLayer) [(None, 200)] 0 \n", + "_________________________________________________________________\n", + "dense_1 (Dense) (None, 4096) 823296 \n", + "_________________________________________________________________\n", + "Reshape_Layer (Reshape) (None, 8, 8, 64) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_1 (Conv2DTran (None, 16, 16, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_1 (BatchNormalization) (None, 16, 16, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_1 (LeakyReLU) (None, 16, 16, 64) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_2 (Conv2DTran (None, 32, 32, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_2 (BatchNormalization) (None, 32, 32, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_2 (LeakyReLU) (None, 32, 32, 64) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_3 (Conv2DTran (None, 64, 64, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_3 (BatchNormalization) (None, 64, 64, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_3 (LeakyReLU) (None, 64, 64, 64) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_4 (Conv2DTran (None, 128, 128, 32) 18464 \n", + "_________________________________________________________________\n", + "bn_4 (BatchNormalization) (None, 128, 128, 32) 128 \n", + "_________________________________________________________________\n", + "lrelu_4 (LeakyReLU) (None, 128, 128, 32) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_5 (Conv2DTran (None, 256, 256, 3) 867 \n", + "=================================================================\n", + "Total params: 954,307\n", + "Trainable params: 953,859\n", + "Non-trainable params: 448\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "dec.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "#dec.save('ae-cartoon-dec.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "#model.layers[1].get_weights()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "#model.save('autoencoder.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "optimizer = tf.keras.optimizers.Adam(lr = 0.0005)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def ae_loss(y_true, y_pred):\n", + " #loss = tf.keras.losses.mean_squared_error(y_true, y_pred)\n", + " #loss = tf.reduce_mean(tf.square(tf.subtract(y_true, y_pred)))\n", + " loss = K.mean(K.square(y_true - y_pred), axis = [1,2,3])\n", + " return loss" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# Notice the use of `tf.function`\n", + "# This annotation causes the function to be \"compiled\".\n", + "@tf.function\n", + "def train_step(images):\n", + "\n", + " with tf.GradientTape() as encoder, tf.GradientTape() as decoder:\n", + " \n", + " latent = enc(images, training=True)\n", + " generated_images = dec(latent, training=True)\n", + " loss = ae_loss(images, generated_images)\n", + " \n", + " gradients_of_enc = encoder.gradient(loss, enc.trainable_variables)\n", + " gradients_of_dec = decoder.gradient(loss, dec.trainable_variables)\n", + " \n", + " \n", + " optimizer.apply_gradients(zip(gradients_of_enc, enc.trainable_variables))\n", + " optimizer.apply_gradients(zip(gradients_of_dec, dec.trainable_variables))\n", + " return loss" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def train(dataset, epochs):\n", + " for epoch in range(epochs):\n", + " start = time.time()\n", + " i = 0\n", + " loss_ = []\n", + " for image_batch in dataset:\n", + " i += 1\n", + " loss = train_step(image_batch)\n", + " #loss_.append(loss)\n", + "\n", + " #print(\"Loss\",np.mean(loss_)) \n", + " seed = image_batch[:25]\n", + " display.clear_output(wait=True)\n", + " generate_and_save_images([enc,dec],\n", + " epoch + 1,\n", + " seed)\n", + " # Save the model every 15 epochs\n", + " #if (epoch + 1) % 15 == 0:\n", + " #checkpoint.save(file_prefix = checkpoint_prefix)\n", + " enc.save_weights('tf_ae/cartoon/training_weights/enc_'+ str(epoch)+'.h5')\n", + " dec.save_weights('tf_ae/cartoon/training_weights/dec_'+ str(epoch)+'.h5')\n", + " print ('Time for epoch {} is {} sec'.format(epoch + 1, time.time()-start))\n", + "\n", + " # Generate after the final epoch\n", + " display.clear_output(wait=True)\n", + " generate_and_save_images([enc,final,dec],\n", + " epochs,\n", + " seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_and_save_images(model, epoch, test_input):\n", + " # Notice `training` is set to False.\n", + " # This is so all layers run in inference mode (batchnorm).\n", + " latent = enc(test_input, training=False)\n", + " predictions = dec(latent, training=False)\n", + " print(predictions.shape)\n", + " fig = plt.figure(figsize=(4,4))\n", + "\n", + " for i in range(predictions.shape[0]):\n", + " plt.subplot(5, 5, i+1)\n", + " pred = predictions[i, :, :, :] * 255\n", + " pred = np.array(pred) \n", + " pred = pred.astype(np.uint8)\n", + " #cv2.imwrite('tf_ae/images/image'+ str(i)+'.png',pred)\n", + " \n", + " plt.imshow(pred)\n", + " plt.axis('off')\n", + "\n", + " plt.savefig('tf_ae/cartoon/images/image_at_epoch_{:d}.png'.format(epoch))\n", + " plt.show()\n", + " \n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "train(normalized_ds, 30)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "enc.load_weights('../tf_ae/cartoon/training_weights/enc_29.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "dec.load_weights('../tf_ae/cartoon/training_weights/dec_29.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "embeddings = None\n", + "for i in normalized_ds:\n", + " latent = enc.predict(i)\n", + " if embeddings is None:\n", + " embeddings = latent\n", + " else:\n", + " embeddings = np.concatenate((embeddings, latent))\n", + " if embeddings.shape[0] > 5000:\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(128, 200)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "embeddings.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n_to_show = 5000\n", + "grid_size = 15\n", + "figsize = 12\n", + "\n", + "tsne = TSNE(n_components=2, init='pca', random_state=0)\n", + "X_tsne = tsne.fit_transform(embeddings)\n", + "min_x = min(X_tsne[:, 0])\n", + "max_x = max(X_tsne[:, 0])\n", + "min_y = min(X_tsne[:, 1])\n", + "max_y = max(X_tsne[:, 1])\n", + "\n", + "\n", + "plt.figure(figsize=(figsize, figsize))\n", + "plt.scatter(X_tsne[:, 0] , X_tsne[:, 1], alpha=0.5, s=2)\n", + "plt.xlabel(\"Dimension-1\", size=20)\n", + "plt.ylabel(\"Dimension-2\", size=20)\n", + "plt.xticks(size=20)\n", + "plt.yticks(size=20)\n", + "plt.title(\"Autoencoder - Projection of 200D Latent-Space to 2D (Cartoon Set)\", size=18)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "reconstruction = None\n", + "lat_space = None\n", + "for i in normalized_ds:\n", + " latent= enc.predict(i)\n", + " out = dec.predict(latent)\n", + " if reconstruction is None:\n", + " reconstruction = out\n", + " lat_space = latent\n", + " else:\n", + " reconstruction = np.concatenate((reconstruction, out))\n", + " lat_space = np.concatenate((lat_space, latent))\n", + " if reconstruction.shape[0] > 5000:\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(5120, 256, 256, 3)" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reconstruction.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "figsize = 15\n", + "\n", + "fig = plt.figure(figsize=(figsize, 10))\n", + "#fig.subplots_adjust(hspace=0.2, wspace=None)\n", + "\n", + "for i in range(25):\n", + " ax = fig.add_subplot(5, 5, i+1)\n", + " ax.axis('off')\n", + " pred = reconstruction[i, :, :, :] * 255\n", + " pred = np.array(pred) \n", + " pred = pred.astype(np.uint8)\n", + " ax.imshow(pred)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reconstructing Cartoon Images with Latent-Vector Sampled Uniformly" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10, 200)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "figsize = 15\n", + "\n", + "min_x = lat_space.min(axis=0)\n", + "max_x = lat_space.max(axis=0)\n", + "# #print(max_x.shape, min_x.shape)\n", + "x = np.random.uniform(size = (10,200))\n", + "x = x * (max_x - (np.abs(min_x))) \n", + "print(x.shape)\n", + "#x = np.random.normal(size = (10,200))\n", + "reconstruct = dec.predict(x)\n", + "\n", + "\n", + "fig = plt.figure(figsize=(figsize, 10))\n", + "\n", + "for i in range(10):\n", + " ax = fig.add_subplot(5, 5, i+1)\n", + " ax.axis('off')\n", + " pred = reconstruct[i, :, :, :] * 255\n", + " pred = np.array(pred) \n", + " pred = pred.astype(np.uint8)\n", + " ax.imshow(pred)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reconstructing Cartoon Images from a Latent-Vector Sampled with Normal Distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.random.normal(size = (10,200))\n", + "reconstruct = dec.predict(x)\n", + "\n", + "fig = plt.figure(figsize=(15, 10))\n", + "fig.subplots_adjust(hspace=0.2, wspace=0.2)\n", + "\n", + "for i in range(10):\n", + " ax = fig.add_subplot(5, 5, i+1)\n", + " ax.axis('off')\n", + " pred = reconstruct[i, :, :, :] * 255\n", + " pred = np.array(pred) \n", + " pred = pred.astype(np.uint8)\n", + " ax.imshow(pred)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Tuts", + "language": "python", + "name": "tuts" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Autoencoder-in-TensorFlow/.ipynb_checkpoints/Autoencoder_FashionMnist_TensorFlow-checkpoint.ipynb b/Autoencoder-in-TensorFlow/.ipynb_checkpoints/Autoencoder_FashionMnist_TensorFlow-checkpoint.ipynb new file mode 100644 index 000000000..0c6ae492b --- /dev/null +++ b/Autoencoder-in-TensorFlow/.ipynb_checkpoints/Autoencoder_FashionMnist_TensorFlow-checkpoint.ipynb @@ -0,0 +1,664 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import imageio\n", + "import glob\n", + "import os\n", + "import time\n", + "import cv2\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers\n", + "from IPython import display\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "%matplotlib inline\n", + "from tensorflow import keras" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "os.environ['CUDA_VISIBLE_DEVICES'] = '0'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 128" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.fashion_mnist.load_data()\n", + "x_train = x_train.reshape(x_train.shape[0], 28, 28, 1).astype('float32')\n", + "x_test = x_test.astype('float32')\n", + "x_test = x_test / 255.\n", + "# Batch and shuffle the data\n", + "train_dataset = tf.data.Dataset.from_tensor_slices(x_train).\\\n", + "shuffle(60000).batch(128)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAIuCAYAAACy+nJwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABBAklEQVR4nO3deXCd1X3/8SPAi2RZmy3Jlvd9AWyQzZIAZSclCRmmkBAa0jSlM22HDhMSMp0wXZIybdI2BRoyQyaTlCYpYNKGFpqUsBSzBMpqMItjMAjZMpYsW7J2yQv27w+mM7/2fD6ae5Ir6/ro/frzw5lHz71+nuce7ny/91t25MiRAAAAkJPjxvsEAAAAio0NDgAAyA4bHAAAkB02OAAAIDtscAAAQHbY4AAAgOycMNp/LCsrK7iH/Ljj9F7p8OHDSSekjpN6DGXlypUyv/DCC2X+05/+VObbt2+PsqlTp8q1J5yg396BgYEoa2hokGuvuOIKmS9atEjm3/zmN6Oss7NTri11R44cKRvvc/i/Uu4JoNi4J4D/bbR7gm9wAABAdtjgAACA7LDBAQAA2WGDAwAAssMGBwAAZKdstGGbpVId7zq0brrpJplfffXVUbZ69eqintP/75/+6Z9k/v7778v82muvHbNzUV544QWZX3/99TJ/9tlnx/J0CkbHCPC/cU+Mj4ULF8rcPUMbGxujbP78+XLttGnTZK66cwcHB+XavXv3yrylpUXm6rzd59Xxxx8vc7f+aKOLCgAATChscAAAQHbY4AAAgOywwQEAANkZdVTDeKivr4+y1FEDBw4ciLJ9+/bJta5QqqKiouDcrZ0yZYo7xYga3xCCPz/1GkPQBWFr166Va59++mmZv/vuu1G2dOlSuRYAcvejH/1I5q74uL+/P8qGhobk2p6eHpmr5hpXZDxp0iSZf/zjH5f5ww8/HGX333+/XDtaI1Kp4xscAACQHTY4AAAgO2xwAABAdtjgAACA7LDBAQAA2Sm5LqqdO3dG2aFDh+Ra9/PUqpPIjXtwP0M9PDwsc9XV9KlPfUqudVTH1MGDB+XasjL9K9QpP5+d2qG1ZMmSKLv33nvl2quuukrmAJCLLVu2yHzHjh0yX758eZS5z5S+vj6Zq04st7ahoUHmb7/9dtL63PANDgAAyA4bHAAAkB02OAAAIDtscAAAQHbY4AAAgOwUrYvKdfu4ORZnnXWWzFV3UHd3t1w7efLkAs/Odym57irXuaU6j9wsEUfNqDp8+LBc694/99rVeneME07Q//x79uyJMtcpltpFpa6TY3nWyUSS0rk3a9Ysufaaa66R+fTp06OsqalJrh0ZGZF5a2urzO+6664o6+jokGsxsa1evTopd528qhv4+eefl2tPP/10ma9atSrK3HPfzblys6tUp6zjPpuOBXyDAwAAssMGBwAAZIcNDgAAyA4bHAAAkB02OAAAIDtlo3WwlJWVjVl7y8MPPyzziy66KMq6urrkWtWNFILuyHDc63ddYYqb6eS6TopxHq7Ly3VGKfv27Sv4b9bU1Mi13/zmN2X+5S9/ueDzcI4cOVL4P8JRMpb3RKlzHRwHDhyIsmuvvVau/Yu/+AuZq869GTNmJJxdCPX19TJX98quXbvk2rq6OpmrTkl3/6jXEkII7e3tMlddYddff71cyz2Rbu7cuTL/+te/HmVz5syRa103knv2q2tRzZYKIYT58+fLXM2RcufhuoHd31yxYkWUVVdXy7Wf+MQnZO66Fo+20e4JvsEBAADZYYMDAACywwYHAABkhw0OAADIzrgVGbu/q4qiXKGt+wnpjRs3RllfX59c6woZn3rqKZk3NDRE2cqVK+Xa7du3y1wVoDU2Nsq1r776qszXrFkjc1XI6H42f926dTJXRZmuiK2yslLmKUXaDgWVpSWlyLi5uVmu/e53v1vwMdw1lPpz9VOnTo0yV4yv1rq/6ZoI3LPN3UO9vb1RtnbtWrn28OHD3BOJ/vVf/7XgtW1tbTJ3xbqu2UMV8aaOBXrvvfeirLa2Vq51135VVVXB691oFPf54cYtHW0UGQMAgAmFDQ4AAMgOGxwAAJAdNjgAACA7bHAAAEB2Cv9d/1/R8uXLk9arinLX2TBp0iSZ33TTTVF28skny7Uf//jHZb57926ZT5s2Lcpct8fLL78sc/V6XEfTjh07ZO5ezy233BJl6pxDCOHRRx+Vufo3UD9VH4Lvorrmmmtk/s///M8yR+lzXYtKZ2enzN294saupJyH6xhRzwk3ZsF1aO3fvz/KXFeM6ggbzSuvvBJlo3W3TiTuPVbXgOswcuMN9u7dG2Xu+nRjDNxzUXGdTu5vqtfurgt3zbnr+aSTToqyTZs2ybWu4/Dss8+Osl/84hdy7XjhGxwAAJAdNjgAACA7bHAAAEB22OAAAIDssMEBAADZGfMuqquvvjppfUqnhuu8uPPOO6Ps1FNPlWtdJ5brAlKGh4dl/pu/+ZsFH8PNI3EV7AMDAzL/yU9+EmUtLS1yravIP3jwYMHn4ar3b7/9dpnTRTU+1Nyk999/P+kYKZ09rotq6dKlMt+2bVvSuSjqug1Bd6m47pyKigqZqw4YN4vKPVNcN6iaRYUPpFxz5557rsxdp6d6LrpOvD179si8rq5O5urf1HU0udeoOmW7u7vlWne/udej3hN33bpn/JlnnhlldFEBAACMMTY4AAAgO2xwAABAdtjgAACA7Ix5kfFVV10lc1dUq4r/XPGTc/rpp0eZ+qn1EHzRlit2TilYTPlpbvdz3a4Q1BUsNjQ0RNns2bMLPo8Q9PvtCjj7+/tl7oo1VdH5PffcI9eieFKK952UomRXmOiOoQp23T3rCt6d8vLyKHPXs/ubqijT3ffunnCv/V/+5V9kjrQiY9dI4kY4qHvCNW+4Z6WjjuM+89x1oa5zd1+5z8iamhqZNzY2Rpm7J9yxV6xYIfNSwjc4AAAgO2xwAABAdtjgAACA7LDBAQAA2WGDAwAAslO0LqolS5bI3P00+8jISMHHdl0Tf/InfyLz5cuXR9m1114r1+7bt0/m7me1U6RU3rtuAdep4arpVSW866B55plnZP6xj30sylylv3ufVOdKCCF8+tOfjjK6qMZeSjfKWHKdJOp6dvePG9HiukDUteueKe5vqu4q91rcecyZM0fmL774osyRxnWWdnV1yTylG6++vl7m7t9aPXPddeuuOTV+wXVFTZs2TeYpI0ncWvcaXXdaKeEbHAAAkB02OAAAIDtscAAAQHbY4AAAgOywwQEAANkpWhdVR0eHzJ977jmZz5s3T+azZs0q+G+6OVJunoiSOmMk5RjF6Fxxx3AdAKpjZMaMGXLtrbfeKvPLLrssylzFfHt7u8yvu+46mf/oRz+SOUqHmz3juilUN+PFF18s16bM+nGdeIODgzJ3s9/q6uqiLLXrRJ23uzddN8/bb78tc3feSDNz5kyZ9/X1yVxd567TKbXrTuVq3loIfm6fuo7crLTe3l6Zu/Pu6emJMtdt6zp2q6qqCspC8P8GY41vcAAAQHbY4AAAgOywwQEAANlhgwMAALLDBgcAAGSnaF1UrrPhnHPOSTrOwoULo8x1Ab300ksyf+SRRwr+e8XodHLV52PJzYZKsWnTJpn/1m/9VpSpf5cQfCcWSktKt6DrlnKuvvrqKGtra5Nrd+7cKXPVPek6rlyXl7Nt27Yoa2hokGvd7LzKysooc91PbkbVO++8404Riaqrq6PMdca5eXnqM8t1DKXMKAtBd0y5Z7aby6g6oNy173J3LaquWLdWXfsh6I5D10FIFxUAAECRsMEBAADZYYMDAACywwYHAABkp2hFxsXS2tpaUDYa95PYiisyHsvxCyncebiflHeFYooryvu3f/u3go8x0ZTKdeGkXi9KagF7TU1NlLlCZbU2hBBefvnlKKuvr5dr3fldeOGFMlc/S//KK6/Itffee6/MTzzxxChzP4+vCmBDCGHJkiUyRzo1lsH9e8ydO1fm6p5111bq/a3uQ9eM4o6tzsWNXnDFvY5a39zcLNe6e1mNmFBjUUIIobOzM+HsiodvcAAAQHbY4AAAgOywwQEAANlhgwMAALLDBgcAAGRn3LqoXDW4klJlHoL+6Wu3thgjD8ZDaveX4n6WXJkyZUrSMUqlq6jYivG+uy4/12Wh1ru/5/49inGdf/7zn5f522+/HWWLFi2Sa91PyqsOI9dx9cYbb8jcdUCpjhvVWRVCCO3t7TJX42JcZ5ob4eC6q5Du1FNPjTLXdedGDajPoJQO3NGo46R2Uan17nPTjYxw19zGjRujbHh4WK6tqqqSuerCPfvss+XarVu3ynys8Q0OAADIDhscAACQHTY4AAAgO2xwAABAdtjgAACA7IxbF1XKzKRUjY2NUea6S4pVNX+0FWPmkOtoUdw8EtcB4M5DrT+WOq7c+666G9x7lnrtu+6LX9fll18u84997GMynzNnjszVTJotW7bItcuWLZP5ySefHGWuY8R1QO3Zs0fm6jhr166Va0866SSZq44udx4DAwMyT7k3Mbp58+ZFmep0C8G/7ymzntwx3PNAPVvdfVyMZ6X7HGtoaJD5HXfcEWUrVqyQa8855xyZb9q0KcpSOnOPBu44AACQHTY4AAAgO2xwAABAdtjgAACA7IxbkbGjirZSi1CXLl0aZe6n6idPnpx07JSf5B/L4ln3elL+pvs5ffVz9a4QzhXOjVVh7Hhz768rKC6G6dOnR5kr1r3oootkftppp0XZxRdfLNe++eabMndjDFRhYV1dnVzrCnNfe+21KFPjG0IIobm5WeaO+wl6xRVrtrW1RZkbJeGKjN2xVUHqWF5POVBjAvr6+uRa10yhnqFurENq4bh6Tri1KUXQ7rnvjuGuIzVO5LHHHpNr3X2o7mXXiDBe+AYHAABkhw0OAADIDhscAACQHTY4AAAgO2xwAABAdkqui6oYnUdVVVVRtm/fPrn2WP35dHfeKR0jrhvlmWee+ZXOaSJTP3N+/fXXy7XLly+XuRp5EILuSHM/we5+Kn3q1KlRtnfvXrl24cKFMlfdiSGEsHv37oLPI6X7r6WlJekY7vzUz+/v3LlTrnXnrTpxamtr5dr33ntP5ik/p++OgQ+oZ3x/f79c29TUJHN1v7lrK7ULV13PbgxESmeuG/Piju3Or7OzM8oeeeQRufZv/uZvZK7uFfdvMF6OzU93AACAUbDBAQAA2WGDAwAAssMGBwAAZIcNDgAAyE7JdVGpTgNXwb5u3TqZ79+/P8rcbKRS76JyXWWual5xlfdXXnmlzL/97W8XfAx84MYbb4yylStXyrWvvPKKzF0XkOrQGhkZkWunTJlizjCm5vmEoDuuQvD3yuLFi6PMdQy5XN2zrqPJzQXq7u6WeX19fZS5mTmtra0yV/+W7pmiOnxCCKGjo0Pmq1atijK6qEan3mP3OeG6lNQz1HUBuWO4+01dG+7+cfeEUqz5hur9c89496xR92FKR9jRUNqf7gAAAL8CNjgAACA7bHAAAEB22OAAAIDssMEBAADZKbkuqpQq7DVr1shcVaUXq/q8VLjXo2aPuPlU5557blHPaSL4whe+IPMZM2YUlIUQwvz582VeXV0tc3U9q9lIIfjZM2q9m33luC4LdS2669P9TXV+7u9t2bJF5q7bQ3XLuI4W1524cePGKHMzxVK7ZdycPHiqe8l1tdXU1MhcdRG6+Wzu387db6oDMLWTV30Wus/HgwcPFnyMEPyzRnHdier1lJeXF3zco4FvcAAAQHbY4AAAgOywwQEAANlhgwMAALJTckXGKdzPratCQVdoW1lZKfNiFCUX4xiuSMwdWxVrugK0YnAFcq6g7ljnxoNMnz49yrZv3y7XLliwQOZLliyRufr3c+MAnJRRG+6ac//WKeNO3JiFrVu3RpkbV+BGOLhrTo2ecMXOu3fvlrkqMnUFqa4AfN68eTL/nd/5nSh76aWX5Fp8QN1vblRDbW2tzN99990oc9eFe4a6onS13t2DroBZ3YfuXnP3hLsW586dK/NCzyMEXajsPmfHC9/gAACA7LDBAQAA2WGDAwAAssMGBwAAZIcNDgAAyE7JdVGldHssXLhQ5qqbwlWqlzrXLZXSoeXW9vX1yVx1+biOoInWRfXHf/zHMn/ssccKPkZvb6/MX3nlFZmrn5rv6uqSa91Px6t/J9dB6DpJXIdEW1tblLmfd3fjFAYHB6PMdYq53L129Tpd98v+/fsLzlUnTwj+vnKdOCeeeKLMoccphKCfLzNnzpRr77rrLpmrZ9qHPvQhuXZoaEjmrktJrXdrU8aGuLVqdEUI6SNTFPcsV12E6lkwnvgGBwAAZIcNDgAAyA4bHAAAkB02OAAAIDtscAAAQHZKrosqhZvpozqxjtUuKsdVx6u5Ia4K3nUoNDc3R5nroppoXAfUhz/84Sj7yle+Itf+7u/+rsxVJ1EI+t/PdXW4+UjqenH3hOskcuvV+blOp9mzZ8tcdYG4eTnu2n/rrbdkvm/fvihzryXlOeG6pVwnaHl5ucxVt0xTU1PB55EzN29QPefWrFkj137xi1+U+dVXXx1lrktJdTKGkNYt6rr83PWiuq7UXDW3drTcdV0p7vzUPe6eS+OFb3AAAEB22OAAAIDssMEBAADZYYMDAACyc0wXGdfX18v8/fffj7KU0QajUcdRBW+j5aowzZ2fK3orxutx55dSgIYPqMLcr371q3Kty08//XSZf/KTn4yyyy67TK5dsWKFzNU154peHTdqQF1Hrtj5lltukfmLL74YZbt375Zrd+7cKXNXwLx169Yoe/311+Xak046Seb9/f1R5kY1PPfcczIfGBiQuRpf4dZONA0NDTJXxf5ufMnmzZtlfvPNN0eZKkgPwT8T3fgS9dx2Bb+uUFndV+7zwBUwu3vIjbVIoQqv3SiW8cI3OAAAIDtscAAAQHbY4AAAgOywwQEAANlhgwMAALJzTHdRucp2VX3uqsxdJ5GrVlc/W50yNiEE/XPw7hguVz/v7ta7Kn33GlO6a9xrnGjUv6nq5hvN888/X3D+5S9/Wa5113llZWWUuX9n1+3hRkn09PREmeu4GktudMLll18eZe69rq2tlXl7e3uUuXtwz5495gyR6sILL5R5Y2NjlHV0dCQdW90TqdetuwbcGBzFfY6p57Mbm5A6esSNnkg5huqU7O7uLvi4RwPf4AAAgOywwQEAANlhgwMAALLDBgcAAGSHDQ4AAMjOuHVRue6blBlLbk6JqoR31fGpnS7qOO61uAp79TfdMVxXjJp9VCzz5s0reK3rxJpoUq+jsXLgwAGZl1p3w9F0//33F7xWdUth/Lz55psyV51xd999d9Kxq6qqoszNUHOdRO6+V89tN1/MfTap3HVcua4tNUMthLTP2ZSO3VJ7zvDpBAAAssMGBwAAZIcNDgAAyA4bHAAAkB02OAAAIDvj1kWVUsXtdHZ2ynzlypVR5rqRXFV6TlxnjePeV8XNuQKAX9eGDRuScsV129bV1UWZe/atWLFC5q6bNWUmoOt0Us9t93nlzmP69OkyP+2006LMzaCbPXu2zJubm6Psvvvuk2vHC9/gAACA7LDBAQAA2WGDAwAAssMGBwAAZKdstGLfsrKyX78SeAzV1NTI/FOf+lSU7dmzR65NLTJWP1tdUVEh17riNvU3Dx06JNf29vbKvKenR+bDw8NR5sYpuJ/Vfuihh2R+tB05ckTPrxhHpX5PIG/cE8WjntuLFi2Sa8vLy2W+cOFCmatxN67RxT2fR0ZGouyXv/ylXNva2irzdevWyVw9+x988EG51pk6dWqUqXMea6PdE3yDAwAAssMGBwAAZIcNDgAAyA4bHAAAkB02OAAAIDujdlEBAAAci/gGBwAAZIcNDgAAyA4bHAAAkB02OAAAIDtscAAAQHbY4AAAgOywwQEAANlhgwMAALLDBgcAAGSHDQ4AAMgOGxwAAJAdNjgAACA7bHAAAEB22OAAAIDssMEBAADZYYMDAACywwYHAABkhw0OAADIDhscAACQHTY4AAAgO2xwAABAdtjgAACA7LDBAQAA2WGDAwAAssMGBwAAZIcNDgAAyA4bHAAAkB02OAAAIDtscAAAQHbY4AAAgOywwQEAANk5YbT/WFZWduRoncj/OO64eM91+PDhX/u4DQ0NMl+1apXMzzvvPJlv2LAhyt555x25dtKkSTKfM2dOlF1wwQVy7dlnny3z73//+zJ/5plnouzgwYNybak7cuRI2Xifw/81HvcE8D+4J4qnrCx+K48cSXspN954o8zXrl0bZUNDQ3Lt22+/LfORkZEoO/744+Va9znx5JNPyvxb3/qWzI9Fo90TfIMDAACywwYHAABkhw0OAADIDhscAACQHTY4AAAgO6N2UY3pHz5B/+lDhw4VfIxTTjlF5qozateuXXLtmWeeKfPzzz9f5vPnz4+y9evXy7Vr1qyR+euvvx5l27Ztk2v7+vpkvmjRIplXVlZGWUVFhVz70ksvybylpUXmAJCLYnRRue7XJUuWRNny5cvl2vvvv1/mqjtXPd9DCOGSSy6ReXl5ucxz6qIaDd/gAACA7LDBAQAA2WGDAwAAssMGBwAAZGfcioxTiokvuugimTc1Ncm8ra0tylzR8E9/+lOZ/+AHP5D5lClTomzevHlyrRvVsH///ihzhb1qdEUIISxbtkzms2bNirKuri659qyzzpL5+++/H2Xbt29POr9ijNcAgFI2PDwsc/U8d6Maent7Za4KhOvq6gr+e6Od30TBNzgAACA7bHAAAEB22OAAAIDssMEBAADZYYMDAACyM25dVI6qHF+8eLFc297eLnNVaa5+9jqEEObMmSPz+vp6mQ8ODkaZ6wjr7++Xufo58KVLl8q1rhPL/WT3wMBAlLlK+p6eHpmvXr06ylwXFd1SAI5FqgPUPc+mT58u86lTp8pcPeN37twp186dO1fmasSO6sANQXe+huA/PyYKvsEBAADZYYMDAACywwYHAABkhw0OAADIDhscAACQnZLrolJdTa5CvLGxUeZqHtOjjz4q19bW1sr84MGDMleV7ccff7xc6+Y0qa4r9/cc1S0VQgj79u2LMnXOIeiOtRBCKCsrSzoXADjWpDznmpubZe6e/apz1XW+us6okZGRgv+eO/bMmTNlPlHwDQ4AAMgOGxwAAJAdNjgAACA7bHAAAEB22OAAAIDslFwX1ZQpU6LMdRg1NTXJ/Omnn46ympoauXby5MmFn1zQM0YOHDgg17oqfXUMR70fIfjKe9VB1tHRIde67irVtTZt2jS5Vs3mAkpdMe7NVD/+8Y9l/rWvfS3K3njjjTE7D3wg5d/6rbfekrmb86c6aFM7ZdVn0wkn6I9slw8NDSX9zdzwDQ4AAMgOGxwAAJAdNjgAACA7bHAAAEB2Sq7IWP20tBt54AqrVqxYEWWvvfaaXDt16lSZpxSgubUud+edwo2vUD/vXV1dLde6wuG9e/dGWX19vVxLkTGUYhTxqoL5EHzRfIqxLCZ2GhoaZN7a2np0TwQhhLRroLOzM+kYkyZNKigLwX++qbEMblSDa5bp7e2V+UTBNzgAACA7bHAAAEB22OAAAIDssMEBAADZYYMDAACyU3JdVFVVVVHmxhW4Dp6LLrooyh555BG5dvr06TI/dOiQzFUHlOsYcbmrhFfcSAbXRaU6TK677jq5dteuXTJXr92NdQAU1ynofq7+jDPOiLJbb71Vrm1ra5P5VVddVeDZFceGDRtkvnTpUpk/8cQTMqcTsfS5DqiUzqjDhw/Lte7zQH1+uI6r1E7eiYJvcAAAQHbY4AAAgOywwQEAANlhgwMAALLDBgcAAGSn5Lqo1EyN1A6empqaKHPdUm4ek5rpFIKuYndV8K5qXnWYuOp4V6XvZqOsWrUqys4880y59sEHH5S56tBqamqSa7ds2SJzTGypXVQf+tCHokzdxyH42Wq33367zMvLy6PMdUm+8847Mj///POjbN26dXLtwMCAzN28IJS+1G4k9Zng7gnXbas+E9znhMvdsScKvsEBAADZYYMDAACywwYHAABkhw0OAADIzrgVGbuiKFWI5wqE3biC+vr6KJs6dapc6wq/1MiIEEI4cOBAlLlxCqkFYUplZaXMu7u7C17vfjrejcBQr6eurs6dIhAZHh5OWn/xxRdHmSvsdPfyNddcI3N1vw0NDRW8NgTdMLBz50651kkZ0YLS4j4n3PWSUmTsCu/VdZ5aNOz+5kTBNzgAACA7bHAAAEB22OAAAIDssMEBAADZYYMDAACyM24l1u7n1tVoAtctNWvWLJl3dHREmftpdlcF79arLip3fu7YqmreVcervxeC7/J64oknomzTpk1y7cyZM2Wu0AECR3VquPvHXbennnpqlO3Zs0eudffV7t27Za7GrrhjuI5I1dHixry4Y7jnBMaHG6WjuI5TN35DPc/dWne9KKkjI9yon4mCb3AAAEB22OAAAIDssMEBAADZYYMDAACywwYHAABkp+RmUakOIzd7pqamRuY33HBDlDU2Nsq1blaH615SUmZLhaAr7FOP4bpU1Ht1xx13yLVXXHGFzNV74joOysvLZZ46iwjHLnctKn/7t38r866urihz973rRnEdJmq9W+s6oxT3ut0zxc2Ew/hQz1zX6bZu3TqZu+4qdW24Z2hKh6rrtnXzrCb6DEG+wQEAANlhgwMAALLDBgcAAGSHDQ4AAMgOGxwAAJCdkptFNTQ0FGWuUn316tUy37JlS5QtX75crnVV6a7iXeWuAypl1ok7D9ft4Srvm5qaouz++++Xa//0T/9U5vPnz4+y7u5uuZYuqmNX6jWXcp2fcsopcu1nPvMZmb/xxhtRVqxZT+51phxDdXS547prf/369TKvqKiIMvUcRHGlzAY7++yzZe466VRXk7ue3f2WMkfKfda4TuOFCxdGWWtra8F/71jBNzgAACA7bHAAAEB22OAAAIDssMEBAADZGbci46qqKpmrEQmuyNgVZymuGNb9xHXK6ISUYuIQ9Hm7YjVXCOd+rl4Vprn3qbe3V+YzZ86Mss7OTrnW/Tu6omSUDndduBEJIyMjMlf3litsV8XEIej73hXSu3vCvR6VuwJhd1+pwmb37HDn3d7eLvNZs2ZFWUtLi1yL8eGK5l0hsLpXUkd7qM8gd9263H2OqWc8RcYAAADHADY4AAAgO2xwAABAdtjgAACA7LDBAQAA2Rm3LirXGaWqz12l+t69e4t6ToVQVekp3RsuT62CdxX57n1V3nrrLZnX1dVFmeu4cl1UKH2p3VJqpEAIIfz85z+PsnfffVeudfdEZWVllLlr341qSOmIdMd2YxbU/anukxBC2LFjh8zd+7d27dooo4uqtLjns+r+C0FfX+oaDyGErq4umad057rr2Z33smXLouzFF18s+O8dK/gGBwAAZIcNDgAAyA4bHAAAkB02OAAAIDtscAAAQHbGrYvKdRSoTohp06bJtc8++2zBf891+/T19cncVaWnzAdxM3NUdbybX+OO7biOM8V1UZ1xxhlR5jpUXGcA/L+d+7d211zKzDXXXaeO4bqlGhoaZP7DH/5Q5qqb0c3XcbOeFPda3PtUjK6T6upqmavr/LHHHpNrZ8yYUfAxQghhxYoVMsfRt3r1apnX1NTI3D0X1b3vPg/cM3toaCjK3DXkrn2Xu9eZG77BAQAA2WGDAwAAssMGBwAAZIcNDgAAyM64FRm7n4lXRVvl5eVybUdHR8F/zxVqukJGVyCq8tQxC+o1uqJMx70e914p27Ztk/lZZ50VZa6YLqWwMwcpxefu2nL50XbhhRfK/Ld/+7dlvmvXroKP7QqpXZGkev82b94s17oiaFfArO4V9/x5/fXXZf7ggw9GWVNTk1x7+umny9y9fyeffLLMcfTNmzdP5u56ThnVkDp2R13P7rnvPoPc81mNasgR3+AAAIDssMEBAADZYYMDAACywwYHAABkhw0OAADIzrh1UTmqotx1GO3cuVPmqqI8pfslhLRq9dSfyVavx/2Mt6ved+fnXo8yODhY8FrX/aJ+Tjxn7t/DdZkp69evl/ncuXNl3tPTE2Wu8+K0006T+YIFC6Js5cqVcq0bgfLf//3fMledJK5LyY1dUa99zpw5cm1XV5fM161bV/D5uWMMDAzI/Pd+7/eizHU/tba2ytx1utTX18scR19zc7PMU7pqndRnvMrdZ0rq+JLZs2fLPDd8gwMAALLDBgcAAGSHDQ4AAMgOGxwAAJAdNjgAACA749ZF5aq+VYfR4sWL5dotW7bIXM3ZSJ2llJorqR1Qiqu8d9X7qmNk1qxZcu3+/ftlnlK9P9G46+jEE0+Msm984xty7cMPPyxz13mkOoxGRkbkWjdL6Zlnnokydx2eeuqpMnddV9OnT4+yGTNmyLXV1dUyX7p0aZTNnDlTrq2rq5O5e0/UzDp3PbtZRMrWrVtl7u5798zbs2dPwX8TY0tdhyGkP4eLcQy1ftKkSUnHcN2Wbo5abvgGBwAAZIcNDgAAyA4bHAAAkB02OAAAIDtscAAAQHbGrYtq8uTJMldV4m7eUWdnp8xVR4vrGErtDlJdXqnHUBXvKbOvRluvquYrKirk2t27d8tcVe+7zpCULoKcfe1rX4sy13W0b98+md9///0y/9nPfhZle/fulWtdrrpD3Nwd12Fx9tlny3z16tVR5uYruXulpaUlyty8qB07dshcdXO5c0ntRlHdc+655I7tnnnnnXdelLluHowtN//MSemUdTMVXXeVulfcs3x4eLjgY4QQQl9fn8xzwzc4AAAgO2xwAABAdtjgAACA7LDBAQAA2Rm3ImNX/KR+rr6/v1+ura2tlbkq5nKFXK7wy52fKuJ1RYUpIxnc33NFbK5oWv3N1IJKdQxX3Ob+bXJ16aWXylyNB+nu7pZrzzjjDJm7Il7177Fo0SK5dmBgQOa9vb1RVllZKde668IVJqoRCW6MiiuwVmMMysvL5dqqqiqZu3tFvXZ3T7hRHOr54e5ZV3zs3r+ampooo8h4fLjieHdfuXulGCN91LXojuvGgDju3soN3+AAAIDssMEBAADZYYMDAACywwYHAABkhw0OAADIzjHdReW4qnTFdTq5bgrVRZVawZ7CHTvlZ79dx4h6Le4Y7jxSOsVyMGvWLJmr98ddh27EiPu5dXXs7du3y7UpYwLc6AB3bbnOvV27dkWZu3/q6upkru57d36uw8h1KR04cCDK3BgI112irnP3GqdMmVLwMUIIoa2tLcoYgTI+XJdfaiequodSn5Up15zj1qvOPdcp67oCjwV8gwMAALLDBgcAAGSHDQ4AAMgOGxwAAJAdNjgAACA749ZF5ajqc9ft47pUqquro8zNonJV5ilzmlSXRgi+G0UdI7VrImW9O4+enh6Zq/Nzx5ho3R533nmnzNXspd///d+Xa88//3yZNzU1yVx1Ubnr1v2bulxx3R7qvgohhHnz5kWZ65Zy98o777wTZc8++6xc+5d/+Zcyf/zxx2X+wgsvRJmbOeQ6xVRnlPs3cM+l3bt3y3zdunVRtnz5crkWxaOuZ/c8c58frhtY3UPuGC5XXYSuo8ldi64rUM2Pmz9/vly7detWmR8L+AYHAABkhw0OAADIDhscAACQHTY4AAAgO+NWZOyKoiorK6PMjQkYHByUuSrOShnfMBpVVOYKzZyUwlxXYO2OoX7y3hWHupEB6tiuyNj9hPlE89xzzxWUjWbGjBkyb2xsjLIlS5bItc3NzTJXP82urpUQ9D0Ygi9UVqMannrqKbn2xRdflLkqeiwWVXzsiqBdIXB3d3eUueJQ97xyBZ+33357lP3gBz+Qa2+77TaZI526J9y/nRvt4cZyTJs2LcrcNe6e5epzxT2H3ZgS9/mhPiPdGBqKjAEAAEoIGxwAAJAdNjgAACA7bHAAAEB22OAAAIDslNyoBsVVn7vuJVcJr6RUsLtjq4r0ENJ+yt0dw/20vctV1bzrdHIV9uq83ftUrO40+E4NlavRECGE8B//8R9FPaccfP7znx/vU0AJUl1D27Ztk2s7Ojpk7joOlaqqKpm7Z7/qmHJrXUdxyjged37HMr7BAQAA2WGDAwAAssMGBwAAZIcNDgAAyA4bHAAAkJ1x66JKmaWkKr5DCGFoaEjmqrLddWK5Y6R0YrluqZSZU6lzbVz3knqvXBeVe+2q8t7N0env75c5AJSyioqKKHvvvffk2h07dsjczTRTc64c9/mhns8NDQ1ybW9vb8F/z/1N9xl0LOMbHAAAkB02OAAAIDtscAAAQHbY4AAAgOywwQEAANkZty6qvr4+ma9cubLgYwwPD8v8vvvuizI3Z8N1Kak5II7r8kqpSncdV+4Ybo6U4rqlBgYGCj6G6jgIwXdoAUApmz59epS5WU9qblUIfiag6jp186Lcs1V9ruzatUuuVa8lBP/5pp79rkPrWMY3OAAAIDtscAAAQHbY4AAAgOywwQEAANkZtyLjffv2FZy3tLQkHVv9bHXqT1lPZKqQzRUqu39HAChlDzzwQEFZCCHU1tbK3DW6rFu3Lsrq6+vlWjVaKAQ9Mmfnzp1yrRsNoUYfhRDCL3/5yyhz4yiOZXyDAwAAssMGBwAAZIcNDgAAyA4bHAAAkB02OAAAIDtlbswAAADAsYpvcAAAQHbY4AAAgOywwQEAANlhgwMAALLDBgcAAGSHDQ4AAMgOGxwAAJAdNjgAACA7bHAAAEB22OAAAIDssMEBAADZYYMDAACywwYHAABkhw0OAADIDhscAACQHTY4AAAgO2xwAABAdtjgAACA7LDBAQAA2WGDAwAAssMGBwAAZIcNDgAAyA4bHAAAkB02OAAAIDtscAAAQHbY4AAAgOywwQEAANlhgwMAALLDBgcAAGSHDQ4AAMgOGxwAAJCdE0b7j2VlZUeO1omMlzlz5sj80ksvlXl1dXWUdXd3y7Wtra0ynzFjRpRVVlbKtSMjIzLv6uqS+eTJk6PsZz/7mVxb6o4cOVI23ufwf43HPVFWVvjbcORI4ad3wgn69r/gggtkvnLlSpkvXLgwytw5DwwMyPzQoUMFH2PXrl0yf/LJJ2W+detWmSvHH3+8zN9///2CjzGWuCc+oP6dxvLf6KqrrpL53/3d38lcXaNtbW1yrbsPU+6JBQsWyPyRRx6R+U033STzX1fKaymW0e4JvsEBAADZYYMDAACywwYHAABkhw0OAADIDhscAACQnbLRui4mQhfVH/3RH8n8ox/9qMxV9f6sWbPk2pdfflnmquukoaFBrt2xY4fMOzo6ZL5o0aIo+/rXvy7Xugr7UjHROkZSuqXc2sOHD8v805/+dJRde+21cq3q8hstV90r7rnirnOls7NT5q7Tqb+/X+aPPvpolN1www1y7Vh1rBUL98QHUt77L33pSzL/gz/4gyhbtmxZwccNwXfQqvNz1+2bb74pc9WxO3v2bLl2//79Mk+533bu3Cnz7373uzK/+eabCz72WHYn0kUFAAAmFDY4AAAgO2xwAABAdtjgAACA7Ez4ImM3xsAVaw4NDUVZbW2tXOsKv6ZPnx5lBw4ckGuHh4cLPo8QdKHlvffeK9f+13/9l8xLBQWVHzjuuPj/Q1xxXlNTk8wff/zxKHPX5759+2Q+d+5cmQ8ODkaZu3+mTZsm8/b29iibOnWqXDtz5kyZ9/T0FPw33TgKV2g5adKkKDt48KBcO5ZyvSdSi1DVM/QXv/iFXLtq1SqZq2ele66683DnXYyRKWrsjiukd1KeKVOmTJFr3RihlpaWKDv33HPlWleMXYzRDhQZAwCACYUNDgAAyA4bHAAAkB02OAAAIDtscAAAQHZ0CXOG3DgFNdoghBBef/11mVdVVUWZ60ZZsGCBzFXH1J49ewr+e6NRVemu+wWlxXVeqE4N19WxYsUKmdfU1ETZf/7nf8q1rnPPdS+pLqUHH3xQru3t7S34GJ/85CflWnev9PX1yVyNmPjc5z4n1/7VX/2VzMejY2oiSf3J/rvvvjvK3JiF1tZWmasuvZSuo9Fy9Yx3XUruvlddgW5ciut8dF1K6m+qbkh3HiGEMGfOnCjbsGGDXHvJJZfIPKVb6lfBNzgAACA7bHAAAEB22OAAAIDssMEBAADZYYMDAACyM2G6qE477TSZj4yMyNzNpFHdWK5b6oUXXpD522+/HWXnnHOOXNvR0SFz1RUTgp7RUl9fL9eitLgODjenTFm/fr3MN2/eHGWu+8/Nu3n11VdlftVVV0WZ607893//d5n/9V//dZSpazkEPz+uoaFB5up+O/PMM+XaP/uzP5P5zTffLHPF/TumzCfC6FTHlOuuczPN1L+T+zdyXV5u5prKZ8+eLdfeeOONMv/+978fZa5byuXu9ajzcx1haiaW+5snnniiXFtRUSFzN/urWPgGBwAAZIcNDgAAyA4bHAAAkB02OAAAIDtscAAAQHYmTBfV0qVLZe66pVI6IVIq6UMIoampKcpSZpqEkFY179aitKiZUyHoeS3Nzc1y7VlnnSVz1Y3nZuO4Tojt27fL/Nlnn42y2tpaudZ1kqh5Qe3t7XKt6wpUs3FCCOH555+PMte9cd5558n8tddeizLXEZby74jRuX9TNZPJzVBzz3L1fHbP7NQZVSmztW677baCj+E6xcrLy2Xu3hN13qndfyp35/Ebv/EbMv/5z38u82LhGxwAAJAdNjgAACA7bHAAAEB22OAAAIDsTJgi4+XLl8vcFWG5Yin1s9WuiFcVwoWgi7nceUybNk3mbn1fX1+UuUI4HLs+8pGPyNxdi+q6qKyslGt37dolc/eT7apA2I0vuf7662Wuxpqccsopcq0rBO3q6pK5ep2dnZ1Jx1i7dm2UuSJjiomL59JLL5W5+ul/90x0Rd+qgeOEE/RHoivAdaN+VCH8d77zHbk2pSDZ3T/33HOPzLdt2yZzdS+769a9fyp379+5554rc4qMAQAAErHBAQAA2WGDAwAAssMGBwAAZIcNDgAAyM6E6aKaNWuWzN3PwbsOKHUc19WxePFimaufuN66datcu2PHDpn39/fLXFX1t7S0yLUoLSndN/PmzUs6xqZNm6LsnHPOkWuXLFki8zVr1sj84MGDBf29EEJ4+OGHZX7SSSdFmesIc7nr8lIdMAMDAwWvDSGEqqoqmWNsnX/++TJX15zjRpKoLir3LHfjClzXUE1NTZTdcMMN5gwLt2HDBpnffvvtMi/Ga580aVKBZ+c7wtyzY6zxDQ4AAMgOGxwAAJAdNjgAACA7bHAAAEB22OAAAIDsZNlFpSrYXefFnj17ZF5XVyfz/fv3R1ljY6Nce9ttt8lcVd5/9atflWv/8R//Ueau20PlKR0HKD2qE8J1K+zdu1fmanaP65ZynVibN2+WuZrb5rqO3Owe1RU4ODgo17rruaenR+bq9ezevbvg8whBd2hNnTpVrnWvEemamppkrrqA3DPRdQelzLNy95v7nLj11lujzF0XtbW1Ml+xYkWUzZ8/X651HVrf+ta3ZK5mrrmOKzeLSr2v7v1zXcljjW9wAABAdtjgAACA7LDBAQAA2WGDAwAAspNlkfGCBQuiTBWlheB/gnvatGkyVwWLrujx7//+72WuipK/8Y1vyLWucM4VYKrCL1d8iWPD3Llzo8wV8e7atUvmDQ0NUfbcc8/Jta4g0BUbVlZWRpkqxh+Nug/b2trkWlfc6+4J1XTQ29tb8HmEEEJ9fX2UqedMCCG8+eabMoc3ffp0mS9fvlzm6vpyxfGuyFg1exx3nP5/fvccrq6ulvlXvvKVKHPjCmbPni1zVQT92c9+Vq79wz/8Q5m7MQuqoDhl1EkIetyJe0bMmTNH5u5z1t3LqfgGBwAAZIcNDgAAyA4bHAAAkB02OAAAIDtscAAAQHay7KJSVemuq8N1ZAwNDclc/az2D3/4w4Sz0z8Tv3PnTrnWVbD39fXJXHXApHa0oLTMmzcvylx3xOrVq2V+8sknR9njjz8u17qOQ/c3VTeF+9n3d955R+bqPnQ/+666X0LwHVDqOG40ytatW2WuxlE0NzfLtXRRpXOdRFu2bJH5ypUro0x1CobgxyyoTh3XceW6fR566CGZq2fun//5n8u1aiRDCCHccsstUfa9731Prn3vvfdkfs8998j8yiuvjLL29na51o3LULnrTnSjUdRzKYQQnn32WZmn4hscAACQHTY4AAAgO2xwAABAdtjgAACA7LDBAQAA2cmyi0rN6eno6JBr1byP0aiOlm9/+9tJx1Bc94abc+Vez8jISJT19/f/6ieGcTdz5swoczNzXFeg6oxy15zqUAnBdy+pLhV33br7Ta13HS3u2K5z6+mnn46ypUuXyrWuW0a9f24OEdK99dZbMr/44otlrjr6rrjiCrn2tddek/kdd9wRZcuWLZNr3bX1pS99SeZqJpPrZr377rtlfvrpp0dZ6mfNzTffLPPPfOYzUeY6eb/4xS/KXHV/uY7i8ZqHyDc4AAAgO2xwAABAdtjgAACA7LDBAQAA2WGDAwAAspNlF5WqYHfzderr62VeWVkp840bN0bZoUOHEs5OU/N8QvAdI25Oj+pocXOrcGyoq6uLMtUtF4LvAlIdSa4TT3VvhOC7QFRHi7tu3TwrZfLkyQWvDcHfh2oOjrvfXLeMWu+eHUjnugJTOuk2bNiQ9DdV15Cb5eZmE7qupi984QtRduONN8q1bgbU+vXro8zNJnRuvfVWmav3dfv27XKtm7fl8lLCNzgAACA7bHAAAEB22OAAAIDssMEBAADZybLIWBX/ueJLV/ToCiqfeOKJX/3ERrF3716Zu5/ed+MX1JiK8vJyudYVWqK01NTURJkrMndFmarwPrVg0RU2q+trcHBQrj1y5IjM1RgIt9ZxRcmumFpxxa6qSWH69OkFHxejc9etu0bV9ayyEPyz/Jlnnomyyy67TK5ta2uTuSvIb25ujrI777xTrnUjUFTx8XvvvSfXrlmzRuYXXnihzFXjyUsvvSTXOuqzyRX6u39flxcL3+AAAIDssMEBAADZYYMDAACywwYHAABkhw0OAADITpZdVHv27ImyiooKudaNZHA/Nf/UU08VfB4pPz/ufq67oaFB5q6LatasWVFWW1sr16r3CaVH/fu57gM3lkNdR67ryB3DrVfn4jr3XFeMyl1XjLuvXMehGr/guid7enpkrrpDqqur5VoUj+ukU/8eqR05XV1dBR03BH+9uOfwbbfdFmWui8r9TdcxpTzwwAMyd52y6h5KHemjPiPVqKDxxDc4AAAgO2xwAABAdtjgAACA7LDBAQAA2WGDAwAAspNlF5XqmHLzPlxHhuu6cuuVlFk/nZ2dMncdUG4WkXqd3d3dBZ8HSo/qAnIdIynXp+sMSZ3bpjpd3P3T2toqc9UxpV53CP6+cufX2NgYZe59ct2T6v12rxHjI3WuYDGe5e45rK4510W1efNmmff29kbZiSeeKNe6jj4341DNUUu9ntX7TRcVAADAGGODAwAAssMGBwAAZIcNDgAAyE6WRcaq0MkVYbnCNFcs5YqVlZQi4zfffFPma9askXlKAWbqT3CjtKhr1BUZu+tCHcONNnD3xODgYMF/0/1EvDu2OoYrDnUjRtw9q4qmXYGpO79CjzvasVNHCWBsDQ0NRZkbDeG4z4NHH300yi644AK59nOf+5zM1bN8586dcm1LS4vM6+rqZK648SpOyufbeOEbHAAAkB02OAAAIDtscAAAQHbY4AAAgOywwQEAANnJsovqJz/5SZTNnj1brp05c6bMXYfERRddFGXf+9735NqUivy2tjaZq0r/EPRPgYegO0wOHDhQ8Hmg9KifVXedcWrkQQgh7Nq1q6DjhlCc68V1Erkur8mTJ0eZu/ZdZ4jrAlH3eE9Pj1yb0iXputAqKytlTjfj2Ert6lHXnHtmp17PDQ0NUebG8ezYsUPmqivQ3RM1NTUyd9R17q7nYxnf4AAAgOywwQEAANlhgwMAALLDBgcAAGSHDQ4AAMhOll1U/f39Ufbiiy/Kta67qqqqSuYf+chHosx1UbnZOCnnMX/+fJm7Lq+UWTooLSlzpFy3h7vm1Bwkd427biTXYaS6Vw4ePFjwWnds9xpV90sIvvtLdZi4te7+Ue+f+/eqra2VOV1UpaWioiLK3PXpuhNHRkZk3tTUFGWuEyulc8udh7ue1WehO7ab13gs4xscAACQHTY4AAAgO2xwAABAdtjgAACA7LDBAQAA2cmyi0rZuHGjzD/60Y/K3HU8qDkza9eulWs3b95c4Nn5rhM3K2vx4sUFH8dV3qd0eWHsudlQivu3c51OquPHdXUcOnSo4PMIQXeBpHbzDQwMRJnraHHn594T9dpd16KbF6TOxb1/OXajHAtSZ1EtW7bs1z6Gu9+Gh4ejLGU2oeOO4Z7x7vWorsD6+vqkc1GvsdTwDQ4AAMgOGxwAAJAdNjgAACA7bHAAAEB2JkyRsStMdMXEjY2NMldFvJdddplcm1JkPDQ0JHNXeLp+/XqZb9++PcooJj42qJECIeiCXVc86MYYqOvfFcm6a9EVMqqxIa4Ysr29veBjuNeSWmCtCipdUb9qIgjBv3bFjbrA2Eotel2+fHnBa9317HJ1f6ZcQ6nUNR5CWmHznDlzinU6JYNvcAAAQHbY4AAAgOywwQEAANlhgwMAALLDBgcAAGRnwnRROW+99ZbMXZdSV1dXlK1evfrXPg/XzeW6ZaqqqmSeYyX8ROG6qFS3U2pHhuqMcn9PjTYIIYT9+/fLXHU1uU4nN8agoqIiylw314EDB2Secq8MDg7KtW7EhPo3cF1oqWMqMD6WLl0aZamjEBx3bSiuAyqFOz/3etTfXLJkya99Hu4eLMaYil8F3+AAAIDssMEBAADZYYMDAACywwYHAABkhw0OAADITpZdVGomjZtF9dBDD8n8yiuvLPjYrqujublZ5ps2bYoy10XlZua4qvmU6n2UFjd3THU8uG4F172krlF3rbhZSmpelDsXd926jhF1X7luLsfNkVLdX66LynWWuTlXytSpUwtei1+NunaL0Y3kPifGqwvo/3L3rDtvR71XxejApYsKAABgjLHBAQAA2WGDAwAAssMGBwAAZCfLImNXaKns3btX5u5n4lUR4p49e+TaK664QuaqyNgVj7ncFTb39/fLHKXPFdWqgnJX9OqOoYr83OgFdw2lFCW7USKuAFfl+/btk2tdIaO7Z9Vrd0X67vzUMdx5uGJsFE9KkfGMGTNkXltbG2XunkgpMk/l7iv1elILqd1noWoCGBgYSDq24u6J8cI3OAAAIDtscAAAQHbY4AAAgOywwQEAANlhgwMAALKTZReV6niYPHmyXOu6kR5++GGZf/azny342B/+8IfdKUbcz8xXV1fL3HVu9fT0FPw3UVpcp4bqnHCdOu66UF0TCxYskGtdZ6GjOk9cB5TrdBoZGYkyN+7B/ey7G3eifoK+vb1drnUdLeo+7OrqSjoGiiflPZ41a5bMKyoqomx4eFiuHcsRBO7YKZ1i7hjumaI+99wzZc2aNTJ/9dVXo8x1J6Z0NhcTdyIAAMgOGxwAAJAdNjgAACA7bHAAAEB22OAAAIDsZNlFpRw6dChp/V133SXzT3ziE1HmKsTdbI/169dH2ZYtW+Ra1xniOrc6OztljtI3adIkmatuHTdzynX2/MM//EOUPfjgg3Jtd3e3zF2HhOp2cveb6/Zwx07hOkxUd8jll18u195xxx0ynz17dpS5Dszx6hiZSFK6qBoaGmSu7jfX5Zc6A0qtd+dcjPlNrpsrpfvLPX8aGxsLPo9S6yAsrbMBAAAoAjY4AAAgO2xwAABAdtjgAACA7LDBAQAA2ZkwXVSpVfCuC+S+++6Lsuuuu06uVbNOQtAzgFpaWuTamTNnytx1aLW1tckcpU9114Wgu0Bct4Lq9gkhhNbW1ihbtWqVXHvppZfK/JJLLpF5TU1NlLm5No7qXnEdLa7j6sknn5S564hUFi9eLHP1/HDnsW7dOpk/8MADBZ8HisfN+VOdiK47tby8XObuc0V1KblOp2LMsyrGMVxnZm1tbcHHKEZHWDHxDQ4AAMgOGxwAAJAdNjgAACA7bHAAAEB2JkyRseMKBd3Prf/4xz+OsiVLlsi1r7zyisxTig1VUXMIIQwODsp848aNBR8bpeXuu++WuSrudQWB7ppL4UY4uDwn3/nOd2R+2WWXRdn+/fvl2kceeaSo54RYStOIa7zYtm1blKmxIyH44uOU0QTus8bl6jW6YmJ33u59UvnIyEjSsZViFDsXE9/gAACA7LDBAQAA2WGDAwAAssMGBwAAZIcNDgAAyE5ZqVU9AwAA/Lr4BgcAAGSHDQ4AAMgOGxwAAJAdNjgAACA7bHAAAEB22OAAAIDs/D9gXtfEU7l6UgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 10))\n", + "for images in train_dataset.take(1):\n", + " for i in range(9):\n", + " ax = plt.subplot(3, 3, i + 1)\n", + " plt.imshow(images[i,:,:,0].numpy().astype(\"uint8\"), cmap='gray')\n", + " plt.axis(\"off\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "normalization_layer = layers.experimental.preprocessing.Rescaling(scale= 1./255)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "normalized_ds = train_dataset.map(lambda x: normalization_layer(x))\n", + "image_batch = next(iter(normalized_ds))\n", + "first_image = image_batch[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0 1.0\n" + ] + } + ], + "source": [ + "print(np.min(first_image), np.max(first_image)) " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "input_encoder = (28, 28, 1)\n", + "input_decoder = (2,)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def encoder(input_encoder):\n", + " \n", + " inputs = keras.Input(shape=input_encoder, name='input_layer')\n", + " x = layers.Conv2D(32, kernel_size=3, strides= 1, padding='same', name='conv_1')(inputs)\n", + " x = layers.BatchNormalization(name='bn_1')(x)\n", + " x = layers.LeakyReLU(name='lrelu_1')(x)\n", + " #x = layers.Dropout(rate = 0.25)(x)\n", + " \n", + " x = layers.Conv2D(64, kernel_size=3, strides= 2, padding='same', name='conv_2')(x)\n", + " x = layers.BatchNormalization(name='bn_2')(x)\n", + " x = layers.LeakyReLU(name='lrelu_2')(x)\n", + " #x = layers.Dropout(rate = 0.25)(x)\n", + " \n", + " x = layers.Conv2D(64, 3, 2, padding='same', name='conv_3')(x)\n", + " x = layers.BatchNormalization(name='bn_3')(x)\n", + " x = layers.LeakyReLU(name='lrelu_3')(x)\n", + " #x = layers.Dropout(rate = 0.25)(x)\n", + "\n", + " x = layers.Conv2D(64, 3, 1, padding='same', name='conv_4')(x)\n", + " x = layers.BatchNormalization(name='bn_4')(x)\n", + " x = layers.LeakyReLU(name='lrelu_4')(x)\n", + " #x = layers.Dropout(rate = 0.25)(x)\n", + " \n", + " flatten = layers.Flatten()(x)\n", + " bottleneck = layers.Dense(2, name='dense_1')(flatten)\n", + " model = tf.keras.Model(inputs, bottleneck, name=\"Encoder\")\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "enc = encoder(input_encoder)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "#enc.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def decoder(input_decoder):\n", + " \n", + " inputs = keras.Input(shape=input_decoder, name='input_layer')\n", + " x = layers.Dense(3136, name='dense_1')(inputs)\n", + " #x = tf.reshape(x, [-1, 7, 7, 64], name='Reshape_Layer')\n", + " x = layers.Reshape((7,7,64), name='Reshape_Layer')(x)\n", + " x = layers.Conv2DTranspose(64, 3, strides= 1, padding='same',name='conv_transpose_1')(x)\n", + " x = layers.BatchNormalization(name='bn_1')(x)\n", + " x = layers.LeakyReLU(name='lrelu_1')(x)\n", + " #x = layers.Dropout(rate = 0.25)(x)\n", + " \n", + " x = layers.Conv2DTranspose(64, 3, strides= 2, padding='same', name='conv_transpose_2')(x)\n", + " x = layers.BatchNormalization(name='bn_2')(x)\n", + " x = layers.LeakyReLU(name='lrelu_2')(x)\n", + " #x = layers.Dropout(rate = 0.25)(x)\n", + " \n", + " x = layers.Conv2DTranspose(32, 3, 2, padding='same', name='conv_transpose_3')(x)\n", + " x = layers.BatchNormalization(name='bn_3')(x)\n", + " x = layers.LeakyReLU(name='lrelu_3')(x)\n", + " #x = layers.Dropout(rate = 0.25)(x)\n", + " \n", + " outputs = layers.Conv2DTranspose(1, 3, 1,padding='same', activation='sigmoid', name='conv_transpose_4')(x)\n", + " model = tf.keras.Model(inputs, outputs, name=\"Decoder\")\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "dec = decoder(input_decoder)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"Decoder\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input_layer (InputLayer) [(None, 2)] 0 \n", + "_________________________________________________________________\n", + "dense_1 (Dense) (None, 3136) 9408 \n", + "_________________________________________________________________\n", + "Reshape_Layer (Reshape) (None, 7, 7, 64) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_1 (Conv2DTran (None, 7, 7, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_1 (BatchNormalization) (None, 7, 7, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_1 (LeakyReLU) (None, 7, 7, 64) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_2 (Conv2DTran (None, 14, 14, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_2 (BatchNormalization) (None, 14, 14, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_2 (LeakyReLU) (None, 14, 14, 64) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_3 (Conv2DTran (None, 28, 28, 32) 18464 \n", + "_________________________________________________________________\n", + "bn_3 (BatchNormalization) (None, 28, 28, 32) 128 \n", + "_________________________________________________________________\n", + "lrelu_3 (LeakyReLU) (None, 28, 28, 32) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_4 (Conv2DTran (None, 28, 28, 1) 289 \n", + "=================================================================\n", + "Total params: 102,657\n", + "Trainable params: 102,337\n", + "Non-trainable params: 320\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "dec.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# dec.save('ae-dec-fashion.h5')\n", + "# enc.save('ae-enc-fashion.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "#dec.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "#model.layers[1].get_weights()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "#model.save('autoencoder.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "optimizer = tf.keras.optimizers.Adam(lr = 0.0005)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "from tensorflow.keras import backend as K" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def ae_loss(y_true, y_pred):\n", + " loss = K.mean(K.square(y_true - y_pred), axis = [1,2,3])\n", + " return loss" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# Notice the use of `tf.function`\n", + "# This annotation causes the function to be \"compiled\".\n", + "@tf.function\n", + "def train_step(images):\n", + "\n", + " with tf.GradientTape() as encoder, tf.GradientTape() as decoder:\n", + " \n", + " latent = enc(images, training=True)\n", + " generated_images = dec(latent, training=True)\n", + " loss = ae_loss(images, generated_images)\n", + " \n", + " gradients_of_enc = encoder.gradient(loss, enc.trainable_variables)\n", + " gradients_of_dec = decoder.gradient(loss, dec.trainable_variables)\n", + " \n", + " \n", + " optimizer.apply_gradients(zip(gradients_of_enc, enc.trainable_variables))\n", + " optimizer.apply_gradients(zip(gradients_of_dec, dec.trainable_variables))\n", + " return loss" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def train(dataset, epochs):\n", + " for epoch in range(epochs):\n", + " start = time.time()\n", + " i = 0\n", + " loss_ = []\n", + " for image_batch in dataset:\n", + " i += 1\n", + " loss = train_step(image_batch)\n", + " #loss_.append(loss)\n", + "\n", + " #print(\"Loss\",np.mean(loss_)) \n", + " seed = image_batch[:25]\n", + " display.clear_output(wait=True)\n", + " generate_and_save_images([enc,dec],\n", + " epoch + 1,\n", + " seed)\n", + " # Save the model every 15 epochs\n", + " #if (epoch + 1) % 15 == 0:\n", + " #checkpoint.save(file_prefix = checkpoint_prefix)\n", + " enc.save_weights('tf_ae/fashion/training_weights/enc_'+ str(epoch)+'.h5')\n", + " dec.save_weights('tf_ae/fashion/training_weights/dec_'+ str(epoch)+'.h5')\n", + " print ('Time for epoch {} is {} sec'.format(epoch + 1, time.time()-start))\n", + "\n", + " # Generate after the final epoch\n", + " display.clear_output(wait=True)\n", + " generate_and_save_images([enc,dec],\n", + " epochs,\n", + " seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_and_save_images(model, epoch, test_input):\n", + " # Notice `training` is set to False.\n", + " # This is so all layers run in inference mode (batchnorm).\n", + " latent = enc(test_input, training=False)\n", + " predictions = dec(latent, training=False)\n", + " print(predictions.shape)\n", + " fig = plt.figure(figsize=(4,4))\n", + "\n", + " for i in range(predictions.shape[0]):\n", + " plt.subplot(5, 5, i+1)\n", + " plt.imshow(predictions[i, :, :, 0] * 255, cmap='gray')\n", + " plt.axis('off')\n", + "\n", + " plt.savefig('tf_ae/fashion/images/image_at_epoch_{:d}.png'.format(epoch))\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(25, 28, 28, 1)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "train(normalized_ds, 40)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "enc.load_weights('../tf_ae/fashion/training_weights/enc_39.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "dec.load_weights('../tf_ae/fashion/training_weights/dec_39.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "embeddings = None\n", + "for i in normalized_ds:\n", + " embed = encoder_model.predict(i)\n", + " if embeddings is None:\n", + " embeddings = embed\n", + " else:\n", + " embeddings = np.concatenate((embeddings, embed))\n", + " if embeddings.shape[0] > 5000:\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n_to_show = 5000\n", + "figsize = 10\n", + "\n", + "index = np.random.choice(range(len(x_test)), n_to_show)\n", + "example_images = x_test[index]\n", + "\n", + "embeddings = enc.predict(example_images)\n", + "\n", + "\n", + "plt.figure(figsize=(figsize, figsize))\n", + "plt.scatter(embeddings[:, 0] , embeddings[:, 1], alpha=0.5, s=2)\n", + "plt.xlabel(\"Dimension-1\", size=20)\n", + "plt.ylabel(\"Dimension-2\", size=20)\n", + "plt.xticks(size=20)\n", + "plt.yticks(size=20)\n", + "plt.title(\"Projection of 2D Latent-Space (Fashion-MNIST)\", size=20)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "min_x = min(embeddings[:, 0])\n", + "max_x = max(embeddings[:, 0])\n", + "min_y = min(embeddings[:, 1])\n", + "max_y = max(embeddings[:, 1])" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# Create dictionary of target classes\n", + "label_dict = {\n", + " 0: 'T-shirt/top',\n", + " 1: 'Trouser',\n", + " 2: 'Pullover',\n", + " 3: 'Dress',\n", + " 4: 'Coat',\n", + " 5: 'Sandal',\n", + " 6: 'Shirt',\n", + " 7: 'Sneaker',\n", + " 8: 'Bag',\n", + " 9: 'Ankle boot',\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "figsize = 15\n", + "\n", + "latent = enc.predict(x_test[:25])\n", + "reconst = dec.predict(latent)\n", + "\n", + "fig = plt.figure(figsize=(figsize, 10))\n", + "#fig.subplots_adjust(wspace=-0.021)\n", + "\n", + "for i in range(25):\n", + " ax = fig.add_subplot(5, 5, i+1)\n", + " ax.axis('off')\n", + " plt.text(0.5, -0.15, str(label_dict[y_test[i]]), fontsize=15, ha='center', transform=ax.transAxes)\n", + " #plt.subplots_adjust(wspace=None, hspace=None)\n", + " plt.imshow(reconst[i, :,:,0]*255, cmap = 'gray')\n", + "plt.show() " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reconstructing Fashion Images with Latent-Vector Sampled Uniformly" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "min_x = min(embeddings[:, 0])\n", + "max_x = max(embeddings[:, 0])\n", + "min_y = min(embeddings[:, 1])\n", + "max_y = max(embeddings[:, 1])\n", + "\n", + "x = np.random.uniform(low=min_x,high=max_x, size = (10,1))\n", + "y = np.random.uniform(low=min_y,high=max_y, size = (10,1))\n", + "bottleneck = np.concatenate((x, y), axis=1)\n", + "reconst = dec.predict(bottleneck)\n", + "\n", + "fig = plt.figure(figsize=(15, 10))\n", + "\n", + "for i in range(10):\n", + " ax = fig.add_subplot(5, 5, i+1)\n", + " ax.axis('off')\n", + " ax.text(0.5, -0.15, str(np.round(bottleneck[i],1)), fontsize=10, ha='center', transform=ax.transAxes)\n", + " \n", + " ax.imshow(reconst[i, :,:,0]*255, cmap = 'gray')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Tuts", + "language": "python", + "name": "tuts" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Autoencoder-in-TensorFlow/AE_Cartoon_TensorFlow.ipynb b/Autoencoder-in-TensorFlow/AE_Cartoon_TensorFlow.ipynb new file mode 100644 index 000000000..8df29609d --- /dev/null +++ b/Autoencoder-in-TensorFlow/AE_Cartoon_TensorFlow.ipynb @@ -0,0 +1,805 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import imageio\n", + "import glob\n", + "import os\n", + "import time\n", + "import cv2\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers\n", + "from IPython import display\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from tensorflow.keras import backend as K\n", + "%matplotlib inline\n", + "from sklearn.manifold import TSNE\n", + "import matplotlib.pyplot as plt\n", + "from tensorflow import keras" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "#os.environ['CUDA_VISIBLE_DEVICES'] = '0'" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "img_height, img_width = 256, 256\n", + "batch_size = 128" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 100000 files belonging to 10 classes.\n" + ] + } + ], + "source": [ + "train_ds = tf.keras.preprocessing.image_dataset_from_directory(\n", + " '/home/aditya/VAE/cartoonset100k/',\n", + " image_size=(img_height, img_width),\n", + " batch_size=batch_size,\n", + " label_mode=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 10))\n", + "for images in train_ds.take(1):\n", + " for i in range(9):\n", + " ax = plt.subplot(3, 3, i + 1)\n", + " plt.imshow(images[i].numpy().astype(\"uint8\"))\n", + " plt.axis(\"off\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "normalization_layer = layers.experimental.preprocessing.Rescaling(scale= 1./255)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "normalized_ds = train_ds.map(lambda x: normalization_layer(x))\n", + "image_batch = next(iter(normalized_ds))\n", + "first_image = image_batch[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0 1.0\n" + ] + } + ], + "source": [ + "print(np.min(first_image), np.max(first_image)) " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "input_encoder = (256, 256, 3)\n", + "input_decoder = (200,)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def encoder(input_encoder):\n", + " \n", + " \n", + " inputs = keras.Input(shape=input_encoder, name='input_layer')\n", + " x = layers.Conv2D(32, kernel_size=3, strides= 2, padding='same', name='conv_1')(inputs)\n", + " x = layers.BatchNormalization(name='bn_1')(x)\n", + " x = layers.LeakyReLU(name='lrelu_1')(x)\n", + " \n", + " x = layers.Conv2D(64, kernel_size=3, strides= 2, padding='same', name='conv_2')(x)\n", + " x = layers.BatchNormalization(name='bn_2')(x)\n", + " x = layers.LeakyReLU(name='lrelu_2')(x)\n", + " \n", + " x = layers.Conv2D(64, 3, 2, padding='same', name='conv_3')(x)\n", + " x = layers.BatchNormalization(name='bn_3')(x)\n", + " x = layers.LeakyReLU(name='lrelu_3')(x)\n", + "\n", + " x = layers.Conv2D(64, 3, 2, padding='same', name='conv_4')(x)\n", + " x = layers.BatchNormalization(name='bn_4')(x)\n", + " x = layers.LeakyReLU(name='lrelu_4')(x)\n", + " \n", + " x = layers.Conv2D(64, 3, 2, padding='same', name='conv_5')(x)\n", + " x = layers.BatchNormalization(name='bn_5')(x)\n", + " x = layers.LeakyReLU(name='lrelu_5')(x)\n", + " \n", + " \n", + " flatten = layers.Flatten()(x)\n", + " bottleneck = layers.Dense(200, name='dense_1')(flatten)\n", + " model = tf.keras.Model(inputs, bottleneck, name=\"Encoder\")\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "enc = encoder(input_encoder)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "#enc.save('enc.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"Encoder\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input_layer (InputLayer) [(None, 256, 256, 3)] 0 \n", + "_________________________________________________________________\n", + "conv_1 (Conv2D) (None, 128, 128, 32) 896 \n", + "_________________________________________________________________\n", + "bn_1 (BatchNormalization) (None, 128, 128, 32) 128 \n", + "_________________________________________________________________\n", + "lrelu_1 (LeakyReLU) (None, 128, 128, 32) 0 \n", + "_________________________________________________________________\n", + "conv_2 (Conv2D) (None, 64, 64, 64) 18496 \n", + "_________________________________________________________________\n", + "bn_2 (BatchNormalization) (None, 64, 64, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_2 (LeakyReLU) (None, 64, 64, 64) 0 \n", + "_________________________________________________________________\n", + "conv_3 (Conv2D) (None, 32, 32, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_3 (BatchNormalization) (None, 32, 32, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_3 (LeakyReLU) (None, 32, 32, 64) 0 \n", + "_________________________________________________________________\n", + "conv_4 (Conv2D) (None, 16, 16, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_4 (BatchNormalization) (None, 16, 16, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_4 (LeakyReLU) (None, 16, 16, 64) 0 \n", + "_________________________________________________________________\n", + "conv_5 (Conv2D) (None, 8, 8, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_5 (BatchNormalization) (None, 8, 8, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_5 (LeakyReLU) (None, 8, 8, 64) 0 \n", + "_________________________________________________________________\n", + "flatten (Flatten) (None, 4096) 0 \n", + "_________________________________________________________________\n", + "dense_1 (Dense) (None, 200) 819400 \n", + "=================================================================\n", + "Total params: 950,728\n", + "Trainable params: 950,152\n", + "Non-trainable params: 576\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "enc.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def decoder(input_decoder):\n", + " \n", + " inputs = keras.Input(shape=input_decoder, name='input_layer')\n", + " x = layers.Dense(4096, name='dense_1')(inputs)\n", + " #x = tf.reshape(x, [-1, 8, 8, 64], name='Reshape_Layer')\n", + " x = layers.Reshape((8,8,64), name='Reshape_Layer')(x)\n", + " x = layers.Conv2DTranspose(64, 3, strides= 2, padding='same',name='conv_transpose_1')(x)\n", + " x = layers.BatchNormalization(name='bn_1')(x)\n", + " x = layers.LeakyReLU(name='lrelu_1')(x)\n", + " \n", + " \n", + " x = layers.Conv2DTranspose(64, 3, strides= 2, padding='same', name='conv_transpose_2')(x)\n", + " x = layers.BatchNormalization(name='bn_2')(x)\n", + " x = layers.LeakyReLU(name='lrelu_2')(x)\n", + " \n", + " \n", + " x = layers.Conv2DTranspose(64, 3, 2, padding='same', name='conv_transpose_3')(x)\n", + " x = layers.BatchNormalization(name='bn_3')(x)\n", + " x = layers.LeakyReLU(name='lrelu_3')(x)\n", + " \n", + " \n", + " x = layers.Conv2DTranspose(32, 3, 2, padding='same', name='conv_transpose_4')(x)\n", + " x = layers.BatchNormalization(name='bn_4')(x)\n", + " x = layers.LeakyReLU(name='lrelu_4')(x)\n", + " \n", + " \n", + " \n", + " outputs = layers.Conv2DTranspose(3, 3, 2,padding='same', activation='sigmoid', name='conv_transpose_5')(x)\n", + " model = tf.keras.Model(inputs, outputs, name=\"Decoder\")\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "dec = decoder(input_decoder)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"Decoder\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input_layer (InputLayer) [(None, 200)] 0 \n", + "_________________________________________________________________\n", + "dense_1 (Dense) (None, 4096) 823296 \n", + "_________________________________________________________________\n", + "Reshape_Layer (Reshape) (None, 8, 8, 64) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_1 (Conv2DTran (None, 16, 16, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_1 (BatchNormalization) (None, 16, 16, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_1 (LeakyReLU) (None, 16, 16, 64) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_2 (Conv2DTran (None, 32, 32, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_2 (BatchNormalization) (None, 32, 32, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_2 (LeakyReLU) (None, 32, 32, 64) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_3 (Conv2DTran (None, 64, 64, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_3 (BatchNormalization) (None, 64, 64, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_3 (LeakyReLU) (None, 64, 64, 64) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_4 (Conv2DTran (None, 128, 128, 32) 18464 \n", + "_________________________________________________________________\n", + "bn_4 (BatchNormalization) (None, 128, 128, 32) 128 \n", + "_________________________________________________________________\n", + "lrelu_4 (LeakyReLU) (None, 128, 128, 32) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_5 (Conv2DTran (None, 256, 256, 3) 867 \n", + "=================================================================\n", + "Total params: 954,307\n", + "Trainable params: 953,859\n", + "Non-trainable params: 448\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "dec.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "#dec.save('ae-cartoon-dec.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "#model.layers[1].get_weights()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "#model.save('autoencoder.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "optimizer = tf.keras.optimizers.Adam(lr = 0.0005)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def ae_loss(y_true, y_pred):\n", + " #loss = tf.keras.losses.mean_squared_error(y_true, y_pred)\n", + " #loss = tf.reduce_mean(tf.square(tf.subtract(y_true, y_pred)))\n", + " loss = K.mean(K.square(y_true - y_pred), axis = [1,2,3])\n", + " return loss" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# Notice the use of `tf.function`\n", + "# This annotation causes the function to be \"compiled\".\n", + "@tf.function\n", + "def train_step(images):\n", + "\n", + " with tf.GradientTape() as encoder, tf.GradientTape() as decoder:\n", + " \n", + " latent = enc(images, training=True)\n", + " generated_images = dec(latent, training=True)\n", + " loss = ae_loss(images, generated_images)\n", + " \n", + " gradients_of_enc = encoder.gradient(loss, enc.trainable_variables)\n", + " gradients_of_dec = decoder.gradient(loss, dec.trainable_variables)\n", + " \n", + " \n", + " optimizer.apply_gradients(zip(gradients_of_enc, enc.trainable_variables))\n", + " optimizer.apply_gradients(zip(gradients_of_dec, dec.trainable_variables))\n", + " return loss" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def train(dataset, epochs):\n", + " for epoch in range(epochs):\n", + " start = time.time()\n", + " i = 0\n", + " loss_ = []\n", + " for image_batch in dataset:\n", + " i += 1\n", + " loss = train_step(image_batch)\n", + " #loss_.append(loss)\n", + "\n", + " #print(\"Loss\",np.mean(loss_)) \n", + " seed = image_batch[:25]\n", + " display.clear_output(wait=True)\n", + " generate_and_save_images([enc,dec],\n", + " epoch + 1,\n", + " seed)\n", + " # Save the model every 15 epochs\n", + " #if (epoch + 1) % 15 == 0:\n", + " #checkpoint.save(file_prefix = checkpoint_prefix)\n", + " enc.save_weights('tf_ae/cartoon/training_weights/enc_'+ str(epoch)+'.h5')\n", + " dec.save_weights('tf_ae/cartoon/training_weights/dec_'+ str(epoch)+'.h5')\n", + " print ('Time for epoch {} is {} sec'.format(epoch + 1, time.time()-start))\n", + "\n", + " # Generate after the final epoch\n", + " display.clear_output(wait=True)\n", + " generate_and_save_images([enc,final,dec],\n", + " epochs,\n", + " seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_and_save_images(model, epoch, test_input):\n", + " # Notice `training` is set to False.\n", + " # This is so all layers run in inference mode (batchnorm).\n", + " latent = enc(test_input, training=False)\n", + " predictions = dec(latent, training=False)\n", + " print(predictions.shape)\n", + " fig = plt.figure(figsize=(4,4))\n", + "\n", + " for i in range(predictions.shape[0]):\n", + " plt.subplot(5, 5, i+1)\n", + " pred = predictions[i, :, :, :] * 255\n", + " pred = np.array(pred) \n", + " pred = pred.astype(np.uint8)\n", + " #cv2.imwrite('tf_ae/images/image'+ str(i)+'.png',pred)\n", + " \n", + " plt.imshow(pred)\n", + " plt.axis('off')\n", + "\n", + " plt.savefig('tf_ae/cartoon/images/image_at_epoch_{:d}.png'.format(epoch))\n", + " plt.show()\n", + " \n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "train(normalized_ds, 30)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "enc.load_weights('../tf_ae/cartoon/training_weights/enc_29.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "dec.load_weights('../tf_ae/cartoon/training_weights/dec_29.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "embeddings = None\n", + "for i in normalized_ds:\n", + " latent = enc.predict(i)\n", + " if embeddings is None:\n", + " embeddings = latent\n", + " else:\n", + " embeddings = np.concatenate((embeddings, latent))\n", + " if embeddings.shape[0] > 5000:\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(128, 200)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "embeddings.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n_to_show = 5000\n", + "grid_size = 15\n", + "figsize = 12\n", + "\n", + "tsne = TSNE(n_components=2, init='pca', random_state=0)\n", + "X_tsne = tsne.fit_transform(embeddings)\n", + "min_x = min(X_tsne[:, 0])\n", + "max_x = max(X_tsne[:, 0])\n", + "min_y = min(X_tsne[:, 1])\n", + "max_y = max(X_tsne[:, 1])\n", + "\n", + "\n", + "plt.figure(figsize=(figsize, figsize))\n", + "plt.scatter(X_tsne[:, 0] , X_tsne[:, 1], alpha=0.5, s=2)\n", + "plt.xlabel(\"Dimension-1\", size=20)\n", + "plt.ylabel(\"Dimension-2\", size=20)\n", + "plt.xticks(size=20)\n", + "plt.yticks(size=20)\n", + "plt.title(\"Autoencoder - Projection of 200D Latent-Space to 2D (Cartoon Set)\", size=18)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "reconstruction = None\n", + "lat_space = None\n", + "for i in normalized_ds:\n", + " latent= enc.predict(i)\n", + " out = dec.predict(latent)\n", + " if reconstruction is None:\n", + " reconstruction = out\n", + " lat_space = latent\n", + " else:\n", + " reconstruction = np.concatenate((reconstruction, out))\n", + " lat_space = np.concatenate((lat_space, latent))\n", + " if reconstruction.shape[0] > 5000:\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(5120, 256, 256, 3)" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reconstruction.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "figsize = 15\n", + "\n", + "fig = plt.figure(figsize=(figsize, 10))\n", + "#fig.subplots_adjust(hspace=0.2, wspace=None)\n", + "\n", + "for i in range(25):\n", + " ax = fig.add_subplot(5, 5, i+1)\n", + " ax.axis('off')\n", + " pred = reconstruction[i, :, :, :] * 255\n", + " pred = np.array(pred) \n", + " pred = pred.astype(np.uint8)\n", + " ax.imshow(pred)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reconstructing Cartoon Images with Latent-Vector Sampled Uniformly" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10, 200)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "figsize = 15\n", + "\n", + "min_x = lat_space.min(axis=0)\n", + "max_x = lat_space.max(axis=0)\n", + "# #print(max_x.shape, min_x.shape)\n", + "x = np.random.uniform(size = (10,200))\n", + "x = x * (max_x - (np.abs(min_x))) \n", + "print(x.shape)\n", + "#x = np.random.normal(size = (10,200))\n", + "reconstruct = dec.predict(x)\n", + "\n", + "\n", + "fig = plt.figure(figsize=(figsize, 10))\n", + "\n", + "for i in range(10):\n", + " ax = fig.add_subplot(5, 5, i+1)\n", + " ax.axis('off')\n", + " pred = reconstruct[i, :, :, :] * 255\n", + " pred = np.array(pred) \n", + " pred = pred.astype(np.uint8)\n", + " ax.imshow(pred)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reconstructing Cartoon Images from a Latent-Vector Sampled with Normal Distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyAAAADcCAYAAACIyMWXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9775cSY4cCBoAP3EvWX80anXPaEYfdh9g3/+Ndn+jXc2M1KpK3ojjDuwHM/gJZlVlZZHsGqkV3p1ZTPIy4kQcP3DAYGawqsJrvdZrvdZrvdZrvdZrvdZrvdbfY/n/3RfwWq/1Wq/1Wq/1Wq/1Wq/1Wv/jrFcB8lqv9Vqv9Vqv9Vqv9Vqv9Vp/t/UqQF7rtV7rtV7rtV7rtV7rtV7r77ZeBchrvdZrvdZrvdZrvdZrvdZr/d3WqwB5rdd6rdd6rdd6rdd6rdd6rb/behUgr/Var/Var/Var/Var/Var/V3W+OX/rAyC2bXf/83YNlbVbCna/qxrw38C73037Tc/b+Bq/jvc/1L7NkC8HxD/tIe/Jfcm/+tr9ee/b7132Ks/VXrrwTNnz87P/7tv++Ze+3bb18/cs/+9xw7/97X/tqz377+u42zP19mjL3/nay/tGd/sQB5Xn2j1jpRBbh388RQlTBAD6HxxKlC4euH08wBA2olCk+/DyArsdaEmSNi7NfKXMhcgBncHJmFGAErYK4HUAWPAcDgHrrWBFB8v+sTIDNh5l8FC75+6vOY/pzXzc9l+tvX6+zP8vS/KxcqExGhU9f2z2cl3Fzfheta1v77+3vTtbvffu1tea1fWNyzvO9cptvCPVuVuh/X7wP1J0FpZWLNE+7cmwDgHqhKnOcDIwY8AlXXvuG91v2FwZz3/7qW0nNkT9fDZ6IKiPCvfn/vTwCZfH70MtxreuZWJsIdrn1V/V5ZT5ngtdeu59PQMYLXWE97/C//Pj/TxO326ftu1mvtde3bpd+xp3uwFCOi/wT19PsRQ39fkcu6RrCv9hffJ//k3lfljocG23GMf6f2a7s7qhJzPhARcIv9s2tN7Vldo9l+/7XW/u/+s37errjM53DOEzBgxAAK+xnqfdtnSYyxv5t+1vrzVxWynmJtP4u5MNeJ9/ff/rgb9z/w4n0p5Jq8j0/3mPd9ck8Z/0HxXOx48pwn8PzGU2zmfgAA5o9XvOb+SZ3t9tXr8PeuM7rjPOP0tfeh8x46n/nSfO3OP573cn/WqqVrv85x7uXEDraKy12JX88bP/OcJ9wM5vH0vF3nhNl+gPmZKnHzt3+BO/g/3uq48+fi7Nd5gD2ntQCuM7N/vPfEFXA79iTcOjdVTNJ7Fgpu8SfPiennn+Pk89n79Djss+Lrz4X9s88Q0PVcXflm77XnPOCK1897EE9nQT297vU+X31f+32gn/3zZKtfVYA836jzfGBlYozxdLDlviAeXEzaeFELbgH3AeyEpb9MQ3joiz8x551FxnjbB+k5H1jzwZ8dN1QBKwOGxFofQBWi3gH4DnBVLAZMN7EyFewS7sfeDAxcPLhX9ibRdefaASY8sKr2zxoAj4OHLhayCnOdWLlwjJsKJRVZSiRCRVJVoVBIFXJj3HhgVieEE8fxKkC+d117NjHnncm+igcUkLVQKmwjBhO5frCKB4h5ICsx54k//vRfcRwHbrfPGHHwka9E5sSJBa+hvQzMdaIyAQPcB4NJJVYm5uLDHs7E0VYHsUKuhLlhrYVjHNrPhjkn3AOuyLNyInMiy2DGg8uMqWghUWnwiP09dCIGMxgMWaWCWcV3BEIHLJ9ZAQoeV82ivYni3oeCUuWJrPNVgPyg9Rxre9/u+1CFlQ/GVB+MqdrLaz1UgLzBfSj+7hfdsbHr0F08dnG7oFg1sfJExI37vJj05FNx7QBGBBgnT8wEzA+4OVYunPMBoBgL/djHIz/TyWfOB1bV3tOGgpvDFfdzTdwfP6FqYYx3jKGYqDheuS7wZ911KHfCOWAeqDWReXLfZsHHG8y4z3PdUXUHXgXId6/es5UTc34AMMYIxVTGqxPhAzFuMDDuZC6YQckWwcWq5D02wOCwPqtR2uvJ/WO+U6CsxP3xoRjp4M4vxmAovu/Cgq+2VsLc+coFxdOF4QdBRCVXuSZWPgALRBwAlLBWobBgNhAxkGsqJuZOaCOu5xMqgsscBuYUhUSuEwBjap8fzEcmKgsxjh2/V/J1bserAPne9RxnH+eJQukMfAaOmQ/4z4Dshnc2SKOfZc739ArKD8IDMcD4WMBcE7mYexzjKpAbFDEzBK5CgdsqMZfygAb/VeAYcOW06OK4AKyvrzEZO2EEKFkIEfjvc8DgBPvdtcc7Rj+D9lcDQZAo8PS+phrg+bts4Pbny36pBdXtqi4aHucDH/cvOJOIQ7jvL8NqYi0m48MdWXywRxiAPvwKix8R4UyE3BxuhrlO5FoIB1bygh2GmQulhzvNAaFzIwyGCTcgazD1KsMYN4xgYDnn1IEFwBwRhoibEjfTDWSBMLOwEvsLDwfCsBE7oJg8Avx83IJEMaqQxRpvJv9+KgEdbhiu39fGTwBuBYPhTGzkw1AIK/zP//jvXy3Wb1w/37NznnicX5AFXEgA73NAxWAB3SswMww3ZBkfq2ThsHIRJbaBKsfbccCNHcFVU3s9ADhWpgpgIngjBgrAl3Mi4Qh3omogqutC9AzAnCfWPHG73TBiINyxkg+2C/moWpjrjjP5bKF42I1whNdGuImymBAYJp9dfKy1GLgMmGtdAc8dYQZ38JBGwVEwY5LIw7DhIBX1lvjdP/w/X3v2O9bzvq1MPM4P3O8/CYEtjOhDMGFYABywYNFQTMjdgLKBlV2KOqx4L+ci4uvmSHN27czw5XEHKhFWMDc4Uigxi4QEcK7C0uFynnd8HoG32w3uBivG/HOyKzPXwpkLRwTCD3XhDKlnzw14zIVz8X3CAyMcIxj3US5waSLnA4aJM3ktESzIw/gsZCYMTFj5HDGurjkJDtVC5YkGu2rxM1YuEIxy/PZ/+X+99u03rp/H2vO84/7xB6zCjjsp8J/7K1QAZoPEcO8unrq9AFxn8Crov4BVF6J6P0+EmbrEjHNrPXA/J8KC7xMEbDrpc/NdNDOGJc45dwFSKPSpXigMa6R6wrEwVyJLIKcHRnDfJgIFgkaNEFstnGvBzXEEX8/UEX/MhTUnxmDXHEogVwFhARhjNGoJLALPiyrMTIQB//M//YfXnv3G9Sd7dk58eTxUbGAn1c0cyGSOEOrqMTe0C8gBUN3dzcRUvhjW+964T4r7fGZiZmo/Mi/esazPVOvnAcoNmOT39Xb3LqtwG0P7o7t5V5eCYDd0nrM4RqVise/X6IbAqm7eGI4xdnfnT77DBtGz9vPC7045TCbsqRJzM/zD73//Z1/tlzUgfDcATMTvjxM/fTzwmAtA4fC+A6y2KvlwQwhCFpCzUHWhy2sfRLaDlBmQi2jI0s1IO2FK+lH6cswRzi+zZuEIJYlYQumcHz5YkMw1MecdEUSnDQfWemBm6b9F/crEY/IB56HGTTa8lKTxGu8nE83TjcFIm2OmakBtQgh1hgHpjtP4PmHYhRiDixDxzF01uj0hl6/1N6/a/4Ie2BPn46HkBmyNQp0A7bWqq7NlbjjBZKiDv8UAylBpWFh4PO5Y88FDcp2oJGpR44aC4ZyLB6kzSZzBN77PhbLCcKhA56EH4wHZe+3T22clews/rQfOcxIJdj4vKCIlj3VREm7jwHEMHKKjkB52Z+FlzmembHdVkhUZZi3McyKQLHDckc6DOjPRRywTX0WoSpilgjVQLyuL715fxdpcOB8P3D9+wtKBs7z3E9P5LjLZyXiOqeyMrTKcC/sebRqH8c88DmQVHo8PIBfehiHC4EYUusGhsoGzjInTSgwHFt8FZiXElwVIFkGgMoMP7QvjoVvqgofzOUIxaasQUjgLcz09EyqqUIXzPPGRH4jgwXiE8zpzMlEzfhmhAqrW4jOFAnLx8K8C1A1pGlDtrt9rfct63rOZjIv3+33fRwAodSXCDQl2UM1qgyKsIZ5pTaUOHVRIO8oM5yp1OAiYTBDoZDwvrFU4z4n7VCfkeMMxDnYZFMe7+2wozEk2h2MBorUM6w+VKMsNTgILVaYkr3DcPmk/OVaxmM4S8aoSjgaMHBUqr9TlXnMK8OQZ0YDD2tSyK1fyp1wJKqTOv9/t/Ve5fp4fPM6Jj8fcjJ3OS/veAExxhyjRrmS+87zuflQCs+mr5iy4AYwxkBn7/lYVJgMSVhbcE4d3XutYyTN9KS91XOBkqmjORUrgygUrw3Tun8yE+dgFNQCBTrjObiTjP1hAF4BKfoZZdeUFczEntYvW2DktClgCMnuPZrEhQYZSdwj5Hbob/uH3f/5+/GoNCPRiq1ito4pVXifcQs1GuJAPgznLwNQDyBrNhYiRphUGhEM8S1ZyWQYrHjDsOjAF8uEwC1QmzloXwlYJgIcJX5Pkp9TNnPODtCZzzFz48jjx6e1tt74yhTrAEGYqegwOV0eHhxuDEFDZhY/Biu9RnQiY4fAgKqODnPQeQ/NFs1SI6Flgcqgb9jIm+6Erkw/VUnHsMN2TAvTAVBkf5FwwUVEeU5zi4UCyw7CEQJxT9C0UrFjAwAMwFq/3x4m32xvcD6TpvsNgxu4XO2MBZGKt3KgFzDAicIzBgnoCKGDWiVwJh6OQQE4+4PPE/fGgHmVNWL1hwFBCUnItnCr+3QqwwNsR7KrUEg+ZBTz7d0I1TF05EJ2B9E0AQCpBYQxnkggA+QLkfuRqdK6ywEYqEdHMJ8Cm+jBN7l840f0uNEBQBwJTOraRLlrwmigVI0Oo33B2VGYmznMCACIKCRXg6mSsUreCPRbMBEGYxU6yuZMSIFRu5cKswu1wmA2UGcyByoX7Y+J28DlZSaQYYFLmYKGi31Jnw5UkMOnsrkdVwUr8aIg+kCegQ9pywmqxBVOM71avffvDVgk4TO1NJXlr8YwHAksAn6PEYihY+E6WSMUWEozugDDGnHORxhKBUudvCdEdMWAxkKOQHpgJLDiGORjXUonRlVAWiFyjHM3dL7goWtoXtbSHHQkHlJCdWcjJmHqqwOU+Txxu8EFKL7t/zAFGA7U2Lv2UEORMdkbCTOdJwiyQ0pV4NI0cP6MDvdb3rmwWTAM64I6r/efcQUvnIhN2YCku2+6SQIm5mHjGeNzxMsE4WwAiguD4SgRCIanglSgYHiqU3UxFiAog5Y0xWEyfC/Ao1GKhfBPtetX1+bwLm8Xiv+AE4C3hiq2p6+4cqTsjViyC+fu5v5PNpnjSlWYB3mcSdsVE6PLpen6+frEAYRy4KiD3C/Wvfmc4/9+KDUx7FvqyWgxVcX41WNm4mUtvQl7aEge+ynSAFO6TCHGMg+1bI190zoVycju7GDJVl5fMlwfYH7/cUR8Tv/lcSAR1FxZMJPV3ecW8XlexsFt1VbCsLRQz0ctWEhVemchipRnOBG+E436eG3WHklAergUEvwtzvp4bN77bL9yt1/qrq6t05mH2xF8kMtuF8P6Wn4SOVsWkLZcKQoclkFjIxV11rsQYB8KNLfxOzJaOqSocEbjdboD45tUcT1wt1eGOCMcdJ0pJFXB10pqWYGYICdzhxtK9WIqsxwf+8//5n/D73/0bhP9WyCLR5qxuJcvkQM9n7tdVUSRKAfdh7qKinwUGEyLb0eJKa7MGv4q51/qu9XWsxU7izVsfkTu4u3Fvsjm8WESawatQFrznVer0Xa8NoViNxqJK9707Yy60NjBzsr0/qCmJLPgS1xcs6AsuOmoSsVtggb4Wfro/cLu94xgHbsfA437iXiUazEUTuJ/U9x3hBKpge+839cFjoLDU1g8mjZZYCGSCh6nFPnsYZxdggcoJK+36p05gZhA0eK1vXs97Furub9MWI9XaikmeS+jKwpmJjxVhwwt0SyZPScrnLEdr27IKtVJdj6ur1x0NGoSQdlVGQHCb0qSoV4q9pEKzuHYl/KXPwvfrOOcwB6wMCWdSaYZHQhSrxKkOc1PMYgQifH8mBzUwzDILhlBnb13skeuIEkD7ZNTwZJLi1TnUa33r+pP8wPt8VOFpHZ3axCKF5OvvqwjpM9Cr1MUFzJretPNyvYa6hCrMU/u1uwwNfp9rYSWZO+GO9/c3oCh9wI6IndOQ7nXUAOC43d7wNoJ0w7oKqWbzVDHfbaxzpTrNMEw9o6T4OYZBz1Mb2RhyNV299Px1HYBdtFgnVmbXvobjl0zbfgUF6/riXe2cRpwAAKKFhJWQUtKsGJTojtKtHArC95GIckJbYbyDMwun6F0OoFaKW6nkPwtL2ow5TyZdEsuYFaIKWVM7jNcbt0/4n+INCbbDOoiwmKIochqQuNwI+LE6KeWN9oNiYgedMWpN5CR1JzNxu71JvMab6GZYG5lrsU5rYxJIu9pj2tUsbF6o3PesfiB6dWLlrvTNHfYM0WlfGwKWCRTpTo6+P6QrrTVhLu68EC56FiTvnXQfcMf72ycc44YCMCfbu93CfD8O0rpABOWIEGdaSMFKnDokH48H0pwFayUTKn1Ak/HD5/c3VE4cYTgiuMcBnHWhMhbc22tOPOYEMIhWApsu0Icvlj6TbxxQRVEikdQuqaCGsQP4qpm/fxUg9B86NPyiqFQCxpho0j8UkokWCmjxKi4aS6PD+8RRf1V1CLagPBdMFBOoUI4x8NvfEPDxGIBzv4wlEXmxo2GmgraIkpUZxjjw9vaO47hhZmIYkb/DgJmLYA0MtRbmXMBaWOcDYbf9TFpXSQXopxUnmbB2QdF7t0CdS/8MtgyZBRpEkTQ3dKfcrF779jvXc6w1iK7qDqsFbwpSO5bpDHTdW+YDrQkp3WtTxwG7eIYZE3sTrZtBUqAju3A0E8E2+shFiuptHFsb1GAOjW8uQLTR7C3czcVnyxtYMcbC6ohten05q40D7foVMWARKDOZ3lAvasnrju5egkV7J8HmQHjxmUfBkmCYAfpsLOzCru/7tb5t/Ul+sEGaDgbquELgDGRkwz9CVGyWjynuXAg/wSEFYzjkdgbmAQ0smvOcjiGzIr9ywO789v5yMzzuH/jDeWKMG42YnBSpOSfCPmGMA8egLgliJAW0B/s96zJDosZuERi1q/6lgrU2ZfJQsY8s3H9eiEEhuiXWquxYKKd0TFBc/sYC5KsbV32AdSXGhGuVARGo4EFUOUU9cnhQK4GVFCwCmNlUpEtUVSBicrsdODLw5f5BOkwlLBzudEaZsigrM8R42+hA4Wrfzk1ZgA5sIRlqZy1RvUJtqZQb0JnAGAG4Y82F9MB4u8FUdLBVddnpYhHFyEWHLatEdOGVk8mAbIUB6WD6xOv/aRciu14/fuFmvdbfuoSc9X0BnaY2PxkdPEp7s9BELRgL1ogAkq194qo0GKjuaJnL6SdRBqQPlLOomJl4LNKytv2uQV0DHYBoZIRJ46zcHbH742M/yF1or1yotTAA/PZ3v8fvfvdvMOcJiwPj9gYfB4v2LMyTAt7B8x/n48QywxoDKwu3W1MYC/NcSIkth7sEZiymq62wWSUTHMilT2AS27/Wj1qFRpsWVk54TcBlFdmIaNUuWLhfGc+4o5zuPZM8+Sp1cxtkKRY5nZxXnnispC3t22c5/DXPOeFFfVBaM5hKbX7uBwp0CyEu/adPn/E+Bj7OyYO0q2YdrKWDlsmkKIJQkY3aP99CR1LJ+CyfWCg3GBatsZGAJZVKxi5KrpPJ2roD84uSSiA94ONALhmgxKsD8sOWiVZdomZUwZwJENl6jC0AaVTpoZ9X6icdxFnqpNRVlC/9mUfQ6GXSRADGPGR4d1WSnQW5tp3zJD0VTAaXgEd0x9lJz2JxxGKBW5B7cWWjvX1CEPyk9yU2Ehwo0VgKnoWywuOcRJ6delM+T0uJKF97ZYmmzveLfqblNGc5UbkQGKLFdBH9Wj9qKa0GwLiW6sJ13th/mmsSCpHbeIPHmfp5nfHMaZmjwphnmhke58mOh/ZMrSmtlLokwXd6v9Fp7Z9/+oL7OTHnwn/+4weO2xvK21kOmKtwO264He3Mlrhn4jFbU2ooucq1kyZpZIlcLaUoMSwcN2OXZK21cxUWxND+fMqlslg06QxYdemV+OOlM6L2s/WX1q+gYHXVU6hiURDdw2zfdT4udKWwEHd39zmw5OTiAFaRl+mCq2gjlt3DImUr6AbhGBsNLAkriYg43m6fN6p8rok1TxAbcXh2y3bi/RjiPS+YJXGzJTZztfCWTjJzJo5wBsv5gN1EF6hErRK1uICUYLnIpUYman7A/NgVZ/OMubXlX7/vUMJaw7Q9qLtd90t35LX+2jJgf4lXy78TLiJmXfH3IUduMKl7Jpu7MQbGuNEN6qQQkaWky0iBLf7bGBju+Hg8mPh78M+VYFkXF5NObnNO7eeiqNwdNznCYRnOyY5brYX7xx2ZC58+/wZjHNwrRRrY2/tNaEbhdhxYGOqQ2H7410osEUJptdve82sjQZwZMlCT1sHRFARddznFxk2FcJeKa6PrBrz27HevjrX9vTNmUmTNvbf2Pbg6JSXbUaK3xwjMBaz5QM0Tw5iwNWULCXg4uchV1ETUROXETx9/RPoNx9tv0YXCPO84xoEMOvqg+jgu2uC6ozntbobA4vMjpDfM8KjCQ91Dl7YvVZyXPPLDihoNpXks9IGm2LQrEH+LdNe2Ow1bKl6AWpcwHrmklZLJRBZs0S2EmkJHYv38NrzW37CeE4ssJTU9UwC49kuV7D5ZfB5mMB8EBgV2zKTJwaqmd8idUE5nuyPi3YfoPcH7LayaxUi5qFy5AZ49W0HJVHMSSPFzJVGEbCtLXbYNZnd6AjfgdgRsyPZUNugEZ9W1K2qYzgX4AXV6LiS4v5Zt4tHfV5LWZeAz65ZILLjExVbWj8FrfeN63rPdBeb3bUgrJe3Yhec+96A8ghtbFNSGSVSUqFNmKjxIxSfIcTsI6syVmHPifCTOtRDjgGPA3fB2DAzZ878dAw+d0//07/4R98ni5jGXaIiO33x+x20MavbmxP088ZAIZTy5a5Y6dp3rlECCtZb0f9jsH3dHqltzzcfjM1OZl9Y52ziCQP9zp/3S0+hnni3hf7Z+tQsWX4iWdMOKjinjJvcAFibkLEskWD3ro1M73q629KSYsOQMNpX4iAIQhrfbJ7g77vc7gETEweJC3GgPv+hXHZDMicJBtLDxxj832UxaFwRqh4rOxUtzyjIq4Vh4u93UnVlIVQtW6vKo40EQRRsnDA66rLgqW89Aaqhg86xZyF1KPcv1Jw/Fa337ev72qq7gvoME1BmrpmmYxLhtX2uIMTCOY3OKbRIViAgMc1k9kkHpalOO4O/xIU9W/zocLys/CnWrLfecxcvmgYryl7L8/be//z3ebjc81qL7BYgGDyfH+GrhBxzUUJWsAM/FxG1EU3loY91BtzLZcrVGYGIf7tSBFAxXqzmM+9+RcmWxHaRfxIDvX7X/BcWaBSsm2GEFD1nkyibXC0yWVBD0fbRijD7eDu6HpsAg2IU24DDusbREhKHiDbMMfrzR9SqLvONFNNkWhw1Sd1J7j9+CBfi0pQOJh/V5fqAyMBcPsbe3N8Zv8ZuJGBYOf9JD9bNpRmQ7QUMSc2m3xnZMokc94MEDOzABSznJlRxo+kwgsllKjKv4vFzA2mt963rODxg2cicb4iWoU5doW/6CbcT4SaEEiJbUnRRikjpna2l/E4CxplyJjij/qW0lDQCrrmLUuzunm35pZxMyloNXqeBXAdu5S/HauliGtR20C9zqGCkBMrBjY62JXJr5lJ0B4aKhoYshObgV9UwQOIpam6fP48Re+cF3rq/2LKB8jxlqGIAREFubQLppTpKTSYDOIQXARTgGsHPLLm094ivtw3CDHwdug7o3ZOD9CDxOulveRnAPmOx1jwNzpfJdw7sZfrqTUZGZ+CSbfgI73EeuHOMxJxLA2025Jy6VVeupUCxAmBd0Uc8Nfw0Z11dUJdqib0fBJWBojxIA93YzSqAOUeEqbv7c+tUUrKslZRtRoNhKbXXRsQ6HEAs6U3lzI3X7cwlpFnpK2jG5xra7LEI1ilWlG9FbIIQwJAEudzQJLUwzQ1AoH9vWVJcNg29UpYsQ6GbkWvJzIafvGJ/w6e2TkGslkEl9iQeRm9QwFx+av2AJywcmTIF4ks/nN952a/FQbbSlUSETgtmOSa/141ZVuzywG8FD5UJaeSgyWZlrkZbhg9QAwmj4uGuwmvYxAwXwobkwqX96uu3KRs/aVrSEUuvwbBqA8JOfDwlsNC2fnqQpGO5xnnqmZPUrtCVh4hgTpjtul2OL67DrLiQRR7ZqU0V1yLWIHUkeuKsSh5GmQI1U8GAvYMB3wuz+N5npvdZfWR2wTWLahAO1pMERsmSGKsWiCriR2+tCdN3obbaEdC0Ab2rhZxUT+lHcK+OG22fDHx9JvUcVJgLEdxZyLrwJsS4s7pWDdqhrLdIChf6ei93duSAec8GK+o4hjVJ+3JFVFJ6nwYJ7bEHCTisVSHTNsmCnbjhF7s2JX15Pw+ToBsYEU7TZPFHLUXVDrYnCQPgA6kD5G9xeFKwftuoaxFaKXVZr25lzwJns9Bdt9tn9MmmHyG05VwvCSWcnkkuTjDBD5sQ5T3Xf1DOznhWSOMxo2DA/lDQFloqV0p6CMaEntXCJDkh703b4pNUqL8SHE9SZC7cymu6Ei9GRnMHkzr0PFvlTANXjPJGZOEYPSZQ4Xt/NponDydBYHIAcKjrSDlLWs00lXgXIj11dUIAgtLLmBvccBhvs3J4rVQ62Qxv/PtTdKmXgK1MypWA+a6R++zYUcPzmN+8wGB5rMtcoOsZN5benZmmwEyEFsVN/fByXk9o5Jx7n1Mw7xvrzPJVHGo4wFdcN0BCUCrsA0e6i81zA7sRftCt04oQC8x8D7dWbYgblHrxO3+YTVb/s3ParXbDcZK1IWwjQXq4ZdPLjzmSi5Wx5d1HRUxpd5f/Sw0VBMFCgkt/DUCu3rehKbgZ3OktwFkPqQI19YyBELcx269UOzgLZRaiqPDfH6oQf7QDAQ7mpZRFD9mvqmujLPFfCbTCYDNfLUrC7p6ivAo9+/l6WNg6eOyfdCSKv+kKN/FWAfOd63rP9UHQfPfvP9WCH8bBk5a92qbXzAzScksVpe7FDhW1XNqmkrzsrXfGagTajK3EbB0aIE/mEfHWka5F6qfMQOmTIY55bJDmnpqceN2mRlIgKv1jXNwD3wBgH8pwUjhNfFEWiE1UllYyXGrbkeo5JVuvBoQu2nZX4vJNWkFUIvPbs967nfWtq3zM5CwEeUFDvwpF2pCgDM/SD+2oVkHcl5KE9bFgWsDQcRavzcB5O5gR/Bhw+T/RgrHG8AYscdKsilwR90PBnHjnxOO/XAeSDSSLYtYA4yKQmHozloNgWgwXTCNucapQpQSM9qoqJXtkhmhfgKcDADcAhiiCINjft1ThlGv6GZQ7ggfJA+jssAvADE4HY6Ptrfcv6es+awJBAEy6Y8FCP5qDjFAoqnhsC5L8IpphmE9i+xxSz177/ZjQv60SpGmXVWQ2hsccIHMEX3zoNdbpXu7mJ7VCLRU1lYoo2fYRhLZrfQEXUXNS1BFwdN8bZ3VV/oqG4ce+mhm6WOa/HaOd7eJAy2DOoCptTn0k3TR8HCgfU9tmOb6/17eurnLadBm0LGvQzLCbMu08n1k7Wjhil+176eTZLpH2Q3TSGSUPZ1CkxEjr/tacp61XSBSXnzQGaG2e7MMr15I5WiTmL2hTlEHw+5MDWxYvoqsWKm5RcfQaHiDj73FfMtX6+9Anrylf6G9kOYn45eO7p6QJ1NWv92zsg3TKEbppbWzVSBEaRvfVdReWJOScsGFFi3JT4L5jTRapKszByaZCUiqt8wPxQsq5WPQoWh1pChpwcypYFHDiQwRu08mTSZkyWUp0UiHKwh80ZQLpYbWtU82DQPB+Y54ly4ChO0K48VV12AErcxhvgnYRic/r7cM75AdIkgqlkFU4NxprGgIo8JYAjE7k0o6EtUV/r29fznt1FQe+HKh1+lxC9aRpuIB9SbdA+JAEm6t02hw48UgXEGf0ZJck1aAtu8NuBEUNzHfJ6pnNhLgBLBTlYXFvSwaWyBxa1eQIpU7fjponn7LZcQmRe1wKLAorIm45Crv+6f5AWY4Fx3BARVMQIuYT7fh1yYZeQESgwxaYlpAoxsrNf63vXn+zbdhRqHYOK2i5uGxhpBzUA6l582QfOuRZWW4iiaNCxuF8boQoiPKhVVzFQhcMdM50FAAruQ88TkWg34H0M0E6U6K45wRwrZolmzv1cwFpzOyM1OGP7ECZanvOhLvCxhZCpQ3XbvzcglOogOydIlyWaj71yMumUxgBxNFAp5xffifBrffv6Kj+AOm9BR0sT4EhdqCjYOdX8pQVyQnO1npI/akMZh5odcDlXMfjeDuVDSCViCyOAoYHDsMQYk4CSh8TdfFbmoja0RO0qo2vWpoyLMjsTaOeuFIUPirfN3hD0qkSRv3PNlZA2IDQY1pwgj1/jDIYtVLG7iTl3HI5xwOMGDpVTl3yl9CEvsOd71td7VhpID7jENb3Hem1ilfFnt5W/NJ5VUF6pV5UxEWnVGhhbiZUTuQz3x2VGEx6bJRERdEoTXfqn+13zm/rHmybOTt6E7HxL1rqSQHg4Pr2/sXMoavea5FHw+DB4atAh+yHStxRO2f8OD7hRo2oATrF59oUjdten/yl9d6bP21+J2y8bJ/xNLljN+1pCfwuJUwecg5NLA/yA7mN70s/koRbFCboA7cfWPDGEzq554l3DzehkwQE/HpquuJacBBKIkBCHN3CuFLDgiBjgAEH+HUB8Z6HPqcM5grWgqXuxkhOssSb++HFnVZsU7yzNFlklznV13ZvaXER7PBPzPImKD+NUd2P7ds2TQ4qsbxAP9P5nJa0wXwjHj1ttHZu5KLKuQvk1BZw3o527SeuDROgp44C5FukExgE+lWsnQ0st96ni9+YOB6evdzcFZph50hkOENWJ17QmD7o0VwBK5JrAmhSqLaIHjzmRmXi/3YjcuiHkpMI5O6Ss8L/5nmEGUxHBxn9hzhPuRNT6O1hy7qBLS3eJ6LjS4vxeERwAVhqgWNCB+zoTf+hqv3UiW3TpCyfldMjms1BYqanQNnHAkXbS+Uct93OSKmpOc4KZiZzKlsI09IyxbBXpKj0Vd621h6KV5h+5cxYCMWp2CnOd7KqRpMfCAAa3gzHWZeqRRMBdhgu+QQElaeayXJcFccQ+bNtSOM1UlDtj+pRj3OB8hREhtPHEcCBXiU4TyHUqBiTKE2UHXpH2R65WI2FzzM1Jfd0ghVHr49oXPfCs6meFjDHx67/XA5CH2S5akEmXOFH5TLTWbafroflKLNi9SP+m0NxQRc1cZjM57DLYQGKEI22QorpO2epezAlXN6UyRdvpBLGFt6Xz3jGVe5QKl56Z0FomdqAdhJgGIg6YH9gOmuKNV7Vr02v9iFV7z3ZZUpvtUiC4vudcPdUlvSezOwblLAxbW2nYes2lKNP6tFUcapyJnZf2hLimUR9jYP3xj0zgW2tq2N2M+ZioMfYzxHl2C6FOybgN3AadY9eaBDlVBNQGXmw/r3MupBMcuo2QEVNuIKvUruT3pRx6qeJuA52maLV+tNgvyWaY/IX1VwuQPURFKOzq/Fu0K0hgW+aA88E5DnVKmrKFunhuJaQq+ch5LQQWCgs57/BtQ2r0/vaxNSfmA29vDh+BId5lAQghXDEG3IL8dhUmhbmFtASl6ZkfHhxkCPHfb6Q8rPODLbAyeiu/vanaXeRZS8BoINI3QpMsxYVOoYGrKO4pte/O84NORBIrs0viunG9ORK15t/yDL3Wn1lPTQEiW20jWtL7lNqs6O99IiDhKwo+DbNs20ZayF0Kl3vPkNuP2oBogSupzoU5J+0mhQgAYLvSedD1FOZMBikrCtdzLQ0CMmAywJlcfc7zARsDE4k4XN1EQyYHBaVO8vChw5SJJtQ6Po43FBzHGDjT2E1EB1klD8D+NeCoPX9Cz6BpyF3zvfW9vdb3r20P3YG8Sj1SdsbI1XXElk2S3pQWmDgBLyWARJF9HHA/tr7nnNRsuItiENT1uLrTea7dbu/hq8ATO6H4LzYDTd0YdT6ao27sk8T2kBedRr4bPcR15uLcHTOYMYnzceN/R+Ddg86Ei4XGkmap6QVNAQBkAey+s1gzFvPR11na2flAPiYQEwh2V17r+9azpXkpNvb+WalOlWjHHNI3cGge1/Nr7CJkd5FZiGamZhiQHw91ZNkBY/euu2orG/MJjBHqNPjWpgDCnAobVKJFNcOkK+5WkSqz4IydBRzoidCXs09VwjrGZ894AKocgcItAscInRvYKHHPUzPRWsoKyGODATCOA2jKebWVdS0ly6/1Q1ZhJ9dsfMgUI1oicJkOoTsfAKBZWAYoSWe+blYyI3KUXY5TnNHh+1x1D+YWKoy7o2wqggu2daYjWICgiyKxKCgn0JBic5ynus/Sx3VocxU0tp7LAEMJaD2az2iGT8fAEQQJUiMrYMxb2i2sO4KwZkXU7oAQdHAMDAAtdv+l8uNv6oCAug57aq+jEO3YACb3EcGZBA48se5325JcXRYdhoUoWkx6LdQCWg0BCcl58xlgYpAuNeQw0KJfWoySz2w6slno5EYbzEr8ZCWCcnXpIFUF2GBvNwjMIcag/V0YqpY6Hc3156EZ48BaJ2rSRvLz59+ghchrNf1l4QjDp7cD7SDUtm6AaAGCOCpfBciPW9QthAEpPieynRoYfGjHXDBbQoAXpgqQFpoNcYsTLQGU81V3XfWwGehONIJIbS1aqVpx9szwA4f17Az5xhsw5wMzmbhZt0pROHoKNsAZBhY6vEqWjeBhKiJ0mGm2DefnHAOwLKRcj4yCK4wIJBL3887ivS4TBGWXbDW77dkOhtq0LxYkBB66OHmtH7gamhJA0bQ94CJ+NII6DqOaoQ8l0TgZ046tv8uV7NTlhFVhjDeEtHWb7lWn6Ku2Z9GY7n8IGaZpgqxwUcROSgeoGy4/lNoFi6pyJWgG09wQgNSSWQWMACw2jWcEk0NzQ+LUeygh6L6xFYYt0nq0G8uedF/A1j+RoqUJ1AnAx6sC+ZFLRTO7uyyeJ0gj7cRljAPHcaPgHO3odHVjASY+kuruWTfssJE6Ct3fMQ5kaYihKabLbvpZY9kFM90O+79VWKPY3SvGXdfruBt1WNCEcxnYtIYPKiLabpU6AsBS3UWTfnSPFFA3Wp+x7VHbEjgrUe5ID9F5gU3x1fPG6em/zKd/rb9t7e6HwoWp6AWe0H5gU0AJCDUoQ5vka1IIO1VhwBGO4TRUOGVI403bF3ATsG6lXGdo9UgKduCGnKdcWmtD7enkPdy7/xtFU/HROY2AdgP3IMdS0MhklWEZ5+sh+uzgRTRACmgoeOl5pAUhZnUXhd9hn0ME2hV7Q/KCZMNhz0D7M+tXi9B3JaSb4jC2uctQ2Q5Tth/vtbO8hZSbhFkh86TFZGtvALVAHVm8SXORj9YC4NvtHR6aYg61yBIwEDVmu4y6EXLtGcjIqWs1PhHDErrAgNIUgIv77u6wMTYVoURPsUpgNYefVISIgBWHC1kmjgh4HBu1PovFxIjA8fm3DLzZnRkg15TVGoV7uxB5rW9epn81mMTQYDs5gRkKdJDa8kED0gqwAWNJjbOgTlpimeOtDDchxlAXL1EaHHklPVmkYD1O7d+ip7c7854+jpvOyH9YPPCwua7bI1jkiI/sJuQuOEV1I4wr1Wkh2pCojaj0MKDM4oDNOgEAs5zuHuIot5CedoR6np+zXjSFADqcVXjhErW91revr2ItaD+bCMwkmj/kUS+bHhQYx8LismuU1qMRZGQ7aCU+zhM9fG+tSd0HTF00Hk4WAy34SRg7aTun6rKYz9b9cWcxaqQQAoabTEOzgFoa5CbDA7rEqdsMoorzwULkFoEswwQQxUOUCaWogEUQgEYkjh5ku4CNJJeB6mRW4vwOciL8IEoH/ZyQeRgwXnTX71rPe5a3ywWIYGve2vEydH4zxsnCs+l2SsQMRRG4zt1zD+0jvXQMJjed+Btc9uSm85QAixsj13jKDVDMK9bSoLjkPqAbJbUmI1xzSIAB/gxZE0aDnBT9pGGo1n5CyLBMEAzgENhHIldiHBr4qqSzCzK6BmmorQXKe+immCYp04lKIDlHKl71x3ct++rXkpiXwMCqHRcTUKzoxFqGNCqa51oqcklHRl76kDcj9a4LyTOxgR9oHzRVuqowjPHyXJxD91hrX2nlQg/A7j0UbpstsVw6KnlqLnWVmf8qD6qewcPn4JwTywKzDG8FjEFh/P2cqHQcDnz58hPWmqQ3xpDOjhW6baewK362EUl3POXRhCds4c+uXy1Cb4cLN0caaUXQw1muJKRU+evBJyeOdCYeXhNeJwxsa7Z9nqobtHXYysnBbjlRoj0NGCx4GHmKHfrEYSa9hjcxNgCm60iKgKpOwG86xMBDXO15a7QvBtutiz78M4kcDivOHtmI8BVsqoAjAscxAB8wUPxzn18QWzCs79ILJX/8zNLUTSWoQnFe69vX81fYzT/m5t55PORvp8NA2T76gFBiJstI9vUL9hZA0OUHuSTKIo+dwFrpAQQgmlNOvr6PG2xoUrNAtKYRVJX2lG1KnhvYGq2UvTMuC10ouCnZTBVAaDGdKASmDob5II2F1TX5xrlUxByAXQlAhzEzAgzt+OWma5TlKZHuFmXmjhGv9e1rNwsAwWHyK7HBg0qxMuVi1fsU2GXBPighlzIAeMwHHh8/oeKG29snoArTHI9ViFAh3VjRfl6Kr6+t1ahs4aK+nHOizHAbbQUsA66iEYKLUlhV4JUwdnrbNgIqdAoxbjAr2OJ/zwRSvfBcdFGyYdsNydA6Eif/2pyInwTIXUpbvFEbqCGOdOlNYBkSQzrA1/rW9af5gRgFJcykwLPfnI57EE3KaJls4Rd9Q6+o3hmylvQZl36E76c9385Aiqf6Te2azgmuPWsqiuYepnYJxZteC+mLWJh3sd0zFJymNtVX+OSI1AWYujVQx8JMyR5MgnhXj7uTXeVF6jgnlMQZbVG3b7w7rOGyV7D9YctkbNCxt+zSRVRRH5lFK2jZEch1SvQ765+WDqKgji32pmxX01M6TugeHzFI8QKkLSVwmal9Hr67uM24MLCz52AcO0sCc+Oztc0RCspPlOdWC96BKhW4izIIy4TbTVrrxONceFTij3/4A40dPn3aQnIzAo+wptXy2YY1PNWdkf4e66vv4M+tv8nAf9OZ9gRSBvrLCaKAWjDxfisnMk9yfhfF5Z9ugbdBgeFaEzN5Qw3ivcPhxop/zgUEOZyoiVq1ky6KCbGrSIrOm2pyfQHs0CwWH6DzVjvIMOhALWDbTkeR9P42AJCPd3+JRPF0kCkCh3VrjC9I95qC14nD3xDh2zFhyXO8uhOy23pML18dkB+3qlvcmerONaJ0HR4ttM19IGAn4AbgvhY+394pckR3KWrzJOeifqQFg+aG4QcPsSB653HsBCgFEfYesKLbxObMdxu4+HphBVuJxQkzvC7vhLBFX0Q83kRFzHbbUnBYoN003DcKYxpiZLLfSxVSLpExYHs4nJlz4JKCYta6rARF13mtH7sarb/26pBbnsN80BgjT8bYObHMgHGgrZkTwClnv9txYBzvKA8COABgLBh8H6ZXF5irE3kJ3ktd5jkZY+UeGDEUR3kmlE7vNuuoTCx1JgaupNHLkSM43LXPFWgmA3oGA4Eeq4V1njjsoI0upOAS0nANF2TyeK4HKRLSQpkdPLZleVruQA7+72v9kMU8WQ5PVfBylBd1koO6jwQtSe8P7rcRBvdDTIPSJHRRYqlO2wPQmGBdg1RtDMUqGXuggE31aPQZQC7kpCsaTT6IKLO7JnGwXKnI+e8PJCtn0PNzVko7qCWaWYKmOC6zBdfzGiE2iHKVlC6kssj8MwNWivMPvZZAICWymzzmgMQlV7H1Wt+/BNS1kxOPX3XgGsRTDI4geEegfWGtiXJuiMoCLOTCxpktD1ATHJqRxZlMibk40BjBmXZLNrpMSFWgFAAVsJdTnwD3NTFryU5fxk/H+57F1R2aHgaebWDQRYKR1lpzYWHhjx8PDHzG26d3EMTie31+f9sdjmv4JfV67Pw5lsAevi6TBeYFu63AgukX4uxfp2Dte8UW1Jxzt5/cxRNTld5diVX88nlNbO8Pd7zfPmHYidtBbvmchTkL97MnpS7AaJnrtWDrgZmJFYazJgqG0YMAAWCEnmM+qqtFxButS9G+lCBK2JUSdSVc1K6xW69durjaaCtCAYKInnt3bUQd0+yTWYWaDyaVANY8sc4TFUISi8F3Pj4w7x8ohJw1HLVOXHzDX7ojr/WrVoNUgNCsQs7J/03O1ehhOl18JICJgg9S67ySTmvHDQuGP/70Bf/1yxe8HwO/fX/D+xE4IliMZjIgAU+tdtvPBXBZ2apndh10fZUSs1Ul0oVztCWwXrcpWGXceysXcomTb4G55tYzZRXmTNznwiMNMx33+50uSeYYNfAeBwbo0Kbdh6zctpI7AVYHD+D70v2DNAEmtC8qy/cuxf3duV11DZmqyu30EzEQcUNZ75ep2CVDAlAUm2visRaO44a3200xDvt+ujvioLKDzBUSE83ki18UIGbTaCI2aBPtONTk4RYaCjGUVJdFySLos8BO2xk9xIFksVlNc8WFdleSXuYDboVHFe4ffyCN4UiEH3qJ1h0AC7mtLBcr/X09R/BASAwK5mE4K16F83eunx9VV19ABWIlRhy4HQeO48BKUl3OtcgEqLEF4inK1VqLNKNagHSbZgQXS93dx+QwzPTUgDUTowGk/gnSG0ZN3FyTvxY9JLq7J859VutGhF4XC6HdGbRmJrb+SVOzQZrhVJ5Aygp1sE3rORdj83EDOJiuZ5MxlxgcOQgzvuYCC5HcZxPNekrnw3O/6LW+b12FBvOBAp1TW+cA09ysXHDdizBONf8yE+ukedIqYByfMDxgMRhT18JjFd5UC/dZ6gINczEfeZynuAz8GRNwk2spD+CejLiSGgOHc7eubs2pzq+GflbIAMkUI/WB7Sqw3YF1Tj03nCcCaBZYFVLx/VxsJBwlGpoB48mOv/WvsTvTzEsI9vLNfmmwxF+lYD1nSkuDqZqusTqRL1BPASLKC+RluirCCAphhhMx7WqfosATPQmhOWuVJ8KBYwiUXnesYtWVNYV2BXJdyRH5pAwi4UzYlhFJJBvBZMjVqGLfbG2w7nA0OqGW1zEO2ljmxDAhHXY5uiCXWrvcBJUTlrRFu42bUD2no0AVwolqz/XAcdxgNjolfaqCX+t71lWxtzNPwMOUaFMj5XY9PCtrIwTcR4HhBgxs7dGnI/Db9xv+yx/+iMfjgd+9/wbvtwGA1qVfHqKLANJd8BpctBh7vq4OAnZdr1inPGgyAQsWrS2+dd9UqFKL1WA7CIUJbTCJF6swNYMhEUgrTBu4rxOeJ2ycgLilpeeyO3jIc18Xmy2xRXjk/O8vmkH7dSZ+9/oq1hZRNRaXKqJhcBtwP2A2MJzC6vKAhUu3w4MpmzsOWkXPOZGyLYcRMX47DhzhOmAvK1IY9+XwHvx2pZlmYPGCUkIPEBXr7rgjUhpvsx2Dmegxyp3zvGYwVRIxthZUht4bwKb86gvJNyAJbAHX0EzrYkadHMjEgdatayM6bkBJ01JFsGHN9S98V/91r+c9y4SD98SDCjkzw7jd9uwioJB+TT0nQjt5P2bnFiwYIoyzZ4qDCEc4wci19nwDK+orof1It6wlMLMwRRVplVqEq3PnF0AJbOorcGFXz8RS4ki0fmameDEXTGf2ktFI5xdVxunp54mKAVuaB6Lixg2wMbZeKSwRzn09s/MAOb+x8kBPyH6tb1+1/8XVhgm9Vmt/++f0i9YJMUQ6jjg0DoKx2fw5KRdQCO6BPjvNmP8VEnPekUvApcBFGjuxQzH6zNV17aGFxS6DF5ANkqO2ds8pHFLeEFs2sGCab0OB+8rEwsIYAygNMgxqkcMdt9vb9R2pGtv0Kn1fS89gg0HdTWLO0U5hTQv+8+tvoGDVdhTSOUXRo/Mi+CUvuBULAfIz0OGpkYN5PvA4OVRnuCElrqJQRujqmhhBNG4+VY7uskgTncU1y4O24r43i3cLJFq0ftWOADeCgGkmflUA2mHIro3KK6cbQdyI+O0AtBQESXeJOFhFzw+K4EonuQItFEjNEiMKIwIx6MTFDa7K8WXD+wOXDhV3JfWyrdPhsRGqTJgPjOEa4GNEHDQXAVU4Bjnj/zgCP/30B3atNKiq6QcUe5NqCLmxmIoC67BUzwVHXyFTzELbQZY6gaQwZNk+BNvkId3J33Q6qtFxRQYUQn9Z9MoswQ7UG3AbBx3nUAiQSgVRJwyFXOe+rubchyWsJmQhtyk8pKpB/O7X+lGrOcahYVClTq3tEdAMWW15a4Jzygd/3x1uBzAXPh53WATcaeloipPefOGvcOsk/cOot4s+APMa8tdorQGa3txqDaiI6OnVtg811wFIUEeizSK6PUy21HrRdn8BROkxYC3+fjlIp11JVzsfcB+ICHx8fNnGC46lOScG1FRnSF8dOcQAFmK89u2PWsxJTNBqyqGNLmxNMc01NQekheaTyYoAlXCyJTgfxumU6SxEbh6IZG4x243yCQhJzcvZKPOOl0zeei8TgPJtctBicIDPBLse0qZI5+dy/As11hwXUMjBgqQi9rPZonkAuN3ecGZpnk3P9DEctxvzFnThvBBObQidMCWADxcYMVEvivYPXWRESLPT+0EhsbIUl0RLdv7e1vvIAOQYdJii/q3Uv7oGdnMuEjjGoXiOtjlNJePtcA3QdNujJSxsR2dTlwbFvJXTxnTumyHKAE9Eg085sc4Fv30CoOeg+JqkHrLrNnCw2MVluASZKzlaEsEuUGcw3TXqX29ORwMRhT0CwAU+/Yzu8dX61S5YZo4xDjzOBza3zOg8BRBdaBFvuMk6jy2fj5O6i9twzDPxdjuQeeK//uEPTMTjkHiLThan3KuIHA893E7v4mBbZCI4KVQEkO4isDnjchcyRIuJwY3UIjXXF7k5+Y3YdEAUKjKTqK875y30pMxzdVHhFNMFheSz6M6CdWdrt4iKzLXI50+2j99u7yg4HtUbSeK4P2lsv9bfsp73LNFZ50yP4rC1AVeXgQ/RuUjRO2QC0K5OpgfcK/GHL1/gSPzm0yfA6Kt9zom6s0NGZDfl5y0tiFDeTs6a6uVqja7qBI+HZerer8ztfFVoLqfKlbZyNHZ1yiSwNKGPBUTV7sA0HfBwhw3qOLAGUBNnljQgkEUw0eYTULJJVCTkXJNrSbTL1zc0pQGy1Xyt711mF7rURa2rAO1W+kq6s7HLwT87pY2bKCxoBoIZbADDDs4DGQeHtJrjzNzUp7kkEq8S+iXrRxUZpa5Dx87mwVcRPYRdjjE6cXai152bjpn9320qycnCchR0bE0ccLm8hBG18xjAOqmEEhJYySI51cHkKsBUxBSwFPwrSaE9vFBzYs2Fcbzhtb5vXZx57o25aiffXiymIw0pQIXn7sJcPcmG+9ndEcPhceDt7R0G4Mv9jgDNNVJ7kphe7eSReGBufcfhNCRYBriEt2ctUZoYa03wz4IhIA2o2U64AAKR6VBHxeTqpTEEWy9VIBk9lIZpuCIKc52cS+aBqbxkKRl7j8GCWvlRFueEbFphLuU8RKQ9OZh2ZiFenoPftQTibwAnIoB57o6Hq43BeuRyLuuBma0vEt8HQ1Pszj03g3kuC9jaGqBHJjwXbE1kTgLWMeg2GAO2TXLa0EPuWCpu2hGknSm7SxP6NQrKmaURXBOPjw+8HW+4wfkaohkOFU9RgfPjAfZC+DwcwWKIxklyaUs+s6Xr4/PXHUQ1BBx46tdc7I6nDvqfW7/aBYs8OdmQmqFMPEnYrnJYTLBL4Ul+5CrSSR5zYp4nW+zpCH9D+cKsgoGzQyo5fZeaMorJOV7+kFWtU4RoBkdgO2dliXYiJ6ksbIxZiHN1C0nIX1pXct2+57wEdkzsSahWFCvKDpL2agXYxWV2dWDMiQavXKRHaFJ7zknqgRsOx+UbLg5oVcoqkkHntb59/XzPFrDdxhK+hX5LRXWMg10JIWQrCy7nHajDhfnAP//zB1CJ9/d3FQqFnAuFa3hQJ2fWQwqBK5jhst4zIW/YidnVb2v634UZtP1ed/LYaYmtWTfpMlg6Tawn6zse3pDYfHgnYwQPevhWH75hhqV2cB+2Ta3JmnpexI1umz/rzuNrfe/q4qMdByOE1BJuwjWg0LZuKS324VEQjUluhbebK2bZnhTd79OdtP5fRsUe7gcxSXLbOcL7GWk9U/GwbMSwkpPHG2lW97sPdtUVu03f7XwKjrGRaBZZ7Sa0dLBJiOyheMkXLWAXKlakTjoAO6RBSBUrMkLh0E/I9CRe2/YHrAY3u2BdcprqTpQn8MgFq1CesGA5pbe9itpcoiUZgUVHMTZbC7mVaHV8rO40dCeZ+7GcxYB63+p2UdLedO2LMtpxtnaCaYBmIDksO0Sncp7e25r+0KyOlPEMsN/X41CO4Ci5sLkFwgLjuD2BDVcHhpQWFtDmQep3FdwOjONNg+1eFKzvWV/nB20D/WRKpJ+yjk9XTSqqnvI/6Y1nFc4EdU0FjEM241mi7bUrGgXongmzwZw24opt1tIEHcoqis2qt/C+kAba95R2tC60PxcB8Xku3HHCjIAnzDgqoplJotlmcoZIOhlHU8CSaVh4qoMHM+qwnkqNvgbfjrLdHqdjV+5n8c+vX92DNr2wqa2yh+NkintePAC8OcH6R1Zga53445ef8P72hmMQWaWYxmE21DIFqgZifYg3xt8cIXtb9nd6PzA4KKhVKkjh4tuziJCTqgHlotSAIscWINHtYGmj0OaSLS61pWrRGk/JJK0kWbX2gK62QFsSvPu4cUqxkDdOsLQrYZWOhRsAnLpqv+wY8Fp/+2JBySSlciH1cHPiKbsjPWm3hWKVsttbiXDH+6GhPbkwzzt6KBTZew5U7A5cn8h86OqyqVUk6yRrp31dhJiq51qoCrSQvazTMx2k28YSu0DKWuA8Bwoqs51k7DrcGLSUchoFmpzOSlcra6vsXChnC8aw4CbBLzRgDLYd3bJ82/e91o9bfTCOCGRO5GQrn5QkHRqgI0q3w8Mdt2C3uK1uo65WeO+XRqR2gXyVCXJ4EcI2Hxegw4va6Gyjf3von/bWKhbkEM2r3V0y5DiUkKXo1edtwbqZXQLIfI6pnT4yMXN/2qfJZ9QqMcah4V7qXJr0XxIe53wg1x0VAxCl7RVpf9zq+8dQwf16ivr0dgy5XC3kfMBqIdNoH2ptCpP4WIXb26fdqdh7NKln62LHVCxUJru0AnZ6ltEmfre7YSW2bfXGhYrUQpeZQtVTMUPAufjBcM3Xqf36HdNrTmQBZ/VA5LYu57/a+jli4DbG3usm1ywlJtz3DUAEE9SCXOqaneGGWq9Y+6OWqZvWusaOSWrkSjBOkJrjJ1jQGgBU4jxPTFdyD9JE9x5U0cEOwgLWA5A4O2KIUuuSKlw7q/VwsFTIvc7vDsi9N9u0owH0JW40gUVHODUmj0chfQiY0uu0+yHA+Xklql/SdTDHoc44jSEc4JwoIw2QBj61O0n8PpXbqJJnXr1Tnz+7fr0LFhjI56IT1lqLMz3McLgs5orCyVk944KvkGDl6EG3qfv5wJAgEmAwmGX6PQlwJQZa4GC0zc+UNzibqrSAXIsWoplNU3cNROENn91i7TCSC22UEu5yQCDVpfLEKofFgUucVtulBVWoRQvglp0QxRG5S1S1UO23kHTnMqeeZfEzVdLX/rI66+nAr2Pxe9bznu1Bf0TeUnbM3a1iF8ohGpN+jgWDk58+iEIP/ySEJDHPB4vjKhXQKg70Hil0GdGWkUKCs2iVChXK2YK0pgCQMqVfKjrSDYu5Y+1iyoDN/+xEk8iuCu9kYRIOZBIN3wUR+BmzuyxGobIZaTmzCpGFtR7kqILP06khXwUgF20tbdx2y/i1vm99XQ4wgDvIeU83YE12SNGgC/es5YLlwhFBFxYPHQQ6YPTfzL10UKhAKXWpTTz0BaAmX/+caxuDLxiGsdAkldR1CCbtdJXkWy6sJjCazBiEhq8ypCesZ9JU0VnUApmGxOIBX+S7m3GWzgjG0MxJRyM4HWBA9y4v2VhbO7VpsrZJXJ9T/8ukGNGblTqD1/r2JZBY3TLRmCt1ziaH87694zhuCNPA1JWY5x1pQ9Rl8tFTVD+Lg7E3DCkr8lwnHgvq7jnNBXroMECxrRMYoR00bW2aKlIt3DZcRfPVrgBwPXcpAXhrnohC6++BOtcsFlYBUmeRiXU+MHPgNkLUGf6zAJ050omgQRzmRVV0+Hok4EW9C9xRNrajUCj/oOb1pVv6nvVVTquzsgG1p2bH1vn0FO+EOlQ67+cisGyrGJPc2aE6T8iQXBRmvs9aAuu97WagopcT1Z9saNBDtVvd19bpPVD7MEoDFnokhYAeWZiPCLwFhfHIQs6TxckhcD0vCYLbNfk810TOwmMa8kjcgmqTSomu2uFq+bYV7g6SedvxQoyLryntf2n9ahesflDaR7sHmlBA0zQUHkRrSYTdjZpKrHliOC3qRtCRhV0OWuUGVEn5gI831HImUTGw44X14SyBobwqDDzouHlclV2jzz0jki14RiFuEbOe54z9HnwF/ndEUAxUnOwYGynvAUl9A+XEoZtPcWVfA904TLZpCBcfld8jkzn+9V9uVr3Wr1lf7dlskdnVDTCw1c80SXtHwT1kqzvcEGqTmxnezDDPE+dU4QxZlvZcjacCpAXaKHYF4diJXCPMBiWBoow0YdAiYOUXz7g3ZWEjJOGNlFx+8SZHOAYvcfidBS5QOsB6gxsPsu7mQVx8BTfTs5rrAZO2w9R2rqrNTTYU3m5vgA9OIH6t71pX3+xCqAyMO34EDxBXzKxFlC64P98xYINJWO+9PlwajTV1nI1V7Ha/Mh14BhXJRU0fE8odwRXvuNcsNHV9F7FEmM0GD9xGv9DUgKvLsucnoakF3bljR633etP/sPcedgePz2vgAGBFaiGts5ue0J9JmisHMDgTxMdAwOnG+HIU+q5V+19cKV3k4SGzg4lj8Lx3FDICU0Biz964HQeOcbDDsRZ8DFFVHRay34VzWrOKaffCWgJfPGR0YKjulMFk/ckixBGanSSXKmsDnSeUVujKFXvxVdfQQNaCFed+tWHNgCPrsXMNsjRM9Cl140S7huaYkI9PdJtzwYodbOe+Zp7D9+y5KmMM3Py1Z793/WlO2/ksswE3GsEQJOnzXLFIAGZ3wJpOys6ripQ1EZU01wDQ5YzFgbKlXPkCBPlvsYY69FftYoNNj8TW0qHphASl8rm7h6aCE/xvdy5Hz17qQjYIgJfh7SAtqw15+nkOu/J3c8XjCAJGpU5Nd9rdpX81PVvMZZNCxd3Z+3Prb3LBqmTRga6coCJANyi7ODBXG10H4qTGYYwhdGOoI5JwtOq+0eEeSjig5hdcQlgies0574GHkBOVbk4lepRafymk7AnJqKZdAYBusF6Hrj8BaLCVK2C5nJGQi1Zl5Wjle79WNDVst6Q6EQy4sz3bVSosYVvQvnBxQdt28rV+xKLTypWIhTNYuGFrKErwAu8TXbDYSiU6B+M9izCUeMxmQKC2g0Q7upD6AQCXm1onf67DrPUiocR/FeDee9Y2Peo6Si9aYVuSOloI1jaSxuJYOB6nBDMxWwIvWLhceg3TLJ8emrmDjZUCXsIRElIeePOBuQoU+LJIGxEKcq9N+yNXqaDlvkkdAAM9G6APUJOdJz3iRUVdTbUD2s0n+mDoXnilDtPU+5iAmsvtpH+vkcENzsjV6plSmMmuYtubFgohbV6FuMDVls59eENJY+89293g1h1Rs0ImMQV25OUz+YvL6apNU3f9xmkKfBag/Wkoi10YxS/xAl7rG5fiW3WH1kVXJcW6acgRY1uPuhngzAFqqEvViO52jwmyIDbQ1w49Kkh2XCT1pMxk30tWA1ydRCgd7L0L23vQ0SAqrz2cneHNetBeco89V8ycucVRAyb7Xz6HXWQFOxqNw6IF+iVYqLaAHoAo7INuWCb3Q7nheSUs/DU88weutoGGCpANeKTilD3V12JQNOqftTaIByOLgY59E45EjCtOntLGHYPW5w14i9MA3+9TaIvnti7vWNyuhSEabhbYadOcJsbW2DbCpBOqQPJB2jlk5QuTep15yHDZsYu9wcGu2EBtQe6J/NLUQGDG0hTf6NiuL02XiykW0l9af7UAeXZmgV36CJjj5gdQhVkSaSvpHo7tdIJiW/443inobfvEANzeyEVXItaJXJkL+NIkc1VTM+lS1a3SDFFUNDyL3DMefqmf8S46wNdky21t95REoRx0SHLHbfDL3W4Equdo7Re6qUTAL4Skb4WSRQWZmWojGzspkROt6DTdMAbr5lP7Ezf7tb519Z41vyw+PQJIJvedAbXNrFnIBk9TcT1QxjZjC80LgfJCltOlaj2oLZKmZCZwGFDGLkTRbgWrWogIpHE6c6dh5Q41AZ+CTCd/eEoku1OIhpcZ7PbeVgEut6SEnpui4LInCUN7OldiJnALfnbzUDBNlBX8MFgdOkRvdAoph3sJJSe1p9Aagdeh+L2rE2gm/KRgdEmw3UiKBhmGyzEqZJBRIDVudjGwk3vui8ZNt+hQvLkE3Yr42opi1okYM/rehn2/bSdZtS1NSxo2CB275iVx7lFPdt8lR3G7rmpOtVH8CBZWsKCLEgzZLi4g9cuEsFdSP3DOE+GOYxzItfA4F8KSpgvWcx8Ca53SdhrKDli89u33rOc9y99QfiAEdxg1Cx/3B8YIzCzpxg6sAs4sjC5MpeXMlTCZt5xzMTaHhmNan9+5E58E8wSFUZ7WuiCaHdgFOtZFm+3uXgM4/fMtmmXnzHfixj3biqVOHqUlMoOtE+dajI9Jm+geztYAWGYP6gS1HG6kTVrrQdQ56oq/mFxyBkVu/etrffvinn0yAPABjn+UOcGToVGbZVhndqXzLjU7TPFPUDvu9y/ITNxut51DMMzyJ0awCztFleL5bFtolzs+qiQWYIqn9wHI1qAFurFLqK6yG2ArLxto5T005kw9m/z81GY/DwwsfS+XyN2UhzMP5uyRcnYdzR2nqLfMXwoe2O6iu7DY9O8/v/4mQqHLnSEk3xCoTyeIVpGjFfLt905BLLsjFODwADFZJRKrgqo5PHUQnurCXVIt/cYqbAqKiGdC0AyQC1GacLCuVL0LCVPgFPqgA3zJ1jJJTt7vyZvEPyPligVkT8nMLKwWMynYVXLKZYpfP1w8ueSwGYeSDaun7/bJdeG1vnsRyfKL52hyp6o+QtgOLXU/gBaAKVlH4aED0fT3q1LoguPogVoG/f0u1O06naG3s6bhtfbkEvC2Ha41YvekBxnSV8HY0Wt6YXc1OiCisJO8pr3MAmBE7NJKiYGSuhKCqBbtXAxa5gMhfdacaz9njahspMQZkGnw8DoYv3d1MgRcHQAOkJR9qRKe6+dt/7PbsFVwLEQtHh6pmtR034teWffHgx0+tys2F92uurnRNAHXIbNja2lgrJKynvlRKJk7dDEti2ewW5iNIldq1kFzmqFZUrXb9eyYSLuHqWFedKxzxBOFYeGciZyJiURp/oSJ7gJRs45w2JxYq7DyhKl4j1dC913rec82K4Lsh8Vuh5sAn058YiOvuRIFnpEjFiwTQJLJ6oZa0nTEEzgjNx4TYFfGuPcM04hkvZ+N7rR1RtHN2p2IgnVz7wTbiZj+22XkIO1p79mFVufZRUeR1ujplfhciHpuboDTZWimKLQRnK2WAj63Ayd1A/PxQNUdR5g6SK89+z3rec+yOyB0XwXFdmUD0KVH/z13R6CBQUM36yJoAPL57cBjUrtRLmMOmd9E55Ia1lldiEIgIUqjHxR3o6+0lCv43q+7+6C8JXTuhzly0LAhnzRSwPV3Z88OU37SeS0a4GnYyq5zhdBkX6+eK50ZfP5STUvmDf13zbBdXv/S+vUFiL4wovQU17TwRncTmzsJ6JDig/xxf2DOO97GwO04ftbaomf2TA0bNFNyTiRhJQDZ0dUe8U4Ez8XJzMrd8WDiqDcoCr7b53sXNY2Coa+DD3dZYi0iH+2G2zaR1ehko+QgBeYu+7VlHNjm4N+vWhRNLg1nDEd4AZaCEcmlyzURIWHlq/r4oWsfTEbEyazRBRnJ2WYrAo1z2dPB0SiADlbu64mVE8P77/KdrNa+fdcsB7bQG9K6Hkzuty4ICuzWkA5Iasza783XJPf46bkBUUPbbhbtAMNEbKmIZtxyGifUVXR51r6uUlLZ6HDEELrDGHMWBXfe/uCLCcZZaj2/nKN/7Opi1QdyTqz5wBFxdZt6DynB6lgGJLwWp4sX0WdSBQ6smhsUWVn49P5J1Fbuo1yzmS9Ayamqiwihx4Jx0bbrZoYYXUhf17EdewD0AcoOBvdbzkkXr+wiBorXqY6yafYIi5Bz8nkbxxD9CjsZrVzItTBCegD3reHroxLSrcRRmCct4QuFjBef/ketvu/uBkwZCfgB7MLZkYRKlWiJlWCO++NErXO7WZnmX8x+4Sx4rWvSeSZ6ujTBRSblVdlkPL2t3j9T5/eVfpaKXROI0+hyipYI48BDFg6+tXoNuJIidZmXlK6NU8ulNakEumDuM6RUQFUX9vzMva8z2dE7BtHdx+OOw5NCe02qfq0fsy5gG7sTFipseU7qPi12oHKf67xPcy4MBCwCxxgEOsypk84TU+ckZGzTEVEPy6ZaXUBSbZfCa28/gZpQPlGtaVWXRtuaw7gTwwY8Aud5x5oTaUMgvyvHSNFSJWSHsiDJAXpieqhB0FqUua/NgGzAy1RoCWTfjQPb//6ltPavu2DpS19SwLcgBvYseGEw2Q83GgG+2j65EojcHxBFX2TkAmrhzMItBuhZDKJha+GxqM1A0X2LYi4AcGQ5LE2e8RR3FXtTWGtizRNHjKszo+DRbhk9BTttYVVSCF8JBF1VoA4KymArhRzTrYLfD7sZcyUrPySyTk5gl9DdXVxqWbfmfOAxJyJuoGYvOcSxZIH2Qji+az3v9XZmaYcVR9PtxOdNuUEVC4vUwddOKW7UOWQXD13srkQg0Zl35cRlTMBn0702cuAdSIpdjItOIBcitVdp4CBTAjjpXPlkeX1h5KxI+O6g1Z8CUS3MyechzYA4gENTsM02ncHV7l9ZuJ+nxI0GDLaO+Tl6HkMKqetBW9cBugC8TsXvXz+P0dVdXQRgg9xemNAv6u2EsTBpczqWnAnMnKg58cd7wuOGMQis8I0cxzHEv68d40vFsFfK6tPgsoIEsJG/Qmq4KzuDgYIZqSWOQmqPuLp6VUVkWJ/SUDt5hA62Tv6eB4RWLljGHmo7J6dowwdBrlrIdcKxANm9OqhNWurUrFyYCempDI8a29VrrbwO99f6pvVVrAV2h8BQpJsoP8hMauZkYlM5MUHKs5kjzVFOW2QCiwSCUkYBDej0YLYGXErAiAkMfJzk3xcAj4FhZB0s2fwuIcK0t2bBYC6aY//snHtezJlibNxuzZK5+hpNcU2CQFjMYSDdRtXE4Q6PyxRhD3BOxXUkVhIVX+tJC6CZZwXAbp9hWMDQwGV77dnvWX+SH+gMJp30AnSGO46QNkLOr2QUkOqfa2HNkwVL5o5r4Q7k5OgFYBvVVJewirMmfR6BGeUKy2Cig83JvQw4jRmA/fdNIE0VNuthZcFqao8QALJx4FHMhUu02N3Z4Mupc0mQMgBYMsbPTPgi6Hk+Pz8W8Eq8HQc4jU8DcIs/R5CWxQj0+ccvdJr/ugsW7xQqi/a75ymE/7I93OYrjRqD/PI5+UXdjhssTxxjXGgZJIz1QCUwULsdxgNLTR91QgpsUVkM3MYhpIM1lhkFXeEUaaVxDkd7vW+KwK4qmYSSpsWBRlVACrXrAW385/JLenYpAHjT3m83TFGxmnuKnIAlxvBLxLZYaBmS+oFK+HhHxBvGccAsuMFf67tW7X/prhXnWRzh2+HKFlHTqtwULMhhJUHLWU79Nom3mdAkSiJHXNxHcZdbsNVoFi+mKSaG7cLVdADjn4ecqjoYmDkTrZ2kUexmWLsjU7qepmJR0FlXobImD8Zw3G43jBF4u93YJdEzFinkz2i7yyGcPIhXz0bp6erGaeotZualdu/Q8Nq237+4b9UzEEiSRVomytR1a3chxq5zAcvpINg4lptjJnB/TKx0LIPEvPyzWzjtpQ2gy0vvaxYZfUBX5b6vTRck44WW58MBOIuPyqYGyBFlxHZrIyLc19iidtu0hwu2anE9B2SaOw43iYHZJa8lbn4ByImoxWR1SMekQj506D2m4aePD3z89EVJHRA+EH7APF879zvXV7G2sNHeEQ5NkFQjQNQqneVzJnywGJwdI+FA+AY5CoawhTMT2C5XijlKaDopo3ZEhU0ttC0oB1AasE7u9WqfrCX0ljEvYLuxZ9XUKpqRlAEzT+UYLcy160Gxi1bD8qS72uzsBa5cAtYUcNFn01AJxBE4YmzHxqkEN6u1AP4Ud+ff5+b+K13PcRaQde1mEBgifLMG+hwvpxW6pwptqLAIxpymdZsVxnAYBsKByMSaE9DQ09bUZYlqX+BrdI5Yhan7vtZEmMtgxPZzhucCAhADyTar6IqnzF3DgwWE8fO5daeS09BbX838egBeOJ6YGVPdQKY5J+IwFkal/FzF2oJtNtTuslgX43/5fvw6CpbaPaST0C6vuWNVbFU5fCd1dJ7QIReOPA7c/DPCFixPFCjS2lNxXda57Vmvw6hkFbl5Zz5wDAl8isMM+YDSY3ypUAhRC9yAtxFqt0qvUZ3scQcMJWTnWjvwsaiSpgPd7gpZtmlSJEwIC6lUmyu3FmCcTQw4wgcqQe9yLFhNToofg/8Ep5xWGXzzR1/rRywTynsE92o4W6ypTgZgsAj4OOA+cKo719OVmWD5ToxMqH+jxpknkzPgqdC9+MYEp5n4QQ5BQBfqnNPB7ZhCRAAPDhJaLewS6scIIy7+UwByc6S75kRwrzogLqvQx6eiqO1NtzeFbHvDr5YphEoTveCzHyMwhGgaCs986BeX/sev7gz08FN2xGyDHCmEn3zlwgGDj0D5wHEYzA/M+wT8gMUQ4ELHrE6IiMqurYszA4bMBWYuIcsaugnNLJinLKrl4qO/WypeCzwnCoZqkrSSsudFUzZHLtEhxXF1FIa63CEnlkBJMJ6oPGkYoYfMxyHRKIEnK+Bm1GdFBNZKfCRwPx9E5j5xurYXVPy/1o9YjB3AES5b2QvtbRE4i8MBO3wXHkvCbABbAL5jpuZ7tSWogdtk2+aq+GD+tpA5sSWhWMxDCsg8WdRaC8zZGefev5BkUg4Zq+nC2d1gJobbJQncp6SjSnMn45ruhBcuN6K2ag+wK53VfoU7q4Sb4ThIffVM5JL+EBubovbUX3NAftTKZAxFrt31d1nMt70tY+xC85w2pcg5KDbEcMmcJPOoGPAYKEzNA2MS3rPsfBccUB5AJkJO5X8C8Y/j0OwYxWtV9P1soUrsmc4VNCw7mQt3XuoRWOoYttuXG+TuShbHSjF2zLjRuphI0s3cgTFCeXGxEDY2ItyNLI++xqd8Y3f9/sL66xQsIbEuZMsM5MRloQZTL6sBR+FcE4/HB0Y44mChEAYcI+DxDs87znnizMSIITpIJ1gSyhido6gfURFiQqjjoO7DHZ5MKK9WlO0JqTybxOPru5cOeLuqEJ0o6CYYUN7OAdhBcyPYVnCJbhNEFKsKfgQ8r1Z+1SUocrWsxnGg5OISSBxjIOKAjxvMB9IOFVRAx9TX+r4lQALugTEOHGPgFBXDDKImBR8Yp82sh7MTIMFUZtJYIFs8q4RNSdXm+8YgjUDJGMGKdp0y/nqjY9iHcia9wps3H9r7gGgwctNyM6RDLf9SELJ9oNOlQ8+LBcwLFh0kSEt4uy2MRZcVGIBFg4gFHqgpZATiUB/y4e+EcNtT8zRXYbNkKR0vD6wfsH4ea+mWdj617IG5aidYO2aCOrkRgSrp02zAfeGosR0Ce35AVWt9ei/qUEXBrM0YoANr4nzQ3SeCMWwlEAeBlW7lmcrwqsSaS5QG7AGfw7HpLyGBODnWRB9TGVYp8XTvuTQAkPBw6T4WVkmQbkHgSte+YLAyJnhKJK1EGRgHPIGJE5kLI2S+8Nq437VM/2KsNYwxSE0BKSGZU+Jz3wkU94AMY57BjHZAE4ASznt5HKR+rjVZcMI03I+xaE0mTktmMDE0Xb2w9+FKg424QCEPCuF1nrPb5wg/UEKFTbGb18PrXWsh4vrw1zMr7rvFHtB5ZgFyUEz4NStBPKszF503TTQ19PwxdRERAjufOiGmEQav9c3rOc4+N7Iapu9Sd64JWxP3k1re0M+UisWIQaMNsMg856IjYHcZAFCvFzsv7O7LSnWON+C921uXKN4dRwx4XC5b3V1D5x5ohkbrnLsYv3JVoaAanh2Ain7YpUmF0dZ/aQBsa7D7y5kFHDKfAkhLLAB//PKBT7cDN0kcXOwMdoiez5e/vP4qBevqNNr2+u0qqN1IjkFxaqaTQ66AwM8mbhn08z6Y6IjCUgnQRnTs99zYgDuRLwtYUFhT3jYtwHYMMOMQnxRSresFupBrZb9ElcEN2AFUjRpANqQtnm9aA7mCLmF953DkRw9NeIU0Hmy18jtoC9gwfi+PL3/A59/9lsmAFa7OrYlyUftBeK3vWPoKzQ1jHFjjICogofU2TEA3w/TfVnxwErw/KiJyro249YFZnVBpQ1wYHfRafXiZkjTsIuY6aK49akL2CH/UJfrF1fC49iX3MtBc5BY48u8Md6AWEnS3ut/vfHbj2EjfTEFqIPq3knxqoHAbB7pHTCMaZRlIGUDkRvjc8fKm/xdYV4FQXyXj3XEy5+C9dt2ZZdJpNNJLZCrr2n9APxpdzLaORFWJF6LkZlSJcyUsNMW6/dydaG9EwGDs4gm1WdLGrUysR3fegLaE7tjOc0OIopy4UDpT+kDuDo3Om62HwlCH3fSsdpdcJK8qzHniRHe9RU2LQFRrrjRVe7zcE75n/Ul+0MlTJffJ4n1sChFt7wGYIYQ0GxxTxQIdB0mJMne8jYE9rLUuypzvnaR/BAqFd8y9uoeNAF/zw/j+7povAyhpbJF3XECjNi07hix81lpblI5L8r7zlcza6PPJKhxR7KCEzp0sUsBXavibPp+PC5Dt/KQjaxVzJH/F2u9az3s2uosRbaZ0dRd6QOGUyVBqGCr3k+MoOqFxMDX3eKoDIUTlYtvAthNhu/91WWHo5opjHAf2jCUxg1pvaX31XcDov5foVVm2Z+0AQM/mKr1ni9b5Gur+WHcfBfyocJ+56GBrve9YXNPqPHCMQ5oTalZxvOmZ4idadZkz+H7fP79+dTltatmMCHLBkOKEj01Lc6PYdVVi4mpDNvOyETMO51l0iAL9MTxif8GZp95UU3edQvLrhom7F814K31JXZcoPOSU0Ls2qpFXtij0rBNQ3fSv2qO2N2WqmuuZDisTOJP8wFwcFqS/x5dihcwuj6HyROUDgPh44pRWnpinLIDXwi84lr3W37q6EFGy3iXl1to4Cz9LoQO4DtI2NuhhbdW1fS4gpxI/Q0XTU2p3M1pnZAB/HhI5AnuPkFTZPw+gQr+/riIH7YzC32cBAEBi+ezoUj3Myq6i2kDHIg0nepwnrIARpfaw7f/L4p/z0F4YjSJKTEakRt/dSsx1ktvMzGCf66/1Y1YL/M/UASiwg9PNe9hfd9h0yBSdzFaB3enuLKgdmIv7Z5WStFCipdlEmRNehaU4SDMEIn3jIM93ZuJ+PjBPImUjgp1nXIfNdO5CUluufVkFoYZKDNF4eD+kIEoHbNfDPgD7GUT/tJH6GurEfdy/AH7gpoPwPB/AOuFO2izjLIuRFLsg3Clof60ftvpudtJUSkZcaO3SjAJEbNCyqqeKt4ulbUMBM8PY4KGiW++FanE63c9qD+3DBpRNe5/7s40+aovbSbNl53AWMDQDAaJ99xs39cWLXZ2qofOiS53adv+sxUuGOdJqzYlwwwl23ysTcy58TGlPk7z6sBtGhGZMJOc7gFqVncj9Epz8Wn/zena+eqahRJBeZ4ZLIwGOYHCQwk17fNMcONvGBj0gmJkBV61mDtAUJ4ZJh4eGXKTZuAyJCvOitWrfpLTGl1uW0bkVJZt+SQaq/1za0BLgLbAbIHV36X37+apctH9eE3tMAOiIeYyDem5zRBR+9/kz7vcPnhXjwLa4/iqJrd0M+HPrr1Ow+mWqhCg7kMHK3vhAJUq83ysZyTJa6GKJh85uQZdDu/FfT9wxXTDEUzPXUSZKSCOBhcKZiTJa2tHq1naRYV3JJu15V1HA7ub8dS5aT8IkfGNBYELgGoje//Mnvy5RxXqjXFB1+IEROpQt6KJhhtNPHLfPRPB8IOIGJBM61ORGmmu3ol/r21Yn4ChstH4WJ4JPoQ+c6F0INPJhiOrRmQwydDLL3eno7kTlROUE8kQaObuoiyaDKiwkqVBCG8gxVYUurnvlUlu2q4WLcohatMUVVYXJ04QV2/awwjEGmhJmmTupa5GZFZ9Jc3YzEgYsCuVkQK/ny3bASwBwx/2caATHjkF/8ckCbIl6NZwCt0YMX+v7Vwv7MxOPuXDOxUI3cw+iUnMOS4dKG2kUpAspMIFaE7P1edZWugCExvIN80KqNiVGh6EKctrpKimMgNvbLrCxJiArVWqgdpnOIXQIzKU4XAYz8qqhBIuajv3hUbkwK2G11FUjuWrOia3Ok0YFgOg1EtzXwtvtk4ZmUrQ+rKi9Wvwes0ou6IwH/tq337UaDAT4nZ5rcchaUSe5rfQXc4fHeeI8T/zm0zs04AMiqWKYEZHthAdK/NoKNQXsVdNgrwLEXJqR6pk0UPEgNZzc1VJQaO5kkLG44/C5LsBpRCDlxX+huFfxw0SS4vVsVyshv/TGvBLLlBi5cu33uM+F+0n62MzAW7icsNrund9dg7ouM5R8BdvvWn+SCm/s+TqDuacCnhocXMYzv6nUAqQBGrQs5YKcv8FYapALpYDAKha8uTtogv+KooAdd5VFc77cZNRzV1xLYE1hSgTDrbrL3Pi+7TykgRdTHmSGPRzRUw6hMBp5ANhMDRlA6RsBwOfziKAEQsWKjxtCum/bYJdqhefW4C+g6n/dBas3vArEiIC/3YAkh9bk0HJW0VIOpAf0C3f7yJ74ulYLVksWjuLTyTUFAFydDS/dprbrq3xCz9gOBegZn7Athn0WnRP3A4j+lQRyi77yfk3s5aHLgzTXZDFi4oLqEK7mjaqO6tayP92wEcaAoaSgRWPH8Ybb+Ce6LAC70l0PWqB6FcISq7s/r/VN63nPbiQhuzDmU9EPLDv0Elk/7R3BEaIHMmnv7kf/ullbG4+2a58OvhCuVpuoJSkv/II6Gl2Mkx6wRe7VV9tiMzqoValDZhR2dcfC9Zn65LVKUQ2JUruGf8JaWwWQ5sVLiHB8en/fxVrOyetw7vmSU9ecpw5Fhx83CTVfsNyPWJ1WVJGOslZb12oi7uD9y0xMddW4B4OTxsEeVSbUSW1nlwWH4wiDFWO2UnkY5PVuwYJ7a0CMM4tUnDD3InXqaEeeLpYbMfSi9g/BIlmJHc9fIb1ILItNUUAnmnXZt/Kt+IzwY8rVCJ3Q1QYGAHaiaVPJQ9rdURFYOTGTFJ+ell4wVBywOAggvfbtd63nPVspcLD/Abad+cpEzoVVhTGC565BDjkUuFaEzkuXHar0m0/Ayi58jTHMzWAhm0/Znbb4lTH06k5fRh/cRQ52wBzdbZZgHD1EU/mEqCnDfJ8X1GM8XQ/fUVJTFuqHrjPkOmcy+chaOB8Tc52a1bOocfIrjhooCs41MYYjxk3oskTTr/XNS0cef114snmuq6MMnb2N3ntsBsOWFygu84yGAD9NvTfHnltenRuqYBGjx+yiwTLdUEGiXLSanaGrboe5diss5aXMP59pTvobRAc2O2ngouG2HW8EtXSmAsqrUC30sNjXHREYx0DE2LRxMyDgOG7vWKJOXpX/JYMoNNj059ev7kGnWjkOk283ULsgkHtKASmkrnmaLhRhhNzr5ymRDv3mt/OVdWKoLaLBfA4mUYpScGtBY7sP8Fft4Qxtnmck3J8oVrQgC9zG0KFnSi5rV5SFS+TDwGJbS8JNogPc7LKFtOep2LqpedmfHccbzN52hWlWmtyrRLUWBeovjucPW3ywROswV8FcaIPRfmhMSbkZdBAw0PQD2BST6mBiDBBf/5RvWl3m3HzIbcEI8tjl5YOLpNUP6aVXAjrRWuw+8GIRHjAn6nueD04pN9oBZi0d6Je1YHa3L0q0RL++k2yvLNIFzOiyRNvAEvJemEh4BQCifkyMHdEKN7vQ8tf6/tUxjB1ek80j6Ust22lnke529YFJ3evanZFaS+gwkAY5tnC4X/N6YT2lF0h010EziYB9SHp31dxEE0n54l+JmClWlpELn2uqEBIVIRfWKQTQ2J1pPnMnhm1xneddDoUm6m/PiOIB3/qmpvTGOLjf18Lj8dgooHvh0zEQBvx0ToTsX19tux+3mhrU9A98tdeu7lyzKAhspGKo7QIUJsTW27BUO7vwVYHK3/X9q2eTj6ZIl8wKspIOR6bTW0yI3t/ce2tXTZuNoeSUsT5kUGNyvexkC7sDBIP2MvdrGyuwU5KyPMUGlDjOIJ6QYv5+LilTirTIOekiigIK/Eyv9WMWhwzmdr50F80eAEGYuLTMPYkatQvUnudlKkxhcts0xmg8sVmqNGdEcHVT9lYWteqsJNgBs0snyu5awbwHCe9GAzttrfPTXmvQB66cBpBZE77CCZ9ZUV2atB5k67jKtiC+c1pAhjkgU+TmgRVkJPE1dHbo8Sz88my7X++CFQHb07qHROQPVk42JOKi44MDmOIEj9BkcmOiT8teolqz5FbC20rHFoAlHshjG8eg/z1LlotTBxO3lEjhnsKKdvRh+CIn1NW1oLNG+8Q3fheyb5wSjVmUlGc974SJHO9iBz7dXGvHGIrPCo4DFN5PkQCHG9wOHbJ0G+jkzexA2YlOIyJeydz3rkYX2u+6W4u9N4QfwyBOLsTp7MACAKG9nlP7hAVqGZEzS2AV92yZ89dCQqogD2/aL4R3kiYbYBTO5c3GEjrchzG5pQw09MVHcOhmcBDDRl4+TlL3yBKOjZbMAq2im9sfKaoOv4vMhUeecNfU9ax96J/nY09UfZwnchryOETlYSF+nxOwwDEYoG4vLst3r69ibTvzNZSsPexgVyF0SFF6vSEN0Uw0VRmJ9I6vvTN4Xy/XewkXIZ7+86FK7x+gODC2ywi3IKjkhlnYpbSiIdr1pR1b0lzxmymiu5LSjRZdCCFng2hw6JzwMTDiRq2Gt0DX+MwVtVxWNJow6UaqAPghQTvdwRwFHwOnq9CGuufjRXf93vUnsRad3DjC6PSXnYwY5HBGAW8laXvUhuyMXq98JYM97JgQis5+d1jSUMN6IGzl3ntVtovXVaBpQRcyHmg6qQtBBsjuWDJ2aKc/s7qSTTdRYFhkdRcauHoX7OIAsxy5RP2SvaqpSGE+MamvMkOg8DgfsBp4v90INqmqe8yJY87trPSSLX3fsudfm1EPefKM5/wrSJANAiUOzElBuqMwIjigUMm6K39tOqEBm+rag4nJ4olt7rFSEc8M2VPXzTatys2QSIRoqksU3ASwlooJIn9oM50ljRsHrBoqeDVDCHlfI6DCK1koNRiaMoZqSvlKCuVpcvPkSqvzqKmCzGiZfbgo5mbkHVURpBrx/K1/vX71dnZ1DszIRTOQ57myz0ceghvdWiY7Sf/qxrs7vNgjcTkLZEMoFnDNaljdFRN1BFawtknVl5TVEygv5HoXB7XgoN3vUpLX5ZF91Trlwes64BOGYfzS3HWob469XLSKRcUxRHEpyJaU/PhzFdKgtj8Qx7FpZd01usRErqB3iYRe6/vWNSQPGOaYG51it6mfB7OSM1ZBbo5AcABau1EsMJE359zPIV1RlsMQElw2bUTt+jhwOwbaeKUnP1dpyFoZKphMtbS2p6mGA6H2JxSYWE8zGCJBuokc5R4tZDRa7FUl0oA0GTfE2JaBgoWF/CzUugTESKGC807Kj5NqGR5ovrWFw5J7uHVXXsC0Fy3ge9dT8+vixJ+nEP5jHwwsTFlgtDfb2n/G+9av4iZjgk6yRB9hMFQqJz0GjaV8x6m0vGg11hon9fv6Z5v3rsK9dRtQh2bzFKMPJs4hqZVP9JWrg9P0quzr666yvppGpslnFkqtg7v1BldXkoW7j4MFCBwjiDyGOYZjO4i91vevMA7uexgufisgqkbnSbxP9zmBXBS2RuwuG0ORtA9JvWZTrlE840P82f0cCJklOwPQLlHCbtuQxj1IY8nuiCs/MQOeBhZbksZYcjdqDUpTu9JatCtTkRLF2xIBfpZU4pho4LJju1EPCKhoNpmaALfj4EBidf2sDLejsO4fWHMhDtLUX5YfP265O+nJMWS3z25CZiJGbBfTjj7ujmMMJvVPjm7Wewog8K1gvrWYAuIBUprpgOpo/RM7txwcnFWya75Ml6ygLp6JofMcMVWgr8Q5lRv7pYcuabNbx3RRGa9nq0XzDu53VOB26HNLo1K1VDgBHmMbRTCvNhySHlBXNZDrRI89+KWM9m+qp3uwzlKbP6EJiEqgKZCkgIsfvlsyfXzkTrR4Zvb/6jApo7uELrqrOgKySWU+LsGbt7CnCrX9sYXq1ULlwnAKxVaLbI3iWbcSRxhEmNE9KtV129ng3G3U6kLFDaBLGbeByRpT3Y1MHoNmhrfjIHVGmzKF2rTcaK4T50mhnnfi+1o/ZHVXzD3gObHWpNNEJ188xQCQN59Q4dl2eioUOZXUsAmVSmnY+eIBNefEGIAF5yN0UNHJuYsU059BNBgv2da5pnmoc8hBn+q69CEMdnXN6Ji2aPEmMW62+yXR3ebud5CSEJ6In0hjJvu9YsLL50MWgQUVO7UDVqVvAGAf2Ebay2v9yEU9xS2clKp1YvaBBhaZ55KLoJM617zeRqVSQlnfe6+2N3u35gHwmSDSoz8XpjWnxONKCIMJXBpde5reBzA2LwOWGwopwIfCWw764uE7gh2ZaoQQJacf7NdpO/P6KgYrAbDCuUoGDxBvmX+H3vZMVKcaR5/eP6PgOJxIn1nhaKtYU/L3Wj9kddnXyzqxqQW33A5Say3a1OaiQ+TbG/emio2E7t9aWNIOASw0jzgQ5nDP7QTUyViDek3l6xwCoM7IRaEtAUWm3w8TeGSd7mGnAT1rJEXDCSvmE11YG4BJk4ju0nB/J9Y8Wey0EQ5ufP1KHG7qtix4qeiZQFphYQDpCAPmPJE1xTDp63oVID926V56W4CLHpWJIwLdmLskOrXBDrIP1Enz2DrMBvX6jEUt0bFMuSQwDEAmzsdDLqyBYQNhl+Mf0IWw3is75qpbXYzFc07cH/dLDrFrJhUYMv8gZbeNzi+KbfhAhMEQbCoUaZCjc9qc1B6a4zZC4zQIZBUKm7VW/Y1ehQ1L8W+kYD0vPouFtQqzXC1OvzQLpWmhUIEB52yNRth24VFY6iKYqsAq2keujYBYvyGFi8WEMTNVdeVOsMwA9AR2Y1JPKgG/hvPxEN8OEsJzL6x52VQSTLP9OXu3lT7vmrLZdXZtzNjhqFwoE8fNNBix1S9V6hb1vr2Gc7VuJctwLiCLFJosR+y7+VrfsrrV2AgrpyTLisBIh+rRkY1KcfopA9HupOlAyzW/6piVDrvn14dQsG5jzsWgUzmRWRp8RsetZQDkStHJ0DDNyiE4AquFTBb2q66EbljhMROPOTGG6C5CtBsYGHYdnKbDda0TZ3Ha6yFwoIdihbQhAwC8YDWUmLHECj1kC02vcBzjwNsxEOGby/pa37dM/2oKCVv+iaE8x612McAO1FQhaOqAdDy96IZWBcsFNKU3G5X2jXg16su5N1ciuTLpHlWMb+xm00HoUXfSZqq+AngsJzkiEjaSZotNC6Dw0dQkIQ2FW8f2gdhxHxYX4JWFtKYhsGCGTEbo5DXhWXi/ccr5T/cH/vDH/4pbaHo8yxWMAIYD0Hdp9qJgfc96Pqn27ITVeopi4dH1gBVWtRlAcUCkWsQmfd4AcKp4zFw4J62gOZ05NvDBYoAx92S2iMyFqXlNZixY7Ek0204/HoyBvGa6c84koFma6XXOhQDZHTB1/GSpOzjDUBRCfs45JwopjRYfNq/WYhX4KUrCdw5nduewu2GlImjC5kLWxNzfJ+leIfZXYuNlr/UD1rOpgaO7Hdj7t+ddXZ21HphZeDxOzklS7neM1kIWnlIIGJK5wJo7h6ZI3Z70dDKYWbZzipULR1A6vocgi7lwONCz5trFkEnI2l0/GjjQPbMs5ehWArj5jyMBHxghnUg4rwMcWjyc9utNL3dv8F50bAGVpXjMnFjxeuUGG8L+cn7wq12wmpts4wYXwh87uDPJK3Um5iwcERhGOkskq/vmC7vQvFDLnk0epyXtaocXZ1WWDGS8m90qKgU1AHBkBFogDFA8U6A71xbqensdF6wmHY50M9RMZZhwVqlnchL2OZmA3obDQ4ivqr7WuAAQ6k1nALOQJ/Pa6LQ9zXw4Fz8/OaQOxA0eLdJ7JXPfs573LKqw5om1HkCRNjfC9j1ZuQCjwDc0W6PRtEbLQieoVUvNC+mOsANtJVm7kBV6vCbu5wOoBfNj85WXrO+gIDbsSgJdok3TBHSYYU6i3Jl83Wmm606sx4LHAfdAqJBwdTjYjWMCOxUc1lrwoFaLBRHQwxJN12I1YEicJw/0YY63Y2AcNywY7mfCw3CY0BGDKDN/55v8r3D9PNamwJxQ0h7OOQqZXXjob+Xa0nFUXRRYo26IMwREAwT2genae5zzwoPFRDuFOW7HgWnU2ZkQ220eosQfeYEqFF2GnIM4EToiENUom9N1RfaAqRh9dcclRI/L5hFgN28xsGLAMby1WyrMnGoVj8LbUAw/HOsWOAZgvtADc0MUnqyE5dodnNf6tvXzPbvWxFrnPuPdATea3zYwGIN7rXwwHo2BmwwGgIJn7u5uxABgT6/F/Rdi9XXxPRcpKDNXn+KAGUGXttn3khtVbDoVr72tqBce58I5ZeDxRIHh5Gr+M4LU1iwVPyp4UNiDmguKwcZk9DDmBO2SGM6hoWNwHhopktQYIC+0/DYOjONGupYoL6/1fas7xMCVJlh3ByDWRLNlVEyUXc5oEDh0/XnJnvyi5VnH22Th0bO93F3AoW8K6fLEvH+QbugBP96emBs9SLY2yOcRcFeRXQTesRby/EAmHasc1Gi4S3vSGa5BdCtTN89h8nciBC5A3YFyurKSvUM65M4zfI+LVXNBdtJLQnjRF818D5n9S+tvkzQVIH8vdQP80k6UIQ/ykXOeWEgM58h2+naDKIH4uy12hHhy65yA9cPNxG8fsnVRnXryOMsWJYDusHLZPRoQnJGwynVYBT2MzbZ1ZPvnm/V76KB1w33l9uCeyeQs1TpxiYEovmcy69YFDINUiJc6J0WjMyGrTN7IKfFd0yHcDD3s5hVmftxq9HTK9z3cqGOAvnM4zlWAJ9H8VIKlSh4dZmQLWtCgN3PZKrJ70nvcwa7YWpPFJJw2zE7HtSkLW1o5syNzGA8jHZtEyQo4s6TvYDdnFzgWOA6Keqe6HOFM+BhY+LnD6KJVcxG7KSZzNVr0a6IRyBVLYALDUGDJ8u+3xw1j3EjtqrU99Cu7j1S4jZcy8keucxL9XTu2GFofhD3/5WQBXexVUSuRyEkuse2Ctp3ltW/1eqH9lHFooBbQqE67wsQ4MNfCKVvy0B4bMYiS1YSeGBUUPd+XZ85sWq5de207ZrkDNmjJjisOewymq0s96Uq6wsjpyFRge/LwFr5NBzc0p//A++ffs7CKq0uvVHl77G/Z4Gt99+rEYyW54o3an+eDZ6uSfjfqJhOG4aG9BOyYVNwv5hRx954jeMeC97nPl5qntATwWBBUpLWuI1dhWNKGGtgGH6hO6gq1JtbkdSfsMhaRYDzAAjsOdYGr6IqUKYcigxUHdXZRnO7wlEor9UwaE8JxDHgVztlCX3Ya4whYBA44xhi0a3Xpsqq7l69N+8OWXe5qZiZQzTC1N3ae4NRubOpqSS1srXmrfrkNxmUW7udEiFLdHWC6BHIPzVz46eMLvnz5CY95AnHg958L729vCBvsXsPFtJFiRHHaQWrUWhP388SX+0+Yjwc8Bj6/f4LbZ9yOQyMuALQ4HSaJlrqJ0samQVRwxtAlVsfKi2I11wI0sNhRvGY0fAQWVBp54BEgvluX4cifWX81c3h2uYAQz3ZQaRtI04EWQcTJbIqutWC5MNWVNbURXVZ82XQlkBfng3z92lMc1XZ82jGmqrM/Nh9qisiaM+zSg5SvHRBgrPqat08asJAJE/1L7SxXAOTr68aVMOWS60AVUA7vgTDQxoLvw3YVUUtWzY3Q8VOYOIK5j23sRPG1vn3x+VTSDu6NLMPH48QRzrZmBw67BFxL3HWgecGgQY+4nu0627ufnQu/uPfinwPUI5UmTsNH90348MOQFpigFqXKkLOaYYAssO25FhZc2hOwde9CQ0CEMTY1JuhCYXTK8tJzWgZb2AnAzMTMxKjk9ekbKwvxmgvTAssCsyaGHbC4wSKUEC4enGvtQBhqy77W96+OtRGB4zhE7SAVgKYYIS3G0lCrawhVC7PpPGXiFTMLtC4wZEcqOEdOL6JLVZL+kqnXkA26Ax9fviBB6kqLjV2OMYReAmkFxIGywBJiNgW2DFGhEs4BijwxyM1vioxdB1WUDDn6SrMk5uTfbIQwMdAd7ynROqexBwskQO+vVyrOzckCFvq7eK1vXc+xtkHFgmPmpKYROsu7A+aMpY0Qb4to9HnfLAZDmGPKpIZ6St/xcSapVFaJ85w4G2QC90DrTzuozpzo4YWZtd16Wue3VuLMQrn0e9l26QR5Kk9MGEbc1A1JFtdErGACH9sMxwDEOGDLYGtKTA8cHrAxtiA+954EfLzh9v4u4bqxW6M8omnqsAYkXutb18+/vecclp0obKZMd45HEODr5JrdsKZ3tqvZ0kBY5rSPKXqp9KYl3ajYsqgCPh4n7mvhfp74//zH/zf89hnjf/0PeLu9MUaKOUHL9UJZE8Js07nm4477l5/wz//X/xf/6f/3v+Mf/vHf4xj/K+7niff3z9o/eXVdjN1nFOVL5rUB/85toIGyO18pACm98uruRp9LYxdYDsi0Bhs4ONsw5C+sv1qAPPO7m1bUX+RMOq2UsXU4z4laFKwESCNYSOotAIlXxL8UEtWlRAFK5EULqHYTMAW3gmVzLYX8WW66E6BEaCNlEnqpgmFrdO3NBiF6Hj2c6NmZpYsTwJecBFSBhgoWTWdQEKI7gfVmtgtx/sOXLxijk96Jw1V8qIjyarcMvccrvnzXem6xQoE7i1Z6NU+8DccYb9JJ8GCaVZoaLipAtUCrBWHcX4I/iMShkzyiGjL60aFx7LakMLarJanuG52mg85BQuugh7aLI1hbQfoWflkLKVFqh5JWEIyMonuxrd82l1m4ngGJzLZdq/iiu6T3AGwgRuF2HBt5XBL6svsxyWu2puz83W7v/xAr3HEbA2cE5pqomgh/IyXFnJOlwWSnDMjZfPWOPY2WeZ+mXXIo7hDueEblzEPW0i1S5+FzzoUzS2JZCtnX3muh6wBGgfNo4JjVRkgyBDHt0xAZQIlfmW2/+D78s0Gn3flhJ466GDkqCYRyk2PRRvV4sGYKeNJzVpoI3777me1k9H/L7f1Xs76OtUw+IgZ8Jc1bKrYJQhcoV/Lm6JkBuzMlB6KeqWBFtgOsMMx2Mc4CYZD+uSYec9GS2TVw1Y1TrOXWg8XiFcXJ0it9d5arY2EMVBwEa6RjEekB9zUJXp7AGhD9SnFaAxaIQ/r+ZkxmHTT2ALskxiRtqrNZeu7eYuDt7Q3HjR3Hx7wjK+SYmOyoS6eV48WQ+J5FjPDqWISZ5lp0VOwimD8TyumY8y4aF+ne9rDqDiQlSveZT2YxTzklBA6xY1t0qfQDXzDwH/9wx3Es/Pt/D9ze3jEfH/DhmALF0ed0LrpcFQvjEcCaD/yX//J/4P/8T/87/u2/+yfc3m46Kxj1p96vi6xuBMwCYg9PtD0AmY6FF6W8KjHn0kyUwlqkcd8G3TULpQ4Ddd/e09nh0sj+Za3d38CdKAli6cBC9xXnAJJKhBfWTGBNYJ7Itm60hfP+wcRs3IAgJx5Z6g4QXX6cJw4fQlVqBwCl6eQby5GCD6MOWIDiG32zmXTc6CmsDonnoWQsE8hJ3/txXO3hbsmmiWYDORRRjDm3x7EKlmKCetYC1sQteBhnARYMkh+PBz7uX1B34Bg35BioCAyHuNBKJrt9DaMA/7V+2KJgV4KyfOB+Z5Ll4rQDog8YrU1d2oYWm1EPZNv1YS3ZJ3dXDY3+XzNqXIVtZuKsRM62vOMk1LUWbK39kLP9KwHa6u6FOmOdfKVQt+Yt72IXRPb00HMPco9X0Rq6ROvqaaoUQKnl0ugawL2eiVuYWreGNU9UGh56KNyJhK81UaBj3atp96NXbaODXHIR8qY3GR7niQ9RW8JqzyNwu5CxXAvlBsO44qgQW5durUSRorGHKIBmKkJShiALxzikMeJzMZecWIpgUZj2V6mA0afo+CvZhw747jS36xE/VTUsqH26Cl/RXS1z0xa7mDhFUVwoPFbRhU5GEIfTvtidAxybOriHdb3Q5B++zFg8HxE4i4VFCRDsQjTiimkABbep7gTUyevZTe36s2SEELIZmvOEV6kA19mtQiaTnPUEi9UENIfmFJ3EVURzEPIQqNTdXDoXQrF+SnOV28xjnoazSFWFElPrTk3mLkJS7A8mX50zMH/xKjxy4TxPfBpM5IaE8SsT50ocqW6KHpq29n0xJH7c6vPT7QImdpxEn2uyPFcSPpUXLBWpNjSDS7rLKg3wXVNaPIGbGwRnnA3jTKXwwO32hn/8t/8Ov//NJ/zu7Yb324E/Pu4451RXj+exGc/jNSd65s3t9oZjvOHz59/jP/xv/w98evuM97dPiDhwfzxodKP3dQ9kGnr6+1L4Cwu0cU2B+e8JduxQhXM+1EEsGTWcoDlDAKbXAnAMNRK6joFoXb+AUP71QYS4Dg0m/+RLnpk4xgG4Y86Jz7djf+FVk5aLlah1R50f6h4Y0kMoh6xvdcWlhxPBKbp0HhIdAE0hYcJHNCHgPljhrVPva6jtiMUvY7jpQCty+XS4kifKQ9hMdmHJeQ/d/EcfjtaUnuYGclNWfx+VyDpI3ckExN8+H3d83L/gD3/8Az59+i3+7W9/h8Pf+gtlQdPYc3Ui8Yow37N4nlzfYQvKoy2OhSh5kM4ykvx108+2B3f7gWfRxWdz1TuNao4osFu1pIl0v4QUgzU53bZQlztFO3KhhBE4ecb7M3Dvd0dk6XBLUVM4SFMIGkjHKiV7xDx0wJf0VnrdpovFbu1DhyII2dSC1aJxRKPntTQjpUVtRrc2sNv4moL+Y9bzvq0qmQ/IjcyvOS5f7l/wz//8fyF7+Ctk2gdSBbJMCVGh9XodydtJxeIaWgnY5kH37qZYkeje2xgY0ki5aT9n86ax2/qOq7AgJbdNCijCLdCcwWlqD1q0poqUJily/6JtJ6vFlvxeWkifsrBeCBhK/P9EPR78TBE4VFzMpPtSU2qawrUBp9f65vXzWAtogN6gKUwLePk9L1GuDhWyF+sBVrvYaFoUKdXcv5cWtMXgJuDOJIwlVWrN5JBZH5xevpbYFAsVoipW6/DalAE4XEizwM1ci79eJ2qepLtKw8FncjABg8lUBEoIWUC3hsVAOiyMFFmrNrWRxW6eMDtgRYeipvOQMWEq0jmGgBMIL4el1/q2xVBp17O/GxiFc17zhdgZbvAPihc0rigZcLTxB3XQFx3WAdSa8GNss4/uPCyQGdOg4+048Om28E//8A/47dsNv/30mbW49ijQhgYCK50bOWKoI+F4//wb/P5/+kfgN7/Db3//b1ncACqaqEOp3j94YhcZkOZIZw5AAJLXOIVRGtgoaOaGmQE5cT4mTg+8HdJw+QXELj0LSzKMsTuDf7r+uguWFjsHpFbdrHAvTjW/HQemLBorKdiKYbgdjponznUyaJABLLeH5kWp1QqDGx/0RqX4MIp6BR1CzfMVrzlibEGNiadfTjqUF3srw4y2pmvC/A0RgbLEODhd96J61XYeaMJ/aYOSPjDQ06A7yZNMB56LFaLTNabqJGe+Ft7GwNvv/w2Ot/c9xGa4mILGpBdOPcDQDXutb19f7Vl1LOhLMHBY4DYMHqGEKnDE0tBLQ087ZbuVHTzu6EkhoXJy2tEBkFOEm2PwpIHr76ISloXDCtOW9mMhRCmJoPVkFws7mOnPuZeacoWtJeIQNaHAIHrDHDCxPb6NiEu5YwxD87BhzuQzAjdRFVYCOR+oNTG8cJjhaLQbnQQ7rJjswh1mAzA61FwF/Wt9z/o61tLa85wnXMjsUoH4n/+P/4j/+of/gt/9m3+EHQcQA4OcKbgHEaeiPS46XlmLKR3tyNK2t7SjlUGHuhptxMdJwUHNhyxTSamZoiaof11N72KJXqAI2Qrb7nnPYNAy8LW++vT9P13QdwLqBrdxUSV4IDARNed7J2cvuPumN2YBOB+Y5x2f3j8hIra+aq4H6T2v9c3rq9JjJ0iuWWBOwxih95lKrJ1xhLRsnfUGdZQDUaRoodp9bVA4bnhKvnUCG4XDhwag5TqxzoT5AmRmYMOpAfLYCWTmRJZiPJzngxXmfCDPyRkkcko7jJ/lGAPhgQW/hsJtsKev6vpWQpRZ3/kNu3xeKf3oAs4PLF9Y0xinMfSdsUvNhl/BwzU8t160we9cFxzD1To2EglSm8wwxHTJWmguznAHZw4t5mzKA8p6KhjgRjfBt9tAO7IxZgmsM8M5H0jti7cIHL/9HT4dB96PwPvtDXNOxlkxglxxMwscJeEH4IGhrthvPv0Wx3hjkeDdmVPBUJB9OTscKVpWmQmUZfHcYHyqM42UPtkMR6iQUr+gBzn3vJsYY4MRe96dAJ5Qh+kvrV9NwSKXrQWrgI1AWeDjwRZlmaFyweB4e/uEqgWLGzxP2tf266wJeIg7xptSMMRxQ0+VJp1Ak3yNnZOVdBGqkL2kXS4FRwzSmBYDTGjeRxUr0zgOWJA9nGZAHIDFpiuEM3WkZlNTgPswLOByC2oxsoleJhthoTE9nMjNcKsEjsDv39/JGYXTTUitOHK5F85FtzC2gCE9y2v9iLXvnQfWFnJxgrjHgREH0hZynns6M72/XaYE/Psu3U8Y6R7WjTvt19Q//YA2ltxCriHKEg+WsemCYaImoAvuYkFu/ffZqWtuZu8NojhK3ow8+mzmACQyQ1zFjQJSFgPuFPWAyEwB4LyJw9uel6j4mYvOYVBioWcVuuZsPna89uyPXKkOyFo8MHCeMNDRreLA26ff4z4LtyiFHNoiu5JrZffaS611EGVFTkXDsbtj/Q+Ai/ebV5HSIuMeSBmisbDeaMchdSjyaR5CvyZkbSo3oFLsVL9no44La89JylqyPWfx3ODPzBKCzddsR7rQIQlg07aQ5EfP88Sn98/SS/FhmZkY9peRudf6G5fxbORwySexbhe1wZiaKzEr8XEuuDOppxaph57JOQq4isyvUFvH0muWLJxv42AnVwOSgYXwA58P2kJXA30NLxlzAexigJToYSENa2HAsNwQcaPLn3PuUqK0B8muaLScvF0VT+pIdvHRq7rDYYaMwLq94ZwP2P0D5QNvb7oub1c3dm9MFMRqG+DX+iGri8eOOR0vU+BjeLdH2rSD+WoPzOSfMe+0CHUtErS6H5hUeasgAIYP7UAaLzgA5MLNgXEMUknPE4DtfMUEutd+P17HklVzSJsSPjSHTppPZRUe1BLlXOiZZXODN9QYWnEuydoWXiU6YduqS7NaS+cLz5TVHfuVcKtNeZQ9FMwKx3HDL2UHf52CtdtVpi+i3UyK80DWwk9ffsJv3j8RfQp6C6MG0gIDhbSlhxMc5y6+ej/URNYOFGoLHPnWjrZHCy+kPQna1JZyHaJVtSeVh7HQWLpsj4FbMLGbRYvTJUTaNQWyaQHNRSX6XYD8u1uEvOk6cr7gF90bBOKq0lzZExjyiJ4g5axAag+WEgoLrKdg9SpAvn91sjRGYIyBcQampfSC3dq8ko9mSaZdqVgHCYCWcl3s8tnmn1YR99CIH3RTvuSw4+q/ShKsRIqi8YSrUO7E7gliaLSvABOKAHN1zUxdiA5selZczwDkYCRaTRdKmnCo9/MubWAoHONAe3WRqw2ihSaBuwcM/DWTCLah10oii78YYl7r16znWBvuuB0Dj7tjJWcTWC3ado53/Ob2GR8nwQvYouDQNT+j6XUbLlaR0U2wji+iDUT4LjB4DD2LwLtEqM2LNgkNScVLneJ9UF9b+Kms1pwQQo3WPwTb9CoWQl345x6YCNFlSsUHn79UctuuS0Tkxu0GKw71uq/aVJ6C4Teff4txvMnJJkV1jV+0h3ytX7e2SyaIiJ5r0YRGwEaJWM/unNHdT8W1Nfe8Y+4TX5wdDwF6SqrSfOcNrVMCDIcbbscNq67nJ27vuInKdPagtypA1rZWTc+9HLwCwHF7Q/ogJRolzZsjjddfawKWez8uaVFDRwrPCWxHITMAqyehqDBzx3DS14/jhkLikYZRZHf4YCHCvZo7+YMZ4jUn7LvWz5/4y/SFc96aSg0oglnwvhZgRf3OUBHar9Cgn3d+B+nXNKS6k/VSd9B8SBsFAKlOtfIHa7OFnsxu7XOwi5kGjh5zEtBBIY37nhddZGAojxguI561ttEOc2cXzTzZEYShqal7UDGDPb+TBLI47DjEHpqViGTnpxq0RRDY1Jf9S7TBXzWIsIrJlysRIX8Xe+rp23Hg43HH2+2G0IRmtPgmBiILCXrGm+ha5JNjJ/Voka8qv5QQvcWPgOMI2jrukCXkIYsDkHLJSrVFREJxYYahFmqptVQSrocH2FmT0LfoB97e+hGtN+kDlsmcEUABIGcvk8BTbhcI0nKGEyk5YJhltPvTwU0Od7erNmj5Wt+7qtNuJS61EHlSZOU3JimVWBEMJMWE23Hsg8Ug2qH0Qj3Ish2jtlPE80Fj+12hPh5bpo0mgMPZmoawqQYFtDuRdZGxr39/HCE2jcTssqZp1GDXjw8I/4pmQOglmYg2P5l/1+3qvBnappTDwzg8LuAx9PMuMdrCmqJmAS8u/Q9YV2ELgS5E9JeMNx4zkTYQxzs8BkadWI8HHueJkM3ZEbb/Pl9TB2Llxa9H00acIInRnpl+AtKAVCEEwkDJpelftM69tFXX3xKC6I4hKuACYPRwlCbKt90jD21SV4dmm6ASKyd2D1EHZVNwzIH1mOq2iHNcTAaPEbAyDaW7b3eX97cbPr9/JqKcE3OeSn4bi3yt71n97Fdx/tdPf/xnWCZuw2BBvrv7wO12wxiBnzKxJmdltagcdRnMALKbdnuKady3vZ9hbShQ6kwzeRw3XhPduAIeZGVgPeiM5s7nyjkfpLvO3a2B8Swfo+c1dBxWoioqzND1dREPxePeTg02oc8Hb7jHMVB7Lo1XwY8bzT6SGkFE7KTMUDgXgR4XuPAKtT929XnobV/PahkGJuzdDaEutHa34JpeIw2oiohnB7/WLrWZSIn9EBHbEj+Tcb21GYAs1d3pkNmxtbN5I+20Y9f9cd+5BOUIqS4MO8XhKqyqkOdJA6SO5QFs+LWu57CSoBblAoz9mYYlwPM4bhpQWLjPUx1nbDkEcOUs7ti5859bv6qfx+DP8n5VUzyAYfTGjvdP+PLxBY/7B2wa7BisAq0QtbDmQ5VfdxJ0QQosKe6Zy5ORbVh+kdOYlHEDQG5YhYcboBHxj/MuCo3kGxLE0DK0cK4P3I4bjuNGi8hkW3OZAbb4GlM6EQNmmagN6nE0wgNDU2T6wGRRFYhxwxgKRBpGtzJhWHBnZLQq1FyYc6ni1U0CsHKhktqA1/r29bzV5zox5wPIiRBBINcd5yQedTs058Li6X60IUKicqLWiYXAMQZWHxzQc5Cyd1RRHAYsFZQhZDDlHoHqZ4je+PJswVq1BwAtoRH8k252tMOQXGXAIEkRpX5n2dUOVRCx4nM0F58rMzkqIYA0pLqLVZwgTN594XE+xA8NzVq4QiBQ4sQqIOv5eGlAfuyy7mBYwEOWpvNEhsMl3kYn7HPKkSUxnUjzCOl7wKFvBlK6+lRIib8LjHMrE7aK06nRh9jq3FD24KZiJNXFBmCa75GpIruw1A0ZIbcVsuy3wLztHg0U5MY4NhI9zztyTg4FfepQZoEuWFk4zwe8DGO4jEYKaaApilND9RbUwMTgtG16T+i7mpNUXuDJNvW1vmupGD2G49/99jc4H3dkPoD14LlshQjmCueUm9AS9cXUkVoTuaa6HLbn0xhIGZkKdURr64rBxcSxndxcnZeVU3o8dj/c2tVw6vymjWkKYELREj3buKE0VwTObq/2H80PDN3xbgOHDoEdN7FW93WINruAW2MusLJwnwu3T78hmLQIMngRpBrhqOoJ3SkwwOAvl8wft3a3oZ3xGkxhAQovPB4nDNiDW58pVaa4Ve3I2rFNyXxrPEn1S+WXjKNDXbz7Wo1dg2Y58VRzyF5cYGCVBiFHbHAojF3FLE5dLzCHNG+zJux8RuW8GgqsGEhJpINX5iRVS3bCt/z/s/d3TXIdSZIoqGbuJyIBsqqnu2dl7z7s//9hK3J3RXbk3ivdRSIjjpvZPqiaR6KmikUSaM5OzzEKACKRGV/Hj7uZmqra4BP6oLYjOLzVxPBZixbYWUDYwpT0oedKZcm8AX9/n/3VFCwDEFF4np1Y8z8eHDwgkYutnuIHYcOBURpU1u5C4yUw7A+4Xgp7IrVyCyrgjMCXxxM+NGSQnzsiAUsVGik0GbVRb4puwGqxaNMYtnRuJw7nhrWqEFqEVSyqXPNEiHg3/vEqPraTiuyE0dxiSGhm0gskp1Q+nw/M4zOGDS7GOJkczIND5MzgQVS5qQ5X/P5o1Ow8n4j1QMWT9CUkap2YohZZ89K9N3o6XaDogsJfOrjCtjNLaY1Fad1oHWMMfNR+cMmMXVi31xAPQhZBKS7nRiDiNRvHvP27sc0ZSsSpnjVTWSjLnSxiu7PVRod7zbKDWTthiHxtTmkGDiXiv9vslirff9v+NdI9Rnc/+JxXfFt8tdc2QjW5X1C3RI3HNGAaEAZZgD8BuyFWcjjbmNvWNI1Wi+qTbVpVga4/Li47Ea4Eh66+ULS/HhSI7lZ/6NIBIB0rbaO+UiLyW4ougw7NgAD5ylVdkIieIOrOlNkHtVct9sX2k/dxCN12jCo6zGXhrBOwhNWCu+F+TNLLzNDc5XOdeM32qWuv/cbYaxbY3ao5BsbtwFqBx/tCrgeyFoB/whwSq+Zit3UFzmDnoEHBMp7PVjxPO/lry9C9h8q4pXJxzzKQ4mIkzoZyEXcKzIfWdkYhweLailQx/idStWHPWupuixk08wkYY+KsFz03YTJtIEjqLhq1aF6bdgXspDDl1nnc3zBkwesjXzbZWvPDDTVc1Bc6FaVda/b7BRk3K2h36+4CDnsekrpxaFMN7n0cgMprCHQ3b5DKj9pn5nDbFrwYDi+6Vk0B5D4GcH+j9qJI6abmUmd4tMEH0GLRiEKdolA5nbRs0FnWwVx0jNZuAKSK6/WMuVkczAFC8+tUMPX5Do6eqFxyTGRBPHziEL28dXf/5U93/OX9iRXcV010DIdAH8gQ5e/Er6JgAdCFom4hCxjqVLC9dO75H6sCfrC96mMwgR8GGAejjGK7sykrrguV1TzfpgYUnYfM0Q4qrfLvG9SMGxITq1dyt1E20aH2NGkdwBzg1heBHxxf55AH+atLU4CcaGxP52082Ex8TQmFAvRMIp9wYmbQ0iwCf/np3/DjD39GpYgzbvDhmGNiurPTUwm7DsVvivrw/27GoXxFhNhwwvOJef/Mm98mniuIjI7bRvKtaK14DIPPO84oJftLnFAVp82L3MPdpBPZfXI6GMkSgdS/UpG5W/QlK2cld1UfBLyNdIsa0y1Ztw/rkGu3nVOgNcQDT43g5pvma8BixeJwORim9URz4NPtEKXxHc+VwO2OiIUzAvfbHWacY9Mdo5Sn+BXfFh/3WoB71uHUP4wxULXgXjiUUDm4rm/TMQ4m2vf7Gw02ClKc2U6CzOTMo+fZg9DMMG83CgiL6ylTz2G9q0ooLr3e1k/VVmRsTd5QEsefoUi+3atgek0yFznmQEpLtDLgGmw1XLaWzY1upBHA7c6uxnCHZyesC8+1cCZdFj/fB27HpGDXBp4Cx5AnLGV9XQ1nXfF74+s1y72gHfzG4Ho0A/73/8//Gz5/wL/86w8YTifAM3Syitri0kq6hOURuYtux0C5dHLonIFgigcAOQc6gGkDjsQoOWCqcB4+dofZjEYKECWwp1cbwMnTfb5Xoud9wACfA2Me6sSUPoDc99am7+4igq85wc4xhfbSefjEmGPfN9ZFdxWwLd8T02vnIGR0XPnB9wqe6SxG3QU2m9GKVgh+O5lxwF4i03QOa52k1m5rkp2FhG4DtKaYDq8UlQ+UOmfULzFnMHS32DIBFZqnaFqh+8WBD8AMuwtu/hqorc6hNnrtuzQNOWQKQcbui1rbtzDrZsH/9qIo9ty6AQrtn+dCojDHAZjhfhzAWnxdolX6xuebWvm341dbKpzt/95CsGRLqYL0ltt01PxM60jL3aYpFNr4EVk4k5z3aaB9mQ4Yuun47izwbcj+VAcFhwkOvGz6fA/TGuJgUl/RlpD5AaGRHVlXlAYgFrcIpyNXzybhMemvi2MvVL0TTdJsXMmgAT7lAKDJ1XDYMXEcBZwP/J9/+T8Bf8AkOp/O9+FOmgQKeD5JVbvi26I58LfbHef5hrUeeDwfyDgxsYDIfWAsOZHdMABRULrSHC7bzqJosiKxQJTWHHieQU2HORJJrdOgcLi0hiUxQdvVOrCt7oaE4wl5Vm1albYO1uB6DL6mBB+0jN73RJhlN5zkfqY2PIi/2nnWCq3u4HPcD2q23I1zexzIGohz4acvP2Een5EwvD+fmGPqNWluiGG71rlfzizfN3g4DTO8zYFxfEbmgZ++PHCuE2lE8+GO2zxIAT3umGPimY1GT2yKaBcFXdhmCI2lLfOcg+smQl3j2jzjKtIThk1xfZW0Ve/ftgsE6HCrAilg/NLe4w38eoFzQm63Ox4RkE2RQD4mbKH3AT1Xt9tWGm7SWvoYuB0HqgLvf/kLfN4BJGxOjHEw6ayUvoloZwk0a4vhK75PFAxRhjOJFM9xx6f7J8zbJzzO/xd++ukvuL39O6Y7/vTjj4i/fEEWNQ+WiSlNyHnShQogaHTzG8/naHRVCY6/bHS5zxJcGUNc/GIRzbEzsk1HASWUm+ULkyRtksPUcR40dKj1Ws9ZwDEGqVQSIJcVKlQcF/OT/rcQPcaqkIu2rWRucEhm60syOFON54GotFWYxQTWBmeOrAx1sa+i+VvilcHxb+08CRWBbo4Q5a3dnBKcJ3SeC+/PJ2df2Iui3Gh6luZn6Dm0i7MDWw1MLgRkZQ/RS7Xn9fltqA12DzOUQHegTZawLXNJ+QqkOWgI0+/MtrbYjMNjydyQNq/4rPl6++oCmUABAHagCnieC3Nw7EYZtdQrC4848XZ/IxsiX91qOtOykHtGyrHrb8c/zByUxgPghj/nFN2k4MEPZFphIhAwHLeB223u1iPbOUQAMk+cqTbW4kj5ITS3hCqMfUEBZk4mKotjGDcAM2NCCAnZG8EwoIRQk3Lgu4XVqET/GwEHBz5M9e1NQfjHCwE0YPPurQsYuQMIau6BbJHAMxeOMdlqq4Jj4v4p8R5EMcc4Pliaindq3BC3ucIVvys+NvvcB47jhnPeeThaIVfhsQrTE4cNpE3AApGF+8EhP+baPJrXCaBXRao9a8nOFswxuWhZuOqwqixRAdnBQ/Z9VPt7XYvWVdSTjmINXuDlCdOFB3aS1oN+mOB9mMyq6rrULo5YPLx1uFcRAT7GAGayrdyIjV5XFPDp7U+AH8iiNmXOAyani8hANqvfJwvxK74p+jp3sdpoFDtUNPN4PB74y5ef4D63aHWOQVtp0QiHOrhs/7dotYSCsRvX3YWhhApNX5VTGlr504lVGawkfrQXvZDrTQ4I2VQ9FcDVHWnf9o+dZHWX2d0wEljGhDJUrGe91jn3cTkUwkQP63OC72mA9IAxxhaE9pnQ9yL98CdOieLNJ93DrvimaBcsd8dxHPjyCBoEmCFjIc4T/4//7f+J++c/vSijxfU45qE9TpQSrcuUorWU4E00J7+Li9qFCCl2oiz1fCdtti461uv3j6nhq1v+OjNSWg3dH5N5RmbPV+C9MgZ4b4ih8TobWusEnJEoUXpoYS7N3S59OicBVuX+DADIZIR3Tir3MBmZ+LXXft+wRpdfX3Knve1HXWVU4ufHU/NdmIN6FUb2vsX9MrSF9pUmlbBofZsEAEvgZxthcLcC0uWjZfqKtBjVyS2wqVcl4anpPXzcK9sdlvlk4ozESmhv733cscfRdo6j+p7gpW2N3LlOvD/e8fntTnaST7zd73is3AW6C60v5equ5oOnS2f1t+Mf7sA8v16K+jHntimz4bBwWC1+GEXRyVCR0oipVSDOxWQIh6Z+k19vY8I0B6Ofz+rlT9LdpKZmmZCPvWJqA7wqQpQ4AkDlLoOsCxnwdfkYTLyaRyohZfYmYW0P2RcZmnQtHYpara1lcS0MQyGTByInExdGsR2djwciEvMgNS2TkyptHqKyiHd6xXcJcpIPzOMmUXfikWtX6QCpR1aFiBNWd1H9su9VVDndKrpPWaWK/oN+g/9AFK4Tr4IoV7IV1SayS2urvR7pxsbkyhpd0+N6o81yT0sV1YmXY0V3QLxvFonLKjmFvYcprbX2PTHtBuT4sPnykL2ZAfYJBeCxAo9T7VNtLNrWsNZCwTFv87KO/g6xkbmvABPqJwBeN88H1vNnjOMzYI7DgWkFOIe8cl33IeWo1JqCDEEM2z2q+c7TXglYa5yGacJzvahKvdfxrmFhQnBFKdUH6mEfos0pLunruuvIZkztwpt0MGzErj4kmKzE+ScPdO3TASADCR6KHEg3RK9JVAWdW2KxIwl2yaPBrHHgGMcfcWn/lwgH3agGbOOHHPiX+PzpMwHIOPeE8rVOvM2b5i1xr/LjYLfM5NjWGrwx9rnuzWzQ+lPahekTxxCgWW17i20pHtV6Uzpt0ewjCBClOs8m0w1zDL/RjAMOWNK8o+ky+PDc2k+zEWcVJJmcyu6DWZ3k7DLn0UwnI4hwswZ+2pELAhSMlLBOKvE6ba74/fHRqYmrSUMfRUNuLVCbY0QGz3yzrdvtfQyGbTXd66JzuQa6UdLYtYzAuqB2uCjMe+8TIJ8pbZvO2bLWby7A5EapYgIfXkvfI3vmU8lJLUXt9i5kALOxc3l2XgQCiCpmzhJlVuJcTxVX7JTf7o45nV1loL20lO8nrLq0+OX1+itdsOxlpdWVP9QV6MmQFby5VCA8V3L4XxnOgFx76EV0qI3ETea1ETQ9BUnxLHa7XGeQxO8cHEOqVamYMeA1Q2RiFxQA8bwS0twt0m6dbcpL9hA6cvqnkBYmmeSYZgGjfHdEDL4HsRUa9S7M6QASK42fSwXmccOnAr483kkD0C59LgrjIwIrs/WbV3yH6Bu7kdWeN/B4PjHnnY4lxkFVsZ54rgdXYcU2R0gbL996kPZk2mAi2VKnjaKSniEraS2YqsTYJEtAljwSj+vA8VfHou1U2BWjeUPjG1mJdZ460NrZiOtzrRPTHVYmMJqbVSYPbquUnSl/lsXJibRFuuSguSC5+YbnWjsx6Hukp2VHLJD7TPrZNU/hO4a9nMU4ayXgteDgIejzRh56JzBYQmYB5MmMyydgyeZuY72pHdsSK1WMlO/J6e165fjASVaxXf4B0NEeGcoBO6nqQmHTsTRXKRad5GzMzZNmglYoC6yU7bMOti6GG6Uj/7kdhXg+WAYewUnxx7FwzAOryNGudSLOBUwWN2cWfff1UdA9KZU4XnTX7xW5E7WlBMiBcp79eCVGVYk43zlPwdkpewbPvxwuloG6INAenLlppVm1J9iv4B51G+ym9XldSdQ3DejJ55s2CGxaXyannWcxwWPPLDhrowJVLHyGOd0zI/HMc3c50M5GRUdNQjXaL9t4pFoj9wJYsff6nirNvZ6uhQFTYtddRv6ciap7JQjfGjufRK9b6T0EskPgeRZNl85F++45J1I0/ep9UxQj7q659+2MQJpE4p2jbi3zgt8OtMYiIySEB0jZYuExKzkvTuf/IF+Qe5iKEk5r7+I1aCUsSn9lYgVffwA4Prx2ZO4iy786vwn2bPaHGdwO3BB4fz5x3KbGRbATyDyIeutRr3PjjKXP95evxa/uQdMetqu7ehUl7iDDpAUv6jTog+FlIW7KabVDAkuTZqItzfrNgz+jD9rtJRXcBcG+N2Ut1i2eYuW4Pvy9xWmAISM1cwHcFZ0j5JqfzMoztUERzSZysQtHGGq3VfcgI6F8pBqEBhtypkjGSZ2HT/jtDilGNtoYCaLJGUITrw3mW6JRCP5ROCNwrsUNQQnO4+efMccNt9udSFYlBgKeCwbpeowida5pRyLQklwD+eN98A0f8DF2YcxamTdyZiPQLR6DHoFoQvvJm2yl4U085M3M20l9O20qWSlhI9u6WTwEWSyQe2kQ7UT3I1GXqUOWjkSeD9Qq+PEGsVBRoIYlVXi4BMHHoNgNxo7QbVCQWR8OySu+LT5+intfMcdK7kPj9gk/TBpcRCw6PlkKfw11OQayAufZbXfHIU5vGp2tutMiEBl7AJzJY805UPbUNvrqzOQWbTbVaqHtnGvPk2FHWDolFbvDhzow3PO70NisLxXH/b75lVenBUbnNa+uvXjIP/KLOkaO83yymx0nkI7b1DBcG/DDUWsh7Kn7K1CXpek3RfeoAJ7Fa52I9YTPAxEsLgACMXPKDCYDNRxvxq6VCWR5zyDlxQ1Ik4GM72zRChTnygymOxAZCz5vkKcMNb9CkxuHWQWaD7hvuiIBpsUECk4AyBrJ9b0OX85YTT0VoKOl89GoAaWETjaoY7jMHZbQb2r9rPaODiSzk8LCebJbN/2OFJenwadNvbrAnm+OjQeabUfXKScpAzDngGXhXIHnWng8n3g+Hvjn//JP6IHRWQVIF1oyNvi4g/egv84rAd+5QYPMthdsKq/keq8yyfcMt7fP+HzccIwBNn3XNpChAZNMOkKOnibNXDmbA7EE1rc5CF6Uq15baFtrnQmoV7faTNqQiVgnaiR+uH0S9ZHvc04VbVnI8g0o7Y74L9AGfxMJ9pWESy3vBp+T7foMNnBEbXFLrDy5ERRpIkPcuZ4ObkIGurNgurkTFNSO4Rr8osR8by59Y5Za+0rrJTIku+VrilTbnAJy/LFCVOyNzHmKaepkYRrbUoWeCslNzCwxepsyepSjEitS3xs64BLP8x0ZC/f7D+InT8xPk5bFxbZfuRJLaLzNLzgGXPHbIrLwOM8t0DYAPm7405/+Gff7J9H6CvMYeDt+1MRmqKVJBNasW7OTFCsVG2O7XvCg4cFjOvC41uhMRZ6y7Rt651PodmyL3wrsIGoJqtMmodpGxoPFKl+6OO++NzGX8QI3wLE3CUPBlWhWBYYFUA8gCjaHqD5Fndb5RFbCi4LJOQ7eg01pzMDb5x8Am1hZojVc8b2iDwWuEW3mNmHDcNOQtDAHspG4EwO0WTx8wscN5hN/eZy7EN7Vhr2KBACiemldqvNcMEx3pEu/JFoisuCbz9sCSDmxOHCMiaaQmvU+HTgmu2rt+JIfwCYzrtk2B+kuSRU2Fff1dZcDG0HkYw4OC1vv8DG7mgJgcllKjOmbE00b4IRXcK4KLgrW94q1Fv7yl/+LtrZyn2SCNOBYdBREwob2pWRBaipKt7ZU5zbnaQyZfBhG5t4UewzbcMfKBSTdzlpHx4RSiZmJZm3g97hLSA6YF6ocrSFpK33zLoGbTkZAsge09etQyrDBRHTeoTNhju6q2J594yjawJu9aGlFqswBxzEdFQ+UH3sCtsvi1Wr3Xq74DtFdjGHtNPgCm6cBb3PgOScyE4cZbmPsvdKqnbJiF5cEuwm8hNgWtvdDE+DdWuHFtQnKFtjBk44OILAP4Jg3zbA7SKc6DU+18lpHQt1qySZYYECmio/QGiLldkiy18A+ndZeVLHuXhIY7VdT8DHxpz/9eXfgu1CBGw5zAfC+HUTJtPCv5BR/K371HBBW96ScrCocxomg8zgQ7lgndnfE1TIFgIwT61w4JDjfEix1TjaOIu58dLtVg1pQhUNZWw//685J25FJjg5HwNNx+ODkW3VqUh+Cc9oastS2EpefghkTS6GHEalP0T7hQp0nbCd4BsN9AI+ewF4FIHAYUAg8Hl8w5o0dIFHG+jPl6GEdiKa2c2ecV3xTNJJaRZpSwGHjxlbikQAcx3HDHLbXqeXCej7592Q7vSy3o0qn9xzap+TQutMHObGxiHZR/yqAJc5x27e77oG+WSO7ue57Xc7uDlZTRsA5NqIJWhXcBhsmBhze6E2Jf/lC6axM1KzAGSFU5ER64T4mxqCzxcqCx4nHWshcYBKXWr+kSBSYaBy3T5jzjoLhsZ6aaHzFt8THvZabe1OguPZ6Uv2mjJojwJZ8JDCqpN9xjCIXv0Crb9N9UHgJZX3v54Up56AzFsbkXmg2MZzrc2XCoqmBhUOOg9Q1vkTFFFXa7lI/F+fRjNFJIJHm7EGcWZxcTqbBpi4Ova7hogL4FM3PNwhQ5qgBoNp+N3AbU8h3CS2ECibSFtf5gPoqqL3/X/Et0V2QTuDKwOGnLtTeJrwH9Fb3Cmjpz2KEa7Zg2lt96x82v707xKJcF9gNqyzM2xsFvmh9xsuIg2lDKA8g2GyVSDm0RdZLv2bqxjSVqrgHh57vDKLLZupu68e6aJra+0cbNWzgk/dvz4La7Fhw3SMTKBn4HJPJawlKMtK9h8xsIs9LhP6N8df7LHxgnZzBNgaTfrpFMhc7hiPmgE3mo6TEco/LCA2cLNnP0gkOgPbB2lb4aS9X2NL3dd5wOPPMWLGLa4D/9po0XjgzccrutgRIvjRJr7wnkkD6mQQ/exCA0FQwr9UzlKHNlLoI93ZIgHArMxyDph2hx3quhce5cBcLgsU4PwMzWqx3d/2XvAb/4RyQTi36Bcqggqisk4oyx8Tj+U63HO+Ev7bQ5hj+QvT85ZkM8e346fXWVNqQJMyJFA3kw2vRDd2WdLtdahIJDR1WPaOgEeDd5ZB9WvdRBBC29Vq7tHSR0fOgDfbVhaEGJpGRKqYSMAouvRL34473M/Dvf/lvWGn4l3/5V0zTRNRGUNxxjImMxFmLPuBXfJcYmzY0KEZUF44HGF1zkPSpruLGH7J1WBVM3qCDT4dZfkBmUWrFalMpdHfN9g2Zuta02evZCtBr0rpsNyIYNUrGTkxAIriiDWBI9L6nBDsT0zlcGpTSBFLfJglD3ZYBTlw/1xMZC2PcMI+J437DKtlPq8ihnz8NHyBAIM1hQSvu4/62ke4eInrFtwXXU338Gz9jdwATGHRdKYEcxPe5cT1WYNbAnvYM2naq4bFddfpxmUAlRgMxUbDR4JLJXhzwcbDLVkv7aL9G28i1m8m4owtoJnal7vIYh6wdJ7rUzqrdJYwkRaYPyP08/f5V2LTX/pmtKTDYOIAEYpFa6+D0c8uxpwNHBufczAkfB3U0Q/4vl+X5d4vhAz9+/hHvz3ekyeFReypsvM7XIrVlhQHBWR1L9KvMQm4Hwt5fmGeYkj6Ycbo92MEY84bKoEAW6nSIM0VEmkJuGPZzHNqvoYKji6B2T0s9xErTftgo8hSLg4W5sr79syWXrA0itLFMYRckXPvMHc4g7abzjTRlOd6WqqZOOjSoswC/1uy3xMecFsBmHrTIfEXyPK3UQNeiuQXoesnZICb9kH6JLvg681vE3Z03ACWWgvLRj2YFzc7xvv4o7ft02IpFl85y29o4gPu/vGz2/cKV1fk55+NZBdrEga/zQ9GtTodJj9V5frM0qqBu3qS5VJDW/pefv+ARiR8/0cjkNlh0jGL+zJEXCY966cf/RvwmCpbyd91YheE33SCBt9uBf/v3L6Az94BBFolGUTcLEA1wU7X4kW7kzfcEQFYmXhy2SEx32X2qLarHcbMXOuevKdEU1+hVG1tQxxCanX2AQ8kmByN1x2TI9aURFT1ql0csjmKxKyNqQoUQ6FEYxmrRxsQPnyaePxS+vL/jJkrDedJLul2FrEIt3qVK+orvEQ7D2+0uFDeQkXg/T85dmQeTJ0D6EApmT/nNZzFpK+fNPTQPxKEOQ3HydOs1oPXCgT1cg5FsTUajJZUImxJjhrj2PNTmGHJIEc2pOzgVOJMitUoW8bSb5O4wnE4rCd2XoubYRuGATjwhKmRvEOP4RBc6oeK9aQ4jNWUoYYhcgB/kgo4Jvbxd+F8UrO8YQkPowsdigzmOb1oSRG1CPrHiiaoDRRUTp/PGg8YCsD3TwPCi0FnV7siVEOGUPXpEoLzbgi9UC0adW+UimocNe6EZ7StiJ2wuzRRpjvxedkaoTWmXxBVdVJWoAa86bEM91sjcgHlshNCNHb21FnwYbA5MCfAr2PHrw8Kdc1FqLL3a+scKySt+dbg7Pr19xkrgqc+VQ9SYWNHlKZFrYa0AbGLJoYwFSfH8tjZBEL9+knoIoFlOcOtkzeViOCQ2p4tl8/R7CPFwGb3IAnh7M+hBP1qXvpobJtYHU1YOL3Z2jMPhXkARcB1uHKopdJjPlVuLh0wkB5EokcwtELahdW340DVhgWQoxHrKQAIv1P2K7xO724zdDR0md9IMPFdsSrRXodYT54p9pg5wMKwJrIaxqDZgF7FdaKANLz6st12bSLtxjAn3gTMCKx7Mm0UbtMliot04e+fimc1pOKXF249NwhBzyzmPretoALyprG0MsnMPGMxoMuOiU47B/Ps2Crcx8DYP/OXxZPGt/Zn3HF9Za5d2svB34h9TsPa14ulgFD4gsniBdLihCrfbDY/3n/Hl/QkfN1ZNBk1CJPKRDhxGJX0PUhv2qkzbuai936P4RuL5BJJuUmVMhA4NkupKLYvOGKnH4xRHouBDxQpRt9yuU/0AHBQDtWiJlIQQRTZR6R7jzmFFKXthOiYZE4KK7Rzoshaew3EcA58/fUJm4jxPxKmNS6h4xMLz/cn23rx4yd8SX61ZED0bLdRyeq1FJr483pF5ItLoslPJVrlP2nVGF5mJjPrQZqQNblvv0eO9k3G+grZBBVLOFXT6WWrXum74o1umINWKfla9RoVihw7sIlVGcuGXmBdQEhYv5xhzTOspwzxEixZ1uN3eEBl4ROKodnZRt6hYbrsMFligBx5rkUYze1CTBJnZ9pN/xJX9zx3CvbTIult14nk+dQDoG93g5TgO2wBM1gH4DWmD10LOa+6DttCJ11qWPeiBCXZLOJiK1FRwpMdiYmjg8K0ziXDTBARIOaBx2CbXWASt2JcK59sQYFMBr8LqhNBdBYg6jcGunus+7RG0u6dYpCZkFk45E3JWQ3KuzZIBg9BCb2vqpFizxpTd+UmOdVBLoGP2j77M/2mjwH0nbXDfElUUMDqUBUCnP1cnq7Ztv7vBRGcpADZ4Xq8ynBGbLeGiImUU4Fojrlk4mFhrqeuVgJHaEgVw+0ysFYgK5Jg7vyhPwMcGRV/GMtgmDnPq5iu6HuWHRA9tycoKQjmMklnNdTjXiVQxcq6k81UFFqsprFQu9FzMd3zg7W7U00TrPmw71l3x+8P+xt+qwLVhdNvbOaMFns8T0w0BApQZSyBJsalhYzuWub/O7+xCF6RFh85+AKJFcZcj4yL3+r4ZNdK340CrSHZh2md/A+G7Y+HUEwlYp76jUMHX2/k1GkYvAOBA4QIBTD4eX2e6wTD3mcOOCoFy3r98PW/3g8B90smrcu336I5N3z3aRfFvxD+kYHWpZRKqzOHI4UKvzu297g58ut8wHXh//8u+vuaQJz0vLgVeepFKxOgAUGhXq64Nh+u5kujIWifW4x1zTt3w1FXsahCvIoZbH7sgLRg26ABeJ9Z50l97D/Fi5Tt8iOKiY7BKgtx4FUcfERmJf4GAawFzmqsjitNdhx2kaelxbnNgGF2+yuixXPGAlSPXtcF8S3DN6kavdtHhhFHAMI9DGiXyKVeymLiNgU9vb0QUqrCW3LOkh9hCRTPkemLMu4bAteCy9srt9QbvKfe5DyX0evIWlRMBYYnek3DlSCX603AeyFPiMDNsncjHx86PH8IH9LoqQN0V75tjHnh/f+DLuTDrQPqEY26BZmYAsVRYDBXXkHuLf2gVQ5SE/+CL+r9AvO56QzsDlbk6GQm33MgWZwscABzPeSIfAYpp0Q0DdoznUELfew3Fli2I3U9cC6ixUbPef0OUg6ouMqkXgrtsdSXqBYC11HKXva0Wd1YgrfQ+6MyS0ntYJ1TmcCWmm/KanGTtpeLjGRjHgTFv6BNkuu9OZieA7UTXn0GABXqeNB2ZovP8sjTyil8Tf73XnlmI4N+piaMNfw+P7OR5+MCshFliwmAOpBcQieMYmFOAIUyJTWza9nb5MZermqxTwc4wij8TEuKS/kTA8/DC2HuvyZWIxWsVdXqFl3S49/Zelz13iaguXi2Z3U3RH27wbB0M77mm+Ng8qNubb7j72Baw0JyeOJ+cPO3s6PHD5E1dbZJyxe+Oj5drXy8Q0ItIhDMXoFnSVHduaV5SyQ3ytUYoFZBWqF7OqIDofx+6cTrsQS1bbdApxLEpURCHD9yPl7tga5h0qG/wse+/zhMKpHnRUl3mISVHK6cAvVkahA4JoNJhCcpx+P8J0rZdeXBmyPCGXQ7Onk08nifOtQiyTsft4GeHEF9I3/f34tdTsERpug1HTiYpnGeRcA0AYgLPTSTLdnfE1VufxwH42Ak83/drwE7tlifAjiU5yuSzT9SkYAsoeDHJN5Bb/OLEi9enQ3aq/e9g2zPWQqxT15LcYmoBCj4nbhLP9HItecZDF8N0Sluf9AYgHxhKClGJMSSarIWf3/8NZgNz3mkhCR6sFG+S0oB4sP1VH1p1V3yHKH6+Sbqc+8tNZ6m9ehc1g65ucxeqFHM7lpUOUaOQtxJmwO1+20Omes4IALVYX/Q9M7q0QU5VPZSNrw60rIsAimZ4KSHuyxqai2a4464DybvNWq/ttJ+zH7dFany9JtOH2tOss4DnKthwHONgsirOqsmIgW1hx9vthl7se+6HmXijlwbke0fPDTA/YIN7nYEtf1qJch2UOca8YcbComuC0icCRdQSFtoiV349/LvW6SufaZEtv+hmnDfiE7WWWvcEZ27HsWkHPShz6iRZHuzkoucz8WzgMk0dwiZnQdewQttFLL+Vh5yrcPJcsKTBiBWJLkxoc098J3OVnxsBgMnuZC5RXPu1TJhBr+3aa79XRLJb1jQ8aJgZBLCkOr/NCp1u4DDKABz4dJuYx42mF8V9q4ZRewb7sL+xoOmOGZPHXjxytDJDaY5RFuBjbLZECjCsIqjJx9Ob0L42TElmJ5L2yldyo0YyttH3Mg/InSCa1nuW7hM9/4Ccwcbc2gEyMbgWj3EAmS2J3Xt9ab3/NYZ/xe+Par0jIAoeBOh9XVue51M5rsAZ68SPezDz7A3p8Lr2uYxXd8TKZHDTwEtTVNuK+eWg2Zbl5s45YqYOovZHaumYL0fR3nfMiYoFDQIDwJxnTlK2hxhM3EO1524Ale/FxthFR9ux082zZzSZgMjCYYnDAsDCGIYf3u6iCgftggUE/dKa/RUuWPiQkOsDcA47qySZd9jEcLaxzigenKCwCnXyIre2wTm8jB94O6uQ3mRCVpsKwEXgSvQCjgMHyKE3n3SCSdr8Hk7L0Szy1QwtxiEn6gxWcAn+7DRWnu6DwmQrFQeO0AHXSJ33oeYUmQG86NMCqCfOSPhkuzW16IaTEzp8YK2FL19+xr3RupLAWIObZJ6KtCGdyxW/N7hm2wWrkzltEI3iKk1z2NZAmApbwJUjuTaORK3ajz3HwNunN8xxyC2FFf4pHpJLf2FkC+DkAkVUcY03WhLk8ROfBuZ4ddxG8vA7z5P/Kr5zz99JUGeyszbRDqo0m8cGSoL6JQqDgffncA7BLLla9H3U7iqZpMU8g8LOebvJepL3VIgeVhLoRRXmuNbs94jt3qb9Z1UhylEY0uHwek804kazgDHndtdB6BoWeNA0amxtU0vPwB5eGCoIKoUFb1tw4BgD03i9pw9NGzEm9rab7US6bOzzgiAa9/MM2o129xigMNndME1dHh1Qq9hFdLxQxB746ZrKmxl7Qu9GgMxQrm6khMQEEE4CD5Bzokm8bKRNXkNfvy0+7rWZf0VNAr4yfQFeblCmxKhziyhSlt3oTNbulhwUO1CgEQekgYsqeFIjRTxZr8dEs06DealrywRzuFwnkzNqUlifSBgaVNwuXQKqBAINpziZruqvDtswlx6P3ZhT69ygDh8AK9KqumvcsxjaKS6L+3JWkk0yBpAHykULB+2r+zyzX6CzXPGP42Mq3NcyBAomDJGBZywc9DtlJ2CSlp3qdmDnq6bvaUYADTmG9rAQ60elAEEgM0Tkvk8KZDa8oGfDSu79hxypTJStNk1zK9nsljoYA4e+Z4GGO5ZAdzNs0NAgkut8ZecypsfjuqIG1TgguSAmkPIh/ReZyL1xJu5zyAWTDQbWVQMYEz+/f8FKGk38vfjVLlj9lVLL53U5+2v8cN0n0dEPLhGlDxomazLURjDoM/8qckwIbG9swsMwBzeoaURdwwZpABlYT07ULThOOCyJsKWSw3U+6DY1J8xSSDftS/24EZ1odNvZim20uj8HyuhfiAsLHGF0nbwVeXUBvhYbd2pV4Hg+/4JzFe6T1AlkqKUqNNmMNAr7JdOyK/5RdFsSYLvwGAPhrq4V0Gt2jOMDdYidkioO6GvUGAANBtQmryL/HPZqtXZh0VqI0MFolnuuCGsTOZuUAWtp8ro4mT73odaakIjA+/nAcdw0BJRoh/cd2bWHXkdvEm6GkmWlcIx9z5UoKY12lHMtNjXCtDmea2GdCwFDzFT3SHqDJPLXgk567V9I8neNkiNVhOh6AHzQ9ST1eRe0bzD5WTvpoz1t7GFnQnBl1cy9jOuj0bDoNWogv15AypD7IMEXmnMArwSz15xesu6xtkcvuXYNae5IidmCRXXlXpbRBup665XQghaOfXbwnClgMDk9rPD+/mBBY056iws915TsyoC5tFhWQMU+q8x/kwfLFb8QYzje7jdEAafONgIxRHiHdDfo8z7kFilqbGQCCygn+4HOaR+qFHUXutDODwVtO11CBQSLSwI2KCXs7qKQ0KUwQZMNFN2EOhHrAoTFTImyQo59xMsZqc/snsUwhmEmi+iUvTodBCm4b8thN1pjo2hTjQZKhWp71csllNA6Co2of4UGX/E74r/LacWcaSFjJk1pCLSQPgdX0SoafUEzOzZITrML2+tR+6IKW0B7qTkMifgoSNfexn2z6X48zwlS55YqVL3yjESRUqsuYOVLXF4wzqLxV5ejQJ3R0Osz993mIeijIqj4DRsME9OJ+y8A9PtW58+x6bXAS1YBM9zmBFb8Qv/jN7pgNYLWLZkuJPiWa9OgeInZcRimQYLxxCOfeObAp/sbbscdPagNpZtd7SB9CpsnN1qJrwGBnXBNp3XdGInzfOCME88s/Leff8Zwx+12x+GOT8fA/WD34Uwmh+1SRXtHA4oVYuPjA2rDVN/0QgrV8jJ7LTIKlRPLKPZMAOMAjvGGJkUYoAM2YKJbkVOaaDtiMVl/0yW54u+HASp0ifAKnN2HByyReaLWiYonUTgNv6pYyEUnnXXmPpS4DohxYLtJ0CK1HYpa6FuV4rxrUJE73AaiEs/Hwl8e76hYpDrdJioT55POEjYmPn3+EbeD9KfGvchY5rsrcZIzgjQzgB1GDCHGRveV4s9wj6VN69moxodGyqYWojfqdj5KwNmJ4cT1hVCXBhUY15r9rvFyAoIGlZXcVILFpfAw00HADp5AEeNq2c0xtP1poN11AGxQKGWyABUGTUPgOvZuMOClcipNvFXRYbad3vTqtdblLBMLkUvFFOj6o339xY+WD70cW9j1CLgNGQDxvWaVZvDIrQ0UMT9CGKQOXKKaNGZABjCadnAizoW0CZ+Tjm5XfJd4dS2MXTtLrUHbmkrIGjpBhyz+HG14MwunG8o4W+ywuYvb/r6dWRQLnPzQbWnwZru2qVjdK75qF76uxIupRqkT0hQxcSd0//VzQkVtJvn1bkMFCvSLhYWH+Pi5KFqugk92MdEFCIgyA13wEDG3Tmo7r9BEm2ywBx+JPld8exDQY8FHzUSHqXs3OjezpK5BhW87wQLsjHA03/gAyn1YT0rmp2iwXrKcThagwOz6WdRYYx6ZiWcsUk0/FCXuA+VTDpoqyMGOS5uH2H7dvDfbmMGsG+kNFtlmlJmKDwKZzFXTCnE+YBpb0HorNATvprmc6mOb7sUsaVdz36N/K361C1Y3YWixqLFsugF5w5BqYkrSSb4kT3wYsPKJ83zixCe4TyQcz7Vw+MCU7qK7C3KdQ88Rsbb6Mo7XSgnMpm7oebvTQ3stHDD80w8/4n67EUVbC7cxVCwQgaMY00UHa5xQE4JbvAMeyL2JZQSaMtYo9c21EDFEiQCeAYw8cSRQdoN7gCLSCVRgnU9AFWcGUZUxXVZ7HKZ4xe+P19XUik25WWVp/kvtAVeoouPPegJxIjwxx1RBuTixPqnPoANLEoGNRlNNjlEJyEUDSX5vDd8FwtBrMePMl8Nolzpg+PLzv+Pnv/wb7m9vAAzHnPjx8w+w4w02b5hDHvpdaJiLuyyEPBYQJzJkL2qJAgsddw41dPD+WQn+3DoRKzHMMeddO5K6JTqwezim9yGtX5GJ98cTrVAxA+Lypv/m+LjXEsgBHBTTRiysXCgU7rc7gAGzyT9bV5QsTNqq2ao0n0O2khEqvqF5BUTsns+nKLKkcs3BDt/q4lmlB/yDmNg4mC0zyREO6j6m6H/Uhfh+XrpvUYjuon6VKASBsa0uQ776UCcZbWCiPZ/7bsCiV6nu91h4X08MJE4jjWIULVnLh2ZE0GI4IrFqweaB+/2Pvcb/maMT5HaYDFGeAYJA1KCpwxWFLyfPueG2Z2pYFm3Px4RlIXN9oLmQg48qzsQAnbYwSBPxZlPYi0YF7f8hN8GpbrK5uPNZcsNk1+GYc+tMoM72UjF8nidWLGpJlfNYMR+i+1du+hU+FOhMxjqf2OXMpjm29mCt2hRaWjJANPfCmSfvAQA3v8Ceb4m/3mddnYk5HBxC0zo7giKl9dCgywv5L2AtoDTSIegOmOr8wYB0WfIDXzGHSu6vGYEVgTlp/Q8QoEGDfBH48nhgrQduWvsww/12R803AK07bifMk/u8O4bPXT2n9m3OgxoCaXj/1Oj5Y7Ep4i4DiCk9yON8ICpx7E+Q91SKAgxwKrx8h9F6pVTO9Usa0V/hglX7LyXh3pDKyivpVAJa6Hm+krJjDukrALsdMBzEXiXKyiJdq/nnNlqt77v1urn69kHYlRrsthKP89SIegA+cbzd4GZ4Ow7MOcitlO+7xanDkPqMMSZtJNVRcTdyR4EtChrDuSmqpdwT0g3cYAPAtIFP90+oPNkC68kz44ANTkE/fLLD8jjheTKZ7TRZSM3hQ+j1379YV/zj+AofKh5iKUcnIl6GctKT6O5Ee1LTVHrk0jqluMoRuM2bHpcHk9dChZCItpM0djwqiUaw9S+ETFaNqbXnc8L9z8jPP+Kf//lf8fPPP+HMwA+ff8DU98J4MIdcM6hhWS0jVgdNE4Wz0RuhGg51H9tSkJuGO1FFd8efJluuP376RLejXIDQEh8DN+OjjTlh3lNNuf3Q1u9Fe+jN84pvi6b9tWMKza6G6JqhFj73zj3nwwxzGKeOS/PRWqLI0Lop0QrEbXf+3QVZ9T3Tjj98DB4wjdFWd9H4nbRXbytc8hbYeRuyFRE6SKrXgWPYTrYItLGj1gM4W/xZaL0HNXccdsthg1lc7/V8IuRUE0GwIOTIchy0Py8f1K2Eo3CSVgmwUDNqT1ZeaPK3RO3fPoA9qdkssbgXjbGLYqLFpBn7OBAReEYqBwCmFcZxaE1AYKDt5+p5MS8UFtzj1X1mt69ZE45UlxsfuiDtOJjJidfnOkFzgnYYfOmhmKgVIiTyHZPug5loswd2YpIAqNBvM2DOAymHTveBQzlJM9MHCtN835/uATcCUIdMUNIHItTJUZfmMqn5tvhIwWoakrlJ82Gb8iQiE6bT/gNuuPlUOlwYY2IN5g6RAuT1uK7/b4pha4k6eW9QrzsRa53UKIGgTFUizifW+cTz8TNWnCgfsqweCNNrHC5HPwq/1zqB3dWwrZujaUNhaGi4SDtAhXQlseUDcwzRxcAxGmPgpvyiwfrI2PeEeWudCpWmXp7oZ9Xkwd9ZgHx94Uqdgf5Ai4dK6WYUd57Hidqr/fRV4kkOzCRqOsfLKSsz9s3fGMHYwpncBxdAFE3NFTwfX/D+eOARgT//+Oe9QUEdi91KRfPViZCMOcXlV6UKbiR7wFF2uknuKgZ59WfUFpH3Qp3D6BNeB8444QEAQvnWUz7RpkT4JL8VIW2Bqe3m1KV8LEyu+OaoDU2E3KXoiLK5udrop3N9ljaSykCtk8X2bC4wAHBgG4vhV0t8NtIAgA4QAcfUlNFGAJqT37MUgE9vn4AsPE526Y7jYCJn7ZoSqLDtINM0B24wzTVOVBSQiTnEnQZd31xDD9vjnoe1oYbhNnwLJZlgaoJ6abaPD7Vs7dVeBQAzoeS2E0ZcBch3japXt9aUCDEZb72Z3NI+oLW5TnaW2wUI2IgbDyt2GoCmv6jj2l2LPnTtY5v+NRehO2QODety5564iPyy4OUeat4ObLXnNDQVxoWSm5kotGDBn7wfhwoLazTbHIXcU30rSnN7SL+a0/Hjp094fz5oi21MJG8H8bp1Ap6OqkU3xcN0aGMnt1d8n/hYfEQsJjvqxFHoK3dB0zrWvC2e676L3yH6Ctw2rfUjba+sCaKvvi0ANCbSnYXbGLTDN+xztqdYd8fmfky4aYqztfOV+if1OouZbPHnXcW1KSehLqCprkJ9pcPLBjcNO1HjNO2217Z9b8BedK6m6ngbiiw5uf0CmnzFb4tOjYcZwqkvJor/ug49iJKdXYLfTc9quuqS65+hsBAvTaUev0XkNJAhyDcGSS9VQ8n/qbUDxHnifP6M9XzHenx5bchlQC3k0t44BlBkbKzzIb3b+JBH9zrVHqp817RfJwBUbLtg+MupDnLWqgKOeewZI5lts2Siy5bcDFvvZNrLX02KHk74t+JXuGDZ5laaT3DiLucqVA90KhYdFMgksL7A/IYxmVCvcqwciKBl6Wwp7YfEJuXhDjYi6CRgwKmbOvGhQNFmMo4D5woct9vWhpzPB8qAlGjzsejmM6pocWdymtBJ2wdR1otxWno95MP5bos+JGwccNQ40C+mTJZ65QgkKt9hGXieT1S5NmImpY0mQgVRBjjl0uS1f20w3xRfrVknEpo7kYLcowrAa0KCoTAsERavayO6yBiO4QftOwt4JlCyoetCuO2VAWyePQtqpygxmxrgas8ntp89gDMLfgw8V8IrMQcpWitSNbKsG/cpJs6wpdRKND0YQseJ4OkenUKVsbFsdfMCUYX3x4NOROVYK/F+xp6zQzc6bXxmqCKCWePgy0gmk/7395crfmV00rSngjuH8iUoYB0FZDmAiSom5qlCJIuIq8PVpSXCusCOxpzdaeaedj6f2EYfcv+rCpznol2pCh3ahSdW9IFDelN3aDggccIs0PanPOxIm+XCsBewoveW7c6F9tByWgoP1+wI3lDUqAAhzYdbqrB2+LBtrzpkrkArbds20zzwacmbJb99E5XsK8zyit8TnTTXbobqL6VuweDeW1kIoyPfNNkyo/RzzAkAfr1nZ5CK7YBmGrTQ3EQAB5paYvAuqPmwnc7LjrlohavzgLanhihSVW6yUn85c0q7VMQhQ4h3F9SpvXULjiGtlmaKbHJgaT5EJp4ndYA4bnQ81JiAwks3CG9mCB93KA/gQOPSvWevg+aK3xX2V39xd+TirK+mV7UhR+cRIU1cQWsTL3nAKMIytA2XSFwGGoXu+mp/6qLZgGEDbk46bBXO84l//+nfcTsmMhJnDcxxwCdp1zaGBgBrKHY9EDZh84bnufB4PnGfU/sk30evXUA6QMi9Fsxn93wvGTNEvu6RlTJSQPLMN2wdiauQjyhYdmHjW8he5i+mBqSp+jvxqylYLEBIE3J8QIEr9k1XKEScWI8vGFNy2eGivRzk78puz9FtWaAw5FhVaEcztqhe/DlYd2RLfGLqJo5pGMcNJcuyxxN4rhPHLCQcp1paY3AwV4svVxa5oPqQ93NA0ym7Re+lw5WbBgcROheYxGEDtBluh4wxbkKiDbFO2VBCCa8BPoAiSlTVlSTIWb5QuW+Kr1qsUNfAJwzBQ3KMfUAAIWSNSNN2CqrA4ZMaijFQ2iysgKHJnyWu4+66qXWPRrxKblgFNHfe540omhxgHmfIms9xRuJQAmZuyEhuDOLHUyzZHT1o82SBFCmHLbySNhToDPdkJ/A2J3pkJulmLvu/FpI5zqX7U+5AbtxAetIrHB8txiXsd1yn4veJj4grLRRNw6A476iRJ/47MS4mPpzWbOYY2euThwm8qUy97vPFcYZheO9jRGLXChwagmU+MKo460nJUclUYZiIgc4ivvdP3gLysXfut6ZhnDToUCIphHgM6gHTEx61D8oy37MSsFgsQ4yc4a7BYN3mZ0Iw9b4WOH0bwaJqTHaNSodsCa/Mq3P3TfHXe+0Qnfo2ZUfq3DMj20lv7E4CZ3Utns1ODv5xHFqX3HuGyfLTCi9j/dp0UGqDCmstYNJql8oSGisUvc2xBxMnXS7dCQXGBwOY/v+XbXs7bWUv6tf5j0aXGVkFz8TKwFoLh+z2CSBANEkWy9Wd48w9CwIo6VmxxfVsVspwASZGCPBRKH3F7wxduu5mRObLWrzztIK6G52Ik743x4DLSqo7xrf50jkkCiu6s9f2TNC53SuHnY6mHWYBHjRG+vefv+CYB+bxBrc3/PjpB6zziTrfERopEQlkPvH+PLlHjhs+f/oBBQgQImDYxh0wrnkYrXb3vqm1ZyqUjg+a7tZadylB0TzPFJmaS4Nl+yP1/fnp/FFu8UujJX6DDciuFpRc9YfKtxDyqudgFEesAIy85UwOW3NxHr1blXLx7luqm/Q7w/mAZGSxuNlIREGDqJwUGgcekXIfXeTiG5O5FWo3CfXrCb89yEEgCJpPmlDrF0W7QGOb6f351JBBYEUBufBIuhTcjhuHa4EWwAbDKvLuISG0Dce5FuL8QvcjFSvM70yv7zoUv1voxvMxdsFLhLZRXyCCg8qm3KY21QPSbmhabWMBdGzhuozqCh/b6aq7pdN5QA6tcupDQpQUHrLH5J//9c8/ciOM3N7h7fDCfbCIBKI3DjUlnEkX3DiUU0ndC9E+ARSOYyJK/9ZdR4O0VkwqUaItOmd+8Iklgk76jt+PmxIHoKevXrXHf0wYig2Eyo350jVvITHpSgZsh5x2hrLQ4E00DcRof6tHRb6GYZoEGa8J1S5r9A/OQWrJu5O6yL831YrfF1VyJtK6hWkQq21KV9Vr7QIQUs17hAYJTCSbow8/hIg7FqiBWRouZ2NgqGtMrUvqcxKynMl7dS08vnzB+PTGWT2LWrDWg7nd/sAr+p8/TKYBdJE0tBF4D+qroHH9MFKa5yCKigpMXe+oV4etclHfxkcH4NpHm/yqJBK0ToXoIBGJ53nifiMN7/F47DU95sQPnz69EsNiJ2WtAObY+QVp27xX9PLlVFVCtYfo48W8J4FznZzloXtgGqmKZuLTC/Chy9sigCM3t1Qvvt9VVQMMsRM7fOjuXPH74yuui/aliKSgG9gdrUBpyLD2lGxDIVJKHZybNNz2vhl5bgaCdlX0gxZeOqWy0VcaBuozfvj8Jxy3N8Ra6u4aRjE/yRrI50lHKtO09Psdn44bMO8sLqrLidex7F2w778DL82r8pLiZDF3AV6ArKlDOqZ67b3F9Zy5UHli+m2vWai8MWVLsHb+/J0FiDqaAHiTRpDfSc6vy2GiEEnv7oBj4UD6G7nBVoAnkdVKTH9NeqxMhBlKFo1hnLDr1hNLweR/I36g60/PZIAOTFVsU3zSHIPUAWMhMNywyhGqNzjnINCzHW5CDlMoDTSEpQyoXGonDcT5ZIJYQZSxEojE+Xzg8f4F/7d//hcejOaYoO5gyD3Jh2HakFtRIlfsScQ66dn9MLs4nt8YX316VaQXCeFnx0LOPtxlEBGoOOlT7zf0MMwAh1xWLTweTx4EY+BMV/sSWMVOHoVoTR3wfQ1dltVeAGLxXnJSR4YPHOqSsSXLZltbiJZOxwKwgkL64dD7cQz45k3P4XgC2zwBuZCV+OHtjkALi4v+46WBmd1stJaJkU5DKiQ3EroH0eVrRWFMbqeRvXG/kssrvi26KOzPksnPKc48E35oz4oCaii9Kw0dNNA5aJ2wDIoHjztgpKJ+eZ563Nq6jrZYNlDYW2YbgT7PE6V2fENF/dqaJ8xOeO1uWMRCNu1KFICCsYj9q0VyyviAhRDFkV30bNc4kIoy3ZCLhdKYk0Nf5T5XSWfBZ/SEG8NDM2zen0si+S8oFN7PE9OpLeTQwstR6Fvi4177UWfZHf0qnfeQlf7WkJJmanZDueGRGhT8DKxMHBr8Rle0kOGB76KVHT49rw+erSg8Hu9wMzzXQsGwTq7586Sj0HHcYMn5G/04GSce7+/48njHn//8Z+7/evE9XPamLkm1IY3LwAaFgqyFZaqw92DpSQ84TpLtgbaTjoXz+Y4wx02D40ramD3gsxPagOg8AOzSiH7PSAFr3FPZBR6202cBilrlTtMkjoQoFbvYXVdz37o17suBU1qIcgHvaEoX9XJQR5Z5igHzwKdJw47j4Iy79/efkOuxgdF5e8N/+dM/wccNdvuE2+1O8L/Y4VtB+hfcP6wU3S/1IkS1+KG6+wdoT2zJQQOrvCdbe3pm7sLb5K7JjhHfTxfX0wxmMhj5hZz2H1OwPvxlt1LFMSOK1HNmhbD6xDwc8KCzxJi4jRssA9MBz9xtxYzEKsNzsTVah21rXJOYFtEKfSKu7GSQEjXn2EOyaM2rjQWuKaJC586FcUxSFLw4YA1Fp67BeQ4cUBU87IU+uPP5to3Z7sQsvn93+Lxh3Ba8ApaFUYtVKyh41jEKs4SPgaxDhze0cCfGPEQNq1+6Vlf8iihgTzhmDp9CDGyjYFaN+ieFsBgSxqYO0kAUC5FE4ecv/w6g8OnzP+n6FOkjWsO1Nx6DtXFpyE5ZSd6o4hTeFMWqDJH+oupVbY7n++OBW3PxmcLB7CUi6yFdDlb+bgdy9OZCqtnNDe5tG33i+VwomzjmndQatIj3QPP7q4qHdXYrlkjfcDBxE5eb5hEmmo1tcfMVvz9q/4YN0BhaDEm0bYBoMS1KDSU6a38dH7R5x6CmoowTlaf2LrMeZWnbKrSHrfXIo1RXwUEHqn5NRHId03WMFTttEHhCRxXOS2fxMnYyan0QqfPmeszn8x1v9ztu0xABQBqSGgPHHDjGxHTq6FaSwghRY9birIUQSryHg2ZipTouPvGIxKrCCiadYzimja0luOL3Bdfsa7PNLTRvZFUUVBDBf7kLlfQ+jhwHgUYBL5mL3HKwk+DS+MwyrBWIWBqyqcfKbg5T/HoKVIIZHs+nGA8nbscNf/7TjwR0UhahopYex0Tk5JnQbmmwbcUKUcnQGLbW2gkO8VypF2Gacg2gfOI+J47DcX75AkBC/KTgGLVgoMvVqxc4ZRMsiprRMGR3JBv1ueJ3Bz89FQmQHnOn5Y3kv0w4dLm3Qyvz3sQok8ukbSbQR+2IO0mzbkVNZ/clsjAKW3MEH5vW51pj9/sdtzmAeAIxEafh/XkiDfiXf/6/y3DJkTZUqPI1j0yYLXUrqHMz6LWb3lOzQmhsjWOyONnOmc735NofUx1Lb0e30vySKuXfY89Koe5UzIwxX+/xF4rm3zSJyZSE9/+3SKefo51Zxjx2kdHtRPMDGAa3UKVPzQYCwDFwu3EiuY2JF9OZLc9tIylEoirhA5jjwG1ODAN+erzjf////jd8evuMT/c3PkIfZmZbWOsAjtF8fVmYojCt0IPpBsSv96HEkIfzGI4BonL3SVeZigMPC8wKjHhs9y1Wzq5KlAnFEPpd4EXePOuhydpot6Urvkc0wss2ZOoGMwmn1M42g4+2iBaKBUkddQPdjpu8tV12iFz3bMk2lam7H1B3sBFeih3ZKQggnyy8l2HNG97ePjF5isJaiS+PB2LR/34aYBJhogJuE2GN/ukucYpshwZW9eE8GyCowPvzJzzef8anH/8F7nc5gdXmvBZqU3lyLWkGphJgFlvptTch7cuvLfuqmr97eHFqrZf0FIY93AooEVfJsY2UUBGJZYXcBcLL7WoKqDEzPJ4CUwBktnhcuj737VgEGYP0xPS2WB+TQzMjAmYDoa6iDYfF615jssY97VRS2CjgcMPhjgrH2zFxG04AyX0DTcNajAwcxwDCZUsN1EfjEHMmkoNi8xWcnaL2CtKGJrEHUkkj3HFcdPrvFj1Yd2id9o5Qss238g8Am4pSIz98VFFbagMWRjCwe2Bap6iQcyEAlJBof7lo6WvTaR0akaSgOlOt+9snwG2b2ywkzmLG6EP5h/iCzZePqP069swDWbE+10m4R7TIgeSaNLCQGYaaKfo1mRtRYlXkYkc6TpnZ6H4VKt7JbsIoQa3WnlwA5XcNHWDU74LABprSSvoQlcTA7En2bnCbyCJVunPsUqG9gt0Mn3fcCtJUyg/WVKTLTbWUj1pBQytJ5Q/tbdMHjmNinQ+OnLh/xrx/AnyKCuVbx2b16lKMwU5ZRm7NXOv+UvfpbCBT7l7HpOgdWmdepU4PsLTu3Pj+mhlV1SCUqLpEs+B+27Sr/Aeapd/ogtWCWGABmKnORItU5W4yrBDiikcUwoziWmtvbpcgjWwzt4SNg65Z1h1QtabE+Uw57lQlHo+f8fntDbjRjWfYwJ8//wn/5/3f8PNP/wZE4POnTzjmBIwi4qgXkrBV/ypqRqMMGRgQl7SIOBYGVhYyiPzOMfF2UFB2uFEkd0yMesDygZUlaUliAcChIiiJVPIi3Tg1FfRAV5nGi3+JzL4pGrhQZiyeexeu1TuFNn26SwBMsJYOmaGOGikDgTwO3qhau6EOygpyMV2W0oR3C+UTZjJWKOM08wLOxcPn/f0d72n44U//BSvyZWsLOs2NgyYHz3ViWiDKXnoUOKeYR4oiNTG9UKtwxpOfgQ8OOwSpYZWGeXxC4ECSvIVVhlGGFYFz8ZiNCPz8/sCPn3/4oAWQMw0oxG83MbZnBT6MC5X7HtGFrcnNaWiqbWspmm4KFFv4WESAy1AYGOpEh9Ha8fl8wsZB44UxcJPV6Foqikv7tDX2JyGxAzGm7Js5uHI6QRkz0qXSS1QXUhED2uPxMibwPnAzqR/RGi4reCWw7XQPtNMbfT9IU4hNx7KN0j2fsQ+/aLZyNWKtBHMMeBYmqvXDRKyLCKQHh8cdY/2PutT/KeLr/EDdUAA9L8b2/zOpKds4vhwERWcRDXQO9UeSM23O0nVHiTYlI5lUMq5F0e5FZaQFGusZfg0GnweTMt5K0mIAUTRHCJ3thxgbLkHyE8nnzR5CZ5jO+WIhJ8RVgJVxv1WTrxJY5xO3ObGS1MCIQDm1Koc6es9cGgdAOmFiIjGQNngmqCbBtj5tZP6K3xu7saHr6Vo/sNyGA53vDjmy9U9294SAzUTbP9OsAIgynOUAhgxeuCBCeyGT/u5UqF1inFt3OplAPgZWArYKt7cbzAyff/xX/PDjvyJtYhx3dr590JSjsA2RqHPlPTKHAyflDT40mFBn+uNM/Hw+8engWr/NqaJ7iEGWKOdda2YCK7uL4sp3SMxlLqScesz9+fRg0N39/jvxDylY++PXjcvbrlQt9iXtVg+FWXCj17ocHYjX+e4krLUwJnY3oCBhuBC6KhY1XoFcsd1T4lw4YwERpJjkAorOEgOG/+2f/xX/LRPnesdRd7y5wefEmWzTn4vT07E7FBBvlQctNHzOKmBFo+aqA7GA5yqUHWrH6v2Vo3JRBB/y6S51amwghVaby/McXawlYFML+kPyVrkFzlf8vvjrNcsETmJGXebuZFOIZUrADKieIM7WfnfgptMur1Fitlonxhw4dLiFjAYiQrSkCZvAYSD9T2jbOjlUyH3SfndxWNxNLm2z7ppwfgrAJpVmDs2JKd4rJdSbNKpJemRoloJqIW6AA/P+A0r3X1PNOEmbm+SqJQ0UcDvuWzC5tQLVh3lt1IP2EXgVdFd8t6CteaHqJAjjnYbz2rGgTu1BoPLbD35PF8p+IMOwInHzgWMS9JlumMM37xdo/Bi7u8VkUA5U6t6uXARnZKRg0v+txSS+JFg8jhue54lMDnjrDhvpuE7DDwBr5Z7AHpk7KdQ748GdnFmyp1Zn4vk8lXTytffXSXHRvu4D80YZdK7A81zcf5302VlBCmRcYM+3BBkjr5u/h/n5h6+ZbWAfTUQBXnu0m2M611zTOrNlGJrOPH1gzNsuNNwTiN6zTMMvtR+ZePkqJAqGZyYekSp6wGGHKpOX1hYBnrZqEHVsUUO0B3R6u9Vg06QOh1DjkI6J50CuwOMkIDQHrXSRuTvrY0wcQfFxGQFK2sXbNkro51pKinsq9xW/P77OD2wXm7qq6NxwD/PjhoimWXVRYUq802REUJzvReBRblD2wSFSqN2ey6UCtkxzi+aBlXRFhQFnJWAD97cD/zJviFhYmXiuU5bjEyEr/cxEBAlTwx3HnHi73+Bj4cvz5FntmoIOYCbt989IFt0+uA4F/BeKYJGxIYDeJw0C9aULzKArrajsQx2U/UH/9Qf+N+K3UbDUNqrsASTYNnOd0LdAp7r9LfSpRCU5I/A8H6j3RGAAzkTomAOHt7/wgqXasBrgxyMmMVHw4Xi7TbzdDgCBXLxw5/sDyMWZliX/gUqMSonQbXdqMjQwziFrPC3CxWGBVSaaQXF+yRlILBwG+G3uQmnF4hCwIspX6x2cnKnN2Jm4ZeVGmacnrGSLidTFohblonh+x1CnAqJDGUhPCXlhAyUe+Ae7PLlZpywiC6BXd/u25UJVowWyODWHO2e6nLRDwW0KDVARYEhphg4MOzTFnGuXw4mmXLWEgKfBxsQYcuYyIS2p6QXOTdCSE0yzHYrgGMZCe875IXkrdXS0R4i7Chja7cXdMY9JKqRoAaXDcDuBFZ/LzfYec6Fy3zdIf1qooNOI2UEQJ57g4CB2tSBXwQqoUDH0AENSWiZuAoW6+xfxcsHKYrLk7oCK6I8zFYY0SDUPgi3SXfz08xecEXh/LhxzICLw08/v+PHzDzAfWOuBqBPnIvr76X7H7bixi4LQ2SG6QhnptUahcbsQpnjLK/uADbw/T7yfC8dBm9Om2TxPzjXxMeFdXBn7QQnu+2f2Gi4sAG+oX7SHvOK3RbtRsWBt2ih2F7U1Q21N3vts7yOdN2jHZSK0ntzvbnT5aZe2gYGViaoFDrFModqFaepgtINacqfPSjxODkqk25FtrVOKEggAFUtaIeDxfGJFYswDuU4axcwpiqHBhwt5TngNcevpFOTeLknUEaKa1hignbkS2f4AS+8b7Son62FjYX1KU3jMa81+zyCpwWDJc7CNANrKtvPnnS+UZsOUhNhGY6Os3PRnB/+NxAbb+bBUC3xe4PUcSafJ6aSxlg7dzECVS/dmQLZxDC32H89TBUgh1sJtGO7HDcccoqhyWa0qjO5mqEN8HDewnn51JflnAbKA900tFztHjJLuLPZZ053t12O93u8/in9MweoXplZPqjsB5GuoifjmgLyCi1al/b1s5fDee1909Mk4scox5h1jTMQqdT54IFlyRkLpQlkmDmcyxxkeE8MHMhfe338imnGegBmO2wSc7iueiTleE3tXd2YiNRhpYJTaps8Tn+ZNAxZt/zKwfWZjEKlW1VtxIpZsWcthNVD2tpNSUgIIuZ+ycLNcmPPOCZHO17IRIuuq+YrfG1+vWc70oPaCZgakLhl6wGQPboNuJBP1Cn0DmYb7oYBYWNnPQuPELHZJInInSs/zHXW7Y8wJm4ccNtiuJ3+TMxGeGch4R84Bx5sKjMBwOqOgXq4VWT1ThlSY5sZ3IbMIv2AL1YXeZEOQ0MyZLnur9VWJcz2J9JTpHtd70g7W9EdO4oa6K4wEvkLTr/h98XUN125CJwxJ97wCKk5A+wZqyIlE/HoZcFRb9EpzBgOv5VroIS4sdMGkKBe7dVvQ+OK9j9YuAQBYzD7PE8/3J9Z2/ZkYcHz6/CN+/PwZ788TZQ4UO4S3OXAbRsMPN1jKwAOkMq51YvmUGQTPmchs/wVACWauIIVRC6/51Oc6cT6fwDzgERgFUc84X+TxfOI9Cuc6UevcBireXe4rfncYgKZgpRz/KkP6t+C2U0beiXR3XtSVhf7NUWIKiPkQLAggh7SpuU2pTqtBmqcuqIsUweEmOjNP7YhQAURajcOxInCbQ5QZOiA9nk9kJu6YsMmu3xmkRqc5xmgqIZ/LFinWTTfp9cncp/faxBiGY3CfDhiOMWEGvD8fosxQJBzVnU3OZXK5s21ZtNY7B47mBfZ8Y/z3+yw+dPDt68JA/2T10j20oZkuObLP3irAag98pV6Hc71WLKwk4NHmvKR48bw1dTFc1x9JEGatEBOB9wUAzEnr8DNYEHy+cRDhCZoqDQ0jfEbgueiKtSJxHFCnjznCIbctAHh/nKRXaQYY9Xu2c9GepN7zdFLAQucbzP9l/78PDPWLpM/7e/GrBxECoKhFn3wVsAdzbnrG64WTO8aNqPn2PB4TNRw2DnHZbkrcFs4neZOoduGB2lXin6kcrdBrMKf/9nni/cvPGOOO+/0TjtsbpoTwRAXZli1n8QLQlpK5msSYKPjxhnEMWC0AAZ8Db8eAPRfMA2N+wjFvMB+sWqs/i1LL9EAdRGu2JzLhSUz1h+f9ro1GmLvx8xk+OPTlchT6pvhqzVaj/nQHyuK8gO2gUqbJ6CyQzRzD6KiDwXXIHIgtThTgduigE2UkkyhaLh66SNrg5sQoByo0E0fi2Fw4E3hfJ84EOyCDt+Eho4QxnEK3YI/mdWAWDzW3XaCU8cDfpnviY8M4XZpULs197nazgSBBsLCYaFFn0YlmLSLiQlBS7X/T5iI22baSbnOIK35/fLVuO0keTscUdY/dZJ5gTYBrwwGukwKTprLBwnOjyVynz3ViDteUZYPNgdvxw+6EwUxrWEXumJjDMOYQrZQd8MfjhAnBRRXmMPzp059waDZHRuAMww+fPslI4eTkchmKTjeUDYzxI37++QuRx0F7a9q362PQO6Teg53vOTjUrcWW7gPzOBA2KTQP6gU86Yb4WMkD+nmiMjDnwJsbhc9X4fxN8XHNVpU6dgvtBEgDggEgN5rvBib16K5HFyoEcKDiYhhw3O8bVaXe7dXRJqNCP4sJGPfQLGo5AeB5PrmHGd3+7seUyYKc0s4TuRbnOICUb7Mh2ji7De1SpaWODFr8JgAvurzt5JRe0ZheeBu37RBUgCyfDTcAsU4ARuq2zp22Zp9y/WJhh90RH9JsXfHt8foYTR0w7gNNu+p8uRPtTcXqr6cK0njlvP3AnbceHwYCjhobzCT76jW+l9ke91AomYcZfHK3fJyP16yyedtUKavaa+V+HOhhl2P4fu2mtTf8NQxQdRKOQfMPmiMEItixaaevkPMrX10XYtiFCPp+7q5kM6D0G3+S9v+/FL+agtUuF2iqip4wrVsytSkrbW/oTtFjyvqQjjq8yaY7npoyWSisWHieJ6aE6FTR8wKP4aJENTZneJ4Ltxtg845PP/4LVk08z8Dn+w+Yk29rVSFXIJICobYMXll4T1B8A1qcrfXEbQ6s6fDiBjAwkVmY44DZpO2ZxPXvzycqFqvVMiKP4DwPXuzYNJa9sI0JqTvU8i1SKUC/ZXxoY13xHcJcnHhHIV4dpup/053iLrRY1bwoKJxG7ah6INWKHyauIwxPiSGhTsJ0g82J5/Pc+okVgXaMNzfcfSBPznf44X5H3u84o5By6xkqVMtc64Giy0Rq6inXyHRRSsrgcA0wrD3bA0bdFV0utKYkg2kzhiqi0ccxtWapbUp1N3NbWetg70NYP0/0BtIKXPE9g+t2QPyqbjwxypCxADsAzbUokBYIP1B+IMW474GqEQu9n5q0Q00h7ANmZbKrrOOD/vjcN8cQ6qX92N25Z2XgkIOhm+N+u5FOEJxFYir4ezYNrc5NoMDEHE4qwTpR4tNz2KVKKjMEoAKYSDrPGBbl9xsd6t4XgYCIwBmkHEQmOz99dkXCD+69dBe71u33ip0faI1s57/oZOVFO9l7MLiyO4lvFsX0dq1sKii2xykdqV6ItOGDUPjjazBjIZIJ+MDhN5jcJn0/RuHT/cY1CdriVhGppv0MAM0UI/WcYt9nFmm4bnAM3mMZGuRa0M2CtuoXrk4aeFY3bwB8/ExsJ5StRQl9SMek6Phc53/4dfxfKVLMhe6C9OfeAL56Fa99V0ANO1MlBovtM7ANWqpSOk/fSfwYziGVzJQ3uLnNFDpHMACDa8YrcZ4PRC4cw2WMw/1xDkfIYZMFDLXQ52Lnm3m0wXDbnYuIwhx8s28SoFcVfHI0RNarIPhAqNy5DEGC2FovarJec8+6GaECAVsl/gv77G9ywRpjSshS2zaWmZo2GxsUKWpASWZhwhFyE3ALTJN/sgHhHHpm4uff5lDy53psHsRD7fZnkT9cNpCYOAO4HRNZjvsnIPzEOOgc8FwLXx5PzDHQs4QbJT4TOG53TaRmJfv+DLgfeAY3lUjd7CY3CuP/kw8f2+EINfZQIpMVn7k6sUa+XTvDkP/a3uJENkPctIQh05SAXvF746s160zigcELYmNTO7KYBHViYy5TAbgqeLmXoVBGSp/bAMYhygrkmMbnLfeeecpC5YOzVapQGUKfPx0Hxrwhioi1TVINeFNjiw1LjkSkLowtLh9me5AR4ERHxHEf6t6UD9kD+x4AliqumrfJjZRKOhYuLqTGX21W6PmVtJIi4/sE5X55UVm+R7QL1i5A4aiiJTKMwtvNd8/cgwITB7J4aIUdSJvcI3sSuSgebhrq170FZYWu533BO0rejXtWGTvIX84TPgY+Hy8N0+Eg4NMmDSgNysRu3XslKl8DLE1uSZYnooD726edlJkBjsTS4DlSeLHXKgfiUhicoFh+wuBFilmiJ7qPPftnSHIc55OFdgkQG9e6/Zb4uNe2dW2V9i+d824vsxoWG/zVk6anTYqw0cBJyayAblCsSaShFM2DkM7g2WymM9rkVCWzHNPA1iw8e6YOCI66scjBpGi8nHpRB7slIT1oG+qQqjthnrCkZTrGB977Lnq6eHCs4mP2uAK+jQZcja8XIIBU3U2WCQ8+pL3m+rdCYXLi+xXfFA2kuZEaGif3UgJw0sahjVd6TYmOr8rXuqvgjvPDcO6ltRbqsPb1nGNsdk8X6yVt8jCetSsT5qRJDblxPk7HSsMxJ1Kvb+jeepUIAoyS+cyKwu12sFA4Dqy19HzUQnWHzQA5t7mYDMAydmOafvVxcC2KDIljTjYIVHwwJ4e+H3psU571y0DPr3bBAlrB73KJ2iQj7HYMSr7EtSvE7XxRKZcKQ+WJMwNrsQKNLLwdd9mR8omjOy36wPl+FmADx3FH2cCSt3yk4Zm0Fn1/ylqxElNtz/HR9tdoCwwYHTaELP/445/B6b0l5CzgBc0lETcPFNMbeCCv6kmvtS+ki+JFBJp2xWNbsrX3RqJM5oRGLmi7H3ykvF3x2+PjmjUYOwg2AFfa5dzwUd04NRUKmgQNAHC4T6A0m8AGhoYxUIgl95YqHQjNv+dmdb/fNirX3GhDwcs1pIezO7KAUx2MAvmkDQXupAvkitLGjx20yvXVMDez1/Cg5hCPMbbdNDuXmsgOIW7SkZS0MVx6pPYMOXPAxZGVDd8c6sYI4RsAXJSYK753qIPhRFrpgFZgmyBZDDqRWQojmej09HGoiwCo4zHbCQWyFRWPPmj9WAVUJOkn1YMIAQ7pDNQcoglIf6SD8jaH1u7CUzTFygXAUPFExQNm+XqNALBkF20DZyTub5/g5jjl9qNRnjvxXIuCds6DSpxBlM/8JZY8xkD5QA0mo/O4IQt0qSvDmAvPxwBiEe1z31O6r/h9Ufs37ikfqUNMbuhQhWqjiqa4cM9NmWM0gImqr4qHHmiYwVyB2th24uQeaipAel837Z8uFBlOp8HQ2onSHAaBPa7RAg6we2EGl1ZuFKk3w5mcZRRgTSFUFvthnZo7fBxkYMeJWE8WV0Z0OiLoYCg0uQuqXtfh+YHObTthdO31rs/tit8fBexBxV1YuLvYNdigenfk6EjIfNHxElZ3Ut0anxWx7XDh3a14gTykKwkATH9Rmxt8Bju9iECdyQ7FMNzGwDqfONfCMQ9wVh0AGO5Cq8+kPu79cdJ4oYD7uXBTl2MYhe6dk1jxDAiwYzzorwuATJxA6V4GaPW1ZFzCPCIy9vyTFUBlYIwEmnZWKov0/n5pm/1NLlj7QbP2IZPW1IyxxatA7VZ7l5tePPQi2UaCDpZX+0vFSsbLVhHkhc7bTe47TCAz2T045eENGzjPhefjifPxxKf7bW8syKAjlbFtX+vEl59+wm0LahN3HaK6BLootMl9PmknSfSZlqevGQlgRRscPGTWk61p0VZG6hdK+I/RhjizKTDUBBhsW7c1K/CK7xMFFbNlOxGqNmzfPYu2PiyUN/Is8bcQK3dymTOWeJw9iLDNE0Q8LACa22GARO0cRHUCGD51cALDyEfeosSQrZ3TbaLhlkZ8bU5NCw70kCC01482Oe53omKhXglpmTQw2K4sozsegFrC9uFT+xp84M8SXGgnjgYkrkno3z9YPAxUntrEjdq3KrSejmuN+9XCRKU6x679NUKOZvr67kQEYEOoWIEGvoVCAPlyRUszLPBxBjM0lIVoBfbqlGXiPBeQpHlBdJIMTcY2Ghm0mUGsEyh2Tsyn6IaGCs5/KCOlcJiRmvt80A1JnWbAhDAKXSsJed0xggV3rYVAdx+F0hW1BdWf7zVz6btFzwmDD2k0lCfgpTurDfzwmjTgSIG5un9yMwNe63BlYWiyMhN5rgXO8Si05nQY5GBYu5hJtUXo+HZixSKIA6LSnNhcMAe7htlJaO3kn2uZBQWTlRvzFaO5w3k+OFTTJ6Jy6wqraF995ql7EBzeWbW7RFBxkpU0WQA7hVNzeCIC6zx3sT0uisT3D+0NhRL1WJrHsl1c+oez0tRZNXVE+hyMfJkEdIHh6o5FBWL47o5Iw05wx/rEdjmvLpzO+XYFx3Hcdd1fe65397u0Bh/veD6e8HnDcRwvAxJ0kTW3lrSUb8CUgxYHLKMSiUQYBelzr7UC9IpN58YCtr6jZAmfFfzMNgIs7ffvLUA6weYftV16XgNG1PoJtr6zNFlcqAVAFIStxkStJwf3GEXXYzqQgVG1PcDR1rZyfXie534tZ6SGuEjYfhykZ1WgVgDJFtGJxBgTBQ68shGwuiPN8PzyBfn+M374p3/SvIXEcz15eDmFjUNCHFrniS+qwiIj4NpcrYoWv7uN5a/KWSj2GIOVcwuUqyTJayGpJhTDEd3iu+J3x8ePr1DbgSphEs6mPn9R+zo5QeEMtsxnJynoAVQqVKpwroVYC3OYKAKNj6jIdGAWMHZhXrqHWGxGsmsAOEyiYoS4ykIJ95/quGVqcBz4/SYeWcjakQMz+TVDUwRJx6qmMQC0PVVbmMOGus2sKa96v43qoYQAldwvJO50UxvYfXdZrvi24Cf42mu7M8dDiQ56XA9sfUdTtRJYaThlCx0J1AqYp+Zi9H3A9ZVInFmYk0Uyux0sHFzFK10ASYVCge4qzlX2XETDzAeppo0KSujLd8HH8jkAuwN5arhgaX+9IRYdvsZgUc29U506sBtzBrVUHIIotG9/PtJAWScDKowdiBV4PjmE84yFLCO9Qfzl4ewq3uZvwt+u+KvobaoTs9ecCibfRPkB0zjJLJmZVyFLAlk5A+2uCWgs414CHbVXau4GAISZ6IUqSPu81Qth16xwDMEzVbBY6CnQxxhbL3SMidLZ6+WI4sDYzLUpUVa1uzsZsYccbtvUcIFSBJxKYGIUHUErQZMFJaoQXafGEEVblLTka68qapWY3e4hyqSxX3vtt8SHo/WV09bLjlnHnnLfHnJar5lBZvBkPvvS9hrGnBhFGpXq7N1hAVhIPp6nCpUPLRgfm6HAfHFi+IHIxONcLGRtbBOHM1hITxnXlIwbhgF//vwJaQTTmU9rmKJ21u6EAMwhzADL+ursoUsgXrpRaCYIoLkfvsXtCQJAlBf0PJUPBUh/CL8Q/9gFaz/Wy4+99AG+5n/UB2s8yh+HMRFa2w6PNyNFsbQLm3qRWbG5vaoDRd9yoJzuGiYXFW1UZr4T+0w6Ykx/JZRrndsdyNaCrRNlAzMX/vntwIGAG3UlEQsDFH26vQ7tFeJE+8A4JhEzCXFa7DuOQ0WV3qMEINZDXOyFSrbIyHTAVxknFbuRpyxe3RW/P5g/1+svlboJTGgb0BSnbB5ud0iE4EU195MdL2uHlho4DibvhsQwJfMwHJrVYQBGcWBcAZgqSgAivcO1LrAw/dg/H8aWf9vzvVzgBt5uhzprgEcjfLntol20mG3au919SnQtFlB0W3ENVvTdJTQlBp1NSA631yvtAnvfNkAmCi7tzHUmfnvU/q3/Ls2ONvUCZ1u4k9JBDrkhzBF+IDUktSQsH8Yu8UAIqeJB4wbcJ6kx3qhadbH8EhEvIxFq+CAnf4jzC6CqB2O6jBBKSJtvXV3qPCiAqLYbxmQymRnIYQCCLq1Gl6/htC/tT6DtnV8JAdRNgZLTkJaLh6sbV+2UINRKBb4bYgwgSJ09huN+OG634z/+wv4njq/2WoB5gTYUy0RKI1fGbloVrcOjQT3V2CIlvzp6WUJUuae9choVm92ttRfFmx2uFDdfhXWJJN57KWRoY9RmuvvuEALAUtGwCuoyilpYsa3bxzz0s6TUTBjG/WDXRwU8bdxDhUbhGNx3scEe7r2l+QmdpxmUB4DDFw2gK6YKoI+i5it+X3xcs1W0a87k+Z4q8vZ6+utZLfrZzYzY/yAQ0g1T1xjV+632vrY4FyDZa5+W+ypyYZpR8yqOkG39awKYCPJzPhS25e8xuZapp/KXro/VCKwS5woa4Rw00dEbfeWleE1/f830kHOXAKDOLFy0yR7B0fQyU07Bz1n79y90mq2uBX3FFVdcccUVV1xxxRVX/EFxwe1XXHHFFVdcccUVV1xxxR8WVwFyxRVXXHHFFVdcccUVV/xhcRUgV1xxxRVXXHHFFVdcccUfFlcBcsUVV1xxxRVXXHHFFVf8YXEVIFdcccUVV1xxxRVXXHHFHxZXAXLFFVdcccUVV1xxxRVX/GFxFSBXXHHFFVdcccUVV1xxxR8WVwFyxRVXXHHFFVdcccUVV/xhcRUgV1xxxRVXXHHFFVdcccUfFlcBcsUVV1xxxRVXXHHFFVf8YXEVIFdcccUVV1xxxRVXXHHFHxZXAXLFFVdcccUVV1xxxRVX/GFxFSBXXHHFFVdcccUVV1xxxR8WVwFyxRVXXHHFFVdcccUVV/xhcRUgV1xxxRVXXHHFFVdcccUfFlcBcsUVV1xxxRVXXHHFFVf8YXEVIFdcccUVV1xxxRVXXHHFHxZXAXLFFVdcccUVV1xxxRVX/GExf+kfI6LMDAag/qAXdAXg7vY/+jX8zxoRq8z8WrMF4A9cRdea/ba41u3/mLjW7e+Pzg+u+GPjWrO/P3qfveKPjb+3Zn/xSrgZzAzoP39F/L3D83sfqh8fr+r7PH79xgf5rd9/xX98uPl3W7P/M8TfW4Pf8p7qWth/ePyedfu94u/tn/9R66AKyN+82f6HvJQrviE6P7D/AWv2/5/i2i//54neZ/8zr9n/mVbjL3ZAPkZVoSoRseBmQB+Y4IESuXRxfSOv/Jl6fR/6+/O1AITU8nsDAOA+9WXb/xZrwd1QBZi+lhEoFF8LDGNOZAYqA2YG9wHr11lAIfVuXn+vKmSGvjz0Hvhqsb/bYD4AFDITmQF357/ovWUGqgpjDD4+DJEBVMJ9wN0/vB+gMgEDzD6+J3427rfffCGv+O+j+IEi8gSvVa9Z4swr1leJX/9MVcJgXIP28Rpz/RiwE0Ved3x1fVHgtQfXPr9uyOJ6M7jWcv33r1ePYf1aUHDzfR+ZOapS95Bz7TifoyqRmVxLML4mc1Ty+30MYN+Pte9PN9/vlffaCR9Da7xR+eKaBQDn/dPfzzV7/4+8lP9LBddBIYL70mvN7u/Qn7Z/L3zca19rtnrNmePVFqu/+jofJSsBrTfA9trr5zTjPdHXvvdDAB/2w7/a94uvrTe5zA/P61zPvIfyq9fO5ylkpdY/4N73XPLr7rB67al97/W6/Poz4M9//ByrSq/7im+N1167PqwPXpvIgMNg/lprvYZTZ3XvzSxOdZb64HfreqbOzNd68J2TAAX3CWjf26/p4zmutZy58PU9wn02M2DovMFe+2GE1p7vx+i91n2gSufCh7Xv7sis/Tj8bGK/ttfj8DXuNatzpzIAs6/yjGuv/b7Ra/ZcT3xcN712X3vk18XKx72l12xpzX68vlyzS18fX53vPJMD7gMo5ge9BgFgjuOr8577J1Bl+3nMmJPwJ1+F8IoTwx1jHPjv1vmHfdnUlKhMFF5nwV73GTBg3w+9d1Ylsop1AH9Crz2Z+X58HDBPv9/f/uY1+FUFSN8kmYFY7whzuM8PH3IgK+A29KaBPpyY9BuGj32olA66vui8gAsZDybs4w0+DmTxA854Yq0H5rwrWSqccWIgkVlIG3AYjpiIeAIIuE+M+Yavmzypc5BJVeZCxIlzvcOsv5+HqJlh6ELAHMMdWYmIJzIXxrhjjFu/U8Q6tUAm3AcymeD2ge5jYo6p5LQ3zb64/DiiWDwdx1WAfGu81uxCrHcADh8HYI7KQlYg4+Q6GYeOqUJloGoBcJgPrc2CGw9GM98FQaGwzicKiTFuGD61rFszlgAA+zFJREFUXoDKxc3EhjYZIFGoMrgbvIbWYKoQxr55UxujtpWNULsZ3AxVC1bJzUjf765CA6nnGIA5vz9Dr3HiGFMb61KhVUibMBvoxBRIVCxkTZhNFR/rw2Y6ddqmNszAcVyH4veIPkQiEo/zBBOroaQO6M1+H3Y6VPrwcnOMMXUg5U5ahkCQXvslcAQ+tG6BlQvP5zvmnJjjYBL14fn49NxP3RyJAjq5HwRv0EmfGYsDvade57YPxMIZPOAyFswKWdgH+LkWIgLmhmPeYDDkKi27QGZijIN7bfV9wrPGnSAQD1smwExo5z5cASCqcBx9Xl3xe2MXzBk4zwfX5pj7c+Y+azDj2djrqSqRccJ8YI4bUuskcsFQ3FPH2IDO0hk7xoSDQCf39wfMDHPeYTYQ8RFQyl1y2of9s6pg2q8zWTj1fdLrqKD8owJmA3NMmBHMieSv4YNngwopFs0sZHieFAEic71X5k6lwtyg12cDts8IJqcGwMdt31dVAdS1136P6DW7YuHx/IIqYM7bV2ctC2EIVIb2tgZphq4jr0vlAoxnoxtz3ei1CV5HM0eo8EBx/7VxwOCILO6nAjTHvGEIQGwws8pYNGSDMQDy1Fp25S6J5/MLbscNOD7DlI/3/YZKmA2tR+UYukfMXXkAELFwrlP31Q1uA9k5vYrvMSbPARUrKwj0HvPYhXRm4ozz2woQAKgkMnqeD2QBBSIWWQBgmA4sJOpk0s0DqADjAYVGfbN0cwVW8MbuGxjxgFsi8Q7YwGMFHs8HKp+4T4fbwOFAFhCADhTHl+cJN8Pn+w2uvScscJ78QKAP1ZTMZRWmE72OOLHWA4EDZc+dBN6PA8ccWjAFN6WomYAlIgrusdHq1CJ5z4eeSb90cJc5bmPuBZVCTWCOKXR8RcBQ+OHzr70qV/xSZCZWLMR6cmM5FzcGIU3HcEQEVvD7WJgmDIEsXr/MQugGPQa/5kJHVgZiLVUORB1U4WqtFVayg5YwJJgczjFQWHBwLXai9EJTXkgJhCB8ebxjOl/zqIBVIgt4Lr4nm3eiHm54rkCos2E+MIZjOJCPdwwzTOOrsVoYYyDrhbL5vm/5mt0OFjW5tGl21wRAhYofAz7/6/+oy/yfLiITz3Phy7nUcX1+6OhyzWQwqZ5uOhgKpj3KYfwesFCYw1A4CcXsg4h7TcLgfsAAnJlY64Q9nzAfuA8W20uJpJnhDK6BOQ74mDh0OJ/PEyWEd46BObjWI1MJXggxNh3QgYilZBOYbohIJacsvqKAt9sdjzNhArpK4JE7EM+FYSy0eceUPp/1QpJRu0PUX0+B4oXCnz9fm+23hYq5TJzrxOP5UHJeGAaUNKTDgaoHqtQ5UytteqHgeOCJqMIZfLzbcBTilYSpmAaA9UVJnc56U/fseZZykkLC4S4ARvulATjmxDCiPXEuZBVWENEdDiwEXp0bIGGYwwEEvjzOnajFPhdOcPUl0x4UHIHn+QQyeX8KCBrGwtpsoNR1n9qzM+uVnxjgKAxzZD24krs76YW3H/7lj73E/0mjQZ4vj4WoQr4/1bHltRkOrEhUBoaxY+DGtZkFZHGXcTc4EtP5s2YDUckOQiWmOx7nQpVxv9P1dQPOL194v5RjzDuGM7d4/+knHD4w5kR8YMhEJgYI1Aw33Jwg63k+4b12QTA7I1FGMCYBgTAAQNB/BffT6YYpdlEX7s8VvIeH4+cni2uu+VI3E8g8MVQDnAJ5DEDWc3exG3z6r//0t6/BLxYgtX9jgr3WifP5RGbXgUCB7Zkcjki82jbD4Qa4lTYdfDj8iMB2y4ZJ1gnLEw5+aCuB55n46ctPMCRiOm7DgVGsJucbTIXQFHJtoaPGhNxV8Ub3gQi2sUqnTw0WQxGB53niFDo3J1tllgsVB9ZaAALTPhxlBZSdgBJKd2cXJHMXZFHAisJaRFvSBm5zwsEEmNeaRdwhSgsLk1fL+IrfHs3EAIiUxvnAOp+q9p9ctzaZeMN4o+rwZMeAyXkkAPgH6lSiltDTIgXkuXIngqz8dX2FRGQZnsGDCWMCfuC43dk5RAGpzkqXqyoYjsmkrgvfjMAAUGvh8VywXEAurOABP+ZErsIYvJ2f54mlFv5xu+N23FDDhRwvlAemF4sYAeFVKVSnUWwW+mj0Td9oxQPWXJ90GeIS9X1zdHcYACICX54nfnqciAghs/7V/gMVfulMziKErKEpBLx+ZsbCGGyZD3UFLU9UBYtiP1DmWMnOG5vtCzbYrTuTVKgsw/M8YVV4e/sEP96QB1/8uU6c68RtOn5aT3y6v+F2e8MKHmQANnq2aU9FBLJEI8hM0XuBcyVBqKcQ8UoMNyxRHapYPA3RbLvbRyQ+vzoAuxsSmbur2XRIXHXz746P+UGswPP5wPv7u4rUxGC2ThR1NK0FmwUAY7JNoMewGrAxQzjT+uEDc/A8bXDmXEz6D1FIBPcgulA3Q+D13FWJaXo9MWCDZ3xUYUVgCQtMdx0gBvOJQJNbDLGCIBVYgGQVVvGMMTChrAxMY2EUkbBKwAgOwAyWwbMhE+UGHwdqHlii5JhASQI/zs+mAshQkVNIu9bst8Rf77Pvjyd+fjxZaAiYjHp1rqqKa21wXbkDGNyLuW+R8jx0jiv9U1eAIGDAsLJpoGTSODoPxgbI17kQZixIVsBtIc6T67BeYKUbMF3AkiUyFuJ8wLFgPmHuOCsBLJT2RthAVuL8AMJzXQ7knLzfGlgE8FyJlYCPiZUqJAriM4laVSmCtmEJBCDYpA6i9lnD349f3QEBQLpTGW88EF3rw6UAnMHWvhuACMxB9KDRjqaljN0e5QGHWkTeSlVkNd8yUVmYxw2NmjRlxgbbrVlK3MBCYg5egNU84TFQ54lnBDmlRWoVytVeNYT+3/R1A3nGESFkIlGWqkSZkEV/JsUWMltR3ETd1P0wXuAVCyvXK+GsggnNNAOmTSDFcb3qj+8YugmCBQU3B2lz4EzuU0iGD5znCXeS9lYWW6r2SsqyiOxZlVDohIHJXZZ6I+6oSMRiQXqeC+qpwkbsrkQo6TIfKAO8EonCGCXUDyBC6ChMDBhiPXGuE2uFim8jrcoPnAXdi4azDJHSimCJqmIwDIwBIBMZPJCtCqrNUdbHrdZ/gahKBZALVoBVAMZiHVXIHISjr/iusZNsbfzsHDf1ivujCwKuMh0yJpRLSVh1PsXEfA7HAHCKp086lgrRSkQRdRWhCwsOy9qHjnIgDB/IBJCFiO7EsQiKtfDl/S9Y5wP3+6lOORBpiAiiycb3MP2lIQFY6IxdMLFT0vdwlaEisZQk9GHvpe5GhjqL2Cjd7kAb1Nc0ePUBjBcwdsV3CSYfhQiCND6wi8q0gcKQcL2pHAWMIaCjEV4l8KIbehUyqR9xsQeiuB5DiZG7IVPdBZA+szJgg0CTASgH0gpnsRNofX9F4Hmy+z3HQUKUFRyJgDR0uo+qmqnBXMHBDjQAdjGkU52zabdiWSSTWOa9gzlJpQDQFJe/MMDEtwCMwfvWlACXip8XvHbF94hM/dJ+4B+SaEtTEQyM6r1kIMF9xp000yyexzCepeY8P5+LoIkZsFaI/sxzmukF6bW3eUPC8VTxzUKDezaKuQrzTqjTzT2viP8BnReb9HFRiFoom4A7fPg+RwCooMBGELpznsVCykC9Z5aes/OfLKxMAe7MkQ4Vaav1UALfDdwLMhJj/P384BcLEO0BuzVjEqWWXqw5D5MVCbOmFI2uA4XYOVIvHsHq3wbbRzYGYDxEEo5YT4z7HWlThyMwjk+43W5q4QZsOvy4A+ONCXwkkAtZhiyigcPXbhcNFRbnGcDhKlZ8H1ChK8GDsFAO8uZUMaonx38rVr6kzuiAi0QlqTEwvlezfvyS0JIoXjqYXOIlYmK5/HqeK5X7tvi4Pbe4vAo7GRtiNq14GQnAnIeSF/9qzUUu3EYLD1lAV71uXrMBc8dQIeHmsCJq4ABwPvlzlbAM2DjgxaIljYeopO7bYIGHXO4ixEAOahpgNXDaQNpgkukTY0yMYYi0XRQFCBKYUF+uKwO86SuHivzSr7E/tyhSJhKBZySmAVP3sSH2mzchOpXUjlzxbcG9VoibKYl5Gtq4I5UFlcANa5BjP4Cpe8A/pzssU5ol7E7rUFf6fPI6lk2kOmBIIrbm0P5J8a2PiWNOFUFat9JBNd2G4IlhReLt9oZPb3ftoYYVgZ+//Iw5Jua8c8/t/XkcPFsqUSuRSlLdS0kntEUGrELFlunz8v3/tbvK2JQsvljfXT1Dd/vYzb4ad98WH9esuckMo/9RQtTuSX/4o9F8oHMLnp1jAKN/fK9vLgA3MS1kEALrroe0RVX7Xmjdx80JCJkPPmeFaNfSHimhy1jSGSVK7A6TGU1W7TODwnI+xjEPwAqlbooZ700T1QoqnlFK8Eo8fTipPCDAAxAIiO4+VrBzA+64ZkNf041wFSDfFF+vWf9QLArlRwOVrYkkoLG7WGXwMuklwFIkZQBTlAZY8vurRPcsII25oxVI3xc1C5IRDFMeYQYMx0pRbiuxCxB1HYhNpsByQYbSIrEoN1SSlYQuIuDqiPM9ppgcUDYcG5ApFv0FFcmvbkanrGoqAxBLorq47g9Z++3+ob+/Zn91B4TIwqAbVCbM2j1HrU1gf0hb6GfOpCcouq4Ifa9uL6u9mQAGH4Obw/BdJd5vN9FWCrnecUbCDnE7wUMSuXg9AF4wnURKL2Fw3I6DH3IEEgthiXUuPM8HWEfxTUSkKklgDFJyUOQqR5IvXaI08D85uwzSAVwJXxno3DUGbEzMTMzBDZFlnK5kNufU0CSLK75XtBh7wCw2rxa6uTID5pNFsI99M7hxg3g8HtRVWFOkoG5Anxwl44UhXRRPKte6H2NiThXSPuDzIE3KHYcKTp6/0l4o6aMRxqAJgjibbo5T3b7b8cbi1gzljjRDCf04MxHPJ7uBLlpYJ3L9qQg1L+M95yqsq4qdSDiAwYNT95m3isUWEKeoLQ5os7vi26L2bxC6qpa/gd3c7kQYQZ/MZDEyXAcJwHVCkGPOQVqeuMIGorTsPk9EDFSFun2xaVAoYNQLBTM4jjlxc0cYcCs5AVbBMpB6rccYwHDYbeIYhmNqD18UM67nAz/++ROOMTGr8H/82/+FP3/+hHk7hK6RSpBWSAwYChO8l4gMBzIeGP4Snq8IhCAhFt8SsWeKggtAHZVGk0PJQZr2git+d3y1ZgGtWeiMlzGGYBZy2NkNLp11UHFcTnCkYARoZPoScueBybhDIIoDAogSmQsHSMNrB0oHgaNDbIiGQ/s2qUoVPUzE7sftA5Wa3QYvdgENBkjH5wA584Oc+bYhZocylJTKqUoU70KpOBKqra6l2YBnCZ4tjFpABqwIALjAIQc7JQROr332W+ND7ryLSncnOC5jl1BCbUYxNqpgwzdj5QABOxOwA51/pT2zBe5TLm48PwV0F7XU1BV97DAUhrEYzgh4LubaRQbOMALw53rgeZ5ABW5zwO+T+5hL9F3KQ0VBXbkAO5DW4JHeeTVFF3tdVS6+BzO9HuXzuwXYP18CraiDauS0vw3Vxg6l1/T3AcpfT8FSkrMSOMXZILLPSj6DLXxTxU8k70CkY62FL1/+gvsxUE5XnazQoUrEYB53GA7E+QXn84GSdqL8jboN6zb+iff1EzAWjuPgxY6SQJP8zlRSX9gEdyT48+v5BNY7rBYe58I4DgrTfBCPrkDkwmEHN7AKZJ74+f0Llt0wjwlHESk2XQCbmJMtsHMtmv3aQADSnLT1GfmcLXJiR2ixoNnWl9cm891CiBuvA+CujcAawTBxkSkdzOYCuOFcgcfjHQN3LCSOMdRGZ9Foul7nCjzOE+YTw7kBoZK6JKGu0x3Fc4xrQxvU1gMFdiszY/0VPYHFNg+i3F0bR2JlYp0n0gypQgpmOI4Dw0BnNhCBHgYUEndmCiy83LESG/2IKjwXxfak+JCeY6LpeBY3xnzAjO1ky3WBct85CN7URpygdXEWC2V0F9VVSHYhi0AsaS0ycMZCjclOcxWTvBZWChGreAIRgFxN7sdBAXAuxCqc4BqNwiup30LiIgXK2KWTsSjvq0g8ng8837/AzPH57Y2UgUo8nyd+/unfMQ0YIcphBcacTNIqN5UVXkz4bOL5WDiLeiirQJwLIwPwiahOCAFxFLCCBZKJ37xEqSUds+Djb336V/zusPr6TyUq5kLzwWRn0zvtg0VoUwwjgSEazFoEO4+JgmOYkc4s2hMNGkj9aIcegPSryMGfKb2eTJzricoT9+NAk/iqCgG6w412jYPtZBRmovAymQp1fqlJAlZppgQSEXStOw2wkBGCdB9M+BJlgdsYKNMe79Rl0XxHxUsCFg73hNdJlzh+nBoHcMX3iqo29aDuAlXMb0VxpZYnlO9RmxTBvLeIv23zIMgSuuFpmJE9UKSmhnSY6/mEKefMtVAxtssqACAStRZWCKA2siosAnOdyPMday3EHEi7i2Y11GVhSRvnicdKrDLc7mREuHKe7HtR6ztUXJAtUSrMATaGWKmwEE/dz0O5CrsxbcgwwWJ8LcoNlvLu4/dSsP76QkWx+Fgh3+uVTKzIG+EGL7Ggu3zlJeB1M9zmwcQPBdQictoOJmYQvVJtJv5MqWNyHDfMed9dhDMLXx7tyHXgBsPtuJNranTYKgCzSE15nqfQEIONGz6//YjPQtKGpQo8k6XfxO2445iDr7FuGMcNWVO1LDUmW+B2ELFxAPc5sYr8OLoicaMZSiKHEk8Xik7rXVqjVWfMV3yXqE6c8lXYGXhdevZFFrVL7i9nFrJRErc56Q6R2BtBd1XMB29gaYueoe5BBoxAnRJINUlFz4u2wavO42SvaOTbWxbKqDAqwoYAiGy0hSWKHPcBumokaE1pMNicmPc3bgzBInstinjdABxE+mAS46Jbsnyttxs7L8MA7WQYZfAEhisp3PzUknalEfgrfm90Y5hgkj5bA+ZwVDmsxgZiplP7M9y2g153JSKCZmWLl09EAhYR0W5E/DV8soiYvEfa1arFw2NOoOjexvuIe79VSDsHeKnLa4ZJ4roE3ix0bvc3/NOPf9qaPIDmIsdxYM529Uoc7pjW1tQLC3osJaYQzcezEOsJFAW/0wvmpMf2/fbXtAC6wagGM2vg8aqbvzH4cb9MEQBSPOZoK9umH+n7JfLm567uhtZ7CulHFc9cafGiO25rIc3IpMBrv4JP6vIMeDxP1EasB4GX4dKhALEeyDjlCjipXwom/jm4DrOTKP0MgF14RAo3LMOXVdSr+mTXpw2rS3aqIVdBgU0ZBDYBQybBHX4sY4NhbZDgSAI7BaCe8FzsNBeAXH/Epf1PGx/v+baPjbX2HtpUzaYnjDlh5XJO+3qmxlpJ/cCHR++csNcCi285wiXt7Uk3PRFGTfRzOG5TOaRP0mRHIc8nEE8yhdJYTGfAPXF6kjGzgPKBqIExb7AyfHl/x7//9BPGvHOcxfPkfucDcx77fczpm+bqRee4KrIb2tCmiZCtP/xwSKFd6apKLrkLBVO+gQ2M5S8ktf/QBesDCLdRiv5XOlqxNck7nF9nG9YweHThNg33H3+gID0pas1IPb7sQlGwOXH4Z5zPd9iYdBo6TxQS47jL415ai1h4s4FIJvuZgbQB+ECZo8rweJzAGDAk5phEkucNPgaOgzf9eT7x008/49PnN9zmxLgdbI9qbgnF5Py5kUSG4Y4hpMTMEevEOp+4HQfmGBQXCQVaSxuxF6bxVwubU7YC7fxi+RIKXfH7ovZvOhPJW0FzxW2jpN0dSc3JoHsaIOGkO47bHYeXlK5MoHhQ0Ot7FL3DzRx4PvF8vCMj2EFAW/WxAevmu7VpIMLNwZetlGJe32ujspBhOJe4mwDKBnUqGaDgXdQuDQ0sk+Vjo2RmwMmWblTCJwd1WVuXVrdbWTC5GALuFMX3h2ix4HjCccIQgPNQL1Er7Fqz3xxfrVvUtvU2FI7hmLcb3rJwLg6CvR1z06siFiKY8If85cdw3MbAcBoJtIMKbZPptGZwpKhY63wykfPJ53Wu1cMGzupZTQBA8W+A+9bwRoCxOfAFOaocb7jfDszjhgk5yeUCcMN5UidipmS1EsNY4IboJnRVrJ1AzjmFUpP2N6pwTC5AE60qi4rSKum9hmEMvn4MvolRL+e5K35//PWapcOZaT9QcZk900KUDjMUBmape6eEvwuWIe3FMCDHkEkN6PSjZ2q2gmk/XUHA8bkWno93THd49qwCJlm3gyyFM58EfECE+5hveD8X3h/vGODskVQR8aYCuarg2u8SFJabinpkwsaAT1F4i4lh7X4gYOp9W/WQxtYP2KszZA5rsUmqCKkk8JVPufCabFWv+L3BNbsXLSpkBoM2v2jtDa8iXQSnjIskKteiZxpR21iBtaZcI4tAjek+GKO1lcwP25g/kfB8YpZjgEBTmmPkAuJ9u05CLl0DOqMHRCPkOe1VcGikQwb+67/8VxQG3p/UQ/uYGPOAKX828+1Ua+jPoHbS79iNZBknNV1LH5xyfPsqpzGsLGn4uLazmn72t+M3uGDpQzVna0b2AQls7/fKwLkSoxJWLgRVH9wUpx3QBzCUudhGOuYkhcqNsw4qThQKY96YmLvDIfeqLNwmdR2WiVyGL88TxyGxvA1AnYohfujhegwJd1cEfnp/4LjdWcisE2P6SxQGw6m2U4E2w2MSPXGjNJe8vLVFzeYUCDNZxRZRvvh3RD56AFIPqkvQNesjV/+Kb4u+gaAUv1U7zdHsC+NCLUJdK+/qZCOqomgV8EyQOmKFlYUpEZkNDqo6g57iXvTNXskChsgWOfi0iZS//BgwO2iPWkANon0rEs8VWHXCjY5yh1x+5pjavAzjGBoYB95XGh5nYJK4xAnFGDgL+HKGbPLAmQpOpJnCMyHFyUS2YmHkE7begSK9wMpQOWA2afwAFuxXfL8wtdKjam/oczqGdGo80OjfPuRu1k5XKwZyMdFP7SdphXOxqDUUxizc3m7sxJqjaiLTcFbQ+WdbMdNqNI0dFwyu4SrymJEOO26keIGc9xBsQ+BmYBXRY7emzCyYGf78ww/cJ9WpJiDTtpEUamZTYMRFPsZAVsAxgFq7E1/JLp/Pl1iTdpdMbmkwIfFoJ8WJXzwYr/itwYIipccx4z7JTZjXJKpn2ThsQN9fiEUrdAhEdECFiGGqQOUQSleBSp3lCg5tM3OsOPHT+wPDHCcGpg24HwT2ivoLugIdmvsRGOMm8G/Axm2vtapCrifgQ/s1AUT3A2MeeETgPJ+oWNShWGEwTeTnAK7dRsMTDvObAEZx0ioJlGZrAFLGEQuWofuaBjeVjlxLucLVbf5eYYY9JNK9CwrIHECOWFrLx3DpjAlYrqJr2VKeN0R5SPOX4YEeK60d+FiIsrCRecucGHYAOPdsufN8x+P5hPugK6ENoDjkc63AcbsBMJRPAAMQYwP1xJfzgbIDtzlxhhg5WVgg26iB0erXJnYOn6c2IOBwHP0ajeyHlF3YHBxEHBbKM+i8ZSje896Du5mbT/v7Se0/dsHaF4uXx93hRWRpGkXjMLoBDCuUF27H1AWU2Nq37HpPSHUbsIQoJ4n2ZTehYDwYB+73G2JPReei4UwH25Wa68I/14OdCtWoPg9ImSg3qsYUSWk5o2B+A5x8+cKJCUfWAKdADzzrlTwyYZt0OSoQFV8UMo95qPPCahT5misS0i2b3uOKxke05Ftg9qG6vuL3xwfmEsS4YGLkL+FhZrdJ1WY0Uze1/b5VKBq7BFWpDoPhWcBIrkEvHnB9HceY8KFuhzmm0BSIpuI6RKFOhQlWmC5XliXuseYdhPAFB78/1knesByG2sa0zRy6uGn3mDmnKGd0jDnzRaE8jgOzO30FtofN4AjEOpEZuOHEWE9yPH3AMNXRAdIdq45tq33F7w/VuqJGsdNbCbn0fd19nkLq2JVObIqtQ+6C0hMlO19AYuVAFWcRlJJEIn6k9fk8MG2ixkRJM7HpKeaikLKN7/PAYYYxDx28SuWN+2TrnNrJaCXPhud5butrTrIKOQAy2UoNxoKLjotBnYsQYx7cXMvIHmx7akaNC6GETEIcPZmaKJ2AqUod7AnLK5n7luCalXObE+SzTmRKxgnkfsCHI4qcCK8Pneh8OUJGBMq4GsKDg4YBtOvaC4I1dYmTA4mNZ/Lnzz/Src04YJYIL/duqLNXdkNWwv2G8gNhRldOm3vAHLWnSvw0C2eCZ//tmIiTVJPygQwOpF1lSIydeCZcHZ+StdeCjaRYeFCfWvVyI6JMZWHkIiJtkwi9DZQdog1uXu8VvzM+rlkOd5VTWgJwsXkyN+vAlZyPFnlvx0B2XA21RdZDAAhzjpQjZfHaKl9ExTZXGGPAxwEfgJWzC71ODk8GC2OMCbOpLsQNz3rC/HgZPIgiXsgNGk1z5HnCfQLD4YPuXc044rp6fR6cPwZ+zwAZITZQzkzaJOSaxnkf7tLQukkfCoQGKE7z3WXxYt71uzsgGwQG8HFa83CTO1C7W+RrGiQSx7xhu194t3NKB0mjVKAAx3J7eK/1ZCKWwG3e4OPOAgE9+CXoBIQSgsAN7jzXti07Bl0NrESp6UUSieVqtulwfjsOvB03PNeJnx7v+PLl33D86TMKE491Evm2AbjhGBRazjnY7Qn6kTPp45/t/pVlGGNgraDnNwo4HxSp5YlMwzgOfbriv9aep3rFd4rmjmeeFHDP26aLcJMJZKgLN6aK3pJFbm8sJtGvY1SymAkm8jZkt5yJc3Gg2hwTxyH3laQldMEQZpviBWwzFG1ypFJt6p7pObOULNkL8Ut2KSD3I6uAf5is6+77YHMj9WDsNqk6lyYrSLnEAKCOQ13JwgRGoeLEGUQn57yjxgFIsBnNl4ah6nIT+tb4uNcCjQC7TDAC7w8CGm1dzsJT1A7jbJuIExUc0katDrsLZrSZpNNUYsU73o4DNoeuOTscZVxvZezgBkirgp6pO4eckj65/k10pqqdJDqwkcPIxOINtQuSUhd4FXbymbmwznftqY73MKQSS3YKZZ8utLHMkfGOOL+IN637RAdwGdF4QOhk85YJiW9HpSt+f3y9ZgmubLOVCuqOUs5kuhakpL72ZrRONNU7KxaT1bO5oC5CJoEdJeFViS+PB+Zxw+1wwG54G6SW9oiAoQ3Ws/dwYM6D5hrjII9F3ZhjAHOMDU6FM9ka4FprdoOPgRGFnAB8ID0Q54nFNp5yHdsuRBxLkBsQqkpEDek9VIBLB8p7JOW8KUF8FymyIbZrzX5T/PU+6wInaLHR+xHXZetEpxeml/SbGppaHMhqg0m6W0l8HujhhM14MRSQC1ULsdjpKBuwYTgs4OMAshlBLAiGcz1wKOWAzQmvCU9RVJ3Mh+G2zRrgA8dtsouRC/Cp/NPhbfIg2QSSZ77LTpgvVjbEAkk3zbFk+oBXHiGiLV3smFgw55Y2mhbsANrJ7u/Eb7LhhVCoFp57O0lA9A0A87iJUoS9gaQUgIUgV9IphKkAVjyRa+GxErmeOLwQxeFrx20g1EZPHbRIUkGqEg5aPZ4aJGTA9vhGtYtMImVbtuTDjTFxF5JXxS5MYAJ+w1qJx3risYhiwGPzrc26rc9lPFzJgARiS+5FN1mf2ge71lQLZ50BGzeUrNxCwxspBvZrg/meURR4Zy5kFs7zCZvONaVJte3vDfHcF9tjWOtkkjcnMCa1PZr54eDAybaurQwOoSoOGoxuO4p3z1Z7AXI6AaDb+P/H3t81WZYkSWKYmrmfeyOzqnoG3F1gRUCA5P//S6TwBRABgZ3d+ejKjHuPmxkfVM3Pzd7p7urK5EJkGN6SXZGREffr+DE3U1NVI1o2spE6Br5htgtRb8QCHMjV1pOowaFEoG4k1N1LHexjd9QYpIBS95B7rm2uXQlB07hKXEH3AzXYSzkjMOZPyDFhCUSdMJSExRd39mP9mMXOlwK7ca8+F7nmh3FqdJaGP2mnNDAaKXGiAraLL68+PXKdtCtVTEoE3HtAnEAQFSoXWoidDLHDbqQBSuDLgWoaQjumZpVoPhQKpxFRpj3kZLGbgYSMS+IJxInH2fbOhfdwmB8YuXCehpwD4z6QovA4OJX966//jJ9/+gPGuOESSwbgLIyiiBKiNDNCNJgsiqU/1o9ZVeoELBnAJOPheqFdpdT/ZAEkDie9KUNW9JBhgAs4ilAnj/vkZgcwCCAiE7chq16Jh5n8kCaaKAqIcZkYwAdBKPQMo5LuQgOR3USpJ+DzeDxhx2TXt/gezzrxWJzLYc4cxoDdMT7U6W5HLrquLUzNVIi1kOsp51ZqQhNMCscACzIjqJUZiFU7aaabW/yrn//H+j2ruxpB9zWBj9mTecWMGHDuZdnPm0H6js6BG4g8uZfNQCc/UlytY3VRA1JusHljp7fAHCQS52JO2yl7BoXdNp3aZgFLVokVwFSR4AbmI0Xt3nAO4ExgF7jYuYIB4JDijMIqDbQFNCojlWs4u4AZiHjuLk6EOsplu9jItZDrlPauNugVAk3n9wwi3KJzobCKIESPZbebGazcB/D588+0o43FKtGnrqWQDx2Z3jWUDax02HzTAQUUBtLnFpVnXGiAVc+0ZeLXgi1UYYorh2RbiNalC6gTsZ4wN6TfeagXOdYowNzw6dNnPIchsPB4PrAKuH/6zNkNBhyHkzOqlt1wEKVYyQNOQe1ciWNMwDR7JIJ+0McdPjmIa8nKzI3uQiVe9Del+cf6XevbPQtkEZHghNOF8yykig3vpmQVqhaqBjKYoKxMXrsprY86fxO8dsec2zXL3HBkACvY6QPbmFkSKpZse5tG8EKhMaPTG2/adrpKzAFw4jifow9Y3ntFpwm5ebn7DoW8R/g7XilazIvgVjSylCtRa1vowMFCxQGgDDVubKXaRPrEGAfSkpOOkbvr90EL+DGr921qVgWnMw/Fyxb9C65qalZB0AUEurj+S9SUP0u6kVfI8vN6viogasHGpO1kyhFQ1AM1DFDa58OG9koLiqFCG6LPYBene/5BJimIAmxcO/IYE1/iC4sWFPxt4vl4wpC4zxs7G87D0i04wykdroGzawV8kg9t1vQCUluQ2EBYu4d19wPJ11QfgrvvXq9OOCuWnJ6uvZlB/N+jZ7P0vyUibYcO20VzbXQVwNaiKaiyQAgm55PCIsTzwZim/d8dCE6aNpQL0RUFV0QbqOWAKd0pfXQuat4YtNI/k/rA5vuXOsizHT3BjsUGPru5A6iICFQFPGjDTxoOqbSu+WE2BnxgT87mPTyBXMi19P2BD47E969vjZT4X9I5ZTe/z7aSG+Rid7hCRQCt6gE5qHbsyRKwoiTdZj8LAFPXwzHGsV0Mu9OV0k+1Y2zzyKtYzEeMzZboPWBiZJgZckx+XwYLKINBdK8qHtcqTtwdK2MDpBkqeJfm0KCA0L2AIG232EwYPvbXpe6Gg3NKEjR9aBojhfElmu2/vv4GG95E5gmvtVHfQA9v4defP/0kCtTgRPIxsedaCM3rRCqMTdnjuOOYBwe+5AIqEeK7S+qPguwfEWx1GTeJZaGCbhIQ9xR5ks5UxQmi9UTmA1YP5CosC3i9IadzTLxTDFw3dmXOtXD/fMeb2lxljunAFBe0E4CIhfP5jlgnbrebiiu1rEzDYEqzHgAFKPJIEZdbSLeVyfPno3ysH7cs1yWgEuVqaQQtxbM9KVn0JnWzUra7Q9bRnaAfRqoB0a3QzZ2wg8N+OvtJufewWSZXiNGDEeX6pr3i1mkbYFs4zGCzLUhROwAxPjFojqH7ZNdc7Oiw6zHQc3A4k4QHKCTIbfrDPpCtvfqBKr7P9ANuA5EnuyWigG26BT7q5h+9tluVmWbIEGPri7yNLfjT7GwEO33k43M4ZlQ7T7HwmHOwo6eilaWpugLWB1+TEaDhW7aL3irW0D6oWSOTXYx3pz0wgZhC5WKRb3Sh4sAvihrNUkO2grEz6a82DJi3LnAGaVIGSA0CqydWvON5Fu/JAdzmZ7hP0cAERxdBAk6lbk2K6SSB4rO/JCIf64es7ISoeddMvkrgZc/YANqRLbFwDdobPpGiuLi9pAwN0JDsjqol6ilR54gFjAPubTHO350mgGdcdBLWHOLPG4tUV4GiYA1aSjvMDlRyJs1Kzn4wo7bUitq5vkdN+360VKXavjShMlgdlrreVwZKzIoxaPnqXjAsFu+rKZZC3bGufOpjffdqYLzd/EjPNwEuCUm2t87BweLaYdd1bpBTsYQSAn49LPbe9aaQusPGjTlEMzQqEDA6C3YMMxbAFIZzT7g5bNJ0hJ2YQA8zmmYyNDipF7RDACkB86k8w0chsQDQonpFiCHU4yJcebvcBJEYg4UL4BhFkxuaNHVhUcpnfec0HPaqcJx/vmv3VwuQPdX8mwunkfC1dgV5HHeYH3R/QHvH80WegX1Th6yTxwBsHDjEz30vCq9SForksbHwiAistVAVGJOOBUQF++1zZdHpBY59CHanJeGk3FShInCeARtPfLrdOJ9kR8zCkmvWMA5wmc5AQ79xcgGf50KcHBqX58JtTjkqTCHCtX3vYUCaywWDFLaovgOIYpPS1kXIx/qe1XvWZBqgBgLngWTItrlQpinh6AOoLfgMyxyf3z7RXKBa/Doo9NXPPmTx602NMcOKE7HYoWNnlcUm6S6Jw1yFCwt0TtLVcwYHGVnTYzJFyeOdzLk4OiRB+lMl5MbRCIcORhcPuagjqOBBigJc6AeKwuQU4kb6DkWZBUPUdShHGXCunQSMjR5/O2X9Y/2+ZYDoTiwgXcUdaXGAIXfHdgDb4Yngq7I0m3t/AByYxcLTkW54m5MCRR/weRfqlXh/PHDMwLzd2XEW/SCFUK92TdNrcctNSckG/grb6rdpMTT5Ixd4Rcl5iOYJa514Pr6y46f2ScAwD/rgM0njSZzqwDhoy1rd1RwHpk9kBlbQJCGFJnr14UeTk4jCUiFmRtOSj237feubPdvfUTyDuWbQBM1jIKqRTrgoOu8N0JSAAB/1FiFmhKGBm6INrUxeKjVLS0WITRagZRp6ps6cC62heQ/PfneHTyZt3LMJJItUQ2nexyUcZj7DOM5O8VAV3ja7LHLndHZ0nDGd06udTp1yDK048fTBWVGLh5IP9biFPWZbFGlWRDvvpOgu9rFrv2u97tnWogHdHbXNHqAUsxS7qLVsCpSg5g0JbeqTAaW5LisWVkLz8GhcM41dLOtxEUm6ohWwVnDOjN/QXlnHcMwslB8cuo3L1jbEsEhrzd4JB/PxXTrZgLtmme0OHUHWMQYGEmndCQ9UcV+binRTcVzoGUsimxVQuXBqwCYp6Cdtpc2Zi1QB2r97LMC/sv66CP0lH55jSEch3+OgV/0YB+a8gdaREBfMqMIHQ04XFVF9oX0fMLbb45q+LAvcSlmRLjqdWHvOm5LJ+hN5iygvGfTCt6IjFxNKA3JhYCKMnZlYiYctDU4cGox1h4vnNowf0LBLoBbFSZk+JubbZxgKzyA/m5SYsVtQXeGaMuC2P43kBhuALvgBz4DBhCJ+rN+7GD/U4QCuoG2DDQGwhRjFG3+CTkA9oIwWy4Zpbxjz2NfdgK3P6ZtxNIecGSIck+1KS6BogEDR5NhBr7nBHfDoIHRNaU51zcwlPrN2r8DuUHA5ejJ1anJrJwB83y4bwSD6a45hSRoBOPhtNOqn178eT8xDzjAAnThAzmnCaGnN70ioxk+5k+WP9fsXY632rZDb7hY34JNCkC1FZxHnlsiuBlhNl4sgraA31a4AOH3gj3mwQ+CO9Xww4YpAPJ+Yx01FMXCK2rWSHP0C9yUL+cSZoi4o3vXQQE7U5XMGDOmMgysS9y60EwSszOA2sYr3QRbpDcfgrKeqxUnSaFtzEy1SVum5aCG9CjmnKC2TB3xJTC83sSYiWsnF5f+si/1vZL3uWcbDCbr/A9wvBNi6v+uKWfv3dU1oU0ogboyJZyQ8A/cxARvbvrTtMjYNRbHUTYWpj93RKLMdn6Mtf/r6fxOvbHeqmVdweO0uQOS65n2m4wKq3GiNDge8NMfDJ9FrCwx37uMCap200/WBWk8AAcvEGMBUh6NiIUAzCWsqzjius+MD7Pnutc9S4KLq2av7qHQWAp07n1hxkpHgtfdBO7GWgCHmpm2UoO7y/lmOoU7RowiQNMDCwsTHHTZsg6HmoIvmuHEots7gpnv1vJry1r1p0rnJjQ7g94ars6OunJlcsAioD+e+pT7dtqHNnBMmsJyMIubxnJ/DoZlsDHQcKHWae4YKC/Y5/nyZ8ZspWG5Oh585gbWwsnDGCZhjzhumWvu6XrrAGngifUSLXKtRrW29y6FTtO01Hl5qXxo0/MXlD07PMmSPJUqiW966izmpwUDCi9SAnlxdxSnBAOc2FICMwNf3heO4aT6Is6VmtLuspD83+XrYqKCjqO2ApqD6gHtvRh56mQHkSVQl2DWppDhuqsOCpvFwr4ga8bF+1BrGvWPJjhmFVcAxOYyt0dVV7HYd6n4Boo/IUQ3oxlbtllsHr6riVF2hZ9HFJ2zXBQDkWkFXNSvI2IBoNel9bNWLMLAtKXtPcerwhYxncpBRyuZy6mf5MukzL0b/bhcPY0sfAHog6J6WbpyRs2qhQI49UGzf+iB3v8jFP5MT4H2/h4/1w1ZBnaZFmoYS8I6rLVxsihOAi1bUexaAeVGzUYHH44HnOuHjjQ5bfBrqnMYF7DTFLzXc8Cx2ocdoJ8KF9zhFx6LjG+N5bPS4qjnBBkTgAQDmPDuKlpI+OZtm7/gxEI93ZFLn8Q//8s/48us/4af7xKfPP/GeEQ+blsAFFIWPS7oAP+678DYzdOPfrIe+1UaQrQu3j/VDlqH1aEPicVGrABXEJg2bABh1BUg+UafDHLc5SGmqQJyimEjX2Vx7V5yMFmT7IcvRQaqLnm9qAOUsFrZmjMHTh+Yd1VV0SDycEn/v55PhAbYg99SQTnXCu0NdLm1IB3wmtS7OPMbkf3MxmS2aRfQwUQINSQ2NAXa88X6LQA+Oo2b2Y8/+qLV7+EaqVcYpF0qIMtrF6QvxrQqtM8vupGQ7SMrquS4AnAmnKM/m6nCd/FkVBLxJSD2dU/u37x1nUT6m5Ayam9QsRzdDxkI7+1Eyr0HDSdlEbZ1cXV2eyt01bBOZBMGeAsF694NOYLGw+0UVmH7TyAmaJ5xLrl+Vur07R2JXc87f2QGx/r8uG9WxoIL+RJzvuH3+A+a88wNq/nwRdeALTqyojeCGWqgAEd9O8uYUgqc26JevX3A4i5d2lYoWgVXtqtGcQ1JMrSgKecE2VzmoRuyJoxMw8fna/9nBCe1VHPaDQgU5xk0p4MefCCWpS64c6eQCRqXoWByO9emYiMkq9BiOw03UL8NZtW2MvTerBhpFGOpvGA35sf7r9W2LFbxR4Lv7kLEwbODt/obpA2cE3p8nap1YSXSWN/jE7WgxsO2biF2w3oPaO5k4F5P55gu3GJJIQAsgfQshG91OuzqCr+I4ycx2d7AItZB2ow7F0iFOdy0+zoG2xjUVREzYpnQsCGDFiTMXhtzoUIkpb++IteclVJ64zYNzJ1yi5AyceOxiywyY9lE0f+96TSs6EUm5CSEDAPcXaSAAbOgggdD+xDoX+bkSxz5OuvJMY6KTkXg+H8jUMKmS8Ff6iD3RPEkFjHVirYWzOPS1qvA8H+zy+eRcA+mdQtOh1+4WNu2QvboUb/lQXGSnpL4tsm1gHjQiud3ecLvdYLVgPjBHYdSJsxJRROXO5yIdLUkXWyvgCE1p52vJMoxJWux2oimigB+Og9+3OtZCdJYE7e4j6HI2UKggVOiJPdmeqC8Fvq65X9MI5I0xcNwn5jC8P048zkUr8GqBNmMhB00y2fd5yMjg6hC3wQIgIElD1hhuLxzc9LONgndCWUnC2BwguCgANSIxDyZFJYr1UCLX+RGNRZzW7Ah10CVFloFDCrA6o53bErNkEOFDiDR59K0bpCvnRwHyPev106MJi4riDFguQGYfsKmuQQDSHDFE6RwWNQ6mAZva09k2t8itFWXHLGF5Mg51J6s7KzrfmY9SnF5txQzmzKPPdWvjA70fNwyb7JxgYaUjIJfDInhl5xOk9XK+FJkNuVk5NgSA1sE8ADQTDmkDzzZPyJMznQQWWCW8FhyBYRxoWJmotV708HQu/HPrr1Kw9l0MIW94aTONG27HHWOyUgq9aR5mTgewDHUNXNV+ffOYHFmPnZATMWEh4hJGHkNDT1JcNjPMeWwKlwuV5nlcO3hw4CEPoTJOKJ8G/ryZaC48cNtCd4j3V+UaQAdUDVQ50iCePqlhzwzcp4bOgRcmzycej3egbpjHDcABs8JtOI63G85gUkt3AAqfIzlrIbbF78f6vet1z1bR0jkxwRnNLFTfjpu6D0qWALUcKUqPKpyZqHOhANyPQy13Fg9LyXdWH0LdDlVb96UzYEKp2zWoXaPMcqNZLTqGDlfrpEzvyQzb+hndOgXFvUTprmJfBK5dPJscWy40gZQFuU8C6vShyGMlDdTgYIfoOvSJ+JU5Rh0IEXSyWpD2sb5n/eknWEmN3UABxm7uUD+LB85glySZnHUM6ym+Bs5XStDtiXxl2jpmFtJppUyHoXbyG4hYFAcvOgem6FcRF2XBD1JtOPuv9SHtXqS/Cdiz4nOWF9YC3t+Z0PX7dR9bTzTaLreAt/sbCsC5ntIOFGhOPNQlSUT6BsbGGJuOqHINAL/fTjFEkrWP8RFrv3e9xtrMvCaaFxT3KARfsXS9GLncDAOaJSanM3e5DM7W+ZRidAvFxy52GNNYRJsKkKac9HC5HTs3+KjUU4mfAZtaO9qUAxfHv506ex4PnK4+t+PY1NUS7QbiyJvMH0xnxFqLNr2DXXQHXRLnkJU2ChFPdYpE6XXanyby0rIaZ6Awrn+4YH3P+ianLcW/DLJ0wJjLbj/Jgv19l5V4D9x0AX494HcMk2OWikabMKsdk0azEGC0zM8TXayawD13dok5WDv28MAU6E+Av23WVYhDYIrRyW246edoxU+750XnTyQqSu9ME9Bb8+FGRo80TyagxivVjSdz4jYHOzjcnMzPjwPuye5MhUxSmEuk/9ca8tf1N7hgYSNaqxwYB355e8P9dmcgMEPVKb6xLLvMsADVd1ey111E/lyh4oT5odwqEXFiWmLuDgfEbZPAxrZkXIgwNnqBars/BkXIaxldWOj5Zzu8oANm6IOmtW/pwOIgISZ6pUIpZTFpfj3GbbDA+jQ/w60DXKgq0gR5o4D+8aTrAITS069engIfZ+IPW031C7B7BnPc3w7cjxsAYCnBIt1uImWVO0DEbmt5gA2dNMrRRWN33QDo8CGHsql0Dib4ncS72UuhYoA6herVvYjHdd8Y9ryPl/pDXzuGDuzsw1B7vaett/NLKn0rd/i8Y4QojHotY168UXfb92knh7kDILMLCt9U8H/QAn7womPZMDpGwbDNNByGY5icsYCywuP5oPC3QD97kL7HAVXGAkSzGAAgz4WlmJmxJNYdqFVYKsDXYoHiop5OZvEwG/vrLB66USXHIadTmjrMBQrmrYvzKnZV6hTiNzAHUGPsjglniYwdW2/+hvN84FGJgRtgAdhCWcDn3Iml5UWpsi7mGwAQUEDKy9Brb0XIx/ohq0jbI2WwHfdMzHdCg67O0yFdg4+5mQg02Eg814k5qMzLShzHgWMcONWZJhc90XOTSMm6wMI9jV2xk0UF0FrAVDKVHV/RZ/hFBb/NiRpjd9HdGJvnHLjJWvUb/YBieYFFlMEg9BVRJbq2ngMBH8DEwFmkZGfGZb2KQsZX5AKav+ua4m6WH0XzD160spXNrDWtuuAWgnEC5tpjsB2boGR/uMFz8XfQ8XoyT12LgIgara1dMtjWMwOUNpDWxxyyXvYsL7da3dX3FXYuwE4g+A0fQFKzDNB9dXT34UqUgUpRzBxmPTSRepAGair3mGE2AgbgfuhTI2BqBuYNOZDJLgvcMEA5gpVjlWNTvv+V9RsoWLbbmVnAM4BVBvNDUxaVWPEjxnavqgWToBeABlalRIesLNcKtXFINZhmiDjx/nzisBbtqg4AZM8rzn3m7rpEkqfODo3YvoROdPFyU/dTIvjNXgBFZv0hcepjwUAqQFzVEn3px8QxD6wCh6/UUtfGN6ff1LKDYbdRAU437hZf80WrDD4dkPXeFjZ/rN+1Xvcsim3/RxTOICLw6TavLgGPg12o5EblKCBfrEAovhZKtR20moLkneDThpQuEWMnQy1Cs+5KbMqCYoH+z9wpdITtvUhDt6Zhibdfl/FC7sNP08/1/b5XYZrm6g4UKO4ED/uQ/grGomSOA26G5yJk4EJmeojb8zyxj9AiLzX7Zz+oLN+9Xvdtc+k7kRK8gjYx7X3Q++pcmqYLuqlkKTamBsGCvu9tHbnWyesL7u0DA7AWhuvYGQdpK+0j73O/PmutG5ToJylRs7t8oPapaYPWgnQlYyV0DbI2jZyXJWS7/lRhDFIGTt1zhxJVDldcCN0JlQupIqgHbPUE6h5+1wYi95tvPcKH4+D3rW9irZHlAHXjIml3mZG7Q8prOnHTxHIMiVxB4WwmKU5RbW4wcLvdNFRtbUtTUrex9w+6gAGLYAVMdBe585NSV5iFjBgSfn1vd4XBvdyAqxnoNGcCIGvnWmgUGyWzBhUjc058/vQJGaSQ+ZioNIQFRi2YTYmHB6yoqbU0eJ7IWHx+AOVT+kCQSv5Bwfqu9U2cdWoeWwxeNhlzk3RXnqvteCYTkOQmSRhMTm57Sj0CUQ6zqQJCNH9ouB8gNy3N4zDqhsbQEG3t11TeMkydxQIGfLsNXvGXb6gLkJZe7M6cU4ZgxeLetiC16Yh1MYWKgxN5RqRYOvrZLKSkC6SAMT6f6AGMi3R06Z/KIJt/8PP7C1273z4JXTd/KKC4btAyWnnxJg30bAGoBdsoKa0ZlZQDgCWnLmag8sR6Jp4o9EC4mjfhgK5ED7uPwqCizgaALc4y/FfiQtWVuIbDXL8PJW22q81LNNdtYW4Ior8EA/mkQ8+cEdoQBqit6uCwoQLpL1ktwAtRbcauqgyAj4GbD6y1PgLMD15ZwBkUqvoclDwmwKL00ixVFXxe9ClHbdvmyJ7qzLXJJia9SLXwm/++aVb76y6E+xF0oGz8Vgid7her1o6A8w4KSuKUjAqxgIqm1ovoXe0gtOkw+QITOMVj5bXvx6vLx/cVWbDh/Hm7nIQ2SOdMHga68/JRgHzvet0dPjiA0N03el9xuf6Y3Nog9Pft/ob3Ux1VoxNhZhEAGnT3O/MqZUzWt00frC4KoB1pjiFEr9y4/3S49G7jXCgiu3NOdV4kaPSBnnOUsmq0Hiab1zutKhoaVCHScYYEyUKOP3/6BDfHcdypd6oGk9r/ngdoRvfZwc+gXcKMDksVsd/fyMJUDP8onL9vfbNntQ/cB13aDFhpW/cxDOx4jAM15o4ZTWXBviYDZYPdaHeUD8AGfJR0oEKZFeBM8Yf5yRV3S4WBQeY3gGgs0M+INttD0szQ9JMu8yn0VYweKlr6JxSvG+jaRiRVmoYu8xt9Ppzp4BgzkM8gEOQ3AMF9moVnGaYZ9R8OmE+UD9QYqo7GFgx/rN+3dkMBjGY9+NFeCs6spl8ZfE45RiUHoRa2Kc22Qt9n/UUJNYDmN+rWdSeZhguD90LTBrWnUNqT+tM0v2TVvfPfBIHtUselx3a+DsBk56Ip3ceO27toBkBOhAou9Ky0nsHD5LTtivnabH9+ke3mCrCLSMDe6D6yGVOI+kv1x28vQPiysREt03kYkODWOWkateCaILkHkFTJ85iDsu5jAF6o9Q7kCSTV9922N5h4ZOJfWgt09a/6FExBg84+qmKrUTtRwebU7yg41YVy7ODjELdSh3Qjy+Y74PT7QKXEoRz8hXjCjFZoKZegbmU5cAWnJPdaDuZKBMXld11EDHyElx+7Wn/h7bqSajV28lLFwhCkDLb7BfYeKkQA4SaXM6CTNs7p6A4Zr3Pzind7Xk5uV2ejf54s48ZgDc2b7xK3dB/wt3e1be1+4XyNGSgbCpIKLFW7EM9Mdfhso94m+M4wdsBs5IWvqhGWRA/1RL+ftu9VIK0W432sH7Z4SPmeAp4BrFyy7TykW1sbdf7p02e83Q2/vj9wBoA8ESgcTgH2mJNAiWLo0B5CAZkEW/IlzBmKosO2PQcP16qCZSD6sIKxE2YDE929EJd59IGeYrVqV8sFaUPTKKCM7iux9AIGfv7pM+63OwqGmwqYiBOqu7flb1MXDSXkMpArkH5Dtv01bNsYZwykURsyx0e0/VGrwZamb0LdhuiOg2YfQAVGd/MKLCwYvmhRmnaR47IgwwDS9IZyiUaAGzy0Bh9fX1OjphUqQFrwrc6iiugWAJMG9iJGh+3Hh+6dHePrYnukKC2Q81eATpekSHLmDJ20NBjTmLBR38XU0PMEdVUDPuwbend/bttI5GP9oHXtl4wlAIf7ywwcyCcWTTWqV0TWCxd4edHnyH5hEtlDV8F8I4J5srp/e8/vrpzAmd5rRVAF/TMpAxoUyuYGjSLokAgz3Vf8HUE8/LpjOPRa+95RTsJ/p00/Cy/+LgsYCfR9oHVzVUYX3PNJrYsel90eg3nKZEFg0I/ogPTNi+aFKSnyeYMZXVhSnQ/bN2ogM3A+OfyNOZe6Fa236A8QYMEB0pM6qSkhWaieo6GwVUTnSg4sEOrVzHZ6x3OyY6PEmeK4F0DnID1tUoPRFJgoCnlQ0GELDA8EKCYj4kZOa2Yg3cGRSo4l+kPTqyAqxHMlq1VnsTYlKikUjm3fdyFKH+vHLDOCRyXLoMxACDFbIYcSH6TH2TWLPktOQJkSFzpGtpsZBYaRiQH6bFO/I6ctQDcv/+4qKzhBXJ2LoIPQVVY32sEgEKUD/WWuTIYcfrz3FwuotU6izoMoREajxRKIi6sKoRLsaBA952DNErpTOIPOSQaixi6HOOh5YX1/9FyKj/Uj1ut9X1cfC61Ds7IX/VsLCbm/MzlVaM4D82BUi9SB50PxlL9hVUzA3WCY3AfATtAHsJG4FkHuzkLJzhR0OTQfjK2N2EHCRRW5/gKsMFFTVzwvqI76EU2TNiajt9tNjy3UGl1gJB7ng65DyYRhzok5Jx7PB0aDVGWoxZkK8MnAbsXnyEAlBZJ6tx/rd65v96xgGZ1pIW3DSiLBQ0l0QnsTimODFvlMxlLxkwkRrcB5nROGobgTO77VLj5ZT9R2o9rFhhwrHcY4J6i4JBK3Cs40wrHZETuHscvSt9HoKpocUBxuOGOhkrbTbaXqAhf5fqI/GSZ2JrprGfMfB6oIyEZyvhiGswMEoPIkHWhwMONHvP2+1Vlln/Fn0II+Fl0Hp7Pw9DHhcFFEl2j1fAAe4dL3JlhgFpANwhR1d02NuroSEIvmpYvSQGdTrYZy6aD2r2lXrlyX9fRil7soJN/FDyBTa4MP2wVLg6Owa9ZSk3oBwGxsYJIFSAoguFApU9HFrgcLkGckBiRBQG2r84ygeD35PuovbNrf4IJ1fd0f1DDRkSr0B6A8XEw3sz30xCzpfCUceIwhJNYwxg0ww5SoVTkTyg74OIiw6sm7JdZgq+FCJRo1blpBNClF1BeDoS3zTKKcdsfQFoF3M0Tt0FLQK/3sdhIqunPcjwPLEulJrYA54FMb4kKcs20HQY7rFuQbjz9SLSjmzPI9rPBj/b710mPYy4xiLLtSGSVEQhw0uKcLiC4+zcjf9I2WyZpOw4BuconqYqO6aOjnxSVQbxIWu3NXAOhWaqzSwcnD1boYbwGRRHLzpThX75jCXQgBNMeUoJeDLu2ihHknf7Z5p6UW7NLhz/dJxDLRYjMmiC7EvQ9yf30tH+u71uu+vcAeLTNgHBi2YKABhhcBjgKw6kQqDrvJdjZVjII2jh3HhxyxXKhXtbg8A94xGy8mCo329SGn+4hFvR4bQDtMXY5DvfcLYxju5uxyFDCs5GcvXYcK5HHcNhLNuTpPfh7qvlQVznVSz6L4eRsHjjEoJF0EF0YVciWGaeaOJeZggdamEcpTP9Z3rC5M+R8xDzK+7X4I2MGY5L0rHg03TM3d2lohd0yrra1bCc0lKHXgdI/YhfJe4ySt8zC065npF7apR4OafX+VbNYdAlQuFgWTxW+TMHSSVtf5EXKyTAMOpxOR40ose+4Jb3By/8ML0xxpS2g7p1avWLqPhjJVfX7KREyUmY/1+9eOqkV90joX1nki2kDBDGPeMCaF4a4uLtA5Y2EgZT2fO6mPTbHvglheUxu8G7ur3S5USgjEFCoAokd3zq3HIHBkcu9TvorWBya2kYKKowbo0Tmy1c5LldDy/bx0GnuOCMRoGurcZDlK+RGbA01xZc4e0opweK3AJxk6HcNRfmDFD+iAQAHm+lBTVVkgKuDiZVotFDiunS+scJuOqCGkrt+4XFKcB6XufT62D8yh9rkoJL0B1JREk6PaOagRlBIFjDNCbCPFTOquNpRZf09Uq50BGMzi2gh2oRpZl7tQddt1TBjWpnB1xRslMaZauHxuBmM3qIhjgtsWbl4fdJYfuRqRa+n/HByKkzooXWhyV7i9J0qJ9v1w2HHw2gppbtqed0IOgbl5ZXkNSkgpsgNHoeQIdKHEZbJrbCxPe4yg26uAi3x7zvvob2kq8GhKA/mbabb9vHkG20ZB3ByYTWPE5apSJUrX4gHIsKaEYexZHwVaaTfmUi9Iysf6MSuCNM+siyZq41DEWygNtzJQY3HRSuiyZz6vSc5o/ZmKDyeyvOWI2qzsuOU3jkFduKIL9b2//SX5VMcaVyLKeTukvbgSy+EvvPvAZXeqDiWpKdg0njm4wyKFIuvf6JL4oOGHO33oAzTadr4Pd+C43bBkaz7daSk9VEzpc/gYRPjjVsdGIsvqRPjk1pHYd84DY4zdjW1xdYvAzQb3oOcuEJr+RHv/1u2UznzbP2MCOPdgTvTvdjea3bbrjO6c4jJO6I4yFLfbxt+tz37BmbsbmNuG2ozPnyAYySKddKvHycKiKb8mugyMg5JLsfY25nbQtNbqyRiC3PGPOPvDVler1UOveV16f7r1ic2EvC506OUhmM9lNcG03deuArntzQm4yyUzO1amcmrGpd1i0cvrOSIDl56aIJAGbMpQhvfY0D6VFrC6qKcuL1rs3EUJBN3XVv6RoaG475KzVPdUnO8B6jwPg3J0UItRTW3XPcr2NTuD3zuIsPTGGVzocT0d9ARWpUQ0gVSoPbHZOD3ZfAqxC5yRGM46fqUqMJmGOyQmsxY8MhFscU+3/003f5+JdBUQugHnBHMJvW0nTvygqYspTB2e3p0N05RKiLum6rQdNlASdlrJHY/p5TMKpF9paqZRrVZqoQ39/hgaHGaGYx60+iuALlosjlhLfnRAvmfZN1/zb30wjjHlYkK0YThkp9vXdOwDCa6AZADqGmS4InaXoxN9oEi965S8Wm9h0kjpPt2dPGChNL9GfTZNICW1cABB49yetWFm8OEbqSNAzefux97FRIvChYqT71x0uRjNI9YnVeSntvA+jF7kc7AIMZ/bZWvHXhV10HN+pHHfv77Zt4pfKw3P5AEz/QbMicoTkTS2yExULDzhgN9oiQjnAVchTi73QrZ1sugp7p3YAVTzQtK0qWQKO/FiwWJCfBNlfhk36N6KSkxAImH7Junbeb5xwjXvh2/d27x4PzHxA12BDCyOog94CpkHbqIJGHKdSCtEdK+SRbrPiZFEOccYW9y8bSZt/EVqwMf664v5gToGPTzPX9ydAFjS+WoMUkTnGLTnlx4vUFixMDQYc9OkahNElONosFsDx3oN3fVjnnIVFgA2NBKKu+3O5XKYSnM6p2m/d4mdCtRNGzzsMvpg7qGCCaahbnq9yZi+BPQ00PhYpG114UKHuoUI7ljSWnzTcyJpwR0ybnBnLM5MDP/ID753bcMhM/i8YYyDCXq1wQYF1oZECNgxCyH5TbdmTmuiRQ/NpYtNZSWDhkC4CHgyzgik8km6yg4TONPFBSDDgstNc0C5twAWVNv5SwwP7d/SgNciJDlwxeLXGWFsiNDV06owHOhhxg4KzplS16ZEmhkiCseYsOnAYp4b61SHRm5eSszb5OT4CwnCX6Vg7bPDgPk6YM0K47hfIb968m2qlc9HMDOYeOddVJSKFMh5IDR7w4Zs7oCNqu55CZD7jxKqq9oCgKaH8M8cvpuW6O5Gj6dXkOqJvbBCsys3mo2m6QQMjsACyrDOQPklXuwyySUQcwWzjQJmwe93tu4aaDdSYdyVQAgRt2Lg+UtDWz7Wb1wvHyGvMVuKbIEzmC+EOgjFAxPY1687G/0I++uXDphusavlCggtxrby5d6X1LxqdylAQt6mKR6i+HXi1QVDJuc4sHAatEXdBYV9U65aF9d5JXzc//oUDHuXZ/H5hrjKOSeRGDfMGpiTHb9IBqhp0OBF7O5l9z4M9iGM/MHLce2FKNnOzkFhn7Nzus6FSGhmgmO1JSQYa13akQvYUUyr1hq1AxFvFw6fnFv8ytjmO7b3/2CDRUWJVgDTEFfq21rIu0IAEQorSs6Chjl4NEffY4l9V3RF0NqroSK4b2cDcBwHZTH5REbguRYKhWcOlFEQDx8U8zrpXmNIM+WiA32DiH+s37tq/5/MPvTZ0n6f/zS769px1DhLYQA417mHShoWrHy7Dl7QisxCFJ+Kh+g3+wV2UepKL8oF2GSxCMq88gngOrebPcHkj/G69y2ZDAkL7Ni+8wQwGelkNsswza/PwGx3aeaobUXsL3H4XKE5PEpOGxyzlwhrTuMJz2/OtY/1HesFp2NhPGEREnoTFEQJZBEgXl349jmeyb1hBfODAJA7qA1Rl7rteY0xGEATDdBaphVJDYlfHZUh3Z7PsfVH3QTrDpqpGIZyx9Y/caYck/9WHnVxUXUxcmAXe+FSFKoA1/lTYn4QN2/6F/B2u4HgfeF5rl3cpzrUrSfkrfqXN+3f5II1hmNOR54L6ImHjViAbZ7zfOI+SRegWJZ0AEuIJ6c2f6UEgUGxoBmOOWAmJyghDeZjd46MIoormRPCZ2rP8mVQeOlCDBot6eExlXRTuQorir6gQkpRRh8eiCJH0VJwnUhzDL+z6BiO6W94P8999RwU3q91anhSYc6Dm1EXap2J25jchHnSWcYYlD6SuR+33I1o/nGgIvcNC/QNZftgaQJdu+pUHzbuWzBG0XZeh1C19kiteG+6CXZB2sEA7SahAOe55PRm6rLp/tBQpBUJqyB1BGrDKlTwbVjjEjs4OjoA2FX0qNgw801bNHGbt00fVNQYmBwM3xSDjKKFa0mXIjpN34MumuPH+oHLmlPbiC6/Xlnkmc8JywdiLU6vheMwRyYFlYBxOnTrf9DWji0urF2EVqR0Ei4PeHWhU6MrFQ77+OFEZyZ3xySt5lD3ux2CuKdSrlQLZ5y43e7w42B8V9JWOjy9BzDIuXBlv8ra7isOJoMdI1m8UIP4rMIz+LPpQDoPNmoNAJOlcSqxZAj4y+LIj/W3rbYaZYwAPJkItSKo92DTMmjIoV1VqfZwIlb/HnYOUbDdeR7thwtBlLaj13bd3Jo3UaEIGpWcpF5os0jN5rq6KinLmqa2FAoR6wIP7dV6VZ3wRpSNZ8Qwx3me3IfO+2moU1750j2fEyc0Z6oux8EBw20eqDGw1jvM2qTHgA+b/h+6DCz4SlqMNAHlqkS5sy43PXdSOZ/rxOPxjmNOfPr0iQYgYk8UfdC5x73nZgAoYEVirZPAe4RGLwyMGhzbYWPPiIO5unfcXMxRugMt3TQEXIPi9yVDpTLbg0GnQ4ygTm1rx/PS/WGQZgnKWZJ5etsHMztWjlw7OZbOUIVMAWcsnM+HdKmX5fCfW3+dgtVfG7YGg1MjDed5Kp1jUpUYgN3xjB446Jg77aGIipMnC14By6VDJMVxZvup1ftbJNOtIJWPkYko0a6Mg9EsgweUOYaqvTMBgE4cBSNPOAKxFkXfPNY2Ok7M70XAA2ebtCebA6gIPM8njvsbWuOR6l6YBhp6+0iPA7fjDWaOx6LFZCqRa0viSLa/uME2hPOxvmftahTbNjaU4K+1EPW6l+gcgSQSMMSjz2JnQrc8ILTDdwKjpBwGVPSJBi/qmoaMBaocsRaL11hoHjty7e5EtVg2F7Ce3H9ZmGNiWsGwKNotA49gUsXaCWMbJrRYd+/hV3UGM8kW4PbHZE4uZ/ap7HycyMBjKQF1Dh68z4nLklIJhL1i1B/rhy0ziR6Jvp0rcK7AvDFO+jgAO4lAzRvcmbQAoplgk5GEMi91SIi4yfdko1qkQnVXorVD3S3plhq72/eDzkVs11MLGHAgEwvXvcOD0nGulGWjwWcneyWQKWDBw5ciRhbaqxhrTcUI3bOSdu2WmEb0cprh8f4FZ6hDKCqjjU5+hYbrTzt2dXL7sX7/6uZqNVKMPwHpM7Fk2GHlV3wJ7O5vO+6UfpZukUSO2c1tZkMzLyCKoeKcXWd2yiDHcFFme9aHlWiH9uJqJVw6XhHf5rOrSIde45KbDwtZdojbiAFmWw/S4NRww7lOQLarQ7G36WBjABM3+JhYa2HFuYt4NoykPxmkrgef/L/1Jf43t3rPMvwUP/f1BOR0NUydpvBNfQuJroFLSH477sgsvN1vOG53zDZYyELJGQpdPIA5Ih3ZFp7nyf3WHRdR/+Gzs2TkKizRwwvAMQ8VG4C/OLj6dpYjuP9ccl0zE6MsEAuoIRmAfi+Teu3MVJ6tOU0FoILmIpINhDqUfB+J5zqZ/4uClcFBhG1ZbJUYJB0qp//z+cFf74Ds3zUlRY5PtxsAtVpEG7ofN8zpCJ94PL8gQq3PoaFQSlqGFZAnKk+Mphz5UBdi53HkT7qRRYBGeEVXssvODEIpGJO6IqzN9+wOTYEiR3eDHcc3wuDIBfeeXjkw0C0kHuEpm70ujM4I1HmSDoC2JwU4eZro4G1MTDsw5gHAMBXgpnUZSi70HC7rtQIycMb5Vy/Jx/ptq7sTTQvJLJzniUja71UVwg6UE7VC2W7V9+8DFNI2ajCEitANpQsAyMmHYtfbEJoMOqmkZoE4iPRZ70PCauSNbg4qqSvH1IRURbKqALLgdpCyL5pMQL7zfZfUNqaUyP5Cm0tcfzdn9274LkiqiCwGUoMLselqbfvbtIIqwIuCNwa/jwLkexdDy/U50q0MgNCz5/NBkGcOLBBJyyw83r/i7ROQ4VhWWGeIRzxgNvdsDJMDVRn3X+LS2DWg5SrKzbm3UdfeSXXcjuMg7UtI7GtKlAaM4iDWFjPWHDDctv6J4FVPNJc9uoqdnlMzpN3jVPdAGtNUjyfGFumSmmhIjOMNn283RA4V5fwsm+oKqJPZ70vOhB9Y8vetb/Zs6dzts7YSEaFOGjVyQ459KSvPzZ6okulCwNoaWQU4BPLNScesb54b7J5UmmLt1aUo4JsCZLx8H7iGtMGkP8ouIK4uYHeR24GQzl6ae9bPLxSYpiUHbrNdLadcwRI2rkFxUAfFZf3uKZZHDDpioTCt4C5BcBWqloCezkE+1u9dr3vWAM7tyHdMXxgeuI2S8N8xnYBy2cCzjIMWLPa+PY6x46GZ7b2MuoToQnJAAL1ni/GfzA1uk13hMYExZf08UEb6MwFKwxJSRHaGvVRSQFu1Z1HnmpI4mAqIzeZQZ+/1tXTxXvo3F/1vWg8Lpdtg3zdWgfN8YIyBiEJG7fcURfr5cbvBa/J1+fiLe/ZvmwOCpHjaiURFMMj0sLcQWmV+Q4TU/eK74aXl2hfKjB8YfMhbO3U2EIVmXl/75u+uCGEXvq5sJFpWWv3YjbBdaHgpkcSmkaSKggIHuphfLU7r9ywv76xAlssauNT9YVUJazRNUiJxoTNfebGOnqra/Hu20WoXQoX6i+2qj/W3rUoebEOiLccQ7zJwnoudj5GikkwKAWWr63XxLlsovqVc3odBvQQzXtMpm2kAe+801cqG/PC1D1HyDUeTVkxds0Oai9oHVqH2nAOry+3KyzZ6iAJKxWxb5mInfkCnnW6XE5wpIWU8MxZCxqL6033s7t5lXXnxrakNeBEZf6wfsrKKM2okgs0qxPnET2933IQyVSzEeuL96x8BA25zUvh4njREcAl/vYsIxqJ2xSq/Jtt2XM7KXXRysOyLlm3TtK7900DRNYvhxVJSe9bd8OnTZzzPtR29Uu396VNugVeY9u6nCbFWuYEJFs4RtOYlgh4spO83rDCkFx4ndTOZi8lp0WmrymHF+89MA7w+us0/dBnA7mktrFiIINJ7GV803ci0r1NgjKyXy7FWF6IMKsNp9OFGLyGCMbtXJ2oon33vI3W5utPRA1Q7jl4DB7m2k6YNcdZLVNnaP08azNVdlt8RY6VAmv18MMZ9EMVup81Ut6Q1rV4ldFV8/0pU8byiXXZg+CFaJVREf3RBftxiF+CwE2knHCn9BWNZZ3SFwuGHuiCpuXQNPF/aOuCaP1cQUCezmB6SufPYVhCbYc6DUoWmzAoQMvPdhdsaDLu0n4aOu4zDPgbKXYM6OTaA9yT3q6ONHEpda3Zs+rnoAiY6ls4LU5eP3aKFiMAYoOlHCoxPveCdOwzAb9gF0ncVIDoZ2qLMGklFkWxbFHRzSfRlE2OkRDztV4JmNfFDSOeBpITtXBr0ghaQ+1VVyVVrJfaWaAQviwcOOwvNcfeXBCmJ+oEX6Wq3dreFN/RKDmK7q3AxXezeSOhujTmsDGcmyukDndUCZqdLARyoFC2rN5SOVrVvzPnZRQAQf4+Wvx/Dsb5nCSgAoJvYHVCRjME+wfIEhnQac+KYB45jbpF1I7FA7eE/fem6gKZ7ie44cxbQjTOUAZlCAQvWjnA2NTGXFBPu9cti1OzArhicSExZD9Jkd0Q7md0+a8piUugrhLeDk79+Jl3E10u5WxRnrky5D3UnUdxVczl1FR4RGPuz7cDGr8dHBfLdqwvA7c6iPZjFbu7bjUjbgDj0Y2DNG375+Q94SrB9qDIcQnL/+Y//CKvEp08/If2ATXXEdvGJvecNhQUZRjZVxAytjhreHm8XiCTPGBZM2UUHk0vT1yinbmUYVj7ZodBzmLuGywlFA+8jr9yUwt5ZTEALz3UC0g2aF9xJkU04KjkpG1FYNbGS2pSZd7T99NDQuxWkA3+s37++2bOiaULxqqlG5obbccP9mPw+TNrItqIfSNc05QyctdDUZhNyS0o1k0KoIG93yRC9GsZcoVRkZAEmbdF21dxA5k7dsHV8ot6W1Z6HxHSTuY5603wNUOfGAMB3EdUdF8/coKNl50T8xMp6/hgfE0bKmLtjolgoO+QU6kBNjHkjVahi26F/rN+/Xl2wxiBrYYXAaMWhhOGxFsbtJ7STKt0ymzWgczgL58rdaaWb2URrOVv43UBKn8ztxmdg92PPvBNoyJxS8/ZksrT3Kerbc97IrxhiJ6QPoALPCGQYyrbx/84beKME004bMkJwFea5pQIwEDjteHwuDGeu9Fgn3A/eN2UcyFzAMxNvTlcwDgH983H2NwwiFMIr1CvqGrBTxdZ+JDshqVHwXaA00u+qTwwFn7wpyW/mJ2gAqP3pyaP8+WzqSHYdCqESzAQrWzDEB7HsC8IXTw5+o2qdumm6uS5y6nvdXk2/kBHa6HXbSzSEEk/Z21ULahVfm5vi3YWIQqzmzfNDbD5rH+QvIXbTzj7W963tJKb/tk4C0EHgQ4cTufQmm87miVjDsTC0YLt5jN6Zm5C3FnFbH1JVO7HZk0sLO3nrIrtpLT1tF53gVSFAIVi2y4oZMlsez5u9pFmpZCG0/eVh+60XIN2Wof2+C7WntTci3VoSIjgSmrltXjf646h+L/XiqQ/8NaeLj/Ub12uc/OYbpGna5rCTkvL26TPO2w2+Aj4cboX7kLubHKfOWPAx0JaQjaK1Q4tLf9bUmVDxICgLY9pGzC50GewIwy5ntmyaItvw8Bcr3hTi61Pfl1B58DD1yJ2wQrE5hOz1jBBHIZ4P1POBqAXDiTFNqHJRUlWXYUNP4GUHnpSDITpOQa/3o3D+YesC7Pg3H4NmLWb49OkNb8cNzwispK5hjHENLuzfccdIXF1hDU5LaezaqaoZF01zacpdY8t8uI5NL5blO6+4kO3m2F9obVNSLqluD2Td+8hZaNV+nitvsUoY+t4SdRU888kSSRmTXENem3hBh6zu8JBtwdSGLJHn41eYfzAkvnspF3B33G5vwP0N9nwgYiFzEUC0iTMT//yP/4C/+7t/Jzqewf3AGHNTlSsTZbFzO7If1IVA90JsswQMTlkQSE9i4TuVE15dtU5Emk0xvMHGC0Q0VcGmGNmPwXtxYmYhvLZOadc/YjOV3tOel2e23WPbepexF9vVc91yM0Q++YEC7cxDezyTA2EXhmx+QfOoP7P+tkGElcg48TxPZJxK3Onus9YTaaKOhHiXkxL0FBVK730n4ZzcXFeypM6FTg1kyZZUh2Csa0haFpgkdXIpykBDs3sKaV1itIGhlpZoVyohy4CKQNtDuoJF6f1ZhThzDBBdjHXhgsRV7YAUn4gTWYaIBR8TVaUk4kXz8ZLEactJhv+xfsRqhKtF5+1mtXbwB3pQIdCtfCG53YLXwXYFELwcdn/yPBFYRhRrOvcgHVRqF85EJ9gdgZK+tkwtgHQ/iE8NANXCWdGghFZXAhHPTdOJAnyonG70TsWOvxYhKtyzSqIxaTj6/i4iFplgwqiuZlbtYr3fdQ/qqj2l6WP9kFV046FwMV6sz4WCmRJ8We+aC441g3sSzCm6sMzjJrpp6aAQoLKLSxXYKqYTAH20OkmD3Fa6sA0hzV2sGyIC78/HpQ/pgVvF+BnFpKt1GBvYKpCaWuxAM9ZC9AFy48uM2rh8Is93UqtiIfFAVGGJkBBhGMdnzNsn3LyQa/G88Ekx9PNJRN0uRHonqx/r+5e2YCddw6/hpV24GkinOmYDlbbj1AYdAaLAKMR6MqGS/347ouFPrhtBSsZU8wvhZidOHQ17eZkqBHZuoCQuQWpe21hnXiBTFmnnBBwLU284k7qAqiHKCtGr11fZBRORanacIwjc3m43vq5M+DDM6SrMTlpwK9ewjB3HP9b3rXr5f4MogE65wBlJBdsAHpF4nE+sdWKKMn8YwZgRJVYC93jPomkAsvXRvOY610tdNBuwQW0wa2P7BgwpQLmx7dfYeUnv5y6IvQvhAmBxdbQNfwKwpJ5N3Wbtf577fhU2fQ+b77hfIEQOa90dz5IJ3rtnvf4OkKJgskALVKw/ey3+qgtWJ1kha1nywBZyLSb9YKvmeT5wxhMZtaeY90nX6FijGBTXil9ZBU727YmUaqUGOy1nXq8ksuCySethcpWFzJMXETpOFXwiFpGz4AVbuJLFpnVZtRhS1WwAIVRwC3R0WLqbxMZjt+UqiQS2wL1gW9Dm49goSVfHfO+OMiYK35YbBVTgY/3+RfCgee9NIDEWIcki5BQKaiDadq61D5oeLMibtI9TJi4kTOmwS6K2PTMkgnt4pSMGTRUMiVgLLdJKGA4Nkup5HU0PYJAqrBWoXHShMEMVEQbOpNFzuuNoq1yhiFmGykkOaCm1Slmsoh2rOolMrKRgmJ8B91xl4owTbSVdNvB2+4RSi7aLb8mXieS9IIsf6/tWY7G1dydtzTMW/u6XX4RCMcjTQU/XSe5/japSi8EOLF3O5gZ52q+95yr0M//pJezH4WwnQ42mhvb9UVtg68Px+e0TH8kYm9vkIwH4RpkvEGpl0BK1KadVMmLgoRVZOJxzFVYE6lxAkro4VeS34NwKWDVwHD9j3n5CnSdsLpznifdVuN3vmPOGNEeR80pqwwcF6/tXXXu2+e3unHs1IefBCAwfpHrKQrk1pT3Uj8CkksKNJjusmMighdx6ru5kRWoUYAM0DeAIcEoBQ0PxvcyAIdQ21x7GliAlN4L3VM8S6xk6HebMrmKpz+uqLui5l/n+8urwtEfNS2FS7cxVl0B+uMPJz0DWybwFzKeIsfrHnv3OdeW0JkMEWtWaQEDYQCa1kFEDv/z9fy8xMnUbmaQKugnFMJrAbL1wLHgFkASgs+i0lgl126T1NOmgkiC8ecqcoGM78197KWqhPAB1DcPMLhiSz89OhImOdbF+LlD1wr15nl85QVUXy4ZXwCsuNHODA01FRAYqEmca5sF8PCJ30RGVGPnnc9q/TsHiq5OVI3mzxxgUwLrBB63Fvj6+IMNhBdzmm0S9dJhKWXVVBcbtDSZf5WFyeYBJJBNwG0KmTd9PFSiXyAxKgtDFS/UAP/7OArl37cDh1Wy5Fv9wDfHw3NW2hzaDNd1An7k55nHARjvADPRAw9pJmTa1NqGhcDsmhxbalsyBARpYUVug7NabJJXIfqzvWU23crum0DNZIWIxxrGRB1I8sG0a2a1Uu7GW3HzUAdFE8lc1xka5UHIs4ayPCO63fOnmkV5Veyd2vysyYMYCKTVfZ7aupNoWkjc8HRq1j0zItQFz79lLv2TG5LDnJuyOZT+GOpC0HkwkUgPeTlQl7p/+gGNyzgRSZYeCWw/s2taVH+u71musZSQzvN0O3I6JjIUxXEidpJGRshdNHN5Dz5gJ5QZoSm5sV5LYlBTbX49NEZ0TauMDTU49hlBY3Qewocm5hqqrM8OXXtcgVsXj7t4cZmj79qYp9L+lOintbNjvZRj/BNg9+fT2M57PBywnjvGGaYWBE3MeeDv+Dn58ZtfOHrAKzOMNdgbGPDDnDQXg+XxqUCgnrH+s379ewbNSMjWF9Fcl7eg1Y+GME3swGwA3dqbbGteUA9yGNHQGjDlo2WsQ977jMK7CpeOwih6DqtJMLJnahOKT6d5hx7c7dLVjbJub9tyk2YJvM3g54MSDacSw01gldcpD+m57uf9KhUqb3qAKU1rY2yAo6Qa4i75bC8iTp4MSPlMulB8FyHetevmKBhsLmaf0ygaMg6YJ48Dbp58BvNJA+XtVMhbgRSPqnydQQbpRURHKQlX7xHkFO2dY2XmAzD/qMmrYr1B76DJ/qU2bfgVaU4VJRmwA6Ana67vmkg3ki7paD2DOvKGLjRd6Y1N9AaANGU3xvPT+TKYjtMXWzB1oCnyczL2Uh/y59dsoWEaxWFuamhmHYZnhjEUbWxTGdJg+SEe3OANxPvF4fMVwiXXsxhtVrS9gwBb7E2bXqHhkV5Z9odQQ0vd6yAt8iDaiiyc71dJB2ZOrTWkc9gdLuRFsir7g2EKSzblxugSPsVtnnTSWqlSYo0ZzRVOtOD6PAG625TI5vr4PaG3swyk8IvrybU/kY/1t65tPzy63Jxh5jPTqvhzQAOhG6d8W5UmmA5frSBe4/ddG/F4QCqSoABeyu91YgJ3wsZCQc5yei7okPuacbV0nq91/JQA1CsKt2gKz2q8USur6f7C+h15eu12uWKRosfsCEIqJpsX4kAXmZeDQFr8UFX+sH7bsMtfYqKhT/7NkJzr1vTkHno+1venNHGmln+cE+4uOUjx6JFQEGtIBaa3W8A2/m3hJwLSHeRDlFkYWcg9ObSfCKtMMKNmNol8PttCysnbxUSqk3aUHMcccBzuBeu6IwNucGD5wO2jVOuTsMo2cbD/uuHz0hbJ7oRwKwgzrx5yi/Dj+wrn4sf7G1aqJMRyIvHQWNtRtUvdA6GqfzU1L+UbP0fEIeOnSXVq73r8pqssYYyO+1HhKoyoHt8xEDWfCBOcYJsVS3/eHKCpGhsMck8+pROxRopq+MCJUt4PJLGdKmAGcssNu+nDDGX1WmOaKQY6IcvgC3RqpDWHxAbS7KKuugoCx/4bX9N/2Iq3uPB+kwwU1maHCdoIdsZ2P2UDJUbOL3DIS8VJOZ92dc7EQkJ0xKPu0ARjdpDqZb2CwzQs6V/CXe6AX931rSnpPGHqAKzXatQ2TnhG43w7YmHjtqjf8uQvbvifRxYLOCLvyhv7d1H2Qooa7XitSs6eGY8wBD0ecT9A58TsKkA4WUIJGJ4YeY3UVAffjhqgJlDdkwUqwOPjPDbgNR8XJuQs+0cp87FaTLlz/t4DNFS1gpe12JvRhEd1OtcToOqRRrAwYqgALPMxLiIgb20dRBc9gSmiDJUpXfGaA5oPQ9pR2wajCc7Gz41YYc7CgSFFrQIrZisD0iULi18cDZ5zITMzbG37+/Jnv2ft12dYFfKzvW3vPgoWjxyKCMTgJ150tznXSUk9ABmg1R1cq0v2IurUzFIMW5CJk4mle+3H/u+4XCsgnPcXNd5sfAN3S3GCVOFVUG0DdVKMlJQFl8fVM4+uOlISMpx1GBdFo9+0I1IYOgG3LydaKoBrfbkiRrh19D0Jc62ckZhKF7mmnbA0DPrlnQ5/3x/q+9YpomagWay0dHqBOIk68P098fnuD+8Bx3HHMA89zEQmmClYJOlCR8IZd9LhmIPIvEKfne3TZ8c3r6YI2k3qhKqJdTVPUD9beT/xuJuCDxUUU5ArE2Ov9PRXMUXQyUrYJd1oH29DzxSnDDwno/QCK028C5N0P4140JYJRLHJiLXx9Bo4JfPaxDSSs39rHvv2u9bpnvTujABq1jY0HOgZKsxVo+FGp2LP1ajIm7SK1LgTPcMXTdpBqipMJWBruGn0GuCUdMC1JmhXLYoM0skLf7lRmMAxRx6XT3EVzg0DYZ/wuCMDiqTuR/KfBgshc/PyU2JT33pycHTa8QZwAkn/O84GMB6weOCYLcZRiss4P/+iAfPfaBfC4ofyGrImoxKmuMoxz2yDGRBbd9cwdPiamQWP52heSZYRbIXbC3pIC5QXSH5coVHMOuPLJBmXKr9fXAvCC6IR67ak89ioYIKYEu3IDzHPcDM/zxDpPnH1vqkvYgL48HkCg07BYTjAPqtLsGVn+dux+MW0oc+qWEDQSiYXbcafG2QxrnRiauffn1l8tQC46i2GYUwfiiYGDiVqQDzeOG2qRWrQqcD6fG7G434YOCHZLDPzw6bfcvQnbFX9XhGlEqqCgQ1e9bvv7HlQ0qitN/TF+pE2zQdMEzDQLhEelD3sJbEIAiy4dnVQNb+Fn7Y3SE0u7GXZMTQYGBeuGLryeCLllsa33plkjGvDW29cdpcJpc6I/1u9e2wULeDmguDvcaFNKe9MldHbs4oP2jQOv05NDE0lf8Yg9E6HpImXteYAmTLmup0mUa1VIJUDWkCB7IYCRy2wGtVFt+8YDgA9RAy1hps6b0MB2h9m0K7sOLR7utdGUrNfX+ELOEfLDwxnoYmoFi5tQgmvO0OrghNAQKvixvm+94lNASdj9BHwxFkXAzfHp7U0mFupclME8dse3NUksXFKP6ZpMzni5ipSDHvoSGqBq6mIo0NHiVJ3b8gt9pasVNgpX+/u5h9EtJZalfd6uQBgcuJZWONN16EusaC4tC7shZQbMA4cKMvL6jRaUmTT6sML49ImJ2ToRCRYeX9/xfD7x9QxMd5z3O+63G8ZxQ4rmSnrhx/q969s9y5hWYgZAX8OcOoqm+pldnTIlMfbySMeY6gpTdK1NpNioM9yUlJlhziGqie2fA9q9DYAHEs/9el8jVVuqjqGzfh5otoSPS1w8DDiqkOma7I4dlwnsSNSbbdiBK+dAuxspzRtM9twKcwAVC1VP1HpHPr8i4gGzhek3pAS/hqHuY+3n/Vjfv8aYuN9/QTyfcFtAvSMDqFw4zXAcE0SjRd12aSGHw6MQabvI3vsTBJJtd8vkPlmFFbTLP+ZxTTaP4MDOUhGhXKVzj22Co/++OsB1R6Sph322uxuOMTDMsDIEZAns35I7dRJ7O+0ODvQeSlPXSwMypZMWkAXl6laFUY45WYjn+YBX4hkneqba91OwwE7HGPSk5osLtBDlmBMo4KwT5/Md5/mEG/B2u+OYE6Ypy4hvLXxZ8vH2zEoMuJAD8oIrA2EtoAWuAUC6GYsWfSWXi5J/N9r0ogpIWYq5o5yCeKvcj2nuMrASf61pD2OC8xV68mVtz+Q5HFkDNB9ju3k6EUAbhgE6WQSKiKQbbj63kxArWv7JSER3l/JbjcrH+v2rRbLX4QVl3uItVuA+eWCsdQLlWKEhknV5kSU6iGALGmm12K14JfkyHshIFQ6DSbsleqJoqgApTSptUWHk2okjmrcs1I4Tx8H9bcDqoYB6j5w3QqL0cJo6yGtD1AKXh3ft+6NteN1NBUTC9PpDMExKgHyeJ3ICNm6Yw+TdfxX8TBT/G17Y/z9YBQpPswqPd+oZ3Bw///wL5nHDHIPDNBd1eWstZIQ0eTx4mBhdrfaNWlU7wClZOk/MvMSOh/PQbVS3O3NTh95T7iZZHDBncLTteCUtpN1FiVGnDlV7Zg3AgzozcebCs2m2SQcj90T2/WcAqjn1cmuzYle5CiueFO2uHp442f1B4j4HzieokZk3wHl/Rz74idQrvfJjff+SU18sxAqe3bFggxS5plZz3lfhKfc+7klguuLhhmhzn5Mwufwl9ZOcmP4nubhiYbe3NmkDF8DYX3fXegDX7AS0uDw3QJRFXny/vymxJkcRsBhi4SHkSah0ZLE4HkOW1M5zAQsTpLNWJZ7Pk4XH+QWjnqg8mRcZgR2LABDIfAKmedT+EWy/Z/1Xn54NpN1wVrIjkoF1PvB4vuN+uwF+gDomGr0MdCqr8zySc+gGZ9lEnFfnWN0TZOFcJ1bQgdPKMFxn8fOJdigsMxa+7SLo+n7mPmPbCKY7L605Lg2rzCrYGKTaynQnI3CW7KGh+WWVu6A1aY9qGzLpTUI6lQxp+/jtIeD/169fcSge38wxjokVC4/HO+lX3bz4C6D6X3XBggDOjZDyk1LB8OIljELGE+fzC+Y4OBjrODjx2xLrZODIXUmluHNXgofXNy53iO5MoINRBVtHsglL2dndJ1tWGGrJg9y8YbQUzUgiMQpuZFVTNE+ghWOShqntKvB5ktLKhBMtjAQwndQUHYomGliNgQFSEALOdpjTsaXWYvcEALxQ7ltAVKUg+5cuyMf6q6ur+NZlRCy1PXVQmBzKug+mg3FpHzk6CcKmWukM3B09FiAsNpADhcLjPIFYvLHHIQYiDRqmnzBzUgWBbbN7DKHKVqJmSbuUJ/eLD0wfbIdWYRQtTbOAOS77PY9E1lMoW3dKDEhDGG/+pn4ZcPH5q4d3sYuY6oqYQYL4Fmiy4Lr5NadmuBB3h9zCPtaPWwafB+63N6z8iudz4XYQwbLuZRUTvnMFzsV9d/NB+0MAE2yJ0/FPughrLvq1lyMTZ5G3TLedwNQeoIWkwcbEbfCoqEo8nk88V9ChZ86rMM+k4HsM3Cc7vxG5aQKtNwqTkcOKPcTWlbxlFsoCQbwYm/NfoNZPBRKbKTdMO6kH0QA7ADiGYWLCPt2BShzDcTsOuA9khPR3fumpPtbvX7p+rbUIWdCf5wmrwjFvuwDIKjyeJx715H5wZ+JmEIW0uwp1JVrqgNTOG/h30rUMUP7Qur0LCVbpXdRcDBUepGJzb9GaX3uzCsglV0LmNIzHhjCe/maKu9HTEtQhkUC+BeOls2RF4NP9zq60G85z4fF84vP9hsON50cB5pP3z3RY3RG1cNgEbLL7HE/Oq9Ln9LG+d2nPVuLMxBmFKNLmzE7AE8/nA4/zhE/D4Vf3LQSWRCae5yJ4Oe9ybEvkSp2LhjCBmRlY56LxEAw+Xcwh7ssBbKbOMTgoNQV8A+CICGu5A2DRM0bYYZh20aw5x+lyfmWOEjizzw3eqygylwjKtzmI79x4GMXk0wCfpAFH1gbkrQKHOwYSs71GyzEBPCs5VNMM8MmC6M+s3zCIUF/rkLlsaVP3GxMmA50dPr3d6azig57cbi8c3bHbj/w+UBVK7MF5G5uY2fx6DXypgqlggdqvMLbjhxWmnvNAK/X7Zk1YJ5el5F+P7eqWdIFlVoA7OaTo4JV0vzDDQNGpAuB4ewOAQUvdShUxRRRyHBjik2YGzlNt4DhxPr8AT8fnT79gzpuCnbQBH4fid60/TYXXenLfojtcAEbhca5tNYvq46S7HJdrSlk/KgtQF4Wgu2yRS63VIP9XbjtyFFUXDYClnLNaeMmaaAqB61l+UexKbIRaezdV3EAt2JUKSOJMZyy9hmIXcfimP7j14WlIo+c3XQSb+28brdlORNaW08D0xOGBmyeGPP26YetIrL9gs/ex/oalPWAgbfB2o3XsvL0REbNBzZq6YudaeDzfgTjJX9fhyHlGiYqTDzimWvrsVh1N0YMhp8TixsRsqEs/Jql8MIcNFsLsng28C5XLXHjGSX+V4r31Ngxvx4H7cbC4n4znPXfBXjqB6Y4JxvFh13uvCnWCXRotHrDHcbCQrkQlXYFuNjBn35cSE7v2vr8BMmg4DroXhtu2uP7Akr9/1ctXpTMwC0gzHPPQTBiBeiG+Olpfp3MebEnsKJs9kZqru3PX2X0BhLWdI1uLApDs1E5sBA27ewu/tHHN4PCQeQzaoYuP7Y0wZwvfawM//DtzoGFzF9CVnCXWw0PxIsKdQrbnGDiGc0hcAKgBO95gOp8ez3eEk21BSmSiwMTvw7jt+9ZrTptZWGfgjJ5YXhjzRvD8dkdW4n7cBUoXz1rlik2xm8ehYZMC6tykP9pQETtpYD5xnwfGPHAcB/fMMa8OGphbNPjXTputQebtQgv9FrFPN0wfmAJ5DhswSQgyE+tk52WIGpltyGEciAgDhvLdfg4zY7fRSL2iQ6eyl1w4Y20DhQFjMZNFcDfAmTVjcgyF7oE/t34zBetcgcd5qtMpxB8pfhg7IZYL00g7SXlrsyoroc7YlormQzeT06p3OwYEVvEAJtUr4UbbXs4jorVvFFQtXkFjc42FsOEbxDCFlkhfEu2kNXaLKCpgWXI7YFAKtceGkPIeEMMp7MKcK9AOXS5UBmBwfD4e+PL1jziON/z808/IGDhGAbXUch1A+U5Y/5Um4cf63YuuU891bq2Sy2jg1y//jLfbfQ/bGe7ir2u4HiBb3fbeVgAw2wULZyXIaQukKNoY6rQ0lckQuXjzo+BjSufTAjOgBWUFUy0qcZo6L5lEZEpI9XG7ib6lYDGPF3er5kcLQbxaQnyNTiEx+dn6ASN1pwyw88QhnRJdjNrm2oCaAOYOhG1hOcYHKvcjF687E5VZgEnz0fulRbFVtDu0TEA8+N6T3S/vZHwvXfPpTKSWuMoplLkpsJFAGo05eo8QpR64325IAIcdOIbjXIFncngbfJKY2p1zIWumLrODxhC0R+XzDs21YQHVc3B4P3lbVwodL6NLUZkk8zaQFgqbnDVBsClRqQnCdnW+h6srgw82y49cVSUqYIoq5wR3rGdmUT824ZyzgKur3Nu1EdvtfClkFk3/0A/v361CVOqEv1ywEi/fV6Hg272GDoTibmzGQeqe4wDMBqNCeaFhRbLT5uJC6DZr0Oayrwa6h3Nx341UdKOzIMxF00pE9HMDh/G+WXbX9GpZm84Jy4WmfH+sH7UEYqszGtmaz9qa58fzifsxCaJHgFQ4nr1jsiu14tKHXpqHwvl8Aj4JRhcF4MNpnOFiVmzwsVh8t416AJqFB8at4agVpFvBMMeB23amVEHUQGqp21csegbm/plyutlOgftdjfX9to/yzXhq5yv+++P9nflGUmbw0zFgAWQ+aTC1EsjCPN4Am1jgPfLn1m+gYMkxwAfmPPDPv/5R/1aoSQS01jsOB5C0shvitmc8pcHw3e5kVX/AbKDMN8+8Z2uslRw25boqcHJ7u80UJ38ngTkHho99eLoZQshGgoFqQB0b813JPZ5PYD1g845PbzeYT1GhKNqJk0JfQyAwYTaui1AbC9eFyu0MQMG67/bvH79+QcTC/f4TbrdPfO8WmPOOw9+UUKibBAbA4b99OP3H+q/X6541c3YkHg+8P4kSj2F4PE78l//yn/E//If/iHmbugb8bR4u7IxkFYbQBlhT9XiQ7iFBcpYIK3X+utsneoACWqzF5Mlyd8bc6VYEIYSpE3a4AeLPDyQnt+PlQEbPUrDdEZkTDFRWssZth7lGfYSwGIXs28nLLwtfc2B44O024e707o8HshYiTlTdUPXqOJTa9x8FyA9Zu1jEFhqOMVTkAhGMMysDcMOYB1wue1CHApAVIwAbN3WincPWdAj2RHJT8VxbwGv7cDwNpOYZVKwIABoT8wBu+rlphjETHok2QUgAKxknDb6tRLeeA80LJm+ZdrqQTqRwLtIH6H7V4kvfne9OAmEHzCbKEk852KyVeJ4npmJq2ZRDIoBioW3RBK/Cx/q+ZTvW2mZHjDHYtS3GS/iQjSQLSc72wgtY2DJ0JSrVur129oOGuHFl2dYWRecbMDxTMwgq8VwLxzw2hbbU9WVtREAllWFRc0fC3yqgVqHGZdU+fTKeZnfwLtl8ad/qhbPYtxagAxBS7aLa9LvIAs4EjSbAJO8mo5QaN4xxALLqRS2YnTBLDJz/P7+m/5bXa37g7hSEjykAjwYbmSYntMJZLD5nd6Rs7nPfCrCiTocxiuMqmnL4NR84jkGaqrHIccXRC5xXAZIvM8NgAi6NNFoUfSojcS7aTsMNLkOO2veZ2A3KE0pdcxofgMwcN9J0K5WDU5+H7kAWgApkiIFkynULtPfNBVPZ8PNPf8DNgHw+EAFYPkmNhWPOA1G+9YJ/bv3mbHfOibfbGx63G76+P2Bi6VJ8cwPq5MFZnHrKdj2neZrfKI41wFURmk8FhCX0d2CtQOSpD1Mqe799o/oPdEurAJuYx01UmkbxCqGORCaQEA9f3OSVT+R6Is4Tb8dd7lQTFQlY6AMrAEzm2mmrhxlt5yq0c1Cx8JLif+jAbDT97e1nzElNDDnOojuIU+1JQX7Ego8bkcCP9buXelIAmNQPWXtGKsnPwh+/PvCHX/6ArMAYBsvrgNNkGexJ6t2SlMUtMumU0QiXEW0YaOqH7T1DdKP2YWzN4Sxa6h5OJy0zbMs9LyViVtSUJGkFwwfOAuCT95Dsr3swoINUMrq8Mfkim1EDl2zLK7F97LsgUTfDUbjPgbfbDW6GYxTO54kIACq6Mpk0XsPmCBB8rO9brxhRC2X7Gg2TkxsC748nqhJv9xsAoHyi8oGME6uAtcTRHY5x3EXRS1g794m+ogwQLq97noGk+EHJU1W7ANme2VDFg62TKvKSB+BNMJSToe4FKOmjVjcVn4ElQ5JpRp4x2JGL4hDX7sS4y8J1Pye7KT4GEIvdRBtY69T0YnLt13qn5eusFwemgGo3bB7Gx/qutV0y3XE/DjweDwybOLzwXIFZtQuRqpCN91VukNqsfeQGq7biZ6K1p5CLWsfmK8/3ShXeKk4dhVVK1CI5vwtFjnxRC1rGBLP1RpmBlQX4wUSszTg25UvPL3RAbHf0Ddr37etuMv1fd8l7yO0wFThiaKwEzjPweL5jxYn7ceD+9pkWrT4l3m+zOukW7TVSfKzvXaQ3EUhPzfByP2Agrd6LNLkagKugNZfDavbgydyU5S5EzJw/7xMwxxw0XogWX/Km4Oy3iO2KSW0SqfinHp8dO0e6oybBJC/A9FhuzaBplyqgPQspHtfrcQKwqEQ8n8BQMWWaiSRzHmTrTwRwstyHGXC73eBz4n674+12o8idzkp8rZ44ylBjorL1tX++a/ebM4dSwj2PG/x5ItYDc/6CYxpsOjIPPNevSPAiZibOdeL5PDFvtNcruFqytD3NTFSkhvO0Qw+LAHNHDgeKfDLojfAA9OtAGrzA6/wKmFA+Of6QG8pW5zz0QYPUBq9jV3x0L2J7C7nU5CwxF+guE7HQfM4CL5YJQalKDAz1RGondACHE43B+ZAdpY7jTlSxgsI39VP43j8Qju9e+py7QKzS/osTX79+xbDEp59+Iof98U73KzjKp5IVF7pQDSpfBWfSahkVWKFiuyl5tZDmCBjmcCDoUmRJeffwiduccO0jDsnka73wsheNlQpgFzc/rb2nXo67KllD595/pNQ0r5Rocxfnw0S1gp5D+39K0+SyqO4P0dxRSQtCoG18mTyGDMJHfWhAfvTiPIvcQMbhh9xJEnTGCSACE3STYgFhW6fXFogui28KD8VRFmrM5IhFQOo5z6DlbieWKxOe1F2EHNSQotjat8i3jjxUuQCg3ovAioXMhWOQJnWJLC8VUr6Ie0mjql3oOoAzEoGFY7D9XxnS5wHv5wkXtWWtE3g+kQ4K6qcBODmZW2KTyMBHLvd9qxt236wKrCXqcgSe7ehTA7GWKNWivoypDq30I9mduNLZrGhX2AyKRmqt84cCxcPAHh7bnVlD0bnTBiIe2MMyfcjsg9TYVdS6dSyMCHYrDNue2tVFyQyayzjp3yX9W6mT0wg793XJOprdeAwAK3BGbJq4H3dUBL58/YKCY9w5mJggZqrzHdy7CCQ+Yu2PWjQv4J+1Tn7OJqG4c9irp2zvcdFfefbl3m8RARsu974QOyBIm/YbtsCzKOKWXJw58vMh5hBtge24YRRZQcjWbtJ5dajI7jgcQVOEEFVwKVbScGGirZtTsXwAu+hZEaRRqchg/A0wewkWLZr9lLk2nXAOk/FMyvSBVv1n0MV2B9VkYcJ5a+vPXoPfPAekJyu+P09EJqbEOubNrw0dgpOuAmF4nHQqMZvogX7k3DcPXYdILlh1nQcN+6NAPCABLi6+vI2pISrsTJxrcY6G6CrTW/wjEc+YROBcbV2bmBMwH/RILtmnxoKpIMgqjKPFm0BlcXxHdz2a5gDS027zwDFMQxHF70+6BQE63NcTn283UVZC7btkkQXHioX1gcx919oHgJKXHpx3u00mXjg4oCdonPCIwFqF20E6X0/ubKCiD8OUc1Y/bmug+kR0iL9uBTidLNq62maiyjHnxKfbTfaf9jJFmgUKa4LuYEjk5lN80aI7FyQW428yCKT2pHV3rh8TQLkQZRNCIXHly6ybtqIeJk6o3gedNAzEES9KFws2mUOouPlYP2B1rM3rkKlop0FqPG5z4B/+8Z/wh1/+IOAi1QETHRayQ20Eq2OgGzJ49A0DXMSXRAFyFIzigWFoMTu7HSsCqa5JCh0zCAzqQjfldw+hzVbo4aqRdOTiNuZ54Wh9xgVubUCogKuPqecVRewRC9EuhVByV4nH4yE6ZBdDhe1d2XqADLgrAcj6sI/+gYtJzYl4vqNWYCU7rlGG5+OBXz5/0owXxsqhjvK+yqViphr8qF3Y8u9+xTZFvy46moFgciJyUReHivAeIFhCa3v8S2TBS5qiKsXzfl6ainBYIF9j06WZsF3i4H2PqWtn+8/FZuhizdxgoXcog4cxJm5vP+N2HLhNubUVpAFIzAqgFmALZR8akB+1evbXWud2yzRPUlfHpM14FbJoj8xckd3giGsMBV5iYVvm70GruXD3G/WUPjQEOfoF6Jx37SUCjeYDp9ORkPTqpuLRCTPheJ5PVA3ADwB0ee2VhpdOo4po772pp+4uN5Qniypl+vnWDVaRQdS/aFk4M3G7MV/NFXg+35W3lHIYNhKyHLk4iPzPrb/ugtUXai18fTzw9XGikgnbisV25/NXfPnyL7jff0I5OfVRifID45g4jjsdKKzoGJVLF6kwvHCbA3MPPOGcBfLpDTAm6IDvJIqUF/78eiYiA3NM6cyvuR0AdiWLviigLsAwlagSjWOc6wZrouKJ+XbbAttjaJrk/hm2vnwMjGo6DWcuwMjzux8SkRkQ6x2//ss/4fN/9+8UiLnh6VTTQ4+yc5CP9TvXdYgJRaa7AdwGbmPAkbjfbvj1118RNfDT/U7xmXOmQTus6IT4piMBGSxYixHHYBpXJaeeeulQEB2+3W6wYxKVcNu85NJBiSq1ZeXEoWKB9wt95L2GaGTqwBgL8XZ5cSEs1sWxEJwxLg61WGHbrOGmFBQKfIfm2EQ8sc4HmipTgCYEK7BUXsFar7NpWR/r96/X2z7V1Wo0+DZcLlGF9/WOOH+F4yeUGebtwKfb4HVZJyxO0QSGOlWiGJiJC0yevMnGbeisMfMXekhTCRhnUcE9quVG97buoBQu8w9ABdRaKoBZIB86WGEshszG5VS0wZzepE4b3Vdhr1qR3laXSMlKNNgwTtQS+ueOcdwwIGcv0RzbkGQAaFrzx/r96zU/yAjUOmHxwKjC2ziwbGDVwv/2//nfYf/hv8fnn/+AiMDb2x334xBQchWXBCixtRlooE8UGf7MoIVtOWqM3V1Gqigd1BwdAOaml5LeRwOSS6Dr5pwrAmgfE2a5DVnresd/bGrLpqxYx062Tuiw1fTDprzwtdQ+hwRWtSW6GUp2rP/dL7/gNm+Yc7TYULN4FtwCh5dAho9d+z3rNT8AoG7uAgTkzDEw5uQIieHwSmrvMrHOBxAncEy0O5SjYORDoaeeAwS95xwcBeEazdDP30YLgM7na6ixq/s1pyt2ufYD844xyABCAOc6gftBrF5CdZd7ZmxrXQ7K7r2IItPodkwaz6hDR9VoqnNOtZKJ6TBkoGBVWPWgoVTdEOuBXAsGitpRPXyWs1Eylcv/hT37myhYZoYzgoNUfCLL8OvZtrOBiIG3n/8HYEyMLJzvX7DScNx+wjwO4cSJAXmw62asMupBVAh4OYYNnCvY7irRuSS8yGqaSG6aFO3KeABSHyJhZfFw8j1rIzGM8zjgnMQeSbegstYASFCcSV4oXIggD+osOb3A9hBDJyGZr6ZaPLm3OsoKz8ev+N//4T/h7376Cc/zHQyPzO5SoykbT7/mDX+s715GlCuEP60qHOLu/vJ3f48xJv7py1dkcCbHc6XsaXeoYCerUpbR5A872gUrgRboIkXd6kGTegSj7mlzmXfxwJfY/vUuJDghzrK6haYTshQcOLdEaEe105W14IPfVmMmi0XJ0IfBe6J2l6h3WiqJdHd8fZx4f/+KqoUvX7/il59+Rk12bcpxHYHa99FP9LF+2Or2NtRdWHJwezzf8Q//+H/gXO/48v5H/PzpJ3y+32k6kIkHAAqF1NXYLkL9yC6KrIwDitSXLlxTSRkAQAJgmhTwMbtYGKIc8hC1brSoC2dbD8d/d7jX3jOmuK8WNiKD3UNvygAFmAuJUbWdXZQK8qA1Q1v00mY3Mecdbwc7j2udqDWR60RkYWw7SSYBbZn6UYL8mLX3mDoP5kD5gTkm/uGff8V/+cf/jOM4cMLx86fPmKJNdyXAuQNiRvARAQE7AHhOVrsTivphAKq7dhfsM30gAZyxABvaYykePdcAC/bUaZsqMEYXpXbZmBq4n5fg4SlXua1HEZAKiNWhc6JjvbvjuUJDFPn5TIn07wXcPhnMPn1D3yrQaIKzn8AcJRcKccX+j/VjlhngB3zQVvZ+sNvP/dkDTpnbFejyNkef04BZj3bovSQjjjIcxxve1wWuXK6ti3qTLCz0/UOzGksyIawIejdA2YUsYBjD8Xa/A8+Tbq5QnQ7jjBq5ffJ+dM2p6RhKCuIcUnbUNWQwZZ7jAjH73DBzHIMMpnM9xfZYstjm+WAGDJ+I1cPGCxbc93f783H2N7tgHccN81iYUXjPJx6x+MFl4Xb8hJ9+/gOeEVjnE/NIRA3YPHSAAagTZguosTUcNgYMsn1cHPoy0mBD/Nyq7RjgvVnURhqqFptmddn46pV7hwW1wgoSByuAdPu3PdBc7SNLHZqTm0oHOd2KaEtpRveX7ZtcTbkiT9qLDguNYgDAf/wP/1f89OnzFTzx4nXeCOBLUvixfv9qXjqtdZPCXO2nMWlXZ8luBsBDqyCXIe2t3mdM4sbeJ9VFLHiA9ZYrEH2YRq92irsLKy+b2sxiMY2XAuJPWl5E+WwX2N3NK2Phg5JGarQYjgGDrXnRYV6cWL5xbzOTGF+JI0ivoUgZWLXwD//4T/inf/lHfP3yL/h0f8Pb22eYk8d5u9kueI55Q8FxRlAs/7G+e12OQhfNzqCDammWkNzXnueCfVIyrf3i44DNgkVu+kd356jlgUAPWdNa0aWw+mi6hMG55zRAxem1n1P0rqaaVL/gTSm4kDyoe8jp69rDqlkbRoJAHX5fv1/X45uSOvLzU/SIAR+TNsCnYR433Ccn/ZoPJNjRWUE60CCygMu4/SPWfu/qz4/dMtPw4RvnIqEBucT//D/9z/j86WeJXpVoedcsL7SlSkQ7ZKEtoLtDpoI3Q45o2DGMgyV1TU1Ob909M2BPES/snAA+UOmyiyZlkHO+fOMpVdTdGWTgoeSyc4C+V/YP68PYesFiN/DKW2zvuuGAHQa3uQFP1uRJK+lYQInCrWJkSaPwsb5vdZx1OVGyIB6cazF1/a2TO+aBDmBOATZoLaZmf1SftzLkkBOqzxssF0EQURC6y1Luok87un4vITnWhUNvLek7y0X6No4XeBvHzm37HnRnjjKGo2S+sa2swczjOG7KW/O6R5Q3FJQDK8fp9yVsSbo+4H57Q+HAqYI4DZhjbpdPl9U5Vggw+tfXbxahD3PcxkBFIBfb/ImJMxNehqfEj7z9HDZu5MIPx0Qhnl+R0kO42pNVQrGS/FybpItM0wFqutRqj74GBOiZTBBG5Hpp54vkqfZut3g3v5QRDj0ZuFQJoha3gQH34ya3lETmky19P2Bj6rU3QskWb/W2zEAhEIQl8fntZ3z69AeMMSl2euEOVsp566WGtr9wsT7W37Z6eCRySXQaWKIzMalbmOZIc5xrsUMitIBis9pAwD5wGgnmE1z0LBW4bgavwAQT/sNdyJiGbQLcgnsOx8tU3X7h1b2w1ppwR1uxeL0dpA82Su5GrRQPO9JrhMcAtfG5XaxTPN50M8NaC88MrPXEMSb+b//xf0LB8FwPdvP6UM2AuWGaY5qGvaEQ60MY+SNWc96rLpAic6GQGo6Z+Luf/4Ayw+P5jsfjC249iZweuVt/lnL0cSe6vGmJ0EGnGQMwisX3YFf9oWX6NhuH06dqI8Z7RoEQsLalRu9m3UPdZ+iuQ+91U7HMJgZjfWXgPB8UDvtgkWGOqhMhp8A4nzAAc94wNU/qOG4wFIYKkJGJHAO1aDMZeuPDJWrvz/qjA/Jdqz+9PveHDwQcz3Vi5cJZjr/76WeM2x0lNoGDdKQ4mUPcNJCNsax2Z63PYW7bVxqUaU+JDeHO2QhtKwrIZKMjqsEt8Zq37y6LQaop0QfVlbuisoqQbPqX9nXzWVv/pAJoJ3swIBOBnlgNUb6wb4iVbTVMwCszRG1NnCc1CTS+SdxuomdnIj8sz7977c4aLh0PaarOnLXkjhZJ9oJyVfeJqgWzgKXmY1kpFvLSuv6vzGjeMgYe54ljUstp2mDcSwPDmrakve1X3ktjBv3X2NlLUGzubQUMFQVwmSbMDc73Hmd9kbJnbyc1xXvnGe7uYn/0rwlkgm+gPNMQK0hPM4I87gZ4koo1ne6LMJTRqCczMP0HFCDWHxqIGEMfEAr4z//0zxhO+04YLeRYtfMXx5iI03GeX5BWmDahlEYBaTGJTyZP24YSnN5YRqpHFJM4VnLOV1/1DQLbgYo/JFtdsOsy4PuCZmmsT9FCNWNhIDAsNYWUI43Wiu1qVQAOn2xfFQPCWk+s4mAvt9Rm5sCht+MTPn/6mc4b1SLj67GyDKvdloCdBHys379ePz1+zgm3gA/g0+0NQ05pMIrCnyG75pRDhRk8mFBbhsRUtXUQEacOykDJUjmKh4aBlKyMQA7S/4Y6ZUuOJmgHqfWkn7e+Z3jdt1Abf6DsUKckyXf25toXIk5YBbuEi45vyuhYfCewKmBBagqpYdxrPgduExw6aMBKzvo4bgd8anDRKlQsBAI2js2LJj3sQj0/BhH+uMUDZSHigXV+xbmoyfl0p2MQBqeBT/8EN8P78yvM2Y1KIa6RAVsAirzmMgZNL3L1z0q4kZoXizboViWg2DadymGc1GHUN/EeWdJu6PV6bRqhqbPGDgoPMHSHusGfRodT94FQX0PhPJesVdmF3h/IlQnysFXxm+rG0IEu4EUHmhUhuoIeYNPJplzFgk43/60u6r/xtefVjIkad6QXIp60854EIiOCWhwAay0EgLfbDRlBp7Xd/SPlidhK7r2SSdv/tIEpUGSJVn0cN5zricfzIR2piy5NgW5l78E2Dek92DkKtBsKubgHbdC63eiBfumbQmBj7794csSA87UR1ExSqvTa3cfuHLsZMji3xgyUuIoGeRgAL4zD4LcD74/Eer7Dkz9IfOlj1/6oRadBwSJZeOisfz6fyFzUb3piusEqEMWYyD5ua42DNPphu4NVQSA77eCIh6KB0yFxadZFtd+zP4qA5QSNFGg1LbfBom0/5990LNVMI9i2NO+ZY905LEAMi9pW62ateSLoviqVu+4+H5ruWqUh4aW5Ig7M22fM49hznjLoTpt6DchCrcW84XwCseB/ocz4mwz83YH7MXCbstbLxK9ZeJy6KccEIpR40VK21onzTMT5jvX4gnEbSFcbVeqQYUbL3TxRCNEPUtSSgayFttD9pvuhgxQWQp5ZVEwQcU4jv9itYD6ZfLoukh6lD0R3wzSOtLcEBcWVgHyhN2qiCyTiy0VlkKDNSu4eZvQSLwrk9jOa7W6tdeDrVtvL+/tY37H0Aa/zicfXPyIef8T908/IWET07QAd1Oo66DKR5xPv5wMxxP0sTZ41Tjcfbi9Wofpjrs5GAetEucHhnApa3QJ1DQhkN6ape7udbu1MRKNFHXUMVKWKW52ORHOThbxVvx7SHeY4iH6jsejLnWOL2FEY44Cr7Yx0fPnjA++PL/j8y99T91QL//RP/wBH4A+//IJjDhxTMxeEEDXn/y8AHB/rNy4D0G3yOSfWl39ExBe8v39FrBPDb4BNGALDb5j3T3Cb+OOv/4zIEzbuAC7qob1YP5ImAED7JMKwcCKBPUR1uqhawNbENUrWB1cnbW1zCkDWk7yHohM8Mxg0nwHFwkeFiF3hbhfdEQmr3te+OyOvFEUOFZ24+dRMpykDBD7v8/GOPAv34wASOObAsAM4jbzq5u5byZY4P8Ce71x7z6oDUDZ4zh5vKJB7DqOF/XmemO3wJGdCL+AQjbqtlrnRru4Zk3wBjGo2B9RN3n84GboOIclSVvbeqd6vXQR3syN6Zs6AWW69XFQCoWSzBqY4MiUHOB8TVaSemjSi0B5jzuD7vnHTnCbt510WV22LbTMOmuO8m4R5Ahm4e2AenC1m+p0Pm/7vX9s6HFBMIH16ReAR1GfMecf99qbr3rOJcLEjjCMiagdHgGMgAMbZkOsVZQanwE2DITIugz79X0mHWTK7iVjsOSsGOtgRPhsc3Q6ajPeZ2h+mIqiuQGuG3bUzw2Uekie28Ycog/x5FTtBy+gqYExglmGMN+ZDNtgVGobbQenhJcxPjp9AYcx5Aa3/yvqrLlivh8Uw4KfbRAtRI+hT/4effhEv0uGjUJEY+UDGAxEnnVdyYd7uKIm30HZ5++9Ko7IwTFWZH7CStgK1h8o1TDyFvE5zTPH9ybcTh81lQWYFGNtpq4CZeke53SOJpDjdXbBohutyISj1pfb8gxf/RlaOLHS4UaT6V1u1hFpzs3RSqCfVhjDZE3JY0ofI7HvWK6miKpDPPyKfvwKHA2Mga+q/uh5Fae5hBc8TKxbO0+RYRSu+bKRDHHp2IZxUQSTKks4pogXAEtjBw2BOl7fDjD7aBvLY3bZjRQcAOvdc+iWzwooifVEdkqx25mLSSFciADYxhsndSvfGBSG/JAyJWA/Y4RKAFqYFX+NwxPnE//q//L+wzi/4n/7H/xE/f/4Js4faFakyXBra9c2n/rF+z7oSJP5t1InbCBw/f0LWJx0yC+f5hNWQJo3cYvUVADB+ufC11pNUtQibQkioQ9C+8aTiyS0NxWus6N+UsE40XQVv0wYgkMaqLjBF3bdqZ6FO9A0bYmkjhoxQKB47mXTzPasmU529dhnUGVBF+gxQGEhMsENYofffVDIDViWOMXR2QMj3ZS35sX7fet2zO7cfE5bA6KJEse0uxx1oNhe378FEqWtldIf20sh1d7jpq21E0JSoUlViStKHimjaRpN14AJK+KPUvJUgxDFc9whjuaHkmvYyEFHUrD1wrpbsf5dMDeRUBJ3h0oQOp7B5eguUS1LCwhyO969fMWRjbp6YlqKLBc7nv6DyxOzZVEUaVtRHrP1hSx1jdkgHCTUYOIxn/+3gdyISVQNRpF2ZO8xyF9z+gqo4rqK4kHDEni3WMoAUoAj4S4daP6/rb3bKlogd4WPcKF+uU3RF0Qt9klKqnCT3/cjH9zHgcldQzwW1ElXrRWfY0R5blpB5zUbh6x/UodoQPXYKNKKhSY8Tt0ocBvhwpLPgsr+AUP72DojRAeI+mbzRWYp2Y7f7Hc/HO366H3Anyov4ik/HgGHSxWVQU3Gm+hgFLEIEGOYoP4CieCdwYuimtprb1SpAOpcphBDpA8wPDlKLALLEni+4D9wGUb4s8vEqgXSmZaStsJsBABisXHN7gJPn1pdoRSCxMELPD7axQgiLecIcGtRyIlPD5tgrIYKdyaJMVWTz8LN53h+H4g9bcx74/PknvNcT5+Mrllwb/DB8eQSmD7x9/gkAb5jjdmCEOI/m8pIHzlPohDuiClNnQBYuVGQMNL2KqMjFh5+Cft05oNCFEk9va+gWOrLoPdxkIVwSn5VqiJLLhIKMSW9leT1faSCWNB6lFnO3b2nVN7Ai8P58AtMREfjl559xvzv+6Y//iGMe+L//z/8PnOsdP39+w9gDGgfSyPXmIDtaYLet5Mf6MSvWgs+JiSmBOPObyMDtfsdPn/+A5xJnHAB8IEvDKtGFa3dqlehXJ1t0SgG4pZ7SERUMh8+NSC8NwQJI3Zs6vqJqz9ooFLzaTYvACmtkdrVbb8HXwOckT58xMSPw5fGOT/e33TXZ8s5MuLoyTOZEu1InJSLxiIW77qfjdseUscgKzbBJ2gfP4w1j3OCDgt+2y/6YX/PjVmRiRWn+h1yEijMAEmABqCvvFXiuwhqTBWJ0B4VJUEeTJcEr0OCdOiJFCqkb8Dw5QTyLXYPLiMblLMgUa5gjPRFFznuLeYfbpnlpEqE6cE2Z1b952xcUYp1g8idrdIl9s9T9VrE/5UB0UV6YGPaA0J8+feL7jMC5nrBMHMYz5Ha7I9egw92O8co5PtYPWVGJZwTOZKkA0ZupbyY4Q6jbMcYN52KhG2ZYcAKNrj1mYyfy7JyRXurmBCG1q7M7vipKCZj3IE3mn2RdFKbmctGAbQFJmunhGjqIgbF1zAQ6oe5iae/3VPbOSwwaLitwik5Y2F1IvkbO1rMWs6M1WsyBhqjlFUTw1/Md6/GOlQNTd9wcg2YUWfC/4JL5112wXr4m8kvaCe/VRb/3XJhe+Jc//gt+erthLXY/xtvPvADzTicpJEKdknaTSHM6QsBZUcJQyYR8wAE/+EGwX0Y3Ft2E9NvuVyl4WskdRToAail6tSjnUvQPwSr0Hzfe5AUUHD4O/Y5u+Qp6G0chi1zBtB5eJEQPUDXNxLTWQuYp144W0LFDYs3D0WuxMj3nRwHyPeuVFuDuuN3uiPeBqoXzfCAy8NPtZ/z9H/4O7gPv58IULe9+HLBjMnEpomnDDSOvBJuuE+0G5dpu3JMuRKDk7GYutyG/fOO3c1CHK/EISNPqjhhg1poOdsj43uge4xsoZ3jkthY31YB24YC+Fp+Fj6Azfa1FhOM2hPA9gQw8v/wTfv53/xHmAz4OOW4xcSRty7fVdc+A2NatH+t3L9P/kU7uuN0+Y1nhuRa8kTeAbf948tBI7iIaUC3yb+Fb3zAmtXbWKJ6N3aFjOGWHbq2Fs1ElhZ+lgkY4245VgCNrMVGT+FLgN1eHYECoH4jIxEVtMTdYGQfI5qUbge43On8xaaPNORFK94HzRUPHQDsxnEmtQ9zpdUrUyySgrVkz6eaWmaLO/je4sP+G12usBSA3NlKr2+gAMJTmLLi/aCmc4F3G4sRk7YHdTagSGdU3Utt7eV82dVRqOEzX33ahC8VDugGRXuhCmZuaWldoFJjp5hq2GaItmjQajh5QSAB6sLMxrrhrQtL/VMu5HbGU1M4WGptcCvU+03heuE36Ls2JiIIUJSA+/2H48aMWC0EaJ0Cd275qzxXbJQtKwKskMzAjJ6k4iqLHQECdZlgXnG2x31bmylwlKDczjnBwzifL4pnvzmLCpTO2uty3XKwLL+6VzmlLVFj42N0OajXHLp4rGxzte7P1VRrGDcZlMzoJus4RFiepz2zofiR18Hy84/nln1FRCD+UV08M2fbG43kNXvxX1t+gAWku+YI5E5OKhXp+wTTD3//y98gIxPmO59d/gSHI+dTBlaYkJh0o+QfbVXGaSfaoCangpeDf/QBAdyHrjaLkh6hCqJpkMMM4SAlYC8uIgiUKmDcVEwB8qlDoKdFsj3YRwYt0uWmVuPiFRGUXQgqabpiTPEJD6IAtDDtxnr/C5BYwxoTDMLRvWC13MdW0gT/Pl/tYf9uiOHJizAMTQBb5s7fjwO1+gzsR0Vi0N70fLkcWumK5AeaOo4QiK+EDgP2VdQ9N6JspNxOvVJkYA5CoKbz2PHhafEZWX+2Dl/qUFB9fm0WFSqPElqR6le0Xwn2bmp6dXXzon1AUKRcHYJoV1vNE2ULmE7neUc8/Yp3vsLzDvBPVHpJEXn+XQ6p9PhK5H7UUnNwH7Rkx4FiIPLHOBx7vX8AkBCg/YDVQcSJrISLo3oIbzA9y8qxjUmGom9Yd19IJZUYq0irSZuLlEK5ip7/jnHYsepZTA0Am9Llgml1Du9XeJ22XjhB9MPjzKwqHzoh2GOrEkWVUys68B2vyflm68XjYUZRcWTRkKHbfK9UNjABw17DPJUqXTEM+Onfftbhdu/RU8bALEn6fk78Lj8dX/PT5J6G96hgbwCHDJiYfOeW00N27EC1MJ5BHw4FSsexYMPFpLU65EE25CcnyHyV9BgQKSdeUJI6k4qcNOsdZLlBkLMdOJCqfHPQ52G10m3JM4qtM7fPtZPTy0YSE9oAQcO296U6RsWx33Zn4ocssMwxb7F6X4ZXq87F+/+qC2RQHhgBIAJo3w4HBvZcfjyfc6Pb46bgzFskYoQTqbWSvB2HrGQC5WAE6KIl4d0wdDaLXpQ3mbloCz5diOOlg1EmTEgYbePXy2wC48mmvV830fvfAprUWtap5URixh3Wa6IyiUYLFOo8VvtbH4x1ffv1nPL78Str4dKQPOoTZ0IyeFw3Xv7J+cwFSlXg8v+J8/4r7p6mLxEmR5o5jDNRwfF1fMSbR0nLyxnKtl/YOduGQEnAlqOSHDqdssj0CZeRL8hrTIWBF4ozAMaizyDgv2krJirK/b5rKaLQqbSeMA92FcSWNRCksW/3PAy7yumBZQ90UVrWks6h74kObBhJqLlF0HHPeyVvO0JR4OtL05lEtqoTgo8X6o1YVaUxnArCBebzBY2HFiZmSe+vAoJWjZNvO69GTytWGAEws5SogUjifZoiIykJRbKldWkqoiHytSNTsdivt6TR/FGP0HkgcGny1gqhHyDFo+Nidk5JtrlXBvBBwUqWMyDI7GBMF7sGtLSoCB6iizalzcNvIhXi+Az7x9esXHPeCD8PygcP4Glv43roB9l+ujuTH+s7VRYELuUVhxYnn41c8v/4THivg4w33DFT24VY4F/m+sZ5YWHTpc6Bi4Zg00EgzIWlCmxV5AW7tFYHHudAzDkIdF7G1iLgpWWoKS2Rg5MsBzN22i/MSunwhwLyfIgNxnogIYOgQrSQtGqQhlA0UBvYMJ6GJTRXICsT5xGmlpHBh1ok8H3ReSeAZwJfHwjw+wYcE+o0aKrH9WD9m7c6tYkFm4Kbz0ecAxtvuoLYG0ly06ICoLCBK643W1qZtFW330FAKIAqduWYTBLsg6tCm7iNSWVNjvlR4+BB9lEBNaFaHq/NSVbJZJfjTVL6hwqI7M4bm7+MCFFu/V7R5dzM8V+D98SAIKlDAm86eicd54vH+BT+/3TDKNBCRAE/G2a/6xUnuY/2I1ak7zY5KBZ9vUBFV+PX9Hef5gKHwdhwqAhmbU46Dm4qtkQzDwAnqNQCwc5I6pzv3fRWRQ3tlpRy3oHw0mevCaHufEciAdG2OwtBe1t6oBRvA6I6HzocVMsARcBRBUAsuC3beeDAkwXGqo/bk9AHp9AqIMhxqRqzzCUQg1pNT1aXBXmCD6IzC83y+OBL+1+uvitC7LMsKvL9/QZxfcbt/AsoxfODT55+Icgj5nccdn376e1QuHiJGZIO6CjplhJDT0DC4dl9hVcabmIgaACV8fSgT+eKFXsGDLcvh5bK7myhzlDsqAivPJj3ROqwYwCYuQTuDJxEzDp1TQdsodDS67YAqxSk+/xgDK5v7H3AvJYyhA44HXdtHdjvLheBZI9v7tP5osX7Pet3qrVGgnzq9UR7nE//L//v/iV/+7t/j3/+H/yi0loPdxm3gjLoOIjF6XQiF+QCmqyUvi2jU1mKgaEeX4lv21NthE24cJhcaEldCtUhb0IHbp1jF/ncIlc5I7AFvSRpOIxNV2O38PkDJYUmiekK12/3CHZjQMDcD0oYO+IG3T5+BMXC/38Hp66RimabCpkSWzfH3ptl8rO9aTDE6XjDWpdry51q0Ks/C7fNnmE1kAvf7G97eJvy5sFYizLHCECCvfjoIdtCeD52+tCOK+0TA4HXC915qN6zd5+rMEK5ucb++Aohk40oLy110Ftc9x9Wdly0+5zeF/l085hYD+5jqrNWmL8JaaxW74FnnA5a0PQ+c7JI77VARoWI/QWM7Ezg2UZUSRH+s71vXni1IqzMGqiZuh8MPOkZFJtwPJjhNxdO5P4ZTayuNXQ/rHe6wrAvkA645CYrBcwyhwn0+s5AIhdI03g8ZKU3fIP05+Nqvu6KR8Z11CBgk9/12HBpODAyK9XS++war6KZlG5DqfTuH434jlfy51jYeeSyaMDyfJ8618P4ARg3Y0D0rZkfTzkjb+ejafe+6tJEAwGJzqDCc81VlU/h03JDnE5GJedwougbnXpxrvejwID0Gf6+L5NbGNaXUZKLR+qS1x0KkitfSzhsoP1BhiDSlhQNld8Y2myi/wYyUsAp1Aet69mb29OiJLkAYVgl2DmNHg3Qr345tAc46KeUMZpNATy7+kdWwueF+v2/mTkm8fj4evJd71t+fWb+5A5KhQX3xRJzvGOOG47jBx6GhOaHEfGDc3nCuB3qCc7e8VlBHUZgSyUhxX81tkx0fuS8sKFQR9oHDtvnEjEBV6OdI1YLPjXBFpUQ5Otr7sJOKf06+dQYaPjZRux7iAhUbpYpYA2ucTka34RQUO+SIkUgERtG5oEAR9C5C3MTTy90Pa/oKi05WwR98lh+3urVdFTA/cJt3fH77BWU3nOvE4+sfcb9/gvnAL58/8ybFwoqntg059L7RrQFzdj1QAx4n3NpK0cjJ7K6JOMTTpyarO+YImaWI49nDgtAFRB81vf+xuy0+NLFVfYcsWgO6O8Y88IIVAjbVoWPQIK0skIvP3wX/oQKkYtDD3g+8HRPzeMPtfgcAinvHTc4K1ywggC4vEbwHP9aPWw1mQIdX5YKPOzwWbvOOMe8wFbioxLRCgAYWFGnLHlwJEYAr/gGkegCAuYw05t7Do4WYGmbFGUXiNjdqbfvohkvE6+L8phBCyd4Y3zTNcm+d5L4NSJjcdTc3GNzGfn5XwbKpBg1W9fmRSyxsAUk+SAcowOKBT28HjmNizKnXLh2C+V/kJn+sv321q2W63HesZGE7YEmKdKSGtfp1JlsBYzrmOOCZu+NLgI/x95p2zvPSfdCyIE8CnAKONr3q5XVd+97hmukRkCEHVKBUkJKle86sDUaoFR2T07LLnC6aorqkHrdNEvoeJGjKe2a4wY4DCcNolodQ71BXj/bEgVzqDimhM3fpWlIdmI9Y+yNXBWdWmA34ocGnwNZcDDPc5sTjGbsr0t0JioEYQyoNUFylFshYqCq2dbwyDSR2a7OYukxjQKt9Myie3kjBPU9o10uDQq3RkL4DCZjLjRAsdLxd2cDOzKYtarSAGWeLADza3SCHQQBIjFKHJ+Ka9eWO98dXfI0HTZQq4MMxjzeE5uNcui52sW2QKvbn1l8tQF49k+e4wcYTz8cD4zBMsJsRyYmNPXCn25D0mC+sYtGACnz5+sD9TQlTNVKghF2IQdmgCAuOSFnjlomfzIrKRgJJYViCSEdpyJSLwpJpmH6gBbnsbkxaBdpAz0cguuC749OsG4pEeKAhiLJMd85BGbz4PJ57cybezxPDyOE7br9gzjcU8I2rDNolRFM3zZ1ioKrtXf6xfv9SGo4WBcInyibKJ3xM3D/9hHi8Y84DWSqaBw+AOSfuuOPXxxNRtAM9W8CrwoCmCULS9tAg3SsdlMRjXlW4KcCwTdmiQ+xAVwXuJ2FdZZMplexPXSpMH5NUMQCAq23MNiy7dyra1VVzb49zEwLu20owwXsB7qghZMQMx/0Nb7c7YDSXNudnZIVtfxrJYXSoZNv4/6Tr/G9p2Z/8rYq85PczkHbHcf8JJxYWDngEVhrnf9TC+zPxXBxa9VzAMRpE8d1VK2u1mbRMpiZ9sWWfntznBdggGthdrlNJEUvfy8SjAEmOLwOOhLNDtuO17bkkkXLGKlJyp7pz3T8p8XjSUmgci/QIunJl8PdKdMKSoUhFYAzH/bjDx+SwxAQ+3R1pB47j2J+FGcG0+MYx6WP9nrULwZePkUirumkZSNdeXoHHCtznAR8CDJv+DMbpBC6DC6OqjqEvZZDw4qymf+eQNEf5QtbC6AJcJzqnMnd3mohueruptfA9KVKVba8wR+4Xn/BxU5xtYxp1nfUptJZPv8Hvitpb/V3lJ1nsTp5Bijifn7N/Rpyi1iaGHXwNtYB6qpofsHH7b3V5/02uPy1M2ygmQa1OSldhlaTI+cCYd6zHA78+nng7bgTeGoyBY4lSxfkZgkOyNMiSTxo87Hne22sGAMU8xem2NTKabvicsJYVQBKG/ZpZvC8VC9Pwwq6xnUOEJAvs1+keg+1ZSA6/qIPq+8FsDxwOqHNopDbmWvBBZoaPCdRSvsUY7mOKpqv76/fOAXld7gPzuKPWAyuNvPpIeSTH/pDnHPpcJ9z734ZoWAXzG1Y50VzLHSyqAmmQz7DvG5mND4kbrWeQFMwPJliZSFGxqlKcZXGcfRI3UzHhPgGf9EUW5YoWP6Xhg9oU4qNyg5msfSmGHMPZ9pVjVbfMzMjDPhMoK9wGD70WKoUKtCrAx0HHK3WAthNBR7+P9UOWm7No9ht5u2WIKBbBtzuOeZO2wWS5LAcKAFZPVLFwXFkoNxwFIQQMNkNDhsp5k8WitmI2fcUd7Uo0jJSXM9e2MqU9I9BuQgQtOmlUN1BdN1cyVhiokMBYQdDlFEdEWq3QdsHSnnYrzGGoFCVrzMu9wycw7pjTt0gTSets2vjzdfQwu8pCGsVlr1qCj/X71ytqS1opE5WsiXHcMOYNd2fi8v7+Ffe3n7i3wnAmi1Y4MGZhjkND33wLwEtFgkkD13a20ME2vC0/sal+7CSkOPXtPkU9Xb9W071QcjRMmGYVqGOiZHMUaH6g4oEaJbveuJIBojSK3S56gfFeiEqcK7ZofQ7df4sfWAl5fj8Dn6bjdkyEHxjjAArSCnxLW/xYv39902moEr0qNMCV51iLrFOD/dhZHsBLdw7JvT5ketED23yo7C39EPqaXbyFBVp/dgA1ASMlYIj5hNHIA5BZQ+6C/MIaqXHjXgYgjWjahM87yqcGvLI0uf6n75QGxzpfyxjjhbZaG2yNYmf+PE88zxPTDZ/uN8xhuB8DRy1UPBFBZ6KIJ9wkiB9DjmIf6/cudgT4NTu+zAmfK7DWwi2ag1C4zcG4NNgZWefCqTMfOs/NAQSHFJM02/NjZLghoKOdzgpkApm6vDQsIt0wktwZjqUQIOMGn5djXwOYaQJ4SoQLIuwYrjy3C5oqGdqU9ncqxl75AvNRp2hclCvIJAqugkqf2ZgHxjwQ61QePiRiTlr0q0ODOYEsmE3my39m/eYCxNAf+CGv4dLgP9rfoQqJwKqB2+1gItdxIYP0q2ASPsbAIR4uA4YmjIKc8rJG3Ay5AjXJnevxkW1xSvSgWIE1Z386xb1ldLMo0qrGOHBMta+sz7lLjFkIZGpapb0M5epta/yQDepYNPxjjQ2WPidxuH2CVBmNJizgXIuV6hywKWqadArVNsIf9ccPW+4Dx3HHp7dfcK5zH05//+kN87hhDqelrpCJDOqWshKIhbWYWLG1yRTOMTYXvv3ZDQOZBZ8gJUYoQqMceyja4N5fayHWo6tcDqwaRI4rgomlAtfUECM4ndRSXGmjah3DaXlXTX3ZfBbuSdIfk9JgB7t2NrBSwTBTk61ZPP+n//S/4d//+3+HT/fPANjRSSPKLLiStCu0jaFsWT/W96/W22UiFieWV4n6gQNzGOZI+O0THudiAlQsdmeLzc9z06h2TFJnrutRNprV2a5E24hyTlEg0/cMgy5cvBxr0Z5UYDSpWOQJotBug9eTDBVAwxwB8uSXBtO5syhPxWLblBw+QG1Ko8Ms9ve36yAoRK9csAqsdeI4SLF5OyZGPTHmjWCWU0DvIGCWqP18H+vHLDdONX+bE89KWAa88qIj7bY04FPDJLuj0cYzxc7G1WWQEF1U6O3GVnL5U4IlBw8NGQQ3VMSe3+HOGF4+6AQnS9FGo3uwqnmJVpOAs6gf8yBAIzc2JmYhEOY6w/s1A3Kes9ZemfIkskQyAs/ziS9fvqAAzNuBymBi54YhVsl5PlHrgYwnjuPA/f4GN8buj/VjVgMt8IHIhefzia+LZ9nf/fyTGDytQZ5iV5fOZihmtl05i1eLtbNGSMNZoMuCSf8c2rdjHip8exYcs4YswLIQcpva3QhVT7QUV87p7CI66pIiqPgJWe0D3xL36J6ZG5S/QEvpZTOYv5rh0ttxFtic1MwOHwCeiCDdt14OlwGgyhECApoO9q+t3zwHBPqAokxVfEgV35OUeXA+zyfe3/9I69PhHI4VgVoLIw1jshC43Q6EWuGxQskcE7rMk7lOcZBJPB4YYyJs4GjkxAzTHOaFMUGXlCr5aLPKNWPACTjbQoOc/qstxUvO0fEqguR0dBuOYzjOxaBGRwLwMPQTaQtzTHFZ+7NKeZonzlh0JpoDPm5CZE6csbBgMBVgEfT53w4df+mCfKy/ul4/v0Jt1zVOeiYnedwOCbtPpCaKosh3jFhKVBaF3w624Y1TpHuAUMpar73lYbJsFAVq6hBaKtSVZV3DqQad2qqgQ5JCzCFEmjQFw+FDDHdsKmTbnJYGeBHFtm/efZfWZboP3NEkr4jAu+z3CoZnkvP5+PUd/+v/8Z/xd/+X/wichsSDxZkNjHngfuPreKzAbQ4liN0V+ljfs/6UGpCgi9P7CRAgSe1DdQWQOB8PzayhqcbsgWhJ3UiWqyucOIMx+lD3l+zBxNLAqX4FBsOK0N62vjXQyX8CQFxgDR+/cIYOGiV81sWJCflVh2K46WCVvqWoG2ncpbrbwtMG4Sk6bW1dwERhVOLMJyyfMJz4ly9f8OnTJ3x+e4PBEI8AsJB1yuCDn1nm4jDassazPtbvXH8aaynYXvA8JQxfnGOh/ZNldM3EhZHEy3UdZjSWycDKhRV0BITx+rv7LlhMbILOQawE4FiJgiJzjCQnHT4wndd8DtG/mchgqRvo5lv44QbkuHOGmRJH5n90ZWtXOUDJXbEgIYja75f7PkIW2KDbUprhUYVVCQvg/PrE+WUhbo6fj4nz/ArkCcSJBDCFQLO4/9Atfc9q3LiL1wS2i+nUoGKiK5owLiDvmEODgWsDlhu4jlDiX0AIDDeSAOl+qvkbfohVIenBWsCYuB03dZkJXoc2dmZtY5mhjserkx+BIb6vrLZ7LriRicGcNjGFSQ5Td0MawzL+jKl7c54PdYgJ7LgA/liBPKbeLxlEwxwHBuq5cK4HC48x4LkALCBOxHNh5TX7519bv9kFq12iODFS7xiQaIbCbNKTDF++kL5idYBeciDP7JgYtzcctxvmPDDGxLlOteXlmAUO94FS8pGBFZymygYX+ZKm9hGLLtdcELVBURKTU90/xJMfQxZ9waQwJXZL5PbYdiQuhwTI+rRQNunEXAEUrUmtAigTH55DBw3cCKTMvMH8BvkmbP5yYeHx/gXmnCY9DeIP2l+8WB/rr6/XPRsROFfIIOH/29677UiWJEliomp2TkRmdU9zFwuSSywBguD//xMBkg8EQcxMT1eG+zFV5YOI2onqnepLZbIfFm6DqqnOS4SHux0zVVG5cIpBPaxx2hGBCFot1nFsihwNyw74SMx5AH7CBrv/PhB6+gXtwxRH9/SBup5bCGbwT1k3PTUwpE1lFTRu1n9erYMOwtE0LiFtZgOZDB4yV5kohG+LOgE2W3KVMQA+hNSULui8sPJCgA16wWDHF/yP/+V/wzh/hzLDWk9M588YOgznGHg736jLAoREvvbsj1htIuBtrZjU4EQWHqswJ0f1rPNp2Xl9/ImfQbIh9gxQRAgc4w3mnZp7B6sNnYvlTjMOXWIH7Xe2CccVSzSsT2izEMAtNFycVISyOnyaptVtMMKfbI7BfSy6YmUoP4Slq4HAVj+/GQkj+xhbIG+93wrIwACd3v7087/h548P/CcLVF7I6wmsnzllGQqQw0D0pFpn7F9wh3ytv2F1QQ5AFqEB5FJjySwNr9jSCrNJwKaCU+MqXLHQDmlTzk+xLuR66nglbNIOgwCHFEOByDTm4ARtzHPTvw7HDnZtJFucLmn5pCct7Ekd9ygUHsevR8o264zOiiDT7G4EOvhzg8AQZVBN91QzVMUzeQ7H1/c3XNdDydGFx7c/oWog8c48sgJdRIvZUSsS7hftgV/rN6/a/9IxoviFOSdsOI7+jD8ZxAAuahFvSm8TmHhCmehg5hZYwOvOHdIe9V4b1kQsCHxWKjpIXersMNax1DZN4wvuvUXNqotS3gwHiM1QqLpIjbYNIVFzYiYGT6CDODnRofFBYQF5sfdyIFBkMnXlvX7GON7h8+BbYqbgTAUdGlAudhE614avOerXD9q/3QWrKVelzm7QBWfbM8q7293x9ctXjpIkujIDxjGJ4LmcBorc0GEOHCeuCDQfme1KAQgck8VUgsLyiAUzaU2E6ZobvFik8Q2zzfFt+97mlZYoTytCYszSpa6xqQ4TF9JNj4y2Twtc14VhJ4bffDrDhaoLKPLszb7wMGy+anHTRYorODiOIwdPY2eou345Cv2wlVl4PB+IdWF471c+uI6AG5HWVUCtgs1TB82xcwMoCr8TUe8ykf8qI5oKcE/y94qjT41Gh7iedInhn6Uz1tAhQvcLUkOwbVKxKU7G3JgyWE/7MfYhQ2te7MIK4qDyAMr9MwgSZMNitrNqfBjmmLDxBV+//iQLVMfhPEC5L/s551Sz248V18tN6Acv6sL6zDkAOa2FBmk9ETPxfVN8dyBgecHqwoThkE5tuN3OUEKq+2o1AUh9Pt5ugbfVcnYmQiwGV8XFLJlciNAM2TjVhbvMGVyBnIY5B+Z0TTuaZ0/jhGnB/T20hzXFhibajfAN1Y8fj6coEIGsxFqJnx8X/sMf/iM+vv0bTgemBayeQA1YfcBwghlOvXHV3P8Cw3+t71lZ0jG60QFNdx1AFynAcG0qdlvayigDticg3NhJRyFTYVMpFDnVQiqnoNkO4D7ucM3WrA2dc/0pRwEAv06HW7o4/Z3CTiBJh6yJQjiGdFS5nyFSrT/bGNT964RRcRwDwxzPCMQiAPnt+cBjLZQRVT8MqFyIg2YJkdSgRCNTNpB+YJVhIDfw81o/brWD3vTBklLZMR9XbXaL04qNk716AusBx4Xh26wfDKtuu/wpWhIpVUOFvRUDX2mPIL2pzsRtN16mRqCnB/ULN0Dr+hatff7sMCh6FfS6BW7/Ym+a7g45LFYEUBccidk0rgq6vAKwc2wrX69FnV9SV1Xm8HlyythMDHUxngND5/+vrb/ZBSuFIixFvjeqW/sn1Qi0EscYEmMD7VpVGsuvFUhcHKGC3RzdfXjhFmhIgVpEV4yqenIuWVJdK0DdoVyOUBiQmLuIXtDuF5jNazJaj1FsRMwiJUH2McitJ6QjwbucM0oUsnziuQp/+vlnuA+8v79jDocp2M6ErLkfm1cXKeoobqs1GDalpe1Lp92N0fCXp9D3LNbdtlHTOT5xjWWVXBqjDjeEPgNOxHhpzTHhymWpKjxD9AJQBDw6LKhq240CpCKTaTUALAVd6YCrRI3xqegZMGuqSaMnfO09bSzcE5LOBCEyZnf+hgDhpjRAU8AERBsMtBtYgmhcAVidh2PAPA68HydgN0e/bL8yiSuHxG3evZEMFtpO+LW+Z+mj3xdKQWeYUFxSBFkAuU8WUyrwM3TOSOQ6bWIlYFlyQDT4fAMKWOuJJYQXxaDBLuI4hyZNZZjCZUUTtWp3IbkcRglpMyQo6rU5N+VrZgFO2szblKsb+qJ0nsd7PztVSkzE0lSa74UXG+h2yI/1JG3XOI334wv+p//8v+Dt/QsqPjj6l2Yrgte8S8tSRe3U43HhmOermPsRS5vWfQAyIaAhwUTVg3/EB1HbK/HMwrcrcBizXhrYYR3BhmDMN7gborj/Vlx4RtvQYrv/6GEQNQu4soCA9E6F8+2Qw4+akGQoMbTHWaAR6aY5KUQzd40gaHHtcirkZC44iWlwSEUkmpIrsHOMgVPTGWqj2Hw9I5E+cUXhp/cTXwatTd/mCZsD63rgeX3gnF82RWiIveHTMLojf63ftITLbYDa3WQn3/QmwwKnTlELz+eFr28H9WpBgKfyibWecE+4JXK8AX6SWbFd2dpml2GEG0xpDdzg77mmeGTD9F3fIcQpB0HV4Zrmoal9SepiqQamDTon564pXGtX78kvNa5e959HQrk6DDAmBXLghIKS7UAhgAysxwfKgRWO50qeo2PI4IT3Q/kBnwbPp+zUf4QIXV0d2r5WKFIfArTGdaJjFcgorGCD0ZakJX7bt48HKVhzkhriFBr2tKSLu05QHE56loO/FlWooH2vF/jwyw5gqdvU/cw3JdcO5NpFoSl8RU1Nd6omG7MOW+NUbeF6PnCFYx5vCDg+nk+8TYMbg1laY+I2McZJNEWbhMKiVOFGW9jefND4meL2ided+H2r+00AsuY8UGvKjWIRRROVCRgSZhdyMWU0nQcFv4btQjvEi0/hW8M4qh8+99j+uYDDTcm6tFLrUTzzN3j+MFfkno71ldI9yOeGgn1Hc0Fz/73+d+r3W9hm4jmjCivpCjcPUmuuSFxJgWgWSDGowPtx4Kf3d8AM355P+fDfFJrhg/75shqkSxd0prX48rW+d/U4nf8NTZvp0DaH8+KLwEwVbT4wjjdEPni2OHPIh/Mse0QbexRsqJGx20mH4uwQbZWNbfOK76kx+b5ZpDGODh6cbTRS2ocCg3TW88KtPYXmBA/3f6fSRbbo+P7BiQry2YgINfVE5VwuVmNMAI66Hvh4LtgMnOPg5b0CCOUneFPMijqAeeJIYIz5orv+wNW6n9r3nIneQvR2jIlR1O6ksWgqY9pyqfveXHwfqHJU0DEoLYGhGkOob2rPtIsgwEZ2idpyXU+8lePtPDEh0aymKRCl1Uz0U53Tfd6lAVYGywIy4aF5bzU1Rtkemt40lc8ENHazQqALG0gdY+D9/QseUXhenD7Pt3d8ndT0XUvZCSrgSLUBWgPGrNjXnv1Ry53v8XBn/ozu2SpSkFqD8ViB043i7KQRB6TpxVTOhYDn2dFzPaswwMs0wQs9H8okGjwvh2x1uy5l0KBjUY2O3CaTtml9qbrSfEj0DdUYDmBK15x6zXWjpH1X1z0JNwe8p8+1EAuwcYr2Z3SWLZ3Hqeeu5ymfaOJNja0G40+HRyli4N9ff4cLVr852EEs6RLMtsSqEtf1xLDC4/FAYaKOE9DoEiDCutbCFYGz2D258Q0FhKwGBVgMJzS0JZ4jkELIYBI6Vv2C89bceaiZyLT9vbv7ZHgMy72+aEuNzJVxNwTG5qVUkLkPzPMnDLmsRDxQuOCDTYeNQ7SJvoSlMSkg1oeCC4kiu/4ch0f88Mhr/Vs/kdf69cWHzHDbiUYtuZ/0PlE+iEbuCYoR2di2AIsfRsbCM1ioVRWOOeVtXXsKkRG4BEWvJLrbD2SYySki4KlOBLfLS5v0AaIboEMFHbXRt7wL1DJsG0jxq0No+P46qO3z3UVeCdGpuODQz+ET58GwxALtIxOFK3j4DqvtONc0hXbAyz977a/1g5be1248iZbJ+hmFlgOqB+QlZ/dUmoUQaYBecmqpJ9zGdm0ZnS1TPYGzfRYN8z2uvy9FnYkVpNLbRGLCAAwVcDC/G+JOgoZMGID7e0Ae8mZ3AVr32eyNpIPnL1FL0hVpJz1g8+DFbHSMQy6UD0Qm1nrCInX5F1PezflnkgVu029e68cs09Ss9P5nPHejSysYB2phGprUrHOr0GYH3YQ4aQLUc2Rbgta2ynVV/KzzdNZboYJ60cfzwloXKduZeH87qWWrRMQF6z1ThRiHBLx8rQR9SAmj1hSbCVFqtoff2QZRgCG3QNhNxgrZkxg+AwQFHIco4vPLGx7fvgEonHMy8M0MMSa8irkggzSZWGs7Ff6lULfX+vsWC2Vs6pPVDfa1fXQVm1l3uarq1LWiyUKCJjE+Btkv1iL1gJecAlFsVlR3urvOIN6czBXhfh6Tjpor+SuhsYiSNhB94YPsjrFt1mvrsW+3OFF5wUlNS9c7qyyxMLwoJ5CEIgPM3zmGpix8H7yoUYa1qyF+EVprdRuFtPOsD1KwfnMD8ueFhe0AFTLLIyR8dHWNQdvZeH5DrADcEIsXA9bCMMOzsN0i1lp4Xk9kOtanTIF1PeBJEVvZgcOU5yH0tgVgTHTk26qeA22j255SBrAAbBQsg4JNI2JiJW5dJtZ1IeMi4osJWCEWUGCHWziBccLnRKYDi4JPGydsnBIxt4tH4uMZYHYJKT5TjUY3USwafVv/ldHC7LV++/q8Z5vWFhm7wYXGimSA8+HtA2dlyDmIk4dphgHa2X22nj5MkwmNZQuFFQzBCg4rGaoJWvs6DDk4haBDEVBKJG1KFYZtJG5YbpeeaUNOMhQwrqztwLWqXWT43zfVhD/7SlJZ4ESRn5ecvYR4D6dLG6mUTd0ihaKwkBE4j6GDxu9pjRqzi7Zw9P9/re9ad+MIoaXyfs97/6HIG2/b87UuGl5YC2m1LzOwIvERT0a8jAnEwpfD5YLlG2RxNZVsHogUD7lU8XwnJ71T17H4d+BUy43BMNWS40r/nTnGTY1ZITSQe6XpkQZd+ro8N+0w7/aqrVSrqQdlqDR4FKd5ERi18PGt8M0K5xDinAsrFlYY8PaG4bWdi0j/tb2PX+u3rT8/a69YWKngypAuyQYQCTPpLgOwkcwRGJ+ATQykAhqi78eSWxk4ARtTNrqiQHVT0EWPoXAYEI5NjXo8nvh4PPHlJBC6ng+8v78j1kJEYB6LdJtIjOF4PB8oOH76+hXHceC2aub820FmBfWmrBsi6SYUlbByAgbOpiJBF6EAUJGoCEzjBB3HwMfPf8L7cfD3O2agdVQCIbwnM3nnmbzWdyw1rWQOFK4kW6BUz5KOzQagjG6TkYuTAnMkJsrfUDZBK4wJYG7XqFI8RSZZGF6JgGo8fJp0dDtTtel/0279R4My7fFSkJuat6bzkwZJgGep4bG7C2YTXzSHMPDMRAUZRGMScLKBS6/Nx4lof3SQnmZyPvTjjWBXcbpXsfB8tjCVRXhVM58Eiv1WClYBvwhtMSFQ7dbjfuOfncRsPjcHrLv/CHbwYdDYVXkF4CFV4uFlhxpWIwt8Exji17x7ukbBDVsWrE7ShTQ3t+/+5EyOK7ys++R0w+5Ce6wFcLTaH6q5IWpivr3D/eQYfxzkjBoFokxYt434VRbW9URcARstdpua2viNVvqdNMKHoidFr/VbV+1/aQoQd+ZGAkQqjFOo5p8XCjYODJMLSiWqDMv4mRBhZuE/rIVcpSKMl4T1/qnkAQGTZZ8cqMaQ04VeWX2mXxFdaMoLBWItghwYos8YAFy0p2xL3r6EoSa6PjVVPalcWJqemApG7lPoWcsaWLLwu/oyVdF4HCfOgwCA++3SARWKUDbJa33f6pkdp7I8S+eYKOdnaEUxL9HhRC1aHZ5jKO/CYMmE9DQ2ujY05ZONtLlLEMjprpvji0/4OGA+yDvWOdap0b23fTgwJ0aeMBT3kQp5WjU7Mham9BvnMXEcJ7qI0hhjo3wO5/0YtRPTTed6xMLRjfQgqHMtouduA9d1IS+moo8icrySSN77+RXX8xuyPpDrCfcDmYc0U4nn84H5/js6cb1md9+1Pk8gqoDnCkTQUbJsAHbvq6onKk3NrxKjQ5PmMcEzsCerIK+8Qs2pKTvM93/TtpRntYYnOAa1Jsdx4OO4UDCcx4HrYuL46QP//PO/4V//5cF6A7wPzuPEv61vuK6kw58cEbtB1cx8jxsNtLpeapJC56zr/u6wZGYqUIfXLoIl45vDDW/vb+jTdAWBySESxwCfeSQpbXMy0O0vpUq/1l9f9ek/Mms7orYbH4Xk2MnfbokFTh3cDeYSmY/JOmA6AWjvKXKJjcPPk5djkMYqofnQ3Wti7FTRjIkBwD3X5it1ubCaySVOQE7TG2k+onsDUNPCOtpEFTMkPC94LQCJqab9OA4CWlaocmCenGTPkyHEdmrPDgQMKxLDAu3sWZmoVC1v/WwPVLBY4TlvnyxP/uv1d2hAsAsvwz0JYVNQcgNiYY0xKP4W0lUJjDk5qoHGNgY0R46jzc7gAPmefuyGwHt0r59TjE8JFG+RTRVzRIY6txtWrE2/cbTTEAs8imT49+Zkc6F8Xb55abTim29qNO4vy3wF0simRvpVJu6eYwyoQQGOceCYx7b7JQf5E3/eDJFLnfdr/ZBVovOlBpjOSVZPzZqrbk4HlpSTlFduBI3FU8kmkkXRcOk46n4ephJ0G91oB6F2UeG4lMgxe4EFq75++BrEYhHPvvVBbQf4iRuPgh4cPpca/7lGoupK0GnXJkTkiiACXAGLJ9Za+Kff/Q4jL0QaVhkeF8MyhxuO49hNR78H25Z1AOd54nFR1PxaP3YZCsd0ZHCHDCFcpmAoBjy5Jg2toyM3nucxAzJ93FqNKogO1QQYmS5MgiNZ69ZF6O9EFDIX5iQa7HPuqcSmrybtrdnkcC8c89hNs9pdfCrleKGOiawAkvcE9ysLLArleTk/rwfW8wNvKsJsTqziBN2lTxoIjDE4eS9x9YfvO4OTeoPJnYnA0j/s4/xvfq0VWNeTZhs94fKhekoGyHZg+sSck5OxXMrDqg3GkLonM5oqTQMH3HdEByAwJIu5ISbY1Rn+BS/HT19IjRnm+HIS5e3U8f/9//w/8LgC//RPf8BPX75I5E070XPMBnIlSE/qQfbPxHPaQbCmA+GaNEiLVXBfCxSKYN6TgdOMYcCxgUjRWXKJupV6bmwj1oB0eD5eFKwftaw/p5sKqtYAuQBUaQoBHHMyWLMdS0U1tGHwY27XyAZaTNb1bCIFLYmSRAe2Ba+xQRcznkWOAepECJxuATqMGU+6390MYaV91TRogvSV/fU1gazYjp/iRyDBfLNjmijWBpQDgxHKba+79aZWgE3AOZF8LlkPo4OYHRnX1gDSCQwE/n38Ra3dX6dg7dvjFl1Boyu+z7bHoI3ieXcLelBr8rIaVljGB8lRdFBuNx/c45p0ISKxZM8rlyAhwiEuXrvF0BecPSeyYArbaucgppAm5BWwi8S2TmPh5zjswPTmKUOIBpsgNFJe0GjZcJzvmEa7MoYSugRIjLWvMfYH4ULAOcITLULdLB0LSMGKehVz37O4Z+WCJa6uOV3OEi2SvdHPQopbz4RkwMXJ7AI/7xwRp5NOot0ueojKZtQs7vRmN1gCCwCMpgPVCAEKiam91n8fEkberhFtt5qNQqMnrd248ycmg0t6F/3sMMc5FRQ6BoYBV6V0AfQw/+lt4n04bMiFKAqoxNtU4qkOD5aN0rHofXAYzAvluZOFX+u3rz5r+zPdmTSfzq7eB0AhIOvuzI0wTXfYdE5LkiJEnV4ogA2ofuHt0GdrbHY3kNSTCLT7ipwA5YKYek0ArXP5NQzllD6al4p933++qbJkUcmQQX8X1oghNuJszsanQa4FTnWuWBjHyXO3Ct8eDxxWOJ2FaERioRAB+PyCwwzwg3sbjisNPg5A05VXEvr3L9vnjWHOgzRWtGMQE6PH4DQsMClGd4eHHIjGQBQbTojOZF4oo7HGAPdIle39z/zVWyfVk5gVhTGc/8xDbpiFdV26wh1fvv6E/+G//8/45z/+EV++/oQ5Bo45CZrOAy2aNwDPtRCRCNCVcLhcWsE6whyIXJiwrrsAEJ1+Xot0muIkpC2DKXyGUuK51904mXS5KEWE6ILMi3IHaky6M8ULoPye9Yv6QI9/TzQAsF50niGw1m5Sf5eb5RJYkBOlN7OBzcVTDmxmBGmg86+F6QjSsywDI2mlPwW0kGY9GWQ8GLoNmJws+/XcZ9auY0uaFTXiUFOyAVEI2Wx9CiZBfrW33iC/T53/NIHYza4Bx0Fwvsxh0nld15KIXxWCTHJqTyX1rP6FnvmvU7A+/S/2FZ/oTaYevThSoq6RughY7jeCdK0bGd5IbZloLKaLNdXlsfOkL/clvmUXjPfId8swNwrc9IVuMLDFsqmiLXsDttBX0ItrjNShSLqhgMFCIIQeHqMPkiF07ZOFakPY0HREDYa4BWyIIMqBUGbbaHaLh14Ix/esz3vWIPeVcVADuYXnJopfI8EpSlUhKyjStSm722NTAwRsoCqwVjuS2Kb1lS6cXU26UI5xoJwt7c09N6LMdvOJh4nm1FMG6T324QVsQ4QenDV6+NkP383QjvkDchyvxPxkNnlOx3nQCri9whFJpFHuIM1DjggEjPx6CLUTtaBK/umv9V3rF2etPssdXJqJ0N7qSwOawF0JeHVWkUAiHxiWGMViZfavV+HKwHkcyikCIm2DSZmanOiSSzVD23GqyChogwJH0UIcAnaETjeit8/hNk0o8PlwZ6Gp56RtsjdVy0W/2RO+AR8nmyGfgE9MJM45cPR0HIVYD054JAidY/BS1fm/yvDT+U4Uu5/B1/qu1cYYczjO4wDywlraKBW885Uy7QJhUp85mqqFFqPzDF3Rp5cmYdBeSaKxlIDw+27zGnSB6KK70nzEMhGLtD4Hxd2/++krrkw5d1H39PsvJ67I/b3nGPCiNmDJhr3UlANde9huMjZdEtJPyW1zWDcsAjVNNKtiwxw1aFnqCqJTQxVdxLkDPqQREej7Wr95FXDLCtBi7f7drv8c6XeIasGwzFmDfpoQoydSMkTagKQRgJlEq+9xmkC8HsvSZCOwKtm0roS/fYEDBAFFNbyirchNNTUaqdplJ0AKeE+6u0AwUcUhgfgeB4OdwT57HbLz7fDLApzGEuNgHVPQ1DhT1vtP5LrICpkEdqAhAGvpO3Pk19bfFTqx6SJ1K+550ABwyC/+4hsPFnTb6Scd6ff0oQWK+tz1gonqmS6xUmHUCvtMWt5WUluRcck1g4hav77OcPAiRzRlNRmwvamG3RMIbkWu0CXv1s4EvBi/PR8wAIed8NmGe6LpZKA0bqboOYVkQJxN40gWRt9l8DBpkZprWhSfGpjX+gGrG8UxkVlo2+Nd7Igr6VgYVkA3zwnAE3OcGnmSx4laWE8G7gw/+DBO2jZWtvsFReaM9ujbKlWEcZwfPUE0iiq7gyiFaDFY7nbhyAw6ypgoOYSVpTHjz5LWjRCtVZGJiovPpANzGGYBb6OUNbPoKpcPwBKPVfj5eWHOdyJ0Oz21eACa4yps/Ulm4nEtCi7nK7vmR64+ixoI4fnC5tX78rouBvKJDkCL5wI+NRBDl9AUckbsri+/pvaF0LMOShWFS1+zQR2A09mVIbMRw3QJHHW+xZ6WFbJkBNLPhHrmU6nSmYFLf67Q57TE6KCGJbIwhyNKdCz3bZU5nPSa/f2SgsrSlK80+RxqYFDAqTyF2u/HqwH5UetzpkKCwWZZF8wmi25da6lCHoU9Ac6k09PcAaiG63ruc5rpzYaatKmPyA2rXtcTc/DzZd0TRK/nEBAjtDsTfkx0sOr7cbDOEF3E+j6QAUKCDIyUO1ZWopwsjuQ4hULyBrDQEcjA6inKrg4JACRKdwk2Qp3SwbrflsTuhmvx9Yzh6DQp91fm0g9fOp94pRK4yy5M5c662iFNYLmrRosiw8EaKEGbdUgm4KH6UOebAJYxOPFi+bzkkhp4fjwxkHg73hjMiZ6SNb2ar3ezf+reSyawP1Wbs0AgBav3musc90w2JTtjhNORBvULhlgXfA5pZsU8Krp9mpGmRf2WnFyHwheTMRwum+oxjIykX1l/swtWd0URErSWgR7F3duL/wWGsBUavQIg2lPlQoAX5BxvKrjYwLTw0qvF4MU3cL8S/toxBsrp2GIGoHhI8M0zoCbSJSJO/n8rinv750AV3YDEqzN9j+bTXbEANM+UF/kpe9WICx8fD5Q5zsE3+FmBSH4gS9ZlKxNXOaYCtko9pA/DMQ/MceeExNLPaffmfq3ftn5RUrDb3Yhyd+ctrDUkhiUmCsMCcDXTlYhKRK498XDlg9QceKzAWk+gaA89+wEr0gjSwD8LqJBaSB9Id4xB/vojEtMprJwSFqaKTUfiuhYzH4brdQKF2E7SSB58/X0igbUAlGFdSqqOC3k98KxADsM8TxzHgTkMq9jQP58PZA2ETeYo7NyeFnjyIXZ32enVLlgxJsb019TuB6w/P2s/AzWZndBMrH9oMttAEKfQnETn4l4FWOQPTWrJrks8ng/ADFPakIieVLOBaclgrKUXRVe3NIZjfTweQATOty9Cookar1hsLqzNezkpqwyKcc0leLwBmCUABiBnfgX96coMkYlr0WFlZeIYBk/gWosTvUHuPGLBiyLfORmW6XBUyfkugKFEatLAWCZ+Aglf6zcu1jmiYAn8y7jAEOHAMQT8olAC4ErgoGEwX2lduCReH2dhzIPufMfE87pkEjPId89EgGJ3CmcT17rQs6wINhB2FNbgZ56xsK4HTlcyuSYjMOB6XkA8EesJSMuHuGjA4YbHdSGSWgADkCvwzAX4ZIaZD56j65J9uYmSI4pvpRzrbt1rNLURjMTl4Jm0q6n3093xuy/vN/otUNRE836t3766Nkffm3VP+PvuX0FXpzloCGNJMIVa34HhENWwtHcvnHOq+daEC9TrOZL2+8gNUnLqBgC5KfcG4P3tbbtnRjxhmGAeXTtRUm7QClbqRfg0ZRUzSlCAJg/bLKpiM39YZx8CoQj2QBQzgF+LZy91I6eCbAvUl2TWBk0320h/Yg4WJulLIBTpXsN+naL9VylYe9Sz6QBkH3fKdKMMsO6yOLZxF1PSJ+ksKq5QCrNi94AWrA1NCvDJUs8dOOBCQRw1D9FgOB5zIcrlAGqhemeJr4yia8rbcaA9tEMXH1MvyTFtnnvq75hpGtEfGoBjDmCxAYsKnOe5aS9V4GFpTJimHmDyMlVnDWkDhusy7OmL5Z7SNfPrtX77+rxngXtC0M4UpMW1SJdhlgMBczqTjDKl5bJgMSscg5zmMQcnFT6wVrB57eamp3qGfcmiCqMWLLkPK+k29czCMxJ1HPhy/oT3k9zjKwJRCxEL1/XAtS74eeA8hhy11BCkxvGfrPhY+CXWSmYn5BOjLhguoC4gDQMDx5h0QiqTZarTJckPJG6rXZahLr0WD6YeT0MOSmMfQi8k+XvXn5+1LTDcXuoarZuoK2NMlEnzo3lGaipmQmB3kCo4dcsE1ioYnhgSA6fE3szL0fkHoWhCzzIp+P54XvjTz9/w+59+wnGenCRkalIHnW+8QN8OotnrKiCxhfJEFWsXXZkL7SU/TPdMMKn97SD9sR4fiOui2Hw4MybgqHXRUEGGCV1cumiyw0l/dB/YScOaFDoKL0fT71v/9Vkb1GdWSDQ+URgwLyAXGc0wFAancynqVRUcgVqFcsNKnmlupEJxCtaZBATrlnI8DCzg3frMDTgGcj3xrMD1fOJ6/Iz3n37CKVMNjsaBigu5nqj1wBUgmBILFgsVjpG+p3GmO5uDkoCHUtDrpoePMXeTYB641oVjUvNCtoPsgzPkaC1DEJ3hRMcn5jy2UD9tMQsCwM44e63fvH4JPPSEtqceLMD2FLibhXmwVhwDc/I8Riy5qoamZ2ywyZsJDOcZnEGWgUGmIWAemNXFJkcTbeYyDWk4BZ7jAnB/Tw4wuGem89GL5LNA1gMbneG1HeNIf5K2g+pj1swQh8enJsKgq23yjhmTQaGss6X907vWEyLSq6iNcg9OKsfCAJ//8kJ6wHH96ufx91GwJLzlhyTRo/i+WRLxWgsQWwuhEEFzVE2KxJ3NgHltG9we85N4xsRUFH0JSnoTiGNXFRjGXAQrRwUtfINfCGYpdJo2fBQAkw1/dXMS6+4IPwnm27Vrtg1fyWPfiqjycJzjAFqroibKjSO1Q04AUWDoXI+97PM/fD+t5yLNy+su5LV+yCKto8ODODrk4ZKadiQMQZqfRpRsHB2WjeMaEomVF2ADmbx0zkk01St2GjTtJyfWWhrp0r707ZiAO0WGuF3hxjhoZ6p96Epcb3ThnI5ziGKobVFFJJD2fZC4kc+kMos4ukficDZYxtOTI36wEKNAeYjHSsE5mjJg/XwKAapGOfk6DzNO9eq1Xf//WDvptvpsMaH3XYgAAPMGHCX3tnvK181Aa0KGrBxXFr5++boTeFvjsQMsq9BKpeEAElhJofsA6VP/8Z9+j3mcG7S5gnkKhYJbe+G7HATZ+M/he1+iTPbQt9uLDcfhB0JADIwTv2NwevP74yuGG9Za+PnjG0YBHg9UMlvKjRqvDskECmOwiOspUhMsbgS0Re6v9SNWf6atYRhjskji78JqcSJgg/TUSmpDDHhWUnSeT2QYUDpb3TGHqHbFYmeJNZHKheEZLhpIBbOb4iH3OKVIx9ruVRD1jmjyhcIFR+Dj5z/i7RzItWBZ8PmOSOY7lB3MQPCBobBL9wS1SeOX40vVKbR2DZyzrah5tNJoZCAsERWoWKRRwoCcqMHnsY0lSjQX1hD4i3z61/p7VxdiqubBu69S+o9qSpNtm91N/jHDnAPvcwLpAJhy3jKAUp1KShdrZ5rBDESS4syiswNRbU87sgCIyg+nfnNUiNLH2rcnHOnAcwGXaoFphmNgxwWwwQC1J2DzvJstJDhzvhsuvh+1lQCdacJoAYJZpfeGUw9TnfGEVwH1BGxhjDeUXt9fIvX81QakVfa7UOcwCdYc4v7BqvTDQJSjY3/GiakCvVNxKWrBoOK/KR1uPZ707ZWcslUETDz3wrdvD3x5f4cPgGlGxFXiunahV8XAOZd93eY879ET+N8q/ksb0ey+8MnRY5M0AORkSqn3B+pMVDWftOE1A3zykMu7IRJjZn9fvgP4dHC5tixeFKwfsLYzS6P2m+hxu051xVZgUCT15AMGFj3UDEG2kgbYRETi548nzuE421KPXCSUjz0JSF2SZoa38wvGwT2RVTjMMWDiUPqnBrz3P2kCdNAIzAFxNA2VF1Z+bOeiVUS7Z+sDhhoRH0ANuCXG8UY3KzfEeMMTB6yAn8NwTIVn6uByY5FacD2vPZ41TCi4UCAAhaQ6F25I6bV+4+opWls3d8ZGdkG9p08yLlCDwvYYzHapxJX0lDcnM33YQFuC97S2uuHtPa/f2AYHMgzpYNVVEnwfp/YWx/zPlTcl12hfvS3QNdblRIZggAjuaOSRlAF57IPhsFH8S5yCO97GEL1hIHPh4/EzvhxOfd9429+74DtrwXzidNKx9ntbJfEpBVq3CP61fuv6vGe3CNcMZcyeMSc4k3Xz1lEh1zw2hwcYiJZggOCVwUlA0zuMjlGtLnKwiF/XBUPikFvQMDBUrajVyyocx2S6+PkGfuYJJO/4FYthcbFwfftXctwjsdZSWOW1QU2bJ+9tFYbPKIzJZ3H0GYnEt0tuVwJ4pvmn6bGrRmrt0SBPN+VOGI7u2EZ9rlF8v780KHlt2u9ZDUBs8EzNX+h8IjWqdj+ygpUbqazU5ExRXw4B8GkDrSmN4t3toDthqjZYxWwjVshiycCR1bKFm3mwAEQRxIk05YtpgmiF6apmrVjAK7TWyvb9bBZI7c3NUgLB/9Do17JZQ6SYrQbEUZq0AJB2xVRPsffgGV1VOLxw2IXKC8OTX6WoHyy/dVG/tv6OHBCTFzVFjwC2cJF+6p95ZNAPa/uNKaFtKZiLbwdRBP5d2wWZoRg2WANRF3bQWpGH7E702IbBipZ1lW9sZO0WGE7v0MN743nSsWOhBb+iLuyx0mcHIF2c/QVsSEzeIiCKnLv5IEKhUEIfTL8Unz4yKfJMR1nKFam/jkaB/f1e6zuX2g1NNerT50skttEOQzuxsWnughukDcSNQEPBQ+dMIC6UFRwT7reZXVUg4EgzBAZFlj5QY96iRLNN+3MfuwEfw3HMiT/87ic8rwuZC8AkkmE9Mi3McfJ7FIDFwyFU2A0FzpFLzJ93TN8NSMKx4ByzHm/APDXhyB7UsSj1IQs/7vEh8KHd60rPYmnK84KSv3/V/leftZxFfDpNeQZaXxfYZgRsVvoLtaC85P63dhYNNLFFFsoEGFmP8uUAFAuHk3LKxiSV+8EpcFubUucWaHZII2W+eMldz9xaji4e4e1EDznLBSqCz821EOXbTrfMsSpxJfDl/B0MpEacEC+5bFMEVhaiEmWDF7vZbt54/1AvwCLYGIhXek9f6zevxlGB+6xF5f6dpn30+eKtCMnSPbq4p1SWu0Cckq1p7qLnrhlQsaleboYxSSk9xciYICh4JTCPE5HAYYUrDR9X4IDynDLxpz/9EZYfcHOcP/13yPWBfC4YuC+zTCY3rDmybKdmL93nDhZ9EI3xPA42H2OgIkWlMbl8tQ6JNto+TsAm9YSgTbQl4JmYRVTczfGIBTeWkOPlOPhd6/M52wClYrO0X21TRK3AcGwh1CVGQKI1nndBvidcmbsBLxcQ2aC49ZTh1hvfsLR0lt0d6fcrCQquRTORt+kITb7ZaAATqnEg9yq7n79uGqLaxZY1Dm3VB/OlwHs/o3XbtifgMNvnZIESBEsyLKYnBhYMTxRCE85EOfjcGx04837D/6v1d7pg8UFL0FUizLGCDcicR/d22J7DG+1qKRrR/StINYkE5jxxnm/bnnffiGoiehLRThZVhvSpywa8gCsZuFXthnKg0NSWT5deBmCT0ww3Jf/e1nmk4oi6oIOvMiApGS5xAglU8CK3wSwR0m/Up/Tm9v46vCB5cZMn7T3uUgOyN/kLTP5hi5+FCiBZklbaRj8cajzkX517PsXihe49vBznEKoxB1Y8d+HNhjkR+UTYxDMdVzkdIXbBZRqBlhqcDqECYOR7HpqAdIPbe9DaYxviIY8JS9k7On3oid4MHTD6fnCEH3KqOOTUxWcwjL7nPjjloC63D8F2o7Pdo8HuMFBAR6bQIXfDMV6F3I9c+2gANpXPdMFATWwVub+HrJK9aRzsGpi+XDzzomgTOkUbjQwMJ7e9QPytRd/I0LiWE4l2iotoKiApiBk0XJjDsS66ra1LjcoYzCxolGySG9+QdoLOhGtdgBr8WIFniNOsNG10knsR7atYGMYmiSLkSw2F3Fmm6FYlnYkKXP4ceq6cU849/X6tH7T6fBC9DgIwcm3KyGdXP8Z7TdTwvQcE8cKUQXQtTikAAn3QszAqORURh/5tOqaBboYCPunHMTDPE3YYvl0LH1fg7e2ED8f/+88/4//6v/8f/Iffv+PtPPDFJr58/QNQwPX4o5p3mR+ADXuZ4dFC96ItO0HMgI+J8zgwzWGj8HEtrOsDD1yweepMVTlY2LqOwwfcpvLFEh8fgUsavXNOwDiZfCZQs5QN8Vo/avWujezp3CCwktxHRP9lEuQ3UG4VyAgsM9EBS+nkicTCEkhYZTpvdI4WLcGp40x0ipOZqzwgqI54shkPYC0GKdPcpo2NbpdEuq4aFll/oi46G3fRy6MajBX1UNpYhoEO7TNe+K2BIRUQQHKqUZnA9VBFE3BbMH8C+QHkojFKe8em0xHLJ9oA6t9bf58LVv8DIsdWxZAeU1hL/z1rT3gJfgGO+gGmLSZLpGMOHPPEMW5qAaDvITHlFparsakWbfeBBXaWY/B1ZLFYTPIINsUkAVjWdoupzw5bBvGENSqW/VnGwnMtzHEA4Ad9zCFLMjYNK1MTDwhcLHl/lzjQN5f7EA/fPk1YXJuTHenL5/t7l+1/d2NBC12TC8UehWGo6L4nUVkBmDyuJdRCystegt+YB6l+psMCtQXCqQaYSeKTbihNpdHrMk3TNl1Bvx6Z9AOv1Mi1KHgH8OdTMqh5mtOAYPFFNHqIETbgdsqVg0BBoUMRXYi3kBOAVK5uPtCp2jyaXY4x23bbaDJhlbiWHsEXkvzdq9/Gbj4SxskssMMHu2gunVlZalAEyVlh5330hWhOg487O0bT6+TFl5qYlPZcf97MX7gbcKtErsJ1XSwwzbezVBknLbUWLhuwII2RuhAT5ebeyxm5tU79azx7fRd353Hgy/sXfHk7KXSvhbi+Ybjp+6cmJonnCqS/4dB5GwXEKvgAxiC10GSpyZdy6wZe67evX75/qYaDBUhqyuG1Go/UfgtUXPDtTlnYSWVO2/q2/gwAj+sDfhw45qnvmfjydmzw5u2Ycl8jWg2kAMuuBSasDGdySjwH6drneeJ//i//K2J9APmEi3b69v47THccx4F/+dMHAFqYQ1P0qECAzoleBUgXwneAAvMGvbwC//bHf8XXP/wnOioZZLzAczOSTc15nMgVNO85B/7ppy87KDQykQrYHJ91YK/1m9bnc7aAHdaXVagVKC8xelQlqPycg1qcITvcSFJTcQGB2udWQWBdFh4rdjhwpMGL1UaUIQTyhLI73B0BxyGRudUFiB5egGiBDQzmnkCP4VhZuKIkSCeAeNbkuV6kbYXYRdMKsZ6Msig6sNqk0Q2qJ5gBK9LBHe0Ka7BcmLU0sUxUPpC24HbBiq6gBNMVfYEJzDf8paHd3+yCBXHc8Mmas4Ctr+hJhRl2QBtXiNuuN2YAYbEnDW0v1kUgkdVAU2FKv96XpbkBV4sJNcoSonwOIict4iJyxu/Dn4OitKiUxem4aWIqrGixVjelQI3RMKdXuZ/wMbZfOJuOROTNhM8u1lAoieHp5sF/DiGRrOdoc9mipNel+H3r855tu11OFPpRhuhP2BOqFvyNbYknZyADbA54looY0vfiIO0O4vgSIxt4pvzBn08MHzi+vPNirMIoFvRWt25i52ysC49IPgvuyjfoQlHNUeamOVDXAl7gNhAOijehMbINmBLOTRxOCu9lmZuJtQJVT9EeAJvUpBg6LNT3FLJpNwAkpOcBuANFX+u715/v26ZsTPks+5hsqwv7fKM9qNrbz0YBzn15qJk+BilaQ+iWZ+Faa9P3enI25ux5HZCFqP78+fuh7z+OA8OJFEaGAg+l5XDO7s0c53GqSeGZiCJgQ1qr4/3LVyY7V8B9YpajbAF14OvXL3g/33EMR8QT8fwZuX6G10Lm2JP4j4vi4EM2mGbNjybVhsZ1mgmaHGMqZCj0gnu+Z/1yz/Iuc2ehZcVwV07dyDQgHSvg6PudjprUk02UHww0sx6W0fbe3w4cU5O3ccDHwNsb64pjUn/Ji3ih4BjjwPtwCdZ1kmqKu9ZSsrTj7e0d/v6Gx7c/Mk9k8q4/zzfMOfH7rwPfHo+dYcKfZQLPJbc3ucW1lk82/SXRMAw4jrctGO7bxiU8PmCcgLghPx4Yc+Lr2xvezwOHit2swlqJ8zCdx6/1Pav2v8DpgYIn3Uw5RrbBYahO8KHiXc0EVFtmFcLkoKW7+BiDYHgFKul0lX8GIN5MAtv0164Fe7LsKqGHu5pRBWw6BMIHAoEhO3XkE3AjDVuuf1tA3myKAgrMejIn+B3WTVaA1nCURUzd6ySXc/rhlTikP4FBboukLMI6CoP/rCykfWD4GzCOX/08/mYK1kaqdJEwQdG28xUbAcrLN6rMTxGSrGI4RYktgoQKMRQRXBjH6RFJRK+5apWby8/nvfDx+IDb+24C4M1153hd+i4ePkIKC75f1eigKuWA9Ovnh5X3FASF0+kA4/a2x/Z8LSoAg1Z5iqvB6Sws+/0y+7SBG13W12nRezefr3rux607ZNJ2E3snIHOfdkFnPmghCaAfI9pMT6x1oZmQhZKzGg8PGeTCbGL6QEbBfcEHKS4DQqVN2iIhd8B+lJARGpvKp95EncmgmxCwA38Y4kVRcgIYRS5/PhPPLJgTfZxee/83JQtq+Oc8YCvoCFepyZyjxfv5qekHCqvIk33TBa1JLc55/53X+nEr1DC6Kxm5QArfnoRwTx3HlEvgPSfOkHPKGJi6jNpFhyCOnK3UxHhT+8zYCIhiVY5tDw41DAAABw4FT04UJhLLgTXb7IMZM8dxYowpLUt2W0NL36IL3DxOXPVAliHcica1DlC6lix67VeEgjUJ6uSgkcM8Tsx5oC0sOxBvzkmQQdMPawoWDCHxZeelvNaPWqJvSjBLjRvfc2gf0+Fg7kyE1N5On4BNqUGAVYnnWrv4KxVSAJvcw6S5/IRmP66FN2exP8ZEpkkLFaLJAB/5wDEn3s5Tr9Hxfkx8fPuXT1NCkO7nUGAc7wo+SwNX3Q5zPaHkVO8C7YZJUTnfThw4EcXgzKpb25XQazMWKm7G8DknrWx8EpuPMfALDeNr/ZCVSapql5CcLqsJwGdWjBqFYFPZ8RNAi9f5a8Plujd6cvBJ5VEEKTsPR8Q+gnkBFv5ucBuklQraLAFKc54C/gspfdRKhyenwNcqjIPSg2Yk3fboY9cggvLxftCB7vLBifJ6IktTOPiuB7qu5YT8gjk28MVUG05MUHSaE2+EtUNdKKhB+ZX11ylYdrtcUCTTrlekPmUCaRqxG7bQsBPI3djF96TDzVASbcendpSME37N+1ebMEDP7AL9otwZBjdjCcHVBWoDLSTqeYJBSav62LnRfKPNe/qi19D/sBHN/fXcTN77PU3hO0SHrLnf9FRz5kZERLi3UA+5JtTdaLB41Zf8PDh6rd+0Pu/Zzl5pp4cyisgKhgVTcecbHQAGGCSkT92JOsNvaoGPg9kCSKzgjmRPMTEw8Cb3IR8KD3LTQ8sLptNumXrPjvo8z70XOeFguTaM+733G5GH3CnV7axiGZu+GOL1twiX+6obXvvED21HGdy6j96T1SUjNjf7dMM52LANN5TXfr9biPxav3193rduhmMOjGth6dL4bJPo4CWHksNbYSc5x7aPZgE4xlATK45yxi6EmhpATVIhc2BqUsiQQQX6xaVrC2hXNBfa3aJvJJFo8puTDcDghWxyJYwtqje0OQfccV1s1K/kc/d1TjCzCVgrcIUMH+xEGsXmXsbwzLdTr62fnZ5ocj9vdVdB029SJiKY//Nav339sj7wDe5UKRDSC0hT0bWQ5bzHK/gZ2YSbY9mJrAMDhmulEOhCmuPrl99hzoFVMl+o2nx2mgpwurbWwmMl5tuJYWxmzIGKRKw7J8SMWTLe+w+ktvh8R4FAYmThsEBhYIyTwKV1uKDCEsdBR6EqxPUUTz4YQudGatYUOBl92rZdP4EFht060uXg5QPun8oL3OdzRBvUvA7b71mmfzXwOLatscJcM0RP1V42VYdZ+86eAq9RJrt+fq7DaUCTMmQqf9PXIoWu5AhYcE3tcLN4cDcpMDbge2JswDn5uoPDbqw0fFykvq5kM3KmbXCffa2h5AZYYjGwmuXzAQR8nEgsmMK7hw/qqV2sJk9c2nejwGfZBYvWhNlDABU2m6IATBAUambUr62/mYLFYmRsjnFb1br+SG5qyT0tua4LQ2jEUKMwR5uOgYqZothrfCqS5rD9sDetgG4sgTK5XcyDrwdC7OAS8dZ2iemfgUV+F5mlN0TJwag9bmLjUdtBBmhRL9fwTXi4GcSNbuh/+6dmq+1Tu/XJSjrQNJBpAIXO/A792l/rt6/PI05+zBKCu9zWfIqH3sFQRR1Occ+mkAiYi87nsEzSmawwtSeLCT3a95+MEszwfgzYmDvhXC25Cr172tWfPWlXfPX1ad8RdU74Br7ZmOQnvjWD4GKjizurB7anb3SaY4HqkFAuUyI5PjsBIoo0vhjotrzDtpYDs7Cf9/0e76nna33PKqiJQF+MvNAsqF26NJ3zoSmuEBOKBDk5GO6YoxNoWbgUgMjgFEE6j7fzpMuVvlfjQG6yANbhRLtFfv3IBQj8MRl8ZNYnqo3yknxQiOvjzjeSVgRF1BHoJpc7+nld++c4z4N8ZYBWj11kwgCfwJCmzgfmQcpOcbSC1ISP3ycQKMCCyJ01GjkEMiXqLyT0vtZfX5/PWqDQLFdrsM0b3NE+cHaB5QZgAmOgnCJdH7IWjwte1O68n1P3vGGtS/oKos5NAwckas/CPE4kbnvyFJLr0l4CotcYQaGmt27zBnNq6jKw6oJPFZJoQwVD55rZGLQZjYXHupgHhYQfCl6s1FRkoQK4np/jACCNDIAq2VQDiMTMglvCk8/fY8WeIj5W4OX38eOWWVOase/EtchjabCZdzQQVpu9kn1gZm70LTXNg4D1zJv5wvqdAZviovIs9/GLLLCmdPHmXVjXU+HEhevxwNt5YsyT5hzg372Sc4iriK6MKapVFV27zJECKiMTXpwIX0EDpVR2iQ/nnlMT1QZSpbqgfKhuZRHgom/QENcwjgM+psoO2gtzkkLe0a+tv90Fy+6HtDafXlMPrUo6PS0rJX92k8KJiLdPuxoV1+GRQpY7vXfF2h98lThrBhZcETysRJ/qoq3QWgygvJ2tFFhkxrZRNmjXtfZkxjW1abcZWGlk6hh2bLF5dLFouzfmnyc/Qim//ZGxKIVQuT4oKxPRG9hY7a313IWruQO7I3+t714qxJnwXfuggRA0YOjg4HyMhgIgsmEUoqNIGZnbHUoFEFKZNs3LbV2SYx5TxZja8QqJ0wG3TiXlvhodOqJLDoAEi8qA6PwEAB2smHEBvSdbPIwhX3L+udaI0IyB/zvWQoKBSM+VQnEKV1wYRwIybxiDz0y7vFzkIlK79O/40L8wuR+92kBB/6e0cRZ0/P1U0JkVz9BOAO/5R8nVaozBBua6kGsxlXkMpPbKtpvUXpsNIZWqolyoeHLUnnRywWgr3mDziy7uVZI2XVDoIC/fxWG9QB4YC7Tnim2/+lgL+XgSUMrEOQ860RBeok7AFoGBecDGSStelBpnl/CSoWAB0n7NJ1CLk/AKavw2IPVaP2IZujgfyFhIBOuEaBIogKCpwW3IaxgQC8HAxiQWz+cSl10atnVd+iqGay34ObGzX8BpWcHIPY9E5YU5D1n+Jlxp0A0y0sCBWr8Q5cXM4QNKKqezUP9MrAHYHERhm5OsdaHigg2xJFwAqmqPkgFDrCfKB67sPJ+BSjkfBk0frhV4XgvTgPee7Kl+WaqtbLzqgx+5erIcEYh10X4ZBvPkmRM8M2AAxhRwSVAHsVQuiF5aADXPZBoUaBZDLP1CRcnemROxASCtdoNOLQhzP64ViEXLaTdgmiPVHHmdOuUJuD9X4Hk9cbnjOEgRp8thwY319ZIDXWShYvHnmo5KNrVuQxiB4Uqey62tilLWlABb/rykZFURmNKjqbtAk2UrZF4Y8wdQsIANuvHNVqfeoyzTAwoYPMRj1sMbZcAKdXeN7nUJ3wWcJiDq0KIt+yoxVKj5MVE9isxL5hnWowREJGJPTvgaxh7J1+4MVwTpB4TO7sAUdXcUlQ2KF3dxSNEmTNQa7l5edsax1nA6EvDyTcDbChjI8l/kUZDiAxzHwdde98PwWr99/aI8LsgtjQ9XZcBwczAboK1PtIAO4eumhUE8xoAhY0AQoJAh5Q60WwmpVs1B5guIpD82YFhhnyYbLeA25tmAQUBAc0+hC+hGaV2qjqpkCrZN7UE6FJEWwzt/C5NB4BGasGQl4gqsSBzzwDGnkL3aGEM32QR6WOxekTjdMObYTiA9yXut71991vbZlZlsGFXgjx4moGQ+cO/b0BQMZbhSZ2gllg1SoaTfaA3StZamH9gWkqUJ80gaccQKhXAGLAPDElmBeAae8WDxVzcSVgB1GqPoEz8mVnWwYGGVpmk+eB4XhfAwWkJ3UnDGhevJlHMgcYy5QSuGt4n+4JPNdU/9xM938HvtRg0AkEyzRsoGk3dI2fpHf8z/TS0eKb9EgHWl0r4+mX7OU7X2RK10fkI1BKyzxS5A+808UDEQQWvy9Xwim99ehetZCBPsIyt9WtsmsNbWg27+fjfwOnt5/oqLYQ74sSfLsAOwQGBg2FQTUqi6aDltUwBNwmrhmIZhRQtq5/OTCoKtNGRyiuwZmBhKuHYcY8LGkB6EE5ZrMRX+Dz+xNHuuhWuxgJu+T+XX+p6lt5C1bCFjqTZgqG+CDmfWGUaVezodVwHhyoBRCHCxkcgiE4F6HkHRfT5WJ46bdHgCzKvgzjp6fWpA1nrSUtro1zcBoBJxPfG8Lk49iLrguhaua3Fa6IkcuXUasQKWvuljQ/qQFZzeuINgjtt9j8T6RCXjnoTyejhg5l2A1PnZVN7hKAE9rHUvVDlw/elXP4q/mYJVXSA3OldyD0C7TZFadasvZNfZHLdqQXjqa7eL1j1R6EJtmLoo4w/enHy3AhMKeaG2gLIAuCWyhLyV0quLHGB0l6sf6u04MNzolb+Illj76MLxNiWENIaTZraDh3j5JqBcnd80o92j3K3uFG5d0MAu2IboXo36AOJ967KsetECvmfV/tfdMMMG6RZFdIuIK90e2E40egu5k809PWF/27Sl+/uYDTDgvC0kGwFzmBfahhTFS5juFHxVnJABPT3poJ5GHMx6skZ3oTnm/oFmLti83Y+oaRmYxULVLfW8EBjokSsAHIPe5fxZA6dPTOf7Q4cNOsdYI9kQXTACA5qA9OhVz3z/udf6vvX5rIUmABkLyMJAwUcDNdyLVtkMPTYnVQzxS5I8xhg8f7XH5qAY3XR2r+uh81ekc4ZpIOCoIOBilXAHhrPRQS1YLeQqRNE2cjodqbhNEhlPwBZsdINwh6f15Nv0fe//XZomMjPkyzHUaAWpjjAJK6cE9aQJ0LWFk48NloGAww7vNOAi1oi05LMJ6QLj1YB8z/r81LdTXwpwoRVnO7Qx76C7Ew5UjQ0rSFu2kfByWHzjZRmTlDvI0c1pgctDVM592t+1D/2894sa3J6umShhAEjB0j28s0kAGhxEwtLhdqI1hO4TruDDdGNhWE9UiNLipIyZAy7zj3YMHW6YXjtSgLSbCRsnaVxwOcPNfaYeTstXFIHXZcCXY5L7H6/64HtWffr3PekNuDEmQRgQ1NJuTc/UOWmxgJKlrjV0jtviX9R72kDnrdspAOawcWA0aC+nzSxTDlOgadnVFurm6CyPftnPtXAls27G4DMyxrFdVvvcZ0g2jW08m2FR1OYVmwSfk7pt/Zysg6kbDL0/OQa2DX9diLzQRhOAwZw5Y88AGG8gmiIckQ/U9evnrL0Q99d6rdd6rdd6rdd6rdd6rdf6R60XofC1Xuu1Xuu1Xuu1Xuu1Xuu1/mHr1YC81mu91mu91mu91mu91mu91j9svRqQ13qt13qt13qt13qt13qt1/qHrVcD8lqv9Vqv9Vqv9Vqv9Vqv9Vr/sPVqQF7rtV7rtV7rtV7rtV7rtV7rH7ZeDchrvdZrvdZrvdZrvdZrvdZr/cPW/wfGsI+AL3arNQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.random.normal(size = (10,200))\n", + "reconstruct = dec.predict(x)\n", + "\n", + "fig = plt.figure(figsize=(15, 10))\n", + "fig.subplots_adjust(hspace=0.2, wspace=0.2)\n", + "\n", + "for i in range(10):\n", + " ax = fig.add_subplot(5, 5, i+1)\n", + " ax.axis('off')\n", + " pred = reconstruct[i, :, :, :] * 255\n", + " pred = np.array(pred) \n", + " pred = pred.astype(np.uint8)\n", + " ax.imshow(pred)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Tuts", + "language": "python", + "name": "tuts" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Autoencoder-in-TensorFlow/Autoencoder_FashionMnist_TensorFlow.ipynb b/Autoencoder-in-TensorFlow/Autoencoder_FashionMnist_TensorFlow.ipynb new file mode 100644 index 000000000..0c6ae492b --- /dev/null +++ b/Autoencoder-in-TensorFlow/Autoencoder_FashionMnist_TensorFlow.ipynb @@ -0,0 +1,664 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import imageio\n", + "import glob\n", + "import os\n", + "import time\n", + "import cv2\n", + "import tensorflow as tf\n", + "from tensorflow.keras import layers\n", + "from IPython import display\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "%matplotlib inline\n", + "from tensorflow import keras" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "os.environ['CUDA_VISIBLE_DEVICES'] = '0'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 128" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.fashion_mnist.load_data()\n", + "x_train = x_train.reshape(x_train.shape[0], 28, 28, 1).astype('float32')\n", + "x_test = x_test.astype('float32')\n", + "x_test = x_test / 255.\n", + "# Batch and shuffle the data\n", + "train_dataset = tf.data.Dataset.from_tensor_slices(x_train).\\\n", + "shuffle(60000).batch(128)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 10))\n", + "for images in train_dataset.take(1):\n", + " for i in range(9):\n", + " ax = plt.subplot(3, 3, i + 1)\n", + " plt.imshow(images[i,:,:,0].numpy().astype(\"uint8\"), cmap='gray')\n", + " plt.axis(\"off\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "normalization_layer = layers.experimental.preprocessing.Rescaling(scale= 1./255)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "normalized_ds = train_dataset.map(lambda x: normalization_layer(x))\n", + "image_batch = next(iter(normalized_ds))\n", + "first_image = image_batch[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0 1.0\n" + ] + } + ], + "source": [ + "print(np.min(first_image), np.max(first_image)) " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "input_encoder = (28, 28, 1)\n", + "input_decoder = (2,)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def encoder(input_encoder):\n", + " \n", + " inputs = keras.Input(shape=input_encoder, name='input_layer')\n", + " x = layers.Conv2D(32, kernel_size=3, strides= 1, padding='same', name='conv_1')(inputs)\n", + " x = layers.BatchNormalization(name='bn_1')(x)\n", + " x = layers.LeakyReLU(name='lrelu_1')(x)\n", + " #x = layers.Dropout(rate = 0.25)(x)\n", + " \n", + " x = layers.Conv2D(64, kernel_size=3, strides= 2, padding='same', name='conv_2')(x)\n", + " x = layers.BatchNormalization(name='bn_2')(x)\n", + " x = layers.LeakyReLU(name='lrelu_2')(x)\n", + " #x = layers.Dropout(rate = 0.25)(x)\n", + " \n", + " x = layers.Conv2D(64, 3, 2, padding='same', name='conv_3')(x)\n", + " x = layers.BatchNormalization(name='bn_3')(x)\n", + " x = layers.LeakyReLU(name='lrelu_3')(x)\n", + " #x = layers.Dropout(rate = 0.25)(x)\n", + "\n", + " x = layers.Conv2D(64, 3, 1, padding='same', name='conv_4')(x)\n", + " x = layers.BatchNormalization(name='bn_4')(x)\n", + " x = layers.LeakyReLU(name='lrelu_4')(x)\n", + " #x = layers.Dropout(rate = 0.25)(x)\n", + " \n", + " flatten = layers.Flatten()(x)\n", + " bottleneck = layers.Dense(2, name='dense_1')(flatten)\n", + " model = tf.keras.Model(inputs, bottleneck, name=\"Encoder\")\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "enc = encoder(input_encoder)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "#enc.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def decoder(input_decoder):\n", + " \n", + " inputs = keras.Input(shape=input_decoder, name='input_layer')\n", + " x = layers.Dense(3136, name='dense_1')(inputs)\n", + " #x = tf.reshape(x, [-1, 7, 7, 64], name='Reshape_Layer')\n", + " x = layers.Reshape((7,7,64), name='Reshape_Layer')(x)\n", + " x = layers.Conv2DTranspose(64, 3, strides= 1, padding='same',name='conv_transpose_1')(x)\n", + " x = layers.BatchNormalization(name='bn_1')(x)\n", + " x = layers.LeakyReLU(name='lrelu_1')(x)\n", + " #x = layers.Dropout(rate = 0.25)(x)\n", + " \n", + " x = layers.Conv2DTranspose(64, 3, strides= 2, padding='same', name='conv_transpose_2')(x)\n", + " x = layers.BatchNormalization(name='bn_2')(x)\n", + " x = layers.LeakyReLU(name='lrelu_2')(x)\n", + " #x = layers.Dropout(rate = 0.25)(x)\n", + " \n", + " x = layers.Conv2DTranspose(32, 3, 2, padding='same', name='conv_transpose_3')(x)\n", + " x = layers.BatchNormalization(name='bn_3')(x)\n", + " x = layers.LeakyReLU(name='lrelu_3')(x)\n", + " #x = layers.Dropout(rate = 0.25)(x)\n", + " \n", + " outputs = layers.Conv2DTranspose(1, 3, 1,padding='same', activation='sigmoid', name='conv_transpose_4')(x)\n", + " model = tf.keras.Model(inputs, outputs, name=\"Decoder\")\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "dec = decoder(input_decoder)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"Decoder\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "input_layer (InputLayer) [(None, 2)] 0 \n", + "_________________________________________________________________\n", + "dense_1 (Dense) (None, 3136) 9408 \n", + "_________________________________________________________________\n", + "Reshape_Layer (Reshape) (None, 7, 7, 64) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_1 (Conv2DTran (None, 7, 7, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_1 (BatchNormalization) (None, 7, 7, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_1 (LeakyReLU) (None, 7, 7, 64) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_2 (Conv2DTran (None, 14, 14, 64) 36928 \n", + "_________________________________________________________________\n", + "bn_2 (BatchNormalization) (None, 14, 14, 64) 256 \n", + "_________________________________________________________________\n", + "lrelu_2 (LeakyReLU) (None, 14, 14, 64) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_3 (Conv2DTran (None, 28, 28, 32) 18464 \n", + "_________________________________________________________________\n", + "bn_3 (BatchNormalization) (None, 28, 28, 32) 128 \n", + "_________________________________________________________________\n", + "lrelu_3 (LeakyReLU) (None, 28, 28, 32) 0 \n", + "_________________________________________________________________\n", + "conv_transpose_4 (Conv2DTran (None, 28, 28, 1) 289 \n", + "=================================================================\n", + "Total params: 102,657\n", + "Trainable params: 102,337\n", + "Non-trainable params: 320\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "dec.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# dec.save('ae-dec-fashion.h5')\n", + "# enc.save('ae-enc-fashion.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "#dec.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "#model.layers[1].get_weights()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "#model.save('autoencoder.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "optimizer = tf.keras.optimizers.Adam(lr = 0.0005)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "from tensorflow.keras import backend as K" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def ae_loss(y_true, y_pred):\n", + " loss = K.mean(K.square(y_true - y_pred), axis = [1,2,3])\n", + " return loss" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# Notice the use of `tf.function`\n", + "# This annotation causes the function to be \"compiled\".\n", + "@tf.function\n", + "def train_step(images):\n", + "\n", + " with tf.GradientTape() as encoder, tf.GradientTape() as decoder:\n", + " \n", + " latent = enc(images, training=True)\n", + " generated_images = dec(latent, training=True)\n", + " loss = ae_loss(images, generated_images)\n", + " \n", + " gradients_of_enc = encoder.gradient(loss, enc.trainable_variables)\n", + " gradients_of_dec = decoder.gradient(loss, dec.trainable_variables)\n", + " \n", + " \n", + " optimizer.apply_gradients(zip(gradients_of_enc, enc.trainable_variables))\n", + " optimizer.apply_gradients(zip(gradients_of_dec, dec.trainable_variables))\n", + " return loss" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def train(dataset, epochs):\n", + " for epoch in range(epochs):\n", + " start = time.time()\n", + " i = 0\n", + " loss_ = []\n", + " for image_batch in dataset:\n", + " i += 1\n", + " loss = train_step(image_batch)\n", + " #loss_.append(loss)\n", + "\n", + " #print(\"Loss\",np.mean(loss_)) \n", + " seed = image_batch[:25]\n", + " display.clear_output(wait=True)\n", + " generate_and_save_images([enc,dec],\n", + " epoch + 1,\n", + " seed)\n", + " # Save the model every 15 epochs\n", + " #if (epoch + 1) % 15 == 0:\n", + " #checkpoint.save(file_prefix = checkpoint_prefix)\n", + " enc.save_weights('tf_ae/fashion/training_weights/enc_'+ str(epoch)+'.h5')\n", + " dec.save_weights('tf_ae/fashion/training_weights/dec_'+ str(epoch)+'.h5')\n", + " print ('Time for epoch {} is {} sec'.format(epoch + 1, time.time()-start))\n", + "\n", + " # Generate after the final epoch\n", + " display.clear_output(wait=True)\n", + " generate_and_save_images([enc,dec],\n", + " epochs,\n", + " seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_and_save_images(model, epoch, test_input):\n", + " # Notice `training` is set to False.\n", + " # This is so all layers run in inference mode (batchnorm).\n", + " latent = enc(test_input, training=False)\n", + " predictions = dec(latent, training=False)\n", + " print(predictions.shape)\n", + " fig = plt.figure(figsize=(4,4))\n", + "\n", + " for i in range(predictions.shape[0]):\n", + " plt.subplot(5, 5, i+1)\n", + " plt.imshow(predictions[i, :, :, 0] * 255, cmap='gray')\n", + " plt.axis('off')\n", + "\n", + " plt.savefig('tf_ae/fashion/images/image_at_epoch_{:d}.png'.format(epoch))\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(25, 28, 28, 1)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "train(normalized_ds, 40)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "enc.load_weights('../tf_ae/fashion/training_weights/enc_39.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "dec.load_weights('../tf_ae/fashion/training_weights/dec_39.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "embeddings = None\n", + "for i in normalized_ds:\n", + " embed = encoder_model.predict(i)\n", + " if embeddings is None:\n", + " embeddings = embed\n", + " else:\n", + " embeddings = np.concatenate((embeddings, embed))\n", + " if embeddings.shape[0] > 5000:\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n_to_show = 5000\n", + "figsize = 10\n", + "\n", + "index = np.random.choice(range(len(x_test)), n_to_show)\n", + "example_images = x_test[index]\n", + "\n", + "embeddings = enc.predict(example_images)\n", + "\n", + "\n", + "plt.figure(figsize=(figsize, figsize))\n", + "plt.scatter(embeddings[:, 0] , embeddings[:, 1], alpha=0.5, s=2)\n", + "plt.xlabel(\"Dimension-1\", size=20)\n", + "plt.ylabel(\"Dimension-2\", size=20)\n", + "plt.xticks(size=20)\n", + "plt.yticks(size=20)\n", + "plt.title(\"Projection of 2D Latent-Space (Fashion-MNIST)\", size=20)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "min_x = min(embeddings[:, 0])\n", + "max_x = max(embeddings[:, 0])\n", + "min_y = min(embeddings[:, 1])\n", + "max_y = max(embeddings[:, 1])" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# Create dictionary of target classes\n", + "label_dict = {\n", + " 0: 'T-shirt/top',\n", + " 1: 'Trouser',\n", + " 2: 'Pullover',\n", + " 3: 'Dress',\n", + " 4: 'Coat',\n", + " 5: 'Sandal',\n", + " 6: 'Shirt',\n", + " 7: 'Sneaker',\n", + " 8: 'Bag',\n", + " 9: 'Ankle boot',\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "figsize = 15\n", + "\n", + "latent = enc.predict(x_test[:25])\n", + "reconst = dec.predict(latent)\n", + "\n", + "fig = plt.figure(figsize=(figsize, 10))\n", + "#fig.subplots_adjust(wspace=-0.021)\n", + "\n", + "for i in range(25):\n", + " ax = fig.add_subplot(5, 5, i+1)\n", + " ax.axis('off')\n", + " plt.text(0.5, -0.15, str(label_dict[y_test[i]]), fontsize=15, ha='center', transform=ax.transAxes)\n", + " #plt.subplots_adjust(wspace=None, hspace=None)\n", + " plt.imshow(reconst[i, :,:,0]*255, cmap = 'gray')\n", + "plt.show() " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reconstructing Fashion Images with Latent-Vector Sampled Uniformly" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "min_x = min(embeddings[:, 0])\n", + "max_x = max(embeddings[:, 0])\n", + "min_y = min(embeddings[:, 1])\n", + "max_y = max(embeddings[:, 1])\n", + "\n", + "x = np.random.uniform(low=min_x,high=max_x, size = (10,1))\n", + "y = np.random.uniform(low=min_y,high=max_y, size = (10,1))\n", + "bottleneck = np.concatenate((x, y), axis=1)\n", + "reconst = dec.predict(bottleneck)\n", + "\n", + "fig = plt.figure(figsize=(15, 10))\n", + "\n", + "for i in range(10):\n", + " ax = fig.add_subplot(5, 5, i+1)\n", + " ax.axis('off')\n", + " ax.text(0.5, -0.15, str(np.round(bottleneck[i],1)), fontsize=10, ha='center', transform=ax.transAxes)\n", + " \n", + " ax.imshow(reconst[i, :,:,0]*255, cmap = 'gray')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Tuts", + "language": "python", + "name": "tuts" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}