diff --git a/TD2 Deep Learning - model1.ipynb b/TD2 Deep Learning - model1.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..1e4eb9d9c6fb29b0c7100a599b2df459846ff0f9
--- /dev/null
+++ b/TD2 Deep Learning - model1.ipynb
@@ -0,0 +1,1248 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "7edf7168",
+ "metadata": {},
+ "source": [
+ "# TD2: Deep learning"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fbb8c8df",
+ "metadata": {},
+ "source": [
+ "In this TD, you must modify this notebook to answer the questions. To do this,\n",
+ "\n",
+ "1. Fork this repository\n",
+ "2. Clone your forked repository on your local computer\n",
+ "3. Answer the questions\n",
+ "4. Commit and push regularly\n",
+ "\n",
+ "The last commit is due on Sunday, December 1, 11:59 PM. Later commits will not be taken into account."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3d167a29",
+ "metadata": {},
+ "source": [
+ "Install and test PyTorch from https://pytorch.org/get-started/locally."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "330a42f5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#%pip install torch torchvision"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0882a636",
+ "metadata": {},
+ "source": [
+ "\n",
+ "To test run the following code"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "b1950f0a",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[-0.4165, 0.7959, -2.6496, -0.5867, -1.1638, 0.7261, -1.5494, 1.3172,\n",
+ " -1.1476, 0.5233],\n",
+ " [-0.2842, -1.3210, 0.9482, -1.6569, 0.0971, 0.8307, -0.4953, -1.5192,\n",
+ " 0.1170, -0.0036],\n",
+ " [-0.5698, 1.5647, 0.2267, 1.3669, 1.5906, 1.9830, -0.5329, 2.1946,\n",
+ " 0.9815, -1.3213],\n",
+ " [ 0.4260, -0.2465, -0.7108, 2.0587, -1.4107, -1.0849, -0.7285, 0.5219,\n",
+ " -1.6536, -0.0689],\n",
+ " [ 0.5114, 0.5851, 0.5771, -0.1976, -0.9273, -0.7261, 0.7161, -1.4409,\n",
+ " -0.2859, -1.4682],\n",
+ " [ 1.3776, 1.1774, 0.8684, 0.3978, -0.3660, 1.9135, 1.2305, -1.2047,\n",
+ " -0.2161, 1.2392],\n",
+ " [-0.8799, -1.7426, 0.6338, 1.0270, 1.4100, -0.7628, -0.2303, -1.1312,\n",
+ " -0.4831, -0.0500],\n",
+ " [ 0.9048, 0.6972, 0.6606, -1.3414, -0.1110, -0.5426, 1.4192, -1.5286,\n",
+ " -0.9479, 0.0097],\n",
+ " [-0.8648, -0.7923, 0.9723, 1.0398, -0.0397, -0.5886, 0.9265, -0.7319,\n",
+ " 0.6881, 1.3283],\n",
+ " [-1.7256, -0.0638, 1.0231, 0.0600, -0.1732, 0.9642, -0.5281, 1.3056,\n",
+ " 0.4035, 0.9480],\n",
+ " [-0.0728, -1.0162, -1.5728, 0.5050, -0.0502, -0.2284, 1.6427, 0.1790,\n",
+ " -1.1792, -0.7706],\n",
+ " [ 0.1724, 0.5413, -0.0288, -1.9327, -0.3631, 1.7576, 1.5397, 0.1154,\n",
+ " -1.0803, 0.3552],\n",
+ " [ 0.3824, -1.1323, 1.2554, 0.2262, 1.6234, -0.8118, 1.2303, 0.9163,\n",
+ " 0.1164, 0.4109],\n",
+ " [ 0.0937, 0.7837, -0.1750, 0.4796, -1.6326, -0.9668, 0.3897, -0.6633,\n",
+ " -0.2551, -0.9209]])\n",
+ "AlexNet(\n",
+ " (features): Sequential(\n",
+ " (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))\n",
+ " (1): ReLU(inplace=True)\n",
+ " (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
+ " (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
+ " (4): ReLU(inplace=True)\n",
+ " (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
+ " (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+ " (7): ReLU(inplace=True)\n",
+ " (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+ " (9): ReLU(inplace=True)\n",
+ " (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+ " (11): ReLU(inplace=True)\n",
+ " (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
+ " )\n",
+ " (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))\n",
+ " (classifier): Sequential(\n",
+ " (0): Dropout(p=0.5, inplace=False)\n",
+ " (1): Linear(in_features=9216, out_features=4096, bias=True)\n",
+ " (2): ReLU(inplace=True)\n",
+ " (3): Dropout(p=0.5, inplace=False)\n",
+ " (4): Linear(in_features=4096, out_features=4096, bias=True)\n",
+ " (5): ReLU(inplace=True)\n",
+ " (6): Linear(in_features=4096, out_features=1000, bias=True)\n",
+ " )\n",
+ ")\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch\n",
+ "\n",
+ "N, D = 14, 10\n",
+ "x = torch.randn(N, D).type(torch.FloatTensor)\n",
+ "print(x)\n",
+ "\n",
+ "from torchvision import models\n",
+ "\n",
+ "alexnet = models.alexnet()\n",
+ "print(alexnet)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "23f266da",
+ "metadata": {},
+ "source": [
+ "## Exercise 1: CNN on CIFAR10\n",
+ "\n",
+ "The goal is to apply a Convolutional Neural Net (CNN) model on the CIFAR10 image dataset and test the accuracy of the model on the basis of image classification. Compare the Accuracy VS the neural network implemented during TD1.\n",
+ "\n",
+ "Have a look at the following documentation to be familiar with PyTorch.\n",
+ "\n",
+ "https://pytorch.org/tutorials/beginner/pytorch_with_examples.html\n",
+ "\n",
+ "https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4ba1c82d",
+ "metadata": {},
+ "source": [
+ "You can test if GPU is available on your machine and thus train on it to speed up the process"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 640x480 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "plt.plot(range(1), [1])\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "6e18f2fd",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CUDA is not available. Training on CPU ...\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch\n",
+ "\n",
+ "\n",
+ "# check if CUDA is available\n",
+ "train_on_gpu = torch.cuda.is_available()\n",
+ "\n",
+ "if not train_on_gpu:\n",
+ " print(\"CUDA is not available. Training on CPU ...\")\n",
+ "else:\n",
+ " print(\"CUDA is available! Training on GPU ...\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5cf214eb",
+ "metadata": {},
+ "source": [
+ "Next we load the CIFAR10 dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "462666a2",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Files already downloaded and verified\n",
+ "Files already downloaded and verified\n"
+ ]
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "from torchvision import datasets, transforms\n",
+ "from torch.utils.data.sampler import SubsetRandomSampler\n",
+ "\n",
+ "# number of subprocesses to use for data loading\n",
+ "num_workers = 0\n",
+ "# how many samples per batch to load\n",
+ "batch_size = 20\n",
+ "# percentage of training set to use as validation\n",
+ "valid_size = 0.2\n",
+ "\n",
+ "# convert data to a normalized torch.FloatTensor\n",
+ "transform = transforms.Compose(\n",
+ " [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]\n",
+ ")\n",
+ "\n",
+ "# choose the training and test datasets\n",
+ "train_data = datasets.CIFAR10(\"data\", train=True, download=True, transform=transform)\n",
+ "test_data = datasets.CIFAR10(\"data\", train=False, download=True, transform=transform)\n",
+ "\n",
+ "# obtain training indices that will be used for validation\n",
+ "num_train = len(train_data)\n",
+ "indices = list(range(num_train))\n",
+ "np.random.shuffle(indices)\n",
+ "split = int(np.floor(valid_size * num_train))\n",
+ "train_idx, valid_idx = indices[split:], indices[:split]\n",
+ "\n",
+ "# define samplers for obtaining training and validation batches\n",
+ "train_sampler = SubsetRandomSampler(train_idx)\n",
+ "valid_sampler = SubsetRandomSampler(valid_idx)\n",
+ "\n",
+ "# prepare data loaders (combine dataset and sampler)\n",
+ "train_loader = torch.utils.data.DataLoader(\n",
+ " train_data, batch_size=batch_size, sampler=train_sampler, num_workers=num_workers\n",
+ ")\n",
+ "valid_loader = torch.utils.data.DataLoader(\n",
+ " train_data, batch_size=batch_size, sampler=valid_sampler, num_workers=num_workers\n",
+ ")\n",
+ "test_loader = torch.utils.data.DataLoader(\n",
+ " test_data, batch_size=batch_size, num_workers=num_workers\n",
+ ")\n",
+ "\n",
+ "# specify the image classes\n",
+ "classes = [\n",
+ " \"airplane\",\n",
+ " \"automobile\",\n",
+ " \"bird\",\n",
+ " \"cat\",\n",
+ " \"deer\",\n",
+ " \"dog\",\n",
+ " \"frog\",\n",
+ " \"horse\",\n",
+ " \"ship\",\n",
+ " \"truck\",\n",
+ "]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "58ec3903",
+ "metadata": {},
+ "source": [
+ "CNN definition (this one is an example)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "317bf070",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Net(\n",
+ " (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))\n",
+ " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
+ " (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
+ " (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
+ " (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
+ " (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
+ ")\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch.nn as nn\n",
+ "import torch.nn.functional as F\n",
+ "\n",
+ "# define the CNN architecture\n",
+ "\n",
+ "\n",
+ "class Net(nn.Module):\n",
+ " def __init__(self):\n",
+ " super(Net, self).__init__()\n",
+ " self.conv1 = nn.Conv2d(3, 6, 5)\n",
+ " self.pool = nn.MaxPool2d(2, 2)\n",
+ " self.conv2 = nn.Conv2d(6, 16, 5)\n",
+ " self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
+ " self.fc2 = nn.Linear(120, 84)\n",
+ " self.fc3 = nn.Linear(84, 10)\n",
+ "\n",
+ " def forward(self, x):\n",
+ " x = self.pool(F.relu(self.conv1(x)))\n",
+ " x = self.pool(F.relu(self.conv2(x)))\n",
+ " x = x.view(-1, 16 * 5 * 5)\n",
+ " x = F.relu(self.fc1(x))\n",
+ " x = F.relu(self.fc2(x))\n",
+ " x = self.fc3(x)\n",
+ " return x\n",
+ "\n",
+ "\n",
+ "# create a complete CNN\n",
+ "model = Net()\n",
+ "print(model)\n",
+ "# move tensors to GPU if CUDA is available\n",
+ "if train_on_gpu:\n",
+ " model.cuda()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a2dc4974",
+ "metadata": {},
+ "source": [
+ "Loss function and training using SGD (Stochastic Gradient Descent) optimizer"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "4b53f229",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch: 0 \tTraining Loss: 42.969404 \tValidation Loss: 37.030418\n",
+ "Validation loss decreased (inf --> 37.030418). Saving model ...\n",
+ "Epoch: 1 \tTraining Loss: 33.958170 \tValidation Loss: 31.634288\n",
+ "Validation loss decreased (37.030418 --> 31.634288). Saving model ...\n",
+ "Epoch: 2 \tTraining Loss: 30.212565 \tValidation Loss: 29.282247\n",
+ "Validation loss decreased (31.634288 --> 29.282247). Saving model ...\n",
+ "Epoch: 3 \tTraining Loss: 27.916675 \tValidation Loss: 27.083478\n",
+ "Validation loss decreased (29.282247 --> 27.083478). Saving model ...\n",
+ "Epoch: 4 \tTraining Loss: 26.289432 \tValidation Loss: 25.797442\n",
+ "Validation loss decreased (27.083478 --> 25.797442). Saving model ...\n",
+ "Epoch: 5 \tTraining Loss: 24.942089 \tValidation Loss: 24.634932\n",
+ "Validation loss decreased (25.797442 --> 24.634932). Saving model ...\n",
+ "Epoch: 6 \tTraining Loss: 23.799559 \tValidation Loss: 24.094232\n",
+ "Validation loss decreased (24.634932 --> 24.094232). Saving model ...\n",
+ "Epoch: 7 \tTraining Loss: 22.878305 \tValidation Loss: 23.288457\n",
+ "Validation loss decreased (24.094232 --> 23.288457). Saving model ...\n",
+ "Epoch: 8 \tTraining Loss: 22.012754 \tValidation Loss: 22.940952\n",
+ "Validation loss decreased (23.288457 --> 22.940952). Saving model ...\n",
+ "Epoch: 9 \tTraining Loss: 21.183604 \tValidation Loss: 22.302690\n",
+ "Validation loss decreased (22.940952 --> 22.302690). Saving model ...\n",
+ "Epoch: 10 \tTraining Loss: 20.494678 \tValidation Loss: 22.409808\n",
+ "Epoch: 11 \tTraining Loss: 19.806578 \tValidation Loss: 22.121208\n",
+ "Validation loss decreased (22.302690 --> 22.121208). Saving model ...\n",
+ "Epoch: 12 \tTraining Loss: 19.129771 \tValidation Loss: 21.580307\n",
+ "Validation loss decreased (22.121208 --> 21.580307). Saving model ...\n",
+ "Epoch: 13 \tTraining Loss: 18.499622 \tValidation Loss: 21.994472\n",
+ "Epoch: 14 \tTraining Loss: 17.904921 \tValidation Loss: 22.438062\n",
+ "Epoch: 15 \tTraining Loss: 17.353172 \tValidation Loss: 21.465101\n",
+ "Validation loss decreased (21.580307 --> 21.465101). Saving model ...\n",
+ "Epoch: 16 \tTraining Loss: 16.767521 \tValidation Loss: 21.282284\n",
+ "Validation loss decreased (21.465101 --> 21.282284). Saving model ...\n",
+ "Epoch: 17 \tTraining Loss: 16.223959 \tValidation Loss: 21.613519\n",
+ "Epoch: 18 \tTraining Loss: 15.659257 \tValidation Loss: 21.820777\n",
+ "Epoch: 19 \tTraining Loss: 15.076396 \tValidation Loss: 21.843493\n",
+ "Epoch: 20 \tTraining Loss: 14.633786 \tValidation Loss: 22.021824\n",
+ "Epoch: 21 \tTraining Loss: 14.127839 \tValidation Loss: 22.893900\n",
+ "Epoch: 22 \tTraining Loss: 13.673709 \tValidation Loss: 23.505658\n",
+ "Epoch: 23 \tTraining Loss: 13.146696 \tValidation Loss: 23.559017\n",
+ "Epoch: 24 \tTraining Loss: 12.737727 \tValidation Loss: 23.623140\n",
+ "Epoch: 25 \tTraining Loss: 12.283474 \tValidation Loss: 24.595981\n",
+ "Epoch: 26 \tTraining Loss: 11.867565 \tValidation Loss: 25.076360\n",
+ "Epoch: 27 \tTraining Loss: 11.417464 \tValidation Loss: 26.115894\n",
+ "Epoch: 28 \tTraining Loss: 10.946005 \tValidation Loss: 25.483455\n",
+ "Epoch: 29 \tTraining Loss: 10.610706 \tValidation Loss: 26.264836\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch.optim as optim\n",
+ "\n",
+ "criterion = nn.CrossEntropyLoss() # specify loss function\n",
+ "optimizer = optim.SGD(model.parameters(), lr=0.01) # specify optimizer\n",
+ "\n",
+ "n_epochs = 30 # number of epochs to train the model\n",
+ "train_loss_list = [] # list to store loss to visualize\n",
+ "valid_loss_min = np.Inf # track change in validation loss\n",
+ "\n",
+ "for epoch in range(n_epochs):\n",
+ " # Keep track of training and validation loss\n",
+ " train_loss = 0.0\n",
+ " valid_loss = 0.0\n",
+ "\n",
+ " # Train the model\n",
+ " model.train()\n",
+ " for data, target in train_loader:\n",
+ " # Move tensors to GPU if CUDA is available\n",
+ " if train_on_gpu:\n",
+ " data, target = data.cuda(), target.cuda()\n",
+ " # Clear the gradients of all optimized variables\n",
+ " optimizer.zero_grad()\n",
+ " # Forward pass: compute predicted outputs by passing inputs to the model\n",
+ " output = model(data)\n",
+ " # Calculate the batch loss\n",
+ " loss = criterion(output, target)\n",
+ " # Backward pass: compute gradient of the loss with respect to model parameters\n",
+ " loss.backward()\n",
+ " # Perform a single optimization step (parameter update)\n",
+ " optimizer.step()\n",
+ " # Update training loss\n",
+ " train_loss += loss.item() * data.size(0)\n",
+ "\n",
+ " # Validate the model\n",
+ " model.eval()\n",
+ " for data, target in valid_loader:\n",
+ " # Move tensors to GPU if CUDA is available\n",
+ " if train_on_gpu:\n",
+ " data, target = data.cuda(), target.cuda()\n",
+ " # Forward pass: compute predicted outputs by passing inputs to the model\n",
+ " output = model(data)\n",
+ " # Calculate the batch loss\n",
+ " loss = criterion(output, target)\n",
+ " # Update average validation loss\n",
+ " valid_loss += loss.item() * data.size(0)\n",
+ "\n",
+ " # Calculate average losses\n",
+ " train_loss = train_loss / len(train_loader)\n",
+ " valid_loss = valid_loss / len(valid_loader)\n",
+ " train_loss_list.append(train_loss)\n",
+ "\n",
+ " # Print training/validation statistics\n",
+ " print(\n",
+ " \"Epoch: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f}\".format(\n",
+ " epoch, train_loss, valid_loss\n",
+ " )\n",
+ " )\n",
+ "\n",
+ " # Save model if validation loss has decreased\n",
+ " if valid_loss <= valid_loss_min:\n",
+ " print(\n",
+ " \"Validation loss decreased ({:.6f} --> {:.6f}). Saving model ...\".format(\n",
+ " valid_loss_min, valid_loss\n",
+ " )\n",
+ " )\n",
+ " torch.save(model.state_dict(), \"model_cifar.pt\")\n",
+ " valid_loss_min = valid_loss"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "13e1df74",
+ "metadata": {},
+ "source": [
+ "Does overfit occur? If so, do an early stopping."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "d39df818",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 640x480 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "plt.plot(range(n_epochs), train_loss_list)\n",
+ "plt.xlabel(\"Epoch\")\n",
+ "plt.ylabel(\"Loss\")\n",
+ "plt.title(\"Performance of Model 1\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "11df8fd4",
+ "metadata": {},
+ "source": [
+ "Now loading the model with the lowest validation loss value\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "e93efdfc",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Test Loss: 37.275009\n",
+ "\n",
+ "Test Accuracy of airplane: 43% (437/1000)\n",
+ "Test Accuracy of automobile: 27% (272/1000)\n",
+ "Test Accuracy of bird: 1% (14/1000)\n",
+ "Test Accuracy of cat: 6% (64/1000)\n",
+ "Test Accuracy of deer: 26% (263/1000)\n",
+ "Test Accuracy of dog: 20% (203/1000)\n",
+ "Test Accuracy of frog: 57% (574/1000)\n",
+ "Test Accuracy of horse: 59% (598/1000)\n",
+ "Test Accuracy of ship: 34% (345/1000)\n",
+ "Test Accuracy of truck: 47% (470/1000)\n",
+ "\n",
+ "Test Accuracy (Overall): 32% (3240/10000)\n"
+ ]
+ }
+ ],
+ "source": [
+ "model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n",
+ "\n",
+ "# track test loss\n",
+ "test_loss = 0.0\n",
+ "class_correct = list(0.0 for i in range(10))\n",
+ "class_total = list(0.0 for i in range(10))\n",
+ "\n",
+ "model.eval()\n",
+ "# iterate over test data\n",
+ "for data, target in test_loader:\n",
+ " # move tensors to GPU if CUDA is available\n",
+ " if train_on_gpu:\n",
+ " data, target = data.cuda(), target.cuda()\n",
+ " # forward pass: compute predicted outputs by passing inputs to the model\n",
+ " output = model(data)\n",
+ " # calculate the batch loss\n",
+ " loss = criterion(output, target)\n",
+ " # update test loss\n",
+ " test_loss += loss.item() * data.size(0)\n",
+ " # convert output probabilities to predicted class\n",
+ " _, pred = torch.max(output, 1)\n",
+ " # compare predictions to true label\n",
+ " correct_tensor = pred.eq(target.data.view_as(pred))\n",
+ " correct = (\n",
+ " np.squeeze(correct_tensor.numpy())\n",
+ " if not train_on_gpu\n",
+ " else np.squeeze(correct_tensor.cpu().numpy())\n",
+ " )\n",
+ " # calculate test accuracy for each object class\n",
+ " for i in range(batch_size):\n",
+ " label = target.data[i]\n",
+ " class_correct[label] += correct[i].item()\n",
+ " class_total[label] += 1\n",
+ "\n",
+ "# average test loss\n",
+ "test_loss = test_loss / len(test_loader)\n",
+ "print(\"Test Loss: {:.6f}\\n\".format(test_loss))\n",
+ "\n",
+ "for i in range(10):\n",
+ " if class_total[i] > 0:\n",
+ " print(\n",
+ " \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n",
+ " % (\n",
+ " classes[i],\n",
+ " 100 * class_correct[i] / class_total[i],\n",
+ " np.sum(class_correct[i]),\n",
+ " np.sum(class_total[i]),\n",
+ " )\n",
+ " )\n",
+ " else:\n",
+ " print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n",
+ "\n",
+ "print(\n",
+ " \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n",
+ " % (\n",
+ " 100.0 * np.sum(class_correct) / np.sum(class_total),\n",
+ " np.sum(class_correct),\n",
+ " np.sum(class_total),\n",
+ " )\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "944991a2",
+ "metadata": {},
+ "source": [
+ "Build a new network with the following structure.\n",
+ "\n",
+ "- It has 3 convolutional layers of kernel size 3 and padding of 1.\n",
+ "- The first convolutional layer must output 16 channels, the second 32 and the third 64.\n",
+ "- At each convolutional layer output, we apply a ReLU activation then a MaxPool with kernel size of 2.\n",
+ "- Then, three fully connected layers, the first two being followed by a ReLU activation and a dropout whose value you will suggest.\n",
+ "- The first fully connected layer will have an output size of 512.\n",
+ "- The second fully connected layer will have an output size of 64.\n",
+ "\n",
+ "Compare the results obtained with this new network to those obtained previously."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc381cf4",
+ "metadata": {},
+ "source": [
+ "## Exercise 2: Quantization: try to compress the CNN to save space\n",
+ "\n",
+ "Quantization doc is available from https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic\n",
+ " \n",
+ "The Exercise is to quantize post training the above CNN model. Compare the size reduction and the impact on the classification accuracy \n",
+ "\n",
+ "\n",
+ "The size of the model is simply the size of the file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "ef623c26",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "model: fp32 \t Size (KB): 251.278\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "251278"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import os\n",
+ "\n",
+ "\n",
+ "def print_size_of_model(model, label=\"\"):\n",
+ " torch.save(model.state_dict(), \"temp.p\")\n",
+ " size = os.path.getsize(\"temp.p\")\n",
+ " print(\"model: \", label, \" \\t\", \"Size (KB):\", size / 1e3)\n",
+ " os.remove(\"temp.p\")\n",
+ " return size\n",
+ "\n",
+ "\n",
+ "print_size_of_model(model, \"fp32\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "05c4e9ad",
+ "metadata": {},
+ "source": [
+ "Post training quantization example"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "c4c65d4b",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "model: int8 \t Size (KB): 76.522\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "76522"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import torch.quantization\n",
+ "\n",
+ "\n",
+ "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n",
+ "print_size_of_model(quantized_model, \"int8\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7b108e17",
+ "metadata": {},
+ "source": [
+ "For each class, compare the classification test accuracy of the initial model and the quantized model. Also give the overall test accuracy for both models."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a0a34b90",
+ "metadata": {},
+ "source": [
+ "Try training aware quantization to mitigate the impact on the accuracy (doc available here https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "201470f9",
+ "metadata": {},
+ "source": [
+ "## Exercise 3: working with pre-trained models.\n",
+ "\n",
+ "PyTorch offers several pre-trained models https://pytorch.org/vision/0.8/models.html \n",
+ "We will use ResNet50 trained on ImageNet dataset (https://www.image-net.org/index.php). Use the following code with the files `imagenet-simple-labels.json` that contains the imagenet labels and the image dog.png that we will use as test.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "b4d13080",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "c:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torchvision\\models\\_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
+ " warnings.warn(\n",
+ "c:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
+ " warnings.warn(msg)\n",
+ "Downloading: \"https://download.pytorch.org/models/resnet50-0676ba61.pth\" to C:\\Users\\Malo/.cache\\torch\\hub\\checkpoints\\resnet50-0676ba61.pth\n"
+ ]
+ },
+ {
+ "ename": "URLError",
+ "evalue": "<urlopen error [Errno 11001] getaddrinfo failed>",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[1;31mgaierror\u001b[0m Traceback (most recent call last)",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\urllib\\request.py:1348\u001b[0m, in \u001b[0;36mAbstractHTTPHandler.do_open\u001b[1;34m(self, http_class, req, **http_conn_args)\u001b[0m\n\u001b[0;32m 1347\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m-> 1348\u001b[0m h\u001b[39m.\u001b[39mrequest(req\u001b[39m.\u001b[39mget_method(), req\u001b[39m.\u001b[39mselector, req\u001b[39m.\u001b[39mdata, headers,\n\u001b[0;32m 1349\u001b[0m encode_chunked\u001b[39m=\u001b[39mreq\u001b[39m.\u001b[39mhas_header(\u001b[39m'\u001b[39m\u001b[39mTransfer-encoding\u001b[39m\u001b[39m'\u001b[39m))\n\u001b[0;32m 1350\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mOSError\u001b[39;00m \u001b[39mas\u001b[39;00m err: \u001b[39m# timeout error\u001b[39;00m\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\http\\client.py:1286\u001b[0m, in \u001b[0;36mHTTPConnection.request\u001b[1;34m(self, method, url, body, headers, encode_chunked)\u001b[0m\n\u001b[0;32m 1285\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Send a complete request to the server.\"\"\"\u001b[39;00m\n\u001b[1;32m-> 1286\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_send_request(method, url, body, headers, encode_chunked)\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\http\\client.py:1332\u001b[0m, in \u001b[0;36mHTTPConnection._send_request\u001b[1;34m(self, method, url, body, headers, encode_chunked)\u001b[0m\n\u001b[0;32m 1331\u001b[0m body \u001b[39m=\u001b[39m _encode(body, \u001b[39m'\u001b[39m\u001b[39mbody\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m-> 1332\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mendheaders(body, encode_chunked\u001b[39m=\u001b[39mencode_chunked)\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\http\\client.py:1281\u001b[0m, in \u001b[0;36mHTTPConnection.endheaders\u001b[1;34m(self, message_body, encode_chunked)\u001b[0m\n\u001b[0;32m 1280\u001b[0m \u001b[39mraise\u001b[39;00m CannotSendHeader()\n\u001b[1;32m-> 1281\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_send_output(message_body, encode_chunked\u001b[39m=\u001b[39mencode_chunked)\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\http\\client.py:1041\u001b[0m, in \u001b[0;36mHTTPConnection._send_output\u001b[1;34m(self, message_body, encode_chunked)\u001b[0m\n\u001b[0;32m 1040\u001b[0m \u001b[39mdel\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_buffer[:]\n\u001b[1;32m-> 1041\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msend(msg)\n\u001b[0;32m 1043\u001b[0m \u001b[39mif\u001b[39;00m message_body \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 1044\u001b[0m \n\u001b[0;32m 1045\u001b[0m \u001b[39m# create a consistent interface to message_body\u001b[39;00m\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\http\\client.py:979\u001b[0m, in \u001b[0;36mHTTPConnection.send\u001b[1;34m(self, data)\u001b[0m\n\u001b[0;32m 978\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mauto_open:\n\u001b[1;32m--> 979\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mconnect()\n\u001b[0;32m 980\u001b[0m \u001b[39melse\u001b[39;00m:\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\http\\client.py:1451\u001b[0m, in \u001b[0;36mHTTPSConnection.connect\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 1449\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mConnect to a host on a given (SSL) port.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m-> 1451\u001b[0m \u001b[39msuper\u001b[39m()\u001b[39m.\u001b[39mconnect()\n\u001b[0;32m 1453\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_tunnel_host:\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\http\\client.py:945\u001b[0m, in \u001b[0;36mHTTPConnection.connect\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 944\u001b[0m sys\u001b[39m.\u001b[39maudit(\u001b[39m\"\u001b[39m\u001b[39mhttp.client.connect\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mself\u001b[39m, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhost, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mport)\n\u001b[1;32m--> 945\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msock \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_create_connection(\n\u001b[0;32m 946\u001b[0m (\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhost,\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mport), \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtimeout, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msource_address)\n\u001b[0;32m 947\u001b[0m \u001b[39m# Might fail in OSs that don't implement TCP_NODELAY\u001b[39;00m\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\socket.py:827\u001b[0m, in \u001b[0;36mcreate_connection\u001b[1;34m(address, timeout, source_address, all_errors)\u001b[0m\n\u001b[0;32m 826\u001b[0m exceptions \u001b[39m=\u001b[39m []\n\u001b[1;32m--> 827\u001b[0m \u001b[39mfor\u001b[39;00m res \u001b[39min\u001b[39;00m getaddrinfo(host, port, \u001b[39m0\u001b[39m, SOCK_STREAM):\n\u001b[0;32m 828\u001b[0m af, socktype, proto, canonname, sa \u001b[39m=\u001b[39m res\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\socket.py:962\u001b[0m, in \u001b[0;36mgetaddrinfo\u001b[1;34m(host, port, family, type, proto, flags)\u001b[0m\n\u001b[0;32m 961\u001b[0m addrlist \u001b[39m=\u001b[39m []\n\u001b[1;32m--> 962\u001b[0m \u001b[39mfor\u001b[39;00m res \u001b[39min\u001b[39;00m _socket\u001b[39m.\u001b[39mgetaddrinfo(host, port, family, \u001b[39mtype\u001b[39m, proto, flags):\n\u001b[0;32m 963\u001b[0m af, socktype, proto, canonname, sa \u001b[39m=\u001b[39m res\n",
+ "\u001b[1;31mgaierror\u001b[0m: [Errno 11001] getaddrinfo failed",
+ "\nDuring handling of the above exception, another exception occurred:\n",
+ "\u001b[1;31mURLError\u001b[0m Traceback (most recent call last)",
+ "\u001b[1;32mc:\\Users\\Malo\\Documents\\Python Scripts\\td2-deeplearning\\TD2 Deep Learning.ipynb Cell 29\u001b[0m line \u001b[0;36m3\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/TD2%20Deep%20Learning.ipynb#X36sZmlsZQ%3D%3D?line=29'>30</a>\u001b[0m image \u001b[39m=\u001b[39m data_transform(image)\u001b[39m.\u001b[39munsqueeze(\u001b[39m0\u001b[39m)\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/TD2%20Deep%20Learning.ipynb#X36sZmlsZQ%3D%3D?line=31'>32</a>\u001b[0m \u001b[39m# Download the model if it's not there already. It will take a bit on the first run, after that it's fast\u001b[39;00m\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/TD2%20Deep%20Learning.ipynb#X36sZmlsZQ%3D%3D?line=32'>33</a>\u001b[0m model \u001b[39m=\u001b[39m models\u001b[39m.\u001b[39mresnet50(pretrained\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/TD2%20Deep%20Learning.ipynb#X36sZmlsZQ%3D%3D?line=33'>34</a>\u001b[0m \u001b[39m# Send the model to the GPU\u001b[39;00m\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/TD2%20Deep%20Learning.ipynb#X36sZmlsZQ%3D%3D?line=34'>35</a>\u001b[0m \u001b[39m# model.cuda()\u001b[39;00m\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/TD2%20Deep%20Learning.ipynb#X36sZmlsZQ%3D%3D?line=35'>36</a>\u001b[0m \u001b[39m# Set layers such as dropout and batchnorm in evaluation mode\u001b[39;00m\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/TD2%20Deep%20Learning.ipynb#X36sZmlsZQ%3D%3D?line=36'>37</a>\u001b[0m model\u001b[39m.\u001b[39meval()\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torchvision\\models\\_utils.py:142\u001b[0m, in \u001b[0;36mkwonly_to_pos_or_kw.<locals>.wrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 135\u001b[0m warnings\u001b[39m.\u001b[39mwarn(\n\u001b[0;32m 136\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mUsing \u001b[39m\u001b[39m{\u001b[39;00msequence_to_str(\u001b[39mtuple\u001b[39m(keyword_only_kwargs\u001b[39m.\u001b[39mkeys()),\u001b[39m \u001b[39mseparate_last\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mand \u001b[39m\u001b[39m'\u001b[39m)\u001b[39m}\u001b[39;00m\u001b[39m as positional \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m 137\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mparameter(s) is deprecated since 0.13 and may be removed in the future. Please use keyword parameter(s) \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m 138\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39minstead.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m 139\u001b[0m )\n\u001b[0;32m 140\u001b[0m kwargs\u001b[39m.\u001b[39mupdate(keyword_only_kwargs)\n\u001b[1;32m--> 142\u001b[0m \u001b[39mreturn\u001b[39;00m fn(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torchvision\\models\\_utils.py:228\u001b[0m, in \u001b[0;36mhandle_legacy_interface.<locals>.outer_wrapper.<locals>.inner_wrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 225\u001b[0m \u001b[39mdel\u001b[39;00m kwargs[pretrained_param]\n\u001b[0;32m 226\u001b[0m kwargs[weights_param] \u001b[39m=\u001b[39m default_weights_arg\n\u001b[1;32m--> 228\u001b[0m \u001b[39mreturn\u001b[39;00m builder(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torchvision\\models\\resnet.py:763\u001b[0m, in \u001b[0;36mresnet50\u001b[1;34m(weights, progress, **kwargs)\u001b[0m\n\u001b[0;32m 737\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"ResNet-50 from `Deep Residual Learning for Image Recognition <https://arxiv.org/abs/1512.03385>`__.\u001b[39;00m\n\u001b[0;32m 738\u001b[0m \n\u001b[0;32m 739\u001b[0m \u001b[39m.. note::\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 759\u001b[0m \u001b[39m :members:\u001b[39;00m\n\u001b[0;32m 760\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m 761\u001b[0m weights \u001b[39m=\u001b[39m ResNet50_Weights\u001b[39m.\u001b[39mverify(weights)\n\u001b[1;32m--> 763\u001b[0m \u001b[39mreturn\u001b[39;00m _resnet(Bottleneck, [\u001b[39m3\u001b[39m, \u001b[39m4\u001b[39m, \u001b[39m6\u001b[39m, \u001b[39m3\u001b[39m], weights, progress, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torchvision\\models\\resnet.py:301\u001b[0m, in \u001b[0;36m_resnet\u001b[1;34m(block, layers, weights, progress, **kwargs)\u001b[0m\n\u001b[0;32m 298\u001b[0m model \u001b[39m=\u001b[39m ResNet(block, layers, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[0;32m 300\u001b[0m \u001b[39mif\u001b[39;00m weights \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m--> 301\u001b[0m model\u001b[39m.\u001b[39mload_state_dict(weights\u001b[39m.\u001b[39mget_state_dict(progress\u001b[39m=\u001b[39mprogress, check_hash\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m))\n\u001b[0;32m 303\u001b[0m \u001b[39mreturn\u001b[39;00m model\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torchvision\\models\\_api.py:90\u001b[0m, in \u001b[0;36mWeightsEnum.get_state_dict\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 89\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_state_dict\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39margs: Any, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs: Any) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m Mapping[\u001b[39mstr\u001b[39m, Any]:\n\u001b[1;32m---> 90\u001b[0m \u001b[39mreturn\u001b[39;00m load_state_dict_from_url(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39murl, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torch\\hub.py:766\u001b[0m, in \u001b[0;36mload_state_dict_from_url\u001b[1;34m(url, model_dir, map_location, progress, check_hash, file_name, weights_only)\u001b[0m\n\u001b[0;32m 764\u001b[0m r \u001b[39m=\u001b[39m HASH_REGEX\u001b[39m.\u001b[39msearch(filename) \u001b[39m# r is Optional[Match[str]]\u001b[39;00m\n\u001b[0;32m 765\u001b[0m hash_prefix \u001b[39m=\u001b[39m r\u001b[39m.\u001b[39mgroup(\u001b[39m1\u001b[39m) \u001b[39mif\u001b[39;00m r \u001b[39melse\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m--> 766\u001b[0m download_url_to_file(url, cached_file, hash_prefix, progress\u001b[39m=\u001b[39mprogress)\n\u001b[0;32m 768\u001b[0m \u001b[39mif\u001b[39;00m _is_legacy_zip_format(cached_file):\n\u001b[0;32m 769\u001b[0m \u001b[39mreturn\u001b[39;00m _legacy_zip_load(cached_file, model_dir, map_location, weights_only)\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torch\\hub.py:620\u001b[0m, in \u001b[0;36mdownload_url_to_file\u001b[1;34m(url, dst, hash_prefix, progress)\u001b[0m\n\u001b[0;32m 618\u001b[0m file_size \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m 619\u001b[0m req \u001b[39m=\u001b[39m Request(url, headers\u001b[39m=\u001b[39m{\u001b[39m\"\u001b[39m\u001b[39mUser-Agent\u001b[39m\u001b[39m\"\u001b[39m: \u001b[39m\"\u001b[39m\u001b[39mtorch.hub\u001b[39m\u001b[39m\"\u001b[39m})\n\u001b[1;32m--> 620\u001b[0m u \u001b[39m=\u001b[39m urlopen(req)\n\u001b[0;32m 621\u001b[0m meta \u001b[39m=\u001b[39m u\u001b[39m.\u001b[39minfo()\n\u001b[0;32m 622\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mhasattr\u001b[39m(meta, \u001b[39m'\u001b[39m\u001b[39mgetheaders\u001b[39m\u001b[39m'\u001b[39m):\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\urllib\\request.py:216\u001b[0m, in \u001b[0;36murlopen\u001b[1;34m(url, data, timeout, cafile, capath, cadefault, context)\u001b[0m\n\u001b[0;32m 214\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m 215\u001b[0m opener \u001b[39m=\u001b[39m _opener\n\u001b[1;32m--> 216\u001b[0m \u001b[39mreturn\u001b[39;00m opener\u001b[39m.\u001b[39mopen(url, data, timeout)\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\urllib\\request.py:519\u001b[0m, in \u001b[0;36mOpenerDirector.open\u001b[1;34m(self, fullurl, data, timeout)\u001b[0m\n\u001b[0;32m 516\u001b[0m req \u001b[39m=\u001b[39m meth(req)\n\u001b[0;32m 518\u001b[0m sys\u001b[39m.\u001b[39maudit(\u001b[39m'\u001b[39m\u001b[39murllib.Request\u001b[39m\u001b[39m'\u001b[39m, req\u001b[39m.\u001b[39mfull_url, req\u001b[39m.\u001b[39mdata, req\u001b[39m.\u001b[39mheaders, req\u001b[39m.\u001b[39mget_method())\n\u001b[1;32m--> 519\u001b[0m response \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_open(req, data)\n\u001b[0;32m 521\u001b[0m \u001b[39m# post-process response\u001b[39;00m\n\u001b[0;32m 522\u001b[0m meth_name \u001b[39m=\u001b[39m protocol\u001b[39m+\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m_response\u001b[39m\u001b[39m\"\u001b[39m\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\urllib\\request.py:536\u001b[0m, in \u001b[0;36mOpenerDirector._open\u001b[1;34m(self, req, data)\u001b[0m\n\u001b[0;32m 533\u001b[0m \u001b[39mreturn\u001b[39;00m result\n\u001b[0;32m 535\u001b[0m protocol \u001b[39m=\u001b[39m req\u001b[39m.\u001b[39mtype\n\u001b[1;32m--> 536\u001b[0m result \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_call_chain(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhandle_open, protocol, protocol \u001b[39m+\u001b[39m\n\u001b[0;32m 537\u001b[0m \u001b[39m'\u001b[39m\u001b[39m_open\u001b[39m\u001b[39m'\u001b[39m, req)\n\u001b[0;32m 538\u001b[0m \u001b[39mif\u001b[39;00m result:\n\u001b[0;32m 539\u001b[0m \u001b[39mreturn\u001b[39;00m result\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\urllib\\request.py:496\u001b[0m, in \u001b[0;36mOpenerDirector._call_chain\u001b[1;34m(self, chain, kind, meth_name, *args)\u001b[0m\n\u001b[0;32m 494\u001b[0m \u001b[39mfor\u001b[39;00m handler \u001b[39min\u001b[39;00m handlers:\n\u001b[0;32m 495\u001b[0m func \u001b[39m=\u001b[39m \u001b[39mgetattr\u001b[39m(handler, meth_name)\n\u001b[1;32m--> 496\u001b[0m result \u001b[39m=\u001b[39m func(\u001b[39m*\u001b[39margs)\n\u001b[0;32m 497\u001b[0m \u001b[39mif\u001b[39;00m result \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 498\u001b[0m \u001b[39mreturn\u001b[39;00m result\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\urllib\\request.py:1391\u001b[0m, in \u001b[0;36mHTTPSHandler.https_open\u001b[1;34m(self, req)\u001b[0m\n\u001b[0;32m 1390\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mhttps_open\u001b[39m(\u001b[39mself\u001b[39m, req):\n\u001b[1;32m-> 1391\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdo_open(http\u001b[39m.\u001b[39mclient\u001b[39m.\u001b[39mHTTPSConnection, req,\n\u001b[0;32m 1392\u001b[0m context\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_context, check_hostname\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_check_hostname)\n",
+ "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\urllib\\request.py:1351\u001b[0m, in \u001b[0;36mAbstractHTTPHandler.do_open\u001b[1;34m(self, http_class, req, **http_conn_args)\u001b[0m\n\u001b[0;32m 1348\u001b[0m h\u001b[39m.\u001b[39mrequest(req\u001b[39m.\u001b[39mget_method(), req\u001b[39m.\u001b[39mselector, req\u001b[39m.\u001b[39mdata, headers,\n\u001b[0;32m 1349\u001b[0m encode_chunked\u001b[39m=\u001b[39mreq\u001b[39m.\u001b[39mhas_header(\u001b[39m'\u001b[39m\u001b[39mTransfer-encoding\u001b[39m\u001b[39m'\u001b[39m))\n\u001b[0;32m 1350\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mOSError\u001b[39;00m \u001b[39mas\u001b[39;00m err: \u001b[39m# timeout error\u001b[39;00m\n\u001b[1;32m-> 1351\u001b[0m \u001b[39mraise\u001b[39;00m URLError(err)\n\u001b[0;32m 1352\u001b[0m r \u001b[39m=\u001b[39m h\u001b[39m.\u001b[39mgetresponse()\n\u001b[0;32m 1353\u001b[0m \u001b[39mexcept\u001b[39;00m:\n",
+ "\u001b[1;31mURLError\u001b[0m: <urlopen error [Errno 11001] getaddrinfo failed>"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 640x480 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import json\n",
+ "from PIL import Image\n",
+ "\n",
+ "# Choose an image to pass through the model\n",
+ "test_image = \"dog.png\"\n",
+ "\n",
+ "# Configure matplotlib for pretty inline plots\n",
+ "#%matplotlib inline\n",
+ "#%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "# Prepare the labels\n",
+ "with open(\"imagenet-simple-labels.json\") as f:\n",
+ " labels = json.load(f)\n",
+ "\n",
+ "# First prepare the transformations: resize the image to what the model was trained on and convert it to a tensor\n",
+ "data_transform = transforms.Compose(\n",
+ " [\n",
+ " transforms.Resize((224, 224)),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
+ " ]\n",
+ ")\n",
+ "# Load the image\n",
+ "\n",
+ "image = Image.open(test_image)\n",
+ "plt.imshow(image), plt.xticks([]), plt.yticks([])\n",
+ "\n",
+ "# Now apply the transformation, expand the batch dimension, and send the image to the GPU\n",
+ "# image = data_transform(image).unsqueeze(0).cuda()\n",
+ "image = data_transform(image).unsqueeze(0)\n",
+ "\n",
+ "# Download the model if it's not there already. It will take a bit on the first run, after that it's fast\n",
+ "model = models.resnet50(pretrained=True)\n",
+ "# Send the model to the GPU\n",
+ "# model.cuda()\n",
+ "# Set layers such as dropout and batchnorm in evaluation mode\n",
+ "model.eval()\n",
+ "\n",
+ "# Get the 1000-dimensional model output\n",
+ "out = model(image)\n",
+ "# Find the predicted class\n",
+ "print(\"Predicted class is: {}\".format(labels[out.argmax()]))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "184cfceb",
+ "metadata": {},
+ "source": [
+ "Experiments:\n",
+ "\n",
+ "Study the code and the results obtained. Possibly add other images downloaded from the internet.\n",
+ "\n",
+ "What is the size of the model? Quantize it and then check if the model is still able to correctly classify the other images.\n",
+ "\n",
+ "Experiment with other pre-trained CNN models.\n",
+ "\n",
+ " \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5d57da4b",
+ "metadata": {},
+ "source": [
+ "## Exercise 4: Transfer Learning\n",
+ " \n",
+ " \n",
+ "For this work, we will use a pre-trained model (ResNet18) as a descriptor extractor and will refine the classification by training only the last fully connected layer of the network. Thus, the output layer of the pre-trained network will be replaced by a layer adapted to the new classes to be recognized which will be in our case ants and bees.\n",
+ "Download and unzip in your working directory the dataset available at the address :\n",
+ " \n",
+ "https://download.pytorch.org/tutorial/hymenoptera_data.zip\n",
+ " \n",
+ "Execute the following code in order to display some images of the dataset."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "be2d31f5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import torch\n",
+ "import torchvision\n",
+ "from torchvision import datasets, transforms\n",
+ "\n",
+ "# Data augmentation and normalization for training\n",
+ "# Just normalization for validation\n",
+ "data_transforms = {\n",
+ " \"train\": transforms.Compose(\n",
+ " [\n",
+ " transforms.RandomResizedCrop(\n",
+ " 224\n",
+ " ), # ImageNet models were trained on 224x224 images\n",
+ " transforms.RandomHorizontalFlip(), # flip horizontally 50% of the time - increases train set variability\n",
+ " transforms.ToTensor(), # convert it to a PyTorch tensor\n",
+ " transforms.Normalize(\n",
+ " [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]\n",
+ " ), # ImageNet models expect this norm\n",
+ " ]\n",
+ " ),\n",
+ " \"val\": transforms.Compose(\n",
+ " [\n",
+ " transforms.Resize(256),\n",
+ " transforms.CenterCrop(224),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
+ " ]\n",
+ " ),\n",
+ "}\n",
+ "\n",
+ "data_dir = \"hymenoptera_data\"\n",
+ "# Create train and validation datasets and loaders\n",
+ "image_datasets = {\n",
+ " x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n",
+ " for x in [\"train\", \"val\"]\n",
+ "}\n",
+ "dataloaders = {\n",
+ " x: torch.utils.data.DataLoader(\n",
+ " image_datasets[x], batch_size=4, shuffle=True, num_workers=0\n",
+ " )\n",
+ " for x in [\"train\", \"val\"]\n",
+ "}\n",
+ "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\"]}\n",
+ "class_names = image_datasets[\"train\"].classes\n",
+ "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+ "\n",
+ "# Helper function for displaying images\n",
+ "def imshow(inp, title=None):\n",
+ " \"\"\"Imshow for Tensor.\"\"\"\n",
+ " inp = inp.numpy().transpose((1, 2, 0))\n",
+ " mean = np.array([0.485, 0.456, 0.406])\n",
+ " std = np.array([0.229, 0.224, 0.225])\n",
+ "\n",
+ " # Un-normalize the images\n",
+ " inp = std * inp + mean\n",
+ " # Clip just in case\n",
+ " inp = np.clip(inp, 0, 1)\n",
+ " plt.imshow(inp)\n",
+ " if title is not None:\n",
+ " plt.title(title)\n",
+ " plt.pause(0.001) # pause a bit so that plots are updated\n",
+ " plt.show()\n",
+ "\n",
+ "\n",
+ "# Get a batch of training data\n",
+ "inputs, classes = next(iter(dataloaders[\"train\"]))\n",
+ "\n",
+ "# Make a grid from batch\n",
+ "out = torchvision.utils.make_grid(inputs)\n",
+ "\n",
+ "imshow(out, title=[class_names[x] for x in classes])\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bbd48800",
+ "metadata": {},
+ "source": [
+ "Now, execute the following code which uses a pre-trained model ResNet18 having replaced the output layer for the ants/bees classification and performs the model training by only changing the weights of this output layer."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "572d824c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import copy\n",
+ "import os\n",
+ "import time\n",
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import torch\n",
+ "import torch.nn as nn\n",
+ "import torch.optim as optim\n",
+ "import torchvision\n",
+ "from torch.optim import lr_scheduler\n",
+ "from torchvision import datasets, transforms\n",
+ "\n",
+ "# Data augmentation and normalization for training\n",
+ "# Just normalization for validation\n",
+ "data_transforms = {\n",
+ " \"train\": transforms.Compose(\n",
+ " [\n",
+ " transforms.RandomResizedCrop(\n",
+ " 224\n",
+ " ), # ImageNet models were trained on 224x224 images\n",
+ " transforms.RandomHorizontalFlip(), # flip horizontally 50% of the time - increases train set variability\n",
+ " transforms.ToTensor(), # convert it to a PyTorch tensor\n",
+ " transforms.Normalize(\n",
+ " [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]\n",
+ " ), # ImageNet models expect this norm\n",
+ " ]\n",
+ " ),\n",
+ " \"val\": transforms.Compose(\n",
+ " [\n",
+ " transforms.Resize(256),\n",
+ " transforms.CenterCrop(224),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
+ " ]\n",
+ " ),\n",
+ "}\n",
+ "\n",
+ "data_dir = \"hymenoptera_data\"\n",
+ "# Create train and validation datasets and loaders\n",
+ "image_datasets = {\n",
+ " x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n",
+ " for x in [\"train\", \"val\"]\n",
+ "}\n",
+ "dataloaders = {\n",
+ " x: torch.utils.data.DataLoader(\n",
+ " image_datasets[x], batch_size=4, shuffle=True, num_workers=4\n",
+ " )\n",
+ " for x in [\"train\", \"val\"]\n",
+ "}\n",
+ "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\"]}\n",
+ "class_names = image_datasets[\"train\"].classes\n",
+ "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+ "\n",
+ "# Helper function for displaying images\n",
+ "def imshow(inp, title=None):\n",
+ " \"\"\"Imshow for Tensor.\"\"\"\n",
+ " inp = inp.numpy().transpose((1, 2, 0))\n",
+ " mean = np.array([0.485, 0.456, 0.406])\n",
+ " std = np.array([0.229, 0.224, 0.225])\n",
+ "\n",
+ " # Un-normalize the images\n",
+ " inp = std * inp + mean\n",
+ " # Clip just in case\n",
+ " inp = np.clip(inp, 0, 1)\n",
+ " plt.imshow(inp)\n",
+ " if title is not None:\n",
+ " plt.title(title)\n",
+ " plt.pause(0.001) # pause a bit so that plots are updated\n",
+ " plt.show()\n",
+ "\n",
+ "\n",
+ "# Get a batch of training data\n",
+ "# inputs, classes = next(iter(dataloaders['train']))\n",
+ "\n",
+ "# Make a grid from batch\n",
+ "# out = torchvision.utils.make_grid(inputs)\n",
+ "\n",
+ "# imshow(out, title=[class_names[x] for x in classes])\n",
+ "# training\n",
+ "\n",
+ "\n",
+ "def train_model(model, criterion, optimizer, scheduler, num_epochs=25):\n",
+ " since = time.time()\n",
+ "\n",
+ " best_model_wts = copy.deepcopy(model.state_dict())\n",
+ " best_acc = 0.0\n",
+ "\n",
+ " epoch_time = [] # we'll keep track of the time needed for each epoch\n",
+ "\n",
+ " for epoch in range(num_epochs):\n",
+ " epoch_start = time.time()\n",
+ " print(\"Epoch {}/{}\".format(epoch + 1, num_epochs))\n",
+ " print(\"-\" * 10)\n",
+ "\n",
+ " # Each epoch has a training and validation phase\n",
+ " for phase in [\"train\", \"val\"]:\n",
+ " if phase == \"train\":\n",
+ " scheduler.step()\n",
+ " model.train() # Set model to training mode\n",
+ " else:\n",
+ " model.eval() # Set model to evaluate mode\n",
+ "\n",
+ " running_loss = 0.0\n",
+ " running_corrects = 0\n",
+ "\n",
+ " # Iterate over data.\n",
+ " for inputs, labels in dataloaders[phase]:\n",
+ " inputs = inputs.to(device)\n",
+ " labels = labels.to(device)\n",
+ "\n",
+ " # zero the parameter gradients\n",
+ " optimizer.zero_grad()\n",
+ "\n",
+ " # Forward\n",
+ " # Track history if only in training phase\n",
+ " with torch.set_grad_enabled(phase == \"train\"):\n",
+ " outputs = model(inputs)\n",
+ " _, preds = torch.max(outputs, 1)\n",
+ " loss = criterion(outputs, labels)\n",
+ "\n",
+ " # backward + optimize only if in training phase\n",
+ " if phase == \"train\":\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ "\n",
+ " # Statistics\n",
+ " running_loss += loss.item() * inputs.size(0)\n",
+ " running_corrects += torch.sum(preds == labels.data)\n",
+ "\n",
+ " epoch_loss = running_loss / dataset_sizes[phase]\n",
+ " epoch_acc = running_corrects.double() / dataset_sizes[phase]\n",
+ "\n",
+ " print(\"{} Loss: {:.4f} Acc: {:.4f}\".format(phase, epoch_loss, epoch_acc))\n",
+ "\n",
+ " # Deep copy the model\n",
+ " if phase == \"val\" and epoch_acc > best_acc:\n",
+ " best_acc = epoch_acc\n",
+ " best_model_wts = copy.deepcopy(model.state_dict())\n",
+ "\n",
+ " # Add the epoch time\n",
+ " t_epoch = time.time() - epoch_start\n",
+ " epoch_time.append(t_epoch)\n",
+ " print()\n",
+ "\n",
+ " time_elapsed = time.time() - since\n",
+ " print(\n",
+ " \"Training complete in {:.0f}m {:.0f}s\".format(\n",
+ " time_elapsed // 60, time_elapsed % 60\n",
+ " )\n",
+ " )\n",
+ " print(\"Best val Acc: {:4f}\".format(best_acc))\n",
+ "\n",
+ " # Load best model weights\n",
+ " model.load_state_dict(best_model_wts)\n",
+ " return model, epoch_time\n",
+ "\n",
+ "\n",
+ "# Download a pre-trained ResNet18 model and freeze its weights\n",
+ "model = torchvision.models.resnet18(pretrained=True)\n",
+ "for param in model.parameters():\n",
+ " param.requires_grad = False\n",
+ "\n",
+ "# Replace the final fully connected layer\n",
+ "# Parameters of newly constructed modules have requires_grad=True by default\n",
+ "num_ftrs = model.fc.in_features\n",
+ "model.fc = nn.Linear(num_ftrs, 2)\n",
+ "# Send the model to the GPU\n",
+ "model = model.to(device)\n",
+ "# Set the loss function\n",
+ "criterion = nn.CrossEntropyLoss()\n",
+ "\n",
+ "# Observe that only the parameters of the final layer are being optimized\n",
+ "optimizer_conv = optim.SGD(model.fc.parameters(), lr=0.001, momentum=0.9)\n",
+ "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_conv, step_size=7, gamma=0.1)\n",
+ "model, epoch_time = train_model(\n",
+ " model, criterion, optimizer_conv, exp_lr_scheduler, num_epochs=10\n",
+ ")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bbd48800",
+ "metadata": {},
+ "source": [
+ "Experiments:\n",
+ "Study the code and the results obtained.\n",
+ "\n",
+ "Modify the code and add an \"eval_model\" function to allow\n",
+ "the evaluation of the model on a test set (different from the learning and validation sets used during the learning phase). Study the results obtained.\n",
+ "\n",
+ "Now modify the code to replace the current classification layer with a set of two layers using a \"relu\" activation function for the middle layer, and the \"dropout\" mechanism for both layers. Renew the experiments and study the results obtained.\n",
+ "\n",
+ "Apply ther quantization (post and quantization aware) and evaluate impact on model size and accuracy."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "04a263f0",
+ "metadata": {},
+ "source": [
+ "## Optional\n",
+ " \n",
+ "Try this at home!! \n",
+ "\n",
+ "\n",
+ "Pytorch offers a framework to export a given CNN to your selfphone (either android or iOS). Have a look at the tutorial https://pytorch.org/mobile/home/\n",
+ "\n",
+ "The Exercise consists in deploying the CNN of Exercise 4 in your phone and then test it on live.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe954ce4",
+ "metadata": {},
+ "source": [
+ "## Author\n",
+ "\n",
+ "Alberto BOSIO - Ph. D."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3.8.5 ('base')",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.11.5"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "9e3efbebb05da2d4a1968abe9a0645745f54b63feb7a85a514e4da0495be97eb"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/TD2 Deep Learning.ipynb b/TD2 Deep Learning.ipynb
index 1e4eb9d9c6fb29b0c7100a599b2df459846ff0f9..1c36cf8e69f683a0b95f1549890eaa59e92fb590 100644
--- a/TD2 Deep Learning.ipynb
+++ b/TD2 Deep Learning.ipynb
@@ -8,143 +8,12 @@
"# TD2: Deep learning"
]
},
- {
- "cell_type": "markdown",
- "id": "fbb8c8df",
- "metadata": {},
- "source": [
- "In this TD, you must modify this notebook to answer the questions. To do this,\n",
- "\n",
- "1. Fork this repository\n",
- "2. Clone your forked repository on your local computer\n",
- "3. Answer the questions\n",
- "4. Commit and push regularly\n",
- "\n",
- "The last commit is due on Sunday, December 1, 11:59 PM. Later commits will not be taken into account."
- ]
- },
- {
- "cell_type": "markdown",
- "id": "3d167a29",
- "metadata": {},
- "source": [
- "Install and test PyTorch from https://pytorch.org/get-started/locally."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "id": "330a42f5",
- "metadata": {},
- "outputs": [],
- "source": [
- "#%pip install torch torchvision"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "0882a636",
- "metadata": {},
- "source": [
- "\n",
- "To test run the following code"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 18,
- "id": "b1950f0a",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "tensor([[-0.4165, 0.7959, -2.6496, -0.5867, -1.1638, 0.7261, -1.5494, 1.3172,\n",
- " -1.1476, 0.5233],\n",
- " [-0.2842, -1.3210, 0.9482, -1.6569, 0.0971, 0.8307, -0.4953, -1.5192,\n",
- " 0.1170, -0.0036],\n",
- " [-0.5698, 1.5647, 0.2267, 1.3669, 1.5906, 1.9830, -0.5329, 2.1946,\n",
- " 0.9815, -1.3213],\n",
- " [ 0.4260, -0.2465, -0.7108, 2.0587, -1.4107, -1.0849, -0.7285, 0.5219,\n",
- " -1.6536, -0.0689],\n",
- " [ 0.5114, 0.5851, 0.5771, -0.1976, -0.9273, -0.7261, 0.7161, -1.4409,\n",
- " -0.2859, -1.4682],\n",
- " [ 1.3776, 1.1774, 0.8684, 0.3978, -0.3660, 1.9135, 1.2305, -1.2047,\n",
- " -0.2161, 1.2392],\n",
- " [-0.8799, -1.7426, 0.6338, 1.0270, 1.4100, -0.7628, -0.2303, -1.1312,\n",
- " -0.4831, -0.0500],\n",
- " [ 0.9048, 0.6972, 0.6606, -1.3414, -0.1110, -0.5426, 1.4192, -1.5286,\n",
- " -0.9479, 0.0097],\n",
- " [-0.8648, -0.7923, 0.9723, 1.0398, -0.0397, -0.5886, 0.9265, -0.7319,\n",
- " 0.6881, 1.3283],\n",
- " [-1.7256, -0.0638, 1.0231, 0.0600, -0.1732, 0.9642, -0.5281, 1.3056,\n",
- " 0.4035, 0.9480],\n",
- " [-0.0728, -1.0162, -1.5728, 0.5050, -0.0502, -0.2284, 1.6427, 0.1790,\n",
- " -1.1792, -0.7706],\n",
- " [ 0.1724, 0.5413, -0.0288, -1.9327, -0.3631, 1.7576, 1.5397, 0.1154,\n",
- " -1.0803, 0.3552],\n",
- " [ 0.3824, -1.1323, 1.2554, 0.2262, 1.6234, -0.8118, 1.2303, 0.9163,\n",
- " 0.1164, 0.4109],\n",
- " [ 0.0937, 0.7837, -0.1750, 0.4796, -1.6326, -0.9668, 0.3897, -0.6633,\n",
- " -0.2551, -0.9209]])\n",
- "AlexNet(\n",
- " (features): Sequential(\n",
- " (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))\n",
- " (1): ReLU(inplace=True)\n",
- " (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
- " (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
- " (4): ReLU(inplace=True)\n",
- " (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
- " (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
- " (7): ReLU(inplace=True)\n",
- " (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
- " (9): ReLU(inplace=True)\n",
- " (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
- " (11): ReLU(inplace=True)\n",
- " (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
- " )\n",
- " (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))\n",
- " (classifier): Sequential(\n",
- " (0): Dropout(p=0.5, inplace=False)\n",
- " (1): Linear(in_features=9216, out_features=4096, bias=True)\n",
- " (2): ReLU(inplace=True)\n",
- " (3): Dropout(p=0.5, inplace=False)\n",
- " (4): Linear(in_features=4096, out_features=4096, bias=True)\n",
- " (5): ReLU(inplace=True)\n",
- " (6): Linear(in_features=4096, out_features=1000, bias=True)\n",
- " )\n",
- ")\n"
- ]
- }
- ],
- "source": [
- "import torch\n",
- "\n",
- "N, D = 14, 10\n",
- "x = torch.randn(N, D).type(torch.FloatTensor)\n",
- "print(x)\n",
- "\n",
- "from torchvision import models\n",
- "\n",
- "alexnet = models.alexnet()\n",
- "print(alexnet)"
- ]
- },
{
"cell_type": "markdown",
"id": "23f266da",
"metadata": {},
"source": [
- "## Exercise 1: CNN on CIFAR10\n",
- "\n",
- "The goal is to apply a Convolutional Neural Net (CNN) model on the CIFAR10 image dataset and test the accuracy of the model on the basis of image classification. Compare the Accuracy VS the neural network implemented during TD1.\n",
- "\n",
- "Have a look at the following documentation to be familiar with PyTorch.\n",
- "\n",
- "https://pytorch.org/tutorials/beginner/pytorch_with_examples.html\n",
- "\n",
- "https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html"
+ "## Exercise 1: CNN on CIFAR10"
]
},
{
@@ -152,12 +21,12 @@
"id": "4ba1c82d",
"metadata": {},
"source": [
- "You can test if GPU is available on your machine and thus train on it to speed up the process"
+ "Importing matplotlib before torch to avoid kernel to crash."
]
},
{
"cell_type": "code",
- "execution_count": 14,
+ "execution_count": 1,
"metadata": {},
"outputs": [
{
@@ -179,7 +48,7 @@
},
{
"cell_type": "code",
- "execution_count": 15,
+ "execution_count": 2,
"id": "6e18f2fd",
"metadata": {},
"outputs": [
@@ -193,7 +62,7 @@
],
"source": [
"import torch\n",
- "\n",
+ "from torchvision import models\n",
"\n",
"# check if CUDA is available\n",
"train_on_gpu = torch.cuda.is_available()\n",
@@ -201,7 +70,9 @@
"if not train_on_gpu:\n",
" print(\"CUDA is not available. Training on CPU ...\")\n",
"else:\n",
- " print(\"CUDA is available! Training on GPU ...\")"
+ " print(\"CUDA is available! Training on GPU ...\")\n",
+ "device = \"cpu\"\n",
+ "torch.set_default_device(device)"
]
},
{
@@ -214,7 +85,7 @@
},
{
"cell_type": "code",
- "execution_count": 16,
+ "execution_count": 3,
"id": "462666a2",
"metadata": {},
"outputs": [
@@ -290,12 +161,12 @@
"id": "58ec3903",
"metadata": {},
"source": [
- "CNN definition (this one is an example)"
+ "Defining the CNN model."
]
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": 4,
"id": "317bf070",
"metadata": {},
"outputs": [
@@ -304,12 +175,15 @@
"output_type": "stream",
"text": [
"Net(\n",
- " (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))\n",
+ " (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+ " (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+ " (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
" (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
- " (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
- " (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
- " (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
- " (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
+ " (fc1): Linear(in_features=1024, out_features=512, bias=True)\n",
+ " (dropout1): Dropout(p=0.4, inplace=False)\n",
+ " (fc2): Linear(in_features=512, out_features=64, bias=True)\n",
+ " (dropout2): Dropout(p=0.4, inplace=False)\n",
+ " (fc3): Linear(in_features=64, out_features=10, bias=True)\n",
")\n"
]
}
@@ -324,19 +198,23 @@
"class Net(nn.Module):\n",
" def __init__(self):\n",
" super(Net, self).__init__()\n",
- " self.conv1 = nn.Conv2d(3, 6, 5)\n",
- " self.pool = nn.MaxPool2d(2, 2)\n",
- " self.conv2 = nn.Conv2d(6, 16, 5)\n",
- " self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
- " self.fc2 = nn.Linear(120, 84)\n",
- " self.fc3 = nn.Linear(84, 10)\n",
+ " self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)\n",
+ " self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)\n",
+ " self.conv3 = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
+ " self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
+ " self.fc1 = nn.Linear(64 * 4 * 4, 512)\n",
+ " self.dropout1 = nn.Dropout(p = 0.4) #p = probability of an element to be equal to 0.\n",
+ " self.fc2 = nn.Linear(512, 64)\n",
+ " self.dropout2 = nn.Dropout(p = 0.4)\n",
+ " self.fc3 = nn.Linear(64, 10)\n",
"\n",
" def forward(self, x):\n",
" x = self.pool(F.relu(self.conv1(x)))\n",
" x = self.pool(F.relu(self.conv2(x)))\n",
- " x = x.view(-1, 16 * 5 * 5)\n",
- " x = F.relu(self.fc1(x))\n",
- " x = F.relu(self.fc2(x))\n",
+ " x = self.pool(F.relu(self.conv3(x)))\n",
+ " x = x.view(-1, 64*4*4)\n",
+ " x = self.dropout1(F.relu(self.fc1(x)))\n",
+ " x = self.dropout2(F.relu(self.fc2(x)))\n",
" x = self.fc3(x)\n",
" return x\n",
"\n",
@@ -354,12 +232,12 @@
"id": "a2dc4974",
"metadata": {},
"source": [
- "Loss function and training using SGD (Stochastic Gradient Descent) optimizer"
+ "Training using SGD (Stochastic Gradient Descent) optimizer."
]
},
{
"cell_type": "code",
- "execution_count": 10,
+ "execution_count": 5,
"id": "4b53f229",
"metadata": {},
"outputs": [
@@ -367,50 +245,26 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Epoch: 0 \tTraining Loss: 42.969404 \tValidation Loss: 37.030418\n",
- "Validation loss decreased (inf --> 37.030418). Saving model ...\n",
- "Epoch: 1 \tTraining Loss: 33.958170 \tValidation Loss: 31.634288\n",
- "Validation loss decreased (37.030418 --> 31.634288). Saving model ...\n",
- "Epoch: 2 \tTraining Loss: 30.212565 \tValidation Loss: 29.282247\n",
- "Validation loss decreased (31.634288 --> 29.282247). Saving model ...\n",
- "Epoch: 3 \tTraining Loss: 27.916675 \tValidation Loss: 27.083478\n",
- "Validation loss decreased (29.282247 --> 27.083478). Saving model ...\n",
- "Epoch: 4 \tTraining Loss: 26.289432 \tValidation Loss: 25.797442\n",
- "Validation loss decreased (27.083478 --> 25.797442). Saving model ...\n",
- "Epoch: 5 \tTraining Loss: 24.942089 \tValidation Loss: 24.634932\n",
- "Validation loss decreased (25.797442 --> 24.634932). Saving model ...\n",
- "Epoch: 6 \tTraining Loss: 23.799559 \tValidation Loss: 24.094232\n",
- "Validation loss decreased (24.634932 --> 24.094232). Saving model ...\n",
- "Epoch: 7 \tTraining Loss: 22.878305 \tValidation Loss: 23.288457\n",
- "Validation loss decreased (24.094232 --> 23.288457). Saving model ...\n",
- "Epoch: 8 \tTraining Loss: 22.012754 \tValidation Loss: 22.940952\n",
- "Validation loss decreased (23.288457 --> 22.940952). Saving model ...\n",
- "Epoch: 9 \tTraining Loss: 21.183604 \tValidation Loss: 22.302690\n",
- "Validation loss decreased (22.940952 --> 22.302690). Saving model ...\n",
- "Epoch: 10 \tTraining Loss: 20.494678 \tValidation Loss: 22.409808\n",
- "Epoch: 11 \tTraining Loss: 19.806578 \tValidation Loss: 22.121208\n",
- "Validation loss decreased (22.302690 --> 22.121208). Saving model ...\n",
- "Epoch: 12 \tTraining Loss: 19.129771 \tValidation Loss: 21.580307\n",
- "Validation loss decreased (22.121208 --> 21.580307). Saving model ...\n",
- "Epoch: 13 \tTraining Loss: 18.499622 \tValidation Loss: 21.994472\n",
- "Epoch: 14 \tTraining Loss: 17.904921 \tValidation Loss: 22.438062\n",
- "Epoch: 15 \tTraining Loss: 17.353172 \tValidation Loss: 21.465101\n",
- "Validation loss decreased (21.580307 --> 21.465101). Saving model ...\n",
- "Epoch: 16 \tTraining Loss: 16.767521 \tValidation Loss: 21.282284\n",
- "Validation loss decreased (21.465101 --> 21.282284). Saving model ...\n",
- "Epoch: 17 \tTraining Loss: 16.223959 \tValidation Loss: 21.613519\n",
- "Epoch: 18 \tTraining Loss: 15.659257 \tValidation Loss: 21.820777\n",
- "Epoch: 19 \tTraining Loss: 15.076396 \tValidation Loss: 21.843493\n",
- "Epoch: 20 \tTraining Loss: 14.633786 \tValidation Loss: 22.021824\n",
- "Epoch: 21 \tTraining Loss: 14.127839 \tValidation Loss: 22.893900\n",
- "Epoch: 22 \tTraining Loss: 13.673709 \tValidation Loss: 23.505658\n",
- "Epoch: 23 \tTraining Loss: 13.146696 \tValidation Loss: 23.559017\n",
- "Epoch: 24 \tTraining Loss: 12.737727 \tValidation Loss: 23.623140\n",
- "Epoch: 25 \tTraining Loss: 12.283474 \tValidation Loss: 24.595981\n",
- "Epoch: 26 \tTraining Loss: 11.867565 \tValidation Loss: 25.076360\n",
- "Epoch: 27 \tTraining Loss: 11.417464 \tValidation Loss: 26.115894\n",
- "Epoch: 28 \tTraining Loss: 10.946005 \tValidation Loss: 25.483455\n",
- "Epoch: 29 \tTraining Loss: 10.610706 \tValidation Loss: 26.264836\n"
+ "Epoch: 0 \tTraining Loss: 45.977121 \tValidation Loss: 45.558277\n",
+ "Validation loss decreased (inf --> 45.558277). Saving model ...\n",
+ "Epoch: 1 \tTraining Loss: 42.093045 \tValidation Loss: 38.728575\n",
+ "Validation loss decreased (45.558277 --> 38.728575). Saving model ...\n",
+ "Epoch: 2 \tTraining Loss: 36.241987 \tValidation Loss: 32.551345\n",
+ "Validation loss decreased (38.728575 --> 32.551345). Saving model ...\n",
+ "Epoch: 3 \tTraining Loss: 32.432337 \tValidation Loss: 30.045348\n",
+ "Validation loss decreased (32.551345 --> 30.045348). Saving model ...\n",
+ "Epoch: 4 \tTraining Loss: 30.144946 \tValidation Loss: 28.115999\n",
+ "Validation loss decreased (30.045348 --> 28.115999). Saving model ...\n",
+ "Epoch: 5 \tTraining Loss: 28.477699 \tValidation Loss: 26.730379\n",
+ "Validation loss decreased (28.115999 --> 26.730379). Saving model ...\n",
+ "Epoch: 6 \tTraining Loss: 26.876016 \tValidation Loss: 25.425593\n",
+ "Validation loss decreased (26.730379 --> 25.425593). Saving model ...\n",
+ "Epoch: 7 \tTraining Loss: 25.368054 \tValidation Loss: 23.570359\n",
+ "Validation loss decreased (25.425593 --> 23.570359). Saving model ...\n",
+ "Epoch: 8 \tTraining Loss: 23.990431 \tValidation Loss: 23.445061\n",
+ "Validation loss decreased (23.570359 --> 23.445061). Saving model ...\n",
+ "Epoch: 9 \tTraining Loss: 22.844864 \tValidation Loss: 21.625111\n",
+ "Validation loss decreased (23.445061 --> 21.625111). Saving model ...\n"
]
}
],
@@ -420,7 +274,7 @@
"criterion = nn.CrossEntropyLoss() # specify loss function\n",
"optimizer = optim.SGD(model.parameters(), lr=0.01) # specify optimizer\n",
"\n",
- "n_epochs = 30 # number of epochs to train the model\n",
+ "n_epochs = 10 # number of epochs to train the model\n",
"train_loss_list = [] # list to store loss to visualize\n",
"valid_loss_min = np.Inf # track change in validation loss\n",
"\n",
@@ -484,23 +338,32 @@
" valid_loss_min = valid_loss"
]
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Overfitting occurs for n_epoch>10 so I kept n_epoch = 10 for this model.\n",
+ "\n",
+ "For the first model, the training loss is decreasing over the epochs, and validation loss is decreasing until n_epoch = 16. If the training loss is decreasing and the validation loss is increasing at the same time, it means that the model is overfitting on the training set. We need to recover the model at the best validation loss, so we will keep n_epoch = 16."
+ ]
+ },
{
"cell_type": "markdown",
"id": "13e1df74",
"metadata": {},
"source": [
- "Does overfit occur? If so, do an early stopping."
+ "Plotting the loss over the number of epoch."
]
},
{
"cell_type": "code",
- "execution_count": 11,
+ "execution_count": 6,
"id": "d39df818",
"metadata": {},
"outputs": [
{
"data": {
- "image/png": "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",
+ "image/png": "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",
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
@@ -510,8 +373,6 @@
}
],
"source": [
- "import matplotlib.pyplot as plt\n",
- "\n",
"plt.plot(range(n_epochs), train_loss_list)\n",
"plt.xlabel(\"Epoch\")\n",
"plt.ylabel(\"Loss\")\n",
@@ -524,12 +385,12 @@
"id": "11df8fd4",
"metadata": {},
"source": [
- "Now loading the model with the lowest validation loss value\n"
+ "Computing the accuracy of the new model.\n"
]
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": 7,
"id": "e93efdfc",
"metadata": {},
"outputs": [
@@ -537,101 +398,104 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Test Loss: 37.275009\n",
+ "Test Loss: 21.197588\n",
"\n",
- "Test Accuracy of airplane: 43% (437/1000)\n",
- "Test Accuracy of automobile: 27% (272/1000)\n",
- "Test Accuracy of bird: 1% (14/1000)\n",
- "Test Accuracy of cat: 6% (64/1000)\n",
- "Test Accuracy of deer: 26% (263/1000)\n",
- "Test Accuracy of dog: 20% (203/1000)\n",
- "Test Accuracy of frog: 57% (574/1000)\n",
- "Test Accuracy of horse: 59% (598/1000)\n",
- "Test Accuracy of ship: 34% (345/1000)\n",
- "Test Accuracy of truck: 47% (470/1000)\n",
+ "Test Accuracy of airplane: 73% (736/1000)\n",
+ "Test Accuracy of automobile: 75% (751/1000)\n",
+ "Test Accuracy of bird: 50% (507/1000)\n",
+ "Test Accuracy of cat: 40% (406/1000)\n",
+ "Test Accuracy of deer: 43% (437/1000)\n",
+ "Test Accuracy of dog: 51% (510/1000)\n",
+ "Test Accuracy of frog: 80% (802/1000)\n",
+ "Test Accuracy of horse: 71% (711/1000)\n",
+ "Test Accuracy of ship: 70% (702/1000)\n",
+ "Test Accuracy of truck: 67% (678/1000)\n",
"\n",
- "Test Accuracy (Overall): 32% (3240/10000)\n"
+ "Test Accuracy (Overall): 62% (6240/10000)\n"
]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "([0.736, 0.751, 0.507, 0.406, 0.437, 0.51, 0.802, 0.711, 0.702, 0.678], 0.624)"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
}
],
"source": [
"model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n",
"\n",
- "# track test loss\n",
- "test_loss = 0.0\n",
- "class_correct = list(0.0 for i in range(10))\n",
- "class_total = list(0.0 for i in range(10))\n",
- "\n",
- "model.eval()\n",
- "# iterate over test data\n",
- "for data, target in test_loader:\n",
- " # move tensors to GPU if CUDA is available\n",
- " if train_on_gpu:\n",
- " data, target = data.cuda(), target.cuda()\n",
- " # forward pass: compute predicted outputs by passing inputs to the model\n",
- " output = model(data)\n",
- " # calculate the batch loss\n",
- " loss = criterion(output, target)\n",
- " # update test loss\n",
- " test_loss += loss.item() * data.size(0)\n",
- " # convert output probabilities to predicted class\n",
- " _, pred = torch.max(output, 1)\n",
- " # compare predictions to true label\n",
- " correct_tensor = pred.eq(target.data.view_as(pred))\n",
- " correct = (\n",
- " np.squeeze(correct_tensor.numpy())\n",
- " if not train_on_gpu\n",
- " else np.squeeze(correct_tensor.cpu().numpy())\n",
- " )\n",
- " # calculate test accuracy for each object class\n",
- " for i in range(batch_size):\n",
- " label = target.data[i]\n",
- " class_correct[label] += correct[i].item()\n",
- " class_total[label] += 1\n",
- "\n",
- "# average test loss\n",
- "test_loss = test_loss / len(test_loader)\n",
- "print(\"Test Loss: {:.6f}\\n\".format(test_loss))\n",
- "\n",
- "for i in range(10):\n",
- " if class_total[i] > 0:\n",
- " print(\n",
- " \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n",
- " % (\n",
- " classes[i],\n",
- " 100 * class_correct[i] / class_total[i],\n",
- " np.sum(class_correct[i]),\n",
- " np.sum(class_total[i]),\n",
+ "def test_accuracy(model_to_evaluate):\n",
+ " \"\"\"\n",
+ " Return the percentage of True Positive data of each class for a model.\n",
+ " \"\"\"\n",
+ " # track test loss\n",
+ " test_loss = 0.0\n",
+ " class_correct = list(0.0 for i in range(10))\n",
+ " class_total = list(0.0 for i in range(10))\n",
+ "\n",
+ " model_to_evaluate.eval()\n",
+ " # iterate over test data\n",
+ " for data, target in test_loader:\n",
+ " # move tensors to GPU if CUDA is available\n",
+ " if train_on_gpu:\n",
+ " data, target = data.cuda(), target.cuda()\n",
+ " # forward pass: compute predicted outputs by passing inputs to the model\n",
+ " output = model_to_evaluate(data)\n",
+ " # calculate the batch loss\n",
+ " loss = criterion(output, target)\n",
+ " # update test loss\n",
+ " test_loss += loss.item() * data.size(0)\n",
+ " # convert output probabilities to predicted class\n",
+ " _, pred = torch.max(output, 1)\n",
+ " # compare predictions to true label\n",
+ " correct_tensor = pred.eq(target.data.view_as(pred))\n",
+ " correct = (\n",
+ " np.squeeze(correct_tensor.numpy())\n",
+ " if not train_on_gpu\n",
+ " else np.squeeze(correct_tensor.cpu().numpy())\n",
+ " )\n",
+ " # calculate test accuracy for each object class\n",
+ " for i in range(batch_size):\n",
+ " label = target.data[i]\n",
+ " class_correct[label] += correct[i].item()\n",
+ " class_total[label] += 1\n",
+ "\n",
+ " # average test loss\n",
+ " test_loss = test_loss / len(test_loader)\n",
+ " print(\"Test Loss: {:.6f}\\n\".format(test_loss))\n",
+ " percentage_true_positive = []\n",
+ " for i in range(10):\n",
+ " \n",
+ " if class_total[i] > 0:\n",
+ " print(\n",
+ " \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n",
+ " % (\n",
+ " classes[i],\n",
+ " 100 * class_correct[i] / class_total[i],\n",
+ " np.sum(class_correct[i]),\n",
+ " np.sum(class_total[i]),\n",
+ " )\n",
" )\n",
+ " percentage_true_positive.append(np.sum(class_correct[i]) / class_total[i])\n",
+ " else:\n",
+ " print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n",
+ "\n",
+ " print(\n",
+ " \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n",
+ " % (\n",
+ " 100.0 * np.sum(class_correct) / np.sum(class_total),\n",
+ " np.sum(class_correct),\n",
+ " np.sum(class_total),\n",
" )\n",
- " else:\n",
- " print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n",
- "\n",
- "print(\n",
- " \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n",
- " % (\n",
- " 100.0 * np.sum(class_correct) / np.sum(class_total),\n",
- " np.sum(class_correct),\n",
- " np.sum(class_total),\n",
" )\n",
- ")"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "944991a2",
- "metadata": {},
- "source": [
- "Build a new network with the following structure.\n",
- "\n",
- "- It has 3 convolutional layers of kernel size 3 and padding of 1.\n",
- "- The first convolutional layer must output 16 channels, the second 32 and the third 64.\n",
- "- At each convolutional layer output, we apply a ReLU activation then a MaxPool with kernel size of 2.\n",
- "- Then, three fully connected layers, the first two being followed by a ReLU activation and a dropout whose value you will suggest.\n",
- "- The first fully connected layer will have an output size of 512.\n",
- "- The second fully connected layer will have an output size of 64.\n",
+ " percentage_overall = np.sum(class_correct) / np.sum(class_total)\n",
+ " return percentage_true_positive, percentage_overall\n",
"\n",
- "Compare the results obtained with this new network to those obtained previously."
+ "test_accuracy(model)"
]
},
{
@@ -639,19 +503,12 @@
"id": "bc381cf4",
"metadata": {},
"source": [
- "## Exercise 2: Quantization: try to compress the CNN to save space\n",
- "\n",
- "Quantization doc is available from https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic\n",
- " \n",
- "The Exercise is to quantize post training the above CNN model. Compare the size reduction and the impact on the classification accuracy \n",
- "\n",
- "\n",
- "The size of the model is simply the size of the file."
+ "## Exercise 2: Quantization: try to compress the CNN to save space"
]
},
{
"cell_type": "code",
- "execution_count": 10,
+ "execution_count": 8,
"id": "ef623c26",
"metadata": {},
"outputs": [
@@ -659,16 +516,16 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "model: fp32 \t Size (KB): 251.278\n"
+ "model: fp32 \t Size (KB): 2330.946\n"
]
},
{
"data": {
"text/plain": [
- "251278"
+ "2330946"
]
},
- "execution_count": 10,
+ "execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
@@ -698,7 +555,7 @@
},
{
"cell_type": "code",
- "execution_count": 11,
+ "execution_count": 9,
"id": "c4c65d4b",
"metadata": {},
"outputs": [
@@ -706,16 +563,16 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "model: int8 \t Size (KB): 76.522\n"
+ "model: int8 \t Size (KB): 659.806\n"
]
},
{
"data": {
"text/plain": [
- "76522"
+ "659806"
]
},
- "execution_count": 11,
+ "execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
@@ -736,17 +593,79 @@
"For each class, compare the classification test accuracy of the initial model and the quantized model. Also give the overall test accuracy for both models."
]
},
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Test Loss: 21.197588\n",
+ "\n",
+ "Test Accuracy of airplane: 73% (736/1000)\n",
+ "Test Accuracy of automobile: 75% (751/1000)\n",
+ "Test Accuracy of bird: 50% (507/1000)\n",
+ "Test Accuracy of cat: 40% (406/1000)\n",
+ "Test Accuracy of deer: 43% (437/1000)\n",
+ "Test Accuracy of dog: 51% (510/1000)\n",
+ "Test Accuracy of frog: 80% (802/1000)\n",
+ "Test Accuracy of horse: 71% (711/1000)\n",
+ "Test Accuracy of ship: 70% (702/1000)\n",
+ "Test Accuracy of truck: 67% (678/1000)\n",
+ "\n",
+ "Test Accuracy (Overall): 62% (6240/10000)\n",
+ "Test Loss: 21.195632\n",
+ "\n",
+ "Test Accuracy of airplane: 73% (734/1000)\n",
+ "Test Accuracy of automobile: 74% (748/1000)\n",
+ "Test Accuracy of bird: 50% (509/1000)\n",
+ "Test Accuracy of cat: 41% (411/1000)\n",
+ "Test Accuracy of deer: 43% (438/1000)\n",
+ "Test Accuracy of dog: 50% (507/1000)\n",
+ "Test Accuracy of frog: 80% (802/1000)\n",
+ "Test Accuracy of horse: 71% (711/1000)\n",
+ "Test Accuracy of ship: 70% (704/1000)\n",
+ "Test Accuracy of truck: 67% (679/1000)\n",
+ "\n",
+ "Test Accuracy (Overall): 62% (6243/10000)\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 640x480 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "percentage_each_class_initial_model, percentage_overall_initial_model = test_accuracy(model)\n",
+ "percentage_each_class_quantized_model, percentage_overall_quantized_model = test_accuracy(quantized_model)\n",
+ "x = [1,2,3,4,5,6,7,8,9,10]\n",
+ "plt.scatter(x, percentage_each_class_initial_model, color='r', label=\"initial model\")\n",
+ "plt.scatter(x, percentage_each_class_quantized_model, color='b', label=\"quantized model\")\n",
+ "plt.xlabel(\"Classes\")\n",
+ "plt.ylabel(\"Percentage of true positive for each model\")\n",
+ "plt.title(\"comparis between itinial and quantized model\")\n",
+ "plt.xticks(x, x)\n",
+ "plt.legend()\n",
+ "plt.show()\n"
+ ]
+ },
{
"cell_type": "markdown",
- "id": "a0a34b90",
"metadata": {},
"source": [
- "Try training aware quantization to mitigate the impact on the accuracy (doc available here https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic)"
+ "This is the same accuracy for the two models."
]
},
{
"cell_type": "markdown",
- "id": "201470f9",
"metadata": {},
"source": [
"## Exercise 3: working with pre-trained models.\n",
@@ -757,8 +676,7 @@
},
{
"cell_type": "code",
- "execution_count": 19,
- "id": "b4d13080",
+ "execution_count": 11,
"metadata": {},
"outputs": [
{
@@ -768,50 +686,25 @@
"c:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torchvision\\models\\_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
" warnings.warn(\n",
"c:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
- " warnings.warn(msg)\n",
- "Downloading: \"https://download.pytorch.org/models/resnet50-0676ba61.pth\" to C:\\Users\\Malo/.cache\\torch\\hub\\checkpoints\\resnet50-0676ba61.pth\n"
+ " warnings.warn(msg)\n"
]
},
{
- "ename": "URLError",
- "evalue": "<urlopen error [Errno 11001] getaddrinfo failed>",
- "output_type": "error",
- "traceback": [
- "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
- "\u001b[1;31mgaierror\u001b[0m Traceback (most recent call last)",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\urllib\\request.py:1348\u001b[0m, in \u001b[0;36mAbstractHTTPHandler.do_open\u001b[1;34m(self, http_class, req, **http_conn_args)\u001b[0m\n\u001b[0;32m 1347\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m-> 1348\u001b[0m h\u001b[39m.\u001b[39mrequest(req\u001b[39m.\u001b[39mget_method(), req\u001b[39m.\u001b[39mselector, req\u001b[39m.\u001b[39mdata, headers,\n\u001b[0;32m 1349\u001b[0m encode_chunked\u001b[39m=\u001b[39mreq\u001b[39m.\u001b[39mhas_header(\u001b[39m'\u001b[39m\u001b[39mTransfer-encoding\u001b[39m\u001b[39m'\u001b[39m))\n\u001b[0;32m 1350\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mOSError\u001b[39;00m \u001b[39mas\u001b[39;00m err: \u001b[39m# timeout error\u001b[39;00m\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\http\\client.py:1286\u001b[0m, in \u001b[0;36mHTTPConnection.request\u001b[1;34m(self, method, url, body, headers, encode_chunked)\u001b[0m\n\u001b[0;32m 1285\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Send a complete request to the server.\"\"\"\u001b[39;00m\n\u001b[1;32m-> 1286\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_send_request(method, url, body, headers, encode_chunked)\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\http\\client.py:1332\u001b[0m, in \u001b[0;36mHTTPConnection._send_request\u001b[1;34m(self, method, url, body, headers, encode_chunked)\u001b[0m\n\u001b[0;32m 1331\u001b[0m body \u001b[39m=\u001b[39m _encode(body, \u001b[39m'\u001b[39m\u001b[39mbody\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m-> 1332\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mendheaders(body, encode_chunked\u001b[39m=\u001b[39mencode_chunked)\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\http\\client.py:1281\u001b[0m, in \u001b[0;36mHTTPConnection.endheaders\u001b[1;34m(self, message_body, encode_chunked)\u001b[0m\n\u001b[0;32m 1280\u001b[0m \u001b[39mraise\u001b[39;00m CannotSendHeader()\n\u001b[1;32m-> 1281\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_send_output(message_body, encode_chunked\u001b[39m=\u001b[39mencode_chunked)\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\http\\client.py:1041\u001b[0m, in \u001b[0;36mHTTPConnection._send_output\u001b[1;34m(self, message_body, encode_chunked)\u001b[0m\n\u001b[0;32m 1040\u001b[0m \u001b[39mdel\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_buffer[:]\n\u001b[1;32m-> 1041\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msend(msg)\n\u001b[0;32m 1043\u001b[0m \u001b[39mif\u001b[39;00m message_body \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 1044\u001b[0m \n\u001b[0;32m 1045\u001b[0m \u001b[39m# create a consistent interface to message_body\u001b[39;00m\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\http\\client.py:979\u001b[0m, in \u001b[0;36mHTTPConnection.send\u001b[1;34m(self, data)\u001b[0m\n\u001b[0;32m 978\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mauto_open:\n\u001b[1;32m--> 979\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mconnect()\n\u001b[0;32m 980\u001b[0m \u001b[39melse\u001b[39;00m:\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\http\\client.py:1451\u001b[0m, in \u001b[0;36mHTTPSConnection.connect\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 1449\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mConnect to a host on a given (SSL) port.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m-> 1451\u001b[0m \u001b[39msuper\u001b[39m()\u001b[39m.\u001b[39mconnect()\n\u001b[0;32m 1453\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_tunnel_host:\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\http\\client.py:945\u001b[0m, in \u001b[0;36mHTTPConnection.connect\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 944\u001b[0m sys\u001b[39m.\u001b[39maudit(\u001b[39m\"\u001b[39m\u001b[39mhttp.client.connect\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mself\u001b[39m, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhost, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mport)\n\u001b[1;32m--> 945\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msock \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_create_connection(\n\u001b[0;32m 946\u001b[0m (\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhost,\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mport), \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtimeout, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msource_address)\n\u001b[0;32m 947\u001b[0m \u001b[39m# Might fail in OSs that don't implement TCP_NODELAY\u001b[39;00m\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\socket.py:827\u001b[0m, in \u001b[0;36mcreate_connection\u001b[1;34m(address, timeout, source_address, all_errors)\u001b[0m\n\u001b[0;32m 826\u001b[0m exceptions \u001b[39m=\u001b[39m []\n\u001b[1;32m--> 827\u001b[0m \u001b[39mfor\u001b[39;00m res \u001b[39min\u001b[39;00m getaddrinfo(host, port, \u001b[39m0\u001b[39m, SOCK_STREAM):\n\u001b[0;32m 828\u001b[0m af, socktype, proto, canonname, sa \u001b[39m=\u001b[39m res\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\socket.py:962\u001b[0m, in \u001b[0;36mgetaddrinfo\u001b[1;34m(host, port, family, type, proto, flags)\u001b[0m\n\u001b[0;32m 961\u001b[0m addrlist \u001b[39m=\u001b[39m []\n\u001b[1;32m--> 962\u001b[0m \u001b[39mfor\u001b[39;00m res \u001b[39min\u001b[39;00m _socket\u001b[39m.\u001b[39mgetaddrinfo(host, port, family, \u001b[39mtype\u001b[39m, proto, flags):\n\u001b[0;32m 963\u001b[0m af, socktype, proto, canonname, sa \u001b[39m=\u001b[39m res\n",
- "\u001b[1;31mgaierror\u001b[0m: [Errno 11001] getaddrinfo failed",
- "\nDuring handling of the above exception, another exception occurred:\n",
- "\u001b[1;31mURLError\u001b[0m Traceback (most recent call last)",
- "\u001b[1;32mc:\\Users\\Malo\\Documents\\Python Scripts\\td2-deeplearning\\TD2 Deep Learning.ipynb Cell 29\u001b[0m line \u001b[0;36m3\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/TD2%20Deep%20Learning.ipynb#X36sZmlsZQ%3D%3D?line=29'>30</a>\u001b[0m image \u001b[39m=\u001b[39m data_transform(image)\u001b[39m.\u001b[39munsqueeze(\u001b[39m0\u001b[39m)\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/TD2%20Deep%20Learning.ipynb#X36sZmlsZQ%3D%3D?line=31'>32</a>\u001b[0m \u001b[39m# Download the model if it's not there already. It will take a bit on the first run, after that it's fast\u001b[39;00m\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/TD2%20Deep%20Learning.ipynb#X36sZmlsZQ%3D%3D?line=32'>33</a>\u001b[0m model \u001b[39m=\u001b[39m models\u001b[39m.\u001b[39mresnet50(pretrained\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/TD2%20Deep%20Learning.ipynb#X36sZmlsZQ%3D%3D?line=33'>34</a>\u001b[0m \u001b[39m# Send the model to the GPU\u001b[39;00m\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/TD2%20Deep%20Learning.ipynb#X36sZmlsZQ%3D%3D?line=34'>35</a>\u001b[0m \u001b[39m# model.cuda()\u001b[39;00m\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/TD2%20Deep%20Learning.ipynb#X36sZmlsZQ%3D%3D?line=35'>36</a>\u001b[0m \u001b[39m# Set layers such as dropout and batchnorm in evaluation mode\u001b[39;00m\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/TD2%20Deep%20Learning.ipynb#X36sZmlsZQ%3D%3D?line=36'>37</a>\u001b[0m model\u001b[39m.\u001b[39meval()\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torchvision\\models\\_utils.py:142\u001b[0m, in \u001b[0;36mkwonly_to_pos_or_kw.<locals>.wrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 135\u001b[0m warnings\u001b[39m.\u001b[39mwarn(\n\u001b[0;32m 136\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mUsing \u001b[39m\u001b[39m{\u001b[39;00msequence_to_str(\u001b[39mtuple\u001b[39m(keyword_only_kwargs\u001b[39m.\u001b[39mkeys()),\u001b[39m \u001b[39mseparate_last\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mand \u001b[39m\u001b[39m'\u001b[39m)\u001b[39m}\u001b[39;00m\u001b[39m as positional \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m 137\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mparameter(s) is deprecated since 0.13 and may be removed in the future. Please use keyword parameter(s) \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m 138\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39minstead.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m 139\u001b[0m )\n\u001b[0;32m 140\u001b[0m kwargs\u001b[39m.\u001b[39mupdate(keyword_only_kwargs)\n\u001b[1;32m--> 142\u001b[0m \u001b[39mreturn\u001b[39;00m fn(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torchvision\\models\\_utils.py:228\u001b[0m, in \u001b[0;36mhandle_legacy_interface.<locals>.outer_wrapper.<locals>.inner_wrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 225\u001b[0m \u001b[39mdel\u001b[39;00m kwargs[pretrained_param]\n\u001b[0;32m 226\u001b[0m kwargs[weights_param] \u001b[39m=\u001b[39m default_weights_arg\n\u001b[1;32m--> 228\u001b[0m \u001b[39mreturn\u001b[39;00m builder(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torchvision\\models\\resnet.py:763\u001b[0m, in \u001b[0;36mresnet50\u001b[1;34m(weights, progress, **kwargs)\u001b[0m\n\u001b[0;32m 737\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"ResNet-50 from `Deep Residual Learning for Image Recognition <https://arxiv.org/abs/1512.03385>`__.\u001b[39;00m\n\u001b[0;32m 738\u001b[0m \n\u001b[0;32m 739\u001b[0m \u001b[39m.. note::\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 759\u001b[0m \u001b[39m :members:\u001b[39;00m\n\u001b[0;32m 760\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m 761\u001b[0m weights \u001b[39m=\u001b[39m ResNet50_Weights\u001b[39m.\u001b[39mverify(weights)\n\u001b[1;32m--> 763\u001b[0m \u001b[39mreturn\u001b[39;00m _resnet(Bottleneck, [\u001b[39m3\u001b[39m, \u001b[39m4\u001b[39m, \u001b[39m6\u001b[39m, \u001b[39m3\u001b[39m], weights, progress, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torchvision\\models\\resnet.py:301\u001b[0m, in \u001b[0;36m_resnet\u001b[1;34m(block, layers, weights, progress, **kwargs)\u001b[0m\n\u001b[0;32m 298\u001b[0m model \u001b[39m=\u001b[39m ResNet(block, layers, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[0;32m 300\u001b[0m \u001b[39mif\u001b[39;00m weights \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m--> 301\u001b[0m model\u001b[39m.\u001b[39mload_state_dict(weights\u001b[39m.\u001b[39mget_state_dict(progress\u001b[39m=\u001b[39mprogress, check_hash\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m))\n\u001b[0;32m 303\u001b[0m \u001b[39mreturn\u001b[39;00m model\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torchvision\\models\\_api.py:90\u001b[0m, in \u001b[0;36mWeightsEnum.get_state_dict\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 89\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_state_dict\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39margs: Any, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs: Any) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m Mapping[\u001b[39mstr\u001b[39m, Any]:\n\u001b[1;32m---> 90\u001b[0m \u001b[39mreturn\u001b[39;00m load_state_dict_from_url(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39murl, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torch\\hub.py:766\u001b[0m, in \u001b[0;36mload_state_dict_from_url\u001b[1;34m(url, model_dir, map_location, progress, check_hash, file_name, weights_only)\u001b[0m\n\u001b[0;32m 764\u001b[0m r \u001b[39m=\u001b[39m HASH_REGEX\u001b[39m.\u001b[39msearch(filename) \u001b[39m# r is Optional[Match[str]]\u001b[39;00m\n\u001b[0;32m 765\u001b[0m hash_prefix \u001b[39m=\u001b[39m r\u001b[39m.\u001b[39mgroup(\u001b[39m1\u001b[39m) \u001b[39mif\u001b[39;00m r \u001b[39melse\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m--> 766\u001b[0m download_url_to_file(url, cached_file, hash_prefix, progress\u001b[39m=\u001b[39mprogress)\n\u001b[0;32m 768\u001b[0m \u001b[39mif\u001b[39;00m _is_legacy_zip_format(cached_file):\n\u001b[0;32m 769\u001b[0m \u001b[39mreturn\u001b[39;00m _legacy_zip_load(cached_file, model_dir, map_location, weights_only)\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torch\\hub.py:620\u001b[0m, in \u001b[0;36mdownload_url_to_file\u001b[1;34m(url, dst, hash_prefix, progress)\u001b[0m\n\u001b[0;32m 618\u001b[0m file_size \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m 619\u001b[0m req \u001b[39m=\u001b[39m Request(url, headers\u001b[39m=\u001b[39m{\u001b[39m\"\u001b[39m\u001b[39mUser-Agent\u001b[39m\u001b[39m\"\u001b[39m: \u001b[39m\"\u001b[39m\u001b[39mtorch.hub\u001b[39m\u001b[39m\"\u001b[39m})\n\u001b[1;32m--> 620\u001b[0m u \u001b[39m=\u001b[39m urlopen(req)\n\u001b[0;32m 621\u001b[0m meta \u001b[39m=\u001b[39m u\u001b[39m.\u001b[39minfo()\n\u001b[0;32m 622\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mhasattr\u001b[39m(meta, \u001b[39m'\u001b[39m\u001b[39mgetheaders\u001b[39m\u001b[39m'\u001b[39m):\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\urllib\\request.py:216\u001b[0m, in \u001b[0;36murlopen\u001b[1;34m(url, data, timeout, cafile, capath, cadefault, context)\u001b[0m\n\u001b[0;32m 214\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m 215\u001b[0m opener \u001b[39m=\u001b[39m _opener\n\u001b[1;32m--> 216\u001b[0m \u001b[39mreturn\u001b[39;00m opener\u001b[39m.\u001b[39mopen(url, data, timeout)\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\urllib\\request.py:519\u001b[0m, in \u001b[0;36mOpenerDirector.open\u001b[1;34m(self, fullurl, data, timeout)\u001b[0m\n\u001b[0;32m 516\u001b[0m req \u001b[39m=\u001b[39m meth(req)\n\u001b[0;32m 518\u001b[0m sys\u001b[39m.\u001b[39maudit(\u001b[39m'\u001b[39m\u001b[39murllib.Request\u001b[39m\u001b[39m'\u001b[39m, req\u001b[39m.\u001b[39mfull_url, req\u001b[39m.\u001b[39mdata, req\u001b[39m.\u001b[39mheaders, req\u001b[39m.\u001b[39mget_method())\n\u001b[1;32m--> 519\u001b[0m response \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_open(req, data)\n\u001b[0;32m 521\u001b[0m \u001b[39m# post-process response\u001b[39;00m\n\u001b[0;32m 522\u001b[0m meth_name \u001b[39m=\u001b[39m protocol\u001b[39m+\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m_response\u001b[39m\u001b[39m\"\u001b[39m\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\urllib\\request.py:536\u001b[0m, in \u001b[0;36mOpenerDirector._open\u001b[1;34m(self, req, data)\u001b[0m\n\u001b[0;32m 533\u001b[0m \u001b[39mreturn\u001b[39;00m result\n\u001b[0;32m 535\u001b[0m protocol \u001b[39m=\u001b[39m req\u001b[39m.\u001b[39mtype\n\u001b[1;32m--> 536\u001b[0m result \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_call_chain(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mhandle_open, protocol, protocol \u001b[39m+\u001b[39m\n\u001b[0;32m 537\u001b[0m \u001b[39m'\u001b[39m\u001b[39m_open\u001b[39m\u001b[39m'\u001b[39m, req)\n\u001b[0;32m 538\u001b[0m \u001b[39mif\u001b[39;00m result:\n\u001b[0;32m 539\u001b[0m \u001b[39mreturn\u001b[39;00m result\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\urllib\\request.py:496\u001b[0m, in \u001b[0;36mOpenerDirector._call_chain\u001b[1;34m(self, chain, kind, meth_name, *args)\u001b[0m\n\u001b[0;32m 494\u001b[0m \u001b[39mfor\u001b[39;00m handler \u001b[39min\u001b[39;00m handlers:\n\u001b[0;32m 495\u001b[0m func \u001b[39m=\u001b[39m \u001b[39mgetattr\u001b[39m(handler, meth_name)\n\u001b[1;32m--> 496\u001b[0m result \u001b[39m=\u001b[39m func(\u001b[39m*\u001b[39margs)\n\u001b[0;32m 497\u001b[0m \u001b[39mif\u001b[39;00m result \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 498\u001b[0m \u001b[39mreturn\u001b[39;00m result\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\urllib\\request.py:1391\u001b[0m, in \u001b[0;36mHTTPSHandler.https_open\u001b[1;34m(self, req)\u001b[0m\n\u001b[0;32m 1390\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mhttps_open\u001b[39m(\u001b[39mself\u001b[39m, req):\n\u001b[1;32m-> 1391\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdo_open(http\u001b[39m.\u001b[39mclient\u001b[39m.\u001b[39mHTTPSConnection, req,\n\u001b[0;32m 1392\u001b[0m context\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_context, check_hostname\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_check_hostname)\n",
- "File \u001b[1;32mc:\\Users\\Malo\\anaconda3\\Lib\\urllib\\request.py:1351\u001b[0m, in \u001b[0;36mAbstractHTTPHandler.do_open\u001b[1;34m(self, http_class, req, **http_conn_args)\u001b[0m\n\u001b[0;32m 1348\u001b[0m h\u001b[39m.\u001b[39mrequest(req\u001b[39m.\u001b[39mget_method(), req\u001b[39m.\u001b[39mselector, req\u001b[39m.\u001b[39mdata, headers,\n\u001b[0;32m 1349\u001b[0m encode_chunked\u001b[39m=\u001b[39mreq\u001b[39m.\u001b[39mhas_header(\u001b[39m'\u001b[39m\u001b[39mTransfer-encoding\u001b[39m\u001b[39m'\u001b[39m))\n\u001b[0;32m 1350\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mOSError\u001b[39;00m \u001b[39mas\u001b[39;00m err: \u001b[39m# timeout error\u001b[39;00m\n\u001b[1;32m-> 1351\u001b[0m \u001b[39mraise\u001b[39;00m URLError(err)\n\u001b[0;32m 1352\u001b[0m r \u001b[39m=\u001b[39m h\u001b[39m.\u001b[39mgetresponse()\n\u001b[0;32m 1353\u001b[0m \u001b[39mexcept\u001b[39;00m:\n",
- "\u001b[1;31mURLError\u001b[0m: <urlopen error [Errno 11001] getaddrinfo failed>"
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Predicted class is: Golden Retriever\n",
+ "Predicted class is: Labrador Retriever\n",
+ "Predicted class is: tabby cat\n",
+ "Predicted class is: goldfinch\n",
+ "Predicted class is: chimpanzee\n",
+ "Predicted class is: dugong\n",
+ "Predicted class is: Nile crocodile\n"
]
},
{
"data": {
- "image/png": "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",
+ "image/png": "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",
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
@@ -822,52 +715,60 @@
],
"source": [
"import json\n",
+ "import matplotlib.pyplot as plt\n",
"from PIL import Image\n",
+ "from torchvision import transforms, models\n",
"\n",
"# Choose an image to pass through the model\n",
- "test_image = \"dog.png\"\n",
+ "tests_image = [\"dog.png\", \"dog2.jpg\", \"cat.jpg\", \"bird.jpg\", \"monkey.jpg\", \"whale.jpg\", \"crocodile.jpg\"] \n",
"\n",
- "# Configure matplotlib for pretty inline plots\n",
- "#%matplotlib inline\n",
- "#%config InlineBackend.figure_format = 'retina'\n",
"\n",
"# Prepare the labels\n",
"with open(\"imagenet-simple-labels.json\") as f:\n",
" labels = json.load(f)\n",
"\n",
- "# First prepare the transformations: resize the image to what the model was trained on and convert it to a tensor\n",
- "data_transform = transforms.Compose(\n",
- " [\n",
- " transforms.Resize((224, 224)),\n",
- " transforms.ToTensor(),\n",
- " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
- " ]\n",
- ")\n",
- "# Load the image\n",
+ "def transform_data(path_image_to_transform:str):\n",
+ " \"\"\"\n",
+ " Transforms the raw image \".png\" into an entry in order to be\n",
+ " in the same format of what the pre-trained model was trained.\n",
+ " \"\"\"\n",
"\n",
- "image = Image.open(test_image)\n",
- "plt.imshow(image), plt.xticks([]), plt.yticks([])\n",
+ " data_transform = transforms.Compose(\n",
+ " [\n",
+ " transforms.Resize((224, 224)),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
+ " ]\n",
+ " )\n",
+ "\n",
+ " # Load the image\n",
+ " transformed_image = Image.open(path_image_to_transform)\n",
+ " plt.imshow(transformed_image), plt.xticks([]), plt.yticks([])\n",
"\n",
- "# Now apply the transformation, expand the batch dimension, and send the image to the GPU\n",
- "# image = data_transform(image).unsqueeze(0).cuda()\n",
- "image = data_transform(image).unsqueeze(0)\n",
+ " # Now apply the transformation, expand the batch dimension, and send the image to the GPU\n",
+ " transformed_image = data_transform(transformed_image).unsqueeze(0)\n",
+ " return transformed_image\n",
"\n",
- "# Download the model if it's not there already. It will take a bit on the first run, after that it's fast\n",
"model = models.resnet50(pretrained=True)\n",
- "# Send the model to the GPU\n",
- "# model.cuda()\n",
- "# Set layers such as dropout and batchnorm in evaluation mode\n",
+ "\n",
"model.eval()\n",
"\n",
"# Get the 1000-dimensional model output\n",
- "out = model(image)\n",
- "# Find the predicted class\n",
- "print(\"Predicted class is: {}\".format(labels[out.argmax()]))"
+ "for image_name in tests_image:\n",
+ " out = model(transform_data(image_name))\n",
+ " # Find the predicted class\n",
+ " print(\"Predicted class is: {}\".format(labels[out.argmax()]))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The model seems good because it's right for 6 images. However, it fails to detect the whale."
]
},
{
"cell_type": "markdown",
- "id": "184cfceb",
"metadata": {},
"source": [
"Experiments:\n",
@@ -881,26 +782,108 @@
" \n"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "model: fp32 \t Size (KB): 102523.238\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "102523238"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import os\n",
+ "\n",
+ "\n",
+ "def print_size_of_model(model, label=\"\"):\n",
+ " torch.save(model.state_dict(), \"temp.p\")\n",
+ " size = os.path.getsize(\"temp.p\")\n",
+ " print(\"model: \", label, \" \\t\", \"Size (KB):\", size / 1e3)\n",
+ " os.remove(\"temp.p\")\n",
+ " return size\n",
+ "\n",
+ "\n",
+ "print_size_of_model(model, \"fp32\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "model: int8 \t Size (KB): 96379.996\n",
+ "Predicted class is: Golden Retriever\n",
+ "Predicted class is: Labrador Retriever\n",
+ "Predicted class is: tabby cat\n",
+ "Predicted class is: goldfinch\n",
+ "Predicted class is: chimpanzee\n",
+ "Predicted class is: dugong\n",
+ "Predicted class is: Nile crocodile\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgEAAAGFCAYAAABkLyAyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz92bIkSXIlCB4WEV1sudc9IiMBJFDVTfNH8x3zJ/MJ8zTv8zfdRPXSQ/PQU0QoAJkR7ncxM1VZ54GZRUT12vUlEokaIrgGWZhfMzVVUdmY+TDzYSqlFPw4fhw/jh/Hj+PH8eP4T3eY/9kN+HH8OH4cP44fx4/jx/E/5/ihBPw4fhw/jh/Hj+PH8Z/0+KEE/Dh+HD+OH8eP48fxn/T4oQT8OH4cP44fx4/jx/Gf9PihBPw4fhw/jh/Hj+PH8Z/0+KEE/Dh+HD+OH8eP48fxn/T4oQT8OH4cP44fx4/jx/Gf9HDfclLOGf/8z/+Mh4cHENHfuk0/jh/Hj+PH8eP4cfw4fudRSsHLywv+8R//EcZ82db/JiXgn//5n/Ff/+t//Xdp3I/jx/Hj+HH8OH4cP46//fHf//t/x3/5L//li+d8kxLw8PAAAPi//9/+rzjOI4gAay2MMTCG36218hnJ5wZEBAIh5YSemPDev+/xFpZS6vUAVBSCiOq1iQjQv+Wlh7arv14pBTln5Jzr3yVnFPDnfZv4p9I+lNrG+rvda38fPfp2b9p/53MAsMbAWPvmfO1TK9/VPia0vnjnKKWgYNvXe7LIUoCSafv3O8/aP6O+D8Ow6e/vOawFXDcbU07IOcN7jxgjQghIKSGlBAD12YdhwDiO+Pnnn/l3KaHkjCTjW/sP9ObaMUagALObYMhCu4/k2oCp/QwiwOzmGBFyljkl/VtykXtklHpvviaIQNbyWBkDxAuKf+JzjAERvyBtTQXIMiYFxKNHhAIL6wacHz4ixIjn5wtSLogZIOK1F1JGShkxZaRcsCwrgvf47bcnXBePf3k54BYNck5AKUg5AsgAMj+qLQAVAAWlJKQUkFJETEE+K3yeIUzTBOcG/PLLLzgcZjw+PoKIcL0uyDkhpYxxnPDx40ekFLCuC5xzcNYhF16L2q/DMMIYg9vtCu89/vznvyAEj3VdYYzB6XSGtQbOOQzDgMPhIHNgQk4JKSfcbgvWdUFKPM7DMMCQwWQMqBQs64KcEmJMMMZgnEYMbsDxeADJ3hVDgPcBPngE7+tc+vjxJxyPR3z4+AHTONW5EEJALrneM4aIlBJWv8KQhbOTzJNc9x+dm84aGGvgnJW9jvs9Jb7e8/MzlvWGX3/9FUCBtRbn8xl/+MMfcDqd8PBw5rXnLIIPCCHg6ekJy7rgfDzDWot1WRBTgl9XHjvD9zsejhgGh8N0qHstr+2MlCL3aUrIOcEvK1KKGNwAYy2cc7DWYJomWGMwOItlueFf/uVfcbld8ZfnT5gPBzycz9zOx0cMboBzru6/Ke32SrAcmQ9HEBnklOFXj+fnZ9yWBc9PL7DWYhgcHh4+4PHxA5zjtizLCh88npYX+Ojhg0fOCSVGGAKmacDoDB7PJwzWYB4dUDJKDEg5IgYPZx2c7r1EGOcZ1jo8v1yw+hW//vaElDKOD48gQwix4PX1Bf/H//H/xv/4t9/wv/23/w+3fz7U8S4pI+eEcRxhrYMl3ccNrDU4HQ6wxiClBEsGx9MRxhoMxsAag3EY4IYB8zSjZB6bGGOd29ZYhOyRS8I8zSyHncX/4//5/6qy+0vHNykBOtHPxwnHeaob43uvrYAi5GzfCBw93vt8Lxj13/cE6f6lx7cqARuFoLanwPRKwF3F5evf7Z/nnkKzf1eFav/c+tu+b99TKPbHPaH9vhJAm9/0v9XNa68wlVL+KiXAmALrWntytjzJLSElB+/NZvPslYBhGHCYBtlU6M0m2/edtj3nLApDgSNXlSgCwRhbhUGd08aArNn0PYjgvZdNUjbu0u4hDeDeFCXAdusDaURxEwv/qgQQpOUoMCL8ue2FLAADkIUxFsPI/Z3PQM5Ayqw0ZAAmJISY4QZWIMZx5uclg/nm8QoHswLe80ZJqY0DmaYAFyTkHGEtATQAmDFNI4ZhwDSNsF2f8CbXFNTDYUbOBTFGWGuREgtGnTPGGlDh+a5rMOeEUtr6PB4PSGnEhw8fMAwDPnz4UBUAXSs6lgEFKScMg4MxhzreOl6nYYAzBsCHN3MipYRlWRC9h/cezjmM44CHhzPmea5rQI2fFCNuKdW/tT3G8Dxd1xUxRpSSYYyFs+17felvVdlSBULHJEYW6K+vL4gxYBp5rp9FqP7000+YDzOOxwOmacI0TYiR+3gYHJZlwTTOMMZgGQakmLAMA0oufH9ncTwc4AaHwzRL+0j6PrNxlDPWdUGMAcv1ihgCBudgLeGnnx4wTRPO5zOssUDJuF1vWJcFdrC4hBtOpyM+fvyAeZ5xPMxiWLCiScQKpDG2KvvPTy/d+jYIPsJ7j+v1gmVZsa43GGMRo4NzQzUC2ECIQCkIwWPx3OZSChwKiAxGazAODtM4wDmDcXRATshUYGIBsoFzrBzpnHEiqJ0lRMuKjiHCODqQsXADkFLA8XjA8TBjnEYAVMfUEK/fZhzLfkQEYwlkuD8KCPM0wTmHx/NZzgUbNJGVt+A9UkxIMdZ9/nQ6wYyEcRhg7MgKmbWw1tW5/7Xjm5QAPTYW/h2hC2AjLFSr1AV9r0Ff+uy9B/jag33Lg++Vi/5obX1rzeu/++fpLc73BKx+f0+R6a/fbxT3fnevz790fEtpiO059G7b9ZnfG8u/5mhIDCMb3IT2vDyXWJbye7OciQgpZQCq4JVqXfK5/M5N3vU97ZQ4PUPHkU/mdb0fA+mDjRIpPyolA0X6jQBk+bdcr9SbkfQ5SS903xOBYABBB6hTAkC2CnwQC5ICIJWMEBNC4BdZJyiEAVmCdQPsAIyjQywQAUrIJYEIsLIxWcvPkDILMSJWDoiAeT5gmkYcDjOcsxvFMKWEEILMX1P7JaWEdV1lfFh49oiUojwh8Ma9LAtiZGsdgAj+EfN8wDCwEqBzhQVfln7EZu3o9QFZVx1iqW2IkVGmEANijFi9BwiMEIwjjqeTCMXCCE/OiKLMONnnVGkEbdePsUbGkEBGEB/Dlj//mzZ9lAShSjkhpoQQI1u0KbP1PQyYDwdM84ShU7p0PhpRwq1zsM7BOScKhwMKwRqHQqpmUkWvUs4gAClBlLCEZg6g7uOKCpTcEGDnHKwxQDFwg8M0T5hiwDAM9f4AbdZmrywaYxipK0CIASUX3G4LiASRCaEqCTkXEJWK5Hm/7tq2RQDrQfocvEZMBlKMKDkjx4gUIyNDZFA6O6bkggS57gY9LgBl5IyK/hFhI/N0kRPaXlGKImyQ/iXkUmBKqcot9xnvB6lsEeqUEnJK3Z7Y5E2/71Wt/huO71ICrOVJdc8arw+IJkS1QdUqwltI/Ev/1mt9TaC+Jxy/VVD1994K8XT3nHvXvqdI3HMJfAkJ6M+5Z1G/h47s73vvub+GAvBnbz6q9/iaArC3rL73KAVIKb8ZR4a3AWN0k9+6RHSTCSEAQLU0de6p0ipXq9cEeDOBKciBG6BynagpsISCslMAekW4R5YAUQjAGrz2C8DugELsYlDrACWzgJB21VVSIMgEC3wyjoW4cQCMIAKEWIBUCMVY5MKb1eojXq8LvI/wPmA6HDCME6wbYIyBGw8YMODxwwGjJ7y8vLDQ9vz8bEUTjC1IKSJEbZmFGxSGfcDpdMD5fMY4DliWBSEE/Prrr9VtY4zBPB/bxpUzLpcLt8E5WNtcU6UAy7LKa2FBvC7IuVSk5/HxEYfDER8//oRxHDGOo8CiCbfbDSHEqhAaM8C5NodCCCg5ww4DhsFV+No6h5wyXi+vSGXF5XpFiBHruoKswcMw4Pz4gF/++EcWFqXg9eUFy7piuVyqsmOMQRGlwhaZBwTAGrhxBMGAyLZ5wxMaMKzsBbFil4VdGIoEpJwQgsdtWUGG8Hh6xPF0xE9/+BnzPON0OvH8MgSoq1CE/zhNKAWY5yOssSiFEEMQQcGCnIiQU0FEAvyKkguyCHlGHkaMw1DnNismESlH5GIFlmdLXN0YhYCPP/0EGixe1mtFB0vJWFe/QVQYbWGIPIQEhCTujIicP/EcF2RjXbwYlm1cYwy4Xi9wzlfLV9fcOI7ISYRkTtCflVIQQ0BJhBKBkhJS8EgxIngPHAjOjSqhEVMC5YwY+ZVlHuSUQKXI51HQDUYmQ2AEh8AWvyI+BDBUZwrIMCpoiLjPARwOB0zjiMPxCJSCGH1DLNWYzqyM7pWomAJyTG1vNN+OyH6nEmDfFWJfgvv3lvJ7AvSeQH9Xs3vn+BqK8K3XQWc19r97T1nZ33ePfrynOH0LEvAt7b+HRrx3zhcVgTv3+pIC8HsVr3ttKzvkpRe6+/7Yu50anNzem3+z1LbfVaBIjHIjK5+obgJ9f7x1GWFzTxT2121dL3IfEezIQCG2wAgFINPQA3lnq4EVhio0NFaAWHDkUuBjQsoFa0iIMcP7iNuy4nJjKzrEDDsBg7Gww8TC4ZBQbMScZ5AlrOsCooKUBxAVDIMTi18g6tz63YkRMAwMxbrO0tQx4A0LAv+zEq0Wim5mem6Np8gZITDsywI9YFXfdd1Ebd342li0ceTvM6x1GwVN50oBNvMol4Ic2PJflgWr90gi7MZxrPC6Pl/MnQDo9iRtv8YsvLueydbzWWi0uaRIhAp/vfYgQTKTuGBV+VFrsRkKbAUmtQJ1fhu2/NW9mDPHAlBBtUZLKcgpI6o1HVkhiTGwABPkwhG7R0rJsM7BWFMVPO9XuYcBEbf3kA44nx94KkPnRu7Ws4VzA/vIrYWzFsmxgkZECGHbR845lAI4x9B+i0ETV1lphqZ1FkQGWVG+zKp2dV31mfHUozP2zT6n68/YhnpQ0n4WFKczcq0xSCLYidgVxy4AvSe7CIx8bkigzU7WFJkDMcaqBNW55Nh1aXfud+2nGl/zdQC4Ht+tBOwt1Ld+5fd94l+CkfcWVn9e7ib3ewjAPcGq7fjSPfu27dtfkNCsx6/fvz/vW5SA9xSBfjP5mkC/9/nvFcRyAQBf7q/9v/897lvQXEj9dVSQazCRHj0SUEqpMPJ+g9Zr3Gt3he4sauCgWlaF2Ddv0Pz7vbJRx1kCEVn4qy9bn6g9mykKFffvvCkX/U/iMYiMWHYWMKrVG2QYlEJIIMSU8XpbEVPG6hN8iLjePK63BS+vVwktI4ynRxyHGfPpkYWJGzH5iDyMWNYCH1Z4b1HA7pRp1i0hI0ZCygHsqkCNAxjHqQokRQIAtri992D0hjd57jMOcuNAPO6/QSxMRQmWZcHlcsHT0xPWdYX3vo5z/9IxjjFyK2VvUIRyv/arqyZnWAm8U+RGEYynpycEUQiGYcDxeMTDwwPO5zOmaQKA6qrQTbnfdEsp1dWRZPOfpgnDMOB0OsFah8GN1ULU59PrtWuyr/xwOMA5h8PhhClnrB+4f0+nE47HA+Z5xjiOdU2oK8V7VJ8zz1cD50Y4O8C5iFLYHVQQRWEtiKkAhe+dUkKUNobggVJgrMU8DRjciNPpJAqgE6WCFQB17xyPB1hr8Ph4hhsHJKI6rt7z3FDlahxHcStNMGQQpwQigw8fPmBZVvzrv/4rUsp13Od5rkJY18hmfEtbo8PgQM4gRduQABQ4p8LTwhBAkHVsua+ImjtF9wdrLIwgHgBhnufarlxafBEyC/dxcIjBI8VQ22MNAMeBx0RUlStnWcHMMTE6WBViRgButxtSjDVGRecUB7py/JLGouj4tZibb9+Lf1dMgC6wLx33oPCvCcRvsZK/RaD37++15d7vtxYvkIoRmJhQfcL4QpuJatcL4iyAAlWNmC8l/kHIdft3/jWq8rHvV3TXrX93Y0HttyidbS0+dhXydaK8Oed+33zps97K/t2KQHnrQrlnyfeCXRXH3me2d0ntx36v+BEIZI167gACa+fUoVxgyxGywffPr4Fs9T5FTPpqpurn3YhJzABRYVRAAvpQqAIBMtOAQhB3N2LKyIXhYx8jnp5fEWLC4hNCiLgsHsvicbneQMaBrEXIQIIBrINxI8wQYYrlGIzC0G/LuigQ2QogV6GuWQPWGpABR42L8ImxQbbcv6az2nWMuA/GccRGOeoV7g7JUusfQEUberePWka9K0aFQT9ndH7wBs5IhpX5UjIQfMDqPZZlFQXUYhhGnE5nHA5HjOMEFMCvHsttxbquWBePECNyYmVP0QzvA3JK8CHw3MpAThmDGzEMBGdHcV0suN1ugnj4jVKhluo8H2CMwThyJtbDwwMUQiciUabiRgnQvtBrKAKVc2afdhLkhYNIJE6hCLzOrimezxk2Z+TMwbG81iyscxjGAUCpAW4pJyBp4KeBc1QzBqw1OB2PAFCDJFvMSEQIEcPAzwDLbWpZZqaiR845mM7yV0SglPuGJpG4PWKp+6Q1ohDJtVWIDhqUlw1yShLXwAaFGwaACJLLI8qHwTxzP5JzHPSaMsZhqMrNNLKyp/tLjVPImRV6ggQJksSlmKqMhOAZaTFUDQrNENF9rkcYQUXQq4aOaB9+RTxvju9SAu5uones6K/9rv/sPeHxrRb015SGLz3Lvc82Vl7OVZ6+aSfR5kVmC1cTVPB/+Vnut0WF+J2G7z9T4Y4mbHgDkM872QQUlNIpABoGtznny8eXxurf87jXRz0S0CsBwHbu3ZuH91AMY4yY6azlb8+vV2uKyO6ausg3LoBcuo6Uf9fhIf6eCMgkMQKS/ldyzQpo/zF0mTO7D3zISKlgCRG31ePPv35iBGCN8CHhunh4H7CsAW6cMEwHfEwFiSzgRphhhp0KDAXkckGMzRLlmIoCDigqADK8X8XKZyWglIxcEo7HIw6HLOhLrhYtb0QqsJsPXPu6Ca24Gbe94qfnqgBXCNxaW90E3jf/sp5/b25urqU+2ByQc8KyeCzLguvlBs5mOOAwH/HTx58xTRPm6YCUEq7XBa+vrzVeYYsEiDtgYYF+u91EEGlK2ICcgWGY4b3H5XLBy8sLXl5e4P1aEQ1FD8aRFRa2rI8sXAeHlPjaAFXf+iYITa7RAvH42WNMyATEmJFiqYoAK2iAdeKrLixIUFdCqSmLdnBw44ApziwoRbqmHJESI0Cc1lwYHZo4+v7h8RFkDNZ1rUgd+/tRrVu1ZFXpVpShH1sjgluVgKb4bZVHnW/LckPIAYO1sGRgp0GuwXNznmcYIjgCUDJyjig5IceEZb1h9YHXJuneaDAOI5wrHEfCvkOkzOsxp4TT6YTbGnE4HGp/xNinWGaOQyHL711KqMYrLOsNLlo4+SDGiJiirC3umzr31GxJESUbGEuwRlACw0rUtx6/Swn4EtTfD8r+d5vNF18WHm/8Mt+gJNx7f+85vvZdQYEpDNV+CyLxnlvkW4+9ZV2+YxDlCrv7vz1j/9n3NPGeEP1aH3zPQSIQNeJ/L0QAhgvbhmfqb9iKsAINy9qVTY0j283m2u2eqL7ivv/aY7RofxQF7bcn1fnOd0AmRhQYnuy/a+dUKx/sFsilIAsKUECgYmAK8WaTgVg41/96WxFjxmXxuK4eTy8X+JiweOYDWEJECAlLSDAlwCTgt6cXFDvCJ+BwuOK2LAgh4ulpxbpwYJX3Hstyk41d89QzQvTVOoG4CwpyB2PbritI4H8rG3ZLm+OIbvF/ogBUxO8+IwSPECLGkS3lUgrn/Gd2xWnQmW6EPM5sUatl6Rxb8M1dyf2ulrPV3O8esUELwNWNs1c2ektOFQ5FKPS73iUwz3NtI9AQDHVdLAsjANfrFdfrFbfbTay9Uq1nhnrH6ifX552mGTGwwqLxBxqIplB43beK+s/5OZewomTCKkGHISSB+Xk9DG5ki9SQBAQOHBMQQhVSOQkqFDxiCII26IzmOVEAQYZYWTFugB1dbf+6ejg3SET/Dc45UYAI0zghCK/C5XKp7qU+nbKgVIHYskja82rcCCv2GTklCb7sXUqDKDH8O47zYH6AnBKyZIZ4H9gFRwZDzqCSofwb42B5jVrLsRSRlebHhzN8SHg8n5BjxOs0YQEHIXJ7ImAbF0ndO0TRAVBdBPM81zkUvGd3QafwxRgbKm84w6SBv2/jlr52fJcSsL94P/H2CEF/vJfy1l9jf597CsW3Wv5fs0zvCbR7bcgK2X/lmt/b6e9do96jcLDOvTZ/TRnSa93799fuX22Avi137vGeMvTX9AOJIO9f2/gTRQJo81kVrdQ2JnXnaBqhXk//3Z4RAIqgOLS5Kj+LCLj6XN3zdYuN2q86o3+rHEDg2V4hKIWYCKhArH2gENv/BUY4Bwp8ZCF/uS1YfcTzZcV1WfHp+QUhZvhETBZUgBASfMwo0aNQgvv0BJ+AyxIwTjPWdUWKCeu1IHredEMQJQAFMepGlRE7JUBRgJRj5UZgoQ2xOiQiO5cquJ0EtuWEKkCt5GGrkOR1DhH8pVo7Cn2ygLZiQZYqPK7XaxU67C+NzV9aUSIec70Xgt/sKaoEaHv3SoBeX5WAPmZJ55C+G2NEIdlGqeumrQrA5XLB9XrFsix1X1QFYBv056rgGYYBngyAZ/EZhxqAyXMyv2mbvi+3BTEWCTrMKBJBPlpX3R9W8ud5PicJVIzIOQIlM7mWT1i9R4wBM7Gy1yvLSpSk/TGMM2Z3gDFMnLMsK4ZhxLp6UYA4DdQahzQ3f/bLywvWleNBtoFvDI0rGRLHnigSOEksBAf/cdpfQnEOgGQiWCansrYLDBVlJ6yrpAhGhBiQYoSxEWQsYkpCjNQFpxoDawdO58wJxhA+fHhESAWPDw9IMeL5MCOniBUFyBklJaA0I4VBiIzSKZZOXBbzPNf5tFqH4Fu8k7pTei4DsgZVSf+fpQS8JyB7y/9ecNaXLMl7aMO9v7/2/q2d8fb6gJE853uKzddcIO9dv1dk3m1zzneVgHvX2Avs9459e+/3NbsL9LMvoTn33nUT+D0HGYLBWyKVfhx7f+++7Qoh9lba/jp9JG17NrZUe91i49/nU/R/WxWEqPnydymBKAqtShzIbtyNMUhkkGCZRQ6yjAsBxaAUA2ROK+TAv4Tn1wXL6vHb8wXL6nG5BVY73CiESQdWBlLB4gO/QkZ8vuAWCtxwZWa7lGGiAzKnAbIQUV+8qZupGwzGyVUlwFiC5i+v6/qmb/nfjVDHkAbyMeSdUoYrnKOvgmxZlhpUZ7sNUMdAYw16CL5XEnRz1BTRqmwIiZBa4cYYZL+i5ATvJRo/eOSSMUnQ2TTPzLoXA5Kk6MWUAOJ8f46IByDR+KWw8EMpsI6fdRJiIY3yz5nRIxYw/CqFXUKjBMidz2fM08TkS5JnzwF8BbkAzjCxzzBOoBhRwErJuq4CSUcJYjOIQhSkCNZ6A1LkdDoNYDXEFnIB1f5Vq7pfWxzMGZBSQM4Ry3IV//QJIwEDNSWLiNMTCZzrn0HInaJWCscWEAxQSBTIgOv1hpQaeRe7DmK17g+HQx1P7708c0QInrMUDAnbYosdOZ9PmOIo6a4Cu1uqOfYBzIOQxB0W/MIxEzHCOkYuhoFZMHV/qIRgxLkFxsi4i+A+TBPOxxP+8PNPAApeX56Rc8L1egGBFQ4IOlhyQkIBlYJsDIzEHBxPR0zThOPxCKJGRKZ7Vk+UZu1QuTOstYhxZXbCqixs5ceXjt+lBOwF7Jcs8X6D2H+3v3b/3v/+W63gb0UCvuVa9Tlpu/m3dtaW32l7iwfQa/YC6msCNaeM1CK0Nlr+e+3+lmMv2+5/3xCB946+Hb1v93va8uaaeMtCqUiACvQ+S2Tf5/eUgF7w79O3+nPzPc25WvhAG0y19kubF1mgfxIMgBQ7av5VujMfIFdKhdPXUoHEDhKyxAKUQsiF4CND/ZcbIwBPz5fq+yfrMA4GbpxwfviAXAgZBHO5IL5e4FPGLdxwCwnGOp5XpeBAEwyoCiuGh6luqoOT7AXifHzxiQDEfRVCqL7ZtsZtHStFYUrdmEoldBqG5vNdVw6407l0OBxqmlgpBbfbrQp8Ff4bcqbOQlLrSRWB/jwAiOuCnGK1ivXcceJI+3EaYaxFELg1qlK7mz8ANm3SMe0Vc4WteSPPNTsipYQsc09pj8/nM9Mfj+JGERKgXNhiJUNijXK8gAZm+hrJH5riUxg21/aFxSIn1LREtowNTGQBnlKBMRxwul9XKWfmTVhuCGGF9+yOmA8TrLP1ufuAtFwyog9IBYjltumrxolBSDEjp1BdHDqOOjbDoKyUU7t2bhk4MUWBwVXQt6yF4+GAVMY6ZtbymqwBlClIJoRnLozgURIH7x2cwzhOgghxJkIpymFSavaA+twNEZyxGIcRh0PChw8PCMHjfD5hWW5wtk9h5L2DqbqZcIpdDAMIDocDZ36oO6CUwtwFdUvivVkRCU7TZeQqJi+UwqX2+bce360E6PvXrP/+33skYH+9L33+NWH9pft/6/GuEkHiXxTNvRSJ5i4KDaMFgm8ESS8MiDfT7p1IFQE5r2zfecNUuJonUBNkgBJmcDt7SJxEkH/7BIC28b3UgG/oNwBVSP/eg/vnfrAoEW0UAD3uKVT6eQ/f7pWo/bxLOUu8nkL4Mm97BVDGk4ypygG/J2QQdzmRKAQFtInpkGwQoup6YIvIIGlcgJzHqoeFgUUqBrkAPgLeSyzAdcXL5QofIpaQMBiH03TE+fEj/v5P/wTjmD708/MTPj094XJl9MC6oVITowC4rigxV0pcjhQHhoE3mGkaYCzBOQsgs99XNuAQePNW3v7W7+zjTjEjG8BZte68EAB57ptPbdPX+AIV/tM04eHhoW7+l8ulQvIxRry+vlbUoIeLgfvcEepDTyki+YCc2JXQsgEG/PzzDOe4/gAAxJhAwqqnwqUGd1lNMxS/ckzVTcWC3Ulf8EtdJSrIiNg3PQzMvHg6nfD4+ChBgFbmyd74sbCWcDgcECO7R7xf4f2rUOpeqwCMMcA6x8I0JThzhiHXcRNkpCR+9pzhBosQbQ1wzTkipYAUA1a/IoRV6jisyCmCSIW6THlpnwriUjJSdEgZWG6CVMTmQuLUx0bprIJf1+wwDCgFMh6jpFi2zADvfd1rNE11nmdM84jBOWaENBaFSmX4S4LsBM+KKxtYPJ8JhHGYYSYeo+NhxvFwqFkWqqDElEQUBBhDSJEHOHiPmDj7whmDj48PiN7j08MZl9cXDMKXkUTwkyABGezCIyKM47TJqlASrMvlgsvrBa+vrzKvLcaxbOa9jqkTKue21307cdt3KQE8ub9OHbvflO9ZsF+D2ffXu/f3XyPw37tW/16FqraTqJrRogbUxa6v7kHkWiz4y+6dNLpTz+veFWosZdvenDmlp33+9sWX6Pv1TjbAG2u///z7j70A/j2/YyHboPK95dXmkLSzoA/T2yABBELGW/bBN4f8nAPzWAQDrTc1yA+kNky3Qdex45mgVi8PgCp8/aFWkHDvygzIks2RS/uugJWDVLgeQIgZPmasPmLxAbfVMzVwBmwBrBsxzUd8+PgT3DDBTTNoGJCNBdlXkL0yfTAxjEgAvE/IJYKExEaoCTAM7P+cDxOcsxytTuys0HTC5+dnrGuzNvVopEAZpgCZmgXsfRBGvIAQ31K99tacsuGpr1SZ+ViYC12v+N77SPKtAmlYmInLwXuPHNjfq0oApywCJDEjzg3iQuBgL1YkhXgmc1pbAcEKdK7oRh+d3zZnUQLEXdQCXk1t8zAOVYgdDpwWCFIrbm8ImRq7wAhErEhEL2BLKbApY7ndEGPCcZ7gLNNq96gMB+UV+OCRkhGCmsxsgCkiSQEejhdZ4f3KkSqGatByATMEGmpKTs4EMhYlMQGUZp4oMqKxF3sUp1/HRFQzB5QLX59tmqaqPDbyJEEBNNp+YDbGFDhtM6RGZ63R+gAbU85yQKt1zIY5Hw6Y54Osc1S3lc5tje3JwnjJ7hJGEQwRDoeZX/OMaRwl3TFVZJGqzFAUSdG4vFE81I21rIsQUVmMY0v97A0alQtEbjP/vvX4LiWAI4J3qXC03bj71z3ray9k+8/6a97799e+A96iCPcQiPd+u79Ovru5bH+3Z6r7klvjS+/7c3u/qF7v3vUVjgOaNb7fnL923GtLhay7+33tmu+1sb/mPcucn8HBOVMt7lLAFmVmlrYo8HNMrUqgoi9kDIaB/9YxK52fv9+k3s5Nzm/WkL6G3nRqEpEoHZLHX1o/aaU/FfJM7FPe6FNF+jODGdsygFAAnzmYL0gedc4FmZi3YPUBISb89vkZt9Xj10+f4UNEzIRMVgIJmVAog7DGiGIHWBCm+YCPPxHsMGE6HLEG5tfPIpmOxxMoM2pRShbSFybQGccB08wb7E8/fYAxgLGceqUEO2rBsfAZqsJbCmqaHFvWvMkyJF7gfazXWL3HqAWgDif89PFnnE4PmKcD5/GnhOCj+I8Jxjgcj2f2xVp5/tzyqXkTdVwREgYlMy1uSoxOPD8/I8aIh/MZ4zTh559+wijIgzWG2dhyxkDENLIx4nq74UUogmPkQLKUMw7zzGRA5zNGgeHVYtTaAjVlELxBh5RA1sCZAXZwTOc8jIC1KGRAzsKQgSnq+yXAGHix4kPg2gKZv4QdBthhhJummgPvJLAw5QSYiOvtipJvLCSMwTROHBxH7Jf/9OkTUoxS7RCwhglvxnHgwkLHE7IEtFnLriLrBjZjCr/sMMI4C7IO1gJHa+F9RioBy+Lx66+/QQ2Uh4cHHI9H6c+Ep6enjnHQ4uHhDOcGzDO7A+Z5qsjnNA348OERDw8nxPgTVFFjuD6Ct3oLK6G1Ty8vWFdO7yyl1MDLTRGqtkKhi/a2MAFSLhkpRFF+xZ0i8G+p481BeyUlwDi4Ycb5dMA//unvEIPH6/MTnp6e8fzyzEoUiPtK6iKUAh47oxUTVzx9+gwfPF5eXpFSwjCOtWpjTBHPry9CYmTQXCCjKPCiCLwj9+4d36UEVHak7nhPmL8nNPvv7533LULyW4/30IovKRIbwbVTKDS3tu9gIqo+vlwEggI4IlTP2d1LLVp+27WP3vm8a997Qlbv9jVh/aU+/ZJi9d5993/35D37a/fQbf+5QrP6fBr93IKGRCHogoiaBcjBTr0SsnddsXXRcspZGWhKScMA7h8FVAV7j0DwbUgfpHvYzY+71ML275SBkDJ8TFjXyJB1ykjggMPbwvnVT88vuK3MBhhS4viBAhTiIj0gZjdMSUsac52PaZrhQ+LqglhREFBSQiEOZDPZgIugqMKXK/ELwMGBh8MscQItOEkj2Hu/uhF+ekCtTGLUgVqUPs+NUpGBdVlhyLBvU9o7OIa7cyfcUxILDIRB/OI6f5olmSQYsRWV0vEpma0lDgiMXIRnnnF+eKgUwdV6Msxdo5C31hJQS/Z2uzW2wlJwJmGZUx98iBVNaPwLBCKOsifDXAVExAJ7GLhvFOWi7Xwqpat6qQq+zkDSgkhsBVtrhNLXST57wXL1iEFKzgLVLQVZY7flVqv0cdlai3zgAMmBOG7BWYfoWElvVSNNRe5a8STud2ctcklwlif7unpWbiz/TpVDgAUou1+4Roi1rIAoZbNzto6zMQbTNNY9o+e4SEn5FlDz7rUEtaYcjsMIa5h/QRn4WqwJC3qlTea4i8RKgHxfhNWrGX08pgC7/4wjuIkwjQMezic8nE/MH3C7dShAhiHHfBWGyYl03pacEXOWtN0Av3IhKzcI74Yom0lcIqTj4xymkV1G32P86fHdjIG9hfjvIaj///VgK0t5AjhKm4gJXqgCxxwjgIL6LrUheYMuZSMY2LNA7Z0gvnBgIzXqJlbqL7djq4B18/8oZEjEOa2/Yy7wAupoR98T/u8pAb0vHngbnNICdVrxi4Yi3Ud89Fp9AGJ/X31pdPg9xGLrP3ubXZBKbrEdKBve7dKGoEZc92NFIJDtl5HZ/LZk3rKzkAgp1FtKwdPN488vN6wrb1YcPS5CuxQsK+fQP71e4AO7AZIIf2MdpsMJxg4ATBVyMBawzAUQIjPYxcibWxEFquSMy+UFJfJGx8Q5GoCXRDE4A5DqfSNvzBpp3ZO/sB93FOGbkFOBtQqPt3Fm6twJycWqiPVc+ABDr5fLpUaUK5Tfx4P0aaO9G0Dz/TXFzxhThYT6gY/CYMeMgHMNAGPUDdB1pq82/oRhGDGOYAsuhho0tixaMri2ipUHiZv47bdPrMjEgnGacJgPeHg44/zAAkL94zlnvL4uDB2D1+JY4eShznGNj2AOB2amOx6PEk+hHAMGyzIzauGf4ClgnrXELMetPL++IgSP15cXKOXucJhxOp9xPp/w4fEBGsxWoLENjLTM80mK3Tipt1Eq6mIkiNEag2myOB49Hh8+IESmItb0wD6otE/L1PiAaRorMtXLl954UHSPkY2xKg56/XEYkFNCnLlM8vn8gMM84+HxQ8s4WLlA07qsuN6uumjrOgneC28Cp8oSIPTAzDkwaQlpIpAdMEwTxmHA4TDzHLjdkFPE5fUFfl2wLgsO85HnqrR3GkdYZ/Hy+lIVq2ma2C0h/akcDzr+uq7GccI0Tps9UBHFbz1+N1nQ1yz2L8UMfM/xezQbPXo3hP7dX3P/fX9O98kbT3p3xfZWqGro9Xu91nuKANr79rxtNPlOl4AqAYootFf/3Z0O+YZjj8q8F7vxrde6d+0vvfa/7WF7Y5pFADS/LLDNUeZ37rOvIUH1OvyvHhXsriVKX5EZ0PWFMQ6bIBwhJtLfqt2WixafKbXdq4+4XNcaIb+GgBAjUi7IGVhWjxiTIAARPrCyQpbE+6B1CIoQukTABJBdOWYgJgThqE9SpCZJznIIHqX6O1MloAEVDJELxbBSyPzpWjgopVY4SIVwVeoyAJMlbmU7rtUd00WSK5Spgl1dDEQthVCFAp9DNSYG2FZvbPd5GzCoLqWehVCjqtsauu/u6udh78/XOdj7s/UcvWcUFCHFjBhLJQGapkkUES7JrM+qSksLHCbkvK2ZoNdNEpCoQlTJl1QBKoXHbhhHlIwaT0BEHBEfOdde+1v96tM8Yz4chPmO544qyGz+KCvkIFwGDMUXsNsFUP80R+VXixulMlSqZd7WUHPPadxAhduFgOkegghZ30bIi1QJVM4BV0mClDRKUJNKxsQIYIwZPnDgKqlN1gUEKtqQE1cjtEQYrOUcfzVkiECWUR7jHAbncD6d8OEDV9ycppEZJ0NAdAFkCCMmge4FF/GhaycLeCIDskYQJt/NN+ljY0Uh9Zv18D3b9e9SAnqh8J474L2jFyr9+f9eSsO9e/2u7+9Yu9/6fH/twZvJlo55r8x8DdL/vUJ7H5D3LWjAvp37+A/9ex+9vX1naLtG6AsSwhsKxyGrNbKPwWBhwYFOqgzxrZUpUImClFnMVUHB+z//ln1+4Gj/wtA62DAQ65DDOtU6LACm0bA1roqCwt6JFYtYOHLYh1gFNW/kGb89L/jzb+y3XEQR8D4gZmYIDJEDkkLktDI7DDDWYjwcoeld3kc8v16YUCizv9EOA8PRKWJZmQEtBK5RX+NcbisQlRgm4Xa7AgDcwNa+WhP3FDUWYqeq0LT5wsJJy7pq9TRDFs5yYRyiIgF7UQr2jOIGIn6W51cYw9Ho7ALi4CmF7PfpgaogcK66xTAACkDFyNaT9xzU93A+Vqi5z2rYx/PoRtwrOrrBKoqh81oFeJ8mx/dmBYAjuy3GYa7R7ufzAx4fPmAYWCClmBBL49Zn6JmpdduzNdeHuidiTJimCYfDXFEFHQslVRrcxIGaErh6fb1gXSU9LkfYwWKW+IgPHx7xd3/3dzgeDzifT/j02294+vyZ10QuKDCAZDdYOwDEbJer15iFAmssponXgTGsADw+PoJeqNZgCOG1KoBKHKWHpggqg+C6rm08BifugBb3k0vBPDDfwvF4lBLC3E+XwytQIGhSQQwR3oau4qPFsqy4Xm+4Xi94fn7BPE+Y5wlkHUwBQFxAa72tUh6Yuf2dMxgxgDCKewdA4X4dpwnn0xn09wWHaeIKhiD8j3/5F3z67ROYiCtwMGZ28ItHtBEFzKVwOnJQ7PF44n3K2VqYS9eAutC0H0NgPg7dT/N37P+/u3bA/rN7isB7mvW3KAB7QfJ7j/7a96z+vXCtAu2da+yvc88P/V6737N0733316pDv7/fvv93e6XwS+d9HQVg4b/tF1YOjLkfeNj6fTsPdUF86VWfuGxuX98VGCiQOnulpYZCcvJzh8Zo7ECSDI2UNcKfI8l9SNUvvoZUGf58SPKKiFIWNskmx64oJouxUl2uEETx4bgJhp9vtSRqTEx0s4oCEBT65w6DS1wnnYVxKyBkrOsCSwXByMro1mIA2JLqx6KqX/XvIjlkXDixCdZpmhBjY2DrkQCFuNfVbwRvK54T36w1oKsI2cWj1IhunRtG/NJiqSpCgyxjXEr1zG3mjmYg8MSqxb8U0ev3jCLKo1qjMUUMzlZioMpK6JiWVs/vr6+TT0vvch8Qoz5APT8L3GV2CogiFdY5zLOFkt3Uwk9ChFQEHRmnEccjW/+aqukGJz58vm9dp9A4BYHNS0YIEp+TgGyLxAhoaWGtZ2Drs+gYA1z2Vyvoadubko9aTZIJkAoHDwM7ZZALLanxhEJcPlgRIcFcmSAowvsgSgCvD+89Vh+w+iCxLqXGbai7Nte5pZOaR4nLAbMSUABJBSwwBEzjiIfzCR8eH/Hx4wc8Pz/jerkgFUYHC3ekKLqluZz7uV37vmWWOOdgjSIZVK/1niz62vHdpYTv+WZ/r8C5Jzj+IxGBLyoj3cLcKxF/bfu+pAAAYFpKvPVh79GX9xCBvwYJUJ9mf3wLGgC89dtr23so730k4K1y2b/3KYDANviQiGraUd8vugn0pWj11d8z5QRTsqTp6QYjOf8A5xzLwmfnAyrXv8kFJbHWwBu0bAaBhdDimV53uUWBQtdKwvK6RARYxGwRi0UsDhEFmTIHqDli6HFk9rIPP33ENM34+ec/wIeAf/7n/4FcMgwKUvR4eXnmDRRc3SymzH7hlJgnXSANAuFhPHSbLz8VGYkANyqEItaVq90tq8Htdq2R/5w7L5BpzMKjroQ4yhfA8TRKcmOtw+F4xHwYK/VrP8cVmgaaRahzQM+5Xq91LrXSshBrKGzgYs1e6OsDgIjpXhPzxNeKkUANcHOSr29F8BQCR8jnJCQ5djPHVFAWFNyWBT54vF4vuC03pJzxeDzgf/lf/xcuUXx+kIA0YPVrS/GLseMg0CDDABAh5sQx7+pOsQZJaaa5N5ALODOh2y+MMTicRwCET59+w+oXfHr5DeuywocVzlp8/PgB5/MZf/z7v6tkNUSobISwXI54HBOMcQAZLItHTo0jgcme2N3B7pZVlL1ZxlCVbicKRFPuSub+1WDbPp4jZ05HJUJFARhJ0pK5WjmS5y0jTAY5MCIFqdRpiANn/eoRU0b59JkVEjBK8Pz0jOvtxhwUBSBrMQ3MO0DWwhbX7RccxDcMA8ZpxDRx7QVkrkXgfUAwBuvCgvrD4yP+yz/9I6ZxkHVj8enzE5ZlYebA6BENx/iMI5dV5jkRcL1eYZ2Dq9wJDgQuFNS7S2JOoBIl8HCPzn39+KuRgG/5rj/ecwe8991fA6/31/oSKnHv79K9mnG4a6++1DKsz4E3BrVaDW/e+7gA+Q0BYHg81zNK15JvwQn+WsXs3t/3FJL+u9639zWF6T0F6B5a0x9q8fUKR29NfkkJuJe+CgKoMF8/pKdVGVJrUdMHS+GxzYIGKOEHkgYWct5/LqiCcQkJKSYsgS3uxbMV5mOEj6ky/GUQB5MaAypSXlRSfcZJ0tFOZ8yHAx4fP0jWwDNv1KTtAgc55gLJG4A1aooXlGKqxW6ImrVDJFafEnuJZSPZAkRcMlhjF3pa3pwzYkh142IIPjB8nDXVtSEBVlKzesv+bTzHds4BzfLr58E+7RNorHDqJuohfI1OrwpbzqzgsUENUzdQ9UnniiYQbWvN63rVtcjPm7F6zwQyWuvAOozThOPxhHmeJd2LA46rf19YBNV90jMt9s/kyG3meN9H24yZfh1A2peqGyYXLro0Dg0BmKYJg9Z6KBklMjxihT9By/4aY5Fihi+xg+61dC7BkCiAiRVp3RlrEaluzHSfyJKqWudIh2hURdBEpGSrAsBBcKqExvpyzjFjoQSEAi2YtMgqTymJ1c4xKGsIlX3RS2npNq6NG8AIAmQ6Y8IpkiGGgjVs3ft1hRtGjIPBOA44n894OJ9wPp9xvd4QQ2xkZFJWuCEtjFoESUfVGL+t7GChkzJnLFjTyOW+9/jO7ICWk763xLSR33K8B6//rRCA91CLL8H8ulEwoUv9SKCldqjlp++qEGzOIxHd9X0bbPhWYxDWq7JLe0PT8lh+KdTF71qznmCqZv19HaaBTm834b11v/nZDqGoj/EdiES/4O8de+Wi/50xpkZ+31MCeoutb2OPMlAhUGkoSM4ci8AhCgLxlgbvsyJACCkAlCvpT8zsk/YhIuWM2xIQU8bttrAysLJ1qgGAIQOxcA2BYgpgW7CRCsvTwwPmacLf//2fcDqd8A9/+gfmiJ9GeK3uJj7oECN8R+lbYeOiQauizPiMkkqzkJFBhjALPwCJxdyiuVOtfjeOY4VNc8643VbEEHG9LpUZMCclMbEStc0+23k+4ZdfPmJZlloxTssD92PdR3n3c0MD3DQSXJkFjTE7f3lzG+jzjKPEhJAFikEMuT6bupJ4Y2/3jJEFxDiMmIWopm9XKUDJRRgNA56fXxBjwPW6ACh4fPyInz7+jF9++UVoXh1KSVV49gRIHN2vgWyoCsL1+spW/eEAZTo0JleFWIVwHxE+SFoZp85lLMsVy3JFzgHWAuefP+B4OOBPf/8nzPOMh4czXyv5WkyngFkNSyGM08wTuxTcFhb+11dlXjQyJnzvlJaKKmlxJEV5pmmW9vMepkLdWKpBk8qex2uQqoKjQjrGAO/XOr66TjTF+PXpGWH1SDmDcsHxcOD1KyyPjAQl3JYVy7Licrlhud1k/vI8fzifmDnQCFEYGfHBs+A/zDPmacRh4rLEyAUhceVC7wM+f/ok8RoHDIPDL7/8jJeXPzHKIWW7NXiWCZEcIy1QPh6OZSEi4V+wVQmzhtM/M1gByilhnriccN13v2nX5eN3IwFfg2/3x3uC/ktQ/Zeu963He5b+vb83n4umVVgN3Ijp9+TaHhF4q5q9gQfu/lstMp3k97gZ3ju0pb8rqoBKTWnT41tdAff6sT/3PYu/V9TuKWtfQwb0b4WF966SveDf34d9/RowJ3SoSf26WQryMNFNTBk5i6AXoc/+vYiUGQWIqSDlwkpAKritzCi2LAFRAhiT5JGnXBBSRohJfsfKJLG6D+YAkJxs0+BgpgC2OJ1OGEPAslp4SdljZWf3nE3bFD94wZI9EpKkVxVkKezDVppYTjVQjf2WlUI1Kltdo+UNPmJZmKVuXRkJ4JQxjuovRQs1UY3gHoZhk8bXu3P69d+Pl1qRuvH3VmNVhMSq02u1qoYDnGvR4nqw8NwquXvBo9agKlfbSOyWvqfsctpOTfWCWHjqm2+QdldK1vawc2tHDFEIseKmX7ZZMlsOF7bEOW6ElY4IUBFInXB+OOEwHzDN7P/X+AhtP6MJLFhqSWhhxguBgzZD5GBXXnvKkihZAhI/woiRKlqoY6c4qvaB7o17pE4VIkUKekSoHyudR33NCEOEYi0sGUZ5NP02pc11OOhwwDCOIEPVnZVz4dLDxFknsF3WRmUhjMxLIMpFkfiL4D04Y4GRoGGc8PBwxrIseHh8YOXdB+Tc6MnrfOqRR0AKfSXpTwdrc0WhNfMlJY5M0rn9N1MCdNG9JwjeO9477z8KEfjS/d5TQJQdbv/536J99yDvXgnoJ/++Dffa8j0W+O6XNbipP75XEejRi/13+u97bp/3BP7XFM8+KGqPRvTX3ltx9d0lFoTyt4+8sEJkgc5Mbe3vlApSNkiFEKJQ42aDlCHkPAVryFLNL3YBgQydZwiqEFONgu6h3OIY24lSUTDLq3RKwTg6/PLLL5zr/frCML1YjyFwdTWyVMunKtGVCu9/Sb9hua0oQgesQVzTNFQrPKaWOtjDzVr1TzfL15cLvPe4XK41Il9rCFjrEELA8ZhwOBxBhFqvoC8IVC1Cc58XQiF5pdfVynWKAHjPOegvLy+VJlgRC50fzA3QqHdVaNfCMp0Q1XxsdYFokZ/eX98rAfp7zdXWILuff/4Z83yoCkUNGIxKbkPMzudaSeMYueiQl/TO223dQsYVVuf0VO2/XuFlyxtCkRwRk4cxBT/9/BHDMOKnn37CMIw4Ho5AKfWeMfB1INXxrFAqp8TseSkmLDc+lwmuEibw3MwZQCGkyHE2PlyqBasWtCJPqvhpPzq04EYV/IoMZKlpwOMmpD3dwWO1Yl1FuRDhbUQgugJet3lFzhFJUDjASKDtQdgJZ0GmFi7eBFaErLWSdWDBmUSERepRlCz9XhJABoUc/LLg8vpS19XxeMLHx0ekf0g4nc5YV4/DfMCvv32SAFigSBApiGCEgwLIEj/U3GXWDfzqFGAAiCEjp6bUvDE4v3B8NxLwPX8D9wXFXgDc+817luBfc3wLEtDa1PkAvvO492zfoji0c6gGCBG1cp/vn/+la33Poe3+/UrOfmO8e5dOSWjCGLK4O0ir9qPOGRXyeqX+3+2zdts+vaugMvJ1wqcgAwP71TdKgFjpKRUW7KkgJC7Tm1JBKhycFWJGzAUhESsBnoPwFs8LePWsFMTIvj0t8ZnBtMhBgqv60p9qmOrmrnnK3nv4dah+ea6AFqvlG4KvliaRhQWTwwzCqU6GWcmSzZhnZm0zFt38av3NVdYCvLe1LwFUS6sbzW4c21iiCDImFiWn7ykbIFt+RnKctWRrP+90Hrb4hGZF6ncsyJPA6l7y3iUbIkSxmtQXLX5cZ2uUDWUCZfbtqxWr7hJ12fjAhXTs4jYuPKWx1lQsa4RYzHSsosTn+hDw/MxBm0p3DaCmd5HhjANlBGyljtmHbyT/XDqGAxgBLt1LqChiKeL6gQbtJfj1GSkHoc5WQiVXgz9ZoePiOiUXlIw6LpIDAWVtTPV5NWqexyFnrRvR4mZ65a2xSprNelUEoMbqUJ/hwcqpRvv3bJS9q4vPbxwLVmJaDNkaw6F1EzTDpRR+gsYc6uo602efDwdM41hJgUyJyIYQQwYKkwjlRCDl0yAZe8uIYg1CFtcHwK6s4+GADx8e2XUlzH+Xy42fIclcFf4F7ece6eHKkv3+KshZCjDEfaIcCN96fF9MADULtQ3i9wvq/2gE4Fvb8aXzgC1E/SV4e39873P12r7Che/5y/+9kQDmJ9haYb1Avveuxx4J6D/rn+se8qGbiAoiou19G5NhExbb6/SQ7hYi3ZZ1TTWgif2eBW4GYBq0ppa/FyvfB16gIbJ1HxIE/jfwAuP7WBATsK6RYwB8u0bOWiAI4MqUJNYQIwEN8eG4G+ZcIVYccqmseZfXK1CAl5cXOGdRZDO6XC5Yxfrga2UAE5w1cIY2nOIAP+fj4wnTNGFZBslauKJSo0Jr1ScUMCe/Wt5aUY83dh2DXqnTYaA6bip8DocDBjfIM0M+H0VR8CDq3QJ9elkLJhvHsVqQai0rCnC93nC7LbXiIF+baw44N8ANI5zwA+ScQSmBLLsoCjITO8m88VJFb1kXXG838SHfurzssBFw8zxzO51kDhhG1WKKuN0WXC4Lz1pq5D7H41Fog1mghsjXvF2v4jpaUErhYEI5p7oBjPLDS5qjYcUmythcLhfhKfgzUvKCSMyY50EQByClgMvrK0KMuF0XpnA2XKN+mmZkW1Acal/reuKxcTBkkKmRBIXYrz/Ufu4D9JjRtCkHvK5tJW9qCjpzdxgrtTYyF9pReuC2t5SKqmhsycPhiKGWARYqZyHOimIQaB0FdbVpe3Q+zdOAYbAYrIUlQjAQwq2AFAuutyuoFHhrJTuBa08MM+8h0zR1SgQrI8fDjHEY8I9/+gecTieklPD09Izr9SqMity3bhihKYGaDqpIEpkEK4aMrkkCIacbSo7CMmmlhsm3Hd9dRfDL1vNff+yFy7/3tffXvCfgARUpfbT4+9d8TwH4EhrwZTj/7blfavP3ogTvHewE4Zz89xS1LymAezfAe4rA/pweEegFf//c9xSS/ugRCP279+v25Wj1XZWAkTpLrJQK6bPQz/A+IiYW6HslIGTqlICCZY2IMePWoQdFMgCYOIfvlWvAqT6jUK6ajmtfLMmUev90kOA3ixQDQlhxlQ1fg/gA9ocma1DyAIJkC6gZSwbzfIC1LMB4kw9IiRCCKkiBURJkDANvNiqINf5CLf9hGJBzkfOY2bFkrlPv3FBLBB8OB1hnK+UwgHq9DTrTzQ8Veo1cxtW+2ETX51yvp/ECmvJ2PB5xPB5ZML8zR/u51qzWt+tOFRK9314513msnPXLsiD4iOt1rVXxTifOFFBrMQoUrHUJNOZCefpnob1lBXlLpa08B4DOFbZoOYiTSZcgsR/D4DZESaVkhBikQFMW33dTuJlJMkvWB8Pg/DvtLw4oVXdKCLELiKZNBon2legydcyaa0P6Qio4xhhAUuOiWfFMbqXPrsqnjpHGgcQhtmyf0tx8ZAgWFjRwhL8bOX2y6HliRU/ThGF0GJyFI4IhIDsHIMMZCxiu7wEqYECElT/rLJy1gDOYJsI4jDJfI263azVOhkFJo85IOWP8deJAwOC7eKz7Rhxh637S8UjBo2SdN8oi+G3H9ykB3cZ8T0C0036f4P4WV8F/7KEA4L/v8SXhrZ/vUYf3FKOvXeu72gVU60Lv3R9fs/T7zfg9xagX9BpZrHB9s4jfKk/99e6hMH2gTx/Aptq9RmKrn1ch9oKCGY5hcUEjVknv8p0SoOV8QyqIGYiZ/fT8TlVBuN0iQsocC5CBkKRnDWvnTmt+W4BKYY1dUACtJ96Cwxi6TMI0qExnt9sNhgh+XeD9iueXZ3i/4nJ5rUKCq8FZ9lmWUhUBEAciPZzPSJmtM0ZIQu2nXBKnMCWDGC1ybhH4ap1rwFcpBcviUQowTRHWZghfCpIEjakgPp/PADVqYL1mrwSoAOyjznVj7mMB9Bx1hWiaYWPYI5xOJxyPRzw+PuJwOKBgOz/7OaNKzl4w7fc6rXkAoMYj7BXhEAJeXl7qHAshYrkFnE4n/PTTTzUCXou/3G4X+ODx+fPnyhJorcWHD4+YphEPDw8AlDinpYJVKLwTGBoc+fz8jNfXF1jrMQwcoDZPE47HA6x1FQ2rzIwlcwCdRPQbYxB8RBClM4QIWys0Kj0zW/YxrgCIC+NU1EarRzaki/u+wfesQLqKNBlj4INyJ6wwhnA4Tp1brLH9tRigVu5X49W8GySrh+q+xKV+DcgSBjtwquo0I0vgb8wJqWQ4ZzHZCYOzsIZgidWEkh2IpIR1zsjEbgqtUDqOI4zlnH5V9rjIkpGKmWvts2kaMYwcl2GMwb8e/syK220VJK3c1QEUMdKx1yDOnDPCuiInLy4NUxGvbzm+SwkoHVzY4NrW2drQJpj4s/1ia4Le3LU4+00/pSLMY6xh1uv3gqC0NCj288p1wEJNf1eVGGwtTYVU+Jz2PC6zNql3okK7wSkwki5mJEewWmJATS+rzS2N0cpw3kmD+fgG4gPKWGKfF00MI1vTcDa5f6n/53FBKfVT7U9IvGnfZSSoukKU+u7kaeuCLdvf9JA8L2y2KPg+bDluLH8DKFuY+qp6QhdNe+R8edsWgVodbN/I03TjXn1eOq5cWpaZvQwHOUWGKNfVwAfC7QasHlhu/HkIbPnTGgGja68gqRATAR8jB2Zq5H+SezAfACSDQOrLE9cyH0YLVwhDUUQJMpcKQExkgpKhQU7c/64KcWM406DkjNviZRYSxmlEiBFETH4Sosfl8oKUogTDcflVH1mJua0BhQymAjhXqoBcvEeKpTIKxsRjQMbBFIF7DVMIEzmkZOB92QSgcTQ74XA4w9mJaxuUgNUvggQwO591BgUZl+srmBa6+Yh1rnA8QytoxHuAIBKyOatwIQKOx4MgD0oLm8RibKjBNI0Yx6Fex1guMRyFOS8GHk8UAxTe7A1ZZGRYU+BcxjwDgMUkxYZqzXrDvAvO8bqf5xOssVJ2d0VKL0gRiIHRteNxxIcPJ/zhDx/x+HjEPA8oJWJdLwhhkc0btVKfs1zRb5A69ygFJbegbF27MfE6VBh7EXfI4AacjmdMzmAYLM7zH3AcT6A8g2AxkIMZMn5+mLD6FS/PL0hLxsvlFfOccToaDpJb1lp90RrHvBUyh6bBwJEFZc78yPHKfBfWwFiAkOGsxXyaxB3jOKo+c7aCIk4pETPtESGIEsjxAYQ1QJRsg5QsYhlhigHAlRKtdVX83CKwxAzQgtEFUdAENSDiLdQazHNLL9VaBlQAUwiM0a1w5GCNESUAKCYCJsKYBGMzjFRIJEsgR4AhuMHi4TDVIEjej/ieGcz/v0h58JgyiiUMhwmHhzM8CvLLhTOHqMAS7+OpNBcPk2ElGGNRotSIEEU8RULKbGiY8jd0BxR0m5Z0fL+h8+f3rLTUCXsRrLLI93CvXKUpAZE35d5PrhtBu4cGf5SNJdEEz1bg6zWUnAMK1VYLjNuAvLtJ6f9UiKuA+SEKTMlVABsUELWKYPriDZYhpgY7Nj84UBBywS2kN22u16htkIhySOpQTnz/rh2qHFRLUMeORI7uFCELCypA0mvnoi5eGDJCV8nXyaUgQiFcprxp925jZp2pfuFeCWyQPaeoFbS67AqdpaIBSTwEuQpVfQFkmPpUlQBN5/OhYPUZy2qwrITrDVjWguuVFYAQCkcx28RVIDfzV+cqANgORtY5zZA3l4xVJEM7yjDbWBecoxr7JqCpJJSS6qCwL5k3UGMApIxcEnMMpIzbwkxslwuz9rGbI+C2XOt9TqcDjB0xxgKfCshHJBASEYZccLBcxpRJbRLW1Qtiws9EoohsrWHDG3UqAGLN42YOeYfDwWEYuBhSSkCMr8g5szUkSkAuCa+XFxjDQVTbtdbyxZXaVsdClQDvTY0yb5H+g1itBO85wI2j7LWgDisBTLziMZojiCxHhydRAnNBKR0JEAEGBdYSxoFAcHB2wjxzZoGiS9YAKAnO8rjN06laoiUb5ESIsSDGgmEwOB4dHh+ZI4H5EgYhpvHVkjVUMKgSIMJ/GBiW5jnX5mFvbOXEyM31cq0pkoMbmAxoOGJ0Ix7mX3CYDqA0AsXAGWB0hIdHi8vlgtuTx2294uX5FfkMODjchBdCiXdqAN9hhrMG82hQnENJplZNBIAcCdaxgTONRzycmCTJDYNUzPQIgeMwkq4dz+sq5gKQwWE+whSDNbDbLCSDlBxSIRhYgBysm2HHGZr2ervdBN1bMLgWI6Clgw/TiGG0OJ6YuvkwjfAeKKlwf1iDJMW2BiS4uhaAQhEgUQJMAgMRrABwQS+uJ/B4nOrcTvo8xqKQwRpWrH7BZfHwMaEYAzfPmB8fsBYg239jlJHtRFi0/U8LGREI1iQY4tRHsXhZ4SyuKfHmb+UOuHN8L3S/h/y/5KeXL+qmtIfm+mPvRtgL/m9tW21LZ43eg8dZGLwN1iP0ugKhFcT5lvvreW/dK8TzTIT19hwmnZAfCyqyQQcqhLhrREVx1Lpu0b0axNwKURBbzaIMsc+wCWae6w7GUq2YxxKaI3v1PAIrE5WNgAigDAJr/rnIhBeGPR8CYmZBq4iBCloQoYj/3FyXpgQIxBckcnxZA1bPJUO997gti8QGBG7n7IA7vAw9yqU+0OqjtgbkDIxJcE4VgIaUGHJtk87NNaEbU4wR1hnM01yHQyuc7f3R2i6FvKvvs2PbUwRhP+9ZWLe8eGYAZEg+hqYoq1WkkLxS+gLYQNfOufqd5mWrAFdBcT5zGeIapCRt5TLBESk21kFVNBry1wwG7Wt9Rg0AJKIaIKh92vvmG1TaAqj0817B6AMle3fTHrlUN4S6AXSv2QdJq7XWuyf4dw6Hw1T98ftnV4NFr6v9rOfq87XUzGYg9FwGveHDpEiaVVDg/VoFmrUW8zzVQG9j2A3AaaUSi1IK5pljKpbbTa6vrg9eu86ytjpNI6M9mkoqytjpdIAbBo6z8Z4zLaSg1erZJYe6TYiryWwh7yxsihpPUFMOh6FmEwSpvnm7XuGDh4XB6ABNOSViAi4uutNKTauxmXKLOQCxG4P3t1wj+3UeH49HdlesKyBzoHEfAK+vr+xqGAe1svgcx26CISZg8fxc4Oc6zFwK+E9/+kdoWeqUMpbbiphijdMxxFUDnbEC+kqp45gQwVUNi8ZKpG+Xyd+HBJQtGq2CrW2AO7T6ze+/HmHeW2K9Bb11M7yvCOyVgP11v0UhKBs4evO/rq268W+DmDi4Tjfh9hz8/Zfv1fdfe+ZtH5g712C9gZrA3bRJ71Nv0//jzXMWcXmo5V1HphSgcBCcPhcLJ6rn1ZzinEFFo/31XFUCRM2tlrxe0KBIqpEWvvE+YFkXhBil+l5hPIMIZLkACylRCZQKFgKhsTIRQsTq42YDWvw2JsCNW2HQ0KQCRa36YjfVSpYywtzVOwGMZl32m7wKUBZOtgoWHivO5+eNp1eKm3BSgaoCoAm/vhpjj3htyXFYOEl0fWyBbnz/1j7NSIiRI47necbhcKjV6VQB0ZgOVVSU2U4FtT43+589gl+xLC1/XJWLPTKgv1Mfp+4T6hPWawPYsAPqeT3StI1P2aJUe0Hev/S8PnBNFRbt02r9y6uWnZX76jOO430FQH3Z95QA/VyVClUCNBpe55becx8XYY3l8s4oCIF5A5yzAAYQzTUAkARZZS4Cnj85cxppP4beL1VJ07EmAsZxgEkErUiZPddYmOcZIDYesghZXYMxMWkW6boBAGPYuu2VgKIoII+tc+wG6GNDYozw64pFYn5GY1AGFd4y1sYIZ4akBdZ7SKaCKoyyXtRVV2RzM4aZJmlCjZ/Yx5OgcO2IYXBsyVsH64Y61lr1j8D7XAL79KeRswH++MdfEELE9XrDunrcrrIGU2B3BRl2UViLnBKK1Abx3gNuBBnHLnsCyjvZZPeOvwoJKGVvwW9hej4IyoVdBU5pVq9C4c0KbtfU6/VKwF6Y76ExfVct/0vKQ7/Y1YppaELH2HQXCWiukc3TvlFC1BIn9IoNO6EBvOkvtZYL554Sde/ofs++MioAsmh/YvG3zU7vWbrfiqVqdGz6NhFy5nZlWIbreqWkGFhYjTAQnCGjwPJY2RHGOSR2lCPmgN5CswlcHMlKf1Ibgyw5+By4x8Qzy7Li9fKK1XssK/NoQ5QAOwx8rYGFaErN+cGKQGP5C7FDFaLmX3NhHxBgwcFyKjRU4WhWdouI5/gGC2cH2eBFoVGlqXueXhCp4FRLcVmWGoC1FTxM5tPPNyXy4fs3FwMLFAM3qEAyNQd8L1AZ9pZI+pTx+rIgpbKpM9/P756jwBiGe1Uw9Sx//e9U+DANKqMLei31vaovWJ/7XrzQPiVQLa2+n/psAI2g1yJSPXKyLEt9hmmONWq6X/v9NXtloidk6VMsmwBs9Mb6e808URpbhf4fH+dKkqSEQtoPx+OxCnz9PueMy+UCIk4/7MdFsyv6DJg+DU/7zVoLk5h4SgNkeR4XpBxRCqegxeirS6+UjBA8rlcuzOMGC1ARpMDUOQoh8FGAsU/f5NgJI+l4LT9fA4ABcHyGMXWdhMDhjUU2IyLORigyxm4YJa3yBCcsfPW6gkCMbgBKwTQ5LvFtlCTqKAqYA4jg14BAEQs4o+bp6VkQqoDDfMBxnpnRMwnvAJFQOhtJOy1M3Zszcqd4Uc4wqcDaAc6NEmTdFHo3OMyYYSwH8PplZRZS4RX44y+/8Lhfb1iXFYN1uN1usCCkGBHWwEhzSVWpqnNWGRkzAVRA364D/LVIAO3+fg8JaB2xRQ3uW8F6bf6lVjV7qwi0NtxDEnYtuIMKcHu2xETteiQxENic297L7r76nPzWkID2/Ju2lfqj7vrtWhxTUAT1bopA/xNio53pMbv7aLu2/bZXpt6iIxIyKc0jiWwo9W/D3tJ6c6nYqeoHQBqQwsGZGm3PGxQH/xhTkIWgBUbnT6nBdT6w1b6sK27LgtfLlf8tnPsgZs1z4whjLNzAm0eMWZQARR0kiE+KmcTIaVhcWS/Kdxl1F0ObA7phNVY302n7OicVSmV3RBZecoXzmKr1PiueCte0g7D5PW/awuPIfdrP/2o5d4q00v7q5xsFuRThQAg1gjzGLXxcdou3FzT79veCR+/RAvKmmhUAoAphhq4bKrFdT5Bn3RZ90mtyGmKu8LlC4ipI+5r0fftUYeHgMAdrG0S83wf6zIG+j+vYY6s86Oe6EfcCWRUXTlPkvmipla3ojiImquwAwOVyEabAGysvokz1ykb/jH27q9Up/WZlk9BzuC84/Q+12E9jq+T+i1hzxjSP0DK3UKSgCPMkONZrrwRW40vSRBtTouTn6/zVOZAjK+1ZKLtlSAyJbBAiJXXHKLfCOI1VoV5XrqxorYXLSojU5tGgFQEFRueUSA66XZYFtxuT9aQYMdgBeWx7RjFMBAUw+uhsg+JzShA1qM4VU1qJbHT7KaDFmPR6QkgVIu+txuB8PgEgWOewDCP86mGNgb+tCN6jCG1z7hSfzRoSJS5nIJe/EVnQ/ugF6L2/+8/3f++1f2BrvddrEQes6ef76+2v3Z+3v/57CsL+eg0JaJr/Hibk7/ObzaRZ/P1936Ic7YYCwYsc4q8LyzrNQzXyTlm0ZPlt5p7JlEGCXPACs6Kdq8AghpI2SlQBqMf7AYBQpNxnycTkKTomMChkUOTaAKEQXyNTRqYMHwtCTlhWtrhv6tPynTCVBU3E/kcd25Q50nldmKDl9cLEL6/XBcu61sI76g4YQmYkwLEGHFNmxYWU+ljaX0QZKRpPYLgghymgwpH8NS8fjKi0PmpjpVz4MSXYGKFuAHGLiuWQaq73umxREBVYvRCHCOVmheo6aFCzsw7jIOx+pikj9RqiBPDcZGKf/dFD5LVS2roghlwFpAo5bfPpdKoCpp/LSri0CXDMrbiPIgH9mlYrfZomHOYJ8zTUdu2RMxUkCp1rPr0qAb0PXO8/TROOx2O9hyo6r6+vlT+BGfiYxlipa3vFQZEDPfYuAKDl4GsaXz+WvQtArfd5nvHx40dMk8PpNNTxU+VEFR79nV6zRz32tMa9AqD33CtjPZIxSHGxIEVrcolY/QDl4ketFMmuguPxiBA4WPHTp9/w6dNvXClPgl2HoSlDt/VWYwAMqI7/PM8oyAgpwBTAmALOpmCWQ+ssiqzJBStgIpBYeTdO3HzQzBKHYRzx8PAB8zzj8cNHaED3FVeJmGcUbD5MGKcBD+cZ06guLgNnBhAYAeD0RF8VlHVdcL3eVM/B9baK+4LrIvAzWWHxpEr6lZIQGBWdAw7WAIdpgHMDxnkWtkmPcLuhLAvsOMJah+PhgFKAVfe0xG6R02GuWS3+FDCPI26XK+ZhxPVywdPnJ6zLgtt14f0emdEaaxAkgLBkNsZK3smZLxzfmR1Qw7m4g9XqpO7vXVBb/VPkTilyhmowKFzBrdMomwLAv/ma8N4rFb0y8t57f409mtA3uPQQb97CtBsJSq0QBInisr1ny+/dAgIkEE99XOlPBd3bv1kh6tATNNC/oG0CSjTDykej5OxLx7bsgWYB8J2MwHJmN9psgXc5BnU+NBi+ADnBe6ZcXdaAkCL8KsVtSBd24nfNNCBCEgKe1Xusnv34a+Byu0FerAQUQSGY4jMXQQIkWGGfOVDk+WqMA7F/kBSFejO37imxaimWWjhE4UpFXlQJ0Fz7ZVmRc4ONNXCoFy5KXtM28kaN3Gqwt9iDam107zqGbBmk9jgVVdLxRrUIc8f+phbp9pp4A7/fg8z3BD+6jvqcbaBZiJoJA6TN2t24jDpf+/6lz9MQF26HWtHjOG7iFjRSvhRW3oz3SLa5ETb9s2tHv3ZVUAMNZdgjBfos2g8aCzBNE8aRMxb04LLDzFHIf3PhGb5fs2A1hbpXAhSl2tNfazv03zU+QLZRzrJo7KO3G6dbqkWsfTIMjl0FgQMR/eprJobSTysSymiW1HwgwjgMIAO5RkZIcaNQEzWXUUpc4a/1MyMM1jETIZEQU40DBqngOM8zpmmsfVj7TtrjHFeHVGrkkoVcSdAQzT5Z18D02ZU4LDG6RyRKHjG8rvM9W9Q4JllXuWjwtFpvHMvjBpJCVQMbJjL3Ys6YrYWxDoNzmMahBm8SMgyByYmkOJizFkgZBoT1tgI5Y7lekWIrQYzSyJdkkwKnaBPuuarfO75TCdgajhoE997f9XORUll+nUuuCkGFzhUyR0NoK1K7g+T3/rz+vT/uW+nba91TAPTvXDrrSCcEwIuGABBXqCYyzFBFEO5wDbbp70f1N32/qFiHCtwCIGcQOIWEA+nk9xUp3m46+z6pFfUEATCSFmZEOZAfA4VTUNSKLIWQtDpeMqIRN0XAFIKF8n9zJD9D/oScDK7LDV5gzBACLpcrgmzGuSgboYEbeKEzjzsAIskwYMreGBPWxXP+epEMADuAyNVnz5pNIDBizLkK/yqcpd851rGhSpoaqUGWMSYUNL+l/p5k8yiFef5zWqs/X4P4ao11+a36oDXyXi3UDx8+dOl2EcvCZChkm/9dqZM1wE8h5Gk6SNBlC2BUa5KV6lQtG0191fmuVnQpnMM+jiNQgMMMBNsolJmIBhtIv3cTVBdGajztOs5qlc/zXAP9mLZ3qHC5HkyC86Fu3j2svUfkFFnRdRxCwJ///Gd473G9Xje+b722og56PW0Px5rEGmle17UcvftHrXJVZjRQT/3/qgQAbwsd9QiBxhE45zAOLRBPXWRay2K5rVjXgEOIGLT/R4ufPlr44PGXP/+lnsvtDKIENEWIORkMUJisiecfkBwr2jUrRQrxLCvTGBMVDI5jFwbnMJsRRBwn8PK84OnzE4APMOYIY45wo2VIOgMF3Aa2xg0L/URMvJMTgljTqRNIWciTNHZiEXpq5xqKxLEUZzYSLBdKmmcONr1eOQ3yer3i9fWCl9eXCo9P04xh4BLXMbLfnAqwSCrdunJgY4ih7n+8lVsOuDM85tfrjYP4jIEhB2s50j8XQpLiWKuPrGQYwJIB2UHiJgA3jJiPB6RSYNYV6/WGl8srziljPmSJUzjgcOAYEePFbSEpsAyJEJwljIPBPA9IYcJxnpFCxGIJ1gDVDCFW9gw4HJmdtm/l4XvHX50dUAWX/v3OvYta1mAIWnM7qaAmvlehjN7W7ZSMOwJv/74X9F/7+57yAL23oBbVCtrdm1A4kGVjVXYR4u8gGNt+efsHX7KASkYBW61s6bOg7kDqXR9sn1EFlUbgsvQr9VYFYiHnVpQiZobNmTBHecH5MEXGT/QZ9bsrVL76iGX1uEru8/XmBRHgDYghPgMXU6cEcL+VwiS1bFFLeV0tSALDjHsyd1TzLvLMBczfDxQoRb+eWqpG2WYVNogI+0DZxykWWdePzVfafLHNVdA2ehXgGqWdc7N6qi9TBAlH3E/IJSGXLkZACrWoEqDnjxLU1FvBOu5FeRQ6NKEhQS12QYwl/lvaVQrVAL9eMPbBh330/N4Hqe1WWFoFYI8W9DB7KQXj4Cq0r1arxgvcUwR6i1+Fv/qCVSjrWDW0gapLYZIAMmMMQryhdIWa9kjiW6RvK9z17z4GYL/G7yEMwBZpISqd8hArgpZ0XVhVHlp5ZB3zPkajz74BSCzo7X3VMGvPKChM1nUsY4sMI5X8lF+6CLqkBHGQ+CR0e1v//LnmtDeEoEeJ+r6uyqQoN9ZqYLPUmpBaAjAtIDHljCQpvq+vr7hcLrherg2RmdjvTrr+K5EOt1+LKnHgLcseHWrtySLpxdYAqIiERanGkewDAi2aYkS2SRCg0QJMLRVREbfgA6z1IK2ASVuaZkbJBL0AD4MxJApKK6bVdu9Wb8RIVpgR5ONeFtl7x/fFBOyggH02wP3sAADC5MzQE7pFJAs4s3zSTZ5Z9Rh+VsRgD0fuN4x6p24R7o+vuRX2D1sJajqrRaFXonY9DQJhCLdB8tX3vm1FvT5L9rf3ziUDSChZBZVs5FnTacQaFhdm28Dbc/K9bYW7c2luh1IaxW8ILZ8654JbTEgFSDF2zyzXrIFwYCGcs+T18+J/enrBcltwXW4IIUpp2YjVe5ScBSUxnDYjVipb5/0Yi4AR0qFcCAUO5KwoISSoUl0GYt2xq0AzFrKcy3uhqYuMQFx8RdAaFGDxq/Q5j5cWMiq5jT9bYLluIs2Py1B9n4ZHIIGBR/zyyy84nU74p3/6pxoAxlb0Ah9WLGuzpplEhTdFhblVkFnbCveoP/hyuSCpj1MjpMcBh8MMouZXt5Z9mlRaNPt8cBiGXC3sBje3PH1FAXrLVn9PRJL333zTp9OJSVmEs1/Ty/pgxNPpgMNhrAK7z+EHGk+ACr7L5VIzC0IIeH19BQBMAg9/+PABDw8PbMl2Lgw9R33UHFTKpVv3sUe9YL3nFiAifPz4sSIMqphon/T7gPaZ+vyXZYExQEpTVZAUnbHWblCLHtVQFETLI6eUKtlWC0ptWRSKePRZBqUUzKODIfb3s0CXvU0UXq2fYa9MUmStrSRBbnD48NMjTmepdSDupyKxSj39Mfd5Rggrnp48F88KUYLhHLSMsKwsxJw4Kj4xJ7+ibjEEAFIK2VBFbpTX43q9YVkWvF4uIowzzuczjscjTqcjjocjLBIIGakLztUxyaKcoPDWG0OCX9lt4UlcY2RgzIhhmODGCdYNyIUQAtdR4PbwHBsMKwEpF2QjsQFuwDRyhsF0iMDTC7wPeHl9xW1ZMM4zyBr45cp0vzECxmJdrnBuQM6qjBMsUSWmCn6BX69YbuwWoBIxDTxnFu8rPwMr+n+jwMC7SMAX/r73+/46vfCl0mUadEYbn/8W9t4jAr2m2drzVlvVv99HAOpZfcvrfxDraw/Jt/t8HQlot1ZUZH8/KXFbfc79b0ztnmoJV8RCrqMGr3wmWSP1Oiq4s0TAJsmpz5lL4MbMSkAWJYBlvrg9bGe9Zxa2MSWknLGsAYsPWD3n9a+BYWMfdNPklxXWRNspLaVkYSdUywTS3wLJEwR1EXi/avCkPYkaB1CUWVCs+FIqUEMEiQcADHulKpqxV2jbmFDr56LsfyosEhrjYx+936xR9VVr4JpadUys1KBlRQJYEO3nzDbdsJHSRISoxD7iFwW28R/dbzWtqkEmb0mG9H76u73vuxc++gI6Ihd59WmA2u4UE/Zrto9F6P3aADoB4Gu/qfDUokQqjPYohF5PBaOzDtEm3Nsr+vb036mw77M6VOlpY90QCBWIfftLh3r093rvpcr3uq6VG2D/PH2/KdqkikXfD+NoxdftkVJTDog4sFfjAZipkeozatqaMRO776wRxK3xBNSCPBrbIu4J7h9GB5WQyKqyIGuVrXES1DHB2BajkHOq9SWSROGvUib6crlKSe2VjYru+cdxxDiNoBSAvF1X2qfN5cemaTVGSep3GDFMSKs0sotRr6Glv6XekuwHQIgJFowU6H7K+4q6+zKMzt8YYWCRU+bYg8wXyylxTQJumSgAVMsjU5U/QjuOUoMireV21iJk78iee8d/SHbAvd/1EKRCJj30eO9cHcgeCdhvKLpAdFPpI4C/pV3dXyr2UaD3avfWBXhvI9luqM3y3wj/6uoQSdQhBrkUFOqDatQik42ElNBDzhezuJLbZCMwUW6ST5QKRQCUD3xdA5KUtI0p4bdLQEgS9CXVu/S5DHXVqUzv22S/n1pr68qW3/Wm+fgNEiRTYEXwkWjTIKCkVia0CDrAgluUDq1+o6/atcxXkI0RSB9SoU/Sn0oBB6K1Og1GyscaQQJUeSpFx0/SoIqOL5f45D7PIGKrqk956pEAnkttPqiPXUl3qhAxnIaqv/We88c1yLCuC4EkNdDt6empWscxRXi/1Pv0zH4KuzNL4g0h+Jp+ltOAkps7QIW6jlNNQcRWCVfrV6P++zX/8PCAeZ5xOp2qQOqFpwpQJfzRNvfKhD6z/lYVl3VdAQCPj4+Ypgk///wzDocDPnz4sLFGl2Wpv+vXdM4ZxrJS1u8hdW5LfMEebdSXXvfz5894eXmp7VYE4nw+19gPABXJuN1ukovfnr+viNiTB+lcWhbm/9f4B+1vjdPo97Q+AFGVob7vBtsER49g8Nzg6PgUk9Auq5LI6MDhOOMwzZVMSBVP7bdxcDCDrejQunAq2yoC2rgRwzTicDping84HI7QyH51m6lyt4ZQXQgxRPx6+Qu0QFXKrAQomqRK9ul0wOl8xk8ff8LDwyPO5zMr2etNKmyGCsVzZcUbNIaIiDBYhxgztBQyEWAGyU4wXGI4ZQCB+ynGhBQDCoQgyRiUyGl56bpiHgxsGmpKMxOUcQqiKjUA0zyzspdECWMZkMOKXBK7g8jAjQ4GGfE0I6wT5nnEOBiuK0Di0jAFxhY4ZyQoU9Ba87dCAvAW3FYri48e/u603u4fpbQz9D2X0vJGgSp8+fwvowD3lIb+HXjfDbA/b3tQNZbkim/u2Szwsu2banLuhII8T/28CLwNfdf7bZ8rl9LZ/91ZpUcDWjs0PK5o9C3pE/SaKsPbISSkyAQ5IWWevFFgYYHbpDtYCTBJNGWNCRAlICuqUKTQDtitIC9wRAA0zaY5NbhhSSLvqw9f3qoiJNGlJN9zEBTqnCJVyEiftAu4FFRAXSJKX6yADpHZXFsD67RPm4UGsfozcjab73QTVwHTCz597QVbL6i2ljojKarQMrRc6iasGycT/zSFQX2GvWWqMKhfV6x+FZ965IcvW8u5t2q3Ef20aacee0i/h8Or5d+5MEopVbFURbqURr+rv90r+XsFZJBKbT3bYN/nvdEAqDtne817RkQf5Kfn9BH4apkz0ZOtSlevCGp6JCt1XNTHUEOSGjTNAbB9X/M1XFUCe5cT1xNo7HNFDIeeylqr1LEPW/coKayUGa3TUtbDOEKjy4P3CMHXZ2dFgyPVjRQta21vmQzOWRgZd/6dQarEVqqsU90jc8lMZ0sSXwVImq+FSbGiAjV/vhuHnFLdz6y1GIWD4Xw64Xg44DDPGJyrCFzuELBWSrwhONZYwDZUi/uwpefWvVdy81cpp6zkQM5ptkcjiSoReEWAWx0WWaOaKaQEYC0A0GF0DnlISFlSuNXvj5bfZIkwOotpHDi9dp4wTyMWADl7lJzAtlNfivzLMm9//NVKwF7kv1UBGvLIOg+L+EwtW4BEkqWqAlQUuAnZ3eJtBBdtEfevHsb8PYeEqaAAkmPOVqUKWl0Y2CkApeabK1sUNgqN8vM3wS+CT68LST9BM3ZNzigGkvFLVXloMQvqS1dFIPOZOqFIF2FLZVtXZtFbllgXSIgRv32+YA2RrYGeUIfUV+ZqH6echZmPN1n1R/kExMTldlMuSCR+X3Ki7Fl5tkYWFBMhxNqLVREkatYaQMwtQLzhQZ/RGBg7MMxPskkJGQr3VakziwoxlSqJm4SI2b26abKfMzrPxvFtANleQNac9JVhy6enJ+Sc8fT0tMlh5/MiQgq17vztdsP1ykyJKkCdcyiZNzaNxn95eanCUwUVHx1bnIyFugw+ff6M6/WCp6cnjuamI9Ogdlaw+vN7oh8iqpuZ+v97q7Vn0qsVCpeltk03YV2n6uvWo1ckejSltzp7i13z79XqBbDJWujz9fv756zMlo1mWIM89+yEvSKjyszT0xNeXl7w22+/4fn5uTHyiQKiv//48SP7aGU8Y4xspQmhVAgJKfk6bq0CJ1WUg9NJi6BuTSnj9pFcS7MDIJBznb2yDxBKIdz8wpH+Er8xTRMmM+J8OsFaZnK9Xq+1QA0jPBMOh1mopaPkn6cWoJhVIZO0vj4OAYAbh7qHxVzgY0IqC1ZR0PbKM4BK27ssjEwwoQ82/WvIYBwGzPOM88MZHx4/4OPHj5gPB0zjyIqFwKJEVDN5Xl9f4T2jYACq6+B4OGwQGc0iYa5+NphC4FTfl5fXyvTILJ0TrAVK5Pnx/PwMUyJeqPFX6L4QE9Mkn89nHA4HPD4+YJpGpByxLguSpFIejweACDEEKOTvCDgdJlB5AErG4Jis6POnT3h6SvCS8XAQRGrQUuR/KyQgqzZXhTKgVhd1Vpsxwu+uFmNu9eIB1v5M6X2CBsp2ZiTQQoWWLv7eZbD3r/Ud3vvqdFPY+xz73/UDpufoe8jN0tfjnl+vShDqhX73+c6iqe3tVCZCH1TZorkBSIW7hi4wRC6WLFjbz8KMlzJb9yASgW1hTePXr5p2ZMtdc/B9TAihz8nvlK3N83Y5ydCMCYjCwGdGTXdjVb/1GfHYZu0krVBYCkJiboHmB0DtE6rPbWpwIanGLlZ70o1f+1jnn8w1maVgS/+tj5ubkeVZGvoBNB//RrWVDa9Znewy4I2bgMLMbCF4eL/idrtC8/hDjLheLgzlB18FxuurVG1L26BX9teaiijUWSKBWr0lWccsd1ZUbjzoakUOdgS7NVpWwN76Btoa6a1dFWCqBGzWArChxdX26DkpJkmxbNfrLfDmx92y4fVoiyIuKvj30P1761p4OOu97h3aJm1L/657Sx/30CMSfQaBKjbcPxnLsoLLJe+fqxFUKcKj91sWdoEorfA+6C8lnnMNxWn1KrRvuErkWhES3Q99CHCFaaf7sdsGSCrSxxaw3icVrg2ScoYRBBBgF4gGMBYYFMOwNu/9SdrLq7A9C6+ldl9eq33cA4AaR2SMxXyYMYuyxC49LU/MBkBOQudbGhJUSqnuQGed1BEQUrViawwNn897GLyvvwWY6nhwXE56GEcYMvDBy54bQTmglLUZHqWg5IJh5NTVg9TfKDljXVbEoCWaOZBP43lyYgtYGQ5tBvI44DhPCI8PSCnVWIFff/sEv3qZT7kqjLHLgvna8X1KQC7Cq543i69f0G2BNB+f97eqZfIiGjZQo9lpLaUofJdgJVVK77VXBvYxAj3rlyoCfTRun1a0RxO0TePIZWlX2ZC5TQ227JWdPi9Yz+uh1T1y0adLNYHEws1Q0/K5EJCC5obLZxrOSTfWsRUdBXaVgJdFIsyfPj8BZGHsyOxV41R/p8rYugbEEHGTdL7VB/iYcPUBPjQoslpN1frtUBexwpknweC6Mk+AMvApIU6NVNU0m5yrq6FBdr76thmu42e11tS0KZIAI+53B6FVZAvidpO2maa0WMO8BmhFdXRe9HPESDxBDK12QP9dmztt3upxvV7hk69w1ySlTYPzAAqW9QZQwa+//QXjOOK0nOC9x8vLC1c2FOtfYfqUMub5sCvcEkQoLBX6V2FUCvsCdd2kJCQvdwUO4XQ6AQCO808gsnh5eanKMoBqtesm3OYqapDj5XKpvmpFEPq5/vr6etfSttZiiR6vr2tdiypEFfXoFYkeEu/dFEATOH18Tu+q0OfV+/NzsBKggrTnSNC9pEcCeveO9uNBrEd97o8fP1Z0YhgGhBA2roLj8Yjr5RW/ffq1tqnvz54I6enpCcuy1KwLve6HDx/q/VSQKyoDtLoGfaaFokuXyzNi8MiFM5vUnaRj+fDwgCiWfc4Zq/dS38MhhLUiVyklIbNxEjjIQXIFhOttQckJLy/PsNbi4eGB957xgHXltE5VYDU2ZhhaumxKGcGL9Z+5UM44D5v12tCQSQJtmROgIMOHtQuOBXKIyJEzAAyIkYsCTCPHVCj18DC1IlTVFVcKYs6It2Uz96dpwmgtHh4fK5KQc4b//BkpF9zWFSWsIH+pbgUO2g34h7//I/74yy/45Q9/wOPjA/7t3/6FUxyvXHL748dHjONQmTS5JgNhmmZAEN7BGRgDPD6e8U//+Cf85S9/wW+/fsL//r//N3z67TPGGGCdwTgyUdH182d86/FdSkCMEZaa4OmjXvvJrYcu3pgSM3Z1mj4H6ggc2f+ut5gBwFgYs/XT9YK7P/Zt2EO1OtHv/a5/MWzfBJ0K7P6aamWie6+PADXiqaICJAx8ZERJ0OC26jZg+E5aBE7vk39LUBqIqXslg61WyluE9eq2rFx857YCZGBthnUJPuaqBHDaW6k+rnXxiCli9QEhSq2EO+iGPkvLu2flhCqTILW+MJLeqRXByLTfg610piBW1w+fo9a99m21/PXfgoiom4ZknPbjUruwH2MdGdp9slEceZxaKpatmytvQm99xrqpVotFLRigBoRpCVwVMlxHfqkbrM5JVjKxUTT4Xmzh6GfKJU/E8RWmpG6O9ilVHloUZisMgdtyQ8ktPVCV954kqFf2e+Wjdx/0Fvo+3qEX0Pp8xjg4u11ryrLYj+Feea7oU26FjXpXoCro/WuzVqm5z3prurVr65vf7y/6/T4Dos+EuHeosnYQqlhAELuUoDwe6vNnQhxTv9c+jpEZKqvlDBWKrrrFVHltgYxdZgGaUhVjhLMOB7mXtQ7jCBxPJxRQJbvS1EyGqnVGd9k3WZEIjffIdV3GlOBM4fVcKbk5KylUoyLBGFvT9rxS6HYIlPY7AGFYTAjrKmx+GXEYuFiZHFUpzOwW0IA8dgcl9JtCdV93SE9/z40RxwNZ9zcyBsM4ouSMcZqYStw5kAHmqRH/xBQQgsfpdMY0zc3NJERPhFKZAgdrkCIXCBodz7N5nnhcfYQ1BGcN3MQMiiVnOGPx888f8fz8BBjT+hflrpx77/guJWD1K1DcGwtcO85Iqpi+WtSzr1YBESHZRg3aW9H94NfFbB3IDfXzPeRXB5W2QUb6mR66IfXt6Ae8f9V2GCNxZrx7EOjtRLFGLGKeJKUKfIG9laDHsNAy3QajCxri31fAmfnxLTRKnYijPQssF4YonBlw88y+9XLhvPzXy8JIwPMVIIJ1bJWz9cwvhtuo+vtW36yKnDmaAKaaliDLPN9UI+Ub1A5jq2JSCCDrhDmRNzeockRadEgfmqPiAYHeDf/W5mb91mjxujHzq2iUvsh/pf/lZ9Nx72I06hwp9a3f3hVWBbCx4FTQ9QKmD9xT6+h247zlTZlYasFQarG+vLxgGIZqdV+v1+q6aPPJwFqmXW1+6VIDsXoBVIoSE7GrgIU9KxEadc2wOz+06ZSbnAv+7dfP8D7W62lk9fl8bu4wieTv3WpEzS/fK/QNom4shPpcfeDg4EaMY1MwVin/2lP8Aqj++V6B0PWr99SYh/1a17/7ecSCEtUd0B99kaIeAemv0xM/6dzoXQG9UrNXTqZ5ljz9lunQMiRMLTNsTCOSasWrSCB9FmLNKh4wDKrYEbsAsVSXQkVrBk7lu974u+vrRZ5jgjEO0zgDEzBOI4x1uF6ugkwxmoNSahqm9l3Omf32geOGnJO2iit3WT0mcjhYB2MTjHMogh6sfsXSKWpVmZP9TxWqFuwqXDE5IYSMmyDKOhbTNFVFVxXrQYi1NCZjWRYZ53EjHPcKwN6NYy2XRVe3tFKOG2sxSczMMTKh2zgdMBrCH84TpsFxTEVkdPN0PHD8gTASxhiQQoAFV2c8jExzfL1eQcSxIcMw4nQ6IYSA5/iKbAnDYPF4PuPDh5/wcDrj9aef8Nuvf0EKK/7t82dclxW3dYEJBj415ehrx3cpASFEGIiv6A2UztamzBvRFtlnxTBnsyS489lXxJO6cQS80eYdYDZAwVsUoNf49xaA/qYPFuo1vXsKQIVPwcRFueaEtmjc/lUDEOnePYHOhBbjXtoJ6ad6Eh+xJISSwQWEOFeUqMBaTrHLmX+zrAFeIH3vI663Fatnxj7WWnNVAkiC+lQJiJLvGqK6dxLHfNAg2ogBkMVCZ/ZCEhUFVdCLT55QtWRTIEoEbfoK0BiIDjEoRd4Jxmag7PzL8lJNXOMHdIxIFa5uzPuj9bH66KQVXY48Clcg5DnMihdzfzP0qNdt1m2qFrxa232wHF/HyKbf3AnH4xHTNOHDhw9IKeF8PiOK8qVogvIPDEIAosqIkkJpvygs/Pr6yt0ZPVAV1Fa5bVkWOKflhh2cKBc5F8zzAqAhGOqL1qA+a+0m/qBfe727a28B99H5vX+7/V1g09Yn/55Lrvez75X3/nf9Z/vva2YCgBBaJTug1TToSXj6sdYx7mMB9N89UU7vxriHjBK2MUmquKgA7LMitD2963EfN6H9q88GoBY16tuuwpX3EKnB4ByMZVLZpDECRktNo1rzOTeD62R0LfCCsW5AH/icogYnScZQCgB5LKv4vbMiUdtKj7wXZ3nnPqulo0cJ1nQDSuHKnyF4xBjq88YQELwHUyonUXzY1UQgCfDLkhVhME2MqoXgOXja6l7dYig0DsJYC2e46JoBmPCsZFyuF/gQ6p7qAyOpBbxXK1vgMIxskadY96giis44cKQ/4GAN4TBPcM4i+JUxYMMvZwjFGIyDRSkZY5SsDWswzyNAwB//+AuW5YZLCJWX5XuP71IC/BqATpjutV5rS93I+uIpmprRtPm3QliPN0pALlt3Ae5Av+98pkev/TVNelsFrN/MVGjopaxtMBwfZvPbvRJR79lZ+nJzQEQpNAK+vHVz+BzhuwqFSjNqjEKlvIBfbx7BB7xcVvgQ8Hq9YV09Xq4LqqCuZS078otCSKUR3jREh0CDCl8W2MyqxygIM/a151AhrQKajOMSoKRPuc3OYBcI0wejcCmiNodYCaDaVXcUAR6cOkZf2vypO710fbtXINmi5mfnjY4tsz5CnvvIoxS2yLwPVfirVbedTxw/oEU81Pd6PB7xxz/+EQBvOqtY65p2plkW1rZoZSKSANA2T9X3zHz/BauMhwqOlk9dMM8TpmnEYZoxjIOgCMDLaYUxrlrfPVqnCkjfV73PXz/vI6v1dyqU1ALr0UKtZNeTme3HQ9GUw+GwEbBa22D/u35f2SN5fbBgzhm3m6/Bq70136MOqjj0mQZ6Dy0CpXNDf9v74vsgyLrvUEMyeutTFUDtW3XFTNO0ieXQ9vYoaZ+C2sPob9cC5xRZ5+BKgRO0Q5WAdfVV0eItQGtyQHLoI6wdME8HaG5XCBFEURRsRiFIXAZZkI6UCXa6VSEMY2CHkeOe0DI69BlrhsY0cuXMaYC1BpPjeJEFi4yJr8rPYhh27/kzlmURL2TrA6Yg1roPkQscJSdB7jslQEyVYRxrnBYAXG83hBgY+reMgKqivHrPhpwqAc5hGCcUsEJE4q5B4diEeRph6CDCnnA+MX+CX29AKXCG6guWMI1agrpgGCysJRwOE6Z5xD/9058wDA7/8tsnPL9esCwLcs6iqH3b8V1KQEoJ2TbN/t6GqgumXwz7DfhL7/tXBBDk+r3Q7WFCdN/3x94/qYf6OzdW/O53BQBJak/fRoXk1ArdXqMJ/JwaKUX9DbaCSoUwt7MJ4yUG3IKvcQX6xiWCqaIHy8rc/OoW8DEjJgjVrugguSAqqpBLbWOB/imsAlYFu6iregX9WFistpiF+POlfSQc1j3iWq3/gqr01DRRVYT0STebF9CXau6VzXYevRm7XjhAUKu9ooU6lowKlKwBhhmG1LcqlpFsHEGIPxhmXxFjqEGn0zRXYVitT/HN9VanMgdyO3MVyrrBc2nRIO1qteFbBTNut26CpsZLdIommpAIIWCeWcDNUrBkHEcAhBQslsVX36+m7fWWr85thb21H9Ui7q12VQh0vfVUxDpuLf+8Wc5qYWtwoFrYDw8P9bqltKDIPr2wV+h7SL7lmoeKiKSUcFtCNU6MMTidTiil4Hg8buZNj87soeJe4eljCHSv6VMUm3WZkFODsbWdqij16IDOh35f6l0r+nePrqjvP+dG+tS7p8gQDocTpjFjHA8wRJimA4yxuF5vcp+C6/VWU/OUIrwUYBhGjNMMrSMwjQnOyhrJufrliViRSKkAgV0S2k7NADPOVTQCYDcEZE5Za3A8HOGsxTi1omcpRigHRpRgRR0bDb7znoNhQ/AcTCxliI0xmKYRbhhwPB4wjCPmw8xjKZUGOeYCgAFS4CylwyEilwRnR1lnvP5eL68oBVh93MTOaFxYzhwwuSycEfT6+oxxcFwzwxnM04DDfMA0OlBhtlHZ0DGPI4ACZw0MATH6yvERfMC6LHDGYJVKg2Q4nfPh4YzT6YTD8cgBwYWRlW89vjNF8H4Kji7IfiHpYuw/f+9d/33vlQCE0lCF0v17r/3fEwg9dLZvdxKtbh9UlBKn2LnBVv94Ezv6vF3EObW/230F/hFjth0Ngtq2r1ks6xpwWRaprKd90xQKkakIMSKmjNvKWnWIBSEXrgSofUq5KRPVXWEqhF+tfR1DVQBUthsAhUCWtX4CqrZcip4rv+8nniCR+r/anlKw/0+fZ6tTNn6DvbK5H+deKQS2Pup+w6xCqVMESgEyGOrMqSARB+Ikk5GEDYwDfEL1X3uBIHNOYjWPlSOhbs5CoapWogq65ksvGGMUxECtwljbBHREJmikQTo/qxDeKETt+VMCYuRrWWtxmOfq9zdk4MwR3kd8+vSpxi2oZanrqw9669dfH/TXR8qrINdI/94K1zFi90QjdVHUQdn6tObAo0Rh6z01h1sF3n7s76VJalyE+sdXnwRpsRvFod+P9kpAf/RKgCp9vRIA4A1PQY0hCV6QjUYu1II3W2AmgIoIqOKlCoK2sVcOekplTc/TaykqZa2Fs2wZHosiIRyFf9Uo+JxbxgVrAYwiFs7mGsYRWVyI07StKulXfgYWiOJKCBHhcq1tbkGULMAG19LyCJCodovT4QjnLAaxfpGyuAAyIwjeYzUrUMCWubxWzymYIQYAWlKYFYtp5mj+w/Ega1DcfIZaWe1CoEJIQlkcE1MnG7vlwniVAlYvr9eaaVAzPMgIaRpXCb1crvj89Ix5HDCNAx4fjiACDvMMQxNy9kBJXCCuFExjKzdOKEjRsxtE9pzgF6zWwllGGtwwYhrHTgk44Pnlma+xi2350vFdSoAxFsap37/ZhHtYXS0Ufhju7FJKLWVbrXn5WydKbuw3EAeT+Ke2ucL7e+6heD32wqDdpyEEvaJS0YcY2Y+GLYnMVpA2YcpWddEHkVPlHM0vVyEllrxyQqmgZw4G/nfMgI9MH8t+41i5/UupvV7LAK+BKX4ZvgNgh65NVM8vG9eE9lvjdGB5zfm1G7lLzfovu8g6/ruhJNphPG6le+8EcSndHBJBnzNKSujv9KWjHxYVRmpB6/Vyua8IIGusBiswdjiAjIXWUfA+yrVEQctcEjWm0JRE+V6FwtatAsTULLt+nmZx8CfJyLheb7hcLlwR7XrDsqxwUkFNN08jZEu9IqvCNpf7/URo8QNKV6z1C4gMvF8BmEr1q0LpdrvVZ+mFW7/e9O9+vasC1P/NqEMTngy/W8zTUNeeKlV7tK4X7gBwOByqhdvDyPeyBBQe1tTL5+dnFrbgILo+/XIfCKbPfW8/qXO1U4QUDep/1+8t68p+XiN8HZyfzuVpDXF7lBZ6HCZM02FDYpMzK6WlFA6SJYg7haDsn8GLL1tqQugWmoW7nqigrVASw0Tz9HsUg4vpMEJ0AxXeMW63FZfLTdxqwjpImrUlbJ+lAFRQQLBuRCEgQTMhIoJY83qveeZgyNE5OGtxPDLj3+l44joFRWIbUuMXGMYBj4+PktLMlvbtekNi+BNUgDDPHKZkIAQ6Do+PHzCMAx7OZ1irFNNA1IJK3baoXPxAQcoRGnToBoexjBhFMUspVepR6yweHs44DCM+HA7cvyig6ytiSFhLQYoBfmVlbZhYOYEQOuUUgJJhhMFwcpbdLjFiWa749Nuv8IH3CwOD4+HERaGsESQhYzrMOJ7PGJ6eEMV4/tbju5QAshwZubfMuPPMm42hLjQNittZ73sfHkg2UnY2MTTdFXzoCSTu3WdzLWxdEfp5/+otFWALs0GFoj67bgpi2rd78ce9cCyFJ5NmDOhrA6ODdi9VJqQgRWJ2MYYzmYdaodqiufDShlRU2DJLF6yr1m5VODrZXUhKVEhxj83zdJtqt3PU36GD91Xoat8aIbcoUOhfoOlyxxrHLhg0J6HkLN2N2/f9Qe0LAAKTilKqyuk9BKDeuyOuAhm4kd0+isbwJp4E0s5N6Gu1M2jiQ4eglDaPStEUqPY9z1NASXtCCPASC7B9rRgG4Q833CZjEgi0UQJ03iqxEV9721+qHA0DW3LqAycycDYhW1TfNtBIftS6BBqqp/ft19p7a7AXrr07ge9lMY2u3kMt7/2h19krWT0hzx4l0na0qozcv1qD3jquxqjZFb2i0Vv123G9r2TdMy5UkerRiBACB+UNAyqtL1kp+8sptkQGhjiOZBzGGpOiefSylKtixwoX4GyCs0O9JkHS4LToVhY51Snc1qh7smVMMITfKwLsQrHESNO6eiy3FUVohqcaQyGKRpF3UU6sc8KummvaWh0jMT6UJ8AajfSfMI4DpnmGIYIPC7saZC0C4FiB04AYA8YwMCoZE2IIlY9/yhMKOK3xKO6v0/nIDIGngximDOHnmJFZ2NQdmDolQBUAoMA6C1cGuMFxQGVcGAQ1gHUGh+MBx3HC6XgSF0kAkRXFLCEnIMaAnLTwj0EhQgaJ8cOBioYIzvK4rCkirCteX58QYkYIGYfDEYqSakx2KQXDOGIS/gPjPe7P2vvHdykBTmqB69Evlr1V/p6wv/cZsIXGNy4HRGDno9TXfvHqdXTC7wMA9fv+GgA2C3nvokB5m2+8PxSur0K3sHuAqPsOmtokz5rUkmhsf5UkqRBAA1LJiDlhDRnLErGsC2vGImiZFphAxvI0FojfWAdNUZSpXQWzbhIZrG2wtq/PVWCqIJYIBgK2lftKfaZcdKGge25UeuWUOL89SLGdNq5938k/UkKpaS13pnDpgv22X0D50an+zefnklEgNMLSVoj7gQTB0MhtMkZSsUL1k2vgHQl6ZZ1lfm/LwVNEhGVZ63lAY0Ijw5kkzd3UaFHV4n59veDT56daMtb7UOeDtanOVY0J0DmolmcIHKi0hbRR26FCn6mHO/rcAlyuVwSfav74VWDOSnssSkCvAOja3Fes03aqf1ThbF0vPUSdc65CWZkSNYWrfw5Vxvo9Rcl5tJ3qU1fLu4+i72MFOFaBI7418G4W98jhcKhUyX02Qk+A1GD9ZuErAtGjFf0eqIjisiwYBbZVhWdd10oBrS5JTXfTmIg+EJPT4FoWgd5fFcfepaBKnT7Tdbl1TJNF4lcsjkdGFVAK84SsHuvixZe94nbzgCisbhjhfRBfu8HhMAvrniAgsBL8xvz1zjlWPHIGIPNXbKHpMGOaZgwjE5kVYvrxRQpcpRiBAtxuF8QYsNwWoBRYAoZxwOnI7oJpHFmZzypUgZxnUcB5PZ5OJ4zjgPNJKHUHoZkOUazspQb65pIRcxP4KSkqxsGUhbdWzIeZs2wE4RunCYPQdLNLbELJGda09WeQwfVGeE6kaJANMFhG1s3BASiIkRWt5cZr8enlFTd5fq4fMEtQIZClhLgxhGkccDwdcb6tOJ6OSDnh5fX6dg995/guJaBnt1JIXFM7viT032rYmv++Fdz9b+vGk1KjgL1jhfSbzV5r79GJXnjfcyH0igBkwAvuZRVDzuv/rRB0E4ZNoWDhWgVnanCuCv9e8WH/FFA4ixQpM6d+iIlL9MaAJIkHJJSf1nCDizD4OaPGADUlgIQDQF9FrRfwGaIEOHkIIqoKAO5YmXV8KtUuKjyo1NIp5UqY02D0nue8O3JGzYXrjvf6X1qDKvT7c0VZUXSgqkI9akOoMZA6lxXeVUHNEfYKEVqMGAHhhRCwCDmH2o8NJTBicWEzNxVdUCF2vV1xuVxqhoEqABqMqiREOq96mL3NoW3es841VRZ0487d+SUX+JXTSqtfV7IdVDD1Eed90FuMEcfjsQo0NQr0fooAAC2tr1e6tV/VQtfsiF4At/5q8QT6TPM816js/Vy8t+/onmVtc1Fq/MLYoSP93qbP3gv+vdXf8xX099M26W9jjLBmW1Sp72dVJPbEQ4p+AK0SKiNDrUiSXkfjOPQ6qlBYa/F6uUg2yyrtNChlYNcrkVitmg2hr4QYpJpgyRw8CMI4tkyQwWVA3D28n/fGFz+vKey6KJYtbGM4Up9TVbvCT5mrmhoTRWHPeL2wEuBvHDg5SXqrsexiZoRixTiO8H5ASmPr+8zInLocJmW1tEaMrCxCNIgLMHC2lOzXxhpxr0aQ4UA75wZAEAwyRtY/cY0Oq3woapQZoJiqdJIaT4pQ5sz1QAYLZwnjMABUsCxcpXAVFOt2vXK/kHBsTBOGgeNp1KggcCAhoygTxmmCW1bk8vrFnbM/vg8JsAMGx9HFbIWCo5P7v2tnAGJywVnbzqPtOdw/TTAW05cLLiCbkU3qFrPdaO06KfXoFyxHhjZ2tXuW/HuKA0Qo6nX0GrrZ9BsQD6z64Fgoab6mKgRqFTfIeVvZrG0whFs0WKPB6pkgI8aMmApi5gmedLJKrm6u7RVhJu8FqNH76q6oSoEKcSnjxBp9wVQCX7UqW3ItoipXdWyywH0agZ9LKwaiWm/OBT4GFkJxiwT0Q2FAsDsAYIPA1M/6k7YZFzKizb9HAIoRPBQoZhdkKIiNIUZNeINNldeibdBMczqOQ20LC6jOZ+gaKsV87HwL7z2MMbhcXpEkQjyEwEVNVr8TkjI68uPq9w4NSekhcn61x+HvUdcYCw92I7y+vuJ2u1ahdn3lEs+qBCj6oWl9vbKtglsRC846mGtq3d5d11Nzq7DS/lyWK16eP9eAPZ3/j4+POB6PNUZBr63CVueBKgEaxNavaRXuOrdVOCqVb0wsoA6HA47HI47HI+a5ZXbo2p+mqa75faqgrtVeUdBn1/4CsGkDSsELGjpxuVwqm12fvaTokz6XjrfGVvT9eb1e8fT0VGMqNN7jcDhwkJjEFVyllLH3XMlOg0+1bHVYOaL+er0giN85lwJrB2l/RpRYAX42g9ttwUoe6ZCFf4BdEut6Y2IxBGQCkiCTrHCxS2qeGfbXNXS9Lkgx1NoETqoWxihslzlxHAUdkPKWPZJlga43Tk/MOeNwmjGMHF8wDGwlqyLMivaW8Ivdv5KGqUaSIcBIXFVK1f2aNC5COAa4HHvB8/MzFroifHpldj9n8PpyQYwZgyNWfmSOpZwQQoEzHCdnHWdCZOewpojnZ0YHn56eYa3D+XTCfDji/PiB07CN1pm4QWmX5/mAD48GHz/+DILBX379hG89vi8wUAJYgG2xnb0G3r/zOVvI/p4roFrKOQu0k3lTFOa5e+6A3h+p19nfo1+cvbb+xk8MbO5BhiSFbuv3bgrANpgwq2DMeHPtklGtPLVgYrzHt8AT0CeLmBjCjJnL8vJ1NbiPBTlpHr4GH1JH4cs9z2/VolcBKJYWNCBR7l8KBkg6IZRTQDY1cRGowqDCrz1ngZIbZVECKnyaFUZV10HzWdeDDFdJ3ClpDQjX8dnNyYq0cCt7nYCKnq9oRun6oN1XtdG9K4rvaTYKaJ2zuZEHcYAg+2nZFdCQLu2rHvGp80385SpUWGBvYe0irqRe4ChMzkGHgBEfYj8fdVPTeRu8RyBUP/y6SKGU2Crw6b/vKcu9kFJimn2u937t7ddZSswyp/56rQ0PNGbBYRg2Qrgfiz2y92auUHOVANhY185xXrgqRz3Rz96NqW6NnhzoPeRQjYT9vtc/e0RTBq21G6Wof/UIzB7R0GsSUR0vRW9610Rfj0EzV4YYBV1qBkhKXGRKq+atq+bfM8zIz6Qp0j11OhONAZyJAAvh0VeEr4AooRhCFh83P7cTQShMfDEixVTTbmNgDhprOTI+lwwCuwGUTwR1bje0th+XnBJSTrD2IHEw20wJDTzOuSkCvC6TyBilc28uQjLbuVyKBFlSmwelSC2L4oG8wlmLabQdc6bp+pPYGERCSmBeFV2vYmi1bAAPGlmBmMZJEDhOwcySxaBjZq3DNLOSvEzzHePo/eP7AgO7xdAvSKBtOPuFCWCzqb23weh3KqTVwjCGlYB+I+5jAXofXH//pim6uvj0/F7z7gN5ekgNBCyF6yO0+vKlnrdXBFTw6WasPlbd/IOXQhliVShLXbOMW7tXjFgwcVGf4OFjRExAIQMyDk449odh4EnqhD9AsxWq4KPqFtAEOg4ilNQ8JXaS9lPJyOCFYkyukxYSAaPkNwX6zO25+TvRjmv/8rMqK2GrjqcxB92cMACMbUKfGrKkwp9fMt8E+SDpw1wSn195CtpvZPbWf/f4QQEhlG3kPc8dA+e4WMnpdBK/ratzJkgOLwctFQBj9TcPg4OxjWP/eDzg559/wvl8xt///d9zH6UkBYTWmh1wuy1C3uI2gmW5rUwL/fparfJmgZrqn9R5WIeMOhfHuiBG9aUnlDSAyFZL+OPHj6wsdPn9PRyv19E0tB6B6y3YUkptp+b09xkSwzjU/Pye8neeZxyPRxwOB8zzXCFvVTK0DYpE3G63mgXQuwV7JaBHVLhtPB/28US9olJnSy9cOgSmF8i9wthfk2gbIBhCQFi54JIikxqw2e956ttXfgT9XrkEFBnp26n31QwQVWx0T/27v/s7jt7PXOxquS2IIYEg91yXTapiv3dae0ApM44npg0+zjOctXh5fUWKCcFFYEB1D+le530AOQMzSWodOSbZiREpR9ACXC8XrMuKl5dnVgZl3R3mSXgCBoa5Jcefy2O3QnKqtANAihHRe7y+vmJdV0wHB+uAEByYTpjHbBXh+vT0mYt4Xa5srNTxc8ynMU8YZ+YU4MBLg9uycNVPqdMSK0LVpfWGhF9fVoyjw+k4wa8L1tsVzh5g7VjdUiGuCDnALxGGCtYbowTDYIWemwM41Rgtkvc/DaOguAbLwimDnz4/43q7wf30Jzw8PuDx40d+Hve3ShEk8Xns/yPU96oidW/9eW+OznhTB4Fu0YY43vWeUlP2H9DWBaE3q9S1O22/T41r5/Z2p96lCTi19LRYhvrVS4XZ26ul+xXkVOCDVPpbRQkIqVrVtZekPSsMVhj4GLmsby6oRMa1nG73HPsO0kuiqEbQjQlrnqTKRwEvQH0IOV33maIk/YIFoJRaprYqMPpbOadkPUf9XxKclzPUatcrEsm9qMUhVBFdJX/XrvpPqn/rq58H1SLbz5PNwRfOOQkfQ5YuJlDh8p7W6nuvVPS+d77ORjm1HEBI1gjU7NgiG0dM0ywsjMAwBBgz1LkFaP0Api+uijMMhkG4IIKvAlKVMVWsmuBSxIZfWQhRgo/wPiLFCIIR3yL3UC881Srtg/N6IQdgoyT0gXIKV/eowj7gl4epR/Ikk6C7dkVOZI7pPNlfS5+xV6QrtFPXM6HGIYmFV78jYshX57X0aRIabYWBNy8obRbqNdj/256BC3YJZXdKrKR2GyB116t9KH3N8DTBlc6lABb4vosDyCI4h4H97M45WGc3+8M4cEXUcRgQnBN2ySKkQOqqiZKGJ20zBFPaNWxlhRT3o2YSxABQK+Nd+0fHuBuRUqS8bwZABcGHZvGGUOuqJKesoUOnwbf9m40d1LmhNL9apC7V+cg8H4SEQAEFwLp6+NVjXVaOk1hX3sdJUtkpwwCwRBKIN8KKwRUtW1dO3QRdJlGdhz4hLguQB4yOhDK4bWHqx88pSUq0ByEjJw9nDQ7HGTlFDugmA2MdjOUxtZJaytsozz81Kr33GKjADRaHeYQ/TLUi4bcc3xcTAIsBbK0ZcGEHyqo1b5GCfqs2GTsUNlf4tsK4RWsEsK+b/2nhKYATKAog0fJIACWDUiygEfLS2+Q4Tc1YWcw5IxWOCNVD4XsW5qgBdDkXAAk+JYAKzBAFLZZJkg2ndNSqWEbkHyGDIz4zce7neJ7gCoDbCh8SVv+CNXh8vnqEWHBbIjS9Rqt5kTGwxiGUCF/8Ns+dgCIbdeSHQAxBtqK2IZFsSM3S3QrCKjAKYIFKyaybqKGp/TYDIXcCvsJhbfNFYYFZr10KZMBgogEy4JJSHVMvrblvxXJ3ZKr2Wk8ppfu3Th0NhNtGF1ZrTdIyDaj1n2wOWf15yvQoQUY+avGkALIJ89FUbcOYjJhvSIXgE9USyDBcJ9zaEcYaPDw+1DKparFR5jlMxqHAImcDHxjyZCY3hmvnuYBBz6YE9BD1w8MDiAh/KlzE6//8P/+/WNcF1+sNKSekhQsBHY+nNk7ZYLkljANhHBxydMzxnicQBsm7tyIIIltv1JRmYzSuoaVF6jxlZrmXmm89zwexytRav1bImZUApTJu/udSCowdmT1tnuGGGSkBv/76hIJS++AwH2DdltabDGDsKHnVLIg4iBYIoVTlnsjBugnTfAKMQyy84WdjEWEQQBwuEli5+vz5qSo0vVvCTgeUGJBjAg0BlBl6LgBonOCmCYeHD1uugRhhphnD8STU542KOF0ykl+F6c4DxMRfbhxYMTYEk5jvQIPJckpYJKDyt19/QxSf9vl8xscPH3B+eKhkUIMbME1sOQe/SjDnCGsLnENFk0LwuFyfRfnh2K1BshiySSJ8LKyzKARclhtyTni5XRBDwNPlBcYYvEoBrcPhgMFqzQtgsKLQxQikhJAaOdvoBtgDVUUki2U9TowEzIcjAODmPTIszkRIhscOsn/fYsarD3haVjxdrzDjiHGasHrJvc8R1gIxLkiZM3OCD3h5epL4hxXzNHHBHuswjg4jDRhSwYOxeBgHiNMU0wAkA/xxPiCniL/85YLr7Yo///lfq+uIisWQRwyYMZGDO1gMHx7AUzfg5fUzfLjgcBjhnMEaAmLwePr8G3LO+PDhAcp3Ajti/mlmX//Pv+B4PGE8f8D1uuCyXHBdE65rAsyIcSLMJmGkG/7XvztjeXR4+rd/wP/23/4HvuX4LiWgmhdgv0aF4ZvCXV+qxInNxNqCXqaDszYQHNQ90kG3d+ADtaBVa5cT5TtVu/hjFuzb+218p10bqmLCT8jWcS7iTu8tz7Kx4gtMR/rTkwGBlYOSETOTAIVc4FOBjzyRUwaMERqTXGAtMyT6vCsE0VsRaIoMP+OWZOVNf73T37uT5PnESip400f3/n5zzTemOY8nG79b1GXrXroD9+iY7tp87xlyKZspqOmRuTDclzoL0kiOvxXltX4nNdf58fXZ2GfYw8MMKbMqbN3WNaXtU6XkbTd3CpRYqHt31f53vSUOYnY15nTXNLJttT5+Rq1CycpFr2RowS62+Bukzf5yg/3R2ot6fUYlmn+/h7W1OFXfB5xSyd8xTatY6PpcEMpVcZepQB1H4ewobY5rbImSUSnqFGOCtX2hsv4hmEWtptMCYkFmgFIty51EYbRi2WrVOA4OS826l7GuFLhqoVZFmVGHwYxATqDU+On3/vxx5GIwirToddSnrMhMTQkMvs6LYeDcenZDDQK/o1rLyrev85rnjG6QTannLmqLt1O/6/032Siy9+dS4EMAiDDL58Za9uVXtlJUPosi/aRonRNOkyIIirpCVEFtln6GS1kQjFLdjEEIvlIpsN1c4vkBAC0IW405fS+poCTeuGU2whqDwVqMjl9JUE9nOP6Ii/kYHCaHkhwcMcsolQhLzE54mMdaFGgYHXKO8kqIkVAwVjSqEIm7N2JYVk5/nGZxR45w4wQ7DFzNVWVKt38YmZ/WAJYK5tHBYMT5OL1Zx+8d31k7ICLGt779ewE6/Wf9Btmff+/93ga43yD3wTdAE/a68Htosj93L8w29ze2EzxA8hJIgogakCfBeWwFcyAeyDAqAEIhTu3zwSPGjNviEULC6rXKk07aLPEDAqchwQjjVswRMcfOItvGYfSBRPvAIvVH9sd7gv/e5/043VeU7itQQIuQ1j7dB232KWD7Z2spje8oKV847iknCqt+WelTgdw2Wp0z/XW07XtOCn1mfS5N2QJ4A9YAs72PXY9WRbPrh9249tdSf7K+63XVT6/Mf0RUc85VMOg60kBEZQbU8/cBcnrffZpcP37KKaB+7HmeN/2uz9pn9Whfq9LRFIog/mSOLej7dR/Mq+e16ou5ClNNW3TO1fFQXoKHn3/BODFlrHIjaKqg9nFfVlgLSBFRvZ8G3Wm/qt9+XdfNM/f9nWJCkHTQz58/4+XlBc/Pz3VcPnz4gIeHB3z8+BHTNFV66s+fP29iLXo+BLW8Hx8f8eHDB8yiCGh/vr6+ggNAb0ip8SmoK0nbqM+uMSY9e+N+Duv80HHez1Htg3mekUvCuuq1WoaH3lt/NwxOXtyfh8MBRIQQVsSohEvq72+cCDqHl2URYi4ei3EYMYBgqe1jOkYfPnxAjBHzOOF6vcL7lWuwLAvU7+7cCQ8PDzgdOcPCe44FsMLnfz6fYS1TEt9uV6Qcarrr6fCI//L3/xdM04zT6YhcOADxen3F7XapCOQo1MXWEkIY8Ho5cPbNcsPgHM7nR4klOtZMmz51GcAmvkQNgD725vHx8Rt3z99TO0A1cuGRr5adnKNaXnNTE5y11X/FP2lxBPX/pBEBW6Wi9x22Dbhn2GvlYrF73woBsep04lbhtfX1VtcCVOCjg+X5OqkUlKwWv0bky4sSAIPVM6+/94HZnmIUop9Gm1tRh6LR+gWQPtZNUt91cLX/+ufT590rN3p862fAliFu35/v3Uf//V4GSAukRP0bwGaTT5Ws49uVlvdQiV5R+pLyx/9unA19INq9455l3wvve0pHz15nrcXtduuIc8pGoPVleHuBosKyDwxTwb0PWusDdrXf90GPe6VDN5le4e6zau5l4PTKpgbB9ooe8JZtkKHyt/3YIyeqdOjnGlWvz9BzTvTBg/2rL9KzefFVwZHhzOBGBAyOyVqcs5KyZTmtmdj3G3OGX1esAnszaRSfp7UbYpK2xMRWvbFV+CW/YhHB3hdoUqVDlQr9t1IRa7v7FEWdDxoMuE9v1L5U5UGr7umcUhRLYedpGjkLKWpAaIGmBRO1seGI+v8fb//ZZUmSJImhYsTJJUEyi3UNZh/w3v//PdhzFgeLt4Oe6S6SGeQyJ0bwQU3M9XrcSNKzDa8TFRmXODE3N1UVFRW1qGJARngP+j5LECYywcgZOSb1vF2ju3UOmOugkvdet+vmcwRct12+QieKQcg5lzU71TlNB5dOcSxdbaXm3hYNg2XO5yzotinCYA7yXram9CNw1VnZ7/ZXPR8EbSpRfloc6RADfC4ltCXV5L04E5vNVhzJ4VIrhqhhoYmr6+Ze+tli7ER72TZLWenXtu9yAuYY4WOUwcb7C7L+bSBtGZ0rD4wxy29LsRsSMxYtAc4Y6yx8Vg+1ddXopiyQjnw0vjk+By5ngYfX5CQZNCU8lAn1Fu3o7CUnV2pLp0nY/tMcEBMQYq77FmfAAZDzG6eAEJIQAlPGZZgKeSVViIn3LiPDJCFOJJSSurx46+8hAWsDtK5dXt+b9/6+ul83Fuiv7UM7Afoc+cCuK0e0oeI1TGGuTsCt7T3HgO/ph4PHuBWF63EjZCxs++uOk/r83kOh9G9dvsdjWmtxPB5rBLnZbDDPc63nJqSuFeB0Rzie7zAMFQnQhnCz2dQFXyMVa3SCkTYjbCIFjKb4Po1t0zQ1CmEkoju3cXzZtvR0OsE5h/1+X8VqtAOrBXn0fNAbx56GkuNNZIVGjUx5nhe/RzY+r5tGEkAdN4OEVCpWgrUYvENqW/StnFu76aW5kpegJceAoWgjPD094XA44uHhXhjkXQtvPUTjPmMalnHkXCdUO48jzodDNWre+5q/Z5vp3W5X9RH47Oz3+1Iv/lLvn/f+ShNAqzNyHOd5riJUOYtBFtEowHuBsyUlJBEpxaLIFQCcem6kHS4dPhl7B2MadN0i+FOexHKPSt+BnJRjuQjL6TXAGEH/iNqcTqfyPMxIJY9Pp65pvHI4UBETETbKmOdYAjdpUx7CXNAFURm8v7+DNQabtkXXNXg9PNW50m9a7HYbWAuM0wUhbYUn0TRoGvZJkHr8pvHYbuVZjilgmkYcDgfkaDFMIi6UkBDmCfM04nI5YRjO8M6i66Q65vHxHs4tglDn8xl/fvodzjnc3Qm/aLvdIsaIy2VEmANyGsEUAMeArYz7GOFiLuPssdvfvbterrfv4wTUW307ElxHZNwaFAPARXTloePqR6EJEM/GWHeFHEBFqutjZTooGRV9yHzDmLrnXKJ+Sa1wv4vykwx2I8a4nFNMBiEC0xwRovShZ845gyx9h2yssFNTxlx+hyjIQGLEr6ETKKfqhq3juK4jKz3ea8/wvfG59bd+7VudgK/tb41i8N/vfjd/m6Px3vdvIQH8+8tIwCIStHau1uWleny1s7BGafR10igcihEgjMcoRtoWpxr13qof50Kh0xTrYwK4cnD1fNGRtHYCdEStFfAW7sTiBOnaeiITNEy8Zn5Pv6bHZ4m0lmVHpyFu3RteEyNDSgzT0eC2jqopGmStrZ3ebCOM81TycFrVj+MqRm25jmuJ3yIipRAfADU6Xs+RnIW8qzsS6jGkc0QoXJ9D04ixsNZW+J2oiL6/lCHm2HOcxKhOiKUDHw2p5hhw7qzntJ7Hzi1ll/pe5OJYcNyXe1HQG0CY9CASKDl60SAxMCu9DrbmljTGMhfnOdRnI+dcHJAFidIlk/VZsWtnfSlNlvUepUeA2BVeA9NV0zTW1sSNN9UBMQZFe8BJrwJ1HGNEip3OaNOkygsRcmVTeCRG0kNzgGiwyDPpG4+26UCFz0WfAcJ5qUJifB/legR9Wa/fjf8nVQesty8ttLei7ZsQnXYGVvumg2CdOk11c98YDf6ol43zwoBPpUytDB5yLnLEkAje2tqjmdwA51qYnBDiiJwCQpowhoDTIG1fh4sgA3NMlbABFLEeI/ug0M8cI1LCggIUcha1IpBJyxGyiE5L8MFcOwHr3PEa/v3SPfvWv793Wxv995wLfayc85JmunEe3+oA6H+vHQH+1s5ILmM+TzPmsHAwCLGSHU5p3ArtlUVWGw+dS+YClVKqZK7z+Yy2bXE6ndD3PR4eHkoENr+pBlg/D9q48m+eFyM/LpTr7946v6ZpsN/vK8KxVq7jNWp0gbljIiwactYGhVG5hmF5TEa51HAHsPQ2yAt6oq+B+6fC3uvra3ViFl0GgVe1Wp7OkTdNI1HmMFTNCp4nAFwulyu0xzlXx+B8Pou6o7pWDUPTsdlut/WaiFhUPYPLBefz+er8qOinf3gv6eD0fV+dkGEY8Pr6+uYYJBkSPuY4Lg2pTkgxVL7I2skjR0S3T9ZoEu+/vqbz+VyfLyISnBeM5r212HRtHZ+U1vNSauYBMWW8xj///BMhhAq3xzhXJ4TIjikpDS2/zDEBAONbOIU2SSojVGQgQQK7pnHFGfPoNy26TYvz6YTT6Yiua2Bdxt1uh75rpWeAd7UJ0fl8FpQ4RTWfEsYxlDkujl3bdeJwtA1865AAad9sUJAUU+H73W5/5SxTgVbKN21xWErqzxlkJAgSJX0huFlr0W82N9fMW9t3thJeHtB17vi9jREVF0f9uvai1guX/pwiGKj3l4h+HUTTmFpbmunkDKllzMhGnIFUG85AkAWIdGy15gaFVS5M/nlOmNSP/L2wilMmT6E0zbC5RB1i7EVHf4H/5bjqnCv0IRwHa64V03Se+j2H6z2HSo/pGs5+b9zf227tWx9b//1eVH7reDGnd9/70rn9o85OPU9IysnlJcL4Gvy/Nso0HDSyenHVErqavc88r47Qb+X1bzm7zBVq6JtGi9uan8CFWv8wt6nPa90FT3MQCOlz333fv0lDaYdUdw9k1AtkpLQQRJcGP7GOF9/jOXHcryLscp4c+77v68+6fXPfS8Ma431tuKTTNhQ14nXqc9CoBqNw3j+O/TrI0Y4U6/kXAtzycz3HysqQGfHJuudLm1oSHSl3m5Ko7c2zK1D+jBCWbozTJCWAYRZYXURoFueUTgDHYB1V67nP8+QaTqeTTss4jlcBSEoJEdIKV1oMkw9QnJCcJAVsl6qgaZJmWDBm0XKQE6kVCIysaTiJzMBI5Ycv+fq+79B6v0SDho6GOC/jOOAynIu6IEnrGTlH5KKYOs0jzmcLZyGOiJdzFQL6gsCczxcMIyWwLYBO+rd4j7Zr0fetnGcKyCkg5yjXckoIsQH1RwSNaGCMEIaXkuZV6oTPZQhIMcJZK3oGzgvxsBgV7QR9bftuJ0Dn9fRDqaNV4HrRZUMLvX3LIv2e4cpZdAPeNQDyLWRYOC+1zCZJxzyUSWp4ngAoTUxDnopoyBiFuT+O0mLzMgaMU8RlFAdgmET6MlQDT1lfU5AFW8o5WJK1OCiZDoDhXL02oNYsD6iO0jTku44cNft+va0dtlsOHBe9W9/90m99Lu8dU8OJ6985Z4Hw3O021f+z0Ir3HBgxGgu0vo7M9XH1As9FU8PlNEJ8PrSx13CxsLBzfR3AlRPAH+DaoOvFmJ/RZDmdI9dNdnS/Dd13Y7/fI+eMu7u7qvLHaI/743PPa+NY0ACu+w8wmmTuer/f12hdnIAlr8tzuRVdA7hybLRDpMlzzKszwtb3m6iBMQa7JA67c2I4eY2Hw6FGuuQS8Hx5/Rry1lExj8F7QrIm5ZWHYYApBDz+tG1zhYYQGhdYV0R8UIKYpvH44YePhd0vhkdSS9IUiOOhmwYZY3C5nIv07FjnjzGmsv95XUuPk2si6i0ukl4fNM9kzQWKBfUUOW2HpVAQlXuwzEtb9xtjrMS66gQkh5gT5nHAOE+YwqIQKc4SqkQwUaX93R5929TrulwuyDnj9fBSUBLpWDiFCZ1tpQ+AyYgpAIgwFhiGM0IYEcJYuBvs7Ci8A3YBfX6RPhiHwwHOdtj1cg/arsPd/R0eHx9gjEiqHw4vuJzPuFxOOIQJfS+phQ8P9/Be+ivkLM3ici6QvgoQFiSnED7nCa336JoWnRd1Q0aTzn67af+HkQAd5WmIVees9Pc0GehWhLg29NxMIQny5ZQXj1kMa9YfLP9c8QzkJKQe1C7cAm2MEBYFP/HGgOMoKlRCCAw4X0ZpQTlJqd8cMlIySJltew1Q6uxzzsghgnhDSgvIAABphW5AlbSYcoY64tTsUB1t0WitPfdbY6nH/9a/+ffa+bqF2NxyBL60P+0sriPHnDOsc1887685ArcWLB5PRzzrzwJA13bV89b7X6db9LjTKBCGXevUM1pfOxP6N/kAwBKF6/OjU8BzYFS6lptl/psOeo3GFFKhHRUacl4LfxPSZbTH/evFXX9WP9e3HKb1PZdGPtedP7XADrAoF96qMiC6oB0vphkombtGRXJeZHh53KZpkJOkSJDLPeH9TqVCCEaqBnLp0mEE3WOkRW7AWgqbGgwxSjVQilHEb/ruqmxTI0TrebweQ52z1kiNdpA0MiLR7iiMf9wuseS809/j+POHc/IW4ZR8iZQSjsfj1b3kPQqlZwGj2UXXgvyXgGm6Rqxkjplrh6QEdNas593yPK65EjmL6BJqNUjANAnBm46Rb0SeeLPty1zyCEGgdkEZZuRcyInO4XQ543w5w0A4PoKAOPT9RgSzokGcHVLKGKcRzdDgcmnRtgX98S1SnzGHSRq3ZRFRC1FsT9suze5kDemKvsJc79U0Scvn4/GA4/GAvt+gbbvaJZRr1jhOb+bWe9v39Q7AsnBywG/91v/WixlfXzsR2plYb0tUz5x5idT14gxg6VlNZ0D9lNcNcukYJ6p+CRDFtVWeL2eBY54OE+bSZjOmhHGelAecRM8/A4CVVIIp5EKYCgOKY2EQM+o1LI6xMgxslgRhFejFU0OLOlLXi6k2anpR/V6Dqg2h3veX/q7X8M6+by1A2rnJWRqFmHxb7/pbkIC1A6AdIm1EON+WH4t+I2iRrjkHlnz0er8cd5L8uLBzASSDm7l3OgWauCUs9/FKblfXcAOo++Q1M9eux15XDWjN+DVBT8PzdCJoTHl9/C4jxHWjG/5bEybXc1DfH33feZ1tuxDhNG+A10fnSpdr0ZHT/AyOT9d1V2kA51zNFWsjaq2Fdw7ZOrS+AVLGXH5biPhZnIN05MxFwrZZukY6K90mWRKYgpT7so8DDSI3PWfaMh96JeqjeRDvOd0axWHVhnZu1qidRmF5Xm3jizF8+yzyWVg7dRxH/SwAqEhD27ZXaxK5Crw+strncYKzGcgGzjoh1KnnfxwnTNNwNU95//mazPfS3Mcuzoi2Q9belrN2xVEIUUiSQ1E8TDFWlKXrG2z3Gzk/axHChHEymMYZYZ6l0sEYhBjQtg36VhRVqYngnEffN3h4eMAwBPzx2wExJ5wvlyI0ZXG33xW0QkoIp3kQDlQRQ5rmiAYGu20v9qmkxcSxEKeIfI3z+YzT4YDXl2e8Hl7gPJ//VBEqVmh86/ZdTgCNcN3W0Q3W2XuUvHhZBN7sUBnxLxyVEb+evFQL4/dNyTlZ9gQo5L6ZET7MldZ0jBFTEe8ZpxGxyJrKwi9M/ufTjBBLZMUIi/rPmQJFamzMoiUf2FynpABiye9EpbMAU3L/RaveGCGApByBdM221qmANcqio4Nl2N83zutoQ39mHdmvDf7aCK33xXNZH0d/X0fnQIn0cL2fN7PgK6/pPPr3IAHGCJLDfaydJ30t6+hUR6z6mHqe0gFg0xxqBkiEFa7Ok8fV56kXtcvlchXVkzWumfG8B+tcNT9Tx7u8R9Y6X6ejqferuwWmlK7EioxZ0gHrOmYaKioK0jnleQILmUsbQ30/1+PK13n9LJPTjgWvjfvmeYThgpgyhuFSNPgngYBNKUVupKWraOWL8h41O5xz8LZwPpguAuC8K8fJCDFinibACCJAWJilbWuDvw6a1igMX9cNmjjW2kGlI8Vr1seRiHaZj9rp5Pt6H0KiZPRcBNuzRK38fd2Fj020ACDDWlEltMYApe2zzEULA5GdbttFY0LOS9oGa8eVyAGfrzrnu7729KjGvuxfnNRS9hpGtCUlME10tiXNIn0WHDa9OCy7/VacPGswhxFukDJRpq6Qy5yZRhzzoRos7z0+fviI7XaDH374EZfLhOHC8ZFS8sPxiJiEB2CM4MXTNAuSPMt1C7GzwabfwHpXxnlZ56odCAEphFpJEcJckILiJCskcC0Y96XtO52Aa+if23twZ72ILCSR9evrfdx6PyNfleTUiDIv0LoxAvuL/ZXozljpPxCi5FcSKBW6wCbTHDDNAZfLWJm8fOBCTHg5lwcI6+imXJc+X0NnpMBsRQ+A3AVGUSFdw+225L9sLQ1JQAKkvPcaDdBjAODNoqIjprXxXxvr9bh/7Z68hwisYThtBNb71w4Af6uDfVPE/97r/xkkwBoLqvd9aZy0geF7t46p7xPRge12W50CY0zNP/P8OEcYBekonff/dDpVA8h0A+FwOgGMImhIlgV1iZb0c3QrNaOPTXSBKAb3a62t0TaNP3+v88NaVlichu6N83TLSK5RCh25MgfO6PM9gSA9N8dZtDqGUfL5c9EMMIZlfuxEKM+jMcsC3DS+5p11WZxvfFl0Z5jiWAACRTsvaQBnbzdRqvMM17wZ3m9Ajk8xKY0K0tjz3sr1rhGCXA0juSl6XmsnOaVYHAEhM8eo0wRMwYrKqXYA6ATw+KY4QMYu8P2yHwNnPaxxaFuxB0TfxCAuHJnlmV3K+GSulzI6V1oqxwhKZOcsaqyX4YIwAzF2xalaSm/lnjm0TYPNpsd222O73cg5G+ByEQcwNQ6w0nMmKaRnHEfklNG2HTYlBbXZbPHx40ecTiNeX2eM4yTcmhAwBZlz0zihaeS86QQwGEBOaNtWOowah5xnsTFr5EbNjVquCiG8y5j8v+EErKLQb3EGAFTv85YR+ZoDkbOpWsk5l9x6pn5yFgggA2BJXSH5wQj0NE5zLbuT7+VC5osYphnTNON8GTBOE06nk7A+hxEhJVxmXyN5OTGekxoTLDB/fbjkIgCYIvwjOgG5oBBy3vIZVxY6B79ErTEjzbfLLfmA6Huic8laJOUf2Xg8LuL695c2LtQa2tNePD+zNs41P2nMVxChLx/7H0UCAGEms8nN2rhreFQbLm24yY6mAQdQYbnD4VDLvoCFUCUGdGHD6+vgvlmiSGiXCyaNPCFbLR+qf24ZQxpufb7aCajOqjLsVwuo0gtgiRoNjEYkbjmNvA/8vDZGWv1Pz/u1w0IjwbSGTsXwOHSQeAxe6+lyxlggVSIyGsGY57meP++7nte8p4yamQ7iuOn0iZ6LMUbJA6dQ5HRbNO2SarCOQmoZNhlMk1Qv0eDAoAQtI+Yw1TbWIc7SXMktDpMQ1yyMBXK2QFp0D/QzyeeDTh1TFLrMUDuPRBxzznWdPJ/PSCnVckcSQMVpEsdXWPSDoK3FYHNc2rbD3Z04HHNRLOQykyG9ANquLfNjRkJGTFHeg6u9U5yTxkcwBi5GIC+6CaY4JM4AzrU1DeC9hfUyToJkiBNgnUW36dCkBjlJ46aUMqYyV4wxSDELk996XIYRMEf89d//AzEJudm3DTqUxmVxRkwJ52FAvgiqEsKIXBEUMeAZwPF4hvcj5kFURZGkYmEcJ6DIGm82PazlOpNxd7fDfrfFdn8H13SYpwnOWszT/0tOACfTelsb8xADUryWO1wv3Ot9LQsXrp2AvCIE5oKsm8LMN+QBSM5favjJ2i+QZ4wFjpEFbJzk5zKMldEbY8aEHpm1e8bcyHUUqF/poXN0uCjFUo7I1qgVojTLg+gAIC4s8RQzUnwbMawN83v3hK/f+vd7n7n13i0HYL2wr7+jI/y146d/64jcWlsEl25f77ds6/O5dZ7aAVkcBeb+rxUF+TkaNv771vWuUzU0KCmlKm7DaJjvcUHlfnX0TWeFxkiXd1HVLed8VZrF8107AOvzpZHSOVS+rlNPawljPW40DDTevBYaErLxeR3a+dKQtN60A6CdXJ732iHWDseal7AWxjHG1HQeS7umccSlGPUYhdxDR16jENxCKcnimOp7xHtDY6qPK8dOGKdJ5rcRYRw/L3K/9RqsQTKmOhOnk3RbJBrDMsBrGH6RArZF5tbmtHT2TEBOy1qryyc16uP9Qj5cI1H8IbP/fDljGqdaJklSJjkDcu0W/aZHRsb5Itc/jmM9hqA3DXrnimEsc8JIWEXnxJfxDLHwdErAUFuhA6WNc4mCjQFm6cCacobNRhwBCJLgrC3dPwX+l+qshJTK+Fkr5aQy8eozYMs9jiEh2lTv3TQHZAzIn5/gXIum2dVATIiZAuMTvo8xIkUx6s4Jx6QUOmAYBtnn5YKmSFcDct+dtWj8wjkaxwEhTNhsevR9h81GOnH2bQekjEsz4lu373ICQpLGN6ZE3WJuzWJiMwR0X63bc7juVy0TUnSTrZH8DqP4XLw9EUrQLWCvjawtfZ6pxGSNRPuxeE9xDiWKl31K296MEBPmIKmAYQqYRvk9TlH0ACIQkhD5phiVE4DKgdBbre/PijNhAGtMPS+Tl4oBn9PV8NyKYK01MO6toeciqn/0YgvI4sS6528xivrfNA4akv2WH36WRmttdN9b1PVnnJUH4lsdlluIFA0sjZo+D20ceXwxdLlAfQtUz30zeqpwnIoqWftOSI8SsFpIyFpbI8XT6QRAnIFxHHE8Hst5oJL7eF00PlVwpKAI+/2+OgQ6PcCxZ6WCc64K3dCgkMFNAt1a1EgLH9HQ1650uHbIGH1rqd6cc40IOSelMcvC5Cc5kmIz/K4uX9S5fT13drtdHW+d1tBrg3ZgdO6cY/D09Flqug+HEgBIKeN+u0Xbtri/vy/n0AqR7DLgfD7heDyiaVo0jceMjBQcGueAlNCUvHXXeDhjELZbCBN9gjFAnKV98jRJh7i2bTFNU009UhiHZYk6/XM4HK7SK0R++r6vTibvMwmqdCokkAnyXDlgu+0lUlYOU84ZXd9WB8haC5iMpvXoTFNh53mWyJoo5v29tLamE7DdbmEgqddxvODz0xmbfgu5dRLxM4hbSLGmzHEPa/3Vc5lzQnYoqV3qQGwkDjPX6BxTOICpQR3mESZHbLfbYjRtTSsbZ9D1RWfDyjmdhwu2mw22213lmriCzlwuF8zThBSFT3B3L8+icw0MxMmap4gwnwAzwvqpamOElERGOATEQnrtmgYp+pLijkBKGIYJo5ngrDgnvqB/n58+IWdJZN/d7fHLTz9V52W/38FZYL/boe87NI2D8xbb7QbOWZwv55vr6K3tH2ggdN2y1RpZyEp8VwleepGOqTQeWoJ3WKuNpqmRds5La1cdjSz7NIV4UyaEE4eCkyomyvUKxJMN2/wWQmASJ6D+xIi5qP7FlFE6SyLlou7Hi8jXPgCNfS0xAl/gdYlrJO9lWEfP9VrEYTFUtu5f/KFroZj3ouJ1pL5OD/D3e8Z7ve9b763RmnWEuY6w9bnwt/73ejPl3vOhf+8za8O/Hpt1JMv3tKTr2sjHmJCKnPP6/VvnrY0a68g1F4PnwFp5wvaM3ql8JwvhNWlPz3Weu47EqCRHNInOBrDkTAFBNrQU7SIjO7/JndOYrDXvtabAOnLUJZGafLeG4dd5SRoxHouv0YnSc007ajHGq/JH/b5GKyrXp0Ss/O44LpyfaRoxU565RJVt02DT93goToBzDqcTcDmfMU8ThsulVAiYWj0Qw4xojSzmpvQ/8UDbeAQDRBLfYiywcKzXKzD8hMtlwDxPdUz0+MUYa18H3v/NpkfOS7WAMYvjS90BPTYxkiEv3AXOtevnx6k0nkTFgLQDZg+TOSzIlTFigCQl5atjmXNGPJ9LGmOAgcUwjmg8eRQezikBJcL1xkLY/Vo7pETH5rqElQ4Cz98Vx3LJkyfR2J8jLBaCobEFtcri1JMAaovZ4Tz1xTHW6B9z8dY6GBvReLlH3jXICRiHhbAJk4AgNqPr+2prUojVCXBF/TabhBgE/ZznAIO89EkoKMLzywuABGcM2sZXhEWChhYGCW2RMZY5IqkO6jN86/Z9SMA8Y7LvR4K3Ik9uGlp7z1jcinRjkh7S1VstDoP0Bc8wBWHIEMM9B0EPpHGPdO/L1agn0fwPAfMcMUyjEAOngHkOGINIP84JSNnAeo9cjPbV1ZiFLEPnpV6L+hgjSfm+EFzepBRy+R9THpC5pPf0nsHWRkqP49qQ3LpP7zkEa8djHdXf2t5zIG4Z0PV7/Lfk+243EHrve/o1HnutKa+vSbPYNfmq32xh7cKe17A0javmBPAzlyIHywY+t8rSGPl8/vz5KjoWw7a0/9SbjvKAhTzFc2DzoePxCGARznHOYbvdYlsi281mg8PhgMvlUsV0qKP/+vpaBW00l4MGfo0A6Ah7u91Wo02CnjGmNh2io6JljTl23vtKktQ/wzDgcrnUceIYMG+vFfo4rszPU1ee9/R8PldnS7PljUElE/LznE8hBBwOB7DRE69HQ/schzpnCRUrhGk933OmJLbkdNu2gTHbWjs+DGOZS2e8vr6U/ZU0aojlO1tYawqczCZLS0OhpnFVhZCG0jmLGA3mMAN5KS/lXFs/E+91KtTIBFAkaYtSpJap5tzb7/f49ddfkRIQipotVQMFGRP1xrZt4BuPbCS4ZH+YtnRobAuCRr2D8+ko6/c8w3mHaZ7RTCPGpql6DOcidNUiwFng9XiC94Pk041B1zeQuv4tvLNFqAgwJhdOAd6sz9M8YxgnHI4nTOOI7eYOTdNiv9tVgmMMEZfLILwzK30CGESGFCuyfRknDNOM8XKW+1GcEG8B7zzafgNnraTPM7Dd7OCcQd8tMt9N40XGuPNIaVfP0xVNBGsAa0Re+Fu373IC+EBxkrznBKwXtTXM+t62XhhyziLxq5EADenyO0gi2JOlTCdywYoCx1w5ASkjBOEETHMsLX5TZfPHXKoBINE5VtdiQKNPGABXn6nZgW80ppkOgP4O2zTf+Px6u2V01+9/zQnQ+9GOi379vfNYR+dfO9/3rkEITV9PBXxpDq0jZ35eRx6aCBajyJRKVLt0ueP8YgTK/bG2mz+MrnWDmPU48zia3AcsnSq146vPkT/GLJA9r4/RD69RGzpC/VpYigs3IWee1xo50XwEfR38HK9Vpwm0kMwaISACoZ0i+c51JK8he6ZXaMDXCndMKfC6dFdBHUEvTX8omIQaMWlHhcaMvzmGzAPzulKMlYjGeSXr09v20evN1jnmyrU75Eyyqa15fpayabQGMDVdKvcsFj5AkSczCxdEDP9CchOkQKILjrV2AvRcu0XM5P3U6/4afdH7ZTrq4eEB8xxxPI5XDgSMIAwWTpQB6VhB802Wvh18xgAUHpfMJ5eTpHgLMn3FZ4kRKMY9RCm1M8UB6w3TAEUQycsaTkoyr1E7SylldeyI2GZ4D1jLqN7CmAg3S9l4Foi6pJ/5fEkqOhWnfhgnhHmS+WAtfCdlp943sFY6qgJFCbHx2G67GtyQv2GMqyiGjH8dYpkT37EOf6cTsBDb5IDvOwHrv9cCNuvFbz05648i3QFF1j+X+t3IMkGpy48p1Za94zRhmgJeT5cy0YpOQHEGYsyYK3woutVTlBKYUDR9jVnlACBG+8rQfcE48joBERvhTdRbXYxTKXuoi8hbQ7z+7vp9PX769S85amujre/T+nr07/W/eX7f4gTo+7+89pY7cOsYX3ICNCS/NjA0CIzcmLez1mG72dba7wWSzFeysGvI/nQ61bwu/2bZnzGmlq3paJPnyLyj3O5co1d9njnnK0h/bZSNMdjthITE74YQakvaDx8+lLKl01UOlufyl7/8pfJHuLhqJGC73dZrZxMbjglTG8zTE4XgNe92EqFsNhuEIJ3hOOblLr4xQiyDI6JC50evDznn2uyHRiKlhOfn55trjzb48n5Rqyvnr+dJKgu9AXAo4jc8pncOhmTD8oymGBEADOMIr3Q6UiEZelUZ03Z7bHd95UWQE6LRCu0o8b7qKgXN9eFzwv2RmMdz4FwIIaBtGiyd6d6mA/Qzt3bMOG4aQeO8ZOpCf5ff2e/3iBHouoTzWVohs/qmckaiIBamBFILgidkXaq0Ho9HjOOI19dj4SdMcM7CeV9TDbXuf7OB3e3wYb9B13hJteSEFGdBVLoNfJXmnTFOoh2QkggBDcMFD/f3uH94kPGbQznviJQtYDysbWBNg5yK2FwwSNHKa0gIKSBOqVZPnM7DAvGW8R1H6enQNsVpur9H17bYbXfIOWEaBzjrsd/t0XUtHu53Et2XVtBN06DrRWb4cDjI823FMDoP+Czkx2/d/tNdBDN5AG/y46jv8YFM6ZoUp/fBN+qDWaNieV0mLapt5Lqai84/G/lM81wIKhPGOeAyjEIKKQqBIhhUmgPFVFIEqfAWUHsALNDQ9Rkbc/3Kt/pbemFarl0cDRHSkFycRg9g3n6/vrfa93t/v2f030Um8luOgTbab413fve737d9vcrh1t/ctFPJ89BRjo6MuRCtIX5+j7nrtdO1/puL3pppz7muIyae461x1zl0HYmtP1cd4bJw8zo0L6DvewC4YukTltcEwDVSQiOhO/7x+GtEhNfxnjyydoQYvWuDLNdwHV1qFEdXHzh3rRy4ngtrIiivQfNALInDNHJXUbsWyyprQLpuES3CP75C44vzILleZOnjTqeOc0XGSGrSeV94D4g+8L7pe60RlVvPoh4vfu49B5xNejiO1/tkhzo28jE3x1qjNCmlqvroHAV1mI5bjsuI1drF4YpxibQBwGQjFd1qrLkfnbZb0neisCcKLbHqEPD621aEmTabDVpPDkkAUzGCPthCcEwIYYJoC4TikAjiYOwicCc/BV2p5Y3SKt4aYJ7lnGp/mDKPMhGEGFG7JitUhvfde1+dAeeFMGiNlH02TYuOfXdyQk6hmgRBqQTxyEV9EGDAkXBjKry7fV/vAC/qdgBUxAqK3y2GsyQ76s11FsYVrWdOZABIUseJGKvQT84ZMRfYK8v7rWuVBC/HU7wOnW8JIeJwPGGeA87DgGmaCxIAIfQUsh75A/Vn7QDYpUnKdd/r5eFZ/l4bJXqz1wu5XuCMMUAu5VLZwJgkKQ2kK0dq/VuTZPi6Niz1fqxQiPcM863X1wstF0Qdja2Po6/zloPw3m/9OZborbdvcQI4BmujsM7/r42wLaSp18Mrcl5kUblg87oZwfD+WWtrPp35d5LRCGczYtW5fB6ThkSg+/bKiOkIkMaT18Co8Xw+1/f1tQJyDbq1LKNvkuNY28+xZPRexW/8dUtkPcZEMJha+PDhQ2Wqa+ieEb2+HqIMVIEbxxHDMFSm/LqxDKstGAVrjQTui9dOo7p+FvhZjmdKorDm3Npg1+QbZ9lqzgGbjYgSMc0g0XbCMOTr5xpiUJle6roOMDL+1CY4Ho84HA7o+x673Q673a46atpB431nYyYaYV4T+Q2sytAoGO+7Kc41SwD3+3117PQ8pRDPbre9Wq+MMfXeHI9HzPOMh4eHq7lFY3k4HJFzwuvrC6xtYExfOu2dS1vjS01b8Hy32y28E8EdkhuJrIWwyD/L/U7IualrDsep6zrs9rui3reFCTNyihhH0f+whiWUDhnA6XxBCDMu5wNyFlVEjQxa63B4PeJ8vuDp8xMu5wuslcjb+Q7ZeDx9fi38jFnQxO0ecAZoLHISHtscI6Z5kkA40x4Cvungmw67/R02fY+u36BtPJxtABPR9xs03mG326Pv5LxiDAiTIOPzPMKYhJgChtKqOtuAbGxRvZWKjm/d/mEk4OoxyRlZLxj1H2b5ufp4iWiQYJLKT+MtEiCT0ckxsHT4k4mwtF0USDMUOVDJ0U6z5P6X5j6LE5DNIkJUBYGMqciFnP91m5/ryzBv/l4MuEEyJdKH/llkjelAWJOQeNzynxzrLYS/fl07A/y9jiC/FJm/hwJ8CXLXhlw7ABq2/dLn9Wv6M2T9vvf+l85FX8s6Ar/1XTobhJ2nURqt6ChJj7vej45UNWFwfZ94DM0K1+e5dp40MrFueKONtkYDeP4a6l2Pv35PjIG/Oi+NCOhrWN9LzYlgpE3UQMPq+rvrucqxI2eB3+Hzuq5QQLknGjHQr2tH99ZcXIto5dJ3Xd9nOhKy5WIQF7EtOli8H865+vn1MyDjZK6u11qLmCLmecQ0zdWgAouapIylh0TVHPeszk8LNi0dIcUQ64ZQgmxUBv1qbq2FnPT5ExXRc1TfCxpt/d7beS9jKemnCGuBsVxvKlUHV+OGXNRSPXwZB+5DWP0C+zM4FMRYeACJVRPOwXkPX/bRNE3lCtRVtwSk1jpYA2TEqmKbU0RKQrjMOeNwPMI5h8PhhMt5wOU8YBxndJ2HL86jlBVL0DmOM7xv0LWpHKPodhhTq9+ykpe3xlRxKEGXHGJMmE1El8TeeO/hfHn+ucZjWd85f2Iij2RGskCG8EtE4OhtN9j3tn/ICeBDpic/4VNNGNJGRS/Oy4ReJqP+t17ErXNou75GT3NgDp1VAPSWB0zzjONJkIDjeUCICVOItVyvgH9AKR1EKTfMNMolMnTlIbS20FvLRgNPcYCrhwVGYJ/izCBFRJPhiiyt/DZLz+eSVshWilWtQipYOrY2SBoR0K/dchLW9+t77u3XIvhbDgCAq8Xx1vG/hAik7zjH9cZF7haSwMWLxiTnXCPqSihKskDoaFhfp563XLh3O5ZJzZX0x2eACIJGJlifT5hdznW5v4TvdVdCogrM2WuHIsaI5+dntG2Lx8dHdF2Hjx8/1vwwINHnLUdFR5c64tPGU5fx6XPUAj38m4Q6XitFYXgeGkVpmhabTV/3PwwDXl9fa45cR4hUneOxeO+0w6HHmugMI27ds0AIYRlN4/Hrr79WR2uaJvz+++91Tdrtdnh4eKhjxqhdl43pdY6vaY0MfUwAmMYRn57+uFo3+77Dbrep3IsYAy6XM+Y5oGkWInWMAeM4KETJo+t6tO312JAHQE2CeZY5uWl6aZRT5tZut4Mxplap0BnTAlZ6rutngSgIj8d7SweXDs7r6ytStgjJV06OtRb9dqMiKYmQmq5Ft+mx3e7QtE0lPeYyT7t+Uwh2y3yMsejml+ez7TvYxgPWiEx7Xe/lx1oH6yyapisokKi3pmxEJO5EDgjw+2+/wzkvokAxIWfpefBw3wCtxzRFICe8HORejcOMpmnhmy1a02DXdDA2SnWZFeJgygWp8x4Gch6N97DOI2fg09Oz1KD9+AFt49F3ggQ4J/NgnmeglDeGEDCNs5SoxhkhzpJagwewkIjncfjm9fM7FQNVpL5yAtaGiAviOkK45QTwO/z81U899vWCHIJ09ptnadk5h1mY/iGU37GWpixF/WVflQ9azxgwkutZ0ICsYEL5zHKNOmbn3wDytaHW10gkQHMNla8KAyteqi3RzQ0nYD3OHJcvRfu3ti9F2jrqWv9+Gzm87xis9/0lB0DG4nourefWLUdmjXzo6GaNBOjoUs9HWyIRWVy7uljquQYscr/a4eAiSsY/I219XlwkaRQpCqTTKzyONpZ84HUFgkYE+J5OETEyv4UIrMdFIwgaXeD7mtC4jmz1d/W9WEfl+nlf0AEhNxHq1o7bGnkgKkKoVq8dGlnhvdFGTZ8foW9nJUq+IqgVJKJ+pqQqdDqEMPt1fft1hE1i2xqNmOcZIV63+dX8C5JHNYHVGFzN1TVx0PtFynd9P9aBgcD8SzUH0056fup5mlKqqRpyQ7TzyLQP55B2QjhHY4zFCZDPrHtb0LkhYpGS8LlMYDpjpS5b1m9ZFg0ALS602BmmhJqCuAq0L2irs0RdHJyTtN9lOAM5YTgz5TbDGgdnpQUyUOa8EQObM8uHC/s/5dpIbp4ijDeYZ1tL01kZkOv5y3ktPA6HbAzmSco4x2EEckLXOmI6yAmFc1GazWVJgc9hRpgnSG1FEmJgSUUZY+GafxIxMMaIaK8npjZ0fHA5Yfk+F6u1Ohm/p2VZ3xiLdINFHCLGSTSZh1GIgOezNGwYhlEaN8wzYGyp9TdIEHUibUuIABjjisa0rzfLmAzvEtgQCCVCx/KXUhBQgL9Z4FSALUjt4jSo45sMWIjjYUsrYQuLbFE6El4v5Ouon2O4joDXC/L693vGer346++9ty+9rR3D945967tlll9dw/o615s2ZtqB1AsVcG2IaSyrwQDQdVs0jeS4GS1xseRx5nnG6+sr2ratUVTOGa+vr7hcLrV18P39fV3cAVRok3lf5mQBidRPp3MVD6JYCKN5MvcPh8NVvpy8ArL++byRn8AoV4+Nht15TtoJoEHmj66911H/mmVOg0uERDtYPBalkwGJnJcc8VDPXRMRrbW1OyB5B/f395hKf4+cl8oJay3O5zOOxyNOJ1H3I2+Bn/n8+bNIspoE70UjgaqHZHGTm3C5XJCS6OHv9/vq2BHxocNAdIljTh4Jo2EK/UgZqqgpalid3JOmafD6+ophGHA8HjFNU60OcM5VLgCwKEhqZ0/vj5/hvQaAu3vJOxOtosok5y+1HSTvLM/N4XDA3//+d+z3+zpviZpoh47IFJ1m3htjDDIcEkRN8OHhoepX0Fk4nU5VqXOaJhyPR5XWAIxZ+B7SW2CqY04+zLIOiE1hlcgvH37ApuvQdT28Z87fY7e/R98L236aRmx3Gzx9/oRx4Py5VE7MfnePTb9F4zs46wHjkDIwjQEpoSAEDgYZMRbd/+AweUFtwjxjuAyYZlEClHNv0PgGXd+jbVpY74GccL4MiGGGNRmbvkPfeVgDxOAAV2ykM3CNRYwZMc4YpwvG4VLFgpqWyEJZV+23B4bf5QRIhIqr5HhW/7/+Fz9vSpmGkvWMusmGgUlW5eR5YyUHFBPLhwJClHa/Uwi1rG+cS51/EGlGWcTKiRhTvS2URkRIy/4lLcCw3NTvmJo6KGV7tN7l4iRZQDRBOwFFh7I4A3LzTc3nlAMvA5TluAbSLCOnjGwNsslI5m1+nee9jjje3KPV6+9F8+v93nICbh3/e15fbzz3N9H9ysH5nu1WOmQ9DtpJXUex1rXygDbNlfOqo2Yd2elIkzC+zpOvCXkA6qKsO+rN80L4o244DbaWJNZQrR5DnoOugNA5a2Bp3kViGkVhNBrHcdJRMf/me3p+0AlYo3g6f69RAC2iJEZgukqjAKgGgGOgiYE66uX16fPTJFCSIgFUY9l1naA+JsJZK3DyLK2AYwxoSqohBInCp3FEbTTjJD8bigMVClzdNA2kNa78eOcAA4RZnnfqxY/TWDoKXgc7WuaZctM04BxX3vc1akQnhMiQ5qlwPJeyT9T7lurCyPstETn7DgC2ig6xFG25B+yquKAwl8u5nE8oztzyTGR4ZHTo+w36ToyeLrHVyINc33DlzACpohJiM+Q86ZTpORFjrlF6SgnDMMIkYJ6v+yvIWIomCCAlrMNmg67biG7MNKJtO3Rdi+1mj77bwBiB8EOpAkgpIicjazWDygw5hxCAy4yUqVMT6txuC9O/9c1y/sYgg444ShluxHDZAzkXZ6C0YTZE4hY+EnKqnJCmVBdwi7d1125u3+cEOCFrGCTxNIqyHWHtqqNvjUTWZVIEVZ60RgKsFQdAfucKmRAenuYZeZQGP3OINS81TjNCSiLgkFJVCgwxXylU+aZFhqg3IaO09uV5Cwcg074TqjdimGOKYOmePJcRyIAlwcWQH0AUwBajXogoRddaJw6Wg5myL1QeAJwRBS2TAFxLrq6N+pecAEJ/+n1t2Nav6/e5YOv96d9fev09GF9/9qYDAEiViDrv965d/70+h7Wh10YLQI04N5vNVXnbMAYAS/c5Gi5Cm2tDS4iTOev9fl+PTx143V0uhIDT6QTnlhp4LtjzLO89Pz/X69vv91eSxMMwXKU36ACwBI85cEaxdSHOC8nqeDzW/ZB9zfeAa4Lge06iZq/runQ6BBTy0WgCKxJ0nXnOqj4/XQvN0JmiBgEdLKJbbdvWaJLnzb+HYag6+oA0ttlut5imSQywEXnWME9IMSBG2e9ut0EfWzRe7v3lckJK0uJ1v9+j7/c4ziOOx4NCYwycNfDOom082laW0mkEgIRpGgrSc5J8dLfU1ltra2UAI3BrbW0IRUdUCx7plAQrJegssgqBBpuKiOM4FkdnxjguEsTawZX1QFrpSkqsxfm8xW63xf39Hvf392+cZhrzEKaqXij3poH3Dfb7HYxpkI0oS+52u0J0W5w4oktSrTLjUrTuJf1A2H2xFXLu0gaYFS2aKyKIgjiYL3jBxTUlfSDB3Dw7XM6X8h0ZJ5hHpBRx//IBvqAsd3d3uLu7Q9d0aJoWwzAjTAmHWVT+clwg+lSaM2WIumPOAad0Xp7Rsh71BVXqfIPG+YIOF9tXHKJggJeXF5zPDtu+w363wXbTlPvSwjsLVxxToIP3Fqnv0Lalmqfrq9YJADTtdHMtvbV9lxPAm1i9UpOAtMDPkl8ti/CK3awXBx1hAdf5UYGSlgUoxoB5itUJICTHdMBcBH5iSted6IwpNbLSO8DYDJNQ4P1S1wllkMnl5CKIjBQDkGON85f/a+NjiuG3YHZfHhSRqKyPToba99vNllRDLvKPui5BG85bzsDa8N5KBdz60e/x3+sIcb3Prxn9tQOyhvX1duVY8Ildbbf28SWHREdbt/K36/PIOWO4DLU5iobHtVHld7kgkj/AjREL26zyGIzmCd2TjCcL/VI3rjkBhN71Ql35CwrG1+eqkQDdwIj393Q6YZqmN6V/PM9bKSVu+pkFFmLiuoOfdlA4RrqCgFGjzsFrrgPvH7+j+RU0Bvv9HpfLBYfDoZ6LtRaPj4/ViQWA0+lU74+cSyul1DldjR/nLM9XVwLknGuaQCMkQOkJoOaYdrJ1+jKEAEQgpFDvIe8vDdjlcqmlm4x0jRHZ4hhjlTHu+/7qGdMpUl7LMIjzISIyF3StGHY6pURFWJZJZ7DrOmw2G9zd3eHx8fHqOLw+3muiNjplwfvOJkniBLTVSZumsUbI1xyRRUMG4NyRdZ/HWJ67pfriFsLnnEOKTur6IyCywAYhTojR4vVwQEoRz893MCZhnC44HI4lPTXWZ2az2QDZIsaEcZgwjoLUzXOESULmm+cs3V5ThjFC4ssOSEXOPqcE7zyakjLa7/fw1sHCIAURIZLKBKJauZT3WVzOF3i3pHmd87BOYiQPD2NaAF4Q5IJEZfLZ1Jh+6/ZdToBvGni3SIuuc8A696ohG05wjQTwBurJpQ3SAokFXC4DhnGSzn+ltngKQfIjmebb0s4KMuFsFXdAptKg1P0bhv2ZOEYCYOVDlt5xRJhGoAg0LE7ANUGwsgPydcTvnBc958W3KOeW6vfqXo0wUGu6BRkmL4Z8bWzfM+gct1uLvF6kvuQQrAlhep/rn3WUr3+/Z7xvIRDyxbcSzd/iAOhjEiZbG0guyvr1xcBmvB5eMU1z7W6n+S7MP3Lx5pze7XZVEY811LJQzHVhNMZUp4BdBDWznmxvQvRriJgGjYaF39WNgmj4FlLZtRaBFnqJMeLDhw+qbj69uQ+aaMYx0KQ1nTemw8Wua6yA0FHaekGapgnn86kaV/ICeB+JBmiJY37PGIMffvgBLy8v+O///b8DkMhxv9/j48ePletxOBzw/PxcDZDk7bcIEyB14Yvx0A4ea/W1sJSu79dERhoMGmLC8Nohq2OWI+Jl6X/AeUiUh7wSRvh0nij2JPXrS+qH84xroX62j0cxan/88QfO5zN2uw28d7Xa4u7uDjFG/PHHHzWPzvTJjz/+iF9++QW73Q5/+ctf8PnzZzw9PVXDTdRBcxN4vRxHpses7QC7qXPvMlxqtA/gSp+C4wawTBeYBFK5yv3Lav220ynvn/cNUsqYx4A5zdhsuuoYCRow4HQ8oWmKrHAY8Xp4wfPzM8IsUr7OOdzd3eF8GjAME46nI07HM4azdML1tgNgMY1MO0sPgqZpkL0BvJQo5pTQtZIOuX94wMcPH5CLFsr59Yg5jMhJ9HBSlN+XywXWAIfDK6xdSlfbtoEjwdF5NEbQJ/Y+AIpOjlrj/mlOQMgGNgvJLkOEgwwK7FE9MgsDqePMpVYxlnrMnKhsVDYjOfkMg5QNYjaItJHFmJ+DwzG2uISEac44jwbTZDAHgfGNcQL9O4cMg4iEhIw5Sf29L3BNSqi1o7lYZLkJNIQo58L5looamI7JOcAs41M93I0TAmB9wDOmOXLuKkrB4kCYMgYmo9IMS5YAMLhpsOUr14ZYf04vbrcifv36+v2UpFU0VcQkOGd6w5bfvG8L54Mlj1eb6rFchr3+Jvei3EBIBMCJy1xbrk4dz2+5BwqFKffAWS/3hEas3EtrG8SUYH0qebyMEIGQIqZ5kIfvLNHQbtuJqEqzqVFgLg4jFxvnPJz3SMgYJsKhAXNKiDC4zAEmRKTX49IJ0nh0u3sYa2qnMmstHCA/pV44Z1yJwnDfcmw6IVSwc3h8vK8QrhDPAGMyMqJEDs4ixqKCZhKMTUh5RsqA8xbGimY55yHysvDkLCkaqWu28G2DLkrKzTlXZbBhJMVmcsI4jRhnWTiNMWjLQr/dbKQe3FpkJIHdQ4Y1srBZk8uxgLZ16NoGfS8kKldy7TEKIpfiBGeBn378gPP5jKfnZzibEe62aBqLDx/uRV7Vyb6MSRjHM6bJIISLrENZCLu7knb54YcfBBEqUfTxeKx12jTmzgtxWJ414DKccBlO8I04QSjVRPM8IqZZXjcdnDeY5hmXywBrHMIcMVzG0oFuLKWg0qrWWQ9fesunmFCrjbI8f20rSEVOGc56OOsKLJ1wPBwLz0Lg+ca32O8cvGtgYBBDBLJBCFS1FP35VHLnx9MZ/eaM4+lSkRhjG3T9HuPrC87DjGw8WjiMc4a1Gcl4ZNsiQcZ0CBnwwJwdECLCdKz5/MvphOPpWJxo0X1JvoHzAmV7J+vfbrNDRsZwFjJp23RABkIUguA0zRgv4vjc3d3B3vuC6BrEOSNMoj2DbHA4STtn71tYIzZmGIG//vtnWWdSLOWULaztsNlawOxwPgPT7BBTg5g8YnaYo+gC2C7BOou+kXFFFtvju9KHJO1kLjemoCs9GnjMw4RhHDDPUnkR51nQ5pQxIGBExlTWrSEabJJDMj3m6HE4zOhbj23fwtkMbzN8tvDJyLODhNMkwkS1E2X4dlLAdzoBhb2ek0RukIfXWQNvbTGOEEZ/FFIGpTXpFFxFtAU+F6fCIGcZ1AwUsSDgFB1egsFljhjGiNNgMI5ASrLAsvylMSU6MqX9ZZqRjAwUjQij8YLDIselzec6VbGOsLktkGwuC3NhiXoxDldkrRjefB94P7++/C1EkHUVBj+rIdg6lnlp3bqQa64j7ltEL/0Zai+EdB0tMSq0IoQgpYzGiMG94XHmnKtT8MYBgEY1ljeMNfCUXkWuCo7guS6jA/IvjDGA5Tk21Smp0Wz5jM25NhqRSFYWFJJJz+cjDBK8e0Tfedzd3y/QfggYhgmiI+DgGg/ftCJRXUqp5nmWVtQwmKaAlDNOoyiJbUqP8t1eGN+2RPE5Z9gY4WOAdxOcXXL4dZ8FIaDamfReLzm/psFPP/14peMul58BLDK/85yBOQImwpiInGekBFjv4MzCKwBwxT9g/lgTsNaQd51HEJXPaZzruAGSk++6TtYIIgNI8I2BmwFrpfrGWqZCDLrWoe89Nn1TEY9cHHaZ4xHOZfzyy4/4448/8G//9n/BO2Ca7tE2Fv3HB3gHNA2f+4hxIFN/RMqLWuPuboO28/jLrz8j54zn52ecTiecL8daW38+nzHNEc5beLM0kHr946lEmALXd72kL8ZZjtW0Dk3rsLM9hssEarfEEDGkAdM4XcHYjKydc5Jz5owvhGVrHPpOyiSRgdQkpK6v3RcPr0c8PT3V53az2WC/3aFxQmCcp4DkMmKIxTleHM9pjkiHE7pui8PhLHA4HKxr0W0swvMB58sM60T90M0yJxMawAIRszRvCwACMGeLOAcMh3N91s+nE46vh4U0mxKiD3h4eBA+Q5R7vd/tkVLCi3kBAHSN8BtS6f46Xuall0U06Nttfd7DlBCmVEv6jscjcs744eNHGOelzfFlxt9/+7OsZ9Jtz/sO2+0G2/0OGR2ORyBnVwJTj5g9pijOTGsTnM/Y7trSprmsSCbAxgZuENi/bRv0fYt+0yHmGdN5xPH0itNwlNQQyyMzMOSIySRMVoLsIRqMySGixxQcXl8C0tZh03TiKANwOcPFDFcc6TRFTOMEZxzgcCVQ9LXtu3UCtOEwTOPqhdca5DqFCTGuOk7pfaofVDXAReM/Z73vhSG8hsdvsZIJuenPaAhUw57c1hE0v8v35HretuRcM65vORDfs1XDa22Nzm5B8vq89Dnp7T2HZr0ZiFfrblzr+rfe9630w3vbrXEFiuMIPU+yQmmKgiQMrJU5sVyvLJLJJJCdqsmAqJUemkW+QLgZGT/99BO61uPXX/8FXddjU0qZjDEYpwk5L1UAzjdwpX2ptHoVlnYzR4SU0MyhzjljzHXdvlkSRsZaxGnEeDzWkjnrTEVErnPVQmR6fHxUFQiLYBHljr338I2rjrHmGIyjlBsKpOsxDyIyQiOknxWdZ123Uc55YWfTedbvkazGuavZ/DFGOCORDIBKaGPKhSJMNZpRzyrr1fX+SPwDgOfn59oqmTA6nSn5TMbpnDHPY037PD8/I8aIp6cnGGOu0jLa0WZ+nnLJ1oqYESs9jDFXMtE8X6I5KaeaqtD8pzoHyzWyZJAEP0LhJAOSYMkUCvfPNAJTM4T9u67Dpm9hrakli9KjHtV5kEg9lmsRXhPTUXTED4cDxnGUvLb31bleBxYpSvrpeDghzjPOr8d6z8iT4d9rzgfPj5obnHMcA/6tU14AqpAT18umaTBPUp8PoPaMkLU/XK2lbvW8GSOs/xgjYmLqegkSpdlQvprb1ui0Y4TJc1GwTRjGiGRmzHHElEYcz6+4TBcYVxBMJcRkYLHf7YHCbxvHCS8vr+gaj423sCZh13tkb2Bag8ZBSsmtIGn9pofpCvemjOe3bt+pGKjgdLXVhc2onLlZIPM3xgu4iuwSDEw2wuAvgxITYW6BedcL4zr3zHO6RUDk594zhu8Z1S9t+vh8sPX5rCP179m+ZORv7Xv9/i0nQP/7zf1T36d3e+t4dvXelwz+tzoD9TekS+Vyn1AfuJSKU2kMUhK0aRlzI3QOLkaKVspToBNwTdqiowh8/PABu90GP/38M9q2q+V50yQIwDzHuij7poVrGrgQYe1Skuca2advFlQJQEGHWCUivBR6zzFIHwDmg6U72sI94JiT+X1/f4+2batSXNv6ygbnwto0Hm3bLKTYtMjQOsc2wA4pTdD9GtbOsHa4tfofgFrDT6Op5xCdAM39obEzxiBZwBSgSis00sCyckOjc+IIddUoEKKnbn6MES8vLzUC5ngxX82c+jRfEOOilUBi3svLS81N0wlYP3vUKtjv91VLQrrbvdZyRxoh3gtd2klypDb6mrehg5j7+/vKsWBaKqV01Y5aOwG6XTMdo4eHB/RdV5zmBdWaZkbti/4ASbAigzstjqGTtVfPC+cWKdurNTXnomsfcD5fEKYJ51IRQ5loziutPEnnkw4b+2KQw0Dnj/eHqpK8d6fTqT4vdJ6mcaniWYK6RbSqLCXlfaZhy/wleTEtPUcW1EvGkk6AdQ7OLIJTJhuYHCT3HCISAmIyGMMFw3zBeThhnAf4roVryjgaK9wCGGw3WyBlhEHSHsfDEXPbIHeSJhqGBmgFjUdjJOLPGdZCUm/OVg7SMP6TqgNiECncEqqDeeOM4pXkt8QtY5ZmHyFSLUryaskYwFgYL/KKsshr+dlro6WNERctvfjw95pVrSfs+txo2DQqwP3eKpvS768jYO0QrCPm793WhlezadeOwBqp+JIT8LVjNk0Dq5ya9xyRW/tfH/+987j1fs6lnTLoWNERKPdV3gDrmes5wyDFhDEMgJHqlGXcZB9zEFXJxbBcX/NllE6Tnz8/VbLbNE349OkT5nnGZZhqdBlzhs8Z8xyqQmWMEVOQ6GMuSpVVgjUvQjk6OnfeI01jjeDEyWjgG1eFh7ixx/p1dL5UClzL+drqAKznCA2ztbnk9N/C/dpx5j65f+6Lr+lIkK/TEMcoDk6sUSYjrYRZpQV5nhTcoTgNGfnrWngeg47D4+MjXl5e8Mcff4C97JmGoIPF69huJSVzPFIyWXTbP39+ukJExLFLmCYxaKfTGdY6jOOE7XaH7XaHu7t75Jzx17/+O47HI/7+979VSV0ZG4N5nnA8ntA2Hfb7hzoGPB8SLV9eXmr1CA27XkPoVJ3P58r85340UkJmO0mlMUZJ3eVU2e/GLToMzjn8+OOPuFwu+JTFCWfbZ2stun6DpjjFbDDkfSNcqrygOURjEliF4+GMhbu7nvN83nSZIw2q7h3B6+ZrnHdEQ4gYUdlQO6JEiZnykUq1pZoipUUoq2kcqJFgyzHGccQQI2zh3khJ3gbzNGCasojRzXNF47bFUcs5I8eANMVyPF/a1gPn4YjTcMJ5PGGcR+ywRwMZSyMRjfA8fIOMjBAnTNOMyzAipQiPBkdE2Dyh9wZ9a7DdeGx66WfgrME8OQST8enTZ1yGC/7+9z/wrdv3pQNSKnWR4gRYC+QEZJOFdMXocGVz6MUJMSlDuubJpMnGANZBYFsDITZJ5LI2vLzRXzJE6+9oJ0C/z03vb22cNMypF8i10bu13//MdsvY64foa0jBtzoBb8YQi6f/ngPzrdf8vY5Azhnm6t4tSEBNF4HR/bpxDBDmCGMlb6sRC0J1QRlsQDkK2WCepB3s6XSqxnCaJry+SqewOShlNIjjOodZHAGWu8WEmMTRpROQUsI0L8I2XKRqdUBOcMWhFMPg0ZQ2rYSPgev0k3aCdbRec8vuPQRKPw/FwOB6X1yQ9XG1o8Hj13IsBW0DS+WDMddSvtoxluYv4c3cpYFnFM/oWM+x9TUzIicjXncaJDrCfUvapC/n2WLh3WQcj6crxGO73YpDV4h2wzBWhyGljKZpcXd3B+ccnp6ei7MSS4mXEGvbdsY0zRiGEc41Vykbdv9b9P7nq6iTlQfa2WHkzvJIplKu5pOC2Tn+dAKqU5Ad4JeeB3d3dzDG4vVwQozDlWiVdV7SX45NrUrDm6RL/Cy6rmhGGLVeGgOf+7qvW8gQ7z8dA+3wcb5ox4BjxXmybqy1Dtx80d+XMWBQyKZ05FYtqEDOGWEOmMYBbdeC8sx0bKyVPg4hFBGwnNGr6oWUkwgGZYfkmPPPmMYBw+WMYbxgCiPavoXzDsiAySilqxnWOCQj5xhjwlTuX/AGIyKOecTkgakxyLkFINoWzlmM0WLOGS+HV5xOJ3x6+nxjDbi9fZcTMIcACuaYLFUB2RkgW5ic4bJFduIZZBWFm6LjTGCWgj2ppBZygXtjQlEILNFVDBiCwxQXaG1dlshFhIuXLjekZ81Jsd70AqS3tZFfQ556kdUeu46+/jMowPr8vva3vl59vt99PJTubKvX18b+a4Z//feXEAD+bd76jnJOppAHV45ONYxWNaC68V3nSomfqmnmYh6jkFYPcYC1qLXnnGfjOAth0TfS0WwYYecAN45gzwqef2T1SS5tSzgHcqpwIbBEb2JUl9y7MQb9pqs13d57Nd9LrrXIyqaUsNn0+OmnH2t6gIstzNv7JMfwaJpFbrdpWxjragQJXLeNZq5fG95lTJfyvzV5lQv8OI74888/K2TOiNE7g84vzocWRAJQG9zwvFgpsYzhMr+bpsHj46Ow+YtTMgxDdSTINSCEvttusd1u6nkSoidiMQxDRRFYJfD6+lq5AzlL+SEFiKy1NZf94cOHK37EuhkPNRwohHR3d1fXNKnpHyokznWMTslPP/10VYZ6uVyqTgUdBW6cSywfDPNYz0Emg6kGNaWMaZxwKogJz6frevT9Bvu7O9zfPyjBJrEBsSA5TdOiaUyF7BOW7pbWeTRtf+WkGmNqmm1NYmaKgw4Mx48OEREgOhT685qzEirx0RZD7iWkzOxXcI3i5gLxCzoh6I3cKxLdyzPqHVxYeoZUPkeSFOQ8z0CIMHmCsS3a1sNYqdC5jELey6no/ccIpARnDZz36JoWISRMozQ26toem77DfnePxhs4D4zzGa8vL2h8Ruszfph3CEkqYpwzCK5DLKkFaz26bnNjNb29fZcTkFJCioIEmCJxa4xFMoT2ITytlOriJxN6YdXWqDoXzwkGOSckQOR/I5tuRExhxhwbhGSucoRrI72OhLnAcJG6ZZC/ZmCBaw/zvc/citr/ZzgA62O8d823zvlb9vfOG8VZu97XGo1Zv/el7VscAfl3LuqJ106NHn/cGmsr0RxMLMTA5VwtIW9gaclpDHKeoXOEOc01p5kTpYGFFCXGzoqs6DzDltx2KLyCZZ4VFzcvDqOct7j6LLtcO7HAkiclArDuPTAXNIEL3y2J4rqoQZwGfYi36IGD81Ie2FL5D0ufA3Pje9XJUq/hytFexp09CgjHUxfeWou2cfBmkQjWSI3OjWtBGj0HtXwyc+CsX+extbKjljJu2i2cs9jv95UTEELA+XyukarWlWCun84B/9YiUszTs3cAOSJr5U19zmyIRKeUY8Pj0sHg+Wh9Bo2QfGnt4fWwvzzvYU4Z0XA9zZinUAXYtOhP07Slzr1X6Z8CqZf5Ja15LXzpdhfVGmWNKSWPro4z58WaRE3kSN/viqSVsdDOJ+eBRpiWdFYs85LidhY5Xje9c06icDndVNeCEEyp2V9+KIVMMiQ0o402r6StkRMsIqxN8F4cAOuEgGjMGk2W4NhZ6SmQc8Q8TcgJaH2Dtukkz28BYyPCkHA6n+BdRtskbLYWm1kqGJw3SNkiGWm7bJ1D0y5CZl/bvpsTYGRGSzrAmKKjbIGUYKNBdCK6s1ywtPvNAGJIQh6JSfIlGcUJsFX6N4SIS1FZG+cZyfaIZmklzJvPTUfhnET0EK88YLWtI/lb/9Y3TB9v7XBUT9G5q3PRBKB/dPu64Xz7ubWxfu/6bm3GSP30Ar2/hfu/dE3figTc+rzBdTpDcv8qRVPHemnnatTDLwQm8coXdKgImzhRsORiejic6uIeY0DTi0DJXJQDUwKMNeiUzOs0Txiel26BpjgYXMBD4oNd5oW7NnTOcnxFarZpnOgJzG/Z9bqyRc9DGrZcFjkttctnI4QZ4zTU/enFXUP55BR4J2mBVDq3CbAnpbveWTTlM60vOhjWIMeA6VKqMQDJhaaEkKYyvgecz2d8+v13jJOM86bfALstcgRCQCVa8l7xudY5fELzjNr5OWBJPVgraoE//fQTjDGV+U/Rpru7uxrp970gBGzMxDVjv9/XMeaYapY6oefj8Yg//vij5qlzzkXvPVd5XUa6JCr+8MMP6PtNFZeiVLAmCnIsSIpkUx8qHv7xxx/1/LquqxUQu92upgnoMNzf39e20jlnnE+HOm9ijHh6ecYwjHh6ekaYQ3VixnmCcx59L6qBHz58xKYQUAGDGHPlLTjP5k0OqZAOk+J6pJSQQkQaJ/R9j7u7O+Scr1IgwNKZU3O3iKZQJVGPCZ2A0+mE33///Sq9AkAJOmVZOxLJkyNi4SHknOC8sPpDIG+olOEOBm3j0bUtUs6FOFnQ65ThXYOHh0c4Z/Hjjz+ia1tsukJUnWY4a7DvDfq+w/39VgTrnMWczphmh8sAjEaQQouMzrfoui283SLGhEM+wcDg4f4em77H/cMjkALCeEBMEcfLCZu+dAh0GaYpJfEpAzkC1uHxh0d45/HDzz+/u06vt+8sESzCLwX2TMgwySxIACjFK9guDaGUd+XiBOTiBGTEqgkg0dw0Uxp4KkzWCdlZJOuUB3VNzHsvAudn1k7ALfTg1vvL9b41YPq7OlJaIxD/GSfglmHnwrNGBdbnd+u470bX6/2UiG/92e+N+N97/d3zvLoNhXCaV/fJvE29WCsiINbIHEtY7gtlrl3RcOB+aADlHABqXmSekxGESzt2OUp7UI6/89J+WEPoEh0VZ7Scr85LS2QqegNNiaxSWaB1LnMNsVf0TCFh2uHglpLUMusodOFB6Pti6jMsO+Lw5+Xel1siGvkSsei5HeK8pGTKftg0ZxpH+ZnGEt1IMCBkxGVuMarT10ZUQKsO0snW817LKtMwUluB0SOZ/DTUbL7C+bxGHTTJcrlfvhKb5yL60zSnet40sNwY8epWvOuOf/r4OljQawjz8EQAUkpXvQHoNFwul6uqgUVlThzYnEJNo/C9lCKGywXTJGOVy+wXIlyLViEAdAL4fbl3fG1RVRQnkI6hQQwzhuKQbbfbKwdUR+631gRG6/wMOQD6e5fLZUlDpKVXBQmfwj8R4SDOy+X8IT1aoqwzYuQBkwBvLdCgkB9TuUa5JmudNABq/FK9oCpcGhj03mCzadBvmtoPpWsdmsbBO9FYobqAs9J4yhiHGDLaNsAai+12h77r4JsGKcjYpJwkDQMD642UE/uSes+y8hmk6sT2m39SK2FrrUQKRZWv3rgkfQRyNjDJ1If+2glAbe4TS9QUQTU/YYZPIWIOwrSe54hhish2RlotdsD1AqgXUU0KI7x5y2h+7e/1AruG5NcQq57cX4u4v7bpBUJDU2uHh+ej67CBaw7DLcP/JXTgS6jCl8731u/39rl+HSjmZzVsV+f2xvgXFrxzyKHop1tbiXVSFlagyAqNLq1gAdRcJ7KId2jY0TmHtt/U8TQIgCJsbTZbtIWYZYzBNAfEtCxem80W1i2M+3FaGgfVdsXjhLmURAkkz2j+WmRKFvHF8dU5cs459icYhgtO5+ONcZbFj3NlThHA0suA57nuFc/fOvJmbpoGmhsNOJX3jDGVs7Db7fDw8ICcImKc6hhwnjMnTT17Lqx0BHR6gPtlHv/u7g4///wznp+f8enTpyt9gAXKlsVc2PivFQ3w3uPjx4/oug739/fVsIvRD9jtdvjw4SP+/PNPvLy81LbOmrhHlIIkQ4lU/8Bms8FmswWyQdssjH9WTlAfoooUnc/ViSCEboyp1/Dhwwd0XYf9fl/XnOfn53ot7JfAOSatq++QSifWaZogEucLairNfby0t227qnN/f38P6zysW1QJeZxUoGyuOa+vr0g5o6mlrHe4lGtkbT95GtoxSilV6WG9NvH89TqrHabT6YTX19facplIyOvrK8ZxrBoJw3CBNRaXggRRFySHWNKGSdIWruj95yglvDkxJID3MueJCm62Xa1OaEo+X66jQ2tmPPgT2q5Bv92C8fJl2GAYNzhfesxxRts2aArp0FsHb1tkb9E3Ozjn8XB3D2uBEIRDcJlGxJzR9h32D1v8+NMdPvx4h8ePewzjCfM8YhwDYshw95CGVv8sTgBLKTJQ3BnmRpbPLJ69rvHWq7tRv2xJAufyggV7/ZZlSyagWQwgJ0rdmyHB49ub3ujtSwZbG9u1I/GfNfRf2tYR4JeM53ufv+UAvIcA1DHE+07Ae+f0tch/fY7vfUacbV2hIcm2er4513lUHSEs551SgjVrB63kR2Os5Xw6nSRGzQhRB9cpJS6AxojiYAkZSjQpncG6rr/KbepoWzfbSimXdxaD2jQeLmfY2NVrDHEGa/f1vWLOnQsZS52odaCjaBpiju9yj6H2JdERr1kTAzVDe83Of2/TpEF9X/m6joZF58m9iQrpnC1pjWuERB+LETuPyehYi8/osSJyImNkrvLT2uHRXRCFSMma/7w4jFgi6jXPgq9VtKQ4ns5d6x4wYiUZkHNSO3cxLlr9PDeW/7GREB0Eok08Jg2+tRYpBpBYKl326GTK2Aq60KDr+qv7JGMv7HpjWAWCOs+MWQIVogmuVLQIk/6aJH0LNSW6o+egnkf8Nx0zzdXQSCufZ84b/XrC8owYA1yp1JTnWpzghASDmCLYgtlYg5wF9bBOpLJZrksQjfe86zp01qJvJqnyaWz9TFuaOPVdi75t0RBpylwX5ZkUZ29xWqdxFkegIHm+8Wi7Fv2mR9u38K2Hiw4hlYAoS3NfawD3Hebpu5yAtmnRelcWoICS0S+9A5b8CpcMKk5xUiAJIVAQGAMPiwThBtiUkUwAbMCcgGRmNNlgThRTWAb81uKwXqz0gr7+3Ddfbyn/0JDle4avoh7pumzqH9n0IqYh4PXDoSO4Nf/hPQRgvR+9GZTuaO9c43sG/tb5f+27bz+TEKN+f5W2scJ8T2mF+JSHKIQAh2t4WcZvwmUYMIxjjRgKA6EajZhkEXDNMne5SHnv6+Ir+ckGjeIK/O1vf8PLywumURZzY8V5YJ5SIpoMHy2ltoCUkGJE17Z42C7R8PlywjAsxnwxzteG/nw+w3uPYbgAyKrq4bqZzfV9XyJhYYWHuqhreJq5cGMklaYXal2OttvtrpAT3lMaZY6bMUs3wRACGu/Q97sq4AMsLZ65hRCUgJI4CjRqmiVOY+ucq90Fd7ud4n4c1D0HzudTJe6xkkATAjkGzPlvNps6H//yl7/gw4cP1YDTWFLh8O7uro7RbrfD4XDAPM/47bff8PDwiN12f3WfGFkTMWFFAqFuzuOu6/CXv/wF2+0W9/f3VyI7gjhtcH9/X6sZjscjTqcTXl5epGKiOIyn0xnzPOHp+eUqZXB39wDnxbhwvohQzQn3D01tdZxSwuFwxDxHhJBqykzmZbnvxcFt2xZmu0P8+LGqOK7TMKyAYSks5wINPIWMiBjQsSG/g9/XyA3386ZzZWkCt9n0BXGTirQUA5rGY7Pt67M1nM94eXmpKZe2LY67Fw0OZIMwJzw/vcA5i91mUWjceIt9JyWWzqOWwe/3G6T8CECEtmA7wDSIIeByuuB8foUxHj//9CtMkR6fpgGfP/2BnAOcm2Ctwf3DPR4/3OPDD4/Y3TVoeo8xWpgM7F0HiwZdY+BMQJj+SYqBrhCsjEHxXkhy0NC5hTFSJ6ohAkZClV9Z3jcl/ysd/gilS1c9qGiP260IXxuU6xzt17vQvWeU1guN/pwmCq6PTcP8n3UC+PtLSMDXnBNexxrF+JIjkG4cb33M9f7X57r+3BcRAL4GVD1teW0hBhpjqtu9Po4p+TrnhOyjI7CUFsN2XV66qA6yXhhYyJwhRAAip+rKQrXZbPDw8FCdAC4wLLmraSBznUv3zsm1FSjSQNjCTkVDvEd2FTktP+WZUg4fr5FGtzLsw3yVp17QrIT6FBKdyAYpCRSbU5Z23CHUCg3nbCHYyW+m+RbOxnIfjVmQQluumyVssmCX6NItXRnX80HzItZONZ0NnRfW80CX1HGMmP7hvud5adW71jRghKnRIqIh/DcNljHmirznva8CP/wuDRQNqHZieByW8a2fCY0KcK1ZPzN6TMgVYFqIc4GphxQjjsdjVeSjcyGB8PIsAKXSo7RG1yiKnnvG2jrHOYdlEVdtn5ErsqBTpLxnOpDT80A7smuEgONIBGS9NnN+EMLXzrAxQNMuCog5JUSDyjeoqMY4XK2nbDqWcpYeJHWc5LmxkJr+zWaDZKPQi4ykFmAsrDHF8W2x2W4QExCSQ0xlbsUJ5/MFgMP8OMMYcTSmcSpS1Aldl+F8QQoakQY3tjgzBTNvG4/GtXClqV8I/yTFwL7r4KxBTq5qtskNBSzWRsDA2pL7zwCikLak0x83U92IDOn6l9RrgJO6ViwGmQ+u3rRh5ntrjoCOjPn3exvfW080DTXdMtD8LP/9j6YM1vvWDo2+Br7+JSdAe9nr19+MIxYk4H/W9jUEgFtKCbhqMLU4kQL9Q92L8pqVbobWGNzd3RUN9AHnAonK8SCOq+JuhJBqJGgM8PDh4Sq3OIznMm4jAIO26/Hw+AH/5b/8l7qPw+GA0+lUVe5yzjUittZi07VoC2ENGZgaVxcT7xy6voXD+r5cz13dGGhdOz0MAz59+lQjyMUxGHC+nJZxMyzBkoZe8vxYbDdbeOeRky3lgYR2h7rwpyhchBgmpBhqKkQTxowB0HVCxjLSkKXvGnhn0PdthUp5j4XVvkXO+YoZvjZyvH/a6dH5e+/9VckZywX3+319Rp6ennA+n6uU8GbbVbY6Ve54LB6DhohOBcsCeY5EhP7lX/4Fu92uqvj9+7//e43kc871mHIcU+8V2ycT6ZjnuaIJ+nnWxp/se/aK0GWkbKX8+vpa909uQSqIU4wRz88iajQVvsGHDx9hrTiPMUWkcRQ/Owvfousi2r5D07XVCRhHicabpoUrKRg+k9TImKYJT09PaL3Hfru9Kt9cp6s0gkSHjZoMRBSIxtCoi46B8CKEqHmpc/zu7g5936PvOzhnC2EyS+qtlIY6V9JcKSPMM/pNj4eHuyWdNs84HQ71PkzThFjKDqPz8F6M7vl8Qk4JhzK/c86IO+DDJsACCFGqKJxvsNm2aDctnG+w3004nGYMY8TT0xmXy4S//+0TcjbY9nfo+w28azCOF3z+/Bld59C2wtvodx3avoPzUpUxzjPmOCGmgPvHLe42d5UkOvyzegeM44i28VcPrLW2pgSWCJleX4n2S2MKMi5nygZnYTumInIQS+kgjIWxDtZ7ONEmusoxvZcKuOUtc1vnxt/bvvTeewiE/s33dBri1vnp8dO/10iHzteuHYt1hH+dQ142DflqJ0kTcm5d//eMk3ZY9N/r8eGmDRSA2nl4OZ9rJ8BZ0epumgWKZ+RRBaaSMPgXSLzcCyWrK810pC1oZVWPkzxYaakj1mNFY0PdcudcXcCZV2XUSyehktKcu3IMfZnHYZ6RjYNRfQ+sW6BMPWYadSCnwFrRCR9LmoNjmdJ1SkiP9/LclP6d6lmwVrp4aqcyRous8swS3S5OuGbuSxT69t6un0FyG/T39DFZ2aCjRz2uhOupka6hczoC/DcFenj+1gqsa6z0bWgaYf1750uuV69tpjhFc0kbyDGkvt8XBv0GochFE+M0WAh3ojo4IQbR1I8x1vPWaQFyHNbPPgWB+B7Z//o5qx31yrlRXRBALV0LISDMbwmnNbK2FjAiMrNoVYhCoMwj/kjUC0iTHM7DVBq/GVVLT6NPZGVd4s1nZ/06o3LN+9BzQI8R7/ca9Y1JkLwF/SpVbQoJgwWaxosqoF20HXRajeTjDCAWQ8R13RhRu41R7u3lMmLTiJ0z1sJZJ506vUWOGTEuAlDORliTEGPAPE+lu65FCDOmyWLKE6ZJUCJrHKaJnUJ9vWdCzhfuittsBP2AlCAjA/mdDra3tu9yAj5//ozddgNnLdpmUWoiEkBojRMHxbN0zsNYi/EyYJojTucLQpRqgAwDOC/QiWsKgiCwh/GNSLbO8coB+JIjcAXlvOMIrLf3olQaT/19YCFN3Tq+XpCYf9RRz7okiAspfy+L36KDfcuY6n9zIdU5t1uf+9K1cvNd+6Y98Ne+y781wYnjt0ZpeO80FG5tkZNFVPfWLBG/MUL8ahrsdnd1XGOMOJ5PGIYBv//+p8CEXXt1r7iYbnc77Pd79H2P19cDLhdhZZ/PZ4QkNeWbzaYacH3/X19fK/zOCIXHZz6aLGc6Gh8/foRzri763BclcV9fX9FYj67p6li0TYu2bWr09PT0hMvlUsVpfvnll4o8hCD5ZjooXdfh7u4Ou90W9w93V3MDQF2wFyNrrq6RbGzeLw0nE30gw5vvsw0sy7d0JLw27LznrLff7XaVV6BhbDbk4RjwfZLyxnHE6XTCb7/9Vo07KxDatsXj46NUIeSMX375BdM04b/+1/8qXQb7LR4ePtQFf7uRvDOhfRoUlvgxx344vFbC5oePH+CsR9f22O/uZH2zHpvtri7Sfd/jX//1f0EIcj3DMOD1VeRcP3/+XNcGjj0RDEbDvOYff/yxcidyFrVCIit8Ls7nM15fX7HZbPDTTz/VFIUgFBPGYcI8SR4/xgxfyGfM5x8OB6kO6Hpst33pvbBB32/QdGJ4gJKaiAlhFr4G6+hlfomDvvEtnPVofAskSUHo9AdRFc6B0+lU5xd5JL/88gucczVtwTmkCaFMu+zKM010hahOCCNgAO9JmBRindbLsNag2xSypxHFwufnZ7wW2V2u1U0sVTFYemmII94hRWknPk8BT5+f0ZoOxjygaVv0m42ks61FGiakWfL6bevh3QRrMqbhguF8gTMGxjrM04gQxMEN84Tz6YA4OzRtgPc7AC2GccDn5wv6Hmhbg59+/oC7+y260QBhQuesBFTzeHN9v7nmf/Mn32ymeofkW+aSn2WUIbmjUnpVmKY+iwxrRoTNhTwILkiQWu/MVsL04N5uawO/NsK34G4Ab77zHmSvjch7BnONCOjX/9FUwHvH+RYUg+9rB+lbnID1v/MNzsO3fF9Du2uHjJ9bItZ0nRM016kb+XmLAOkxJ9zJ/CM5+IxCar1wWljFsoDEGll3fVcEhcTxEFiTAyoM3xAjhnGEORzReHcVqe92u9pmNlMZEEAMoZKyUJxC5suFSGtq3poRgrGMyHU/gSVnqZXlAMlLM9qtMr4qmuackH0K/4EL4WQL6a40XcrZA6VWHEX+W2RTZRGNUforxOIMoG1wuZxLGZPIK4dZ2hN750r6Ro7fNIuuvdzXhTuzTgdo57BCzer9dWqM91uzx/kej0lHZRiGWuKn8+ZLMPMWZaM2AMey8U11FhiFD8MAg+v5eT5friJcRq10uHSTH5Ii2SCH/AFKKWtRJf2csbSSzmmFtMtcn+eFh9C2LWywtS8IHXOJTF3RB2iroyfnZAq/hM2mxFCHGGFq9npqNAABAABJREFU/fx1lQTPD+oerZ9ZTV7V913zL3R5KtcDzdHSTsWiD1Bab/ceVAs0MMie3A9JieXMiHkJyuiAMQjQOgnGkO+wXAPXp8L2Lc5uwOvhiG3oYR1Fygr/JmWpUpoDxmnCVISInBNxIWs8vJc1CGDFQMn6Z1X9k1BK7F1FXgzYrVcqA7KhRf627buJgc7YUglAw10WcBgs3CMrJ+MMYKVjmnUObQKsS4jJwsWIPM6IOWMq6YGYJB0QlAPA9rL6AfhSOkD/8L1vMfR6X3xt/b7+fev99b/Xx7oNj377pq/rvY0Pzvp7X/qtPxdzpjf31e/dQk6+5ATw/IClIQiNgTMC2xMepL5/hUlXDoCQ4KQ1KjJwf3+PEAMupee6PNAJ3jeYQ4Ar5WBSQy79A3a7nfThLuQ9idglvcBxjBnIc8Q4nfF6OInet10Y8I+Pj/jhhx9qpPr0+bPk5c8STcAIRNy1TdmnRfYOTeMxDVITz0VXJEYXVEhzAnLO9W8x/BY///xzNQR0fHLONYrSERS7pYUQClwYy+JfGsQ0HsgZjXdIVvTIvXcwEM31aZow5DMAGestthgHOS73QUSg6xrk7BHCUtPP2uq58BkYCeuFXxtuLr6LCtyCWDByBHSfh+VzuvyQzO2UEp6envD8/FxhcW30tLHRTsc4jnh5ean3aLPZ4PHxsUaOz8/PVzr2nJ+//fZbnee5OIGPj49VNXC32+F0OtUyQeojvLy8VCfg8+fP6HuJzunMEG3Vssysx2+apqaHqEHgvYcvJYrS9GoGSiQtc1jKA/f7femQuK/jcin76roejRdHout7hBgQIh30AnF7kQjmvq0BWreUgtLor0v81qkjLY3NOcV5vZTcpoo6aQif8P1me1/SKGySBeSUMU0Ld8ZaW0v1mqap1Qdd12FXunh6tR5xTQwhwtryrKkg1RiDYRzx7//xjIeHO8C2aNoWTddiDqJCOk3iUB6PB5xOA4CEthWVRmcb9J2gbM5kRJNhbKrpdtF6mGGdQdOK/XXOA1nsroWBL70OklnW8G/Zvk8nwKwjMTmYoP5v6+lNcQZcqbluWgsbE2Iuv42T7mvTLN5NERPimJfdX+XD6TFqdjHPZw1F6sj5Swb3lmHWE/OW4b11Lt9qpPW/1z/Ltkyw9/Z5yxh/KVXy3nfqZyBR37dPn7fHeM8R47mt7091FCC8gKW2W+79+nrIfOeD6b0XL5uolLmGuWOUJkH08rmwGGMroW9KESFGpONJegKEAGOXKIRR4zRNpVbYYtPLgvzy8oKcMz48PooRdAt0zYUr5yyNQ1JhGRug8R62t/C2qZG8lNcujhMjRza9YSQt5VNLuoQGVZeIchFb2PSSI61OmLmOCLmokpDHbc1t4Ws6dUDGdl2I1RqhI7qmaVY9HJbIkPdGixLxPnL8iY5Ya2s0rsd6HUnytc1mo1JVGTFOQGF1C/wfoPUZYpRc63a7w263x263L8aLWhOxdBa0lRNg7VJKKSWOw5WRYyMrRuUkk+l71Pd95XcAS1MdQVOaWmqn04x0dAiRMzqWCHnGftvV6DZGkWTnPkVMq4GvHIBrvYFQOmV27XKctmkw+EZYJeZawEueWRlPceotnEIV9T3nWOt0qCYK0lHQ6aelWiG/mRe6Ske6/wlyIXXzgqQRWdHrrCYrhhDQbTfYl/SQtbaiDCGE2hTvKsABw2GxV9OcMIwR52GCGQPM6VKDmuP5XJyAI06nC4AGznlsNh2sbZBzKPLGpZFU4QoYQDqspgQDD28LJ6Xr0TQ9nG+k/D5KI7aUS3D+jdv3IQFqMRbYraIhRTZYDbAp2gFG4H/nPIwrlQI+oUkJ2Yk8cMgDcohIcSq6AaYYwPymZp0Puc7Xr42//je3L0X1V+d9Y9PRqzZsGqK8dZw1qvAtSIA8oMBCrvxyDn/9+n8GCUg5I+TF6/3eTY/5LadIj9fa2YopIaimPuw8WRcZLIsD98HoOCch3nBR5NjTmbDzLGqCSo++bTtsNhtYa/F8PGKYJlyGEUgJc4xwuciHlv0wR0wDAwiU+ttvv+HPP//E/+//+7/h8fFRnIQSXRpjCpQfcSq8gmEYYAH0bQPbeZi9r2MxTgPmeSkZ2+12JVKVRZ5Rz6dPn8rYLgspo1tTxrTv+6v67HkeqyGU1RqAWpCJHjDPyxI3rQ3AjQsuERmmGLTB18Qu/rvrOviU4J0rDZiWZj3awHOeaD4CW9ySKLff75d5q7g2dCjolIQQSrtcg8uFipGnghgkhJAwjlMdX843UTTcYxjGyh85Ho8Yx0V0h+coa9IyJ1LKOJ3OKt/t0Pcy37QTQAifaR8iFuSXECU4n89omqaUqC5a+Twez5lcBqIA0zTh8V5y/G3bIqYEfzojlGi8ppvaFl3Xw/slpQAA0zhjGiekzbaOSYwJzTgBSmiKz3AqyO04TvDWwGWRm9bICu8RX6PTp/UPyMsgTyfGWOF6jR7RAdBoDp0VX9A2ay1sIXmSN6ADC+6b+2ybFg8PD3UOnU4nIWSGUFuEqwWNkQoAgxSBy5hgfUB7GCrxz1hBMo9HuS9Pz084HS94uP+Irmtwf7eDdR7PT0dM04jhcpLURQ5AssIZgKB3Fg0a12DTbSvHqfUNTJiQiLZkYIrf3kn2H+gdoHLuQC0nM0YbOyvJCaYMcvlXqZv03gIxw/uElA2MnWFsRik0lNwuPQy8bcRzM4p95+e6VvRtlP8tBvpL0T0n1LcgAbfSCPpvTtCv2eBbx1g7HPr1W3/r1+t3IYwO5tbfd1Juiw6tr03ve43IvHk/pcpoJezr3FKHnVJCmmeEIExtY6REsKnyorIgbkvDEYmMrg0NFwhhUW8WRv/5fHV9XKBCNSypNBZSkbRdWuEK6/tc877ee9ztd2h8UxaxAJOlJIn5X5kzBsiuat6HEOoCToMnpU27mn6ggI4YuIhF54CRt4XzS9S5RDoyDnQMxssFKS7Xw8iZizqPx8WW1RA0qiRP3oreuJ/NRqRL+f3L5VJLNU1xFjXxj9E9v6Pz9VoNUC/kNPZ8nd/ROXXOy/1+X+ebJonxcxpF4PVvt1t8/PixEjCHYcDT01PtAshjMWrnmtN1Xf2Odug1ssT6fjpyDw8PMMZU8hwJoTwnvZZVprk6/jzPOBwOVROAyEfOQN+LcJN14jCeTqclx67u3aIxIa/rcmHKcDfeXz3X8xxgQoQJiyJiNICJct2chzx3zf2hU8TnhuPB8+GzoXskcH5qp57CVLLfhHmehBNgAN+2wm+xApu7MpecsUgpIoTFuQgxlAoIIr25oEdJ9EOyXrONIOFJIu85J5xTREwjEg4FSZlw/3CPu7sN9nce/WaLp+dXnM8XzEF4AafTK4xxOJ9P4nSeD8U5tMhJiPc8joGFsw28b9H4FhYOOYngmSlrV4jA9LZv3rvbdxMD1xE3klT1yyQp3qHzMEZO3pTJZHLpvAYL5wAY5QQ4J50HKRtsINhwGeh/1AlYQ6Ta6GoP9pYj8F4Uy/3oTcOq7zkP2nisv/vWSPPf792Fb0cG1ps24LdQBGPMG4GmW99/7z39gK9TNu9tOUsb37SChbuur1rowzQhzKESriQP6cQJsAY2i7ftfQM/s9f7cJUvX4zNprLJM94SErnQzGHpxaC5KTRczi0G/HQ6Qoun3BcvnZ3emJJgtCkGFogROJeokaVvPA47wkk5WlehYoH/qdq5lAw652Cdhfe2RprcL3upswPdS0wI89IEiMb8liIf88+n0wmXUn+8OCkL+VJr32uiGA3L+XwuzU02V/PQOVejY94HjpWeD3q7SUYrc1BDufqe3d3ta8TOa8o512vidTNlxFI/Y0xls9Mw896wOc5a+pdIECVoeV0afpbeApvq9H748KGUsC4iR3r90uWBayEeVgnQCeA1x2LENpstnHfwipCo1wGO97J2ZrRdh6ZwMGR/kj5omgYZiyM1jXKucKr8Dxlpku9pNUg9t245AbxOjqd2IBmx01ngnCHHgmMzjqLWKEiAEFOTE2JsNqjImoXBPE/XTsAcCspDmeTiBISEGBKQl/JWA0hOHkAqqew5RumcObE99oh+s0fX79BvxEFp/+NvMM5gmkfEGGCPLzDG4nK+YBikKsAAsJsOSJLSMBBegzgBIgzUNh0MLKT4QVp7x5TFCQj/pHQAbwpyRiqLYq4PH5m9QEKEBdGBjDCMMGaGcQEwFhHiYY1jwDQHzJOQvOaSX4vSoQLG2P+0cM2XEIBvcQTe+33LgOrP3DqP987t1nt6+9J53DqmhuS/to+r11Akar/he7e+r52A9Xtf24dzDt4sTWMI8ekmNVxgKvHPu6odsNvuhMELFKa/GguZiDWiOB4PtQwtAzidLxjGSfKcVnpxW2MUmz0DOSGnZQGgcWQud5okCtOwOaM1aw12uw2myeN8ThiHEc9Pn4vWZlObyVB4hgv08XgszoIclwZcjMRUoh2BTPls5lIfnbMQBJ+enkppmalkwq7r0LctojXwTSNKhUy5AKWpCq8jwzuBJG1x05FEXtXkXCFXANKWODuYXNI5cgMwjyNSCEhhxtR1iCqvqp9FHe1ybqx5Amwtu85fEyHRKQn+tG2LRS5aWgczbUCSHe8jYWM6BnRq2J53vT7otsLMO2ukQvQiPDYbId8JAW979cP6f7a3pgFkeeD9/T2A6wZNAOqxAOD19RUvLy+1eRId8GG4wMBIKgEebbOU0Mr5jnBTQAhah0R+Ux57QSeJtriSSpH+FXS0jV8qLFJOmNOMaXJX90bfZ70OaOIgDb1+7nXaifeq7/vqSMkzKFyPVO4F01C8r7xmOlhI15U01loMoyA9dKKJysxhRgxLQzoJllBR05SkKsi6DUKKmE4BcxglDZcMmmaDvm/gGou7uztpkpUAYyx2+x4GFtM4IgQD8XcNmsYVcqMQA8dxxOXscDo6tK0DckLKATlFSCtfFPJnwF///hnfun23E5AModvrGnAAcE6iVwcRUrBl8Q1BWP/WJcA4EQfKEI3kEIuQRUQojPCYchGw0L0Kv3/TRklH4l9zBPh5bey/1Zi9Z9DXMPiXNm3Tv9UB0Oego4evfXb9d0rpjeN1axzeu/a1E7Deh/7RY+wUDMuFm+Q2Ywrslq+77Nlo4Uvk2jRtFfbgwy6LRyH95Vxr/U+nMygWBGNwGUapMoCQpZqmFUPoXTluLnDcslDm4gSwlGgOEm0TJibCUI1X38Mag2kccI4BT0+fYYyHc33VAuACTij0crlUdrQxphr7h4cHhDBjGC4Vsq7QaZgxz2Pt5Pf6+orPnz8X/QGJpiX6ahANKqOf908bZN43awwsgJxEghY5YxoHMfrIFT3w1sK4DBRBISvhC8I8IQaDeTJoo8ip8li83++hcExTAKjXSgSA95jGEbgW3+J1VD378uhtt9t6DI41+yEwp85onJ9jTp5GmudJlINrIRXsOK4SsTZVQ58Gi2WLRD/ojGitBVYk/PTTTzDG1GiYz4DOZROpoRPJbRpFcIYOl/fSMc8ai5AjpnGGsQFzpIN73bpZ5gFJf1Bj6yQKTqWVcE6w8boUlOeppZs5v7Szp50A3g99DtyXTjURBaAyI1EvTdyzVuSrqevB+8RAlsFENepG5Hpf5pfqcBO5iSq1WNdwNWcFaTSwrkOYRwyXAXOYMc0TUjLwvsVmu0XXN9hud9j0PVKULobbbQfA4vjqMDsDiSNM6TQoKY2UIqYxYRgcziePppHKnXEaEMIEYxoAS1ro90/PN9fhW9t3OgEZsEIquhUNc8sZQAKSFSUtYVgmwM7IxiIkIS8MU8AcE87DJOJBsxC5RGY4CYcASYgR7xhtuRe34XguMvr1WwZ/vQhy07nG97ZbzsH6PPS+30MQvmX7Vmj91me/NaIPKw/9S59dv7ZWPVtv+gHVf+dcGkuZpcxtHCdQ+58LAiVSdZ2x7CeXhy1jnMa68HDxNlYQJS6y4zhXg+JK3ttaqRYAFva7L05AShHzPGEcRMxjniYAS0QhJCsHb6VrWwozLuezdNzMJQKJS+fClBKOxyOmKWEcY2E+B8CgwqJc3OV8pXyJhCVGKJ8+/fFmvMWoLmxyloIZg8pQt9ZirrXK14TXNUufzHLqIZBkpyFwbSy5QOtnUpMNh8uAKcQK55IIx/w5o+JamoUlB06HSubHePUex23tQGoCHAqjXYsU6fI+NgGidC2jfO2sENrW5EMAuLu7K9yQU0018LwAYLvdVIdF8weGYahtip+fn6tYkjGmpiI4riSy0lGh3DGNGJGD7XZb2/6O04ScUZ2Tpu0QQwm2QizS2Qa+bdC2Hdp20VaQ+7iUgy8OPIC8IBOM0H0Z8+12ixwDol3KJvWmI3KeJ6+R1Snk66zTFJyv7Oex3+8rYsjnZrPtkXOD+4d7bDY97u72NbVUZaBjxDzNdbxoWy7nC47H4xuHVI8znSW5jggib8Z6dJstYC4YLtJgD0iYAnAeZzTTDDig6Rrs7nboS7XF/+e//G+w1qHzDY6HI6yRFETDTpZGOp2Oc5CWeylgnkacDgeczydM0wi3uYfxbSWE/ttvTzfX4Fvb93ECMkrDlrebXogyStPXLP+OoeR4IJH9XAQPhjlW4x9LfXbOQMrSPwBmTTh8H7a/FWlzgVi/t/69Rgu4T22kvml43vncrfN8d+wyofXbnIBvdQRuOQFfQwRSiXbTO5/7EoKgr+U9J+A9AmXOpTzxCs0IdV/Oifa/NyKsIVKdc/1ezqnOsfP5XOFDipsIBWXJe4aQ6rxomha5PNA0kPwt5YcJMc6YZyEqjsMAZCn54zmmJG2MkzHCbSkogUiSLux4YCHSsYzs5eVcx2KzFd1zPU4s1SJRTrd7fX4WgR+9OWtrJQSAyjiXhieoucwQ6XxcN+rhPdROgZZcZuRqjKld+mjcNBQv93CRhK2wckqIBV7ngsp6bDpva+dbO/88V92QRyMuOg2gUQ2JKgFjlnw/BaXIvmeJHoCr89bkRc2B0A4tBZ04H+gE8Hs64tXGe5omHA4HHA6HigbxHHivdR6cThOjaW2ceH40sJWLgsWYOt9UsmAqcLgp/We1LDWJudoBWB5YFGRAlfsBIpdbHKUcLeaixHlrPeCc4XOsCY58FnkP1sgm5xjPk6kD3u+2aQETsdn02PQ92m4h4wJYUopFbZJOK50A0UZYWkfr61+CUSckapOQazWbg/N9QbwbwETAzIjJYJoT5hDhQ+Gc9B322w02fY+ff/kR3nk8Pz3DO4vL5YIYIkwuLcktEIIQiycLWCvIwDyNOB7lGfR3HrZdOlM+vZ7ejPl723c5AcaaQqzJNw1bfVitA6yoTMEUBneRAI4pC/yfpFtbTKUBkRH5zQwUkqAp0eF19H8LCVgbFg0335qAa6OmUxr6M/RQ6/V/R9R+6/O3zueLaMpXP3PbOP+jm0HpxLU6xvc4AYyqgfedKg3j8t/WQIz1jfFJJUqAtei6BaaMMWKcJXI8HA6Yw4xjIdblnN9A3dxfCHPN/caU0OzupE+FioKXxTshxYWFnmJEDDOQpdXVbidtcbebDdrGY1MUCIfiLFiDymJm85rddov9bov/+//+G/73//p/1CqGzWaDu7sF6WDJ1/PzCwBUMiMg0fXh8ApCzxxP7x1842rO1DmH+/t7DMMFIcw1+mybBo0TARvdA4ALoobhdXqABolIgCYQ8nXt6Oh9UG0uhHC1wHKxJwQv17GUvvG+kf3Obnhd1+Hx8bGOLT9DJ4EGlca56zblWh3Y10S4STNE4veA00nkdqUM8a6Q4dyV7oIxZPBHsOW1/Dtju91DmN4iWvX09IJpmuG9rYaZ85HXRmlhRvtDEbwi1+Hp6alG5xqS1qWbzH3rMkvnHMIk/IwQROeg7eR+UHSJqZymyAlroSYN04uRdrB2Md5EgkToyuHx4QO6vseHD49IYcJ0XpQ1OSd43VwHCNNrREevk7xWoiA6t8/1RDfQijHCuEWMbJpnHF4PRUDphMtluEKaiHQRITCQ54nPT7UtkecqAkm2cGiSFVa+rCsRh8OEeY4I2cE1G+y6Fs53CDFjDglNiFWcqS8pOhHmsvj5px+w325gkDFPM8Zhql0MrTUwSFLO2Qqnp2s98ibDuxap3yP6Hmk2iMFixkLG/Nr2fU6AoQTp+yx3Y4w4ALbovxspyUCiCFCqUV/KpRwQUu5lmXuyqZYVfgkF+FpUvd6+xYjxdW20uN/3It/3xuq9z7yHDNza/9cM/a33v3ROPKb+vXygROtf2P/XxvBryIl22LRTYIy5aiJ0dX8lhCsLxTL/2LkspYwpTZjnJQ0AoEZOBU6q5yBCGiWPbAw8S1JX90yOf3veWWuQS2Te9z02200xrEu+OsSIVB9iWxc5ETIxOJ4GdF0Pa2VBZY5Ty9pK5DhWslqt4Z5EDMYqUSNZGA1SkusgwVKe1YxpKmpz5frsCjrXTgAXWh0Na8Olo3gdrepcLueXhlGxeqaWe5KuFmd9DM6bGGOFwak7L53h3NVneDy9ryWSl+g2l3mzGA+DYRhrcykxiO0VEnId1U5Xc526AcxNc+6N4wjvbTXyWlWQP+SC0AHV6wP3ocm+2rHSwZGuaiCqkWPA0hhquRdEXxbEZEm3LAY4A+aavEmytjbCzjl4lt5uNthstojBw6a53tNb67ZeUyrjXr2vkVqOq3YO+KMdkpwznElVeGyepAX2OIw1X56SqP3xGE3TXHEXiLpwXuecMVdCoApCsdgojtc8J4QolW7GWvhG+uKEUPhJYWmn7T3bMIuR3243sMZgv99iGieYvGhdABa5lGe2vpE+I42gOtY6XHyL6Bpk45GNL9T8b9u+ywnwZaLobX3DZDE3gKExMWj7HsY6nC4jpjlgTAYmRMRsSp9miwwDDyeyweXhjCnBIcDgrbzkerJUQ1Imeb155cau4Wf+vgVNc7vl6Kz/XhtyvZ+vOSnvORZf2772HY7N2jH4+vdk0r7nmHzNISBp6j0UZo0AaCSg6VrsFNO3aVp431RDOM5cUFKJ3iT3f7qcYa3DbruHdw7bzRYpLwQiyqTSwIuBEuMsrHkHdD18TLiUOdQoVjlyRs6xRgphnhHmCdag5rX7vkdf9AxyuX4Rm9nil19+rrXPQMY4XGCM9Bz413/9VxjT4XA44OXlBQ8P99jf7XC5XOq8ZVkgSWeMcJfWwE1ttxpjxDSPeH091bwmx3eapBzJey+E3RCuyJi8Z9qg8jdZ2ISUn5+fcTqdKjKx3+/rokmHQd9zqq6N4wjvPLoOFYbVeX7tdNMpWefReU5iXP2VoecxdGqAfIacgctFoveXlxfEGCv8/vz8jJwzXl5eqkywTguRob/b7Wp74ioiU4zc77//Duccfv7555qnPhwO+B//438gBDnWMg9k43jSsWMbZN5nji+jY36WxoxjQYeHaBJb7eaccbJj0YO4biRljEDu0pEOpbzW1/OapglN28GXTosLEiBomE4l8ZiPHz6g73vc398jziNGuyAyXGetmnO61p/CN0w3abVEog2UWeZaQ7SI95GbbyKsQ224lFPCNE747bffwKoLXQads7Rr/tvf/oaH+wc8PjyKNHbh1IgzEQCE63Vt7bBYB+tbuBJYWBMBRBwOZ+Q043LpsNs1sJhFjhsJIQdM0ygCYpsG1gL7/Raj90iB5EUH5BbYZOz3O9zf7bG/22O3Ew2SmCL+26cL/jzPmKLBEIDz+E8SCxJ4/y3UC6jMZEbN0+bymcaa0kzBwiUpe8jIaJJDzBmmOAEmW9FqNyLWkCE8xO8pEVhHue8Z/FsOAF+v+yqQT/nrzbFyefW906vv5yXIzKsP5Po78wTKdeDqN49vzNJoCXlxgDKy1JHa64hWf9tYW08g4/raGfVaJ/rf7zlAOoqvOy4XseTuTLG7+kFbxoMPjzEW1jGibOCbFr5p0bQd2MpUmkkBOc9Sh1tEb6ZZyHQhRKlKAQBr4BoPWxCCzHwmz7sOqJw0KyHCPEv6qbThTVbmakpRpJNSgWZHtv1MJf8p7GNnl6ZARR8Fvix0FPwZx6kMgEQTzjnsthv89NMPaFsh8+12W2y2GxiTMY4WXdci5wTnSi+OFBGRMAyX2pzIe6eahliYGchJWiqnnGSxM9LQKMZQ1T1zCIjG4DIMJTpWTkCWEi9gqfAxJA8ag2mecS6VC5wzTgnXaK0BLRIjJYwGLgthOOdcnyppsKIQACI/Kx5J5RqVe8zFPKVUUjWl97gTopor9xJgSV1EiFLJASQASdo5x4R5FgKozG0RXrLW1Vy3XJetDpcYCOFbDMMoHBDnKopARMHYBVUZpwnOCuubDg7Ks8kovmmamgJbnCpTnFeR5ZXIt4hDOSdllzHWe8X0wXCZkZNEmtI5UsawbRrktEhRgz1hci7y1hHIqdSoZxknlBa9iECWZ8NaKQ2VCFUiVWct4FyZF4uTmbPwvmxS/Swcx9bXHD9KFJ/LumatQde1CGFGV/L7JOhO44BxHDCNQ+kvAsAk2IwSQQsnbZ5mjOOAnJUWBpZ7IEhAkDW0NEyiailgyjWUNVSjhsbUNbcihHBwWdLm2UTMIeAyRDRNQsaMrjHwFsXpskgJYgfVesWliqW9sr4Afdui7zts+x67zRYpRwmWnwNSCpjmJKX34z+plfDoWtimKwt5IZFF8U7DLJFJiks9rimDtSkM5Vgg/t3GIyWP7aZBTMAUJOqfQkCICeMUkExCQBDjoYz1e1UAt6LcSu5awVc64uD3uQAuEKSpUsj1s8Xgic0r56P+XQ05IA9VlVHKyPHa+ZBXl//rr4pLtJBlvKcXXnLThMDnSdp7hoBYFgfnPfZFlzyEKF3irEVDAoxzMNbJA5YzrJPJ3ncdYIDX51fknHF/f38VUfX9BuxmRe+e0ZrkypMYjgyEIkyjc8I6Ijyfz+LAWFPbwIaYMIaA3DSYXYNoHCwsom0QnUPwGQEOQ4oIIWOI0pQjNx2SsbhEkaNtu36B8rK0P6WWOnkoxllYL0bYGIPx9FLHwxiDucDaoW3LHA81+vHeo20abLsW202P1gEmTkhzRkwOjffwjUPXOXSNRZoHxAk4vL6g73v8+uuvwke4XLDftthvG/z0Q4/h8iDPT054sSMubob5cYsQWnz4sEPXteg6IIYZ0+VJFsB5Qhg32PdWhJN8g/3GYb+5rzXnd3d32Gw2+Pz5E87nC+72e1jv8R+/P+EyTTh/foFzFrvtHk3jsStzJ4YZ1llY3+A8B7yeP+PDhw/48OEDxhBgvMfd/QO6rsVluOB4OUtTIu/x669/Qdc2aLtOFuAYYLxF07cYhxF4PSOOE14vl1p1ME1SoklpXYQEJKBzDTwMDhdBYVw2aK3DvuuxbXtsmgaIGcPhJATKaUayBsFY9A8tNm0nyEqYENILkp2wvRNeQNtsEeMdHn/scT5d8Ptvf2KePba7VnL7zpRxbTHNAc8vB6QE+KZHShbzDFjrYa3H/f1HtG2Lh0dpJmUANG2P82VECBNCHPH08oq//sff8MMPP+DHH34QX6WkKJxz+OXXf0Hfdfj09IT4+orj+QI/zeg2G3jfoO16zPGMp1K9EGPE44dH/PTjT0IuPB5hjAgEbXd7NG2H1+dPiOGEvr9D32UM5xd43+Ljh5/QugaH5wNyRnF2ABMz2tLEarfrsNl28DhhPg+YL2fEeUaDV8DP6HbSRtg7oGkS7CQR73kaEZEw5RHOO9x9vIczFs46vLy+4Hg4wnhJ+zpv4FsL31j4xgBmLlUWT0W4Z0bbtfjw4RFdu8PdrsXT8xP+/ve/AXlAjKJ82LUWTevE+e4kjfH50xPGUdaqlBKsE9W94/EAoIh9xYiUZMX95S//ijAH/PbHE8YZ2E+isNk2Pbb3rjpyOWcEFFG3RkolrRMHwTbFOUoNwhwxTRGIFnGyGJ4usC8ZrZfyv//yv/wFbb9DtneIyeLl6RMu5xP+9jdpk21SlGd6J2kCm4G+dWgAeGT4XDR1YoYZHPLJ4W//5x/4/Pkz/vp//v0Llvx6+74SQQC5wPwGqZL35DxKQw6lWbzkFmPJU5oSZUqkmGFhTEYocuYGGciiyiRajCLTeAvF1nnFWw7A90Dt17neJeeTC+pxdQIltF+QD4mO5FgrHoAx5bumRt5rBOJ2iiEBWVinyz4FEqlOEc9AfeT6apfxZnTgvIf10uKSx6ehJ1t7OEudctf1ygnxlSRDcgw9ai1Ny+taq6ctjpegSW27kI0E7txgnAOmDMA65LKQpZyKdoRwRHLhmGTD6hELlCg4xFi9dF4rYkSNY7KUP4YY4VDyqSUaSSPb/pb8JzKytUhOIiNTSIDWSNTjvRh7iXrKXE5S+2IagdtlmkjVAiAOszQAWe6otdLz3JgWjV9qfLvWI6cGKYqM7m7bV+g8mIy+a2CNtCFtWw9jxGnMWToDeu+RYkBwVlofe0ErnDVoWyGAdb04T/M8I5d+8NZ5IfXmVHg9Es3FWAi9MWKaZ0HoLPPjBjFJh7ocF10PRs85CzplklkifEB6sU8TGt/Au4Vwhyy6BKxSMUbKKzl+WYhFsMaWa1rSF4bIRZaxr5hPQQlSmpHyjMZ5eG/QbySnOodeUJ8CdIreRNEAgIU1ETFmGBMWvkbUpLalAqEGQMV5FxEbIFzGK0c4KjKygG9UW3Vo2w5d11eeQJ0xZZ2JhY1Poax+s8GlcA4yCpnO2iKmJV30GMBybbHlnJtSLQDBZso8FwTGWgNrMnIKiCEi5wKJI8KaBDhBSr230sEuCxqRckBCRDDSiCvnDCyVhmVZKmuuVT+EecrzQklf4QHFEjT42gaY5Fzp6imdMKWSKCAjI8YZIUwF3SnoMKS/gTHL3JpDECerbREKi3+aZ4zjhLbt4Jwv6425ugdEz3JOgnAYU9ASSJCMhacj1W+CpuQk0b/YRIcMi5QNxilgGCecL4L0eUNNhoIREOEs/V1yFvQsBtF7GC8TzscLToczxuG6EdiXtu8XCyLRxpSTwbVB1jkTTSbigrFci9Rfx1jKoJjrCtIycSGUuJqC0Nst43lrWxtcRvxvofDl8/xtSn/nNZGF39Fph7XTwUVhXe60RiE4Tnqs4jwiTEuNsu7SlnNGqs7UktuTB3/JrwJLgw9dNtW2Lbwqq9GG3kB4H8io2vCaiaxz/XQMmI8GUPOk9JYJu9G4UcmMrHWynXl9/HzO+eo7Uspl62c0EY6LMklzmi1NmI9938k+1zXw1lp5kArjmdfM0qPGe2wKBKlzml1h9lY0JEwIIS/OVMmDdk0Drwh6T09Py3imjHmOYJtdniPPncIxHz58qOSllFJVrmPdM7Xiz+dzvSeaZKdV6ES2d4v/dfeAkICXlxcgA/v9Dgbk0qQKM3ddB+8crJGOib/99vey2IkzP81+qbVnSaZbUgNMK6UYMY0j5inUczoejxiGAa+vr3h4eKhziTl/kr40afB0OtU1aCFayr2kzgCJYhoBTKWsNOQZm80ObKErBuFcORfjOOF8GnC5jBiGSa7FerCsjmvY4SAtfzebzbKezBnPz09VjCmEgO12AyDheJKx//jxY+2RwPPse3HyyEn44Ycf8Pj4eEVyzDnXZ4H35e7uDg8PD3h4eMDlcsHLy0u9zzJfE3a7DVqPolmRxeny0rHSWovHx0eM4ygcEss21nKN8zwh5QltW8Rp7HUZYk6yDsocUYTGkhocwrA03jKSOuMzyMCjyh+vArGudOkcRkFxDodDdfxSioVzs8P9/X0lttZ5evqEYboUoudY56e1nna0Pj/OUxODDoRcA/UKakmmosLlYoizang2z5OQI3ep2IxcVD1nSPjsYE1e4kIwrZqLmBlwGQccT2f8+ekJOSXs+hYpAbvdHXIMCOMkhHnr0HYzfBdxPkrFw3/8x9/xb39/xR9//FHbUX/r9t1iQWIUmGe9NoxXHt6V8Uf1wqAGIJdoT0eN6x9jzRWJ43u3tcFdExnf/Y6RagV84XP/yKYdijW5cTmna1KdzsOnlJCt9GDQOcOcAetiJTTlgtDwPmjDR2KOZuQCqKxf5EXvXRtgYHEE9fnoc+R1AYt4EPd1xSYukH1d3DKjOZScoNTHT+OIEINwBKz0C3clykqJTp1E7N4LHMgcWiq3TxYYjoWp+XsDeU+cqGUcNEt6nePW94oL8nupKHIFdKqJQjDMO8NI21oyrwGR7GVZV6J2RqI2Agpp0qHr+mL0JAXn/STcikK6okFmiRtRHGuMLNoFzUEG2qat1yTPZyHalogsxlDTQC0NSXmO6XiRsUwjUueHcqw5vleppOIUWGsrEVLrF+h6eK0XoB0N7Ujr+VjJpzm9QRR5T0l6435lvs6wdoSzEc6xjXCEr/dGjC2jZpilp4MUnSxVL9YaMVBti6Y4z33fY7QWk7VoSgQb5hmjMXUeD+NYoj55NmM5Jue0oATCaZlncYDaVgyqyEEDm00PZ3NFWYxbSMNiwNslxQpB6gQ5WHLcHFvvy/PnvKR5Ui4olPwnDhWkoU1OUt5WuEp8RtcBWblZ9T4bUzrEwpRjLfeWyE/V/+D9N9eB2sLXCAqlBIBUUCK95hL5Lc+tuVbLJNrjdVWAuW6JLki3pBUSx6Cgg9XOpQThA0mVXIqL2BL7S4zjVH+QE1rvMUdp/hVDRJhnNHOLEBPm0tDofBlwOJzw8vqK19cXXC5njNNYOD3ftn2fE1CjcwDWVCSAmzVSNsWH8TrHvmyZTRmSsL1J8JrnGSEu0Z0YIMC6t4b7VlT+pc/wPb1QXJ3TCqYHUIgmt1GCL/1+7xyBa3U2PanWCAqcuxo37RhZtyi5MSIX4papUQKdgDUS4poGTtUDc59k2z9/fkKKqTY24ZixdIznwgierFwunnxo9MLMz3OB3+12lbhEaVvjHKx3yIU0NY8DhsulRrmiwV56qnsH70SJzTpR9aOz0ratQKHWwgbA5FTg9Q7eGsS4LB5d6+G8x/0Pj7DWVhEXetE0EE0rxo0Rtgj9nGvNsUR+Ho1yqCTXvcFutxeyUDlHLfUqDnDEx4+UBM5lIZUFN8aEaZqLTkDG4SCtjH/99Ve0bYf7+4disGwROOnruForTbw2mx5tK38LylDgX5thshEo3pgaUS+Oj8P5dMKnP//E5XKuoiTjOMJti1NZHKTddovGN5UESR5OlbBl+AVxOrpm4W28vLzgcDgUcSWPy+VS9BLuaomWzsXe39/XxZddCvXzphdW3kdBGIPkbo1DChnJJpgs7c63/RZTH7DpeoQpIMwz4hwxDXMl+b28vOJ0PJd52FYD33UdetU6OoML9rg4PdZgv9/hw+Mjfv755+qIsyERA6ThcsFwOePjx4+wzuL15SI6FgUZGi5nUblDSXKlhPPxhPFywZ+//4GnT3/i4w8/YHPX4fHxAX3XoWsixuGE4+GClCIaIw5KCBO8b/HweA/nFoRKyI0GzgNd36DrfEUCNlspb71cRqSYcT6fgByRd7LWSL8FCwOPbDOMK4hvjCU1c+1kCwoXEQAhu6ZQHUo6ApTlvr+7q6kuYwzGcaiaGSFIOq/US+AyXDCMQ1XbnOepONJC+kO2yNnBGg9rlrQW0cvtdlnzSdz0TadSPsA8c80XZ95aC2SDFEtawNGBThC+ZkZCSUNkICeL0/kMaXAka9gff3zG4fCKl9djkS1vAOvwerogzjPGy4BkPHy/gx9mwIz469/+wO+//47//n/9Ff/22wuenj5L1Ur6JxEDa3TOyGplYJiD1sb2yuiWtSBf5beXlHvdr1kEJb4WuX8pomfEdcvYvpsCoEOR6Rn/Y0gAF6T3+ArL9d52Wm6x86tH7JvKxmbEJ8Qe+VtgVXkw16V4ZGVrOJ1OwDyX/uEpXd2/df0uv8t/84clU0QZKBdLkhphQK3zXg1L4+ENHY1r54fSpPp+ciHRzok+x1Ty74zkgUUgRbPYvXPY7/f1vFiLfgVFh4BcronHz+X92rvcCwTM8xXHoEPTCkmMBsl7X0VgjGoDHON13TVTLss4L6RYnebQ0Dh5A/p+sf0r0xG2RK25IAJtGRuBpmekJIiKQVfHneftvce+OHDee7SdQLld25XeBF2NzABUHQd9L2MICKXPKcvfOGd43rq2XI8Jv8N9aUEhplA4vhrh4lh0XQ/YiEr8TVTaEwGWzUYIis46pESxI7mEGIhGEEoW5KbxHk3boO87GAPMYVKoDZ+NVFqo+yojrDdeI59/pqLYXKg+myXVxvnPXhCCkBTxIKJ95bnd9D2cTbich+p4mhQLiiWd9ZiPX+aMqc5cdXCbIkbkHNqmwUjGf2mCg4IEAAnWCKs/GekIuyB/vpb5Ei3S61v9AdC0DXwS4Ss59qZeU1dIziz/Sykh5IXwLfyFhSNFxLoilYXdrddBOgk5X/erIF+Bx3al0iRGU4Iuye9bcmiMfL6ijRXsoM1LiKXaYpwm+MGjPZ2RU8LxdML5PFQEN8MgJmCcZlF+jAlzzAgp4zLOiOmMp+dX/Pn5BYfjEZfLua7n32O1vssJiInRuUGR9rk6mDGmEoL0Qs1BqDcjUbhCCYeUHLbLgPdL/pVceX0MrI753vYeErBGA3Senv/WD8W3btpI1puh9nELFdHnynOwWDTm62tWydl2QlbhYsHFv+02aNsWd3d3QCFtsr6dPxkCU3Ex4QLz+voqmufHc5W9XcO22jnTzh//Fj38qTK8afgY6V0ul2p8rbU4Ho84HA54fX1F23fYlP3pHgRaOY9GlzXmbdvi/v6+Lq7ssEZNcjowFJTheK3h/u2mr/clhICnpydcLhf8+eefdV86SrbWYi5VDtU47vfY7bb4/fffMc+zqAPu99huesSw9G/f7/e4XC54fX2trYaZz+acYZkYiWEaYdH5cr7GcyN6o3PxnB+MzumoTYWQdHd3V675Ux3ntm3x4fERU8mnOmfx8CD1048PDxVyJIy939+hbRp0nThkU9Fmz6XMi+cdY8Tryyt++/sf+OGHH/Drr7+i6zp8+PChXgPV8ohM0TEnUsHon04A5xMV5fSPToFlZDw8/gDrTWnXjALvG2w3eyBb/PjjTzDG4fOn1yrOZMwMY0bMRTSpaaQhEOfWZtths+lxf38HY4Dz+Vxy91Nx1hbxKqJ05LrQsOvcPxsVMWVwPB7x3/7bf1PnYyraw34FfOb2+32t2felVO/h4R4xdnh9PSDEgBBGRBNhjK/5b2OMEAhdSV14if6l6VGHrmvQNA4PD/doGo/Pn59KOZ04r5aVPGFWhjEh5LmqOYoQVldz9OPgIPUgS37ee4+mpMaa3fK8ee+x7Tc1NZFTxPl0rM8F9fIrf6iVdO4i51PW+SjG1xggWaY02ba4tE9uO7RNV50D7yyct2g7rh2cy4y0l6ZcQkBGcQAssg8IoeAflMVHRMyCpj+/HDCMEy7nE1KM+Ntvvwt/wXrAOyTjMKeM16NUU+UEjHPGMGcczwfEOeD/+P//FX/967/jt98PeD0uzaMMS9m+YfsuJ2DxpoDK4izvSc5pSaGv8ydlHOT75buV4G7MEhUZg6bkhZjrTvl9Q/wlp0DnrL+EBKz/bQyZoG9z+O/95mfeGze9j/Vx17+dNfDWXDkSdAK893CNQN464nBOhJa0CljKpkad/MlmyV9au0iZssyPKR2dD9OOyJrnoTcabMrYkpBDWLguyHnpq87Xm8LOXXMXeJ46x6vTRbqJDY9J5MMYU50FrTOu5wcgxsCWRaGORVq09BndM13APLc+R5hr9IcLvDNL5E4HhJE5iYUkvHERozgMCWM1DVTGoUZBKpJZorhrB5f3RKMf1jlcLjNiEq6FKUQMIgPeOYE1rcV+v6vRrvdC7DJWejiEEDBPsojN3iOlTYV4UVOF4uynJMqHMUWp2y+8j7no2zu/QdN45NzWQIPrhBg+RdwqTrrU519KzxFBsy7DgHEYME5jkTk38I0vTP0O1pvSnEpKTGNp1gKYimowNUNxoXke4ZxEsl3fYrPppb7dSuTN+nuZKxG5LPLGADC5VkJchqWNtRA5Tzifz9K0K6UiuuRKFC6pHCDj7k5SSpeL9JkIcQaQC/IkssbTJO2lu074IjBARoL3FtZ5+W0N5knOLSbJmQtzPi7ja7CsxeV5aFsHwME7j7bp0PcbbDZzceYzvG9grYdzIqNsjUOCpHmbhpwUV8mtVjmqfA522604kSUY3Gy7YlMWBn5OFjC5OlPy7FApkK20yxprrterFSilgj6uRZJjl+DW3vgc1wcea67HtdbCuiJ4FYggYKlWqfuRkxDzmcsxAwYI32OcZoQ5wBdUN2YgxyKyZCy885gTcDwPOJ9OOJ8v+Px8wOvxgqmsf1ccunTdc+G97bvTATqih1n8rAXyXyRCeQPkgctSYkgkoAyGKTeLT43LgEvL8UKQko1b29dQgW9NBxDm1XBveYK/Z3hubhqGWnME9DhxrIwxIr5ReBDsguacw263EzjUSTOUw+FQjZYwakeww5zwGdybHCnVHBlFVUUsMo99EYtJ14qLZPDT6BFi14aHkSS7mdH4szc7X6exJewusrvbGhXTWPHadZ5Qdwfk75RSie4WZ4URCFu4MrdIRj2jTYkkLldOhoZdgaXN6+l03ZRDIxJk1tMpOZ/PcNZiGlx1hIhyMIrzjUfXtVUxkGPJcSDznFE9HRyOGx2h2h8diyIcHU6O12azqeeacsanl98xzkEMBoowjmmwKaWgwlrvpP69GMfn52c8Pz/j4bGo5336jMvlglNRJ3woefzaWtiLXDG7MJ5K9Nb3LawFxmmoUVy/6dD1LZpWEAtBBARONhboN111IFMCYEQng3oV5070ABiJi9yxnMNmIxyE3V0P4wyGQXqup1hIazYiJaDremx3Ozw+PgIwOJ8vuFwGvL4e8Pj4iM12h7u7fTHW1N/whfMhKpQhSj62FNnARmBKM46nA5wXrgfP73w+1+vPOWN/t0O/6dC0Hk3rsdn22Gx7/OX4Fzw/P+Hp+bM4ECEh5Yh+s6R4nJdzWZ5HIV03nYeBESdunHA5nyE18kIgvFxOCCGVNIU4V0wFME0onQU9mqbFZrPFw8MjjHHYbj9hniM2my2McZjG4lBli5jEQey6Vpynoscf5hmzEaJk0zS4u9tju93gh4+isxCClBU+Pj7AGGAqnTv5PFnToCnIGwl5gsoYSE+QuUDzgDD+pUlUrsTQEsTWdECqQkHjOCEWed9aNdU4uKwrkUQP53K5VCfLWHGyUhLN/2wLA8IsEflVeFji3xDEIRPUa8bpIhVF9/sNYC3GkGFNRrAZbePRdRuMIeP8dMDvv/+OT58+4e9/+x1Pz6+4jNKJtXFLhdU/xQlYjOd7xnG51Jp/qcZ2cR5ScQSu0AAIU9MCgFvaZ6YcYFbaA+tzeu9cgev+4l+C97VRLi9csVm/9Tc37QDp9/k3j8PjarJM2zj0ja9QLnOwlCONGYjF8AGoXcemWXKiwjaVHJWOukVC10o/B7d0Q7siqs2KP6CgZj0+2gBppCWltJTrlNwsr9VaW3vB0+EiU15g1S22+70inwqk1rXtwq4Fqmcdgqh7HfOhQH8o41sIpyFgnqSl7/FwQNO0ksP27ARHR2+ROyaaQMMpxl0SUiklHA6HxaEr0SfTLZ+fPuP/Ye4/myRJkixB8AlSYMBBRGQkrK7unZme+RtH++/3PizRLdHS7Mw0qq7KzEDubkiRoPvAzKJiFpFVmXVUTWdJnh7ubqamJirK4PHjx5bXSozZvMyIgXqppaZdhEs4AKMpcmeczxe0TQPXNCSSslB9vgSIYKIq/6eVhm0sUgmEyNkKP8RZh9jIMCea+14zpfvNBpZHyXrvMVwudB3u7+GXGS8vL5imFilF3O33RY55WWYMlwti8Hg5vGAcBq6tA5lJkjIJsWm4+2NZEFiNrW073O27Mg9eAjLpDhADJteA9gu1n0oGWN/Ht/ySYRgK5Cz8AYBqzPkUAQ3M08zroKEQ2fAHBB+ADHRdj+0mYNxNCD5gGmdklqpOTHRsGnJGxlIdOAaPmIi8lxgJyClDIcFojY51NxLDtSLiRfwDzmIl8GZeguz7u/0eKRLPJMWE4H3RTiAzykPZCg8BUBuy0jGSfC0NqSGUgbJ1Xj+ehNn3HYTprlVVwq3sgNzXm80GMRJ0nrO/4qqkRMhH1hl915dSgCgJqmILicdAAWYDy0jENE9AyBguF0J7mDgeYyxEVPIlGyQuT4v+hl88FICAFc0TmH9FsClgkDKDtAbGWCFXSFCKNBakO2FFtEQuObJrFzsO5gktEIVPWZfVzvNzQcqG2lDGn2JGzgpK89TSTKULHzxI1MpAWyBCY5gGnE8XvP/4jA8fnnEeF566u3IYNCPpv/bx20YJlw/05/9eO8TrTHjdWOXn6njUy8pwhmRhKUOpVXr0+jz+cgAgxveXnn+bnQNMDLn5+18bBNSkPIFu5fl1gCLZvjEGfdugb1dmtIy13O12lOl7mo4lmRE5sYiMC22apoEQBcVgFkd/Q968uk4pUXsJ980LXFcHKvUNLzwD+d1t0CLHFQMi89oFlfDeF8XAru/RbzYYhoGifu4J7rueYLBqMJDKgJ8XeADD5VKOTSWQUJxrTSiUmrnwCKQer7XmyXE0o12uiwRd4Ih65E4FuZ6iEyCf//DyjJwTvv3226KzP45kIqyhSX5KKZzP57Ie80idEefzGefzmQmKhqfOLcC8lH0pCIEYE63VFclMgpjCB2gAQFX7LiN4CgRTzri7f0DMwL/8y7/Qmp/P6LoOX799i2We8eHDe7RNg3kcYZTGm9dvkGLEvEwIYYFWGp8+fSx9+0op+Hnm69lDhHKUUsgxwS8LkDM2fY9vvvkOABnJcRwLkiPITx08S2npcDjAWotXr15doSO1KuU4jjidTiXDrrksbWxxmYiwts4h0IWsHGMkgZUE7DY7ILED8hHjMCGnhGkYETxJR3dti65rAaRSiiC06IicE/8NUCrDWY3ddgNrHY2IVUQ0c8Yi2UjrM5P6Z44JyzwTXMwEx1ePj1AAuqZF9AFDIP3+xKI3KQJ+WTBPc0GiqGdeE0lOM8+ksTDOkBaUUYCiiZrONdiyTv48z9yNRc6QkN1V7584R3fQ2qLre9DAqrqUlhB8gu00trstttstcYQ4CBDbQWtDaFrf9SU4D4HvW7/wfbgmMiglPUImJBmhNk0KsKwxOAwHBC+BwBoMIAsBUrPQEukDUFmBA2YFABmKhbzkc5MtE6QvkKwybsnIEctMyJRW1CkgibDWIO6E0qXkYvkzxxiRQUGAQiKxzJSwzHQ/QDfQSWHJGofzhHfvPuBPP77Hu3ef4BwFNZkRB3OlFfPrHr8pCKizaVWyr8oJclRa1ymvMt5c+gLKc1LOiNxKzJ3TyDfscHn8pQ/2pdp8HQTUj9tj3aIEOZMK4m1A80vfvxQEFKfFMPDt3+X317WrlTApfxPnJdripJOFQpIahgFKeYzTXGWPGdqsWXhZnwrql/MowZIWo7iedz1DvWaeA7ga/RpjLOSsOqOueQ2rAhpKxiyfEUCBjcdpRIwE5/Z9h67vCB5mUamaj5ETRcwvh5fSO0067E3RGS+fVxFkeDwecL6ccTi8cGvlis5I0FIcTabasRxHAovMvfNS65/GAUDGd999V+qV1lggp6v7Ro5Tf0lgIsOTxBEKB6EuudTf5ZwLB6QKNKXuXAsQCQoDpQDbIOaMjx8+4HI5YxpH3N3doWkIov367ddYlgXn8xkvLy/YbHscjwdM48jjTVOZ6Cc1XtoHNBAlBsNZpC5CNcJveH5+xmazwW63w+vXr3nAD91DMjxJgou7uztorQs5s+/7wlqXUpYMMZI1lpKEkCrP5zOhZQbIitswoUo3g1JACGDejMc4EEQvRE5A4XQ6MsqwYBgGbMceSq0B/TSNmBcaV0sBW1+EaHJSiOEabaTrRWjSWk5buKNGlUA654SXlxecTkfKnBtXjZSmzyL3H4DSTUB1fgelOjQNlQesNdj0PSMBjhEjKkntdjssC+sScD3fOprzIuspjl7u3+ADlnnGRQ9AJtXOVNWw+66jLL/iTdQiOzHQ6ycmlRqj4RfSPDhNtA4S+CJnRlHYbilF7eScUMjnJjRoxDhTKcd7D78IwZSIfVLO7FmO2bkWxswQXojwh4SAKSUzsg1UZm3QcOcDXbtC3gXFEYaiDWqZV9wxoEGzGLR0HZAQXpmPAo0EGjmcEsvop4yECfMSMU4Bn54PeDqccZk8QgZ0FvL8iq4Q2vM3miKocFNXl1YL/nsW4kP19SVYQkoCJQjgjcNCjFcVlJrcV87jxtl/yfnL7z/Ldquv+rW3XAGp2aSbY/65AKA+Zk0sq5387ffPg491xGnbtmjbFpvNpjgWpRQRRrAGAaILcL4MZUNqnaEzruB8rTVSuJ7gJwiEQKcidSmfQzoPaqSivq7ibKQtzlpbDKjUsOUhwUHd3rdmdQTjL37BOA70/lqVz631yjlY0RQUgyJMfVmrtuvLOYvjLtnacCmfX2uNN2/elLWtrxcxkdcOCFk3+lwaIfhS6x+Gc+HDCHJD0sWhXOt6j9wGAcL3kDWU6yglE0GVSNN9exXYSQ1ePqd8UanhhPP5fNVOp7WBaboSBFD3xsSZmYNzFl+/fYunpyd8/PCBMq/G4HI+80jWuVyLEAIa1spPKZBQDthIMzIhbZxN0yBGcmrCjZDPIsHKspCTFb6L7BEpB4jGhJQMBLESHkVNLJU1u1wu9NmbVblUa5LcpTVcORfTNBd+iVKK9R62XJe+UDlkMBinHkpniAbEOA2sTDkwyY5KWdvdhmRiI7XQSSAsGSDdDxSIkCOjsogQ9bxPeHl5Lt0lpC6pqgCXCJc0/Crz+V0wjgOM0ej7B2y2RP601mCzoSAgRQWlJAigqYPjZOBZZpdQumtk77MgINBApJQuADRSNHxP0j1UBwHkxxOEJJq4/CIBatMS8TRwm/Lz8zNEsMgYA6s1UkuBT/E7KcEv9HwJACYOAoaJdDwIVSAVP+Fx0D5p0HWk+UAS6eQK6+6jOgFKKRR7odj511py3ntCeTKhf1qBkypTCKpliNNVEADERF8JROYWJHb2EUolLCFDqRkKI56fj/j0csIwL6AZhfQemZEJ+nwaMk781zz+Kk5AcVy3ifkN+7J2ijSBkFN+RgxSSqSpHCLN88pUG0mVYl4M6cqhyrHrc/oSpC//Fqf1pS85Vm385bNRXBWujv1bSgPCEi/te5z1XvVrA1fs9sJ89wumYWXny2vFofpIA5fEGIouABkkuRRrpl87cO0DdEUEFIe13++hlcI0jFBQ5WavyxfC5JdHreQGoBDthmEon61GHAT52Gw2ZZ2lpq55qI+Ix0irk6Agcj7iFOvef4H86/KPBCD1+cqNvdlsyh6QYwlnod47C0PYORIsu9vtSgkjBs9EJGnJQenYEMdkjSljjUvr3eNjMaYpJWy32xLs1cFUzrkY31qK+JboSsJF5EBPp1M598uFxgn/4Q9/wLt378qo1u+//76QqiI7ICDhw4cP8N7jD//2b7i/v8c333wDay0OxxdqPQQFm1ppDMPKdzGKhuwYTexlZx06KSFpvh9VLjAr1WMdYgw4HF7K3iTHrJg3oliCekbXtcwvoYYyz+p4kh3/+OOPeHh4xPF4oODGUHAmaAFlcUy4bWmin3BmSGyLjP75fMGHDx8xXC7405/+VO7Z/X6Pu7t7vHr1CI4f4D05qfP5xOBZxjxTmWSaRmizwW6/w363w5uvXuN4OONPf3pf7oW2o6Cv7Yj/EYKHayxiCuTApwFKU3mDhujMgKIxsounIMmHBR8/fSiBpLMWj4/3yEgwVnN5ZcE0j9AmAtlwYNIhZ4V5ota+punQ90RABBKmqQFp7nvE5ACIhn/A5XLGvEzISWGaZu5uuKBtFIxx2PQ9XQPtYFuFaSSBIqUq5xRpyuPa+jtCqYzNpoPhrhNjNIaByik5JfgYcJln+GXmWR1UMp7nGfMy4Xw+4XQ64en5Ey7nM47DGbNfMAwj+ZYsHAyeCGgcGtewbSF9iFpuvOY1iTUt/AOxq2YlvUpXksoKIhlNAW8sJQZVfRXyPvPivA9YFl8mpGpN7btKGfgQMU0XhBCxLAHTNGPxCVAWrumQoRBYj6sETNb+yuZAevz/RgxUAL7QvlfDtXWmq+ggHAMI0YIGK6ScK1hkzc5j4Q9ct9fdvlf98+fn+3nm/ucChwLl5+vjfek4t+8pPwtEJ0ZOIszNZnNFyqs18gVu9tEjBX8lplJnjjFTwFTkWosj1KWUoKrPL4GAtZa6A8Jaqqgdo1aUacTwuViLOJ/aCaXq2khmJs7tdo0l6KkzNYF0pe0MbPzHcbzKHruuwzAM602FdRwogKv3lPX33hPJsIL269JLGZELlGEudT1arg0FramUZeR6juNQCEv0vuuayNqJ4mTOVIcWXocESgKP932Pvu9xOp2uFAXlfAQSlVkC9SPGiPP5jHEc8fLyUozA8XjE8XjEn/70J/zhD3/Aq1evsNvt8NVXX9He44xMxE8OhwNSTHj38ztYY/H4jw8IwWO/33G7GNBYh8a5UgZx1lLWo1eZZFOtsxT4xHBmkIEzam2LlPWUYJRIhaqMUa61MGhtQ9G1eHp6wh/+8AcOfjI2VYcJySo3V10srmuZwUUBG/WEO3R9z0Emkf+enj4xE74vyo/7/R45Z5zPR8zLjMs5cDaXAUiLauCefdIO2O23eP36FYKP7OxE0Edjs+mREvEdLsMZGSSdPC8TowEKz89PZS8BGf2mg54VlVtiwPF4KPvg4eGhBAlApv2ZAtsWwDkq1XVdy0iAJ1ibs962bbilz2GaFLfAxWLLQgiY5gnGa0AZlrelc1Vo0DSa2wEbtE2PpDwWfwG19ImKJItfVagatXJSu2hOrgTkcr2RifR4uZyRYkTL7bHGGCyeUKlhvOAynHE6HYkTsszwkdj+NNBOkB+y6cQDcCX4Fm7NbRsv+QEiO+acmAdAHSv0N0FuCY0x2mLTtMXWFr8iPAP+Xu4HtpEhRPhAbYopJyhlkbNGhkaMAZdhYoRqZKSdagrGNoxWEwpE+jLr4K5f+/jNxMCSGXIUoyrpYPqQq9Ot4U6lNVTKULmaIZ5pUQo6cHOMK4f8VzzEwcixaqf4JTi+hnwBYW9ei+Pclji+dG5iuCWbMGYddCLnJVCq1D7FuTrnsLChO5/P5feCKlDwsDp5Y0zJrO/v72hTpARrHbp+c9XyprXGdrfH3f2mOE4hSaWUAM1ErJhIypczd8lGc85FBVCcsUS8EvB8qQ9fnL4QxYQMJk6dCIcRIQVEH9BYg9ZZdI0jHkmM1O6SIlSmze6MkJUYDWkbzPOMw+FAQWX1JRli1/WrYzAWd3csTZtp48lnHMdx1VXg/SrHElKj4s/+/ExQ7WbToWupjU4ebdti25Ghef36deFMrDVcUqujFiYUiJrKY9KHrTCOE5cZiMF9OBw5QGoZ5nVwLqFtO249G3E6nfHycoAxDq9evUbTtAAULpcB1h6wSRRE/uf/9J/wzddfYxpGLH7B//xf/wPn8xGPj/fQWuOH73/A8XDAp0+fcH+3x363x3i5AImmuAEZzjbQSuFPf/ojUk549fgKXdfi9atXADLmaS5QdgK3t7EGwjiOV+RN+Xrz5s0VUiTy1HLfdl2H169fl9quDCASoarakMt9Os4jQgxYlgAF4KheCjScUsZ333yH3WaHrmmhtYF1Dvd3d7h/eICzBpu+xTsk4JzguBf/cjlxWxupIZ5PR8Sw4N/+5V9wfv0KXePw8f17vPvpR2w2Wzw83APIMEqVbp/WOYzjgE+fPmGeZ1zOJ4yXC+Z5Qs4yaVLDGQPbd+iYkHo6nTBNVILY9h2secBXr1/jzatX6NsGl8sFX73dousdrG2ArDGNHjQRURf7VFpHU8J+v8fz8yf89NNPWJZHxHgPH2Z0I0sRd10pGTlHqpF3dzs0Tc92iBIRrRX6lpzrMlNHSfCBnJwGUo6IiTsiuLVOQ5XAWur/OUf0fYe3X71BjAETq+LRfThjYdnxy+WCZZoRfaCx5gloGyFnGg6AKPOX+0oEqUSvXySrZWIq2bBcbIgFMBWNCUIZ7+5IsAkqQyVSGVBZAYlUJud5xuKpxCLdGa5tWPqdfcVujz4lNE2LxZNM+DhO+PTpCT5EzHOEDwGz9zCauEaUDGaaCguHtESA2xdzNoWY+msevzkIoMXJiJlqM9eqgatM4vpc+q7pz/K/zx8U7EIyqgLL54ysv5yN/9LP8pDWI3GWkg0CX24ZFGeYM2sYVENFvsRv+CUkQJx5TXyrs/9a5ep8PpfXiJMHyOlIACP14tqoyWvEuMaU0HV9qQVL9iT6/iX4YXJV7SQFts+MLtTtfRI8aK1Lrbkmo0nEm/PKqi+lnLjKw0q2l1IqvdxSD+z7HiF4eE/1dckoqaWI2/GSjOJlAgw/r3Fcy7OmjIytBYXqGqzlLMwaA2UyWiZbJlDWLje/7AElaEHOzF2J6xooQDQHxnFE1zUlW79cLiXDsHqVixVYX7Ir2ocGMppZMWRJf8+grargfYBwDWjvHCHckVoRkAKIxNAhjUIl9GFf9vqyeIzjBNM0yG2Lt2/fYrvZ4quvvsLxeMD7D+/grMGHjx9wf3eHr958hWkcsCwzlLpDx+RUvgPoWmhq/Xo5vBRjF9MWrx4eCJVhjgjd4goxreUcKWfI/hMo9vXr17DW4tOnT+Vayn0BoJAEhUgp611PprtGrBLiQL3rIisrJD5raD7A3f4OzlrOTqiEKToTMXgoZBxenjGNxE5XSuEUyflbRzVvv8xATnh++gSjFc4nUsU8HY/USrjbAilBK6BrG2y3G1ijsSxbBCZEimqiJABGN9T3rg20djBdBwXgcj4jxYBpHBFZhKfrKbiapxHOGuz3G7QdBQEpZkwjdS8opcqwHGHBi7ZGStQO2/Utur4BVEKMniYSsgy21ooEkwyp6ZGUr0XOCt7HYhtENXGeJgzDSAJZjoh2yFIeJgU+HxQW4fxUttVZi9evXmEYLrhcTqUksswzlmnGOIzUGcFoKnUCCLIntsow6W+Vp5ZuBu9jCfrlflpt+5qg1fZb9n3XddQaOg/IEVBefMMq2U5B7FiCJ2UMHCdzRPaUYEXDTDM+pRfMi8fxeOKR6poJoLRvoHhkdI6w3KKava5ca4Z1v961/1Utgr/1URtWINPmgYJzGTplZB7xGHP+LKyQWc1/zUOcf10vrklat+WFK6gfIM14+bn6EkNU18tvHxJlSsYt7yfGr3bC4nAk84xh1ckXcpeI7lhrAWOKgZLgQXFmIaSqeVkwL6t+uQQPl8sZQeDqCt4XiV+Fta4ErDC+RN/SelXXreu6thCIZF3Eecn61yI9Yujo2AuWZSoOu0ifmrWPul6vmnQo63S5XIp2gkCK0qIkQ2lqAR5BZ6aF7lwJwkTy2FqLZZ5wYdnj4/FY1qHvO3TMqtZa4/WrR2y3G7x9+xb7/R6vX79G2zbY9j3aZp3QJ+1rQnRzri2fRQLDlQx5TWqthZKE9S6tjmK85BpJXV/WSwIvcY4fP34gEmiO2Gw2+N//9/8XpnnCP/3TP+F0OuH//X/8H/jqzVf4x3/8L2hcg3/8z//5iqg6jhfM04BlmjFczogx4HwmHYXoaezp0xMNM3n37mcmUS7oN1s8PLzGw+NDcUbEDCcGuVzn0+kAGow0IsaE+/s9vA/4+PEjZLIi1WRXLYW+77gksON6v2GCqscqLEPqcyEEHA7PnGk7dF0PMuwGr1+/hqi5ESF1gUzpk3tJBlppLYEyzQ2gYAnwPuBwOOCf//mf8fz8gvPliJgCQlhgncFut8Fuv4WxBvu7LVLa4On5I8bxgpeXJwzjiHEYYJ3F7373O0Z9MmhOfYJ1Bvv9FtoQ9yLniKcnGiBknQFUQkZictyC3Y5sBokAKSzZI6a120USAUEWX79+jZ4FhGLwmJHw6dNHHI8HNK5FCBGHwwvGcULbbBC6gL7bENs9JSL9nSboUqOm844xEG9BG3RtV0iUMQQKthPJ+m63GwAZYfG0ty4nzPNUju3nGRcOsALzc7SmZMCDAvemaQvaQa3TLZxtCiJgbVN8Q/0Q7QzDhEb6SqWrjTooFIDEg3oyBQOehO0kyC92n3U9AEUAGn9OQ1BAsZNdtwGgSdODOQBKaTRdwwE/TYeNMSJyC6QzDtY1sF0DlRQ2G+JQ3Q7X+nOP/7AgQGrsgGSwlAVBZVjqSAVS5ginrtF/GW6X437p5/p5v8TG/3MBAP+DiYp/ngfw51AIIYTVgYA4mhqmrI9Nr1vr7wAKA72w+R3BSfWx6vGaEg2HkNYauDhzH5Dy+BlCEZmwUxMKxeBJ9lrXu2tugMCvkvHX61Szw2ueiDzkmGJkJYiQIEHIfV8KxCSaF9SkLnsIwWez2ZQvCQLk8aW2zfp8N5sNFIBpGIoTL5moXjXrpfyz3VJNerfbMdTr0FUKejVvgpAWBWtz2S/1+q5BAKnRyVrJNVnLCqsgkFzPugVK1v1wOBRiodR3ffC4XM5oGoe3X78tZaoff/wR/+O//z9onMPxeMTj42Mpb9HX+v4kh3upyiSrcJNAttNIU90uZyI4td0G3dRhWWZGMVxx2CLEIkGpIFLSvSKOQNAIqclKggGgnGOM6yCrGCNU4YjmEkjSmqeC4rRth76nchnyqi9fc05oz0sdfQNqZwW8p/0mjiyGiNPphMvlwrDzhDPL/y4s1wtkOB7jbK2FNhqLXzBPIy7DpShi5kxOSGUZYgQ0bYMQA7xvkUHT84hAKecJ1iXge5GRJprqu0Akc0NY5bclEOi6DtrQnlc6c0BB3QeznRECCeMQR2OmLpwUoMD7Mnt4TGwbhKuUyLYnQhLkmivFE/eKfVj1AXxeGFafKmVMag2Wcm+KoRBwCeEgcvk6RpvJ2Y72mggE1T5B7h2q0YdiY2SqIhSTf1WdPNLekGQTEQhYE8TM/oPeo56hU/HRKh9AAZGFpPQpJZ7nsI47jiEiZPIRuSSXJA1NEs62tDn+2sd/SBBQbiC1jhjWGlCaFM90IinQIM4rVRn3r+90+OwhBh1YA4JfKgPcfs85U23pF5x87dTq195+7jIwg0ldNUegJqtJ9m2tRVgUQpGz9EWyt2kaGGvR9Rs4/lyrFOx6E7Rti3lZcLmMBYoWZx3TSlITR2GMwfF4JIh+nFitLpWsWDYWsLLzb9e5Jh+KoxSSj7y2bu/TWpfyAH1RnVaIZVIO0IqcijUGiSH9lFK5eRJD/ucTabJbY7DZbvH61Stst1uS563ImUavOgaj9LyzQZBedAkONpsNnLVorCmIguyNuz0NDLpcLpjnGY8P99hsevzwww8lEDDGIEf6XLJucmxy0DLHnsR/qGVN4eHhEdvtjg0zzbInnXxRGyQt9oeHBsZYhLC2LlprYG0Daxtst+IkM0O0PH+eA6vFE8oUvMf/9f/5v7DdbPD9t9/h4e4eu80G0zji8PyMZSI0ZLejQOf56QlPnz7h559/wsvLCz59+ohlntE2DTabLe7v73B/f49Xr14hp4Rv3r7FNM84Hg9QykDZNVORoEiukXSt1MGeXDsJtqy1+Oqrr0rJbZomHI/HIhs8zzM+ffpU9qkgKJst1bMfHx+x6Vt0rSNEIcso3wExeCBzScUvsMYR58Ja9G2HvuuQYsC236DrWjSWOkBINjahax05dwUWV1pgFE3zCz7g8PyCl7tnPO3vSC+/afHw8ICubVkZMGG33bKcMQVdKUQE5YvQDBit2/Q0Wc9qg4GVMV89PCIn6hZomxbGUgfIdrOnTDI5DMOMp08nhLBguMxo2wvmie9rlXEZLoACzqcz5mXEZtuh68iZa6PQNj2QgX7TwFoNH2bkKeNweEJOwDjO8HHBHC7oN8TX8ItnFUcHZ2k+hSgIyj0sTpdmHFB2//z8CdpoTPOAxjXYbTawSkMjU2lgmUmtMVDdPMWIqC2gV6ljCmAtGtdAa+IySNlN9ojYYCFpU6Cr0HV36PsWxpLWglJEYkw5QClgmobyWrCzpwRsZr+HUpJAlUjpuJamU4xl8J5zFl3bYGTbqRRPMlAkJy/TDXJKTGjOyCmgcTR8SUpibfv5tMpfevyHBAFAAQGw1vzpdyqDRisq4g1kJEIEKvTglzL928etc6p/9+dQgPrY5TvWrPhLx/ql19XPrQ2ZRJdXGb1Z51PXjhQpIkdTNkzdamdTgmUkQI6/fqZcHI3/AktfbnLktXVQsnhARr3GYoTrdasRhV9axy8FBzUXoobz5f1XhOG6dv+l0k2NaCilruJDWQfnHLq2KUzxIjZydU247YkNj0Y1l/yG9yHnKe2K8tgwa5yclC4331U7plKIWKH8Gk0gUqSiLIPOrnxpNv503WVdqc9cgjOZqCbZs3BBAMp26symLiForeESdSRkUKA7LwuOhwPAWWDf93j9+jVOxyO3eSUuRVH92HvKzqSMM3KJQ0Gha6lO2TQOfU/BZ8vcFGctUgZCVlelI9kXwDUiUu/dGkmTMo/UsOvgYZqmckx5rWT82mTkHJDSHWntl2xJI8WEZQmQDgQhp2VNkLDI/N4mESJ1bo1FNhm73a6gEnRORNJtm7ZI4MpEzXEgyL/vujJ5zrHIlLMWmgP0sqcqvpBWiqShQyzrSO2GoUg0rxwrGj/urONMOFRluET8E9MUQRu/EJoQuduh7SxSohJDygrWEIrlHGWt3hOBL0ZPyVyg4VRBhvswMmINyVkTuqFL7T+nlYwtwjwk+03CYVqxbPYWsPaOnTvPyEgRRTBJSoYghFk4NitKakvQXdtnsSS1n6H9RtoCzjm4hmxk23qEoBECoSM1Z0rcRdnT1ZRcsoHrniZi/fp8MNlbpjiKNoqCAnIuAYiMjDZGQ8dVzlhrDWPX2S7S9fNrHv9h5QDhBCoFGJ5kp7RCyhkmZmIbR4Gx1ylxiTfyX/MoMM2fOS/gy7V9ykpJPrh2hNcG4JeDgSLfadc553VfvbDsxUALuavrOqBxUNv+agRwCKEMwdnt92hY4ENeS6NOyWBst1tAKWopAYp4jzEGxtGQlv1+X7IqecQYedzoqvInzO06uwdQnE/tNKVsUWA5vU4jFEKgGHc5T1nDcbygbVa28m63QddRpqE1QMNoDHKm+pgodVEtnAZ4yA223W7x6tUrhna7gsbcBiIhLNSCGiOgdJHdrY2BAu3NnHNBbwTdEEh5GEakGHE+23Kd7u/vWSqVbuK6bCEO++HhFb799vuyVsIXEELnidENKU8I30GUI4XENU0T5nm+4ghI/V6ciOgECKz/+Poewzjgv//3/17IowDwxz/+ezEkX719i9//3d/h+fkJ79+/wzJPeFkWGK3x8HiHYXwFaw0OLy80OCWRIygDfKDQtR3u335dWgKz0oBe95x85rq9VLowhNgp96i1tG9lPSS4AlB0JR4eHkoAKeWh4/FInSPHjzhfPKASGtegbUkxbr/fQzcN98or5LQSnI2hGQie0ThBXI7HI2SqYs4Zu90GTdvg1as3JQCa55n1BM5o2wYvLy8IgXrj379/hxgDnp4+FRlrcebOWWy3G9zd3ZXPJCWfGKn7wxgZsrXw2tHXy8szYiSypQ8eu/0WWltoZaGNgzEOWnssS8A4TDidCP06nwYKLA3gw1xs1na3wf39HttdT/X8LNoSCg8Pe4SQcDqOUEqj6xx/JyKjMq8peN6Q9LeQgLuuxfFICoyfPn7EOJJCKBF3Cco/X04YxwE///wztNLYbbd4+9VX+LsfvocxdH1amQ1RJVohRio5sCmn+QRSBnBsy8AltoUCJC0iR2uCZJj0uNvt8fBwj6Z1UAro+xaLn3E6HbEsM15enqAUSZIja2RYhJSweOIKSGJGATnbnphplHHKSEpKgJQIIWfc7++QQsS26+ADlUqNNrAWhEh1DZw1aKynbrBlgdlw10ZjYZ1h6edf9/gPQwKuHkp6tBXnPrcw/JoNkLzS55Fa/bM8/hJScPu8+vmf/U6yXaydBLff/9xx63OsiSe1c60zC4FEKTO9lvOVOn8taSkMaIHrb2uWwvyta/khBBjOEm95CSvqcv17qVFLNn9b069/rpEH+UyS9d+iIbedBLYqh9S/l2PW76315+sjBlSctRDNajRGXi+BobUWKib49GWuR8li8krslOORQtjquMjhEJoh2WjjHPq2KUGU1NylM6JpulKCkMxfHJ+UgZZlueJtSM1WAkmpYUrpqF5XKSF9CQ1zTYM2xRIIap4tLxm7oHWyx0Q/glT8HNquwatXr+Ccw9PHjzCKgrW2balUk1YypwSDxhgOAnS5/13jSpCYuOWQrjHPEZF7nm2EjF8GgFRGul6rpa1ojEYQXok1OJ7WjiGq5a77XBniEqSYMYfrcdKEgNjCojdGOmJqW0RiSbvtDm3XYrfdsJoeHWMYSLqYJhqSQ6ApiKQfMM8zdvsdjF6RwbZt0fUSuGmkTK10kYf+SCCcM6FK1hEBj6D1yMFnLNK5Shmkste5t6s40Ej3VVblWmntYKHQb3rmOlDt3QhXJSniBiyUNTtnobSGAyNVsm5GujdaJm32JejLSVQUFTheBnVZrOPPjdYIvoFMDCQOAUsmF+RSSHh0DFVQEOr8WW12NdqeEQoZHZxz/izpq9FJxVm6BEJaq3KMnBOQ1j2RZAKmqn2V+C+w9DZ1RhSbk6Tl1hbCZEoJOYiWLiOTRiMajWQ0ckyIAAcJFQqp//8MCZAHoQGV4BC3BYqEcBS50yoLsLaBsb/+A1293y8ECQWS+TNBg8IqSFND9bIxbp17fcycVw10abcThypEJ8mapd65LAu6riP4zRl0jbtymgLT9n1PGULXMQOapYRjKmsmLOa+77AsxBYX5rk2Fi3D2uJISubPQ2lC5XSOx+OVY5F/1200ctMICbJW96thf0EVfkmKtA5OfgnalfeTDS8zFR4eHioDn4pDlZ9TWgcxSYZMY1kDnl5OiCkVCVutdWHfhxAwj0MVzdP1nUYaOiR96TIn/qeffgIAmgXQdfjm67doK9En2RfDMCCEiGlaStlCPlvdiihaCnJOhQzFxlOyfKmpCiogjnu3I6b87VjncT4jA/hv/+2/IueMH3/88TrAGEcs04jT4QVGG7x+fEWtbqcTvvv+e7x585q6ALzH777/Ds9PT/j06RNyzqS3kDIOhwPmeYaxuiABIWX4mLDpN9jutkSe7BrSeV8WyuRShGtEVpfaqIi7YtH3VOtMKSD5deJjiolb1gwMSNCm33TQ2uDh4Y4y6PEJhwMN+RlHEmLpgvS306jrwY94fn4ClWVobUXfoe0ajNNEPAGn2XlTe9fDwz12ux3+4R/+EzabDe7v77EsC56ePuHDx3eIcUHbNeh6JslCoWksUk54fnlCSgnf4GtuOfPISGhai82mx9uv38AYi5Sos8a6WpkSCNFTxv5whxiJgNd2lCUfjmccDhmN26HreigYzHOAMQ0aB/T9ej8pQWqtg3WA0pShfvvtWzw+3sPYa7J1TsCyRPz043t4H2GUY8JyXxI9uRe7rsXj4yNevXqF+/t7IgKGAB8WXC4nGH0HzdB3zgnDOGAcBsTFQ1nL8D7d/8s84+X5GYeXF9YzAZRWMFbDWIOcLbIy3FPfwJrmKnC7TpgyRPCu9hdyz5UkKkXoQr6lAICeTuQ/sqc0/S8G5uBobqXUKCUIJfX8CO6IMMiJ7GKOkVtHHbqmgTOGEfIMqzUa0RnQCnAGRmVYBcSg0HckUCVosf4zCPjt4z+OE5AhwknyP+RabTBf/enq8WsRgC/9/ksZ3u3v69eVfzMKcIsA/NogQGDztb5TSRJX77+y4/2acQeDFHwFW68wqZzjFWStaN7CLYfAWsfQ+YoIyJc8T2BXee+6FivvXXcKCOogx6idVM3orzN+yYbk3GX9xEAsy4LFE3QrbYTy+jojA3DFMbhFZOos/1a5UIKw+rUAoKBYPe8aKSgO0VpEvn5S0pEvKemklOArpy1lAq019cizka3XH6A2MtGEF36GZLmy3muNb0WEpH5ak0mBVZcBwNXerNEUuZYhrsNYpG4v+zbnhBTW/RQRsGQiRFG2TJC444mVd/s9MqMhMUSGVzMTWsFwLwUgMWV43pNtaOGcglJc/9QKVhnkvBrfOgAunBmsLbZlH6lQ9qt8r0mtlFmTIuEagGtmXyvI4BUANMJVrUOt6j0kQbtr+Jx5/7WtaBS0RQCK9iepLcrIXglAJdMX5yv3WY3WkI2QmjJp/d+SbzWjAcJZkXZTSWBOpwE+eEzzDEDDGtKSsMYiOaBtZc9bfq8E6xSaVgMIgIpo24ZIkK2FKNIppRBDxrJ49JseZl6wzJHRG7A9Whn8gUl7st9k6FTm0cOC/tJeXYePCWGu4wBeK7IzwziQhO7iOfi7bgeHNp+tp2SdxWbmlZ2/rve1H5Hzz6CAy4eFWsfzWutfS58KgZPazA6Nkn0JGFbcO+fMHRFAiSIIhygonFJg26G5VGJIJyCnSjSN5irUok+ij/BrH/9xnABFi6OQkBPDL6hgEawEt18y8n/N49YRfAkFqN+3/K78bw0E6varGk6Xz1h/yY0qzl3G1N6+vzxHHODlcoHVgK2IX/Jc0ToPIcCwAy+8g7CiAETicuj7TXGK0qHgw/ocCQRkrZ11WKZVxrh2xnUwUxPRxNnVay3HrHX+xZCLURa0RMa/xuiR4jpeWNZIavlyDIH6xfiLUzgej+Xa1PoDgjIAKEGAOIicSbJ6GicWW+qKQdWahtLkFJE2fSEHTtPETOxj0exXimp1AkXLfhIOQL3XJOBq2xbL4vHx48dyjlIDrp2ESE1rveoayJpLr/qGx8BKXb82aHWZRJyY0gqY6Fyenp5gjMGOURBrKTsN3LI5jgEvLy/4+OEjXr1+xOPjI56ePuH9u3d4+9VXjGLs4KyjMbh+4WuScb6cMc0GkXXXh2GgCZhqvb9F7VKcWs13WPe8LZMGhRdRt0AJsnI+n3E8Hsu+FFXC+/t7OGdxd79H2xkeEARstzs0TYuudyzkQkpyJFqlYSLJwS7LXBAWrQgtk/OiTgCF3XaDftPDuRZKEVt/HCdWbjzi48ePhfMjLaTC3Xh5ecE0TSXQERKn3GOCiNXCSLL3ZY88PDzg1atXZbKndMUcDgPm+YDT8YzJLug3eyBrdN0GTZOx2eyq/RqRUihBQEoLUvYsmNTj/mGPrmuqWRYLKxZOOJ0u+PH4DtSuphBjxjiFMhAqpwSraahQ1wi0zwFcjMxp0vBhQYoRw+kM7z3apsFut8U333yDh/v7wsN4//4dnl8OOJ8XWAcYA7QtOUDbbWBcW4LAz6D4TNm7Xrl8v/ggVcYRxnKgaAGARjDLNdFaoesb+BkYUqQuN4DVThMAzUgAB+dZOnY8YtSwRpH2y+q16CsHGA30Tcd2s+WpiRNxF7LCpm/hmgb3d3t0m3Vf/pbHfyASkNeIh0OwzNm/1G2M1kjWwEZbOeVrhbzPjonPkYL672Jcbr/Xz72tn5R6dEwMQ6316dtM/kufU4IAYJ2HXpPKJMOqAxQ5fowRKiuIPIJkw/J3GWRRlxastczsXTNyVQUPcs515i1qhLftWJ5nGdwiDzWSII86CLhdl/rn6/Nfmd+SOUv0Dw4GtVKI1cSxGONVOxFlTsRgll7lwLMWjNlRhC1rFUKJyr1fAM5oJaChQGNGTLmsiRg5ay0ULBQbEwkSUkqlpEEBT8Z+x4NYONChv1vc7/eF71AHBcJ38Z7GrpI8KbGGFxYvCjwZZFl8IWMpRZr3utwfivu8I4IPLM5iCnSqIHVK+slye9Zuu0OINF9B6rLyGUPwLLCTOECgWrVzFqLdHxZfrp84TylLGK55X5XRlELbtFDGQFl3NTK5vpdMtVYFiq32eo12yH1Z3wdyXMmIBFmSWqtWLfMIiO8Rg8cyk1Htmg20UjRul5qUCMEYBmrT5NbKtlHoGXZNiRKctm3hrKP9FSK8p8BhGiloPB2PFNxuNthuNnDWoG0ctQ5uN6X1NXKdHJnOzS8LFg4+enY41hgkzqal1S4nGquLnEnDgoPt3W6PEKgFO0aaUU8Ew1z2hHSkKK5hO2fQNAZKG2i9dr0IBE49/6qQEclWAzF6zkBzcXi0Xk2xSzRpcWTUyXLwbGisMGgkc4qJy0KpJB9tw+2wPHmQymmeh1RxRs8SvwZr5p+z2O2IlGqek4aCRlIrOgaAIfw14SMyZIQK9D5Nazh4WYPsgtxAkAzxBWBthwydM6/zOt8lRe6O0FWroCJuhFGkiJqRYTQjJ0rQdLIZUIpaQQtvh7gE1v4NBwj9NY9rhykXR+BdMmJGU6SUGwWdMrRxFUwemWn51713LYl7m4XXsLpshPWCgodxqGIMxWDVJYHbzynGS5yBZLYArjJw0UwfhuEzh5ugKEytjl0TxuZlBirYuu97WGM4u1wgQjR1y5scg1jD1eSrKmuNMZbZ61JrrUVZ6vUEqO9fVAxlPcR51kTCGhmQNV7JdKHAg1mDZH2tBgKxZ3OKJAZiqE83Ro+c6XdaG0SOyJeFauutEM2ih1/mUj/PORdSXs0nUErjNMw0aUxr7mVuyuAiawwaJjhJZmmtZSRgKMzzN2/e4M2b10UngDJajYavkXAyZERuCAHz5OEsSSfnRBMzvY+Ip8tV+SRnlmANNPmt35AIUAgBMUSc50slX9xhu7MsMSuwemaZf4W+26DtWty/2iPliHc//4x5mnA6ndC2LV69esVckAOpQfYbfPP113j71Vv867/+C/7tD/9KKm7cHhjCgu1my+tEa28dZcin0wnIRPrMOWO/S3Bti263L3uq/i6okXBkZL9KICzXuX5d/dp6NLFSqgznIu2ACfs914ZBgdX5dMECICweXUc9+9YofPv1W0wT6Wz4ecaHd+/hHE8BtQ1s5/Bw/4C2XfXZtdbQRiMuEUtccDg+k37B4YCnjx/x4x//HZvNhgb9bHpY/Rp922K/3aB1ZCd+/vlnTMMFKQTkFDFxBn06HpBjwOP9HZQhvlBiOLltHJzR8POE48vKe2msQdc2+O7b77DfP+LHP/2MaZoxT2fkLE5fw2hC2BTXuY1RaFuHvnfYblv0mwbbXYumIXSH2ifpfj4ez1gWD6WIuDbNA6xxHCxoyCjiHWenIYQyptkYxSJePfq2K3bQB7q+3i/My6IgQvYYBVQnPD09YZ5HNA05TOIoJIQlw23AthEl46aZKrXQmEYyuZR9ZB81rWOeEQX+w3iG9zOEeLjb9yAtA5Tgjw/ANlbKijKki56XlPAMgMDdcN57avV0pCHgZYy0tcz+Jz9otOJAoHDk6XfGoO/ITvVdi7Zry9TNX8hRv/j4D1UMFMevMrMwWe5YKQ2dAasoCFDaFMeY8gwVYjnOn3vcIgK1U/5zQcBtNiKPGGKJqCS7rzPzPxcECPQsELVAubTBfYH4anWquixRn5s4aIEGm4GkVOVcuq6Dr7JqMphrLVZeN88zQkowPhSkQt5L9MpForlek7r+L1mXGGRpJRKinUTvddAkpQV5/m3mt9lskJNHiiv5UQKEUqqoxDOAtZ/8tlok7yeiMdM0XSEwt9dZ8fhaKF3a6B4eHso1Q87IMVzxJbTWaCqH473H/cP9VasXnQyImYwV5q47AACNZUkl65AWPvms9RrViIqUWeSekvpv5Ey1VuYspRPWGJimCSEG2AaU4WANgIVIKXvK8Hr7ZcHheEDKiaYgclYsJCQRYZLRva5xJcjLOdNQFdnXZr2Haj6JZHxyzHoctayB7MW1BruiU/W+ktKR3H+yL+R1u90W3gcsMwXV5/MF4zhjnjyop7xF8BHz7Jk0RkhNjCzVolYt98zolewLxcH38XjCMpOufQgRbRlcs9oEOUcREFsD8/W+TDHieDggxYjXr19frYnWuiBCq8jNqiRqjMV2u4PSDj/99B4xJgzDjJQytQxqA+cSRE/fGFVQlL7v0PUt+r6Bc9IyJ2qRiqeYGkY5qbSVcyqoXM4afqHr5phLI+2cy7Lw0CFq3SMRM2qF03NFypbMGasNkfLh5UKIWts2JKqkr7uXCFmLV3yrGFd7RrC8KnNpxH7LgLGmocBnXkaEsILYq11ef845wQePEGpkV10dlxJJIQcS4I+caGouP2fxHobLgBQI2Mo/RKRIpQTLgYJlNUbFxMhr/sOvjwL+QxUDV8JDYt0jOmGjNLJiJSQosJIq39wZ07T81e99S3SrnUBtTG5/n1lZL5ULaIoxFsf8Jei7zn5rI7zf7wv5Z+LMqzaU8ly5GUUMBljJKRJFZ6XheHyw9IPHSOI3ZSxxXjBOc7kJyiQ2TZMRZW3EYVEPc8Cm6682U41C3DpQ+azipGX6noxLrlvZVjazLsaq1qJPcUHwIzabTQkC5OatSw7A6uglEJH+4xXeX0qd9XYyWB1gGWNgrMVuew/XtLi7u8Nms8G33367ZqTzjPPxUMoo4oS2mw1yohq5Ugrffvst7jkIEGefYkTrLLQhxUFx0nIso0cscyrOYL/f482bN6XjQD6rjBgWQ1gHRjUnoEa2ZF/Kc2RfHI80fMg6muZ226VxOp1gjMbd3R3D5RGn8wnPL09o2xZv3rwh3YSU0XUtK5y1VedEQtu11yWvlAtS5VPCzG1dolwpjlC6GZqmuarty76T+6FuCZVgQlopa9Su1giRYxhjcHdHLPpxIG2F5+f3mDnz7/sNXr36iuFiA60tjCaRHSoPEXpJe3MVwQqcwV4uhMo8PT2V+y74gD1PrLxt8a2JnYIM1m1eKSX8/PPPZW9IMCqBtgQV5/O5DK7a7XaFe/P61Q7bOeB//c9/hucJdYERJWMsum7D15H66ImD0mO/32GzbdH3DtpEaCMtyqRWmUHTIUmvoEFkPkHMJPGbosI0URm0cW7l0pzPHAT9HWs7NFyCWjCOBPFba7HfbjlLJ8hcOo/O5zPev/+E5+cz9vsO+/2W9ThYMCqR/DAhj+HKeYewljK11kh2hf6LD1BbDsY3aNsG43TBshAKKa+jfbiK98SYWYskI3Gb4K1PkNkBsofFsSsmY+YMzBOhgo+Pj0T07FpMEzBNZD953CmhI23D8w/Wro7rIODXP35TEGBVgmPopzCLOasv/5MsnF+jQOJAGbncQCoTR1KnAEAjK46clDAn10jGGyB0RHyjgRfCIpX6McEJa+ZEhZOMjMz1rRgiFs5SyREZvpim1LnWWheQs4bSQLfZIoPUwLTRsA1BvNo6qrkrmYzG74fyMQjl0ChZU0oBQETbWijVYLfvoU3GMBhm6Ysed4ZRLWzzucZ9BjB7DwwDLLdTyeS4DGCcZ4SYoK0DUqY9kzM5fuNgGlDXg1IICZiWAJsoitS2gdOUBSiA631EjKIgYCmbWhTtJIMgchI5o5pgJTegc7ZcM6UkEqcImq5JYIIVGfWFb2YAZXofOEikejOYtATuWTYwpkXOBufzhMtlxjgGpKRgTAdrezRuU4KWpm1hjEXfdbDOot/uYEtfbsTlci6thDEEZEUJYSoIlkLb99DWYBpJgx/aICuDaQlQah3QdJ5m0mywpB4nLYsxRgSl0Gz6kk1e5gn6+IJN8ExyctCKJKSzBpqeCWGGnUYKQAJ8pNpov13haeqjXqC1g3UKrtGISaPl+qOfRuRAgYCFwas7CmZa3uNNQ5D8sAxwyrGz74u6nRDJMhL8EhBUpEwrAzMH7dY4wKAoviFTwN86lsTVQrDN8POAecoIfoLRFufjC2XFzBVyRq/93gASB9R908AoBfA9kENEChHJBIRlIfW8SAZ0vAT4OSJHB0Ch7/awuoPVPc6XC/70xx+hlMblMtD1b3qkHIkfECJC0tjf79BtHZLyWBg5SZxBaq2RVQRygustovKYLgNCXuAaam/c7/fotz1cYxFTwDiPMJ6RmByhjMZmR4TPhlstlTVQ1uDnD+/Zye8RgsfoPYZlQdIa3W4L1/dQTYPRB5znGckYZCgsMQPWQTmH0zQhhITt5g7KOui2h247qLaH6Vo0mw2UaxCVg4+AWiKszTBZwfiEnAC/UGpsYKCNRqsVFjvDBMryj+ETQlYYY0a/dIjZc0A+oGWuTAgDYuhgdETjMhoLBJsBeOQY4RdSRNztdzSjISeMy4zn0wmDX6Aah6gt5mwQsoHJBnOMCDGjMerKsYnj1npFhUhHhW2/lpF1ZM1DICSRJIkTBYLG8eTShjk8ZLvmyXOZI0BljZ6H/YQkQTn5AaiMrJgwyMp+KlLQPIcAoxVs6+CaBspqtH2L7374FqfTCe9+fscKinPxca1TcMaidQbOGuxcRmsTGswwKRT7+WsevykIaHRCoyUI4OhagSZC8s8UC9QZo6KblCMhBQVwNlW+MypAT18vB6CQrYLqHeY5YVkSUqIbu2TiEg1rx69dWzCggbaxmHNCniPXMT0s3xBKmRWiKT2fxMxUymCz3QN67V2XyJuySXCwIZ+XNlCp5WraXDH5K0GTrrdwjUKIW1gLnI4W8yxtNB7TtKCxmghuHEUKbBZzRlw8fCAncxlo6t7hcCTHbB1iTDCuhUqJjF8GCaE0GpYdgFIKPmXE2cNGqvsbR2SztnNQ7HipjEBDSYTQlnOGDAWRLFTqkJKJlfY7Jn/KEJRV/S0iJVUCAMqqiLzlo0eeK3JmYo3smJF1hhMSTQZSBLQyACyc65CzwvE44HIZMQy+MGrbZo+23Zbz77qeuyd6Umfbt9BW2hGpHm6tLcx18I5PyIQOK4UNTw/89OkT/CUB2iJrg2EWmJI6DIbLytgXYqA8tNZotjT+OfiA0zTgskzYLzNlIz0prSVEZAO0W2LM09z1iGGYkGOCj5aldHm2QcqYpwnztECZDq4htncGBWxaaTyPE6LPFARYi1eMaAha0fctBgyYz+vUyG2/wWa7Kdf6dKKhRMu88kQAYJmJayJkWOnYmOcZ2khQqBDdakxPlzOGYcRLWpEegDomnDVwZi0bpJQwjTNs29IaaQNEQoB88Eg+IEBhmZjbEiIQM4YTHdNPdE7b7QPszuKH7zo8PT/h8EJjfE/HE+3rpqV7EBHe8+Co5i36fUODdHzAaSBE7832LZRVHMwmdHsHjwmX5QSfZrStw3bb4/HxHttdD9tahBzgp1URMeQA7TR293uq8/Y9Bc6NxTwv+PeffsRut8ff7/bw3uMyDBjmCclo9DuabTHNC87LAjtO8KBxvyEqoGmBpsVhGBBCQrt/hHUtdL+F7jrobge76dDu9jBOIUJhCgkhRTSNgssaCglBJyQ/Azlj2/UwzsDBwrsJNgDTMOP5csCigIuh7g6fqMNimSeE2KLPLfxyRvANrAlom4yuyUjcckj7d4Hue+z3b2Fdg5AjhmXCh5dnnOcJpmsQjMOYLVQyUDAYo4b3CY8OMHlFf8R21+23698kCVz5at4vmOep7GejXdnzRjvu9Sdez/lE0znPlwVd0+DNY4OQIhaf4JkbkSnrRVJUvtROc6sj2YQpLDBK4XH3gKYlW9S7Dn//n3+PTx8+4nD4hPEyY1zONFI9Z+w2Bq1t0TcObQPcuYTeRSBHqKSw+F8/efe3lQPYAJbeuaLNCGazZ5Gmr9odSEDhphK7wjSCIAgdXoQbxKlqjda2K7ynNIy9lra9PvSqKU+DF65HCNfORdjy60slS6YhLda0QF5V866fJxuIWfmKyBqCKpCDY3JbdWzSdac6OADs9nsYY4q6mA8B0zzD6svnZQyG8unzGECtwZDWGmrx1FzCWfcvlUFSSoU1DqAYfqUAHRaoqgYnmf7q2FWpOwqcWbcICiwtPwvMXK91Xc8W4iJNwErQ+ross5ZI1kg+CSIUqaaWUsLhcCjRvqAXcl7W2ZtgherSVCKZMacBxq4td13X83roUoqppXWF/EiQrEXfb5FSxjQRvBxjLHwBKSFI+ULY9H3fI4SInNmB8n2lWL4454zkA4oGuBKjljmUXjtQhCmNohVBmZpSCpcztapJWcwaCxiQxn0FnftAkrDeB2IZN6T+1m9opCugCE07nwlyTYmNeix7vjClNfNBQAhZTITipZyRQ8ASVojfuQZt04FGY294xHwunJm+3zCJrbpvuRbvvS9Ey3leeC9RVr7dbtFwyezEo6Ct7a+CebkvjDHYbrb44YcfynUuSM7lgtPlXEobr09HdDyyWGSba2EnCV4kiPz973+PeTzj9PIB2+0Wj4+PuNvfXQWYLy8vGC4Dnp9fmKDZIcaEh4dHCqy5A2S73cEYS1n1NOLlcOBySILRFm3b8QRWVVpP2+4BUAbD5YTgZ/R9C+9T6UBonUPbuMIwJ3VEzQjqgGmZSPhGZey3DdrGonMNrKEuFZWB4TxguAxVi/KARQETCyo1zhV1zZx5Tkdc2x+FsOt9qGyExuIDnp+fAaURksLpcsHz8zOmmY7lzNpFpouTr5KH+AVdkBu4fE3qrsuvNXm4Ls8AuLKppQusaaE1tYKTIV1LcQlCGmTeVoiEHGdCRqXDg2/ycr5Ka7iGZK1bRxNJwe/7eH9f2kCtMTDVREb6XH8jJCBzzb48VBUMKEBBfxYAMHZb4oXKxJefMzIzJeQ3azlAWQfXrHr1GQrGrCI3dcta/SiLUZGS6kUCrvkC9euoQ8FCNaT6VLcryfMlehRJUceQndTyE8tayhRCmRRHYywpG805F6W48+UC7xcsfsY0T1DpmquglIK2FkoLqYgZqLzJOUIjCMJUWti317DUqSKVcvIqyqMAmo4lJZ1qk4v8bB1V1wYVWG+8W35EcWrpuuVQggBCO2h9wOdd35j0XuSU5dhSC1YxI+pYdBaapr0KYADAcdZ/f39PJEQ+l3fvPmCeJ0wDBQEi9NJ1fTEeMSZcLkNpbZLP3DQy49vBuaYEAafTuXRnSBAgtV75XMRR6BFjupH61RwEcI84qDVMAjSl+b7I1EWx2dAYWwoC6D0JWVnQNg1a15QatXQ1REfM6M12A61Wcp2QSOd5RsoNutgDSqPf9EVUavEe0zwVfQR5uIZKKaiCNq2lLIfS7pWR4UPA4sdybdumQ9t2aJr26v6SORPOUYmjDqIkwK31LCRQJ36Bw3a7QdO0hcyqFM1aL1KseSXlWmvRbzb47tvvyuyMcRxxuVxwPJ9KoBFjxPl0wna7xf39PQdyoVzjyEiPoB+bzQavX7/GcDniydF8g/1+j91+V6Z3KqXw9OkZl8uAl5cXHA4H7Pd30NoUASKw+BKgqKuB6/8vLy8wxsJZEidqXMutfxl//OMf8fJywH5/gbENhuEC72cqMxnqukHOaBy1mDWObJjhFlNnDcIi0tQzcg5wZgejWrhNT4EDd4PI9EaSJ/YYxwmLAuZICK9j3QgZzayUohLtsmAWNVMfEJgrAgDaWHgf8PzygpgyxsljGCe8HI6ICYhJweZ8ZdtXTYDrQVRiY1Ze2nVX2DXCq4oTJoJkX4iWwCpCJs+p7WPimQ3GWjTMs3DOkXR1iphnkrleGBmW93StK/d4sfmZlDKda4hP1rbYMlEZAHbbLXacSCqgdAPJZ9PxbxQESC/zn318ITPXRle8Aan5s5Oq/lBoBVWooAGu31hAabiE4gwAFKNQnK2WjIq1sbFm/eX8Fek8yzkUZ8n8AsuByzSRaAj9bY0i6eKt5L3rzJccXNOsWuZSZpAyhRC2UqIaoZAFp2lEygkqqSv4PTPRwKYMY+qoNtLERUQgAzElih7bjmKvSgmvfmTmCiRELlOsJZiYfJldIBmvZOR1a2TNXq/bEGvHLoa7biusX3sdXGn6SrTP5Dli6KlcoMrxzuczYqBee7lhSdGPAqK2JZLZ/f0DttsNjNXwfsHlsgY2zhmk1GCpMnx5TyE0Sk+yOAvSQO8KqnA8HnG5XIocLwkfxfJ3WUOBxvu+x3a7xZs3b0pbn5DFZM2XhchkMuVQKWbEq1V2NOt1LLFWBjEknM/nggTklAHeR+KYRGgoxgj4DKNM6QJwroUx8SrAI6TLAZiKo5POlnme1y4QkJrdinaJwqIBBUO0rl2nAGyQsStZo9YWKa3y1XJ+NBER2O1WPYe6S2WehUXPpC5QNmydxTRPeHr+hJZFVqzTaBIL+yCXtq6aPGiNwXa3Le8jYlKbnjL+jx8/4nA4YPPvGwzcFvvw8ACAHIBTaxeP7KE62LWW9kIIEX7xmKeZylENcXrm2WO4jDidLnh+fkHOwHAZobXBjlsqQ0hYlgN+/vkdseTPZ2w3W3Tthv9eI3e0LufzETTK1qHvGnz37Vv4JeJ4HGF0Rs7x6osY9RkhJmSQFPNwWbAsA3KccW4MpuGMxpHeRAwRH396j8PhCGgFaI3FewStkCwNXiKBJ7LGNFAr4fn5GX6ZcTydMAxDuX9FN6DricNzOF6weBoVPc0By5KgKp18WeNUEs21LHuL9tYdUWKPVp7TKswmwaYgPLf2T0iXdduqBMUpZ5hiP+tSM8r9Q8TthKahoUSm+tza8DmA9nbTNLi7uyO1xRBKN8im69C1HSJrXmz6Bo3jexAgXtivfPymICCmfEU4uIXilVJY/fcqlagMcwEyCVSowh9kOl2uqYYVoQ2AYnhLaQON1fBJBgUQoS9w5KPS6qgzVIGLS3aauWTBG0dpzYMbQJsYKM+Liwc4g1eV0V3Zx9fjbTN/PonaaQNoKEXBAcrf6AJLXTqlVGbVz/OC6OMV7yErYRqq4owKlK4yYlqheG1M2QD0+vU9pUYv5Qq6ptUFzNwOx9CuOKVaJfGWcf2lkkNtsGvDeAvF1a9TSEwgo+tdR950I65ywOKISEwHpUwgrZHS3ieZV9sRVEfHiqVdr3yuRV0FnnLe4uyWeYFmDkTTNNj01Gtfs9jlc4gQSp3hA+sgnv1+z8HJfXHOEljI2pzPCsBMo1FrREfuE6nCaQOjiagZWFimlIeUhlEGy+JL62YpzfBwE6ttQT2sIU6DtWtWJN0TdRZeUIFqMqWqrhsF/QRvCowv9yNpmgPGJF4nGbGaqWWPdTQk66bsPV3dXyvsvvAxq5GwLP3r/YJlmWDuDayjUpKxGpFbuGrm/crh0VfBgZQkmpaY/FJ6+PjxE0KMePv2LfMKtmWdIpdX6mBFjifrJKUs7wO6jocWFXldgscvlwucc5imGW3X4+6+AxghyvmAlxeayTDNM9qm53uSh9kYDVehc/M0IGdgv6e2102/g18ChmGG1oQIZCZ4ijgXnT+J3yhFUrnjOCL6EdYAYZnR8P0TQ8THT59wuQzF6YUQEI0GkinokgQBzhoYrXC+nJFjwDgMV10i2y2x/TfbHaEelwkpETK0hIwQAOfWQJPNFgXGjFMXHk++lkq/RY3rpOXWtsn1uy0FS7AuXRp1d5eSk+GHoMX1ucj+jRxoAopIsoJGKL2S6pUunU8iOGTYpgjSt8wTd4k5NM6U/ZYqkb2/9PhNQYBPCSomsG+H1DDXHyuWJSOXSqGIAYkFy8UJ08dNOSErFjXJ6zrmDIRlQQq+nEMtPEPCOQux2LkWJ7UUYyyjAHnNMKpggE6TKPzKrK1HuoqkYbqVU8CMack6VwOIkulIFVQBLNpAs7FDsNQ2kyLGknWyI9aa2tPuH9B2PZquwzRMGM/TumFipHpqgdkzYsxQmrLemNboNQMli0J1VgDFODS+eXXGqjquUgqNcRRJVtDYbVnil1pQpE6+Bjr6s7/XjrG+QWoddmDNxlfxI7qBJWNcHYUGEoohEa7Cfr/Hfr/Dfr8r/e+ibX//8ICuo2EbTdvg5fyMlEh1LwY6prMG+/0dNn3Ept9ALhox8xW8D4iBsg8ZVao0MZpzziRuYh2MpRuzcYkjfocUE46HE5ZlxjCMmKcZ4yB1aGCeaSJhCsL3qMWNFCdcGikRbPrw8IBxHPD8vJTnIpOYk5Q3qP/eUttd9JjCDKMMwZasMKaNRtv2BfUqEKk2ADSsa6CNQcwUPHddB+scgIyYEwYW9lkWX1Awcf5N06BpGzacM8ZxxjQuaDtN0HLTwRpXWihlP97d3UFrjcvlUtpklVLYMYO+73u8vBzw7t0H9P2Gx1PTvm87h/uHPQ7HJ5wvR4yXGYAqkxOlNexyudCEvuDL+YYQihyv0uuY6axIovoPf/gDXl5e8ObNGyJx7vf82YkUKTCycw4aPfTdIyTNIUEdaj9UymK32+PxccarV6+p3Kkd5jngn//5X3B3dw/XkEgV5U2KEQ6HfrPD3d097u8f2IkaSOfTw/0rICu8PH+C9x6bjrpdHh7fwC8Rl/MA7yOOx0+IcYvNtkVqNKiqQ3ZsmkYMlyNenp9wOr8gLCNSDLCaVD1b10JBYRlnpJjg2ga2cRj9DKUa9G1bkGHDyKmsSUoZy0Kjf2PO2DER8/7ujkiuuz3GacaHj88wZiJWvVJoGrLDbdtCaQskEhBLWSyvgmEBpVv+V41YSkC52p+1pCAoUK29IMRA4Q1JwLh2HmgaR9068f7wngI7HxYs3jNXifhmwmGo1T3l2lFQIzaZg9OUgZjgnEHjHLqmReO4eygEWLv6ITrWl230F+32r34meNqfOIMKQqZ/sNTtNU2AHEqB5+kVOedSL8wg807wdZ1J0/cYAkSyR2rXdU04hFiGt0iUr7RGxjVZjfqVb+okSpWeeQCURUsGZCyUdVASpRlN0pV23RB1j6acrxQhrLMwEoxklM9P0TyxsgUxMMai7TpoPneVNcJChhbe0zrFVTCJ0IxVYEgCgzoDl/Wik5NrRcGZVtWwjDqLz5kM9022ToHMNW+i/i7/XmHkVX1R/valkoIcX9ajDjBK1lpuXtobct3XEgehSSu5kd5HIPumcZimVAh+3ntswxY5Nxyk8cTEJEgNrZMgNcmu2V1OqVzsFBMSEkfrrhCIFO9v51ZCEQBknatsMBdNBZnuR+QrCgIK6bVkNpohXZJuNXrVcDCalOFo/1M7rjUWiUlIgjJIpkVBcURaIiMINKSFggvNTp0C87p+mpXoKmg0gWY7NG0LY0nyNSbuy+Z7mWbTCyKHUhLMOSP4iOApI27SOpvCGOo/l+xY61UIST6v6EJIYNH3PesoTLDWIAThrhAq0DQkdTzPI4ZhBAn/pKtjeu8RYsS8zFcMcmMM+q5HBnUpnM9nnC+kqPny8gLvfZEFd0yeFW5KTSZT1gHtqp2guFOKSocogdp2u8M00Yz7nICnp2f4EDGOE9sJ5rg4B5sdlDGFX7JyaOg9qdd9h+F8QE4Bzmq0jcXdbovFR/Rdi5wnnE8XGk0bA5AStF7tWYyB5iYwD2QcTvB+BqKHQsam28BoA5UYom63JBSFDMMwN/JKvrRsO0UIKEkbMyiQ7roOHQdPfb8pKp50nciMGZ4WSDMu1DqBNlKZQJDbW8TyNpmp+UuyH+rX1OiTMabYF9HvqGdXrGiXQeto9oaPK1F08TQgTZBKQZalZFDss+L/sR0iG8rzPyKhuiRmZQsXLUVBQ9euvd/6+E1BgFYOWruCAqwPdfOdHpk3+uKpdUFqHZkzfoGr1++xgnYA5IwleizxWp8eACEADE/W0Bu0gU5grWY+K03sUaU0lM7k7M1KIinP440grG9YyoAAMvrTPEF7XWBcMVzWrlrT2jCkk4GQMg1MgSbWfga8l7rbypRXigyBsw5d28OZBkbZ4rRk/GyIiTXuF2hNDFbFG6mgJynDLwsFOBzkCCyrWYNasTiTlCzqK2ZSAHKqgop4FZjJOYs06DXZcm2xlO9UnwMjJnQDWPv5RMW2cej7tS4u/fSSrUk5QOC53W4HAKU2dzkTaW+z2WC73aDvu3LzAhTc3N3toJTGq1evWJCICDo/fP89XwN2lHGdahY5eIgxki6DtXAsKdyypkLftjCW9PEba6kuKPVKDmJkct0yEaN+mWcY69C0HZWA4hro0L7SaJ3jGqHInwZC1RwFnwT7A9Tq6tC2lCF2XcszAUKROhbEjngxQNPRaN6QqewljGjtbBUUKEQFhJwBrWCbhkb/bnfIOXEWowopLGZWtmT9AgQyphEKEYDrFlit0HUbAPS5ttstz6qXvQMsi8IwD+yEyHi+f/+exbbIpszziJwjjNVoW4vf/e57WEfBwTRSGefjx3e4XI74+ecfcTgcobKDc+1VoCooUYihaIlIuc05h6wAw3rstJfW7pi+7/Hq1Stsd7tCABOxHxGHWpYFOQT4eR0I5JYINwcMlxnakMiNNQ5fvfkafb8FjQ1O+PTxCZfTgB9//Anb7RYPD4/Q2uL77/+Ohu54Gu4jyICxlkW2Akg7w2G/3aBvDbrGoLUKm96hbSzevL7H03PGj3/6I3KOiMtXULlH11oYA2gDzK3F0lrsdj20DtjvW+SUsNt0aJzFq4dXcNZBQUMrg67p8fTpGQka53HAp8sZhmck7Hc73O3vcH+3w47J0DklhEhSwsY65AwMw4hxnPFyOONyGfDzu/c4nUdME5V7XFNZq7zyvHIWKV3N5GtTMv/CtlcrsfkWHfil5ESCBEFXJRgYhqE8N8ZI6LACrFHwMSP5KvEIvkyRlEBam9V2StBPXQIGqQRMlFQ45xCyxxxoWJniKCHFhIXFqBaQ3ZbHb5Ha/01BgNKGocHPH0LCq34BCQpkxnVmHkDiWTErMSxf/SxZqWTOS1iuau9yTCEE1g4KGSTukquphOz4oKmuoivVPKB2cNeZqxQ3Si0pr3LANVkJMNXrNJRB4TWs57iiHSJ6BOQigGKtYd6Bgm/WSXoASk03RHHO8WrzKr0GNBnXEsSCAcj50sbjSFdx1l85cfhYrhM5pc9bDCmLERWtFaWRwSJ0HVdJ1as9pFCeXwcCK7LyuerVGjGvpB6BxqUNbBzmInkqrYvSXidZofxepEGlnrfdblZCjgShFapSvnzgmeI05EWYz6bam8ZY6ILQ0B6Q4S7EmVlljduuR8PtYHXdntaHYMU6I5FrbtMKs9WlnDVLcMhaA5kRLbUyj2WPay59xQyoTANboEDtsbxmGYrmo+eErOg1xjVwmuVqDe2vECP93Vok3n+S9ZOhjzCRJ8VZS33SBUbldlfQ3pG6stTOQwjwwRNknxJ2uw2UIqQipogQFiitsN1tylqE6JlMBozjBefzCeN4QeN2sLa52lulbhzTVUeJ7DVrbLkO9d6sOSXOOWSgZH61HcvV/U68B4KuUwYroa4cn67rAd7TMUa8PB+RMnA5U12/6zbleZ67Qej60joa7ZCzL+RYrQza1sHZBGdJHMcZmtWy2bS4XBy8n+GXmUmoYUVvC4iYYayGayyaTLbj4eEOfdfhqzdv0NgGyBoaGo3roLXBmzdvoF6e8fF0hMI6d2O/22G/v8N+ty28m67rafCVJl5DCBEpB57dMOAyjBinGSkAWqYdX5n7XH6m8xaN/TVhrO+RlZ9xTW6ukZs6sakDAfl3bUvXJGUlAAr3q35dbfOEdCvHjymDBkZF8lFYRdUMv0fkdvAUI6JWCIqQd88EYn0TBPi/VRCgmwaGa1OZcZxyESpHh4pmlXPGZZzgeTIavZZB3EyvLUajIADrcWLyiKmSRGUGv9T35YIqzXXNisymlII2FjpGoGqH4lFRV6UF+X1MGdYF6ASE6VICAbnI9F5165rGstTw3zU0HsLCkSSp4mVoQBlkRDJki4fSGjYmaGO4PqthbQPS+lGwPhKBbwkFEs2Z2hiphtmUWmYGBy1isDKJx2SjkfMKlzORl/pLGUKja3UpKMVtbb82gvWGlhtG5IFrXYD6GLW2g6xffa3qm3aV6c3ImUiYEswAQMNtaV1HLGLHcOLDwwOPPiX54d1ud0MOypxhTuXa5NwjJVK6E36C9P8L4kESsBMT4wKGy4RxnLHdbFledCqyzbQvebKjIkcaPGmH266BUgY5KWy2W9zfP5ZeaVFOFNngvm1htCkBdGSEQnEg2zSO2qieDwDISVhLjr/te7QNtQgOw0izyNnpOgfETHPcTaSRrtpZgm+1ARQl8pE5N8S9CbBNQquAtufWNZZ0TQpwvoXia+z9qnkhj5ASzsOAxRiEyWGaJwzDBcsScLmM5frE6As5TSlF+ujW4P7+DgCw3+9Wol8MOBxeeHDQBj/++Cf84d//UFoYY6QJidZRL/X9XYPGdeW+FwMuHJ+MlbdSvkBGue97YmnnhDStmeXxeCSBIW7FPB6P6Pse3377Lay1uLu7w+lwxMfDqfTF28bBOreWp7Y7PgeD7WaPb7/9llj+zRbjOOLldKCugacjBbGiTxBpfsM8ey4LJAzDQHoWWaFpWuy7PTQ6pERcg9YqQBm8ff2IHAM6a5DTgpeXD9AmYLtzsI4IlU9PH/H0/BHej4hxRt81cI3Dm6/e4O5+j6/ffA1rLIbLhBgSkk9o+w7f/vAdgspY/vmfYI1G6xpsOm6P3O2x3W75Gkfs9zuA9zNxbRbM84I//uknXIYBh8OZdA3IAjEiyAhiSUAAnasyRkpQTGCtHbDYHJEQl9q/II61jPO6H+OVHQNuZfCrhCUnTJE0ACIHCV3XsUaGdGoR4ifJHCWp5NgVyPZ4Q3X/1jko18C1LaIXX5WgEBGWgAkZ44WIldu+gbNrUFPfe3/p8RvFgtgJA4CSaF+qsmsdQ7IAiYh8iFh4CBBunwMuDyBXgYUqSEARvQGYc0AOro7uhLBTZ/J8kp9dKCUse35GyQT4SymWJFYJKbHccf1aUO30tpSwHifzZlTQmuqkMshiZaeqEpTElKG4fdDyexR5WrXW+OR7/V4Z1B5pzLVokpRSAJDOu5bAi5mwSlGmyCsmwU197Ot1/HIAIM+Xh9ww9XrKNVrXV5Xv9XHp9amcy1riUeWrDjwE9hMiYt9ntG0H14i6l/7shl48DTmpJ0vWi7YGhStSpfWq7S6ZdORhPCnIOmkeYypfCUCEzhRsrm9DxEIFhWAk+7ldW421zCKDj+gEM6NcKQuXgyDRUA2OkQEv1hAJUStN/AVFil6CBPlALWAxRUAZWOHSZOpGUVglmwuhSvYWJNOi55RrwgRDanNNV2RWCex0BiIMDzSSjoPIZafMayWlJiE4rSRcy1LVzmnWal/HYx+OR/z883t4PyNGX+69u7s92rajkhrzh251Rr60vwlJY+SkwMgroUygXACYp+nK8F5lgDf3Up0lxkgogdaxCIFJEHh3dwelNT4+PyGEiGlauPy1Ii2aOSnWOFgbGD2hoJEm1FlYRe2FFNBmaA10XYO+o2l5UArzPGAaWwzDmbL+SIHaPE/IOYBQS3akjaUWQS6HymciFCSj7eg+VCACobO23Is132i9zlLSJHsYAmkPkMhVYn5KZSsU2TcFxUhmRlKrv8mJ5Hnrmn99na+7uVZOinzJrI06ELhFJ2sbJvsjp4TkPUclZLMoGYiISXF2D5KirhIepYGcRDhNkTKsUggxwZqE0nkD8bGcMCcixM/zgq41cLhuffy1j9/WIpgV/A3MnZi5XhvAXBw33dQj16nKeX12fitpsP4dAEpXM41aTBwoyIUDQFPJQFMJavglhAilJZCQiYQyvSkztE8QO900iQUW1gEtXdtQTypnUaVNzjm+IT6HFa9v8IzLQLK7gT2L5bYQOm9we19EnBYYbWBdQFwW6orgjetcAyhNx4AmA56o1Uvr9YITsYo3GZ9X7XyVjrApUs0pJ+Rkyuvkwvy5zVMb9Nvn5bz2egNfDiDqqYC1QyfDFjCf14l/4ziThHLjSo1P/iZ122JYOOKmYUQddXEYBc21zUxwE4YL1Rll0h+pyrXUHoe1/XAYBmity3jdu7u7kkFI+6E4lCInyvwD+VxSQ5QAQkoV2+22DEeapgkXbims4UVxDEEHzpIkMyUugNaK7eBaspBWorLmei2fSOlEKQXX9sjIOHz4UHrZZaCNnDcFFGvgI9dIgjPKNmlfiyO9DR4l66qN8DAMUF0P220AEHLQNi2atmG0IzHiAwzDmdjZ/B4heEIAY0DTWLx69QrLQjXS5+dP+F//9D/wf//f/4T/8//8f3B3p7HdEoucHBW9LsdnjMOCn376qSh2yrlKecHktRxQG/5lWTAMAz5+/ICXwwHffPPNVSeDNgadtXj9+jUs1+ZlSFhjLL7//nel/U8Z4ihRN0ridZTyBmlmGNPg1as3cE2LP/z7nzDPIy7ngdGvDsaQznyImdDFrAFoyJAcyTqtUmgsWUgK3Oia3+06xHCP3//+exxPZ3z48AnLMmIJI/q+w3bX43w5YJwu2G5bdO0GbefQNBYhLBjGC95/+BnICqfDhUczD8is49I2LQsj7ct0TWRq9ZM22pQSjucLhnFi+W+FaZwwThNGlny2zkKbDGWIKK3MWhq0WkMZgxgpeEgpIfoIDyBpfTVGXIJQQX9qe1Y/5B6U85TuJBkNLz5AAowrFdQUEWbieVjuJLPWIGYDnSK8X7V2YmISJlj6nFvQFQC/LMgpY7hcgBSx7TtWyVQlUAyJxhQvC9mRu31PMyZk75aE8y8/fmMQkGF4USM7e1HFk1Glkg0ndrQS3ZUsgiP99bHWpK9ya0FYMkXjUldfs0tdv3S9EDmXurso36WUuHxQCROWY8rXdfRUYHN9XSvSXA+9jQwBEjVKyFDqeqSwD5GGzABQQj5Ris9B2hgTkgGyUkghXWXB0vJojIWx6coZyrkWRITREnESqL/HCFGUJsIWoE1kx7JOxvoc5RC9AbqAOUt7Z65+xz39PHZXZSqbsLuqzmMNEMWhkeMLV6z/NUq/VgOrOwDoS4zCdelizRBnztwjAsPtQkATwScfRNEwVl/CqwCWhYSb6i4BQXdETIQ4Aut+vCqFKFX6e6k9ig1IjFh8uKpD1mzolBJidX2Vkl5k2hpCqF07WszV2gl/RWBP+QzgY8hzJDsmCN8T+dF9PolP/k0oDbD4hdjJ1T0je0kCdUH4RIlPDGfkuRaCGNb3nHynAGctBWZkLMsMrYFxJOLgKtqFYnRzjlwT5UA/BO4QmIFsigKgrHfTNAyHoZx3/Z41pOx9wDTNVwhXvT673W7dJxIYGanzJ1hLmhPKGDjbAFA89pqIzrlA0BHSpQSyAiXgNcauRGfQSNyVF2CQNAmdBe/h3QKdI6jaSe10tCeoW+D+bs8BrccyTxguFyiV4RrNQZlG33fYbXs0rSUStF6ng+aYMS8zlpkIzEppdE0PYw06Hgve9z21s7HzLCp+PFCLZJqprXUYBkzzTC24ImJS3VjFcWfeL5rasCE2N4newbVq4NX78jWr1U1lL8i+kPZAIZ7Xdrb4mQrtMcaUzrnrh1p9niAV5btay7ZK8bUmX0ndNh6eOwBqVFWQE6XkmDd59a8HAQD8xiBgXkKB52l0ZKbpfkyqSSyCsDI2JcMxgLLFQJYsXqYKVtBw/R0AYsiIYZWdXev3BlDCNOfPnkEM+rhqeAMMa2a2nABrm2s29uuKiTEVY00qb6sRlA0UQhAMvVwUrYnxKUYshIAMav2aphnjNHGWrmCNgXUOCQopAT5mzMwN0CEih4C8BK7vSq0KpXZVK0+JwSwOJmeEmw1aR8O1nrZkqclavqkA6wy0Wcl9dX1/XX/pGriOpCUgKHVVZShgYmgMQiRUCUoRY986Ii+FsBSGet1KKOOGZVQwsLJx6e8NQog4nU7IOUGpe6QUMI4ew3DB01OtBqZgnUXX0zGblhS7Pn18D8/OGCBJ3pwzgp+RU0AMgVjxXItNOWPheQIjowPSvsd0OgwXUQ4kZIK4Ch32uw1yCljmEbMPmJbAI1X5nJqG15K6AWJFcpK6deaOB3F6u92uvF7uk2WecDmdcHd3h/v7e1wuFyzLQhkZANc6xJywBI+QImYv3JUJ2+0WP3Q/UE27vy+OdoXSF4Qogk2hXO8ipMJdA7WMK01auyAvgRXxaC+0Lck8ax6fbW3P7U8ySpkmHW42G8zzjA/vPyCmgH/6p/+F/X6Lb7/7Bnf3e+z2/xV93+HxscVPP/8JHz++J55GyNhs6Zjj5QCtxnJP5ZyL8l/TNNjd7a/QJa01sl9KWyIx/oHLZQZAQd08z8gAHBNSf/jhByil8OnTp7Im1C7qoDUnAsrAaIv7+3tst1u8e/cep9OJpoAGGvfb9wuapkWOBHu3bYfXr98WREo4ASJbvdvtcX9/j3EaMc0z/vSnn/D09BH5q4RtB1jXwhgHaxu0bUDf7bDpW/zD7/8Oxmj8z//1PzFNEQkJUAltRwTa3b7H3//9D/jqq9eUkYMy1RACzsczgo9YFlJBvFwuTLzt0PUtvvv2a+x2e7x581VZz+PxiPP5jHlasCwe7999xOVyQWDbcjqdCCUbWYBLS988kJDgw4Kcid9gLAW4hlsNUwilZRCqarWt0BzZlznnMtdDbGHd9ie8kpowWOxlSkXRVY632WwQQwBiouRHSYmTuooiE2OvS1C62EmjSSAJOWEeR8QQcAmBpl9utvCi9Nk0cI5mNgRFbZiiC0JK0Gzz49+qHJASEKke4Vl5TAa5UJYlpYCVKyCbXl2JF3BUV9J9lCgcQJklJM8lCUz6d/nOMIBcZImurrSiQQZUyhUSIlEfOEXPxkiGI5G21P1oY2uTPgtOaqKcOCsAjIz4qneVBWji2g+bM1gFDhwJciarhauwyh3Hqm1KeBeKa6+CdgjyQVklaQokyaizvH6d+CArnzMzTWXYDK99CL6w42so9xoluZbelEedmZbuCSRY9bn0sLW2DL1Imep+EnHLzSXSu7e923XmLM5E/i7TGuvAZ1X5El4FjQudJnqNaO83TVuuaf2ZQvCgWuq6zyRDCIzwSClAgkBr1+/S0yu/k+MqoHwe+l28IjNZZm/KutB5KAgLeEUryEFL25KUqep+eiHKxRjKmlA3iivnLx0dpPI2IaW1515ryaxqJOVad10QITov2SsKMjbaGMMjh2O5ZmVv8T1BQ5XyZxkYBdga2ijEJKOu5bM4tG2DN29eY5oGZARoDVwuE5bFw1pDgmScvEgbX4zrMCddicvUGaJkkFIWEhGwaRpxPp9LcNawCmVNTJZ/ryWUido8rZQppJWNAr7MEO86l4EyUkExJXhpmgYpZ2geq06DsCYafc370FqLxjUwxsOYtQ4r93/wHjkBXd9hu9lgv9/TZ80JjbPY73dwTtMYah4N7pzlvZXLZ0yl8yuX/e0ZIXIyCjv4YnkEXhfHSKggSmvjOPLfw9omDraZ8pC22xQjS4fjaj/S81e7LXZMBJ9uuQL1vVsneqXtHKs+idh6CTDk+HJM0ppR0BVJT8nnTFXJDDXaRNeEdGw42E+kkRN4ympOFLAa4e2g3EJX6IIg8PEvyftXj98UBCzeA54WYJomxBAxL74sJH04QGuLldCmYaxERmqFLiRI4O91Vlk7F2eoJq5tvlrs2ww1xPWCUubPxkOtghIiTmEtCzuIk3ENO3/a0PO8YJwWnC+rrOtKvOKo0Bi4Sn52XmbMy4Lz+VymkAHAOJOiITK3PmUFlel7hoY2DhoatrpmKWVkpbGwzK04ZarzKrimhbYOMdPmnBYPwGNaPLRS5DxQBS3g9hVVtbFwsLRwJwCUAnKGD2uEW5c86oDn9vdyzaSnW+rHEi2LLrgMTZH6OPWHUw/uwhr3cu0fHh6w4/5rrXUh6kgmK85DnKY8T44hN7bWpB1AE7eofHA6nTAMczHK5xOJsdzd3RWnIKUKOr+VTCafXfZKramfc8bj4yPrfd9DUBFrZaAN1b5jDAjBw9gGd9tNCWYul0sxmEoB++0OjRPN+QCRcbVi6FJCigF91xYBG5JK3mG/25Y1FA5DSgnH4wt88Lh/uCvKZynRFEbiMUQACU9Pn4poC0XlaxlKnButk+Ktk+FZEGWeF4ZkU3FIct2TRgnU5FGOqcGtgLQ+OWeaZqg0nLNQKuPubs+13rW+2/c9vv76Le7u9vjmm6/x+w9/h6fnT3h6esL5fMaHD+8xDGOxQZ8+fSpooXSQyFporQsnxBiDaSalycfHR7x+/Rr/8q//ipfDE969+xnH44ECg77HPV93cTRyDwDAcLng8OlQ7pOm7dD3Ww7A6P0Ox2MJjl6eDzDG4O6OujNIQGi93yiAIw7Ap0+f8PPPP+N4POLl5QW7/R5d3+Hx4RW2/Qavtge0dsEyk/R21zTQyuB0PNL+29/Df/0W//hf/gteDs/4+d3PeP36Ef/tv/4jfJwRk4exGsN4wUOzR9s0cJaJnYFKI+NlglYZd/d38IvH4fkJ3gc4Y+DnGR/fvePgkHhdqbLj1hG34fn5gGGccDwvzIAXsyT6LzV/Y73vryb+WYvGuhLw1kEYgIIyCP9lTdRWFLAW8KoDBBloJddA5K1FqVQpQnhb1mto2paCI6yk5JjWQEIbaj9VmrkEgRQ+iczZQClPaONMsxc6DkJRAlP2Z1KGzwkxryX5xdeqsX/+8dumCOY1y5ds/HMI/0sM8vr1FEmumf218y9ZAR8t6Wsy2pe/UKKjNS+8rjFSbT1DsUIZbSCqu6esoHVlmJRi4QdbIGn5LrCQNtLfrNjppNI+tiy+BDYkBEOBiVaaEJRKF2FZFoRIsGxZv8QOP2oAq0pdWWutoXJG7YDL+oEYqFVFRfx7+dxrlV6y7vUXdSmmvjb0a0FQrqcyUmVEI0aqI6rC1Vjr/sLol9fg5mrJtZIIXYKrugYnf5MbOzPSQesfEIJmRw1GJFT5ot8lRnk86ct7khF2zgq1lLgDnkholFFw6SMlpBQg0yCpPq/YqeeSYYfgecgH729+nffUE240tbY5a9H0JDe7dlUEhACsHIx0tYY1ciafOUYpa4nYEL2fZO30WaluaqxB0zaUVWtdrpNS4G4KaXslBIPGm1Ib4NrSm8ueUchln9FxMp/v+lwxAPJZKKhuSimtaVm5kV9L5yx8ihUJo+SCkIsYV+lw0tm3xSgbY7DZbpC4/arveyYTDki+R4okQSxOous67Ha7IgcrwVjpBsgrjyJy+5cEZULwdNWI1zo4LXyL5bpdbVmWQsAs9yDoeseUEAPtf+99yXSFWFk/alRNzkmutzY0UbNpGjQWsIak0LfbLaAMzud1xHUMobpHqYSXEs/ysDRd0LlqOiQUcgLmecJwGXA4PCPGjMb1VyhknWkXsivD4/PiEXzA6XzBNM9YmAOgFAg1FpvG155hXVzX1m+IyjkXxFkSGVmnuo4vTj+XvXxtR1e7+XmiI0FB/doVkSyGsyBrgkABNOkPlttQjWYkVCFH0cbIgJK6P82jMKKdwmuQGCEQxF3zMKUMKVevvvXXPn5bOSBGSJ8mEeZWNaZCZMsruema5HRNvssMB1xdRPl99byIhIDP4ekV9q8EgzJl0GBAvZCiQI6RDPYaLU3zjDzN5Twl06fvFvvdvowENZYmyK0XHYhZ4OLILM0F08Qz6lnRcOa2GVmPqNbMR2DXEFOZfaCUQmcNemHFpgSVydlItFoTrz5z2gCRE/Pnm/g6MJOhF7nsF6UUnKU+8ToSlnWX917rY0wUYucegkZKAguLQ1CVg5GAbDX44lCsNSUrTSmVMkANzctNCKCq59VkswBRb6SpbfSeooEQQkDKEdM8Ypyo5pdTxsPdGxhDg3JSDBgGXzJYYJUYrSVhpX5fDJynGuY4XBDcgt1uV9CQEAjCN8ZgnshZbbc97h4e8Prtt2Vsbc5slGMoWURGgrFScmLDxURHqXGSrkMq2XIIHssyYZw0Uo5YPE3DbBoLa+8JQvYzUopUx0RG4zS0skixKW1q9X0qbYl0M0feZyQSU/YXhATJhNCCWTIJMEU0zmD7cHdFZARQOg0kQCMDiZIdk/PVpIbIgcL5Emj09jQiZ/r8TeOw3+1xd7fH4+MjloWuxeV8wTRY+CXj/fv3xSnvdjt89913hcR2Op3w888/lz2+v7vD/v6uTIqsM1CCvq8HNMn9cj6fMQwDPn36BKcttu227CPrGhjrrmWHncO8zHy8AK24x5ydjvce79+/x/39PV69egXDa940NGpWMttpmhFTQuNatJsem82Czjl03RbONnh8fIsQM8b5A7xPOJ5OuAykDaKVKkjbOI5oO2oF3PYd2o6UBo2hBCSmhOdPT3h+fsa//vO/IaWMx4c3sNaxgFAudewyHGlecBlGDONUxnPPi6fggMnj1hmYLLNDau+ji3+5dXBrcJrWWmtl965Lbuu451s/dfVuehUEWstdK+FX7KfYKUk0ASqbB+5MIFJ6ZP9C/sM1FARQCQrUGs8IYVJAYwyU4fkTXNJTijo/QvCIwRNXMoOJxqRzsiwribbmsv2lx28KAiiCWh10XUcRx4j8JSSAplLRv1G+f4YAyN+vgoAI5FW8ZiUmEv+gMPxRM/9Rnh+i3JzX5YKcM7QypeVCc63dGAMINMRyrsYYmFLukPHERDaUY85MFAtSjuDIl9YDBTkQCV/Zq0n2beHR172zXJ/OhKAobg2rkYDbSDRX63Hl/OnS3LyGMzhBCZCh8fnmqTf9dfQt9cB1ZKox1xG27JF69OcVcxootXa5RnVG9UvRuS6ZbM3EjgjRAyDSYa6z+7hcscQlUwOAEMWw++q8qXQAgDsQ1pq4OGlfAjdu21MGjqVrCTVSBSGQWrpnrYIYI5cSiJmdUoQxmsiKIMLidrtByxLFVK7iDDh7GKW5HbIpwYpjOeEYSWWPYM2AaRpLgMtXlM4HGSlR+YH+JuULi7ZryjmWmxKEDMiMDUFY1qCPJaP5u6KNJXO6oDTJby+e0BdjBJJNZX1SIhEtp2XSH024M0azk/MVs38lH8p9uCw8/4IDEaOp9BTagHkkNOLx8bGgBLvdjtr9rEXG9RTIZVmIBBpWlriQ/W4JhLjJDsW5d12H1rW4396Xv2+2O3QdwcXzPJWSY4iRMz/hBNDmapxFCDSrXur+UnsWoqCgEj4GqFFht9ujbRwuakCwC7Sm0sMSAhafcDyeMM8e4xgwjCPmmYS5hG8wDANisgjBwtoMpRIUAun2aw0ZlpZTwjheEGPGtt8hpwSjCO1KMcAvHtNMg7IulwHny4xhWniwTijIqExwVaWUuXb8cHiJul++2KWUkPX1REhBa8Re1E5eggBJ9urOo9qvyffbrpsa0blFYkRkLBb0gxG5TBMOpf01Jvo5Rp61QRkqtCLpY2XJljSO0GjxGUS+J79itIZRNLGTECwqHdddVL/28dumCHqaViR2Wd5sJYmpWrmwPIQwRgu5fr8tBZS/V0FAih5RVUz/2vFXX7FCH+XcVlguXcFzNEPAoGk0HKMFzjlonsQFkGM+Xy4krMPsUYlOU2Qp0Iohv3jPbVCk7heYFAitoZSBtTx5UJMMaUgRCQoxkxY6oBn6UkVKWODx282pGVVRNxFsCZyytKvVSEBm/QrFBERx/NfPy1Zututjyr+/FAzUKAFwzcqVm0zWmPbRSqarSYQyXIkcMsHs5Ew+v6HXdTGrrHLgdj6XoI2CYVQiRI9lUcwBWDCOQ7mZFRSWeYbW6+xwupGkDq3KDS5a9vM8YxwJmhWHsNuR6lvHI4b3+y1ncEshFQlDvgRGTcuqeRQMGKPQ9x3alo+52aJxjhUh6bPRKOAApSy6roVzFl3XIARy0CF4+LBgngGkVbxJOgiModq7aLB5vzo2+owRTeOw2214lPJY3VTUqy1lgxXRkWCQFdEYxWBdLujCeyXD58cZQIemMfB+KVwLur8p0NKaCHjz4jnLNwgh8zTImY0vITIiCOV9gverBDXtSYOu7ZBTxvH5AgD47rvvsNls8N1332G73eLt27fwwePp6QnjSJ9XdAEOxyOgFTabTSkLbjabK56D1rrcMTnT++/3+yI6s+t3+Pr127KMhsuJgi4QcXRLcwR4kiEhrFQC6voOPnicTqQYuHZkKCqtYIeXlxdM04Rxnsr9sN32iOMznJ5hTIuYFJpxwjR5fHj/EZdhxMvLhdrRGIpv25amXB6PcJNB0xgo5ZFTB79QYLzfbQlpRQZyxOl0RPQJu26H1AZYbRC8R/Ae0zTieDrjcDji5fmA8yVgnEjMJwtYpADXmBK4caaD6yBAaoxcjqjtf0rUWl0FAmIv1vtZFZtDa25Ro7+3kL7YmTrTl/KJIAR1qVhY/taQdHMIHJR5krVWnLRooxlNWNHszEhB1zpAnLgmrQirWbqaAwvPPDGYXBRmrTG4DEd4vyIc9m8VBEi/tCxwHZXVmeXq6IXMJ3WRazRA2vOus9j1CRmAygExr0pcufAJrrNeVAFAhW+Tw1cVdK50cbJrFK+LTCppbzNMHVY4yFhbSJDeBxb2iJzpCGOTPis96LjS09s0tFms4/pNIOdPilKJyhiKtAaUrlInRVF3BgoSIEbithxQ1jKlG+dOK5JqJACMDACsEEc/xEDfb7P5+n0K87+qr4mDvq21SRBQR9QCqUkmLq+pWdkCpUkUXO8zccoUSOriEOp6YIHwYwAWci7TNFN7WyDIXWqcKQeeEEjrHGNGzhHnS+SaGxHxqHfeQRv6DDR2OAMqwbK+OkDSt+fzEdSmRASdrmuQs0PbulKm6rY79H3LU9G4hzqtgVEMHnNOSDny5EfKrh3PDU8p0FhYJhwty4zEn9kohWwNRB8h5wgh+OWsgBwZZAdIUtKU9kaFzJB+RgxLFXyx3DR/lTZST0jGMi9IiTQxRAWUjDC15BprgJirrU3BaUqr6JI2Gjop5lHEUibp+5Y7IC7EsOcMSJyzcAVWfY3IpSCNtuuhtcXbr3fISeP169dlumLOVB5Y/IKXwwHjOGK73ZLW/X6PkKiGvSwLjscjf8YbRU2lsLD40+l0Kgz+nDO3bjaMfFDQEFksZhxHIvPt9mjbFrv9FoCqWP7kMGTYlbD0ZWKirC3QoG1puJPnvS0GtNts0JoGl3HCMC54fpkwzR6fnp6QssLdwwOapsXu7o6dzIJxGnA4HLDdtEBqcT5lBD9Ca8pUkQKR4BqHLUPWIUdYQ8HQMk2YmdA2jiOG4YJpnLEs1ClFtgzFKSqtWPdgrfkrra9telXnLr66BAEZmRVsawck+1acvDhdCYybpqlQ7M+VBW+TXHltzuvsEgkCCXWmDh0fPIZpKmiAsQbWcbKXFZX5sthSBWVcGQ9e1uAm4UHOqNvZFcTfauaTXIt1GfvrXftv0wmYRVu9ljVdoyilyEkLgaFe2IIUXCEBn5cEbuHfnGga2pce5bUgGB3lpgRWAY21tpNy5qxkFVexljLzxHWoGGOZYOdgSjYuRjDGiJEvcAgB2hB5w0grm3hcDg4s/55UvgyUNYxcUPZvLGnBw9Rqa7LnxVoyIKbl0NUYSpFxlvWQr7I+Mo625hKUU/wMEUjh8xHAt4GG/E1qo/KQrEyuY80fkK/6eksQIG1S9U24lgPk41yXmSQIEKjQVQp3crMaowvUviwoJRvhETge9xxTALWNMpIRA3LIGKdUYMOGYXnrNJpkKSNVRIIDEv2+MYCi/u3DcSrr5JxDv2mv9lzXdTCuhXYdXLDwjS2IgayDDx7wC0IgeNvx/HDXWGQmleZMc9+lTCHr5oxBzg4xUbkhMzyf+ebLWeB3glMVGrqTcoRWmSHfhOBnJotZaGiaC68oWAC3mQa/EEoyT4V1vyYLQLQccHsNqyystgWyh+IgxzRwjeVgiFCXlBPO5xM7xD3xALgtT67JdrvlbM0VjhDYyFpL+g19t0XXZjzsdzCmwcPDA0TVb55n/PTTT5jnGafLuWTxsl/nZcE4T/jxxx/x8vLCrZM3UsNAqTM/Pz+jbVvc399DSg5tRyOtZQ+N04xxmnG5XPDx48eCIN3f3aFpG4zjrnRgLd5j5PJV01CZSMo74oRoP1GwsfgZITIvBxmb7R6di/jw/hNN53sZMM8BLy9nbLY7fPfD3+Px8TV+//f/gHmecDod8c//+k/444//jpy20CohxhHncwZygFIZVmX0XYe+bRG2G3Sugc+eatnIWCaS/D2dTpimCcP5jHFcMM8kMlXskQFsQ8JJMoQtlCDBrEFAzmQDq0RSyM86CxdAcaCriq2o2zWBFaEUJUFRAK3txi0aIL5C9nTdjVQHASv3Qa7ZVI7VKJrRIs5JZufIeTZO5JSlKMzlD0Fta9+YBXFdP6ck4JEXRfzOr338Nk6AX4iewdrkWmvA5BXCKXXuVIx6zrgeDFR9zxX0T7WRa2SALjbVCeXxWebL712MWw1lVwEIaQJoaF0xOgH4EEsT6pp90oXf91tYY3lYCrE3aT70qiudEZH5WDlnGtGrRPs+FU15qgNRlJoY+o6JRgMXHQO+/tSk9fkEKkIXvoAE1PDLzfopgDNAgcsgnr8c9/r5WZ5QsvnbwAxY3279W0bODgIJpySZmKjIre2JipGGwKS0lAyURonMc84FPai7CepWVKrffz7Zaw0kq1JRxdwXRwmuyaUckRYirtGNKgtED60ytHIwGmVAR84GyImcoQQlClBSC8soGfRut4Oz9Ho5hrUa1lBGIEOD5DJqTR0JBL1n3puUvacUkJWC1UQq2u42SDGRzGg2iJGGDZFTBWKizJna7mIhfSmlcL+nYUOZySlZ2MzRIwaN4GdE75FCoKlmhobpGAUYBVgaRQANBViDqAGVHWIycEY6ZhhtyAk5JsRIht+0VMP0Yca8TJjnAa4xsFkj5UBfMVf3fi5O9Ouvvy5O2FoLZMXlvoCcCP6X0hPJQ0s3QUZc6L45Ho9X93vf9+g3PV69eV1QGmH/ZwX4GCqex7Uqo/xe0ANxCJfLpbyHLQTVNWNc/EwOOzCHxWo4/oxUFltLK1TyoeFYWlN3gzYGm92WgkpDhMjHVw/Y7rbwIaDvN2gah83Gw2oPZY5QOkJrB9dYvHm7xd3dA/7u9/8bHh8e8cP3v8MwDmi7Du8+vAOSMM8dUqTzDH5EThHPbYu577DbUAtr3zSwUOjbhmzkPGOZJxxeXqrW2oy207CR+VBK0eRJLo8qbZBBUw5TplkH5V5WgGLmfLk3M4CUOauWgT1sD6upqrfl0hpplKD7lgT9pRLo7d/Xzqh1r6dI3R0ACvqgtUbTNmgYAdRaI4H8ggTCbdtRUsMREgWyEUERq0nsu6DAmrsnchZdAM7+jbTmX5Nu/9LjtwUBi+dRqhoqg8eVXrPUU0K1YCvkvy4qSrAgi1z+UH5fQ/7ps4uC6sJCqfKaugwgzyWDQWUAo6+z2gTAxwjEz/uWrbE03UtGheYM71f4utSlUyIDymdAAYFCCNK/SeOLSTAoIUcSslhY6CMWZUVZglToVTWsXj6XuiYOSiZSf+Yrp118WtUKqNY/5ryGTez66xd9MQCof399bdY2NWkVLCStGqhR9G6UvQIxGu6PdZ8FAfWNtqIHmTP8VAIb60wJLK7qhXmVA6YggHgdSilCABJxAnJao3s6R0YGDJVjCmlH9nq2BJ3T4kMryq65sILE8smtDDTSxJq3RsMa2osRuchJl+sDUJYNGmaFQsSlIFQrBRgHzXKuKUUoiOqZ5pYkmrURo8c4Djidjkgpln2stcam/RpGtRw4Z2L8J+r9TkYjBc9fgQjZKXIQsAYCSlPxANbAJAWtGMHgcyat9ATvV3TD8mCgjATvZ3hPgUAfOw4iI2RUtpQbAJTabN93hYhb7vGY4VPgIMqUiZIrX4D21RgSQsisLpnLvbzZbNC0De4fHsp1HwaCxJfgS+nBOVr3+j6TIGCz2ZQSQM75Sh9/25OMruISSmQ5a5op4gFWzxRSqTGaidRkVSgIaHF/f4dlodkWxlpM00jX1CW4hpQwwUPOpNTVtSMUZmhDEyKVsXBGY7t7wKtXb/D99z/g4eERX3/9Lc6XEzKrMyooGMU69SHB+wXTOCJFj6NzCMtCOhaWygIGCl1DwdMlRYRlxvl0oBhWUT28bQwSa6TEDC48kd4BNE0zhTKcFElXFWiPSgBQAm32FykjlQyU71m9ojRfsls1+fg2CPil518j2jUae11KEMGfGvVrWsfzMXKxt+S0aX1d0xAi6T0niRGIQECCMCOMIiKg0iSVnMrQLRQfXJe4/2bdARnU94ickZJUqnFjqGsk4LquXBx7WeB1oXNe4etf8DvgN7vK9m/PsPJwJTpKGdcXkv5KZI2qZnSl+KU1ky4skT2QQexolGESWpuCAkgdJ1RTrwS2yVkhxAiVEg9+yPAh8D5WPAFxXYcQE5YUy6aSWQVl0wEC8rNzXQOAX1yasurq6neq/IaO5ayF0tdjlr8EldXnI/8WJyzPrTkCNdQvSEbhXigF79ebsX6+QPTy1lIzkylzIi+53shEmrv+3LIPsRrilDAv1G8bF6phy+cQEanNpi9qdFqrwomhr/UzKqUYmYiF+7Hd9kwY3AIAzudTCYjLOFNtEfU6gChx94FUtvq+o+FG/H7LMiPlWgt/JCTAL9SaZy3pD3Qtgg+I3oMYy5pJdA21YBlDAiV+Jk6KUkCOHOyQoQ3LghQDjJD6KPUCuEQQw6p0RtcUaA21hrXO0foaxdwJj8Sv0wqY53WwkLTSpRS5hkykTSL2qUKSFKKd1qQFIcIv0iYpho9U1Uj3IcYMZBZW4eRBV4mABAlSUpDSH42NnnkkLyFUb968wW6/x/F0xDiOBf6VPfDq8RFbJl8KElDQhAy8+/nnMjRqmhdMy4x5ntD3HTabvuw150hZMmeSovXek83IDV69fsRwGfD+/YRxHPDu3c9l79zfP+Du7g5t28GWWREJp/MFOc1o2i2s2+D16x7WNri7e4V+s0PTdlh8xI8//0wkvvMJy0KcC1LSnGB0hNYZzlpoZ9A4C8fCOFkZPNzdIfiAbd8h+ICpadA3Lbq248E+Ms9lLUUabaChkJXlkifb0kw1bqVpL2aZUaIihBcgjrRGkBNW6NzYawRAnLvYmvpaS0BZJ1x1ACFcArFrdYYP4KpMgEScLqMpyJfgURBG0fMIgThlhN4lGD1TEChlCx8QQT5WATCZBMK0pX2tlUHC6h9yWtvhxR59KaD5pcdfIRZEU65STtCJormr7LqUAOpMdh2n+kuBQG2sb971JnuvUsqrZ12dKACQo2BmpTgVUl5TyErBABRdqbWNrY6mjOZhQcz+NYagWqrHUQSbMndzsxoh+KIUB11qWKmUH0QxC+Dal3ymvDrAgNX50qaq4CyIbDIgdaGCGOTbCLjOMAVMqAIlSBBAZR1j1pGydeD0JSgMqNTeqoi4zrI+h+nX95egIDDj9VbO85btW7+W1PwUE+bWFtA62Kj3lASYVDoimLnMnPexwGtUCiKnSQZZjDIp4tXBiZRolAJDzorRBMNkMKr1Sn1XtPcJbvaAcci2LVlmZAKfwHnOObRcIkmJ+v2pLTYix8T1aZJONcagVUDTUEscUkYKFASI+I+1psje5kwT64zhITS8VpqhR2mD1JpIgEqxmDUL2tTlKMOSu9bYq32QUgCYzCh90CFo0JwI4g6M44BxHKDUtVrbqtLp0DRE4hMm97IsGMfxao8oRsjWliqSXg1lT2Qo2LL/lVKs6+8KX0drXeDrWgVSgpD9fl8ChjpgVUphu93i/v4eu92udJksy0LOIgPH4xGXywWHw6GQDQlFaPgzulI+ky/naMyvoAS73bYgbMtCYlcr74ZJkh1pbgQWlJnmBTHMaByVRu4f3qBpOjw8vIGzDayjwUbPLwf4ZcY0zwieOqjmmdQKN71F21CngHSGWGOId6I0tpseYQnomgYLFBrn0DiH1jU0pTVGDmQS6hZyaIOsKQjInCxFSUlE70XLLAARrpKEJ3FFgAWCUi7j0Ws7UdsZedQkZWH8y+M2cZFrWScsdfJT+xVx0EqRzLXwNWR2Ss5rskI2lTvYgkfOpHiYwbX9nGgiI5j/ACCbdfS4JNu5JJ2EEAg5+vYz/7nHbwoCnHXlRtdqrdWK062AYVS5anE0+UvfFUWJcsnqGnQGiY9kpanWzuYK+BIcfe0sCKqzuLt/KD2287IgVCL+tcOnbC4igwRUFBTSFGGNodHB1QVfKiELY+lmkL5/tWjoQKIPALFeV4QgY+bMIEMV6UiiCnBGm+imSXG5gsZTBfEUZyoBmKJyR9k1IGa3QNUSfdcGUK7J+rda1+FzkqZsKrk5aude/02eWyMBEkTIDSXvU7fO+SVhWaS9bNWOr6Pu+gYEOEOGvorU6TWA9wsIVo487CoW6FvedxgoW7vf7mA0jWpWoFr6skw4nki+9Xw5MUyXuXXHoGG0IIRUanYAkDL16sbYw7oFIhs6zSNBoi3JJb9+/RohK8yJZEKbpiEW9RR4hntG4ywKNM5OHwB2my2hNo6mL85Fppr02zebDsgRwavStSCoiVzveaGsvN90sM6UjgOolgPfBGsV+r4te0gkj0kHfybnrliMRSk47rs2RgEZ8EXff9UNMEahaSyj1hFtcEi5Jf7CSFKpMVFLoHWk/kecHJT7eFkWDqookCZkpUfTNOW5tL+YNFaFulrrMhr6/v6+OP4QA45PpxKwCRKgrfmzTOvL5VKy5q7v8fj4WMikRWU0E4EtxIDwxHrwzPrfbDZYlgWHwwHTPEMphQ8fPnEbKl3vdkM6ESLT/M23X+N0OuH9h4/FJlG3Q4uYSIBMFOv61qHrLKwlPkOGYgoUZd9GO6QYuO2ZgmnPCMZwOWAcz/jdD2/R3+9wf7dF3zXY9V0hs2VkPLJcMDIF5a112O92+Pa77zDPC4ZxxDjNGKYJKmaElGmUujZQxvF8DBQuACQjB2FPoouSBTK9KlXmq7KBUopl0tcSYj3uVzLm2omLzPutgBUhlP7qZ0GB5XkStJKehkLIgUcJ25KYSItgZmfdNC2gKJEhC13V91NilchM7eU5I8UIDSBwUmq0gUwxFU6PdhqKk9SQIlL4Mpn+S4/fFARIdgyA2Yw3rjevH0jiAygJA74UALDjvP25+j04wi8IwBdqBdcoQwVZa1UEIbz3CDFBaV8hBTdCEnmF6pEzTGJop1pQgZKlM0Jz3UxzpEfOnk9VvCyqiJG5EjIU6WqwkpK2t0y12JvM+4v1fv4HKf8JElAOVz7n50FALgHVyjnA9fH/wuO67p6ufl/etzrv6wz6+vUxZp58tZJ9vhSM0DUj2JCygXqQUU3iCevPzISvz0cygOAXqP0exppS3gKIv0Hz6tVVwEN1W5Le1VohVccEAOUV199FfIaJodySKNK9m+0Gc0iIy6p0N890RQphKQREa29KHQqi0AilEbyiYTCM0imFlU+hFbUnWVPUybSmlqwYA4+9Znll/rvLhu85kem11XVISEkxXD5BiFqGy2opRRYvkYFaq+zxCtkr0nDICinRFMkmOVZW9NzOKMGFZtZ7WwymBIcrX0AVMqB0DKza6jeoDdsiQQA2mw0AsIxwKoqAtZiUCCPd7nEJbgXyXxg9qNtly72WM0zOLHi0ktHEIaVEjPXI9e7T+YRpnGgglFZ4cAbOqaKLcH9/h8UvZS3KOSxLET0S8uu2t7CO+teV0oWEHPmccl7Fzwp6mxgmZ8QlA2XWx7ZvselaOGPYSWd0bQutNJbJQ/F+aB0pGVon01OBJQQkcNlJk1aL0lRvShlE/oP4gpWdRKZNMYpX2xgpFaDkomxuP7M7wErWqweSyR4xVZZd3++y14QsXrcc1vsxRhKGQ+bzjyssrzLtAc1cBWP5c0OCmFDmw4DvMzDii1zbtIhkRFqdP1ftJ7UqSEL4W5UDnCU46ApE/sxpcItbBhSPeqbn8V9vHb2q2gszIQNXf9ek4PclBODa+F+fRc4ZfvF4fn5eN4JCYUgDuLpRxZiIpgByRlx4yl5YpUIlCLCWYMoGgJEWD61JB0CRGJAw/8ugmUiynhkkGGKzhUvSokKKeSEEwAeg6Kdfw+cigYu8EkyuVr/KtOtSilLX/AFdAoP69TKoZl3nWxZsve5yk0ikLZl/fR4SbcvNBOBKoasYROUK0S3lWIhg6w1Xw3OS6TPECOkOMAB86c8tewHkMKTWT+uSuZ0tYLhcCgfAsKYDrTc5E6o707Fo+iC1UgFgQliL/X7HTojg9qah63o+n/kzuwLJKwWugQ/4+eMLHh7u8fDwCIGoxXj0fYeua2k2fFihyK6vAlsf2IHSfIKmsQBewxiC/oF7rjdTbV2kr6fTATEEGKXhjEXDsKVjNbCcM5GRtIYPHstMyoEpRjTOQm17xBA4cCbZyzKR0tFce9d2gAL2DGNHznLmxV9xL7bbVAZvdV0LpYBvvvmmSPoS4Y4MrNRwnXMs1T0Vdj6tf0fDzaJI8K5Dn+73r7lbgDI3IQjKmOVxGK5KHU3TYLPdYrvf4cOHD3h+fkaMqUwUlLqycw7D5YJj0+Dl5QU5ZxwOByjFMrwpAYxiTNNEjpiDAkIMKDh6fHxkXYEO8zzjeDhh8R7ny4Ulhqm89ObNG7imwcePH0lyNwRsNj2XNUTlkkeax4jsE0IkG7fME7S2WJaMpumwvyOC7TLPdB8ZC+satE2P7WYHozPefvUVvv/uO9ztenSNg1GUsZ4OB3iek4JMktnRE+pmrMbd3R5t19Fo4c2Itu8xTgumxWP2CSHS9FMiVlNpwTU0DntZiBiYC7pZG/ebH5OU+YgboLAGaTUSIE5cCJxS7pFR0WLD6sBBnLzYLBE+k+NLsOi9R9u0uN/dk+S1ldLTSvKWco9tHCNQS9nPyMS5UGznpWVZ1ATF9hHnwKzBiZKgk+y7lJnn+W80QEhzBllfA3HWnwUDdXaZbq6bJPTVdwqfcvV9jfwKqoDa6UvUeBuESEBAC7ca8Ov6pdQQaye4RplcT/QeiWcOpJzgo0DOaWW9Gg0THdVOtSoRGWXkuXwkZLD2Op9jIqWoJKQVKBlwwAtWTdICISzSKlYPphBGvjxPomj5+ZceZdlz9cSckWPi0sv6LNrMJLpEwhzXWfo190PKAKv4x1XkilvpYSb/GIHHFJA5YyykQHl95htkHX2bRB1RhIJK21AqkWfKJD1rGbZWisVwOM2goT+AUhvmX7B4kdTuZBSqIswFCjTGNKXCSdhs+oKEIa/lk8TiUcpKlE/XPgTqqx+HM4my5IiVnAco7kpATjAagKHOAs1dBlprwBoEQ1l9DJ4JezT/IKcI5ARrFLRyTLAT4SM6bs5UOimdD5o6EDLvBcW/jwqoBbeoe4aOo5JkPywapCP6rmXYUhdRGKWIbzNN89U9SaQpg0U4EUlq7Bvsdzty7q7BPPvCqzHG0jjeDLhIATmp8HHbcgmaCd5eM3MQC5sDbJFwFgTilv0t8LCQNqm/nO7XltGEhacGTtOM4TJgHAZk0EQ44XUgJaRAU+QyB6xGS814vU8a7mrYbjdw1tIgoWnCy+FQCKFtS3/fbjbY9D2VXLyBNVQOzMwfaYSQpgnVoqEzwDQHaBVgzIgQM5p2g5Qy8xeofCTcIApkO0IAtht0bUNtsjEQ7MyqgEZrJK15pgV3BSkNpx3EiGexNVSoREweKQW2Y2xLee9nRja1kixfsv7VSl9bfbJ8q/T6Ncp4+9orm/+FxKbmIgmqZIw8p0ANEKtMxySbRwO6aIBTBl0PlXP1PMUDxiSZRhnHLGVxKY4Xq86ciZQF7qeusshS8szcLf7yFrX6S4/fhgRgwnSZQPVsGpHatB1CItlJOknFi6DXk000J7uERvIRr2BeJh6p68ucYkC6GSYhTp5fCFkr+p8uTi2rhJg8G27FSoHS7tPQBDNnS7abmNQXIk20OroZ4A2RUkJaFqQQsDBr1r8cyeEZg77r0XY9urbjljBuK7MOWmnsN6RONk+UtY3DgBQWLC9TKSk4o9Fbi5gVwXXSZmJElcoj+wV+mkjFjFnKiJE5AKrET9Wi0DqWAGSNyLLcndXTa4nNda3pjwJPyZGvrpfKZeribr9H4xws196iT0gqwiiqCy9zIIcRFXIi2CiGgBjPzK2g4zaNxTwvrBRHozy3my1F0Qu3yFTn4v2M8XKBUgS9NQyzywjPeXjBmCK+/eZrbDdbhLHFYCIfS8EmBYSM4+m5zOUubN5IzqLrOpo/DwUNg9PTES/xGXkO2Gy2RR1PMo7f/e4HAMDT0zOgAD/MmJoL5vOEcTojnZ9g7y12eo8Pl084vrxQj7dr8PzzEwDg7//h79Fvdph2ljoI/AW2afD9N2/x8vyMd//2Ao2MXaOB5f/L258+SbJk2Z3YTxfbfIs9M9/WVdVdNV3dAwJoDAiAhMhwhv/uiPAjhJ9AIQUjMxgMprE0uqur6lW9emsusflqq6ryw1U1t/AX+ZYmmiYSGRkR7ubutui999xzz1mzfvsZ+92O/W5HWRQUeUaVXzHPZmy2D3RtR6FrVB7I2GMJzIqKwTluH+4l0GodYVxZWotMkRUZeVGw3W6pDyIhroLGlBbnBn7zm9/gBsd/+w/+HKMUfb2hH8Tpbzab8cGrD7BZQNkuWuS22EzIaYs8UOqMfd3iQ+D66pyLi0sIUNct9/eP7Ouar755DQHKahZFmKS/r0xO2zsO9UHY1UNAqUy4BUYkdvu2xnWNtAiNITmHVlVGlik0MWD6o1DV0HfcvX3Lbruhaxt26w2b+0dKm2HQGKXBB37/6e8oioJ6f8BamSYq8gKjDAHH4Ft0abn+6BXL+YLFYkmW5Vib0TYtrXN0g8cMARBfheXSoPWerv5cKr/O0Z91XKxWnM0q/uGf/Sn14cBuv2O32/L6i08lWFclL376E84uztihqAfP73//B5q6wSjhKsw6WMwXVGfXtF3L3dt3ZFZRFZa2r8kLy3y2IjMLXl6fc7la0NRbDk3LfrvF9T1WacrMsDy/oO8Gun1L1/f03UDvPKEfKDLFMq/oyoxuVrLeWna7AxvlafRAF8dHhyAF1+ClFspdj9QGGh+TA68CTgVxlo2kdJBCLPHUtNK0/cDg3bi2ZTHRkvF6R1MfxsQrkXJTguucp+2aMXnwIU5vOVFc3dYN2eBGTYjZ8nxcHzNjMIUVVBfH0A90fUff9fRx1DSZc9nsiLiFIBLczhsUCk8BBJpBSMp5NQelGJSi955tEyBkBGPJM0nuM9Ng1DDGwyNF8vu3H5UEWKtjphaOc89WE1ygj0pPSfMm/d8jbnshLdcniEGK3dPFfLoFTjO1p6hDCnjHXndMNFIiEMIxRwyMlfTxa5qISFlkkL6ozmzsa4LyCh2s6GUbDV5FmEesP63L0ENPZi3J7IT4eaQCkcrJW4Mm0CvFEIRVHpSW96jEOZBIuLLxGKcxrWGImb4bZJ7bRbnbbxk2nBzDSZb7Xd8T63T6/FOE5+mPqdUwyfKDfFYbk5/xHARpd8BER8KnJETwJamyjqOkqQ2QlO2ciwlMSIqUx2skcVGm8r+EVFnIdSiVkiMziiK35JmhsxrXCYIgMsA+ZuZRKGn8vVRq1li0mpAinVgP14caAuP4kYk909RnbeLcuOsHYV+j6LoDrm/o6j377YZ6t6E57NDB47Oc3W4nkOOHLykLgWGVCnRdC8HRHPa0zQE3iC1tkefo4GkOO+r9lsNugw5zrKrwQ4sfDGHoCK5jVooELUFIqEPfIvLex16i917ea+yDEqSV4py0HrKYnMoUhRjLBAaGrqVTAd8PONfjug5n7YhUKD8Qho6ha8bqzyiFtoY+k5HexDmSdpMfSWtt24LS5CUQp3+0toD02/vBxf4q45SAjA1qNC761CQkJCn/pcpfo4PwIxLy1HUyH993vSRgTlQS+67Hmo7ZYo42No56GYZ+GM85AepDTVCOASEE50VOOauYzUUiOOXhzgkXyUZLXYGPbSQ7lgx9L9BvvK6ttSznc5HqVYG+q9nvPMEPBNej8Yi2lSFoaPuBQ9uJzoM2eC/EwLpt6ZqWuqkZrEaTCTF6FOaRBL3vO9qmjujVHjcMVFmOtnJPkEHycBhUvIa8qEMZo8iMRmWWwlr6zFJYQ3AGFc3lVOQpBCfnJrLAxvOTarsw6buP0UKlajiNGYoeC88hvkHWmeQfk1oHI0+JqVppiK60amzhDIM8V9ayxKWJr2NS4pz4X8M4DphIzkJAf0raS2unjxxjH39WgAoKtB0/pwMGP4xJjFOiHGsCT2Ln01X7u7cflQTcXF9zqHYEwNocpQ06K6iblt7tCYPDeRmVQqnxppngzT/wlY6Ps0ajzNFiNpnMjOSguOuR9GGOUpHSD4rMdWnEopyL8sdj/BkXbVEYs+RZgdLys4+w4XQcSSfSw9kUQpKg1KT5YmRhKbI+jh/mR7SBY8V9VEMMI5lNhacEumlvK1Wm6f/TkbgEn6f39OSIfk8CkP7/vud91z7TlgRcFovFE+ON1Hs7HA5Pzl0i3Iie+kA6FInIeArVnfIf0pYen9jYzvX0fSsJaoTipD9bISY9M/JcRqayLMNn4F3g3bt3WGu5ubkZe4NN01DXNS9fvuTnP/85u92Ox8fHcb49jZbe3d3hnOP6+pqqqjg7OyOEwBdffEHXdbx584bUP57NZlxfXzO4hq7bcn9/z3/+z/9FeuRFPqJFj4+P47G6urpitRIp2u12w+Fw4P/z9f8bYzSL+YzLiws+fPWKx8dH3r55w3a7Ybfd4K6uIARe9z3WGBaLBWVZ8rOf/YQsz/jss894eHzk9u6evCh4+eKlKI9Zy2az4fbhVhJioymKkqKsePv2NevHR26ub1guFqzifPzsLwrq+sCnv/0tw9CzWi7J8ozFfIZzA7//7W/RymOUSG/vD3tsVpLlBWfnF8xmC5bnl2hjeXx84HG9Zr44I8tyLi7PWCzno1FYlheRpHXso45wfrz/E3mzyKT6XVQFWsHDw4PM7w9H++6kVmozSxFd+WRKoOH+/p4mssBlXC/j9vYWbQz/w//9f+Tly5dcXl6jlOLx8ZG6rnnz9i2baEuM9mA9q9UZ19c3QByL7WU0tuvE5Ozh4Z7dbjvOm19cXFDkZ/zFP/7H49SCtHRsdJETT4rVas58XnF+vhr5IfvdHu8Dh7yiDcT2o+dhfYd3HuUNs2pG6AdUCPRNQ2Y1Q2M57Pf0Xcf9+pbd9p6u2fDm9QV+aMTsJratMmUpsoL5bIlCj6TMZBG8O0Sjp0zaAikxG+Weozri4D1N1ws/gB7lRMo6JCQgyFSY96BNLChiUJa2rDoGfFJLLpBM2Z5f8yLynKD3mPTr2Pcf19ZYVCaI/Qn/yRjMcEyaM2ugyMdzlZ4jvJf5GGdEXrh9MnatlNiOT5OEtJ5Pp6RO18RRHE31KI6TDH3/9zQdUBQ5bhDSlIlJgDI53TA86cWoyRtNN+X7FnDZUkQOx5/jlk5MOlDf2k/s08jLpL7t+GySE9eUIJdGh3zsw6TKVKcML2i08XhjntgTT5m/BJ58zmFwuMHjeNpbNCrp9euxZ0542l+dnlTnHEaFsRI67VVNA+g0Y50y1I+H5v2JwHPB/cfs44fs//Sxp/sfq+mTz5HO43T7rgQAjpWXEHZSdh6zZC1kPBsle5Nl9DHRevr6VVUdR8fiDVmWJdfX17H/24yKcIm8uNvtGIZhZFFfXQk57/HxcSQPTce5xK53ztlZye3tHff376iqGeUgkHYXvdiVUtR1zXa7Hck+dR292NuWPHqNe++pDw373Z714zouMn5EsrzzOBjV7bSR6ZTd/hCd89SxN2wcKrLdj9MB8Xw5gVmTnkAKLgq4vLigm834/LPfR46C6BQoYOg67u/uKHLDYiFs/7IsUVqWoHRtl8Zg85w6mnWNyXpIQi8Ct47ObTEh//b6EOJ1AS5ml4kcnHQATGYnC7zcw0zWiSeaIUZjfGwl5pkYG8V+eJ4XzOczQIkk8cl1niYTEkdAcXSk7PqeRF+pDzWdaTHKjoFIWz1eL1LwCh8jaIVROQEZIxUFzWQcFOLnld8PgVGt0ruYfLSCu++2G9FK8R4VNL3yo/BV14lb5m63oyws+E6q++CkUAmaMqIU1ojWQRoDHu/vk3vVGCFPZ6nsVRrtXGwnh4jWhjGeyPMCaepJpgYE2U0BP3C8PhUc1QVHQtZz25E79mRtUmn66DimmK6/6Ro8BvA0ChbRpUGruG704/7haDX8BN10bpzxJ446S60qiKg8VKagYBonJihoSLEsujqmT+ff+8G/tf2oJGC1WEaLQkWWF5GwIEzFNYFkXWrjwpu0+xMZLwFMaUvQVkh/SQftyXqf1OFCzCSfCkKIEhhxoU8OfLEvojVZlk/4AGIClE5kP/TR8lcW+12/BxTG7OXxVfVEUTD1jowxcTrqeFH0XU+PsKMJx/lR70TsJ1W9Oi56Oo6kjBDaZNSkyCDLj58zXXBTJmp6/DTwTo9N2n4IApB+Thf5KXHmuf8/9/N0imCqC5DORWLgpr8l5bW+70dXOaXAmCMScNy3XAPH141MmPhz3/cCI8bz5X02yscSYfQ8GtQk4xCtBV7t+x7vhOm/WCz46KOPABF4UUrx8PDA+fk5f/qnf8pXX301sstTr7ssSw4HsRb+yU9+wocffsg//af/FO89/+pf/Svath3V3+q6pixLfvrTn/LRRy/5+S9+wr/+1/+azz//f9K1HRulqZuGwQ384he/4Pz8nGFwvH79hk8//ZSu66iqitVqxZ//2S/Hz7Hf1/z7f/9/sF4/cvvuLRfnZ1yen5PZnMwWIiKUWT755I84Ozvj9dvXrNdr/uZvfkXX9Xz44Yd0Xc8Q5aybruPs7Cz+XkbFUiVzsVoxL4TF33ct2/Ua3/f8d//kL7CZYfN4x8PDA7dv3zIEj5uVPN7f8p/+8v/gxctr/vSXf8LV9TUvXrzkcb3hcb0RuLltKedzqmyGyQWNK8qZoB+7reh4hKRJkSS8xT9AzrG04vquw/VDrLBdTFw8TVWi4/kMIXB5cz0me33Xs9nsKMpiNHvJsozFYgEo9ocDdVNzfnHO4AZu391Gh7wDTVNPErSatmmkXzybsVqtxOFO9SyXKy4uLmmbhsNhz3q9Yb8/cLY6I89L3r55Tdd2LBYrylIIeUVeyJWuFWVVSNKR2SholXQk3CgtbI1mp4liVRltfaAeBuZVQWYUj7f3dH3P5nFNbTMsQnJczWcMWuE66JqaMAx0Tc1+t2WzLrDaocIA3nHYbhi6Htc75rMZn3z4MavFisvLc8qiYLveEYIi7/0oi5sScm0N2SDjnINzNG1P3w+0gwgo9X0vI9pKQppTMREMOraXj8JsCX11cWIrigtic0GBiMlpGuNNaxQg63twSHA9Bn2txNDoyVRTCE/WtKkOCkqNccsajXJFTPCSUJfGewvBEbWSRkK498MYF1Cerj0qG8ralOEVeGfR2oMySJ8jxcs4Vh2ieuqT9f+HswJ+tE6AvLlkYanxPDU0GPts6Usdg4P8fsKUHNOZ9ArHD5d+5fyAG46QuPPu2HODMeDH8DAGMTmQYK0a5YGfaO7HeWnjxK5WLFj9OCOL99B1YxKQKg4d+0gpE51W0SkApWOVmOxwZIsrlYZYjvPTMK2eJetLnyEF5vQ1VSo7hcrThfy+7bsSgOf+/2Mfq05utvSVjknSrp++1/EzpOQ9IS3q6WtMj9XkFeUe9OCiGZFSAa30ODMuOhGgTZzWSCOgCR1Sx5HGJDaTxvTKUka10s9d1z2p6lOrA46jOXmeU1VVDN5DFH05qtullomoyy2ZzeZobei6XqRUdRrxEjnb1XLFZrth6HvapsW5geWLF1ycX/Di5gYiUrDbbnn79pamPsh4VWTFi7lOz6wqKcsZs9mM2WzOYrHEBzg7v6DrOmazOUWRs5gvaLuOfZyZ71qxXg5e/C5CCPRdG/vGchYeH+5pDnsUgaoouL68JLcGHWQs6vLyAoPig1evWJ0JeXJWVVxeXsrYbNtR1/LZ0gguWtYB0UaI95XS5InXGklgqZLzUX9jXDlUMpTRuFhgOOfExz5VfCqRwVwsBnp0r58IxIQQnsyFp+u5rMoxULRtJzP9Stp7KqIcRVFwcXGBDwPtcJBrMT6n645z/kqpUeUvOUMee9RPUUOlpM2aVAVBAoDoV9iob9Gx2+3QxtA4xxCgLCqs1lRFge8HVOTHDEOP1UomYDT0PjD0Hd6JUFpVFOIYWJaoyOjfPAw0bQODp88yQuT65FlOnw0RdTAjPyZJQCulsXKTE1BoZ2IfXHglg3PRSvpY0x4RgbH0TWdmPD8JjToa0OknaMIxzkzWK8ksxuvnuIY9jVlKqfj8b6Oc04IphIBXkeMVjmZG0mryY0vZjG3lp1yE6Vo3fS/HzzrRInlyBI6Iy1FM6en/v2/7UUmAQgwflRb7w4BiiNKtkVExjiaBjHwZjgYy8uaOb1x4MZMxukkSkB5Y182o6AQcmaAxGRk1BEMkMrkE/cmCXM7mT6pRpVQcJ5KkQKHHm/FwOIzVmmjLdyIvbMwogJEgvWnAT1BPlhmMiRLJPtCrpzP23nt0ODI4kz98sqNNWb2sUUeRloQQTBGAKQrwX3M7hfFP//ZdP6djMjXPmC5gSaOh74UnkURZUrKUZl5NRJue9syS8QxPb2bkvNe1KPJZayjKPAbYksW8GtXnttsNTVOPPEoVA4nWQgRdLBYsYn97qvq22WxwzvH5559zd3fHer0e9cbX6/U4j544CfP5nBcvXtA0DW/evOH29pbFYjEqw4UQ+Pjjj1ku5zK2VXes11vKohznxPM859WLD7i5uWa73Y5z+lVZ8U/+8V/w8uVL/vxPf8mhPvDpp7/lmy+/4a//6jcUhWW5LGUaBx1tsQM31y+5unzB+fkV5xdnnF1e0vU9WV7S1DUqSKvg5csX3N8/sF5vaA8t33z1jVSdRtzr9vu9BCClKDLxQf/D558Rgue//5f/F64vzvkHv/wlXd+y227Jsoybq2seHx/5yUcfsT1suF/fcnV9zU9/+lOMzfAB7u4fGJzcf01dozOP0pquHzA24/LyhSRLw8AQeT3OB9wglsttHMmTa0cW56IQM54kxNLu67HFobW0hUIIo1xx2zX44DG7Y0843dveHwO01ppXr17FgsGz2awZIvtba02eZSwWS1arFT/72c+o2z13D28JcY1qW7ERTmhhnuXMK9FdaJrm6FgYywVrj5bc3g0c6obS5xSFjeOiFpdneJfTNg3393fs93v6fqC4vCSbz3hxdYUxlnqzZ51ZHt6+Q+EJrsP1nq4BhaxPXXvA9R2LWcW8eMnHH7zk6uoMNzQMfcubr77isD+IUmokJysUs9lMjLisKKjOtX2yTgbAOMPgPVkmCoU26+j7gabr0cqwrxqM0WKwFoIUvog0O6TiMqnRyni094K4HltfGj8tPt0QWzRRmOhJsQKjmF1qASmi4utxUzGpOBa730ZWHWKaldaOtCXPiHR9pvUlIaNpDUyFxKnWypP3oY4t5FRYyv95Ijzn/76SAJ2gcKWjZKSMXehJvyO9dBpZk78zpnTT3ksIyf/pmJVNE4AnmZqCxPI8qjalauCIBvjJSRFY+DibDtIT1FGpyhgrTNkg/SmbeoRIH9H3w5Ez4AONa0b4cAwSkSAy3ULwo2tY+hjH7C08sUwelaJIyMnTzHCKApzOMU8f+yxfgu9GCKb7+q+xpf1Ne6npgoVjWyMlMsCYVCVzqhEJeOY9vu/zycGdJFpKU1UV+Zisidb5MDjqupkQbUQSNs9zghcoNxEaRaVOj/rvdV3z5ZdfstlsuL9/oI59+wQPpvedbvi7uzvquma/b2iantns2xyOtm25v+9FHjaI2VVmhUTlnef29pau63i8f2C325FnObNqxqysmFcCNY/oFzISOZ/NuIjiQ2dn5yyXC2bVLJI1cx7uH6QlMZ/jvGO329N3ffSyLyPRTuF6h8mFHNvUBzaPW2kX9B15nmGyjOV8RlHkfPO1petamsOe3WbDw90t3jts1JDPZxWzoefy4hylPbt6M2oxpK+27dgf9qwuLoV8l2cobej7qKvQdygjlWPwXu5PJ+PHziXuRoj9XA8kBrgUCiEEGQdWxOOPtA0mHhJlWZLlIsgj57Edz9XhULNer9lsNmy3WxL/pG5qUIyCMglJKsqCPM8ma1u6ho/VX57lGG3x3tHUDaBG7QBjtAhi4YEsEpazuKamfnFqrUn/XngkItPs3EA/dGR+QHlPkVnhLswq+rbDxL63lsyEvmvReIyS6SNFYFaV5FnFcjFnVpYMfaBTopqZZ5az5ZLVciVrHaIbkBJi5wJKTVxA5WaW1qxKqpdy3wrqJTyVVdfTdj37WIj1Q+QKuGRCJEC3B7xXKBfGKSN/srY+uz6FMCIDqb8+0vKnz5tU/0/XWUYEabompWvqybr0zOufruHp+4gcqyMX5XT/p897srb6Y1IA0A9/TzoB1mqClwvR6qiXr0UPXBz3RIEsjeFoeaeCFKSvCNmFEKLKYjrYYTxJwBOBBVTs4aRxn8i2T/CpUkcnvnQc0s0roi6RuBeNOxSCAiQVNZvn4gFQFOSlYsZcgslOsun9fi/VRoRy080uQiYZhTYjNpOcoooiQ6tiDHwi1uHx7ilp0k+IVdMbfAr9T3tRx7bCcQJiuv2QgK5OLvj/WohC+kypakkwesp0pSo9QmMCg8qxbLs26uunRFM9yXQlyTx6J5wmQDoK3aTF+OzsQlAWPMbIIlrXDff3D1xfXjCfEw16CtRcWMq3t7f0vWgBrFar2A+WROXu7o7f/e53dJ1cB0kCdyolmjTk7+/v+dWvfsV+f+Dufsv+0LJcHhMfkMX7sN+xXj/wcP+IVoYiL5nNFpH01/PXf/03KAVt3aCAq6srLi4uWMznrBYLXtzcyOLb9RiluLpYcnV1xccff8zV1SVX15e8fPGSy4uL8Xj9+tef0jQNH//kj9DG8Nnvv0ApxYsXH4iFrDI4F6gPosR3dXnJZ79f89vf/JayyCmLgmy1JCtyPvzgFZfn53zz5ec8Pjywvr1FDT2//92nGK35b/70T7GzGXZeMVeBD1/eYC2sD2up9rqGPsrfbjZr3r17x4tXH5DnGfPFAm0yHtdbnPPsDzuZRtIZg/ejv4L30PctXdcAor7ngxgxKZ08E2TdsWVB8KLcODjHdrcRLtBOFCMvLy/Ji4L5Ys52u6Np2vEevLu/44svvuTNmzdst1vOz88py5KH+3u20YQoyzJWqxXL5ZLFfEZR5rRtTdd3T+6LdM2U85LMZKPQkNJCSq3Kgjyz7A+7kVtQ5DnzshBVx9yOCEfftzTtIaoR1nR9iw8ypeX8AH5AB8eyKqmqGc3FChXHZL0LAs+7nqY9oBVkBkIQ8azL8zOur1aslhWzKqdrFJ1VLKoS31f89Cd/xGq5oihyIFDvDxx2e5kCUgZVzI6Bjghqx2LOxiIuLwU51dbS9T15UdG2Le/uHuiHgbaXyYl2GIS86TzJQE2SAuFc9Xqg72U+f7q+ngbrsaKPhUZQQbhGQYmh0Rioj7bAaY1RSskoqxJXPzUdLQxhjHvPFWjpMc8Vc2kdT7+bIs0p0D9X8E1jSN8PHCfN+NYY4ndtPyoJMMZANnkjBPDSg82ijam1UUI3Kn+ZdBBUAnGOWVOqkL8VgsIxITBaj8Yk6YAlp6bxfehjhm3MERWQDoWcZGMhYkQQks6/sDNd8Ohh6iJohNMZq7LkPzDNtIJPZDRGhAOO6k9ER6ex4tFxhjQa2fjo336EvI8tlLF/ecIBSJ/3NPifBvPvqvqn359DCb4L8h9RnPf8PM7Hx9+n3qoorR2P3Wkyo2Lik97L0cTjufHAbyc9otRVCvN56DFGEpCh7+g68Ypwruewb9nvO7yPaBBpBji1WzwoywcffMB8Ph+D9m63Y7+vOdRdJPQQq60EcSVl2MD9/f2Y6NS1BLkQIWB5jcDD44a//dtfM/Qt+/2Ox8f1ODpU1w1tdBy0mciMGi2KcOkeq4qCMi+wxtC1HV9+8QXv3r6hbaUa7GKyWuQFl5dXfPjBB/zud7/j9vYdv/rVb9jutjxstuRlwXq9Ic9zttstWmuury5ZrpZcXl6yWi1ZzhecLZecn50xK0tmZcFsJm2L9nDg0TsyrZmVBdv1mjAMNNFUZ/v4gDaK66iO+HB3R1PXVJXIM09d+uRa8xEKL0kKf+m62O/3gjyabDTiSihPKiSOj09jtHL9BS+yxjreq8kps3di551IdKkoSNdyXkQHR+dF/CrKQSe2vjEmVvzFaCwj7UbD2dmKPMK+/aAjQdqO0xZ910mrFM1ms+FwqFktlzKGGfefuCRD31OVBfNZGZEzGyt5cZYU2eOWrmuZzSpe3NxwdraUaYc8xxYFs6qgLHJya8itJjMaD+TWyPHyMj1Q2ISQFpytlpyfrVDI+TvsRZdCqUgmjM6KiefQtg1910Vg7pgg67j2qRCiIulxLUiPtXFNK/IM4nellPBDADUci8Up2pxyvMTRUzEQh7G6DySS3JM1MCqfquka5x3e60mg9pF/hpj5TGNOBCB1RDmUErEpExPOpC2SKvs8y8bPHLwXuWUvLS+jkwunefJdKz22uRNqrCO/bdxXSL305EWQtr8nYmBuc4IReCbASFQ02lCUJb3zZH206g2SHIhBhGKc2SQFD4jCqOOWToh8MJmbscagJip2qYofXQzjV2oPCIFIficEnEF4B8ZgErQ/eNHcdgOu96joSV4U5dizEaQgGxeFxHRPTP4QAn3bRfGXfjzZEhYUZClBiSNMWm46pRwekaJN/f7x88c+VuBY/Y9mMpN+0WmmOc0I4dsthdP/v+/7dF/H9/TdgX/6+6S+BcfeZ+rXJxbsKdx/fL/HGyyNQ0lmG+Ss6ygi5MPJ64tr3Xw2j4F3P04F7PqeppbFUWtYr/c8PjY4x2ioAgo3iMhM2we0Lvj5z39BUeR8/fXXhBAE2m966kYkfK0B8ZiSBFMpT9M4nIOvvvqGu7s7/uZv/oau6+naBkKIioeBpgu8eXPH//q//i+kMaH1eo3WlrbtaRsxgnHDEIOT5Sz6EmQ2I7cZ89mcWVWRGUtzqPmb//LX7LZbDvs9+7Jkt9sRfKAqRaXv5z//Bf/hP/xH/uqv/pp/+2//d25v7/nJn/yE5WrJ1eUly+WSd+/u0Mqw/OUZIcBHH33EfDbj8uyc+uqK9cuXLGYz5lU5Si7v14+s73pyrbHzOQ+379g9PnDYbQU9efsG8IS+o9nu+Przz9FFxvJ8ibV2RNak8pHrSvT6Z4RodiPXmxfNhOg+h1wGRxOgaJwkwSDdoz1dFxne0VbXItyeqqpAQe+GMdlIts9Kp6kdcWMMQTQkxMo4o6qqmDiI78FiPqesKubzBUqpcUz05sULjDHRvbQZ701rRYCsrRt0TELfvXvH4+Mj1//wH3J9dcl8PgfgcDhIQucds/mMs7NllBVeEILDu56mObBeP0Z9Fsf52YqXN9fYTNqRt+s1zgfOFnPyrKDKLaU1lNbglaLM5f10wZFbw6zMKQpDWRheXF9xc33O/f0bdtsd68cH6sMOhaIqK64ur1gtV+A1fnAcur3wt1Aj6jFNAsaRz6T5FYQPphTiTosSyWmtKasCZbSMdyrQbVI9jboz6ugnY2IP34yePIIWjNBDkhSP64b3PjoTP4XhQQlz/0kiEBGF8HTd06SwpsekRJIAeZ0hykmn3v+02hcktGfo5e8pKTb6qcFRes8uahH4FOfspMjzMeGZKOXKQvrD0d0flQR0vWR5QsCTPnkXYXarzVipDF5IH0lQIckyxPV8zKLSKONY4439GPmSlsGxck9EQpLOsiL2dxRa+zEpkO+RPBHCkzE/rQwuO7oFikSwi9VbR99HxrdSccGRi8MYy6ya472LJ1F83FOwHkltqReuFM7aqEmfAlzKHuVDpt6d/O2obhW8ZwjDsyjAFC5P+z0lCZ4iAT8k+KefnxsRfN/P3wVTpfc9TUymi0JKplLVnHqZ0/cvN83xwolJ9pNERRAphY7JxzBk8XXM2IIIyGhZ2/URtZGEsW07Dvuaw6Gm64bIY/G0sar6+uuvR5MWgCIXFndmbex9ujFxM0ahdYgGQ4H9XrgHeX6cFgFPWYhxyNdfv5HKMrN4H2RhjwuPGIQMzKoyav3D0PdsHh8orOXy7Jyz1YrmcOCw29EcDlHBToIcIaFzMpM+9ANv377j8z98ztD3ZJlhvd5yqBtu77Ys5gvKckbw0Hcy+355ccl8JlMO7968pqlrfvLJx/ziFz+n3m1pDnt+9dd/xbu3b6OmvMUPHWjFarkQPkVTs9+sefj6ax7u7rh/947qYiUkM+/jeF1D13VcXFySFyVlWdK1LW/vHmjaDqUtShnOL84BaDrh6bjoGZBlWeTVRN2PaBvtvYuuezmqyOUYtgMqJg9Ka+YQ9yX3T9uKZPEwUXeT0cWOtmtGZCsJBhVFQVGWMTDPI4ekxRrL+vGRgATy7W7D7btbyrKgPhzYbjb0fY/WLd4H8kysdxdz8UpYLCQJmFUVNnIciiKXz+gdbujjGFot4kB9B7H1VZY5i8U8rh2OxbwioMiNQoWB9rCnaw6iJqgMRSZiS1VUfSxyS1Va5rOcIrMQPEPXytRJ2zL0A1VZSvWKxAKrox26ORrsBG0I3hHSugaR0yH3mPd+tM4NMRFPXh3gyawl+EBrNNpByh68G+JakCYIFKIwmJoEaW09rmsquo0yXfdCiBMS8r6ma2JSkn3Sw1cO7Y/rY/q9GkNWAK1QmYnaAUF4Th5EWkMQJR+O7VCRl/b4kKODIEhCVE7ooo/x5mgGJAlCGBFwOY4epSSJOK7T/ODtRyUBfSeEEuc8TdvjfKD3Hj/IScuMiYvBMCYBxpjR+CBG9lHKNW2aKMErR/NJiyCEMPl/ekA4PmCiSBiY7ldQCG2SUYd4HWQ2T46PcSEXRm7f96NAi49QUlbMJmxOTVbYGLQEdj0Mh1FjQHFUmzJGNBKM1mSZGbNiYPLZw3hTj+9Ya4wRwxs/pMXsaRIwzbCn8NT7SIPPBf73Qf7P/f77EoLpdpoEnL6n1OvSWn+L55B856Wam8J36fnyGp5vX93J/U4phXN99G4wIxrRdS1d39I2ohSZWj5N07Lb79nva9zgJWEj0MbA9Pnnn/P27bsx2Be5pihk7LCuA+BSaxFrY4tp6GOfucb7wNlZOd7USkFZGIa+5csvv2FWlayWc6pZyWKxwA9iH9wbIYvN5xWZtdSHHV3bsW1qyjzn6vKSi7NzDvt9RADEVyHLRKo5xBZdnknw6/uB19+85ne/+z0gBML145rOebbbgdlsxtlyThbbC8YYrq4kCbi8uCDPcpr9gZubG/7in/wT3n79Jfdv3/C//y//M3/43e/4+OMPWS2XuL6HzHK+OkcReHx8YEfg/ssvubu7492b11xZxQtjxE2w7ahrOdbX19d8kOeYrKBpWz7//HM22x2XVzfM5gteffgh2hgeHzcMztMPjmRy4wZxshPXR6mIQ/BYK06K1lo0ip3fyVqVRtfybLw+u67j/v6erus5NM0Y2Pu+53DYR/VAcdpL7n8pAaiqisVCFOGaxmIzy/3DA845ttstu92Gd7dvKAppG+x3h5hQyFoqKI8dp1OWywUKWMxntEYT8HG81uO9tDn6XsYS26aW0UYj+hpVVbBaLQRF6AMrO0NrQ2Zk2qY5bGkPe7K4lpSZkGYzI34FxgTm84LloqTIJQlIokGSBPTMSnGlVECIY31KKbBgrZNWXIDeu2PfPCUCsVjywUWFQFnXnQtRBVBMlvKorW9iQRXiSGNwUVocWaPFZ05MeqJvW7RHeYpuKqJREfFBkYeFjgRDlcbK4+tMEoAExXsVxvV6tI2etDm10ajcPGlL+OAIzqO8GhHdtO7J2ib3ejCiIZOsttNrOi8Ez3GNRmTRRavmuO5bm6HUMZyfTjd81/ajkoDtdiuV/uComxYfwAEojVIWpQX6GHxgiIYy1mZ0zkWvaPlKFd8x/D/dUgUYAtgsQ2c5x8kAOcISKKLrWczevZfFITH6h76nr2X+Ostysmj1ajJ5XyJhKTCKjf7v9IohuoW5uhZ+gI9+09FiVkdt/MQgVyhcTAaGvgdkPtroySKU2gVaoaNDIiR4K31wBPXwfkwAppX0Ub3s2HtPx0sC4NMRk/S80/7/cxyC07/9XbY0R5/graqqnryv1A891TqYnnd5P8egn/58SjB6usmNLTrxmTDc1fH66GJbIARHFts0BM1+37PddBAERrbW0PcN/+bf/BvatuNXv/o1bdtweXkxLrwhhLE1NLU6TiqDsngEylL05Ltom5vndpQP7fsBYxqqsqAsS4Z+4KF5xMb+YOKNtHXDEBX3MmMxZcl8NpOZ7eD54g9/4N2b12RahFG8kwWHEChy8XPXWtO1Hbt9x3rbU5Wi5W6ynMIGQtBkVvHu9i3zWcnvfvd7yjJH+QHtPWG1YugaDrstD2/f8vrzP3D/7i3r+zvu391z9+4BnGOxqFjOK4wKfPPlYTxnXdPwt4df0Q8982qGVprddhd7rJp3797x9TevefXBh5xfXFKvd3S9wxjLcrliuVhSVJWM5wGH2FoKHMfmbJyRzzIrQj9K0LGu7zCtxvRp2E7O8263lSIgtgMWi+V4r0lrQMiqi8WC7XbLw8MD3nvm89n4OGs1Rquo5ChiUFVVcXV1hQ+et2/fjDoRm82aN2/ejGTi+WzBy5cv45WrKF+8IM/y8b3NqpJka44icjwkaFijmc9n1DXUNfRDx3a3jmuqZ7VaRCRAnCR1hFy7RtCix/tbNo9rgutRJkMHqeTLMkcEbURGWCPKlId9R9s0qADz+Rw1n7FaLsnjmizWymX0TRDxGuc8bT+w63uyLKeqZP001o4JGsGPKG5q9xECubXSV48oWNt1EJMCRXTlHBFfiQlOe5zx2EH8SdpuiNMJ6ttrDDxtQofjtADT9S8WIKeFjBsGggmx7fSUGKiwY2vaGDMG/TQKPWoFxL+ntXyKwI5E90khlbgzY2tiTFj0JEa4sdgAmBaX37f9qCRgvz+QZ+LHfagbGdNAYbOcPE9Qr6gbae1FW9lYtAcRLU3bsYL9blEDgeHz6Nj0ZDQw9k9SQGlSFR96cI4hSM//cDhIJmwHsn6gd44ylCRjEWvjiYvsVOdFwdA5j3etXGgQ9bqnTPDozQ5ioRnfhwhtHGeRx15nlo3BLSnjRRJE/Kzh2AaZJADT6jtdJKcEvOlcafp+miC87/tzj/mh21PY/ujPnfr/4m/+lPmaIPr0vOP35xKAbyMNz6YBMWEUEasMrWMSECQJGHqpOgkOY+RxIUBdD+wPPbNCtPGzzNL3HX/5l39J03R89dVrZrOKV69uaNuG7daNSQwc/R907DNnWTaqIOa5wTlomh6tvYzVGcN8Po/z5l6IWnnOdtuy2WwlKSjyuCwKeawPgaoU1ntmC8qioMxzCIE33wjMbrTCKxXFroQElxKOBGkf6p7tvsca0ErcztIkj1KK9eMj76qSL7/6kuV8xqIqqPJM7qWupzkc2Dw8cPvNN6wf79ltNmweN2wet7juwH5W8vOf/ZTCGjbrNQrFarXCe8/r3TejcI5Wom5oo/zu4+MjX3zxBdVszmy24PFxQ9205FVFWYnRjpA8+3EqwAdRChwremOjiZFYJSuORUBnlMzbK0Wmc5RWHA4HBjfQdj02y6iq2ZNkW5IA4ZV479lsNnK+yoK6rul7Nd7bh8N+JGSWZcnZ2Rlt2/L5F1+MwlLrzSP39/eUZUnf9yzmQrx0kfPz4uYls9mcu7s7qe7blmzsCwf6vhPEKaT7SvwxtAI3CA9miC2CJiID3suEBIjYzdA2NHXD5vGR3WZDcEPsZwvPpcgtzkk7KC1EbdNQ19uR7CfXuOXq4pIsy9hv93jvo55GhtGOLlo+9724R+a5iD1lWUaOrG3phh3TeiWMexUUIU2TxeNbFhneOzkeIeAG4XwlMrhWGqcdziu0Cjjt6Hp5jWeRTPmP3GHp71Ggbfq4sUCbtAUEcZV9Oy3GTdPnmJiwp1gFRDJwx263HzleMoVztBSe7n/6fhMxfFo0TYnTU7RCHnN87jD8PSUBbdvinWfwjrbrGGLGp7TFZHVkxFtslqMjs77vj/PgqUpPTl+p4pFNWNBBMx54QsDEvrz3kYsQP5yLvufBT2QklKKaVWOSkA7O4BxtlBDthyFKgDaxakwqbTJPnNmMoqiw5mg0NB1py7Is9l7Fp12IGaL1n1mDoownIc6PIxd+2zYRNYgRy0sfy9roWBY8Pgx4oSOM6nrpxE+RgNPkAGTxSgIVp62A6f+/jxfw3Iz+NIh/1z4TMpKy4K7rxmr5uS21BSRpOBJknHMYbQU1kSJ3fA9iChMFfjgqMR5hRc96vaZpDhz2MuYFKhoGWULwfPXlV9zd3jH0NWWpcS4lLsLP2O9lcVssKozR7HbbCYR3fO/TczIlcU5JkFWVplbkuCZjkSzLcM6Po2hPuBNxIdzvpE2lg/S3qzLHKHGXbOqav/pP/5E3b95gtAIjyWpTH/jmm2847HZYbagPNW3bM/QtkZ4gTp8ebGb44KNPKIqC5bwks5Z/92//Ny4vzvnlL/6Y1fkZyw8/QFclu+2G5rBn6FoWsxmLquSf/7N/wicfveLx4R1d1/DlF1+MiY53jr/920/JsowXL67IsozlcglViVea29tb3r675auvv+Hxcc1ue+BwVtO1Il08MzIlcHF+QRE9Bvp+oK57XPAkH47tdov3bryPVUzo8zwTjs/QUcRJCpRCIwmb855uWOO9p24OsQUIWW7J8oKqKskyy2q15IMPPuC3n37K7e2tiCi1LavVSoh/rVSq88WM+Xwmo66N8EGapuHx8ZHlcsG//L/+S/pe2h+LxVyCYFzQE2LgncMPA199+SXeex7u7/HekecyDdA0NX3fst08kGWCMl5eXZDlmt12w3634bDb8OUXvYwv5zmzUkapm3rP9nHDF5/9ns16C8GwmC95dfOSzBoKaxnweKCrG+67mmGocUNLmRcs5zMuLlaUZUFViFqiUcJnadqW4Ft22wPbzZ67+0favqd1CQnZsFwuWS5XVLMZ1WwW20C9OAeGQJYVoziU954cGOKI8XzeU+YFXT/QNC2Dl3V8GJwk+J2IxLk+yl4P0osv8mPRBkj8ia1HrbVYnQMmy8YW7dB19IlYGNEGo6PAnJ4IxVkbie9JO1baMUPXRqTYMHQdXdMwdD0qeKpCJKlnVSUIt1JiTR8RKRPXCUEyxVkztxaqiiGOqHs30Bxc1JIwIxoy9C2BfrwHpmvV920/KgkQ7W6iiIOTm7JpJfh3MuNZlKLSZZSm74XsoSIDN8U/52KVGyGLRKpT+sj4TD0RFQP0KVGjH4ZR0xnE1TDpVBtjyLMjetB2Hdv9Tsavug43CJnC2j6O3BSRVKEiaiC91b4XJapEHJLxRHEcS7KdPkE7BKw5wjlNHPNCcYSQGYdVSDWtBF2RQh6hxog0TLfT/v/05/T9tEUw3b4vkL/vOdPnvo9fkF4zz/PRXyFlsXAMmNN9nKIVIhAzERd68rhjsDdiMjAiLN736c3Ga0aMWNbrB+kPx3lZazNCNON4eFwT/D3O9eRW0/SDtLacRyk3unkVhSRiacohvfdpApCO+VTd8DRxm3Il+skkyTB4WSTipMh4HhOxdBBPisEoVPCQ21GVs61rvvziCx4fH6Meh7Q4hjia2LYtWim6tsP5ViyUbVT3TDWY1pyfXzCfzzhfzmiams9//wCM+IEAAQAASURBVDvq/Y6PX72gd458uURZS9s0US64Z16VFEXOz376R5yfLfjDZ0KES74K1hi6buCzz76gqkrOz5eEIAx7l2U0ATabLV988QWP6w113dJ2ohwnbb2AjiJSZTWjLIXcplQv6Evk7IQgLo9aHwm5IMQ9m5lRzMnG+9YhTPOyLDE+yYuLzK4c+6MTZZpYKMtCkheIzpH7EclJvW3nIc8zstzSd8ItSsGmrg9cXV3y8z/5E3FlvL2liEF0WgWObnBBVCi72EZQwMXlGaJYKG3KpjlwtlqyWLxiMZ9H5UAgDPR9S/tQk1lDboUoao2ijxbAD7e3ok5ZzsgzWautMTKi5wUZGvqeoWkJoYfQs5gvWMwrzs/Omc0rmeoKgb7zo+9C3w9st3u2ux2HQ03vHQNhTHC0FhfK2XxOURSi2+KE6BdgRE4TlwwVxwaBPB+w2kgS0LbS3ms7mqalCS3SgQ2yVg+i0U9AnBaNxlpzjBlRS0RrWc9Dkg2P65BPwlNax/Z2vM+1ich2TCwSATxec6nAc8MAJkoIx/awd+Ipk8c2UxlHQBN508VrsYv7z7Kju6oyGpVnIzKYitrgLd4cx9oHBz7I51XqdFzwu7cfhwR0PdYIs94NnhDU0U3QWrQRKWExSvAyJeCOlo0+QAgi+qK1IkSoPTmNJbdAQiJmIGN4EbazxmBiJmadoApd1wvk6wYG7/B76dn3ucNYQ14UeIJA91pjYp+p6zqGfqDrBppaqkWbWZTWwmXQmrJUcU70KBox9IMohnHU/tckUt/0olAjrDtC/elqI3AUSfKR2RvGBOiouxh/fibg/9fapjyAabD6vse+7+9whKmS2l7qoadFLlXNKbAnrgTH+BT/f0wGvm8LEeKf8kmEJaSOj4g3vMwlRUUzrVDKxb8/TaCe6ymeHvv3ISrPnbPT4zP0SXhIjWRGjZL59hAwRsiIWS5Vwv3tnqH9mv/H//Q/0XUN7968pu1aghcCVV7lNE1H1/a4fqDvWmxRkGcZn3zyIX/2Z78YIepd24GC7XaDDwM3l+dUZcHZP/hvyTNLfdhz/83X/OE//iWH27dcna9wQ8ebb75mNqso84y2qbFG8Y/+4f8Jo8Ux8VAf+MMfPudxvaYoLfPljJcffMDFxQVZUbLZ7/ns8y/5w+ef89vf/o75Ysn52YV8nV8weMWhERKn8/D69RuszWg7MZZ53GxQWlOW1ZggKiVrh/ACZJ7fzGYUhViQF7lUw0MjMHnTHKSQie2rruvG4J+Qtr7v2O9F9+Gbb77CGsNHH33Eu3fvOBwO5LkkCSnh/fLLL8nzfCQXN23LcrniH/2jf0hR5GPCmOc5l5cXXF1dxzbCUWtkPitxhRxXvEOhRlTQe8/rb75BKbAW5vOSvLB4D3YAfXnOYl6I+mnUW9Bas99u8EPPmze3PNw/0ncN1sAHL19wdXnDxx9+ION5CrwXxJMga1FRVRTFgtVqxqwqIkHa0sVA/PDwSNO01PtOuFleo03GR598QtN3rPe7EfkC4Qy1TSO8sSFyp6ImS9c3OOe5u4v8i8VyXEut0iznczEPCoKydr20eveHA+u1YW8UKjg0DrTG+aRToI59c+9JHKyEEkvCHhcclSr6WEwlcp/3DK5H+YHkZTG9n9N3rcAq0b0oy/KJJfBUJGq6Bky5UVNpYeER5U8K31NCdfpZG4PShRTTRNrk35eLoHOiEZ3cm1LlrIxBm2MfNsSTJX7PARUJ/KOlg5KaOPEYxoApVyI+SILhiahDkMogTMgUSil0CAyDJ+Dwg6z8fT+gdawavSQmqETmi2E3Zo19P+CGCUkNMDZp3ksygD6OjBxHCZMPuegYZEmLPEKyKBVv4EQyEWElpVIuMEYpufZCzETVUfDkNNh8XyLwvp9PA9izfbL3oAen+3vu78+97ilqc4o2TBOA9Bx18p0nx+u57WTK4VsPVE++yx4DIukhF6Qaz9N7XuF7AvvpY6bJw+lzpo+ZEn+kKrHjgqWUkJ98JHUpq7Fx4Wjrno3b8au/+RXe9xwOOyEaaakYrIkIiRfjnb7vMVmGsrBaLbi+vmS/r+n6nj7scHH8qO9t7L8WzM+X4B2ub6l3Ox5ev6avD8znMxSB+rBH4fFDjnMDWimur69FU+Dqkv1+z7t3txwOtUDHVclisaQoKzzQtC139w/cPzzy+LAmL2bkeUGW5cIf0jImNTiH73p2uz1aG5q2ZRgEYtfWRO6HHu8VDyPsm+SgXRTuEmRPMdCPVbfzfmwlyjk4aoyIBa8spIfDQYSUjGa1WrHf70fZ8JR8OO/ZbkUbIaEK2sh44ieffIxzA4f9Lr43TVkULJeLyGtqcP2Ad04srifFRLoe0rTRfr8bJwBk+kHjnUYFgyoLskyQLuE0SaLdNTV923LY76kPB4xW5FnGarlktVqymM0ACdD4aMQUE+LM2nEaJstzCTZKRbc/qcrrumG3bwgBsqzEaMt8scB0LW00hErcmXTsh9heTYm5gnHKqj7scc5HRDfeF7HiVVqLdoDzDN0g8SN4ulZQqsxqhkFhlUaHp6N2sg49hcjTGiQy4rEQSetCum+D/JPEh1yA5E1xuk09B6Zug6e9/lNkNW0JOZ0ijmkNSdfnIAIlE0IgaO+xWTbGKhmp/3tqB2iTi7WhDkgQ1xRGpgKUyfBB4YA+MkSd5zjPj5ga+KAJyvCkkh770EfChozx+ag/fhQLSjBSIolleYYNGcb6KKMpkGLTCalvXx+kRzgxhdFKWgDaWIxp4gIjz3M+IhzakJlsnNuUyrYdK1yCjJ2Q/AMSPB2eXnAqXUQqMReUJABRMUMRq1INOihJBFLB+gMTgfchA9MA/1wQnwak9Jj3kQXflzycBsHpHG3a3xRh+K7AKi0hFW2FU7YtyZZST0GB9P+xEk+HNaJN8oukMj4e+agSlq635CWRPl/87YSp+32JwGlLJG2ngkinxz3tN4mJ5FG6OlUfCh85AEqkXF3AaJHI/fXf/hatAso7otUSKkSSnzyd7WbL119/RVGWZFlOked8+OGH4zjsalfTDz1d15JbK7PmZc7N9RVD37K+e8dhv+HT3/4tQ9/yi5//CRerJYvFXNoBeca6b+kGNwbV6+sbLi4uWW/3fLDZcvPqQ6zNmC3PqLuO//Cf/5q7zYbP373j8XENGIbB0zQ9n332BXd3j+TVDJvlZKaAoHm4fwQUWYRQX7x4Ge/nkqSzISiiEOaqWTkKuXRdy+BkfDdEQmrf9aOcdVHmSCGjYyUsQaqJIkageHi45+HhgY8+/pjrm2vW6zW3t7djJbZczvFBgmiWZXz88ccC0RrxXRD/h5bN+lGg8ziK7Ic47uak/YcxUW10oKkb6rpmNq+i42JJ1zbs9zvKquD6+pz5rKIqCg51T13v0NGKW4J/z7u379jvdvT7A2EYyKwoAP7FX/wFWhk+fPURmS1Gmd83b94IITk4Md5aVgQ8TdNSFEK63B9qjNHso9+ED5Ls2CzDOxh6z6AGul6MmIqiGK930Q8QTk4b11vn3KgGa7VBWVFv7Pqew36P1pqsEJEsG8V0ijyXIi7P0ErEeVzfiUnQMGC1pvUG5xVdH+HzQdDiVHcIPeeI4Mm5BE1k6k8Ct4riRIopB+goTqciQV1rTXADrm+PgGZckLxzQlLVenQ8TNeI0Zo8EszbSMAUeXlH17bSItd61JLIIyIuMtEN9UFQrSyrJYmOra8fs/3IJEBHz+YUuGLvWhuUNvFAy5dLns+IKygJro03VwLDFYox6oU0/qFj9IyKSxEOO1aXE+W8WP1YFD5WELgQ3QQdg3dk3o8mP8YcIX9jrGTfsVeUzlvKsDITDTsiXyDBQOEYbZ5kdeP7S/1j+YBMR1KOMWV6JEYkitNM9LsSge9KAr6r4p/+/BwS8GMTgdPXPU0+TjPh08Tg9HfH4B+Ro4QgHV/lyfsNTw5seu/pVoyvq8arLfaX04391Pjjuc/y3Ps+fdzpY6bH8bn9Pfnc+pgICyIld4fRJoqySMtIKj9P27RYC1UpcKHznsSITwYqfdey222FnJkJYbQspRedZRm9V3R9T/AOE2HFJEpjNbRlgVIyJmaU4my1YlaVURpciE+p0koGPmkM7Pz8ApvluJCQbkXTdtze3fGwP7DfHxgGH/0/BHVr6gbv4cxkmETYNRld345QqLWiEGiskI9FSCWKRcXPZW1+FI7RPbjjOXDeTyBgNZIF5Twc2dipmk98kNQumM1m6Dhvn4yvMlMQQqCuW4wxLBai7pgW7z62fNqmxXk37r+pa4HVY/KQqn3vXBSr6iirfOQzpONMyMmjkqSgPp6ub7FGY6wWnYq+Y7fbypRG16MDFLnIGl9fXYky5GIBQXE4tDR1zX63i6jDUR49eM/gozBcHHeVa0KSqWFw46RGIBCccHJk1t9HZDOZIh0JwlM1VD1Bb5I3jA+evhsIXj6T1zpWuHKvapJeiqCweZZR5PkoqMSg6b1odojR0FN4XC7bp2q16V781j0f0voTn6snXCCdSHyRy6QVysf7wCTN/wn07wYGjsY/uYKQ7nElvJbpWuGcQ4cwGhalttAQ3SaltSp8jBCUTGgkd9wfkQf8qCSgLOd0QyeEjsGDMiidESIcN/hA2w8MgyQBQYlksFIRZlNSKQ9xtl+gX7DIfK5R0hlXWli8KENZVVTzWVQWa2MlM5CefLRlzEVkQcnNHpRIeNZNQz8M9MOAuLS1IuoQYTfR/M7iRX4k9AQfcMoR9HHRTmS9eRVGlTKlE0mmpyeMozpjVTYGrBh+RpgmflexpznpX6es8++KBHxfwH9fUIenzlTPPfaUlDgNatMefwhhXNxS5QWM7ZRTrYDAtxMBxt99O4ka8zAf0SOdfjdVC1Mkz7FjUwCSYUgIkqVqo2P+eXyPzyUux/fzFDF5rg3wXdv4HAXaRnJa30gxo0AjkyPeiSKZG6RC+ODVjCLPuL44pyhylosZ+8OeL774kkM98HC3IxDILBz2W7756ktcUKOeRyC1xayIG6GYVbnA/PstRaYgeM5WC37y0Ut839HVOwxeHOa0kqmYOOlgM0sWLA+Pj2w2W9q+Jy9KLl/csOgvGFA8rjf89vef8fC45vMvPqf30ATFYr7igw8/Zr5YMVssGKJbnDUFmS15+eIDqvkc52ITx2i0sVSzmaBEMXHph45UXRgjF0HTtvRdG8f5OgmY0o+U6jLL5JyrdD3oiPDJWpGCVNd11HVN14nHw3q9FrvxoeX65pqPP/qYaj4HBe/e3aK1WAxba0f1OyEmSqDqO/Gw+Pqrr/jmq6/H6+Dly1fM5ws26w314cBXX31J2za8evmCUJbs9kL4zPOMxWLGy5tr5vOKpqlZbx55+/a1JGZGR2Gjms8++x3r9Zqff/gJq8WSq4tzjMmYFS1uCDSRnb9+3I3cHblXLV3X8e5dTZ4b8txEMzRF3Rzoupa3725pmjZO3OScra6wymCstGMPu5q2ObBe3468rCyaLMk6EaJJlszPW2uZzedobThbLen7IY5lpkp6oDnUDLbD9X1ECzXeD1irWMxnZNZQlSVd33G/7ajbfiRbJuqVOIYfNWaIrWml1IjIdZ0Q+ZTSY4IoPMWjUJuJKE8iokvyYiRJ8YvxcU3TUNc6Jn4h2o/L71SMXUkBMCVKqa0MIcqdmxFJKWNiDoG2bahradEPQy+JonNHj4PvQCJPtx+VBIA4PvkgI3qaFOwFfXXOy7hVEBRAFsV0wDUEN/bk08lRCoE2Y0UUk7Q4w5pQgbTgTrL5+DhjbLy5fcyAxKLSWslOlU5KbmL84p3wC9Ko2bTSTz1BHdGGaXU/HoGYrSaJ19SbDskQaBhwUSlrFG+IJy7E1oBsRwQghKcBRPHdSMAPbQfIMfthCcB3JQbft4/TPvdpZXyqbpgSgKef+SQJGI/B00x8euzSMf12Tp/2mI7NEUlQKl5TIQX6qEimnx6Lb+3tPQnKc489PW7ftU9j9OQ4xM+jiNVfgs5kGkXc3Cpuri8oy4LVaslmU3B3e0vfNwxDg7EqShV7urald5J0K5vEvCTrTIx6a6TKct5FwasepSpWiwVD39LghHAVBhLtWt5ZGGHR1KKrG9EOqZYrLNI/7fqBh82G9VZkih0apwW2nM3mLBZLlqsVQ3TXzHPR78/zgrKs0EbkoNuuH1FCucelRRhivzZ5ycuiKD3rNLJptAFN5OyIA5/SBnciU32cAtIMw9HEy3vxv9hsNogcsaWKSoHiWhjGka1kRU1UMZTzHkbSs3NuhHITCWy5XMWgUdO0jXyWCZTcRvEya0208RWEsm1r2kYMp3xuITOR49HS9V3UF5DefnotozUeYex3bVJJ9SOhMs8zur6ha3tCcDinKWcFWWZGhdW26+n6AW2iA188Jx5pAQ9RDfKw349wf+p3HxHdoyeKUuL2qpQgOkaLWZb3XopIiI+X6j4VcAQx7MlzO94z+ZBR95JGS+UcMLoTNG0SzOW9HGWGE6o7Fm2EcdVJsYCxcD2uA9MpAa0QSyj11A443f+jo2w8Fmn9SCOL03XmeKyiIR3PTxzJSKGcVxNHqscl7wduPyoJOPQdTd0JQaftxNrTyjgF2ozTAEEJ899qgfTEPEdGdJwP9MMxWCgU3oSYocvFZOKHUEYWkX4rWtsu9e3DEdYbegm4edGjjSweWmtms4rBFRgr88Vt08mFP5L6FHleYG02ugRmRYENARN1q/UQwB21CVK/JY8ZbRKC6NomysX2JGKOzbPjmQiRAwAj+e8YyKJ9sPQNYtWrkSmKvxsSkLbnOAGn37/rcdPXPQ3azyUNT4k2R1budG7+dJu+7vTGUXoadI8tAfGOSJMAx+CaEsvnY7IkoSk5VkpHTfOA1pF4NTEIeTK1cBL8n0MITnkRp+fg2Xek1ChwQwoU8Ss3CqNAO1m88rygKgt+/vOfcXF2xh999JGM3l2ccfvulqY+8NU3d7x+u6Msci6u5lSzjECPi3BucEOsqKUdlmUGmxlIHhWuo+saHu7fUVqYzT5GB0uYZbi+ZeiEfDW0XQwOMn1T6AKUcAI2+wO2G6hWFzRtzxffvObNm7f85ne/FzOlzgnDWwmTPM8qXr38kI//6BMuLq6Zzef87W9/y8OjGCpZk/Py1QeEAL/+7W/p+h5Tt2R5ztn5eYQ/ReCpqZvYluhxQxfJZwGtjBAFtUD1CikQvPc8bDYAo2HPMAwYazk7n7PZbNntduM68/nnn/P7zz4b+/5n5yuKMuPXv/2U/f4wygxLsArs97uIVMi6BaI3st1uefv2LW/fvuX8/JzlcklmM+rDPk46OV6+eDEGIeccd3e3WKM5W81ZzCpsZmiamnfvHtnvttSHA1pVqNxgrYheLRazyCspyWwm6qndwHa9pWk63t0+xiAoegxXV6uRm/LweMehPbB5fORQ7+j9K3p3TpZbbFGwXJ1R9o7MFmht8V7IgtutaFJstnt22w3v3r2LiphiBzy99mWtPBqjNU2DUmpcn5dLOScy2y+jd9552jCMaJYkXSYmASq2IoB8R3WQMd80Qpp4K4SA5+nahHcMIYxryNN1Tt63jPl5BmPwQcYL07o2ivcoCcIhnjeJD/1Iepy+5nStSWPDaT+JS3FMVvy39iXx6+h6mcUkIK13f2+KgV3X08ZeUNv1KO1QnkgMjBwAoenKQUm9/5Dg4qdfqWfiU9YbIng7iRXOOXzUY08HQw5kzNx0QHnhABiO2XxanPXUcTCRDgNADO5Ko+Nz5T2nbOyYUU17ZGECs0gsD09O7rGK45gDjM+QIxKR4LEVIC8TXzO55fHtAP9jkoC/S0vgfbD2c+jA+14jfU/HI90M34cWTI/5k2A7ogFPXvnJ98QJGFsLKUFIf1TTY0XkBMTfRbnhY9vmqTTn6XGeJgHp76ckwOe4BKefVZ6n4mRM/DnC7uljh1ihiOZ8yWI2YzaryHMRwymLgtmsYrVast21LOZC6Fou55RFMe5fh8hqDoz7LooCFLheHBYxUgkmIlXf92RGBLC0yjA63s1O+AmCTsjnzvIME6CPmu1N23GoG3a7PbvDgbYbGJzgsWKLnI8TAeI8mTObz1ktz6KT5x7vo56Ik1bR0DuG6FBqTBrzkhPsXDJlcTHYqIgQBhzR3tsHCptU2mIS6f0kTxdG/RQhTNfBKNIVwmgc5L2n7Tp22y27SGKT3ztQovLXdp1YIHtPGI7ysSEGkbIsxQWRZLstv1+sVmil2G439L2PwKimrMo4Niaz/If9nrYTPwOlj5B2CBlVWY6BQMyGOkI46teLLLnCmnRNx2rWyBh1lmUylt1nQlP1wguQUV7h0vgAwclx8B5JNkGInXlOUZRH3RA30DbtmNynoiJVsukWmZJyBTUMoJLerAizBZXY73EcW0l7AKXQAcqiYPBKOBxaj3Lmfd+P5lPHaiHxBWTK7ORGPqK3YYoWyO9OUQFpA+jJOvQ0NpwmAc8lBNN27Ol0wXQ9StfkKFueZ2T2KMr296YYeH+/punaqMDXycWgM7TJMFmOMhZtLUYJMcLFY+eisE/XC1TepaCQFiWtMEGJS5OKATHCvHVTUzfbyYFVcTGLByZW0Ck5GCcHtPgxm0juM8Zgg3ASXCS6DM5F4ot7ckB1bEWIO9ZRyCONEimVWgD+SZYHjMIbx7hwvIDGSpYJ/A2xIj1eSGJl+cPIgc/9/XT7u3ICvqs1kF739LHTIJ9EQlLmOs1sp4FyOh73rap7/MxIz2l8HzHZCDK2ehp45UFjenXcx/jdo5UhxMUzhOOIzvTmmwb451CA08+UroP0/Rjwn6IKo9CIElETG4O1QhHcENXjeowKXF1ecHG24vLinFlViqc7juCXVGXOT3/6CbNZRQg9RTVjsVph8wKbF2jrsS7QD+L6meU5Nsu4vrnGWMNbxHRnVtioeOlpmpo3b1+zmldcX6yYFSVlvqTe7ThkhuRrUbeyFpxVC7QxbA8t/eB4/e6W9XbLl9+85mG9ZggKjCBuVTlntbzg4vKK8/NLrC1omwGjLGVZMasWzKqGrh3YcsCYO0II7HZ7nHOUc421qQiQef7Dfs/6cY3NBC6vioIiz8ce9n67o+97zpcVeXY0DQrECZ1oDHM41JQhsFgu45ilG4P7+cUFRVnQR0U74QfUvH79DYdamNnSU+5QWrHb73l4eODTTz/FaM2syEdAcLlccn52xseffMLN9TVv375lt9uxWCyoqoo//+WfkmUZ/+E//iX7/R6roSwLXr18SZ5nDEPPbrfj7Zu32EyTF6IeOJvNKMoM50p8cCwOc4bDwLrZYG2DUnGkUClymxGCQsf1sWlauZesISsKLi+vWK6WDK7DZrLONo1wptp2kMRr6CVZG3YoNMaU2Czj5uySi+6MyzORSU7CaY/39yJ+ozWz2Yw8F8fDBNvLvluB+VNQ12ltOQZh5ZFK0UlCEgJPnHOXiwXFTIh0Sc656zp2u100hDrQK+h6GXd3ThLA0A1oe6zsBV3w47oWgiB1hkAWiYkiBy76FJk1zIp8FEgCxomQpDr7XIKQ1s8UR5LHylHESlGW5ahjkZwa8yiMZ4zh1c0li1k1tqD7YeDf/Pv/xA/Zfpxi4KiKFvOgEBc/JTiM0fI3H60UvcgYSUYfRNBn1BiQkhsZs9CgI6c3gGQPIuyQjIFGgsfJIqrsU1vdcTFGZlDFjCpEF0PG/j+okRiUTkjiExxjyVN4WT67H2c1p4FnXNxH1CGkXaQ9kRICQQHUWKpOxSdOq83nAv13/e20ev2hCcAPRQq+6zmnwX06LvjcuN30uL3va1rFT4/n0+P7FI5/+jrPJAAqJgcn30+P4enxfA4FOM3S09+mScD0GE2TgHSMXAgyregdBE9wTtQ0e0/QUOS5SI1aaUd1XYtSIerEDxR5Jra/ZytsLuxxZYQ9rnxsp8TjaJK+vgJC6mUrZrNS5GNzaVEkXXsf4VBj9FglJ7dHa4UhXZQybrtvenwYeFyveVxv2B32NG0HWmRWq/mc5eKMm6sXrM7OWK1WoyBK24mkrkwALMiLUvw8ugEf/MjCViiRHu96nJfquo3KgForyBgNxNwg6EFahLvWjNyBKeIji3HsUaeRx4kb4fS8JfvjohDzp9l8ThaJr0KoewcKttsd+/1eZJ8jQdYYS2aiBXFRiBvkxQXbrUxx5HkeR0Wjel7UOahmwgWpqpkQOhPK5p0UTzpZc4sYUvo83ju5pnxCGjQqiNRvWnezaAQUQkJUBryTlpvWGoMdpz9cdNdDCVHTBEnc5X2qUczHeyGynZ+fjzB/SgQS0z21HpLKaAqIZVl8q9DQ8SsoJeZGWo9oqzgrHrVcQgCsyEQXRY5WR3OvrutQSo2W0UnKeywoIkfgybqWVu7nigxSJJH3aY1lVlXj5+y7jrosJMGYoACSPMm5FZSmheBlUs0Y+j4lAa2UMFHbIb2W1sdjktA+gif4AU/k0v196QT0UVRBa4WxSnQAonY+XhIBjZAGHZ4hqvnJuOC3A2YS/EgazonkM+qwDz3OdXFBlSopmfiMtrRZEqKQG79pmohUtPHEiGmIjnOdIh8bsFZGq4695FTBCjSsIKpvHdnDkMZb+kkS4Ee2qRmhRGJq6uUrpP8f4et4LzGF/XUkdkjb4ruD/nehBFOI6TSQnwZ4eL66/z7E4LuSiWnQ995zaiL03PbeJGgk9aXvE7h/ss/v3P8TBACSw6D8nPp74VvH7n3vcfpZUzI6RUBSG2Qa+JNgSkoAxCMhzo17B84RhkF6jw6Ck9HaIrMs5isuL84oc4vWQVjktSEzYCJr+Ox8xccff8jgA53zBCWSqCom4ClPKvKMrMjp+wYU5EWGNZrr6ytJArQit3Hmeeilt55FYRzJ1Uk82aIo0cYwX67QxvCwO9Duez793e+5f3zkze0d/eDQ1lLNF9y8+oCXN6/4xU9/QVlWVLOZqHcOA48PjzRNR1FUvHy5QFmxIH9cbxncwGK+iBNIQvDdbHYMQ8+h3o/yrMbKot73PX4Y2O32cZa6xg09yvfCIo/uliH2H6fz+ynQ101NP3S4BKl76cl+8YXYS3ddx+XlJT/96U/J85wvv/ya7XbLv/t3/w4UZHk+rhl5kXNxccGsmrNarkbL4KurK5bL5Rgok0Wvd542Sg73/cDHH4o88NXVJW7o2e0eSQZBStkY4FrW6w4VW46H7Y76cCD3Bu2VTFQF0LqQFpiRtsxyucQ5T9sK12s41ITg5EtJADzUDU1bC+lMK2azBcZaMqeRNru0A5yXCtTtD5wtS37y8U/Y7Xbc3t6y2WzG0UqtNYv5nNl8znw+f5IEFEVxTEa8jyOy316jjsm4oLppEsOHQLaoMJkkxq6QcU1ph4RRJ0N3ncQa5+jN0VMgTO5t2ZJA3hHhOxalARUTBaUURZFzc30Z5aJr8txijaKez2maemzFbLdbkTxuarq+Y/PIqDJorQUvPIi2lesiyzKKzJLMngThFtMlE7+aeo/vG5KOwXcstd/aflQSYKMYgQkBFScBusGPIzsSDOOCODi6vpdKPqSgFxmNNs1WTlj68YT6CMu6YYgX7rHHZ7QZIZBRhYoQ+zwRMUB4BgLpxN5TUFEAQo9ZL0QyGcdAKoplArcQwLV9ZJpMLzw19pTkwkyvlSp9WXTTxMOE4D2mACn2y2sn1bNpIHw+uP8QdOB9SMD0b6fbc899LhF439/Sc6cJgFJqvOGPjorH6vcUNZieh+c++7e2hCYRD2ZCdyZJwXP7UAqZ/VUpCVDjtfnca0338+z74HmU4Mh5OR6raVIgUskZNhOjkSF4GWmPyaE2cnNmmWK1WnB+fs7Z2ZkkieGIRMmkTBfJVwPd4Gi6IbYDSnlc7JULKXdAGdHhkORE2lduGGTxweGsITOBzCraJhcv+iInmTylHqu2GWhN0zY470cEYB+d9bI8B+1oejeifkYbjBHS7BDHdsto/wzRgc3a0dTFGI1zij71OLXcOEfpVIPJZTxMINKMoRN0ILV3lsslSkFX745QrYJu0qYSpVE9jvym6zQ9/lCLKAsozs7OuLm55vr6hhc3N9gs4/Fx/eRaL2fVeD0sZjNeXF1S5CVVJQ5yfd9T1/X4+vP5nFlVkdlkfNRL0RO1/ceqlTRereJryfuVCYJB1h2C+BzsD1RkGAwgc/iZlTVaDYIOpetycE769SGOT2slpOzID+n7Pq7VKvq2gHdRN0ZJtWq1JZF2vQ+jdwNIkEtOm9ZaZpVYYk8d8YBxzZD70jMMgjzJ5396j4bJ88Z7Kwi079UwPtZag/eTCYkYP2RU1KCNHxMUF4vWU2QvJfVpjHxU70MS8WwYMAS22xkJ2k8oRJ7nLJeL8ViXZUld1zw8PIyJp/eew6EZ39fpmjNtH4QQlR2DR+tsnA7QiugKynisfsj2I3UCZmSFwHe9E9axbvuRAKiMBaVxg6d3A4dDTdv3BKIhRJqxtBkojcmSRaqZLGhuzMzbtsUaMebJs5yiKMZeUlpY93U9EgfT6KBoi5eS4Tad3DijYeHk4CgVITE5kEWRj/2d4APbfU1wYgObFu+pHCQRUjLGjBm4jCYNqCyZ+YwYB0+QgJQMyBv5ViIw3b4vAXjusadB+4du34cEnAbF6c9HcuSx+k3zwdOKeeqz/RSBie9/emTUpLUy2RIaMP484fp8J+IgO40PnqIf306GTquP5z73OB6kv00IOj7meVJPnmeUVc5ht2PvB+ECKMgsWAWZhlmpePXqho8//ogXVxcYrbg4W9A2Dff393Lddx2HuuZw2FO3HbumZbm6IC+FdOYjMawbHFkhFaodDMYazpcLrDE0dS3JQl9T5Bbl54ShI9eSNM2KnLLIWc5n1HUtgdRYAvDN23dsdns+//wL1ustj+s1TdczXyzF9GW9TTQque+1EBD7w8Dq7JzFchXvCTVKxZZVBVqz3YmM7Ha3JwBlItINwqjOs4KqLEc2OQTu727Z7fYChyvFBx98yGxW8emv/5rdtpaqEKIboRo5P2l9Suc39ah3ux1v373jcf3Iz372Mz788AP+7M/+nFevXnF9c0MA1utt9BQQeHt1foa1YhhTFQVn8zkpUb27u+P+/n5sAVhruby8ZDGfY7Th/v6Ouj5Ekl4+qstJhR7vMa1ij1iu091ux36/xWhQBN6+fcthf2BhK3Jtmc2WZFkhrQv0ePy89wxuoBvETM0qRWYz8sLSdvWIinR9i7YSoAMNWhu8VxA01lZRg6XEe8Q4bhhYbzYMke1fTLQChOgqCcHgk0qr3DcpAGbZlFQXnkwXnK43fS/IrFfSMui7Hj/Ia6r4eUJgXI9GFFlruQ4i/yN5ErTd0RLdRY+aEF8/jfMlAam6rkdkut7v0GEYWx3WWpbLJbPZjNlsNiaIb968YbPZ8Pnnn0dUQLRvNtudKAjmR82A6XqefCmS4NSRs5KTWcgmBnY/wjrgRxoIBUXfp/6+VBfdSDtGKhTtGQYf+0QOrbywh434fotan8z1u74hOIVyZkR7QxggOLwfcEMXFcUyAkkK0hOIYg4gFyIGrS0ELfP6IeAd+EFIHwTRMlCRRJgsIHXMOjMj4iE6EhKlJ+vRYcDjCC4ytlEY5chE3wHvQUU+hA+px9PHCsTHXk08GzEhSD0xYxIsfKySEzcgjUv+XbfTqvS5iv50O1Y/R94HfBtuf9/f4l5iFhpinJXeZOrXptcXzQYX+65RdCl+aTzi/SCOlYMb4rWU0qh44yZFMiNWzP0gM9F5WciirqQCxnuSKqAxInbjhh4fPFkmLSI3ZEDGarnCDQO3795itebyfIkbHHXdoHqPci6dRnKrMZnG2IDS0DQ9Xd/jUARjKebVeC6JyIAnUDcDWSbVydD3tP6A9j3zMkAh17AKDhU8mQkUGby7/xKTtdj8E4o8o+1rmr5mfXiQmfhBUDlTWHKjmVmLsoa27xGyvEHrTERrbEWeFYRYKYnHR3RZdJq2bfB9YNN4yGCucrKQse41nTX03tKS0xslKqHA7b7jYb1n3fTsekfjxO9DEcAoyipnsZxx8+KK1cUCXSVPkUDjD7iDYx79BRL3wGY2ogfylWWZLMZezmWWPEGU9D8TT0JpsJliviijKc3AenfPvjbSJjH50X48MtwPjfAOxD3Oooww4rtepofyoqAoS8q2ElLf+TlnqxXLxULm7r1nMSvJtCKPZkHKOzKdcbFaYrQi0FMfajbbrSS/dHGmfkCrHK0s1lRk1mC1IzOBm8sztFYs53Jcmu2Ouq65vX1L1za4ehCRLK1we4fbO1SsdCu9wBQ5Ohi80rSDwoWAbTq0MvReWpX9foP3gcEPoDOsNrgwMDix2J0vltg8Z3D9uFZoUd1BgBa5p4Tc7OK4c0DpQNPFgs65mHMrdJaTVzNMnqOtRQ09SnlykxEIR4EfpYREiNxzWvmTNSikZqskmNqgrSzKAY9XPSq2+HTwWDUwK8SMyPcZw6BotWOIrQeFI4QBG8RQefCiPaFjmztNNWgkKQ59jx8cQxD0wgRwGurtPbNZRVassFoCswktvocQMoIxzAqDXla01xcsqpy3b99RBy8S4CEwdC0qePJKphuM1gxxvHMcSfQKrQzWZGQmx2qHUT4Wo5GX9wO3H5UE7BzSt/RHxvzTijONpESDmOAwKjAv7ajsl7JP7x1928jjJ7BxcIMEAN8zDG0kH+U4r2EAHwa6PowZj4gQqZgBe5yTXo9kdgHXH5X5tFJooyIkKZbBp+5OeAke3g9oWrk4XLyAdfR8zo6VaMrM0hyqTyOM7ml/e5w8mLQc0gl9Mh+vngrInAba6U3w3N/h6cjaFIb+rgQgVdzODd/5WqdfT187TTnI/xPxZRietgymIizy3ADBobxCK4fRISaCLuoviDolaJkxBwYE9dHW4IeBfVdTFDmrxYq+7wja44eAHwYUkghYK7aqzolNalHMsSajbYW09eHLG/quYXt3x6zI+PlHL9jv9nzxhw2RsydTSQaqZSEkJrkfuR8aDk2LzudokzM7v8TauKg6Jwz1rqPebSkLTVkYfHdg6G+ZzSyLeU5Zik9G3zY412ENGBP4/Otf8bD5gnLumM8FbqzrmjePr+l7R995iqJieXaJ8ZrcadrOc2haBqcAO1pll8WCoihp3VZQN+9RxpDnJX4YqIcdjYOWAZ9rlnpGCAWuN1Q2o7IZg9J4I0zl4D1frWvevluzqTua3nFwAqlmxqOMYr6ouLw64yc//YhiXqKXknkEF9i3G7rNwCergrPlOeL3oMlyQRVVTI6LPMd5MQxDy4y0IERCiKqbHq3BWMhLRVHN2e8dTTtw+/A1bdth9BJsObYJ0lq1PWwl+fUObQu0yXHB0PYDKE1ZVSwWC7z3XF1d8eLFC64uLzk/Oxth4vPlnCE67XkvhkKZKnh5dUHXN2z3Dzys3/CHP/xhrAyd6yEYjC4wOiOzC4rckBuHyuHi1XWEziv6ruPtm7dsHh/58g+fC5IUW6IaRb8dGPYenVtMZlmaC6hg2/f0zlF3HqU8TrXjepOEi8YWqAnk2uKCx/eOvCiYzefjvZrQ1unM+3H9B62HmLBJy3QXpwnSxJbWClOUlItFJHoK6qcjF0ApxXq9FsLjyNA3aOkvyOulNTZMTOrkxdEqkx69HwihB99CABtk/HZVwpBpcpXT94qdEu2KQ9+jQnwOEkjxDt97dJyIzbQaDe8IgaFtcSjU4AjGkAUYfMs+rMnCGeV5idWBzIDyA75tcC5DmYxlZVnNl1SZFkXKww7lBzYq6gbUNSZ48vkictkMfduxXW+ZVTMWiyUqKKzOyG1BkZdkNJjRJyWAH55d65/bfpxOQDQ0mC7+p6NRUyg4ifAkQYOxMor/HyYJxTE5OI5nTeG552DZU/j19AuYXExPZyuNNuO+npvXDHEMajoikrZpjzf9PMKIsTKY/m3sASv1g76mx/N0O+35f1cP+/T9fv/21DTnuxIAPzku0+ORIDQQgtb0/J22KdJ+5XglKOh970xQHDU+JI1XyrGfzWYYo2Mfso9SmohpSUzqfBQFEedHmYUu8oKf/fFPmc8WvHpxxW6z5qs/fMqsyLi5vuTyYsXZak5VlqyWS7a7LY/rRx53W7aHPU45HPqoow6gAl3T0Os+0kQ8bugh+HhNa7x3ZDpQlIY8MyL0ER+XZZaysDEJEMJYkcsMuneDJBdjQi0Ledv1tL3HmII8nwNitkLn45y8E5OXYUCbPvaAjzPZCSJNpLksyzBRVMe5NH8P2lh8JNE9Pj5yOBxYrzc0TcN6vR7V8NJ1UVUlL1++5Pr6msvLS0xusaWNeue9vK6Sql7sZS1KBdYbqVDrw4Guk0QwkBLcZP+ryDJD8hoxRqGNmCwNg8zpJ8Kf9MwVBOEhKSWTPPLZBiSB1eMxTdMCxNe8vr7m5uYaheL+7p7dbstsVuG8TCCs12ucc1xeXsbrW+bz1+tHtJXe8Gw2o6oqdrsdb968YT4TPYflYiG6DjHZMVFCVtBGL1MGXUffiWVvnufT3hc+BLE2VouxHZGKEhV1CaZFBxyLl2lba7oeThP20xZXeuypPsZ0TUriNqdr6z5qKqSv9Ji+75/8nPrt31eAqESS0xPvjdE4LK0x8ntjLCJkZsZpiSRb3PfCYWvqjkbJ+Ls2UaciEL0yNMoYoagruU/yXOyVq6ois4F5NbBYLKIOh/AaQnT1k3RNOC9KqdgmNVxdXZFlObudWEsPztE0LY+PjzJ6mhfj52BcRxlbqkopsiqIAVncjP7hSPKPawd03UjIS1u6UKbeyakfkrSRTy+epLaUnp+SgKmV4rgQxUr5tFd+enE8lwTIiT8GIbkJhJA47f2d7sM5KfuUk6wwvZ+khDfdpgF+eiEmpOQ0Cfi+ZAB4EkhPg/33fT+96abbD0kERKv6eG6mx3j6NQ3opwvGlBmfkoXpAnSalJze2M9uieyiUvA/5gvJn0BcJDuGocO5YRQ9EVvYuPAFcefLsii4UxX82Z/9kqura15eX3D37i3/2//8/6IqM65fXJFbg/nJB1xfXfBHn3zEl199xe8/+wN//etPuX24pw8dQ1ASpHwi5QizNwTpjyogjzbTEmwVzg8UWaAqDFkW5Xtjf7RazCiLfEwCqqqkLPIxMJVFMaJF3nvqeo8Pms32QFWtWC4NRSkBxrmOHhHLSW5mWmtccFGn46km+ixay4oam31SBQr0a0fS1zfffMP9/T3r9fpbSUDa72IhCnuXl5cSIA045QGxBs4yS2bl2pVAIJnefneg64RXJPeC8AnSeiLGO5aiyOSYxyTAWEXTHDgcDnR9yzD0Ua2wo20HQtBPOCoyahcrWJtH/sZxZDCtIVdXV5ydrXj9zWvu7+7Y7rYslvMxgK3Xa0IIkbwpn2cYetbrR0FCludjIvD27Vs+++wzLi8uWC1XeOfoq4qu7cizjE8++ogiL2jqGtcP0QOhp+s7fPAyQeD92Lb0zpNlOVWcLrDWHtVRD4cxCUikuNRffspbOQokTdfQpGY3XWdOi7nn1pYQeIIYJPRvt9s9iQXTQjCR7b6rCHqyJDxbHAYgEbWfIqLWyvtQ2sQWpSSjWVaIv0w/oLUIVaEdxqW1VEyStBYhJaWNWF9rMzL6y3I2JgEi6JVHtc4hJiGglUzXZSTXSxF/ur6+pigKbu/uORwC+33D0DuapsNmlrKaY62Iaql4b6bReUluPcuiHMm1AObvqx0w9K2YK8hRHw++VjJ6lIKstYmxKO7txxl5mcUPIULuURRl6NoRbk/BIrOGzIhGuGgyC+Fl1IacZq0+xH15fLrwnCxa4kcgc6VGqaixHL26Y3Xp4zyujz1qP0hP3yYeAc/D7tPtNElJjz1NAqaCRNM2wPSmSln66X5TlX56Az6XRJy+j+9qBUw3WQQ100A/DeZTBOA0IUijPtPjMP38ST0s7SfBi+Pin95PIF4zk0if9hf/HZGBeEzLosDH5I3gcUpMV/q2pu9a+r6lLCxFZlktl8xnM/pBBD3+8NnveLi/o7S/oO9rrq4vZEzOD+R5zovrcxbzGdYw6vabPGOxWvL2YcN6d6C/3TH4Tix5h4GghCntfdLYL+W9e3l/bdOQ0RFyhzEZZZHHUaPA+fkZi3lFVRXkmeXq8pxZVXB9fUlZFMwXM9qmG4PkfLbgULc8PO5RCrq+BWUIQXPYN+zrlr6XRGiIevJ96AkqsNnusHVL04nkdds047FfbzY8PD6yWC44PzsjK3LOLy7Y7Q/c3d1xd//Aw8PDOHaljEEZze6wx1rLhx9/xNXVFeeXl8wWCzwyO71vD9GgpyfPS/IsZxgch/pAWYrAV9/LopznGd6nETLhfqQRrBAKlssZScHQxep3s17z8HgPiJtd09RReKUaCcDpHhJWuB4JVlormqamrg8c9rvxaksmQsZqZvOK29u3NM1hvIa32w3GaPb7LXmeM19UDP3A69dfU1Yl+3oXpYR9TDgyCND3A9vtjrZuRqOh64srFIq2aWnbjvvbW9qmZbNey9RU1+Gdx/X9qGtQFgVFXlAUwxEJcNKjT8z8aTs2bcm4Jk1dTdeRcR+TdTl9n65paZsWdtZY8rwQhb9YFHV9TwjQdcPonJcUFHs7ECxRtyCuBbKz4xoWfx7XnsRLSqBIvG7TWnKaIBgj3BwdEQFjMobBURSlCMcNjiwrKPJKNGTSKDEy2aKUjFYqpbAmI6ksyjHTZNaT53oscvu+p42jiSGAsx5rHUEpbDZQ5CVK6Sj0BZeXlxTFHu8fROq+Te6AUuRU1YyyqiiKPHFM5fyZo6Pn32X7UUmA63u8PvbTpr3tLLPj6MX0QmGcHQjHIB7ke0oEBAY87s8mUwRjYo8wsueJpIxwTAJCgquck15RCuSxaldoMY5AkhUbE4AEl6SLiUlmHaJICIZvbVMoHHg24MGxDZF+f4oEnPIApvt6rr0yDcjT7X1owvT9Prc939N/euNMA/w0AXnfPtMi8VzLQik1XhvTfaXMX+tJoiK417deR6579a1xQq2j4YhWOGdHe9yud7RNTdc2dF1DZuao3DKfzzlbrdhs1/R9z+vXX7PdrvnpJy/wbuDsbInVgRAGMqu5ujwnywxaB87PV1xfX+EI2CJH/+FrlL7nYdNwaGW0K6S+hUpTB5IQpwTGu2hwYwWGNlpJEi1AB8vlgtVqwWo5pyxzXr24pqpKlos5eWaZL+Z0XU9dt9R1Q5aVPD5u2e1FYazvO0CSgKapaeoW7zUoLcTVQTMw4Akc6gatu3GxGlz35Bo3xnBWr3DecXVzDVpRNw0Pj2s22w2b7Xas9pK7Wx3FdFZnZ5xfXLBYrsRBDvEC2e8PMQl0ZFmJsZnA6q0nyyq0znBOpmyyrAAUXSdcIde1owqdtYnhLdWa9x6XFATXa2ymMZrR+CbLhG8jCGPS/ogTPnENUwrarqVtG5q6jmxy8Seoa0noiiLn8fGRzWY9BjGtxPP9cDgAcHa+Yhh6bu9uKYqctm/GalgemwOS8NeHmlYJaTi3GU3bktmMtpPP+RjdBR/v7wWZUBo3OFzfi3tp1zHMZvjZtyH8dA4TQpAC8vTemTrYTdeBxEJPa/F0jZm2eafPSa+rjSGz+eRv0sogKNzg8CpNZrjxWlBKU5Z2EjuerlWnbYnT70lTRN7jaXGkMEbqR22ymNwYnPPkuZCPRTlWPCuMzdDWkiyOxy22kbWSzz5FOoxxZJmKfAs/Jrrje4+6Oir6D2RZgdWKoigJQbFardBas9vtAWgaB+g4sWbjZIWIgQkn4ulEy2ks+qHbj0sCvBsVm9KLp9GP1P9PWVCq9KbBLM1Ept8nS9l0saYAkS5KyWg9bngasFI2my74tK8pYXHa70oX67SCngYR7/342uNroND66NOeTnja9/RgPwfzT8mGzwXqaTZ9uj2XYKT3lb5PUYbp5/leWP17ttPE4LlWwOlrTP+fCEfTG3TaQkqfPR3Hp9VEOPY6n9sibYDp+Yue6ofDAe+dmNz0nVR+Coqy4PxsQZlnXF9fcLZa8vFHH7BYzHl4uKepD7x7+w7vWrabewieshCGfn3Y4M8qVqtKxuzaAzM7p6pmfPjBC6rFnKyYcX5xx76ROf1dI8zqrMhQWliDKqJQpOAaPEZ5cqtZVBU3V5e8fPlCTH2MZjYrKHIrSEBuJdipwGG35UDg4f4OpRRFbsnsnKqcUeQFm82Ophk41D1GZwTtsFZTVgWoqLinwPkBF8TMJ41kjT1YT+xxFiJnnEkA6fuBd+9uAfjiiy949+4dXdfHakrU4ASd6EUUZ7Xkj//4Tzg/P6MsSwBpG3QNh4PMx4/8IiVa5yLf6rE2RPc5GTuT93dgcMOoDphIqFmeITLejrYTMnCWZcxnMxaLGWWZ0TRnIu/tMyCJBUHbNBACdiLy1bYN292Gd+/e8vBwx2K55Cxb0rY1XVczRBGb2awkzzNurm9GUtvQ9/z+s09RClZfrWiahrdv34ICYw3z+ZzzszMuzi/4o0/+SIJ3TFCC98yqijyTttZ+v2O72TL0PVVZEtzRcS/LM/IsQ1fVaFdrs6MYldKaWZzBd4c9vXNjpZ/g/SxLomlPidFpXbHWjuNwpxX/NBg/h1SGEMii+E36exrNm64T6XnTNnBa+9+39jzHRZomH0D0mDi+t+Q4qZQagUX5jBlaiXy484EsCFrmfSDLC2yWj0nA4JyIS0VX2+ReK9ft0a2yLKNhlbFxis6P+7ApqZhoI6R2UxEFpcRuGdq2Y7lsKMqSy8vL6MVQkOeFeDLkOdUwUJYihZ1xAH44GXC6/agkwPsk2sARto8nNyUB0yCfMqRTstm0DzStGp8Q9yKq4P3AEIbxRJ9eHC6KJjjvpB3gI7Q/IbekmzC9Tnqt02A2/duYUfI0w32y38n7TonE9IaY9sCn+z8N3M9lbd/1t+eC/HPB+7nH/5DWwHMowQ/5/pScc7xhT4mS6XidZq+nSMCT4zG2AKRFMB6fiBh0g8zZD0Mf5ak9xshitlgsOFvOeXFzzfm5CL0sFjOsFf/19fpBDE7aWlz8Mk1wjq4XAZayzOhaT3PoUXis1axWC4qqYle3BKVYLioeHjOaXgSr8kxu+ODHdx7fr1yPWkFmNHlmmM9nXJyfSZafW4wSsakiz8gykfVVCvquxQ1DrIIt5+cXZDanqnKapqMscoY+EHwX5XFF1CSPI4JKm3i8/HhfTHvBEHMsLcm9NYYsP0rY7nY7AoGHhwe2222s3lT043BCauoHiqJgvlhwc3MtLnlZNorjtENHH/u/ZrIoex9HR6NtqtEaZSW4BX8U3krmN+n+FG6E7KPv5VozWkiRi7kYLokKnaNpwQc1ShX3nbRGxvtWQT/0bDYbdjuZ+y/LAlSI5E4/yt9aK2O+s1nFfD4nhMDhcODh4Y5hGNjttiN50nvP4IU0mNuMVy9f8ZOf/ITtesNhvx/3eb46k/fmxJulbVuSW2MiaR6JzeLSmtbTEXmMByOtyXnfgx6+VZTI/9VICE3XgNw35tmppR9SXY7B1iiyDJ5C5se1IL2X03V4WkhOt+8rbKZrtIvEzuN6fITziUN0cgxk4kipgA4ybZBlfeSa5DEJiAlElFMOkZtkRxKe7EtamolAKPvWLrkdWqw5ahOMHP6EmugpudnQtpJMZ1lOWVVcXF6O8dDabGy3D84xm80pihxXd4Th/w9JgDWWsqqe9JhSdjcN6qfs/Gm1Ph0xSSfvKNZTjB922k4QuC/1igGSIpuPGZofZ859SONnLnKJ4miK0ZE4lNikRGUoj/dRpthHok2QdkXnOpgkFFNEYJowTBOXdOGlmyttp0H9uZtqGiin7YTTx/yQG+J0n6fPed/vk1756WPehwQ8ycAnCM90yiOEMB6PhPCkxwlk1hEycTRLSnuBY8snyVCkmxgUOtoLG60jQ7sbF5csy6JwBtj4ve9b7u/vOBy25JnC+3P+5I9/RlUWfPDynL5rOVtUdG3Dfv0NrvcY78lsQDEwn2WcLW8YBs9h94jKCsoiZzErWC0qzs4WnO8WKJvRDx6blQQUbS0BWeRFIc9E0yIzJXnW0TYHXBRUWS0XXJyvcEOH947lXJCA2bzEaE2fibKfMSr2m19L1V4u2W3XdG1DCI4s1yxXc85Wl6BzUJbBgXdwaBoG56mKBTqKmaAYde4P+z1KKWbzOYvFguvrK7quo2lq1us1X3399agE17bCBdhs1tRNw5dfv0YpxT/7Z/8dH7x6yc2Ll+R5LnoIbcduv6ecVXz88SciURsVA/tuGO8Z74T01/UO7wJt2xO86Kh776mqMpL2RB1Qev3SujnUdWSfq9GMJ8/zSM7yZJkYc7mhjzLAbVyzXLx+W9rmwHbzSNfWGAuzecnl5QUvbl5wcX7Or3/zt9zevuMv/tE/4ubmJnIWPF988QVtc+DVixegoKoqrBFytNLCCE8+8y9fvOTq4oLt45pNFNQJIWAvr0RNbr8nhEBeFPRty7t379htdzw+PoqQj5XCyxRm5MUEROa8648iMlkURdLajrB007RxHUvrVgYE8WiI66agBllkvsvfp+tKkmhPUtvPkZ5BRgPTEpjQhVPSctpnig2JXyKcj+9HNKdrXUoouk4Ieen9OCdqsSbqGyilSURjQU5UNKwTW+myrETVNrYLvA9xmiX6yxg1iv9kmXA7nPe4oaFvHsZjYY3F2xADt01LmXA5vEfahIaU7yS0JkSEoW07yqri6vp6XPdG9MAaMh9GEmLrCtwECTA/Ag3+UUmAEPYs9j3wv3d+NJkIQfpkqKd+yOl7Omkpq51KOn4bfpoEpSD0j2NgFpgmfQ+xkgiS78UTEr+i7OXxQo1JQPDjDTAGteBHotmU8PI+5GBKmpmS/qbb+zLp5y726XOfC/zPVevpNb4vgfg+1OC5v0+r++f2BcfzPNUBSMgQMPZPU0WQHuucwxtN8m2QKlXINCkBgPQ9EgKZJFMkwuKk5WMioVSFeBP31HiGQQheVSmV4sXFOcOwFc6ADtR7KMuMXjnoO7QSvYvMWmazgv2+pm6kZ2uMIrOaLDMUuZD72t6jjUCAPkBPICiRONJKkRlZjPLMYrSMMjrnCM6JC1lZ0vXiX14WkgRkxsS2hyhTZtbiBkfT1BhtMTqLvBoRqEqs+WpWoU2B1hld7xmGwOAdanDYSvTVZ/M5ITAGiZQ4pz7yfL5A6wPJjjbJ46bqp+066qahruvIT8i4ubnmxcuXo5VrGldr205MhJYr2rajaZqIAHiEfS290mEQIx/npPo+XndieBSiKVK6tkLwBC+98b7vxVkvE/VPUfMUcEnuVVlgRz2PcBSTCkEKgb7rYtJgKcuc2azi4uKcFzc3vH7zNYfDjpevXvDhBx8Kd6BpIrriWa6WGK0pS9EMODs7w9iMLC8kmaqbKA8s/fKxIErvT8WJhSiQ5bynPtTUhwNtK5yP1DJJAW2s2LU46qUEO4RAsFk8Tu7J76d9ZO+PbVXnnOybJKP+fOIvhVjK0+X4peVt2pqURCER9vTk+cfHSqB+OlmUphdOi6f3tXTH1UElA6kwvi+SPTcRNdLyfhLSG/8oA3xaC4KhZfQ0BLGoTmTlhF2lYjW1PAC6VjG063gsVJTSP8aDVMim4+2GgaDTcVQReUhqtw4Ti+7ZbEYI0Vo7FtsWhVMhxkzhtAR9XPdFcO2HbT8qCTg/O5feUyQ3+cHRhyOR6Ai/y8H1WgLx0PVRBriJH0RIIHmZjdmy+Iybcd/BCUt/6IQBm4K/3GxE7eQQq/cgjw+BZFSgAKsFYrGZjd7WliLLR5apH2RkqmvakQnrQ5LzDbhekIDpRTcN9AmxSEjGlEDzQyrv9wX379umiMTpvp/r4f3QLd3cp/t8X/X/3Gc6ZQ/DtILwT5LAKVoQczLpu0EM/qdEF8naxeEsvZ4i9XmNVuS5tJDcIFX2fr8j+J7ge85WS+bzki+/+pKHxzuury/Y76/JM8dillHkhnll0L/8YzaP9/zhN79iGGq6bofRPcY4nGuBHq0GjHaE0OJcQ5EpFlUurnnBU7c13gV0hOSX87kkuyraVHoZ0XN9YL/dcffuDctFwWJeElxHCI6uU4RgaZoBMaJKAXFAa8/F+QqlDXleEVC8euXoh0DXBYpyTpabSFDq8OLRzWIxA6XJ5it0JsxiWfilRzybLdBasdmIyclut4vnWIK4LGpyLzStkPDu7x9pm4YXL665uLjgl7/8c25ubqiqOW3bjGOEDw8PLM9W3Ny8YL3Z0PeOtqup65blYhW1EAJu6Dk0dRRCkpbDciGIRde0DHESoB566nonxwVpBfVDS2ZnFFkOwdN3HYf9gaZtsNkMtGYY2jhqp7Ehw5i4rjjhacxmBbNZwYsXV3zwwQd89OFH1PWB3/z2b5lVJb/4+c/55JOPuLm54d27twQ811cXuPOVkLuURsx95DgVRcV8fsZmvaHZN+x3B27NLSHAcnlGZkXMqW977ut77u/uaJqGh/sHuq7lsNsz9AN5VlAWpTDEc5HeLfKS+WwukLM10hKN56rte0CkdA+HA8kHQSnRLUjrRRo1m7YDpi5/pwH6lHiY7s/TIK91IiK6uDZaUn0iz4c8DxgzjNoSXTfEFo9hKpoWV4FvJQWyL3UEDUMqgqacqcl6FIOzSogAkhzElOHYxo7+CF0XBZLcMCZKynsOh72ofk54E66XpFaOg0ZxXJ9dnD4Qs6aWwQkaY7SJ71+Pts6JMxUieT6NyE7jrI/Fa93s6TqDJepHpGPCD1//f1QSIIYL0SDIPWVmjhBu6tdKSibwR6r2YgKQkN4jEjAhphAILmVwsYc0gZBSRTC+7jT5mGaYpDaAyBXb8XUi5EzKVN2TivR4YR/39z7ofzp7OyXYnPbBxxMTvk1i+TFJwGkC8V2Pfy7Z+CEJxv8v2zRbT8dgChNO38v0OVrLDP14/t7zPo+VxtPfS/WbobUYzig0XhH7uAMiRe0FWp/N8F5gx/XjI5k13FyV4qNuNVZnnJ8tCUMjFYySSjEEh3cyRmcMsbrxMUn0WKOwVsexWCAmp1pJKyrPM0kCYOwvKx+TIzfQtQ1D10lrIMiIqncOrxVBxIjH6QEVp2esVShtyTLxql+tVrTtQGMGlLHj4uMcuKAJQaoNY6wk8zYStVSIPc6jm5sI9Ay0XSsJujVi6IVMPAQCbohTDoMkz+fn59zcXLNanTFfLMZrve/Fija5vCVHT0H0kmeI9FGHwQu0GkV8hAynR9nWdM8756KugiRIIY4DpmvqKcM8IYg+VnQRVcgsCfVz7qgDYm2q8grm8xllWbDbbTjsd1xcXIjGfxR8Cl7Iw7OqIgTPYj6LlW3iO0W75hGq7kSlT+knbRBrLM3+EFsvLU3dsNvtpGUWiYPWWmGtR3KZmKoFMHZcf47a8uLgiveip98f/VWm/f/pV9qmiN8ph+e5bbqupZ/TOiCJf0Di77EoGGHtmBWIF8HRDvi0gJiuF89vx3OttYZgRsRwatV+TCQmCQXHn8f1P76P6RoDeuQTSNwQLYiExoQYrKex4tsF2dMYxTPB+ilSnc7F0Sk3oU6iyCpS71aLtPH3H6dvbz8qCciLNH86RCjvCPnq6Y3qQ+yTHC0RpcoWHegsz7HWMJtL38xmJi4WMkbinRv3NQyOoXfxgCQk4CT5GL/kIMsCLSfOWj1+JYIVJE37Pt4c/YSkGCI0qcjyauzjpYUlIQDTn58jzzzXl0//f191ffr3H7JNX+e7eAan2/uSiFNy3/sQgefe+xFePGbA77sh0vEbEyjlEA9diOO+8rgnn0tFH/E0C3wUgCqKHNf3HPY7mQ5oDwxDhzZwvrrkbLXgX/zzf8ovfv7H/Opv/gu3797ym9/8mt/9TvF//qe/4OJiRVVeUOSGs5eXZKbn08own+Wcn82jENEhEvGW9B76vsboQBkV/qrSkulApxw6CCelKIS9OysyxADQETQYq9BBYSxY7cEPDL30pK0VGewQHATN1eUFRZGR5zaSk1V02wwoZcjykr73vHw1cH+/4fXrW9a7Aw932xjcFNoKyWmVZxir6SOHRhZJWKxWY/tsu9vxxeefs9vvuLu/Yz6bsVytJMHRKsKtnn3TUrcds+WC8zznv/+//Q+8evWKs/MLlDZsD3sR9SlLir6nnM3pneerb17TNC113UqAUHZsHR4h5CjqZSHZl3vvOdT72DOWJE1pCTBaK6qypJqV47HKclFn1Eomk7aHA70bZJxZa1aLBT6INXPTNuy3Dc71ZLllPptzcX4uLZ62hug1cX6+4vz8nN/85tf0fce8mpFlGVdXlygF291GkE4UNstYLOa0zcA337zmzZs3fPbZZxR5Tp4X0R3QcH19zXx2NGZKKqWpIsyixG5Kxsb7J86Ij4qsgHYO6/wo2JRGyU6LnHT/pt8lblcqco7V61PyNhynrd63rgiB0TCbFSN/5JQ7kNaI6f+Tk5/WR+XKtL2vDXn6f6VE9CmYybqmpgFXxTbKNAE4Fq5Jy2Twch3mUa0v7T+ZHQ2DG2NWWo8UHpuJ1kMysCsmk2QpCbOZSGCX5WxM3KS6T8fXPEFNEz9iOpWWGhOj+VVObHMcX+uHbj96OuA0+I4jGyqgwjGbAo4fbpJpTjPtU9euaV9K+ePFMrKZmUpa+klSQBSKkEppEkPiAYsoBacBLZHgpv2jiCBoTZ5ppuzh9F5TEvDc6MyP3f4uScBzicbp3/4ury3Pl7582tcpS/f0taaLyhQxmW7fYqCH8OTx6QZ8/jOryfuZ/nZCCIpyqx3HTDm9v8Q3scawXC65ur5isZiz3RTs98Jw3263ZBlcnM9FNS5Cq1VVkhfS+/cEGe3Tijyz4AJokSC2ZpJoWj3+HAIjOsA4yx4TYWPITEZuhMFeliVZtIZVMeF1w8CgZB95npHlEgC895JQaCZJKQSVke9rVAyYfd8SgiUgKpCBk+ovBnU5Z2nfUrlv9zu22y2bzYYQhKSWHDPT9E3X9/TDwHwxExLhzQ1X19doK+NRqVBYLBYAzLdbtDZsdztc78Zgb7MMNU0+ScnjUfhliEji8d4IoBinA5QCHQOiLM69aL2EIws9IQJGi/JbXuR451Fa0Jmua6UQcVJ0aC2cg8NhT9s2UX2wi1D9PYf6wNXFBVVZiZlQTDjCGGSPE1KjJfH+IGOBXT/a6g6JSDu5L6fVeFGKpLAUWxNbap6y6RO3IDCp4CWzIgVArfS4r4TqTNeyRJ5L7+P0/k+J4nSNPb7vdLfKX6fiRNN7nvHxT4uE79qeVOmTn9P/0/5kO6qenuxlhMlDOEUUj59IKTX2/o8xIRZ6Y0yboiVyHavAiEynzzVlZ6X3ZwIoH+IkgYkJgBhqJSRh2grxfqqlENdopWCiX+C953gF8Z7P//z2o5KA/X43LhZTdbiUsZzCSOlDpJtgtBKO3t8p20tZahqJSX2WdENPofXgw7iYTQ+svOjkmwJUEPcrJYIg6Sp1XghAPlpzosJIhtJa9KAza1gtqqgu+G2p32kmfUqICyGMxMnT7X0V9TTwp/2NH2sSXKc3wRR+T7+bvsZz2/clKvIaTyG9H4ICTJO90yRleqwE3Xk6fyzfvXhBhfHkjedShUkeHxevdP9qJHu/uLhgv9+xfrzDZIYsq3CDwXXQdw13dw1d26C1jHWdnS0pCsPQd3z6u9/w1VeaxTzHLebowYBy/OSnn7BcVAyuQ4WAtYo8N1RlxrKo0FnBbi/EuFmZM6sKlosZmc0oC4f3ELwieDjsNnLtDo7ZrOLq8oLz1YpXNx+xXC5ZrZaslgvm8xmHWoiK6/UepQIvX16iNGNVtdk8Su/RZGRZwWIZ0DrD2gIfHIf2QN0cqNua+fycslzgEeGtpm9phx67yNDGkuXFeA82bcub1695++4df/VXfzVC+CjN6uycOjK303lbr9fUTc1/88s/5eOPPuKPfvozzs/P2O/3NHXNV1+/5uzsjH/xL/45+/2B84tL7u4f+N2nf2A+m7NcLSmrGWVZCRcogAsBF7yMxRkD9DjneXx8AJiI2ghxbzYvI2mxJbMGTWD9+Mhut6UsC7LsaMk69KIvkBfSQpnP50JWHgYO9YG3797IZEIjtsp5ZjkcDux3u7FguL+/w1rL+vGBoe+4ublhPp/TdjWL+YJXL18CsNluGLqOt9stWmUU+QwVoD4cCL5EoWjrhuA9Z4ulqP3lOZkxbDcbSRgOB4wx/PSPfoIxhsPhIIqL250kY3KToY2haRoOh4PcV0pJe0sVBBfABVG443i/WZPHYKewxlAUoitgM8vQCwnUDQHn+jFpSOuj1olUSFyvjklLCIHgRQAryyxtq55ID6dKP60VU1Q1bd77UXTpdL07XYufTiTI9sTunWOhGFfA+P8AQceEM+VJRw2CrhtGaV6APC/G2HdcKxUmjv7leU7X1qzv7ilLR2bzEc2WdoS040BjSSPlU0O9EF1tjxyz5D/gvaMf5BrXKj4mz8kyEQQjBIa+Hm2bQUS5fuj2o5KA4P2YWYqtp/QtQ6rWfTjadMZUSyGZTKq0lTou4N4djWb6QW5GH/eZnncMODEQjDCwGlPQkBjlCRGI31OfOfUQCdIXTHoChGg9Gnt2aYHJ8wnRbxJ4T0f+TjPT56D052Cr6XYK50+zyOnv3/f13H6e+3m6//dn0GGsvN73vO9KAtL372pJTBOd6e+U9niSS5iPJi96hKsTq1bHVk+6iOS6O55P4RcojNIUmcHMCprmID13N9D3XWR7X7DdKLrO4ENBnqu4GHgGJwtaFqG9LLME58ReVSfTGgjeobQwhauqZFaVGL1BjIIMwcPQy+dKAJ7SYOI1l+aRU0UoXzLjbjRkVljwxhqUSsp3XYQHIcvlvui6Dq0DysrMvo1VbllVGGtkOkEJ2WqIFYPSBmMzCcAK6lqq9t1edPdlJEpMV4C4CPV0XXu8LrShLCvOzs85v7ik/P/y9l9NkiRJmiD4CVBkyM3dIyIjMrOqsruqe2a3d2eO7mXv5e6I5u8P7e4c3WxPX093UVXCgA4MKBRwDywsKqqu7hGe1TWa5GlhZmoKREUYfvxxWUHrHM4d0fUDbm9vKaSvMmQhBE6UrUSiYgwJPwChLJde2aPkucdCFvAEpgz2sXMWfd+RIU9hQZqrIaUYsUSefFMpR08Q8KGsOJTTZdStTwpg6NrEwybnhJvUsBzJMh36PVBJ4/F4hDWGmjbB43Q6xfLXIl9hs6K0wXazjXPUWhsULlU2UArVBQyFJa9dKr616BTlRQGlR8wHVV0lii7KDwHpiJ0vZQR8aJyPfVtYGafRBS/TNZ2ubZaL00guA3/7nq4rxWewwuOI3TSaKoKumB4/6g0xhvSnEQV6nuk2lUEy+T6JLCKVn4g4MY40zeXWGK2hlHMqzln/sKwk4zmUHwYjIAKhMXLRTFXCVD4rFaIyIhmDaFgk9xx9pofP5ku255UICgET6lD7vqd8k3XxAhFCVHYg3ABbZDwBtRBQAnBmgHEWx1D7G0sHjeEnCusdFTZjFARSMgBPTiYW50acczG0Zq2lsix4eGvQN9OuVACVDOZKQRdk5eX5WMtOx55GG1LvfDIuSk0sWbIk+7gYHtvminz+3XxbMiKWPnuqRJBf579LreZ0QT2l7B877nyfJfwGl7rwfrkChPYYdI9edcgLYqvjxWIClbP2wTgIxspgDETncTzcw5qBKk0EoBVwfXmBV6+u8OOP3+OXn39E29S4+/QJv/nma5S//xv8y7/8d5xO9/jNb3fIc4HVqoRSAv0wkAcU+sNfXu7R1jUOfQudKazXFe6ONY7ne1g7IC80Xr16gaJa4fsf36Lra6yqPQCJoSP0epGxcSKwKnPkmUQWiLd8mLdCUNfD9fqKmP5KYgssygzeOxwO92jbBre3txBCYntxQcrUenih4IWGsRb7qz3KzQ77a4fbuxOOxwbrTYEsL+C7Hs4L8sBXG7x+/RrwHr+8fYvj6YT37z/gcDxCZ2ScrFbEC3I6EalN17eEbjYG3377Da6urvCHP/w9vvnmG2y2Wyil0bQdbu/u8f/9r/+IN2/e4P/5//p/U+4S5DkV5QreC5zONSCoIYsUKpTHBcXkOBJFHuXV1RW8Iy+/bRs4b9CeO7x/fyK+hu0KWUbjqZVCrjMUeY4iEAN5eKhMwYuxhO72lqILVVkizzS26xVub2/xxz/+kQimdjvU9RnD0CHP16FTHKWWrn/7LfI8x8f3H9B1LX78/nt47/H/+6d/igqRjZer/St895sLXF1c4T/8L/+B+i58+oTa1GiaFqfTGVpp9B1Feo6HE4wZQqWGxOFwJCNltUaeF9jt9pF6uusGWEuRAak0FFNzK1pjg+sgPSKhESv2lLMFANqWyjs5SpvneWxOMwf2shxMKeK5wqDve6Js1hnalrqIclMq7xEBp3ws53ysjRcCMdeeks895vGTbPETZ5EM12U6dlaMi7FQQQZixEFgjE7QdRJmyU2MiXE8jDGAsyhLavV9Op1jAnoOKBeS2gNzZ04gOLfBueZKibIsCFjvfXQUotwVZMTylinqjpnez5duz+YJSK0U6amXczrgY65qrP98GPqderBjiOph218+zrwsb2IEeMAELvAh5EONZUt6DC3HvE8Ig3HjEKV1yB2noX9KPbgFJftvsT2m/B/7fimf9iXH+dJzjzm25x9v6Zr4ej+XfpimE/zESwDGFIBYOoz3YB6Hvu/hLKGohZbUgConoVYWBaqSOvHleRZDcDMzPIKogg9FvBLhHiznwGd/AOWlCfVdwxgyQssyh4DC+XiKgkBLiTLLsVqVWK8qZDndLwsRbnsLb2GthBD0KkM1Al17SNlIiaKq4J1APxBvf5ZnkLpAXkm0nUPbOTStwbkmVkMPQt47EGteUZQABKx3GIwhilOtkRc51psNcQUUBIyyYS14D+RFgaKs8OLlS7x69Qqb7RZFUaJpWkglUZQlkQ1tt8jyAofjMQhoArOt1uvAKULeq7WEYPciIHuEhJTk/jqwwcgc7KEBT6YB72BNgTzPAjaD/vI8hy1LFFmOTGfhmYS5JgKmByJECF0CcqZqjrIsUXAn1DxHVVXY7/e42O0IhCgELi8vkWc5TodjVJTEFEgllUU+Us5672IqZ4xOAN66wPfQos4yGgc39ZwFEGvmqQqE6J8ZnOkclUbLED5xnrpZcgk10dWOcnJaDSDi66jUxj9WziN2i65oxNyQQa5CtYfWGbjV8TR0PsrfNJ36MBK5DKyeb0tpz+m/H9eBj0kjFn1RhoHfY0wX0BVStFmEmAJHIcIQCikB5+CcGJFofowUIKY7+bwxnE1KPIm6SkkVNNwvZ+JkxUhoHJX5ID06fvPtWUYAkxhQXfHI75w+WGAsCUwZ5MhCmxLpLOWOHyp8Alvxb+YNinhQ5mx1VELkqW96Ek6aGyT0bxn3oc2FKMey5//X3n6NYk9/uxSST7977BzjeNL7x46TbvOUyOeU/lPHGZnIpoJKgKJQPvUEwsLyjmrG6/M5NKTqkSlSUkzYsttuMXSXuL6+wtXVJfq+QdOc0HcNzNCjkT2ME9h0A3ymQmMahSyj8LUxBm3X4ng6gpp5FKibDl3HPOw5bm8/4aef3qE+n+Ccxf7yAkpq3Hz6BGc9Mi1RFgWu9nts1mu8enENb88w5gbEAeNxPCp4bwFB4cY8o+qW6xeXKMsc+/0eeZ7jYr8HhEA3DDiezvjhh7fIsgwX+z2Kco1qfYFzPeBcD2h6i0PTwgugNwbd0AOQWG93WG/36I1B23Y4nmp0/YD1ZoO8JNpfVjR935H3DQBS4sWLl7i4uMB/+I//EV9//TW+ev0aRVHg7Yf3AIDf/e53WG22+MPf/zsoJfHnH36M3mW5WuOrr/LI7geh0HeW0hlBQSs50nq3fQ3rHe7u7iAEQuWQx3q9AgK2gzKtngy9vICSAquqjM3CzuczetsT34gU2OzWkFLS511H/P4gI8s6h8v9Huv1mubObgfnLH7/N3+Dr998jSG0qd5tt5BC4ng4RJxT33e4vycypVcvXkIIyocrIQMzoEHfdWjrhqI/oSPg/e0duqZFGfj+VysuMyQZegjHBBAJaibrTABOAMKPaHHTB2O02iBLWsyOYXgFbqIzKh0FBLCgc55oa8sRU8ERvbHKgKOzVJ8upUJREAskG7dLIOE0UjmXL49FMZ+zkSxZ/GaeNMAYHfBgT2PqpALMQ8Au0ggu9NEQYJPNSyoj9F4E7JqHCG5F7IUbDIc0KioE98GYkcSBCmBjOoJfwSn5YEhEojy+07+SEfBo7SaCBRQumnNDHCYSoFxX2kWOASzz43JEgJG+pJxpgkr5sCwvWkeSas2t5JpzwAu2WOn6ZMKulUYZ0tBO+nCWwuZfun2JAn1qm3v9T71fOveXHnvh28l+X3KsXztG6eY9pZacJe+M/81EH4IzeGLcnw0Baz26vgOchXMDhfT7DG3b4Hw6YRj6kEujudC1LZrQBtYHb9R5YDCERQnV8GFBEmDNhyjFYIjXnfLjA6wjbynPcqxWK1y/eIFhsNhutxAQWK1X8NZhv9uhyHLs1iuUBSkqqTLIgri/y6LA/nKP3W4DIRhDYKJgGoxF07QYjIHOM6I1VQRw2+y2UDqHUAqDtTDnM7zXyMsCq80a290ObWcxDJZyyZC4v79H3ZqQVx8IzNe2QdAJSEU4CKLUJmQyQM1YVqs19vs91usNyrIKbHQNPn74CCEE/uZv/har1Qpv3nwNY4ZY+qa1pnvWBYTo4ILHamDjnMyyLLb7hqfnSka9IeeGPa+QT87zjPokOBvFuQj3YB01JeLSrKYnQ6aqKkgp0XVdDGErKZGtVqHnwDo6GUIISHAnU04cA6fjOQrdPM+xXtFzff3VV1BS4frFi9jYqsjX2Kz3qM81hn4A163nWY6yrEJjmBxZlgeSngJSCmII9Ai4DRFYKkMjqDRnLVm5+BhhYZxAltt4vnG9iolRkXqeU7k65sKBUa6zoZGmPVIZzvTAGFdtIi+oVDtZ+Il7Plap8PvFP96fverUu/bsfT8uk/wj70KFHgEXwZ7+CBwU0715j0SeSkAqwjax9y99lF/jPdFvH+qYh1gvxraxzI/Pwo3MuGyMTKMBfyUjQCsFhJQAhdTC6WYXzl4cT5omhMrmdfbznA+H+ZlDWWsNbik6L9Obh4R8YCfU0sELCQEL7yV1iUpyMulrClbhCe0Y3OindZn/I7enQH6PpQXSjcfkqeOk7+fPbr7P50L7T0UfvnSj1IsNnPIW1jho5QHlowGHYLB5jPzlnK9rO6JuhSNyIK0FlPAQzsCYLvyUrP3j6YDD4Z4UjHeQEPBeomkHWOWgvIMWQBFyd94LWAdY49H1Pc5NjXM9oO0MnMjghMJ6s8ELJ1CuLmC9wG63hzEWV9d7SAh8++ZrZEpBC0H0pEBoD1yiqkpUVYVXX73E1dUlecVwFK0YOrTtGX0/4HQ+QUiBduhQlCWuX7xCXpZ4+forGAv0g0PddDieD9jtr3Gx3+Hy6grGCvzy/hM6UyMrC3hI/PjTTzB2JI2hVAY1SSEmM8Re9dyKl9ZmgcvLS7x58wYXF3tU1QpNQziBP/7xT1BK4n/73/4f2O12+J//p/8Zd3d3+G//9I9RcWy2e1y/3ABQsNYnnURJqBVZHuvn4T3O9YkijyG1pxVH8aj9clFUZEgMgR8kgAQpjD7Esr5hGHB3dw/jLKqqDDiHU0TVl2WJVbUm0OjVHnVdU/TBi2Bz+Eh4ZgeHD7fv0bYEIKyqCpf7SygpcbHdQSmFi4sL9H2Hm5sbVOUO1/uv8eHDR9Tnc1DkClW1htZ5jDqw3OMuh86Rd73TWexCl0ZdnXcTJUuUyy60WibsVl6MZDbpemdFHY+V5P7nsnXe+4Uju2l/lBQXRT0gPKRgEKCNSpQR8Xz88dkjpmiBgL+Kyl0EDc0x9yh5wLgt8HMKz+pROZP+dKbSIcZyZoYSjrItUcjhAJw+jdFVKSC0hnQeABFj+SQaMpfbPO7OuVgiy+Mfn4OgO+R90+64LPu8pxTmr92e10o4KGO2PNIw+1QBCHC9uRAIZTopWYSYvDIZiNZMHjO+ek/WPE0UAeemRodjT86NfPVUn8to1/GcvI0cA0iO4WfH+MsiAQ/H5Hm//ZJtSfGm15v++3MGgIhu1lj6k57jKSX/lxoAfAyuDLHBczPGQEtJzXckMCbiksUfKhrKoiDzIDADZooiQsYaFHmGPC9RlSWVQ+XkeSsRAD85KRBrPXpn0cIhUwI6J7CQlBo6K1CUK2RZCSk1ICxFD5ylZiBSEAMdCPh0e3sL5zw26w2KPMerVy8B79GeTjDDgKbtsFpvcHl1iSyjfuGa2q4h1vQHfgzOLYrQdyDLCyilca4b4jTIK+rkF0qJmrZFGTzBar3GNRTq3sILhWGw1ASprtENNpDECKJSlTISyzDmoe/JABgGQjsrTxUDVFpIOcvNdoNqtcJ6s4ExBu/ev8fxdELfdzidzjCGog1t20LpIlQEUGlbBm4yFnoAzIxvjhhWRQEIar7inUPXU0dHZ0uKBPgRbMrX3nUtzEB8+0opbDYb2JCfb5oWHz9+QtPU+PTpE2EH+gGr1Qr3h0sM/YC2baCVwsuXL6GVRlM3sYqoLCpIEehpISgd5X1oaAQ0TRN6Ldwi12ec7sgI+fjhY2BZNJBCoMhziloYg7vzGc752HmxKAqIfOzrECuyAgkbcU5M5cwQQNk2zMuu6yP4jp2ocb2PUdilMuiULChNtaYEQlISHobp08dNhFQDRZBYtrBDxr8nWTteP1/P0w4Y759GEZJvn3RYlnEBMdwvmF8BacI9nFU8SChM0qEgHgcnKN0C5+BlKnvTiAYfPvzbUTmm9y7SGisp2bZJDIaQarcjA6RzhOXRSRRlHoF5anu2EQCMNaJTRT5ad1QyAgih4JwAkC96mGMUQESlz2VS3BiBCgZG8Ap3ruJzpZgAGih+5TCVSK53DPfHbnUziyw1ANwTFuXntn8rI2A+mdN7/1xE4KnrWr4+LpOb7j83BOaRgX+LlEBq6ZrBYNADeQ1K0aLgcCwbKRwWBpG/VGVJDYMkoBSQBTCdtQOq3QWu9jtsVivkmUZVFnCmhAuo+wEW1lt09RmDt8DgkGcShc7hvIRUOfK8xGq9hc504Pge4DwR6/SGPCqdaerk1ve4uztAQOLN669xsdvh22+/wdD3+LlvMQw9TvUJL1/t8Oqr1wAoCpLleVzwDFpj8JwXntDfmUZZrQAhcDgdkRUlrlZbGBea9AwD6qbBquthrMN2t8Pu8hpN7wCpcTzVaJoOx/MJ57rDdruNAlwEkBkbEkPo/td1PfrBQCoFnwE6ywhUGGqfL/aX0FrhYr/H6XTCn7//IfDOa/LCjUHbdbi9u4POKwplCurJzh6/McTD7q2JrGwCRACkpMR2t4H3Hsf7ewzWomnOELCww2r0WJ2DDHwjbduiawnzUVUVdJZhv9/DgVohn89n/Pzzz9T+99MNAOCXn3/GarXC1dUVKXul8O233+Cbb75B17Y4Hk6BX6LAer1BUZhotN7e3mAY+qgo+75H3/c4HA5QokAmP6A+1zgej5GTvygKZBn1bBj6Ae/fUXTh+voa6/Ua3333HUUsxDlWZDHpEK+VNKIKjBwjXOPetGSMjOXPeYwEpEYBr+N0ix0+EwOLlQ6fK43QslzgSi4uL50bdSnqPj0eMGICUkPjOdtno5LsRyx8zr/nSMAy3c7016nsk0JCcpwvOCoeY4UbefZycqyIXxBMcDVyqHguEQQiPocZe83Qow9U0M45ZGI1MQKesz2bMXDken7YPnLpoVEN7thueO5dzw2INOQxgljoyQmOBDGAIx4EkIpIWZSWof/4aKQAgIcLkUKDyCXgx5wKfTRalmQVTs7yrG1eBfFrty9V9HPDaOm7x441fr6cWviS13+LjYXCMAxQOoQxFeNIdJr2i3lfGUCd1loIRQhlAW4PDRhDzFzr9QreO9RNDR9q6cnDctB5CeEdWgTAlgCUA7znIlMyBMpqDZ1R+9DBClhImHOH3g7UDKcbyLvNiQHPOY+mqeGswT/90wBnLZrTEVJIajSjFO7uDwjQn0B6U8K5Ad5ZnOt7DEOHrm/gvAUkKeCsKJDlOcpqBS8kbu8P6I1D05JhUlQVzk2D5scfsLm4QrXaQmYaq/UGN3dHnJsWvbEw1uF0bmKUbhgG3NzehnByC6LWDsQrAsjLEtvdDvurK1y/fElVAVWJzXaHPM/w6quvUFQVmrZF23XYbNaQSuHVV6/RNA0gJKrVOkYClNIxouidh5NkgDjnIIMRoCQgQzQRAMqqALVS7kIvExUU8QABBRNiwipEFgUy5FlOXA9ZBuMszqczTqcTpJBYrzZ4cf0SAlwGRuKlaRp8OBzivBz6HmYwuL/foCwLbDcbaKVxuD/QfFXcTCyHdx5FPgRDpEffWtzd30X5yaV4nAJgkPXxeIznYyUYPVPnEgU7BUmnWKs0hO+dp0iAZWXN2IYUF6USOTfiABgTwEY3nWdsiQuMMk7rbAa2VgkrIW3zf0886M8p7mduacphvo3pgAVkgFiOwvJHMQoQZR47QePnHMKfO1rzEH/6GT83ay2En3IFBEU2MZhSUro5piC56s8NU9yeGQmwk7zUHOXPGz/QufKZd6Gab6kRMDLPuciXHvaa3Cd7hVKKkDaS8NJDej53UFTeB6BQamBMiXMm1wwBIQgt+2s2Hp9fsz02Nl+6SB4771Opg/Sz+edLiv+vYQQAiSczkBGQ5wbeKiA+CjYAQ6MeyXOLKH2VUoEsxgVAm4hGgPOU+/ZwUFoCnQ+NWXI6lleES/CAcgLOy/inVIaqWkNpjSzP0FvAeIFz5wBBNdt911Ob4DwQyziDpqnR1Ge8+/lnCv9qhd12i+urN5BS4u7+PgiZYAQMPZyj9qWn8z36vkMfjAChKN9aVBVW6zW2+0sMg8XH2wOMBYwTcKDSwbvDGfeHT3jlJfaCGs9Ua4nBWtRti8HY8NfEse978tbZ2+SN2DQl8qLAZrfD/vIK1y9eoggll5vtFmVZ4uWrV9BZhj/+8Y/kneQ5VisyDs7nM/rBIC8qWEfZVQKJkREnjYW0SckgaO0SWReCogFsWUBKoO/zCCL0gUOCHEqKDklBGCYpBPIso1SLzuDNgPOpxul4hhQKZVXib//2byEE0LYNmrrB3c0NurbD+3fvI4rfhvbDm80KZVniu9/+Dpv1Gof7I/q+x4uXV2PFVCArkkLhnNfo6jPu7u6Q5wQezfM8lq7mRRGrAj59+jQR9GGiT+Qse90sX7inPZfxpZv3Hjef7tB3PdImOvTbER81dyDGyhyWGWQIUO+VZeZSTuuO+IOHLX/H4y0bAunrX7LxNSxtUyPgISbg8d+k+09fow4BZkYAFseJjzcZG0FMtnDTUvzUCEj1VoqJYmzCJMogvlz3PLs6gEF1DApJrU++yIgbENO8E/CQOGaufB8qZ2oSEu/tMQvvEe936bzTErRxQqb5MiEEBH59ucq/VSQAWA79Lx079Rzmn3/Jexqfh3TMXxoF+EsMAhHUOntBUg7wnhDUQkhInUMJGRG8FNYjrnMhBLJMRhY+bjrlnIAzCGFtKnOjVIEI9eQZrFMwXsI4D+sVPLKYioLUcF6i6w3hw6UmmlCdIctK5Dnw6dMP+PGnX/D2wy3qtsfLr75Bnpe4ur5C3/X49OEj2qbDpw+3WFcl/vZ3X2O1XlHDGWnhfB/yzETdWpUVuqGBMX1YyFRbr6BQVAXyssD+8hJFWYZxEVhvtjDWoe0dHBQcNHRrANnh3LRw4h5dT215P97e4ObuDnmRQ+sCTdPEdaCURp6XkHKIaTeiWV5ht9vi7/7+7/GHP/web968QZ7nZPj0PX744QcopfDhwyecz6fQbTAx6IJXS14vlUF5B5iQ7hDw6IeeWEMddSSEoNr3YbAxgqOkjPJlVa2gtQSEhzEDTucztFLIlIZSY3Mqjvj1HbVF7geDPC9wcUG0rFVV4fXr1+RtW0N4jTdf4+eff45r7HQ4RWbHvjcw5oy3b98iz3K8e/cucBg4lEWBzXYLay1ub25wOp3wyy+/wPQU1SiyDJv1mlIvAFUn9H2MCFxfX6MsS5xOJzjn8OHDB+gsQ17ki9GBlAXQWAvjAiuqH+VfVVUoi3Iii1M5PpfNHPmZGgEApxDS3/J6Z4Nl7hwwxiONErP8TeXFHCPwl26fTcWmIeSZUxl1RLy+WO0/3heWZaCfRFKAibAK10W9JTBR0kqp0Bp4dEiX7gkgZ1cqAQ0FIQFrJYGb1a9zOIFfYQTwJBhDUKE1r3cxz55eeKqU5g96bv2N39to6UgVKmCSY6avz9nmRgC/nyvseN3i1yvyz07EX7l9zgAApotqaRGmv3n4uuzl//XTASIyxjlYWGMhQPzdKlRtjMYglwsKor9VROVLWBIJZ4k+1znAghgsOb+ttYCuSkitoLQGrEPvBKz1oLY8MnB4S0AoOC8wDA5ZoPoVUkEGY0Brh+PhSB3iPt2j7Q0ur79CtaJmRW3W4ccffsTheML79zfYX2wh/1YiL3JstmsMQ4u6aSG1ImBPRvS61g9w3pA3FVMiAkVVoawqrDdbZFlO30mgWmn0g4OFISNAaCjdQiiFbhgwnE7oQong4XTE8XzGZrWGyHTM+SKsU07daW2D1ympOdCLl/jud7/DP/zDP0Q5wOV1Hz58BOBxOBzQti2spSgerzNmiCNvVQMQAYAY2Cm9C1UhKee7gxe8D7HRUTvw0DCqLEIQiCIobdMg1xm8tihKMjZ0MBC7rsMwDDgeTuiGAZnOUeQl9vs9VqsK+/0ltKJsLtW3U9e7+/s7HO4PONzfR2+bcv0WNzd3UFLi7u6WUPhZhmG1QlWtYiXC4XDAx4+foEWOMttAa6ImZtnADZi8p2qr7XYbjCsyWol5T2N/dRnHk6b9WE3Fx2Ig4FymlUUJKdQDuZyG73kdp8p5yUljw4o77S3J0ngeP+Ku5g7M3Ajga5qf+0vlBpJyvSAWHt87hvZTBU2st6zcqQ5/jABwi+oo85J7mX4+plFGY4H01yRiIikaMNGLDvE86VixnONLFVKAOmQQWFpISlv+JbrmWUaAALXtVFyqI4OiBPU1pqT7yOPtAbKGYliErH4huLogMRKCZ+eco3ChswEAYUEEKg/DRg/+gLHUgvcJ6HIpBEQID2o1EmTA+wA8o8GeTnoN8YywSrqNwuz5W6q05+/nCyrdh1+XjK754pp/Nh7LLR5/KRWwtN+v3YQUkF7CcTmSIW8073vyegxV70ulyEsMWADm1TeG5svQtxiGFm1zRqYFci3x4eMHWNfh6zev4NwF+q6mTn+KVlHvMwzWwxhajFYLWCdgDWAGj663QK6QCR2NgnPd4P54glQa290e9eCh2h513cA6oChXRFQlJTItsdnmyDKPjx8/4ng84OeffwS8hfc9Li/3uLq+hP/NNyjKHEVVodqsUK4qWDsAIAIhLyinbIzBYCzaboDOcmwuLqE8GcxKZRC6xFdvVrh6+QZ//v5nvH3/Cedzi7YbUDcdrPdoO2Im7HpC2+tcx5CksRaDIcpXlQXOjiQNEfPYQqBtWwBE2rS92KGsSiCwdgqp0BuDTze3UFphtV6DOhoCTCZDRqeLikvmOQQ8dKgIddbENSuFiFSpSgDGWXRmwLmuKX3hHKTwMAOooiSU3DVNg3Nd45/+6Z9xbhr84Q9/wG63w263Q5ZnOJ3OtP4dyy2KYKxWG0oZFCWxEmYam/UGSsrY5+Tly1cEwKsb9IE8ipo8EVZgt9vBGcC2LhyrQhFSAcfjEXXTwAwW53MNISSKosTr11+DesWTIVZUJbxHwpoYPEJJHqS1NrAPBm/SewhNjJdZlkMrPUmDfvGa/IzDxZEeLhlMjRPvI+t7IkOnIe3xPNRxkww6/o7POSXaWY7Zp/uS8SHlskyKp42HYccHDyMB8TsX96RjLDtAznP/E5apbDxwVH8EB07eg56nM/aBnPUAhHPxekVID2WhpTcDS6WVk6DGc7ZnGQGUa2OgSIq6p+/SBU1WDJdUjIqZay05n8/tQkdLEONxnAs9CIYHE3IJmCiEIEDReFEQHHISwfpKkKn8uhx+Gekwf832lyjG9JqWlP98n3SbpwM4fJou/nlobh4JSGfTc1IBf4k1KhAsY8aDwIHoc6fdGeN5glVM9zqWFw6OkLPGGEoXCIW6qSHvLPYXa2w2FQFIpUBZFpBSw8IRD4D1EN5TGsEBzhKHvXUOzlMUwHvAGiq9apoGHoJodIsS1lMzH+s8VEYVMTJ4UFWpoZVA0zSoz2d8eP8OSnpQMMJCZwpt9wLWOZQZUeHmuSYsgKB770L+3jnqpXCuGxSlxyooBucdlKD0QV6WULrEn77/Bff3B5zqFl3Xw1gq2RoGE4B/JHh0eOpEnewifbKUFDFhQCSxyBG/fF3XY/gYjvo2KIWq7xOl43Gu64CoX8FaiWEYsT9RboQ5p6QiIKAm2WJFEP/BUGfyMS8FrKUIwRBQ81rJqBQFxvA1e9afbj7hdK7x+9//PvKRSCnRNm1wXMCjQEQ7OoOoAK1odIQAyrwI904lgVVF1QnH+yPhOE7Ea9B1Hbz3KMsSQ+dgW2Lny7IcVVlhtVrF8ksqvzOhe5xEVa2iMUEyiyJ7w6Ama4D3IY8biQKlFcW5cZU4Pc/xsj8XzeRjjQyCqTdP62lMOZCWpRK30bMeU7AIxuHcCHhMWsSrwDSsP6aVH/tpfMxxc8EAGDluRino4txcjgQwgBKBbyQxdJDKRfqLuincAkdtnQ/xTbEQveW7ShgNhZAMhwJ8aMCV3PJzZPGzqwPSnP/88zT/l04KVkz8gPnzlLwnvWk+BzANH80NgXm+KlWAS+CVOcCGt8mDi4uEy2d+nWKTUv5qsqF5JOC5v1UzQyclBZmH3ZYwGOlvefsSY+AvMgKE4CA/CZaQEorpAGvhVKih9eMzpbyvA7yAC/eY5znWVY6qyrFZFwAMBCy2mw2u95c4ne4xdB3VaCsBbwWcJTZAOIMWFj6TKFWGInfwTkAKBa0z9EOPvu9wd3+Pd+8+4NOnG9ze3kFKIn+5PRzhnEdRraG1xvWLF7BmwMvrK2pHLKhaoSxyrNcV9vsdttsNtrstvnp1je32AtQzYGxzrbOMiEgMyMtTClp6rNYr1E2L//L/+S9o2gGHU4vN7hJXL15D5xVUtsL//n/8H/jP//n/xKvXX2O7vcDV9RWkzPDP//gDjsc6zo31QJGLum4gBLBarbDdbvHq1SvsdltcXu6htY6NZrIsx4cPH/Dhw4e4rrbbNZRW2O12cV60bYu3b9/GagNrBfo+GEP1aUSpCwrJ6oDHEEKCieWEEMSwKAS8p17xxgwY+g7n8xnOWuR5FnP8NpS2RQHriFTnd7/7Dv1gkecF2rbDf/tv/wTvAa2pxPTVy5foux6Hwz2OxwNuPn3CZrPBfr/Hjz/+gA8f3gcqYhm98vV6Da3G3PyH9x8BIVAWFTjGvF2VWL/eY7PZYLPZUJ6+JIIoSnlStJJD7Vy2Wdc1GRShaRvLVmttVDBcxsd9J7gbJTEQUrt3Li1MUzMsBzn9M3GkEkxXivlKSdZYnqR/adWCtQ7OTZ03fhap45HiyjjlkRo5v2Z7WNrtp/8S8+98/DzKw8k3M6zD5Nejtw9Mkf3LMjxJCaRGmQuRBLfQil2OEYB0XNJ/ezMaK8/dnhkJEEneJJThyfH9vPY+/sZj8jcZjKi4BYQgQgy2lr5kEoz146xIgtEhZBJCmZbWzAExHL6x4mHI7FkTMbHMHpvE88e0eHRP8aOJdx1/6EfLMNk9PbKIMZcwPvH1YXgv3fdL4klsc4+vYnIxgk16vv7xrI9P0tSIT6I4HogePi8Qld49nzeO9RglynJqhJOXBeAU4A3KcoXVeoPT6YB+oHp0YvcKNemC+hN4T+FtjgIYG1reCgnnCYTF/d67ljxRXa6hpKZohKHacSUlyrIEXA6UJYWarUGeZ9iu19jt1nj58hJFqBvXOgOiQ+phg6eho1eXUSRNEKGQdUDddvjpl7eomx73xwaX9QAncuTFGlk54OPHT3j//gNWmz3KaoM8L5HlBQYzxFC+lFQu6RwZW0rJSFazWq1iPbuU1DqXNx4DNuRX6xLKB8rf8EyGnlqEe+/Rdz0G49G1wYMfiGRGSUWMqxJU7eEB+NArIjxn70Mbc/iA2B9grImESlKSMs+yLKRLBmQug/JE6COVwG67hQnEOc46HA7kvWeZhjUG+91FvKe26WKDKD7m+XwmAxQUvRHBrcyyDFVRhnukNEq+Keg5AajKNS4vLiMjYFpbHw12N6ZI05K/NM8/V6LO+0is5aybyB0pJbTSgYnTJZGf0QiISkXSM/Op3BIicjTMnTeen3HtSaJ4Tg0JgJSa8HK6PzDRDxOF6rlJlY9zKJUHfL6J/GN5E46V6p3x/8lZxORSkEahUt20JAt9GiyKB5/u65PjpV89JVnnMj7egwe8CB6+pBbZTA04l+HLV/xl27OMgKyoAGgYB7huGEELIfzjhaI6/eQ3AgCknFhWoUAIXmh4IQEZmKaC8oAIORDhkGcCRZZFZRNfg+dI7EoUvhfp52K2HwSojygbLTb5jo4rZSjxUbRPE3qqIwqj0ciYfMb/TpSTynQgjwmL1/JidpNJxOxQMb0hBJUjDQPY6AqDk4Shpq+TWW0djO/HXwXLS4Cq7KSQ8Co0uvDTBQnvYQJrVfoE43PmO5wZN7wWnGWEq4+hNXgPy16ApeCa8y6ZC2QcWIDq81clVmoNMwS+dzegbS1EWaIQgC4zQAlYBApXRw2idOCSgFQwzuHcdqjbFp9u7/Hb3/0G3377Nb77d/8B3333W3z/9gY/fniLY69RVhYX1yXWmwyXl18D3mFoa+Kidz2aYcCPb9/j8nIHVeQY+h59Z1GfW5yPJyjvsCkyakOsM2DYoesHnO9uUAuF7cUldF6i2uyoLEtlVGq33WKfC7ysJH7+5Wf89POPqFYVyrLC3/27v8OLr17ieLxDO/SQGfEPrHYb6hkgNe7OB/zn//2/4d37D/i//q9/RtcbNJ3BxcUVXrz6iMv9NfaXLyDEBX7/+/+I1WoL2ArtScBoh9VqDe8Ftd72Hsb0VN9eFMhCW104hw/v3uJUVaiPR/z+u+/w8uqKlFs/YL/eAtcWdUMhcGU9vBtwe3cbwHXk4V1Uq9AieYP7+wNubz8gL3JcrcvRIw2gTq25p4iPs885h08f3oPq+D2sGVCfT1ivV3jz+iscjgd8ePcO2+0Ku/0a96cbvL95izfFG1R5hvW+QmEyGEnVBkVBlSivXu7Rdx1uPn3Ch+M9fv7hz8izHJv1BlmW4c1Xr+Gsxf3NDQqV4/X1a/RtCzMYGGvIUGwczLnFfX+A1hl+++23KMsKu91FqFahahJdlBj6Hqe6xrlpotfLDI3eOXgpoEKKAADOZ+pPwKQ78IDwoZeBAKTw0IVCmZckHfzYYVJrBQmBIYAu7w4H9H0f+kP4GL1g4qL1hiIaWVHA9wPgmJwqAwwxEBpHKVrpuNGbRqYFdJbDY5RxdddTysxaCOfRB+82hsKzjDrjARi8R29MMPS5MiiQGgUDxHnyt1k+8j0GIQM7DDCgKiDrXDC25GjMyOxh9Bc+9ANxocSUPlNSRbR+muqwPqSu3BiSB0IJKzjSQUFJAIAMJcyJBLc+pEKSAPE0akDzMpW80bVx4fppIMg4AOKrhJr0ZHDPKGx7ZnVAwmAUB2O8mYlynGwiMQKCzhLL0YGgGSFlQGKDuNZHJTwaA6z0J5/zBUWFnYD++DSezRAE3OLMwAArR+J/nnu/MvF2E+d/ct/RKmbPKdnRJwLuwf4hNOpn1zJavPOrmW3TAY3/nirysR1mGrJi4yjaKGJ6fUuv6ffGGyI8j8cXcbw8QK6ec/FzH1CuHgHFD+oFLjNNWI4oIEnoakf9vGUQeFHwCQEvRqOGDC8LeAfvLbwX0FmBvFyhqNbwQmOwQG8cpPFgLoqiCMLJ9fAG8IOA9Z4Q9sbCOg9jXSiNG9B3HbyzUCKAZaVAkWnA+YAXcOGRCQidBaFaQhUldLWBVg5aGjhj0ZxrOOvQ9wZtEKL94ND3VDssNaAtoIUgwJ0VODUDTo3BuTUB9DfAixpQ9/A+B0QJITLsdlfQKqfubhYwnoRdlml47yCci9THhcpjFICpYrXWGPqeOvgFI9UaAwGqmKDSTerBIDxg+iEi7IUgUJ+WikLpAJwdIHygdg77ZFrGVICUIqZDSCI4Or+zgUWUqgGKPEcW2gizSem8w2B6NG3gg8gUSi3hXI6mo+fG/PR5pgFnoZTC0PdU3pjlkBCEb5BEiTv0ZCBlOoNTBt6O84/y8ATKU9JjVa6wWq1QFVUMy0NJQFM3Sqb+5fB56l1TrtzGCMQIuJvikkSyjgFQL/qZHPHOw4L4KwjoaTCYhI1RkCFurIW0NlR0OGg/ttRmz5pbSDPmgKlwZcJXQPKDGnJZY0Lr6SD53Uh0NDEG2EEKUS8OtTvvx46hPD5J5MHzK0cchYiGgmO5nFZ8idSZiiMVZRSY4p6dSikhfQC3Ch/moVxwjkhpjwaGD03rRLi9USswTmIWhpjIXynkg2jpw6gtoiKd7Mu4yV+xPcsI4NJAYPQg59iAp/Ih8/wzo1/5lbEBlHOk1qNm6GD6NoYG01cAoxUSPP+oORGMg1BbTpEHfk2OJcSDY/MElUoCbopt4NfHlGKac5+E7txDXvSl3/LYTAgjwvYlefn5lh4zBZzMX3lfUgxTa/c523xO8HHm+cb59fe2Dwh/Gh9rpmDAmPvse/ikPpqEqUCuCxhrUNd1UPwWeaZRljmatsHHjx9xe3uL6+tLlGWJq6srlGUZmQOdtxBh0ZuekPPKeUgtqSVxWaHIS9QnIn65ub3Bp0+fwpoW0IGjnbwxAZ1ncF6Qx9j18OcTlM5RFBT9sQHE2NgBeV7i1cvXkFpBaIW6afHuwwcMlowelVFZXX2uKXRblBAQ+Hd//+/x5s0J+6uvcHt7j+9/+AXGeHTtgMPhBOcULnaXuLy8hhAKAhJdNwR60inpTLFeI9M6NLPJsd1u0LYt7u/vidQmz3E+1/jpp5/QtxQqP9enUGLoAtCOGt2s16sJNoijUX3XwXsXgYX0AAF4DyW49Iw+NGYIAL+xZj3LMlxf7lHXZ3x8/466RAbO/v1+j67r8Kc//Qnv3r/D4XAIOIUt9rsLFHmB+1ODpu3w008/oW1aODcgy3L8zXffoW1bvHv3DjefbvCP//iPEZC6Wa+pdC8rkGd5BFJyeiRT1HvBGIOiKHB1fY0iz6HUyJLKkUJuAzz3Sruuix4wy0EpJVar1cQb5WOlfCZpy/ZU/nKzn3PTUtorlH9eXFxEOe69j4ZGE6ITdV3HYxETonpAYBRTFaE5Dl9Pig3zEFFXPPDCExmRYgNSuTMMw8RwSI/F1z2XqYyHKIoCOhhd3lM/h5SJluXetGW9msjcp2TqXN7xdf2lW57ni8eey9Sla+TnyFsfDMkv2Z5XIphYPOETUOh3dOnpQkbE5NRbnUYP4qfOhbIiPoec/m5J4YdXH66Lgynp6+d+G/8e+Z4mId/n4wr/4Sse4COWlOMYG2EFHV6TiZX+5jEF/tQEfErxL//+IZbhsQWxZKQsTdC5obG0PTCe/LSMyIZFzAZjzDs6AgUOw9hQQwgfPRWtNayxqOsa5/OZ8rqCPL2JJxYsa+FDlYJL5njCF8Ec7hGcRb8mT9paMBJDShm8B4Sc7BCCJBqQCnnTQGFA7gm17yEo3Do43Nze4lifoIscSmtsMg2hFHmKHrD9EJSRACBjeJTmq4DWYQ15vv4AuHIOxprQQjlV0IhVDMxmtw7tdK21KIsC69UKUhKgj40AuqfQo0OIEKBK1/44LyIozWPMefM69+k6cNHoM8ZASZIxWunowQshIrJ/CFiG0cB0RBqkM5iBjMKqKIk5MM8AQV3/6FmGjoOJkcphematNGHOIeM5RZFFzu8XWRkVIo9dprM4BpwSQ5JXTzFJ6fqbywhWjCkZz5ID4pK1wcdgboTD4YjBGKxWqwkIcA7G43WVKkh+DvPqHL6WeTOieekfUbZPoxRLyiyVCTwu0XhauN90rFLQOH+fRhxSYrjUMOXzLDl2SzwGn9sel/EPo62/ZpvL0LkDxzw9vD2nFPSZrYQFlAS8F3Ahm0vn9eDKSmAMd80Vgtaa+N2VejDozjn0ZoiGhA/HJT39UDEtTYzHti9X3tNXpeSDh/bYvg83Hg+epDQ2nMqiz4DR2KF7pl7yy9uXWqmpUJlHGZ6KBNA2GmDzyTt/pvNJ/yUT7/EoxiiYhmEgEEwcJxE/a7sOeSIgiNLV4P62gZAUycjzDOt1ibLIsVqV6PsOv/zyC/785z+DqhAt1us1uq6DdcznTgpQSwklKzgzoDnfU6jR+tgboGk7HE81hNTY7i7Qtm0gfRkwWKaulRROh4CXpNyH0zmsmBNUluHm7g5Zd0Z+viVPJNNouwbd0OHt+/c4nk/47g9/g8sX1/iH//V/wTbP4Rwprq4+49w0+NOff8Td/QF//v5HnE4NPt7cY395jdeBtTDPSxhrcXd7h+PpjL7rUZYrKKnIkBkMTB/Ab8EzzLIM6/Uab968ISFrDNbrFXa7HYQQuL+/pxp5S1ETJSUyrSGFjFEBbksc5yOmimddrRLgmyVAYijt6/uOGACPR1hrsF5XyLTGbruFdw43NzcAPL7++mt453A6HaMRsdttsd9fYLNeY7/b49OHj/j5xx8DKdAKf/fv/wGb7QV+85vfxIY959MZ33//PZqmwd0d8fv/5je/4ckarzPTVG/viwIAsNtskGc5VuU6KsNI7AOBtm5HLz10NU2FeFotxQo8bQiUEgGxkcHGQPo5VwWw0cQK+3g8om1b/PO//CtO5zO+/vprbDbUhKkIVMUA4nGNMdGTrqoK6/Uah8MBx+PxgXIHxuqnuWKKnr2QkDqbyIo5GdH8eHwc51ykrWbvOO1ZMGc2TKMFqYE1H1/2ludGAEdFnrrW+X1OZRcW3z9n44jFkmG0pHNSgwfg7pFjlPk5lWnPMgLGm5x6/enG4fRUAaV1pNJ7uMTC44eUhmvisYJnM5IJpSdKwHhJqkRAzJQs/2qMEvCX4/uFVAL8mMue36EY73M8Q3p1KY5AgOo704c6jpUQnLaYRkieCv98bvI9Zjk/uJPZc1r692OW7ZIRMKm4eMRg4L/5YpKBLGhpDgAgEI8IrYZnKQVetBJcHipiyFNrjcH0kcDl48ePyLUOHjNNf0Ko64hUz7WCASIhEbNXDoZyyl3XUx290lRD70E5UGtgLOFNnNTwYqyB5k6IXozcE13fozkciDymKikS4AUGQyQ+JuRVjaM+8XXfY7AWx3ONpu1QNy2GwUCpDFnusFqtUBYlMSEKqqP3ToB4D6jawRgDJxzl9UM4lzw/Zv8cu7plWkMXBS4uLvDixTXqukZTN6Evg4HSRODDQFyODHCkRIQ1yufwPlRdhDpxEtgUtZABYOX9GFLmJjgIz8LLULMvKJ9vrMEw9CQnwrmcc1CSKIG7ro2lfNZa3Hy6QV23lI4xFof7A06nE+7u7mLnQQFBoDkxzWFnOgt8AQiRpJKqOoocSqqJZ+y9nzL4YWogP7Z+eGMvOFVUcyWbHovHa55+tNbGtA9zFxwOh9jAKE3vprKYeRVSo2S+zp9yvuYePF/n/N7T9Z2+zlOGqVJOP3vsnEvGRhrdYPmTOqFp1OAxOTuXl4/d29L2JQbD5xR/ep/zTQoJlziQX+Ic8/bsBkJPWUKPXWjTNNHS5AnJx+HcEz8AYMw5Ue2/hnhGi8T0ipwnUOH45ajkyVhI32MEC4KiHby4n3NO/iDiPLkeVPiFHWmbP+jHBMRjxsCS0vzSbR5mil0XZ4LqqRAZf8ZMcvyefxPz/Elu86G1DWTSR0GUejt8LG98zHVxOH+8bhnQ5Rpaj5iSsqRIgLUWP/zwAz5+fI+/+e53uLq8xDrwuOtcQmmJIieMQFXkML1GW5+AoBS7fsDp3OB4POH+/p5yuEojLyrozOH+/oi27VG3HTF5lWtInSFfUdg4K0qiOM5KSKWh8xy3h1v88v4Dttsdds6jXFVYbddYn84wkNjurrDZXmKwAoe6w48//4zT+Yyf3r2Fc0BVbSCUwuuvv4WxDl03wDsJ5wSG3qAxPfK8hFZU1y8g0bYE2uu7Fpyf11qhLMsQ7q+RZxptXWO73eLy8hLffPM1fv/73+P7P/8ZP3z/A/q+RT90qHQVwcLeO9R1jWHoY+3+Upe7vh/Q1C3KsoDSVcjFZlQdICW6FsR+ZynC40MaA/BQWuHq6orSK30HIQCbZQGUKWF6g5sPNxCSeA7KsoBzHloTHfV/+T//C07nGlVVwXuP+zuiOf7w4QPgPfIsQ5EXWK+3ZNwlf3mWI9N5nGv77Q55XhCAGYRhARD4EBzOTZMYu4CfebpxTns/mefp5zxmqfKal+ul6ak5nwoAvHr1CsbQPk3T4J//+Z8BAGVZYrVa4euvvw5ETmtYS2RHx+MR3vvIZ7AkMwBMohX8OcsTKYl+m6/5KdmWerUcIeF9l5yCuXKfpvVGvABvKd3xY0YX66GUt4CPl5537hg9pgvT7UsjBhEnMxuXpffz71zmJ3No5jI/uT2bLOixMMNT4XHOn6VAJGAcjLRmVSkVgR15nscwV7r/Y9tDo4Q/42uaeuTj+/krf5fez+xBjiedfTjmaNgLeLDf0nXzJJtc/9SSXgrlz7elz75kgtLxAEBi4RCLhkr63XzBpgs1zSemgmx6bhHLc4wxgY46iRixYJhZ61NjQYT5QmFSsa5QVRWUklhvVrB2gPfTqBPPD+8FrPPUyY6FsKAGNZS1EcQP0A841y2sGYI3rMPcDSCjLIPzQJ4XUFmOLC/IiFUKENy2lRDHHh5eKHTG4Hiu4aSElxJZUWIrJLa7Pba7PbK8hFASXkg4UJ8DDwEZygWFVFCQyDIJY5ISTB+a1PgBQ08IcBNC+QCtu7IkStzVivLkJgjQ8/kMgNbu1dVVLP/ifZjLXwCAojEyZpj1gadIoQiRLoCxB+z5s/dlYQ0Z4G3XYuh7EMCSat3ZA/fOoTU9rDGoz6fwHAciCSpKMPOoCykGjnb4gDEZzBCR9977kHowlM6QEquqQpblo/xJDEkfsntRVkm6p1hCFvAOdD8UcRGCQM5eiBHInKwX3uZkaUse9Nz5mnu76Trg81prsS8KeD/Kbm5OJKWM98lGRhpSZ6WZhuHn1/TU+6dE9XzdL8mMVM5w+H/JC04dgVS+pJiCOXYhPdf8b+n58DaXv1/iIC6N0VNRgKfk93zcpsea6oO/WiSAGamAcfDnIav5HzDmdXjicj4ntby01lRaU1XY7/eoqgqbzQZv377Fzz//PLthTN4/FYJJJ0P6+dx6ffgQPJYCEPFcfO4HxkHwZp15YJk/9mC8pyhBNIoQCFSeuNcvWYhf8vvp5OTxmC6qVJmnYzX/nkOIi/f3xHsAEJpqg9mYGEP7IRJgiYyKQ9h8XhJ6AFwGa01kphPC4+pqj6urK2y3G6w3K/zpT3/Ehw/v4P0IPBNSQDnqR9B3PZySUFLAW6J5FUJAwsELgX4gZf3x5g5918IMPS5DREFmGTQE1oUAhES13kHpHKoo4SExOBdC+xawDjZQ86qixLntcHN3wMVgsDUOm90eV1WFb37zHS6vryEzDeNsYAE0ELKgtsSrDQBBvQ2EgM4kvDcYTAfvqWzqcDihqRsIT0YS3ZNEpoEs07i8vEBVVdiG7nf3d3eA93j79i3KssDhQNUBv/32W/Qd5SzrusHd/R3VaAdefSGANkT84EfFT6kZEd/rTKFCEdsAd12Lrmsjmt1YMkIypWPYOs80pCAj4+bmE5qmwc3NR0hJHCLX19dYv3yFsixQVSWOBwrzn7oT6voc5q4POAYRmhxZ9AEPcXVJRD6Ee5DEDpmw9223W9zfHXA+nR/Mf0L2J/nmAFQFSBGvVisy8JM5m0Y9hRhBjtHICvIxxQDwxgoxBQ2mCpwdLgYq7q+uUZQl1d0LEaOyp9Npsg7ZMGA8wHa7Dc2SRs6RdN/UmJ9jBuh6HeTM0H/sdUk5c0SRIxxptcA8usS/4+tgQ5SNqzQilZ4j1UPzZ/JAPj0RCZjf+5KjtPR+/tljsnXuOC0ZLpnOJ5EAISW+dHseJoAtLIIEjqEfESomBeX3BPcVCMlz9qzgqSbU2aSVrw9esPORvMEaCzOYUJvsAjEEKLcedfDoPQOsjEPtJ+9DO4aUvI/5+fRVcC7+wfeA9ECk0Q3HGpX1CF4cr4H28T4Q5wTUsgeXInLCIRlTjMf0AWtBobTH2wEvK/Dx3ymaeH6Mz/3WmOXc5VOTkP8YoQ8sGz7zz9LvGPsRS448MLOvYs43BVHRwmZDdFzonONtmgb7ywtcXFzgq6++QlnmuNrvUZYFKZ7GIi+LpGOkBLyAh4SUmjgKjAFgQN3uqDGOCkLKeaAfiBhHh85+QhLbmfMOQ0vgw7ojIpMhzGepMvT9AJ0VgFRQWY6yXCPPSwASg/X4eHOHph+g8hxeANYCSufY7i5grMPpVAOBSZAqIXIY62EDoYhSpEQFFCkmD7RtB2sNVlWJohgZ7Bjhv16tJkjq8/mMw+Eenz5Rm2BrDZSSKPI8IvYZmcz0tWQsAgitoZmYRqogIwLFt/eOogptm1R20FzINOerSRG0bYe+63B3e4u2bWPKwVlLhp+1uLy8xPX1JU6nE87nM+7v73E6Hmk+UVgwdCKk9AAbmkrKWJYspYJWZKCwB0mg1CnolWvpbQJO4/kAQZwqWZahKEtY59AloLQU5AdMw8Dp92x0p+h84CEAl71dXjtcJpcqyzQ155yL62Tu6fP5ucX0XEmnciFGQRZC9koJyAWZwb9Pj8X3lCrBeVogTSk8pojnEYA5diE9//x6UyMsPdd8nOeGQHpvaTpkfs7H3qfHYEPnc797zNCY/GbhPI9tz0sHWAcBEr7wHNLzQAiNsSHAApUv1HgXwEQ0WTjkaBOF4SBgDaGVu7YNFjXlgIVQIVrvyagISphvNARxpoZA+MLaMSQ5f40GwML3UohI0TgZ1GDMLE2C9L2blbPF8XjC2otWcJ5FATSe/ss8+9SifWq/x4yKvjdxRB+7t8c+57Ikfqa8COevS9EiKadCzAfPbbw+Msy4FI/PQ9GDMbytdA5jBtR1jeORQF+/+c23ePnyJbbbFfq+Q6YpjP2v//qvaJoG2/0FtesVZEj4UCGhdAbTe/S9xYABnSB2M6Wpu6RSOYwFbNOjKEsUmYZUVIY2WIfBGpzqM7phwO3dEcY6+r3SyMsK2jkUxQqlpk59VVUhLwoMzqLpDf74px8ASV3ksizDxdUlsqzCi1dvcD7X+O//+kcopXFxeYVcSeRlhW5wMBZQQiHPFTJdwK25a59D8/Yt+r5HWVIbXa01KbzwV15ewhiDuj6jazsc7u7x/t17fP/99yG6ZZFpje16g6LIobWKUZVzXWPo+8TzJyMtUxoIyldJCamZ09+ia1vUp3P0yqoVYRiKPEemiXjJ2AF3d3eoz2e8/fkX9EOPrmvQNA1ub2+xqir8/ONP+O3vfovf//5vcD6f0TQN3v3yDnd3dwH3oKHzArnOYp8RW42eLJdHZjpDWVQTJdA0DUwgP+L5SAQ3IyCP2+uyINcqRxmimW3XRYwAgAfGMivwuTGdKrRUwaWpLO/9pLU7h/CrqooYHSFExA20bTv5zXq9ThDmRCXdddSToQj8EHydE/mWeNBpJQjvqzUg1GjczFOAc1nGsnIuO/jYc0ySUmpqfCXgyNSwnacV5jKP5Ub6+Vypz+9tyQBJZeGviQR47wON90MnaUluzkscjbGT+/urlQiylQ4hqJdx4kWPrhvlO8nyJsGtVPACLHGPC0G105kNyFQ5Ars8HLqeUL1d36Lrh8mDmFumS5ZZ+jq3IOevS6kAUtYA/NgCM+b7PcDtkqcKEUijAwLEIseo8FERUqgw7B2jJCOvANWCP6XIn/rsuUbA/Pexcc3s94/9Jh23sixRhBIqAA8m6jx1lP7ey2lOjnkCphGIEOUIgpKvRQoZPB8BnWmczyecTvc4Hg54+/YtLi/3qFYlLi42WK0qbNYraKXw7t27+HuyHylkToB0ASEVHIBuGADvILwDILFabeK1Hw8H1G0LoTQcBExLrGyH8xnDYHBqewzGomk6eCFiRUFRFBDGwrkB3gkI79HcH+HsHfJVCZ3n2F5cIC8LrDcb6CyDyjJY53B7e4+u77Bab+E90NQdus6ia23Incqg9A2aukXX9hCCQqOraoXNisK9ZVkgz4LB6SkCtd1SGdl6tULTNNBBOXZdC+74WZYFUARqVozhazP0hNZHFo1pflY+HH/oh9gVlNdtFjAJSqlAJKTDOnA4Hg7o+w7v3r1F09SxRe8wUAnZ5f4Sm/UKl/s9nLX4+aefI+mU0hrb7TbOn77voxEuhECRU058tdsRkU9RUBTIY1JyZ62FDJiPtOyM7pHWdlmR4SCViuWtrCiZrpeF93yNsqJjJcYKm9dCWtrGc57/WPGnSi+uz/BbmDE1ycYK75/Wzs+5BrhSIFVCwOhopH/zdc6/X5IjT8nruXyYp5153zQl8phcmuuAJd2Q/p73WZJvj3necyPgqetY+i7dHuMueOwv3Xdu5Dj/VzICpFpQ/jFcnrZfJAOA/LcxJ8MTTGfqwUOPF+8c2raJk0uqjLyrZHtsQs2/ny+2xwZ3/h0AeEnCQIwHHV/9qLwfmwhSkBJZ8obTLc2r0b8p2TIP6T+1aJ6656XfPXUMa82TE/WxjYFG8wjG/Doe24w3MH4UfCxEGGgVAz+eSky5jth7D6Ekioy8vaLMYQzlMm/vbtF1DYoih/MW//AP/xOur69wdXWFIs/x008/BWGeNE+BiM1coMgIaLue6I6dhRcKq802AqoOpxPOTQOV5cghcDo36Poeb99/IA+wG0I/BQGtM6y3O5QQWK1WMG2PvnMxDXZze4vD8R4vX3+F3f4CL9cb7C72uNhTB79jW6Ova3z4eAPvPbb7S/T9gJtPN6DA2ZFa/RYlBkfljLe3dzgejsgyysN//foNNps1LnfE5z/OSaJsZkY5CYHz+QytFIoiR9MS6U6uC2RFAa1HJrmmaeBCjX/f99BhrltLnR973UevrWs7nI/HkVJXAGVZYLfdYlWtYhj7cLhD27a4u7vB+XTC93/+c8QPkMExYLPZ4M3rV9is17i83OPu7g5//tP3FH3IMqzXFdarFY7HIwEke0rNGGMI+HaZIdMZXl6/iL/p+wHH4yk2DGKvfL1aoyyquFajESAAIRWq1YrGrWlgjUXf9tHw4LQUg+3GtU5rghUxe9ZcYcBe/NwLXjIC5koaINnV96GcNSh9Hl82Rrqum6R/AEzC/Ly2U6/6KSMgzdGn4e1Fw39BfrJTNweRa60nSpuBgnPysLmDGGXETIl/zhmaRwDm22Py90t++9iWys6nHNX5Z3ze/yGRgLTr1ecuJL1otlSXgCSpgkxDX3w8IUJjsfDvB7fmQ/QB3IrGJwkBD++CNSpE8Pbo1QsRu8bRhAzXHPZhNDC4asADhPhH8FLYEEg/H80gzi+qgCSOIDM5ou+9B5hEhHm5aUGOZBk8Dum/P2cILH3+uUnP25y6Mn2Wj73nz9jY4/OlXhMLTn4/9/JlJiHzKW1nGuITgRzbWgsBRA+Fj9f0fWj8MXovVVlhv7+Ahyeq35sbrNcVtCIkOAsQ6kk/oA85ayUltJIoyxxCKCidwVtLzbxkBqXZS+pRNx3qukVZbaA0ACmp1W+WIwOwUhrOURoDQmLoezRtg/v7O7jewjQGeZ6jKEqU6w2sEHj95ltcv3qJzWYLIRX+5Y9/QtM0uD8e0A8DznVNzYp0AQGBqtoExWjgPdA0LU7HE06nE4aeUeoaRZ4R179SxE1QZAGURsqpqkrstjtSZkJQqN8OI/e/pn4DztlQamgjC6FzllD8GZXnCSHQ9V1UlB5UOw+4SY8Ajo7xZ9YMMN7jeDiiac6oz2e0bQslZSjfWxG/BkS43i12ux1evniJIi9QZDnarkPfdzjeH8M5w/5lFQBTFA7fbXcUkUmUm1LUCrmqKqxWq8g0yV4ze+lSysgMqJSeKNbBDDieTxBC4FzXMEkengFv1G7XRkXOSpG91hTIxiQyrBzTNTf3Upfy9KwsU16I1Ajg/ficDCyce/PzHPs8NJ2C9pwPcx5T4+AxBZnqhtSxS/VDaqyk17XUkp4jBel1pttjBshSFOCpbW688GdL+z31fv7d3MhKcSKpEcl/u+3FJAr7HEPkVxsB6SZCXj29r/lNLuVd+GLTyTSf1BxWFGwIJGkHVv54YABwWRc196CD0YWGowVwY3j1bJliNBIk4R5YqQctP4kEzD9Dcl+MLk5LH9N75PtzjnJbVo6KkT3ZpXH8XESAx/q5li8/xyzLJ4snndyPvc6f8XyC8iRmDu80l8j75lWBSlePGgFEXyDgwuJnb84FQ6xvGihNKP9hIAFQlCUuLi4ADxwOB9zd3WG9rlAWObHeBYHTdyFcHeiGlSCK2SLPIUB17I7nifIQzsMMFn03oA2kPVvjkDuAgIHUfS2DgMooH98PdL7eGKBtcTjcA1bA9YDKcui8QFmtAanx8qs3ePPN1xgsKZ0//fkHfPj4ETe3t3DeY7vboqgqZAVhCNarTQhZ92jbDk3T4nB/wO3NTWAOpPx6kefBCJAoiwJVRa2CWTmVZYntZhOEKpXyGTvAWQtvAx1vplHXoRsdG3nGgOl6pRCoQmicGiiFdeqp9h/w0RBRDEgMAlxK6mpohgHn0xHn8wl13aDvO0ghoTKFi/2W8veBC2K1KnGxu8DV1XU0Aj59+oT7YcD9iWiiN5sNjVNRIEvKlTebTfSied5qTREEnp9cW24GAzOYyM5HkU1HJEZ+lGOkgCzOdZ140iqC/1JFxYp4yXtlo5oVGhsOS0pq7mBNgITB+ZgbHKxUu66L8intKaCUmpI+PXKNqYJPlTGcx2Cm1Q1zIyI9Xqr4+Nrm+iA1BJZC+fyXpjQe85xTGTM3QJZ10Oe3pxR7Gvl4ah9gylsQe6aEtBJ/xtU0PMfy7/KJEfCc7VlGQK4ZDczhhgjBo5vgP8F5dVKyduip3eOs9EVrRVztQR1zDyUhQI1SBGA94KyJ6GUXzmGDQZDpoFxDXnMwhkrFQuMMZw0QvH7mgKdQvYh16CyonHch3e+J7tV6SEGASM7fCyGhNNHMaq1D1z8G7lA4ncaGupnxJKrKElpnWK1JQPLDPd4fMAw9mrYNLGUKg/FIK+3SRbC0MNJ/p5PsqQWXLjxgDB8tLdR5JOExQyIVPunfY95JCogCfPRKUot/uigFdJYR3iLUNh8OByglkSWGS5ZRuelqVQWAVIYsJ8/rcDjgt7/5NtIGHw4HNJ2BtQ5920BJGUpUS5RlBQGB9eYC1gzouxan4xGnuqFOacbhVHc4HBu8fA3ovEBWVrDO4u54BKTEmzffQCqFtuMmJg46y1Ct19AiR6ZWKMsSVUUUv9Y5VOsVus7gcD6h6zpsdxdQWYHtxSWV0TkHpTWUyiBAPQX6jsLY3lHnvSLPsd1sUIUQ++X+EuvVCtfX11itVri6uqRGN5Lm82azRZ5n0JmilrJ5Bucscp3BCgEnbKjPJ9Bd13XRkyfEvUC1qiiyFVZpmRfjPPMOQ9dRBhG0rpQAyiJHUZZQUsIag4/v3+N4POGXX35CXdeUnnKhAkkINHVNFMVSIstzwDnsd3vstlu8fvUKq2qFP/7xX/HDDz9gs9rgdD5h6ENlRjBCN9stRS08YI3B+XQKcziAS5WGUoFCt6yw/XaD29t7HA5HnOsaTduiDcqzKomT/5e3v8Q5aa0jBkhj0XVtZO1bQqunUU9WuowB4HQANxJi5VwURfxtugbZGEhr6v1snfK642Nwox0GDFprI9FWSkCUnmse0eXP0xC984Bz0zTvkjGRHnMuz/g93xOAiWGUyg92LNKIwFzepWM+97b5OzaI0+ude/mpLEuPkRp1qZxeuga+N35u8zHmz9MqDr6uNCrAx5WBX4W3OVjzqe2ZvQNGNiX2oKcTbDQA0glvE+WfWlzwRKRP4n3k6xOCsAeAgjcGJvSMp7bAwfsPHj4Tj4xlNvSdc1Q+RG0ggwEAAoFFKmLwJAv34BLF6AFnEUqzRstSSgkFKuHLi9Gr4PszRoVXM7HUiiIHhEdR5DG6MQxA2zVo2xan0ylhtdLwfqTz5Ff+S5m65mMNTBcUMI3CpIt6vgjS88wn7NLCn09s9pLS7akIxOS6QOHsFBA43Y+MNjXDVjRNA60VdGgKQ/uriGzmtrhFmcM5Kn3i3KgxBk3T4NxQD/fz4RDY84gJbxgMtFYoygpmIMCXxwltS6RD3nv0g0XbDwAklNbI8yL0I9CQCnjx8hWyLEPTtWD6YaUzlFWFIltjVV7QdYY6biEl7o8Huq6alE1ZrZEXFVabLYyxOByPAeBG3QWdI+O3bVooIWMUikLaFaqyxMXFFpv1Bvt94AXYbJBpCu0rpbFeEUZASgGpyJDSWgdCIA+LMQXCVSBKBZZGqagpUp7B2mDUeTLyqULHwht6vkoIZEpCCgIZ53mGqiwiEO/+/h43n27w6ePH8Gx1SO2UEALoux4CAkYIOEt8At57lEWBVy9f4es3b9B3HXEjgBpF3d7exnp+530kLBJAaN/cz+Yy/a6qKqyqCpeXl+i6AXVNWCWe56QcJIE17+4mpXl5UUDIgVIi8mEEcG6Is2JJydFY0TFrH3f1YyKgiRJIUgrW2hFPkERoU1nCaT8pJbqui90DrbUTjz6VfXOD4DHnwFrqIgihwKiqpzzgdJsrTt5SpZ/KNcJx9PGaloyAJaU/10e8L8vXdFsyAp6Sh3PZvPSs2aBLZdncSZpHbcbI50MDjNNV6Xh96fYsI6Bpmhg+m5dhLCkOfmWiCl44POjzXM5j+WTTdzChpp++RxgoAM5BSgEXOMJpgVo4MxChSjFSfdKfemAEjOdkmksyJIaugfcjCCjPC2RKoipyeA/0bRMXbVGUKMsCL66IPIbBSOczlT+ZvoMzA+4w0jtaY1AVOTKlUITUgdYKgxHoh4ch97lSXwrRpZ8vhcF4jOcART5Girpf+lsSBLz/PJ+Xju9jr+MWsBfpPYikxagX8aHPf6ukwna7DVUoVLcupUTf9bi5uUFR5gQOdDsAHufTGefNORDEXGB3kQMggiClJDabNaQgZr7BdDidTlS+OvRo2gEWAoMhcNq//4f/Ff/h//Z/BwRFscgjUPj9H/6ePECt0Q10HW3b4Xg8UWRKKeTZGlV5gW+//Ra/+e1vkQfD5dPtHQ6nGveHI9quQ1FVUCrHtlrDAyhXazJazicqvR2ojr5te4qMeQ8JgTzLsd/tcLHb4fXr17jY7agtbp6jyCkcn+WEypdKoB86fPz0gUoFyzKE+yniJ4XAuWmCsRr6DFhqMHRzOlA3P2bJDNEIKWg+r1YrSAmUZQ4tFUqdQSoqF4R3FGE5ndA0DT68f49Pnz7h/fv36NoWRVki0xoKZDDsNltKA1R03VopeOfw7u17tE2Hw/0BP/34E+5u7mB6Ay01qqKEEhJeUYSxzAkkWVYlEAwF9sCJ+MfE9r4MEGyaNkSZyKhkObharQOmo4hlhsSVoqCzLOCLRqKrFCyXrlGWh+n6Tcv7UgXNEYc5torlchYqPqSUROjkHqe7XZIZvHG54ZLiewzjw8emKKvkXPGztqWIwdKYzeXcvDpiCZM0T0em1+89RSNTY4N101IkJ91Yj7GuS/Xi3JBKxy3dd379Y5R0OjapnI3f+9HBo3v/MqMLeKYRkLI2pYOzFPZI/9L9U89zfvOptcWv3rng0T8MpQhBTFzOC2rVCR86nFEZGYF3RgR0+rc00VLF5pxFP9CrZStUEOpfSwXrLAZjYfoebdchUxoCBVZVhf3FBeCJmMQMA6F0ux7WGXRtS/lNTVZdFuq0tQqdsJSClKk6XN7mk3E+Lkv7pL+dLyze0gkLTCMH/PpYJGA+punnj70me4KoAMIcwNJ+/O3D4+d5DiGJgIafdyQ98UQju1qVKEvyzrqui3nwLF9DSh1y1AJ5psNvaxhjKbVkLawZMAQvx3lKSV2/eIXr6yt8+vQBdVNHI+ri4gJSSpxqQpg3TYO6bnB/fw/nKZqV6RplMeBifwnnfSARUhjsqNTbrofOSygtoXURcvUZur6LFLDOE3e9cw7ecX6WlOyqqrDbbrC/2OHiYoeqrEITHjKeR8Iggb63OB6PkEKgbztorQIbIEUorKUmNEWRQ0od1+eZwXtKQUDAJamcPM+oT0BQXpnSQVAG/eCJN6RtGtTnM+r6jKY+o+WUg6DySTIsBMqioFTHdhuoQzy8dTjcH+CMxdAPuLu9R32uaR4IGQCLHl5RK2CtuLnU6NCklSgsCyaMcok3nVKg53keI04yfC4l4UJYAVhjMHRDVACpMkll5xzIxkYBGwG8Bh9EVJN1zbI2ymUPcGfSpfWZ/jbdJ/2bGwEc9p87BqkC4znza7bHnJv5Po/98e+WHJjUgEmBdun3qZ5IUw5zfffYNfFv52M+v5b08/lv5sdNUwbz6MLSWD02bkvb83gC6OjwIb8mQh5PSDkJ08owAZgZjGrlEQh4ZATQueAxWIyTxvMDcoFMyHuqG3Yeaf26Cu1LtZ6GfoQgnvlMKyhFpBlCinhNnA4QglH65IF6D0S+f09AxOrlHs45nI5HyuEPPbwlME2eZbjY7qAvNXRGYeA8z1GVFZy1yLOMwtdCwgQ6W2uJCdE5RxS1zsGYgfUfjQ+oU1pZjo9mSeHO30+e02wSLVnwc8pMSltwHnL87WOGXfod/3u+QL7EAIhWr5jyq8u5JRSoWJcWoHUWddME3Ac9uyzLYqkl378IqaqhJ1KUzWaDoihxOvUYBgMXQsRDAGVKqSGlh1Q5hqHBuekAL1GtNpSnVwrH0wkfbz5FutZyRWHWm9s7tF2H9+/fgxr1FNjttri43BMW4XhApjcoiz2sBz58uoH/8AnOA7/88gvu7g9ouw7GWpi7A4HL8lP00p33yHUR14UoJZQXWK8q7HYbaoaTZXj9+itcX17icn+BsiRK3b6pocsMUpIRpJUmlL/sMYSSsb5tQyqhiDliirBQ5IWEEhnJ/j0pBm4RfDoeIual7zPkmQ5eu4Zar1CUW2IFNdSDoO+p6VDXtjFNsV1vYK2hWv4sw9XlJQk/Z6CzDDoo7rZtidTo/p6AgWWJ+7s7HI9HrFcr5FkOCWoFvLpYQ2c6AnY1KylBFMs+VDuk85o4CQZ4D6J9TihppVRQWkEo6nLq4WGshXAuiLkA/hOjAOeQPnv5qeJcIrlZMrrnUTh2rpZkg1LEYJl6l2kUMI0e8MbXwWmfuXxJ33N0JP3cex8M5V9vBCx5+un7NOQ/V87z3/E9cQSF6cmX/h6LLswjp3MDiJ8tG3lL0e3UkEgjCymdMb+mRlYqM/ke5rKXnID/EUaAmIZaBGlOCOeA5KbmAzg5RjqQjkiFIpgiGVyiKLYAyDsmMpnxQWjNqQQ9nsNTS1rvfAQ8FXk20hgnBgCT9oxBaB9yvmQQEIUqCT5rzCTf7awFQqiMc4cM3JAidBQLx8jzHNrpmBttfRv51WOFQRgZum+yCKRYZrF6akHy+7mVmU7YNDQ2/wPG9q7psZ8yAubX8Jin8bntgXIP/xxDYgJ4EAdAHDMqCxQYuerJ2ExDpj5gWIw1McdIDIHUAjeOmSXDNtMZRGj967zAMFgoRfMxC0bf4XhEXTdQmkB1ShOavA151rquIaXEekNh42q9IoPQWWi1QpFTRcTpdEbX9ej7AXf3B5zPZ2pP7APKWgiorg/eYbjOpIxVSwVZUCRqu9kQ+r/Icbnf43K/x3azRp5nOB8OcNZg6BJktHSx7I4gNR4ONgBhRQxzUkfGKsxdHw0ufg5ajcaBD5U53MiHDN2EgwEU4Rv6Hm3TYAiguDyAFbNgmHBIervZAAIBGDgqzxgBsYQ54KhL3/dkQKiQL5dUYqhzPZlrPKvmHjVv0Xv04/wZPe7RY+SBcAg05e6h9+392PuCN45YpfumUdOl9bTk8S0ZCnRdMhq/T3mKS/fPim3++WOv098CCQP5X7zNnYanIgHze2MZwpGVJbmV6rUUFLgUNeb95oYYMM3rp895SUbODYzRWVmO1KYRibkuoPbcX6740+15ZEGS8/JuYnXMw1BcawrwZPbxAr0ff++4hh9sQIz94Dm9URUZqjIPEYZgVCRjw4KcLWt4EpzGGPKuJVnpD0NGIokE8OYnL0IQQHAVEOZKyeDNDxiGHsfDPbo8R9+1ZARkWRRQQ/D4q4r6u283a3jvUeRZyDNKGGvRh6Y7Xd/DhkYkWbFBVuWPKtunrDzOYabPZckgY6OFrfgxWjAyiKWLfMn7j6OWTPr0HF96/eQ5AEIkuctgnUUPx41Ce/7bYRhwuL9HlmlUqyoYi46Oh1EwNk0DITzu7++Rh+YuUhJ4zXsyHJzz6Hry1vKihASV8FlX43hugqEBlINBUQzY7a9w9fJlmFdAP3QY+h7HM6UGfvO7340d6Yoc+8uL+JyM1RiGHB/ef8A///N/x8dPN7i/u4cMc5rAZRJNmCPOERBtvSaPWwcvoqpKlAUR7lzstri+ukSZ56jyHJe7LfbbDTbBCDjefEJXW/zX//qPaLsO3/3uO2w2G7z66isIAC9eXMW5kOaWpQR22y02qxXef3iHu7v7aCxKCGSKKmakHClsN+sNlJQxSkKIdIf7uxv0w4C+61HXZ9R1Q2sVwHZVUSdGDnmHpj9lSTgcMxhKOQwOrnewPeE4sqJEEfgW4AS0JBZCCtcTuVFekkPQDwPJoITePIZ+hYRWWfDsEUuzfIgEVFVFmIA8g9Iaq9U6yh7viVbae8CGdJbKNDwAbbIHHTDnqcnUa+U54oIhlK7Jea7Y+7GMkAHJvKksB8TIOshGSLoWUzAir3cA0fGZKy3+00mqda4wjXVouy8Hpz2QBwuKPL2ONBIQ8Q9hS++f7+exv/R+hRCx7wQ/m3k7bD7vUs8FNprmY5JGYtPIJO8TqaZ14tDOnsXcCJr/21kHm0hH5b7cAnteA6EFL3Au9FNLir9PbxqYhqd5nyVrkiY90e/qNM8lBBFReB/IeGToNCYCEMdhkKRFosJPzyPCJ/w630KuklCunkKgXsTWqd5ZWugBLc0CUwfvUikZyn1cZGXjfDOVWI7hQKZRHgYB4yk9ILWJD3FJ+T5lDPCiToUFh5Dmkx8YrVU+ft+PXcnSYz5mnU6GbcFi/tJNJOWa8+vz3gfGqNEImIwHEEBTLCh8UJhUisbCt+87AA5tQ/zopJxApXl2bKpikwgVsf2xp0clVy60HR6MQ14IKKVhHUdYOMpChi4rQOen+JiiKDAYha4jJVHXDc7nM46nI4qCykmpORABHClFNj5DrSTKPKey0hAtK4sCRZGjyDLCmnAtvqCGPLnWyDKNTCu0TYPTOSHCicjzEP2yNhjjDj7cm2KMDQSV7vkxhzl2vQzKCkAZiHhSJeudQVN31Na3H0LImVgG+X61UnBhLliQIpEihOyDQxEjACFKRCmKaf8JKRQEZGxRPUZQUu6QqafoJaA8feXCvBJBrkg/KhwdDKRUAfl0Xnoy2KIyEAJuwUBO38/Xz5Ix/phSYHk6j9bJhbWcRgtToyTdZ47bSv895zyZvxeCMDO/VhbM7yu9X96WZFn63dK4fYkxwPcxN3geO9dSRGVp/6VIzdI1f25b0pMAKOU+c8y/dHs2MJDzaSkH9fxm05KNdHKnNJipsmJLd8m6Mn2PzhmIsoDKcwgmv+g7atIjFaSSKFTgZVcqCGoHEUBeQds/2OLkDos8NQycdzgN1MOAa2ilBNX6r6r4OQG+PkbP+uLiAqvVCqfTMVjSPbTOIrc9b1VVhHukpjYyGC11fcJgBviEMTAdj89tQkzLf9IIzRIoci5EmJP9sWOnr/Ntjm6dX/dnIwIYPxd+en0uRLtYwE68BTG2Ua2qCsb0aJozVEwNAMYa3N9Tad+L66sY1VFK49PHE5wDrq9fkBdjSJkfDqfgBSjkRYWrFy8QRH206D9+usMw9DC2h/cOZUFUuAwwOxwOsNZSlUJR4Fy/xnq9xvX1NZwTEIKwK3meY7vdQSkmmJKoAzhOQECrDNUqB7xH27QQeYbdix2qssTlxQXW6xVeXF2iyDMUOgesRWdqNKcDcumx365QFRleXF+iyBWuri6hAvBPawlrBwiBQAcMdG2Lofdom5rKKYchtvr24f6tMYDzwQAvIgVtU9fQSmP9ag0hQO18hYPOJM73LT6+fQsOwtnA8y+0BtTIjmeMifggKQSKLIc1Foe7OwhQ7bwLjgAb+OzpCgBKEF7JO0cK2GoIav0Q+ytQ6kGhLAhjQUh4alttrMVgTVJ/riLwDwBUpsNzCmF+52AdU/6SESollaIKj8gQmAr/ucIe57qLES4uDWNZu7Qe55+lpX15nkHpbFJeNlfgcxK41FB9bM0vOW5T450qSn5NgJqfZSof0lx4qjM47ZHKnZQACngYWUjHOX0PENvlZrN5sC+PZ+yTESIuaYSFGzelOIBU36UGwJITPO/AOh/XJQOAX7XS0xTyM8b72ZiApyykubXzmCXLg8STOlVWfJxx8ntwTTb8mFYAvw8NdxDYAqUAvEh7mI++/nxguLsBwHlBROEkQS1GfWLkcHohC/3Nvfchr6lDCHc6DuAH7iwce07ex/xhOn5SUh97JceaUd7nuc+Ijal0oc8BR/MIw9yTeOzYnzv3XxQJwGjBCxE8/7C4QyCADIDkd/H6Z9fogydG5W9078NArHUpDoK8tbTShfAYHj7QnnIraEKZk0dPyHrSKpS6MsbBeRMjP3mew7kxerVarVAUeRRe5/MZ3hs4L6JgGevM6Tf9MMA5D6alLZkLwRHfxG63Q1kQ619VlsgDYG6S5fIEeENoyCMFoCWlFJz3qKqx1zx78c4SaM+H9aakRC9VNHRdyOvzNCHHgLqAOp4HkhnvSDnKCPgl/g6yu5OOn2FzARDM3CLOOXghY9tg73w8NjxdW8TjSBk9cFoDIp6H58R4Oh+vf+JtLsx9jgQseeE2RPLsBGdDRiQbDUpIKDEt/5vjdtL5vIRWT7fo5cuHZc7pvmSIjGs/Pe9c9szv97Hv5vs8tpFDtRhn/ew2H4/0XKnSn19rGgF47NrSqOZj95VGRx+LKsyPOZeh6fGWIjTp9/yXGgVL36efLV335/Z5bHuWEcA1u587yZJlxlZxaiX1fR8FZpZlEwuMS7iE7SFMB+IKdFFZECBXRDCYAIV/lRQQSkKpMrL8+XG1TycY4wJ4kQeAjwifr1cVrCXvi6sVtNaoigJqtYLSmnKGXYfBGBiusXeOBLKUKJIubd5aykcmD5stdBnGabNeo7MKbZKL+9w2f/ir1Wrxu1SwsFcyr5XlKoGl33/u/EtGRvrvpyIBHh7CJ2mkxCgAEElP3EKUwTmq2R+UmqC3y6rEdrMmMqFM4XgEum7EQzAq+tWrCzBSnqIhwVDwFsRaRWRFpPAdButQFDmqPIPUCnnf43w6Yhh6ENucxKuvXgdl6FEUBb558xpSChg74P379/jHf/xHSLmCzi5xPB7Rti01/ykraB26wimNvh9QFNTtbr+/gpQSbVujqir8/d/9nsB4oGyJVnSl3llkWhK1rqbyP2d7DF2Dvqlh+h6//c1vMFgXcBFUleO8R9sQTe/xeIi5UDJ0qbTyXJ8whJJYJ2ht7fcXEEKEjn89hhU1c8oLHWruW/R9YJIbelSrEoQLchAWsMKHNQyYYaCSumGIIEIlZYzGFUWBoijw+quvJorBGap4GQxVFEjJfSg8sow6HjppAOFih/B5OSy9B6yj9W7syFIXXYZwTp5n/WCjUe8cNVOysWU0lRIXOoPKyweeflrulc7n+dp8qNyn0YFUUfDn/Ns8z4lNNdwfOxepIcG/m29pjjtd50tO4FwGeTytbJ/aHlNyqbHG0Q5gTNE8pWyXjrd0HmNMpFIG8MAIYoOKnxtXGrBM5W6RqeM1l3dp+omdNu8Js5QaMUvG2vyZj5Ediiry9lfDBHCTj7h5DuEyOQQp4FSQ88175+hP8HsCBgqQB0GCygIcXrPkDcD0EKZHFzgA4gMP5XxSUIOetg3lE26kjvQJ4p9DybHFYggCCIixegBAcAUBIOZ5OewnRZbgEkgsqJgaoZ+5ULKVaQUXPBYas/DAwDlsA1IqBPgietRQo+qetrLnE3zp/WNWYWqxPvT8H+b85wLgqc/mE/NZm58JEv5vcrxlwcKCk0vOGGCogveaZRo6UyFN4iYGgNYZhoHQtX0/JAaSD0aiiDlmrXMIZSGdw263xWazwf39Lc71GcPQA8JDaRXBcEKAUjs+hLfh0bY1jscj7u7ukOcOq/V6JC8JHARc8UJtdRnYpkMVikJVUu4/Ro2MgfUOBhZKCGgJaFFA5TpgWKikt9MSTVNH2l/jCMsiE0+S5oWPa5Su3cJZBxcwK8PQT+YPeJykCmyFecC+cJUArT8O1ROzoB071/nQdVNMQ+HeOUgIOCljWoQxAwwU9t4DwsfyUu985JXi8kmvHLwQ8LHleViDxsIJN1GMZGiSZ+/8WB3BbaZ5c5YjUOH6WTmEdKR0aXST2A3neKk0UpquqXkEdb7ueHvMI05D/6mC4tf0nHOlw9cFYAIyTL+fK6M0IjG/t790W7q++f3Ov087Ij41fo+9T42N+XHYW0+dprlRN1fUfMz5HzBWh6THWoq2p2M8v3+fBMh/zfYsI2BdFXFgqOsdlc6wMy0DEImFLN/Mzc0NdcXzjizyYAC0bQsPIAsodQm2lD26riWUu+kgbBfBXVpT6L0oCiip2AiPk2W1Ii7v3W43scTIABgjAyQ8RAjxk7eEWW3nsT7De4+yLCGljmF2Wsw29kVn+tMsG/N+hLr3MQoy/s7AGI+2ZZ6A6YSlcZTQeFg7+thESl+Z0GW+SJfwAMC87ERCymmpyWPWf/odb0vCax5Sm4fKeB8pBOCSlBHk5BhsxLGhNBXcHp0ZAuLeoChybLeriBMoihx5kUEpAWuoO1ye51iv18iyHL/8ckTXjU1JGEGtcyoRLIqC0j1ax8jTd999h6+//hr/+q//HW/f/QIpgaYhxS8lceJ771A3Z3Rtg/ORekTcH+5xc/MR33//Z1zsX+O13sfGIG1HKPTdjlDoV/tLUqihI+V6TQj//e4CgMP5dIQZBjT1Gd4a2KFDkWtURQZ9tcduUwLewgwdDoc7NLXCu7fvcD6f8e7QwDiPi90uVokoxRS14RkKhPLLfuwVIAW4Xo6qezx0QsAjhMA2PLq+7wlwGAxgNxjkWmG93aLvOiJhkgpOjh552xJTXx96f3C1TV3XyLIMlxdXMaViA5FXjAYZC2OorBgAVd4E3ILWGj6zgBznJ7XZdRgmqTcRjT8pJaRWgWuEKjYsc4m0bTDsKHrIXPw2gCpVP0Ap6mHhjEVbt3E+p0DpNEKazvc0SsDXkrL3zRHy/BvO77PC7/sOzuNBXwI+Rop6T6+PZVMaCUjlCP9m/hmP4zMc0QfbkgGUetRs6PBa5fd0Xhe5J+be/NLrkjybR0VSY2rOr8KvLPM3m81kLIAxAjM/Bm98L9w7ZcnISp/3sqEhJiD35xhgz64O4JvTmkoA00m69CfCApFSBmUqZ14EYh0yA9pYyRLC10FKh37o4YLwEd6HkiQq5YEHur6nf4BCi0U4Fnti7NW4BSNAgBDfAgiNhSjCoRlkmFh/c4uYJyKPT/QcYMFc8akC5IdJOeMRoTulVNZxIqYKf44o5fFLAS7pv7/EI1+yrpe+XzIA5vsuAZ/mBsCS4SCEiPn/yTkmGAEO3YjFvC2PV9uSsrLWoh96Ygx0BsZmcI662LFw42MTIYyZlAN5jB7UEMq+KDcfWt+GklCdZYFMp4RzHsZ0cM7icDyA2AslpAJMKLfiXHueZ9jv9/juu+8in8D5XKNpusBimEcyIwbDknGtAwVyArxNFFfq+Rlj4O2AXgDeDci0Qt+1MMNABD6YMnnyM2TaXIDK/1wIjRcqrNGwDikiYCchfOeocVYMjYfmNPyMnJEQgaeBu/GlZDN9P8CY8KiB0OqYavyzLCNyowRkZ/ohPLMMWUbYDYoSCAweoZqA5lbbdXAYefVNwBg45wCBMXrok/XDwjx4/en4cvUQePwm83c0JJy3k6Y+S1G41DPn93PMFDeQYQNhCSswjeg4SKVjg7N0fqSyiI/NW3p9aeRi6n0+BLlNPF+Kkz5Yp3/J9phDMv9LHa/5b5c+mzsoSzIwlV3879RQY8dhCRMwV8hzOTdxVBf0xfx36W/i9UCmgaq/nhHALVrnFuSSl5lexMXFBQBMjABrbbSeOTS7Xq8BICItAUC5HspmxC3uXADPCWzWq9hYwzkHfyBLK1MKZZ5jf7HDMAy4uW1jFGEpZySEgHeBwCNwzkM6CClRVRWc96jrOj4YrfUk506saGMDEgrhZtHyY7INHpe0Pt85F39f13WsSZbBIJovaL7XdBHyBEzfP7VY0hAib+mzojI7PPj9Y+/TV0JGT5sRPWYITMY/MQTibzE7R/BAOZ2SXjt5UzmGvsf94RieQw7vLPquRZZTSqAoMuS5JoUb8v983V1nsN/vIzf8YAbcBYpfUVNJWFEUZCRKQChFALVMIy9KrDdbZHmOu9uP6PsWP/30Azw8/ua730IJgUPbRMWltcZud4E//OH3+E//6T+h6zo0TYMff/wZ79+9j0yBr169QlWtY4ieec2ragVjhjiflVJQ8HBeQ4WQeh9Ic4augR06rNcV8ixDU59grcPu4iVklsfx54qevu/RtkRvTCk8Or7OFNbrFXa7HWFaHFWy9H0flL2NRkA/tBiGAff39wTeEwlAFR5HPyqxzWaDsiyjMUIVNQOV/AkZex3sNltonSEPnQm7roMZDNqmwWq1xnq9RVnSXHGGQIRt3UThLJXE4faAbmixXq/pfCHP75CE1gPuJApzKaA8ARwhKI1n3dhEyAXQaESkz5R66p2y3GQDIqWkXQrt82fREAo9DoAp81+qiPl7iopZbKoVGavhvGmnTjbAUkOM5W/ap2BJVqQKa7557yGVhs7KzzohS9vSMZcU85JckpLmTHqcVHam8jSVmXMD4LEoAm/ztADL+tPp9MBrT4/Px0p1JuMbRrByEokKx3rMQIn3P/tu7jA+tT2TNtgDsUmICPl1B+fEQ4Y7+gc8fAjbCwx9N4kEiOC5w1PL375r4w14Z6GkwKqosMpWga2sj+dgsBSfrwrIaf6MG/fYYIGn4BHe0nQBnzfmZKREFpDWSoygIAnAh9ympx9BeB/xBBQfAWAtbKi9lkLEMkSEseEMYxbCzC7PoYSgHgjewfdnrFcrlGVF4WJjMPQO1gIDHJxw6K0BBCALFb0oDw8X2VA9hCAKUykBqYjoRsRSxTEHPBI3hWY6ycR9ypKdL0Y2buZewvw4qacjhIC3HhKS2NbAwjRR+ZZSAgLknWpJtfdCh4iBo/0ZxNX3hmhqVQHngL6j/LAxFvf3HYSo8fLYw/kCWbmGzIH1xSVk8BgH42Eh4b1AZxw60+FUtyirAqtVhX4gMpTBANYJQGgI6SFkAakciuoCgIdUKxqX0sPLDvkgoPItqvU1Xrz8BmW1gtIZMRB++ESh5bJEISj0bh3V01vLoUeFvm8AeKxWFRkWhjxx00msNxX2FztoKaAU0A0GvTcoZQGvC+hKQXoXQH0DipyMoe7cQghAZQJSAdvtGm3b4ng4IPMaUuawQw/Td8i0htYKjffwxqCriaGPaK89/GAhrEMR+gtICOrGWJSwdsDQtTifKfqxPp6JnjikaKzzxL5Y0ByQWQYohXPXQhmDVZgz1ls44SEyDSeBzg2j0vUE6jTSwyrg3DcQpsPgASc0BidggYCpEIAEHCSsJ1ngPL2n+eLh24HWLkTEIhGGRUEFI8BbH6IX1AI9VxpSKsASGyNVqaiJ5x0VuSDeE16V1EZdxO845ct06rymOFQvJHWwLNmQ4N84h65rx7SlAIo8CxGrhP3UOxiBke4doUcKV5oEWUHLl5Umr+ekOics1RhlkDKhe5/iCXg/E7BQLonYRAOIBiOsb5KzSpCMcMbCW8KMeEfAUMafDNaN15RetwsINu/G6/cjrgMAlKa0FrWVp7Q3vIcVVAVC10XPHEG3TYwqTXOKOEpEEPmMjeFU69Q44bHI8hwycfiEpMolnVM6MALM4WE9YXXieImpEWD+WkYAvCXmNi9gA2jG2WkeYi78WUFrrWFN/+CQIhzXGot69r1WAhe7LV5e7iZ1mZxTSQeRPWe2zD59+hSVDueG+Rp5sJjIhY9JyF4bF2emKZSWsQJHQF8Pw+iNGgPpR9IiHQwBNwywXYe8qiZER2lOjq/Nhd/1SkF5T/SxzRn7fYWvXu5wPJ3RtC0aaTAMHj2ojlkJGq/VegfvPY6+I9wDC4HYa8HFUjmlPRIQKYbBArAwlvjRNTKwEZACiuZW/xLOgDup8fNJa2vTe07xIqkhxvSyEcgJN2IBwp+EgBeADPlRYOyxDQgUeQEBgaYeUORrZNkm5gi7zkJKj3f6hLoGLi9rDKZEtb2CznNcvXgBYww+/fnPGAYLKzJabAM1IjocDri+vobOKzStwfHcoekceiPhRQFIBaFXkJnCbh8MHL2lznWbDVTfY/BryvdfXeGbr79GtdqgDPeWFz/Beh/SAEWgq25R1/WkjLCuS2SZxsV+G+f80HdozgpfvXmDP/zhD7i/u8Xd3S1cZ9G2ButsDVQr5OuAdzl/gDc91rsKzgk0/QkAkOUU3Xjx8hI3Nzf48P4Mn+fQEhi6Bl2jUW53qIoMR+9g+x6nwz26tsW6WkEJCfQDhPdY6TxMP48iy7Hf7XFqanzsetzcHfDDDz+gLEuUZYkXL15gt9sRpicvIXQA5RUFPICbA1UrOJWEwQUgywxWCdTD2LLXhDLQXjoYDZxq4mqQKodQJTorIZxAloXSUBHWpuNQNgGIPQAzOPieUiNTL4xaKEfDIwhkJQSE0IiOtXUQHiTg5ZSzY6IME8Y+lhXshfMa7IPscJ7KOHk+pE2MUvY/6xzOpxOEEFividmwLDiSgoAZoNw5g64jC6AApFbI9EOq3cf+0v2EUNBCwcLCWFJ8JB9Hz5YMGRs59733Y4Q5NATjfirMQawF9RSx/RDlMYyDxehoNG0LYx+yBj71nj+jdFtJKUJHxnXKQBj7TnAJavR9LbRyKHIdn5EQCE3N2PBgQyDcUqhGcUEnFYH7gtNnQgjILENereO8McZg6PtAcJZGDaapg+GvZgQk22M5h3TyphMkneSTEIvARJHMPct+6PHp06eJ0kjDVEu5FGCMCKS/SRHJfP3suaahm7mCS5VXenzuZZ2G89hCT6+Fr4PvOQ3t8PvUMy6KEm7lYviPw8WMqyirCs453N3dhVp2si2llBDeEzNZEk5USkEEshMfou4+eNoskJTS8BCQQsH7h+H+eQh/HrLk7x8Lsy39+8HfQgOMpwRNej15nk9KoPhZczqGgW+cepJSxVB2rjSQpKm4TIhohgn/4pyLLWOLoqSxjNfkcT6fInlUSvrB48PhWY6WbLdbFHkxWchjFUIA6kn2RikNR81nxqZZbBy0TQ1C2NM5tdZQAZzLnP+MUq/rBtYSgFKIJC8dnt35fEamM6CiOXlxcQGtFHKdwQOUGrMW59MJt7d3qM/nUFbYAzYA+TgfHv54jnG/ht1uh67rQllkNsn1z5VkGk7ltbCkRFNcDs8DdhzSSKBIFHcqa5ZkSWr8zild52Hj+XHSayPgcD5ZO+m/5/eSAvP4PYM22dhOZRkrUU7H8Pl1KGFODXFWtvO0AK/f1OhfSh2m21wepJ9HzxVJyDxJV8wxEbwvK1kR5lGa5+Zoa7qlYDjeqJpjuYqIP1uKTgKIRhRf8+RcYoqFSGXi6DQR+L3IMngIsJXAzyTVFdaSscCpODkbQ77O9Fo4GhTHL4wLN9vjbRi+nLL52UZAetNLYeGliTMvNUlf57iCuUHQn484ng+xPpiR3bwo09y792OTiPR4fL2pYJgDWfia0t+lOTcAE0HA2AAp5cRSTJGgjx2ftwhCC0KGm6VIoWKnNhOAVXVdY7fboSiKSBrT9z0RypC7TMCr8HyklDEXSNdNOQFjLYwb81gq8n+TkjADVWekE/wxwMvcCOCxmufc5gs+/Zy3+T7pfo8p//T6iqLAMAyRtY6Nsa7rYhc8Hl82CPq+R1PXQFZAyLGdLP/ueDwibbdbFAXKsqTIltLJNQOn0xHH43GSs1Vq9HpYULPBst/vUZTkcaTKj5VilmkgoyY61BxprC3mOcOd9w53t4FxcBuFv06MAPYYAVLiXddC5wZajyA1AQoNn8J4MSr/8vIypmC6rsP5dEZ9OkMAON4fRsNnGND5FlIIVEUZmwAh8S6HYYDKM+w3+/hceQ7xmua/dL2kZVhsBLDHmM4XXttzgGqco5LWwZIRkArd+R+P+5eAzebykc6voHL9YD6zcZIC2bz3seNoirHJQq8LNpjYUGVjKoaQhYhgRq31xFBIjQo2VOcVBmxMpN0O03tdep0bNvQ6du1Ln+F8radzgNcGO1NfDm2bblqpOAbpeR47f/pM+L7TSPP8uc9l19QQIPryPM8DqPyhoTEy5yLiS2xId6TH9N5D2NEJmBtp7Mh5AKYfkpQuMJi/khFQlEUkC5oLYt6WAAlzBcLCMPXAgSkDVnw1AyAkjHXwXQ8TLC1GanNL4OmrCOhU0KtnlLcNLGyhpMN5WEeWOuX7qEe8c47y+twCNAx2OAEAQWWKZQnrHFTXBSPMox8MBmPJE9MZdKiZllzOKCg8FLsZqsDu5wMSWUj0bY/6fCaGuTzHerNBWVX45ptvsN1usQoAymq1xrmucTqdMBiDumkoAsAhNa1jj3ofOtL1wwCR0KHyROWOjU+1/2TDYG71z/+dTtQlMGYqsNIFmhpTfLy54bD07/SYqSGZep+ph8XnNsZQ/v9wQNZ1BAR1Y4kRdyYExnKqpqlR12foTEJIEqIMFE1TPXPkO1v7ab02MIJi2cDdbDYBCKYgQKkdFsQ60Py+evUKxhhS6G2L4+mEIoSbb29v8fbtW9ze3uD25lO8Xx4D8nQsNFWwomu70HVTBZxJDwuLru1jBMBaaoHdnBsKLwf/a+ipDfaqWgOlQ9d2VI4XKEyps5mgmvpwDGUtMknPiQFcPD7n8xlt204cg4uLC2itcXl5OXm+KfCKnz8rG34Gk32lhHO09kRYx+RthrkGxPJha+0YcmcP1jmYdizzS70u/j38iIWarhsJIVTADLCjIaCcg7QOxrnQHI32dx4QkhpYOWfRNC38YNC0LZGSWaqeGgZ6lg4YqxjA4WcKQXPYWMbxUhDSwTIHhA0dEmM1A7X0lkpRaeEwgHLco4xlWTbKazmOZ8xNE5eL856cFBKbo2Intz60d+cybQJw0o4Ov8oKEAJSK0obzpwQnif0iMaoSPpZ6vzR4ZajRXP5Q/os4Ek8EU6ZUGmTRq+FGJ+PkJh0zp1v1np4WIjgBLD84vlJshgBA/JrTabnGgEFGQHpwC5ZVUuhlsf+/VS4CQAy4ZFJGbm5u9jrXUYhy54ECeqkmQejf9OHkjQesUEJBlhfCJPz9fkYenL8TyHjUAtJ7WT1YCDVOCbO03kYuMgeSzRsMCI5ZVDQcSxCuLJtqA0tQu67qqgb2rfffovr62tstpQL7q3D4XDA+/fv0fU9/V4IZKEKQ4YQMASVQxlrAhqaQ6YukinRM5uv1HFLIwPploa50ue/5E3xNvfSUgt3fmx+fSoikM7BSQokeJ9pfXUaATLGQPQ9rHHQfY/NZkPjGpDfRDFMBhIbFE3boG7O0NkYkuYqlVSoEHMYUBTk2XDaiK+XrnkM33Pfg9WqioYsQOWwMVSqFaqqxNXVFYZhwNu3bwEB1OczTLjP+/t7fPjwAbc3N7i5+YiiKGLOmO/ZWgs4CThg6MhwkUJBSke8+Z4YAmUuoQsNZ1xA4rc4HU+Qk3C/RMVMoIYUp5YkVgZnIRAAVsH7VN7DZ3R/bDyx98sesPc+RkQ2m03k/eDIH88bfo48f1IBHtMiSdSgH0jh8ffzuRSjIixwkwhY27aTtrpLc3E+T5PVEz3jVCEo5yGlgwxOUWq8MjDZWgtXN1Tt0PVQxpJDlCgxXuMTo9pT/wKWd5kn2UPGoISQNobnXTBepJTQgnLdUukYPRijfqEEGglwL3GOxOSZCNhAMAUEkSJEFDEIoF8qyU6aw7EHb/GrFJsQoZlVMhbp850r9Lmjwvc7T0nNn3Eq09J5ODECDKWvOB3HuqofDJyd0kHP54z35Hx66wCMRkA8N4LhFqLAfB3pOHzp9myeAD7BY3Xsachl6eaA0YJMQ/ePRQQKJVBoGUNULKDTMBcLaDYK5uGp9D0bCyyEyrKM1596cjEklUwiPgd7HG3bRg8vnUwc1kpJQJYUGYee56F0nWlstlu6vopCxm3b4k9/+hN+efuW2qUC+HhzEyMb7JFKpVGtVxM0sbEu6napFDKfBwWk0A/U7XBkbwt8+U8YdvMJNn+fKsOl0N98fszHOp03TxkA6f4MnOPj8TMygeo5rUXnRljn8xmoa7y7uYMDcDgcQh6VFDZ54GOY8Hw+B/SwSrgtqAEPP28Op97e3sYmU7wvb3d3d/j+++9xvjzBW4ftdovdbhfDus6agE6m+zmfz3DOoSionXXM2cJD+qlCq89nvH37M+7v73F/dxd6FhTxnok3wWKzpqqFw+EA7wPqGkCRF4B3MH0PNxBpT9s0qE8nNE2DtmlQlRXhBoJL03Yd4D3OdU19B3qa00TsFErxeL57i94T1W46a4RQKIsK2x1hJZQmIVwWZND2wVhhdDyPjUs8RlYijHJ3dgCEgQCRZ2UJ50I6d1O5Nk9HspG62Wwm+87Xx5JBylvfDzifR9DxPC3IGysexkcwcHm3203WE5cs+2AgpsbFnH2OlSunW5hoidcp33datZDed4rlemxNpsqVx81aj6G3kzWZnoe3pShxeq7nbt57fIn6mz9flkEsk3n9Txy4RE7NU74ieOP8DM7nM+oQpb28vAQ3pxJCoW1OaEMX0xiVkqFTaXLMdJyllEggU0nlQ5JOSe5vTq/+1ParjYB0YPhC5yxuc2tp6QGkE2Oei5dSotASpR5DvHOgC4cBef/5+XihsBJI86/sJXEecY5nmHumaciZJ0taqZAuKvZk0t/Ox+Sx1IlSxHtflEXM/w3DgI+fPoV7oMnT9j08fDRssiyHzrIxrN33gA2eAxDKHKk3vFIEXBHGgMo8gwHnBRuWX6SI0y1V8I8JybkxwHMhNSB5+9x55wbVXPhy7nPeY50/Z6X77v07GDs28MlzHWl6eV5z9UhxznEqiciHENejURBbEVuLuj5HfEKar+d7v7m5gYDAqiJvWCmFoe/hHVHzpnlwZnuTwmMIHBT0rII/kKzHvu9xuL/H6XikaFLyPDhHzFNcAGibBs45rKoVBCif6izQDwQc85a6Ah4PB5iBSm7LnHL+Lqn+YKS5s5YQ8YJaHCs1cmXQNctIx5sa+1JI5HmBi4s9NutN8BBFvNcU68HPj9dcqmC0JhyChIfxU4dEZQW0WlYRqTBPZQrPL8aRzOflkrH8cL4D3teL8zM1sFPwKr9noyDFCKSl0gAmijs9JitnPmZqBPC48SsbEemxlgyVdEyeWo9c0srbHPs1V6ypck3P8dyNlDGeNATSdcjXxoqWr2FJl6T3PXdipKSqBXZImfvleDyiWq2wDd47BDUG4woAAmuLJJ3DFzk9n/eAg52sm3SMxOx5SfdXMgLu7u5QhdDGPMSRTsB0gaavqbJOQ7bz17n3zuRBWuvoufM52BNno6BN8nbDMOB4PKIoCmw2m2hd80DyJGUh2wYqUJ6ssQ5XjIQqvFAYlJMaAEywURTUJjid3EuvvE+60aKgB5jmi4UQ6EK9OI/3alXFsJDzDl3fYXAWCN5i3xMKnPOInP6AH61/9jZIIDh07eO826nBl25zITAXhPPQK/87Dc0/lQr4klcun+G/ruviM+FQO1v2/NyPxyOsc1iVJaRWWFcl8iKPpFZaawx9j7ZpcDwe8OnjR9zf3eD9u7d498sv2O0u8Pr1V7i42OJwd4++7aA0dYPMlIKREmagcrmhyMbxcwbwFm4Y0DUN9vs9Li8vcXtzg+PxGO+JjQozED6hqU84Ho8UVfAe9/f3MIZIjlarCi+ur8N4Eu3wxcUFheylQN/1aJuanruU8NbBeofj7T2MNTCrPqxL4tRvm5Y4Kxwx/7V1M3lWxlDDLGdH6t7dmihTtSKiHyXlZI3akJLqe4uiLFHlFcqipPUSIsWr1Ro6z1DXdTyuEAJlVcJ7xDUnuDdB6CqopKIojdKxtMw6rvU2cJ5Kb7t+VEyf20QMW1NvCR8Wj/epcOaac3p1zsbveX5mWY6vvvoqGvP8R8e1E3yDECJGO1npU8fJEZzIXj2vXQARzMqOCWN+GGPCc3+OmeC5nkZQU3mdRrDmhvvcSJ84UNZPDIz4ebLO08jK/PvnhLPTzXsPZ0ysgFq6xnkqKX1Wc4dhfuz5+7lzy6BCvpdhGNC1HeqmhfOIbJzDMCArCuKQmEWflM4Aa6EUpXSsc3F9pHox3q9z8FJOkifPMZ+eZQR0bRd7A6STJrXyeGBS8B8P0PxvHnpLJ9nkJv3Iic0Lho0AtrymgCtEpX06nWCMmUQCxsiFA2DiwuHj8H2kSiq1noFpjS3fLxsQ8/re1Mude8TOjihYIRCbovA4Rktea4jBgpvjCEEAGIDyTz6Um/hggVMOloSuMSZ0RksnbWJBgr0Jhw4PUaVLC3LJUHjMO3psm4/F57bHDIB0S8c7Nc7SCAzPkSZ4wVlVIctz8uqVig1qRDjH0Pfouw5NU2MYyCgww4D6XCPPFOBd9OKl0ASoC6h8Hj9OhXrSECHH2wL3Y5o0BcbFCJmg3Kn3LgqP21uKIrChU5YlVqsVtttNvGcW7N5R7rdr21gLDili18Au5LqVoOZgBOgz6EOIH4lgjKFcnzROcT6WdpahyyiNHRkbnB5JnyGHKpVSyPIMRVnEcdLZqKyGYARIqVCFNSUGihAoEVjU1OhlpvJBCAFYahDkvIRwgZjmkWk2V3AApyVHzEu6hh+PBDz0kMl5WWEY+qgQU0N5TBGoSPGbRjzu7+/hvUdZlMjyMVpAcmoa8RrxLIydGDER8drdVCGmkdLUUeE5uDBaCNMyKTeeK/NRSc6dgKcUfbqmf40h4D0R6SxFKubHTcdkvG43kfNLv39so3t9yJxrA0BQKZp/E/xTiALIMFYeQQdIQEobuFIikGJy/fH6EKV5ejVfdM3Ar0gHLAn3xzxD3iKl5sL3bH0BiGGu9PtcCuRKBvY3hSwjJi4KISpkuoAUmgBN1sK7NjxIA2t8aKNOQBXnAGeBwVtY4zBIAyFkUJo2tPgVyDSR3ngXkK0I+bHBQggFAQlrBjR1GznkzeBgjEOR03W1TRcnlPc+5EBFULYIwBVaLLwJKQAh4QJLXF3X5EkFFPAQ8vcOHkJI+CGAfUIVwOXlJYyxlJv1PoafqHSQGLX6vsdgR6PJBxVEE1BMBB/9fJr2SefBPOw/t6BTz3H++89tacgutbjnn/G5U8KR9BgcIWAiKCZU4c+99zBCYLAWx+MRWZbFtrU0RjZGgF6+fJmENKkDZNtSo6u8yFFVJS72hGZ/8+ZN8II7cK0/j1lZErivrhvc396jKIpJqomF9mazRp5plGU+KgNH7Gh8bgFQH4CgOCO/QXiyxhKFbko2JCBQn2p4Z9GcG/TDgL4bIDxim2vvPYrQZEkJhVznsf+GkhrCC6yrDaVCJBkQ+90FlJQ4n87UoS90yCTkt0ZVaeSrEtV+B24lbC2h38kg91AqQ1lKMKLe2gHWGhyPpyBAqbEAjVGq9Km01dohUcTRvAYD0dL5N58rc0MgdVa+xKhNvd70HFKScZXpAlJqFHkJux4xH/Q3RhNIFlG5mcscpNSR+twDaNsebdPj/v4IZx3tH46TZxlUSGVlWQYBATNYSDH2vaAHzeyIjmBAPgAApSBCOEholUNJKiOJyp6NuPBbANGo4PsIiccH+IKl8s153v3fYlsCGfPz4dfHnE5+PyL5/QOjYB7diMciutNYjkxjJpDleQQGa62hsgyV1qhWq4ghIIc2lGPmCirITGsJOApMe0jYUO0Vu/EK+eAav3R7Hm2wnA5e6i0/lgf2fuybzL9ZCsPw63yxWS8R6F/iZ0oFdqTkIUqpoDxZvrQbe9EBAxC4yNnacgEVL8To0QC0CJhoxaQEDB6JcGEFTpb/lNWOfkJeuI15UwYsSaUCuhpI2fHo/nmM6Ngc1rMmeAZhP+c9BBys5W5vxFSWaWL7c44NAMTveXyts0nUwxGfMFKLfyzzWQr/pc8JwAPFH+fK7HnPtyVhOjcUHzMElrYlTEF63QzqTA0Tz4ZSUEbssZKCYtwJlWNJOXZ7Y3AeK/dhGKAzRX0EAkBwv98DALquieV87LGt12tcXV0h00f0bT8JB5OXJ6GkQpakr9jLs9ZQ+arnHuICWcbtqhENIuqxIaPy4ONHbE0/wJkBxhBbp7OBndGOPdqdDq26lSbDN8xnKYJSyzLkAfuipCK2RiEA1IlXTDiUkbiownq9jnNwDI0nLYyjMuFgBCGt6VH5yfychpqnlSk8X5goiWOqMSIz2gXTPPLMCIAgwBbNl3G9ziYbMJ+zAb/NaxJA5P/QfJjEmCakvoMwAl56WCchnUMlRgxSxEP4McpF7ylaxOfzQS455wGRgO8C3S3fe5SDLjzX0L1TBFnIcwpAoEwGhHNsFoBHj+Uej89EhrCs81OOAl6jrCOQyBiW079mYwOTj5Oe52GkZyp3OJw/l3nzbclJopEQwdiiplfM6RLvncs15bRsEEmFB0cFnKOmVC6eU8Zyc49RZwG/fqyAZxoB280WeT4yOnnvJyHxJU8RGMN180FbssAebNbAW4Ou70KOjyYildEIZFwLL6jtZ14RF7oaMhRVifV2i7wgjyZeZwiFyqCYdU6LRIYOZJvtBlIIHE+n6NFY7+FDDa0TgMw0ylUFGcLH1lOYYbAGrkf0TNlK14oY+zIBpnaDFz70LQ8ARyGhPJftAMZ6yNAaVSkFocZaYKr5p3arTdcFCzMP3kBOZX/wobSSylaMs+gHg64b0PU9TPCqgEAaAgGCcy1blE8tivT7+YKbG3up4Zj+dslQnFdXPLaxp83pHufcBKzH+VVWPoxrybSGynNINdJHk1c5ArCkFJGkZdzoeuqmhvMWEHt473Fzc4OiKPC3f/s3KIoCfV/GEG1sOhPuf7Va4/XrsaFMnmcYEtBXXoyIbniPMid2SzYsr68uo8BjLIp3Dl1S1cBA2KqqSPmHjn+Hm08Y2hZuMBDOR93gw7NQknL6tM4UskxQJ0RQh04my8oDJojvnSsjrLVQQo77hahC7yw+fvyEVUWcCOUlYQLO9ZlSEELAO8AM1BZYSR0MHQpXxzyzYk750QAcibrCeg4KF5L2VzlFJLnGmlJxY3icDASBULhOf8EIsAFbMN/SWENcNnHN0OtgDermHio8y0gGFfaLURMAwo+c/czjP14vyQKmR9ZKE+ZnGHA+nXAKiPTz8YCbu1sAAl+9/grr1QpZUUAK4sb33kMYCessekN9EYwl7pUsJ6IoGeYQGyreewhH2pwcmIDCZ0MaHNYMBhMELDwkQidKQY2aTJCRbIB7KaB8kJ9hHUMIlEUxkUNfvInRb3vw1YL3P3/l9TIHWKa/F2Lk7kgdWg7JC6mgsxyr9Vhq2fd9kPkjo2eUjYI4R1JgvPceUmuKBASuBkgZo1/SGAibkt/ZCIQFEGT7l23PMgLS2sk0HJwO4nzQH/sOeOglPiXkWVFyyFd64v+OlpOelqDwNWZAXHjxYSVWO8S0TCQ210msWMceQLJJSYx80bsKAsN5T7lIHwSMj0skHpf//Py+pAfsGM4iK1/G6+JzSBEaGwXr2SWUoCwkfDDUvUcwNGbleuDFkipXAc2We/IMU6XMz2keyUnnwpc88/kxlwyApcjAY8eaH4OfUcr+lRqn8VjJb8wwhOfOz8SE78ayUAEPH7p2cn48PXbfUfgfIBIqrRRsEgljz42jDJRW4LkriSWQx5aFb7hfxghYuih4OYKPZADDcaTCz65LhPHpA76hbVqYvotjqMSUwjuGQ4OBIOJ/Dze+t8FMWzQTloUiALxWnBnQNi2yQEMslSI8RtdhEKNA46iAlKHnRVJOzHMV8NH7H/E3vN7EZK0BjEGibqHjGANejOEAL6aRvTjX3IhlwGwUBEAI79ng8FsfjHFYOxH0PG5MqpPKGPbx2CjjuZpGjHSm40k4esnrIdKJez/O8dkfxPQ8EZGOGNh4cEMCifPGkUZPn3sh0uAKKU+ZlK6J2TXwevQupCAQOf99USRHeuYWh+tp/bO0LYEYUzk3J6ni4zsXImkx9YSIy3HeQ1kbe7own4JjoylJyfKxPUBrEknaVozYO5fgCIAAXE1u87EI7dL2vHSAeBj2589TcA5bU6lVw4OYRghSCz4VWung51ohV6NgSst0+Bj87xTtzq0zm6ah/L73SRh8bL7B341KFBFYxX8pWpYffpaU4rEHEkNz4diMhfDexyqKFEAJjFSnHFEhQelgTQLECoIsz4mAaH95SWVnuy2ccziczkQ/OQy0MKWEcx5tP4TWsC0GQ0Ar6zyEUsiDd8WhRcMelPVxoafKYA6KSg0VfmafKytK5xAfax5dmIfveL/5PEoXNufJWCFyhIrRz3wvqTHIzwsCsKFZDKcDtNaQSob0CiG+B+dgzYA8p2qNqioJ4R5aR69KAhd++vgB3jsc778hBQrm9XZwlhD+zg5QpIsoDB9SMHx9PIeapqH7tcQuyNzi3jG9cR8rIcqiwP5iBwEfeQGstQH410dP8l/+5V9wOBxwuSqRZxpVqElfhfxkFioPrKW8dNs0o9ALxgRjJrwn3MBqtQpRAxFJrTgywb0Dur7H4XDAsa7x4f4evbGAVIR1MRa3t7eEgg95b55L5WoFzVHEgFZ3zoVWwgO6oY3PUgiWRRpasaJl1k9AQdF7B3oejp6BCZ3iWMmTwSRjukUITv8AnE6gOYr4AUXQ0veJAlIOPqf5zOmPdA7Po2BpeiBdM8z3z+shrfnnCicue+ZqqpGBksaBz81rkOUlR1r4XMy/Mld26XWz7JyvXYDSoX3fTVLBLP/mTgPLZueYZEugqqpHQIlPb56jxAvm6pIxMJcpcx2TjhXf88RITnWhoEgOP6sYwQqRlRSzZK1F1/M8SAxDKSGD3JHBCPaCOxNOSzfTZ9E006ZJnD77ku3ZmID54KVbOiB8gWlZSqrk08FNB32O5E6NwTF3Agg/BaGM5+fw2WjJjv8Wk31jydzsPORN0B9PqtT6N5ZD9CMzl4vXQwqbJxODN3ihM9mJEGlJR/DyPZ8b0Rp0zsWcEPH7k+EgIy99OKcnQBHt6CdNJuj2lkCdAZnqACGSHJp/6FXPn3H6TNJnPbe+lzz/VKGn55h/thQJWIoULAnT+IyTkqj5/TvnIOwYHk5R7MqrmTARgPCwVo4phWGACyVUdV1DNA3alpRmXZ9BfQe4BzxdS13XEdHPPSJcSBmxgBSCvHovROQN8DF6EcLSPslv+rG5jg0le8x4aMyAIVAgc8ns+XTCNtfIlHw4LhwZDxEhppONf5jyghhDhFRxbWJcd6kXLww1UPIYgcLGGHR9DxnAUQCS9TEqGhX4DeCnOf9JI5WwpkaBOiqQCGRj5yO51zGYnfrtCEaBgICH8AnNNUaBDy9mMhGIXeKCITCCClPPN43wMFhvdMNdaL+bVhqQwT2N5AljJ+emNagAeChuZYyZokIqp0eZOn314XejLGRZO5GrvDJEQsecfCbm8oCVWKJA2cmRfpR7qaMwNcxETJGM9z2VAxxZ+5JMwpIOSx3Uuaybjt10LCf7hM+ZEhjJ+onjFufD+OittRDeQyqOECD8dsoLEOV60DM6gJlTY8UlqYHPbc8yAvI8p5ApRu+fEaD84Hgxc56Sb46BV/OwcZZluLy8jN5727a4vb39/7f3bkuS5MiV4AHMzC8RmdnFZrNHSFkR7v9/xz7NJ8zOiJDL2ZaR5fSlKjIi3N3MgHkADuxAHea3qKrmTodWRbq7XXFRqB5VKBTlfNlUQV1iAOBdYYzcPAgROBxPcADe3YKa+z4F4viux6brcTodMc0Rp9Nitac1sUMRXIDDmAfZZpuSxoynE0KM+P79rXgdKJDSfPKcl5htsMvr0l1OhUph8P3lFc57PD8/A/Dw3QDfRQybbbbqDhg2G2z7DU7jiHGaEIr3gpmj0sY//WYD5xZPxSmnCJ3CnOYNux5wHv1mizmmNaosa2Ey7+C6DkN2VflwPsj4aZW19fTYKF97/ZqyJ48wYGhN0bcABEn5ymeLMcaYlLO476ZpKtZPSUQzjWU7z+U9DtN8Kjzuo0eHLiu/CYdD2tXx97//Pbz3+G//7b/i5eUn/MM//AOen5/wr//Pv+L5+Qn/+I//WIDw29sb/u3f/g1PTylb35fnL/i7H36b1uHnpYHep73kO+/Szn0x4u37S5lmCCE9Z7PZ4J/+6Z8QwgwXU5/++7//e3KlC/B5f3vD8XjEH//4R3z//h1/+ctfMJ5OcPg7dL7DNM4pt394S9bl5pSCErPnisGQaefCvCPiKcUVhBBxPJ0wnAaEfkjxMgj49z/+EZ33+O3f/32JBQgh7aux3e3wf/z2t1WMxPfv37Hb7fDlyxe8vr4WMOacK+m3CZ7IHxokp7JIo83ZvwycmxHPkrIU92yD58tvhwLq02Yvc9GAm67L029JOJ+Ox6Lkizt4jhhHK5SXYK45sCRKKY9+so7fs9DPew7oMshc3q539SZY2cPisrcFrkPfpWmDGIEQCQ7Su0NAjjXIeffhSiDoWruwccpR2aO86z2ecvpevZ/z4WcyIc+xb3MemGPOLUFeYP/Ss9d5X0Ag24IekBCOi0G0Qi1ZBKAAaUtl6sYYsJW8Q8QsjDTFiDjVu9bmp2VvV1f6dY5puS4AbMYJ3nfoNxsQmBUDOSajk4B8//SMPdLyfTVi7qG7pwO891XDt6wvNhCDeNYsMV7bWoJB8s7By3H7Th0ILeVSzkHBYV3eyjJ2rgyMM+Rs7rFokWhXAdESrJStpxDgYdfKLu3Kdb3DZpO8lljS8KZAw4B+TsEzPZG7k0HLuf8AxCnFJYSMOn3Xwef13lMGDC4unovSMmastwZ/y7VmBVPrmjUib61Z/FoG+9uWT5W5loN9xqkL9mnIMRM+b4SSlJmDSzk6TF8ly6j0cbG4p+X7OOHt9RUxpv3cfdelTYmOR4zjCePYpwEfgTjL0ql5xvvbW4pLc64o4nFMQZzj6VS8BsVzERehRC/AnDMOzvOS2jrFMwD73Q6bvKti3y9BvsUd2RwltDTT9zT/7HE65XwUc0oDjGypRSQLjsm2xmnCHJnsJkeBI0fzx+RVG+aweNZiTFtix2UufeZ8v0Pe7yKVkMCkuP6LRyJb1xHFcIh08KUaKceU37F4DHnV4kWIxUqX2AnZzZBBmotM82TIq9Nka7RY9wtfKwhQT4EG3KqymsQA43IznWpgvymIt7La0rlSOx+D8P78+uy5uuTVq2J2VqhdKpbmPOj8vMzXqaWTLpfLIYoF3tJ5Zy4KJ2CQ8W6+g+8AN4tlX+JeYvG8ObesJOj6ZUrnejlrugsE+LRtWrFs7JyRClkWkgpemVOvBVKSFM7pMiK7VBJppyU7AOzyjpYbx8478XqrUFpARj91jbeSdi7LQ4HAeVMOPh1cwAKQdM6Mnbjb7vC0f4LP1gefwajaftjA+2VLXEwzIkYcx1OxaMcp7z4GAA5pW+FhAJxH1894+f6C47is7Pj69WsCB+9j5UqySt0qdzuAW3RNqWv7tdq/BR4vXaMAoNX26rFKfJn715FvIzw8whyBkJd5+bTVZ3QO0S9LDU+nI46HHt6l/punCcfjO/70x4DNywZxXjxiLy8vmMcRp8MBLz/9iP95+P/w+vKKb9++4Te/+QEvLz+l/QxyudLW0Rs8Pe3hnSsesh9++AGd93j58S9LfaYJCDOmMaUr5YY8KTZgggPw9LTDt29f0HmP52GDXsavzVrH+UkqdMi45n4Ef/rTn3B8P6XVKfOcUg/3HfrNgBgCXt/fcBpPKdo+AvvnJ4wh4nBMIGUSd/fhNGKOwGmckfZZDwhxxtt7mlc+jXOxJOEBH4HoAXjJMpqn7SKBgOsAn/ZFIOAj21l9sKYfeJw5Oijz+n4oqaV1fnizOZUYH7r0u87B3y6TzfvraTTtoxa41b8Y09bLnL6ySq3ruuKVssmCHrUqtdyPksp3ldvWA9J6Zwg5u54Z83yGLZ+VRWqI2DK1PvV7QATCupchRhQejOnSQowjSLsuenRdKFNxQAr8G6dlq2weJy9sNltsNtvyvHH8hVYHTHkuck3wt5SptdhohanyZlpRumhJ3nt4OPR+cV0xqUjM1npdjjrCMoEQRWbpHku8F9BgNCKztESM1nrVHmVOLvkZlEmJ6pirn3NrPD9Ncwk8Su3CgRyrlKHJRbtJVtH7W0l8cxpHuL5H3/WIzlXurznHFQyb5E7mCoTD4VC2FgVybvISwLm4e9es/DUFvnad9vsaENDrLnkCqIBsGVoggO3GTyULDpxzOfJ7ubaasvLkg0UQhxBKzoy0mUvOmx/mHIS3TBFt8zK/BOaWjHEKDtPU0iA8m2IIQkgRx0OfNg4iUE67v004Zq9ASgY04pRTWb+/v+egwRGIaelr33clcM97j9536OBKjv5a+XM+l1vEioXtgL4fsNlus+t2WVaVruG8N+CyoKN7fA5L3Exa89xLW7s81jpwHJMfkvvTg3tcpBGX3qXxOjGmrcBdBJzju/i+vM49WMF8+TePjWOavtAAX+1Hq7RYntTHKfHRHcZZIU4BxnjuCU3jgE4YekUWmROjRrOn92vQIWUCDToGQ7bc4a0hf+uxR4j8qMpawY+VUdZQaMkXvfaSwWINTHt+7Rzn+Ut5QIUfzW96mIr/qYwBYFlCPc/caMudzfGXjbQ4ZT30laz7xTwBp9MJnTSQbRCNtLcCWT0BGggYQtoVq5d5In1+3/UpD3tGQbRsOL/Na2kVpznMNF+f5h3HPBjz+lY4YVQOHI24XMp1ytGbnA/UPNqaXAbg5h+9MC+ygFzyKVBgAiiuUgr2SeaOpnHCO96x2+3yPvPP2Gx3OI0TTqcJf/7LXzDHiO/vBwzDkHIgeJ9TDuctW/sOX56eSjm/v77ip5fvCQSEGc/Pz2n99naHruuzOzqUNMLsH7bvNUte+aDlbbkEBCw/tRT8muInqRdgAWC1QOM1NrPgHOYS8EU+pQJKn0uynSIkXOKnP/3plMtNXtRdMj3meSwrSVIugGVrYYcUBf38/Izn52ccDoeSG3+eAzrv0Pcez89PZV58GkdM04hpzKBxnnE6Jos/Kf+8JjkvU0wZLXvs8tw6QUA3J5c7jFKppgfcEtzlsjDyDtju9nh+/op5jthsDlX7zvOMMUhfwGHK4+80TUhronv0fR0vRNd539cuzXlObnYChiV3g92Nr07ZqzxFoBBjO5Oc5aXW7/f3d7y9vaXt1HNgo64a0tgo5c9pmtD5vnLV3kPexyrI0SpB5zhV4+FcyNeGAlqHnDuE16fVAYtsOxyOORbrWDbQWt6xXq6fS9m3iHKxZSS09A6p9G1E8zxwDgBa77hUrstkjd78lze6ZBI3BQfLnUjTJ2GRT+QtbglPXqYnc5yoD2f88O0rtp3yyZWiCt0HAo6nHCBUu7HTS5fgnDXBzuMcMKyo7sRnG3rM0c0FVMSYXNpDj650Nspc4zhPS0KKnPaXM1bp/TH/x5YilF58BHNk9GU6NuWADC8u04j8bJd2QHO5s1I5Qw44YjQ1cvR/zB1KEJDKEGmlAIBLG0rwmWlv6iVlKN/jYraFYsQ4jVl5pdTJb4cjvn37hn/4h39IWd02W/zPP/0J//4//x0//vgjXr6/AnBlz+sQ8vRFCBhcvQcE++4WS570qCeA1z5Cy7xsLC7bau5fEXqsA3tCSS5TeyLSoA6I0bhhfYoahwOYmGbISHzZbjrxFr1cQD0NkeboHTx82QjoeDzmMobiVTidOry9vZXsfN45HA5pf/kpJzc6Ht7LdtMxpDSyfbfsGkeAzGk8JqPymS9L3YDylwdVmRbwAgRO04S393ccTiecyq6EHM8zgoyxkMdTClhNHpS84CkF4FIqIiX+0chxh7SEMoY8RuPifes65CWTSQtGxJxCN0fSxCWhWJJVHlzFI8xW+wXtbzlW8hnktLwx9+cxL+3tcr/TUPDZM9JnC++erV2r1xc+K02wHAerurQ3ZUgiB9f57BnJhhoi3BxycB4zkca0T4MD/JRXdOQtoOsp7Lp9Gq1VHXfVMZR6rH4K+VxuPeySy0PaIN1b1njlFMi+EROgOqn1217XrNcVoFhWpYmVH+Uz3yTHKJP4PQEvjtWkJ/O0HA1r0Au2tIn3PqcP1hiC2/ntLhDw9v6WclPLulLNB1Aj86WBda93YMkXDUCs+7kIUF0fejweS+S0bhKy6YbqXURPjCqli2uz2cDFiDlbc4jJZRiBvC+DLxnCoksdWJRuFkbjlNbMurz2uHd9CdpzLg0036eMfvM0pejs/OziWsqu2S4ngwnjKTF5HthzXKYKfN9j6AY47/NGQFOJnHd+WR9MYXnM1tE8pRiEn16/49tvvuGf//mf8Zsf/g7/8Pvf49/++3/Hv/zrv+Bf//Vfcz4Bl5ccpXtfXlIe8t9++01RDGsDR63u1sC4BQDwudaaf5Ssi9Dmk9B36NRCEiJ1IOtStjoANnkAlnin5CZOqXyfn5+L9ykN4JSCj5v+MA8EsGz4ggi46PD6+grvPfb7fdpHYJ4xT2MBBT/99FPKC5H3Enj56UecTicc8/TQ29tbARHeOwx9Bz8kq46WK/uM7useviQXIqinwodzixdAxjd5+Tie0l+OpNZxGELAnNs8rdSKmDIwmcJcUma73qPzPdAtnrkYl7S6lBdU+pscKX06Jn4tbvly77LREYVhycnRJ4ua8GSNL1rE413fY5fHHus7Zc+EeguZDnYYhhS05T3mOe0r8ghFav9iuCxKRstH0FpqmO/RwEkAcHnFAYHZ6XRCQMRpGpMydQ597IGBnp/sITUK/xoASN8XIBCzvRUvAIFyq0MxlrhbZFXX/N0mL55DQHARvevQ3WMKt+rR4IeWB1JpjgzCrq+v49WyV0AAQEBKtli8330P33XYlDTcYkDMIeueOiYgxDod8y+WMfCaQG1Z/rxG52DVMhnHsXKl8VnFenP1LoUKBKzg51RDy110Zg3KeXudTlvQdctgHwUoa8uSmJADWNz/1jtCocq2qBgAfhl8cUk09OXrV+xzOeY5WVaLkHDotgmIbKYRh8MR//X//q/Y7HbYPz3hx59+xJ/+/Ge8vr5h6DfoN2n6gu9gdHpJUGT6u6XMW9fcQwoIbNDo2cBXnjDvsm5YbWNr+dtnpqar7RtKpBjcAvQcSlazQHZxyRrt+gGdS5ZLmCcgekTfl1369P1p3wG6idPWt/lRzCadl87lNf2vr/jxL39J/f/8BCBt6Z2WBi7TGw7AdpNiBzRdcpkOKZIpoM56UfcH/0sR+nn1SEbMzFXw/vaGcRzx9paW8w15yeXT83PaZXS7QcyBrHMMiKcc1Dv0iDGtFqCimuepWu/vvUfXL2lby34OSB6S1B9YXBZusbaKgpRjxTJ2KG7Z0nkVH+U+P2Nhl5V8j65bAiiXrczHAoRSuw/ZG5rupuB/lKxhpWVuAmszHtXLqvfSY8FU2FYWLnECtWxslWPtGD2d6QRWYINWtnHIjO0zOWDeG2PM2+peVthrxzWosnWdfX91L5Zgv1Z501/yXMS48GiItZdws92i6/rSR4u3JiV8I/AEFq+675a9dHLDNevXovtAQCOoRpV7i1k1WjWVzVWK03tfLB4FEOV6LJ4DBQCqrEityM6W8rDKwoIPdoZmy+Nx3RmL5dBdEpfI4OV9Wi6NxmacgVoSfd+nATMvy77YXtvdDhHA8XjCNM34/vo9T1WkOcFht4WbOmzGlCXwv/yX/5JynsdQUpNuNltshrSxxTAMFcPP84y0R+K55X/JjW/bVO+9RC1PwBoAaJ1vPc8CgBLIt+J1iDHCyfhZ8si7Smgt1a15Z7PJvJwtr+S+ntF3KbKeXq73nHlvyJ6geZ4x9AO2OaI38YCHc8jLCMey1fH7W8qkx0huZlV73u8WINot2TI1KyWTBnlgcek3BDvBJBPruBiSRMvtEME0ycDr2yteX1/x8vKSshU+pWyJm/0O3dBj6DYpedHbW1qxEEPKqvj0hGmcMR7HoqzJ4/TkdX2XpseyzDjkLHlc35/heylTUfLl++LhKcp/6bUm30gvlystX1kPZYxpZ8/j8VTJi74fsjzQ1S7kn/utU8rL5Vnr8qxFFgQAqR+Z/0HjnOhxpEdlDewrrQGD1jThvdRy1du/5nmEBaivlHPtuCrjW+VQeYZzGYC0yosMrlF+B9ReA7Y59wegbijz//NcUnOTJ0tQrqlLdOuxDZbuSxa03ZTAEbVwNUBGrUgeZ2fq+aoQOY5giQau0zSqO5PTBlbx6HQE50IZob1mQfJeCwLUc0EFzXJSGLAs/NQpkWEYZM3nYvGrACbAqNbr5s9pnDCexJswbErmNOdc2UZymlPGthQnkNzJA3eby8FlvgcGl3ZT9JLOOYRYkrXEmOMbvIePy0rxluLXT5jr9K8FFpSssPio0Gj1rwUF1hq65Xn518rzkZZ/eV+WhDJgkAOaS8tOpyOSa3Yp1/F0xNvrW3Hbv76+4nA44Pn5GV++fMHz0xP6viuW948//oh5nvH1yzMLKaC6w3a7WQBQCIjzXOZLe582xKHQ6DvhR5fc/3Aub1LlsrWS5lhdDGmfjjxHHB3QbQbsvzxjk9MnD8OQNp+honRpC9UklBMQfT8egMBtgpkKlVMnXAGyRKkDS4BtUqSuuEh1GpL9ku5bBDjPl7GGmNwB0scWtF7iV5v2VQ0gXkOvofJaCgx9uspza2T5lsC9pQjteNpuE8jURG1aXnparLGmHtV7AUD+hUdAD2lRiPUGYppzxfYV6xcQqlffWn49dknhrwGR6Lg8NV8HUfIVAOCfK1MbiV8WZE/qAABiD0lEQVQ7wAGj8FCMOefGPFV9Q6KRYWP0sFLnFt0HAobNmTJTxrGDUvPo67yiFtZ6ECwI4HaqRKeKVvU6WkGKcLlV6fJMnapIS/9UUZBYJw4QNrDWnQxJ9z+FqwIkC4z0Xn5XkFS8CWHZS8A5h2Hj0fVDiSzvDkc4PxXU2rk0v7vdbjOC3GKaJ0Q3lfdvtjtst7tsFaVMegoCuiHtxugiKk/AJSCgfabfrwGAa3QNdFhaE4a2b689p/XcRHVSqPSZlH0IKWqd67HTbmDLexMISDySLMVlWmsaJ3x/+Y4YIzabTVkW+uXLF+z3e/zud3+P/W5XMgq+vLxgniY85e1J6V2gB0mn1ZKLfVFGQTxY3nv0A9PKivcm/Vis5xgRxYNX2sUl1/4uz9fu8v4DvcyXO+/QD3nlSw6sPZ5O6NyAwaf5fcjSxMCtvCVPOq1njtc0toYz0L/0eUArkp7X+DAhGN6+lYqCMZ8KMKlUKReUnp4eV4hWAS0KO49mqQtXQqSlgsuSUNbBrpbh+FfrV+V0UWJnwyaa4/Z3YqXqNjpa2g4XDQk4B1hSf7bBUsZaKSdv1nlOl0u/eax13aU/fVbMQLp4AoCy/Xs8AwAs63Kt79JS0DHvEMidB8mzbJOu68oUQRBes7E5t9LduwhqYgy7tE3dVmwc25lJMI7FbW6nCqh8CRyOpxMOx+xej3QHJqXYCdh0zi1pg53D++GYS5EtCvEZcr1AOpYtE98hziHNz8S01n7O+8jvtmmrWXokUqR+WvccAtdtR3R9KKkrfQCSw8cjwhUBPTH/N3I0/+GUBGbfI4ScRS2kthzHKW2ScprgfNoMp8tLCru+x5ev3zDn3O20RgEkt+s8w5+OZZnk8TTh5eU7+qEvO449PT0VJuQ2zX6eyxT5vZ4AGx+ifHDLMywY5KcOuDVr3h5Xy661UmB5poM3zikLapgFrB74KTzneDyW9p3ngM3GoetcNafKpVf0CJVgPN9hM2yw3++x3+9LECEVOjP7EUCwjbk50jAMacvfzpXNhUi+8/Bu8aBV4zZGON/ntNLLPQ4NF6zjJcvxzSZZLNvtDn2/eKimnEp4zjOjm90+rarJ6a8P7+/Y9h32myUwWDdsoUWjoNkGGtuldtpXLbBdrkNMKbKz9eVirYkcWkGuy/duSFM+aZzEshJos9sWsLQooKVB0yqIDmKD3E0sKZdAcg8BboWc4vliVkAx4zh69DxSgHIPuFQIKiQaGwwqdS4FAg6Z77qug+84r0LZu5Sqbi8Z79T0apjmSlSfbGNXt3UA41z4jFSvEOZk3FAPRMC7joyLOKdVVvM8L/Je6BYgoIYDAZHKNqtcz+RQXOrOduZ1qvhjVIBAWZWCiWngjsxx4+rpqFS+lNw5ICKGlMdCh64GCV6j+zIGGkvfImMdtHYQWpRCYabCWs/xeeM45QrWAXXenQetENHyu7rhY9TrgDJh6BzgfPkd2UGB5Up7DjDl6TIIl+vmOSAiWTvDkPL5Q1BhSsbS5frRpciVB7TWO0S3bGiUXLopOnoKY0kHXNyuzmO73SEMy5RHikxPc0l+nnMEcMQcUqDZOI7YbLcYNim3wDBscqi7S+vTXUh7y0tQjbWib7HObwUA1zxC5AdF+2tBixrboOd1MK+h45ZBuDxraYsaaCRwQG/R6RQxz2l6QD08rBdBQBUE2vXYDBtsNumvmlZzrkrl6pwrykCTPXW8VpW5c80VHqW9Y5r6sXn0XeZZPiqutI3v0r37nDmQ7/n++ooQp7LSZej7tIkKkFcILMF/ylc6xaYWrQrh8u7iOajljv5ZGUUDwrlkDCzT8+d8Wv9G9V7v07gOLmSrbeFH9QQor3jPpb4CDu4g9gnllsqdshESFqVvh2TkMZfncbKi4fOSfB3x/r7sXZGs0rTEseaRC4q/cbziH6l+9UkAoIAhLPPjXexKeZlSmn2aQMvykMiAO5iloNoeDRmhpPE0Oo71nWv3snPSCoj6utr4OAcAMcZqfM856BSZpwkAFi8Nco/TIJ0r2NNK+LRG92UMnCbM8+LqprtdyRvBpeieFaYH4P09bYxBK5kZA6dpKpXmGl8VGtazYBtTP9eOtcgqHqYE9T6trz5IpHfXddjv9+U3pyje39/L0ileV9yR3pdkJ7rNMC0ctt14PGE8jWnr1N0WtH04QE9s85gE3n6/T0uThh5zCDgek6X45fkZu/0Tnr98LcvUiMCTUmRAVuqTGAI2goLvseYrJXMDtUBiqy/1WG2JL/fq1M2ld62Vb5EjrbrZMhFs0EWt70HaYng7pF0CfRK49LoQqNELNvQDdtsdpmnCjz/+WIKBXl9fcTwe8f37C/quK5vn7Pc7PD/lZYQhZM9PxIBlXTEt6xjmkur33Hohj59PRen2uWlDGcmelsFG8n6c8PLygjdud4wlvbbPW3+XyP48xr99+wYffeU9ZLvq8j4q8hjrPAvDMJQ5bl6rIIDTItp/dIHHGBG72/JaKM/ob77XZjVVbxPfaacCH03D670vAaF8rtbdjj875frTTz8VzyuwZHfc5w3OhmEoniXmmuBuk7/5zW/w7du3h8r9USII0ABFbXsFYErJYxDqBT88Z+T/JRDA88oH1tiwPJxWB5wDo/P3orofSOPx/XBAjLkMXYd+s61kBrcWB5C2lR/S5lx93+P19QVj1i330t1LBG0DKCXGq6Oz0/GyBRAADsxlXaP3Hbw/f6bLQoeCqX5HXTZrRS7Iub3szIKE5dwy4DlgeF6DDBnByfuT52CqBinL0HWyjakILTIZ22vJXJimClx29aqXhIg4oewO3rklYLHv4eYZxxjznGyaMhkGoO+6vPNW3vqV9Z7Tuu4Q5pQnvzNJQuh6u4VisbNW79HzLrv5tL/PrrceB5dNB/HmKlBYBSKNech0bYSpbjV1matlbl/MGkd+d2mVwZCjw7liIGYQ0Pd9sXCAZfqCe0OUmIEuZcecxhHj8QjngMN7UvZ//9vfYrMZitfgkIUG/0raZy9725c6xDLn75xLVYh0WKklnVMFKxjgOZ/+cEzBjkDaOZOrCJH71OWgvjAvAVreeXSbHpgCwpTc5yF7B/gXQiieCI4zjicqNqZSLUG5YYZ3y26WLeCYtvMOcOLavsUsr0FwuifGKCtI2h6EM/AQaZmp5+vq68v9dRyVAlrlSgIhv/QjEojSbWbJm9vtpsr3stkMWW7N2RCb8eXLl6peKK+kbG0r1QQEUyIs2xaXjAkF3UtbAmd9FZf6Vu0skyCWYuP7GgdU5VoO1p/1DWV8LcVdPDepLlqfWkfxFubE6PsUn+X7oQKWGpjKzJp912EzDHgvYz4XaaVuLbozJmCDGBeF3vcdum5ZYpIUmMc8c/7KAUjzYUuDpGMJ4X4t9y1ofoNh2JdnTdOYc3b3OS1v6od5ZpNzfb0GGIWMnuqtRtPn4lobxyUClS5J7x2+fPkG5LmZ1DFpsPX9Uteu8xhHRvYnILPd7oVH1HMBAB4xuuSCz9MOzvkS7Xw6LZnXAGDYb4tVRxfY8XhEmJbpjq5P80LzdMIUI8bXVNeh61PbMH1snuvvwwwfAroQEPNmRIgRPkb0SMmROpdchjGEzNQxJTUKFKihMDQECUcRRvyXciP9XhR+BEo2MBXJc+Sa6nj2qUFQgPH0OGDYbvJxlOso/GPe1CNwDo3l5YCKDh6LqzFkho0hbRrks3Dq4IA82GgZb7dbDH2PlBveYbMd4L0rG4mEOSBgwsvxe+Gxjdtg97QHEDGfTtj2Pfa/+U0R0Bz405h26eu6nKTnyKjhFAm/3z9jnme8vR/QjzOmOZZ4AgIK59O8Lq3vYbvLc777AmTVhR5yQOHpOOVc+8fiFejyNtsOPfabHtM8JUWf+3fg/gdZUU3HqbSx9x2Gwae4F8yIPvHZaZpy5HOaXqmFY8QY0j4K83hCPB3x559+TO282eZ0yDv0PfLSQo8ZsUqUEoGUNa/zZR6ZrvkFmBfxXUCULwAoHZumKccDAEByUSMibxEcylgAupS+O3P3PEU4F0vciY7xMjIcP93Zeecc3t+PBfvqGNDxxs95Tu/jivXtdkDXO4S8vOwPf/h/izHz/PyEf/7n/xMpcHjAOJ0Q4oyuT7/3T1vs9xscT2lJcgHweWryNXuoqpiuecbheMRut8Pf/d3fl3bhzqiMnWCxqchTuuyYs3F2eH76WnRC6cs+YrvJUkQMKP7udkMeN1ORX+lULMAyd3i5xwKBU4wlQ2261ASEFvCZeZVyMgTAd4jdsonPAggIEvwCoLAAhEQ+p3hO3wEHF9PmV91mg00/YLfZJvBMGTyNeH35CW/OpQ3EWkjnBrp7K2FVbunTWnBklPr7uWvNlWQ1tasfWdEvaJ6RsMnwXhAwLZl0L92WQIyuBNFoZyaEd+7iJnHqYcnvP2HZc6B2Wdcotg5KWupyjsc0epnPZFk4yGnVU5hrLvwoQmARGigM6r2Hz70awpyVYFouhuwiVlTG9MPsOg4O6TgRzGIF2eOlLaWfYRh9GZX1p56msFv9XFC3Upm7zBfH7O0I8szIdjaClGGjTtqEn1Hap7aYXQFcm7yEU92/CUgAcU7vmcOM6CM6lxI6Dd2Q5s/nKSXYyWv9uwwyYoyYs1Xc+drjlHazW5bWMpiU54C5gG6WicFIvksBgQm0cLmew+Kti0iANeHHaQpgpHnsgC4uLlM3q/MTKckVd54oesgtvxfcnkHhUie1/K2blT01h4C3vCIiIgWBDcMAFxy6GOEQUoKnaLlDeEyfK1ZZxUsEqEUhu8xTNDrk3hDr54rcI+BwedlocWKVT3cmL+z0TOGlBp3LF5W9qQDee3RISy5DDBhzDhHucjiOJ1nZlMrW910OcM6gzyXFv2yNnIwDbqGt8Q9pqivt/EiAmKZF2ed1mfnMGPNmSaAH9Fw1qayrKDeqo2fGh8WjFxdPQyHvKwBgvcKItd6oQEA+N8vxpY88nD9/JotoDRi9JI3Vbrmv4NIcQ+MjvDufElLd8Kt4Ah6lpous8WnPk3SeS5eF8JwOIB6nFb3b7cqcvZ1DZCS/Lu8Dlo7X1Q6tMl+rR6vOllrH06ZBT+U8I3itoGC56dJj/TRNM5en2eWSfEYJtMzK6/10QivvdEuwWqCzFpzXtN7N87z32HR9895acMczfopxmarRa9ZWEpiaJU+BO+dT1lHrqjyoFvQarU5P5Dp3XVr2ybgG3fJVV+PweqBeJw4A+/0em02aH2Q/czth3ksvw36/xzBskrU8obQbFTsD/bbbbTX/qu3CuVnlPT3OenNJq9aPwbraL9qnFgToNZw+nOcZb29v6LoOh8OhxApwnwT2CwVk8YJI3I32XWtVE8cOf3P5sSoHnZdv/eZz+n6olJo1Pq5RPR2w0DW5GYtyXGTd7373OxwOB7y+vmIYBry/v1c5S7ih1bdv3+C9P1uKreOAKwhINFhSfMpQbcHO9rYxKqybXe/eVN5arwu/W3JoTYa05BCngPVZ9lNXDRTehcO4kmjIlqV1TqeegSXC/5LsW5M/1+SS0sMg4BoD6nHbKdee2xLErb/WOXtMoyrt8+ppgPZqA62bnl8DAOrBuLV9Lh2zQOJa3VvP0voyYKl1Ppbft5VTqcXcdjBr25z1c4OfbN1v4aHWwG49d3kevUptkKPflWfW+PHS+87GDJa5W5Zd7/N5ft7njaiWNoq8u2yQQwUILJsTVc8SsMeVJyEs4ImZKcsug1kgacCbtrE+l3Wk0CdpO2m/aPS1fl4S0iyLjf2h0tHUvRofYBVzi6/WwLuWQVd1tPpzrexr40Lva/22Y6glT24ZH5xiSVs3O+x2O6TNlGQ31xAR3WI8cYlgDcjyeySAZvFqJpmxJCIL8K476wP9s3VRA03jydbG8jUgYGmtvVrH7Xl7fO0zRnf23Et93Sqj6kttv1Ydrz3rVrp7OuBRRHqLAG81HBW53TOAz6WgsQhS11TS2tfyAOcR6XwGU2mqdXmpni1woEEcrXsvHT+dTsVqaglQ7YcYl6xfirx5LS0vZSgKT/0MIcDB4fnp+Uwh2wG5NkCZLW1tgF66f2RyjMY9a0jYKqZbBUHFZzf2r1WiPKb7RqyNDb3eKrLiPnZ5fMGV5a86X++cK7tSAkmoq8IehgFP+2eM/Yi+G7Db7vF1/lYsQN7//PSMruvw/n4owYWMwN5sNikXRX4ehTEtfHqeWtHvCjKB861+W+BJ+20NEFgr9OnpqVIkOtb1OpUbVqm0+FDLo5+lm67w/ppy4PeWArgEAHicHpRrILX1G0hxRDEGbDdb9F2P3/397zDPAe+HdyAuCjhtkuYw9B5Dv0Hne4R5xDROCHPM7unMp0hTBNscva4yOISAzbDFPIey3Tvd1q0Uxuw75Sl95hq1QKn+XgOt+lunYu3n2jH77Ep/eA/XDwBck0+uHbMKXz1ZPKbGiI6lW3Vsi+72BNyqzFqD4NJ9rcHD32t/rfN6rPUM4DKKVMF1bZC1lP+tvy8dVwZQhWGXrlgQw09letsWPK9uPrX0+j4Fk60x/yVGbtWpJeDbYG+dT+xxe7/W99J1bMPKInQOzMnVQv78bkGAVex2QPJ+VYLnvCqZz5AC71oDvJRddoRr8bO2Q9lvYrstqwkUBLbaea2vLZDR9rGKVME3UOd5sFN5rbK3eMnWy5ZfwZjepwJT627LroBijZc5Jm072eta4y2lQD5v69Y4aVGrv9Z4fY14KgVX11amtgv/7BJEfQ6L2VJIBKVAXuGUL27t9QKcg0X1yl5qD+2XFrjSz9axS7LsFhCwJhM1yHTtvfad18pzqYyXgNKt9EBg4O2/SRbVrSn+1jW6lOpeT4AKD7WqLPNbN6Ey5FpQzrV63wMY7HEbcWvraEkTJLE+OtWhaZtZZ51/Vut9s92WABUFI7o2WQNTLimVe8j7tEUzcJ8XQOtswYACDv2rwBQAH6ez3df4nBYAUEF1ab62pUTVc8DdBDlfv9lsqjl2u0cG+5Jz02W/AuCsrtyP4OnpCbvdrmz289NPP2Ge57ySZdnRk+3SsjpZZ83uB6DknmAdNUUteUzHFPMb2GkD25/6aftjv99XY2ENjABLHATjBJhvQXkbqEGABTw8pnXltba/WyAplanmjXsAANtO28C+t0WqfFOg9LIZmfe+xBxxHKsXMcaUVnztPVZOnoPbBDY2m215L6erVLaxfBwXIYRq98tHZYoFMJdkiH3HtXuta17rEmLAyeiLSyDAgjjlZSuDCMzss1tTXPqeW+g+T0ADnd2i3NaY+BYQANRukJaFxOtb6NhayyoEtHwtxG+zTsXGNwBnuyuml6N2q7vyj4k8Pr9P66gdbdulvF8UXiu2oWUF2kGWBrQra67VravBlJf64RLKvfRZqu5gm9YoUyxLa/K1zrmy/j2tAqgHUoyxLAdMv1GWisW8/LGL8WYQoKsAtL1byrgWit3ZsziHyKQ86l6P0vYAyjVpsyjmDk8rEJz3iW+8S0GOIWAOcwkSdD4lqTqejjjmKZt+2OQlfx2czNHTQzSHkHkhl63rECOj3V1Z+VFaLXUCFp6O9XlG2Nv7yr38yEtJ2dnkASyKpyhbtm+My8qPXEaEuARYF/5w5fnlXIymDsJfttxVmcUkJq/weocqJgOoLUQLXFqy7qOgmpRA2wLMdCyrTGAZWvKjNcaVrHIlcWxGpD4JOc36rFM8Pq2GCdUzUnrmqm/Ky9I/ce03kPaqCGE5J58RMcVAiAzQZ1T14PtjnQ665oWF3+Hqqalrcq8FQLQtayDX9nisAchfDARYoX8rKr3mXtfn2msolKziWVNOGnTE+XAiXc5L8VqiYnUlhpAysUWk/OAtS0Np7XjXdUs+9yzPVK5Uv/ksl0WOlLtlbdu2omIimlal33JhtlBomjeulVtzUBuBoWXTVQm2Ta4NAKRVtFgGtH5GVMv8ypmlPbmW/tL7OKDtNV3sCkjQ4xYEsJ2ty5IoXYUq77denErIuh7RhZTUaehTfvpe5rcd4HTue8gZAfsOmNOSOecchi4vKR1SRPY0Tzgcj+nvdMwZxV5Lpr8YI/phi83GYbPdwTlXLLS3nFgmxoC+T5kPh2HA1nclbwLrEqQPIpa91NNvV/3mXusx1tdVlS0frjrEr1X7iZwIqJWMi2k/CD8HwAX4Li0947u5XDK2lHv5ncrvgJz62FXX5bRIpW8gZTqTgyECuJ7G1QJIPW6vaZ1rHU/pql2Rf3YDIZWVCmhb1qhOH9py6/UJoHk43y+xADHlzGc5SEOeMmD8QMwg6jTWXjD7vku/uWOiPV+XM4MDAZCsq05b5Etz/0fAZbmYwSc41RMjOt9jGHbNsmldWjIwhIC3t7emB1iftbYKxV57iweb9OHAwFs8AWtKfs0TcMsz15COHTAthWfPt5g6fakx5iVEZ8vjvS8Rt4vFWpk8DRSQlVyIeVOiuVKy1tuhg5KK/JritsfrNnHg9rG2zRRUxbhsr6xt3AoMvBUIpEyGE4qJX+WCWIspYPnOt6i+VgY5AB+ZxOO8XC0Q0PIEtNyX9l4rYHx08B2TbnW5/dneBHdcv+3yd0a+IyeequdR+YzCwoV30trr7XZ5/zwHDMNSToJG/sW4bJ/N4CQqg2XVTSfPq129LA/5iy5nHl8urLvEYX3cW76z67Wtd4aBdc45jAakrsqd/JnmtEMBLTbHh6VVgLuiyC5Z3Hq8JV9a17aOzSU1SFvo1EpRVw4tSdUW+U15Wbcf8zyEUGdFRJwLCOAzLQhgf5E3JgNEHqE1WWDlZkse1TquuBtLzJB9ZvXbuTOQdcsnv7eMD5X5a9d/lB5aInirB0ArY6+9BQDo73ULcqHWORXOFsS0FGw1MIuraF3xrw3Sa241fda59yNF5VrFYlc4WMtbPQJKtm1XmTK3l028rZbsGqAD0ta2mi/e1vPSIDiejjgc59V2WgMCwDLfbO+5iWKEj3MBARaxW2+ABQG6xlqjm9k+nI9mhD4phADfDfBd3Z6L0PXouvpdvG7OCYi4R30CZT2YaYyCOAnmpAS4Vp3leH8/Vl4xjlHNKaHKnso/xiUrIeMJSHZDMOYcYH2Px+MZf66N9zUlR28X15VrTn7bP6mt5mqDLbWabIKnhSXO8xVoToSWDFj7jdIj9ZzvLQCA59bmx2+RwyHMBUSm9uvkXPL4UIGnNmFbuoxdXOFHbqlNpb9E9hNsTZmHe8BFxHnZU4XWq+5jwDLYWJRWAOElUlkA1DtTrsltvlvPkdZkxzWZMs0Rp+Np9Xn3gAA1HHQMKQ8p31jdtcZPLXrYE3ALA7aY/pJAX7NabQeuISO95mwgyqDXQd5SoiUA70KZW2TLY62itYFsj6tyUaHFwCvWjznBbaCVBTWXLIwqsCRGnMax7HBln2HRqX22lrn1LttPdZ1Rsm3Z664NXG2vu0lAgD7bDjK1/PW7Rj0rX7JtLDCr+tQ7dH07ol3bum6nxUrpOl8JVv5pqmyWkX1trQsVLPT0UIgymEuTmHA9vp2ismOJoIHv0qVhLV61dbykGNf4zx5THrd8tM4O60rdln2NzmVFDb4tGG8BAj1nPXyXZK2lcUyZAcsyUen7JTZliYPiclFgkTOJZ+o20nc25UTXye6rvlLMquTJX3wWE0y1gke1fa4ds+et7rDnSZfc6Nfki/c4Ax/6/dIx27+Wt+15K3Meln/4FfIErCkg7YxLQKA1IFsR6WuKh0ysLlMVltY1VSlgJG+ALWuLLik+reNaW9j204HP9dlcw60Aw669tYjSKm59L4X0ci9wPB4wi7vPKr+WO1zLvNYu1z77ocMwn+8Vf0koPyKcz44BcGE68wTYd9m25Kdmm9T4C17P9fbWi5P40sH3bS+ZBQFrPDKOI47H41m9VJnrKpf0zJxGNtR84JyrsuKp9auKXFeI6DhdAwEAKh7V+2y9r/Vbq41sH2k760oWPW4/W4rF/r4XAOjv8wi3c2rJP/KQrX/rvS06Ht/L5lS8ToEAs/wBi2eUfLcG2rSstp/ZJ33fY7vbVysSKIfpvXFuMWwo7+jRe39/X1XIt8jV1j1WdrTkuspWS9fe45zHMKSU27asa/pDj7fisFplUNnQAlb30s8yHdA63lLil65tAQHgPGKStKZkrfInU2nnKrPTXQugEubOuxwYKNnNLgVbGISZoklNhxoEXW41j+q7Dpt+kLnZJf2vCmF1tQE4Y4wY49kyM9v+NVMBw2aDLtRCtUL4xhOg7a9KgMcufVbfHdB5CQ2MSNsex9yn+UDIOX6jhlbaccOpXRNg5iTbmV7qgiueAAsyo+kzW3+rZDXaWgWfjRoOIe2wF2Laerfzi2ua9Q85yr8Apa6Hc9nd6Tv0mwERQNf3Jd6E5er7Ab7vEF0KIDxNYwnQSl6IHp1HCuCLqe1957F/Wrb1Zh3Iaz5EzCHmTYl6zCFiPskWuRlckE7jEkcApH0LYowYp3Pgrd8tKFA+m2YFu4DzS1DnHOrNg2xPW2tpzvuCzOE8aM+55Al0mWVCjJhNfZZnsdzplzdjI8wzwrRWrst0aexeOwakuBFdJmkT0KisXXgnXc+pIS2LkjUEdLmfcx7THDBNM8ZphvcR3kdM01z6EACcT+dKXpQu9cU4rScdW/vNY5eCAvV7Sx4pWF1r27XfKTgVsJ6ftXfZ3zQUrPxpJZ5rjZFKHp+1zDr97J6A1vnzYKHapdQCAHrdLY3Y6mAiTQoxjZwHzrOY8f60vMTB930WBLlMPgWQIcYKEMQYy9RBOYZ6iWGF7q/8Jjhh27E+uue6uoGt0tEpDwIFm3tA3dRFSTmHzYBqOkD77ZJwBs73Wl/rn9b5rvPohmUzEa4GKJ85UMlFomURXr49KC8NXm17ZBBgB50FNS0gQCWvQEz7w66vV14OCAhIG4P4vqu2rg4hYDqe0ja7zMfvPTqkZX0dd2UDyooCBSbe52V9AKYw45S3Kw4xWX+bIe0iGHN7+6wkt9u0eyWzZpLPQjykDYN8SBsQ+a6a33WujgGIMVbr6ulVCFWg2P0gIEa7K2hXxuM8TxVwtmNi6PpqKiOEsOxqZ8rjfT31k7J41vt31KDYN48DwOymMxBwqwXLPrBgVMvbIoKSzWbZSyHGlEFwztk5F4Vdtz9BQGs5tQUMGlNRTT/BYZqTwj8DAQoCDQjo+jSOroGANXkCoJpKuKQf1p5zra3X+82VlSdr5VwrtwJvuzlQSw61dJeSd7d7Bn7W1QFr96jLuHXvpUFPdKQuJZbDoiW9jwKJkcEqYG2wim46AmQgECMOx+NVRmyhPW0r/rFDqdwpCOkGozDlYFUBq0JLy8D24DyaWpt00fEY33MuvLKgyu/quh4eKnTPB8eaxV/taOVq17leay3uBFZGnMY6NW2MsfzmvafTqQrAozDb7/cIIZTgNPJDa16dvJSWT3lgSqsi7DSTutqU57S/+Wyd+2y1gRU+QBqovvPwvoNjUF/MuRq6Dm7XlXIlx0fybYQAzFPAPAU4eDw9PSfBY3k1yNSD69B3gINP2+EquBVlMGawcDweSx0YKOi9x263q/hFx7a6hbX9eN7W/xKtAQJtW+U9C2wrkN24Xo+vWVnkTW0ny0s6JrTM+swg045NINoop7aZHW/3UN8zZiUt6CSg7jpOMbjCNqmOwOk0YprmXCePeY6Ikds9L/eM2TOyjJsUJHg8jogOCPCVzOJ3OzUB1Jtj8ZqWrG3J3JZi1T7T363zep22davN1wACDRO48zwBl74v7b6Mn9Z0ty2nfY71YEx3eJ7uAgGtSNpb6REAANRJVqxiVeWplpgK42maqrlN4NxNrlZD6YQQMJ5OJbFFSyDxWfxUBrGIWduQ11NwEfXpvbZ8tpO1vBTgGuTTAl8t5U+G45KwbkhrfLVOdqBZd5UKQtZR0aqdD9fpDDL+NAWcxgS6aK2FEKocDnov++l0Oombd/GWUGlphG3kPtwZXLD97bJItWwUoasVqYBH72kF6KwJK+d8cq27BQDEqO/tq/vVMgglAY3DbrtPe4yHGlilP/J32kAmPctVsyIKFgmyFESGEDDNMzY5UFBjabiFs0MdvWyVOJw7S74Fo/Au/eWrYJpWcE/2CqyQc22grp+WzkDLhfGvv7W8QIrQb3lDW2VogZ6We/vW3wBKxP9yrs6oahXUnKdU1Ks4TUvcUPZdYjqz1lMWzBCmtNKosRzxvE/rNrMgwMoWK29bAao2aK6UzgIC55SBmm14S/tquybR2QaK157RkqmterTutXEv1iN7iX6VrYSBOjUnsHT82idpEdSxBPOxo1XR2EFDJOS9ryx/DQjkvWww3jOOY5pHzczc+Q5wQNenBEBe53dLkFRIc38xIM4xbfYSXdmDnElQTlxCh2V/9BjT/fmJ2PQDtv2yHMmCCzuA7ABRq0gZROMK2GYMXKPn5HCKZ8LaCiZVyraPzwXKfFY+/V7K0e/w/LxB3/Xo+h7H4yFZGjEgTGNRcg4BnXd43u/gvMfz0y5ZqNsdpnnG0HcSIS8b3OT2jgQWXYeh79B1Hs4NZ0qW9VUQQOChIMTyngom2yf6TPJACHPKwhdTBkDvfcrW52svRgRydrU0LeW8K8mlUv3yb++BvPe7dy5dF2UaJcs+ZOARmSmNeRkkQ54r31kGl1uSf4VDyCj1J8utniXem8fDkhyofpc+n/L6I0TWe/QxnCKjw4X6ox6Lelzf93jhOUaVbgUCaiC0zp+BnMaztByXZLa9LkZUmQHTSeA8R0qjhZzqifTPklEwg91IgBsKX8eYuLnjckyVN/lh7c/l1T7Ln6U96gvsb31BGs+NUze2ceu6Fiiw16yB2FvpVwEBFqmpJd9iJmthJUuxntO3UeoKFBJyXebvVPnr2noOEJtV75Q9AMEDcElQMp0urUtScDmTWA70KgwaY0pFm+vEexi4pJ4M7egQAjwcBt9e52rRrHUjtbwlqpgUAKmQGIYBznscxuNZGmSL3NdoLbCu1ff2uX3vMPQLqJunDmGegZiyiAXGcsQUVT8MjMpfoou7aULMVtdsvCPAksymuO69Q+ddDi5DVUbSpbk3XksPgeVhrbt9hvceM3KgnZvhcrrjECM6ACE6dNJGzrksHH2VTKcoTZf1egQQPXyMiC5Z/THGrMWMsOaNRvHyuLmDN6Zjlh8sAFgFAouGVC9B+dN3gXkTauH7iNAr/XL3nfqM8g21V6IuZ/X5wXcC7WVndbnWQYCdDrukwO2zqnPZljmvZzvnQYznxgQV9RrZcutxKyNbXoDFExmFv+tnr32Suoa3+3YlDjCXgtIaULLX3ELUffbYpXa9Rr8KCFgLsOL3NbccFbQVpsp4GuWqpHNM6krXKQ12BudBeXwYBgzOIU+iFqLSbrlabAQ438ny0yXOuVbOrcYYy/I//o7TXGIZWm1jB50ytM6J6qBh3bkEjM9mex4OBwAOYc5R142+0P5qlUsBmLr7tY8Yw8CNcLouBcQd3l/x+vpjWZuuXgoFgfZdJM2ZoH2i8R7KQyyHdw7Hw7FE4Wt7sU2VtF9DCCWtbkuoaN8023OeMc0TFqxIIJGUPT9TgheXvRYauwJDSaE7F0VxAihzwQvZrJC30No4vfU+fl/j5UeefQ99RFheUwQtL51c/NA7STZa/ValRA9lEWIRy8qbkghNwFGMleK0Ms2Va2u/UaygYvrlPYohwzK2PBCtPuExNWKU1jyiCrB1vK+VYa39Wu156zVr4OKWZ+h0NOvJzzX+sgbfI3QXCHh0EFGwqtsUqDtzrWPV/aqKS88rtZBvC2Fqo5XIVE0L23VwQ4qYbwWykbRMau0dc1ChvYceCiVa5KQpRIxhrJ5trehW/Sxj23dr3fVZVNwAECLT115muBYQaE0HaNlsWxEADMOA4yEpeoIY52o3vAV/OlAIzpTP1FOkCX2UR/q+L1b1JcDV4ks934qTsX3SGqQ+RmCu3cnLZ5rzT9u+0lBeItFTG6zN+7EebaUaIzDH+SYT9VHFv3b/Gl9d+r0GpO6lj1pMa4YMz62V+6N0TXmsW6YZ/DUU3iUFSfLOc++hTEnlu6zqq89yLyeRUtZB+3y20y3Bji2wcKkP1/jI9psCDHvdowAAWNInr13zCNiwxy/x2SVgc4nuAgHzPC+b4txIKqBJVjCsffKd8zxXClo7kCCBjaNrVe377FIW3UaTbmJaoP3Qww0D4JZNLzQojEQlo3/ee7y/v+N4PFbMrsrGJlrR5VRzXhmgikkVjVW6rWhSPlcHXkshlpzdU7JIXb8eXNVSbEqHw6EkJvHe4/n5uVLqiuwZ1EcLPoapeAj0fawbA9a0n7mkLYSA9/d3AKgABEEG625B0eFwgHMO290OTtrCpprW9mp5ArgMle1op0MUyGiQYTfPiCZASwd5S+lpXepc/OveGj1W2jYEBFc/1153KwC4RznbMl2iNeH9KH0kyp5laJVNy9e+9uFXlnetWXrXFEvXdWUqpqUk1j6BjyWg4Rhck0u2PjZuqOWNawGBlhF0S3Ioe45U73VQ07W2Tn3ejpdq3XMGusR7bQ0bXq/6oDXGH6G7QICNUL+VWoxgEVkLoem9a53fulafZS3elmC0SDD9TnN+EUAJVGk1shGa1trlOY0ady4nIpJylI5G2pe6pWhtp6+1UYvadTx/rst1ar3jlmNU+t774s7XhExUlMCidFPdozB2KgnBEsvlgBRw6eq0vS6/FxbsdPVuf97lne9KWwU4OPhN7W3QduTxNfStLlNV/jqNpXyh5QsA+gZ/0zXb5De+HyjbrbYUuJLt61haND3p7J7C6wvPR3uudY/9Lp/qMHYL41exYlq38wrH1evvoUfvte/l73Lclo8nfwa6JNxb4GP5nXnuZyjIvQACBPxITVM+aQSIMdDi/aqfcoM2r2l8ziFUMSjt68o/AtI43Wt1nA0gPA8oTFVeePsWELB23Zrn+ZLc/ghguwsETOP4EKy95N67BADUotPodp6jxa/WGoHKOI4YhgFPT08l8xWfwQ1QNEe6Bt8cDgf4zsOFTdoqMjOO77uU3W1TR+u6rFzGecIY0sKYL9++4je//bukjLLQZHljTBtNhJhWFIzTVNJkhjnAZSZ8dOjqcjUqJFqOutGNcymZUtd12O/3cM7j7TCWtMFsD2XCFgIn/af/9J/w9evXsgLhcDiUxCT6HPbXfr8vCvF4eMXh7Sd0LiWu6Yel32ME5k2ed89CjeufO5ci4HvvAOfRd2nnvb7PUwnewxHQ+aSM0iqO7NGJAcdjiofQ3BGqvHVds03ksdul1QnkscPhUD61vrvdDn3f53bOOzJ2HfxuV1aYhBBy1rGcxGbpUEQBMAhpT/ZxHBddk0EO66zghwBIAWvIqwkiPKLLfwBi3jI4uoDoUrR+dB5wEdF3gPPluAyA6pNAQz+Xa+W6insi/+cvWCnrorzrbnIpiPdBFGBvK9Z1cX8XmCpn2/feQ865s+XNZ2W7oFhieMwLwN+3WNSt++cQME5JXaryj5nHyyeX7WZ+jzJmbCNaZS6nWMD0jGm8EBTI+BgTJ2OBhyHb7C0+cjHCx3Mj+RbFr3JGpz4VDOi1LcOiAgJ3jJNfJSYAeNxV0brXWslsiFZjayOtNX5ryRsZF6F+F9F+i5gqmJY+gQbdt8DSwbT2I5bBlpRAgEdMqWOu1Nu2jyLFS26iVj8Wa3cFzbY8MHbw6/JLDchsMTKBCNtFYz8SdWVgxBjh/dDsX67B5vPyGb0IjGoGqIMcXExqLEQrJNYHqfKRLbttD+VJ5c1iCYUAxwRW3sOFAMxzWlECJEW70t+FZ3htrldASlmLRv9KeNjSQmLlN2pcrrHXqoegvF+BgFzbAgJn/IvcP4bvzrqBnrmHtapRLHdSbemmcji3lP3cO/D4u9ZI287yxxm/RMjSurYiusT7KhtvucfKi1m+65+OF25LTF4OKsMqoIk8ls+9QYvNny8rndIqI6pPyL1a75rW/EDnV7X6/LK3Zv29LVnO3/bPeunnXypZ0KO0Vgk9t9YAQM3capXpeRusRyuf1jej4m0mOV6rv/ucLnh0KJGv1xSEJb6HFiMt/b7vMc8zvn//DgAlPSdXDXRdhw5+sWSlrVrtAdSxDnY5kSpfXU5p+2EcxyzRzqpSvbc1kPn8f/mXf8E8z8WzoiloNZaDnoLv378X4OAxw7u6bzTGQu+PMeL19RXzPJd2ZVAhPRtqhdt+rtsmZUlUpa2I3M7jV4Att0GJa4gpI6Tym/IIn0+PQw9gu9uVOrHc+h7Lc+Rhu1kRPxVcrQUsLmWpy6bUGqNrZMH4tWst6LZAaY3YTo8aFGuGwC3UitBvgTzSR4we+55H56gBYBrnomj1mmvAl/x4DwjQ64JzFZBdu1ZBNd+pMsDStXbV8XWt3GvlWXvH1faOEWFqB+teeidwPnYsXymv2fsA4OXlpdpI7D9ksqCWJXAJCCi6bQl0JVVE1kXC43TDr82dqEvFe58t4iXDXOtdtsz2typMdTXTnQwsa4AVsHTRwaMWwi1rv9Vm+ttaqGvgi4oFANIq9TajrtVTlbNa9C3BSGXMupb+ylnstL1GCZDUtNGtPtC+U4VrAzA1QJB7mKdnL6mK7cqDS21gAz/tToprwm95V7LDU53qtrVKK4p5mYwiO27qeIqVUp9ZQffQLaC99dueaynRVntfGmv3kAXOP+cz7Jhc45lH37wm0G8BAUDaB4G8Q/DnXJTP5Xh+UqlPqHKGWFd6zbd6TXARsSFrW3KD42hNrtlj13jLysFrYK0F1i21+vicD1aLdfGdfB7BHuXbpb0D+Kft1gJst9BdIMCuG72VLin5S0AAQFGYGu1tBbnO4WpQGoBy7263K8/WxEHqGdBtXyOAcR7hoK6r9hJBKh67/FCVP9+lHatz97pmHtMMjIulp5/8ru1l539bTMTrGA9BoqJNKxki+s0eMJtPrIERWy5asqrkrYfFOVf2OtC+nsYDTofvOBwOOBwOeHt7K1Z+jLHMqX/58qVS9uxnKnj9bTNFsr05XcFlnPMc0HV91b+66kN/W17QuisPaSCo8ilXOSQenIG8KqTme/aldaXWoJRphdP9ep8GDLlyXJ//CN0ihB95RktAK9B71Hq37/1IudcColtlV6WTL3r4veTjVhtcAwEODtvtHl3Xr157yUrm+LnnHoKA6PO0UAMctgCT1Sv3WLK2X+3Yu6/86/x27boYz71F157LYyobrPzWP1X4OtY3mw32+3157i+2dwADjh6lNWvhEhCg5ajuYG0oPa4MpgjJzpdooCBd9Mo03HJ1CmOZU7PlsaRWpyoc3ksXOQc0I+ZtmcdxRBcdehMcwmfpMbvuX38DKGBJwQHfofWlgra7Hl7qq9Z11grWemnZLQOzbK28+yRVyuqys2BI213bttVGGnioA22t/vad+g7bxraN2AaVp8K5KrOlfQ9/rwml1rLRVjlbCjDGBWRYavXBowr01mfdouh/LjDwUVrzYrTOA497AJSulbtlmfJ4a1qJvy8pRAt0W9euKboQIqwaurXtCZqt3G19tp6r8v4REHCtbK3v+UAKbIzt6y+9S2WDtrvtPzum7R/pHj6/CwRYK/JWsi7TS58k/tYtdWlRq/DVOSR9F4UrFTYtXq4w0PXstFjZ4IfDAXMIOGIGBISop0Drpla+rlHdbDalrFwzz3wAm82mxAbwvdM04XQ64Xm7x3a3P7M6lTG03WwbqLIlONHVFQoMOIe+3W4B5/D97VS5w+3nJYXFdf4EWES2uimN3qflHnqHTb/MQVrvyna7LWjXe1/aXC0Ju1xPPQYEe2rNd12HeQ7ZXdp2tyn4UPDHftFdD+20j/K8xjnw92Ga8Ho4VFMZ1ZSUGQt2fLRyYdz6O9Whfd3PoWz/I1ILDN1zr9ItAODnABzAuZWs77r0G6DcbCvra8rwlvX2a2WYYsQxjtW5a7Kfn5SLdoqA17SArn63gP5S+Vv1vjQGLrW5A9C5dZf8pWc6t2zFbacBbgEBtr73jOH7lgjOEc5ZZQ4Q6zrnkKJkzYBBWvueCovymQoaS9YpPsP7tAzMey/RrQ5w3PAloyVEwKWsfqdxAQcRETGkskVE+BjRO4cQHaY5IsLD9ylXvnMeIQJTdgmnCqR0wb1LsQHe5WVmIblW46SNDTjmas/lDz7CRY8wLR14wgjnkAPYOvS7AS56dK5HiElBu+jRux6IDuMk6Y5zmzovu8oh5Zd3YJ0CwpwGnSqSCOTlXxEht6ET4NMPGQDBl13oUqa6ej5aUxFTidmIfh18CmD0b02hxQhMAYjo4LuN3J945HCcMAfAd0d47zGHVJekLCOmOWAOM6Z5UbpTAOaQdpfrh+SaDHHhr35w8H0Ad58rYCvExDzeI8BjzhtB5UVMywANEdF5BDhwm9UQHdL6DiA6tp9DWrnsgJhGS7reofd9zn3g4OSatFlSGk8M33fZrc9g1XK+QS6ac3EZlzGvt3JYPNWMJo65XjwRQ0hLKEJEmGdMcMXaqboyxjR2Ylw+iqdBlWSATjNzCRlizN/j8ryYrmA5UxsBjqfOqHF06YL0jnjlens7izOHsnwNyLIuDfj0nLj0t32qiwE+zClq3VyQxKdb/V39rNpNvml7WOHvXFprFGN9r1WE568ADBgt45/3yXc+k79dDIDISbYXm6v+zMqNoBkOQ98jBE1/vdJXpU8jlmWrUc7pNu2Md0pyqC9Lz0MZU95JYGDkKq50Dz9NA7OZ4bCMTSmgFrW+c3kNnOMUyKLQYxmG57oWVWyP5evzd12iu0DA8TQnRYJl3TFTQybBmnYuKyqdyC5GBBFibBciHt1Gd7G80iY6U5iztZbzve/2GIahrEFPgj3i9f0NMcYqMU16SUDXObjOYwoB4wx03YBBXM/jPCOMM/b7ZBXDz3DosLUIPKS/+XyYw6OHdwC65dowR4wZnJze8u6BMWKz2WD4tkHnA3p3wBxnzFOAR5fm7wLwdhiLtUsLm56IMkeYlUOcE4h4fX0tiLLv+zL37rOi4i5znXfYbnfVNr2n06nMU9M1xT5irAI9CYo+9fcwDGfBj/qpVrtFtCEC8xgR0MP3u+S5mSZMc84YOB3gvcP7cUbX9Xh6ekorD7YbzNOMt8Nrfs8pRedvNpjmiHECdrsNhu02TQPNM7ZDir/wfRr83A63lTEwOIcp5TICdOljzjWwCUC9yVsaH1DhiUUULHlIIpzz2AwNK4/9avjMM4er00svjPa1UwUApKWoMUaMxyVjJQU9YlqCybaYxwnzmFZh+K5rPD/KR7tkc/67lxxSLjZPgdiqngUHKgljSrOsgLW+9LLlN0/T+Rr2BZ1UAMZaomnnyxkutp99rQyX4rCuPiMbAjfda873Jn+K9R6s/TkAbp7hxjwh4JBzPJx/khcLEADQOYf9dle9j8aUtY5DjGXrPipoVeIxBJwOKfaHOTrCHOC7Dtthk2TsOBXAgD7lHonl2Qn86rJn0rkrvl5x06J1D13E6XSeUt7cXb4tWDlKWS7ceoHuAgFJEdslehxUABBzf8TqGl2up4OQFr2tTL1m/dxVpC5unWtdyuiLi5YbAzHwruU6oTLcbrfw3ueAsSXYsFARMjfArIhSLn0O68upg2lc3NolKFEFSHb7apAdB4F1q3MTIhuPUJLMCIpU5axtQnc5iedswh8+30bj23Lb57N82s/W7U4X+zRN6KWM6d562VIISdmo27/rkrejQ48Yl6A9tpPGFYQQcMzTFdqeZ90p9VJ+Po+RWbfO1+gWt7G1+hcF89jIt2PA7vjWUkjaBmumxi0GyK1xRbZm1u3eLkC8eM21Y2vPXeOLtWsrNzUAj/PAwlunXnR83UvcyfyWtrC/FQy33M1WQdv7bYyS/a5kj6sMKx7e1meMZ0sRrfeCz+b0meoB732Ztl0jVfQqz+1xwBX9eKlu1443rnzgutvlwt2rAy4NYMsoJFqydhDres4a0dQBXKosaK3xj8qJ16hC5xy79x673a5kCzwej+U+59K8+GazKXMynKd/lKwS1TlexiowOJFz9LyWjKoR6Vx7rgBKI/5VcXJe2pmBoeXh85UIpghCdMUF4yRUGFHZ2kA9jeq1+wDYsujvYRhKnARzDegKDtLa2mWW27Y5gZW2bRWA6BwOL4ficWF8hLa1Lt3RZ6aYgvaukv/RqTXXu/bbHl8b57eQVZD33nvpvZeU+bU6XbtOeXyNl63BUj4B5G0bz55rjSJbDisLW+9sgXbwzfE8UHWtri0QoPkoWtde6g8dk/eQ5ZGWt0FjuCw/6v1qHLVkHnUFiTK51c5n4M7opiSHN8363HKs9d5fg+7zBGShbxlAO0ePk9ZQJK1Ru2xOlYzOJSsIsFa9Wso2wCrGWKYPdFkgO0KBxWJxfmwVhBUEakWwHroEh8qcm9FoQB2DGkk83gIGioStZa51ssrLllPLxbIQNfM9BCi2X+0z+RwlyysW/CnaVmFiA+zs8+0xi/rtYO58Sl9MftNgQgIgejQ06FTzPHyEV/4a5Jwr02aPWIh8xqPvfvTetbK0jj9i8V96hgYPA+duaZINbE1tnKfCtNp05xrfSfkt1zKBdIxyY+uefFp/e+/hXfdQP7c207nlOSTt65ZuWDvW4g+dDtDPlu6xK3Go5JlynjLteDwWmWvLaeugILB1PP2dyyC9fq2N+F4bh3UPrQG9W+i+JYIiQC8p/NYSKasg7Jwx7+OfZn1Ty5f3qPClQmot/2KH637zNvpa15PrIP4ItVCitpuCACorWphsE15v1+oSMWqku/YFy67z8FpnbWttL37yXipgxgJQ6VM40APBMtjd9/h5SfDbMtv2Yv+tta3+5nMUULKNdLWAfed+t0cw84kKilgGBZF2F8GP0F8D/dtNnVq0pjSVr+6ljwCAVlnWjt0KFu65X9tLx5Dl+fOVHbLvw53vdYw7uFCutWc4RzDSlmXXQNHa6oBL717KfQ7o7zUeW+9pgQD7qbJcLX3KUU41Hg6HKgkZQX/Lq2D5tg0CNOD9fPrqEu9/FBxf85Jdoof2DrjWcbYyVA62UXQQtSxICl99p1qCOp/D43wXlT6FPhPD0LKzLmx1f1vU9wjZIBINtFOlSQvbuTRFcDqdsN1u8fT0VMquTO2cK2l4d7tdpaReX18BoPKgXCqf9gvrfTqdSjvq/BfzHChI0LK1BNE1VG0H39vb29n1ep8OFAUN8zzjcDhUdZ+mqUwxEGxtNpsyzbDEDrgsaeuBqjxGIKF7QfCZP4dS+2vQLRbe2vFfypr/yL23KvFWubXfWwJcibxuDRjeQ16xSvDWrH/22DXhfqneMQLjeAC3t11739pxJlnj+ZbybukCNXTscSvPb9EpFqxceiffq/KS/cDl2d77yhNKmbem7K2X0cohBQAWNF0bJwqQPmLNf2RM3QcCwuUkDEB78NiISt5zCQRYVxL/2ClqORME6HW62yCVAs/ZAB+rEOkeaimye0kDAfmbQkEt6mmayhr7/X6P/X6PcRxzJr/FM0D3FXekU6DQamOSrQefSbJr4JXoEbCBfFYYcnpCLSXbr9bTwmPTNJX9EyxAsC56a60Di6uPZVLX3+l0qs4zDqMo+WEpN5+rZdUIaX4qKP0IfZS/HlHGbKNbFGfr2NkKnDvpI8Juja7VpcUzvO6euihfW0+APn9NwV0qYzoGqMtfQfot9US+nUsvp2mEbe5by7Lfp5VYlu/XZJqSyhfbDirzW6BAy7NW30vX2UypVP4q43WaWac+qVuAdoyHlT/6V6dYrstrwZw1iC/xyS9N9+UJyI2lFbDfLyFo6/K1+fwpeBkN3/d9SezD82r5UpADtYVNIcfrde5aURfLoSmFWVbgg+gqK00qHHWv87mq5HQFwDRNeHt7K6lzNSZAAQ/bgkrv7e0N3nt8+fLl4XJrzAWnUXSaghY320kFgHpegHbEb0sIW5CnZAeaHTwkKiaN3B+GoQixGJfNfdj/vI5tW3InyPbUChpUYD2aOOs/CrVAAHC7RX1rpHzr+R8BAZdWbtjv9hobnAxcC6xbyFqV1ujQ6+wfYpqXPytTvdofiBEr4hMMEnDmHtdcr7TkmEh8+xjYe3t7w+FwOFPY1gtik9uwrZ+enppgyAKplhJc0yOX+pf30VOqcglAFb8EJJBz7b1rir997fo0cuu5StardC99xHt9lxRTZQa00XXr2BpatoEQRGEUsJoHXi0vKr4QQpmP1Ux4ZEwdiCrYdb8BAGdz2xqx/0inqLfCzufb+XoqL7vtMK1XuzUvz1N5sbz8uyci11q/2tb8znLyuRrDoGDL3qvv0O8tq+YSAl5z09nr2b+M2KeS1z+We0kekgbONM4pX4Cr4xH4Hs0foLyriuAR+mugfn33NYW/Vj6VAY+899HVFKqE9XmXfv9c1AKjli/Xr1mblxeZCJwFCa4UJN0ZY51YSOtdHbvNC9G6RqdJrfLXT44PvZYZPgE0FT2vt+eWKjw25UQDhkaL8pt69DiVTANqTXa1+rpVrnQ/zu5vUeu4GqeP0KPtBdwJAqhYbYPQgltzm9CSpfCwrmdrAeq9tN5Op1M1x0Q3uY0FoFLVd8WYYgSoDGx5Q1gi8C3QeIS0M3X1g/e+SoPMY+rh0DLpnByBggbKqYJ2zuHr169nz9Y2VWpF1zvn8PT0VMpDMEIQpfXglASTCRFcESRoeS3PWCHAfmUyjxbqtqhefzM+gteTDzSGgYKBZVfe6Ye0dTTv1/ZVhK7vVsDw6JTAmtX5a5AF4ErXlIadSvq1qNVetygzyyv33Mvj7HOdImoJXg1oLXLQL3JorWzXyvDIfTECw+DRdY+9V1Nz87ydzmvFPaiRos9uWfwkHeeUHWvK8tox3U6csh1YDAVOXXIZuXol7DMvAQBblxDSZmS3Kn/7rGtxXJfoUc8c8OBWwqq0rQJvkVZOlZg+j5/6HaitamUyRaItZcf7qMx1Jy7bqSwPr9GYgEfJus5YJx00rbLwnLaXzlWxvKy/9XYoY16ynlWgsQwEKRqsp0pd/1QIanIf+3z1wpBUOOi0jgUmrbK3QIAKXZI+qxXYo9d3XQ9NqKJ9Z5W//bxU5mv01/QEXGrne8bzI/SROIpHvRc8p+fvARBr1qqd/rLAwF5vn22vXbMyzyi5Di6ScyzjY++1spq/9ZMyTdtJZcs1ssaf3r+m8C8pU5U7rfrwU6+z9bHvWgMAQC2PQqi3Ib9U19bzPiIPPnLvh7YStpXSeXZ7vOVetwpLryNy1k4ClshPoJ6Xo4Vt58sZGPb9+/eSSpdR4iwnU+Yej0cAC5Jc28LzGsUY8eOPP5b1/Hwmg/lCCCUhkc5Da6pfYNnt0LqnufKB/UELmufptlblp+3snDsL7uI5ggC2vWYhtNavHUyXgJMKCXpHOO3C5EAWIFnBe+nZlr9YFuVJ+5vfd0+p/XTDI5ICI5tE6P/PZHn7FitV6VHg8+h9pI9Y02vbq95yv7q9+bt1rXoAAfLhjGpPvdh2/DfLHVGWr168PjamEyJwOp3HBLTedUu7qkxRRcvYGOsxuBQzc03p6Ti+55P3aiC4el95niuKdFr40thuWe32Pen4apWugoDWNbfSR8bVQ3kCWi+nErFW6CWUTGoJ/aVRz3NGq/VHshHcLev6kjJpIf2PELMVWiSpCojM2Cq3lov1VcZThN4SRIqk+WnjOez0g7aDRbR8h+Y7WLN49JhV0Kwz+1H/1qKJW+2jn5Zf1JPB6QrnXOU54nl6ABQksJ1b7ab9uFbve+jR+z+qTD9Ca+P416BrIPPSdR8BEPbcrUoMACICdMeEdOp20LXmdanL037mHALC/Fi9bT9bz5oaXK1nXApWu8b3CqLu/bTycc1Vbj2XRSagrvuazlKdlPgBgEnXu1b/WzwFvxbdBQI4Pw+0laaiKj1OS8rODWt0KVC7cshotIb5PHbwfr8vZXEuRfjHGPH+/l6Vixbz8/MzhmHAdrutgASQtqnlchge/7nAANvs69ev2G63+OGHHzDPabMflo3zU8wPwDZhXXRuTpWlBlHaWAEFHFSA7Bda8+oNYEwEy0VPAIN76JHgPNpBtsBVxamBj1b5twAevx+Px+KJsXyl9dAAPx7TeX5OkQzDUPIucJXA8XjEOI4lergkD/EdfOcLb3A+kZ4Krrqgp4R9+pF5ONbzI/d+xGpYS3D0iHK4h36JeIJbAYBNfnPPMyw/tr7b65bvEXCt99pgsvPgsvScsHL8lr7q4PBYMCXHWXrOOQi2oMDKds7F1+U5V6wtY+Xt7a0J/NeMKlsfjg/nHPb7PQCUXDG68omyl8+z+T/ss60xWgdtd1UKYlu/td+kRz3Pl555C90dE6AKkkKZykjdvLouW0GAPuNSQ+t3VQqqCKyyJpKz9wPnmxhZRlHPglqvjxIHkCoLMo2mLbaeEwVSWgf1fhCBWyveto8FVHa6RoEQmV/BCcvP56r1q/UgSGEwngWCLau+5fmwyt/yiAWSVpDoNIYFlPxt20bLoJaLXWuspPWxHoEWgGmR9ZJcu9Z+sp9bZbJ10fOtul6iS9e03rFWbttntv8VRLYUREsO6DX2XS0FwnPWBazXWAOBfKPpxm2/t9qg/oyISDueOufSLnvOcZPkVC+g2qo4vzw9Q935fBefr+/Nz1HE4J0H3LrXosUHrbaxbdk6Z8/b+64puGtAq8WLl0Aq++6SErbjguctH61R/a42OL7l2EdAvT6j9f0a3b1EkJYfLaqvX7/ihx9+wO9//3u8vb3h9fUV/+N//A/88Y9/LAKOu/Ppc6wg5XcqI1ZCs77N84ynp6eS9U2fQQ8BrUnOA2mqSF5HUgWox7g97q1CrkX7/b5s6QukNbchLFn9dDqA0aqn0wk//fRTse5ZZ7YJvRncB4Ht9v37d3jv8fz8XLweCkI2mw3e3t7Ke/gubgoUY8TLywuOxyP+8Ic/IISAH374oWQk3Gw2eH5+LnXm/Citd3prfvjhhyo+QckKCf3U8+pVIG9ocKECNfUm8BnqqdKYBvKEBinSGvbewUlfK5rX9yjqjzFtXkUPkvaVlkkBiPKresFasRX6bl2Kpd6O5+fnSkkxh0OMEbvdrtSDZdV32ayZrf5aI5bn6empZOzk2GK78506JUOLTHM3EJS9v7/jdDpht9tVCWoY7EpwSgWtUfiso67EsWCQ9/BZmkeE2TkBlBwdpO12i91uh+/fv+P9/X21TWy7aftN84Tj6YSu7zH0PXweg6xjWQYcI0Jclv51BKldV45ZBav8GUJADGmnAfJg5xwcQtUubFc1UjSo2BpSJHvskvyzYLh1/aX7dRzba/l9zfPcm/bVPDPAAvCpI9Rg1etadSCRd+qpkPaYubXdbN/eQ9bLdY+37e6YAJK6Q3Qtu6J+G41pkZ4CgEvKVskKRpKCAlvmNeVj33kJ3Vpk2GJKW7/W8jFrjbfKQQGl81NU6nbZG3ButdqIdR6jpU6lcTweSzt+//69xDDo/Wvz9RZtry2ZuqXtAVQKUK21llXPclkQeQtgWxtkLWuAny3rjterN0SVvAoqLa/e35pG0XbVMmhciGbL1PZqRTdr/wN1TIfmPbi1nVgXHfsWBPA5mmQJqAUTFTb7VINEyZ8WLNkpJgVXWiYFYNqu9tq18a39d49FtUbOpc3XvPcFbMZkuMv7kD0DgPO1/AxZsbvyvPINzqV7U108nAuIMcA5D8QI7zo4nEfrq0dM66mgaU3JfvT3Wpve0tZ2DLVkvvKI3mfvvbd8l2jho7tvbT7nHvooj94FAnrZeUw3UlELRV3DrFBLQVilqpVR5W6Zl9sA2y14ab3zN++187atBtPr9bcKCJbLMl/rGOusCpvJK9S9blG5MqkGFdKC5aoGCjGdZgAWRLvb7YrlyPfwGSzv+/s7/vznP+P79+84Ho/FyvnHf/zH4sHouq4S5GzPGJfcBNxQKIRQPD6XgMAlEKBrey0IID9ZEGCF2COUhOgC0JT/WkJQQe37+3u1gkP5lf1IPgGWscAlr8zDoNHUCqzWAJZVapxy4zjks/hsTUoFAH/+85+bW5e2AI89r8CD/ECZoH3HOivfkA6HA15fX894nG30+vpa+FfLbQPGgHozMlXuBL1sG3r86BVhPzBdNYCSqlvbmfLl0SlC7zs8PT1rK54Fxyqo0X6Pcdn3xLnktUrKv85FYPuvyMbo4LBk0dOtyrkiKoQlHwhllsbQ/Np0bQxeA2qWr9fkUetYCyDcUfLVZ9vy/Bzg0r5jzbC8RndvIKRMC6QG54BWBlRhaBE3j7Ws77UKWKFnwYMCAkX0rQFyCQi0ynoJNbY6WK9bE6L2+hZSVetYQZNa4LxO255uWBsla+tFV78KFLp4tW7qCVDLXPuFCmGNGdc+W+3W+m2pBSAfHVjzeLq7rAoc9U/dg9on1kujOR/WhLkCTe0jntcpJdvPnLJThcJ+YrlbUd23gIAzRdMYO7at1LIkb+ozWDcqI/WgOOfOrud7rAdA29N64lpgXdtX5Ya9p1W3W0kVevoDyvbCpo1ayt0et7EuLXlVxu4YEGI4W2psp93WrOqfi3S82vLqNfa7lXuXPj9SNtJH6/8oj/wc9KuAgBACZtQWE63yw+FQ5Wpfy5Cl1FJiPG7fy0GtKF4ZhVYDlZoKTitQ7TyyDTbj+xVRrqFQvc9eyzLY+/WT33XOTp9tBbWdbwaWeVMKfrr5mUaYeQ/0j7m9NSOh9x5fv36F975YCLSAdE8BWhT6Xq3rR0DANQtUf1+6/laKMeLt8H5WfuULzeVgBTD5l54TdbcD7akaKgX2j62HKngthwVZ6oGz7cDVHiwrvTtUomp5X2rPVvvadNbqZbC8rzxMTyEtbXpD1JvIHA3Mq2GP23FvQQD7w8ofygTr4rbegxbfad89Ql3foR+WLcJ1WsQq9xbYsF6dW0AAAMQQ8fL2gmlctizXmBiVO5Z+KTBwK1k5cc0gs59rSvCXVNKqOyytlVvpUU8T0E7Bfyvdt4HQOAJ5oGsaWeeWrWfVLUoFQuHZsjj4fY3pyKg6h9V6pgbzAagC59Ra0tgFkq42ABbU2nKXknTwtYSDDcRZs5Za7nO9TgUTXXMa7KhtQkHHOvLeaZpKXais2IZqLen72JZqudokQbcIimsIXq+z7lG1wBTMqUBXZfko2UyLamGz3dUCawFHK9y1H/VT66a8qPWx/KnK1PIPn2OnvggCLWjQ85f679I5pvDWuukqGCocteaVL4F6vl77WadNyKe2XJaHlD/02do/+qcWsY595XmSgrZHyfm0zU8EAJd5gaDCpSWqrpQBCLPJed+z3w3vNbwcIdZWfd/38G5R/uqBqu4zXgH1/v1SZBW8klViFiQr77T44RJdk1uPKuNb3v1LUsv4uoXuAgGcm+IcowaZUSioslBr9FKHXzpO5tTncr26db3yOio+oM5FoBaHdrTO3aswoTUM1NZhSxlYVE5r3FrtLQtYB6Vew2eyvHTzq2WiStoCIgUFjKWgsH5+fi75EVQJ8h1sB50u0D5o9Z0ORq3LJSCgz2gpQiugrfCy0xSP0HazAZyrrE79vATovn37VrZ9Jr9rn+tcrO1n5UneS8CmQXckBdhUvKRhGMrW0hyTHK/kCY254LMtSLn2CSxz6rZcupOjBTvc5ZJTUGwb8oEV6upVpGzRcat8oTxJGaBTIPoHnKcxt7vLaZurnHsUCAREzEibVBUg4Jfxa8fU8XhEmAPGOdX7eb87kx9nQFCAawyhgIFhs0HnFjBPauUeUQ9rK8blo3Sr4bD2XpXzax4A4HxfFHudvf9RC/q83I/LoI/QmhF5K903HSANZq1nWiMsgFo+Ngp5zWXTOn6p49euaXX42jWtZ9jfa+VpWbQki8qsALl0j7VE1ZLSYCkOYgIAVSpUElpWFZS8lsE/LUXXAjlF0KwMQnWr23pdUixrfWP7Q8Fk69i9RItKrUn7DrXW7b1UrlTgBI58jio8ggHeS/Cs+TX0WAsI2b5Ya6dW3yjQsv1g/8grLRe1BSgK3KzHT4ltQr48nU5lOnG73VZLB/l83SgMqL0yqqxa4FP5Veui9+gfy6hj1XraHiEHANHlbw5wHilLgAdS7D64y2CM6bgr6wHyPvWUN07kDmQ1Q0gb2ISwfI8x4HA8wGFZpq3eGi6HJO/xPHdwbQH+m+t8RbbbvrLU8gDx8xqPrz1zrZxWXz1KLbnGMtl6r7XPR8jqnFvp7pgAHcgAKqayFrEO6FsK3jp+C4K7puwv3avlvAQy7G8LBPR7q24tK0LPW8GsAIDv5MBlG+t3nmeWPGsZW+VBa5DClp8aUa3WHcugAp/PtUrT1k1/XwICtm1vpRZYu+de7/zZsiw9v+amB1BWcRyPR0zTVFYLsH0Yj8GcC7rKgcJXwZuCAiUFYzrHfq0NLM/beBh+6vOvzT0r0GE5WqmsWyCPSphptQlCNacGY1GYyyLGWPJPaFQ/sL7UTevHsnKVgCo3vZfP0+dYAPYIuYis2JHTAwW4/ItAAFweWL7ncxEp7a9PEwqpHFluYRkr80weVdAacXh7S7kDYqzGMgHr6+triSOil0Yz6P1c1JKNl8a4Go4tRX9JZrfGge3Da3LoMfrrTQV8hO5LG5zn4YF6JzjtgBBCNUDt0h6lVgesKQ9VgvM8l7S1fD/ny/lu2+l6LX+T7Fw379E0wq0ytQQqyU47cADagUArg0CJyoGWoI2zYJuyPura1RgMlo9tp5sX0dpxzlUC0lqaLeWvLkRtN1rDOii1fxUktQSAtn9rOsAK+2tC5B4axxPgFs8K24DBczZ4j+8HUPE6gGLR2rYg/1MRaTIrVb7KvyQNTNSpK9sG6iVaS0FKviF/ah9fEro6njgdp94jLnds8TiVC5cuKi8r32nbs5+ZjIjX8HoGDnJaUKPv7XQf79UYBZLOfStAJvG3XYFxF7naC+eiQ4j11Jefa9BOHlHZpu3Pa7SOdmx4nwJCYwjV1to63r9+/VrAKGULN1n7uWnNGm4ZWRZwXzIG7aeOY8u3FvBa4P8RsJfKDeCGfSF+Ltmlz7J6+Fa6L0+AzO23XKMsCAtDprKDktdbxdA6ByxbWOrc1ZoVpIKwBQK0rKSW1cP62ndcsqwsI7YsZmstc/5U8wLoc60SBBZA0cqayHa3wmwYBjw/P5e2s2jaBlqq10AFoQ2WbLWbttkaALDKpzUYVSmsBW9anruXYowYTZIbPt/OFeu71aJSjwyVDT816Y3ez3FheVWFE6/VFRn8bNWd/d8ShDpGrLKzYFytZK2vlk/zEigIsHP1+uzdblc9w0a9a3tQ0Wn2QLYbp1fWQIAde9rXrYBIO12pfKBTQY8GyqVEQTmnR4xwcfGg8B12DJH/OGVHWcB20qkrx62CXR0gGWOE2wyIYRnfOsZsjIQCs77vq/Tvj1JL0a+BAZLKMr3uFgAQ4xLXZMcT28B6grQcH5EltryXjv2cIKD1zHuef/dWwhxEmuRElZUOGB5fAwwqZPhpBZKCDg3msYOZ7+eAVo+FbRA7b6lMqVMeLRej/raKVC1v60JWBWifp3ETallakGEVIq05lpPCcL/fF4HHP1qotvzqGbArBVg2Faza1irkVcHYdm31r73GkmVobUN77NJzrlEq0/qynmsCSPlFFSw/rRVHwa/BdS3Qqu+iQFMese3fUlI6BUVe5PU2Kl7LwfevebqUp7WOBOA2aZT2nXqzdDyQT1XJqzxhiuvdblcsXDu9wmtboNK2qR6zfKqkgO5RwZ128suAHREMDHRwJc4qzDNcCHAugQbnXEr5693iZXYogYUaYsBzdb0AOIf9/gle+oF9pbzXmlIEzqdKfi3S/lw7r2OsdS+/23Gp3iALwvUZj1Bk55wd/3UAwK8CAnTQUsErmufLW644K0xagqcFCkgUcmTMFgjgdapM19B7C31aa2ktGrilHFQw8jjLY+9tkaJ7CkoNDrPlagEK9oeCAA5qupLt4LfTDnbFhQUzKmBbc7FWaNwKBCxv8Zn3DMhHB6/3vhq7+hzbv9bzYxWcPsNeR2XinKvc8S0QoPeRFIR576scD+xvklrHwJJb3PLQpTZbcylaAK0ClV4CCyZ4rQIBBTHv7+9lfDMwTaeHmCeAddflrS0ZYwEZUO/SZtuZn602aYGHeyjGgFm383V5eV9MiYIDEwfFXC7yUv6eogGQf+fP/NuWark2/R42Gwx5qk49JDpeLRCj3Nhutx+aFrCK9Z42tH1qn3Pp3Joe0bGgY1HpY8BHUVlNtwKBxwFIrXd/sekAdSVTkGiwjbrrbTBga95l7Y/XsHL6p9u4Wnd3jPVWwrrsRd+tn7Z+VeOItUKyAqFlwbG+tN4AlE19rJuWCVF0Tpjfuayv1Q7AgmYZec42/v79e9NKIiCYpgm73a64lTVA7cuXL/DeF7e/9Yy0lg61vCettm61vbabTTvLAa0gUcEey852fGQAxRhxPB2rd9m5Q2tp2n5QvmEZWB5umsN+Z7syudbT01M11aWf1vq07aeKV8/RUua8fQihRIHznv1+fwb4tF3Vq2WBmY0cZ53Ydl+/fq1iTjTRD70ADExTMMlljtzgKsYlUp/xOayD5RW2cQuw2mmJ1njVNtZrlQ8fpXGecDgcK/BDjwfbT8G29gOAKlBPx5g1khS0J1ARcYTHLGBQvbfWYFGjjs/8OelWIODcstW1LWMLgOtxAAUcK4AH6lUslDct/WKnAW+vny/TPpasDlmr96Nk9dI9gOvutMH6Z+eXrIBcs/4eAQH6Hs1UVyoi2dCsUCvP9B5rQ7nVgHaeu8Vwa6DC7nqn2ym3lKqNXKa7v7QDzkFAlDJQiOocos23r0KSwpHW4jUrSctrp374adfn3gMCLO/oAKYyUdL32n7ic2OqACy1LIMYAtD1zVUCzmU/rKstJyop55JbF8Lz6rLnO1SBzfOMIc9rx5iSvHQEASHtBlfaJPe2S5lmUoR5TFNyVZkAeLfMt5OnyvJdCuFc7n7oEUNyUcdw7t3SNmJbRqDiHS6vVG8SXfURQJBpJOcdOp9BwDxjmid06It1qwqSqy3gUjQ821MDkpVnWtNvLQDZkkVNPmnwU5Mc/4loxIOBj9a0veXTd4g4z5hqPURd1+W+b3vSYl5CGMO5x2qaJkSZMrR1D5ErFc5jQKZpwkhjzrn0DpWTjXaLbJLq2HrbtJ6lwLbwfxkH6TvH25k8jHlfE+8RwowYYhlP2r6XeObaSq70mvN6exdxaWqxUWPY1rpHeQOxNP8ZCLjW4EJ3gQBlVrXKGBTEgtBSZ8PdEllLxaifrEwE4PsOPguWcZ4QXVLqrGwK7grwfV4zH2tL0TuHzZBc5bo0rjScW9bSHrI3gRaPc2k9+MvLS1G2qoBUcbdcnywHLW5gsWy4/asCG+d9CibqO3RDn+b0HCOKk+WaNiV5gnM5fwNSUhLXeeye9otw8w6dyxafQ3pen9rxNI2IeQ5y8B7OoSQdYR+34ghaQZn8vhb/0RKiZ4q78/DewUVfljWRlUOMiGEuSsh1Hh4O3ZBXQsSQhQCVjQdCREDe7Gqa0Q85uj4LmOPhgDDP6J2H6ztsN5s0iH3OvX88pe1dQ87IJ8FVpd7OwSGiqwavK8ohsIpdB995bPsOmxixiwHe+XTeJTdiqjvQQYVa+eesvXahDuxTwOacwxRDmjvuOuy/PGMb9shFLpuBZdbIwsRaW+mYngNUoSaecV2HGAMOhyPmecJxGuHmCafTWO733qF3PaYYMJ6OGKcRM5DXyzv4LsVmvJ+OeD8dUzn7NAYAYAppzPuSkChvaS7juB96bE2ugRACoveI3qU/ANOkK4lSu4fI+fL0W6cd53kuAEU9eYDDMPTUj/kZJ6Rlekts0hxCWiAY09z/GIEwzQXQARGd80gb/8WiNMMc0nkfCxhKsszLveS4xIfeudRfzgOImMKMOQZgzlc5/ZT7WYn8LEQgAEDni7INWZfrvgfKfwU45zKEGBY+RpunLG+V49Mox2IGUT12uy0YG3GS5dBpTKZ7D+NYvS+VVz4BwLvEX7HLgZrZaARwGE8CQtIzn56eqjit799fE8jIz53nGZ3vsMuxLEu7EMwtv5dNoEpz5bKe68j0fAW6sxhzMj3pk44oHqY7nAp3gQAl61KzcQA2KOmSq6MFAKrrXWZyv6yN1eOJQev0sdZqDlKuNUBSXJxumVsiM6gr3ypGbQ+19PWcuqS0XTSnd3WeA14s0sSqCdnCOXR9Ki8tQm37wojZelTFru8HUIKUUp0CIuq8+GfATBGnKJ4WXUK2VTsV4ZR/+wQE+NRsgxbQ511t1WmMSBGP2UBL1vUMH+od+Wh1d75PWdVy+tYIIDqzLLIDnD/fH8E55BXgUq9GXSl8OxmgtOCW6i+Cfa09lb/VXjmzTAigXGqEru+r688s4ubb1knv9wBCoLcqAUnnHMZpCTBzGdoUYabWWwb0yfqcxavkFwmZ2893i1ePFmHp9wyeWf85hNS+BFr5WbzHZeAbc2qemZ5E+GL5hvwc5z1c/q2WOltdxyZ5xjkHz3elF2XPSyjySLVx6Y9I6zmWNkven9QO0UeydioHFp5zeYyQn3i/PLiURXnZyk5gsSYjlvpFxNJ3pCIfqjotVmp5hpEfLZ4tfWcMjTF7hcodLgG3aZ7RSf2tLmq+K+OdJS5j6YN5nhevntxH3uK4CjFgktUd0zQh+oh5Zepp8bKgAPEWGDun3PIxFLChf2Xqq0+yy8eUW+Ke6atfP/Tzkz7pkz7pfxNqgq8LwPeTPuk/Gt3kCSBTT9NU0A/ZnBayBgJaK8NmE9NrWqgpH8jvXqyGco1FObHe9EXdJ/MciiuGgXFjazoAKKkzWV4G7HA6gFa7rv3mfG4Qq5kWNFAn7AFQ5tg4dTDmZ5YyFwtu2a3NtiOvZXnHaSoekTX3e0swNYVVTBn09PwlBN/yhrTo6vHiFq/dX/ZajRhXSyqIJ4Au2BgjYu5HbceQ24nBkM5HBO+TtZc9AXOYS//P8wwfQrKCsveglLMx+7amAhYrJv8WT8C97bVmRbV+t/r5Ul/dQno/PSbjmNqYqX11qZmdv+eUnM7PcozyeYuLN7nwtR7sF81bYb2TdidFG8jI8VLGoimvyrZFntSrLPhelmkJ8ovJS2SC8Pi+VnyCei/1nlbgZ+vdNh7gUt9d+lwrT3pu221NN3fxkMSUsVCftbjo7/cEMD6KPAagmtZl397kCaiO17UIQaxr8X7aHByaq6Z4fmIOEjbt6b2HD+2VQLb/LdVTAcnzEVqeAAc4o4PWnmnpJhDw8vICAPi//vN/vuXyT/qkT/qkT/qkT/or08vLC37zm99cvMbFG6BCCAF/+MMf8PXr1w9ZD5/0SZ/0SZ/0SZ/0y1KMES8vL/inf/qnq/EBN4GAT/qkT/qkT/qkT/rfjz4DAz/pkz7pkz7pk/5G6RMEfNInfdInfdIn/Y3SJwj4pE/6pE/6pE/6G6VPEPBJn/RJn/RJn/Q3Sp8g4JM+6ZM+6ZM+6W+UPkHAJ33SJ33SJ33S3yh9goBP+qRP+qRP+qS/UfpfuJii1KRu6RQAAAAASUVORK5CYII=",
+ "text/plain": [
+ "<Figure size 640x480 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import torch.quantization\n",
+ "tests_image = [\"dog.png\", \"dog2.jpg\", \"cat.jpg\", \"bird.jpg\", \"monkey.jpg\", \"whale.jpg\", \"crocodile.jpg\"] \n",
+ "\n",
+ "\n",
+ "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n",
+ "print_size_of_model(quantized_model, \"int8\")\n",
+ "\n",
+ "for image_name in tests_image:\n",
+ " out = quantized_model(transform_data(image_name))\n",
+ " # Find the predicted class\n",
+ " print(\"Predicted class is: {}\".format(labels[out.argmax()]))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The quantized model is able to well classify few images selected on the Internet, and it did the same mistake for the whale. The size of the quantized model is 94 Mo, where the initial model was about 102 Mo, so we saved 8 Mo (6% of the initial model size), that's interesting !"
+ ]
+ },
{
"cell_type": "markdown",
- "id": "5d57da4b",
"metadata": {},
"source": [
"## Exercise 4: Transfer Learning\n",
" \n",
" \n",
- "For this work, we will use a pre-trained model (ResNet18) as a descriptor extractor and will refine the classification by training only the last fully connected layer of the network. Thus, the output layer of the pre-trained network will be replaced by a layer adapted to the new classes to be recognized which will be in our case ants and bees.\n",
- "Download and unzip in your working directory the dataset available at the address :\n",
- " \n",
- "https://download.pytorch.org/tutorial/hymenoptera_data.zip\n",
- " \n",
- "Execute the following code in order to display some images of the dataset."
+ "For this work, we will use a pre-trained model (ResNet18) as a descriptor extractor and will refine the classification by training only the last fully connected layer of the network. Thus, the output layer of the pre-trained network will be replaced by a layer adapted to the new classes to be recognized which will be in our case ants and bees."
]
},
{
"cell_type": "code",
- "execution_count": null,
- "id": "be2d31f5",
+ "execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
@@ -935,21 +918,29 @@
" transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
" ]\n",
" ),\n",
+ " \"test\": transforms.Compose(\n",
+ " [\n",
+ " transforms.Resize(256),\n",
+ " transforms.CenterCrop(224),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
+ " ]\n",
+ " ),\n",
"}\n",
"\n",
"data_dir = \"hymenoptera_data\"\n",
"# Create train and validation datasets and loaders\n",
"image_datasets = {\n",
" x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n",
- " for x in [\"train\", \"val\"]\n",
+ " for x in [\"train\", \"val\", \"test\"]\n",
"}\n",
"dataloaders = {\n",
" x: torch.utils.data.DataLoader(\n",
" image_datasets[x], batch_size=4, shuffle=True, num_workers=0\n",
" )\n",
- " for x in [\"train\", \"val\"]\n",
+ " for x in [\"train\", \"val\", \"test\"]\n",
"}\n",
- "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\"]}\n",
+ "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\", \"test\"]}\n",
"class_names = image_datasets[\"train\"].classes\n",
"device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
"\n",
@@ -977,13 +968,12 @@
"# Make a grid from batch\n",
"out = torchvision.utils.make_grid(inputs)\n",
"\n",
- "imshow(out, title=[class_names[x] for x in classes])\n",
+ "#imshow(out, title=[class_names[x] for x in classes])\n",
"\n"
]
},
{
"cell_type": "markdown",
- "id": "bbd48800",
"metadata": {},
"source": [
"Now, execute the following code which uses a pre-trained model ResNet18 having replaced the output layer for the ants/bees classification and performs the model training by only changing the weights of this output layer."
@@ -991,10 +981,90 @@
},
{
"cell_type": "code",
- "execution_count": null,
- "id": "572d824c",
+ "execution_count": 15,
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "c:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet18_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet18_Weights.DEFAULT` to get the most up-to-date weights.\n",
+ " warnings.warn(msg)\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 1/10\n",
+ "----------\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "c:\\Users\\Malo\\anaconda3\\Lib\\site-packages\\torch\\optim\\lr_scheduler.py:136: UserWarning: Detected call of `lr_scheduler.step()` before `optimizer.step()`. In PyTorch 1.1.0 and later, you should call them in the opposite order: `optimizer.step()` before `lr_scheduler.step()`. Failure to do this will result in PyTorch skipping the first value of the learning rate schedule. See more details at https://pytorch.org/docs/stable/optim.html#how-to-adjust-learning-rate\n",
+ " warnings.warn(\"Detected call of `lr_scheduler.step()` before `optimizer.step()`. \"\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "train Loss: 0.6560 Acc: 0.6033\n",
+ "val Loss: 0.4741 Acc: 0.8627\n",
+ "\n",
+ "Epoch 2/10\n",
+ "----------\n",
+ "train Loss: 0.5999 Acc: 0.6736\n",
+ "val Loss: 0.3602 Acc: 0.9150\n",
+ "\n",
+ "Epoch 3/10\n",
+ "----------\n",
+ "train Loss: 0.5082 Acc: 0.7438\n",
+ "val Loss: 0.2580 Acc: 0.9346\n",
+ "\n",
+ "Epoch 4/10\n",
+ "----------\n",
+ "train Loss: 0.4097 Acc: 0.8058\n",
+ "val Loss: 0.2073 Acc: 0.9477\n",
+ "\n",
+ "Epoch 5/10\n",
+ "----------\n",
+ "train Loss: 0.4419 Acc: 0.7975\n",
+ "val Loss: 0.2074 Acc: 0.9412\n",
+ "\n",
+ "Epoch 6/10\n",
+ "----------\n",
+ "train Loss: 0.5443 Acc: 0.7231\n",
+ "val Loss: 0.2224 Acc: 0.9412\n",
+ "\n",
+ "Epoch 7/10\n",
+ "----------\n",
+ "train Loss: 0.4913 Acc: 0.7810\n",
+ "val Loss: 0.2901 Acc: 0.8954\n",
+ "\n",
+ "Epoch 8/10\n",
+ "----------\n",
+ "train Loss: 0.3980 Acc: 0.8223\n",
+ "val Loss: 0.1996 Acc: 0.9542\n",
+ "\n",
+ "Epoch 9/10\n",
+ "----------\n",
+ "train Loss: 0.3834 Acc: 0.8017\n",
+ "val Loss: 0.2097 Acc: 0.9477\n",
+ "\n",
+ "Epoch 10/10\n",
+ "----------\n",
+ "train Loss: 0.4306 Acc: 0.7975\n",
+ "val Loss: 0.1897 Acc: 0.9608\n",
+ "\n",
+ "Training complete in 10m 25s\n",
+ "Best val Acc: 0.960784\n"
+ ]
+ }
+ ],
"source": [
"import copy\n",
"import os\n",
@@ -1161,8 +1231,15 @@
"\n",
"# Replace the final fully connected layer\n",
"# Parameters of newly constructed modules have requires_grad=True by default\n",
+ "# Change of the 2 last layers of the model\n",
"num_ftrs = model.fc.in_features\n",
- "model.fc = nn.Linear(num_ftrs, 2)\n",
+ "final_layers = [\n",
+ " nn.Linear(num_ftrs, 256),\n",
+ " nn.ReLU(),\n",
+ " nn.Dropout(),\n",
+ " nn.Linear(256, 2)\n",
+ "]\n",
+ "model.fc = nn.Sequential(*final_layers)\n",
"# Send the model to the GPU\n",
"model = model.to(device)\n",
"# Set the loss function\n",
@@ -1178,7 +1255,6 @@
},
{
"cell_type": "markdown",
- "id": "bbd48800",
"metadata": {},
"source": [
"Experiments:\n",
@@ -1193,29 +1269,78 @@
]
},
{
- "cell_type": "markdown",
- "id": "04a263f0",
+ "cell_type": "code",
+ "execution_count": 16,
"metadata": {},
+ "outputs": [
+ {
+ "ename": "KeyError",
+ "evalue": "'test'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)",
+ "\u001b[1;32mc:\\Users\\Malo\\Documents\\Python Scripts\\td2-deeplearning\\exercice 1 and 2.ipynb Cell 36\u001b[0m line \u001b[0;36m1\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X52sZmlsZQ%3D%3D?line=13'>14</a>\u001b[0m accuracy \u001b[39m=\u001b[39m count \u001b[39m/\u001b[39m dataset_sizes[\u001b[39m\"\u001b[39m\u001b[39mtest\u001b[39m\u001b[39m\"\u001b[39m]\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X52sZmlsZQ%3D%3D?line=15'>16</a>\u001b[0m \u001b[39mreturn\u001b[39;00m accuracy\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X52sZmlsZQ%3D%3D?line=17'>18</a>\u001b[0m accuracy \u001b[39m=\u001b[39m eval_model(model)\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X52sZmlsZQ%3D%3D?line=18'>19</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mModel Accuracy : \u001b[39m\u001b[39m\"\u001b[39m, accuracy)\n",
+ "\u001b[1;32mc:\\Users\\Malo\\Documents\\Python Scripts\\td2-deeplearning\\exercice 1 and 2.ipynb Cell 36\u001b[0m line \u001b[0;36m7\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X52sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m model\u001b[39m.\u001b[39meval() \u001b[39m# Set model to evaluating mode\u001b[39;00m\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X52sZmlsZQ%3D%3D?line=5'>6</a>\u001b[0m count \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m \u001b[39m# Count the correct answer of the model for the classification\u001b[39;00m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X52sZmlsZQ%3D%3D?line=6'>7</a>\u001b[0m \u001b[39mfor\u001b[39;00m inputs,labels \u001b[39min\u001b[39;00m dataloaders[\u001b[39m\"\u001b[39m\u001b[39mtest\u001b[39m\u001b[39m\"\u001b[39m]:\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X52sZmlsZQ%3D%3D?line=7'>8</a>\u001b[0m inputs \u001b[39m=\u001b[39m inputs\u001b[39m.\u001b[39mto(device)\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X52sZmlsZQ%3D%3D?line=8'>9</a>\u001b[0m labels \u001b[39m=\u001b[39m labels\u001b[39m.\u001b[39mto(device)\n",
+ "\u001b[1;31mKeyError\u001b[0m: 'test'"
+ ]
+ }
+ ],
"source": [
- "## Optional\n",
+ "def eval_model(model):\n",
+ " \"\"\"\n",
+ " Evaluate the model with the computing of the accuracy on the testset images.\n",
+ " \"\"\"\n",
+ " model.eval() # Set model to evaluating mode\n",
+ " count = 0 # Count the correct answer of the model for the classification\n",
+ " for inputs,labels in dataloaders[\"test\"]:\n",
+ " inputs = inputs.to(device)\n",
+ " labels = labels.to(device)\n",
+ " outputs = model(inputs)\n",
+ " _, prediction = torch.max(outputs, 1)\n",
+ " count += torch.sum(prediction == labels.data)\n",
" \n",
- "Try this at home!! \n",
- "\n",
+ " accuracy = count / dataset_sizes[\"test\"]\n",
"\n",
- "Pytorch offers a framework to export a given CNN to your selfphone (either android or iOS). Have a look at the tutorial https://pytorch.org/mobile/home/\n",
+ " return accuracy\n",
"\n",
- "The Exercise consists in deploying the CNN of Exercise 4 in your phone and then test it on live.\n",
+ "accuracy = eval_model(model)\n",
+ "print(\"Model Accuracy : \", accuracy)\n",
"\n"
]
},
{
- "cell_type": "markdown",
- "id": "fe954ce4",
+ "cell_type": "code",
+ "execution_count": 17,
"metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "model: int8 \t Size (KB): 45304.25\n",
+ "model: int8 \t Size (KB): 44911.014\n"
+ ]
+ },
+ {
+ "ename": "KeyError",
+ "evalue": "'test'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)",
+ "\u001b[1;32mc:\\Users\\Malo\\Documents\\Python Scripts\\td2-deeplearning\\exercice 1 and 2.ipynb Cell 37\u001b[0m line \u001b[0;36m5\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X53sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m print_size_of_model(model, \u001b[39m\"\u001b[39m\u001b[39mint8\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X53sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m print_size_of_model(quantized_model, \u001b[39m\"\u001b[39m\u001b[39mint8\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X53sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m eval_model(quantized_model)\n",
+ "\u001b[1;32mc:\\Users\\Malo\\Documents\\Python Scripts\\td2-deeplearning\\exercice 1 and 2.ipynb Cell 37\u001b[0m line \u001b[0;36m7\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X53sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m model\u001b[39m.\u001b[39meval() \u001b[39m# Set model to evaluating mode\u001b[39;00m\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X53sZmlsZQ%3D%3D?line=5'>6</a>\u001b[0m count \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m \u001b[39m# Count the correct answer of the model for the classification\u001b[39;00m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X53sZmlsZQ%3D%3D?line=6'>7</a>\u001b[0m \u001b[39mfor\u001b[39;00m inputs,labels \u001b[39min\u001b[39;00m dataloaders[\u001b[39m\"\u001b[39m\u001b[39mtest\u001b[39m\u001b[39m\"\u001b[39m]:\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X53sZmlsZQ%3D%3D?line=7'>8</a>\u001b[0m inputs \u001b[39m=\u001b[39m inputs\u001b[39m.\u001b[39mto(device)\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/Malo/Documents/Python%20Scripts/td2-deeplearning/exercice%201%20and%202.ipynb#X53sZmlsZQ%3D%3D?line=8'>9</a>\u001b[0m labels \u001b[39m=\u001b[39m labels\u001b[39m.\u001b[39mto(device)\n",
+ "\u001b[1;31mKeyError\u001b[0m: 'test'"
+ ]
+ }
+ ],
"source": [
- "## Author\n",
+ "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n",
+ "print_size_of_model(model, \"int8\")\n",
+ "print_size_of_model(quantized_model, \"int8\")\n",
"\n",
- "Alberto BOSIO - Ph. D."
+ "eval_model(quantized_model)"
]
}
],
diff --git a/dog2.jpg b/dog2.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..6c1cb96b831fb3f1af2e3f1def3798bc3b06b8a0
Binary files /dev/null and b/dog2.jpg differ
diff --git a/exercice 1 and 2.ipynb b/exercice 1 and 2.ipynb
deleted file mode 100644
index 871b5165bf17e3a8dac5f727786d795371795756..0000000000000000000000000000000000000000
--- a/exercice 1 and 2.ipynb
+++ /dev/null
@@ -1,693 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "id": "7edf7168",
- "metadata": {},
- "source": [
- "# TD2: Deep learning"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "23f266da",
- "metadata": {},
- "source": [
- "## Exercise 1: CNN on CIFAR10"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "4ba1c82d",
- "metadata": {},
- "source": [
- "Importing matplotlib before torch to avoid kernel to crash."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "image/png": "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",
- "text/plain": [
- "<Figure size 640x480 with 1 Axes>"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "import matplotlib.pyplot as plt\n",
- "plt.plot(range(1), [1])\n",
- "plt.show()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "id": "6e18f2fd",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "CUDA is not available. Training on CPU ...\n"
- ]
- }
- ],
- "source": [
- "import torch\n",
- "from torchvision import models\n",
- "\n",
- "# check if CUDA is available\n",
- "train_on_gpu = torch.cuda.is_available()\n",
- "\n",
- "if not train_on_gpu:\n",
- " print(\"CUDA is not available. Training on CPU ...\")\n",
- "else:\n",
- " print(\"CUDA is available! Training on GPU ...\")\n",
- "device = \"cpu\"\n",
- "torch.set_default_device(device)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "5cf214eb",
- "metadata": {},
- "source": [
- "Next we load the CIFAR10 dataset"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "id": "462666a2",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Files already downloaded and verified\n",
- "Files already downloaded and verified\n"
- ]
- }
- ],
- "source": [
- "import numpy as np\n",
- "from torchvision import datasets, transforms\n",
- "from torch.utils.data.sampler import SubsetRandomSampler\n",
- "\n",
- "# number of subprocesses to use for data loading\n",
- "num_workers = 0\n",
- "# how many samples per batch to load\n",
- "batch_size = 20\n",
- "# percentage of training set to use as validation\n",
- "valid_size = 0.2\n",
- "\n",
- "# convert data to a normalized torch.FloatTensor\n",
- "transform = transforms.Compose(\n",
- " [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]\n",
- ")\n",
- "\n",
- "# choose the training and test datasets\n",
- "train_data = datasets.CIFAR10(\"data\", train=True, download=True, transform=transform)\n",
- "test_data = datasets.CIFAR10(\"data\", train=False, download=True, transform=transform)\n",
- "\n",
- "# obtain training indices that will be used for validation\n",
- "num_train = len(train_data)\n",
- "indices = list(range(num_train))\n",
- "np.random.shuffle(indices)\n",
- "split = int(np.floor(valid_size * num_train))\n",
- "train_idx, valid_idx = indices[split:], indices[:split]\n",
- "\n",
- "# define samplers for obtaining training and validation batches\n",
- "train_sampler = SubsetRandomSampler(train_idx)\n",
- "valid_sampler = SubsetRandomSampler(valid_idx)\n",
- "\n",
- "# prepare data loaders (combine dataset and sampler)\n",
- "train_loader = torch.utils.data.DataLoader(\n",
- " train_data, batch_size=batch_size, sampler=train_sampler, num_workers=num_workers\n",
- ")\n",
- "valid_loader = torch.utils.data.DataLoader(\n",
- " train_data, batch_size=batch_size, sampler=valid_sampler, num_workers=num_workers\n",
- ")\n",
- "test_loader = torch.utils.data.DataLoader(\n",
- " test_data, batch_size=batch_size, num_workers=num_workers\n",
- ")\n",
- "\n",
- "# specify the image classes\n",
- "classes = [\n",
- " \"airplane\",\n",
- " \"automobile\",\n",
- " \"bird\",\n",
- " \"cat\",\n",
- " \"deer\",\n",
- " \"dog\",\n",
- " \"frog\",\n",
- " \"horse\",\n",
- " \"ship\",\n",
- " \"truck\",\n",
- "]"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "58ec3903",
- "metadata": {},
- "source": [
- "Defining the CNN model."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "id": "317bf070",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Net(\n",
- " (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
- " (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
- " (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
- " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
- " (fc1): Linear(in_features=1024, out_features=512, bias=True)\n",
- " (dropout1): Dropout(p=0.4, inplace=False)\n",
- " (fc2): Linear(in_features=512, out_features=64, bias=True)\n",
- " (dropout2): Dropout(p=0.4, inplace=False)\n",
- " (fc3): Linear(in_features=64, out_features=10, bias=True)\n",
- ")\n"
- ]
- }
- ],
- "source": [
- "import torch.nn as nn\n",
- "import torch.nn.functional as F\n",
- "\n",
- "# define the CNN architecture\n",
- "\n",
- "\n",
- "class Net(nn.Module):\n",
- " def __init__(self):\n",
- " super(Net, self).__init__()\n",
- " self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)\n",
- " self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)\n",
- " self.conv3 = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
- " self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
- " self.fc1 = nn.Linear(64 * 4 * 4, 512)\n",
- " self.dropout1 = nn.Dropout(p = 0.4) #p = probability of an element to be equal to 0.\n",
- " self.fc2 = nn.Linear(512, 64)\n",
- " self.dropout2 = nn.Dropout(p = 0.4)\n",
- " self.fc3 = nn.Linear(64, 10)\n",
- "\n",
- " def forward(self, x):\n",
- " x = self.pool(F.relu(self.conv1(x)))\n",
- " x = self.pool(F.relu(self.conv2(x)))\n",
- " x = self.pool(F.relu(self.conv3(x)))\n",
- " x = x.view(-1, 64*4*4)\n",
- " x = self.dropout1(F.relu(self.fc1(x)))\n",
- " x = self.dropout2(F.relu(self.fc2(x)))\n",
- " x = self.fc3(x)\n",
- " return x\n",
- "\n",
- "\n",
- "# create a complete CNN\n",
- "model = Net()\n",
- "print(model)\n",
- "# move tensors to GPU if CUDA is available\n",
- "if train_on_gpu:\n",
- " model.cuda()"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "a2dc4974",
- "metadata": {},
- "source": [
- "Training using SGD (Stochastic Gradient Descent) optimizer."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "id": "4b53f229",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Epoch: 0 \tTraining Loss: 45.882111 \tValidation Loss: 44.668585\n",
- "Validation loss decreased (inf --> 44.668585). Saving model ...\n",
- "Epoch: 1 \tTraining Loss: 40.603230 \tValidation Loss: 36.758304\n",
- "Validation loss decreased (44.668585 --> 36.758304). Saving model ...\n",
- "Epoch: 2 \tTraining Loss: 35.396721 \tValidation Loss: 31.935054\n",
- "Validation loss decreased (36.758304 --> 31.935054). Saving model ...\n",
- "Epoch: 3 \tTraining Loss: 32.144104 \tValidation Loss: 29.167652\n",
- "Validation loss decreased (31.935054 --> 29.167652). Saving model ...\n",
- "Epoch: 4 \tTraining Loss: 29.971062 \tValidation Loss: 27.150468\n",
- "Validation loss decreased (29.167652 --> 27.150468). Saving model ...\n",
- "Epoch: 5 \tTraining Loss: 28.108355 \tValidation Loss: 26.775549\n",
- "Validation loss decreased (27.150468 --> 26.775549). Saving model ...\n",
- "Epoch: 6 \tTraining Loss: 26.360687 \tValidation Loss: 24.830030\n",
- "Validation loss decreased (26.775549 --> 24.830030). Saving model ...\n",
- "Epoch: 7 \tTraining Loss: 24.820620 \tValidation Loss: 22.812824\n",
- "Validation loss decreased (24.830030 --> 22.812824). Saving model ...\n",
- "Epoch: 8 \tTraining Loss: 23.395856 \tValidation Loss: 22.326507\n",
- "Validation loss decreased (22.812824 --> 22.326507). Saving model ...\n",
- "Epoch: 9 \tTraining Loss: 22.100028 \tValidation Loss: 20.783471\n",
- "Validation loss decreased (22.326507 --> 20.783471). Saving model ...\n"
- ]
- }
- ],
- "source": [
- "import torch.optim as optim\n",
- "\n",
- "criterion = nn.CrossEntropyLoss() # specify loss function\n",
- "optimizer = optim.SGD(model.parameters(), lr=0.01) # specify optimizer\n",
- "\n",
- "n_epochs = 10 # number of epochs to train the model\n",
- "train_loss_list = [] # list to store loss to visualize\n",
- "valid_loss_min = np.Inf # track change in validation loss\n",
- "\n",
- "for epoch in range(n_epochs):\n",
- " # Keep track of training and validation loss\n",
- " train_loss = 0.0\n",
- " valid_loss = 0.0\n",
- "\n",
- " # Train the model\n",
- " model.train()\n",
- " for data, target in train_loader:\n",
- " # Move tensors to GPU if CUDA is available\n",
- " if train_on_gpu:\n",
- " data, target = data.cuda(), target.cuda()\n",
- " # Clear the gradients of all optimized variables\n",
- " optimizer.zero_grad()\n",
- " # Forward pass: compute predicted outputs by passing inputs to the model\n",
- " output = model(data)\n",
- " # Calculate the batch loss\n",
- " loss = criterion(output, target)\n",
- " # Backward pass: compute gradient of the loss with respect to model parameters\n",
- " loss.backward()\n",
- " # Perform a single optimization step (parameter update)\n",
- " optimizer.step()\n",
- " # Update training loss\n",
- " train_loss += loss.item() * data.size(0)\n",
- "\n",
- " # Validate the model\n",
- " model.eval()\n",
- " for data, target in valid_loader:\n",
- " # Move tensors to GPU if CUDA is available\n",
- " if train_on_gpu:\n",
- " data, target = data.cuda(), target.cuda()\n",
- " # Forward pass: compute predicted outputs by passing inputs to the model\n",
- " output = model(data)\n",
- " # Calculate the batch loss\n",
- " loss = criterion(output, target)\n",
- " # Update average validation loss\n",
- " valid_loss += loss.item() * data.size(0)\n",
- "\n",
- " # Calculate average losses\n",
- " train_loss = train_loss / len(train_loader)\n",
- " valid_loss = valid_loss / len(valid_loader)\n",
- " train_loss_list.append(train_loss)\n",
- "\n",
- " # Print training/validation statistics\n",
- " print(\n",
- " \"Epoch: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f}\".format(\n",
- " epoch, train_loss, valid_loss\n",
- " )\n",
- " )\n",
- "\n",
- " # Save model if validation loss has decreased\n",
- " if valid_loss <= valid_loss_min:\n",
- " print(\n",
- " \"Validation loss decreased ({:.6f} --> {:.6f}). Saving model ...\".format(\n",
- " valid_loss_min, valid_loss\n",
- " )\n",
- " )\n",
- " torch.save(model.state_dict(), \"model_cifar.pt\")\n",
- " valid_loss_min = valid_loss"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Overfitting occurs for n_epoch>10 so I kept n_epoch = 10 for this model."
- ]
- },
- {
- "cell_type": "markdown",
- "id": "13e1df74",
- "metadata": {},
- "source": [
- "Plotting the loss over the number of epoch."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "id": "d39df818",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "image/png": "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",
- "text/plain": [
- "<Figure size 640x480 with 1 Axes>"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "plt.plot(range(n_epochs), train_loss_list)\n",
- "plt.xlabel(\"Epoch\")\n",
- "plt.ylabel(\"Loss\")\n",
- "plt.title(\"Performance of Model 1\")\n",
- "plt.show()"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "11df8fd4",
- "metadata": {},
- "source": [
- "Computing the accuracy of the new model.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "id": "e93efdfc",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Test Loss: 20.574108\n",
- "\n",
- "Test Accuracy of airplane: 63% (636/1000)\n",
- "Test Accuracy of automobile: 72% (723/1000)\n",
- "Test Accuracy of bird: 49% (497/1000)\n",
- "Test Accuracy of cat: 46% (461/1000)\n",
- "Test Accuracy of deer: 56% (561/1000)\n",
- "Test Accuracy of dog: 58% (588/1000)\n",
- "Test Accuracy of frog: 69% (696/1000)\n",
- "Test Accuracy of horse: 62% (625/1000)\n",
- "Test Accuracy of ship: 86% (866/1000)\n",
- "Test Accuracy of truck: 72% (724/1000)\n",
- "\n",
- "Test Accuracy (Overall): 63% (6377/10000)\n"
- ]
- },
- {
- "data": {
- "text/plain": [
- "([0.636, 0.723, 0.497, 0.461, 0.561, 0.588, 0.696, 0.625, 0.866, 0.724],\n",
- " 0.6377)"
- ]
- },
- "execution_count": 9,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n",
- "\n",
- "def test_accuracy(model_to_evaluate):\n",
- " \"\"\"\n",
- " Return the percentage of True Positive data of each class for a model.\n",
- " \"\"\"\n",
- " # track test loss\n",
- " test_loss = 0.0\n",
- " class_correct = list(0.0 for i in range(10))\n",
- " class_total = list(0.0 for i in range(10))\n",
- "\n",
- " model_to_evaluate.eval()\n",
- " # iterate over test data\n",
- " for data, target in test_loader:\n",
- " # move tensors to GPU if CUDA is available\n",
- " if train_on_gpu:\n",
- " data, target = data.cuda(), target.cuda()\n",
- " # forward pass: compute predicted outputs by passing inputs to the model\n",
- " output = model_to_evaluate(data)\n",
- " # calculate the batch loss\n",
- " loss = criterion(output, target)\n",
- " # update test loss\n",
- " test_loss += loss.item() * data.size(0)\n",
- " # convert output probabilities to predicted class\n",
- " _, pred = torch.max(output, 1)\n",
- " # compare predictions to true label\n",
- " correct_tensor = pred.eq(target.data.view_as(pred))\n",
- " correct = (\n",
- " np.squeeze(correct_tensor.numpy())\n",
- " if not train_on_gpu\n",
- " else np.squeeze(correct_tensor.cpu().numpy())\n",
- " )\n",
- " # calculate test accuracy for each object class\n",
- " for i in range(batch_size):\n",
- " label = target.data[i]\n",
- " class_correct[label] += correct[i].item()\n",
- " class_total[label] += 1\n",
- "\n",
- " # average test loss\n",
- " test_loss = test_loss / len(test_loader)\n",
- " print(\"Test Loss: {:.6f}\\n\".format(test_loss))\n",
- " percentage_true_positive = []\n",
- " for i in range(10):\n",
- " \n",
- " if class_total[i] > 0:\n",
- " print(\n",
- " \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n",
- " % (\n",
- " classes[i],\n",
- " 100 * class_correct[i] / class_total[i],\n",
- " np.sum(class_correct[i]),\n",
- " np.sum(class_total[i]),\n",
- " )\n",
- " )\n",
- " percentage_true_positive.append(np.sum(class_correct[i]) / class_total[i])\n",
- " else:\n",
- " print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n",
- "\n",
- " print(\n",
- " \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n",
- " % (\n",
- " 100.0 * np.sum(class_correct) / np.sum(class_total),\n",
- " np.sum(class_correct),\n",
- " np.sum(class_total),\n",
- " )\n",
- " )\n",
- " percentage_overall = np.sum(class_correct) / np.sum(class_total)\n",
- " return percentage_true_positive, percentage_overall\n",
- "\n",
- "test_accuracy(model)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "bc381cf4",
- "metadata": {},
- "source": [
- "## Exercise 2: Quantization: try to compress the CNN to save space"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "id": "ef623c26",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "model: fp32 \t Size (KB): 2330.946\n"
- ]
- },
- {
- "data": {
- "text/plain": [
- "2330946"
- ]
- },
- "execution_count": 10,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "import os\n",
- "\n",
- "\n",
- "def print_size_of_model(model, label=\"\"):\n",
- " torch.save(model.state_dict(), \"temp.p\")\n",
- " size = os.path.getsize(\"temp.p\")\n",
- " print(\"model: \", label, \" \\t\", \"Size (KB):\", size / 1e3)\n",
- " os.remove(\"temp.p\")\n",
- " return size\n",
- "\n",
- "\n",
- "print_size_of_model(model, \"fp32\")"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "05c4e9ad",
- "metadata": {},
- "source": [
- "Post training quantization example"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "id": "c4c65d4b",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "model: int8 \t Size (KB): 659.806\n"
- ]
- },
- {
- "data": {
- "text/plain": [
- "659806"
- ]
- },
- "execution_count": 11,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "import torch.quantization\n",
- "\n",
- "\n",
- "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n",
- "print_size_of_model(quantized_model, \"int8\")"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "7b108e17",
- "metadata": {},
- "source": [
- "For each class, compare the classification test accuracy of the initial model and the quantized model. Also give the overall test accuracy for both models."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 12,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Test Loss: 20.574108\n",
- "\n",
- "Test Accuracy of airplane: 63% (636/1000)\n",
- "Test Accuracy of automobile: 72% (723/1000)\n",
- "Test Accuracy of bird: 49% (497/1000)\n",
- "Test Accuracy of cat: 46% (461/1000)\n",
- "Test Accuracy of deer: 56% (561/1000)\n",
- "Test Accuracy of dog: 58% (588/1000)\n",
- "Test Accuracy of frog: 69% (696/1000)\n",
- "Test Accuracy of horse: 62% (625/1000)\n",
- "Test Accuracy of ship: 86% (866/1000)\n",
- "Test Accuracy of truck: 72% (724/1000)\n",
- "\n",
- "Test Accuracy (Overall): 63% (6377/10000)\n",
- "Test Loss: 20.579821\n",
- "\n",
- "Test Accuracy of airplane: 63% (637/1000)\n",
- "Test Accuracy of automobile: 72% (725/1000)\n",
- "Test Accuracy of bird: 49% (493/1000)\n",
- "Test Accuracy of cat: 46% (462/1000)\n",
- "Test Accuracy of deer: 56% (560/1000)\n",
- "Test Accuracy of dog: 58% (586/1000)\n",
- "Test Accuracy of frog: 69% (698/1000)\n",
- "Test Accuracy of horse: 62% (627/1000)\n",
- "Test Accuracy of ship: 86% (867/1000)\n",
- "Test Accuracy of truck: 72% (721/1000)\n",
- "\n",
- "Test Accuracy (Overall): 63% (6376/10000)\n"
- ]
- },
- {
- "data": {
- "image/png": "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",
- "text/plain": [
- "<Figure size 640x480 with 1 Axes>"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "percentage_each_class_initial_model, percentage_overall_initial_model = test_accuracy(model)\n",
- "percentage_each_class_quantized_model, percentage_overall_quantized_model = test_accuracy(quantized_model)\n",
- "x = [1,2,3,4,5,6,7,8,9,10]\n",
- "plt.scatter(x, percentage_each_class_initial_model, color='r', label=\"initial model\")\n",
- "plt.scatter(x, percentage_each_class_quantized_model, color='b', label=\"quantized model\")\n",
- "plt.xlabel(\"Classes\")\n",
- "plt.ylabel(\"Percentage of true positive for each model\")\n",
- "plt.title(\"comparis between itinial and quantized model\")\n",
- "plt.xticks(x, x)\n",
- "plt.legend()\n",
- "plt.show()\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "This is the same accuracy for the two models."
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3.8.5 ('base')",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.11.5"
- },
- "vscode": {
- "interpreter": {
- "hash": "9e3efbebb05da2d4a1968abe9a0645745f54b63feb7a85a514e4da0495be97eb"
- }
- }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/exercice 3.ipynb b/exercice 3.ipynb
deleted file mode 100644
index 21d94a6b109be809fbc554f2595ac85cd873e998..0000000000000000000000000000000000000000
--- a/exercice 3.ipynb
+++ /dev/null
@@ -1,155 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "id": "7edf7168",
- "metadata": {},
- "source": [
- "# TD2: Deep learning"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "import matplotlib.pyplot as plt"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "id": "6e18f2fd",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "CUDA is not available. Training on CPU ...\n"
- ]
- }
- ],
- "source": [
- "import torch\n",
- "from torchvision import transforms\n",
- "from torchvision import models\n",
- "\n",
- "\n",
- "# check if CUDA is available\n",
- "train_on_gpu = torch.cuda.is_available()\n",
- "\n",
- "if not train_on_gpu:\n",
- " print(\"CUDA is not available. Training on CPU ...\")\n",
- "else:\n",
- " print(\"CUDA is available! Training on GPU ...\")"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "201470f9",
- "metadata": {},
- "source": [
- "## Exercise 3: working with pre-trained models.\n",
- "\n",
- "PyTorch offers several pre-trained models https://pytorch.org/vision/0.8/models.html \n",
- "We will use ResNet50 trained on ImageNet dataset (https://www.image-net.org/index.php). Use the following code with the files `imagenet-simple-labels.json` that contains the imagenet labels and the image dog.png that we will use as test.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "b4d13080",
- "metadata": {},
- "outputs": [],
- "source": [
- "import json\n",
- "from PIL import Image\n",
- "\n",
- "# Choose an image to pass through the model\n",
- "test_image = \"dog.png\"\n",
- "\n",
- "# Configure matplotlib for pretty inline plots\n",
- "#%matplotlib inline\n",
- "#%config InlineBackend.figure_format = 'retina'\n",
- "\n",
- "# Prepare the labels\n",
- "with open(\"imagenet-simple-labels.json\") as f:\n",
- " labels = json.load(f)\n",
- "\n",
- "# First prepare the transformations: resize the image to what the model was trained on and convert it to a tensor\n",
- "data_transform = transforms.Compose(\n",
- " [\n",
- " transforms.Resize((224, 224)),\n",
- " transforms.ToTensor(),\n",
- " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
- " ]\n",
- ")\n",
- "\n",
- "# Load the image\n",
- "image = Image.open(test_image)\n",
- "plt.imshow(image), plt.xticks([]), plt.yticks([])\n",
- "\n",
- "# Now apply the transformation, expand the batch dimension, and send the image to the GPU\n",
- "# image = data_transform(image).unsqueeze(0).cuda()\n",
- "image = data_transform(image).unsqueeze(0)\n",
- "\n",
- "# Download the model if it's not there already. It will take a bit on the first run, after that it's fast\n",
- "model = models.resnet50(pretrained=True)\n",
- "\n",
- "# Send the model to the GPU\n",
- "# model.cuda()\n",
- "# Set layers such as dropout and batchnorm in evaluation mode\n",
- "model.eval()\n",
- "\n",
- "# Get the 1000-dimensional model output\n",
- "out = model(image)\n",
- "# Find the predicted class\n",
- "print(\"Predicted class is: {}\".format(labels[out.argmax()]))"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "184cfceb",
- "metadata": {},
- "source": [
- "Experiments:\n",
- "\n",
- "Study the code and the results obtained. Possibly add other images downloaded from the internet.\n",
- "\n",
- "What is the size of the model? Quantize it and then check if the model is still able to correctly classify the other images.\n",
- "\n",
- "Experiment with other pre-trained CNN models.\n",
- "\n",
- " \n"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3.8.5 ('base')",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.11.5"
- },
- "vscode": {
- "interpreter": {
- "hash": "9e3efbebb05da2d4a1968abe9a0645745f54b63feb7a85a514e4da0495be97eb"
- }
- }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/exercice 4.ipynb b/exercice 4.ipynb
deleted file mode 100644
index 9f48325c18f5b4a300cdb03c9b045ffcaada1eb7..0000000000000000000000000000000000000000
--- a/exercice 4.ipynb
+++ /dev/null
@@ -1,380 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "id": "7edf7168",
- "metadata": {},
- "source": [
- "# TD2: Deep learning"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "import matplotlib.pyplot as plt"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "id": "6e18f2fd",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "CUDA is not available. Training on CPU ...\n"
- ]
- }
- ],
- "source": [
- "import torch\n",
- "\n",
- "\n",
- "# check if CUDA is available\n",
- "train_on_gpu = torch.cuda.is_available()\n",
- "\n",
- "if not train_on_gpu:\n",
- " print(\"CUDA is not available. Training on CPU ...\")\n",
- "else:\n",
- " print(\"CUDA is available! Training on GPU ...\")"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "5d57da4b",
- "metadata": {},
- "source": [
- "## Exercise 4: Transfer Learning\n",
- " \n",
- " \n",
- "For this work, we will use a pre-trained model (ResNet18) as a descriptor extractor and will refine the classification by training only the last fully connected layer of the network. Thus, the output layer of the pre-trained network will be replaced by a layer adapted to the new classes to be recognized which will be in our case ants and bees."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "be2d31f5",
- "metadata": {},
- "outputs": [],
- "source": [
- "import os\n",
- "\n",
- "import matplotlib.pyplot as plt\n",
- "import numpy as np\n",
- "import torch\n",
- "import torchvision\n",
- "from torchvision import datasets, transforms\n",
- "\n",
- "# Data augmentation and normalization for training\n",
- "# Just normalization for validation\n",
- "data_transforms = {\n",
- " \"train\": transforms.Compose(\n",
- " [\n",
- " transforms.RandomResizedCrop(\n",
- " 224\n",
- " ), # ImageNet models were trained on 224x224 images\n",
- " transforms.RandomHorizontalFlip(), # flip horizontally 50% of the time - increases train set variability\n",
- " transforms.ToTensor(), # convert it to a PyTorch tensor\n",
- " transforms.Normalize(\n",
- " [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]\n",
- " ), # ImageNet models expect this norm\n",
- " ]\n",
- " ),\n",
- " \"val\": transforms.Compose(\n",
- " [\n",
- " transforms.Resize(256),\n",
- " transforms.CenterCrop(224),\n",
- " transforms.ToTensor(),\n",
- " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
- " ]\n",
- " ),\n",
- "}\n",
- "\n",
- "data_dir = \"hymenoptera_data\"\n",
- "# Create train and validation datasets and loaders\n",
- "image_datasets = {\n",
- " x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n",
- " for x in [\"train\", \"val\"]\n",
- "}\n",
- "dataloaders = {\n",
- " x: torch.utils.data.DataLoader(\n",
- " image_datasets[x], batch_size=4, shuffle=True, num_workers=0\n",
- " )\n",
- " for x in [\"train\", \"val\"]\n",
- "}\n",
- "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\"]}\n",
- "class_names = image_datasets[\"train\"].classes\n",
- "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
- "\n",
- "# Helper function for displaying images\n",
- "def imshow(inp, title=None):\n",
- " \"\"\"Imshow for Tensor.\"\"\"\n",
- " inp = inp.numpy().transpose((1, 2, 0))\n",
- " mean = np.array([0.485, 0.456, 0.406])\n",
- " std = np.array([0.229, 0.224, 0.225])\n",
- "\n",
- " # Un-normalize the images\n",
- " inp = std * inp + mean\n",
- " # Clip just in case\n",
- " inp = np.clip(inp, 0, 1)\n",
- " plt.imshow(inp)\n",
- " if title is not None:\n",
- " plt.title(title)\n",
- " plt.pause(0.001) # pause a bit so that plots are updated\n",
- " plt.show()\n",
- "\n",
- "\n",
- "# Get a batch of training data\n",
- "inputs, classes = next(iter(dataloaders[\"train\"]))\n",
- "\n",
- "# Make a grid from batch\n",
- "out = torchvision.utils.make_grid(inputs)\n",
- "\n",
- "imshow(out, title=[class_names[x] for x in classes])\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "bbd48800",
- "metadata": {},
- "source": [
- "Now, execute the following code which uses a pre-trained model ResNet18 having replaced the output layer for the ants/bees classification and performs the model training by only changing the weights of this output layer."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "572d824c",
- "metadata": {},
- "outputs": [],
- "source": [
- "import copy\n",
- "import os\n",
- "import time\n",
- "\n",
- "import matplotlib.pyplot as plt\n",
- "import numpy as np\n",
- "import torch\n",
- "import torch.nn as nn\n",
- "import torch.optim as optim\n",
- "import torchvision\n",
- "from torch.optim import lr_scheduler\n",
- "from torchvision import datasets, transforms\n",
- "\n",
- "# Data augmentation and normalization for training\n",
- "# Just normalization for validation\n",
- "data_transforms = {\n",
- " \"train\": transforms.Compose(\n",
- " [\n",
- " transforms.RandomResizedCrop(\n",
- " 224\n",
- " ), # ImageNet models were trained on 224x224 images\n",
- " transforms.RandomHorizontalFlip(), # flip horizontally 50% of the time - increases train set variability\n",
- " transforms.ToTensor(), # convert it to a PyTorch tensor\n",
- " transforms.Normalize(\n",
- " [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]\n",
- " ), # ImageNet models expect this norm\n",
- " ]\n",
- " ),\n",
- " \"val\": transforms.Compose(\n",
- " [\n",
- " transforms.Resize(256),\n",
- " transforms.CenterCrop(224),\n",
- " transforms.ToTensor(),\n",
- " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
- " ]\n",
- " ),\n",
- "}\n",
- "\n",
- "data_dir = \"hymenoptera_data\"\n",
- "# Create train and validation datasets and loaders\n",
- "image_datasets = {\n",
- " x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n",
- " for x in [\"train\", \"val\"]\n",
- "}\n",
- "dataloaders = {\n",
- " x: torch.utils.data.DataLoader(\n",
- " image_datasets[x], batch_size=4, shuffle=True, num_workers=4\n",
- " )\n",
- " for x in [\"train\", \"val\"]\n",
- "}\n",
- "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\"]}\n",
- "class_names = image_datasets[\"train\"].classes\n",
- "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
- "\n",
- "# Helper function for displaying images\n",
- "def imshow(inp, title=None):\n",
- " \"\"\"Imshow for Tensor.\"\"\"\n",
- " inp = inp.numpy().transpose((1, 2, 0))\n",
- " mean = np.array([0.485, 0.456, 0.406])\n",
- " std = np.array([0.229, 0.224, 0.225])\n",
- "\n",
- " # Un-normalize the images\n",
- " inp = std * inp + mean\n",
- " # Clip just in case\n",
- " inp = np.clip(inp, 0, 1)\n",
- " plt.imshow(inp)\n",
- " if title is not None:\n",
- " plt.title(title)\n",
- " plt.pause(0.001) # pause a bit so that plots are updated\n",
- " plt.show()\n",
- "\n",
- "\n",
- "# Get a batch of training data\n",
- "# inputs, classes = next(iter(dataloaders['train']))\n",
- "\n",
- "# Make a grid from batch\n",
- "# out = torchvision.utils.make_grid(inputs)\n",
- "\n",
- "# imshow(out, title=[class_names[x] for x in classes])\n",
- "# training\n",
- "\n",
- "\n",
- "def train_model(model, criterion, optimizer, scheduler, num_epochs=25):\n",
- " since = time.time()\n",
- "\n",
- " best_model_wts = copy.deepcopy(model.state_dict())\n",
- " best_acc = 0.0\n",
- "\n",
- " epoch_time = [] # we'll keep track of the time needed for each epoch\n",
- "\n",
- " for epoch in range(num_epochs):\n",
- " epoch_start = time.time()\n",
- " print(\"Epoch {}/{}\".format(epoch + 1, num_epochs))\n",
- " print(\"-\" * 10)\n",
- "\n",
- " # Each epoch has a training and validation phase\n",
- " for phase in [\"train\", \"val\"]:\n",
- " if phase == \"train\":\n",
- " scheduler.step()\n",
- " model.train() # Set model to training mode\n",
- " else:\n",
- " model.eval() # Set model to evaluate mode\n",
- "\n",
- " running_loss = 0.0\n",
- " running_corrects = 0\n",
- "\n",
- " # Iterate over data.\n",
- " for inputs, labels in dataloaders[phase]:\n",
- " inputs = inputs.to(device)\n",
- " labels = labels.to(device)\n",
- "\n",
- " # zero the parameter gradients\n",
- " optimizer.zero_grad()\n",
- "\n",
- " # Forward\n",
- " # Track history if only in training phase\n",
- " with torch.set_grad_enabled(phase == \"train\"):\n",
- " outputs = model(inputs)\n",
- " _, preds = torch.max(outputs, 1)\n",
- " loss = criterion(outputs, labels)\n",
- "\n",
- " # backward + optimize only if in training phase\n",
- " if phase == \"train\":\n",
- " loss.backward()\n",
- " optimizer.step()\n",
- "\n",
- " # Statistics\n",
- " running_loss += loss.item() * inputs.size(0)\n",
- " running_corrects += torch.sum(preds == labels.data)\n",
- "\n",
- " epoch_loss = running_loss / dataset_sizes[phase]\n",
- " epoch_acc = running_corrects.double() / dataset_sizes[phase]\n",
- "\n",
- " print(\"{} Loss: {:.4f} Acc: {:.4f}\".format(phase, epoch_loss, epoch_acc))\n",
- "\n",
- " # Deep copy the model\n",
- " if phase == \"val\" and epoch_acc > best_acc:\n",
- " best_acc = epoch_acc\n",
- " best_model_wts = copy.deepcopy(model.state_dict())\n",
- "\n",
- " # Add the epoch time\n",
- " t_epoch = time.time() - epoch_start\n",
- " epoch_time.append(t_epoch)\n",
- " print()\n",
- "\n",
- " time_elapsed = time.time() - since\n",
- " print(\n",
- " \"Training complete in {:.0f}m {:.0f}s\".format(\n",
- " time_elapsed // 60, time_elapsed % 60\n",
- " )\n",
- " )\n",
- " print(\"Best val Acc: {:4f}\".format(best_acc))\n",
- "\n",
- " # Load best model weights\n",
- " model.load_state_dict(best_model_wts)\n",
- " return model, epoch_time\n",
- "\n",
- "\n",
- "# Download a pre-trained ResNet18 model and freeze its weights\n",
- "model = torchvision.models.resnet18(pretrained=True)\n",
- "for param in model.parameters():\n",
- " param.requires_grad = False\n",
- "\n",
- "# Replace the final fully connected layer\n",
- "# Parameters of newly constructed modules have requires_grad=True by default\n",
- "num_ftrs = model.fc.in_features\n",
- "model.fc = nn.Linear(num_ftrs, 2)\n",
- "# Send the model to the GPU\n",
- "model = model.to(device)\n",
- "# Set the loss function\n",
- "criterion = nn.CrossEntropyLoss()\n",
- "\n",
- "# Observe that only the parameters of the final layer are being optimized\n",
- "optimizer_conv = optim.SGD(model.fc.parameters(), lr=0.001, momentum=0.9)\n",
- "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_conv, step_size=7, gamma=0.1)\n",
- "model, epoch_time = train_model(\n",
- " model, criterion, optimizer_conv, exp_lr_scheduler, num_epochs=10\n",
- ")\n"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "bbd48800",
- "metadata": {},
- "source": [
- "Experiments:\n",
- "Study the code and the results obtained.\n",
- "\n",
- "Modify the code and add an \"eval_model\" function to allow\n",
- "the evaluation of the model on a test set (different from the learning and validation sets used during the learning phase). Study the results obtained.\n",
- "\n",
- "Now modify the code to replace the current classification layer with a set of two layers using a \"relu\" activation function for the middle layer, and the \"dropout\" mechanism for both layers. Renew the experiments and study the results obtained.\n",
- "\n",
- "Apply ther quantization (post and quantization aware) and evaluate impact on model size and accuracy."
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3.8.5 ('base')",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.11.5"
- },
- "vscode": {
- "interpreter": {
- "hash": "9e3efbebb05da2d4a1968abe9a0645745f54b63feb7a85a514e4da0495be97eb"
- }
- }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/model_cifar.pt b/model_cifar.pt
index d90635787a88d0e535fac0231688f0effee947fb..d7e30074491b5ed68b521ba69de011f6c8cea543 100644
Binary files a/model_cifar.pt and b/model_cifar.pt differ