{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Illuminating the Latent Space of an MNIST GAN\n", "\n", "_This tutorial is part of the series of pyribs tutorials! See [here](https://docs.pyribs.org/en/stable/tutorials.html) for the list of all tutorials and the order in which they should be read._\n", "\n", "One of the most popular applications of [Generative Adversarial Networks](https://en.wikipedia.org/wiki/Generative_adversarial_network) is generating fake images. In particular, websites like [this person does not exist](https://thispersondoesnotexist.com) serve a GAN that generates fake images of people ([this x does not exist](https://thisxdoesnotexist.com) provides a comprehensive list of such websites). Such websites are entertaining, especially when one is asked to figure out [which face is real](https://www.whichfaceisreal.com/index.php).\n", "\n", "Usually, these websites extract fake images by sampling the GAN’s latent space. For those unfamiliar with GANs, this means that each image is associated with a real valued vector of $n$ components. But since these vectors are typically generated randomly, the usefulness of these websites breaks down when we wish to search for a specific image.\n", "\n", "For instance, suppose that instead of fake faces, we want to generate fake handwriting, specifically the digit eight (8). We could train a GAN on the MNIST dataset and produce a generator network that generates fake digits. Now, we can repeatedly sample the latent space until an eight appears. However, if we want to _find_ an eight, we could optimize latent space directly with CMA-ES. To ensure that we generate eights, we could use the output classification prediction of a LeNet-5 classifier as the objective (see [Bontrager 2018](https://arxiv.org/abs/1705.07386)).1 But notice that the latent space likely contains many examples of the digit eight, and they might vary in the weight of the pen stroke or the lightness of the ink color. If we make these properties our measures, we could search latent space for many different examples of eight in a single run!\n", "\n", "[Fontaine 2021](https://arxiv.org/abs/2007.05674) takes exactly this approach when generating new levels for the classic video game [Super Mario Bros](https://en.wikipedia.org/wiki/Super_Mario_Bros). They term this approach “Latent Space Illumination”, as they explore quality diversity (QD) algorithms (including [CMA-ME](https://arxiv.org/pdf/1912.02400.pdf)) as a method to search the latent space of a video game level GAN and illuminate the space of possible level mechanics. In this tutorial, we illuminate the latent space of the aforementioned MNIST GAN by mimicking the approach taken in [Fontaine 2021](https://arxiv.org/abs/2007.05674).\n", "\n", "1Since the discriminator of the GAN is only trained to evaluate how realistic an image is, it cannot detect specific digits. Hence, we need the LeNet-5 to check that the digit is an 8." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setup\n", "\n", "First, we install pyribs, PyTorch, and several utilities." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%pip install ribs[visualize] torch torchvision numpy matplotlib tqdm" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import sys\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import torch\n", "import torch.nn as nn\n", "from tqdm import tqdm, trange" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Below, we check what device is available for PyTorch. On Colab, activate the GPU by clicking \"Runtime\" in the toolbar at the top. Then, click \"Change Runtime Type\", and select \"GPU\"." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Loading the GAN and Classifier\n", "\n", "For this tutorial, we pretrained a GAN that generates MNIST digits using the code from [a beginner GAN tutorial](https://debuggercafe.com/generating-mnist-digit-images-using-vanilla-gan-with-pytorch/). We also pretrained a [LeNet-5](https://en.wikipedia.org/wiki/LeNet) classifier for the MNIST dataset using the code [here](https://github.com/icaros-usc/pyribs/tree/master/tutorials/mnist/train_mnist_classifier.py). Below, we define the network structures." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "class Generator(nn.Module):\n", " \"\"\"Generator network for the GAN.\"\"\"\n", "\n", " def __init__(self, nz):\n", " super(Generator, self).__init__()\n", "\n", " # Size of the latent space (number of dimensions).\n", " self.nz = nz\n", " self.main = nn.Sequential(\n", " nn.Linear(self.nz, 256),\n", " nn.LeakyReLU(0.2),\n", " nn.Linear(256, 512),\n", " nn.LeakyReLU(0.2),\n", " nn.Linear(512, 1024),\n", " nn.LeakyReLU(0.2),\n", " nn.Linear(1024, 784),\n", " nn.Tanh(),\n", " )\n", "\n", " def forward(self, x):\n", " return self.main(x).view(-1, 1, 28, 28)\n", "\n", "\n", "class Discriminator(nn.Module):\n", " \"\"\"Discriminator network for the GAN.\"\"\"\n", "\n", " def __init__(self):\n", " super(Discriminator, self).__init__()\n", " self.n_input = 784\n", " self.main = nn.Sequential(\n", " nn.Linear(self.n_input, 1024),\n", " nn.LeakyReLU(0.2),\n", " nn.Dropout(0.3),\n", " nn.Linear(1024, 512),\n", " nn.LeakyReLU(0.2),\n", " nn.Dropout(0.3),\n", " nn.Linear(512, 256),\n", " nn.LeakyReLU(0.2),\n", " nn.Dropout(0.3),\n", " nn.Linear(256, 1),\n", " nn.Sigmoid(),\n", " )\n", "\n", " def forward(self, x):\n", " x = x.view(-1, 784)\n", " return self.main(x)\n", "\n", "\n", "LENET5 = nn.Sequential(\n", " nn.Conv2d(1, 6, (5, 5), stride=1, padding=0), # (1,28,28) -> (6,24,24)\n", " nn.MaxPool2d(2), # (6,24,24) -> (6,12,12)\n", " nn.ReLU(),\n", " nn.Conv2d(6, 16, (5, 5), stride=1, padding=0), # (6,12,12) -> (16,8,8)\n", " nn.MaxPool2d(2), # (16,8,8) -> (16,4,4)\n", " nn.ReLU(),\n", " nn.Flatten(), # (16,4,4) -> (256,)\n", " nn.Linear(256, 120), # (256,) -> (120,)\n", " nn.ReLU(),\n", " nn.Linear(120, 84), # (120,) -> (84,)\n", " nn.ReLU(),\n", " nn.Linear(84, 10), # (84,) -> (10,)\n", " nn.LogSoftmax(dim=1), # (10,) log probabilities\n", ").to(device)\n", "LENET5_MEAN_TRANSFORM = 0.1307\n", "LENET5_STD_DEV_TRANSFORM = 0.3081" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we load the pretrained weights for each network." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import os\n", "from urllib.request import urlretrieve\n", "from pathlib import Path\n", "\n", "LOCAL_DIR = Path(\"lsi_mnist_weights\")\n", "LOCAL_DIR.mkdir(exist_ok=True)\n", "WEB_DIR = \"https://raw.githubusercontent.com/icaros-usc/pyribs/master/tutorials/mnist/\"\n", "\n", "# Download the model files to LOCAL_DIR.\n", "for filename in [\n", " \"mnist_generator.pth\",\n", " \"mnist_discriminator.pth\",\n", " \"mnist_classifier.pth\",\n", "]:\n", " model_path = LOCAL_DIR / filename\n", " if not model_path.is_file():\n", " urlretrieve(WEB_DIR + filename, str(model_path))\n", "\n", "# Load the weights of each network from its file.\n", "g_state_dict = torch.load(\n", " str(LOCAL_DIR / \"mnist_generator.pth\"),\n", " map_location=device,\n", ")\n", "d_state_dict = torch.load(\n", " str(LOCAL_DIR / \"mnist_discriminator.pth\"),\n", " map_location=device,\n", ")\n", "c_state_dict = torch.load(\n", " str(LOCAL_DIR / \"mnist_classifier.pth\"),\n", " map_location=device,\n", ")\n", "\n", "# Instantiate networks and insert the weights.\n", "generator = Generator(nz=128).to(device)\n", "discriminator = Discriminator().to(device)\n", "generator.load_state_dict(g_state_dict)\n", "discriminator.load_state_dict(d_state_dict)\n", "LENET5.load_state_dict(c_state_dict)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## LSI with CMA-ME on MNIST GAN\n", "\n", "After loading the GAN and the classifier, we can begin exploring the latent space of the GAN with the pyribs implementation of CMA-ME. Thus, we import and initialize the [`GridArchive`](https://docs.pyribs.org/en/stable/api/ribs.archives.GridArchive.html), [`EvolutionStrategyEmitter`](https://docs.pyribs.org/en/stable/api/ribs.emitters.EvolutionStrategyEmitter.html), and [`Scheduler`](https://docs.pyribs.org/en/stable/api/ribs.schedulers.Scheduler.html) from pyribs.\n", "\n", "For the `GridArchive`, we choose a 2D measure space with \"boldness\" and \"lightness\" as the measures. We approximate \"boldness\" of a digit by counting the number of white pixels in the image, and we approximate \"lightness\" by averaging the values of the white pixels in the image. We define a \"white\" pixel as a pixel with value at least 0.5 (pixels are bounded to the range $[0,1]$). Since there are 784 pixels in an image, boldness is bounded to the range $[0, 784]$. Meanwhile, lightness is bounded to the range $[0.5, 1]$, as that is the range of a white pixel." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "from ribs.archives import GridArchive\n", "\n", "archive = GridArchive(\n", " solution_dim=generator.nz,\n", " dims=[200, 200], # 200 cells along each dimension.\n", " ranges=[(0, 784), (0.5, 1)], # Boldness range, lightness range.\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we use 5 instances of `EvolutionStrategyEmitter` with two-stage improvement ranking (\"2imp\"), each with batch size of 30. Each emitter begins with a zero vector of the same dimensionality as the latent space and an initial step size $\\sigma=0.2$." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "from ribs.emitters import EvolutionStrategyEmitter\n", "\n", "emitters = [\n", " EvolutionStrategyEmitter(\n", " archive=archive,\n", " x0=np.zeros(generator.nz),\n", " sigma0=0.2, # Initial step size.\n", " ranker=\"2imp\",\n", " batch_size=30,\n", " ) for _ in range(5) # Create 5 separate emitters.\n", "]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we construct the scheduler to connect the archive and emitters together." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "from ribs.schedulers import Scheduler\n", "\n", "scheduler = Scheduler(archive, emitters)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "With the components created, we now generate latent vectors. As we use 5 emitters with batch size of 30 and run 30,000 iterations, we evaluate 30,000 * 30 * 5 = 4,500,000 latent vectors in total. This loop will take anywhere between **5-30 min** to run." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Iteration 1000 archive size: 15189 \n", "Iteration 2000 archive size: 18422 \n", "Iteration 3000 archive size: 18784 \n", "Iteration 4000 archive size: 18936 \n", "Iteration 5000 archive size: 19202 \n", "Iteration 6000 archive size: 19321 \n", "Iteration 7000 archive size: 19373 \n", "Iteration 8000 archive size: 19775 \n", "Iteration 9000 archive size: 20835 \n", "Iteration 10000 archive size: 20865 \n", "Iteration 11000 archive size: 20877 \n", "Iteration 12000 archive size: 20908 \n", "Iteration 13000 archive size: 20936 \n", "Iteration 14000 archive size: 20968 \n", "Iteration 15000 archive size: 20998 \n", "Iteration 16000 archive size: 21034 \n", "Iteration 17000 archive size: 21050 \n", "Iteration 18000 archive size: 21110 \n", "Iteration 19000 archive size: 21130 \n", "Iteration 20000 archive size: 21141 \n", "Iteration 21000 archive size: 21161 \n", "Iteration 22000 archive size: 21179 \n", "Iteration 23000 archive size: 21187 \n", "Iteration 24000 archive size: 21198 \n", "Iteration 25000 archive size: 21211 \n", "Iteration 26000 archive size: 21227 \n", "Iteration 27000 archive size: 21250 \n", "Iteration 28000 archive size: 21253 \n", "Iteration 29000 archive size: 21258 \n", "Iteration 30000 archive size: 21264 \n", "Iterations: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████| 30000/30000 [04:30<00:00, 111.06it/s]\n" ] } ], "source": [ "total_itrs = 30_000\n", "\n", "for itr in trange(1, total_itrs + 1, file=sys.stdout, desc='Iterations'):\n", " sols = scheduler.ask()\n", "\n", " with torch.no_grad():\n", " tensor_sols = torch.tensor(\n", " sols,\n", " dtype=torch.float32,\n", " device=device,\n", " )\n", "\n", " # Shape: len(sols) x 1 x 28 x 28\n", " generated_imgs = generator(tensor_sols)\n", "\n", " # Normalize the images from [-1,1] to [0,1].\n", " normalized_imgs = (generated_imgs + 1.0) / 2.0\n", "\n", " # We optimize the score of the digit being 8. Other digits may also be\n", " # used.\n", " lenet5_normalized = ((normalized_imgs - LENET5_MEAN_TRANSFORM) /\n", " LENET5_STD_DEV_TRANSFORM)\n", " objs = torch.exp(LENET5(lenet5_normalized)[:, 8]).cpu().numpy()\n", "\n", " # Shape: len(sols) x 784\n", " flattened_imgs = normalized_imgs.cpu().numpy().reshape(\n", " (normalized_imgs.shape[0], -1))\n", "\n", " # The first measures is the \"boldness\" of the digit (i.e. number of white\n", " # pixels). We consider pixels with values larger than or equal to 0.5\n", " # to be \"white\".\n", " # Shape: len(sols) x 1\n", " boldness = np.count_nonzero(flattened_imgs >= 0.5,\n", " axis=1,\n", " keepdims=True)\n", "\n", " # The second measures is the \"lightness\" of the digit (i.e. the mean value of\n", " # the white pixels).\n", " # Shape: len(sols) x 1\n", " flattened_imgs[flattened_imgs < 0.5] = 0 # Set non-white pixels to 0.\n", " # Add 1 to avoid dividing by zero.\n", " lightness = (np.sum(flattened_imgs, axis=1, keepdims=True) /\n", " (boldness + 1))\n", "\n", " # Each measures entry is [boldness, lightness].\n", " meas = np.concatenate([boldness, lightness], axis=1)\n", "\n", " scheduler.tell(objs, meas)\n", "\n", " if itr % 1000 == 0:\n", " tqdm.write(f\"Iteration {itr} archive size: {len(archive)}\")" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "tags": [] }, "outputs": [], "source": [ "from torchvision.utils import make_grid\n", "\n", "\n", "def show_grid_img(x_start,\n", " x_num,\n", " x_step_size,\n", " y_start,\n", " y_num,\n", " y_step_size,\n", " archive,\n", " figsize=(8, 6)):\n", " \"\"\"Displays a grid of images from the archive.\n", " \n", " Args:\n", " x_start (int): Starting index along x-axis.\n", " x_num (int): Number of images to generate along x-axis.\n", " x_step_size (int): Index step size along x-axis.\n", " y_start (int): Starting index along y-axis.\n", " y_num (int): Number of images to generate along y-axis.\n", " y_step_size (int): Index step size along y-axis.\n", " archive (GridArchive): Archive with results from CMA-ME.\n", " figsize ((int, int)): Size of the figure for the image.\n", " \"\"\"\n", " x_range = np.arange(x_start, x_start + x_step_size * x_num, x_step_size)\n", " y_range = np.arange(y_start, y_start + y_step_size * y_num, y_step_size)\n", " grid_index_batch = [(x, y) for y in np.flip(y_range) for x in x_range]\n", " imgs = []\n", " img_size = (28, 28)\n", " solution_batch = archive.data(\"solution\")\n", " index_batch = archive.data(\"index\")\n", " int_index_batch = archive.grid_to_int_index(grid_index_batch)\n", " \n", " for int_index in int_index_batch:\n", " if not np.any(index_batch == int_index):\n", " print(f\"There is no solution at index {int_index}.\")\n", " return\n", " else:\n", " sol = solution_batch[index_batch == int_index]\n", " \n", " with torch.no_grad():\n", " img = generator(torch.tensor(sol.reshape(1, generator.nz),\n", " dtype=torch.float32,\n", " device=device))\n", " # Normalize images to [0,1].\n", " normalized = (img.reshape(1, *img_size) + 1) / 2\n", " imgs.append(normalized)\n", "\n", " plt.figure(figsize=figsize)\n", " img_grid = make_grid(imgs, nrow=x_num, padding=0)\n", " plt.imshow(np.transpose(img_grid.cpu().numpy(), (1, 2, 0)),\n", " interpolation='nearest',\n", " cmap='gray')\n", "\n", " # Change labels to be measures.\n", " plt.xlabel(\"Boldness\")\n", " plt.ylabel(\"Lightness\")\n", " x_ticklabels = [\n", " round(archive.boundaries[0][i])\n", " for i in [x_start + x_step_size * k for k in range(x_num + 1)]\n", " ]\n", " y_ticklabels = [\n", " round(archive.boundaries[1][i], 2) for i in [\n", " y_start + y_step_size * y_num - y_step_size * k\n", " for k in range(y_num + 1)\n", " ]\n", " ]\n", " plt.xticks([img_size[0] * x for x in range(x_num + 1)], x_ticklabels)\n", " plt.yticks([img_size[0] * x for x in range(y_num + 1)], y_ticklabels)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Visualization\n", "\n", "Below, we visualize the archive after all evaluations. The x-axis is the boldness and the y-axis is the lightness. The color indicates the objective value. We can see that we found many images that the classifier strongly believed to be an eight." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo0AAAIhCAYAAAArc4DYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABg5ElEQVR4nO3deXxU1f3/8fedyUpIwiYEBAICsoi4QFFwA7Qg4kLdqFoRQS11Ray1aCvgty36bbXan4rFotbWrdZibUUBF3AvivAV9w0BMTENagIhZJk5vz/uzJ0bZsjMhExmJvN6+pjH3Jx75865E0w++dxzPscyxhgBAAAAzfAkuwMAAABIfQSNAAAAiIqgEQAAAFERNAIAACAqgkYAAABERdAIAACAqAgaAQAAEBVBIwAAAKIiaAQAAEBUBI0A4vLAAw/Isiy99dZbzR63detWXXrppTrwwAOVn5+vLl266OCDD9bFF1+srVu3OsctWLBAlmWpsrIypve1LEurV68O22+M0cCBA2VZlsaNG9dkX/B1N998c0zXE6lPxhg9+uijOuaYY9S9e3fl5eWpd+/emjRpkv70pz9JkmbMmOG8V3OPGTNmNHutAJCKspLdAQDtz5dffqnDDz9cnTp10jXXXKPBgwerqqpK77//vv72t7/p888/V58+fVp07sLCQi1dujQsMFyzZo0+++wzFRYW7vW1N998sy655BJ16dIl7vedN2+ebrnlFl188cW69tprVVhYqM2bN+uFF17QP//5T1100UX65S9/qdmzZzuvefvtt3XZZZfpN7/5jcaPH++077fffnG/PwAkG0EjgFZ37733qrKyUmvXrlX//v2d9qlTp+r666+X3+9v8bmnTZumhx56SHfddZeKioqc9qVLl2rMmDGqrq6O+LoTTjhBq1ev1q9//Wvdeuutcb1nbW2tbr/9dk2fPl1Llixpsm/GjBnO9QwYMEADBgxw9u3evVuSNGjQIB155JFxvScApBpuTwNoddu3b5fH41H37t0j7vd4Wv6j55xzzpEkPfLII05bVVWVnnjiCc2cOXOvrxs8eLBmzZqlu+66S5s3b47rPWtqalRXV6eePXtG3L8v1wMA6YKfdABa3ZgxY+T3+3X66adrxYoVe83+tURRUZHOPPNM3XfffU7bI488Io/Ho2nTpjX72gULFsjr9eqXv/xlXO/ZrVs3DRw4UHfffbduu+02ffjhhzLGtKj/AJCuCBoBtLpzzz1XP/7xj/Xcc8/pxBNPVKdOnTRs2DDNnTtXX3zxxT6ff+bMmVq7dq3ee+89SdJ9992ns846q9nxjJJUUlKiq6++Wg899JDeeeeduN7z4YcfVufOnXXNNddo6NChKi4u1imnnKK//OUvBJAAMgJBI4BWZ1mW7rnnHn3++ee6++67deGFF6qhoUG///3vddBBB2nNmjX7dP7jjjtOAwYM0H333aeNGzfqzTffbPbWtNvPfvYzdenSRdddd11c7/m9731Pn376qZ599lldf/31GjNmjJ5//nlNnz5dp556KoEjgHaPiTAAEqa0tFQ/+clPnK//9re/6ZxzztG1116rtWvXtvi8lmXpwgsv1B/+8Aft3r1bBx54oI455piYXltUVKRf/OIXmjNnjl588cW43jc7O1uTJk3SpEmTJNljN88880z9+9//1jPPPKOTTjop7msBgHRBphFAmzn77LM1YsQIvfvuu/t8rhkzZqiyslL33HOPLrzwwrhe+5Of/ET9+/fXddddt08Zwq5du2rOnDmS1CrXBACpjEwjgFZXVlYWcabxzp07tXXrVvXq1Wuf32P//ffXtddeqw8//FAXXHBBXK/NycnRr371K5133nnq1q1b1OMbGhpUXV2trl27hu374IMPJKlVrgkAUhlBI4AWeeGFFyJOajnppJP061//Wq+++qqmTZumQw89VPn5+dq0aZPuvPNObd++Xb/97W9bpQ+RVniJ1TnnnKPf/e53euaZZ6IeW1VVpX79+umss87SCSecoD59+mjnzp1avXq17rjjDg0dOlSnn356i/sCAOmAoBFAi+xtIsmmTZt0/vnnS5IeffRR/fa3v1VVVZW6dOmikSNHavny5Zo8eXJbdjUiy7J0yy23aOLEiVGPLSoq0sKFC/X888/r+uuv19dffy3LstS/f3/NmTNH1113nTp06NAGvQaA5LEMU/4AAAAQBRNhAAAAEBVBIwAAAKIiaAQAAEBUSQ0aX3rpJZ1yyinq1auXLMvSk08+GfU1a9as0ciRI5WXl6cDDjhA99xzT+I7CgAAkCKSFT8lNWisqanRIYccojvvvDOm4zdt2qSTTjpJxxxzjNavX6/rr79eV155pZ544okE9xQAACA1JCt+SpnZ05ZladmyZZo6depej7nuuuv01FNPOcV0JWn27Nn6v//7P73++utt0EsAAIDU0ZbxU1rVaXz99dfDaqpNmjRJS5cuVUNDg7Kzs8NeU1dXp7q6Oudrv9+vb775Rl27dpVlWQnvMwAA2HfGGO3YsUO9evWSx9P2N0p3796t+vr6hJ3fGBMWl+Tm5io3N3efz92S+CmStAoay8vL1aNHjyZtPXr0UGNjoyorKyMuW7Zo0SItXLiwrboIAAASaOvWrerdu3ebvufu3bvVv//+Ki//JmHv0bFjR+3cubNJ2/z587VgwYJ9PndL4qdI0ipolBQWhQfvru8tazhv3jzNnTvX+bqqqkp9+/bV1q1bVVRUlLiOAgCAVlNdXa0+ffqosLCwzd+7vr5e5eXf6IvNf1NRUeuv/lRdvUv9Ss8Oi01aI8sYFG/8FElaBY0lJSUqLy9v0lZRUaGsrCx17do14mv2ltotKioiaARakW/H05Ikb+GUJPcEQHuWzKFlRR3zVNQxv/VP7Pfb509QbNKS+CmStAoax4wZo3/9619N2lauXKlRo0bFfD8eAACgRfx+J8Br9fMmUGvFT0kNGnfu3KlPP/3U+XrTpk3asGGDunTpor59+2revHnatm2bHnzwQUn2TJ8777xTc+fO1cUXX6zXX39dS5cu1SOPPJKsS0CC+Pyrw9q8nnFxHdPc/ljOH0+f3PuinSeW80Z7j3g118+W9N1XFfjhk+X6ERLY9tWuCDveqgmN0/F0OyOm92hLvvrnJEnenBPC97mux5s/aa/nMO/e7Wxbwy9txd65+hL4XsX7bywRgp+Z9U1ojJcpLpbU/OcEYN8lK35KatD41ltvafz48c7XwbGHF1xwgR544AGVlZVpy5Ytzv7+/ftr+fLluvrqq3XXXXepV69e+sMf/qAzzki9X0IAAKCdSZFMY7Lip6QGjePGjVNzZSIfeOCBsLbjjjtOb7/9dgJ7BQAAkLqSFT+lTHHvtlJdXa3i4mJVVVUxESYG+3JLFOGi3T5PabW1oe38CAPBg/VQWzDbz/P6fyRJ/jFHxPW6WIcUNPncd6+0N3JyQgc2Nu79JO4MgM8X1mbV7rI3qqpDxwVv23tcA/YDdeXM/okvFdIaQxrSmuv7482asNfDWvL5pMLQgEyVzN/fwff+pvwJFRUVJOD8NepSckbKxyZJXUYQAAAA6SGtZk8jsmiTG5A60vr7Eim76LYP9cTizTAGxfp5NjnOnWEMyorxR6Frdakgkx+o2dZtv9jO0QbS+t9Za3CtFtLan0VLJtGhHfGbBI1pTI+bvmQaAQAAEBWZxjRkWXZNpUbfqrB9GZ9hABKpFVdnQPvR3M9dspDtTIrMnk4WgkYAAIBYZHjQyO1pAAAAREWmMQV5rNBA/QafXR7EfYsj0m1pAEDq2ZfVopCCyDQCAAAAzSPTmEKCf5EGs4uR9gEA0lMqrR2OFjIJyjQaMo0AAABoJ8g0JhkZRAAA0oNl/LISkBVMxDkTgUwjAAAAoiLTCAAAEIsMnz1N0NgGGPwMAEA74DeJWSeatacBAADQXpBpTBBf4wuhLzx2bM6kFwAAa1WnsQy/PU2mEQAAAFGRaWxlTobRQzwOAIgPyw6mODKNAAAAQPPINAIAkIKovJGCjEnMkn+G2dMAAABoJ8g0AgAAxCLDxzQSNLaCSOV1AABoDe7fMd6sCUnsCSjuDQAAAERBpnEf+GpX2BvZ2cntCACg/eIOVurI8NvT/EsEAABAVGQa4+T/7P7QF336JK8jAIDM4M5CkepJLpOgTGMiyvgkAP/8AAAAEBWZRgAAgBhYfr+sBGQaE3HORCBojFeOa9JL8JvMIGUAQGsL/I6hzA5SBUEjAABALIxJzJJ/abKMIEFjvLwRPjIyjQCAVkaGMQVRcgcAAABoHpnGGJnnbrI3SvcPNXbpkpzOAADaJ8rrpDYyjQAAAEDzyDQCAADEwm/sRyLOmwYIGmOV5bWf8/OT2w8AQPvlmljp868O3x+hDI+v8YWwNiARCBoBAABikeFjGgkaYxX4hhoyjQCAZAlkIiNmIYEEI2gEAACIhd8kKNPImMa098uB/+Ns33SfPabRMqF/LM63uEmJBCakAwASLELgEhzbKIXGN/rqnwu15ZyQ+H61dxm+IgwRDgAAAKIi0wgAABALJsJgb/K84eliY7mSs9yKBgCkClfgEbwtzS1ptCaCRgAAgFiYBBX3TpMxjQSNzZh9+KbQF9Zg+ynSRBgyjgCAtuT+vRPMMLraKPSNRCBoBAAAiAVjGrE3vkbXX3KBDKPJzgk/kJI7AIBk4fcO2ghBIwAAQCzINGJvsnMbQ19YEf6SizCOBACAhGt0/X4K/A5iHGMb8CdoIkyarAhDtAMAAICoyDQCAADEwvidOQ6tft40QNAYwcFdZkiSXjnV1ejzJaUvAADsyV20O7jmtHvt6eDwKYp7ozURNAIAAMQiw8c0EjRGsNvaKUnK2y8/1FjU0X72sIwgACC5fP7VoS/IKqKNEDQCAADEgpI72NMu/7eSJE9BQaixrt5+dn9jKbkDAGhLkYILfgehjRA0AgAAxIIxjQAAAIjKbxJ0e5qgMW2dUnCsJMnTYXOosaHBfuY2AAAgWYK/g9yBS3B1GH6jI8H4JwYAABALbk9jTwcUWpKkhq8bnLbcgg7J6g4AIJPV1YW2c3Ml7bHONL/J0Ub4pwYAABCTBC0jKErupK3dgRUDvcXe8J3BsSOSlJ3dNh0CAGQur+t3UfB3UE5yuoLMRtAIAAAQiwwf08hUYAAAAERFpjGC4sBdZ7M7wuovabLUDwCgnXCVemsyAQZtj0wjAAAA0DwyjRHsbIzQ2BiYHUNxbwAAMpPfn6AVYdLjLiZBIwAAQCwy/PY0QWMEw4vrJUnZA4tDjWQYAQBJ4B7H6Gt8IawNaCsEjQAAALHI8Ewj6TMAAABERaYxIDt7P2f794MvlyQ1flHttGUNjVByx6THXwYAgPaB29JJluETYcg0AgAAICoyjc0wDa5MYlZg7c8s10dmWW3bIQBA5ghmn0jvpA5jEnOXMU3uXPJPEQAAAFGRaQywXPFzTaOdQfSW5IUOCMxsshrqnSaTm9s2nQMAtG9pMqYt42X47GmCRgAAgFhkeNDI7WkAAABElfSg8e6771b//v2Vl5enkSNH6uWXX272+LvuuktDhw5Vfn6+Bg8erAcffLDV+7R/vk/75/tU90mt8whOszeWx3kkbEAsACAzBEu4eDySxyNv1oSwB1KI8Ye+Z635MPEPT4g3fnrooYd0yCGHqEOHDurZs6cuvPBCbd++Pa73TGrQ+Nhjj2nOnDm64YYbtH79eh1zzDGaPHmytmzZEvH4xYsXa968eVqwYIHee+89LVy4UJdddpn+9a9/tXHPAQAAkiPe+OmVV17R9OnTNWvWLL333nt6/PHH9eabb+qiiy6K632TGjTedtttmjVrli666CINHTpUt99+u/r06aPFixdHPP4vf/mLfvzjH2vatGk64IAD9MMf/lCzZs3SLbfcss99Kcjt4Ty21Xq1rdarvKEFzkNZ3lDZnT25/1oAACBGTjaR3yHpITimMRGPOMQbP73xxhvq16+frrzySvXv319HH320fvzjH+utt96K632TFjTW19dr3bp1mjhxYpP2iRMn6rXXXov4mrq6OuXl5TVpy8/P19q1a9XQ0LDX11RXVzd5AAAApJo945W6urqwY1oSP40dO1Zffvmlli9fLmOMvv76a/3973/XlClT4upf0oLGyspK+Xw+9ejRo0l7jx49VF5eHvE1kyZN0p/+9CetW7dOxhi99dZbuu+++9TQ0KDKysqIr1m0aJGKi4udR58+fSIe53f9Z1l23W5T73Me8nolr1eW8TsPAABi1thoP1x3p3yNL8jX+IKTcfT5VzsPpCC/EpRptE/fp0+fJjHLokWLwrrQkvhp7NixeuihhzRt2jTl5OSopKREnTp10v/7f/8vrstP+kQYa49VVYwxYW1Bv/zlLzV58mQdeeSRys7O1mmnnaYZM2ZIkrzeyLeO582bp6qqKuexdevWVu0/AABAa9i6dWuTmGXevHl7PTae+On999/XlVdeqRtvvFHr1q3Ts88+q02bNmn27Nlx9S9pdRq7desmr9cbFhVXVFSERc9B+fn5uu+++/THP/5RX3/9tXr27KklS5aosLBQ3bp1i/ia3Nxc5cZQhLtDVhdnu3e+T5Jkaly3vKt3Rj0HAAB75Ymep/F6xiW+H2i5BNdpLCoqUlFRUbOHtiR+WrRokY466ihde+21kqQRI0aooKBAxxxzjH71q1+pZ8+eMXUzaZnGnJwcjRw5UqtWrWrSvmrVKo0dO7bZ12ZnZ6t3797yer169NFHdfLJJ8sTw/+MAAAALWX8JmGPWLUkftq1a1dYnBS8Q2viKB2Y1BVh5s6dq/PPP1+jRo3SmDFjtGTJEm3ZssVJl86bN0/btm1zajF+/PHHWrt2rY444gh9++23uu222/Tuu+/qz3/+czIvAwAAoM3EGz+dcsopuvjii7V48WJNmjRJZWVlmjNnjkaPHq1evXrF/L5JDRqnTZum7du366abblJZWZmGDx+u5cuXq7S0VJJUVlbWpOaQz+fTrbfeqo8++kjZ2dkaP368XnvtNfXr12+f+2JZoQi8qiGwneWKyvcyZhIAgJgEMj3cgk5jiVrUI85zxhs/zZgxQzt27NCdd96pa665Rp06ddKECRPiLllomXjyku1AdXW1iouLVVVV1WTcQK/O45ztX/YeL0m6+LzNTpv3qAMlSWboIKfNFHQM7HQFlFks5w0A2DuCxpbZ2+/vtnzvb++4SEX5Oa1//tp6db7qT0m5tngQ4QT4TKOz/U29PfuooSw0EcbrsyfHNCm+Gin7GNzPGEsAQAS+xhecbZYJTDMJngiT6ohsAAAAEBWZxgCPK372BQL+7B6uj6cg3352/zUQzD66M45kGAEAETi3pfk1kb7INAIAAADNI9MIAAAQiwzPNBI0BjT4a53ter89EaZuS2hyTIdIL2IiDAAAmSPDg0YiGwAAAERFpjHA6wmtTx1c7ttb4DqgplZhgtlEdxkeMowAgAB3TcZgqR3K7KQvY+Jb8i+e86YDIhwAAABERaYxIMsKZRqD8b6/znVAsOSOxwq1uTOMAAA0gwxjO8CYRgAAAKB5ZBoBAABikeGZRoLGgHr/Tme7bwf7tnPDzlAiNn97lb3Rp3foRcEVYXJDt7YBAADaI4JGAACAWJBphCQVekuc7W/r7cku3pwIE12yXAW9s7PtZ0ruAABc3KV20I4YYz8Scd40QIQDAACAqMg0BjSYXc52TiCZWF8TyioWmEA2sdEXelFdoCZPfn6iuwcAAJLM+O1HIs6bDsg0AgAAICoyjQAAALFgIkxm83jsW8s9ir7ntBVl2XliX6MrERtcEcY96YVSOwAAIENkfNAIAAAQEzKNkCTLCmUVP9phb2dluya9BL+hDfWhtsZG+zknJ9HdAwCkOMrsoL0jaAQAAIhBps+ezvig0ZJdyDvPKnbaCrLstoY618fz3+/s5/59Qm0NDfYzmUYAyHg+/2pnm6xjO2USdHua4t4AAABoLzI+0xjUqLrQdqQ0cXD5QPcygcFlBAEAGYusYgbxBx6JOG8aINMIAACAqMg0AgAAxMD4jUwCxjQm4pyJQNAY0EW9nW1f4HvXZFxqfqCQt5ePDAAAZB4iIAAAgFhk+JhGgsaAav3X2S7I6itJyslrDB2wY5f97C7uDQDISEx+QSYiaAQAAIiFCTwScd40QNAYUOv/1tmuDtTsrqt1ldTJswt4m6JQEXBl8fEBQCYhw5jZMn0iDCV3AAAAEBWpMgAAgFgwESbDWXaytYun1GmqDcx/aWx0JWJz7VvVVl1o5RhTUGBveEjYAkC74w/8Jnf9jPc1viBJ8mZNSEaPgKQiaAQAAIiB8duPRJw3HRA0Br5Tu7UzbFdNbW7oi9L97cM7dQq1Bf/69PvD2wAA6S3w87zJ5Bd+xCODETQCAADEgjGNkKQ8dQxrKy6sdbZNsLyOzxf+4pycRHULANCGKKkD7B1BIwAAQAwY0wgAAIDojBJzKzk9ansTNMqyP4IdrrWnu+UNkiTtrAlNhOmx+UtJkunePfTabNeKMQCA9FVfbz/nJbcbQCojaAQAAIiBMfYjEedNBwSNpjGs6dvgH5y5DaHGqhpJklVVFXppSUlCuwYASCB3ubTAZEff7pVOkzdvYlv3CEhpBI0AAAAxYCIMJEmNZrezXVkbKPhd5xqzWLVLkmSKi0NtDYFMZK6rCDgAID24FmNwSu3wWxHYK/73AAAAiEWGF/dmQSQAAABERaYxIM8K3XbunGvH0h0L6pw2/w9OkyR5Nm8OtR14YBv1DgDQauoCP9t3h4Yl+QpfkCR5syYko0dIE5k+ppFMIwAAAKIi02jZcbNPofI6NY12wSR3ce/uNXbJHX///qHXBss1uMs2eIjDASBlBH8+uye95E+yN/KT0B+kNeo0AgAAIDq/ZT8Scd40QNAYGEjQaELjF6vrfZKknXU5oeN84UXAySoCQIoL/pwOLhMosVQg0EIEjQAAADHI9IkwBI2BMY0n5h8btuug474JHbb9W0mS6bZf+DnIOAJASnKKdpNdBPYZQSMAAEAMjLFkTOuPP0zEOROBFBkAAACiItMYGEjwUt1Gp+lQa5gk6eWVPZ228afYk2Osb78NvbRLl7boIQAgHk3KoCWvG2h/Mn1MI/87AQAAICoyjQGWK34+orv9sYy/yJVVLO1jP+d3CL0ox1WSBwDQ9iIsrsBSgEgUYxKUaaS4NwAAQPuR6RNhCBoDdvornO23K+3xi76vdjhtntpaSZIVeJYk06PE3sjiYwSAthQspePzvxDWBiAxiHYAAABi4bdkMngZQSbCAAAAICoyjQG1DaHVXw7p4ZUkmfrwkammS9fwF0cYiA0AANoXYxIzaSVdJsIQ4QAAACCqjM80Wp58SVKWN99p21JjP3/6RpHTNvhCX/iLg1lFsosAkHgRinZTXgdtKdNnTxPtAAAAIKqMzzQa0yBJyvOEsor1fntwwZBfhJYRNAUdFKax0X6myDcAJJw7q+jzr7bbKLODNmQSNHs6ITOyEyDjg0YAAIBYMBEGAAAAiIJMo+yB1d/VbXFaOhQF0sQ1odVfnMku7oHY+aHJMwCAxArekpa4LY3kYCIMAAAAEAWZRuMPazq4k93m37jNabOGD7Y38iNMiAEAtC4WTUAK8vst+RMwaSUR50wE/k8EAABAVGQaLTtuznYV9/7XVruUzswZk8OP93pD28GSO1l8jACwT4KZxQiLJgTHL7rHNALJwOxpAAAAIApSZAAAADHI9NnTBI2BiTBeT67TVGvs287WhvecNv9RR4S/lsHZANA69vh5GqmkDmV2kGyZHjQS9QAAACAqMo2BiTC76iudpvmj7Ozj9vs2O22dg5nGdBmtCgBpiGwiUpnfWPInICuYiHMmQtIzjXfffbf69++vvLw8jRw5Ui+//HKzxz/00EM65JBD1KFDB/Xs2VMXXnihtm/f3ka9BQAASL5446e6ujrdcMMNKi0tVW5urgYMGKD77rsvrvdMaqbxscce05w5c3T33XfrqKOO0h//+EdNnjxZ77//vvr27Rt2/CuvvKLp06fr97//vU455RRt27ZNs2fP1kUXXaRly5btU19K8kc4229s7yhJGvPIoaEDqqokSaagINSWnb1P7wkAaCpSWR2yj0gVxm/JJKAQd7znjDd+kqSzzz5bX3/9tZYuXaqBAweqoqJCjcHSgTFKaqbxtttu06xZs3TRRRdp6NChuv3229WnTx8tXrw44vFvvPGG+vXrpyuvvFL9+/fX0UcfrR//+Md666232rjnAAAAyRFv/PTss89qzZo1Wr58uU444QT169dPo0eP1tixY+N636QFjfX19Vq3bp0mTpzYpH3ixIl67bXXIr5m7Nix+vLLL7V8+XIZY/T111/r73//u6ZMmbLX96mrq1N1dXWTBwAAQLyCxb0T8ZAUFq/U1dWF9aEl8dNTTz2lUaNG6X//93+1//7768ADD9RPf/pT1dbWxnX9Sbs9XVlZKZ/Ppx49ejRp79Gjh8rLyyO+ZuzYsXrooYc0bdo07d69W42NjTr11FP1//7f/9vr+yxatEgLFy7ce0cCJXdyFVpTuoM38N1zrfRicgMleXJDpXkAAC3nvu3s270ysOGz9xVEWJELaOf69OnT5Ov58+drwYIFTdpaEj99/vnneuWVV5SXl6dly5apsrJSl156qb755pu4xjUmfSKMZTW9j2+MCWsLev/993XllVfqxhtv1Lp16/Tss89q06ZNmj179l7PP2/ePFVVVTmPrVu3tmr/AQBAZvDLcmZQt+pDdtyzdevWJjHLvHnz9tqXeOInv98vy7L00EMPafTo0TrppJN022236YEHHogr25i0TGO3bt3k9XrDouKKioqw6Dlo0aJFOuqoo3TttddKkkaMGKGCggIdc8wx+tWvfqWePXuGvSY3N1e5zWUHAyV3tuxe6zSdOcw+3qroFjqupLskyeTlRb84AMBeeTb8n71x+DinzZs3MfLBQApJdHHvoqIiFRUVNXtsS+Knnj17av/991dxcbHTNnToUBlj9OWXX2rQoEEx9TNpmcacnByNHDlSq1atatK+atWqvQ7M3LVrlzx7rhrg9UqyI2wAAID2rCXx01FHHaWvvvpKO3fudNo+/vhjeTwe9e7dO+b3TmrJnblz5+r888/XqFGjNGbMGC1ZskRbtmxxbjfPmzdP27Zt04MPPihJOuWUU3TxxRdr8eLFmjRpksrKyjRnzhyNHj1avXr12qe++P2haefXv1IqSVryyRanzQw4wN7YS+oXABAb/6GHBDZWO23WZ59JkjyDZiWhR0BsTIKKe8ebvYw3fjr33HP1P//zP7rwwgu1cOFCVVZW6tprr9XMmTOVn58f8/smNWicNm2atm/frptuukllZWUaPny4li9frtJSO2grKyvTli2hwG3GjBnasWOH7rzzTl1zzTXq1KmTJkyYoFtuuSVZlwAAANCm4o2fOnbsqFWrVumKK67QqFGj1LVrV5199tn61a9+Fdf7WibD7utWV1eruLhYVVVVKioqktdrF/L+ftEVzjH3jP1OklR6Vqh4t/+MSfaGu6B3cHa1J+nziQAgOfz+0HYzPwudcYySrMOvktS0kDcFvBHNnr+/k/Heb42/RB2zclr9/Dsb6zXqxSVJubZ4EO0AAAAgqqTengYAAEgX/sAjEedNBwSNAbtMqOp6n4m+wJbrVnTwtov7bj63pQFkOvfPwaoq+9lV1kOBGnD+4GRCSd4Ip/E1vmDvy5rQ2j0E0EoIGgEAAGKQ6DqNqY6gMWB9/dPO9guPni5JGj+lzGmzgoO9vZH+RgYABDOM1lZXubKOhZIkz4cfO22+kfYCCk0KenPjBmnAb5SQkjv+NJmSzP+mAAAAiIpMY4DfhIp7H3/uN5Ik69Ahof3BTCPjGAEgJELJHdOla1ib/9ARoTafT0A6yvTb00RAAAAAiIpMIwAAQAzsMY2JOW86aFHQuHXrVlmW5SxyvXbtWj388MMaNmyYLrnkklbtYFvpkT/c2W78yi4RkXVSj9ABwVsw/nSppgQACdQYGNITKKkjSVZNjSTJdOvmtHlzTmjTbgFInBbdnj733HP14osvSpLKy8v1/e9/X2vXrtX111+vm266qVU7CAAAkAqCYxoT8UgHLco0vvvuuxo9erQk6W9/+5uGDx+uV199VStXrtTs2bN14403tmon20L5rnec7bdfPUOSNPqaCOs/Zrk+MibHAMgkjaEJg87Pwvx8p8kqC5QpC2QcJUmD2qBfANpEi4LGhoYG5ebadbaee+45nXrqqZKkIUOGqKysrLmXAgAApCW/LPmVgDqNCThnIrQoaDzooIN0zz33aMqUKVq1apX+53/+R5L01VdfqWvXrlFenZqyvKG/lr/3g8BSWLtDSwuqa0f72T2mMYt5RAAyQPDnXqRSOXWhn5P+Pn3sjUBSQZLMu3dLkqzhlyase0BbMabpasKted500KL7qrfccov++Mc/aty4cTrnnHN0yCGHSJKeeuop57Y1AAAA2o8WpcrGjRunyspKVVdXq3Pnzk77JZdcog4dOrRa5wAAAFKF31gJWkawHd+erq2tlTHGCRg3b96sZcuWaejQoZo0aVKrdrCtPD9qsrPt6WoP9m6461mnzbtwemAnk14AtGORJvgFJ8C4bjtbn30mSTKlpWGn8GZNCH0xfELYfgDpqUUR0GmnnaYHH3xQkvTdd9/piCOO0K233qqpU6dq8eLFrdpBAACAVGACE2Fa+2Ha80SYt99+W7///e8lSX//+9/Vo0cPrV+/Xk888YRuvPFG/eQnP2nVTraFMza+52w/ef8wSdJh9xzjtPmDg71d5SUAoN0JZhjd5XVycsIOM/37hx1nbd1qb1BmB2iXWhQ07tq1S4WFhZKklStX6vTTT5fH49GRRx6pzZs3t2oHAQAAUkGmz55uUdA4cOBAPfnkk/rBD36gFStW6Oqrr5YkVVRUqKgoQkHsFLZ/8dGSpK93bnTaDj078Bd07e7QgZGWD6S4N4D2KtJCBpFKjrlK7ngGzWqDjgFIlhZFOzfeeKN++tOfql+/fho9erTGjBkjyc46HnbYYa3aQQAAgFQQnD2diEc6aFGm8cwzz9TRRx+tsrIyp0ajJB1//PH6wQ9+0GqdAwAASBUmQZNW2vVEGEkqKSnRzp07tWrVKh177LHKz8/X9773PVlWelx40HHZR0qSXihocNqskuLwA4OlJlgRBkB7EZzEEulWtFuwzXUrOtLwHP9mu6qGp3R6a/YSQIpo0e3p7du36/jjj9eBBx6ok046yVlv+qKLLtI111zTqh0EAABIBX6TuEc6aFGq7Oqrr1Z2dra2bNmioUOHOu3Tpk3T1VdfrVtvvbXVOphoD1f+TpL0s34/CzVmBf6adq+zSskdAO1NMMPozi5GWmc6mJEsKAi1BX4megunhNoKE9BHACmjRUHjypUrtWLFCvXu3btJ+6BBgyi5AwAA2iWWEWyBmpqaiGtMV1ZWKte1zFQ6OLzIHntzZp/vQo2NdiFbU9on1Mb4RQDtVbSyYRFK7njzw5eM9W1fZp8uMGRJkqzhl+57/wCkhBaNaTz22GOdZQQlybIs+f1+/fa3v9X48eNbrXMAAACpIjh7OhGPdNCi9Nlvf/tbjRs3Tm+99Zbq6+v1s5/9TO+9956++eYbvfrqq63dx4R6u9oOfme8c6bT9k63IZIkk+/KpkaaPQ0A7ZX7Z10gE+l5yfXzfcKE8NcElhskuwi0Ty3KNA4bNkzvvPOORo8ere9///uqqanR6aefrvXr12vAgAGt3UcAAICkY/Z0C5WUlGjhwoWt2RcAAACkqBYHjd99953Wrl2riooK+fe4ZTt9evoUdi3I6ytJmtevNNS4XxdJkuedd50m/7AhgRe4Sk4AQDqLVNw7yLhSH9nZkiRrwi+bPV2T8jtAO8SKMC3wr3/9S+edd55qampUWFjYZBUYy7LSKmgEAACIRaJuJbfr29PXXHONZs6cqd/85jcRS++kE7+xlw8869QvQo3/tQt4+w8Prastr7cNewUArSzCsn+OCMsDWrW7nCZnUiCVx4CM1qIfAdu2bdOVV16Z9gEjAABArCju3QKTJk3SW2+9pQMOOKC1+9Pmcrz2GMUj/hAqSr5ucmD8zrffOm2mW7e27RgA7KsIZXMitrkEf+4Z9/jtaMW/AWSEFgWNU6ZM0bXXXqv3339fBx98sLIDg6SDTj311FbpHAAAQKowgUcizpsOWhQ0XnzxxZKkm266KWyfZVnyuRe6BwAAQNprUdC4Z4mddFRc3EWSpZxs+7Zzv5weoZ259qoGTcpQBANh920abtkASGXun1ER1o92fsYFS+9IMp07S4q8tjSQ6YwSM6YxXUrutCjqefDBB1Xnnm0XUF9f32RNagAAALQPLco0XnjhhTrxxBPVvXv3Ju07duzQhRdemFZ1Gr2ePEnSQz/6ItTYYP+lbXJDk2PIKgJIO5HuCrmHDwV/rjU0hNoCY9T9m/4cOqz/BYnoHZB2/IFHIs6bDloUNBpjmhT0Dvryyy9VXFy8z50CAABINcZYMom4Pd0eS+4cdthhsixLlmXp+OOPV5ZrzJ/P59OmTZt04okntnonE+nMTvZf0M+9HhrTc/LkKkmSp6jCafP3729vRBojRBYSQLpw3UGxvvpKUtPyOs5SgP1DL/HteLrpPgAZKa6gcerUqZKkDRs2aNKkSerYsaOzLycnR/369dMZZ5zRqh0EAABIBdyejsP8+fMlSf369dO0adOUl5eXkE4BAAAgtbRoTOMFF9i3dOvr61VRURFWgqdv37773rM2smL3c5KkvG3fd9pO7r2fJMl07RI6MNKA8iwWYgWQIiKt9BJpOI2r8oWn97n2rsonnDbz/j2SJGvYbKeN29KAzW/sRyLOmw5aFPV88sknmjlzpl577bUm7cEJMhT3BgAAaF9aFDTOmDFDWVlZ+ve//62ePXtGnEmdLnY3fidJuvsnm0KNjYEMY72rDEWkv9wBIBmirB8d3G99sz10WPezJEm+2qedNmeCSzfXWPRurdhPoJ0xshJSiDtdinu3KGjcsGGD1q1bpyFDhrR2fwAAAJCCWhQ0Dhs2TJWVla3dlzbmkWVZKs7pLUl68sk+zp4zjquRJJn+/UKHRxrTSNYRQFuKtcxX4DhTFKqb69u9UpJk1e5y2oLZRwCxyfQxjTFHPdXV1c7jlltu0c9+9jOtXr1a27dvb7Kvuro6kf0FAABIiuDt6UQ80kHMmcZOnTo1GbtojNHxxx/f5BgmwgAAALRPMQeNL774YiL7kTSd1EuS9FJFttN2Rge7/qRVW+u0OetQc0saQLJE+vkT/DlVXx9qC97Gdq304pyCW9JAi2X67emYg8bjjjsukf0AAABACmvRRJh33nknYrtlWcrLy1Pfvn2V61rfNJWd3NleYPXkXq6xmJ/Z22bI4GR0CQAiizAhz1k/unfvUGPg56/XM64tegVkDDKNLXDooYc2W5sxOztb06ZN0x//+EeWGgQAAGgHWjRAb9myZRo0aJCWLFmiDRs2aP369VqyZIkGDx6shx9+WEuXLtULL7ygX/ziF63d31bXIcuoQ5bRV7V5zsNRXx96+Hz2AwDagt8fudSXJDU0OA/PoFnyDJolb/4k56G6OqmuTr7655wHgH3H7OkW+PWvf6077rhDkyZNctpGjBih3r1765e//KXWrl2rgoICXXPNNfrd737Xap0FAABAcrQoaNy4caNKS0vD2ktLS7Vx40ZJ9i3ssrKyfesdAABAijAJGtNo2vOYxiFDhujmm2/WkiVLlJOTI0lqaGjQzTff7CwtuG3bNvXo0aP1etrqPJIsvflfu0zFdedsDe0acJgkyWoIlbAw+fn2RrQ1XwFgX8Sw6os3f9Je99kHeO2nnBNaq1cAJPkDj0ScNx20KGi86667dOqpp6p3794aMWKELMvSO++8I5/Pp3//+9+SpM8//1yXXnppq3YWAAAAydGioHHs2LH64osv9Ne//lUff/yxjDE688wzde6556qwsFCSdP7557dqRxOlztiTWza/0dFpG3DsDkmSOSAn/AXuv/5jXQcWAOLV2Gg/u36+eLMmxPRSMoxAYhhjyZjWn7SSiHMmQouCRknq2LGjZs+e3Zp9AQAAQIqKOWh86qmnNHnyZGVnZ+upp55q9thTTz11nzuWeH5Jlk7a3x6reMCUb0K7SvaTJFm+RqfJRBqlSoYRQKJE+Pniq/qXJMlbfEpb9waAGNMYc9A4depUlZeXq3v37po6depej7MsSz7qGQIAALQrMQeNftesYf9eCs5u2bJF8+fP3/detQl79vSKbbslSSP/VuzsGXNSYAnE2trQ4R0LAy8juwigBZobA90YuqthfV1uH9bnR2GH+QpeSEjXAMQm05cRbNUI6Ntvv9WDDz7YmqcEAABACmjxRBgAAIBMYgKPRJw3HWR80PiXk76SJH3yZbdQY+A2kulQEP4CinsDiFWknxeRhve4fpYEb0v7ap6RJHkLJjv7Yi25AyAx7NvTrV8eJyNvTwMAAKB9iivTePrppze7/7vvvtuXviTF794YIEn69ROdQo2B2d8mx1XcO10WhgSQOiLdjXBnGhsa7OfgMqWSfI32ZBd3hhFAauD2dByKi4uj7p8+ffo+dQgAAACpJ66g8f77709UP5LALu7942Hb7C83/De0a9QQ+9lVBkNZGT/8E0BrcP0sCS7356t/LqwNQOqh5A4AAAAQBekzAACAGLCMYIbb8LVdaqdP7XanzcrOtjfy8kIHer1t2S0Aqai5VV1cvJ5xkiSff3Wzbc6kF25JA0gDGR80AgAAxMKYxBRTSZcCLRkcNNprT79UYZfVmfBWjbOnYGLgY6mvDx2eG1iPmoLeQOaKVKA7sB0xW9ikuLf9FMw4utsApAcjS361fnFvk4BzJgI/sgAAABBVBmca7ZI7RTl2dN/xzNLQrro6SZJxZxXJMAIIcpfjivCzwfftPyVJ3s6nhe/bvdLZ9uZNbP2+AUiYTL89nfRI6O6771b//v2Vl5enkSNH6uWXX97rsTNmzJBlWWGPgw46qA17DAAAkFzxxE9ur776qrKysnTooYfG/Z5JDRofe+wxzZkzRzfccIPWr1+vY445RpMnT9aWLVsiHn/HHXeorKzMeWzdulVdunTRWWed1cY9BwAAmcafwEc84o2fgqqqqjR9+nQdf/zxcb6jzTImeUnRI444QocffrgWL17stA0dOlRTp07VokWLor7+ySef1Omnn65NmzaptLQ06vGSVF1dHVgOMVeWZemE4qskSfcfFyq50+uGoZIk/wH9Qy8sKLCf3SvDcMsaaB/8EX5kR5r0suc+7TGxJU6+2hX2OfIntfgcQKYI/v6uqqpSUVFRUt77N4PnKc+bF/0Fcdrt263rP1oU87W1NH764Q9/qEGDBsnr9erJJ5/Uhg0b4upn0qKe+vp6rVu3ThMnNh3TM3HiRL322msxnWPp0qU64YQTmg0Y6+rqVF1d3eQBAAAQr+Aygol4SAqLV+oCcyzcWho/3X///frss880f/78Fl9/0ibCVFZWyufzqUePHk3ae/ToofLy8qivLysr0zPPPKOHH3642eMWLVqkhQsXRthjT4T5yHpHkvTi5u85e84t7WNv5ORE7QeAdiDSXYPaWvs5WG5LcibJudt8/kCB7qwJcb8tGUYAbn369Gny9fz587VgwYImbS2Jnz755BP9/Oc/18svv6ysrJaHfkmfPW1ZTWsTGWPC2iJ54IEH1KlTJ02dOrXZ4+bNm6e5c+c6X1dXV4d9UwAAAKIxgUcizitJW7dubXJ7Otf9R+seYo2ffD6fzj33XC1cuFAHHnjgPvUzaUFjt27d5PV6w6LiioqKsOh5T8YY3XfffTr//POVEyUbmJubu5cP3S7u/feD7fGLoy6ucvb4CzraG7t3hw4PRubujESMS4oBSCHNjVF0l9LJz7efXbeHvAWTw17qq3nG3kj6n+AAEs19K7m1zytJRUVFUcc0xhs/7dixQ2+99ZbWr1+vyy+/3H4/v1/GGGVlZWnlypWaMCG2OyVJi3ZycnI0cuRIrVq1qkn7qlWrNHbs2GZfu2bNGn366aeaNWtWIrsIAACQUuKNn4qKirRx40Zt2LDBecyePVuDBw/Whg0bdMQRR8T83kn923ju3Lk6//zzNWrUKI0ZM0ZLlizRli1bNHv2bEn2reVt27bpwQcfbPK6pUuX6ogjjtDw4cOT0W0AAJCBUqW4dzzxk8fjCYuXunfvrry8vLjjqKQGjdOmTdP27dt10003qaysTMOHD9fy5cud2dBlZWVhNYeqqqr0xBNP6I477miVPqwoL5YkHf7frU6b9dVX9kbnTk6b8XrtjSZryXJbGkhX7okrPv9qe8M1QNwppZMf5TwRblkDQCK1JH5qDUmt05gMe9ZpvGnQPEnSvNmuoPHkI+0Nd9BYZAeXYmlBIL0F/vCLGDS67Ev9RQCtLxXqNN44MHF1Gm/6NPY6jcmS8UO3+3Xw2Ruuka1W5Td2U/fuoQODASKBIpB+6uudzeB6z+5AMRgg+hpfcNp8jc/Z+3JOSHz/ACANZHzQCAAAEItEz55OdRkfNJ5wwDZJkqdPp1Bjl8B2pPI6bmQdgbQQzC42aYtw+7klBboBIFNkfNAIAAAQi0QX9051GRw02ssILlzbV5J05xFfOHs8wwPjHF3joNRMVXYAydfcxBXf7pWhLwJz/1jCD0C8Mv32NPdXAQAAEFUGZxoBAABiZ2TJKHx959Y4bzrI4KDRXnv6yxp7XVnPmNAi3qYwsPa0q9Av60wDqSfWWoruiTC++ucS1BsAaN8yOGgEAACInVFixh+myZBGgsaibPsjaFz1gdPmuWqwveGe/OILTI7JyviPDEgKd1Yx0gouzr6aZ0KvibDEH8W6AaBliIAAAABikOmzpzM+aBxc7JUkZQ3sFGr8738lSX73+MWCgjbsFYA9RVr2L5JI2UUAwL7L+KARAAAgFhT3BgAAQFTcns5Y9oowE0uqJUmmtiG0Kz/PfnZPeqHUDtCmgregg7elYy2vAwBIjAwOGgEAAGJnAv8l4rzpIIODxkBx7135kqTRnlrXrkBW0Z1pbGwMbwPQKpysYuMLTptPq5PTGQBARERAAAAAMWBMY4Yb0ske02gdMcxpM9k59kZw6UBJys5uy24BGcUpp+MaO8wYRgBILRkfNAIAAMQi00vuMCUYAAAAUWV8pvHlr7tIkg56/3OnzQwaaG/U14cO5PY0kDjBoSCUtgKQwjJ9TCM/oQEAABBVxmcae+U3hLVZVVWSJBNpvWkyIUDc3JNagmV1vFkTQgfwvxWANGCM/UjEedNBxgeNAAAAsfAHHok4bzrI+KBx/EFbJElmR2GosSEwlrExN9SWG9h2l+Eh6wjErUmGEQCQNjI+aAQAAIgFE2EAAACAKDI+03jOk70lSf+eWeS0meCtaPc608Hb0qw9DYREGa4RaVWX4OovrPgCIO0kaCJMulT3JtMIAACAqDI+bfaXk76SJJl3vw019rOzj8rNC38BE2GQoZqUzQlmC1swqYUMI4B0lemzp4l6AAAAEFXGZxq/+MpeRvCwQ3s6babRF34gYxmRSdxLaObkhO0mWwggE1HcGwAAAFFxexoAAACIIuMzjUs/7SRJunNHjdNmRnS3N7ze0IGNjfYzt6mRCVy3pIO3ooOTX9xtAJBJjDEyCbiXnIhzJgKZRgAAAESV8WmzEZ0D0X33rk6bVflfSZLp3iN0YHZ2W3YLSIwWFOOOZR8AZAKWEQQAAACiyPhM4+DCWntj07ZQY6+S8AODGRoKeiMdNTMmlwwiAMTGKDEr/qVJopFMIwAAAKLL+EzjMVMD4xcPPy58p2W1cW+A1tNk2b+s1eFtu1faGxFWywQAhMv0MY0ZHzQCAADEItODRm5PAwAAIKqMzzRuXW0XMS4dV+m0+YcfZG+4i20yAQZpxl2MOxJv3sS26QgAtBP2RJgEFPdu9TMmBpEQAAAAosr4TOPfN/WUJM3tGSqz4xT37rZf6ECWEUSyNVP2qckElwgZRsrqAMC+Y0wjAAAAEEXGp83yPHZ4b326yWkzA0rtDfeSa15vW3YL7VV9fWg7mLWOMl42mCX0abXdsA9LAQIAWs6YptMdWvO86YBMIwAAAKLK+EwjAABALIyM/AmZPZ0eqcaMDxr3y/XZG526OG2mqDj8QEruoDXk5MR0WKRbzGG3qfdyHAAgMbg9DQAAAESR8ZnGlWX2BJezK7912qySHpIk06lT6EAyjWgDkTKHwRI6ZBUBILn8gUcizpsOiIQAAAAQVcZnGv/3uC/sjZxBocaaGvu5sDD8BRT3br+ilLKJ+zyxltKJUIzb1/hC6LisCRFfBwBoW8YYmQQMQEzEOROBTCMAAACiIm0GAAAQg0xfRjDjg8ZPtnWVJI3++KtQ48ADwg8M3mpkQkx6i/HWcaTjIt5ODq7w4iqlE7ydHOsa0BHbXLekmQgDAEgFGR80AgAAxMKfoOLeiThnImR80LjsyyJJ0hG9C5w2EykLFWxrrckSaDst+Z5F+H67i2oHefMm2vsiZBXdr91zMks8yDACQGowSlBx79Y/ZUIQ9QAAACCqjM803jjxE0mSGTHFaTPZ2faGP13KbaaQSFm9RGVnY32vSO8Z6XvrPq6xUZLkzTkh7DB3ORwn+9jkfe2nfckuAgBST6bfnibTCAAAgKgyPtMIAAAQC2MSM/4wTWp7EzR+/oldcmf4ps1Omxk+zN7g9nT8WmMllX05t/uY4Pnc5w2s9uPtfJrTFLzd3GTCSaiCTpiIt53J2QMA2rmMDxoBAABikeljGjM+aNz4bbEkabgrQ2U12AWbTUHH0IGRikLHWii6PYg2mWVfPovW+Byby1K6zxtYT7y5tZ0BAEC4jA8aAQAAYuE3Cco0psmgxowNGgs79JdlebX6azsLdU5xobPPZAcGtFlW8ydJ5wzjPiynF9Px7tfE2hYocyNJysoKP645O3bYzwWhIu0Ry+VsX2bv6/qD2M4LAECACfyXiPOmgzSOegAAANBWMjbTuKuuQpbl0e0/+NRu2J7r7LM6dZIkmSzXx5NKWcXWGAMY67jESDOQY33fYObQfXxg9rI7I9js+zbHvUyfazZ0c8gwAgBaykhKRF2V9MgzkmkEAABADDI20wgAABAPSu5kKJ+vRpZlKbu7127okOfsM/n59ob7FmmyyuvEeZs25tvOwVvHWRH+CUSbuBLplnWk80SSmxv+2kia619g0kukW9K+3SudbW/exNj6BAAAosrYoBEAACAexiRo9jQld9LD2893kySNPnpH+M5oE2FaO/sY6Xyxlq3Z8xxuzR0frcxNcxlB9+fT3PtGeg+3hgb7OTs77Dh34W1nub9mJr2QXQQAIDEyPmgEAACIBWMaM1SWt1CW5VGWFciQ5eeFH+T1Nn+S1sgwxjoesbk29+vq7SUQm2T0IpW+iZR9bO64aH2KJJhBjPQ5RrmuSIW5We4PAJBMmR40UnIHAAAAUWVsphEAACAeJpBrTMR500HSM4133323+vfvr7y8PI0cOVIvv/xys8fX1dXphhtuUGlpqXJzczVgwADdd999cb+vz79LPn+NPqgq1AdVhTK9ezoPeTz2w+cLPYJtfn/4o7U1NoYesbyfe19Wlv1oaAg9Ih1XW2s/gsfvOallz/dy9yn4mbiP27HDfrjarK++kvXVV/LmnBB6ZE2wH+62/En2w9UGAAD2Lp746R//+Ie+//3va7/99lNRUZHGjBmjFStWxP2eSQ0aH3vsMc2ZM0c33HCD1q9fr2OOOUaTJ0/Wli1b9vqas88+W88//7yWLl2qjz76SI888oiGDBnShr0GAACZyO/kGlv/EY9446eXXnpJ3//+97V8+XKtW7dO48eP1ymnnKL169fH9b6WSWJxoCOOOEKHH364Fi9e7LQNHTpUU6dO1aJFi8KOf/bZZ/XDH/5Qn3/+ubp06dKi96yurlZxcbGkXFmWpR2zz5QkdZg10jnG9Nnffs7vEHphsBxMpJIxLZkQ09yaztGKcO/52mjleCJ9i4OTUyJlLt3HByfWBAueu0+xDxlBf/nfnG1PydktPg8AIDMEf39XVVWpqKgoKe89puhSZVm5rX7+RlOn16vvjvna4o2fIjnooIM0bdo03XjjjTH3M2mZxvr6eq1bt04TJzatqzdx4kS99tprEV/z1FNPadSoUfrf//1f7b///jrwwAP105/+VLW1tXt9n7q6OlVXVzd5AAAAxCvRmcY945W6urqwPrQkfgq7Dr9fO3bsiDsBl7SJMJWVlfL5fOrRo0eT9h49eqi8vDziaz7//HO98sorysvL07Jly1RZWalLL71U33zzzV7HNS5atEgLFy4Ma8/O6izL8uiTD+zi3odUhYp7mwM7hB0f8zJ5sWouqxipuLa7QLbPZz8Hs4WRyutE6q/7HEHuMY/BbGqEYtzurKJvx9P2sz+0ZJ+TnYxQwsdbfErY25JdBACgqT59+jT5ev78+VqwYEGTtpbET3u69dZbVVNTo7PPju93cdJnT1uW1eRrY0xYW5Df75dlWXrooYcCt5il2267TWeeeabuuusu5Ue4hTpv3jzNnTvX+bq6ujrsmwIAABCNP/BfIs4rSVu3bm1yezo3d++3wuOJn9weeeQRLViwQP/85z/VvXv3uPqZtKCxW7du8nq9YVFxRUVFWPQc1LNnT+2///5OwCjZ9/CNMfryyy81aNCgsNfk5uY2+6EDAADEwlhGxmr9oDG4nnVRUVHUMY0tiZ+CHnvsMc2aNUuPP/64Tjgh/nkJSQsac3JyNHLkSK1atUo/+MEPnPZVq1bptNMiry181FFH6fHHH9fOnTvVsWNHSdLHH38sj8ej3r17x9kD+5te0xi4JdvL9UE3t1pKS25TN7dGdXCiiSRrp32L3BSFguKIt333/Esi0mQW923n5o6LtL62O8gOnMdf8XioLTevad8kefMnhZ8bAAC0qpbET5KdYZw5c6YeeeQRTZkypUXvndSSO3PnztWf/vQn3Xffffrggw909dVXa8uWLZo9e7Yk+9by9OnTnePPPfdcde3aVRdeeKHef/99vfTSS7r22ms1c+bMiLemAQAAWotJ0CSYYKYxVvHGT4888oimT5+uW2+9VUceeaTKy8tVXl6uqqqquN43qWMap02bpu3bt+umm25SWVmZhg8fruXLl6u0tFSSVFZW1qTmUMeOHbVq1SpdccUVGjVqlLp27aqzzz5bv/rVr+J+b68nT5bl0ejxX9sN27s6+6xOnSRJJvAsad/WmW5u/WbXzG/TqXNs7xWcCBMpmxjpPYOZSXdb8BwRuLOG/q//ar+0z4+a7xMAAGgT8cZPf/zjH9XY2KjLLrtMl112mdN+wQUX6IEHHoj5fZNapzEZgrWW8nL6yrI8qvrZsZKkrEnDnGPMgP72c6SgMVJAty91GneEZm2rsDD8fJFmPAcDvuZWo4kUNLq/1ZFeG3hNk6BxK0EjACD5UqFO42HFs+S1clr9/D5Tr/VVS5NybfFI+uzpZNld/7Usy9IV9x0gSbr7AtcMomD2zzXhxhGhHE0TzY1fdIsUhAbrMQVL6bi5azXtGfC5b80Hs4/ufkYaoxnse4R++mqeCX3RpWtYm7dgcnj/AABAu5axQSMAAEA8gqMQE3HedJDUiTAAAABIDxmbabQC//2gt33b16rZ5ezzD7BvWTe5TRwcRxhcNcWtubGFbq5bxlbZV5Iks7+rVFDw1nKkSSo5rjEUwTGKgdvoVnVo9pMpjHEsRHC1Fm41AwAQE7/ll5WAOo2JKBieCGQaAQAAEFXGZhqDNZGOHLLNbqjIC+3sE8j+uQpvKy+w351VjDTBJMY2E5hg0qRsTiD7Z7lnVGfZ2U5T0DHsGryd7SKe/sonQo0RJuJ43nnX3jVsiOu89rc+0gSXJhNh9tgHAECm8ssvK4HLCKa6jA0aAQAA4kHQmLH8kizl9Qhm5kJL81mBsYImWDdRCl+6z81dtiaY6XOV47EqKuxnV+V107mT/ezKIP5zwhuSpNNWjnLagtlE37f/DJ0vsNygCgLnyg1lSSNmBI8I1F10ZxAD/XQf77yHa/wkGUYAACBldNAIAAAQu0wvuZOxQaPH01GWZcmTa2cJTZ9ezj6Tm2tvRJop3fQk9nOU8YuekrPt81bdG3qP/A5Nj5c09ekR9oYvfBUYy1Xce8/VWayaGmfbp6clSd7C8MXIo2UNg1lNAACAPWVs0AgAABAPv3yyFKEsXiucNx1QcgcAAABRZWym0e/fJcuy9OVb9m3i0vND+zyVlfYx7oLawYkt7lvRwWLdESbCPDj6Fadp+qv2rWXv4IudNqvicful3c9y2swnd9n7RlwW1t/gLe5ImtsHAABah5FJ0JhG0+rnTAQyjQAAAIgqYzONWd5CWZZHW6rsZfdKV7/t7POfOTFwkOvjCS4pGKm8jjv7GHjN9LVHh9rcBbwD3BnGoEgZRgAAkBoyfRnBjA0aAQAA4mFPhGn9m7TpMhEmY4NGX2BM47E/DRTtHnxwaGeDvXygcWcag8W9fa5vbDD76M40BrfdSwEGspPmzV87TWb/EnvXoFktvwgAAIA2krFBIwAAQHwSU9xbaXJ7mokwAAAAiCqDM40eSZZW3mLHzd9/JD+0K7j6Srar5E6wvE5BgesUgZjbtSKLAutVzx7xjtN077b59sa40Iorzaxk3YS//G/2W1FWBwCApPIbnxKRb7PPm/rINAIAACCqDM402jrl1oe1WTW7JEmmS9fwF7jL5wTXqHZnHwNZRye7uI/IMAIAkBpMgsY0JmacZOsj0wgAAICoMjbTmJvdRZbl0aGjv5YkWZs7O/vMkEH2hidCTB0ss+PmKsPTt9/tkqRt357San0FAADJZ+STSUC+zVCnEQAAoP2wV27J3BVhuD0NAACAqDI209ir4HB5rWxZuXbxGzOg1NlnghNc6sMnyTS5ZR1cMca1IsyXr0+zmzb9OfSS/he0Uq8BAECyGJkETYQxrX7ORCDTCAAAgKgyNtO4dccbsiyPvMUnSpKs/24P7QxkGo27uHdenv1sucpyB8vvuLKP1pBL7OfW7zIAAEgiY3wyCfgNbyjuDQAAgPYiYzONluWRZXkkT+Avhq8rnX1mwAH2hmusonbZBb9VXBxqCxTytnbuCLW56nwDAID2g9nTAAAAQBQZm2kEAACIh13cOwFjGinundpys4tkWV7VvGuX1Sk8wLWmdOC2tPXdd06TKSqyNwK3pCXJqq2VJK09/x2n7ciXEtRhAACQVMYkaO1pw+1pAAAAtBMZm2kszC6Rx8pShwGBuLm0p7PPs22bJMl03y/0gg4dJEnWt986TValXabnyJd+l+DeAgCAZGMiDAAAABBFxmYadzVWyrK82vWZnWEsdBXoNiU97Gdv6OOxtttZRausPHRcaR+7LeG9BQAAyUZxbwAAACCKjM00AgAAxMPIJGb2tEyrnzMRMjZorKmrkGV51GGQ126o3e3sszZvtTf67B9qC5TaMT1LQm3lFfZG98T2FQAAINkyNmgEAACIh12nMRFjGtNj9nTGBo1jOvxQWVauajeVSZI6jq0P7QxMirEq/us0mW7d7LbV/wm1HT3Sbkt0ZwEAQArwJehGMhNhAAAA0E5kbKbxlZ0PyLIsffbphZKkEZ985eyzBgfGMhbkO20mO9veGHOI0+bpfW7iOwoAAFKCfRs5c29Pk2kEAABAVBmbaSzI6yXL8qpvL3tZQKugS2hnt8C21+s0WQ0N9vP7nzht5j8/tdvOZhlBAADaOzKNAAAAQBQZm2kEAACIh19+WYnINCagYHgiZGzQ2CG7qzxWljpfOtRu8Lsm0X9bJUkyJaGq3da2wESZ/LxQ2+T/SXg/AQAAUkHGBo0AAADxyPQxjRkbNFbVbpVlefT5rzZLkg64squzzxwcyD56XEM+a3ZJkqxxN7RVFwEAQAoxJjFFuBN13tbGRBgAAABElbGZxvycrvJYXh0ws8Bu6Fjg7LPKyiVJpkvn0As2fGw/j2irHgIAgFRiZKQETFoxCVqcsLWRaQQAAEBUGZtpBAAAiEeiJqwwESbF/aDoROV48lT3hr3CS+55vUM7AxNgrA8/c5qeuaujJOmk6W3XRwAAgFSRsUEjAABAPMg0ZqjHv1smy/LqjpzD7Yas0EdhCu2souUPfRNP+s9Vbdo/AACAVJKxQSMAAEA8ErXcH8sIpria3V/Jsix98J8TJEkjxv/X2WdVbLc3enWP9FIAAJCBMv32NCV3AAAAEFXGZhoBAADikemZxowNGrO8HWVZHvUv/UaS5P+/Hc4+z4SD7Y33QiV3NKwtewcAAJBaMjZoBAAAiE+iMoJkGlNaYV4veawsFR7XSZJUvbrK2VfUNZBh9FhJ6BkAAEDqydigEQAAIB6MacxQNXUVsiyPal77VpJU9IPQMoJfP2iX3+lxWWlS+gYAAJBqMjZoBAAAiAfFvQEAABCVMUaJmLRinzf1ZWzQ2OjbJcvy6ONP9pMkHdYY+kdQ0KlekmRN+GVS+gYAAJBqMjZoBAAAiI9PUiIqq5BpTGndOw6Xx8rSQaPtSS+moqOzr+a7HElSx4fnOm3Wube1bQcBAABSSMYGjQAAAPGwS+O0fqaRMY0pzi+/JL8+X99JkjRkSk9nX6dPP5BEdhEAACAoY4NGAACA+CQm08iYxhTXwdNJHitbnsDXjas/dvbd8fQgSdJ1tyahYwAAACkoY4NGAACAuCRoTKPSZEyjJ/ohAAAAyHQZm2n8uvY9WZZXPUoKJEkNFaHi3td9eGOyugUAAFKUSdDYw0Sdt7VlbNAIAAAQHybCZCTL8sqyvCo+q7ckyf/5f5195tn59jEnLkxK3wAAAFJN0sc03n333erfv7/y8vI0cuRIvfzyy3s9dvXq1bIsK+zx4YcftmGPAQBAZjL2pJXWfrQg0xhP/CRJa9as0ciRI5WXl6cDDjhA99xzT9zvmdSg8bHHHtOcOXN0ww03aP369TrmmGM0efJkbdmypdnXffTRRyorK3MegwYNivu9/zzsZD1+8FQ1/GerGv6zVVZBjvO451qP7rk26fE0AABAmHjjp02bNumkk07SMccco/Xr1+v666/XlVdeqSeeeCKu901qZHTbbbdp1qxZuuiiizR06FDdfvvt6tOnjxYvXtzs67p3766SkhLn4fV626jHAAAgc5mE/BdvpjHe+Omee+5R3759dfvtt2vo0KG66KKLNHPmTP3ud7+L632TNqaxvr5e69at089//vMm7RMnTtRrr73W7GsPO+ww7d69W8OGDdMvfvELjR8/fq/H1tXVqa6uzvm6qqpKkrTLZ7dV19VLkrJq651jan277X3V1XFcEQAASJTg7+Tkr9OcuPffM+7Izc1Vbm5uk7aWxE+vv/66Jk6c2KRt0qRJWrp0qRoaGpSdnR1T/5IWNFZWVsrn86lHjx5N2nv06KHy8vKIr+nZs6eWLFmikSNHqq6uTn/5y190/PHHa/Xq1Tr22GMjvmbRokVauDB8Qsv5G+6yN9btvY/XFN8c28UAAIA2sWPHDhUXF7fpe+bk5KikpGSv8Ulr6Nixo/r06dOkbf78+VqwYEGTtpbET+Xl5RGPb2xsVGVlpXr27BlTH5M+e9qymk5dN8aEtQUNHjxYgwcPdr4eM2aMtm7dqt/97nd7DRrnzZunuXPnOl9/9913Ki0t1ZYtW9r8H10qqK6uVp8+fbR161YVFRUluzttimvn2jPt2qXMvn6uvX1duzFGO3bsUK9evdr8vfPy8rRp0ybV19dHP7iFIsU/e2YZ3eKJn/Z2fKT25iQtaOzWrZu8Xm9YVFxRUREWDTfnyCOP1F//+te97o+U2pWk4uLidvM/UksUFRVl7PVz7Vx7Jsrk6+fa28+1JzPZk5eXp7y8vKS9f1BL4qdIWdKKigplZWWpa9euMb930ibC5OTkaOTIkVq1alWT9lWrVmns2LExn2f9+vUxp1UBAADSWUvipzFjxoQdv3LlSo0aNSrm8YxSkm9Pz507V+eff75GjRqlMWPGaMmSJdqyZYtmz54tyb61vG3bNj344IOSpNtvv139+vXTQQcdpPr6ev31r3/VE088EfeUcQAAgHQVb/w0e/Zs3XnnnZo7d64uvvhivf7661q6dKkeeeSRuN43qUHjtGnTtH37dt10000qKyvT8OHDtXz5cpWWlkqSysrKmtQcqq+v109/+lNt27ZN+fn5Ouigg/T000/rpJNOivk9c3NzNX/+/GbHCbRnmXz9XDvXnoky+fq59sy89kwQb/zUv39/LV++XFdffbXuuusu9erVS3/4wx90xhlnxPW+lkn+3HUAAACkOJY9AQAAQFQEjQAAAIiKoBEAAABRETQCAAAgqowLGu+++271799feXl5GjlypF5++eVkd2mfvfTSSzrllFPUq1cvWZalJ598ssl+Y4wWLFigXr16KT8/X+PGjdN7773X5Ji6ujpdccUV6tatmwoKCnTqqafqyy+/bMOraJlFixbpe9/7ngoLC9W9e3dNnTpVH330UZNj2uv1L168WCNGjHCK944ZM0bPPPOMs7+9XnckixYtkmVZmjNnjtPWXq9/wYIFsiyryaOkpMTZ316v223btm360Y9+pK5du6pDhw469NBDtW5daE3Y9voZ9OvXL+x7b1mWLrvsMknt97qRQkwGefTRR012dra59957zfvvv2+uuuoqU1BQYDZv3pzsru2T5cuXmxtuuME88cQTRpJZtmxZk/0333yzKSwsNE888YTZuHGjmTZtmunZs6eprq52jpk9e7bZf//9zapVq8zbb79txo8fbw455BDT2NjYxlcTn0mTJpn777/fvPvuu2bDhg1mypQppm/fvmbnzp3OMe31+p966inz9NNPm48++sh89NFH5vrrrzfZ2dnm3XffNca03+ve09q1a02/fv3MiBEjzFVXXeW0t9frnz9/vjnooINMWVmZ86ioqHD2t9frDvrmm29MaWmpmTFjhvnPf/5jNm3aZJ577jnz6aefOse018+goqKiyfd91apVRpJ58cUXjTHt97qROjIqaBw9erSZPXt2k7YhQ4aYn//850nqUevbM2j0+/2mpKTE3HzzzU7b7t27TXFxsbnnnnuMMcZ89913Jjs72zz66KPOMdu2bTMej8c8++yzbdb31lBRUWEkmTVr1hhjMu/6O3fubP70pz9lzHXv2LHDDBo0yKxatcocd9xxTtDYnq9//vz55pBDDom4rz1fd9B1111njj766L3uz4TPIOiqq64yAwYMMH6/P6OuG8mTMben6+vrtW7dOk2cOLFJ+8SJE/Xaa68lqVeJt2nTJpWXlze57tzcXB133HHOda9bt04NDQ1NjunVq5eGDx+edp9NVVWVJKlLly6SMuf6fT6fHn30UdXU1GjMmDEZc92XXXaZpkyZohNOOKFJe3u//k8++US9evVS//799cMf/lCff/65pPZ/3ZL01FNPadSoUTrrrLPUvXt3HXbYYbr33nud/ZnwGUhyVkWbOXOmLMvKmOtGcmVM0FhZWSmfzxe2mHePHj3CFvFuT4LX1tx1l5eXKycnR507d97rMenAGKO5c+fq6KOP1vDhwyW1/+vfuHGjOnbsqNzcXM2ePVvLli3TsGHD2v11S9Kjjz6qt99+W4sWLQrb156v/4gjjtCDDz6oFStW6N5771V5ebnGjh2r7du3t+vrDvr888+1ePFiDRo0SCtWrNDs2bN15ZVXOsulZcJnIElPPvmkvvvuO82YMUNS5lw3kiupywgmg2VZTb42xoS1tUctue50+2wuv/xyvfPOO3rllVfC9rXX6x88eLA2bNig7777Tk888YQuuOACrVmzxtnfXq9769atuuqqq7Ry5Url5eXt9bj2eP2TJ092tg8++GCNGTNGAwYM0J///GcdeeSRktrndQf5/X6NGjVKv/nNbyRJhx12mN577z0tXrxY06dPd45rz5+BJC1dulSTJ09Wr169mrS39+tGcmVMprFbt27yer1hf01VVFSE/WXWngRnVTZ33SUlJaqvr9e3336712NS3RVXXKGnnnpKL774onr37u20t/frz8nJ0cCBAzVq1CgtWrRIhxxyiO644452f93r1q1TRUWFRo4cqaysLGVlZWnNmjX6wx/+oKysLKf/7fX63QoKCnTwwQfrk08+afffd0nq2bOnhg0b1qRt6NChzjq7mfAZbN68Wc8995wuuugipy0TrhvJlzFBY05OjkaOHKlVq1Y1aV+1apXGjh2bpF4lXv/+/VVSUtLkuuvr67VmzRrnukeOHKns7Owmx5SVlendd99N+c/GGKPLL79c//jHP/TCCy+of//+Tfa39+vfkzFGdXV17f66jz/+eG3cuFEbNmxwHqNGjdJ5552nDRs26IADDmjX1+9WV1enDz74QD179mz333dJOuqoo8LKan388ccqLS2VlBn/z99///3q3r27pkyZ4rRlwnUjBbT1zJtkCpbcWbp0qXn//ffNnDlzTEFBgfniiy+S3bV9smPHDrN+/Xqzfv16I8ncdtttZv369U4poZtvvtkUFxebf/zjH2bjxo3mnHPOiViGoXfv3ua5554zb7/9tpkwYUJalGH4yU9+YoqLi83q1aublKLYtWuXc0x7vf558+aZl156yWzatMm888475vrrrzcej8esXLnSGNN+r3tv3LOnjWm/13/NNdeY1atXm88//9y88cYb5uSTTzaFhYXOz7H2et1Ba9euNVlZWebXv/61+eSTT8xDDz1kOnToYP761786x7Tnz8Dn85m+ffua6667Lmxfe75upIaMChqNMeauu+4ypaWlJicnxxx++OFOaZZ09uKLLxpJYY8LLrjAGGOXoJg/f74pKSkxubm55thjjzUbN25sco7a2lpz+eWXmy5dupj8/Hxz8sknmy1btiThauIT6bolmfvvv985pr1e/8yZM51/y/vtt585/vjjnYDRmPZ73XuzZ9DYXq8/WHsvOzvb9OrVy5x++unmvffec/a31+t2+9e//mWGDx9ucnNzzZAhQ8ySJUua7G/Pn8GKFSuMJPPRRx+F7WvP143UYBljTFJSnAAAAEgbGTOmEQAAAC1H0AgAAICoCBoBAAAQFUEjAAAAoiJoBAAAQFQEjQAAAIiKoBEAAABRETQCAAAgKoJGACltxowZmjp1arPHjBs3TnPmzGmT/gBApiJoBJAwM2bMkGVZzqNr16468cQT9c477yS7awCAOBE0AkioE088UWVlZSorK9Pzzz+vrKwsnXzyycnuFgAgTgSNABIqNzdXJSUlKikp0aGHHqrrrrtOW7du1X//+19J0saNGzVhwgTl5+era9euuuSSS7Rz5869nq+mpkbTp09Xx44d1bNnT916661hx/Tr10+/+c1vNHPmTBUWFqpv375asmRJk2O2bdumadOmqXPnzuratatOO+00ffHFF87+1atXa/To0SooKFCnTp101FFHafPmzZKk//u//9P48eNVWFiooqIijRw5Um+99VYrfFoAkLoIGgG0mZ07d+qhhx7SwIED1bVrV+3atUsnnniiOnfurDfffFOPP/64nnvuOV1++eV7Pce1116rF198UcuWLdPKlSu1evVqrVu3Luy4W2+9VaNGjdL69et16aWX6ic/+Yk+/PBDSdKuXbs0fvx4dezYUS+99JJeeeUVdezYUSeeeKLq6+vV2NioqVOn6rjjjtM777yj119/XZdccoksy5IknXfeeerdu7fefPNNrVu3Tj//+c+VnZ2dmA8NAFKFAYAEueCCC4zX6zUFBQWmoKDASDI9e/Y069atM8YYs2TJEtO5c2ezc+dO5zVPP/208Xg8pry83DnHaaedZowxZseOHSYnJ8c8+uijzvHbt283+fn55qqrrnLaSktLzY9+9CPna7/fb7p3724WL15sjDFm6dKlZvDgwcbv9zvH1NXVmfz8fLNixQqzfft2I8msXr064nUVFhaaBx54YN8+HABIM2QaASTU+PHjtWHDBm3YsEH/+c9/NHHiRE2ePFmbN2/WBx98oEMOOUQFBQXO8UcddZT8fr8++uijsHN99tlnqq+v15gxY5y2Ll26aPDgwWHHjhgxwtm2LEslJSWqqKiQJK1bt06ffvqpCgsL1bFjR3Xs2FFdunTR7t279dlnn6lLly6aMWOGJk2apFNOOUV33HGHysrKnPPNnTtXF110kU444QTdfPPN+uyzz1rlswKAVEbQCCChCgoKNHDgQA0cOFCjR4/W0qVLVVNTo3vvvVfGGOeW754itRtjYn7fPW8XW5Ylv98vSfL7/Ro5cqQTzAYfH3/8sc4991xJ0v3336/XX39dY8eO1WOPPaYDDzxQb7zxhiRpwYIFeu+99zRlyhS98MILGjZsmJYtWxZz3wAgHRE0AmhTlmXJ4/GotrZWw4YN04YNG1RTU+Psf/XVV+XxeHTggQeGvXbgwIHKzs52gjdJ+vbbb/Xxxx/H1YfDDz9cn3zyibp37+4EtMFHcXGxc9xhhx2mefPm6bXXXtPw4cP18MMPO/sOPPBAXX311Vq5cqVOP/103X///XH1AQDSDUEjgISqq6tTeXm5ysvL9cEHH+iKK67Qzp07dcopp+i8885TXl6eLrjgAr377rt68cUXdcUVV+j8889Xjx49ws7VsWNHzZo1S9dee62ef/55vfvuu5oxY4Y8nvh+lJ133nnq1q2bTjvtNL388svatGmT1qxZo6uuukpffvmlNm3apHnz5un111/X5s2btXLlSn388ccaOnSoamtrdfnll2v16tXavHmzXn31Vb355psaOnRoa31kAJCSspLdAQDt27PPPquePXtKkgoLCzVkyBA9/vjjGjdunCRpxYoVuuqqq/S9731PHTp00BlnnKHbbrttr+f77W9/q507d+rUU09VYWGhrrnmGlVVVcXVpw4dOuill17Sddddp9NPP107duzQ/vvvr+OPP15FRUWqra3Vhx9+qD//+c/avn27evbsqcsvv1w//vGP1djYqO3bt2v69On6+uuv1a1bN51++ulauHBhiz8jAEgHlolnkBAAAAAyErenAQAAEBVBIwAAAKIiaAQAAEBUBI0AAACIiqARAAAAURE0AgAAICqCRgAAAERF0AgAAICoCBoBAAAQFUEjAAAAoiJoBAAAQFT/H8FRncSyO+FuAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from ribs.visualize import grid_archive_heatmap\n", "\n", "plt.figure(figsize=(8, 6))\n", "grid_archive_heatmap(archive, vmin=0.0, vmax=1.0)\n", "plt.title(\"LSI MNIST\")\n", "plt.xlabel(\"Boldness\")\n", "plt.ylabel(\"Lightness\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we display a grid of digits generated from a selected set of latent vectors in the archive." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As we can see below, digits get bolder as we go along the x-axis. Meanwhile, as we go along the y-axis, the digits get brighter. For instance, the image in the bottom right corner is grey and bold, while the image in the top left corner is white and thin." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_grid_img(10, 8, 7, 105, 6, 15, archive)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we display images from a wider range of the archive. Note that in order to generate images with high boldness values, CMA-ME generated images that do not look realistic (see the bottom right corner in particular)." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_grid_img(10, 8, 15, 90, 6, 15, archive)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To determine how realistic all of the images in the archive are, we can evaluate them with the discriminator network of the GAN. Below, we create a new archive where the objective value of each solution is the discriminator score. Measures remain the same." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(array([2, 2, 2, ..., 2, 2, 2], dtype=int32),\n", " array([2.76139498e-01, 3.46052289e-01, 1.13701016e-01, ...,\n", " 1.55930499e-12, 1.01614751e-10, 1.87576145e-01]))" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "discriminator_archive = GridArchive(\n", " solution_dim=generator.nz,\n", " dims=[200, 200], # 200 cells along each dimension.\n", " ranges=[(0, 784), (0.5, 1)], # Boldness range, lightness range.\n", ")\n", "\n", "imgs = generator(\n", " torch.tensor(archive.data(\"solution\"),\n", " dtype=torch.float32,\n", " device=device))\n", "discriminator_archive.add(\n", " archive.data(\"solution\"),\n", " discriminator(imgs).squeeze().cpu().detach().numpy(),\n", " archive.data(\"measures\"),\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, we can plot a heatmap of the archive with the discriminator score. The large regions of low score (in black) show that many images in the archive are not realistic, even though LeNet-5 had high confidence that these images showed the digit eight." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo0AAAIhCAYAAAArc4DYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAADkgElEQVR4nOydd3hUVRPG391N742EhBBCJ/TeO1KkSfEDRUFAVEBFiqioiCCKVAtVVEAUBERBBBQQVKr03lsgpJDee3a/P+bumQ0JJCAxxMzvefJkmdvOvXej975z5h2dyWQyQRAEQRAEQRDugb64ByAIgiAIgiA8+shDoyAIgiAIglAg8tAoCIIgCIIgFIg8NAqCIAiCIAgFIg+NgiAIgiAIQoHIQ6MgCIIgCIJQIPLQKAiCIAiCIBSIPDQKgiAIgiAIBSIPjYIgCIIgCEKByEOjIDwgK1asgE6nUz92dnYoW7YsOnTogBkzZiAyMjLPNu+//z50Ot2/PladTof333//kd/nnWzdurXIj3EnQ4cOzXVf7/wpSor7mgYGBmLo0KFFenxBEEouVsU9AEEo6Sxfvhw1atRAVlYWIiMjsXfvXsycORNz5szB2rVr8dhjj6l1R4wYgW7duv3rYzxw4AD8/f0f+X3eydatW7Fw4cJ//cHR3t4eu3bt+leP+W9xr2u6YcMGuLi4/PuDEgShRCAPjYLwD6lduzYaN26s/t2/f3+MGzcOrVu3Rr9+/XD58mX4+PgAAPz9/Yv8QcuMyWRCeno67O3t0bx584e+/6LY579FWloa7O3t77pcr9eX6PN7UBo0aFDcQxAE4RFG0tOCUAQEBARg7ty5SEpKwhdffKHi+aWnd+3ahfbt28PT0xP29vYICAhA//79kZqaqtbJyMjAtGnTEBQUBDs7O3h6eqJDhw7Yv3+/Wken0+GVV17BkiVLEBQUBFtbW3zzzTdqmaWyZE6t79q1Cy+88AI8PT3h4uKCIUOGICUlBRERERgwYADc3Nzg6+uL119/HVlZWbnGfbd9/vHHHxg1ahS8vLzg6emJfv36ISwsLNe2a9euRZcuXeDr6wt7e3sEBQXhrbfeQkpKilpn6NChWLhwoTqW+Sc4OBgAkJ6ejkmTJqFixYqwsbFBuXLl8PLLLyM+Pj7XsQIDA9GzZ0/89NNPaNCgAezs7DB16tQC7uC9iYqKgo2NDSZPnpxn2YULF6DT6fD555+rdUePHo2aNWvCyckJ3t7e6NixI/bs2VPgce42ncF8rc3XAng41zS/9PTNmzfx7LPPwtvbG7a2tggKCsLcuXNhNBrVOsHBwdDpdJgzZw7mzZuHihUrwsnJCS1atMDff/9d4HkKglAyEKVREIqI7t27w2AwYPfu3XddJzg4GD169ECbNm2wbNkyuLm5ITQ0FL/99hsyMzPh4OCA7OxsPP7449izZw/Gjh2Ljh07Ijs7G3///Tdu3ryJli1bqv1t3LgRe/bswXvvvYeyZcvC29v7nmMcMWIE+vXrhzVr1uD48eN4++23kZ2djYsXL6Jfv3548cUX8fvvv2PmzJnw8/PD+PHjCzzvESNGoEePHli9ejVCQkIwceJEPPvss7nSvZcvX0b37t0xduxYODo64sKFC5g5cyYOHTqk1ps8eTJSUlKwfv16HDhwQG3r6+sLk8mEPn36YOfOnZg0aRLatGmDU6dOYcqUKThw4AAOHDgAW1tbtc2xY8dw/vx5vPvuu6hYsSIcHR0LPI/s7Ow8Mb1eD71ejzJlyqBnz5745ptvMHXqVOj1/P69fPly2NjY4JlnngEAxMbGAgCmTJmCsmXLIjk5GRs2bED79u2xc+dOtG/fvsCxFIZ/ek3zIyoqCi1btkRmZiY++OADBAYGYvPmzXj99ddx9epVLFq0KNf6CxcuRI0aNfDpp5+q43Xv3h3Xr1+Hq6vrQzlPQRCKEZMgCA/E8uXLTQBMhw8fvus6Pj4+pqCgIPXvKVOmmCz/7NavX28CYDpx4sRd97Fy5UoTANOXX355z/EAMLm6uppiY2PzXTZlypQ8Y3/11VdzrdenTx8TANO8efNyxevXr29q2LBhofY5evToXOvNmjXLBMAUHh6e77iNRqMpKyvL9Ndff5kAmE6ePKmWvfzyy6b8/jP122+/mQCYZs2alSu+du1aEwDT0qVLVaxChQomg8FgunjxYr7Hv5PnnnvOBCDfn06dOqn1Nm3aZAJg2r59u4plZ2eb/Pz8TP3797/r/rOzs01ZWVmmTp06mfr27Ztr2Z3X9M7vixnztb5+/Xq+x3iQa2oy0bV67rnn1L/feustEwDTwYMHc603atQok06nU9f0+vXrJgCmOnXqmLKzs9V6hw4dMgEwff/99/keTxCEkoWkpwWhCDGZTPdcXr9+fdjY2ODFF1/EN998g2vXruVZ59dff4WdnR2GDx9e4PE6duwId3f3Qo+vZ8+euf4dFBQEAOjRo0ee+I0bNwq1z969e+f6d926dQEg1/bXrl3DoEGDULZsWRgMBlhbW6Ndu3YAgPPnzxd4DLNydmcq9X//+x8cHR2xc+fOPGOoVq1aocYPUCHM4cOH8/xYKmuPP/44ypYti+XLl6vYtm3bEBYWludeLVmyBA0bNoSdnR2srKxgbW2NnTt3FupcC8s/vab5sWvXLtSsWRNNmzbNFR86dChMJlOeYqEePXrAYDCof+d37wVBKLlIeloQioiUlBTExMSgTp06d12ncuXK+P333zFr1iy8/PLLSElJQaVKlTBmzBi89tprAChF6OfnlysFejfulma8Gx4eHrn+bWNjc9d4enp6ofbp6emZ69/mNHFaWhoAIDk5GW3atIGdnR2mT5+OatWqwcHBASEhIejXr59a717ExMTAysoKZcqUyRXX6XQoW7YsYmJicsXv97ro9fpcxU35YWVlhcGDB2P+/PmIj4+Hm5sbVqxYAV9fX3Tt2lWtN2/ePEyYMAEjR47EBx98AC8vLxgMBkyePPmhPTQ+jGuaHzExMQgMDMwT9/PzU8stKejeC4JQspGHRkEoIrZs2YKcnJwC56y1adMGbdq0QU5ODo4cOYL58+dj7Nix8PHxwVNPPYUyZcpg7969MBqNBT44FocH5P2ya9cuhIWF4c8//1RKGIA8BSz3wtPTE9nZ2YiKisr14GgymRAREYEmTZrkWr+orsuwYcMwe/ZsrFmzBgMHDsSmTZswduzYXGrbd999h/bt22Px4sW5tk1KSipw/3Z2dgCoEMpyjmZ0dHSu9R7GNc0PT09PhIeH54mbC5u8vLz+0f4FQShZSHpaEIqAmzdv4vXXX4erqyteeumlQm1jMBjQrFkzVd167NgxAJQGTU9Px4oVK4pquP8q5gc4y4cgALmqzM3cTanq1KkTAHogs+THH39ESkqKWl7UBAUFoVmzZli+fDlWr16NjIwMDBs2LNc6Op0uz7meOnUqVyHK3TCrfKdOncoV/+WXX/IcA/hn1zQ/OnXqhHPnzqnvopmVK1dCp9OhQ4cOBe5DEIT/DqI0CsI/5MyZM8jOzkZ2djYiIyOxZ88eLF++HAaDARs2bMiTQrVkyZIl2LVrF3r06IGAgACkp6dj2bJlAKBMwZ9++mksX74cI0eOxMWLF9GhQwcYjUYcPHgQQUFBeOqpp/6V83xYtGzZEu7u7hg5ciSmTJkCa2trrFq1CidPnsyzrjm1P3PmTDz++OMwGAyoW7cuOnfujK5du+LNN99EYmIiWrVqpaqnGzRogMGDB/+jMRqNxrtaxTRo0CDXw9nw4cPx0ksvISwsDC1btkT16tVzrd+zZ0988MEHmDJlCtq1a4eLFy9i2rRpqFixYr4V2pZ0794dHh4eeP755zFt2jRYWVlhxYoVCAkJybXew7im5qkJlowbNw4rV65Ejx49MG3aNFSoUAFbtmzBokWLMGrUqPuaJyoIQslHlEZB+IcMGzYMLVq0QKdOnTBq1CgcP34cb775Ji5cuFCgElO/fn1kZ2djypQpePzxxzF48GBERUVh06ZN6NKlCwCaO7d161ZMmjQJGzZswBNPPIEhQ4Zg7969qFChwr9xig8VT09PbNmyBQ4ODnj22WcxfPhwODk5Ye3atXnWHTRoEEaMGIFFixahRYsWaNKkCcLCwqDT6bBx40aMHz8ey5cvR/fu3TFnzhwMHjwYu3btyqO43S9paWlo0aJFvj93PrA99dRTsLe3x61bt/KojADwzjvvYMKECfj666/Ro0cPfPXVV1iyZAlat25d4DhcXFzw22+/wdnZGc8++yxGjhyJ2rVr45133sm13sO4pvlRpkwZ7N+/Hx07dsSkSZPQs2dPbNu2DbNmzcL8+fMLHL8gCP8tdKaCyjsFQRAEQRCEUo8ojYIgCIIgCEKByEOjIAiCIAiCUCDy0CgIgiAIgiAUSLE+NO7evRu9evWCn5+fmtheEH/99RcaNWoEOzs7VKpUCUuWLCn6gQqCIAiCIDwiFNfzU7E+NKakpKBevXpYsGBBoda/fv06unfvjjZt2uD48eN4++23MWbMGPz4449FPFJBEARBEIRHg+J6fnpkqqd1Oh02bNiAPn363HWdN998E5s2bcrVemvkyJE4efJkoYxyBUEQBEEQ/kv8m89PJcrc+8CBA8q7zkzXrl3x9ddfIysrC9bW1nm2ycjIQEZGhvq30WhEbGwsPD09S0TLNUEQBEEQqE1oUlIS/Pz8CmypWhSkp6cjMzOzyPZvMpnyPJfY2tr+Y99Z4MGen/KjRD00RkREwMfHJ1fMx8cH2dnZiI6Ohq+vb55tZsyYgalTp/5bQxQEQRAEoQgJCQmBv7//v3rM9PR0VKxYDhERsUV2DCcnJyQnJ+eKTZkyBe+///4/3veDPD/lR4l6aASQ5yncnF2/m2o4adIkjB8/Xv07ISEBAQEBCAkJgYuLS9ENVBAEQRCEh0ZiYiLKly8PZ2fnf/3YmZmZiIiIRfCNdXBxcXjo+09MTEVghQF5nk0ehspo5n6fn/KjRD00li1bFhEREblikZGRsLKygqenZ77b3E3adXFxkYdGQXiIvFlpGgBg5rX3inkkgiD8lynOqWUuTnZwcbJ/+Ds2Gmn/RfRs8iDPT/lRoh4aW7RogV9++SVXbPv27WjcuHGh8/GCIAiCIAgPhNGoHvAe+n6LkIf1/FSsD43Jycm4cuWK+vf169dx4sQJeHh4ICAgAJMmTUJoaChWrlwJgCp9FixYgPHjx+OFF17AgQMH8PXXX+P7778vrlMQiogW7q8CAE6lb1WxlLSrudaZWu0D9XlZNFV/3Yjl9T+rRcrXt2FhKnYkjnypplefpmLvXZ4BADAa0+45pkmVaZsrCdkq9kM0xap6Pqlil2PW33M/d9LdfZL63MaH3mCtLeZ4v36OlLuk54cAAOpu4Dk1T7k3BQD8GndTxWxNdgCAzp48f2X6lckAgO8aTFGxZ4/TXN86HkNV7HTsikKNub3bBADADf1FFatuqgMA8HJpomLOVjSG5JwoFYtKOFioY/yb6HT0H02TKeuuy+62/H7X+yfca5z/NpbneyePwvgE4b9McT0/FetD45EjR9ChQwf1b/Pcw+eeew4rVqxAeHg4bt7k/xlWrFgRW7duxbhx47Bw4UL4+fnh888/R//+/f/1sQuCIAiCUMp4RJTG4np+KtaHxvbt2+NeNpErVqzIE2vXrh2OHTtWhKMSBEEQBEF4dCmu56cSNadR+Pcxp4n9De4q9lmbcADA8nPlVexoNKWjToONQ2uaagAAqrvZqNjv8bcAAJ5G3t+BzJ8AADf7tlIxg4mWd3UYpGJPeVNq1c5Ak6B3ZfytloUm7AUAzKnJaeeBVUIBACO7p6qYcf5LAICTMZy6fcz1NQCAk0NVFfOwq0zjyOdPZEm1uupzY/eRAICKqKJi9T1G0P6MXOEXbaAJyBdiOBWwq+VbAIC1T4aq2ISttB9/R57oPcyX0shr4v4CAPR1GaqWGbQJ4eeTt6hYM4enAQCzby5SsYtedH+OGU+r2PM25QAALvZsXWFrQ7YLbg6VVWxf83o0zut8zTwMVD34XWs/Fauzk8aQlM5vt53cHwcAbEz+UsXMaU29RXpTb3AEkHuKgNGYkWs9Yz4pz4LSoPmlc++VVr3XssIsv9/1HpSC9m8+36Iex90oruPmR2GnFDyM/QmlAJOJfopivyWAYm0jKAiCIAiCIJQMRGn8D7C8/vvq87AT9Dl93GAVy4ijd4PhmwNU7LKR1K1o0zUVa2PVFgAwpka6iq1uQUUfs07zV8WnPalbkxZWU7GQl/4EANTYcVjFng0ghWpJ5A4Vs9OTlUBZHZf4V7JrAwDot4XVx2u6owCA2/BSMf/MigCAU8adAID6+sfUsqrOpP6FsqgIo4nGqbNi1U7nSKrntjQuVunl9D8AQDUdzw8JzjoEAAi0bqpiMSCVdM6FHD5vnAEAXDfygTOzUwAAtlZsmxCXRApsNc8BKvZO+ZoAgPRTfF8+eYImNn+9m1VPB238zeyo2Oa7D7ioxPE1Uvcys6JVbE/CfNzJ+hgq9rG28lCxrGwqqHFyaqBit8bRPW3yJSswNX5fAwDIyUlUsbKuLQAA7uUqqJiTNSmR8SmsNv+cuBwAkJ2TlGdMJhMXFGVnx+dZbiY/hdHMo6L8PWqUtvO9Fw/7WuS3P1EfSxFGUxHNaRSlURAEQRAEQfiPoDPdayblf5DExES4uroiISGhxJp7v1aB5u0Nr0xK0apgVo8auZN68/U17o+5bRn9DvsmRsUO3CoLANh5m9+anwoghezrq2xc+kbtOADAiqusDA4KjAcAXExwUrHVwaS+/fTKLRVrOZ/mqZ1J4/l2LnY0DzL8w9oqVn8yjdVsFQMAbqa8jv8Hs8hj6im3gQCAxCx+26vnYaBzjUhQsTZebtp6/BXflUTK6skP+FimoU8AAIIClquYp5FUM52J36uq2ZMS+mQAqwoXk8g4/uWul1Vs0gZSCXcmBqvYiQ9pPcPor1RMp6N9Z338jIp9/HUgAODdS2wnVFJwtA8EAKSkBT/U/ZqvkyUmU9F6mgnCw0JUyIdHcf7/23zs2FtF1xHGw3/AI/9sIulpQRAEQRCEwvCIWO4UF5KeFgRBEARBEApElMZHkJUWXTvmB1PRw+E4tk+Z3oVSoesPky3KrjjueDLjXD8AwICz51QseRH5Mu2/Fahioy9vAwCsrtlRxZo1p/1MP8s2KrU+rQ4AGD7ugoq9foTSzn3KG1TMTWth8ttvbMOTo4sEADjYcGp7YRUqNhk+nbf1NFJavKkHp6SPxVLstp6LPgw6+rr+lLQZAFBD31ota2ftBgBY0JiLK76+Qmnp4wnxKnbyJJ3vocGnVGzzJ0cAALvbc0rAuxu99emqllWxx/pQ6rtFJR7TnoNUnJMSwX9KFxPINiZbl6FiIVupAEcHLsoxp1it3vxWxXS6kvsn+bDT0mYkFS2UZP6NTkHCv4gojYIgCIIgCIJwb0qurPEfJKQ3GU8PXtNYxS71oFtk+vFNFTt9gdSvIYOp6OS5J9uqZdf6/AwAqLSYrWKyM1jdMlPGQCbSTxxfo2Kv3B4GALitD1axmOmkFlZtw8UkW94jJfKVQVxs425LxzDoeL2hfmQaHeTMSuPXV+k95XQ295GOxQ06x1juWexmoGKcKiinYufSyQT8Oe9xAABfB37n2XyL1D07CxPyeYvprf7HyY584rZUANP0WzbobuJECqd+R7yKLfmQVMeXXmHj7S3Pk22MtQ8rB/UuUgHQtotsm7OwBV2zszGBKrbsAh3XhHvXnVna0Pxb5FI/CxifIAgPzqPUO1x4QExFpDSWkIyKKI2CIAiCIAhCgYjSWMyY29ABwOHvygAA3u8ZoWLLYsjI2vhGJxWb8uQlAIC+ZiAAYNfTbKbcpDqpYRHj96rY+ss09zEqnRWl57xpruLnt/lYx7V5hNs78bvE2RBSCW9cZIuaJ67R8RZ8XVHFHh9I8/cyjbxeV19SIl++xKpi+Rwas7uFaXcZeAMA3gnidoOzL5Di5mFtq2IJL/YCANgtaEfn/90GtWzRbLIdeu4Vnm+IGPp69/+upgpt6EVt9J7Y107FUl5aCQAw2LLK9tJoMuvOvpGiYs98Q2N3seY/m9rudE2HNWCT9LE7ab2RVXnbgYF0X16uP0TFfNavxKOAqIuCIAiFQ2cyQlcEqmBR7LMoEKVREARBEARBKBBRGgVBEARBEApDKa+elofGf4HzXV4FAARtz9sTeJi/L/8jgSxdXm9/Q4VejKLuIr5fcYp1QXtKJz55KQQAEJzCxSIdR9QCADjbc5o4/H/mLimchuxVnnoVH4lupWITalJKdtJ+ts2ZVJfSvReT2AE/O4ME6phlPM5PmlB3mKrtOd19dBultp/2qKNiDgYawx+301QsGtR15sWLF1XMC1RYUkHrZwwAdh9S72X9z7/R2bTgYpbRa7WJ5Sls23PjfbImsvmR+2H3nUAFLgsb7lOxl193AwBEbuZ08s9fUsr8YAxbA/UPyNFinObv6kdddtxf4F7R2EljafECFwpdXU3b/nqZr62Z/DqewKJRk6SPBUEQHhGMpqLpEy29pwVBEARBEIT/CqI0FhGmXdw7uMYIKuZYWGeqio3aSEqauzVL0hdWkELl4sAqYZmaVGCi++NvFavoQPs7Gkoq3NA/G/B+65wAAIyryT2gpw4kpfHN1VVU7PvrVHQTlR2vYrPOkprY3Z/feOadpfWqu7K6duu2KwBgfxTb24z8mMa+6l3ug73oOu27vx/v7+cwioXqr6vYke6k/u2+VF/FPrlESuTSTa4qht10DWZNonFO3MLvPKkLSDkMv8YG3YHttWv3+rMqZtRSAC2WbFWxhXPMlkBsDWSvKaKfzohXsXnT3QAAz1Xi2NFouga1ojhW3ZXUzvemcbFPkAsV9tR2S8Q90RTGe6mL/4ZFjqX6KebagvBwsTT8vhOx43nEKeXpaVEaBUEQBEEQhALRmUymkpFIf0gkJibC1dUVCQkJcHFxKXiD++RKt5cBANtCvVXMPI/vu+BUFbPV0Vy5MdVZNZp5gd4wP23Ib5ofnaYxfn+6torpLl0BAIwfQurV282C1TLXyhTLiOLb6tSJxrJ5nr2KxWaSyJxtcfcPa3P1YtJzVOyykVoLhhu5jWBVkAl3TUc3FavgRNu2LZOsYj6OdL5eXhw7cZ2Mycs58fzBbkdIdXzMns29Z7Shc0pKZNXVvzmpj6t/CgQADPmcLXpMNclCSHfxiorl7KE5kuH7+a3e/1ltzqM3q6Rd+pD6N646C++NA2huZpmXKqgYokmxtbyOPVeQgXml1ptV7PJ4UhhDD/LYvcrT+S79i+c+Tjj/oTb4vH+CMo9REARRHXNT1P//Lsyx4859CRdnh4I3uN/9J6XCveYLxXJu94MojYIgCIIgCEKByJzGh8wvITTPsIIDvyFuDCFVcU3XaBV77Q+qoj0Uy9W5L1QiRazuW6w+vvg+zcszrfxNxYyaPOjvQObaHs15H1MWUmxzLFc219pElc2RGekqdkV/AgBQG/VUzN+R5krqLboONrKjcd5M5fl+9dypLd/MMSEqtmsdqWtH4pxUrGoWnU+PI1xRPa8yfeUqNk1QsR4XqOVheYuXt8n76DwWTWWzbqNWydwxIBwAkLScK7Cd29ExjL06qJjBho7v34fHhGOaYurN5zOiMl3jdIvqtQ1aW8AXY3kOoqkZVWt367ZLxbLX09zRs4NYufx9M7VZ/DmUlcZ+0TTWSxZTGu1tSaWMHNZSxdy/3A4AyMqOhSAIpRtpO/gIYjIVTcu/EpL0FaVREARBEARBKBBRGgVBEARBEApDKa+elofGh0Dmu9xP+LVXKHUbvi1bxco70KTW6X8HqlgrH5KiP761R8Uu96IikVljuFjijQ+1L1Kt5ioW9haZVW8NowKTRus51fpnNKU1/+zN6YzOv1CKN1IfrGLB88h+55k3+CuwO4XMsF/zZ2ued26QNU0rq84qNnsxFcok/5ChYuaUdjOPJBWrqhlff2PDPapbvEMp5qivuThl/sfxAICXJrK9zhdrKFWeuTlexXTaQfyHkQ1Ql2Fuapndz3QeG3uBiaEU+JLhPCYfO7o/vXqxhdGAT6oBAI5MjlGxvm/T+DJ231Yx2xp0HlaBFpOUnSkFnXCOpx7U9aXr/dEFNhqfU49in15gc2+9jsbsvGSdijnZU5/w7Ow4Xs9AefucHC4eEgSh9GBp0SOp6mJGzL0FQRAEQRAE4d6I0vgPyP5oGAAg5CgXWuzcRIUwXSuEq1gVrWWfR7ibilV0IJVuuFdbFZu7md40nq99U8XWz6CiCm/bqypWvyq1p2vgTsfdxnUmqO9CqlStX06p2NNu7QAADd3LqNjer6gww6DjqpeD1KUPvx1jlbSLXTcAQIeyvF7yjzQWh3kDONb5IADA05aLbX69RKpaWg6/m1x8i86xSyDHDi6hz0v2syJ5fOgJAMCM0xz7tDVd0+SjpLg19ODz+XgTFeI8V+ukii14nKx8ziawclrFSbMkusW2Qp+NpNiIxqwWnllAhS3xGdzmsXV7Knrp8zorohsXkK3QLxfYmudqMqmpK1uFqZjn8j9pzPb9VCwljcZnZeVuEQsGALg5cdvI+JTzANhw21xAAwCp6fxdEQRBEIqYUp6eFqVREARBEARBKBBRGu+TtFcHq892rcg0O3obq3DDB5HVzRerWHk6qbmnmMBvEuPbkF2N4SyrRl1epLl3PSawgrZlIc1bXDmL59FdOFYJABCZRvsLcGLLnZQsivVxaqdiExvRmAb+7qZi5WxJpXyxCtvWPL2ebGZOmHi+X0+nNgCA5mV4vt/wDaT+fevCc/G+uEzn4WjgeXzr5sXTeadkqph53sagqX4qNKk2zT385PFgFdsaRl/NIRaKpN8zNH7jE10BAB+v3sS7rdEaALDiIKu+unOkJg6+xj43n1+gOY0LLvL9GVSRlEY7T74/tZ+lY330Kh//wFu51wcAuJKy29Y3UoWGvk/zEjN/YlPznO2kwB5NXa9iZgNvvZ5NynOMdLz45HN51jOTnhEOQRAEoRgwFZHSWELatYrSKAiCIAiCIBSIKI2CIAiCIAiFQGc0QlcESmNR7LMokIfG+0THmUQcWEhCbaOWXIny60+U9vw70qL3sw2t182X07RvbKfijOGVuDNK+vF4AMDafhyDF6WirfW8v0H9ggEAt7+jZQejOMX880RKXV7+k9O0+25QKnhBY07TvnqECjjqBHLHlXEmsvz57EIzFQvTUstrg71U7OmKFDt6iItE3q1NKdvj8dwFJe0Q5eX3HGGbme+u0wX8/kdeb/aLlF4fWpu72AB0HWu48pizjlEKeMy4fQCAHn6csq+8aiMAoHp3vha6BoEAgKbz2JJoxZYTAIDl67nA5kQ8TS9oE8xjujmdUsvtvVmMb/mhGwDg0nS+Zsk/0b06dDtQxcY+TucdYeJU/Uu+rwIADidxGvtIwjI6ryxO/ZtT0fn1ntaBxvlJzbdU7LWzH+RZLz/M20pPa0EoeYjNjvCoIA+NgiAIgiAIhcFkKpqWfyWkjaA8NN4nOosr1mIUFVpc+5YVpa5dyAKl52PVVeyt4bTesThbFavlatRirJY5XSQFb+EFLoSx09ocB7mwdL1jSzkAwEBNJXSz4fX7z6Flvg5sBhucQkUYZWzY2qW+Gylojn6skt4+TypgJz8+yVoupNx1/IqP0bzVGQDA/nfZXmfADFIdTSYuEon4jUyzp81NVTGvT0g5HPKkCuEbTbnbvYKP4WdH++l1Yp+KhW96GwBg//1xAEC3btz72qpfYwBAztZjKmY8HgwA0Nnx+RiGdwEA/O/SNhV7fRcptt5NeOxln64DAEiYzH2mgz+mQqWqX7ZQMZM3WSz1n7ZKxaJ+IRV59CBWPW3e/ZDGYmHSW86N7JZCE/aqGEw52nqscOr19nQ+OXQdC6suWiIKoyCUPERhfAQRyx1BEARBEARBuDeiNBaS4B6jAAAVXqvMQbOCV5ZNoeMvkpJkPH9dxeq70ZzCm6l8uVOyaY7ZuH5XVMzgQ3PqbluYa79bl5S5ugtq8HGPkNlz1C+kPJlCedHUemR8/c11VhVtdTRncGwQzw90s6exD1nBc/teq0HK2BfX+I3nojMZWX/U8pqK7Z9CxuRRFgLZN9o8S7NtDwBMe5/m6p36jNerUYNic8vwvE2dH6mUB2N4wmgvzRB9nqmLiv3Uidon2ujzfm2N1UnV1B+5qGLpJ+gYehb3YO1K5+M2vqGKLQ44CgDIuMlq3PJedD4vf8Em225ZdF9W9bEwWvekbf18+P1rZxgpxt/P5nmlZrL3TlGfDa3eBQA42gWqWFomtS00GrlFo0mzYshPLTQYyEKooBaDek3hNIpyIQiC8OCI0igIgiAIgiAI90aURkEQBEEQhMJgNKkmFQ99vyUAeWgsJL/fooKH52+xPUrcTiqMcO/KqeDrKyjtbGfFvY07Vab8cUoKp18zs+nSWw9prWLbhgYD4B7LAOA3klLbxi2HVWzDWor1e57SoP0zb6llfXfTfmN0R1Xs+TKNAACrg/n4R+MpdftzH7a5ee8PSr334mYt6OJL9jErrnqoWNZNGl90AseSU6jIZ9MazgXHfRMPAMgx8XrnzlMXnRXXuH9z+C5Kma4eelnFRq2mYhJna+62E5NB1/TT9sEAgF9+5VT4+wvWAgBOrmZ7H/taZNtjKl9OxfZ02w0AaDuezzHxGqXvPWa0V7GXO1Gxz4An+D6ueZPu49WUQBUbtIWKYrIXbFWxpmXoOn8Rxeej11Oq+qOhXBxjZ0MX2s2Wz6OqHXXyiTBdUrHweC4GuhNzcUxBSFpaEEoeloVzd2JZJGNeTwpnhKJGHhoFQRAEQRAKQymf0ygPjYVkSC8qBEk/zhKy+wSyeUn/5oiK1X2NejD/+hFPF/1Ns9CZPZCVJ+uRHQEAZ186oWKt62qm0DfZhufHd+mLFJHOalRUBu27TxwVs/xwhYtZKllRscbyevyG+vpRUreOGtk+5mnXHgCAmXvcVOzTGXEAgNhf4lRs7C5S6z5ozOrntE1UdPK4b5KKOVqTWvf+y9wHu7UXFbjsuG2vYtWd6Xwi07jYp4IzjXX4t5VU7KsBVCDUYRUrkrsGkjr613G6Fn0nsmq3Y0IgAODVF1UIL9cg+yMXB1btQtM0GdWVx7nqNF2/MUfO8MYZ9MY+tQEXpOjcqFCplgubtL/ThvYd6MgFUu9dmQUAcLBlhfOdimMBAJMvsV2OnbY808TncSJ+hXYwVlgt7XcALowBis5Kx/KYphLSE1UQShP3UiEFoaiQh0ZBEARBEITCYDQVkdIocxpLPDtaTFKf23cl5Scy2EHF/PecBQD8sJsVspYXySqmjB23pJvaluYcWr3VT8WSX98AAKhQMe8XZf55H/V5Ri9SJ20sDLeNSTTPzhBEqtmrT7Mdzs2vaCyrr3PbvxGVSRlLvdJKxcbVJuUwoCvP2Wv6Mh3jjco8L9CoKVkTD7LxdmoOKWM3kllB/OY1UvVWLXVTsePxtPx/5dlep/EbFDv4Ir8lX0yg/S1ty/NFE8NpjuT6NjxHZ9cxUj33a9Y8j2eyzUxKFv0Rf/N5sorNe5/GHODAqubT35MSbCxbVsUqO/1NsTAepzGGFMag99lyx+RPymn/smzr0+9mGADg3XmsKrZwfgEAkK5jBfFmMo3P1pZbL6ZnkrF6ZjYru2YsVQRPJzIaj048mme9okLURUEoeVj+d8M8vzG/mPAPKOUdYcRyRxAEQRAEQSgQURoFQRAEQRAKgxTCCHfjsVFsZ7LuM0qNPtGWO728PJtsYV6ryR1hrK0p3VvOnruvHLtGaWT3J/eomL8XpQxiEizS3Voa95N3b6vYjDlVaZk9f6EuJ1MRR+ZakrNvJVdQy96sTcU0A0/yPio7UR/sv9Zwj+y6g2i9+APcTmZOJbKPefPaSRU79SQV5SRGcbrdyY1St3+c5eKcXzZQeraaC0vszzSnYpaT5zkle/nzeADA81V4f8uv0rguRnmqmJsNHWN9iJuKnYmjWGMvrUjEYg5IRWe6Jutn8fUcN46uwe4VfN7IofuT8c46FXp8AKXCM69x0UvcTRqf72Ocvs9ZvhMAYBjWScUWTaLvw4cb2FbIUI+KXSyLVC7a07QBe2u2Z+po/wwAYGv8bN7W4KINk78/0Ukn8uzvfmnk9jwA4Gj81w+8D0EQSg5iwyMUBfLQKAiCIAiCUBhMRWTuXULmNMpD4z3IOB6rPjf2prc120ashs1JISXNsbmbivV5nQpQZjXmoop23anoxFCFt4UjFWJ4BbNKmXaevjQJf3Exx6RXqIhjzXIu3DgfT4Ut67+lf696m6emWhtIkVxYPVDFNoXSctNlVhVf9SebmUW3+CuwJ4o+u4CLXlb/TUUxXrZcTJJ0nVS9LIvveGgaxV5/jO1tvt9HNjRVnbggZMstMvceXIcV2/DTdto4ubDmSiKpiZ80jVSxNddp25RsOnDT1/gN+kkfiu2MYCudJ5tREYtxeYiKPdOe7sXNTC4U2rObFGPjor9VzKsGqY5h83ictxPo/pU5xmbbL79BY3+/P9+D851fAgB8c9VbxT4LWwEACLBurGJftosCAJTbqELwdaae2KEJu1XMZOJrDwBWVm4Wy+gaWJp856dIisIoCKULURiFokAeGgVBEARBEAqDzGkU7oalqnjrEM17M33HKmDFrqQyHfrGVsUWtiFlzK+7xaXt/hgAIPvLHSpkGE3m2lPGsX3LuGZXAQDug3mOIiLjAQBt/CNUqEVZTdWKoeOm5vA8uRMx9PnpV1glHfs6qWsT57I1UAXqaofvGjqq2DZyj0FZe56r+GUIHTcCbExunvuoM7IBtZ2e1K1Ve6uomLUWq1We1cK2L9D8wmMreMx9AuhaediwafazgaT0uTilq1h1Z1LcNt+i8z80n9siLp1Fx3rcj9+ud48iG6C90XyOX/aj89DzLUOf9rR84xK2Osq5QvY/wTE8zpajzIof7y/7Eq3XuxwrnEMO01ji9KdVLD2TVMWLJv4O1NlJ3y9bG1aRU3Nof1YGNxVr4/gcAODPpCU0tmxWsYvK3FsQBEEQ7kQeGgVBEARBEAqDKI3C3YjcyG3y2o6i38l/cVWrvg5VNte5yiqcThOcfv6K1cI+HlSN/PNWVvDq/E2V1G91iVexrGRS0D4Yw6rVOy+RgbX/9AYq9v1QUu6s1pEKeDGRK3eDXEn9++MrVsNO7Q4CAIzoEqVis16g+Y1Vpoap2Fv+tB9Xa1avDv1B28bPYSPtcTtpnO1YmENzT1oe5MdzNJ/ZQfMGHQxsFj59O6l/gWAz7OZlaH9DP+T9DXiOxu9tz20E+5WnuZEns6gqeuw7gWpZRx9SKT++zCrcJ3VITgxL5fP531oy9+5ejqu3f09bCQCoMLKqin0bVA8AMPMcz1XcUp2q4JcNj1exPjXJmNui6x9sTaSAppv4uxI3pA+NcyNXd8foyPTdRu+kYlHJp3AnfyR8muvfBiu+JmYTbstqa0EQSicyj/FfwFhEhTAlpCOMmHsLgiAIgiAIBSJKoyAIgiAIQmEwGemnKPZbApCHxnwwfTcWAODkzYUZpiQqzHCsy+nFzB1aX+iynE6GFYm3feZxyhFayrRtRS5O8ahHptFfr+PCkfZlKbXbtgzbp4TsIoPWCu4XVKyB5hYz7xSleAcGcGpy520yh3YwcKXH2bFUbBPkxoU9x36igpR+Lk1VzEZPX9qUbM61fjSQ0q8N3PxV7A3NQPx0rJuKudnS9Rm3m9fLBp3HsTj+ms2oSmNu4MvFMR320PU5NbSGik1vSMfdGmph/xNMKeUEUFq+mSenvc8lUkp4/w+8fu8BNKZRVfk+OlhRCqDd55zind2ZzM+zTWzu/XcMpcd/i5+uYlZN6DxuDxjI572E+on7eA5WsQCXdgCAyJSzKub+DVnouDvVUrG21t0AAGcMXAwVaTwCALC25nuVqdnpmItesrPjcSc68D2T4hhB+O9jmYo2G3lb9pnObz1B+KfIQ6MgCIIgCEJhKOVzGuWhMR9M6WStkpHACuK6L6jqY+h3bNhsc+g8fXBiVS/7jFZsEs9FNNk3SQks83pdFcvaSMUx3QO5EGXPLbJeybCwsvn2Ohled7vN7ezsDfR5bB3a1smJFbKPz5Ia17McWwNVrkXKYMNUNs/eGu4GALiQwMbbNV1JretkUczydyQpXgYdf6EXXdQKXCy+PeZiju/Wsg3O8al0DRIzWTm11tTMtHRe7/0KVGzjbMXn+HMIKYbrIvj6eIHsb6qYagMA5l9n5fbH9mTNE76Qx/R1JzrWlQguFBp45gQA4NwStrmx0ZF63M6GVddvIkn9s7Plgh2jZrLtvW61imV3om31Ov4OBMdvBwAYDKw229jQ+cRaFLps0psLqPh79lPj8QCAASfYjFunp2tlMtJ91ul4KrJO29YoaoIglCpEVRSKA3loFARBEARBKAxiuSPcic6f1LXYGFbXhi6mOW45mw6rmH5wJwDAlv4837BzG7rxkV/znL0yNWk/K15i9XHoeFLNvI2sljXNJIWv8niel5c4jlTHJ8fyvMVnxtN8vIEmUvzCgvmNM91IitvpOJ6zt/FX7Xwy+HwCHPNK4TkmOtZHJ3k+3coVpP5tfI/VrfBUeptd9wa3JdT70VzKCx+x5c3qYDqPx31ZzWzTm8yrb/7BSuPHwdTmb1Q5tim6kkjjm1aNx3I5mdS8BO1l+s2+4WrZG2vILqefP1sDDT5Pau7X1Vkdjkqle1X7R75m9UGt+26m8/0J1JE90tlFrFIaRiwFANjZ+KmY46ubAQA5Rj5HT2dSlKvrWqrYycytAACjFe8vK4uuheUcxD6HZwIAnB3Y/iczi74Xvm6tAACD3DqqZXODP4AgCIIg/BvIQ6MgCIIgCEJhkDmNgiAIgiAIQoEYTUWUnpaHxhKLKYTSgfZ2bNWSvpoKGL78g9OGo7J/BwD0nMRFFVmHKcX7ezAXUDxd8xoAYMjgWyq2+wtKu1YvywUUlV/V+hwHcPozOEXrOe3ORRWrFlAK9vLXlIr+5ir3Ry7vQIUwh2O5mMZsM/PJG1xUsuZrKuxxtuY07f4oWm9R76sq9sFrdL6N3bnYJiabUrErVnGHm2EjqUuLycT7e6cV7WfAZr4+R+MoBT2sbrCK/dycrkHgVGcVa9D1HAAgLZgtfOKzaAyVnGl9K2++dgFaA5xR5/ka3/ilAwBg41hOOy+s8TwAYPYttrnxc6BU+bUU3jYRFHv6LV8Vc3Uga550i97PZmwtLHJytIKVI5nrVewJl2EAgPWxn6qYTk/3ykrPBUpZ2TRdITXjNq+n2emEx+8DAMzVft8P5uIZUwnxAhMEQRAePeShURAEQRAEoTBIelq4E1M8KXjO7mxfEBlMUlYrr3gVs3qyOX0I46IX6771AQD/SzyuYgYfUpL03ZqoWJvepPzoQiNULLAfKUizKnLRybzPaAxX53MhzM1EUuS2hlOBx4K2IWrZ7ONkeN3Rwpi8oR+pVoOnsYJp0r6ffcvzF7VLUDAAwKk7q6STfEkt3PM7K27lben4rtZskTNmBi1PzmIlq3c8FeO082H1MciZxpWQwOpa5bdoXPOHsU3QsnpUWDPiJKujB8fSthd3035Pb2ZlMls77LLaPM6sLWSufSmJDdSbeJD9T6aJbYAOpFA/7PIm3nZH8lcAgJNGVljtNNscX4f6KpZipGKWdAvD7YxsUjb/as4m4ANOk2l34ktPqJjzElIis3P4GGaMOUl5YmbF0c2pporFJZ/Ns15+iMIoCP8txF5HKA7koVEQBEEQBKFQFFEbQZSMF3t5aMwHYxopaA7V+fKcv0ZzCmtW47lm4e+QGpSWzkramRiyVOn5tJ2K6dtQ67gNz97Mc6y+72arz8E7ugAAYuecVLGkjTSWK/E8t8/XgVSyaT3I8qbdKlbcNne6AQCYfZTta9rXISXrsw58/Bd30P6uJPPYm8WRUfW6KawCbg+jeYs5JlYkX65G+yvrwDYzn18hdXRMFUcV87On5ddS+BgXk2mu4JUUHxXzGU8KYkUHVi5nnqHr7WVia57hC+mautjQsQL4UIjXXrovJvLcz2+/JbXy15SjKpac3RgA0MWhoYoNqUgK52OH16iYDnQMJ3uetznA9X8AgJ+SflaxlIwo3ElnxyEAgK+v8NgNoGvgvXw/j2X0k3SMhWvz7MNs6A2womBWC/X5mPoKgiAIQlEjD42CIAiCIAiFoZTPadQXvIogCIIgCIJQ2hGlMR+sqlCKOesM92Bu+hEVQUx+jjutfPCulpr091KxihWoiCTne7ZvyfqWiiD6zqulYpmbqIAh/Xc+rl0XeobXG3huQ1QEpVu7LuSuJsuGxwMAeq6ifdTXcQp17QWyoWlThgthJm6rDABY/CWnwl8LoeXTz/J6vf1p2xcnc0FK9jQ6/q1UtvD54Dwd38vAafEKttQDOTSN30OOxlEadV9MvIoNLE/X7zFfvrbTtQ401d04JbusP/Vl3nY0UMUmXKXr6JVJ53ssmXs2b+xEKfua27kAKewlut4rF3LHntTsRgCA72K/U7Fzyb0AAInvtlOxhvPoPKrouCjox8QNAICElEsqZtL6UVumkw8Z/6L1om+oWLZW2NLD5RUVC/x2JwCgnBsf91b8nwAAo0UBjpWVm3Ys+l7EJJ1Qy8RKRxBKF1IAU8yI0igIgiAIgiAI90aUxvxwpwqLTdu50qJ/bSqAebMdK2SbFpHi1XsFq4C6M6SQLV9fUcVa+5AtSyWwPYq1r1bMoGMFL307Faq4NOIimlubScHa/jLb+gx7hcylh4STChZ7im17vJ8hRbTjMC4q2fE6qZ6jXuAxNfAw33q2nul05CAAwP+lOipmayL7oWct1NQ6mW4AgMg0Vi4n1KQxfX+DjcarOZP6Fa+tDwBDmtP1uXCJr1ltd3p3eaoq2+ss3k2m4q/2uKxiIalNAQC9K1DP6VVXuUf3mL9oLJ9V5oIhr4VU2JJjZDX1p8RDAAA7Kx6TUev9nHyJ3/SupP4BADgxv7uK2Y2m41qqio2dhwMAjiVzMUtUIvUnt7flsQzzHg8A+CZquYplZJFSbakqmrEsdsnRzMQ9nOsByK00isIoCILwL2I0FlFHmJLx33J5aBQEQRAEQSgMpTw9rTOZTCVjpA+JxMREuLq6IiEhAS4uLvmuc7HLqwCAwHrxKmYkwQ0/7q3E6yXRM/eTATEq9ksozYds6Mbq0bUUUqYSslhVfK4GqX8/XWU1atQAajeYcoVviYM/fbYqz6qnrizNCxw7lixy9LxbfPw/UuYGLmPLnY6+dPwki6kwbja033mhJ1TsvQBSspbc4PN5yo/UvHpurEieTyRLHi9bVjMPx9K1eKIcz4esXZnUWSs7foM6eIrU0VXBbOtTxYVOwMIXHDVdaLC2er4WP9ykY1xJjwMAVLR1U8uWDaVrt3s3X09na9pHr5N7VCwhNRgAYLLwxOrkNAIA4KDnd6itySsAAEmTOqpYs89pzme4kedIJmaQ7ZGdNc91jUs6ox2Dx67X07bTq76hYm9f/AAAm3bTP+hzb/eJKvRz7ExYotPxOM1zKgVB+O9iOY9Rp2UhSuPcxsL8/7uojx3/3Vi4ONgWvMH97j81A27Pflos53Y/iNIoCIIgCIJQGEq50iiFMIIgCIIgCEKBiNKoYVw4Un2uNojSudnB/Ext5UexXknBKtbPiVKcOw9xKvjtsVqxRAvuD5zxLRVf2A6or2LBU8ku5pVXuYjFlE7HMNhyp5Xvt5Jdjo8dF3N07Eip7acrUDHJJ+cd1LKXvqP10y2KK6x19AYTncFp0F9vxwMAvq5VXcUmnqNimwMTOBU9bD7Z4bT04lTI1WQ6np2Br8+pOBrzjNfiVeyVOTSWMUHcNeV4PG07oRYXFH1yjo6xLe2AinVPbQEAsLfiMSdk0jUor6WCT2Wxpc2+PeW0MXHK/PsbJPFPLt9Dxc7E0bX4NmaZillrtjV/ZW1RsbcrvAAAmPm9CuFkwhwAgJdzXRXzsKPpCqHxf6mYOS39buX3VGzh7R8BACdiOJ2cr12ONlvEMiVtTl/rDXTtcnJSIAhC6aQ0pqUfKUp5IYwojYIgCIIgCEKBiNKooXNkGxVU9gMAZP4dp0IOzSnmUo5VngPzSQHqOcbCDPsKqXRWIawgxl4jC52cD9kUukI/msw87gO2nmnoTm8aNVx5f4P6BQMAftvMBR7WDahvc81wKjR5xVhWLVtymQpMDBbFFYc0Ua+zL6tw9gYq2DmTwG83NzRT6h83dFYxO03p63nyoIptb0j9m38L81Cx7uXouP+bxj2lq7vR74BK8SqmD6XCmvh0nkhs0Ibax6mlil1IouuYBL7eTZxp2/OJFHvBn4uSftHcer6KXKVibW37AwBWxe3AnViqezna50aGLiq2K5Jsbq7qTqnYxkZjaJxHP+f9aBVSOj3bJP3PYywA4K9o/v4kpgUDAH5I/ljF9Jo5en7KgdHIarN536IwCoIgFDMmk8oIPfT9lgBEaRQEQRAEQRAKRJRGjU2LuMS9axsy4XYY04pXuBoCADCGJqhQi5c0GxyLqierJuUBAOm/8Xw7Z80X+9YNNxUzRlBbuRoubFBdVpu3uDmU7Vvc9tLcxB7D2Abn93m0n6bVSaL7NZzb+TlYkWpWxYUtbbZH01zFr55ipercUjL6ru3Kilb9UGpn98dtbs93NiUWAOClZ2NwOytSLN+YydvOfouON4hXw6ZbNJa+a7kV36JmpI5+c4XV0XUJNN/vcGtWGjfeoOUzbu1UsbiUKgCA8iBT9YE1+BrX3kE2N90cBqrY1hRSHY0WtjTZOaRgfl6D2/lNuLwCAGBtxbZGTtakmIYn7FUxa30TAICVRftE857NiiMA/BCtqYk6vo467bOlDU8bJzIG/yvxc4v12NTbzJ1KpKXxt1HmNwmCIPx7lPLqaXloFARBEARBKAyl/KFR0tOCIAiCIAhCgRS70rho0SLMnj0b4eHhqFWrFj799FO0adPmrusvXLgQCxYsQHBwMAICAvDOO+9gyJAh/3gcnZtyqtO2PaU/j7/MhSuVK1B6+Pw1Tic37k6pW707F0GYWjej37/y/pxGUeHI+ZfYZqZGJUoxDqx7XcXcWtJ+uAwFSDxIKeCtK7gQpl1tSpWP/ZUsbaq58BtKTz8qonnnNO+juRuNufwMDppMV+iYNo+p2NYJ1FXl63WcY07Npl7S7raeKjb0MFnojHiPi1mCnCm1HpfFKdmvRtD+vt/MBSs/BpNtjGWRyBNOfQEAzx9IVDE7HZ23t1U1FatoJGujUVpafvZRtjoqb6DjvluX9/Hjn2RNpNdzqj7AhVLwH9z6Q8Wc7bQe3ikXVSwtg86xv8ebKvbCRbIEsrFyUrHsHJpmkCsVrRUh5erWoqWULbu//JnwKe7EZMrbh9rJnu5HcuoVbV8Wf7aSnhaE/xRiqfOIYyoiyx3T/e/zfp+fVq1ahVmzZuHy5ctwdXVFt27dMGfOHHh6et51mzspVqVx7dq1GDt2LN555x0cP34cbdq0weOPP46bN2/mu/7ixYsxadIkvP/++zh79iymTp2Kl19+Gb/88su/PHJBEARBEITi4X6fn/bu3YshQ4bg+eefx9mzZ/HDDz/g8OHDGDFixH0dt1h7Tzdr1gwNGzbE4sWLVSwoKAh9+vTBjBkz8qzfsmVLtGrVCrNnz1axsWPH4siRI9i7d2+e9fPjbr0rTUc/5ZUiNVVxHhe9BI0mhezk56wE1X2KPv/4pZeKPfkBXc7d09mM+1wibXshkVWmJ8uTIlg78LaKuT1DCmfqL8E8Lk2ssq/Oqt6mNVQkkpZD6lavRtfUsg92VgUA9PNnxW3DLTrPg7F8PpUdKHYgndXUjU1IVSzrx9tW3UD7ftKZ7Wgi02hQ69ZxQcZLg+kt6WQqG3l38aRikoGBrLCuCaZr9WX0NhXrZNMJAHAzk4/roKPzHRDAKu7ZBHrHcbGm62jZ87vV39sBAGVs2ay8nq42AMDdlpW5zalkvxOfygrv24Fk7D7tau4ezwBgbeWuPmdm0XkYDKw0Wmuf3exZ9QyP36etx9+vnBw+NzPcQ5rfMM1WQJb9pfV6s6l33n0IglCyMSuLpbmndGF5JHpPL3kJLvZF0Hs6LQNuI78o9Lnd7/PTnDlzsHjxYly9elXF5s+fj1mzZiEkJKTQ4yw2pTEzMxNHjx5Fly5dcsW7dOmC/fv357tNRkYG7OzscsXs7e1x6NAhZGXl/4eWkZGBxMTEXD+CIAiCIAiPGnc+r2Rk5J2y9CDPTy1btsStW7ewdetWmEwm3L59G+vXr0ePHj3yXf9uFNucxujoaOTk5MDHxydX3MfHBxEREflu07VrV3z11Vfo06cPGjZsiKNHj2LZsmXIyspCdHQ0fH1982wzY8YMTJ06teABRfEcOziR9Up4Cs9Jq9EwCABQvTYbRcfsojdDy6KnrD00l/FgbBUVmzg5nj5ks7n2hvn0JuE2itsN/vgaqY/9V7LVz6FRNI+tSSNu7dfnbRrXlo/pwJ/8VVUt0zy28eEZfhN6OpCO+1U0z+OLTKfzydbxw3ZUKilaK3bzPakMUtq6+LJy+qb2ptKzP899LO9Ix5tWnd+Quowk1XGzhZ1RpnaxjncIUrG0dFpv3hm24bHTpgh62vBxb6dSsFNFOv/njvM1sbcmo/E5lWup2AdXScW9mM7WQHEplwEAjZwGqNjHN78CAHR2eVXFfk9aCgCIf6W9ijl9RtMgjBYtGjO0z5HZ/DJSxeMJAEB0Bqu4iak0Bst5jubPer2tRSwjz3r3UhhtrMkcPjMr8q7rCILw6HKnwmhpuyWq4yOIEUVUPU2/ypcvnys8ZcoUvP/++7liD/L81LJlS6xatQoDBw5Eeno6srOz0bt3b8yfP/++hlns1dM6nS7Xv00mU56YmcmTJ+Pxxx9H8+bNYW1tjSeeeAJDhw4FABgMhny3mTRpEhISEtTP/ciwgiAIgiAI/xYhISG5nlkmTZp013Xv5/np3LlzGDNmDN577z0cPXoUv/32G65fv46RI0fe1/iKTWn08vKCwWDI81QcGRmZ5+nZjL29PZYtW4YvvvgCt2/fhq+vL5YuXQpnZ2d4eXnlu42trS1sbQuef2A8xQ+Tf/9C+9ocxnPXGk8hk2nHGvwW6KG9EAx4np+9s/+mz+28WR06sNig7Y/nx/UvT8pm8opgFQtOJcUwdcE+FSvnRtLhiTU8lsWXKLb0E6rc9ZjPatyCi6QWbjoQqGKpn+wGAJR34Erp1Tdofy28WP00z7l8zIdNwJ+rTK8/007yQ3kNUNV2wzLcejFN2832CJ4+8N2btHxmy1AVq+hC43vsL1YJJ5Sn836jfpiKJabSfqLSeH9m4XfWRVLtenjxG9nMGz8DAF65wvc6IvEwjdf1CdzJwfgv1GcnB1KFdyZ/pWI6Hd1H/y8vqJiNNr+xoV0fFQvRU8V1aCKnBBoZSO1cl7JJxfp6UhX2TzHcRtBcSW2pXHq7UvV9ZAK3bTTPb8xVja0hCqMg/LcQdfERp4h9Gl1cXAqc0/ggz08zZsxAq1atMHHiRABA3bp14ejoiDZt2mD69On5Zmrzo9iURhsbGzRq1Ag7duTuC7xjxw60bNnyLlsR1tbW8Pf3h8FgwJo1a9CzZ0/o9cUumgqCIAiC8B/GZDQV2U9heZDnp9TU1DzPSeYM7f3UQxerT+P48eMxePBgNG7cGC1atMDSpUtx8+ZNJZdOmjQJoaGhWLlyJQDg0qVLOHToEJo1a4a4uDjMmzcPZ86cwTfffFOcpyEIgiAIgvCvcb/PT7169cILL7yAxYsXo2vXrggPD8fYsWPRtGlT+Pn5Ffq4xfrQOHDgQMTExGDatGkIDw9H7dq1sXXrVlSoQPYl4eHhuTyHcnJyMHfuXFy8eBHW1tbo0KED9u/fj8DAwH88Fn1D3kfjGCqWKHOCe0A7N9EqTCzeBsxvBlfnsc2MTkfp15spDirWoznZu5h7NgNAZg498S/aw0Uso9vQcfUW0zOzs+kfDcZwKvix6bSfmJ/IcqacG6dkO/pSEU/Wij0qlhpHKfXj8Zzi3pZyFABwK6W2in3ZgQpHfEawTP3kYDcAwEcNY1Vs2CEau7M1G4I6a1n7F9tdVjG7uc8CAKKe/UHF3j1OfZuH+vC2f0ZQCvyN64dUrJ01VXSlGjkla62j6x2vj6dx2vH9KevcgGImNhKPAKWnx5evrGLjr5LRuYMjW/PkaOmghtaPq9hzgTTO50+xDY+5f/QFG7Z3ik04CQDoY2ECvi56FoDcfaY3xNB+DAbub22e8F7RpYOKXY7doC3jP01zWtrOlv6wMzLCeRmKzTFLEIQHRFLQJRiTiX6KYr/3wf0+Pw0dOhRJSUlYsGABJkyYADc3N3Ts2BEzZ+a1mrsXxd4RZvTo0Rg9enS+y1asWJHr30FBQTh+/Pi/MCpBEARBEIRHl/t5fgKAV199Fa+++mrele+DYn9ofGTwZuXL4ErKYFIGq3tbV5KqZW7hBwBObdwAAPZ2bOniN4jWOzaLd50WQ5f5SAwrY+lGKoLoVZ6Nrw+dpVaBTYO4cOSri6QuTX2soYo9eeUnAEDwLlI/F5xnqxp3bcj9v+AiEV97CuZYvMmc7EtjeW4jz3HopjnybDXy5NqJNWm98YedVay6Zmza2D1ZxfZHk4q55xgfN6D3Fhr7CZa+W/vQtZjwIRfCbPmYFLxjl9kux8eBVLgefmx8vSOCjtvQhqx+mnnGq2Vx1+ieudrxtVjfcAwA4LWrf6uYgxVZ86Rn87Y5mpIXZctFJSNOf6l94uP7uFCRSmYOFwqZFcFNCWxbYKWZehstWgI+5z0OALA8/EMVq+LRBwCriwCg19RHWxuezJyWQe0QMzLpvoi6KAglG7HVKcEUcSHMo45UjwiCIAiCIAgFUqxtBIuDu7YRvLCUV7pJ1i/HPmLbHG8XUpeiknhOWog2b/HxTjxv4Ng+Mlt2tOa5eBUr09zDtQd5bt3wN2nfk99jG56qTjRXsa0ftxYM6ERvoWF/8UTH+BRSGE/Gkgp4OZkF4zNxZL+TadFQ/ZOm8QAAnY5v9fEoUlZTc/i94UhMXq9Ld9u8LfsmHCMbHHcrVmLblqVtrySxR1Q/f1IiW7/Dcy4bPUPnlgW2CRrhS/MQN4Rym8OdU+j6zLJQTMvY0jmtuEHrfdcqXS37OZjmYc4J47mcbrpyAIDr6WxhZGflBgCooW+tYmezyU4pIYXtdfp7vgUAOGo8qWJWWmvDBvoaKrY9bSMAIDGNWzk2dBkCADiWuFLFTEY+XxXTFEOz9Q79w1zNxt+fe1nuCIJQchBV8Z/xKLQRjJs7HC72NgVvcL/7T8uE+4RlxXJu94MojYIgCIIgCEKByJxGQRAEQRCEwlDK5zTKQ6OG0cINXX+dil1q1mErnVW7KbX8bMerKrZnO9nl/LozQMWqulJa9fvrZVTMK4KKL54IZKuU2R/Q8co7cBq5d+3recY1aSEd18uiqc3TValQxjGRik8cLFooVnGhCdYfz+ZijbBvKTW65hKnepOzKSUamcZf1PlTqBAk4ySniSf+TOc4/igP4MkASo9PD2Hrmezw5gCAxR24q4uTDx3392n+KlZXs435O/Oiiu2+TSkbo0WBR7NpdE6Tq3Ja93QCpQRcdJQe73CA7X36u9L1bKJvrmKv16T0df/TfG8zjZQy35+wUMWSRg0EAFT4js9xUyIVwgz3GaVi30QtBwBczuDCFXPnGB34HqTo6PpZdnoxF7jkKmLR0s35xSyRtLQgCMIjQil/aJT0tCAIgiAIglAgojRqZE1bpz5b+9vlWd4tkBS0a2e4cOXlZ0gZ1DvzpFhTOqlCb16OU7GwG1Sw4l2RLWqg1U081/mKCkVcIOUwNJHtbcbWI9UzJpELcE7ept7Ytnp6MwlmURE1tPmzLUewpU02SOUaGcCq5gmtruVoFqt18X/Qen9dqqBiu5ODAQDjAllNTdU8yt11rFxma29JS0/xtu+sIEXyp5/ZkujzbnS+209XUTF3G7pmb59nVbG9GymSCy/zeZgnkX/fjRTRYdvrqWXLon/S1uFzrHTrSQBAyBtcgGQ7+UcAgLNjNRVz+YKUw6E+E1Xsdyvq/fzFrekqZu5RnatwRXvvslQDL8Svz7OeCTl5xpcf9rakypptdgpCHcOiSX1BxxAE4d/DsvjFbLUjBTElF5Pp/lr+3c9+SwKiNAqCIAiCIAgFIpY7GsE9eO5ahbdILTMe4fmLEX/R7zK1eZ5a+Emy3Nlxkw2le1cjZfDr06y4HYsmFcrJmue9LfuQTL3XLWTl8ucQUoscrflZfkabYACAazVWj6weoxZ4Z6eRfY2zPY9pxnGav/dMIMuPDWvTXEr7WtzasPt7NM+yopO9it1IJkXQ34GVVm97GktkGh//TAq1FOzq7aVidV1pDEnZfI5Lr9P8znB9sIrtaUfbPPUHq6kOmpWNwUKZO5hDjdg72HBrv9vZpNS+WJG2HdCD54AO+5IMv5+qwK0a+x5bDADQW7TkyzHSOVoZ+Ph6PS3PzGJ12M2RVMX4FFaCjdq2er29xbY09mwLs3CzRU45V7b1uRX/JwRBKH2IqvjweBQsd2I/GgIXuyKw3EnPhMfbK8VyRxAEQRAEQSj5yJxGQRAEQRCEwlDKq6floVEjoC+nVU1+1Pc35PcbKubhTele65qcki0/rA4AoOGI0yrmNacdAOCtE+dVbO9sSpl62nMHk+8XUHpYZ2G38tUAqo6JDeH056HrVBDSbQYXbuDIGQBAjfZk7RJ3mgVjeytK8Taqz/Y+Z09Tl5o1v3Hv6+crU8q8bSCf44eHKKV+JJG7v/R3pc4xx2J47Dk6Op/YDB57++qUlm/6K6fFu7rUBQD8z5lT8JMP0jZeBi4ceaI8XXuDRceauOstAQB+jvwVTUiklEBoGq0fuJA78exvSYVCe8O8Vayc1iv6SGeePlB96zFaZl1fxc7GrQYA6PSclk9KI1sjk0X/6CoeTwAAbiRy1xlrKypeskxPm/tV55eS1uny/snpdPzds7Tpudu2YsEjCIIgFAfy0CgIgiAIglAYRGkUAEDXsrb6fGkUqVHVhnPhyLVvSMFzdmYV8I/BlwAA7XpyAcXhIacAAJkWPZ1zTPT5QjwrfYdjSV2a0Zctb2x7kZro8ycXX3TrRWpit4asXM5rRNY0Zb1oTPOOBKpl7tr83Mmbq6pYhlbDUt+di1liM+n4C07wtlVc6Es7pRX33PboTNvkzGaz8s3hpIb58aXAoSvU53laBf5Kjbm6BQAw17ObirnY0HGvprKVzoRruwEAz3n0UjF7UIHJr8lnVGyUH92jV58mRXboCbbS+ew4KbJLIn9UMVsDTSYevoPNvTvb9QYA/BS/mAevKX1mOwwASH6zK41jxk8q1tqGlOVZ9bn39IATX2jb8v02W95YW3moWFZ2rLaMVUKz4fe91EVLHkWF0d+tvfosxT6CwEgBzH8Uk4l+imK/JQAphBEEQRAEQRAKRJRGM0k8F8+vPKl7piS2Zak0nObMZezieXStW9HviUtZ1QvS1LqnGrFdz5qjpIiFpvEz+itBNOfQ0iwcZ6htYWB1VgS/2mBW+NggO0OztZl3uBIA4FYy28zMaUNzC8f8VU7FJtVOAgAciWWl88XxNG9x0VxPFUvRWgs6+bOiNfkjmiNosPCzftLfDQCw7zav99nt/QCAV3068tirdwYAuFnzfMggF9rmRhKruLMDewAAKjqy+vhT4jkAwP9cm6rYiOakwJb5+ASA3OpezHZS/7Z35zaCXqBr+2sitwx0daBrdr7TABWbdoKu8aqoOSr24Vq6pyYTX9uNSaRifneC54vm5JANkGUbQZM2pzE7mxXoRm7PAwCOxS9TMaOmRBgMbNyek2Ph1F4CEHVREITShMlIP0Wx35KAKI2CIAiCIAhCgYjSKAiCIAiCUBhKeSFMqe8IY9o3kxboLUTXWEpP314WoUJxSVT1sSucLXcqO1IBQ9fpbNXy1xRKsVbxilWxclrv42Pv3FYxWytKezracL/lCj3oVkT9wROovZ+nAo8Vkzj9GZxCn3v6xQMAItK4ImXJZdK4x9bg27riGlXH9LfoPf1rGL0vfNA8RMW+O0/9pc1pagCo40rjq+bKxTEfnKQ0t62Br5m/I43ptkXnGE872s87bTlVv+VUIAAgOpPPx9+ezve3MH6HOZdC5/ZiRXbG/+gmFR5lmuga/1CXC2GeOk3TBs69zKnecp/R+s97cVeZpVEbAQB2Bp4WEJdGhTVWBr6OqRl0r8o41VKxyMQjAABra07pZ2TSdyR3P2pCp7foGqDlHowyOV4QSgVSCPPweRQ6wsRMHlRkHWE8P1j9yHeEEaVREARBEAShMJRypbHUPzQaD2n2NqP+x8H5awEAzmVYBXTyJFXxxZasuC36gZSui6/xpteSqcBjtCMXNKx8mYpYbme4qVgjd4p1HMUqJVKoYMSjNhe9LHuLFLmWPmy47ZNAbyG302nbi8n81lPekb54B2JY+frqKbL1uXSaFbJ53UgJ3XCsIh9eUxivJHDxR2o22cK4WnPhirstjcnPgY9xOpbeqlv78FfqqSAyDt9+hvtwm/8uDkbxMSpWoOBLVRNU7Lx2jj/dZOWyh3MQAGBlHFn51G7Cb2PX9mwHAHjNC1CxrGy6B7OCucDFyZ6WV9bXU7FwR1IdIzMu8DiNVOBiVhcBwMulIQAgOumEipl7T1sWzChrHCN/f9jWx3IasT73+oXEUtU0oWT8h0YQSgOiLgr/dUr9Q6MgCIIgCEJhKO3V06X+oVHnTEqR7uw5DnYkE2fT5aMq5PgsqVyIYaVxVCaplOO/q6Jin44OBgDM+yZQxbqUJeuVWh3YgmX9RlK8so4Hq9hr39B+Zj7G6zkY6JtU41lWqCoep/l7entSnII38dy+Pv6kiLaqw3MVX/mB9utoxQqVfTAZT/crz+cTn0XKnaM1r9fdl9S6WuUjVexqMp1bpoWcPrVBPADg8/OsZjbdRdY0L5ZhpTEth/Ydl8n2OhOvBgMAtjTleYaXQ+mzEWx87WJD24a+Wh0AsHQjn7eZxx36q8/HcsgQ3dXI81DdTGSjlAK2AboauwkAYGPjo2JWBjcAQI6RFePIhIMAcrcCNBjyayNI5FIBNTUxtwn4g5l1i7ooCI8mlg0CRHX8j2IqovR0CSkvEcsdQRAEQRAEoUBKvdKYcpDm0TkMZIPu9e1JUWoXaKtijo7anL6brLh9+QspXT39WLXSvfQEAOClC9x+zrk1qVsnVnFbuV23aY5bvyx+u5jcmNTBKX+wclnFmZYbo1jxirlOcxnt7Empevltngs4dpIbHdOaW+fZawrji9V4XmS0VnFt+XKTo31ePJ/nVC56j8575e5AFXu1ejwAwKDnjRddJDXPnS8Z9jcmg/E3DvB8v0l1aNufYqNVrL09GXMfs5jnaK7C/vKxMBV7apumGK6je1XOnteHZqj9ayq3EaxgQ8bgN4zHVexsBlU7Z1oYb+sNdH9MFvkBs5rYwOVZFTMbc1sqhDnZfO0LQ24l4u7tA21tyqrPd1Zoi9IoCI8WoiqWIoww/+/m4e+3BCBKoyAIgiAIglAgpV5pFARBEARBKAwmowmmIpjTWBT7LApK/UOjQ21K0+pWb1GxTlUpPWvvwWnIyBmnAQDBUVysMWo0pQ1/XsbFH/pzZNsSGsp9njNXUSp6dbCbir1YhdKaq7dZGFS3IRPsqW5XVMz5SSqY2f8xp7bTc2h/N1MpF1zpJqeTm3hQyvbvGCcVMxfnrFrDdjRPdydD6/kbORU+9gVKj5+azwbZAF2fQYEW/aMbU2r51dW87U9JvwAALveuqWJfH6Nzs9az7r7kEl2rdQ35CIkZZG/z0tkoFTs1j4py6o7nbY+8RIU11v507dLOcjHNLyFjAQA2FibtTtZ0nb54nu/j4C+oH3ZIFqeVr5gOAQCSM9jMvYwDFT5lgm1znvF+GwCwKvIj3C/m1LLRePeUtCXmlLQlkpYWBEEQipNS/9AoCIIgCIJQKEr5nMZS/9B4YgMpcg1n+6uYp6aCmU5eU7E9X5Hy1arWLRVLP0vKj689K3NzXyCjbXuDhfWMB9navFIzXMUqjKNClYbHb/D+rtPvzDRusYcosyUOm4BvjyD1r6YLfcvazmBVM+GriwCAF7ayzU2rraRSdqrARSUmrQCnvhurlDH7aX9zz7mp2FHNVujkG1zAkXCSvjafPMGKaI8jXQEAVrY3VayJOxXvNHBj9c/bno5nsFAfw9Lo3No6VlKxCuP3AwB2NWUlduefNK65F2nS+Ya+PPZETcFr5OqsYpsSzwAAKi7kAqCIxI3aJz6+ox0psE62XHxyK2EvAOAxnwkqtix8OoDctjk60L2ynAhvXm5ZWFNUKqEUxwhC8SDFL0JppNQ/NAqCIAiCIBQKk/ZTFPstAZT6h8aGM0jxM1VkZU4XcZt+69nk2myWnZ3GKtOh82QpE+TD9jGjatO2xgze1q48fZ5mYQLeaQqpcHGZbI3TwJsUsXPRPH/x4myat2it42/UsxWpBWDV+rR+9u88pgUHSZlbt4hNuzOP0piO7mcl7eI+UkINFvsNjyGVrk95CyubENrfN99zKDiF1LVnK7H90KZbpETuj+ZzPBAbT2O3+Jr52JAq2tKbx+xmTYpcaCrPH+xq3wIA8Fc4j69nVboHv88kRdK5+wa1bG+zngCARZd4/RHetQEAi28fUjFHO1KU0zJ5/uTGer0BAJ3//lzFDJoNz5gabM2zTBOKLRVEc2vBhDRWWDOz6LoU1O7P3IKwsPMc80MURkH4dxGFsXRT2gthxHJHEARBEARBKJBSrzQKgiAIgiAUCimEKd2Y09I5n29SMat+jelD4xoqdmo5Fay0HMspx445WppC56ZiE9+gtKa9gdeb0JIKRvqXj1WxQzG0TUQ6r7fgMm37WeNkFTuXRCnMsRO5mGPN57Rt2D7q1tLSos90kjakQwv5HIOTKwIAarpxynrjdTrWjFd529u76ffhGD6fCTXjAQChKVzs81sofbufPsJp1R4eJFr/GHtBxf7uS2nsD//ilHWK5n6zI4xT0eODaNB62KhYTTe6LptCOBU09jIVp7jtpFTwRP8halmLA18BAN4KGKFiv4bT+SabOBWdkk7b2lqXUbEOY+gY02LeUrFZoesAAA3+XKxi5lR0TNIpFYtKPEJj19vjTgpKHT9oWjp3/2q6FwWlwgVBeDiYuzpJmloojZT6h0ZBEARBEITCYDLST1HstyRQ6h8a321FFjUfzuIikay1hwEApw94qVjzJ0n9O/Ap29tsDqPPE5qyNU+gI1n4uFlzMcniQ1RMMrg62/V0dSK7mIBnWMHrsICUuR9u8HErO5E0F7aR7WXqeJCqdCmBbIAcarIdT/YO+u1myyqWv5GUqc8vsDF5fQ9So160sBoaXY0Mr0/Hs5JVz43GdD2VVcDXayUBAH4JLa9irzYIBgDs2cHX8d2ddH0uJLEJ9xXdeQDAhHLs7v3ChUsAAGsTN672S6L+0t3KsdVP3TTqA700ehsA4FAUX5On3IcDAF5pxPfiox+3AwAqO7VXsd4+3QEAO9IPqJj/qBMAgIjEwypm7gvt6lBdxfTmvtEmvrdtXF8FAJw37VMxs0l4LoNurcl3YVVAc+9r2jQ71zLLQhwXRxpfYsrFQu1XEIT7R1RFQSBK/UOjIAiCIAhCoZA5jaWbDz+MBwAYg7mtnHV3aoXXsDebbH88jFSt1GyeO/bhd6Twpa9hJaicPb2R9pnAKljCVrLk2XWe2/jtjCDV6tMmrIy1GkhK26WvHFRs8Ew63rVPWHGr9RqpmfaLaJ6jKYXfguu5kwoWncZz7Oae09oNuvDYI9Lo89ggnit5RJvLOCiQ5z4uu0Zq4WfPspH3/t1+AIAhlW+rmFcXuhbNjrIS+/FaGueovqyudXVpBAB49/p6FTvYqi0A4MWDrDR+Pon8bVYv9Vaxs3F0nb+v2RoA0KIJz8es/S0pwbdus3WSmQO9+Wu++ij9XvgYz2l8dR3NufxaM/QGAB+XZgCA2wl/q5hes+GBjq/j3kSaPGpvy4qtnwOpqMFZO1TMaLq/+Yt3qot3QxRGQXi4iKooCHen1D80CoIgCIIgFAaZ0ygIgiAIgiAUjAlFk0ouIaYXOpPJVEKG+nBITEyEq6srEhIS4OLigoj+ZNHiM4TTlbCitHTmn9wXWmelpSQ5MwnrBj4AgFcncL/jl6qSrc7mUO7qcimBLvFbdbhzzJ7b1JGlilO6igW6UYp85WXuElPWjrat4MDpzRZBVFDjGKQ98xu4cCUnmqxsvt7MPZtH9KcU+PpNnLoNTqVtO/pwKnryKYpNqc1/EVeTKc0d5MI2QH7utI21Na93MZzOx2jiC/TTLSryuZLI53hOR3Y1e9vyOQ75kwt0zLTzptT20Wi25gkz0bU9kfwDAKC360i1zFG7Z/syT+bZV0jSfvXZqKV9WzsNVbEjmWS3lJZxG/fCaEzLEzMXrJR366BiEck0hnJOjVXsetxWWl+scQThkUbS048ud/7/uziOHfHiALjY2BS8wf3uPzMTZZeuK5Zzux9EaRQEQRAEQSgEJpMyw3jo+y0JlPqHxtNhpDB6R7LidmEdqVY+Xnx5PIZQoYMplHsR3/qWthlXK0XF3j9GhRsfNQtVsY+PU4/qpZdYzWzrTQpamz5sPD3jK1ICYyxqJgIdSc37JYxtdbpMp8KNkx/SWHQW/aOj00kZfLY5F67s3k5jj83iwp5nq9H43vybLXICHUixdLfj4pjVZ2ibyk5c4OLrQJ8HBHLv6e0RpLYmZPJY2vvQG/v0x9hq6NkN9QEAn5zkN7Xy9nSOtd1ZMd0VTqreEeOfKhafSorpxIAxAIB2ZVj5M/ecHl6mgYptiqTxcbkM0NyJDMEj9WyHk6oZfr8e+I6Kzb0xB0BuI20ne+p5nZJ2XcXMBSuhiaxm5uTQ9+FGPBfCmBXJwha4CIJQPJjNuwFRHQXhTkr9Q6MgCIIgCEJhkEKYUk7HvjSPLfsGK0AeLqSCmdVFALj6WSzuJDKF5h0kZvGb6fNVaP7ehmvlVOxsEs1V3Nib5zQarEkZ+/BLbrFXxpZibw5kG56d22k/83/gOQ45O04DAGq2oG/Ztt/ZyqfndLqlGdt4nE1rkdK3bWdVFcvUVMeXqvJ8w4h0srzxcGEz7jmNaA5exSqsFu45Qabe1xN4TNPeo3Nr8hrLpHXdScVcfZjnV655hhTQN3/msZhZGRGsPlfUka1PZ7suKlbWncb8TeyfNE7bdmrZKRwCAFyLYmP0eJCa+nK5l1VsYShZ5Djb8/0xMzf4Y/XZBLIuWlzrbRV77dIyAICVFc/BzM6JB5B/S0CjhUphnstoqVyaWw+alUlBEIoPURUFoWBK/UOjIAiCIAhCoSjl5t76glcRBEEQBEEQSjulXmlMPEVpSEfO8MK5jJZq9OVuJFfjab0un3BqsuIe6qN8cYeTigVNppRsu5tcJJL1EdnvBIfwq0RUOhW2HI7mtOaXHShVnhHB64WmUap8yxhOjzfwpXS4b1e6fc7WnFpfOJ6W2eg57X0xkVKjnXz4WOdiaEzNKoSr2LZjgbT+ab4YfcvTcZfv5f0Na0sp5sV/cop5xxQ6nyAbHvvxWHoneaoC2/VsP0jFPpNbBKuYR1Naz5TBRTQvzKfzSM7iPs9mKphqAwDeuvSZivV2HQ0AiMzhY40sXxEAcDCKx6TX0/V0teK+2fG4AADQ6bmLjtkYZ+SZj/jA5vI2i44w/prVzq24XXnGaYmy17EokXsYaWlz2lvsewThn2EugJE0tXAvSvucRlEaBUEQBEEQhAIp9UqjtQM93lv3ZauW6I9IQbTbcULFUnKoMCNuwVkVm/gHKVmf92F7m8wtZIPz7W9c/NHCMwkAcCaeC0dqu5Fdz6ZP+fUi7CdSjWbuqqZi7b2pKGXDLVbB9kWTSjbeNhgA4O+cpJa1/bkJACB54s8q1nmji3ZMLhIxasLUnKNs+O3vQEEvG1b3KlUl+51Ii17WF86RddD4UWwr9NLHdH2quLKtj7897eeT89xTuoYbKX0n4wNVTH+Cfr/zJX8dt8/eCQDItujZ3CChDW2bsRkAUMGlrVq2OXEpAMDGmq/x/rPm4h1LpZFU4fDUEyrmYEfX087aTcVikni5GZ2mUjrasRIbn3Ez1zIAcNKWJ6VezrOPh40ojIJw/4iaKDwo4tMoCIIgCIIgFIxRRz9Fsd8SQKl/aHR8nKxXTCfZ5sZ3Sl0AQPryQyr29RVSzbKMrDJVc6Gb/MoGnu+3dBQZPwdZ2NY0e5Isd+Z+wAbdLcqSgpZ1nufgOWvTJX3sWBmrXoaUvrmt2Mg6R/u4+wgpZFW09oMAMLYhKaGTW/Ct/bEtGYmP28f7bVOWlj8TyHMl/cqQ+mlpFv7MD6RE1vNgtdBam/vn8zuPPSSVrHter8Wxg1E0b3Jl/2AVO3uRWi8uvcytF39PPwgAuDqwmYo96052Ol9G/aRiYdY05zPyuZYAgAY/sArpYk/3pZ1NNxULt6HzOZj0NRi6jx72fM9iUi8BABrb9Faxm26knL7ozQr01ODlAIC0TDZkN2rzEi3tdfJTGM1WO452gSqWnEbfOb2FmXAdt0EAgJNx3+TZhyAIgiAUJ6X+oVEQBEEQBKEwlPZCGHlorEoKlS7pIsdi4wEAH23huYXjg0g53BzGl2x4ZVLpnqnOquKe36h6upwTV8bqerYAAIxee0nFAh8j9S9qP8+FS08nxSkklWXqNZfJYNzxGqt/XfxJcUvO1lr8vcDV265v0rbLTgaq2OujaG7ftDRugbj/tift/4aHitWJp/aAsZlcHzWkElVmr7qeqWIjq1Lsz5u+KtbZl8byxhGe09irPI3l9a2s6tnoKebFoiuy0uj6Hcng9nz9nGhO6IyKfVVs/U1az3np5wCAKu691LK4FLp/zo49VMzNhs7tYBKfz9OeYwEAq6PnqZi9Lamfp4w7eX+JNK/1kL62iqVn0BzO/OYRmtsEAvm3CjRp/0Uwq4uWWKqUojAKwsNF5i8KwsNDHhoFQRAEQRAKgcmkg8n08OcfFsU+iwKx3BEEQRAEQRAKRGcylZRC74dDYmIiXF1dkZCQABcXF2R/PBwAkBXKKQy755sCAHJ+O65iBzaTXY2DFaceozWD7vgsFmyTs+k53N3CtqapH6WTHZ25cONWOFW93Eh2VLH6ZanAotzLfioW900wACApkfO5ATOoUOfq61T0supaWbVseA1KRc85yb2VHbThXUngsfcNoLeaBl5cCLP0ElnpOFrxG8/AClSIk2Jxjr6uVOwy64TFODPofGu5c3p6Y2QEAKCydRkVm1iT7IFupTqo2PKr9Dslh+/BvvR1tD/7x1UsVUfbRhspjf1Hk4ZqWZ2dXwEAqrtxOvvlcjS9YOLlFSqWnklj0uv5+GWcagEAaqOFinlYU+HP9rSNKuZlS/u7GveLipnymYiSn+G2mHALQvEg6en/Dnf+/7s4jn1j4FNwsbEpeIP73X9mJiqsXVMs53Y/iNIoCIIgCIIgFEipn9NoqENqmb5/RRWb1YsKHjxt2V7H1ZoUpe3hrKSlZ5NqNKdNiIpdjyQF0cWWC0e+PEfWOI/7sjXO2pv0JpGWzcpTjzmVAAAxC7koJyKailOWX/FUsTGTTgEAbiTSscpaWPScvk2K6KeL+PijR9JbkYsNj/1YHClfbcuz+hmTTvvpGphpESOF89ML/FUpa092OSEp6SrmbE1FPBZdEbHlMfrHjMN83KOxdD4VHXlbT1s6xs74H1QswLE5ACA4+6iK/dWULHnaHqS2fy0OcOu+ti4vAwCeLc/K7ahziwAA1lZcKASTWQFmJTg6hYpeduvYKudWX1I4fX7gWEIq3Ze6boNVLN/CFZ12vhYFMaIwCsK/h6iLQlFhMhVR9XQJ+V9EqX9oFARBEARBKAylvRCm1D80Rq0IBwC4B7Fa+MZcUgbnTuR5C44GerVoWYZfB4aO1eYD1qmjYh/3J0PpuW+Gq9i7t6nN4MoNrGbGZ9B+cixeL6IXkCXPFyd4vXEdSOma3Z/VvwkzSR01twKszD7ZyNG+eNWHsL1PM6uaAIAmZXg2wsAaNwAAZ8N4vqGtgbaNzWSz6RquNI9waUc2tD50k+ZQhqWx4fczrekcB68NVLE/rtG8Shdr/mNwMJDC9/lFHsum9fTZfugzKja9PU10HLuD5zSei6NtzUbZ1ay5jeBNHR3/9atXVWyo92gAQGQ6qw6/5pBBd1YWn4+TA1kCWVm0AvRe9y0AoIxLYxWLTiTV01JdNFvtWNrs5Ge5w+vrLdYrIcZcgvAIYlYTdRbm+KIwCkLRUuofGgVBEARBEAqFUQdTKW4jKIUwgiAIgiAIQoGUeqXR2pZSiVZPNlUx0wGysjkew6nb3vUpFV31GS7qiN9OhS3Zv55SsZdrUF9mUxJXhJz4g4pTcizmLLT3odxyPXcujll6IpBirpyK/vh3snlpf4q7zkyoR7Y64fGUlzboOcW967YbAKCzA3cyWTCVUrE9JnBByNO1aJtj8Ww9U0lLc/8dzee49BqN+cfHOZVaxo7ObXcUp6dz0mi94VV4vf3RVODibM3j2xZG61V04m079IvXzttVxTpupuURpj9VbOXR/QCA3h5vAAB+TVqulmXn0HXc33qkis08Q/f2AjhlnZkVCYAtcAAgOY0sfCzTyuZ+0FGJR1TMvI3ltvdKRedHYVPSBXWYEQRBEP59TKaiKVopKYUwojQKgiAIgiAIBVLqlUa3bmRbAyMrQMe/J4Xsu5ncq3npPFIdz8xn1adVBTK5Xnuhgop19iNVb9MPbHy9IYQu83v1I1XMSius8W/DiuS5dWTDcySOVbg+/jQGs5E4AHjXIruasi40li9X8fG9balYpHf5GBVbt5B6MMeAjbzrbaceyLMCy6vY5WQaZ3gqTyYvY0UWNtsvspXNU1PpGFensG2NU3NSMX/ezsUk/cunAQCqe/B1vJFAauLuKFY417ekcY3YYa9ilfVUbNPIlk3KfTw7AQCmvUZKa+y+LmrZkG20/oprvI92muf5xvMbVcxciFLGpYmK5RjpHsQms2JszGdCvdk2x1JpzNfIWzvGPyl0EXVREAqHFL8I/yalvXpalEZBEARBEAShQEq90phzk+bC6ePOqNjNFFIVrVYmq5izFalGZssYAPBqQW8Gr/ZhBQ8BvrSPN3jbx3xJhfpbM94GAC9bejtetJQVxKm9yF7n9wOsHDrZ0Hr1u8er2IhPKgMAyjrotH3x4V019wlbG1aq1t2g4w8ux3M0c0wdAQDfBaep2If1yF6nN4t72KnNkTxicYpdVpM9UWxmoIr9sJTOLSKN52NuDaNzM5o8VCw2k75y49uzaXbwNVpezoFVyjfqhwEAWuy9oGK6VJpr+f0UUmSfdGuglnXWhN1XBl5TMa9ZNB/RUrULdO8KAEjKvq1iKZmkANdwe1LFLsSR0XhBrQCVhY7JMmathSyczu/Yx537EQShYCxVRf47E6VR+PcwFVH1dJFUZBcBpf6hURAEQRAEoTBIIYwgCIIgCIIgFECpVxrjtdoHzxf9VUyvo7TiwWh3FbPWbG1upnIuOPh3Sqfui2CrmMFvU9GHmy2/NqTm0LN5M39OiZ4I8wYAJGbyeua2yBVdklSsYiNKny9eWVnFvn4vgvZ7nFLgFy9x2rl2EyrE+fLXKip23Ui9tAfYluXjx9OtHxTIKeFlV6mIZMHMeBX7aAylftJzOC0fGUNFL372nPZ1tqLPF3Vsb+OSEQQA+DGEj3ExlfbtZsN9vYec2wIAaGPdU8WG7iH/H3s934NnPRsCAM7EUQr8XDynf5fHUB/qbz/l7jwZWXTtXvB7l8/x9ucAgIquHVQsNpmmJpzPWKdiej3dZ2sDt9vJyqLiotyFMJQyN4GLXoxaYU1+qWhJSQvCgyPdX4TiRgphBEEQBEEQBKEASr3SuOo09Xl+9WqEit1I9QEAVHJkJStLm6RqZfEycCOBCjIaeLBBd+xP9Ll2EKtwlw9WAgB41eL9lYkl25yGHqzCWXvQM3xCBquZsZdo+YjOV1TswGoqtllxjZTDpZ+wMvnh5KoAgO5+8Sq25zatF5/Fpt21XEg5vJbCMXvt2/DtbFbX5jajIpHZp3xV7EQ0rXg0jr8+5+LpfHu4sqm4uTe2Ze/puAxSKb+6wopbT8c+AID/BVgUrDiTijDrTD0Vu55EYw7Ppv7eF4171LLOdr0AADlG3u9ZrQDmy7DpKlbdg4pdQlIPqZhOp6mFFgUzttak3mZksXWRrS1dg4wM7iuenzXPqY4vAwDq7lqYZ5kgCIJQcjEadTAWQdFKUeyzKBClURAEQRAEQSiQUq809qlE1i4ph1JU7NUvaL7dipd5npqbNalQ1nqOpeaQQuVbhpXGtFSacxMXx+bVbpr9zZotFVXssUA67uUkbu23fjNZ7TQvG6ViB0NIJdxxmBXJJ8qRTc6oanRcrxF/qmX7m7cCkLtlYSUXus1/RVjYBdnR2Gu5sTIXpnUqtLVoS7j4vK+2Pu/PbBcUnsqxjr40H7KZB1sNbY8gxTLboiws2UjbfliXFbrvgmlO6PkkPkc7A+1vXdyXKnalG815bLbnIgAgNZNVwB34BQCQkc2qa3YOfT7e/hUVa7T7awC57XDMJtwOdjzPMi2dbIWgYyX2vcDnAQDvXGTl0ozl/EVRGAXh4WKev2g5p1EQigOpnhYEQRAEQRCEAij1SqMgCIIgCEJhKO3V06X+oTFguBt9yObiD1wmi5oKDpxittM6wSRlcXqkqisVZCQkcL/jCm0odTx/FVv4PFPzBgDgdKi3irn6UiFM1CVOf6Zq2eOIG1x0clXLtjb35NRyHa2/9XfnKZ26tUFHtSw5k1KtNgZOo99Kps+tfFhYdtKWp+bwF/XpCpSf3nGbU+bQLGI8bFg7j86ga5BtUXRS24XOZ+55i8IeHaWUorO568yT5Wnfg85wYc8TLnUBAAtu7+exZLQEACyvPULF9t6i47nraJxPl+Xzjtesiyo68/nMDFkFAHjrBHfdMdPX4w31eUPsLABAavrNPOvBojhm/m2y9fF1a6NiYfG7aTWx0hGEh0p+ljpisyMUN6X9oVHS04IgCIIgCEKBlHqlMXoNWcp4ftZNxfY9ST2Lna35rfZGCqmOKdmsDNb0JpNpB0fut5wTR8rU72HpKhacTAUuswexujbqGzLf/rw392DefJgKZao4czGJjZ6KRCo5parY79eoOXQDN1Lw9BYq140URwBA1ybBKhZ/nGKXEtnKx9ma3hemvhqiYgu/JHU0Op1Vyrm9acwN1nLhyIcVawAAGnry12fVddqfpW2Nkw1dK0drRxW7nkxvU10c6qrY4ohvAABe9tVVbF08WeKsieexjCnbHABQxkiKbScfHtNzF34HACzw7apibwc8AwD46OYqFbO2outpVhdpzHQMvZ4VY6ORrq3qLQ0gIp6VUHWO9mSnlJzGPa/N25j3a4nZNJyOkbc3tSCUdkRNFB5ljCYdjEWgChbFPouCYlcaFy1ahIoVK8LOzg6NGjXCnj177rn+qlWrUK9ePTg4OMDX1xfDhg1DTEzMPbcRBEEQBEH4L3G/z08ZGRl45513UKFCBdja2qJy5cpYtmzZfR1TZzIVX6H32rVrMXjwYCxatAitWrXCF198ga+++grnzp1DQEBAnvX37t2Ldu3a4ZNPPkGvXr0QGhqKkSNHomrVqtiwYUOhjpmYmAhXV1ckJCTAxcUFGRMHAwA2/cF2OI29ac7g9XhuD7g1nJRGOwO/DdgZ6NJNej5YxZZ+S6pidWeex3clmRQsB4t5hiFppMI182AFsWEVMo0ODvFQsaCm0QCAL7ZUVbGhTUj9+/AvUiuTLV7Mu/iS6vl3DM8tdNc+no/nWz2hViwAYE2wl4ptiL1EsQaeKvbhaboGizrfULFFR0hdS7I47oV4Om55Jz7uiURqqRhpCFWx6iY6j5/GcuzyHjJJ/yuCjzvx6ncAgBq2nVQs1HQOAKDXbDfCE1j5a+symvalO6Fi4Ql7AdzResxI4zRY8b3Nzo7PtV+ATbvzi1na69jYkBF8Riabw99LaRQE4f4R9VEA8v7/uziOfarzcDhb2xS8wX2SlJWJujuWFfrc7vf5CQCeeOIJ3L59G9OnT0eVKlUQGRmJ7OxstGzZstDjLFalcd68eXj++ecxYsQIBAUF4dNPP0X58uWxePHifNf/+++/ERgYiDFjxqBixYpo3bo1XnrpJRw5cuRfHrkgCIIgCELxcL/PT7/99hv++usvbN26FY899hgCAwPRtGnT+3pgBIrxoTEzMxNHjx5Fly5dcsW7dOmC/fvzzh0DgJYtW+LWrVvYunUrTCYTbt++jfXr16NHjx53PU5GRgYSExNz/QiCIAiCINwvZnPvovgBkOd5JSMj79z3B3l+2rRpExo3boxZs2ahXLlyqFatGl5//XWkpaXlu/7dKLZCmOjoaOTk5MDHxydX3MfHBxEREflu07JlS6xatQoDBw5Eeno6srOz0bt3b8yfP/+ux5kxYwamTp161+XW1SlN6baX0x+BAygl+eenbNUy6w1KHR9ew0UdUelU1JAZytvGZlLqMsCFO5P8Ekap7T7luDimgiN9Q3ZHsb1NQlZ5AEADb56jGXGOjheTwSnR5YcoLd2mDH2ZojI4hbo7kmTz1mW4OGd3FMVcbHgfn5+nFHiPcvyF9LWn/a67we8SzcrQOPddZguh329TJ5pytjz2ZC3tm5jJX6kq9nRt+7q7q5i528y4ryqp2LFEOl8rcGed9wNp2oCjgVPq4y5tAQCsrjsUADDkLFvk7E5cQPu3KatiNtZUMGPuDAMAOgPdM3NKGrAodtHx2PXaZ5OR71l+mNPSlgUzkpYWhMJhmXa+s9uLpKSF0kj58uVz/XvKlCl4//33c8Ue5Pnp2rVr2Lt3L+zs7LBhwwZER0dj9OjRiI2Nva95jcVeCKPT5a4YMplMeWJmzp07hzFjxuC9997D0aNH8dtvv+H69esYOXLkXfc/adIkJCQkqJ+QkJC7risIgiAIgnA3jNCpCuqH+qPNlQ8JCcn1zDJp0qS7juV+np+MRiN0Oh1WrVqFpk2bonv37pg3bx5WrFhxX2pjsSmNXl5eMBgMeZ6KIyMj8zw9m5kxYwZatWqFiRMnAgDq1q0LR0dHtGnTBtOnT4evr2+ebWxtbWFra5snbmb6LFKj3p14W8UWzaWYvz2/6S5bQmPqVztYxb7dQ2pZhTNcwBGpCVPlqnMafKSRns0t+0EfiCSlr5UXF8KYiUhiNdPXlex3hmhFMgBQ6bUyAIDwL8guKDyOjcnPJrgBAA7H8jlfSsj7hfC0JfVxbTBbCE2uT0U3fY9Gq5i7kQplRgVycc4rVUg5bebH927yYbr2rjb8HhKWQvY7DhbFQ1tDSZHcnrxCxcaXfwkAcD2JDczfufIFAKCH83AVe9qDjL5HXKCip6RNg9Wyx/9H57g3Y72KOdvQmCITec6rTk/nbVnMYlYGTSa+ToN93gEAfHv7Q+TB8o+ypDQMFYRHHFEWhZJAUZt7u7i4FFgI8yDPT76+vihXrhxcXbkINCgoCCaTCbdu3ULVqlXz3e5Oik1ptLGxQaNGjbBjx45c8R07dtx1YmZqair0+txDNhjooacYi8AFQRAEQRD+FR7k+alVq1YICwtDcjL7QF+6dAl6vR7+/v75bpMfxWruPX78eAwePBiNGzdGixYtsHTpUty8eVOlmydNmoTQ0FCsXLkSANCrVy+88MILWLx4Mbp27Yrw8HCMHTsWTZs2hZ+f3wONYfInpHzFfseK3ws9rwIAtu/iuQW9qlJa+4fTbM0zsV4YAGBrMCucddy0Nn6BPB9y205SBi1NuLO0t4pkC7Nw89xEJyueE7cvmt44Xu7KJuAHPyKl72Q83ehsi+dle03Vq+nCb+2Tu9PYDx3ja/T9DVrP14GPv/ACjXNKBZ6D2E1rgegYwPMNJ6+huY+bbvF5h6eTSudiYeT9Rq0UAMB3wfxmY8bfqSmfY0w8nVfqWhUzzxGs58nWBuuiyRLIrAye/Zjnfu5KXgMAyM5hhTc9k2yFTGAF05hDY7JUGvMjP4XRvE1+cxZlHqMg3D93zmMERHEUHm1MRWTufb/q5f0+Pw0aNAgffPABhg0bhqlTpyI6OhoTJ07E8OHDYW9vf69D5aJYHxoHDhyImJgYTJs2DeHh4ahduza2bt2KChXI6zA8PBw3b3Kxw9ChQ5GUlIQFCxZgwoQJcHNzQ8eOHTFz5sziOgVBEARBEIR/lft9fnJycsKOHTvw6quvonHjxvD09MSAAQMwffr0+zpusZp7Fwd3moNGPzUMAHAxtIxap8UAUtVenlVOxQYGkBK54ZaDir3TlFS47VdY2j2VQMqdNwuN6OAdDwBws+dK3L3hNG+ySZlYFYtLp40OxHBVcllbUskyjPwWEpxCx2jvTWP6NZzfEm6l0PpPBrDy1bE6KY0TdrFKmphF8w0f8+X3huspdIz4DP5KvNeYTLg3XuVrEZGu186R1zNXRdd350rlqadIRUg1cSV3ay+3XOMEgOqutL8fIm+pmJ2Rzun7Nlzd3XovKcDJWTT/tKPdE2rZhtg5AHK3MXR2oDka/rYNVMyoo+tyOX6LikHbRm9glTTHrFjm8+dhQqn6kxGEh45ZTcxlvC8Ko1AAj4K595EOL8LJ6uGbeydnZ6LxH0uL5dzuh2KvnhYEQRAEQRAefYo1PS0IgiAIglBSMGo/RbHfkkCpf2j0WNATAJD1xGEV+2wJpWIrs5MNtkVQWtpsIwMAP16g/o6tveN4fzaU4uzany1yTv9KhSBlynLV0sVLVERS241vwV4Lo28zJ+IpFd3QndO5bjaUHl12lSTyVy3sfcwTdLOMLCK7taWxtz3LadUTcZQWsuyHbW/QrIEs5qbvvEHFM27WvJ7ZQWdHGF+LVCN9ru3Kx13YIh4AcCOBC2E+v0Cp6grOfJDZoT8BAHY3a6di/Y7T9au45WcVe8WfbHAWhlIq+pINe26OKkdeVgeTw1TsWMI3AIAU20AVuxW/GwBgNHLa+zHX8QCA3xPmqZi557QJfI6CIBQd5lS1pKkF4dGl1D80CoIgCIIgFIai9ml81Cn1D43p728EALR+nK1nYn8mq50bqayGffg6KV8n1nHRSTlPKpjZHcxFInZ6UuSu7+L1wlJJ6fv1AFvZfDCaimhWfcfbetvRtr52XDhi0JE6eD3ForJGo79W7LI+hCfN1nGl2IB2V1Vs0XyyyDnONTdo6En7DU7l894ZRSuY2/8BwL4o+iL3KMeK26EYTf304utjNNHnN0+z6vrr/0hZ3R3GZqNJOWTNsyKaFcTYn/oBAKy6zVIxc1GKXs/Xce6Ia3S+nzQEADiYWJm10gTOYwnL+SS1Ipabcbm9rABAZ9EycGfip3mWG0XtEIQiQ1RFoaRiNKFILHeMJaS+UgphBEEQBEEQhAIp9Uqj/cBa9MGOS+ir/kHeRtY6VrLGzqA5iFkWbwP1Y0iRe3Eqt5/bO5eUvuhUVsgqu9Kcw8cncGu/JR+Qmnkzld9YzG8aW2/xbRkbRDY9li8h5laFTla03ql4NiY/FJepjbOyitVxpeU9Anjuo1c5UgGHb2Abnu9a0Y7fOszK5dLnSd37aycroqcSSWF9xZvthyZcOwoA2N0mQMU6rqdJoUvq8XGfqkD7/qEe2+A8OYjma35S8y0V2xNByua6NXwtrLt9BgCYWvk1AMD0G1+rZceT2c7IjJUVKbtZ2SyxGjQF09LqI8fCENyM2Vw8P9NuS5XS0uJHEARB+G9T2tPTojQKgiAIgiAIBVLqlUZBEARBEITCQHMai2a/JYEHemgMCQmBTqdTTa4PHTqE1atXo2bNmnjxxRcf6gCLmkPvRgMA9kZxStbOQGnNI9G8XqAzScfj23AP6NQESnFGreb1LiVR2rlNWd54Uwh1f0l9l9d78wnaTzY3UEG21mnFrgynRP/cQ/srZ8/FMdvDaL3odLp91/VX1LIFVasBAGwNnK4N9KB08ph9Xir2Wg1Krbf04a/A7jAaZ0wmb/v+99RVJcWiwbWnlhav5RGvYl3DmwEAXtnH49zyWAQAYOEJ7lFdViv2ab+Z08NnEhfRmPWv8FiydwEA/J5kMXy0H6WlV0VdBAC423NqPTx+HwDAyb6SimVmU9rZYNHpxZxONhkzLWI0Jr3OsrDn7hP0He04BZ+cdu2u6wmCIMUugvBf4oHS04MGDcIff/wBAIiIiEDnzp1x6NAhvP3225g2bdpDHaAgCIIgCMKjgHlOY1H8lAQeSGk8c+YMmjZtCgBYt24dateujX379mH79u0YOXIk3nvvvYc6yKKkyTIqhGl6+IyKRa6PBwDEZFRQsXHtLgEAPvmrqoq9NYAUvk2/8XrmHsxl/bi4omESFdScTuDCkROHyIbGzsCFFMuuegAAxtSMULGDsWS1U92Z16voTLftXDwV4DzuXFct28qe4oqaSVSU42Xh2hOTSe8L9Vy5iOZwLI3v9Rpsw9PhMVJEn17C5zikEp3jpKNszQOQmtDQkw+y8ixt81Jtbpr+6zUqqPmxGRcela3QHQDQ6IdLKhabQmqin3MTFfsqkux0Ah1aAgBuJx5Ry3SgP7jUjFCO6ajwyGBh25OZZSEf30Fhi1pEXRQEQRBKIw/00JiVlQVbW/of8u+//47evXsDAGrUqIHw8HyeWgRBEARBEEo4RuhgRBH4NBbBPouCB3porFWrFpYsWYIePXpgx44d+OCDDwAAYWFh8PT0fKgDLGoODD0PAGjUOFLFzoTRXM30HL6JWZoJ9uO+CSp28M+ytI9ongvnobnqxNzmeXRRGaSqVXXi1nUn48iOxsOG1a367jS3bunFsiqWqU1v/DWMZxL4OdC4fhp+CwCwfhfP4zuXSLf0RCwriH8lRdHY3Xku3nryFkdqDquK9Txov63qcns+60puAIC2PnyOt9JIaRxSicfuY0fn9ubpFBV7IZCUyM5/8RxJVyOZfwen8DzHrw6Qymu2uQGAnByyBLIC2xT1d30OALAqaoYW4fXLuVELwtD4v1QMevNyVjVtrGleZ3Y230c1zxH3PxPZrHA+yLaCUBoQI2/hv4TJpPpGPPT9lgQeaE7jzJkz8cUXX6B9+/Z4+umnUa9ePQDApk2bVNpaEARBEARB+O/wQEpj+/btER0djcTERLi7c2u8F198EQ4ODvfYUhAEQRAEoWRiNOmKqI3gfzg9nZaWBpPJpB4Yb9y4gQ0bNiAoKAhdu3Z9qAMsamr4U+r22BFOCeu0VOOgilw08cE+SgF7WxSTmH2V2nuzfUv7epT33Xe6vIpdS6HL7GfHwu6IMXTcfSv4IdtX+84EpzirWHdfStNuCuV097Rh1Ff61M4yAIB0I3/ZzGlpbztO61a3pbT0zeQcFXOworR0ZRdOO7fxosKaTUc43b1pI/3uUJa1c2crypnHZXJqe/5lWt7By0PFYrX2OR9X4SIaZ2tKBf/BswGQqBWvXOraUcXWXabPEy9+pmLXcjYDsLDGsUhnRySfAABYW/P0iKysGPptkRbT6221TTllbcx58LSZpKUFIS+SihaE/yYPlJ5+4oknsHLlSgBAfHw8mjVrhrlz56JPnz5YvHjxQx2gIAiCIAjCo4BJK4R52D+m/3IhzLFjx/DJJ58AANavXw8fHx8cP34cP/74I9577z2MGjXqoQ6yKLH3JOXr2gVW/E4lkIL2cq14FSunLbZ0bY/W6jvOJbJqdeNAFQCAhw0bdHf0Ifudpm+wTHl8Dm2zN5r7W7fwTNW25YN8eI6+SOXtOWbSjLb3RrkBAH66xUUdi5rQG/4vIWwzU98tXTsWx/r4U0HK8mtuKhabSV+HVddZJajlTmPuHshWNuP3k13QzZwYFetXlozBsyxm834RQUVGK2px3+qDMWSiHujIqmdPp2cAAJW2fqliw33oO2SpWHg41wEAJKdThb5Bz9fT1Y6U3RQLS53snKQ8+zDb72Rlx6tYdY8nAQAXY9dDEARBEIT8eaCHxtTUVDg7Uwp1+/bt6NevH/R6PZo3b44bN2481AEKgiAIgiA8CpT26ukHemisUqUKNm7ciL59+2Lbtm0YN24cACAyMhIuLi4FbP1osfwvUgZHr2Cj6sfnnAQArD8bqGJ2mmn39WSWkJt7kUrpbctWOg5WFNsbzfvr3fg2ACB9Ox/3k3OVAQDTGrGv5Z9hpOCNHsjm0ZU2k/1Pmxocm/YdjfmGNkfRrC4CQPVupFYe+46VvKVXSDmd0ei2is05Q/MhP3uS2yJ+sJlaEE4I4jmah2Pp96KzrBZ+2IgmJL5yiFVSd00d9bXjsfT0o3mi887zehsSVwEAUtLZ8NvHhQy8LY23l4Z+DACwsSmjYkF6stU5YbUZd3I74e88MQd7mkuZanGsHK19oM4iFWBWGC1jMldREO4fmcsoCP9tHmhO43vvvYfXX38dgYGBaNq0KVq0aAGAVMcGDRo81AEKgiAIgiA8Cpirp4vipyTwQErjk08+idatWyM8PFx5NAJAp06d0Ldv34c2OEEQBEEQhEcFUxEVrfynC2EAoGzZskhOTsaOHTvQtm1b2Nvbo0mTJtDpSsaJmxnRnfpHI4JtYTaeo89XLVLRbctQCvpsAlvZbLhJy58obxELoeKMvuW5W8q8P6lfdQJnfeGk1c58fo47o8waTinojZu4c0tqNonBN26xH+axGLLG+aA+Fbgci+ZlPy2ljicRaXysVYNpvzv28TlWc6Wxf7SlmopZa7qzZZcYczmPvwOna987TrY22z6JU7GvP6Hz3hrORUHJWmFNJRfeX8rt6wCA+bXfUbE5oYcBADbW3ir2rNeLAIDIdL5oWxPmAwBGlXsdALA4dI5aVtG9BwDgetwWPlZaMIDcaWejkdL3+fWZlpS0IPwzpPuLIPy3eaD0dExMDDp16oRq1aqhe/fuqt/0iBEjMGHChIc6QEEQBEEQhEcBo6nofkoCD6Q0jhs3DtbW1rh58yaCgoJUfODAgRg3bhzmzp370AZY1FhXocKdXR9y4UhyNqll/csnqtjlRDLXfqMOF64su+QHAGgTwIUW8VlUuFLGlqW+rrWoojwklBXBkGTa365IVinfWkam2k7WrIy9/xGNYe4UNs2uq328lkQK3l+R/Oxfz52+eVHpFgU739Ax3ghkxe98PK238GkuhJmwjhRRax1/ezt40/Ebd49VsVtfBgIAdn/JFj5dK9B1iUjngpl2FUjV+zmUC2HerPQuAGB+2HkVu5mwm45rxcVDyyOoEEan4zFf6ToYAFD51+kAciuDNxL/AAC4OtZQsfiU83nWg6Yw5lf0IoUwgnD/iKooCKWHB3po3L59O7Zt2wZ/f/9c8apVq4rljiAIgiAI/0mkjeADkJKSkm+P6ejoaNja2uazxaNL6mFS0mr5sm1O9TKk3G0L9lOxlByKJWfw+VlpAt+357ll4OujbgEApi3gWEIWfe7Vlw2ywzbR9Qvg7oBo501q3upgVhVhQ7cog4VQvFidVL0BB+hLNrsm2xzVq0jLXt4eqGKDfGiO5NJrbAI+KIC2WfxbVRWr6UbqWo7Fl3ftTVrvzPesFtZyocFU9uI5jYmpNKcx0IEHuuAixXak/6RiHwZSodQgAyvUS4w05pgUVj0tFUYzPf+mlormFoAmI9+znJwUAEBC6sU821liVhPzUxJFXRSEwpOfwmie01jQeoIglEweaE5j27ZtVRtBANDpdDAajZg9ezY6dOjw0AYnCIIgCILwqGCuni6Kn5LAAymNs2fPRvv27XHkyBFkZmbijTfewNmzZxEbG4t9+/Y97DEWKQZNOPR5u7aKHRkfAgC4msxqVzkHqiP++RargAGaqtY7iFPyr39SEQBgbyGUNfCmdns/rGf18VoKXfpYFstQ5zV6I497nxWvyRNIkfxfALfs+1qbS7m1C1Uiv7+/rFpmo6cK5BwLe/ksrQR6WKCzip2Kpy+ogxV/UfdEkxL5RDmeW9itLFVo30hlhdXVmuYFTrA47qLH6JrFhnupmEFH1+fNcv1UrLWmpjbZ+6OKZefQ3MfaLmzXdDphHQDAZExXsXNxa2CJk30l9Tklja6FyWTEnej1PPfSvD+DgSVes0qZH3oL5cQoiokgFApRFwXhv8kDKY01a9bEqVOn0LRpU3Tu3BkpKSno168fjh8/jsqVKz/sMQqCIAiCIBQ7Uj39gJQtWxZTp059mGMRBEEQBEEQHlEe+KExPj4ehw4dQmRkJIzG3CnBIUOG/OOB/VtYeZLYempisIrZaVelS1lOWzasFgYAmLG7ioqZ09crTlZUsdfrU5r2dAT3TN50gwy89RaFFnsiyZJnQTO29fnlS7LkCU5lu54AJ0pPn4zjlLGLNe1nzzWytxkQwOPcGEop6DKckUWmkVLQFRw51QtQkYqdge/d2Tg6ltmOBwDSc8wFLmyG/fVV+t3Ei78+Y3ZRsc2NDC6OaehC52Pp917vj8UAAFeH6iqWZaBjnIqzmCerFbvUdx+qYgmIomMkkkWPOSUN3LuIxTLFbW1N9yUzK5KPdY/iGMuUtDlVLWlqobRSUNpZ0tLCfx3pCPMA/PLLL3jmmWeQkpICZ2fnXF1gdDpdiXpoFARBEARBKAxFlUr+T6enJ0yYgOHDh+Ojjz7K13qnJKHTCkEi01iau51OKpfe4sH/6MEquJNe5ahwxFbPNjPHwnzyrNfInaxi/ohk25qpdemNPKBhkopd3UVqYu9yPBZPG1L4UnN4+ukT5UlxW3SRVLO6blx140OiHca/x/Y6J78gNTEq3U7FTifQ/jxteb/Dq1BVjrWOq3OWXyN1rZw9X4xnK9Ln74NZVXCxpq/SrlFcsDPuO1Iap934VsWSRw8AADgv/lnFzIbbsLDZCXBtDwA4Ef8Nr6YVubg5kl1PamaUWpaVRce1VAt1On2u7YDcCqPabyGtdkRhFARBEEozD/TQGBoaijFjxpT4B0ZBEARBEITCIubeD0DXrl1x5MgRVKpUqeCVH3Eu/Enq3rE4VvdiM+n3xKY8Z+7Dv2neoo1FvbmPE80lPHyb5y+m5dCND3JJVjFrPSldvcpxK76Rx0mdbHWTFcwymqtNJSeeP5iYRQes4sTzHLeG0vFquJBCtj+Kv2wzWpH9z6Vl/EC/+gat/+HQayrW+BJt224rq3v7I2nuZRUXViR7+9M4ozJ4va2awGc5R7O+B43hze/5fOI0R/KWtv1VLGDlTvpg4nPMT8G7nXoWAGAwsHG50UjXwNwe0LLtn5o4aWE1lJ/9jtrGYkpFfusJgiAIgpCbB3po7NGjByZOnIhz586hTp06sLbO3QWgd+/eD2VwgiAIgiAIjwom7aco9lsSeKCHxhdeeAEAMG3atDzLdDodcnJy8sQFQRAEQRCEkssDPTTeabFTEjGd+xImJ3tsueUJAIjJ5GVWWurypd/9VWx+G7LS2XyVYx+fpI4oLbz4HaF79ZsAgG2XuPvLVa37SzUnTsMOK0/pXicrfsD+Xx9KLb+1jNP+QypRSvuHm54qZmeg4+m1Ip5mFsf//HggALblAYB0LRPceR7vo7E7peXrWPPxs7XyLUeLLjFZml3PmVw2PLTNNVOYijUx0nEvJVja+hBv1+TPfU9qxTbWPJbMrGjtE3+v0jO0Pt0WxTF13Z4BAJxL+oXGls3pfisDnU92dryK5ZeKNvfGNVr0rRYEIS9inyMIeTGhaOY0lhTLnQfqCLNy5UpkZOT9n25mZmauntSCIAiCIAjCfwOdyWS671S6wWBAeHg4vL29c8VjYmLg7e39SKenExMT4erqivgDc+DiZA+cugIAWDGLCy561SDF75cLFVTMbJCdkMVvA9e1Wpcg9t1GRQeSLC8m26iY2X+pqUdqnpilrY+jFb3Zp2azAHwhiQpaziXwivPGkur54WJSM6s7c1GJWRlcfp0LZz5rrKl7elbyPj5NPaI7lOVYcIoh1z4A4HAMjblnOS6OaV0mHgCw87a7ijVwo/UOx3IBzqcRvwMAYlOvqliOkYqHnO0CVCwxjQp0bK25oMjcj9pSTQxyJ7ue83HrcCeWPaLNFNYiJz9rHkEQGFEdhUcB8/+/ExIS4OLiUvAGRXDstY0mwMFg+9D3n5qTgYFH5xbLud0PD5SeNplMuQy9zdy6dQuurq75bCEIgiAIglCyMZl0MBVFevq/aLnToEED6HQ66HQ6dOrUCVZWvHlOTg6uX7+Obt26PfRBFgUmO3uY7O2R+if5xzhbOapl0/aTvU5zL1ZM3axJzdsWyjd2WGWSC6+ksKrYrhbNaTz/N1vPeNiQgrXiGqt1Nd1I3aruzJMpd96mMbz12CUV+3NXNQDAJ2+Hq9i8z0hhdNXEtT4d2Rro6WWBAIAc8Nj3RXoAAF54ifdR5Qadx/UUvoddy5Ih+L5ofstJNJnVUR67qz3NW3SyYpF68SW6BvZWrNbtb1mLjrXthIoZ9GRtZLbNAXjuYVrGLdyJXs9vdHcqjHo92ySZ7XgeBFEYBYHJT1U0zwUWxVEQSjf39dDYp08fAMCJEyfQtWtXODlxhxMbGxsEBgaif//+d9laEARBEASh5GKEZcnmw91vSeC+HhqnTJkCAAgMDMTAgQNhZ2dXwBaCIAiCIAjCf4EHmtP43HPPAaBq6cjIyDwWPAEBAflt9khy5gL1io7Psuh7rAmotdy4f/PpOJqr6WrREmb5VUpZf/u/y7y/87S/aIvi8iRt3xVYmMUzmjXPustszRPkQvt74Se23Hm9VhwA4MuF3NO6oVZ08kMIFZ18+ktVtSzLRAd+toKziq29Qetfmu2nYlbqNDjFnJFD49xzm1PmQQ6U2j7KLaVxJp6shoJT2F7HqO2nnicXwlT69SsAgL9bexVLy4kHAMQmxamY2X7HsuhF7fce1jj5ptEsbAsK21NaEEor5r8hnUUhWX6paElLCwJhNHEh68Peb0nggR4aL1++jOHDh2P//v254uYCmUe5eloQBEEQBEG4fx7ooXHo0KGwsrLC5s2b4evrm28l9aPOoVEX4WhlCxs9Pd6nZLOC6G1LD73lvFlpDEmhIpUPm0eq2Ph9pNxZWRSMp2TRJX2+SpSKeXmSN098PBdumFkWzv2gu7uRwuhqUc1/OIZ2fiuVxxeSSmNxs6Gxe9qy0juuBo19wUVev7oLrT+hQQjvI5b2m5jJCkNZR81ex5+Nt80WQ2kW7wEZWn9tVxs+n0xtCM08uCDFbGVzK/5P3Im1lYf67GofCACISeLrDR1dR5PpHgUuprwvJ6IuCkL+FFZVFATh7pigKxIj7pJi7v1AD40nTpzA0aNHUaNGjYc9HkEQBEEQBOER5IEeGmvWrIno6OiCV3yEadI7Hi52Ngj7g9SwpzTDagDYrM0zXHK8oorVcqF5fotP83zNMdUTAQDLtrK9zlP1SDn8/BDH3htEbxCff8jm1T396HgTLSY6/nWbVLJ9GRdUrJxDEADgWAwrbo29SOHr7ENG2Q1rcju/DutJVTy8lOc0jnjNKs/YXTWVsl0ZVveCE2kbOz2rdUbNVicmg5XLuEyKWUzvxOKwhQAAF+tXVCzIjcy4b2UeV7Ekzejbcv5ijqkcAEBnYaFj0FORVaYxr3JptsixVBXNcxlFaRSE/NHlY4AvCqMg3B+lfU5jodsIJiYmqp+ZM2fijTfewJ9//omYmJhcyxITE4tyvIIgCIIgCMWCOT1dFD8lgUIrjW5ubrnmLppMJnTq1CnXOlIIIwiCIAiC8N+k0A+Nf/zxR1GO419H37kh9E72OLyaikP6vpaklj21l1KoSVFckbLhEqWsQ1L4gfhMAqWWD1lk6kd2pyIS/9O83spPqegjPYf1508v0LZT6rOXza4I6gfdz62mih2OIsuZtj7sidlOK9C5lqx1kFnvppbNDKL9Xv2aFd8eWt/oXbc5PeVjR2OZe57T4wbtnaC3P49z9XXaTyM3rvZxt6EVX6zBafFvY30BAHEZvO2F+B8BADuaj1Gxzn9/DgCws/VXsdik07gTcyraEuncIgj/HElJC8KDU9rT04V+aGzXrl1RjkMQBEEQBEF4hHmgQphTp07lG9fpdLCzs0NAQABsbW3zXedR4cTYS3CyskWvHqT0LZrJhtpPVCLrmV+ulVOxas5mI2tW/LxsyYzbWs+X0RhKKmBtN1bKLmiKpAe3qEY9N/p9LYH7POcYzctYCTgXT78tbXW+C+ZtAGDPmynqc8wRGvvcYxVUzEZPymBVZ36V6eRH8mglR97X11dpzPU941VsrjOpk3+w0xAqOVJRUEgCF9sMcu8HAFiftEvFnvd9EwDQ+e+ZKmYy0TXLyLyNO9FbTNTPzqYxeDjXUbH8FEkzOj1dXNM9zMAFobQhqqIgPFxEaXwA6tevf09vRmtrawwcOBBffPGFtBoUBEEQBEH4D/BAD40bNmzAm2++iYkTJ6Jp06YwmUw4fPgw5s6diylTpiA7OxtvvfUW3n33XcyZM+dhj/mhUNE/Fi42NtDZUeu80RN4buHns2m+nZMVq3v1AiIAAJv/ZhuebuVJreszlF8RXv6YFL6OPtkq1l1rGRgb56hiZ+PcAACt67Lhduu69Pu3Y4Eq1i+AxtfOP0LF0nNo/mBIKj24v/UFr9/QneZSuli4a7xQJxgAsOwMq4/h2nzIPy3mbfYtT9uGJvM4P7tAXxFfBz5HO01ZHXWZ57m+4dcFABBx64CKrdTsdczqIgDoDdRmML/2gJbr6TRz73upi5bcq92gIPyXybedpqbaW9rsiOooCP8cMfd+AD788EN89tln6Nq1q4rVrVsX/v7+mDx5Mg4dOgRHR0dMmDDhkX1oFARBEARBEArPAz00nj59GhUqVMgTr1ChAk6fJmWofv36CA8P/2ejEwRBEARBeEQwFdGcRtN/eU5jjRo18PHHH2Pp0qWwsaEChKysLHz88ceqtWBoaCh8fHwe3kgfMldCvOBoZQurm5SCdrLh1M2oJ64AAExZfBfnb6kKAKjrxinr6BRKtV76llO8Y4Ko53R0Knc3OXqjLAAgqAx3QTHb3xhO8MP3nii6ll3LcheU0wl0jB5OnH6tqn0OS6NjPFeZ+1zHpNEc0tQcBxWzsaO075FoPsfQVFre3JOtgWKzKBW+M4LHbqWnbau4sHTuYUPb/FSnpYqtuKZdK4tvfmYWpe/NRSoAYK016vaw54454fF7AABl3VpaxPZBEIT8KWyqWVLSgvBwMWo/RbHfksADPTQuXLgQvXv3hr+/P+rWrQudTodTp04hJycHmzdvBgBcu3YNo0ePfqiDFQRBEARBEIoHncn0YKJocnIyvvvuO1y6dAkmkwk1atTAoEGD4OzsXPDGxUhiYiJcXV0Rv/5NuDjaYvv79CaeY7JQ0mxJyVtxjc8lPpPeAyo4GVSsmSdt27l+sIpN0PpQv9c4VMXOR5Lh9zYLBS9Fq/nwsuXj9vGPAwAsusRG2pWcabmPHb+HWGub9G1Afa6X/M2qnTZMBDqwguhqTZ/D0nlS/K+hNHZnK35vOJFF5/FnVx7TgF+pX/bSFskqNv4gmZUnWhSf7E5aDAAYU/4NFVsYSv2oLY26szQrHcuiFzM6i4nA5h7SltuKubdQ2hHlUCjNmP//nZCQABcXl4I3KIJjL679FuwND99SMC0nA6POfFws53Y/PJDSCABOTk4YOXLkwxyLIAiCIAiC8IhS6IfGTZs24fHHH4e1tTU2bdp0z3V79+79jwdW1Pz0gQkOBhP69SBFcOzyympZW29SE1uXsVD39KR81fHgnoGHo0hxa/gTz0EcUYbUMktj8O6BVBB0MoGVxiPRpP4FOrJy+Vu4GwDgqznxKtZmNB13YzeOfXmCbH9WHaExD6zC7fyMOXT8d4548z58SGFs7R2nYh/eugAAmFmuqYotaUpjGrWRr0Wijly9PzlbFgyZe3tYsQdnM+fnAQCfh3C1vNFI18XO1s9iW7qmBgPb+rjYBwIA4pLP4k4s1UWDgd6+cnIS86wnCKUBs4WOKI6CUDzInMZC0qdPH0RERMDb2xt9+vS563o6nQ45OTl3XS4IgiAIgiCUPAr90Gg0GvP9bMnNmzcxZcqUfz6qf4G+a6vDxdkBuqTyAICAdWwP5GVLb/E7b3MFctsypJoFDeNLtuJdmm/3gnddFbudZt4HTxVdc5mUtm5+XD3dwI1Ux02hrD6aK7MnvuOmYl82pcroQ9dZrdsekQQAcNKqkm30rAJeTyHlslkZPv6wxy4DAKZuqqpiU8o3BwAsvsaqnZWeFMwAi3mb3va07/1xbH4+yJ8U1iMxfIyfYhYBADq7TVAxWx3tZ3PcLBUzm3abVUgAiE8+h7thOadRFEahNHEv025BEIqH0t5GUF/wKoUnLi4OK1eufJi7FARBEARBEB4BHrgQRhAEQRAEoTRh0n6KYr8lgVL70Jg+dxtsbGwQfpVsdUa3YkuZ7w9TIUhaDt/GbM2S5/f5XGpfxYmWJ2azVUx4Ks3nrOvGsWaeqQCArWEeKvZ3JBWTdCvHx2jvR0Uni29y+n9KhRQAQMYVvlUbelOa286T1nvvZ047e9rQ/g5G8bzSH5Z7AQAm10hXsT3RlBZf1pxtc/ZFUKHJ+fhMFXujFqWRX6jKY/pEyyavvD0Dd7IzcYH6bGWga5vLSkez2jGnqQHAhLz2O+ZCmQbOg1TsaPxX2vol5c9LEO4fc1o6v6IXKYARhOKF0tMPv090qUxPC4IgCIIgCP9N7ktp7Nev3z2Xx8fH/5Ox/Ktkp+iQnaVDdg4Va/x1prxa1syLrGmG9uTClW+3VAIANPWKV7Gvr1IhysiqrNb1CaAilc/PcQtFDxu6zElZ/HZSwYm2nRd2SsXquVEhSmUrLo55aj2pcC9W5ef7k6fI/LtfIzL3zrGoS0o30jEqufCtrWPlDgAIS+cVT8aS6ng82lPFdDp61bHS8TinnyZl1aBjex1nK7PxtqXBKSkglkqIuY2gJaww3ttgICeHFNYj8V/ecz1B+K8htjqC8Ogi6en7wNXVtcDlQ4YM+UcDEgRBEARBEB497uuhcfny5UU1jn8daycTrG342d5kMUdh6WWae9gijh+S+9YOBgDsvBjA6/W4DgBwntBcxT4dSOqaiw3v72YaKQc7YtnW5/VKNM9wals2uf7pNH2OzkpVsQnVaduNt9hq47N+VwAAt685AQCae/GcwMnXyV7n50ZeKjbnLH3uE8C2OecTqT3gQQ6huy8d197CtLuqKx23oiPPkXzh1EcAAL2B2yyaVZEmri+o2KH4LwDkntNo/my0MO22XK72V2LeuwThwblz/qJlTBCERw+x3BEEQRAEQRCEAii11dOCIAiCIAj3g7QRLKXYtfSBnYMtbh6hS9CycqhaVs6RCkdcbLnA5bfzFQAAAwaEqNg331NxzKkeXPDR048satJzuKuKnYFSu6uasrD71OEIAECgUxkVM/e3XtaGO58su0A9rDv7csrq3V/IYqeBO+13YN8batm6z2lZShZbCFV3pfRvjeE2Kub+Pv32s+OvakgqpaX9Lfphp2u2QzdTOWalFdbkWHR1MX/lzSlpAHCyp+uTnHZNxcypN71FOs7dqRYAICbpBO6FuYjGbNsjCI8q90o7W8ak6EUQhJJEqX1oFARBEARBuB9MJvopiv2WBErvQ6OVAbAywNma3vBnHayoFtX7f3t3Hh5ldf4N/DvJZGayr2SHJOybIgRFwA1RBJdKqYp1AYpLEVEU66u4FFAr1KpVW8WiiOL+syxiRSEoOygaElllDQmEhJB9zySZ8/5xZp4zIYHJIMMkeb4frrkY7mefSevJfc65T5jM4K3OC9FifcNklvBv76n94uxZumg1bwSL7GV4Lu6kMnOlVpnp21GmSul8eZnMbP5nj5psMyJaTkT51y61zvStXcoAAP+Xre7FkWFcfERmQj/6Z5y27d5u8ievc3SpFivKCQMAvD9PTVzJqpD7Bfiq7GdGsXye/uHqp7ezv8zqDYk9qcVeOCzL4fjZM44AUGeVmVPnDGJV7RGcSlt72imz4irD6MAMI7Vlrc0WMqtI1H4JGGBrYfLmuThve8CJMERERETkkm4zjUc/LEOwnwkDBsqsWb8eBdq2A4dliZphcWrM3n+zZDZvdFyZFksIk2MP07JVZvBPfY8DAH48pop7Ly2UH/PNnVXZmv2FsqxPtyAVc5j35yPa+63/k/dS67TbgUp5vqQA2ea/pbMae3lxNznmclFGVy2WEigzh4uOqLGSiSb7En8GlREdEy8zjXvKVWyj/Vo+BjX20ugrs6OO7KIz5wyiwSDvz+QXrcWs9QVNtgGAsJffcc5S2piNoXbsTGMVWV6HqP3Se/e01zONb731FlJSUmCxWJCamoqNGzeedt9JkybBYDA0e/Xr1+883jERERGRd7nTfnK2efNmGI1GXHTRRW5f06uNxs8//xyPPPIInn76aWRkZODyyy/HmDFjkJOT0+L+r7/+OvLy8rTX0aNHERERgVtvvfU83zkRERHpjc2DL3e4235yKCsrw4QJEzBy5Eg3rygZhPBeUnTIkCEYNGgQ5s+fr8X69OmDsWPHYu7cuS6PX758OcaNG4esrCwkJSW16prl5eUIDQ1Fyev3IsTfhIJvZdduY6MahLotV3Ytj31Qdec+9bzsJr4xXpWycVRw/7E4SItZfBwlatT57kiSa1mvOaEmjvQOltf9pVSt35xeKLuq/l8/1S2+vkBOgHGarwI/+6lX5Mp7eWWg6uJ675C8RqFTf/atSfL9ugJVcifCbJ+cU2x1ismu6Ktj1LG7y2VX2t8OPYdTOUrlAEBJ5W4ATVd3aWlVF8d2rvhCHcVv6WJmyR2i1nP897usrAwhISGuD/DAtV/sNRMWX4vrA9xU21iLp/bNbfWznW376fbbb0ePHj3g6+uL5cuXIzMz06379Fqm0Wq1Ij09HaNGjWoSHzVqFLZs2dKqcyxcuBDXXHPNGRuMdXV1KC8vb/IiIiIicpdjGUFPvAA0a6/U1dU1u4ezbT8tWrQIhw4dwqxZs876+b02EaawsBCNjY2IiYlpEo+JiUF+fvMJFqfKy8vDN998g08++eSM+82dOxdz5sxpFjdc0huGIH+E798KANi0OVHbVl4vP5Y3/qHWb742RpbDeWWPygw6MoJDI1X2cdNJmXV0ZBcB4JNsmf2LUociwF7wO9RPZdwM9iTdJ0fUbxlD7etKl9arySmxFpmVWDBUXveXwkht28/lcjHpZFOYFvvwsDzxcKeP+r95ckLKH+LUBJclebKsTt86FXuv6DsAgK+vWiMbkPfiyC46c84gOia7COFu4p2o/fgt2UJmGInIWefOnZv8e9asWZg9e3aT2Nm0nw4cOIAnn3wSGzduhNF49k0/r8+eNhia1iYSQjSLteT9999HWFgYxo4de8b9Zs6ciRkzZmj/Li8vb/alEBEREbki7C9PnBcAjh492qR72mw2t3wAWt9+amxsxB133IE5c+agZ8+ev+k+vdZojIqKgq+vb7NWcUFBQbPW86mEEHjvvfdw9913w2QynXFfs9nc4ode8a+fYDCZUF4sC27/WqHGKAyOqLBfR+3/S6ksUXNptPpCNhfKDIOfUyd/g/2Y/xxU4xefGigLeb++M0GLfV8gM3d/6pGnxYqtsQCAIRG1Wuxwlbz33WXqugG+8mvbnC8zgl8dVTf6+gC5bXuJuqnuQXLcYlaVylb2tsgs6v4ydezDKfKe95Sra11suAwA8D/bNi3WUpHtlsYqtpRhbO1YRo59pLbIVQkdIurYnLuSz/V5ASAkJMTlmEZ3208VFRX4+eefkZGRgWnTpsnr2WwQQsBoNGL16tW4+uqrW3WfXhvTaDKZkJqairS0tCbxtLQ0DBs27IzHrl+/HgcPHsQ999zjyVskIiIialPcbT+FhIRg586dyMzM1F5TpkxBr169kJmZiSFDhrT62l7tnp4xYwbuvvtuDB48GEOHDsWCBQuQk5ODKVOmAJBdy7m5uVi8eHGT4xYuXIghQ4agf//+3rhtIiIi0qG2UtzbnfaTj49Ps/ZSdHQ0LBaL2+0orzYax48fj6KiIjz33HPIy8tD//79sXLlSm02dF5eXrOaQ2VlZViyZAlef/3133TtqjIzfPxM8LGXyBmdeELb9vg2ObHkggjV9f3EdfsBAD9sV13MJ+vk9q5BVVpszQm5WspAp/Wbn/hBdju/d/cBLZa1MwwA8O7+WC324ieyy3reRHWfjjWiL3Q63/FamSDOsV/W36i6gT/JDrUfp0rpBBrlffo6DXUYYp/r8k7uUS3mUyDHegY5Tc65NUl2aX9Xq557++XXAQB6py3UYi12Wf+GiTDsliZPE01WL2rexcy1pImorTqb9tO54PWJMFOnTsXUqVNb3Pb+++83i4WGhqK6utrDd0VERETU1NkU4m7ted3lbvvJ2ezZs5vNym4NrzcavSX2nniEBJohcgoBAOkfqsky18bbi1zHqfWoN6fLkjzfF/hrsX4hsmzO2wfUoNWBETJDdveIg2q/7XLd6o/WdNNim+yntjaqQtozxsvUYUapWt96YJjMHEaaVCbP317pe2iknDDzZW6Aei77fJ7kQJUlvTq2GADQaFOpRsdEnWihygqdrJXX2FGpalm+cuQtAMC/+z+jxXqtfgGn06S4N0vtUBvkyAy2tAa0c4yFt4mImtJto5GIiIjIHZ6ePd3W6bbRWJd2GHVmE2pOyqzd2wdUQesJKbL7+/c/F2uxOV1lZm5cosoC7i2XhbxLrSoLOKyTzBa+9313LTYwTBbhjjGr/S6Llh99vU1NYD8oK/2giyVYi+VVy0zkojI1RrFPiMwsRtmX/bOoSjq4PkHe80dZEVps7Qn5vnugqix/kX2M5PPD1VjOZzenAABOVqgTOjKHDU5ZSkcswF+txFNVcwQAxyJS29RStrC1MSIiknTbaCQiIiJyh6eLe7d1um00+ob5wtfii6Bg+VVNzlYzoD85IjOI/+rdRYt1j5SDEGf/HKfFbu0is3+vDSvUYoeLwgAAcRaVVTxaLcdBOi8FaLLP2u4aXKPFthXK/SItKvtYUCMzjReGqXGLs66W4yXf+0FmM41OFeBf2iWv/8yAk1ps/M/yGr2Nagb05fb6n6NWqzFc9TgMABhoSdZiG+3Fvx/dqxZAd2QTq2uP4VTOYxoNPnJcpc3WfO3MljhmWwMcD0nuO1OW8LfMjiYictB797TXinsTERERUfuh20wjERERkTsEDBBovr7zuThve6DbRuOJDDOq/UyIu0R2nR6sUN2/vWSVG5Q7dSfvL5QTYUbEqm7TQKPsgnZ0SQPAc7tljvnx3qqUzgUJsqv4jR2dtVjfELnfzyXquqmRMjams1pP8mSV3L7PPukGAJ5cLbulQ+xVdSrqVV77pFU+zyu7VSmdmSnyXrYVqec5bJ90E2RT5w0wyLJDH514UYvdGP7/AADr65ZpsYpqWaS8pYLezhNhDG4mstklTe46mwLcXCuaiOjs6LbRSEREROQOAc+MP2wnQxr122iM6laNEHMDfMZfBQDonbZX25YQJotb7y2I1GLLj8lJKgOclvPrEir363yFmugxqigZAHD5ILVk4JxvewAAoi3q+hsKZCo6yikWak/6bcqL1mJr8uTfXUNUlrCoTmb4YvxlzFFkHAAabPKEjU4/gWvy5X5HqtRkn3u7yaziwHBV3udojdxvdZlKk/+v5CWcLZutxvVORK3U2mxhS0W7T3ceIiJqPd02GomIiIjcoffZ07ptNJovjoE5wIzSORvsEVXc+509cuxhvL8aY1drT91dl5SnxZ7aJuvWDDyisoD3pcqyNYs2qOLeD18gS9NMXB+mxb68TZ5n6U9dtVjacZnhGxSlxgK+ce0hAMA/tqrzRdureV8QKkv+vHhQFSEfHxcLAOjsr8YbLj4s349PUksgHqiU1/ilSO33q+2w/Z26fkRwPwBASaXKxDrGMjZZMrDdJNepvXKVQWzNNiIiOnu6bTQSERERuYPFvYmIiIjIJXZP69yG/bIrusypvM6+Mtn9arWp2CB7OZz/7FGrqkxIkRM91p1U+y3dlQwAKLaqrts6q/yYH+hu1mKz0+TkmMJapxI+fvKYy6LU+tYfZnYDAFh81U/UHSlFAICN9jWlX+7rNJnFvlb1ugL11fr5yGvc3DtHi035Tj5H3zCTFrspWK4lfV9lmBYrrZKrz7RUXofIkxzdzI5uaXY7ExF5l+4bjUREREStIex/PHHe9kC3jca8/ytDpZ8JQ5NkFm7tYZVB7BsmP5bB4aqUzoFKmSXsH6oybin2kjuObQAwIl6uUV1YrYp2r8iRk1NGJ6j1oP9+SGYE/3WB2q9frxMAgGdW99BiQyLlfntK1eSUxPhSAIBPgcw0Hq1WdXuSAmX2s2uQ+gGctCcbAHD7qmQt1tlersfHqQj9pF9keR3nCS62M67nq358mAWi3+LUrOKp74mIyPt022gkIiIicgfHNOpU3L3xCAk0Y9Nz1QCAKLPKlDnGA1aHqOzefplUxLCulVrsWIWsxu3vNN5wWbbMKp6sVdd6yF5yJzRKBYf+KkvoHK1Wmcv/rpEZxh7B6nyHq2RGsFGo2KNpskxPtxCZEdxarjKDv+8sxyj+N1t9tVdZZNmcVFWrHL/aj7kutlyLPXdQ3ovzz67BID+Dlpb4O1MWksgdLWUVmb0mImpbdNtoJCIiInKH3kvu+LjehYiIiIj0TreZxpKPc9DgZ4JjJZgdZWq1lNQI2RVr9lFt/yT7utD5NWq/eiG7eJcfVd1ol3aSk2LmzVPdvlMfSwQAxPqrbuSbEmS3+LCBx7RYl91yhZnlx0K02KRucvLMFqd1sMddlAUA+OtaWY7H36ja/qvzZPf0ZTHq3vfY15JOL1KxO5PlOtTDN72GM3F0Gxqguqcd5Xfay2wvIiKic0HvYxqZaSQiIiIil3SbaQy/Nhgh/maEvC/XbzY5ZRXTjsusWt9wVUpne6EsvzP9xmwt9u16WQz7sT6NWmxrkf1NXJQWuzBMHutrUNe46rrjAIDMtdFarHOELOodXagyje8fsmdCi9UkmiNVchJNhP32ruqkJudsLAwEAPwx9ZAWW56ZAgCYnZ2pxdbYl5L+e+9ntdgTvz4PoGnJHUdZnUZbFYjOlvOkFhbrJqL2Sgj58sR52wPdNhqJiIiI3GGzvzxx3vZAt41GW2E1bJYG9LtGZglDNqlC3jlVcQCASJP6GpOC5FhBY6Ia03hxgizGXVQeqMXGdpEZucbNKjNn8ukCAFiSo66x/V1ZNiclSGX1du+TywFWNagMjGOZvytjVQHvCJO85/ezZWbSaAjXth2rkr+uzNugCoQfrpBjEAvrDmixVL8b5L2rW9I4j1W0NVY338HOUY5HHiSaHevIWHLsIzljhpGIqH3SbaORiIiIyB2cCENERERE5IJuM40+McHwCTADg3oDADZ/kattGxEtJ538WKy6oq+IlhNm5r2VqMXSC2U3211d1XkPVspB/j6LO2mxPw89CACY8AfVRv/np/bu6UC1IkyRVX4dI+3XAoBlx2QX+WVRqh+5W5jslrYJOYlm0o0HtW13v5MMAPhdgjpHgFHOmPmi8IgWW1f9GgBgffmZf29oqWtZ63ZuYZUYV8eSvrTUFc2JMETUbnloIkx7+c8lM41ERERE5JJuM43WHYWwmk04/L7MdlyeqLIeP+XJLOGlETVa7IohRwEAuWvUBJNLo2XG5JjaDVMulVm/1zZ312Lzt9hL5PysMnOZRXIyy7Eq9RUk2ufT5NeatNifulUAAD7OUmV4rrXJtn5Bncz43bkgWdtWb8/+Lc5S5/38pL2UjkHFHO+dy+s4ftVxlSFkBlGfzlXZHGYYiai90vvsaWYaiYiIiMgl3WYajTFmGC0mbFktl+fLqvLVtnUOkG3+Q/bxiQDw7Zcyw5gQoM6RFCDHI/o4JescpW56h6ixin/8vSwI/sz7avDjw73lMoPTdqrC3PeHyVI/vUNVrKpefkU3Jah0pk04ZweBab3UeMfMUpmuLLaqfbb1eRgAMHeXuvllxfPkG6eyOX5+8rOw1heC6EyYLSQiPWJxbyIiIiJyid3TREREREQu6DbT6HNhZ/gEWpC8RK54cmOPAm3bvJ/lmtL39VDdtP/cI7tu95aqc5h85MeXX6O6ghvtOeYSq+runrO4GwBgmFPZnE6B8rrDQ+K1WLBRdmk71qAGgFcyOgMA/I3qGhsKSwAA96fI7vO39qs1soP85PVTgtV9XrLhDQDAmLC/4FTOZXPYLU0tcXRFOya/OMeIiPRECAHhgb5kT5zTE5hpJCIiIiKXdJtpFHuPQ/ib0D9eZvfq61VmcHwXOUklNFBNPgnyk5k+56V+Gu3vH+h3TIv9Z48s/h1obNRig8JlVjE6QJ2vtEauJX1XssoqLjsWBgDYvbOLFltdfggA8N4FkVqstlHu981xeY0oi/oao/3lfVY1qBu9I/opAMCnBXO1mI+PzE7abCr7GeQvJ+pU1hwG6dOZMojMLhKR3nEZQSIiIiIiF3SbacT1lwLB/ij73zYAgI9BNfN7JBQBABb9kqLFugXJ7blO4xeDjXI84DdH1LjEaIvcb0hUqRY7UhEEAFhzQg00vDhCLlW48aQaj1hrT11eGKbGGa7oKZcy3HBcHXtzgizJ8/IeWQS8b5jKkvYNkZnDcT//vdkjP93tr9r7Fw/Jgt8Ws7p3Zhj1iRlEIqLWEfDMin/tJNHITCMRERERuabbTKP4aguExYQfCmSm7fYbsrRtK76Vs6d7BVm1WFa1zOpFqsQgYsxyPGRFg8r03fc3mSX860NqDGIfe6HvT4p/0WIzhssi3P/erzJ9n1yfBwDYeCBRi+0olOcZEO40o3pPKABgWLRs828vUoXEd5bIezE4Fe2e2/NpAMCT+57DqWrrjjeLUcfgatk/59nQRETkmt7HNOq20UhERETkDr03Gtk9TUREREQu6TbTaBh7OQzBAei1fDsA4J//7a5tK7b3Sl8Uprp9x3WTZXUe3BitxUojZF+11elXhG8myYkyf+pWpcUuHyW7nW1f9tNi/9gkP/rkQDXpZVGGLHlT4rRu9NM37AcA9P9QrUc9K+lCAMAvssY3Ogepr/GVI3KCi49T1+OT+54H6Y+r7mdOgCEico+cCOOB4t7n/IyewUwjEREREbmk30xj9jEYAi04Xi2LbPcOUZNeFh+Wmb7iOvXxnLTKySlPXVCuxZI7yQzi7uOdtNhlV8qJJV+vUQW6v1iRDAD46pj6XWJQpHxvNamsotWedNxeVK3F/vy5XIKwm6hV58uWGdCbO8tjR8SrJRBfPSJjQqgsqfbMTpNjnJcPpPbP1QQXZhWJiH47jmkkIiIiInJBt5nG+tW/ot5sQoQpDgCwIjdQ2zY3VWbuPj4co8UGhMoxhQFGlcH734HOAID9FartbV0rM5Kjh2Vrsa83JwMAQk3q4461yEzfw9cd0mIfrpXjKv0MqoRPYqB83ycsQIstPZEPAMgsiQUA3L/jXW3bmcZaMLvYPjmyhK0tkcOsIhGRZwghX544b3vATCMRERERuaTbTCMRERGROwQEbB6ZPd0+Uo26bTQa4wNg9DehX2fZFd0jWn0UZVVycswtXYq02MPpsmvwvWF1WqxByEkndyQXa7HvT0QAAA59r0r4pATISTZDotQPxUdHagAA2dU9tNie0kYAwKwBaiJMUmwuAOB/e5O0WJiQ61BfGyvP+9YxNZnGsYS28w+go/yOjd2W7UZLXcwtdVOzK5qI6Pxh9zQRERERkQu6zTSKW6+FCAmA2PAlAODfO1SJnBvjZVmdRYeDtNikZPlrwNIjwVqsu31t6jd+DddiiYEy69c7WE2Y+b5AFgF/dMBRLXaoUl7P16B+vegbJie9vLY3RIs9Y5LXOF6r2vfflf0TALDmJ3nszK5/1bbNy3rB/oDqvC2V33EwQGUp20t6vCNrKXPY0rrRRER0/tnsL0+ctz1gppGIiIiIXNJtprHx9S/RaDYh7UAKACDUT2XZeiUWAgB6F6ms4rYimZErt6rfB34okG3u6xLUsYMj5PjGZ39RJXJuSpQZxPp69XF3C5LjF5cfVdmjW5Pk9gNlTssIpssxkn3DVeyBxGcAAP+tWA0AeCn7NW2bwSCzmkLUaLEzluFhdtFrzlRK50zjFplxJCLyDiEEhAcGIHrinJ7ATCMRERERuaTbTCMRERGRO/S+jKBuG43GLkEw+puw8aTsOr4qWk0W+WiH7LLuE6zK63Qyy4+qT0ilFltwUE5YOVGruo77jywBADxmNWsxP58qAMC7++K12M0JpQCAKLO/013JLmuLUXVN9g+X121wSl2PipOTY+bnpst9wv6obdtZ8iGAlie4/JZJL5ww0/qVWc6035lK6ZwuxokwRETUFui20UhERETkDpuHint74pyeoNtGo6FXPAyBFtydLDODe8vV2tNBRjnZZV+lyhb62hNtJt9GLfZwb3ms0Sn2n89lljLOojKX2dUyU3RjfJkWyyiRWcojVWpYaUKAvG51g/Pke5kJ/X2XQi3yp5/ldkcpnd1l/9fs+VrKBv6WDGFLx/oZI7T39Q3FzbZ3NGfKHLY2+3g2mGEkImobBDxU3Pvcn9IjOBGGiIiIiFzSbaYRDY1AQyMq6mWG6Ntcld2rF/L9fx8/rsVefC8ZALDwoMquOZbxM/moYxvtSwtelqyO/XqzLOSdVaGKdoeY5H6RZvX7RZ9gWSansE5lPSvtCcuLN32txR6OnwgAuDriWQDAvMPPa9sMBsdXqu5JCM+UDdVDdvFMxbZPfd+aY4mIqP3Se/c0M41ERERE5JJ+M41EREREbhDCM+MP20ltbx03GuOigSB/fFeQDwAYFqM2Vdh7FQ99H9jssDuSy7X3n+fI7uaJKSVabN1JCwDgXxnJWqxRyIky9UKVrdlTIru2P/tzthbbsl6W5MmtUt3Jvj7ymCstt2kxR3e080QUh5bWmXaUy9FrqZyW/JaSNux2JiIiPdJvo5GIiIjIDXof06jfRmN2LhBghtnHBADYVaKyeyNi5Pv1+VFq90r5hb65L0iLHa+Thb53lKoJLlH2Kj3bTqpsVEWDfF/vNCEl0iQzks9+1l2LPXvNAQDAl7k9tNi+Mjk5pm+YKgL+fXUsAMDsFwoAaGhU2c+WMo3norh3R3OmtZ2JiIioOf02GomIiIjcYBMeyjS2k0GN+m00FlcANVbcmCA/gk0nVbYw1E+OQaxqVJPL5088JPdbr5YC9DHI7dlVKoOX6C8zfV2TVVbxmouOAQA+2KqyinvL5DEWX3Xsk9/KDGNPdSv4sbQaAPDP7Ne1mLAvN2i1nrD/W/2whQf1AwCUVO5u9sh6yy6eqVwOs4tEROQuYf/jifO2Byy5Q0REREQu6TbTuPLtIAT4mtE1WI5LDPVrXgC72KqygB9/0xUA0DO4WosNe1j+ZrDlDRX7+ngwAODXUqsW217SEwDgo06H3Oo6AICvwaTF+oTK8zlnqZeOrAIAxC1tXWaspQyjg4+PGhdps9W06nztBWc+ExGRpwk4L51xbs/bHjDTSEREREQu6TbTSEREROQOltzRqev/FYOQIH8suKsQADAyvkDb9tVRWek736kHt7rBFwCQXqxK7sy+T3Yd39IlQIs90E9Oenlrd4IWK6yTPwwNNvVDUdooT35LpK8WSwyQXdY7ytT5Rq+Vf/v6qkLjtkbZHW6wlwuy2epcPa59v47fJc1SOkRERJ6h20YjERERkTuE8NDsaZbcadvEtl8h/E24IFRm8HYXh2vbxnU9DgB4Lj1Oi825UpbcuW9lkha7t5us5P1CVpYW+yY3EQDQM1Rdq7e9hM6JWjWEtNwqr7smX82OWZz/KgDgD5FParEgm5xY09hYpcVMfrLouLW+sBVP2r65u9wfs4tERESeodtGIxEREZE7OKZRp/LT6lHlZ8DBSjl+sH9YhbbtmW1ymb6r49SXWFYiy9V0DVEfmZ+PzGr1M6rsY7RFjlHcXVKrxYZGygzj7lI13i63Xl7vthiV4ewT+gwAIKO4UYttLvs3AMDHaaxefX2Ry+dr70sGtpQxZBaRiIi8Se+NRpbcISIiIiKXdJtpJCIiInKHsOcaPXHe9sDrmca33noLKSkpsFgsSE1NxcaNG8+4f11dHZ5++mkkJSXBbDajW7dueO+999y+bmhcLcLia5FT7Yucal98eSxce1mMBliMBgQbG7XX23vi8faeeHQJFNprxTFfrDjmixGxPtrrgd4n8UDvkxgc5a+9fio246diM7oFG7TX7YlhuD0xDLWN0F6/FDfil+JG/Lf439rLx+AHH4MfbKJeexkMRhgMRvj6BjYpxeNMOP3xNiHq3X4RERHR6bnTflq6dCmuvfZadOrUCSEhIRg6dChWrVrl9jW92mj8/PPP8cgjj+Dpp59GRkYGLr/8cowZMwY5OTmnPea2227Dd999h4ULF2Lfvn349NNP0bt37/N410RERKRHNi3XeO5f7nC3/bRhwwZce+21WLlyJdLT0zFixAjcdNNNyMjIcOu6BuHF4kBDhgzBoEGDMH/+fC3Wp08fjB07FnPnzm22/7fffovbb78dhw8fRkRExFlds7y8HKGhoSh69g6EWEyYPj8FADA6Tq0VvfyYnHQyJEod18VeeNvko1LIP5fISTQHy9VH6G+UE1C6OCUALb5ye4SfmuCy4aQcGRCmlp7G37PkMy8e8P+02N2ZLwIAfhf+hBZbUfJ3AIDBYB9dINR5z2dm8bdkBFmEm4iI3OH473dZWRlCQkK8cu2hIVNhNJjP+fkbRB22lr/V6mdzt/3Ukn79+mH8+PH461//2ur79Fqm0Wq1Ij09HaNGjWoSHzVqFLZs2dLiMStWrMDgwYPx0ksvISEhAT179sRf/vIX1NScfqWTuro6lJeXN3kRERERucvTmcZT2yt1dc1XfDub9lOz57DZUFFR4XYCzmsTYQoLC9HY2IiYmJgm8ZiYGOTn57d4zOHDh7Fp0yZYLBYsW7YMhYWFmDp1KoqLi087rnHu3LmYM2dOs7hv1wj4BphxR3IlACApolTbtqlQFuiOs6js49oCizzOoErZ/C6hDACQEqiW/fuxSH6kPxQ0aDF/o2ybP3mBusaiLHlMuFGlGuf3l0W9J/wyTx1rlvfyVclLzZ5BCHkN5/I6ntJSkW3nbGFrjz1TjIiISM86d+7c5N+zZs3C7Nmzm8TOpv10qldeeQVVVVW47bbb3Lo/r8+eNhiaNniEEM1iDjabDQaDAR9//DFCQ+WSK6+++ipuueUWvPnmm/D39292zMyZMzFjxgzt3+Xl5c2+FCIiIiJXbPY/njgvABw9erRJ97TZfPqucHfaT84+/fRTzJ49G19++SWio6Pduk+vNRqjoqLg6+vbrFVcUFDQrPXsEBcXh4SEBK3BCMg+fCEEjh07hh49ejQ7xmw2n/FDJyIiImoNYRAQBk+U3JHd0yEhIS7HNJ5N+8nh888/xz333IMvvvgC11xzjdv36bVGo8lkQmpqKtLS0vD73/9ei6elpeHmm29u8Zjhw4fjiy++QGVlJYKCggAA+/fvh4+PDxITE926/ta3fRBo9ME3eXJt5wfCy7Rtji7oOptqsd+cIFdweWGX+siu7CS7lt85pLqx4y2yKzrIz1eLjYiVP2AfHFIza0bZl7Uus6pr7CyVPzTXhE7XYuurPgBw5gku52Pyi6uuaHY3ExERed7ZtJ8AmWGcPHkyPv30U9xwww1ndW2vltyZMWMG3n33Xbz33nvYu3cvHn30UeTk5GDKlCkAZNfyhAkTtP3vuOMOREZG4k9/+hP27NmDDRs24PHHH8fkyZNb7JomIiIiOleEhybBuJv8cbf99Omnn2LChAl45ZVXcOmllyI/Px/5+fkoKys73SVa5NUxjePHj0dRURGee+455OXloX///li5ciWSkuRaznl5eU1qDgUFBSEtLQ0PPfQQBg8ejMjISNx222144YUX3L62v7EBAUZfmO0JwY3HYrVtji/vH4dKtFh//04AgDintmlFg5yIcmW0Rd2j/RPNLFY/APm18iLBTsm6rQUyM7e0SE16ebjLswCAAB/1tVjrC917sHOgpUkvzCQSERG1De62n/7zn/+goaEBDz74IB588EEtPnHiRLz//vutvq7XJ8JMnToVU6dObXFbSw/Su3dvpKWlefiuiIiIiJqywQaDByfCuMOd9tO6devO4q6a83qj0VsuejQQIQFmBL92AgCwuzhM21ZQI3vt37hQZRCr6mUtyB+LVXmdVXny47unm6r9mFcjj6lsUKV0+ofIOksZpWpCTh97VW+fYpV+fCPn+d/wROdOS+MXWYybiIhI33TbaCQiIiJyh2MUoifO2x54dSIMEREREbUPus00VizNgcFkwo4iOWg0vUR1v96YIEvo5FSprmiLfc3pviGqvM7+MnnM3vIgLfbVUbkO9KVO9TIPVslu6R3FapWYvHq5Es1XFz+qrvvTywAAIc7fbxzsaiYiImodm8EGgwfqNHqiYLgnMNNIRERERC7pNtNYU2GC0c+En+wTUW7prGoVzd0lM4w3dVZt6jIh31c0qNi93WW28KMjKtMYYp//sqtE/dYwqWstAKCgNlCLXWQMAwC8tr9aizkyjC2tJd1SDSdHlrC1a0C3pKUJLi2djxlJIiLSu7Y0e9obdNtoJCIiInIHG406FRBeh0CTwLT+uQCAn/M6advuSJF/Fzkt8VdWL9/XO32ve8tlRvJEtcrC3ZLkY99fZSRf2Svff1s2V4tFhQwCAFyI4c3uzTmr6G428UwZQVcZRGYYiYiI6HR022gkIiIicofeS+7ottFoCgVMZmDZ1gQAQIxZzWyubpSZwdpGlWnsEyxnTa85oYp2R5nl9h6hKkN3XA5fxJYTKkP3dcmLAIBHk1Wx8Fj72+dzPnT73luTTWxpH1dZQ2YViYiI6HR022gkIiIicocNjTCg0SPnbQ9YcoeIiIiIXNJtptE0cThMQf7ouuEIAGBLoeo6Lq6zl75xqnzTIGS39F3JqjSPzV4ax2hQJXeWH5VdvM9cUKfF5l8wBwDwzyOztNiE2NkAgMrqA1rsbLuW2a1MRETkeQLCQ2Mam5fVa4uYaSQiIiIil3SbacTxE0CgBSfrZHbvb3OKtE0THgsDAAQ6VaD51Z5g3FkSrMVuTJBjEEqdyuuMT5If6YIDasJMWu1WAMADTpdfnD+72S0xY0hERNR26X0ZQf02GomIiIjcICfCnPtO2vYyEUa3jcaGrVlosJhQbO0KACj+Wo1VjPaPAACkBKkxBo7xjVP/qX5YFsyQwZwqdd77hx8GAARkJmuxkJPDAAC3Rv1Vi/UNl2nMOQee/a2PQkRERORxum00EhEREbnHM8W90U66pzkRhoiIiIhc0m2mUdTaIIQNKYFy8slrP3XVtl0VLcvlfHrEV4sZfWRXtOUx1WX95VG536DIAC32/Hc9AAD51eq3hsX5qlvaXWcqw0NERETnj000whP5Nnneto+ZRiIiIiJySbeZRt8wI3wtRpRYZTaxT4hae/r7Alkup7S+RovdlSJjFQ2qnd03zB8AkFWhjk0IlOdrqaTO2WCGkYiIqG0QHhrT6JlxkuceM41ERERE5JJuM40f/V9n+PuaUWYvzJ3oX6ttCzfJbOFH1+dpsVV7uwAAtp5UYxoTA+Wxsf5q7GOoU0FwIiIi6jgEGiE8kG8TrNNIRERE1HHIlVv0uyIMu6eJiIiIyCXdZhrHpR5GiMmEqmIzAGDhri7atkJ7T/XkbxO1WEKA/Kge6V2ixVbnhwMAkgPVbwh+9pVjxkWqlV6WFj1/bm+eiIiIzjsB4aGJMML1Tm0AM41ERERE5JJuM431VUZYrUZsPxYDAIgwqVZ+dqX8u2eoSYudrJHbK+rVTJcCe0ay1Komwrx4SGYYJ3rkromIiMhbhGiEgMEj520PmGkkIiIiIpd0m2kMu8wfIf4mHNsts4kbT6gxCo53wX4qg/jyVUcAAN8f6KzFegTL7OPhSs/eKxEREXkfZ08TEREREbmg20wjERERkTtkcW8PjGlkce+27cN3O8Hf14ykgDoAwAmrWj86ys8CAEgKUvvP2ZwCAEiNUCnkk3XyB2dfmdXTt0tEREReJoSH1p4W7J4mIiIiog5Ct5nGC8PKEWQ0w99PZhgHhkdp2wKNMoPYM6hGi2UUySLgm06qtHRioHy/vOgFj98vEREReRcnwhARERERuaDbTGODzQf1Nh8cKwsBAAyJVGMaj9XIj6WyQZXcsdizj92D1TlqGtvHsj9ERET027G4NxERERGRC7rNNBIRERG5Q0B4ZvY02kfPpW4bjYPGlCLEYsK/308CANzeJ1vbtupQIgBgc6FaZzq7Uk6KqWkwa7FJXWvPx60SEREReZ1uG41ERERE7pB1Gj0xprF9zJ7WbaOx+qAVRhNQZ/+edh2P1rZtOSmHev4+UWUSfQ3+AICCGvXFLjggs45XefheiYiIqC1o9FBHMifCEBEREVEHodtMY0BffwRYTLjuUDEAIC0/Qtt2Qbj8PSLIT5XhCbEPb/T3VWV4nj/47Hm4UyIiImoLZDeyfrunmWkkIiIiIpd0m2n878ex8Pc1o29YBQBg2nUHtG0vr+wBADD5qDEG3YOajzeYnvQcAOD17L968laJiIioDWCmkYiIiIjIBd1mGomIiIjcYYMNBk9kGj1QMNwTdNtovOWPeQixmLDikxgAwPrVPbRtQyNlIe+XdgdqsYs7yQkwB8rVZPt3ctktTURERPqg20YjERERkTv0PqZRt43Gsox6CD8DLogsAQAYDeHatp+LZSHv8cn1WuyHIvn3O7mzzt9NEhERUZshhGeKcHvqvOcaJ8IQERERkUu6zTQuykiGxdeC+wdmAQB8S8K0bVFmmSY+Wac+Hj82r4mIiHRNQAAemLQiPLQ44bnGphARERERuaTbTCMRERGROzw1YYUTYdq4yYOyEOJnwi9ZcQCA7wvM2rbxXcoAAPvKg7RYtMUXRERERHql20YjERERkTuYadSpwASBQLPA7l9keZ1+oeoLO1AhM4w7ylR28aXDLORNRERE+qXbRiMRERGROzy13B+XEWzjDm4PQ5DRjCuiZXHvg07jF2saZYZxd0mtV+6NiIiI2h69d0+z5A4RERERuaTbTCMRERGRO/SeadRto7HRZkCjzYB1JyIAAOEmte6jI/16RYzFC3dGRERE1PbottFIRERE5B5PZQSZaWzTLEYbLMZGBBrlFzUy6bi27Y0dnQEAkeYWDyUiIiLSHd02GomIiIjcwTGNOnWoPBgBvmb0DakCALy5s4u2LSFAAAD2lAqv3BsRERFRW6PbRiMRERGRO1jcm4iIiIhcEkLAE5NW5HnbPt02GuP9qxFkbMSK3HAAgFktMw1fg/zy3j42yxu3RkRERNTm6LbRSEREROSeRgAGD5yXmcY2rd/oSoRYrOiyXa49/b89Sdo2q03+QEyIna3FFufPBhEREZFe6bbRSEREROQOWRrn3GcaOaaxnXj5h24AAKtNfWEldfL94nyOaSQiIiIC2GgkIiIiaiXPZBo5prGN+9cHibD4WnBfL7l84Mqjsdq2Odcd9NZtEREREbVJum00EhEREbnFQ2Ma0U7GNPp4+waIiIiIqO3TbaZxYFgNAo02ZJ6MBAAk+tdr2wLf/tBbt0VERERtlPDQ2ENPnfdc022jkYiIiMg9nAijS4N65SHEZMLibbLkToCv+sK+uuQZAMBN217wyr0RERERtTVeH9P41ltvISUlBRaLBampqdi4ceNp9123bh0MBkOz16+//noe75iIiIj0SchJK+f6dRaZRnfaTwCwfv16pKamwmKxoGvXrnj77bfdvqZXG42ff/45HnnkETz99NPIyMjA5ZdfjjFjxiAnJ+eMx+3btw95eXnaq0ePHm5f+6vMFCxN74rRiScwOvEETtb5aK9fykz4pcx0to9FRERE5DHutp+ysrJw/fXX4/LLL0dGRgaeeuopPPzww1iyZIlb1/Vqo/HVV1/FPffcg3vvvRd9+vTBa6+9hs6dO2P+/PlnPC46OhqxsbHay9fX9zzdMREREemX8MgfdzON7raf3n77bXTp0gWvvfYa+vTpg3vvvReTJ0/Gyy+/7NZ1vTam0Wq1Ij09HU8++WST+KhRo7Bly5YzHjtw4EDU1taib9++eOaZZzBixIjT7ltXV4e6ujrt32VlZQCAmkYZq2iwAgBqG2vVvdnk3+Xl5a1/ICIiIvIYx3+Tvb9Os+euf2q7w2w2w2w2N4mdTftp69atGDVqVJPYddddh4ULF6K+vh5+fn6tuj+vNRoLCwvR2NiImJiYJvGYmBjk5+e3eExcXBwWLFiA1NRU1NXV4cMPP8TIkSOxbt06XHHFFS0eM3fuXMyZM6dZfMbef8o3u05/j38Lndu6hyEiIqLzoqKiAqGhoef1miaTCbGxsadtn5wLQUFB6Ny5c5PYrFmzMHv27Caxs2k/5efnt7h/Q0MDCgsLERcX16p79PrsaYOh6dR1IUSzmEOvXr3Qq1cv7d9Dhw7F0aNH8fLLL5+20Thz5kzMmDFD+3dpaSmSkpKQk5Nz3n/o2oLy8nJ07twZR48eRUhIiLdv57zis/PZ9fbsgL6fn8/esZ5dCIGKigrEx8ef92tbLBZkZWXBarV67BottX9OzTI6c6f9dLr9W4qfidcajVFRUfD19W3WKi4oKGjWGj6TSy+9FB999NFpt7eU2gWA0NDQDvM/pLMREhKi2+fns/PZ9UjPz89n7zjP7s1kj8VigcVi8dr1Hc6m/dRSlrSgoABGoxGRkZGtvrbXJsKYTCakpqYiLS2tSTwtLQ3Dhg1r9XkyMjJanVYlIiIias/Opv00dOjQZvuvXr0agwcPbvV4RsDL3dMzZszA3XffjcGDB2Po0KFYsGABcnJyMGXKFACyazk3NxeLFy8GALz22mtITk5Gv379YLVa8dFHH2HJkiVuTxknIiIiaq/cbT9NmTIF//73vzFjxgzcd9992Lp1KxYuXIhPP/3Uret6tdE4fvx4FBUV4bnnnkNeXh769++PlStXIikpCQCQl5fXpOaQ1WrFX/7yF+Tm5sLf3x/9+vXD119/jeuvv77V1zSbzZg1a9YZxwl0ZHp+fj47n12P9Pz8fHZ9PrseuNt+SklJwcqVK/Hoo4/izTffRHx8PN544w384Q9/cOu6BuH9uetERERE1MZ5fRlBIiIiImr72GgkIiIiIpfYaCQiIiIil9hoJCIiIiKXdNdofOutt5CSkgKLxYLU1FRs3LjR27f0m23YsAE33XQT4uPjYTAYsHz58ibbhRCYPXs24uPj4e/vj6uuugq7d+9usk9dXR0eeughREVFITAwEL/73e9w7Nix8/gUZ2fu3Lm4+OKLERwcjOjoaIwdOxb79u1rsk9Hff758+fjwgsv1Ir3Dh06FN988422vaM+d0vmzp0Lg8GARx55RIt11OefPXs2DAZDk1dsbKy2vaM+t7Pc3FzcddddiIyMREBAAC666CKkp6dr2zvqZ5CcnNzsuzcYDHjwwQcBdNznpjZE6Mhnn30m/Pz8xDvvvCP27Nkjpk+fLgIDA0V2dra3b+03WblypXj66afFkiVLBACxbNmyJtvnzZsngoODxZIlS8TOnTvF+PHjRVxcnCgvL9f2mTJlikhISBBpaWli+/btYsSIEWLAgAGioaHhPD+Ne6677jqxaNEisWvXLpGZmSluuOEG0aVLF1FZWant01Gff8WKFeLrr78W+/btE/v27RNPPfWU8PPzE7t27RJCdNznPtW2bdtEcnKyuPDCC8X06dO1eEd9/lmzZol+/fqJvLw87VVQUKBt76jP7VBcXCySkpLEpEmTxI8//iiysrLEmjVrxMGDB7V9OupnUFBQ0OR7T0tLEwDE2rVrhRAd97mp7dBVo/GSSy4RU6ZMaRLr3bu3ePLJJ710R+feqY1Gm80mYmNjxbx587RYbW2tCA0NFW+//bYQQojS0lLh5+cnPvvsM22f3Nxc4ePjI7799tvzdu/nQkFBgQAg1q9fL4TQ3/OHh4eLd999VzfPXVFRIXr06CHS0tLElVdeqTUaO/Lzz5o1SwwYMKDFbR35uR2eeOIJcdlll512ux4+A4fp06eLbt26CZvNpqvnJu/RTfe01WpFeno6Ro0a1SQ+atQobNmyxUt35XlZWVnIz89v8txmsxlXXnml9tzp6emor69vsk98fDz69+/f7j6bsrIyAEBERAQA/Tx/Y2MjPvvsM1RVVWHo0KG6ee4HH3wQN9xwA6655pom8Y7+/AcOHEB8fDxSUlJw++234/DhwwA6/nMDwIoVKzB48GDceuutiI6OxsCBA/HOO+9o2/XwGQDQVkWbPHkyDAaDbp6bvEs3jcbCwkI0NjY2W8w7Jiam2SLeHYnj2c703Pn5+TCZTAgPDz/tPu2BEAIzZszAZZddhv79+wPo+M+/c+dOBAUFwWw2Y8qUKVi2bBn69u3b4Z8bAD777DNs374dc+fObbatIz//kCFDsHjxYqxatQrvvPMO8vPzMWzYMBQVFXXo53Y4fPgw5s+fjx49emDVqlWYMmUKHn74YW25ND18BgCwfPlylJaWYtKkSQD089zkXV5dRtAbDAZDk38LIZrFOqKzee729tlMmzYNO3bswKZNm5pt66jP36tXL2RmZqK0tBRLlizBxIkTsX79em17R33uo0ePYvr06Vi9ejUsFstp9+uIzz9mzBjt/QUXXIChQ4eiW7du+OCDD3DppZcC6JjP7WCz2TB48GC8+OKLAICBAwdi9+7dmD9/PiZMmKDt15E/AwBYuHAhxowZg/j4+Cbxjv7c5F26yTRGRUXB19e32W9TBQUFzX4z60gcsyrP9NyxsbGwWq0oKSk57T5t3UMPPYQVK1Zg7dq1SExM1OId/flNJhO6d++OwYMHY+7cuRgwYABef/31Dv/c6enpKCgoQGpqKoxGI4xGI9avX4833ngDRqNRu/+O+vzOAgMDccEFF+DAgQMd/nsHgLi4OPTt27dJrE+fPto6u3r4DLKzs7FmzRrce++9WkwPz03ep5tGo8lkQmpqKtLS0prE09LSMGzYMC/dleelpKQgNja2yXNbrVasX79ee+7U1FT4+fk12ScvLw+7du1q85+NEALTpk3D0qVL8f333yMlJaXJ9o7+/KcSQqCurq7DP/fIkSOxc+dOZGZmaq/BgwfjzjvvRGZmJrp27dqhn99ZXV0d9u7di7i4uA7/vQPA8OHDm5XV2r9/P5KSkgDo43/zixYtQnR0NG644QYtpofnpjbgfM+88SZHyZ2FCxeKPXv2iEceeUQEBgaKI0eOePvWfpOKigqRkZEhMjIyBADx6quvioyMDK2U0Lx580RoaKhYunSp2Llzp/jjH//YYhmGxMREsWbNGrF9+3Zx9dVXt4syDA888IAIDQ0V69ata1KKorq6Wtunoz7/zJkzxYYNG0RWVpbYsWOHeOqpp4SPj49YvXq1EKLjPvfpOM+eFqLjPv9jjz0m1q1bJw4fPix++OEHceONN4rg4GDt/8c66nM7bNu2TRiNRvG3v/1NHDhwQHz88cciICBAfPTRR9o+HfkzaGxsFF26dBFPPPFEs20d+bmpbdBVo1EIId58802RlJQkTCaTGDRokFaapT1bu3atANDsNXHiRCGELEExa9YsERsbK8xms7jiiivEzp07m5yjpqZGTJs2TURERAh/f39x4403ipycHC88jXtaem4AYtGiRdo+HfX5J0+erP0sd+rUSYwcOVJrMArRcZ/7dE5tNHbU53fU3vPz8xPx8fFi3LhxYvfu3dr2jvrczr766ivRv39/YTabRe/evcWCBQuabO/In8GqVasEALFv375m2zryc1PbYBBCCK+kOImIiIio3dDNmEYiIiIiOntsNBIRERGRS2w0EhEREZFLbDQSERERkUtsNBIRERGRS2w0EhEREZFLbDQSERERkUtsNBIRERGRS2w0ElGbNmnSJIwdO/aM+1x11VV45JFHzsv9EBHpFRuNROQxkyZNgsFg0F6RkZEYPXo0duzY4e1bIyIiN7HRSEQeNXr0aOTl5SEvLw/fffcdjEYjbrzxRm/fFhERuYmNRiLyKLPZjNjYWMTGxuKiiy7CE088gaNHj+LkyZMAgJ07d+Lqq6+Gv78/IiMjcf/996OysvK056uqqsKECRMQFBSEuLg4vPLKK832SU5OxosvvojJkycjODgYXbp0wYIFC5rsk5ubi/HjxyM8PByRkZG4+eabceTIEW37unXrcMkllyAwMBBhYWEYPnw4srOzAQC//PILRowYgeDgYISEhCA1NRU///zzOfi0iIjaLjYaiei8qaysxMcff4zu3bsjMjIS1dXVGD16NMLDw/HTTz/hiy++wJo1azBt2rTTnuPxxx/H2rVrsWzZMqxevRrr1q1Denp6s/1eeeUVDB48GBkZGZg6dSoeeOAB/PrrrwCA6upqjBgxAkFBQdiwYQM2bdqEoKAgjB49GlarFQ0NDRg7diyuvPJK7NixA1u3bsX9998Pg8EAALjzzjuRmJiIn376Cenp6XjyySfh5+fnmQ+NiKitEEREHjJx4kTh6+srAgMDRWBgoAAg4uLiRHp6uhBCiAULFojw8HBRWVmpHfP1118LHx8fkZ+fr53j5ptvFkIIUVFRIUwmk/jss8+0/YuKioS/v7+YPn26FktKShJ33XWX9m+bzSaio6PF/PnzhRBCLFy4UPTq1UvYbDZtn7q6OuHv7y9WrVolioqKBACxbt26Fp8rODhYvP/++7/twyEiameYaSQijxoxYgQyMzORmZmJH3/8EaNGjcKYMWOQnZ2NvXv3YsCAAQgMDNT2Hz58OGw2G/bt29fsXIcOHYLVasXQoUO1WEREBHr16tVs3wsvvFB7bzAYEBsbi4KCAgBAeno6Dh48iODgYAQFBSEoKAgRERGora3FoUOHEBERgUmTJuG6667DTTfdhNdffx15eXna+WbMmIF7770X11xzDebNm4dDhw6dk8+KiKgtY6ORiDwqMDAQ3bt3R/fu3XHJJZdg4cKFqKqqwjvvvAMhhNble6qW4kKIVl/31O5ig8EAm80GALDZbEhNTdUas47X/v37cccddwAAFi1ahK1bt2LYsGH4/PPP0bNnT/zwww8AgNmzZ2P37t244YYb8P3336Nv375YtmxZq++NiKg9YqORiM4rg8EAHx8f1NTUoG/fvsjMzERVVZW2ffPmzfDx8UHPnj2bHdu9e3f4+flpjTcAKCkpwf79+926h0GDBuHAgQOIjo7WGrSOV2hoqLbfwIEDMXPmTGzZsgX9+/fHJ598om3r2bMnHn30UaxevRrjxo3DokWL3LoHIqL2ho1GIvKouro65OfnIz8/H3v37sVDDz2EyspK3HTTTbjzzjthsVgwceJE7Nq1C2vXrsVDDz2Eu+++GzExMc3OFRQUhHvuuQePP/44vvvuO+zatQuTJk2Cj497/1d25513IioqCjfffDM2btyIrKwsrF+/HtOnT8exY8eQlZWFmTNnYuvWrcjOzsbq1auxf/9+9OnTBzU1NZg2bRrWrVuH7OxsbN68GT/99BP69Olzrj4yIqI2yejtGyCiju3bb79FXFwcACA4OBi9e/fGF198gauuugoAsGrVKkyfPh0XX3wxAgIC8Ic//AGvvvrqac/3j3/8A5WVlfjd736H4OBgPPbYYygrK3PrngICArBhwwY88cQTGDduHCoqKpCQkICRI0ciJCQENTU1+PXXX/HBBx+gqKgIcXFxmDZtGv785z+joaEBRUVFmDBhAk6cOIGoqCiMGzcOc+bMOevPiIioPTAIdwYJEREREZEusXuaiIiIiFxio5GIiIiIXGKjkYiIiIhcYqORiIiIiFxio5GIiIiIXGKjkYiIiIhcYqORiIiIiFxio5GIiIiIXGKjkYiIiIhcYqORiIiIiFxio5GIiIiIXPr/3iVDUGumbk4AAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(8, 6))\n", "grid_archive_heatmap(discriminator_archive, vmin=0.0, vmax=1.0)\n", "plt.title(\"Discriminator Evaluation\")\n", "plt.xlabel(\"Boldness\")\n", "plt.ylabel(\"Lightness\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Conclusion\n", "\n", "By searching the latent space of an MNIST GAN, CMA-ME found images of the digit eight that varied in boldness and lightness. Even though the LeNet-5 network had high confidence that these images were eights, it turned out that many of these images were highly unrealistic, given that when we evaluated them with the GAN's discriminator network, the images mostly received low scores.\n", "\n", "_In short, we found that large portions of the GAN's latent space are unrealistic_. This is not surprising because during training, the GAN generates fake images by randomly sampling the latent space from a fixed Gaussian distribution, and some portions of the distribution are less likely to be sampled. Thus, we have the following questions, which we leave open for future exploration:\n", "\n", "- How can we ensure that CMA-ME searches for realistic eights?\n", "- While searching for realistic eights, can we also search for other digits at the same time?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Citation\n", "\n", "If you find this tutorial useful, please cite it as:\n", "\n", "```text\n", "@article{pyribs_lsi_mnist,\n", " title = {Illuminating the Latent Space of an MNIST GAN},\n", " author = {Yulun Zhang and Bryon Tjanaka and Matthew C. Fontaine and Stefanos Nikolaidis},\n", " journal = {pyribs.org},\n", " year = {2021},\n", " url = {https://docs.pyribs.org/en/stable/tutorials/lsi_mnist.html}\n", "}\n", "```" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.17" } }, "nbformat": 4, "nbformat_minor": 4 }