diff --git a/TD2 Deep Learning.ipynb b/TD2 Deep Learning.ipynb
index 96bc0494484e0f849cd0162b91525e6093562277..b6ce0e1a989fd6641b5a1454b9b0d7976e66e72e 100644
--- a/TD2 Deep Learning.ipynb
+++ b/TD2 Deep Learning.ipynb
@@ -177,7 +177,7 @@
},
{
"cell_type": "code",
- "execution_count": 31,
+ "execution_count": 1,
"id": "6e18f2fd",
"metadata": {},
"outputs": [
@@ -211,7 +211,7 @@
},
{
"cell_type": "code",
- "execution_count": 32,
+ "execution_count": 2,
"id": "462666a2",
"metadata": {},
"outputs": [
@@ -292,7 +292,7 @@
},
{
"cell_type": "code",
- "execution_count": 33,
+ "execution_count": 3,
"id": "317bf070",
"metadata": {},
"outputs": [
@@ -356,7 +356,7 @@
},
{
"cell_type": "code",
- "execution_count": 41,
+ "execution_count": 4,
"id": "4b53f229",
"metadata": {},
"outputs": [
@@ -364,11 +364,33 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Epoch: 0 \tTraining Loss: 9.849982 \tValidation Loss: 16.806046\n",
- "Validation loss decreased (inf --> 16.806046). Saving model ...\n",
- "Epoch: 1 \tTraining Loss: 9.694958 \tValidation Loss: 17.402767\n",
+ "Epoch: 0 \tTraining Loss: 44.446738 \tValidation Loss: 39.709481\n",
+ "Validation loss decreased (inf --> 39.709481). Saving model ...\n",
+ "Epoch: 1 \tTraining Loss: 35.712898 \tValidation Loss: 32.340186\n",
+ "Validation loss decreased (39.709481 --> 32.340186). Saving model ...\n",
+ "Epoch: 2 \tTraining Loss: 30.993299 \tValidation Loss: 30.197401\n",
+ "Validation loss decreased (32.340186 --> 30.197401). Saving model ...\n",
+ "Epoch: 3 \tTraining Loss: 28.716211 \tValidation Loss: 28.417901\n",
+ "Validation loss decreased (30.197401 --> 28.417901). Saving model ...\n",
+ "Epoch: 4 \tTraining Loss: 26.939352 \tValidation Loss: 26.354477\n",
+ "Validation loss decreased (28.417901 --> 26.354477). Saving model ...\n",
+ "Epoch: 5 \tTraining Loss: 25.582816 \tValidation Loss: 26.713869\n",
"No improvement in validation loss for 1 epoch(s).\n",
- "Epoch: 2 \tTraining Loss: 9.317991 \tValidation Loss: 16.902088\n",
+ "Epoch: 6 \tTraining Loss: 24.345140 \tValidation Loss: 24.874123\n",
+ "Validation loss decreased (26.354477 --> 24.874123). Saving model ...\n",
+ "Epoch: 7 \tTraining Loss: 23.290062 \tValidation Loss: 24.112446\n",
+ "Validation loss decreased (24.874123 --> 24.112446). Saving model ...\n",
+ "Epoch: 8 \tTraining Loss: 22.414044 \tValidation Loss: 25.658204\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 9 \tTraining Loss: 21.516157 \tValidation Loss: 22.744862\n",
+ "Validation loss decreased (24.112446 --> 22.744862). Saving model ...\n",
+ "Epoch: 10 \tTraining Loss: 20.712172 \tValidation Loss: 22.697988\n",
+ "Validation loss decreased (22.744862 --> 22.697988). Saving model ...\n",
+ "Epoch: 11 \tTraining Loss: 20.020578 \tValidation Loss: 22.441365\n",
+ "Validation loss decreased (22.697988 --> 22.441365). Saving model ...\n",
+ "Epoch: 12 \tTraining Loss: 19.345497 \tValidation Loss: 22.729177\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 13 \tTraining Loss: 18.707986 \tValidation Loss: 22.530268\n",
"No improvement in validation loss for 2 epoch(s).\n",
"Early stopping triggered. Stopping training.\n"
]
diff --git a/TD2_Deep_Learning.ipynb b/TD2_Deep_Learning.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..e27e758e1d1b4a574e12e3b02dddebc8f372b9e0
--- /dev/null
+++ b/TD2_Deep_Learning.ipynb
@@ -0,0 +1,1986 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "7edf7168",
+ "metadata": {
+ "id": "7edf7168"
+ },
+ "source": [
+ "# TD2: Deep learning"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fbb8c8df",
+ "metadata": {
+ "id": "fbb8c8df"
+ },
+ "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 Wednesday, December 4, 11:59 PM. Later commits will not be taken into account."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3d167a29",
+ "metadata": {
+ "id": "3d167a29"
+ },
+ "source": [
+ "Install and test PyTorch from https://pytorch.org/get-started/locally."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "330a42f5",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "330a42f5",
+ "outputId": "6e51b21a-e633-4f33-b76e-34fd145ef0b6"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (2.5.1+cu121)\n",
+ "Requirement already satisfied: torchvision in /usr/local/lib/python3.10/dist-packages (0.20.1+cu121)\n",
+ "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch) (3.16.1)\n",
+ "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch) (4.12.2)\n",
+ "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch) (3.4.2)\n",
+ "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch) (3.1.4)\n",
+ "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch) (2024.10.0)\n",
+ "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.10/dist-packages (from torch) (1.13.1)\n",
+ "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy==1.13.1->torch) (1.3.0)\n",
+ "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from torchvision) (1.26.4)\n",
+ "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.10/dist-packages (from torchvision) (11.0.0)\n",
+ "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch) (3.0.2)\n"
+ ]
+ }
+ ],
+ "source": [
+ "%pip install torch torchvision"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0882a636",
+ "metadata": {
+ "id": "0882a636"
+ },
+ "source": [
+ "\n",
+ "To test run the following code"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "b1950f0a",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "b1950f0a",
+ "outputId": "7a1758bc-8a4b-4df6-ac1b-7430740b5b84"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "tensor([[-1.2895, 1.2400, 0.4831, -0.3706, 0.0101, -0.3556, 0.0615, -0.9143,\n",
+ " 0.3954, 0.8348],\n",
+ " [ 0.0218, 1.5397, -1.8694, 0.0323, 0.8841, -0.2688, 0.4880, -1.3547,\n",
+ " -0.5961, 1.2928],\n",
+ " [ 0.5192, 1.7479, -0.4975, -0.2688, 0.8931, 1.1361, 0.4854, -1.1558,\n",
+ " 1.5288, 0.2812],\n",
+ " [ 0.6235, 0.1043, 1.8881, -1.1311, 1.1723, -0.6601, -1.2593, 0.4189,\n",
+ " 0.5574, -0.4006],\n",
+ " [ 1.4374, -0.2810, -1.0138, -0.2625, -1.0253, -0.1667, 0.1795, -0.2560,\n",
+ " 0.5106, 0.0398],\n",
+ " [ 0.4167, 0.0312, 1.4281, 2.1389, -0.4448, -0.6421, 0.2039, 0.2291,\n",
+ " 1.0519, -0.8063],\n",
+ " [-0.6767, 0.0314, -0.5346, 0.1729, -1.1490, -1.2153, 1.4849, -0.5210,\n",
+ " 1.1402, 0.1790],\n",
+ " [ 0.6089, -0.2845, -0.8845, -0.1962, -1.1061, 1.3853, -1.8311, -0.6607,\n",
+ " -1.4634, 0.3426],\n",
+ " [ 1.4712, -0.6397, -1.1063, -1.0366, -1.4058, -1.5566, 0.9857, -0.1916,\n",
+ " -0.9744, -0.2545],\n",
+ " [ 0.2238, -0.6325, -1.4858, 0.1888, 0.4826, -0.3605, 1.5526, 2.5483,\n",
+ " -1.5241, -0.5940],\n",
+ " [-0.4768, 0.2024, 2.1094, -0.1436, 0.8020, 0.0820, -1.8182, -0.6793,\n",
+ " 1.4447, 0.4831],\n",
+ " [ 1.4599, -1.4023, 1.3450, 1.1937, -0.5197, -1.0252, 1.3253, 0.0656,\n",
+ " 1.0715, -2.3567],\n",
+ " [ 0.3710, 0.7372, -0.3647, 1.0369, 0.8668, 2.4054, 0.1624, 1.1735,\n",
+ " 1.1086, 0.6845],\n",
+ " [ 0.5828, 0.9586, -0.0703, 0.4475, -0.3496, 0.0403, 1.5633, -0.0249,\n",
+ " 0.8291, 0.1752]])\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": {
+ "id": "23f266da"
+ },
+ "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": {
+ "id": "4ba1c82d"
+ },
+ "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": 3,
+ "id": "6e18f2fd",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "6e18f2fd",
+ "outputId": "0a6a334d-3e0c-4ff9-9d32-75cd7943c858"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "CUDA is available! Training on GPU ...\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch\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": {
+ "id": "5cf214eb"
+ },
+ "source": [
+ "Next we load the CIFAR10 dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "id": "462666a2",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "462666a2",
+ "outputId": "e92697c5-9bc9-488e-9b4d-2fbd4590fe8d"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "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": {
+ "id": "58ec3903"
+ },
+ "source": [
+ "CNN definition (this one is an example)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "317bf070",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "317bf070",
+ "outputId": "a210a414-85e7-489d-d780-61227165f35e"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "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": {
+ "id": "a2dc4974"
+ },
+ "source": [
+ "Loss function and training using SGD (Stochastic Gradient Descent) optimizer"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "4b53f229",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "4b53f229",
+ "outputId": "51576e31-126a-414c-d880-a12c51dfc2b6"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Epoch: 0 \tTraining Loss: 44.199701 \tValidation Loss: 39.149789\n",
+ "Validation loss decreased (inf --> 39.149789). Saving model ...\n",
+ "Epoch: 1 \tTraining Loss: 35.756507 \tValidation Loss: 33.250751\n",
+ "Validation loss decreased (39.149789 --> 33.250751). Saving model ...\n",
+ "Epoch: 2 \tTraining Loss: 31.220159 \tValidation Loss: 30.010739\n",
+ "Validation loss decreased (33.250751 --> 30.010739). Saving model ...\n",
+ "Epoch: 3 \tTraining Loss: 28.729241 \tValidation Loss: 28.890655\n",
+ "Validation loss decreased (30.010739 --> 28.890655). Saving model ...\n",
+ "Epoch: 4 \tTraining Loss: 26.905334 \tValidation Loss: 26.454167\n",
+ "Validation loss decreased (28.890655 --> 26.454167). Saving model ...\n",
+ "Epoch: 5 \tTraining Loss: 25.485036 \tValidation Loss: 25.076245\n",
+ "Validation loss decreased (26.454167 --> 25.076245). Saving model ...\n",
+ "Epoch: 6 \tTraining Loss: 24.196011 \tValidation Loss: 24.774686\n",
+ "Validation loss decreased (25.076245 --> 24.774686). Saving model ...\n",
+ "Epoch: 7 \tTraining Loss: 23.173993 \tValidation Loss: 24.909123\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 8 \tTraining Loss: 22.212043 \tValidation Loss: 23.173045\n",
+ "Validation loss decreased (24.774686 --> 23.173045). Saving model ...\n",
+ "Epoch: 9 \tTraining Loss: 21.273993 \tValidation Loss: 22.828963\n",
+ "Validation loss decreased (23.173045 --> 22.828963). Saving model ...\n",
+ "Epoch: 10 \tTraining Loss: 20.511636 \tValidation Loss: 22.586984\n",
+ "Validation loss decreased (22.828963 --> 22.586984). Saving model ...\n",
+ "Epoch: 11 \tTraining Loss: 19.730919 \tValidation Loss: 22.112282\n",
+ "Validation loss decreased (22.586984 --> 22.112282). Saving model ...\n",
+ "Epoch: 12 \tTraining Loss: 18.959367 \tValidation Loss: 21.318977\n",
+ "Validation loss decreased (22.112282 --> 21.318977). Saving model ...\n",
+ "Epoch: 13 \tTraining Loss: 18.308497 \tValidation Loss: 21.576726\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 14 \tTraining Loss: 17.707600 \tValidation Loss: 22.016084\n",
+ "No improvement in validation loss for 2 epoch(s).\n",
+ "Early stopping triggered. Stopping training.\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",
+ "trigger = 2 # Number of epochs to wait before stopping\n",
+ "early_stop_counter = 0 # Counter for early stopping\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\n",
+ " early_stop_counter = 0 # Reset the counter if validation loss improves\n",
+ " else:\n",
+ " early_stop_counter += 1 # Increment the counter if no improvement\n",
+ " print(f\"No improvement in validation loss for {early_stop_counter} epoch(s).\")\n",
+ "\n",
+ " # Check for early stopping condition\n",
+ " if early_stop_counter >= trigger:\n",
+ " print(\"Early stopping triggered. Stopping training.\")\n",
+ " break"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "13e1df74",
+ "metadata": {
+ "id": "13e1df74"
+ },
+ "source": [
+ "Does overfit occur? If so, do an early stopping.\n",
+ "Yes at some point, the validation loss increases while the training loss is still decreasing. The gap between the training loss and the validation loss is increasing. This means the model is overfitting the training data and is not good on adapting to other data than the training data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d39df818",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 472
+ },
+ "id": "d39df818",
+ "outputId": "7e3f325a-39b7-4523-88af-4af0851786b5"
+ },
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ "<Figure size 640x480 with 1 Axes>"
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {}
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "n_epochs=15\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": {
+ "id": "11df8fd4"
+ },
+ "source": [
+ "Now loading the model with the lowest validation loss value\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "e93efdfc",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "e93efdfc",
+ "outputId": "8dd365da-a6d8-4011-9206-07f229ed322f"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stderr",
+ "text": [
+ "<ipython-input-9-bafb944717d7>:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
+ " model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Test Loss: 21.316800\n",
+ "\n",
+ "Test Accuracy of airplane: 65% (652/1000)\n",
+ "Test Accuracy of automobile: 73% (731/1000)\n",
+ "Test Accuracy of bird: 44% (448/1000)\n",
+ "Test Accuracy of cat: 48% (489/1000)\n",
+ "Test Accuracy of deer: 55% (551/1000)\n",
+ "Test Accuracy of dog: 40% (401/1000)\n",
+ "Test Accuracy of frog: 74% (745/1000)\n",
+ "Test Accuracy of horse: 76% (764/1000)\n",
+ "Test Accuracy of ship: 80% (802/1000)\n",
+ "Test Accuracy of truck: 68% (681/1000)\n",
+ "\n",
+ "Test Accuracy (Overall): 62% (6264/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": {
+ "id": "944991a2"
+ },
+ "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": "code",
+ "execution_count": 21,
+ "id": "3f0e1df3",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "3f0e1df3",
+ "outputId": "28dfbd9b-4c5c-41d0-b153-62b2d85a3a4a"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Net(\n",
+ " (conv1): Conv2d(3, 16, 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(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",
+ " (fc1): Linear(in_features=1024, out_features=512, bias=True)\n",
+ " (fc2): Linear(in_features=512, out_features=64, bias=True)\n",
+ " (fc3): Linear(in_features=64, out_features=10, bias=True)\n",
+ " (dropout): Dropout(p=0.5, inplace=False)\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, 3, padding=1)\n",
+ " self.pool = nn.MaxPool2d(2, 2)\n",
+ " self.conv2 = nn.Conv2d(16, 32, 3, padding=1)\n",
+ " self.conv3 = nn.Conv2d(32, 64, 3, padding=1)\n",
+ " self.fc1 = nn.Linear(64 * 4 * 4, 512)\n",
+ " self.fc2 = nn.Linear(512, 64)\n",
+ " self.fc3 = nn.Linear(64, 10)\n",
+ " self.dropout = nn.Dropout(0.5) #0.5 is a common value for dropout\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 = F.relu(self.fc1(x))\n",
+ " x = self.dropout(x)\n",
+ " x = F.relu(self.fc2(x))\n",
+ " x = self.dropout(x)\n",
+ " x = self.fc3(x)\n",
+ " return x\n",
+ "\n",
+ "\n",
+ "# create a complete CNN\n",
+ "model_2 = Net()\n",
+ "print(model_2)\n",
+ "# move tensors to GPU if CUDA is available\n",
+ "if train_on_gpu:\n",
+ " model_2.cuda()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "id": "aa2236d4",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "aa2236d4",
+ "outputId": "d1a7cab4-7d86-4a2f-ddcf-87db5f2001cf"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Epoch: 0 \tTraining Loss: 20.108037 \tValidation Loss: 18.833331\n",
+ "Validation loss decreased (inf --> 18.833331). Saving model ...\n",
+ "Epoch: 1 \tTraining Loss: 19.196221 \tValidation Loss: 18.523573\n",
+ "Validation loss decreased (18.833331 --> 18.523573). Saving model ...\n",
+ "Epoch: 2 \tTraining Loss: 18.362557 \tValidation Loss: 17.838665\n",
+ "Validation loss decreased (18.523573 --> 17.838665). Saving model ...\n",
+ "Epoch: 3 \tTraining Loss: 17.738212 \tValidation Loss: 17.422238\n",
+ "Validation loss decreased (17.838665 --> 17.422238). Saving model ...\n",
+ "Epoch: 4 \tTraining Loss: 16.772911 \tValidation Loss: 16.826992\n",
+ "Validation loss decreased (17.422238 --> 16.826992). Saving model ...\n",
+ "Epoch: 5 \tTraining Loss: 16.201394 \tValidation Loss: 16.889830\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 6 \tTraining Loss: 15.527665 \tValidation Loss: 16.168353\n",
+ "Validation loss decreased (16.826992 --> 16.168353). Saving model ...\n",
+ "Epoch: 7 \tTraining Loss: 14.886742 \tValidation Loss: 16.258967\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 8 \tTraining Loss: 14.350744 \tValidation Loss: 15.825301\n",
+ "Validation loss decreased (16.168353 --> 15.825301). Saving model ...\n",
+ "Epoch: 9 \tTraining Loss: 13.758344 \tValidation Loss: 16.022496\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 10 \tTraining Loss: 13.160968 \tValidation Loss: 15.681582\n",
+ "Validation loss decreased (15.825301 --> 15.681582). Saving model ...\n",
+ "Epoch: 11 \tTraining Loss: 12.707114 \tValidation Loss: 16.122889\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 12 \tTraining Loss: 12.219064 \tValidation Loss: 15.557430\n",
+ "Validation loss decreased (15.681582 --> 15.557430). Saving model ...\n",
+ "Epoch: 13 \tTraining Loss: 11.639842 \tValidation Loss: 16.094964\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 14 \tTraining Loss: 11.387620 \tValidation Loss: 16.256315\n",
+ "No improvement in validation loss for 2 epoch(s).\n",
+ "Early stopping triggered. Stopping training.\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch.optim as optim\n",
+ "criterion = nn.CrossEntropyLoss() # specify loss function\n",
+ "optimizer = optim.SGD(model_2.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",
+ "trigger = 2 # Number of epochs to wait before stopping\n",
+ "early_stop_counter = 0 # Counter for early stopping\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_2.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_2(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_2.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_2(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_2.state_dict(), \"model_2_cifar.pt\")\n",
+ " valid_loss_min = valid_loss\n",
+ " early_stop_counter = 0 # Reset the counter if validation loss improves\n",
+ " else:\n",
+ " early_stop_counter += 1 # Increment the counter if no improvement\n",
+ " print(f\"No improvement in validation loss for {early_stop_counter} epoch(s).\")\n",
+ "\n",
+ " # Check for early stopping condition\n",
+ " if early_stop_counter >= trigger:\n",
+ " print(\"Early stopping triggered. Stopping training.\")\n",
+ " break"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "id": "96d4a864",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 472
+ },
+ "id": "96d4a864",
+ "outputId": "589b4da8-e6f5-4cb4-96dd-12e4eca7d792"
+ },
+ "outputs": [
+ {
+ "output_type": "display_data",
+ "data": {
+ "text/plain": [
+ "<Figure size 640x480 with 1 Axes>"
+ ],
+ "image/png": "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\n"
+ },
+ "metadata": {}
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "n_epochs=15\n",
+ "\n",
+ "plt.plot(range(n_epochs), train_loss_list)\n",
+ "plt.xlabel(\"Epoch\")\n",
+ "plt.ylabel(\"Loss\")\n",
+ "plt.title(\"Performance of Model 2\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "id": "b86dd2c4",
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "b86dd2c4",
+ "outputId": "424f529e-fd29-49c4-8c40-bdae467cb077"
+ },
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stderr",
+ "text": [
+ "<ipython-input-28-e13c9b0c28d0>:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
+ " model_2.load_state_dict(torch.load(\"./model_2_cifar.pt\"))\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Test Loss: 15.748232\n",
+ "\n",
+ "Test Accuracy of airplane: 81% (818/1000)\n",
+ "Test Accuracy of automobile: 86% (867/1000)\n",
+ "Test Accuracy of bird: 54% (542/1000)\n",
+ "Test Accuracy of cat: 50% (500/1000)\n",
+ "Test Accuracy of deer: 77% (775/1000)\n",
+ "Test Accuracy of dog: 69% (696/1000)\n",
+ "Test Accuracy of frog: 81% (811/1000)\n",
+ "Test Accuracy of horse: 75% (750/1000)\n",
+ "Test Accuracy of ship: 82% (821/1000)\n",
+ "Test Accuracy of truck: 85% (858/1000)\n",
+ "\n",
+ "Test Accuracy (Overall): 74% (7438/10000)\n"
+ ]
+ }
+ ],
+ "source": [
+ "model_2.load_state_dict(torch.load(\"./model_2_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_2.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_2(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": "bc381cf4",
+ "metadata": {
+ "id": "bc381cf4"
+ },
+ "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": null,
+ "id": "ef623c26",
+ "metadata": {
+ "id": "ef623c26",
+ "outputId": "06062c2c-27c7-4359-b494-6554787edfe0"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "model: fp32 \t Size (KB): 2330.946\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "2330946"
+ ]
+ },
+ "execution_count": 42,
+ "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": {
+ "id": "05c4e9ad"
+ },
+ "source": [
+ "Post training quantization example"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c4c65d4b",
+ "metadata": {
+ "id": "c4c65d4b",
+ "outputId": "a739bc3b-adab-46e1-b32c-94c7e4e26d1b"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "model: int8 \t Size (KB): 76.522\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "76522"
+ ]
+ },
+ "execution_count": 15,
+ "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": {
+ "id": "7b108e17"
+ },
+ "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": null,
+ "id": "35135f12",
+ "metadata": {
+ "id": "35135f12",
+ "outputId": "fd00c58d-93f4-4a39-f2c7-a7ae2259593e"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/torch/autograd/__init__.py:266: UserWarning: quantized::linear_dynamic: an autograd kernel was not registered to the Autograd key(s) but we are trying to backprop through it. This may lead to silently incorrect behavior. This behavior is deprecated and will be removed in a future version of PyTorch. If your operator is differentiable, please ensure you have registered an autograd kernel to the correct Autograd key (e.g. DispatchKey::Autograd, DispatchKey::CompositeImplicitAutograd). If your operator is not differentiable, or to squash this warning and use the previous behavior, please register torch::CppFunction::makeFallthrough() to DispatchKey::Autograd. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/autograd_not_implemented_fallback.cpp:72.)\n",
+ " Variable._execution_engine.run_backward( # Calls into the C++ engine to run the backward pass\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch: 0 \tTraining Loss: 17.109160 \tValidation Loss: 17.287051\n",
+ "Validation loss decreased (inf --> 17.287051). Saving model ...\n",
+ "Epoch: 1 \tTraining Loss: 17.108934 \tValidation Loss: 17.279689\n",
+ "Validation loss decreased (17.287051 --> 17.279689). Saving model ...\n",
+ "Epoch: 2 \tTraining Loss: 17.114191 \tValidation Loss: 17.282382\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 3 \tTraining Loss: 17.112787 \tValidation Loss: 17.279775\n",
+ "No improvement in validation loss for 2 epoch(s).\n",
+ "Epoch: 4 \tTraining Loss: 17.114435 \tValidation Loss: 17.270469\n",
+ "Validation loss decreased (17.279689 --> 17.270469). Saving model ...\n",
+ "Epoch: 5 \tTraining Loss: 17.110570 \tValidation Loss: 17.282572\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 6 \tTraining Loss: 17.106720 \tValidation Loss: 17.281430\n",
+ "No improvement in validation loss for 2 epoch(s).\n",
+ "Epoch: 7 \tTraining Loss: 17.106561 \tValidation Loss: 17.282130\n",
+ "No improvement in validation loss for 3 epoch(s).\n",
+ "Early stopping triggered. Stopping training.\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch.optim as optim\n",
+ "\n",
+ "criterion = nn.CrossEntropyLoss() # specify loss function\n",
+ "optimizer = optim.SGD(quantized_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",
+ "trigger = 3 # Number of epochs to wait before stopping\n",
+ "early_stop_counter = 0 # Counter for early stopping\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",
+ " quantized_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 = quantized_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",
+ " quantized_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 = quantized_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(quantized_model.state_dict(), \"model_cifar_quantized.pt\")\n",
+ " valid_loss_min = valid_loss\n",
+ " early_stop_counter = 0 # Reset the counter if validation loss improves\n",
+ " else:\n",
+ " early_stop_counter += 1 # Increment the counter if no improvement\n",
+ " print(f\"No improvement in validation loss for {early_stop_counter} epoch(s).\")\n",
+ "\n",
+ " # Check for early stopping condition\n",
+ " if early_stop_counter >= trigger:\n",
+ " print(\"Early stopping triggered. Stopping training.\")\n",
+ " break"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2c5913bd",
+ "metadata": {
+ "id": "2c5913bd",
+ "outputId": "a50deb87-1f80-413c-f890-de399a047ef9"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Test Loss Model Quantized : 21.156928\n",
+ "\n",
+ "Test Accuracy Model Quantized of airplane: 70% (700/1000)\n",
+ "Test Accuracy Model Quantized of automobile: 77% (771/1000)\n",
+ "Test Accuracy Model Quantized of bird: 47% (475/1000)\n",
+ "Test Accuracy Model Quantized of cat: 43% (438/1000)\n",
+ "Test Accuracy Model Quantized of deer: 50% (503/1000)\n",
+ "Test Accuracy Model Quantized of dog: 55% (550/1000)\n",
+ "Test Accuracy Model Quantized of frog: 80% (802/1000)\n",
+ "Test Accuracy Model Quantized of horse: 66% (661/1000)\n",
+ "Test Accuracy Model Quantized of ship: 71% (719/1000)\n",
+ "Test Accuracy Model Quantized of truck: 77% (779/1000)\n",
+ "\n",
+ "Test Accuracy Model Quantized (Overall): 63% (6398/10000)\n"
+ ]
+ },
+ {
+ "ename": "RuntimeError",
+ "evalue": "Error(s) in loading state_dict for Net:\n\tMissing key(s) in state_dict: \"conv3.weight\", \"conv3.bias\", \"fc1.weight\", \"fc1.bias\", \"fc2.weight\", \"fc2.bias\", \"fc3.weight\", \"fc3.bias\". \n\tUnexpected key(s) in state_dict: \"fc1.scale\", \"fc1.zero_point\", \"fc1._packed_params.dtype\", \"fc1._packed_params._packed_params\", \"fc2.scale\", \"fc2.zero_point\", \"fc2._packed_params.dtype\", \"fc2._packed_params._packed_params\", \"fc3.scale\", \"fc3.zero_point\", \"fc3._packed_params.dtype\", \"fc3._packed_params._packed_params\". \n\tsize mismatch for conv1.weight: copying a param with shape torch.Size([6, 3, 5, 5]) from checkpoint, the shape in current model is torch.Size([16, 3, 3, 3]).\n\tsize mismatch for conv1.bias: copying a param with shape torch.Size([6]) from checkpoint, the shape in current model is torch.Size([16]).\n\tsize mismatch for conv2.weight: copying a param with shape torch.Size([16, 6, 5, 5]) from checkpoint, the shape in current model is torch.Size([32, 16, 3, 3]).\n\tsize mismatch for conv2.bias: copying a param with shape torch.Size([16]) from checkpoint, the shape in current model is torch.Size([32]).",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m/var/folders/c_/bcjgdb5j6wq89qpwvs1rl29h0000gn/T/ipykernel_27875/2110516623.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 60\u001b[0m )\n\u001b[1;32m 61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 62\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload_state_dict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"./model_cifar.pt\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 63\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 64\u001b[0m \u001b[0;31m# track test loss\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36mload_state_dict\u001b[0;34m(self, state_dict, strict, assign)\u001b[0m\n\u001b[1;32m 2151\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2152\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0merror_msgs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2153\u001b[0;31m raise RuntimeError('Error(s) in loading state_dict for {}:\\n\\t{}'.format(\n\u001b[0m\u001b[1;32m 2154\u001b[0m self.__class__.__name__, \"\\n\\t\".join(error_msgs)))\n\u001b[1;32m 2155\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_IncompatibleKeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmissing_keys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0munexpected_keys\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mRuntimeError\u001b[0m: Error(s) in loading state_dict for Net:\n\tMissing key(s) in state_dict: \"conv3.weight\", \"conv3.bias\", \"fc1.weight\", \"fc1.bias\", \"fc2.weight\", \"fc2.bias\", \"fc3.weight\", \"fc3.bias\". \n\tUnexpected key(s) in state_dict: \"fc1.scale\", \"fc1.zero_point\", \"fc1._packed_params.dtype\", \"fc1._packed_params._packed_params\", \"fc2.scale\", \"fc2.zero_point\", \"fc2._packed_params.dtype\", \"fc2._packed_params._packed_params\", \"fc3.scale\", \"fc3.zero_point\", \"fc3._packed_params.dtype\", \"fc3._packed_params._packed_params\". \n\tsize mismatch for conv1.weight: copying a param with shape torch.Size([6, 3, 5, 5]) from checkpoint, the shape in current model is torch.Size([16, 3, 3, 3]).\n\tsize mismatch for conv1.bias: copying a param with shape torch.Size([6]) from checkpoint, the shape in current model is torch.Size([16]).\n\tsize mismatch for conv2.weight: copying a param with shape torch.Size([16, 6, 5, 5]) from checkpoint, the shape in current model is torch.Size([32, 16, 3, 3]).\n\tsize mismatch for conv2.bias: copying a param with shape torch.Size([16]) from checkpoint, the shape in current model is torch.Size([32])."
+ ]
+ }
+ ],
+ "source": [
+ "quantized_model.load_state_dict(torch.load(\"./model_cifar_quantized.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",
+ "quantized_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 = quantized_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 Model Quantized : {:.6f}\\n\".format(test_loss))\n",
+ "\n",
+ "for i in range(10):\n",
+ " if class_total[i] > 0:\n",
+ " print(\n",
+ " \"Test Accuracy Model Quantized 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 Model Quantized of %5s: N/A (no training examples)\" % (classes[i]))\n",
+ "\n",
+ "print(\n",
+ " \"\\nTest Accuracy Model Quantized (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",
+ "\n",
+ "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 Initial Model : {:.6f}\\n\".format(test_loss))\n",
+ "\n",
+ "for i in range(10):\n",
+ " if class_total[i] > 0:\n",
+ " print(\n",
+ " \"Test Accuracy Initial Model 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 Initial Model of %5s: N/A (no training examples)\" % (classes[i]))\n",
+ "\n",
+ "print(\n",
+ " \"\\nTest Accuracy Initial Model (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": "code",
+ "execution_count": null,
+ "id": "748b1915",
+ "metadata": {
+ "id": "748b1915"
+ },
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a0a34b90",
+ "metadata": {
+ "id": "a0a34b90"
+ },
+ "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": {
+ "id": "201470f9"
+ },
+ "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": {
+ "id": "b4d13080",
+ "outputId": "8b9c7dbb-d743-48e0-9a07-693fa5a54631"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/opt/anaconda3/envs/infa4/lib/python3.8/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",
+ "/opt/anaconda3/envs/infa4/lib/python3.8/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 /Users/paulineramage/.cache/torch/hub/checkpoints/resnet50-0676ba61.pth\n",
+ "100.0%\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Predicted class is: Golden Retriever\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQ8AAAGKCAYAAAASUsRVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOy9265mSZLn9XP3tb7DPu84ZESeqqq7qnroZtAgAeKaCx4AiXfgZRCXXMILcM0ICQnNBRJIAz09zGhm6KmuqqzMyMzIjNix9/5O6+BuXJj54dtZXZUdmfSAtD0VEfmdfPny5W5u9re/mTkRER7bY3tsj+3v2Py/6wE8tsf22P7/2R6Fx2N7bI/tvdqj8Hhsj+2xvVd7FB6P7bE9tvdqj8LjsT22x/Ze7VF4PLbH9tjeqz0Kj8f22B7be7VH4fHYHttje6/Wve8PU0q8evWK8/NznHM/5pge22N7bP+Omohwf3/PRx99hPd/WLd4b+Hx6tUrPv300/f9+WN7bI/t/8Ptd7/7HZ988skf/M57C4/z83MA/rv//n/i5OQUR4IU8c7Y7k4gQUr20gnOOZwPQKodOc+cVMIJHu8dznn7jcM5imbjvCBJcNapIIgICCTydxyOVhMSvZ6k8jKJQHMNnG9+IYAD6jjEe8CDMfljasaPvi0iiN2XJB1XltwPNTPnnF7FUfp09m/tWe+9DR4QsfvV0SCSbLw6YpxDHtw9SNOH4B048hszHrF+9Fk5XB1vfmbOles+vBcRfSZ1mFLeL5/nSbJP83zpNZNdv7lZgSSJaONykvSZ5d9I0t81z0EklZ/XPuuogoMueIJ35RrzPDNOMwD7aUBiZI55LoQ4C1NeaymWecq345wH50ipjkvXfJ4rAYQQdJt53+E8OFsX3gW8d2WdiEQdawh0obffeETE+tL5D11X74NATDN55Tjn8Ti64MtrcHRdRwiheUpO5xQ47AcOmxu2968ZhoH/+r/9b8r+/kPtvYVHXkSnp+ecnJwhadYFUaSFbsK8LcVeBx/Kb+12EfJrFQQ+Cwvn0HnNCzHiSHiqIND9VzeVwO8RBlI2pzSCwy5CcoEK/+SN7fA+jyPolrRxRVQWtZtS+zXhElO7bo/mq/1/7xx523lU6FDuXf/EvJ/keNNJSgiCb36PE5Ko4MudFGGe33VSBKlDQCbIiz/l6+axSttV20tpKSb9efO2NBvdZqfOh/1vKsJcyiFQDglUQMcY7XVCRIizvs7CI5UuEq1MSympgJdUNrxzjkVw9J0ueecdcRb6eQBgOa2Yp5nZOp1TIkVhmudyT3pbeX2rEEgJRFy9z1TXgRMTIDa44AM065/ybOvaDCZMQmfCwxZCvj3nhL7viyDw3pGSI8bJvhHxflHWbhc6vNd95/NvnCM1j2S9OmW/WNF3HYfDvszXH2vvLTy+05zHdj5gC526OexLJBw+b1Th6KHrNq935UVMoORVkvAuNtcQfBLbBPYAnFMtKCtA1mc+pfR1Mm1Cx50XBvm79hDzyFV4103pCYiD9HB+bRF13hNFSLEu3KOvmVbinGsQ64T3VXsxHYB6UDpUXOTJ0d8G32zS6I7kYtWiUvNKaEQDiNf5QhdmauaSvKEdOHHlO0fzJXYw5GEkOZYvIu3U4bx+JUizTooaVuenjdeMQl0DgMchzuN91gqa+0Efg+AQcUf3OichWL9BPKHzeNEt0InOeLDOfIzEkPBlqTo9FMpB5kiSEEfR9cSkb34GjlQ0N713j3dVo02SD4F63zE5nHekvF6DzyeijuuBNuucx3shb+U5JlKacK63ayS8fZb3QPL1twCh8yzXK2K8QsKS79t+sPBIJhBwQRdmWezH6mtW1fUktQdoEjVPngfSAxVZpWQ9jcGRJvvc67IPiE0geKcbLJsx2azx+YE1Wg1AEjUPYr6hrPpKY0qkqJK+bJhk6mGzcY8P26NraB+pahymikaEUMyOiCAUq89BTM2eEtWm6qKx8WVZ4iF5/V4ZUzmx8kPJ2lm+kaRjSa1aIPV1fhaNPMjjSe3NHml+YmKviN6jORGRo3USJd+TUDemPq+snYiYDps3cpzxrpFX9t1ixohpVY1QkxSZEfrONgweh2PR2yYLHuliMUm7KTHGibmYFOB8ImuoKSabPylmSkQ3ZBXoXk0Ueyb5fD2at/bxeF/WaRFAQYVj0cb98fp1Jpnz+u9YkOKE2Iqeoz2bvsOjmoceBAKSNTkPHrr1mu6hyvwH2qOr9rE9tsf2Xu0Hax6tiumyoQ6mdrmsyRtQx/FpbaBgbg6Hl2rolLOr2MJBT2DDfbwHidHOrAy6JlUPJWsWehaKy6pllvbBvu9J0mAkTjKQAkV7cTSHvN5XayolQUxTKOOWOu6HKVNijEcaRO21OadtHrI9DRHB4bNm4Zzec2PWOBv7saFY/8a0Fak3q9fPtlFyeio12kWLRZSbc/Un5KlqLupIjTbzUA9JIK6YZ1npOJ4jKRoMZDynMWu8x0kqz9x5wSWPOD1JvVlqLSiYtYP9OGonS0fnXQEevQ/MUs0WupnO97gMoErCB08yFTV5fRYpJVzMQGdnWlMzF65qpCm5Y2A9Pwv7Quc8Pqi2nVekE0cXGpzEzOrYmMTeh/IAQvBE70lpsGskYnQ4lwgZRJVqxup3IiA47wuY+33aj4d5oCZMUZR9aJaMKaUiBhJay+BcWVnyAO3Pa0ZKH6qv2oJQyJtIIluOwXftDxEnrRywzeWJ7RveFROlAIaSjjb/HKV6X5ypqlK3xBEo+LA5tWPzhsobUqSqvBVXqfPlqCZcvoeCiUiea1ev4dQOb00KaUwEr2gPwd6YRYgiR6qygwp6p2RmlHwXnHqA9xR1GjFPRGMqNeNxzjCS5ogoJm4DIjkEb4eEJG8eFLsPAwl5IHCqIl0BVO/N3pdISpF51nsb3Ag9IKbK53WZzRQ6vEs4l70viZRiNW+TgvDZu9HMRF0GAuIaTx8OUvXWZQEZXPa+VDwjA57eqfclg51IxDnK5yGoh7KAtiL22syxNAGJcYp0kgWl4i5FYIuOJaYKSn+f9iNoHmYPNhIUQIHIuuZcswDLeyaWq3uX5tQHlbIN4IQJIdMaEpDMDVukvasnM+STtgJ8zlSgUASQXid/XydW0COhujAb8WX33WIDekJII0ycc0WgufKe9eJgmibiONDZmliterq+K/hOnD0xSYE3q5DNfSa719Zr4TIKdzTn5eTL3qAyTq8nk10zONNEGm9QMpWrehlUEH4Xja8CQDXQclFabwGSEGKzcMUW/jFI6qnz553TUz9VDKQcPFRhnMHElGID6tq9mLuU4npNxDkiBrp6HwyQrs07DyGvpxkpuk6eCt200TSelOIRsKFAfaP1ihANZNV79HQhFDzDG+bhvS/CuAuevu8akNUjKZKhdtWKqz4f44RIqkIziblyYZ5Nw+m6AnzrI/J6eB6pvn+8/WiahxTdNaNaWdo2G8hl74G0H7Va9bEZRDpa/Hp2uvJDRaftxLdjasZUPpG267KYdQFUzQQbT7vxMTD0mM6RirZSQMSygXTWCwib1JVYvELN/YPu72kYmIc76A/axWKFl3Ni6u0aAVwoUyRQtKM8HojklZgVfZCiluq1qn/FOd9I+txroOUveBEykKZzkTdnFXyOlsuQ7ztrnJCkCgfdBMcalbqpmnEXaXCsuhWA2TQ0V567dpSk2bT6zXKfXUjE1Gh2knU5O3hSYmIuIKI3LaK9Lz3B8zpyBO+L90UtFZ3bqkm7o9tIIhAglnHOELzOMao1BN/RmWALQT1wwTxxuUtVCXWcwUH0XTkABPdAC26fCbhuiZv1kCjrL0Y1T0zAeNcrwCq6Hr5vewRMH9tje2zv1X4EzcOOAdMqsvngJDMXqwQVaIA0VHXCFS0lSSK4RpaLMzQhS9nsmM0mib4S78BllVZPtWMFtNqdznv7rD2NOTr1HGpKJeoJraddPflacDibJEfnpqOOQbItmlXNxDxPxGHDePgCgJvDnm59zfpEKf/eXTCnBZi/Xm3y1s53+MakSy1qWf7JGpHNQso8BftNfm55lpJqbUUJLiZkqw0eQzvfMV/c8SmomuRc8aLvAMEZPJX6nhPzsppabYzdSiwzAlg0AldSp3fGJ8AbkayOI4piFq557jHFMhfiPa5Ze4IrRDNsGrIJByimV7Riw03Mf5znRGFMQZJ+3uFJUnk2IXR0oS8mivcexJmWQHlGqo1kW8fhU2OKUqEDHaiBp8U28tB1EGey+zaJQEoE11oHyhf5Y/EsbfvBwiOrSCo4GsDLQLHK96D824JprTqvHIM6cSoQXF2tAhALIpwJOkfaroia2Y3A8a3HQBSkSs3nSsby5SJOopk3WajpAoiN3a9dVXtZhGLb5h0mRQXO9nGjEnc9B5aMk9GAE8h0R5K3AHRdTxRPv8g0ZbWdM2DqxZFcI4xNJuj69eW6ZdrQDUSzKavNWzEO9VDo97MQqZvEruePvWQPm0jt+yHhq4znyAviTDC0A24wJRNehQaeUjV1qHObhY9zQpJ8yORDQ3k60QSOAvNV/Q9iRkjjKknSHgiOLJR0+IpvKEht3wdc8EdrCXFlk/lFb9czEyR4Ba/LNQ3ElPlorQieOYOd4s3NaNhY1PsuI81LsOWB5DMn5UNjUrA3c1r6CE6JaZ6/R8D0qDULE9DJPfJI5AVdBYq4Y1s+OV9PINFYjCodWv/NsZbx3YiO8iUSQpdt9mTXcPXzzEYECD6pGzBVajMiBFyxESt2nu9DSWPNMCngJXlfV/elAKHrWawuGArwdYb3if3e7N8u0i0gyGwT4w1hzwtAiUqFOetcobtX7KVeL8+KuqrzBvD2/WOty9k1k4gh+6G4+fLGbkHso3mX/G6+r9ne+/14hsIwD5+fOzo8y+vi3g3gxFyUMM9RH2xeNk7A6bdjWUtZiOQ4E6daqLlZRaz3B4TEwh7NYy7sUZ2/mBrXtwnNmAW8bVwfsqZseFx2IzklQFZtSOcvNkpkMMEdynwrtaDO47HiXPdfPuD0XeeE2B6gztXYoRQL0aHiXX+8PWIej+2xPbb3aj/cbKGaxnJ0eKjLKjUnircfVPdyI7LJ6rarqqNJx3oAfRdb+G7Eau5PmteOuUHRpTGF9HBoTq1kEW+uqt4OEBdxkv3xeqIUaS968uVxVRdtdguKnSa1Py+Jrg9EOQEgzj0pzVXrSh0uRSbjNAVD/zMVwmGaQWMeJLK56Mp7vp2vxpzIs6QGnGkqLtmzNLIV2OmecK4GlD3s4yHGcfxMfMW28ncbb0DjbC4tmyGuaFVqQPWG/8SUyWt63c51asoUt3UiWRBlV+KgTMtw2fSJSIw10tTlCO5jk+/YNHLFlM1Oq5bkJRKPPWLKXygarIizH9l9iVeNNV/D8Cnna7yRoEGbudfZ+C6+ePLMRi7rQnk7QvsMLM4nB+z5BchYTLB5numCjUIePo2/vf1wnkeKBljpjVQV+LuDiEXdPdLz6qZLJhyK5tVCm2reuCYQTB+MfVYm7zhehvxoGiDo+BsCkr5r34uqiKD8CIliAJv2kBoBlTkJrcIoqQJ8LpPKGqxBvWux8Dw8HTE1/FsHkubijhSXN51d0+lirKaJgJjZlTeI6DOpGId+v4VmUhPI1gX930xiCiToOrxf1LHnsTUS6WEUbb7H2hqjxARHM/vH9nn5rTsG73wlNYWyRvLDTwZ8u3LfnYhZmXUc0TnmKVNEY541m0+NnC4b3VbekRh0lIWWUgWp27geaUz3FCvRsNxsA3IrQVjKELMZHgqnB13vrhVmx4e0K3/Za9ED2Jd14phFTb0CjXuPJI/Eg91LJNp1W4fGH2s/XHjMIzIPdMHbxNWVKa1UNY3giBWJ4gVZ2iknNTRStNqB+kZ+UA1jzwRSBakq81S/8V1CU4sEKBzlSDn820EGwsp3kl4b0bDnOeUTVj+PUheb3pNqBMVGl0RWaPT7qd5Yk/tBdbWqnThRQCy/0axdSnxnI7GSCHFORSBlQZ35KtHAy0JKQkrIv02czV0WPlF1R0cVWj7QrubfV620MdlNGKfmHWi5BD6Dnc2nzmVCe8UbdB7rk/OuTJ3lT2nC8pOSBlvwUxQ4QLL2KF61j0I8C4iv9+kQgvfNGHQT++rQUWJgomo8hjkdOweaeTEMqfJXMmu2Cs9MoC6sVUnG+8iohB3Tzfzr9slgTAZ987qCDkGCKwxenbuO0YbtJTFHR3QwpkfM47E9tsf2/3L7wZpH5yKdi3jzOJTmPMklUvaBq+2g/19UC1N3M7cfNBbAVTu0NSlE1ETKTU8gh/hwxBtQl1cdSmw0Hf30OOpGpAaqIXZiua7apj5CTAULmOf0wLbPrsLmIs1pW92Vdlok1+gXpQcNqy+u9+xWtZexAVnsvtWEy+PWPCniWzMlB7dldV41omyWKEnSl9MxJsEHV4KugmkZHq8eDcC5qFpek1fioaereMmg4EvtmKRB9HN0eJsDrc6jnchSXf5lPqn5UiSzbVP1ckiBFlzpy4krSs8c1Uwun3sNdcjaTWYp931oxi05FIaUVANtdO086HoDD7SzTGt4MFvtxJF3x3Ho/TFfqsU4QLdP5bgca+vOZU9Niz86nE905gWaZylb8e8AefwYgKkUFS8DiaALs3OB2dTERKXcHm1cX9250UyasnhEbdECRUpNiQONGiuOmJq+XbVdddHUTdYFc0+mvPgbewLMttYRZ3xFoqrFbRav1jQs1O1WXz1SxLP6nq+R5UAVMA8jWJ0BzmVDtb/HyENSVUe9xezzz9dUolQoX0pHgXPZfMkxD97Bxx884cn1WXkAKSW64PHWybu7Hfv9yBxrvohsDukzARccyeyhlJJh562aHSvukqPxGjyrQChlOh8Qy5y6nI9inhoafp0Pipmi16pAY2e5NuYpg4YR5ykAq/MenD+KO4lJ6lp00Hl0/ZbUhTrfOV4mZzYp676JJ/lDrTUTnfPmJs8mW0bsqoteQez8Y46xG6lrr+I52kdnWdUEQebZ9tf3bz9YeChLrqtSNdvkZpDnXIqR1stR79S5mowmCUa0qvZeagNMfMAn30xc/mYFGjM3QTJqblnFihMjpcL8A7X3LKTVrqELzuEoPm/DJlpgzD6wj/V0aBfGEWZS+rfTW9Aw8hawExOeDWmgTVmgqfge2NCpQX9cRvW9BgsCnS1wV2xywQU4sQQ45+s1JycrFosFAKtlx5OrU66uTnWu4sg8TyC+aAvPr3rGKZFM+O72kc1+KM+w64K5UGIeOCklhkG5I9M840TYD/r5OKsgSRKrByGDuDafqfxvliZ5zrPA8hxn2lHJozhIq4UlsnPFh0AcoyX4gZBxriNtwWKnUIpP1/lyeidJxGhr4UhA1ZgoFWCuCKAkFe+o3z/G5Oo+qkLryIGT/2qEhYg0kb16Dw+xltRo7N7pYRDnnOowEp3ifkf77Y+0R8zjsT22x/Ze7UfjeUC2qe19h/m99bX6njtwrmY6z7+zf2tcqJ0o3mMcbP1eEhI1wlCZ0jn6JaubrqhuYCdUk/R3FsD5qsqbzC5mTrJTvolz8M5ZuHSmNh/b4MfuZ74jvbO1GdrM8jZz+Rp6LzW5j9KeG3PA6XWL1mz5GCrMJAU7qBiRnkjZfl52PSfLBRdnKwBePL/k4uKExaJqO9M0sN3ekgeVUiLFmczziNOApKm4UZ9cnnN9eVaeYvBCmrYl+7fzFhmcf28ejsk0l3mKvLs78PZ2z3YY6/y5xg0tGQ2oGmcLLUh5L68r9aTEWDVX7z1dFwreM88a1h68RTGnqDkzspYQU+OahxAsIrc85oD3mkYyn+qzHJslZUhHz7BqNw8jksvvfMvT8EdckhKLdZRnv8E4ynXy3GiSn4AreKGY5ubLJugJwZFCOLrnP9Z+OD3dA5ZL1ElNLOPB8pFWd2Vxg2bVLxsdjf1bHZxUwlZj39k39Xc+ZypraMRmK8vRb1wGGdS9Rp3smOHT7MIr9OOWY6Dcf+dzAFRC5gZkdVUI5D58cx92N3WJHKmu1cXWkrSdd/ROSvIakUTnHwiTBqAW1EfvqLlN+j6wWgTOT5SI9vzJJU+enrJaGQiYZuK8Z7/Va0zjiMRU7lOSmhISI3MyTkDUzZ9p3/N8a3k684ROIJHFalWeUUqx5GARv9TBG8dg4R0vrhecr+Cbd9rnu+3M7jA1uWuFVnfXxT9TzJZs/pav5DlyBfB0jTACA4MbvCtaGYX8bHJO0ILhJczkyWvWK/qWpiLU9PnUJytyXKbDmZQLRpF3xVTKzzE/w3qAlkC6PL0p4kNNXqVYkS8mH4YZ5n2YsTJpnAiFmGY/6cICRyD6RBe/v9nyI2ge+l8AoqMyIBswK/+rSWDa93TzuyJwdPKDbajZMoS1mcWOgJ/kaGD9fGFylGZ+X5x7sNEouIAXTGJUgK/Ma5tYyCewpC+dA0Kbc6HGlWgf3kItbGGmhKcmWfZlfqrQEZNo7ojMRrXRk7N7yRvjeHGXu25wkS4EVv2STz98CsDT5+c4lxhHTVE3DwMS58p1mCPDYajz7T1pPOC8kEpq/0Cc5nJqDQcdU9ctrI+BbhEY9wcbZ8dufyjJeHzoEaBfKq4Sug7SyHLh+clLfe/DKfLmbuL1jZYB2A0zbV0WDMto+T++4TakpEFnXegLsBujpi2st5a9UKZdBn0SKQPvQWGbEgiXZ7lZZ9qPL8F2PmMNtm6mTBKTegC0AZKdBTu2sUUKyLmKZXEc0a3kn7YsiLeDLc+N/upImzFBWwRMDqwrgJv+pSk+Zr5ve8Q8Httje2zv1X642WJ+NeccXePzFyi5hMGgCxEcsfGE5NiMxsRwVWXrvIU7m4TMIdLS2MJYCv0Sjk0C3zDw3JEMNg9KxhxMLUyNm69IZN+YME5fZ8HtnJZMODr8q9ERnCM6qVG1SY64Jt4lvDsmtWdORuM+IcoxlVweOOEdyViQOsbQqQ29NBfc8yfnfPzhNWfnFg0cD8zDyGSaR5wm4jxanku9BxHHYa+fh64HEcbtfTk9iZF5mopTSKLG/ISV1vsIEvGLJXFUzeMwDsxTJCyW9vPEyflTzjrVMpyH0J8Susq+WfqRl08DJ0t9/frtnpttrKlVxSGpeT5O10m2SoK5Lqe5FobS+iY1UXDOUXvE1JRUTvCYHC6EEs8UZ12n+Zo5lYC6UvP8RtO8bR14xSeyxik2v137mrqeOfKuUcaV9wWYdtOYyLruqklSgosz70MqSFAqA8aI8x05qxrJmRrxdyB58KPlMNVJ8DiqKz4nOz5a/VWrwlSyRPHvq8npilswF+3J+SniselreSXyKrZNmP9usUkqBtK1AKNdtO2yrZpUMJmyME1Aecd30h4kiiqrYe6VR+FMHolxHyanLmLvqnAAdRfWwch3/vE5jaDdl/OVlp+LNV2drvnZp88AeP5shffCPKkwGHYb5jkyD7qx46x1SmS2VIhpAueYDgpcDuIJIRDHgWSV1WKC6bAhLNY6N75jGgdcFha7e07PL9hu7m1cgeX6hMNmB8D55XMurq7pFrpw1+slPnirOJjNVc847lh6FWofXTkW/ZKv36oZI7neTJPTAkepyTLPiTGaul+SEGUz0kwIr/vr2HPqywbzVvMlrzcV7HN57VwHLhiXL0sxrWLU1psR5Q2UuWoeqR4OR6C4K2ZnXqe67KoZ4gVo8p66RuAATGLBlQ0epzeQCMXCt13SvPYp42Z87/bDhUf+YxvE19klSWUaUm6oBbZ8ITuBwRe5MyxLWCtnDXAqdWbzxV1LMBIru9DOgisGmmDJgxo7MxNp2sto/2ZDAy0XRBPyhpJpuhCdskTJ+EU5LZRgVISmeKJE5sY/n4lBTcIoTA0rozqO11BGqneZO+K4vDjjF3/ynKvLnJdzYN4PHO41wdBue0uaxnpKSSDhiZNuynkacM4zH1QQ7HZ7QrekW5wwmXDolwvFEUwgRQbmOTJa+G+i4357ABQDWa8XzNPIxfUHAFw/OacPkYWzcOFxxxA9MYXjBMZxLuUmY5q5XnvkUvt8ezeyn+vzVU+IYxhzrlDV7Fr57pxqC1XTy5nhc5yNYR9NxUOS4nj6JBS7qES/nIWsKQaGHnglyZKRymoGuTyYPP9iB2qD1dhSyuCuVhYEl1nXhCONKa+GjLuQy766XI5S51UIZN5S51wpUKXPrEav/11oYj9CxTitfObNPmhvyrlSVdZUcE1yVyf7GEnWqNomJXyNdQWgD47JgtK0Ayvb2OgORwlk8v+1WgDHp0EGZH8fO7ElkSuTzyZbPK6pvVL0ncKiNGAs30XWPBqV16N1To9wLUlVxU2ehrqm/bm6ADN5KC/2j14+5ZMPLzhZCy6N1kdiHnbcf/s7AHb370j0+C4n0ZmJsakJ65fEaWDafQvA/iDMdKxWq+I18LsFwzCwWBoLNYEPMJrAWZ4/RZKwNo8OceL86przMzVbfDogc2K/V61imCbC6ozV6qREgkYc8zwXTc15x3jYcW4u5XHdMdxJMSHm5ImpATvtgMpnkT4DBSFznynO5gnS1yGoGI+NmeNcZeeW8o/ZlZsSIjPi2nSHclQZMASPl+akRzfqUYY0qlYcMqHM1SxqkhIEKQB18bLl4MWoToiaUS7Reg+dWKKLpuaMhQcfeZ/yUvy7GC6PgOlje2yP7b3aj+aqzdpAEW7e0XjPSg0QoSbDdaa2ZzAxSQa+GnsOSicp+yIzviE5xW9zgDuFIXMxbcUbGs1Ef1g1pJLKMH9ByDT7rI2Iw0DVppem3+O0A1QCl43Bu6hJMu17EaU9e9/2qTK/zy7AzmDaBtKx9KE2F8Lpes0vfqbmwMsXp4S0Zzrc19SEkti8+YL7bz/XPheXSOgLBnLYH8wNaipySIz7HcNGSWLOrximiWF/T2cYxxz3dF3H3Knm0PmOcTiU2iBpuAW/IM66tE7PTul8ZBo2+vncIfudkv1QDYphyzDfs9+r+TSNM93qvMYuxZlZHM7U7ifrHu/WfHlbHZo6l/m+beG5VvdQdb1c1zSL4/wo5as1dinzlIJHIuU+JaV6SpciuqorSjGFnLlvKwCXCW/5kUdDC6HRPJBiTXmnc5RTLmLu5qp8WyrKnOjN6J0AACAASURBVKzJ9Yph5PXv85iAUDEXkUq1xzkLPmxn64+3Hyw8PJqHIxXXSlXRjkhPUKuulAK7IC408QKOKNWXXrJWNQlvNFlx06lEA5VyRa2cVDkLGNvkbSEkKm5CI/jAzJMH9UO8fEdEFW5HHuexBZrLAWYdOL9tKrJOhgaUNapj5x0+NPayVLGmi6jauh9cnvHLP33B1aWBhMM983RA4oQz78nm3Q03r79kiErYCqkjjhvmUTfpYb9hd5hLrRgf9tzfvSFkQlfaKSHMuxLgKOKJ84jv1VvSLZYcNjdsNzcAbDc919cvcUGf8bTfM2+hX5o3ZnFG0gwT+toLEiPjsGVv3BDfrZH0FYtOx7U8eUK/WhYm57DZcb7YIxeXAHx9DznvhY5bgxpLadHyzCjf8bEjptZYzTsymwtixaPyp0kfQi0ZZ16davKKg+D7xmlQTd66DtS7p4NQAdbUFW9IjfXY1MTXrdBzZS5KbaN8yLjeDt3GAHFOi0UVz5IBoy32Alq69e+VJGYxSRm8bCcuNan59HxuA3gwLcEzF5zRANLmpo5C2UWsNEO+Rn46DU6SD5vifUlHKHsSHqSXz5Xt8sOSSmTL4yjDbYGvCm4eLRCaACipr4/TP+nx453Hu0q5DqHiJs5ZkYlsP1td1Q8/uAbgl3/6gtUyMR70RI/7O2QeCL5jPqhnY9rfK4YxqTCZHAybb5l26gm5v79nTIHDrBu773skCWPU38dhS9+dgHMswtLuZaLv13R2EnYuEaeRw0GvcXp6iveO/UZxk51E+sUZK1uUfhqZWYBX8LNjZLu5YZ5SxRu45/7ujs7rKX95ccnJxTM6c/d63zPuBs6XunDWT5/y+j6wNS9RcLb+kGbafTnAAMRKLuZnnJIWLa0Z2vO6q4dQxvG0Oyun6pylLlD3LkdgpjKuczY4rNJb2cTO4Vw4qm2b8gGZy0ma5hCawy6JkArdobdCW6ax2vulpKUkkBq4CnrYBQfO7jU61NsVh5Jd7Pu0R8zjsT22x/Ze7UfDPDqnuRKl5O+wEz7VE1/p6FLsTk3zU0PIpZp/+jqpz7y4Lyk6SL44+YeZzCMPPvMiGleTNY/sKi6oes6bWlxA9k9jvng9RSpnxR0RdyrRSF+nJBYuX7GZh6dYMFJO645vafQ1pL/qtM+uzvn5T54D0PeRab9lNC0ijQPLTpDxjt29vvfm1V9z9+YVsdPaMNv9jt1ux+7+1l7v6ZeXsPzA7jkSpwNxtnSLw8j56QIhcdjZOMKCvl/jRE8oiTPzNNCbNhfjnt32HUym/Uwj/UqwlCEshsjusMOvrvTzzZfc3e8QhGmsJq/vem6++i0AF2fnvPxoy3JtqQNOr3H9imE0beccPr56ylcbxWVu7zYENLaq4mdqHMdWnW9oA6r1eCphEQO7pDwPkdTgW7bymyC2rtPkSa3m0ZopKfkHnj2jp1NeNmRH0yRsLDWAUkMvurzmQjCNPO8M40llExk0wRZCyWQkSU1tS0fQCYhXAtz8d1AnfrirVjTvpWIXvjws0AQ92X2mZoCj8j1+HzgjBqLqJ7NowaaQ97DXBe6bTOg6LaGBPIWW6FXrvVYmpkXzkYfkGnJQO5ZqLh0PVlByVjpioNbYFuecYmeNS5m6DslokLp/mz7q1Ji9XiMfn16c8ZOPn7JYWlTosGHc3JeN3jPDNHDY7bl5rQDpZ7/+Na+//DV+oYFxp9cfsTtMjNHAte6USIcMO5uhBeKWhRAmricxM+wH1ufax2pxQh8Whfex3+zxYZGxOMb9nrFb4y1adYye6SBEM0F6drx78xXSmel0+4rNzTcEF5BOsZl+sUTiTNct7RE67m7fshyMpTpPLE/Oa6KpFDnF8eGZmnRezri525qZUcH2nASpPt8mx4UP6kI/4mQ0p5kAvkkyJTmrfGV8aphJjXnKHA5XrqHHXxmH6DopyZkwnA9XCF0181jGvpp1TraGj+kPQhWatqxs3A3XdQ5NfIxT/CUEuhxM9T3ajyA87A9608nXi0uqaf1V4kozGXoit1moMPp6GVzBKPPpmwhNCjtnmHJqUPPMVqsglYIyR4KqIXDpPWgSHftQUfuyePKXjuBSFS1tCcWHoCsY6p9pylI7MDxECw9VYQv1O8E7Ou9ZrXXDfPDklIuLjjRtATjc3xLnSJcU8/AeNrvI6y9+x1evvgbg23vYuyfErf5Gujvc6gxEhUXoViTXl8XfL1YcdrdMJpA8M/udo1+dE0LGRdYsetjtduQZCkFYrXu7j4hIZLfX57RYnzKPB3amIbm4Z7Mbcb2Ctnc3W+7f7UgSWSxVc0hxYtn3LHpdntPdQP/Jn7G++BCA7XYLskFsh90dDiSJrO1QeXHxlK674Nt3m7pRnfKBsicqr8yKVUXaoLW6nvKJ32qR1gRijPXUd65Q0vVjy7IXWq2grovcU2gOu7zkaxpC6ymPKw8pa9aZvFgWpyYjciGnrTAeU5pLcGNKswn3nDZBr991wbSn79ceMY/H9tge23u1H05Pdx3JdUQNFSunWD6NWzUcAfHV/YWzcnq5s5y3s2AIUj0q+gatTSkC0QU8NeCp2o9mZx6pqjRYReNKkQYrkeyskZbBbsh5/oo3b1KrQjZ6iTM0u8hmPeekRmkVm7nauMfNBY8LsLZ8FOcXK5wcCgdjniKdmwmmqe3uD7z6/DO++uoLbm7uAIhhxRQcaaWYxzTfwuaWqr4uCN7Tnz7Rz8eJcYysLf+HTFo8ablYapAccHLSsd/dMUUd13LREaehmIo+jcwj9GZySByRNDKNqv3gO/XMjGrG7Cfolqds7t8xZaQ/zYyHgftbvdeLs0vC6Tsun/1EX1+/5O72a7xR3GOC+9tvePHpL/WaIlyfPyelM769NUxIInOs9W5JVo84m4269I7yZOiTbeJUpLFEUfwjSULMtCzsjtabpwEu+bGrxlk+swsXXOU4hqp2IRSqwQMOUl7K0qxF13iNYpxrwqzs3k2zWgvGtg2+I5c0yebo92k/gtmitTPzPRf1LmX2RvswyuzoTaAYSGPI2F6uAsjR8D5cIKVYE534cOT6AhSQFQpQW2jiDSCq5msj5Jpxtu68Os78W7uus2ztJcmyLYz2mcvxNapCSgVc5WGuyToTMUbO1if85FPNxXF+7hk3+5KsuA+BkHbs7tVs+Rd/+b/x5Tc3DLJmMNfr7v4dd5tbptnAtyvh+vKkANbL5RrfLxAzScQ71oun9BaQttsdmGJP1y9Y9gpWTtPAPOtvATwjozjEcJJRlpwse6ZRzZr9YUDiyO6gwmO5WLNcrdluVMCtV2v29weGYSjcBR965mHG9yr0/OkTRllyv9U+16fnPH/+EZu7b3RM88Q0Ob741b8E4NnHW67xPLn4hP2oQm+zO9B5VwDTVFBz24R6YhSsAeeIKVbuiB0m9aALKjgSZdydd0iqGIjCXomaad4bGS2vC2gJi3pO2gFJKNc94p+Uz/M4jg8u7NCOZqLM82AZ/kJZrxr7YpnTgDnNStd3iRgHvm/7EWJb9E/O6JUKoJQhxLzz9dsuzdQH5hDnS4h+ybDdcu4bKeudQ1PkFwgKce6BtK6gZW4FrAVyApiSKjCfBiXT2DHIpT3mB5ylvbfMWI0v3dVrqpZVTwucU8S96TT3V3CtljYIXJ+f8ss/+YDzc52bcfuO6TDQmQbg4oY4jXz2278B4Ndf7pjcU1Kc+Pb2HQDv3u24eXNXnkmQFVfXL1j1OUBqJKUO73Rju+BxPuIsyGoetizWT1iszpqCe4HQrVkuszCBFEfyUjo9PWEa9mw2FrkbJw77d0yDYhzxRDPt5zKP47gHl+icY7AYm904E2XFqlcBtZ8ShzHy+svf2Fx8zYcffcrlE/USbe7ekdKW2chwb179FpcSVw6eXX2sfQwz4ziUg8d1wTyDdvrCg1IWJgzsrr0B4JVOpAfbnBLTbKzTeWa5XGkl+/zcBShR4jmpdQUzKYcXJYsYSEn6lAuQlbgpEqHRZiDpYdBkpz9C3u1eNB2hZVXDKV5YMsYpCyb/+b7tEfN4bI/tsb1X+xFC8l1BkaOkIo28V7X8CL0WwHW4JrWbnr8ZAc/9lc7JGT0AVQl9pTYLoi6pI/W/+uqPxlnGYXZtaDSTlKpNKbNqTG0dkPyb4r93TFJLFfrynXJu2O8aN1+9jYryO6gh+Q4XPItef/PRi0tOT0Ohkk8TamKMSgNnuOft66/56ktV3c8vnvOrv/5L/vJf/At+8+U7u2zHYn2ON7r5uLvg2bMPeHaqfaZwRgwzS/Tk7NyKEAJ3t2oepLjkybOPWC4C+8xanRQD6byVTmAmhK5gIqHrOOwc6wvVCnb3n5PmXTnP5nli9oFcwVvSyDTs8aFnsNQAb+9nRoGgl+RkOzNNiYWt1t9J5Obdjj//h6ppnJ2dMceZE9EvDGNgc/uWKP+KFz9VDenlk6d8/o2UZ+IsjKFoyiRwNQdvqfWT100OlcgWrBNcSnQpQWjWW5wQlz1PyttpHCFIQyct0FvDjk5JqqldPm7r+TQJjUrLZTdyV67JHbLQ+2pq/eYwh6x5uOCQ1OFcJMzf3Tt/W/vxeB5lcx67Hqsr0hfX1TGImo42lfaRQ99zcpS6iXOR6NKc/r5CGmLcjbop9V/7vtmPRYClhKRY3FhiQFqb5EVD6o8nNc5z7dOS8hyDWC0QbHZwkzEqL4ijymAOXjxV8tSzJyskHpgGG5cILm5xo2IF+7u3fPnZrxktLuXf/N9/xf/wj/8JX7w58OLpzwCYhteMbz8v+UPXyxXDOLIP2udiOSDi8Wu95unpmjjs6XsNt3/6wYdcP3nGPOvmBpinA4FYsJYUOpbrsyp8fcfi9Jo0qymU4sh02BLMBRgHQcKaFLW/3e4tcTgQcXzzToXHN+8iqRfLmQFB7nl98y1/8tEzm5vn3O08v/3NrwH45S9/wXJ1xjgpwOr7BeO4x2033H6t37n6eM2Ti1Pe3u3yE9AQAHuGKcfBNOtYs9M3wPsRrqUJsX3o6Eo+XEsRUYqFOauAWNegdtGYLTQHmygoP7cfGgfJc7yPHuajaZaW4jDWZ79YEJPeTzUzpImjsYPLCw6twfR924+QhlBP7Yd4ISmSK5gBOVkgSK0ejwMhHmEcaiLWJCUaJ2KfxwwnNfYgNlHNYe8yLS/31wgg05MadFqFh+So0KjFm7R6fAZmH+IpeUwVZCVKQd1zwaDSHKalVMC03G9jQ//k5VN++umlvTEyDkKywJ9AIk1DSba02dzzbht5/U69Cf/4f/lf+frNhv/sP/+vuL9Vnsfn//J/ZnX5MQcjgb366ks+/+wcXiiZ6jBtePbinOsnxtwMA+HsjNNT3dj9ck2QAcHhOx1z359w2G8JvZHGlr1mE8uaBHB2umJjXg5N/xbY3+lrCQeS2zFaLqD7zT37uzcMU2QwD8xuhu1hwyELTvMe/M0r1bJ+/tHX/Mf//l9ws9Ll++qLz/nkk08IRkRb9EtmvyROew57FXKbm8948uTn7A8qxHaH4SifRx589kNFJ5rtLQOm9lc94FQrCaEvh513QhApa0k5L4ov1OddO3l4wOVraDyMvhejBb75Zv22JEg5zgkClcOS+3Y+Ia3wkLyG7aUlEBJq3pLv0x4xj8f22B7be7UfHpIvEW9JhV0T8SokRY9b442G3kvGCFpXk9l7OXlryrzV8lK1jbamKd4YfrF8ybeIthxL6pxANqPZkpRr4gozVsfYhr9nT0prmiVGUszXNK9R48Fpv6/30fBTzKzy3rMwr8NHL6759JNLxOqjSJqRcao2OjMyH5jNJfr69Su+evMt/8f/+VcA/O71Hc+urvnlL875/I1qFnMMxLRjf68Rrjev/iWH/cjtnZoUoTtl4XZc9IodxO075u4ZJ1cf2X0EIh4hMlmYQecT0yQ4c+86F5jnqVDJ5yRs7++qze48l9fPeGdz8/bdO2ZJbDaqemy2O755uwPx3Ez6q9vDpC75slAcq0Uo0df/+rM3MP1z/pN/9GcALNye89MFveFFh+0N3eqMsDwhJV3i+9t3dP3nvLhWrsgX30xMTTY4EY6ygIE908YUzVqr/kD/8o6SmQ1LbZi1xZSs3g9Va2i9GcfF0jHzW43lavLKkQmcVF2v2IuZOi1Q6JqYKYi23poId9uLWctoPY/xO3jK395+BLNlBpkKIFrSp5FNifpwvM/BRPUmdH6z7h4AXwru5MCiEuQTzKVa1DxfcyHk4STDMRrb1NNmFhFLQ1h/55zLkWoGjBnhLYdFOzVlctIiJ0JwntnlxDCq9rmGW5Ie5ATBNf15X9ThsxPduM+eniFpKvkUYkzE+UDOXZmmPS4d2N4rYPqrX/+Kf/ZXn/FP/y911a7Xa16+/Cn/7J/8jzirCHf19Kds7w5svlEz5vJ0yXp1yTha4iG2PDs94XD7JQCb4Yyrl9eIBVB1yzPEOea4L/Vs52lH6PoiLLyHrlvhsLSC2z3OB0qZF9cT057zixN7Lfz1b19zu1F8Y9gPpOT5+l7YxorvrBdnOKOnr1c982FjhxS82wm/fbPj5ZdvdJwhcn15wgcvntkjHtnd3bBaLegtjF9Ys7l9x6XhOc8un/D12/tymOXEDS1ip/9m08IYFk1qBbH7yYvQ40FSU3DJNmY5DIXkpYTCO6MelNSGomtTvCuHbnAWC5Np8pgZ3o7UguUAvKSjtBVaWFxNnxzGn7OVVjPcVzC4TR3xR9qPwDDNPA3BS8OQyGzQnP7Ad1UYNBvZN+hzlKD8iRIs1hkgWrkjSrAyJNlpYiAFXq3wjkyoFtLgIr6t0mVvNyxWcY5AfR2T5nkoiWNMWykp8yWRYkdvdmYUx9QeB6gtXSIjg2oZoYn7SSlxcbrmTy0T2MkJTLsdZJQ8GXibLEjtcIOf97z67b8B4H//p/+af/07x+nFpwDcf/XXHPYbzs5XvP7stwC8/fwzBDjcq6bx7OoZf/LznzHsXgNwedLRucT9qGSsqw//AReXT1lY1rBu0ZNSpAuaLQwgsWS5XBaeB1bVbjwY3rBY4ecD242Oe316zf04sNnrGM7Oz3jxInC3+dpmYmRKga4HjC8RcFw++ZT1Sq8RFh23717D/Rc6znXH2/3Mb15pYueOieuzk1Kguwse8Sv2uwOCXufs2iOs2N+rwLl4fs54dsLbO8VEwoP8Hvl/UvHCaUGuSq+oa7KA9XZAFE/HrITGkr/jwfe1NKqrIK0drjSHXwbtswfP4wwrrAesE8G5DC5bYue22p53Fp1eMbcceAn58jm88+9ReOA6cH0RWtUNa+HLDRtUy8jGo42bpFYVz6SacgM+6OS5jGZrXY2SQMco8Zhb2DqxdIW2cY1k462WiZN0rC46c6dl6R8j4jVQzuWMsV61nVitKUs2Y7/xARdjIzpU8GTEW5MMC8lkx2qx4NmTc37y8RXrlXZ6uL8hJfBLHec8j8zziDP3ZYh7Drt3/NU/VxblZnrGf/Sf/jlv3qr3Zdmv+OrLv+Hu9jXXZ7r54xSZxoGrcxVQ/8E//Ee8eHaKRA0wO+8HXH/Ny+c/A+Ds4orF4oSuN5PEe1KcmdyIRb+zPtHF3XUZ0JtJDlZrPdHTfMvdfsvaSisMU6RbrRjf6uvDbssHl4HpJy8A+M3nkdCNbN9skCys08S4/5KTtY57HiZ22zvO7KA58cJbgY3Vtr3djnx7u+OFZYlfLs/o19f0/Qn77Z1d955+LYS9XmP37iueXLxkmnWu7vcDXagJuwVl+aaUfR++1MXRdWSacQl30A3tvS/mloTjesOZ/VlB2GPtVL18WXN3zXeOw/wddblLSojEyoo2RaTCAzY+5488MtkQ06ZZ4Z33R2D+H2uPgOlje2yP7b3aD9c8LDeGwxIAZaUhC7AmSEipuY1qKGYjNnCQNKQaceBdphGDSDwCfnJuDgVYs33Ua795HBbXXyqEg1l8WVJngllVHUMSkNi4aDVtfWyIOEpnzielOceavKnOaer9PM71csnFuZ5yz69Pubpa4v3E/p2q0cN2Q7e+QEx1n4aBaXdPMADVyR2//rf/lsWZgoT/5X/xC3zv+be/U7X89KTn6uqU337+N7zeGCAq8PLFz/j5T9W0+dOPTvAucnmlZsqiu2Z98ZLTc1X3+35B3/d0fa1ploICkUtjaHmfgSq918NgxZYMj3j77USSjs6rVrAftkyHHVfGX7l7M3P77obnTxSfeHt7xvJ8YDfB19t3Nm7PsH3Ht8N9eSZxTPgTnc9hUpBwN+hcfX2z4+W7LbuDPq/lMrHfvGF1+oRuqfjPMBwsFsrUf98RQuCT559YHx23m0MttYDmmC0xUh5IsZgkWk0OUpzLXGDFtvP69J23fBUPg+sqRhKcVga06TbXqyNlTbiUTKw6keJ0NH1W56zmmKkaTXJmakmjaRh58yi9gJlCD7WhP9R+sPDoXKJzqfEKNDkuaGNIHHjNHFYKkDuPuHbAFmlaMj/bezZTFgd5VC0r5+8otqFoTpHyG5lVxJTIRW/gVzadSlZLACvo5JFYhVREHhQQMsOqVALTgKipLJJISo7FQvkS69WC1XLBmQGZF+cdxC3D/S07Ex6JgOumsjjnccdhe8ep/oTbm2/YDZ5/8O/9ud2XsB0TP32pgmAVT7lcPOODJ6dsDeN4/vQJP/nkOfsbrduy7iYuz664vlQTY3l2zsnJNS4otrBYnUBTllCr+Tmc9JpuCnBpQtyEWJLlRQfiI+NBzav1esVyFZimnMhnwTjNDBYYF/oFU7wqIPmnH7/k9Zdf8NGzC+4Hnc/bzYb9uKNvCzt5x81Wr7mdBPBc2PwOk+NXn3/Jzz+9svn9CEk7dptEbwF8rlsxTzPOWYxNjDrnlrTok2fPWC3XfGPFtSVpIqpiRsSI6x0ZtlIGsmhG8hLxqn8VEN/4QgWyk0Rb5TDDHZU0lpMDNZCK2uA1cY96JciCQHCkmIpQlKhJh3K8mCTDJakyTvP0VuGRzfiUkiXu/n7th6chdFH/WLacCpgCqabiU6AoakBUW7HeuaN6osVGwzCFlOpEWA25rJtoIiHTRhrUqk32mqSjrR2mgqeScLS3NhRO8ESLnLXJTQ+kNI6UqlcIPC6kBnQ9thv7LvD0as2TC6MDpx3TcM/27VccdrZY3QL6NQtjch6275jGHaN19e7rLwjMpKin8xSXuBhhVMDvyfUZgQMfXS9ZLF4C8Oz5E25ud9zstM/LJy95+uIjTlfZm3LCyfnTklg4zSPzPBXXtgtYOIBjtmps87zH0aRVEMccIZmH5uS0ZzhoXwCXl+c4XnJzo+MmrOl294hFb56erliuzhmHG15e6zienwe+ue35yghwc5yZ5rmspXXfcblecXVmRLUucLvZ8RvTwl68OKNbnjGMB2Ybx/rMk1IiWOLlOE8Mh89KoCFp5tmTp5ytVNi8vpnZ7oXZdtycvWB5sfqAZE9es561jlz1rug2aOgJCVKpI4sC+q2W7hwu1aRFOGXBhqNqAFWL8KAZzsrBpZn7JQe94UoC5qPSrK7VZaTQCY7X+R9uj5jHY3tsj+292o/A81A1yoraFQ9DrjvSumXVpEvUTB+5DktNmSaNLysbNFl11JqbbUo4LXjjXSwFgVSMd8RYPTo+1Bylc/I4X2vFYAh31iJSElPzKiFI7D7zdZ0L5Tt6h0nV2Owe857VoucDcx0+e3rK6YnHmdt12r1j2Nyw39wwHvS9RM/y/CnJaN7jOOL8gv1eKdnffP0rtjvPpdOT8ezpLzHDQPsc9wS5ZI7C6kQp7j4IF1cdH738DwG4vP6A03V1GZ+cXdMvuoLc+37Boq+lG2KcmYct0DFOxmmJI8iMN1OnX67oVqo6A8wRJtmwcAubq8STfsnppRLX7m7vOOy37A3fiEkYRtjev+HpqWEasuTifMGlpTZ89eYeIbLMvI/e8+z6gnPTPPrOc37fs7fyD99885oXLzoQx2jvOYT+9AnzlM9bz3Z3j+dXOv8f/BSJE5fP1RP10xcLNvslX73Vudjs92jhBHvGKVlhs4bEaGb6UZHU5vOCveVk0UbmKgWaxIrDu0I7qjWDimWja7my6pUOUYpZocmPMz43x7HsxZwGoQsBpKbPyCZNG3LxfdoPN1tE/cyJBFKzUac5EZGSANl7y+9IBdvUNVernSPqyi03oP4jin2XVaty9VyXk/odUYZq9Y5ZhGzJNOzMZdYCUFVNdBn3VH+Xvoex9kqxnlndbQXz8Li+Y2lEqmXf8eRyzfWlAhaLRSJNO2RQt+G4ecPh/g3D5oZoyX32k3D54S+JxiB1mrKd/TtVxYe9x3fPy93Hw1csTj5gtVZBsVidEhP4mFiauzfGmZP1CU+eakKhk1VHGgdW15o5bHVyDr4r+MO4v+Nw2JcC3khknA6kWF3uzgl98KwMZBV6xsNQsK1+seSiu2QwMPNwOOBkS29xJ+enHZ1fYRAI87jj+tkzvv78hC6oCbeIHQ7PUyOWPb1ccrvbsTZ3e79Ycnp+wqUR7LoucXnmLK8I3Hx7z+XZluQUiwIYuMMv13jJzFjHOBx49fmv9T68Zz48JZgJt1xfcNL3PL82tzeezWEgr00NeLOXxYRTglYxd9HNngVOconoXAVhg4coJF/JhQXob1a5Bo7XombaL7ZOAE9JlE1yGhFsOVkik5p7IgruApHeeFf5WtrRd0DUP9J+hKjaZH8ySFrf1z2dw9J9RZsLlVz/r2gWDpybK2AXVXiEEl7sCzcE9FTDadEal2/Fa4LX7F0JPvtkKqAqTUooL0n7KX1WRLwFe9WD0jxkieUE9z6w7DourZjzybJnfbIgGAOVeSBOG9KQyykODNtbUhy5v1VuQuyfKefFKO/iPC5NDJY96/L5z1ldfFjGdNh+zWJxwXqlm3g3RvquY5apnnRuwfn5BSsjW6V5w/LsmpMzy9DVd0Bib9Xe9tsD3eKEji/FDgAAIABJREFUhF5ze3+nRaPGQ3GfrU5OYbGkNw2pWy4Jq1N27wyL2bzFu0hvRLPVyZp9ihwOObWApv5brU/s9UTfJ168/Jg336gW4NOMD77M90cfXHJ1WBf+yWq5YnlyQq7cHMdblsGRg8M297e8fbPgyfMXHGycAZjHPcEEa0qe7WbD7ZuvdL7TSPjZX9C/tWRLT3pGtpyc6vx+eL3izcaxz8F6LS6Rp/v3EKy8hTroj7xWyGs2aCE5AkpQjQa85k4t3UUuRv6gf+dVO8k4i3oAKxmxByRq6ZEKzSRSasq+eg1bTSK/5w7+9vaIeTy2x/bY3qv9YM0jRiHGnMCkrVFhWLTLqc+0iSRiccBYEFwOP5ZkZkOlhWe8QfuYianVPFxz3eqKFSrPw7nZPD/ZxJiN+5rxCTFVsLonS1xOEcOKzWScxDtP8NX9m0+HyVyLaelBZoIzjkY8EMcD86gmyXxQL8Kwe8vNWw1aW1yccti80xMV6LqOaXNTvEIXH/xC3WnmPZjnS4b9G5jubIxLQgjqJraT5+LinMuLU2R4Y9/pOD1/QlhkPCKyu73lfqMem/XZU5yDuDeNKQTSbCeWHTOLxYrV+gxvWkAUpbGfP1UPz+tXX3L75iskGi38/JzT02t8l68ZmIeB3hiq3aJn3r/jg49fMO50nLc3X7Pbz6XshBNh1Tu6hc53FyKLTsszAIw4Nvt3Jahwnra8eT2wPl0RUy4FOdOP5yTLzzrFyDQcGA/a51e//Q0nZ1fmroa+f0t/cs7eSkwsV4mnZz1vySH9UaEId+yhOEoYhBg9IbtmBWIbfJdxQDNFZ9XinfOlXAMWv3XkwBPKek+iFIgagGrmlOEbTjwLL0hf/b8xRSvClpnaZn9JEwryPdoPj6r1Hd53KiQac8mRCI5jXr9zIJ6Yfee5slWZbM2r2NpzTmJJMPswE3pK2f2UsRHtRYsyVVdtaILpyIyQbE1JTTqkP8gf1sjEyv2vpK++81xZ3ouzk44QKIDecuEJsiMatXzeb5mGLfutmijTYc8URw67HcNgD3AaGPf3LMzE8MEzD1tOTpXG3Z88pV9fsL3RILa+3zPsd0RLjBHjPRJO8WHJ2aUSsE7XgUUf2W51/i6efczyZF3cjeNhIPolawN25zhw9+4Nh73F0yRB0gIXKMQx3wWEkclOgG7h6TqK0PvkF38Gv1ny5Wdqgsy3A85tCQawjuMBcZ5oz3S97tkMnt4NvPj4TwDY3L+lS3MtuuxnpkipcHay7mDelRq882HDPN4X7omXiWEYefv6FWeW0UzEMa62de2IZ7vbEQ1oH2d49+YbnhpgutvesMTRm+s2ppnF6owrM02Dd2x36rqtZZly/ppKG1BGRgXjwR3r+w0NYJ4nZkvwLVZTRQtNUZ0IxjE6EliprlWNMkuZLYZzyhERKO5bJod3c92uJjT0jPh7FB7iA+I7RXsbnodGtkpT+NrAUWKxZYX4e8Hdso+TNNYblRyWCV9F22gESxGieTYD0njaCyZVSgAm0zqapC8uT2Nrm9Y0biklpjlxv9NeF53j6iyxtrx5Mowc9htGCwY7bG8Zhw07yxieUmK9XnPY3zPbgr/59guePP2Qs2vd+DJuwK1YXOhrF7xm8bJq826/IPlTpr1qLnOc8UHo1wtOrSzjydozbr6kW6pwOL+65rC7I2ECannKsDvw5edq92+2B3ZDYrKFN6ee/Q6mWAHmdb9lmnZ4C8TyXkHC6ycKwn708cd8+NMPefGRaiLbuw3D9qZkVz+9esn+/i2DsUfnw4FEYLPZcnKu9/r0g495/dVvGI1t2/cdIIjZ/YfNN5yerAtAOo0bXIP1LPolyMRhu2F1cgFA6FeMhw1dp3MxTHuGYWaz0XFcnF8Qp4nBnllnRKu8rpYn5wyHqSRFOl2tAM9+jEzmiUoizJR9bgW3a9JkXVtSSJLlvbyOvaMz/kiO4PYpH472/ahCqlSZc6o9lwO38DvyHqvlLkt0uleLYRjM+zdOhN6z7JfQFFX7Y+0R83hsj+2xvVf7ERIgB/3jgh362Q1r4cxH/HkBQol7ccmSp9jraHUwctRhCLmgZHbDGvqQva4iOKc2os+kvmxnNoV2EtRkxakwI/T7ObdCAUmMA+J8HbtEhFSSEHWdpwuO9VJVy4tTYd0dmHd6ao37PcNuw95e73cbpnFbyg8s12ekpMWQtreqOby7G/ngo5/zQUHVPYuTp8Rk9VtXF5ofwk7bsDxnQUAsV2iUkf32htPzpyyXevos/MwkC64/UFV8ngYmTuhPlcb9289+zasvXiGimsg+LbjfUTCQ27t77u/vQTy94STBwzweKh4UJxbLJf3neoL/5b/6nE8/fMIv/0RLHvz0kw85P3vK3kpeLhY9Lk4ctspfmeeRs/NTNveB8aCa2dX1FZvbNWmrGIYnEXpHzgaUorDf3BZcYBgOkEAMD/JdYNGdMMdZeSlAWF2oWTBpn+NhYrfbMVmqgdGDXJ2VKFyZd1z4VHJ6Tt0Suq7Qt51TJm4fXMl/Ms/OosoNwyARpOElmWelwBP6bkmk6rWuCBFH0bldLg6WMY5k72G/VkCk5P1Fg8BLPA0Us6c4fSSR5ojkgubTDlgSfVcZtN+j/QgkMf0jEg04bHj+AjVgrXVMG5jjvdln5lYNOgnFteXEtCibZu+NWZsxk3wtwZdMtt6ArEb9ahzjapc2Qi0XQs4grE38kWNM9DYyRZgUuT4PvLzQhdaNb9jdjMwWt34YNgy7HQdLupOiFuERUwnjPBIDiOvY2WLd7z273aY8vNXylHG3wVu1t77vGQ93RKOjgyPFicVK1XLXT8zzrBwMS7URDzsunr5gtVYBtDk4wuklv/tcC2F//vmXJHpudnqfv/78a27efMv+Vl23h/2G/e5eA+PWqu7vt3stKJTV5sWSqyfPOTXOxepkxb/661f8zqjin350xV/82c+5vrB4mmXHk6cXpPTS5j1y880rvA8Mxnk5OXvCxfklk+VeFYkEgcnAYZc6RoTennnf/T/svdmvJEl25vczM99iuXGX3CqXruomu8kmpeFwAAkUpNECSNDocQRKkP4sAQIEPcxfIUAQBOhJI0AURzPsaTbJ3qprzazKm3mXuLH4Zose7Ji53+JgmNNVmqe0RnZ3xI3Fw93c7JzvfOf7KlRREwSULYoKUxaM+y2DEEqq1TkEzdDHx4d2pOuPtLJ4rJqS4Hq6VtKpUaNNkcvxRQmqrCjklnFBMViNdeTGtiSqnBYHjcoq7fF3xIXDhvxExBpShq00mKhnklJmH76RHqQiwWy+xjQmbY6aMbgMfCo0BEm780dEfZtCqPpVYdHGiO7Muxdrv/XiYe2ItWPU8ph/r4LksAbIZEuNb6nSIf+b0WjpkUnvE5R5us9tJMDMTr73UQ8k4SFaatazKxav0ezYlFaEBCgRAat5NYjgY39Bfi7gvEILun+60JyXVwwiJHMco3aG7YUvsb+i3W1p+/gJo3cYU2QwynlLUZwRVODQpt6WFUPX5nPh3cDgCpay4+uiIOgSJ7tFd9wzjp7FSqwkt19QmIqiKCiSTGNds9qccLeL38HyCW+vb/n1r34Vr51Z89nlkc8+fwXA9voNN2++QiXgEUt7iG7zhTShBR9Nrp28xgfFF5/+gtUmktVefPgDHj55Sisi1n/189/greUPfvxDAGp6SuW4eBwjk36w3F5dYseBYBNv48Dpgydcv/lCviNg3ZAB0TG4KK4kF7UsV/jgaVKvS12jTENZr2kPYlUhkpiDLA7dwTIMnk5El7WKYjkH0QQpTElRNnixcwjBsVIeFrEL1+iCyrjY0yOrgfLfYJhKNSbdBclpwM+bz+4xUKdCwiTHoUlC3/GacD+aRzGVWpCNOORNSCkopAE1fWRBQJeGSkcw2NQVIZ1TPUcZ//XjPebxfrwf78dvNb515GGUxai0C/kcFWhdCJaR+lYA2eGTvmewIdY0JJw33kXCuSxpRmu0n7fsS46kpscqmn/OlMG8sDIy0QPUvJMlRTlpR4nM0bwuh9j4j5oYhMEHTGl4dBp/y+OTDj8YrI7VAW96gr3JxsHOVQxhSSt+rV41nDRL+n1MFw63O5Qu2G5v6bqYk1eLU8axmywgtKFZX2Tege13jN2BUMRIo1iU1OuKQT6z7z1Nc8LZ4w8JNn7v8vQRu7s9KfBYLBRffvEJRxujma/eHvmLv/gXbN+8kuvRYZ0XQWmyKtzoRsZOqisqViqs7NiD7XHecjhGz5TdzSVPn/+A7/3gd+Jn2I6f/Is/Z30S05qlcdQmcCr09vOLh+xvH/Pmq49Jeq3tfsvq5JTlScRmbt5+idaztnPvKOs1VbWWeQLOHbOcgaeiKhqaepk1VYxSYAqO25i29KPheOwnEWsCwXf0UkE7jLF/++winoudAuVH6lNhmK6+D7phWWpqEUAeRkdnNWPGZuacjhjVWutmYXCQVDj1ukR26bz8G3uuQj43RgVcmHXqOot2GiOG6EoqRBOtIAUqs14tFbGZlOorUxC8mkrJ7zi+PebhLDgrQkA6N/1M9JMZfhHAB3uv78RBdnqHVHJK7cUKp9QkKIsSOrmQmCRiU9pkCbt4v3+j/hsUk8gywNQGnTRDRjvhKFk0NgvVBiqjqETgpmt7FlVJaUS4xx0Z/SEvHt4HrA35M61tWTaabh9D4u1dQJea66sjZR37TpzztMcjpZRV3XgkBCvevuCHHm97RgEVC9PghjuOnWAk60c8evKCRaNRvpYfV3BoLYM42l9+/gVfvHzNG7FU+dlPf8qXv/5L+uNdvh6L5Zq6jgvUMFgIDucdpaRsQUWnsdHFm9D6TgR241Q6dpZPPv4p27dxUXv+7AlGK37+Vz8D4OmTCxYmMPbSt3J+zvmj5+y2VwwCKA/OolTg/CJyXPa3VwTlszGXAoqizkI/uB4VmqzNUdQ11WINwbKUtC74EV03jD4S0UZf0fVDNmzCO/r2mNMzpUr2uw7vot7r0PcEd8Za0salH3DrH9GPS6xcIxcUzgVsAr193NzSXPMu+QPNtHHlxoZUKAgU2twD8rWesMQge6dPHJdxiHeZEmC9NpRB58Ul+sTExs2p0fN+06oPXvqZAs4mz5m/e3z73hbn4klRCq9VduBSaLxXqFkK5XMeFl9ktCDpeiKSBacmrQ0l3P+EZyhN5I+mD5U4Qk+Id9BJQ+Qb0ckMA1FK3cNnfHKuiwceASatp6qOitYM+1Yii7LGjnuMFde0fkt38wnbq0jgurndc7Mf6cZ4TOePnmHsG453ceIOw4qXn39K10GziJP77ZvX+NBgxAah272hbM7ypOmHgXHsIVkZ6oB3PauTiDUslhdszpbY9prVabzpXFD0Q8/NPk60v/n0il/94mMu38Y+lK8+/w3D8ZZO6v3OWdruwGYdHzeLM5xXuOBzty8+MPRHhlEqS+NICB5jEkGuwinDW2HOuvaa5x/+Dq++jucqDFsena3ByvUajmzOH3NydsHbrz4BoqBxf7zjRBTPTs43dIc9rkgbRIFRJjN8y2aNG7rc+BWsi/bP2lBLh/E49tE0XeZJ21v2x4GzdfzMcThwPFjO60gqwxRYHFZKgV1n2bKf+p1CoA4KtfwxNoh1hbUSNUyYR9SjSdUUqLSZWVxyr5IyuQjOOY0qizKlz/Te5zvA60gCy/dZ8Lk3K30mASFapg00kaHSW6YuXPdvlSRmFMFEiFkplUtZUfBEZRGVfGJmatExpTA5ZVAR3ckkmkTWm7oU/YzlFdOagFRKksAKkaqbO3Xl9Sn1MXknSOXfCKRlfqoSCbhZhQZ1X/AmUoBLjMj4h+GA0nXeLfp2oOscpo676wcPTxhvvkDp+Pr27i1t72hd4OQsVh3KesHq9CHOdvIzGurVBV4eK1OiyhNK4k0bvKVenNOsY+RydnEK9pZgikzg6pziOBZ8dRPTmKu3l7z+6mteX8bdtGt3U2SYzp7WDGNcPMpqiBPROZKE1jh0tN0do+zAWiusUzEcJ9L/F5VGSaSy63qurr7K6eKwddQ/+l1UIqqFbWx0q+tcFu3ajqHbU0rJebU6ZXd7na9ZWRlMUaJ1jLBGa0FpKiGE6aqRGybgClF1b5bst7cYWXwPh46u71CSTvXDQFMHvICyrfXoomZ7ExdBvzlFa9BdPEZTlCwWO1blL6mbjwCwxQLnA92Q5BJFFDtXY6T6kudmml653AIokYiYzd/Za7SOjZgz9mUEXdU0n2Mxcb4gpT1xVj2cyqEorTEhLlCFeQ+Yvh/vx/vx//P49oCpKTGmlMXMTGXWtHtnuqvCpEY3PXuNInNANClHm2rcopgmn+AlfEu52n26DUSQ716vSkjpTwKlwIQJGFIqgNGklv7gbPymWfk2drUoCjnOujQYN5LWXlWuwOgsA+Ccw9rAxeMYFRg1srcOL9J7Y3vg0I4cO0WzlCihPWLMzCumMATf5x2oXixRSmVAL9iO9fqEpeiiKkb6MYbqSsfnRqcoV6eYKu6mu90t1lpSQ5Q2Bk/IfSYAZVHQCfZgihrvIoegLKXHw44473KLeFEUNGVJJ01/RWEwZZXLkSOBsd3j2lgyHeundL7gIvFTqoLdfstyuaFZxedG6xlGx/42grCb0w3D8Jyd+N9WVY1SZO6JKmr80AG9/C6NqUq0D3T7mKKtTjWqqEDSwu3uOpb4ZaKM44DB5LSk7z2udXhpdry7u2VzcsKqidFOu15yvKrYbAzLB58DMJz/Q1q3jjwYyObZ0zwiWpDIYx8i+JmEtJN4RNQqTNKBsYScAmulNEZpVJFS/wXJ3D1ODECFPN+TFOJMfmaKhmZRTcoMjE5uXX/3+NaLR1mWlGVFEDQiVzO8j8CRHHChQtQyUIacMshnpBTDBfe3mn5UCJP9JCHmrIlNF6TbdSZi4r2P/ipzWzr0ZBSs4oKhZqBsfE7CNR1wnnuaH4RAaWBIWIyuCWFBJ+G9sUdUd4MW0MosHnBam6xKPtgeYxRHAUyPR8vd9oBXdb4JvS8oygV2EMboOBAAJ4zIvjswjjYzPZcnK5rVkl54C/2+pVmsWNRrdCnubu2Ru+1tvpHfXh94++YrBsE4hr5lGMfpGILCtW1Ovyo7xHPrICAdq67HezcpxjnPONdxcR7lHE7wB+8D7eDwAqiWzYZh7HHC/Kzqk8iRGS213JhDX+GDzYC1944nz16gTFxMRjdiTMjgcb3cYIcDVhoRazdQmbhwpgMb2wNojTPxGh32e8rKZJDbGoV1jlG0WovyBD8MeWHtO8+d2zPU0k/Td4xdQXeAs2NcoJaugNP/mEEA6xBmWq8kbZkp7Q4E0e+e8Z1CVAXLa4F3aDxF2m+jSGpOU6Lf2iz1jJhrTpWiX1HImIkc2D1zeJB7IMSenncd376rVklrujTBJTm06MJG5p4bHR23IutbgMcg1ZFMiRWwaeZcrlSYgEsiXhJm4Kb30R81754ZH0myhBqlJvQ6Yh4TqCUvnr6PgFFyCDNyrE6OYoBSFaVR1OO1vGuHq88ISm5Ku8MGw+Wb2HD2/Q9WuP6O/V28AW+2e9ohYOrA4ZCa5QYRipHSYrm8h82Yak1RG5JRW1UarLX0wmKt6gWlUaiiyb6yx3bA+oJeEPQ/+vf/Eb/55eccDr+J3xkcwzhwsoqgYj/2dH2bFxOtC+zQMdoRLTd7XMCniehEYS1NZussh669twGMviTIwqoLw/HYZSmCRaVZNyV9f0AL5rFcn6JUS9vG42iPd2gNjx7F4/zq1UucdxNxzQW0KUEW82EMVEFTK0UluNPh7o6yqelbYfR2PU1T0ori2bKEu11LUcW/u6pm6I4slxGnWq4agveUggmYskAXFaasGIQQV9x+TrV8RVf8KH6GFcwjs5sVZoYURHeBMK/c5tJqkuac1oIwe9fktZzQjG/0hWb5CEWUNtSzuZQOKXW3T1HInAbxd4/3mMf78X68H7/V+I4EkGODWlo5Ia5KseSUwiuF0Srz++XN8XH2CXEiSxgfG6UwRs/Q6VmlRoYPkmaklTeIuFB+woJOAs3pW+d5ptDXU8OTfI3W0yKsgMIoVo2E3vqAPn6OsckGwdK3B9rUFzGMvL255uFjcZsPA8ej524by5W7fcsQSqqSjBF551C6iHk5EH2UZj0kWlGWhkrMl7xrGQZLJThBpUYUjkBByL1DJWWtWa/je6qV4Uf/3n/OT/5pPO67m88JKFoRPFZG4b1jI6Veow123OO8JejEf4gXOV3nqOc78Xms8/fc5r33PHzwhEJCpsIYitpgbUp7FKNXlHWDH+Nx9N2BxWqd09Xj0NIeWpYrIek9uuDy66/ojjHSWH7wEEbwPokyr0AXWDtkrCaoAkfJ9vZa5o3Hh0CflCJHuOkD9TKmPssqcHN35PKNWFhWmqrUVJISLkqDbxVV85yqiGTB7njF4vZnNE+iyVbnY8qQVQaTAZNK505aNWbVxJRxJF5SiphtugW0pzBT3OylWpjC5xB0dLpP55/4d2/JjZ0T+JG+V+ABzySJ+A7jO+iqlX8+pio5pZAuvqy9oeIPi7mXPOcChVZZJNkrjffu3okxqJyvaTUjnZHKUPFfToV8vAgqX7AAwaIS01VO0LwBKNba8wNZ5NRU00dFBTNZYEoNnppBTFXGbsT2R9pjXBz2uz2HduCpUDLGocfZgbtdaoILuLJkWdS0bczju96yODmfOdvpOBHEwLsqG0yhJjCZgrLSGWBVdozO9WWdw1GlS6pKU1fxM3/981/w+NGGH/3RPwTgF//v/8HueE0vHI6Ghg8/+iPORFPkk1//S5yPCvXKTLiT0QZKKb2OY1wsppMJymRSWWECwQ6MomFqqppmucIE8ZDtduA1ZVhRi0FTUR5x1rJcnss3lrj+blIIL+CDj36fy1fR+Pq4v6JenlOfCNbgXNyAgsqbxGLziG7o6TrBbryUROUa9Ra6XnF3JwJOvIncFfF18dZivadI3dgG+g7efPkx9R/KJqEe0d18THkaj0vXv4uzQ56zceNUMzJh7Ai/Lzoc0/TJq1ZyaLnxHQrtyYLePkzarfkTIn8hPtDRaHtWmUUFL4uFLB4qpv6EkEvu7zK+AwHkSOpSKpJZ3IxbGmXp02pHxEVmDFAVAOVz8cUTDadVNrCJE2AuphKLOMIlEcxEhTkxZw4ExXclZisQ83Ot7jlj3cMWRAYgknXSohW/s5Ou2WOvKTjBIYzI4Ybj7ppOtrEx1CxXy9war8LAcbfLWIExkUJcl4abt5FYtjx7werkNBOIyrLCe4cRCrY2AXyProSeTgFYlGARSheYxRnD6PFe2tCNIfghMzevL19xtd2zOYu074/+4E/47Jd/ySA0+uff+wHnjx/y6c9/CkTBYKUheHUv4AsojJhTVfC3JlxZmIwNVEZFIFPFBakwBU1dYEICFeF4OGIUVCKKXNUr+uM+06frxZrO29xOH9qeeqV4/Dw2192+fcvQ7SjL+P6Y53thX8q8qFb0x8u8OKfvTjfybvSUGooEBA+Wq+s9C4k2i6KiLMFI5FculqzOH1CXOoO/66d/D46fUYgxF6VmCDqrrsUCwiT1EA3P5oSxuBV766eqm4ryl+l1Tt03NcuWq/k3ibBVim58mAGsEsWqWGVKOYATMecQZBF5x/Ee83g/3o/347ca374lP4ANYoYzpVoSAcxAkBByA1xuwU9JT2r6MSp6xMri50PABo+RhC+YQNBzYymPCsndNoXq6ftS2JcsFyRaIUSvjNkCGytGieWa9EBmCHfwlEbKZIBzJT5U6NRcp2uK1XNWp7HMunRXmKKgKmKFYbEIuKCoq3gsy7WC6hRnx2ym9Gi5BG8nO0Q3EtyQeQjWecqymp1Oz9Ae0S7uxvX6NPZWjB29YBjeFhitWYmQ8PPvfYjzX/Lpx78AYPSwOb/gsIvHtd1e8fb1J+yPEbuJ+p5R3CZ7/zp3j44eeT71jOFoCd5mm0eCoakWnD18JOeiYjzcoQphqC5PCWHEWo+1iX9S4/1tZts25RrXbKhXUeowOM/Q3YKT0uxqweGuQ4sPrVIGo8rYhyN9OgpNsP09s692tCQ17lIFTqrJGKmqNNZrdjuh6teOEMpMC7fdW2jfcH5+Thti6tlsHlOWj/GtlOTrXqphkzAPhDmdOWJuWapBvFWUQifeETFq8CIhEWxkwVZlsk2I/itT34q6N7ellitzeSp9zzU0jIoRTTx3vPP49oDp7NCNnvgTCC2WvwV2hkl13Dm8mu5KFUQ3TN7iiA5bLuETHkKYqVUHpJYeciiYwrM5gex+FhMB1mxGjESS8mdnPU5FwG/qQvSsq5I6XTBGqrJAhcjj8P0KzDXWxZsu2DvaHooncbJrXbHabHj8JE7uu0+vKWpNKAoW0tviA+iiFFUncshdNal0u8CYkqFPCuE9+EDZJA+WCu8jdlJUEUQtcBSjYrePPTWb01MWzes8WW/ffMk4uAxQt8ch6qoKmc0Hz7w7c34ZE49D65KqqvLiPA4DIQQqwQrOTk45O91ExA6w7Q1lXeb+JGNKrF4wBOhs/K7TkzVqf5s1NqMlWs/okh/uBdpohkOk2S8WGjsMtMKjqeoFoXWUjc8aLP3dW1zfMko38GihKhVW5omR5smlCByPzlFoxVb6mYwB+mlz2iwXmLrAeSUENfDDDbb+IHoIAzp0+FBgbSJexZTCCOhqgKjnkRFUKUCQweKgZ4p2xA3TB4sRsCYq+U/3hCTn+S1aC6YS/GxhiNWAiU2iJDUPWRfnXca353kQ2+p1KlDP+1SACQWW3Cy43ITjxe07Y6wIgCQnLi4yc4+4BMimBWkClrj3v7P9JYR0PfLfjZoJtuj06Xk7ILiAVz4/o/AMg2OzTBUDj3YtfhTW5OElu5svefs6AmW3O0tRr1lIr8Wx+4rV5pwP5HTf7izbrsceDtTiULY6e0xdLxjzTalRY4sf4yRzf9YKAAAgAElEQVQxzSoK9AqT0zsXF1ojgi6mwbmBenWOL+Jzdzef8fZ6Ny2C3tL3HU+exn6a2+vXHHe7jLOMdpDTmCLD2KGllMZm0ldkKeXmRhNz/qRwb52lMIqTZTyGsjQsVlNrvHMDhKmr2Q2HuNMWTY5AR+somlOckK9it6rPdg/jaNGFyXKK43FLs1xO7fWuJ6hA2VzQ3sYFxg4HglG5Xd4RI9s+E6ADo/NUVTyG3Q5aa5HAkMH7iDLJ431raUrLenWKE37JePcl1cM/JvXtKDyFDgwScQcv+F7CXbQ4Dsi50NKAqblfTbkvSqEIVuX+JWMKijB10qkUYaRO9FlPWc4KEkEq/XSi6plnft/+3eM95vF+vB/vx281vn21xfsZYhxk5YvJwj1pDRWkbKbyohdCTEtS9KCVlhKbvEU8K4KaRRVBM0Uz6bkw6XVwP9IIOV+fymUq6yggi/T98u83gxkXFN3o6cUkuSkNOmhS306wjnHwUMSdUBUd6Boj3qpX+5ZHp88piriTbs72+O3AZXvL16/jzvjge1Kik03JjnvsaFmKVYDRCqcMXlIjJWFoKsvGSpBGG8MgYbS1GjvafL62uzt0WVFIFLDZnNMejtzcRDHirAGRK1dRYzYEn4V2Ulk89wo5Swjhnh2iUQYlmEhZFng/ZoEhbwNGK0YpDx/2O1QInD2s8mdYa6maJcNRIruhx1Nmjdh6DbYfaMRTxaotIUAt4q3trmNx/izqVIgOKiHgxzFn0S4EbEh9TnFaaTylSeXgGkLPKG/oBoXSHmPi6wtVogNoXaMrsc7c36DdAZrY1u+lipEqTy5FA4m7gYUQMs6iTIxEAhPeFmbs0enaTBiIdQGlQ2akIuzpKbWXd+j7Wqr5i+QzY3VU/dtNW4J3BO+w38iOs0Br9lgh8+kziClLTCYcScOaT+CbeFQwWzxSSRhksgvekX90PiezROXeR4giu5mJpcxKW8gClo+XGNIZpTO46X0h7xEOgGmgqFAC2OEtdbXhKD6zw6hoVhd0Y7w5mtPHLMMN5XbLg4exhPno0QOCs3idJoWLLdKiUuUpOWwvM09BqYKqLNBDyq+jMpSzHUF0NxfLFRsbOF5GMeLbqysMjvYYP+P07IKhG+illLs73kZtFjkVRVFJOjIXiImYUmoHSFhH4s0UumCxWDCIWI0x65h3y45hreft9R0fvog3mPIjRmusdVR1AvRAm4JqEdO+m8vP6PqOvhWx4s051XKNLuLfm/VjhquXKAGbFw8+ott+TVlMPrG2b6OmRwa9fb5ZIS7CZrZ6L+uCQhvEAge0obWBfieOfaOl1pquO7BaR1Kddz1qvKK8+Hfk3BSUZcG+S74ubtLYJWrZotSUxaSmTwWpE07JYpEWnNgbo6c00Yo8xNwMhjnwKVBCUJlsef9v5O+M5dp/i3oezsd/hGhUE3LuFQ8usdqShWRI3bZyzPdr1GJbmR3ifH4uvlzf01Qm54Oz1TkkYtgkIRj7W2bRxSyv9yHgvWP6q0Kn6EU+0+IZXLKBiH0owbXZ3tCNB4KzlIUwY/VA0yw5CjEqYPDaoIqYs68vHtB1B569+Ih9G4llVV3iQkALuOZtT/COYhGJUoe7a7ZXrzGS9ysdOD17Tr0QBmWxpOs6vNMgrMrVuma727Hfxe94+OgJL1++5PQiVj5urt+CJvd/1LanH4Z/xQQK98/fvHFRlMXKVH3RiqosWS5FEc3D0FvuVDyGzeYDjNZ0AjYsCkVT1wzDQFlG7KAqS7puoKxjL4vWNUpbelFCb/dXVPUpy02M9J794MdsHv+QO8E3Dle/pj1cU51/kKNc5yxhxjsKsjtP7E8oDAyCKRk9UJYaPaY+Ks+qLhjGeB52neO0crjjLX4QBu/JI+z2Mx58X5oZzQfcHXoq2QB0ofFuxrDWhWxUE4aXTaLyPXLfTjXaUarMGbLWQvAEiXK1LueSN3K95HNnmEeYFTMiXOmzQPO7jveYx/vxfrwfv9X49mmLKgiqiCu4mpnRzJSNIO5Qcx4/IGHUtMzG1/h7+ovJlyK+QN6T0GkJ51JbvXyz5OnpLXHlnpiFetaRGIFv5+elyEDQEVOYU9a1Ufm4RqeoVUDrhHgb6rJAE0Nabwe645btLoari3qJ9TprbDZVw+Mnz9ltX/PZx1Hr83f+3f8UZ/tclej31yxOn2KkGnN8c0vbd3Q3sVO30IZHT39E0UQGqvWKolygFqd0YjbVtUfeXL6hks7Qbhxx45B/q7Uj1XJJcRePa7k6oyxHrPArnPMMYxctOVMOHjzGGIrcg1Ng/ZA7jhdVg3c+4xF1XVKgONnEknLf9zx7/nxKco3FozGmpuvirr9YnuK9JWnVjj5w2HVUq1glct5R1AsGCRvubt+yPjnheB2tGoIHRcFxd4ORaM8NPVqZqMIVf0g8D/K7Gu2pq+wrRTceOanh6i4+sao146ziduw9d13A64KmkfN3ckpz9hHuIAzT1VkspaZKk40RrklXwCicVvei5qD8/BYRqtQ8oo/3UOp58S5yQ1J2RalmMp2pK1czp7BHK1himibXOVLnPeHfIPL49ouHhPc6mmbOgB7uhUAqPzuNSM6aQrCIM/hZI1xcPMxcCDX4e+XZWGKapN0CsZ3ZZw0QL3of6QOchH354+QKTaXlINhLisvicZFl8pbVSBlglBzKeRhdm31OD/tr9t1Ivfq9+HcTS6QJ81huHlOZLzjeKD783ehnsqg9wXq8iCw7QJuSsYvh/ugC7eGSr6Wf4/lHf4zSM9NwVWLK6K+628XJezyMPPrgBW+3kcT08ce/Qakiv8d1lkJX1OJ/67yDkiw07FO+Hcj6oEYbyqq5p/ugw5THI5yD9hhTtvZw4MHFGTpMokfH/YaTk7igqbKm7VtWq00Og/eHA1WhaGp5jVkQQptJY95D51qCPH61/ZQXP/hdlidRfOnq619RNwucHRmFeu+sw9k+bwBGKUqVWtGinm5dkIHdrh1pSp04ZFjnqQs4itr9uilwDt5ctTx5GH/r6dMKFk84qngcoXc4TxZEJmPxgmcELfTzlJJkBBPU/Xsl8zbmaT9EzCT47NOirSVi2+l+kIRHTeZUBFAu4BKXJMwoDe++dnwXkQezXGpWJxYQM1vt5SrMpJZF4nFMWGfERrIZVCB2AZE/8z5KnI8iRxOZbpKGRENeujid6Hyk1Tke8/wXiaqSVnmXinloYBikl0UdKcIl/T7m2LvtDVdvX/PmTXzsgmG9bChEwWUYB263WwrpvSi1QtUrNhcn3FzHyENpgy5UVq6SI5vIP92Bw+7A2flH8fjVSN/eooXTEUoFKtC3e8oq4g2VH8A7Cjk3j548oh/GrItaLhfcfPU2YxzGaMauZxRTakKgMCXjOORqizGR0Zg0TAOeuqzv7XVlvWIltgm4EW3MRIxSKlZfpMIQAlRNjdaB0/N40+Etrj/k6KRanOAoGcSas93d4IqCxTpiIsvlhuOh4+Q0gs/OOlp7Q1EvcwMZyhNUQ9XEi92YWyodkKCAZQFlCaMs8G2nWC+masy+cyxWJVrecBxhXWu6IfDyVQSkl+df8vD8d3MEGqioCzLm0VuwNmRdX+tcVMubbhlZhKce8Djjp7vaS6PivCeGWY9M7Jdx2bI1sThgWqSiUNlUoVSyIDkCjndfPb714jEVQRPgmQRz5Kb0099yRXRGU1dqajtOYq3fjFB8XhgkXJuVmOLz0wLjSahy8rEQ8DSvsvFEZqpgJp2lYyD/hqz2DijvOfTxMzd6D7pldPEH3d1e8ubyLaGMjNLz8xNC6BmHOImKqmK7a7k4j4tH1/Us6hoIPPwgLgYn6zUEjxcWUgCGYRLm6YYjq/Ujtrexke7Tj3/Gs4/+iEqaspx1KG1w1lM1osDedyhCLot27ZFuf8uNON254Dl2Xb5G1npG59FStbC2j+dNKXSmbVe5FAxQlGXsvJVrVOiCqqqF2g7L1YrVuqEWUBYzoIzOn2cUtIc95WaDlapP0SypF+t70WBRlNRPfj++Z91ye/uawz6Wct14ZLNZYyViGvojECnvRtKrslqjq5rCxxvd4Km1QjIOljUordmLePG+taxrxein3XnXOTbLeExVXWOdRleavo/PvfnyJab8Z5zZ+Duq849Ybz6i9SLsPFqRHhSSZN40p6g5WlbOQoCUXmW1N5n/s8Y4Bbka45RH+xkVQUVZQxVyY67cbxJdI1EHcRq8e63lPWD6frwf78dvOb4zMSBQ90phIAFT8mTx099SuBQkHcjvyGUpeRjkPRPEEc1/MstMC94xCcB6wS+KuYap1jmXJUQN1bxq+pjbh1m24H2IoIMcpxYJxVUZd5RGbXE+sL8Vj9eba3R5zkrKqtViSbu/opEW81cvP2e9eZaFcbv9HeXpgtMHT+mOfwVAWVe4lC4QQ9mhPZDW90Jrvr7+mpcvI2B6/uj38EpHESbA9j3KNHhn6Q6ia9oPHI4dd9uonTH0PU6XWTdj//YVZVHlvB4fBZDPTmM6sL27ZrfvMdpMXsBKzJ/nJfmQ+8twwaG1yf0c222HMRfZVe10s8Ioz1FAxdVqhVaB/njkRNIQ2x5wwVKtY+rjnGN3/RL0Z/Ewywcszp5iVARQjdvjRpeJUmXzEGv3FM0ipwwhBJw9sN/FaKXUUeDpZBEPfNnE39CPkqb0oIKjFFJYP6roASwRVRFG6rJGF5pSyuVmcYquTrJeqypW9K5kL1INzsXIWc98iTwhb/daRbe+yOVQ+bd/Iw9n3u4S0+4ip57OuygrkLI1Fe+9wBRJz+kPQE5xiqAp/g3iiW+ftmiksUy0N+ZIxAyH1DoBPVO4lJqsVPakN/KSiaMR1NRIF6JabL71vfBE4s0/6ZrOXcaTqOxkNKUzQBSfMFM/AKIwlXOglGcGTOlZFoKXmCWuvcVK92q1eEAzHvESInvnKEzDdhsb0q6uO55/9IDbm4hvdK3n0aPfp7v9FU1acKqCw/WnLE6fyWeMHLub6JlCxETKxQXf/2EkJG23L/nJn/1v/Cf/6L+Lfzc1pizwKIpSJm9nGVGshA/RHFo2p46uiYvgmzcv8d7nG72sa0lR4vubZknbHSlMOTm5a0VVLfI1tG7AGEMpN4yzlmFo2Yg6elVGYPHtTVzAzjYrDDqD5O1+S2k0uq5zXw9+wA8dQQSNvR+pFqd0Ig69u3mNc29pVhHbWZ+cQNHkG6pYNrjDMZpsreICbgpNWTQsRZ+jLqPVYyKBNbXiMGgE8uBoYXA+YyIuBJSZ+EJlAarwUBR4Ix405ZJyuaE+iQQ4q9ccjgNdlgGbgYPENEIplTLsGYlrwrq0ToxsWbxlbmZ1dAXgZyRJJcbgPr++MLG+k8mXPpLnsiBWQKqc033zLuM7YJiK0hRRYSp9eSCpkk+VlNjuPqPOZpxhvkxOOWAszcKcs6QwU6k1JMBVo5JVXcoc04mSz80kG+9gZjcZpDU55ISQyJqdqXfH98HBit9q0WBQmEXEOFTZE2hz5KCNwbqR7XWc7I8eP6e9u8xt7EqN7He31MqwEZBwf/UxFKc0gmEEa/Fjn3fo9dmHbFrHl1/8EoC/+emf4X3NH/z9qAp28eQZY3/EVCfUIstfDhZ/d0DJ5F4sNlTVnjdfx4ipKBpWmzNMiDv+bn9DYYpsMTH2AyfLU1brDW0bF8r2eGC1PqFLC6du8CFQVvHcDP0BCDgBflVTcLJuaKSiY73i0HWsZYFr9zt6AmPf0Ygvr7cjlSE34/WHK5xzHA4C0uqKYRhQUpIuwoGu6BnrCGDcvv4YU1QEFKMsQE19jvOeUqwFFgUUWlFVU/dqP04GZEMI9NaTVPXLAmzQov4fhasWdaCuF/n81pWmXl8wFpGENwyGPkRD1TiHIrY20f9lfjMNpRODWl6jAT+RLdMGPL+vpuchKM3oLGWqNmozOTDOIhg/ay2PeIfCBhcNtN5xvMc83o/34/34rcZ3IEPoRfchoD25qqGUmfga8QnRH5l0SGOeNq2iPsT8bs4VUUyvT3T0HFopESFCoXRyvb8fdiWBZZfTmtS8JzllcMQW8VQlkt0hZMiDEKJptfXJD7eBckOwMQpwzrM4eZQ1SvuuY7fbY6SpzfuO3c5zcRFD+U9++TPW6/+AkwcntK2UH49HlhcLSNELnu5wy176UB4+e4r/4q+5fh2JUKODuqz4+tUnAJycndF1A7UqCUrCaG1o6oa2j8fVLCqUmqwhS1MyqoFCIhWcp1k0LIV4FjCcLGs2p2s6kaR48/oSbabGuEN3ZLFY4qSis1ic0FQ1zTJGIuvVOn6+hI91vaAqFjjRLSnqhsoYjAbbJz/bDrU5Z5DoZnfzlkPb5XPhgLKqp/DfFFTNGpuMkrzGdi1Fs8iNmmPfY/0kxaBD7IhP7ooe2Hc+l7V9pq5LabeqYnOi7LcjGq8aymqZI+Hd9hZ7+Irq7O/J3NIEpyYuTparkHnFhPvF65V4Umr2olilDLOK5HTEsUIUZnCB0orgTLyXmDV/xC+T9yYb2GQsJX5LPkR1r3cc34EYUMQLkupX4kbEEzUtHknPY66lGJCUZ+a54ufrDd/4zUxV6/h6L5nOlEOnfDHMTtS9Umz2eJmpqYep8zSKDUWWX1qkUsOfiHXT1iUnaGoJs4O/ot0PVAJEOg+bB+dcX8ayamE06/WC668j4DcMPd7FTtS0wHoX6PZvWZ1GfGIYe4rqNONBfuwJRcn6LHIZHneO3a7jn//z/xuA04dPefzwMUO3x4tHigpRT0LLRKs0NIuG0wsRKRIw+e4q8lOaZsHm/IyluM/XteH16y+4vvmC/SHeuI8evWB9csZyJczWr15SaIURD5W6WbJcLLJYdPCBplmjJew2dYVWAVMIFuG76DcTPKMscgoVm9jkuDsLt7suN5gpraOe6EJMtgpNWRSZpDeOA1VlUHbAiNjSsT2glKcpJ7BS6YlcqFCx01bSLediKJ94ItbDoionk2ql6EfY7g5slvE2ugs911/+nGfn4tuy+GN666aNifCNzS0+TrynZErNjMuU5++MWhC1ORL4KZo4s/msZqzVoASknXWWA2gzu2fS/aEmnZZ3Gd/B4qGJi0Jc+xKLTTE18ZCeCYkHPluJAxPYSZAO2IR56Hs176TG/k1XcWaKVyEEdCCvxC54OUkJAwncXzhCRKFntpjpX5YZDJ7Bevay/R4bzaKoCW7aMZYnK7a3V3LYC5zrWYgtwtn5GYui5/JlVLpaLM/orSdUZ6hBGKSHa/YdXDwVyjuG+vwFrQjiLNpzluuHbM4iGPf6y0/xYcAKDvPq5Rc8enBGdMuU3+41pYaLs4hpfPbqaw67WxrBG7pFzbC/o5Ibf7E4wTDw6cc/A+DQHvn69Su01vR9/O3744Gz9SkPHkXg9smTpxwPh5wr12VNWVa5G1hpzXK1xCTQ20UGZNrxgx2JBl2aUTpxm+WC7rDlzZe/iudGrSjXD/G7GHUtmxJdFpk7slyXGK3Z3sUobrAjFIFFpXL3qdY1Y3czdZ8qRTFzRw1CdEicI60EN0ssYiFQSf8Zo3UsywE3eq6v4qJVncHxuOTwJh538+JD+uI8z1fvkhj3rOrBNNIWp75xE0c8P22OSZJC5b+FMFmLqNSqkRpRvY88qXss65QBTNG29x6lp+rou4z3mMf78X68H7/V+A56W2a9IPeej8zEFFUo4XAwr1srxItjVj1RKjPhCB6tJ2aqytyNVBmJ5SU1K3xP+Ii8J8Sgbl66nanfA8lfxuTXJ0natEP0dsCOA1YqOrfVkvVJgxadzuX6nO2byyxZtzxp+Ow3f0O9jClGScvtq88paymZrhdsb2/oHm0y/RndYIqGVuwnV+c/IPiW/hj7Umz/hLquMfKdp48+oGlDLgf/7//r/8Lv//iPUKbKUVdVlAQUN29jxNO1B4wu8CHmX93hDuNstoi4/OKX7A47tnfxGA59bCYbrEVJzXJ/PHA87rNR1Ivn3+fiwYNsO5FkCU/XqVRb4qxFBbGIqEvs6HL0o8oK73sKpXASebjO49zIzV38jm27Z3V2xtMPfwzAcX9JVZbUIhlYlQZ0xW53yNc0hOiLPIifrTGnjKOnF9ZvVWoKMxN2tgrrJnU+rXX0RMnpQnycPGONVgzWsahUtmNwzkfsrZTelnGkMoOYP8Woxs15TSI4mPgXWmmi8NIkU6Gkmhi0z+8wOqUrKXKGid6g0Ebn6+VDSpemiF4LRSJ3f0njo9KTnOG7jG+/eLiRYMdYQ1azvEupSMyaHYx3DrzNvA0vxtgZQEXd02+E9OPTh4YUp8XXS4dtYGoqSj0WPgNfgGgVQLoY04nTysR+gBlIGz8n4IX/EKvfLqs3dYNlGB2l5O3H/Wcc9kc2508B2N5eEjycrGO+XaqRtu04HuPN8PryhmLxgKcPFyxUvLGd6+nHK67fxjSkXD1m0VRgRcPi8Jb1+XMa6ZA9Pf+Abjnys5/8nwBY/YRDN7Bar7O4T6CnGy2daIaEsY/YQhdJZCY4Km3Z3UTK9s31FTfHI5WIBldlmZu60kKatOrvDvEzP/n0Vzx79oLzhx/INQZMgUvnrjDRUU5A2soYrO0Zj/GmLlT0dQnKZS8Y7IEvX33FqzsBOzuLHd7wQFy0nn70h3TbS2rh3ayaBXc3r3N6UFeLqIYfNMhCGcJAbzWDqJEt6orSuEm5zSq60VHIBtGUBqVN7jxtCgMh4ISzUZk4W4fR0Ui51+sK21sKaW4c9IbWqmm+qngGZ5Mv4nWyeHif0vA5iSsQmPgl+dkwpS3zokPCIKfXF1g/YoKfunm1ET7TvI8qzvMsYP4O4zuQIXQRgAwihWYmlTDnJ4UvH5JU3XzlTWBQfHTfijLlgFN/gfIilyZ/D0hN3CeJw3TqppMLENS0JGmRQkyLTAge71TOKWNVJghHJX5mWRSYNBkB5xWDM2jJjwvtWC7P6Pt4o29v3mBMw5MHkQB2++X/w9vXl3TJ2tAaHp2vcGNPaGJFpl5VXH35OcUiksTubi6pP3hGIQD00O0wRmfhns3FB2w/+UtW6/gdvYd/9mf/F//Ff/Wn3NzGaGUYRsbRZqKZ1or97WtuLi/l/BqWZcWlKJ5ZH1iUdb5CRhVYAloXhFnPjTE682gG5/j6668Iwq66+OCZnKc4tU5ON1QFmDLIuQyUZY0XFuxoD4zDkbqpMaJY9urylj//m7eEMi6+Y7unfLRkL5jS+dlDLj54AYfItjXGcNy+YZBFsl6cgOqxdqCWCGccDvhQYXs5jspjjMIJbtX1kV2aSGFlqanKcmq4VIFC59sPJbdZYRTWJXwh7uKdNEyuH1zR6mczIyUBaM00N0FNjaB5X5ykOqOwzzcWkzBVXbwYo2UmN6m/bHoc0NjgpooNcW7n94gmxT3y5DuM95jH+/F+vB+/1fj29HQ1Ex9WbmKtqVgGTOy22HMCBPJzCpNIpd/81Pgewj2J+BjW3TdsUjqGdJMmAnAPg5GcMbcZzrRBSFmVzzX4zCWZdwjraPCUV3utsWqFrmJpdtE0+G3L/k7MkqzmxdNz3P7XAHz95ZeU5Yq7XUxRnj55wQcPY3Vm+cEzOcqeuj6HEMPqu+vXrJaGSmjeKliC69iIj2zwbzHK8OFHUQ/k888+469/9hc8/+iHPHvxOwDsdjuhn8eooO+ODMd9rmo8enSB3e1YSA/Oollw7Ifp/IaBzM3N9H5FUy1yOO8JtP3A6zcxCticrSmaMyrBUfr+SKXLXFp0BIpA1A8F3GjxIVqTfvoyMl//6U8u2baWs1OxelSBwR6pm4gZtftLVpVl80Bo4Ic36DBgTMIvjhRViaIE8ZY97o9os2D04qHrA6WZrBRu28DgAqdZrNjI/JS0zYMqNVlnWEXswXmfzceVDpSFjuLJADawqByHUT7Tx4h4kh2Mc22KQ1Ru2Zigu29QD1SKUFLqnlLJab47f48mgormKBk3ScF+hgu0zgUcrd89nvj2vi26xOiSSYUo3XCSYOTcK6ma6xkvP4KlKoE9pLRhyu/mpdkYzs3yORESSuUqIDbgqRlvPzNDZuXd+Q8QWCa/3MSL5Tz5uDTSPCevsT7QjnCWUiU3EJxlkHLmiw/OOSl2fPYyllkfv/gB7faSZvkCgM3FKbbfo1WRgVqcZnn6CCtq3yFUHO/uqJdCgVcBvKORtGWnHefnj/CyMCwazd62/E//4//An/43/y0Av/PDP2Tfdtg+5uD98UhRr/j+9yOgd7re8GboqUVnZL08QamWVoyRrAetPdr77KWzbtZURZ1Jd9ZbqlJnHOvlF5/x7FmgE9R7WZ9CKPL59/1A58fsiKaLJSdl4NWbLf/0L2PT2pvDKDqnkVvy7LSiKUpKIbM1VYHrtvg2HmezOKWu1xxHWbydYxwOLFen2e/2brdluRyjyRjQj5aimMSUOptutDgKpRmdp5TfMaa5kqZNIGraapP3t7ooMGWdxaus0nSjyrIKPqSFQD5DSrIqN49OpdcsU6G00NgTsK4wKuTjjmOmg0q6JyY5CVFryalmusPSe9K9kppK33V8dzwPAW78rJv1nqN9Mo+OK4K8Iv53CCkacCQBaYgnzED+0U5FNHlWKJktHCk3lT9N6438XUApWTwme8SMvOQPDRDNeTKIKjWhVOQhKl4PYtastcbgef4o5uiLKvDxb+54/OIHADxsjnzuLcbEvxvlMabCGMUghkFFc45q20nl63BNd7LIwONidUZZrbMVQFWXnJysabuImZT1ArcPfPzZF/yTf/I/A/AP/8P/jB//+EccBNysmjU/+MEPOF1FnGR3e8tdvZBGNyIvxdR40fvwDpwe8MbQCOv0bH0GeHoBHqsAAYcS5HHsW/q7G05OIrdkHGWiS5+KUj7eJcluIBj++jef8dnrget9XCwiNjlFnYvCsF4sqYVkURhDWWm8YExOOU4efcTh+HMArK5ifu87CrFF8K6m7Um17pQAACAASURBVBWJqNEdB5pa0Wfxpei8lgBDowd8qKeGwBCoNLnHxCuDC47SFITEPPaOelVjNlFBLs4zhw1TJS+3IceTIRUOeagDwSWuyYRZzGdo0k65Z5GQKi7yDpgtAlI9jNGJLGreEjQUswqkC9HHYOTdF4/3mMf78X68H7/V+A6Mrh1jcDGsUvPgCVn90u4dcsowhVRphUyrpJeELsUk90u96SPnDFMIEnbp+6+R/59ek7VE7j0fj0UxhW4uV3ailUR8kYHkiSuf0bmCXYiRxHrzmA+LjsvLaJ70q8++ZnPxnA+fxe7Kl5/+lM4uWAqNudvfcHoSja4TS7Vcbxi2W4L06HS7jvZo6aWbtaqaKLMvqdKiXuDWpyx3sbLy4PFTdsMVVVXz6k2sSvzFT3/B3dHyi1/8NQD//T/+r/n7f/In3N3E9MD3lma14UQqNqMFpSq6IfFbxmik7DwLiTxOTs+xo8WYGDFZO2DdSGFiFFZUJWPXY1zqut3grM0MU2tHcHvKIj7+m9+85J//4ivqqqaUFGOwMY1MXJCqMhQlNOLrUupAoSxOPHUP22tW59+jkJSu3V7TrE6oajgeYnSyt4HHZzUHscNwxEhytClkh1U9tcIvirhXlyJyHXRUyzVS/fLB4bxBe0MjlhtNbahLgxFP42v1jN6OOUpIU33q7QoxSMhRRvpvATYQTVU1RSLeR83ScpLli+9IczPeeNMNIN+XsZT4Y/AhMCZFP6XwIUpVZJ3wdxjfgQyh/GduwZbHpMasgiMGRpNYrsJHfdD0WaJFkFAJpbRIo6W4bp5exHQiu8Hl/gE5hlnb/786EJv+PgeoCq0gKCxTaVZpjw7fEHfG48Qhbn3+gpvtv+STT38DQLO44OHjC+7u4k38xasti/UTLt9EPsX5+gxtSjAVWvRGBzvEUp9I2A37LYftV7QX8TuW69MoiCx0du8DddNksPPs/AL/+dcYXWeexur0nNEq7nYRC7i+OXB2fspBSGBFtaBqVlkLdOWBrmUhIOLN3S1tv0PrkpX0iKzW5xwOB5RQ95uwYhiOBJESKEzBQlvGu7io3QxHQoBFHV9/9uAhm6UntCLK/PkblIm6pnPB7BBgJbhjVXjKYhJ0qkog2JzSBQvdzRecCYC6u7uhP95SFwuCjilZPwwE7xA5DzodqQRJm7jQgbI0GDHk1sqjlc2ksFEFRuco6zTPSnzQOBuygdhyuaA5/RHORJBbYyP+kbkFSmgEs6KCmlzaEpFLm6lIoLQAot/gfWQ1dRXbMeZp9z24QDo85yQIaz3ej0xmXhEn8R46WVzfZXwHRtdKyCf63oIHCLszDq+i5LBiIhz54IXMk96g8gIC0vM3r6wINTTcfxKYmzrNo5J08lTOXT0zdfZ0bIRsSqWj5ZOQ3OQr0j+degEiQajX8aYL1QXKHjg/TfoeK4Zuz9ur2Itxt+vph684yGLy+OwhithbUazie3x/h/ID7TZWLY7tFnddcP5EHOJMQ7t/g5ILHsaepjljcxKjhuPuhvNVxenJilKMofrjgcuhp+/EMNo7TOizkthisaRZbjCNLCZtR+kVxzaKFtmxgxBFdC4exarQ+mSDDppeGKajszTmBC+PtY5Od7UQvr6+vuLjT17xB9+P73/x439AuPuS3XU8F3e9y1yeLPqkIhUidbgu64JlXedqiqZn6Pt8PbxV9N1AaWPkd/L4e+zffIYb9hyFaLZcNhzu9pw9kIqNhaE7ZvWxs3WF0QHbx7lZqBgxpEbPqlD0FrwojZW1xgWD9Q6X+noWC9TF73Ewz+P5DmQ1+Xjc0ZUuk7OUuscmLZL7gJ/ja4IRJak2H/+YO3WDjc2eCdPzHj0TwAlEUzPn3GQEHqJdA6JsV1R1ZEtrzWgnfdq/a3wndpPeu3gi0JP8mZ6IKiAdnJK6pFpgzGrsrEwaceBEvoo89Sl1yVBTuhhaM/euja+JKcq8lJiji/Qa6caNxzBbIeQdiTQ/XYL4aO5p6zxUMnmNMpyentHU8cTf7QaWteHTT17J9xXs+y2VKI0RHKpYUzRLSnF3O24/p+/uOO7jjT6MltIXmDIuUIfdW4LrqRcxUtGmRHuXF4LV+oLHj855/HDHq7dx91ifXLA8e8jLV58DsLu7BGepxNKgrA4s16dsTuPru0OPV4ZSAFRMSVHUrFYPOT2LKVhTFzgbshdtMbb0w0gtN7ZyPaUyiDYQ/duezWbNB9//3fj+ZcXd246v30o60Vvq0lCoqWITu4ENaxH3acqCqtI0lVQ+uiOHznKyFqe79QntfsdeLCdUXVKtntAfPkGZeL62d0fGdmCxiNfs0dPHHLZ39OIV872//1/i2ju++nlk7JZlwJQVxyHtzh6PyUQ/XViUjoS5hdDkl8saX57T+0QmdODdtNkpRQg2t8tD6oBPC0Gqxkw3uvMe7x1BIqIUJU9SnOGeTWQKoif1vSCl+ikaz5BCFhaP6ZgumoRrv9N4D5i+H+/H+/FbjW9PT3c2hkBi+jQnj3smCqwigjIRnpjhDX7SIlCiUZq8MeJDlWveBHevZBozkhSPpFzU56a8PGYkG58A1NwklCIiCfvSLjEDshAMN4WKqZkp033rM6rmlPb4CwBWm4f85ld/ze42RiL1okKHnpNNTFGq8z9k+fTHqLBn7GOKcHv5S4becPcmht56ec7y7AmXr2J7vBtfUD3/HQ538e/N+jHnD9csluIFUxU0i4aHD064OsYd+4OPfo9h2LOSsunN9sDhbkQT/27KmrpeUot+x/L0nHA48kBSlKvrN3g3YsqKRkR+V3WJ7zs0MTUa5bqlNF0bhaGnSlGDKVle1JycSpk6tBi758vrmCq11tKUhllQh9aa0kyYR1lqShPQXmQBuo5htDgff3uBAcZ8jQ83r8S6oWZwcYrbweOU4u4uRjzLMaCKksUmRmEf/PDvoaszvPQS7V7+hGBqtKSJzrtItpKy7DhCUQRKbTldi7H42VO60TME6S2StGAOzkvpQOaRksa2KUqIt9GU6kSZTzeLGgIanT2BCLE/y+fgRqFDyKVzlMJXoPQkzhW1TDSpsUebgqArdLHAf4NE+a8b34HpU3QpQ+l7BtIqqDk3ixSdZa6HPOuVJszCOKXupykwFz6RdCXhF+liKE3uKhROxz1PnDCZ7Tnvs1OdvCEfCyDKTMk8e2Lk5YsIWTxWJCuoCsehv2UjYrtvbt/w5uurnE8rd+Tk7ITnf/ynAJz/6D+iCC3a7rj+dRTzubv6kt5foAppfHv0fa6+/MvMVtxsntLur3J15vbuLZiSi/OYThSFYrlY8fTxA17eSAXm7JRm/RF/8y//PB5osWK/bTl7FHGSomqicpgsQNv9ET06NpvIYr24eMLl657FYs0yNfnhaepFnvBuHGjKEictxcp70UGNU+v8ZMmAYSWK7Kq/oT+2fLUTJTEdiVKVjqQqgCF4zhYVlTAiTQlFGBikc3cYjhilCaJGtu+29G2XSXoE6HbXLCrNQdTdPFBXk/mUNnBzc8vmLJ7vdveasxdPefEP/jEAX9sdb2+u6Ma0kQVKo3LntC8M3gVKYzMYrNfPcZipg1glU+pphimlJYVnxsWYKpLxtN7fhGPHa3yktZmcAOQzzYxo5oVpNidSalQmm03fN6mPBWdxskEW/wa5yLcniWkNWmdaayZ0hShLGPKNHm0eVZhTaYOstvOVeV4fMXIS7q+GuUVf0rgohpI+Mshp+f/Ye49nW7LrzO+3TZpjrnmm6r0CUIQr0BvRqpvNCHYPNJBCA4VabqaIlkKa6c/SQCOFGB2atNQR3ZSaVNB0EwQBAiBQAMo+d+0xmbmNBmvtnXkfWmARVeLobkThxb33nJN5MnPvvda3vvV9uZ6HEGX0PfpfuUYph7liw5xL5pxmkaKymJT3pKwq7PoeHJuTM3L6AQAfvfchbeuxg1Q5Tk/f5Cu/9z/y4Mu/pd/vQB4Gxv0LsraI5+joTx5VUeXLD/+SmBrWZ4Lcj8Oe3XWi1ZJpDJbbq4vqg7rZvsF2c83nn8J331ex4t0lq+2GR09/BoBv/Ns/xv+z/2kmaFWyXtHis6RpJAc5pwen54Tjnq7t8IrN+DSAbSqQ6J1jHI94BUhtnjA2kDV5fny+4YNnR24/kkqT70Z+9PGeSwUPvLfEmLCtx5YyeYBHp76KE9tscG7N8fBMr9VE323Z38rCEOLE7dEyKZi5aoXRejgGRnW5HyKMEdYH2QC6pqHreybFPBxAGlmdy8K6efrzHKa/4N0Pr8uDQt/kylhNUSba2dZwqg2QMTtwHU2d6LY8oPocAdbMrGLjsLYuJVX6cIkXVrJDYTvrYnuHamCoVASbBX+sP1eRrLnTXEs+dVIYDCZNBHItf3+ScY953I/7cT9+qvEZVFus/EdZEUsjUSRiKn4BsgrOjHtqalAJXBnlgsjKvDQBluHALIV9NELIS0Mp9G/zyj0v31pmNfMLSx9CtfyrZJvF6k5WPGdRbclGazLQGINzhklbxFs70DUj67d+CYC3/8F/y6Mv/iIx7PXNkUgDfsVqJSnC5975ba4Pt3z0N3+mx7c0qx6jYMLt1Ud490blhUzjDbe7y8pvefK5U/rO0+SBjepcTMdrwvGMq+dS9fnyl97h/MFDdqr1GQOs11t8e6vXG0zKktADhAnvPI1tMHFO63zjYK8RWgykGGvY3DYWEgSN788fnvPo8IIfffPfyWc+fcKPXl1TElUvl5ZMqg/j6arlfN3ivZYSXdIKg0Q3edph2omDykIep0x2ljGrtWQGZ1rGKVYSWCFaDSUSGQZCgDQJLrV/+QMefenXK0lw/fgrPO02vP/8/wTgxbNnHHKm70u/08DKw8PTFdunvyC/236BbB3ezqmRyalKImAtxjoWJUlyLSGqWHHKQkFnfg5hEbxUj1nF8LRZdCaiiT5IrFFFnM2xF70t5Lwglknk/feu5yH4AbV8FHNJCqMuDuVLOWnfMa+LrKbFglO+jObPAM4vlg8BKpeUjmygMlNBQNlsZvNtY2fAVX82mmotx7JrMecoKVTxU8WS07yQZSuLYOmLeH7saNtf4enPa7PY+gfY06/w6Gv/GIBme0KIh1nsOEE0Le3qIVnFfZo4kp5/i6YTbCH7BttsK+syjgdCCEzaODcOicN+z3AqEz+Mowgtr3p+4WvSVXsde26u3qvszv/kP/0v6VrPy1eSlux2B5p2buwiZ5yZ08IQEzEE1usTvPaEOAudawiKHRxyhjgQdJJOPtK6PIfLY+Tp53rGg2A3L292vHdxU7+XNYYQErb3JH123jjpWa0a1it5T98ahv3Lmf6YLTe3B8ZQyvHiNq+EVMnfc2KIs0iUN0ZT2Dk9Nfp9AV6+902+8g//KY2RY+Y3f4a4OeErPyts3N31vxJVND0H8ZaJnD98k2YrAHPu3yQZPxuk62aal2jwwvulpA9LDY2yLNxtVVmkzEb+aObHFWPtTLDLtqby5e+5EM2W8wAqZSIZyNZhc7wDXP9t4zOQIQzkHDDRQI6YhZixtXk23M1BIhHjmDlast/P78h3AdOUxYDpDmNu7rqFglGY+lAUOnq92lmqPFVuLguYm9IMyt6h7gI5C1HM5kJFFj+tZUNfXqiTvTh2YL6C+/LbAHz+i4bsWtDJkMKoi2is5ygt3Z6sJkQ31+8TRqpZUtN4Qso0jfI6TGLYX1cEP5oW61p2KgNwefGK9eqEh2+uYSvn/W+/9S72GPhn/83/AMBX3/4qf/lnf87tUXbbZnPC8xe3XF4KPwID2bVy7kjHdOc71usT1spkJew4hkBQfKFtO8ZbU29JCBM5RdZNr/cHsaHQmf0XP3rBPgRajUhjzjTZ4M3cSPlkA3m6JPkSafRM45FBu2ytNRwny06FfZyTKlDZffe7gc5rlU4fwMYZ4szup2ks2EyjpuD7Fz/i6tl3ePC5/wCAbr1lIvHWzwpO9cNv/wW3hz1OUXIXE5t+pFtvsBo9jkYNyEo0mzPgQdv6M0afvxoGSxGhPnd6D7BzoaGAm4U4mTLGZfydOQCzRCeAXSxIRVScOwdaFhEygPOY5DD2k/PT7zGP+3E/7sdPNT4DnkciRUV8zTJfkmigGt1YobHf8YHCQg4somZFRXTlLmWuihLL8lnZdYhmSFqw58oqXRh5FgPGUSwtk5ForbIZtXRca+Azj5WwDP3yTKN3Vq1/dLV3NhGGkXHR+0Kc6t9n3ZFSZ1c5u+EF48X36+UaU2SrJdGLqz1t52t5OMXIeNjV6sDp47eZ4pHrVx/Xz/zZX/pdvDe8Ogr2YmPPf/1P/zve+8bXAfjDP/gDjtPI7a1EK+2jR+R+jVHm63DcM465etU6k2l8R9v2NW0ZjpExxLpjYxOHbo3XXf9kdcp2vSaoTipm4Ls/vOb7L6Rq8eI40Li5mrBtLL2HzhuCljxPNxu8GdiqL0tMkWmaavq5PwLW0KllxP4YMfuRjXrXpjxwGCa8mc28ukbuQ9tqumRhvfazLskx8OJv/pTtY8EvSJlsPQ/e+iIAX/2l3+F73/w3BI0qNoycna/xq22lyVvfcseAqVDR87xHG0uNekvUUf9qigiVmSNn9XiuGrs5Q4RYn1+5lKZaRujn1mdP+BL5TmNYqqzwclLWGIz3WP/JKaafgZ6HDPGHmEVJcp3Yhbxl1G19eSEEzCk3MGXIuEUIptqjcx2WpZiK/OYuwFN8WErHgAGcCVVTwWZx0woUwFTOtdxPkwXkEh+aUiosWWipi2teWqjKVo5ZPELk3/mxENWsXIGzGCOtGfDjh5xsZLHY3YycnTzg1aXk2M55jJ2/W8axPwZOT0/1N4Fxf0uyMmFW/RnOd7SrFZut4CLvvG0ZL19wdSW8j8uPf8hud0vUtOTVfkfICbcV3MX7joytOXrjO1IHbdczKYcijBPWWPoTSWNurwKf+/wX+eJbInTkrCxCNx8LJT5Nr/jR9ZELBTe9tYQY6z3ctoZNawgp8uRMFotVlyC7qhQfxh0hRqJqhU7JkJg9ddernsNhqACrsYYwZRpvcPoa7wRoX6uz9ckmsRtiTZ+61YrDR99l2Mui51dn4Nrah/WFX/sn3F59zPVzKcc3tsd1K4zvsAWjS0HKtXPx9Q7cj26GZkEdX+Cl8jeE5BXL+pKli7bQBsTjRgmXKJZRQVTZRJydCwby9UUVr867NIlYl1l8BuYOePtJxqePPMoCoSdZCS/GEI1ZVE6c1LgRBBjk4sVFHdxmaa8vjNNSqa6fWdyxamNdxJUJvTypnOtExmRIs8hLYpJFSt8Qahfv4obrAtIUXKuAsvqeaOQByLX2bgWfWbiJkeePNBUCKw+ypYkjLh04pjJRPTfjwEHVsVbrc6YwUaKwYTyQFlKIw/GgBtMC8I3DBc8++CZf+tnfYqMLknuy5sO/+lO2p9KoZeMIaaoO6sY4nMkcXolZEn5FtznFumLu3GBbiRgn5aMkHP1qS78W3sfpySlvP3laLST2uz1hd8FH3/4L+UgDj84e8v6rq/rdvXWc9jKJvdeGOGN5oFgNPtM3K8IoE/k4HBhDImVZTJqmEdGirOQsB00Ho+IwMYqwcTQZWz4Sy8nasunku+8OE33XEbX64tqWeLjgePm+XP/+AVhPVL5Kf3LCO//oP+cHf/wHcv1f/ZAQLCYszcFm8yQQLMLCna5ay3ISy5NeXRLzbJw2b7BSSHgNoZgJXqmQyApOmEjGVNW1uVqTa7+MqO1RXfxKtJ5yqqpnn2TcYx73437cj59qfGZpi+Rm7k59Oi8wDhEzlp1+bnU3Ghaa+ecQanux8DqgsOvI2sGrf8/KJXELndNicVnR6WJFWWrcrxkGSy6oiSIlzBPKfM1NpX47l8eswTiLc7O5trUW6g6kWEq5NLbEHhqpGCNaE1dHdlfSq3Jzfcnlq2esVkI3l1p/Syg5eRAbxmxl9z0MgYyh1531+tUHxGnHky98jXPtgH324Xf57v/9L/jqPxZavM8JF8ZaRo1RfB/L90omEWLEKwaSrafdbnHeMxzVUtE51qfnbLeSLq29pe9asmqpdm3H890F46n8ffjoI37pnS/xzR9KGrPuWrarhrOuhHHSXv7Gww0Ptf+lb2HVO8aD4lTJMQbLoJti33e0rqu2FDFMtF3DcCz2EIYpGVpSjaJWTjRFbpVhKn1UY/WmTcB5B8ePBR9qHn1VxLUL83gaWJ894qu/918BcPvhX9NwJG4ajloyjj6BcaLxoc9aNswVSCPVxjopchIm9oI2UKp4c7FkEUXD4tku0btEPJUrophJjCUtd/rzxLLzNjOzT1PO0tafeU0b9SePzwAwlfbhqs+4KDGJXof8HDGgk7wCkTnijGPSMDrFgLV3HbVKi728IOk8XuAcWdKI5XFL+bW8QLLdBaiRZ/Co0NaWN9AYadirvBMrH1jBXi0nl5KctSVNmcu/UiLTBck6wXXKSfmWdLjm+OoHdVIed5dY2zAMxUOlwzSW4171R5ue1eaEa3WKD9PIg4dbJnWWn4aBTOLm4kPWasA9xSt44wEkSTk6wKY5xCUmpkwlbJkkD1HR/Wy9p+k2eOfqPUnZYV3DVqUBVt7QNw1uLRP/5sV3aB5v4bksQKOF1sHb56rQvlph0q6G4dlA2za8/ea2Otd5M9G1jnFfFgOH9Y5Gr/cUDckk+rZcf0/KE6aE6sHSNh2YoXrTppQ5jImoG8I0SfrbK4CacsY5z/BSVNdOwn9Mdp0oiwPOWmKcaHpJ186/+puQE1NKsyJXLJtPSRUSccFLshaSCYtSLvrvAgMpZdTXfrcc1syaN3WUKaLFgEISm6KkF6JBoy9VX5c7qdFrPV6fZHzqxSNOA9G7qvpV52hKYBZsFv2b9IzojwpW1ouTSzNMiUQEpKwgrGFeSMqrfkyP4+6w1qnYT3mdLBxzY5ycdxV019gpmnnBcaV+X45rRd2saIZYayXXnQ+qeeWcU4ZkxYpQv0g+vsLkkV4Vumx+RY6I1CCQnWcaJsZJJv52+4Db25EXKiF4froiT4G9mi0Z39AZy83VKx6cC2kppBH3tZ/BrAVk7VYnsLupzXWkhDENjXbVogQ6X5XoE23bk8JUAbv+bEPb9rXasmktq75hUBGd25tnNI89H34kFZ8HJvPy+oJVo5853ZJtrkD6GAJferjG5UhSUWX8DdPR4qw2wk0ZYz1N6clpemKaTdUxhphcnYyusRgiacp02ul1PSQ6b7FlqbSGIRpOGsWcLNicCLeqwXL7Lv7N3yKHYmFpSZiKF5EStkz2cpezEYiqbhoilF2npXKSaqOnnrt9fSGA2vwW0gzUy1mYuxsqWtGs0Uwmxdk0KpkkwkrO0vg5Us7yFQAB8Ofd9v9jIv17xj3mcT/ux/34qcanjjymOOKDr7lY5U9Yg81poT8qsn5ifaCRhaY2pTO0pAklFysybby+Mi8wk5l+nu98xnLXt2TtKZDzwlBzwqx4R9nFDKVkbGvkERWWKbtBThK5jPoZXutDszScSAKU7sqYkhgbFUtLDMY5Th68xah2AcYkrKeG5sM0Mo5jTSEOU+D5R+9xdlIYp46rm6Hm9A82DTkcub16we2NVE+cmTi+9w3sr/8aAOunb2OvXmL1xExIODe3qWff0rRrkkY//fYB3hqyaYjKbO27NU3b4UsZ2liybdldS6RxDFd02fPilWA5L8eMHa7o9VoexAyGSY/x+dOWR+uW8Xhk1c/085xyZYP2K3h1QzWSMjbjXZ6LGMkyTqlqWnjriebIEHOtOrjGisl0np+TrrV4ffa8zSSUKQ1cfv1/4Y1/8AS7+by+fpL7u9TKNVmiiBoBaTtGYTPLBVrgazWhKWcO2VSeSKGqF+PpchzH3NJhauQs7wmaFhVcZOnZAoIxthacdRTrBYwTBcBatRQ8zvLvSYd+wvgMGuMmUpqwyuFYJMfkBWjo1NnNW+5cCAO1ZyE66iQHBTOtnTliWfpLyiQuhzN2bpiXPpmlnoGqQpcPTXLDCs8j5bkmrgfV1uhFOmWk9TzW85DPKwvOMEX6xs7NSEVnpMgUaE9FcSdzDlb9GndsSfp9V6enJLPj+lY+ZJoGYjA4lQR89fICa3LlPhyHAMbx8EQ0Oa13NE3Ly+c/Yr2RNOXp489xc3XLD95/F4C3v/iLfPDBB9VDJYwDOVO1OFb9KU3TYhUw7fsVzhq69ZZYpAOmica3M57jHClbPv6+YAXtaebD997lIy3N4jyb4HjY60JrDGNMnCkB7IuPN+Sc6HqPt4XYJ4t7edhPNw37IbFXevqqWZHdQrjBGLzz7JVL4hqDMS0pHetG46yRln1dYZwxbDpb061+65RCoGS461dcff1/5vw3/3u5p80ZTsv49Z4WAmTlJQnQWSAlkda4q+dxx485awnWLrC1H8M4jGq3zkUF62aipDEGu8ALQha8rj7x6rAYY6K43xUxruVhTDm3v8/Fw3mP9x5XV0/9R6ses0aoWdLf5FdVA0RfkrnTvJOFUUbhOkR9cV0IClBJvrPaGuYbVhYCFueXs6kgYcoC8tbKCAWNXt7kcvFnfKUY6ch7LFOcNRRADpcXT434+MhRfY74dE1IcPLwLTmPMHB7eTV/jxwJ0czGRhG6fsOgmprZwGrdsVrLJHQWLi8uGY4D7TuqnpUSb7z5Nt/9tnTqvv0f/Srv/Obv872//oZ85rDHjEM16vKI3sp6K4tPniba1SneN3Qqqty2LY0Rl3m5hy0ff/evudwLP+LhkxVf//q3aj79ubM1t8NQla+8NZhx4ovnavvYOlI2eOux2o1KPNxx6Gu85Wwda7VlmAZ675hCWZwnrG1oXDG1jnhjcX4mKcakhCy9JZsusxsDXVlcvCFlVytmxq0ZLz5k963/FYDTX/gvCLa/A/SifIkZIpfJXB9hY9RatUKVik+Uv+uTpvfc5dKdnhcQhDxllVRts1T+dEe1BvIsCgbkfjwHbAAAIABJREFUYsSob5enUmCNMB+WWY/G6oaeUv77bYxzCEvzdRuFKhVfw8RUeVLlYnnvlrHcjwG9RgtKc6WkWDwUNHtZXSmrv7vzkKSsyHPVaZM0KC4m9rK+M+sp54oIOT2Hwhe0ufhpzBGQ3OCSMiVyMrONpjH1XAFau8eMF6xOP08cpbqyv31FJFcwLYVIjA7UXgA8IUHQ3dd7z8l2W7/38xcfMQ2Rp289xevEbvotP/fLv4Z5LB65f/in/zu/8bO/y9s/92v6ng+43d8ylKgCS7Pe0qmEYIyJVb/h5PwBXs+rax3rflXlJZ9/71v86N0/oXkqj9JH73/A99/9gAdbWdQO40iImUlLuTdjYGsNk1aZzIOGzjfkNJcSp5hEkqAp0eNE6+dJNoZAM3m8lQXtMGQcqaYg0xTASSRWurzHoAJ7pfLhMrsbw+a0gJvS7ZpQqv6Q6Po1+eJv5Ocf/B80b/8+uFV9bgqknmqabe88ewVkrtWt4lOrzWfCwV46KyqZ0cRZvtNASrYuFga5NiXyKwIV5RCtkzQ+LSp/KYula12Akk6DBfu7PMN/h7XjHjC9H/fjfvx049NjHqANbVnKV4s8P7OMQPSfOJdvhUzj6spsrbbs3ylDzW829Xflt2VHnzkYuXhflGNopSvqrhVzuuvzqefKMlDKGpaWc7ZizGMX3yXlZfhp8M5SE6qcyNmSaw+DgFhOQ/cuX0gZj8zuWhrbjOvpNo5xeKWHSDRupjIbMtNwZEpyy954c0vrHc8/Fm+Y3W7HyfYBIY0VN7JNT/9oTXwhXBD8nq9/74/4lZ//RwC85Z6wHx6wO0g0M4yDSAIoZduSOd2ecLpZsVY6ec6ZfHvBex/rjuz2TOvITkuzV9fXnPSralz0ahfEHd6oILJJhJS41Xb6pzR0bc843s4u98kTYsYoJ8N5g/OGTp3ZxlHu+1T8b/FiSq33x3tL1vs8FWAcI0CrPmshGvWFmZsXwWA0mgk5c7Mfq0fv+PJbtNs38Q+/BkCyDca0ClSUY5QoWO+71ZTYzH/ntfRaGiz1sckJchBsq74mkZnlH0TYJzLPhhm8LffMWDMT//RBNssQv/BEloCpMeSU1Kbhk41PzzBNCVIiKQmlKoojE7DqgBqryVmeU5kSphfdjATYuzx+a9yPATzzhJJJJtz/1+vUJexLdxHkXChjiwXEzGGffKaI2cxCtWjKVNKlu6ZQIWViTHTlaiYYw4TNpUcnMSXotJLSpgMYyzRNdFt1rA+R/OoZuyK600wq+lLSvsBuiFUtfdt7ri5fcakM1a5rub3+GPI1x/3PyWk/bjh//Aa7PxMVr7OTh4wx8O7lhwA83Z7B8Yqtiu6cnr1BxnK8lcXG+TMePjzHTQNH1fw4Hl7yN9/4I+wjVR3/6pd49u/e5Qff/b6cZ9dwsm55pirluyHwYNPwcCOLz+NHa6Y0MY1HvZcJZw2WwKgKZlMyNL5VVzMYxwgp1IkfR0Nq7ULp24Az2gskPTnTIOzRVMWoVKNlkWpaOxPmEgK2ly7mvm0ZQ2SvQMtZG4kXf01z8kSuzeqJgPPW4Bds5ZRnrKZgZxW8zApkFq6ISbIxzYq6oMpfNf3X/pdl9TCnRXphdBHSX4gn1FwBMrpIGDun/zlJN/yCSalYzSKd/wTjMzF9yinohWI+IWPvULSTGtMsmW51rS4LjslkM1saiEjPounHCMhTlKWzKRHOTOed/W/rIepry2cKOKR4RFYyzwJ4sRhMnpuq5PbnCptEJe60lfNliDES9Aa3PrO2uSpjWQw5+4pqNXmg7bY0vcUGpaMfL+UGF2Fha3AkRn3Q9kexWzzfyg4+jQfGsbS3wxQmrHGyaxfXs27Lydk5jx6IqPLzFy+4vrjCeKmE7B895dit+fiv/xyAVX9C3zQMKiy82Z4xjR9i1x1//C//N7mPzvDyxQsePVSh5hcf8Pz5K+xaSsi7cSJNsZaQv/zYsmnbWkpcnz2kbxw5y+JysukI08BhCHOe7xyRuRQrql8wFgOm3DAOsDqRG5Ai2GQIRRkrZ6yzmGQrbT6mTOPmylrOatzli+CTu0M1cN7S9CekJBIIQ3C424/xz/9E7uFbv4drHykEWjm6wv5MpQ1BH+08HzMtFhMplxq0XFKfTYOpFci51LssES/A+DRveHpxtNFQF8UExqm6WKnIxCyRuK5hzoqbY0ypdrh/knGPedyP+3E/fqrx6Xtb5sDhjiiPsQaTUiWzWLK2Hi98W7SqkRd03RzuNsoZmzGprLqKbxfH9SThqDGzzKDoPszIe3EId1WIRyKVUloWHY7ZSrI2HpmFyZN1spssCEIp5UU+HWlsnCOmZFj7hYgtYIzHG+0xcYnWrwTd72THNr7DuBXGaenVjVhzZJx0B8mZzcpTvGpvry/J1mmfAvSrNbZZMYyZi0uJLN467uhT4nd++z8E4F/9mz/i/Y8vCB+/C8CbX/5lfvBqYuckdTppOj549SEfvS94RthfY8lsHj3i5ZX6rBiHdWsurmVH/vjld9gfbyqe8+BkzeQCq14ipHXXcnl5ydmZ8FHOHzwAMq1WLcbjDbtjJLKqpLqudcQ45+jWSPWJhU5NyomkDWhYMC6XDZxsDNY5zDRXwJJiAUF3dK8eseX5NFmiWqsWEj5HNo+f0m6fymfuPybmPZN6CXv+kO6NX4P1m0QtMSc1sk41zZayaVxs5oVeXh4Ms5BqkHQkK62gUAs0rlj0ulg7P++pCIDXlD4p7iI/F45IZNbyjTmpcPIcoacSwb9e8vwJ49MvHimKKKyRslO5GRQAqmYxWl4yC8BTyS2zM5tB+HTlKRA3raI7IK0v8wIFkHGIUlg5jsSKZeI7xSpKmTUmbToqi1wJFcv7tYYuqEjBYtTVqzAeG8cw5drn4K1wQMp5BsVg1uZS3z/h3AOs9rY0plOjqljxnW7zhH414N0zfU8gpfmGO5NZtYZRNS7GMZNsj2/lwd0fjpjjSOsb3n/vOwA8fPIzNKsHnCuX5J133uGvvvkNnquT3eFf/3P6Bz9T+37+6i/+Hy4vPuagfjM5SUeyu7iurNTOWZzJXO8ltYlhwgJONwBnRlZti9WUbbebePjwEV/94s8A0HYNbWu5Vt2My90NbdvReFdThhgTjXekoGlJGgkx0pb5FBO2gVFV1YTz0hNt0atIWN9jjCMjC7azosrmFXdyzmBswlR3QumBKk2aq94Sds84eUuUxdqHbxEOr8gHwZjG4YC9+A5tPtBs5fpOZi2fY0oqGQlTqOmCQeZBAcvqY1h7vQRgzcvmxVw4H68tFjUNVxylrANxkdLUtznhNuXXUvUF8xXVBfkxNvdPGJ8eMNUDWnRFLLutEQr2rCAo01EW0nmXX6LVYLFmJq+IuPJi5TYZcrxzDPHHmXdgkwFvFui0PhxpzksNLC5c1ginfJ2Cn5iqRpZ1EywXP2HofWZYKIkZI8I3IIStkF1dTPz4Ht48x6+e6DnKE5My2EYa43wz4tu+yvk5FyViqguWxeaJw14XKBq6flbEzsnQrXq6vmO9EjDz+YffZ/vwzbrDfPELb/Orv/wrfOubYov53gfv456/qBMm54mu70lq+pRsZByPJGuJg0zUMSdijrhCbEJ2c4U4ZFFNExsllT169JCf/eqXWWskgnNMwzXXKsLctiu8b8gpYsyk17fgHHIepEyYMlMRlE6GFBK+KbyOCG2WFlK9h7gR10ATXL0+KUGrQNUYkviV+bq7YXImKkaSXE+TBoaPBA/afOm3ad78GukoGBXjJXG6JhyuMK5YfmZy05KqqRMSFZUooQCqFfCXzTbVzVL+L+VcafIFEF1O9KWaXnGkK1hFzNIZXZ97lUWMi0jDqsOiN4VAJ0plKSVivMc87sf9uB//P4/PAPMIpBx0pZs9M0uZozTfZGkiqTwK+RtgEnOtXenk1Z9DEfeCRudCN1fPWG2Vx8bXhJXvGFrW1VqOme/W3rNERUV9zVhNq1LdD2ico/G+7hAxJrom46v1oITAZXfYOjnupCbLfR5xxw9wSdIBs3ooKLtRrgByDr610jYPeHeJNQFln5NI7AeIRbuycUyRKkhkvcM6Q9M2vHohKUHT9ewuPsBpNeCtr/wOv/mbv82VllFfXrzk6vIVt9eCkcQkJT3nNKQKAeekaax4jYSYVGCmGD4f2Ky2bNcSWYzTxLbvePRAcJS3P/cG1mWyLX4nB15dPKM8epv1mv3xSM6GRvGGnCdyjmKgDpAjY8xMin01PhNCwvk5hx/HSawWQcSvp6QpazGOcuBmz9eYwBtfd/jsFRvTezpNE5vVqgr57F9+l03TsDqX9CtOb5LDHsYLomqqYMH689KqgkOkOGuR9bXeEXP3/6QpLitnas5agNkMu2h5zJGHvm5hwm6g8tmzRXuuTE1PBQaZU+KUIjEKg/fvUm35DHgekWrwtBApSSlh0lQvQlIuROkK1G/K3E0iwJjUm2fMw5iMyXN4ZZhr2MkaTIoo11Y/wwgno6Qcr0NAKWlZeVG7XQK9GLxyAmIFmDI2BlbaCGGtVOYLZTsaIR8VXkgi4UysE8zYBpMCqGOcyWcYY5nGXTURanxH45u5Z8Fa+o1jf5RjHI+ZkCyxqD9FQ+ssrfJCDA7f9Bz211jFaq4vX3F98ZztuaRLUwg8efqUJ0/l5/c+eISzvjxdXF2+kPtU+BZhwpCJ2VYtz5Tia2leYtW3nGg/zPFwy9e+/CUeP9b+mDhgrKFTEZ333v0hz1+8z/ZE/F1tu6bFkMIR58oCYzDWMxXb1CSnuB/KjEnELLR3vUGkGHCu/AzHONF4fT4A46BxeeZo5Yz3lrE0CR6h73p80+j1tJAnXFPSyI60e0FWgNt2D/CrR4zhEUH5JTEfsGPAlB6bZIgLNXXRMDWEsvnNFC/9s9GO7sUU0cdzOczil683shl99udjJmyOSqEvz5Zn6fNikyXnQDJ3WQ5/2/gMeB5mdlOzCVdUlSgXQs4mqkoVi8VDihqGWfk5Ss26foPIFDK2qoi/1gCXtW17odKVrSvruJ5fUpdweU9yki8vhzVGLBQBZ6xOmLS8rUDWCgB0vsEai3aIM02ZVTvfnBANPk94Betsc45xz7hzX9JITqFWV6x1dG2PNs3S9j23hxsOB/nMIUitvgB8rbM456pgrWsE/3Cuq673m9MnYBvGvQgIXb98F9f+Ar/0K78BwLvvfh9y5KCErZgz0zQwugMAx9sjzjpiDASdZM5YlVDQbtT1ihgnUpD3fO2dL/H259+qeEWOglNdPHsPgI8//ABjPZ2aQuU8kiaRFmgU/I1xJIZQBY1NTIyj4aiudK3XHpAamTiCRhogu2+MSXuFFHeyCZNNvYfeGl2UStTrSMngdDG2CJnQ6ffoe4f1kAcBwfu2ISMLpFE1+kNsIIPVKpCzpUFSbzmiYm6L4djcQaffY145KhFScfrqemhFPGi5ZCwdEclKeFsQGkWYKs7PXw4Y4ysu4q3BeOkJSwW8+gTjHvO4H/fjfvxU49NHHsbIKmfE8DrWSkjSnpPi2ymLqlDJS8hlIMeFBPzdkKwwMksaZo1lpq6Dc9LHIjniTFUWQZVCDZeUpNZzjOaBca6+OOcqL0S2iYhh1l9tvFh0F/m+nEM1yAZY954cRzpXducGcoePskvZeIvxfa34GN8Q97eQrGI+WjlqPOszSSlWN0fa65tawbFkjLO1ZwSC+JjUypXomq5XLW0voXW/Pcc1K4571dZ48X36k7d4+vRLAPziL/0q/9cf/msePn5TvleaiGPLoMLDpAljPbvDrhos9U3LYTjSFEtKk/ncW1/g539eej5ONy2tsxjtwcnRsLt5yYfvfU/PM+FsW/1UQpjIORAnKF4XrmmJeSKpMc7hkBijIWupOyYRYCplOGstQ4y0hQ9kpJdjirP2iydJhaXuyFp103KwbR3Wm4ohmbwHbI2o0viSfnNCo9chDbekMLHuTphKZJEMU55lAHI2kqrrHcuAXTCoBYube6RK28NdTE6qIPWpz6VyUj5TQo2l0VQuH06JQlQdcRHhxBQoRmjGiqRmNZz6hOPTYx5GeBYV6InlpJXjb2cCGEjOPJdRpSW/TGQDWLdcPIQGPnfPR6yx2EIAK5SSnIlF0CBqj03RccjcwUAsFkyuxkZyr14HsjKNLc3O8nPXNQyqsRmjYbNyTCVlMBnrDFbTlDU7RrMC1+n3DMSwBzVRNsaQwkBKfq7xW89q9ZDTM8FFrp5/SNNY1l39Wowpz4ruFgih+rkavT4Yx/4g53H4+AOGkDk/VZ1Ud2R/+SNWW8EbfvGXfw3fbfj2d6R0G8NEGAb2Kizcr3r2+1usgUmVxDbrtZhDqbv82dmWN58+Za1ubY03pBwIyhWJwxXDeEOnPi9jmGhaRKgHiKMjTBNta0lR07wsN1eVBRiGRIy+LjgG6QsqU8r4yDiBrgN4G3HWiyKarvEpF9q6LiYeYpxbCAxBwvuSjjUNq9WKVoWRSAO9tzTawDSqiIZJO6K2FPRth02GUR/FMUghYZbxzepVW35S9K3O10JQnHtVrBERqjtTepHWlIy9LB5W2zkqDyTJ4rF0FACZM6V3SCaS1ebP1wCWnzA+g8XD1P8Sc29AMUkqu3UylhTTvLoiX3jZ/yKUkXz3Qi2IZgVQtZVAUy5KqqQkIfuYuv64oqVRryZQIcV60JoLGyPVHusN66rObWgcNL2qTI2JEAPrTqXgQsKZY+U+tNzQcU3IMvN9cwL+FWhlJcVBVM/ttuar3q9o+w29GkqvT8/Z3h4YRsEregw+GYapVI0MWEOj55hjIBrPzXHieCkL0MnZObgX9CuZuN0UuHrxI6ZBdtP2/At88fNPOFH3tyePH7I/7jmqHSXOc/XyGddX19zeSrfv8faGbnUqiyHwxqNHPH78mL7XhTJPDDdXHHcX+hhM2JiqU1ucVqQUsGmOoHKeMHGOUqc0kWPCeDlv6xxdk6sNxThJfFtFmbNMhsMo7z/pVHXfgtMcPhHx3tIqICrEv4BbdKN678kKfrrO0jae9cmZnFM80K232IqNdeB7xtjitbEzZiCmytUxzpUSot6zvIAt1XR9sdNbI86FudiFgJIWZ2DUqWlU4UIZ5YXUhj9r7iwUVjMD3YblQBlSDHMFx2blYS0Amk8w7jGP+3E/7sdPNT470yfuhv85ZZULnaseuaDJNR0AFtx+USlclJlUQ2PZjrxcVQ2GHCLZ2VrDtgj3I5vCFdHIo1DNTelr0KMXZl5JnUwGEmOAQoo86dtaAgPobCTnhKfwTQIupcqnMMbT5Eu83et3n4h4nIoZ5/GGNA00qzMGpXnTe4xf07bCDj09ecxNd0GnsXskcjjOOIxscpmsFYdpSsRpYorH2YLyeKRpxtp5i3Vc3VwAkjLsb57RrJ4QlOvwcG3YNC3T+oFeOs+DkxUJall0d3NNzpG2aJO4DHEgThLNPPvo+zhjWes5xAnGPBDVQqJftUxDJgepw7qu0Xtsatk6htKprcfoN+TDLauiUhh0Jy2V2ZTpGlPPcYpJdGGy+OICZJvoWodvShqSMbgqcdD2K5rGYku52BqysazUeJzBMuze5+H2F/XtAdMkjO/wet6HydA3tlb+DkMgmVnXxWWnFcjys+QjJQIImp5Ih8VcYYw5LWQ+l3MHLa+aOxFMynd5TklbMmpVJtu75k5Z0qS8nHufYHx6wFSJL9ZZPalC4baLxaJkNh5I5JJiaJ27phRa5J49VFBwqIRglkicabZONRqywRSKtUVA1WoOg5TPijalbcgsenBswpBrb0aIUUSagZIwGwyrdr45q7bFmITPMgFi2mPigLeasxtDigmbDvW8Z8llOOwuwThinDjupFdiipaTbqvXCHFrW29oNYWYYiD6wKD06RASU7SVh2CBcTrSr09EcAnRrdxszwhKmEih42S1wWibeYwjx2HPoBN7f3vLGGZV+GZ1grGePE10vZQl+9NWQmXFPKbxyLvf/Sa3l9Iwdn56wiFMrN+Ufg/fTOTcM12UHpNM4/IMFCMauIlEVIXoaYykHGlLbpki+B4UE4FJTJpK06VJGDs7r+WUCCZjrRfNDb0H1jRVQNoaR7f2eCWmubaRNnwlnnkn6exwFALY6cmWNOxosoDPxvcc2dCYsYL1vmlxOYnQMgLkOkvlKYUkDWy2gsVlQs/lYwFMbb2Ho14Tr9+tWqhXARojlHTK0MWirj1qOmUMJdEQFXg/LzimeMG8hq38LeMzwzzKyZYvUZreZoC36HOmSlBJUcHTUrkoE75UV+xcqZFfCJpcFZC0G9akTC4EIe0qrCek4JKtnbsRsLUXRl5vau7bNaJvkBfq6U3b0PiE1x2bOMkEzMpezNcYk7CKA1gjLvBZQUZjLN36cXUrS+oSP4wHonIX8vGa6XhFv5Ycu20bmnbL5lR6KY7HH5HDjhy1yoEI6GQFvTIOZxzDccBV9fOOMO740buyQJ09eMLDR6c0jTJf+xabbiU8AEy4gBGyIn7H/XO6zTlhd4XZSDQSpiPONXz4niwWH370Hi+ubzns5bv/zq8/BAsXLz/WY25pukbMqYEwHTDWCOMTMAqCZ2zlXARd+6dKo5SqSfmMvsvsFm5KBlGurYLaKTJOog+y1XBl1Tu8bSqRz1kUL9J7bJKwS4uqnXM0TTNbRZJxzhIn+Z7d6jEuJkI4EOxj+Z0NojOrz+u2czhnKLSiKchGNeovhhS1mVT5K41njIkpJsZpbiFu26ZWaFJKd4iUpe9qAWfcqeCUOeiMIZUmwBIxV6eCXKOOv9/IoxwwpztYiynLWPUykZPOi/App6SrYAErjTpW3k1T6rGyALL1dxq7JtJigRF0e1YulzSkUNpNjhjr7p5rNrXT0VmHd5lt39TPiCHQrX3ZLCHusPFSaNCAiXtsOtbPtHmkuK8BpDBgvK8THeOwviEfj5VM5YwhxSO2lcVitX1Av7phdSpl1Cdf/g1ePn/Gt7/+xwBc3R7Y9NsK6OEcr169IpvIRn1kTT5y+fwHxFyUyleEcMRr09rjRyes/FAXY2Mdzkca/V7DMUJck8KO1kjk4X2CPDDspQx9dfGSxjccdFIOhwPn52dcvFRZwhcDb7z5lJWKBV28vKLrNzW89NYzRCpdv3wX56neLiQ4DGMtozrXYM1YFdnjlHHO0LUFwLZY6/BNh3dzCz5m9oJx3uLdwg/FZbyNNCUycZaYYm238NaDNUQFVG28pc0O156xsVpZSnDEsV0rqGrhqD67gDoL2lrl6L1lHALbtard50jSamFpfWgaeQ4HvRbxxwoKsjktS7tkFgxrqU5JOlQeULv4q/xb4Ffzd4g97gHT+3E/7sdPNT4DerrQX7PJSjeXsZRjkxdm9WWZc1uh6y5MnnKhn8/RCtlUSrYxGeyiPwHxoDVxJtGUUljJdY0xuAVwa0TwYBF5iA9qwUS8s3Te4G3mdFU4FIEwTXTaZGVswtiISXv9iAHiAbusm+eFeJBtVIdB05ymJ8ZMTBdoyg0kxuORQTUqsB3GNZWHsGoT7/zy73LyVPQl/vKP/zmXz19yUCPs1ekDHr/xJuOwJyqx6ebiyBADDx99Tu+JZThOdfdMcc0+O3q9vn2/guMt07AAj03EO0+r6PE0jOQYWakm6Waz4nAca5n6eBxxztbU6PLlM7pVR9NJ2bVpOjFGtwXAtnjv2A/jTB50DaZxdIXjMgw0MXEcdNc3DrfgJGRriFmIYACrvmW/CzgTaRU4GaeIMYlWAVNvPY3rKk7ifcTaWO0yZPc2VfpwnAJN0zENhZ9yQ9uuseYVCQWH3Yq+aWs7xTE1uGAF4wGM81iTq2fs8Wpi0yVy1Pu1S9h2hffSqgDSX7Q7DItYXJ6v+vwqllGgAIP2qSzymBijaKWWsMsYyEspTkmFnLV/p8jjM0xb7h527mIt+ISERiGERdcsZGdwtll8mpvFiJXsckftfFGtEbFZXUCKBkgKIl1cwjhNn6rYj5zcjFqbDEQsxQQ40vmOvnX1BnQ20zBglNhk4ggpyH9oiOg6KPhDCpqxzQ1+NG09b+97pnCLb3qysiKPxz1xeEZSItnhsOew32FU72PrOj7+3r/g7A0RN/6Hv/+f8ed/8i95+aH0jBx31/i2ZdWvmTQvv92PbFcrAfWAw+1zxmHi5FxUvT569oLNZsXZU9EjTWGH901Na4R/MYgRtl7PmISNuNXUaLteQU680k7dcZqwaaLVxaPtPDdXLzg7E8ykbXsOw2H2NIkTzhkSniK+JDoutsbFtvX4GPG66A2HnaSMyji1zihbuWBpSUh8YWJ/KICjA1Kd/L0X8L6kB06fkVp9C45pTDRq0H087PHOcjzIs7ta7bUC0mJ86TdqsNYRdZI2xmBNIqhOKjYzjLDT3pe+a2hIvHylDZO2obFWhHr00RkDWOcrDwljwbpZoa82gsqoYt+1TRyZZ6YYUEmak1VNrIz6tk8OeXz6xSOGRAwiN2jcQiUsZ1Kc2+dJUlaKpApCWc295rXBKv6qF8aV52fGL2IINbyxRvCKZE1lBvryAJaPzJnwY1WfTCrUXD23iZJTWnZ2pGs7tr2bXxPSDICmUY83n50hkVVaL8dp0dyn38s6vJZhx+GI9y3DMBG0gjAdLtkdDqQkE3eYJkI0OCO7Utedstp+getXYrXQ9De884u/Xo/w8fvvctiP7Pf76iJ3frYBHLudTuzxCtevWelDc9J1PDzdYDS6CTFhXIe1kx6zBWuJMTINBZhNjHGqxLO+awiTr1jBNE1gXN1dV/2Kw/6WUZvvrHeko60izSkmiQ6SqyLUKRmOQ2TVFdWvFt8Y7LEwetVGslL7LSmaWpJOKWFdZrNuuD3M323VO5yyfkvVrUSovukwJlXrzRgTIUjEKc/FSiawbgj744RrDb23dXOzJkI8kmKp8GSsafDafrGPnoij1QpZ4wzD0LA50QaNcTn5AAAgAElEQVQ760nJcJgCU6WwG4zxVSoAY0XOsxItDSyi9RQFRF+K+lgnnzvrVhSHAp0UKWF0QXrdluQnjXvM437cj/vxU43PjOeRjfRdzA078v8loFJZVmkoK5VZbcgpry4ap5XXUdp5XlsM7zTWlYMVB/okPTXVc6WUshZScEu70JxFOqC2brvEjqB1b8mPz1eqg1opwcJpKdWBagVYhW8tOF9Lpikr8akUiUIgxUSYDlj1D227hpAyQTkY43DE+lXNU4f9BcPxFtdIWfDi8hn73QdslMS0PnnI7vaabIyYYCN5PtiaPjnnmYYDFy+lUrJenxGi4xg1Z9fvWHAY5x3H40GrRtr0ZxtCGHGKWaw3p8SUWLcS3UxTYBj2+LKjO48hMxx29TONsRwmxRoyOC89JyEX3Kljt7+px1i5hq5rGTRlyOZKSrOLakHMMw7QdZ4YBiCz1grMFCRttrrrp5zIcaz9MdY0tN2K4EqfVcJ7xLgJCOOB0c26JGEYGIYBMLR6HjaB8atKLXdMYOFYmjSzwxtTmxujs6Jrq7jfcYgcQ2CMC0NtjGIcBbOTNL1IU8hzmmoFJ4dR+l1sqfB4EfDOS+HxwgMplSYvz1ktkX6y8RkoiUXBMLSWXA4ueVucv7QCqMbM3ZGlV6UuBnXhyPWzS5dhHcZUctCsKE0l1Yjop3kNUFpclAxgqpdnypo66eunmLS7MPNcFcKnyXPeG1TUS2+crWCvEOIstpQ8XUPGEkoIHAIRV1OZYHsSe3zbEbTmLlOhYTxKmjIc90whiCYHYHxHHPbcXLwEoD97yvFoOd5Iz8lq1WHdKc61GA1xb2+v2O8GvKYUzrf4dlPNtdv1I1Jzzr7IYmSPRcSF5RcjXb8ixrHiCzmBGUw1B+r7lmHoaBRQ9Y3hcDxwoh19TddjbnJloOYofItyTjFZhilhbWLS69f1LU3bM2v9NML10L4SotwvW3EYWQyKx02TxCxsmiJOJ2rrraSThYThDGEYcNqfNB1vsCYyafOjb1fE1GCU8OUtjMNY8aAYEuPhViCFWDaAjMPXdArXMgVf+T0w4a1l0mfxeIQpRo7q0LebAiHINlu8fY1xd3pbalOpKymd3JQyhyb5I76mZ7L4LOkLGV1cys+mYD2BWED/TzA+9eLhjcEboxWOxSzPRindhXHKjFUU1Pc1SopR4LUK/ljJ02bDJqvgT/m55H3zeiky9HkWRDZWRYhKdCBkpLzI2ITOW6If/YxxXv1tDthsSPrsrowhh5kx6kwj/U/lwueEMZ6oQsJhGsnZEkvjV0gMwwSmY4qCBbj2nHVjMRo1NO2G/XHHOBUj7Atcd8L+mTrEra/p3MDZueAoh2NLc9iJTKCXB2f1sGfYHri+udbvCZ1rcHqe07jn5tbVnW+zOSUx4AstfPOInAbG/S1WJ800jcLgVCKZ9wbnXY1ujMmMw8igIKJvJNIISkcnj2SgLQI6OIZgaUysC2mXoGtW3O7kvPtuTUh5JjWpcl2566W9vmwg0wR9a4nR3mld996RtdKXm4Txi0g5G2KYnQdjiFjTVUJXmvZwssUddaU1kWwmYriu0UjKEklZnbgxeoJNFLwUA2N27EfFQIZISIaDAqgxgTgJxjmqRnhKS06Gc55WIyqbIyFkQomKbYuxTa30JV0khH5O/QxjLFEB/xQzKU44xyz9+AnGPeZxP+7H/fipxmeAeURBrCUWqr9PSaOIhRiQ+P7m5RIILFYwKynK0nf2bgu/pj3LysnMf6//ZjuLBpmE4ijaNp3Uq3YWVdDScarnYoxhTLOZ8D5bvHVYbVIzeYfPgEYNOKfSfFrpmUYShqjckcBRuTD14pCSIcaRrjShhSO31y8Y1JLg6nJHwNBog9/NxXPO3/wC3VYauXbXLzl9+IDDRxKJ7G8OTNOR4zESahriWJ+dc34muMjxcCAMr7iZVIjZGsIU2TwQVuswDXQ+sToT8eJVt2Y6XkJfSp0wjSPWZlJSmcFsREJRv9uqdQzHQ43kNtuGfrXmVr1iRMB3rClHY3oia8ZpZIxF8m+N855UtEHjgCETRu3JUV5CuYUxCjOyWGMcx0jjRY6yiEIZa5QWr6zUMNI2q4pjRRzOWKybn6MQDjReStLZWKYxYLR/KTtHtg7XdJVWH1PGxDkiNk78jA+alowRDtPExbGk8iV10HKxk1TLmAV93yKRcy5CSQbnbBVKmlIUA6zKEdXovFhaRjEjS+QF70qqj3MT6wQmCo5XqqOfYHwGvS0q1IiCp/X3+k8lrxgonI2av8Vah5YPqK+UH7UTtxgBG2uUoq5/z1KcX5o4Ob0hszxkKUdVeXQsqT7cETEsmlMuVSLLialOQrjKGVDqsl+x4VgBvRgHYsgzX8V2pDhV4prxG6aw5+byAwC61SPa9SnHw03VTj1OmRAmBuUhTDFyuj0H5ZZM08Tu5pL1Rujoz9/7Nq71dMqk8jfXTDEICU9LhTFmXjw71JSjaxuMtcLbAMYxERjo9dq4aDl743OcKr16GPZgGvre1pJmCiMpxoo70Xji9AqrKcemW7G7vWGv3cK+2eC9YaUYSBgPkuKVPiACiUTCVhJYs9ux3Z6StDQeDju8c0yDvCeGhPWuPmMxZYyb94+UMsMYccYQdCV13uF6OxvhGEOIY00xwhRETLo2bQas7SlS6O1qjcl5/rzjiDOewRxmTxXryXZ+9lIeScYSFXgPyRNTw8qXFMNIv0vRwlU6QyDUDaBtvCyEBaOLkTyNVYhq0PS5KSr6Rr1za5e5LByiIVwoEuaOtqq1Dm+9qOL/ffI8nLU4a6WikFM9aWMVUKxno/nnAtOYV14durDk138uNydqN6GZ/wyKUZQFTNuT69+0k7Gg5sbIxUp3Djs3SNVdwxh8DYmk0/Rm0DyTLdZOtNqX4q3HpKFiHsY2ZOcpT0COgWb1gK6AdVm+gnUNw1F3MuOw7Vl1hDPWsdmccHOjoG06MAx9BecurgcO4ZqnT4Twtd6eEtOtuL3VxUMMuG92Qzksvm04OdMIanjFo6dv1/6Np08/z+l2xaCyhdO4Z7PZMo5HhsOtfpejmAVV17NAGA7VXtJbkW0cx4IVJCabccow9W1Lmnb1mFNIxPEa71dYXW7HYU/sPFlX74lRoiS1OIjZ4O5UHJyak+vtioYwZQ1p5Z7d3o6Y3KlQNbQNpDSQU8GhjhytqUxZ6yLWR1EjQ4hpbb+ti2YsbnDWErUSlcxIxuPUjMplc8fuwSM2pCUKvh0sISWisliHSXpbnKGaUfVWHAOKil2IibSoFpqUwc5FhySelbNEhTHgJOrKC2lO2fhmANUbq3PjkyMZ95jH/bgf9+OnGp868jD6v6R5VMEOUtTW+7qTQ1npKostad61iCQy3MEvWLxPOnJnSyejVF6snfEWFYCtOg7OKUejrMySwRQsJr8WxcysFFtLbF6qv4xaPrs2FtuecoZwF0wcaZsNJt+tthhlWcbplnS8nEV6xoHDYcftzTVZeR3WOS6vLjGaY7/15A3SdFtz2xwM42HH4aBRhO95dbVjeyrsxK4x5PMH4Az7nZ7HMGGmRLOWSMM5h2t7jIbq54+f8uStJzx4LOXgvrVcvny/7ign2y0xTCKbWHgariHaRLuS77a/umIaDjw4O9PzPDKGsYpap2kgZxEBArlVru3IqoUSYmTVZvbTQFPy0XggHCyDyiWKZGFi1ErUPhiySayaUlM20p1d9HJNJkwJ/GxsFCIMhxH7cD4PIrXF3riG25srVmpH2XiHyYOkR4CzhpgGrEpJ4oX+nr3DFsGhMGlao9FkyphmTSrcEZdI0XOrXjz7YRQzq1mLG9dIku6Y8YlhitX6Iia1Yy0VZ6dJeHmQrXxQxdespdhTLrvVl/aTxkAkk5NhWrSj/W3j09PTcxZTJAzJzCIk4io/h2wmF3c3FmVS9eUsUzYuWutB/UvtzNdHS6+VbaXNeAugNhtNYfL8OwPM6uq+upnLeUqJuArIkiCrdEBZtFJJdwpPw3I7GowXsPPUBPK0x/sCqB4hTRVIc23HdHvDbl+c2SLW9eJfspKJfHt9g/UbzjaCR7imEXp6Ff01hGBRWIDd7cSUMje3MgnP1tJ2vto8wDht+QYGVbMCsE1P227Ynsp5b88fsFk1pKOc19X+FV2/4mQj5d+cJ4ZhL6pnpd8ljIzWYRtJQw67H7LedHRK5b+6vGW3Hznbyus3q5ariwsGTfHOH79J0/jqsuZubrnZ7fBmYq2CS8cJjoOQuECwwuMUGeIMCmbSXI53hhRz9TS2JLKBnC07XXBaZ1ivAVMEhbzaJKuZdvZA5lBKsV3GuoakcgYhGlo7kQuHw65lYoZA1M8cTZICgja1Nd1ankXtV5oyDCERSs5sEA5G8TS2DmcNmVTbJ1IS4eushMRcNErvPJum7n5Z52JNY5KUfVOaqQelhX+pyCeLY7qrMPa3jM+gMU7+s0vgkxk7qLX4RWXkrnBQnqXocxblpYV1Xv5/2XuzJsmS80zv8e0sseRSVb2gQYAEydFopP//NyQzXYxsaNSQA3Q30F1bZsZyFt904Z/7icJcoIFuUTflZiQ6KzIjTpzF/fP3e5cbm8JcP4wbzEQV0HSbdNQnGGySya1OHu0Q62ekSEyhTVCGVAKCbr6jQn8S4h1jZEUxadnHuy/Y5beoIB0FEWHV6gelcd3I0LoDnmVeGJyi7wTNP0SMc3Rdec+P735gul4YJKHMBsh0xCcxFo4Lu3HESBTAHAMmR5LqyLLSOWPpd4fmg5Eo3YFe9uSEmWnyDGP5jN3uHud6Vl9Zri+kGOhs17oUl5d3DOOBS61EcmC3H1tq2vNpYVo99xL+3O12mPOJIM5j59MT4zg0HUo/jFwuZ1JKraMzGM00B+phqpi4rMXyD2CwuZjuVMpFLjEL9feNLmCqMobOll867mA3mhssIKM7g+2r3igRNSQJxl7WiO1MWwDw4FePtYI9JOiHI9mkFo6t1FgsLlMlwClsdkQB2n3M+KRaZ8QYGK3d7tUY8TGzFqv38h4Vz7vpMKbbhqWqz1pdLFOZWDeK6v9kilz+d+uqFO5Tlq7pT++2fMY8Po/P4/P4m8YvQE+vM2HaZMOUSsMo8+dgQtl/VYdAlbj11lCVJlsRb9my3BDjpMrZSjRSAr3xOApLdascUk4Sjl33wwqV7YbU51iCuusxaMh/Htr5ZxT5lBQezbkGB+sBa19DKtRxly7Fa6JyCNaFnAOufogPOBa0G9tuap1OkA2rr8stdOMD3bg5Wy2XMzGUFd91Dus6jneFk7FML3z88JY1aB7efC3fJRc+g1QnznQY19GJWtX2Pc6Njbl5enmP1qbFFfSdZbffYYi8l7jIrAeMtlyffyyfYSxGWz4+F3ziw4tHmdSMhjM9Sht6iZTouwGFbpVKiJnj3RE9razCvAzeY3IqPqLA5DNLNBwlMyUSiMFS1z6tM4sP7Gv+py73TlaJ/b78zuFgSiehbj0zEBOhdpGSA2UYxPGMVNbmFmGgNUp8Q8oFy+R8LRaVgpPEGIhph632DoIt1NZ5SqXDUXVXPiW6XtMLFna9Xnm+TtItrOu6hvpcIK3aG/8Oanaz2iqGfMPhKDadqujGbmwdb2nZW+B1+tSD5y+MX0YYl7IYH98+dJlIRkvZVyni6SbtqpRSqrVZS421TQSp1mdNH1MMj2+3jDmn0qKr/hDaoIxpk0ct6JrxWs6gPHU2SCQM6pMarObs1nZizEVr0KzhrMaq2AhGHyeD3Q0oU0BDnRPZP5ULBuKpOW3HqEoine1HgkwGu6FjDYZZeB5pmRn2Q3PNNn3PdPqArQBeDjy+/ppxXx7K8/mZb7/7yOGwx7lCHIvRs7u7b7Ly7CEvKy8vFXsp56viKq4fePXFr7i7L/4enXMoFj6+/UNrKY93X/Dhxz+0LUM/Hvn4/i3v3pWHUGvD4/3Y7AuWNaKMw4u2xbmlPNhy7ublyrSCj66R7nLyZBRnmUx8UnRdt22FlSHIogAQUsKYqq0qIKLtHMpEjtXPtXOAx1XVn0olnKrSz1MQj4tyPYbdAWv7do2ruNI2TUkxwc4pkkXQl1IJAlM1+0V5jILQFi4vW/GahyvpAHIvGq0YnP3EziGmMsGmllZYJpNbKUiGm9zb/MnkQUyNu3Ir5yiujH8GLdzQIn7K+AUwj7LHKr3lrYpIORcmYr3A+YZD0TZ5CsW251OyMNSbICS/OSIhfA62mRIE8kiZzdshY9OmDUhoEQfVzy6VTT3ZurgNbW0Xve0NG/swlRt1A5MUXa/Z2XpBfbmoujpzj+js8cLZKC5Otk1Qy7KSTU+KC1o4Ah/ef4c1I9drZWJqUppwWjAP22GtbsKsL/7ua379D//Mux//DYDv/vAt2nW8+fKLlrw2z1eupwunUCaLbtyTUm6J90Yb7Hikk8T6xze/4fHN14w1FW1+5uX9tyzThKtYzA//jvcBtyus1ae3P3I+TU3INQ4OqxQp1BiFicPhyIu4p394euH16zfY6vexM/zpwwspe16XeRC/GC4L7XxZrQlJUTOYT0t5JnSqOBU4s0UcxAQ75zC6a5Wbc5qcLUqqma4ficHj12oGrAghsa5Tu7fM3mAEu/EhM3SKLK2RZXnBWItyjnADaiutihENYPNM0lNLJ8QMYLeAadCEsKUBpEyrctXNIqw0GzNW4uNaioLwXSqYn3NBPT4tMiTh4GbyKM/QNtlulch/4ORRR/nOt/Z+UgbVyUSKNXVjK1hqldSA1JzKed+6rkrqy/oZ5SHX7bxKAvgN5T37SNSq2dwVyaDeWlc3x1beszBkP83oVMXdqoJrui48dcIpeaT19UMPo5nodJDfN1hzRMsD4peLbK+EoKQMrj+yXJ8aPnX/6gsUlpfz78vPx1fYYaA/lCrA4HnuPrAr+B7d4TUvT++5PpeJwRjN/f09KeViMAxgesI6c57K74Rs6PuhuXkvQdGZyL2k0+8Oe5xOnGRLcn7+gbBMdP3I6WNxQ/ceVLfn+vxWrlnEh9yIUX3vGEeLa1WaZdwPXCcRiy0e2+1aPMHzaeHlktAqMsrssIaMs6ltES4rWLttPRcfyqmsFZMSN3y5hOfJMwwRZRLVnUwbTVhTMxJOKdMNR/pdZQlntF+bmDEnuF5e2Mln2ujwDHT7o9whPTlKtkzrqgp4KmZKxnbFLb7e72osQjtVq96ytY3LRl9PFPbnFkOqixFVXRy1EtU37V4rt/6299cpf5KQqGXrc/twftJUaRXyxkL9KeMzYPp5fB6fx980fn7lURHT2h/dOOMFLGq95JKPopRu+bVKerwtL1SX96jAa6a8X9uZqULdrWVETgklvI7G3EgZSX6Sv5F/q/9gTPkv8acoPXJuy53SxtN6Y6OInqZiA0Zrdr1l15eSeN9rdlbjajWTAzobMAf5/Z5FPVGXk93hi5KHa1ILrk7A5XxmLyHU3W7EaYMWEpkPCy/PH1iWuvr+iOt3WDkGrTXXywuvX/8Dg5gTz+//BFaT7U6OK2M1XIR8tTs+8vf/+I+8EoBVa82Ht39gFlNloxPdMLBcL41U1+0PrPO1Fben8xmtNQcJug5ppR8G9vtRrjtMUwZVft7tSmDV+48FWzhfJ9YQ6ExmWitpKeMMnM91r27pbvJPEprRqk2mohWd2QKeus5ynRf6g2viuhwVQ9+zyDbFrwta940Dk5OFFLfgKOH1BJEcmGRYV0+inBtnS4BUzomw1BAtT5d127asIeLsAJK5m5UuHIy6LQ+KNa6EigtKBXFrBViTFz8tCLYth1IZY8yNmXGmWBWG9nqzNW4+OLFs/+U9GvT6Z32CvzR+gW5LicNTcogtL0L2brphD0kAz9ROhFbl9a2bUsq4W8S38Cvap4lYbjtxSmXpTdcyrXA/cptgcmM71uMyksFRP7N8B/lzFM5qcWGXSY2SdNYLo/Fup3m1ty2O0tpMZx0mlZI2REsOKy1cxxiMeWhsUdcdWOYTVo/MwnDU7sAw5pYF4+eJqDJOgEetDX6+EOQBG+/uuHt8zYd35e/neeFw95q7h0fmc9lirPNSjH7kjuhFkfnb3/0TAPv7r3B9z7u3fyy/v85Y45qRj2ZlWRZ8zAzHwkJdl4Wnjx95efpRrn9xE7tcxEk+Kfb7A+NYiFIfP7xlWVacCABdZ1nWiavwRJQyGJ2wWmPFnd6YxLJ84hOGQRGjkMKUYuwcSchZTpXQ6oq77Hc9MQTmeWUn+I2PqbjAi8Ym2liiKOXJSXFC5VTuDUo3q4g5y0VeY8LEdVsbY0AtV7qhpxMcSuXii1FTE03KhRBYGyHGEFWHDxWIL4pkV7HNnMgxi1ZLficWP9XNVAvg9gkvC5uWmbScg3wTBl/8bWpzAeQRKSirvIOQyv6amYNf0IawtIxU29eXL3DTKREFLJIat42NDVpwh5sqAVC3/y0Tbpug6s95m81v/399zwzt9dKu07RYR6K0Vds3ahLmei6NhmNveBzLcR97z6AnnACkxnSleJELaHNPtJksakrtIDtHWIWJ6Fciipfnd1wvZSV79dVvWdcrvjpr7+4Iybe4QZMi427fVteHr36NNZrpUqqIlBTW9Szzua0oPkx8+Bhxgmk83L3mct3iJY0bWf3AJA/+2GuOx6FFAUzeo83AeHzFu3dlQvrw9gfWy3uGmqGrNH3nuF7Ludnv98XBPVYn+ZVxtBjBf4IvHZ5xKA/cy3nBktn1BiGlMq0FRFTbmojRibXKBYzlumZGAay7TtG5TCWHZuC4H5mnC6t8166L+BhwUoVpDD6E1g3UShHDzKaqzTjbtxjSnBXzMhFqFMa4x5oSt1kNr5xzqBzaz6SIThM2Vw+6HmNcI8OtIRO5sbdMmWQ/zZHV2qDz1iRo4GolkcXUHNShPBvmpgGQas1/Y4hVoJaKBpWfFQqjFPGvmEA+Yx6fx+fxefxN4+djHllDNsLHzxvtu86EsmVwWZVgqJtoyEyV5NfWKNz6MWYyKsdth5GKlDjf1hey7bmlp2+U3fp6bt2XEr6dtui9DKjc8IwWzq2gF03+wwAP3crRlb1t7xy236FdFVlZwQQqHV1h420MRYKsCbna+BtCUGh3x8OXBW/AODI9oRKM7A6nDfjiixFT4uGr33H9/jsA/DqRVORF6OrKOOb5QsqPDGIw5MwHcvxAL+3Gpw8fS2yBGB4/vX/H/nBHL/4eSsP7dx9YRf7thgNuUHz44x94/lDiI41K3D/ct4iCsd+RsiaIrPzrr77BWNu8TcKuR2lLkIpqv7/jcnmmGyRDdg3kaNgPiZaDozQ+07orh07hrGKueo+cWUNkcFW0VoLWD331IfHc7Q370bXr3LmhGOnYSiY05JxZRGho3UA37MmpespmfFiaEHEY7rD9AS/dGONXoMdoCHXrqUdMHpp3TI4rwXckdZbvZYCO2NZshcI0OkPMWXJ7t615xQlrQZ9SKt2/G6JkCLdZzCXX95P7X4iWG7EsF0sD+SkVly5i3qgVP2X8AjyP4gdavuxW/peJQmFrG7bqUbjheajSUlLtNfHhaD3q3B7u+mmZ0CaCts25ORFKWISNY6pLFsXG0NBkVMuTsVqT1RbwpCiKxN5pvj6Uk/2qm+nNpQUZ6a7HdkMTh6E1KYZiFAwlgc7ckJpywq8T1h3kdUAZ/BpaWU0InK+e8fh1O3+Xy0d2Y8FRTI6s03vmszif7x9RlgZkBn/leH9kf/cKa+XmNRZru7K3B2IKPN7tmK9lWxKePvD8/LFwUCj7ftf1DLviLJanE6fTt6zTiUEA0OPhwNBronzGeHzFj3/8A05EbcfHN5IxUh666aSJic20yFiM25NkuzUtnsNoyWnmaZJrYDsScBjKJDb2qrBkg9yuecUYU3JzAWNTERk2p/TANHleP4zNUMiHFWV6TOPwZKzt8NJeX5eJbtijhURmoEyC8nNYiyN8EvXdabpwON4xjj1ZxHMpyn1QsS2l0NZi5LonM5LQDRNJKOKNSrz8m3CZGuBf8Iuq8NY1CK1NJgC5cVxSKjBCJTRqzQ0Zog7dJpTy1+U5StwqXv7y+PmSfJWEZl4OY0OrhT1XJ7tYyCz5pkzISchl1SaemwmEyq24UczqXJ0Kgdrk0YVA0/5GgzKkG9JMMyKiTnablWGQz6hMTqUyx17z5Zh4kJu3cwbnXmO7soLbrkcZS1UHx5zISaNFuFUwFQ1i1Zd8LKw+uyXjRbej21VvMrhcLuwPX7J/LLyO08fvGXZH5rkAi8t0Zp0947HQ0VNKZD2gZQ+/O1iOd69ww9hCm5RKhKzwEmH51etjMQHO5T2v54903YEgEvJut0e7O15OZaX8+OFblHG8fnzFUewP748jfp24eyjHucwLy/mFN1//tpwbZ+n6jnXeZOnj7rgxNSm2eG8/lM/4w1vP1w8D06IZBNy80warFlxfLlI/9KBd4+oYa3DGYHWNSShY1tDVycUzLQspDuyGo1yTyPP5jORhYZ0jxogT8+I8TwR/QdfgrpzQQN8Lrb6/EzvEQuKbfebl6R3wyCgBWE65ZvkAxQ2OdUKZMlGabsAYWuVR7AUj6aYSybH4qm2uFOaT+5VCL6U+BapW2ZVGf/Ps1F9o5sf1H2/MhIDGVv8zuPEvjs+Yx+fxeXwef9P4BbotgZy97Ms2r0unTZmZ6n5OZeFs3HRCsip+ipV3nLYWVXlzJRWMVCayJ2uekapUKqVRWysHkenfBEJFdYuT5E967Uop+s7wIO3J+1Fz5xZGtW4+C27AjXd0gyD1uiDiVdyVUIJ/3HSRMiQxjklGo7DbvlR5TIaugyxdn8WDHe5bju8w3jErTRYmps8LynXkVJidaIOPCWSr5EwmJc/d3SPTtWS5xFwqrSqH18ZgXccqXZ/n00rmyl78PegMl/MPXK+ndn4fH+/ZHY7c7Su+kznev2oL1Mv773l8/QWPb8pWx3aKHBeWuRs8LBsAACAASURBVFQWw/GRzh2YxNNUWUdKiZi39vEaSzfjfmfbNXLONGtDpQ3G9s3m0WRwepMPoDqMyjgJdBp2jjWsrMvMIPT03e4RFFxPpeoa9wf8ulRfYbQuOTshijmQtaQ1k2Pd3va4bsAMpXQZ7cw6n/DLtUVtBuuxnaUai+QQyI5mzKySwntNvFnetaZFXYSY8CkUpmd7vWi96r1YWq/bfaZ0Eb3d9i/N7R4lS8FR+UwgnrGZdIv7tf/4D8U8KixReta6UYYjKYXG6VBZC1ZxowgUU5Oct5/JkRaao5SIfGSPKCrdW9KYUjWLtnxpI+3h9ltaiVlRdQ4rgKxQxXh1GPjV457Hu1J67nuNMWXrVD9Xa42xtuE2YV2IITaCkdJKeGZy8wsGUmlmGV1a6kL4iimStUb3fdNWGDfiw8oima7H/SvmZWrelcPujnV+Yn84yHsErucnBjEPyji++Oo3HB9e8/ZP/x2Ap+cZnRWjgJOH4z0avxnLqMRuN1IDuk8ff2Acx6aqvbt/g1GKziiOElRtdNmVv/uxAKjj/R3745utIk5FGNbLQ9YNR6bTqTl2xbxnWX3T1zjr6Bwchr4pccM60/cdg+AkIXqUNsxTeY/OaTpXsA2A2Fts3qjVu75nNQsphDZxZgL7wxEvGNM0zWgyIYlgr9sXfKw9YWVhq4tQCBG/Ppf8XqDrHHrYkXIgyb21+AU9a3Sl5lNEaakeg13Q3dLycsEQw0a711phMUR1MxXU+7D9Trm/mxAu39IlKo1h40rp+iZsavaciyjvz4Ok/trxsycPrQxamQKEKd3s02KIhJQ34FKJLFgbskz3KVd9S2W6larA6qp9SaTI1imhzMLNzUlmrozaDIVSRqgc5WPRmBuZuVaasVO8kZX09UFzN2aECoFxDu16tO1wQgpTKIjrJnTLsmmsFRCgXS/xC0iXJW4h3xgwlizGNJpiZJzj0iZK1w+ElBpuElVxdmqp7cpy9/jNZm4cSvhPBd+U3fPm1//Iskz8+FZIYr5UhQdR3vbjHr9csMKxGPKAc4ZYb+4UmOe5OXStceX+sOdX33xDV+XwYeb53YcSLAQM+y/JGnpxH7NGU9ZWEZBdJ1JO7B8KVnN6PmO0boBeJjMvATN2ePHAM6qApFFUtn3XMydYZcLZ7xxdp5lrjlRVmso94LSmdxaIRFEU6xSww5FROlHL+kRBvOo1g64/MkuFZKwB12OEHaoyxHVmWgTHAgbnsKrbmgFZs/oJF137HXTXcKmkXHGxq4LLmIkhNdUtUtGi1I32qkSGbtymDClt1Yc0A3RbK/Wm9+IGeNXbJFGEc/+zglbdUEF+yviMeXwen8fn8TeNn115OGvprAMVSdm3fr5ShrjRPmTPJSz7WhnK6y0oWkHWmhbtmQ0Rj0rb9oGbki62mTM32/5SjGymLTqBtTRk/mG0vDl0PPTibamnYjHXYgTv6XRHNpuJi0qB6GfWqZS4cb6WlUHaeHbYYa1rq21OCa27T1aLNXmMlS1GWouxcC75tACX6wlrHHU+P59OxcOhZsPkjHU7+n0xPHbaoE8fmSZZ5XLi+9//Ky9P7/n4TkyJjGE/9jy8KfEM/e6B6frU/FJeLgtfPA5YJxL+aWJeFqJsa377D//AP/zuN1ijuYre5XJ5IYTIeCzdlnE8sjvsN6PmXKjUNbwqLDPOODqRAy/TyvU6QY01TKmEMRHalmE3giY0VmrXd5xOqe3lO1PwtVrVzj6w390Et+SEdZaYG9eTZb4y7B7K9gQwZkLl3Hxe1nWl0z2DWA1cLyd63RPEMiGsc8HnasZugKASrtPt/o1ZdEzCDdH6jHYD1pTP1NZz60eTcrwhMAAim4/55quIZWDD7GqnpS37uXjiVOYpSMzC1nbJOeP9Zm6RyU02sn3G9tpPHT9f2xJj623nnNqXRKliKts4GWUvVnxKZZuiSj99c2sqNOFmPAwoZdE3fow1dOd2GFXakuVztHyOkK1USdca5OS+6QPH/IyNgpQpQ1YjRlp0xrpyIFmRaoZoWFnnmSB1clg8mdT8Ro3rJZRbrqgxhVtSnbv9inP7BobmmAhKE0Lm/FJ4G0j6WJaga43B9Qe6vjyEKifWkLHDq/bz/qHj5blspV5OJ/zlD6xx62XvxoH7V4/cSwJcCWLS7ca6nM6MNvDmtej89wOn85Vf/+obAH73u9+QcubHH3/g/FKAxv39Gx6/+YJB2pNWlWsSfWugk6PfBGk58fL0jH/3rhzT/T220xvtOwa6wTK6hOwk6UzZDltXw7Uz8xxwTaNTJANOCF8hlBCqOoHFXMKyl/ncwEzvF+b5hOnL5Ku1IqwKJ2bFiuLR0cs1HfcPIp6T+8o4UvItS0Zp8TeNMIheRltA6RbinVFE79HmLF9sj1Xb4+mFOn6rKcnCW6oNgBYk3/KQSj5w+/0EyugN88jqE7LmzRuTbvhUdetSf7416Pqp4+e7p6dEELFahQKggIZaqUZeKaeldlu2zscns14TvFWORiBH3wAkjUZn0/j3StSuBaTdVLIJ0/gmiszoLK9HITXF92gVQFy/lDngdvc4sclzriSyp+hb6O86X5kuH4kSd4jKdG4jgaWUMKZrlYhRBbyLApAqYws2I7yPQo7TrH5tBsbD/jXXy0tLocNBzB3V3dt1Hefz5SbeYcbYnn4sD/4YMjFeGIyh72pnxNENI1YAU0dkmV3TgFhrIavW+Xj84hv++X/7isOhnJvLdeXl449cL+cmjHv8+neMvSVLcPU0vTBfzgyi7jVWY53jehZD5A8f+PjhT404dbj/3/nt331DnAv46Uzg7mgZXdgIhUpAaLmGswQs1Qe5c8WfxdbgKK/JSbdFKUWP7TqsdQ3ItaZnvpzZd6WyGHdHTv5KjDX6wmKta5hG12tsv7sBTBdCok1GmURIEYvDi9zXaYPrDFqYr9r1ZO1IepugYgrkm0jLHDOx6mmEA5WUvukW5lbNQX0GdHvOolKlI9Tcf9QnTZMchUvF9m9R+Fa1YjIUYLgC/z91/AL09PLBGUC7zagHJa3J2lY1pKRk67GBm7czndKFbdcs99NCSUSvR1sS16ugR2toarmtB4M1ubFWB6f5Yp85mrJC2zyTA3gh++BWem2as1XOmeAnQdfFRXy+4qdTW9ms60gpEqQzgiqbpmpxp5Ulq9DS6nMMJdu1tuwE6DTGMO5LJbGuMzkpnKxi03RCWYd2cuMZhzYzHwQMvbvbocLSwOOuH3DLUmT9YliTc8BZ3Vqxu/0Db9/+0GwJu85hu66V2aTI27fPfPHFo3zPAaU0bjiyuy+tWKMy+CvTc1Hini5nDodHjg9vAAhh5XJ+BlMmrOPDl3TjrpnsnJ9fOBw7vnpTJr2HvUXpTI40S0ByxijNKpVfCpoQAp2wWI0qGcjSnOEyX1kTOGGYxhQKFkpuKtnS19Osy6V9N9vtGwNVa0tOoU1A1+vEOOomj1caVNLMsnUdeos2Dq0trqss31JLVOqB3VlwO5Q44GczkLVrt6rRhXafpJopJj9ayom6+H1Kb9D5U7BT38Sb1N+/9RPOsm25ZW6T+YR1naX4+Ws9TD8Dpp/H5/F5/E3j5/M8lC28AZUgx5tti1QDFQxFgykGxvzZ5Fbduwv4k9gkzWUrU7kjGl1WgIaJJOHop5utThHq7foyL365h3vzRB+LFV9KqxyvlIrrhJ0vaDHKTTmyLDMp0bgIPq5oa3HStivtf91abGm5MmhHZRwlbctqIfyJUobblj62XE/kHDk8fN14ByFGjLWNl+CXlX53xyDbqWW6kLTGiJ4mpswwjA1ncYPFTI6UU6tetIr0uwP7Y9mGfPdv/8L1mhgFdD1dfixiQ6mQtErk+MLTx3J+f/e//BeUGfE+YoTCbsOZ929/36TpD1/8PcN4z/VSWpxPYiZUW8halTDn87lUftN0YVnueTzIahxO+GUihrxtW7VljbkFXxuTWX3g/iAtzuzpnaUGxiWl8D6jxsrlUSiVWLxv3A81aLS1rHW71Bm6flcsIpE2punbfaETLPNEJ/R1ozTO5mbe5EOk68byd3IN+mEEo4hyH8QAnd58Z3N3IKmRKBVWFMOseu8aXbYj+gYGydoUkDVuVPyUcquCjS4eLVu4WiJC29pradHmvJlZVW7IJhgolo8qq//Y0KfaHFak0j2o5VY2xd7jhrev2ZLN68i3qtoUUTm28p62w6k9ay8ocWWTloddo3GigB2H4vD10JW/OfKRPr00vGH1AZ8jnSDgvXWCRpfXtdZoZfBx2oyCbYexe3SdLKKvjXM5ToX3C9SSOHUYaxoXQmtHCJ6wPLe/H/evyVk17ohSCq1zM+CNMYG2GNHTxMsL87I2AotCY7qBWFW4q2d/uOf09I51EvHc8cjd4xcECXH6+PTE0/N7Xr8q+MXXX7/h+vTxJhUtEQJIRhSX68p/+s//hevlB5RsO96//w6lLff35T2MslxOH7g8FdLYfDmzLJeGcYzjHusMDw/S8ek7vJ94eimTpM0WlEObiMo1dFox+UAns8O8eGIKDPIQeu9xux1RcMgYtYSsCxPZGNDQ9wOzGEpblzDK00nMQfAnYrAFIIdiGp0CWgteZAtwGaoviXE4bTgIUOxjJJJY/Nq+635/pBt2ONlqamMhBnIVP+oVZbuGxyVx4Gt6MAr3I98Q3sqCvJHVYipmP9u9BznFxmvSYrh74wVU/i1v3cPqNtbC1eTUZZVvMMq/PH6Bbku1hc8yeTQ3WIxxrcgodcinyHJ5QckJQSaNSNX2aQVJs4FBKcDNBBRzYuwdXzzsefNQJoPBaVjPZIl21PGZFFeCrBhrLC3PiogbY0k5Nqq5dZ1cULOd7ATLNJErWOk9Rm8VETkRU6AT8PL4+td0w6tGbvN+IfmpMVa74Y6YEtPpmbDWSIKBEPQG9GoFKeNcJSkp1utL6+CYYU8KcLgrWMQf//3/5vHNr7l7fM3zhyLT74cjShvOz2UyWaYzmsRVOjzjbuDV119vAr64ou0jIVVg0vLy9AfW5dJS77thh1aKRQR7c3rmev6IHUo1M969ok/Hdg2fPz4R/NpUtfcPrwl+5uXDd3INF5x850Vk/euqGMYdsh7wflq5G2/FjRmjEouv7j+ZELc9vNMWHyPGmOYclmJGG8WyyL3lDEpHUqzsqoGc16ZyNmaQe7diYQoffKseO2vK9c2QJH1+WiJZBZAcXjtYwUykmskTZAu6WjSWqqFWM6VayyS1EbpyivKM3BgMKVpbu8aT1EcIlUHfSPIVKDFErtKPGwJ3Oa5qmCXH9FPHZ8zj8/g8Po+/afz8yiOsJKPBKLGOK0MrjUq+6FEoGIGubSQZSilI8UY+DOQtEKiQ23Ojeav6uvzBw3HkH795xZev9gxiBLlenlnWJ9ZU9uApZaIyrbKIMeH6Lf4hpoTDbCHVpiv5MVm1nn7OhdgTJLMjTFeCX5pgzzpF322dpppyV41lor+itG6fEUMkrFdiWEppS9G2XC4/tDR067qCmstKqIzGGcMq7xnQZG1JodKpHc/PH3j91T+xrv9SzsUyEdOW3kaY6Z3BioDMryvXyxO/+a3I6buR08sTi7Qr3394z7zO3N3do8RfdL18xFjVwrKf3r7FunE7f2Sc2TeP08P9I851eDEJXuYLzipevSlcknV+zzpfSEE1kt2wcxgDy1rxoLK9rFWDsYV+Pa31vqhBRwKCaIeKiehnOmlbe7/I9kK4O2tE233Tx2idCl9DtiDXZcE6w9bby5iK2VG4JFZpbNc1rUqWIKpFwrXNdZYsYtmmiGS/VrQxCg8pbrRxlBJf3608SHHjQGQRuNU2tsrFE/iWaZ5TupFKIKYfCiVdIGey0Cpq20csHsh/VTXx8yePArdgxLH8kxg8RWt1RWk23wbuljT6eMO/Vxit2943eo8xetuXZlBG8eVD2R787tePvLkf6K3CS9J7mn4kT08ge9WYMiEmlmXr56MSMQgZay3HqIUsZN1QeuvcsPZSYV9O58Lc9PNESjS9x7EbsfK+AMmf8fMOLXt260bCem0XPIaJdb5inMNJK3Fdp6KwbBfdlhSzZvqyoo2lqwrMEFBuwAgOMHQdL6dnlunE8bFsZd79+Cdy0hxe/6oc58Mrnl4uzVjmuD9weln48GNpu375m3/m9Zd/z/n0JJ/p2e8fGYc987lMBsNuRzfuuEiOS9fvOL7+bWvFTtOV64fvcH0Vf8GyTC1ScRhe45cztZQf9D1WORYuOOGK+BAgrpyuwvPwCzkrSX2DsYdMJPhKDJRt5g0nQ6tIRDX4zNoOH7dwpBgzmogyg3zmiloXOsm86UQv9QnnKDuQ821MEXgqrdtCpMRkp/5NDJF1PuGaU1uP6vubdDfI0bfnIWcjRGzV0iOVUiStWxwqqtDH6vdQGSFnyn2SEyS45ZOSsyQT1AeNTzkdhWdBIn7S9v1L4xcQxm2mP1qZtmcS+kfrjBQmhPSnUxWI+U8UfSVTUzdsIKwrqrNtVbs/DHz15sA3rwqP4ThodF6Zz1fmU7mZw/WZuEZC3RPmiPdLswy0bgRjUdItSGHF6wkt2INxHSlmol+YBZm/Xl64vLwnC/BYiTdGRFbadJR8VLkJ/Ewm4rqDfI8FpSwpC2i7XtCuo+v2zILNxLjSuYFVDJF9vOK6PVpVZ6tyozo5F6wTyXs6OYbd4SPX6cz1/MR4KIzSYdjx9O579neFS3L31d/hfviRy0W+x2HPbtxRTX+n0wdCLKn3AEoNxDhzOs3sZDIwynJ6/z2D4DuHh98U0FomBx8CB5m8AFIM5Bzw0kWK2qDQresR/ULyM1qlYjFAOY9nb/j2XSWSZXZOMUp1OXQOHzOzVIKD00Lqk3vNGNY10He6YXDaOHQO2wSPIYZEJ8C60tXZq7xn3w+sy9omAk3Bx5qIUzmctUBqNhRKGeFpCDZGccOvvCVybJNsGbYQBmMF4iOF8aw/qdCNUuRmHRbE3KdOOJBuflZ8GkVSDcBL5tgNv+om3xnEZCvxWRj3eXwen8f/9+MXiJsUPketr2s5Je2hOrQu1UfOqTBHobRia2QDpeyLKVBrNuMUu7HjV1+UlfOr13c87Huq2xzR46cL08uPxKV0GGJIIMntUNB82/coVQOOJdNCbdqW0oqV13MiJc+6zqxLWfnW5Yq1HbnubYMvOIe07SCitCsVCIAqBsAtJ4OMsZbpJEa5pqd3A94vrGv5t364Yzl/ZFlebo7rsWl5tHUYbTGyvUrpyjI9k6W12B1fMV5fWK5Lo1y7fkfI8O6P/wOA4/2X7I4PLL6cq5wzpu9ZppovY4n+wklCoQ739+zHAdfbVka/fPiW4Xjg8PrvyjUyGj8tLGulq18kzOuGdZkDTs6dIoKKOCn/SSsah19So0tnOv7th4kgK/Jdrxh6U0mrGK2YvWaR160uEvZauaBsyS9RmXGQ+zKvKNM15qU1ijlEomxvU8po7VqkgVZB2Jrlz7V2aKNbXm7OKxFwdte2CNoY2UIIzhfFV6buFrIvwdjNFIrCeWqZLFl4UJtOSpWSdsNalBaNVKU3FOvPahaUs3DRb6QeN8YYcn4rMfvT6kTftHh/yvgFs2rloFsrVhWzniaM0xiy9JI3sCffuHzlRl4pP9/dHfjHr1/x+r7sQ3e9xuhA9FVgFvCLJ8al2lyQskKbbjPqsQoVFbV1aIxQeG/qQmOH9lBq48ghCsejnJ5hvCPGgBc6epa5pxK6OtNjuxGtq+5Bg7GN/Ka7jun0oV3Cfv9A8gvzdKYfC4HL2p6X+bSVya4j50AIIoyzHTnHltLOeM+yTK10nKYru/0D0/nbhpuQFrzfiE+9Dzy+/przqXBL1iVyOHTM9dbSDtcZri9lK/XH379w/3DkeNwTVxHGHfa8+vofW/bIh7ffs65rA5Ov1wuu63n58IN8L4fpuhZmtRuGQtSTc5fiQopLAYdTec8f3kdezguv9uV7dC6xG2jBRoU/o5q2JeRYFgtZwEIqStx1nRmyTFLKEKPaIEGdMUbha+vbOBYfikYJynZCS/YsYLQjhIzrtoQ+pXUBvataGoVzPUq+K6bcj/U98HPJ+pGt54pmTbE9IzqLcXdK28KjxSyrTSYCxt/cvzGljUaPPEfyWkhJlvdbH9SCjag22WppB+f/f0hilexSjYS1Vigjcn2KArJE3226k5SFiJPqLFpmvt1QDuurVwcejx1DJysjAb/ERt7SWZHigso37ERVjIlzqzQSKS1Nu1KAprzN7MZhXNdcs3MuQT7BB0zrhDjyPG0cFpVFPyHgprpH64EglYrpD3Td0MyErucn/LrQixlvSoFlPuG6AScA3Xw9F1KYHEfXDcKUFPahtSUEXJ5z6xwpLHipXJbzCa0Su8Ordhz7/YHTDz8wi2zfzxNK6RYv+e5P39N192SEszGv7Hb3LbDJ2sjl/ELOkV/9+u8BONwfcM7x9PYP5T2nM6bbs67lGu7v3nD68AeI9Vw8slxPjecxTQuKlY1mrMm5Y1o8LyKme7mm4pguGMduMDi7EbboLaA4yn0yLSs5xlLVUDApYzWdVSR5cG1nCxkwVRGbxdmeZa0GRCXwaA3VjczRO4undtwUxjq8TJLdOGCtKyrwytOICa0TfY3kMJqYDatgHn0MuAzaVNJjJlhTIcBPgp1U4zYhFZm8lisLu0561SD5Bjtkw0DIkqpY6v7yT+lG/V6O/K9S09bxGfP4PD6Pz+NvGr+AGVChhneuWL9V+/vOGfq+p6sZpdZK7uzWlE4xkm7kxiWIWdFLeM+h1/Qubnm3MeO9byVayoGUltL6ar6cQk+WFcb7VZih9T1EQyDvadwA2jU1oV8X1uVKSrkFBJVee2irGCkRQyBVPwkgxAUjS8iwe43tO7xUAMHP2P7Y+vvrcioYSjat1PbrFW5yebvxnmm6bPToFOm7sfFClAqk5Imp8kAyYSmq0FbCGsswDnx4LseRrithvqKkC2T7Ee99i1F4ev+eL776slHindV8+cUDu92erpcIgxQ4ffyufTc7HFiDQtXKLQVS8BxfFx7Hcj2VqrNFcxZ1dc24Cavi9PLC6hdq+HiIC1ZndtIJ6fuCG9Szk5MCY9kfynZhWQMhbbaPOZfg55wVSTofKSuUGvDr1pWwnWrHlbLCmq26SdlilW509hgTypi2XfB+xhmN0n1rxTqdCatvoVnd4LData6GNgqtE9bUqkFjk+XStFqhab+Uqfe4VOiNhS0cqoYO3CZEb9uV+nLpxAieUv1kUv5ka1MoFRqj1H8sz+PV3cAwjOyHnt3QMUqvfugsvduSrkRsX8xKKu07RlrOLUAKpBTppOzrBofRpjmGRVUAvnYT+YmkMkmpJshQYgqzLrKnDgGtTcuJ1QrQFt1tfJQUC0AKxbgnZYUxpm1tUgpFVyNl5TxPXK4nxp0EIfkrKjpSDUkeD+QYWxlq3J6wLuTq/q0tPqzYrmeWwGcoqe/7uwf5UZFSKO1FIMSAcW4j+nQjnN43ynGKEW0c6/Vj8Q8Bdt0OZ0+sL4UKzrjDdT1Pgkege15Oz3z1698B8OOP3zLNnmEok8vHpxf6MRPTxF0Nc04BUtrsBsxIXmeM4CqXl/fsH75qeppCUDON23A+nfHBM01ePvM9D3eau/2By1wFY5rjmNkNtYyHpDLGbeY/JIMRXMAahY8bRVspU+wgbhaJFGtbtW4xFCbHJgcIMeKsaffrvAb2o8XWhDktHI76C7nwkFC2+aS6zhUhY/WuVblMHKp69m5pieU+SAyGJqTLWfxx2LhPVX7fcBFpRGyt2iIMrSbK2yRbJ8lyApW6MfzRBQOp+EbVl2X1KZbyl8YvMHkc2I0jd/uBsXf0rpxcoxOa0DgdqjpA36yWyL/VL55jIT5Zcag2tivgalVoZiv7zkn+PjROfmMOhoWY/GYhqHVZhWRFUdKbrylpOSf8fBYRTeWmaHIOrUIKYYG8NsAhUTsyteevSVnTy0Nnu76QeeQhTstCC+dB9sZ2KD3/6hFie6IbGlh8uZ7K3laOwVlDDrqpf401GKs2opToJIK1LGLia68nHr/4DX/6/f8DwHp5ont81QBUZ+84TS+t6hq6jqcPP/Lm618D4H/8Dr/eYe7vt8SyDIvPGNFnLPMKOrFcCoFuHPdkozAS8q2UY12mpoXxfqXvDZOk1r15M3J/3LHOvn0X5+DNvWVLcS8Poa+QU4rkODezba3BJ41vs0fAGkcm4aW7EpPwH+TZDwlUSM1gKOdi/1e7bjEmlhCbirnrDSGsN0iBQmlbWKXiwJ6WALnDyiTXuQ6lDalyS1LRQGVhOysiSW+Vt1GA0iSVG4s6xdAATTnQUjVs1idw09HJqVgbtrjXXFisOZeFGwpWUXSdW3ODxtL96ZPHZ8zj8/g8Po+/afzsyuPxbmC3GxkHR290K7NJK6Slse1yLPyOHPwNy66sKLUthXao/g7lxAkLjQ9L89w0plQdUSzwuvEISrHMS9vbmn4kzal5afiwkNLWOfHeA5lqAzlPJ1AzTjxPleuJ0TPP51Y5QGZdfalAQExmLeO+bDF0tyMrvfljmkIt902haUlas14+yN+r1iHaLPYVrjtyPhWvT2JxActJjisqMiv9WLozYT7TDwcmMSYuq1PJgd0dy5c7P/+J8fiKR6kk3n77bzjT4+R7xRQYd0eCcDRef/Ebfvz+33l88xsAnN3z7t17tFE8pPLdjIauf2j8FGMjcV0YRsl1sQPrGlmXclzXyxNGqRbYNAwjy3xmEFzLuh7v1+K9IbyDrx4s1io+PJfjOu4UPsTWjt91hkXwMQCnS7eh2tvGmFFdAmtatmwKAe027o1PqlgIxspxKQpwJ6WJsQYfI7NwXpQaMdahpLrR2hBSLG5grmIvC/Pi2VHbvWCcRVd9l9AQqpFzJBEyraooUZQKjSLKl8lIQNkNo5R0s22hOIdtWnbE2Jnt42mEFwAAIABJREFU9RS5tb4QL4vtZ/lDdavG/QnjZ08eu6FjP3RFPp0WcqwZIJ4Yp5sth/iChk2arpRF5dwAJTs8oIb7tm2BhFUGLwDUPK+4rmsEo87toXPYbmyGK1or/DJzeS7Jaufn96zXc+vPZ3wxm6lgZoyY7tjATnzx1PB+xuQq9rLkTAPTwjJjrW1y+RRLwJWqWbWlc91k/ykloZ3LjWk0MWmm64l6Aa3rCctLOzfaFeJa1WuseWU4DM39ez6/JUWNE21G7osfR8wZJSBsTpHL+Ym+6na6HtM5BgnPfvrwTHJje4BevfoG86d/4/0ff9+O++XpLdPlifXXpb17d/+GzJm+q8bCgX53R5IW5zIvzNcz00VsH60jRd/wo3WZCd43c2MtQnBrO+7FwOnQJb794cIqpsq7sZhFm/aQaaJI08tnaEJKDfOIQQBQ65CP4bwsuJQ246mYRVAnIsEUMWhsbeUaizWmkci8V2i92zhKVmNySZmzJspx7vDr1LYDJXU+YKu/LoXg1bYUlO18qo+h6TAK4ro0PKLRLtpkkWWrVGn3gqc0S/ZK+hJcUD4p54irTvzU791gVRG1fmp5+JfGL6BtiWgVyXEpYrPaHYgrzTsRQOWSAG66LaBJabQ22GqH3+9JWjewLedQEsvqHZAy2Sf6+7IK9v1ANzygH3UDlFDFJzXFfwJgmU7MlyfiKpqR+UIKkVmiAcpFcnjZk2O6ojX4ZF9ZJhwnBKKoV0IMzQ8z+JE0bq5eqsZMyHdf15kY1xaUvS6e6/ktKMewL96f6/SeGObG89B2IKeEX4tIzfUHjOlYpxd5j5V1WZuQy4cVrUtFUrstOSWe333LIPySsJyI4StUndTwnJ8uDK6i8N9wfPUl7yUNznV7+q5nPBwZpbJwXYd2jlVWxqE/svqFq5y/sKxM1+eGHWhyYT/WLAwTsTvbTHem65WUNNZpdl054e8+en58jjweq09GZnCavquiwQK+d+IdOkRFydUun7GGSIqWpFIDmK0ZSTG3h0qZ6uRfJ9oC4Nea2Jhiol1NmUm5gO43APUw7lBOt5gJoEQ31IWI3NSqUMyhc07E6izvxjLBiEFy8fkIJEKbDEIqfqb1PXKuWphKIpMQqer/Ks+ZhL0WPI4Sb1E5LiCJc6YSOMukofnrcIyf754eJmJQqDiT/drKU6XAKNfQ6UwoFzLn2pHDaIs2XQEYgWgcpVNVZ9Fij6aFbj04C2ZglAyQYXCQCxnt8lIo15fnZ7r9A8OhTDC2f+B+/5rLS+kwvLz/P1AYxn0tsw0+w7KIGC9kWC4FYJVKwmiDCmYzlQWM6drz4FMEZRsIm1Ih8TTQVnpNtYU3nT+gzEC/uycK+OvXVdqG5T363T0vH7/fckZsz7rMXM9l8vDLSjceGtU/SfyesZYUaueoVH9TZeTmIhdcxGlsHDtePj7hl3I+p9OJ8fgVjxV8i4Z+6Hh89ZrdXqq9caTrusainK4XlmVmmspnrtMJ62xbEYvLeqkuoGy/QjC8SJSDUon96LA683Qu1+CHj76swELCc/sSAeoqcxZFShHrastTodUW6RGzJiUthsJCUnSwrr5tY3LWBSCt1Uu9TytI7le6zrVMY2MMqO2hDOvKqhXdsKeTSc0vE0ZDvy/XrChuXaseQkwYo6hCRKWKC96t8U8Wlme1kAiUe7QS0XLON4pZyEEiW6sTuiodx3rcmVwQ5aRI1aW90ukrRUJ/KsT7qeMzYPp5fB6fx980fr6fR5LSTLIjKukG4V4oKfV13VepLTfWmGIQFFUNiB4KXqA2wIm4kkX0s85XxrsjnWAiSpsSTaAMpisr+PX8P3j/7h27xyLcevOrXxOmK86VSuP13/2v/PDv/xcvfyz6jd39l5jhvtkU5rQKjduUVQLprS/pEzm1Urml3pMz2vRtrxtixpotwNivV+I64+eqjTHYfk+OK7NsQ8ASwkIveETxkuhb3EBIJbG9gsV2V8Di9SqVR1ZEf2Z/98B8KaBrPmW6ft+MeJy2WKsbj+a6rvS7kcu1VAGH9YxTd/RjIY0t1xf6fuDj+ycW4TIcA1z1lelSzp+1HSl4Fgmr2u3ucIMjye8HpVmXCS8WgykZ5mluMRWHu5HgA9+9fWlRC1BC02ukgXMKZ1SrZnzMEqxVftsZxaLNTXuTEhCuHUoIWTWsvAZ55VQq39Ba4aJ4Spu/aMq5tcpjinTdBn5aPRC8x9m1BUdZt4O4kFfhZAw7oZJXjMMU/9tcK1roVKneAOZwxRi35dBC0RApi1Kb/6jSplFJSoWxtXJTDgVfrG+gdfEJyanhNSQxDN98HUWfl9v5+Cnj57unZ0XOGmV2YHIrA5VWRa3agMyiezFG03hsEupUS0lyIR9VYk4KmpQTQU6FGYayd5PyPzrIwaOdxQu4qfdf49yF92+Lec3u4TXL+QPTtQCkd4+vuPvyP/HxX/5PAD58+z27u5lVfDXGoccNA6YbG+MxCdibG9JuMdZgZd9e2Hpb5wRxd/JCTIshEYX1CIXTQUos00vL7Mg54TrXOjyrXyniX/leKnC5vNtKTtPhl3PzX3Bdh6Fn6Dv8Um7m4Ges7UVLAijNsky46r3x4T1D1/H8XLZ8y+WEsWNzQn/58ANd51jDihVHrreX71mmj3z99/9ZrlFiXi7sJOh63O0hB+ZUyW1lwmgTawi4zjKOZVu5LIHvfvjAunoOO9G/4OmcZhQA1ZlYsAm5+X2IhatQJw8L1nDjYVHAyhASrvl3lK1TC4BOqXht3B6X1tuDrhUhZDrhLaUIPiR0zY4xRQG+rlNzarPWNTVxuaix+LjI9jWFFWXHJhK0qhgXO1N+XtZAzJGYM7oauCpbuEx5m1jJqZEDnSo8kYqRRMAnmrK3eOwA5G17lHNxaG/dF729NT99/OzJw9ix/J8pafTVINYYh3Vdoy0blcUsJxenaiCsvkQVUlPRhgLINczD43MiyUOYdceiV+blB/muBrTBB8VODG+UNqzesQig98O339L1mnkqk8d0uXI8jswiiPrTH7/jYZ6Ja3lg9OuvuP/i79nfvW5pbst8Ia1XViFfZWVQyjbjmCTJ5o3tWf6xqRhTLmFItSMU/Fq6KqZr5r+Jwmqdp7Oc1w6lLV7wnvnywnx5QtcEOTuQgifLZ477BxgH/Dpzukgb1XX0fd86YOSV69MPDaAmR3IIjOKItkxn3DC2Nre1PfN04nD/0CjVScHhq99s6XnZ8/j4yCARBSEkLpe5AbspFoCwYmG7cQClmMSQ6P3zmXlZuRu6dudqVcL3erFL7K0hZLXhAD6Ve6lWDVrTaRohTKkiv4wpgr+heWtDW6fk3zZwuTCVazWjVOm0ZOmoWauJwbPKbN13PX0/ENeltfBd16Ewm/uY0sIaFUHf6kv7vau2kAHdxYbVWG1Ygi/dryr0NLFU4K3ITYK5VWV6ROW5KG+Rjk5Wzd6AXADbzE1Mqy4K29rLKB2cjLntEvyE8Rnz+Dw+j8/jbxo/Xxg3HHDDHm0NznVYs8mRtbbbDEixY8sxCVELVr8Qotoo164rdPJY9/EBciDUlmiasTkxnwvZ6vTxhX73yOHV10wXCe9Rhm53YJDK43y9sGMPVpLKVeC7f/+v/Onb/w7A+3cfyTmiq6hKjRy/iOwY6CROYH//FbvjG+z/+K/lb378vsRN1pwWa5iuH+kuQk93PVllghCpiBNdNzTSGNqSksI6R4x1H5qLzkVmfqPL/nh6eVdfpu93xUaRooFIMTJKeNJ+/8Dp+Tte3n2gLlOHw13BmaT6U0rjlwurVGGrmDg3LGE5MV+HZptnrEV5RY6e67XwNg7H1+yGEaPL+XL9AWtd0xKdXp6YpxPW1BU9oHVkN5ZrPC+ZefWcLtKtWVecNQx9x1UqTGsNu8EVQRwUC74Ak5y/lFLxLJGls4jNVPNLSShizFhjG0/Gpyw4Ut1WJMA0E+sQA8nkthfqTOnYLLJFdm5XbCaqqDMVLVE37tt9EP1MNxxRVcafIiq7m5yWFb9cMWIPEbqeqEZ8qBheqV7zTZGQ0p9VDVIytO6LMqUCr3u4lFE5bbSBXPKiy/eWLa9SQnHf3ldrkYE0yvpfHj978rBuh+12WOcwZgNDq8Fq3efHEIm+sEvrHjCknuHwwO5YHjpnEst8YRbdQ1hmwuobYeb6/BF1veLlS5+nicMX/8T9628aVnC6XDEZHl4V/sT1eiL60LYQf/z9v/L0x3/l+blMQP/9v/03yLrd7Mnc8fT0Ed3fEyo4dp3x0xO9ZIA41/P08cfmH6Eonqe5KR+Lx2lNblOmY76eWn8/+vj/svcmT5Zk15nf707u/qaIyIwcagKqQIAACIKtFsWmkTTRxI26tzJt9Y9q0QtZm8ykVrPVnAkCBGrKyinGN/l0Jy3u8KK4YREFcZXXrEgLZOYLfz5cP+c734A0LT74ajAUvEXhUbl/9iFyuH9d83KXZ0/wbqRsDG4+orSmy9gBUjAc9ylZLt8T3WbDMEwpzR1QbfLgPB7y77SWpl3UsZ71Hjv2NIvUXoV5ZrlcslyvKmYx7LeMQ8/ZeQKgGz8xjfdM+QGKMdDq020lhMd7yT6nv/X9jBQNw3gSKrY6OdaXrFqjBItOVsB6mi0hSmxxS88BY+TMFWMUUvs6Rg0+GcOEmLgV9f7zsXppkDGq0jKIGFLkSf7TGJP725zPv3OepukqaSxGgbcTul1Ws2c7DSil0MX8OYs0izDOmFXKIsptTHAzWofsDJaeXa1USg7MCm4fEuBaNgOpZXZLz/9GRKRs6nGHmHCUck2R4oR7FAez3J6cgNzMTZLyX2Ql9u1JYsUAqAC31dgnseDKxCFYi3OBEATFIl83Lcv1hvU6MzXtgPMWYdOb0fY9QRhiJtF4scNPR6bCPDz/gMv3P2Z18bgQWRGmoz+OWFcS4Fom75iyu/qbr37J/nbL5bNEwX705C0319c8fpYYlKppcD7N5Kds0rsf97z97K8IY+JHbB49xghX3+hS5ndefkhDDGjV1A3Lhykb9GRnrOWSYEMyBc43RdOtEoCXMY3DzRfYcUuTncYgoLWurlRuHpHNGqHKjXtg6nfY6Vgrptl65mmsQq3N+hFHf4vJ3Pzz9RJr58ovIgSCnfBVSRohQn8c6kvBO0+YHVOuNLRMhkwmT8AWiyUQq3n0NDusi/VhiD4wB5umc4BWkabVuHASiDWtYtlq+rzBxOhRPAANpSAqUa0ahEhkLy9LWJhEaoULttonKqmZna8AcwIhody4MceGnAyAI1pJwgM7xUYnlXf6nck13dqTM7xsFDEnAgA5vtFXrpNzDtW29b7xwWFCz6rJjN8hvXfkAyGcTAdXDiodo4zEjO9Y79GCelxKNwkHKf+gUDhOVJvE6s6Gz+n8FpuMf0JZ/2fWO8zj3Xq33q1fa317hmnwuOCRjkQHrjkXyQcj1rbFJeOfEJEy7dSrswu6RXcKd+6PjMcdw5A9Nl3AeceUxUk+wn67ZbtNE4nv/vhjmrZJloG5RcB5kLIK4RpjOATY3SfJuG6XmMUZ0aTpzL/94/+Zz3/xd5UdOg49h90dQUjOzlKEAXFkmI5cffELAM7vz/nw+z8kZAGU9y7JrYtwLqS3TNUjeI9qFtVkZx6PjMcrlF6i23X+jJkoJeMxGznPR7rlI7r143xce5p2w83dL/P5jWilcBkH6Pf3hBBpm0WlYM8+YpbrOimZRGSjG4ROLZtULfO4Y8xVxDw7vA+EKsqCpmnY3r2ly+HYUgq6tktBX4AxGqUW1ThJRM/QHxkyp8W6NK4sb08pNMdpoOS2GKVRAg6Dq2/PRZtGu0M27lk2BufdA68JlXr48oYPyXyqRjKi0ghWqsoCLjaZpZpXUuCiR5cpRfbgLb8jhJD8PUrF5QOzm2m6PAb3joXuECJUjCgqhVKnLFqjDXaacbmC0m3A2VAtMT2O2DhMnnZpHRmnk39puQZwartzHNJJ4uEsVkRiZkMLmWw+VQ1giYme/iAv6WE8Sjk5MQvl/gXDlm+/eTjncNYhVfyaY3qMOdm7pKYFh3fJO7HLaeZd16G0Ysrg2TgOTNZxPKT++frtFetH79Otk3pVuZbt7Q3DVHwbPP1hy+54yzjlG23ZQjwRtIie8XDNsLvNxxs5e/oBpejq+yMxNtUgpz/uGXdb1pfvMZw/A+Di8hFNd4ZZpof/7esXODfz0fd/D0jYRgiOMatmVbNgc3FZx4BaNyDMKSnMTZhuTURXdaogA8QlNPniA5CSMatshZDMw66Cy6bVhGDp9/l72Znl5hltd8b2JnFc5sMt588+YrVOZfFoFiBaVJs2xdurl5w9/yHNIZPKRMthf8PUp5t9nGasHZEy0h/u8/lUTE1f3cdixhRKGT1NE2Gytb3yPmJ0rEl4wXlkjJiS+dpKnPcMk2W9yP6tpmOeAzHT09VCMc5jba+MlNkU+ETBVuKUAkgM6SGI4mQGFEs7UEx10jkv14iKC+S/n30+TVNCuTyzdbTdiSZu7cSy604mOyKDssWHRECzXDMWScF4REaDKwCq0xgpaNtsgi3SBhiCOG0OMWE89TNjAjtDvZcGlG6qi5r0AmRS7AIpaD4nBvgHO6mQAhnKd424qSeKHNj+Dde3J4l5n5iPRPCi9oxJaeopXLcQAt4HdLPk/FG68RarBdOwq+j/NA4Mw5ExT06cc0i9ZJHfvm9f/Jw3Lz/lH/4+Pejn73+Pr778FT/7+8+Yp3RBPvzBj7h4fM5FDr5eLFY4N2MzWFmk621+g7BcYl98zpB5H/1wg3ewuXwPmzUi8+RYLM5YnyVcJMyOcbJcv07q08vnHyAIDNnkaLF5Cuhqh59wDVsnT0o1zK4nhAlZ3LDaFXZyJxagbPHzoZLs/GwZhgO6XeYTHJn7LUoWnYKn2Vwk1/J8M28ef4hUC6TJStz5yO3dW+7v0818f33DM5Y8e/rd9BlKoZoFImHNbG9vOB62qMVpArC975lGz9WblDLnAWMWFIdGqTyNOrnTL7oFzgfGsRhARVr1gL2rDP04YbSi6bLyWUqOh6laFUaWBG9OalQhs/VkPhUStIyntPkoECcKZjrOkI6okBhjASErQSrJ2kV9O6cKwGSBn5MeHyJjJhsu1yuCG5ktLDIrWGsND0ykYvRIqVhu0uZgp2NKZSubnJSM444um0Vvlk8ZncWNrkIPMSb1sKhApszVXDFOSo53pzojEsMpGQ+ZWNxpMypiuqQxK58YYsB6h9A6PcffcL3DPN6td+vd+rXWt29bvMd5n3b6ePIVSPbuybIPcrklFKZdslznt2eM2GGsnpumXWGaI4uzFFe4fvYxzkVe/OpnABzu3zCNR/ptKss//Ye/RzBy99Vn6FxJ/O3/9TmrJ+/z2z9J9OnHj59gjKjKRqVbYpCEkEvkxYLN0w/Y5/Gw9APd2YZoloRM8d3v7pGPzlheJFMdITXH/R1D5gDs77ecPVb1beGdJ/KgdaJE++VSUhsMS+w0IfO0xLuZYTiidKGjR6RZcNylKuH26lNihDZT4m+vvmCxecxylc7l0O9TwLGUtJv0Jux3M3MI7LLW5eUv/4F20dTJiG4WHG7fsFqnn7v1ezQX3+Uss3UXTyfG45bQX4FN1WC3eM3rV29r32yUwTlb31feweAiy2Vmrdo5lQa5HTNGEeNccS+iZLaORglMrqKmfsDOM4scrTCOM6N1tObkU4s4TV9K9k+pNkKeokhBVZtKpVP1IU5v5JC9MdKtmBirtXrJlTOUMLCUoxxq++WSj2uMuBxVKmWHNl2dYoigIJ7wCqlavB8qw9qYxBKe83RRNYJGKwbpqoRDx4TV1ElTAC1Pz5WgyWPWeqcR/WlqJDLOGOMpSCozCeqSUiFNC1KdquVvsH4Dwrjk4l2iJU5GKAAP8lGkIDiBabpqBDNPR2SzqiYvx+MRHzUhE7pEMByPb2rietMt8VGzPM/A4+z47vd/wOwbYi4vD3/7F1y/2FdB1I9+/CPaRtEfCg8hoheKMffw/evXyUQnC6K06dBNx3G/Q26yrL/rUvZp9ihtuwUegyS1Na9efsFkHc+/80k6KTJgtKianYTFncpEESPeJm8Imx/Kqd+jdVvbEgEc715wvHsBwGr9CFRHv7vJx9Dw+L2PcWN5qCPDMOB95OZ1MkLyLrDcwMtf/jUAt7e3fP8n/46Q+RFjt8UIXcV1N7dfoqXieJ5wlMlOaLOiUQt0pop/8MlP2Dx6zJuvUm7LMCTeTshYwqJpEgZQ2oOYQO+iEREiopWhzQDfvh+JIdAtDSXPxzqHEJG5ZKSYlIFc+BCJ96Crp6mMiZAoC1fHh2SMTTgFRfmQaA754QjRZ9EYD9bpByH011zuIsl1v+hBvB3RaoFQ8vSCDBbQEIs2a8RGX1+OwfskkFTp77frZwQELnN91GJERImIoYZqETXEkw9JFBGlJSIUt/p/InILgchJGvHw/59MuAQlWC7/o2TaVHChb7h+A4Cpxzmf9QQ8OCKRAKtyMDH1WstVV8lUKd1NM2XMY+z33N685dWr3E8HRddG7u8zWMct9/dHzt/7LQBWF09YPfqA98SaKFLlMdxvefnpL9hfpc+4e3ZOozTH3Kvudnsc9zXM+S///M857rdsss3/h+9dcvn4Od1qWbkMzjs8kuX5cwAa6Tm79Az3L4HkE7Hd3tXksMfv/ZSYTYkg+U0kLUUBcR1SKdw8Mo9Zy6IMUqlKPPPTEcLE5sknAEyTZTje0W0SOet8+T2sfYDlSMNs77i/foXIHh+Xz3/IbPeIvMkppbl6+TmLHJO5XBnOHn1QMaa7t79CiZntdfoe548uUSvH0Y5Vu7JYnvH0gx+x3KRzsb274u3b10xzYegKlAzMWfDnvcc0mi6T35xzSESNp3TOsuoURomqqvUhmeA0uoi70r1UiHxCSqQUVSHrI+goT0xaZkTgwXadHnxHOCXUi7SPnGwgEy/jNIIoPhuh/nvvHdVSJEejCmlO7luCbLhdeB7JmV9SojXT/S5KHKWziKgr2BzsiFIbtBT0uaoVUqfv/7BUiCdeR/gntoExa8gKRhJLINqDHT3FO5zYtMW0S3KK7fgm6x3m8W69W+/Wr7W+fdxkbldijATBqfITInsfnEZfQibUt27+ymTKeqZc+8RMHA85iFmviFGw26aefe53TOMRJRN6rcyCGBQXF0+5uUvckGZ5wWpzXq3+767fIqXm9ib9+fXtFXe396w3qTV6+eZzfH/k/L30Jt08/Q5nzz7GNJrjPrFSp3lGGcvxkMeqyxai4Jg9LKRp2e/3leX6i7/5L6zOLjk7y8a4wzGHRqVe1w57IgoRqPknUgp0szxZLExpLDsOxeIusjp7UnvfsU8xkKt1qkSO+1tiEDz/+Cf0eWS8ffuK66uXTJka7r3FGM2Tj74HwPmTDxjHiSBTW9h1mqEfeHyRqoTVquPR86f44Li/Ta3Q3e7IwjpUZv0uz97jiRcc9qk6vNtu6bN6FLI+Rmi8L1oX8JyCmjsTQUTG+aTHsC5J8ItzWITcbuQJjTTJe6L4eIbMrSl5QFkt60N8EOdg0NkGMN2PINSDLBP4mjJaRPFPXvY5P6X8++yhEYulX/7MEGWVSkhAylivezIjdtXUOsWQBHAZf4vQ6uRdUggXIgZqmExe4QRxpKonxlrtxOhzeNOJOetChCjqYCkEl+whi9mzkPgYkwGz4huvbz+q5WQkkh0rgXTxAoJYAKZsMDvNM9GnG0+ItKkM+SGcLVgXiZmwdb+9Q4qIK8YywbPYtLz44ufpM/VjPvnh70JwzGPaHKKdkChKsPXV1VsOuwNfvUrj3Xme0UrQ9wk78Nby09/9HZ5/8AkAy8fvI5oNy/OzSvMe+z1KGXZ5M3Gzxk47yKCfXpwxjTfVQ2F//xU//8v/xPc+TqNdEY7gfQ2tDmEiRo21HmEyh2X5HGU6fJbPzy7QH/aYrF0xQmCnnjkT5qSAbv245orMVy+QuuPi6XfwMY9FXQ/DjmFILYIyhicffECbJfm3r99yf/slNtsAMA/Y2TO4fH1si9pbzi+f8/Q7mRvy5gW77TUhh1Wll8IJSFRR4KWEUpqHpOUp1nmtVmgjKxHNxoh1nrbR9b3TapWJUGX+m0ru6lMbUyhSARW9Byfdg40hJN6HEBWDsy7ktqKQ2b7OhopEpBC1pZBSIIXk2BcafZJhlBG0iJHgPI021SAohNSmFcJcyFqZYpTt/Ezy54j1z83ijJIwQA6l8hGMOh0XggfkS5EBjDK2FvhgH2we6SVdWmZBcpn3Jz5+MuaKJ4q7j2k0rGWTn5pvtr715jE7j3Zpns2pjUqgVfy6ai+G5O1wusiRaZ7Z59T2Q98zWcc28xAOhz1+HtjdpLfe0O/wPnB/l81rxGe8fvmKy8tHrJbpbXkdPJJQTZN/8emn7A8DY96AFq3GaMWYe8oPn5zTj6F6ing7cf/2JfqBN4nUCwSem1efA3BL5OzyCVKmh1B3HtnsORzS5hIiXL38lGDTz88uO4TvaTKb1Dqwdo+bjgzHpO6NNCwvf8DycXJAO25f0nbnJ3B57rF2wHQJUJUoYlBcvUhKXzseuL9+ydgf6kZ6e/UVh6E/uY6bButccrUHdrcv2V6/Zdyn8znMnsEGvvz80/S91BcorVl0S9aZFNYtl4xDj/ZpwzE6GToX85pFJ2CieppGIdLvf+BaNcyuih1lBiFFlLRdee1JrHUnYtmDpPfyIUKqypuJJP/fgol4l6JChSjbeXrWnKf+m5QsWDxmgOKEU1irMk1nivGUzPfNyZQnCen8AwVrQCUHslxJp2gIX1mqRnRM07G+IMTY00RF05RYkAnXCBC6bijpGTptBgiR1br5KCIPohUy2dD7WpWFkAhmUqmvRYmE1C6kH72FEPF4/L8mScyTAKsYYlYMltFXEjpVa3gfM1PuVF7a2bHf7ri5zSXv/R2DRg/1AAAgAElEQVSvvnzB9ZtURiME87Dn2KeTfXe3Zbs9ViXkfvoFP/tvZ7z/vd/CqCyd7gyogMxTjHE4sB9dzdCNwO3+yPkqbTbWW15++hkhl5I/+J2f0piRcX9VjZlDhOhndBZeDX3P8T6NnQGcnbCOXPEkwdHoBVd50xsPDR++/4irz9NGYdoumRjNNhkuA9Nwyzj+JW8+/b8BWD76bc4ef0LMaWTRj2ht6FaP87kbONy/PGUBN48Z+luuPv9LhryJzfPM7Bwij3eXq0e03UUljQkhwVtC2fBjpDWSxXm2SFANIVgUAzev08apdEsQpsrOH58vIUZ8fsiUEjQKYlvevhLvfY136KcA5FKaBKA2WmXpOPl3OII/EZ18yPnCZboiJdaHatoVXUjRFxkwNVpV+X2kiOUSFX4qzNfoaYw5TSNCIMiTKXDMk8OvxUMicA/o7EoJoo8EWajiLjn3l2hI04IwuBIzKjRN0+GK5YQd8UIQig2nOEfLRAqztqitPUK5GmUqUklWXcGklGgh6hQpmQ+dDJQJNjvBn4h5RIMID2nwBqlK6/PODOjderferf+f12+A5yESF18IfPTJ4JW0M0ulH/DpU0xEJDKNaec97La8ef2KL3KZ/Pmnv2J/95plU/q5VD6Wfm8YJ4SEfi7t0Ja3L37BPF2xvU9v24+++yOWF4948+lnAKwXDf2UKNPpeFPmRdmFt/uetjWQc10+/4e/Y/rOx7SNZlmo9TEmuXsuR7tlS7+/QeTx72K9wDSG6ZC/135PFIZVjnd4+eLnNN2as4uklZn6e8I8cXN9i8r98jAeEuhXMl2//BLRnvP0w/fzuZA0i80DEp5ndfa8Cvq2969AdAglWORxrmwWTPOX7O6zBeMwcrx/y/YqcUf63Q1KzrSZNOZsoOk6FutUcY1j4PzsEiUlw5xB63lmtZRMGYh8e3XL+WZJyG9446HRqoLH1oEXogYOQRrDLjJvJCjFaAPD7HG5zZV4ztarSujy1mP06T5AGKSwiAcAaSRWrw2tZeUZlXLfB4fkZHYjSdVxOc7gA1qLWu3E4JCqObGt8CAbSmydc562yYhfqYhMytf1uWpwStAtV7XyS3nNBpUNkyEilUHqTJoULUoKNIGiBwjBpjd8OdBiWVhA2WwiXjAmn8PjRQma0hKtNMq0J5IYEHCIEsSuE49GRIUKp+f1n1vfevOwLmJdBOkTaFZ6WaX+CSgV6ZRmth4zFy/KI2+++Gv+7s//HICvvnrLarNi+UFimM7zEaVkFY+12iA4mcZYH3n9+iuEmbjfp4du+zd/zW998gE3+3Tyt71D66Z6fab2IwmdALSRNHrNxaMECLrpwP2rT9ksFPYiTXViCLhppMn8iCgk0zjgsu/p1DcsVx0qBzDFCG52zL6Ishw//9v/wk//h/8JgLPLNfvbVwgJx33atLwPOD9xyBtSv73F/j//O3/0H/43AJp2lUhTMYdVzRP3t284f5JYr/3uhptXX3D5nd/jcJfA4Nd/95/Z7Qb6nEj/+HlD12qOOUjqyXvP6Hfb6p7u/Yzplow5wLs/bLEusl6tWa/TDX93PzOMM48u8iRpSl4XXdaljNNMjOkBTtfIp74jP8StMcRprtGQSis2nU5ThypHUYzTTNOmz+yakn1SxnQhPzCnl0wU6RwCtI1GaImztnrbJLwwVB6DjwIZk29L+vOQ//3JxDryQJvlU7CYVCf+ivOBrmvwvvxvCilNdSuz3qPsTFNMwE0DiLrJKWXQuq3qbLxF4lksGpY2A+Gzyhk0+btS1MHl54QnlZ8VyS39YaATFFOhYnqT0KOHpmGJo/VA6/MN1m+EJGadx+aEuCIkwgUIHlGIPVEkWvJ+T9PkUasC7w9VERiCZbYT93fpoVytO2ym7gKslgvC3icLOqA1qfe9vdnSLPPNe9zys5/fs8smwD6k0Vl1dReJojzn3nepNI1uMW2idC+WLXN/z+7+qrq2z7NDa8MiT1ekjdgomXPvOux63LyskZZEDy3cXaXkNaThsHvNL/7uLwD4wY9+j+X5c55IwxuXqq7b6yvsHOrNrNsFV1/9HX////6fAPzk9/8I0zR1I93evmCYRsJVIqodDntUa3jz2T/S5w0oKkOIgkzU5DhGPth8xGKTlG+CgLfh5Fa2XHLoD2x3CWdZtBoZLeOwqzT4y8sLrq7v6xTiyeNz5nGojlvLRcfxcCA2xflcEFWyBwAYrc8ucyfqowsxVYJ5g5EisSRDprRLKSHKSp2OfiT4UyUiZM6Qy+fO2+QQ1jTmNM4VadRapjzJuUESy4NuA0raaiQc/JyNjjI2E30CcOvUQ+J9elDLLe9jwLkZo7ODXEyRJD5vOGEOKUCsAL3R4WNbX7LWjsmMKXYsuhIc1TGOI8KfhJ0Jj8mbno+IcNo8SiZtwXKESNT25BSfz4VMYrqye0QSszQ+dAz6Busd5vFuvVvv1q+1vnXl0c8TUSmsszTG1EzSmFPMizJaAiKkKqW89TWCxfpJnSDE+CW7+yNNNvY5O98wO1sDo621tEaj8vhSm8gwOQaXTFQAVmcN8+h40qa+X2tJfzxwyJJwoxO1uUw5jNJoLHPmLchO07Utt7e3vLpKZKt+Sm+kJk9f2nbB8XDHcpGOY9XA1B3YbDb1dxIjWmeOhlnQth2HTHZ7++Yl7+uPkHpVKe3tckW3PFG0nZ2ZhyMvP0u6lO//mz9hdXbG1cvEcTkerrl4+n22N8kW4PaLv8U5weGwo89Vl1AdzouaG/vqxec8++j7fPhhIsRNQ8qULbjUMHj6w8TjbGegtUTJJo8HM6mrW/LkwnE8pvYpEeg0WcPGPFqkUjXkyTTia0Y9k51p9An5T22ByPKF4tOSKsZoy5syIIXC53OjpMJDrV5CCLkUP5XoUoJSba04Ex9F0eRf4VyK3izVSvQB7yKSEm6e7tdCA3cu4IOrJjtCSpx3WOdpsum3ViG1M5kWoLTBOld9aZEJGyziR+8mcMfK1QGD84EgqOHXMXHoHviOfD3JPoVan1bM/UjFbohJxyLEqeuTaYoUT6cbvvYp32x9681jHCaIEt1oIrKCikpIHCdfB6Mk6/Wa880aU9yZgkQ1j5iya/awT+1KOfmIyDRbhrG4qXtEIzhbppvbe4fSAmkDw5Q+o+uWrJaRYUg/z+NI12iabEo7jH0Cu3JPrmU60WOfcIC2vUR3musvrnh9m/GIkPwsNznYyGjDOA1IkYVyUnI89PXmXa4WRHci8lw8vWSe5+qm/rO//guiUHzne7+NWSSSWDOnVLU5j5ilannvez/l1WdJUfz2y5/z9P0POd6kkenFkx8Qo6hGM9M0gOgYhn0VAZoFrM42PC3uV7Zn+/bnbNbpuDePzhi++gKXhVyH45TwgnxzLjeXCARj31cWcO+ONM0Sk8+3nQaiUSyX2dXdeXCi9v3EgBCWRVvwH8HkAosiWCM/GPL0gEiViFDOF6Dc0+oT0TIIhZJUc6UY03UUptACfMpM8bFu+D5zjIoyd5wsIob6Eok5JKoySYTAe4+k5A+TDYjyrZkJY847VBapiaxKLfwmLTsiyeQKoOkWCZjMG1YQOrc2RVgHIjiUEVhf2LRgGo0vMwKRsBdX2pgYAJUYr0DMT514QBJLNApFfOj6UXYlKPPfwvbkm67fUGKcQApNyH0kpMSuMM91B1x1C9rGoASVdSpEuqhzZkCKmEJ+i2Hv2O8Yh77u3DpEQji5QanGIFsFDpbr9JltZ4jBEo/pgo3zQPQSmXf3rut4kBpJIzWmbWq0YfQT2+2Rl9dbbH7baqXo2haTp0DTMGA0p61bNQTruHqd8IfHT5+xXrUI0gXevj0y25GvXqVKZh4t5482dIsNNZWOBYt1w3KdQVq1Ythf1Xn99uqXyLhH57T6fr9ndtfs7hJztlmeMx2O+PlA16UHZrEwjE7RZYsDrWCeR/72rxKX5E///f/Ksw8/5pDlAIjAYrmq0vb9/S2Xzz9BSMPYF+5IwBNoFgXkc/nBKwpYwzzO2JKupGWavsQCZkb8fApoWhiJ9xEVHwQuxYSBaF1IX4lyXYKOordVqQpkPtFp84k+pmmfiPiMcSjTAaIGNDU62fKdmJkiTbsyQKRUAroLrd5aiZ1GVCmxsi2AAFzGe4RYpDTAwhiNDqVWdcOx8wi6qdMYnynwxoR6jCIMiLCikG+UyIQ4Heu/cYEHTmPJzPihzaOQoapjI4kinwDRfMJ8CcsueJCsNgcPq5p/br3DPN6td+vd+rXWt648hJRJ2xAFSp7yWq2zqZjKPb2Qgtk6htmxzuzDtvWIOBNseRsobIz4kHbmN1db+v1M25xGds6fdAlSKpy1DEfH+iLPypF4T81jffqkYzhMbA+pEpkmQdvoKihbrdtkn5hLz+BnxnkkCoHJFVCnFYLIIWtbrPesRYtNH8kgA1pK5mwKc/32C+TT57SP0/h3snvGfqTPE4pnzz/iyXd+yDT16OztIJXBR1lR9hAb5mnG2zJS1rhpS8xv+MNhjxctfsqTlSDY33/F+uxJYjYCbhwRwWEzVby5eIYWLetloq+/+Mef8aPf/2MGWzJV/itaRYxJbc049Fy/eYFu1jSZTWtiMuop3qAp81QTQhkNJn+JNjN6xzmNZYuvho8CLeWJYRqgbVL14fKrUeeKVFUugwBFDTj3wSOQyDx9UcisSSk0/JwP26hKHfDOok2HyixU5yLDZGsr5H2ACLZodLRGyojL7VmIGucUweU3sw5okQ2gioeNm1L0qsheG96SuCZFL9OmAO+SzWMnxvGY6OEkv5pGXCQfkvxdnJ8gnKyfBYBQhGpSZBHRPZjgCJKdwKktFCFVWHUKK7I5UxljZ92LkOJfVE78BtqWmP8LgHygbIzotq1BSRHJrk/jXJVBqfVqjZYSW5PiPc+enRFjegj3t3eAw+e/bwMQwRULyBCZ+4FpnFiepZt7sVnTHwJdl8DL9abjbDOgrxOmse9n+iGwfpzag0cffIfYb9nepD8PpPtt0eoHqWeBcT7W76ykIMTIXNKVep96z/xz20i8PRJJv8Noxcv9KW8mmhWLyx+zNBP9Lo1znb1HNy02P4RKCsZ+i8rBI/2h5+LRhxzus+FxgPu7LxD5EHa7G7w0rNdPajKdC5b9fks8ZPKUaVms1jy6TNyQz/7xL9geJ77/wx8D8MHHfTJxLlwdbZjmid32LfOczu96uURIsFMp1ZOxc81HaQzKNOhyYKJlmmaajHPNLjK5SKNOClqpFFqp+oCkUlyeNqicdlbbEpH+XTzZjwIy9WVAmGeapknCtAwWRxHxfkDnl9liscSHA9YVjkZSldop/dyZTC8oBt7OEoI5jfi1SpuWoG5yAk/0FpnH/iF6pvFAu0ibMbLBh4Cu+T2PCKLBTWkzD8ES8rGULGBnR7RpUaK0t5E4zhUnEfhMg6igSGqHcjssZaLqx0Cl9wsJIp68Ywg+tXmok9/JN1jfnmGaRTZCJoCp9EzGtGizQMg8KfHFat/UL6a1oe0a2rbM5y0//Z3vc7FJn/HFF5Hj0bI/ppv/btsj1ZJumS6OsxPdUhGkJmZ0X2vNo/Nz9vv0tm2X5ywvHlG2Wb3dQxy5ep1YllppnjxeUJ5CFwVCNszTxFx35qTbKRWQzqldtk6SIiL6amYshaIxCmNyyDczw+Q4ZGxnHGeOY2TRLYgxX2TdMtmAXqSH1LsRKQQ6YwvXrz/n0bMPmXMvPM0RITsOWR1snadpklP3Ppv7zPPEOM5EkX7vcfuKxeJDpjGdz/X5U15/+t8Q0109huE4pWoM6FaP6VaCxtzy9nUyVwrzxPmjc0Q+rv5wQADTlDbfOOn0YBZxmIpMIoGk6forhhjIXkEYo/A+TUMq5pF1LEpX+BIpRI3oUErSNPoUWq3N15zE3Jy4DkqesJYQ0gY1Z9eupu1YtoukjgbG7Lhu8wZvZ4WSsU5rjIzM04iS+T5xDboJBB8QTYk90Ol3Zi2L1A0xhFqR6pAe8mz0j5QGpTpsvMuf2WMCROmrJkeJ9H3LlGfyHqkecmBEmgg9gCqkj1U/Y20gCoXUpm7G5JewKJqaUrnEUN3vvsl6h3m8W+/Wu/VrrW9deSihUCKXRg8Ypsa0aR5f0OyQwm6axtTMDpCszi4o22bXLnn+/CkxW9GvN0+w4z0hj3Jn69jdH3iWPU5XZxdotaJbjPS5OgmzY7FqWC7SG0ZGwWJzwWUJC44eP4ca3Pzzv/9rvlwtWLUFndYMQ89g53qcC6OyhiQdZ9t0aUqUS1iJotGqyrtVZvDJbI0YYkDJWAYrvHz5gr//q7/hex+t0T69+dZnF/TXr+mPuVqRAdOe0XSp9en3N+y3u6S3AF599jnbw3AKHAJMZzn2d3VM2nWGZiFrySu0pl0/YvKpSliqjuaDwNinN99ydcZ4vEbphNUsVIuUmtXFh1zkNmV3d81xLzi7SJjRZrPmcNjR5fZ0GCfsNNSx9WwtWktcxgqc80gpa9SFMjIpQ5WsWS8xG9dU2b7Iytp81whSBVMmZAGJswEpinJaJ36ElOj8vw3DQAwamfurw+6G1eq8WjcYkXAcnyu7cZpojazy+tYYEBGf3+jeRbwWtFoSfDFAXoFIFU46jpjwiRINGcbEgcmeLChF255hchjYyYPkwURRhqR8zl9eRUcjYm3H0gl5YGKETB44udKPPtkl1BwlAJ+8XQu7VggNwRFkrGrdb7K+PWCaqPUEH1BaVUKXlDKLdPJNomROynoIqnounzzjT/7sz9KHxSPPnj7m1YuvgARSzbND5/KfIJjmEZvLwGloMBcb2naF48R3aFvNKiecWRexc6BdJj7F5uLIbC0XWe9xGO64vh+4rye/SNMVTeGCaIFUsiaTj6NDKYnLJa4j6TlKIJCQAW0MPpevzgvaxYLWpAs6u56//a//kcOr5/zWJ4kqvlqfIaJlzCFOSmVwUWWacrzh9ad/zSe/80cAXDw/41e/+gcs6c8Po2O17FkuBU0WXlmf+CLluIWQHLdH5jEdx93VK1artkrb2+WSTXyCnYr2ImEPbhpZb57laxQYh57dNp3vR0+esorQH9PPbWOw1le+QIwR70+4QAzQaDhmUt84S3RMbUuXNwPnI94LhC7+tz65dBVn8yCIztLUUj09GCWJzWiFcx6jqfKIxWrJfndH16bzpaRhGvvKeUktnqvCQ+8FUcn6UIZg6dqmjkCld0TnEN2iZudomSwnav5wu0i6l+I05h3B2Zrb4t1IbBbotqTxzZS0t5BfEi6xvmqId0RkkLQA0OnFIeIJK4sxnjJ1dYMXEkJEUlqdgJKGUIl6khg83rmKWX6T9RsQxjmUcyilaFVbiSg+JKGcqh4LBq0NPvhqjns8RDabFX/2H/4XAG7efM6rF58T8hvceksQii4ntWlxx2bZYEz687ubW3TbsTlfoDOPQ0uFkIq5+Klpw2wjq5K0tjhnsZk4y5vHZuiY/PA1l2mRRgj1u7iQ2I1lT5Yi0iAqwm2tBaPqd5XaoHVTzXL3+yNSNCwz/2J/N9Mpx6Hf4326caZ5JITAYZc8QNarNfPxPqHxJLfuIV7x1ad/BcCzj3/CT/8w8OJXSRtzEZc8Wi859GNF2ufpSGM6ulXRSTQc+i1dNi8W2yucd6zOUnUzThOX731SWazjNHL5/D3mfs+bF4nJapoFHbE6mu22d1ycP6kq0HkcMUYz5SmFECmprBg1t03yn8jPeQIqpeAwWaTIERANzN4TC0FLJDZnQfza1hDi6XoY06a4znwRjdYcx5HQGFwoIU3ndM2SPuNBy+Waad7TZBvI1XJJ5EipLoPLWq3KwxEJf8hqYKNbpEp2iMUpTJsmDV+K7WDTYtp1ZdtqBYE0HYHi/yKQJm32UnbpO4sqYcuueoJQmK1KIr3HZkMhHyJIVdW+QabYpqKg1cagkpMOpXxJzoai6nRCSE7zRH/iLn2D9Q7zeLferXfr11rf3gA5L6VS+HBh7IWQets6xpIa6wNuHpnilH/5mrPzNXPWMPigEVIw5t53tx8JQtVohuNkWW7OmfN4bbYj+/2W9XqBaYq+oENqyTyfwpqltVxnjKNbtjTNmvV5OobzvmeYHPuh+KRmhWEU2MryS5u0ruHODU3bVSxhvx2QyLrbS90RpapvD+8D02TpMk18ubC8vr9Dak3IjMd5POLcWN/ohxCZjrd1VDhbi46CYw68ev2PE08+/BE6K31397dcX9/SaI3LGTR9bxm14lnW3BymmY1p2GcZwHvf+THHu9eUYKOmabCz5clHvwPAmy9+ztQPnD1+zm5XsnyPSGmq58c0Tdxv71mvUwUVhWIaRkovFFwSUcTcwlmvkcrQ5hZkCjHFGkhVWxmhJFLIqmWJUiKEZs74DjayaESKSiB1CcroyiaVUhFCyFySTKvvkw2kznYQs53QesVYJiGNwlhdGaZaG3x2VivfKwSHzhwOtEaoFqnaynbVbZf4OiXcPXgUgSbfm9N4xAeHyVWwkC3eR6Qqo/EOIQQCX93yQkyTvdJ6Jv+PDjI3KgaPFKb6fHg3k6qZzFt6MDwpdH4pkj2BKpaLhKps/5esb715SCnzf8nz8WGvm8hj6efZOQSBaTqiRaEAX9A2aZwFCfjaDzOvX6Sx4PX1jrPzrt7shCy7zn+/7RR+HjkcB84zgCeURrUtbSZf3e/uAcXUp88YBp3EcdmAZbEcaBqLruHZkUgyuy3HrqRAKlE1Oa0xtFrjXC6JO0Vr5MmgRRhiNNWDQZuGdrGo7cT7z1t8fMv+eGA4pk2tP9wx7HfYPulpbg6v6drAImtytFZ47wg5D/e4v0Fdv64X/bi7RclkvvPqJpHZjoOnNY4PPszjctfTzx6Rz//b11e0bYdSGSNB4ObIWZbfd+unvH31GbrbcHb5nXQJ/Fc47ytnoO0UwVnGMZ2LbrFiGqdKcgpEfAyVKBVDAkPLRutDIMQkAZjzzT1ZkR5a8eAzhDy1EDEwe4HK7YH2Jj9g6ZiUECAV8zxXqv54PGLOl6eHarYE4Sr+plEsFh27rD+SSqKNxIsC5rcJJC/PWJD4GLB2qIFXoj2ja5rqHB+FQCiDynSFTmnGfofN7MK06XUPDJF9zspNMvt8wvIxFq2LISqDyNdM+BGhzANsJuJdqEY/4HPgU6xtnxAqt+W+/o6kQhP193yT9RsATNMb17tAYKoXvITf2Hy2jdGEELHzXLUri2WH1oLDLu2i9/f3vP7yU65ep7fr8uwx2rj6GVIIonPZnRuEMkzjyM3tjm6dgceuTUE5OjMFZWC/O2S2H0zzHiF0ZXYSZdJN6NLrJjasVqKi+1ppxANmoJLg3Q4R0422WrY0SlZeh1AaGyQivyhnH2kXG3xmclo7c3m+It7PVRQ49lvevvmymhf7OLHqLoixuGM1mFZXT1ghNbdvP2WxSZORR0/ep++PvH3zliarU48xImSsE69OC7ybWWYw+fr6C6a2xTSL+hnjeEDc5GuLwobIF5/+jO98kqoRqRcEe6z6F61aTNs88NwMNKYl5De4lBKlDaponnwy6FEF9BhnokgTKhmKf4rHqOZBcHWK7oxlmhI98+xR+eZvG41C4fL3dEBrNP0402UDp0BMxs0mbYyT3YO39VFxLulpNpls2PczyJPg7DhG2ralaTNzdhhROkJwTJlAGLxHP/subRYJJs+Mk/u/EAppFpV74uaRkYgpaQKcIRqLj7JWj8QElcqaNpWEbkX4pkRiRRe+UEi5E3VzL/9G1P+bfEdUPMUzeJ+c5Ush8E3XtzdA9h7vfQJcxIN4SS/wJ9A9Z8MKvA9sskPXcrlgmi232Q391YsvePPyCp9HnKv1JY2aadpUiYg5IJRkzlOOplFIZZmOB67fprKaeAmrDpNHcIuuYxru2OdpgJ0tiKYSd6Z+YrKh0qUjqdLQUlSLwBQcFk4PjLAY6TC6AF0Co3XdgKROF7EyPa1FhMhimZB9PY8o5TnbLFiep5bieLjn9vaK5cLk406AXCnFY/Q0sqXJ0wLZnBHiPcccP2mWjxGy4enT56xym7daHRlGV20fm9bg+z1NmyYnq03D/fUdqslvQiF49Ow9xhzFMPcH7DQy2z03b9M10KZjmu6q4LEf7ukWS4rasDENQpqTQa/OpjNFwBkNUpk6gdBaVyGccGWzCAyTY7UoIrQ0Qi0cSiUlRF+v2ThPtM0iu5XD7F1yRycmMJu0+fbDni4/VdqolBWc71fnLDHIuqktli3b/YEmTw/btmGaBrrsgK9NS3/cIYSsLcbxcIPUknVM1pHL9SPaxQpXVOPHPXYeHgC7WUbg0vn3vk2K2wf2AjHYRGnP1Qsi4vDIYiLuLT7GSviKUSK1/loMhUDUlgVSi5fiO8tFySDqCUP9RusdYPpuvVvv1q+1vn3l4Xz6LyZZU6W8iuS3UUK3w6yRSvJovWK1OgVVC+HYbRO34dXr1/gQsGPaJTePnhGGW2Te4yQwu4lxTj+fn7VgFP0s2ZxlDU20HA6uZlScn3dcnJ8hs9ju9mbmMBy4zVaHs0uhwKboJmT6PTJC2xaAVCMENBnYaozCqIbyOo3BpV07nxOJwbsJn8eTUknmqa9lmDaKxjRoFXAZwNttb2jMg5SyKJBKVVLSNFoIfaX7G+04u3jMbSYo9YdrTPMIZEeXM2xW6w3DcUcUGRRU5yitOGYZ/+Xlh/h5JuYSedhd4ecJs0gVlcq2dCIEbt6mUe35xSXOuYrnSKEZjn02A4ZxPNK2ywqYxuiyz2b6WimQKFa5vTaSEAJaUVubEFPvPmciWdPKTJ7K9P+QK9zyds3aqsLpcDYipU84Sq48jDJopRiGdC7WmxXCGOacR9xoAzGeQEWtOVuvOO7z+XUjqjFYm9rK1WpN060Zj/c10Eop6HfbE6/DOeLZE7rsA7Mymumg6PM43rke0bToLl2vSCZpSVM1JoJYMq/Sz1fA7GgAACAASURBVDGNkX3GvoSU4HwdVCQvFKpVR6qoEp5RWp/gA5OfanWjZDJRTiZB/4qYh/cW7zQ+Zm+nB36kSa+QBVCzTIniPtBmEMtow2qlsdksZRws12/fEkUWYZ0/4ouvfllDlFujGJytmoaAZLVcMoe5mhAFN7Lb3zFkN63n73/E5eWC1VlyKxPK4F7fVpFV26R0sjn/exEiXSN4dLGoTEElE/nttDl4iO5kyCJyy5YDje000SxkRr5zH8pUgTKtljRaptJ3d53/zT6xULN2ojFdJv5k5EUKopTYrKJVZoFebrh89jEA99cvOexuCGJZzZ6bZsXm4oO0cUFOdVNM2ZtjXGyQsqnhVm3bcOwP+FxGm2aJ1h3WWmxG92+v34AUNeWvbVZEZ7FjOn/LZeJxlHvQ2YDSD+8LyWxdnR4Qk5gyRonOnhWTjSnIOp9x6yJJpJs3ayHSRlOmW3naUJi1PjpEUInIV4x2ZJqgFJDweDzSdW3FDry3aNNWZibWIaTi/FEiF97f32GnoZoZ9/2eru1YbR5Vhm4MSXNSSIzz8R4ZfW1L2tVjlufP0RljmvavEwM0t+nSnOFZ4IsCFLIHqaiakxgddh5Pka3SoJSsJszBWoQOhIrYKaKwRDdXHCWSsvZ0mfpolaY8/9qYh7WpJ0OIbAqTv4SfE6st30WORK7yU8+bsosCkjV3GTC9fv2K6y9f88l/9+8A+OrzT5kmx2KdTvY4eeys6xsqCsGi69jebXnz1WcALFpDPx457g71OMbxSXXz9j4idFOdxaZ5hkiNZrh4tGDTGcxiWcfMdpqQhAr0xpB399ovJ9ewsplIncqXQm7zdkLQnujrIqWbjcebarJDjIgoWOZxrjYGIUK9mFIKYgiotlgHWOaxp10kzOSjT36P7e41129e0x/SNRjsjJCXmEXCmJy1iOmYYg+B+6uUCDeO6e2rdQJPy6Zn5wHrfKJi57vVuiHR7/OD3R93ScRWnMGERsupSt1j5pWHrwF4ot781llma7G+oa2uXzDPtl5nYiKaFfc3RDEvLFOKZAlR6Nfz5MAkVmtxVHekzyuTkDA73GzrZjAOR5R8SArz2OC526brs1p0CXjOX0RpQ/AWGSPrDNbHMOT7ogCTMy5MyIxBDVbguqHeV6Z7TPB9tSGMosEGgfPu5IYuVY6gyONfN+d4yby5qCVeyLop+jATpxmd5QJNY3Be4Lw/RVMolSY0lUYv/kWbRlnvMI936916t36t9e2zasc+m/Ok0qmMFsu82tfZsqRRmiAju22aELStQgrLy9epB3zzy1+w2ZyxvUuj2sl6Ls5WKUwHsINk9DHFNZJKNudh0UWevZfGj4fDwDBYNjmhvmkCN9dv6bNPg5GC4B06gzHdpmO9UJyt0xt8db5hOB5w1te3VNMsCXasMuim1cQg8bGEJo/EIKtGBBxzv0c02eSlbYhRnUaPbqLfb5MBbrXMD3RdV79bDGn0FyqxR6KbBld8M3QkBIfLEvNRGc4ff8zF+fvc3iQ7xPu7O6w9MOY3zvrivVQmV+LUEW9BZx3FNI2poM2VodYGKSOTn6pozfvA4KYq726bJBgrpLyttwiV3tTpwBUu2wKWVfp0SJwNIZIF4MO/4+NJGKdUMlAuUZGNBmnkqTIRHud0zYKRUuN8pGlOEgIXkkapVCLGGIZpRMic/atXHIYj61Ue7SqF0pIS/Xy33bFcdpU3Qgwo3RBjqOZVyrRE72r1raLABwmqTEo8duprpIcgWQSWwPQgDQiDkKf825jtAkPN7Y2ksOxCgkxj1tN95FFK1wkQQqCkJmpVNTVKKRCyfkYIycc32TJ+c0n+t29b5gGZIaMYQu11UzbECURUggzIqFMYtpsZ+pGb7K1xPNyAvGC+SmXzo6fPCW5gzorO+6NL+am5f97d3fLk8XP+ze//hHXGNK5vblh/8RWvXicQ9jhYrLU1EbxdNHz348esz9NNE0l9YnHCakyH3gjmaXog5nLYkC4AQNu0RO+rcbCRiQFaQColSZhI9orQ6gylDTHjBvPcMxzvMbpKEjBaYVqNaRK45qwlxrne/EpprPM4Wy6uRukFZJ/Uye3Yb/doBWePk3bl7PEzhn3P9VUSGs7DLe3qUQVhlwTG0eIyFtMYw+xs1WKMw4RpW9q2oc+EOBdCbiOyz2kfWbWm6nhC9ByPA11TyG0Sbx1RnY6b+CBtHoGWihj9yQdDRAghhReRNiyl4mm0GCD4iMpCOqUkIcKUwdFxtBgjAHMKn7IW60IdjyohMULUzbddLonBcMzet5vzcyIBkT1cNmdgh2O9B0zTJB8XpR7k3QpMs6jfw88zUc1YnX7uFg1S6ZqqGLxFYghZ0xOiJgoJKMqkQZQkvPyZIQBSJRczwIWIFBJXMA4hiVAd8UX0EEGqBqPLODdmvk3hDAm8dzgfmEvG7TdY395JzDmiVPgsFBO5ExJSIMWJK5GM4lLYz2lXFYzjkf4mcQiUt/T7HZcfpzl5CAdu7waubxJ+cRhn5mlX6b5/+j/+IX/w+7+DNGukSjfFk6czP/7Jf89dDkO6vr5lGAa6jGhfXi6x41QNhubZMhy2p7ecVkjVoZWucYfgcdMRkYk4TbNASvCZx8FikSXfpyqLKCrXwXrP7KZKRffDkN86gk6dLrrWqjIFjUnq1BJN6N2Mm/p6nPM8YrqBQDGnASUjh3lkzKzVzfkFqlnz+Glih1rbJybmMmEgu/lItzAcdukz7NwThaHNOMDgJ47HHaZpaDMW40PP7H3FskL0HEZPl2nci1ZinWN8YC0ZXIRQ7guwwdfv4UNAK5lxpDyBkSqZ8BT6dMbTygTCS1DB4TPfR5gWo0SNc5hswPnIYhHq5uFcwoxK6JPpulR95ICseQDTmFrp7bdbFptVlQcoIWjXZyd5vXMYozFS1sme8xHnfZVKINNrtWAN43jAmJaCFsQQ0J2pcZQheKLwIGTFlIjpeSlWDDFMiJhiKtNxpeD4SmcXgnkaMfl6KJ3AZylOEv5ITMTH/BkxBpy3BOfq+fkm6x3m8W69W+/Wr7W+deWhVTJyETkY6ISQx68FzfjoCUSkFyfuR4xM4wGfKdnRe37yB3/An/775Fnxn/6P/8h//vPP2e+zfH7V8Xv/9nf5wz/5YwA+/vgD+uNEpEXKwgRcA5H1J6mN+d73BT64aj839lv2uxuiyJmwxwGVzWYgibLcMCDa9YNy1OEXXTVxkUrQLTZVL6OaBqU6+qxLIQTm4LnNU6SFMWhpa4wCISB9JAaBborJr0Kopn4P3Wics7U9CMGyMIY+y7ldAMEpszT4ASk7pG7wIcdg9jvGuzcpDgA4u/wuPkRivkbjoWOejiyypeCxn1MpnS+hMZrZWaZpJuQ7ZZF7/mO2VAwA4pT5ChIlFWP2DOk2C2QOQ6L+DYHLtgwxxGpWU1sZGZJHb+m/oyeESBGqWxto9GkUDg1KaUwecxstmOaEF7X5uyfKQCDEzPr1Gmk6jMk8mqlHqgVa/3/svUmTJUlyJvapmpn7WyIil9qA7gYGwGCGy8xheKDI3HjgjRShCPnjKUJyOBgA00B3V1VuEfGeuy2qPKia2UteOruqBKdwkRKpyIx8iy9mqp9+S2+VCq6Pn7xSMCa1xDhCwaEFLe/QplidFXy6e0BtbXzuwItjQ4PkglbrMCKOgS2/trcTsOqD7EnxfwNA5zUDG2WgU/XBbkLdDbZaRikbesauiRIZjfINByuaE6HfjyriXJDxuH7R8fOdxAIQIsAiEJ4tCUBoIuPDEBSkZsQKL6Fqa0DNKN6D8/Et/uP//L/gN//qVwCA/+N//wr/8X/8T/jhD4ZfvP32V/jm138zHvT3738Hroq48Bj9tVYRQrQyGMDzdgUoIgYDwo7nCFK4aS7QhLAcTjNIOERc5Q8ABZC3DDU/43x3B6xdt5MRWaEObl6vFct6BPnNu+cNH542fP/OFsVIAffnZZTdiYCH1Rah4GW1ub2H0YeKAKXUMb4krGAVHD0D1lLsmuXYwMDNvJsvyeIanJKfjVjni/P3//B/Iq53UM9SjTFC24LiRKl1WcGePQwAouYgn3MevI4cnBMwqmoFgW4IXow1xkHg2mqGiqL6SrwQA6CR2wKCtRuKG1KdtbxjQRJz7x1ZtdoApfGziIm/OnUkBWATQakV6zL1SEAYRL1WN7SyzRYDDdpmDjIRoVVB9sUmRoZKxe540NmlBqXseHw0nkdpgvtXbyG1YxoNtM50ekKwtIEuDI0BiEeQt9xRzbRaaYpFFfbdtbulh8Vyj3Tqfgxf7KrAYKpdvlmwREykNzQCDSptvoeq4ZM35LIvOX6+qtZ8iAA2tGNy6v9/PHkXSarKEDDlXMBVUHwXOr35Db769jtsrnAVusef/+pv8Ks//yv7fRyQC2O72sPAYgzHmq8D8+C0uFCv7/IABRqiIA5HxOWAxU2Uj0iWpqXzZK/YUPOG5tqVQoRzIhCZriRvuwGkDlI9Xz/iw+Pz0NN8eLri3funcXEe847rvuPgJkbf3SuOp7M9rF1Mx8n4E94/N8kGZN1Y8dVWcfAFq2j1B9dPb1jBVCyoSPo8P0JUxi6ftwuWckU42GSq5gwmHjEVbdtdHj8nK4EJMYQxaWoe9tzvzQgMnMauu0AgM+axFp+2+OmFIjsrGTAd0ADQux5GGpin6lNUQSoDMA0wQDX0CYNYgDVj4irMhJwbZO0CPZ+yDQtMQGobC3pMK0R2cPSJjgTsOiX9BtBGnyICl+sjTucHHE/3IK9It+cPIBUcPNZDJaPljOiAKAKD4xnBoy04LUA4TcyjZrAqlGRskGgNYIL44kAeVNW6c795340YCmWAbuw/OzJhBYzMP2EaVS6gPvESBJkV4h87XjCPl+PleDl+0vELGCC7LTzBM0/6SudmLTds0u4r0HkGJWfcn1ZTugL49d/8a9y/ehjTAiUgF5lZElEtStIZkgEBFAJazpPFjWClV19BVbBfLlid7RliwLKeRl7HoRLSchijLQVwt34Lbjs+eTj2h3zB6e4eyceNj/QIxIx/+Hujlmta8PjpceyMz9cNaU1jpHw+rAAavjnZz3cHRYgJlA4j9JiIENMB3KuA54yUls+iOa1qs6+1RMs97W0O2L6bVhl2iBQIkIox0AmEy37t3RdSvMN1v47+mgOBRJF6rKM2lGpj4mWooxuql8GAlbmsOjgsdp11RAVAFKxD7gEoI9d805ObbD0Q9U0eVdUnd/3eERuL9vgM7lmrPskLARU8OEWRCUu0z5p96rOuC3KbUwrV4LiXl+6iAOJos5clQLTN+6JVi5PwyoVF8PzpHc73X+N0ZxR25ke0mrG78dS6HtDyBdKzmVktbqGzhhePJhm9vWXdWtnVafXebHRGKY8T6dejOlbh5yYewaENr5lSG2Ky1mnEKgQztBp5wt6yKPUYyi87fn5ui4oTfdh7poEyGgCmHaTh8YWHYVArID7hf/pf/zcAwN/+7b+H1mkcQyFBlzkua00geUPwE9vIFqlwI0GuLdtD1cs1NU1HN2xRADEdkZKVmscDYz3eYe9jVxBOyxnHBTg9uwZk27EeT1hjv6ARX68RFw+Z/r/+y3uAGR8eO48j47SkMc58e5/w6ixjzh7QrM+nMBLsVQVhOU7f1NYA8PRxUMGSlvE9e+5Gd63SZsY2vdUA4Er4OQINIdgC17NUWZEOaeiAVBkcaDh4EQUQVwPCHZshUZPydLr0CGSmcZ05TBc1FRl5xv1+KXmOenu/DdKBgzApAk9imdHfJ0WbvAXu9xo7wFhyd5IXIz1BsPmfxRSRUoC6oMx8VRVD6U5iQdcdiCTL1emGwGXfjDbezw0nVBF8+Pgjzr7An89vsG+fRmbKogfwcjK7CpjVA5Ea1gGA0gFNA6iDyURAiCAyU2g7Xw2iPNcXpc8wp9B3hi7hVwKnI6g7jdUdTaLrjZw23wRc6yQ1kgHv9Ccipj978ajSEFoDqwKgMaGwzzkZfgSBQyNz9dSGmhV/9d/8DwCA+4e7z1B54gUhCcRJTHW7gNs2dpigCtFmIdtdeFWvoBbHrpX3AgoBtU9K+IR4XMYOtB4WE711kx2KOBwDDmsynwpYKPPz04bDyU2MHl6BasO//+//LQDg7vSf8c/fP2NxIGzfEu7OKx7ciCaF6tqfzvBjFyFFD2AGQIywrNgeXZMjDUtakfuaJgUhxKGebMRYYgT1n6UCZg+F4nySIAyROkRTUGMbRrf6BwUELIhsb7LnHSGsI6WuwcA41TZutKAMkTAiDETM2Xzcw67E7Q9dZI//TFMHpDdsUiIFs/rC1z+mIjJj6QZNapaWXcQWg7Mqb6qhrHUY94gYV0SEBi+jlop1jWOiE2NCqTu86HU+SBsvSoGxbRuWHtyVTKA27QGb1ULEeHKvmL00nI/3gDi4nK/+ILgSWhnKEeL4HDg5Kazznnxx0GbiS9g/Zxp1muE/NLVEAH8ebE8WAhWdbFiaGpisGNdERIxj4hhcXBIIwVLl/oTF4wXzeDlejpfjJx0/X5Ivpri0HvRGn6Dk3g2+w6Bn2uowrhUxE+PLkztfHVasMQykObjx7YgMRLUWyZfHqoJadoTl7KFMJskH6nCQapIRD6/nGNDn5B0rSKczwHEGChHjcDjgdGC0aq/53XfAj/E9jiebtiQCLo/fA9V2lH/913+N777NuDhbcc+mirw+WxVx3TPyfgF3LUxYoCEgpXX0nSFZ5uvIgA0LQjpAdnsNJkJDRBttofm5jtKeGornbvAo5wO0NcB5H6AFQMD18uzXZANzgvSwpSYQLWPmyUxgARDmdQ28QESnipYVpbUxeSLAIzemYlMx1dVbtsDl7rHZ9UPEESHMKkHi3OVZxPgMnR8RA9juBvtMTfH4tI2/JyLv1PRm6lPhun57j9ZMA1P6eN1yh8ZER639evJrejwuSEscLfQSAoiSfR+vc6ntaCUMqTukQOs2KO21FiQP6fZPh3YzlSQQ1Nv9fr4Z1lJ1prY0q+4nSxt+rTrV3MwFxfkptF/MV6SRSQsA55nMuaxxPMRZvP+C2hYDQc0jEu6ZCXhqGjAs1wzuMmRGbubLpebh9aC1oVEdF8j6f8UYN9ECYP6+/U6D1AxaOs/AwLVO205H06H0JLsYI5hl3OwprRDwCKsKJAgxItx4kh6OD1gOr7F7+HB7focYBMuDSbG37YpYn7F6W7IcGdenC9LaqeQ7lhDHPF81eIKXhRH177pdPtx4lia0midNmS10eS68DbW22S6IpZsRZOAggc0moOM9ISQ0qePBZw5mnYCuZxC0VoYXhPKCEAwQ7UY7gaNpIzpySwwqZZTVJLaJdCZUbWJUfv/71hpiIJRuoBPZAog8D9he0lq8vpiIl+4pduzGdCS9Na1Vcb1cR8JfSmbqwzwtAgMbuNif1FKa6Zm6ZUQrYAkDhG2tIaQDogPr+2Uzgtj4XoolEQ6HBZsD603gQHxvT8kp9r4QECGAxzNRm6BSHS78pqXyzbXzjkhAmCNlghmN94ArFes1+qInjT7bYFNI2PKGKjefiyKgGC0d0KCsaKUO68wvOX6+ATK7A5Fa/zp2QvWV7HbODP0MkCFShNZG4rdoG8AfAEem0+D1h5BRxq4CgMIwG+qvm5YjAtPUhIiAlLAcjduwrAta3cZNktapNQDMOFdUENPdSDdvImiIyNvf2y/JBlrejCS7Q3gEpwXabL7/6fHJdk8P5mFSIE7AWMgYlsvC4wEoeYPWOox5RAWt5XGzArBJ08CUBEAdLmAqNrFowNhtVRtCJPTEAqu+dNyYzKao7ItJhGDbZXJiXPjFvNwY8DIIikIdRwHCsg7ujtQyzi1ghmIhBPM8gTNpmUYMZAoEsJr+pX9uMfWojpcxsC85u5WRUco0vMm7YC9l4GsxmoqKWcG+4CgzQDqqWjMg0jGZCmyOZq1jdMQoeRuG00z2HTt2Y1V0RYgr1qN7w1wzci5jUsK8oGlEHMmBGc2FgH7qQDq9TVSrL3Y6AGZ2BXL3iilYoJSm5sa5QL2CqiIQacN7JsQE5oAA3MRLqhHHho5FocKjM/jS4xdrW3pGZk+KFxEjinEnQZGXKVNuDJ8ETBpyP+md0LWAeAEFR46ZETiiOmIOqSAE27XGbpsg1W4uwHaY5XhC7p75IYNJQX4BT+cH1P3qwBWQlggiwuHu7QAaW1PU7RHFKe4ZRxzvXuPgeYdlS7h7AD65AVF8vuCQCLuzE9fVnON7AlotFZoUS0pjcZVWHAhzU9x8gbY22q3gD11/8M1Be6KG5jgFH/dNiYBSGGBnztkIdH669+fdU9Z98eCIGBpq6+/RgO4aP1qGZPJw/zmQmdd0d+LmLMpxE/ou12/2Hk3aiWUhJKgCHOJ4+JmbjUn9JQLE69ZedgcADbtf47yLTVhuQNsxneiTJ7VYirFAgdBqHQB9igFMmLlDpFjWOK65YD50dh68etSG5IxdOjByyeNBP+BgGT7+WSITKIhXAfARtoz7jKyftvfz69yYQa0O6kFtGyjKVHRHBisNABtiVUqrfQMwkh8zRous5JPLTmdo5MDsLavzjx8vgOnL8XK8HD/p+PmYh5hUmoP1qZ0Wa/P7MFZQFcuJYAqjEidi854M4w+s6ujAIi9ASIi+ssuyQ9sJwTNCrKxPAKZHCJEaYFjcfyIrBAy3jcSCs2XJdpMdTojrXHEPxxUpLRC52aGv71Hzjhas9TmuCW9fv0LNHUw74/n5Ga2ZxiEEhTJw9HL2dFywl4btJn9mCQtAcdC+pWbE5YDNLeuIGRCeXAYiEMURrhRDtJQ67n4Vz1BShBCHD6ft1mGEURXNZhbcLQVzNtp2nKV75GmYI2Iydo4RycHGGBezcvQZcuMdWjBJY85qkI5yNEWtbVSVMSQwxKwaYWW5CBApovi5CNFaiGkOJAiJp57GYz3K3tP0zJRw9P1iXBcmmlxBKFppIyPX7sZZ9eYiOK6WCwsYXyJnwRJ74qGNPy+PTgx03Apt8MawrgfX2fSRcQVLRXJdFQdCimFgX40ZUhW59KrM+CkEhfg1M++TND1L4dggd9q8mzmN4l3RavYcXAOildiIdt2MiiNU65ADqBt3IfDUxHzB8fPjJon9Pyv7Bv+tkTXVXRSkQKDgisl+o5l34lBTkl3Ujmk0yZ/5f6T1HiqK4gtDBKEWI5XRQP8ZGhdQdBNfFsQl4t4T5UQKcs5InevAy2fnLC1Hb6UqWu7q1Cd8eCxjYfz6L36NEDHQ6toq8n5BchxgY8LhuOB0tECm1hQxFyzuZlZKgdCC0oDsOp0QAQSaSeYpYdsvc2EFoUkbD1RaI0hlPOjNiVaiMtB8kIGincUaSkHbLw48A+tq37OD3LkWzCggB59VEfiA47FjSAVLCuNz1BLs/MPOVZViWEmzz9C0Aa5VAQz/ocgIqd96xqBkwligWq24vYUtR4cHvnXZdpRSh3CuC/M6g5KSpQJ2UZj9oS0utZfzZFhPpxztpaGJYBmYhhgPyVu4NUS0vOHg3rfmM7pYrKW3lnGJWNfzuD+VGlSuUH+QOb42JjB3o2ZbhLrRMyRD2CaBDV3jxGAN4xlRbebcpxPzyKg3Tm92/rvXKgVYmmPZ0HrANgdwmBuTdv4VZIrnvuD4BSqPCpUAcPA+sk9XrN+a4zMfy4DHKJDYuaA0FxPF7FMNNW7DbAWIQLiCnFgVNEHk2a33/WYt1cCgoUi2QJzqJ3e7PCKEiMPBKMUhMJZ0nOwYNkp4zhd8+mB2iL//4T3yLvjLv/pLAMDhcELdHoep7369gG5W8iWtOB7vx4N/vVyQjhXFjYZLbWgakPeMkg0nOd29xnZ5HkK5tm8QyYguzrNqoiHdmDA3tLEjMSUjdVFAp02qFqNX+6K2HFaU/IzqQC7BpgdTIUsAWcwiAJS9uu2/IPa0PE0AMRa9jvfdCxD7xEwaYlqwu2S/lYwYpsEusVlWdmynVQOFOfAcQ5OaQdANBhZjGBXTda+DLAUYKKu3JlOkaD796wFh7O7gt9WMaJt4TySUJqMyMSd7HiPSXLJVBmOTis7ypTk9KQawdrMqMhBr/JsYFwReB+ahPi5NoT+wwXb/wHOszwwpjK5E5yVCWxm2hKrm1JZ9SkIgJKaxMJRqMSStxZvFQqcDPbx78EjQP8UI+QXzeDlejpfjJx0/f1QL4xZIK8716FOPCOJp4KI+ZbE+vVceauNEmm1LL7H7zxwCgo9qm8cIRt+1JFa0sBlno+MibbPX8dFsgLVUz4+mUwlLwOH0gPOdEb7WNQKtInQ6735BqxlPzx/xdHWzFCR89dUDHs5m36etoLUy8lmhBVXy0Kmkwx1iPI1YhcMpQbVhYw9RbhZFKSLDe4PDGflyRfSqYS8fkdYz9IbAFcKthsRo4F3DU1sDh9Wp333mX0EURuZKSgtCTCjdRIdswlNK/33Fsgb05rP334EJHLsnafIIwz75aGi8jp6bDgwpu5tiw0eGs59lBihEELnnBRoik5HZWr93gs8x+31iO/7IJmkCaeo+pfarSkDvQVQUVcz/o3uTBCKkJQxz4hgCAk/NiIk7dXAfzGKEICMbpgcreVUHRYhmrdk/p5LFP0T3PeUQ3YzY74uUsB5f4+otXc47rvtlELwOywJm+6xL6HT+hiwyIkDPd69AidFTdmuraE0HtR8qUFb0CxJCwvGQENKK7G04teb36iQDSu8K/oR64hcIurYZvDogQ9r7lN6+9CG2dSsEGgxIqC0OXT+QYgKFaDcS4MG78YYbwgghDZUiWjWvg3YzInZzml7Pf/z4PfL1gjffWctxPL/G/as3uPPFI1+fEOJxaF9a2fD4+BE//PAjnp6MiXk6nfH1N1+NUeB+vRqBy79jK1dwa6DFF6zja5Dk4dOwpIhaM2KXNIj1ujVWHNxUZtsbOEXIpZsmR4SUkD0RDmO8PC+ugXPe4jVLSBOq869e7AAAIABJREFUI4XO7o02HuS8b2iCGw7BWOv93Jm3SvIFPCZjk8ZlwXJw0I9sPDy1FxtAPNLja1FULUhLZ11GX9Ds70MwILqXxymwnUeWQYgTIm83+yJmG01zI55WxUFRP58h2urRwTIlE72FMZmFqLXRHYMTEaREwxi7wZy9ZiaQtYATiA+2UY62x5PuYpzOYYFtAfEWLnFCSiuit9lsjDuoJ+HtWzZdkPRFsEAlQMiuPQAH/58hDs7nzcyrOgieS0GpbebiDKMk/x5NzON0aHdsk+AQBu/D2KWdu/IviHmI2H/m/jQZe36PDRwALiJSwpD9UjOp9DqCjhaQNqgDO6QRUuWzhYiIB7En6yMUAhHC5g9drRWsbUx0jseIr775S9x/ZSbAcT1iXSMurpgNYYG2NghdHz6+ww+/+y2UF/z6N78GAHz7Z38BlYq82epfyhUQHS7kuRYgHhEOBsqGdETZMnjtQdgJMSR0GFD3AgoFaV1QmwG3lB8NG/AdeT3fQcokHIUYrbm/YUQG2JTGzq6xQ62v96rAUfZuHKPGvhoYU2tORx4PhC3Epb9nYsSUEJYVi4+rApt7Vjr45yaCSoGEPmULsN3Zr3ERNDWhm1/Ez2INORirU5Qg3vsbPNgGN4SJwXAjZfTnnwZr1e4VQl8qBEARRaLJWhUx9Xenw2s3+uEuyTdH+CHkFEKMc0rEIcJsr/wzBnYVbhjsZECMJdqrw5AANrtDe5FkA4F+brQhKMD9+ghwuRgmNKZRIULVzJkBM6muZcPi1g3sLgF9MRZdQJAbZzdBk4aIgOgSjlI2aJt8/1ZtiCFy41D/BccL5vFyvBwvx086foHKw5hqzAkQ7taKxg5UnaNaN0O+LY2YgfPxhJPvYgxBa/uUBROj1jxqz26Io4MoEhDTCSCFklUBMTLuH94ieZktCNguGx4/GQcjLlc8MeHVvb1nbRUtV3xyKfx2+QHf/tlv8NU3fznKuvfv3iNyHlVBaw2QiuKciyaM5fjNiA2EFsQ4zYwBRsGG4B6nlZqPUI9gl8MnJuzaED0+knnBtZQx0rSqIozdWFpDCGFkmygptG2ItM6oR7WQ4x4nUEVR62RJ2iW5sTJkRi0NzB3PYIRoQq/+W2FdINDPfFtE2rD259ywY067ApvXxvh9KKTJ6DCELUArUhgUd1WxKUPzEacnPYvraQIZr0hu21++nRo5bwF0QwtwUWavYrXZNxoVkBp/xV8zdIp8v6FBoIAxAVINWJcDWisIPvZnnh4u9k8CQoxg7tMXm4j1kfTp/GCv5xYKkjM073je9zGp45gs6wWzAhVp2C4fAADH0yscjg+f6WXs63f8iBG85Y2px7Y+oe0XRMeDqto0jTzS9EuPXwDzsP+aCFqYPSTgpZR/KYL9b9NpBHM4HPHq4RVWf9CJMrQ0wHkIqgGBBaLTabvKFLXF9ABQQdNtpCepAu/ePyGmLvC5AtKGN+hWNrx6eMDuuEApFzx9ejS9C4C7V2+Rjm/xj7/9LT78aMl2y0r47ptXQzOS8wZoGY7sYX0NXs7joZQqiGEZQLCKOUjRGFeyzfK1IHoLZvgOjdEsAIQUoWrnouYNKcbhjMWBbMHQaWIUGCNkGQA4nVDr1UPI/VJoG5m5quZ4P5zjKVhKnbcgBAE8l6RzEdJyciKSp88vC5hpGPFUqaAShi8q1JLfe1ndRCA5jxK6igF8TAHknAryxaO7WKRoNIDs+g3zRsHwI+1Y31yeGDEYff9zsxyd353IWrje17Bxk7rmkheGimUKAwbWpzA1PtIaNC5YDssAZYmjtSk36l4aWbOwsXirAHetlhkyd69WzQXKDE5TYtAUaEo4dG3WskDrjtw3rlqQyj6EcgJ1Wn9fnS0wqhGP5ybwgn2/zmCoEFBqhYbp+fElx88niTEbx0MBkjZ2KNNa6BSxifatboi/zscjTud7sPeMLe8GPvWdsxnCPeIFVH22PvtBOEHr8ske9MvliiaE473xONZ1MaKZr8Tn4wk1X3F5NjD08eMHhHjA26++sc+gCf/wX/5fPD1/HC7YX69vPSHOV+qS8fT4Aw4eIL2sb6HgoUhclhWt7QMAjNEk3v2uCjGBRCB1H+eCmJ0p6AsQKZb1MMDjEBMUGAtBoGj8lr6zKqFmWH/rN1Ldr5C2j38jHW/ouglV1KZjgVdUcJg4gXFuEpbD3TjnISbwchhmSgRFyRk598DugCXFUREBBFAcHA3JO2KamhxWBZid2NYxj2CVQo9HjBGt1s/0KpHCwAVaqQCHG0ElI8CqjG6HyNGnKZiVhvZ7EgYErwsPtieI3Y3MF80UjQnb8Q0V7LkgrQekGyUuwmT0hmjsw7FAqSKQovgNXpoAbRsRCHXPUFLbTL1qLbWiIaB/LC0NKSxwrhogDTVfoW1GeKjSuN8h2UhsRRAP3TX/iFplONqnsPhiTTd16B8/XjCPl+PleDl+0vEL+Hl4Lwk1M1z/cwr0Gb6hZKYwpJPZdnc+YklhUG2tHbjlhmQAcwzFIYAoQmVKiQGnu/cdxmgdo6VotSBEwsPrt/5PKqSFoWY9nd+iCPBff2th2+X6iG2/Iu/PiI436FdvUGsZ9n5SnsFESKdv/bse8Hx5msYzAHKVEdsoWtBaHRETRO66GROoRxAE8w/t4sjIAYQVNVgbEtMKVRm7mqpAmoyQ6povqDWbLsQ1+K1kCHRk2AQ2TGpQ2qvxcvom1UQQIo3pFrthUVrPo1znuOLAaZTN0hoaCtTbg+V8jxAewNI1Nxm1VGTnxMRoOo2ufQkqYF4BDiMzF+Q9SMeMOCDn50nNjzaB6CzLGE0K0dsvhoKjjVZ7ZEEMBAjdKLqz4QqjyyZw5PFAGI8jDUkCpwRUjJycJa7Y9yvyXnByc23Is2Uy96qqU+B7C9KKRXZEHzkXU6P30fredqhTGWZ1HaBNhxF2loqwLjPuEwSooPr55Wb0ho5zmY2DAlIgrRtjL2bD0HGpYBYGdMOG/ZLjFyCJeXdFAuj0hiD0lcRuqtIaVAVpifj6rZX733zztWXIdqMTYjTQ4GwEXgAKKI5HmLBpGaW8NvHaOqINjThj2zOCE4aW4yscjyccjjNA+v2HK65+8z8/fURrZTi2t1JBKSHEhMU9TGMMaDpHntZu3EFh+MS2bdi2K+7u7PevlwwOPABXac1McHp7Vm1RBPPU1MQVWwhA6OfCyt846OgJpbYb9+9mI+PuxJ0WsN8octO3aptjUuN4TEp7E8MjRqlK1v70z5mWk5H2CMPNrYlxdXo7mssOEcJyMKA3uiNadUc0dbJXGG8hlh7f6dVrNBCwKUS6WTbM18U3HnMIn+5lBo7yMEwmZhBPSb+0AiZyb9tevvd2xRckEft9/1ylChR1mBNLI/eZ7S5ggnW9H1YPDYy4LKglo4qPsdezEclu/EwIGOPPqArSiur40PXjJ5dezHEwcUCtguYhWwZgKhB7m0hoe0PoRLRoAWfiznmiZBhHl4DQAlUz0CK3CghElvI4bBECiAJuHcy+5PjFVLXkaPd8azWyjj9wuRakyPj67Vv8xW+MsPXq1RsEAvarcTRysUlL7OxFVJ+s9AvPEClTiaq2YKWw4uj9nKrgGE6jemnScL1seHy04Otan7E9PyL7jr/njBAXqHTfDBM4NQ03qsNmYJ3/3BRoLSL1qIUnU7T2m6TkivVwHMh8k+q7omMNIhAxVecYHDEBCCO8h0MEEw+CESlB5IJGHZRVpDh1EiY+M8PjzvOoTX0n6UQyx6BuDJua8EDyIxNCwiDDxXRAiAfs1ysOLoyrJRtY6wtUKztao4ElqBi2kJ3JaWFcPPgoTDaVCM6Yc/kHtu06IjlABOUI6i7vWsGBB3NzREUMxy73EOlGP6TG1GQFy7wjiWns0GZef7PZEaFKA4fb6cys7LqrSF/M9z0bYBtoMI1PxzurCP1eIj5Ypaw9SHzHkhYUv98//OGfsD68wfn+3t8hgYggaKNyrrUixDiAW0u4B8Tvk7gsJi4d+jBYUIUzl4kjWFev7m8mMCEgduyLrFZqrX628fyx4wXzeDlejpfjJx2/COYhKka5vkGnoYymGHJlkoq7w2u8ffU1Fp+Lt6bI9Yp87QE1uzlLdXac62bGCifu9DTAa2slFIQifSITILVg322akrcLtusz1oNPRo4HxMMR+bmPNAn7dkXrIVCnB6gGNCnmoAXTQRjWcvF/ExDX+xFs/fHTB3z37Xe4XGy3uF4vWA+H6ZtRK+RmJAq1/hI3wUVChLQsg8NiGh5GdNyEOaCUMvUccnWG46zKzNFNUZwPkZKpSKdfhE2rWvXpAMzvstviMZntYHecYk4I6YhaG7pjXa0ZiQ/o+w6RIu+PY+yXeUUrZWIkS4CiDVYwYgEvpznlgEIlI3AYu6W0BqEG6qU3AijokOR3ClH025fJ2jyMtkaHJkd5tj6EmZkCEq8MvXSP7Hk0dnCKXnWMuat5rjh1n90fNqX5CFlIOI9/Iuroh58bwY5SA4LLGAoKpGQsPilJyUK61zCNmavn0narTooBKSY0n+yFQIjHEyicbt4zItJs8RheN/XrHKxdbr33rM0Mw0UHhPAlxy8mjOvox/SSCGaJ1vM7gmkHHp8+oqOCx+MBS5r2coaPELyjwHFZoVLQnDoOf4cezKNwgVpuI6z5+vzelBf+kmW/Wn/bffLUDFR09NNiPAS/CUQUHCJO5zPOngQmIDAvCA6W7U2RKOLjRxsPn893qK3hevV8mSpIaRn0daYEpW0KSciEZq3mcUGJosnefeGs4mPY4aEZrETtWba1QLUgkmfX7juqsHmH+Kg2RfY0vmnfVytQcgfTekj11Lok5pu8XEEiBsfjMCFK68GuX+dnkQHeveXQ0iBFEOKdv+cCEkDUrs9yPCIeXo3Wk7Sg5moGx34NKjNQCazd5Le5uY+3QkT2PHbylTTr17txT2nOZ+EBxgfPn+kh0yafmLlCKi7IG4REBlEYRD+F+YoWx2pCCNBqi+IkVtnod8ra3WOkU+DLBlRCPBl4v54eoBzGyJQ5Yl0WJJqvSVcy7Yovtsvh3oLc6cnfkUCIA5tRqYYvjfvKWmHjrPRFyjxYSm/z2gZ2IuC0lf7jxy9ggGwfhDtb7KafZvcr8N9EaxUfP77Ds4fkvHn7FR4ezjh4L0skKLXhsPTFQd1v0cEgAVI6ot+5rTWUUrHtV+x+c+frE1QTSvd8rBWBlwF2JuMGDXVlaw0MnonhoboD2ILrxRaDr96ckeIyfFDjcod3P/6IzcV0r169xdPTEx4/2fd69fo1wITdXbUXFjOplY55EFKMYJpu6CEmSFuGFQ+jIsYDYvLvXgqW9YjshkIhVYhiRnGSm+UwI3aWbzNsZezYqii7TPHT2Gm7sMtAwunIlVFzwYEDGPag5n1DWE7DIY7CivXu6wGyUmu4XC/DzazuF2OperD44XRvoF/rCk9CyxlhWeeu3wQZO8gXRqkZ0DYmHUay0ynsEjaild97MdmmY57HXmmoRyR0azFnU4axUBaI6iTthQRRGlMNJmPf9viCJU2NSsdBOug3rGGI0WrF1q9x2dBKHNyT9fwKDQFp9Qo3JqgSmuyDGxKXFRoVyl19vdim0n9mq9RqV0ozjckmACgEQew+2TvBMLNFmfr5q5Sg0ReOLyeY/vzFwwxEIoDPSTVgQ+ZDmCVxrXaBsiPD8dMnnNYE7TbyHAGqN1aGhBgi6jAJrtipQTsgWBtqaSg1I/tEZi8V0nYUVy6KCLAI1uWVf94jRKYrWKvFbiJnPFJkix+oV7z95m8BGElp3zewVzzXLePTp/f481/9awBGTMv7M5qPch8e3mC7bqjePnBS5CbDbJdg0wIzRfaHkCNCOkPRM1Yqgme3AEaYS4d7KHzypIpaZcQnUggICOA6CVlwUVQH02ox5L6b7ggUgcNwCA9sJW8f7Zo7VcN+fcLx/OCfoyJvG5K706/LAXSgsfOFuOL4umDbbXpV90cwltEucIwIBLRM8zOEAObTrChbM8MbzHgBThZz2c+VEk/zHxVoxdhtGVb9GWjqD7ZUMHjEYyIwpDZjhaIbOTeMdowDSGm0Y8u6IqKi7H2qERB5MVXs8DY05nBffFttNnXze7M7o/dR7t35HrU1HNY+QQO0XpH362hTGDYW1tjH/urXsW+w9hm78xgpQ4SHyxpga5qlxHW2tyAJIaRecfqolm+rpj9+vACmL8fL8XL8pOMXI4l1EAs3c2K9Hd2qAYdBZPD2ny+P2J4jDqt9jOVwAsdlpoh7CE7HdUrJQK2jssp5R6k7as5jlxchlL0O7QXcDGj4OMAqn+75aCHdGCPP8vwJxIS/+bf/AW++/g4AsF9/QC0bVrfn+/jhB7x5+xs8PfWEuAtKvuDOKfHH4xG/+90/4eHBSvVWd+zXbVZhIaKK5fwO79UWnDjWecf8eRtICRwXM06G0Rb27XloMWJkNA0AM8RDnPZqc/uSe24ImanxTRCX6MR/lCJuGNtopUDKBpKCfDX6+fH8FYCpbQnrCTGkGVnQGkJacTrb5yzLGbJfBg0/cEBreXAMAEFYDlb5dTPn7WpYUBfoxQhGgrZuPxBhgdD9JSpEywDaSQGOprnpdj/2u3yDr7GNaftoHIvFF9z4izJj2GoWIQOv924AVb09wCSaUXQeTOebWIDZID2mLj/o+MURFkY8W4xaK5pn2vbPSZSGl2p1icZgTpp57QCkiYyQ2b8lQdxmcIKhMbID4zT+jRljT07Klxw/X9tiywYAQRWeUYekNoEZ5isVJAJ4QFQ/RMoIaw7M9vvjQbcFaRjEkqCWy9AwlKwGANYKcXAtHV/h8vg4uAtMwftIX1xKQ25llHBMCRwCqpvWhhTxF3/77/Dw5lv88IMBosfFCF67l+Kv33yDSwY+vvu9ncQYUCXjq6+Mcfru3Tu8+/4PeLjvxLQKhGA6Elhiu0r2C+U3fIhAE7RyA26WMsVLKUBFQL54HM4PKPsjsn/PXNjAydSGaU4M7h7e8QkYKWyQCMUW094ftybOZpgszJIfkfYzlFyR+fwR5ze/gvpFzDmDKYwFn8jKaPZSPoYj6DBvZlOXrOhJVEKEuB4QwmHmiMQG4sNNhGIEMyFf/VVUHWPpCyvbl7nZuAhGuAr9PpAGRZ1EMm1+n/VzkwCug1TGHNw7pr+etQqri0pKaabAZR7TKVEyLlK54SFJm0ZIxGi1DbOgJgFFEnIHLkUAPbleqT/Y6oLSvsDo4Fb1a2otlp8aMZyRxx+oe+7o4IrEGJ2t3dsWHgLJP8EL6JdzT1dRBBYMthwRhGYsIQdb6UMIo88/Loy7Y7IYP3Rj4IKjmwNJM3AsuZS4xiv2veHaR7t7QxFGLnWQavbrs2EiA7XyTFsHSEkKpLYbabXtvKd76+n/zX/7H3C8+xb/9Nu/GwvQYbkz+X2nm5eCH//5P80dujK+/vbXo/f9wz/8Z4uR9L/fvTKqPjJdVjOSUYRBOxaN4Bgg7bmfWKR1SspLvkBrHVXCcrhHe/gaef9H+5pFEBajU/O4AXZExcB3JAuWBGR3EFcoUuCxVFhOKgZRiIggtSBf32NxprAcA67PP+L86s8AAJEEueSBgcTeP3c1NTEUM8aRiaFUUcnzcnkxm76bu9aueYTyTM8z6n0XpdnrzigBhSJ99u/hSt5wM/mAxjGtqi1D9Ha6YAPNTkxjTm4IPVmsrbXBggWMMtCkTXMrVeAmARGtQbWAHazZAaTDAez34rXocGCzF4h+vmiGZCnMF7lD2x401XGqEfY11goxhXm4OZ+dLt+JeSECgjHGVnsIvND98tXjBfN4OV6Ol+MnHb9A5WF9eYzRd48blBdGsOq/xmQr/erW9PfHhGVdhuGNghEQ0fUwTQSsM8yn1oacCzbnU2x7xrbvyHlH9lgDqdm8M4Ys2uIFsvf9HIxo1neLuEa8evMV/vKv/zt7z6r4x7/7v6GQYRXw/PgJp7szumzq6eNvAZ3TlOPd13j77W/wwx+sjblen3C6O6OUacJju7m3W2UHxMh1fUKDYMSrTqArebeRZJ9SCEF0ovBNgOPDd6OqeHr/e6AJIo5I0anN5QrOzzfWnhtUGKW3lqoIbAnpgF0f1Tro35YFW6F1Q93e2e/Eb4FUsX/6nZ2/V98hJh7W/02sZO5hScwWs0B9AqFd+t0JXla5itKoToh20JImSUwUHBKKb3U9zKmbZbdWEOIcQTOZiTPzreeHGf10voRlutTh50pIaJLB3P1Gk8VGdtJeSMZbku4PS2CO0JuYD0KzCVqneGs1Ul3Py4WY1d/wvJmTF3tJi5uwSsDbbNgEZea26CTFoVfO7YYSoSCWyRMhQgyrPaYzj9MxEPv/Kpbbq6w3otM/fvz8US3ZfyFE8xFA98usUMZ0YnJNBccw5uLresC6HoEeehxXMKeRsXK5XiBtEpBytYCd4qPefduwXZ+R9zKJgGEBBRrMzBAXKy37yQQhcMDi4ObD66/w7dd/hk/vzJnp8fkRISWQ8tDLLOuK7XKFoitcD+B4HF4ar7/+c+Sc8fvfmX6GiLAuh3GTkI/Teo9ZSkbwXrnzIWJgpOUI6aPX5kSsnvUbXLXsRj0hMLZ9Qzh8bZ/hzx+wP72D5jL8WPPGWGJCjNYixMio+wwSL0EnZAXHl1obNztDoFJAOpXM7foejRjp3vxanz/+gNPD2+EQXvcrGIraAdKQzMzZNxGBK5qdEQnNULU/02H6ROB4HC2Fij2U3VyJ/XwMr1BpiOkMSF/ABCGmz8RfFuQ1w7ATR8/96bSABCltgLY2UJ8eLBxMd1I6i9WxBeUbPKIBUBlq3wALWZ+O7dkc6boyupGf/N6S9Ace496CKPTGxxduND60RGpntP81u/P8WJIooorl+PV2tlUn0PUcXzKsJFIYvKMvOX7+tAUd/BVHevsDYyBWxxbg7LVWFRrdXXoJQEyDrNI9DLvQ6Icf/hn75Xl2pcyA0Jhh7/mKnIvR473nDesJIaRB/iEC0Oq4oOCI+7t7vHltGEdc7/DDhyc8P5pNIYeEoIzT3etBhPrd775HChuOrrIFLeB4N8Rdd/df4fvv/3nY6B0ORxAveL545GXNuO77qMJCE4ACDhFj56u1QknHjpI8enIEG3GAIAxsgVkRSgZ6+HbOCIc34KVCqy1yogBSGyFZACNyBtxOcSvFd8re1yvqDe5owwibFhB3k5yGsr0fgr50eo3H998jrPfj/ErL4GpVQYqKGisW/9xEFhvQ4xBBizuNJUh35AoBKS4DD9JgOXbDkUsJ1DLg5EGK7vAljnvUK5Z0Rgw8Hrrask0k/HdErPbpWJkCCBonFmY5IAOLYTfLGZhsCH7Pz6iK2orhHo6bCM0YVsBeinSyyARwt387WmsuyefxHPk/GqC3ufN5tdHPBeZn0GY19QRxHaQmutlA2aqMAQuapaPSzTn+guMF83g5Xo6X4ycdv8Cotk9YrCvr2D2xzZXHSi4NpcF8JU+WmbKkhBAOk8ugFfte8fjR+usff/f/4Pe//fthfHt//xWW86shumo4AClZJGBnJ3KAhgDp/TMaiAlfPVil8frN1xAkXBw3eXr3A5SAw9n0BssSAUS8e/cB22blvkLw+tURyn3Xsv7x1WtrGR6fnrFdtxvGo+1QXRTY3Hek7wa1VYs29GxZe9GGVq5DeLWkBenA2P0zVFELS/J5vsUIrAhH32GYkfcriiiWZOf3cAZK3sBpBmnldIWw0ehDYTS5CVNSIIjMHYrgkvV6E1UoZji0W5uXWwEfX6FtH/zvI2JcAfdWFTCY1vGaCGriLe1s0BWiO5RD14+B2MLLcTMpCWGGPVdRECcoPBS8l0Gj4yA0JsTlALrJdFXJ415jFhDSmPw1KXYn93MBw/Fm5GVEIx15KqYL6tT/2UKIFKTbloN03K/QhibZ2xWglobWboWfbrlJOuUSlmsyrQyJh62k/WjtmNZZWYPDxFLIzg+xR6PAxuM+W/LPRT5ZihhuVF9w/Hxti7onJrnCs38eVZRSbjJDTBUZKIzsjJRWhJDGTdNaxXW74KNnxH56/wOePv6A/dluzOvHP+D+m79COruDF68AOdlmuI9VK7f9ihzWM87HdTx0P75/wuPj88QaYsCyHoYO5fHxGdv1ar4eHWwToOxACvYeW844ne+Gv8T3f/geTx8/DH3BuqwYJwJAzhUhrAPr+fjxChGgrMvQDJM0hJTGCA4gUIjDkb0142N0fQwTg8IyqOTMDctKyNtlfI4YEkAF0dPwAidQ+DSASfOI1c8WOWYeICwqzFcj8MCyuhBSe7IfFUj+AIq2YBGJtRuuSyEhoClqdc2I+2TM1PcEUnOw72ClSDQqf19spYGFIW6+pFCAG9CzYhCsXeqlPRicTNbQVcikCm5XUP+uKgAnxN4ytwzoNsDlIGr3TK/tA4M1IURXhLvehkMYzmzqYGj1F1mCu6lrJ7fZwtmkLyaCgEkb6KpmoI0WzizbMXgdaj3L/FydljDTqUA0uVSqZFPqm7bPnPcmAbFUteuhPKCDLzl+PuZB6v2ZS6b9Q+/7Zg5Q3ZTWDWVjAM4nuwnSstouUbthUMb1+ojnJ1sstusFWjbQANIaSm4Da+uEtJzzQKdDDBbx55jHnhuenj4NGzyCgHROgVgD9m1HqaZSlNoQAkGqTttBUXzMGcz2IKf1iLQc8fjRdvBP7y2VroPZx9OdvaYDu09Pn7Aux2G5f71csR4OKBVDzyH5grg8DMCqVoFQGMzBtB5R8zaYnRoIIa6ggVeY2jitp7F7EgghzsT5eLizHWc4i6mR5vzc1FbBYcXSd+NWnYHLN7wNDwgaN6JL+RxnIVZQPI8JjkqwCUt3Pm+7uVx1M+nuHC5yY75gO7oOMDOgNl8kYABlIICDLyYKCK3wAhWJG0QJMR7RxMVg3BDSMoySSBgIK5rvtJGD3UOdoxHMpb+NHR8IiKCPZI+xAAAgAElEQVToD7FrhogCQk9ii9EtBvoCRSCOiNSjAjeEFFDR7z2PkBhiax7hS108JzA28YhWqKb0ityvh+lsujM6kbGGx0DHA7boRizXxZeTEGe4yQ12/kXHC+bxcrwcL8dPOn4BPw+zzQ8UgGaoNmC7FqtM78oYQQDuTwecz1ZG2+RAB3LcmiCXaeRTtye0chMCxYvnn9zEFcRgmTFtsijLXsaITl21GbuGRAkibeZTtM1NZP1zagX7KtyjFIgjpFbsxV7zdH9GKRlPH21CU67PkFaxeHhVTAv2uo+MldYySkuD99FKRQkCfc44nzwoii5o9TrHeCIA8wjgFjwDrc0dqTWUKlhWz7xhsulMCMPcR1oFL0do966MK/jAw8oQTU1ZuXcfjCsUafh8BmleeYQ5IRDDatC9VOEl9WCDFkh5AkWbvhSJoLoD7sXR1HCQ20zUODJefWcMwSKX+3dV2FSht8SOgXS9h6p5xI5wJSSoZuTGgJ78u2xAjDinjnFkIC0Iyd6zlGJkaVe2SxPTt3g1adMhnthD2SzMneLQarF7w/TKrtbdfh5ZzCcgPiCre9mSja47FtHfVxSjxVC1CnLoj0S9GurvadVGn870Dqa7L5rtYwBoMkqaVzbtBseKMd52Ml90/AKhT3YCRcRIML00IiP9TBqtfbL1sAz+RIirUYQ7SCM7ynbF7vTznC2w6XN3Ix432eJfuLY2DVnceTr4yY0hADI/lzRLChs/q528/nCkxfJRSt7Qun5ABSAexKY9F1yf3g/cRFTQVHB0IPhyuSAENv4JgFKAZTWymX3vYJkqlZGWDh4fUeuOsNhDV5sgUTMzGQBECzhWSPcG5QDNO3bXwqRwAIUKbXVmqrA5VXWgtsFMjVN3BOdsN1uX04eAvVbMjJbD8FIZIio1ox14aa58Z3qaUXtHQNoAVEErhI+DeNazcbvwi0AosEzXKTCz0jv4ezZVT6lzLCFFlCYDOyCQj599A4H5vohWVLWWQcMdjnEDoRtLucNWtzwgQtYGTj2DN0NlCvjsPg7wDhoxJHBMUAWqi1MCRygqOt5ltPtqZDM45nFj1t2p7Z1AZ0HctuF1fZGqg6eTuDE0Sf1zqQdr9YPDpN3bdevnzlsfaRBguPkz2QYbwvov654u0pxoo3bOxlzcXMFGSppzek6HFakn1gwbfMcu9iu2pw+4emh1KxmiU8zERhn8LNKvlALonFpok2EiDNj6bCh4V922z3Y9qKBpxbp6ZCAF7PvFXMF9IhCZsBynO/cPv/89gDqiGeKSUDfg/sEmNj/++A5v3rxFyVZ51JyR9wQSxxb2ihCtt93cunC9P6DWxxuY1WwcqXW7udVuTleatirGj+mEr1pBIYFU5uK6nG337GzFmiEhIDiBDiFBWh2anBYSqGzDAg8kSGmF3c7+gCAZCD4Q/4qmy3TkgmAGPgHQjKBA9T9r1bGafvMzdaLQrBb9gRm4v22/43MWEZTSxo7NNqAYkRNhsYjGNRGqP5hLYiwhQqoDubzbFMNL44QElTbCyBsBoeq8fykCIHRNd1yO5l8jiuwLkhJbpdZd68gWhH6/LimAKGG/YR5bOJN9xqZk54WmHqkr1ue0xXki3bxY6mf4KTM5d6TzrYKB66Cb32EbZviiFiO7WPJPKDvwgnm8HC/Hy/ETj59feehNT2o8Pf8bhTFM7acmDXeHA+7OZ6TuWUHkJsY+Ar0+48Pjj9gee+Vhu2if1fd4h973t1IMfWYeJa26wrd7ZOY2GXRAN5Qt6Ks9KbAcDgi+A+3laoHQQgOLiTHheLrDp4/ujpWviCkN3ESq4v7+fsQ5fHz/Dqe7O/TxsalTZahV9/2CRQ8AK3K2Kc+yBJyWFcUZj+AVedtxvHN2KNmYT3yUVptAlMZurGIZtIEP2D3z45rNgrHTttWxBXacRFsDlRt7gqSIvAAwzKnzP4gjJnVBEWneNgEVRQiNOpfEeQrjLlhsTOoeI5HhLmB97Bocc2oI6KPxZhOUoXxW8y0duh5vfTAnU0bL9ozjbA5quaUxs9/zjsABx9Uc5U7LFSRljEmJA0KK817TAE3rZ/KKWsqoADgdTFovDNq6QrghBho8DnWOxQiO4gVC67RZcLm+YlbgCrbWdBQB9i37hER7hd9bNOmeIn2C0sBCs/1gb2Ho5iVrAbQh8pxQWgyp3ASS//HjF8qqZWjdYW3KzRhIZVxwIuDuLuGwHubviOkA+s3+/PwB14/vUfxnEQvvwTBGUXtNX2xqzW7nd8OpFgHpHE+qCHJr0xNEZfbt6PZyNBLvSxOUDIAw2pLD6YQff/wRtWfRxoBLLmPcW1vGw9tv8PTBKe4Q1H3Hnrtvg+D5+oxI3Ve1obYNRDMZbN8qzqe7sXikw9F6f7/Rtu2CWstN+phhK6dz79EZJN1Yyc2Wnp4gzEjuAcLEaJLH+JdDMt5Ix5xqBfOC4UdULrCUtTnE654g/XMYaTsPsV3BCqJBP0KVvlj4woBmi9n4WdG0ABxuIA/2jaXfYwHCPAybSBUkt1RqJ5512wA1X1RUHcS+QAF3x8n7UCQQ6hDX2Vg4IrPzf1JArdfxPQiKKsWuC+yBJ00QEl9w7Z7XKFNY2KqR7DowyQEV54GlOfQ78CSFWjYz0+ApmV4MQ5eiBHvebhYo26Q7bggPxfLzS8bzoPG79sgmBLDzjmJybxTCn9S5/IJmQG4qM1xfPIbSF4rzacE3r+6xrsuYN7cmKDVjvxi49vzpB2zXR09UswmCNNiTAtgDTwGtp2OJIAYLW+o7srQKSAH1jpnMf6P5DhNDsgWkp7cJUC9PyP73pamrEMPwEbk8PmK/PA3wtxEgrQzgi0NErYLd4xxCiNj2baiBt+sVzDrMc5+fr0ghgBhDmVsFOBzPg0C3b1eEuA58Zt83XC7Pw6D3ul+hsg3j4UAAyGIWV9eR1GXH5bqPqIWYbBLTzxUHBmobyDzFfq5dkZzO0LpZH913T7FktfFAuLYjUldjBmTpWhoD7+yh7u70V+gNkA4oeGAofeRlIrQOmIJsU+o+nZBexQ05qyXGDeIUQWkBkwwxnTnPYzjzN0o4BB2anb579/MLVjSZDFQpGRzj9BARY6GGG9YvtWqVlPYAsQCFIHJfrPnzBHuFr/MTLyKYgHIsi2rPVcd/TB/WZrUYYMOBMZky858Rsk6E7qp1mxDHrIPNHJdk5kccwfwvqKqlJqAmbmOmN6Mev2iO5L++P+F8urNVrq+00rBvO65bz1jZIE3GqbITEEaVQGoktB6zAGIU0b5sAQDavqOUC1JPa6MAubkYFYR1XUYbc902SKuDubmuJ8S0gEJAdvf0vD2CoZBu56eKUiv+1d/+OwDAq1dn/OPf/T0+Oa1+OZ6QSp0LmAJoCuFuurzj8d0zznf3w1Wq5A3/zBF/8VdmslO2C/a94Oiu400yHh8/QnzHuVyfcH9/jxDchZwtQkEpoPbpyXLAIorr1aMfKSKsC4ZhE7Mlubcu77YpB/oOzwyOB7PT6+BksGpptDRE4LgMsJKlgDlhr74Ase3ac9QLA8FDbxdMGKkQpD5dkertgT+oZMDfmL5A/WGZVW0HGu3nbhLEYypRckWtNNy0QiDgGHEfu0rZqqU+GbF0PRpVgk2l4phkiYUImRyiLyhVPVfIq0MVLExQ7QlyZxRe0CPvGWqv0e9eterQNoxZKavUEcEhDZ9lF4mYkr2DsoHZiHp92qJmLGTEut6Cmbr94KZbISazoBSZVP8vOF4A05fj5Xg5ftLxCxggy+BJ0C3B1XvW6KbB96cjlnUBOAFjbFdQ8j55HcWAohG04/6bvXSMHND2J4jrCwjB0FqatYeI+X3knj2rACggrE6Jj9HaJQ9i3vOOhoC4dKqzlXPX69UCowBoqyDUmyySAlXGhx8N2D2eHwDych4GDj89fRrtVSk7YlzGCLmVCoqK5+vHYXiTDid8/PF3eHiw73Z/t+Car3j/3j5njAxtGf/0WzPhsfT02aDGyFAhLGWOPA/rAuKIZXU/lD0j83GGK7WKENKoFnOulh/TS+CaId1PU7rMHGBKI5GsdUyja11qQdQNhYy/UmtCCjpKeUIDSRukPnZ9EmNiFuq4yrDEIwPfZ6CY/9mEDty7c2IHqmY1QDe4CJqOlLQoBFn6CBYg1ltvYghbOd+rBItYq9NX1W5UGJfP/iyrWSr0yllhvqRrN0Zazgi8IIUbDseNhyB7lowqBrVAezvn31VaAwWa30us4hp0BigIgsB9HGxcIebp48scEDhOXRUYgQ17CeFmzP5Hjl/MSYxBHr47ISZSxflgb3E6H0ExfnZiSmvYyz4eZJGGEA4IwR7aVjJUbpyttILbNngKBrjasjHUqTBBU+nuY1KRsI+0t7ZbGPTuXAYKqwn2uGMgivc//oBa9qkILp5aNzwzGxSC9+/+q30OFFyfHgGy19guz6ilYTl0p6tsYjX/TI+fPhqRKfDIsOH/r71vbZYjya07QGZ19+UlhzOjkRWWpQ/64P//n7Qb64d2dkneR3dXZgL+gEdmj2wt95KxYYc7I2aC/bjVVVlZSODg4KDtIDB+/NlUyj/88J/B3DJIH1JwPB7BXmR1fu7o1x2P713fdd+Nn/HDu1SGH+0I1Y7qxmTbDmi9ZWtCewgHhALjsIKq6GHToBaeEGWWQYa5wOEWl2pCR7LgP9QbDuQ6I1rQBmf9RvHqztl4qs8QxN8qvqamWhZB+oDorP51dp99Hh5+Yh7zdSpweehaA1QVoI3JQypFnb0ZfVzUqk695wqVDcpIYefeO4rYugschMAAb9Bosar20IdxqfVozbdTMEuhzLm+xxDIEAc3PexgK1abhXFmIBIxysctsm47WK/AcENbttzI4xi1eH+W+I0gVNYtjfrXjO/geQz7D7JciWUYjlvB3/3k7Qge34PKAX307KB+vZxxfX3B1TMMxIy6bThny8WGPhpOJ6dojytIrXQdsE1BxNJ4ssTHCqSEIGCofPT23M+vGGTFWoCDnejZHa63ZsrmKlNlys95pp0Fp4dHfPxox/jjf/8d+t6gNGn2RDT79LIJHz09GTDcRwMBeDpfsyhw2w6oteJ3/2oG6eH9D3j3QNgd39nHFZUr3jm1/9Pn/wbpHewG68vrJ7RrQz0eEVrlz58/gcoR+9XSwe8eP+D4cEiltnI8WqZDoy1mMS/Or7MeTijSrVlXZM1QoHKdO6Gop/ns3u+dbXelENW5ovdD4lYKwxHUC9ZICWUzMZ+Jl9n9lCUrMcYUljIK9tx9CS50s5QgENyYJDOWQTwNjEIxpCQFniDgQlkewLDewNkagxjqQC7gxWREhllEX1gQQAXKrrC+N1Qr7rffFEVrkmUKVKzBVnoZ6RkAqfIlRj0PjE5VwRhpvMFWTh/HYGnQommQCC5HoDMhzDCphdhUTB7RPZ/chP/yuGMe93Ef9/Gm8e1hSwqJkP87ai0I//DL+/Q8TqcPEFW0fk6x4tcvn3F5+ZQI7/FwwLg2Sy8B0NFQtlPqanAh8wLc89jFOPu8yMXBU5FJ/oHpJ5w9U6KiUBKQo+77+bOJCkeLgxb9VBb8RiMOj2s2+YGXs3kzz19+xeVymRILdCsG9O7dD/jll1+weV69F8b1crWGQG6+9/2Cw/Fjksb+8Lvf41/+67+A3CtAZ0it2cT6dKjY28Cz9/19fXrBtm1oTbB7YaG2M5heIZ5BuLw84/DwHj/9/HcAzHWvldN7YXRstcxWh94+9LAVDI6UcrfCK/9OHwPQpR6mbO4ZegxOwIEJTYODERwOz84s6ckZ56vvtguGMWaqcc5xfA4Lc1YMBL4k460Q+U0vAQBKeia1VGsSnr1r7Y+zTgiWno3f3A4H9KFgUZRoxCX6m2yhhX0tOkqDzDPmed4peOzXzVbJNsNEKFSWa6NoJh+1XMbPCBkAAVDqO2hgOZ6JIp0asLUWHMohw0Ihnaz3r+eIfQ89DwsLmKoRiBwA/PjjA/7T3/8dHt8bo68UByGbWuNiACqvKJVw8nRkrQe0dgb75Bcq2E4fMk2l5YBrE5x3r9xV07BgloXcIug6Zq2FqE9K9AMV4/l7Y6Qu1j0utERVo3/FTO+KqvWSjXTYgXF69w5PT5aaNbIalpSy3YTTydzXy/kLWv+Y7up2eICCoFd1pS57GEupqTfx6df/gV9//BEfP9gxnp4+g/U9qqurl+2EYx2pNCYqUCXs56d8T0dDIWS/E1XFlz//MVOJH3/6GWMUJwkBzBVVCanFERoRQD64h1Kh5YDurFW0HaNXqIdCrATaHmYqF0DhqdXB3gEtjBGzHbuPPnvseuAVQLk6KS3VyACo8s1DZ/1OpvEhtoc9ewETZQ1M/G5rHd2rbk+FwTyBXFUrpiwuUEQARGfVM3OByO4M1Im9ROElEL1/KfU7rq2hQWbBJQZuogSaYG+EbMbO1dxkrMsfp2IfvM9LsIi5FChN5Tjyui8CIME6LRVdl7nwvr8TwP268d0AU8vlk8v4AT88fsD7x48oToXe20DzxsLbgxmUEwAtV1ycibn3J3Q9YWeTDMS7d2i0IW7OtQOtKfbEHgwnWZXTCgHqEviAF9MtiLaZ2Fko17rxCVYpO6voVKzqTaqS5dn1eML5fMHZd/1SGAzKEmej0c/GRwWK5y+f8fDBMhCffv3ViTuE/eoPoQLP8pSGlbngT//2b4D+7KctaNfnxCuODyfs1322ktwH2vUZtbyHBsnOvZ+gxYONDHR9Ne/mMyoeHh/gMAr260B5d3QlNHiltG1J5NwPcS7PwQ1OrRv2a4dWz+jszXoOufShjOZd27w4D+Rl/mEYxERxAIx8jzyD4DfVPdrZHpH+N4t8Lvz4PESL8z0ZUyiLXAxJQt7BCth48W7syQ4cy+5JEKtEOoyDIZmFK9sB/TpZqYAJI5VUXTtAqCBaYKbcY/6me2A6RZEr2DaUdD0Yy05p5SEi2SFOA2VZBJCZnH7uhk+omJHPubFGbFYSgK8ed8zjPu7jPt40vt3z8Mo4cc8jkfpagfqQrQ2fXq54fjqjMGN3Svb5PPDyfMaLl6W/vLzi+bng1Xdb3WCpTA8HZFibhRCiKWx1F8xj7q4EsDJovTKZBXpEnLuQvWGvN56WGvAdMZSMpAPg1CBVGTi/vmbxEZH37ljYeapq8ogAKgten/+Ew2bs0YeHR7y+PqHt+8wgwFKU0ZKSmfDl0x9NSBoWuR0PB1z9mMoFp9M7nN2L2NsFp+M7XM6XTBVGnURQ8S39TLNW6PyM8+tnlPpf7DdJ8Pnzjp9/+dnn24gPTDV3PtEGXjIhzBXMmlR9Kozz6wUOzYBos94vySp23kgUdmkD6dGxiBmGFCqIHbarpMiNf8Hu25xtm78oWnO3ZSy7aPInEkcxjMWjV5RyAnNDCZnBHinY8CYV23ZcxJo6dChEWmJKpVhfZMWigSI7ql8rlw2ihK7B4DUKfraSdKKJebp2XjsGWBVbqmqZtzMjPCvmi3U0TLB0SgyqQov1xeF8KIzjEavVIL4I+b4+2/Id9DwsBLCUX4Vn4PDnL2co/wpiKxb7/PkZX55fMBY37+X1jHbZMwYcQ0ygJC5STU06Ym929y0WUdmsGZEIZS5dVSAUjiEA6T659vnheLQmPBQCLsZVmHRecXd0Lj72psoh5tyul5mq898swBQYctc+i5vAAAu+uPLY6fE9tsMJ9aeCpz/Ze0TFFgxPN/pyecHxbCHE6Ir3Hx6zWI/JGlElDqBAv1yAui8LoINRUxAZRBijY1wCzGS0fsXTn+0cfvzlF7w8/xnHZ/vNbauGPhCnJqx1lZv0aFUC8YYWaelajIiVdVoKkYoSGhcq6CjoPXK9asSxOjEmgoseRxpVDXdawxLC1Lwg8msLCjwZXoYQ0oHjVkQT6PXg4dwCrzAwmrLHSvMQJYxHcYAxUvzFlcamEtiQBuaRm8bpsIF1NpISwCpp/TrZwcysGyIzHKwyeR5EVvwZ56Hdvs/Rt3d4SOevE7uI31B06RAQthBgIuvhS7jd7JJs95Xjm43HuQ0MeBcybVl78fz6Rxz/5+f83rXt3tx5gkG9A8tjDtVYnPZ66LjhEBBFC8IZI0ZTnThmNJ+K2NVINnHjkQuy5NYoKIzMo5MylBhc5k1tzQDRONdaGaKMdF4I2UrTfhPO85hVtVwPqdx0UOuWPjrjx1/+AQDw5dOfQFyyvkM9XRCYSPMFeXzwZsXEkD69smPdbCm4chQAjG5l9dXxiFqP3hE9jOArBEiA9Xr+gFIPePls9+2nX37G6AO7dHx4dLlELpYlikK4Ul0OIJo4AVzLBAKV0XrHiA2AAZNlh19XA1FDLVsaBxPwXRA9uPFYGJKqPcFlpuICyn6KPBuDpRIYbFqy6bcqRATn14k5lXpIAeRSTOMsNgCu1bMvwSc64nCwQrjhEgYCq/OpoTA3CNvhlHIGxAcUJWwy1y+RzqbUljYygDqMBcjlCCZPhrgmlgMdIG/MZbfHZRGjDsgrnMuyLpjICXE+R6HmjrVK7C+PO+ZxH/dxH28a3+x5tD3cfM/P+/syBOcuN65oIXVJNLeAxTgXSE/ExVFSEp49bx6upTH44u9VRmZCknDnKTpZ0n6Ft/RmWu9g4omRKKMSQyKMOR0hvWO/XtNLOW7V02dLPCiEEs6L8u2OL8ZOneeplg72168vn3F6fI+Xlz+hDc9abCe01pJnsDfT7jhHfY0AennB7tKGp4cHa+odlaUgz2YtrqhnSqIGRlhvkvlj7Bb37+YVPH36FR9//gW7N8Qyr8CqnV99JzseLOUp8HLusqFog+4Rp5gA8CUai3NB99oKwHY5BmedTymAonv2Yk5vcSzKb7xVNWeoJDeeHjwVmYz3YR4p1jBQHUtIz2OAwJk+v/aB9w8b4JyM/vIC1QEq09PjwpMnUhnH0wNae8l1oswg5Vn/osNbNER5hXiIPL3kIcter8MzH1PnRQC0PrLSmT27mJW6EJPUWSpmzduK37CD1NNSt8I+Nf6zpBJOz181vgPm4WGId32P2AxUHBfw8/V6iDXFZuKvwPRxrQho1lFYmflKHlpTaSI+OZg3RInBjAw5jHyEnBhCGDp7XUoFiFEjLh1Wt2C6Fh5CRCgVtRbCprIeqVhj4jhM5ilkxSznBlmDpazFGDi/vOCHjz/iy6dffbo2iAiaX8fhsDkWHa659U65uDEptQC6Y+xuXJSNczDXDYjZFkzgvmJgW86vdygbHhJd8Rlt/wHspKfn52e8+/AILhVfXKvk5/oI1utspo1HEJepczEGDrXg6i4xmFCYF26Dixn7XCnMiNE4JN/EODclAWgTBKZcJwRfM2EE3bWPGIPIovnVkAp5PB9hK9tGFBor3UPbPgyAVrYQpERdyubaHoG3lWISFEx57eJkrvkgj5vEKvkzEdoyVpslaQTNaAwQ1aS0CxQyekoJcLGNL6QcrG/MOlc8FzfM6KFYt8HCk/9xY6n9skRmaPg147vxPMACDORFEtsDnUxP9YdIZ40CNLQ4whNhVx6LiZEbEg2R3iwKQ+DjYYjdtGNoy7w3wcAuJPhmKu8RL0MEQzml4UQV0jvGAjqBQu0pwLMwLLGS4lz8BjNDhBaFdstEzd1goLWG4+kRD96u4XI+e+OmmQ0oTMlhKczgBZm/vp7x/v0RLTNR83QojZbL9/mlEguY4uG0eWSqi8J9weuXX/Hxp7+337iecXiweLp7Ad+nz2f8/PEIFXvI2uUJZTthRFsJAMKzTkVFwd4U2t/AKj1p9XADVBXVl6Otg+khGQA4JfLs2JoPkKirsft1WxaO83v+JRBFayO7HYJZNHu5dvQT3+hiKEuS+LLRdRbSVRC84tmzf1fdjRGaTagVWgFZ1jOJJBamjutMspttflDNIkDDAZGYHQkDOtJgwdeu+HovGsZo4hilVnA55pwbK3u2XvDVYO0mxtcbjzvmcR/3cR9vGt/sefChoGwFGIRSFMm5R4QpMwMBKFofM9Yik+aLJjniTNBIIRGZ+lYJJF/Mm8mepGwhiu1Mky1n9PZJOzVth5BXGyCMxAq6qvUIjWoHZqAWkHDWkbSu9j0/QoFiSEXsaqqKIRmwWXtRiTacZumpzLJ0dZ7C89Nn/PDB6J20XwAslaJcIGPk3DDUU6ZTN7U1xsHp6ufXq4dufOO+BzUZAGgQeFtKsYkBpmwKzsQ4X87YzpY9qMcTLi8XbNv0Ts6vr3jeCO9cbkD2K6TP3jCyN7Q2I2olyyhMFiXbEsnMCWNIh4xZ2jBkZBmBT5idL+K++2/FPaM43G1otDaKsmPITSgDHRieMj6/7hgfT6mYBk//zgiAbP6dLcqlOOW9ZOWtuHxEhJqFyKpmY2X0hu04MmwcA3A0x6/LrkEhKRVJaiszwolBw7NQHnpqh2VtApsxfszMWALkjaVmulczJe0T4dnS6e19zfh242HF01bIJGORpzPgaKZMAag1YVpLrc0t9MkGo5QpWjIvNr4NqA5Up0/31pxotUymUOb07Y/Mjaw1MI0waH5zWKFUF56Ig1IMhMQAo1lhUfYVIWcJx2K3b4XLG2ApwWN4stclHyAD8xSKiwOg9XDEvl+nCvzQm3BMRJz8NOdkv+44eA8cBZJijQx9fDFF7Ge5XEzeTEmALn4DVPF6Njzjw/aAS7tiqyU1QkCMz19esJVonl3QW0fLQjkDi/fQS8E8PoAMD0MXAwKwVFjXtyl/qDKREULQxmP+o5bF749aJ73AlMYwfktQve08fZPIUnfbqOLU/vz0gl9+fsCDrxMmBpPOkK5Ur9+a5feEglIPKA6qatx351zIuKLT7KOzjQYZ1yyFl8FJLwf8tnGBOtDqi8eejtxU7KpTwwRhF2e4qyuOyOzyifNR/60IkTgJj2liOl8zvh0w3btXSgY5KuJnBgLAg0OaOhwjiR2bEI15AVi/OZHM0ZtM1czfyxgGsO0tXyMmaF8AABzDSURBVPfhiyswDbICM1kMkOkZ+DHUqxTjvFyjIbwEETGSDmYhlnrNQ8SyPRmrC7bgpVx+UL9ZU8hn7UqnEKDYOQ1n21ZmFNrmg+bckdy0pAMYuTtbVkqTO0JcrDZjKRAjZ2Fmu4BiBVZcY+cOTsF8KJmRHdovr2eUreL19ZLqY6KCPgY+fTbM46ePDwD2vNbWFWDOVhZtH27EAjuAz0PcAIZCMcYVRbyTIDsZK9siEGJHRvy5zgxEaJyuICx02M4eYDFZUV5UDJvzV1D98+6NyR+O5lmUFEKeD2WtB2tTCaCWI24aSgOmOEe3jcSB2bB7CKH1Ao5MCYUAUDSJYmOErqpoas3BMpsI5z0tHBjTng3DKf6I2etaN2x1Q1meM1W1Z2kV0CI2YaK/pfEAsUvr2wUm/VcVkIESll8cLIXmdQ/RBKwA2x10mey6HbC3SwrmwF3TJAB5ARETZctE6zM7QVcTKpppVgUALrmYjbE6DYOFPPIbFF3BOvuGUFByFnINlmItIpNkzDAGALjOTJPa54cyiWd2I9kqhG12bC4X+vrKpKVisgMcmlKFzQNcwDTfo6bSFRnlOtii1tZhCZWiKMt/83J9xZHeQRigVL8iiDC+vETq8Iof3m+okUpUQbtKAudaCa3/hh1KNHuZhEHtHVL9GKX6OUVVr7hwcsy/OuiNPKbqmNsx2LNKnOEsYIzQqbCuKBRtJWxuLteG94+u/M7WfznBZioYY0ymrXsIpCM77JXDEf3yAiRLtaLrSNUvGYRWePESbMOZ62JgiIdlOg2QefHhMXkvo/UhX8oagB1bqWl8BLa2RBf1Nw8V143dyJSEv8Z63AHT+7iP+3jT+C6pWiKzWJaCm+k08zJmepKJXCIu0nQD1qN0DXUEm8eZ+76nHkcck7lkSk5FEnAKMZQowQ9cjKigsKYgS2g80II/GPU8CDQmhGs5/QDPFGO0JCmBCzDmzgcNnMZ38JAw1NWrmKBsLZbbZZo6IqI641UATNZwu3iulquX+S+cABBnTK7Dwom1j2/h4oBl7DgHECatnrkaILdgJKYm6fes7zifgXcPj2g9uAkKXTy35+cGEeD9OzuP49axN4WrPhpewpO0F7ycGzoBF5D0LDATOWAVONYQ+Y3pFrmpr7F7WCbQzhPPSF6Q6i0epLCmTF7sOIbg9bzf8H9aG3OdiKC7xi5g3QohFpLFMblsjtdEcaN5J7zUnYzRJ0ER5k0m8YzCi94SyAXNENV+qjjdwS+L2J+DkA5QEAk2l0QgWLg8ZAHf2Yh6qx6K0SamMNHXjO/Q9IkdYZ6kKGByG6J3G3vPFSu0su+YC6i3i0AF6jnuQhYO5FT7mohJIFebjgcPcLd4BdTdoM0HiEE8yUGAubKOk5mClHMjggvS+/CQ5TcTGwuRFBDKDA5T8RqSWRszkS0AHr4NwXKzzBkPUhLzduua60ApJWNbGbaAhk7moYQhTB6Mfyc7nzuvYzXWNAMshVrtRj5gJrx73RtOh8iIGdYUpDodij9/vqB5A+kffzjg8eGKz8+OD3VCIZ6ZJw9tk0gFAZXNs0kTSGfMNo1xd+N+kBdHyrLeQOvfRyg2lszdvC6/OAvqYh2Qol33DLtLKaAxjaRKR6m2Edn8WwFiKbNCW8QevqhXFRD4hphlxiFwEtMt4ds14OF+TE9xmlnyZMiwmjhv9XCElrBGB6A1gGLDR1QUgR6uIcwyHQak/i0L49TzCiNk3vJkLJ6ey5YAHVCSJdVK4ELZH1RUDPmVWYHJ4HygoEZySuQZlk5se5uAkpPTpiJUTPBMHYr3QgXc2ECXruRm+bHQ0ccYZt0jjlT594sXlAVQmoBqeBoHExjiaHnQQGSivpEOBgCRloJDpuY905UMTnahzXt0FgujybmL6nKevLR6jMZcEdamilkCZ4Su0THdxhCFtB0qdp5W1StoYzJ4QYovz9Y+Q/CIHx4PeDhFa4sOopol5a0LovMfAC+oMy9Ks6DMZSITMHXvMnApYs+arbsxAQmoMogpqf4xP6CS92hoN4wnmMjMeHm94vnVvJ+ffzhBeKDH51DUcshMCtBRjidoG3O9EgFUISEd6ZmuKKbjut3cj2TR+nUNja14MYQEB3nDoIen7sbBXZMeXsRQQFuqxwW9gTAry1XVm1xNAyK+1ui3G+R/MO6Yx33cx328aXw/GUKyMCIa8oqnCSPbYoVIJtoz3Wq+SWGKGv6crqLH68EkH7AdInRRVK0O5VYY1zCP2KWsIGrWuth3ZuwL8hAgXE+q6SZHmbmwoMskGLG77qsHZPl93wmzgZDv1vWIoQPDY3ou7NafsG1TX9Ti1XA3zXmPuWFw9vSwY1RLUU+Xy7yKBWcynk1N4hP5nCUFmay7vEp4JgJimelgsBOhOH+ndyM5hbeIsvn9tNdPLy8ATjhtoTdxRRtTvIZLAQsmngRPWcs1pQ51NAhptrKwNcL5NxbumRSDzZVlxmYt5NTknN4iu6boJKfZXZsci94HXr0Fx48frC1nXHfZjt7j1a/j+IA6CETX3KstVU7o4Un3jsJ1lvFD8PBwzJC5dcpQB/B+wxbtZ1jXu0lqZsZMzevMHrpiRYKRXh8wwmJpxtXR07u484k1Epf8Hbt2QhSkxnx8zfj2XrUUQCZ58ZuNMAyZSyajfNVS8rkd1i14clLVU4E6iTn2ZrirxcHIoGqSpywndjDcEIQBGug+KfBjMFZQZIiL0AbjjswUAJhaEKWYzmYCYxWdMGsFyDQjNR9aQuGJAQ3ZAaIZfoEgo98UlIkM79o1cREDttwgBfckHkJVMG6LBgsRugOadv7sylJ+3m490shFmjBJS2YYJ3chqlcXW+sV1GFITRdjzjep4vn5An1850eotj7S4LMDw3ORJukrmjqN5ozcMPiOzSx9Y5kW/gpX132JubMv3UAixeo+sBgLXXU8HVC7Xl0TdgzUeoB4TQ+IsB0Oed1jCAqxqcf7KLyhKTC70BFErlB/kI/l70GHDZ+evHcwrIIyzkFgQD8RTXqCRnp+3mdb8H5asDqhrKtygx/ckaFxb4wsNqdnVu4SGcYznKfyteM7AKZ+A9zqJi9BDPVNV0QjRlfnFyB3hrQvLvY6KcTqhUbz+8OVvgCgoBg4hKW4zq1ZWma141evFDWOQV8WIgG0gUs8ULZwaAES4yonssuexfFXxCDIEsvaCEk7DDHcJA9nFGJashCKglIZIkEgMkMSnxcuYV3tN73QLg5pnAUzNSG7H3T/mXlyyrxfhjX3nqCs49HYkqHt86iaDFN13ghF57RmGYoghVkBmeJ8cemA09E4CMklsfu4soxtV5xEPpUdOrbcsUF8k51RGQATKFXCKe8QAK9E9QxN3CMRdCxGkACmWbgZa/Hlxchv1/YRh8cHeD9ukwjgLcljvV/Q+g6Rdkt5X7xglYspqMUmA+C6W4mG/2h67DHf5vEqJOcrNpfY0OxcRuJxzdpdZAmHMVx3N2q17XiA8UYkpfEoN/24dkBnhfxXjjvmcR/3cR9vGt8B84BhHnDPIdNUHQRN3ECZoEN8Z/TdNrOfHt9ZfnSmrpwrEfGfkJgmQbj23Vw2XTyNPuSW20/VUluY3ks4qfb5bdrKmhr5rr6w7SzEmJfMTLN4CcvWDfcSAmCAuY4AFpdQUKplCGIzCOZlSPtbe8WRMTfTTF0CsKzVIoRbuaBwcUbhDMForQkhZEPjmAsCL+cQFwv/TYuNBTIZobDyenUih4i4W+3YgGMPoVnR+0AtJbMzquaFyRry1QpCyXBLpKFiNlNy8u0SFjIgkrUwY1jaP/gSqqYDSqF64/fILiE8PfdeOTI2FSJIcSAV51xg3sM2BAG4iQz0dvG0qnsF1TzvCAsrG7AQ5zXGjj5GZrkwrOFVrJOoW4l5iXtBoPRAAMUQzWsXVbBiYl+kJrvgr0cX9Laj1iNikKeyI6WsJOi942/et6WyCekICiBjSfuJ64lGOMAO6smCL+gN8AU4aBMPLVdI35PqXLnACFnhQsNi0Tof7PPF1BNKPgmax43XJsoSv2cCRLkwycOgxU1mdpxmEaOxBRxGTsyfzC5fLgoT2g+1Wvc4f0qLaymYEK09MCVEc7KwUFF4yy5fUbyUZs8xlLzKJW0boaIBpisWUzKNa6dtBY0JBCOAOlrm1y9zUZe3Arq4r+TnhfzcdDPc4PcBHCYRTYbzK5ZQVMXWxkzf3lZFi1rIR5myd/x04UfI6JNLAkvFqs7NS8pmoWqmVR2ni5odT6/nJiPDyh/ywqw3ijgW0doV/XqB9JYpeGEzBtG8vPodmXUnF4x2Qcn1fYsL6hgB1c/7JPDwdWqAmOh4GEFGFwWXGX4NFXtWAKB17Ocn4JFzLmqJGihfW54KJlr6F33F+Haeh6tTkfhOvcSUqr/NGnuz4VmbDl06aE3mXOzkhiPEMYYosHQWU7fKxVl2MRy0BuC9j3XGjkHQSpEiYjMgGXceoKO7cZlkKzv9GbdbcdJs9wBCloiPQMCDSCsFxnEJS19AEAOPg8RUXDB5EUoiLagHi7G3U8Hz5y+5M7IvsNjFDocjxn51DsrsLg+di0SzAfRU6xZRUJl3iQiT56Fq+QYuWcBnWTMsotTO1ckCMgPzppix4tp6PmDBtp2KcOyKcgJk28Yx1dvguJACE1p3jG1t0LSM7H4mI1tX2FMoy7WyG6NZvzRU0sBfrjuMpBegohmiEKK+nl9Nta4WsHtV7XJFKVsayj7MUYlTaDvQWdBj0yF4d8EwWLYJ6QLOG5q3KodNgqTdQ2OGpEDWCCNoY4yB/XJBOZxQT4/+N/Y+rb+RRunrsy13zOM+7uM+3jS+3fNQ28WnW2Xvi++MEbYMEa/WXL2R4rnncLki5TSDbzLdvHyNUkA861RIgeveMjXFINRSFjq0IcnBXlQPp+IkUnXNzahI9xTmbNodSvZ5baq2o8R5ls2wlyVtuor+msu95VWVUnCoJ4i0PGZvHX0MbOndMIY0nC+20+17QRdk71TzJgJvANpubQCIyyKSU2528KHW2nGG067FErUupXjri7kbQweGInvWhE4LLedpPI3pMVmDbH8JLxOPMIThrnjs6AUhGsXsPWq4m5hzZH1cxnDG406jnmkkRH8Tuz8Cpoq6bdm4S8TOM6qWs3ZpphxQSPM89+sFgom/MRXoUKiX5G9bhY4jRrX2mnYagZPNvA9kLJwjE3nuEb6GcuKIWhiCSLdwN7g5avc5cRKXuciQ4zchXOjFhgfB1TzP3hqOp7keo8HUPO+Rz/LXjm83HmNAeXgIgpsH3bpz26uVk3Dj8Cw8DjMklPqjq/5mDJGlvNviEUyxmPhpRUlBWG9KFcbDDVQKyZClc4fHqaoOZoayEiyuXHGRwAFWoFRlccWF0UbLBzvS2GUh+vTWzN0PV1yNN5B/A9O7jHqEIYpCNQWSrMl3wYju8w5Oc9HlvJ3qvTQdAsbsIyLNLLCnH0UtxRnK5qZmr4t+CbBttjiTf8KTYwAYnjORB79HPj/2eQV40ZaAGiZAmOXuo2L0lg2ayCdclusiD7mA6BS36H2IQp3/s5SEeD+dAGXj/sZD2E35yy/lfGloXXBYVNmAjuJFUJtsGPSCWivKHiQ88vXuIV43la9IfRc0QPrUnnHB4Zhv4uK400zBD43jRgjt1z7z2iAta0Dn9jnmpngXgpEbvCyUewAL/id/Y+OhrsyVLDU7sQIT3clCmwUgi8mE55ZjproUP054DYbT6XoI0hR0EVWrUIVOMM0V2AO4VVEM6WhBukF0o58EGRpTxAigjO8n/4Fuq2ShNyChiaENA43jPHmtHBWzUklcM4S895E7ehTF1YN7FmO3ZlM1OtgXE45Jt02dPeo7q5oOiWpimfk4BXOzlGp8hdR5V3Cp6amE8W85v3DDPLMpBqwtbSjUgOEJLHrtzEwW3ABxBtJiSgkO9bofvlm4oh3DO92VcnCjP0Ham9+EgfBJlCrOKrbJznupOhZDR4bfLIS5gYEa9xCEQ62L3kq8G/jEju14wqV1IDVYvINAiv2IFaSFJzes+lvFWcXhVec9BBAFgWvDK8gsdaFyu4Gy/U5YPSpWT1MDzxBbb4od17PVH53evfPCSjuGJTxMk2fdCP7SuGMe93Ef9/Gm8R0YpsG0N9co8AgKF3CJKUM3MnuMIphuoc4Ur6crv6ZE1atER5DpvGFOcCTgR4VKysp3GRi93XgvTEgpPiJA0TFTj0aLtsrYuJYdIelnpyVegxMxJCXCH79RnDKd5808w5xo9GOagADM3S/E2C+X/A2lLcWfRQElQnXdvJ70ZT/k0KndsfAddNnZLIizDAxgoWSXghGBBpExwcPlJQBkc56ZIt/1p2Nt1xU79GzbmVslwCO/reIs1CUErMXSiIkxkUstBNuWGWCdYd9vCSnpwbu36Z7P2os1qr4nm9PCs9xnycrv1dfeaSt2/VGH0gaOVBCKapULrl1szce1kXpa2dfeaHh3eFhqufQmE4VhszixnOjjspxntltdPDeZfiDyfgSXxJTLNNLvgfkMwWhOi9dHC729v3Anq78pxBnuf834DsbDAE9Xopw3Ug1XyP4TnoayRtL+HcKNXmPxcvrUQyC4IfBf8ngvRU1oxqwruUWVESlPGSZWo9MeGXCYeXHXM02xmjHxDg28wa4xlMttEc7FngbMf99u5nxmycvOV+qv0bwBdrdaukBowRKInF8y/f+Nl/4nbAVQM+vHCRpmTYi6kJLH1EPUigvjtqvxBQIDYVflTg1OkvCL06AQAj3On7CFV+ZyBtGNsSCZTajtcia4yVCspLW4VlpKHVJaAIvB16WMIW5Xzrf9YywPKqnxWZbpvEnpq5oZPDjvY9uq9XZJ8Y0O1dkbGDKwX14xWkNzKj6TgqRlkZqI4rKfcXBhng0HByaDOGl4nybZUCYGFkMB6KK54s/ANLT2lyv9AWRdEONKo1laJBX26wu48IK1TDwoxKW+ZnwXDVOrqRh+pRPYMVwgYkiFFcctwCJZpei6M9LCpBwyHImfu1rB4mX4igkdEMAnFstCVFPTjoW4bQfTxQiyUBwmdi3nBhAWBqkCvY2bQjjSpdIx3ot6BP/9ufNZRD3jVBfDEc2dDlFdnDUNlmmi5TeG3AJaxhKMHcq7kcmMfx3ESMNp2peaCFkoqlEaSRdypnl/iGiVdrYFrjODY4swT8kzBbPxuBEBeeEpuFfSJtbDpXijpgn71bLNbnmweg5NAxY4jD9Q6fXd7Md+vzyud+M+jYX65pbv2G7sc/fyesbl+QWHo13c6eHBPEhEbUszL0P2FGQiKNr+vBD9qrX0jI1KBO82wR7rWfxqFvFtIkwPFba5ivQEk+Map8EFdO1uCHIp0rkWrYhwacQ1rqj1YdFjtRtDPPkiXzO+vfWCZxIs9JjMN0mEPkBGd++I8wbaOp27lHVaWypggRRjASbolYplcXzV6Tmo3lrmUsCj5oNetyOIkB3Q4O5rpuTU+pyKSHKSVCKVGOdJsdbyvPhm0j3TlDshW4FedHVne+hH6pe7a66LVFyoWYeHO8b01ODGWCdwaUbACvQKTSMHFUimMAm9i/fXsVCJMI0cw9PuWYVrGwPpAtB5FiOvTW1+omOZQkzI+sYrU5SZeLJdPOeO3UOSJf1bLD3r96j4pjQfKvWQzF95pi8lLxVgEk87I26agahZpGb9VDL8UsUgQK/OIN2vAHUc6wf/2O5V7N6Xy8XCAJ2Fb6NfIaOlor3KwFamoLT0Kx5qx6ZG1jqfr35NPv8eDoY6WFyreWnTS7gJlXxSk2wI2ztiA64qABfPuoUHypA1+0fxHHKey9eMO2B6H/dxH28a303PI4CgycGwMV3N+P7a7Nq2MF5cMEdK7HXiCO4VYBGyAYBihXhWcBc7XezEQbKx0Ck9AyL0YXu+HSKsvn3chutecriDyNTuqtfBy26gYueyIGfeZMhfs1Hoo1WDeIhiPUjjvDxoT8owLWSe384bwFRdSi/esZS0pbeDJAar5UiZxzj8ApDqrYu7diPL91dAOgHscMMcaNQZ56ssfXSi/+4abjHn5yrqnoeCtOZchAYFgPQeMowJOYJFPBqYOiTEFo7wcq2m2zk9t3Ad0/1nuqn74VJRyubhOJy8VdC64Rv7+Qn79dkUFf2YrTXslz35KZamFWCLcgBgo46Dc0XOKAAvXRUxn5cMo/1/GYmKFRVO/M08v/SKg80YYHOtXkoxMTqAUMqW9AQBEmf8a8a3N31KDYDbiry1nsJeuz7FgkYTrCvXWjEoY+VTOCC0uKdeHBNvQBE8fXuLixWCre69hSnmSlqWgidjD676nhAIYQxTy6rOsSCwFT1F4RaTt0j0B7uspCMXVvGiM2CCgmkKZcDsDeffzC7ycRoG6a1IPcnIgj91Udsp5CypjhXtD4ksf68pWGOYRuAkFmPfYhamu7mgoaTe9GqZL5pfgU5h3fgchOxQZhyZnvcwMgmr6K/dfsVILRMjwMXfjNFdP3RODaFm5S5WnAa2JouHwDHnvY8bASH7bKn6ticob0BlgkpHJLW2ekAfHaOZ0pj2hjEGervmZLTLE1q7TmNAaryOfCwe0a5nUGAgrnEaurREMJ6Gz1vOKNFChTa8J/sjuWD3vGe+eZTgkhSw37MAQ7fDCSpT9xSqqJuxWP+KZMv3oqeb8YBOQVnfUIDFiEg+IPGQWdl0qDGRU5CnorVb0vQ/FMpiEwY3sMO6gKe3AkrgCbA4MgyKnZdlOVYZevNmJH+DIwacgTlK2VJQ1wSUSxYHGzYAE58FDCCUmS6uNUrloxo42lRMo0cw6cK5g3i1axCIxtxtYt6JCRsvwj8aGIL/jadtJ9NVQHWujmm0J8C6THd6OyueEwS53NFleGYojmF3d6R9N9bwurFYzE45N+yU6jRylLCgf78ZluLzbwD1vIdQOLFtZS4LKq8yBrbxTJaqebwr0E46PdQuA613nLwn74BCesPwFh6tXzFah3bBfjaD0i7N2K0S5fLO5l3U9EbfIQjFNMDEr1aUDzeYh6iV4KfwFNuzFG07w8NKiYFSwOUwsyYc+J3g+OAd+cqWgld2TN+oaGmG9hXjjnncx33cx5vGmz2P2Eku51eM3i0E4ZItD6y36q3GJmA7bGyEMiw7M9semA4n09xhh5fQ29/Ci7Qc3VZ18Vf3fPxbN6XFEiKFkscQadj7TK8pkC0sVQTCAC9xven7irmosF1vLV0eFM2n/HVrBgsE32DvnjKL8x5LTD7Rf0bCEx6DLzu+uleUHtQAcwW70LB08fBAk1tDngrMTBRwE6JEsWC2pYDelIgbMW7Wodib7tvP6bbwMbNdkT1wf5/t2mg6N66VEde1gQdZO4qMT3GTGZEhuO4XiG75OfEsarM1tDRC8gxTw9yRQQQaU7qBmNCZgEWewHQ87Zhfnl9xPp+zNYYMRbt8xsvzrwCA89NnXJtiv+w4v34CAFz2C65DM/vSW8cgArscpV4u0HLFruapDPXmqDo9Dld3zszRCMUsJweObjjKcO97KLnshDdMV9NZnRQJny+iTI9v1PweRgbHykhUxbJMwI2n+H8apH+NdNAyfv/73+Of//mf3/Kn93Ef9/F/+fjd736Hf/qnf/oPv/Nm4yEi+MMf/oAPHz4sdOH7uI/7+H95qCqenp7wj//4j7/hLv378WbjcR/3cR//f487YHof93Efbxp343Ef93Efbxp343Ef93Efbxp343Ef93Efbxp343Ef93Efbxp343Ef93Efbxp343Ef93Efbxp343Ef93Efbxp343Ef93Efbxp343Ef93Efbxp343Ef93Efbxp343Ef93Efbxr/Cy7cqSGIm3DkAAAAAElFTkSuQmCC",
+ "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": {
+ "id": "184cfceb"
+ },
+ "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": {
+ "id": "5d57da4b"
+ },
+ "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": {
+ "id": "be2d31f5",
+ "outputId": "28dfd36c-42bb-4eea-f805-6ad3eb324524"
+ },
+ "outputs": [
+ {
+ "ename": "FileNotFoundError",
+ "evalue": "[Errno 2] No such file or directory: 'hymenoptera_data/train'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m/var/folders/c_/bcjgdb5j6wq89qpwvs1rl29h0000gn/T/ipykernel_27875/1654466997.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[0mdata_dir\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"hymenoptera_data\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[0;31m# Create train and validation datasets and loaders\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 36\u001b[0;31m image_datasets = {\n\u001b[0m\u001b[1;32m 37\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mImageFolder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata_transforms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m\"train\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"val\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/var/folders/c_/bcjgdb5j6wq89qpwvs1rl29h0000gn/T/ipykernel_27875/1654466997.py\u001b[0m in \u001b[0;36m<dictcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[0;31m# Create train and validation datasets and loaders\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 36\u001b[0m image_datasets = {\n\u001b[0;32m---> 37\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mImageFolder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata_transforms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 38\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m\"train\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"val\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m }\n",
+ "\u001b[0;32m/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/torchvision/datasets/folder.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, root, transform, target_transform, loader, is_valid_file)\u001b[0m\n\u001b[1;32m 307\u001b[0m \u001b[0mis_valid_file\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mCallable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 308\u001b[0m ):\n\u001b[0;32m--> 309\u001b[0;31m super().__init__(\n\u001b[0m\u001b[1;32m 310\u001b[0m \u001b[0mroot\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 311\u001b[0m \u001b[0mloader\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/torchvision/datasets/folder.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, root, loader, extensions, transform, target_transform, is_valid_file)\u001b[0m\n\u001b[1;32m 142\u001b[0m ) -> None:\n\u001b[1;32m 143\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mroot\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtransform\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_transform\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtarget_transform\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 144\u001b[0;31m \u001b[0mclasses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclass_to_idx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfind_classes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroot\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 145\u001b[0m \u001b[0msamples\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmake_dataset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroot\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclass_to_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextensions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_valid_file\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 146\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/torchvision/datasets/folder.py\u001b[0m in \u001b[0;36mfind_classes\u001b[0;34m(self, directory)\u001b[0m\n\u001b[1;32m 216\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mList\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mDict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mList\u001b[0m \u001b[0mof\u001b[0m \u001b[0mall\u001b[0m \u001b[0mclasses\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mdictionary\u001b[0m \u001b[0mmapping\u001b[0m \u001b[0meach\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mto\u001b[0m \u001b[0man\u001b[0m \u001b[0mindex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 217\u001b[0m \"\"\"\n\u001b[0;32m--> 218\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfind_classes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdirectory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 219\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 220\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__getitem__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindex\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mAny\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mAny\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/torchvision/datasets/folder.py\u001b[0m in \u001b[0;36mfind_classes\u001b[0;34m(directory)\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0mSee\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;32mclass\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0mDatasetFolder\u001b[0m\u001b[0;31m`\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mdetails\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \"\"\"\n\u001b[0;32m---> 40\u001b[0;31m \u001b[0mclasses\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msorted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mentry\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mentry\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscandir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdirectory\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mentry\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_dir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 41\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mclasses\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mFileNotFoundError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Couldn't find any class folder in {directory}.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'hymenoptera_data/train'"
+ ]
+ }
+ ],
+ "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": {
+ "id": "bbd48800"
+ },
+ "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": {
+ "id": "572d824c"
+ },
+ "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",
+ "metadata": {
+ "id": "iwhS2eKdTLsN"
+ },
+ "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."
+ ],
+ "id": "iwhS2eKdTLsN"
+ },
+ {
+ "cell_type": "markdown",
+ "id": "04a263f0",
+ "metadata": {
+ "id": "04a263f0"
+ },
+ "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": {
+ "id": "fe954ce4"
+ },
+ "source": [
+ "## Author\n",
+ "\n",
+ "Alberto BOSIO - Ph. D."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "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.8.13"
+ },
+ "colab": {
+ "provenance": [],
+ "gpuType": "T4"
+ },
+ "accelerator": "GPU"
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
\ No newline at end of file