BMEN4460-NB4-GAN_faking_MNIST_images.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple Generative Adverserial Network (GAN) for Faking Handwritten Digits.\n",
    "Chen \"Raphael\" Liu and Nanyan \"Rosalie\" Zhu\n",
    "\n",
    "This notebook belongs to this repository [\"RnR-2018/BMEN4460-NB4-GAN_faking_MNIST_images\"](https://github.com/RnR-2018/BMEN4460-NB4-GAN_faking_MNIST_images) and its parent repository [\"RnR-2018/Deep-learning-with-PyTorch-and-GCP\"](https://github.com/RnR-2018/Deep-learning-with-PyTorch-and-GCP).\n",
    "\n",
    "This notebook is inspired by [this succinct GitHub repository](https://github.com/lyeoni/pytorch-mnist-GAN) and [this elaborate GitHub repository](https://github.com/Garima13a/MNIST_GAN), neither of which can be directly run/used due to issues with the PyTorch version of the MNIST dataset as well as some weird things with the training processes. Anyway we thank them for the resources, and we especially like the latter who walked through some nice concepts in detail.\n",
    "\n",
    "Also, we later found [this beautiful GitHub repository](https://github.com/znxlwm/pytorch-MNIST-CelebA-GAN-DCGAN) that is, no offense, way cooler than the other two. You are encouraged to take a look."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import the necessary packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import tensorflow.keras.datasets.mnist as MNIST\n",
    "from sklearn.model_selection import train_test_split\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "from torchvision import datasets, transforms\n",
    "from torch.autograd import Variable\n",
    "from torchvision.utils import save_image\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "# Device configuration\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set the random seed for reproducibility.\n",
    "The random seed helps to make sure that the model parameter initialization, sequence of random shuffling, and most other nondeterministic operations are kept the same each time you run this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(4460)\n",
    "np.random.seed(4460)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare the datast. This time we will use the entire training set (N = 60k)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 100\n",
    "\n",
    "(image_MNIST_train_set, label_MNIST_train_set), (image_MNIST_test_set, label_MNIST_test_set) = MNIST.load_data()\n",
    "\n",
    "# MNIST data is in range [0, 255] and we need to normalize them to [0, 1].\n",
    "image_train_torch = torch.from_numpy(image_MNIST_test_set / 255).type(torch.FloatTensor)\n",
    "label_train_torch = torch.from_numpy(label_MNIST_test_set).type(torch.LongTensor)\n",
    "\n",
    "train_data = TensorDataset(image_train_torch, label_train_torch)\n",
    "train_loader = DataLoader(train_data, batch_size = batch_size, num_workers = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's check our dataset loader is functioning properly by displaying a sample image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAALEAAACxCAYAAACLKVzFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAEt0lEQVR4nO3dzyusbRyAcfN6LU7ZIMoCp6xs5EdKochGLI9/4djIRlnbW9r4C2yUspCkKBZYsBA6HTlngU5KjQVKqHk3ZzffR2ZeY+Ya12f5nadxL67umtvzzKQymUyFRPZPsRcg/V9GLDwjFp4RC8+IhWfEwvv3tRdTqZTnbyoZmUwmFc3diYVnxMIzYuEZsfCMWHhGLDwjFp4RC8+IhWfEwjNi4Rmx8IxYeEYsPCMWnhELz4iFZ8TCM2LhGbHwjFh4Riw8IxaeEQvPiIVnxMIzYuEZsfCMWHhGLDwjFp4RC8+IhWfEwjNi4Rmx8IxYeEYsPCMW3qu/Y1dKxsfHw/n379/D+Z8/f8L54+NjOF9cXMyaXV9fh9een5+HcxWHO7HwjFh4Riw8IxaeEQsvlclkkl9MpZJf/GC/f/8O51+/fi3Y37y7uwvnp6enBfubhXZ1dRXO5+bmwvnBwUEhl5OTTCaTiubuxMIzYuEZsfCMWHhGLDzMvRNJ90i0t7eH8x8/foTztra2cN7V1ZU1GxwcDK/t7e0N55eXl+G8qakpnOfq5eUla3ZzcxNe29jYmNN7X1xchPNSOp1I4k4sPCMWnhELz4iFZ8TCw9w7UQw1NTXhvKOjI5wfHh6G856enndZT/RUytnZWXht0ulMbW1tOJ+cnAznCwsLb1xd4XnvhMqWEQvPiIVnxMLzgx3ct2/fwvnS0lI4Pzk5CedDQ0PhPJ1O57ewAvCDncqWEQvPiIVnxMIzYuF5OgHS0NCQNTs+Pn7ztRUVyV/MuLy8nP/CPoinEypbRiw8IxaeEQvPiIWHeWRf8Y3r9fX14bW3t7fh/OfPn++6plLgTiw8IxaeEQvPiIVnxMLz3okS1NfXF863trayZlVVVeG1SV+GuLOzk/e6is17J1S2jFh4Riw8IxaeEQvPeydK0OjoaDiPTiI2NzfDa/f29t51TaXMnVh4Riw8IxaeEQvPiIXn6UQRffnyJZyPjIyE86enp6zZ7OxseO3z83P+C4NxJxaeEQvPiIVnxMIzYuF5OlFEMzMz4byzszOcr6+vZ812d3ffdU1E7sTCM2LhGbHwjFh4PrL/AcbGxsL5yspKOH94eAjn0b+j9/f3818YjI/sq2wZsfCMWHhGLDwjFp7/dn5HdXV14Xx+fj6cV1ZWhvO1tbVw/plOInLhTiw8IxaeEQvPiIVnxMLz3ok8JJ0qJJ0edHd3h/Nfv36F86RH9pOu/yy8d0Jly4iFZ8TCM2LhGbHwvHciD62treE86RQiyfT0dDj/7KcQuXInFp4RC8+IhWfEwjNi4Xk68YqWlpZwvrGxkdP7JH1x4Orqas5rUjZ3YuEZsfCMWHhGLDwjFp6nE6+YmJgI583NzTm9z/b2djh/7akavZ07sfCMWHhGLDwjFp4RC8/Tib/6+/uzZlNTU0VYiXLlTiw8IxaeEQvPiIXnB7u/BgYGsmbV1dU5vUfSo/b39/d5rUlv404sPCMWnhELz4iFZ8TC83QiD0dHR+F8eHg4nKfT6UIu59NzJxaeEQvPiIVnxMIzYuH5Y4zC8McYVbaMWHhGLDwjFp4RC+/V0wmJwJ1YeEYsPCMWnhELz4iFZ8TC+w+A6+2mnfQEOAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dataiter = iter(train_loader)\n",
    "images, labels = dataiter.next()\n",
    "images = images.numpy()\n",
    "\n",
    "# get one image from the batch\n",
    "img = np.squeeze(images[0])\n",
    "\n",
    "fig = plt.figure(figsize = (3,3)) \n",
    "ax = fig.add_subplot(111)\n",
    "ax.imshow(img, cmap='gray');\n",
    "plt.axis('off');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the Generator and the Discriminator.\n",
    "\n",
    "The so-called \"Generative Adverserial Networks (GAN)\" is not a particular network architecture per say. It is a training strategy named \"adverserial training\", such that we employ a \"generator\" (**G**) (i.e, a fake artist) and a \"discriminator\" (**D**) (i.e., an FBI agent) to compete against each other. The **G** and **D** can take any form.\n",
    "\n",
    "For now, we are using the simplest feedforward neural networks to do the job. **You can change them to convolutional neural networks if you want to have a try.**\n",
    "\n",
    "The **G** generate images from noise (at least this is how normally generators are defined) to mimic the images provided, which in our case are the MNIST handwritten digits. The **D** is trying to distinguish which images are real and which ones are fake."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Generator(nn.Module):\n",
    "    def __init__(self, g_input_dim, g_output_dim):\n",
    "        super(Generator, self).__init__()       \n",
    "        self.fc1 = nn.Linear(g_input_dim, 256)\n",
    "        self.fc2 = nn.Linear(self.fc1.out_features, self.fc1.out_features*2)\n",
    "        self.fc3 = nn.Linear(self.fc2.out_features, self.fc2.out_features*2)\n",
    "        self.fc4 = nn.Linear(self.fc3.out_features, g_output_dim)\n",
    "    \n",
    "    # forward method\n",
    "    def forward(self, x): \n",
    "        x = F.leaky_relu(self.fc1(x), 0.2)\n",
    "        x = F.leaky_relu(self.fc2(x), 0.2)\n",
    "        x = F.leaky_relu(self.fc3(x), 0.2)\n",
    "        return torch.tanh(self.fc4(x))\n",
    "    \n",
    "class Discriminator(nn.Module):\n",
    "    def __init__(self, d_input_dim):\n",
    "        super(Discriminator, self).__init__()\n",
    "        self.fc1 = nn.Linear(d_input_dim, 1024)\n",
    "        self.fc2 = nn.Linear(self.fc1.out_features, self.fc1.out_features//2)\n",
    "        self.fc3 = nn.Linear(self.fc2.out_features, self.fc2.out_features//2)\n",
    "        self.fc4 = nn.Linear(self.fc3.out_features, 1)\n",
    "    \n",
    "    # forward method\n",
    "    def forward(self, x):\n",
    "        x = F.leaky_relu(self.fc1(x), 0.2)\n",
    "        x = F.dropout(x, 0.3)\n",
    "        x = F.leaky_relu(self.fc2(x), 0.2)\n",
    "        x = F.dropout(x, 0.3)\n",
    "        x = F.leaky_relu(self.fc3(x), 0.2)\n",
    "        x = F.dropout(x, 0.3)\n",
    "        return torch.sigmoid(self.fc4(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define hyperperameters and initialize the two models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "z_dim = batch_size\n",
    "mnist_dim = image_train_torch.shape[-2] * image_train_torch.shape[-1]\n",
    "\n",
    "G = Generator(g_input_dim = z_dim, g_output_dim = mnist_dim).to(device)\n",
    "D = Discriminator(mnist_dim).to(device)\n",
    "\n",
    "criterion = nn.BCELoss() \n",
    "\n",
    "# optimizer\n",
    "lr = 0.0001\n",
    "G_optimizer = optim.Adam(G.parameters(), lr = lr)\n",
    "D_optimizer = optim.Adam(D.parameters(), lr = lr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Isolate the training processes of D and G into standalone functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def D_train(x):\n",
    "    #=======================Train the discriminator=======================#\n",
    "    D.zero_grad()\n",
    "\n",
    "    # train discriminator on real\n",
    "    # The '0.9' is for smoothing of the ground truth label.\n",
    "    x_real, y_real = x.view(-1, mnist_dim), torch.ones(batch_size, 1) * 0.9\n",
    "    x_real, y_real = Variable(x_real.to(device)), Variable(y_real.to(device))\n",
    "\n",
    "    D_output = D(x_real)\n",
    "    D_real_loss = criterion(D_output, y_real)\n",
    "    D_real_score = D_output\n",
    "\n",
    "    # train discriminator on fake\n",
    "    # The '0.1' is for smoothing of the ground truth label.\n",
    "    z, y_fake = Variable(torch.randn(batch_size, z_dim).to(device)), torch.ones(batch_size, 1) * 0.1\n",
    "    x_fake, y_fake = G(z), Variable(y_fake.to(device))\n",
    "\n",
    "    D_output = D(x_fake)\n",
    "    D_fake_loss = criterion(D_output, y_fake)\n",
    "    D_fake_score = D_output\n",
    "    \n",
    "    # gradient backprop & optimize ONLY D's parameters\n",
    "    D_loss = D_real_loss + D_fake_loss\n",
    "    D_loss.backward()\n",
    "    D_optimizer.step()\n",
    "        \n",
    "    return  D_loss.data.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def G_train(x):\n",
    "    #=======================Train the generator=======================#\n",
    "    G.zero_grad()\n",
    "\n",
    "    z = Variable(torch.randn(batch_size, z_dim).to(device))\n",
    "    y = Variable((torch.ones(batch_size, 1) * 0.9).to(device)) # The '0.9' is for smoothing of the ground truth label.\n",
    "\n",
    "    G_output = G(z)\n",
    "    D_output = D(G_output)\n",
    "    G_loss = criterion(D_output, y)\n",
    "\n",
    "    # gradient backprop & optimize ONLY G's parameters\n",
    "    G_loss.backward()\n",
    "    G_optimizer.step()\n",
    "        \n",
    "    return G_loss.data.item()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the Generator and Discriminator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1/50]: loss_d: 1.236, loss_g: 0.877\n",
      "[2/50]: loss_d: 1.176, loss_g: 1.281\n",
      "[3/50]: loss_d: 1.454, loss_g: 0.802\n",
      "[4/50]: loss_d: 1.321, loss_g: 0.790\n",
      "[5/50]: loss_d: 1.313, loss_g: 0.819\n",
      "[6/50]: loss_d: 1.185, loss_g: 0.987\n",
      "[7/50]: loss_d: 1.146, loss_g: 1.250\n",
      "[8/50]: loss_d: 1.353, loss_g: 1.950\n",
      "[9/50]: loss_d: 0.967, loss_g: 1.472\n",
      "[10/50]: loss_d: 1.050, loss_g: 1.286\n",
      "[11/50]: loss_d: 1.216, loss_g: 1.659\n",
      "[12/50]: loss_d: 0.950, loss_g: 1.405\n",
      "[13/50]: loss_d: 0.862, loss_g: 1.478\n",
      "[14/50]: loss_d: 1.229, loss_g: 1.630\n",
      "[15/50]: loss_d: 1.101, loss_g: 1.330\n",
      "[16/50]: loss_d: 0.831, loss_g: 1.374\n",
      "[17/50]: loss_d: 0.890, loss_g: 1.893\n",
      "[18/50]: loss_d: 1.186, loss_g: 1.393\n",
      "[19/50]: loss_d: 0.912, loss_g: 1.441\n",
      "[20/50]: loss_d: 0.834, loss_g: 1.656\n",
      "[21/50]: loss_d: 0.975, loss_g: 1.797\n",
      "[22/50]: loss_d: 0.960, loss_g: 1.814\n",
      "[23/50]: loss_d: 0.856, loss_g: 1.769\n",
      "[24/50]: loss_d: 0.810, loss_g: 1.927\n",
      "[25/50]: loss_d: 0.835, loss_g: 1.944\n",
      "[26/50]: loss_d: 0.990, loss_g: 1.653\n",
      "[27/50]: loss_d: 0.910, loss_g: 1.718\n",
      "[28/50]: loss_d: 0.829, loss_g: 1.978\n",
      "[29/50]: loss_d: 0.799, loss_g: 1.867\n",
      "[30/50]: loss_d: 0.828, loss_g: 2.167\n",
      "[31/50]: loss_d: 0.972, loss_g: 1.971\n",
      "[32/50]: loss_d: 0.918, loss_g: 2.031\n",
      "[33/50]: loss_d: 0.778, loss_g: 1.912\n",
      "[34/50]: loss_d: 0.860, loss_g: 1.912\n",
      "[35/50]: loss_d: 0.881, loss_g: 1.874\n",
      "[36/50]: loss_d: 0.959, loss_g: 1.837\n",
      "[37/50]: loss_d: 0.835, loss_g: 1.905\n",
      "[38/50]: loss_d: 0.805, loss_g: 1.891\n",
      "[39/50]: loss_d: 0.886, loss_g: 2.035\n",
      "[40/50]: loss_d: 0.976, loss_g: 1.973\n",
      "[41/50]: loss_d: 0.853, loss_g: 1.996\n",
      "[42/50]: loss_d: 0.758, loss_g: 1.847\n",
      "[43/50]: loss_d: 0.764, loss_g: 1.916\n",
      "[44/50]: loss_d: 0.883, loss_g: 1.848\n",
      "[45/50]: loss_d: 0.941, loss_g: 2.142\n",
      "[46/50]: loss_d: 0.880, loss_g: 2.209\n",
      "[47/50]: loss_d: 0.795, loss_g: 1.894\n",
      "[48/50]: loss_d: 0.803, loss_g: 1.932\n",
      "[49/50]: loss_d: 0.802, loss_g: 1.981\n",
      "[50/50]: loss_d: 0.907, loss_g: 2.189\n"
     ]
    }
   ],
   "source": [
    "fixed_input = Variable(torch.randn(batch_size, z_dim).to(device))\n",
    "Generator_output = []\n",
    "\n",
    "n_epoch = 50\n",
    "for epoch in range(1, n_epoch + 1):           \n",
    "    D_losses, G_losses = [], []\n",
    "    for batch_idx, (x, _) in enumerate(train_loader):        \n",
    "        D_losses.append(D_train(x))\n",
    "        G_losses.append(G_train(x))\n",
    "\n",
    "    print('[%d/%d]: loss_d: %.3f, loss_g: %.3f' % (\n",
    "            (epoch), n_epoch, torch.mean(torch.FloatTensor(D_losses)), torch.mean(torch.FloatTensor(G_losses))))\n",
    "\n",
    "    # Use the generator on the same input every epoch to track its performance.\n",
    "    Generator_output.append(G(fixed_input).cpu().detach()[0, :].reshape(28, 28))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### See how the Generator performance evolve over the 50 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABGYAAARdCAYAAAAT9ESdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOydebxW4/r/P7cyRKZQNKiUigZFKpVIpaJRSHKMkflrLgcnjjKc88UxOyRJSiGNpEFJ86BoVigNSoWSQof1+2Nv31/3dX3aex+q9ez6vF+v/Xp1X/t6nr2eta513/daPfd7hSRJIIQQQgghhBBCCCF2P/ukvQFCCCGEEEIIIYQQeyu6MSOEEEIIIYQQQgiREroxI4QQQgghhBBCCJESujEjhBBCCCGEEEIIkRK6MSOEEEIIIYQQQgiREroxI4QQQgghhBBCCJESujHzJwghJCGE8mlvhxCA6lFkDqpFkUmoHkWmoFoUmYJqUWQKqsX/zx5zYyaEsCyEsDWEsHm7n2fS3q7fCSFUCSG8H0JYH0JI0t4esWvJB/V4WQhhVghhUwhhZQjhHyGEgmlvl9j55INavCiEsDiEsDGE8E0I4dUQwiFpb5fYNWR6PW5PCOGD7Amj+sY9kEyvxRDC5SGEX832nZn2domdT6bXIgCEEI4LIQwPIfyQfS3zj7S3Sex8Mr0WQwgvmG37OYTwQ9rbtbPY0yYbLZMkGZP2RuyAbQAGAngOwOCUt0XsHjK5Hg8EcAuAaQCOAjAUwB0AHklzo8QuI5NrcRKAekmSrA8hFAbwbwDdAdyc7maJXUgm1yMAIITQEXveHEl4Mr0WpyRJUj/tjRC7hYytxRDCfgBGA3gWQHsAvwKokOpGiV1JxtZikiTXArj293YIoTeA31LboJ3MHvONmZzI/l+HSSGEp7P/V3ZRCKHRdr8vHkIYGkL4NoSwNIRw9Xa/KxBC+GsI4fPsu8SzQgiltnv7xiGEJSGE70IIz4YQAtuGJEkWJ0nyMoD5u+6TivxAhtTj80mSfJQkyS9JkqwC8DqAervsQ4uMJENqcUWSJOu3C/0KQF9p3QvJhHrMfq9DAXQDcNcu+aAi48mUWhQiQ2rxcgCrkyR5PEmSH5Mk+SlJkk93zScWmUqG1OL223MQgHYAXt2pHzRF9qb/DaoN4C0ARwI4D8CgEELZJEm+BdAfWTdMigOoBGB0COGLJEnGArgNQAcA5wD4DEA1AFu2e98WAE4FcAiAWQCGARi5Wz6RyM9kWj02gG4a7q2kXoshhPoARmTnbgHQdid/RpF/SL0eATwE4HkAa3buRxP5jEyoxRohhPUAvgXwGoCHkyT5z079lCI/kHYt1gGwLITwXnb+PAA3JUkyd2d/UJHxpF2L29MOwDoAE3bOR8sAkiTZI34ALAOwGcD32/1cnf27ywGsBhC2y58O4C8ASiHrf2gP3u53DwPonf3vxQBa7+BvJgDqb9ceCKBrLttZPmu3p7/P9LPrfvJLPWbnXQFgJYAj095v+tn5P/msFksAuB9AhbT3m352zU+m1yOAmgDmIOs/rspkv7Zg2vtNP3tlLR4HoCyyvt1eFcACAHenvd/0s1fW4ihkKRmaA9gPwJ0AvgCwX9r7Tj97Vy2a140FcH/a+2xn/uxp35hpk+x4TdyqJPsoZrMcWXf0igP4NkmSH8zvamb/uxSAz3P4m9v/j9oWAIX/u00WezAZX48hhDbI8so0TuLlJGLPIuNrEQCSJFkVQhgJ4A0AJ+eWL/ItGVmPIYR9kOWB+58kSf6jFSZ7BRlZiwCQJMkX2zXnhhD+jqwL4odzeG+Rf8nYWgSwFcDEJEneA4AQwv8CuBfACQA+yeH9Rf4kk2sRAJC9DOoMAFfnlJff2CscM9mUMOvVjkXWXb/VAIqEEA42v1uV/e8VAMrtnk0UexGp12MIoRmAl5Al+dLXUfdeUq9FQ8Fd9L4if5BmPR6CrEnkgBDCGgAzsuMrQwin/8n3FvmPTOsbEwC6W7h3knYtfoqs+hMi7Vr8nUsBTDY3sPM9e9ONmaIAbg4h7BtCuABZd3nfTZJkBYDJAB4OIRwQQqgG4CpkyVABoCeAB0MIx4csqoUQjvhv/3j2aw9A1lcAkf239t8ZH0zkS9Kux7Oy37NdkiTTd8onEvmVtGuxYwjh2Oz3KA2gB7K+nir2TtKsx43I+l+/6tk/52THT0HWE+zE3kXafWPzEEKx7H9XAnAfgCE74XOJ/EeqtQigL4A6IYTGIYQCyHqq53oAC//sBxP5jrRr8XcuBdD7T7w+I9nTljINCyH8ul17dJIkv0skpwE4HlkdyVoA5ydJsiH7dx0AvICsu33fAeiWJMno7N89DmB/ZK2vPBLAIvwxMWVpAF9u196KrK94lfkD7yXyB5lcj/cBOBTAu9vd+P4oSZLmf+C9ROaTybV4IoBHARye/TfeBXD3H3gfkX/IyHrM/nr2/32dOvs/UwBgbSLh6p5KRtZiNo0A9A4hFM7++32RJaYWeyYZW4tJkiwOIVyS/XeKAvgYQKskSX75b99L5AsythYBIIRwGoCSAN78I6/PZEK8TGzPJIRwOYBOSZLUT3tbhFA9ikxBtSgyCdWjyBRUiyJTUC2KTEG1uOvZm5YyCSGEEEIIIYQQQmQUujEjhBBCCCGEEEIIkRJ7xVImIYQQQgghhBBCiExE35gRQgghhBBCCCGESAndmBFCCCGEEEIIIYRIiRwfl33nnXe6dU4XXnhh1O7Tp4973RVXXOFiN910k4t17tw5as+fP9/ltG/f3sUOOuggF/v111+j9saNG13OEUf4x6X/7W9/c7GTTjopardo0cLlvPvuuy52+eWXu9iiRYuidrdu3VzO888/72J33+2fFlu+fPmofdhhh7mcBg0auFiXLl1cbP/994/ajz32mMspWrSoi5UqVSq44G7i8MMPd/W4ZcuWqN22rX/y2gEHHOBirNb22Se+T1mmTBmXM3XqVBf76quvXKxy5cpRu2BBf6pt95jqHLe1bNmyUXvhwoUup2TJki7Glin+8kv8ZMPixYu7nPHjx7tYs2bNXOynn36K2ps2bXI5S5YscTGW17Jly6g9a9Ysl2P3AwD069cvlXrs2rWr27kff/xx1K5SpYp73bhx41yM1eyCBQuitj1uALB161YXu+CCC1xswoQJUXvz5s0uZ7/99nMxe3wBYN99943arPZtPwUA06dPd7FKlSpFbXa+rVq1ysW+//57F7P9f6tWrVzOE0884WKsrtevXx+12bnVv39/F1u3bl0qtfj3v//d1eKMGTOidrFixdzrpkyZ4mJnnHGGi3377bdR2+5rANiwYYOLff3112RrY+y+BoDSpUu7mJ0rAMCoUaNy3S7bpwP8XPr555+jdv36/oETQ4cOdbG//OUvLjZixIgc3xsAjj/++Fy3AQBOPvnkqP3SSy+5nIYNG7rYM888k0ot1qlTx9XiMcccE7VXrlzpXlejRg0XW7p0qYtt27Ytah988MEux/ZRbBsAXxusX2HvP3LkSBdj46ilevXqLsbmqXa7Ro8e7XIuvvhiFxs8eLCLVa1aNWpXqFDB5Xz00UcuxubYdrxh5wjrUyZOnJjanLFp06auHu38qWbNmu51bI7Fzlk7x2I1y95/4sSJLnbkkUdGbVvrAK/jQw891MVsDc2dO9flsHlA4cKFXeyQQw7J9e+xuQLre+35xOr/yy+/dDE2Jtg5y3/+8x+Xw+ZIU6ZMSaUex44d62rRXj/b8xUAhgwZ4mLsutheC7FrlYsuusjF2Hzf9oXsWLL3+vTTT12sVKlSUZudWx9++KGL2etwwNcs66caNWrkYsOHD3cxe43G5uas7goVKuRia9asidr2egYAxo4d62I9e/aktahvzAghhBBCCCGEEEKkhG7MCCGEEEIIIYQQQqSEbswIIYQQQgghhBBCpESOjpnzzjvPxaxjpnnz5i7HrnUDgOOOO87FrGPArrEEgBdeeMHF2Lqy++67L2pfddVVLoetDWNrg+3nvuyyy1zOU0895WK33nqri1mfRt26dV3O448/7mJszbXdXz/++KPLsT4AADj22GNdzK6Be+2111wOc9jcf//9Lra7YNtjPwdbq8jWVZ9wwgku9t1330XtZcuWuRy2xteuVQS8e6NIkSIuh3kfVqxY4WLLly93MQvzOTBHkF0vvHr1apdTq1YtF5s5c6aLWUcOW7PM1v3aOgaASZMmRW3mx2HrmDOJ888/P2qzzz5nzhwXY5/LegWY56RevXouNm/ePBc78MADo7b1VgDAF1984WKHH364i9ntZ94E5mpgTgS7ppe9F/OGsDxb17/99pvLYWuPv/nmGxezPih2zjdt2tTF0oK5T/Li9WDeK+s2AoA6depE7QEDBrgcthbbeswAfzyZo4V5tpiryn4mtiadueBYLdox4sknn3Q5bFutvwnw8xPmjmH9wKmnnupiL7/8ctRm4wjrZ9KCnRfWGcFqhc3p2HhvnVPWXwDweREbm+x8k50P1hsG8H7RjpnMo8DOB9ZX2lpnfkbmk2FOs3LlykVtNt6zuRBzh9n3Z+ckc4akCevf7fhRokQJlzNt2jQXY74S65awbcB7JgE+97N1y66Z8jovsk435sdh/Sw7B+w1DPONHH300S7G+j3rzWHXK+xcZd4oW6NsrmDrP02YH8z2cewa2M7f2OsAX2dsfzC3Eatr24+zeeX777/vYgUKFHAx20+w6yrmcWWuIdtf/vDDDy6HnQ/t2rVzMTv/ZOMo68+Yd8wej0GDBrmcDh06uNiO0DdmhBBCCCGEEEIIIVJCN2aEEEIIIYQQQgghUkI3ZoQQQgghhBBCCCFSIkfHDFvr17t376jN1mKz9WitWrVysXvvvTdq9+jRw+U8+OCDLsbWztm1s2+++abLYWvImCvmoYceitpsDe7AgQNd7IgjjnAxu36PreFk1K5d28Xsennr+wH4utGOHTu6mPXOMMdEkyZNct3O3UnhwoVdbMaMGVGbrQlk61jZmltb78zbUrNmTRdj+9yuiWVru9kayoYNG7qYXZfL1tCzdY9su+bPnx+12VpVVqPsnPvll1+idvny5fP0OubRsdvKPATWL5AmbB3rrFmzovYpp5zicpjviK25PeOMM6I2cynYvhjga2mtb+Wf//yny+nUqZOLffLJJy5WtmzZqM1qkTmtWN/YtWvXqD1q1CiXY90xgPeJAd7DwJxZN954o4tt2LDBxT766KOozfoPtuY9LZivxH6uBg0auBzmt2DnvnUFsHG0ffv2LsbWWVsvwLp161wOWwfPxmDrdGL9Q8WKFV2M+YeeffbZqM1cLsw3csEFF7iYXXt/7rnnupxnnnnGxT777DMXs5+RnZPMq5YWa9eudTHrZGFzjaOOOsrFmPvD1g/zBk6ePNnFmF9qv/32i9q2/wb4PIz1eePHj4/af8Z3YecA1hcCcP+InQsBfv7JzpHGjRu7GBvLp0yZErWZq4w5FNOE9Wd2Hs3GvryO03Z8OvTQQ10O84aw8cP2hcxXw1xMrA9t1qyZi1mYI4h56957772ozeZm7DxktWadIGyOylxhbK5cpkyZqG3nyUDe/Iy7C+ZetV4Y5j9j7rE+ffq4mJ2bMe8Pm0+xc9066ph7jr2Ojfl2/Dv99NNdDvs8rF+yHlBWK2x8Z7Vo+3Y2/larVs3F2Bhs72+wnOHDh7sY8/gC+saMEEIIIYQQQgghRGroxowQQgghhBBCCCFESujGjBBCCCGEEEIIIURK6MaMEEIIIYQQQgghRErkaKINIbiYFWBZARPg5XcA8I9//MPFunfvHrUrV67scpiY67LLLnMxK5dkQkQrewOAxx9/3MXuvPPOqM0ksG3atHExJp+y4jsmX7ISVQDo2bOniy1dujRqMwkmk9MyqZ2VbrH9wCR3aWKFVICX27F9aeWVAJfxWnEhExIysZQVErLXMoEoE9ONGzfOxdq2bRu1mXTvsccec7EzzzzTxawc2QrDAH7+MhmelYsxWTjbh0weakViK1eudDlMzpUW06ZNczEr+dtnH3/fmwmBe/Xqlevf++abb1zM1gXAha421rJlS5fTv39/F7vkkktczIo7meSMycatUJcxbNiwPL3XzTff7GL2nLB9JcDHMyY7rFOnTtRm4kF2bNOiatWqLmZrkY07TCC6adMmF5s5c2bUZkJUK+UDuODS9jfsPGfj2tNPP+1in3/+edSuVKmSy7FyRQDo16+fi9m+uEaNGi6HSXaZeNOKg9n8oVixYi7GRMX2bzK5LhOOpgUba23fZcdsgNcBGx/tODRp0iSXw8ZaJgG1x4D1zazfYsJnK2Vl/SI7H9gxt/0UE5RbOTzA5yb2b7JaZKJidjysaJM9cCCTpOgAF65aeS07VmzewoTgttZOPPFEl8MEt2y77LFh0mDWb7D3t8ePzZ3ZnMKKfgGgaNGiUZs9vIHtG1Zr9qEbU6dOdTlsTspidl+wczyT+kaGFdyyazU2xjRv3tzFrJz+hhtucDmvvvqqi7Hr7sGDB0dt1hez8fbKK690MfsgBvYgIFbXb7/9tov99a9/jdpMqMvOLfawDjsnYp+RzYeYENhe07Bzq1atWi62IzJndimEEEIIIYQQQgixl6EbM0IIIYQQQgghhBApoRszQgghhBBCCCGEECmhGzNCCCGEEEIIIYQQKfFfy3+tpOewww5zOUy0c/3117tY165dozYT5jDJIhNsWUEaE1RZwSjAJbBW5Na5c2eXwySbTKZot4vJ+5isrkOHDi5m5afs81jZMMCPx7x586L2c88953KYAJEJ8nYXSZK4mBWkNWzY0OXYzwpwURg7NhYmkGb71wr1WrRo4XKYmIwJbq2Ibv78+S6nXbt2uW4D4GXakydPdjlW0AZw4ZWVoq5Zs8blMKFW4cKFXcyeA+y8PPbYY10sLZj40MqymQiT1QqTtI0fPz5qFyhQwOUwKS2TsFpJM+u7mISSHbtmzZpF7SVLlricRo0auRg7t6ys0m7njhg6dKiL2XOESekHDBjgYsWLF3cxKxpkUk22n9OC9dNWWlqlShWXwySshQoVcjEr02P188MPP7gY20f2tU2aNHE5gwYNcrESJUq4mD0HmcSQyX9Zv2u3/4QTTnA5TIrOxkM73kyfPt3lHHjggS7GRIb22LK+k21rWrAxwM5J7IMaAC6NZeOXFYoy8TWT0DPhvD3P2ZzgvPPOczE277L9CHtwQv369V2M7S97DjKJKpvnsblJuXLlojYTY1qhO8D7Tzv/Wrx4scth0uAnnnjCxXYXTOJrx2W7jwB+/Jjg1gpQrYAV4GMrq0d7DrD+jPWzrE+w28X+HrsmY/Vo5x7sPGEPwGDCYfvwCdYXs+tONpYsWLAgaudV2JwWVp4N+DmW3T8A399snL744ouj9owZM1wOu15n8wA71164cKHLYfOppk2butg111wTtdkc+LbbbnMxJkK2Dx9iD7Jgn5udg3b+zM55JtZm1yZDhgyJ2ux6af/993exHaFvzAghhBBCCCGEEEKkhG7MCCGEEEIIIYQQQqSEbswIIYQQQgghhBBCpIRuzAghhBBCCCGEEEKkRI7yX8bgwYOjNpNgWiErAJQuXdrFevToEbVfffVVl8NkrkyQ2q1bt6jdpk0bl2Nlb4CXJALAOeecE7WZ0OuTTz5xMSbrsqI7Jmq0smEAmDNnjoudddZZuW4Xkx6z49G9e/eozYTKaYp+GUySbMWKTGS1atUqF2MCQiZktDCxIBM9WXEhe28m62N1a6VUTDLNapuJs++7776oXbt2bZfDamHdunUuxvahhck3mZDNSgnZtjOZXFqwY2ClyUuXLnU5TFDHBLq1atWK2gMHDnQ5TFrIBHN16tSJ2qNGjXI5TKL54Ycfupj93P3793c5TM7Ljt2pp54ata3YDeDjy+233+5ic+fOjdpMksj6M3Y87LnKBMHvvPOOi6UFk8uWKlUqajN5NJOKMumn3W9TpkxxOWPGjMltMwEAZ599dtRmEkPWV/7jH/9wsX79+kVtJv276aabXMwK+QG/Dxs3bpzr3wOATZs2uZj9TGzf50UYD3ixL5NsTp061cXSgsklrXiUjSVMzsgk93a/sfkOE0qXLFnSxez8idU+O/dZf23nqUyAzuatbCy028oeXsBE+Gw+YQW9bD9/+umnLsbOy5EjR0ZtNueoV6+ei6UJE3rasYidd0xGzUSgdj8xSTkbR88991wXY3JoCxOIWtEv4PuJX375xeWw48euRax497LLLnM5I0aMcDFWoxMmTIjaTCTPxmS2723fyPrZvDzQY3fBzilbZyyHCcjZ2P35559HbSZWfu+991yM9UH2tUzqy0TRrP+3n/HFF1/M9e8BXFhds2bNqM3qwj44A+APjrFzZdY/s2tse38A8PMAds3NxukrrrjCxQB9Y0YIIYQQQgghhBAiNXRjRgghhBBCCCGEECIldGNGCCGEEEIIIYQQIiVydMwMGTLExVq3bh21t23b5nLY2kXm/rBrge1axh29jq2XvPzyy6O29SoAwCGHHOJiCxcudDHrumHr2JiT4YMPPnCxW2+9NWpfffXVLueGG25wsZNPPtnF7BpKtp+Z1+LZZ591sbp160bt+++/3+UsX77cxdKErUO06/2Yk4KtvWZr9e3acbZG9swzz3Qxth7ZrpNla0fZ+lrmbWnfvn3U/vnnn13OuHHjXIytWbbrVdl6XuZ3mTRpkovZ7WdrTpl/x/pkAF/bGzdudDmsf0gLttZ75syZUbtgQd+99unTx8WOPvpoF7Pr3q1zBuD7kbmvihYtGrUXLFjgcmz/CQAtW7Z0MetuYf3zRRdd5GIM6x+yDi3Aew0A3o9Pnjw5al9yySUu58svv3SxEIKLWT8L6wfZOZ8Wdt014NebMxcH+wz2dQAwa9asqM3WfjPPAfNs2O24+OKLXc4bb7zhYsxVZX1crN9avXq1i7E+r3z58lGbuRbY2njmfrLrxm+++WaXw8Yk5m6wXhv2Ge35nSYrV650MXs+sf3PnFD2mAB+XGBzAtbvDhs2zMXsWDh79myXY+dJgHdbAN4Lw8bx0047zcWYo8g6kJjviPVlzM1kPxObtzLvoXVJAkCnTp2iNpuHsPlnmrBas9vNPELMxcH8Gfa9mMuIed/Y3P2LL76I2sw3yNxU7G/az/3NN9+4HOYWYQ4ie43HnI3s87C/aeeD7NqKucKYH87uL/b3mIcvLSpUqOBi1mHC+rzHH3/cxazPEPDjMsthbkR2rWyvGe+8806Xw66PWL9k5+3sdew+ArvOt/XC+mw73gD8+qtw4cJRm7k1x44d62JszLHeNNb/s/ffEfrGjBBCCCGEEEIIIURK6MaMEEIIIYQQQgghREroxowQQgghhBBCCCFESujGjBBCCCGEEEIIIURK5Cj/rVy5cq5v8OCDD7pYz549XaxLly4u9tBDD0VtJmRlIkkmnLSyzDvuuMPlMLneU0895WJW1vfpp5+6nOeee87FmEBz2rRpUfv66693OUmSuBgTbFn5GJNdVa9e3cXY/rJyt/Xr17scJjhNEyaI+uyzz6J27dq1XQ4TUjEpXOfOnaM2E0MzKS2TaFpJGxMGtmvXzsWWLVvmYlY+yvYDE0Da2gOAYsWKRe1jjjnG5TD5GhNx/fjjj1GbiePYNtSrV8/FrMi2dOnSLufrr792sbRg+8PWBpMFMnGYlaADXj7IBK+sFlmfbWNMQsmEmewcsbJKJjljYlNWs7YWJ0yY4HKYLN1KlgHgqquuitpW4A5wCSMTZlqp9dy5c12Orf00Yf207ZNY/8PGDyZPt8JZdsyZlJbVpxVOMqE3E0kycZ4VAbIxk8kO2TzDCqXZ+cDqjp3jzz//fNRmguN33nnHxdauXetiVnrJjtmRRx7pYmnB+m0rXmT7f/PmzS7G5KRW1MpkqOyYszmQ3VYmFa9SpUqettXKi9m4agWRAD92diz/7bffXA7rm9n4aMXB48ePdznsIQFM0Pn+++/nmsMeEpAmbJy2c12Ww2qBiWptv8eEyHm5jgJ8vbO+mD0wwl77AL6umMSaiZpZP277e/b3WG0zsb6dG7AHGLDPyOZNVuzLzkt2bNOCiejtQy9eeOEFl8PmLWy/jRkzJmqzOQqbe7Pjee6550ZtVtdTp051MTY3sMJxJhu313EAl55/++23uW4X6/+ZCNn2l+x6jMmYmeDePvyA9dnsc+8IfWNGCCGEEEIIIYQQIiV0Y0YIIYQQQgghhBAiJXRjRgghhBBCCCGEECIldGNGCCGEEEIIIYQQIiVylP9aOSMAHH300VG7b9++LoeJmrp27epiVtZXq1Ytl8OktEzGa+WAbdu2dTmzZs1ysR49erjYo48+GrWffPJJl1OqVCkXGzRokItZwVzHjh1dTsmSJV2MSauskLB3794u55prrnExJnO97bbbojaTFTEJY5owGe+ZZ54ZtdesWeNyWD0yiaKtR1Z7TDB25ZVXupgV9p588skuhwn8rNwKAMaNGxe17WcGuECaiQWtYHLFihUuh0n9mCjO1seGDRtcToUKFXLdBsDva/Z5mFAxLZgc0H4u1k/lVbZsxXlM9sakryxm+40pU6a4HCtoA3j/bwVmtjYB3jeWKFHCxaw4lUmJ2b755JNPXMzKbhs2bOhymHyPCattrbP9wKRwacGEnv/5z3+iNpPrMVFfmTJlXMyKHYcNG+ZyLrzwQhdj/a7tF0899VSXw+qH9f32XGJjJpOpM1G67XdZH8UExIULF3YxK+1kfToTiS5atMjF7HFjx4wJlNOCib+tYNuKcgE+B2LSfitIZWJMJhe2olDAHye27azPYCJtKwhnYyGTcbJxzvb1bMyYM2eOi7G+0sqRDz/8cJfD9jMbt+17sc/YqlUrF0sTJkS2+5c9vIEdFybjtecxq+28CHUBP86wsZyNO2wuYudw7NqH9UtMkmqvDZhwlY0beRHvsjk261NZf2z7SyYLzyRJP5MaW5EsmyexfcTmSrY27BwA4OfsiBEjXMw+dIc9AIHJnVn92FocOnSoy2HyaHYu2TlF69atXQ47H9jYamv27bffdjnsuo0Jzq3gmz3sgl0PNJjVITUAACAASURBVGjQwMUAfWNGCCGEEEIIIYQQIjV0Y0YIIYQQQgghhBAiJXRjRgghhBBCCCGEECIldGNGCCGEEEIIIYQQIiVylP++/PLLLvb0009HbSsvArgQsnjx4i5mRZJdunRxOd27d3cxJmmzAsS33nrL5dx0000uxgRJF198cdRmn6dZs2YuNnDgQBez8jgmANq6dauLMamdlXa2adPG5TCYCPmf//xnrq9jklkrDd6dnH766S42ceLEqF2nTh2Xw/ZvoUKFXGzx4sVRm4mfKlWq5GJMnmfrnUmxpk2b5mJMVmYFpUzUzOSYv/76q4tZwTbLsZI/gEsQrdTruOOOczlMAFqgQAEXs8JVJlk+6KCDXCwtatas6WJWIsikah06dHCxd955x8VsrTOhGRMbMqm1leI1btzY5TChH6uDZ599Nmpv3LjR5bBtZdh+nEkYrbgY4OeSFbMyQfCHH37oYmz8atKkSa7bkElSQSb0tMeFjZmbNm1ysY8//tjFbJ1dffXVLmfy5MkuxsZIK8tkf4/1GWz7mZTZMnjwYBdj4k3b37DxgfVvTIpuJfJMSM/E7EwYaIWjrL/OJPkvO/etJJLNBdn+Zv2BPXbs/GV9M5vD2XGVHRM25jAppT1HWJ/B5KSsj7V/k20DE2+y97Kia7bvbb0CvF9fsmRJ1GbHh81D0oTtc7tP5s2b53KYDJ89rMHOLe3DPgA+l2ESXzuvY7JhdlzYWDR9+vSo/cEHH7ic6tWruxiTxNu/yeqFXa9UqVLFxfr16xe12XnPaoidc/b8ZbJhJtNNC3btZ8cUNp6w+Rr7rFbY/dFHH7kcJsF98cUXXcyKcJm4mD04gV1rvfnmm1G7V69eLodd57NatOM5m9Odf/75LtaoUSMXe+yxx6I2m2PY60uA71e7L/Iq/N8R+saMEEIIIYQQQgghREroxowQQgghhBBCCCFESujGjBBCCCGEEEIIIURK5OiYKVWqlIvZ9ZjPPfecyznwwANdjLlJnnrqqah93XXXuRy2vtaupQP82ja2Zo2ty2Nrj+0a5cKFC7uc2bNnu9jtt9/uYnZNL3Pf1KtXz8XY+l27Bu6www5zOcwbYNcLAt4ZYh0NAHc5pAlbo1muXLmozfYbW1dZv359F7NrdVkds/WvZcqUcbHTTjstarM1vqy22RpN60Hq27evy2Hrea1PBgAGDBgQtdl6zFGjRrkY8znYNdB2XTOQdy/MV199FbVXrFjhcuyxThN2/tv1wTfeeKPL2Wcffy+crT21NcvWwbP90bFjRxebMWNG1GZrxNl5w46BXQdvfVwAd9+w9zrjjDNyfR1bU8/24fr166M2O48aNGjgYmXLlnUxW9dsu0aOHOliaXHCCSe42LJly6L2hg0bXA6rA9aXWa/WF1984XKYk8F63wDvw2E+ENbPn3rqqS5m++IFCxa4HHaOWMcE4D9TyZIlXc4xxxzjYk888YSL5cVXw8Yk5kOwYxIb85n7Ii3YsbPuFlYr7Bxjtbhu3bqozZwpzFvE/HTWV5Mkicux3jnAn1uA7zOYH2Tt2rUuxvqyypUrR+1Zs2a5HOZOat++vYtNnTo1ajMHGfMssnGbuZ8srL/ONGytsXOdnWeTJk1yMevLY44ZNrdmfkFby8yFxfx8zI1hfUDMj8XmFMwraWuU9TfMvdi/f38X27JlS9S2nkKAz62Yz8T2BeycY2NQWjAXnP38zI3Hrj+Z58Q6Ydkxv+CCC1zskksucbHWrVtH7ebNm7sc5jtjc1nrL+zcubPLsdclAJ+v2fH29ddfdznMbcfqwF7f2toEgDlz5riY3TcMdu31yCOPuFi3bt3o6/WNGSGEEEIIIYQQQoiU0I0ZIYQQQgghhBBCiJTQjRkhhBBCCCGEEEKIlNCNGSGEEEIIIYQQQoiUyFH++9lnn7nY2WefHbWvuOIKlzNo0CAXGzhwoIu1adMman/77bcuZ+LEiS7GpHBWQmkFagBw3333uViNGjVczEra5s+f73JatGjhYkOGDHGx4cOHR+0iRYq4HCZAZDz//PNRmwnKmJjonnvucTG7r5kQkYmKW7Zsmet27irY57XiOis1BryIF/ASU8DLHZlojYm4qlev7mJW9sskhVbKCvDPaIV95513nst59913XaxatWouZs9fK6oEuPiPCQ+t1IsJOpnkcujQoS5mpbXsPGH7OS2YAM/K9F555RWXc8MNN7gYkw9aGe+aNWtcDpPJMcG5FV3vv//+Lmfu3LkuxkSAP/zwQ9RmfV6TJk1cjAlj7bm6cuVKl8PkgFZsCABnnXVW1GZ1PWbMGBdjkmDb/7N9z2o9Lb788ksXsxJKJhVkfb4VtQJeNMjGVia4ZHLJk08+OdftYlJB1mfYMYz1D0wEy/pFK9Bk/c/dd9/tYkzYa7f1pJNOcjlM7Pnhhx+6WPny5XPdLntOpgkbO9iYbGFjLauNU045JWqzz84kvuxBBlYeyradiZuZBNq+lm0Dey8257VjLauVm2++2cVmzpzpYvYcZ30Ze8gBk8Hbz81EwkcffbSLpcm2bdtczArf2bjDxgXWv1iRcMGC/pKKCebZ/NO+lomh7ZwL8HXMtovNC1jfxerWzrFDCC6HSb/ZfrUPbmE1a0X+AD+Olp9++snF2FiVFmxsrVOnTtT+/vvvXY59MAbAj5OVf0+ePNnlsD6uU6dOLmav4dm4Y8dygAvOhw0bFrUPOeQQl8Ouq5h43faXTO7PHtDC6tPOWdg8isXsNRTgJcT2uAJ+jpoT+saMEEIIIYQQQgghREroxowQQgghhBBCCCFESujGjBBCCCGEEEIIIURK6MaMEEIIIYQQQgghRErkKP9lItlZs2ZFbSYAuuqqq1yMCYGtoIpJ+ezfA7iYbMCAAVH7jTfecDlMlmnFRADQqFGjqM2kbUy+1qNHDxezgi0mwrN/DwAee+wxF+vatWvUfvjhh12OlT4CfB/27t07aj/44IMuJ9Ng9fHdd9/l+rqNGze6WNWqVV3MiqWY/PqAAw5wMSa4tXI3VrNsG9i2Tp8+PdftYvvm/fffdzFba0wwx2jYsKGLTZo0KWozEZcVxwHApZde6mJWvlmpUqU8vVdaMCG45eCDD3axF1980cWYDM3uS7b/mcSXxazAjAkKmQCS9Xu2juvWretymFSQvT+rdUuxYsVcbMWKFS5m+2PWD7LPzcR6VtTNBIUnnHCC39iUYMJNKwxl/Q/bRyxmhaGsz2UCayZjtNvFaowdEyYftP0gE/UxeTSTElepUiVqb9myxeX85S9/cTH2UIMuXbpEbSZ0ZCLqSy65xMVGjRoVtZlw1fadacKOp5XcMwkmG4eYsNTGmMyS9Q/Lly93Mbsva9eu7XLYmMNqw/ZTTJDKhK/sQRa21tl7zZkzx8UOPfRQF7MCUDvnBvichkk8rYiafR4mKk4T1u9ZkSwTQzMBOdtPdqzIq7yVXYucc845UZvJr9n4zurDnif22AH82o2NkXZezITbrF9i54mVsLKatX0xwI/jm2++GbXZvINJWNOCCYxHjBgRtWvVquVyfvzxRxdj8yI7LrOxfOnSpXl6r169ekXtG2+80eUwETXrl2w/wcZp+/AegM+Lbe2xemXXY0ysb+uMnZN33XWXi7H5gx3P2bjx3zwwQt+YEUIIIYQQQgghhEgJ3ZgRQgghhBBCCCGESAndmBFCCCGEEEIIIYRICd2YEUIIIYQQQgghhEiJHOW/1atXd7E777wzal933XUuZ/HixS52+umnu1ipUqWithVDAUCzZs1cjMm0rOSJScjYdt1www0uNnr06KjNRGBMGGalfwBwzDHHRO2rr77a5TBhXtGiRV3MCieZjOyZZ55xsebNm7uY3V9MjnTSSSe5WJosW7bMxex+YmImJg5buXKli1lpIBMS1qhRw8WYDNMK2Zj8+qyzznIxJsy00igmDWZyTCY+szUzdepUl8MkWOPGjXMxKy5kUi8mfWXnkxV5MuGZ7S/SZPPmzS5mJaxM9sZklUyimCRJju8NAEuWLHEx1idYyS6rlSlTprgY6+OeeuqpqH333Xe7nE2bNrkYk7BaceIDDzzgcqx4EODniK0zJqJmMGmh3V9NmjRxOZkkXGXnk4UJ/kaOHOliNWvWdDHbV1aoUMHlsH6X7aPPP/88ajORJJt3WNEj4OX3rE9nYszChQu7mJ0bMJkxq2smr7T71c4BAOC4445zsQULFriYHd/YXCEvEu3dBdu3VjzK+ig212B9hv38hx12mMthcmG23+y4ymSWbM7Bjp3tw23fBvB5COv77bYycTGrFbZdVgC6detWl8Mky2zuYMd3Jrhk758mbN/ZvnDDhg0uh40x7Dxet25d1Gb9Bjvu7BywDxRgol92XcPy7PZXrlzZ5TBRMTvn7Puzz8P6IDbXsf0x26erVq1yMSZ0tWM8O+8LFCjgYmkxfvx4F7PXE6wPYuMaqwM7lrIHaLAxjB2DuXPnRu2LLrrI5bAHPzBh74QJE6L2UUcd5XLsNTfA5yL2ISd2ngzwvpFdA9t+j8mjJ06c6GJDhgxxsVNOOSVqswcnsWvsHaFvzAghhBBCCCGEEEKkhG7MCCGEEEIIIYQQQqSEbswIIYQQQgghhBBCpESOjhm2/tuuZ//4449dDltLxdYN3nvvvVH7X//6l8thXhi2Htk6H0aMGOFyLrjgAhc799xzXcyuk2N+B+bmYOvwLr300qj95JNPupxOnTq5GFurO2PGjKh9yy23uBy2Jpqt37OfiblTBg4c6GJNmzZ1sd0Fc7nYtbTMt8DW+7HatuuR2drL2rVruxhbV2mPH1u7y9a/Mq+NfS/2OuZ3sQ4YAHjooYeitvUWAcBHH33kYhUrVnSxwYMHR2223p+tR2brQu1xZGvvrQMoTZhLoXHjxlH7lVdecTkLFy50MdsPAkDfvn2jtnUFAPxc79Onj4tZXwA7Rz744AMXY+e6fX/mGWCOIrbW376W+cqYu8Su6wf8+uC8OJF2tK12TT1bl229GWnCXEb2HGaON+aReOutt1ysYcOGUZvtM9bHfv311y62ZcuWqN2oUSOXwxxI7LxZu3Zt1GauBbY+n/VTtjZY/8NcFMzNdPDBB0ft9evXuxzm02PuHjvmWQ8FAJx44okulhbMvWXrjI0vrH9gY+20adOiNnNJMXdGXpxQtjYB3r+x/rNs2bJRmzkgWF2z9/rkk0+iNvN3MIcNey+7/cz7wfbz9OnTXcz2sWzek2kwB5St0YIF/WUQ6yPYWHTyySdHbTafYr5I5gOyTjd2rjP3HvPhWOcFc5cw18fs2bNdrEqVKlGb+XGYW4fl2bGUOTxWr17tYqxvt+9vxwOA75u0OPvss11szZo1UZv1XQ0aNHCxHj16uJi9HrTjEMDrmp0jdkyZNGmSy2HOHDbW2f6Fef1YrVgfHQBceeWVUduOBwDfX0888USuedarA/AxgY0l9lrx7bffdjn/jX9L35gRQgghhBBCCCGESAndmBFCCCGEEEIIIYRICd2YEUIIIYQQQgghhEgJ3ZgRQgghhBBCCCGESIkc5b9W9gV4QVWhQoVcDhMjMnmlhckfmXDvwAMPdDErHL788stdzksvveRiTGBWr169qN2vXz+Xw0RuVtgJeLlT586dXc6DDz7oYtdff72LWWkqkxAxCReTllmhFxMEMzFymjCRV7FixaJ2zZo1XQ4Tan377be5vhcTC1oBMwDUrVvXxaxc+IsvvnA5TC5cq1YtF7Pn3KxZs1zOkUce6WJMnG2lcPYzA3w/MwGqFQKzz8gEc0xa+9lnn0Vt1ocwmWhasM9lpZaLFi1yOUzU+f7777uYPZ6sH2zfvr2LMcGY7XuZyK1bt24uxiTNS5cujdr169d3OUymWKlSJRezQkImRGXSbCaKs9vKJIzPPfecizFhu5XmMckdO7ZpwUT0VatWjdpsfzBxbbVq1Vxszpw5UZvJf5nMkh1P2/8wySiTEVq5KuDPCdYHsvmJrWEACCFEbdZHsfOBjTdWsPr888+7HPYggiVLlriYlQ/auQmQWf0iExjb/o1JKZnglsWsSJLJLJkc3J4PgK8XJh1lfQ2rMzuPZOODHeMAPpe1+4fNE+y8EuDCajtuswdnsPpkcmH7wAgmomXHNk3YPrF9HNuXVuoL8L7EPpAgrw+fYPMpew3DHjrCJL5svLUiXNZPsdpmDzWw1xnseoL1jWz+bB8GweY1bFtZn22PB7se+uWXX1wsLdi82vaXTDbOxkP2MA4rUGdjmH34B8Bl7LbPZvMwJt5lwl47V7rttttcDhOQs3N3+PDhUZv1N+xBQx07dnQxe96zbb/iiitcjAmOq1evHrXZNSeTHu8IfWNGCCGEEEIIIYQQIiV0Y0YIIYQQQgghhBAiJXRjRgghhBBCCCGEECIldGNGCCGEEEIIIYQQIiVylP9asRUANGrUKGq/+uqrLufaa691MStDBYAjjjgianfv3t3lMAkukyG9/fbbUZvJf5mYrlSpUi72zDPPRO06deq4nG3btrkYEyfa/cUEcA0aNHAxJv6yYjEmOWLStmuuucbFJkyYELXPOOMMlzN06FAXa9GihYvtLpgYy0rOmOyLxZjkzAqBixYt6nLOP/98F2PyTStXZjJAVi9MSrxgwYKovf/++7scdk7ss4+/72r/JqshVttWaMm2lYmEmSiUCbusFJQJyZgANC2YcM+en2eeeabLYbJxJgWzkk/WdzFhN5MPWvEZk7J+9913Lnbaaae5WI0aNaI2E6Yx+SarRXvuMgkyE8UxYaDFSuIAfj6zc9duFxu7OnTokOs27C6YWNmOA+yYM/Euq2sLqwt27rM+zwonWX9XuXJlF7MCYsDXFOuj2DjKatHWf8OGDV0Oq08mULaydja+M4k8E3s2b948ajPhYoECBVwsLZj00NYik8Tb/h/ggksrTV24cGGufw/Im3CejS9s3zLp7VdffRW12X5gMkv2XvYcnD9/vsthtc5iVlQ5d+5cl9OuXTsXsyJRABgzZkzUZnNnds2QJlbqDfgaYmPyyJEjXYzNGa1Yn/VdbJ/bax+AC1AtH3/8cZ6269RTT43arK9n4mk2f7D9Epu/MfEuOzft+cSODxuT2dht5b+s9lgfkhbsPLYPT7DXnoDvWwAup7Z9aJMmTVwOG8PY/OHLL7+M2uw4Mek8G/Nt7JFHHnE5nTp1cjH2ua3snYnRWX2y8dbODZhg+q677nIx1u9ZST97CAeTWu8IfWNGCCGEEEIIIYQQIiV0Y0YIIYQQQgghhBAiJXRjRgghhBBCCCGEECIldGNGCCGEEEIIIYQQIiVyNP316tXLxS688MKofcstt7icUaNGudisWbNc7PTTT4/aTKzKhHj/+7//m2uMSQWZCLBMmTIu9uabb0ZtJgdjgiErJgKAd999N2ozwTGTfzKhlxXKsb/3r3/9y8VatWrlYlZWlNdjliZMELhmzZqozQRgbF+y97KSz5UrV7ocK8ADgHLlyrmYlW0yERqTSDFJoZXCHXnkkS7HyroAXh8bN26M2hMnTnQ5TI7JxIL2HGCfZ8mSJS7GhIo2j4nF2HFMC9Yn2GNw4oknuhwrrAP4flu9enXUZrXIJNBM5GYFkGeddZbLYX2QlU6zbbX9COAFrwAwc+ZMFzvhhBOidl7HEratVn7N+nomomZSXLv9TMrI6jotWE3ZfpBJY+1YDgCLFi1yMdbfWMaNG+dirI+122HlmQAX9e27774uVrJkyajNZIFMts8EnbZ/mzx5ssv56aefXKx9+/a5/k3Wn9raB7hI24qu2X6w86g0YaJ9K4Zmkt3Fixe7GBtX7TFg0mkWY32ZlTLnVR66efNmF7Owseq4445zMVbrtl6sTBrwffqOtsuK/FlfweY0JUqUcDErVWbnbqbNGdk83W5jXkSqAJfaW0kym9uw487GfCsgZ2JoNuazsc6Oy1ZoD/BrHyZTZXMxC+svmeTbzrGZbN6KiwF+PWf7QvZwEHb9mEm88sorUbtp06Yup3z58i42fvx4F/v3v/8dta+88kqXw6TerNbtdrAHILDxqnr16i5mxzBWF2x+UrduXRezdWYfsgIAr7/+uovlpTbatGnjcuy9AICfz/Yz2utSgJ9vO0LfmBFCCCGEEEIIIYRICd2YEUIIIYQQQgghhEgJ3ZgRQgghhBBCCCGESIkcHTNsvWTfvn2j9iOPPOJyQggudtJJJ7lYrVq1ojZbe2bdAQBw8803u9imTZuiNlvz2LhxYxd77rnnXKxz585Rm61TZ+t52Tq2K664Imo/88wzLufcc891Mbae9YgjjojazHNx9tlnu9h+++3nYnY9NVtH2qNHDxdLE+Y5sftk1apVLoe5PthaeLt+nXkA7DpggK/Rtuvcr7rqKpczYsQIFzvttNNczJ4Dv/76q8tp2LChi7HzaerUqVH73nvvdTmjR492sblz57qY9dWwNfpsjS9zNdh1m8wDYddxpglbq2v7PdYHMV8HW0tunSzXXXedy5k+fbqLVatWzcUOPPDAHLcT4OvsWb/XrVu3qN2iRQuXwz4jcxZUqFAhak+aNMnlsHOrSJEiLmZdAtbHtaPXsX1v3Qms7t555x0XY3377oCts7aOC7YenI0fbH2/PXbMK9SoUSMXGz58uIvZMZL1D8yHwNbZW4cW8y/89ttvLsbWy1uHE1sPzvYzG6etL8V6PgDuTmIuETvm1a9f3+Wwfj4t7JgAeD8EG1fZ/GP+/PkuZud5NWvWdDl2jgoA11xzjYvZORzro9ixYw4tO/axORfzZLBz0PbP7HVz5sxxMbbvba2z/o45JpivyfpAZs+e7XKYOyXTsGMd6xvZGMmuh+x1DXPasD71k08+cTHbZ1etWtXl2LEc4OO07SeYO4b14+w8tOcA8xI2a9bMxVg9Ws8bq8cPP/zQxdg5Z11MrG987733XCwt2PWLHcPYeMI+O5vL3HDDDbm+V9euXV2MOfvsGMz6AzbmDxkyxMWs95B5hdh8mvnU7LXygAEDXE6XLl1cjN2nOOqoo6I26/9ZDbPrHNs3sPON7Zv/+Z//cTFA35gRQgghhBBCCCGESA3dmBFCCCGEEEIIIYRICd2YEUIIIYQQQgghhEgJ3ZgRQgghhBBCCCGESIkc5b9M5PXll19GbSbEsrIfAHj99dddzAo+mdjK/j2ACyGt9PWee+5xOb1793ax8847z8WsDImJutq2betizz77rItZeVCTJk1cDpNL9unTx8V69uwZtZlkc/369S7Wr18/F2vQoEHUZgIo+/cA4JxzznGx3cWnn37qYlbgxORrTHLG6sqKd5kgmElSWZ6VTlohJOBlXQAwZcoUF5sxY0bUzqsActmyZS7Wrl27qM0EnUzIxgSEVpDJjg+r0a1bt7qYlRQy6SITHqYFE5NZGV3RokVdDjsmTNx89NFHR+3ixYu7HCb/bdmypYvZc+Thhx92OWeddZaLMYFlp06doraVXAPAkiVLXKxu3bouZkWDTHLH5MJ23wDA+++/H7WZiJ31s0wub/tsNg4ykXxasL6lZMmSUZvJApl4l+0jm8f6O1YHTGpvz3Mm9WUCSia4tBI+1vezvsYKFwFf6+wzsvdifR6TEFtYDedFisvGskwSrrJ+0X4GJjlm/RsT+VtJPDvPmWx1zZo1LmZFpKzu2HnDhL127srOLRZj82cr92e1yMZVti/KlSsXtefNm+dy2NjOpNm2rq2sFgBmzZrlYmlijzEAJEkStdm5yATh7FjZY8NymDjVCuYBL2FeuHChy2HHnc0zbD2yOZ09lwAuO7X7i10D5EUWDfiHSLC+mO1DNh+05wn7jKxfSQs21tljzuZO7JrAzjUBX+usVt544w0XYw9Hse/FzvVFixa5GMuz8wBWF6tXr87Tdi1YsCBq33nnnS5n8ODBLnbssce6mK1Z9lAS1mezY2TnrnaezP5eTugbM0IIIYQQQgghhBApoRszQgghhBBCCCGEECmhGzNCCCGEEEIIIYQQKaEbM0IIIYQQQgghhBApkaP8t0KFCi5m5ZVMOGbFgwBw8803u5iV9XXp0sXlMFnudddd52JWFMfEcTVr1nQxJtOzQi8rHAK4ZPfxxx93sYEDB0ZtJiNj78+kRnZfv/322y5nyJAhLnbppZfmul1MvvTaa6+5WJpYkR3gBWCbN292OUxkx46DlWwxqSITVDOZlRXKMSEkE0uVKFHCxazMkAn2mDDNStsALz0uVKiQy2HSOSa8su/P+gu279euXetiVqjIRL9MZpYW7Py3n4tJmhnsPG7atGnUtnUOAGXLlnUxJkx78sknozYTkzHpn5WrAr6umeg9L6I1wB9PJkZm5xYTXdv9wwSdeZVv2vFr5cqVLscKudOkRo0aLhZCiNqsf2fC94oVK7rY+PHjo3a1atVcDpMzjhgxwsWuuOKKXLeBiYTZdllBJxvz2fnAxgh7PrP+zooaAS5AtOcl+3tsXsMeamBrkYk+Z86c6WJpwfaHHSfYnJGJSNlDF+wDI9j8jYl+mbTfyh5ZrTABOqt1u11MgslEp0zGawXK7L1Yf1q9enUXe+edd3J8bwCYPXu2i7GxxR5Hdu4ysXOasDnDpk2bojb7HGx+yOT0tv6+//77PL2OjUVW6Mpqj43TtvYAL8JlgmNWV2yeat/r448/ztN2jRs3zsXs2MHG35NOOsnFmPzdzl2ZuP67775zsbRg15/23GPz/ypVqrgY689sn8COE3vIAzvm9jxmYmU2B+rcubOL2fktm4uwhzyw+rdMmDDBxerUqeNiL730kou1atUqarP5Q+vWrV2MydJtP86u6dl9kR2hb8wIIYQQQgghhBBCpIRuzAghhBBCCCGEEEKkhG7MCCGEEEIIIYQQQqSEbswIIYQQQgghhBBCpERggtDfmTdvnvtl165dozaTUt5+++0uxmS2VsjD3mvAgAEudscdMF39bQAAIABJREFUd7iYFfcw8RETKzFJj5X/WkkcwCVqTFpl5WNMVsfkn0zIVKZMmajNBKlMotSzZ08Xs3JIK2UEuHSqSpUqwQV3EyVLlnT12KBBg6jNaiivWBGZlVMDwFFHHeViTDZo5aO33HKLy/n8889djEm2TjvttKh96KGHuhwr9QWApUuXupitGSZHO+KII1yM1fvw4cNzfR2TwjGxppVaMhnk119/7WLjx49PpR7/+te/ulq0x5xJLpkwjQmS69atG7WZCPPGG290MSbQtfXC6q5Dhw4utm7dulzf34qpAS6mZGI++/6sxphM8tVXX3WxvIihmeSRSfSsHPKDDz5wOVY8CwDjxo1LpRaPP/54V4u272b9Fju+VjoNAK+88krUrl27tsth4m92PO3YetNNN7mcvn37uljjxo1dzMorWd/J+iQ257GCYyuCB3g/z4SxVk7NRKKDBg1yMSYHtK+tV6+ey7H9MAAMGzYslVq877773M6dO3du1LY1AHBBKutHzjnnnKjNRJJM/F2rVi0Xs30Gk4ozSfPWrVtdjM3XLGxuwvpim2elsACXzPbp08fF7DnC5p+sD2T71crgWQ6bA/fr1y+1OWPVqlVdPdq+kM2BmPyYyfDtNQU7h5mcnWHnn0z0zeakTKBrjzvr89g5x+Zmdn7CrjsY7LrJPriCXZOxuQ4b3+2+YEJlNk6nNWe88MIL3UGwIllWd2effbaL9e/f38XsucfGZLYfmRjaypZZH1S6dGkXO+igg1zM1tTixYtdDjsH7RyYbUevXr1cDrs+Yg+OsdcmeenDAf4AmCJFikRtdk4y+Xvbtm1pLeobM0IIIYQQQgghhBApoRszQgghhBBCCCGEECmhGzNCCCGEEEIIIYQQKVEwp1+ytYRdunSJ2tZ7AgDjxo1zMbaW3K65mjdvnsvp2LGji7322msu1rBhw6jN1pSxdWwsb/PmzVH74YcfdjnM5cLW79n11Gyt/z333ONibJ107969ozZbZ8zWknbv3t3FBg4cGLVffPFFl8M8H8xXs7uoWrWqi61fvz5qM48EWztYqFAhF7MOgVatWrkcdozt+kLAu4uGDBnicpj/oHnz5i5mj+miRYtcDvuMxYoVczG7rpjVP3M82HMC8O6bbdu2uRzWh1SrVs3F7PrglStXuhx2/qYF845UrFgxarNzmPkJChb03bDdH3Xq1HE5zClwyimnuJhd987e66OPPnKxSpUquZg9b1iNsX6c+SJs///AAw+4nNatW7sYq9m1a9dGbeuJAfia92effdbFLr300qhduXJll5PX9ci7A+Yosg6xESNGuBy2Bp15NqxLgrmr9ttvPxdjvhrrgZk5c6bLqV+/vosxX5PdLuYuyYsnCfD9G/NusHkAc0bZMd56UQDghBNOcDG2Lt32ecydx+YBacE8D9Z3wepu8uTJLsbGE1sHzGnCvBLTpk1zMetzsP03wN1YzM1h+3XmAmEeuOLFi7uY9U689957Loe5TGrWrOlitm8YO3asy5k+fbqLseNo+xR2HJlHIU3YvMX2VczlwnwybJxmfY6F9XFsDlS+fPmozdwf9hgAfCyy46F9b5YD8HNn1KhRUZsdY+uRAriXxJ4nbL7OttW6aQDvt2OOMbYNacHGsNNPPz1q274S4MeJjU/2OoTtWzYPuOiii1zM9oXMBcSuw5kXZuHChVGbzRnZHGbMmDEuZueWbI7Brh0+/fRTF7P9MZuv33fffS7G5v7Wo8P6TzYHbtu2rYsB+saMEEIIIYQQQgghRGroxowQQgghhBBCCCFESujGjBBCCCGEEEIIIURK6MaMEEIIIYQQQgghRErkKP/t1auXi3Xo0CFq77vvvi5n0KBBLmalwYAXczFhWpUqVVyM/c1bbrklar/yyisuh8ljn3nmGRezwj0mmLPSJgB46623XKxx48ZR+9FHH3U5TAR24YUXupiVBz3xxBMuZ8uWLS42evRoF7P7+u9//7vLYUK+NGFiLCtdYiLEY445xsWYDMpKPplokYl3mTzOilOZ+I/B5Jvz58/P9e+xbWWiaSZpszAxJRNqWSnx119/7XKYLJkJ5qy47cQTT8z176UJ2z7bL7H9z/ogduzsucfElLYuAC4jveCCC6J2gwYNXA7r44YPH+5iVlb2/vvvuxwmRLRibcDLN//973+7nEceecTFmDTbxpjol0lrrUAQ8MeD1SsT2KXFjTfe6GJWanzggQe6nIMOOsjFJkyY4GJWNMpEv+whAHkRJLMHBdSuXdvFDj/8cBfbuHFj1GYiVSYMZ1LNW2+9NdecGjVquJgVEANe1sjmGOz9rUwd8GPXlClTXE7p0qVdLC369+/vYrb/YX0BE6uy/W1fy+SuTHDL+k/bZzCpL+tPjz/+eBez4k02v2BCWfYwhTPPPDNqswcVDB482MXYZ7T9YKNGjVyOlXPuaFvte7H9wMTaaZIX0T0TxbNzatWqVS5m55uff/65y2nfvr2LsbnMpEmTojab5zHhMpPK2jGYCYjZnJQJyO21Asth4l023jZp0iRq2/k7wIXt7EEEVpL92WefuRzWp6YFm/sNHTo0arM+r169ei5mHy4CeDEuEwTffvvtLmYfoAL4/oWdR+zhMP369XMxe46w+QMTl7M+1PZBTIbN5LylSpVysTPOOCNqs/phD0JhY5X9TExWzUTFO0LfmBFCCCGEEEIIIYRICd2YEUIIIYQQQgghhEgJ3ZgRQgghhBBCCCGESAndmBFCCCGEEEIIIYRIiRzlv/fee6+LWUEjE4Xus4+/37Nt2zYXs+IeJu9jErJ//etfLnbXXXdFbSbyefrpp12MybrOPffcqM1kkyVKlHCxli1bupgVeJ1zzjkuh+3DiRMnupgVWTHJERON1apVy8WsmJEd63LlyrlYmjA536+//hq1mSCYSS6ZJNnK7JiYzIodAS5Ds9JAJp9iUtE333zTxWwNbdiwweUsXrzYxebMmeNi9jMxmdw333zjYr/99puLWYkeE4Cy84TJqO05wMRxmSRcZeeelbAycSSTlTHBuf38VnQKcHlfs2bNXMwKMl999VWXwz7PDTfc4GIvvPBC1GbiRCZEZdLJ2bNnR222v5gAkWHPcSb/nTZtmou1atXKxawMj0mcP/zwwzxt1+6A7W8rp2eSXTZOs31kxX+sX7n00ktdjAkn7YMBrFgY4OMhE1Hb/pMJrK0QEeCCQivpZ2MNm1Mw0bUVAZ511lkuh40tr7/+uovZvpiN70wYnxZsDLAybSbcZpJ4Jli3/SKrYSbGZAJdK8dkrxs1apSLsXHIHgM2Rm/dutXFrAwV8LXBji/bN2xssfMV9uAM9rqGDRu62GGHHRa1bf8N8PE+TdgYac911uex8YPVqK0/9jo2tjLZqX24B5P6WuEtwPv/8uXLR20meGUPa/j5559dzPZndt4H8Os7Joe113NMSs8eAsO2y+4fJqNmc4q0YMepa9euUfvtt992OWx/s/PM1h57EAqT+7PrPFvXrIbZOM2kt/Z8Y9cqbFuXL1/uYvbBFUysz+ak7BrQCrhZv876cTZ+2WtANi9g4zu77gb0jRkhhBBCCCGEEEKI1NCNGSGEEEIIIYQQQoiU0I0ZIYQQQgghhBBCiJTQjRkhhBBCCCGEEEKIlMhR/stEYWXLlo3aTGjDZKhWNgsAzz//fNS+5JJLXA4TQV199dUu9tRTT0Xte+65x+X8+OOPLlaxYkUXs5/byot2xJgxY1ysRYsWUdsK5wCgW7duLmblXQDQrl27qD1p0iSX07FjRxe7++67XcyKj5gA6qqrrnKxNGGCqDZt2kTtqVOnupyjjz7axYoUKeJiVkrFRGtMBmXlqoAXUa5cudLlMPE0k0JWr149ajOxFJO7WWkbABQsGJ/yTKrGBMpMgGqFwGzbmVyYiQutYJvJmZmsLi2siBsAXnvttahdt25dl8PEZCxm5a3Lli1zOU2bNnWx7777zsUqVaoUtYcMGeJymLh87ty5Lmb70GOPPdblMHEqO55WoGtF3gAfS5hU0MptWb126dLFxfr37+9iViLIZNjsvEmLTz/91MVsf37eeefl6b0qV66ca8z2IQDQq1cvF2O1aCXB7Jxmdcfey8qFmaCwatWqLnbIIYe4mP1MTNTKxkN7zgP+M7H6yetDE6w0fvLkyS4nk4SrbB5hpZfswQZMjs9EkjbGHmzQtm1bF2MScbsvmWyVxXr27OlidpxjfRSrayY/tVJdVhd5mScAvi9mUn32XmyeareViZ7ZPCRN2Hm8Zs2aqG2vaXYE64NsvS9atMjlsP6SXSvYeZGdowNeEAzwY2q3g207e+gAkxfb+mAPaWHXaQz7XmyuySTuTNB86KGHRm12rJmwOS3YXNjKxdl1cunSpV2MXTvY85/Nww4//PBctwHw5zG7Bmb1YwXhAPDJJ59EbSbk/tvf/uZi7MEAtq7vv/9+lzNy5EgXY9dCVqrO5utjx451MfYQADZ3tVx55ZW55vyOvjEjhBBCCCGEEEIIkRK6MSOEEEIIIYQQQgiREroxI4QQQgghhBBCCJESOTpmhg0b5mJ2/bRdMw4A7777rouNHj3axeyaSrZ2i61H++ijj1zM+hbyumatefPmLma9A3feeafL6dGjh4sxT8N1110XtZnvpXbt2i7G1r1ec801UbtatWoux667BLjfxK5btL4QAHjyySddrE+fPi62uzjooINczNYMW0PJ3DTMc3LMMcdEbbYukTk12PpCm8fW0rI6Zu9v89hnZGvhWQ3Z+mCvW7t2rYuxtdN2jem2bdtcDltzztamr1ixImqz2p4+fbqLpcWUKVNczPoOmH+rdevWLsZ8JfZ8ZPXD1lSz2rBrbtlaWnaOsPXZdt0yW/t9yimnuJhdZwz4vpetu2efm7nCrFeCjSUbN250MbYO2+4L5qjKJJifwx6DV155xeUwzwlz0Vg/Adtntu8EvNsIAGbMmBG12Zp05jl47733ct1W1p9adxUAhBBczHon5syZ43KY74jtQ+v8Yb4OVtes77d93q233upyBg0a5GJpwbxstm9nDgnmwGDuDOuyYOMX83CwMc3WBhvHmcvhsssuc7GhQ4dGbdZ32v0A8L7FekvY3IyNq8uXL3cxew4yHx47B1lfac9Ley4Defe17C6Yj8+OH2x+XKdOHRdjrhi7T1jfyM5r5tay8yc2vrPjxz6jnbuy8Z2dJ+wcYH44C5v7se239c62yzqpAD7G2ePIvE7sWjQt2P625xk7p+rVq+diDRs2dDE7ZjEfGRvfWb9kvWhsbGV+rDPOOMPFrO/vhRdecDnjx493Mea4XbhwYdRm/SDzjjGvnK29AQMGuJzrr7/exdjcwPb3CxYscDn9+vVzMXZvAdA3ZoQQQgghhBBCCCFSQzdmhBBCCCGEEEIIIVJCN2aEEEIIIYQQQgghUkI3ZoQQQgghhBBCCCFSIkf5b4UKFVysSJEiUZuJg5ioiYmIbr/99qjNxFlMmNSzZ08XGzx4cNRmct4HHnjAxZjczQqHe/fu7XKYhIsJvawUiEmImIywfPnyueaxfcPkwkwKd9VVV0Xta6+91uUwaVmaMAmZPX6shooVK+ZiTLhqjx8TkzHWrVvnYvvsE9/zZMediVr3339/F7OvLV68eJ62i0knrVyM1T/bVnZO2+PBxHFWMg0Ay5YtczEr+/34449dDnv/tKhevbqL2XO9WbNmLofVZ4cOHVzs0UcfjdqFChVyOXkVURctWjRqWxkwANx///0uZoWWAFC5cuWobccDANi0aZOLsXPJivlYrTDRLxtzrHSUjV1vvPGGizFZnZU8MjkkE1inhe1rAOCdd96J2kmSuBzW1zBhdc2aNaO2FeUCvH8YO3Zsrnls25l0vUWLFi5mxYlM2LlhwwYXY8fcnjdMbMjGDPZQgyuvvDJqr1q1Kk+vY33DqaeeGrWZ6JdJNtOCjU1WmswEwaw+W7Vq5WJ2XzJ5LpubMRG1zWPiTXaejxs3zsVs/zxhwgSXwx7MwPpYe47kRcIO+FoBgBEjRkRtK0/e0euYUHbevHlRm40/rB9IE/bACHvcWc0yAS2bf9pxjfWp7PxkYlP7/iyH1Tv7jPacY+M0k5mz/tjKW9l7sTGZvZcVTbN6ZCJYNoe34nUmZWXnXFrMnDnTxez+YHJ3e94BXs4LAHPnzo3arH5mz57tYkwkbPsvVnesDtgxsH0Ve+AOk+Xm5VqOiZGZSJ49vMRe53Tt2tXlMCEwk9Lbh8kwCToTFe8IfWNGCCGEEEIIIYQQIiV0Y0YIIYQQQgghhBAiJXRjRgghhBBCCCGEECIldGNGCCGEEEIIIYQQIiUCk64JIYQQQgghhBBCiF2PvjEjhBBCCCGEEEIIkRK6MSOEEEIIIYQQQgiREroxI4QQQgghhBBCCJESujEjhBBCCCGEEEIIkRK6MSOEEEIIIYQQQgiREroxI4QQQgghhBBCCJESujEjhBBCCCGEEEIIkRK6MSOEEEIIIYQQQgiREroxI4QQQgghhBBCCJESujEjhBBCCCGEEEIIkRK6MfMnCCEkIYTyaW+HEIDqUaSHak9kEqpHkSmoFkWmoFoUmYTqkbPH3JgJISwLIWwNIWze7ueZtLfrd0IW3UMIq0IIG0MI40MIldPeLrFryAf1uH8I4YkQwuoQwnchhOdCCPumvV3iz5MPaq9KCOH9EML6EEJCfl8khPBOCOHHEMLyEMLFaWyn2DnsAfV4YwhhZgjh5xBC7xQ2Uewk8nMtZo/ZL2f3iT+EEGaHEJqnta3iz5GfazH7931DCF+HEDaFED4LIXRKYzvFziG/1+N2eceHEH4KIfTdndu3M9ljbsxk0zJJksLb/dyY9gZtxwUArgRwOoAiAKYAeC3VLRK7mkyux64AagKoAqACgJMB3JvqFomdSSbX3jYAAwFctYPfPwvgFwDFAHQE8LxuYud78nM9rgbQHUCv3bZFYleSX2uxIIAVAM4AcCiA+wAMDCGU2V0bJ3Y6+bUWAeBhAGWSJDkEQCsA3UMIp+yujRO7hPxcj7/zLIAZu35zdh172o0ZSgjh8hDCpBDC09nfVlkUQmi03e+LhxCGhhC+DSEsDSFcvd3vCoQQ/hpC+Dz7fylmhRBKbff2jUMIS7K/dfBsCCHsYDPKApiYJMkXSZL8CqAvgBN3yQcWGU2G1GNLAE8lSfJtkiTrADyFrBuHYg8mE2ovSZLFSZK8DGA+2b6DALQDcF+SJJuTJJkIYCiAv+ysfSAyh0yvx+zfD0qSZDCADTvpY4sMJNNrMUmSH5MkuT9JkmVJkvyWJMlwAF8C0MXwHkam12L27+cnSfLz783sn3J/+sOLjCM/1GP237oIwPcAxv75T50ee8WNmWxqA/gCwJEAugEYFEIokv27/gBWAigO4HwAD21XdLcB6ADgHACHIOvidct279sCwKkATgJwIYCmO/j7bwAoH0KoELKWjFwGYOTO+WgiH5J2PYbsn+3bJUMIh/65jyXyAWnXXk5UAPBrkiSfbRf7BIC+MbPnksn1KPYu8k0thhCKIau/3OGFisjXZHwthqwl8FsALALwNYB3/+h7iYwno+sxhHAIgL8DuP2PvD6jSJJkj/gBsAzAZmTdLfv95+rs312OrK8jh+3ypyPrf2FLAfgVwMHb/e5hAL2z/70YQOsd/M0EQP3t2gMBdN1B7n4Ansx+zX+Q9T8dZdPeb/rZa+uxO4BJAI4CcDSAadmvPybtfaefPbv2tsspnzUERbHTAawxsasBjE97v+pn76tH8/vuv/9t/eTPnz2oFvcFMAbAv9Pep/rZ62uxAID6yFoKv2/a+1U/e2c9Iuv6ukv2v+8H0DftffpHfwpiz6JNkiRjdvC7VUn2EctmObLu7hUH8G2SJD+Y39XM/ncpAJ/n8DfXbPfvLQAK7yCvG7LuCpbKfs0lAD4IIVROkmTLDl4j8jeZXI89ABwGYA6AnwG8BKAGgG9yeG+Rf8jk2suJzcj6X5XtOQTADyRX5B/yaz2KPY98XYshhH2Q5Sf8BUAmOSDEf0++rkUASLLUDBNDCJcAuA5Zy+JF/iRf1mMIoTqAxsi6hsn37E1LmUqYtWvHIusO4GoARUIIB5vfrcr+9wrsnHWTJwEYkCTJyiRJ/pMkSW8Ah0Oemb2VVOsxSZKtSZLcmCRJiSRJjkOWP2FW9iAr9mzS7gtz4jMABUMIx28XOwn6uv6eTCbXo9i7yOhazN62l5ElRm+XJMm2Xf03RWpkdC0SCqb0d8XuIZPr8UwAZQB8FUJYA+AOAO1CCB/v4r+7S9ibbswUBXBzCGHfEMIFAE4A8G6SJCsATAbwcAjhgBBCNWRZn1/Pfl1PAA+GrEdwhRBCtRDCEX/g788AcEEIoVgIYZ8Qwl+Q9XXUpX/6k4n8SKr1GEIokS3sCiGEOsh6wkO3nfLJRKaTdu2FEMIByFreiey/tT+QJbgEMAjA30MIB4UQ6gFoDT3Bbk8mY+sxu10w+/cFABTI/v2e9m1jkUVG1yKA57O3qWWSJFv/8KcU+YGMrcUQQtEQwkUhhMIhS+7aFFkekQ/+7IcWGUvG1iOAF5F186d69s8LAEYgn3rl9rTJxbAQwvb/4z86SZK22f+eBuB4AOsBrAVwfpIkvz9loQOyDuRqAN8B6JYkyejs3z0OYH8Ao5AlPVoE4Pf3/G94FFmFPQfAQci6IdMuSZLv/8B7ifxBJtdjOQB9kFWTK5C1rnPUH3gfkZlkcu2VRpZj63e2Iuurr2Wy29cj69HE3yDrm1zXJUmib8zkb/JzPd6L+Kb1JQAeQNY6dpH/yJe1GEIoDaAzspYerwn//z+vOydJ8jpEfiRf1iKy3CDXZW/DPtnxW5IkGfIH/o7IHPJlPWbrQP5PCRJC2AzgpyTribP5jhAvGdszCSFcDqBTkiT1094WIVSPIi1UeyKTUD2KTEG1KDIF1aLIJFSPu5e9aSmTEEIIIYQQQgghREahGzNCCCGEEEIIIYQQKbFXLGUSQgghhBBCCCGEyET0jRkhhBBCCCGEEEKIlNCNGSGEEEIIIYQQQoiUyPFx2RUrVnTrnLZu3Rq1t23b5l43fPhwF7v00ktdbL/99ovazz33nMu59tprXax48eIudscdd0TtihUrupxevXq52AMPPOBit912W9SeO3euy3n88cddbPny5S723nvvRe2xY8e6nMaNG7uY3c8AcOH/Y+89w7Uor/7tNTZUFAFRBAFBekd6U4oiCIgg9th7idGgeWyxxBZLTNTYE8USGyJiUBBRaYIiVRBBELCAIhYsYIXc74e98/651jqB/WgeZkN+53F4JGu59r3nnrnajPs654gjkrhMmTKh5vHHHw+5RYsWhVy9evWSeO+99w41O+ywQ8ideeaZWUhuItq0aRPaY926dZN46623Dj+3YsWKkKMtfP6cjB49OtR07dq1RJ/19ddfJ/G8efNCzR577BFyFStWDLn33nsviTt16hRqxo4dG3LffPNNyPnzReemTp06Iff222+H3IIFC5K4bdu2oYb64UcffRRy/vysXLky1HTr1i3knnnmmVza4+233x4u+qOPpm8sLen1LVu2bMhts006NO+4446hhtrnBRdcEHJ+vPTXzczsrbfeCrmPP/54o59Vvnz5UFOhQoWQu/vuu0PuV7/6VRJ/+eWXoWbGjBkh5+cNM7OGDRsm8Q8//BBq2rRpE3ITJ04MueHDhycx9fnJkyeH3IoVK3Jpi1dccUVoi7NmzUrimjVrhp979913Q47GjEMPPTSJR44cGWo+++yzkDvrrLNCbunSpUlMbYz6Dc1hHupHe+21V8jddtttIXfUUUcl8dy58e3sNC5S+2nVqlUS+75sZrZmzZqQo7nLt8WDDz441Phxx8ysUCjk0hZPOumk0Bb9+mnnnXcOP0d9n9aWHTp0SOLXXnst1Hz//fcb/TkzsyVLliTx7rvvHmq23377jf6cmdmee+6ZxJ988kmoobFy6tSpIef76ueffx5q/DxuZjZz5syQa9asWRJ/8cUXoYauBzFt2rQk7tw5vqDF15jlNy6amZ122mmhPa5atSqJ58+fH36uVq1aIVepUqWQ8/2/Xbt2oeaDDz4IuerVq4ecb0M0tjRq1CjkPvzww5DzfWCrreJ/g6f5kOYEfy6efvrpEn3WwoULQ84fP51TmrtpnqhSpUoS//jjj6HGzzdmZi+88EIu7fF//ud/Qlv0bY/aytq1a0PulFNOCbk77rgjiU8++eRQc+edd4Zc48aNQ86vp6ZPn16i46L7nN69eycxzX0tWrQIOZoTfDum+2kaz1599dWQ8+uM5s2bhxo6N9Q+fR956KGHQs1OO+0UcuPHj8e2qL+YEUIIIYQQQgghhMgJPZgRQgghhBBCCCGEyAk9mBFCCCGEEEIIIYTIiQ06Zsj5UqNGjSQ+++yzQw3tpb3nnntC7h//+EcS0x5fv1/bzOy8884LOe9bIKcN+WT23XffkNtvv/2SmPaWL1++POTod5YrVy6Jn3rqqRL9XMuWLUOOvAaeku5BPeOMM5L4yCOPDDXbbrttyJHzZ1NB7eqNN95IYvr+5DShff/+Z2nPKu1VJC+D39vdvn37UPPMM8+EHHlaVq9encS0x538BNS2fbv17dOM9+XSuR84cGASkweF9qbusssuIef7fpMmTUIN7VnOC/JZXHfddUk8bNiwUENOhL59+4ac9xaRA2bx4sUhR+3T+12OPvroUEN7uPfff/+Qe+SRR5K4Z8+eoYbGDdpL7j0o1PbJyUPtrHXr1kmcZXHrLrmgTj/99JDze5Spv5HvKC/ofPtr984774QacnGQK+DFF19MYvJS0dw9bty4jeZOOOGEUPPPf/4z5Hr16hVy48ePT2Kap//1r3+FnHeJmUU/XJ8+fUIN9eemTZuG3GGHHbbB4zQz23XXXUOOjr927dpJ/Mpibf18AAAgAElEQVQrr4Qa3/bzhJwsfu7z/jUznqPJo+LbD7nI6BhorFy2bFkS05gxZcqUkPPrQ7PoWCLnErUVcjJ4hwE55cgnQ33E+1R22223UEN9l/wOfiwm941vr3nj105mcbwk/4q/zzGL7cUsXlPv5jDj9lgS7wx5kahd0bzm3Vrko6S1Av1O70Ghe7KStiHvJaG1JrmlaM73/jnycpbUn7QpoDX6gAEDkpjuD7t37x5y5Ans169fElNbIecjrc38PY0fR8z4ntF7ksziWoSuObkE6d7Ee2G6dOkSaqgPkrfO90F/T2xm9vrrr4ccjQN+7iDXFDkh14f+YkYIIYQQQgghhBAiJ/RgRgghhBBCCCGEECIn9GBGCCGEEEIIIYQQIic26JihvdiLFi1KYtrHNmrUqJDz+67N4l7a888/P9TQHkFyTfh98N7xYcb7s6+66qqQ8x4V2ntMewHJ3eD3B3/11VehhvZGDh06NOT8nms6p127dg052qvn95KSt+fEE08MuTyhPZotWrRI4k8++STUkGeAPAneeXHggQeGGu8iMOM9yn5vMzlayC3kj8GM97R7aK89tTW/75f8GeQNIQeJPxc0XpBLgdqjdwzQ/mTaj58X1M6++OKLJKbvTuexWrVqIeevC+0NpvNNTpZzzjkn5DzkQCIXxO9+97skJr8SeXR++9vfhty3336bxH/9619DzZo1a0KOzuukSZOSmPwUfn+7mdmYMWNCzvcb8rM0b9485PKC2pR3INH4Q+NilSpVQs77uLy/wIzHUxpHvOOCHFQ03pEn7YgjjkhiWovQfvazzjor5Px4Q/M7nRtyl/i95DQ2U7um8dq7pchXQWNRXtB38C4janc0J1A/9+Mgrc38utLMrGbNmiG39957JzG5gMgVQGtSf13IiUFemN69e4ecHxdffvnlUEPfx/v2zKKrbeLEiaGmY8eOIUf+GD8OUJ8kd1+e0HrNzw00nhH03fyahHwvtG5p3LhxyPnrR841uq+hsdd7Wsi1Q3PCiBEjQs4fB415dG7I6+HXSHTuqU/vtNNOIecdISV18uQFucD8dSIHFPkFqX/6ur///e+hhjylNB5PmDAhiWnMo7UTrSP9/Ee/b+zYsSF30003hdzs2bOT+PHHH9/o7zMzO/jgg0PO90FyLvk5wozXLN5FQ54b6vPrQ38xI4QQQgghhBBCCJETejAjhBBCCCGEEEIIkRN6MCOEEEIIIYQQQgiRE3owI4QQQgghhBBCCJETGzR1kVTQyyVJjEgSx2nTpoXcZZddlsT9+vULNSR9euCBB0LuhhtuSGISDA0YMCDkPv3005AbN25cEr/55puh5umnnw65Cy+8MOQefvjhJPaSU7N47GYsP3300UeTmOScP/74Y8j98Y9/DLnbb789iUkqdv3114ccnfs88UI9EkeStJGEbF4qTRLBChUqhNy2224bcr5dkZhvzz33DLlGjRqFHMn/PEceeWTIeSGqWTwXXhJqxu2KhFpeQEgywKlTp4acF2KbRUnbDjvsEGoOOuigkMsLGjc6d+6cxM8//3yoOe2000KOpLReFPbYY4+FGhJ9Dx48OOT8uHfIIYeEmnvvvTfk6Jp7YTWNLX/4wx9Cjsbx9957L4l79eoVakh8t8suu4ScF3d26dIl1JDYkGTJvu21adNmozV5QtfJS/JIPEj9ycsZzeJ3JblzgwYNQo7GLS+9PeCAA0INXSeSnfo+SG140KBBIbdq1aqQ832Q5lGSZdIY7gXuPXr0CDXz588PuTp16oRcrVq1kphkln7cyRMS3Hq5ecuWLUMNSVOpj3lJMIkYK1WqFHLvvvtuyPl5m84/yZZpvvdrhblz54aa/fffP+SoLVatWjWJaeyk9SFJ5P34Wbt27VBD58a3O7P48gWSz9PYnCckl/VCZBKIkuyUxNb+8+m80fmlF1l4ea2XZpvxuEHXlNauHhrjaC3i52kS1FI/oZe0+L5P54EgWbq/jiTErV69eok+f1NA63E/7tH1JQE5vbTjoosuSuKXXnop1ND9xXPPPRdyfo1IknIa4+6+++6QO/fcc5OYXhhB95XDhg0LOS+epvXDPvvsE3IzZswIOX/vQ+eeXuxC6+dly5YlMbV9Wt+uD/3FjBBCCCGEEEIIIURO6MGMEEIIIYQQQgghRE7owYwQQgghhBBCCCFETujBjBBCCCGEEEIIIURObFD+e8stt4ScFwb++c9/DjUkoyMRkRcKNW3aNNSMGTMm5K688sqQW758eRKT/HHs2LEhR4Lj999/P4lvvvnmUEM5LwAyMzv22GOT+Pzzzw81f/rTn0LOi5HNzG699dYkvuSSS0LN2WefHXIjR44MOS+Fu/TSS0MNCZPyhMRyXoxHgjYvwjRjSZuX7u2xxx6hhmRQJHT28umlS5eGGpLsUh9o0aJFEpOMlNoxSbC8iI76CUnKvJjOLIq4SABKIsYpU6aEHMmnPVmWbbRmU0FCNi8RpO/0008/hRwJ97zst2HDhqGGhOokKPVCzv79+4eavffeO+RIbOqlghdffHGoIQE3jY1eHkkCUIIkf15+TcJFuh50XH4cePLJJ0MNSSUvuOCCeLCbgAMPPDDk7rnnniSm704i2cqVK4ecn58OO+ywUEOyfZIEe2EjjRlenmtmdvDBB4ecF8GSIJIExyTuXrFiRRKfc845oYZeAkBiVi/jpPNM1+PZZ58NOT8HffDBB6GGvnde0Pn26y6SP65evTrkaM70c3nbtm1DDbVFf33NosS0Ro0aoYbWE9Rmd9111ySmcZgE/TQ/Tp48OYlJNjlnzpyQK1OmTMhtt912SbzNNnHJX7du3ZCjtu5ltCQKJ2luntALCfxx0zWgtS9dPy+d9+ObmdkTTzwRctRG/XqQxkHK0UsA/LWi8YbWYa+++mrI+T5NbZv6zoIFC0LOj2f0EhWCxNm+/9L3obVVXgwdOjTk/JqH1jZHHHFEyNFLSIYMGZLEu+++e6gZNWpUyF1++eUh5++BSyqd79u3b8j5+yN6YRAJrGlt6a8x9V1/X2LGc0n79u2TmF6i8NBDD4XcbbfdFnJ+/qJ7FRpT14f+YkYIIYQQQgghhBAiJ/RgRgghhBBCCCGEECIn9GBGCCGEEEIIIYQQIif0YEYIIYQQQgghhBAiJzYo/23VqlXInXXWWUlMgqEqVaqEHAn3vKCK5GV33XVXyN1xxx0hd+qppybxTTfdFGoOP/zwkCORjxf+PProo6Fm6623DjkSn3lJ2/bbbx9qSDJ7ww03hNxzzz2XxF4GbBaFRmZm3333Xchdf/31SUyCXC82y5v33nsv5Lp165bES5YsCTVegGcWxZFmUWpGUl9qo15iahZlUCTiJQEcyQy93JHkqiTUIsmiFxdWrFgx1JCElc6rP/6XX3451JAMkvqAl8rSuDJhwoSQywsSdfr2SXLEli1bhpwXrZmZLVy4MIlJ+OzbvhlL/rzMedtttw01JBCk4/Lt00svzcy+/fbbkCM5tb/GJL4jKTEJq6dPn57E1Hfpe++4444h9/rrrycxCV5pjsuLN954I+S8TO+pp54KNSTUJWmdlyzSOaNzdPfdd4ecl0vSOPzb3/52oz9nZtaoUaMk/v3vfx9qqN2R2NPLJefPnx9qSHBJguwXXnghiUk86M+pmVmPHj1CburUqUlMEvDSJEUnSaSfH+klDDQ/0hrryy+/TGKaQ+nnzj333JDzfYLmcWqftA7xIszmzZuHGuojdC68aN+3ATN+eQGJYb1sfu7cuRutMTNr3bp1yPk5r2bNmqHGr+nzhtY3b7/9dhJXr1491NDLDkic2qdPnyT24mYzs06dOoUcrbdLIk5u3LhxiX7Oj1U77LBDqKE25L+PWZSW0jWm+zR/T2ZmNm/evCQmsfWNN95YomP161QaG+neKi9oreTX8n7tYRbHPDN+QYdvZySKHzx4cMiRpN+3M7ovoXU8zbf+OULHjh1DDUH3rf5FB7RGpTGb+oivo+9YtmzZkKMXS/gxhaB12vrQX8wIIYQQQgghhBBC5IQezAghhBBCCCGEEELkhB7MCCGEEEIIIYQQQuTEBh0zixcvDrlnnnkmicm1cPTRR4cc7QXzjhRyYtAexAsuuCDkvFtl+fLloYb23N1///0h5/dj0j6zlStXhtxWW8XnXH6Po/fXmLFbgRwGfj8y7ecjzwft2R8+fHgSP/DAA6HG7y01473Hmwo6T37fL+0vpL2n5KDwe6bJi0RtyO97NItOkAoVKoSafffdt0TH5V0K9B3btWsXcrSv0u/JHzNmTKghrwf1Te9XqFOnTqhZsGBByNG+b7+Pljw3dA7zgsZGv0eV9gF/+OGHIUd73L3/w3uGzHj/9OWXXx5yV1xxRRLTOFW1atWQI++DdxlRGyPfER2r9zX9+OOPoYb2GZP/w+9j9i4ls+j+WN9neY+ad3uZ8fifF+S88OMP7W+fOXNmyNG8Wa1atSSm6+RrzHg/u/ci0bhC4wPNYd4VQ8dF++DJw+Y9ZOQuIRcH7Tf3fcn7fszYxUJ7/Y8//vgkpvHjk08+Cbm8oOPzfogmTZqEGvKokL/HOxloriLnDvVh77iin6NjoHnOtxdqw7SOJHeY/3w6pytWrAg5On7vg6JxkRwWU6ZMCbm+ffsm8VdffRVqSht0/fzaglyK5CmiMcGPQTS30nmi+da3D1q3kh+LHDZ+fbLLLruEmr322ivkaP3pvUQDBw4MNd6JZ8ZuLX8c3g1nxq4tWiN5ZxxdH5pf8qJnz54h5++nvevMjMcNcpT5cYN8UuSaq1u3bsh5F+Irr7wSag444ICQa9GiRch55yD5jsjdSXV+jCNvF7lcqH16HxTd29L99CmnnBJyfr1O987Tpk0LufWhv5gRQgghhBBCCCGEyAk9mBFCCCGEEEIIIYTICT2YEUIIIYQQQgghhMgJPZgRQgghhBBCCCGEyIkNyn9JbDd79uwkbtq0aai56qqrQq558+Yh50VEixYtCjV33HFHiT7Ly8r69+8faki45YW6ZlGkSnI9knyRpM0LtkhqWqlSpZAjkeH111+fxOPGjQs1r776asiRsNZ/VuPGjUPNZZddFnIkPtpU1KtXL+S8AJnEfD/88EPIkbzTtw8vhDQzO+6440KO5Fn+OpOgk9oCybP88ZP4iz6L5MVevkaSQpK2bbNNHCq8iItk1CRfozHDy8FJ/EUC3LwgKfmIESOS+Iwzzgg1NG4MGTIk5CpXrpzENEYsWbIk5Ej+6yVwffr0CTVepGdm9tZbb4Wc71+vv/56qKH2SZJdL3zzkjgzs/r164ccya+9aNZLZs1YVE/X0c97XoRnFsVxeUJjhpfdkWSUxgeSLH7xxRdJTP2czjfJzf1neQGrGbcDaote/EriSpJTkyTVi7rp3FAfrFGjRsj5eZNkt9QWu3TpEnJe8koyUxJo5gX1zXnz5iUxSUdpDqV1y9q1a5OYhIo0RxN+PqH5nsS4JDL3awdaM5K8nqTcXl5JcwbN2ySL9WJbeqkEnUNqZ8uWLUtiP0eZsWQzT2gd7deRNB74dmbG49mECRM2+NlmfF/TsWPHkPPjxOrVq0NN165dQ45kp7490nhG/ZDWkZdcckkS09x37rnnhhwJvf0LPLwY3IxfHjB69OiQ82MvfVZpWjPSusi/MILWOzRXUDvw65aTTz451JDo2r9cxCzeR1K7pnma8OMqjWd0j0b3HP4em4TPNDaWZD6nz6J5yT8DMTO79957k/gPf/hDqKGXaawP/cWMEEIIIYQQQgghRE7owYwQQgghhBBCCCFETujBjBBCCCGEEEIIIURO6MGMEEIIIYQQQgghRE5sUP5LUqyjjjoqiUlA2alTp5AjQaGXN5HQaNWqVSH3pz/9KeR22mmnJC5fvnyoIaGXly8R9Flly5YNOZIOeanm9ttvv9HfZ2Y2a9askPPS1M6dO4ean376KeTo3P/lL39J4latWoUaEjrmCUmqZsyYkcQk5vOSUTOWHc+cOTOJGzRoEGp23HHHkCOxqReR0bUi2RThJW0kyiLxNIkpv/766yQmuZWXxZqxuHD58uVJTP2EBOILFiwIOS8Xe/PNN0MNiRLzwot+zeIYRBLliRMnhtzixYtDzovbvDTPjOV9JDvs0aNHElO7I2k4XfPnnnsuiV944YVQQ7JTGl98eyE5Xkllyeeff34S0/XxgjYzlsr+/ve/T+Ibbrgh1NB1zAuSLHrhJIlNvczTzOz7778PucMOOyyJ6TqRENjLec3MateuncQk0qPxjdqPF6q/9NJLoYbmPsr5uZvk8DSWDRs2LOQOOuigJKbx7swzzww5Gt9uuummJO7bt2+oKU3CVZK9e+EzjVEllTR7+XizZs1CDa1JiYEDBybx888/H2roRRPUb3xbpGtJUlOS7Pr5gITK1Edo3vZ9kPobSW1J7Oklzn6+M2NhZ57QOt2vgT777LNQU9J1Xs2aNZN4zpw5Jfosms/vvPPOJL744otDDUmlaZ3qxcH+hSZm3EYp568pvZiB2gJ9lr8fovNFYwG91MNDEvTStGYkmbmfS+k7+DnTzOzFF18MOS9u9mJqMx576Xf+7ne/S+JRo0aFmvPOOy/kSnIf8tVXX4Uaukf77rvvQs63PbrfpZcAUJ2XxJME3Y8VZiV7qcorr7wSako6L5npL2aEEEIIIYQQQgghckMPZoQQQgghhBBCCCFyQg9mhBBCCCGEEEIIIXJCD2aEEEIIIYQQQgghcmKDpi6S7F522WVJ7CWVZmann356yJ166qkh52VXXl5kZnbJJZeE3GOPPRZyXnC59dZbhxqSyZEI0wt6SbhFoiCScXr5FEkY6XuT0Mt/J5LCkWiM5GZeVkeCwnPOOSfk8uSZZ54JuY4dOyYxXZdDDjkk5EjM2r59+yQmWR8JUatWrRpylSpVSmKS/NG1IkmVlxKSBJkkpiS79sJVkoFVr1495KgPrFmzJolJjkmiUOpzr7/+ehKThJT6dF5Q//QysaFDh4aaI488MuRIBHj55Zcn8YknnhhqSLRZv379kPNt6oknngg1vh+ZxTHCLIrbSDBNwt5JkyaFnJ8TqE+OGzcu5I4//viQ8+JL6g/Uhukc+r7qxdRm3HfzgqTz/tx6abMZt6mHH3445IYPH57E++yzT6gheR/JMnv37p3EXgxrxvJHkoF7QamX7ppFQbmZ2dtvvx1yvXr1SmKSGdP6gQTHfkz1IngzFkGSvNXP8fvtt1+oIXF3XpA0tk+fPklMYsSWLVuG3GuvvRZyb7zxRhJ/+eWXocYLRs34pQv+BQv0QgBam5G80q/raP4qaR/x8nQSfZLU1ItozaJcleZjP4+bsRDUzyMk1n355ZdDLk+oH/trQ22PBJ80h5177rlJTOtDmkfpWvm1Gc3TV111VciRQNfPa2PHjg01vl+acfvw4yWNQffcc0/IkZjbXw8SCVPfoXWqr6OXT9BLN/KCRLK+v9Dxeum2Gc+RXpBP8wndf9Ic7EW1J5xwQqi5//77Q65169Yh58dLejkEze9U59sB3dvSmpRk/r5d0wsjqH3SC2a8jJ3uzUsisP43+osZIYQQQgghhBBCiJzQgxkhhBBCCCGEEEKInNCDGSGEEEIIIYQQQoic2KBjhrwDfp8UuTNoL93hhx8ecn5/9oABA0LNRRddFHLnn39+yPk9m7RPkfY2N2/ePOT8vt+FCxeGmipVqoQc7dX1+3DpuLbZJl4Gchh4ZwjtU69bt27I0R5Uv6f+oYceCjXeuZI3/fr1CznvkqA9/+SuoFyLFi2S2HtPzPj6UR9YtmxZyHnIB0KuH79fmNwxdAy0f937Y2i//E477RRy1LaHDBmSxNT2vvvuu5Cjvdp+zyx5dOgY8uLDDz8MuWuuuSaJyeFB54O8Qtddd10S095gcm0de+yxIefHiZ49e4aaM888M+S6dOkScn4POvkz6Fhpv7OfJ+g8XHjhhSHn251ZbC/kk6lWrVrITZgwIeS8+4z2Ul9wwQUhlxc03/pz1L1791CzatWqkKP92f4ak9eD5ph999035Px+efJzkd+Cxil/zem4aG85zd1+vznt6+/UqVPIef+XWfSZ3HrrraHGz79m7Gfx7Yz6PI27eUHj2+zZs5OYnEjeaWDGrjPfZskBQznyIvl1HTkNmjZtGnLec2MW3SIl9VmRa8T3Z3IakKeN5qTatWsn8VNPPRVqaL6nseGAAw5IYnLwlSanhxl76fy16dChQ6ghLwzdD/l1JPniqL2T18Ov4WiMuPnmm0OO3Fd+zD744INDDUFt2x8HrSu949OMz+Hq1auTmHx05OqkPuDX2JUrVw415Ge69NJLQ25TQOtX72QhFxa5nKhd+/vbNm3ahJrHH3885K6++uqQ8/c548ePDzXkS6QxyI9xNCeTj8h7W8zi2E73WXSs5CjyfZDcZP6ecH34MYWuI7mZ1of+YkYIIYQQQgghhBAiJ/RgRgghhBBCCCGEECIn9GBGCCGEEEIIIYQQIif0YEYIIYQQQgghhBAiJzYo/23Xrl3IefnOZ599VqKfI5meh+Q7JBUkiaOXSpEQq1u3biHnxXRmUXBMcr2JEyeGHIlnvUSJRE70vUlW5GV19FkkVrr99ttDzkvgSFa36667hlyeTJ48OeS8MJEEipUqVQo5f43NzMaMGZPEJAxs0KBByJGAyotTSQZFAmK67h4StNFxkdjaSzRJMv3xxx+H3KJFi0LOy5hHjRoVanbZZZeQ23///UPOi5ZJCjdu3LiQy4sZM2aE3MUXX5zEJP2kPtu7d++Qu/vuu5P4yiuvDDUHHnhgyJFg0suiSRZ72WWXhdyUKVNC7ogjjkjiRx55JNSccsopIUdCPz8nkPia+gNJZb089LTTTgs1JH8nUag/juOPPz7UkETv7LPPDrlNAckYveD5hhtuCDV0Hkm6PXLkyCQm6V+5cuVCjiS7/nouX7481LRq1SrkqM5/Rxq3fvWrX4UcCQqnTZuWxCSbfOKJJ0KOBJ1ezEovK6B1B43hfs6nMX3q1Kkhlxc0tjRu3DiJSbjt5e9mZuXLl99oHf3cihUrQq5hw4Yh50WtdOw0ntILAHbfffckJhE1yWPpxRJ+TU0iXnphhBf9mkWBJsks/QsU1lfn1x1eXGrG1zZP6AUZ/rvR+o3GLjrn/lrRixloDURjyXnnnZfEtOaidSv1E78OJrE+zbe07rrllluSmITtJekTZmbDhw9PYnp5AImtSTTt19T+s83MWrZsGXJ5QTJbf3zUVmiMoLXfXXfdlcQkiqdrRyJhP+6RuJjaCo0J/h6DPovWYWXKlAk5385ofCaRMN0z+etBfYvmaRov/Es36LOefvrpkDvrrLNCzkx/MSOEEEIIIYQQQgiRG3owI4QQQgghhBBCCJETejAjhBBCCCGEEEIIkRN6MCOEEEIIIYQQQgiRExuU/5LM0MtqSPo3adKkkCOB0bPPPpvEM2fODDVNmjQJOZIV+RzJhEggRTKk6667LuQ8J510UsiR+GzgwIFJTGIrEtbS8Q8ePHijx+WFdmYshfMi3XPPPTfUkEA5T0jO17Vr1yQmQTBJt0hA5QXSJFUjSEC13XbbJTEJiOlakYS5c+fOSUztn9oL1XnRHwmeSVRMcjd/fkgkvNNOO4Uc9QHfz0kWTp+VF506dQo5fz1LKqC9//77Q84LZ0neRzLCPffcM+S8VPS5554LNTVr1gw5kjSPGDEiiUmQTTLJ8ePHh9x+++2XxCRqJIEgzRN9+/ZN4qFDh4aaL774IuRIZPvoo48mMY2fJHnMi6ZNm4acF8pTe/XCZDOzTz/9NOR8m6pcuXKoee+990KO+rmfb2lMr1ChQsj5MdAsisy9ZNaMpcH0wgIv+6X2Q0Jgkl/7Y6WxjM4X9UG/pqA+T2uw0oQXPtP3pPGN5jQv9iW5J33W4sWLQ87Lr+makAR2hx12CDkPSbRJ4ksvlvCfP3r06FDz7rvvhhytffz4TO2HcjS++X5JMsv69euHXJ4cd9xxIefvYS655JJQQy/kIJnqmWeemcQkoKU1Vvfu3UPOz5F+fjQzmz59esidfPLJIefHRmp7fu1sZjZ27NiQ8+tBWu/S+pZk7F6SSm2b5mlq734cOfjgg0NNaZqnSTpPc5aH2o8XMpvFMYdekuNfcGLG98V+rd2mTZtQQ2Mj4e9vK1asGGroJQ80Lvl7DHrhjn+RiBnf5/uXGtB9D81B9Dv9vRD1EZqX1of+YkYIIYQQQgghhBAiJ/RgRgghhBBCCCGEECIn9GBGCCGEEEIIIYQQIif0YEYIIYQQQgghhBAiJzYo/yV5kxdJXnHFFaHmrrvuCjmSMHnZ1VNPPRVqSEBMslwv6/ruu+9CjT92M7Nly5aFnP9OJKMi0akXUJpFkRsJWUm41b59+5C7/PLLk/jee+8NNSTLJNmeF0WRJI3kbnkyYMCAkPNtqFWrVqGGxNMlkeCRkIquO4mlvGxw5cqVoYb6FwkmP/rooyQm4Spd4y+//DLkGjZsmMQk1J0zZ07IkZjVizup7S1dujTkqB968SLJ90iClhf0Hfw1JwEkSUxr1KgRcm+//XYSk4TMi/TMzN5///2Q81LiLl26hBoSopIM04+rJGcnyV23bt1Czs8JHTp0CDU0Xvbs2TPkpk6dmsTNmzcPNffdd1/I0bn30uMXX3wx1NBYnxfUL/yYR/MJyZ3HjRsXcl6gS5JRGnepTXkJ5YknnhhqSB5N8kovLybxNQmIqV96QS/JLGfPnh1y7dq1Czkvmy+peJnWNf47UX/wovk8IWG+Xz+1aNEi1JAInwSKXmrq50Yzs2bNmoUcSab9+HbQQQeFGhpPaY72dXRNKFe2bNmQ86JTkkbSvNq6deuNHtduu+0WakoyzpvFsdLLk824z+eJn0fN4lg4d+7cUENi06OPPjrkvOyX1oK0dqL1gxdb08mRYv0AACAASURBVIsCaP1AL4zwc8Iuu+wSakiyTuO4l4v7uXZ9x0BrZf/CFxKuUhulfuJFyHSPSWv4vKDz/Y9//COJSWBM480NN9wQci+99FIS00t4SChN582PJW3btg01NF/Rd6RrV5IaevmMfzkB9W9aP9BxVa9ePYn9vZGZ2UMPPRRytLb06/Obb7451JDwe33oL2aEEEIIIYQQQgghckIPZoQQQgghhBBCCCFyQg9mhBBCCCGEEEIIIXJig46Zhx9+OOTuvPPOJD7jjDNCjXehmJn9+c9/DrnHH388iS+88MJQQw4M2pfoXS60H5z2Hm+1VXw2dd111yXxxRdfHGpor3dJ9tKRV4SOgZg1a1YSH3744aGmcuXKITdlypSQ8/udL7300lDj3QJm7GTYVPj9hWZxjzntpV2zZk2JcrVq1droMdD+xZYtW4ac963QfkxyQ/j9vGZxLyTVkEuBPr927dpJPHr06FBD54bcAd5hs2jRolBDfWL+/PkbraP9pTQW5IV3HZjF8YXGCNp7SnvXvYeBnCbUDui4/P7ae+65J9Q0btw45KjN+j5I/oM6deqEHO03HzNmTBKTe6JevXoh9+STT4ac96WQU4Kg4/djSpkyZUINfZ+8IAea9/WQ52Do0KEhR94I70OhOYA8FQsWLAi5pk2bJvEdd9wRasjHRX4xv9ebrgnNreTP8L4C2utPDiRy1Hm8O8KM+zP1N+8XGDZsWKg5/vjjN3oMmwryqPh5iNoFrYuqVasWct41RPO9d7SY8fzYq1evJKY2TH4p8mX5sYvaXcWKFUOO3GH+HJJTjuZjOlY/39N5oD5Pjjc/zpDfgfwLeUJ9iq6fhxxQ1Eb9uoXOL/kM6fO964O8GDQukX/Le1rImfX999+HHK35/Xekddjzzz8fcjQW+DU2jY0EzcF9+vRJYvJB0RosLw455JCQ8+d2xIgRocbPTWZ8bn2fpT5M54NclDvvvHMSk++obt26IUfXybdjOi6C1jXeRUbPAmiepnbtXZrkKyOHIo3ZfmynZw00NqwP/cWMEEIIIYQQQgghRE7owYwQQgghhBBCCCFETujBjBBCCCGEEEIIIURO6MGMEEIIIYQQQgghRE5sUP47ePDgkOvdu3cSX3PNNaHmH//4R8h5sZWZ2Y033pjEJB0tqcDISxxJZvnOO++E3N577x1ygwYNSmKSnFWpUiXkSETkhXL0+0jyRaIgL3IjGZkXF5uxPO64445L4n79+oWarl27hlzbtm1DblMxbty4kDvwwAOTePz48aGGBE4//vhjyPnrN3fu3FBz6KGHhhyJRr0gimS27du3D7nVq1eHnBcJk7D0k08+CTlqQ76PecmXGUu3SB7nxZc1a9YMNSTaXLhwYcj5a0THTiK/vKBr7vvjhx9+GGro2pEo8ocffkhiEjseccQRJTouL9zbb7/9Qs20adNCrlWrViG31157JfGoUaNCjRe8mrHQtXXr1kn85ptvhhqSR++5554h50V0559/fqih70Nt/ZtvvkliEjXmKUH3UPvxIjuS1JLEkeR9DRs2TOIJEyaEGpoPSczqzy1JTEkgWrVq1ZDz4zXJH0nUR2N/p06dkphefECSdxLZ+jnp2WefDTXt2rULOZJx+nHQyw/Xdwx5QfOcF5IvXrw41ND6kMYM36bmzZsXakhK6V8OYWb2xhtvJDG1C5Js0gsW/PHTeaCxjNZwfg1AUn06hzSXeyklyUUbNGiw0WMwi3JtkoZSf8sTug7PPPNMEpN834tBzaJg3iyu3akv0nUhGemJJ56YxLT+pJdP0D2SFw7TfEXjDbUFfxxLly4NNX7MM+P7LT+XUl+lc091fvz3axMzlt7nBZ2PsWPHJjF9B+r/JE327YzGFhov6dr5ey1qKzSW0DMDP4f5ta0Zjxs0n/t1Kr1ogl4uQp/lRdok1qd7DnohhZ87aKyQ/FcIIYQQQgghhBBiM0APZoQQQgghhBBCCCFyQg9mhBBCCCGEEEIIIXJCD2aEEEIIIYQQQgghcmKD8t+SiKwee+yxUHPLLbeEHAkKb7rppiQmOdqll14aciSF8z/72WefhZr69euHHEnOvCDVyzPNzPbYY4+N/pxZlDlRDR3rbrvtFnJeHEoSzOuvv75Ex/X0008ncefOnUPNb37zm5A76qijQm5T4SW4ZmaffvppEpOYiaRbJJD2wjQSSM+cOTPkvMTUzGzVqlVJTMLA0aNHh5wXPJvxd/KQ9JXEVV4eSeeB+iGJPL3I+pVXXgk19H38NTOLslJqs9Te84JkdF4ASWJckkeTwMy3RRKHeZGqGY8bXtZKAtE+ffqE3K233hpy3bt3T2L6PpMnTw656tWrh9ykSZOSmMZnGhtJlu5liscff3yoGTJkSMhR+/R9/N577w01JMA99thjQ25TQGLuatWqJTGJlUlKSZ/l5ZLlypULNSWVnfrrSSJwEgKT+N0LdP13NjN77bXXQo5EhrNnz05i387NWEBM59ALz/v37x9qpk6dGnLU/r30+6STTgo11Lfygs6Hl3R6GbAZSy/ppQW+TdH6jeaXRo0ahZyXs5MInATZJG718kpaq5Asl6Tr/vPp2KmfTp8+PeT8uac1DY0NtKbxfemQQw4JNbSeyBMal3x/JLE+rTVo3PAvXaAXhXTr1i3kqA359kji2mOOOSbkRo4cGXL+noVeDkFCVBp7/XhGa02SUdOLTvx3pM+i8WzGjBkh5/u+H8PNeN2aFzSneJEynX+aP6gt+jbVs2fPUEPniGTO/kUe9CIYuqcnia9fy9Nalj6LhPD+etJn0RqYXsTh76tonKW1Mr1gxovRaS4h8fIFF1wQcmb6ixkhhBBCCCGEEEKI3NCDGSGEEEIIIYQQQoic0IMZIYQQQgghhBBCiJzQgxkhhBBCCCGEEEKInNig/NcLgMzMHnzwwSQmqRSJFx9++OGQO++885KYpDokOSKh1w8//JDEJPQ68sgjQ44kPV6yS6JPOi4vWjOLUqO33nor1JD0j8RHXkRHYiuSCpI4q0GDBklM56FixYohlyckz/Pypx9//DHUkNSJhMBe4ETiJ+oT1Adq1KixwXh9n++PwYylUR4vwjQzmzJlSsh5cScJ2ubOnRty1B69vJWEeSSYa9myZcj5tkZCQhKE5QWdDy8H3XXXXUMNCUpJGLho0aIkPv/880MNXd9WrVqFnBf0kqTZ/z4zs8MOOyzk7rrrriQmMR2Ng3feeWfIeXG8l8yasSCbBHN+DCXZG/VdGge8fNDPeWYsncsLEoH6sbJHjx4l+jmSMb700ktJ3Ldv31BD55vmJ/+zXvptxv2Gxn4/r9E8RzJa/33MYjum8ZrWMCQa9KJ3OjfUfrzw2yy2az/mmpk1a9Ys5PKCzrdfK3Xo0CHUUFtZsmRJyPn+OmDAgFBDbZjEzW3btk1iGgNJoElCcp+jOZuk2STL9W2qSpUqoea5554LOS9pNYvfm9YctJYlKbd/4QWtZanv5ol/CYNZnIOpbdDLGuj7eml1+/btQ82cOXNCjs75888/n8TUtq+55pqQO/300zd6XDTWlylTJuRIau/PD4031HdobPQ5eukArWuuvfbakLvkkkuS+PDDDw81s2bNCrm8+Nvf/hZynTp1SmJaJ9FcRPOhv7+l9TLNMXQNvEiY7ktoPUUydt/O6P6dxiU6Vv9ZVEPCdlpb+s+ieYNeikP32B9//HES0z0Ona/1UXrudIQQQgghhBBCCCH+y9CDGSGEEEIIIYQQQoic0IMZIYQQQgghhBBCiJzYoGOG9qh5L0DHjh3jh8K+rw8++CDkmjdvnsTdu3cPNc8880zIde3aNeT83uPjjjsu1Ph9YGZma9asCblatWolMe0ppr20tHduxYoVSezdLmbsTFi6dGnIjRo1KolpnzHtgydfx4IFC5KY3BRDhw4NuTyh6+f3AtPey08//TTkaM+h9+zQnsM2bdqEHDkE/OfPnz8/1FAb8q4ks+g8or275GrYfffdQ863ZfLj0PcuW7ZsyJUvXz6JyZtAe05pz7z3rPjvbGa2cuXKkMsL2p+93XbbJTFdy/vuuy/kGjduHHKnnHJKEpOHxo9TZmbffvttyPlrTvvNa9euHXLUpvx39POBGc8Jp512Wsh5HxTtB2/SpEnIkZfB79mn9kNuCxr//ThAvrITTjgh5PKC2pnvr7QvevHixSFHvgW/X5ocQjQ+0DrAHyu1FVorVKhQIeT82sB7Fcy4n1Kb8vu/qe3THnHqg35u9X3GjJ1g5PVYtmxZEtM1o/3/eUGONz/HlGSdZMbeAe/7o99H55vagb/G3jljxms/Glv8POd9LFRjxm4/v6Z59913Qw05o0aMGBFyfl3ctGnTUEPnho7L90s6D/RzeULju/fZ0dhFXhg6TzvssEMSz549O9TQOS/JPcW0adNCDfk7ab3mx3v6fbSOpGvqx7hbbrkl1JDfi+4p/BhN6086Bu+2MzPbd999k3jmzJmhhlwfeUHrXn+/Qmt2mm+pTfn1U0ndqHT/4n2RNM+Rv4k8Wv560n3Ce++9F3JfffVVyPlnEvQdybXlPYtmZs8++2wSk8uHfJs0pngXmfdFmZn96le/Crn1ob+YEUIIIYQQQgghhMgJPZgRQgghhBBCCCGEyAk9mBFCCCGEEEIIIYTICT2YEUIIIYQQQgghhMiJDcp/SVTppViTJk0KNcccc0zIkXzKC1K9NM/MrFevXiFHgqG1a9cmMQmxSMhGElgvSCIhIknOSIbkBVv+OM1YnEXC2j59+iQxCZPmzZsXciRF/Mtf/pLEZ555Zqi56KKLQi5Pudt+++0Xcr49kqSKpHskfPNSqp133jnUkCjLy+TMYlsjKTEJgb1Eyszsm2++SWISHnoJnRm3NS9GJNEmSe5effXVkJsyZUoSH3300SU6LhoL/PkhSXZpklzS97r33nuTmARt77//fsj5fm0WBbcjR44MNSQxpc/yfZb6yP333x9y/fv3D7nTTz89iUk2TuJy6iNeBNu6detQQ22Y5gnfZnfaaadQQ2MqyQd93YUXXhhqaBzIi2rVqoWclzIPGDAg1CxatCjk+vbtG3JePkpzPolxSSjtBd4k6iNRMY2LderUSeIlS5aEGrrmNK77n/UvJjAza9++fci98sorIefFiV7ga8btmsSPfnw+66yzQg3NI3lRknmVxpUHHngg5PbZZ5+Q82sZeiEArfNobebnIRpPaX6ksd+v8+i4SOLZqFGjkPPCyU6dOoWa5cuXhxwdvxdvvvbaa6GGZJzUb7w0nuY36oN5Qt/Njy8k7KUx1a/DzOK9AknKX3/99ZDzgmezOHeTzJak5NQevUiYxmdqC9RGn3766SSml5XQfEvna5dddkliup+gFxj4sd4sXjcaUydOnBhyeUFjiW+fJJYlSTONs14ITn2R5lEag/x9Ar1wgdowtUW6X/HQWDJ27NiQ82McCYJprKe24dssXZ8uXbqEHEnWH3zwwSSm9lqS8/Bv9BczQgghhBBCCCGEEDmhBzNCCCGEEEIIIYQQOaEHM0IIIYQQQgghhBA5oQczQgghhBBCCCGEEDmxQfnvhAkTQs6LiEgkSbIrknB56RAJIt98882Q6969e8h54R4JX0keSrIlL6gqibjYzCzLspDzckOSENH3JrHSqaeemsQtW7YMNTfffHPIkVjJC5pJTkvHkCckT/IiRy8UNYttw4yvn79W9erVCzUkNPOiLLMoNfMSPjOzfv36hRy1Dy+f3nvvvUMNtVGSSXq521tvvRVqFi9eHHIk//KyVvoskqR6YR59Pp0vkpXmxd/+9reQ89eFjveAAw4IuWuvvTbkbrzxxiRu06ZNqCHJLrVZ366p7Tdr1izkSIzrhXLUhr140IwFc15gR+MntUUSIPrxi+St99xzT8iRjPk3v/lNEpOYlMaZvCABc/ny5ZP4iSeeCDVt27YNud///vcbzVWpUiXUkGyfBHi+jmSZJKok0b2/BoceemiooXUH9RE//pCUkiShJKr0Mv/DDz881HhRuJnZyy+/HHJ33XVXEg8bNizUlCYR9UsvvRRyfiyn/kTryDFjxoTceeedl8S0fqP5mCSRnTt3TuK6deuGGppXCb82IfE1tXXCj88kgSWB9YoVK0LOCy1JsD5u3LiQ82tgs9ifvaTYrPStGamv+7nihBNOCDUkAvXicrM4F9HYSPcwJMB+8sknk/jzzz8PNV27dg05mjdnzZq10eOisWv06NEh5/sFvXyFxuzq1auHnB//SyqLJsm6vxclSS6J5POChOC+H3fo0CHU0HWie8ZRo0YlcatWrUp0XCRz9mMoyZ1pHUnXs379+klMa3sax2lN6sdZOgZat1KdXz+T8Ny/XMaM27Uf7+kYXnzxxZAbNGhQyJnpL2aEEEIIIYQQQgghckMPZoQQQgghhBBCCCFyQg9mhBBCCCGEEEIIIXJCD2aEEEIIIYQQQgghcmKD8l+S1vXp0yeJ77vvvlBDYiuS8XohFcl5SXBJ8iAvSKLPop8jKZAXBpK0jQSmJIT0n0+CIcqRtMqLMOn33X777SF3yimnhJyXaa1atSrUPPTQQyGXJw0aNAi5t99+O4npupA0eKut4jNJL/YlGSB9PtV54TDJlUmoWxJIaEnCVZIB+jZEYrFq1aqF3COPPBJyXipNfWnZsmUhR9LqefPmhZyHhJx5cf3114eclyGSfPnRRx8Nudtuuy3k/JhAbYykf3TNvbiNRG477LBDyFWqVCnkttkmnTLmz58fapo0aRJy1AfffffdJCZZHfVTEs16gSWJ9qh99ujRI+T82Ej9jcS2eXHaaaeF3IIFC5K4YcOGoYbGdy9XNYsiTBKPUo5eHnDwwQcnMcnOSeJIAnffzmh86NSpU8i9+uqrIefbMYmE6biov/njeOONN0INyRtpTBk7dmwS+z5jxvNiXuyzzz4h50WSdLyTJk0KOS/nNYsyXurTXpZvxmOxHwdJ7rzXXnuFXOPGjUPOrwtovUvyWJr3/LrOy9vNeD1BbcP3Ly+mNuOxuUWLFiHn11q0NvfS8byh7+v7Oq3pqL3QdaBxybPHHnuEHEnn/fqTBPZ+/jXj6+CF4CTsJcHxSSedFHL+ZS40l9B8u3z58pDza0uSa9P6k/qhX7vScdH3zgsSavv5o1u3bqGG1h/0AgT/syRBr1GjRsjRfYiXeNO9M81h9GIS/7O0/qQ1HY2Nvv3TuaEXRjzzzDMh59c6w4cPDzX0fWi89ONsScf69aG/mBFCCCGEEEIIIYTICT2YEUIIIYQQQgghhMgJPZgRQgghhBBCCCGEyIkNOmb233//kLvnnnuSmPZBvvfeeyF3//33h5zfH9axY8dQ07Zt2w0d4v/PDTfckMRXXHFFqKH9yLRfzO/No72S5GSgvXNfffVVEpOTgfbljhgxIuSefvrpJPYuBDOzfv36hdxBBx0UcuPHj0/irl27hppatWqFXJ74/fZmZo0aNUpi8gzQfswOHTqEnPcy+NiM96zSdfB7Yr1bwYz3C5Prx+9fpD3R1K78nmWz6C6hPZq0175v374h99prryVxoVAINf76mPF+5Pr16ycx+VNoz2xelMQxQ/3nzDPPDLlPPvkk5LyXglxA3bt3DznyTj377LNJfPTRR4eaKVOmhBz5V3x7OeCAAzZaY8bOLO+Peeutt0INfW9qB75f0v7nOXPmhBzNX9OnT09iGivI+ZMXd955Z8itWbMmiWnfNfVN2m/ufW3k8KDrRB4eP++QF4DGRXJq+Dm4TZs2oYbGGho/vQdizJgxoaZmzZoh58+zWWyL5NmisfKf//xnyHl3D3n/tt9++5DLi4ULF4acbz/kXyH3AfmHypQpk8Tk/1u0aFHI0fn214nGgrJly5bos/xYRmu6zz//POSobuLEiUlMbYzcB+RFmTVrVhLTXENOMBqv/ZxM54vcjnlC18q78cif4b0qZnz/4H1VdA9A/j+6f/DOTWr/5KOcPHlyyPn1GvlxaC07ZMiQkPNuFH9PY8Ztmz7fr09ojURjPbl8nnzyySQmNw2d57yg6+nXJLTubd++fciRc8evP2n979u+GXvB/HWicZb6Da3N/NhI60Oaw8g5uGTJkiS++uqrQw2ta+i+6sUXX0ziZs2ahZpLL7005Gi95R02NGbTPdT60F/MCCGEEEIIIYQQQuSEHswIIYQQQgghhBBC5IQezAghhBBCCCGEEELkhB7MCCGEEEIIIYQQQuTEBuW/JJf08l8SAL388sshd8opp4Scl4eRIJgkfF5GZWY2dOjQJCYJLInAqlevHnL33ntvEh9//PGhhmSZXkZlZtapU6ckJjHygQceGHKDBg0KOS9WGzBgQKghmeL5558fcitWrEji6667LtQceeSRIeeFr5uSdu3ahZyXN5OgjYSWXkhlFgWQ/hyZmTVo0CDkSIzlxcHUjr3Y0SwK4Myi6Oudd97Z6O8zY8mWl2fRufnss89C7oMPPgg5Lxsj+Rp9Pkm9/Hei60hyz7wgIfg111yTxCR2JAFcpUqVQs6LHKmNeXmZGUv4vCiS2kr//v1DzkuDzcz23XffJH7//fdDDY3PJEX0bYqkbaNHjw65bt26hdzSpUs3elwkmKPxbNKkSUlMfZ5E5HQONwUksz3vvPOSmPovCURJWufF4iSgHDlyZMiRCLZz585JTGMNSYNJDN2yZcskpnUH9UGSw3ohbZcuXULN7373u5A77bTTQs6Pu7QWIbkotbPhw4cnMY0fpUnST6J9L76na0KybpIme/EoiVW98NaM16l+nKK1Gc1fNP/Wq1cviUnkTOsXGke8QJOEoLfcckvI0bzqpak0DlO/obncC0FL+gKMPCFRuZei+jWRGa/DSFrt5xQSxZMQlcSsvo2SqNW3s/V9lp/DSORPbfvDDz8MOd+nqc+RsJfmFy+hp5+jNvT888+HnL93o75En58XNMYdeuihSUzfncTN9JKHd999N4mpLfqXSpiZTZs2LeT8PSndV5KQmdqGX4tRuyPefPPNkPNjb+vWrUMN3Tv4l4uYmQ0ePDiJ6QU4Dz74YMg9/PDDIefPF61r6LMuuuiikDPTX8wIIYQQQgghhBBC5IYezAghhBBCCCGEEELkhB7MCCGEEEIIIYQQQuSEHswIIYQQQgghhBBC5MQG5b8kXDr77LOTuKTCJS/qM4vytV69eoWaxx57LOS8GNMsCtJIokTiIxIFeWHvypUrQw1Jjm688caQ89LjK6+8MtSQeNeLRM3MLrvssiTu2bNniY7r9NNPDzn/s17QZ8Yy4zwhGa+XnZJojeR5JK7zEjwvp17fMZBM0gsfSZhZuXLlkGvbtm3IjRgxIonffvvtUOPFxWZRtGYW5a2vvPJKqGnWrFnIkUzVywyphs49SR29CPnbb78NNSSmywsSlPrv76XNZmbnnntuyJ155pkh54V71BZJsjt79uyQ81JRGtfLlSsXcl6sbWZ2+eWXJzEJJ6ldU85L7Z566qlQs9tuu4Ucidd9nyCJ7T777BNyJOWmsdBD8r28+Prrr0POz3UkmKbz7ccHsyiqPfHEE0MNze8krPaCVRKukuiXZHp+fqK2SOMiyTK9HHnIkCGhhiT91Ee8tJDGCvosmiP8Cxj8CwDMzGbOnBlyeVG2bNmQ8+tBEvFSWyTJtxfOH3HEEaGG1n6rVq0KOS+1HjduXKghgakXEJvF8a1MmTKhhoTA9Fm+LXqppxm3KZKL+rGSxorDDz885Eig7OcbWkOR1DpP6Pz6PkuiY3o5BN13ePkviYRbtGgRctQH+vTpk8R03/HHP/4x5OglIL6f0DhF42DNmjVDrm7dukns+40Zi/U/+eSTkPPrOppv7rjjjpCje0M/p5EEn8bUvKC1sB8vaezyL6Mx4xez+HGDauh80FrJj5f+pT/r+6w//OEPIedfzEDtgtodfb7vlyUZi834JQ8DBw5MYppbL7jgghIdq2/XdJ9Ia5H1ob+YEUIIIYQQQgghhMgJPZgRQgghhBBCCCGEyAk9mBFCCCGEEEIIIYTICT2YEUIIIYQQQgghhMiJDcp/SSrnhXskniLeeeedkPPiYBIUksjnoosuCrnjjjsuiUlmSfLQ8uXLh9x9992XxCQePOqoo0Lu2GOPDTkvVyUJUY0aNUKOpJdevHnqqaeGmm22iZf0wgsvDDkvyf373/8eagYNGhRyI0eODLlNBYnVvEjWyxLNWBBFIqbevXtv9Bi8sHR9x9W5c+ckpva/fPnykCOxmheb1qtXL9QUCoWQo7bghX0kvKLz5WXG9Fkk0atevXrIzZgxI+S8lJDkqiTdygsS7/rrOXTo0FBz/fXXhxyJKRs3bpzEXnJtZjZ48OCQq1q1asitXr06iaktekGwGbcN365J5EwCYhqPfb+htkJjF8nj/HckQTZJuqnOixlJKE5i57zYb7/9Qs73V5JZ9u3bN+Sobx5wwAFJTG2RxN/0WV7W+sILL4Qamg+pj/hr4OWHZmbPPvtsyLVp0ybkXnrppSQm6Sv1LWr/fhyktk/S4xdffDHkvLCaxthGjRqFXF5QW/z444+TmOYqEkqTgNa3DRJX/utf/wo5L2Q2i2tLGldIxkl1XnBJ8nrKkRjWtw1qr9Qf6EUcvo/Qetq3fTNu102bNk1i+j79+vULuTzxLxUgJk+eHHJNmjQJOZrzvVSX5oVJkyaF3DHHHBNy/rrTz9HLIUjm79dKJBumsYT6nL9HovUuSXypH/p7Spp/Dz300JCjsd2/6ITaLI2zeUHzmp8jaa1BEl9a27du3TqJ6cUGdE0WLlwYD9ZBYx6NXSQJ9us6EqPTOsCv6czimEMv7/EvzjAzq1+/fsh56TmNn/RinieeeCLk/JqI+tacOXNCbn3oL2aEEEIIIYQQQgghckIPZoQQQgghhBBCCCFyQg9mhBBCCCGEEEIIIXJig44Z75Awiw4PFTDuxQAAIABJREFU71AxMzvppJNCjvZv1alTJ4lr164dasaNGxdyd911V8hdeeWVSez3NZuZ/fGPfwy5u+++O+S8R8E7Z8x4D/pZZ50Vcn5PPe2J87/PjB0o8+bNS2La10/797IsC7mHHnooiUePHh1qyIdR2jjkkEOS+PXXXw81tB9zwoQJIef30q5duzbUUJ+gtrBixYokXrlyZaipUKFCyJGDyO93JjcNQftCX3755Y0ew9Zbbx1ytCd62LBhSdypU6dQQ54qOi6/9518MuSsyIuWLVuGnN8vTf3utttuCzlyq/hz+cgjj4Sahg0bhhy5YvzPXnDBBaHmqaeeCrlvvvkm5MqWLZvEtPebjot8Jt75MmTIkFDz4IMPbvTnzOI5pDZGrjDqu96tQx6yTz/9NOTywrsfzKInivoOuaToe3mHCc3ldevWDblevXqFnN9LTvvnaQykedPvl6e98s2bNw856m+//vWvk5jWNX7+NTP7/vvvQ873EfKbbL/99iFHPgxfR36f0uRRoPWH98DQdfKOFjNeA/l2RutDmjvofI8fPz6Jvc/HzOzLL78MOeo3fl1A14TmWlpj+P5GXjvyMdL45o+f1ozkvqBxvSS/j8bwP//5zxv9rP8ryKnh++yee+4ZaqgNUd9bvHhxEpOTiD7rn//8Z8j5vlOrVq1QQ+vW9u3bh5z3r9A4RWtScmN435/36pixz4TWg95BRcdFDrwOHTqEnO9z9H3233//kMsL6lN+jCNPDs1F5BoaPnx4EtP9tHc5mvEc6e8Tzj777FBz7bXXhpyfR83iGE1uVPIWTZs2LeT8WufAAw8MNVdccUXIdenSJeTmzp2bxORJOuecc0KOnm/48Z7mM++N3BD6ixkhhBBCCCGEEEKInNCDGSGEEEIIIYQQQoic0IMZIYQQQgghhBBCiJzQgxkhhBBCCCGEEEKInNig/JckfK1bt05iklKeeOKJITd16tSQ8xIgkiySRI1kh16iRsK9evXqhdyNN94Yctttt10SDxo0KNQ8/fTTIffcc8+FnP9OTz75ZKghkehll10Wcl7ASmKzV199NeS++OKLkNt9992TmOSN9B0POuigkNtUkETNy7JI8lelSpWQmzNnTsjttttuSUySPxIJk7CratWqG/zs9R0Dydd8HyBhGkmPSWboxWokCKPvTRJf32a8DNjM7Ntvvw25Zs2ahZyX4bVq1SrUtGnTJuTygsS4PXv2TGIS0JKs7Kqrrgo5//1/+umnUEPCPZK3eik5XScSDb711lsh52V1fhxZX46EsV4ES8L2gw8+OORIoleuXLkk9v3PzGzBggUhR23Ryw6p7dP5ygsS+q1evTqJSXhL4wO1DS8MpetEElaSP55xxhlJ/PDDD4cakllSX/KyTJKRkgyb+o0fF6l/Dxw4MORWrVoVcl7iS3LFyZMnh1y7du1Czouoaa6hdVNefPTRRyHn523/0gczlj9SP/eSeBLhU1uh8cCfb1prkhiX5KS+f9E4TKJf+p1vvPHGBj/bjGWo9Ple/lu/fv1QUxKZullc+9DcToLjPKH1lG8fW20V//s0rTX9mGoW1yQ0Z9L6k8Y4P856sbCZWbdu3UKOhNu+79ALHej+gcb/Cy+8MInpHoNE3SQz9/2V1sV+/jXj8divGf1LMsxYIJsXfiw3iy8vITE6CZ/9OGhmNnLkyCSePn16qKGxkdq1v4/yL7YwM/vtb38bclOmTAk5v5alccOv38z4pTj+HNLvI7kwvdzGr1MHDx4cavzLe8zMWrRoEXK+79K9Ct1rrQ/9xYwQQgghhBBCCCFETujBjBBCCCGEEEIIIURO6MGMEEIIIYQQQgghRE7owYwQQgghhBBCCCFETmSFQiHvYxBCCCGEEEIIIYT4r0R/MSOEEEIIIYQQQgiRE3owI4QQQgghhBBCCJETejAjhBBCCCGEEEIIkRN6MCOEEEIIIYQQQgiRE3owI4QQQgghhBBCCJETejAjhBBCCCGEEEIIkRN6MCOEEEIIIYQQQgiRE3owI4QQQgghhBBCCJETejAjhBBCCCGEEEIIkRN6MCOEEEIIIYQQQgiRE3ow878ky7JClmV18j4OIdQWRWlBbVGUJtQeRWlBbVGUFtQWRWlC7ZHZrB/MZFn2XpZl32VZtmqdf+7I+7j+TZZlTbIsG51l2WdZlhXg34/Lsuz7dY79nTyOU/xyNve2WFxzVJZl87IsW51l2aIsy/bd1Mcpfjmbe1t0x70qy7K1WZb9NY9jFb+cLaA91syybGSWZSuzLFueZdkdWZZtk8exil/GFtAWG2ZZ9kqWZV9lWfZulmUD8jhO8cvZDNriCVmWTc+y7Ossy5ZmWXbTuuNelmUVsyx7pni9+H6WZcfkebzil7EFtMdfZ1k2LcuyH7IsezDHQ/3FbNYPZoo5uFAo7LTOP7/O+4DW4SczG2Jmp2yg5tfrHHv9TXRc4v+GzbYtZlnWw8xuNLOTzGxnM9vPzBZvsqMT/2k227a47nGbWWUz+87MntqExyf+82y27dHM7jKzFWZWxcxamFkXMzt70xya+D9gs2yLxTchz5rZc2ZW0cxON7N/ZFlWb5MeofhPUprb4o5mdr6ZVTKzdma2v5lduM6/v9PMfrSiOfpXZnZ3lmWNN/VBiv8om3N7/MjMrjWzBzb9of1n2RIezCBZlp2YZdmkLMv+WvxfF+ZnWbb/Ov++apZl/8yy7Ivi//Jw2jr/bussyy4t/quBb4qf0lVf5+MPyLJsYfF/Qbszy7KMjqFQKLxTKBTuN7O5/3ffVJR2NpO2+Aczu7pQKLxeKBT+VSgUlhUKhWX/ie8vSg+bSVtcl8Os6KZ44s/8yqIUs5m0x1pmNqRQKHxfKBSWm9kLZqYbkC2MzaAtNjCzqmb2l0KhsLZQKLxiZpPM7Lj/yAkQpYZS0hbvLhQKEwuFwo/Fa8FHzaxT8e8oa2YDzezyQqGwqlAovGpm/zS1xS2S0t4ei//9sEKhMNzMPv/Pn4FNyxb7YKaYdlb0X/0rmdmVZjYsy7KKxf/ucTNbakUT3WFmdv06DW2QmR1tZr3NrJyZnWxm367zuX3NrI2ZNTezI8ys5y84xj9mRX+2OinLsq6/4HNE6abUtsUsy7Y2s9ZmtlvxoLo0K/pz/R3+t58lNgtKbVsETjCzhwuFAm6/E1sEpb093mZmR2VZtmOWZXua2UFW9HBGbHmU5rZINyyZmTX5GZ8lSj+lrS3uZ//vgWE9M1tbKBQWrPPv3zQ9sN6SKc3tccuiUChstv+Y2XtmtsrMvlznn9OK/92JVvSnTdk69W9Y0RPd6ma21sx2Xuff/dHMHiz+/++Y2SHr+Z0FM+u8TjzEzC7eyHHWKTrVId/OiraNlLGiG5BvzKx23udV//x3tUUrGkwLZjbNiv5cv5IV/Ze46/I+r/rnv6stun9fo/h4auV9TvXPf297NLOGZjbdzNYUf+6D6x6v/tl8/tmc26KZbWtFN0b/U/z/D7SirSSj8z6v+mfLbYvFdSdZ0Y13peJ4XzNb7mpOM7NxeZ9X/fPf1x7dv7v23797c/1nS/iLmf6FQqH8Ov/8bZ1/t6xQfKWKed+KbkKrmtkXhULhG/fv9iz+/9XNbNEGfufydf7/t2a208858EKhMKVQKHxTKBR+KBQKD1nRzXDvn/NZolSwubbF74r/96+FQuHjQqHwmZn92dQWN2c217a4Lseb2auFQmHJL/wckT+bZXvMsmwrMxttZsPMrKwVPbSuYEU+LrF5slm2xUKh8JOZ9TezPsWfd4EV3cgs/d9+lig1lPq2mGVZfzO7wcwOKl4bmhXdwJdzpeWs6D8ui82XzbU9blFsCQ9mNsSebr9aDSt66veRmVXMsmxn9+/+7dT40Mxqb5pDTCgY/7mq2PwptW2xUCistKLFnbaL/HdQatui43gze2gT/j6RD6W5PVa0ooXlHcX/AeVzMxtsemi9pVKa26IVCoXZhUKhS6FQ2LVQKPQ0s72t6L9ciy2P3NtilmW9zOxvViSFnbPOv1pgZttkWVZ3nVxz21K3lgiz0t0etyi29Aczu5vZb7Is2zbLssOt6E+SRxYKhQ/NbLIV+V22z7KsmRVZ8B8t/rm/m9k1WZbVzYpolmXZrv/bX178s9ub2XbF8fZZlpUp/v/lsyzrWZzbJsuyX1nRnrnRv/RLi1JJqW2LxQw2s3OzLNs9y7IKVmQ/f+7nfllRqintbdGyLOtoRf/FRW9j2vIpte2x+L/ILTGzs4rn6fJWtO34zV/2lUUppdS2xeK4WXFuxyzLLrSirccP/oLvK0ovebfF7sWfObBQKCQP/wqFwmor+ivCq7MsK5tlWSczO8TMHvmZ31WUfkpteyz+99sUj51bm9nW/763/lnfNGc2y4N2jMiybO068ZhCoTCg+P9PMbO6ZvaZmX1iZocV/xcvsyIZ0T1W9LRvpZldWSgUxhT/uz9bkfflRSv60+X5Zvbvz/zfsJcVLer+zXdW9CdeNa1oj/C1VmTaX1v8O/oXCoV3fsbvEaWDzbUtmpldU/z5C8zseyv6E+nrfsbvEaWDzbktmhXd/A5zfx4rNl825/Z4qJndamYXWdFcPdbMfvszfo8oHWzObfE4MzvVitaPE82sR6FQ+OFn/B5ROijNbfFyM9vFzEZm/+8PJSYWCoWDiv//2Vb0auIVVvQmnLMKhYL+YmbzZnNuj7+3IinxvznWit42e9XP+F25kqVbxrYcsiw70cxOLRQKnfM+FvHfjdqiKC2oLYrShNqjKC2oLYrSgtqiKE2oPW5atvStTEIIIYQQQgghhBClFj2YEUIIIYQQQgghhMiJLXYrkxBCCCGEEEIIIURpR38xI4QQQgghhBBCCJETejAjhBBCCCGEEEIIkRMbfF12p06dwj6n1q1bJ/HWW28dfu77778PuQ8//DDk2rRpk8SzZs0KNbTVap1XZa2XvfbaK+RmzpwZcmXKlAm5n376KYmbNWsWar7++uuQmzhxYsidfPLJSbx27dpQM3ny5BIdlz8/zZs3DzXly5cPuUmTJoVc06ZNk7hixYqhhnI33XTTxk/+/xFt2rQJjcG3j3LlyoWfozb05Zdfhtzuu++exF988UWo2WeffUJu5cqVIffdd98l8R577BFqfvzxxxLl5s5N30C4/fbbhxr6Pk2aNAm5xYsXJzG1bV9jZrbLLruE3LbbbrvR45owYULIVa1aNeR8f33//fdDzbfffhty8+bNy6U9XnXVVaFRLVq0KIkXLFgQfq5///4h9/bbb4fcu+++m8TUhhs1ahRy/hjMYpv97LPPQo1v+2bcpmrUqJHEw4cPDzUdO3YMuTVr1oRchw4dkpjGf2o/AwcODLmaNWsmMY2pRIsWLULOzy/Lly8PNXSeH3zwwVzaYocOHULj8PMAzRW77rpryM2bNy/kdttttySm8W6nnXYKuTlz5oScH1OpDY8fPz7kaMzw7YzWHUuWLAm5hg0bhtyIESOSuGfPnqFmm23icmnHHXcMuRkzZiQxrUWWLVsWct98E98M/9FHHyVx9erVQ03fvn1DbtCgQbm0xfLly4e26I+5WrVq4ef89zTjufbzzz9PYpqXaA6dOnVqyPk5mca7smXLhtyKFStCzo9vNK58/PHHIVevXr2Q8+2Hzpdfo5rFNYeZ2dKlS5O4S5cuoYb6PLXrKlWqJDGd08aNG4fciy++mNua8cILLwzt0Z9fWsvT9XvvvfdC7tNPP03iHXbYIdTQmp+oXLlyEr/zzjuhhtp27dq1Q+6II45I4ltvvTXUtGvXLuR8/zKL32n+/PmhxrcNM7Ptttsu5Hxbnj59eqhp1apVyFE/9+2PauhecdiwYaVmnvZr2h9++CH8XI8ePUKO+l6DBg2SmOZD6uurV68OOd/+ae1Na3S6Z9x7772TmO6rfI0Zj7O+LdL3obZI98V+fUJzEK0D6FmGHxvo9/l7bjOzBx54ANui/mJGCCGEEEIIIYQQIif0YEYIIYQQQgghhBAiJ/RgRgghhBBCCCGEECInNuiY8fsUzczGjBmTxP/6179CzZ577hlytK9s2rRpSTx79uxQQ/uyaK+ndwyQJ6NChQoht2rVqpCrW7fuRo+re/fuIef3m5pF14HfB2hmtnDhwpCjfZbeyUD7YOmzKlWqFHJ+fyntpSa/Q56Q26BWrVpJTPuFad8s7e3+5JNPkpj2rH7wwQch59uLmdkLL7yQxN7NYRb3f6/vd3pvDrkOdt555xJ9vu8D3mVixn2C9qF6R9S4ceNCDbkn6Dv660b76unn8oLO91Zbpc+5e/XqVaLPouvp98mSy4vaMI29/nqSM4XcA7SX1rtuaA8utRXae+/HKurfF110UciRM8t7erwXxYz3HpMHyPfd9u3bhxpynuQFOUz8/n7fNs14PztdA/9ZtBfb+6bMeL7155JcKzRHki/L76GnsZ/2xpOnwY9l9Fnkvjn++ONDzvc3ckXQ9ybHyXHHHZfEtI567rnnQm7QoEEhtykgx5tvnzQfk5/sq6++CjnfZqktkmuF5iG/LiLPFnl/6Fh9jpxg5Nnyaw6z6Ceg9RuNW/Qd/ZhHfjHqD7Qu8NeDHEC0/ixt+LVYnTp1Qg2dE3Jq+HU6tRe6LyC3n6+jOf/AAw8MOeonw4YNS+JDDjkk1NA8Sm3bnx9aP9D9Cp0Lf19GczKtW/063yz2E/p9NO/lBfnB/DhB/ZPuzWhM8GMjzckl9Vr6eZP8f9SGad3ux3+6n6a+Rff+r732WhJT+yFfDT0P8I6Zbt26hRo69/Qd/ZxPY/3gwYND7oEHHgg5M/3FjBBCCCGEEEIIIURu6MGMEEIIIYQQQgghRE7owYwQQgghhBBCCCFETmzQMUN7o2vXrp3Eb7zxRqih96f7nzOL+xn79+8famgPbseOHUPO740fPXp0qKF3rDds2DDk/N68n376KdTQ3nXaE+f3/ZK3we9vNzObO3duyO26665JPGPGjFCzaNGikPv4449Dzu/pe/PNN0MNeTTyxH9/s3jdyWtAzos99tgj5Px1JmcKtWNyn3Tt2jWJV6xYEWpoLzy5B3wd7e2kvbQ77rhjyHknVOXKlUMN7dsvU6ZMyL311ltJTOeGvAmdO3cOuSlTpiQx9TnaS50XNC41atQoicmlQG2F9hX7PasHHXRQqFm7dm2JPn/UqFFJTPtyZ86cGXI0jvsxjvap0/7n+vXrh5zfS3744YeHmiFDhoQcOXn8+EX7gMkFdccdd4Scb580ftA5zAu65t5XMHHixFBDfjjyLfh+R24a2otNawNfR23MuwPWd1w33XRTEpNzqVOnTiFH7jR/XDQGkqfB73k3iw4L6t/UPg877LCQ864PGlPIXZAX3l1nZjZ16tQkLqkrjHxHfi1Dcxydb5ofvcOD1knkX6A1hu8T5PoibxEdv+9v5FSktRD5h/w8Sr+Pxmvyx/j7AfJs0XyQJ949ZhYdVuSfoLUZzbd+nKX1FLUXWrv7Y23dunWoof5P9zX+OpMfi7xvNEf6tQE5QmidR64PP7bTepfGs6FDh4acX4vQmE1jal5Qn/Xfn/w95LWcP39+yPnxjByHNB/SvWxJPoscSHTP6O+naT1F0L2sHwvp95Hfi+6//BhHTh76jjS/+DZL14ycvetDfzEjhBBCCCGEEEIIkRN6MCOEEEIIIYQQQgiRE3owI4QQQgghhBBCCJETejAjhBBCCCGEEEIIkRMblP/OmTMn5LxEhwRgJAryokezKCa7+uqrQ82gQYNC7qmnngo5L02qWbNmqCHRIMmWvKBqyZIloebII48MOS/UNYvyvr322ivUkFiVpFheRETyRhKBrVmzJuS80Ovoo48ONSQ2zBOSBnoZGkkovUjVjAVRXu5GIsMmTZqEHImafVsjcRxJt6jveBkgCaTpGtP58sI3Ojck1CKZ4bRp05KY5IPURl9++eWQ88dP7ZiEZ3lBojl/zCTJo+tEUjgvzlu4cGGoIdnps88+G3J+PKPfR7JD+p1ebtiiRYtQM2vWrJAjCaMXZvqx0oyF6tRmvRDbSxnNWMg2YMCAkPMiNxoHSUyaF9RXhg0blsQk/aO+SdJ8L0qnMZb65nnnnRdyvk/QNaH58NVXXw05L2Bu3759qKGxhkSwu+22WxJnWRZqSJJK6x8v0PTXwowFl6+//nrI+fUCjenUb/KCBLq+v5L4mCSLtF7z82hJBdbffPNNyPk+TFJxgq6Bby8kaaWxjGS5fl2w++67hxpqwyU5Li9iNosyXDMWb/r5neZAOtY8Iem8Xz+R/JckuNS2vZSfJKN070Nj9jHHHJPEtK6kdRiJcfv165fEBxxwQKh59NFHQ47GPd/HevfuHWqo71D/9dfDvwDGrGTrVrM4/k+fPj3U0PiQF3Sv6dsinQ+6Z/QvyzCLczy9oIJe6NOzZ8+Q82s4ur4kEieptZ83t9tuu1BDcz6tlf35oWOnF9kQ/gUtNA7Q96a2WK5cuSSm+Yxy60N/MSOEEEIIIYQQQgiRE3owI4QQQgghhBBCCJETejAjhBBCCCGEEEIIkRN6MCOEEEIIIYQQQgiRExu0nfXo0SPkvBCYRJJffvllyJGgbtttt01iL3A0Mxs7dmzIkfjMCwpJ3kWiShKwejkRyVBJQNmyZcuQ88IfEheTkI0+y4uPvCDUrOQiQC8RGzduXKghedT/x96bR2tVXXm7c0vUiE1siKAiCCKKKI000rcCYouISuxilYnGmGRUvFWVVL6bylff9+VWVarSm8bELnZREhtEQEV6pBdUQBTEDkWMTVBsMGje+wdkDPZvPsAbr5d9jvk9Yziq1mSd9+x377nmWnvnrGdXCYnVVCamQtGIiA4dOqQYCdk0h2bPnl3XZ5EMUyWFJNhTYVQES0U7d+5caqv0LIJlkiR0Vak0iaxee+21FCMZoEplVaAZETF48OAUu+2221Ls2GOP3elxkRitKkhgpuK8d955J/Uh6R+Jvnv27Flqk+CPRGv9+vVLsVmzZpXaJMRTiWEES8//4z/+o9QmaTjJqUmg261bt1KbxLNUe1UaT8dBUlmqvf/0T/+UYpMmTSq1hw8fnvrQd6wKEu9ecMEFpfbKlStTHxJJkgxZpfY67iMirrzyyhSbOXNmimlek4yQ5LBamyOyLHPatGmpz+WXX55itH7QfJkwYUJdP0d1QMX6/fv3T31oLiNhNQnVlX322WenfXYVJLjUOZmkkSSNpXGuksg//elPqQ8JTLt27ZpiKnOlOYfmNHpxgAqHaR1Gsnaq1yoxpRcHUF7QWFI6duyYYiSwptqvQlkSctNnVQmNKV3DLVy4MPUh4WqbNm1STCXP9b6Qg9YGq1atKrUPOOCA1Idip5566k5/J8n3e/funWIkrdZ7sAEDBqQ+NH5JpqoiWKqDkydPTjGq4ypLp/shOoaqoHW7fn8SzFNOkcxZZdF0z0FiZZrX9N6Eagvd+/fp0yfFNKdo/UC1nnJdBf9UZ+m4jjzyyBTT5xR0v0SSZXouojlL14yei2wP/8WMMcYYY4wxxhhjTEX4wYwxxhhjjDHGGGNMRfjBjDHGGGOMMcYYY0xF+MGMMcYYY4wxxhhjTEXsUP5Lkk6VLJIUiORuJJccN25cqU1C1s9//vMpdsQRR6TYrbfeWmqTqKtVq1Yp9uijj6aYyt1IdkXCV5VRRWQ5HQmqVNQYEXH33XenmLJ48eIUUzlSBF8jFbyShO7hhx/e6THsSugYVTCpMuAIFuqStFGle8cff3zqQ9LPN998M8W6d+9eapOMVOWnESw71c8//fTTUx+SLpJ0TqV29PtIwqpyw4iI5557rtRWSSj1iWA5l44TEuKSuLAqKA9UFDlixIjUh/KAclbFZyqAjmCZJB2X9qN6oLU4gmVlKmkmSSpdX5L86bisV5I4ZsyYFNOxS2OSJKwktVYpItVBEthVBUlLmzdvXmpT3qn8NILl6SrepRwjsTJJUnXuvuSSS1IfWj8cd9xxKaYi2CuuuCL1IREs5dnUqVNLbZKW09xKeaYvFKDzrC8FiGBBoQrPae0zfvz4FKsKfaFDRETfvn1L7U2bNqU+NE+QiFQFmiR31dyPYPmp1l2SYJLMlj5f1xO0ziPx5gcffJBiOo/QZ9FcSwJNfYED5Q/NtSRVViEwyUwbkhQ9gs+T1gQadyTUrqeebdy4MfWhvKKXh+jYoTmf1ma0ztD5dvTo0TvtE8HyWT0O+o4ki/7qV7+aYno9KPfqlRLrGpteYEJ1pSr0JQwRWYZPfegelWT4urYnITPVZ1rL6HGQ1Jfup+nFIVov6edonqZ+9913X6lNL/mhmkr3e7rWoXM6ZcqUFHvrrbd2+jvpxQq01twe/osZY4wxxhhjjDHGmIrwgxljjDHGGGOMMcaYivCDGWOMMcYYY4wxxpiK2KFjhvZPqxdA90BH8F4t2sd21llnldrPPPNMXccwbdq0FNP938uXL099yDtD+/NPPPHEUpscJV27dk0x+o4tW7YstW+88cbUh/au9ujRI8V0n/Rpp52W+vz5z39OsTvvvDPFLr/88lJ7xYoVqQ9djypZtGhRiun+Xfr+tH+RPBh0nRX6fPIR6L5l2lNM+xBpPO23336ltu6tjeB8Jw+S5jvtl6Q8pv2euq/yU5/K5YT2HtP1ePrpp0tt2i9Px1oVdI5Wr15danfq1Cn1qec8RkQsXLiw1K7HExURcfjhh6cY7bNX1NcRwY4lzWP1aUSwx4D2uOveaXJPkM+B9qVrnuncEpF9CxERs2fPTjGFfAsNae861Yxly5bttA85U8iTpnMDXd/hw4enmHp/IvK4pnFEtZnqiB4/fRa5It57770UO+GEE0ptGkeUd+QN0VpMtX/UqFEpRr4mPS5yTNAxVAW5yNQDQ14zmhPIYaJzTL3OFKq7Wt9ozqE1I62L1HtFNZ3ygM6Fzhs6N0bwupXmCP38efMlF+D/AAAgAElEQVTmpT40b1P+q5OBvFXqRqsauhdRLyHlLLm2aI2l8wC5LNTLGcE5qg6KDh06pD4DBw5MMfJvrVu3rtRWb1EEjwnKUT0X5PWg2rty5coU0zFG6w7KIZpvycGj0PepClpP6f1Ely5dUh9a75ODVN1pEydOTH0oD2h9WM/cSvMo5ZS6vOh+l9ZYNHdfddVVpTZ5VmnN+OMf/zjF1Je4YMGC1Ie8luTCVY8a+Zvo+m8P/8WMMcYYY4wxxhhjTEX4wYwxxhhjjDHGGGNMRfjBjDHGGGOMMcYYY0xF+MGMMcYYY4wxxhhjTEXsUP5LQr/HH3+81G7dunXqQ3KfyZMnp5hK60g4RvKuN954I8VUNEhyNBIYqVwvImLDhg2lNgm3VDobwWIlFRl++ctfTn2uu+66FKPvqNIt+rmRI0em2CWXXJJiKp4lYdKsWbNSrEpIyKbX4eWXX059VD4VkUWtEVnUTDJgkrZRvquwiwTMJJ0j8aUKDkmE1rRp0xRTmVxElmnT+SJx4aWXXppiOqZJbkWyQZI66jh/8sknUx+VSFaJyp0j8vgnmSeNTxKFqfiMagtJ/5YuXZpiOm6uvfba1IdEcX369EkxlelRDqtcMSJi0KBBKaZSy/bt26c+JH//2te+lmL/+Z//WWrTdzznnHNSjITi69evL7Wp1pO0sCroO6gwnGT148aNS7G2bdum2Ne//vVS+7HHHkt9SMxNtUw/nz7rjDPOSDGSF+s8TZDwmeq6iqfp5zZu3Jhiep4jIoYMGVJq0zw9ffr0FDvllFNSTOsnSRKpflQFzU16LknaqWMugsW7hx56aKlNwl6SUlIuvvPOO6U2zTnaJ4Jl/zrXkiCVjoFEwirjpNzXdXgEvwxizpw5pTatp1U0H5FFohH5OzZr1iz1Wbt2bYpVCX2Piy++uNQm6by+aCOCJds9e/Ystem6kFyZzp2uP4cNG5b6UC6QvFXnZZIS01gl4aqKyumlAyQq/sUvfpFiuqagYyC5Kp1DXX/SWoTqc1XQ2NN7BxIf09qMpLS6JqUXM9A5Ovjgg1Ns6tSppfaHH35Y1zHQfaTOWXRN6Ljo+FVqTbWYara+0Cci3wPTPRQJgQl9iQQdF8mwt4f/YsYYY4wxxhhjjDGmIvxgxhhjjDHGGGOMMaYi/GDGGGOMMcYYY4wxpiL8YMYYY4wxxhhjjDGmIgoSl/6F/v37p39UaRX9PIkAVWAakUWqJOghMRFJQFXsSALTJk2apBiJglTypZKgCBYIEiqUe/3111MfEnMtWbIkxSZNmlRq77777qkPycEuuOCCFFNJqEr1Ilgqdv311xcpuIvo0qVLSjaV/3Xr1i393LJly1KMzvkxxxxTapPIjXKUxoBK8M4///zU55prrkkxEl8+9dRTpTYJ00ioS+I7zasrrrgi9bnjjjtSrEePHimmEi8S5pFcmMahijVJ1E0/d/vtt1eSj1dccUW66CroJTElyd2oXi5evLjUJpk5CTNVOh2RZZsk+KPrS9dTrzmJtemak9Dv2GOPLbVJtDZ06NAUIxnen//851J71apVqQ/J5EjIqSI3lblGRLzwwgsp9qtf/aqSXPzOd76TclG/K+UK1UqSm99///2l9j/+4z+mPiRDpjzT87bvvvumPpTr1E9rHolx65UG67GS7FDn3wiWnWou0hqG5pZWrVqlmIo3v/GNb6Q+AwYMSLEf//jHleTi2LFjUy6qwJvE+3R9Sfip8wLldZcuXVKMxI5af7QdwWs/QtdPJNQloXT//v1TTGXeJ510UupDNVBfgBGR17K0blXRZwSvU3UNT2tsWkeOHz++sjXj4MGDUz7qC0tofJLElOaU+fPnl9q9e/dOfWhc07ypLz+hmkrnl+T0Wl/oXoHykdZdevxUPymm82hERFGUU+HZZ59NfUgOS7mmayl9mUAE1+f58+dXko/f+ta3tn+zvRUSudc7H44fP77UJuF/vffm/fr1K7XpJQwkcac1utYSeqkE3dPTiwE0F2nsrlixIsVo7afMmDEjxeiFM/SCDX2pAZ0vumZ33HEH5qL/YsYYY4wxxhhjjDGmIvxgxhhjjDHGGGOMMaYi/GDGGGOMMcYYY4wxpiL8YMYYY4wxxhhjjDGmIrJdbRtIRKryIJIFkiCV5D4qOiLJEUmlSJCkAlYSGpGQh0RTDzzwQKlNkkQSbpEsV+VrHTp0SH1Ickefdfnll5faJL4jmRbJOFUMq8K57f1clZDMVqWNlBstW7ZMMZI7PvPMM6U25baKHSNYqKXX4Zvf/Gbqc9xxx6XYG2+8kWIqKiYhKgmO6fj1d65bty71IYmmynkjsjibJMi9evVKsWnTpqWYymFJ2knjpCpIkqfyX8pFEuLR9TzhhBNKbbpOY8eOTTG6TiqY3HvvvVMfGg907bQez507N/VRuWIEC6tV5EbHTjVbJYkRuV5SrpBM7tRTT93p59NnderUKcWqgmqGCntpniO5M811ej7o5+iav/baaymm8yHJ+6j+UI1VcTPVZpVzRkSMGDEixaZMmVJqkwi2Z8+eKbZy5coU27RpU6lNQkSScVJNufPOO0ttWg+R4LIq6NrpOSIBbbt27VKM1kAq/KSfe++991KM5iaVq9L6gl4SsGbNmhTTa0Dr3enTp6cY5azmNV1fEkmSbFvn6EcffTT10bkmgkW3mp9U02lNWiVUG3VtQWLZyZMnp9i5556bYiogp99HMmqa1/r27Vtqt2jRIvVZvnx5ilF+qLSacpZk0fQSAD1f+kKTCJ4P33777RTTdR7lP80v9Pm65u3YsWPqQ7LkqqAXIKgIneqUrisj8hwTkWsCnTNaf1Ld07mbPovmw+uvvz7FtCbQeNMXnETktUJEFjzTGKHjonqm93s0jmhdQy+D0HUGvVSCXhixPfwXM8YYY4wxxhhjjDEV4QczxhhjjDHGGGOMMRXhBzPGGGOMMcYYY4wxFbFDacOSJUtSTPdckWvlmmuuSbG2bdummO5tpf2Z9HOXXHJJiul+RtqneNRRR6XY3XffnWK6l5b2Z9K+PDoXuqeP9kGSy4X2Z77//vs7PS7ag7pixYoU0z37ut86IrspqqZZs2Yppnt1yZ9Be6/JxaM/27Vr19Rn3rx5KUYul7PPPrvUpr3dtP9V9wZH5H2otL9cfR0ReT9+RN4frHs2IyKOPvroFKO99pqP9PtoLyw5F9Q1QU4V3S9fJeRJUIcAXV+6dj/72c9S7Jhjjim19VxHcA1q06ZNir3yyiulNtVB2m9OzhetS+TYoM9v3rx5iul3GjBgQOpDvog5c+akmJ5ryleqA3QOdY4jHwC5UaqC9qWrK4bmVnLnkL9Hawvt/SafDPkmBg4cWGrTOKd93ZTX6nCia0muGHI/aW5Q3qmHJoJ9Nf/93/9datP3ofyhtYgeF9Vm8rpUBeWUHnNRFKkPOVnomms/+n3kyxo2bFiKqTtD62QE54HOxxG53lDNoDm6adOmKabuFvIV0JqOXCb33HNPqU21uZ65PSJi5syZpTblNXmBqoQcFOqD0Lk2gvNqwYIFKaZjj9af5I6i8a/1kq4LjXXqd8MNN5TaVGfJ6Uk1W8cA1SBygNFaVtcPtI6iOk5eEl1LUc7SPUNV1OMjo2tJbjw6t+otU4dKBPtfydOltYrOLa0ZyR85ePDgUpvubWldvHnz5hRr3759qU3rSvLVUO19/PHHS21aH9K9Hfn69J6G3Ek0braH/2LGGGOMMcYYY4wxpiL8YMYYY4wxxhhjjDGmIvxgxhhjjDHGGGOMMaYi/GDGGGOMMcYYY4wxpiJ2KP8lmdiNN95YapP0SaW+ESwoVBEp/RzJtN59990UU6EcSZR+/vOfpxhJpY488shSm2RvJPfRn4uI6Ny5c6lNx07fkWRIKnMiSVbPnj1TjKRTQ4cOLbVJdrZs2bIUqxK6DoccckipTXI0kjKTlFZFUiTCVGFgRETLli1TTCXBw4cPT31ITEZSOM0hkgG++OKLKUayqQ0bNpTaJGIkCeUVV1yRYirnojE+Y8aMFCMprgqwSUbdp0+fFKsKEoCp2JTyjmRlKmqNyHJHkquS/Jvyf8iQIaU2SQxJlv7ggw+mmH5vuk5U42i8nXfeeaW25mYE5zDV3muvvbbUJnEoff4Pf/jDFPvud79baqtAM4Lrc1XQ+dBjvvDCC1MfEn9ff/31KaY/+/rrr6c+JLgk8aYKvKl21lvDVV5JY5LkkjpnRORaRrlC4/T+++9PsW9/+9ultuZmBItTTz311BSbOHFiqU3zNM2LVUF16oUXXii1O3XqlPqQgFJ/LiKv60gQqRLMCK5TWovpmtD3oX5ai+nlArR2oJdB6DxC9fSII45IMZUGR+ScVeFlRP3jTV/EQeObxlaV0DgeO3ZsqU1iU5oj6btpDaWXPPTt2zfFSEaq15QkpiTspfW9SnxJFktjYu3atSmm45Be8kAxelGG1nsa4yTcJgGuXg+S0tdTn3cVdK+s9Zzu6ejcUi7quaT7NxJd0z3w4sWLS20a63SdCP18qlO0Lu7Ro0eK6UsMqKZ26NAhxebOnZtiuiYlQbaunSMiJkyYkGJax2neIGH79vBfzBhjjDHGGGOMMcZUhB/MGGOMMcYYY4wxxlSEH8wYY4wxxhhjjDHGVIQfzBhjjDHGGGOMMcZUxA7lv1OmTEmxs846q9QmUahKaiMiBg8enGLz588vtUkKSnIfkjypAO/YY49Nfb72ta+l2K233ppiKiIloa7KtSJYNNa+fftSm6Rqzz//fIqRvFKP67jjjkt9vv/976fYl770pRRTOR1JuJYuXZpiVULCqw8//LDU1nMUwcJEEuhqvyVLlqQ+JAQm8e4ZZ5xRas+ePTv1GTRoUIqRfE2FaSTfVEFwRMTkyZNTTCVqJP+lsUrfUaVey5cvT31IIE6ftWjRolK7adOmqU9DR0WUJFVbuHBhitH4HzlyZKmt0rPtQTmlQsJevXqlPn/4wx/q+vw333yz1CZhO4nc/v7v/z7FVBhLotZZs2alGMk3ta6ef/75qY9KfSOyBD0iYs6cOaU2XUcaW9/61rdSbFdAkkUV4JEgmOrIueeem2JaU/fZZ5/Uh8Y+CYH186k2k4yU6qLOkToXRLDskI5VX0RA8wOta0iqOXXq1FKb8qdJkyYp9vDDD6eY5jHNb/Qdq+Kll15KMa0RJEbcuHFjipH4W4WWdM2pBlL9VAEryTJJ0E958Pbbb5faJOeltYNKNiPyGFm1alXqQzJ1Gpe6xqb5nj6LJKT6+fRzJGOuEhIn6wsJTj/99NSHROIkEFVRM9U8FZ5HsHhdzzl9ls5NETwGtH6RlPikk05KMbrX0fpFL6igNUz37t1TTCXZNC/pWIrgl7motJmE28cff3yKVQVdJxW+k5CZcoXGns4pw4YNS31o7U33mnqNKX/o2tF8qMdPeUFrOpoT6nnZy8yZM1OMRMV6/0yfRXMC1RQ9X3QeXnnllRTbHv6LGWOMMcYYY4wxxpiK8IMZY4wxxhhjjDHGmIrwgxljjDHGGGOMMcaYivCDGWOMMcYYY4wxxpiK2KH8lwRmKve66KKLUh8SGJHQ6aqrriq1n3rqqdRHJYYREbVaLcVUdqUyv4iIu+66K8VIkKRiXxJPkfiI+qnQr3fv3qkPned99903xfbaa69Se/r06akPSdtIHqcyvCOPPDL1IYlnlZAcWgVRJLQk2SCJmPT7durUKfVZsGBBitE5VwkiCa9UXrY99LhILEWS7I4dO6aYSjT33nvv1Iek0iTPUlkWia3p56gW6Hck8Z3mf5WQzFlF3yQvI4lp//79U0ylYyQQpPwcN25ciqng9vHHH0996DqRBFprNMn1qD7T+VJxokpTIyJatGiRYtOmTUsxzWOq9SQPr+fzSUpMcsiqoGug9Z3mphNPPDHFnnjiiRQbMmRIqa2i/YiIAw44IMWojmidIqGmys4jWJz62c9+ttR+6623Uh+qGSTL1XpDokZaU9DcomsREsjS/N63b98U0+OgFwx07do1xaqC5pxXX3211CYRL6016LvqeaNcIQGxin4j8gsPSMhM6wTqp9ec1lMkgSY5vsoyNc8j+NysW7cuxfQ4SB5LOUxrDB0jtK6kOaNK6F5E5wqqZyQlb9euXYrpuaN5mtZ+9HIDjdG8061btxR76KGHUkyvH10rekEK3YtobX/wwQdTH1rrkDBWXzJA44SgF77o76QxQWL8qtD1YUQW1VKdormI6qzOrbTOPu2001KM6pnWaJKG03zbtm3bncbonr7ee2wdb3RcJKemMaL5Q/J0Ev2OGTMmxXTtSvehdK+1PfwXM8YYY4wxxhhjjDEV4QczxhhjjDHGGGOMMRXhBzPGGGOMMcYYY4wxFbFDx4z6ZCLyfmHdpxsRsWLFihS79NJLU0z3fdHeMNqPvHz58hTTPf+0h5v2v5HXYMCAAaU27fWkfX/qTIiImDBhQqk9a9as1IfcB7Q/8OWXXy61ae867a+mfbZLly4ttWlPXEPaux7BfpdNmzbt9OeOOuqoFKPzq/vENdcjItq0aZNitEdbc5T2jpJHhfbaL1mypNSmPefkuXnmmWdSTPdR0l5q9ZtE8D5p3a9O7gZyl9DeVN3HTE4J3XtfJeSD0H2y5D+44YYbUoyuXc+ePUvtSZMmpT50fU866aQU033cdE3qrUGjRo0qtakO0p5l2l+t9Yy8LbS3nDw9eq4px3r06JFi5NtRZwv5FsaPH59iVUH7rNVncf/996c+X/nKV1KMcnHKlCmlNnkIaN6h+UNrKnlonnvuuRSjPfVaY2m8kcdr/vz5KaZ1nXwd5MCjvNZ5inwSmvsREf369UsxXUvR/EB746uC5kzdy09j7uKLL04x8h09//zzpTbNE0cffXSKkQNJzxutk2gtS/VAa9Luu++e+lBdpH4KeTKohhOPPfZYqU2eG/Iw0efrWpwcELpWqZpevXqlmLrxaPyQ84LqbJ8+fUptWguSw4bcQjpnkVORaiPVDR0n9Fm0/qT80BylNcZ//dd/1fVZJ5xwQqlN8wbN+eSt09pL516dNlVCaxI9H+o3jWCHHDmDdC1Pazo6R3RfrGOE8pXmVrqeb775ZqlNeUfPGsjvpc4XchfSvT+tDXROIHchuZOoDuj9Ha2j6PnG9vBfzBhjjDHGGGOMMcZUhB/MGGOMMcYYY4wxxlSEH8wYY4wxxhhjjDHGVIQfzBhjjDHGGGOMMcZUxA7lvyQAU/HZnXfemfqMHTs2xR588MEUU5HPBRdckPqQTIhEVi1atCi1SYxJotPhw4enmAoJSdBGslz6jioYomOfOHFiipF4UwVGJHciIduaNWtSTKVTJIckiV6V0PHodSDJLgmc9PtHZOEVCeBIEEjSUpWVkZCKpHMk59LPf/LJJ1MfkmeRLFdFcZMnT059LrroohTbsGHDTo9Lz19EFn9FsBhLZZjPPvts6qNy5iqha77bbuXn3IsXL059SB5N1+nmm28utTt37pz6kGiRxJQqO+3du3fqQ5I8kky/8847pTZJ4ajOkihOc5bGyDe+8Y0Uo/zp0KFDqb1o0aLUR4XnESwv1hpNMuwxY8akWFVQfdc8oHnh05/+dIqRbF9rBp3/1q1bpxhdT5UW6piJiDj22GNTjESAWmNffPHF1IcElJor1I++46mnnppidA5V1nr22WenPr///e9T7Pbbb08xFeB++ctfTn3+7d/+LcWuuOKKFNsV0FpJpYcqTI3gdR7VH5XQk/yfJIsky1RZPb1UgtYJ9B01X2jNQZJNlfNGZGk2ySbpO9IcrbWMxhutlemFCSom1TV3RMOT/z766KMppnml9yERvMaiuVVf7kFy3nPOOSfFaL02ffr0Urte0Xc9kmA6dlqb0UsNtM7SC19I6Er3JyrJJsk6jS+6F9XPIhE4zSVVQWsNXU9pO4IFt3Qf0q5du1KbcoxQUXREriUkz33kkUdSjGTbQ4cOLbXpHoeEz5Rnep+gL7aI4BfskJRe71dojND3oXsmvc+n8UBr0u3hv5gxxhhjjDHGGGOMqQg/mDHGGGOMMcYYY4ypCD+YMcYYY4wxxhhjjKkIP5gxxhhjjDHGGGOMqYgdyn9J7HjvvfeW2ldeeWXqQ6IgEiieeOKJO+3TqVOnFCOBmYqCjj/++NSHBHCECuVI9Elyn6ZNm6aYChBJtESSOxInqjSJhJokmCKp0X333Vdqk1iXBIhVQnJHPQd77bVXXZ9FMjEVZKocMIJFaySqVXkcSeFIjkYC3f79+5faJJAdN25cirVv3z7FVDpJ54tktCRCbtKkSalNwkMaq4TmO4nvSFJYFW+99VaKNWvWrNSm+klj6mc/+1mKkdxRIbHpd7/73RS7/PLLS20S7lEe0OernI6uuYrQtvdZKo/8zW9+U9dxqcw4ItdVHTMRLDsk6ZzWexKTksDu61//eortCkhwqGI+FdpHRCxYsCDFaOyroFRlwBFcTymmeU3yXJIZkzBW59uHH3449SERNc2RKpyk+kO1jPK6W7dupTaNScpPWp/o+odycdSoUSlWFVoDIyLmzp1batOabvXq1SlG85zKXIcNG5b60BxKY0Rltj179kx9Fi5cmGJUM/Q7/fGPf0x9CBL7zpkzZ6c/R2shmqO1fpIEXKWhEbxeUYEm1ZR65q1dCeWa1gRak9e7NtM5hQS09BIAukdSyS6J2OmlIDTf6nekukFia7qn0LpHeUbnmdZI+lkkZaU1NkmPtYZed911qQ+JnX/yk5+k2K6gR48eKaZCWJp3aE6meVPXlnQPSbJ0Ot9a46gW0+fTcemLJeha0jxK9y863ihfqdbTWNJ7eKr1K1asSDFaP2u9oDUMjYft4b+YMcYYY4wxxhhjjKkIP5gxxhhjjDHGGGOMqQg/mDHGGGOMMcYYY4ypCD+YMcYYY4wxxhhjjKmIHcp/SZyn8p3x48enPip1jGA5lIqfXn755dSH5Gj0+So1mzFjRupzzjnnpNj06dNTTAVbJBLesGFDiqkMNSKLj0gk3Lp16xQjKZZKoO6///7URyWGESyiO++880rtq6++OvUhWeZVV12VYrsKFTxHZGkxCelUxBvBkiqVUlH+kwDy9ddfT7GTTjqp1D7ooIPqOi6VG0ZEvPLKK6U2CfxIaKnSxYg8dkhI1rt37xSjvLrrrrt2+NkRLBsjuaHKs+j61Ct23hVQHqg8jGRfJ598coq1atUqxVR0TIJGkk6feeaZKaaS19/97nd1HQPVS5XpUZ2iXCdBodYzOl/Lly9PMRIOf+UrXym1b7vtttTnn//5n1OM5i+te0ceeWTqQ9ejKkgkqblBxztr1qwUGzFiRIrpWCRJ86WXXppiNO+Q+E+hXHn88cdTTOV9VH+oNpMIUOsU1S0aIzq/R2Rh4AUXXJD6TJo0KcWo5vXq1avUJpEoHVdVkKBd5+S1a9emPiRWpTzo3r17qU01kESVJD/dc889S22aQ+nFDJQ/ut6kFy7Q2o/WGE888cROj4sE3JMnT04xramUYySdpu+o44tEtDQfVAmt0/W603qKxKP0chJdt9Rz3rb3O1W4TPcTlAtUG3V9Us/LV+gYIuqTrFMukMhWJa80xklGu2TJkhRbunRpqU0v6yChd1XQOdLj++Uvf5n60DpMxeUROV9mzpyZ+pDwmUTX9bxohuZyunYq1+7cuXPqQ+tpWkfqsWoORLDwefPmzSmmP0v3ODSfqdw/ImLevHkppowePXqnff6C/2LGGGOMMcYYY4wxpiL8YMYYY4wxxhhjjDGmIvxgxhhjjDHGGGOMMaYiduiYof1Ve++9d6mt/osI3ltI+811v/QXv/jF1Ofmm29OMfWjROT9u0OGDEl9rr322hT7/Oc/n2L1uCzIh6O+k4iIxx57bKd93nnnnRSjfaO0/1PRffcRvM9y4sSJpfaxxx6b+jRr1mynv29XQq4fPXe1Wi310X2tEbwXWPe7rly5MvWhfZW0Z1I9LbTfU/c6R7AjR90llEODBg1KMdp/qY4gGqsTJkxIMdo7qteDvE507uk66t50GhO0z7UqyA1w8MEHl9p0negcnXHGGSmme+Npj/WaNWtSjM6beovIN9KhQ4cUmzJlSoqpO0n3n0dErF69OsWolqgj65Zbbkl9vvOd76TYj370oxRT1wR5N8jfRA4S9TLQuVE/TpWQ10FrGdUC8sLccccdKaYOmz59+qQ+5Ekjb4jmAY2jadOmpRi5Prp06VJqk7OL6iLt9df5nFw76tSK4Lqo14N8MvX6uHTe+MxnPpP60DqtKshhomtEmqOPOOKIFKPvpXMm+ZXInURjWHOW6qn6XiJ4vte1GfkKyJFHa01dY5PvhGoZ5Yb+Tlq30jilOULP13vvvZf6tG3bNsWqhNZT6ueo10FI113nSJoPKbdpPldfFa016fPJb6G1cfDgwakPQfmocyuNJaqp5LXR70h1cPbs2SlGriC953vxxRdTH3L5VAXVJXU80rij707+Fa2NNBbXrVuXYuRk2WOPPUpt8k7SdSJnkNYzqus0J9BaVn1Y1Ic+i9Z5Oi/ROKV7Dhq7CtVUGg/bw38xY4wxxhhjjDHGGFMRfjBjjDHGGGOMMcYYUxF+MGOMMcYYY4wxxhhTEX4wY4wxxhhjjDHGGFMRO5T/kuRJRVOXX3556kMiKBLyaD8SGo0ZMybFNm/enGIq1SSpIImJVKxKP0vyNZLlkjCsU6dOpTbJkps0aZJiJBVUYW1RFKnPIYcckmKLFi1KMZUwkqxOj71q6Nx9+OGHpfa4ceNSnyOPPDLFSAqmQs8BAwakPiQN3nfffVPskUceKbXbtGmT+pDUi4TAOnZISKjnIYJzVOVrJAzs2LFjipEIWWVZJGKk70iyUj0OksWq+KtK7r777hS78sorS22SfZ144okp9vvf/z7FtObQWKfxSdLwE044odR+6qmnUh8VtNfO40QAACAASURBVEVE3HDDDSmmAkgV8EVEHHbYYSmmEvSILKYkmeT48eNTjASIv/vd70ptEiqrbH576FglaafK8aqERHMq3SYRtUodIyKOOuqoFNN6Qzn80ksvpdiBBx6YYirIplp2+umnp1g9OTV06NDUh+oirWtImq9QnafvrcdPkkQaz4cffniK6XxOImESI1eFXt+InGckoKT5kdhtt/L/lkjyx/79+6cYzSf6WSR3pbUZia51/UR1kUSntJ5QaSfVGspXEvtqHaB1JX0+jRtd0+j5295nVcn3v//9FLvoootKbbo3oe9P9VLlwjRXkOxUBfMRuUbTmovOOUmCFcpHmvNp/anzMv0+erkLrdfffPPNUnvjxo2pD9UHkuJqbtO9D60/q4LuQ/TlG7SGpvNN6ynNxddeey31oRfBUO3VnKWXhND6k+4j9X6dcozmQ4pp3aN7CRoja9euTTHNHzp2itH10HmIxvfzzz+fYtvDfzFjjDHGGGOMMcYYUxF+MGOMMcYYY4wxxhhTEX4wY4wxxhhjjDHGGFMRfjBjjDHGGGOMMcYYUxE7lP/+5Cc/STGVB02ZMiX1GTx4cIqpnDcii8juuOOO1KdLly4pRjLbPn36lNoqJo2IeP/991OMJLDdu3cvtUlot379+hQjmZZKt/baa6/UZ8KECSn24osv7vTzSUb461//OsWuuOKKFFN+8IMfpFjXrl13+nO7EpIcqjRW5WIRfC579eq1088iWTQJno855pgUU+EVib9IBkUCbBXq0Xl49NFHU4zE2SrLIrnhzJkzU4yEnyogI8EWjd/p06enmIovVVIcwSKuqqDzMXfu3FKbJKMPP/xwipGYb+nSpaU2idxI1KoC64g8jkmIR/V54MCBKabXjiTrJOQkKeKCBQtKbRpvJK1VCWVExA9/+MNS+ze/+U3qQ3LVk08+OcVuuummUptq9qZNm1KsKmjeueeee0ptEvGS3Jxqpf4sScXp+pJoVHNv+PDhqQ/lD8n0Tj311BRTSEBJklSVLtL8TqJfEqX/4he/KLXPPvvs1IdE5nQdH3rooVKb6ilJSavi9ddfTzEd1zTOaU6rR2pM4koSQpJQdPTo0aU2iXhpDUTfccSIEaU2fUeSzNK4fPfdd0ttEqvSfE9jRMcznRuSptIY1OtB65eGNEdH8Dx9yy23lNqUZ3StaG1Wz0seSGJKNVTneKqf9OITetmKQsJVYurUqSmmUtk1a9akPiSgp7WBSpXp3oru0+i8LlmypNSm+Yxe0lAVtF6bOHFiqU3rHVpr0HnTl03QupJe/EBz/siRI0ttndMiIv7lX/4lxahu6LUjsTbdc9CaV++j9GVEEfWfLxXpU47RfUg98xKtGel+YHv4L2aMMcYYY4wxxhhjKsIPZowxxhhjjDHGGGMqwg9mjDHGGGOMMcYYYyrCD2aMMcYYY4wxxhhjKmKH8t/Pfe5zKbb//vuX2iT7mTx5coqRjLdZs2alNkl7SLZKIlWVfOlxRrB8h6RYeqwkCCZRH0kpVRi2evXq1Kdt27Yp9txzz6WYHus+++xT13GpFCoiS9ro3KiAtGrqkU6SwI9yiPqpWI2EqCeccEKKkdxNfyeJuHbbLT8XJcGkygZJQjd27NgUI7GvCnpJRktyLpJ7qriMZG8kqCZBs4qEaVzS51cFyQH79etXapNojXKYRI56PRcuXJj6fPDBBylGIjeNUW0kcTPVPa1VlCvjx49PMaqNSo8ePVKM6uCwYcNS7Oabb97pZ9F4e/DBB1Osb9++pXa7du1SHxU9Vwkdi4qbdXxFsBCP6o/KSOfPn5/6kDivffv2KaayU5JZ0vmmeVPnOrq+VPtJBKvCSRVTR0QcdthhKXbXXXelmIpgKYdJ+kqSV615JE5vSJJ+Ot86f23cuDH1UcF9BNf7pk2bltpUt0hAe/rpp6eYitKPP/741Ick0CTxfO+990rtFi1apD4kkiRp6vLly0vtcePGpT715rWOSz3OCJZh69o8IsuF6djpfqBK6Lvp/EH3E/TdFi9enGL6MhS6BrQOI2GvrsHps2h9361btxTT9SbNmZRDJC3VdQDlP60jac7RGkfrYhKck7RaJaxUQ0imWxX0QgJdi9Hanl5UQjWhVatWpTbdH9K8RnJ6neNpPaXrgghek2oNpTmfRNc0b37ve9/b4WdHRAwaNCjF7r333hQbNWpUqU334XTfQ/JfXevQmKextT38FzPGGGOMMcYYY4wxFeEHM8YYY4wxxhhjjDEV4QczxhhjjDHGGGOMMRWxQ2nDE088kWLdu3cvtWkvJu0tX7VqVYodfvjhpbbu7d/e5x9wwAEppvtyaX8j7V2n/XX6vTds2JD60L5U2ts8e/bsUpv2QZJzg/bs6x61u+++O/U55JBDUozOxVe+8pVSm7wTup+7amgPvvoz6LyRT4b2DrZs2bLUHjlyZOpD54nyQ/df0s/RXsvjjjsuxepxuSxatCjFaMzpnmjyiKxZsybFaO+4Hkfv3r3r+izaJ61OmXo9KFWh+3kjsrOAvmfr1q1TjNwDmrNPPvlk6kN517FjxxTr1KlTqT1lypTU56STTkoxciydc845pTaNSdo3TnVW/Rz0faimkrdI8+Xxxx9PfcgRQnuidQ/xT37yk9SH/GtVMWbMmJ32of3mP/rRj1Js6NChKaY5S04D2g8+b968FNOaofkUwc4uymv1G9Ged3JVUX5q/ST/wiuvvJJi6t2IiDjjjDNK7Z///OepD7k+KP/1OMjvQG6dqqDzoWOY1ij1zC8R+Rwdc8wxqQ+5k7Q2R2TPB60daA1MLhqtN+TRoXWI+nci2F+m6Loygt0HCq2ByVtE11HnPPLQUA5XCY0XHes0h9F9B807uiYhFxat8widw2itQNePau+AAQNKbar/NL7Is3Hrrbfu8Dgj+LqTR0ePn9wxNHdT/dd+tN49//zzU6wqaM2oNWfSpEmpD43PIUOGpJjmAdVU8vfQulp/lq4lOZfIoaj3GHS/S2tgyin1MNGYpHma5nz1+dC5p3mDxqDeh1KtP/XUU1NsezScGd0YY4wxxhhjjDHmbww/mDHGGGOMMcYYY4ypCD+YMcYYY4wxxhhjjKkIP5gxxhhjjDHGGGOMqYgdyn+bNGmSYirRUdFdRMRtt92WYiNGjEixAw88sNQmWSBJWkn+q1IjkgLdfPPNKUYiuhYtWpTaK1asSH1eeumlFCOh36BBg0rtq6++OvU59NBDU2z9+vUptnTp0lKbxFYqRIyIWLduXYqpKJGkUCQqrhKSe23atKnUfv/991MfkunRdT/iiCNK7Tlz5qQ+JFokAaEK0uh6kvjv4YcfTjH9WcqXa665JsVU+hoRcf3115faJOvS8xDB31tlySTMo/FLguNHH3201KaxRLK6qqDvumDBglL7tNNOS31ICqZC9YiIO+64o9QmkfDXvva1FCNRnEpvqWariD0i4n/8j/+RYprr06ZNS31Ijkly6rFjx5bat9xyS+pDIliVtkVk2SbJ2UmmqDU1IucZSS7rEXTuKuqRis6aNSv16d+/f4o99dRTKaa1ctmyZakPiUdJ6Ke5eN1116U+nTt3TjGSP6qYtXnz5qnPa6+9lmIkNtWXB5AIliSbWrcicn2j46LzRXOS5id9Fkkeq4LOm8pVSer47LPPphitP/UFEfUIpiMiPvOZz6SYClFJGknzEIl365mjb7/99hTTtWZExMqVK0ttqjUk2qdarDJXkshT7aeYXjcSylItqhLKIc0PkpHS+SWhs+YfnTeqXSSi13FCc1+vXr1SjOY1Xd/TdaGfo/qvn0Xji9atlB86nkjYTgLie+65J8V0/qJaQILaqqCc0nsselkGXfP58+enmK5T6MUJtI6kl0Go4J/WSbSm05eLROTvSPWf6iytsVWuTfWTPp9e8rBw4cJSm16Ecvrpp6fY888/n2LDhw8vtWk++2tepuO/mDHGGGOMMcYYY4ypCD+YMcYYY4wxxhhjjKkIP5gxxhhjjDHGGGOMqQg/mDHGGGOMMcYYY4ypiB3aNEmKtXbt2lL797//fepDEjsV7URkuc+AAQNSHxIYqRwtIsuQ9txzz9RHZcMREY888kiKnXLKKaU2CXVJuEcCo+9///ul9sEHH5z6kDxWz3NExAUXXFBqk+ytT58+KbZkyZIUU0HSsGHDUp+33347xaqEpGAqZiahGeXx008/nWJ6TUngpPLrCJbCqbCPhLckpiTJlgrsVHoZwflO0uoOHTqU2nRuSAD38ssvp5gKDkm6RRJWEjHqZ9H4os+qChKFff7zny+1Sbqtgr/t8aUvfanUJtEaCaVJ+KxSOBL10bghQaleO8prkmiSFFG/k8qAI/gcUj3WcUNyxXpF8vo7qT5Tra8KyoP77ruv1D7qqKNSH5Iaq/QvIl8nmkfvv//+FLvssstSTOWGNOffeeedKUbCPZ0j27dvn/rQeKPvrRL5uXPnpj4ks7zkkktSTPOF5prNmzen2OOPP55iOt/MmDEj9fn0pz+dYg0JFXySSJ6EzyRp1tpCcwnNe7Qm1XmbhL1UH2jNqGtZkkKruDKC81qPg4SgFCPZtsqYaT1NtYzyX18QQcdOdb5KaG2m54Bk9VSDaH469dRTS+0XX3wx9aF1Eb10QSExLq39KG8Vyv96ZdcqjKWXVtB8S/OESojp3ND9XatWrVJMayitzWndWhU0PnXeIXn6+PHjU+zCCy9MMb0Xv/zyy1OfZ555JsXoZR96LikXR48enWIkF1axPtWNvfbaK8Vo7Oo6ldYdJEs+77zzUkwl7nTslIu0Fm/Xrl2pTfdVJCLfHv6LGWOMMcYYY4wxxpiK8IMZY4wxxhhjjDHGmIrwgxljjDHGGGOMMcaYivCDGWOMMcYYY4wxxpiK2KH8VwWmEVkc+e1vfzv1mTRpUoqRpE2FvSQmIqnUSy+9lGIq9CPpHwmMSJr6q1/9qtQmMd24ceNSjORTn/pU+RTTOb311ltTjERRKtpctWpV6kPnWcVEEVmEOX369NTnq1/9aopVCYnCDjrooFKbxKYkR6SYCmdJ1kTHsMcee6TYq6++utPf99BDD6VYPXJYEviRdE9lfRFZSkUSQZKBkVRWZZX7779/6kOCYxonKs3r0aNH6kNS4qqg66RjqH///qkPSQWHDh2aYiqwJEEhSUVJzNeiRYtSm84tQXJAFXI2b9489SE57/XXX59iWo8ph0lsS+NSzw/V9cceeyzFVIYdkfOY5OkNSbhK85qK4qlu0c+R2FTrG0n5rrjiihSja6c/S/Wa8prE70VRlNok3KM1BUnEdf3w5JNPpj4kLSTB5YIFC0ptqoEnn3xyipFcWNcL/fr1S33oWKtCv3tExNFHH11q0zXRdVIEi3d13bJ48eLUh3Llgw8+SDE93/SyA5WVRnBea/7QeKP87Nu3b4rp2o+Oi8bgwIEDU0zzh14qcdFFF6UYyYufe+65Uluv6/Z+rkpICK71TNdqERFdu3ZNsQcffDDFdO6m3Ka5iISuul6g+ZDmd8orzW2ay1VYHZGFqBER++67b6lNuUcvNaG69P7775faujaJ4BcrkDD8xBNPLLVpLUuS9aogmblKb+mejtbxJIHWNdA999yT+lBe03nTNRbVVKpx+tKBiPwSCXqZAq1FKNc1f2iNTWvzX/ziFyk2YsSIUptqPT1/oHOvawPKO3pusT38FzPGGGOMMcYYY4wxFeEHM8YYY4wxxhhjjDEV4QczxhhjjDHGGGOMMRWxQ8fMe++9l2JHHXVUqT1nzpzUZ8aMGSlGexB79+5datN+7YkTJ6YY7VHT/ZK0f5L26l5zzTUptmnTplKb9rrRXlLdSxeR9wfSfnPdwxnBHg51kowZMyb1Ue9HBHttdM/pCSeckPrceOONKXbppZem2K6C9rbqftQ2bdqkPuSkoOuge40pX+ha0Z7YQw45pNQmT8WFF16YYrTHVF0KtHeXHDC0d1r3wtM5pXxZtGhRiqnfh8ZEz549U4y8AHrdaP9qQ/J6rFy5MsX0u06ePDn1IUcE7SW/++67S23NgQjeszpv3rwUGzx4cKlN15dqPfmqdP8u1anVq1enGHmYdNzQNSf3le4zjogYNWpUqU15TQ6PPn36pJi6FNTtFcG+kaogx4BC32HhwoUpRmNMawvlz9KlS1NM5/eIvFf9pz/96U77RPCe7QkTJpTaZ555ZupDbhHyKKjjiubDpk2bphi5UXRuoT7k4qCY7r2n4yJvQFXo2iki790n7wc59dQnE5HzgPx55LiinFWHDY0jcmCQ70LXUx07dkx9qJ6S00nXkXR9abzRHKH5f+6556Y+6jOL4PGm6yhaqzSkOTqCc+jll18utelegb7HWWedlWJaN2itqR6RCM4PnVtp/Un3InSsmgv0czROaD7X+7l685HcOrp+pppK65phw4almDpUaA1Mx1AV5G7Ua0f3b+Q+0TVdRF530bVUj2YEu7y0XlIO33DDDSlG10mdXLQOu/nmm1OM1srqr73yyitTn5kzZ6bYOeeck2K6zqPnDw888ECKnX322SmmNYXWMNpnR/gvZowxxhhjjDHGGGMqwg9mjDHGGGOMMcYYYyrCD2aMMcYYY4wxxhhjKsIPZowxxhhjjDHGGGMqYofy3+7du6eYSqWeeOKJ1IfEViT/VckTSYFI6EQi0m7dupXa69atS31I5EbCNxVUkZSSpKYk8fze975Xal922WWpD4kqly1blmIqcyJRFAmISe6kkjKVmEVEnHbaaSlWJSTB0nNCEkHKPRKrKXQ933rrrRQjUZ7KslQGHMFiUxLRqZSK5IMq2Ipg4aoKr/bff/+6joEkiyrApe84f/78FOvQoUOKqaTw2WefTX1IolkVF1xwQYrpmKWx2Lx58xSj66SCMRLqUt047LDDUkyvU69evVIfOrckDFRBIYmvSVBKxz98+PBSm+r/gAEDdnoMERF9+/YttVXGGRFx6623ppgK1SOyIJuOi+bGqqhHuEq1kyTiI0eOTLHrrruu1KbcJ/Eo5efVV19datP8SyLJESNGpNjAgQNLbRJy07mhNYWK+ei46PMPPfTQFNNxQwLSf/iHf0gxEtfr8dP3Wb58eYpVBYlINUbzJdUaWq/pfEVzDtVTunb1rIHoJQEU0/lxzZo1qQ+tTUjKPW3atFKbcp/yjsabyqNJfK21MyK/tCIi10p9Ecj2jqFKaH2j133vvfdOfehFBvTSAl1/0vqQ5iJaA2ndu/jii1MfWpvRCyn0xQwkwW3ZsmWKqVw1IuJLX/pSqX3LLbekPnSPQbLToUOHltp0nuu9T9NzSOemHjH+roLW7Vpz6OUqJOmnlzyo2JuuJdUgyn99wQJJg4899ti6Pl9zkdYiJA2meUIF//SiIbrmd955Z4r179+/1Kbz1blz5xQjObWun+lat27dOsW2h/9ixhhjjDHGGGOMMaYi/GDGGGOMMcYYY4wxpiL8YMYYY4wxxhhjjDGmIvxgxhhjjDHGGGOMMaYiilqtVvUxGGOMMcYYY4wxxvxN4r+YMcYYY4wxxhhjjKkIP5gxxhhjjDHGGGOMqQg/mDHGGGOMMcYYY4ypCD+YMcYYY4wxxhhjjKkIP5gxxhhjjDHGGGOMqQg/mDHGGGOMMcYYY4ypCD+YMcYYY4wxxhhjjKkIP5gxxhhjjDHGGGOMqQg/mDHGGGOMMcYYY4ypCD+YMcYYY4wxxhhjjKkIP5gxxhhjjDHGGGOMqQg/mPkrKYqiVhRFu6qPwxjnomkoOBdNQ8L5aBoKzkXTUHAumoaE85Fp1A9miqJ4riiK94qieHub/66u+rj+QlEUny+K4pGiKN4qiuLFoii+VxTFp7b+255FUVxXFMXzRVFsLIpiaVEUI6s+ZvPRaMy5uPXfbymK4uWt/76qKIovVHm85qPT2HNxm35HFUWxqSiKW6o4TvPx0NjzsSiKGVvz8C/H/lSVx2s+Oo09F7f2GVsUxcqiKN4pimJNURT9qzpe89Fp7Lkox/12URQfFkXx0yqP2Xx0PgH5eERRFJOKovhjURTri6K4mtaVjYFG/WBmK6fXarV9tvnvK1Uf0DY0jYh/iIhmEXFiRAyNiH/c+m+fioi1ETEwIj4TEd+OiHFFURyxy4/SfFw01lyMiPj3iDiiVqvtFxFnRMT/KYqi2y4/SvNx0Zhz8S/8LCIW7cLjMv//0djz8SvbHPvRu/oAzcdKo83FoiiGRcR/RsTfRcS+ETEgIp7Z9YdpPiYabS5ue9wR0Twi3ouI31VxoOZjo9HmY0T8PCL+EBGHRESX2HJv/eVdfIwfC5+EBzNIURSXFEXxcFEUPy2K4s2iKJ4simLoNv9+aFEU9xZF8UZRFE8XRfHFbf6tSVEU39r6v0Zs3PqU7vBtPv6koihWb30y97OiKAo6hlqt9otarTa7Vqv9qVarvRQRt0ZE363/9k6tVvuftVrtuVqt9udarXZfRDwbEb4Z/oTR0HNx67+vqNVq7/+lufW/Iz/O82CqpzHk4tbfNTYiNkTE1I/1BJgGRWPJR/PJp5Hk4r9FxP+q1Wrzt64bX9raz3yCaCS5uC1jYstN8ez/79/eNDQaST62iYhxtVptU61WWx8R90dEx4/1ROwiPrEPZrZyYmz5XxOaRcR3IuKuoigO3Ppvv42IFyPi0NhSVP6fbRLtqoj4XEScEhH7RcTfR8S723zuaRHRIyI6R8S5ETGizuMZEBEr6B+KomgeEe239++m0dPgc7Eoip8XRfFuRDwZES9HxKS/4vuZxkODzsWiKPaLiP8VEf/XX/vFTKOkQefjVv69KIrXti5OB9X/1Uwjo8HmYlEUTSKie0R8duvNz4vFlj/X3+ujfFHT4GmwuQh8PiJuqtVqtTo/yzQ+Gno+/jgixhZF0bQoisMiYmRseTjT+KjVao32v4h4LiLeji3/y+pf/vvi1n+7JCLWRUSxTf+FEXFRRBweER9GxL7b/Nu/R8SNW///pyLizO38zlpE9NumPS4ivlnHsf5dbEncZvBvu0fEQxFxTdXn1P/9zedik4joFxH/d0TsXvV59X9/e7kYWybYb2z9//9nRNxS9Tn1f3/T+XhibNk2smdsuQHZGBFHVn1e/d/fVi7GlpueWkQsji1/rt8sIh6OiO9WfV79399WLsq/tdp6PG2qPqf+7283HyOiQ0Q8EhEfbP3cG7c93sb03yfhL2ZG1Wq1/bf579fb/NtLta1XbCvPx5bJ7dCIeKNWq22Ufzts6/9/eESs2cHvXL/N//9uROyzowMsimJURPxHRIys1Wqvyb/tFhE3R8SfIqIh7eczfz2NOhcjImq12oe1Wm1ORLSMiCt29FmmQdMoc7Eoii4RcVJE/HBHP2saHY0yHyMiarXaglqttrFWq71fq9V+E1tuhk/Z0WeZBk1jzcX3tv7fn9ZqtZe3xn8QzsXGTGPNxW25OCLm1Gq1Z3f0OaZR0Cjzcet99AMRcVdE7B1bHlofEFt8XI2OT8KDmR1xmOxXaxVbnvqti4gDi6LYV/7tL3t118bH5NcoiuLkiPh1bJEqLZN/KyLiutgizjq7Vqtt/jh+p2mQNOhcBD71cf1e0+BoyLk4KCKOiIgXiqJYH1vkbmcXRbHk4/i9pkHSkPORqEUE7oM3jZ4Gm4u1Wu2PseV/JfZ2kb8NGmwuChdHxG8+jt9nGjQNOR8PjC0PgK7e+j+gvB4RN0QjfWj9SX8wc3BEfK0oit2Lojgntvyp06RarbY2IubGln3jny6KolNEXBpbZEIREddGxP8utryutSiKolNRFAf9tb+8KIohWz/z7FqtthC6/GLrMZ1eq9Xeg383nxwabC4WRXFwseUVnPtsFXWNiC17Qqd95G9rGjINNhcj4lexZRLvsvW/X0bExKh/37FpfDTYfCyKYv+iKEZs/f2fKorigtiyt/2Bj/xtTUOmwebiVm6IiK9unbMPiC1vKbnvr/6WpjHQ0HMxiqLoE1v+MsJvY/rk02DzcetfzjwbEVdsnaf3jy3bjh/7iN+1UhrlO76FCUVRfLhNe0qtVjtr6/+/ICKOiojXIuKViBiz9UlaxJYbz1/Glqd9f4yI79RqtSlb/+0HsWU/+YOx5U+inoyIv3zmX8O3Y8ursCdt86Bxdq1WG1kUReuIuDwi3o+I9dv8++W1Wu3W9EmmMdAoczG2/C9wV2w9ht1iy58h/kOtVhv/EX6PaRg0ylys1WrvxjZiuKIo3o6ITbVa7dWP8HtMw6FR5mNs8b/9n4g4Jrbso38ytvy591Mf4feYhkFjzcWIiP+99fNXRcSm2OJk+O5H+D2mYdCYczFiy83vXbKNxTReGnM+jo6IH0XEN2LLXD09Ir7+EX5P5RTlLWOfHIqiuCQivlCr1fpVfSzmbxvnomkoOBdNQ8L5aBoKzkXTUHAumoaE83HX8knfymSMMcYYY4wxxhjTYPGDGWOMMcYYY4wxxpiK+MRuZTLGGGOMMcYYY4xp6PgvZowxxhhjjDHGGGMqYodvZercuXP6c5p33nmn1P7MZz6Tfm633fLznk9/+tMptu+++5baBx98cOozbVp+Y+9+++2XYnQcyp577plif/zjH1Ps1VfLLwDp1atX6kPfZ+XKlSnWtGnTUvuNN95IfQ488MAU03MTEbFs2bJSe9OmTanP0KFDU2zy5Mkpdswxx5Ta69atS33atm2bYjNnzixScBdx0UUXpXzU/OjXL7upFi7Mb/pr1qxZiu2xxx6l9qGHHpr60Hmiz9fzqzkVEXH44Yen2EsvvZRiY8aMKbXfey+/WX358uUpRt9xxowZpfagQYNSnyVLlqTYEUcckWLvvvtuqf3nP/859enUqVOKHXbYYSn2wQcflNq333576nPOOeek2A9/+MNK8nHEiBEpF//whz+U2vTXiAMHDkyxjRvzCw2eeqr80pdPfSqX6iZNmqRY8+bNU0xrEMCahQAAIABJREFUFR3Xa6+9lmI6HiJyXVqxYkXq07NnzxTTcxMRcfzxx5faDz300E77RES8/vrrKfbhhx+W2q+88krqQ+ON0DrbtWvX1Ofxxx9PsUcffbSSXPzWt76VLqiet9/+9rfp51q1apViTzzxRIqNHj261KY5WcdvRMRxxx2XYlozdD0Rwdf36KOPTrENGzaU2mvXrk19hgwZkmKLFy9OMR03b7/9duqzfv36FOvRo0eKHXDAAaX2okWLUp8WLVqkGM0t+lmtW7dOfVavXp1i11xzTSW52KpVq5SLn/3sZ0vtF198Mf0cjXPKRZ2TN2/enPrss88+KfbWW2/ttF89a9QIrp96DejnaD1BazPN2SeffDL10byI4ON//vnnS21dl0RE7L777ilG88E2b0KJCJ6TaE1aVV2MiDj//PPTxdL6TvOC5mwEz4c6Z7Vp0yb1obmPcvT9998vtWneeeSRR1KM1lj6WTRfUQ7R79Q6S7Vr6dKlKdaxY8cU0/E6derU1IfmDcpHrfcjR45MfVatWpVi06ZNqyQfzzrrrJ3WRsoVHcMRPHfr+F+zZk3q0759+xR74YUXUkzXU5Q/VG/ouLp3715q070KPTM46qijUkznblprTpw4McUoFw86qPzGbqqzdA+81157pZiO+0mTJqU+9Bxhe/O0/2LGGGOMMcYYY4wxpiL8YMYYY4wxxhhjjDGmIvxgxhhjjDHGGGOMMaYiduiYof2iukft4YcfTn1obxjtQVenDO2vq2c/b0TeJ3rkkUemPo899liKkZNEvyPt8aN98P37908x3Zeu+9oieD87uW903x/ty6bPOuSQQ1LszTffLLVprzbtPawS2rd35plnltrkAejWrVuK0XXQnyWXC40JdcBE5H30tEf2tNNOS7Frr702xXSvPV1PilGOqiuG9vufffbZKfbcc8+lmDqV9FpEsFtn//33TzE997QXlj6rKsjNo74VcmHRXlraC9yuXbtS+09/+lPqQ3t1yVeleUy+BfIMkFdI6wTtqSenBn2W1nZyFhC0N17nDtoHTHMQnQt1Mz377LOpj9biKqG5YsKECaU2OdjU9xIR0bJlyxSbO3duqU17y9VDE8GeqAEDBpTa5BGh+qB+i4jsEaI5jFxD5Pp45plnSm1yhPTt2zfFZs2alWLqw6HaT64P2p+vx0Vjizw3VUH1R69xvdeJXGTaj1wgtF6j30lONIW8gZQbes3JuUFrM1o7zJs3r9Sm3Kcxol6yiOxFofN87LHHphjlrM43VK/33nvvFKsS8laecMIJpTbVM7oXIQfaeeedV2pTTaV1ADlm9L6GrietZcl9o/lHv4/mw/vuuy/FLrnkklL7tttuS330nEZw3upah+7TaE1KdYXWiIquo6rk0UcfTTG9LlTL9V4tgj0/em9CY5juUek+R+sqrR8oRmtSXT+R+5LWU+Rc0/NF9Zl8MuTu1Jyi+YDcOrQOePnll0ttegZC13F7+C9mjDHGGGOMMcYYYyrCD2aMMcYYY4wxxhhjKsIPZowxxhhjjDHGGGMqYoeb+mk/2p133llq095F2v9K7whX3wLtByWPCu2J0+OgPWvkQyBvhfoQaP/k7NmzU4z2Rj7yyCOlNu3npe/TqVOnnX4+7V2l7037LHUvIPXRd8ZXzbBhw1JM93vT3m7Kofvvvz/F1LNBP9ezZ88Uo33beq1oPywdA+3b1n24e+65Z+pz9913p9i//uu/ptgPfvCDUrtLly6pj+ZsRETz5s1TTPdRkuuCnBVz5sxJMd1/Tw4GckRVBe1/1f2unTt3Tn3I+0MuBa1LNNbJ2/LOO++kmPqUKMcoh2nvvbqGaF8ueR9oz74eK+1Jnz59eoqRH0rnjrVr16Y+lMP0O/W80r7pIUOGpFhVUE594QtfKLV/+tOfpj50fcnfo3Or+jQiuGZQ/Zw/f36pTfPV8OHDU4xcdup3+M1vfpP6kFuExk3v3r1LbXItkLuE8kBdaKecckrqQ3lHTgntR64pdQBVyfvvv59i6iIgrxP5Cshrpp9P9Y7WeXTN1TtAjh/6LPIa1OOn69q1a4rRekXrM/kKaN1NfhOtg+SAoVpJn6Vz8qpVq1Kferwfu5J65unu3bunPuQDGTt2bIppfaG1GflRZs6cmWLHHXdcqU2OR/UPRXBe6XUgtx2t78mdp+OQcujBBx+s67h0bUD1grwzdJ+m84vOLRG8tqqKpk2bppje06inMILHIvVr27Ztqd2nT5+6PovWN9qPcpj8r1SX1P9K11IdLRERvXr1SjFdp9I1p3u0wYMHp5jefw0cODD1WbBgQYotW7YsxdT9RI5DWgNvD//FjDHGGGOMMcYYY0xF+MGMMcYYY4wxxhhjTEX4wYwxxhhjjDHGGGNMRfjBjDHGGGOMMcYYY0xF7FD+S2IdlUrVIwuMyGKriCwtJJnQG2+8sdOfo99JokeSFpKEa9OmTaX2HnvskfqoLDCCZV0qTSJxJYkNSRSkUmU6DyrDjWDZ54YNG0pt/c70+6qGRKMqZKTcI8klyVTPPPPMUpukeGvWrEkxOr+tW7cutUn2SGJBkmSr4JAEkHTdx40bl2IqeaZxOXHixBQjOaPKzEhe+cEHH9T1WVpHSBBMguqqIPGhfq+FCxemPjTOSHann0U1iGTjJObT/Ny4cWPq06FDhxRbsmRJiulYIjEl1S4ab9qP8nrUqFEpRkI2Og5F5d4RLChUSORJ57kqSHCoQlgV8EWwuJYkvnrNVZoawZJdqnkqoTzppJNSHxLrU41dvXp1qU3zFR0XiTAXLVpUao8ePTr1uemmm1KM1j8jRowotUmG/etf/zrFSIQ8dOjQUvvNN99MfRqScJXWJFrfVPQewfWtX79+KabSS6oZJF4k4WSTJk1KbRKrUq0kKaXWMqrz9B1btGiRYrqGodwn2T8dl66DKRfp3FANV7moCi8jWHBaJST/1TU5vYSB1pEk2dYXg+i6LyJi6tSpOz0GOlZa79BLEWidp3Xp5JNPTn1IZk7XT2WndN1pLpkxY0aK6VxFcwS9RILWSLo+p/pPY6cq6J5R5zq6V+nbt2+K0X2I1kJ6oQOdI/qdmtckWacY3aPpPQD1oetEAm79LJ0fI/jegfJM16Qkm6e1Dp1D/VmqO82aNUux7eG/mDHGGGOMMcYYY4ypCD+YMcYYY4wxxhhjjKkIP5gxxhhjjDHGGGOMqQg/mDHGGGOMMcYYY4ypiB2akUhsp5IbEg+S3IdkaK+99lr5YOqQ1EawqFIFZiS2IqkUSYJVYEfSYBJvklhNJUokoHz66adTjKSXDzzwQKlNgjKSC5PcTY+L+jQkcVZExOOPP55ies6pDwnNSN6p8lqST6kwMCLi0ksvTbE77rij1FaxcETEwQcfnGI0nlRSRUKqq666KsXefffdFFNhJtGlS5cUI3GV5h9JO0kGSeNXxZck/SZJWVWQbFZlayR2pDFFgmQVZJLkknKFZJWaBySFe//991OMpKIkeFZojGitj8gySZKnk0CQ5gQd91Rnn3jiiRSjnNI5jsYpieqrgua6Tp06ldo0zz322GMpRtdO+5HokYR7JLPV45gwYULqc8ghh6QYnW/N65YtW6Y+dO2olukYpPl9zJgxKUYi20MPPbTUnjJlSuozaNCgFKPrMX369FJbr2sEiyCrgnJj8eLFpTatK2kNROs1lR/TXDVr1qwUI8m95jrlCknLaY21cuXKUvub3/xm6jN58uQUo7WyXmO6viqYjmDBpc4HS5cuTX2oNmhtjsi5TmsoepFFQ0NFsiTUJeE71QStJSQIPv7441OM5kOt4/TyCZIyk3D4iCOOKLVp3XfZZZelGL2YQesqreloTUHCXhVgU57RCzCoFuh3IsE9jZOq0BoRETF48OBSm8aPCs8j+HzrPR3N5bTeobl1/fr1pTZdS5IZ0/FrXT322GNTH1pX7rnnnimmcwndm9Paj9Yi+vn0+0488cQUo5qtMu9WrVqlPvXce/0F/8WMMcYYY4wxxhhjTEX4wYwxxhhjjDHGGGNMRfjBjDHGGGOMMcYYY0xF+MGMMcYYY4wxxhhjTEXs0O5KskQVDJGwjuQ4JJdUeRjJc0lgRJKz+fPnl9r7779/6kOSzbfeeivFVGpKAjiVWEWw4FhFlZs3b059TjvttBSbOnVqiqk0iURdKguMYEGSni+SmZJks0pIAKZSv6FDh6Y+y5YtSzGSpKpYkKRwJI4kKZweBwkP27Vrl2KdO3dOMc3l8ePHpz7Dhw9PMfre2o+EZCSTI+Hw3XffXWqffvrpqQ+JCym3VdD8zDPPpD4kwK2KdevWpZgKtPfdd9/Uh2oECfBUZEf1hgRwVF+0hnbv3j31oZpN31HlniSTI4lax44dU0zlhjS2aN7o2rVrium8pLkZwdI5FbVGZFnd8uXLUx86N1VBdUTzbOHChanPwIEDU4zEpioHJSnl5z73uRSbN29eiulxkHiUZIdnnXVWimlu0DxH+UPXrkePHqU2zX0kJCfJn66b9LMjIm666aYUozGin0Vjl9Y1VfHII4+kmArPSe68atWqFCNJvNYpkrS2adMmxajGqqiS1nmjR49OsWeffTbF9AUAKs+MiLjoootSjNYOmlO6LolgWTLNmVqL+/btm/rMnDkzxWgs6bmmuZ0ErFVC9w9aX2iepvUhnROV+JKMmkS/tJbVdRet7+nlFuedd16K6T2Mzo8RLEklEazmkIqFIyKWLFmSYvXcg11//fV1/RyJuem6KZTb9LKOXcFuu+W/g1DRMc07dE9A4m29TiS8VUltRBYQR+T8oXUSja1//dd/TTGtEyTBJVk6nYv+/fuX2iTfp5e9UJ1VGTvd99C8QesaXTfRvETPGraH/2LGGGOMMcYYY4wxpiL8YMYYY4wxxhhjjDGmIvxgxhhjjDHGGGOMMaYiduiYUX9HRMRhhx1Wau+1116pD+2von366jWhPbK037xfv34ppj4Qci3Q3kXaj6Z7wmlPJe0bPfXUU1NMvxPtT6O9h7RXV/eETpw4MfUhTw/tQdf9mbqnMIL3z1fJ2WefnWI33nhjqf2Nb3wj9enTp0+KkXNB9xDfcMMNqc+wYcNSrB6nBu1PJp8DuWh0r+gXv/jF1If2L3bq1Gmnx0rejXfeeSfF5s6dm2K6n5o8AbQnmo5fXQp0TskXURWvv/56ium+X3Jx0N5g8qFozaFrSeOaxuwLL7xQapOjq0WLFilG7hKtVeS+ITcE1TjNa/o+VLNp7/SkSZNK7fbt29f1WXfeeWeKDRgwoNSm80XXtiro+HRP+KhRo1Ifqhm0l1xdVQ8++GDqs2DBghSjMaz7uGmPOM23M2bMSDG9TnPmzEl96HuT30F9DuRM6NmzZ4qR/0PHxJQpU1KfXr16pRj5+jRnab1F/q+qoHWLrsVoTTdy5MgUI6eP+hbIHaBOmwj2oej6lmrGyy+/nGLkc9N5m3xB5O+g66keHXKN0HxAa1J1Ej3//POpDzkmyF+m45kcH7TurhK67hdeeGGpTR4S+v40h6kvg/xndI9BLkRdz9P5JSfXc889l2LdunUrtR944IHUh6475aP6Xaiu01qW1pHqVOndu3fqs2jRohSjOqu5RsdA47cqyO9y7733ltrkG6VxTXOkutNobqV7bDouXfvRWlCfBUTwGl3naXquQGsY8heqO4+uL7koaU7QMfjUU0+lPjS2aN2kzzfo3P81XkL/xYwxxhhjjDHGGGNMRfjBjDHGGGOMMcYYY0xF+MGMMcYYY4wxxhhjTEX4wYwxxhhjjDHGGGNMRexQ/rvffvulmMq0SBb17LPPphhJjVTy1LJly9SHJIskHVLJKAko27Rpk2JDhgzZ6e8kqS+JTulcqCT0lFNOSX2efvrpFCNJqMoxL7744tTn/vvvTzGScKlMi8R0JD6qEjoeFfGtX78+9Zk+fXqKqUg5IuL4448vtb/whS+kPnRdSIyln0/SNpJQkoRVJVj0HUnIptK2iCxUpLE0fvz4FCMR3R/+8IdSW2XeEVnWFRFx++23p5ieLxIxUl2pikMOOSTFVJyqEseIiLZt26YYyR3180l+etJJJ6UYiUD1GlNNpetE8jW9TipKj4h49NFHU4xkdSpbo/lGcyyCxcv6+Rs2bEh9SCaqAuuIiPvuu6/UVuFoBIsgq0KFuhER06ZNK7VpPqSaTzVJx93AgQNTHxLiUf6orG/06NGpDwmlSSqr4leSRxOUBzq3qLAwguu8nueIfD1mz55d13FRzp511lmlNslMBw0aVNfn7wroJQJ6XUjESPXn1VdfTTHNTxJXUozmE10PUv40a9YsxUg4qeJRqv0kxlQ5b0ReD9LLLkjATXOLijDp3NCx0ss69GdJkEtjpEroeB5++OGd/hzdr9D6U9f8JP2ktdnPfvazFHv33Xd3+NkRPL7oO6pMlV4qQdQjw6f1J4l3Ka90nqY1Hc1ntF5X4T/1oXmjKujlAzq2aQ1NInoSyer9c5MmTVIfWgfQ+kbPG+UwrRXoxT9670DnQV/iEsFzsN7TkOiX1rc0Bx955JGlNt2H05qUYnqsJKWnF61sj4azujTGGGOMMcYYY4z5G8MPZowxxhhjjDHGGGMqwg9mjDHGGGOMMcYYYyrCD2aMMcYYY4wxxhhjKmKH8l8SJ6lshwRDJAr63e9+l2InnHBCqU3iSpL7qDQyIgt6SdrWt2/fFPvwww9TTIV7JKujzyI5mMp+SQq0evXqFCMpscqWSEBM537p0qUppmIxkr0dffTRKVYl8+fPT7FRo0aV2iTYI8EnySrHjRtXah933HGpT9euXVNs7ty5KfbFL36x1CZhVNOmTVOMxKl6Tek8kMizZ8+eKbZx48ZSmwSLI0eOTDGSjam0luSVKrSLYHmrHtczzzyT+pDMuCroWFRUS31IfEbnTeueiqkjWEJJcjetOSQLpFykuqQCMxLAkUxu1qxZKTZixIhSe9myZanP1KlTU6x3794ppoJzqtkkICYRrAqNVeocwdesKkgMrblXT45FsMxZxysJLkmcWo9gnY6BpJck7td+dC1/+ctfptiXv/zlFJswYUKp/Xd/93epD4k3adyo9Jjqqb6sICLisssuSzE917RGWrlyZYo1JLS20zV//vnnU4zGsOYZCUZp7Ue/U+s1yRlJTvrEE0+kmI4vqoFURyZPnpxiKnOmXKlXcKwy18WLF6c+JBylY9U1Uz2y4aqhF1+oqJYEzHSNSUquMapBND6pNuq8TGs6qkF0n6brYMoNegkDvdTgySefLLX79OmT+tBLK2hO0JpN91+f/exnU4zudfQ+je6tqD5UBUmnVYxLcncaiyqujcgiero379ixY4rRmNVxQ7lI9Zle1qD3n/T76LM2b96cYrrepDUw3V/Qultlv4MHD0596N65W7duKab3K5R3dM+5PfwXM8YYY4wxxhhjjDEV4QczxhhjjDHGGGOMMRXhBzPGGGOMMcYYY4wxFeEHM8YYY4wxxhhjjDEVsUP5L4lvVHL22muvpT4kPiOZp0ICKYJEQSqRItkVifoWLlyYYiqJJCHTAQcckGIk+1QhFcmRWrdunWKbNm1KsfXr15fajz32WOpDUiiS4an0lcRZKv2qGjpPKm0kgR9JsEaPHp1is2fPLrVJRkrSZ5KhqeiJhJkTJ05Msb333jvFVIzYr1+/1EdzI4JFwioNJKks5QLluwrBSCBN32fo0KEppj9Lv68hCVdJyKhiaBJ1qowxgkWOKhUk6d97772XYiQ71PFPEkPKT5IKau195ZVXUh8V2kVEHHbYYSmmP7to0aLU59xzz00xkqyrBI5kdfUK2VROR+Juuh5Vcd5556XYb3/721K7ZcuWqQ/NVzNnzkwxzQM6HyS9JBG9/s5hw4alPiTqo1wnIaRC8209wlUSKtcrmtVa/Oabb6Y+NN5ozr/33ntLbZIzN2/ePMWqYu3atSmmazE6ZzRPkDBcc4/WjCSXpM9XQepNN92U+pAsk/Jf6witHUjMTnVE1zR0fWk8UM3TvKa5hsYbid/182k+rmedvyuh76bfg+rBihUrUkxfNEGfRVJfkpGScFlr1Zlnnpn60As5SJauuf3CCy+kPrRmpBqk5/C2225LfehlJZQLKlxVUXoEr2HouHR9pS+jiGCZcVXQsei9Cd2r0Dmi86FrM6qNlNd0XHqvTC//oPUa1Ua916Q+VBvpvvuYY44ptamuk7CdhNL6QgG9/4vgcUP3X1qP6aUn9KKM7eG/mDHGGGOMMcYYY4ypCD+YMcYYY4wxxhhjjKkIP5gxxhhjjDHGGGOMqYgdOmYI3eNF+/11H2FERK9evVJM9xKS+4C8MOQroL2zCu15LIoixXT/HjltaC8p7fvV/c4HHXRQ6rPbbvn5GPl9dK8e/T7aU0v73XQfHvkk6NxUCfkCNB9pfzntVaT9fp06dSq1e/funfrQXkvKR90XSj4E3eMYwW4kjZE7hvbXkldizpw5pfZTTz2V+tDeZtrTqueiVatWqQ/tF6Z9roceemipTdfxrLPOSrGqoPO9ePHiUpucFPo9I/i86WeRk4LcA+SFUv8KXd8PPvggxTRXIrJzYeDAgakPOWYorzdu3Fhq0/VVV0oEOzvULUW+I3L+0BjZvHlzqU31U71PVUKuKp1LKX/ITTB37twUO+OMM0pt8goNGDAgxciHoOdb57QIHltPPPFEij3yyCOl9rx581Ifqlv33XdfiulxDB48OPUhaAzqXnVaD9FxUZ6dfvrppba69CJ47FYF7e/X46MaSHMa5aeuxWict2vXLsW0BkbkMUE1isYD+Qq6dOlSapPrj8YNnQtdW9I6jzw95LWpx9tIrhFyvOm5pz5Um6uE1rBa32ldSW4h8mgtWbKk1FY/5f/L3ptH+1WVeZ/PkUGQSUADhDFkgExkJgmZgYxAmMQoiFq2tpbl0tfqWt1dVa/1vv129bK6rFnRLqstfUsQiiEQQMgACSEhc8gcEkIgZGAMgzIZIPz6j3vpN+f7fG7uTwrZN/j9rMVa7if7/u75nfPsZ+9zvPtzIti5SettdShSH/IZ0rym6wdat9I9EznXNIeaWftE8Nyq9yfkRSJ3Ca2VtYbSHEf3bqUYNGhQiukcRk4Tyk/ytGgNovtKql3NuPeoDtI9VDNeOepDri2qobfcckutPWrUqNSH6j/5sJYuXVprn3nmmakPOWzIRaNjicYueaXawn8xY4wxxhhjjDHGGFMIP5gxxhhjjDHGGGOMKYQfzBhjjDHGGGOMMcYUwg9mjDHGGGOMMcYYYwqxXzNSM3IfEvaScIskeQ888ECtTYInkruNHz8+xV544YVamySYKneNYOEeiQbb+30RWb4UkQV2JMkiKRxJU1WWSdI/EjmRqFIFSSSYo+tREjoelSyRTE8FwREsXP3FL35Ra/ft2zf1ueCCC1KMJHgquKVj2LFjR4pRfujYIfGf5kZExOzZs1Psi1/8YrvHsHv37hQjEaNKj1WEFxHxyCOPpBjlmsq/Jk6cmPr8/Oc/T7G/+Iu/SLEPApK0NTNetmzZkmIkaTvppJNq7YMOOij1ue+++1KM5IBal5YtW5b6TJs2LcVInKc1lCToKr5uK6b5QoJOkleSxH3NmjW1NuUwie/oOup3JHEciUJLQSJZPWY6ZzQfDhgwoN3PImEvidLnzZuXYlq7VAwYETF9+vQUo3GjslMaI1RPzz333BTTPKaXFZC0nGqZiqjpO9Iag4SOKmcncfHgwYNTrBRUD3SN9eCDD6Y+n/3sZ1OMhPkqP6Y1EI1pEp2qeJTWjD179kwxEtyq1JTWxRSj2qLjmeZoWh/SSwhmzJhRa9N5oLU5nUOVcdK6UgW2pVHRb0Re+9G8cPPNN6cYreF0bqV7JrouJOzVGkri0VmzZqUYyXhV3rpnz56mjoHqv8rLVQYfEbFz5852fy6iOSk9rYdoDOg40TVTBMuFS0EvdNH6RfWTXhhDIuolS5bU2vQCDfosiukYobpB9wQkv9bco3UyyX9JSq6yX1oz0guJSNirLyzQ8xfBawoab5qfVFNo/dAW/osZY4wxxhhjjDHGmEL4wYwxxhhjjDHGGGNMIfxgxhhjjDHGGGOMMaYQfjBjjDHGGGOMMcYYU4j9yn9Jaqqyq9WrV6c+Q4YMSTESOqk8iERQzYrzRowYUWuTLOq5555LMRInqki1X79+qQ8J0+g7qrySpMEk5lq+fHmKqUSMREskzCO5k0qmSFa0cuXKFCsJXaszzzyz1m5WsES5pteKpG0qv45gwZxKA1VaGMEyQJW2RWSxIAkPSbg9cuTIFFNxIcmiSbhN537u3Lm19vnnn5/6kLST5JsKSS7pWDsSKkUlcSTVJcpFFYiSCE3zIoLFZyppJMGfSkYjIj72sY+l2FNPPVVrNyNSjeBc1+OgYyAxOkkRNT9JfEdji2qvChxpHqQ6XgqSUmpNIkle9+7dU4zErCpBP+uss1IfmneuuOKKFFOZHsn1VOje1nHp2mDr1q2pT+/evVNM54yILCUmsSH9HPXTOkDjiCShKrCm4yL5PImdS0HXXCXfWkMiWB5KwnCV3tK5pTUjzV9r166ttS+55JLUh+oD5YH+ThqTtAYgEaYKgUnWTrJ/EgnrGCehO9VKymutn/R9OlJdjOA5Rb8HSdAvuuiiFKO5VSWpJIam+5WhQ4emmNZZmq9oTUdrXhWUkqRcXwASwWJ3zW0aS3SsRx11VIrpyznuuuuu1IfGDsmodc1L62IaJ6Wg+zAVvpMwmdZT9F31fNNYpPs8Ekrr55NYme536Xfq9SR5Lt3LkrhfryetD+ma6/OBiDznjBkzJvVZuHBhipHgXNe3dAz0Ypq28F/MGGOMMcYYY4wxxhTCD2aMMcYYY4wxxhhjCuEHM8YYY4wxxhhjjDGF8IMZY4wxxhhjjDHGmELsV/5LsqIZM2bU2iSgJCHM3fpVAAAgAElEQVTP4MGDU0ylUq+//nrqQ6JKkpwtXbq01lZpXkTEiy++mGKjRo1q97hUyhXB0sJ169almAqSSJikEroIljWqdIjkeI888kiKDRo0qN3juvPOO1Of30ZW9EFAkrMePXrU2iSuPfLII1OMhJ4KCcdIwkryPBVkkqCR5LDNSEvpepIgcMmSJSmm8sQvfelLqQ+JrUkaqGOMBKAknSMBro7pJ554IvWZPHlyipWCBHVz5syptal2UV0iqbHmy+7du1MfqkGU6ypkI9mh5kUEC9k0Z0nES/JNuuaa6yqTbuu4SBSq+Tl27NjUhyTdJKJT0R3JG+kYSkHHN3z48FqbjpdiJMtV4flxxx2X+lCuk6BQ5x2qUVTLSIrYaDRqbZJok7yV5vyBAwfW2iSupLmb5mmFJPqnnHJKilF+XnfddbX2ZZddlvp0JMHlAw88kGIqSCVhL9UHqlMq/CQZP+VKM8JJOi6qzcOGDUsx/VkSBFN+3nHHHSmm624S8dJ8TOdC6yflMMlcSfap8zuJYmm8leS8885LMZVs00seqC7RfYeuEakPiYTpWmkdp1p80003pRitsXR9S9eY7t2mTZuWYjQ2lT59+qQYycxvvvnmWpvurWickABX+9HPdaTaSNdA19q0fqP7acpZnYtoTqbaSLVEx/+iRYtSn8985jMpRi8hUSE25R2tFaj2qoCbPouOge79db792c9+lvrQPRrdm+iLheilGLSWbQv/xYwxxhhjjDHGGGNMIfxgxhhjjDHGGGOMMaYQfjBjjDHGGGOMMcYYU4j9OmZov1szXhhyVKxYsSLFdN8XuTNOPPHEpmLdunWrtWk/H7kPXnrppRTTvZ20j4325dH5evLJJ2ttdfREsK+C/DHLly9v9/fRPratW7e22++Tn/xk6kOfXxJyjOh1pmOm70Z7GvU60L50yj31yURE7Nq1q9betGlT6kP7X8nTMnHixFqbnES0V5fyVvcek0eKcu/ee+9NMT33VAvo88nTo3ubb7vtttSH9omWgq7d1KlTa23ywuge2Qjez6970Glck49I8y4iuxTUORPB3hA6ri5dutTaNB7o82n/9+LFi2tt8nrQOaScOvTQQ2tt2gdMDglyLqjTiVxbe/fuTbFSkM9C/UNUO+kcUR5oraTfR/Mo5YZeA3IUHX300SlGXpjp06fX2rSnnuYD2ruutZ7mTPo+mncR+dzTz5Hfh7xno0ePrrUpX2k8lIKunY59dc60BXnZ9LPIAUDnkfJT84Dm1ZEjR6YY+Ra++93v1tpUaygXyaMzb968Wps8RjQGaf7VuVzXo219ljoTIrLngxxkVPtLsnr16hTT/KN6QA4ouq/RewVaO6kLK4Jdc3rO6X6F1rI0t9533321No058twsXLgwxfRckFuIPDdUQy+44IJam9a7Dz30UIrRONH6oJ6wCD43pRg6dGiK3XPPPbU21U9yDdE6T+9DyD3Xq1evFKP7br125BAiFxy5b9SLRnMfraeotqsXhsaWOm0ieN7UPOvfv3/qQ+OZHDZaQ+nck0OuLfwXM8YYY4wxxhhjjDGF8IMZY4wxxhhjjDHGmEL4wYwxxhhjjDHGGGNMIfxgxhhjjDHGGGOMMaYQ+5X/Ll26NMVUhkOCHhJVkvisa9eutTaJyUgwRtJClbuRDJU+n+Rup556aq1NIuHDDz+83WOIyMI0EhTefvvtKUYiN5W5khhz3LhxKUZiLr1GJBoj4WtJSOSlUjDKM5V5RrBgTK8VSRVJeEWiuDVr1tTaJJEiwe2FF16YYirLJakvSdRIQPjLX/6y1iYp3I4dO1KMJJ06fu+8887Uh8RlVB/mzJlTa5MQ+7eRZ/2uUcFnRJZzU/40UwcjsrSQZMMkIyS5sP7OLVu2pD5XXnllipGMV783XUsSGy5ZsiTFNI+HDRuW+qxbty7FqPaqDK979+6pD9VUOtb169fX2iR6J3FiKWiOXLVqVa1N55EkdiTO02tOsnOS95HIUMewzrURETfddFOK0Zx/ySWX1NokxiTROAmOdezqXBDBMniS/+p8S+sHWjf99Kc/TbGvfe1rtTbJOZuV6X4QkDS2R48etTbVwEceeSTF6HyrkJzGIc0TdA10TiY5Z7M1Y/v27bU2rQlofUi1WOWqNI+Q1JZyUX+WxhuNEVoz6ueTnJkEmiWhOUXXZvRiEhr/JIG/++67a22S1NJ1oblV71nuuuuu1IfGDuWjHitdd8pHWnep0Pn0009PfWhtTmtezTWdpyL4HoleRDBkyJBam84zrYdKMXPmzBTT67Rnz57Uh17yQOh1otpIcm59CUNEXhtQ/owZMybFqM5ef/31tbZet4hcPyM4p3Rdp/N2BIt+qR6rsJfWlVQbaS2rcwc9f6Ax3xb+ixljjDHGGGOMMcaYQvjBjDHGGGOMMcYYY0wh/GDGGGOMMcYYY4wxphB+MGOMMcYYY4wxxhhTiP3Kf5uRVz799NOpD4kqSViqckCSSpGsiKRAKnw7+eSTUx8SVZLYUWVLdB5IMEdyMBXokkxo586dTX2WyrSOPfbY1IfODUmcVcC0efPm1IeEWyUhOdP8+fNrbZIu0XdT8VNExFNPPVVrDxw4MPUhKRzlguY29SHRGomrtm7d2m4fOi4SBH7961+vtekak6RKhXl0HCrjjIi44447UozErI1Go9ZWAWJEvj4lIUnbqFGjam0SMpOEjMSXOtbp50jSTMelNZtkcitXrkwxvSYROTdI0ElSQcozlaiRDJsE1iSiVlkd5Q+JqGl+UREyiXNVNlwSEiiqCJfmBcopms9V6EnXhIS6JAR+++23a22af7/61a+mGMm2Z8yYUWtPmjQp9Xn44YdTjATugwcPrrUvuuii1IdyhQT8eqzPPvts6kPnhtYZ3/nOd2ptEn7rsZeEhJ8bN26stWktSOJmium6iKTQ9HO0JtWaRLmiNT2Cxbj6syRp3bBhQ4rRmkbPoc7/EXkcRfB5VRkn1WGq4SQE1fmeauymTZtSrCQvv/xyio0dO7bWpvmQpM8kCb788strbapnJPen66AvqSAhP81FtE7VtceJJ56Y+tC5oc/X+zL6jiSxJpG85gydZ3pJC0nFSbSsUL0sBdUEheY5itG10zFL4mvKdVrnaU2gNRetO955550U0/ynewKaN+h3duvWrdammkf52cx6jc4pzfkkPdafpZfLNHP938V/MWOMMcYYY4wxxhhTCD+YMcYYY4wxxhhjjCmEH8wYY4wxxhhjjDHGFMIPZowxxhhjjDHGGGMKsV/5LwnGVL7zr//6r6nPueeem2IkTFMxGUkFSXxG0lsVDKlwLiJi0KBBKUaiOBUgknyJBKwkHVLpK0lUSaJGEk86VoWEoCQHVFmdyjMjIl588cV2f98HCQmVLr744lr7xhtvTH00ZyNYLNWjR49am2RQp556aopRP5VSkYiXxJGU25ofJLyaPn16il1xxRUpptI5kmKRyJNExZofy5cvT31o7JBcWIWxWhvaOoZSdOnSJcXmzJlTa5OUj0SLJP9WWSvVz49+9KMp1q9fvxRTIRtJyE477bQUI1Gc1miqgzRvkBBYazTVT6qDJE4l2btyxhlnpNi8efNSTI+DxKEjR45s9/d9UNB3V9Hxv/3bv6U+48aNSzG6TloPSOpI105llhERjz32WK1N0j8SPVKt1LwmyTvNfSTW1zxTeXsEC9wpP3Weopq+bdu2FBswYECKrV27tt3fR4LCUtB5+8QnPlFrk2B0+PDhKUbnW9dPlPuPP/54itHaSWsxCfTpZQ0khlZxM8m2aTxQ/uvcQueBBKk0Rnr16lVrU67QyyFIHHrrrbfu97Mj+HuXhATnuhaj9SHNrbQe1jmS1i00Zimmx0XrPMp3enmA1mjKM7pWtDaYNWtWrX311VenPiTWpxzVlwzQWnPChAkpRsJYnSe0VkaweLkUdJ+gUmYSTNO4Jnn0NddcU2vTfEiCefoszQOSNFP+UM7qPTytFZrNRV1v0tp5xIgRKUaSdb2vorUP5Q+9hETrDH2fZu7f38V/MWOMMcYYY4wxxhhTCD+YMcYYY4wxxhhjjCmEH8wYY4wxxhhjjDHGFGK/jhnaq6ueB9pbSM6UTp06pZh6DWhPIvkoyLegeyjJmUJuAtr3p5BHgfZS0x5U3UtO+81pf/WGDRtSTPfqkU+CnB50HXUPMe3V69+/f4qVhM7TwoULa+3Ro0enPo1GI8VOOOGEFNMcotygn6N9xerwoT3beuwRvLdZnU3keCB/Bu2ZV/8HnRtyMJAXQP00dG6oFixatCjF9HuT/4LqQyloP6oe8xNPPJH6kK+E3DlaN+haqgsrIuK1115LMd2XTnt8aQ8x5QbVJYXyZ8uWLSmmuUi5f+aZZ6YYnQute7Snnvb1X3jhhSmm45nOs47vktB40u+g/qyI7A6I4DqiXhga5+SFIdRRtH379tSHnAk0b+qebcrrZ599NsWon+Y1OWBoPFBNUu8EOULIXbJgwYIUU2h807GWguYJvXaUP+qeiGCfhq55aL1D45X8PTqPkj+uZ8+eKUa+Ap0PmnUn0bXTMfjLX/4y9SHHFdUBzT1y651//vkpRu4t/VkaD/S9S0LHqHMKOTzUixQR8fWvfz3FNN/pvoDufeheZMqUKbU2eTI3bdqUYuQIUdcHeTFojUVOTz0/5JCj8UvztDo7Hn300dRn5syZKUbeUj0Oym2q/6WgMav3snRvO3Xq1BSjeVPXJJTD3bt3TzGab3WeOeuss1If8smQl1BdXlQHyXOl4yEirx9ofUjzLfm9dI1EawzyZtI6VfOMxiTNe23hv5gxxhhjjDHGGGOMKYQfzBhjjDHGGGOMMcYUwg9mjDHGGGOMMcYYYwrhBzPGGGOMMcYYY4wxhdiv/JekYCrOUwFfBIskSUDbt2/fWpskXCTRIbmkSrfouEjaQ0LIbt261dokC9yxY0eKkZhPZZ8k1yIxF0nU9DuRGFlFSxEs2FLhE0mnSGRWEpJUqdTvhRdeSH1IEKji2oiIz33uc7W2Si8jWIJ14oknppheK/p9JDQjKaSKvkgg26dPnxQ79NBDU0wFVCRMe/XVV1OMhF3vvPNOrU3jctWqVSlG40lFyyTCPPLII1OsFCS5nDhxYq1N8mgSapMkWK8B1YMLLrggxUiiplIzFfBF8DU57rjjUkyFmSpji+DauGTJkhRTWR3JAqk+H3/88SmmsneqAzQnUD8dIyTM60gi6vPOOy/FNm/eXGuT6JHyjmR3V199da1N1/z+++9PMRKxa42g80iSPJrrVLZP8xXNh3Q9tQ6SDJ+EnSQ3nz9/fq1N44jEnjSPqBxW10wRLKMtBQkudV1EUkqS4NJ8r/WT5rhBgwalGM1zKuylWkDrojvvvDPF9HuTHJ5yir63yitJSkmCS6qLOm5I2HnHHXekGNVKzTNaV9K1Lcmtt96aYpdeemmtTdeqV69eKUbrdP2+9HP0cgha52kdp/shkrjTi05Utk81m45BX8gSkWs2jUvKY10fRuQXqdCYo3XxAw88kGKjRo2qtYcMGZL60Nq/FGvWrEkxFZWTgJxe9kG1REW4tGak+0+q2Xre6OUNtN6nl0NonlEuDh06NMXoRQT6s3S+aJ6mdYCuz2n+pTFIL+vQdTetyeglQm3hv5gxxhhjjDHGGGOMKYQfzBhjjDHGGGOMMcYUwg9mjDHGGGOMMcYYYwrhBzPGGGOMMcYYY4wxhdiv/LdTp04ppgIskqo1Go0UI2GOygdJkkWSM5WhRmRh1OLFi1MfkhyRrEyFfiTXo2N9++23U+zZZ5+ttUmCTGIi/bmILHIjMR2JN0mgqUJCEpXSuS/JySefnGIqz6JzojLnCBbl3X777bU2SSJJNqgSyoiIgQMH1tokyqKfI0GUyv/mzZuX+lx55ZUpRt9RpV503ek7ktBbc5Rkb/S9Sban4jK9rhF8PUpBkjwV2ZF8bcWKFSlGAjOVt5K0kWoJ1V49VhLpff7zn08xEudpDSIpNNUuyjMSuiqnnHJKilFeq0SWpPFUz6ifCvJIlrxy5cp8sIUgsbiKOUmoSILP9evXp5jKW0kaScK9X//61ynWzJxC8l/Kdc0fqjWUiyTu1jmeBOh0zUmmqMdBNZ3WDyT21PNKks2LLrooxUpB6yldk9C6ks5RM+OOfh/JcknArJ9PuXn66aenGF0nrYNUY0kuSeNS17dU++l80Vpc84xyn8TvNI/ouoDWxTR2S0LztNZG+v733HNPipFUWvOPajHJTgcPHpxiKsM/55xzUh9dF7QVUwkxzXOzZ89OMbp/UOE4Cc9pTiBpreYtzUFUG0kOqxJiur8jQXUpaN2rL6Qhqa9KjiN4Law/S/WTcpEE/JrrJLOla07jX69xM/c4ETyfK3S/R/cv9CIXvS+kc09rTcpFrZd0Tmneawv/xYwxxhhjjDHGGGNMIfxgxhhjjDHGGGOMMaYQfjBjjDHGGGOMMcYYUwg/mDHGGGOMMcYYY4wpxH7lvzNnzmz3A0jIStJLFQhGZKHo+PHjUx8SVJHQ66677qq1J02alPoceeSRKUZCPxURqcg1gmWEJPZctmxZiikkTiTxZr9+/WptkmSRUJYkUCqUI5FbR4PkyppDZ5xxRupD0j0Spqk0SoW0ERFHH310ipHwTaVwJLMl8dmWLVtSTIVdY8aMSX02btyYYioWi4i48MILa+1XXnkl9XnooYdSjAR5eqz0++bPn59iKpOj46BrvWHDhhQrBX1X/Q4knSYhHklSVei5adOm1IcEY1QbVTpH4rhVq1al2JAhQ1JMxW0k9aW8pnlC6xfVPDpfdO5VyEmiNRJ5qnCR+tFnffazn02xUpB0u2fPnrU2jR2SmNK1U0iuRxI+qmUqYaVr0qVLlxTT7xOR6y7lz4IFC1KMhNIqyKf5nc4NSdH1BQkkUiXxNYm0VQ5L5/7OO+9MsW9/+9sp9kFAeaYiZZpzaG1Gea35QgJKkuCSBFSlmjTH0fWlvNbrSUL3ZuSfEVmgSeJikkBr3kXknKKXcJDMldaR+pKKYcOGpT7NCN1Lo3MkCbypBtGaRGMko66qqqmYrsFJiEpz8uTJk1Ns9+7dtTaNS3opCI3D6dOn19qUs3QPQ/cdWr9INvzmm2+mGI3Ds846q9am+kny1lLQ2kzHC407Guu09tPzQflK+Unzk86RlBeUB3R/pD97yCGHpD69e/dOMapnWhtpnl69enWKEbr2oxyjMULPJPQc6n1WRMRPfvKTFPvhD3+Ix+a/mDHGGGOMMcYYY4wphB/MGGOMMcYYY4wxxhTCD2aMMcYYY4wxxhhjCrFfxwzt8Ro5cmStTXv0x40bl2K0H/WWW26ptWfNmpX6nHPOOSmmfpSIvJ/uscceS33eeuutFKM9iLrH8YUXXkh91LUQwa4I3RO6c+fO1IditEf52WefrbVpPx/tY+7cuXO7v5P2fa9fvz7FSkJ59U//9E+19vbt21OfK6+8MsWGDh2aYnrdyUNDe3Xps3QvJO0pJidCM/lO17h///4pRvmhLhpy39B+YdofqfuFyTdCe1OpFuheUdpDq3vcS0L7WNVZQHtwyQtFzgt1vpBbgs4t7YnV2kjuJPIrkC9Ac5ZqMe0hJheEHis5PMhd0oyTi5xZM2bMSDHah63Hv3jx4tSHHGalIH+b7menOWzhwoUpRtdTawR52WiOoTxT38jatWtTH9pTT/4A9YboHvsI9kfQPv6TTjqp1qZxSnMk5ac6zWhOuuSSS1KM3Cias3369El9dE1WEqpT6n2jtRnVDJq/dI4hBxU5Wai+6RqO1rvkYaLP1/wnbwO5vZYuXZpimmfk3KDvTU4zzT1yHupaJYKvo14jOl/kBSoJrW80r6hO0RxD+bhmzZpam1xG5NSj+Uk/n9Z5NF8ROmdRzab7jttvvz3FNP8oH+neh9bKuk6lMdHs/KIuRDo3I0aMSLFSkOtS5z/y2dH3orWZOtfIJ0XzLR2X1i+qn7QGonsm/U60FqTvTeNSnURUb8gVQ/VM10TkdKI1KcV0vU7uJPLptYX/YsYYY4wxxhhjjDGmEH4wY4wxxhhjjDHGGFMIP5gxxhhjjDHGGGOMKYQfzBhjjDHGGGOMMcYUYr/y38suuyzFVL5G4jCV1EZE3H///Sn26U9/utYmARzxwAMPpJgK5kj6R9K2fv36pZhKgUjQRvJPEmCpYItEToMGDUoxkniqkJDkaxdeeGGKkbRQ5U4k4epIstWIiLvvvjvFTj755FqbRFb33ntvipFYqmvXrrU2SSg1zyJYMKfHSsdFQuBmPl9FlREsWqPrp7I6EjE2K0/Un6XfN3ny5BRTASj9TpIukuS0FBMmTEgxPR/PP/986nP++eenGIkcVWBG5/+8885LMcpZlQpSvg4ePDjFqIZ26dKl1qYcJpEbzRMqeCap2hNPPJFiJLnUejZ37tzUh4R5JEDs3bt3rX3YYYelPiTTLQWJ6D/xiU/stx3BckDKRZX1TZw4sd0+ERF33XVXiqkIk2rNgw8+mGJTp05NMV0HUK5QXaRcVCE5ycdp7j733HNTTI+DZOe01rn11ltTbPTo0bU25TWdm1JQLupahs7Zli1bUowEuipxpGuia4IIHq9an+maUE6RGPZjH/tYrU1SaFqvkTBfvyOtP0kkqfLPiPzCCzo3JOzU7xORhbUk5NaXXZSG1sNaE+i80fxO/TSH6PdR7t1zzz0ppvMmza2ULzROrr/++lqb5nx6GQqtM3SOpLXz7t27U4zmF62969atS31o/UDf++KLL661H3nkkdSHRO+loPWr3jNSbaSaT+JdFdBSTaVromu6iHwuae1EtZHWSnrvQ/cJ+lKSCBb26rOF5cuXN/Vz+qKhiDx3UP585jOfSbGZM2emmNY9Oi7Lf40xxhhjjDHGGGMOAPxgxhhjjDHGGGOMMaYQfjBjjDHGGGOMMcYYUwg/mDHGGGOMMcYYY4wpxH7lv2+++WaKHXTQQbU2CW9JIKXSv4iI+fPn19okztLfF8HCtyOOOKLWJvEmSbIWL16cYirdIqEmieK2b9+eYiq+O/LII1MflXNGRGzatCnFVMzYp0+f1IekhY8++miKjRo1qtYmMdVvIyv6ICBxlQrpXnrppdTnlFNOSTGS4D300EO1tkpAI1iISjLJm266qdama/z5z38+xUiS3b9//1qbrpXKYiNYfKaSzrPOOiv1ITHdO++8k2IqtVy/fn3qQ7WAxFgqPVNJcUQ+DyVZtmxZin30ox+ttSlfSWxK/XRs62e3FSMxtMrdqDaSsJ3Gv9YXFZJHZAldBAuf9TuShJLyk76jihlJKkt1kD5fRYYkYaS8LsWAAQNSTMWcdH2PP/74FCNRfOfOnWttkpE+/vjjKUZSQa27s2bNSn0+/vGPp9gvfvGLFFPRLK1FLr/88hSjuqjXnGo/Cdx1/onIEkGq1ySdJnSsfutb30p97rvvvqY+64OAaoaebxrnJJLVvIvI9YfWgnS+Kc903FCNambNEZHF7yT6pTUdCVj1O9HcS3JeWmPs2LGj1ibBOq2xKT9V+kpCcbpmJSH5t9ZuWpPTGoUE5xdddFGtTded1mZjxoxJMb0/oZeckNh0wYIFKaZjgL4j3Q/RvKbXlESwzQjoI5q7HyJxNo25O+64o9YmYTON+1LQukXF0PRSGZItL1q0KMX0ZRALFy5MfWg8UF3StRKtgeiFMVOmTEkxXRtQrtA1p3Wq1kZ6SQ7VOMpZre16zxbB9/6U17p+oLU5vVihLfwXM8YYY4wxxhhjjDGF8IMZY4wxxhhjjDHGmEL4wYwxxhhjjDHGGGNMIfxgxhhjjDHGGGOMMaYQ+zUY3n333Sl25ZVX1trNCihJWqWiLBIakciHxI4qLSQ5L8kfSeinki8SE5EojqSFen5IFEuiNRKGTZ06tdYmCSMJmUhItmXLllqbpF8qVC6Nynkj8vela0ByK8pblZxRDpE0+Hvf+16KqViQRGv33ntvitEY0OMn6TOJL0mepf0oj0n0RcIrFafSuKfco9+p8tZPfepTqc9vI8/6XTN8+PAUU4kiSfl69OiRYsccc0yKab0koS7ViGaErlTzVF4WkSWmEVm+RtJXyh8ScqqQluYIGoOE1mgS148cOTLFNO8isiz8iSeeSH2WLFnS1HF9ENC8tm7dulp70qRJqU+z863mJwk+KQ/ommv9IWHpwIEDU0wlphG5pqr8sK1jUFFrRMQZZ5xRa5NwkXLxrrvuSjEVmb/88supz4033phil112WYppzfvBD36Q+lx77bUpVgqSTKvYt1OnTqkPCZkpr0877bT9tiN4XTR+/PgU01ykdR4JXymm6zqqzTS2SJg/bty4WpteOEDS1Llz56aYzttUmwkSDmsdVHFpBEuJS0JrEl0zkiCW1lg9e/ZMMc13qjd0TuglACrOptymeYcE1Tp3U82j2tuMNJ/ODdVL+nzNGRpLJKOm2qj3J3pPE8H3Q6Ug6bmuhVUmHcHzNK3Hn3766Vqb1oK6LojgmnDsscfW2qeeemrqQzWIjlXXWPQiIJpb6Xz16tWr1qaXT9C9EKH3R127dk19aD477LDDUkzvn2mOGzx4cFPHFeG/mDHGGGOMMcYYY4wphh/MGGOMMcYYY4wxxhTCD2aMMcYYY4wxxhhjCrFfx8ynP/3pFPvIR+rPcshDQntPaT+a7mekz6K9Z7R/V/coDxkyJPWZMWNGitE+PN2rR3vDli9fnmK090z3l5ID5cknn0yxc845J8V0P6a6ECLYK0J753QPHB3D2rVrU6wk5OdR3wF5MWgPLu09nTNnTq29cePG1EcdSxF8fnUfJe0JpfP7la98JcVuuummWrt///6pz/bt21OMckH3k1Juk3eDPEjqTqD9mMuWLUuxyy+/PMV0HzN5gXTfa0nou6oHg1wudE2oNqrvQPfWRkQ88MADKek47v0AACAASURBVDZo0KB2f+fevXtTH9rXTfu/1X9A/hXyuzTj/6B9uatXr04xqrM6J5C3R107EXzuNf+HDh2a+ug82NH4+te/XmvfeuutqQ85fbp165Zie/bsqbVpLz9dO/IVqOtgxIgRqc/06dNTbNSoUSmme8nJ40U+q6OOOirFqH4q6tSKiBg7dmyK6VqEnAy9e/dOMVqL6DxC++7JxVIKWsOpK2Px4sWpz4QJE1KMXAH6XalGUa284447Ukz9I3TsdL7JnaE5RflEHp1+/fqlGK1hFF2jRrBPRb0l5I2kOYPmWl27Hn744akPzQcleemll1JM65f6pSIiZs6cmWJXXXVViqlP6uGHH059brjhhhT7/Oc/n2K63iQ/H807N998c4rpGlFreAR7FsmHo145usZU66kea22fNm1a6kPrJlor67WldT45VUpB86bOAzT2KYdpDtNaRXMfzTt0vnX9SQ5C+nzKA617b731VupD62Ja+2ndIzcqrddofaLPFuje7uc//3mKUb3U46I16oYNG1KsLTr26tIYY4wxxhhjjDHmQ4wfzBhjjDHGGGOMMcYUwg9mjDHGGGOMMcYYYwrhBzPGGGOMMcYYY4wxhdiv/JckoCruGTBgQFO/6J577kmxz33uc7U2yVZVEEnHEJFlriQOUgldRMT69evzwQrbtm1r6rhI8qeSYDr2Ll26pNhvfvObFFPZGgl7m5XJqcCLRJAkNiwJCaJ69OhRa5MUi2RlJPCbMmVKrf3cc8+lPiTiIgmeynJJ+kzyNcqrkSNH1tok4qLPv+iii1JszZo1tbaK3SJYuE2/U4WrK1asSH1ozFHeqjxLJbMRLHoshUqnI7JU9+STT059SN7XjBSO6hmJz6huKCqAjmDZI9V/lTnTdSL57+zZs1Ns+PDh7f4+EpxTPdbPInEiyT0pp7TukbSNxnwpSPqpslM9PxEsNiWpqEI1kD5fRb8RWTJNuTJ58uQUI0Gn5susWbNSH7rmdKxbt26ttWmuofykOqB1kQTTJA8nQef1119fa9N4uPTSS1OsFCTob0aKTmJumif082nNSHM7HVfPnj1rbXqpxCc/+ckUo3qtP0sSTMp1qj8qPaY1HUn1SXCp8w29FIPOs8o/I/JY0usawWL/kpCAVtfgJDynMUuyfa2hJM+lekZ1VueZgQMHpj40d19wwQUppuu1SZMmpT7vvPNOipGgeurUqbX2XXfdlfqMHz8+xbR2ReRa9atf/Sr1oRjNOZdcckmtTfc5NKZLQVJaXdfRS0lofGrtisjrQbqvpPU+3ZPq/EQ1m2oXrUm15tA9Dr0w6DOf+UyK6f00nS+6p6f1rdYvOgYaIzQH64uFSGpN574t/BczxhhjjDHGGGOMMYXwgxljjDHGGGOMMcaYQvjBjDHGGGOMMcYYY0wh/GDGGGOMMcYYY4wxphAVybGMMcYYY4wxxhhjzO8e/8WMMcYYY4wxxhhjTCH8YMYYY4wxxhhjjDGmEH4wY4wxxhhjjDHGGFMIP5gxxhhjjDHGGGOMKYQfzBhjjDHGGGOMMcYUwg9mjDHGGGOMMcYYYwrhBzPGGGOMMcYYY4wxhfCDGWOMMcYYY4wxxphC+MGMMcYYY4wxxhhjTCH8YMYYY4wxxhhjjDGmEH4wY4wxxhhjjDHGGFMIP5j5LamqqlFVVbfSx2GMc9F0FJyLpiPhfDQdBeei6Sg4F01HwvnIHNAPZqqq2lZV1RtVVb26z38/KH1c71JV1ReqqlpZVdWvq6raWVXVX1dVdfA+/96zqqq5VVX9qqqqx6qqurzk8Zr3zgGQi5+pqmpza649V1XVf6+q6uh9/v24qqpur6rqtaqqnqyq6uqSx2veOx+CXPxGVVUrqqraU1XVzwoeqnkfOJDzsaqqj1ZV9ZPWmvhKVVWrqqqaXPqYzXvjQM7F1n+/vqqqp1vXlI9WVfXlksdr3jsHei7u0697VVW/qarq+hLHad4fDvR8rKrqgdY8fPfYN5c83v8IB/SDmVYuaTQaR+7z3zdKH9A+fCwi/lNEfCIihkbEBRHxJxERrQ9oZkTE3RFxXET8zxFxfVVVPcocqnkf6Mi5+FBEjGg0GsdExJkRcXBE/OU+/35dRLwZESdExDUR8aOqqnp/4Edp3i8O5Fx8qrX9rwWOzfxuOFDz8eCI2BERYyLimIj4TkTcXFXVGR/8YZr3iQM1FyMivhsRZzQajaMjYmpE/GVVVYM++MM07xMHci6+y3URsfyDPDDzO+NAz8dv7HPsZ33gR/g+8WF4MINUVfXFqqoeqqrq+61P2DZVVXXBPv/euaqqO6uqerH1r1W+ss+/HVRV1Z9VVbW19f8lW1lV1an7fPyFVVVtqarqpaqqrquqqqJjaDQaP2o0GgsajcabjUZjV0TcEBEjWv/57IjoHBF/32g09jYajbnRknjXvt/nwpSlg+TijkajsXuf0N6I6Nb6O46IiCsj4juNRuPVRqOxMCLuDOfih46Onout/z690WjcEREvvH/f3HREOno+NhqN1xqNxn9tNBrbGo3GO41G4+6IeCIifDP8IaOj52Lrv29oNBp73m22/tf1/fj+puNwIORi6+/6TES8HBH3vy9f3HRIDpR8/LBwcPtdDmiGRsSt0fIXK1dExPSqqro0Go0XI+LGiNgQLQ9Hzo6IOVVVPd5oNO6PiD+OiM9GxJSIeDQizomI1/f53IsjYkhEHB0RKyPiroiY2cTxjG79nRERlHxVRPT5bb6gOWAonotVVY2MiF+29n09It7dOtcjIvY2Go1H9+m+Jlr+X2Lz4aMj56L5/eOAyceqqk6Ilnq5gf7dHPB0+FysquqHEfHFiDg8IlZFxD3/0S9tOiQdOherlm0k/y1adgL8T+/PVzYdmA6dj618t6qqv4qIzRHx541G44H/4HcuQ6PROGD/i4htEfFqtDyxffe/r7T+2xej5U/iq336L4uWvwI4NVqeth21z799NyJ+1vq/N0fEpW38zkZEjNynfXNE/O9NHOsfRMTOiPhEa/uQiHg8Iv7X1v89IVq2kswqfV7934c+F0+OiP8aET1a26Mi4hnp85WIeKD0efV/v1+5KP/2l+/+bv934P73IcrHQyLivoj459Ln1P/93ufiQRExMiL+c0QcUvq8+r/fv1yMiH+MiP+t9X//14i4vvQ59X+/1/k4NCKOioiPRsQXIuKViOha+ry+l/8+DFuZLms0Gh/f579/2effdjVar1grT0bLE73OEfFio9F4Rf7t5Nb/fWpEbN3P73xmn//9ekQcub8DrKrqsoj4q4iY3Gj9U6xGo/FWRFwWERe1ft7/Ei1JuXN/n2U6NB0+FyMiGi3b6mZGxE2toVej5Qn0vhwdLYXNHJgcqLloPpwc0PlYVdVHIuLn0fJ/nnSkfffmt+eAzsXWf9vbaNlyfEpE/GF7n2U6LAdkLlZV1T8iLoyIv2/vZ80BxQGZj62xpY1G45VGo7Gn0Wj892hRg0xp77M6Ih+GBzP742TZr3ZatDz1eyoijquq6ij5t12t/3tHvE/7dquqmhQR/xItUqV1+/5bo9FY22g0xjQajeMbjcbEaBEaLXs/fq/pcBTPReHgfT730Yg4uKqq7vv8e7/wn+t/WOnIuWh+/+jQ+dh6bD+JFjH6la3/p4r5cNKhc/E9/Ls5cOnIuTg2Is6IiO1VVT0TLS81ubKqqod/B7/XdAw6cj4SjWBlSIfnw/5gplNEfLOqqkOqqroqInpGxD2NRmNHRCyKlv1oh1VVdU607JG8ofXn/t+I+D+rltfAVVVVnVNV1fG/7S+vqur81s+8stFopAcurZ97WFVVH6uq6k8i4qSI+Nl7+aKmw1M6F6+pquq01s84PSL+r2gVtjUajdciYnpE/Leqqo6oqmpERFwaLf8Psfnw0WFzsfXfD66q6rBo+XP9g1qP5cPuQ/t9pkPnY0T8qPWYLmk0Gm+8969pDgA6bC5WVdWpanll7JFVi1BzYrS4G+b+h7+16Yh02FyMiB9Hy01x/9b//p9ocX9MfO9f13RwOmw+VlX18aqqJr67Vqyq6ppocbrO+g9/6wJ8GBa7d1VVtXef9pxGo/GuEGhpRHSPiN0R8WxEfKrRaLz7po/PRksxeSoiXoqI/9JoNOa0/tvfRcs+tdnRIjraFO9NTvmdaHnF5j3V/3jQuKDRaExu/d/XRsSXo2Xv+oKIGN/4H8Z9c+DRkXOxV0T83xFxbOvvuCci/nSff/96tLye+LloeRvOHzYaDf/FzIHLgZyL/zki/ss+7c9FxP8RLXuKzYHJAZmPrQvAr0bEnoh4Zp95/KuNRuOG/FHmAOCAzMVo+X+A/7D1GD4SLdsF/lOj0ZjxHn6P6RgckLnYaDRej30ErlVVvRoRv2k0Gs+/h99jOg4HZD5Gyz30X0aLeHhv6++4rNFobH4Pv6c4VX3L2IeHqqq+GBFfbjQaI0sfi/n9xrloOgrORdORcD6ajoJz0XQUnIumI+F8/GD5sG9lMsYYY4wxxhhjjOmw+MGMMcYYY4wxxhhjTCE+tFuZjDHGGGOMMcYYYzo6/osZY4wxxhhjjDHGmELs961Mffv2bffPaU4++eQUe+yxx1Js2LBhKbZkyZJae8SIEanPjh07UuyRRx5JsQEDBtTazz33XOpz0EEHpdjrr7+eYp/4xCdq7aOPPjr1efjhh1PsjDPOaPd3vvbaa6lPt27dUmzLli0ptmdP/YVNvXr1Sn3eeeedFHv66adT7O23304x5fDDD0+xefPmFXsvfOfOnVM+jh49utZ+6aWX0s8dd9xxKda7d+8U07yl79+1a9cUe+qpp1Js69attfYJJ5yQ+uzcuTPFDj300BT7+Mc/XmuvWbMm9Rk8eHCKnXTSSSmm+f7oo4+mPpSP+n0iIjZu3FhrU+7R95k6dWq7/a677rrUZ8yYMSl2++23F8nHadOmpVzUfNm1a1f6uUGDBqUYXQPNl0MOOST10ToVweNaaxXlCtXL0047LcU0Z6k2Ul4/8cQTKXbmmWfW2s8++2zqc/DBeYrq1KlTii1atKjWPvbYY1OfI488MsXoenzyk5+ste+///7U55hjjkmxG2+8sUgufutb30q5uHbt2lqbxuHxx+c3Vv7mN79JsV//+te19jnnnJP6rF69OsXefPPNFNMxQvO71vS20HXA0KFDUx+aRzdt2pRiuo555ZVXUp8uXbo09fn6vYcMGZL6nHLKKSk2f/78FPvIR+r/39mJJ56Y+mi+RkT84Ac/KJKLPXv2TLmodYRyjKC12VtvvVVrU92iOZpqpdYpWifs3bs3xY466qgU0788f/LJJ1Mfqhm0xtBaSX1OPfXUFDvssMNSbPfu3bU25TXVWKqfet1ofNP33rFjR7E145QpU1I+vvFG/Y33eo4iIo444ogUo7WljkdaA2nORvC9iOby88/nFxzRWKc5ePv27bW2riEjuC4tX7683c/f5810/z+bN+eX31A9fuGFF2ptulekn9P5PSLiwgsvrLXp3Os9U0TEnDlziuTj5ZdfnnJR7wdpLUjz7Uc/+tEU+9WvflVr01ike0aqG1p7X3zxxdSH6hLdJ2ie0bXs06dPU8e1bt26Wvv0009PfWi80Zyg9y90b07zBo1BzT0aD7R+uPPOOzEX/RczxhhjjDHGGGOMMYXwgxljjDHGGGOMMcaYQvjBjDHGGGOMMcYYY0wh/GDGGGOMMcYYY4wxphD7lf+qTCgii9xIcEmv4CbhngpYSQSosp8IFvk8/vjjtTZJMHv27JliJJ/SGEnhSArUjHxNRYoRLMsksdKrr76aYgqJkel86XckoVFHe5X6VVddlWLbtm2rtUl4S3lM8mYVV02aNCn1IanTwoULU0xF1iSYIyEwSVK7d+9ea1966aWpzw9/+MMUu/rqq1NMpaAkrKbrThI1PS4av/3790+xpUuXppgKu0hSRmK6UtBYX79+fa198cUXpz7Lli1LMRp79913X61NOfy5z30uxUhwq3k8Z86c1GfixIkp9v3vfz/F/viP/7jWXrx4cepDud6vX78UU6Gc5lMEiylpvJ133nm19ssvv5z60DVbtWpViqn4js6N1p2S0HfVsdK3b9/Uh8R5KsaMiOjRo0etTflDUlGqxSotHDt2bOqjLwWI4PlQZXq0VqA5n6TWKv6jc0primaEwLR+IAEi/U6VNlNtpjVMKWiM6bmla6mS47Ziun6imkEvpCCRsEopSapPglSqeXqd6PcRtI7UuY8ksHSeaU2jUk16EcRZZ52VYpRnKm792Mc+lvqMGjUqxUpCommdd0ioTbJTWn+rxJfkrSSrJxmvHgfJ2Uk2TiJo/Vkac1Qv6bhUSkxrRsohkiXrOCGx7UMPPZRiNFfpOBw5cmTqQ2vSUtALHFQCT/MvyZ3ps/R8U14QdG+ua0ZaJ9H4p+uka1ddq0XweopyVsXQJOylekm5qGOX1uEkAVexdkQWYtO6leaztvBfzBhjjDHGGGOMMcYUwg9mjDHGGGOMMcYYYwrhBzPGGGOMMcYYY4wxhdivY2bgwIEpNn/+/Fqb9mfS/lrdgxWRfQi0H5CcCXv37k0x3RNL+9PUYxHBe1DVh0DHQHvu3nzzzRTTvW2jR49u6rNof77u/6S9dOQCeeqpp1JM9yjT3kbyB5WE9j3rPkHyB9B3W7lyZYrp/kXag6v7bSMixo0bl2Kao8OHD0995s6dm2I05tQXQXlMPhPa06h72uk7qgciInsm6LNozynttaRrdOaZZ9baNH4pt0uh++0j8vm4/fbbU5+vfe1rKXbzzTen2ODBg2ttclmsWLEixahW6Z5e/ewI9rbQsf7d3/1du7/v/PPPTzHyZ6gPi3wg5FKgffC6D5vGaefOnZs6rgsuuCDFFN0rXxL1EUXkvdfkTHjmmWdSjDwb6lYg7wZ5B8iXdeyxx9batFbQOhzBc5jO3XR9aQ86OXJ0Lr3mmmtSH6pbM2bMSLGzzz671iYnCXkn6DuqI4TWKxQrBZ0jXRep5ywiYtCgQSlGXi2dJ8gLQOeb5iGFnAzkFdEcJsgBQdAaS+sbXV9yxRxzzDEp9uyzz9batF6n70Pzr44lWoeT56Yk5HTUsU5zBblPmvFZ0NxB9zU01vW6a65HsL+N1sV6TclXQ9edPFo619E5pfVJM+vuc889N/Vp1unWrVu3WpvmOPrepSDXmB4z1Q0aZ7TW1jmF1kk055N/ZebMmbU2zfl0/zls2LAUU+8S1XWqz5RTem9CPiL19kSwp0fnCfJaUq7TfYh6zeg70vOBtvBfzBhjjDHGGGOMMcYUwg9mjDHGGGOMMcYYYwrhBzPGGGOMMcYYY4wxhfCDGWOMMcYYY4wxxphC7NeItnnz5hRTyQ0JsUictX379hRTiU7fvn1TH5IzksBIBWkkciMZEgl59HuTuJVkQiSoUkkTSdVOOOGEFCPBkIrcSCbVvXv3FCOhox4//RxJp0pCwjuVj5JYkMTTlB9btmyptUnA3L9//xTbuXNnipH4UqFcIOHb6tWra+133nmnqZ9bsmRJiqkMjSR0KlSmn4vIY47GpQraIlhgp4IwGhP0vUtBcq/evXvX2hMmTEh9fvazn6XYtddem2IqdH3wwQdTHxKykTxaJW1/+7d/m/qQCHDAgAEp9tWvfrXW/ulPf5r6kBi5GXEziTxJnEjjWcXLS5cuTX1IuEp1XGV4JLkj0Wwp6Dsoo0aNSjGtKxF8zZctW1Zrb926NfWhMU25qDLn6dOnpz6TJ09OsSOOOCLFVFSp82MES8tpzh85cmStTd+Hfo7WFDonkZxT11ERPB/ocVDe0eeX4vHHH08xXaeQnJHEtSSvVxkv1S0ShtPaUmvSokWLUp/TTz89xeh36lxIua/ri4gsd47I45L60FxLa2UVvdP6aOPGjSlG517XQ1SbO5JsNYJrvs4ftEah2ki1RM/BvHnzUh+qEbR213p21FFHpT50b0W1RGOzZ89OfWh9TzG9x6O1GeUCSat1/UxrZxKI09pA853W3PRzpaB1kV5zEhjTyzjoXkhrI+Ur/ZzOfRFZ+EzrXbo/ouPXekz3UCTZfeyxx1JMr2fXrl1TH1prUj3Tl7ZQLhJUj9evX19rk9SaanZb+C9mjDHGGGOMMcYYYwrhBzPGGGOMMcYYY4wxhfCDGWOMMcYYY4wxxphC+MGMMcYYY4wxxhhjTCH2K/8liZoKOJuVfZG8TwVVJO8joRkJ2VRiSjJUFfFGRAwaNCjFVMikArUIFi6SrEulSSSSpM8iSdOJJ57Y7u8jzjrrrHb7kABOZaalOeOMM1JM5ZEkUiVpI51fFQKTZPS5555LMRLMqfxp165dqQ9JdklKPHr06Fqbvo/KcyNYaqc5M23atNRn5cqVKfbKK6+kmI59GksqDo3gfFT5NIl+SWJdCpLKqdztkUceaernSJipAloSg5IUjnJW5aDf/OY3Ux+teRE8RlQod8EFF6Q+zchoI7KsTr8z9YnIYrqIiJ/85Ce1NsneqJ6RwE4/n8ToTz75ZIqVgkRzWltmzJiR+rzxxhsp1rNnzxRTGWOXLl1SHxL10RjW+ZDmVhLvUu3XfKHPojHy5S9/OcVUPkt1S6W+ESyC1bmUhIhUY+nca+6RXFTnh5KQiFhzkWrGpk2bUoxqmQpF6aUSdM1JwKqyRxIE0xqLxo0KLekYSAj88MMPp5iub+mc0nqapMq6XqE6T3l9yCGHpJjOUyQXJYlnSUh2rOOFxLUkuCWZrV7nXr16pT40F1Ft1LyiOkj3ZG+99VaKqQCVhKs0JlSiH5Gl1XS+KB/pfk4/n+7JSDRLOaq/k2oxzd2loOuk94N0najG0TnS+kUSXKpntCbVNRyJy2ntROJm/Sz6fbTOo/sqnUtpXUD3QrS21JwiAf2GDRtSjMaI5h7dL5H8uS38FzPGGGOMMcYYY4wxhfCDGWOMMcYYY4wxxphC+MGMMcYYY4wxxhhjTCH8YMYYY4wxxhhjjDGmEPuV/5KcVMU9JKMiaSSJj15//fV2f46ETvpzERFXXXVVrU3SYJXnRkQMGDAgxVRqRPK1Pn36pBiJYVXaOX/+/NSHhGnNiMZIAEWfRRIoFUqRLPm3kRV9EJCQTsWXmzdvTn3o+5NA+rjjjmv350hIRWLfJUuW1Nr9+vVLfSZMmJBiJIdWaSkJvEgwR9KwWbNm1dqTJk1KfUiYR8IrldtOmTIl9bnmmmva/bmILBKmYyeBVylIcrZq1apam8Rz9913X4rRuVW57J/8yZ+kPiq+jmDppI6JIUOGNPVzdFwqDKS8JqEfCQP1mpMU+q/+6q9SjPJAxXckwqQxcs8996TYFVdcUWsvX7489aFxWgoSt+s1pnG4cOHCFFu0aFGKaR6Q2G7FihUpRnPr3r17a22SWp999tkpRtd86tSp+/3sCJYDvvbaaymmUlR9MUEES61nz56dYpqLNOfT9yaBsgo0aQ1DssNSkNhRx8r999+f+mzbti3FdE0Xkdd1VIdpfUhzmq4nhg4dmvqQaJ/WACraJ8ku5TCJm1WESfMlyaOpfjYj46Va1rlz5xTT9RH9HEltS0L5qCJTula05qf1va4jaW1GOXTwwfnWS2WkdP9Fa2Cql/oyFBLf05xP86bWS5rz6X6Lzuttt91Wa9PLLujeR0XdEXktQvJ0EhCXgu6ndE6hOYBedtCMDJnGMJ0jumfSYyWxPq3z6D5Spbokw6f5lvJf18U0JgkaI3qPQbWLjovmF63/JDOm79MW/osZY4wxxhhjjDHGmEL4wYwxxhhjjDHGGGNMIfxgxhhjjDHGGGOMMaYQ+3XM0J5q3V9O+0xpbyE5ZnSPIO1Po/2ZtG9869attfagQYNSH/KKNLP/k/bzkX+Bzlcz0P5M2sev+0bpfJGbg/bZ6n5h2lOrexZL8+CDD6aY7oVUP1AEuyXeeOONFNP9qLpvMIL3wp9//vkppjlK+0tpvzB9lrqXKB/Xr1+fYuQ40X2O9Fnf/OY3U+zmm29OsfHjx9fat956a+pDTgQah+q7oBrSkSC3lu5RpX3k3/72t1OM9hAPHDiw1tZ98RG8b5b2VOteY9pLS9eE9qBrP9oPTjVo8eLFKfapT32q1l63bl3qo76XiIgf/OAHKaa+EfIy0FxF10M9K7Q3mGpDKYYPH55iOn7IQ0K1kjwtPXr0aPfnqMbqHEPHcdlll6U+5OLQ8RCRHWDko6PPOu+881LsgQceqLXpnC5btizFyOuh55D259MedNqzr+eexhvNI6UgR4Wui2g90r9//xSjnNX5asGCBalPly5dUky9PxE5N2gtqA67CF4DdO3atdZ+4oknUp+qqlKM/HQ6bsgTQ24Ochnpuo7WxbT2Uy9ERK6fw4YNS33Us1YamsO0btBcTnMY5aieE/Jk0v0KrQd1nqb1PfmxCHWMNbtm1HoTkZ0atFagtY56FiOy6+yGG25IfWjt18y9iPpHIppzLJVE5wFav1HtovsXrTlUi+m+UmsXHRfNrXQP3IxLkOoN1UEau48//nitTfM75SLNE804nWgdQMeqbiCaS+h7t4X/YsYYY4wxxhhjjDGmEH4wY4wxxhhjjDHGGFMIP5gxxhhjjDHGGGOMKYQfzBhjjDHGGGOMMcYUYr/yX5JEqoSJpH8k3yGZmMp/SYL73HPPpVjv3r1TrFOnTrU2SbJI2rN8+fIUO+GEE2ptErKuXbs2xUiQpBKl0047LfUh0RhJU1WiRDJLkneR0FGv24svvpj6kGCqJKNHj04xPQck+1JhVATnlUoUSVhNQl0SPamoeffu3akPiaXouFRKRXK0k08+OcWon/5OkhSq7C2ChYr6nVTAGsG5Tag0j8RfNO5LQSJQFZSS8JaksSTJU7Ei1Q2qcRs3bmz3s0iYdtRRR6UY5b+KPJ955pnUZ+jQoSlGtUTHCInj6PO/9KUvpdgtt9xSa0+bNi31ueuuioftwgAAIABJREFUu1Ls7//+71NMZY0kO+xIYvSHH344xXTOuuOOO1KfsWPHphgJ/VQ4u3PnztSnZ8+eKUbXXOsI5T6JfkmQrfWa5H26xojgPNOc/dWvfpX60FqHRLYqWCTx5ubNm1OMzpeOZxIEdyTB5aZNm1JMvz8JLkkUrTLUiHy+6frSeaS135QpU9r9OZJG0nx/55131tpUH2h9S+JmPT80F1KMxL6a6ySdptpP9UJFyHS+dI1aGpo/dA1Hwl6qJSTv1DmMxOIkfR4xYkSKqayV5nw6Brrf0p+lmnfVVVelGK3XJk2aVGvTiwho/TlgwIAUU+nxqFGjUh9ak5L0XNe3ei0iuPaWgmqc3pvQmp1eZEAvmtG8pnlB720jsrg2Iq/laVyvWbMmxagu6XXRe/UIXitTrVJonqb1GomQtfaSkJvu2+jeX+clEnfTZ7WF/2LGGGOMMcYYY4wxphB+MGOMMcYYY4wxxhhTCD+YMcYYY4wxxhhjjCmEH8wYY4wxxhhjjDHGFGK/8l+SlalUikSAe/bsSTES8qiQau7cuakPiXdJVqQSJRVeRkQ8+eSTKUayXBXYkZCVZIQkmtLPJzknSZZJ+KSQpPXUU09NMRIkqeCSzo3K3kpDokWVRpEMkMSUJLnUfCTBFsmzDj/88BRTwRWJpbZu3ZpiJHdTqfSjjz6a+tCYI/lX3759a22SwpFgksSCmjMk0SNhJskTVS42ZsyY1IdkY6UgEfHs2bNrbZI7088ddthhKabXpX///qkPiQ3pvKmQjURuDz74YIqRgFwlml27dm3qs0466aQUU8kl1cEhQ4a0+3MRufbOnz8/9aHxRmNX+2mtjIiYOXNmipFI+INg8ODBKbZixYpamySjJOqjOV8ljiSPprlba01EzgNaP9BxbdiwIcV0bUDzL9XF2267LcW+/OUv19okkiRIvLlu3bpam+TzNE81I9Wkz6LrXwr6Xiro79evX7t9Ilh+queIZMO01qTjUsEt1WuaHymmAu6LLroo9aH5i+qn5h5d36VLl6bYqlWrUkzXDlQ7SfhKUlaFxjzNZSWhF3KoXJbqO+Uercm1NtLcSvJfWhdpbaTaQi9hoPXg+vXra20SPNOLT2icPPTQQ7U25Sy9PITquB4/XR8So6tQPSLLVGm9QnN+R0LXg7SGppwiubjWQrrmdE0o/7XO0rxDn0XScJ2DzzrrrNSH6j/d32ptpDUj3WvRC3D0noY+i9aytM7Ytm1brU3Xh8Z8W/gvZowxxhhjjDHGGGMK4QczxhhjjDHGGGOMMYXwgxljjDHGGGOMMcaYQvjBjDHGGGOMMcYYY0wh9iv/7dy5c4qpTImErCQQPOaYY1JMBbpXXHFF6kNSoLfeeivFVPimMrYIluAS+vkkPmpGjhaRj1+lXBEslCXxlwqZSO5K35FkeArJikhEVRISS40bN67WnjFjRupD8l8VtUZkqZmKFyNYSEX5qFJLEmyRkIokanrdSVJFEk2S7OqxkoiLcogEcyoXI8Frr169UuzP/uzPUkxFnvT7SGBainvuuSfFvvCFL9TaKgSLiHjjjTdSjISJKrv7m7/5m9TnqquuaurzVXZIMskpU6akGEkLX3311Vr77bffTn1IOke5qPJiEg9S7SU5oM45Z599duozbdq0FPvRj36UYprHzcpbS0GiY5VSUn0n8SIJ6g466KBam+ambt26pRhJC9euXVtrk2Cd5Hr0WboWobUCyfBJpP0P//APtfb48eNTH5KknnLKKSmmax0VwUewuJteRHDeeefV2v/8z/+c+pDEsxQkjldJJL28gfJu9erVKaZzE+UFrYsoz3T+pbUZvSSAPktzg0Sxei3p5yLyuoNk1TomI3g86xxEa/o+ffqkGNVw/SyqgTQeSkKyY13nkXSbXnxBclnNIRrXdN3p3Ok4IQExrT/p5SQKraeojpNkV68pjS+ScNOLDnTtSueLzjONc722VP870jxN6wgV5NO4pu9FayD9rvTd6fNp/akCXbrPp/vDL37xiynWzM+deeaZKbZo0aIU03UkyZ0pfygXVSRML4IgUT29/EDF7jSOfhv8FzPGGGOMMcYYY4wxhfCDGWOMMcYYY4wxxphC+MGMMcYYY4wxxhhjTCH265ghd4buPSXHAPGb3/wmxVatWlVr0/634cOHN/VZ69atq7VpTz3tZyRvhe717t69e+pDn0/7azdu3Fhrn3POOanPT37ykxSjfdh6rLQvr0uXLilG+5h37dpVa9Neavq5kqg3ISIfIzlTdO9uBDsRdJ877dHcsWNHitG+et1LS94lch3omIjI++rJMUN7x4877rgU0zFAx/Xkk0+mGDk7dAzQ3uN///d/TzFy/ugeaNrHT/WoFHRuV65cWWtTPVuxYkWKqXcjImLq1Km19sSJE1Mf8k2Qd0brBu0XJp8M5Xqj0ai1KX/IzURjSb1CN954Y1PHRf4D9ccsXbo09fne976XYlRDNf/Jf0FzQinIFaA1j/Y865wZwXv577vvvlqbri/t69Z96hF5TEyePDn1Iai+7d69u9amY9+zZ0+KqXMpImLEiBG1NjlCqM6Tl0S/97Bhw1Ifcj6QK0L9IpR3dKyl0GsSkecrcpjROCcvldYRqj/k5iC/g/ajvKD1FNVwrankDaQaSN9RnUTNuuhoftTfqevRtj6fPGRaB6kO0/UoCdV39aHQunLx4sUpRn6XCRMm1NrktKJzMmTIkBTTsU2OJbrG5MbQa0q1hdYntBa57LLLam1ygJGTi87F3Llz2+1DDg9ai+g6ktbO5BYpBbmG9D6MatDIkSNTjJyVus6jfKWfo3qsNVuPM4KdknSPrfMmPTOgexo6fr33Hzt2bOpDtZdyVselOmciOO9oTtD7SVpj0z19W/gvZowxxhhjjDHGGGMK4QczxhhjjDHGGGOMMYXwgxljjDHGGGOMMcaYQvjBjDHGGGOMMcYYY0wh9iv/JWmVCvZee+211IdEOyQrU/kUCT/pGN54440UU6FQr169Up+BAwc29Vnaj8SDJBgikfBhhx1Wa5MAiES0JJhT6RBJkB9++OEUI/mtftbzzz+f+nQkcVZExMyZM1Osb9++tTaJMEkK+eyzz6aYiuLmzZuX+pDAb9y4ce32IxEmCSD79euXYipuozFBY45kldqPBKCUx/RZKlt79dVXUx8SnpHUTuXTdAwdSf6reReRxWckz/6DP/iDFCMJn15zqrMkuaTzpuJXGiNUB6km6BghaRsJ5g499NAU0/pFMuyHHnooxahebtu2rdYm+RqJBilnVT6oYuEIFraXguY1rTckVKRrQrVSxb46p0VELF++PMVICKkCURIPkkSfRICas5TXJCOk8aaSPxLqkrCTxNCa19dff33qQ3MrydM1RueGZISloPqj14DyjoTwVH9U0EhrIJqrKM9UCDx06NDUh9Z+dFzaj46B5i9aO/zLv/xLrd21a9fUZ8mSJSlGawwduyTupmtG10jnIJJlqtC9NHTddQ6jF3nQmKIXZBx77LG1Nr0UgOpSMzG6VrS+b6bu0VqT6jitKXQtQqJuErrSPZ9+pzVr1qQ+dB9Ia6kNGzbU2vTiD+1TEnohwemnn15rn3vuuakPCYFJvK3XhV7iQTJ8qr1aC+maUz2j2qiCc8qVrVu3phihNZvu46iO63mOyGsd+ixaR5LwX1+KQbJ5kiW3hf9ixhhjjDHGGGOMMaYQfjBjjDHGGGOMMcYYUwg/mDHGGGOMMcYYY4wphB/MGGOMMcYYY4wxxhRiv/JfkvSocE/FPhEsECRJngr9SHJEckmSOKr4jH4fQaIplfT06dMn9SGh7s6dO1NMZat0Tjdv3pxiY8eObbcfSb9I5NapU6d2j5VEYCR8Kkn37t1TTKVOJLe6++67U2z06NEppoKxT33qU6mPSp4ishwtIuctSQpJ9kifr/lOUjiS+JLw7Zhjjqm1SWZMYjGSqOl3PPzww1MfksktW7YsxXRckCiLhNuloLqn0jESgG3cuDHF9u7dm2IqCR8zZkzqQ6JFkpWpUJoEoiTBpWugdZZEvyRqJQmjfr4KWCNYoklSQc09kmGTeJ3GpZ6vH//4x6nPpZdemmKloLlu165dtTbl65QpU1KM5tubbrqp1iaxPrFp06YU0zym+ZeuOc1Fmns099EcSfVaxYwkNqS6RfOmfieqsTTn07hUUSmtMWhNUQqSTKuUk/qQnJEk9ypXpe9O608SXD799NO1NtU7kkeTfFzlvySgpDwgQaeOy/vvvz/1obyeNGlSiqnQkiTyNB7uuOOOFLvyyitr7S1btqQ+JP8sCZ1znStIfE+1ZMGCBSl24YUX1to0l5999tkpRvOt1ji6LiTIJwnzrFmzau0ePXqkPiRBJ3mxjh0aE7RmpPGrY5/Gr85dEXwPo9JmEgSr/Lok9MIIHZ8klh08eHCK0fykcmpaC9IaesCAAe1+Po0jun+hcaN5pnNaBNeze++9N8VUtk3rFRIoU/7oy0voPp9ePkHrT71GtN6icdMW/osZY4wxxhhjjDHGmEL4wYwxxhhjjDHGGGNMIfxgxhhjjDHGGGOMMaYQfjBjjDHGGGOMMcYYU4j9yn9JFKTyRxJIkRSMZDgDBw6stUkKR0LgLl26pJgK90g6SqK1cePGpVjXrl1rbZIrklxSRU4RWYZEEkwSCZM4sRlIYEeCS5U5kaiL5GMlIanTzTffXGuTGPqyyy5LMZI27t69u9YmUR59PuWHCqJIjKvysogsHo2IWLx4ca1N14quO4nP9FgpZ1UiFsHHr/lBQrtFixalGAkChw8fXmuTYEuvT0noWFTMR/LfiRMnppjKMSMi7rzzzlqb5Hpr1qxJMRU0RmQZL9VZipGEVcVtNEeQAJEkf2vXrq21VUzd1ufTnKMiNxIizpkzJ8VIOqrSvPHjx6c+lOulmDt3boppLtL8q8LbCJbkfelLX6q1H3nkkdTn0EMPTTG65lpvXnnlldSHZJw0n6sonWSEJBWkuq45RaL5ZuduHW8kVyRZO6HrB5p/6ByWgmqGrpVovlyxYkWK0TjXcU3XSaW+EVyTtD4PGTIk9aG6S4JLlf+SrJoEmjT/6hqbxi6tE1auXJliCtV5yimSzE6fPr3WJsExvSSgJFSDNEbzNIm4VfQbkc+n3tNEcI7S2kxfDECyUIrR+l5fEEHXinJh8uTJKabS/HPOOSf1ofmQaoEKeuk8Ux2nY1WBOv0+yu1SkLBX5zCSL2/bti3FKH90Pr/88stTn969e6cYiej1eo4cOTL1oTU6zYe6Vqa5j7435Znmz9VXX5360LxB+anzEM0bVHvpvk3HJd0f0DhtC//FjDHGGGOMMcYYY0wh/GDGGGOMMcYYY4wxphB+MGOMMcYYY4wxxhhTiP06ZrZu3ZpiuoeM9tKqoyWC98ktW7as1lZ/QQTvDSZHxejRo2tt9RdERAwbNizFaO+Z7okm9wF5PmifnH5H3UfaFrSnXq8H+Xd0f3IE77lT1NETwfs6S0JuA/VB7NixI/Uhj8QNN9yQYuo5ueWWW1KfCRMmpBjtTddrRWNCXQQR2S0SkfdEq3MmgnOb9pOqP0b3uEbwXnjqp+NEPR8R+fpERJx99tkpps4fcl10JJcC1Sr1JJD3hzxXtB9Vaw75A2hPNTkLtMbRsdNeb6r/WpfIt0AOCaqhuueafACrV69OMdrbrC4a+izyMpA7qW/fvrU2nVMaD6UYMWJEiu3atavWpvmK6hZ9V3XG0bWkeZT2m+vcrS6ECF5T7Ny5M8X0mlM9pZpBbiatn0uWLEl9zjjjjBSjfel6/DNnzkx93nnnnRQjH47ucac1BuV6KWgf/Z49e2pt+u50nahO6ZqHrjnF1JMRkX0a5DYiRwV5B3Se0/VoBNdTcmjddttttTatdylXqO7qfE+eJFoz0fpTPSW0rqR1SEmovugcTHMfrT/o+ql7g1xbNMfQukhrKLnnqDaS01P9HOTSpHmU7rd0PUjeJfLC0DhUN8qjjz6a+lCO0u/UeZpqD52bUtDx6Zjt1q1b6kP+LapBOj4pX8lNQz4pdWaRh4Zyke7RtE6MGTMm9SEnYM+ePVOM8kXp06dPii1cuDDFtMbpvXoE139aS2l+0jqK3HZt4b+YMcYYY4wxxhhjjCmEH8wYY4wxxhhjjDHGFMIPZowxxhhjjDHGGGMK4QczxhhjjDHGGGOMMYXYr/yXJKAqJ1KxWwTLykgOqDIc+iyVGEawFO7++++vta+55prUR2WTESyvVBknnQcSH5GgUwWpJBAkYRLJrlRiS0JZkgurWJWOgwSkdG5KQrI5zaGLLroo9bnxxhtT7Bvf+EaKqaSNrgsJLa+77roUu+qqq9o9hu7du6cYSeFUZE1yNJJNjRo1KsVUQEbyQfqOJP9S8SXlGUkdSch333331dok8KIaUgoSq6lEjfKVaiOJTS+55JJau1nZOAnmunTpUmuT1JuEnCSFU3kcXXM6hmbksJT7JIUj0aDK5Tds2JD6kOyWpOf/+I//WGuTPJzqeClIZP5Hf/RHtfYzzzyT+tC1W7BgQYqpVFDntAiWCjYjpSWZH0lMKaafv2nTptSHBII0r6lMcdq0aanP448/nmI0b2rNmzRpUupDAncVtUZk2S3JLEnUWgoSkit0/mmM0TUfOHBgrU21k8S4NJ9oHbz00ktTH1oDkOBV14i6Ho3g9S3JzVVCTOON5lUagzpv07qVRLe0Vtb5jESxOo+XhmT7KqWlWk5zGM2RKkk99thjU5/jjz++vcOMiPyyALrGJBsfPHhwimnOLF26NPWh+wcSYOs6g/KRahC98EWl+TQvqdQ3gu8DVeit65wInt9LQeNf13V0vFRTaa4gybRCL6SguqG1l2oeyWzps3QsUY2g+1265irEJjkvSaf1xS4ReQ6mNTbda9F31HmIcpFyvS38FzPGGGOMMcYYY4wxhfCDGWOMMcYYY4wxxphC+MGMMcYYY4wxxhhjTCH8YMYYY4wxxhhjjDGmEPuV/5IAS0WkJPJUwVMEC0VVlEV9SHD50EMPpdgFF1xQa5MMlWRXJJxU0dGyZctSHxJQHnPMMSmmAiwSOZGgcPv27SmmP0viQZLcqSQrIks1SQBHosGSUF6ptJGEgSRrmjNnTooNGzas1u7Ro0fqQ3K3sWPHppiK20j8tWTJkhQj9Dq8+OKLqQ8J7I444ogUU5kVCeZIeEX5ocfRq1ev1OeWW25JMZJpq9SL5K0dSf5Lgrq//uu/rrW///3vpz4//vGPU+zP//zPU0wlwZTXVC8pZ1UoR+eRpHPUT2M0JimnSBSp8rgdO3akPlRTSbystfELX/hC6nP33XenGAmOv/rVr9bav/zlL1OfF154IcVKoaLfiFwzSBpJ1/faa69NMb12JMGl+kASVr3GVLdInEo1Y+LEibU2Sf9mzpyZYiozjohYv359rU01loSLVPs1z0icfsopp6TYokWL2u1H44HWMKXQ+TgiSxzPPffc1IfkpLS2VOh8kOCW1msqwqSXN9CcRjVW15u0DluxYkWKkZxWrzmtVXS9G8E1SXN91apVqQ/VfhJV6ssK6LPOP//8FCsJSUV1LqW1NuUx1arnnnuu1iYxLuUj1RK936Ka2rt37xSjvFVRMV0XEluTmFvXrnRvRT83fvz4FJs/f36tTddHa3EE57auPUio3pGgewCtcc2+mIHWfrruovseuk40f+h6iu4lSHBLL7fQ60S/b/bs2SlG8ujLL7+81qZrThJ3ehGHjkv6js2M+Yj8nR588MHU57epjf6LGWOMMcYYY4wxxphC+MGMMcYYY4wxxhhjTCH8YMYYY4wxxhhjjDGmEH4wY4wxxhhjjDHGGFOI/cp/DzvssBRT6RCJGEmQSsIflUiRcI8EWGeffXaKqdzn5ZdfTn1IvkRSKZWakRSIZJwk+Xrrrbdq7U2bNqU+JCUmgaYKEEnCRZJNkkCphJGuGQkXS0ICPz13GzduTH1IIkjyteOPP77WJgHco48+mmIqi47IAt2BAwemPtdff32KqRA1Iks6SXJJAjuSPut3OvXUU1MfElPSZ+l4IiEZjd958+almOYfSR1p3JeCxM1jxoyptakGUd7RZ6mQsVu3bqkP5QpJG/U4VOIYwWOLpHMao+tLcjQSyeucQDlGMkUSrmrNJvnamjVrUozmOJ1LSORJ57AUq1evTjGtg1R/nnjiiRSjOViFgSrqjuBaSTml0lISCZOQmSR8WmPpRQE03y5YsCDFtPbTNScZIY1drZ9U7/T3RWT5fEQ+h1Q/aMyXguYAnWNI8n3CCSekGK3N9PuTwHrIkCEpRrXy7bffbvfnaA1EdaRz5861drOCVBqXCxcurLUHDRqU+tB4IymxCqVpvm9GZhmR84zkn7reLQ3VM60TdMx0fpu5P6E69cYbb6QYvbhD1zy0rqQxQddKc5vWrSRqJUm8SnxpXUDnkNakOufQuaFx0kzdo7UC3aeVgu7pdB44/PDDUx9aa9D6WNeIVFPpHFFM1+Mkz6VjoHsTXWNRzdZ8jeDj1zGoa+62oHmpmZpNMXopjl5HqsW0FmmLjpO1xhhjjDHGGGOMMb9n+MGMMcYYY4wxxhhjTCH8YMYYY4wxxhhjjDGmEPt1zJAXQPeCkfuA9hvSXnLdj6l7xtv6LNqfrXsJaT8o7Ymj/Zm6B472BtK+7tNOOy3F9DioDx1Dv379Uuypp56qtWn/M+2lo32cuofwpJNOSn1o319JaJ+j7lmlPY4jRoxIMdoLrPvQKbcffvjhFDvzzDNTTDn44DzUyAdEe2l1XNDeYzo3N954Y4r96Z/+aa1NbiFyANA4VOcL+X3oO+qe5YiIo446qtamerF58+YUKwV9Lz0+2kc+YcKEFKM9tzpm6XxQrvft27fdz6c93LQfnBwCCu3FJycX7UvXPCYnCe25pv3yuh+Z8prms4svvjjFZs+eXWuPHDky9bnuuutS7Jvf/GaKfRDQvKnzB3132ru+YsWKFJs8eXKtTfMonW9yLGkukgOAXFKUZzr/Pfnkk6nP4MGDU4xqMeWsQg45mm81j8kdQ14P2oOuax0691o7S7Jr164UU28FuVzWrVuXYuSG0z3/O3fuTH3UzxURMXHixBTTGkvnkcYWOdi01lOO0XigeUSPg+YR9SNE8DpP1xM0jmhup+PXa0vnmfwLJSHvlDovyKtCLh6679A5mPKY5o+XXnopxXQ+pOtCP0frAL3voD4EjU1dG1B9pnUx5ZrOEzTn0zqSPCg6TmhdTJ9fClqbLV++vNama073jHSfoLWR5laqXTSHaV2lY1i7dm2KkbNPawn5vmj9cO2116aY1kK6R6N7WcopXUc2u5al+271bdJ4o+NqC//FjDHGGGOMMcYYY0wh/GDGGGOMMcYYY4wxphB+MGOMMcYYY4wxxhhTCD+YMcYYY4wxxhhjjCnEfuW/JAVSWdn69etTHxKrknTo+eefr7UHDhyY+pBwj4RsKtAlsSGJ4kiYppIvEgmTaJAElypg6tSpU+pDscceeyzF9HuTMOn0009PMRI6qkyLpGIkoirJ/8femwfrVV13m+sEMDYYxCiJQROa51kCjYAAg4QRwSZAAgST70vSiRN3ks7UXyWx4ySurkrsTtlxd3ViPhuwnWAMmCCEJDQggWaheZ5BEkJMFmCMbey3/7jX3Tq/9ejqBRPtK/x7qlTlvdj3vWdYe+19ju9+XpKRao6S5JJkp/fee2+KXXXVVcf8LMptyqHTTjut1iYZFEnhlixZkmJ6b/r27Zv6fPzjH08xkuWquIqkwSQkpHHYaDRqbco9EoTReFLhKgm3f/u3fzvFSqGy2YgsIiPxII1FEtxOnDix1laxW0RE//79U4z63XfffbX25z//+dSH6hnlgd5jyn0SR1JMRW6U1yS5ozlHxWqUP6+88kqKLVy4MMVUYEnSTpKzl0JrTUS+liSPplykOVivJf0+ErVSvdb6Q7JQkoqSxFFzg+StJECk49f6TD9HuU7ibj1+kuhTLpLIUEWJJAhWAX5JSKCo4ki6HiTQp3Gn9/iGG25IfUgCqnNVRK4/tK6kcUO5oWs/mu+pntKaUcW+JP/t06dPim3cuDHFdIzQGpg+n9Z+Kvak9SeJMUtCdUPHHs1NNI+SdF7rLN1PWgNRvuvcSkL+zp07pxj9Ts13krJSvaTnNJUj0/ilL0OhfvrFEpRn9Ny5Z8+eFNM6TnlMtaAUdI0GDBhQa9M9oXu+aNGiFNMvOaH1J8ls16xZk2L6nLNs2bLUh8a/SnAj8nmTyHngwIEpRs+kKuXWdwgRnFMkpddapV+uExExc+bMFKPntgULFtTa9IU+9NxzNPwXM8YYY4wxxhhjjDGF8IsZY4wxxhhjjDHGmEL4xYwxxhhjjDHGGGNMIfxixhhjjDHGGGOMMaYQbcp/SR6kIkASNpLch6RgKrciqSOJ+ki8OGjQoFqbpHwkgVWZUESWvpKMaty4cSm2adOmFFORGwntCDrvDh061NokNCJJlv5cRHPnSMKwkpBMTM9Nr3cEyxGvueaaFNNrPnz48NSHxsT69etTTOWwK1asSH1IXEjS59tuu63Wppyl8fVnf/ZnKab3mSRVdKwkPJw7d26tTbK6MWPGpBhJEK+++upa+ytf+Urqc88996TYZz7zmRQ7HpC8T89VhcYRzYvPHnrooVr71ltvTX1oPFAu3n333bU2yQ6nTJmSYiTDVEgmOXny5BRT6V9Elq2R6JfkmzTGVYpKAlmV40VEHDp0KMXuuOOOWnvOnDmpT3uqjZdffnmKzZs3r9amOYAkdnTddN4kCS5J/0hqrzLbUaNGpT40r+n8HpHzn8YRCfeo5qnskESNBH2+itLpetE6gGTzKiGldQfNU6Ug4bPKzWmcb968OcXoPqlcmK7/zp07U6xfv34pNmzYsFqb1k4k+6dc1/UmiSup7pLNWwd5AAAgAElEQVQEWvOaRL+0lqX5QNc+JGfu2bNnipFUU9cAdD4qMy0NrYt0fNIcQGJTqmd6DWis0xcn0Ppe5zC675TvdKw6xkjOTsJ/kiXrMx6JZ0mWTDmk45xqAUFzvtZQEnzTdS4FPYfo2KPnMJJHk8RXxz/NJ/R8QXJhFT5T/uiX5ERwLuoXM1Dtoi9roLWIPjtQPaPxTF/yoGOX1h20pqBnIb0fJOSm+eVo+C9mjDHGGGOMMcYYYwrhFzPGGGOMMcYYY4wxhfCLGWOMMcYYY4wxxphC+MWMMcYYY4wxxhhjTCHalP+qqC8iC4VIhEPiMxJJqjCHpGok+iUxnwqMxo4dm/qQKIgEVf3796+1SfRI0suLL744xVTutHXr1tSHBHCE3o+TTjop9SF5F4kG9b517do19XnrrbeaOq7jBUlpNddIhEnnQef7k5/8pNZesGBB6kPy3+uvv/6Yx6WiwYiIlStXptinP/3pFFNZFo05OoaXX345xVSQtmbNmtSHpIvbt29PMT0nEv3SMSxfvjzFVHR31113pT7NjpPjAYm+VRJLtYtEayT0GzlyZK1N11/luRERn/rUp1JMf1ZlbBF8n+hYtWZTraf6THJAlcepcC6C6xlJ/lR8R/MNjZtevXqlmEraSKJHEudSPPnkkylGx6ycccYZKbZ69eoU03whiTLlCok3VQ5KcxjVyo0bN6aYCiFJRkryaBK6aq0nCSPJGynP9JxIik6SRF13ROSa8uyzz6Y+U6dOTbFS6BwakdctdD0mTZqUYjRP6NxEa1QV70dwHdE6RV8IQPWNcl3zhcbWU089lWLTpk1Lsfnz59faJNmktRCtc/T4VcQcwTJ+miN0rUxiVRIvl2Tt2rUppuJ+OlcSgZKMdNmyZbX2Jz/5yaZ+ju6VrsWofpIQmJ5rdK1EAllad1A91uOiuZzk/rReUxEyfeELrUVI3q2iZbqP7Un+O2TIkBTT+kXi2mbXH3rvaO4jOTuti1RmTrJhyjt6BtbnT5ozteZF8Bys8yatBekZm66h1iqSe9Nalt4H6LMPzTeW/xpjjDHGGGOMMcacAPjFjDHGGGOMMcYYY0wh/GLGGGOMMcYYY4wxphBtOmZ+9rOf5R+Qfdy077pbt24pRnvUdI8j7RejvWHkTFH3B+1vHDRoUIrRXj3dB0nuG9pLR74OPf5m99fR3kjdl0r7TRctWpRitOda9y0vXrw49aF71t6YPHlyrU37/9TREsF7tDVn1PMRwR4A2nOre8xpXzp5bqifxmgfMI0d8hjo/l1yl9A+cdrnrvlI+4XJAUC5rT9L+4XbE7pPPSLnz+DBg1OfmTNnphg5ffQaUU3t0KFDis2YMSPF1OtBtZHcEORf0bym67B+/foU0/3gEdltQHlNToTNmzcf8/NpzzvdD3IJ6Jwwbty41IecJ6WgueiNN96otWkub3Y/u86b+tkR7KnQfeoRed843V+q4VR3dS1Ce7jpnpO7RP1GVLf27t2bYjq2InKNpXOkOenhhx9OsWuvvbbWprH19a9/PcU+97nPpdjx4EMf+lCK6fn37t079XniiSdSbMSIESmmXi2aS8hR0Uxtodrct2/fFCO3gs6/5I8jP903v/nNFNOcIl8BuW/IraD9aM1I6wTyj+jYpetAvoqSkKdFnS80H5LfgtZKmh/3339/6qOeyQjObb12dA+odlG91FpF9XnHjh0pRuNJ51Jy29GcQGtG9YLRXH7RRRelGDk9dX6he03r6VI04/qk8XPeeeelGNUSrTn0bEvrFnrOUajeXHbZZSn20EMPpZjWCfKk0b0j1BlFa2CaI+lZVp/r6f506dKlqePS30l5R7X3aLSvKmqMMcYYY4wxxhjzS4RfzBhjjDHGGGOMMcYUwi9mjDHGGGOMMcYYYwrhFzPGGGOMMcYYY4wxhWhT/tujR48UU3EPyR9JvrZp06YUUzEfiXFJCtS9e/cUmzt3bq1Nwi0SIJLATOW/JM4iESDJDl966aVam4SLJDol0ZiKGUm8rELECBZ6qbB2+PDhqQ+dT0lIAKnyNRJLvfPOOynWsWPHFFMZL11fylHixhtvrLVVlBvBsimSzun9o/OhGAm7VLa2dOnS1IdEWatXr04xvYYkkyNxGYlZhw0bVmuTwIsEjqUgYfctt9xSa5PwliS7JFHTukHCPaoRJM7TPKOaRzLS2bNnp5iKIunnSPpHea35smXLltSHBNkHDx5Mseeee67W7tevX+pD9V9FkATVARJtloLknTrfUl5QHpDsTudWktnSPac6onPKkCFDUh+qsSQl3rZtW61NeUF1iwSLmj90vejnqK7rHEx1iySM119/fYqp9JLWWzQGS0FrBl3fUP0ngTVJWVX2SOOcxP5UK1WOSfeXJJv0JQ+asyQ4XrVqVYrpWjMi5yx9+QTJ/qmfrl1pXqX1Jx2XCrGpplONLQndP10XUc6SkH/KlCkpRnml0Dpg3rx5KabPOs1eS3q20i9woOtANZueFfQ+08+RRJ8+S+ccWtPTvETrJp2rKLdV6l4SEqPrszKt4+kZmOYUvW70ZTdUg+gZQCXNtDZbt25dilHN1vUT1WwS99O8pteC5nyaW2meHjp0aK1NX4BDYm1aI+mXYtA1fTe10X8xY4wxxhhjjDHGGFMIv5gxxhhjjDHGGGOMKYRfzBhjjDHGGGOMMcYUwi9mjDHGGGOMMcYYYwrRpvxXBVIRWYpFwk8S1KkcJyILnUiOREIeEgGqFI4EcyTsJcGQSnpI0koCoA0bNqSYCpRJJkRCYJJpqehWBb5H+yw6VpWLkkyOBMolIZmk5kefPn1SH5JJkmBMpXsDBw5MfVSKFRExY8aMFNNc69atW+pD1/y6665LsWXLltXaKi2MiHjwwQdTbPTo0Smm5/3kk0+mPs3IrSKybI2uTbOSVBUv0vj9xCc+0dRnHQ/+6I/+KMX0Wl5zzTWpD+UdidVmzpxZa//Gb/xG6kMSPrpuKiqmcXTnnXemmMpVI3Jtp3p23333pRjJVFW4SqLfL3/5yyk2duzYFNNxQ6I1OtZZs2al2PTp02vttWvXpj5UG0pBku+JEyfW2nQvSd5JItA33nij1qZaRvI+EgHqPaD5neTCJNBUsSmtV1SeG8H1U+e6p556KvW5+uqrU4wk4FTDFTofWp/o9aJ1AV2vUtCaQeeAZoWKhM45JG6ldaSunSLy+pNykcYIfRmErhEfffTR1Ie+mIGOX4X5dOz3339/ilEN1zUN3R/KOzpvzTMSBLc3OnfunGJaz0mSSiJZGmcqYSURO60/X3/99RTTWkW1i+4ViXE1R+leUX2m+z5ixIham2o9rbt13RqR14gkb9VnuQi+XvosSusaGquloGdNPVeam+jndO0Ukdc8//7v/5769OrVK8XoCzqWL19ea9MXINCajmJ6j+kZddeuXSnWzHuEK6+8MvWh8TBt2rQU09pIgmy6HyS11vmc6g6NraPhv5gxxhhjjDHGGGOMKYRfzBhjjDHGGGOMMcYUwi9mjDHGGGOMMcYYYwrhFzPGGGOMMcYYY4wxhahIQPpzBg8enP7jWWedVWtv3rw5/VyzAiOVtJEIjQRAJM5T6dbLL7/c1HFRTM9xyZIlqQ9JEukczzzzzFqbJFYk7CTBce/evWttkj527NgxxUiApdearhdJj19++eVixrc//MM/TPmoOXTgwIH0c3SPKYdUprxp06bUh+RWU6ZMSbEVK1bU2qNGjUp9SKhFAmkVjZJAViV0dAwRWSKrktmInLMROfcispyOco8EtUuXLk0xFZCR4JWkslu3bi2Sj3/3d3+XcnHRokW1Np0D5SLdcxVkqqw7gsesCvEisqzs1VdfTX205kVEbN++/ZifT6I+Eg0OGDAgxXSsLly4sKnPGjx4cIqpYO7yyy9Pfaiebdy4McX0utL4XrlyZYrNmzevSC7ecccdKRdVKE1SShqvb731VoppvpAEc9y4cSlG85quN0gESOI8mltVaEyi8eHDh6cYyfsUug4kqqQxotdVvwAgguXRJAHX9QJdLxK6PvbYY0VycfLkySkXO3XqVGu/8MIL6efontA8p9eSPovq2w9+8IMU01pGslWaC2kN984779TatE6gdRh9vorwSdxNNVCPISKvI2mdQNeLhMMqxCWJM0nXV6xYUWzNWFVVysfu3bvX2jSHUb0hcap++Qk9T5Fkl76YQWsJrRUo92htoNC6QMdlBF8Llf1Sfaa1LD276ZimL4+hNSPlldYMmpfoC1JWr15dJB9vvvnmlBw6L9NYpLrUjICccoyeaWis67qLjoG+7IOkxD/60Y9qbXrOp/UnrR+akcTTupvWyrpep2tKv4/qno4lylf6/O9973uYi/6LGWOMMcYYY4wxxphC+MWMMcYYY4wxxhhjTCH8YsYYY4wxxhhjjDGmECe39R9pn6zuf6V9feRHof2Ze/furbVpHzx9/rPPPptil1566TGPgfbv6flE5P1utG+U9snRHl/dE057nSlG+zN1/x7tyzt8+HBTx6p7aPv165f60P7tktD+Rd3PT/tfaX/h6tWrU0zvw5gxY1KfZnw9EXnvLO0XpvFFv1P30tJnkRPhnHPOSTEdO5MnT059yBt1xhlnpJjmH41fGjvquYnI14ucA+RSKMU3vvGNFNMxS/unyXlB10j389OeVfL+UD/9LKqDf/Inf5JiVF8mTZpUaz/11FOpD7k45syZk2KaL7/7u7+b+pATgfZJn3766bX2N7/5zdRH54gI3l/dv3//WptcFzR2S0FzndYk6jNs2LAUo73kOhbJz0Xuk/nz56eYumh27dqV+vzkJz9JMao/ug+e7iW5gG6//fYUW758ea1NrgX1YEXwukb3+tM1PfnkvPQin5Jee3KS0GeVguYO9VvQ8ZI7o0+fPimmXj26ZrqujGAnoOYeXVsa+1ofIrIXg9wW5ASk3NB5m/x0VOcpZ3XNRMdF/hHyoqhvQd0REbwWKkm3bt1STHON1hq0dpo1a1aKaQ0lr9+1116bYnSdNIfoHtPaTz2LETnXaC4nN00zzzq0ztP5NyJizZo1KabPHfRZ9NxBY+DUU0+ttWlN37Vr1xQrBblKdT6k512aD8nvorWKahfdX3qmUfce1RZywNBzq7qTKK8pP+m5jfopzXgDIyKmT59ea+saIILXHeSf0pryxhtvpD7kODwa/osZY4wxxhhjjDHGmEL4xYwxxhhjjDHGGGNMIfxixhhjjDHGGGOMMaYQfjFjjDHGGGOMMcYYU4g2rXG7d+9OMZVXqrAqgoU527ZtSzEVc6nMKYJltiTm2rlzZ63dvXv31IfkOyTyUZEqCcRIuEXCNIUkuyT/JeGTCphIHEcyY5IWqvCJrg39XElGjhyZYir6I8kfSZ1Gjx6dYiqz+/CHP5z69OjRI8XoXl1++eW19uLFi1OfTp06pdiBAwdSTKV7AwYMSH1ILHbFFVekmAq76B6TcHXp0qUpNnbs2FqbZG80Vqk+qDCWZF3tKR9Jcqa5QbLqe+65J8XuuOOOFNPrtn///tTnqquuSrF58+al2F133VVrf+tb30p9SFb23e9+N8VUcqa5GRHx+OOPp5hKuiNyHi9btiz1oXmDapzmLInYSTRLEkY9p4ULF6Y+zUjojhc0VnSephpIcmoS8+lcRxLTBQsWpBjJlrVWDh48OPUhOTUJ/7UekICS6jVJPHXeIFky1WZaB+ha5OKLL059SBpMsmRdE9FxkYS1FFTbVT7e7JxAkmldr9FcNXXq1BSj9Y0KRUlcTMdK8mKtzzRGSHBM9WfChAm19uzZs1Mfkv2TLFmvIR07rVupxup6iCTv7akuRvCXKaigl46ZahDJxdetW1drkxSeZLaU75pDtN4hCSutDXRu3bp1a+pDuUDXQsfck08+mfrQsxt9lo4Byn+6zjR+dS1L50OC2lLQXKS1kcYwPdOQsFrHp352RMTAgQNTjL5EQusefeECCYipLulx0f2lZ2CazzVfSJZMOUXzrc7TJIqm86HaqFJlutckBj8a/osZY4wxxhhjjDHGmEL4xYwxxhhjjDHGGGNMIfxixhhjjDHGGGOMMaYQfjFjjDHGGGOMMcYYU4hKpTXGGGOMMcYYY4wx5vjgv5gxxhhjjDHGGGOMKYRfzBhjjDHGGGOMMcYUwi9mjDHGGGOMMcYYYwrhFzPGGGOMMcYYY4wxhfCLGWOMMcYYY4wxxphC+MWMMcYYY4wxxhhjTCH8YsYYY4wxxhhjjDGmEH4xY4wxxhhjjDHGGFMIv5gxxhhjjDHGGGOMKYRfzBhjjDHGGGOMMcYUwi9m3iVVVTWqqupV+jiMcS6a9oJz0bQnnI+mveBcNO0F56JpTzgfmRP6xUxVVXuqqvphVVVvHvHvK6WP6+dUVXVrVVVbq6o6XFXVoaqqvlFV1ZnQZ3NVVT+oqmpnVVUTSx2vee+c6Lkox/1mVVU/rarqyyWP2bw3PgC52L2qqserqnqtqqqDVVV9paqqk0ses3nvfADysX9VVfNa//uOqqp+teTxmvdOe8/FI2nNucaRta+1Ns6vquqtqqq2VFV1VcljNO+dD0Aufr6qqvVVVb1TVdVnCx6eeR84kfOxqqqOVVV9u6qqA63z9DNVVY0tfZzvlRP6xUwrH280Gh894t+nSx/QETwTEeMbjUaHiLgkIk6OiL/7+X+squrqiPg/IuJTEXFGREyKiF0FjtO8P5ywuXjkcUdEp4j4YUR8p8iRmveDEzYXI+KrEXEoIi6IiGERMTkifu94H6R5Xzkh87F14fe9iHgsIs6JiN+OiPurqupT6FjNL057zsWIiKiq6jeiJQ+Vb0fE6og4NyL+R0Q8WFXV+cfz2Mz7yomcizsi4s8iYsbxPSLzX8iJmo8fjYgVETEyWubpb0TEjKqqPnqcD+994YPwYgapququ1rdmX259g7alqqopR/z3C6uqerSqqldb/1+w/37Efzupqqr/vfUvWN6oqmpVVVVdjvj4q6qq2t76/+j+S1VVFR1Do9F4vtFovHxE6KcRceSfbX0uIv620WgsbTQaP2s0Gvsbjcb+9+kSmHbCCZKLR/LJaHkwXvTez9q0R06QXOwREQ80Go23G43GwYh4IiIGvi8XwLQrToB87BcRF0bElxqNxk8bjca8aHmRc8f7dQ1M+6A95GLrZ3WIiL+JlofeI+N9ImJERPxNo9H4YaPR+G5ErI+IT7xPl8C0E9p7LkZENBqNbzQajZkR8cb7c9amvdLe87HRaOxqNBpfbDQaL7TO0/9PRHwoIvq+bxfhOPJB//PwsRHxYEScFxE3RcRDVVX1aDQar0bL//OwMVoWXf0iYk5VVbsajcbciPjjiLgtIqZGxLaIGBIRbx3xuddHxOiIODMiVkXEf0bLw0OiqqoJ0fJG+czWz/jV1vhJETEqIh6tqmpHRHw4Ih6JiD9tNBo/fL8ugGk3tNtcBH4zIu5tNBqN93y2pj3T3nPxnyPi1qqqFkTE2RFxXUT81S981qa90p7zkRaJVUQMeq8na9o1xXMxIv4hIv6viDgo8YERsavRaBz5ILw2/NL6g0p7zkXzy8cJk49VVQ2LlhczO979abYDGo3GCfsvIvZExJsR8f0j/v331v92V0QciIjqiP7Lo+X/6eoSLf+v2BlH/LcvRMTXW//31oiYfpTf2YiICUe0H4iIv2jiWC+KiM9GRJ/W9oWtn7UyWv5k/7xo+X/i/r70dfW/X65clP/WtfV4epS+pv73y5mLEdE/Wibod1o/9+tHHq//nVj/TuR8jIhTomV78Z+1/u9rIuLHETGr9HX1vw9eLkbL/1m3Jlr+T9PurT97cut/uyMilkr/v//5MfjfifXvRM5F6Xd/RHy29PX0P+dja78zo+UvCf+y9DV9r/8+CFuZbmw0Gmcd8e9fj/hv+xutd6qVvdHyQuTCiHi1Uf9/HvZGy6IsoiXRdrbxO498W/dWtOxva5NGyxalJyLi31tDP/+rmC83Wv786uWI+GK0vFU0JyYnai4eyZ0R8XSj0dh9rM8x7ZoTMherqvqViJgVEQ9FxOnR8sL67GhxcZkTlxMyHxuNxk8i4saImNb6eX8SLYvHfcf6LNNuaZe52Fr7vhoRn2k0Gu/AZ7wZLQ8dR3JmeCvJicyJmovmg8kJnY9VVX0kWv7iZmmj0fhCG7+zXfNBeDHTFhfJfrWu0fLW70BEnFNV1Rny337ud3k+Inr+FxzPyT//3Eaj8Vq0LO68XeSXg3abi8Kd0SLOMh9c2nMunhMtE/lXGo3GjxqNxisR8T/DL6w/yLTnfIxGo7Gu0WhMbjQa5zYajY9FiyB4+X/B7zXlKZmLZ0bL/yv8H1VVHYwWmWVExL6q5ds6N0bEJXIMQ1vj5oNHe85F88tHu87HqqpOjRYdyP6I+J1f8PcV5YP+YqZjRPxhVVWnVFV1c7T8ifzjjUbj+YhYHBFfqKrqw1VVDYmI34qIb7b+3L9FxOerqupdtTCkqqpz3+0vr6rqN6qq6tr6Gd2i5c9O5x7R5X9GxB9ULV/1dXZE/K/R8u0P5oNHe8/FqKpqXLS85fa3MX2wabe52PqXg7sj4n+pqurkqqrOihbn0dpf8JxN+6Xd5mPrfx/S+vtPq6rqf4uWrcdf/0VO2LRbSubi4Wj5f5+Htf77+cvokRGxrNFobIuWP+X/m9Zj+NVo8TV8972frmnHtNtcjIhoPa4PR8tz5Mmtx3LSez9d085pt/lYVdUp0eK/+WFE3NloNH72C5xncT4I8t//rKrqp0e05zQajZ+L+5ZFRO+IeDkiXoyIT7b+P7ARLTKi/zta3va9Fi2m+zmt/+2LEXFqRMyOlj+l3xJHF6W2xYBo+RP8s1t/x+MR8ZdH/PfPt37+toh4O1r+RPrv38PvMe2DEzkXI1oegB+SP0k0JyYnci7eFBH/Z0T8ebTsXZ4fEX/0Hn6PaT+cyPl4R0T8t2hxzCyKiKsbjcaP3sPvMe2DdpmLrdsE/r8/62996I2IePGIP9+/NVpeCr4WEc+1Ht9L7+b3mHbFiZyL/xota8af8z8i4lPhl9YnMidkPlZVNTlaJMI/jIjvV///H/Zc12g0Trhvl63qW8Y+OFRVdVdE/LdGozGh9LGYX26ci6a94Fw07Qnno2kvOBdNe8G5aNoTzsfjywd9K5MxxhhjjDHGGGNMu8UvZowxxhhjjDHGGGMK8YHdymSMMcYYY4wxxhjT3vFfzBhjjDHGGGOMMcYUos1vZerfv3/6c5oLLrjgmB+6Y8eOFBsxYkSKbdiwodbu06fPMT87ImLz5s0pNmnSpFp7586dqc8pp5ySYlXta9lb6N69e629ffv21Gffvn0p1q1btxT7lV+pv/t67bXXUp++ffum2Msvv5xiP/3pT2vtj3zkI6nPSSflb6s7//zzU0yv4dtvv536dO7cOcVmzpyZL9hx4mMf+1jKx71799balENbt25NsTPOOCPFDh8+XGvT+dPPbdy4McUGDhxYa9P1feWVV1LswgsvTLGDBw/W2j/+8Y9Tn65du6YY/c6PfvSjtfbatflbiOmz9Bgi8ng67bTTUh/K7V27dqVYv379jnlcOi4jIh5++OEi+XjTTTelXNR8OXDgQPq58847L8W0RkREdOzYsdbes2dP6nPWWWelGNUzzQOqEd///vdT7MUXX0yx0aNH19qrV69OfajeECefXJ9+LrrootSHan2PHj1S7Gc/q3874vr165s6hg9/+MMp9pOf/KTWHjRoUOpD88ujjz5aJBdvv/32lIt6jSjHli1blmJUMzQ3aO47++yzU4zy85xzzqm19+/fn/poXhzts3r37l1r0/xO0F8JP/jgg7X2xIkTUx/KlUceeSTF9Gd/8IMfHLNPBI9dzX/6fRMmZB/jokWLiuTiNddcky6urnmmTJmSfu5b3/pWivXq1SvFXn311Vqb1qMvvPBCitFa6UMf+lCtTflDseHDh6cY1WdF1yoREZMnT04xrak03i699NIUo5qka4WPfexjTR2XXpuIPCdt27Yt9fnhD3+YYqXm6IiICRMmpHzcvXt3ra1rogg+f6pLen1pDUSf9dZbb6WY1t533nkn9dH6GRHx+uuvpxj9rNKlS5cUo7Gjn0W/T3MjIqJDhw4pprlMfeh6vfFG/qLQiy++uNam+vnmm2+m2JIlS4rk480335xyUedWqlM0pvRZMCLizDPPPOYxvPRS/gK3Tp06pZjeY5r7CF070c8+99xzqU///v1TjOZpPX76feeem7+Jm/JAr+upp56a+ui6MoLXt3rtaV1Def3II49gLvovZowxxhhjjDHGGGMK4RczxhhjjDHGGGOMMYXwixljjDHGGGOMMcaYQvjFjDHGGGOMMcYYY0wh2pT/kjBQJUwk1SEJLokkVe5GorWlS5emGMnXnn322VqbhEkkIN60aVOKqZiLZD8kZCNZnYphSZg2ePDgFCPZld4PknjSNSTBlkJiIjrHkhw6dCjFVJ71/PPPpz4kWiOJ2o9+9KNam/Kf8pjEWPPmzau1hw4dmvrQ2KGYyulOP/301IckqZSPKg2j3CCRG7FmzZpam86RJFh0jvPnz6+1SXDcnvKRxovKw0hSS+egeReRJZfUR+V3EZyfeqwquY7gHKaY1iWSlJOkmcalji8ab82OQb0WJBIm6RxJZbWuUi3u2bNnipVi9uzZKaaiShLE0rmr3DkiS/pJik5Sa5IR6vxE8xWNfboHmnvDhg1LfUi2T7Vy+vTptTbJXEmoSbVShYRU70hQqGM+ItdwElE384UMxwsSKGodoZrxqU99KsWo5uk8QXM7XQ/Ka61JOp9FRFxzzTUptmrVqhRTaT/JsEmsTWJovV5UT2nckAhTfyd9UQHVeRLdDhgwoNam60VjtyR0TfR60rimGIlAdT1Fv49qF4lqNW+bEfFG8L3S46B8pOOic1ShMeULHV3uZKUAACAASURBVBfJW/UcaX6ndT496+gXUtAXc9D5lKKZsU5QTaX1p451Onda71Nd0vtENZuOi+TF+vlUn0lcTms4zUWaIyjvKH809+h60RqJrpeuM+j+vJva6L+YMcYYY4wxxhhjjCmEX8wYY4wxxhhjjDHGFMIvZowxxhhjjDHGGGMK8a4dMwrt3dqxY0eKqSeDfpb2mdH+WnIr6H7hfv36pT60v45cNLpfmPbXkedj69atKab7y6dOnZr6rFixIsUGDhyYYrpvrdn9wuR30D3utKf+kksuSbGS6J7SiHy+o0aNSn3I60E52rdv32P+HO05vOyyy1JM3QO0/5XGV7N7iBXyydDnz5w5s9Ym9wTt26cx17Vr11r76aefTn3I5UP7sPXzO3XqlPrs3r07xUrRu3fvFNOcoj3cuic9gu+d7pOl/a/qV4qI2Lt3b4ppXlMO095gunc6JoYMGZL6NOMniMh7ddetW5f6kKeH9hBv3779mD/3+uuvpxjtBdZ9zGvXrk19mvUwHQ/IV/LHf/zHtfZ3vvOd1Ifu0wMPPJBi6m4hnwztn9Z7EpGdbuSLo1pD+7p1bqX6Q+sT8gOpE4zmPtrzTuuAPn361Nrf+ta3Up9//ud/TjGau8eNG1dr33jjjanPvffem2KloLHyyU9+stZ+5ZVXUp8lS5akGNUknReoRi1atCjFaI7WcXPgwIHUR92FEeyq0vtEx0CfNWnSpBTT86Yc27JlS4rRtdC6Sz4qWjNRXfz85z9fa5Mbkdw3JaH1lDpMaD6ksU41Ttck9Pto7Ueop4I+i9ZmzXh0aCxRHtN5K+S+oTmBckGfkejn9Pkrgq+9Pg8047QpCfnO1MNG95LGP/lq1PlCP0fzKK0t9XmQPKsEOV90XqPnOPp8en7R9wj0/E7HQGNQ84V+n64Fj9ZP7xv59eh54Gj4L2aMMcYYY4wxxhhjCuEXM8YYY4wxxhhjjDGF8IsZY4wxxhhjjDHGmEL4xYwxxhhjjDHGGGNMIdq0ipIoqFu3brU2SWNHjhyZYlVVpZjKiUhiSBIyklapjJMEQyQ5IjmUyulInEXXhiRiKisisRWJ3Eg6pHI6us4kKl62bFmKjR49utbu3Llz6qNy19KQkFGvCV1LiqkoKyKLWel+Ur7MnTs3xVRqRiI3ur6U2126dKm1X3311dSHhFR03r/5m79Za2/evDn1obFDEm49DhKX0fWiWqDXmoTYeh1KQkJtlamS/I6EiSRyI0FmMz9HMl6S9TXzWSQw03pM9/zw4cMpRvdcZb+UYyRLpuuqx0o53KwoTiXxU6ZMSX1IbFuKm2++OcX+5V/+pdamsUMCa6pl+rOzZs1KfWgu2rVrV4r95V/+Za39hS98IfWhuY9k4JdffnmtvXjx4tSH8ody484776y1169fn/rQ+dB43rZtW61NeUeyQ+qn4sQvfvGLqc+0adNSrBQkk1fpLa2BaH4kcfPQoUNrbZKhXnnllSn2ve99L8XGjx9fa6vAN4K/AIDYsGFDrU21k2ozya9VEqpr7qN9Ps0ZWp9vueWW1Iek6yTa1+vVzLqyNPT8oHJxqgf0RR5UQ3XdQkJ1yiGS3p599tltto8Grf10DqbnFRpzNJ/rMwyt6V566aUUozW2SvPpHEmSSseq95bmDXoeKgWdq45jGsO0RiHRseYBrcPoS3hUoh+R51sS06tE+2j99Fgp92nuI+Gz5gF9Fo03ykW9H7SupOcjGuMqzSbRM31Zx9HwX8wYY4wxxhhjjDHGFMIvZowxxhhjjDHGGGMK4RczxhhjjDHGGGOMMYXwixljjDHGGGOMMcaYQrQp/+3Vq1eKqVjnjDPOSH127tyZYipUpM+67LLLUp/HH388xUhaqBLiK664IvVZvnx5ipEcUOU+JGklITBJuPT6kExo7NixKUYyTpUXb9q0KfUhsR5J7VQyS3ItEjuXpBkZGglv+/Xrl2IkfFNZFkl2SXxG0upLL7201iYxJX3WxIkTU2zOnDm1Ngm8SBp24403ppj+LOUsjQkVOEbkMU25R3JGkpKp6JHGeDNC3OMFyfQ0P0lYSudOsjuVCp5zzjmpD8nEqG7oZ1HtIpEbnWOfPn1qbcp9kqjRWFJ5K/0+klxSXaKcVUii2YxceMeOHcfsUxK6Hir0oxwjgTEJ8v/pn/6p1qYxTZ9P91wlf7R++PVf//UUo7Gvx6o1N4LzhwSXOudfd911qQ/Jf2fMmJFiw4YNq7Vp7TNmzJgUozni9ddfr7X/6q/+KvUhIXApSOKo8xytgfSaRXBOqZSZ7u/+/ftTjGqxCuZVLBzBczSh6ykS41L9IWnqqlWram2Sf9J6jb44QGs9jUkS5NI11PtBOUzzSEnoeFT+S+OT5tFm5Nw0t6rwNoLXsiqQJlk0jQnKUV3n0dxKzzUkldX5hc6R5Kr65S4ROW9JFkvzC61T9bP27t2b+tCYLgXJiXU9SOsKukY0PvUekxiX6gb107pEx9CMzDgijyUaRzQG6VqolJzWDxSj/NR1ANVZ+lIc/cKZiLxGpLFF4+Fo+C9mjDHGGGOMMcYYYwrhFzPGGGOMMcYYY4wxhfCLGWOMMcYYY4wxxphC+MWMMcYYY4wxxhhjTCHalP+SROfll1+utfv375/6zJ07N8VIzPfCCy/U2ipji8hSvoiIqqpSTMWjJMYdOXJkipFUSgVGzcg5I1juRseq6HWIiPjxj3+cYnqOJFoiSaJKliOybHXNmjWpD4niSrJx48YUU4EoicNI/Ee5rT+r4sUIlm6RXFklxD179kx9SDxK8mIVUfbt2zf12bZtW4o1A4mRKR8pj7UWUJ6RxJcEo6+99toxfx9d+1KQ3Gv+/Pm1to6xCK6XJNzT63H++eenPiT0I7mbQlI1kmGT3FElbRdddFHqQ8dKtUo/S4W1ESz0a0YCTjms+RrB10ulcCqLjGBRXCkeeeSRFLv77rtr7ZUrV6Y+JPcfPnx4imku0mcNGjQoxajf3/7t39baNM4XLlyYYir9i8hyTBLIkhCVZIcqiaS5hubk6dOnp9iCBQtqbRKJUm2g+6FCYMo7Oq5S0HmpOJLWgjQ2qbboFzisXbs29SGBPs21+vm01qQaS9J1rW9Tp05NfahuUe3XvCZZMn1W9+7dU0x/ltaoJP+lL8/QsfTtb3879aG1UElImq/rWqoHlAu0HlbJ7i8ibx0wYECKKSQupxylNa/So0ePFGvmyyCo3pBkmSTBWsdprUBreJLD6r3VeSqC1xSloNqoQlh6LqF19fjx41NMnx3oOlJNpXqmeUzHTmtGejbRfKEvwKB6RsJenZcpFylG9V/nHFrnkaiY+mmu089RnT0a/osZY4wxxhhjjDHGmEL4xYwxxhhjjDHGGGNMIfxixhhjjDHGGGOMMaYQbTpmaI+X7nejvX/kldC9wRERXbp0qbVfeuml1IecDOQr0L16tG+U9urRfmfdL9bsPkXa/zlq1Kham/ZiqjsmIuLZZ59NMd2HR/vnyTVC3gB18EyePDn1IbdOSSg/1I1DObtq1aqmPl/3rDbjW4jgfeK6R5vykfbzkotmzpw5tTbtX1RHQgTviVY3EuUj7UMlL4x+Fnkg6Hpt3749xQYPHnzMPrT/tj2h94DGD+27pnqmtWTp0qWpT+fOnVOMXFGjR4+utWlv8Lnnnpti5KvS/bXkz2h2L61eC3I6NeNvisheM9pnTHvqyUWjtVHnlgg+71IMHDgwxbTmqbcign0lS5YsSTE9V9pvTrWZ3ApaB1988cXUZ8SIESlGTiftR26R9evXH/MYIrLfjvbwz5s3L8Uo19W3Q+4PWis8/fTTKfbnf/7ntTaNkdWrV6dYKWjuWLduXa199dVXpz5U27du3Zpi6vSg60jXiPJH13Xk6iDXCK2VtEbQ2CIH0qOPPppit956a61NcyHVeTp+zU9yzDz22GMpRs4ojVFNeeaZZ1KsJFS7tS6RY4PW/LReUxcHzQuUQ+S+0bXSaaedlvrQWoF+Z8eOHdtsR/DYoecHXVOTH4fmUfJ06RqJxj2tNen49TjIU0LnWArynOjxkfOOrtGBAwdSTJ8LtFYe7edoXaQ5S+4kmvsoD3T9Sc8v9NymzsaI/G6B5j7yldGziX4W1Wy6Z7S21HOi8U3PiUfDfzFjjDHGGGOMMcYYUwi/mDHGGGOMMcYYY4wphF/MGGOMMcYYY4wxxhTCL2aMMcYYY4wxxhhjCtGm/JfESSo1JVkR/RzJAVVeSbJJEvaOHDkyxVQESJ91zTXXpBih0i069maFwHv37q21SdSofSJYFKfSTpKD9evXL8VIonf48OFam+5Znz59Uqwkd9xxR4rptSPZLMkeKW9V6qRC0Qi+JiS7VlHcBRdckPqQCJakz8uWLau1SYhKolmSvKqI8vzzz099KF9IgqXC2Lvvvjv1mTFjRordfPPNKbZgwYJa+6233kp9SORXChqzKuMmkTOdF9USzReSV5Lkku6TSs1INk4icaolKjUjmRxJs0kKqfJo+n1apyIiOnXqlGI6Lin3KUbX/rLLLqu1qaaQaLAUN9xwQ4rt2bOn1iZpJEHCXr22JCxVeXcEy/RUUEqSPPo5EiBq/lxyySWpD403/dKBiCxApTpMQtSVK1emmM43JP9UwXQEj8vZs2fX2rQuIBltKUjcqcJPykWSTpM0WWXRzQimj9ZP5ZgbNmxIfT7+8Y+nGNX1Xr161dokUaUxoj8XkWserVWo9pP0UsWwNLfTGoAE67t27aq1SbZNn1USqt3N1EJaW1Mt0XtFwlWaw6jG9e3bt9amuYm+rIFqo445Wt/Tz9H90y9uoWOgdTGtSfVa0BqY1sqU77peJzlze4Jqowp0SYz7/PPPpxjNYXrvSNJPcxEdl+Y/CabpPlGe6XqQxh/dX4rpOpX66LoggseS1lV610B5TfdIryH9PqopR6N9Z7IxxhhjjDHGGGPMBxi/mDHGGGOMMcYYY4wphF/MGGOMMcYYY4wxxhTCL2aMMcYYY4wxxhhjCtGm/JckTyq3IjEZSZhIert79+5a+/vf/37qQ8I0EkapdOjOO+9MfUiORrLM733ve7W2CpoislwxIstQI7JsiWRvJDAiQdLChQtr7TVr1qQ+JPTq0KFDiul1JTmnihpLQzIxjb3wwgupzymnnJJiJLPq2LFjrU1SzUajkWIkhdOfJRnU+vXrmzouzVE6x82bN6cYCWpVVExCKhpfKkSNyHJkEshSvtP9uOiii2ptEnhdfPHFKVYKkgqqfI1kxVRvSFaptZDygu7dmDFjUkxzlnKYpH90D1RyRrVl0aJFKUYiz5kzZ9baf/AHf5D6UE3dv39/imltV7F8RMSKFStS7NRTT00xvbckOG5P0LibNWtWrU2CcpIDjh49OsWeeOKJWpskuDqXRzQn/6V8nT59eorRWOrRo0etrTJI6hPBtVIlxKtWrUp9SNhLY1DXC7RGovy89tprU0yPg+41nXcp6Pi0Rtx///2pD80JNA9p/tD1p1qjAtOIiPHjx9fa//AP/5D6ECT/1eOnNTCNN1rnaa3XdUkEjxs6R70fVAOnTZuWYgMGDEgxHeM0HoYMGZJiJaF5WucUmg9JFq3i6YjmvnSEhKv0LKKSV5UBR7BYn6TnOq/RcwHVZxLBaj7SXEJfkEKSVJWXk3CVjqsZkS3V2Wal98cDen7R+0THS2toejbT601zJtXZZvpRjtEzPcl/9Z0BrSvpGOhLfnTcTJkyJfWh+Z2OS9e8NObpWYueQyj3FKozR8N/MWOMMcYYY4wxxhhTCL+YMcYYY4wxxhhjjCmEX8wYY4wxxhhjjDHGFMIvZowxxhhjjDHGGGMK0ab8l4Q5r776aq1NUiCS75BAVyVPEydOTH1UiBWRRaEREf3796+1Dx48mPqQpHX+/Pkptnjx4lqb5LwkXyIJn4qC1q5dm/qcffbZKbZx48YU02tIP0eSLxKgaaxLly6pDwm3SrJly5YUUwGVShwjWCpNkkKVDZLQieSYNE5U/rds2bLUZ+vWrSm2ZMmSFDt8+HCtTaJWlX1GZLlhRBaZksCrT58+KbZr164U0/G6dOnS1IfGr8q1I7JskMYciQtLQfJFvZ8kRFX5XQRL8vR6q0AtgkV9JB/Uekm1+Kabbkoxkvxp/aLP2r59e4qRRE1z79lnn019Ro0alWJUx/v161drqyg9ImLo0KEpRvLf2bNn19okYSQRZCk2bNiQYnfffXet3ayAcvXq1Sl2wQUX1NpUYy+88MIUIyGkigxJ8Ec5RXO+CtVJIKjrlQiunyrgpjmzU6dOKUbXQiWP9HM0l5HgW+ekqqpSH7pnpaD5RNdYJJJfuXJlitG8respqp30WVRHVOJLn0W5Qv303pG4mL4AgESnuo6k9QWtNWmMa/5Tvj711FMpRuvUCRMm1No0vqkWlYTk0Dt37qy1SdRMElaaD3Veo3UlyZtJNKpjm9b3dFwkU9V5jfrQtaH7p/Wf1mGUe1SrtO6R3J8EtbSu0XmCjkHXziWhNZzWDZp3qA5S/mi+UB+K0XOePvt069Yt9aE1Oo0lPX6a32kdRl8soTlF14ae/UnYq2s4WufRuoOe/XUs0dr83Uj6/RczxhhjjDHGGGOMMYXwixljjDHGGGOMMcaYQvjFjDHGGGOMMcYYY0wh2nTM6F7MiLwvd9++fakP7cEi18ShQ4dqbfIQ0B503aceEdG1a9dam/ZKNhqNFHv66aePeVzajuA9ZHRcuidUr18Ee0VoX7Hud96xY0fqQ3vuyJWirhHaG9je9gvTPtm9e/fW2uoKiOB93OokiuA9kwq5f+ie6n1YtGhR6kP7PWnPrR4XeRPI8UB7ojUXKI/VkRDB/gbdT03XnqD9qprLdG1oTJSCaqNC50D78ukeqJeC9pbTvlzav6t1T30sEexNeOKJJ1JMawL9HB0r7TfX60M+h2bvuR4HOWC05kXw9dLxTPW/Pfm3RowYkWK6J5/8JXSNyDWmTh+aT8gBQB4VdVxQjaL8oXFDLgKFaiXNm3r8dH9/+tOfNnVc6hKhzxo+fHiK0fpHfQ5jx45NfcidVAo6h8mTJ9fatA4jKD91XqV7omvBCPamaY2ln6PPJ3eYzpndu3dPfcg/Qrmu57ht27bUh3w1NN507UPjm9Y95CpUBxj50pq9t8eLZlwu1IeuCTlM9D7QfELPQ7SW1X7qdongNRbVXp03aV1JPhNaK+t6jWo2rRlpztG8ojmfHHLNeHTofCiPS0FrIL2fdM3ItULjrBmHCV0jup/qTKHnd3rmoPWgrhfIc0XHRWNQn9tobUZjhHxN+jspx+gYaIzoeKOa8m5qo/9ixhhjjDHGGGOMMaYQfjFjjDHGGGOMMcYYUwi/mDHGGGOMMcYYY4wphF/MGGOMMcYYY4wxxhSiTfkviZlURKTy1QiWS5Lc5+DBg7W2ytgiWKhLgiSVUn7kIx9JfVatWpVidI4qOiKBIJ3jxIkTU0wFSXSOJPmaO3duiqmMkyRKJCMkEZHK8EhoRMLXkpBoWkVPJFqj3Hv55ZdTbODAgbX2xRdfnPpQvlx00UUptnDhwlqbBK/r169PMcoPvQ+DBw9OfYYMGZJiJOy6/vrra20SUn30ox9NMR2rEVk6R+Nk7dq1KUZCRf2dAwYMSH1IBlkKkvypfJHGNQlLSZip+UmyR5IRkjhPxWckuSS2b9+eYnreJEw7fPhwipGET/tRDtMYoePav39/rU05THnXjACRrinV1FIsX748xfbs2VNrk6iPpIIkENWadMkll6Q+c+bMSbHf+73fSzG9x5TXJO+jXNdaT/eJ5NEkge7Ro0etraLTCJ4zKA/0+KlWPPTQQyl23XXXpdhTTz1Va9N4a0/yX7qfeswk0Kf7S19IoGN40KBBqc+YMWOO+XMRWVRJayea02iNoT9Lx04x+iyVrdI65LHHHksxEmGqXJhqM80/dF0112ntQPLPktB9VwEynT/dK1rn6Vyh0tQIlrLScWneUp+OHTumGNU9HYf0nEZ1ltapKkunZytaa5IkXmvB5s2bUx+CPkuff+h5hfK9FDQXqTSZ1iN0vakmaA2iualz587HPM6IXINozUUyc5Ke63xLdYPGFo0bFaPT2KW1H9X2vn371tpU60lqTc/dWgfoHQXdx6Phv5gxxhhjjDHGGGOMKYRfzBhjjDHGGGOMMcYUwi9mjDHGGGOMMcYYYwrhFzPGGGOMMcYYY4wxhWhT/ksCLBV+kryMxDcqoIzIIigSW5GMigSaKh0jUR/JrkjIo6Ip+jmSKE2ePDnFrr322lqbjp2kpieddFKKDR8+vNbetm1b6kPCURVjRmQpK8n3Ro0alWLtjaqqam3NT+oTEXHuueemmOYQCdPovpCASvNq586dqQ9JNF9//fUUu/3222ttEiySXJXyViVVNC5JOqcSSupHUi+SVaqQMCJi2bJltTZJ26gWlIJkYiqPJpkY3V8S26lEjWoqCZJJNKrCNJKjbd26NcVIyKbnRPmj4rgIHpeXXnpprb1r167UZ/fu3SlGgjz9WTr2devWpVgzcxXNcSpPLwkdi+bB0qVLU5/f+q3fSjGS2i9atKjNz47geZTkfXpf6D6REJLGvo5BkvqScJEk/TpH0lqExIYkWNTrRbWZcurb3/52in3iE5+otWnO+M53vpNin/nMZ1LseEDzo9YMWqPQeZH4W8cm1RUS1ZMYVOsn1QLKH5Je6ufT/EACbpJ46jqE1owq947g9boeF60Z6Qs2SPapdZfWwLTWLAl9WYPOKaeeemrqQ+sWunaaj3RfqKbSONFaSDWC1kUkKNW1GJ0jQfmu60iqzyQgJrm8rkVo7aMi9gheS6lwmOYbqjWloHPVNTStjal20fVWKS2txymnaD2otZCuP82RNAdrjaM6RZ9P9V/HLt1z+gIV+p26ZqG1Oa1P6Eto9L7RtadjPRr+ixljjDHGGGOMMcaYQvjFjDHGGGOMMcYYY0wh/GLGGGOMMcYYY4wxphB+MWOMMcYYY4wxxhhTiDblvyQrUqlNz549Ux+VMkWwJK937961NgnTSLRG8j6VB/Xv3z/1WbFiRYqRoOryyy+vtUkgRjLCwYMHp5hKt1avXp36NCt3UqkdSQVJyETXXu8RyX8XLFiQYiWh66TXhPKR7jHJoIYMGVJrk4yUrvmIESNSbOHChbU25QbJ5MaMGZNiKv9TyWwEyxNJgK3HT7I6kgt37do1xTRHSYJMwiuSt44bN67WJvEy1YJS0D3XekmiPhqfJFNVyVmzomhCayPdJ8oVErmpTI9EayTfpH5ac0iYRnWWzluFmVS7qA5QfurnkwiS7m0pZs2alWK33XZbrT19+vTUh4TeVPOmTZt2zGP49Kc/nWIkXlTpusrIIzgPqF5rnZo0aVLqQzJLWmfo59P8O3fu3BSjsav1efbs2akP1VhCxZ60hqF7VopVq1almMpPR44cmfpQTSIh+S233FJr07mTnPR3fud3Ukzzk/KCJK2UU5rXJNSlLyEg8abWa5JCN4vWYvqiCfrSCkLvB305RHsS9Eew0FmPke4nfQEC1SqdN+kLF2i9Q/O5ill1PRqR5bkRXKtUuEprRpr7aO5evHjxMY+BJKlUs/Va0M/R9aJrr2OTvoiAYqWg8a9re5r7CFoDaQ2iHKZnQbre+qxFQmYaN3Q/9XdS7lOuUF3S2k7Pe3TeNEb0fpB4mX6OpOe6VqbrTOd4NPwXM8YYY4wxxhhjjDGF8IsZY4wxxhhjjDHGmEL4xYwxxhhjjDHGGGNMIdp0zNA+et3HRvsN1R0TEXHo0KEUW79+fa09bNiw1IdcMfpzEdkDQL+P9qPR3jnda0z7yPv06ZNi1E/3C7/yyiupz/bt21OM9rapn2L+/Pmpj7oWIrKvIiI7T8gL9JGPfCTFSkL7ttWTsH///tRH99tG8P5I3S9MXhhC73FE3jOvrqEI9smQz0L3wtMeehontN9bj4OOnfbzUm7r3mPaz0t7LXVfbUTE0qVLa231EkSwB6kUNGYVqi10HWnM6j5W8lw1s884InuFyG1E92nAgAEppk4iOp/u3bun2BVXXJFiy5Ytq7XJf7Bv374Uo37qjyGfDOVdly5dUkzzuD25jQjyu+i4JjcJ+aU+/vGPp5h6POj6k/eNcrEZlwvVJHJOXXnllbU25R2NLdqDri4Kyv1u3bqlGO2pv/fee2tt2lNPx0pjac2aNbU2OUnI2VIKqtvjx4+vtR977LGmPovcRg8//HCtTTX2wgsvTLFHHnkkxa677rpam2osOR9Gjx6dYuecc06tTfM43V91CEXknKJ1yFe/+tUUozXAli1bam26P2vXrk0x9Z1E5PUE3cf2tmakWqU1n86VahCtGfWe0mdRHaQapOt7ql20Bl6yZEmK6big5xWaW6lW6dqAcmjnzp0pRmNHrz3dH7r25MPR60XzNHmjSkHXQ/OHnEinnXZaipG/Tc+VPqtZx6HmMR0D1ThyFV599dW1NtVnWgeQk2X48OG1NuUdnTc9m+izOM2t9AxFriC9FlQHyFd2NPwXM8YYY4wxxhhjjDGF8IsZY4wxxhhjjDHGmEL4xYwxxhhjjDHGGGNMIfxixhhjjDHGGGOMMaYQbdo0SeQ1aNCgWvudd95JfZ555pkUI7HamWeeWWuTVOfAgQMpNnDgwBRTORHJkUiWSfJiFW+StIfER3QtVMi0cePG1IeESSTF0nMkcSUJm0nsqUJgEpu9G1nR8WD27NkppjI0kiqSLJekjQcPHqy1Sfw0bty4FCOZ6umnn15rkwCOBFHXXnttiqmciwRwJG+mHN20aVOtvWHDhtSHJFgkkFbBnEpmI1iSS8IuFftSHpN0rhRdu3ZNMT2vHTt2pD4k19NcicgySZLf0c+RoFQlr1p3I1iQTfLByy+/vNbW+SCC6xnlgUr+KBfp54YMGZJiOsZpLiEBN13X1157RbxyGAAAIABJREFUrdYm8R3NS6X40pe+lGLTp0+vtVXUHRExderUFFu3bl2K6bgjOTjRjNiRcpFqJY0bneOXL1+e+pDwn0SAmutUT2m+veeee1JMBYtUr++7774Uo/XJ0KFDa226P3Q+pdC6FZGPmdYjJGyktZLOhTTnkCia8kBloVQfaA1EokoVWlLNoPXEeeedl2JaBx9//PHUhySeJD/VdTedD0nRSUqswlo6n/Yk6I9gIbKObXo2obUZXSdd81MO0VxE107Xn506dUp9aL6i+VDzUb+MIoLvFY3DZo6BxjSdt9ZZylm6ZzTnaL2ktT8dQylo7Ok9oPpJ8yj10/Ugza1vvvlmitGzn34W5TWt8yivdc6n+Z2enUn+q/lJcx/VelobqOCf1p90XIQeK40t+mKao35e0z2NMcYYY4wxxhhjzPuKX8wYY4wxxhhjjDHGFMIvZowxxhhjjDHGGGMK4RczxhhjjDHGGGOMMYVo09RFgtQZM2bU2qNGjUp9XnnllRQjwVbv3r1rbRK5kXCPhFHDhw+vtUlQRcI0Ep2qZHbKlCmpDwngSJap8ikSE5FojMTLKiIi4ZbK8SJYnKVyJ5K9qTS0NCo0i8h5pXLbCJajkVT0sssua/OzI1iUddVVV6WYSrZIHEfiKhpzKiOlY6DcI0HtvffeW2vfcMMNqc9TTz2VYjQ2Dx06VGuvX78+9SG5NgkPdTzR+CJpcClU6h2RZXQkK6b87Nu3b4qpTIzGJ9VGqsdaE6hGkCydhMCaBySYo3tHAm49RzquZoW9KtajcaTyyqOheU1CO/r8UujcF5HFkX369El9SBRNwvAHH3yw1p42bVrqQzWJBHirVq2qtammk1SQcmr06NG1NgkRaZyShFFl4yT9o/wZM2ZMinXo0KHWvv/++1MfmluuvvrqFNNcbEbwWhKq9yp7pPWhSsUj+J6rxJTqA+UwXTeVrdKagNZrVPP0CwDoCypoDiXZqtZ6Gm/Lli1LsX/9139NMf2yAppDVeIfwQJlXa9MmDAh9Zk3b16KlUTHT0TOGZJukySV5LLNfGEE1RsS92uMvjxAZeARLLjVNT+tBUlGum/fvhTT/Fi0aFHqQ9BzjV5rqv/0vELPadqP5hsa96Wg3NDxT+dJuUJ1VnORnjlo7U1jpJmaTZ9F86bWEpqv6PmF1rxae+k60M/RnEC5rtA7A5UZR+T1D61RaT19NPwXM8YYY4wxxhhjjDGF8IsZY4wxxhhjjDHGmEL4xYwxxhhjjDHGGGNMIfxixhhjjDHGGGOMMaYQbcp/ScijMjSSWQ4bNizFSJjTjGSRJDokwFLBEIlVVfAXwaIpFWFu3bo19SG5G8V2795da5OYiARGJLJSWSZdL5IdkthTxb6TJk1KfQYMGJBiJSHpnt73Xbt2pT4kuSRhmsr/SK5M92XBggUppmI8kq+RUIvu6YsvvlhrNxqN1IfymOTNkydPrrUffvjh1KdXr14pRuJCzWWSetHPrVixIsX0upKsi2RjpdCxGJHHEI1FEvaSVFSFgXTulNcku9PPV+l6BOfdaaedlmKaZ/RzlIsk0XzmmWdqbRoPlAdU21UYS1JNkjxSTdFrTfeH5rNSkFTuiSeeqLWpbt13330p9vu///sppnmmYuEIFl2rtDwi4sorr6y1n3766dSHJJszZ85MMR1vJCAmueSTTz6ZYppTNE6XLl2aYs8//3yK6f0gOTyJZr/4xS+m2G233VZr33jjjamPimdLQvdA1zckiKTrQdJUnU/+4z/+I/WhukiSYF27Tpw4MfWhuYryUyX6tG6leZvQn1WpZwQLskeMGJFiuj4iaTkdK33hxYEDB2ptEuROnz49xUpCaziVSlNu0HUiWajWQlrf03xIaC2h56gtW7akGK3vdc1I50hzN82RKgmmLyYhQW0zwn/KIaoPNOfrvExzPsl0S9G5c+cU03yhc6d1GInRVX5PP0fzVTOSfhKE03qNPkvrHt1LlQ1HsIBc85iuA+U6reH0WKlW0Hig9wh67WkepFw/Gv6LGWOMMcYYY4wxxphC+MWMMcYYY4wxxhhjTCH8YsYYY4wxxhhjjDGmEG06Zsh9onv2yEdBngPag657NmmPF+3PpD2xuiecHADkhdi5c2eK6T482ru7aNGiFKO9bbqHnpwGdI60V1V/9pRTTkl9aN8o7VF+4YUXam3ae6h+nNLQ9f3Qhz5Ua5NTQM81gq+T7hcmlwLtpSW3kO7xpftO/hU6R91rT/lP+xdp3766bq644oqmPovyQ/ew0r73t99+O8VoH6p6T2h/KV3D9oSOF6qfVAfJ5aXXrW/fvqlPhw4dUozcGLqntxkPRATvJdfPohpEc8LGjRtTTPOzGd9LBNds7Uf7n2m/OfkiVq5cWWuTH4d8A6Wg66bzH50Djdcvf/nLKXbZZZfV2uT+oPmQavFjjz1Wa5OHhtYB6uyKyPvLaR7Vvd8R7C0aPHhwrb148eLUh9YUVK/VFXPppZemPhQj95PWgccffzz1ufnmm1OsFDQ/auyWW25Jff7t3/4txcjzoe4D8ivR2KS1n86FzfiCIviea26Qw47qLvnp1DNBHh0aI7TO0dpA60paH86ZMyfF1N0zaNCg1IdqSkloftL7QF4PWgP16dMnxTTXdN0XwfMhrYF0fqJrSfMVrWU1R6k2Uh0nOnbsWGvT8x3VcTpHXbOQI4R8ILQe1DHQjAexJOpUjci+EvLC0HqfnC/q9GmmHkSwG1J9PTRGKH/0eSwij0F6JqD8pPWtXi/KMcpP+p063ijHyIdDrjA9LppvaE44Gv6LGWOMMcYYY4wxxphC+MWMMcYYY4wxxhhjTCH8YsYYY4wxxhhjjDGmEH4xY4wxxhhjjDHGGFOINuW/JCtTqRRJI0kKRP1U2HjBBRccs09Ec1IgkmStWLEixfbs2ZNiKkMiOZoKsSIiduzYkWIqpCIxHZ3PmjVrUkwleiShI3kUSTw7d+5ca5NwiwRGJaFzU8EkSRu3bt2aYmPGjEmxl156qdYmGZQK8CL4/pF0TiG5oR5DRBZc0VhSKWIEixj1+txwww2pD53P66+/nmKaM5QvNA5JSrZ///5am2Rd7Un+S/JFrSUql4zgvCBRrUrHqKZSfSa0rpIUmiRnJMvV4yBB4ezZs5s6Ls1PyjGqXXT8KnmlcUrjmX6nXledWyJYcleKp556KsX0ftI4JBnhVVddlWLbtm2rtUlcS4JCyh/9nToPRfA9IWGvSi9p/UCivlGjRqWYzvEHDhxIfUj+O3LkyBT7i7/4i1r7H//xH1Mfmqf+9E//NMWefPLJWvuuu+5KfbZs2ZJipaC1ko5hyjuS7FJMayUJ+mkOveSSS1JM11hTpkxJfeiek8Bd1yEkpSQRaTPrSKplVBcpptJOmnunTp2aYiSZ1jE4duzY1IfW2CUhia/WRhLQUl165plnUkxrCYl4SQhM6xvNUcoNym2SrKuM99xzz23qGEigq/WF5kOSwzbzxQ/0ZQW0vm3mCxKo1tNxlYKORa83rb3peuicTD9LQmZ6ZqRnUl3n0b2kGNUgnROGDRuW+lAeNPOFNHRtKD/pWUu/RILW2FTHae2n95auAz2PHY329eRtjDHGGGOMMcYY80uEX8wYY4wxxhhjjDHGFMIvZowxxhhjjDHGGGMK4RczxhhjjDHGGGOMMYVoU/47adKkFJs/f36t3bdv39SnWfmOSllJjqQi3ggWuennr1u3LvVRQWQEC4xUArR06dLUZ8CAASnWq1evFFNhGgmZSDpEYrUlS5bU2iTspOuswqSILIMk+S/d25LQMaogiu4BiaVITKn3hgROJKOmvNJjpWMncSGJEVVwRflCQioS0V1++eW1NuU/iYRHjx6dYioIJGFm7969U2z48OEptnr16lqbaggJQEtBkkutVSQmo3pGeTZo0KBam+R3lFMkSFYpHuUw3V+S5ep9ot83fvz4FPvrv/7rFNNaRRJkykUab1VV1do0tkgESUI2jZHUmq59KUheqeOa8pVkp3Pnzk0xvZZ0n/r06ZNidI207pJsknKKpIg6hzUjG45gCeuyZctq7R/84AepD0mJKT81RtJ6EiCSUFxln/PmzUt9br755hQrBcnN9VrSvfzRj36UYiqEj8h5TfMErYtobamia6rXJMvUWhMR0aNHj1qbxiTlFAkuVahOIloSoJOUeP369bU2rT8feeSRFCPx7IgRI2rtxx57LPW55pprUqwkJIRtBrp/JBfXOYUk6FQHaaxTTKFxQmJf/eIB6kPPSFTbV65cWWvTWKIxTfOmjqdmpL4RXFd03UQ/157kv1RLVC5Oa1z6kgfKA42RFJrqDdUEFa/T+oHqGa3t9YtWqE6RNJzWZjqW6BgoF6kO6HMUrUUoP5v54geSxpPE/Wj4L2aMMcYYY4wxxhhjCuEXM8YYY4wxxhhjjDGF8IsZY4wxxhhjjDHGmEL4xYwxxhhjjDHGGGNMIdqU/6o4jCARL0luSKKjsh2SmqqEKCJi165dKabCwIEDB6Y+GzduTDGSk65Zs6bWJvkaCeb69++fYgsWLKi1SdpE8s+1a9em2Mknt3m7IiLLAiNYeqnyuCFDhqQ+zcjIjicqIYvIItBRo0alPjt27EgxEuOqrIzkpyQVffbZZ1NM5dAkJqM8JgGhyotVmh2R5YMRfL1UYElCSxJbL1q0KMVUENizZ8/Uh8SXdN4KiadJrFcKEozpPSZJJMn1aFyr1JLGMF1bGv8qZqX6TMdAMRWfkaj1s5/9bIqRrPLpp5+utS+99NLUh+45SQX1WixevDj1oXpGYkYSPyoklS0FjZWrr7661p41a1bqQ+dJeabz2jPPPJP6kNSa6oF+Pq0LSOJL4k2t/SSCpTUFnaPWN5p/d+7cmWKDBw9OsU2bNtXat912W+pD6xOaR3R8TZ06NfXRL2SIYNn28WDy5MkpNmfOnFqbagbN2/pzEfl+kriS5OaEyqOblVnSFwxoTSJxJdUyEpnrmNB8imCxJ32+rlOHDh2a+pDYk9a8Om/TlyrQGCyJSnAj8vnSPEqC8Gak1fRcQNJXyjWV8VIdpHU65YLKfukLQCivaF7TfN+zZ0/qQ/ed1g+ao7QOpzGtY5U+iyS5dM9KQQJjzT0Vf0fw8yGhOUXXlp4/aT2l8x/No1TH6Xld84Dyh2rJhg0bUkzzgJ5fml3XKLRepzUjXUMd4/RzVGePhv9ixhhjjDHGGGOMMaYQfjFjjDHGGGOMMcYYUwi/mDHGGGOMMcYYY4wpRJvSkmb8LnPnzk19aA8WeSvUyUB7C2mf5VlnnZViulePPov2ntFesHfeeafWpv3P+/fvT7EZM2akmO7VXbZsWerTr1+/FCPUT0F7/GifHO2D137PPfdcU8dQEjrfESNG1Nrkk6F93OQ5aWafIDlC6Nqpf4X67Nu375g/F5G9M+pAiuBzJB+Ojk0aJ7S3n1xMuqeXxhd5Gag+6GeRk4T2GZeC9myrZ4O8QlpbIni/ueY67QOmzydH0auvvlpr075cdcdERLz44osppnvo77nnntRn9erVKUa/U/OA9gHTPnX6LN1nr/6yCN4nTT4KzT0aW+QTK4X6BCKyH2vs2LGpD90n8vxonjVbT2nuVu8VuVYOHDiQYuRp0H50XFR3yTWn+/EHDRqU+pCL4vrrr08xdUWQh4/mEVpvqR+K7lkzzq7jxUUXXZRiOgeMGTMm9XnhhRdSjLxCOoZp7aT1LoJ9cVoj6J6T84EcXTpv09qB1ox0XFqTKPfJK0VrS10rkIuO1lU0R+uakcbbkiVLUqwk5LPQe0p1ijxC9FlaG6nekMeMnFx632l9SLlA6zxdB9O6gNZ55MGgn1Vo7qbnNL3WtK6ha0O+lEajUWvTOoqcP6Ugx4yumemakTuH1jfqFyTnFOUPeYX0vtCcTOezZcuWY/ajdTyt9yn/NRep1tMzMLns1N1D45RcYXRcujagXKQ19tHwX8wYY4wxxhhjjDHGFMIvZowxxhhjjDHGGGMK4RczxhhjjDHGGGOMMYXwixljjDHGGGOMMcaYQrQp/yW5pEp8SQBGQh6Su6ko7vDhw6kPSaVIGKVCHjouEj2SOE8FiOvXr0996NqofCki4vnnn6+1SUxEUkoVW0VkSRudI0mUSGCkMie6piQtLMkVV1yRYlu3bq21SWZL16lLly4ppqJRup8kyiJh7xNPPFFrk0yPxLgkO7322mtr7ZkzZ6Y+lNt0XAsXLqy1O3TokPqQ5JLkWSQ4VEjaRvmu0jOqBSTUKgVdbxV901gnuR5JwbTuqagsgmsqCZhVOKyi3Ai+l1R7H3300Vp7xYoVqc+2bdua+nyVFpIQla4N1Ua99iQIprHbjDCQJHpUZ0tBY0xFlTQn0/W+8cYbU0zP/8knn0x9SJJK9U3FjlRjSTr9ta99LcWGDx9ea/fs2TP1oVpGwlXNdTqu8ePHp9gDDzyQYirx/c53vpP6kGT58ccfTzEVJ9KXKKgAvyQPPfRQik2YMKHWJpkojXOat3Vc0zqMxjkJe7UukmyY7hPlmYoj6RhILknrLpVTk4iW6hvJox955JFa+6abbkp9aJ6iMaLi7kmTJqU+tNYsSTNCeVonvfHGGylG4n7tp7Luo30WCV21ZtMag/Lqu9/9boppXtE4aXadp3MryXnXrl2bYrSW1fOmuZxym9aMej/oelEdLwXNayrup7FIkl1aT+l9oXUB1SCSRyt0n+izaH2rtZeeuakO0pygOUu1UZ+5Izh/dP1Dud9sHdA6Q9eGJONHw38xY4wxxhhjjDHGGFMIv5gxxhhjjDHGGGOMKYRfzBhjjDHGGGOMMcYUwi9mjDHGGGOMMcYYYwrRpvyXJG0q+SPpH4mJhgwZkmLr1q2rtUlWpH0iWAyqwsbu3bunPr17904xleBGRCxevPiYfUjCR8eqx0USJRJnkTxIrw9JskjyqJJl+iwSLZF0qiQqR4vI0ijKMxKUUn6oWEqlZxE8JpYtW5ZiQ4cOrbU1DyJYwkqSKpX99u/fP/Uh0SblAknnFDrWTZs2pZiKyihfSJRF11WPiyRoKkorCYm8dDzS+KRrRJJLFa6S1JqE0iTs1jzYsGFD6kO5SPdO7wv9vt27d6cYiTW1xlFN3bJlS4qR7FSvxXPPPZf60JgnEd0ZZ5xRa5MUjsZIKUg4qeN12LBhqQ/JHylnVRhO0JiePXt2ium9+/rXv5769OjRo6mYzqVf+tKXUh8SxlMtUxFgM7LqCJbKqoCb5nISd9OxqmhZZfcRXCtLQXVq//79tTbVAqqnJMtUwSf9HInSaezrPaY6THJwGg/6ZQJ0HUi0T2JxPa7NmzenPlqjIli6PmrUqFqbahn9HEmP9VhJrNtMrTiekFRU7zNJ0GmeplzTL+Sg+0mf1bdv3xTTeZnWmjTvkIheazvVKcqFU089NcX0ejV7XDQO9XdSDukXQUTwfaTnRYVqbylIMq2SbRIr0z2hdbw+w9FcTjWO6rFKk+m46JmRZMu6xqLaRbVRJegROa/p2ZyEvXSsui6m60DXmdbFOsZpbfVuvrzEfzFjjDHGGGOMMcYYUwi/mDHGGGOMMcYYY4wphF/MGGOMMcYYY4wxxhTCL2aMMcYYY4wxxhhjCtGm/Pfiiy9OMZX0qLwogqVSc+bMSbHJkyfX2qtXr059SAD39ttvp1jPnj1rbRL8HTx4MMVIfKYyRTofEmiSFEhltI8++ugxf19ExKpVq1JMBVjjxo1LfUj4RDIklXWRuJikYiUh+drTTz9da5PkTEW8ESww0+tE95OuJQlQ9+3bV2uTRIryiuTQKpSbP39+6kPCNBJ9qcSLfh+JhFVoGZHFdyS5I2EvjUOViJOsi0TjpSDJn15vyhUSuR06dCjFtMaRwJvykwTZKn6lsX7yyXkqoDGiwjTKi5EjR6YY3U8dz/T7Bg0alGIkmNPrShJtkjyShFH70T2j8VaKZoSTVAtonJPI/NZbb621SaxMOdWMzP/Xfu3XUh86H8ofzf/LLrss9SHxO80jKvYlaSSNZzpHlbdS/tC4ofqmslsSatKXGpRi9OjRKaZrJZIok2yZhJMq8aV1GIkXKQ9UWL1jx47Uh6TTlP963lSv//M//zPFSDiptZ9q83v9kgeSbFJeU23Q46LrRZLlktD41PwgiT7NyZQLupah9Q6Nf6pnGqM+JA2nXNBzJGk4jTlCBaskbyUBOQl7tR/VQZKknn766Smmwm06hmYEwccLmlP02Y+uB62XaX2j63Gqn/TFObRu1xiJi2k9RdJzlf/SdWjmuScir2Po99H8Tr9T85/qIK1JqQ5ozlK+0vkcDf/FjDHGGGOMMcYYY0wh/GLGGGOMMcYYY4wxphB+MWOMMcYYY4wxxhhTiDYdM7q/OSLvBaM9fAMGDEgx2hute1Zpz6PuA46IePbZZ1NM97vSXrrnn38+xej4dR8u7bvX/Y0RvLf5gQceqLVpr5vu4YyIGDFiRIqtWbOm1p4xY0bqQ3tcaV+xehpuuOGG1Gf//v0pVhJyCw0ePLjWJmdQr169UozcSOqBofwnVwPtUdYY3WPag6v7MSOyN4ecRG+++WaKkcNG9xp37do19SFPEeWQXi86H933GsH3Ua817dFcvnx5ipWC9v1qblD+kJ+A9myre4D2/NP17t+/f4pt2bKl1qb9yZR3tCdW84D2+BJUZ3WPMs0RdA2p9mptJz8ajUGqA1rHaQ82eW5KsXnz5hTTPeHkqaA91VpPI7Kv7cILL0x9aL4dM2ZMijXjy6I58vbbb08x9bXRnEn37plnnkmxadOm1dr9+vVLfb72ta+lGI2Ru+++u9amekfOE8pFPSdaYyxZsiTFSkHuJV2TkJtk7NixKUZzgF4jymGqi7Qu0vmL1ppr165NseHDh6eY+oHIFUGfT/dO5+RFixalPuRTolzXsdSsF4bmN13T0DxC46Yk5JvQ+ZDWdDTH0DpP525ywAwcODDFqJ/O+eTdIFchPTfpfEv3k/xGdL3Us0E5RH4jWuvoepDGKs35NH/t3r271qbrRW6UUtDx6bxJuUjOHbpu6iSiuYJymNC8pjpLcx99vq6VqE7RsdJziHrl6JrScw/9Tp2X1bsawWOXnovVI0Xjm9b5R8N/MWOMMcYYY4wxxhhTCL+YMcYYY4wxxhhjjCmEX8wYY4wxxhhjjDHGFMIvZowxxhhjjDHGGGMK0ab898UXX0wxFYWRHI3ENyp6jIjo3bt3rU2CHpI+qeQoIot8SGxFx9WpU6cUW7lyZa09bty41IdkqySXVFErCdMOHTqUYiR0VJnihg0bUh8SbpF0TmVdM2fOTH0mTJiQYiUhgZ+KpXr27Jn60L0iGen5559/zJ/bvn17ipEoTmWA+tkRzUvONEbjhMSpKqSKyLlG0jYS+L366qsppuOQhGSUxyT6Urktjbm+ffumWClIuKdiSrrnJHcjUaTK+ijHSLRJkjYV+pFUjfKa5G56X+g60PmotC0iS7mpDpLwmeqACt9ofNNxkchTpYI0jlQgWRIam3r+JGmme0exSy65pNamuZxi+nMR+VrSmKYauHTp0hRTSSrlCsnNr7/++hRTkT6NLYLq1KxZs2ptmkepNpB4efHixbX26NGjU5/Pfe5zxzzO48W+fftSbNCgQbU25SIJmUkerWOfxJi09ps7d26KaS6SNFLXqEdD10/jx49PfWjdqmL/iPwlDyQypxpIgledk2lskbib5hu9XjRnvBvB5fGA5KB6PWlNTteE+um8VlVV6kPCXpKkai7Tz9H9o7Wfrj+pntE6jM5b85ak3BSj36k5RGtZ+jn6Ug/6nQp9qUEp6J5r/uzZsyf1oXtOX6qhzysqbY7g+ZD6ad2gtRmtFahuaF7T76O1GdVLzU96RiOBNdUlXYvT+CYhP63hdQ1G8zvVoqPhv5gxxhhjjDHGGGOMKYRfzBhjjDHGGGOMMcYUwi9mjDHGGGOMMcYYYwrhFzPGGGOMMcYYY4wxhajejZDGGGOMMcYYY4wxxrx/+C9mjDHGGGOMMcYYYwrhFzPGGGOMMcYYY4wxhfCLGWOMMcYYY4wxxphC+MWMMcYYY4wxxhhjTCH8YsYYY4wxxhhjjDGmEH4xY4wxxhhjjDHGGFMIv5gxxhhjjDHGGGOMKYRfzBhjjDHGGGOMMcYUwi9mjDHGGGOMMcYYYwrhFzPGGGOMMcYYY4wx/297Zx7sV3ne9+cYG2xs9kUIJKFdutoFWtCC2Bdh2RjHSxwMJo09Tp1O0jYTp+1Mk7pNk7jT6cTj2Dh1x0kTYweDqQ0GLDZhBBJCAu27hIQkFmGxGbCNAz794163Ot/nc+89LNH7u/j7mdHY73Pf3++e857nXc7hvp9TCD+YeZ1UVVVXVTW69HEY41w0nYJz0XQSzkfTKTgXTafgXDSdhPORGdAPZqqq2l1V1c+qqnrpoH9/Xfq4iKqq7ulJwnceFFtSVdWPq6r6SVVVa6uqurzkMZo3zkDPxYN+dk7Pz/6sxLGZN89Az0U4/jtKHqN5cwz0fOyJ/0FVVbuqqnq5qqrNVVWNLXWM5o0zkHOxqqphctwv9fz8D0sfq3n9DORc7IlNq6pqaVVVL1RVta+qqj8peYzmzfE2yMe5VVU9VFXVi1VVrauqan7JY3wzpBuzAcgH6rq+q/RB9EVVVVcGt/UfRMSmuq5frapqdkTcVVXV2Lqunzy0R2jeIgZyLkZVVe+KiC9FxIpDelDmn4MBnYsxAI7fvC46/nr2lo9VVX06In4nIt4fEZsjYmREPHdoj868hQzIXKzrek9EvO+gOiMiYkdEfPfQHp15CxmQudjDtyLi/0TEuRExPCLur6pqTV3XNx+6ozNvMQMyH6uqOj4ibo6IfxkRN0XEJyLilqqqRtZ1PeDm6gH9FzN9UVXVNVVVPVBV1Zd7nuhuqarqgoN+fmpVVTdXVfVsVVU7qqr6zEEzUbidAAAgAElEQVQ/O6yqqv9QVdXOnqdvD1dVNfSgr7+wqqrtVVU9V1XVV6qqqvo4jmMi4k8j4vP6s7qu19V1/eqvihHxrogYqvXMwGYg5GIPfxgRd0TEljd3xqZTGUC5aH4N6PR8rKrqHT3xf1PX9aa6m511XT/7ljWC6Qg6PReBqyPivrqud7+xMzadygDJxeERcV1d16/Vdb0zIu6PiIlv9txN5zEA8nFuROyv6/qGnnz8ZkT8OCI+/JY0wCHmbftgpofZEfFoRJwY3Rfzpqr7yVpExLcjYl9EnBoRH4mIPz8o0f5tdD9xuywijo6IfxERPz3oexdFxMyImBoRH4uIS/o4hj+PiGsj4in6YVVVP6iq6ufR/VcK90bEqtd1hmag0NG5WFXV6T3f/Z/fwLmZgUVH52IP11Xd2zzvqKpq6us7PTPA6OR8HNLzb1JVVXur7u1MX+h5YGPefnRyLipXR8T/bnVWZiDS6bn4VxFxdVVV76qqalxEzImIjv5rC/Om6OR8rHr+aWxSy3PrLOq6HrD/ImJ3RLwUEc8f9O8zPT+7JiKeiIjqoPoPRcRV0f1XKa9FxFEH/ewvIuLvev7/1oi4vJffWUfE/IPK34mIf9dL3RkRsSa6/+xqeM9n3wn13hURC6P7v8oVb1f/+/XLxYj4fkR8vOf//11E/FnpNvW/X9tcnBcR74mIIyPi30f3JHxs6Xb1v1+/fIzu/xJXR8StEXFsz8+3/er4/W9g/RvIuSj1zu45j/eVblP/+/XMxZ6xcUdEvNrzsy+UblP/+/XMx4g4oed4PxHd99OfiohfRsTflG7XN/Lv7fBffT5U1/WxB/37+kE/e7zuuWo9PBbdT/ROjYhn67p+UX52Ws//HxoRO/v4nQc/rftpHLTv91f0/Be1r0bEH9T/f7sSUtf1P9V1fXtEXFJV1Qf7qms6mgGZi1VVfSC6B9Xr+/g9ZmAxIHMxIqKu6wfquv5ZXdc/rev6L6J7wj27j99rOp+Bmo8/6/nf/1bX9fN197aRv4nu//pnBiYDNRcP5lMR8d26rl/qp57pbAZkLvb8pcQPo/svrN/d8zsvqarqc338XtP5DMh8rOv6mYi4PLr/Omd/RFwa3X+9ta+P39uxvB0ezPTFabJfbVh0P/V7IiKOr6rqKPnZ4z3/f29EjHqTv/vo6H7Cd31VVU9FxMqe+L6qqnq7yXjnW/B7TWfSybl4QUTMqKrqqZ6ffzwi/nVVVd9/k7/XdCadnItEHfnPVM3bh07Ox60R8YvozkHz9qeTczEiIqqqek9EfDS8jentTifn4siIeK2u67+v6/rVuq73RcQ/hh9Yv53p5HyMuq5/VNf1zLquj4/uv+QZF91/1TPgeLs/mDk5In6/Zw/kRyOiKyJuq+t6b0Qsi4i/qKrq3VVVTYnuty5c1/O5/xUR/6WqqjFVN1Oqqjrhdf7uF6L7SeK0nn+/GrDOjIgVVVWNr6pqYVVV7+k5vk9GxIKI+NGbOWHTsXRsLkbEf4yIsQf9/OaI+HpE/PYbPFfT2XRsLlbdr4SdV1XV4T3H8EfRvaf5gTdzwqaj6dh8rOv6pxFxfUR8vqqqo6qqGhIRn4mIH7zx0zUdTMfm4kH1rojuvyJc8gbOzwwcOjkXt0VEVVXVb1VV9Y6qqk6J7v+gt/aNn67pcDo5H6Oqquk9x3Z0RPz3iNhX1/XiN3665Xg7vC77lqqqXjuofGdd11f0/P8VETEmIg5E9583faTnT54iuveifS26n/Y9FxF/Wtf1nT0/+x8RcUR0v6HmxOh+S82vvrMVPX/y9f/+RKuqqnf3/N/9dffrsauI+E8RMSG69+dtj27HxyOv5/eYjmJA5mJ0/xfhFw/6+c8i4uXabx4ZyAzIXOz5ry7XRvd/Yfl5dO8pXnjQ8ZmByYDMx57//68i4n/2HMPz0f3Q+huv5/eYjmIg52JE9zamv5dtBWZgMlBz8RdVVX04Ir4Y3fP1zyLiloj4r6/n95iOY6DmY0T3m5p+9cDmh6/3d3QS1dt1bK+q6pqI+HRd1/NLH4v59ca5aDoF56LpJJyPplNwLppOwbloOgnn46Hl7b6VyRhjjDHGGGOMMaZj8YMZY4wxxhhjjDHGmEK8bbcyGWOMMcYYY4wxxnQ6/osZY4wxxhhjjDHGmEL0+Vama665Jv05zc9//vNG+dRTT02f++lPf5piv/zlL1Ns3759/R7gO96Rnx295z3vSbHnn3++UZ4xY0ar36efi4g4/fTTG+Vnn80vp6FzPProo1Ps1VdfbZTf9a53pTqHHXZYitHvPPHEExvlAwcOpDrUXqecckqKPf30042yXteIiKFDh6bYtddeW6XgIeIzn/lMysdnnmm+rOXmm29On+vq6kqxMWPGpNjhhx/eKB9xxBGpzj/90z+l2Lvf/e5+Y2vX5rcIHnPMMSmm5xORr+ljjz2W6lx44YUp9uKLL6aYXudHH3001Zk4cWKKvfzyyymmOUrtQHlF+a59Z8iQIanO7t27U+yee+4pko9//dd/nXLxrrvuapQ1nyIiJkyYkGKvvPJKit1zzz2N8rx581Kdo446KsUWL85vB/zwhz/cKN95552pzpo1a1Js2rRpKbZ58+ZGefLkyanOVVddlWJf/OIXU0zH0B07dqQ6lIuzZs1KsfXr1zfKo0aNSnVoHLjppptS7KMf/WijTOPsgw8+SLEiuThnzpyUi9r3qc8deeSRKfa+970vxV577bVG+bnnnkt1KNcHDRqUYk8++WSjTHOMXsvejovGG+XYY49NsS1btqTY8OHDG2Ua+/fu3dvq+5944ol+v2vw4MEpRnOLXqPHH3881SE2btxYJBfPPffcfudoOk9a01F+6pjRpk4Er81eeOGFRnnYsGGpDl1zQnNR130R3AepLXSdR3PvSy+9lGLdL/ps8s53Npf49Lnjjz8+xWje1nOkvCZKzdERPDZqm/zsZz9LnzvuuONSjMYgvTa0A4HanHJBx1DNz4iIE07Ibxmm8VjHJVpr7t+/P8U09yLyOdJ1//GPf5xihPZDnQ8ieE4gNEepvagfrl27tkg+XnbZZSk5dK6gvj5u3LgUa7Mep/u+9773vSlG/V+Pa9KkSanOhg0bUozu83/xi180ynRfQusH/VxEvq+neyHKdZpf9H6C1hN6nxzB44CO49ReND5/7Wtfw1z0X8wYY4wxxhhjjDHGFMIPZowxxhhjjDHGGGMK4QczxhhjjDHGGGOMMYXwgxljjDHGGGOMMcaYQvQp/yWRz1NPPdUok1TtJz/5SYqR4FJFWSR1JDkUCZ1U3LN9+/ZUhyBR0PLlyxvl6dOnpzok/SM5qbYhyepIpkUiIm3XkSNHpjo7d+5sdVwqMCJpsEofS0MyqJNPPrlRXrRoUapD8jWS22mbrFq1KtWh60LHpdeGpGokgyIppEq8SJJK0lcVWkZkWSsJOlX8FcECMhVRksiQZGPUB2677bZGWa9rBEvuSqHHG5FleiTXo7YlUa2KKB9++OFUZ+PGjSlGeXbDDTc0yp/61KdSHerrF110UYrpWEXStpUrV6YYyRSvvPLKRpnmDYotWbIkxS644IJGmcZBmoNI/v7d7363Ub788stTHRpTSkHzh87TJPij+Z3GRe13JKan/qqi6Ig8xtL8TtLCNnO+Sj0jWOxJx6rfT9eX5sg2bUECQTou6oPaXiSopfmgFG0EnDQWUA5T39T5hES/9F1UT9ubBKYkaSWRpPYlWhPQix8oZ9ussUkyS8eleUzyWLpmJLjU/Kfxg/ppSU466aQU27VrV6NMay66LiQtVagtKfdoDNLvp/GGjov6k47ZJLCnfkJzpK7r6BrTfRStDfSztF4h4ba+kIWOi/Kf+m8p6Lz0JSQ0/9LcTS8J0XGC2oNeqrF69eoU0/GFhPm0jqcX7OgLL2gNTP2G5k1dL9ALMB544IEUo2cL2r8oryk/ScCvwmp6/kA53Bv+ixljjDHGGGOMMcaYQvjBjDHGGGOMMcYYY0wh/GDGGGOMMcYYY4wxphB9OmZof7/uYyOPAu2fpn2cuj9s27ZtqQ55OGgvtu53pf2ZtCeO9n+eeuqpjTLtU6Q9m7TfTX8n7WOmvce0j01dFLRXj/bBtvEAUXvRHu+SvPzyyym2bNmyRnnixImpDnlOdB83fX/bPYG0L1T3v5IPiHKP9qZrvbFjx6Y65B6gfqJ5RXVo/zrtPX7ssccaZd1nGcH7Y+kcP/ShDzXK1Da0l7oUU6dOTbHvfe97jTL5jmjfL/l7/vEf/7FRpj2+H/vYx/o9zoi8p/4HP/hBqnPaaaelGOV1V1dXo0x7gynXyW1w7733NsrkO2rrjLr11lsbZTofchRRG2p+0rxEjrFS0Lym/hVyY1Eu0hirvgk6d3If0O/UcbGNtyGCxxYdu2g+pDmZckOPg9Y+NJYR2m/ImUN9i+ZpdQnQWoTavhQ0RqsXgM6dzoHWfrpOoTYjtwWNGdqW5EijYyC3ShsfH/U3Ql0HbfsIoX2Q5nZqezpWzUXq39Q2JaHrp9eZ1r40r1E9HV/ItULtRPcB6p0hBwytnQidS2n9Rk6NNu4iusZ0z0drOP0u6r/0/eRU0XmI+gl5SkpBc5iea1vXFn2Xek2ozp49e1KM1l26tqdrQveo5HK55ZZbGmVar9CakcYl9dbRWE85Rfd7Ch0XOfDU0xmR5zRaI7U5hl/hv5gxxhhjjDHGGGOMKYQfzBhjjDHGGGOMMcYUwg9mjDHGGGOMMcYYYwrhBzPGGGOMMcYYY4wxhejTGkcSHRVGqVgygmWWJAlWQU4b+V0EC+b0OEjwR0I/kl2pFI6EiCSTI3mQCidJRkZyWmoLFWzRd5F0iGR7Ki2jdqDzKcnDDz+cYhdffHGjTNeYBE50btqeW7duTXVI+kpCNhW+kTyrrchRz+nEE09MdUiufd9996WYytdITEdSOOq/mkPUJ1asWJFiJCrW41DhaARfj1KQSPYTn/hEo0zStptvvjnFSBh49tlnN8oqPYvgXKc2uuqqqxplEglT3pHsUI+VrtO+fftSbO3atSmmorjVq1enOp///OdT7HOf+1yKqfiV5I1tRdfUL5VOGhtJeqj9iaSCJKCkcUTnP7q+Q4YMSTESQupxUTs+++yzKUbnqPMmjYs0H5JsX6HjonGexkqVBNP8S9A10rzWFxNE8HmXgq6djhnUD0m8S6hQlMZAki3T3KR9n0TRlMM0rus1p3Ok728jc6WxmWJ0XPr9tNakNQC1q64dKPcpVhKSv+r50jxHfZHmaZ1naF0wYsSIfo8zIuc25QuNJXQfoPcPlP903jS+LF++vFGml2JQPtI8oflH93djxoxp9V0qNKa5q81cfqggGbKOQZQ/dH1JJKttSevsnTt3ppi+VCYi57/mQETEpEmTUuzGG29MMc0pup+mdZgKiCNYEqycdNJJKUbjmYqQacymz9Ecp32JrmPbdUCE/2LGGGOMMcYYY4wxphh+MGOMMcYYY4wxxhhTCD+YMcYYY4wxxhhjjCmEH8wYY4wxxhhjjDHGFKJP+S8Jo1SkOnz48FSHxHkkZlIZjoruIlgmNnTo0BRTwVZbkc/EiRNTTI+DBJckqyO5Ewm8FBIbUhuq7IqEsiQ2JOmQysFUXhfBgqmSTJs2LcVUukRiJpLbkVhq7NixjfLChQtTHRVG9fb969evb5RJeEXXeNu2bSmm4jMSbbYRgEawIFAhyR1J2rQPUP6TKG7QoEEpppJgytlzzjknH2whSGr8gQ98oFHetGlTqkP5SULGJUuWNMoLFixIdUhwTvLfpUuXNsqamxERv/mbv5liOt5ERNx///2N8uGHH57q0LhEElbtuySA++QnP5lijz/+eIrpvDRnzpxUh6TxJ598corp3EGC+66urhQrBc2Reg2ob9K8RuOIzimUd9TPKddVlkniWoqRzFnFjiRqJSklicy1DalNaT00YcKEFDtw4ECjTH2ExmYSBupYT1JS+lwpaCzT8ychK+XU3r17U0zHEZqrCBICa7vRWo3GJELnK8ofWgPQmlTHRcphGptp7acxmsepv5GUWNcrtAZuI9Y+lNC8oxJjWvvS9aOXSLzRF5hQ/1eofan/01pWj7XtmpGOVe+tSBpPOTp69Oh+fyfly44dO1KMrqOONTQOUnuVgmTLmgc0RpxwwgkpRnP39OnTG+WVK1emOueff36K0dpA+whJd3fv3p1i1Jf0u2gup/sSWpvpuEd1aOyiF17ocwSap+llL3RfrOdI9zi0PukN/8WMMcYYY4wxxhhjTCH8YMYYY4wxxhhjjDGmEH4wY4wxxhhjjDHGGFMIP5gxxhhjjDHGGGOMKUSf8l8SJ6nElyS7JEsk+a8Ko0466aRUh4Q5JKgiWahCYq4ZM2akmIqzVOYXwcI0kh3qd5Ggio590qRJKdZGdkWyOhIrqXSK2rTTRG4kat65c2ejTJIqkpyRDFCloiR4JVHWuHHjUkzFUiqqjIh45JFHUowkaiotJYkYXavJkyenmOYjCdooH0nIpvVIUkYiLso1lYiTHI/EYqWYPXt2iqk8kkRrc+fOTbFvfetbKTZ//vxGmaS+d911V4qRlJakZgoJBCnXNY9PPfXUfr87ImLKlCkptnnz5kaZ8odEwpQ/+llqGxLmjRkzJsVUREqiTYqVgvqrXhcSSZLMlsYplfXRukDH4Qieb3U8IBEgjdck/Nd1Bp0PyRTp+NsI/0eNGpViJINXcSgdF43NNFbq9ej0XKS21fNSUWIEX3NaY7WRh9J6jcYWXbvSMdC8d8YZZ6SYClFJ6tsW/SzN99QfSGqt8zu1DUHreoX6SKe9MIIkvnpuJJmmPKZ+pmv+tutvqqeCW5q3abycN29eim3YsKFRrqoq1aFzpP60ffv2RplE7yTnpePXfkjzBvVVOn59KQa9TKONZPlQ0eaeg64Jzd20btExiNaotM5r85KQNlL3iCyKjsjnRDlGYwndC+magtqU1oz0UhWVJVP/pvaieUJfHEPHTuvW3vBfzBhjjDHGGGOMMcYUwg9mjDHGGGOMMcYYYwrhBzPGGGOMMcYYY4wxhejTMUN72wYNGtQo617GiOzEiOD907o/Ux0NEbxvdsKECSmme9SGDBmS6tDeMPIoLFiwoFEmFwh9//Lly1NM9/3Rnnfas6x73iPy3jzaj0j7/saPH59i6iUgH0Cn8dBDD6WY7uWjfYJ0jant1HFEOUt7gzdt2pRi6rqhPbi//du/nWK033PLli2NMvUv2pdLe5uvvPLKRpmO/ZhjjkkxzeOI7LGgvaPkRiFv1OrVqxtlysepU6emWCk2btyYYtoe1La0p1qdJhERJ598cqO8e/fuVIfy50tf+lKKqY/gwgsvTHVojKBroHlN+2bJIaF7qSPyHl/qW+QsIC+SjqE0ftI+5u9///sppnlM1/rSSy9NsVKQg0LPn8YHguppu5HnQNcFETx3qzOFxjvyc1AuqluBxmvaI055pnv2yWlAvgr6fq2nfTki4tFHH00xmrt0nqI1Ep1PKWh9o/MvrVFoTqDc0Pag7yKnD81f5KRQyCtEuaj+M7pOa9asSTFaY+tagdqBPkcx9YOQK6KtD0fX6zTOk1uhJDTm63mQo4t8kZQLOv/RuEHuTPqd2k+oL5F7ktZreqx0XLfcckuKnXnmmSmmcwn9PvLOrFq1KsXaeAnpPo2uh0LjM/WJUtD9obYbOd7IFbNkyZIU0/UU5RjlFNXT/KH7F/J5kvNF+8isWbNSHbpXoZi2BY1dlOsf/OAHU0zzmnxitK4hp+jTTz/dKNOaTP2efeG/mDHGGGOMMcYYY4wphB/MGGOMMcYYY4wxxhTCD2aMMcYYY4wxxhhjCuEHM8YYY4wxxhhjjDGF6NPURZJRlVeqcCiCJToktlP5GgnTSFZGMsZzzjmnUf7lL3+Z6kybNi3FSD6lsj6VAUewdI4EnW2kcHv27EkxkpapbI1kVyRyaiNWIqEXCYxKQpJDlVLdc889qc6IESNSbPDgwSmm4joVQkawzJZkViqqpTwm+aCKWiMiFi1a1ChTvpDMeOXKlSmmeUvnSEKtc889N8XWr1/fKJPYduzYsSlG5639lQRwJIgsBYkAVVCn4sWIiN/93d9Nsa985SspprLKiy66KNX5h3/4hxSbOXNmip133nmNMl1z6v/U31RkSGJtmhO6urpSTCWyJAgmKbGKoiOykPO5555LdWjM1r5F37V58+ZUh4TwpaBxmqR1bSAprV5z+m6SfpL0UuuREG/u3LkpRv1Nc4NEvDNmzEgxyg09Lpoz6UUHJ554YorpHLxr165Uh8ZFEl3r+oTWUSRhLQX1MV0D0Rpl3759KUZjkn6W5J76+yJ4nafjGwlGSYZKY5IKIWkOpXGRBPHKgQMHUozk5rRe11ynz6m0PiLitddeSzHtIzT20/Uvia5RIvK4ROsRGs+o76mYmdqN1vy0JlURLL1MgcYbehmK1qMxr+1LR3Q8Jrkq3ftMmTIlxXS8pzmfxgca4/QlADQ+07q7FLoOi8hreco7Ev2SEFzFvpSv1NdJZqvjMY3FNDbSPL13795GmeZDyk9aP+h4T7lPawqaW3WMpvGT7rFpbaCCY+rf9JKP3uisO29jjDHGGGOMMcaYXyP8YMYYY4wxxhhjjDGmEH4wY4wxxhhjjDHGGFMIP5gxxhhjjDHGGGOMKUSf8l+S6amciMRkJK0iKdYvfvGLPssRLPycOHFiiqksl2SlJJCimArMXnrppVSHxJgkIrrjjjsaZZIRthUNqhRLJZURLD0mUZQKHLdt29ZvndKMHDkyxVSSOnny5FSHhGl0vipkJPETteWQIUNSTPOK8pH6DvUTlXuSpJDkViT60uMn2RtJw6hPq3iZJHe33HJLig0bNizFtJ+TUJkkrKWgc9BrrkLyCO6fTz/9dIpde+21jTJJDOfNm5di1Ec0RuMnCf0o13VsJGknzRskilRJJ9WhXCc5rArhFy9enOrQ2EBt+I1vfKNRJvGdihpLQuOUCvdoLCfROM1Fmgc0PpBclYR+KsBbuHBhqkPjCAlddS1C4kQVIkaw7FPnUpKp09hM4+ftt9/eKNPYSS8wmDRpUorp2EBzGV3/UlAfpnWdQudF6y7tiySJp+tLkmDtE5dffnm/vy+CXxyg15gElLSWbXPetL4gyS6JVPU4dM6O4PmHXj6ha17Ka+o3JSEBrY4JNPdR+1JMr58K7SP4XkFfMBKRxzhaP9Ax0H2AQnMy5QsJULV9DjvssFSH5kMSyWs/bLvGpnFWxdn0OZqDSkEvLdCxhPKHrgmtI9uIhOl+l+5DLrjggkaZ1ox07WidoXmm92wRPG9QPc0zkqzTnE8vSND8oTGPxnES++paio6BxMi94b+YMcYYY4wxxhhjjCmEH8wYY4wxxhhjjDHGFMIPZowxxhhjjDHGGGMK4QczxhhjjDHGGGOMMYXoU/57yimnpJiKn0iqRkIeEqapiIxkYiR3mzp1ar/1SARFEiUSH6mYr63YkCRqet4kbVIJUW+/U7+f5HgqCO7td+pnSRTbRip2KCERqIoFSV5JwrtnnnkmxVQ6+fDDD6c673//+1OM8l0lVXRdqM3pHFUETflC30XHpVLQNvLrCJbH6bGStPOyyy5LMRJqqTSM2oskfaVYu3Ztium4RLI3kgZ/6EMfSjG9xvT7zjjjjBQjQakKCknaRuMNCcx0vKQxj0RrlJ+aZ9OnT091qA3XrVuXYieddFKjfOWVV6Y6xG233ZZi559/fr+f+/a3v51iX/jCF1r9zrcakvypaI5k8jS+v/e9700xlW6TxE7HlQi+njofUj8nKTH1ff2dNB/SOoDklZqLJDskWSZJ11W2TXMSzcnUFno96Fp3kuCS5gCVn9IcR9JIGkdUPN32+tL6UyWO1LYk56V1qsrZSfjaViirx0q/T0WfESxZ1u+i9TQdK0mPNT+pvUhwXBJqJ33JA4llSWJM/VjXWCTw3r9/f4pRvo8ePbpRpr5EYmuSsescuX379lSHrjFJyfVFDCRJpZcTkNBV23D37t2pDp0PSZx1PKbxgiTLpaA5ZevWrY0y3au0Xffq/S2ts7u6ulJs3LhxKabrVLrmBK0zbrrppkaZxqn77rsvxWhdrNeY+gPF6GUv+jIIWj/QvLFr164U0zU1PRehPtgb/osZY4wxxhhjjDHGmEL4wYwxxhhjjDHGGGNMIfxgxhhjjDHGGGOMMaYQfTpmaK+u7mc+/vjjUx3al7Vz584U0/1i9PtmzJiRYrQPXveN0t5d2ttMe890nyztWaN9f7S/ltpH0WOP4P2suieU2uvRRx9NMdqrOmTIkEb5hRdeSHXIG1AS8qHo3kdyBtG+Tdq/qHsM1RMTEbFq1aoUu+KKK/LBCrRPnJwFd911V4rpHug1a9akOuQNmTlzZopdc801jTLtl6Q9oLQPXfcH0358cgD8+Mc/TjF1o9Dv66T968OHD0+xxYsXN8q0p5j20p577rkppvuzqQ9Tnx0zZkyK6X55coeRK4PcFXrNaYwgd4nupY6IuOSSSxpl2iOuvo4Izk9tL9o/T46xHTt2pNgPfvCDRnnatGmpDvl9SkF9TP1AtEec9lTTNVenDLmHyJlC11z3Xs+ZMyfVobwmx5UeK40P5OMiT5jmLM3v5Elavnx5ium4Tv2B5iQawzVGYyytt0rRxodAayLySrTx5VHeEeTe0nyha0Lfv2LFihRT1wit3yhXyGelfZXWDuR5Im+ejtc0VtDcQu2l6y9yiNCxloTmD3VvUO5RXyefmrYJzYfUP+keRtfz5PChNl+5cmWK6bxG61Ya62ktou1D50PtTOtbXftRn6PzJg/Qaaed1udxRvD6thTUP3U8p3UvnRddA53PyctD+UntvWDBgkaZ5ibKRcoz9RZt2bIl1aE1Ha1PdFyi+Ybu16k/6zMJ8lHRPSd5emHboxMAACAASURBVLRdyTFD9wy94b+YMcYYY4wxxhhjjCmEH8wYY4wxxhhjjDHGFMIPZowxxhhjjDHGGGMK4QczxhhjjDHGGGOMMYXoU/5LcigVBZHkhoRpJL5RYRrJ+0ic10aAR8ewZMmSFCN5kEqBSEZIMiESemn70DmS5I5i+lkSrZGsiCRNKtok8ebQoUNTrCQksFRpKQm2SDyt4rCILOxTQXJEFqn2dlyaCyTCXLt2bYpt3rw5xR555JF+Pzds2LAUU9FvRO5zJG278cYb+/0c/U7qJySVpRxVIS0J7dqIJQ8VJPbV3Fu9enWqM3369BTbvn17ik2aNKlRJmkjCeDOOeecFNNcfPHFF1Md6jc0Xm7YsKFRJqEu5TBJ3HWMO+GEE1IdEgiedNJJKaZ9guYuEv0S+v0ke1u/fn2r7yqFti3JPCkPqG21LUneTblIc77OhyrijIjYv39/ipF4U4+D5nzKKZo39RpT/pD0mOZNHReXLVuW6px88skpRuOirn+obWhsKAXNE3oNqG3pRQbUtrqWIWkk0ea7aP6ilynQOKLzHK3zaP6ivnThhRc2yjQ2k1yYvl/XyiTepPU0tYWumUjOSeLNktD4ouMEjV2Ux7TO075Ha00al0iyq32dxhsaS0i4qi/BePDBB1Mdkj7TfYeug2kNTGMXnfegQYMaZZK6k+y2zb0o0elidD0HGg9ojXXHHXek2OTJk/v9ffPmzUuxNuupESNGpDqUiyTb17Gq7Uty6JpPmDChUaZ5g/oufb8eK42zs2fPTjF6iZCOAzQn631cX/gvZowxxhhjjDHGGGMK4QczxhhjjDHGGGOMMYXwgxljjDHGGGOMMcaYQvjBjDHGGGOMMcYYY0wh+rQnjRkzJsVUCkTSJ5JkqTQyIot8jj322HyAIHii71eRIQmkSBRH36UyJJJdkXSIZFcqQ2srOCapsh4/ielIakttQeI2pZPEWRERt956a4qdf/75jbJKZCMi9u7dm2Jjx45NMZWtkVRt4cKFKUbCO81bkqqpCC0i4qtf/Wq/30VSzYsuuijFSHilfZqkmtTvqf+qqIykWJTH1He07UlMqkLcTkP7P0m3ly5dmmJXXnlliqlE8Oabb051/vIv/zLFKGdnzZrV53FGRKxZsybFSMCsx0U5NnPmzBQjKfHpp5/eKNP4TLlCItvbb7+9USbZ52WXXZZiJHzbtWtXo7xixYpU5/DDD0+xTmLUqFGNMgnDaUwi6aeOEZTXJBAlqfWHP/zhfo+B8pPmKz0uEideeumlKUbjrl5PkvdRftJ3qTSbxOwkdDzmmGNSTOduagcad0tBwkk9B1pP0TxB56p5tmfPnlSH5M70YoY24yLlOgnJdRzZt29fqkPj4pQpU1JMc4PGQPp+Got3797dKJMMm8ZTHZsjcl+lMZak1iWhXNB1BMmcKUcpH3U+pHGD+jqNJXVd91uH+gmNoSo2pet+xhlnpNjo0aNTTOW/epwRPI/Seeu67tVXX011aDyjMVT7NAmx28rBDwUks1X5Mb0kgebRs88+O8W0vem+h3Kd2mjBggWNMh07jfV0DTR/6BjonoPEu3rvQ2MQHSuN2dpX58+fn+rQy0voHlPnDuoj9MKg3vBfzBhjjDHGGGOMMcYUwg9mjDHGGGOMMcYYYwrhBzPGGGOMMcYYY4wxhfCDGWOMMcYYY4wxxphC9Cn/JQHniBEjGuUnn3wy1SFZGYmCVFpF0p7x48e3Oi4V+ZDUd+TIkSlGskOVDrUVepG8WNvnqKOOSnW2bNmSYiSrU+EbfRedDwmUtQ1JrNpJUsGIiLPOOivFVFpK151EWST60zYhsSMJJilvVcJMv2/ZsmUpNm7cuBTTXKPjorZZtGhRiqkwevPmzanOE088kWIPPfRQiqnoj8R/1DYkTlVZFuUsicVKQW3U1dXVKJPYjkR9KoCLyOPeBz/4wVbfRQJRFf+RMFMlhr19/1VXXdUoL168ONWZPn16itH4ouOqiiojWLjYRipLebd8+fIUO3DgQIpdffXVjTKJl+fMmZNipaA80/OiPkd9jGIqAiUBJUlSKaaiUXp5AMkISeKp560i+AheP9B88JOf/KRRprGG1jDr16/v91ipvajP03XU+YCkgnSOpdAXJ0TkPkyiUJrT2giY6cUGlMMkf1ThfBupYwSvzVRoOXfu3FSHYldccUWK6TnRWEY5RWO41qPxlPKOpJfarjSmkEi4JPSyja1btzbKbV7aEcFjkN4P0ZhH14rW6ToW0nfR+VA+6nxL1/2CCy5IMRLk68tJKB/pWDdu3Jhi+/fvb5Qpz4YOHZpiVE/XNW1ewlESEtHfe++9jTKNUzS+032Ojqu0ziNJP81r2m40Fuv4GRExb968FLv77rsbZboPJ9EvrXlVoEvnSC80oXWezvl0v0t5R+OejiHUT1+PGN1/MWOMMcYYY4wxxhhTCD+YMcYYY4wxxhhjjCmEH8wYY4wxxhhjjDHGFKLPDXi6HzAi+y5oXy7tZxw9enSK6R61448/vtV3kcNG95UNGzYs1Rk1alSK0f7PI444olFWX0gE7zOjY9U9t9Sm1IZ33nlniqlThvap6rFH8H55PSc6Lt3DWRra07hr165Gmfan0v5CcsXoXmvKF4q94x35+aZ+F+XL/PnzU+yMM85IMd17rPssI3iPPu0d15yhfCFvAu1zve+++xplahv6ftqvqn1n8uTJqQ75rEpB1/OGG25olKnNyIlAe9z1XOmaU3tMmTIlxdRhNXjw4FTnAx/4QIqRt0j33P7xH/9xqqP77iPaeSXGjh2b6tC+X/J73X///Y0y7S0nR8CECRNS7LrrrmuUad/97bffnmKf+9znUuxQQJ4WHc9pLKB+SKgPheYT9dBE8J5/3ddNe97pu8idpHMY9TcaRyg3dJ89HRflInneNNf1nCPYxUJ5rdC6hpx7pWizl5/ygnKYzmvv3r2Nctscpr6vTkDyZNA1IQ+c+sXoHIcPH55idPzqEaI65KKg9Zr6uGiNSutPQtfnNKaQW6Ek5OLQdSSdB/VryketR3O5Oloi2MWjazNyx9D6lvqOHgfVaTtm0zkp1DYUa3M/RP2E/J3aL2hMJU9eKb75zW+m2JAhQxpluk+mPkUeNnUn0ZqRPCd0D6ztRvc4dM9B61t1Gd11112pDt3701ynx0rHri7WCO5v6tuk9QPdJ1J/0M+SN/b1jI3+ixljjDHGGGOMMcaYQvjBjDHGGGOMMcYYY0wh/GDGGGOMMcYYY4wxphB+MGOMMcYYY4wxxhhTiD7lvyS4VHEeycRIdkdSqSeeeKJRJsETyaHouM4555xGeffu3akOSaVIoqSyLpKqkdiKZF163ip2i2AZIbWFCphIJkTHRTJO/S4S69J1LAlJl6ZOndook0B01apVKUZiKZVlqUwrgoXLJIdWSSEJV0nkRmJrFVOS5Iwkd9Q3NabfHZGPPYKPf8GCBY2y9ueIiOeeey7FqM+ptFalhREsZyzFihUrUkxFkSTPbSNai8jXSaW7ERG/8Ru/kWLUtjpekty5rQBS5XEkFaRjJSmxjl+UdySro/YaOXJkv3Wo3yxbtizFdOxVyXVEFseVhMR22l9JXEvzFfVXlfy1kXdH8Jyv8wzlHY2LJOPU+Yn6G50jiQb1u0jeR2M/rUVUNEtzEkHtpSJDavtOEq7SHK3XmETONHe0efEDXV8Sjc+aNSvFdJwaM2ZMqkN5R9dcBdmLFi1KdWgOJbmwXk9am9E4T2Oetg+tZSl/6BxV7EnrVhLplqSNsJfGRso96nv6cgNa39O4QUJgvQ40t5LQlcTWO3fubJTpRRMkOKdz1PmF1mG0ViY57AMPPNAoz549O9WhNRKtb/W4aO1M/aQUJA1XuSxJduklD9TPtD2or2/atCnFLr744hRTubiuryJ4TUffr+Ps9OnTUx36fpoPtX/RNafzprFKx17q89S3qN66desaZRpTKId7w38xY4wxxhhjjDHGGFMIP5gxxhhjjDHGGGOMKYQfzBhjjDHGGGOMMcYUwg9mjDHGGGOMMcYYYwrRp/yXJG0qviHxIMnKSOikUjwSfpK4lqRA+lmSZBEq74qIePrppxtlEvGSTIgkXypkI8GciuN6O67Nmzc3yiRuHT16dIqpYCoiy91INEayzJKQKHL16tWNskrPIlgGRdI9FZiRLPrAgQMpRsJMlUaRRJBEiSrYi4jo6upqlEkiRRIskrupqPgLX/hCqkN5Rajoi0StJFkmobfmNp0P9cNSkMhRhV80nlEO03W6/fbbG2Uai7/0pS+l2J/8yZ/kgxVIfrpx48YUW7p0aYpdffXVjTL1LRq7SFanskPqIyTupv6m/Z4kjCRtU2l8RG57ykWSwpWCZIy7du1qlGleoHYk+aOKcOm7SDza5uUBJOekeZQEpXPmzGmUKccoD+hYdSymlwdQ25C0VudNFfhGcK5Tv1FJKOVwJ83TNK/q+oOuE805dF7alvSCApq32/zO559/vtXn6HfOnTu3UVZ5ZgSPu5SfKgB95JFHUh3qNyQ91rGLzpHmFuq7+v00H9PavCR0/XSepvOnvkhtp3JZWtPRHEljkI5xJK6lvKJ81DGaxPr00gqSz+o93rZt21IdOm+67zj99NMbZRob6XoQOjbSfRStrUpB7a1jEPU7mndo/aH5QnVoDKK5VfOMJOt0XDSv6X0CfY5k2ISOl5TX1Ed0PUTfRes8vfeK4PbSZx4kem57jhH+ixljjDHGGGOMMcaYYvjBjDHGGGOMMcYYY0wh/GDGGGOMMcYYY4wxphB+MGOMMcYYY4wxxhhTiD7lvySfUpEVyX9JTEYiTBUKkaiJRD7r1q1LsSFDhjTKs2fPTnVIKkVyMJUAUTuQXJjaQoWyJLkj0SCJm1S2Rt9FEi6SLalAdtCgQanO2rVrU6wkdK1UOEvyKRISknxNxbsk1STR2ooVK1JM25OEUSNHjkwxkjDv2LGjUaZ8JBGffi4iS1KpTUn0tWfPnhRT0R8JZKn/EtpeJJgjuXAp5s2bl2IPPPBAo6x9P4LliCT0nDRpUqNMYkcSiV9//fUpppJ1kr5OnDgxxc4888wUUzkgjfU0LpHwWcdLGrtIRkjCTJUEq2QwgsV6y5YtSzHt4yqZjYi49dZbU6wUNL5pW1I/pFwkqf348eMb5fvvvz/VIeEqifl0XiMZIcVIiq7id+qTNI+SwF3bh+Zymqcp/zVG/YFehkDXSPs4tSn1h1LQix90zUjzKrUHzdE6N5Hwk6Sj69evTzEdW6gftZHgRmTB5cc//vFUh+SSNC7qyydofqBzpJhKbEmsTetDWgOovJT6CK0nSkJjiR4jXU+9BhG8/tC+R58j+e/KlStTTNeDbaXMNCboGP2Rj3wk1aHrR+Oszoe0BiYJOvVzHeNo7CLpN61ZNEdpXKdjLQXdJ0yYMKFRpvmK1jJthPL04gR6+QTNO9OnT2+UKVfoPpzuX3QdvHDhwlSH1nl07TT25JNPpjo0xtEYqmMD/T6aX/SaReT7L/p9NL/0hv9ixhhjjDHGGGOMMaYQfjBjjDHGGGOMMcYYUwg/mDHGGGOMMcYYY4wpRJ+OGdpzpXu6aN8l7U8977zzUuyhhx5qlIcOHZrqbNmyJcW6urpSTPdG0n5b2o9G+0t17/3MmTNTHdobSXvudE8o7cV8/vnnU4z2yWlbP/zww6nOlClTUoz2MetxkdODHAQlof27Rx99dKNM7dv2PHRPL+1LHzZsWIqRl0H3HFK+UO7Rvly97uSTob3HVE/bkPaX0t5m2mOq7XPFFVekOrQ3mNpQj4v2oT744IMpVgraQzpjxoxGmVwckydPTrHly5en2Pz58xtlGs9on7r2B/quZ599NtVRX0cE57XmJ7m8aE80OYp0L/muXbtSne9973spRvuwNf9Hjx6d6qi3JyLitttuS7HPfvazjTLtm6Zj7STUz0G+jsGDB6cY9dennnqqUSZvA/mBqI/omDdixIhUh/oDOWx0HKE5k1xw5FHYvHlzo0zuoaVLl6YYOTW0D1Id8kPRukmdLeQIIJdVKehc9RyoDnklNO8isquN1p/kTCEeffTRRlldXBG8ZqQ5WseWNr6g3tA1L60ryR9B7jntz+TyobyjMU8dOeROonGmJOT20/GLxgNyLtIcpu1E+UjfT24qXYOTc5PWwDRPay7QWEzHRe2lno22+UjnqPlB/h26HyKvh84lNL/TGr4UNBfpuovuVSinaD3exjVGuUK5oS5KcsCoVyuCxyA9VqpDblA6Hx2PyStE9wl0/Bs2bGiUaV1D8y19l95rtXX69Yb/YsYYY4wxxhhjjDGmEH4wY4wxxhhjjDHGGFMIP5gxxhhjjDHGGGOMKYQfzBhjjDHGGGOMMcYUok/5L4lvSBTUhn379qWYCn+2b9+e6pAAiwSvKiwlEeDatWtTjITDKstVqWcES5RIvKkiN5JrHXfccSlG8rWNGzc2ytOnT091SAJLgq02EmeSd5WEpFE7duxolEn8R3JEEt5pPtI1JiEhtZOKq6gvjRs3LsVIbKr5QYJOkm+SwPKRRx5plEl4RfI1EsWpsJFkYCSCJbmn5ii1PfXVUtx9990pdtZZZzXKKheLiLjzzjtTjNpIxzOS2T7wwAMpRpLUb3/7240yCQQ/9rGP9XsMEbnf0PhMwkz6LhVRkmye+umsWbNSTPOYxJT33ntvio0fPz7FdAzRcTciYuLEiSlWChJD61xE+UMSaJo3td/RHENjLLWtzoeUKyQEJpG5jnk0j9I5ksRT5xbqIzS3DBkyJMXe97739VuHcpH6rkJzIEkvS0HHp7lIcxWtD6m9VbxIslm6vvRSBJ1HSdZO4w+JYfWcaEwnmeXu3btTTMdBEknS+EZjrJ7jtGnTUh0aP2gc0Lag8yGJZ0loHaF9+4gjjkh1SK5Ka2QVQdN1oXsmaicVypNkl3KPxsbTTjutUR45cmSqQ9ePxktd39ILWSj3qG+qAJeOnQTVKiCOyH2OPkfr1lLQfYLeA1Bfp8/RfaTmOrUtidepnt4DU/uTBJ3QdQDdJ+/duzfFaOzVe3+6H6Mcpnsm7RMk56VxgPJav5/6lvbJvvBfzBhjjDHGGGOMMcYUwg9mjDHGGGOMMcYYYwrhBzPGGGOMMcYYY4wxhfCDGWOMMcYYY4wxxphC9Cn/ffnll1NMJTckDyUBFglzVBRHglSSHG3bti3FVBRHMjmS4NJxTZ48uVEmURcJ5qieiv9UvhrB50gCI41R25M0uI1Uk6SzJN8rSRvhMgkg6dyo7bR9KR9JBHrYYYelmIqxSHhIAsi5c+emmMp46bqQIIwElipIU+FcBOeQin4jsnRy/fr1qQ7FSHKp14gEo21lY4cCyg3t22PGjEl1SGhGAjOVCy9cuDDVIdEmHdeSJUsaZRIBPvzwwylG16mrq6tRphwj8RmJm1VuuHPnzlSH5qBvfvObKab95itf+UqqQ+JLEqh///vf7/dzJF4uBY0/OlZSjrX9Lp0j2woE16xZk2I6jtC4QiJAFepG5HmaBMQ0VtKYp58lWSCJrmktMmfOnEZ51apVqc7YsWNTjMYGnbup7Wn9UArKAxUo0jnQ2oz6vuY1tRl9Tl8SQJ9VsXAEy3npd+r4RmMzzdH0wgsdW5555plUZ/DgwSlGgk4VTtKLMyivqS0UWldR23caukakY6b1RxuxMY0bBw4cSDHqA7q+ofUu5THJVKdOndook2S9rbhfpdgki6Z8obzVfKR5SQXBEdz2upaltidZciloTND7EBJR00s1aN7UPKb1G83vK1asSDGdb+n60r0z3bfqnEDz+xlnnJFiNLeqlJj6Fr3ogMZZzQ0aB0j+S/V0TUFC/gcffDDFesN/MWOMMcYYY4wxxhhTCD+YMcYYY4wxxhhjjCmEH8wYY4wxxhhjjDHGFMIPZowxxhhjjDHGGGMK0af8lyRPKgUiQc/pp5+eYqNGjUox/ewrr7yS6pCsjORrKvslaRsJ5i699NIUU3klSaVIrKQyqoh8rCoDjmAZEgmwVEhGMlQ6bxJF6bGS0IjOpyQkgFQ5IkmqtmzZkmLUJsccc0yjTFI1kvOSAFUlWySmnDFjRr+fI0giRuI/ErkdeeSRjTLJT+lzJK3W89b2i4iYOXNmitGYoflOcm0aj0pB1+CCCy5olEmCrmLZCJYoXnzxxY0y9Wsau6gfT5gwoVG+/fbbU53f//3fTzGS8c6ePbtRpus0bty4FHvhhRdSTCXEGzZsSHVUYhjBbXHjjTf2ewzDhg1LMRp7VUhIQjuSt5aCZN2anySSpLlV5YwRed4hASX1fRrL9FhJIEgCa/p+nadp/UACShJd33fffY0y9V1qQ5qndaykHKa8I1m4zlM0Vrz00kspVgrqK5qLJFala0fiZo1R/lCu0Pijx0pjBn0XrTG0Hq2daHyjefU73/lOo6xzdgQLnyk3VDhMwld6MQHluvZdumadJOiP4DbXsZsEn7QGorw9+eSTG2VaF2idiIhHH300xTSXaf1JL62gPqD3JyTkp3lUXzQREbF8+fJGmfpSmxeMRGTpMdWhvkPibJXKkiCYJMuloPHlRz/6UaNM/ZNkttQ/tS2pzWg+pPsQzQO6TjS/07z5yU9+slGmcYPGMxp79T6H5NE0H9L93uOPP94o09qnrdRarxutrdoI1f9f3dY1jTHGGGOMMcYYY8xbih/MGGOMMcYYY4wxxhTCD2aMMcYYY4wxxhhjCtGnY4b2VOo+qaFDh6Y6RxxxRIrRXjDdE0t7imnPHe1x131l5LShvWHkB5k0aVKjPHHixFSH9smRk0H3S9L+SXKgELoXltqZ9smRB0L3DNL+ZNqzWRLal6/7a8nlQnt1ac/hxo0bG2Vy2tB3kWdAc5ncQtS/RowYkWK6X5Fylq4VXVPdV0yfo72pV1xxRYrpflJyMR04cCDFKG91LzDt1aZ9rqUgT4XmIp077eddunRpiq1Zs6ZRpmtC+8Yp/3X/7qJFi1Idau8LL7wwxXT8J58Y9RvyA1G+KF/+8pdT7I/+6I9STF0CtK9/+/btKUa+o7PPPrtRXrx4capz1lln5YMtBOWG9n1yP1Ab0b5xHacoh2lPNc116rOgsaBtP9f5nHKY1go0H7ZxuVAbkhdGx3C6PuQ7ov6gfhHaw9/pqDNI9/b3Bo0j6j5Qz0Rvn6Nc1DmaxihaJwwePDjFdIyla7lp06YUIzec9kvySVBs0KBBKaZeGDpH8juQm6ON34ccKCUhF+Rxxx3XKJNjhlxJtPbTdtLv7g2611FPC7UlfX9XV1eK6ZhNfgu6XyH3jY5BlP/kA6Hj135IPhD6Lso1vR+gez51j5Zk3bp1KaYuQVoLktOHclHvsSnHyPlIY6Pe09C4cdlll6UY+ap0PKPzaevAU/cTzfk0/tN4pvf569evT3VoPT1lypQU0365f//+VIdcQb3hv5gxxhhjjDHGGGOMKYQfzBhjjDHGGGOMMcYUwg9mjDHGGGOMMcYYYwrhBzPGGGOMMcYYY4wxhehT/kuiORVBqbAqgsVZJGlT8ShJ8kj+S3IolTyRoIqkhSTvU6EliX5J7kZCv9WrVzfKJHsjwRyJblXoRXInEnqRoFPPieRaJGkqCcm99HzpXEnaSCJolUZRDlE7kYhLoWtM4jOSlWkfIJEViYQpP1RARbJPyveXX345xVQot3nz5lSH+gnJkvUakZCQrkcpfu/3fi/Fvv71rzfKKnaLYAEtCZ/Xrl3b73ep8DYii2sjsriN2r+N2DAi5yyNeSQaJFRiTYL4OXPmpBjV0zYkkRvJ9wiVNpNQnWR1pWgjaafxh6SXJO9TISSJcem7KM90/UDfRUI/kl62kUfTGob6iI679N201qE1i14PGpvpvGnc1TGc6tALGEpB56rrCBoz6HM0R2u/o1yhsYyE0jqWkTSS8keFuhFZ9kjjA42LJJLU+Z7EmzQfE3qO1A7Ut2htovMBrS9oPVGS6dOnp5iuyWl9SOtIGhs1R2kspnGQ1jd6L0IyZxK2k+BYrzN9jvKR7re0by5btizVoXsyuofRdqV+QvcddKw6L5NUnMS2paB+rIJbeqmAvpQkImLXrl0pNm7cuEaZ5gp60YzK2SNy/lAO073Q1KlTU0yhXCHpNM3B2t9oLUjPGmh+0RdsUJ+cNm1aitEYqsdFL3uh+6Pe8F/MGGOMMcYYY4wxxhTCD2aMMcYYY4wxxhhjCuEHM8YYY4wxxhhjjDGF8IMZY4wxxhhjjDHGmEL0aTAkyZnK7kiqQ6ImErmpPIxkQiTAIiGbyh9JdkUyIRI76jmSNJLOkeRTe/bsaZRJjrZjx44UGz9+fIrVdd3v56i9SFCoYiiSflE7l4Sk0iqzJYET5d7YsWNTTOV2dP4koKVcUPEZyTHnz5+fYiQrU0EYofLBiIht27al2IQJExrl5cuXpzqUoySVVvEiicuefPLJFDviiCNSTMWLKuaKYElZKX74wx+m2Pvf//5GmfKVxJSUG7/1W7/VKFOOHX/88Sm2devWFJs0aVK/x0AyScr1559/vlHetGlTqkNyNxqrVq5c2SiTbJhkcrfddluKnXfeeY0yCQpPOOGEFKM+eM899zTK1B9IfFkKyg29niQeJAGtzjEEyUJp7qacUrEj5aJKDCN4XFdUJh3B14lEg5rXtFag9RAJgameQmMDiWxVRE3XjK5tKejcVSRLcxy1B32XzhO0/iQBK4kw9Thovqf1VBtRMV1LkgvT/KjHSrlPYyW1of5OEleS/JZ+ZxspcZsXIRxK6GUKuv6gfKExleS/mkNtX+hA6LxJElzqOyNHjkwxFY3SWpDOh/qAjqskV20rEtZ5gsZZ6l+0RtK8pbGRpPeloLWMngPdq9D6g8YSjdH4SS+70bkvIucLXV9a79N8qMdP/Y1E0ST21XshWtPRmpRkvLo20Huj3o6L+qXm/2/tpwAAB45JREFU2UMPPZTq0Pf3hv9ixhhjjDHGGGOMMaYQfjBjjDHGGGOMMcYYUwg/mDHGGGOMMcYYY4wphB/MGGOMMcYYY4wxxhSiT/kvyZseeeSRRpnERCSlPPLII1NMpUNtJYskPlLpEMmi6LhIaqpyHxKrkuxQRX0REV1dXf3+PpVz9oZ+ls6HZFoqRo7IYiU6H5JClYSkYEOHDm2USfxEsrINGzakmAqjhw0bluosWbIkxc4555wUU8EVtS991zvfmbukirdIpEoSLDr+LVu2NMptxNAR3A+1Xe+4445UhwRh1H9VenbmmWemOiTdKgVJ/nRsJAE5XTuSgi1durRRHj58eKpDgsmrr746xa699tpGefLkyakOiQDpHHV8IREvjRuXXnppimkuLly4MNX527/92xTTMTUi4sYbb2yUSWL4kY98JMW+9a1vpZj2GzofEtOVgo5Fxx8S9pK8k+ppbpB4lKSiNObpWEayYRVXRuRxPiLLhWlcWb16dYqRXFjFkSQopLGSxkWVsFKb0lqH5jedD0iu2EbYfKigdZe2Eclm27aHti2J5KmN6Lt0TUrHQAJrkkfrWozmqu3bt6cYrU00F+kcSRJK56h9l3KYxnmSZeq1pT5Ca+WSkFxZxwlaM9N4RvcwKkmm7yJhb5u2o35NYxzlla4N6LpTPySBro7jtFagOZL6k45ntN6l+076Ll0/kOyWhNiloBfNaLvRmo7GIGoPffEDvUCGXqpBgludI+kYVqxYkWJtZMt030pjKuWnrj2ob5GwndpL+wS9OIPGcXq5hQq4aVxvKwGP8F/MGGOMMcYYY4wxxhTDD2aMMcYYY4wxxhhjCuEHM8YYY4wxxhhjjDGF6NMxs2vXrhSbNWtWo7x79+5Uh/YIkn9F9/Lv2bMn1aH9b7RfTPee0b77008/PcUee+yxfo+L2oH2YtJx6f5P2iNKbUiOBN2rTXteaR8j7ZPTc6S9mOQIKAnt1b/pppsa5QULFqQ6a9eubfVdTz/9dKNMjhDN/wjea6lOEHIR0L5f2qOt/hjKM4L2V+seVtpLTVx44YUpdt111zXK5G6gfZXqmYjI+UfeJdq3WYqJEyem2Fe/+tVG+corr0x1yANAY9z69esb5dGjR6c6l19+eYrdcMMNKabemSeeeCLVoVwk/4o6g2iPL/VBOm89J/KB0Fxy9913p9jv/M7vNMqrVq1Kdb785S+nGM1L2hbUzuRZKYV6DiLyPEO+AnLMkG9CPQC0D568AxRTaA5r4xaJyM4LOnba807zrTofaE99W0/P0Ucf3W8d8iFQLmrbk2uKPlcKugbaHuRMoetLazjNFxq3aI1FOasOA8oV8tWQ+0DrkWuk7dpPrzmtwygXqV3VYUHzPX2OckrbnuZxOseS0Dita3da55EzhdwYmu80HxKUj20cPnSPROO/Xj9ydJGniPqTnncb104E3yPpvQiNF3TNKN811sY9WhK619S1PbUtraFpzTht2rRGmXxfdC9LjkOds6ivDx48uNX3jxo1qlH+zne+0+oY2jglydlIfkq6d9D1JrlC1WMUke8TI/J6k+ZpctP0hv9ixhhjjDHGGGOMMaYQfjBjjDHGGGOMMcYYUwg/mDHGGGOMMcYYY4wphB/MGGOMMcYYY4wxxhSiT/kvSUa3bdvWKKtENoJFQfRdKjUiIR5Jq0gUpzItkq22FXqpYEsFTREsUySRlUoESe5EwjCStKmYi+SKJLqdO3duv8dK14yEoyV5/PHHU6yrq6tRvueee1KdsWPHphiJwlS6R3I0gvqAXlOS/JFEkOTNKk8keeuGDRtSjCSaU6dObZRJNjxy5MgU27p1a4otWrSoUSZhIMlb6ToqJMzcvHlzv587VJCM7rOf/WyjTOc5fvz4FKNrp6JyqrN48eIU+/SnP51iX//61xtlGoPWrFmTYpQbOk6sW7cu1aGxXnM4Io/ZNAbNmzcvxej4VQh80UUXpTqXXnppiv3VX/1Viun8cv3116c62o9KQlJ7bSOam+g6kQBVBfYkZ2wzbkVkaSEJn2lOJhm+jrEky6R5WmWEEXlsIVkgzQckAlRIwkiccsopKabXaNOmTakOichLoXNoRM49mpfoc5QH2t70OcqDV155JcVUWEqySco7up66FiPRI833tA7RdV6bNo1g0am2NYmEaR1JYk99mQAdVycJ+iN4/aHzTBtJeW/1NEZrZhJBU25rPVo/0BxJ9zUKjdkk7KUxW697m3umCBa6tnlxBa2taH7R30nnQ/eUpdB754h8Xeh+l8bL2bNnp5iOeyQbJjHuxo0bU0zXFNTXSfRL863er1xyySWpDkl8SXqsgl5qG7r3p3lT7x1J9EtzAvVn/Z10r9J2HRDhv5gxxhhjjDHGGGOMKYYfzBhjjDHGGGOMMcYUwg9mjDHGGGOMMcYYYwrhBzPGGGOMMcYYY4wxhahI1mOMMcYYY4wxxhhj/vnxX8wYY4wxxhhjjDHGFMIPZowxxhhjjDHGGGMK4QczxhhjjDHGGGOMMYXwgxljjDHGGGOMMcaYQvjBjDHGGGOMMcYYY0wh/GDGGGOMMcYYY4wxphD/F9fTDfUgOLNFAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1440x1440 with 49 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['figure.figsize'] = [20, 20]\n",
    "for epoch in range(n_epoch - 1):\n",
    "    plt.subplot(7, 7, epoch + 1)\n",
    "    plt.imshow(Generator_output[epoch], cmap = 'gray')\n",
    "    plt.title('Epoch %d' % (epoch + 1))\n",
    "    plt.axis('off')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python3.7 BMEN4460",
   "language": "python",
   "name": "bmen4460"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}