ConvNet_from_scratch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/akhti/ammi-2019-ConvNets/blob/master/convnet_tutorial1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mCt-frpFH8oN"
   },
   "source": [
    "The tutorials use PyTorch. You will need to load the following dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hqnl0AKVXIA4"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "import PIL\n",
    "import imageio\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import skimage.transform\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.utils.data\n",
    "import torchvision\n",
    "from torchvision import datasets, transforms\n",
    "from IPython import display\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CKeYuM-cIXxs"
   },
   "source": [
    "The code below may be helpful in visualizing PyTorch tensors as images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZZd_rI8edYIB"
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "def show(img):\n",
    "    \"\"\"Show PyTorch tensor img as an image in matplotlib.\"\"\"\n",
    "    npimg = img.cpu().detach().numpy()\n",
    "    plt.imshow(np.transpose(npimg, (1,2,0)), interpolation='nearest')\n",
    "    plt.grid(False)\n",
    "    plt.gca().axis('off')\n",
    "\n",
    "def display_thumb(img):\n",
    "  display.display(transforms.Resize(128)(img))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dzfEE578uSNp"
   },
   "outputs": [],
   "source": [
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "71LRkRxndajG"
   },
   "source": [
    "## First tutorial:\n",
    "\n",
    "In the first tutorial, we are going to train a logistic regressor on the MNIST dataset of handwritten digits. Next, we will turn this logistic regressor into a non-linear convolutional network.\n",
    "\n",
    "The following code will load the MNIST dataset. Run it and inspect some of the images and their labels to confirm they are correct.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GX_ky5qC--uv"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to /tmp/mnist/MNIST/raw/train-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100.1%"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting /tmp/mnist/MNIST/raw/train-images-idx3-ubyte.gz to /tmp/mnist/MNIST/raw\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to /tmp/mnist/MNIST/raw/train-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "113.5%"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting /tmp/mnist/MNIST/raw/train-labels-idx1-ubyte.gz to /tmp/mnist/MNIST/raw\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to /tmp/mnist/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100.4%"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting /tmp/mnist/MNIST/raw/t10k-images-idx3-ubyte.gz to /tmp/mnist/MNIST/raw\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to /tmp/mnist/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "180.4%"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting /tmp/mnist/MNIST/raw/t10k-labels-idx1-ubyte.gz to /tmp/mnist/MNIST/raw\n",
      "Processing...\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "# Load the training and test dataset.\n",
    "mnist_train = datasets.MNIST('/tmp/mnist', train=True, download=True)\n",
    "mnist_test = datasets.MNIST('/tmp/mnist', train=False, download=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "E8dy7-kBHwco"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Label of image: 5 - five\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAABAElEQVR4nGNgGMyAWUhIqK5jvdSy/9/rGRgYGFhgEnJsVjYCwQwMDAxPJgV+vniQgYGBgREqZ7iXH8r6l/SV4dn7m8gmCt3++/fv37/Htn3/iMW+gDnZf/+e5WbQnoXNNXyMs/5GoQoxwVmf/n9kSGFiwAW49/11wynJoPzx4YIcRlyygR/+/i2XxCWru+vv32nSuGQFYv/83Y3b4p9/fzpAmSyoMnohpiwM1w5h06Q+5enfv39/bcMiJVF09+/fv39P+mFKiTtd/fv3799jgZiBJLT69t+/f/8eDuDEkDJf8+jv379/v7Ryo4qzMDAwMAQGMjBc3/y35wM2V1IfAABFF16Aa0wAOwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=28x28 at 0x7F1C5C044F50>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Show a random image and the corresponding target.\n",
    "img, target = mnist_train[0]\n",
    "print('Label of image:', mnist_train.classes[target])\n",
    "img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aKbXgidhWr6L"
   },
   "source": [
    "Next, we create a PyTorch dataloader for the MNIST dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ay0iiI1kWyMC"
   },
   "outputs": [],
   "source": [
    "# This ensures the MNIST dataset produces PyTorch tensors.\n",
    "mnist_train.transform = transforms.ToTensor()\n",
    "mnist_test.transform = transforms.ToTensor()\n",
    "\n",
    "# Size of the batches the data loader will produce.\n",
    "batch_size = 60\n",
    "\n",
    "# This creates the dataloaders.\n",
    "train_loader = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True)\n",
    "test_loader = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "liekFZzvYX9E"
   },
   "source": [
    "Next, implement a logistic regression model in PyTorch. Note that a logistic regressor uses a linear transformation of the input.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "eFtFvYF3GVRz"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([60, 1, 28, 28])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(iter(train_loader))[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zEw5YorSYkWF"
   },
   "outputs": [],
   "source": [
    "class LogisticRegression(nn.Module):\n",
    "  \"\"\"Linear logistic regression model.\"\"\"\n",
    "  \n",
    "  def __init__(self, input_size, num_classes):\n",
    "    super().__init__()\n",
    "    ###########################################################################\n",
    "    # TODO: Instantiate the layer here.                                       #\n",
    "    ###########################################################################\n",
    "    self.linear = nn.Linear(input_size, num_classes)\n",
    "    \n",
    "  def forward(self, x):\n",
    "    batch_size = x.shape[0]\n",
    "    # Input is a batch of images.\n",
    "    # Its shape is (batch_size, 1, width, height).\n",
    "    # You need to reshape it to (batch_size, input_size),\n",
    "    # and the apply self.linear. \n",
    "    ###########################################################################\n",
    "    # TODO: Apply the layer to the input.                                     #\n",
    "    # Hint: you may use .view() method to change dimensions                   #\n",
    "    ###########################################################################\n",
    "    x = self.linear(x.view(batch_size, -1))\n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HCerRXDHZFAS"
   },
   "source": [
    "We will use the following generic training loop for a PyTorch model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qVyEKl3OZLJw"
   },
   "outputs": [],
   "source": [
    "def train(model, criterion, data_loader, optimizer, num_epochs):\n",
    "    \"\"\"Simple training loop for a PyTorch model.\"\"\"\n",
    "    \n",
    "    # Make sure model is in training mode.\n",
    "    model.train()\n",
    "    # Move model to the device.\n",
    "    model.to(device)\n",
    "    \n",
    "    # Exponential moving average of the loss.\n",
    "    ema_loss = None\n",
    "    \n",
    "    # Loop over epochs.\n",
    "    for epoch in range(num_epochs):\n",
    "      \n",
    "      # Loop over data.\n",
    "      for batch_idx, (data, target) in enumerate(data_loader):\n",
    "          data = data.to(device)\n",
    "          target = target.to(device)\n",
    "        \n",
    "          # Forward pass.\n",
    "          output = model(data)\n",
    "          loss = criterion(output, target)\n",
    "          \n",
    "          # Backward pass.\n",
    "          optimizer.zero_grad()\n",
    "          loss.backward()\n",
    "          optimizer.step()\n",
    "          \n",
    "          if ema_loss is None:\n",
    "            ema_loss = loss.item()\n",
    "          else:\n",
    "            ema_loss += (loss.item() - ema_loss) * 0.01 \n",
    "          \n",
    "          # Print out progress.\n",
    "          if batch_idx % 500 == 0:\n",
    "              print('Train Epoch: {} [{}/{} ({:.0f}%)]\\tLoss: {:.6f}'.format(\n",
    "                    epoch, batch_idx * len(data), \n",
    "                    len(data_loader.dataset),\n",
    "                    100. * batch_idx / len(data_loader), ema_loss),\n",
    "              )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kC3z31pvadeP"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 0 [0/60000 (0%)]\tLoss: 2.334645\n",
      "Train Epoch: 0 [30000/60000 (50%)]\tLoss: 0.430591\n",
      "Train Epoch: 1 [0/60000 (0%)]\tLoss: 0.359659\n",
      "Train Epoch: 1 [30000/60000 (50%)]\tLoss: 0.336424\n",
      "Train Epoch: 2 [0/60000 (0%)]\tLoss: 0.328149\n",
      "Train Epoch: 2 [30000/60000 (50%)]\tLoss: 0.308472\n",
      "Train Epoch: 3 [0/60000 (0%)]\tLoss: 0.307478\n",
      "Train Epoch: 3 [30000/60000 (50%)]\tLoss: 0.299796\n",
      "Train Epoch: 4 [0/60000 (0%)]\tLoss: 0.298112\n",
      "Train Epoch: 4 [30000/60000 (50%)]\tLoss: 0.286456\n"
     ]
    }
   ],
   "source": [
    "# Create model, criterion, and optimizer.\n",
    "model = LogisticRegression(28 * 28, 10)\n",
    "###########################################################################\n",
    "# TODO: Create criterion and optimize here.                               #\n",
    "# Hint: see                                                               #\n",
    "#   https://pytorch.org/docs/stable/nn.html#loss-functions                #\n",
    "#   https://pytorch.org/docs/stable/optim.html                            #\n",
    "###########################################################################\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.05, momentum=0.5)\n",
    "\n",
    "# Train the model. If everything is correct, the loss should go below 0.45.\n",
    "train(model, criterion, train_loader, optimizer, num_epochs=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "x0QN7Mhiar7d"
   },
   "source": [
    "Visualize the weights of the trained model. What do you see? Why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gxletH44a4MX"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "assert model.linear.weight.shape == (10, 28 * 28)\n",
    "show(torchvision.utils.make_grid(\n",
    "    model.linear.weight.view(10, 1, 28, 28),\n",
    "    normalize=True,\n",
    "    nrow=5,\n",
    "))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Lxf5NxQ6a5cT"
   },
   "source": [
    "Use the following function to measure the test accuracy of your trained model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8UYWbqZYa9Qr"
   },
   "outputs": [],
   "source": [
    "def test(model, data_loader):\n",
    "    \"\"\"Measures the accuracy of a model on a data set.\"\"\"\n",
    "    \n",
    "    # Make sure the model is in evaluation mode.\n",
    "    model.eval()\n",
    "    correct = 0\n",
    "\n",
    "    # We do not need to maintain intermediate activations while testing.\n",
    "    with torch.no_grad():\n",
    "      \n",
    "        # Loop over test data.\n",
    "        for data, target in data_loader:\n",
    "          \n",
    "            # Forward pass.\n",
    "            output = model(data.to(device))\n",
    "            \n",
    "            # Get the label corresponding to the highest predicted probability.\n",
    "            pred = output.argmax(dim=1, keepdim=True)\n",
    "            \n",
    "            # Count number of correct predictions.\n",
    "            correct += pred.cpu().eq(target.view_as(pred)).sum().item()\n",
    "\n",
    "    # Print test accuracy.\n",
    "    print('Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
    "          correct, \n",
    "          len(data_loader.dataset),\n",
    "          100. * correct / len(data_loader.dataset)),\n",
    "    )  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MrEY_dy5AKQV"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 9207/10000 (92%)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Accuracy should be around 90%.\n",
    "test(model, test_loader)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "g1DV-MS2bxYq"
   },
   "source": [
    "**Question:** To have the logistic regressor output probabilities, they need to be processed through a softmax layer. Implement a softmax layer yourself. What numerical issues may arise in this layer? How can you solve them? Use the testing code to confirm you implemented it correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Dj4X2PnOfK9W"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(nan) tensor(1.0000)\n"
     ]
    }
   ],
   "source": [
    "def bad_softmax(logits):\n",
    "  \"\"\"Computes softmax in a naive manner.\"\"\"\n",
    "  probs = logits.exp()\n",
    "  probs /= probs.sum(-1, keepdim=True)\n",
    "  return probs\n",
    "\n",
    "def good_softmax(logits):\n",
    "  \"\"\"Computes softmax in a numerically safe manner.\"\"\"\n",
    "  ###########################################################################\n",
    "  # TODO: Change this so that doesn't output nan for the example below.     #\n",
    "  ###########################################################################\n",
    "  probs = (logits-max(logits)).exp()\n",
    "  probs /= probs.sum(-1, keepdim=True)\n",
    "  return probs\n",
    "\n",
    "\n",
    "# Test the new softmax layer.\n",
    "logits = torch.rand((1, 20)) + 100\n",
    "print(bad_softmax(logits).sum(), \n",
    "      good_softmax(logits).sum())  # by definition, the correct value is 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4C_J5S0RScXJ"
   },
   "source": [
    "Because of numerical issues like the one you just experiences, PyTorch code typically uses a `LogSoftmax` layer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oSqM9k_FD8wc"
   },
   "source": [
    "### Image processing via convolutions\n",
    "\n",
    "As fun way to gain a better understanding of the type of operation that convolutional layers can perform, we will set up an input containing two images and manually set up filters that perform common image processing operations (grayscale conversion and edge detection). We use will `nn.functional.conv2d` to apply the convolutions. Neural network do the same, but with learned filters.\n",
    "\n",
    "**Question:** What kernel corresponds to a vertical edge detector?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gDHLyTmlD_WC"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/aims/anaconda3/envs/NewEnv1/lib/python3.7/site-packages/ipykernel_launcher.py:52: RuntimeWarning: invalid value encountered in true_divide\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWUAAADdCAYAAABja2MXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9d5gmR3nu/Xuqu99+8+Sd3ZmN2qSwiiABIploMGA4tjHYxMOHsc2xCcbn+Bx/9jGOn88xGAcMGIxNEMEE+zMHg0g2AiEEllBerVa7q02zk+MbO9Vz/qie2dEi7YpdFLDnvq6+pt+u6u6q6uq7n7qfp2pEVVnDGtawhjU8NmAe7QKsYQ1rWMMaTmKNlNewhjWs4TGENVJewxrWsIbHENZIeQ1rWMMaHkNYI+U1rGENa3gMYY2U17CGNazhMYSHjZRF5DdF5G9+2HkfwrVURHY8SNoXReQ1P4z7rOHcISIfEpE/eLTL8ViAiHxdRF7/aJfj3xNE5HoRee1joByvF5GvP9T8D4mUReS1InKHiLRFZEJE3isivac7R1X/SFUfUif7QfKeC1T1+ar64Yf7Po8kROTlIvIdEWmJyFS+/0YRkUe7bP+eICKHReTZpxx7rYhc/yD53y4iiYg0V20Lj0xpHxsQkY+JyN+ecuzpIjIrIhserXI91nFGUhaRtwH/C/ivQA/wRGAL8BURKTzIOf4Ps5BreGDkz+bPgT8B1gPDwC8BTwa+79mIiPeIFnANf6+q1VXbaQ2Zf4d4E/ATIvIcABEpAh8A3qaq4z/MGz2cffuR5rPTkrKI1IHfBX5VVa9V1URVDwM/iyPmV+b53i4inxGRa0RkCXhtfuyaVdd6tYgcyb+Sv73a8lidV0S25hLEa0TkqIjMiMj/u+o6V4nIt0VkQUTGReTdD/ZxeID6rAwRcyvnWyLyrvxah0Tk6vz4sdzqfM2qc18gIreIyFKe/vZTrn26+hkR+e8icjBP/5SI9D+UMp+mLj3A7wFvVNXPqGpDHW5R1VeoapTLA+8VkS+ISAt4xunqISL/LCK/esp9bheRl4jDu/J2WcyP78nzlETknXn9F8UNG0t52qfz0dWiiHxDRC46TZ1eKCK35s/jBhG55Fza6LEMEXmOiOzL2+XdgKxK8/L2nBGR+0TkV/J3ws/Te0Tkg3n/HxORP1gmJRHZISLX5dedEZG/f5SqiKrOAr8KvF9EKsDvAAdV9UN5WYsi8her6vGny++ynDLkFxE/b4Ot+e9rROSvROTavG8/9XRlEZEREblTRN6S/+4Vkb/L731cRH5PRMyqe38jL9sc8Fv5setO4Yvnrrr+g17vB8WZTroaKAL/sPqgqjaBLwLPWXX4xcBngF7gY6c0yIXAe4BXABtwFvfoGe79FGA38Czgf4rIBfnxDHgrMAg8KU9/4xmu9WB4AnA7MAB8HPgkcCWwA/fBebeIVPO8LeDVef1eAPyyiLzkIdbvTcBLgKcDI8A88FdnWeZlPAkIgX86Q76fB/4QqAHXn64ewIfJP7QAInJpXo8vAM8Fngbsys99GTCbZ30H8Dhcf+kH/htg87QvAjuBdcD3OKVvrLrXFcDfAr+Iex5/DXxORMIz1O9HDiIyCHwW+C1cPz6IG90s4xeA5wOXAVfg+s5qfBhIcf30ctyzWZb/fh/4MtAHbAT+8mGpxEOEqn4auBn4BPAG3PNdxv8EHg9cgqvHk4H/8QNc/udxRmMN+PaDZRKR7cB1wLtU9c/yw9cAHWB7XoYXAP951WlXA3cDQzilYPnYHbj++S7gg6vyn+l6Dx2q+qAb7gWdeJC0Pwa+ku+/HfjGKelvB67J9/8n8IlVaWUgBp79AHm3AgpsXJX/u8DLH6QcbwH+cdVvBXY8SN6vA6/P918L3Lsq7eL83OFVx2aByx7kWn+Ge8gPpX53A89alb4BSAD/dO3/gz4b4AZgAdc5ngZ8CPjIGa6zuh4hMAfszH+/A3hPvv9MYD9OvjKrzjf5/S59CGXuzdu4J//9IeAP8v33Ar9/Sv57gKefbRv9MDfgMNDM23d5awPXP0j+t+d9YHX+f83TXg3cuCqvAMdX9c1/AX5xVfqz83bzcRJVBJRWpf/cqmt/BHj/6vfn0d7yMjeBN59y/Ajw3FW/XwAcyPdfD3x9VZqft8HW/Pc1wN+e4b7X5334MPCzq46P5n02XHXsVZzks9cDh0651uuBfat+1/PyDD7E6339dGVdvZ3JUp4BBuWBNZUNefoyjp3mOiOr01W1zUkr68EwsWq/DVQBRGSXiHw+HxIvAX+Ea5izweSq/U5etlOPLd/3CSLyryIyLSKLOO12+b5nqt8W4B/zYc8CjqQzXGc9W8xyyrNR1avV6ZaznBwF3e+5nK4eqhoBnwJemQ+9fg74aJ72L8C7cRb+pIi8X5y8NYgbTR08tYD5MPyPxck2S7iXAx74eW0B3rbcRnk7bcK17WMFL1HV3uWNfIQmIq+Qk868L67K/6nV+VX1GfnxU/uLcv/nNHLK79X7W4AAGF/VTn+NG4mAG6UI8F0RuUtEXnfu1T435O/UDHDXKUkbcMS8jCOceQS9GqfjnGW8CjjK/Uf7W3AGyOSqNvwr7v8+PtC1T+UkcPzwUK73kHEmUv427qv8U6sP5vrQ84GvrTp8uuXmxnFDqeXzS7ghwNngvcA+nDVXB36TVXrcw4iPA58DNqlqD/C+Vfc9U/2OAc8/5QUtqurYOZRn+dm8+Az5Tn0up6sHuKHxK3CyUFtVV4aFqvoXqvo44CKcjPFfcS9bFzdsOxU/n5fv2ThJZ2t+/IGe1zHgD09po7KqfuIM9XvUoaof05POvOc/hFPGcR8cAEREVv/mlP50Stox3HMfXNVOdVW9KC/LhKr+gqqO4KSC98iDhIg+BjCOI7RlbAaW34kWbsS5jPUPcP5DWeLyt4El4Bo56Qw8hiPV/lPacLUP4wdZPvOhXO8h47SkrKqLOM3mL0XkeSIS5EL7p3HDrY8+xPt8BniROEdaIb/m2RJpDdfITRE5H/jls7zO2dx3TlW7InIVjnCWcab6vQ/4QxHZAiAiQyJyJjI9LVR1Ib/Pe0TkZ0SkKs6heBlQOct6kJOwBd7JqucrIlfmVnaAe2G6QKaqFqcF/2nuTPFE5Em5FlzDEcgs7gX7o9OU6wPAL+X3EBGpiHNK1n6ghvnRwD8DF4nIT+UjnTdxf9L5FPBmERkVF3r6G8sJ6qIWvgy8U0Tq+TPfLiJPBxCRl4rIMqHP48glewTqdDb4BM5fNCgiQzgCXQ4OuA24REQuzo2c3znLe8TAT+M09r8TEaOqx3Aa8ztWteEOEXna2dzgh329M3oHVfV/46zRd+DI8Du4L8Oz8uHuQyn0XTgv7CdxX8cGMIV7YX9Q/DqOSBq4F/mR8i6/Efg9EWngNORPLSc8hPr9Oc46/XJ+/o04J+M5IX82v4Ybsk7h5Ji/xr3EN/yg9ViFj+A09mtWHavj2nseN8ycxfUJcM/kDuDfcJr0/8L1rY/keceAvbh6P1hdbsI5uN6d3+MATvf/UcbL5P5xyk0RWaeqM8BLcX6ZWZwj9FurzvsAjnhvB27BOVpTTpLrq3Ehj3txbfUZnBQAzlH9HRFp4vrcm1X1voezkueA38WR7x24un4H+P8AVHUv7iP+dZxv4Rtne5Ocp16CG318IB+ZvBJnvCy34ad5YGv8oeKHdj3JhehHFHlEwwJOgnisdpizxo96/UTk1cAbVPUpj3ZZ1gAi8nzgfaq65YyZ1/Ajj0ds7QsReZGIlHM9+h24r+PhR+r+Dzf+vdRPRMo4a/r9j3ZZ/qNCXNz3T4iLzR3FDd3/8dEu1xoeGTySCxK9GDiRbztxIW7/nv4X1Y98/UTkx4FpnAzy8Ue5OP+RIbih/TxOvrgbJzWt4T8AHhX5Yg1rWMMa1vDAWFu6cw1rWMMaHkM4p4U2PE9UVi1G5gUBCRlFMezpBGws93L8GZso9Q7wjc9cS5j5RFiMUUIxSCBkcUpaKFCMEtq+Ybgb8v8/46385MG/ZKR/A5c/4TL+6fNfoLPQxg9DMrX4+PRsXkdrbBKvp8rC7BxhwWdoPuHtlz6HT0x9h+mhCt+bGKdOiJ96pDMNtKdEb5yh62pMHZ/B9NTJ5hoQCr7nEQQ+SZyQxAm+52MyxYYemYBtRni+T6aK53kUCj7tpIvneXhiiKKYoBgAilGPbqtLwQ/oduOzjqF+jv/y+w1jTDFEkxQpBEi1AoN9LJ3fS1Q3DFxzMxhx6Z6HBD7i+9goQnwfstxxHwQcftvFbLtmnGS0l4mrSmz+9HF0bgFKRZfP88i2DOMfm0Z7azAxgxRDNEmY+JldDN3aIiv6hPvGICyAVez0DNJTR0TQ/h700FFMbw/Z7Lwrb+BDGEIUYTtdpFCALEMKAQC22UJ8H1VFfB8pFdF2x5XdCLbVwVRKK22RLS5hwpAvtT96Vu277S/eqSuRqPlfsaAehHMGE4P1Ia0pWaioydPNybwAkrrbq6eE84ag6a5XWFTiXqE1opgMVCDtyfAXPVCnT0jirm+6QmHnEsm9dSSFpG7BAxVFMnH3EPDaQlZ0J68uy3IdRO//GwEb6EoZRUESAQNqFFSwRVcR0zUugwrqKaJw6K1vO6u2fY556drw+wz4iv30g7btOZGyiOB5Hta6B5tYpRSD2VTmXr/N0mhCpb3Ad797K75RxFpCDFv8AmMViLsx1giSdFGBPjLOf90TeLX5JMOV87jtX25hujlDoRTQf+mTyCaPYTQi7K8xdf297HjjC5m7/QitZoveoT5KV/Tzy53bKXeWaDe6XFDuZ3yigamEEHh0m23OW7eNsfYcT6qu5+s6Q1+tjBQ8siTFiEHTBDKh4PkkAXQ1IWylqAAmxRrwvYBON6ZSrdBut8nSBCOCZ4V2N8YjJQgCkjg5l+YFwBQCNLOgFk1SUIsZ7AdjiIYq+G1L/RuHUM84Qgt8vP4+UEXbHQA0TRERpFBg6mUX0XPA0rh4HdUv3cGmmU1ouUjz0vMpTkegEPcVKN+wn7FXXUTvgYTKQoNsZIDOSIXB29v4x2bwykWyDYOYYxNItYIUCujiEvbinZiFFuzYio5NYvp7kSBAkwQxBpukYBXxDIj7iGicgBgwBrEWCXxso4np7UEXl9A0dek48kYMJgyx0dlEVOZ9N2UlklwF1FdKJzxMAlkI3XWW+s55VIXFw735OUK4JMQ9FlQQdaSHQDht6K7P0EvadJdCpO2hgeK1DN7WFllqYDEEBVtQGIpgOnREW1KS/XWSdQkkBnyLdDz8tkdWsY6ABdLRCP9EiNcRkh6LFwnW15P1MK5OanLiTk4S+vKHxxYV9dwmiUEyAQu2bDEdQQOXcY1VHz2cEykXCgWstRhjsNYiacLOF17NXGuBZz/hCdxw8HaydsrAhgFGBjZx23dvwc9ga08/zWieBd8Q+AFNsQSx5epfeSn7Dt7K4G3HWWwXedqVT2RudpK2Rizc+V0ir4y3lPCsZsgFL97DyL6j3LNvjOplO7n37gPoUkB2+ziL1hC0IiojQ7QbU6wf7EeiiGaUMjY3zVWXXsSdB/ezTUp0gIW0Q+AFoEqUxPjGp5V0Ec9QCnw2Vmow7LPYaZAWDDbxiJqW5mIDEfdxElWidkSQW3tZliHnuKSxqZQhScAIZKBpQvs/XUVhIeXEU0P692Z4iWI3rqMzuo3yv7pZrNnoIN7EPAQ+JgwhTQE48ksX0Lc/o3q0jWl2aT5nD8WpCJNk1O6YQo0grQ5ZaZSpn74Qv60UZ7o0rtpM7bYJCuUC/p33YbMMlhroBVvJ5hbwhgeRKEbTFO/4NItP3kL9jlmkrweSFO3kFq8qGkXgedhWB/EMUgwx/X3Y/hpmqY36HpKkGM/Dzs65hsgJOVtquo+U6v2I+myhhpNWcipkj2tggpT2dBW/klD4+z5sINR6hNZGZ4p211skErRgIRP8jiM1LwINLeaWGtUEWlvykYlCdKKCFizFSR/UBRynrQDpT0hbPtQS9ESIdD0kEkzs4beFaDAjmDek1Zxk5wuYBLqbY/zZgLRqMV1HvLagK/dDxX10wFnamRsBqOfymK5x+wY3TUhAYncNyWSNkR9lnBMpp2mKWUU8GgTs/+eb6NTgqwfmaFYsZr5NY6rJWHGcgS2jNKem+Y7fpBV36SmERDbmSa96Kpv7ejj8nW9Stx7HDOwu9/HtA/sJDVQEOlM+Gy4ZpHJBwN5siaXr9rJn3Va+ni6yeXwaGzZopgX6NvbT6w3QmJ6ksr5OesQjiyMq1QKVHeuYODBGx1O2BRUGY5+P9MxRzkKyOKVcroInpHFCZg2BZ7BFn3EbEUymdLH0burF+pb5qSZFPyRNEzwxZDZzw0cr2CxzUkh2bpaydiNnUeYQP6DyuZuRMGTb8fXge8hSi/TEBKW9PrJjK0xMY2aW0FbbSRxJwtjPXUB3UBm8PcNkimnHpP0Vat87Ab6HBj52epb0sh1EA0OYWBn+2hidHUN4x6YoecNgDF4nQTePYKsF/IkF2utKlAIf4gStV8nOW4/sd7Nk0/4K6gmFEwsQ1iFK0FoZz/McMacpBAUkLECaImNTaGbRLRsgTrFjE876jmPEM46EweVJE0yphHY6Z922NgCTOrJaJqbkaAXbFkxFkVmfmSsUG1r8hgGjqAde0yAWTMOQlRRJQKzQ2pZhmh7tLQlYIZz2SEtQWBCiQUs44dMdTqGUUToQUljyyYoetgC2UyCrWEzboIFii0pUtkjqLGITGWxBKSwKaUXxFnxsqM7CDd3HQmLBxM7SlVQwSW6Ri6K+2/ebhqQ/w2AcUef1XpY6JJMVq3wNjx7OjZT7AiqtAu2szfDmDVRVuC9rITZFOwuUt46SbC4j9yo7BoZom5iwb4SiXyQ90mRTVmC/l7H3o//Kk3c+hVujAvfOjlEQy97tKUPtKsdvPYaKR7e3wIm5KQa7JZL5Of5H72XIzhHaoyWaHcu6dBet47NEpDTtJFoX7jp0D+fHMKYdglTJ7jhIsa/C/zlyBxsyQ1LyuCit0NWEhX6fhU6bYhSRlgy9pV5aiy2kbfEDD6ka6BjGD09Rr9bwPY9UU4wvqLWu8wNqHXlkmQLntu626ak58upGyO7tqCeYxRakGXQi4q1D2PU1ip4h2TjgCKt3M7ZgCA8pWi0jCw1GP32ImedsozQZUzg6A8aQDVfRrUP4N9+DhCGmUiaYWMTrlPHmmsxdPUJjk6G3dyt+25KV+ikcXwBVvCRFKyWqd06g1QqSyzT+XdNIbw89Nx6HwEd9D1svQ2qxtTKm0UbjxMkZA30wt4h2u0gYIpUy2mrDvkPIQL/ToK1d0ZmXoVkGYpyUcw6WstfNrUv36ByhAfFQRjDn4UVCWrGocXqyLTrtNytZNLdKK4d9kprC7gb+oSrJQErpSEB3yBKNJkjbozsCfsMgKXgtD5sKJoXs8Q0ESCfLqK+YrnGab5xbqiIUZ4T2BovfFlIg7rNgBYwiieDFhrSeIZFBfUUiwXogqNOqI0F9R7LhjEfcZ50lTC7ZeO7DtPyb/NgaHl2cEyn3+QUapovZWOVVSxWWhsp8JQyZbzTxBzIiXSLau0RP7wBHW/P01cvEC/P0tovUsgLlK8/j0hMzzIwt8NGhSbK7jrB7eJiD903Q2T9BKwioJ5b1wwPElSqhn3HfzHF2XnE+f3jbbQyPTzETtckmu4Sj6+l0F6kUKkw1IzbsXs/GdRsY7c6wGEb42zZQaitTtx/gx2sbGdowxL+NH+KwLCEF8BaFnT0DjKdtglaMhpAkKeVSlXbagdkWCngiREstAgSrQpKl1HrrdLpdgsAn7XbxPB9rLXGUntPDkUoZnV9ENm6gO1ojLRuK00X8+TZZNUSsUjw4he2t4k8tkQ1U8efbqHH67MLFfZSmq4THFynNpgRTDaJtQxTuPk7x0DTqe6gIbBgiCwM0MPjHpmk8YTP9N05QnhzAb8T4Mw3ikV6k3UVLIczOk1ywmfaFvdQONTHtmO5oHbHrCG85hN2xkfZoierdc5jZJUfQRkiH6vgLS2g3hWoZkhipVtFuF51tOU1cBLuwCCJgDBrHeEOD2GYLUyyi7TYS+O4D1GqfuREfBFnJYhJHsuu/aZi5FEpTQpR4pNu64GfoQhHJhKxqIXPEjRUKk0JSV1pbUnpHlmjf0UcymFHdH9DakjlNNzKYSPC6QjyYoeLhxeDFhvbGDF1yy0R7XSErO8JXXzGxk0SyotLcFbuyRgF+W0g8IWgYovUJ6osz8CPjrOIQkvUx3kwByVzz2YJiEkGA7kiKRMbJFKF1H4HspLNQDUiuuHyfE3ENjyjOiZQ7aUyolp2jI8wMGtZtHqZW6eOCuMYtU/to33kIPGFqZoowFpJ5pZkp9/pNhkpVbvzmTWwthhxvJZynW1iolWgPl9Axy2CzwIawzs19KbNDJaYnx/lPP/4slg6klNUjEo+jEw2G/QpjQcbCbYfp3bqJ8mLKnqc8BU9jZqbHuH1HHzo2w/HbDlOv1rlgy27ulQWub+6lU7MMJSGdbkwKzB0aJxiqU16MmFxqANBqtSiWQ7o2QgHjQZZlGATjBXjGI+rGiApihTjJMJkFBeOf2zhQuxEYob1rkKTq0Rw1dPo9skKJ3kMJpbsnwDPI2BSo4nciNIoxnkH76vR+6R4Y6IWZObILB7DVkKTmEwZOP9dqCVOrkpULeMenOfHT2xkMfawnoEp4dB5bdxEP/vf2Y3dsRroJc8/bCQrl6ZSsXMAstineehj6ekj2bMXrplT3ziJphpaLSLuLqOIfGof+nNznFwGwi0uYeg3baIJV8GRFqhDfRZBoq+30ebVoFDnHIM4JerbwOobyuJCWDeY1E/R8Zpi5yzLnHBsvYkXxrZCF6khOHemJQHdY0baPqSYs3ddLsKuJTJRJr2qgsyW8hoctWtSHrKj4Sx5qIB7OHXkFSzAZOMs4FUwqSAKVI0J5yuJFSrffIzkWsHCBktYzskyQRIiGU7ymhyTidOJAV7Rgb8rJIMsaMSaPvrCC6RgkdfKG6RqnJ+eyBQp+y30I1HcjPq+7xsqPFs6JlPdsGqH27MvYdnCSr83cybZD0+zvM4StISaOnCBo+IS1CvV2QlDzWewukmUG0w8nJlrUsx4OtyJ2PXMTnbExorbP7O0TiIZMqDLXnsOvFJHI8rKffCGfveYzbLtqC/uvv5N6bYjnv+5lfOJdH+Kq5z6P33zmq7nqRU8lKigDhQLtQCn7ZRrTDap9NY7ddS/jY2O8/9MfY/HoraR3z6FFg/T1kM0uQStioh5gFhqE9Sp0LZopnoJEKVYFMQKeIU0ifE/IktQ5nbIIVcV6KZ5XQESxNqOvv++cHk584UYmH1ek0FD67okIFwxelJGUfUp7xx1Z1augitSq6GLDhbQN9KFHTzhN9vg4nWddTHm8g+kkVG8fzyMzuki7C8UQSTKO/fx2Rj9wB9GTdlO/7gDa38u9r1vHrj87xOQLzkNfUuCDez5MIJYRT8lQ+kyJO+KEXYHwwcWdfHN+B/d8Zj199yRUjk9DIcAO1PDiBDpdFy43PQc9NfC8FQekRpEjZCMQBGiz6coeRahVJM9H5OUhcgbNMsz6dadpvdPD7wjNrRYTCycOD2J+rIsuBQjOYkVdFINkOALLwCy6j4DfcBETNIrY0BK3C5hE6E6XVsLPvI6zRJOejPJwi86JKt6ijxrwZzwQKI8LwzcsgoHF3TW6/YbZiz2ygiIWqkdh8HtCcQFK421MlHLw5b0kvRle03MyiA8mESdHGCDXhVEnm2TFZU+mc/QtOwCXnXnquf20snzAnW+DNW/fo4VzmtH3M5dcql9K7mVDqcrS0Sby+E303TfHscU5fq64kX9N5jncSShnBlNS1l+5jcft3sWtt9/Fa0/U+OiWhKmjk8xJE2+si7cIsQ9eqcDgUD9L7RlKQY1WowtGCSKPAKVYLJJInWs+9D4uu/wy6v11EMVbdoqtrpPJNTR1oUFZmrE4u8DrXvv/cMvttzG9OANFj1ANzTRiq1dmxkt5jWxkPWX+VA4wk3YpRmAzJQM8NWhqwXPWmzGGOEkQD0whRFOLtYpRQ5pEZ20uP/0n/reWDs2R9Vfwj83QuWiEwnQHb3yG7kUbCY/Ow8w8GEGKRZpXbGRmj8/QbQlRj0fQtlQON5BuAjNzLpwMMOUyOjqMWWg4OWKp6Qgzs+5a5RKIUPpwk/+28YvsyV/QUHzsKa55k8djWRSDEGnK7bHHW377v9D/nUl0csY58zzPEXNPHZKE6PxR0rJH5fYTaLPp7p0kKxKGpqk7Jw+fs1Hk4q/D0KXl2vKXo4+dXZzyx/5IdS5EA0v1sE9xWpnf48i4OG3IQkh6bG5F5s69Zb9tTmLxYIaUUhcVkWvUJnb9LO1L8ed9/LYQ91lM3g2CprDhWxEIzO0OaWxTF4Z2itPtflhxxMH6G5XqwSaTT+phaaddiawAZ+2mVcUWLF7HOCfgsvNuOQzZ6IquvHy/ZenCpOKkF5zz8uCv/9panPLDhNPFKZ8TKZ930YjWLhzkvwfb+dupGylfvpXPv+9GvEKVJz5tC4OXX8b3vnMtg7Uaxf0dogo04ll277maydAwPX2cbZt2862PfIH1mzcxM7FAe7bB1Vdewi13H3DD8dCnFcWEPRXWVddz9RVX8bZf+1UuvPRxhEW7UhbFOgkhd5KsxG7y/RE+AqTdFDEBn/qHz/HLv/BKWn5GMYHaQA9xq01SUNLAx2tmdLOMSqWMAHGrSxqlFItF0jRGFbqdiELo41V8vNDQbnQJTICoob3QPmtSfu7j3q6NHVXmLvQYui1lYbvP6HtvRUpFFp69i/ndhvXfiYl6fcqTMbZg8JsJM5eWkQzK05alLR6jH91Htn0U/8Qc2eQ03edcSvnfDkMUQSFAmy1MXy92qJfJq/t41htu5DeGrqfPnJyssZqMzfexxvdjyXYJxPD0W17N8KunT05eGR5EGi1HuMY4iSaKHFkD2my5ELpqBXKZIms0MOUyUi4jxRC7sOgsZuDa2fefVfue9653qnPgWSrDLVpTFYJ5D0khXpcSzPrYgou4qJ+3wMJcBW+mQFbL8GoJ4Yx5i8MAACAASURBVF0lTApRn1IeFxb3JJSOBCDQHbKIQmHOEO/swGxIecwwdEtEWvFYPM+nucmeJN/lpj1dTZYJW6GwaAjnYMN1c+x/Xa+z3Is4rThyERwoK5EUXiT3c+CppydjmgXwFK9tVmKeJXNpa5NHHj48bJNHorpHgYx3901y+9gMvXemXPaCJ+NJyE1fuo7o+rt58jPP58LLtvHV7l3sDEd4XHMjn7zhZtT69BFxrC1c8GOXsf+797B1cJCnvuwnubNzgs4dd1JOlCc++zK+esON9A7X8W2B3/it32TPhedhDej96FZO9nHVk/Gn5tS+7hwkQdEjSRN+6qdewIffczXfve9OqmpY1C7lviqLc/NIaskQ+r0Qv6dGa6lBFEUUPJ9uHJFmCSIeXiEgVSBTjLWEoU+5XKLTPvuQLQBb8hELpUmldKKD3w5ZePElqAf9X9xP75eVuZ/YzdweYcMNPp0BD5WA9f8y7SSKQoAX11h81i56v32cdOMAx16zhdKMUvpmF41jFl9wIX1fvJtsZAD1DD/3K1/mTX37MBTvV5bVFvGZCNqi1E2RjsZ89bIP8ZM/9lbqt4yvxCBrXx0mZsAzTnqplF2c8kIT225jwhDtdF2khucmipBlTu6wAVIunYzWOEvUDwitjZClHtlED7K9S5oI0hsjCwW8nU30vipZX4J+rZ+6B+31CkaxCwXaOyOK1Rj/thr6zHn6ru2lsw6iHV1krkCw5OKM/eNF94GcUGYvDmlusajJTlqrcL/JHQ+KVdZF1G+J+yAr9bPjk00Ov7DitOIkn42XOOMkC11501Dx8hA+jIKVldl9Rl0o3PJMQRM7a3ktCuPRwzlZys9/8/P1q9fcQOa32H35JjZVB7j0exN8aovHZVc+g1tu/CbV0YyDNx9hON1Ia3aeWr3KuvM2c8/YbfRurDJzqEHa8Fm3pczIzg3EWArVAge/cTc7L9zD3XsPUCiUGDL9fPzjH+eCC84nCJwmt1L0fM6rATccW1UnWZ3gpjvlZG5BM2yaIp7ha9/8Di9/6ctpNxYo95VYijP8TOkzBZaIGdmxhbSbMXX4BKkombGYjof4CTbLGN2wmbGjY3iaQBiQoEgXEpuctaV88VvfpaPX7AOgfdV2ugMexdkMv5sx8YQi62/s0hkK6L1pwskQ0/PQV6e9o5/KvmniTX0UDk2jzRb2vBGWdtaQTEnKhsFvTbB02Trqt05BWCCrFHj633yX/9J/K9XT/APpU+UL17zygHkslq6mBHi8/siPs/izJezsHGZoEG23nTRRLqFRRHL+Jrwow9x7dOU6GifOok4SZPsW7D3u3wBKTtI2TvhK+smzat+tH/ljLd8d0llvsSVL+YhPe2uCt+RTnBWiXmX0inGOTvTDYkDphGOpaNASbG4RTZTR0CLFDDNVwNvUJl4KkcBCw0eLlmDWJysqxSnjJpH0r5oLvWo24f2a71T54oGsabsqOROG/02Z32mIexVbss6pl+dRX7E+4LsIjxW5wrISLmfSkw5BG1pH1omsWcoPIx42S7k7s8DGiwYY2LyD791wC8fa46SVHtbNWk4c3cfjdgzzzS/cTkmKxLUGjbDF4KYat524iaBrWDzeZrBviBPzk3Q6htmpecbHp9i1exe79+zg8IHDXH7RxTzx4ifzlje9laGhQUTcmgAnhTZXFgHH0qd2B4vz2qtFVfLzc31NBWuFqNPhovPP54MfeD9v+7W3cGJ+nHoQ0ikZ5qIMu5Rw9NBRknaMyYRarc5Cc5FyTxnPD0nSmBNzE/gDZYJQSDTFU6hkZx8dABAuKPHFW2mOFhi47hiVLCPdsg71DLWjlrkLQjb8n6Ou3sUC2IxkuE5l7yQkKcHYAtlwLzI3j2lGlCdDwiNzLF06zOLl66jfs8jC44eZvkz40M/+FVeFiuHBCfmBYLFYIFPFYjEYvHxCUaZKopZJa3nD+ut4+9/9JOW3bkFPTK3o1hrF2EaTYN8x9/FQxevvI5uZw1s3CL4HUYyOTeANDkAxdHHaqhhz9hECZrpAa2uK6Rq8lqG9K6JyT4gaaG1LkNRw5OA6JBWXvinFaxu8rhCNl13UROwhCz5pLYPjZcKWoMatXVE6EpBWlNGvW1rrhMVdufV5Jqv4VJJefRzuFzEBToqYuVjovVdpWiEaFLwuYCAt5fqw5q+G50haEqd/ex2zQtp+y01QMXnUxbLDcg2PPM4p7uXeY8eYbU6xsDTLlXuuIGsIaVbiJf0X8zvxBdxz3xGiQkBLLLsffxEj24fxSyVGBkbwtUTmKd1ihz2XbqFS6mOwb5jdO3Ywdd8sx46Ps3Prbq6+7Gp+/7f/gKHBAdy7nlu5+QosgvuX3Cd5WtwEA1XUWmyWgk0RzTCqiHV/QRG3MgvFsES9XuXJVz+Rq666ioHhDZQ2DVD2PCrtFDIhanfxPQ9jhEZjEYOH8YVWu021WieNYmd5hD4S+pTqZRJ7bjP6eg51CebaFBcyFp+40S3akylzF5ZY2GXovTeGfLbbzFWDpOdvJi17JKNubYx8DjjRk87H1op0BgO35sV9DWqH2yyd38v0FcJNr/xTHh9mZ9SKTzrzEiyWRDMSzchWjUxsbsatPjZkhB3BEn+847NMPqUf3TRMOjoAhQCS2Fm9jSYEAeJ5ZDNzzkHre+hSE+2rYztd8NzsQwoB2lN1U9DPEmIhmPewPSlZLcMsBLR2xKQVpXQ8gAzCKZ/6vZ5zmBkX9xsPpW6Yn7iYZXDWqtcV4s0x8WAGnsvbtxfmd/ks7taTcb8PRsiyasv7subrWGhuSKxEWMjytGm3n1aVpa2C34HCvMEWIO7L8LqyIpOYyEVoSOzKKqmQVezK9GwvEvyWuL9tl7aGRwfnZCmP3TPOYL3M9B0zHFsaZ2ikn8LzdnHtv93BBw/eTP/werZdVaQ7U+fbX7iJUk8/dqRKY/EYtqLU11WIGxHzk8eZaxXo7e9BvJiFqSXq9R5++j+/kl/8hTcggeMYu0zGK8j3raJZSppliBiMMcgK8UbYbNmrbxB8bKYkmSXLFM/3MRJgEEphgd/93bfz2rf+CrfdfTPajNg2NExrapxSuQRYTAnEFmgttWnPLWGtMt2aRIAw9liamMOUffyqYBfic2legr1HYKCPyt4pdGEJNo8w8YQaffsiBm+J6Gwos3jlCOFcyuA/3oUM9KGjffhzLbRYIF1Xx2tGFI+2kaUmwVDJDS7GZ5D+HsZfEHDLs/6KshROS8gWJdGMSN20+mDVTMUMpasJFveF9xC6mtFWJVEIBQri5jb2e11+8S3/xEdmXkTPzeNoo4lu3oAcPIaUy27er+chVrHz89jJaSdFHTji0qwlO3Afplx2jsk8lvxsIFtaZBNlzKKPZJBVLdLyiQdcUHJxLKC7KSG4pAWH6xQnfFQgaHpYH6KL22TNANN0bRGPxBSOFwA3IWTkW10Wtoe01+fktmqdjVOxsvLcsr0B97eWvWWz2G0rU8NXzYdOeiyibuag+kqw5JFsiJGm7wh51T1c7LUgEStyRnZ+EztWJutPCEoJZmz1P5JewyOJcyLlcqaYcoCECRuvvoCLt5+PPTrOpssvpdM8zt4b7iJIS7Snu4T1IgPnVRG/SbVQwC/30Z6LSRctUb2Md2Ke/Xfu44L16ymXerju899k27YtBKGHJSXLjXpBXUwredywOls5swmSxXhBEWsMKYJqiqhHljTIsg6eCfGkQoZPiu9kkAwS6ZKmzuoaHh7m7W/+DV762lcgFUNnU5GoZekJimSNNrqll+zAFPXBGmhA0u0QdyJsAq2FJsYIxJb2XBPNzm1GHyJoOcRKkcaVG5jfaSjNKDOXhpQnAga+dQIAOzGF9PXS3TaI+gJSJa34FBYiTKODrZfR4+OUbzpMunMEahVe8g/f4mW1g/SYEpk6Jli2hJ0zz+KvIt+EjK5aauK6zLJckailYZW2ehQlIxTN5Yz8PIVIlZa6855cOsgX3nSY5BU+UqsS95cpHPXd0qCNBqwbQA8fx9uw3o12Oh1ss4UmSjY9g3gemqZk0zNuqvVZIhsvUx53S3TGdcgqFq2keOUUOxvSHU0gFaJ9PVBUkl1tgiCj1Q7Qjk/1ljJp2VnEmYK0CqRVZeAWQaxy+AWFlQWAgO8jZLHfv6/CyvKhQB7uljtPlq1yC5LkfGyWLWdFjZDUlNohsIEhqVsKJwpkBciqGabjpBdRJ2vYUuZm9aXONM/Gy6gPZiEgWwzOdYWANZwDzkm+GN1apB1HjDzlYv6mehEjukRhusFH//4rfO8r+5C4Sv/gEMVhj6TSZeruMSa+Psbopt207xlHD88wumUDOrnEzqv2UAhr9PZt5tMf/DibNq8DSVGbItY46SHv2WKMW1SFAiIBguJ5SjtRupkixkdQNMtIk4QsjmkvLdBsLJKkXTKbAEqWpSRJRJImxHFCFHWxmnDVlZfxS69+A7s3n09jaoGhYojtzvPkLRsI5pp0Uktzuk17Zp6k3cH3PDBKZjPUqnNwZyninZsul+0YRdoR01fWmXgi2AIETWXjB++i/0v3QmZJ1/dihoegEFC8e4zCdXewtK1I6eAs/vFZOjsGMTOLdJ92EVIu0h0KqX94kRdV9uMhJHryv88vW8sGybVhtwEEeCxYQ1szAvHwREjU0laloT4HkwEOpz00rCHJCairHos2oKU+C7bIXFYmQ/i9Lf/EvW/cTOuCYQpTTaS3B+10iC/fjiy1sJ0O2fgE2eS0k2wKBcQ4WUqzzI2M8nWjzxa2ZIn6lNZGy+anH0VKGSQGOVbCbxqKYwGFWY+06hyB5miJ9GAVbzKkeMKndVFE3GeJ+zOyeoZJ3ESP1qgwc7liAx54qvL9pAlHwLag2MDNprMBK0trqu8kOvUUDRxzq3HrPKvnpA2TOilFMsiKlsVdSv8+S2HRoAYKi+LC3YqWrGJJq26xD6/tnIE2tCtWvKzSq+Uc7Yk1nD3OyVK+pKePbn/A5Gdv4k+eX+drf/1V6gWDeD5+JyEejqlsKnH4noQg8ykMFBi+tI/BtE5j+ybqQ/3c9d07sYnlUPMoz33843n8RZdz4RVbAcXzhCSJKBRCtzSoKEge+mbcYuFKhtoOnVYDYzzarQUExWYxqMVmzoLuNpt4BUshrGGMh7WQZjFxp0OlpxcCQTUDmxIUAt785jdz9TOexkf/+ePsv/tmZu6e5NbjUyxEbWp4NEyKSQVjBGMgKHhE3QxPDDZL8QNDubd2Tg+ntbFEoRqw/stj2MJGNnzyHhcK5nloFMNAH+0NJaq37gfADA9hH38BWQDtHQN0BzwGbphAu12K402mnrmR+T3KO0a+BEAgHk0bUTfFfCxi7kfMyxZ0pAknsoyCKIfTEPwuXXUWYlcNXfU4lgzQ67UZMG08cZNsWuozndXYGcxSl4hM3HohPSbhvS97P+980o9z/PNb6d+bUNk3RWHvcbK5hZUF8DXL3AdWBMLQrXvhee544DvH31nCaxrS0QjjKfMf3YQ+OSVY9AiW3LoW0XkRLPkEi4akpqQVuzJN2Y7ElO8o0R2yFBecrBEPZsyf75bElHwiiCNdx8CnLkCvHuArWswQ38JCwS0H6tl8woewrAmJSu4vcRESanRloXq1bvq1LGvPodIc8Ri4M6Ox0aNxnpsA47XNiodbzaoJI7HTnd1U7ZOKyP1C9tbwiOKcSPn6rqEQxxRHerj+a9dR9UKufOmLuP3zX2W+0yTZl3J8/D56Sh7rtm9kYnyOA/cc58jEDH3rqpQbysuufBb+bSf4h+gAXa/A+osupRilSMmj2+kgWKK0g+eFeL6HxaJqSNKUbneWhYUZ4u4SX/3SVzh2YB8/8aIXs3XHBZTKdYznrIHW7BTtxiLVukcUtSFVokyJ4xjB4scxlXKVbqdNFDVBDZ5f5eILL+bV9uV85p4jfPuKFn3zHqUkYOy2g4QmwBpxLeg7S0WMe/lKYUgqGY3O0jk9nPKJLmKVZEMfG64dR4pFjv30JjZeO4NZbJIdPkZ9sYH21El2jVI4Not3670MH+4h29CPF4eceP4I9aMplUNurYnK9kUSdZbudOYWiW9lbSpi8hl7jojbmjGReeyNNjCR9vDn3342pcMFdj3nIC9dfxOj/jyBOCq/o7uJw91BthenmMqqFDWhbUMWMqdLLngFRryIyazAVFYlpk1REt6w8Ru87wXCwuQmuHAdJlH81gjmprvdynFZ5gg68F3b5paxV62gWXZOmnLWn1I4GmJ9mH5agjR8/B0N2jNlZ0nOusgZNXnsbuD+FqYM5nCJrOQs1PU3JsxdEAAe0UiysuiPFhTSk4sMraxfnIoj43IKkQeZ8J6nf4yvLF7EnQsj7L9vPWQC+QQObH5/AS3oydh8zSMklsk+jzdWC40dGc0tQu0Q9OwXFnfm4W6++2CYPLLC+iet8ZVoi5y7rVmLanu0cG7/eWR8ibmuR7bUJCtaWp5y4+euRQoe2y/fyb6b7uZxpsL6JfhKZ5FaT4WtO85jtjnNiaU5frawnW8e/C7RUIGR8iauuPgSzh8exoY1xCZkSZPAeARhkSzu0uw2iZOIIKjQWJzhthuv5x3veA933jOOX6mTNOeo1DZT9Uv0Dw2AX6ZQDMgSCIM+ksxH45Q4miEzysL8IkcOHmXDxs2ct3s3vl9C8EniOeIsw6bK3OI0h7yYXf07+ere6xnZsBlTdpa2pJZUhHJYo9NoUjYekWREgeBHkJ3D8BrAn2kirY4jn0KAirDxc+NQCGhcuZHqt1OyDYOItfhLXbK+Gt0LhynMxwQTCyzurDJwVxfrC63zepjfozx1/XFqJiZTZdE6HbjHCA21nMgyFmxIr4nYF2/gTw48l/Kf9VK85QgXVqfRRpO7aruoP63DZbXjlE1Ev9+kbQv0+W26GrBgy8zFVQD2dTbwjbHtXL5ujFcN3UDNdPHEMpdVidWjZUNOLNWpd5TGqM/6Lx0n2jaEnzv9FBdzbkol7LyzoDXLXGRGqmDPPkIgPB6Qlh3xBFMBWUHpzJXc5ArcxIp0KKHQ0yXqBtilABN7tHfGEBuqw026S0XGXpuSLEHpSEA47pNUFQ0dISMu7CyrWPAtpG4xIkSRpu/+k8mc4Vc/8zonXRQUs2oKtGSuHDZfv0JSwVYyNwOvmNJTazM37ZYYkLbv4pCNc2+jLg45890HIQstXtO4ad89bglPt8aHWxBfPShOGeIevd+C+Gt45HFuq8SFlnCiSaeqPPHHLuHm2+6mNd3ERHDvzBKVWg/pVVfx8W9/naHZgGZnlmaq1PqFzcUyf9Pdy8bFmEa9yFN2Pp7NGzZywZ4LCX1DGi/RXGxSqlbBFCmUMtLFNkZ8KqUa7fkZnvu8V/G8F/4Ct33vTv7lK9dS8jzqfVVGNu2m0lfF8wM8AwsqoJZumhIWK7TmZrjj7r188dqv8tnPXsvbfv3NNKMGW7ftxDeF/8veewZZmp33fb9zzpvue1Pf2zlMT46bZjM2AFiAiwWJRRBASyRFkXSgbUq2VVaZplgulWVbsmlbRVslskjRphhEkRaDKZCACAIgQITF7gKb8+zEnp7pno63b37zOf5wbvcsZJddnq7SfpnnU09X1/Tt9733eZ/zf/4BVyq0zGm329x16g7+i//k5/jFX/mfmKg26WxtkwwzwmZA0jeUHYfBcIcUzb0fvIf+W1f59L338XW1TXm4r8trF329PiIIaD11lOZ312GrhclyKhvbMFajdXeNya9cAd/DDCLCpEHWDCnGq4y90UYYg/Yc1j5YR8wO+U+nv8aYzGlpxYVskgNOC1ek1KVirXBwRcGcMpwD/uDO3yL8Z4J/uPFh/vSZoxhXI2sxH2++xSnvBqHI8UZbKm0kXV1iSvV4J5rnj6/cg/yLBjO//Qbf/K/vYvuhMp+aeo1AZrgiR2F4azjPZw+/zrd+5hj82gzFRA1vvYfu9VCTE5higAgC9CgSKn7ybsJ3t9j4yAylLY3Qt944iuCmiCIbK3B3FMaRyFSgfUPezBFDRbZdRUiDm48oZUNFONenv1kGZcgGAbW5HoNeHWcgML7lARt5kwfsdBWWJ4fN61OWoiZTqF3VOJEhHpNkNUleGuHMjhV0GGWz+XY9LpyBQ+Eb5HxGXiieOPMu33j5NEYZtMdN/rILvUMat2epbnnNWEy5biOqdm09jcBmC/age2eKX0tI2gHhlf1x7G/Xrdf+JuXCwQlq6KjH8vkVqn6VdtpFx5parUp7u8+3v/0MY5limwEN4RNFCauX24gCDi3OUR+vs9FvU3MCfuSHP4frSXrtLUqhj+M41BtNdGEwWYzRiqDUQFBheu4EuTLkRnPmwZMcPNzgwhsvc/zUHVQnZ3D8ChiJzrsEYR3XdykjkK6PmIDZ6SHLl9epBpP81q/9BqfvOEY8PUOzMUHUT/aWjFGcYIqCsufjG4eol1ASVbIdKEyPSGjcssvd99/F0sUlZj56hH/80jc4Umry+kZ7f3fHWMWbHgwZe7ePKQdwI0dHMc5EE72+xcSfD6yHRK+PcF0YxribO2A0+YkFtK/w1noUAXz+0V+lKgvOpQ1mnB6hSLjTE2TGYWgKMqOYU0Nc4fBkuI4avT3+q6lv8qlPvsKvrn6En5x5lgf9DerSAxz6JmPe2aEpYzSCUBQ8XL7EO5Mz3FiqIus1Tv7KKssnx7jRGOPu0jJX00mk0GRGsR7VKLQk94XN6Bta03vd6drUESGQlTKdR89Qe2eHnQenmf6LVevNvLxx6+/dHIw/apCRJGsUqIFdjslYwijJQ4+SQArHTruy55CeryFKBr8lyUsG74UxiinBcKGAAmsINJR7uLJ2rSeF5CazIqtqjIK0AV5HoV2DM7RWn9q7uSRUMWDs6xDG0u1kKnBfLJNWyjzrjMGCnd73PF8MdmIOCtISkAu8lrK5fqO/URQW7nBiiA6mmHqCc6lC3nagoolO3nr+4e3aX+1v0feBA1xeH3KPu0gmErQjCHyPjRs7xKWUuckG15fXycbLTLpjlAmQ2x1qpkw6B5vtNn7X4M9VaYZlpMlIC0002MYPZnEcDyEkedEnG7YojMYPS3bRhQNRwmAYEZYCKuUKDz3+JNp1EX6AIUeaGEmF+njJYnIGhFQ40x4H04if+PEfJY49HrzrTmK1Q3d7HWU0FBlxlJHkGZeXl3nn4iUSWeGDH/skv/+bv4UhRiuoV6okviEXORcunqdUQHt7mwMHZohvxDj7VEVtPTpFZbVBWlV7Tl/l0lGca1sY18GcWITzy4iJJjTraFchN9sI30OPVXE2LKat6yFZGQoEPa1YyiYZVwPKMkEi6emE1cKjQDKtvD03uB0ds5o7zDlwyOnwSwc/TyAklZFRkUZTweUeL0Vi8WhX+FRli+2J1/j7P3aQ4odneOL0eRpa8XZvFoDMKLbTCt3c56XVA6QXa4xjWH6qyqF/umJ9LqRETU9ZgjpQe3MbpKC0mREdncDfiqyz3C2WzKG0ZhtUERqKwn5tRSK2qeahxWD9DWXNiaSydpxjGrctKXzbsPOyJJrWe7Q1vAKdSdSor6lY7vGBtfMeC4BdlZ0CFVlpt/bM93kdaxfELr9w9G9nKFAJlFc1aVUQD33SMUNeLXC6NmwVAziasBaTpQ5qqiBbL++xP1QiyMYK8hrIrkOcSpS6qeQz+vai7/2qfTXlQ/MTiOkejWCO1tLrrK/kHD46zdRCnY2l6/zAk48QDVJeO/8qtXrA6voWT/7Ix0H0iQaGuNvm3BsXOT21wJFD80TdG6xurDI1vkiWpYxNHgFd4Hs+Hk2cwkHIAIFAGAfpC8pS4SrHTlcYK/E1hf0QaIXQQ4xyMUIiHQna4Dges3MHuO+hhyx+qcDLfUq+S5FG7PSHCCNJsoxLV67y6//0n+GVAl595tvUKxUyL0BjEKELehsHh8H2gPs++ADf/Np3ac7VKfkh9f2RL+jPC5K6R16GyjVD+UZK+3gZ50CJ6pUByx+v4Xz4LsbfSknrDuWVmKVPH7I3NrL0uYnXI3qLAenBhAvpFM/2jvFg5Qo9HfCQH5MZqEsPV2QMTYorbMOVCBoywHUSfOFSd3ZZGaNU6T1Fn8YfcZd9YY+8oXD5WLjMO3e8yITbwxUFQ+3RVAN6OuD8cIbCCIa5R7JU5eQ/uYoJA8a/NsA06sgwtBzlwEMko+DYrRY7Hz/B2J+8gTg4jw49RLN+y9c2mc9QLReVgL8tKHxhvSM8Q2lF4fVgMAfZdEaeuHtxUE4kyLRAuzYfz7iGwbxB13KEq1FrPkTungIQzZ5dplHW9GfX75jCLobT+ujhsuvaNvr6pn8FN3VSo6ae1gTdI1j/jZEKTw1sgrZxDSKRhOd9otMGse1RCGBEuRPGQjYyltbc3rcMj6KWI2KF01Fo97bJ/ftV+2rK25fWMFe3ePrJQ4x/9r/kC1/9Pfp1n2/90deZKEsWmhOMHamy1bvIwrEZ7q/dT6uX0et1QXsUZBw7sUAWGz7ykSdYv7pClMWIuZAoz6mLnE53C0mGwiBUANqmcaSZxnEcXM8FU1BoS2czUqCLHCUEwliZtc4ypOtgCgekS57GmCJj8dAB1ja3GMQZjeY41XKJQWeLGc9he2ubkuPw+IOP8nv1P2Zp6Qq+71FkfZRrj4lyWODVQuLIIE3Bm69cZP7AIVaWr+MISw3bT1WvGcqrKVefdql9cJOtr06jPTj4uyvoRoVkQhPVc4KWS++QYP2hALcPbg92rRtbp0o4ieFvPvANvtK+g05W4qP1iLYOgZiL+e60aZd+mSnwhUPfJITCoyaDPUWf9bYwJCbHFXKk5tMMTEpZSDIKXBQdnRIb+Gz9JZ4dHmcjq3FveJUDTosL6TRj1SEv9w8SOimn7r9KMTGGeesCchT0iuta6mOSYUq+NeMHGi9soE8cgvNLSKWsWdEtlhgq3EN94r6HSnzyMwPytk94zSGtyY3SSwAAIABJREFUG+IzMTp2UC13DzYwEuKpAqcnCbYEWdUuyfwO9Bx3JPy46bCmfXttLb3MWFaFMpDueraM6GnvacC7bxkjDca16jywCz+0XR4WgWG4YJCpxOlIVHozIcVILEQxkl+rVd+6w4kR1u0aTCEQqTXhT6dzVEdBLnD61q50zxj/dr0vta+m7M/PsNCYpHTgLr748h9xLU2ZLI/xyR/9KE2vyqvXLzA7rFCZmmCjM0B2rjE5O8/ShS3uOfsBlq9eYHp+hoO1E4RBnbicYXQJicSTkPY7KAWu9Oj1WgyGLZpG4Pl1vKBi+ato8jxFSYlQkiLPkFjZdRIn5EVCPOwhpKJcaaC8CnmcIJSm3+8ThiFOSVCpjqEciXIcfOUx8APaO1tkcU6vu40jIfA9BoMBApeiKCiEIc0zMB55UtBJ23R2upSUx3A4JKgH/5/X8P+toklBNOkjpod0np0m7BkG84Klv7FIUTJUrwjicY94HLy29dmNpg31i4atewSVa4J43pBMaubcNn0/oObEKAyuSLheZLgIAqG5kDVYy+s8GCwzrjLGZcmmdBtNYjIrGEEx1BlSWCl1S8NQu6wUdVwKDrltxqSmpRWu0CxlE8y5O0w6XQ4521RlRigTQhLG3QGX+xN0k4Bqq4d2HESphO6MaIQjE3uiyKa7xIlN6lYSSgG600NNNG/52gZrivD1CulpgzjbwX2pjgwMWcXg9gXRaEmrYjupZmPFKLDUmscPDlhRh7ej6B3WFvrIR0Glo0b6Xre2oqwt5LvXkBlhzpaOZhR7tprIf8NYa5evXLA3SotkNyHEwi3W7s3YzD8PcI016S/ESGBiU0j2JNcGdMkgBxaaQUE+ZU8P8t/wX75d/3ZrX035M3fdz19efZNnt79LfqXHmZOTuMZFjlV4+doFJqfH2Y66jC9O8+ab7/DYvffz3He+yaRfxZMZg7hNrANay1fxPViPh0zMNoiGa2RRSuCFCFeijUNtYpoXv/h5jhzpcfDk/dbtDW2NhjDkSURhJI6EJOkTZzFRkrBy/Ro6iWiO2WgmPyzwlEcUJ2hy8sKhXG0gpaLIM9IkIwwcXM+jGvpE3QGNsYDuoEujWSXVMXGWIIxDqZ7jO5o7zxzl1KkTRPGQb33lGYRxmTs4jtgnrSh+YIA6V0YulQg2Dd3DgDSkNUPtsiRuWphiOGNovAPb92qmnhdkZfsBdYaWS1tadajKiLWkxiO1Syxn42xlVcarb9jpGMF9fpvPXfok12ff5qcbLwPsiUcAOjolNYZACFqFZlv7tIoKf965i14WcKpyA4B5p0sgCjaLEgV2iXjI3cQXBQPj0CoqzDk7VFXMdNBja1immAgR7Q56qoHIMkwUg5TIegWUpHvfHK1TCieC+S/Z5Z45Mkfm3PoROzqaEs1LZCptVFPdWOFIRaNdkJEi2JDEUzYyyubsWc5xXtUYT6O6DmnTwgCyGDE5xnNEz8F4Gmlsc5OpQNUyimTEwsjFXkipbaY2NQQpyGoFSJBlK/tXasRMNoJi6HwfD1rEApViE7WxXOQisK5vMgORSYpqgUjUKL3aPgCcoUBF9gHidsEdGPoLoG6MpmqN5Unfrvel9tWU/+WLX+XgkUPMug06d5R5fecSp8YXuHrubRKTc/jULOeuXSPpRUxVypx/9zwPfeBxnn3pGdz168S9lJJTxQkcGhOT9DsRphAMe1uYQpLFMQ4K6aQM+x5//qf/ig9/8HFqzVkmZks4rrJmQ1mC0BqcjEEU8cJzz3Ll6ibnL6/glT3ICvq9DjOzM8zOz/Lhxx6mGpYxAqIkoTbuk2Uxgoyg5GOEoVqp0u60UfUQMeVz4tABVG6QzSr9pM+h2RnGHJ8X37mMSnq8/dwzTB+a4+xDx1jbbuMFJYJ4f+/s8rfL9A/aBU7PUYSrguGsoX5eoFJDfKagvDyKHKpB9aJi4yHN5IuWc+oOtJ2agAf9DS6Xb5Aah+VknMwoNosqTdWnTM71XNL+8iy/80iFO89e46OlFiXhkZicoSlIjcETgtVC8fNXPsf51WnUlYAisHjpc/27iacLSrN9/u4dX+aQt4XCsJ5XOOtfp6OtJeik00UJzRF/g4vRFM3SkKRRp/jQKdDgVn3UIGN4sExWkjRe3EBmhpnvJnQPemw9Mkm4mZOX5M3Gdgulti0skU9kkErcnm1S5euSaMaglSGe0LhdO1mm4wVu206V/qYibQj8HWFpbGWN07cm8u66a6fQTFp+8Qg3zmOFX01I0tIIuRA38WPDXqMHOHJ0naW1cXTkYFKJ8QucMOfA4hbXro8DCplY/vKuyxtq5Imhvt9Xw21bKp4TCYwS6JK9X3lzRGVUgnQMG/o7Zh9AxoN9Im+3ax+1r6ZcPTDFsLXNWt6ndHCKYmDoEeE2AsYKw9jiPDOmhYkVk9UDtAY75KpgujzORFDl9EefglIZ51pMe3uLWq1KlCfUa5MopRgM+ngFdLbXCKeOs3J1mbeqLzGxcJqJ2SNgDFIYCqnIkpS4X6AcxfjkDM+//Cbf+MZf0BnA+NQElUqZC9c2Wd/4KlHU5oGz9+A5PkmS0JieIYv7bKxdo1Yq4TcbaClwPZ+GJ4mXVrnjUw9SET7Dbsw3v/0Sm9k6jVMnuPOuYxyZmePq0jLLq5eZmpngzruPsbm5SdN4+7o50bT1LnD7DvFUgVEKmUFWFRQZlGcGREkVmQn6NYPTt5/ytC7Iy4a1jxQITyPaLq+l4xz312gXZU4ENwhkxnI2zkD7vDI8yAPlK9SWC7arVX5r+jE+euQLACghcI2gbeB6HhCInLvGVjn3+iIHv57i9FPi6RJpVVJZlpTXSvy3P/EpPnX6DSoqoZ2FPBxeZFuX+VbvFLNem7OBNbKvOjETQZ+tazusfGIG7YLXc5j+WofwKuzcWaN9/xS9BUl9SVBbThnMumzd5RJsjni5t1hy5O0guw66VFCUDHnZEC/meGuu5TF7BqMsXqv6iqJkg0edCNKmHXLz0LIu8tBiutobmcpjoQpdKdCpQ/mCRzTj4M0OyVdD2zjliO0wMhQSsUKmguWNJvOTN+mUvdin2y3ZhiztsnB3iQh22Yen0dpBFNag3qr1NIVrCNYdCs/gdiWpo9GupfOlDW1z+UbScGcg90Jj5f4MDm/XPmpfTXk2nKA/ljHMJYPtHR5aOM1Gr40sBcidPr3VdZ7/5rc4duR+zrfXKZcdLl9Yp3VtmyAYI924QVFAuKPodneolmsWH9aGXr+P64W4haDINd1ezGc++zmWL55jMByAdDAY4ijGkQqjXPrddRrjdTq9bX77t3+bra0BSVywunIF4QhrYeS4OAjCwEVol37eQ2jNlQvn0OkQ45cYq4whjCFLCzqtNmfvvgN0wcVL55kcm+LJjz2G60rWt3eYnZ3ADTxqC3VU6tP0KmwuXUf6LmuD9X3dnKymybBYotdS9I5af4bCA5XAYDNk/juG9jGJvwN5KKhdhspqSl7yMNJ+SFUC55JZDnlbDLSPNoIryRRNZ0AsXRLtcDmZYvXTGd4VRSsu77Es1ouEQAgUhvPpNGeD61wZjHPyNzqItW1Mf0D5kk95lJknPA8hJplye2gEUeGijeR31x9hmHts+RWO+2sADHKfpe442YNTCA3Nd3OiccXK07MYB4ItQ++AFVQMphVxXZKHgvKKZREErVsf57K6pY9hoHTNJRnXGGlwtl1rDi/BlAoybZuzjOXIOkLQP57hbThEB62TnEzEKPxU7GXe7aVadxW6pCl8S6fTS2WEY/Zw3V0vCkYGRIULYsfnWnvSvlAJOBrhaasSNHJvkbeLXTv1hCJT1kzOt93eOPY1+DcU8WKK03LJFmNK7wakY4ZoISdYdUiOJJihsgtIZzTZJxLp3qbEvV+1L97LpRuv8frzzyGSAaImaBUFrSyjNjPF1fNbXFvbJNYh69ubeG4dzQRTB09wz6fuIS7l+AqalQaHmwdx/ZDGxCSOgKiIMVoghWZiYppquc7MWMgPPP0JoqJg9coF4jxGY/DLdaRfQbgu440qjjBICU9/9q9Qm5qmVA4ouQY3z0n6MVG/4O4zJ/HcEvgO9WqFsmf4sz/5PCYpGKvX6Pc2ibKEYZ4Qi5gTd99FlveZnqpw/IHDUBqyPVwhGcu4tnKJF15+DrcsSdWAsOYxVWuysbKBU67t6+aUr0smX7JeBUVgG4OKBMm4Zuxihr9uM/yCLUPh2WP2YEGw8hHXbvUdK1KIpjVN1ecBfw1P5PR0gB5tmz4QXGXRb3FfaYl/8PCfIDO4em2CvsnQGGZVibr0qErB3f4KLhpHaK788BhmZhxZq1p/Cm0wnS6m1+Mjx85TVTEVFbNYalGXCa989TRR7nI03ORCMsN2XqGdlci0pHWHQGaGwbSidafBOOB1DYUPleua6RczimBE5apAMiaorObkpX00DgFF1fJ54xlLofR2FHm1wOtIxt60Hw3jmFGwqIBGip5KKDWjvWY+9rZjxRxtaRVynm2Gu+nV2jcYaeyUXQjyZk4RamvBOfKrUKlA9SVuW+HtKEQiwNOogUIOJbLrUHk1oHrexekoipL+Pk+NrB3gXSrteWFoz6Zna09TuW4gleT1HJNJhou5TR3pS+IDGWaokKm0cVEdB7flEK6o91o1365/y7WvptysLfDYU08ReR7KHWNnp8vG1hqN8Sb3P3mWypzPA/c+TL0+hjYJjhNzffktVl4+j7yRUtkOOdu4h5/9uZ8nTlKyOKUoBIoSbllRHgu5snSBN95+hfPvnsd1fC5fWuLA/CJLF99FF5p+r0ertc3GxiYrWy3OLV0lzjSecPjcJ54mR7LTj4iKDOMYfu7v/SxRGpNpjVA+uVZkCE6cPkNSJJRClywdcP7cO6ANjVqTT3/yrzJc3eDo+AyDNy+z6NW548BxjtUnmAtrpDsDFpsHcLIyN/pd1r0206emCNP9+R8mY4b1Dxc2a8U1eB1JsAWmmbH6IYd0XLNxryQZE3s+vJVlw9g7tqnJROAuDHjpc/8LW3mNlnaItYsrCiacPsf9NX6/cz+/s/QQv7HxOFUZUbuimZtv8S86d5GYjOU84rUUvh3N8p3oGL/bfphh7mEkLH22AcZQtHYwsU0GOfcPTtHJAjKjcIVVCWoE2YkhSeEw7Xbo5CG/t/IQ2ggOVNs88bFXCbc0w2lB5aokq0L3sGWfJHWB18mIJu2x2m8bZGZoH3G/n6Hw/7cEo1gxy5LQ1QLtmRFH1zD4yAARK9volCGfS5GOxln1kS/WqF+Eha8PGcxZOCGdKCwssGmd5rRrMJ7B37L/R1YrKAKN03LAMRQlbRu2Y8hDTVHRFIEhq1pfivCyR+2yfSCr2HbIYqT0UyNvZAQY11BacUhrGh1q65Gs7QPa6SnaJ+3DBsfs/T0it8yLYMXF21E2caRtTzpZM2d4oLDJKrfrfal9wRcz4zXM0iXmsoKrOfQVTPllvvflb3HyniNsXt+gdXWN8ckJDh6YQOcZ42KcPKrQCI/wC3/vf0Q5ZdKiy+zCAms3rjPZnKRUGaPX69Jut6hWxllcOMYgTrh44R2OnzjGO2+9ykBKZicmKbTGCXyG8ZA4KyhVG7QuXKa3s0Nnp8vxuWkW5u5lfW0N1/coS01qFJlRDPsRtVKFq5cusDA/S63k02ptE8cR1XKVwlirriItOHrmHto6owgEUdSiVp2mJisMnG3uf+BeAs/l+PQBTJJybukc5dlJvPH9UeKypg3fFLmluwkDeQXGv+WxcxqCG4rwhiGegP6ixTQLV6AySGuGb//UPyIUip7W/FDlTb45PM7ZYJmDTsTlPOStZIEj/gaPzlxhK6nwexsfoHNMkp6b4g/0fTwcXiQzIU01ZDOvspOXWfS3+VL3NF5X4LUN6bFZ+ouHKd9IKXwrXsi1JDOKG3GdeX+H/6P9EEentxgPBrwxXKCVhsyGXfKRlniQ+7RO3lQtuj0oxiEvG0xbsP5QiPY1g3mJzKF+qWA4pUjr+2gc0hBODikKSXGlghjaZlzUCigE/rtlzFQBjjX/0ZsBIvLwOoJg09A5Dtv3BMgcipJG9RQ61CTjxZ67GxrihQwRyZu2n80Yei54GpNJirr1cUZaXBlA9q13dveooahYaXTv2IjlkQryEUNDZILS5JB0WMH4BtVTFBMpatsdUeXMnk2o2nHwD/cYbpYpygYZSWtMNJWgt3zLxvBGlLxcUJRux0G9X7WvpvzV3/8S89Me2lWc/cHP8exbrxB3hpy990GKSsKE9Kl4ZTr9IZ3YELUz5qYO8UNPPc0Tj30G5fjoQmOEg1CSsOwziNoMhn0G/S5JljIsMtZuXMUPa+x0t1COIMsGCBPz7rtv0hhv8M758zzwwKMMBgNefeV1rl9bJQgCjj5wFOkbon7M0ZNH2dnZwfEU4xNzIB28kmKY9PmT3/vnfOSDH+LShWt8/OMf4zvPPUtlrEm5UibPYq5eXWJleRPR9HBkgkSwtXyRcnWCcKJGNOjx4hvfox9n3DF5hHAFnDTiRrK2r5tz8E8LhtMSrWDrQwnVN3zcgWH7Hmt6nihJEQjcvt2uuz2IpgynHrnI/3b489RlQGIylBB4QjPn7rCSN1jJG1xNJ+gUJZb0BC9uLtIsDVnp1tCjY3GhJb++8WHuqqzwf14/y989+udcT5v82sXHaa2MUfKhdW+BdkLcgaF10ifYMeDk3FVftdCT22crq/KHX3ichUdWeOHqQf7Rg3/Ef/fO08xUe8yWuuykJd64MUd1xVgqH1YOX70KaVWQjIE7hPHXBE6s6S1I/E6BdgR+99bpF8F1l6RTQyUg1MhbOBdUX3OJxy2eH151LOWs4hJsg8wMbl8TTVjGhZE3k7uNGqn3fI0Mc3RqqW8ogylpZJDjLgUUQwnNDGJFMBGhlGawGSKHak9abRyIGzmiZLMD3Z7E35KkDavWk6nFjI1r5eE6sO8HXbLJIVaabaEXZzIm3woQuSC9UGMkzMTtWd9oveFb9eF8jLoWEGw5ZFVDNna7Kb9fta+mPP/QSarVeQbJdb74559neuI4lfGcbzz/ZZ54/BOsv/Yaucz51Cc+wTN/+SKP3vdJPv6xz7I4vTDyHjZIbfBkmUwBqkscdehtr2LyjCTPSbKEXKdcvXyOtevX8D2XUujxyne+wZ1nu7z43CpIwdbKFdJswMb6JstL13H9Et9bPU8axwhT4NccHnz0XnIhub66juM5FEmfS299D9dVtDZWyKMBWZYyPj1DEJQplUpsJgnXV69x5NRJ7hyf5o/f/iY1DZtpG5kY7j35CG+8/gYHDi/yxjvvko/7zD18kG2Rc4dzcF83Z/tOj7Rmt/0zX3EZTlk8deZZw9rjgtrFkeT5qR14rkH8wIBffOAP+XjYQWKn9AJDKBSFyAlExmZe443hAql26Oce/cwn15I3l+ZwbvgY105+/Rcn+O6dHt/YOA0S/vP1H8WkCnfTobFsJ7nyikIl2kqFa5KNB60V5PNbhyk5GYPc4+L5WVwXrm+PkSeKbhFwYnyTCW/ApNdjJ50nuRGij0M6m9J4wcUogTswaEfQP5nhvuXSOyhovmPIQ9i820Ol0D106+hbfMDygOWWQ9bMUT3bFIdz9qFUWrNCHFmA1xaU1wriMcnO6dEUOVJMIiycAEAm0IWAgUKom4b0xjHQ92+mkSSK2myPRhhxdWkSGeYEE0OMEdYmdNMnWHfAOKgY0nv7e/bKeeQihg5GGeYPbbH+2jSE2i4UR+KQXVCyUGCWQ4RnqCzfdKBLa4bklMXFlaPJIhc6HkXJYt+6pBHJbZn1+1X7asqLR45x8dJ52ls5Dz3wFOcvvcp4cJgzdywSxwN8xydLHH73N7/C7//GF2k2phFGWy8DgV0OGU2aRkjHoVqfQOc503Pz7KzfwA88arUpnn/2Mkm/QzlwKZcCtNYkUY8Xv/1FhBI4rk8UGeozYzhac3A2QAjJWMUlLxSuK8jjLun2WwyjaywXaxijKbKEzWtXqDVn6HR2WFw8xDe+9Q2m5xeRUpFlKUopfN+FVsTLG28xFTZ47dnv8tgPPUX78jucv7LMudUtjpaa3HvXh3j39deZCHzK4xX6lf2RPfuHCqqXFf6OYfMBqF6CpIldjMUC7YETGUr/ss4v/cI/5m5PjaTQNkEkHykAWjonFIJT3g5D4/NE7Rzf6x9hzBlydGyDX9x4EjO0lpB61HBUDOL5GhUJhQtO7BBPWOpUNGNZBlnZJmQYZcUKXluSp4Lzenbk0ysIVxVJw1B0feYObPPfv/YJjk9v4ghNN/cJVG6nyy1F5R37EJp9NmL54wHl64bwikttuaB9TLF1j6D5liYrW6x5P6ozEUucvrQ8ZOXgHO7Dm1WEtl4U8cEc/5qHvwPlG5qNByTaHU3FgpuqPGNVeRgLT4jcmv1gBNmYXbgVnsWdjbJmQpkr6F2t09d18DU6chj2XcvayCRCQFqznOG8DOZ6aNOnKxpRy/Amh6SRy+q7U5hqgUwlRcXiyUVZWyaIsXJrPRdjjKDrO9asqKoxpQJnJcDtCvKqgbECb2pItlpGZAJvS+2Lbni79lf7aspvv7NEOfQ4c+ogvZ0VdLJNb9ulOTGNIwruPP0AH33ihzl59E5q4SSQj97Mo3DOIkXnKY4nrZQWgXQ9ri9f5cDsFEXaZ+3GNbyShwRK5Sq5MRQmZeHgAdY310nTmPZgQJ4XFOsZptDEgyHb29ssHFhACB/PreCHAVIqyAt2blzFUYAp8F3DzuY6FBmNyQlm5ucIwzKF1uR5hlCChYU5rnbPs5R2qGvJE08+DmRkqsl3vvw8H/rg/ZRMTj0w3PnQGV65dIET1QbC358jUf1dRR5ilzVtiUoM/o4gaQLC0D1V8OMfeI7/oPEci044Cj69GekUm5yeLqiOfCoAqjLiC+17+WjtbdpFyLc7Jyn5KREhOrR5QEJbG0p/SyETcPuW1xts2oWiMzSUtjW9BQUSsjLkJfakwN6mYxumsTJgvyVIC4fOeInj05tMBz0yI4kLF0doGrNdBltN1I41+rn2sWAkQRYc+HKH1SfqaGVtLbfOCurn2QstvdUqrSqGiznNe1qsr41Bpshn7GJWJpLK2x7BtmE4I1h/xC4F3yvK2A0sFVqglXVys5ABZCUN5ZygkhB1Aitdzu31KDwbRaVSKHwwUlrzJWUQkc161MEoj8+xUU27UISMJMQeqeeO7hP2YaAMciitcOQ9zI8i1CgJeqBwesr+zsIa/KdNTRGOVH6JJEsddKARrqComtuT8vtY+2rKZb/C6vJl3n7tZY4fnkdlMcsrFzh84BivvPwyf+Wn/0POnvkAjqNAJBhs0rEamb5KYSjIyTKNEA5aFwSBT1B2ubS8RG/7Br1ui16/S6PRpBCSTNtmngy6VCtlut0CVwl0FtHr9/BdF0dpKmWXPI8YG6siHUkhHYRycVwXKXyiQZs0GZLnCa6qMTExwfrGGm6pgi4Uk9OTDAZDamM1+kmbN555g0NPPcCl11+lFSestbd56pFHeffiOfR2xAuvvUunFTNREXzsr/4Q8Xab8+HWvm5OXrKUsInXctpHPWQBYxdzVp6QjL8uOPofX+DnJ16gJP6f4+AVAg30jEZik6XH5ZApt8cXWvdyoTPJVr9MNPBwxxKMERhjj+Bm6JCHBrewSjcy8Hoj6p2CrGyXbsmYbUS7vFnt2Ia1ay8pCmvYnk9k5BtlNvyUXEvuaaywkVQ5Gm7SSkKGL9RZe1jReBucIZS2NWuPCZrnAtyeYe6VPmq7R1Evc+XfqeF2wevd+qIvOh2j1n02roxDmOO+HZIfyPaaXLhhGMxa+uF7DYN2azdp2mLJN/0sVCwwicDELsmOi9KgUvtwwoxM7mHkzDb6ecc+gMxoeaeGo4Yo3mNwZEBo+xAQI6sLI60Hhg5s+Knq24xA7duHlTcek22VwNXk9QJTSzE9l/xoilzzKaoFMswRaz667UFoH91iqDC17Jav7e3aX+2rKX/o8DTtsQbb/TmSuMTKjRU+9uACbz77be6ceYzH7/sgrpIgzIgXa8+bGpBGU+gcQY7QBq1zTJEjBExNLeLqG5RchXJ8SqUxjFKkcQKFIUk9wnKNsN6kmSZ0Wpt0drbodXsIoVHS0JiYAqNw/BBtwDWCPE1RfgmpCqrVMn2syQxSc+3qeWZmZsmTIbra4JsvPkOS9fjus39J48AsRx85g0oiPnrmYZZba4wZw5f/8st85MmP0mqtsfjAHNO1aV546SW++dLr9PsRBxcP7Ovm9E9kRDMKt+MhM/A7hhuPKiZfNvQWBf/zgS/gj6w24WYa9W7tTseFgRhBbBRSGB6vvIsSmrKTcM6ZplMKUMIwSDwKI0hTBxmmpDWHOFWIHRevLXFHikEjBfHIC0jvSnLFaEHo2wVYXrFO6zIFJATLHvFMTpS6yNDwh6/dj0kkb373TgazAnPWTptb9xqCTYlxFAtfy7n2pIffEmydrZA0qky/EDP9QoHbLegeuvUztn85IGlovG1J6R2fwZyh9rZLXobyiqG/IIgnRy5vI+z4vbWbWiLjEawhGWHGZpQuLaz/xCgxxJ4azB43WYy8MoQBMnHTtnP0e3ahmb0Hgh6FmxprISoze+2NMjh9RT6WWygi0Ailka5meqxH65UKwzk7/burIWEfkqZDfjBGFBIdK5xCoIYCb0URzdunhvJuL/rer9of++LtZ6iHIXfNP40UOyyvXmRrrcdf/6G/yU/+1M+SO5LdKASJQesCKUdwsk4oigyQSGW9zKWCLM9od7cxjqJcmyAIG+xstzBOQbvdxuQFcb+P55eI0gTHKzE+PYdwXEq1BlJKkmFEa3uLShhQCirESUJeaMrlOr4XEMV9iixHSEkprGIcj0oQYJREmpzO+lXeWH2Lqzcus2gK2ls3qC8coH91jVerfe4pzfHlV96iGpYRW4rF8ZMM3T5kNJ3IAAAgAElEQVSOSHngwdPMTh8lSR1WNvan6Bt7xTaJ/lF7rK5cV5Q2BdufHvDq47+OK0rf14gtfGH/nVMw1BZTdgXWGY6cnnE4l8zhy4yjwSazXoe3+rPW1a3fJCsULR1S8jLbnF2NmUxIHI+sIvecyPyWIA8tpKAS652Ql60Xg4rkyEbSkJcBaX9u96UubTfxl3zCVTtZB9uGaFpQWhdoVxBPGmafT8gDy6GNJw152Tau9QcDommNyBSljVuflLPjEc7VgGSqoHpfG/PmON2TOf6WYjBnJ+RdNsR7ywj23NxEwR7OjAY5ghOc4c2mCVAI27TVXoYeI9N8a1bkRFbKvZvLp0cZeSITNx8I0iAz+7X2rfxb6F1bUJB9ZRkZibQgVkextlwiO5KBFsihxf2TcWPjpFYD63LXliTjGjUTkSzYExKFwDtX4na9P7WvprzQrHNg4izDjTfYvNHh9NFjnJ5/mB/78f8MoRzEHrtfWNxMZwgkWmuKPCFNU0pegBaGoihAOCAcmuMzOCgcx+PSxfMcOHyUja1rVApNPIxoeiXiLKVSq9Hv9ygKyfjMHFlekCYpjjfA88skUZ9yOcRgCB2X/mCIH7hIKfBKJdJMIVwH4Zbww5AgCEm0pFKpkPdTJoM6H7jrBF969Vn6m12yNOeeU2do5iXGpqt0GJCPFXiLDhdfW6a71Gc8DOmZber1Gs1Sf183JxmHaDbHbdkG1DkG6aGY5x/7VXxR2qNjAXuex65QZKZgaDLaWjI+cqqLjUEJUMbwUHAFKQxlkfPP2w/zmfFX+d7gCIl22IrLlOoZg8yjWo7pDwKMETgTsaVfJQo9VBS+FTXYlAuJcTTO0JrF2wikUQacspJoUyqQpZyikNTLEb24RlYR9O5IaX7PxWuDSgydO3NwDMNpD5Xao3g+kVF6y6N8wyZtaGUDPot90MDltcBOu7lg8N0JignN7LckKtHceFR+n1kQcrTM2/2exB733mtIP4pXkikjT+Kb37fwhEGPHOMQI9hiBEEUvhl931jTOA1mdzIemeMb+Z5fn1nlHqOXJIrR/yvFnu1m4RtUamXe3o4kqxrSu4bkkYOz6e697vTMEN3xkMshftt6eOQVQ3TwtvnF+1X7asoHS/fytS9+hSfOPILSa4TyDn7qR/4OQtXRIsExjlVNaUOaxYgiJzeaotA4jsZzJFK4SCe3WWzSxfNKRNEApRRpmjI7f5Ak6VKrjlEtV+m2OiR5QUVI0jyiXKkRRUN6vS5j402SOKNUipE6o72zydb6DRqNJp1ul1q9htE5lUoFYwxu4CM8D9+vUq2Po1F4YQ1cl7/+8b9G1FrjXz/zJ9THx9m5tkbHiXj1S39MsTjL4oPzXH5hhzdfOM8d8hjrV27wt/69v8Ov/Mo/4fjRg/R6XebmZvZ1c5JxzYGvwMa9I+9c3/CvP/zLhEL936bink7JjKEAEgOhgLI0uEhcIZEUuEJSl7Be5ATC0NYOT1XfYLOocdjfZMHb4V13hkHhITEMCo/NcoVuHNDpBzTHBkSpS1JyMUC24+NtKdIxvcd7FRqKyij5xRcYRyN8TblmjeqrpZjAyRn/wSusdmtUvjVO3ITyDbsom/mmIpqQtM4Ymm/B5KuaDeFSvVaQ/bstyv97g94RhdsTNoLpFktFgvhQgrPpkVUMtUuSrXss5U7mI7bEaJn3XqaFyAVyNzJp5HOxK9DQrkH7o+87Zo+7LHIxgjTekyYy4iOza/eZWoGJiuzPyUyQ1zQyHv1uYSdohEHCnrcGjCbrEZRBaFCJIFwTDGeM/TuntMWIux7lK449aYye54d/VdA9pFCpoXtYjCZxjbt1Ozj1/ap9NeW185f5yGee5pnnn+OvHf8YT//oz1AZq4HIAQVGUxQKncckUZs07aFNgaPqlFUd1xOAY0+JIidLB+SZZQAkaUKnu8bOzhbNxgR5Ztja3qFcLlMpufT7AwKvhCkEvhdy/frKyMrTUC5XkFIRVOpMNJqkccTM7AJbrS6O5zPodXEDn0o5xHEdXD9ESU3o+/ieAVEQ5SlvLl3kpZeXOHLHBD9w30NMzc/xZ995hsbUIoeOHWO+ssXHz/wAwptEf7rB2ftO89DJx/iVX/5vyJXg7df2d3MqVyXXflAz8V3D1oMFv/ADf8gJ9+Z4uDsdD03GaqFo6wBtJKFM8FVCXarRUtUu/Tq6oKcVIGlrhwvpDK8PD3B3eI2h9nm1t8BC0Gbc63M9alB3I9JCUXUTtlbrDN2CopCEYYKSmjxMiBo+JlGY6QzdDsDViL5jncvCDOVoPC9HSk3oZVQ8O4ENMo/2lQaHX05onfLZfKggnB7gPFNnOG0QhwasNUs8cPYiJ5yE6U92+ftTL/Gb/8Mhful3PgNA/fytMwTSurbKt9mYyssltMPIhpS90FIbondzscYIhngvBW6v3sNbBvszamAbrfYNTt8mSJuRNBrsUi+vFbhbDnnZNveiZGELlRrcnV3/DZADC3E4kSQd0+jRa5WpnaiNujkxq1jQP6ipXpZ0j2nK1yUy8xk+NCSetB4dzkAw9UpO93CAO9Ss/GCBV01JtwNKU0NKr+4zy+x23XLtqykf+eRDnP/Lb/DgyYOMHz7ExMIhwOwdqo0BzQClcoqoZ49kwqdS9zHCJUcjRAF5gaMEUghKgUeW2tSJWrVOrVphc30NITzOnDmDMZpOp4WQKRubLdo7PYJSjcOHTjIY7uC5CqE1pjBUghDjK6L+AINgYjrE8UMaU7PkaYIjQecZYamMUi6e74NwCIIAGHBh7V1++m//ME7SY6J2L3/6Z19gs53w0z/x4/z+v/gjxsZP4M2d4eSdx/ju17+O0z3M4eN3EITzrK2u8crr5/Z1c5JHelReqNI+bRib7/JkeB1NsDcha7SNYBKSVhGSGoVGclJ1cYVAGzvlJUbjC4k0MK00HW0x/qPuBofqmzw7PI4rCv7W9F8C8FYyj8TwWmeea90GtSBmfnGbThTgORnaCHItqQYJoZfRi3yMEbiTA3w3Jx+XpKmD42jyXFIpJbiqoOKmCGEY8yOGuUf5uuTaf5RR5JrpZo/oK1ME24YP/NirPPOv7kU3DWdr1/nbzdf495eeZrNI+MnaFf7XiiFcEUy+Mrjla6sblmkhuh5pFfLQfD+GLOxyzDgGXc2RQYEeODZKSQlExk0IY1eJt5vBlwtIpbXwDKxMOq9YjLpo5DilnDxRiL6D27bycrd3E3ZAGrK6sSkl2Ea76wiXVexpRKZiL+hVpWLkYAeFZ0gqGuNqBgsCvyUZHChwe5LDv2wYzhp2Tloc+cZjimwyQ+04HP4D6C2U6S8KvHM1hrO3fGlv1z5rX035mS99gUAGDPOUn3nkUXxtsa7d97YuCnRuSNMeWXyNaxuXWN1c48kP/Q1y4eL5ln8s0f8Xe28aHVda3vv+3ndPNVepNEuWLHm223ZP9AD0DDR0E8I8BEJCQhIugZMETk5yT5KbZCWcwD1k4CadkU4Coek0QyD0SNMjuOe22/MoS5YlWbNKNdce3/d+2GU1rHs+3GWtdfjSzxfba3lt2XtXPfXW8/z/vz9hEKAil8CP8P0AKQVSalQU0VHMErgBfrNKq9XkwoVpBNBqtejs7ERpCyklqVQa33dxmxVMQ6CUiwQsU8bz4lDh+gECjQpCLiwuUCx2ku9MUigUsWwH204ihIHjb+XTv3Qz27dvwdaSiaUxbv6ZX2Ts9GnMRo3f+sQnePnAPub3P8n3v3MPv/mHf4IfaR76zn0sVuG3fvtPmBo7tK6Hk3oyE6cXNwS/u+PRtVPvxVmyq0OaKqKsJBfCDn5U2caxUj9377gHWyiKF1kKQE1FeBoqSlJWDpaIkEIRaYM9iRlWogzzUZ75IM/Tq9sBKLlpRgsr8TWEpitpUQscyq0ElqEIoljNYRqKTMLDDUy8wEIIjYokzYUUsuiTsgKGsyVypkfBamIIRT10uPrnp/i1jpewhODR5jC3ffY8/7R6Lathio9/5Pt8+eQbuW/iKv75iVs5/P4vEWjJbUc+jF0R/OwnfsgjM7su+d7as3ascFDxAkz9L3LpjOEGb9l0muPlPrqTdX6+93k++/IHUEuJn2jeFxnEF1OoddvNByCaMaENQ0MoMVZN5JyF3R55xDFQxE1ex1ZvZelX00X8GGavA7FmrUaD7ggxF601LrRov+lsV2K0oPuwIkgrsqcrBF0p/LzJ1NtS+AXF6K4Zyq0ELc9mqFBlNpdn6mMGbxg9w5F7d5OZjahuveRb+1qts9bVlCPPpNCXZOVwlf7CDkJbIXQdv1XFkRs4euoF7rrng0ydX+HKbVdjaZ8Xnpzn6B0TfOazf4OO4hDUMAgJQ58gighCDyEFttXEwKbp+gQND1OEtBoNNJpcOg8Ikh1FHDtFo9bEMEw0ilbTwLEF1ZUVbNOg1WiRTGfQQuK7VUK3idtwcUNBX/8QXV3dpLIZcvkCUkoyuTxCSDqkoNVq8KOn7udtd76b4f6tWHbAFZft4tnvP8nTj36b/kyRnbdeBimTZ77998zPj/Omd36U237m/ThOgifu+3v4wMcv+f7KENzOmPx2XWIaR9h4OmAhCslLwZdWrud799xIdlpR2hV/1R141ucdt3+Wx97/57haYSFoak1NGTS0SVM5SKHICh8LxXSUYj7MI1FMeD0ADCZiwPqm1DJ5s8UFr4DVjvlY8HKkLZ/pcgHHCqm1HLJJDwG4voXnWURNE0KJ09tksFihP1Vlc2oZS0RsScxjoDGEYj7I87GxD/Hwjvt5a2qKrHT4r52v8OHxd/HAvteh8gEfufplHrR385ajH2FhocAX3/At3rB7lqLhcO8jN8Edl3Zvg7xCtiTZaUF9WK9l5Yko1v2a3S3CwOChly9HBJKposehfduwt9ZwhUbbxCMLX2C4P5bFl9Axra0RX0tLjVk244ZqtPXKFxnKxKMSGYLKxA1YXjR/CNr85PiaOhU78dDgzNiYFwy8oiZM6bUZdwwg0siUYPpNJs6mKn951df4zOkPMjvXAR4MPCEondqA8zOLlFsWk9MD8Rw5GXFsqZ/qtojKXsXQ8Po09q/Vpde6mnLKCRGtUe7+uy/R9FfIep3cc++X+PcHv8RVV9/AyYMHsXIZFk4FPHDwIBt39tO9F1aq0wRhLQ51tJMYloPhJEgaJggZO/sAFbqkzTqYC1RWFomUD2hM6eF6LvVKSF1IgjCi5Yd09/RTr9UxTUG+WACtyGWzaGHQanlUylW8ZoPTp05x5zvfh5VM0dFRQAUhhoZcNotAYFkWwjBxnCTXXNPN8tICxUIR7bU4c+QHLK2MUegeoX/zZr6/734Gu3ZS6OjD2ODw/W//B6n8k+w/dIi0uPSv1wCRE88z//YP/5ol5ZCWPm/Y9yl6v+uwdLWk84jGSWuy5xoUjvlUdhUob7awy4KaNqlpKMrYYp03wUJjCK99dYOmUqTlKraIOOQO46p4uWNKRclPs+RmkELhRhZ132F3cY65Zg7HCBnMVwDoSdeRaMpekmYlCa4kN2aSfes8OcdlS3aJVjuT6mJDLhgNLBFRNOrsGZ3mZU+z05bUlM/nF29kfLkTujwuH5rln1+8kUJPjaFCGWcg4rd/9AHsrI9xJIO1DtNZYj7O/AuyEHYG3HXLPdycKPOKn+AH1T08s7iZqZN9pOYlYUYTFASMNAkDg8RAg9ZiKpajCdr6YWLpmS8wG8baSCFKtZd67RP1xRkzqn3CTii0FaFrFkYoiRJq7boQqzScVYnXFcV6ZiXWUlKijEI2ZTzyaJcAlBmPOLzJLB+a/TRDP9B0dRskPzjPwt4+8uOa1mM9qO0hJBWpKZPWgGZ1Kcvt1x3h8dM7KP+gH95y6ff3tbr0WldT7rBH+cKf/gVf/sc/4C8//xVGN2cY3qbJ5JPsf36KrMiwPFlh50iejONQ3NjNy6/UeG7yFSbOfIq77vpTgoRNLt+LKZ0Y16UlWkMkI4SVxjIzdCR76OgKiPwmgdfEb1Y5e+YkOqhSqZYwHYvA8xg/Waart5tkIkEURZi2gfbjLU29vkw2lWBhaoI77rwTYRhEUUQQRohQgdY0avX4pAwYUmAIE2nalFbLnJk/x87hq9i+7b3MTPwjde8C5468RG3RZyE4R+9AH6+75nZmJv+OsH6Bd73t9Rw/cmBdDyfIwDc/8Re848HfYufnJvF2DNKxycHLQc9+hTIFmQsh1S1pQidDY0DQfTik74kVfvX8Z/id/+vrdJtVdlgNLAwM0bbfao0hBBnpkAH6jYBrnTPUdcBKJFiIMnx16Y34ymChnidhhTQ9myfPbWVj5yoFu4WvDFKmjxvFjbzUTGKlfMRsGufNS1hGRKQkrcjGU7ET4pzXwxYn1m7bRFgiIiEijnoD3F8Z4qMdL/Cb3T9i3/xmmuUkh88MYy2blHWWy7rn+YPhB/jg9Cfxmxbb33SeMyc3XPq9zWr8Ds1d7/xXHi7v5be+/UtEGQWZELkShwQYgSDI6liLPe8QJjTkAzJpl5atYou0d1GJobkoaYiAMGzriINYsyx9gbESf4rI8Mf0wg0DlTAgGRHmY+axbOuTpScIciqeRwMoQWLOxC/GXIyL1mqj1T4pO68qQaBtUgnhws1t19/ZHsytDfpuWuTY+QFompgVI1ZnGJpiT5V9D1yJLaG2/TVH30+r1mVwd/UxfuU3bmVkZ5ZCb5KlSpKWynJsv0+z5JFMZai2Ag6cWKJhCgJPErklhjb1UK0uc+b0yZgvoQNU2ERHTaCJlC0MQyDa2+5IgBY2hp3DSnaQ7R1m77U30T00SihtghB8LyBoVSnNzbA0NxeL+5WNwiLSgo5CjsB3sS2o1muYlglCIKWk2NVJppDHTiYIohCFQimFRKCUwrINvJLLi4fv4QvfeBtH6w+y7ByhlamjbIc73v0JystlPv8nv8k99/4bZyammJ5ZYNPA6LoejuHBL/zZZ+kaLaH6OrFKTUQEXa9UscshQUpgNUI6DpViy24AZiuiubWIU4342tzrqakEkdbUdYCrQwIdYQiB2XZXSgQKhSEEeWnTZ8C1jsufDTzCDZ3jAASRgReYBJ7J5HKRk8u9qB+LpgiVpD9bIwoMlAmVehLHiIedloy4IjvDlsQCXWaNhrKJtMRv//xAS7JGi6lWkd+feic3P/xZlubyMWO4bTH+/M3f5ly1yMfu/k1G/12TOOdwdr6b7GD1ku9t1OtzxbVn+dT9v8SPvnoNYS5CJyKoWGgBKhsS5iLCnEJlI8J8hOEK0iccVudy8Xy43n77mG0SnCBOovbFWnOM0oowE+uW/YImzMan3PS0IDUr12KkhGfEx2lTx1xnW+N3RhieWEuhTiyYse3biCH5QsfI1iip4xBVJ7Zby5D4BJ+IE05Uj88nbn6SzTtmSSYCql4Ca9ohd9Ik6vcw+5vk+mvUmwnczV78IVRbB+3ptVpXreuknOvOcWJ6lgMHX+Daazv54eFF+rdtxuyoECyFLCxfIGEOorKnOTIR0YgGmJ5s4akaO6/KcNc/fZ1/uOu/U15cprIUYNiCju4O8t1bQFkoqRDSRIi2DVULDDsR27QTSbbtuI4tW67Ecxs8+eQj+K0mqXQaN/BZXF5AI8knC5w9fYCJscN0FXtIpQt4rRatRgstDMhLQiCRzBCGIY6TJAwChIxHGJaUFHMFBjsXeenIMjOLkyyu1Mlm8hiVGd6+5zbu/of/zrU3XMfjjz/NyOZB3nvn7dRXqpyurM+q6nVAfjJi/nAX4fXQ82KV2kZBmMph1zSpxYgwYSAzDoUzTYRKkZhYhiCkct0GLnx1E8bvPc0+d5DjrQ1kDJerkpNc5zTWLNiWMNYgRgpNRjooFEXD4VPFQ/xS4QBLyuTXTvw8y55FOunhBSbjpS4Aiukmk+O9ZM6aGEVNlNJEnknZTSKEJtKCQBsMmqtUVYIeo0ZVJdonZUVCROySy1yem+Yrp68nMW/irMRjBcMD93UN/uibH6LrmgWGH61S2ZZhz+2nmap2sLSyDtlWxeKVg5sxXUF1e4RVNQjyxEAgO5a8GXXZ5lHEBgxlaRrDEcJRca6dAPJBrB1esWNI/EU7dSTiJWLUbtBWO1hVghZxKrnQkBuTmC1NdVPMwIjsNpDI0hAJwoF4Xq8ciY8ZQ5DaLr54Zt1OqpYQ29rbPA4dn9JFKBArNv/6nbcQJTRhLqIW5iCneP/bn+NMvYcD54YJzYhgMYko+Bhb6uS+n1nPS/e1Wketqynne4rs2u3x0tEjXHX5JhLHGmSsLKtas9haxAscdl9ZA3+QRr2f8bNL7Lg8Td9QmkrV5SMfuIIXn95P5Ffo6uxnZHQjS0slhFki1zGAFDJ2+iFj2qcQr6qWBCjDxDAtLCF48+138uLLz1AqlfC8BjJQJJM2YxOHWZhb4djhKXbskGzcZNJoZslGIZZjkc5mCIKAarVMMpnGNCWmkQQp4g8DwHM9CsV+hgZ2MPbdEju3b6RVW8VxXP74/r+h2N3Die/N8Lq9V/Dej36U47Nlnnv6BbZt3bSuh+MXI1Z2mnQdUSzvFXQdNuOljxDY9QizFbG8x0FENqarKYx5VK/soz5gYNU00btK/P7Jd+IFFsMdq7y99yj7m5vIyhPstjSWMPB0sBaSaomLp+f2nzEoGibg8W+XfZXfm3on5ytFlIo/yFJOwORED4l5k66jPqUdNo1hjWqa+KFByg7YmChRixKc8voZsFZJiJCEUUcKjYUi0oKytrk8McWevo1MfTNLeZvEbMZLsYGv2TS7oTXbS+sa6HzfDEdmB3Cey6I3XzrkXrZVDeGAjzlrx43YUaDiyCRNvIRTmQhrxcQvqLWIJGPRZvCKOYTQTM50IepW7GbUxJCf5qunzIsLPRGx5hLU7Zmy0FAbjZUazkp88HC7Yoi9EirWfK/Y8eKxarTZGWLtuhcDCZQRn4qNZpxOc9H9J9pKjotwKMMVpOZMvKLG64n496feGI9KpEZXkgwej/ByCVZ3QPOO2iXf29dqfbWu8cXxI2OIajebt+xioVHiw7+8m+eeLDF/wUKGA1x90yiDoztxejZzbuEEZlJQT5i0EoINl43wz/95H3/0N1/kl3798yzVVlgoLcZSOJpoGRCFLcLQxTRBCoEQoLWm1WrFamghiJTCMC1MK8HuvdfyumtvIJkpMjY2xfFjZ5meWyTQNucvrNIMJE/ve4mm69JyXUIVkUyl6O7uIpfL0dGRRymF7ZhYpolt2xhSkkwmyWSyXLbzGjb1XEG3cRUj2dczM9nJ7//CZ7jS3sFff+7f2XTVHfzLl+9mYXmFrZdfTTbzv6a3/f+twokY8VjeLLErgrMfSTDwbEh6IUILwdzrHeobFV4RstMhUcJYs+5WtoLx3SKFv8oy/PFZ5mtZDtWGkT+GO6srj6aOcIS51pAVioWotTbSCHREShoUJHxm8Af8t22Pkk25+OM5Vk8VcebjrLzkRAnD1/Q/Ewe8tjybUEl6rQrXpsfZ4cxxmb1IhKBoBGRFSEEqEkLRZ3hstlb59f4nqQ3FluBWtyY9qyn9Wp1Wr+AL//VuVvdEVL+6AW8lSXVXgM5cegai0PGyj4YZqx8uNspAYDQkRlOiMjFFLShE8eKunTgd5iKmzvQyOdmDlQiRRQ+/NyTKh+3Fn0Lb8d/9cZXF2rvtonXbYE3f3OpT+AW9Fhv16mk45iJHyXiMojJRzLyGdueNf2u0JMqJ59/a+LHFoopjtYKMRoZQ3RnPikUQm0y0oaHfo+toyNx7fUp74n+3N/PaSfmnVetqyh2pLM3KKaRc5vEHlzl1+iTX3CI5sr9KR0+FkycWscJOXnhqDF3NUswFCJXiiQfnaFYjArfI3mt30lARzx86wOzCBZLJJEI1qJeXkYZGEKBVgIaYmRzFjTTuySHoEENKDClIOhZCSzYMDNFsBBw9dob5xTrfe/gxbnnzLTz+9As4yV6eeeYZTp85QxiGhGGIYRhYlonruti2idbxV3utNUJKDMNAR02U0lx+2a1UltI8/L0jbMj28dhjT5NN5Xni4cf5jd/6DPlshqC+xLvf9TOcmz6/rocTZOIcPIChR0pkxwzmrzPJvzCN2yHpOB2fFAf2eZitED8Xf6UefOACZkMgQ1i4xkF7Hs1DRY6u9NNrVnC1xZlA44j4i9JFGL7Xnjv3Gq/CaCI0FgYWgmLb8/u6nmmMlqDjhCCxDCPfK3Phzj76H7lAkBb0PQfReIYgkjSVQ0IEZKXLUpQkKwOCtlggAAwBCSFoaJNAGzR2e1gVwciDLdyiQDzVQZiC/3Lg53j5HX+Fn4ub5udu/g7O9KVT4sJcRGsoJDFv4PWGiFCQPGeDgrCznfhcMzCmEtglgyAfxfl9Qq+llNiLJupCkqgao/Jk3UQ0jTi8NIibq7Ziat6rLsH49/GHp17TKosoHl0gQVuKnk0rCFuR3lKJofmFAOFJhCcxcz46EcWci7ad++LIAvVjP0e8igyNGRvgzFtoA6xq2y0oYLRvmej/WEYvOZhDDczhRszWfq1+KrWupnz+/DKPPFbjkW9V6ct28a53f5D9Bxe474HPcOaMwS1v30NNLXP1Ld1svaaH/c+5rJ5Z4Vc+fAeLRxuE0TLzc8eIrIianmZ8KuDk+ASucAlDD6ktLAlataitLGIIgWW2U4y1JvIDDKFxW2UCv4nvlqjXFgkISRQMllbP8uiT32doRy/PndiPkUswMb/MYrlFeaVKX+8AUeSDFCjtU6svU62soFWANDVB0EILSajBlElMI+Itt76D8cnDFLqTjE9c4Iar30+iJ+TFo//ByVMncGsORw+Os9QsgZlb18PJTil6H5pg4/dK+F1pOt4+S9dhRf6bLQpnWsy+KY7/mXu9w9LlSQr7JsmerXH24wMUxhWGr8lcUPFC0xMszHTw7YXXxc1Px6oJC4GrQ474ERJJSsSNLtKamvP8v6MAACAASURBVPIxECxEPiWlKKkEZ90+AmUQphWppYjBBy9Q2Z6j50ATlUuRnfZIrATYq4KdnYu42sQWEa42mQy6OOV342uJJaCmDCTg6xiOlBABn7nmcfITCrfHIX8upHFtCz+nMA9l+NvSNZhNTfGY4KzbGzvmLrFEJGKQu4JE0UVLaA2GqHTcjMxGnH0XZhRhMk65TsxayKaBXRVryzyrFmPfZM1E2SqeGxfa1zHiE2+M64SLVtc1oUa7Oat0FCeGOBrpweDwCkunujDmHNxjBfxihG6a8Xw47xOtOtjLJlFKxU3dvNjcY420bptYYmdWfFqPMgqvU8VqjmQMiRJhzNiYmO1CaUFyThJ4Jv5cmsSF19gXP61a10x5drrGe947ysx0i1cOzPFnf/Rlbr15D3f91b3ceOMWxo4s0jukmJ85SnXW5KobBtl7xfUceP45tm7p48ipGk7eYe+eFGHd4JGH/5Pbrv9zqkuTCOXSLK9i2hLLTpNM94BUKCCKIqSOEDpeV7nNOqmkjWo1sXRAOqV5Zv+juIkK/ZsTuHKZzVcOcerEWRbLs6iawHvhJd7zgffTajQpGzaGFKRSWWzHxg8URC2ENgjDAK0l1dVVkpk0Xd0d2LZBwsmRty0OvvgwP3r6ENl0J2Mvf5K5VpXR4Tz3/fXfcct7Priuh5OZbjHzoc1kLkQUnp/B/UIfCzcZ+F/eQeNGQe40tHo1mRlNajlk9eYRli8X9L6kKG8x6Dwe4OUNgmu3Y3gw+Khk69WL7G9uQgrFKa9B1mhRkE1GrDKGsFEoXP2TY4HZKMWA0WQlymAIRbddo/fF+M3e2tyFjDTLe1N0HReYqy1E02PAzeO/w2Dey3NUDGGJkAFrlU6jTlObeFHcoZo6niuf8PsYsla4JjnB1+yYNhcmIb3fZOCJEmE+yZPHbqCw2qI6muRb997C6O1Tl3xvjZokyipaWzzEfArpCzJnTeobFcqCMKXQTkRiJuZACyUxmwItJMlrl3Eniui0RiUjzIpBcnuZRj2ByIMo2RiNOAQgTLcz79pGkItjiYvZfTKILdlmNR4ER0nN0su9GGZsuVYOmNUYYRqmNWHDAici2BAgVuMPULMu4yaLQDb4yZHJxZOzjnMH/Xz8QSMbbVt3RqGbJqsv9eIPReiGBemQqPFaU/5p1bpOyh94/bsJzhlsT4/wN5/7BLffupPOgRRDm7fwvYdfQCeWCFWFSKdoWJLtrzdZ8U+Q26yoZRbZ+0aDW989wu5reimMSOg6xVcf+R2ef2mJuaVVin0bSOa6yHQMkUgkQRgIYWCZNobpYCRSaA3pdJZGvRkzGQKI/IiG69G9YYBUJkm13uT8uRm68kVGhvr5uTtu49rdW3n4wf8kmUqSy6bp6u7DMB3cQBHoEMuyMS2TKIowDIO+viESiTSGNLjpptsIfGgEAtfP8Kbb38lKpYVpN6mWljh3usYrr0zyj3d9cV0PZ/r2NMklRbPHYOyLXczcauP2hNRGBBu/t9xGT77691f2CKyqoN4fjzEWr7KYf3PI4lUJ3B5NmBA89NB1/OvJ6zlQ2ciNqXE2W0vssVfplgKJxMQgJWxSwiYvE0RoNppNzoc5Am3SVDZNZWM1FfUBgyBrYtUi8ucC3E6b+uY8U+/rZ+nKFEcf206PXWOrM8/1yQly0qWmkrjaJCsDUjLE1QZpqbgtOU+f4ZEQIUtvDJGBRvqxBXrq7UWslQbKFFhLdQqn6/Qc9Knefek6ZaGg47CksN+JucJVQWMwPnFa9fgkLBpx+opIRDglGcdepTSrE0V0Klqb/WpT454qoKoWb9g0TnpDjSitYgi92R6DtOfUIoyfmdGUmNV4DCJdQZhR8SIvFOh2wKpKKEQQL+v8jpidkZoysecstBLxiMTUhFkVMzpSsaZZ2To+RVs/SbhzuzQdp+IFoN8XEiVj6JFsGHjDHrIlEe3/d3bPyrpeu6/Vpde6mvJA7yivv+pWRoeHOHl8jMcfOc8TT05yfv4ke260mJu3WF1IUujexobNO3j6qTmqtVmyKYvR0QEmj4Z8+98OMrStn0y/TyK7hWcPHOVfvnYfzzz1JIdfepHIbWFojZBm/KmvQSuIQoUKFb4fEipAGoSRwEmkyGWKeM2QM6dmWVhsMX2+jAwt5ibnGe4exF2cQwYe1159FcvlEkJAGAZkMhmUDtFCYxiSIAgw2iaTKIqHgZZl8ZEPfwRD2pybmeOZF8/y7MvP0rexwOxyFUeFbN3ehW+2qC+sTxLn9oUsvQ7qQxrjdJrhx1369klSs5rF13eSXIoz+1rdgvImi4F9IXYNwjQ0hiMKY4qN3xbUN0aEHSF+TtD7ckTPvUn2P7+NP5x5B2UVz48tIWN9NhqFoql9PB1QaTMzLBHiaosus85IYhmjpSie8kjOuyTHVxAaMhM1Gn0SpxQvzawrVznViPGlrjYZMqv4bWeDI6CmLBIioqEkrlZEGrIy4Ktv/jJaCvKTPn3PlOl/3qU5kic5H8+0yzviJVRy5dIXfWFeURuB6mZFatrE3ewRdgfxbDehUd0+GPFSL3HWobnFRzmxXE0nIpw5k8ScgbUqY15xMQQJ+w7vwHo0HxPgisHavDdKxNpiZcXUtyip1xJLUAKrIqEdQquBMBthNOVPkOjsiqA1GBFmNKkzTqwYaZtMRBTHQV1Eehot+ROApYvKkfI2SC5IZM1ApSL8nhCVUtgz9poUEFNTPlu85Hv7Wq2v1peOqD0atSadXRtJil7etPd6hhMbeemBiMkDOYK6h7S7eOzR0xz50SmKdhebNryTx394gVQ2w4W5Gr1dnbzw9Gnk6l5++OhxKqUMu9+wnS27dxKKiLFTx1mYPYMXNkAGhIGLViFSaqQp0TqiVqshhYlwHAwZm0KE7VAtV6nqFlbSwauU6U+k2J7rITcwSPfgAGPj5xk/fZZyvYFhmFiWgykcTJlgtVQjCHx8t07CNvFUlZbXwPc9lsuLbLtsB0maDHZpitki9UpIIpliZOsWhns7ufOWq0k761yWqBhGFHaGRLZm/rokboek79EZiieamC1FZMPQIyv0PVMhyEhqo4rBp6rodEj6gkur26T3BQGhoP/hGexywMLVBrltqygt+Of5m3isOUJNhUgkdeXFsHwMHGERaBgPOjDQZGULS4QYaJQtsVaaSD9Epxysik9QSNDqjj8kWr3QmMjz7LlNjPs9JETM67BFRFoEHPa7qKkES1GSTkNT04Il5VBWNodbG1ndCdoQuH1pvA4LuxIQpUxql3XS6BfM3GoROZf+8rVKMa8isSRxuxVyxcKes9ojCtCBbCM6IchpaJ9YtRUnTmvJGm7Tz2usZRN7xcBeMajc4CL6XAjlmonjIvYzjoeKSXAX4UXa0jGyUxNzMax2IKut49l0+xqtDRHOkoGzLLGvL8FF2/Zao49leyJsJ5n82OIvSipUSuF3hzQH2woOLTBqBlbJIMy2k00KPrT5z6/VT6fWlzyycQdLCy9ydvwcofapLDUoFEy29GYojhqcPb/CxNhLpJMGA/lRzh8vc/jle1B2xBf/6IdsHO7k4H5NZEnM6BXsMEHS6uTQ1DN85cvfYOemzdz8uqvZs2snP/uhjxAGHo6dpNXyEBKCIMK2bToKOYSEynwVw07iVsucPzfHTbe+jpmz0xR6u/HqVcqrS1STAVYrIIoEf/kXf8uffeFzzE1N4Dc9EAaGgIH+bkzTQpoWoe9Rryyj7CS2ZTM7M8X42RPMTZ9lz2UjZPO9rNZKpNKaajXANrIcOXqOru4kI5t71vVwOjZUaC4XSZ2Ll5tOSRNkBf5wF7WNDrmJFrmTHipl0+pLkjuxSv75OkjJzv9h0drcSef+FbSUaFEAIEoaFM5A512rLO8ZYf71Di/tGOGKN/49ZeXRaWjmQ4UtQmrKIi9hl72KLQSTQRcFo8lJd4DU6UXm3jpAYSLA7TCx6xHOihejK9ts4e3/4wynv7SRJ5Z3sJzPYgiFRHNb5gRZ6ZIQAeUoxalAkhY+WRHwSH0398/uJT0jWN5tE+TAqkKQSuBUFJEl6Doa0Ow2KW+69Jev3xuT24KmgdmQGM3YGRcl2trfMG74hWMmlZ0RZrktnbMEstPHd0xkIkReSBB1+VCyYomZBB1KbtpxhrTh89jEdsILqZjJbLZ5Fyq2XkcphQjin6McjXTjsYXZiBkXTklg+AbN/rizpgdq1BMpRMugNZeLr9kV41ARQCSIsGJXnyeIUiqOkWoYMWgpGUv2zHwL01S4dQfazr14ESlIjCWIkpog/1pG30+r1nVSPj0+SzpbJFvoYKVUpmewB5c5fvVTt5EtLPErv3YHW4dGCHyfY2NnGNxu43Q4jI4M0pUtgN1BqTHLbTdewb6nT3HD267GSHnMTtTpHRlgeqXKvd99lKa2KS2XcBtNKqUS9UqZ5fkLCBWwvDDLwvwFzo2PU61XWFqZx/Ma9PcVOXnsKAVpMdTRw1f/6Wt85Sv38tgzz5Lu7WPs/Ax+EHHy1FH2v/g0L730IybPn+HAgeeYnjhOKmnRaDRAK8or01RXy5yfnCTwmizOTbH/hf2cnJvm5ZPjeI7gpp95C6+cHOfpl57j5bExXjp9iK17L1/XwylPFggyGj+vSZTiuHvpw8SvgZ8RjH3cor4tj/BDModmqW3vQBeytLb3EhUzKEsiShVm31yk+OgYc3duIHIkuUmXcMsAidkao1+fRUWCl1sjLEQZjvo5xoIu9rU2ESHY1xrhh62N3FPZw4TXw8v1UVb8DP5wka4jTSJH0uqWfPjPH+Lqvz/EhqdbeJ2K7HmNdj2c00kOHdzM145dxw/mdvLVk9dx3+p1dMsm00EnAK+0RjjuDfDd6pVUoiTTix30PbtK7nxE57EILWHhzQGZ/ecp/OA0qQPn6TywSnXnpY8vzLIZcyY8QTTo4m9trS3Iwo4QEQisskF5T9hGarYbl4SoEefYqZZJlNSYCzYyECgzTvHWrsGPnruMR5+4Cs6kY5VFO/EbA7SjiDpCRFt2ZtZjdYxKxifjIKeJ0lG82EvGWFGZCfBP5Nm0cZGu0RJWyWDzrllkO+5LeQbaNZBdHtrUcUxX2/atbY0uBCDBSvuI8TTiQA7nnIMM4n9zlIxn0M5qzGzW8v+LMn2t/vfUupry9IVJ6q0y56fPUqmv8Nxzz6H9JPufH+PZR5sc3DdBNlkll9Sk0wJLd3PN1cNIu0LL9YiMGv/tj9/JN+55gtvfNcID9+9j7MwcjqPoGkiza8823vGutzI0OoiUFo6TJpvN0zM0zNCmLVi2Q1dXN8lkimKxk/6+DXT39OIkHNyGwE5ZVKIWiWSKb9zzDURL85br38TLrxxmuVTik7/+cR556D85fOggS0tzrCwtYBiKWn2V02dOUatVcBIW9917D7atSCQ0blDhyNH93HrLtcycr/Pii2f55tef5zO/8Rds3Xkj1956C2amRSor+csv/j/rejipWQOzKchMC+yqZuBZFxFpMq8k6Xt8no79FqEjiNI2OpdGG7B0XRFtSmQzNgmc+KONDPzDKyy8dxt9950ic2yByJE0BhxKVxWZ/OAAWwcXSciAotFkq1XhrakK78tMkZUB1yfP02eWuSo5yW2ZE1yXHafTrmM0AqKkieEpwgT8z4d/lnrkcOGmJF0HIbkcce5397LxP0sUjwj0ksPcSh7DUMw0C9y9cgMTfjedRoO/ffAOcoZL0ayz4mdIHE9y4c0dZCbr5J4+y9C/nmL7rx6mcfUwpTu3I1JJopzDrs/PXfK9DXMRZiUG+qQPJVE1i7AziKFE7Tmv2RLkTppIVxKmYhdc5pyBbBrIlsQqmdgVQccpCAoRYTaiNRCSvBCf4KNsPE5wluOTuFUTOEsGiTmT1Fmb5GkHqx43c2dFYq9IjKqJ4QnMHzvBdr4i6Xw8gfQFU/sHWT3aRfqC4PxLG5BGhHJNkPFCMqrYYMdqD+lKCj01yIToUCBaBupCCrmtTrC3gb+1RZhVuNtcdn5pheScRL6tjex8Lc36p1brGl/s3DHEwlKZXH4IS/axdYPB6bn7KU1bvOddb2Hq3AUG+kc5N7nAL3/4rRw79DyDqZ3YfQXOnZznvTekOfjgCp94z83c/8hT7N21hZMnZlhY0tSW5zHCOhtS/dz8xjuxEyaGYYDW+F6AISWJdAdaKZKZIirwcYMQVIDTtBjq28D55VP05FJ41SZ+ps6xVw6QkmnsyOHw2CQ331Jj28ZuHn7iJCNb9vLNr3+FPbu2wBVbGdqcYHFhkXp5lZXVEjPnp1haWeSpZ5/l7q8/hW0mqDbr/O4XbuVHPzxMtSq4/1t3c/DQ0/zxn+4nlymyaTC/rofT2OJjLlt4eVCWpDqSIH9O4ZwLOP+BfnKTika/JDeuGPuFIp1HNF5BoIVJ6liN+es76H1GM/erVzH4wAzNazeTfOU8znwDeyV+07sdef5uy30UpWybSWwqysdCsMGwCIjYYLRo6oCK0vhUmDE6aQynSU83afUmsRoavyV46ORuLCu2gWeOLzB74wC17Xl67j9LdfMW+r5ps7IrxeHdJuZGxZHyIGezPdhlwUOlyzld7mHxhX42/cNJhGOjyhVO/d9X0P8s2NWIL911F5+beTvLpVH8nIHaNHjJ99ZaNWK+cVIROZLUtElzqx+T10yNdhRuj8bPi7V0EaMuaQwpUjOSxmiEqMf26NJlGuFJdC4gMeng9kaxMiIREaVknOTNxZPyxSGvWKPKATQL8QzYqhgYzXie7PcHqGTIhjcvM1fL4l3IId1YdVHdEgfVqvNpTB2PQsyGJOz30RrIBahQUl7MIhMhVJw4p8+1CM9lYgVI2xEYGCbjH+2h45RiabyIDATJdRhzXqv11bqa8plTkxiJBNKUpFIRdqeP9os46SrPHjuGJKBW8ujdNMoD3z9EMhSY0UlWXIttw31E09vZOiTRTc3tr7+NHxw8QKFo0RWGpPucWPhuLYBcRKtuWm4TFYVoFMKQJJwEjXodKSTCMlGqRaQ90qk01++9kl21UcbOHiTfVWSuPEt4vsHc3Dyd3d1s2dbCcSSl1RX2Xr6Llw8epG/DKM+/fIbVsseGqRIDvaOcrB2hVlvloe9+HaTD/f/xfQgFtUaToa09fOtbL3LLm65ieXmMSNfYvfN6Bjp2MjTYwb7HnlvXw0mN22tLnDARL5z8jEAZJt0HX0UrVjenGX7UR2gN2NgNhbu9D6smqA0LDB/mbx+k94dL0N2BdgzcntTaZj6KfZOUIh9XG0QYWCi6jYDzodUGB0GgDQJtsMFeYekKSXlLlo4zIV6HILECrk6QnBe0uqG+uxdla5LLPo3rR+k+qKgNmvS+5LFaSXFgejtRn8d4fYB8DfY9uhctYfM3lkEropVV2L2Vzd/xmL4tSXJJ4mqTTw48xf/Zt5Vmv2DosUvnMwQdEbItS2tuDJCpEFrmGm7TLEu8nojI0GQHatRKacwli+SCwO3WJGZj2WFzILYvRx0hom7idUZxPqGWiIZBmGprlGW7B7edfpgaQoF21Bo4SLbiFG3ThcAQJKZs/LzJ2NKG+JpCo3t81KqN3dckmsjEyz1fIJQgGnLRrfjUrAHDiYg8Ax1JdCbESftES3GzDbPxuMIqGdglgyipWdkryJwXhAnQb6hc+gv3tVpXrWt8kUwVCKotVi5MUQ8XOHD6KPNLPsWuEbZfMUTPljSFgRwtHTA2vsz4ZAvBFSidxZAVTFHEdjpp2TbdnXkKaY1jK3bsGGHmjKJRSnHi8BJSD2JIC8d24hw9rUBFcUKzJVEEuG6T0soKKgDbSfLhD7+Peq3Gzp2XIUxJiCLQiiDShGFEvpjh+NgUvRu3cOrEKYrdvfzwhQMcPDXJQ0+8zOHDZxmbOMv8wiRjE+c5fnqMhhviuRH9fb10F3P0DaaIQsFzzz2H47h86r/8PKurFX7+5z6NY6W5+ab1zZSjpMZsQmpeY7pQPK5JLUe0uiUruy1qwybNHokMNYkTMzhjCyhLoMWr8fUX05XdToHKJdG2yeplOdKnl7CqAV1HXRJC4whJXgryMp5zKgQGgqyMM/mWoiQH3CEayqHTqPO+n30Gsw4rO821WCWhBDKMt/huh0HurKS6MUHm0CytLkn/0ysk9p9l4KEZisfAmUjgLBgUzgYUTsfJy6LloTcOYAz00tqQRoSa/ud8lAWf/rNPc9QdwvzAIsqGmdsunRJnLxsIHUvPZCtuXBgxOF4EcTI3KjZu1M/nEXWDsMeHN5SJUgqvS+H2R2gjNmOIpoFZl+ikIjlpYZUlyTkDoWJHn/RitvHFHD/txM3bqBkxurOdwxclFUFGE6YVfj5unNpR4ERYHR7WRDJmU5SSRAMe2lFkt5YR3R66ZCPsCCMZYjgRWoOxYsW/JkPU2cyahln68XgjKEb4fQEfu/1pktvLVHcENDeGRIfW9y3vtbr0WldTrlyYZ8OGIlsuG2VyskR/1zBL05rF6SSHXzqN2UwxMz/HxNQcBVPzur4NBOdnuXJkA93pXrYObydv9UDk05G2KRRSdG/sYnxxiabhUW/U+IVf/iiLi5MEUUAUn5HBNJC2JNKKxaVFarUaUeDR3dGNFBar1Tq1VouWW2X8+CRRpcrVuy5ndOMujp2dZXjjTp574SSPPXKYqQWNY6V45PF9LJYqhKGgHqR45NEXabghd/3D91BWlmdemeZbD+5jtREwNjlNIp9hYW6FbMcQ2s4R6h6eP3icL979aZotxV13fYfvPbW+jL7koqDVr6hs1WSnIpq9ktRMk9SCovdlFxFCek6RPVuHZILWjj7S8yHlLQZeh0lzY0iYfBVK43UmaIxkyFzwQSnMqsvExwT7WhtpqmjN/GWhSImIAM0LrY2MB900lMPViWlsEXHKG2DBy2E1NcXTEWYTqpcF+Bs9iidd6sOarh/OMHD/FOn5AJ2w6b//PCwso4MQXI+Ob76C4cHInx9CmYLOZy4w8p0ldLmKOnIKVciQnGngdtloM/6Q6Xm+xN3/dicNz2bkfx5i6JHSJd9bdfHbuaWwS5LkaQd8SWLexPBjipxZjRu3dhQYkDjn4J7Ox1I281WgvG4T2oLOEMI239iC1nYvThhpp5OsEeM8gbVsxaGpmpihnFCxdE7GEjsZijVYvVU2wDOw7JBwaxOhYv5H9mAClKA8lyOqmzFIf8EhqtgYE3HSu7I1smyhlp1YdhfFxhWViPXTIhLIqsnXHriVZiMBOh6PeN2vsS9+WrWuplxqlVBGSBi4fOh97+LYi0dJSpczZ15ipaawByQHf7hMbVZx623X0LEnxYbbBzGMDqIo4tzEMRKOy8ahnZybnWZotIdGvczMYouenk56+ru55+v3YFk2UShBOGhlEgYS08wyNzcXGz6UwnNdWq5PGEY0Gw3Onh4nCgXF/n6qrsvjjz/BN//9PlqNOv/y5X8kmzTYsrmf0F+m0azTqLvs2L6ZjqJFGNXoGu7mX+/7Dp5UrFYclBSslEokUw6d+RQ6cGkEikQU0W13c+LgDIVCN0vzS/zO732SdFGR71zfw7FqcSS9CAXz7/HpfamFNiUdR1axyi5eUVB4chxjbpnZOwapbLZZuMZCmSAjSE+aMQN4SJG+AJURE6sa4cxUCAaLtDZkGblXkJUt3Is+BqCpTbJS8GRzAyP2MoE2WIpyLEVpGsrhgtfBjyY3IyJo9ErMpqbvKYPhb0iMus/2v5tFZ1I0d/VhtCKo1lGrZbzLR5A9XeggQG4ZYfjLp0Ap7LIPUsLcIiKTxuztQQQR0vUB8LMG3Yc9/O40yUXNht92kcUOgs5Lp/CFuTjvzmjn54UZjb1s4HXH6gctYgZylIipd0ZD4vaFsZa3rWqg7ebLHbfipV7DQPhtDXMxhJoJPV47ASTO7JPthOowo1CmJkootNQYTYl0X51nh8l4LHJRcywCgTuVRUwlMZqx0cTt0msLvYuZU/HcWuPsLkPVoni0HcAaihhsRAzeR8f0OaMusWrxIlMacSPWCbUGLHqt/vfXuu78ZVdcz8KiS0/XFk6fmOKG62/h3W+/jbdc/0ayVagfUNz0xj383HvfTXMu5Par3s5Hb/9F3vb2W/iFj/0cm7Zs49jJ89xx53v4zT/4fTLJHKpqkEtmaTQatJotbCfFas3FD1oxfF5IpLAIPB/LsjBNE8/z8IOAerNBEPoszc/x3e/+Bzff8ia6+3q48ZabKdcaKGESKkmgNI2Gi6E03YUsmUyKXLbIkcNjSGERRj61lTomJtdeuZGs2cBvtSgW8piGYHTTENVqiaHRLqr1ec5PTCO05OyxC3j1iGtuHOWaG0cI9KVLtgBKezWJZUnYHWCdSTJ7Q5JzP5tm9rZOhB+Sn4go3b6Z87+4meSKonRdwBVvO8nAm6cpfaROYzSgcFrwvlte4H2ffJIwJTBaISqXxKi5WI2QyJGc9fqoKIua0nH6t1BUlCZrtEgLn6UwRy1KMBUUaSibV1aH6HggxeKNIa0eQfUGF6cSmxyEUhBGiGqcT+h22ZDPIjuL2M+fBCHQfgCLJRAC9+bdKMdA15vQ0wWWibtrA6JUobGlA7sSkjtbB8A6MIbV1P8ve28eJFt21/l9znLvzb2qspb3Xr196X1BSGotSGhB1gyLZRQsRgwxMEF4ZmwTjllsHHhigiHsAY9jPCgAM2OPw2awBEgIRiDwwCBALC0WCbVare5WL+/121/tVZmV613OOf7j3JuZ9bpbSF0t9QvH/Ubke1mZd8uTN7/3d7+/7+932HrHUbbffQqRvXLbVpHoNA1L0vaNfdKWI9iV2EaGzKB+TVJbk0Q7EntsjHACPRQcfVQgYoEaCWQ7wWrfS0PFXqoI+gK9q4mODv2M7BWLqRtM3fjIOnRe6lC+F4buKV9NJwALUXvkJ2K1gvZdu7AUoweesE3T0roIrRc8YWP9hUEOJbbmGyKpCJYB5wAAIABJREFUnqJ/rYXuS1Z+4Cpy5DVtE3p5xCcUJaZuiXb9lFNuMcGs1TxJb2nSRmmJe61wKFLudHa55557aS3M0+12sZlg87piZeF+XGB46tIVVH/A/fcvY+f3+A+f+i3+5f/6c1y7usXqydNcvnmNuSMLPH/5eT7z+S9x5bkNWiJisdEgCuZpLyzz7HNX+H8+9BFG4x5ZNiJJh0QVxWg8YGl5mdFoRKPRIAxDomrEOB6QJgP6/S4f+/cf41N/+Lt88pO/w26ny7OXrhBngkpzjg//8q+wtzuks9bHOct4nJDGsLszQKuIxkINGUm2u1tUo4j5Wp29rW0whotXLlGfb3Hr1g0GbsjJe04z3444d3qZJIlR2qCClLn5w2Wwg65keFdMdW5MuO8LMqqbPtHktKT1xW302DG4K8FEgpVPBVz++Xu4dHOZh46uUbkZMF4U/P6Nu/nQs29i/lKGCyXJQoStBIyWQhpfXOd//8TfZN20GDpF1yraMmPd1HhztMO6aXE63GJeDVnRPbazFsM0JOxZTn8cTn5ywPwfVoh2Y+pPrSOSDDvXoP4rI6LtkS+Ndg43HGJHI+zGFkJrWJpHRBHR9oisqmC+ibu5DtZSefoGrj1H7VoPGRs69zQYtzXu3jOoxGE1WA1x+5U3zUkbDtMy1K75XHe6mIFwpPMWvR2QLqfw7j3itiPaBWd97+GT773K2rs8iWctQ/Rklf6FzBdq4PtYmNf1yI4kxJs1TKJwNQMVO5k2yklH2vL+a2F94yEEfjon7Yi7FeYv7GLqhvhTS9hUwekhQUdSu65of98NGu9fx949QA+Fd3JIP7O2afhjU2NJupLy7OdPTWfIlkyKVdKmd2sMzma4wM9BKDLhp6+qO/SorOh7rSCK3sGvBP/kH/w3rtGCoysLrF2/wa2bXW7tPc2N611kGHPp2Q6tVYnG8Ka3fiOPPPAOTi0vcfTkEf7w059ibytjdek4F69c4cKJC/zqx/4t7/72d/KhX/+PbPcyGnXF4txR1m/2+Pcf/zCYjEhLjiy3yZxB2YT24jJRpc72zjad3R69wR6ffexRxonjwfveyPPPPM0v/+ovcWtjA5cpbKo41q4SCsvDDz/EXz32eVxtnstXN4CALBkzV6+gGwoXCSpKciys89TFTWxgOX73Ki9cvcHS0hy1iqDWHtPvw8nzbXo9SW9/k1bgeM+7v5EP/cLnuPVC/IrP7rv/pw+6rOawKzH6VkR1XVDfsDSujXBKEjx5BVZXcEKw/o42nYczassDHjiyzmN/cRfhnmS8YmlekfRPWu76lQFXv73JuQ/dwu11Ea0GZnkOeWWN1m86MiupqIw3zl3BOknqFN9YvcKK6vO58WmeHq5yfbTAZ794HhlLjt27ya1Ly1z45Zjg2jZYi0tS3OoSTkq239Bi5c93sbUQ8cwVANw4RrbnEbUqLtC4MMDMVVBPXEIIQfbgWfSXrsHqCrYWksyFBP2U7vkaYd8SdVKyiuLmuwIu/MImv/vMv3hF43vmw/+zEzth3ofYzxgNvuFQtpAhB96aZmoOWzPULgcMz6RUbgUk8xbdF5hzY9xWxI/8J7/Hz3/+ndhYQSrRPeXbaC4lvuWm8TqtreSqvXTIkfJ6c+ilCRtZhBM44Zh/WpO04L5ve47Eai7+/jlEBuNlS9iVvrhD59NLhfnvV+LdG7k+LUd5pWDFb7fYR7DnXSNZUVxiRV5t6HKJxReTxCuGq3/vR1/R2L5Xfm8ZZv81+KT92MuO7aEscbW5DGcqYOusb+3RboeMBvN82w99L7/2Ox9h7iQ0m4btG/tsXOvReKSCICUZJHzX+7+bP/nTT9PZ63P14jbv+56/z6/943/Ee97xCHNBhQ3bI7aWQdbjxOkVfv2jH+XBe8/zTW95I2s3r/Lsc8/z/X/rA1y9co16o8Vw2KM/3sOYmJ//2X+LMJpB//8mqoV0B11OnTtJPByjZcDVF24hlGSt+1cM4wzZ28EKR5oOCWtgKxl9EyM6MExTdnWXY+cWWd/aZGv7BqfOthHCoauaTmfEuQstnvzMFnc9pOgmbVbuWeAvPtfh3rsONbxktem5XdkWJPP+1vj5Hw448f8q9KmjZK0K4fUdmjdbdN/s5ZK9uMbffu+f8O8eeyuyG9C6Yjj2vhv8xPs/wU/85z+EbVRgaweRGeQoJbv7BE9+os7g7oTvfN3j/MnOXTx++SS/8c5/zce7r+dEuMuNpM1G3CIxmvt+ehucg26fuYbB7XVI7zuDGiY4LRFPXUIEAUe2WrjBEBkGvgX2OEbWqz5SHsfQHyLSBL2usXefQtzYIri1R3rvKd/GsqIJOzH7Fxq0/3KD3sMriMyxfzpg6XFH/75DiPb7AW4xQQcGs15lfCTzRCZ88/qs5pN1LMXI7Yjh3TE6MqR3Z9iBpnI1QN+oMF4U/J+/+q2Ewne0G907hp4va5abEZVtwfjhkS+FtgJnBPQCXDuBvdD3rmgYZE95i9pSzPHvuY4WlicevYt0OeWB91ymn0RcfWEFcaqP2a4hkryLvShmzBa+VDsWCCsnPZV1T2EqDpGBThTpgpl0l5NjP7uK3tZkdd+0yETOT301LDXl1wqHGnnhLDevXOa5p55EKcEz15+jurjK9c01fuMTj0FQZWSanDh1DytL57j4whp/9MdP8tMf/D/4nd94FJNaXv+6t/KzH/0Iv/8HH+c//aa3kg5T9hqKU8ePoqgw7EOW7rO5scOpU6f4whc+j3OGk8dPMhyNSTPLeDSi191nONjjueeeobMXs7s3QGkY9Ec0Gwv0ezFJbOj3+zTm6oytoTu29Mcpnf0BrUadxXaTVqvF0KTUaw2k0NRbbaJWjSvrO6BrjIeKbqdPtdEgqoZkznL12jbn716lv7bA6lLGxq0uz689T0cvHPoLalwXVJ+p4CS0LjuSeUG4EfArP/OvcIFCZJbRhWWGK4rwSgX1Z3OMf36VX/yjd0AmOffQTX7sX/4iV//4ND/xfX8HOfRJNXfhlG/c1B8i44zqpuP48V1++9kHsU5y4uget7I5+iZiI53jymiRjVGTJy6fgO093MY2Qivcfg+xMI/eHyNGCbI7RC4t4pIE1+9j+wPM1g5yfg61egTRXvDRdLPu50FsLyBaTeQLtxBa4wYj9E6ftBlgqhKMo3llSP+BZSo7CaMjEY01Q+uFATMzW70iuIHm3tUN1EgQ7ihkKtB9wbFH1iazSOvLFYJ9QXupx/GlDnY3RNYy9u/JOPKBq6w8lvLd3/WnjE8nDE+n6FsR7sQIPfRR5+BCyutPX6NWi2nPD1Brke/+1tfT5kOJxDYNteN9zEaVLz12mqf+8hw2dIix4uknT3Hrc8cQsSS+3sh7M/sIVxjvey46xpmqnfZTVpAtpqCcnyqqbgk6nvyFE6jEV/llLTvpxVE0TnJRGey+VjicprzVY3m+yc2rl3jogfupVechq3Lz8nP803/4X9MOLSoMmGsv8P7v/RvsdNb5s888hqxYPvHbv8nHf+03+YPf+13+zt/8Tt785vtonIqI2hXCWFBRIWdPHwc7Yq5R53Off5wP/uzP8IUvPsFep8NwlLCxuclgMCDLMnZ3d9jaXOejH/0YzkmOHj9N6iRpltIfDOjs9bl5c5ud7S7DuA9KUa1WkUAUaCSgkQwHY1qNRTobHXqDmEyAdBln7zpLVIuo1SOQMYntkSYGJxL2di3b+1tsJ9tcvLFPNpBE4yWk6Bzqy4l2BfE8NK9b+vclpDXAQeMqfOu//u8x9QAbKcaLAe4/2yHag6N/PsCEgjO/lXL643Dzj07ywf/ib1F5/S7D1SrZQs3LDJFifM9RMJZ0rsLyX2wj/80S0ZM1bvbm6Mchfzk4z9p4jqENudRd4tr2Aqc+Jr1P/PxJrxWPY9x+DzZ3MRev4G6s4QZDhFKIhm+xKSsR+cy3ftmFFu7mOrbT9RE3kD58BlevIpp1AFRikalDOIfa7hHtJOhuTOPSPiq2k/VeKYKO72/89GfOki4YklVfYp22LRvdJubEmKAnMTXff2L3+jzbf7iKGkmOLXVpHevx/GdO81/97K/ykd9/G8QSvadJFzL0xSrjoxmmaSEVfPaJ8/T2q/T/aolsKUWeHkBo0Ssj5HyCU46gGSOElzIQeYN77R0Snmwd1XWZd6kTk4IRLLn7Ip9WKvMXE0/YoHcC77wY+F7J6ZHUF6skgrRlvF85n98v3PGT+6mhhKzUlF8rHIqUtY4JWhG2qrmytoZQkthso1REf7xOMpS4xHJt/wYf+fC/43NPP8m73vVm/u4P/zC9YZd3v/PtbHWvsdF5jI/8h/+Lb3rre7j89A3Orx5jb6/DM0+8gEsMK0cWeeNbzjK3uMQw0/zSRz/Mnz76O/z5o4+ys73Jz/3cv+Av/vxR/sE/+kkuXtog0JLdnTV6vT61aoSSAuEsy4ttFJLhCI60F7FJTLUiqIYB3XGfvWGXVqNBb7+PIyBUIaPukHQsuPz0ZUIZsrfbxw1rDK47qkQEoaO9MIcdK6K4yXgj5sr1myxULWHlcAZ8p7yEYQLhG5srX53nFOgByFGGTC21zYTgo22WvzDmxrvr2B/cJthPuPlOTbQL4c0O6rcXWHurQn3+OQbnWujNfcLPPIeLE4ZHAzbftsSorRAGxK8tEv/5Ir/4+bdysbPEb/3CN7Px2aOc/5Gb1L+0BUGIWNvG7Owhmw2Q3smgT66CUtheD7F6BDcee7miVsV193G7HViYg90OSIkIQ9xeB0Zj9GMXQSufCExSwvUeVglsqMiWW6jYgHPIzT2qz2+RNUOy6is/fdOWnTSS93XKUxKKN2rIWxXfV1n7ZNz805pk3pEtJ2x84QjDYURlR/CTP/8D1NYkRz4tvVNuoHxj/MQTn973FXNupDD39tG1DGskUSumUYsBCObHhKGhv9ZAZn7W6aKNp5cevCY8vCvxckfdF60U9jyn3GTKKeEKYp6+B94G50JHsB6ghzJPMorJ3YbTjqTtSdpUDnkLUuJQOFSir0SJEiVKvLoo1fwSJUqUuINQknKJEiVK3EEoSblEiRIl7iCUpFyiRIkSdxBKUi5RokSJOwglKZcoUaLEHYSSlEuUKFHiDkJJyiVKlChxB6Ek5RIlSpS4g1CScokSJUrcQShJuUSJEiXuIJSkXKJEiRJ3EEpSLlGiRIk7CCUplyhRosQdhJKUS5QoUeIOQknKJUqUKHEHoSTlEiVKlLiDUJJyiRIlStxBKEm5RIkSJe4glKRcokSJEncQSlIuUaJEiTsIJSmXKFGixB2EkpRLlChR4g5CScolSpQocQehJOUSJUqUuINQknKJEiVK3EEoSblEiRIl7iCUpFyiRIkSdxBKUi5RokSJOwglKZcoUaLEHYSSlEuUKFHiDkJJyiVKlChxB6Ek5RIlSpS4g1CScokSJUrcQShJuUSJEiXuIJSkXKJEiRJ3EEpSLlGiRIk7CCUplyhRosQdhJKUS5QoUeIOQknKJUqUKHEHoSTlEiVKlLiDUJJyiRIlStxBKEm5RIkSJe4glKRcokSJEncQSlIuUaJEiTsI+jArq0C74rlzDoFAFH+Ll1kJkFLi3GRVhIO5+SV0FAEOEPnDIoTwy9p8uzP/Gmtv27LB4XDWgfAHIKwD50BYrLUYYzBphjFmsm0hBFmWoZSiVglpNyq0dYP1/Q6Zg51hDyEUUkqssYj886pAY4xBSkkYhoxGI6SUSCGIHNx75Bh/duXSlxmJL4/36g9MB8nln1X89ddRodR0+Rzq6BFcJURYh5Ni8v+BMbodt4+vddPX8/HFOf+3lLgsgyzDJSmkKUg5fS9JEFojmk1YaGGbFdRGB4zB7O4hhAClwJh8sw4Rhn47SiGqFWyv7z+bUgghsHed5Pc++xOvaHzv+smffokP/AqQn6pO5s+dfzjlz2s3s0zx3mQ9bvvbn6YvHSpZEAaEzb8zB046cGLyPKs5ZCqwgcM0LHIo0QO/vFP5+s4fq9MgE/87dTrft/H7ThsOpOPKj/x3r2hs3yu/99UZ2/8f45P2Yy87tociZb7c0N9+8sGEiN3tKwpLmo1IbZqTpD8rhXAUZ6hyOVkLMBRkkq9e8IOYbts5/+NWSJyzOCzOWXDTi0JBykp5wjXGMBwnDGPDXhQziGNwEucUQoC1dvrjkeLAxaUgZOccmXUYIfjc2vWvdkS/ZnDjMaSpv2BJAWJ6AZ0M4ItWci/7vssJW0gJznlCzklbKImzypOyEIhAI7TGJQmu14PBAFmvY3u9gxvNCdnvUky3A1NCthZnjD+mJy++4vH4qlGQavF/AZeTWk6axbIiAaQnwQPrv8xvRrg8kBEgMv9cOMAJT77FOS4d0ojJdlQMScuhEtBDgQlBZIJwS/l1pD82mW/Thvn+Mk/wTjlkml9U8MsG++Llz4kSX3McSr4oAoCv9r0XnZhCkWUZ0oFCIJ1DOoewIKxFWItDzJzT/pmT/mGFfwhAOoHEohAoBEKQk3xOGML/4IMgQOuALEuoVGpICUrlw+EMoyTNV7HI/GUhhI/oclLLsuwAwRdQSiIESKm+qvF8Wbjb7wi+zHLFYxZCQpL653l07JybPl50x1Gs9/I/TiGEJ+RiOTtD4EohKhEiCnFxjGg0/H6DwC9jLW44PLAtf2zywMMlaR71O/9/sbzWIOWB177WELYgydted0UEy5R0i+HMXxPWE6X4Sr9GMSVpp/IdOv+aNGJC3sG+QKYQ9ISPfgXI1BNwcaxFdFxE1DIBkZOwCWfuVo1A2PxRxrmvKQ4XKX+VKEhNyIM/dIEgSRK0Cg8sO/v/V7cfv1XnHNYW95PT94vIuD63yH2rD5MOE55++os0mk0Gg96ErITw0TAwiaiNMQekl+JvKSVCCMxMtPf1hB/TnKRegqzsaIwMg2Lh6RvyFUZEQkwiaXe79KG1vwtZnGf8pnPokSH4yz1kewG71/HrOeePsyB2axGBxqXZASnFZdl0f/LrlAK5TVqYJalCPnAy/+zitnVm1pv8KZlqGS9DeMV2hPGMXBDvi5aTXqIQGdgAsrpDjQTRniCZmwlZxG3H7cDK6fPZaNz5aGb6OQoZpcRrgkOd5U7kX6hz/st1DoubvO7yqFRKiVIKpTRSKgQSgfRcad1EcshMgpAOIQ+euUopDNY/nEN6yWvm4RDWIvPfrVaR/3BSIqSdnGHCgUAiUTTm25w8eYZapUVmYOXYMmmWvohgrLUHyNlai8o1TfCfOQgCr1XnOvVkcL8WJHJbFCykmOisk8fk4N0BSYAse0lNWmiNs3byePE+82i6iGKj/OKplJcnJvrRdF27tED/whxZTSIyhzhzAhcnB7Vr54/PSxXKH5tzPhLOt421iDDw5JymByP3VyFSFm76mLxmxIHIcTZBUtydza4jzAypzg6fAJmJafT810SgxfZeKh9TRLsyEagxtK5Y2s8a5i6CqTisfvG6Tnot2UkwkZsez8xyk+Wdf28a9ZfyxWuFV0dTzvVJIUUu+4qpBmZndeSZ2yUkQshcNwYEpGk6iWInu8ijVkWRlHvxYUgpD2h9SkmMkSglUblu7Iyd7GduqcV/+d3fx/0PnsAIiDPJP/vnP8NgOMDZkDRNJ2TsnJtEw1prn8jLj6+Iiotk3yQpmcO+nCzwSiBkPr7yYHT75SLz2ehZCh8tKwVazyTtfKJuNun5IhQXoSIy1gqRStAKhAZjEWoq8Jsj8zz3g02O3bMJQCfTtP/HCL0fgjW4ceyPO08Eej3a+sSeEBBohDGTC4QzNift/BiKY3wV7kpmI8oiCi5eOBAFz0bPbrqyKGSxPIE2G1074clQfJnDnJUWiv0VxDk5xiLCtRB1YO5yys59AeMVR/MFUGOBifIoW06j+IJcfXSda8rB9K5x9vMeeM8xjZxLfN3xqmnKTuS3sZMTlklC7OXF5dmtCKy1pKnXPqdSh8PY9MXJwRk4Nw3SJslEZ8myjDSxmMxNNTeluf/MGc6cXuTWRo9hHNJordBstFAuRAhxIBIunhekVTg4rLUTSUPlEVuxTHEM6muheTqbE2n+UOorlyCM8c4I8Ovkj5fVlAtYOyVAa71bw1qvU8dJHoHnx6AVnXub1E72WN+aY5QEHGn0SOejiUYtAj2VIoJgIk24PHJ2STqVMYIAUWj9hZsjH1+hXx31zcn8od1Uw2Umei4i3Zlo14kp+flxORhtO1HotF/BvpXDhA4bOJx22NBhIucj4MCH5E76HEttw7D2TZrRMUvQFYxWBOncNLARjokufNCp4d8voufZz1hcmIooWbgXXxhKfP3wqtxfO2aSRhM9Vn7VenCh2VprJ6Snc31SfJnU4SwROueI43iyjSKxJ4X/0b/+9a/j+77jXVzf6pPJiH7i2NnZoj/ooPTUiVGQ8Wx0XETP022LSdKwkDhmCfxFWuth4LzrwFl/BRJKTsnqK0ThgCDLPMlabzv7qvR752A0nkodPkM6IeXdb1pl5zvGDDbrIGAUh1zrzBPsJ6AVIgi85qy1J+gwmMovRfRszOQiIISAyBO6UHLi6HiRXe8wmE2KFRf3g0Hzy68qpqTmI8yZdYQ7mECzLzO+IidDW5C5fy7Tg1JK45pj50GFTAVBV5I1CxtcTrQz0fZk0zMXFlHY6nJrndMOqws3x0FZwwZlpPxa4VUhZVmoxDkhSSmRShJFEUqqnEimy4uX2a21FgekWTolOBRS6Knz4aWIOT/brMsQ0vn/lSIKtfce12pEQRUd1Pjh9zzEC9d2QISgKtjMsbvb5w2vex0L7WW01gRBkLsz/H6jKDogqxRkK6Uky7KJHW72cxQXmFcFQnr5Qil/51F4des1T2g5wf51mFy4kvRghF24LL6M2wLwRFi4IaREVCIf4daruGoEYcDmt8VwveoJSTpMJunt1dh4pEF6dB7CwBNzFE3kClGrIsJgqhEXhKtUbqPrH3RaGANBME0CvgqYlQ9wAhULZOpdDV+RG8EJZDazzkxCcPbx4vUKovTkK1NPwDLL/89vbKIO9E+KiQxRWN0EEHYEMgGrp1KKMN6v7K16whPv7G7VVFax+R3CRGfOt13itcGrcv83yfk6kdvBBFpplNbMzc2xtr6OFAKHnSkveTGEEARhSBSGWGORyh/erHd5Rsie4Wd3IEoVQuCQaK1QKqDdbmN1yD/8nrfzbMcSNts05+aIs4zEeNfz2TNn+MLTF6nXG4zGQwIXYK0ljmMQUKvVSNOUJEkmCb3ZaBmmGrJSaiJtvCrItRlnpff8CuEJTWvEiWO4F65+xRKGrFYQlYrXaXV+fIUT4uWiT+e8Dg2g5IS4XRiAVqQrDZwUXPoBidzSmIZFN1NMJrE5OfVPW5afkNhmHTkY+a/OWtxg6Im5UUfECW489tLFTOHJZH95XkCEob/AvIry0KweLBMmxR96IEibU7J7WbISDoc4EG1P3rLixczuptJC8efsc5n5YxIGamveh5w0vRwiE++6EAZkIjCVPKoeCkzVYYuLgoWs4SNpkYmpBl54n8mj82IYXW65K/Xk1xSvCikLAY4pMWmtadYbnFpsk6aKXq3DYDT0vt2X+b6FACcEDoEOqjiR4ZSPjIWQuYfYAQLrHHImanboPM833bhzjiAMUVKysLzCd771PqJQovZBa8U4zUjTjEajwX6/S7u9QLu9QKezC0KQmczfjQaaJElIE+/MyLJscjdQSCyFFe52HTpJkldjeCkcE0IKHxEHCjHfIjm+gMwsancO2+35YouXkUwOSBOVCJHlBRhF5K3V1DNVJNMKoi8KTopkabGPMMBpyXAlZO0dIEIf1jnlI2SXSoJ6QtoPMQsZo+WQ1tbAbzv1Ua4IAi+pjGO/bpJOpApnzCQ6d7O6dX7H4EbjV2d4HZAXUrhcSlh6KkP3DXv3RDgpcMFL6MhAkWB2yo+TTPx56dSMw+ElSK5IEM5Gp1ZNCd3k2q+PmmHnGxxBXyBSSFsONRboUX5MOammLa87Y5lY56SBrOJA5ySeMXGPTC5ERY7W5e9ZMYm6S3z9cShSnshVziGVRAqFwyfCThxb5rve9zZUqmlU3sVvfvpLfOZzjzMYDLCuuO2cprSdA5wjM5YRIYHWhDIhS70ubIw9EBy7meeFM8A5hzWWJEvRuoIQgtE45u6jTaqtKpfWxywuz2OCBkFUY2GhQpqmVHSIcgnjgb9wSKWQs4m8SoU0Tial2LMui9ttb0UErbV+dSLlPEoWOpiQrksz4tOLXP7OEBzYynmO/Ylk4Y+vYLv7nsxu30xBpGmGMNZHvEpNi0qy29aZLQiRM8+T1JdMhyFOCMRgTP/EAq6eoNcisqUUoRw6zKjPJcSpJgv8Zwj6AqclKImw3v5GGHitezSCJM0LQ2b2d/sY+pMBVHD4RF9OqMIUkoN/2VRg4xEFTpHVLRc+OuTWNzcwFTDhbduY0Wyd8sSoB9625qTwFXRiKg0I6yPR2WTbhBSNT7BNEm8xhF3YfchR3ZDe9iYKt4Ujq+VVfFWfGIx25UQLLshaZn4Zb43z1jlhmHzeA8el8oS4dOhRmeh7rXA4nzIOIQVhGFIJI6T0CTWlFJ39Pt0+bA1Tru4mvPmhs/z4j3yAeqv2EkmwPCJGgs1IejuYdMxobBGVFoQNjA58rwZVJKUcxmU4ZxDWYrIMZ3zySTio16tYY2hWIh556B6yTFOph4iwibCCAJ+gM3FKvVphv9+j0Vym3x8wGoyn3mShkSKYJPxmo2VgEilPxiS30MVx/IoKXw4OsLeCyWoVWa9OqthEoAn2RuihIOgLom3F9jcIvvQ/nEa2F6bOjNsgckKzna53TQxHEy14oicXFxkppk4H67xHeNam1mr4SstGlf2HEsgEpmYROQELAVGQkaWKsJpCPyCeU8juANEbMFlICE/SQQCB9udGkk6jdOcOFo3kJd1uOHrlhS/kDoN0qgEDeVFGLgEEnszpPDwGAAAgAElEQVTCjuSF99eZv2SYf96+SJudbC93WjgJybxlvGKJF+2kmk/muu7EF537lwtdV+YVf7P+4eY1R7zoCdMGTI5LGFCJQI8EpuIJ2VYsSevgd+5k7uoIc1eJ8J8RDhIy5BpzXo6t4jJSfi1xKFJWShGGITrPviulCIKAhXabbn+AQTAcp6hqlZGrsJ+m/NO///0vH0U6B8bibEwSD0jTIXFnkyweIqTGonBIgiCclPUHUiGFpBJGRJUKURiy2JyjUg2Ym6/z/e//DqzLGCUx1eo8rXaLWq3GYDBgPB6jtKLT7WCtZX19ncZci7BamWjFSkrkzI9fCEG1Wp055IMXmCIheLtn+ZVA6ABZq/kkGHinQhggj64gd3tgQY3yfgcGZCz50o+e9MsFL44iJ35tY3DDke+HsduB0djLFwWK4hAh/OtSQLUC1QqiWoHFBWwtIm3XuPSBOZ9MSiSuami2RuhKSjIMGMQhSlvibgUsNG6MsQtNqFUPXgRmLl5CSUSzMT0Waw9o3QcLS175+Irc8mWDqQ3ORA6kL1sWxke9NnToseDW2wVJU9C46lCxKOKIqQ4sfTJbJaBHgqAnUGNB2rSTKLWwuflqPe/MAE+wWE+Y4b7XjNUY+scFybxFxr56TyZiYt9TY0+qeuj3VbumCQa5bjyTKCye+8KQmeDhdpfGrANjptdGia8/DnX/F4UhSIHMtQQrNfE4RvVHzLXmeO756zxw/72EQchw0GHkBIkY85P/7Q/zC7/+hzx18SoaByLzv0shECJEBXWiMAAVUK9EpMk+xiQ0qgHNeoW9vS7zrSaDXo8wkCgpaUY1drr7nDl3knpjHjBUtWJnb4dQjNH1eaJqQJJYglCzOr/CKI4REioqYi/ZR9Ul2f4ILYUfGiex+Y8tlDUckvF4RJqmE2dFIV/cbokrrH2HgaxXJ3pyERXa/gC534PFBeYuwt59Dhs59MgLhCoRPPtTD3HXrwwRn3tmst4kag+170tRqXjnRKMKo9hfDJs1zFwVvbmPabdQ3QEuCkBKTDNCb+4zeOAISdMTuAkE4Z7AEWBqFlkxpJkiDA3L83364wgpffQs9xVZVaG3E9xsgrEoCKlXvZowGEIc+2QfTOWLoupPenukKxoTvUK4PBKURkyaCTktSPPEmNW+2Y8e+gi2NpQMjoOMYeE5y949U6mg2IaPMplW0gmwod9m0BeEAzCRX84Xe/gI2QbeARF2BVnVR8RBzz+vX5eMlxxGOfTQyyLJnGN81BB0FTaCrG5xqwa9G/hGQzPd5GCaRJxo22Iq1Uwic+XP88LjXCb7XjscipRF0XBHaCwCKzVSw3DYp1pvcXNji3PnL9AfxjRr86hQsdvZJXAR3/nON3Dh7AqPfvaLjNOIQIeIqOrLtKUllAHZaJ9AVVhebGFsSkBAqANcs0a1WiGUGcnIMHekhTIhFZNgXEqjViXJUtCKIKiglCQIAyqViP5ojEL66kEhCZBYZ9jZ3cFaR7XazB0XXnhzwtv0hHXYIGA08m4Ba+2LIuJZC5zWmuywlq2X0FNFGGK7PVSrSWMtZf98gB5JspqP6sI9iaw4rv2NBnMXXs/iH9/AjWPfHChv3QngogDRH+ECRdZuI4zNNVCFWKhjGiFoiRwmjI/5yFWOa2AhqQtUTlxW5wQUOqIoI4l9VJ+mCikdQvh8QbgrERZss4IcpQc/V3FHYSyuP/AOHWOmvTEKyWRmPEUU4eL4lY9tzlQmdDjtSbGQELK6A+mwEYD0xJyBGgEC9k9JFp8yCOPonvU/IVPxYxG3vcTgu68J1EhQ3fTMl9WYNC6K9iCZ989l6o9nvOyJWeREbSqOse8Y4IlXS0/e+xKVKE+gGQT7apLtswETGWXiAhF5Uk+SyzUzvTVyOaXwOBcyx5erQizxtcWh3RdpYkizoSe+IMRlSd4cJ2Y4HrGxvceJ4ysYLdFKsrK8hMsywvYqdwcR33Dv3aREPPbEM9y4vo7Wkk53h1aoCesVWkdXuXn5MkcWqjgVoIIKQSXk9W95E9ubWzz1xSdp1xfIUAzHGckwI5qbRw8HpFnM+tYtnDxKbXiLwfYe7eOniI3D6QrziyvsdreRZCTxEJulyEChCTCZwBqDc771p3C+kCSMAiRiUlo9KQNXahIZF5V/r0aiz43G2HGMCDSyWvFOhTz61YOMynbIcNVNKrbiJYOwgnTO0r0g2b3/JMLB4hOO5uUBLlDo7T62HmHbdYbHIprP7xMfqeelthJTUay/OaCyBcuPD0jmNTjQw4BgmJE2A+zYR5S1TR/t2qHGdBqYIwlkEhtIFhZ7dLp1wEeQ0lhskPucU4PIDro5XKARtVwaSr3X3OXNi4TW08g415UPk+hzepp8U2PQVvpEWC4F2YoFCSaWmMgRDDyZ6YF3Q2y8SSIT0AOYu2zpnpPooZcBZAZpYxrVmsjrtKLorWS9RbC6IbGKiYioxvldjfEXBj3w36PuS6pdRTrnqN+QmMhH9UkrPy4LNnRkDd+cyDtA/Gv+w/poXg29Bg1Mez0X4yGmxzb7d4mvPw5FykUTHq8ly1we9Am0JFNIXWeYGHQYIq0iSVIQYNKMaqjRUZ29zh5K73PiaIN24xyZjdntRYy6I5JsGoEuLi2xuHKM/d6A/miIGcbs7e0xPz/P+fPnub62SSr2WJyfR0lNJhV73R4LzSZxmlCv1siwhDVJTdRo1poEKqRaCxgNzaQqL45jstwuJqTy0prz5S5CCipRxHAwnBBuESXP9o4oHofufZFmuDRDhkFeaJHLI5UIkhQbSFTsJj0LZCJwwtugbOD1y6DrpaXBMUHSaiAMREcjwm6GSvOkXGYZLmtGy5Kg5wiGDhVDZc8StyM6FxT1W34f43Y4uQBUOpa4JZGpj+qwoCKDrKY062NCbYgqKbELfPQoBHqUItK8kX0h/RSRspSIagXX7XlNXEhffQj+QpS5iRYthDiUfOH3CzLXhwtdWQ0FredBWM3wqC9hlrF3RAQ9gdU+4tV9r+/GC461U465p2C87PVgUwE99MFr2BWohIl/OatC2vRuChNCddMxXM17GOfbK7zIpuKobEmGJwzhjvKR8wpUtgRxfmdkE188YjOvYdtgKj0IM9NTw+H7PktP/k7l0bwRWOWmrUInlqZDDW2JQ+CQFX2OsKIIw8ATmJBoFWINIDTbA8sLV9b54hefRWnBkSNHWVk+QqPVQIcKY7yDY3tnzMpKG3RCGGpCGkilOX3yJJ3dbWq1Fp1BQmbh6LGjKKW4eu0iq6uroCRbe3tsbGzzLW9/M+cvnGd/f49Wq8Vcq8Xq2TMElQZXb25jVMDmrQ12d7YYJQnXN65y6/Il5pqCt77xYY4tziOcQCqFksK7SYBA5TYurQnD2oERmG1cNFuu/LLNfb6a0XUOWa8iqtVJBZ4IQ5+sE4KgM2bucsrCkwKnwRyJscsJWcNiAzeJzKI9x3jJ5T10c81TS7pnKlS2U0wzIux7p8DwqP/Btq5YBqsSp6Cy46jfSrj57jqdC4pw35G0BPGcpH/aN8Op3fKk4jYqpHsVxknA+vo88bUGtUaMfX2P0YpPIDpVWOPyxJKW00c1mhmAvOdGkdQr7jyKPhmH6cKXJ9YKcipKmU3F0b0Luvd4WSHa8Uk/FXuSTeYdybyXPJz21rHWs4rhqiNZsBMytiHEbX/RGx6z9M5ahkcd42WbV9v57Y+XfKJWJbmOPRZ5n2The2CEoPqS+Ejmk48LGb3zGem89UTuIF70dy2FT3m2g51VeTVhbncTmZj02UDkVYAzZHyg30eJ1wSHipQtIJ2YdC9zMgKZYk1MEo8QoxHdKOLKeo9jRzdJ04zl5TYLzRZZMsZmGdubWxxZWSJLDSGawWhEta6oNk6wtnads8ePMbdylM2NNZ67dBnhJFGkOHP6BPu7O5y/cBeNRoX1jX3GgwGDeEwYBdTmFjhRrZClhovPPctCs8buzg5KOuabDTLjb3/bK0dZW9vl5KkTrMy3uVXbZTge4vJEiZUOJyQyL48RRa/g3Pp2ezXfgWmuDmuJg5yMyJsHKVAOksTrxMMY3Qto3oTh0ZA4jTBLCaKZ4lJJZgSVbd+0piga0ENI65KkIWncStk/HTFeqlDbsCw857VeUxF0z2iiPcfeXZqsDvV1hR6BGjlM6KvcTMUXMyw8b4nnBNGuwElB2hSMTMMf63JMf6PB0okOo8UGtUaIGqSI4i5CcsB94YpScoNP9hXNimaki4kb4xCkLKw40MO4qGxTifcA29AxXHUTfdbpvBIutOiuIqu6/DVHvOhQQ0nYkfTuMjReUIyXHEFfEvb8HUHWdGT13EusnXd/CK8B67GvystqeTIv8clAkUmGpzPkUFK5pREWEgembom21MQhEnanlX6+ClAc/JwzfZRtrhkXvTBulykms5+UZdavGQ5FylIF3rOb5Zlx7ZCAkiHCZWTxPvvbDttI+YNHP8ff+8C30tvvUKtUkVLS7fZoL7aRIiEM6zjZpdffJapE9Pa3OH7yAuloiDHWa8zHjtAbJdx/92mee+oaURW2t7eo108jlSKq1lHVJludEafPnKQSKPZ29tjb3gI3ZGdvi2azhR72iRpNpA3YHo0Q0tHp9VlZWaByJcRYS5bl7ToFgEA4gxCSZHYOuVyimNWTZxsSHZaUDzQQUgqhnfcuBxqsQYxigg2DTOoc/6OU5/92hOhpXMWCdAT7kridS0AhOCkI+4asIoi6lt6pADXOb6srgv6qRo8cnbslC89YTCSobjt6NYHVgqwCJhKEHUd6KkZpS9YJqewq31Zy15E2PTFnNQFGwE6EENDtVVHLAlNRCOOQmZ26L/yAelmiIFzrJs2JfNl8MShikvw79J1IXsRRyDGeCL32K4TA5eSMgKDr7xoYKS8J4ceTfAYPFQuqWw4nFP3zhtYziqwOvbOWYF/SfAHSht9G2shlkZno2AT+GPQI9h9KCG8FqFhQu6pxKvcoq7x721CSLFiEAT2QpC1HirdHOnmwmdCEXGdKq18qCj7Q4Y5SU34tcTifsvB2NGRGkg6IxwOyLMur88DZFKnG9PtbZEhMPCTLUsbjMRvr64RhFWMNveGItfVNtjv7LB5Zpd5qY7Qkai/xhje8gZ2dHbLAcfb0KS4cP87a2haIMZVGg93dbUKtqQQB9993FucSavN1kjihWq1y8fmLbG5uImSNqNqmP8gYDsbs7m7T2d3B2ZTMOoajjL39fcajAc55b7JU0+b2UkmUlgci48KBMWuPmy0qOTSUnPQRduMY2x/46LHw52YZTknUbh9hLDKRnlRiSbAZYCNfMquHgtqGoLJrGRxRJC1/2x7PCbZf76hs+1vb3hnon5TU1v320zpUtw1O++h4dE8MDk+8saJai2le0tQ2LVYJsqpAD3w0Hu1Koj056UqWjgLCfdBDr6k45cl7WmYssMFMn4u8jeekxBpyS9xMKfghUEytpJKp5uttNi5/Ly8uSQS6LzFVT7xZ3TI8m3q3SzR1b4xXDHsPWYI+NC8qxktQv+WItn1CcLzoJYvBCTuZ+UOmfsYQU3Wo1JNq9vYulashKvYyQzrnt19MgFpM4SQy7+zI6jav7rMTHVimt/mSc6fJpL/GxHkhDniti0VLPfm1xaFIOQoCQqUJdIVKVCXSAVJrXF7CK6zDxEOESyDpoaKA1ZU6na0NknRMmsVoLZFZxrC/T2BSdtdusbW2jnOCb37kG1DNGidOnuPs+dcRKsFD3/gQ49GQ5eVlzGjMiZVVQgEygExYzh0/weblyyw0qqweXUEGgmqzTr/f5/q1KwiXMUgcne6IcTKgN+6TjBN297pcvrJBGFUItXdaKKmQUqG078pmEahA5cUvL0++s5OyHgYiinw3tUqErFd9M6EgL57I7YhiFINzyMTgAi8XRDsKlXhpweaVWkHfk01j3dBYMwgL8Rv72Kqlf1Kwf95HbcOHR+gRjJYlKob+qvIaqfY8ODxhaF6zBM2Y+5c3sNrLIWHP0bqWIRyo2BHse0+vGnnikx3N3JUMU9FeO1ZTHdnm/+PABb6956Qt6UslS/PZtA81vrdZD3x3tplkV15tJ1NPmsG+RKQQ7ir0niZZMtgQXF5hF+4pok1FVoP9h2Pi5YzdB/zms5ojbTrCfUfzsvRJUecr/4rSaRNB44bDPTaHHuH7V2gIuoK0YRkdsUR7uW4vwVbtxG1h6wYZy2nv5VxH9n2YmbCuTPNOdAVhCzf9zHJ6x+Dfe+VDW+JwOBQp6zBEhQE6yHsQSxDOIvL+F8akjJOM0TjFmJjdTp9QhCyvtNlY36K3u8t8o87GzqafHTqQRPUK4ySlEgpuXr+MdSO2trb55O99koX5JgtzDc6dPcuD99+HtT2kGjG/MMepY0ucOLbKAw/fRQXNNz5wL3PNBjeu72BQfPPbHuHhh+5laWmBUb8HytLtDOjv9fniU8/yV48/jgy8bmyyGIFFS9+3UQqRt6AQBEFEGIZEUXSgjzIwaVAEvDruiyjMq/N8D+IDPSGyDJemvqvaYASZRXclUjniJUN1wxF1BFnDUdnyP06rIa0JZOwwkcDerIGD6pbj1H9MyFqWudaQ/TOC7n3GR48C0nmf9Dt6tMPZ+9ZwCt5315Ocru3SvO4/4+bbDNsPakZLgmAASAj3IdwXLDwFS48LbFEin1vhXFEpKcXEP21DlVcOVhHVyrTXMkwbFMFE2nilsHpm2jI1TYQVUaRTBSn7KDWZs6Qt72ipbkyTgkWkXGjSJnLozZDKukaPfALWBhB1vLbfO2eornnSq67J/K7CJxMHxwTNa/7ORRo4/btjVh8d0bokaFyVXi/Oy8Ll2K+TNR2qqyfl3G7mF1002i+q/BA+Qi8KTCbLzCT3RN4lrtSUXzscipSNNblPF3A2T355PdZai7EpyhmkTenvxzz91DNs76yz3+tTb1SotWpcvXEDayQbGxtkWcpg0Ge/36fbGSDQnGgf4S1vvIfFuQUunD1LMhqzv79PFFZ419vfwUJzHmszqlETRZV6pc0//xc/yuLJVSyKn/rJH+Vd73yE1dOnePB134CqViAIiYe+N8W1q1fZ3drAJGPGox5ZNqZSCQi0QClHNQgItSQMAsIgIAojjh49ypEjR2g2m0RR9KLIeLbK71CYJaG8B4XLMq8zGzO1izmL7PRoP+0wOxG6L71u2YDaTV+0Ud8wyAzCviXsJkR7ft3K0oidNxjGi5rFM3uM4tAnp0LL1tszkjmfdDMVCKRlsTLgfT/2Kb5l7mkA3vdjn2Lz7RkLq12yh/rYyHc7UyM/Fs2rltpmikocemiRqcVUNTbMo+RIYQOJDRQulJiKJjnVJju5jJhred+ytZNZrYFpb+XDjK+ckvFkotAZciqq+mw4LXGWGVQ3BP3zBjnyLomwI5Gx8AUn+XYRMD6TgIX55y2VXa9Tm8gx/7Skd84S7QpGxyyjYw41zhsZjUAljs7dkLQc8se3+Fcf+jesft8Vxo8MSOZ8Ui/albnv2bsvVOyTfIX5+EDj/dsgLJNEou8iJyavw9QaWGrKrx0O577wnjavkYm8GZG0voWm82eHtSlSCuJxl5trG8Tjh7wdCbh16zpZYrCZI1CSwWBMZhwSxzgec+3KdU6fP80jr3uYWtQgqlQRQZUL58/z+ccf58yJVaSokpoxx04eodYIueueu5lvN3js859la2OTD/7MLzHs93AqQ6B44P4zGGcRLiDUGmstSTomHMcoKQlzf2zRGtTlrRCF8j8AqRxKR+hAYzKXSxxy0msZePVmHcmmSUXAS0Iz2xeISRLQDYY0biRsvy6ckEv9pvM/PuOwShD0LcLkftxRRv1aRHbG8uaHLvKZyllORzGRzrh1rsbcEwGD41Mb1Wg1o10Z8kNHP81D4Tb/7Na38aXdI1T+twUu7KcgaixK2H5wxo4VgLAOFVtU4nBKeDIWeC+LFAjj8mrJfAIBCVmgEIFEmDpSK3+nUiQ8i/E47F2IZVJS7G1EwEylm807rAGoTBCfHZONNMmClyqc9IRdzDEZ7IuJL7y24RgvhaR1X4p+/A+6bL++Rdjzf8vMd3iLdiRp05HMQf2awFRh9wHB4sNb/N2zj/LBL72HH/zpf0zcBqEcWcvfyQXdnHUDXzXotL+IFK04i89llQPlE4SQR/NS4PJycJHb/EzoHSd+cA83rCUOj0ORcjWqToIVa23edzghywyZSXAGDGCFQEnLtVvr/OUXvsDpUyfZuHWLuYUm3VGXTq+HsRaJJNAh991zkkfe+jZWz59GJzGtuXne+5630l5epT+M2e8NsMby7DPPcN/99zEY9Hjw4ftZOX4aGUouX3qBn/rxD/It7/8entoXfODNb+TcSsann7zJO9/8bj72iY/ywq3LDFPLeDxmcb4O+11imxFUGoyTLC+TTnHOzy4iVDEfX+AJRQiarSb1ZgNrDMPhkI2NjVenO1wOV8+r2/LubmKc4OIEkSZ+Hrvi9l3kM61c3mLp8eP0TgrqtyzxgkR3LFHHzsgDgp0Ha+y+KeX0qVvERnGuts03v+l53lK9xPWszT/pv59922DuWUn3XoMeSk4+uMk7Fp+nKcd8uPMGLv4v97Px7ZZ71obcfO8co2XH4hOw/5YRx34zZOGZEXKUIv4/9t40xrL0vO/7vctZ71a39u6e7p6enoUzQ1IaUuIuUrAcSbYEA5YlKwucOEAgxYAFJHEQI4CBfIw/KIg/WHC8IDHsILFsB1ak0IxlSrJkbSQl7jRn7em1urqWW3c99yzvkg/vubd6tAARi+Z86QdoVHdV9a17Tt37nOf8n/9SVJidXkjHaBwmV+jS4rREVm3kU+1ACrwWWClDo5SCZiNF9BOE66PmNfLuEb4ovi3ndmUCtJYgOxAtmLxOhm6nXhN7fKGR3Ybo7ZSm59eTs+l69Dw0NVUF6CY7tcyvaepNy+hlyejlPtlxO5FayA8kJguqvWBAD4urgVfeXK84+eY2f/Prfz4Er77ckD6MyI4Fvdswer/HXilx8wg9U+tjEEZAy7kOKSftgTpQj6Vte+2xLV9dWoGsWpk3YRH5uM3ok3p36mKGRFm6Nl63pmnN7i2ONv8N8M4Hj2IZ4ZzhC1/8GuPTOcKVeG8wpkQ6Q5rmlMbRHWzx0U99iJ//5/8Xj26P6CYZrif5npdf4q/9Nz9Ft7/JRz/yEb7yla/wwe/6AAeH99neHTJ+dJ/Z1iUGnQ6/9tlf54c/9l5+8V/+En/r7/xd/sZ//V/yMx9/gctXNpHdOR/56A/w1S/+OrfuHhPFCu0lrnVQqxuLjkPqSHiP+pBgEq3iqcA7h5IKFMg2AUMpxXK5ZDwef9tioHyeBM/iVpbs1z/fslaGtNFIRBqMZes3D0hf3EM4j/A60Ly8x+QS2XjKDcXZx2qu/XNF/nZCmsd8If8gn34lo/gv/hXPJY/4ay9/lp/92o8x/q6G5DCi2jE8ONngtY09rscn/P3f/STqE4Ir/0qy8bcf4v67iNs/mrG4IogSw+FHE7a/lNO/tUQkbRaf8wjrAqsgku2CKUzKXsv1BL2anp0OTVq0HcKplGRzgDDm2xYDtfY0XuHILWVsNSGvJk+1FKhSIR/otUjDK0/dc8Rnimgh1uyNctvzZ//z3+UX/8kn2PyK5PSjDR9/8U2+enSJxdsDskeSxdOG/msaaYIUe3bTBpZHLRkO59Rf3V7DDMUlHZr25fB+6tyTcD9bC07qjUDrs6lvl7tBdLLOHXRhgSnWx+N5vOu6VqsjLOchqu5J+si7WRfClLtpQh7FZGlKkmYkSViCRXHcehGLdc5dFEWoNpB0sVgwm8249/bbLGdztNbM5wuM8dy9+za/+q8/x3uvXuEv/MiHmfcuMY1u8sz+Nn/lr/513vjyqxhj2Nragtiwv7eBrBuee/Ymp2eHZFlKVTrGPuFT73+av/ez/z0//sn3Irczbn3tFpezIc1iwXzp2eh2uHn9GlPvmBYljQXV+iaL9rkqpdZWoytbzjiK1wu+KIrWHhgrZ7jV5x+3+PxWynZiXB61H2N81poKZdkaV10Fn4oouLl5rYhmDfGkpv/mgmhmcZEgmllk4xncKtn+tZjxTc3tH9vC5hqnJMUlz6f/+p/i79z9fgqXUG1ZUJ5q1yAayYefvs2b0x329RhRS0QjOPqA5M7PPc/dH8wxXcfmNw1b/UWbiuGpBzGT5zrIyqBnFcK4ttnKdtsfGq+LZaDItTQ5m4TXTqDJhY9iRZGzNgh40gTZ733r57b1GV4p21ZLrsctLGXrgxyWfgKTt4q8NkcvGoffQdPzlFue5SVH5wF85h98gnLXMX0G8rdivviZl5iddth/8Yhq05MeaJrWnbTYD2rCaBZod/Zfb2O6QcrtIsgfBpe55EwgK0HxlKPe8K15feA4q6VoOdah8a4ocao+93heC0hW0VTiPDfQRZ6m44P6TxCW23+Mb/ST+vdfF2rKtXU0LV8XD0KuqGSBvyz8OR5qjKFpGoqioG5KjHVUtWM0W3J6NmdRVAgf8dLzz3L9xlUu7afcP7EsUPzc//Y/8cZ4zkvve47/8x//71TFBKkVuxub7PVydD3j7tuv89LNl3njzTe5fe82h6XntGr48688y43tAb/9O6/y5370T+PiLkdHB8iy5PKlbV5+/3u4ur2FE+BbEYgzFoVAiVXOnwzHpXVIJWkXeY834ZX5/eNfu+jELBobfCLWCSAyTMRCnDMSVmY+TQNNg5gXqCqY/cjKkJxVJCc10Syo9U5fTpk9LVjuhS2/MJ4f+Fu/SXosOHlfxMk/vcrDegAK8uESNagRFn7v/lV+8srv8Y9OPk5+L0yH0Vzw6COeas+w+znBvT/riZUlPRKo2jO/ohm9V1BcCdJ0r2Sb0tzCFTIYIHkl1pPxqllDwMJxj2GljWmDW1tP6OYPuM39SWr1ym8n5FV4aJAdh7/pQq8AACAASURBVObkVNuolMdmoXmrUoTFWkVrPOSptw1ee/KD4ANSXApuffFEsPOlBmGh//WYh4fD1j0uTLYrrrPr2HWK9fQ5S7lvKPcs82uOyYdK0pGgf9sFD+XNGj0PTArTCWZKphMgF9Ntj6H9YxO/Nqv3f8DfwulAw3OtdbaqHzsfLYvkSb07dfFFH0EA4JzD2UCFC/z0d15pV85pcRwHaKAxLBuDrRsmxSk7wwFPXU3pD3rc3N/ns5/9Mu97z9N8nJyf+amf4T98rse99AblDcnho2OevvIUs5M7RM2cYjKlPjvlt37lX3D9Pe+lagxMjvn+7/8or7zvJcplyUc/9nEqIfjbP/cP6caCqzefhiRBe83e/h5ns1kw0v9DCyS3nvYXiwW9bo9lUVEUBf1+h4ODA6IoIs/zdzAwVp7KFynRelwI3xq9G/eHY5vWTzPALyJNAluhsYiyQS1K1HiK39+hvJHR9AXl5YbLv6IYvUdy+nLGZ//b78N9EBCw3Bb8/uga3StTZqMOWEEyk1SzhL/5hR/me565g6pbr4ZPjvnpZ7/AUd1j+cGYxim++L++H1IYP6PXGOX8kiIZx2Hi/QPG9L5d8nkpiGcNdT9CLyx6XlMPE/LbY3wSYbrxH2ZbXBTGWO1D9Jq4EDBa3y4AxTkTQZjW+1idP38bQ3ImkbUMzTEDhgFflnWYZE/eHwX+9yXP1vaMk2KDpi9ohmFJrmcKdapxL8xpzlKEFXTe1my8aRl8/j6+m3H2SszxKwJ5Y07/t7o4HS4IxaVwoYjPgkx7xSQBwkWnhS/CQbR3B0nAm9UyNHa/klu3Vp/CindErT2p73xdLKOvle6FZbjD+SA5zqQE697R4B5Xwi2bEoQgznKm8zkbvS6+cSwmJyyGW0hZ8JGPfR+/8Vu/w3PvucKPdFO+8GjOjzzn+Bf/72/wm8mSvUGXk4e3yUVDN4P7t1/D6y5v3bvDe198kcOzKVl/l6lIqRScnY65det1XnjPVd56/Q7bW9ucnB1zLM6Io5goSimWJXVjiOKYyjQ4a+lkeVDtGY8SmulkytnZiDRNOTxeEOsI91gElPd+7aWsL5ohF8xFwPvAUvAetMLnaZAje8c61FSK8G9jgl+xEPg8QY7n+K0hojGkY0u5GUbEw4/Cpd+ynD2nqDdi+ncch590XP0M3OpdxQwNySMdTIxST3o3xivPV+49T/1iQzTSXOkuKF2ERfLWdJvXb++jnvP03woKtmQEjFpv4EiiC4OsLS7RUAfWhcmj4PNrPE5J4rOa6GiG66Rk92f4OKhWpHGBj+1d4GzXTYix+lbrMfqbsm0KtWG9+AsRSi2SIcPXVmq6VcPTpSAeE6CLfYfvWKgk+/9WMnlWMHmlBuHpfzlh85uO+YNteLmh2WmQs3Bu9SKki/hHOWJYM/hcyuRFi/2eguI/6zCZ5Oi7gvRU4CZd9MJTbQrKDU96IpAN1P1zabU0YdI9Tynx4fzWApMEzw3hwSVtsGolgnnVCuYQ4fv/2NTuJ/XvvS7clJXSQZIsJUrlGBuoYc46mqZZG70/bt5TVEtyFbMow+3n+9/3MmcnJ5xM5hSvvca8bPjL/9Ff5Nn3XKKX9Ln81DX2di9z68Ftbh8tufXW27xVTbi+u4WtFyS5oqNi7h8dMXYdFj7m5jMv8fkvfo33NpYPf/gjbAwW9Ibb/M5vf46b70l588238CJhvnQIaxlubFAUD3HOcXJ8TJLFpGmK9z5ALrUhyzLG4wlpmlJVFY01oDRCSsqyXJ+TFazxbVn4yfb2PhF4lQRYojRI56CqQnNyHlxLjaNBFCU+iZHLYAI/+t5tsmNDPKrZKh26iOn+5EOmNxN20opP7L7FJ7qv84tnr/Crjz5A/22PfC1YV0ob5NYu8mRHAtl4hIlonlly78uX+fRLMf/DC7/Ee7KHfKl3jV/+4vuYPC/pvxXUZ2oZbsvLrYjuwoD1RA9G+E6Gy2OE9+iFRVYW09FEpwtcJ0UWVcCPXYBrVmiDtw4hQurIKtLpW6l32FoCuMDFDl9s73YsazUytGZFcWvl2UIExeUg/tCFwuSSSx9+yL1qn94tGH5GkR/WnL7sefgp0FNPehCFiKc6wCDCQDyW4SJQJBSXPTufl1QbPZab0B0HhaRNQtMcfbdDGEF+ICkuufWy0uWBYqEWcq1ChHNqn81CmrVatk24DjzrajOIX+RSrGOghGXNQHlS3/m6mCGRbKPePcRxjMcFd68/gqf7eOadraBJBVW1IM0zOlGM390m0TF5nlHNj/i5v/d3+U//0l9i56kbOKX50mvf5O6DE07HM3a2t3l4ZDk8OuZyL2F3awfpNcvKEouYiYVPfvyDiDin2+sTRRFlDdYbdi/tM52kvPy+PqPRiNPTU4TI6PmYp9MuxXLBZDLh5OSEpraUVEghsa6hrgXOGYwJar0sCVl+TdMgKkOu4/D3dgl4Ya5yu/zCeVwWjOZFy6YQ1r2TUrqKfdI6hKJqBcsS382xsaDYjUgjSdOVxHNP8w/2sf/xhA/v3CYSlv/lwffzzcM90nGAMPJHnuzIUw0F9bbFC4+q9NrE/ae++zfpqpLn4kM6suJUdjFO0dldUExTxi8rorEiOQ33wpUVmDQnKhzJWUpyuEDUBrUIWLM0DlVasAF6wXt8moQptTKIxiDyFJoAfgZTpm/9/AYFXtuVHdi8vfVfCS9aNSOw/ryNA8PBS088DV9Ux5A/Cib3AJP/+zLueyrcDxQ8nGZsbS742N6/41fvPAeHfWwazOtXwhS1DH/kWND0IJpDPLP079RUw4ijV3SQUxfBKP+pX/FMryrqDcgfSkwOTceTjKK1xagugldJcSU0Yi8CFU5VYu3hISxU2629q2Ed5uqDiBVpnmDK71ZdqClrHYJToyjCe09jLKZdcP1BybFomRhSKdI8I01Tnnv2Bnmakm70uLG9S20aTGN4/fW3QMNXX/133Dk4Ie/kRKrhG1/5Os9e3UNay1e/8kWuDPskvS36L3wSnXVZfPnLvPHqN/jJH/8wz7383SBgMp5graWuPGmSsbMzwDVLbL2k30148/VDBIrx+IzT01OsN5jGoJVHCMfxZMwzN27w6MF9FovFGjfOsow4jinLEuFhXpdUdYVuBSlqlZpxgXKRCoq3WILzqMYFdzXzzjBRZLv4a0NFfTfH5QnFe3doMkndFyx3PbIJlK7h6w6noHhtg396+CFEbhDSk34jY341+CrvftlS7ATbzq3rZ3STinuLy2y8BvrHjvmZ4TdQQvBaYym9YmS7bMYLnt4c8UazQ11LTMcxeD00q3TsyI4qxKrpqsD11sdTFi/ukt+eIKet0573uE6KTxSyaJtwUYYEa92acKD+aMna/8/yknbibW/929O5oo/hW7vTli63+lr4vYQlmemEZdr8aoBqhq95yk1B57UER0K3gdqkfObGJumRRC95R+q1bKDpQRN71LNzvIf5gw7zawK/KWEu0FOPKkRQFsaeB5+USBMy/FZTcjIOOHBIuxaUO+C0w6We+DRYfLokQBir8AO9EMg6PB+n/fk5aHHmJ+yLd68u1JQ3Br2AJbcKPu9doHy2TXjloLbClteOas6jhcM2JSKLefv1O7x96x6L2Zxut8NwuMmNF15i7/J1OnHCdHLKG/fvYKqarW4XU57xn/zEj/AP/sm/5NZbR/zG60f0sg737r7Jn/nAB3nl+aeYP3qN4+MzZrMF+zffB97Q7eYU1QCvzrA6Iu9u8dwLL3H3ztsIJVGRxhYVWaQoliHMdZDF3L39JsiYZ67f4OGDB1hnUErR6w1omgpiRWo0/TihcYazxYwszYij+EK/nHoYt/Jf3/LB2y9IAhOjDVUNCdWt2b4xCOcCpFTnkMHwjYaNtwTRzND0NMtNxeR5sJcqotjQTBOS+1FY3vUNolTc/QnH0/9Hw8YbhuLrQ4qO5MatJQffl/OXr32Jz1cpnytucqfc4i9ufh7nJdeSESdpl7fkdlDHdSyT5yXdu6yZFrrFlJUJzdb1MvLXT0BKFs9vkd+eBrxcS+qNhKSykApEE4dwVWPxozNEt/tOQ/w/Ya1u6VdT8FqAsWr0IhjM0yoafWvshBfE41bd2QjqjSC91gvP/CnJcs+hi4DVljuhMUZnwbJz9oxl88uSeOExiWBxRVBdbujvzJnfGrD5NcH8WmicvW/GnH2qxFVBNr9KZ0lPJNmxRy8do5eCkZJetEb3lQgTcSHQrlXpieD3LE1ISwEBdWBXyKad9svWj7kNdFU1axXgk/rO14UxZSECNmecJY5X0fShUaxSn40xdDodhsMhzjmMtTivOJtW1LZgPDljuL3FCy+/xPbWFt1ej26nSz9PUImiJ4d84tIlvDfgDFf2X+D6dsInv/d9fP53Xud//kc/zxSIRMSH/9QnGA5TisqQxxo1GAQ8WyfoOGFRHfPw/h1OHz4ML2CZsnP5Ks88/xKvvfoqB/fuMJ2OSdMATRR1xVanj1Iphw8O6PZ6KCWYzWZMJhOyLMNJQZIklNM524NNBnkHqRSz5gLBnsDKx0AgEMYF/i4aKUAYh6ibIKSoa+TGALs7DA2tjVuKz2qkiYhHJeVuxul7U8qtQOOyXUuW1ySRoRCQX5rgvaDvJC/vHPI9gzs8+q4+/+yrH+Dm36/IAJQg/dgJ70vvc2q7DPWCJG9Y+JhENmyogrMqpzrokB3J1l8Cin2YPisYvJbQv6uIxxU2j0GAXBr8sIuLJPntKWYjxWtJNC6JRyW2EwVMOdGoyZJmb4Dq50ER+AcDWP8Etcqq87JV960Xf+0iTK9u6YPHcTUMlDO8p9pdqTFCw15clkhLgJlyS7Npyb+ZEj2Q1BuenS85OvcL8J7pzS7VIMAHm69aTK5p7g7pjyCZWcpCASHJuvv7GbObFmvDxaN7T6ALz+kHHNGZxPQdPrUkZzG922BS1rascB77lB6Hn1cP/Opp46OQR+ilX2f6eQl6GbL/ntS7Vxdqykb40ByEIIkiTG1QKGIdM/cN1odmFcQhc6qqIk1TjAmTZhQL0JI8T4mV5NL2JoNBH2MM48mCOJlzeX+PpbTsXrpMnqYMen1Gj96mFh22d7b47g/FfPLNe3zti1/ip/7KT/PK932MmobaOpbFgkZG6MmE+bzgzt27HB4esjHc4sYLL/Lg7gGj0SmRq7n31m3QEZevXYUDxWw8IlYRg9YBz6FJRAzSc3o6QmtNVS1pGtlKqwGlmdkl0iqsa2jqi1G2hAfhAmfWJhJVuSCwaMNHsTYY9sQR7myMLJaITo5vGkQUoeJgk2m6MS4SLHeg6YdFUTRRLKOUzv4UITwvbx+yE895Jjvmc5MbAHy0+ybVezW//KkPsfvFhtFPz/kfX/xFLIKFi3lYbwDwBvvcLrf57cMbHD8aIIY13WdnHD/YQI90sAy9LfHKM72u6SmIRzVeScwgWfOShQkUwPjRDB8pZBm41qJdCCMFatmAccjGBuz8Wz237Q5WtjaVq0goJFjt165vJoZ66EmOJXouqIeO+EShCxEMhCqPFwLTCUnW+Z0IvYhougFV6t2Gs+cVpy/1UA3UvRBwmj+Q2ETx9N/4bQ7/q4+x/+sj7v65Tep+oK0lIxmSqschqVw4mH20RCrL1i93SKaOyQ2FTRWLqw6/WxHdyujd8cyvibXxPoQLkItbfwwVvKK9F21g+2pKDhO6i1uvjCfoxbtWF2rKQgiSNAEPdV0TpwnNsmFZBuaBs5bG1DjnSJIkYLt1jdaabrdLt7PBYDBgMBhw8+azOAlxd0iMYHTvPmVZUleGctngBGS9LijJ5Zsv4BYzbj06YzFr+Ikf/iGeSYZcNimnrz/Ed2JErHEypzENJ9MRR6enTGZztvb2GZ+cUi8K+v0evV6Pbi/j1v37VNMZ8/mUzf6AZ5++zmvffJVYRUgpmIznDPo9JvMZaZoGLLmFaay19Pt9qqrE1BrjCorlBadkaHHCVnBRO0ymiBYGWRkwFm8sNMvASMizYOdZlogkwfc7mEFCNYwoNxSTm4AIkxwCovsRplKUjaapwsvgajoiEpYf3/49Dpohvzp5kfvFBs//4Ft8Y/AMw8jwC6cfZCMq6KpwfIWLAx3ubJfxNGe4PWN81mG+TIh6Nb7b0OmUcG8zLLHmjnJDMb7ZYevr1VpenZxV1MOEeFLj8hg5r0DJ4K/cGOxWD1nUAY9uDGK2+LacX5f5kCLtxdrnGGjPefCG8K0wIyzSwiRdDz3L/dA8h686FpEkPQ6inOb9C+xBDqcSc0lgegHHdZlFGImeSpaXHDZzzH72Izz3D0fc/vFNqm1LNJHI+bnrXLMRWCZyLom+mRFPodiDxRVF3Q9Kvxu/UDG5mTJ5zjN7Ojz3zn0oLvsWmhDEkzAprxKz8QGjDh7LoVkHZgYo+2RSfjfrQk05kgpjLUoq0ixmOjVMiiVNMcc3wXUtamllKwe1kNhhEEjqxhD3unzgIx/j+OEhTbVEcMz169d58cUX6QyGHJ2e0tGSt2+/jZaKNEmYTR3OeyLZJU4U9uSYH/zEx/GJoqyXTJuCSVPSOMF4Ng2SaRkMlKSX5L0hcRJTmznWGr7whc9zdnRMlueknZyimKCkwHrD/qVrPHz4kKeuXWI8npIqTeXAak1jDHVds725Ey5CxiKkJRcRjbJ/hBDlT1ZeBQqaVwKbSeKJQU8r5Lxq1W0S4g7COXzZXgSsC5CGEIjaUXclJ9/rSB6poNoSmuZqRfOeho3ukvGoi4wtv/fgGom0bMYL3mIX4ySJNAzjJa+Nd3nlY6/T0TULE3NWZ5xVOdZJjmcdpPRI4UmzGiE8WbcijRtmJsU7SfnFTTaPLU0uaXJBVPhWYeaZX9Z0HzTMns5JzgwuUkjn8YkOrAvraPYHQXRibDjmSAeOsv3Wz69Xrel7dT5JQmjUK2bFmhrmBcK0ir4iTJb5Q480gtNXDI+ebej/TgamDZA97FIPoNwLDdV1LGqmkAuF137NIxYm4Ayv/tU+0cjTfVvhBRRPBd8VHzuSI9VixUG9V26HRmzSMPGazPPWT8Qkl+YMf6HD8QeDNLvcEUSz0KDrgafphuOySTgu3+YExpPwmMiAJ0sDK+fHJ/Xu1AUpcUF+LCPJ6HjGfLFEVhXC1Agh6Ha7eB+mY2PMmpHhnCTq9nj65rPMZjO+9qUv89J7X6bf62KahjTv0Ov1qKuSWHru3LvPYDigqV9nf2+ffr+Dd56yKOgkCf7KBmMnsRqyToeobMia8KaOq+DDEccaqSKauqE32MAYQ5KknJwcs7u9w/DDH+HN11/n9skRW3vbHLx9l+eff5aTo2Nu3LjBwYN7wbjeezyeOElI0pS6rul0Ojx8+BAhJY2p0V4BF39Vh1RkiVOQHTfoSYWszXnyxrAfjJ+qGpomWPK1ghLTTxk/n5PMHMOvSM5edviugUaSpA3DXkFRxQjlEPcylgPLv6mf49ruiCudMcYpRlXORrLkWu+MRBm0cFzpnDBqOsTSMm1SZnGMFJBFDZGyFE3EXndOZTWduOFw1Kfatjz6sKD/JvTvWIo9Tf92xeg9CZ0jx/hmTO9BeyFZudmlEaQRsrY0/Zjszjg05Lo5T7W+QMkqwBY2aafY1IcptRVdqOqcqyvagIPwHwOF7ey7LLLb0PtSRjJSTG+2oadV8LPwkSc5DRafdeRJn5lRVxr7KGs9i0NMV3IK9SzQHZsurUJPtmb5OsixOyE1u9wNSsHlnm/tOwPsMHhd4d/ocfRDJcPfTDh72RGPJWbTBwP9dlJuen691FOL83gqXQT/jHXU1Ds9i57Ud7gu1JSV0jgrODwYMxudkmhJlCToOCfvdpBSUhRFa30pqeuaKIqI0i4P795jORmT5V0WszM2tja5fOVDNHVJuShRShNFEZ005+aNp5lMzrh16y0ODh6wu7vPcDjk0u4WWaeD1noNJ8gko15WCBUzmY7aC4PHOY9pDJPJFOc8ZVnS7fdYLgvu3rvPbHJGYyqEaTi994Abzz7DaDxle28b4w0iiulkGqkVsY6o65ppsWRvb484Ttnd38N7z2g0olgu6bWy8ouU0wJpPZ3DCn08g0jjsghivcZio1mNaFoDqKqGOMJnCfr1e2yPNnG9lHicUG4l2FcqTKOpy4iZTom1Icka7NMWJgnidsbtw8vc3tliMCh4afsRe8mUrq44rbtI4eipkoflgEQZHp312MyXABgnqYxmNO3gvWBRxWx1CppS03mgiCetTaXzdO/XnD2fkI49i10ZcHMlqAay9fdNUJUjmhmKp3JMIphfCs5p2ciiFzZwtS/AU/a6teiUIXzUL/16safqIJle5Qt6FaZUXQRps3mpQN/LYaqYPWdwt3XI4dt2xFOJLkLDX1HoOncV3Bugk8AEtFlYrjUdH6TZrEzqQ8qLqIOh0CpdOyRU0/KbPXoWRB+qDDixSYMPRvbNlPnVcJ6DzDtg3bJqU7OL4CDnITjwNdB5IInmnnjm1ji7Lt0TnvK7WBdrylqCF+zudNne7uNa+qnzpqXIeaIooigKvICyLBkMBhwcHOBNhVIb5J0OV689jfaWV7/yZTZ3dukM+pjJmKtXrwalGhFCbLCxscHp6SkAo9GI0WjE5ubm2p3OOcd0UXJ8fIJSMnCJk4SqrIjjiLKs6PW6FMWCNE15dP+A2WKGUprZdMrp6QmDXo/RyQlnx4f0B32WRRM8O5IEZw3dXo/x6QhrLVEUYa1F63ABcc6xv78PgPg2iEe8EjhguZcidpN1g1jZRArvcXGKnjcoIZALhdnpEd06DAGrWmG6MZNnwr25+EYPt22hZyimKduXT7FOEmkLAxAbJc0oQwLjcYffHj/DxsaCblKT6QbjJQfJgLdG20jp2MhKelHJrEnJdIN1kkF3ybRIyZKau4ebiHmQE8dTT35sqAaK/KgmP3ZUg5a768AkQT1Y9RXZqUEYj4tla+Mp8TrcBMwvKQJH+UKn9lwg4tuGV5xjq6bTNuNWxR3wWGh0+LHqtc56qtz4qqb+gQnlUQeRG2piXO5IHmlMJ0y0Nj0XcKzyDm0amqBrf4Zv34l6LokmgZesy7AYlDZMtU6Hv9ebIdtPX1+wLGK8E4hZiISSlVib53sF6Ulo4NlRSKJxUcDFbeohDSrGapOWlx28PYRXF1JLPqmL1YWacl1WqEgjkCgIznBCotEI1UIVRtDtDTg5OUGrmMV8SawjVC6ZTsd88lOf4ve+8PvMLk/o9Te49/ABw+GQ4eYmOMfmcJc00+AD5S6OYpbLgtPTU5I44+HBAZ08J0lSklSB77C/t0maBs8KYz3eOYqioCgKjo+P6Xd7qDxGCMub3/g6xgsW8zGL+Rmj0QlXr14lkp7FfIHQCVEcsbe1zdnZGWmSYgY1TWOYL0rKsmRnZw9jDGmeEalwK7qKyrpIqaq1upQEY/12K+4jgjmPD1ludT8lO5KoSKLHy5DtJyWcjjn+D7bY/90586sZVV/SOZCUmwn1hueO3aa7WdBJajyQRoZlZCmXMfYsxseOs8M+k9wQJ4Y0bnBe8ML2EZtxgRaWymmMV4yWOdMyYXbSIerWqMwjhKf/qgIPydQRTWuSI8P8mR5OC+J5OD4bCZY7knTkMKlAGoVqPNHMopeOYlchDJhcrCEFuUqf/lZr5e/ggnjEP/ZOCH7CrC2rmzyo+Vb8Y5sEWKAaeiYvW9SbfehZ1MMEs1ejRhHNwIWYqDzgtXoukKVYy7ltGpqzbA2B9KL1PV55VzSBurhSEto0QBh1x6EXgmwmKGwH6cKCbpU+IoygGQR3OJd67FShSsFyJ6gRo+kqlYQ1ZVGac+Mi2TZjr59Myu9WXQxTVuENt/J4CBbKqwh4hUSgIsGyLOn3+2uTnhVj4ZUPfohPf/r/YW97m+1hH+OD73K/36eT58RxzHwxRkV9kiQhSRJ6vR5a79Hv9ynLgjiOsdYyHG7S6eQkSYKUkiTJcc5CbajqmqIoGI1GZFnG2fiYupnjrGBjY4ODh3fZ3drC1w3j6YxiOmMpLFmW8dTuLsPNIW/cuk2v16MsSyKdUS5nRFGE1prRaMT29jZaKpRUKCGovw22F++wsGz/vcpeCwnEAivD7Wa9oUkbh4s1qhBgLePve5qn/tltzJUtys3A4rCRoOkF20iZWIpFQqQsnaQmjxp2O3PynZq3elssq5gkMhgnuTKYsJ0u2IwXRMKyFS2ovGZiMhZNHBryWY7KLM045aTW4ATVBnQeeha7CmESkjOIJwYvwHQUiz1FNYTBLUfdC6bvLgp+zDaWeC3ITh3FToA21mnOFz25qwdoibvvCByVLQsjDt+3alw2CZOqXoSps9lt0KcR8ViQjDRN39P9RkK11WKzrqU1VueLQ1VCMg4yaOE8piPO8/FEqxbMws8VRuDyQFHTy9DgZS1o+p76qdD8XZu0LYswbdcbDrUUJFOJ6XiqHRdw5BbSkM1KIBIucL51jTt3l/N/bL7fk/rO1MVsR7zEe4FS57ZSQrhgB4hos/AEUSSp64YkSXDOkeddfuhHfpTP/NIvopUkThPu3LnD9s4+3TwniRR1WVIUczpZJ0wSOmI43CRNUySOzcGAxjTgPU5AmqZrTnRd11hrEEJQlgVKgtQJzsH4bESvk1PMGmbTUw4P7jOZjDk7OaUsS6QSQMxTT11lupgzmUww1nDt8hXmiwVJr8+8mFNVCjOvqZ1DqZj5fE6e5xhrqGyY6r8dOX3CcZ4CvRKTrMzK2mbtIoEqPTZVCOtwvYz7f+EK137+LmiFyzSDtxuKXU3TCW9GVQrMQiM7Bu8FibI82z9mJ57jvODZzjFze66Y24oWbOoFuayY2JzCxUg8J1UXLRyRsuAEbhwjOgZfaPRU0TnwpBNH9qhCFg3o0P2m12OSmSeZOKQRzK9I9AJcD/wCVCKIZ6619lREc4/JA8Qg69YH+AKn9/EE5/XHdru1kkHjruVBXAAAIABJREFUQ4NSZWvl6UODLttGFx1F6GWAJ6odQzRRgd1gaIUZ4YZG2dAwmzgs81ZSaxBrj431qRbhouCjwAoRpnWIU7SRVUHVJ01CPQBX+DW1zSuIJuHiVW8E6EQvwoWu6YXHW75QEd1NsHnwfBYu4NR+7bvc3iG4J/DFu1XfBi8o37q/yWBIBGvbW4E49xj2rKXX3/+nf4B/88ufJYoCoCal5Nq1ayA9jSnBR1hX4ls/RedroqiL9w7vHTrSRFqTiRQQqEivU0GaJmDA08mCxaLk6PSEZbFkPJ0Rtw1hvpjS7+d41+X69eucfuWU/mBApDWLYsZ8PufOvbv0O12Sbo+mMTwanZKmKXmeMZ1Pmc5nRCIijmOapibL0nPTJaWo6xr1bWAJtCeyPdPtR8G6YTzOWPACvJLc+zObXP30CJ9E7ecF0+sRXqzy2M6XUEAQ+SiDcYrGKwZqSa4qdgGFJ5cVHVkRCcvY5jRe8XaxzaOyx52zIctljJ3GoNsHXWhEr8E4mF/XpF+BahgTxRI9rYimNYO3oR5oql4whk9PPDYlUOZmkIxNm3ItUJXDpOrch0KFxuwvcHofn4zXk6o8V/mJx5qSi/3aiMlmnngsgxLOBsaCjyAeqXN3Ng/RvJ1EdWiafrX4E+e2mgCiPQa/Tv1YeVh4fOwRlQwUOe1JHmmaXnCG8zJ8XzQJd0BNrzUfaj0yoJVeG7E2xfcS1MMkWHbOggzcx45orAJFb2XfqZ9w4t7NulhTlr5NfW7l1qjgf9E2p1WDWnUVKQVbO0P+7a/9Ko0NTWtnZweAZVGQpindfpeT40O2tjeolzWlkK3xT0GWJSgl0AIirdE6QimNUgKBoDINTdOwXC6ZzKa8+eYt7t67zc7mDs7WqCQhTyKqWnD/3gllOWU6mRILxdl8incWKRVVVSJcTrlccnZ2RpIkdDs9yvmCVGsSpdjb2mIynzE5GzPc2kQIj7UGpTRxHLNYLC7MvliHesL6Dfs4dLGSA4dvBK8Uy92Ip355sk7pqK4MgOAcZrKwjU9PBdWWR9QSpxRVFDFNEhZpTGYSImHJVUVPlqSyIRWhk89cysylHNU97i82eP3tfZIHMW7ThmVUAj6xUEuigwRVCOJZOIZobkIen5LIokF0I3RhyURY8jXdEDpq43ALX+xFxFNHclqx3EvXi7nAzgC9OFflfUun1ga3t1U80uMUsNXnhBXrbDtVBhxYL8JEqhciTMRRgBNWYgyTh+Zo03M+8AqnpZ2KV97HwhHuLtoF4Ao/1guBkoKmHzINk9PwIqiHAVfGByilc0+u2RvRrF0GitbToj1f9dBi98OdS/JIE5Xt3VccmBd1v/1/ybmwRDZPMvrezboYpiwCGCXl+StaCLmeiFeTorWOLMvwafAmHgwGlGWJtTYs3oYbLMZTGEJVFYxGE6QKzA0h/FpBt1wuiXRELQxRHHyQw8/UQIhjqqoqMDPOzuh2e1y+fIXjwwM6eYcsy4iiiPHkmLpeMBmNKZdLiuWM7e0NJpMpxhuU0ZyNx3S7XZIso6oqqrJu3fD6SKXo9/sslgXee2azGYPBYM02WSkYL8y+eEdDbhcw+IAty3PTGGGhyYNpTVR4ms2UpKjAOZKHU5qtDslE4aVCVpCOwmM4JXGASRSLKmZcZXRUjZYJA11Q+iikIctwcVm4hDPT4ZvTfQ6mfeJeTbUviI91mBBTi4odfqoDC2AMeumJFo7lbkwyNoH+Fjmi0wLRT7GZRFegK4+NAqfWK6j6gqggLAnHDVU/QXiwUWgqNrngMLdKFZHn3Nx1Z24b28ofQzbtBUd5vG2bYgpNL+T1SUsrvgjSZheFJm1zhyrkeSRTEtgRq4k5LBf9OfVOh0VbvWOJzhSdOyqci61w0YgnbWBA+7xmzxqisSKeBHqd8IFZ0fRC9h4R6KlCnqpgx1lDM/CYniU91FQbYQkZqIrn5wLXZhU+qXelLiizDss+7z1KSkAiRIAp4jihrivwEi1DGKkxzTusLeu6xnvPYjRikKbsbA1ZFHOyRCIlTMYzfC/De0lRLCnLkslkwuVLl0iTAMIZY9aLxqqu1tl4jw4PKRYL+v0+e3uX2djoEMcxt2/fRkso5jM8HuMa9vb2mE2nZFlKEmkmzrOoGibzBYuy4tKlS3S7HZy1LJZL5tMJWit6/T6LRU0cx9RNTVVVZHEalpnRBVIx2np8Ig6pEBBGoDBdqtqff61lCzjdwhlaIeYVWEd0usB0I8otQbQ4N0yPp4LGSSwxs6XmVhnxMO3zvt2HDHUBQEEcmjNwZjqULqJxivmjLrKQ0LXUO4ZoUJHGluXdHkiIVipoB4t9TTxzmEzioojYe9TCEZ0tUYuG4lqHuicDNW3pSaaBQ1wOFNFMY1OJajyqApu0DIyLAm9eIPBrmOIdyy0r1nhumJhXyr721t4HBkY8ltjUt+o81gvDlcEPQuCj8Di2E/jHq+Xf2iazZUDg2snfQXZPB2l3h3Wmn2xCs11rWOqwXAzil7C4W03pulhxm8MFIp6F51dvhMeKTxSm45FVuMihfYiHWg0B0r8D3nlS39m6oHgk4LhBn9Q+oI5QSuJc4O9KodvJMWxmrA2shn6/T1EUge+bJiH9OU5QgNaaLJLMZ2Oqcs5o8hbPP3eTslxy7eq1sPzxDkW4IDRNg3eepo1wKsuSy/vbNM0AVzc0xlAUBbLN2ROujbBq3xR5mpMkMeOzMSKKMcai0hrjPE3jmM1mlLMFGxsb+MS2FxZB1N4NzKYzdBzRybsYa5FKYZrmwnFQXgW2hYc1S8BFYekjbWjAq8+HRVEQm5hcITcyoukCsPg4w0VBYotoDdajYKiuKkH8lmT6rMRUEveUwXhJ0wK2zkvmNqXxiplNqZxmViV09+Y0jcIYhTOSZhkhZbj1XsXbr6rphITqZLwSaES4RCGcR9SOeGKIZoJqU2OsOG+AMhxjPG6wsaTpiHXckbAXs5cMC7YWaxWE5tuavK/ik8ILu23a6tzqUljW4o7AxPD4nPX3RfOgyBNOrGGX7CBg4qspN5hNtSo6H36mdy0rIm7lzrQMm9TRdD3RNEzs6XGYmAPPWuAj1pOyTQJ1LyrCAhIvKDf9Gn9fqQ4p2mVpHS4yLnpswUlLOXxS70pdqGtkeYY1gY+rtELLCCkV1lpUJAMDAkGv16OqS5IkQenQSOfFYt2YK9Nw/+EBvX6XQb8f2EjW0u1lHD58yM3rz6CV4Pq1p4jj0OSbpkFKSRQF6XRZlSwWC5qmQQnJ0dEJTVmhNeR5Tj/PeOP11yhnBd45hv0B0XJOJ40RCE4OH6GFYlYXSCERxrPV73Hv4Jhrl/Y4nc6pvcVJQRQl5FnGdDbjqcv7HBwcBnzXWcp6ifUGpWKsvZgpUZOJNR/Xq9CE1vSs+BxTNV1xHhmkBHiFXljcVh85LRC1Ib87oxoMqAbhXSdsYALkh575tTAddZ6akbYUuLlNSGVDV5VMTM6ZyTlYDihMjJKO+XEHUcvgoZAZ4rzBvdklapty3Q/NwaahMeWPVtiyWweoVhsRndsz5tcGAdpoj8fGwboynnlmVyN699tLvgvqtNX5UN8O2mE7IYsmTL+rZrnCZFcm+OfTbzgOkwcptc0cspbEZ5JzT+YwWacn4f/Y7HwxB+H3GCZmf/6YgI9bJoURVPuG6FSHu46JRJrgYZGMBCYP50C0j9l02zSRGlYTksnDBUA2Yi2MQbZ4tg9TdzISuCbwrV3u0BOJLlcCkouf2yf1rdWFmnKapPg44I3WOWKdUFV1u/SDKIrJWqvOtfqtXYSlacp8Oltn2qVpineOyXjMU1euUJmGYa/DzZs30XFK1smp67qluZVoHRgXQgiss2vf5uVyyXg8Jk1SFtMZNI553TAbL+h1+sRxhBABStlQwaT/8OwUnSbEnQ6nd5doJcnSFOc8WSQYTWYorYmjiDiKaFxwvsuTlOPjE8bjMUiJw3P58mXyPGe5rP9Q+PKftGwKK8MuaUOzUlV7a9lyWk3WsgKiMCWvpmCbKiLvwfvgKJcHw/xk7Fhcad/kXc/smfBGtR1HXWuE8EzqjFQZEmmQeCqnWdqI0kaMy4yTSReRWMQ8KL98E9FMI+g6XCRBekQTFmDChgw7mwTcO5lYkNDkuk3E0KRnBqcENm6nxDo0LZMK8mNLcloSK4HwKbPLGpMFtdtF/BlECxes4J8wKZ4zEIQLGK/TbUNu70hWFLZoEaK69CL4RtQbAV6ptzzxRJI/FK1IxJ9DD541nIEMv5o1R7pt6F4HXnL3zYjiUqAL1ptBMKKq8JowLcPDrabiaavG0+2yrmV6qFa8ohfifInYUvjiaVj2uij8n2imcMlj+PqTetfqQk05aZM11kkjSpLmKXiPEkFmbL0DqXBWolXEcrlcW3c2VcCUp9Mpxs55dHTMU1euoKKYXq8XYpf6XRaLkqhxPDx4xMbGBnjJYrEAGcQmtjFMp1NOj49omob5fE6kPGks0TpjPp8znR+TZxn1smQ6X5B3OnjvsNaxmEw5Pj4mTRISDV7F5HFMEic4IElTXGtifnJySjfPMd5T1SWDYR/rLLX1pGnWuuA5siy9MPvCxufTmV1NaNk5xkyrBnPtVGd1MEF3WlD3JKrKiLxHnk5RjaHzMGF6PcFp1k3C9BxqIYMS7DCn2QhufqMiQ247FjphaSPuLza4czrEGIWdR6A8xIHfquaSaC4xaZjYokWYdFdNLEisLTYJFDcvBTYRmEQAWbiwWBDOk514mo4Mt/IVlBsKYTOk8TRZWGYKH1zSLtI8vOJcxdc2R9m0zxlC02w5yivM3quWYtYuIJ0G0w2xUPFEnLNBXJBlyyao7eqBP6eaERqzNOcwj5fgsrA09BKyQ0G5HZp5chaEKqoU5+ZJccCAVRtntXo9xDPRJqC3z48AdVSb4aBkFSxBVSGoNvya8wysLyCrmKoni753ry7UlK21JEnyjvinEOApwptHSKKWhC9EmGz7/R7WBpwX59fqvvARjk9GeC95+mZCp9NhPp+ztbVLrGOquubevXsBq5ZBdNLpdMB5zkZnNE3JgwcPAlsDxdbmLo8O76IjzaXtXWazGf1OjzxNePToEU5FTKcTDg4e0O10ieOYjc3NoDarKrIsxynJyckJkdCYpiZKYvJuh+W8oKoLIp2FBr+sOD4+RspAA9za3AkRThcoaQNWvKLDrSaqd/CVVxVQC+pe2+BaW0gvOiSm5Y87T35kwGtmN8LGXs8lzaaByEGliO8nFDpIpG/HW2xncwDujwcYo+BBhkhD8oYc1nCY4CKodixqFnL5bCpIj8N0Fk88vfuGuiexMSw3w/NSVZBNe6noHBm8DHcBJpU0nbAo1KULlLOuJFo4Ooc1XsZ4KSi3OF9kfAu1MvtfMR+kbfF7dY4Fh19CO1EbEK2IZCUQgdDomp6n6VuEFaTHck0xc3E7sdatx0Xz2DJttVhsl356LoMpEVDutio8214826UgsjUVarnmruVrJ2cB0qg2gkF+PJbt0heanRCOqpZhebnK8otmApsH6CNM8g5VhIn7icH9u1sXaspl1VDWwXwIIVBShTDVRJNEKVqfi0O8dyglQGm8VkhRs7u/i4o0TdNQFAWn4zNqa2icI+12uHRJ0807KKmpbU29DDzh8egkTMzGUiwKtFIorTC15drVa8xmE2bzBcdHB8zmc7YHQzyQd3KssUxmJf2tHepiidwYonSEVopOt8N8NsdYS1E3HD26R1kHXHjv6UtUVRUm8cUC5x1xlFCWS8rGYK1hMOjR7/fp9frMpnMGg40L/XLU/9femf1Iclzr/RcRGZlZWWvvPRwOSa3X8nKv7oNfLgzY/71t2IAtyYsWS6Q41HCG011da1YusfjhRFYNny4wLVzqoQ5AgOR0TdfSfeLEd76llSvxMWVZy6LP50kxNnhhDPzl5NXjMzkb6ztDyBSmrTD7DvvdDnVRoXykH+eEFwnnNBF6jWq1wB9POWre0QfNshljjSczgUOvyT6t8bscvTPE9wV2r+gWCcKqAsrLdbq7kGmuvVCsrCUapNnupMmZPjD+0mEaeez6xzmmBdNF+ZooUuSsiZg2onykvbB0M0U3g3wr0+jHVrbTR6gi2Eg/CsdDDyVX+qExQmLCJNXdYCSknUyV+UrhphpXBQ4vPNleJ+N8Eiwh/5hWuMbK8T3fCXNQ5JsBmkiOdHuBf8xB8gFJ/hhRQazArhWxOR3crjpBF+1VIIw9emcoHvTxINFehFyDd7SpkwG/FkhF6IgCgT2HA36u59WzJ+WBj6wSgOqdp/YtDdLMMlNQ5DnFyGKt+F6EEMSWcywGsr53rNdr3r9/z36/J8bI4XBI2HHO49OKECM3iym5VtiRMOb7vk/XWYFQZvM5WsN+v6VtWw6HA13fsq9ryqJgX9fc3d7y+s0bDnWNazq8Fom2tRaFTLk+BLquo+/7owPdALsURU7bdpRlybgc07YPaK3punBMVTHGYEwQSuAzajCnieY0FSsXyRwgjpmETHBYV8q1WJRjsk3vxwAa0xcUS0Px1mE2LSpEbC0S4WiAp0xoXguHN5pYehTQ9hkxfWOtIuNZg1KRvrboVpElTwVT6yO+2d04sm81HNRx8vPlB25oZsA7I7oL+FLjC42thafsizQxjwQCydqYLCwjtIFozJGjrZ/x9sZM5PmDms/uUgitkqWnL8Fde5mcnRgR6V4dr/ZZTaKqJa8KrYhoQhnp5x43VhAUsfJkywy7k4narkX150cxJUkDKnK4k8/bj+T1upct5tsiUe44plkHG8n2muZGcGZnwM0D+qCO4ajRQLbLEoYNrhS7zoHHrHw8Pge70SKO2Q4/a4qsPwlczvUvX89qyllm0wRshPWQOMveg7YqUcICrWtwe8F6YxQ6mjGaorDMJlPmfzdnvV5TFAWr1Upkzn9+zbt37xPP+I4XL17wtK3FcCgqAprtbkfX90fBxsPDAwTPdr3kt7//A5lWfP7qFdVohM6gW3W8f1jS9C2fvHhBaGqeVjtQinq/w3sxsH/38B7X99y+vCO6yDfffMN9NaLrOm5urmnbTnDwtkkxVzXWWuaLC4zJMdoyGhuqqnrWh/MhTWnIV4OEI2cnSpzuwXpg94G5jZHpqJtCOzcUa8N8pMmXHdn6wPxLw/htRrsw7O80hxeRuDXEPB5PgN2+xDuNNvJLHR4ES8k3iovfyUJq90odp23daewyQ7dweCHpyvl6YF1wNAEaf+fRLrJ7KcvH2VcN288KsjZS32hMB8VabgmuVFgvN4TDZSbSZSON0FUf3ziUU+j0UofDA41Q46KEpVKbE8RAmqrziBsHwo3AHNleZMzmIFxiV0F7yzFVOtQGdyGQkU5Kv5jw3QFnDloUdLGQpmm2Cv1deeQli0lRwO7UiXu81nSLQPleOHzaiatc7hSjt7LMc1XEjSTlxW5PrBuMHNzZTnwx3DiK73Iny0JZeJ4xjB+qnhcHZTNCiBhjjpzcD/0ejDGEEPDOEWNIVppD6rUYz3vfU28bHt4/8Lhc0jYN2mh2O8Eys8zwq1/9Tw51y93tHZnN+PFPvsAWJT5Eeh9o2h1aG5RW5GXF02rJT3/+d6xWS3rvWT5t2G6fUNpQlBWv7j9BjIwUXQxkUVMUJU9PT7R9x2GzZVSMWD0uORw6rq6uyfMcYwxt0zIqR3RFR3Adu50Y+FTVmMlkQpYZ+t6xuFh8T+n4MRUyweajUbhh0hyu2JyoVUOEz7Dg8fnAg03X4waq94HyuwZ16Ilak63b4/e4/abh6Rcj6ltNtND+qMdYTwya4DShSYwKDdF61Mqy+pk0XOWheNJkO/n+vhQjeNG5pDBSJZN88RQxHeQbj6s0o0dPVnsOt7nQ4AzHKdm0oF0k3wWh2E2M+AEni8pucRJSfFR94O4Us7TU6wQLiiYtvBxHnHnAlgdII19JtmAoIvVnDkxEHQzZQVG8ywQSuRQMwD6IGKSfBrKNTjizLOVCEvLoZGw/TP8hxTYNJvfai6LP52C30qijkUPY7hR2l2h3VTwaHuVrdUwzUU6m5u9T46CphImhe3lvTToszgyMH66e1ZQH20ytNMboo5AkhPC9BV6IYBM/WaTKEqxa1zXb7ZavX79muVzSu/a4xHP9nhAjy+UD8/kc5zv+63/7z/z85z9nMq1EkJKP0NrQ9w02t8QI2/0BW07QWnNfjTjsdkSluLy5pRyVbOqaaTGmKEv2XctPFte8efOGN2/eoLWi71pm8xnWlmTWsl6v6boWvwlU4zE2y4jNgdGoZLXcY4ym7QLjvGA+nzObLWibHq1S4vQzSn4xhwXUidg/TMNHgn9EvJaRX6yB7pXXkXwbmf5pT/ZuJckk1kJmoOvJwgz73Q53OUZ5ePFfWpa/KOgnOTEUYsRjhBI28Ft1J9SpqOEwGtRjkfZKtvdZLZNzLCKqFeZB9a1m/Bd5jOki7SLD50LjK9cCV5TrQDeWJVl2kESO8kkc8mThB91cIAD9V2gcg+m8HBoxUcoEutBOEZV4Eh+DVP2JsuYmEf+jhnLUEZ1G/2UszUwlWAVppuoxCXAsuJknf29wk0gYe9TBJHnzhyyMSEiMG+XAOIGhYibLuG464MHq2MhVEOFIeymHi11rCXkNp5+FYzqZijS3yVApLTTNQd6LQbAz4M3+DF/8YPWsphyCNNe8tClyKRARfnLXC91NWBnqmGYdY2S33fL111/z5ZdfApG269OS0IrVYZaxmM/wzqUlYWSzWRGjJ88zdrsdy+WScTVlvpjjfS9c5QC5zRlPZuy2a4rCUI4mAGgd2Oz3VNMJdd2ybxtGuqLOBHv+/PPP2Ww2FHlBBLa7mna/Z71e0/c9P/n5zyiLApfw8OV37yWGqm2YzSSRu6oqRqMSEJm4f24qcGquoeRIfwP5JTcdR69fNMcgTSLYbWT+laP67Ts5GNpOcu2KHJQiZoZwPZNkaBUgioXmMGXbnSZ/EnZEN4+pyUvzCDbiJoFsp+Xfy/RctSyi3DgtnBp1XIaZA2w/F/c3n7DwfBvJ20Cx7NGdZ/mLCl+IqCRYRfU+JB/hSDs3tHMx3xkYBKLW+fhR+Wg6FJHpWA/Mi8EVLkEM5tTYukUgLByjWcNhXVIvJ2RbTRYFuiCccGZXJXxXg7sJVH8Wv+VoIvjE4hgLHRGSQjAxLEIhB49pRCACQocbln7NffJ86UQYYrfqKK12Y7lB9DPhStqtLF4HqKd41LSXgXwtEvHBhEiFxH/mhD2f64epZ8IX0oyV1mTG4JxDK0UInpBikrIsB3ratmO/37HZbPjd7/8vdV1DkEaeW5Fra51hsozLy0vyzLLrGopQonVkvXrg5cuX9F3Nn/+8ous6tIZv/vdX3N7e473n+uqWUVGyWq4k5dorsrxgs9lgjKJpeooSgocQIm+evmZUVYzHY3yKeoom449//CPReXa7HUVh8R7W6yeYz7m9uSE6TzsW/rPKxMd5MplQVRVaKxaLyXFB9pwK9sRBPfrcDsup1CiCTZNZC3YfKdaRxW+eUJu9NOQYv9eMMYb+fkrINKbxUFmiVpTLnu2rQvDcr4XxcLjRTL6B+k5ods1VJBRgn3SS+UrmW77RBBMTl/b0/KpHWda5iqOCEK1Y/EEc4/JNjy+NfP9VoFlomptEBasU+U441+Iil5ZgGtxs4H9//KEXTTxyk+PwPieGi8it49ECMxrBZ0MVUDuD/8uUIpya2cCAGW4u9SeB6q3AG66KFA+afh5RKRnErjVuGsnWhmiF7SDc59R8O5mOu4v0XPXJOpRWoZcau1U0V3KItBdRlHg2YneKbiaNOUvhqP0sJlxfmnO+1ke2hu5Pr9skD4/wgVr0XP/y9aym7DrPdDzj0Df0yT+470S9Z/MCo00yta94ePiOx8dHmral7z2ZtmCkOZbKks3GVEXJdDKmGI/5yRc/QmnNt+/e8N23b3F1y6gQVaDvWqbliHq/RWtwzZam6TE3d7z59jW2zAmNQSnNZrPGe08IgmlfXV2JD4bWBA1FVeJ72G0OhOjZrp7IM2kUkgsXKMcVrz55yWgkqsOmbQjBU0xnXE9nzCbTY1MuCvF41trgXP+sD0f3wqAwnUycAy812AFTHCYcGD1ERg+BrAmS+GzTRxsC0WaE2Qg/svQzSz/WrH8sOXejd5HJm56s9iLIcBHTiaF8VsdjsnPWRA63MHorfOPBVax8L0ZCQ4RSdxkxtT6KL/xI2At2R8I55Youj0/pGxPL9lMjLIYoGLgK0I0V3UzTT2UC9FUgFgN2E+EZOXJZLQ3LJc+IwQxoUMYNvGWQ20G+0ugHfcTrScvAoXmNvw1Hilv3TlHfy2sonuSg0p3cQsoHoR1me6HCERWhiHTzCCaQbXWiPMZjLJTu5aBqL0TabTeK/StP/mQIVp5/sPEIcZkOsgdDVssNKjvI9442eWvYSPlekR04KkAHdgzIa3uOV/W5nlfPasrT6VQWexoika7rj9Q4osI58RcGuL+/RxvDN69fc3VxyXK74Wq+4Pr6mqAMF7MZn9y/IC8KvIoikQ6Rl59+yigvePuXb+g7T4wdt9cLdIRd3/PFi8849B2Z2vP+3TeYXH7Cei/c57Ztcc4xGo3QWvP09MTj46NYb+5rRqOKdi/cZO8D1WjEdD7j17/5NS8ur+n6nqws6ENkZDLqfY0PoIzl9vaOq6srLuaXx2gorRO1atDQPqP6yYmLLHHyfG+5NZjzANT3imAMs68j7nZGttzTX0843OVEBe1MU7+QSQyE5xuB/UtFyC2Tv+ijhePhRl6DaSLbHwm1LWrF6G2aoiKoPpnbdNLIfZnEIitN+RjpZ8mRrlTH5qW8KBI3M8Pt/zhQ3+eYLuILjfbSY4cg1WCguRFfBrdwYCMqC+jBXjJC4OM7x2BqdPQhThhqSPjtgDfHdAMY8vNsUv1NX3t8LjcI00b295o57WKjAAAQgklEQVRoFN309HkJbn260agwHKaRfCXvy+E2sR1ixGz1ccGompOIY3BwizoSSPzlWot1qFfYZGKvGoFYBGuONJdJaj0mRVypIyskZtDNEs/5g/DWYR9xbso/XD07eaTve3wQc6DCWsaVLOGIEKLc7WwSiFSjilevPkN/oXlxcwtG472k+mbjkkwZuq4lxsB8Psd7T+dajDFMFhPeP665v56xW+3Js5yffn6Lcz19W3N9MWNbrzg0B8bVjKIqWSwuePvtO1brJZ9/9hnWZgJlZJqHh/coAr//3e8w2jKfTzBG8frrr9HWMhtNWO1rXNvy+c0N48kcH2AyW9AcGqbzS66ur1Ba0xxa+s4Rgsdk5ujzURTFP/v+/XN18rodvC5O2PKR/malSboKNp9nxB9lHG5HR8bAcC2ORq7Gg2GQ8sPWXdEuNNV7T31rZJq1sPtMGpHuoFvIFds0J7Obbg6j7xTFE6w/C2mKk1y98kGa3MXvRZTRzhXBKOZ/7glW0U0t+cZj2sDqp4XEJEWJLTINdDNFeyWPVY2BPkIQf+Fok7Y8f4aMPcprCNlp8h0mfpQ0wmAFbhi8iFWEfCULtdVPDdrLTWbAoXUrX9PNgwhIWplQQfBlN4nHZJJ+GmlT04wK8qVg9LZONMekGDSH01PuJ/JnQzOlV7iZx8/l1qB6zfQrze5zyelT8WSh6nPZCdjl0OBJS0I4CZPicWI2z6PYn+sZ9Tz4wjmRUluhuEnsU8AkKpjVFpT4U4xGo6PCrchlotxu9lhjyEYyZbatNGCDYMzee9quYTqdcjgcGI0Dm0PH2AbG05xv3z2htWI8ntC0NZeTKd0IovYsLi5Zr9cYY/nlL3/JzcUl3vdUeUamIq9fv2a33fLy/g6lM9q2od7V3N3e4b1jvd7Q73ZMZ1Ouru+YVBN0ZkApinzEYjHHZJlQASNJNCITZtMIf9k596wPR7tTMyamCTWeWBgDlSvYSBzBAJbI1Ve4qcdIokzSjIcJSPx2YzJFl6m3HycRRy5JIOV3MDiO6Y4UuCrTY7/wgokaWP5DQF+1RKfpckPUGePXggnvXgiUoRPmvbvP0A7KtSdbe7qFpbkWrHMQyfgC+nkAAzEL8j+zIMpDgNZIQ34GfHFaYKYlnRpUbaRFWTy9505BAaaHw61wgKMRJoRALQrdqSPmbXcC6YioR3wxskbYNP1EMF0/Eu63q+LRxS1zsljNGlmYKqeO2X0hk8/AtFCs1NHKc/ZHUW26scAbh5tIvtQnxp8TX+Yh388l6ryrBKIZvDKCiccpPhRCwzzXD1PPasqda7HW0tQd4/GYtmnxLnB5eYk2Ii5RSeyfJRhDKYXNJEB1PB4TfGDf1EmBV3N1dSk5e97hXc98csG+XjOdTvn05T2rpyUP794y85FDv2NWLdgfdtzMSozKyDLN5iDN/fLyks1qy8VsweJyTr3bM7I5mS1YvnvEVwGyTLjOhwZrLQ6PUoGyLLi+uqSajplOx4zHU4zJKEcFkUhuRxDkF4sQiAHevn+HtRlaG5bLNdVk/KwPR/fSkLNGJhrdyoTUXsSjledQcWhYCqIVWa6rpPGYgzQNcxDHMdWfruNyFVZ0M8X+paSFVO883cxgukg/ERZAN08LRyVNBBNxl458Y2Hecznfs9mXBOvpbcQ/5Dh/ggmyQ/yeGMaVmnCX0000/URilGIWT5hxnppxJC0sFdk7K6pFDebJPEs8ovuB362OBj8xi3ibGqDjg3gkeYwbBCsJSrIbdZRcD25ywwJxgEOKp9TEOxh/A91cyyIuIi6CITFKEp5ud2miTZPu0FR1Jz8HPpfPLNuLl8XqX4nIxhxEcajS8jIU0mjdWKV4KmF0HPnPjUAYqOHrBDcfeMrh+Ze8c31kPZN9keO9O0YfjcdjiGKt6XxHVVWURUWWScCo1vo4ETeHAyQjI2steVEwrkYopSiLAq01TdOw2+6IQXFxccH11QUv7u/40lpC25CpHKVaooddXRPoQFuu719RlrJwm06n3N7cgI7MZjO0j/gQqEPPuCyEBYJikSKqdus1WmnyvCAzGYe6QWEokwXpdDql63qapmFSTQleJri26xiNRrRtI3zmoqTvn7foG7bgvgA+mHLMQZqqHw1X8MQUSAox1WrBIRUMirAhPw7FMVbeaFF1qSDwRHvlae7B50YYAB/worMaVKKOHW4DqpQNVz/NuL3eoFTkYloTo+IhTtB9LsvCgzSgbi6J2+VKKG2uUOgMbC3daXBJy6Y9vtfExkjSdnIri53Bj2Sy95Un5grVf/w0Z7qTb7AwDmJ6nerYKP0onnDgjNOfKzGT7xMfWOTXQwNXJ1m8lgZafjco7BSj94Ihd/Nks5oUlAOEYlqOLn6mUcRSDrZhURgGM6SEV9ut7ALcOCWUNOo0fWuBTERxqI6TvZt83x9aRcRIKU8/a4lNcq4fpp7XlDOL0QajBW4oioIQI9oYVC/ZelpptpsN9uqKssx5fHzEx0A1qtBG0/eOypaSGNK2R2e18XjI1Mv47rsH/vXP/w1aCTd69u+mmOj4/R9+K6KTZk1jR2zbSJYX/P2//w9gNOvVivF0wmqz4XIxxxiNCw7XB3LvCCowyTNClJElhp7MZDw+LhnP5wQf+PEXP2E8mTCZVLRNoDnUTCYLSepOjQ0Uk2KMNhpbFDRdx9XFJY/L5bM+nCBoyXGrHoqYNuOyfHOlNFm70YK/Wo99yqSpJHmt7mXbrrwS+CItofwkSGpyJs5m3S8OJEM/tv9WRvDqDznFUzxOaFkjS6H+H2u0jjTrAjcOLDcVV/M9Vgc6L0kkMBwoadpVpwXe6MHRzTNUiKx/ZHDjgBo7YmtwTUY+7uiR166S3aWyPU5HXK5RnYaLDpb5R7+3UackkcECNTV/X8h7qjzo4+Enh4ErI3F08pHQvZj8DFFQIT/ZX6a3WXDnWWr8FnafyuQ6+VqWnvUL0qI88ZtHcrBme3k+zQuPXWlcmlyHz09yBOV5dvNIdkgLxYKjL3T5GGmdLEtt+vt8mWxA84F1kpp1WrD6PB49Ps71w9TzDImcx2hzZDf0vcN5J+ZAsxl5nhOD4ur6CuckJLUoSqrCst/vaZqGm5tb2sOBvu+xuaVKi8IY4zHDz1pLkZkkzhhR73b85as/8Q+//EeUgv/+6//F5umBFzeX3Nzfs95t6buOxWLBqJrypy//xCp5aCgNv/3D/2PX1Ly4v6OrG1yIySTfMxpVvHpVcTg0LG4vuLu7AyLb7Z75fErwiv1uT1mWKB2P4pblcklZjljMFzw+PWGtZTF/ho0ZJw6sdmnB59RR+tvP4pEO1V6lbLbHLFlGxuRUpmlvfDKrEaqXrwIqwQK6TZSsHLTxjEcd07JldSjZvZ7R//2eXkXsryfkK9i9hOYmELY59Bq7aAmVI3415u28pLrdoxSUfyjJ9pH6PsmlB3tMJ9Pi9jOLaaC90Bxu00Gzy9CznugV3T4nKx1KRZQWr5R+VULhMfOO8FRgsoCbf3zniApUWm6p5G2sAjA4pMWklpvKNDz4LJtkwnQKPk2NeEgTSebywUZM/wHvd+Cap8m7uRY13dVvIruXmnwjf8f+k3icsHUP4z8b6vtALGSZp3vBrEMW09JXmByhkIm4W8h/ayf4d8jFpjOm1xXySBy8LVSSk7cyUetWPJrdJGX2nesHqeexL1Sgcz3VaIJWms61lEUu+HLb0nWSAO18x77ek+cFvWvouhZjMi4XFzR1TYiOi8s5MSj2ezH3iQp6F5hNZyymC6ILOOfpXM9iOkV99gUKh9aG//RP/5Ff/e7/MB5Pj6kmRW7ZrHcUpeWnP/sZwfW4GCiygryy3HzyCe1ux77e0XWB2WKM63tKrRPkccvN3Qt6r7i+uaNrG0KA8aTi6akmL3OI4UQBBPLkLR2c47CvE4TyvBoa8jFhuRAYQneCE0t8kNgwhhyBANJCr1sEdC1eC/3Cy/W41qeIe5e297NIFjS9N3TecDPZEz9N13EVyf/pgaffXuInAWzAlJ5YePp1gSo9xU92KKcJQVPmPXUZqV8I5SurxeWsm0tD8UaYFe5WfIO1A25aaAwxKMpxx2Fdkhc9MSpU0lL3gCnEvQ4P7pChi49XOBwZF+mgOwZNRo7SZzdJsvF00OlWII9YkJzYUjPrE0vFCc7bF5F8I05ywYIrTjQ+FaSxu5HIo4PVjB4i7VyWdaR066iH3MVI9VYf47Viog2GPCWNdHKDUj4JQ1ZiAxpk956wcsG8jVfHuKqhIRNlAeyzAfo6N+MfuvRzHhxjZDqdJomzZz5fYK1ls9ngvWc2m4kUuWmYzxN84ByTyYQ8tzRdiy3EqH61WrFaPVFVI/q+482bNxRFwctPXjJbXPB+tUT1HuugCw5lM4LKILNgDVcXl8znc5RSbDYb6rpO03vPdrvF2oKm6dhu98ymC+7vP2E+v0SbDJTC+8Dd7S1ZlnF7e8f17R15WVFWIzJjmE5niXdtmM1L1ustzjlihHrfQNRsN1tCjNze3FLX9fca9sdWN41HqlY3D4SEI6oAbu7FF6FV9POQkjEQF7OUKxeKgB8HsrXBrg2+Eh7r6FtDKCOTFzvsvMU/FYSgCFHRugybAvAy48mMx184zKwTPHVrCXWGqhyx1zS7HJs7ujZjuy/pp4HmzqfEjaR886IMDBkcbiLttQhBfCXc43wqPhLGBIppS70pcU4To6Kpc4FcNjkxKvR1i6oNauAsf2QNNw2fMHY3ikfRC6SmO5KmpXxqWoMzXPL4yFdi6yl4rHgly3I1+RyPTp/HkBYjoarSxNvLyPYLRbfg6JHtS065eghjQ/kUOZWoecFIBuDgi6I7eczkm3jEhqMR/+bBJyRYQEWaT3pZ+IbBVlVuCyFPYp+zdecPWs/M6KsgxfBOphUK8L4nMzmXlwtxUPNgtKXrGrzTTCZj2q6jPRyYzef0ztG0W8rRBfkoZ7tc87TbcH99y2cvPyU0nkPX0HYHnjpHlrc0rUMrjQsB19SorOHi8prlco3WGZeXYx4fngCYTse0TWCzW2O04auvX3N7dckotxR5xWg2pe1bfNNS5iXx3nJxfcvlxSWHrme12bDZ7nlxe8dGN9BFRlVJ/XTg9eaJV5e3tIeWvLAc6o6nzYbb+QLnPG37PLLnYA5DlKkKEnshi/QXHrMzx6lKt0LDcmNpxkJ1k3QN3Sv8KBBzkfbaraK9DthP9nRdhmszVKtoDxabeXaHAqUiIWiaQ442gcllze6pAhWxi4Z+KbcAO+lwneGwKwTO+XqEv3KowtPmhn5i5Pl0EZ9Dcwvuqmd8caBtLG6T43aW6e2OrrY4Z6jKjnZT0D+VmOsDockgD6jG4LcWO2+JXuGbj//xHXBXXyS8OHl2iK+HLDR9KfQ0YYAIC0UWrmkpmIzoCcn+MykYi0dNex0Fn+0UozcmYbmC+Wa1PAdvIQsf+G4k3F8dBNsdYBChx3GCqnqhxUFqzEmgQoDtF8mDw58M+MVZUBq4z0E1mstfafavxAwKSFLugXPNMVnlXP/ypeIznczOda5znetcf716FnxxrnOd61zn+uvWuSmf61znOtffUJ2b8rnOda5z/Q3VuSmf61znOtffUJ2b8rnOda5z/Q3VuSmf61znOtffUP1/5b3txnsuoLsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Load image of a kitten and a puppy.\n",
    "kitten_uri = (\n",
    "    \"https://upload.wikimedia.org/wikipedia/commons/thumb/1/1b\"\n",
    "    \"/Persian_Cat_%28kitten%29.jpg/256px-Persian_Cat_%28kitten%29.jpg\")\n",
    "puppy_uri = (\n",
    "    \"https://upload.wikimedia.org/wikipedia/commons/thumb/6/6e/Golde33443.jpg\"\n",
    "    \"/256px-Golde33443.jpg\")\n",
    "kitten, puppy = imageio.imread(kitten_uri), imageio.imread(puppy_uri)\n",
    "kitten = skimage.transform.resize(kitten, (200, 200))\n",
    "puppy = skimage.transform.resize(puppy, (200, 200))\n",
    "\n",
    "img_size = 200   # Make this smaller if it runs too slow\n",
    "\n",
    "x = np.zeros((2, 3, img_size, img_size))\n",
    "x[0, :, :, :] = skimage.transform.resize(puppy, (img_size, img_size)).transpose((2, 0, 1))\n",
    "x[1, :, :, :] = skimage.transform.resize(kitten, (img_size, img_size)).transpose((2, 0, 1))\n",
    "\n",
    "# Set up a convolutional weights holding 3 filters, each 3x3\n",
    "# Dimensions: num_kernels x channels x heigth x width\n",
    "w = np.zeros((3, 3, 3, 3))\n",
    "\n",
    "# The first filter converts the image to grayscale.\n",
    "# Set up the red, green, and blue channels of the filter.\n",
    "w[0, 0, :, :] = [[0, 0, 0], [0, 0.3, 0], [0, 0, 0]]\n",
    "w[0, 1, :, :] = [[0, 0, 0], [0, 0.6, 0], [0, 0, 0]]\n",
    "w[0, 2, :, :] = [[0, 0, 0], [0, 0.1, 0], [0, 0, 0]]\n",
    "\n",
    "# Second filter detects horizontal edges in the blue channel.\n",
    "w[1, 2, :, :] = [[1, 2, 1], [0, 0, 0], [-1, -2, -1]]\n",
    "\n",
    "############################################################\n",
    "# TODO: Implement a vertial edge detector on blue channel. #\n",
    "############################################################\n",
    "# Third filter should detect vertical edge.\n",
    "w[2, 2, :, :] = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]\n",
    "\n",
    "# Vector of biases. We don't need any bias for the grayscale\n",
    "# filter, but for the edge detection filter we want to add 128\n",
    "# to each output so that nothing is negative.\n",
    "b = np.array([0, 128, 128])\n",
    "\n",
    "# Compute the result of convolving each input in x with each filter in w,\n",
    "# offsetting by b, and storing the results in out.\n",
    "out = nn.functional.conv2d(\n",
    "    torch.FloatTensor(x), torch.FloatTensor(w), torch.FloatTensor(b),\n",
    "    stride=1, padding=1).numpy()\n",
    "\n",
    "def imshow_noax(img, normalize=True):\n",
    "    \"\"\"Tiny helper to show images as uint8 and remove axis labels.\"\"\"\n",
    "    if normalize:\n",
    "        img_max, img_min = np.max(img), np.min(img)\n",
    "        img = 255.0 * (img - img_min) / (img_max - img_min)\n",
    "    plt.imshow(img.astype('uint8'))\n",
    "    plt.gca().axis('off')\n",
    "\n",
    "# Show the original images and the results of the conv operation\n",
    "plt.subplot(2, 4, 1)\n",
    "imshow_noax(puppy)\n",
    "plt.title('Original image')\n",
    "plt.subplot(2, 4, 2)\n",
    "imshow_noax(out[0, 0])\n",
    "plt.title('Grayscale')\n",
    "plt.subplot(2, 4, 3)\n",
    "imshow_noax(out[0, 1])\n",
    "plt.title('H-Edges')\n",
    "plt.subplot(2, 4, 4)\n",
    "imshow_noax(out[0, 2])\n",
    "plt.title('Your kernel')\n",
    "plt.subplot(2, 4, 5)\n",
    "imshow_noax(kitten)\n",
    "plt.subplot(2, 4, 6)\n",
    "imshow_noax(out[1, 0])\n",
    "plt.subplot(2, 4, 7)\n",
    "imshow_noax(out[1, 1])\n",
    "plt.subplot(2, 4, 8)\n",
    "imshow_noax(out[1, 2])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "P0xTuXo3dyWH"
   },
   "source": [
    "### Convolutional network\n",
    "\n",
    "We will now replace the logistic regressor by a small convolutional network with two convolutional layers and a linear layer, and ReLU activations in between the layers. Implement the model and use the same functions as before to train and test the convolutional network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "filter size 50 and output shape torch.Size([1, 50, 4, 4])\n"
     ]
    }
   ],
   "source": [
    "check_archi = nn.Sequential(nn.Conv2d(in_channels=1, out_channels=50, kernel_size=2), nn.MaxPool2d(2, 2),\n",
    "                            nn.Conv2d(50, 50, kernel_size=5), nn.MaxPool2d(2, 2))\n",
    "\n",
    "filt, size = check_archi(torch.rand(1, 1, 28, 28)).shape[1],\\\n",
    "        check_archi(torch.rand(1, 1, 28, 28)).shape\n",
    "print(f'filter size {filt} and output shape {size}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vg4CO_WDeLqh"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 0 [0/60000 (0%)]\tLoss: 2.298790\n",
      "Train Epoch: 0 [30000/60000 (50%)]\tLoss: 0.341484\n",
      "Train Epoch: 1 [0/60000 (0%)]\tLoss: 0.202488\n",
      "Train Epoch: 1 [30000/60000 (50%)]\tLoss: 0.142703\n",
      "Train Epoch: 2 [0/60000 (0%)]\tLoss: 0.121101\n",
      "Train Epoch: 2 [30000/60000 (50%)]\tLoss: 0.105236\n",
      "Train Epoch: 3 [0/60000 (0%)]\tLoss: 0.097060\n",
      "Train Epoch: 3 [30000/60000 (50%)]\tLoss: 0.092981\n",
      "Train Epoch: 4 [0/60000 (0%)]\tLoss: 0.084372\n",
      "Train Epoch: 4 [30000/60000 (50%)]\tLoss: 0.075948\n",
      "Accuracy: 9819/10000 (98%)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class ConvolutionalNetwork(nn.Module):\n",
    "  \"\"\"Simple convolutional network.\"\"\"\n",
    "  \n",
    "  def __init__(self, input_size, num_classes, in_channels=1):\n",
    "      super(ConvolutionalNetwork, self).__init__()\n",
    "      # Fill these in:\n",
    "      ##########################################################################\n",
    "      # TODO: Implement a convulutional and a linear part.                     #\n",
    "      # Hint: see forward() to understand how they should work together.       #\n",
    "      # Hint: the following may be useful: nn.Conv2d, nn.MaxPool2d.            #\n",
    "      ##########################################################################\n",
    "      self.conv_network = nn.Sequential(\n",
    "           # Add your modules here.\n",
    "          nn.Conv2d(in_channels = in_channels, out_channels = 50, kernel_size = 2),\n",
    "          nn.MaxPool2d(kernel_size = 2),\n",
    "          nn.ReLU(),\n",
    "          nn.Conv2d(50, 50, kernel_size = 5),\n",
    "          nn.MaxPool2d(kernel_size = 2),\n",
    "          nn.ReLU()\n",
    "      )\n",
    "      self.linear = nn.Linear(in_features=4*4*50, out_features=num_classes)\n",
    "      \n",
    "  def forward(self, x):\n",
    "      # Input is a batch of images.\n",
    "      # Its shape is (batch_size, 1, input_size, input_size).\n",
    "      # Output should have shape (batch_size, num_classes)\n",
    "      x = self.conv_network(x)\n",
    "      x = x.view(-1, 4*4*50)\n",
    "      x = self.linear(x)\n",
    "      return x\n",
    "\n",
    "    \n",
    "# Create and train convolutional network.\n",
    "# The accuracy should be around 98%.\n",
    "conv_model = ConvolutionalNetwork(28, 10)\n",
    "###########################################################################\n",
    "# TODO: Create criterion and optimize here.                               #\n",
    "###########################################################################\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "# Make sure you optimize conv_model rather than model.\n",
    "optimizer = torch.optim.SGD(conv_model.parameters(), lr=0.01, momentum=0.5)\n",
    "train(conv_model, criterion, train_loader, optimizer, num_epochs=5)\n",
    "test(conv_model, test_loader)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EgLLXSScfwqK"
   },
   "source": [
    "Inspect the filters in the first layer of the trained convolutional network. What do they look like? Why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Ye1xcjUif4e-"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "first_conv = list(conv_model.conv_network.children())[0]\n",
    "show(torchvision.utils.make_grid(\n",
    "    first_conv.weight,\n",
    "    normalize=True,\n",
    "    nrow=8,\n",
    "))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FMxpPxv8EOEP"
   },
   "source": [
    "Let's visualize convolutional weights of a bigger model trained on classification of real images from ImageNet dataset. Training this network will take a lot of time, so we'll use a pre-trained model from `torchvision` package.\n",
    "These weights look rather different. Why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gADbMxziFsOh"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcEAAAHBCAYAAAARuwDoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3debAlZ3nf8fft7rPebe7sM5qRRkJCAglZIBswsQ0mpmzHTmwSF6lKxcSJXdgJi6SZQTjCjo0BGy0zWiBAElMVu1Jx4qoQVwE2tuMixlh4CWgBtDNaZjT7drez9Jo//Gf/ntG0bhMivd/Pn89t9enTy3nOqfnpeX1VVQ4AgBBF3+0DAADgu4UmCAAIFk0QABAsmiAAIFg0QQBAsGiCAIBgJRf6o/ee/38CAPCSVlWVt/7GL0EAQLBoggCAYNEEAQDBogkCAIJFEwQABIsmCAAIFk0QABAsmiAAIFg0QQBAsGiCAIBg0QQBAMG64OzQpvbu3af/UNRHkPpKv/RwOJD10njNNJvKel5MZP3ue+4x9qTt23eL/oP4+uCTWG5aRh1Zz403FblC1ovJWNY/fvfH9Y4M+/YZ1+n/IwcOHLjobffe+h5Zr0p9PbzXdef0dYoifa+WpXEBfS7LB++403jdupfCNXKu2XW6ed+tsj7M9LOad/R5z4yv7mnck/Wk0p8RcVkfJ3nwzot/P845928O/qx+zUx/jhm3hoszfe+VlfGZ0s1qtbSfym0/ve8z+kUNL4V7r8l990L4JQgACBZNEAAQLJogACBYNEEAQLBoggCAYLWaDo17uqdWVT0Sdf7MabntE0+ekHVf6fTUpi2Lur51Xtab6nV14swl9WRZ0tfbdmbn9C4GQ73vUkfIrHRo6Iqoa/xF396J1/dSkdVTzM45N17VqTsrDdwb9o3jCduwqicanXNuMVqT9VGhr9+5ZEHXc33e+51ZWe86fTxN+OmMrBdrOh0apfpejVd03ZdGMrknEq+L+j7FhfFLEAAQLJogACBYNEEAQLBoggCAYNEEAQDBajUdWqQ6XTeYryel3vi2PXLba27cLeujsU6QPfXwIVk/ekhv39RkWe/Hi7mGZapnSRYTfV78QKfTokTPDu1E9UQqnKuMEZ6x1+eryHSKbryiZ1hOx3r2ZBXp75Cdjk4vQp/3OWc8Y7m+fud7+vyueZ0CzSp9nYbViqw3Yc0CjVKdQE6WdJp0cEony2MjHTqaqdezDr9pXgzOGgAgWDRBAECwaIIAgGDRBAEAwWo1GNMxFoA898yoVnvgi1+V25458Weyvm33Nlm/6vodst5faGds2nRFhyKKvB6iSGL9nSLNjMCMsX1vRv+j+uyC/kf10HmdO3JGLsZ54z/oJfp6RF19X+fGUs/GNLXgWQvEzpb1zwfnnOsaiaeThQ7YpIkeTzg17o8oNv7QQJLrj9DuSI9w6x7X2287qoMx3VyPUzu7ub6fU8n630+I+CUIAAgWTRAAECyaIAAgWDRBAECwaIIAgGC1mg6dTPXYqZnFevLpxh96ldz23DE9SuzxR47J+v1ffFjWt+1qJx2aGMnA8cr5Wm0y1am1Uk9Bc1FHJ7/STKdDR5Wxo8BVlZGKs068kTrs9PV5j2IdM41KvR9vpH5DV0T6WSozfZ3mO7rez5dkvZPoz45Jrl83ayHGWxgj2fJU1xdKnQKdGel7rGNEW5dn6tvHJYs5vxg8rQCAYNEEAQDBogkCAIJFEwQABIsmCAAIVqvp0P6cTj5FcT3lVXXPyG2v+WE9/+8tP/daWS/GOlX17ONnZf0PviTLpt6WRVmPZurv1RuLtbpSJ7yqUn8HqYyrYi3iGrrEmJmYOF0vjTSptWZxnOgLEhn78cwOlbJIpxdXyqGsR6VOm88aKdCN1TlZXzVeN/EtfPx19D1QxHq13cmMPvYz+mPGdYzZpOO5+v6Ljj5fuDA+VQEAwaIJAgCCRRMEAASLJggACBZNEAAQrFbToWmuZ/1FIihVjPRLP3JCzwX8m/99RNaHQ72f4bCdVdh9VyfLOt366yaRniVZFfq8lLkxe9JIKRbWLMzAWaNDCyMdWhizQyPjO6E3Lkjl9falMVM0dFWlz+NaNGtsr59tb61Qn9Xn+TrnXBLrz4JpNZD1Rro6EV7N6xToipvKehob7zXXic+iN7ro18SF8UsQABAsmiAAIFg0QQBAsGiCAIBg0QQBAMHy5qrczjnvvf1HAABeAiormuz4JQgACBhNEAAQLJogACBYNEEAQLBoggCAYNEEAQDBogkCAIJFEwQABIsmCAAIFk0QABAsmiAAIFitrix/0803yfpgpr6y82RlLLft9jqyno70Csu9oV4dOq/0KssH7joo65Z9+/Y12v674cCBA42233fLe2u10nXltj1jxevImMSX5npVdR/peuVzWb/rrnv1Cwi33bZf1ouikPUk1iuTL5/Xq4SfP70i6zNzesXyzdsXZf0jH/2wrCv79xv3nXFfV8YF8cbX3Mjp6xEbs4S9saPfvP0+/QLCy/FZevcv6fdUGivCD2d6sj6Y1c9ff6i3X5vWPz+nU33/Hrz9Hlm33LpPP0++1PfewHiGXa7ra52FWu3paLvetj8r63/04Xfp13wR+CUIAAgWTRAAECyaIAAgWDRBAECwaIIAgGC1mg71TifUyrKeWur2jXhhofvyaGUq65t2bpT1M6d1OgvORVW/Vhut6CTXyqpORsbeuHWMlOJgVm8/WNDptyYK457pDXTSeDijj2V2cV7WJ2Odujtx5KysT/Wt2kjkdEoz8rpufZ2NYn09IiPtWZXG/q164JbPrcp6HOl7ptvR16MwApZxpO/VmWE9TToQtRcjK/UxdrxOVQ+LZVnfXR2X9f64/oDsqPbIbZ/MLpP1NvFLEAAQLJogACBYNEEAQLBoggCAYLUajIki/Q+nK6trtdoVr9optz301ZOyPl3SI7AWtg5l/fBh/Y+ycG51VB+5tDbR/5A/Ef+I7Zxz2UT/S35sjFmbd3q8ne+tPxizsqSPPS/0/biwUb/m9su36O036dFND3zlcVlfNUYCNmHExpz3xng04/tsVFkBGL3/vDDG21XWEYUty/TnUuX1ebRGm/Ur/dzEHeO6JvV7u4ra+U2TJ0Y4sdJBM+frY9Ccc25xelrWd7lna7VhVu8RzjnnjfF+beKXIAAgWDRBAECwaIIAgGDRBAEAwaIJAgCC1Wo6tNfRqbvnjhyu1X7sZ/+e3PZLn3lI1rdu3STrc9vrI8Ccc25qpLbg3PZX1Bd97c8bI5GM0WOlsWDtZKTr6USnvPKpMS+qgcmaXuzzzOklWS+dfs25LXqR3K07dTr0iqt1mvT5Z/UYqSasRWynY33sWa7Pu4+MRapTvX1mLYpMOFSKE31+i0ynqgtj/JxVL61VkcXC0JFxLE1VxgLby5FeLPqEkfw+0dkm60VSf852RMfkthsqnRptE78EAQDBogkCAIJFEwQABIsmCAAIFk0QABCsVtOh1tzI0aQ+S3HDop43d+b4OVm/4qrdsp5lOhlYGTMT4ZwaMTg7q5O9m4zZrMNZnco9e1KnuU4e1UnNPF//Yq2DgT6W80s6oXf4aX0shTFQc88VOhXnvU5YDmd10rYJK6WZFjqmmZX62Sut7Y2FiI3Qr4vFrEo4FxnzOktj+qu1vTWb1ZzZKupl1dLCx8YKv3mk78nlWC9Gfcjr+dBnXD1tfV3ymNx2Q9nCCtUvgE4BAAgWTRAAECyaIAAgWDRBAECwaIIAgGC1mg5Nc53UXFysp4cOP6ZnxW2/bKOsxwOdklo9rVfx7vfbmaP3crR8qn7OTj6v512WhZG+tWYdGmk2b6TihjPrX1l+wwY963Ca6lmgk4lOnK2eM2aQHtf32MC4x6J4/YM240Q/msM5Xa8ind4sjZR0numkX2wMCY1ivi8rkdfn3Tcdtlpas3X1PelFkjkyEsJNbfU6oZ/4VNY7kTFHuLtL1leT+v8ZcCzR25bZcVlvE3c2ACBYNEEAQLBoggCAYNEEAQDBogkCAILVajp0PNJzI3fu2F6rPfPNo3Lb7a/UqxGP85Gun9Zz6wadVt/ay8rqcn024MqaTnuOl3XyqzDShZ2+Pu+Lm3WC0w/W/z1sMKNTmrML+jVLY+ZnlumZictLRkIv0jNLi2r9iVfn9Pl1xnzIxEp1JsaMUG/s3+B9S3MpX2aijpFCz40Ur5HWtWaEFsYMWZk+XX8o2Tnn3NDrz9puvCLr/Vinp3PjXh2J5yON9bO3GutnrE38EgQABIsmCAAIFk0QABAsmiAAIFg0QQBAsHx1gdWIPZEwAMBLXGXFbx2/BAEAAaMJAgCCRRMEAASLJggACBZNEAAQLJogACBYNEEAQLBoggCAYNEEAQDBogkCAIJFEwQABKvV5dff86v7ZL3K6r02KvWKyYmxYrl1oFVsrHwe6VFxd99xr7En7db33ayPR3x9sKfTadbY1iLXf6iMpaPv+sQ9jV53/95ba7Wy0ufRR/p7Ullab1bX5UrYF3jde+6+09h/3fv26Ws06OpVv62BuIO+XhHeG98VreuX5nol+t/6yG8Zr1x3096bZL0/NFYyL2JZXl02no80lfVOX7+p+UX9BH70N+7WxyPc9m/r951zzk0yfb6yqa4XuV6FvCz1sVvXNYnr7+nOgwfltpZbf22/rM/3urK+fF6vwr50Stezqf48nN+0UKv154dy24999EOybvn4+94h65O+vgdOxfVjcc65M36zrEfies94fU2rQn9u3Hvg4j8fXgi/BAEAwaIJAgCCRRMEAASLJggACFarwZg41/84n4gQhZ/qfcwU+h/++0bgIiv0P6hO21oPuNTBgkoFY4wQiRUu8cZ7ipx+zdIIzDRVFPV/bPfW16FK/8O8FRax0iLeeoELLOp8seaGfVnvGNkd9f6dcy42DsUbURoruDEd6ZBDEz7Wz1Lc0c9HbjxPyyfX9P6dfm62XjYj68OhPp4mUutaq5SZc86Xxmsa1zU2wldVrPevr14zw+FAH4sRzOsk+iM3MkI9bqyPMh/VL3jRbec3zbin77GTXR2AedZvl/Vz1RZZ3xwt12rD4rTctmt8/rSJX4IAgGDRBAEAwaIJAgCCRRMEAASLJggACFar6dDSSlIW9ZdJcp2eGmT6kLqFkZ4yUlhlt523FiXGGLBuPbnmjeSXi5ol67zXibCopcSrGmHmnZHCMhJ95pg1M2aq91+2kP5KjNcsC32Mzhzhpo+lMkbETVOdsJxM9EiyJuJYv2Zi3O/jib5nzp/R6dB+T7/XwXBO1ucW9eixJmIj8do1Eq/eSCnmuXGdjNSvdQ+3EEw277G4Y3wWGMnW3BgFZz0eXtTbClKejjfI+mGnU6BHqz2ynrlZWd+RnavVtlf6Pi2mLaX8L4BfggCAYNEEAQDBogkCAIJFEwQABIsmCAAIVrvp0MxIYYkkqM/1S1cjvW9vBP2Svk6QTY0EYGNGok3VKysFas0ONeYFVsaxeyMx2JQXsxQrFTdzzp7TaCxYu22HTpBNJ3q45ekTZ/QLNBAZB5nmRlrZmjFZ6uuUT/V+Rqs6BZqvPxzqIiPxGnl9jxWptTCtvsf6s3o/gwW9MOtgXi8S20RZ6QRk4vSxRMbM1tj4MGj6fBjrejdiLYBt/b6wE5zWnFTrM0JsaiSHmzpTbZT1026rrE8KPW9229oJWX9d8Uitdml5Um57JN8m623ilyAAIFg0QQBAsGiCAIBg0QQBAMGiCQIAgtVqOjSJ9e7iStV16ik35o9mRpKyVEu8O+cKa6XmplQMyzk9CtOa7WnOpGw2A9Eb77WpSh2ntQq7MSM0NtKLsbWcu7GMtzWDtInJVMcxs9RIhxpDI61AcTrRqca1Nf26RRuxQ+t+N9KImTHH1Loecwt6RfTKmPE6Ga0/8loa97UxNtN1jLSnNYPUep5iI1FbWcnvBgpjrqw137Qw7r1EzCJ2zrnKSPdGidjenNvbjDfO48ZCR/e3jR+X9e+v6ilQ55x7Q/VArXa20qvWL/WvlvU28UsQABAsmiAAIFg0QQBAsGiCAIBg0QQBAMFqd3ZoYiT9RKvNjTTbtGOk3yIjcdfTb6EYrD/55ZyzQqyukivdG2lPI3pZGatSV8bMy5YWjpav62MrWaf3kY3Hsn7k6Wdk3QrrWonBJtLCmPlpzQI1UqOFMfQznepjXBtbq4q3MMPRSj1nxj1j3B2LW/Xq3nOLfVnPjBXqs6meFdvENDPSocb2pTFP07ono0gfY2kkMvMW7j0rgZyL+bzOXej6aUlPn4PeQMxybeknzTDS98AgPS3rW4vzsr4rOybr58r6rNGH+6+W2z7YuVLW28QvQQBAsGiCAIBg0QQBAMGiCQIAgkUTBAAEq9V0qJWCLMT8zbijX7rUIw3NJFeZGDMWraXoG6qM2YCyas2kNFd8NlacN1JxlTXHtKFKZNGMQ3eRMQ/WXOHcmJkYJUa6MFr/dZpmOs02HRuzPY1jHI+mevvMWt1b12dndCKzCWteaZHpemQ8B3OLPVnvGCnscqr3n63JciNVpe+Z0kjxToxUrjXjNXLGivPW8RjPdhOlTInbdXP+rzH3s7RS8eIzJTWeg8aMuG6v0M9HYgx/PVptkfXlfj3x+UDvKrntsc6iPpgW8UsQABAsmiAAIFg0QQBAsGiCAIBg0QQBAMHy1irbzjnnvbVUOgAALw3VBaL1/BIEAASLJggACBZNEAAQLJogACBYNEEAQLBoggCAYNEEAQDBogkCAIJFEwQABIsmCAAIVquL6u7d/wFZz4r6oouT6YrcdsN8X9YHgwVZtxZOtRZavefAQVm33HLLLbJeROL7Q6UX9ewbCwg7Y+HNKDYW1dV7cbfffofxF+3md++v1ZaXluW25uA8Y2XTqjQWGTUWPE2Mc/Pbv/MfjBeu+5V9/1rWJ9Z/YCxUGhnHkor71znnKqcXCq5Kff3uu/Ne64hqbvrVm2Q9GevvrYXv6h0Z7zU3hkiNOvrY+5F+zj75oYt/nm59v36WrMV2Z/v6mR8v63MwWtVXvDfU1683W/+M+MjH7pLbWm69Za+sF5k+RmtKpY+sP+jnJkrq+7cWVr79jrv1vg3vuu2Dsp5H+n7PjQW2c2PxavVJNmPcp7HX1+7TH/lNY9/N8UsQABAsmiAAIFg0QQBAsGiCAIBg0QQBAMFqNR3aMfJ4G+bqybXdV79abnvm+ZGsP/zAk7LendV9fG7LnKw3FutT1Bn0arXKSBF6IzVapjrBmmd6P2Vhpa2aWV1ardXGRrLOl/o1faQTYc5IHUZG+q0s9LlpIurr1JqP9cFklT6/naHeTxLpe8BKABapcW4aiKf62GfGxr1hpHLjUh9jbiWQh3r7bgvra5eFfk+lkSI8t6ITy88+cUbWRyv6s+Oq1+yQ9WS4/uu0ahz76rJOv+ep3n4oPk+cc25mRqd+Y7FGbNXSb5qk0seYGtHWNNbHPjES5EUmnvmu3ncnWv/nwwvhlyAAIFg0QQBAsGiCAIBg0QQBAMGiCQIAgtVqOjQ3UnGnz9XTRp//vT+S2y5nS7L+E+/8AVnfsWNR1s+d0EmxpnKnk1Kzs4Narcr0fEU3GctyVerkUz7RqdF0Yuy/of6wPp/VG1+HvJEUK0U6zTlzpKiLE/2HKFl/Qm9kpGnHkU7WZcZ3v8TpY+l0jZmixnzavIXEa2HMY4yNFOickVSdWdXHkhqzXFNjPmRljCZtxLjUsTE3siPmYzrn3I7d9WfPOeeiaEbWN2zV21exvn5NbNql973jal3PjM+IYqLPQTHS5yAd17eP4jYuknPzhf7sjAp9vrKRfk9xaaS2ff15stLN1kjcNvFLEAAQLJogACBYNEEAQLBoggCAYNEEAQDBajUdmhqDI1c79VmV7/iNt8pt/8E7vl/W/+Z/PSrrX/nsA7Lec0NZb6oyZiYOZutJtKjUr5kbXzXOndXzBcfLa7KeTttJhyb9+gHFPT3/LzFWGrfSoZWRJo2NcxAbs1mbSDs6iTeK9HsaG/NQq0yn2czxhbk1a9TYvoGyMmbWpvp+3HhO3xvbz+qkX9kxUoc9/borc+ufW1sYz5I1Vzbp6tdcvERf76Srr8fESPGWRjq7CTUX2Tnntl6+IOsLW3WC9exJ/Vlw7NvnZX3lTP09pcZc2ab02XVuYKxcP4x1faRmhDrnxlX93quMWcTe+JxpE78EAQDBogkCAIJFEwQABIsmCAAIFk0QABCsVtOhM4s6KXXZzj21WnFSJ7bedcOHZH35hE4a/f2f0mnSwQZZbiw2Zlv2evX3an2jKEZ6H9aMySzVSb/cWIm+qb5YrbprrM7eM1dtt1KjxgrkxnutjJmBTRRGKK400sqRMVO0KIx04VSf944x3zMx5s02EVkruRvnKzJWOO86vX1WGAlZ6zpZQ2EbKBuel9w4du+Mma1GGtEou8hIJDbx2FdPy/rDXzoh62Wsz8HMvJF4NVK8iUjxeuN+bypa0+n02Z4xtzYykuLGQOKJSD5PjeG0afGdHx7KL0EAQLBoggCAYNEEAQDBogkCAIJFEwQABKvVdOh0Wcf0Hn/6uVrt+NN6Jt73vUGvIP+a798j608eekTWz5/XCaemkkh/T8jSaa3mjZmURa7TbNZq7pE1fDJrJ/1ViVmNnb6+FeKuPhZvDAONjYRamelk2WSy/nmoPWNeael1PTWuU27MKbRWc+8YCc6ekZZrIjOezHFf189s0P9B1p+T9ZFx8x3dOC/r08H651J6Y2l5bySKi9xIHRppT2s+rRVYTvP1v6fpij6Ys8fGsr62oj+XFjbqmaIbd+j6zMZ6LemtP+3qnHPjVKekh5H+HOt3jOfD1T8jnXOum01qtZGRDv1/sbQ8vwQBAMGiCQIAgkUTBAAEiyYIAAgWTRAAEKxW06GREdvauK2+4vqea7bIbTOnV8L+2wf/XNa7nVlZX1jUKzs3ZiQG07FIhxrvvzCGW1oZwrij01mdqp30VxLXX7nXNeZgGiuNeyM1643U4dRYxbs0kppNJE7vu2/MmIyNVGcpzotzzqXWvE7j3kjEytlNJaU+9qij3+uafgzcpK+PZRTr67o6p7evjHPTRBQZHzeVfj6qUr+mN/bjjVR1ZFw/6x5u4rJX68+xV32fjvFaI2EnE329p1NjjrB4nvJs/Ulr55zzxkzV3Ei5G5fJdYx7Jhbp9Mo4divx2yZ+CQIAgkUTBAAEiyYIAAgWTRAAECyaIAAgWL6yBus557y3skwAALw0VJUR5Xb8EgQABIwmCAAIFk0QABAsmiAAIFg0QQBAsGiCAIBg0QQBAMGiCQIAgkUTBAAEiyYIAAhWq4vqfmjvu2S99PVFGitRc865aakPKS2NRV+NhTRjY6HVj911UNYtv/ZzH5T1PKlP4bHWUs26+lismXS9+nq9zjnnOsYL/Ppvf9TYk/a+D3ygVrMWHnWFPvbE68VwvdfTiUrj+1ae69e9954D+niE935AX6PSOMNd4zp18jVZt65T0asvFu2cc3nclfX7PvQhY091+/btu+htv5sOHLj46/T+/TfJelXoe6ayFuE1v7sbCzQb0x+9WNz1rjuafT68FK5Tk2vknHM37b9Z1r3xGTHo6vt90NfX78zZU7VaVelFiPuzG2T9jt/6iKy/GPwSBAAEiyYIAAgWTRAAECyaIAAgWDRBAECwWk2H5k6nhMqoXk9L3X8nZU/WM6fToV1jrcTEZbLelO8YfxCHM430saQ9XfexkWYTqTXnnCutBGdDVVHfjzfSulba01c6NeoK/Z7iWF/vyjhnTVS5jtMmIsHrnHO9yjjG0XlZ90YStjCuXxLPyHrovJUCNZLflZEUL42UtHeprMexkQ5t6Xl6uenFOqk5NZ6zbz91QtYXe7Oy/qa3vK5WO/Tct+W2Z8+elPU28UsQABAsmiAAIFg0QQBAsGiCAIBg0QQBAMFqNR1qJT5zkebKjCTp1A30PnL9mlWpU4q+pfZeVjplmnfrpy7VwVaXLejUWpUYCdaRLkeZFVVtSKT0KmPuoq90gi4yEpOldaGM1GgkksNNeSN5GsdG8jTV591PJno/1rnp6rRcGRs3QuC809cjNu4B7/Vs1k6kz2+eLesXLq0HinSoklf6Gd60Z6Os7379K2T9Dz7zp7L+1Q8/Uqu981/9qNy2o0eHtopfggCAYNEEAQDBogkCAIJFEwQABIsmCAAIVqvp0MIYtJn5epprnOt5gak1f9RIlvlSJy9LI+HU1GRWp09X5+r11Xn9mtNtK7JeRDqNOFzVqbj++XZmUqpsXWSsIO9LnaTs9Y3zawRYy0zvp8qNGaRNGCNYnZiReqHtI2M+rZWQrabGOUhaeE8vQ4VxPSJjPm3U0TMsk0Q/H0U2lnVjVGxrCfKXm2RFn7Bn7n9a1ne9QT/b9/zRv5P1377jf9Rqn/uTv5Xbvva6PbLeJm4DAECwaIIAgGDRBAEAwaIJAgCCRRMEAASr3XSoka4r1ErQiY4R9odzsu6N1aQrYzVwl7czF7Ds6uRaOawnAOMNRgJy7pys+1jPnvSlEWcbtzOTUo1bjYxAY2Ssnt6d1yne/rwx+3VNJ2HXTq/pF27AWpu+yq15qEbSONL3b2zECHPjO2RkXb/QGee3Ms5Xleu0Z2YkmSsjyWx+1TdSqaGLe/p6vGL3Tln/8n+6X9Yf+uP/I+v/4tffWattX9CJ35PPnJb1NvFLEAAQLJogACBYNEEAQLBoggCAYNEEAQDBajUdGhkzFmOxOntkzfY0Vof23lh92lj5PfbtzG/0U/2e/LSeoKrWdNqzY8zZ7BiLqnfX9LF3Ju2kDr1I8UZGUC6xEpNOn5eusZp71NH7mbYwwLEyUn6V8R2v8PrYM6+P0RnbV8a5sebchs4b5zFyRqra6RXhy0Injb2xH+v6mfXArUb6vJSJvh7vePdPy/r9X/hrWf/9j9Rnh+6+/nK57fzcrKy3iV+CAIBg0QQBAMGiCQIAgkUTBAAEiyYIAAhWq+nQTqxTjbFI70WFTtCNJ3oV9szYvhvpxGRsBP2a6mR6FmY/rSeoyhV9jLExmLPbMeZyLhszQkf6WJoqyvpxelFzzrlqYiT6ThtzHZd1giyq9AavZiAAABeJSURBVAVJRy2keGN9G1dGgrUojRXku3ol87LQ6d7C69cto1Yfq5eNODLSurlxD1S6HsVGWtdYQt4biWVGh2qdnv6cWZvoZ/7B5x6T9St+YI+sr5ypf0Zko1Rum06M/4ugRfwSBAAEiyYIAAgWTRAAECyaIAAgWDRBAECwfGXM+3TOOW8N+wMA4CWiqiozC8wvQQBAsGiCAIBg0QQBAMGiCQIAgkUTBAAEiyYIAAgWTRAAECyaIAAgWDRBAECwaIIAgGC1uvrnLe+/VdbHYl3E2dmh3LazdkrWp2Njwd75RVlPCz3x7d67PibrlptvvlnW5zfUF2A9fkwvOplnet+X7NbnIOp2ZH3l2HlZP/iJ+/QLGPbfsq9e7OjzFSf6vFdOL2A6mur9JMb3rV6ib8Hbbz8o68reWz4q6889/aysL8zrRXX3XL4g6+PJRNarwlrEtSvrv3n7XbKu3LJXXCPnXJnre+PsqdOyftV1W2S9P6PPwbHn12R9MtHbf+rjF/+efu1de2W96ul9Gy/pViNjUd2Ovpc2GovzDsWD+cGD9+gXNXzwl98v69NUP/Sx189Bp6PfrDXWsnT1KWD6bnTu9tvvNP6i7X2/fk/WIsRFphfEjY2F0JN+/R7OnL5G3lgA+8Bdzd7ThfBLEAAQLJogACBYNEEAQLBoggCAYNEEAQDBajUdmuUiBuqc2zicr9VOP/O43Hb3zp6sz8zvlPWzqzqFVaT6WJqKYp1OSkQ5TvW2R545KetvfNuVevtnj8p6uqpTWE1FIl3X6xvnfVa/p83bZmU9j3RGbXlZJyxHp3S9iUOH9PnKpkuyft2Nl8n6xm061XnksE5M+lKfszRf/2PVj/U+zi/pFN3q0qqs79xzlaz7WD83Tz16XNbLVF/vJozT5aZdfc+sJDoZudTR392LSu8nNuqRmae8eOdX9f1bGsuRx5G+fh0jaRxHOmFZRfXnsrTimw1lhb43esZ5nxvqlPv4/FTWR2v1c9ad06lnb6RG28QvQQBAsGiCAIBg0QQBAMGiCQIAgkUTBAAEq9V06OyCnr14/KlHa7XvuVbP/Lxku06z/c5/f1DWd157iazPz7Tz1iIj7RiJmZqx8Z3i8Ld14m7Xq/SxP3f4GVkvpu2kQ1eX66mtU8f0vs8dH8n6dFXH3zbv3CTrG4zkpavWn+KdHeg021Wv2yXr116vj3F5eVm/gDEDsSz1PZZO1586zDO9jzTVabm00NdvdrOOZI7W9H6Wz+r9zPTWnzwsEv18THUw0E26xvZdfSy5MS94lOn3OmPMy23ESG+avy6MpGpp1L2YEfp3L6tS2+2kQ/vGLNdNM/WUv3POnX1azzR+5tBhWd91Qz3pP79Bp4/HS+tPj78QfgkCAIJFEwQABIsmCAAIFk0QABAsmiAAIFitpkPTU3pV+J1b6vGvq658rdz2tps+K+uX/8gbZH3Pq3UC8NiDD8h6U16msJzL83qyrKqMdJYxB9Ib6bcsN1ZZdsZS2w0N5ge1Wm+ojyWKdP3Jh07I+uNfOiLr2y/ZIOs79+h6E1e8Yk7Wd12qZxqORjrxeuq4TqqePKaTe1VlJNfi9X+3rIzvp96YPTmY0+nbTl/XRyf1rNHxmj4Hs8P133uTWD8fUyM4nFr1xEjfGrMtUyPBOdWh4ka6XSPa6nTyNLLSocawUTO/Kleob+c3Td9IPT//iE65//VXviHrr337tbL+xrffUKs9cv8hue3y2bGst4lfggCAYNEEAQDBogkCAIJFEwQABIsmCAAIVqvpUO91cm3H5VfXap/53b+S285ep2eHvuOmH5b1P/zkZ2T9koFODDblS2Nl57Se8qqMOaO7rtgi689+4zn9olP9mr0ZIy7XUOHrCcDBov4+tOd7dHrz7e+9Xtanqc6znXz6nKwfe9qY1/mHuqx0jVmSZ4xk2WSq3+szh/TczCNHdWJy02Z9PRaGVmLw4lW5vpc6XX1+Fzszsn7++Iqsn3lOn/d+T7+nQRvpUCPUmRpzUisj1Wmttm6MeHVFps9ZZjzbTXQ7eh/drj6P1uLvpZEIz416JVLblXUCGhoZCeHnzy3J+g/9wptk/Z//yj+R9b/47N/Uao/db6TKt22W9TbxSxAAECyaIAAgWDRBAECwaIIAgGDRBAEAwWo1HdoZ1GdSOufc4efrSbQs0S/90z/zeln/8u/9N/2aS/VV0p1zbuESPVO0qbI00lni+0MZ63Thnqu3yfrzjx2T9ajQ6cJo0MJK2M65JK4nCXNjxfJDj+pVow89pmeHdo1kZDfW9XS6/lswFUld55xLV/S+l5eMNOlJPQt0ZqhXZ9++Td/vw8H6V5Z3Pf39NDbmkvZifSynj+oZoSvn9ODMDZv1Ct/9ufVfp6GxwvvAmilqTM5MjORsbsz5ndFhRzeU8zebsVaEz0v9ot6Ih1ZGvTTqqTiXUyMF21Tq9b3xiu+trwjvnHM3vlnPCP38J/9E1r/wqS/Xapfu0J/Xs3Pf+d9p/BIEAASLJggACBZNEAAQLJogACBYNEEAQLDaXVne6Xl5E5FkuvyV2+W2Jx99SNb75/UcyMuuuULvZ1nPTGzMWC2+EPXCmB26YUEn91bP6eRed6i3T3o6XddUNa2fy8r6OpTrxJ0v9azK6YpOxZXGzEtrpfQmssK474w5pivGbMTeQD8OW7bp97rRmLeaT4wV5xsoK5007nX1MXaSvqyPl42ZlIU+N4NZneL1RmKwiRnjWfKVPpaukeqsjFtGnzHnZkp9nbp+/SnejjEj1FkzQo00qZXrLI0EayZWojfGjDbWn9WfP/1YfxZ87fPfkvUnvqZnI19/7TW12q6rFuW2eWf9z9IL4ZcgACBYNEEAQLBoggCAYNEEAQDB8pXxj9LOOee9b2cODwAA3yVVZaSyHL8EAQABowkCAIJFEwQABIsmCAAIFk0QABAsmiAAIFg0QQBAsGiCAIBg0QQBAMGiCQIAgkUTBAAEq9VFdfft29fm7r4jDhw40Gj7vTcb70ksaumNRSfjnrF4Z6RHs6YTvZpoJ9H7v/OOu/X+DTffIt5TqVfknJnRi4ZmxoKn09w4duPrljdW873zwF36PxD27d0r64U+Xc4ZC5t2E/04RMZjMlrTy7h2unph2gMHbjcOqG7/e27Tf+iMZDny+jWLUh974fTJqTJj0V6v74+7PvFhWVf2/vKtsu69sdju1FiAdjzV9b7eT2Rcj1Ls/uCdF3/fOefcBz5wi6zHsX62y1IfY2k8B4Wx+HGR1w++VG/IOXfffffJumW/9TkuXtM556LEWNQ61wvizm0c1mprS/pZKsf68+S+T90r6y8GvwQBAMGiCQIAgkUTBAAEiyYIAAgWTRAAEKxW06EvS8bXhKkIPpWZTk9t2jEn6xt26lTVyRPH9Wuu6VRcc/VkYGYcu4+NhF6RGdsPZL0odcorMpKBTVSZTi4m3kg6GmnBzoy+2Klx7KPzOqmZpHr/TVSJTgW6ga5nkT6WyhvXz7qxsxldLtZ/ncpU3zOD+b6srxj3e8/r7QcD/Z7Or6zIen+mnlJsyhtJY+O0u0qkyp1zrrRSoJmxfVWvV6L2YhiH7np9/TxlU/38rWXLsn7lJbtqtW88cUhuO5z/zrcofgkCAIJFEwQABIsmCAAIFk0QABAsmiAAIFikQ19Ap6OzUrkYvXjkW6fktkcfOyfrb/rJ62R92/Ztsn7urN5PU/1hPb146pklue3OHTtkPe6dlfVjh/Uxbt62XdbXlvXrNlHmOrm4tqrThd2uTuXu3Lwg67t26cRrVj4n66eP6qRmE7mRbK0ifT8mQysBuSrrZaUTfdOVjfp1pzo12ogxcHY41GlPbwyc/drnHpH1t/7IG2S9s1mfy1Nn13/vWYHMXJ9elxppz8LYvqqsVK6qW7nOhowZpN3erKw/8cxTsv76H7tK72dav97f+MoTctuf+qUflPU28UsQABAsmiAAIFg0QQBAsGiCAIBg0QQBAMEiHfoC+vM6Sbhtd30eaKfQ237xv35d1rOxTmG95i17ZH1m67ysNzW3UI+2lsaxP3T/UVn/Z/tvlPUnHvmcrG9a3CzrcU+/bhPdob6NJxN9fh//mn5Pzz52Wtb/8S/qhNq1r9kj608mz8t6E1YosIp14rUzo+c0zm48JuuxMZt0KdL16UoL35f14uHumUf03Mh33PZ2WT/ynH5P//N3/ljWf+bnf1zW1zpjfUANWOnQwpgRmhszQq0UqDVbV5W9b+c3TWT8Nlpd0knj/px+T6+9/ntk/Vf/4adrtT2vvExuu/FSPXe5TfwSBAAEiyYIAAgWTRAAECyaIAAgWDRBAECwSIe+gNFUp/EW+vX5m9/7Y5fKbbOpniV56Js6jfjsI8/K+pbJBllvam1STxK+8W16junH3vtfZP0f/ewbZf36N1wp6089oOdsbt5xiaw30TXGWu7Zos9XbKyS/oXf/UtZ97leEf3Nb79W1jcM9CzMJipjtmclZ0Y6V5W6XhY6IVtaK5xX+ntxbuy/iY1btsj6U392RNb/9Pf/XNb3/vufl/XfeMc9sv7Nhx6V9Uuv0TN6m4gTfb4q47zH1nUy06HG64o/RNbGDZXeSAjn+rPwuuuvlvWvf/FJWT959Hyt9sufeqfc9ssPflnW28QvQQBAsGiCAIBg0QQBAMGiCQIAgkUTBAAEi3ToC1hb0UmpI8/VE07dTj0x6pxzV75ep+JmNw9lfXVJpxGtpF9Tx4+crNVeeZ1OeN341tfI+mf/o07u/eQv3CDrz8/pOY15C+9plOtr1E30sMrXve0Vsl4aycunHtbJ1ke/rmdYbrxEr8DdRJLpmapVqvddGPfpal6fE+ucc8Ypc9O17bKeZetPJq+mer7pja+/Xtb/8D/rZOCmTfpYfvydb5b1+z//oKyvFfo5a8KaHWqM/HRRbMwCNe4976wXUDvXmzYVJfqe6cc9Wc9H+oUf/otvyfpP/Ms31WpHl/Qzdubo+q/RC+GXIAAgWDRBAECwaIIAgGDRBAEAwSIY8wKyqf6eMM3qY62ei1fktrMD/Q/N1VCPxoqNxTHjqp3LtWmwWKt96+s6PPDmn36VrP/l5x6W9ScfOiHrs329OGZqJTQaSMf6fJ04qRcBjbxeVPfyG3TgYrBBX7/JRAdvllfWv1irz42xW3pylatKPaqtLLbKelbo91QYAZg8H+gXbmDq9P0+M6ff1I/8aD1A4Zxz3/ziU7J+xWt1iGLj5k2yXlihkwas8Xbe6etnjTZrvCBuVd+/tQBvY7kxss84XUun9Ofe/GYdFNxxZX3O4dOP6pDZ4mCjftEW8UsQABAsmiAAIFg0QQBAsGiCAIBg0QQBAMHylRX5cc55b6yuCADAS0RVGasWO34JAgACRhMEAASLJggACBZNEAAQLJogACBYNEEAQLBoggCAYNEEAQDBogkCAIJFEwQABIsmCAAIVqsry79/3z5Zzwq9yrLS7ehDGo30qtGTsd735q3bZf1jH7vtoo/FOefed8t7ZL3f79ZqPtKjVgtrAqsxzi4Sq0Y759xkPJH1++79tPEC2r79e+uvWerznhd6lelOpLcvSn3sPjFW1Da+ht155x36D8L+W98v63mm75nBXH1la+ecWz63LOvDWL/XSa4v7LCv39Ttdx2UdWX/vg/Iemmcr9y4ZzqRrlelPvbIGrFo3MN3HTyg/yC8+92/KOtJt/4sOedcL+npelfX8yyX9fF0LOuFOGcfv+8TclvL3lv0Z15ifBbYq79b10m/pzKKazVr13fceY/xmtr79tY/H5xzrtutv6ZzzkWFfs6iSt+spbiJK+N85cY+7j5wp6y/GPwSBAAEiyYIAAgWTRAAECyaIAAgWDRBAECwWk2HOmMhei+iZWWlU4dRpPtyPk1l/dyxNVlfPXvxidQLiZOOrPdn6gnDbkenp3yi673uQG9f6fM4meh0aGNV/XhUYss552IjvlkaqS3re1WR65Rbp2Mu+HzxjPPljWO3kqrDmaGsrxxfkfXZjQuyHvf0vd3ESqrvdxfr8zg7r++xQddI8U709sVUH3uuA4CNxElf1jsdnfaMjVRuYjyTsdf1yHj+ciMh24T1FEzH+vpVxr066Ov32jWuXy4+U72REG4qGep3NTNrHGOl073Zmt7P2kr9c6w0UuWlkRptE78EAQDBogkCAIJFEwQABIsmCAAIFk0QABCsVtOhcUens3xST5wVxkDNuUWdIIuMfS+dncr66pKeF9hUZRxnKtJfZa5Th0lXH3uZ6ySeEbJ1lZGgaioWcz/LQh97lhqvaRxkp2OkTMWsQ+f0/MamysxIYxoJ1mmu75lN2zbI+hN/9bSsX7Nho6xHXSPZ2UBvqM/v4rZZWd9uHHu+ovdz7Kklvf2qjoFm1vDQBlRK/O/o61cYM4cLHZB1hfGH0ul72whqNpIa997amr4HrNm6qfFZsGGDTiy7uP6erIRlU4tzOq077Ok0+5lndEL/2ceO6hfo1o9zfqt+n1H3O/87jV+CAIBg0QQBAMGiCQIAgkUTBAAEiyYIAAhWq+lQbyxt3BWrsGepjmZ1jRl6g1m9GvjSGZ0CzacjWW/KmlOo5lJaQcc81cmv0hvpUCtFZ6363ZAX81mXllbltulYpwU7Rlq3N9D1wayeL9hG4tXahzV7clrodOju63bL+hc++RVZH+3S52zPK+dkvYnFTfp8bd2kU6DT4/o6Pfxn35b1o8+dk/WdV2+S9cFmI6XYQJQYyWGjXhZGatQZyUvrATTug9JInzaRxDr13O3p58BKxftYn4PMOAexV6/bzudDvKqP8dkHT8j6Q1/V6eky0fu5/q2X12qbd+s5vJmV/G4RvwQBAMGiCQIAgkUTBAAEiyYIAAgWTRAAEKxW06GTqU7d9ZL6LLrYWu05M5awjozVwOf1W+jPt5OUSif6eCoxa9NKdRZGwssb8zcTY+XztmaHViKVWhT6faapTt96b6wUbyTucmOuatXCytGV169pnS/rmg436QRyZKQLTx4+K+tXd/VM0Sa6uZ7fePhBner8xpeekvUjT+lE3/VvebWs77lhu6xPK2NgZwNWkjISaWXn7G/oiXE9KuMezq2Zoi08TomRbJ2Z0devNBLe1j3sjQS5CoJWLaXHjx7Ws0CPPHde1hcuXZT16374Slm/9Lr683HutDHL9pzuKW3ilyAAIFg0QQBAsGiCAIBg0QQBAMFqNRiTTfQ/7mb5pFbr94xFVnv6kIpCj0qKjRDJcF6PnWqqKi5+MdjS+Ad4K4hhTTnqdvU58GIhzRej163vZ8t2vVhrNtHjn4wsgxlycMYIpaJc/1gka8FeX+rXjIwAwfIp/Y/z2y/Xo8TcVO8/n6w/7HP8qTOyfsIIJyR9/Z5+6J/eKOvX/GB9dJVzzi0t69ddPrn+gIK1cKwVuelYQZrYGGUYG9cj1cc+zdefjCmMMFxkfC5Z96oZajHuYSf2Uxoj2ZpKZvQxXnbDVlnfuEt/duy4XI8PHImRlqdPLMtts5X1B7JeCL8EAQDBogkCAIJFEwQABIsmCAAIFk0QABCsVtOhva5OZGZ5PeEzWdOJycxYjLLTNxav7Oi3YC3O21Sa6nRSJhJnlXifzjk3NdKhhTG3KTJGylmLFjeVjupJ266xeHB32Jd1K9WZGwnAqjJSdGJx4qa8kSK0xtj1Yn2fHjNGjG3YqVNua2frqWfnnFs5pUfNNVEZSeBLr98l63Ob9ci37oI+v6fHOgl7+pQemZXr9YMbKUvjWhvJyNxKRhoL0CZdI8ls3KveGGfYhK/0PiJjgV9roWDrXq2s9HRZP2dRCyMInXPODXS529P7L71O3z5/+JSsnz1Xfz6WT+l99Fv6zLsQfgkCAIJFEwQABIsmCAAIFk0QABAsmiAAIFjeSu0555y3Vn0FAOAlorrAisP8EgQABIsmCAAIFk0QABAsmiAAIFg0QQBAsGiCAIBg0QQBAMGiCQIAgkUTBAAEiyYIAAgWTRAAEKwLzg4FAODljF+CAIBg0QQBAMGiCQIAgkUTBAAEiyYIAAgWTRAAEKz/C1Vz9gc0creuAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 8))\n",
    "show(torchvision.utils.make_grid(\n",
    "    torchvision.models.resnet18(pretrained=True).conv1.weight.data,\n",
    "    normalize=True,\n",
    "    nrow=8,\n",
    "))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ncHkdY3df6R7"
   },
   "source": [
    "**Question :** Implement your own version of forward pass of nn.Conv2d in numpy **without** using any of pre-defined convolutional functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv_forward_naive(x, w, b, conv_param):\n",
    "    \"\"\"\n",
    "    A naive Python implementation of a convolutional layer.\n",
    "    The input consists of N data points, each with C channels, height H and\n",
    "    width W. We convolve each input with F different filters, where each filter\n",
    "    spans all C channels and has height HH and width WW.\n",
    "    Input:\n",
    "    - x: Input data of shape (N, C, H, W)\n",
    "    - w: Filter weights of shape (F, C, HH, WW)\n",
    "    - b: Biases, of shape (F,)\n",
    "    - conv_param: A dictionary with the following keys:\n",
    "      - 'stride': The number of pixels between adjacent receptive fields in the\n",
    "        horizontal and vertical directions.\n",
    "      - 'pad': The number of pixels that will be used to zero-pad the input. \n",
    "        \n",
    "    During padding, 'pad' zeros should be placed symmetrically (i.e equally on both sides)\n",
    "    along the height and width axes of the input. Be careful not to modfiy the original\n",
    "    input x directly.\n",
    "    Returns an array.\n",
    "    - out: Output data, of shape (N, F, H', W') where H' and W' are given by\n",
    "      H' = 1 + (H + 2 * pad - HH) / stride\n",
    "      W' = 1 + (W + 2 * pad - WW) / stride\n",
    "    \"\"\"\n",
    "    \n",
    "    N, C, H, W = x.shape\n",
    "    num_filters, _, filter_height, filter_width = w.shape\n",
    "    stride, pad = conv_param['stride'], conv_param['pad']\n",
    "    H1 = 1 + int((H + 2 * pad - filter_height) / stride)\n",
    "    W1 = 1 + int((W + 2 * pad - filter_width) / stride)\n",
    "    out = np.empty((N, num_filters, H1, W1))\n",
    "    # Check dimensions.\n",
    "    assert (W + 2 * pad - filter_width) % stride == 0, 'width does not work'\n",
    "    assert (H + 2 * pad - filter_height) % stride == 0, 'height does not work'\n",
    "\n",
    "    ###########################################################################\n",
    "    # TODO: Implement the convolutional forward pass (in numpy).              #\n",
    "    # Hint: you can use the function np.pad for padding.                      #\n",
    "    ###########################################################################\n",
    "    X = np.pad(x, ((0,0), (0,0), (pad,pad), (pad,pad)))\n",
    "    for n in range(N):\n",
    "        for filt in range(num_filters):\n",
    "            idx3=0\n",
    "            vertical_step=0\n",
    "            while vertical_step<=H+2*pad-filter_height:\n",
    "                idx4=0\n",
    "                horizontal_step=0\n",
    "                while horizontal_step<=W+2*pad-filter_width:\n",
    "                    out[n, filt, idx3, idx4]=np.multiply(w[filt], X[n, :, vertical_step:vertical_step+filter_height, horizontal_step:filter_width+horizontal_step]).sum()+b[filt]\n",
    "                    horizontal_step+=stride\n",
    "                    idx4+=1\n",
    "                vertical_step+=stride \n",
    "                idx3+=1\n",
    "    return out\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6dDNQP8VvVVj"
   },
   "source": [
    "You can test your implementation by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7Leww6XRuC_0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing conv_forward_naive\n",
      "difference:  -1.5956700752541409e-09\n"
     ]
    }
   ],
   "source": [
    "# Make convolution module.\n",
    "w_shape = (3, 3, 4, 4)\n",
    "w = np.linspace(-0.2, 0.3, num=np.prod(w_shape)).reshape(w_shape)\n",
    "b = np.linspace(-0.1, 0.2, num=3)\n",
    "\n",
    "# Compute output of module and compare against reference values.\n",
    "x_shape = (2, 3, 4, 4)\n",
    "x = np.linspace(-0.1, 0.5, num=np.prod(x_shape)).reshape(x_shape)\n",
    "out = conv_forward_naive(x, w, b, {'stride': 2, 'pad': 1})\n",
    "\n",
    "correct_out = np.array([[[[-0.08759809, -0.10987781],\n",
    "                           [-0.18387192, -0.2109216 ]],\n",
    "                          [[ 0.21027089,  0.21661097],\n",
    "                           [ 0.22847626,  0.23004637]],\n",
    "                          [[ 0.50813986,  0.54309974],\n",
    "                           [ 0.64082444,  0.67101435]]],\n",
    "                         [[[-0.98053589, -1.03143541],\n",
    "                           [-1.19128892, -1.24695841]],\n",
    "                          [[ 0.69108355,  0.66880383],\n",
    "                           [ 0.59480972,  0.56776003]],\n",
    "                          [[ 2.36270298,  2.36904306],\n",
    "                           [ 2.38090835,  2.38247847]]]])\n",
    "\n",
    "# Compare your output to ours; difference should be around e-8\n",
    "print('Testing conv_forward_naive')\n",
    "rel_error = ((out - correct_out) / (out + correct_out + 1e-6)).mean()\n",
    "print('difference: ', rel_error)\n",
    "assert abs(rel_error) < 1e-6, 'Something is wrong'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[[-0.08759809, -0.10987781],\n",
       "         [-0.18387192, -0.2109216 ]],\n",
       "\n",
       "        [[ 0.21027089,  0.21661097],\n",
       "         [ 0.22847626,  0.23004637]],\n",
       "\n",
       "        [[ 0.50813986,  0.54309974],\n",
       "         [ 0.64082444,  0.67101435]]],\n",
       "\n",
       "\n",
       "       [[[-0.98053589, -1.03143541],\n",
       "         [-1.19128892, -1.24695841]],\n",
       "\n",
       "        [[ 0.69108355,  0.66880383],\n",
       "         [ 0.59480972,  0.56776003]],\n",
       "\n",
       "        [[ 2.36270298,  2.36904306],\n",
       "         [ 2.38090835,  2.38247847]]]])"
      ]
     },
     "execution_count": 258,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "convnet_tutorial1.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}