Berthine_convnet_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mCt-frpFH8oN"
   },
   "source": [
    "##  **BERTHINE NYUNGA**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9xEQgglnWDvC"
   },
   "source": [
    "## **Convolution Neural Network Tutorial**\n",
    "The  tutorials use PyTorch to build CNN "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "N_4pJZPtbahT"
   },
   "source": [
    "Import libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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": 2,
   "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": 3,
   "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": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 388,
     "referenced_widgets": [
      "1d41d7f4fcf047aabdf5b264e414c8c1",
      "210ccbaebf244c2393e23e34f09d4102",
      "b4b440acf21843888a5928e048d527b3",
      "1bd0f825d61f484e97df8f6e282682f2",
      "bcb5b95d847146dfbf2290db072d2877",
      "01edb66027d1485bb30faa2c900ddd2f",
      "010025b45dc641d8a42f81bc2f3a6a13",
      "a882d748140a440fa3aae49e2036dbf6",
      "b158c97ceb7e40b8ac56f6bf753ddfe7",
      "4974d84e6e52424fb9ed1d3341792f0d",
      "8a9eb7aa9d0a4e41a31962cee369870e",
      "42ed50f42ff5495eabb25b6ff76dd694",
      "e793c316ebf0498fb49da4c2622aa783",
      "cc6959e6cbe74c48aaa69c97b72a572a",
      "8a87a7c0b4ba42d68b89067e63a4072d",
      "fb67b7cf56e74aeda09ddc56b4b1292d",
      "6e5376fb32ab4156bc2c8ba10e3f100d",
      "b3553d409b6c4fc6aa950c6c9b0e2e00",
      "3c0724a8db6c438ebc4d3e97f2cce581",
      "47e03014168e456da856d3c01dea0191",
      "33948d928244442b861d476aef5e3ed3",
      "b7894871373943338c68a0929324da45",
      "adb8301e95b9455b94237ad0a2ef4586",
      "7ce6a3aae3a7427aa66aab3ba1d8acb4",
      "955625669ff14f73aef9b9afd76b104d",
      "659de0a24dfe4a8bb27e26d70764a0f9",
      "d76a43fc904344b88b66746dcda1effb",
      "938735cc3cb844c794d883459a74817d",
      "2b97d01025874200b10576347fe9d453",
      "7483c34f774a4e7d951a4df7825fd2b5",
      "58eea398145b4c6981656413b92d5457",
      "469f338fb06d4b23a19c483c672b9df2"
     ]
    },
    "colab_type": "code",
    "id": "GX_ky5qC--uv",
    "outputId": "86559c7b-316f-4f88-904e-0863f3f4e6b8"
   },
   "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"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "12d4c6b923c044bb9083123c311cc14a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=1, bar_style='info', max=1), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b1480ae3281b4e3e900d93dca2bf22ad",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=1, bar_style='info', max=1), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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",
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f7efc1216d5b43d9a30819bbe6d53f31",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=1, bar_style='info', max=1), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e1eb6b927b1048bd9c8ad070aacf2ae0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=1, bar_style='info', max=1), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 62
    },
    "colab_type": "code",
    "id": "E8dy7-kBHwco",
    "outputId": "22e29f50-a9bf-4229-a503-b21d114b2882"
   },
   "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 0x7F5E679AD610>"
      ]
     },
     "execution_count": 5,
     "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": 6,
   "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 = 64\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": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "eFtFvYF3GVRz",
    "outputId": "b6b4926e-5996-4de2-ec13-62a900b19f1e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([64, 1, 28, 28])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(iter(train_loader))[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zEw5YorSYkWF"
   },
   "outputs": [],
   "source": [
    "class LogisticRegression(nn.Module):\n",
    "    \"\"\"Linear logistic regression model.\"\"\"\n",
    "    def __init__(self, input_size, num_classes):\n",
    "        super(LogisticRegression, self).__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 = x.view(batch_size, -1)\n",
    "        output = self.linear(x)\n",
    "        return output\n",
    "\n"
   ]
  },
  {
   "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": 26,
   "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": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 191
    },
    "colab_type": "code",
    "id": "kC3z31pvadeP",
    "outputId": "753db613-8e2f-42d9-ea50-40c528c7a62e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 0 [0/60000 (0%)]\tLoss: 2.307891\n",
      "Train Epoch: 0 [32000/60000 (53%)]\tLoss: 0.905872\n",
      "Train Epoch: 1 [0/60000 (0%)]\tLoss: 0.651954\n",
      "Train Epoch: 1 [32000/60000 (53%)]\tLoss: 0.553812\n",
      "Train Epoch: 2 [0/60000 (0%)]\tLoss: 0.515317\n",
      "Train Epoch: 2 [32000/60000 (53%)]\tLoss: 0.476886\n",
      "Train Epoch: 3 [0/60000 (0%)]\tLoss: 0.443619\n",
      "Train Epoch: 3 [32000/60000 (53%)]\tLoss: 0.428509\n",
      "Train Epoch: 4 [0/60000 (0%)]\tLoss: 0.432549\n",
      "Train Epoch: 4 [32000/60000 (53%)]\tLoss: 0.411057\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.01)\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": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 167
    },
    "colab_type": "code",
    "id": "gxletH44a4MX",
    "outputId": "314462d0-bd6a-42c2-ece4-26651663aab8"
   },
   "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": 30,
   "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": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "MrEY_dy5AKQV",
    "outputId": "bcbe3786-82a4-4b4d-d2c1-48a1639bbb33"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 9007/10000 (90%)\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": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "Dj4X2PnOfK9W",
    "outputId": "81eafd44-534c-41ca-c879-66b7cf9ea560"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(nan) tensor(1.)\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",
    "  # Softmax has two problems : underflow and overflow respectly when the value is small or the value is big. That why to avoid it, we need to do some calculation\n",
    "  logits = logits-torch.max(logits) # to normalize the logits to get the number  less 1\n",
    "  probs = 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": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "colab_type": "code",
    "id": "HeGkxU8mlIPb",
    "outputId": "41389c7c-1257-43b5-b555-c2987a0776b3"
   },
   "source": [
    "logits-torch.max(logits)"
   ]
  },
  {
   "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": 34,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 238
    },
    "colab_type": "code",
    "id": "gDHLyTmlD_WC",
    "outputId": "adcda2f0-435d-46a5-e27c-56bd00317bba"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWUAAADdCAYAAABja2MXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOy9eZwlR3Xn+z0Rudy19urqrt6lbrUkJCQECCSweRiwjfGCN4yNwZiHdxuMGY/3MePt+c0zMON9GdsYBNgY2zMem80bqywwoAWhXa3eq7r2qrvmEnHeH3GrutSoW6IbkLDr9/ncrnszIyMjTmb+4sTvnMgWVWULW9jCFrbwxIB5vBuwhS1sYQtbOIMtUt7CFrawhScQtkh5C1vYwhaeQNgi5S1sYQtbeAJhi5S3sIUtbOEJhC1S3sIWtrCFJxC+aKQsIj8rIv/zC132MdSlInLgHPveKyLf84U4zxYuHiLyFhH5lce7HU8EiMgHReTVj3c7/j1BRD4qIq98ArTj1SLywcda/jGRsoi8UkQ+IyJdEZkVkd8TkZHzHaOqv6aqj+km+3zKXgxU9YWq+mdf7PN8KSEiLxWRj4tIR0TmBt9/WETk8W7bvyeIyBERef5Z214pIh89R/k3iEghIu1Nn5UvTWufGBCRm0TkT8/a9hwRWRSRHY9Xu57oeFRSFpHXA/8v8JPAMPBMYC/wDyKSnOOY6AvZyC08MgbX5n8A/x+wHZgCfhB4FvA510ZE7Je0gVv4C1VtbPqc15H5d4jXAi8UkRcAiEgF+CPg9ao684U80Rfz3v5S89l5SVlEhoD/CvyYqr5PVQtVPQK8BNgHfPeg3BtE5N2DkXENeOVg202b6nqFiBwdjJK/sNnz2FxWRPYNJIjvEZFjIrIgIj+3qZ7rReRfRWRFRGZE5LfPNTg8Qn82pogDL+djIvLmQV2HReTGwfbjA6/zezYd+yIRuVVE1gb733BW3efrnxGRnxaRBwf73yUiY4+lzefpyzDwS8APq+q7VbWlAbeq6stUNRvIA78nIu8RkQ7w3PP1Q0T+XkR+7Kzz3CEi3ywBbx7YZW0wc7pqUKYqIm8c9H9VwrSxOtj3l4PZ1aqIfFhEnnSePn29iNw2uB43i8iTL8ZGT2SIyAtE5J6BXX4bkE377MCeCyLykIj86OCZiAb7h0Xkjwf3/0kR+ZV1UhKRAyLyoUG9CyLyF49TF1HVReDHgD8UkTrwi8CDqvqWQVsrIvKbm/rxpvVnWc6a8otINLDBvsHvm0Tkd0TkfYN7+yvO1xYRmRaRO0XkdYPfIyLyp4NznxCRXxIRs+ncHx60bQn4+cG2D53FF1+9qf5z1vf54tEOuhGoAH+9eaOqtoH3AC/YtPmbgHcDI8DbzzLIlcDvAi8DdhA87p2Pcu5nA4eA5wH/RUSuGGx3wOuACeCGwf4ffpS6zoVnAHcA48A7gD8Hng4cIAw4vy0ijUHZDvCKQf9eBPyQiLz4Mfbvx4AXA88BpoFl4HcusM3ruAFIgf/9KOW+C/hVoAl89Hz9AP6MwUALICLXDPrx98BXA18JXEbo30uAxUHR3wCeSrhfxoD/DPjBvvcCB4FtwKc5697YdK6nAH8C/ADhevwB8Lcikj5K/77sICIThGfq5wn38YOE2c06vg94IXAtcB3h3tmMtwAl4T59CuHarMt/vwx8ABgFdgG/9cXow2OFqv4l4bq/E/j+wWcd/wV4GvBkQj+eBfzM51H9dxGcxibwr+cqJCKXAh8G3qyqbx5sfhvQAy4l3LsvAr5302E3AncDkwSlYH3bZwj355uBP95U/tHqe+xQ1XN+CA/o7Dn2/TrwD4PvbwA+fNb+NwA3Db7/F+Cdm/bVgBx4/iOU3QcosGtT+U8ALz1HO34c+JtNvxU4cI6yHwRePfj+SuD+TfuuHhw7tWnbInDtOer674SL/Fj6dzfwvE37dwAFEJ3P/p/vtQFuBlYIN8dXEh7etz5KPZv7USEMGAcHv38D+N3B968C7iPIV2bT8WZwvmseQ5tHBjYeHvx+C/Arg++/B/zyWeXvBZ5zoTb6Qn6AI0B7YN/1Txf46DnKv2FwD2wu/y+Dfa8AbtlUVoATm+7NfwZ+YNP+5w/sFhEkqgyobtr/nZvqfivwh5ufn8f7M2hzG3jtWduPAl+96feLgAcG318NfHDTvmhgg32D3zcBf/Io5/3o4B4+Crxk0/adg3s23bTt5Zzhs1cDh8+q69XAPZt+Dw3aM/EY6/vg+dq6+fNonvICMCGPrKnsGOxfx/Hz1DO9eb+qdjnjZZ0Ls5u+d4EGgIhcJiJ/N5gSrwG/RjDMheD0pu+9QdvO3rZ+3meIyL+IyLyIrBK02/XzPlr/9gJ/M5j2rBBI2hFu1gvFImddG1W9UYNuuciZWdDDrsv5+qGqfeAvgO8eTL2+k+ABoKr/DPw2wcOfE5E/lCBvTRDI/MGzGziYhv+6BNlmjUBs8MjXay/w+nUbDey0m2DbJwperKoj6x8GMzQReZmcCea9d1P5d20ur6rPHWw/+35RHn6dps/6vfn7XiAGZjbZ6Q8IMxEIsxQBPiEinxWRV118ty8Og2dqAfjsWbumCYS5jqM8+gx6M87HOet4+aDezbP9vYRZ5ulNNvwdHv48PlLdZ3MSBH54LPU9ZjwaKf8rYVT+ls0bB1P6FwL/tGnz+V43N0OYSq0fXyVMAS4EvwfcQ/DmhoCfZZMe90XEO4C/BXar6jDw+5vO+2j9Ow688KwHtKKqJy+iPevX5psepdzZ1+V8/YAgYbyMIAt1VXVjWqiqv6mqTwWuJMgYP0l42PqEadvZ+K5B+55PkDz2DbY/0vU6DvzqWTaqqeo7H6V/jztU9e16Jpj3wsdwyAxhwAFARGTzb866n87ad5xw3Sc22WlIVZ80aMusqn6fqk4TpKDflXOkiD4BcIpAaOvYA6w/Ex3CjHMd2x/h+MfyistfANaAm+RMMPA4gVTHzrLh5hjG5/P6zMdS32PGeUlZVVcJms1vicjXikg8ENrfRZhuve0xnufdwDdICKQlhKndhRJpk2DktohcDvzQBdZzIeddUtW+iFxPIJx1PFr/fh/4VRHZCyAikyLyaGR6XqjqCuHa/K6IfJuINCUEFK8F6hfYDwYk7IE3sun6isjTB152THhg+oBXVU/Qgt80CKZYEblhoAU3CQSySHjAfu087foj4AcH5xARqUsISjY/L8N8eeDvgSeJyLcMZjqv4eGk8y7gtSKyU0Lq6U+t79CQtfAB4I0iMjS45peKyHMAROTbRWSd0JcJ5OJ5YuKdhHjRhIhMEgh0PTngduDJInL1wMn5xQs8Rw58K0Fj/1MRMap6HPgQ8BubbHhARL7yQk7wha7vUaODqvrfCN7obxDI8OOEkeF5qpo9xkZ/lhDs+nOCF9AG5ggP7OeL/0QgkhbhQf5SRZd/GPglEWkRNOR3re94DP37HwTv9AOD428hBBkvCoNr8xOEKevpwecPCA/xzZ9vPzbhrQSN/aZN24YI9l4mTAcXCal4EK7JZ4B/A5YIgREzqOcowfu5i9Dvc/Xlk4QA128PzvEAQff/csZ3yMPzlNsisk1VF4BvJ8RlFgmB0I9tOu6PCMR7B3ArIaheEiQvCJp0QrDpMsEpWM/7fTrwcRFpE+6516rq4S9mJy8C/5VAvncS+vpx4P8BUNW7CIP4BwmxhQ9f6EkGPPViwuzjjwYzk+8mOC/rNvxLHtkbf6z4gtUnAyH6S4qB/LFCkCAe+pI34IuML/f+icgrgO9X1Wc/3m3ZAojIC4HfV9W9j1p4C1/2+JK9+0JEvkFEahLyFX+D4Fkd+VKd/4uNfy/9E5EawZv+w8e7Lf9RISHv++sk5ObuJEzd/+bxbtcWvjT4Ur6Q6JsIwv4pwnTtpfp4uOlfPHzZ909EvgaYJ8gg73icm/MfGUKY2i8T5Iu7CVLTFv4D4HGRL7awhS1sYQuPjK1Xd25hC1vYwhMIF/WiDWtFZdPLyGwcU+CoiOGqXsyu2ggnnrub6sg4H373+0hdRIbHGCUVg8SCy0vKJKGSFXQjw1Q/5X8993V844O/xfTYDp7yjGv533/3HnorXaI0xaknImJ4zzY6J09jhxusLC6RJhGTywVvuOYFvHPu48xP1vn07AxDpESlpVxoocNVRnKHbmsyd2IBMzyEW2pBKkTWEscRRV5Q5AWRjTBO8anFCfh2ho0inCrWWpIkolv0sdZixZBlOXElBhSjln6nTxLF9Pv5BedQvyB66cOmMaaSokWJJDHSqMPEKGuXj5ANGcZv+hQYCfutReIIiSJ8liFRBG4QuI9jjrz+avbfNEOxc4TZ66vs+csT6NIKVCuhnLW4vVNEx+fRkSbMLiCVFC0KZr/tMiZv6+AqEek9JyFNwCt+fgEZHkJE0LFh9PAxzMgwbnE5tDeOIE0hy/C9PpIk4BySxAD4dgeJIlQViSKkWkG7vdB2I/hOD1OvbtjCra5h0pT3d992Qfbd/5tv1I1M1MFf8aAW0iWDycFHUDYVlypqBvvNmbIAUobTq1XSZUPcDvUlq0o+InSmFeNABcphR7RqQYM+IUWo3/SF5OAaxf1DSAnFkAcLKoo4CecQsF3BVcLBm9uy3gfRh/9GwMe60UZRkELAgBoFFXwldMT0TSigglpFFA6/7vUXZNsDf/ErqnrmUAXUCcYqcqyKjxTxQjmZY1OHMR71oTPGetSHY11pNhJL7bEKZV1JVoV0WehOKX5XH9+3YKA23KO7WBsYVsEJplaiSym7Lj/NqYURdD7Fbu+CCsZ6vAvn9Cq4boQkHjGKCIjougnxXlinOfVhowih3Srh9lHBZRaxoQ5VwUSeOHZkvXij3nUbH/7Onz2nbS+KlEUEay3ehwtbeKWag9ld4/6oy9rOgnp3hU984jYio4j3pBj2Rgkn65D3c7wRpOijAqM4Ln/VM3iF+XOm6pdw+z/fynx7gaQaM3bNDbjTxzGakY41mfvo/Rz44a9n6Y6jdNodRiZHqV43xg/17qDWW6Pb6nNFbYyZ2RamnkJs6be7XLJtPye7S9zQ2M4HdYHRZg1JLK4oMWLQsgAnJDaiiKGvBWmnRAUwJd5AZGN6/Zx6o06328WVBUYE64VuP8dSEscxRV5cjHkBMEmMOg/q0aIE9ZiJMTCGbLJO1PUMffgwak0gtDjCjo2CKtrtAaBliYggScLcdzyJ4Qc8rau30Xj/Z9i9sButVWhfczmV+QwU8tGE2s33cfLlT2LkgYL6Sgs3PU5vus7EHV2i4wvYWgW3YwJzfBZp1JEkQVfX8FcfxKx04MA+9ORpzNgIEsdoUSDG4IsSvCLWgIRBRPMCxIAxiPdIHOFbbczIMLq6hpZl2E8gb8Rg0hSfXUhG5eDeLdl44FVAI6V6ymIKcCn0t3mGDi6jKqweGRkcI6RrQj7sQQXRQHoIpPOG/naHPrlLfy1FuhaNFdsx2H2dQDCrKSj4RGEyg/k0EG1VKe4bothWQGEg8kjPEnUtru4DAQuUOzOiUym2JxTDHpsJPtIz/TChT2oGxF2cIfT1gcdXFLXhI4VBnIAHX/OYnqBxKHgxoqb36yOXIoCRQMahLYpL4MB1x3BqOLYwinqhzCzSifAjOSioCjbygRyP1SjGHFN7lkis49TicDCIh+07l3HekBUR2NDqpJFT5hbfiqFecuKBbdSnW5h9fXr9QJB5NyGuFpSFRQSaEx1as03Ug9RL1Fls6gIxbyJpGweuc6XFe4OsD2QKtlJiRIliR1kGG5SFpVrP6LVTbOIek20vipSTJMF7jzEG7z1SFhz8+htZ6qzw/Gc8g5sfvAPXLRnfMc70+G5u/8StRA72DY/RzpZZiQxxFNMWT5x7bvzRb+eeB29j4vYTrHYrfOXTn8nS4mm6mrFy5yfIbA27VvC8dsoV33QV0/cc4957TtK49iD33/0Auhbj7phh1RviTkZ9epJua47tE2NIltHOSk4uzXP9NU/izgfvY79U6QErZY/YxqBKVuREJqJT9BFrqMYRu+pNmIpY7bUoE4MvLFnb015tDS6YIKpk3Yx44O0555CLfKWxqdegKMAIONCyoPvN15OslJz6ipSxuxy2UPyubfR27qf2L2EVq9s5gZ1dhjjCpCmUJQBHf/AKRu9zNI51Me0+7RdcRWUuwxSO5mfmUCNIp4er7mTuW68k6iqVhT6t6/fQvH2WpJYQ3fkQ3jlYa6FX7MMtrWCnJpAsR8sSe2Ke1WftZegzi8joMBQl2ht4vKpoloG1+E4PsQappJixUfxYE7PWRSOLFCXGWvziUjDEgJDdWjsMUqoPI+oLhRrOeMml4J7awsQl3fkGUb0g+YtRfCw0h4XOruCK9rd7JBM08eCEqBfIwWagqcfc2qRRQGfvYGaikJ2qo4mncjoCDQnHZSdGxgrKTgTNAj2VIn2LZILJLVFXyCYc8bKhbAxIdjnBFNDfkxMtxpQNj+kH4vWJbpwPlTDoQPC0XZgB6IC0TN+E74awrERA8lCHOLk4RgZUwZhNExEVdj/jJJF4ji+PsGe4xem/2otPwG9X/HQfckM03sd7Q5SUeGcoswjtWSpdoXaoxeKdk+Chctka3gv9dspyq0YcO/r3DxN7KCYLvDM0mn36AxLMiwpFYSmLCLcWh4Fyuk++lmLrBUaUfi9BSmF49yorc03iZoYrLL40RANyNhK8XedMGFwHHrR6wcZhAHGlwatseP8KFHlENGiL10fnhIsi5bIsMZuIR+OY+/7+k/Sa8I8PLNGue8xyl9Zcm5OVGcb37qQ9N8/HozadvM9wkpL5nBte/hXsGR3myMc/wpC3HDdwqDbKvz5wH6mBukBvLmLHkyeoXxFzl1tj7UN3cdW2fXywXGXPzDw+bdEuE0Z3jTFix2nNn6a+fYjyqMXlGfVGQv3ANmYfOEnPKvvjOhN5xFuHl6i5FJeX1GoNsEKZFzhviK3BVyJmfEZ8uqSPZ2T3CD7yLM+1qUQpZVlgxeC8C9NHL3jnghTiLs5T1n4WPMoBJIqp/+2nkDRl/4ntEFlkrUN5apbqXRFyYB/MzmMW1tBON0gcRcHJ77yC/oQycYfDOMV0c8qxOs1Pn4LIonGEn1+kvPYA2fgkJlem/ukkvQOT2ONzVO0UGIPtFeieaXwjIZpdobutSjWOIC/QoQbuku3IfWGVbDlWR62QnFqBdAiyAm3WsNYGYi5LiBMkTaAskZNzqPPo3h2Ql/iTs8H7znPEmkDCEMqUBaZaRXu9C7atj8GUgazWiak4Vsd3BVNXZDFi4TrFp56oZcAoasG2DeLBtAyuqkgB4oXOfodpW7p7C/BCOm8pq5CsCNmEJ52N6E+VUHVUH0hJ1iJcxQZi6iW4usd0DRorvqJkNY+UwSM2mcEnYepe1hW7EuFTDR5uGgYLyQWTB09XSsEUA49cFI3C96htKMYcBhOIetDv9Xm6ONnwyi8G1nqcM1gbpvcAR2bH8a2YaDjn6MkJ9JqCuJlTrqYYAVMrKboxKLi1OHirhSFetcRPWWbtdIN4Twdrlc58DWLFrEWUsSdbrCLbcmpDffzhJizE9FyVcjpHC4PUS7JWSnW4T9YEF0VYFSojfbJOQlTLyRaqEHtW5hvYeoEIRImjHIxRrh9B6vCFoJnFVMvgPTshqRZknYRqM8zcvDfoJi8awsC0IYPI+Ue9iyPl0Zh6J6Hrukzt2UFDhYdcB/El2luhtm8nxZ4acr9yYHySrslJR6epRBXKo212u4T7rOOut/0Lzzr4bG7LEu5fPEkinrsuLZnsNjhx23FULP2RhFNLc0z0qxTLS/zMyLXIwWm6O6u0e55t5WV0TiySUdL2p9Eh4bOH7+XyHE5qj7hU3GcepDJa5/8c/Qw7nKGoWp5U1ulrwcpYxEqvSyXLKKuGkeoIndUO0vVEsUUaBnqGmSNzDDWaRNZSaomJBPU+3PyA+kAezilwce/dNsPNQF79DDl0KWoFs9qB0kEvI983id/epGINxa7xQFgje/CJIT2saKOGrLTY+ZeHWXjBfqqnc5JjC2AMbqqB7psk+tS9SJpi6jXi2VVsr4ZdarN04zSt3YaRkX1EXY+rjpGcWAFVbFGi9SqNO2fRRh0ZyDTRZ+eRkWGGbzkBcYRGFj9Ug9LjmzVMq4vmRZAzxkdhaRXt95E0Reo1tNOFew4j42NBg/Z+Q2dehzoHYoKUcxGesu0PvMtw6QKhAfmkI16y2Ewo6x41QU/2laD9uqpHB15p/UhE0VQ41CI63KAYL6kejelPerKdBdK19KchahmkBNux+FIwJbintRCgPF1DI8X0TdB88wELiFBZELo7PFFXKIF81IMXMIoUgs0N5ZBDMoNGimSCtyBo0KozQaPAC+mCJR/1wRNmINnYMDCt/2aw7WJR9GJspcSroF7Q0qB9S2WiR3+xiu0YdFuGqiBOiJOSbKWCrZdEcYkxir+rST6sJJet0TrVpLqti7u7STbqSSZ7QS5oZqG+rsEZpbNSpbpiGHv2LE6FpbU66UhBa7mGxJ5+J0H7Fqk47OEK+f4+2rXkJsYMFUGXN0H/zrsJ1ZE+ZWGDxu1kQw9OhwOZm9iT1gqymRpmNA8kTJA6xPgNGUcAMR77GGfOF0XKo1FCy/Qxuxq8fK3O2mSNf0hTllttonFHpmtkd60xPDLOsc4yo0M18pVlRroVmi6h9vRLuObUAgsnV3jb5GncZ49yaGqKBx+apXffLJ04ZqjwbJ8aJ683SCPHQwsnOHjd5fzq7bczNTPHQtbFne6T7txOr79KPakz187YcWg7u7btYGd/gdU0I9q/g2pXmbvjAb6muYvJHZP828xhjsgakoBdFQ4OjzNTdok7OZpCUZTUqg26ZQ8WO0FTEiFb6xAjeBUKV9IcGaLX7xPHEWW/j7UR3nvyrLwY8waiWl5Fdu2gv7NJWTNU5itEy11cI0W8UnlwDj/SIJpbw403iJa7qAn67MrVo1TnG6QnVqkulsRzLbL9kyR3n6ByeB6NLCoCOyZxaYzGhuj4PK1n7GHslllqp8eJWjnRQot8egTp9tFqCovLFFfsoXvlCM3DbUw3p79zCPHbSG89jD+wi+7OKo27lzCLa4GgjVBODhGtrKH9Eho1KHKk0UD7fXSxEzRxEfzK6nokBc1z7OQEvt3BVCpot4vEURiAOt1HN+I54KoeUwSS3f4Rw8I1UJ0TssJS7u9D5NCVCuIE1/DgAnHjheS0UAwpnb0lI9NrdD8zSjHhaNwX09nrgqabGUwm2L6QTzhULDYHmxu6uxy6Fl4TbfuCqwXC10gxeZBEXEVpX5aHtmYxUVcorBC3DNn2Ao0kOPiZCV5xCsX2HLuQIC6YzyeKKQQB+tMlkpkgU6Q+DALuTLBQDchAcfmcIOLniaQeNN04LWm8v8HiswqSeUvRqdO4ZI2hap/5lQbGKHayiystkhlcZGE2xU/m6DbHZQdP8cAdu6jtaeFvH6a8rEeSlHgvlFlE0YtIRvvkWkH6Fkqlf7DPWj+lLC15N6aSFpAHuUa6lqhvcJkhuWqVspNCxaPdCE0d5IbaRBdVwSUuEHJpiCoFjck+rdUqqFAWETYJo3mRRyTbwzFZFpMkJXkWgzcYGQT8rMeVNgQFB9LO+XBRpNwrc1L1HNw5zcKEYdueKZr1Ua7Im9w6dw/dOw+DFeYW5khzoVhW2k65P2ozWW1wy0c+yb5KyolOwSW6l5Vmle5UFT3pmWgn7EiH+NRoyeJklfnTM3zz1zyPtQdKamrJxHJstsVUVOdk7Fi5/Qgj+3ZTWy256tnPxmrOwvxJ7jgwip5c4MTtRxhqDHHF3kPcLyt8tH0XvaZnskjp9XNKYOnwDPHkELXVjNNrLQA6nQ6VWkrfZ0FXsuCcwyAYG2ONJevniArihbxwGOdBwUQXNw/UfgZG6F42QdGwtHcaemMWl1QZOVxQvXsWrEFOzoEqUS9DsxxjDTo6xMj774XxEVhYwl05jm+kFM2INA76uTaqmGYDV0uwJ+Y59a2XMpFGeCugSnpsGT8UMh6iT9+HP7AH6Rcsfe1BUKjNl7haglntUrntCIwOU1y1D9svady1iJQOrVWQbh9RJTo8A2MDcl9eBcCvrmGGmvhWG7yClQ2pQqKQQaKdbtDn1aNZFgKDhCDohcL2DLUZoawZzPfMMvzuKZaudSE4NlPBixJ5waUaSE4D6YlAf0rRboRpFKw9NEJ8WRuZrVFe30IXq9iWxVc8GoGrKNGaRQ3kU4NAXuKJT8fBMy4FUwpSQP2oUJvz2Ezpj1mK4zErVyjlkMM5QQohmyqxbYsUEnTiWDe0YDsXZJB1jRgzyL7wgukZpAzyhumboCevpxcoRJ0wEGg0CGj1L5yV805C9aGEbNTjv2mJxkfHaV9aYBsl/V5Cp1UBL5jEBU/aCclUlyQpseNKt5+QNPs8cGqSHVfMMbfSoHrdMpEK7eUa1aE+ZV8gdeSdBKwyvG+FdqdCrZaxtlSHzCC5Yc3Vkb5l5B6huuBJVwt6ExHtYyP4y3NMxUHisJHD1JVeJw3Xtl6EjJfE4b2htVolrpQD3dgixm/oya60eCfY2FHk0UZWxjqyVoqtlhgTiLzMz0+7F0XKV+2epvn8a9n/4Gn+aeFO9h+e575RQ9qZZPboKeJWRNqsM9QtiJsRq/1VnDOYMTg122HIDXOkk3HZV+2md/IkWTdi8Y5ZRFNmVVnqLhHVK0jm+Y5v/Hr+6qZ3s//6vdz30TsZak7ywld9B+9881u4/qu/lp/9qldw/Td8BVmijCcJ3VipRTVa8y0ao02Of/Z+Zk6e5A//8u2sHruN8u4ltGKQ0WHc4hp0MmaHYsxKi3SoAX2POsUqSBamYmIErKEsMiIruKIMQSeXoap4W2JtgojivWN0bPRizEt+5S5OP7VC0lJG781IVww2cxS1iOpdM4GshhqgijQb6GorpLSNj6LHTgVN9sQMveddTW2mh+kVNO6YGWRm9JFuHyopUjiOf9el7Pyjz5DdcIihDz2Ajo1w/6u2cdl/P8zpF12Cvjjhj6/6M2LxTFvFoYyaKp/JCy6LhT9ePchHlg9w77u3M3pvQf3EPCQxfryJzQvo9UO63PwSDDfB2o0ApGZZII0F0VwAACAASURBVGQjEMdoux3anmWoV2RQjswOUuQM6hxm+7bzWO/8iHpCe5/H5MKpIxOY/6uPrsUIwWNFQxaDOAKBOTCrYRCIWiFjglYFn3ryboIphP58dSP9zPaCJ1oMO2pTHXqnGtjVCDUQLVgQqM0IUzevgoHVQ036Y4bFqy0uUcRD4xhMfFqorEB1povJSh586QjFiMO2bZBBIjCFBDnCAANdGA2yiausRzJDoG89ALgehVMbvpf19Q3heB9feLQvnovpX5qhmaHdTak/a4mGN7SXayEFLgoZDOolZCpgyXsxRR7h2zFSLclbCRjIygjvDd1uiohiYkevlUJmiUf6XDU9w52ndrD20AgymdE6NoSoMHaHMPXPpwDI94yRD8XkDUNvIjgdQ8c8Q0cttZmSaKWPr8Xc971VKhM9Mi/4whLXclxhBwOXbGRqAJTthLheBF4gyB6uDPvXU+Rk4CnHteBEiNHQ5+T8M+iLWtH3bU++Rt9f3M+OaoO1Y23kabsZfWiJ46tLfGdlF/9SLHOkV1BzBlNVtj99P089dBm33fFZXnmqydv2FswdO82StLEn+9hVyCOw1YSJyTHWugtU4yadVh+MEmeWGKVSqVDIEDe95fe59inXMjQ2BKLY9aDY5j6ZM0I7Aq50rC6u8KpX/t/cesftzK8uQMWSqqFdZuyzNRZsyffILrZT403yAAtln0oG3ikOsGrQ0oMN3psxhrwoEAsmSdHS471i1FAW2QW7y8/5uv+m1cNLuLE60fEFek+aJpnvYWcW6D9pF+mxZVhYBiNIpUL7ul0sXBUxeXtBNmyJu576kRbSL2BhKaSTAaZWQ3dOYVZaQY5YawfCdD7UVauCCNU/a/Ofd72XqwYPaCoR/qzQvBnkY3kUg5BpyR255cd/4UcY+/hp9PRCCOZZG4h5eAiKguzynZQ1S/2OU2i7Hc5dFBsShpZlOGaQPuezLORfp2nYN9CWP5C9/cLylN/+a6pLKRp7GkciKvPK8lWBjCvzBpdCMewHXuQguLcetx2QWD7hkGoZsiIGGrXJw31WjpZEyxFRV8hHPWZwG8RtYcfHMhBYOpTS2q8hDe2soNvDsBGIg+23KI0H25y+YZi1g34jswKCt1s2FJ94bM+EIOB68G49Ddnohq68fr516cKUEqQXQvDywf/0Exdk2xs+8FM6v9xEVYjuqxG3oHV5gSQOezoNaX7DOVoazGIcPP1CSFYN+ajH1x2mUlKt5+RZRNGNManbIOy0FgJrrEXYiQxXGqp3V8jGPQfftop0+vQOTNCdjHDJIKf8bNtuvo0Htk3XPOlywcwNFbKru6iXDSLV1QQZDjMll1mSer6R5yyiD8u42Kh2QMpKOMYmYTDyheHIK376nLa9KFK+5EnT2rxygp+OL+VP5m6h9pR9/N3v34JNGjzzK/cy8ZRr+fTH38dEs0nlvh5ZHVr5IoeuupHTqWF+/gT7dx/iY299D9v37GZhdoXuYosbn/5kbr37gTAdTyM6WU46XGdbYzs3Xnc9r/+JH+PKa55KWjnzmljFBwlhI7HwjO3P7qEAZb9ETMy7/vpv+aHv+246kaNSQHN8mLzTpUiUMo6wbUffOer1GgLknT5lVlKpVCjLHFXo9zKSNMLWI2xq6Lb6xCZG1NBd6V4wKX/1U9+grQMNlq60TN5esnJpxM7fuw2pVlh5/mUsHzJs/3hONhJRO53jE0PULli4poY4qM171vZadr7tHtylO4lOLeFOz9N/wTXU/u0IZBkkMdruYEZH8JMjnL5xlOd9/y381ORHGTVnFmtsJmPzOazxuVjzfWIxPOfWVzD1ivkzi1emJpBWJxCuMUGiybJA1oC2OyGFrlGHgUzhWi1MrYbUakglxa+sBo8ZeN/iH16QfS958xs1BPA89akOnbk68bJFSsi3lcSLET4JGRdDl6ywslTHLiS4psM2C9LPVjElZKNKbUZYvaqgejQGgf6kRxSSJUN+sAeLKbWThslbM8q6ZfWSiPZu/7kEcb6erJOKQrJqSJdgx4eWuO9VI8FzrxC04ixkcKBsZFLYTB4WwFOrZ3KaBbCK7ZqNnGdxYd+FLh655J2/pjZyOGeYGltjqVWnv1DFZIbqnhbdU40wGwF27lugV0QsnRqGSBka79C9dwSTh0ExXbRUrluic9coUUfIr+yGBR2nK+y4Yo7ZpSHie2tc8rZT4Bz5vglWLqmc35bngoYBzuZQXSg58bIS144g8RuEaiOHdwbvJBBuYYIMo0GGsYnfyGk2ohg7mEkNUua8C9z00Hede/HIRZHyzht2a3PXEOPbhrnjzn9jpDbCtuFDWEm58/0fIrPKs77qcq58yn7+8ZbPcjCdZm87488P34P6iFEy0gO7qVcb3PeJe9k3MsFXPO8rubN3ipvf+SFqXeWZL7yef7z5FqZ37aTmR/irt7+Lq668BG8izHpkYgAzuGkfNgh+jjQWAiQGpSgdzhu+6fkv4hMP3UlDDaumTy1NWFhaRqzBOGGEhGhqhM5ai/biKomNcAqlKxCxYcoLRFVDXBF86anVavS6Pdpz/Qsm5ec/+1e0u6NCd9Iw+ek2xUhKbzxCLYy99z7wytLXHWLpKmHHzY7euEUFJm+eDxJFEtPb26SoW0b+9QTlzjGOP69BdUHZ9o470Txn9Vuewuh778Zfugu1huf/yc28ZvQeTEic+pw2nctTPruMQehpTqGeb3zN6xi6dSbkIJcueOezC2BNkF6SBL9tFLPSxs3OYdIUdS5kamxOCaxWkVo1LIYZZGu8b+Z3Lsi+1/7Im7SzC1wSvNfs0j6sxshIjq4kpNu7lA81KMcLhm9PUAvd7Uo5WiKFQWsllUaO3N4kftoy9n0j9LYJ2YE+spQQrwn5iA9etoORe6E/IbT3+od7q+t4JA/5bGySHEShdsow/eE2R76+TtkIUouup7YpuFTDQ2HADlL4MApeNlb3iQYSXl8paPLgLWsED73mwkj5qp98s7YOlkRDOf50hZ1XnmZutcG24TYn50aYHG9x+sQoyXAG99XxSZhZ2HqY1hvrSNOS4o4Rdj7rBHMf2EU2ppTbc6K0pJyrovUyzAJyw8G39/CpZeXSysbKywu1rY8H8YO6MH5nxkMvMcTNHFcajA15yHghSsuN1LZiLcU2iqAZD7TkMotCGmXfYmol1vqNbTbyPPjSn/vikPILX/tC/cebbsZFHQ49ZTe7G+Nc8+lZ3rXXcu3Tn8utt3yExk7Hg586ylS5i87iMs2hBtsu2cO9J29nZFeDhcMtylbEtr01pg/uIMeTNBIe/PDdHLzyKu6+6wGSpMqkGeMd73gHV1xxOXEcdJ6Npg+ughkYd3OfZPOOsNwJXf/PGNThyxKxhn/6yMd56be/lG5rhdpolbXcETll1CSskTN9YC9l3zF35BSlKM54TM8iUYF3jp079nDy2EmsFpDGFCjSh8IXF0zKV7/uzbrzpnsA6F5/Kf1xS2XREfUds8+osP2WPr3JmJFPzgaim1+G0SG6B8ao3zNPvnuU5PA82u7gL5lm7WATcUpRM0x8bJa1a7cxdNscpAmunvCc//kJfmTsNhrn+Q+kzyblYF55xDIeT19LYiyvPvo1rL6kil9cwkxOoN1ukCZqVTTLKC7fjc0c5v5jG/VoXgSPuiiQS/fi7w3/DaCkKTiHzwv+ofzzC7Lvvrf+utbuTult9/iqp3Y0oruvwK5FVBaFbETZed0Mx2bHYDWmeiq4mtmEJ97TIZutoalHKg4zl2B3d8nXUiT20IrQiidejHAVpTIXFhtkY3omR3V9Jic8nDDOJpBH8qY3kY44YerflOWDhnxE8VUfgnqDMhopPgKikOGxIVd4NtLlTHkmIOhTjxSCKeSCPeVnvP+ndfG2bRSjjmgohxNVKgdXaa9UiU8nAFz77Pu4a247Ikr/3mFcVbGTfZqNHu1uiveGajWne2SIsYNL9IuIPI/wzhDFjmyuhsae0VsjRu7P6UwnZxYDbbbtZhuehfX9sj6dHswcZGAjlwrildVDih8uSGoFRT8K3nHqEBtWLLrCIFY3Uuq8C0us1Qm+HZOM9VEfsjAAytJy+ItFys992Q165PhpxveM8umbb6XWTbi+PkyrbuHKPeyqGT7ynjsoxVFppiytrLL/wHaOzJ8m7hmiSsxwfYxTh08zPF1hZPsIMzNzXHboMmoGjjwwy2WXXsEzr34WP/6a1zE5ORGE9HUr6rpM4QdL3vVzPWUf/lENEVEROzC8oupxriTL+qz1cj5xyyd4/U/8OKeWZ6jFKb3E4DOPX+tjmglFN8c4odkcYqW9SnN4CBtBUebkmcOmKXEqFFriFOouZmlm6YJJ+Wnf+yYdOprR3pkw/qHj4Bzl3m2oNbT2VsiGhR3/51jwiofqMLdIceVekuOLYSVdNcWP1JG7H0J27SCfHiI9usTaNVP4CIbuXWX1yhHmrxXe8pLf4fpUH1WaOJuU/YAhnCoej8Fs5GM6VbpasOThVNnkDQ9+I7XXpXBqbkO31izHr61hmo0gXahix0ZxC0vYbRMQWcjykM9cqUAlDXnaIbeI9x5984VNsd/4JnUNF1LDPLixgvq9KWqgu7dAShM82lKwnZAPbLsGmwlFMyzsCF6mUDbDvqgjqAnvrqjMWcq6sv3jjs42y+plQQrZvOT5nDhfj/SsvwQteeR+aO8MC1VsN2RelNVBIRPIWcoQxAyZG4rtmQ3SjrpBE19PhTO58OBPXpimfMk7f01d3yI2LK6Y2rHC4h2TJKtC90COrZakaYGq0FusYmolvh+F91U0CtTJRm5w3AjBNplLcVWPNErsbIoaZf//6iNOWT1QCwPPZts+Qsv17MFu/ff6e0z04WXDMvpQ58rlio7nsBajkRIN53gfBrk4LSmLiDgpKQoLKvgiLDiKkpKik2ASFwi7COL+kZf/zDlte1HrVO8/fpzF9hwra4s8/arrcC2hdFVePHY1v5hfwb0PHSVLYjriOfS0JzF96RRRtcr0+DSRVnFW6Vd6XHXNXurVUSZGpzh04ABzDy1y/MQMB/cd4sZrb+SXf+FXmJwYH0Q+B17u4A0sQvgvuc+MdhIWGKii3uNdCb5E1GFUER/+giLhzSxU0ipDQw2edeMzuf766xmf2kF19zg1a6l3wzQp6/aJrMUYodVaxWAxkdDpdmk0hiizPHgeaYSkEdWhGoW/uBV9w4f7xEtdKiuO1WfuCi/tccrSlVVWLjOM3J/DYLXbwvUTlJfvoaxZip3h3RiDNeBkN1yOb1boTcThnRcPtWge6bJ2+Qjz1wmf/O438bTUPSZCDsG8Ao+nUEehDrdpYN9M0uuYNMKBeI1fP/BXnH72GLp7inLnOCQxFHnwelttiGPEWtzCUgjQRhZda6OjQ/heH2xYfUgSo8ONsAT9AiEe4mWLHy5xTYdZiekcyCnrSvVEDA7SuYih+20ImJmQ95tPlmGaX0hYyEEgZtsX8j05+YQDG8qO3gXLl0WsHjpDduckZNn02eRzqNHwd/2zrgVbNki+bChr+4SoB8mywSeQjzpsXzZkEpOFDA3JQ1ulFFzdbyzPtpkQdST87YZ9FwrXt0jX0hzpsn16mYXlJn5Xn6KpVA8nCNCdryOfGqI63iOplJhqyciOtbA8uxchnfAuCxHwnZihg8vEY33itERK2P6vStmIWTlUOzPYbbblJqzb7uwyathYRDOggrBQKNpkX6CsCcmagZUETTzpeI+yHW+8ZKksIox1FIXFtWJUIUpL0mq4P+1SjO/EuG4EqzFp7fz37UV5yjJldWKoRl4q/bWCybExLv/aq8n+7U5O9nLGpraTD/XoL5QcuW2W6vAYw9OTtFaO41xBcyolb2XUVwoWOwmXXL0XsX3uv32GoaFhfvbHf4Ef+L7vx8ZBfvTrZHyW/cUr6kpK5xAxGGMwIiiKuD5e16P6BiHCq1I4j3OKjSKMxJR4fFFwanaWV77uR7n97k+haxn7m1M8ODeDqaWAD1znLZ21LrG1eK8bckljeIS1pRVMLaLeqFMudehkF5598bWTP6CMjyJFia6swfQ2Zp47zug9GclKRm9HDZcK6VJJ+sn7kfFR8p2jxIth1V+5bQjbzpBejqy16TxlT0jF+tRRGBvmnp9ucuvzfoeaJOclZI9SqCPTsKw+xmJFcKoUOAr1A50eLIJD6apSKKQCyaBsS4UPdg/y1p//BoY/NYO22ujObfDgcaRWA/UbGRd+efnMaj6voB47OUE5expTq4XA5NIy72//2QXZ98C7flndbC2M7Q5cw4eVcWnIJa2cjOnvLmhMdOgeGSJZNahA3A4PbXZ1F9eOMW2LJorWS5KTYWpu+8L0x/qsXJqyfOUZb/VchLzx5rl1fwM2SCMsN1wvOPisv7NikL4GYZBJVsLKwWwiLIwppnKkHQVCNmys4FvXnTG6IWfY6S7+ZA03VhBXC/zJ2gXLF099z8/pylptY1mxa4WsCS0M6VAGdzcpD/S4bu8xPn10D3KyQjlcks7GlDVl9IpFSmdYXa0hRhkb6bBwahjJDfGq4cBvHabYv53ly2sbtjpjzDO/1wl33a7rnrBK8IDVyJnrogMeiQRxISVxPVAqPsQDyppS7O/jc8voZItOL6XMw4zAiOKcCR6+gol0Y6FIo96n1a4iooyPtJlfap430HdReco1p5hajKQFu268gqsvvRx/bIbdT7mGXvsEd938WeKySne+TzpUYfySBhK1aSQJUW2U7lJOuerJhmrYU8vcd+c9XLF9O7XqMB/6u4+wf/9e4tTiKXGsL1kcPKQM8oY1+MrOF4jLsXEFbwwlgmqJqMUVLZzrYU2KlTqOiJIoyCAOCulTlmH0mpqa4g2v/Sm+/ZUvQ+qG3u4KWcczHFdwrS66dwT3wBxDE03QmKLfI+9l+AI6K22MEcg93aU26i5uRR8iaC3FS4XW03ewfNBQXVAWrkmpzcaMfyzkYfrZOWR0hP7+CTQSkAZlPSJZyTCtHn6ohp6YofbJI5QHp6FZ58V//TG+o/kgw6aK00GqzsAT9gQpItq0TLzA0VdPU8Itsy5XFOppeaWrloo4UlE84AYPQKGQqdLRcNyzqg/yntccoXhZhDQb5GM1kmNReDVoqwXbxtEjJ7A7tofZTq+Hb3fQQnHzC4i1aFni5hfCUusLhJupUZsJr+jMh8DVPVovsbUSv5jS31lAKWT3DENFKS7rEseOTjdGexGNW2uUteAROwXpJJQNZfzWoEMeeVGy8QIg4HMIeXMwakP/HRDAuocW0t0GwZN1r9yDFAPPz5whbjVC0VSah8HHhmLIk5xKcAm4hsP0TPCQNcgavjqQbsrgmruZGhqBWYlxq/FFvSFgZa2G+f9pe+8Yy7L7zu9zzrnxxcq5q3s69+RMDjMpcigxSCYFWTJsaQ3DXq8TZGBl7cJYrOFdA7ahlbEOUFhIsmRa9GoVTFFaa6ghtYwzFDmcPNM9HaurK4dXL994zvEf51X1jKAdQt3QAQpd1d0V3ql7f/d3vr9vuBHjj+iA1ZM9Bu2YhaUWW7tNOJVQraZ8/42TYASVU11iZRjWIoSwtN+YxIQWW9VYz7C3NoasFsx9NaRxucPe0ycx/7afT7xtb9+OGY/27u3Wq9YDoxzVURhnVypTN/A0o07ZSgeRBh2HuWc958txsNFERJqolpFnPmWusKXArxYEYUmeea5IA/1B5IaAQKvrHjTvtu4Kvlg8ETHMMxY+8AC/UbuPBdsl2O3xhd97lhefvYTIa0xMTRPNKopqys7Fdba+vs7isXMM39rEruyxeHweu93lzJP3E4R1xsaX+f3f/CLHlmdAlFhTIox00MPoyhbykBsQIISPwKKUZVhYUm0R0kNgsVpTFgU6zxl22/R7HYoyRZsCsGhdUhQZRVmQ5wVZ5rrqJ594mL/3c3+Xc8vn6e20mY5CTHrA+4/P47f6JKWhvztkuHdAMUzwlAJp0UZjjXUDbl0i1B03yQDo04uIYcbuEw223gsmAL9vWfrNN5j4yhXQhnJuDDk7DYFPdHGd4Buv0b0nIr62j7e2T3J6CrnXIf3QfYhKRDod0vidDp+tXkYhKOxtBsthtywRI2zYvQH4KNpGMrQaX7hOubCGobX0rMe1YpKVsknPSIrRNZdaRcf4DKxH20S0dAWN4J8c/2Ou/OfLDC7MEuz0EWNNbJKQP3IK0R1gkgS9uYXe3nWQTRAgpIOlrNZg7JFv9J0uExuycctgybD84VVErKGQiFsxXl8SrfsE+4qy5gaBcjWmvFZDbYdEGx6D+zLycUM+odENjSyc0GOwKNh7xI46sb/mG78DmnA3vgksxndqOuNzZK1pPQfRWWWxI8vIdxyvpUWWDkpxDApD56xl4pJxnb2EoCMc3S0y6KqhrLmWUQ0dlm5Cc9QtisMu03JbZHIHS3kaoyA5UfDkU28hhGVsss/GxgRm4MNeSG+3ht/IqcwMGHZiers1TCmwmxHeyT5qbkg8njA2McDrKua+HOANDXuPNt3rP9zbtw/1Rqeew48Ph3Vl5CiBRrkO2b0J92cAOuJoyGe8w/11pxCpLbJ0J4rwwDL7HYm3EboHWtsn6UaEUU5QyfFrOUI6xzljJH7gVHwWRjoJ94u3f5V581fWXXXKDzbHSSd8tv/wBX7pxxp87de/SiOQCOXhJQX5bE71WMzKWwW+9ggmA2YfGmeqbNA7dYzG9ARvfO91TGG43l/l6ccf5/H7HuHeR08AFqUERZERBKGzBhUWhBgxKtRoqKexJiEZ9JBSMRy0EViMzsEajHYddNrvowJDENaRUmEMlDonTxKqzTHwBdZqMCV+4PPzP//zvO+jH+IL//qLXL74A/YubvPy2g7tbEgdRU+WyFIgpUBK8ANFlmqUkBhd4vmSylj9braXwVJMUPOZ+/N1TLDE/L98y1HBlMJmOUyOM5yPqb18GQA5O415/ALah+HpSdJJxeRzW9g0Jdrss/OxJQ7ut/yzha8A4AtF32Q0ZDQ6i8h3FObDDjqzBRtaEwjLShmCl5Ja1yGmVpJaxa1ikjE1ZFIOUcKJbAbWY1fXOePv0xAZWji/kKYs+NWf/hf88lOfZO1PTzDxZkH10g7Bm2voVvvIAN9q7R6wQkAYOt8Lpdzf+x5qavKO91b1JeVihlSWgy8cw76/dI5kXedrkZ3MoOvhdyRF3VJWzZFM2SzkVF6LSacNUdvDCsinNAfnRx4LI7GCK7ruRvyrBvRWAZ7FRhrhmSO8EmVGgg/BISYkrBgdy123Zkc0NzsSNohiJHIQYENLf0Ex+bqmt6TonXQCGDWUR9OrQ+xUjPw8hD607XwbI+GHFI53W3niE53uUQ8KXv2TC+QPDRjsRu5+KQWVs22y3CNrxdiGwI8LdCmJKjmTcwdsvjRHOV5i+oqkapCBpYwkRYXb8IRwne5fFYEcdrk6FBR1540d7buPdTAyYBp9jj4kGVmwI/tdK0cmTkeCmlGh9t2/lxXB7PcNrfOK4akcoQzJIBzVJkYG9+5rloXnDKj80Xh8ZOVpindvJu6qKH87lQR5TrTQ5Ntf+wY1FfLET32WV//0qxwkfYpLJWubN2jGiplTS2xttrj61ho3t/YYn6lR6Vl++okfwXtlgz/KrpKqgLn7HiLKSkSsSJMEgSErE5QKUZ7CYLBWUpQlabpPu71Hnnb56lee5dbVS3zqsz/BidMXiCsNpHLdwGB/h2GvQ62hyLIhlJZMW/I8R2Dw8pxqpUaaDMmyPliJ8mo8cO8D/Jz5Gf7grZs8/+iA8QNFXPisv3KNUPoYKdwOeq5TEdLdfHEYUgpNL+nezfZS2UgRxlLMjzP/zCYiirj1k8dYemYP2emjV27R6PSwzQbF2UWCW/uol68wu9JEz0+g8pCNH1ugsVpSve68JqqnOhTWdbq72lkNDvSQqpAjxZ4rxEOr2dKKN7N5tsom/+vzHydeCTj7iWv81NwLLHoH+MKV8tfSY6ykU5yKdtjRNSJbMDQhbe0wv7YKWFAZ2zpgR9fIGRKJgr+79E1+7dOC9vYxuHcGWVi8wQLyhYvOOU5rV6B9z+3tqDNWtSpWa8zIn+ROlp4oCVZDjAe7HyoQPQ/vdI/hXsV1kvtOUm3liLvruz+DHYlcidGx61DnvlvQuuADimyhODL9sYGF8rbJ0JF/cSlcMa6UkCnQgl/58O/ybOc+Xm8vcPnGnHMkGwk4MKPvL3DY9RFZGQc9vI2NIbTAGuid1vSPC+rXoXlZ0Dkzort57oEhR1Jw493uxg/l4Yxqt/khR+x3W5V6xuAgJiFi4v17DPbqnLx3k24akRYe3VbVPYiUpcwUQaXAGkF2o8520kAZgdrymX5Zs/2EImy71xBvCVRm0ZFAlhajRh+HDmJQmTPQT2bdvujY8n/81G/wjy//BAe9Ct4rNWzuvK9N4F6nl7o9Nj7uQTjCm0UJ8tCg6W10OR0LekuK8MASP++z/1QB0hJUC/LUDf8QIJV1fhpqZPpvhfPLAGQlf9f9u7vkkc0urVShu310ZBgoy3e//AwiUJx65AyXXrjIY7LKXBeeTTrUm1VOnD7Jfn+XjW6Lfzc4xbeufY9sOmChcoxHH3iQ87OzmLCOMAW66ONLhR9G6Dyln/bJiwzfr9Lr7PHKd7/NP/tnv8Lrb23iVRsU/RbV+jI1L2ZiehK8CkHkowsI/XEK7WHzkjzbQ0tL+6DDzWurzC8tc/LcOTwvRuBR5C1yrTGlpdXZ5brKOTtxhq+++W0W5peRFddpi9JQCkElrJP0+lSkIhOazBd4Gei7OF4DeHt9xCBxxSfwsUKw9OVNCHx6TyxRe75Ez08hjMHrpujxOum9swQHOf5Wm86ZGpNvpBhPMDjZ5OB+ywfn1qjLHG0tHeNw4KYU9KxhQ2vaJmRMZlzK5/mlq09T+edjRC/d5N7aLrbX5436WRofSni4vkZFZkx4fYYm9cmAygAAIABJREFUYNwbklqftqnQymsAXErm+eb6KR6ZWednp5+jLlOUMLR0jdwqBiZko9ugkVh6ix5zX1kju2cabzT0c8c+i4xjzIHroK3WjplRWjB3zhAI19xQCZxXgw4sSSseKZBAFIJyuiBopmSpj+n6yFwxPJNDLqnN9km7Eev/YUnRhfimT7jpUdQsNnQFGeFoZ7pqwDNQOjMihEX0PZdk0pL8V3/wHznoIrDIt0mghXY/hxn5V4hSYKraKfCikmZ9SGvXWQyIoed4yNLxirCuk9SeeyDo0KD60sm+m87C03l8OEN8qyDakeRN+w5D/DtZg50qolJitaC100DFJZvtBkoZvJEpj/IMZ45tsXowTp4rhLT4xwek+zHhRILnGVr3QyAg/NcN6quWIoai5hqgMhL4A0tRF5QxeIn7t7Jyu7vVseU//frfIdzwEVag0hEmr11hlsWI8jba66LuRDTZjAbfULkWgAVv6Aq0laNiH7nvl42Phnq+IeuHyLYHM9mIk6wRwlJkPn5YwtUq+YKDNw7TS/5t6+5c4kJDuNUnqVne+5EH+cErFxns9pEZXNnrUq03KZ98ki8+/3Wm9336yT790lKfECxHFX4jfZOlTk6vEfGBM4+zPL/EhfvvJfQkZd6l3+kT12ogI4JYU3aGSOFRjesMD/Z4+kd/lh/9zH/CKy++zl88+wyxUjTGaywcO0d1vIbyfJSEthVgDWlZEkZVBq09Xrv4Jn/2zFf5wz98hr//Cz9PP+tx4p4zeDLAlwojS9rtNg+cv4+//1/8Ir/8K/8zU/UJOnv7ZMOCykRE1rdUPY/B8IAcwyMffIj+Gzf58Uce5S/UPtXhXW2vG/T1+ogoovX0KSb+chv2WtiipLazD2MNWg82mP7zGxAG2EFCJRunmKigJ+uMvdZGWIsJPLY+2ETMD/kvZ7/GmCxpGcWVYppjXgtf5DSlYkt7+EKzoCyXgH91/29T+U3B/7DzYb787VNY3yAbKZ+ceIPzwSYVURKMpirGSromZkb1uJgs8kc3HkJ+dZy533mNb/zjB9h/sspnZ14hkgW+KFFY3hgu8rl7XuWbf+80/PoceqpBsN3D9Hqo6SmsHiCiCDOKhEo//iCVt/bY+egc8Z5BmDsvHDriSERRjGn8A4X1JDIXmNBSTpSIoaLYr7uCUY4oZUNFZaFPf7cKylIMIhoLPQa9puMphyMesLzNA/a6CseTG93cylHUZA6NmwYvsaRjkqIhKeMRzuw5QYdVLpvv0OPCG3jo0CIXC0qt+Mi9b/H1Fy9glcUEHHXO1ofeCYPfc1S3smEdptx0EVWHtp5W4LIFe9C9PydsZGTtiMqNO3fgYyQpRkJ1LKG/XUOPG/LMRyeK8ZkehVa8tTbrfCUSR3/TnqEyPaDIPYSvGW7WqS92jzyf84ZA5RbjC8K22xtvaFEZRwUXQOWjh23iDKd6x6C2XpLXJVK7vS0qAh0K/NR9vg7dCSKJ4MSpbbY7daKnuuTfmnJd9dvEw8JAOukwadXxsJHGi0q8Yxl55rnkFOOk2GojBB2SL+SMT/ZR0rK3Ovau23d3nbL28KIGJumxenmdelinnXcxqaHRqNPe7/Otb32bsUKxz4BxEZIkGRvX2wgNJ5YXaE422em3aXgRP/2Tn8cPJL32HnElxPM8muMTGG2xRYo1iigeR1BjduEspbKU1nDvE+c4fs84V157kTPn76M+PYcX1sBKTNklqjTxQ58qAumHiCmYnx2yen2bejTNb//6b3HhvtOks3NMjE+R9LOjIWOSZlitqQYhofVIehmxqFMcgLY9EmHwqz4PPvYAK1dXmPvYSf75D77OyXiCV3fad7O9YJ3izQyGjL3Vx1Yj2CwxSYo3NYHZ3mPqmYHzkOj1Eb4PwxR/9wCsoTy7hAkVwVYPHcGX3ver1KXmUj7OnNejIjLuDwSF9RhaTWEVC2qILzw+XtlGjS6P/3bmG3z2My/xqxsf5efmnuOJcIemDACPvi1Y9A6YkCkGQUVo3lO9xsXpOTZX6shmg3O/ssHquTE2x8d4MF7lZj6NFIbCKraTBtpIylC4jL6hM703na5LHRECWavSed+9NC4ecPDELLNf3XDezKs7d37tlmDDUYFMJMW4dubr0sUlMUryMKMkEO25blf2PPLLDURsCVuSMrYE3x9DzwiGSxo0zhBoKI9wZeM7TwrJbWZFUTdYBfk4BB2F8S3e0HVqJrg9yFIpYN3PIayj28lc4L9QJa9Vec4bgyXXvR95voxoczbS5DFQCoKWcrl+o9cotIM7vBSS4zm2meFdq1G2PagZknN3nn9IIVHVnDL3SIYh0WRCnnnOIjvUtNtV7NBDVEr8qET7hjjOGXQjzHoMCyn97RrCQP0LDVSu6ZzwnMgnFHiJK7pWggkEMreo3DqmClDG7mGTNRVWCkwIwjroRvtgPNfhBj2L0O7zvARsZimrgvUXFtChJViRZHMWvycQ8ja1zgSOwaIrFl0x0PfxJ26/xsMYKdHzCE/1qUQZrZ0GB7t1glrO1PK714W7G/S99xjXt4c85C9TiAzjCaIwYGfzgDTOWZgeZ211m2KyyrQ/RpUIud+hYavkC7DbbhN2LeFCnYlKFWkLcm1IBvuE0TyeFyCEpNR9imELbQ1hJXaDLjxIMgbDhEocUavWePIDH8f4PiKMsJRImyKp0ZyMHSZnQUiFNxtwPE/42X//Z0jTgCceuJ9UHdDd30ZZA7ogTQqysuD66ioXr14jkzU++InP8Hv/529jSTEKmrU6WWgpRcmVq5eJNbT39zl2bI50M8U7xOnucO29b4baxjh5XR3RearxKbxbe1jfw55dhsuriKkJmGhifIXcbSPCADNWx9txmLZpViiqoBH0jGKlmGZSDajKDImkZzI2dIBGMquCIze4A5OyUXoseHDC6/C/H/8SkZDURkZFBkMNn4eCHInDo30RUpct9qde4b/7946jf3KOj1y4zLhRvNmbB6Cwiv28RrcM+cHGMfKrDSaxrD5d58SvrTvzIilRszNOBAM0Xt8HKYh3C5JTU4R7iXOWu8MlS4i3XIHSlRHHVDISibiiWlbcjRzuqJHaTblj7pjBb0t06Ap2WZUks+aItkagMYVEjeqaSuURH9h4t7t7MRr4WQUqcdJuE9h3eB0bH8Qhv3D0sTcUqAyqG4a8LkiHIfmYpaxrvK4LW3VmLIZKI6XIPdSMptiuHrE/VCYoxjRlA2TXI80lSnE7ndvcxbVrwKxXUIWgnCkcvDK6/7xAUyQ+/ljqjOq3Y2y9ZLBfBwF6rETuRCgNdiYjagn2L0RHD5sydnDC4d7J3HW67xCDjAZ+sgB/aAj6hnRMoQNx29RfjWB7JQ5JEY7TXMLYJWis5hQ1D2+gKKtQVMHrg47dg1PHltn7dkhyn6Vmh2t7k+TGmdjbVBFNpNhqTpb4TvlnBMI3lLkiD/8WB30nFqcQsz3GowVaK6+yvV5yz6lZZpaa7Kys8SMff4pkkPPK5ZdpNCM2tvf4+E9/EkSfZGBJu20uvXaVCzNLnDyxSNLdZGNng5nJZYoiZ2z6JBhNGIQETOBpDyEjBAJhPWQoqEqFrzzXXWGdxNdqdxMYhTBDrPKxQiI9CcbieQHzC8d49MknHX6pIChD4tBH5wkH/SHCSrKi4NqNm/zGr/0mQRzx8re/RbNWowgiDBZR8cHs4+Ex2B/w6Acf5xtf+0smFprEYYXm3ZEvnGy2GVBWoXbLUt3MaZ+p4h2Lqd8YsPrJBt6HH2DyjZy86VFdT1n58RPuF5s4+tzUqwm95Yj8eMaVfIbneqd5onaDnol4MkwpLDRlgC8KhjbHF67gSgTjMsL3MkLh0/QOWRnuqr6t6DOEI+5yKNyRtyJ8PlFZ5eJ9LzDl9/CFZmgCJtSAnom4PJxDW8GwDMhW6pz7325iKxGTXxtgx5vISgWsxUYBIhsFx+61OPjkWcb++DXE8UVMJUBMNO94b7PFAtXyURmE++4om4+KYryuCHowWIBitqDM/KM4KC8RFGZEpwqd7eZg0WIaJcI3qK0QEv9IAYjhyIDIKnubR2txLAuLS8eGo2HS4fu3/Ss4giUOi3reEHRP4vw3Rio8NXAJ2ta3iExSuRySXLCI/QAtgBHlTlgH2cjUScN16BgeulEiUoXXURj/ztmyslGgQ4UYKMI1Hyt98ukSr15gblSJu4JkwcOfTsiHnnPfmywQiXIqPu241b5n6C1VSKddIazdhHgP5yBXdftjPNc5m1GXfGiwdOiSV1QEZaSOlJBv97eAUSEffZ6VziFOasv+fRFl7L6WN7Qo37Eyymh0WskE3SQiSQLe7FUc/c0zLlw1cjxl2w6g7vQPfi3HWkGZevS68V+3bUfrrory/rUt7M09Pv3xE0x+7r/hT579Iv1myDf/4C+YqkqWJqYYO1lnr3eVpdNzPNZ4jFavoNfrggnQFJw+u0SRWj760Y+wfXOdpEgRCxWSsqQpSjrdPSQFCotQERiXxpEXBs/z8AMfrEYbR2ezUmB0iRICYZ3M2hQF0vew2gPpU+YpVhcsnzjG1u4eg7RgfGKSejVm0NljLvDY39sn9jw+8MT7+GLzj1hZuUEYBuiij/JHE9ahJmhUSBOLtJrXX7rK4rETrK+u4QlHDbubVb9lqW7k3Py0T+ODu+w9O4sJ4PjvrmPGa2RThqRZErV8eicE209G+H3wexxdlK3zMV5m+c8e/zp/3r6PThHzsWZC21SAlKvlYbfphn6F1YTCo28zKiKgIaMjRZ/ztrBktsQXEo0ltYaBzakKSYHGR9ExOamFzzV/wHPDM+wUDR6p3OSY1+JKPstYfciL/eNUvJzzj91ET41h37iCHAW94vuO+pgV2Dh0ZvzA+Pd3MGdPwOUVpFJO/XeHSwwV/ok+aT9AZSHlvQPKdkjllkfetKT3ppjUQ7X8I9jASkhnNF5PEu0JirobkoUd6Hn+SPhhjyAKE7q9dfQy61gVysLIcxnsUXd3pMw7KhYW63NkcSkOZd3CoiPLcMkic4nXkaj8dkKKlTiIQjj5tdoInTucGGHdvvOjELlzr8tnS1RHQSnw+s6u9MgY/w6XGXqIUEPTYDsh3oUulAp7o0pZNQyblmAipdiJnVxdWsRIGSkPfMJ9SV4K1IZPZbdgOO8Tj5AqHQiMGjEuAATkOKz5sKgenjJ0wGjwyZEi47AjNko4vwwLXnr48HT/J5mWYBwv2UssZeyGhFaBPxh12SH0t2t4jRyhXOKI8kZJKhZMqmgsdel146NYKRVo/Er+Ds/lv27dVVEOF+dYGp8mPvYAf/riH3Arz5mujvGZn/kYE0Gdl9euMD+sUZuZYqczQHZuMT2/yMqVPR56+L2s3rzC7OIcxxtnqURN0mqBNTESSSAh73dQCnwZ0Ou1GAxbTFhBEDYJoprjr2IoyxwlJUJJdFkgcbLrLM0odUY67CGkolobRwU1yjRDKEO/36dSqeDFglp9DOVJlOcRqoBBGNE+2KNIS3rdfTwJURgwGAwQ+Git0cKSlwXYgDLTdPI2nYMusQoYDodEzehutpdkWpBMh4jZIZ3nZqn0LINFwcp/sIyOLfUbgnQyIJ2EoO18dpNZS/OqZe8hQe2WIF20ZNOGBb9NP4xoeCkKiy8y1nSBjyAShivFOFtlkyeiVSZVwaSMXUq3NWS2cIIRFENTIIUgtZqWgaHxWddNfDQn/DZj0tAyCl8YVoopFvwDpr0uJ7x96rKgIjMqZEz6A673p+hmEfVWD+N5iDjGdEY0wpGJPUni0l3SzCV1KwlxhOn0UFMTd7y30Zai8mqN/IJFPNzB/0ETGVmKmsXvC5LRkFalrlMtxrQrHoUzjx8cc6KO4EDRu8e4G7occVxHhfTtbm266uKDxFFBZnTkHhkFKY5sNQ/lz0frkK+sOWqlRXaYEOLgFmf3Zl3mXwD41pn0azESmLgUkkPJNRZMbJEDB82goJxxpwf5V/yX/6bLb3nUVjzaDxhOvO8Wq99YppjWKAl+W5JPuxgnlTl8vJgu8esZ5V7s0kYmDLpiCDoerfO+U9cJxyzRIahcjBgUFhOM/j5wHfORx8WIx3zIsDjE0Y3v8GQ3SB3R45RAGQdVWdznHHbWZSSO3vcGlmxcHD1IZa0YWXkq1CjTTylndO9XC4bD8ChlJK6lDAYR5dCZE73buqui/BMPPMa/ufk6z+3/JeWNHveem8a3PnKsxou3rjA9O8l+0mVyeZbXX7/I+x95jOe/8w2mwzqBLBikbVIT0Vq9SRjAdjpkan6cZLhFkeREQQXhS4z1aEzN8sKffomTJ3scP/fYKHbFOKMhLGWWoK3Ek5BlfdIiJcky1tduYbKEiTEXzRRWNIEKSNIMQ0mpPar1caRU6LIgzwoqkYcfBNQrIUl3wPhYRHfQZXyiTm5S0iJDWI+4WRJ6hvvvPcX582dJ0iHf/PNvI6zPwvFJZ+d3Fyt9fIC6VEWuxES7lu49gLTkDUvjuiSdcDDFcM4yfhH2HzHMfFdQVN0N6g0dlzbe8KjLhK2swVONa6wWk+wVdSbrr7nuGMGjYZvPX/sMa/Nv8h+PvwhwJB4B6Jic3FoiIWhpw74Jaekaz3QeoFdEnK9tArDodYmEZlfHaNwQ8YS/Syg0A+vR0jUWvAPqKmU26rE3rKKnKoh2BzMzjigKbJKClMhmDZSk++gCrfMKL4HFP3Mtkz25QOHd+RE7OZWTLEpkLl1UU9M64UjNYHyQiSLakaQzboLvcvYc57isG2xgUF2PfMLBAFKPjsuTJaLnYQODtGKEewpUo0BnIxZGKY6UZ+7udk5vSEHR0CBxGXGAUiNmshXoofcOHrRIBSrHJWrjuMg6cq5vsgBRSHRdIzI16hDdA8AbClTiHiB+F/yBpb8EanPUVRsc4HqHq5gqOBh3r+vK2gxizOD1JeVCBlshqqcI2h7p/KH8zqV6y8Jhykh3kjl8oDlKmqW/jBu6GQdhHHbDeROCLkfpMFLDYTNqPAfjIVwHbHzIG3ak6rMj0yYIugJvABiHG/t91yXndeEEJdIZE1lnAueM8Cs5w250hL+bZCQWSdw3PzR3Su7JKXdjFz6gLGbwt5jR9y9feJbjJ08w74/Tua/KqwfXOD+5xM1Lb5LZknvOz3Pp1i2yXsJMrcrlty7z5Hs/wHM/+Db+9hppLyf26niRx/jUNP1OgtWCYW8PqyVFmuKhkF7OsB/wzJf/Xz78wQ/QmJhnaj7G8xVGF9giQxgDXsEgSfj+889x4+Yul6+vE1QDKDT9Xoe5+TnmF+f58PvfQ71SxQpIsozGZEhRpAgKojjECku9VqfdaaOaFcRMyNkTx1ClRU7U6Wd9TszPMeaFvHDxOirr8ebz32b2xAIPP3marf02QRQTpXdxZQPVb1XpH3cDnJ6nqGwIhvOW5mV3XEvv1VRXR5FDDahfVew8aZh+wXFO/YFxXRPwRLjD9eomufVYzSYprGJX15lQfaqUrJWS9lfm+cJTNe5/+BYfi1vEIiCzJUOrya0lEIINrfiHNz7P5Y1Z1I0IHTm89Pn+g6Szmni+zz+47yucCPZQWLbLGg+Ha3SMk09Ne12UMJwMd7iazDARD8nGm+gPnQcDfj1EDQqGx6sUsWT8hR1kYZn7y4zu8YC9p6ap7JaUsbxd2O5gqX0HS5RTLu3Y77kiVV2TJHMWoyzplMHvuhsyn9T4bddVhruKfFwQHghHY6u6oqNji7/tu06skI5fPMKNy1QR1jOyPB4hF+I2fmw5KvQAJ09ts7I1iUk8bC6xocarlBxb3uPW2iSgkJnjLx+6vKFwnhjqNhQC4LcdFc9LBFYJTOx+X+XEiMqoBPmYE07kY+4BZIPbMMqdLH/Pd0VsoiCIC0Q7Ih8zxJci0hkX95Q0Idjx3APFN4i+c+Pz93yMb/G7Er8PZcUN2IqqoLKJoxWWjp9sSkHQtfRPGvIxQf26dBRQOPKKFhaycUlZgbxukef7FNsVh9lnjv6oY0NxvCS+GOElo+7aE2QNV4R1NKLcWTcg1iPhyXC7CoDIJabjQdMlhtvJHJsrEIqyapAdz80chsqlZpd/i/BF/dgMw9Y+W2Wf+PgMemDpkeCPR4xpy9jyInO2hU0V0/VjtAYHlEozW51kKqpz4WNPQ1zFu5XS3t+j0aiTlBnNxjRKKQaDPoGGzv4WlZkzrN9c5Y36D5hausDU/EmwI3cmqSiynLSvUZ5icnqO7774Ol//+lfpDGByZoparcqVW7ts7zxLkrR5/OGHCLyQLMsYn52jSPvsbN2iEceEE+MYKfCDkPFAkq5scN9nn6AmQobdlG986wfsFtuMnz/L/Q+c5uTcAjdXVlnduM7M3BT3P3ia3d1dJmxwN9tLMuu8C/y+RzqjsUohCyjqAl1AdW5AktWRhaDfsHh9d5fnTUFZtWx9VCMCg2j7vJJPcibcoq2rnI02iWTBajHJwIS8NDzO49UbNFY1+/U6vz37fj528k8AUELgW0HbwloZEYmSB8Y2uPTqMsf/Isfr56SzMXldUluVVLdi/vuf/SyfvfAaNZXRLiq8p3KVfVPlm73zzAdtHo5W3fXjpUxFffZuHbD+qTmMD0HPY/ZrHSo34eD+Bu3HZugtSZorgsZqzmDeZ+8Bn2h3xMu9w3XIfZVdDxNrdGwpq5Z0uSTY8h2POXB0KR1aVF+hYxc86iWQT7gbs6w41kVZcZiuCUam8jiowtQ0JveoXglI5jyC+SHlRsUVTjliO4wMhUSqkLlgdWeCxenbtKleGtLtxq4gS9f1HQ4RwQ37CAzGeAjtDOqdWs+gfUu07aEDV+hyz2B8R+fLx43L5RtJw72BPAqNle8uOnvXZXGwDLmkyDxE09H/0nsTvJsReRVkXGJ8Dxs729RDn2evL0hO5fi9kMJpkNCjgZtRgO9UdSpxHbI/dOyYom7JxyBYxUEXowJ6yGSRueNuA5y6sEGhHT7TTUOGqbuQylroMG5GSj/hBCVFzRJvC2Rm8bSj5R3ahaq+dA+6dPQEMOBthpR198uRuZOWy30fKy3a/+G40F0V5fnKFP2xgmEpGewf8OTSBXZ6bWQcIQ/69Da2+e43vsnpk49xub1Ntepx/co2rVv7RNEY+c4mWkPlQNHtHlCvNhw+bCy9fh8/qOBrgS4N3V7KT3zu86xevcRgOADpYbGkSYonFVb59LvbjE826fT2+Z3f+R329gZkqWZj/QbCE87CyPPxEFQiH2F8+mUPYQw3rlzC5ENsGDNWG0NYS5FrOq02Dz94HxjN1WuXmR6b4eOfeD++L9neP2B+fgo/CmgsNVF5yERQY3dlDRn6bA2272Z7KRqGAndBBi1F75TzZ9CBw8IGuxUWv2Npn5aEB+541bgOtY2cMg6w0t2kKoNL2Twngj0GJsRYwY1shglvQCp9MuNxPZth48cLghuKVlo9Ylls64xICBSWy/ksD0dr3BhMcu63OoitfWx/QPVaSHWUmSeCACGmmfF7GASJ9jFW8rvbTzEsA/bCGmfCLQAGZchKd5LiiRmEgYm3SpJJxfqn57EeRHuW3jEnqBjMKtKmpKwIquvu+Bm17rydK5qOPoaF+JZPNulimrx935nDS7CxpjCuOMtUjjovQf9MQbDjkRx3TnIyE6PwU3GUeXeUat1VmNg4NoIGs1JFePZtKRmj90cGRNoHcRByqz3tflAJeAYRGKcStPJokHeIXXvNDF0oN2AKXbU/NLUPNxXpco7X8imWU+K3IvIxS7JUEm14ZCcz7NCxHvBGnX0mkf6dU+LK8dINEo1A3YooJrRTNB4EWA9EYAjjgrQWgG8woUAlEpkJkqUSfysgXSgItzyiPafYk6PBtQ7dtS+sw/6LiiCbdRzz+orbD+O9UxptpWNrlBWDTj3WWmPoUrrQC2kIw5KyVI5dM+Q25g8ki9p5i5jRYPdtQbXhtkc2W7rf41yO2ojQjZKyUeKvBfj3dhn2Q7QWjo+deVBI+CFhRHflEndt8xVe/e7ziGyAaAhaWtMqChpzM9y8vMetrV1SU2F7f5fAb2KYYub4WR767EOkcUmoYKI2zj0Tx/HDCuNT03gCEj2KTxGGqalZ6tUmc2MVfuTTnyLRmo0bV0jLFIMlrDaRYQ3h+0yO1/GERUr49Of+HRozs8TViNi3+GVJ1k9J+poH7z1H4McQejTrNaqB5f/74y9hM81Ys0G/t0tSZAzLjFSknH3wAYqyz+xMjTOP3wPxkP3hOtlYwa31a3z/xefxq5JcDag0AmYaE+ys7+BVG3ezvVTXJNM/cEojHbnCoBJBNmkYu1oQbjtCfbRnjziYgyXB+kfd8dF6TqSQzBomVJ/Hwy0CUdIz0SirBd4b3WQ5bPFovMI/fc8fIwu4eWuKvi0wWOZVTFMG1KXgwXAdH4MnDDd+cgw7N4ls1J0/hbHYThfb6/HR05epq5SaSlmOWzRlxkvPXiApfU5VdrmSzbFf1mgXMYWRtO4TyMIymFW07nf5cEHXokOorRlmXyjQ0YjKVYNsTFDbKCnju+DSCtB1N9lJ5xyFMjhQlHVN0JGMve5uDevZUbCogPEcM5MRTyRHxXzsTc+JOdrSKeQCVwwP06tNaF2HdAQblOiKcXLfkV+FygWqL/HbiuBAITLhwjoHCjmUyK5H7eWI+mUfr6PQsXmHp0bRjgiuxUdeGCZw6dkmMNTWXMdaNp2f8XC5xAQW1ZekxwrsUCFz6eKiOh5+y6Oyrt6Z0vE3XVZgY7enxXTpqHctHzGe43cF0dWQPHNBAmQKv6uQi0PsiYTZ5RY6tMSrPstfSZCFJWq5U8ghRc3vOUaE9UYeFqHGirfJrLXjG8tiRHErLf4AqqtO1KGUQZcSYwS6VJjvjSFfrCNzB5ccsjKKOnhdSeOKPBoelrHrunVgCTpAqBGjbEEWUjdY3fPhzIBhP3QsKGUxGzF0PaI1/4dW3bsqyhONJd7/9NNN/QAzAAAgAElEQVQkQYDyxzg46LKzt8X45ASPffxhagshjz/yHprNMYzN8LyUtdU3WH/xMnIzp7Zf4eHxh/iFX/yHpFlOkeZoLVDE+FVFdazCjZUrvPbmS1x+6zK+F3L92grHFpdZufoWRhv6vR6t1j47O7us77W4tHKTtDAEwuPzn/o0JZKDfkKiC6xn+cV/9AskeUphDEKFlEZRIDh74V4ynRFXfIp8wOVLF8FYxhsT/Phnforhxg6nJucYvH6d5aDJfcfOcLo5xUKlQX4wYHniGF5RZbPfZTtoM3t+hkp+d37K2Zhl+8PaOUv5lqAjifbAThRsfMgjnzTsPCLJxsSRD29t1TJ20RU1mQn8pQE/+Pz/wl7ZoGU8UuPjC82U1+dMuMXvdR7jCytP8ls7H6AuExo3DAuLLf7vzgNktmC1THglh28l83wnOc3vtt/DsHR5aCufGwdr0a0DbOqSQS790/N0iojCKnzhVIIGQXF2SKY9Zv0OnbLCF9efxFjBsXqbj3ziZSp7huGsoHZTUtShe49jn2RNQdApSKbdsTpsW2RhaZ/038lQ+JsuwShWzLEkTF1jAjvi6FoGHx0gUuUKnbKUCznSM8628YUGzauw9BdDBgsOTsintIMFdp3TnPEtNrCEe+5rFA2NjgxeywPP4ZgmdN1xWTHomkFH1kVNaUHlekDjunsgq1H2rh4p/dTIGxkB1rfE6x55w2AqZhRv5R7QXk/RPuceNnj26PWI0jEvonWf4EC5xJG2O+kUEyXDY/roGH8nKxhPkaErynKgMLXSycCHLvSXh7vooedMm6RFnepTjXPKTHHw4jTHvqq55wu3ODgXozJIptz1Xdm2hG1LURWYwPGHseBVSkxsRkVTUNQc9/pQTl1UHa88nbKovYDhZo3qyzGm72P6DtOI9yyycPdN0LXO8F7A5GuuOcjrt0UrCAjbgmzS4m8GhHGBKSRSuSGtmSrQq1V3MhjNBUxkkZM56XL+Qx347gq+mJtsYFeusVBobpbQVzATVvneV77JuYdOsru2Q+vmFpPTUxw/NoUpCybFJGVSY7xykv/xH/1PKK9KrrvMLy2xtbnG9MQ0cW2MXq9Lu92iXptkeek0gzTj6pWLnDl7motvvMxASuanptHG4EUhw3RIWmji+jitK9fpHRzQOehyZmGWpYVH2N7awg8DqtKQW0VhFcN+QiOucfPaFZYW52nEIa3WPmmaUK/W0dZZdelcc+reh2ibAh0JkqRFoz5LQ9YYePs89vgjRIHPmdlj2Czn0solqvPTBJN3R4krJlz4pigd3U1YKGsw+c2AgwsQbSoqm5Z0CvrLI9K9L1CFmzB/6+/8EhWh6BnDj9Ve5xvDMzwcrXLcS7heVngjW+JkuMP75m6wl9X44s576ZyW5Jdm+FfmUd5TuUphK0yoIbtlnYOyynK4z591LxB0BUHbkp+ep798D9XNHB068UJpJIVVbKZNFsMD/p/2k5ya3WMyGvDacIlWXmG+0qUcEUMHZUjr3G3Vot8DPQll1WLbgu0nK5jQMFiUyBKa1zTDGUXevIt2Tloq00O0lugbNcTQFWPd0KAF4VtV7IwGz5n/mN0IkQQEHUG0a+mcgf2HIjf4iQ2qpzAVQzapOXR3w0C6VCASedv2cyKFng+BwRYS3XQ+zkiHKwPIvusAu6csuuak0b3TI5ZHLihHDA1RCOLpIfmwhg0tqqfQUzlq3x9R5VzRsgrUgUd4T4/hbhVdtchEOmOimQyzFzo2RjCi5JUCHd+FWlJaFmfaqDnD+gsLYF0xFpEmO1sibtYQ0zlCWEyhKApFtlMh3Jec+HKP7ukag48tuaJaFwRdKKtgPXEU9ArQX3ZDQKOdfWnnvCbaVugQvFSQjTv83wSHb87vQw0k/WUXECsKwfBYiSw9vIH7fof0ufTeBGFiTADhAXRPGSrrEh2OGBhDQXK8oNyqcOreDW5sTzo4qhTomqY+36PfrmATN+BTnsZ4Ahv8LRblZ3/vz1icDTC+4uEf/TzPvfESaWfIw488ga5lTMmQWlCl0x/SSS1Ju2Bh5gQ/9vSn+cj7fwLlhRhtsMJDKEmlGjJI2gyGfQb9LlmRM9QFW5s3CSsNDrp7KE9QFAOETXnrrdcZnxzn4uXLPP74+xgMBrz80qus3dogiiJOPX4KGVqSfsqpc6c4ODjACxSTUwsgPYJYMcz6/PEX/y8++sEPce3KLT75yU/wneefozY24SKdipSbN1dYX91FTAR4MkMi2Fu9SrU+RWWqQTLo8cJr36OfFtw3fZLKOnh5wma2dTfby/Eva4azEqNg70MZ9ddC/IFl/yFnep4piY4Eft9N1/0eJDOW809d5V/c8yWaMiKzBUoIAmFY8A9YL8dZL8e5mU/R0TErZooXdpeZiIesdxuY0bFYG8lv7HyYB2rr/OHaw/yDU8+wlk/w61c/QGt9jDiE1iMa41XwB5bWuZDowIJX8kBzw0FPfp+9os7v/8kHWHpqne/fPM4vPfEH/JOLn2au3mM+7nKQx7y2uUB93XVA4IY09ZuQ1wXZmBvmTL4i8FJDb0kSdtzFHXbvnH4RrflknYbDJxUj71xB/RWfdNLh+ZWbnqOc1XyifZCFxe8bkinHuLCSoyBZq0YChNC4INDcUd9QFhsbZFTir0TooYSJAlJFNJWglGGwW0EO1ZHowXqQjpeI0RDM70nCPUk+7tR6MneYsfWdPNxE7nowMci2P5JmO+jFm04p9yJEKcivNBgJM/F7zjfa7ISuu1tMUbcioj3HiCjG7rwol9dqrC962FZIUDhIQCWCyksR/RPObD+8EY2M+S3RXoAsoLpt0FWfrCFue1IfCnE8d1IoaxaVjLp93z24o0pOkUTYzDnghfuSwYLFVAzRhnJDO9w9YnzHuKlPDOivNvB7ErXnJPFljSPMWEdgcjdAxLo4qGhX3o6XAtIF59gnU8nV63MgHO9bFoJyrKS3UwMjiKYS0naEuVmFikE03j2j766K8uKT56jXFxlka/zpM19iduoMtcmSr3/3K3zkA59i+5VXKGXJZz/1Kb79b17gfY9+hk9+4nMszy6NvIct0lgCWaVQgOqSJh16+xvYsiArS7IiozQ5N69fYmvtFmHgE1cCXvrO17n/4S4vPL8BUrC3foO8GLCzvcvqyhp+GPO9jcvkaYqwmrDh8cT7HqEUkrWNbbzAQ2d9rr3xPXxf0dpZp0wGFEXO5OwcUVQljmN2s4y1jVucPH+O+ydn+aM3v0HDwG7eRmaWR849xWuvvsaxe5Z57eJblJMhC+85zr4ouc87fjfby/79AXnDPe3n/txnOOPw1LnnLFsfEDSujiTPTx/A8+Okjw/45cd/n09WOkhcl66xVIRCi5JIFOyWDV4bLpEbj34Z0C9CSiN5fWUBbzPE+q7z678wxV/eH/D1nQsg4b/e/hlsrvB3PcZXXedRXVeozDipcEOy84QzEfju3j3EXsGgDLh6eR7fh7X9McpM0dURZyd3mQoGTAc9DvJFss0K5gzk8znj3/exytkyGk/QP1fgv+HTOy6YuGgpK/z/tL15lKTXXd/9ufc+W+3V1Xv37DOSZkb7NrK8SV7xBjYxtsFmc0wwSwLY4X3zJuQNOcCLOUkIPuBAAiYsNsY2jsGWsSwvsrCELFnrjKTR7FtP71t1rc967/vHfapmTIg4Z+b4OUfndJeqq3tu1fO7v/v9fRdWb/JQMbR2XTn6Fm63N4Zcc0gaKapti2Jvxm5KhSUrxJEZeE1BaSkjrEs2D+RdZD54Qlg4AYBEoDMBXZvbNjCkN46Bjn8pjSRSVKfbjBT7nD83jiymBGM9jBHWJnTVJ1h2wDioEOJbO0N75bTvInoORhlmd62xfHgSitoOFHNxyACUzBSYC0WEZyhfuORAF1cN0X6LiytHk/Rd2PLIChb71gWbV3ilVzqRUCrF9Foe0YTOP4eSqGGLXuWEQzhmSCYyqscdZr65STxWpD/usrXbnj6MtLiw1zTDxiMp2e4UMeiALaYezlVQwlp1yligb2szXu6xcnycaEwTjUc25NQxZD0HueXQadfwNyTR3hCTmwcNgmO1Yxi/c5mNR6ZIS5bLrD2D18ybhoGIpS3RicDfEOiuSxoYC0ltC3GEoVLu0+4UiLqW3ZH5BlGL0dH30Ptix559nDp9guZayqE73siJ088yGuzm4PU7CMMuvuOTRA5/8Sdf5TP/80s0RiYRRlsvA4EdDhlNHPeRjkOlNoZOUyZnZtlcXsQPPKrVCR579AxRZ4tS4FIqBGitifptnnz4SwglcFyfft9Qm6rjaM3O6QAhJPWyS5opXFeQhi3i9Rfo9ee4kC1hjCZLIlbnzlJtTLG1tcmOHbt46FsPMTm7AykVSRKjlML3Xdjo8/TKC0wURzj86OO84s1vpHnmRU6cvcCxhTX2FhrceuOrOX7kCGOBT2m0TKd8deKRzq6MyhlrqL16B1ROQ9TADsbCHFfrGwqfrvF7H/koN3kql0LbBJE0VwBs6JSiEOz3NukZn3urx/hOZw91p8fe+gq/vfJ6TM9aQuq84KgQxGNVytI6azmhvZGEhv6UPUYmJTuVNnnOmdeUpLHghJ7G+vQKiguKaMSQtXxmtq/z/x1+C9dMruIITSv1CVRqu8s1RflFuwlNP9rnwvcFlC4aimddqhcymvsUazcLGi9okpLFmq9GdSZCidORloesHJzdHXi+gtDWiyLcmeLPefibUFrUrNwh0W7eFQ9UY2DhAWk3I+NaypyK7Ng/qduBW+aZYdfn9ASJK2ifr9HRNfA1uu/Q67iWtZFIhIC4ajnDaQnMxaJNny7bLssb7xH3XRaOT2AqGTKWZGWLJ2clbZkgxsqt9UyIMYKW71izoorGFDKc+QC3JUgrBuoZ3kSPZKGESATemroquqFQmt5imeKcorsrpTTRJT5RtfJm39A+kOAvOow+qZj49hobtzaGSrthYvfgtXL/Y2utaYvxwPvYSENSsZFYiHxtx1Ky9QJLmwEEGlwNPQcRZGQdS14eiGjiEY3Y8FCx3TyTekYSaISjmV9ooEY0qm/524VlSVJiGAIgk3xQXEnoFRTuukNW0RSnO3RXSvgrilYpoLh3i0i5JLiYqsZ03O9id/xj11UV5aMvnqNU9Di4fyftzXl0tE573aUxNokjMm44cAevvfedXLf3BqrFcSDN/6A8nDOL0WmM40krpUUgXY+LF86zfXqCLO6wtDiHV/CQQKFUITWGzMRs27md5dVl4jik2e2SphnZcoLJNGG3x/r6Otu2b0MIH88t4xcDpFSQZmwunsdRgMnwXcPm6jJkCSPjY0zNzlAslsi0Jk0ThBJs2zbD+dYJzsVb1LTk3te/EkhIVIO/f+AxXv2q2ymYlFpguOHQQZ45fZJrKyMI/+ociWrHFWkRO6xpSlRk8DcFUQMQhtb+jPe97Nt8YOTb7HCKefDppUin0KS0dUYl96kAqMg+9zVv5bXVozSzIg9vXUfBj+lTRBdtHpDQ1obSX1PIyCY4yxSCVXusdHqGwrqmvU3BgG5UYCgF9lbzgY6xR0x/QxBnDlujBa6ZXGUyaJMYSZi5OEIzMt2iu9ZAbdrj5dwbglyCLNj+wBYL99ZsxE9gWLtFUDvBMLT0Sq/CgqK3I6Vx8wbLS3VIFOmUBStlJCkf9QjWDb0pwfLddih4uShjEFgqtEArbAJyljNeChpKKUE5or8VWOlyHkOUeZbbqmJbaIyUYKxkW/Rt1qMO8jw+x0Y1DaAI2ZcQesSeyzDJOi8yspcfrS9jfmRFbVPguwqnrezvzKzBf9zQZMVc5RdJkthBBxrhCrKKuapOWS37ZJMR7t1byFaBNM3hHsduTuUTLuPPRGhXsvqy0aGv9dAZb0Bpy78fZO8ZBdGIhZZ0wVqpumtWFo6wvHVn07EudYGxgQBYLNvEMqcXZhhXQGhFNSLndIsszzI0wh4xPCvMcbqWO61dhs2KkZa7bIop1Wqf3lLddsiepn+hAoWMzLfS+vZGiZGxNs3QgURZpkb7pb2qr6ool/wyCxfOcPTw01yzexaVhFyYP8nu7ft45umnecdP/QtuOfgyHEeBiDBYtY3KV1oKQ0ZKkmiEcNA6Iwh8gpLL6QvnaK8v0m5t0O60GBlpkAlJom0xj7otKuUSrVaGqwQ66dPutPFdF0dpyiWXNO1Tr1eQjiSTDkK5OK6LFD79bpM46pGmEa6qMjY2xvLKEm6hjM4U45PjdLs9qvUqnajJc488x6433sHpI8+yEUYsNdd5490v5/ipY+j1Pk8cPs7WRshYWfCGd72ZcL3JieLa1SwvacFSwsYOpzT3esgM6qdS5u+VjB4R7P3gSf6fsScoiOI/+vMKgQbaRiOxydKjsseE2+a+jVs5uTXOWqdEv+vh1iOMERhjj+Cm55AWDW5mqUck1n8282yHmpTs0C2qX1JPGccMQy0H9pIiNxVPxxLSlRIrfkyqJTePzLMSVdhbXGUjKtJ7osbSXYqRo3bKXVjXLL1C0DgW4LYNM890UOttslqJsz9UxW2B177yQV//QIha9lk5OwrFFPdokXR7MixyxRVDd9rSDy83DBpcg6RpiyVf8rNQocBEAhO6RJsuSlta1uCmlpaUkDuz5c93GEp5RWKLg/0lXDI4MtjEZZ0zbfKOUkTCFnFpi71R9ggN4I2GJGsFcDVpLcNUY0zbJd0bI5d8skqGLKaIJR/d9KBot27RU5h/Avd8qcvMhphY0moVUI5GnyljRlOEn+Es+IwdiUEKehPOpbW9bH8dDHxteKmxMGcmILYNgtCSLBQgFKp3WYJKYhCSIaYuQmkNmBJpedgG6OcMlCz3sMgLsvVKzlUn+XtpHENcs/CFv2khu8y3r5/t7UPfIUkVaSOhPNqjs1GkurtJc7VMOhFTrvfprJRoNks4fopbjogiF1P9HsZBvXr3JM36COudGaKwwPziPG+4cxvPP/owN0y9glfe9ipcZd2hLS/Wnjc1II0m0ymCFKENWqeYLEUImJjYgasXKbgK5fgUCnWMUsRhBJkhij2KpSrFWoNGHLG1scrW5hrtVhshNEoaRsYmwCgcv4g24BpBGscov4BUGZVKiQ7WZAapmTt/gqmpadKoh66M8HdPPkKUtHn80W8ysn2avXcfREV9XnvwLi5sLFE3hge++QCvef1r2dhYYscdM0xWJ3niqaf4u6eO0On02blj+9UsL51rE/pTCnfLDkL8LcPiyxXjTxvaOwT/aft9+OKSDaD8B+eiQXecGQgRhEYhheGV5eMooSk5EcecSbYKAUoYupFHZgRx7CCLMXHVIYwVYtPFa0rczgBTE4S5F5AeSHJFPiD07QAsLRtAWmWYhOCCRziV0o9dZNHwV4dvx0SS5x+/ge60wNxiu821W40dqDiKbd9ImXu9h78hWLulTDRSYfKJkMknMtxWRmvXlZ+x/TMB0YjGW5cUXvTpzhiqR13SEpTmDZ1tgnA8d3nLsePLr0F3J8Mc1pAD4xuTp0sL6z8xEBsYhkb1g+53wFUmEUOhw7Ag5NDMsGjpPNzUWAtRmeQcXWVwOoq0nlooItAIpZGuZrLeZuOZMr0Z2/27C0WKHYgaDunOEJFJdKhwMoHqCbx5RX/W7hrKu/JBn3esYLnfkaAwJ2ntTyifdAnHHPZ8rk04WaAzmYuNBsV48O+Wg/9yS04PtLSnEaPsiU1k4LZsIdXK/vDg1CRSgZPYx0Vi8XWL6zNUQH7Xe2pyBaRrT0Iisd9neaqNt2VhjqSihqKitJEwWe/Qfm6C/rSCgqZ3rkqwJWm16lBP8Esx/b5nU9IBc65Er5bZz8XI97Aof+3oI9SKRW6cfStSbHJh4RRrS23e++af5cd/4pdJnYGJqUFi0DpD5jxsrSOyLAEkUlkvc6kgSROarXWMoyhVxwiKI2yub2CcjGaziUkzwk4Hzy/QjyMcr8Do5AzCcSlUR5BSEvX6bKyvUS4GFIIyYRSRZppSqYbvBfTDDlmSIqSkUKxgHI9yEGCURJqUreXzPLfwAucXz7DDZDTXFqlt207n/BLPVjrcXJjhgWdeoFIsIdYUO0avo+d2cETMHXceYHpyL1HsML9ydYq++jO2SHT22mN1+aKisCpY/4Euz77y47ii8F2F2MIX9vuUjJ62HwhXYJ3hSGkbh2PRDL5M2BusMu1t8UJn2rq6dRokmWJDFyl4iS3OrsaMR0SOR1KWQycyf8MS9bPAmowLbaXd2rMxSNZG0pDmOFwWXOpAzq038M/5FBdsZx2sG/qTgsKyQLuCcNww/VhEGlgObThuEyEQsHxnQH9SIxJFYeXKO+XkGiv5jSYyKrc1Mc+P0rouxV9TdGdshzw8Pl92GcHQzc26jpnB4iNzOMHpXSqaAFkejaSGGXrkpvlWhuv0rZR7kBWn84w8qyTL/wZpebSIXJCiRI63Dmh0yjIyImlBrC3F0oUCyZ4EtED2LA4ajRobJ7UQWJe7piQa1aipPtE2e0IiE3jHXtrz96Wu0l1rZM+Oku3pM3JDk87zU/SmNMVFSThRoDf+3WVn4FFhBhubEKjEDH2khTFWDq7tDMXfyOEyrGBEewx51SaP0bJBqJb1oT0wufBuoLy0Dntm+Dm9HD4xyq71YF7itiTasUNQ49pjyuqxMfQ1McLRqGUft51/ZqTBn/OIRx3cDYneHjMxsUWv6hL2bQejL/7jJ9vBdVVFeVujxvaxW+itPMfq4hYH9u7jwOxd/Mj7/hVCOQgu2waNwegEgURrTZZGxHFMwQvQwpBlGQgHhENjdAoHheN4nD51gu2797KyNkc504S9Pg2vQJjElKtVOp02WSYZnZohSTPiKMbxunh+iajfoVQqYjAUHZdOt4cfuEgp8AoF4kQhXAfhFvCLRYKgSKQl5XKZtBMzHtR42Y3Xcv+zj9JZbZHEKTfvP0gjLVCfrLBFl7Se4e1wOHX4Aq1zHUaLRdpmnVqtSqPQuZrlJRqF/nSKu2EL0NY+iHeFPPaKP8AXhSEdCxh6HrtCkZiMnkloaslo7lQXGoMSoIzhUHAWKQwlkfLnzbt4++izfKe7h0g7rIUlCrWEbuJRKYV0ugHGCJyx0NKvIoXuKTLfihpsyoXEOBqnZ83i7c2VZ8Ape4OYQoYspGSZpFbq0w6rJGVB+/qYxndcvKa1Yty6IQXH0Jv0bB6bb0jHEgoveJQWbdKGVjbgM7sKGricC/IJv6D7+BjZmGb6WxIVaRZfLr/LLGjQbQ0LtMR2XYPv82IqMpu7Zz2JLz1u4QmDzh3jEDlsIQaTfJM/bgULUoMZdMa5Ob6Rl/36RDBIEBHkdL5YgBRD283MN6jYyry9TWm9IW7skfYdnFV3+HfHB3voLQ95oYjftB4eadnQ33nl5hdr8zVUweB5KRcPT6PrKbs/o/FXuqzfNmLXNv/oWpgi/+coa8Gp4pxeqC6toUyN9a/IvYzlwAtjMBjMh29GD0zoB++bZWwMEl60sayOrGALrzVwygu6wP7cYF0Tu9YDZaCKBVlgmw+ZCHQs8c95pEVDcPsGWc8nXQ1yJzlD6eYNmpslVlZquBc9dMFgJiLM+PewU95ZuJVvfOmr3HvwbpReoiiv5yfe8yGEqqFFhGMcq5rShjgJEVlKajRZpnEcjedIpHCRTmqz2KSL5xXo97sopYjjmOnZnURRi2qlTqVUobWxRZRmlIUkTvuUylX6/R7tdov6aIMoTCgUQqROaG6usra8yMhIg61Wi2qtitEp5XIZYwxu4CM8D9+vUKmNolF4xSq4Lu/9vnfT31jibx/5ArXRUTbnlthy+jx7/+fJdkyz485ZzjyxyfNPnOB6uY/ls4v83Ps/xO///u9yzd6dtNstZmamrmZ5iUY1278KK7fmO7tv+Nt7PkZRqP+tK27rmMQYq1w1UBRQkgYXiSskkgxXSGoSlrOUQBia2uGNledYzars9lfZ5m1y3J2im3lIDN3MY7VUphUGbHUCGvUu/dglKrgYINn08dYUcV0Pea9C29QIDBhfYByN8DWlqiWLVgohgZMy+qazLLSqlL81StiA0qLtWqb+TtEfk2wcNDRegPFnNSvCpTKXkfzkBqU/GqG9R+G2hY1gusJL9QXhrghn1SMpG6qnJWs3mzwN2Vx2s19WjE0+SEsv3cQDrNKovEPLhQU4ZshdFqnIIY1L2LTJ+cgM7D5jKzBRffs8mQjSqkbmHFvEoAgZJAy9NSDvrHMog6JBRYLikqA3ZTm94YS2GHHLo3TWsSeNvCju/gNBa5dCxYbWbpF34naAdqWXu+GQTCSEXQ+lYeqbinBU0do1MmRKGJV3xkoMh3kyNbidHEbQdt42NKx3rLm9UbbzHfghDzZPGdshnJKDjQ5IIZqwDBiZ2WI9KMBpzsCQOXQ+hD/y5w7eA5FzEdMgZ1x41oExamhkTxLujHFLscXPLwZQ0aQFg+oqxn4rwN9l1a9hQ9CfhDiViH8iUPmqivLSiTO85u1v5ZHHvs27r3kDb/3hn6Fcr9qtCAVGk2UKnYZE/SZx3EabDEfVKKkaricAx667SEniLmliGQBRHLHVWmJzc43GyBhpYlhb36RUKlEuuHQ6XQKvgMkEvlfk4sX53MrTUCqVkVIRlGuMjTSIwz5T09tY22jheD7ddgs38CmXijiug+sXUVJT9H18z456+2nM8+dO8dTT59hz/Rivu+0QE7MzfPnvH2FkYge79u1jtrzG9x18HcIbR//ACLfcdoBD172C3//YfyRVgqOHr2Z1oXxeMvcmzdjjhrU7Mz7yur/iWvdSezjojnsmYSFTNHWANpKijPBVRE2qfKhqh35bOqOtFSBpaoeT8RRHetu5qThHT/s8297GtqDJqNfhYn+EmtsnzhQVN2JtoUbPzcgySbEYoaQmLUb0R3xMpDCTCboZ5DaMjnUuKyYoR+N5KVJqil5C2bNdQjfxaJ4dYffTEQa+BkwAACAASURBVBv7fVYPZRQnuziP1OhNGsSuLkuNAnfccoprnYjJt7X41Ymn+JPf3MXvfeLtANROXDlDIK5pq3ybDik/XbDihOBSegfAILxtMFgjhyEup8ANr8t4y2Cfo7q20Grf4HRsgrQRDH9OJFad5645pCVb3LOChS1UbHA3B/4bILsW4nD6kriu0fnfKmPbUZuBACa2J5jOTk3ljKS1T1O6KJGJT+9Qj3DcenQ4XcHEMymt3QFuTzP/pgyvEhOvBxQmehSevXLmULY9RGx6UNVUz0BpIaa517drexl2PIhwGhRluISza4chzm6kQGaXDOy1kxfhyLJwgjXrhWGL96WhajxyKdxWZNavYmCQ72/IYcesQmt967YFSS33owZE/1Inb031baHuTxgKy5LO/pjgvEdadgn2tuiXPZy2pLAsmP3yMrpaoHqqy/m3Vkj29G03D+y4T8PP/p/X76qK8p63HeLENx/izut2Mrp7F2PbdgFmeKg2BjRdlErJ+m17JBM+5ZqPES4pGiEySDMcJZBCUAg8ktimTlQrNaqVMqvLSwjhcfDgQYzRbG1tIGTMyuoGzc02QaHK7l3X0e1t4rkKoTUmM5SDIsZX9DtdDIKxySKOX2RkYpo0jnAk6DShWCihlIvn+yAcgiAAupxcOs5P/cI7caI2Y9Vb+eKX72O1GfFTP/Y+PvPJz1EfvRZv5iDX3bCPxx98EKe1m93XXE9QnGVpYYlnjhy7muUlurtN+YkKzQOG+myL1xcvogmGHbJG2wgmIdnIisRGoZFcp1q4QqDzSXJkNL6QSAOTSrOlLca/111hV22VR3vX4IqMn5v8JgAvRLNIDIe3ZplrjVANQmZ3rLPVD/CcBG0EqZZUgoiil9Du+xgjcMe7+G5KOiqJYwfH0aSppFyIcFVG2bXS2rrfp5d6lC5K5n46IUs1k402/a9OEKwbXvYjz/LIX9+KbhhuqV7kFxqH+efn3spqFvHj1bP8TtlQnBeMP9O94rXVI5ZpIVoecQXSovluDFnY4ZhxDLqSIoMM3XVslJISiIRLEMZlWCQi72JjaQtLYGXSadli1NlIilNISSOF6Di4TSsvd9uXYAekIakZm1KCLbQDR7ikbHKTdzEMelWxGOKymWeIyhrjarrbBP6GpLs9w21Ldn/M0Js2bF5nceTFVyiS8QS16bD7s9DeVqKzQ+Adq9KbvuKlpVwOacUKMokKoTPr/YMNa+BZDOGYPWH4mwKTQzjDE0UOYQhjhURG5vviAK8XNrIpLdoX7k8YkqpNDnfbgmA1b0giOyjMLb1zm1UrK1d5EovTFxjXFnuRXcLyrSMdQxZRf0qjC4bISOsoWLKnkZ3/PiYZjTCOpL3DZ+WeCeKqIFgz7P78JtFkiYuvcXFbgsx/aU+cqyrKj9x/H4EM6KUxP3P3y/G1xboGn22dZejUEMdtknCOuZXTLKwu8fpX/yipcPF8yz+WaNIkQWchSZwRxwlSCqQ06CxjpFEhCRPiXot+v8f8/BwC6Pf7jI6Ooo2LlJJisUQch4S9LRwl0DpEAq4jLV6casI4QWDQScr8yjKNxii10QL1egPX8/G8AkIo/Pga/uX77+G66/bhGcmZ1ZPc87af4OTx4zjdNr/0wQ/yxFMPs/Tkg3zl85/kF//DrxFnhr/9/KdZacEv/fKvceHks1ezvBQfLNv04q7g3+x/YNj1DrDk0KT0dEZTS+bTEb61dS3Pb0zz8f2fxBOaxsBLAWjrjMjAlpY0tY8rMqTQZEZxY3CR9azMUlZjKanx0OZ1AGyEJXbX1+1rCMNYwaWd+DT7Aa7SJJllczhKUw4iwsQhSlzraZBJestFZCOm6CbsqGxQdSLqbg8lNJ3U5/YfvcBPj3wHVwge6O3gtR8+zx9uHmIzLfKB932FP3rxFXz6zG388Tdew+F3fZTESF575L14W4If+ODfcf/Fg1e8tt6CZzHLPK1C/yO5dGpHlzfsOc4LzSnGCx1+dPLbfPiJd6NXg+8q3gMP4oF3r8nVfACiZx3aUAZSidp0kIsuXg552Bgoi1/aI3zOBBiki8TWzN4kYiitxoAZSXFW3KEPxMAoxwslqg/jhzVJSVM5vkUyViSuOVx4U5G4rtl98CLNfkA/8theb7FQrXHhJxUv332CI5+6gfJCRuuaK15auqdquKkgLWqKKymd2bzMXLbEGzcZxq9dJQl9Jstd7pk8yWe+8GpKF/On5vCRyXXhOpc3a3mJ+SJSCwsYx37ttQReSw1ZL4OAhwFH3EiGQ0GL11/ywwBIA5MLXDKKCwoV5j+r7cbgdkHFkoknuuhA4W70yUoeqhOxecsone2S6LYO5oI9FaSVjHBU0ryujtnVZ+JvHIL1mIVX+C+5fldVlLPIoT5VYP1wi+n6flJPI0yHuN/Cl9t47thjfOyT7+HC+XVuvfZ2XBPz2INLPPfmM3zow7+HyWwIapqkpGlMkmUkaYSQAs/tofDohTFJN8IRKf1uF4OhWqoBgsJIA98r0m33UMrBoOn3FL4naK2v4zmKfrdPoVTGCEkctkjDHmE3JEwFU9PbGRsbp1gpU63VkVJSrtYQQjIiBf1+l29984u86S0/yI7pa3C9hFuuP8jff+VBHnrgc0yXGxx4zfVQdHjkc3/A0tJpXvf2H+O1b3sXvh/wjU//Abz7A1e8vjKFcNQ6v90VzOELj8gkLGcpNSn46PrL+MInX0VlTrNx0B51Z/4+5vvf+GG+9q7/Qmg0LoKeMbS1omscetpHCk1FxLho5rIiS2kNieZMNAHAbGAN1vcU16g5feajOm4e87EcVSm5MXPNOr6b0u77VAoRAghjlyhyyXoOpBJ/ssdsY4vpYou9xTVckbEvWEJhUEKzlNT4yZM/zJf3f5HvK16gIn3+9ejTvPf0O7jv4TvQtYT33f4EX/Ju4A3PvY/l5Tr/+eV/xctvWKChfD51/6vhzVe2tklNI/uSypygs8MMs/JEZnm/znifNFH87RM3IxLJhUbEsw9fi3dNm1AYjIeFLGKBCi/L4gus54LsDriwBqfp2IKq8qP1wEOZvGtMQZdtAZYD8Ycg90+2r2mKemiH6V/0cOYVUcOQFs0Q47YGRAZZFMy9zsHf0+K/3vYJPnT8PSwsjkAEM98QbBzbhv+2FZp9l3NzMxYSKGQ8vzpN69qMrZs023dcOcc+q2WoZYftXzWWiyzzo39qiKuCzg7wt3VYOTMK5ZS2m/CJh1+JOxjGuZafLFObiydz2CMpCdJK/lqx9adweoM1ZUg9TINLg0CZWoe3AXY8EH+ozK5tWjJkniGtZ4hUUJhX+JuSuHYZ31lYo6/Ms6+7dkuRzg74w3f/KR/4wk8TrJbICoZtD4YkRwMuvidEzQeUzivimn2PdNMjqgqae31e/pYjL7l+V1WUi36K6O/m47//UXrxOpVolE9+6qP85Zc+ym23v5IXn3kGt1pm+VjCfc88w84D04zfBOutOZK0bb1HvQLK9VF+QEE5IKRV9gE6DSk5HXCW2VpfIdM2qtaREWEU0tlK6QhJkmb045TxiWk67Q6OI6g16mA01UoFIxT9fsRWs0XU63L82DHe8vYfwi0UGRmpo5MUZaBaqSAQuK6LUA6+X+DOO8dZW12mUW9goj4njnyV1fWT1Md3Mb13L195+IvMjh2gPjKF2ubzlc/9L4q1B3ny2WcpiSs/XoNNOBAa/tt/+F1WtU9Jxrz84Z9n8q99Vm+XjB4x+CVD5WyX+vMxWwfrNPe6eE1B2zi0DTSklVjXHHAxKBHlr67oaU1JbuKJjGfDHYTaDnccqdmIS6yGZaTQhJlLJ/a5obHIYq+Kr1Jma1sATJQ6SAzNqEBvqwChpHrSofJ9S1T9kH2VVfp5yzIoyHXVxRUZDdXhxt1zPBEZDniSto75yMqrOL02CmMRN29f4I8ffxX1iTbb6038mYxf/ta78Sox6kgZ9yqMZ4Mlm/mXVCAdTfjYvZ/knqDJ03HAV1s38sjKXi68OEVxSZKWDUldwK4eaaIIZrr0V4qWjibI+cNY6lkscLpqCClkxbzryzvqAcaMzjvsQGPcDNN2UakkC/TwdYFcuCCJxjLLZ9ZimJKSle2wKfMvtaACrEJNQ3Suwg8v/Eu2f9UwNq4ovGeJ5ZumqJ029L82gb4uhYKmeMGhP2PYXK3wxruO8PXj+2l+dRrecGVrq7YUY0dsqOnWPvj193yK/d4y/2nhTVTdkK+fvpb+WpHigiIcF7S8IuVtLdrFEkbY5GoVDuiHFgYF8Fsav2ULrREQVy2F0iiLLQ+GsyKDuGjIckhKhdbTIgv4rsRxt2Wx9bihrWd2SyEziOuWheJ2cjqduMSPBkvZK83Dz/zFB9nzjZCVWwpMvW6e1plZ6sd7FJ4v0ZvNMFJaCEVApiXtN3SJWz5PfPYmOPR/Xr+rKsoj3m5+69d/mz/6H/+e//qRP2X33jI7rjWUawWe/PYFKqLM2rktDuyqUfZ9GjvHeeLpNo+ee5ozJ36ej33s10kCj2ptEkf6IOxI1hjIZIZwS7hOmZHCBCNjCVncI4l6xL0Wp068iElabLU2cHyXJIo4/WKTsclxCkFAlmU4nsLEdkrT6axRKQYsXzjDm9/yFoRSZFlGkmaIVIMxdNsd2ykDSgqUcJCOx8ZmkxNLZzmw4zauu/adXDzzP+hE85w98h3aKzHLyVkmZ6a44843cvHc75N25nnHm+7mhSNPXc3ykpThsx/8bb7/S7/Egd84R7R/lpE9PlEVJp7UaEdQnk9p7SuR+mW6M4LxwylT31jnX5z/EP/3//sXjDst9rtdXBRK2Ds9MwYlBGXpUwamVcIh/wQdk7CeCZazMn+2+gpirVju1AjclF7k8eDZa9g5uknd6xNrRdGJCTNbyDd6BdxijFgo4b9+FVdlZFrSzzwiy/DnbDTBPt9ytz0yXJERiIznohm+uLWdHxt5jF8c/xYPL+2l1yxw+MQO3DWHpqlw/fgS/37Hfbxn7meJey7Xve48J17cduVrWzHEI4aPvf1P+HLzJn7pc+8nK2sop3l0D6hEkFSM5WIv+aSBgVpCuRTS97SVSEcDJoZhQGnIgDQVl4kR8gHcut1FZHoZX7ir0IGCQkZas57HMucny0iQVLXFo8E6ji06xA3rizGQVqt+3in7l5ggkGOjKczfk6v+Tk3gXNNl6tUrPH9+BnoOzpay7AxlaEy0ePi+W/EktK+7CkWfhPXrJT/6gw+yENX5Nw++B5EK3PE+OpNkiUT2JP0pW+XS0KGbCQrVkKjpkJRtWKnTy9czp75lnhjiu5jcB6OrbRr1oh32CQ2d7fZ5Ttd2t9qzQz8b5WUZGCq0HbRxLVtIBinBijtUp3pbAu3kv0ObvHvPTzbGQAb+pqAz44OAs/NjmFcnrN7jABFyy6V8TtCbtYPD4r4tzCMjBBm0d7+0u+FVmdyH5nl+6hdew64DFeqTBVa3CvR1heefjOltRBSKZVr9hKeOrtJ1BEkkycINtu+ZoNVa48TxF62/hEnQaQ+T9YAeUvZRSiDyaXcmwAgP5VVxCyNUJndw06FXM759N6n0SFKIo4Sk32Jj8SKri4s5QdxD45IZwUi9ShKHeC60Om0c1wEhkFLSGBulXK/hFQKSLEWj0VojEWitcT1FtBHy+OFP8lufeRPPdb7Emn+EfrmD9nze/IMfpLnW5CO/9ot88lN/zokzF5i7uMyemd1Xs7yoCH78Nz/M2O4N9NQo7kYPkcHY0y28ZkpSFLjdlJFnN6xkNwGnn9G7poHfyvjE4t20dUBmDB2TEJqUxGQoIXBydaVEoNEoIahJjykFh/yQ35y5n1eOngYgyRRR4pBEDufWGry4Nmk9AvIr1ZLpSpssUWgHtjoFfGXBTldm3FK5yL5gmTGnTVd7ZEYS578/MZKK6nOh3+BXLryde778YVYXa9ZjOO9oPnLP5zjbavCTH/9Fdv+lITjrc2ppnMps64rXNpuMueXQKX7+i+/nW392J2k1wwQZbLkYAbqSklYz0qpGVzLSWoYKBaWjPpuLVYsPd/LbxzFDXwdyQcigOGYlTVq2vOW4bkgrtsstzQmKC/KSmCHKY5IdY32dPUM8mtlBVE7fCpYdK/tW1iRfGFtksoKxXg++lVsPaGc6sAkneiLmg/c8yN79CxSChFYU4M75VF90yKYjnOke1ek2nV5AuDeym1D7yt2edCnjptcd5xMvHuLbf3Ibbj2kvqNJEjqkocPYWBvTSKxB/2yHkbE2OlKkJyqoWCDTSwnU2rPcd60E2skpbDk+nAaQBnnSdEEMqXD1k5riwqUOFwbKP/uYVhBX7f9LSgaRStyzAdGoGSoHAdyuhUiygiDLHfZkkrNkPAEamtdKbnz3UW7bc4GZmQ12bVuj/KLPyAuC5h0x8UhG2kjpdQPCccuNdjovXXavqlOujlc5OrfAU888xqFDo/zd4RWmr92LM7JFspqyvDZP4MyiK8c5ciajm80wd65PpNscuK3Mx/7wL/jvH/u3NFfW2FpNUJ5gZHyE2vg+0C5aaoR0EELk+hOB8gIr0w4KXLv/Lvbtu5Uo7PLgg/cT93sUSyXCJGZlbRmDpFaoc+r4U5w5eZixxgTFUp2o36ff7WOEgpokBYJCmTRN8f0CaZIgpIUwXClpVOvMjq7wnSNrXFw5x8p6h0q5htq6yFtvfC0f/+//lkOvvIuvf/0hdu2d5Z1veSOd9RbHt66cRwvWfKV2LmPp8Bjpy2Di8RbtnYK0WMVrG4orGWmgkGWf+okeQhcJzqxBkrJ11zbm/2wP6t89xMPhLC/0t1FWIbcVznGX3x1KsF2hhiZGGkNZ+mg0DeXz841neX/9KVa1w08f/VHWIpdSISJKHE5vjAHQKPU4d3qS8ikH1bBHxixyaIYFhDBkRpAYxayzSUsHTKg2LR3knbImEBkH5Ro3V+f40+MvI1hy8NctrKAiCO/o8quf/WHG7lxmxwMttq4tc+Mbj3OhNcLq+lUYPm25PP3MXpxQ0Louw20pkhrWEMizlDfVkbkfhRVgaNfQ3ZEhfG1z7QRQSyx3eN2zJvFmoBSzN63MsUuTq8e0tMff3rSFPKonJU7f0NpjB1aZlxsSuQYyQTpj8XrtS2KcnJ2QDxGzy5gDEqysPffjMLZLF6lArHv8yeffQBYY0mpGO61CVfOutz7Kic4ET53dQepkJCsFRD1G7etQ/Ur5ipdWBBlPHNsNypAcihALRZpjDnLFR09GNNsFe6pwDP3FMv2c751MJQSVCOdbFRsmMW4VMsVlqx4d4MdDifqAPpcPAYW2hTb1BSqGxosGt6tZu9EZMlXSkhk6ziUNK1RShZQkCnD6YihWGdD3nH5Op/MFTmiGxV3F+XAXwbe/sx9dzHArMUIa9Kjhuu8/ye1+l8cWdjFR6XBueRQ9G9Kage2f/h7ylGsTDQ7eEPGd545w2817CJ7vUnYrbBrDSn+FKPG54dY2xLN0O9OcPrXK/ptLTG0vsdUKed+7b+Hxh54ki7cYG51m1+6drK5uIJwNqiMzSCGt0g9p3T6FuMRaEqCVg3JcXCF4/RvfwuNPPMLGxgZR1EUmmkLB4+SZwywvrvP84Qvs3y/Zuceh26tQyVJc36VUKZMkCa1Wk0KhhONIHFUAKexmAERhRL0xzfaZ/Zz86w0OXLeTfnsT3w/5j1/8PRrjExz9wkXuuOkW3vljP8YLC00efegxrr1mz9UsL3EjY/2Aw9gRzdpNgrHDjh36CIHXyXD6GWs3+ojMwwkN9ZMRrVun6Mwo3LYhe8cGv/Li24kSlx0jm7x18jme7O2hIo9yg2twhSIyyTAk1RWD7jn/HkVD2ePYn1//Z/y7C2/n/FYDre1GVvQTzp2ZIFhyGHsuZmO/R3eHjf2JU0XRS9gZbNDOAo5F08y4mwQiJVAdpDC4aDIjaBqPm4ML3Di1kwufrdC8Vg5vwJlPePTGob8wSf9OGP2hixxZmMF/tILZe+Um9zJnNaQzMc6CZwuxr0FbwxpDPq0vZ7jrDnFdD6f0asVj9pZFhDCcuziG6LhWzWiwJj+9S13mYKD3XRzdHFMWBtq7LVPDX7cFIRyzJvZaWNtJse7ZwWNL5d4ZYvi6g0ACrWxXrHpyKFcWWGqeds3QHEqFguKiQ9QwRBMZf/nNV1ioRBrMVoHZFzKiasDmfui9uX3Fa2syCamkPt6iuVbGBJp9s6tc8EcgVaShi1z1yCoZqidJK3l0lJcRz5WQ926hlCa5WMVfs25uTmi7VmWZjEPxy9BhLl9brS4JdNJAENUUpXlDUrZcZONhg2xzm1RZiWC+YC1wcqXkwH9DJnYDzQrghDkv3Fw2nHWguGRASOSKRDsu4VRKsKfDUy/uRsQS2Yg4d6zO3s+0iCaLrN3oMve6l27Wrgq+eOHISURrnL37DrLc3eC9//wGHn1wg6V5F5nOcPurdzO7+wD+xF7OLh/FKQg6gUM/EGy7fhd//Def5ld/7z/z/p/7CKvtdZY3ViwVjh5GJmRpnzQNcRyQQiAEGGPo9/uWDS0EmdYox8VxA2646RB3HHolhXKDkycv8MLzp5hbXCExHufnN+klkoce/g69MKQfhqQ6o1AsMj4+RrVaZWSkhtYaz3dwHQfP81BSUigUKJcrXH/gTvZM3MK4uo1dlbu5eG6UX/nxD3Grt5/f/Y2/ZM9tb+Z//tHHWV5b55qbb6dSfmmN+z911Y9ai8fmXom3JTj1voCZv08pLWcYIVi826ezUxM1oDKXkgVqSCXaugbUXzeo/06FHR9YYKld4dn2DuRldmcdHdEzGb5whgVZo1nO+kNIIzEZRamoS/jQ7Ff5v659gEoxJD5dZfNYA3/JZuUVzmygYsP0IzaJoR95pFoy6W5xqHSa/f4i13srZAgaKqEiUupSEwjNlIrY627yc9MP0t5uJcH9cUNpwbDx0x36k4Lf+tcfZ/PGjNafbSNaL9A6mGDKV56BKIwd9tF17A02KJR5XJDqSXTZuqgl9cwO7vLE6bSaceHEJOfOTeAGKbIREU+mZLU0P3JrjGefeznLYni35fS5gYzYKEN/ShPXzTA26lI3bH2Rs4KFUXQ5s7aVkFde+6XqS7Rv8W+jLhssatsdJmXLZmgdsFixSKzIxCgD0xFjz6UsvjNm40b7d0cXr7xTBpA9SZQ4iK7CbYQsblWJmz5Zy8VkgsK+LfbsWyKtp0NOuJQGxiPCvmf/WeWUcCahP2ndCDPfMjAyP3fWGzDtJEPjJjGgGg4ey6w/hpVq2/dZJAJ8jQkysqZHNhaTlTTRiLamTmLQeduvVWzQ6lLu39BeNBcauS2IRgyNly8htCDqueAYCvMKdabAjq/FnP6RKpvXWgqjisRLrNxVFuWRYoXe1jGkXOPrX1rj2PEXufNeyZEnW4xMbPHi0RXcdJTHvnkS06rQqCYIXeQbX1qk18pIwgY3HTpAV2d8+9mnWFiep1AoIHSXTnMNqQyCBKMTDFjP5MwWUluTUzApSkqUFBR8F2Ek22a20+smPPf8CZZWOnzhy1/j3tffy9cfegy/MMkjjzzC8RMnSNOUNE1RSuG6DmEY4nkOJh/3GmMQUqKUwmQ9tDbcfP1r2Fot8eUvHGFbZYqvfe0hKsUa3/jy1/mFX/oQtUqZpLPKD77jbZydO381y0tStjl4ANvv36ByUrF0l0PtsTnCEcnIcdspzjwc4fRT4qo9Us/eN4/Ttdjc8p0+JoroPdvgufVpJp0tQuNyIjH4wn6qB2b4UY47T6pLZjQZBheFi6CRa37vmJhD9QUjRwXBGuz6QpP5t0wxff88SUkw9Shkp8skmaSnfQKRUJEhq1mBikxI8i4nAZSAQAi6xiExiu4NEe6WYNeX+oQNgfjmCGkR/tVTP8IT3/87xFVbNH/jns/jz125S1xazehvTwmWFNFkaulQZz3QkI7mic9thboQ4G0oklpm8/uEGaaUeCsOer5A1rJGM7LjIHrKhpcmtrgaVw87L2DIELCbpxlylQeKMyQYVzOxZx3haUr7tuxNXE8QkUREEqcaY4LM+lzkcu4BZDF0QssZHwN12wBv9ZfcockO2Ofsnloj+5k1zKqPs72Ls6NrvbWv8HKLMWY0JporI0ZitJaEZytgbDQSAuLY4czJKcgEopDiTPfQObfbDxJam0VMIpE9NeQUO6GFE2Rmh3qDBHcu2/gG1rGDdbXOcmZYqLORlNmDy1QbXbZvX0fGklItxHgapytIxhLrGxLaE+nl4qB/aN9qHPuY17L88cUT48i+RK56iL6itz0lnkk4/4GMtJqxtT+lvdfOKV7quqqifP78Gvd/rc39f9ViqjLGO37wPTz5zDKfvu9DnDihuPetN9LWa9x+7zjX3DnBk4+GbJ5Y56fe+2ZWnuuSZmssLT5P5ma0zRynLyS8ePoMoQhJ0whpXFwJRvdpr6+ghMB18hRjY8jiBCUMYb9JEveIww067RUSUoK6YnXzFA88+BW275/k0aNPoqoBZ5bWWGn2aa63mJqcIcust6s2Me3OGq2tdYxOkI4hSfoYIUkNOLKAozLe8Jrv5/S5w9THC5w+M88rb38XwUTK48/9L148dpSw7fPcM6dZ7W2AU72a5aVyQTP5t2fY+YUN4rESI29dYOywpvbZPvUTfRZeZ+N/Fu/2Wb25QP3hc1ROtTn1gRnqpzUqNpTntR1oRoLliyN8bvkOW/yMZU24CEKTciTOkEiKIo+uMYa2jlEIlrOYDa3Z0AGnwikSrUhLmuJqxuyX5tm6rsrEUz10tUhlLiJYT/A2BQdGVwiNgycyQuNwLhnjWDxObCSugLZWSCA21hwpEAkfuvPr1M5owgmf2tmU7qE+cVXjPFvmv23cidMzNJ4XnAonbddyhZfIhDVy1xA0QoyE/mw6NEZ3ujb7Li1bLwNnSxEsuMiewmuJ4TDPbVvbN9l20J62uHE9fx11yat3bKsp8wAAIABJREFUwBiAvAsbdMvCDsayksb4BhnB7I51Vo+NoRZ9wufrxI0M03MsPlyLyTZ9vDWHrKhtsXEGxd1ypE0uYrHKLNutZ2VNNKotm6OQu6il9sh+ZmEMbQSFRUkSOcSLJYL5K/e+SPouJlI4PcF12yzbRs70ceshUd/ev/FmYA3ffY1JJclqweKxXZf+ahHRcnHXHdRUb0hFk7GlwcVVizEPNhuRMlDED2ENrWzBjur2+ZlvJdX3HjzO3MVRWosV5uZHYTQiDF1kIYU9XUgl5YsME7Otx4b9OqqLYXjrYKPVypoU6UBjfE1WtRu6cezQ1Vtw8byU4nmr3fY2JO7G93DQtzDX5p+9czcX5/o8/dQiv/mrf8Rr7rmRj/3Op3jVq/Zx8sgKk9s1Sxefo7XgcNsrZ7nplpfx1Lcf5Zp9Uxw51sav+dx0Y5G0o7j/y3/Da1/2X2itnkPokF5zE8eTuF6JQmkCpEYDWZYhTYYwdlwV9joUCx6638M1CaWi4ZEnHyAMtpjeGxDKNfbeup1jR0+x0lxAtwXRY9/hn737XfS7PZrKQ0lBsVjB8z3iREPWR/z/tL1nlF3Xeab57H3SPTffWzkjB5KAKFISqcQkiUotW5bVtiy3w7jb9pLtnp6eNW336u417bU6eVqOaslJGtuyEiXZCpQomiYpkmISQQIgCIDIQBVQqFw3hxP3nh/7omjPTHOmgeXzB1gLwEXVrnu/853ve9/n1RZJEqO1pFWv4+dzDI9UcF2LjFek5DocfeF7/ODJlynkhjj34idY7rfYPlvigU/9Ifd85Cdv5HjJX+mz+LGd5K+mlJ9fJPitcVbvsog+u4/uOwXFM9Af0+QXNdmNhPrd29h4g2DskKKxy2LoZExYsojfshcrhKlHJLtvX+Ol3g6kUJwOuxSsPmXZY5vTwBIuCkWg//5YYCnNMmn12EzzWEIx4rYZe8F82Ps7h5GpZuNgluGTArveR/RCJoMS0YcsVsISx8UMjkiYdOoMWR162iZMzaenp81c+dVonBlnkzf7F/nCYOOe+JB7yWby8RpJyef7J95Bud6ntd3n61++h+33X77us7XakrSg6O8KEStZZCTIn7fpzCkTrplVaC8ls2g40EJJ7J5AC4n/lg2Ci1V0TqP8FLtp4e9t0O1kECVMxFDXhAAkuUHm3cAIcm0scS27T8YCIondMoPg1NesvziGZRvLtfLAbhmEaZLTJF0HvJR4OjZ8Ccw2XzkgEMguf39kcq0p0yZ3MCqZG43sDmzdeYXu2dQPjRHNpOiuA7mEtHv9RdledbF3dshOhJx5eRbtauxNSTgTQWiRGeqTpgLmc8QjMdJL0R2btOXy9oNnefbEbnQxJqlopJKkQympLwmHwF+TuE2jYkg9TEG0QaZG8oYG5RkpnEgFdmCKuZYQuPDUoZtMTJSnsDMJaWSh6zY6m5KpROiWRWsHZDbNa3kNTeKDEgKv/vcRn4ODJckKKscsmnvNktYKJKJnlsRRNcU5VyDeFSEchZaWQbi+znVDnfJPvPXHiC9Z7M1t47/9x1/m/nv3MzSZZWbnLr79vR+iM+skqkmqs3Qdyd632mxGr1LcqWjn1zj4dot7f2wbt7x5jPI2CcOn+fzDv87zh9ZZXq9THZ/GLw6Tr8yQyfggLISwcGwXy/awMlm0hlyuQLfTM0yGGNIopRuEjExPks37tDo9Fi4tMlyqsm1mgp96/3285ZbdfO+738LP+hQLOYZHxrFsjyBWxDrBcVxsxyZNUyzLYnx8hkwmhyUt7rrrPuIIurEgiPK86/4fZbPZx3Z7tGrrXDrT5siRef7k05+8kePlyv05/HVFb9Ti3CeHWbzXJRhNaG8TzH17Y6tLuHZtHhA4LUFnwowx1m5zWHl3wtptGYJRTZIRPPTQHfz5qTs53JzjndkL7HTWOeDWGZECicTGIitcssKlJDOkaObsHgtJkVjb9JRLT7k4PUVn0iIu2DjtlNKlmGDIpbOzxOWPTrD+xizHH93LqNtmt7fCnf5FijKgrXwCbVOQMVmZEGiLnFTc568wboVkRML62xNkbFCNMobLH6zibHZRtsBZ71A+02H0aETrc9evUxYKKsck5Zc8wxVuCbpTA1NBx3TComvSV0QmxauZjLYkq6lfrKKz6dbsV9ua4HQZ1XJ4244L5KbbpDlljAf2YAwymFOLxPzMrJ7EbpkxiAwESV6ZRV5iGAxaDiRtAwB7VDHsjOxlG3fZQSthRiS2JimYqCWVNZpm5WrTRTv6teKhzRKxctosAKPxhNQ30CPZtQhnQ2RfIgbfd+HA5nWfrbY1macKBM8NU91dM53xthBhaZy6RbiaJQkc4kqCk41h3TM2dOC5o3vNgtPSWzAroYzhZvrgCp19EWHFFGK0cfzZfY3de02R4XQ0XkNjhaZ4R8XB6KYuoJiAo7C8lKTlIt0USjHCNgGs175+GZrRR1gVJqB1ILsz6E7xmotQDmRyQOXkQC8+ERCXU7M8FgbQRCTRkSSaikgPvD7S94aK8uTYdt56271sn53h1MlzPPbwAo9/f56FlVMceKfD8opDfdWnPLKH6Z37ePKJZVrtJQpZh+3bJ5k/nvBXf3mUmT0T5CciMoVdPHv4OH/2hQd45onvc+zQC6RBH0trhDTZW2jQCtJEoRJFFCUkCpAWSSrwMlmK+SphL+Hs6SVW1/pcWWggE4fl+RVmR6YI1paRcchbbr+NjUYNISBJYvL5PEonaKGxLEkcx1gDk0mamp+A4zj89Md/Gku6XFpc5pkXzvPsi88yPldmaaOFpxJ27x0msvt0Vm9MEheMJ6y/CTozGutMjtnHAsaflmSXNGtvHcJfNyCX/oigscNh8ukEtw1JDrqzKeVzirm/EnTmUpJKQlQUjL2YMvpln5ee38P/vvghGsrMjx0hjT4bjULR0xGhjmkOmBmOSAi0w7DdYVtmA6uvqJ4O8VcC/AubCA35i2264xKvZpZmzhvrnO4afGmgbWbsFtFABOoJaCuHjEjpKkmgFamGgoz5/Ls/i5aC0nzE+DMNJp4P6G0r4a+YmXZjn1lC+ZvXv+hLSor2NmjtVGSv2AQ7Q5KReCv2Xo1EYJmlXua8R29XhPJMJ6QzKd6yTWbZwqlLwyuuJiDh6WP7cB4pGQJcNd6a96YZoy1WjplFpr7eSixBCZymhAFUXWO4CVZP/j0SndsU9KdSkrwme9YzH/qByUSkJg7qGtLT6su/19FdU4409oC/KpFtC5VNiUYTVFbhLrpbUkBsTeN89brPNs0qutOacEixebGCM9InVwjQqfn+clNt7EzM8FQTtZhFlWNTYIsRViXEWXZx5z30coZgJUdmrIs93Ofq0QlmvyFxOhAMm2LJYG6e+Ay41YPswy0DjcarmyWnUKBDiZNJSENr60aguzbWmgvDIUkloXBJbrG6TWOgcbrmNZRl5trAa4CkyLx2b3wQOtuzwVXoinkPWYsZkBrhKITURJuvDwK/oaKMDum2ewwNz+GLMd518E5mM3Mc+k7K/OEicSdEusM8+sgZXvnBaaruMDumf5THnrpKtpDn6nKbseEhfvjkGWT9IE89cpJmLc8tb9vLrlv2k4iUc6dPsrp0ljDpgoxJ4gCtEqTUSFuidUq73UYKG+F5WNKYQoTr0Wq0aOk+ju8RNhtMZLLsLY5SnJxiZGqScxcWuHDmPI1OF8uycRwPW3jYMkO91iaOI6KgQ8a1CVWLftglikI2GmvsuXkfPj2mhjXVQpVOMyHjZ9m2exezY0N84J7byXnXvywBjBSoK0iGElJXs3KHT1CRjD+ySPXVHnZfkbow8/Am4880ifOS9nbF1BMtdC4hdzWgP2Iz9kMBiWDie4u4jZjV2y2Ke+ooLfg/V+7i0d422ipBIumo0MDysfCEQ6zhQlzBQlOQfRyRYKFRrsTZ7CGjBJ31cJoRcTlDf8TcJPpj0L1Y4tlLO7gQjZIRhtfhipSciDkWDdNWGdZTnyFL09aCdeXRUC7H+nPU94O2BMF4jrDi4DZj0qxN++YhuhOCxXsdUu/6375OzfAqMuuSYEQhNx3cZWcwogAdywGiE+KihkHHqh0jpdIDzSsaopLG2bBxNy3cTYvmOwLEeACJ3DJxXMN+mngoPdBWmd9rx6RaXIvV0s4gkNUdhH8OXqM/neKtW3gbEvfOGlyzbW8VeiPbE8kgyeTvLP5SX6GyimgkoTc1UHBogdW2cGoWSWGQbFKOYMB/vt7LW7dxmoLMhkSkgqjn0FnJIzo2yXBMZyNHGlvUGjnSUsLwSJvsVOcatx/laWMrB+yhgPhigbiWQSawcqdFd1pvLfPinNiC3F+jyr22SB04WD2z9JYRCD8lDmyErfBKASoyxVk5GutKBn/eofCh5a2ifC2aKvFNPJXTMzmV13YE15apcX4gp9vVxconCFuhIwvZs7Z42dJRuH68NcL67103ljwyt4/11Rc4f+ESiY5orncpl212jeWpbrc4v7DJxXOHyPkWk6XtLJxscOzFL6LclE/++6eYmx3i6Eua1JHY6RHcJIPvDPHy5Wf4i89+lf07dnL3m27nwE37+ZGP/TRJHOK5Pv1+iJAQxymu61IpFxESmistLNcnaDVYuLTMXfe+icXzVyiPjRB2WjTq67T8GKcfk6aC3/2dz/Cff+s/snz5IlEvBGFhCZicGMG2HaTtkEQhneYGyvVxHZelxctcOP8qy1fOc+DmbRRKY9TbNbI5TasV41oFXjl+ieERn207R2/keKlMN+ltVMleMssRr6aJC4Jodpj2nEfxYp/iqRCVdemP+xRfrVN6vgNSsv8/OfR3DjH00iZaSrQoA5D6FuWzMPTpOhsHtrHyVo9D+7Zx69v/iIYKGbI0K4nCFQlt5VCScJNbxxWC+XiYstXjVDBJ9sway++dpHwxJqjYuJ0UbzP8O3Ii2PufznLm9+d4fGMfG6UCllBINPflX6UgAzIippFmOR1LciKiIGIe7tzCg0sHyS0KNm5xiYtGchRnM3hNReoIho/H9EZsGjuu/+0bjRlyW9yzsLsSq2eccWlmoP1NTMEvn7Bp7k+xGwPpnCOQQxGRZyMzCfJqhnQ4gppjJGYSdCK5a99ZclbEoxf3klzNmi7NNo/GKONMS7MKEZv/R3kaOYDl2F3DuPBqAiuy6E2YypqbbNPJZBF9i/5y0bzmsMGhIoBUkOIYV18oSLMmnkh2LQNa8o38zC71sW1F0PFg4NwzRUaQOZch9TVx6fqf8sKRBBnKrRRue801DsRqBKlAI9GppHDUg3vrbG4U8C56pHODeKWJgEI2pLNQopTvUx+3YBDkK0ZDdk2scVvlCl977O0UFsxZaput+C0Zm2JtoPTitWioUCPXXeRkH+t0jjTjwVSI8BTlySa15RLpTMJKvQAZTeoPzkUN7NmJkeLJyHwOtRwoL2xBMGwKu+ekFEtdwtimcblsxlWhCbR1zpj3AaP/gDbrMxeWyBWqFMoVNmsNRqdGCVjmF3/1Pgrldf7ZL72f3TPbiKOIE+fOMrXXxat4bN82xXChDG6FWneJ+955K08/eZp3vO92rGzI0sUOY9smubLZ4svffISedqlt1Ai6PZq1Gp1mg42VqwgVs7G6xOrKVS5duECr02R9c4Uw7DIxXuXUieOUpcNMZZTP/+kX+Iu/+DKPPvMsubFxzi0sEsUpp04f56UXnuTQoR8wv3CWw4ef48rFk2R9h263C1rR2LxCq95gYX6eOOyxtnyZl374EqeWr/DiqQuEnuCuf/Qejpy6wJOHnuPFc+c4dOZldh98w40cL435MnHeJOpmaibuXkZw8ZcgygvO/VOHzp4SIkrIv7xEe28FXS7Q3ztGWs2jHImoNVl6d5XqI+dY/sA0qScpzgckuybJLLXZ/qUlVCp4sb+N1TTP8ajIuXiYp/s7SBE83d/GU/05vtg8wMVwlBc729mM8kSzVYZf6ZF6kv6I5OO//RC3/9HLTD/ZJxxSFBY0Ogjxzvi8fHQnXzhxB3+7vJ/Pn7qDB+p3MCJ7XImHADjS38bJcJJvtt5IM/W5slZh/Nk6xYWUoRMpWsLqu2PyLy1Q/tszZA8vMHS4Tmv/9Y8v7IZtOBOhIJ0KiHb3txZkSSVBxAKnYdE4YMLdtoA0EtKuybFTfZvU19irrsFB2ibFWwcWP3juZh55/DY4mzMqiwFTAQuzpa8kiIHszO4YdYzyTWccFzVpLjWLPd9gRWU+Jnq1xI65NYa313BqFjtvWkIOHsFVaKEDCzkcom1tYrquAX1cjS7HIMHJRYgLOcThIt4lz9h+e4LUNzNor26YzVrq/9dz+/9zuXUL5SlzoxkKcXa20Z5CxRIdS8pDHbQStG8LaK3mEQ2HqKrIlvt42Zik7RDHNv50m9rVMjQdcNSAV605d3WUrz3+NspnBp2qy5YNO/XMk9o1QJHbNhmSSc6AhpgIiLsOYVWZgrnhMjbWoHGhilcO+ND+4zCfY89b54nLqSG8OZD4mt6k+XnEBaPmSHKm6AdViEsp3vY2weUCG8dHaSyUkdWQNKuwqiH4qVGP7O+hc/+ARfnK1Xk6/QYLV87T7Gzy3HPPoSOfl54/x7OP9Dj69EUKfouir8nlBI4e4c23zyLdJv0gJLXa/Kvf/FG++sXHuf/D2/jOg09z7uwynqcYnsxx04E9fOjD72Vm+xRSOnhejkKhxOjMLDM7duG4HsPDI/h+lmp1iInxaUZGx/AyHkFX4GYdmmmfjJ/lq1/8KqKvec+d7+LFI8fYqNX4xK/8Ux5+6Fsce/ko6+vLbK6vYlmKdqfOmbOnabebeBmHB778RVxXkclogrjJK8df4t573sLiQocXXjjP1770PP/yf/4ddu9/J2+59x7sfJ9sQfK7n/yDGzlesktGVpS/InBbmslnA0SqyR/xGX9shcpLDoknSHMuuphDW7B+RxVtS2TPmARe/fdzTP7xEVZ/fA/jD5wmf2KV1JN0Jz1qt1WZ/8lJdk+tkZExVavHbqfJe7NNPpq/TEHG3OkvMG43uM2f5778q9xRuMCQ28HqxqS+jRUqkgz81+/9CJ3U4+pdPsNHwd9IufQbB5n7Vo3qKwK97rG8WcKyFIu9Mp/bfAcXoxGGrC6f+e77KVoBVbvDZpQnc9Ln6rsr5Oc7FJ88z8yfn2bvLx6je/sstQ/sRWR90qLHTf9l+brPNimm2E0D9Mm97KPaDslQbKBEgzmv3RcUT9nIQJJkjQsuf8k8ksq+xKnZuE1B5TTmA1xI6U8m+FdNB58WzDjB2zCduNMWeOsWmWWb7HkX/4xnSGQ2eJsSd1NitWysUGD/nQ526Ihk6LEMMhJcfmmK+vFhclcFC4emkVaKCmwzs8ykpE0XXKP2kIGkPNqGfIJOBKJvoa5mkXs6xAe7RLv7JAVFsCdg/+9v4i9L5PsGyM4bSLNOfI3TsvA2LDLHsvQ3faxCTCYfka306fY8rLpN7qThUitPUd1VIz5TJI7M2UWBTX85z/AhC501Ixw5FKFqHtIyM3+RQn45xemY4pupKbJrisq5lPL5FK+h0AL8DYXbGKS+KGHolDGUz8HsIwnqK6MoVxGtZfnu6QMUL8DJs9M4pXDw9WmiscSkXPtsjUKC8YT+uEFzikTQ28wyum+d4v5NctNts6TMpuz5t3Vkw+HmD54BwMuHr3d8Nza+2L9vhtX1BsXSDI4cZ/e0xZnlB6ldcfjIh9/D5UtXmZzYzqX5VX7h4+/lxMvPM5Xdjzte5tKpFX78HTmOfneTX/7I3Tz48BMcvGkXp15dZHVd095YwUo6TGcnuPvtH8DN2FiWBVoThTGWlGRyFbRS+PkqKo4I4gRUjNdzmBmfZmHjNKPFLGGrR5TvcOLIYbIyh5t6HDs3z933tNkzN8L3Hj/Ftl0H+dqX/oIDN+2CW3czszPD2uoanUadzXqNxYXLrG+u8cSzz/K5Lz2Ba2do9Tr8xm/dyw+eOkarJXjw65/j6MtP8pv/4SWK+So7pko3crx0d0XYGw5hCZQjaW3LULqk8C7FLPzEBMV5RXdCUrygOPezVYZe0UZLKWyyJ9qs3Flh7BnN8i/extR3Fum9ZSf+kQW8lS7upvnQB5USf7jrAapSDswkLk0V4SCYthxiUqatPj0d01SaiCaL1hDd2Ry5Kz36Yz5OVxP1BQ+dugXHMaL7/MlVlt45SXtvidEHz9PauYvxr7ls3pTl2C029pzilcYU5wujuA3BQ7U3cKYxytoPJ9jxx6cQnotqNDn9f9zKxLPgtlJ+/9Of5j8ufpCN2naiooXaMXXdZ+vULcPu9RWpJ8lesentjgx5zdZoTxGMaqLSawYCqyPpziiyi5Lu9hTRMfbo2s3aPKIWYzLzHsFYapQRmZQ0K02SN9c65WtD3r8jqgV6ZTMDdpoWVs/Mk6OJGOUnTL97g+V2gfBqERkY1UVrlwmqVQs5bG1GIXZXkkxEBnVZjFGJpLFWQGYSaHompy9wSC7ljQJk4AiMLZsLPzNK5bRi/UIVGQv8GzDmXMu2C8YS/CUbq2WTHevQXs9jZROyuYB4VtHxfZxiSBLa1M9U0bMB3mmfYDzFuppBJLDx9hikZmS0xebZIXQpIWk7WG0LmUC/Krd+Ptp6jQmyFSVlCaPWcMBtQa/tbC0HNw9qOtv7QB/WcjgNSdrP0NqJWbouZME1MjinZhOOpEYpM6DRWcWIOPHMknY4JAls1jaKZtFnG3aJlY9Zu3eS4jnBkbEZVCIRZ/8B06zPnp7HymSQtiSbTXGHInRUxcu1ePbECSQx7VrI2I7tfOdvXsZPBHZ6is3AYc/sOOmVveyekeie5v633sffHj1MueownCTkxj0jfHdWQa6h1Qj9oIdKEzQKYUkyXoZup4MUEuHYKNUn1SG5bI47D76Rm9rbOXf+KKXhKsuNJZKFLsvLKwyNjLBrTx/Pk9Tqmxx8w028ePQo49Pbef7Fs9QbIdOXa0yObedU+xXa7ToPffNLID0e/Ou/gUTQ7vaY2T3K17/+Ave86zY2Ns6R6ja37L+Tycp+ZqYqPP3oczdyvGQvuFtLnCRjFk5RXqAsm5Gjr6EVWztzzD4SIbQGXNyuItg7jtMWtGcNnGXl/inGnlqHkQraswhGs1ub+dT4JqmlEYG2SLFwUIxYMQuJMwAHQawtYm0x7W6yfquksatA5WxCWBFkNiHQGfwVQX8EOreMoVyNvxHRvXM7I0cV7SmbsUMh9WaWw1f2ko6HXOhMUmrD048cREvY+dUN0Ip0sw637GbnN0Ku3Ofjr0sCbfOJySf41+O76U0IZh69fj5DXEmRA1laby5GZhPo21u4TbshCUdTUktTmGzTruWw1x38VUEwosksGdlhb9Js5dNKgujYhEOpySfUEtG1SLIDjfJgU8/A6YetIRFoT22Bg2TfpGjbAcSWIHPZJSrZnFufNq8pNHo0QtVd3PEe6cW8We5FBkeZzgTovumaNWB5KWlooVOJzid4uYh03RTbpGDGFU7Nwq1ZpL5m86AgvyBIMqDf1rzus019hUoFdsci2BPgZmLa9ayZefctOvUizkgfbM0tk8ucWR8lXvZQKx7hkCKzYhnwfEEjuhZCCTbtPGjIV3qEoY1q5YgKwoTc/p1LS6NRtvuaJCe2KHFuE6xYk1mxifMapysIRhP6S3m0o80MfE8H/8UC4u114pUCdiCIPI3yNYXpBq22j2q4oDQ6m1LMhrQTSeRYvGFqmVcuTaNiCyufYNmpsZU3TRSW09X4R7LGqv2G13/f3tD4ws+WiVt9Nq9eppOscvjMcVbWI6rD29h76wyju3KUJ4v0dcy5CxtcmO8juBWlC1iyiS2quN4QfddlZKhEOafxXMW+fdtYPKvo1rK8emwdqaewpIPneiZHTytQqUlodiSKmCDoUdvcRMXgej4f//hH6bTb7N9/M8KWJChirYhTTZKklKp5Tp67zNjcLk6/eprqyBhP/fAwR0/P89DjL3Ls2HnOXTzPyuo85y4ucPLMObpBQhikTIyPMVItMj6VJU0Ezz33HJ4X8Kv//J9Qrzf5Jz/1a3hOjrvvurGZcuob/WV2RWMHUD2pyW6k9Eckm7c4tGdteqMSmWgyry7inVs10G/xmuvoWrpyMCRQRR/t2tRvLpI7s47Tihk+HpARGk9ISlJQkmbepRBYCArSZPKtpz6Hgxm6ymPI6vDRH3kGuwOb++2tWCWhzIdExhBULIrnJa25DPmXl+gPSyae3CTz0nkmH1qkegK8ixm8VYvy+ZjyGZN1Jvohem4Sa3KM/nQOkWgmnotQDvzaf/41jgcz2D+xhnJh8b7rp8S5GxZCG+mZ7JvChWXA8SI2ydwoY9zoLJQQHYtkNIK3NUizinBYEUykaMuYMUTPwu5ItK/w5x2chsRfNgVF6IFsLWErx097pnhbbcugOwc5fKmviPOaJKeISqZwak+Bl+JUQpyLvmFT1HzSyRDtKQq7G4iREF1zEW6K5SdYXorWYG065lc/QZ3Pb2mYZWTGG3E1JRqP+fn7n8Tf26C1L6Y3l5C+fP1PeU7LhLNqaZaatq1w/BjhJ+Z7LZnwXHfV5sTSBEHfJR6OufWO88hQEJUV0aiZ5euMQnkKXXdRhZTeQpFk3WfoFcyNTl3L1QNlG+ddXIAkJwz+E3OTY+DuC0cNVSgcTs2/L0e4lQBnskuykKc7lxLHNmOzNYLJmB0Hr7J97zKtlo/jJjgjfXQhIVMKaa3mcTMxlYkWx07PYnsJjm+aJZVKcDT58Q7WT65R3w/dAwHxzT3S+dfnitxQUW5eXWF6usqum7czP19jYniW9SuatSs+xw6dwe5lWVxZ5uLlZcq25k3j08QLS7xx2zQjuTF2z+6l5IxCGlHJuZTLWUbmhrmwtk7PCul02/zsL/wMa2vzxGlManpksC2kK0m1Ym19jXa7TRqHjFRGkMKh3urQ7vfpBy2uUx4YAAAgAElEQVQunJwnbba4/aY3sH3uJk6cX2J2bj/P/fAUjz58jMurGs/J8vBjT7NWa5Ikgk6c5eFHXqAbJHz6j7+Ncgo8c+QKX//u09S7Mefmr5Ap5Vld3qRQmUG7RRI9yvNHT/LJz/0avb7i05/+Bt9+4sYy+vw1QX9C0dytKVxO6Y1Jsos9squKsRcDRAK5ZUXhfAf8DP194+RWEhq7LMKKTW8uMUm+AyhNOJShuy1P/moESmG3Ai7+vODp/hw9lW6ZvxwUWZESo/lhf44L8Qhd5XF75gquSDkdTrIaFnF6muqZFLsHrZtjormQ6qmAzqxm+KlFJh+8TG4lRmdcJh5cgNUNdJxAEFL52hGsELb99ssoWzD0zFW2fWMd3WihXjmNKufxF7sEw+6WtXX0+Rqf+8sP0A1dtv3Xl5l5uHbdZ3ttU4+jcGsS/4wHkSSzYmNFhiJnt0zh1p4CCzKXPIIzJVMs7GuSNlM4rJ4kHkogGfCNHejvDY1MS5h0ki1iXChwNhwTmqoxDOWMMtI5aSR2MhGvcX0bFoQWjpuQ7O4ZSHtXUjiaASVoLBdJO7YB6a+a7sy6aJLelauRDQe14RnZXWqMKypj9NMiFciWzRe+cy+9bga0GY+EI9cv5zTWZE1aSbDWXIKLBdLYgrZDZtFBJZJoM0NcVsRdF9UxcsQjF2fNXL9gZsja1lj5GCxNZrJLfrg7kCQKNm81fAoY8D0GZytj8BoYdoVl9MtJdqBdluamKGKxJaFj3UNrKOYCrNku9lBAUMvQ+cEoXjngwuIIC6tD5mvuO6hU4l/wKGQDRCTRWtDq+DjFiDiwUUpiOwkqFRSqXTr1LGunR0hKKcPDbRw3QU/3X/f8bqgo1/o1lJWQxAEf++iHOfHCcXwZcPbsITbbCndScvSpDdpLinvvezOVA1mm75/CsiqkacqliyfIeAFzM/u5tHSFme2jdDsNFtf6jI4OMToxwhe/9EUcxyVNJAgPrWySWGLbBZaXl43hQynCIKAfRCRJSq/b5fyZC6SJoDoxQSsIeOyxx/naVx6g3+3wZ5/9Ewq+xa6dEyTRBt1eh24nYN/enVSqDknaZnh2hD9/4BuEUlFveigp2KzV8LMeQ6UsOg7oxopMmjLijvDq0UXK5RHWV9b59X/zCXJVRWnoRk4XnLZZTohEsPKRiLFDfbQtqbxSx2kEhFVB+fsXsJY3WHr/FM2dLqtvdga2U8jN24YBPKPIXYXmNhunleItNomnqvSnC2z7sqAg+wTXfAxAT9sUpOD7vWm2uRvE2mI9LbKe5ugqj6thhR/M70Sk0B2T2D3N+BMWs1+VWJ2IvX+4hM5n6d00jtVPodVB1RuEb9iGHB1GxzFy1zZmP3salMJtRCAlLK8h8jnssVFEnCID01FFBYuRYyHRSA5/TTP9vwXIaoV46PopfEnR4CKtQX5ekte4GxbhiFE/aIHRD2cM9c7qSoLxxGh5B6oGBm6+4knHLPW6lvmgSkiqCbRtGA0HCSAms08OEqqTvELZmjSj0FJj9SQyeG2enfgDw8NAcyxiQXC5gLjsY/WM0SQY1lsLvWuZU2ZurfFuaUDLoXp8EMCaiC06WZoz7kCra0D9TtssMqVlCrHOqC1g0fVcQhtFCZHcKvxsemTGu8T7eq8FGDga20+wm5aRKHYchKMMpMg1TyyFZ7Jkh3oEXZdOw4dcQn5HE+VpupOv0d9EYkYE15gU2hJbemK7N5DJFTS4yljLpcGgyliQxhbryyWijktcN+7C7raENLGQjkJKhXSMmiXpOux49yU2Ngr4SxZCaHQqiPuOcSy6CXFooyKLdj2L6Fk4U10KE236kYNlKbOMfZ3rhoryzbfeyepawOjwLs68epl33HkPP/bB+3jPnW+n0ILOYcVdbz/AT/34j9FbTrj/tg/yM/f/HO/74D387M//FDt27eHEqQXe/4GP8C/+3b8l7xdRLYuiX6Db7dLv9XG9LPV2QBT3DXxeSKRwiMMIx3GwbZswDInimE6vS5xErK8s881v/jV33/MuRsZHeec9d9Nod1HCJlGSWGm63QBLaUbKBfL5LMVClVeOnUMKhySNaG92sLF5yxvnKNhdon6farmEbQm275ih1aoxs32YVmeFhYtXEFpy/sRVwk7Km9+5nTe/cxuxvn7JFpjE38yGJBmJcc76LL3D59KP5Fi6bwgRJZQuptTu38nCz+3E31TU7oi59X2nmHz3FWo/3aG7PaZ8RvDRe37IRz/xfZKswOonqKKP1Q5wugmpJzkfjtNUDm2lTfq3UDSVpmD1yYmI9aRIO81wOa7SVS5H6jNUvpNl7Z0J/VFB6x0BXjMdkLQUJCmiZfIJg2EXSgXkUBX3+VMgBDqKYa0GQhDcfQvKs9CdHowOg2MT3DSNqDXp7qrgNhOK540t1Tl8DqenWb9rnI17ZxH/t3ni/8h1bdGZ5hVR1YB94qLGqUlUPkEmkLssyS5LvE2JmggQWmD3BOPPCEQosPoCWY1QtmFpWKEZVTgdgV2z8cZ7JpE9o0hzKWkuNZ21q82owxrwGdrWliUXBV61b/SsShib8nCI3TUFOy0oiueheNEUbJS5McieRGUNEMlqW3QuF7E7ktGfXkD2zUw7dc14xCwUJWlO4dVM5JQeikiXs6ZIr5u56/Ve13TDXAuL9TSZmTb99awh6mnILjhYXYlayZBOhJAInIak8pxnuCGbDspXhBUI+i66a2N7KXLToXOpxOiOTTOK8Yxx45pMDQZdsjDF2g5Mt3ztz3LlPt6aBZ5CVkKKN22i2g4yk2JlUsonbbIXXBNiaylsOyVNpelwQ0PTP7sygtxw+ZWf+Q5xaCMsjZ1J0JFEKYFuubj5CKvmmKcszPfQbWXobGaRhdeP2rqhotxo1Ni7dx/FSplms4lKBGtXLEYrN6GdlJMX5rE6XW66aQRVrvO9J77DJ3/7v3F5YZ3JmTkuXb1MaazCuUvnOHT0FPNnVykKj6F8Hs8pU62McObsPH/5hQfoB22SpE8U9/AyFv2gy/DICP1+n3w+j+u6eL5HEHaJoy6dTpOvf+PrPPH9v+HRRx+m1mhy5sI8YSLIFEp88ctfoV7r0VjuoLUiCCLiEGqbXWzLI1/JIj3JRnMd3/MoZ3PU1zcgTTk/f4FcucjS0iJd3WNm7xzlqseOuRGiKMSyUywnplS+/g02mA9Ob3eIXwpwW2Z+5q+ZRZO2JcXjG9iBprs7IvUEo084XPrMXi5cHeHA+DKZqw7BkOCxxT184cxbKF9I0K4kqniojEN/2CV/fIU/fvC9rKRFetqiqSyqMmElzXKHt8lKWmTOXads9Ri122wkRXqxi9tWzH0TZh7tUv5+Bq8Wkju5gogSVClP7it9vI2+sUZrje71UP0+anUdYdswXEZ4Ht5Gn8S3oFxAX10Bpci8uoiulshebiPDlMbePEHVRu/bZti2tnlEDqs3QDLLa9JiSvay2XXHQwY1FpcV9oZDPBLDvXXCqsarGSmVtjQz71lg+R5TxJNiinfCp7MrMUYNDMcivbVNMhYRrmUN8CabGgiOfY2xrImL6RagPfX0ljQMWxM2M5R31UhzKeETw6jYgrkeTkOSvWJR/clF8h9eQe3pYveMxAsJIhKmC7TACiTxaMyZo7OvJWRLtswqccGoNbrbE7RjMghFIkx8VU6bFI7rvFLXLBK9JROt5U51iWMLuxQZrkUmhdubpL6icEniZmKcpkXuQI3WdrObSIspQ4ctkpzpRIUSJIHN5C2rjOzdoBu6uC2jrAgrpvAq24x8worYIuWlA9JbXNDERUW34ZPu75ob05ksUhiTlm64yIUMd//CIW7+4BnGdm8Q9x3iyEZKTRzaZMoBVjYhCRys6R6fOn4vKrBJezZCKoStUalEO4qo6ZHb2cSv9IkjmySyjJvP1qjO679vxTV28PVc/+Zf/HOdL8L4aIXlK4ssXW2yVH+VxStNpBty4UyD4qTEJuUtb30jb775LmZHhhmfGeP7zz5BfT1hcniK8/Pz7Jrexde+/qfc+4G7+cJfP8JGOyGfsxgqjbNytc03vvlFSBM8WzI2UiXRKZaKqA6N4GVybGxu0Ki1aXfrvHjkGYJIc8v+N3Hu9Kt8+WtfYml1FZ1YqNhiourjCsXBgwd46chRdLbMpYVVwCGJAkq5DHbeQnuCjCWZcHOcPL+GchRTeya5uLDI8HCJbEaQrQZ0OjCzs0q7LWm31ig6mnfd+0a+8OeHWbr4/0G0fp1rz3/4PZ1kNWo0xF7y8FcEuVVF/nIfbUmcE/MwOYoWgpW7qjQOJmRHutw8tsKRH+7GrUuCUUVhXtKZUez+SpeFDxTY8YUldL2JKOZJR0rI+WWK39YkSpKxEt5UmkdpSawt3ujPM2p1OBzM8Wpvkiv9Ci8e34kMJRP71li6MMKuL4c4lzdAKXQUoyeH0VKycXuR0edrqKyLOD0PgA5CZLWMyPpox0a7Dmkpg/XKBYQQJLdsxz51GSZHUVmXqOTidGKaO7O4HYXXiEkyFlfvcdj152v8zenfuq7z3fbF/6LFpjvgEJvEaDDAoaSSILtGmpZmNSqbkr3k0NsWk1lyiMoKuyNIdwTodY9fffff8pmjd6NCC2KJ3bYMRnM4MsjN1MxpVWYwtZca2TeJGto1ownlKYQWaKEpv2oTFWH/+88SKZvzj+1AJBCMKNymNOYOexAv5Q4+vxKj3hjMp2V/4BTMmNe99n84daMaSa6ZS9QgEHRg2TaP+2YhtvBL/+q6znb7p35HX8NtXoMsyVgYAH9uEEWdii27cemkRXfWAKi8miAqQ7KnR9JyuXnfFS6sDxMFNrabEvUcpKPwMjHicBGZmtGFlmxBgpz24GaXAfSgYLsQVVKqxyVRUXDXxw6jEDz6+BuxQkGyq49YzJCOhziZhKjt4hYi0sTC9WLCvoMcjCeS2EIp0z0bJo4g40d0L5VQRWOxRoAQBqqktCDtD4RusQRbsfALv/HfPdsbksRlSwk6zYDKsbJep1p16XfLvP/n/jF/9fADlGagUEjZWGyxerlN/s0ZBDFRN+IjH/5xfvD0szTqHRbOb/Chj/4yf/W//kveddebKTkZVlWbUCm6SZvpuVH++qtf5ZZ9O3nbnW9i+eoCZ86e46c+/jEW5i+Tyxfp9dp0gjppGvKZT/0pIrXpdv4ML+vS7DaZ3TFD2AuwpcPCxSWEJVluvkQvTJDtTZTQxHEPNwsqk9BJQ0QDenFMzW4ysWOIlfU11jcWmd1eRQiN7ds0Gn127Cpy4tA6uw9YNKMqo3sr/PBwg327b+h4SbKv3TAzG+bN6nQE537BYfohC3t2nKSYwb2ySeFqkeYdZlxSD7P8zHt+wF8ceSuy6VCcT5n40CK/+eEH+c2f+DlUPgPrm4gkRfZjkj3TnHgwR3dPxI/e+jI/2NzNy5dm+Nbdf8g3m7cx7dZYjKqshkWi1Gb/726A1tDsUMqn6HqDeP82rF6EtiXi5AWE4zC2XkR3e0jXMVyDIETmfNMpByF0eog4wl6xUXtmEYvrOEt14n2zhq6VsXEbIa1deaovrNI+OIpINK05h+GXNZ39NzC0bznooQjbSUlXfIKxxBQyYeD115xcDIfIDY/enhDbS4n3JKiuTWbBwV7MEAwJPvu19+EK89je3xdA29ia5ZpHZkMQHOwbK7QS6FRA20FXI6i7hl2RT5Fty0jUhkOmPnoFWyheeWY38UjMze+6RCfyWLg4ipjtkG5kEdFAiCsYJGYbkpoMBULJrU7RblukmUGSc2QRV9ItupwMTLqKvWGT5Iy+OPW0ib7qXf9DtLbMa6e+ueFpW5NkFE4lJFnzkcMhqu7ijfWIruRoHDRPKTKXkGQ93LokczSLjKH90AzW/9RF113kRM9EV9Vc+jkLu2yszXZfbLG1vbqgP6bxV43aJRg2BEAEeBM9Rg9ssi1f46FXDuDkIt74jrMkSnJyeYJ0OiCXDel1POzsYPQoNEHXRTqKNJYkoYccFN2gkUFmElTPJu47eFNdkmQwFgstvHxMsOljFyOQGjcbY9spvY3X34Xc0PhCaMXV+UucPXkCyxKcvnIWf2iSK2vLfOvBI+D49NMC07N7GR3ewfmLyzz51Al+9/f+hIe/9QxprLjt1rfyqa8+wGOPf5N/9La3Evdi6nmL2alxLDL0OpDELdZWN5mdneXYsaNonTIzNUOvHxAniqDfp91s0evWOXv2NI16SK3exbKh2+lTyFfotEOiMKXT6ZAv5QhUSjNQdIKYRqtLMZ9jqFqgWCzSS2Ny2TxS2OSKVbxilvmVTbCzBD2LZqODn8/j+S6JVixc3mDnnkk6yxUmhxNWl5qcWz5Hw67cyPECkL8i8E9n0BKKlzRRWeCuOnzlD34H7ViIRNHfNUJv1MKdz2A9VyL4zCSff/IuSCQ7DlzlX3/y8yw8Ncdv/uTPI3tmqaZ3zRpwU6eHDBP8Nc3UVI3vnrkFpSXT43WWkhKd1GM1LjHfH2K1X+CVS9OwUUevbiBsC91qIypl7FaA6EfIZg85PISOInSng+p0Sdc3keUS1uQYolox3XQhZ3IQqxVEsYC8uISwbXS3j73ZIS44pL6EVFOY79G5eYTMZkR/zCO/nFK82P1/JEH8j166a7NvchWrL3A3LWQssDuCiTcvb6VI25cyOC1BdbjN1HADVXOR2YTW3oSxjy0weiTmxz/yNMFcRG8uxl7y0NN97J7pOru7Ym6bu0w2G1Itd7GWPUN/69ivwYciiSqkZKc6pKs+p47McfKFHSZxI7B49cQsS4cnEKE0aR6JKchCmZm0dvQWMS711Ws8ZQuSIaNeUJ6xXjsNU/yFFliRcfklRbXF4rgGTtLe9T9BX/t67NE+mXWJ3ZFYXQt9JYs/3UbVXLSfEl3NkVmXjM3WuHnvIrkjvjHN3Nzj7p84zNQXTjP2GxcQQiOHQ4KOy+hIy9yMEkFSSajuqZHMBojZHpkNs+i0e4I4D3EeZCLoTSgOvv80Qcfl9OVxHj5+C5af4DgpryxN8vLFWdLUCMnDwHTEWgvSVCKlwvYSdCpwMgmWq7Y65my1h7Q0bjnEyiTESzlsO8XzYggtwr5DcbxNGlk4GVPke5tZ7H/QmfJ6m5FygasLFzhw801k/TIkPlcvneXf/S+/QtVVWK5DqVrhw//4fjYbKzx36Agyo3jwu9/mm3/1bR7/27/h59/7o9xxx37ysx5eNYMbCjKWy/a5KVB9Svkch4++zO996g84dvwV6o0GvX7E6toa3W6XJEmo1TZZX1vhq1/9OlpLxqfmiLUkTmI63S6NeoerVzfY3GjSCztgWfi+jwQ8x0YCNpJeN6CYH6Kx2qDdDUkESJ2wffd2vKxHNueBDIlUmzhK0SKiXlNstNbZiDY4v9gi6Uq8YBgpGjdyvHg1QViGwhVFZ39EPEhbyC/A+/7w10lzDsqzCIYc9I9s4tVh/PkuqSvY9p2YuW/C1Sdn+L1/9nEyt9XoTfoklawZM3gWwd5xSBVxKcPIDzeQfzSMdyLL1XaJTujyQncny0GJnnK50Bzm8kaF2a9LoxPfOWNmxUGIbrVhrUZ6fh69uIzu9hCWhcgbPabMeAySb83frRTRV1dQjabpuIH44DZ0zkcUcgBYkULGGqE11kYbbzPCbobkL7SwQrX17673chqGb/zqoe3ElZRo0lis46pitVkgnQ5w2pI0a3gHtStlNr4/idWXTAw3KU60OXdojk986ms88H+x9+axll3Zed9v7X2GO76x5oHFYpHNJtnsbvVMdUvdkqDAtiJIcRJIRhAFEWJHgBAYtqLASRw5CCxBARIPsAMjCAJnkBMpkRFIjh3LlqMoaUVDS62eu9kcimSRVfXqze+OZ9h75491zrn3vSoOzUcF9cf5gFt177tn3Pecb6/97W+t85ufhswQ7UcU6yXRi13mF0rc0EMhfOErNxgddRn/4RnKMwXm2gQST3RuhlnLtVjNMENkYddyqWrndmIqsg1075rGElYnjOCp3BdKwlJqZ6KEDdFurM6LidZKLs4XmqySC8WKU79y9Xy/ZFcf7menBsp3rynHe1brbbzaUznoSoYbOlzHY0ygf2WE3Y/wqwWzC57RLOXWr10nRBCdnfORR27xj7/8LMX/0uerdy4RGY+bxKxvjtl6ZYPk4gRJPdjAzt0V/Dgm/kqfbD0wP+eZn9GnrMyuFfgkEF+ZsBrPILNEicN2SowE5tNE/cQmEL3QI0lKlRpKg6+09zKLCN5gI40AorjElYayiJgedUjSgvwgxReG9MqYEET185WcUBgmkw4SeYqDlCiqnkZj/gQfBxVFGfFKiu9GvHLnDmINmdvB2pTx/C751BByz2tHr/PLv/Tf8Uff+Bqf+9wn+fM/+ZOMpod832c/w/bha2wdfJFf/if/Ld/93A9w8xuvc+PSRfb3D/jWV14m5I5z5zf52Keus7p5hmkZ8Q9+5Zf4fz7/f/C7n/88uzv3+Dt/5xf5vd/9PH/xL/08L760RRwZ9nbvMBqN6XVTrBEkeM5ubmAxTGdwfmMTn2d0O0I3iTmcj9mfHrIyGDA6GhOISWzC7HBKMRdufuMmiUnY3xsTpj0mtwJdUuIksLG+ip9b0mzIfCvjlVtvsN71JJ3TpVkHqxKGi0ULm1vNzgsWogmYWYkpPL17OfGvbHD2y3Ne/74+/id2iI9y3vhsRLoHyRsH2P99nTvPWewff5vJYytE945I/uDbhCxneiHm3qfPMNuw+nj1X90k+91N/vs/fo4XD87wj/7+97D1hQvc+Ok36H9zG+IEubOD293HDAdgdMgWXb0E1uJHI+TSecJ8rnJFr0s4PCLsHcD6KuwdgDFIkhD2D2A2J/riixBZnQjMC5K7Iy0yk1jKsyvYzEEImHv7dF/YphwmlN13f/kWK74pJF+nxNbItnqY2x2tq1w9h23tGxH5WqA8m7P15fNMpymdXeHn/6t/g94dw/nfMeqUm1ithZAr8UVHmjEXZhb3/jFRr8Q7Q7qSMehpDYR4bU6SOMZ3Bvpgzbk0ZTxVelBNePpErnJHX5NWantesKF55JSEmpgX34Ha4EISiO/GRNVTMaTSk0E15XxDSdp1TjcEKftVDemBp7yUEyYR9eOpsnnMeLeH29RoMTkwyB+skq+C/+QhxTjhG/cu0H8h4e4/vQpfG5L94QaSG0bjLtIvm2f5maMIcgNRoPjQGLkxIawXyPkMf6agsz7HPTrnAxfv8NuvPK5VAceJTtoGIUocZRYhJpB+aJ88j+j1MiXgcaR1MoRmf660lIXqJCIBsYHZJCUaFkSJY3bQIZ8kGBPUwuuEEKDby7ErBdPtPskgR96mvzvVRF+LFi1atHhvcboi9y1atGjR4j1FS8otWrRo8RChJeUWLVq0eIjQknKLFi1aPERoSblFixYtHiK0pNyiRYsWDxFaUm7RokWLhwgtKbdo0aLFQ4SWlFu0aNHiIUJLyi1atGjxEKEl5RYtWrR4iNCScosWLVo8RGhJuUWLFi0eIrSk3KJFixYPEVpSbtGiRYuHCC0pt2jRosVDhJaUW7Ro0eIhQkvKLVq0aPEQoSXlFi1atHiI0JJyixYtWjxEaEm5RYsWLR4itKTcokWLFg8RWlJu0aJFi4cILSm3aNGixUOElpRbtGjR4iFCS8otWrRo8RChJeUWLVq0eIjQknKLFi1aPERoSblFixYtHiK0pNyiRYsWDxFaUm7RokWLhwgtKbdo0aLFQ4SWlFu0aNHiIUJLyi1atGjxEKEl5RYtWrR4iNCScosWLVo8RGhJuUWLFi0eIrSk3KJFixYPEVpSbtGiRYuHCC0pt2jRosVDhJaUW7Ro0eIhQkvKLVq0aPEQoSXlFi1atHiI0JJyixYtWjxEaEm5RYsWLR4iRKdZ2cZRqN+HEBAEqT/Lm6wEGGMIoVkVCbC6doYoTYEASPXyiIgu66vtLv3rvD+xZUcgEHwA0QMQHyAEEI/3HuccrihxzjXbFhHKssRaS6+TsDHosBENuHt0QBlgdzpCxGKMwTuPVOdr4wjnHMYYkiRhNpthjMGIkAZ4//mL/L+vvPQWLfHW+MHoxxeNFKpzlbfvR8XaxfIV7IXzhE6C+EAw0vx/rI1O4mT7+rD4e9W+hKCfjSGUJZQlIS+gKMCYxXd5jkQRMhzC+gp+2MFuHYBzuL19RASsBeeqzQYkSXQ71iLdDn401nOzFhHBP3GVf/aF//Rdte8TP/83HnDC7wLVpRpM9T7oK1i9rsPSMvV3zXqc+KyX6YNDJQ/iQHz1mwUIJkCQ5n3ZC5hC8HHADTxmaogmunyw1fpBjzVEYHK9T0NU7dvpvotBABN45af//XfVttf/p194d237oEtwHoEJi/YDxAaCF5Cgl6GEhnDC4tZfoPr+gd+Z+prW7R1fr9pnEEzicJlFbKA/nJNlEWWu9ClGf+jgheAMtlPiC7P4TvQ7kUAIQpyWvPCv/ydv2ranIuUHNeJ93y3tuibicHJF8RTljMIXFUlWJySB+gq1oSJrAUdNJtXqNT/IYtsh6M1tMYTgCXhC8BAWnUJNytYq4TrnmM5zppljP82YZBkEQwgWEfDeL24eI8c6l5qQQwiUPuBE+KM7t77TFv0TQ5jPoSi0wzICsuhA779S65XCm34fKsIWYyAEJeSKtMUagrdKyiJIHCFRRMhzwmgEkwmm38ePRsc3WhGy7lIW24EFIXtPcE6P6Wsvvuv2+I5R36BL5AD6PkQ0pFkvKzlglu7zk6R8cvM1rwhIqe+lIoRQkxJKvsZJsx2bQb4SsDlEU8ElIKWQbFtdx+ixmWqbPqn2VyrBBxswRdWpoMvGR/Lm18SfAESqS+1kRwVIrNdZqHs3CQQnSqYV0WrbLtrk/iaW5r/gqeM9hWVB7EBwZrGRwhCvZpS5xRcGE3ts5JiMOoiEip/Q40E7C7EOXxqCF0zkCUEQdOgWAbIAACAASURBVFntSKCYvzXtnoqUH9CG7+i7+/4olrIsSeJI1wzLrVv9KMcixKoxzPInMAgSpLo7qoYS/aYmaf0BhDiOAWE2G9PvbzKfjwGDcx6CY5aHZv+m2o/I4scFmui6jrprWFuTvn3Q2X/nCCdHBG+z3MlhihjIC+haJWQ4NlIhBCXXk3iLG1Nk6cYVAbfUQ1qrBCqCPzjErK8RxmOIY418vSdMp8e3BXDiGEJeKJmXpW6vXj6K9Jjfoinea8ixkdrS3wPgOE649f9+aZmKZd9qBFmjJuQgVOSj25RQEane2xV5QjwSXFeXMwU1d2kf4hcbFQJSR8cWXBKajkTc0oG9w+N8r/CWl7eEBVECzcnXBxjQKBd40wsinPhuEestLvEgSpoVou2YEAeKKMakjlB97wpbHfNytLnUWYgGkxKH5joIziz9oEGj57fA6SLl7xAioi9zvPUEIc9zIpscW3b5/+9sP7rVEALe1+PJxfd1ZNxf3eSpSx+kmOZ84xtfZTAcMpmMCCE0kbSpiKKOqJ1zxwit/myMQURwS9He/5/QNq2Iy97fGfjZHJPE9cKLL8y7vPua8OYEwQNEkY5CNteYf+Ixopkj/v19zMY6fv9A1wtBj7MmYu+ROCIU5TEpJZTlYn8P6jj+JHAiolge1dbyQahurIa8Tt70yx8NC5Z8k/ux3o64JfJ+wE8TjEoUUoKPoewH7ExI94V8dSHuNZF2fXgBvFm8X47GG/Kvz6OWUU6JpUvk2N9g6e81cS1FusukpdJAWFpejpNs03HJm7ZtIx+VAvb4j3psMCgBZrbZttsoYK5RsvTLxXHWx1FHv0GQWskN1TJL15BYv/iwvI03walIudm2D9VvqRfTMpE2RCz3X2UheL2hq4uldHkVwS5vXEm08K75u73valUSNVYb1NqUsixUAw6l7iPUv4PBYBmsrXPlyqOkccLuaIdzF89yeHB0H8F477GVhll/jqII731D3nEck+f50nkqzJ8EiQR/jFTFiH5+ELn6oMvXJF2WECf3LVZHo4ttnjjuupOKqssljiDLdbveN7/9csjjz6wzubGCj4V4VCKPXiFs7x+/S0MA53S71up5VPsJtVbtHNJJ8bP5Qneu8YDO5zvFMnEdI8Y3WbAm43q9emDmozqSPU7UphB8FN6cMB5wLA+6Z+to2xQqWQxe90RZIFsxHN4ImFLuW3dZ5/axRsWmUMlimVv0DRgnzfm9F6Hyg6Ypgj9BSicJtll3ocEiOl8VTkbEpUD0FoS83LmGpeXrr5cH5U6gMEQjy/AmRDMYzVLml4oHt4VZRLxiVRb1pVFyr0Y3YgIB0SjbyaKz+ZMk5YVurPqkEoRGvo0G5uve+3iYIBhETKPLIFAURRPFNruoCMFST8rdfxjGmObiA5UPnDNYa7CVbhya4TWsnlnhp/7VH+PpD1zBCWSl4a/99b/NZDoh+ISiKPB+MclYR8NRFOlEXnV8dVRcT/Y1k5IV/H0TkaeAmAcT8FtF5svRsxGNlq2FKFqatFPyW570vA91p1RHxpFFCgORBYnA+UU0III7v8a3f2LIxSfvAXBQRmz8ZynRUQLeEeaZHnc1Eah6tNeJPRGII8S5RrcOzjdyyLHZmvdgVLIcUUpz0z8gCj55g1cLCAuSDmbxXR2BunQhETwINdkuzVU1BNscYx3hekgPYPVmwe5TMfNzgeHLYOeCS6vOxCx1HF63rdG1bt8vDauXz/fYd4FF5HxaLEfCcEyL1ZM9sbiXJmpuBCqpN7QkWZiAJOG4jHAS1fkfI/5SGvmjGSEI4IT0nuX8FxyT85bZWSEewRwg8gtSXboOarkilEaPxy7O62QHYqJaGz8xhHkAThXKHbtWhSYirQ+6nhB7a/FPmpf3nqIo9K+N1BFwvrh/cnAJYSlIayYTg6csS4rc48qgM84CxkY8/eijPHptk9tbI6ZZwmDlHMPBCjYkiMixyLh+X5NW7eCoI2VrLbaK2Opl6mOw70Ekd//J+opIq5e171yCcE6dEaDrVK/wdp1HFbHW76UicvJCI+ayXBBlZDl4/5De1RF3t1eZ5THnByOKtVSXqSb+GikijhtpIlSRc8iLhYwRx4itlq3dHFX7NpH7KRFM9YoCYenGkuVr2VevpWAnLBOXvz/qFidvKwMEA8EGXBLwcSBEAZ8EXBpwHf0bEggmIB56W4473x0xu+iJD4XZOaFYXQQ2te5c/1+fRx016/4W+687AwlU7g59f7JjeNeobm9jNbK8b+geFq9jBHty97W8AEqkTt6akOt1bNDoOPLKdlbfS+IXUgYghWH9m4G9JyOm54XkKBAsxCu1CF/t7+SxelFCFj2/Y9FwFe3Xkka9fnjQSGwJ78n4OlTywfJLo+Dv7IetNVvvfUN6UaVPyrEu4MT+l4gwhECWZc02lAcEI3rTf+QjH+bHfuhz3NoeU5qUcR7Y3d1mPDnARgsnRk3Gy9FxHT0vtq1kHcdxoz8vE/h9WutpENR1ECpJQqxZkNU7RO2AoCyVZL3azr4j/T4EmM0J3iuZG1NJD7ru3ndfYveH5kzu9UFgliW8drBGfJRDZJE4Vs05ipSgk7ixuTXRs3NNJyAikCqhizWNo+M+u95pUAcQFSnBkpTxNj9hde9VES8nHBehIubF64GQigz9Qg4Rr5N24qTZxuC1wO4HLKYQ4kNDOaxtcBXRLkXbzaaXOhapbXWVtS5EAR/Vbo7j8oePT3/tLl9OwfP2JPqm26k64ZPR+wM6y+MrUvU2Sw1TjUxCKeBESbUQNr5kOHjCYBykh1D2NJgsxpXc10TdCzKubXl6frIgay+Y2CHWN06MxTHLsYj6QXhPSNmoGIGpCMkYg7GGNE2xxlZEstxWD96t916dKJUerGRsMRK9qS6tG9SrzYcSMUH/t5Y0idR73OuRxl2iuMdP/sCzvPzaLkgCtoMvA3t7Yz764Q+zvnGWKIqI45g4jpsOIU3TY7JKTbbGGMqybOxwy+dRdzDvCcSofGGtjjxqr26/p4RWEezboem48uJ4hF07KZYdFQ+Cr/Tpyq0hnVQj3H6X0E0hibn3pzO41VVCMgFXGkb7PbY+PqC4sAZJrMScpo1cIb0uksQLjbgmXGsrG934mPsC5yCOj+ngp8XyfUsQbCaqvy6T7FshCKZcWmdpQnD5df96NVEq+ZpCCdiU1f/VwCY9gPFVaWSI2uomQHIgmBzVrqmjXvUrq1VPlHiXd2sXsoqvRggNb1XbPi1OTubpzgSfW3xpjt3KbzX5VWuyofL+4pZG37L0OolGQxJth7IiYSdQGiQ34ITurZjZGSEeL+3T6O9iDyJdTmhINziVKygMwZmFjFFLNFatcKEi4GMk/A5kofcoUq6jZRoyjWyEjSLOnDmjko7oWb1VXykiJElCt9MlBN9MOIXGjLi89jKJhCa6rV8ihiiK6HY6bG5ssHHhIr/4F3+M5w88yXCD4eoqriJUgOuPPkocJ/T7A+IkptPp0O12m131ej06nU4TOVtrj0XLsNCQrbWNtPGeQMMM7dxqOSVJNOK8clGXeYcShul2MP2eRsl1R6I/3FvsPzQdAVGlSVtLSGLCoEtxYUh+eZVv/MdnYTvFDTzRsMCXhjJTiWF8zRMSgx/2oZMigx6yMtDtiyCDPqbfW5BzHDeJJ3VHUc8LSFJFL++hPBSWTt/ki8/RRPBRFYm+1d1SOyY890kWjZyw/KoiZ+PkmMzQyAmVzU4c9F8PdHZCc0wmX9jZ7FxwHTBOfcpIwNvQEGs5UDlE3VhLskajK3Ps1jKV5PKOOqJ3ipqwvBDmFioy9JNI4w37NjYxv0SmnoUFrv5uSQJpLHJeiZd6FOBl0dE4qQgaVp6PWH3Z42Nta5Opq6WRr6OAZILM7PF9AKZXVpN80hxHI03Uo69jfmazOL63wHsiyoks6LZ2Jwz7Ax7Z3KAoLKPeAZPZFGPsg4cZ9TZECAhR3CVISbB6tYjopB2VYu9DwCxFzYFo4QCoEEIgThKsMayfPcePPPcUaWKwRxBFlnlRUhQlg8GAo/EhGxvrbGysc3CwByKUrtTRaByR5zlFroktZVk2o4FaYqmtcCd16DzP34vmpXZbiBGNiGOLrK2QX17HlB67t4o/HGmyxZtIJsekiU6KlFUCRh15R3bhmaon02qirxNO6snSeh9JTIgM03MJd74XJNGwLliNkENhiPs5xTjBrZfMziasbE9024VGuRLHKqnMM103LxqpIjjXROdhWbeuRgxhNn9vmre6UepoUTyc+XpJNHbsP5kSjBDiB+jIsIigrLaTyfW6DHZpxPwAwqknCJejU28XhO4q7VejZtj9UCAeC1JAsRKwcyGa0XiOQf8u1XC+ts4ZB2VHdVVxVRKJCccnJpf81KpdSxN1nxqVnipVp2VmhtXnBZtb9p/S85TE6YmcaKfafSHWaxJRQ3gCsW/03OV9NSdybENK/BSmWT70PGSGzm5g72khOQKbBYqBEE3BFgEXi/6eAcrVUtetCbU0eC+Y1GEip/Na1WRgE/ULTcLI8uTw2+F0lrj6/xAw1mDEEtCJsCsXz/Jnf/jT2CJi0Pkcv/Y73+QP/uhLTCYTfKiHnc14Ue/zECidZ0ZCHEUkJqcsVBd2TsdqSyPMxQimmpUPIeCdJy8LoqiDiDCbZ7zvwpDuSpeX7s7ZPLuGiwfEaY/19Q5FUdCJEmzImU+04zDWYpYn8jodiixvkkWWXRYnbW+15hxF0XsTKVczmBLFDemGoiS7tsnNH0kggO/c4OL/bVj/7Vfwh0dKZic3UxNpUSLOg6204HrirzyxjshCEjFL7/NCU6aThCCCTOaMr6wT+jnRnZTyTIHYQJSU9FdzsiKirLKy4rEQIgPWIF7tbySxat2zGVTJIsf2d7IN9WIAG59+oq+6WcTVkoP+2XVg6+MWgqXsex7/lSm3v2eA64A76ShcGqIHq8QYTQQ7h2BEM+iWkjHEqxtiebKtIUWnE2zNxFsGySHsPRvobhl8lVulbotA2auy+Lo6MZjumUYLrsnalLpMsEq4PtL91Od77LiqCDuYQDR7ZyOvN21avSWbxIk6aLNzYXJZ/w+x5+zvROx8zBD6JUYeMBFY/U5iAqHrILOYqdHLI144qo6Zs+tbUkJD3CGAnRpcXGX1HkSsvGw4eCLQ2a5kISvYDHwK5aCKfG3An81hFun+liUZJ/gq9RpRmSK4qgPyS7pXdQwmcSrpTd/6uj2VfBEIiFHJoZOkGKMTatZaDo7GHI5he1rw6l7OJ5+9zs/99I/TX+k9YBKsiogx4Evy0S6umDObe6SzAskAF8Vaq8FWQz0JuFASgkO8x5UlwenkkwTo97t45xh2Uj7+7JOUZUSnnyDJEPFCjE7Quayg3+1wNB4xGJ5lPJ4wm8wXiSMSYSRuZIvlaBm4z0ZWW+iyLHtXiS/HG1itYKbbxfS7YCpdOY6I92dEUyEeC+mOZedDwjf/w2uYjfWFM+MEpCI0f3CoronprNGCGymo7mSMLJwOPmgm3rJNbWWAeE8YdDl6NodScD3fpMWKQBqXlIUl6RYwjslWLeZwgowmNAuJKEnHMcTqTw55sYjST0orVUp3mM7efeIL1b1bLDRgoErKUJLzsZJZcmB4+Uf7rL3kWHvB36fNNturhv3BQL7mmZ/zZJtepYBSZQrjlmSMUhp5Aqg05KXIWWD4WiDbVML0Mc1xiQObC9FMcB0lZN/x5CvHf/NgKldHUrlKRM8RjhMyKPlIlY5ts1NGygFcbvC5XfiAC0MotdPwscot8aFhfFkY3LR0X0oJbskiy0KjrSfUTOyxKzl+tcSu5ipPlGYhVdTyRNW2TWRdyRim1L9Jbrjwe5APq9/cc6z+hynAzrRTc6sOG/tFZN74FsPCBldF375Qi9fyBOAiuUUjaZ/bRaLJm+BUpGytJUkSomr23VpLHMesb2xwOJ7gEKbzAtvtMgsdjoqCv/rv/rk3jyJDAOcJPiPPJhTFlOzgHmU2RUyExxIwxHGi5wrExmLE0ElS0k6HNEnYHK7S6casrvX5cz/6Q/hQMsszut01VjZW6PV6TCYT5vM5NrIcHB7gvefu3bsMVldIup1GK7bGYJZufhFZaM1wXwdTTwie9Cy/G0gUY3qVzgrqVEhizIVzmL0ReLCzqt6BA5MZvvmzV3W5+P7euPFrO0eYzrQext4BzOYqX9RI6wIJon83At0OdDtItwOb6/heSrHR46UfX1UdNTeErmO4MiPqFOTTmEmWYCNPdtgBD4PX5/j1IfS6xzuB5WQja5DhYHEs3h9zWiwSTeSBHc87btvK8uXjhQ3OpRplxSNBnEa9PglEc+H2Z4R8KAxeDdhMGh22SfiobjybQzQT4pFg50Ix9E2UWtvcNFsvNEkqNld90xQ6jDY52DmMLwv5mm90TpNLY9+zc+WHaKr76r0WEU+UNJYnCuv3ppRjSTH3uTSWHRjLftx3AV+odiPWN5NcEnklMSfYHIp+ZfczMD+jbRPfSpS0zHGNWSQ0UoDPLVJn2XVcQ45EHunWPVwVIQtK0B4oDdFYMJnBTgzTc0ZHNTMWI6YQMGUgmui+o6le1/5eR6WPWuqpOwKvLo6w7LB4kDZek3lN0G8j2J9q/JcmCRjBVDv0JiKbZ9jxjNWVVb79wi2eefr9JHHCdHLALAi5zPn5n/lJ/v4//D/5+ouvEhFASr0vRRBJsHGfNInBxvQ7KUV+hHM5g27MsN9hf/+QtZUhk9GIJDZYYximPXYPj3j0sav0B2uAoxtZdvd3SWRO1F8j7cbkuSdOIi6tnWOWZYiBjk3Zz4+wfUN5NCMyok0TDL662RLTI2CYz2cURdE4K2r54qQlrrb2nQam32305Doq9OMJ5mgEm+usvgj7TwV8GohmKhDaXHj+F57lif95ivzRt5r1mqg9iZBOinQ66pwYdGGWaWc47OFWu0T3jnAbK9jDCSGNwRjcMCW6d8TkmfPkQyVwFwvJvhCIcT2P6TiK0pIkjrNrY8bzFGM0ejZHlrJriXZyQt0B1Np1CNDv6r0xmUKWqU8ZFvKFiDowjFTZXf6BMs07RaiiFVPPzDsIkVAM1GLmI82ci6YaSfWmhsllnQha/7Zn/8mFVFBvQ6NMGi9wEPCJbjMeC8kEXKrLabKHRsg+VgdEciiUXY2I45G+798ySlo2EE1VFslXA/MLjvjQ6lC77wmXHNFerIWGlqrJwWJU32jbspBqmsjc6nVeT0o+0CnyDiGVXBCcWUzMmYDtOspVh9m22Fw7vmiqnZHrqPbdfTlhdj1XHzG6rncGCoOZ671gMqG0Sl2mX+DnEfbQ4tZKJU9ZjERC4pHSgAPXUweMzQzTC4HOTjUCSSAe6+8+PyO4LkTjSv5ZzxDAZ7aKyOsGW2rcsHBYyLIEs6xx1wkxXt7S4ASnLUhk6hsmwiN4E2EimE7HdPsrvLG1zWM3Hmc8zRj21rCJZe9gjzik/MhnP8rj18/x+S98lXmREkcJknbxBILxJCamnB0R2w5nN1dwviAmJoliwrBHt9shMSX5zLF6fgXrEjoux4WCQa9LXhYQWeK4g7WmclSkjGdzLEazB8UQY/DBsbu3i/eBbndIlmWN8BZEbXriAz6Omc2mUOnGJyPiZQtcFEWUp7VsPUBPlSTBH46wK0MGdwqObsREM0PZ06gu2TeYTuC1f2nA6uMfYfO3XyfMMyRNmtKdACGNkfGMEFvKjQ3E+UoDtch6HzdIIDKYac78okauZt4DD3lfsBVx1c6EkATStCTPNKovCoupTPUhQLJnEA9+2MHMiuPnVY8onCeMJ+pJd25RG6OWTJZTwdOUkGXvvm0rpnJJIERKirWEUPY1+vIpgFFiLnVIi8DRI4bNrzvEBQ6v6y3kOtoW2YYOz7X6mmBnQvee3oVlryLDAOk+5Gv63hR6PPOzSsxSEbXrBOapHm7Z94TIKHkfGWxulUBLiI9U/waNqGsZpXGBiH7GUMk1S7U16sCt5o1K5nirLMS3bdqa+yOPjXwjSZSFxfQLyrnBzyE5VGeLnevLdLWdei8lxBN17IC2K5FKNNJxlKUgiSfMLOEwwc4FnwRkUhF1rp9NCR6DFILvekwmSE9/9/q3sjPBDYMmURkdpUSzqr0c+L0UKZVIleClsiMuRksh8WrFLZeEh5p4a2JuUrKDZgC+BU7tvihyR1FOlfjihFDmVXGcjOl8xtbOPlcun8NFhsgazp09QyhLko1LvC9O+dD730dByhe/8i1ev3WXKDIcHO6ykkQk/Q4rFy7xxs2bnF/vEmyMjTvEnYSPfOoT7Nzb5utf/Rob/XVKLNN5ST4tSVfXiKYTijLj7vZtgrlAb3qbyc4+G5cfIXOBEHVY2zzH3uEOhpI8m+LLAhNbImJcKXjnCEFLf0rQRJIkjTFIk1rdpIFXFjmgyfx7Lyb6wmyOn2dIHGG6HXUqVNFvNCnp7CRML4UmYys74xAvFKuew8cNe09fRQJsfiUwvDkhxJZoZ4zvp/iNPtOLKcMXjsjO96tUW4PrWO5+MqazDWe/NCFfiyBANI2JpyXFMMbPNbLo3dNo108j3MEAd161Ph8b1jdHHBz2AY0gjfP4uPI5Fw4pj7s5QhwhvUoaKtRrHqriRRJFi8i40pVPM9EXosXkm51D5I1OhFVSkO9oBpjLjA6tJ0pm0US1ya1PGL2BJ7B603P4mNHhbqVdFoNFVOtS1Wmlrq3klXC6Wwa/ZLWz82pU47RjiCb6O0ZjQ/fQUqwG+q8bXKpRfb5SHZcHnwTKgZKMOkD0b3qyGs3bqWrQwKLWc90esji25c/vBlJprWICrtJZa986gB+UBGMpS4PJ1UXiYyVDH8HsXKAcaAfSvStMLwRA8GlAxga3VhKmOvEW8Mg4gjSoVbDvCZsF5k5HNfJQdVSl4HoBk1Ujl5HBdQLGQGdbKAYwuKW/VTCQreukHwF84rUgUWEIzY9VN2LV1rMISZ2Sca0p15OPZvE71O3zVjgVKTvncM5VWrKp5EGdQMtLi4n6THNHlCQYb8nzAgRcUdJNIqK0z/7BPjY64sqFARuDxyh9xt4oZXY4Iy8XEejmmTNsnrvI0WjCeDbFTTP29/dZW1vjxo0b3Lpzj0L22Vxbw5qI0lj2D0esD4dkRU6/26PEk/QMPekx7A2JbUK3FzObuiYrL8syysouJqYqfRQ03UWM0ElTppNpQ7h1lLxcO6J+nbr2RVESihKTxFWiRSWPdFLIC3xssFloahaYXAiiNigfq34ZH2qPPrko5CsDxEF6ISU5LLFFNSlXeqZnI2ZnDfEoEE8DNoPOvifbSDl43NK/rfuYbyRNB9A58GQrBlNoVIcHmzpMt2DYn5NEjrRTkIVYo0cRolmBFFUh+1r6qUMrY5Buh3A4Uk1cjGYfgnZEZWi0aBE5lXyh+9WhMHWECNipsPICiI+YXtAUZpOpIyIeaWRX9iAaS3XzBu48Elj9OszPVh7ijg7Lg9Vo0Oa1pABlF4qhuilcAt17gemlqgxntT3x9XYCnW3D9Ioj2bUaOZ9TEsmqkZHPNXnEl6ph+3ghPYhbqqkRqsksUzkfbBXNO8HbsBhh12R8ClKuI3CXVdpyMxFm6b2QYBy4WOUEm2m7JAd6bC5VchYvFKnn6P2O3qsR8/NeK9sZMEdVcflgsHOdrLW5wSc6t2df7+A6gfSeYXY+VJ2dNN5tU2rnFE2Esq8jGpcGsg2hf9szumbwlcwUHxqdYHWxpmXXQW5NuFDttNK9cwOmkjF8de7L1r1qPuGtcMrkkUDSsSRJrAQmhsgmeAdIxM7E8/Ird/nqV5/HRsL58xc4d/Y8g5UBUWJxDgKBnd05585tQJSTJBEJA4yNuHb1Kgd7O/R6KxxMckoPFy5ewFrLq6+9yKVLl8Aatvf32dra4fs/80luPH6Do6N9VlZWWF1Z4dL1R4k7A159YwdnY+7d3mJvd5tZnnNr61Vu33yJ1aHw3Mc+yMXNNSQIxlqsEXWTALGtbFxRRJL0jrXAcuGi5XTlNy3u8520bgiYfhfpdpsMPEkSnawTIT6Ys3qzYP1rQojAnc/wZ3PKgdeqYBWfpfuB+RmNpl1SaZ6R4fDRDp2dAjdMScbqFJhe0Bt25RXP5JIhWOjsBvq3c974vj4Hj1uSo0C+ImSrhvE1LYbTu62kErY6FPsd5nnM3btrZK8N6A0y/EdGzM7pBGKwtTWumliKzOLVTZcaoKq5UU/q1SOPuk7GaarwVRNrNTnVqcyuEzh8Ag6fVFkh3VXt02ZKsvlaIF9TySNEah1bed4yvRTI131Dxj6BbEM7velFz+i6Z3ohMD/rq2w7FhpmohOEOpQX4iMlGp8E/W5syM6XOvm4XjK6UVKseSXyANmmjlpqn3Lt8ACqRJLQ2N2klKbOBlJlAS6R8bF6H6dAM5Sv6gwHr0/vmF1xTC57bA79W9quUmqbzTe0QzOZZiMmh4b+zYhiNeC7jmhiKqdEVRXPC/mmIzvryNc95dBjR1YlngND2Q0QBTq7UunM2uZ1lqSPlbCnj2mwODsXOHjckG2EatRTyUBOCKmOlk8mkDR2PFPZ4aKAiTVirosQLWpiy9smjsApI2UPmCBN9bJgUjAF3mXk2QyZzThMU165O+LihXsURcnZsxusD1co8zm+LNm5t835c2coC0dCxGQ2o9u3dAdXuHPnFtcvX2T13AXubd3h2y/dRIIhTS2PXrvC0d4uNx5/gsGgw92tI+aTCZNsTpLG9FbXudLtUBaOF7/9POvDHnu7u1gTWBsOKJ0OfzfOXeDOnT2uPnKFc2sb3O7tMZ1Pm9lUbwJBDKZyWkpdK7iyvp3M5jv2mKvTWuKgIiM0UjRWe+Q8V514mhGNYoZvwPRCQlakuDM5MiwIhaF0QmdHi9bUSQPRFIq+IR8YBrcLjq6lzM906G151r+tV6vrCIePRqT7gf0nIso+9O9axZmM1gAAIABJREFUohnYWcAlQjEMuI4mM6y/4MlWhXRPCEYohsLMDfRYz2aMtwacuXLAbHNAb5BgJwVSjyIMLM98hDqV3KGTfXWxoiXponFjnIKU62LxwMLOZtUJ4VKNQqeXQqPPhqpEZEg80aGl7Ibqb4FsM2CnhuTAMHrCMXjZMj8TiMeGZKQjgnIYKPuVlzgKqk1KNWyvsvLKXjWZl2uUJqVheq3ETA2d2xHiIQ86RE+3beMQSQ6lia5rEjl2ngt+xFcRXV0L4776QJVOeqp6ysvWMSdqQ+s4dSlEHiIYX/eY3JDuKgGbXDtEU4LvabuUXa86shNkbsnOlnTfiMjOeIIJxEcGm1mKFT2RaKzbSA51jiUIREcqEQWrRB2PoejrZGp2uYDckGxF2JnKI/m6p3dbg5GyD727otp2NcFXu3b0A1UijnY6EvljbXDsEWHLEfLbdHinImVjY/XsltXMeKSKizUJEkrK7IijnYAfFPyLz/8Rf+HH/xSjowN6nS7GGA4PR2xsbmAkJ0n6BHPIaLxH2kkZHW1z+erjFLMpznnVmC+eZzTLefp91/j2118j7cLOzjb9/jWMtaTdPrY7ZPtgxrVHr9KJLfu7++zvbEOYsru/zXC4QjQdkw6GGB+zM5shJnAwGnPu3DqdVxKc95RlVa5TtPUlOEQM+fIz5CqJYllPXi5IdFpSPlZAyFb+xqDF4PEOmWXEWw6T97n8fxW88G+myCgidFRMi4+014c6QhaSsaPsCOmhZ/RIjJ1Xw+qOML4UEc0CB+8zrH/L41KhuxMY9QQfCWUHXCokB4HikQwbecqDhM6e1bKSe4FiqMRc9vRmZDdFBA5HXexZwXUs4gKmrDzQdRtV7xuy9lUkXD9LsWkUaSb/Tj0SqZI46ptHiVC1XxEhVOSM6DA2WGBmVRJC2xOjKc82E7rbgSCW8Q3HyrcsZR9G1z3xkWH4MhQD3UYxqGSRpejYVam90QyOns1JbsfYTOi9GqlfthvwVofeTA35ulf3wkStXQVqjwyGY8WElp88Esybk8KxCnecTlMOodJNTfUEDlHXQSiNdtRe280PSspZTHykSTY212w6l1aWPyvkou2T7gnTyzC/4OjetrgOZOccnbuW5MhqUk/V0eSrXjV8rwlLplRpb/iaZ+8DQroj5GtgDiPikcGngWJFfw87E4ohVaSuoxi34pC5OSZzSV3noikNGpbOX040aM3M7wyn8ymL2tEwJXkxIZtPKMuyys6D4AuMnTMeb1NicNmUsiyYz+ds3b1LknRx3jGazrhz9x47B0dsnr9Ef2UDFxnSjTN89KMfZXd3lzIOXL/2CI9fvsydO9sgczqDAXt7OyRRRCeOefqp64SQ01vrk2c53W6XF194kXv37iGmR9rdYDwpmU7m7O3tcLC3S/AFpQ9MZyX7R0fMZxNCUG+ysYsnjxhrsJE5FhnXDoxle9xyUsmpYU1TRzjMM/x4otFj7c8tS4I12L0x4jTykFKQzBDfi3VixAvRVOhtCZ09z+S8JV/RYXu2Kux8ZFFXYfQojK8aend1+0UfujuOEGl0PHsyg4ASb2bp9jKGL0X07nm8FcquEE00Gk/3DOm+aaqSFbOY5AiiafUEB6vkvUgzFny8VOeiKuPZpFhDZYlbSgU/BaSe/MoXmm99c+l3VXJJLkRj1RVtJpR9z/R6oW6XdOHemJ9z7D/riccwfNEyPwP924F0RycE55sqWUyu+ObJH6bQJ4a4bsAWSgjlZw7pvJpgM5UZilXdfv0AVFdN3kmpzo6y76vsPt/owKY44UuuSKLhisZ5UQ3rT/LHaQd4VQW1UBh8YasiPkvHAlpK06tG77pKiMXQMzvv1cttNKo3mUa/4/cVJAeGzj2LT6C7Df1XdPRW9nTEUJcwFQ/JfpVcU1kPxcHWpz39WzqxKA5CVSpVqkdouc7CvWIKJeRiJWA6ZeXjBilMY7drqtMtB88nC9kvX6by9pN8cEpSTuOYxEbEUYdO2iWNYkwUEaoUXvEBl02RkEM+wqYxl871OdjeIi/mFGVGFBlMWTIdHxG7gr07t9m+c5cQhO/5+Iewwx5Xrj7G9RsfJrHCs9/1LPPZlLNnz+Jmc66cu0QiYGIoxfPY5Svcu3mT9UGXSxfOYWKhO+wzHo+59dorSCiZ5IGDwxnzfMJoPiaf5+ztH3LzlS2StEMSqdPCGosxFhtpMR6PYGNbJb+8OfkuP5T1NJA01WpqnRTT72K6HY2SrVUpA5BZBiFgckeIVS5IdysfaKEXtkYMSjaDu47BHYd4yD42xnc946vC0Q2N2qYfnBHNYHbWYDMYX7Kqkepj8ZhecQxf88TDjKfPbuEjlUOSUWDltRIJWkMgPlJPr50p8ZmDiNVXSlwnUu3YLnRkX/1PgBBrec+mLOmDJkurp2mfqn1PWA+azC5ZBDb1kzpcV0cdUkCyZ4n2I/IzDp9AqDLskn1Les9S9uDogxnZ2ZK9Z3TzZS9QDAPJUWB4U2f9CZr5V6dOuxQGrwfCF1c1oaHKMosPhWKgZJXuV7q9Ad/1jdvC9x0mM4vay5WOrHWYaVjXFFUlupqwJSzO2SxGDLJche3dYKngEaAR8olMuDqRwq0XxEdSTfYp4RUDLUka6ocQGYh3I7J1z/yso1jxZOuQrwemFzX1uXdb6G4JZU+dFbMLvrHbBaPfJzuWeKz7LoeeaKK6s+uqbBRiHRnNz3iKobpvsoslfhrhE99ox8cq1NXXUl0xri6GVLsvatmi5uh3oCmfipSjJMEmMVFc1SA2IMEjVf0L5wrmeclsXuBcxt7BmEQSzp7bYOvuNqO9PdYGfbZ27+nToWND2u8wzws6ifDGrZv4MGN7e4d//s/+OetrQ9ZXBzx2/TofePopvB9h7Iy19VUeuXiGKxcv8cwHn6BDxHc9835WhwNev7WLw/I9n/44H3z2/Zw5s85sPALrOTyYMN4f89WvP88ffulLmFh1Y1dmCJ7IaP66EalKUAhxnJIkCWmaHqujDDQFioD3xn2RJlV2ntYgPlYToiwJRUGYzwmTGZSe6NBgbCA74+huBdIDoRwEOttV5BFB0RNMFnCp4N/oQYDuduCR38gpVzyrK1OOHhUOn3LN82eLNZ30u3DhgOtP3SFY+OEnvsa13h7DW3qO9z7t2PlApCUQJ4CB5AiSI2H963DmS4KvU+QrK1yoMyWNNP5pn9gqc7CLdDuLWsuwKFAEjbTxbuErS1ztza0nwhrvqa1JWaPUfNVTrKijpbu1mBSsI+Vak3ZpILqX0LkbEc10AtbHkB6otj96zNG9o6TXvWOqUYVOJk4uCsPXdORiHFz7p3MufX7GykvC4FWjenGVFm7muk45DNjDqEnnXq52F2qCrbL86smuOsGkWWZpck+qR0KdSlNu7GD6vsnQq8ipSTOujs11aTT1dF/Pyw104s4NdQLapTppZwoh3TGaBl2da++ubnf0eEl3S62NvTcMvTuB5BCSkbomVl+C/t0CKQPv+x+mPPrrU/qvG7r3TOPd9l3f1Keen3PNMUpdNnR5IrQq/kRd6S83hMwuSozCws9cv38HOBUpO+8qny5QPW/POdVjvfc4X2CDw/iC8VHGN77+LXZ273I0GtMfdOit9Hj19dfxzrC1tUVZFkwmY47GYw4PJggRVzbO86mPPcnm6jqPX79OPptzdHREmnT43Ge+l/XhGt6XdNMhli79zgZ//Rd/ls2rl/BYfuHnf5bPffbjXLr2CB/48Iew3Q7ECdlUa1O89uqr7G1v4fI589mIspzT6cTEkWBtoBvHJJEhiWOSOCZNUi5cuMD58+cZDoekaXpfZLyc5XcqLJNQVYMilKXqzM4t7GLBYw5GbHwj4HZTorFR3XIAvTd0xrq/5TAlJGNPcpiT7uu6nTMzdj/qmG9GbD66zyxLdHIq8Wx/piRf1Uk314HYeDY7E374r/wW37/6DQB++K/8Fvc+U7J+6ZDy2TE+BW91QhBg+Kqnd6/A5oFo6jGFx3UjfFJFyanFxwYfW0JicJ2I/JENyqtnkdUV9S376nFQdYe3lOX3rmEWZFxrkcs3XJ3V55NFirMpobsljG84zExdEsmB0Qyzfmi2i8D80Rw8rL3g6eypTu3SwNo3DKPHPOmeMLvomV0M2DlNyq/NAwfvg3wlYH5um//yf/x7XPqxV5h/fEK+qjpnumcq37NGpDbTSb6aDOvO5kHOK/E0E4laRU6av8NCMz2NpkyVqIINi8JE9fRBbRWLPZJ6JHHYmbZ3Z0eYn9EIVXK97nDge675nVxPa4rYDFZeVpmsdlWsPB8xeazAZMLsfKDsCzbT9VZvFmx8bcToaozN4fmfSrn+t77N+R+6RfaRMcWKZlFGoyoAqOqFSF6187KlrbpG6s5OgnaWZmYwUwulSjfNU7jrDuodZkmezn2hnjY9KKmKERmvJTSDXh3eFxgjZPND3rizRTZ/Vu1IwO3btyhzhy8DsTVMJnNKFzAE5tmc1165xbUb1/j4hz9ILx2QdrpI3OXxGzf44y99iUevXMJIl8LNuXj1PL1BwhNPvo+1jQFf/OMvsL11j7/5t/8B0/GIYEsEyzNPP4oLHgkxSfUA1LyYk8wzrDEklT+2Lg0aqt5QrN4AxgZslBLFEa4MlcShGYJ1qc737Kkj5WJSEVBJaGn7gjSTgGEyZfB6zs6Hk4Zc+m/obLZxAW+FeOwRp1/aWUn/tZTyUc8nn32RP+hc51qakUYltx/rsfqVmMnlhY1qdqlkozPl37rwOzyb7PDXbv9pvrl3ns7fXefxowKkx6aBnQ8syED1uYDNPDYPBCtKxoJ6WYwgLlTZknoBBwNlbJHYIK6PiayOVOoJz7o9TjsK8TQ3lNqIUFtTFSn7qsIagC2F7PqcchaRr6tUEYwSdp2tFh9J4wvvbQXmZxKd5Y+Fy//ikJ2PrJCM9LMptcJbumsohoF8FfqvacS494yw+cFt/vz1z/M3v/kD/MTf+MtkGyA2UK7oSC4+rFg31sgxREpKdSnO+ry8DWB1ghCqaN4IoUoHl8rm5xJ1nGjjnq5Z67at9qjD9aVC7yKAVT05BGAeMXlEE57qUYAUKiUQdF07tmpfmxp6bwjRXM+pu+NZ/2ZGsRrjUsN8zRDvRbgq4vaxSkArrxTYzHN0Y8DuxxyffPZF9l6+xuf/t+8i29AU+PKsw6Wa8ONjHZHa3GiRrerZh3XKuASqNP3QPBRXllKwzdxAZlSzTrwmldRt+w7m/E5Fyt202wQr3vuq7nBOWTpKlxOcdnZeBGs8r92+y+9/+ctce+QqW7dvs7o+5HB2yMFohPMegyGOEp568ioff+7TXLpxjSjPWFld4wd/4Dk2zl5iPM04Gk3wzvP8t77FU08/xWQy4gMffJpzl69hEsPNl17mF37ub/L9P/qv8fUj4cc/+TEeO1fyO197g89+8vv4X3/9V3j59k2mhWc+n7O51oejQzJfEncGzPOySpMuCEGfLiK2fh5frIQiwnBlSH84wDvHdDpla2vrvakOVyH06yL7oi6EeU7IcqTI9Tl29fBdqiet3NzmzJcuM7qqJvhs3RAdeNIDvyQPCLsf6LH3iYJrj9wmc5bHejt8zyde4FPdl7hVbvAfjX+UIz9g9XnD4fsd0dRw9QP3+N7NFxiaOb908FFe/M+fZuvPeJ68M+WNH1xldjaw+RU4+tSMi7+WsP6tGWZWINOM8uxQn45ReMqeJZo7fGQwWfXIp9xrmmskOGOUKI1QrHWQlRTxK9hxjnntHmE6fU/ati4C1KQg+3pGXVNwYaGxlkkgTCPMoCC+2aEYhiZyLgdBrVipTgTGE+juOsaPROQbjr1nDHvPrNDdriJSB73bhrJLlbigcsLkqvrKi2sZO988wy9+7V/Rh2Y8U9C5E9PdFoavwN4HA+7yHD+ONaqrzkFKgcr6pU85qU7Ug3VL805RwFV+deMEk9W+XamKu4fTRckAuVGb2FIZzQDVUzgqxraVxbSqceHmlvheTAjqzw5RIPRLZBThI4imhuRAWLnlGF2x+FjnO6Znu3R3fSM5de5pJ1X2IB5phzPfUHln+yOCHVl+/6uPa1GiayXRkcVmsPElw+7HHPGjM1weEeYWF9fzGjQjIEz9vM9QpbnLfZFw0zkWAs7ouTdlRpc06TfB6QoSdTtN4XVXFlWxe4enev4bEHzQGsUmxvuSL3zxqxzsjhE/J4SSspxjfEmn02Neegarmzz32U/wK7/6D9l6ZY9B2sUPDR975ml+5i//BQYrGzz3qU/x5S9/mY9+6CPcvvs6Z86tc7D1OqPNi6z2+/zWb/42f+q7P8Cv/5N/xN/6e/81f/Uv/RT/3qef5NLlDcxgzKee+wG+8sXf5uXXtokTSxQMvqqglheOKIlVH9awlCiy2Lh+PBUE77HGggVTPZXDWstsNuPg4OA9ewxU6KVas7hKSw7N/h1NZkj1aCTiCErH5udv03nqPOIDEiK1eYVA2TOYIjBfs+x/d84jv2rp3Uzp9BK+0Pso//i7ukz/nd/giXSLn3nmN/kvvvpnOfhQQXo3Jjtb8sbOGs+vnedassN/83vfi/2McPk3DGt/9w7+P4h55V/uMrksxGnJ3edSzvxxj5WXZ0haPYvPB8SpVcnFVRKAaKQcItNE0HX07CMl6dp65G2HdGMVKcv37DFQTU3jWkeubqo6Qq5vLjsT7Nxi3oiaJI1gA/nQk+xb4ok07o35mcCf+bd/j1//5c+w8WXD7nMFn37qRb5y7yKTm6t0twyTR0tWno8wpUZmoxtOXR65YX19TP6VM43MML0YKWlf0vupf8vA690m4SRfU1vf/0fbm8ZYmp33fb9zzrvdvW7t3T29Tc/CmeFQHFLiJookLEdLZBiJLVlZ4MRBAAkGLCAfAhgBAuRjAsRB8iFCEkdIDCdw4gWwIodhImtxZJEMF3GnONMz09N7V3dV3brre9/lLPnwvPdWNSVuU/QLNHqp6rr3nnvf5zzn//wXl4VmuCtFbVUoxCmuadA06xPs6vKNVkc5TlNP/Bn63Lu4Vhxspc8MY1ebwppCJs/P11ow2WXDDR5Y0KAzC5OEKNciba+h2PY892/8KV/49KukI5hfDqhrC/I/7dJ5KCb+5VCMhiLEq6TYgWSm0HVg45Vj8s9tE8aRvN8zYcYsrll0FRFNDfW8g282WNf1YAIhC0KJC0pCWGk64+a0BWeGw9+9bM1naA3fnLX1/B7XuTDlbpbSjhNaWUaatUhTGYLFSdJ4Eat1zl0cx5gmRmmxWDCbzbj3zjssZ3OiKGI+X2Bt4O7dd/iDf/4F3nv5En/1lz7MvHeBaXyDZ/e3+Zt/62/z5tdex1rL1tYWJJb9vQ10VfP8czc4Pjmg1cooC884pHzyfdf4u3/nP+GXP/Fe9HaLW9+8xcXWkHqxYL4MbHQ73Lh6hWnwTPOC2oFpfJPVmXipldXoypYziZP1gC+O47UHxsoZbvXvZy0+383lOgm+HTe/J4RWYyrUaq1x1VXwqYrFzS1EhnhWk0wq+m8tiGcOHyvimUPXgcGtgu0/TBjfiLj9V7Zw7QhvNPmFwKf/9l/gv7v7KXKfUm45MIFy16JqzYev3eat6Q770RhVicnLkw9o7vzmC9z9uTa269n8jmWrv2hSMQLVIGHyfAddWqJZibK+Kba6mfZL4fWJFopcQ5NzqXx2hCYnv6sVRc45EfBkKbrfe/dr2/gMr5RtqyHXWQtL3fggy9BPJvvFjkc1OXrxWN6DuhcotgLLC57OA/jMb32cYtczfVbMdb7ymZeZHXfYf+kJ5WYgexhRN+6k+b6oCeOZ0O7cP9/GdqXT8zG0HwkbIT1R6FKRP+OpNkJjXi8cXrNUDcdaCu+KEmeqU4/ntYBkVRTUaW6gj4NYaa5y+lT4nr7RP9S16tjPmrzbhhbXFOTg1Cnm6iGkHrtdS0JK7PHLSLr6LFBueoptj1kqvvxPXqXYd0xeclI4D9q4VmD0PmFbZEeNb7KHasA6UWS5rSn+aFvodg0rIzuEcsvTuxnJ0HRgcV1PdmAato1CFZLlJxtNEIjCKsGaz4p0mrnEer9bYftRQLfsmgoXAk8PAv+c61xFuXKeuuHrEmRnFCqZ8JdVOMVDrbXUdU2e51R1gXWesvKMZkuOT+Ys8hIVYl5+4TmuXr/Mhf2M+0eOBYbf/J//K94cz3n51ef53/6X/5Uyn6Ajw+7GJnu9NlE14+47N3n5xiu8+dZb3L53m4MicFzW/JuvPcf17QGf+/zr/OW/9BfxSZcnTx6ii4KLF7Z55X3v4fL2lrB4GhGItw6DwigtXbKRvD8TRZJK0gzyzhbhlfn92a+dt2NWtROfiHUCiJaOWKlTRsLKzKeuoa5R8xxTitmPLi3pSUl6VBHPRK13/ErG7JoMQrKjgLKBn/1v/pjsUHH0aszRP7rMo2oABtrDJWZQoRx8+f5lfvXSl/n7Rz9N+550h/Fc8fgjgXLPsvsFxb1/PZAYR/ZEYarA/FLE6L2K/JJI04PRDQe0gSu0GCAFo9ad8apYg2Dh+LPHQcHPV/LrUH+X29yPcq0++U2HvAoPFdlxM4k3TaEyQptCNUWwFLqfGA8Fqm1LiALth+IDkl8Qt75kotj5ao1y0P9WwqODYeMeJ53tiuvsO26dyzd93lHsW4o9x/yKZ/Khgmyk6N/2Qu/arIjm0onajhQX2xHIxXab19D8cmlYm9WH7/K38JHQ8Pwq7rA6sx4Ni+TdXn+my17R4M6IV1aMDGU8JF460CZhOpTSPetujdnP8V1H54FGO0W5HdBLRXZgyI4a90ErIhpTyaDUdppNLRGvkXJDkZ0EqoEwk4o9S37RM/3IkuyJZvONGuUh2yxIjsy6wOpKETpOPh+NQdXKDzlEpz7cqyGkrJ98zWeekDYud2ck58qEUyjje1znH/QhAgDvPd4JFU42w6d32pVzWpIkAg3UlmVtcVXNJD9mZzjgmcsZ/UGPG/v7/N7vfY1X33ONn6bNb/zab/BvPd/jXnad4rrm4PEh1y49w+zoDnE9J59MqU6O+ezv/1Ouvue9lLWFySGf+tRHee3VlymWBR/92E9TKsV/+5t/j26iuHzjGqQpUYjY29/jZDYTI/0/M0Dy625/sVjQ6/ZY5iV5ntPvd3j48CFxHNNut59iYKw8lc9zqcbjQgUvgy3r/2xs0/ppCvyislTYCrVDFTVmUWDGU8L+DsX1FnVfUVysufj7htF7NMevtPi9//hn8B8EFCy3FX8yukL30pTZqANOkc405Szlv/jSL/CTz95pPvzgPzHm15/7Ek+qHssPJtTe8JX/6X2QwfjZaI1Rzi8Y0nEiHe93GdOHZsgXtCKZ1VT9mGjhiOYV1TClfXtMSGNsN/mzbIvzwhireUh0yuJaRcmLyOKUiaCsdM7+TDKxSyA90ehKS3FsAUPBl3UlnezR+2Lhf18IbG3POMo3qPuKeihD8mhmMMcR/sU59UmGcorOOxEbbzkGX7xP6LY4eS3h8DWFvj6n/9kuPpINIb8gG0VyIjLtp4rDmaGfvIjmdJAKJmqWUtjDqsPTNKHw6qmotfOs61Mc3dW6nYFOQmjqRFCnCdVairPu1vh5TKgTOg+MbCJJ89ybjbHcovFkVlz9udvcnVwjKOEv+yTIILUfqPsQzRTVhYr+NxP2Pz8nejwhtFKqPcXjD2bk71/S/lIPF0PrcWDygjA99DgipGe6fhDbA98MJJtBX0gCYTXQq7RsNE1HrLTshuGHgC7gvBl9jXRPhuEeH0Ry3NIanH+qwJ1Vwi3rApQiabWZzuds9LqE2rOYHLEYbqF1zkc+9jP80Wc/z/PvucQvdTO+9HjOLz3v+af/9x/xx+mSvUGXo0e3aauabgvu336DEHV5+94d3vvSSxycTGn1d5mqjNLAyfGYW7du8uJ7LvP2zTtsb21zdHLIoTohiRPiOCNfFlS1JU4SSlvjnaPTaotqzwaMiphOppycjMiyjIPDBUkU489EQIUQ1l7K0Xkz5MRcBEIQlkIIEBlCOxM5cvCsQ021kr9bK37FShHaKXo8J2wNUbUlGzuKTfmgHHwULnzWcfK8odpI6N/xHHzCc/kzcKt3GTu0pI8jMTHKAtndhGACX7/3AtVLNfEo4lJ3QeFjHJq3p9vcvL2PeT7Qf1sUbOkIGDXewLEmyi26cvg0gkpYF7YdC4ZoA95okpOK+MkM38lo3Z8RElGtaOuFjx28cLarWmKs3u0VTn83TjBhZVkP/iRCqakhWr62UtOtCl5UKJIxAl3se0LHQanZ/5eayXOKyWsVqED/aymb3/HMH2zDKzX1To2eydpGC0kXCY/bqGHF4AsZk5cc7idz8n+/w2TSJrqryI4VftIlWoibWbEh2KmuoeqfSqt1Y+5zmlIiwzZdKWwqnhsqgE+bYNXG/GcNc6yGc+ckt6yvVXJ02XCBY+kUlfFnCr+G1J+6qkXglxHx2FAPHMs98cBIjg3dW/LZWrxaECrN5hdjogLe+cNrkEC559C5ltNNA08FBX4DstsJPoI7v9hFhS7xlHUUVPJmi2gOqgWLZ+R9jWeNz0bU4BIWQhzQ5arzReZKSyU5flZDrVFdK5DNUhGyxs6TUwbKDxKQnLsoGxOJJFlrjGljnVDDvPPUdb02ej9r3pOXS9omYVHI8fN9r77CydERR5M5+RtvMC9q/sa//dd47j0X6KV9Lj5zhb3di9x6cJvbT5bcevsd3i4nXN3dwlUL0rahYxLuP3nC2HdYhIQbz77MF7/yTd5bOz784Y+wMVjQG27z+c99gRvvyXjrrbcJKmW+9CjnGG5skOeP8N5zdHhI2krIsowQgkAulaXVajEeT8iyjLIsqZ0FE6G0piiK9ZqsYI0fy8BPN8f7VBFMKrBEYdHeQ1lKcfIBfEONo0blBSFN0EsxgR/91DatQ0syqtgqPFGe0P3VR0xvpOxnRUeRAAAgAElEQVRkJR/ffZuPd2/yOyev8QePP0D/nYB+Q6wrtRO5tY8DrScyMFE2pn52yb2vXeTTLyf8Zy/+M97TesRXe1f43a+8yuQFTf9toRGZRtJabMV0FxZcIH4wInRa+HaCCoFo4dClw3Yi4uMFvpOh81LwYy9wzQptCM6jlKSOPGUO8yNeT9laAnjhYssXm9NOcz+tfZcrkT7rUq1hgvyiiD+i3GDbmgsffsS9cp/eLRh+xtA+qDh+JfDokxBNA9nDWCKeKrV2SEvGWjaBPCW/GNj5oqbc6LHchO5YMNGVz+/o/WK03n6oyS/49bDSt4ViYRZ6rUKEU2qfa8kgzCybIlwJz7rcFIxVL9U6Bko51gyUd3WdGYARZPDnM3/aCcMpntxcodaoKBCWEaQOVWrqDYeqBDNXTlNfKZnrlMGbgZ2vR3TeOGL57CZ3f0E27tZjUYX6zGNyWQcaj2ZTQTKD3l2HjxQuUbSOLMEolluGuqNYXBEGTDxT5Ffcej1M16K1x5YRVBrfcqd2nU58mmnEI+hAqDRmEuG6Ttglq7VoPnDKfP9u+XyGRLqJeg+QJAkBL+5efw5P92zmnSuhzhRluSBrt+jECWF3mzRKaLdblPMn/Obf/R/49/76X2fnmet4E/HVN77D3QdHHI9n7Gxv8+iJ4+DJIRd7KbtbO+gQsSwdiUqYOPjET38QlbTp9vrEcUxRgQuW3Qv7TCcZr7zaZzQacXx8jFIteiHhWtYlXy6YTCYcHR1RV46CEq00ztdUlcJ7i7Wi1mulkuVX1zWqtLSjRP7cDAHPzVVuhl/4gG9FzQdc2BTK+afpjqvYpyiSUNTIwLIgdNu4RJHvxmSxpu5qknmg/q193L8z4cM7t4mV479/8Cm+c7BHNhYIo/040HoSKIeKatsRVMCU0drE/dfe/8d0TcHzyQEdXXKsu1hv6OwuyKcZ41cM8diQNraJpVPYrE2ce9KTjPRggaosZiFYs7YeUzhwAr0QAiFLpUstLaq2qHYGtYCfYsp0DoaAXx33ZYru2uF0CNUUpqeEAqoxHqqkeCVT+aI5hPZjMbkHmPwfF/E/WeJ/NufRtMXW5oKP7f0pf3DneTjor318V8IUs5RfeixGOPEckpmjf6eiHMY8eS0SOXUuRvnP/H5getlQbUD7kRbfh04gHcVri9EoF6+S/JIU4tXAyZRq7eGhHJTbjb2rZR3mGkTEirbnZF+sjvhW4VO/hjDWBWmFLzdHehWH9QBMn4gZUzRXJDOx1PRpoPV6hu0Ejj7sSI4M/uN7+EsFUVKh3uhQ94LQ0BRrO9YobxSCGfTvONr3c8ysAB+YvbLFYq+BGEJg5088+Y6hHEI8Fr9rv1PhlgZnY3ShSUeaEAXKi808I6wc8JSEq9YaZTWu59YDTdaMk+a1/oClPVdRjiIJTo3jmBACtXXYZsD13ZJj1TAxtDFk7RZZlvH8c9dpZxnZRo/r27tUtsbWlps334YIvvH6n3Ln4RHtTpvY1Hz769/iuct7aOf4xte/wqVhn7S3Rf/FTxC1uiy+9jXefP3b/Oovf5jnX3k/KJiMJzjnqMpAlrbY2Rng6yWuWtLvprx18wCFYTw+4fj4GBcstrZEJqCU53Ay5tnr13n84D6LxWKNG7daLZIkoSgKVIB5VVBWJVEjSDGr1IxzXD42onhLtJDZay/uatY/LZ7QzeCvCRUN3Ta+nZK/d4e6pan6iuVuQNdC6Rre9HgD+Rsb/KODD6HaMh3Ovt1ifllkrbtfc+Q7Ytu5dfWEblpyb3GRjTcg+iuH/Mbw2xileKN2FMEwcl02kwXXNke8We9QVRrb8Qxuyoc+G3taT0rUqugaJeycwymLl3Zp356gp43TXgj4TkZIDTpvinBeSIJ11JhwYH4ofO57XUHTdLzN0X9FI135+oTG7rShy62+Ju+LDMlsR4Zp88sC1QzfCBSbis4bKZ6Ubg2VzfjM9U2yJ7oxwjllROga6h7UScA8NycEmD/oML+iCJsa5opoGjC5uKj5JPDgExptRX226pLTseDAknatKHbARx6fBZJjsfj0qUAYq/CDaKHQlTwfH4XTNWhw5nOxL1h13qyzEGXRmyKlELx15TOMOu0mY09IFNZIBFbd18RzRfsN4SYTFO1HEclUfu7YZsRzOXXYljyGtvLaxP5T1rauIuzNlMkLHfLdHsk0EC3FPMu2xK529IppZgcQHymKzYB6ksj6tDw+9RTPSLFViSfkUYMrq9PXoxqs2Zzix99tQvSvNA5qY9ATLLkh4oUgONGqCK8c1FbY8tpRzQci5XF1gWolvHPzDu/cusdiNqfb7TAcbnL9xZfZu3iVTpIynRzz5v072LJiq9vFFif8u7/yS/zW//5/cevtJ/zRzSf0Wh3u3X2LX/zAB3nthWeYP36Dw8MTZrMF+zdehWDpdtvk5YBgTnBRTLu7xfMvvszdO++gjMbEES4vacWGfClhroNWwt3bb4FOePbqdR49eIDzFmMMvd6Aui4hMWQ2op+k1N5yspjRylokcXKe5aUaJo38NzR88OYLGmFiNKGqklDdmO1bi/JeIKWqDS0Yvlmz8bYinlnqXsRy08gg40JJnFjqaUp6X+Snvm9RheHur3iu/YOajTct+beG5B3N9VtLHv5Mm79x5at8scz4Qn6DO8UWf23zi/iguZKOOMq6vK235RjXcUxe0HTvsmZaRA2mbKwUW99r0b55BFqzeGGL9u2p4OWRptpISUsHmULViYSrWkcYnaC63acN8X/Ea3WkPzWN4ZT2BEh+Hw2eLHCFaoaAyVg6H12LBWTrsbjjzZ/RLPc8US5YbbEjhTE+EQ7u7FnH5tc0ySJgU8XikqK8WNPfmTO/NWDzm4r5FSmcve8knHyywJcim1+ls2RHmtZhIFp6Ri+LkVK0aIzuSxk8mVwR+Ualp8TvWVtJSwEFlbArdN10+0Xjx9wEupqKtQrwXa1tk5Enf2nWN/AUQ0Gtcu1qSa8ODdJnxpE8H6uoho5kLAnftiPF0zcqRh8rljthnS/oUui/41luSwLJcidgtyzpoKB83Gbvs8IIKjY02SiwuKDoPuCU7ROEItc6Ekho9JLMQkwBbku67mBkCKn8qZVsiANR2+KOUjBqPfxTDZWSUmTXYrYlnbz6/jX5/JiyUoLNWe9IklU0vRSKVeqztZZOp8NwOMR7j3UOHwwn05LK5YwnJwy3t3jxlZfZ3tqi2+vR7XTpt1NMaujpIR+/cIEQLHjLpf0Xubqd8omfepUvfv4m//Xf/4dMgVjFfPgvfJzhMCMvLe0kwgwGgmdHKVGSsigPeXT/DsePHskHWGfsXLzMsy+8zBuvv87De3eYTsdkmUATeVWy1eljTMbBg4d0ez2MUcxmMyaTCa1WC68VaZpSTOdsDzYZtDtoY5jV5wj2hDXXUaFQ1gt/lwitQFmPqmoRUlQVemOA2x1KQWvilpKTCm1jklFBsdvi+L0ZxZbQuFzX0WpXpLElV9C+MCEERd9rXtk54CcHd3j8E33+8Tc+wI3/saQFYBTZx454NbvPsesyjBak7ZpFSEh1zYbJOSnblA87tJ7oxl8C8n2YPqcYvJHSv2tIxiWunYACvbSEYRcfa9q3p9iNjBBp4nFBMipwnVgw5TTCTJbUewNMvy2KwO8OYP0RrlVWXdCNum99lzWDsGh1pBeP43IolDNCoNz160KjrGJxUaMdAjO1HfWmo/2djPiBptoI7HzV07mfQwhMb3QpB3Kk3nzdYdsR9d0h/RGkM0eRG0CSrLt/0mJ2w+GcbB7de4ooDxx/wBOfaGzfEzJHepLQuw02Y23LCqexT9mhPF41CKf1MZY8wqDDOtMvaIiWkv13nmvlQY1GiphTTRfZsJMST/AQKgO1Qm9UaO2plzFht6SyWoRolWb5DNixJp4KXxsVSMcCL5kC2k887YcF0Tin3u2ibYJtadqPA08+pLHTDhtvKQZvzckvtsgmHpcotr/lyLfFl9llAkFFReDgo4LXmxLqDUeUG3pvGoqdII8PsqkUWgpvFPAHmQx5oyAOmekZzNlLRBtxkGFn6n+gB8a5irJVQYqDUqRxjK0sBkMSJcxDjQtSrEQcMqcsS7Isw1rpNONEQaRptzMSo7mwvclg0Mday3iyIEnnXNzfY6kduxcu0s4yBr0+o8fvUKkO2ztbvP9DCZ946x7f/MpX+bW/+eu89jMfo6Kmcp5lvqDWMdFkwnyec+fuXQ4ODtgYbnH9xZd4cPcho9Exsa+49/ZtiGIuXrkMDw2z8YjExAwaBzxPRKoS0IHj4xFRFFGWS+paN9JqwETM3BLtDM7X1NX5KFvCl5TpsUs1pvQisGjCR3FODHuSGH8yRudLVKdNqGtUHGMSscm03aTpLKDuy6AonhiWcUZnf4pSgVe2D9hJ5jzbOuQLk+sAfLT7FuV7I373kx9i9ys1o1+f85+/9Ds4FAuf8KjaAOBN9rldbPO5g+scPh6ghhXd52YcPtggGkViGXpbJuLTqxE9A8moIhiNHaRrXrKyQgFMHs8IsUEXwrVWzUAYrTDLGqxH106w83e7tk1npt3TGCQaXBTWrm82EYpVeqiJ5opq6EmODFEuvrymDASlsB1JR27fiYkWMXVXUKXebTh5wXD8cg9TQ9WTgNP2A41LDdf+089x8B99jP3/d8Tdv7xJ1Rf8dGW0E48lRUN5mH20QBvH1u92SKeeyXWDywyLy56wWxLfatG7E5hfUWvjfZANyCes3c+0gxBUE3e06pKlQ/dJ45VxDvRiPeSrkY15BVNoxEcZ0LFHpw6lAvU0wWlQqcMvYqKxEdplIRCSN9IJpyNF+0C4yKYKpA8cxWbE8kKGu9LCZoqqr2gde4KGl/7LB9z6D69w4f95yMlP7VN1RYIdzwXmMZUoXQHGL2iqDc/wTxWDdypOnksAQ90NlM9WsIho3TcUu3L6UbVqAnbF3wJgncXnG4rfetipoGow57O4+ve4zlWUlVKkWQoBqqoiyVLqZc2yEOaBd47aVnjvSdNUsN2qIooiut0u3c4Gg8GAwWDAjRvP4TUk3SEJitG9+xRFQVVaimWNV9DqdcFoLt54Eb+YcevxCYtZza/8ws/zbDrkos04vvmI0ElQSYTXbWpbczQd8eT4mMlsztbePuOjY6pFTr/fo9fr0e21uHX/PuV0xnw+ZbM/4LlrV3njO6+TmBitFZPxnEG/x2Q+I8sywZIbmMY5R7/fpywLbBVhfU6+PGeXTEPfbDWCi8pjW4Z4YdGlBesI1kG9FEZCuyV2nkWBSlNCv4MdpJTDmGLDMLkBKOnkUBDfj7Gloagj6lI+BpezEbFy/PL2l3lYD/mDyUvczzd44efe5tuDZxnGlt8+/iAbcU7XyOvLfSJ0uJNdxtM2w+0Z45MO82VK3KsI3ZpOp4B7mzLEmnuKDcP4Roetb5VreXV6UlINU5JJhW8n6HkJRou/cm1xWz10XgkeXVvUbPFjWV/faoI1g1r7HANr8YAuhTJluw17oZROuhoGlvtSPIevexaxJjsUUU79vgXuYRuONfaCwvYEx/Uth7KaaKpZXvC4lmf2dz7C839vxO1f3qTcdsQTjZ6fus7VG8Iy0XNN/J0WyRTyPVhcMlR9Ufpd/+2SyY2MyfOB2TV57p37kF8MDTShSCbSKa8SswnS0eqmuASzYmaAceccUK8oyWnjsubPDPsUKOMJVuLK0AHdtoRwaoTveh5nFVmTFrLY0+tNZfIiRDNN+0nAZlJQq47CZarp9APFUL7//i9f4do/GXH4iQuUQ0V2HKCWlB2XKvI91diqyq/eHTG2n1yPcY0Y9+JnHScvpOT74ontW57WvYhiVwq/qoR5U29agSkU8vtKDAMCga1wZv+vmBIXa4N1DqMNWSthOrVM8iV1PifU4roWN7SylYOaJHZYFJqqtiS9Lh/4yMc4fHRAXS5RHHL16lVeeuklOoMhT46P6USad26/Q6QNWZoym3p8CMS6S5Ia3NEhP/fxnyakhqJaMq1zJnVB7RXj2VQk01oMlHTQtHtDkjShsnOcs3zpS1/k5MkhrXabrNMmzycYrXDBsn/hCo8ePeKZKxcYj6dkJqL04KKI2lqqqmJ7c0c2IetQ2tFWMbVxf44Q5Ue7ghEKWjAK19IkE0s0LdHzslG3aUg6KO8JRbMJOC+QhlKoylN1NUc/5UkfS/eBiqgvl9TvqdnoLhmPuujE8eUHV0i1YzNZ8Da7WK9JtWWYLHljvMtrH7tJJ6pY2ISTqsVJ2cZ5zeGsg9YBrQJZq0KpQKtbkiU1M5sRvKb4yiabh466ranbijhvbBFDYH4xovugZnatTXpi8bFB+0BII2FdOE+9PxDRiXXymuNIOMru3a9vMIIJq/K0kwQp1CtmxZoaFhTKNvSoXDrL9iMJ7zx+zfL4uZr+51tgmwDZgy7VAIo9Kai+4zAzg16YRgkmBV9ZwRle/1t94lGg+44hKMifEd+VkHjSJ6bBiuW4XmxLIbaZdLy2FXj7VxLSC3OGv93h8IMizS52FPGMJh4pUHflda2SOEKTE5hM5GeukqS1hT/Xw+FHWVvdwAsLjUuDHNkT4SaHPDqVGZsgswfXDMlKg841/bdlmDm9ETj4WGDzGwHm8l/SE3nN5VBglmSiiGcBXYtfiqguG+pZCBx9aIhLBJ4IqoF3tNjapuOwPjFFS4Ex0mmgbqs1A+fxTxnCi3P6f9jh5P2OeGQIMU0uoqLcdMI7n0T4xlEuNLBFcmKodq28xgRZ1O8KAPjzrnNS4kR+rGPN6HDGfLFElyXKViil6Ha7hCDdsbV2zcjwXhN3e1y78Ryz2YxvfvVrvPzeV+j3uti6Jmt36PV6VGVBogN37t1nMBxQVzfZ39un3+8QfKDIczppSri0wdhrXAStToe4qGnVclMnpfhwJEmENjF1VdMbbGCtJU0zjo4O2d3eYfjhj/DWzZvcPnrC1t42D9+5ywsvPMfRk0OuX7/Owwf3xLg+BAKBJE1Js4yqquh0Ojx69AilNbWtiILhB678D3FJKrIEP7YOa6JJia4s6+SNYV+Mn8oK6los+RpBie1njF9ok848w69rTl7xhK6FWpNmNcNeTl4mQuK/12I5cPyL6nmu7I641BljvWFUttlIl1zpnZAaS6Q8lzpHjOoOiXZM64xZkqAVtOKa2DjyOmavO6d0EZ2k5mDUp9x2PP6wov+W0JLyvYj+7ZLRe1I6TzzjGwm9B81GsnKzy2LIYnTlqPsJrTtjKchVfZpqfY5Ll3IDu7TpYrMgXWojujDlKVdXWBenXY9ZwslPOHS3pvfVFunIML3RhJ6W4mcR4kB6LBafVRzInp1RlRHucauR5wpdKz2GaiZ0x7orD5Oc6MYsPxI5dkdSs4tdUQou90Jj3ymww+CmIbzZ48nPFwz/OOXkFS9pzptBDPSbTrnuhfVQzyxO46miXLjA66ips/ztd7O2NRAEDgkdi86ceFkUkRhMWQmgFaP4hh/diEyihQQsBBPovx7ROlIsLkrhjRew3FUSU3YoXX7dhuXzgou3nkDjikZUBNqHjrIvrBcfywuKlsK7z0ahoSUqdBUoN+QE5BLB7UXQBHqmcN/ocvKBmvY7McWeF0vahn6IAjOKhZNcyWdKl0Kbqy7UUCsRlegAMaeD5e9znasoGxPhneLg4ZjZ6Jg00sRpSpS0aXc7aK3J87yxvtRUVUUcx8RZl0d377GcjGm1uyxmJ2xsbXLx0oeoq4JiUWBMRBzHdLI2N65fYzI54datt3n48AG7u/sMh0Mu7G7R6nSIomgNJ+i0RbUsUSZhMh01G0PA+4CtLZPJFO8DRVHQ7fdYLnPu3rvPbHJCbUuUrTm+94Drzz3LaDxle28bGywqTui0InRkSKKYqqqY5kv29vZIkozd/T1CCIxGI/Llkl4jKz/P5SOFdoHOQUl0OIM4wrdiSKI1FhvPKlTdGECVFSQxoZUS3bzH9mgT38tIxinFVop7rcTWEVURM4syksiStmrcNQeTFHW7xe2Di9ze2WIwyHl5+zF76ZRuVHJcddHK0zMFj4oBqbE8Pumx2V4CYL2mtBGjaYcQFIsyYauTUxcRnQeGZNLYVPpA937FyQsp2Tiw2NWCmxtFOdCNv2+KKT3xzJI/08amivkFcU5rjRzRwglX+xw85RA1Fp1afBPCMqwHe6aSSf8q2y0Y6VKjXKTN9uWc6F4bpobZ8xZ/O5Icvm1PMtVEudycKwpd566BewMiGdA3mXSKuhOExgWNSb2kvKhKDIVW6dqrzlP4zYFoJqIPU0gBtJmwE1rfyZhflnUWmbdg3boUeliUN7aYIA58NXQeaOJ5IJn5066x8OfiKQP41AvboDTi/aADqtZES4VtNXxid8pUUJXCtx2dnxhz8qiPspr5Nb8OPq37sg7JNBDP5D0hNNDDicY17xdBIAyXwfyCEaOmhnNe9dT6/z0VDIAUcZeIKX65KSeR1XtYDTzROBJ3wFh8TVY0wqg5DZhcnw44FZilJhoZCWMtTtdlZRzFf/C91+58RTkSO7vdnS7b2318Qz/1wTYUuUAcx+R5TlBQFAWDwYCHDx8SbIkxG7Q7HS5fuUYUHK9//Wts7uzSGfSxkzGXL18WpRoxSm2wsbHB8fExAKPRiNFoxObm5tqdznvPdFFweHiEMVq4xGlKWZQkSUxRlPR6XfJ8QZZlPL7/kNlihjERs+mU4+MjBr0eo6MjTg4P6A/6LPNaPDvSFO8s3V6P8fEI5xxxHOOcI4pkA/Hes7+/D4D6MYhHglF4YLmXoXbTdYFYffhUCPgkI5rXGKXQC4Pd6RHfOpCA1chguwmTZ+Vsrr7dw2876Fnyacb2xWOc18SRgwGojYJ61EID43GHz42fZWNjQTetaEU1NmgepgPeHm2jtWejVdCLC2Z1RiuqcV4z6C6Z5hmttOLuwSZqHq1vpvahpRwY2k8q2oeectBwdz3YVNSDZd/QOrYoG/CJbmw8NSGSQ8D8gkE4yuda2lOBSGDtn7BaX9tpinGj4hY8Fuqo0UC80Vl3lRvfiKh+dkLxpINqWyoSfNuTPo6wHeloXXYq4FjlHbpMiqBf5dA1d2I018QT4SVHhQwGtZOu1kfy52pTHNGiqwuWeSLy5Jl4ButSrc3zgxHXtHJT1Jh1Vx7PNGGkNMyDcpOGly3eHiqYc6klQVgpyqsmUqvxFPYCFWl7+rqjiWlOKh7TtZw86q9l7MNvKY4/VhM/iXFpoPVEUxolXW4sHa2P1Np+VDZ0sF21Lry+eU9XfiGtQ2FfmCpgWw2X2jQDTycF2UdNckypUS1HKIwIRJaG9NCsh+XRQga/8VQ3mYLiICj4uZZwoAxUn7XT7mqD/X7XuYpyVZSYOEKhMSDOcEoTEQl+FALeKrq9AUdHR0QmYTFfkkQxpq2ZTsd84pOf5Mtf+hNmFyf0+hvce/SA4XDIcHMTvGdzuEvWiiAI5S6JE5bLnOPjY9KkxaOHD+m026RpRpoZCB329zbJMvGssC4QvCfPc/I85/DwkH63h2knKOV469vfwgbFYj5mMT9hNDri8uXLxDqwmC9QUUqcxOxtbXNyckKWZthBRV1b5ouCoijY2dnDWkvWbhEbOYquorLOc5mysbrUiLF+MxUPMaxydrSDqp/ReqIxsSYaLyXbT2s4HnP4r22x///NmV9uUfY1nYeaYjOl2gjccdt0N3M6aUUAstiyjB3FMsGdJITEc3LQZ9K2JKklS2p8ULy4/YTNJCdSjtJH2GAYLdtMi5TZUYe4W2FaAaUC/deNdDRTTzytSJ9Y5s/28JEimcvrc7FiuaPJRh6bKbQ1mDoQzxzR0pPvCqnfttUaUtBNQX3X18rfwQv3NZy5E8RP+PRGqtui5lvxj10qsEA5DExecZi3+tBzmEcpdq/CjGLqgZeYqLYchaO5QhdqLed2WVMoghSraNH4Hq+8K2oaCpg8tssEwqg6nmihaM0UueugvQzoVukjyirqgbjD+SzgpgZTCKfXNNJqSSVhTVnU9pQxoZti/JTo40e81j7VjUhm7VR35ucbeyouCZkDr3B5hEo96e2UauAZfaJEjRNcGkgmEobafqCpBgqzlJMkGuJZA7s4sJ3VBsb6PYznwtZYndRUkCZgBV+4TE4TrifFPJ5B8iim7p4x/J9GsiEOG7c4F4hnZp22jQ5EYyPYfOZRVgapK7hIFuCMIOn7XOfDlI3ccCuPB7FQ1ut3RqMwsWJZFPT7/bVJz4qx8NoHP8SnP/1/sre9zfawjw3iu9zv9+m02yRJwnwxxsR90jQlTVN6vR5RtEe/36cocpIkwTnHcLhJp9MmTVO01qRpG+8dVJayqsjznNFoRKvV4mR8SFXP8U6xsbHBw0d32d3aIlQ14+mMfDpjqRytVotndncZbg5589Zter0eRVEQRy2K5Yw4jomiiNFoxPb2NpE2GG0wSlH9GGwvnrKwbP6+yl6TBGKF03LcrDYistrjkwiTK3CO8c9c45l/fBt7aYtiU1gcLlbUPbGN1KkjX6TExtFJK9pxzW5nTnun4u3eFssyIY0t1msuDSZsZws2kwWxcmzFC8oQMbEtFnUiBfmkjWk56nHGURWBV5Qb0HkUWOwalE1JTyCZWPF36RgWeyJrHdzyVL3TOJ5oGXCJJkRCccp3BNpYpzmfd3FXP6Ah7j4VOLqicCXyfavC5VLpVKOFdJ31bk10HJOMFelIjrfdb6eUW02R8A2tsTwdHJpCBkwuEfzcdk5v2qAatWCLU4lyWyhq0VIKvK4UdT9QPSPF3zdJ2zqXbrvaEN/hdKqxnUC546UwNJCGrlcCESlKoXGNO3WXC98z3++Hvs4Ics5K11dru8aslfClcQ1bIQCLiLrr6VyfMHvUI26yEF0KnbsiK48Xq7UV+blyQpPTNpBNBBcOSlgWyUJgLuVlI1phy9pBHQsf3BRQbQg85TKYXnZzpjAAACAASURBVBF8OGTCllG1FGvf8uhcYwqRqxc7fn06MUslpk/Ne7RaxBAh1ECQwab9wQEC57MxC5oQFMac2kop5deWfJKFp4hjTVXVpGmK9552u8vP/9Jf4jP/7HeIjCbJUu7cucP2zj7ddps0NlRFQZ7P6bQ60klEMcPhJlmWofFsDgbUtoYQ8AqyLFtzoquqwjmLUoqiyDEadJTiPYxPRvQ6bfJZzWx6zMHD+0wmY06OjimKAm0UkPDMM5eZLuZMJhOss1y5eIn5YkHa6zPP55Slwc4rKu8xJmE+n9Nut7HOUjrp6n8cOX3yYWpu6sBTN8yqWPtYYYqAywzKeXyvxf2/eokr//AuRAbfihi8U5PvRtQd1USvK+wiQneEjpQax3P9Q3aSOT4onuscMnenirmteMFmtKCtSyauTe4TNIGjskukPLGRbsePE1THEnJJcug8DGQTT+txic5riKT6Ta8mpLNAOvFoq5hf0kQL8D0ICzCpIpn5xtpTouFtuzkOV+IbcZ5O+WyC8/r3pnKsZNAEKVCmUGvlWDBQNIUufhITLaXTKncs8cQIu8HSCDPkQGOcFMw6kWHeSmoNao13rpda0bipyVFf2cYhbuUlEUTVp21KNQCfhzW1LRiIJ7J5VRsCnUQL2ejqnvy85Ysl8d0U1xZsVHnBqVedcTDNCeGHTF7+nmv7XZ/V1cazSjVRzVrqUry0cXKiCLHH9xyzwy7JSGCUYkc2GpB18xKjuY7vMnWTvmKUuA807JE4l0LtYiXOc81J08UK2xbcP5kKBBLP5GvtRwFdGcphIGgjkESQzECzkLWtNxzxxMjpxzZy+wTs1SUcpfiWJxobgYOa57o6PQQT1iew73Wd01sSIDTub1oMiWBte6tQpx7DgbX0+lN/8Wf5F7/7e8SxAEtaa65cuQI6UNsCQozzBaHxU/ShIo67hOAJwRPFEXEU0VKCxps4WqeC1LVgwNPJgsWi4MnxEct8yXg6I2kKwnwxpd9vE3yXq1evcvz1Y/qDAXEUschnzOdz7ty7S7/TJe32qGvL49ExWZbRbreYzqdM5zNiFZMkCXVd0Wplp6ZLxlBVFebHwBJoFrJZ6eZ3xbpgnGUsBAXBaO794iaXPz0ipHHz74rp1Zigmsk4pzcJICIfY7HeUAfDwCxpm5JdwBBo65KOLomVY+za1MHwTr7N46LHnZMhy2WCmyZrYQCLCNWrsR7mVyOyr0M5TIgTTTQtiacVg3egGkSUPd0kGctwpm7LDZKObZNyrTClx2bm1IfCSGEO51jes53xulM9k7GmzhQln4S1EZNrBZKx2FBqJ4yFEEMyMqfubAHiedOJRlI0w2rwp05tNQHUmZt19frEwyIQkoAqtVDkokD6OKLu+QYDle+LJ3ICqnuN+VDjkQGN9NqqtSl+0GAepWLZOZNiFxJPPDZC0VvZd0bn48Q91XnDU4wD3wz21l7VBlCy+fienO1DrcUlricUM11Jiko1kK7WFJyecIxAEatTyXpAGVgLr1bJKz5W1B3ZROtOcy8oGTzGDXy0wpRdz4slp2mel9W42EtXj/hy+FiRHUmKjk8DYZygPahKYYcWTCA6ikXOvgqpTYPAkN/nOl9R1qFJfW7k1hjxv2iK06pArd4RrRVbO0P+5R/+AbWTorWzswPAMs/Jsoxuv8vR4QFb2xtUy4pC6cb4J6fVSjFGESmIo4goijEmwhiFQlHamrquWS6XTGZT3nrrFnfv3WZncwfvKkya0k5jykpx/94RRTFlOpmSKMPJfErwDq0NZVmgfJtiueTk5IQ0Tel2ehTzBVkUkRrD3tYWk/mMycmY4dYmSgWcsxgTkSQJi8Xi3OyL1Y0Ep8e9s9DFSg4s3wjBGJa7Mc/87mSd0lFeGgDiHGZbMo3PjhXlVkBVGm8MZRwzTVMWWULLpsTK0TYlPV2Q6ZpMSSWf+YyZz3hS9bi/2ODmO/ukDxL8ppNhVIoYfVea+GGKycXlK2iI51by+IxG5zWqGxPljpaSm6ruSuioS+QIn+/FJFNPelyy3MvWg7nVMCda/OCByfddWtd0bI1L2Vmcb/VvyjWZiLrxQMgE+w2mwYBtc6P3pRD7RGChlSvZig+8wlFpuuKV97HyyOmiGQCu8ONooTBaUfcl0zA9bkQSQ8GVxesh0Lmn1+yNeNZgqarxtGjWqxo63L6cXNLHEXHRnL4SYV5U/eb/pafCEl2fM6OvsR9ebUIr57nVusNqECibkSm0DE4rLXFQuQHfqPmaVOugkLUNSoSCDlaBBIaAqlgnqih/utG6RHwyvIG61+Dlzc8ypaJ9II5/xRYk48YgqhtIjjV1t/GfnjZG9w18tgoP8Fkgf6kgNN7PKm88O7Yc0Thanz5c1viS6Ob9+wHX+TBlJc9Q69MHUkqvO+JVp+icp9VqETLxJh4MBhRFgXNOBm/DDRbjKQyhLHNGownaCHNDqbBW0C2XS+IoplKWOBEfZHnMCJA4prIshZlxckK32+PixUscHjyk0+7QarWI45jx5JCqWjAZjSmWS/LljO3tDSaTKTZYjI04GY/pdrukrRZlWVIWVeOG10cbQ7/fZ7HMCSEwm80YDAZrtslKwXhu9sVTBbn5QBEEW9anpjHKQd0W05o4D9SbGWlegvekj6bUWx3SiSFogy6Foxm0whuNB2xqWJQJ47JFx1REOmUQ5RQhBg9Gyyd84VNObIfvTPd5OO2T9CrKfUVyGEmHmDlM4gnTSFgAY6EnxQvPcjchHVvpXmJPfJyj+hmupYlKiEo5ZiovRa/sK+IcGRKOa8p+KjzSuJnip+fEPVedmj7l5q4rc1PYVv4Yum42HBPWOXMuQzq5WlgjIr6QG10KiSRXmFyfDrpSOa6vi1Uk7+iaehfJIKzaccQnhs4dI2uxJZtGMmkCA5rnNXvOEo8NyUTodSoIs6LuSfYeMURTgz6WiCNdQT0I2J4jO4goNxo+br2CbJoF9U/nz73r5V0tZ1M8z0IZ642peZyQNnQy32woWyWuNOiZlKh6IANOl8lmadNTDJjGKySeBwlmJeCNWp9CVh21pJLIOmQjRTSHaiD3UjyjScEWKKfcdGCVvH9pOJ0zxDLo87FHLQ1qlBAVTdjAhie0HXoW4TrSVUf16ea8Xosf0KudU2Ytw74QAkZrQIxElFIkSUpVlRA0kZYwUmvrp6wtq6oihMBiNGKQZexsDVnkc1qpRmuYjGeEXosQNHm+pCgKJpMJFy9cIEsFhLPWrgeNZVWus/EeHxyQLxb0+3329i6ysdEhSRJu375NpCGfzwgErK/Z29tjNp3SamWkccTEBxZlzWS+YFGUXLhwgW63g3eOxXLJfDohigy9fp/FoiJJEqq6oixLWkkmw8z4HKkYzXW2I5ZUCJBPrHSXpgqnX2smzT5q4IzIoOYlOE98vMB2Y4otRbw4NUxPporaaxwJs2XErSLmUdbn1d1HDKMcgJxEijNwYjsUPqb2hvnjLjrX0HVUO5Z4UJIljuXdnkzEVypoD4v9iGTmsS2Nj2OSEDALT3yyxCxq8isdqp4WatoykE6FQ1wMDPEswmUaUwdMCa6Zmp8beAsKRXgqjXhd5J1a47nSMa+Ufc3NFYSBkYy1dEGVdM2rgeHK4AclWKSyCtfxjeS4eZwzXWRY4cVN99e6F0mB6LDO9NO1FNu1hqWS4aKIX2Rwt+rSo3zFbZYNIpnJ86s25GclRwbbCcI4iIEoCGa7agJ0eAre+ZGvVezRmUK8colTNBDGqptfYcS1IiTCYlAbNeE4hbZDl4pkqqg4hUVWBdZmp5zy+IzqPqwaGH0KE63WLTmhKaorO1P5c90HmzXJKE4RjaTRCI1Eer02je2mKuXzGs9lyFf3m656FuFbslkTCQ89mZyBwiJ+4CnknOIRwXHPbIoNpKDxXvi7WkVN5yiTGeeE1dDv98nzXPi+WSrpz0mKAaIoohVr5rMxZTFnNHmbF56/QVEsuXL5igx/gscgG0Jd1wQfqJsIp6IouLi/TV0P8FVNbS15nqObnD3lmwir5qZoZ23SNGF8MkbFCdY6TFZhfaCuPbPZjGK2YGNjg5C6ZmNRxM1pYDadESUxnXYX6xzaGGxdnzsOKhi19sdeYWiro5h2rGWlK+tCELGJbRv0Rot4ugAcIWnhY5lgoxoqUCyG6qZUJG9rps9pbKnxz1hs0NQNYOuDZu4y6mCYuYzSR8zKlO7enLo2WCvigHoZo7UcvZ+yaQTB8VItstYAysb41MhUvPIkE0s8U5SbEdap0wKo5TUm4xqXaOqOWscdKXc+e0kZsDVYq2KNawbpLZoJOqcnFHNqdakca3GHMDECoc36++K5CAqUP5Xrth4KJr7qclVzBHZJ04FpCL5hRSSN3BkpLC7z1N1APJWOPTtUa1UZQRFi1p2yS4W6F+eCnRLEF3iFv69Uh+TNsLSS4ulj1pgyNPDAedd2VRhCY4Kkzqwtp18LJjQ4uxI4Zx5D5tBzQzCBcrhai7AeZMpwE7wT3rIpWePIa+gilvd3TaNs+NGruYowgBpKpJZ4Lz1Va4fAVSF2bd98v2wm0Uyvsw6roYctJFfQgi5EPu/bHhqvlBVHOjQp3+oHmBueq2q02i2cFT6uiQyRjtHa4JzDxFoYECh6vR5lVZCmKSaSQjrPF+vCXNqa+48e0ut3GfT7wkZyjm6vxcGjR9y4+iyRUVy98gxJIkW+rmu01sSxSKeLsvj/23uzZ0mOK83v5+7hseV691qwkWBzpkfSTM+DXsZkJv33kkwyk9ithSS6myAKKFTV3XLPWHzRw/GIvJCmUSPcphkfys1oKBB182ZGRB4//p1vYb/f0/c9Rmk+fLijb1qyDOq6Zl5XfPPHP9BsD8QQOJsvsMcdkzJHobh7955MGbbdAa00ykUu5jPevL3li5c33G92dNETtMLagrqq2Gy3fPbqBW/fvhN8N3ia7oiPDmNyvH+eKVFfqZGPG40UoZGelZ8wVTdVp8ggoyAasr0nXMzRmwOqc9TfbWkXC9pF2um9MAHqd5HdF/LATz7bUiYK3M4XlLpnahrWrubR1bw9Lji4HKMDu9sJqhM5qaoced0T/nGKTUW5m0tx8KUUpvr9gC2HMUC1XVom327ZfbEQaCN9Hp/LcTTfRrafW2bfD1Mi4ZMO18P8a9AOU1Oneul+h2I5YLKDCf7TQhJ1OubaiK8CutPkj5qTJzNj3D0IxW0YzIHcx4HSNb4mEPPEpHCK9oXD3mdy6lhrtBMPi+JB4Wq5Biq9Zj9NaSIdYyF0dcIy+1P6hnSIUoT7mbxW6IVvHepAttZkzSAg+eXX9P/NvtCdPK/AeFLQvfyeaIXdghZ5cigD2CCpz1OHPxqye4sKYLc6UQYj+eNpBqGC/FN78EqghKgZ74MkdyuhGkZJMikeZNNSDvK9ormKZBsZAA6iIoIM/EYHQWRD8ZWIXcQpTmH2anwm0RDKIJz0CG7uIYJ9FGdBX8Sx2P9L61lFuSzK0bbOh0CeFbRtl4Z+YG1Olaw6R/VbGoSVZclusx0z7cqyJIbAerXis9evaV3P2WzC119/TZaXVJOarusSza0hy4RxoZTCBz/6Nh+PR1arFWVRst9soQ/sup7tas9sMifPLUoJlLI0YtL/7vGerCzIJxPuvzuSGU1VloQQqaziYb3FZBm5teTW0gdxvquLktvbO1arFWhNIPLq1SvquuZ47P4/4cv/f5cvhSkE6YFLMtDxgbPgqsQKsNIlD12wLw02RohRHOVqMcwvVoH96/Qln0a2v5Yvqp8Eui5Dqci6qyiNo9AOTaQNGUdvabxl1VTcraeowqN2QlmKvaXfWJgGgh0ktelI58Vy0ReCexdrDxr6OkuJGBnloyMYyU0LuXyJVRCeaX3rKe4bcqNQsWT7KsNVonZ7jj+DSnDBAP9Ip3hiIAyBmiFLBTl1dQOFze7F9Svby/G1W0q31l2I0KH+USWRSDxBD5ERzkDLrRk50qmgx0x4ydN/tBxeCl2wOxc81bTyTLjE8AhDV7xJarwsDesSLGCSeCXbq9MQMVH48o0Me4OVn7FbQyie4OvPWMohlqipCx6TshPnG48U5CyxaHQ6LESIXhG7FHw6ZN2V8jnbsyic8HuBRfqJnPb6qSSNyOvJtRkEMr44nX5ANsjJW0VzmU5buVz7Qa7uE7Yd8gRL9Uq4xVbmA0PUlTlofBUwOyHNhyJitxpXifTa1YIvq302DocHE6yPsYaeVZSLlKwxJo0YTVmXECNGiczYxwDaELwmM5bj8Thad/atYMqbzQbnd7z/cMtnr19jbM5sNpPYpfmU/b7B9oEf375nuVxC1Oz3e9AiNvG9Y7PZcH/7gb7v2e12WBMpc02WVex2Oza7W+qqojs2bHZ76smEGAPeB/brDbe3t5RFQZFBNDl1nlPkBQEoypKQTMzv7u6Z1jUuRtquYXE2xwdP5yNlWSUXvEBVlc9mX/j81J35oUOrThizHNcShOfBZyfpaTfTmLbCxoi+32B6x+THgs2XBSFjLBJuFjB7edj6dzX9Utz8Hg4V+jKwzwqO3vL9fsmf789wzuB3VojwuQxFzE5jdxpXSsdm92qM5lF+kFh7fCEUt6jFOtEVCqhkY/Fy9KzuIv1Ey1G+hWZpUL5Cu0hfyTBTRfEmeJaTmeGk4kvFUYx0EhSXMHzTDKnQ6ZjtFFkaQIYM3FR4qvlandggQWTZuhe1XbeIP4lGijYxMp4U5QGHjBqqd4rmUop58ShCFdOok3lSLhiwSXFWw/OQb5Vg1enZCAjU0Z7Lh9KtWIKag6JdxpHzDIwbyBBT9ZxB38BFlg+rRue5AaYZBTntcC9OGHa2U3ifgmSTf4bdSsKKUTAwkES9mEyckAKdHcGogVUj0JecGE6/M19DuyC5AcqJYhyoZ1GGs42cAMOwEUewD8I7Vn5QWCqKO0N3LvfNHGUOYVpoL8UeN7u3sllYKfLeJ4/ovyR84b2nKIqfxD9JgKfY5imlsYmEr5R0tvP5DO8F5yXEUd0n/4Tbuwdi1Hz1dcFkMmG323FxcU2e5bRdx5s3bwSr1iI6mUwmECKPD4/0fcMPP/wgbA0MF+fXvH/3HZnNeHl5zXa7ZT6ZUZcF79+/JxjLZrPm7dsfmE6m5HnO8vxcsKa2papqgtHc3d1hVYbrO2yRU08nHHcH2u6AzSop8MeW29tbtBYa4MX5lUQ4PWNpL1jxqH5KHdU4O3n68oJa0M1SgUu2kFFNKFzij4dI/cFBzNj+Sib22U6LF6wN0Bry7wsOmUikv80vuKzEM/H71QLnDPxQoVIysT7r4F1BsNBeecxWcvl8qShvpTvL15HZ945uJkGUx3N5X6YV2XTUhskHR9RyCnCllg5oL0rFYBX9VGP3gcm7jqhzohYK03P8Lwb/goH5oH3C780JC5abkDpqByqJSAaBCEih62eRfu5RXlHe6pFiFtLR2qRhEk8HRsNgMR2Ts50WgxyguU4qPJ82zzQURCdTofSlDomvXTxK8WmXYpCfr3Qa+kJ/JWKFoWgMWX52KynM/XTo5APmIB33c31F3PR0bbWLI7d3lLanznkoeMYrTLoWvkoDMyNdc5h4umlENYbqB3l2XAmUUoRBim6y907duNQftMAaUUG+k024m8u11N3Jlc904GtS+IMmWvmzTsU25AINujoIpS0IhNgtg/w58c6jFVaTXRv5HiQuc8wi+aMZaZV/0eDUpu1pOjEfQimMNhKmWmQUtiTLTuKQGAPGKDAZMTNo1XH94hpjM/q+53A4cL96pPOOPgTK6YSXLzOm9QSjMzrf0R2FJ7x6uJOO2XkO+wOZMZjM4DrPF59/wXa7Zrvbc/vhLdvdjsvFGRGoJzXeedbbhvnFFd3hiF6eYTJLZgyT6YTddofznkPX8+H9G5pO7vbNVy9p21Y68f2eEAO5LWiaI03v8N6xWMyYz+fMZnO2mx2LxfI5lxfTngYYQ1EOVoy4Q87IbR2l18mrx2eyNx5uDCFTmLbG7Dvshx3qrEb5SD/JCS8TzmmipPC2WuCPxxy16OiD5qGZYI0nM4Fjr8k+O+B3uQxhbgvsXsnDiQxElJfjdHcm3Vx7plhZK0qodNxUHkwfmPzJYRr52fWvc0wrclm7E7zV54qsiZg2ilnMmaWbK7q5xMV3i19+bbOdHqGKYCN9FcZNDyVH+qEwglzjmFR3g5GQdtKx5SuFm8mR9fjSk+11Ms4nwRLyP9MK11g5eOo7YY6SQyfQRHKk2wv8Y46DP2/iSCuINdi1IjanjdvVJ+iivQiEiQzKijs9biTai5Br8I42h2TAr+NoIBSNQGDP4YAPQhRIz2kZf8I40F3CuVNhHhsOPRzvhdcLmthBLD0xDxy+iJL6ckyhrzENRBt5HlzNaQic5NT5RmYT3UwJ00QJla5dCj/Zl6COpAIscmu7UZhcjaen4V4HDd2FH82Jso0Zk1FQnPL5nMI0Gjf1YtcJidEi/93/JTFl7/3IR1YJQPXOc/AtDVLMMlNQ5DlFZbFWfC9CCGLLOZGtyveO9XrN7e0t+/2eGCPH4zFhxzn3jytCjFwtZ+RaYSthzPd9n46zAqHMFwu0hv1+S9u2HI9Hur5lfzhQFgX7w4Gb62vevH3L8XDANR1ei0TbWotCulwfAl3X0ff96EA3wC5FkdO2HWVZMikntO0dWmu6LoypKsYYjAlCCXzGUuPE9tQVKxfJHJC6hJAJDuvKtFMrOT4GK0UQNKYvKB4MxTuH2bSoELEHkQhHAzxmEBV+6fBGi+YfaPss8T5Bq8hk3kh8z8GiW0WWPBUGLmd2UHRXjuxHDemLA8l8Z3g4zYB3RnQX8KXGFxp7EJ6yL1LHXAkEkrUxWVhGaAPRmJGjrZ9xeYfj6VA87E6+KUJDFJqZu/RJFitGRLpX49E+O5CoasmrQisimlBG+oXHTYRJEGtP9pBhd9JR27UMinwVU5I0oCLHG7nfvpLP6163mB+LRLljTLMe7CKbK8GZnQG3EPXZEI4aDWS7LGHYieoFI49Z+Ti+B7sRRZrZDs+acGsHHvEvurZKulKVGBeDv/KwQiashcExbbiuuhfqnt0Mw1KFm0Z8pmV2pSP9WSAUOhVewe/l1CU+1yCMilG56qE9G8QjkWAlfMCuzGhEJKKTiD8TeGE4Pfgy4m48upNNVncKvwiiWB3k8WUcw1xVYueEPOKXDrPOCLlcY5MGxdle8cS94D+7nlWUs8ymDtgI6yFxlr0HbVWihAVa1+D2gvXGKHQ0YzRFYZlPZyz+zYL1ek1RFKxWK5E5//kN79/fJp7xDS9fvuRxexDDoagIaLa7HV3fj4KNu7s7CJ7t+oHf//EbMq348vPPqasKnUG36ri9e6DpW169fEloDjyudqAUh/0O78XA/v3dLa7vuX59Q3SR77//nhd1Rdd1XF1d0rad4OBtk2KuDlhrWSzPMCbHaEs1MdR1/ZzL+xOa0pCvBozczoESp3uwHtg9MbdJuWbdDNqFoVgbFpUmf+jI1kcWfzJM3mW0S8P+RnN8GYlbI1zR9AXa7Uu802gjX+pwJ1hKvlGc/UEGUrvP1dht605jHzJ0C8eX0u3kaxLrgpE0P/ng0S6yey3Dx/m3DdsvCrI2crjSmA6KtZwSXKmwqfM5nmfC8zRSCF39ywuHckoGS+koC8jxWskmnx2BgzlBDKSuOo8isb0SmCPbi4zZpG7L1dBeM6ZKh4MRyW3MpKtNNp6i8EqbgxYcNBZSNM1WoT+UIy9ZGAfiLTxyj9eSKVfeSoupXVKiOUX1TjpAV0dcJSkvdnti3WBk48524ovhJlEKWSfDQhl4/nIMY6TTxSfD1AS/MHS3/VMOc2rochn+BRvHweeQYBJSB828x1lJcVFe0Z4lD+t92vjV6SWjOZ1uhtBTc1TYbYarogwbK+EoD+/V52It6qaBbKeJeyND55kM9Yq3FleBn3q8FvjCNGIVEBUC1SjQSUA1vA+QDVK1J6jlX1rPi4OyGSFEjDEjJ/ep34MxhhAC3jliDMlKc0i9FuN573sO24a72zvuHx5omwZtNLudYJlZZvjd7/53joeWm+sbMpvx66+/whYlPkR6H2jaHVoblFbkZc3j6oHf/PbfsFo90HvPw+OG7fYRpQ1FWfP5i1eIkZGii4Esaoqi5PHxkbbvOG62VEXF6v6B47Hj4uKSPM8xxtA2LVVZ0RUdwXXsdmLgU9cTptMpWWboe8fybPkTpeMvWSETbCwahRuPQYwP3kCtGgcp6aH3OYnalY7HDdS3gfJDgzr2RK3J1u34O66/b3j824rDteBp7a96jPXEoAlOE5rEqNAQrUetLKu/kYKrvJiMZzv5/b4UI3gFDFJllHTyxWPEdJBvPK7WVPee7OA5XudCgzOMXbJpBY/MdwEidFMjfsDJorJbRp6FfT5xd4pZGuold69h8DTYLEYTR2x5gDTylWQLhiJy+EJ8DtRRjtbF+0wgkXOpTvZOxCD9LJBtdMKZVZraMwpOtFNj9x9SbNNgcq+9iBB8LuqzYBN2GkTAYHfyOr6Oo+FRvlYjbqpcKgo/ocZBUwsTQ/dybU3aLJ7LwHiqWhvir1DCuiAJW6KOI1w04PqBiG30SCF0r1qy3IPTxCaTLjUquGoJXmPfiLVnyIaIJkYRUj/7aUDAOKNJLIih282Se954z/WJz5wd5Z43+aDwlM0kW5tRQm8a2cy0U7gijPDPYFwkg0pGvvLHnttnFeXBNlMrjTF6FJKEEH4ywAsRbOIni1RZglUPhwPb7Zbv3rzh4eGB3rXjEM/1e0KMPDzcsVgscL7jf/5f/kd++9vfMp3VIkjJK7Q29H2DzS0xwnZ/xJZTtNa8qCuOux1RKc6vrimrks3hwKyYUJQl+67l6+Ulb9++5e3bt2it6LuW+WKOtSWZtazXa7quxW8C9WSCzTJic6SqSlYPe4zRtF1gkhcsFgvm8yVt1P4tkAAAHmVJREFU06OVEaz9GUu+mKfddjSxSQ/8045kMDkZtf8e8kMk30Zm/7wne7+SZBJrITPQ9WRhjv2ww51PUB5e/k8tD39b0E9zYijEiCcR+wd+q+7MSJw/VoN6LNJeMFKXfBUlNLMV5kH9o2byg/yM6SLtMsPnQuMr1wJXlOtAN5EhWXYUJVT5CMGoNPATSWw/i2OX+Sz2hWJMvUDF0dEravlzVOJJPHTJMuwTTNBNI/5XDWXVEZ1G/zCRYqYSrIIUU3WfBDhW+Kr5rcFNI2HiUUeT5M1PWRiRkBg3yonncLDyPnWv6GYDHqzGQq6CCEfac9lc7FpLyGs4PQtjOpmKNNfJUCkNNM1xOL7L3xnwZv8M+AJOeDkgNphP2CtBpyP/kAeYuvKQrq15sWdSdWQm8Lie0DdSppQNxF4EJbE1qKOhT9LmyTc5bjJg68JSGnypQwYmdbJqSCLhyedN85jhZDr4W8t7Ar9ILKODHrv4UAx5fIx0PDcRD20dh3thRqWn8sjwUp+u8b+0nlWUQ5Dimpc2RS4FkYdbkR3HGBMrQ41p1jFGdtst3333HX/605+ASNv1aUhoxeowy1gu5njn0pAwstmsiNGT5xm73Y6Hhwcm9YzFcoH3vXCVA+Q2ZzKds9uuKQpDWQlnRuvAZr+nnk05HFr2bUOlaw6ZYM9ffvklm82GIi+IwHZ3oN3vWa/X9H3P17/9G8qiwCU8/OHDrcRQtQ3zuSRy13VNVZWAyMT9c1OBU3ENJQz0N5CHx3SMNB80Y5AmUUy/F9866t+/l42h7STXrshBKWJmCJdzSYZWAaJYaA5dtt1p8kdhR3SLmIq8FI9g43i0CzbKJBx5D9k+Ua4aBY0aByTmCNsvxf3NJ9wv30byNlA89OjO8/C3Nb4QUUmwivo2JB/hSLswtAsx3xkYBGMI5S9co+lQRLrjVDTErCd1bgPlLF3nbhkIS0c1bziuSw4PU7KtJovSeRFOOLOrE76rwV0F6j+nOCEjbAQVwU+EjgikjUCuYyhk4zENiD250OGGoV/zInm+pIGZ3apRWu0mUjT6uXAl7VYGrwPUU9xr2vNAvhaJ+GBCpELiP3PCnn/xtXVqbAZHG4A0AAtpaGmewBdRJ9+Is57F2Z62z9gfc/qj1AOcFligVxK/NAuoJhOM96Yl/67A1TIH8IU0EYOvdNRyHQebgiiIKia5DI6hAp3c/26R7r9TZCPtMKKCTrLrSJx6OQnsM+wmxUAFaVD6eUA3mmgSZUbJd8CXJyjyL2rdKV1vRGlNZgzOObRShOAJKSYpy3Kgp2079vsdm82GP/zx/+ZwOECQQp5bkWtrnWGyjPPzc/LMsusailCidWS9uuP169f03YE//3lF13VoDd//n99yff0C7z2XF9dURcnqYSUp116R5QWbzQZjFE3TU5QQPIQQefv4HVVdM5lM8CnqKZqMf/qnfyI6z263oygs3sN6/QiLBddXV0TnaSfCf1aZ+DhPp1PqukZrxXI5HQdkz1nBPnmoB5/bYTgVTru7RnAqu48U68jyHx5Rm70U5Bh/Uowxhv7FjJBpTOOhtkStKB96tp8Xgud+J4yH45Vm+j0cbuTo11xEQgH2USeZr9CF8o0mmJi4tKf3V9/LsM7VjApCtGL5jTjG5ZseXxr5/atAs9Q0V4kKVivynXCuxUWO0YvAzYez8TOGUSaO0/U4XGc1fGlU6loTr9hIBxbqgNoZ/A8zinAqZgMDZji5HF4F6nd6dCMr7jT9QuS1A+3KzaIcga0cvYX7nIpvJ0WseyIvHqxDaRX6QWO3iuZCNpH2LIoSz0bsTlKeUSnTzyKbgRaYw9WCRw9sjQELlVOMGr2gn8O+kGDYlIhiGEJyGFz5ohYIY9hTuzOPOu/QOrK6m55ua1BJYKMSF1jjrnvyt1bgoIXHfCgk87AXOXq20/QLEXpIIYxjZqIvGQu0qxKenz+BiRKEVTyIGIgIbiqDVp82Sl9FSVXqMsjiKDYxreDWupEirdvEMBmok44xK/EvquhznWc2mXPsG/rkH9x3ot6zeYHRJpna19zdfeD+/p6mbel7T6YtGCmOpbJk8wl1UTKbTigmE77+6lcorfnx/Vs+/PgOd2ipClEF+q5lVlYc9lu0BtdsaZoec3XD2x/fYMuc0BiU0mw2a7z3hCCY9sXFhfhgaE3QUNQlvofd5kiInu3qkTwzib4CMQTKSc3nr15TVaI6bNqGEDzFbM7lbM58OhuLclGIx7PWBuc+whL/yNK9MChMx0i9GQxUBFMcOhyo7iLVXSBrgiQ+23RrQyDajDCv8JWln1v6iWb9awMKqveR6due7OBFkOEkOsfVIkQZkp2zJnK8huqdHqWtUUfKW5mEDxFK3bkc8wbxxcA7tTsSzilHdPn5lL4xtWw/M6MM1iR7yW6i6OaafpaMxOsgcfUg8q9n5MhlBylYLnlGDGZAgzJu4C1DmvKvNPpOj3g9aRg4FK/Jj2E8snfvFYcX8hmKR9moBqlxeSe0w2wvRYuoCEWkW0QwgWyrE+UxjsfvAf9sz0TabTeK/eee/NEQrLz/YOMIcZkOsjtDdpATVHZMfF2bvDVspLxVkvKcnZ6ncQ30yudc2yzd+8EhLsiGFJ4KZ5KE3Rw14bbAlycg2uzMuMlN3iR6mouE73KaS4hejJVisq51k0D+KG9adyptSHIf2zPZYO1W0lgGpeaAvSuPwD8mwhGONyT1ZByVnSpxqnUvQQ52L/Uh36hRim8aaVLKWy3pKO60aY8+IIOS8+eu3y+/9DCbzWSwpyES6bp+pMYRFc6JvzDAixcv0Mbw/Zs3XJyd87DdcLFYcnl5SVCGs/mcVy9ekhcFXkWRSIfI688+o8oL3v3wPX3nibHj+nKJjrDre756+QXHviNTe27ff4/J5QnrvXCf27bFOUdVVWiteXx85P7+Xqw39weqqqbdCzfZ+0BdVcwWc/7+H/6el+eXdH1PVhb0IVKZjMP+gA+gjOX6+oaLiwvOFudjNJTWiVo1aGifsfopIxd5nFo/qUODyQnA4YUiGMP8u4i7npM97OkvpxxvcqKCdq45vEzae4TXGYH9a0XILdMf9GjheLySz2CayPZXScKqFdW71EVFUH0yt+mkkPtSupF8pSnvI/08OdKVaixeygvWt5kbrv+3I4cXOaaL+EKjxSlxDFINBpor+UK5pQMbUVlAj0oxCB9zC/+ZNfBZRx/ihKGGhN8OeHM0p5w15cAm1d/sjcfncoIwbWT/QhONopud7tdwXH6KV8pmKnLh7Cg+DCrIQNds9ThsUolzDIwOblFHAom/fDiZwNtkYq8agQEEa44050lqPZGfJaqRFTIIKbRPTnGk4pOK1HMDBAZcdugMh7nIIL9WSUSik8xBO1Hy6U4x+SGl43SCDw/Dyi4Fog6NCSiCimM6eEzS7fxBk29g/xnoIyNdc5BOo5L/ezxtIMrHEf4ZwgqE+iiQiw6K/sKhD5JG0i/Bbozcz9T5DonhgzdN5k+4/lMlYvhI1X128kjf9/gg5kCFtUxqGcIRIUR5NzYJROqq5vPPv0B/pXl5dQ1G472k+maTkkwZuq4lxsBiscB7T+dajDFMl1Nu79e8uJyzW+3Js5zffHmNcz19e+DybM72sOLYHJnUc4q6ZLk8492P71mtH/jyiy+wNhMoI9Pc3d2iCPzxD3/AaMtiMcUYxZvvvkNby7yastofcG3Ll1dXTKYLfIDpfElzbJgtzrm4vEBpTXNs6TtHCB6TmdHnoyg+Qkj8L1gnr9s0MKpO2PJIf7NSJF0Nmy8z4q8yjtfVyBgYjsXRyNF4MAxSfpgKK9qlpr71HK6NdLMWdl9IIdLdKcPMNCezm24B1QdF8QjrL5IkdiO5euWdFLmzPwoftV1IisPizz3BKrqZJd94TBtY/aaQmKQoJuOmgW6uaC8Sl7Ux0EcI4i8cbdKW58+QscfEMR0cwYZhTDIjMsfknObUaKqjIuQr+eKvfiOdXD9hxKF1K3+nWwQRkLQnI55slzi3ybein0XaVDSjkkISbMQeTjgknLi3IB4PqFMxpVe4uccv5NSges3sW83uS8FTVTxZWvokhrAPQ4EnDQnhJEyKY8f8MdrWz63BG9rV8QS3RTXS4ySHEehBx1OKePVOhr7dUp67dim70nBiQDFyiHWfBmb61KwMp7KYwfFF4ndnJ++P4j599uSUWKxA9zLD6OZqpFkOG7NbeNx5gF6qbvHO0r7uBN8OinylTrauSpGvhmeIUbAzOgDqU/EeKZj/wnoefOGcSKmtjDAl9ilgEhXMagtK/CmqqhoVbkUuHeV2s8caQ1ZJl9m2UoANgjF772m7htlsxvF4pJoENseOiQ1MZjk/vn9Ea8VkMqVpD5xPZ3QVRO1Znp2zXq8xxvJ3f/d3XJ2d431PnWdkKvLmzRt22y2vX9ygdEbbNhx2B26ub/DesV5v6Hc7ZvMZF5c3TOspOhOArMgrlssFJsuEChhJohG56k0j/GXnPoLof2Q9pecMktTR9wJGKlewiW+Zfk6OvnJcGyOJMkkzHjmTWroDMUVPQ4pJEnHkkgRSfoDBcUx3pMBV6Uj6pRdM1MDDfwjoi5boNF1uiDpj8kYw4d1LgTJ0wrx3LzK0g3LtydaebmlpLgXrHEQyvhBTcwzELMj/mQVRHgK0RgryM+CL0wAzDenUoGojDcri6Zo7BYVM8I/XwgGORvBIgVrU6B4m2K0ezW5cKb4YWSNsmn4qmK6vhPvt6ji6uGVOBqtZIwNT5U5Cg5DMe0wLxUqNVp7zfxLVppsIvHG8iuQP+sT4cyKmGPL9XKLOu1qO9oPsOZg4dvGhEBrmL139LI4b3UCFG05KKjKmpQAgNhFkBym+7XlisVTyebWHGFKBS5ulTrh3PxkUr6JMjCYmy9LTLED3J5qfL59I3tN/9zrBSz0nqX0m1232TTY68jXXnu7cSyoKoFuNOabvxiDDTwXYpxnFOJjP0uasBx70z1/bZxXlzrVYa2kOHZPJhLZp8S5wfn6ONiIuUQnVzhKMoZTCZhKgOplMCD6wbw5JgXfg4uJccva8w7uexfSM/WHNbDbjs9cvWD0+cPf+HXMfOfY75vWS/XHH1bzEqIws02yOUtzPz8/ZrLaczZcszxccdnsqm5PZgof39+KTmmXCdT42WGtxeJQKlGXB5cU59WzCbDZhMplhTEZZFUQiua0gyBeLEIgB3t2+x9oMrQ0PD2vq6eQ5l3eUeGZNyhRr5QFoz+Jo5TmsYbiCQhKCQ4rPCYxJu+aoRgOV4TguR2HpFPavJS2kfu/p5gbTRfqpTK+7RdrtVRqcmIg7d+QbC4ue88Wezb4kWE9vI/4ux/kTTJAd40/EMK7UhJucbiqxO0Piw4gZ56kYR9KUSJG9t8lfAMyjeZZ4RPcDv1uNBj8xi3h74pOe4pHkZ9wgWElQkt2oUXI9uMkNA8QBDikeUxHvYPI9dAstg7goAzBCYpQkPN3uUkebOt2hqOpOngOfyz0bUjhW/1YKkzmK4nA8IhdSaN0kmeikSKKR/9xIRzlwh91EcPOhgIVnHPJUwuYhYa3Jm9rVMuAbJM1P70MYTP1V4gfvGdWSoyoQfjL4Lh7TsNUzmmANlLU4+GwoGdZFDdV7eR/FXop68Sjya7uT70k/lc0w32j6SWT/WWCI7BJedTpBFfL3fSmbiavBOPl9IRcILgw2nul0qzv5TEUSGP3ceib7Isd7N0YfTSZyVZumwfmOuq4pi5osk4BRrfXYETfHIyQjI2steVEwqSuUUpRFgdaapmnYbXfEoDg7O+Py4oyXL274k7WEtiFTOUq1RA+7w4FAB9py+eJzylIGbrPZjOurK9CR+XyO9hEfAofQMykLYYGgWKaIqt16jVaaPC/ITMbx0KAwlMmCdDab0XU9TdMwrWcELx1c23VUVUXbNsJnLkr6/nmDvmEyPByDhptpjlJUfTUcwRNTYKAetVpwSAWDImzIj0MxxsobLaouFQSeaC88zQvwuREGwBNedHZAUn01HK8DqpQpTD/LuL7coFTkbHYgRsVdnKL7XIaFRylA3UISt8uVUNpcodCZJA6j1OiSls16fK+JjZGk7SEuqDP4Sjp7X3tifpK1/pJlupNvsDAOYvqcaiyUw6BKuMKc/ruSaXyf+MBynB4KuDrJ4rUU0PLDoLBTVLeCIXeLZLOaFJRDZ2laRhc/0yhiyUjZ8nnirqfjeszEY1j3AxYKulGn7lsLZJLtBmOdBD9Nf+oPrSJipJSfOtLnkIe0O+UfSlp26lgbmUGMsvv0fA6ngcGyVRSMJ/bRYJA/mNRDmk/UkckPiGe3hmojOXzdMgWmFjHdN3k/plUoF2nP1JMoqSfwR3miJqoIqjttLMonB7taNje7k+uZHUSt6mrRBQzvRcljTzBQ3svA9b+U1fK8opxZjDYYLXBDURSEGNHGoHrJ1tNKs91ssBcXlGXO/f09PgbqqkYbTd87altKYkjbjs5qk8mQqZfx4cMd/+63/xVaCTd6/t/MMNHxx29+L6KTZk1jK7ZtJMsL/v1/+9+B0axXKyazKavNhvPlAmM0LjhcH8i9I6jANM8IUVqWGHoyk3F//8BksSD4wK+/+prJdMp0WtM2geZ4YDpdolCoVNhAMS0maKOxRUHTdVycnXP/8PCcyyuKvTQgiYm/KpNxGb65Uoqs3WjBX63HPmZSVJK8VvcqPVRqpP0QwU+DmHVn4mzW/e1RBIERtv+1tOD1NznFYxw7tKyRo1n/Hw9oHWnWBW4SeNjUXCz2WB3ovCSRwLChqHHyPAzwqjtHt8hQIbL+lThqqYkjtgbXZOSTjhQ0jBqyzWyP0xGXa1Sn4ayDh4+w8H9mRZ2SRJIKcrCqHChOyoMeNz/5QrsyEquTj8Rw5B0EAiE/2V8OA3ftRcarUkHZfSad6/Q7GXoeXpIG5YnfnKhag3iheemxK41LhWu4f5IjKO+zW0SyYxooFoy+0OV9pHUyLLXp9YQWJoknKn3ukAt2LWbxJ8z2l19cRue0obYPXO8hnEEFKcKuPnXKg8+LQEqMA0HlgQQBDMVcWEEn8YbuT8PmyQ/SNR9exVE4Y3c6xYgpiseIrxSHa0WxTlh9lI1tUHCaJsFPUxGExOzEeLJrCVx1lZhjFY+JKTUVLv7gDqh7iBPQXSRDnUJudz9/wnueIZHzGG1GdkPfO5x3Yg40n5PnOTEoLi4vcE5CUouipC4s+/2epmm4urqmPR7p+x6bW+o0KIwxjhl+1lqKzCRxRsVht+OHb/+Z//B3/xGl4H/9+/+DzeMdL6/OuXrxgvVuS991LJdLqnrGP//pn1klDw2l4fff/CO75sDLFzd0hwYXYjLJ91RVzeef1xyPDcvrM25uboDIdrtnsZgRvGK/21OWJUrHUdzy8PBAWVYsF0vuHx+x1rJcPMPGDEZ8U7s04EuRMzFhngMdqr1IO/l9liwjY3Iq07RXPpnVCNXL10FkqhFx4orJWN54JlXHrGxZHUt2b+b0/35PryL276fkK9i9huYqELY59Bq7bAm1I3474d2ipL7eoxSU35Rk+8jhRZJLD/aYTrrF7RcW00B7pjlep41ml6HnPdErun1OVjqUiigtXin9qoTCYxYd4bHAZAG3+OWVIypQabil3BNGwOCQlmhc/WygdUmBMcmEaehUIRXiIU0kMIanmv4J73fgmqdOsLmUI/zFP0R2rzX5Rl5j/yqOHbbuYfJnw+FFkGBRJ8VSCkxMQ19hcoRCOuJuKf+uneDfQgVTo0FQyCNx8LZQSU7eSketWxFLuGnK7PvFD276p05DrXiCrZ5m9vXT4VrLz+gezD7NSVLxjmYYpMnfy47SWZuWkWOt3Wk+MLgq2l1k/o2mW0gnmx3imGbdz2RjrD9EmnM1KuzEoH6guElxtivh5JujFO1sK/MBV8sJwO7kvdpdev20oQ+nDdMyduZ2J13608y+/9x6HvtCBTrXU1dTtNJ0rqUscsGX25aukwRo5zv2hz15XtC7hq5rMSbjfHlGczgQouPsfEEMiv1ezH2igt4F5rM5y9mS6ALOeTrXs5zNUF98hcKhteF/+E//Pb/7w//FZDIbU02K3LJZ7yhKy2/+5m8IrsfFQJEV5LXl6tUr2t2O/WFH1wXmywmu7ym1TpDHNVc3L+m94vLqhq5tCAEm05rHxwN5mUMMJwogkCdv6eAcx/0hQSjPW0NBHhOWC4EhdCc4cUgGKuYgD5fqFVka6HXLgD6I10K/9HI8HqSiSJF3c4+fR7Kg6b2h84ar6Z74WTqOq0j+n+54/P05fhrABkzpiYWnXxeo0lN8vUM5TQiaMu85lJHDS6F8ZQeZgncLKSjeCLPCXYtvsHbAVQuNIQZFOek4rkvyoidGhUrf4h4whbjX4cEdM3TxyxUOI+PCPTFhT1/8QfrspnGM8BkEAcGIcZA4saVilgzXtROcty/EFjI7JEwx0RCH4mQa6Zr6SSRYTXUXaRcyrAPZYKMejvWR+p0e47WiSphlnpJGOjlBKZ+EISuxAR3kw4KVC+ZtvBrjqoaCTBTM12cD9PWMYjyshLmHJ595+P+H4anI6eUzDmkzwq5I3ehW/jxi/2nY180j5YMiX0faZSqoSj6jz5PSVclpkgDTHwQmapcy0DODc2EBfRSWUHuWnoGgpeCW4mL3NJORKBS/+l2Cr3JGaG7w2BgCJuB0uh1OP8GeGC0fo8R9RFvykWsfI7PZLEmcPYvFEmstm80G7z3z+VykyE3DYpHgA+eYTqfkuaXpWmwhRvWr1YrV6pG6ruj7jrdv31IUBa9fvWa+PON29YDqPdZBFxzKZgSVQWbBGi7OzlksFiil2Gw2HA6H1L33bLdbrC1omo7tds98tuTFi1csFudok4FSeB+4ub4myzKur2+4vL4hL2vKuiIzhtlsnnjXhvmiZL3e4pwjRjjsRSa03WwJMXJ9dc3hcPhJwf6lq5vFkarVLcTsxG6l0LqFF1+EVtEvQvIWEA3+kCsXCjHbztYGuzb4Wnis1Y+GUEamL3fYRYt/LAhBEaKidRk2BeBlxpMZjz9zmHknD+TWEg4ZqnbEXtPscmzu6NqM7b6knwWaG58SN04P9uFGuovjVaS9FCGIr4V7nM/ER8KYQDFrOWxKnNPEqGgOuUAum5wYFfqyRR0M6iOpwB9bw0nDJ4zdVXHk1EIqupUUrSEmfnSGSx4f+UpsPQWPjaNgwKSC46rT/RjSYnwaFGknqSDbrxTdktEjWwZIJy/nfipFt1tKER6ijsq7ky+K7uRnpt/HERuORvybhw5Vjv6R5lUvA98w4LtJAp0nWtkzrTuHOcbou8ETDBm5BqPhuz9BO8PsItsnjHYt/+6TuMUkrxCbThWulsLtakZJv0spI8onm85z8fQeTjGuktfUw8ZXqVGkZXeMXtdD5iLI62YHxeIbgUkGzLm5UOPzLZuk4vBaKH0EeS9yckpe2RM1ilF+bj0zo6+WTxAD01mNArzvyUzO+flSHNQ8GG3pugbvNNPphLbraI9H5osFvXM07ZayOiOvcrYPax53G15cXvPF688IjefYNbTdkcfOkeUtTevQSuNCwDUHVNZwdn7Jw8MarTPOzyfc3z0CMJtNaJvAZrfGaMO3373h+uKcKrcUeU01n9H2Lb5pKfOS+MJydnnN+dk5x65ntdmw2e55eX3DRjfQRaq65PB45M3mkc/Pr2mPLXlhOR46HjcbrhdLnPO07fP8lEfjkihdFaQHPYv0Zx6zM2NXpVPkuZtIMRaqWxgTFHwViLlIe+1W0V4G7Ks9XZfh2gzVKtqjxWae3bFAqUgImuaYo01gen5g91iDithlQ/8gpwA77XCd4bgrBM75rsJfOFThaXNDPzXyfrqIz6G5BnfRMzk70jYWt8lxO8vsekd3sDhnqMuOdlPQP5aYyyOhySAPqMbgtxa7aIle4Ztf/vgOuKsvEl6cPDvE12OgUAk9TTo8YaEMLIJBHNHPhekydHq+iuIvcRkFn+0U1VszSnxDkSTVSLHJwhPfjYT7q6NguwMMIvQ4TlBVL7Q4SIU54bEE2H4lHaJOuGy+Shl1Sgq4z0E1mvPfafafCy8YSFLuBK/kfNSf4WevbVJHBstoDWqOA7MhXdvqxMEPZhgknyCN7DCcEEnJ7dBNIvWPUmRdLSeZxR8FyzWt0PjyTRx50mMuoE9eJOl3uFreF0Bzfvp7vpTvUvEoBXXA4YHRzyQqeZZjksyHgtE2VAyRAhe/UzQXeoTtVNqMR0HRR3o1FZ/pZPZpfVqf1qf1af3rrWfBF5/Wp/VpfVqf1r/u+lSUP61P69P6tP6K1qei/Gl9Wp/Wp/VXtD4V5U/r0/q0Pq2/ovWpKH9an9an9Wn9Fa1PRfnT+rQ+rU/rr2j9P8GeQaPP6w2RAAAAAElFTkSuQmCC\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, :, :] = [[1, 2, -1], [0, 1, 0], [-1, -2, -2]]\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": "markdown",
   "metadata": {},
   "source": [
    "## Function to check the output of the image for the linear layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "VF7h_96hxx7S",
    "outputId": "382137b3-d6bc-4b03-a9a4-a87ed97e6fec"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 64, 4, 4])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "n_feature = 3\n",
    "check_archi = nn.Sequential(nn.Conv2d(in_channels=1, out_channels=32, kernel_size=5),\n",
    "                            nn.ReLU(),\n",
    "                            nn.MaxPool2d(2, 2),\n",
    "                            nn.Conv2d(32, 64, kernel_size=5),\n",
    "                            nn.ReLU(),\n",
    "                            nn.MaxPool2d(2, 2),\n",
    "                            )\n",
    "check_archi(torch.rand(1,1, 28,28)).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 225
    },
    "colab_type": "code",
    "id": "vg4CO_WDeLqh",
    "outputId": "fc763a37-9107-4e0d-a432-f84ced872dd5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 0 [0/60000 (0%)]\tLoss: 2.299225\n",
      "Train Epoch: 0 [32000/60000 (53%)]\tLoss: 0.345164\n",
      "Train Epoch: 1 [0/60000 (0%)]\tLoss: 0.193988\n",
      "Train Epoch: 1 [32000/60000 (53%)]\tLoss: 0.143094\n",
      "Train Epoch: 2 [0/60000 (0%)]\tLoss: 0.117315\n",
      "Train Epoch: 2 [32000/60000 (53%)]\tLoss: 0.100669\n",
      "Train Epoch: 3 [0/60000 (0%)]\tLoss: 0.091913\n",
      "Train Epoch: 3 [32000/60000 (53%)]\tLoss: 0.076814\n",
      "Train Epoch: 4 [0/60000 (0%)]\tLoss: 0.075198\n",
      "Train Epoch: 4 [32000/60000 (53%)]\tLoss: 0.067938\n",
      "Accuracy: 9826/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(nn.Conv2d(1,32, kernel_size=5), \n",
    "                                        nn.ReLU(),\n",
    "                                        nn.MaxPool2d(kernel_size=2),\n",
    "                                        nn.Conv2d(32, 64, kernel_size = 5),\n",
    "                                        nn.ReLU(),\n",
    "                                        nn.MaxPool2d(kernel_size=2)\n",
    "\n",
    "           # Add your modules here.\n",
    "      )\n",
    "      self.linear = nn.Linear(4*4*64, num_classes)\n",
    "      \n",
    "      \n",
    "  def forward(self, x):\n",
    "      # Input is a batch of images.\n",
    "      # Its shape os (batch_size, 1, input_size, input_size).\n",
    "      # Output should have shape (batch_size, num_classes)\n",
    "      x = self.conv_network(x)\n",
    "      x = self.linear(x.view(x.size(0), -1))\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": 38,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "colab_type": "code",
    "id": "Ye1xcjUif4e-",
    "outputId": "c48bbdcd-15e1-4b4f-eee2-ea27e18f5fda"
   },
   "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": 39,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 533,
     "referenced_widgets": [
      "6ff84e7904804cae81bdd8b78d54a364",
      "1a1a99cb5a70406986c7e6079094f02b",
      "1695b2f90c79482e8ffb9cbe8a84ff0b",
      "9a013c035e164a71a71853fba30172fb",
      "23545ed6237a4c3199807b6e10f2a914",
      "52730442e8be4bcd867accfbf37bd22b",
      "d7665ce2a36b4073b3e80909b4f062c7",
      "fed433aa1922462a8b66e38529056bef"
     ]
    },
    "colab_type": "code",
    "id": "gADbMxziFsOh",
    "outputId": "cdff6999-10e1-4ed2-d637-324f0b37d777"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Downloading: \"https://download.pytorch.org/models/resnet18-5c106cde.pth\" to /home/aims/.cache/torch/checkpoints/resnet18-5c106cde.pth\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "60b16f23874142aaafd84b7d57c51890",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=46827520), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcEAAAHBCAYAAAARuwDoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3debAlZ3nf8fft7rPebe7sM5qRRkJCAglZIBswsQ0mpmzHTmwSF6lKxcSJXdgJi6SZQTjCjo0BGy0zWiBAElMVu1Jx4qoQVwE2tuMixlh4CWgBtDNaZjT7drez9Jo//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 [optional]:** Implement your own version of forward pass of nn.Conv2d in numpy **without** using any of pre-defined convolutional functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conv Forward Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "khea9IT8QB_T"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RV30kha3vSsC"
   },
   "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",
    "    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",
    "    H_p = 1 + int((H + 2 * pad - filter_height) / stride)\n",
    "    W_p = 1 + int((W + 2 * pad - filter_width) / stride)\n",
    "    out = np.zeros((N, num_filters, H_p, W_p))\n",
    "\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",
    "  \n",
    "    for n in range(N):\n",
    "      for fil in range(num_filters):\n",
    "        vertical_step = 0\n",
    "        for i in range(H_p):\n",
    "          horizontal_step = 0\n",
    "          for j in range(W_p):\n",
    "            out[n, fil, i, j] = np.multiply(w[fil], X[n, :, vertical_step : vertical_step + filter_height, horizontal_step : filter_width + horizontal_step]).sum()+b[fil]\n",
    "            horizontal_step += stride\n",
    "          vertical_step += stride\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": 56,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "7Leww6XRuC_0",
    "outputId": "4d4be613-492e-42c3-8783-79bb1ea6cc8c"
   },
   "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": 57,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 330
    },
    "colab_type": "code",
    "id": "VQBZCpKrUVQq",
    "outputId": "79652e18-dfbc-48ce-c53c-a12a5b756838"
   },
   "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": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CS2zBOlPUWjm"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "convnet_tutorial1.ipynb",
   "provenance": []
  },
  "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.4"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "010025b45dc641d8a42f81bc2f3a6a13": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "01edb66027d1485bb30faa2c900ddd2f": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "1695b2f90c79482e8ffb9cbe8a84ff0b": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "IntProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "IntProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_52730442e8be4bcd867accfbf37bd22b",
      "max": 46827520,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_23545ed6237a4c3199807b6e10f2a914",
      "value": 46827520
     }
    },
    "1a1a99cb5a70406986c7e6079094f02b": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "1bd0f825d61f484e97df8f6e282682f2": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_a882d748140a440fa3aae49e2036dbf6",
      "placeholder": "​",
      "style": "IPY_MODEL_010025b45dc641d8a42f81bc2f3a6a13",
      "value": "9920512it [00:00, 19925279.88it/s]"
     }
    },
    "1d41d7f4fcf047aabdf5b264e414c8c1": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_b4b440acf21843888a5928e048d527b3",
       "IPY_MODEL_1bd0f825d61f484e97df8f6e282682f2"
      ],
      "layout": "IPY_MODEL_210ccbaebf244c2393e23e34f09d4102"
     }
    },
    "210ccbaebf244c2393e23e34f09d4102": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "23545ed6237a4c3199807b6e10f2a914": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "2b97d01025874200b10576347fe9d453": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "33948d928244442b861d476aef5e3ed3": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "3c0724a8db6c438ebc4d3e97f2cce581": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "IntProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "IntProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_b7894871373943338c68a0929324da45",
      "max": 1,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_33948d928244442b861d476aef5e3ed3",
      "value": 1
     }
    },
    "42ed50f42ff5495eabb25b6ff76dd694": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_fb67b7cf56e74aeda09ddc56b4b1292d",
      "placeholder": "​",
      "style": "IPY_MODEL_8a87a7c0b4ba42d68b89067e63a4072d",
      "value": "32768it [00:00, 250031.75it/s]"
     }
    },
    "469f338fb06d4b23a19c483c672b9df2": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "47e03014168e456da856d3c01dea0191": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_7ce6a3aae3a7427aa66aab3ba1d8acb4",
      "placeholder": "​",
      "style": "IPY_MODEL_adb8301e95b9455b94237ad0a2ef4586",
      "value": "1654784it [00:00, 5474942.83it/s]"
     }
    },
    "4974d84e6e52424fb9ed1d3341792f0d": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "52730442e8be4bcd867accfbf37bd22b": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "58eea398145b4c6981656413b92d5457": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "659de0a24dfe4a8bb27e26d70764a0f9": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "6e5376fb32ab4156bc2c8ba10e3f100d": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_3c0724a8db6c438ebc4d3e97f2cce581",
       "IPY_MODEL_47e03014168e456da856d3c01dea0191"
      ],
      "layout": "IPY_MODEL_b3553d409b6c4fc6aa950c6c9b0e2e00"
     }
    },
    "6ff84e7904804cae81bdd8b78d54a364": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_1695b2f90c79482e8ffb9cbe8a84ff0b",
       "IPY_MODEL_9a013c035e164a71a71853fba30172fb"
      ],
      "layout": "IPY_MODEL_1a1a99cb5a70406986c7e6079094f02b"
     }
    },
    "7483c34f774a4e7d951a4df7825fd2b5": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "7ce6a3aae3a7427aa66aab3ba1d8acb4": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "8a87a7c0b4ba42d68b89067e63a4072d": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "8a9eb7aa9d0a4e41a31962cee369870e": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "IntProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "IntProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_cc6959e6cbe74c48aaa69c97b72a572a",
      "max": 1,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_e793c316ebf0498fb49da4c2622aa783",
      "value": 1
     }
    },
    "938735cc3cb844c794d883459a74817d": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_469f338fb06d4b23a19c483c672b9df2",
      "placeholder": "​",
      "style": "IPY_MODEL_58eea398145b4c6981656413b92d5457",
      "value": "8192it [00:00, 95438.95it/s]"
     }
    },
    "955625669ff14f73aef9b9afd76b104d": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_d76a43fc904344b88b66746dcda1effb",
       "IPY_MODEL_938735cc3cb844c794d883459a74817d"
      ],
      "layout": "IPY_MODEL_659de0a24dfe4a8bb27e26d70764a0f9"
     }
    },
    "9a013c035e164a71a71853fba30172fb": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_fed433aa1922462a8b66e38529056bef",
      "placeholder": "​",
      "style": "IPY_MODEL_d7665ce2a36b4073b3e80909b4f062c7",
      "value": "100% 44.7M/44.7M [00:00&lt;00:00, 85.2MB/s]"
     }
    },
    "a882d748140a440fa3aae49e2036dbf6": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "adb8301e95b9455b94237ad0a2ef4586": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "b158c97ceb7e40b8ac56f6bf753ddfe7": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_8a9eb7aa9d0a4e41a31962cee369870e",
       "IPY_MODEL_42ed50f42ff5495eabb25b6ff76dd694"
      ],
      "layout": "IPY_MODEL_4974d84e6e52424fb9ed1d3341792f0d"
     }
    },
    "b3553d409b6c4fc6aa950c6c9b0e2e00": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "b4b440acf21843888a5928e048d527b3": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "IntProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "IntProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_01edb66027d1485bb30faa2c900ddd2f",
      "max": 1,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_bcb5b95d847146dfbf2290db072d2877",
      "value": 1
     }
    },
    "b7894871373943338c68a0929324da45": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "bcb5b95d847146dfbf2290db072d2877": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "cc6959e6cbe74c48aaa69c97b72a572a": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "d7665ce2a36b4073b3e80909b4f062c7": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "d76a43fc904344b88b66746dcda1effb": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "IntProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "IntProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_7483c34f774a4e7d951a4df7825fd2b5",
      "max": 1,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_2b97d01025874200b10576347fe9d453",
      "value": 1
     }
    },
    "e793c316ebf0498fb49da4c2622aa783": {
     "model_module": "@jupyter-widgets/controls",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "fb67b7cf56e74aeda09ddc56b4b1292d": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "fed433aa1922462a8b66e38529056bef": {
     "model_module": "@jupyter-widgets/base",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}