Practical_Project.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/gerritgr/pokemon_diffusion/blob/main/Practical_Project.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wIdbJVP8INKR"
      },
      "source": [
        "# Pokemon Diffusion\n",
        "\n",
        "Repository for the practical projecto the [*Deep Generative Diffusion Models*](https://mosi.uni-saarland.de/lectures/22_2_deep_diffusion/) Seminar at Saarland University."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UtWpIsJoIQNY"
      },
      "source": [
        "## Rules ⚖️ \n",
        "\n",
        "### Formalities 📝 \n",
        "\n",
        "* The goal is to implement an end-to-end diffusion model on the CelebFace dataset.\n",
        "* You work alone or in groups of two.\n",
        "* Plagiarism will get you expelled from the seminar and potentially exmatriculated. However, you can discuss solutions with your fellow students and take inspiration from open-source implementations (see references). \n",
        "* You can also copy&pase small code snippets if they are clearly indicated.\n",
        "* We recommend Python + PyTorch for the implementation. If you want to use something else, please reach out to us. \n",
        "* Your code should run on Google Colab and normal desktop computers with minimal setup effort.\n",
        "* We will invite each team to explain their code in an individual meeting. You (resp. both of you) should be able to explain the code in detail and justify design choices.\n",
        "* Submit your results via e-mail to Gerrit.\n",
        "\n",
        "### How to Pass 🎓\n",
        "\n",
        "* To pass, you need to provide a (in a reasonable sense) technically correct implementation of a forward and backward process. You will not be judged on the visual quality of the generated images.\n",
        "* In addition, you should generate animations (e.g., gifs) of the forward and backward process to illustrate what is going on during training and data generation (cf. *one_step_forward()* function).\n",
        "* Comment your code extensively and assign proper names to your functions, variables, and classes. \n",
        "* Set seeds to make your code deterministic and save the final weights. \n",
        "* You should also visually verify that the forward process ends in a standard normal distribution by providing a reasonable visualization (analogously to *color_distribution_original_images.png*).\n",
        "* We recommend following the denoising diffusion paradigm. When you want to use score-based or SDE methods, you can do so as well. \n",
        "* If you make very unconventional design choices, you will need to be able to justify them. \n",
        "* Do you see any problems with your implementations or room to improve? Explain in a short paragraph (can be part of the notebook). \n",
        "* You can use this notebook or use your code from scratch. \n",
        "\n",
        "### Notes on the Reference Implementation 💻 \n",
        "\n",
        "* You will probably need to activate the GPU of Colab and use batched images when you want to be able to generate nice images (for passing, this is not necessary, though)\n",
        "* We use a simple linear schedular and batch size of 256. \n",
        "* We predict the original image and not the noise. \n",
        "* We use a Unet, inspired by _The Annotated Diffusion Model_.\n",
        "* We run at least for 1000 epochs.\n",
        "* The visual quality strongly depends on the complexity of the Unet. Do not worry if your generated images look more like blobs than actual Pokomen. For passing, a minimal Unet or Autoencoder is enough. \n",
        "* Of course, you can always test other (larger) datasets to play around with.\n",
        "\n",
        "### Bonus 🏆\n",
        "\n",
        "For a bonus (0.3 on your final grade), you can extend the implementation in any creative way. Possibilities include:\n",
        "* Smart data augmentation, extending the data set, or pre-training\n",
        "* Conditioning (e.g. on the Pokemon *type*)\n",
        "* Testing different network architectures, schedulers, or time-embeddings and reporting the findings.\n",
        "* Using a latent diffusion approach instead of diffusion in the RGB/image space.\n",
        "\n",
        "If you have any other idea you think is worth investigating: try it out!\n",
        "\n",
        "\n",
        "### References 📚\n",
        "Preliminaries 💡 \n",
        "* [10 tricks for a better Google Colab experience](https://towardsdatascience.com/10-tips-for-a-better-google-colab-experience-33f8fe721b82)\n",
        "* [Youtube: Deep Learning With PyTorch - Full Course (in case you need some PyTorch refreshments)](https://www.youtube.com/watch?v=c36lUUr864M&ab_channel=PatrickLoeber)\n",
        "* [UvA PyTorch Tutorial](https://uvadlc-notebooks.readthedocs.io/en/latest/tutorial_notebooks/tutorial2/Introduction_to_PyTorch.html)\n",
        "\n",
        "Diffusion 🧨\n",
        "* [Tiny Diffusion Repo by tanelp (minimal example of a 2D diffusion)](https://github.com/tanelp/tiny-diffusion)\n",
        "* [Youtube: Diffusion models from scratch in PyTorch](https://www.youtube.com/watch?v=a4Yfz2FxXiY&t=644s)\n",
        "* [Youtube: Diffusion Models | PyTorch Implementation](https://www.youtube.com/watch?v=TBCRlnwJtZU&ab_channel=Outlier)\n",
        "* [The Annotated Diffusion Model](https://huggingface.co/blog/annotated-diffusion)\n",
        "* [U-Net: A PyTorch Implementation in 60 lines of code](https://amaarora.github.io/2020/09/13/unet.html)\n",
        "\n",
        "Pokemon 🐲\n",
        "* [Pokemon Images Dataset on Kaggle](https://www.kaggle.com/datasets/kvpratama/pokemon-images-dataset)\n",
        "* [PokeGAN: Generating Fake Pokemon with a Generative Adversarial Network](https://blog.jovian.com/pokegan-generating-fake-pokemon-with-a-generative-adversarial-network-f540db81548d)\n",
        "* [pokemon-ga by Zhenye Na (contains the dataset we are using)](https://github.com/Zhenye-Na/pokemon-gan)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X-cAurcjOGTe"
      },
      "source": [
        "## Files 📁\n",
        "* `color_distribution_original_images.png`: RGB value disribution of the trainings data\n",
        "* `dataset_summary.png`: Some (augmented) images from the trainings data\n",
        "* `forward_animate.gif`: Animation of an (incorrect) forward process. \n",
        "* `forward_grid.png`: Imagegrid of an (incorrect) forward process. \n",
        "* `reverse_process_reference_epoch_X.gif`: Examples of the reverse process of the reference implementation after X epochs\n",
        "* `color_distribution_normal_reference.png`: RGB value disribution of the trainings _after_ the forward process"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tbGy2MX29yd2"
      },
      "source": [
        "# Setup"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6gy0_7tz-R88"
      },
      "source": [
        "### Downloading the Data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c7HjP8HYHw4x",
        "outputId": "88f77d43-ff7b-4118-85f1-f623ad1535ff"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cloning into 'pokemon_diffusion'...\n",
            "remote: Enumerating objects: 987, done.\u001b[K\n",
            "remote: Counting objects: 100% (65/65), done.\u001b[K\n",
            "remote: Compressing objects: 100% (65/65), done.\u001b[K\n",
            "remote: Total 987 (delta 32), reused 3 (delta 0), pack-reused 922\u001b[K\n",
            "Receiving objects: 100% (987/987), 45.15 MiB | 11.08 MiB/s, done.\n",
            "Resolving deltas: 100% (32/32), done.\n"
          ]
        }
      ],
      "source": [
        "# If we are on Colab, we need to get the data\n",
        "import sys\n",
        "IN_COLAB = 'google.colab' in sys.modules\n",
        "if IN_COLAB:\n",
        "  !git clone https://github.com/gerritgr/pokemon_diffusion\n",
        "  #!mkdir pokemon\n",
        "  !cp -r pokemon_diffusion/pokemon pokemon/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h09oqw31-TWm"
      },
      "source": [
        "### Imports"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EUA6qMFg-U3b"
      },
      "outputs": [],
      "source": [
        "%matplotlib inline\n",
        "import matplotlib.pyplot as plt\n",
        "plt.rcParams['figure.dpi'] = 100 # Set this to 300 to get better image quality\n",
        "from PIL import Image # We use PIL to load images\n",
        "import seaborn as sns\n",
        "import imageio # to generate .gifs\n",
        "\n",
        "# always good to have\n",
        "import glob, random, os\n",
        "import numpy as np\n",
        "\n",
        "# the typical pytorch imports\n",
        "import torch\n",
        "import torchvision\n",
        "from torchvision import transforms \n",
        "from torch.utils.data import DataLoader\n",
        "import torch.nn.functional as F\n",
        "from torch import nn\n",
        "from torch.nn import Conv2d\n",
        "from torch.optim import Adam"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "si5hv_8E-bWc"
      },
      "source": [
        "### Hyperparameters\n",
        "\n",
        "These are just random hyperparameters, play around with them."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y63rkzBV-UGw",
        "outputId": "108fcb48-5901-4d4f-fb1a-aea07db9ca61"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cuda')"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ],
      "source": [
        "IMG_SIZE = 32   # We assume images are square with IMG_SIZE*IMG_SIZE pixels, 16x16 works, too.\n",
        "EPOCHS = 5000\n",
        "BATCH_SIZE = 256\n",
        "TIMESTEPS = 100\n",
        "\n",
        "# On Colab, go to Runtime -> Change runtime type to switch to GPU \n",
        "DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "CHANNELS = 3  # We use RGB images\n",
        "DEVICE"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9JB6wRKO_n_D"
      },
      "source": [
        "### Seeds\n",
        "... to make everyting deterministic."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kzHs5IGd_ph1"
      },
      "outputs": [],
      "source": [
        "np.random.seed(42)\n",
        "torch.random.manual_seed(42)\n",
        "random.seed(42)\n",
        "torch.cuda.manual_seed_all(42)\n",
        "os.environ['PYTHONHASHSEED'] = '42'\n",
        "torch.backends.cudnn.deterministic = True"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Nkrw3DZTeRo"
      },
      "source": [
        "### Utils"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Zhgi4noSVfy"
      },
      "source": [
        "We start by defining some friendly little helpers. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Q-lk-cItTffa"
      },
      "outputs": [],
      "source": [
        "def image_to_tensor(image):\n",
        "    \"\"\"Convert a PIL image to a PyTorch tensor.\n",
        "\n",
        "    Args:\n",
        "        image (PIL.Image): The image to be converted.\n",
        "\n",
        "    Returns:\n",
        "        torch.Tensor: The converted PyTorch tensor.\n",
        "    \"\"\"\n",
        "    # Define the image transformation pipeline\n",
        "    transform = transforms.Compose([\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Resize((IMG_SIZE, IMG_SIZE)),\n",
        "        transforms.Lambda(lambda t: (t - 0.5) * 2.)\n",
        "    ])\n",
        "\n",
        "    # Apply the transformation pipeline to the image\n",
        "    return transform(image)\n",
        "\n",
        "\n",
        "def tensor_to_img(tensor):\n",
        "    \"\"\"Convert a PyTorch tensor to a PIL image.\n",
        "\n",
        "    Args:\n",
        "        tensor (torch.Tensor): The PyTorch tensor to be converted.\n",
        "\n",
        "    Returns:\n",
        "        PIL.Image: The converted PIL image.\n",
        "    \"\"\"\n",
        "    # Define the tensor transformation pipeline\n",
        "    transform = transforms.Compose([\n",
        "        transforms.Lambda(lambda t: (t + 1.) / 2.),\n",
        "        transforms.Lambda(lambda t: torch.clamp(t, min=0., max=1.)),\n",
        "        transforms.ToPILImage()\n",
        "    ])\n",
        "\n",
        "    # Apply the transformation pipeline to the tensor\n",
        "    return transform(tensor)\n",
        "\n",
        "\n",
        "def show_from_image_list(img_list, img_num=10, filename=None):\n",
        "    \"\"\"Show a grid of images from a list of images. Sample uniformly spaced images.\n",
        "        (Alternativly, use make_grid from torchvision.utils)\n",
        "\n",
        "    Args:\n",
        "        img_list (list): The list of images to be displayed. Can be PIL or image tensors.\n",
        "        img_num (int, optional): The number of images to be displayed. Default is 10.\n",
        "        filename (str, optional): The name of the file to save the plot to. If None, the plot will not be saved. Default is None.\n",
        "    \"\"\"\n",
        "    # Ensure that the number of images to be displayed is less than or equal to the number of images in the list\n",
        "    img_num = min(len(img_list), img_num)\n",
        "\n",
        "    # Get the index of the images to be displayed\n",
        "    img_num_index = np.linspace(0, len(img_list)-1.0, num=img_num).astype(int)\n",
        "\n",
        "    # Clear the current figure (if there is any)\n",
        "    plt.clf()\n",
        "\n",
        "    # Create a figure with 1 row and `img_num` columns\n",
        "    fig, ax = plt.subplots(1, img_num, figsize=(15, 15), gridspec_kw={'width_ratios': [1] * img_num})\n",
        "\n",
        "    # Iterate through the images to be displayed\n",
        "    for i, idx in enumerate(img_num_index):\n",
        "        img_i = img_list[idx]\n",
        "\n",
        "        # Check if the image is a PyTorch tensor and convert it to PIL\n",
        "        if isinstance(img_i, torch.Tensor):\n",
        "            img_i = tensor_to_img(img_i)\n",
        "\n",
        "        # Display the image\n",
        "        ax[i].imshow(img_i)\n",
        "        ax[i].axis('off')\n",
        "\n",
        "    # Save the plot to a file if the filename is provided\n",
        "    if filename is not None:\n",
        "        plt.savefig(filename, dpi=300, bbox_inches='tight')\n",
        "\n",
        "    # Show the plot\n",
        "    plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PWDpwe0h--LV"
      },
      "source": [
        "# Defining the Dataset and Loader"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ny8wyF9g40gG"
      },
      "source": [
        "First, we need to create a `Dataset` and a `DataLoader` containing the images (currently in the image folder). This is PyTorch best practice.\n",
        "\n",
        "The `Dataset` provides access to individual data samples/images  (also providing on-the-fly image augmentation). The `Dataloader` enables efficient loading of the data in mini-batches (also providing randomization).\n",
        "\n",
        "We build our own `Datset` class that loads the images from disk and stores them in PyTorch tensors of shape $(3, \\text{IMG_SIZE}, \\text{IMG_SIZE})$ with values between $-1$ and $1$.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NL8dCnIZgBvw"
      },
      "outputs": [],
      "source": [
        "from torch.utils.data import Dataset, DataLoader, IterableDataset, TensorDataset\n",
        "\n",
        "\n",
        "class ImageDataset(Dataset):\n",
        "  \"\"\"A dataset for images that supports on-the-fly transformations (i.e., augmentations).\n",
        "\n",
        "  Args:\n",
        "      imgpaths (str, optional): The path pattern for the images. Default is \"pokemon/*png\".\n",
        "  \"\"\"\n",
        "\n",
        "  def __init__(self, img_paths=\"pokemon/*png\"):\n",
        "\n",
        "    # You can/should play around with these. Which of the augmantation make sense? \n",
        "    self.on_the_fly_transform = transforms.Compose([\n",
        "    transforms.RandomHorizontalFlip(0.5),\n",
        "    transforms.RandomApply(torch.nn.ModuleList([transforms.RandomCrop(int(IMG_SIZE*0.8)),]), p=0.1),\n",
        "    transforms.RandomAutocontrast(p=0.1),\n",
        "    transforms.Resize((IMG_SIZE, IMG_SIZE)),\n",
        "    transforms.Lambda(lambda t: torch.clamp(t, min=-1., max=1.)),\n",
        "    ])\n",
        "\n",
        "    self.img_list = list()\n",
        "    for img_path in glob.glob(img_paths):\n",
        "      # Turn the transparent part in the image to white following \n",
        "      # https://stackoverflow.com/questions/50898034/how-replace-transparent-with-a-color-in-pillow\n",
        "      image = Image.open(img_path)\n",
        "      rgba_image = Image.new(\"RGBA\", image.size, \"WHITE\")\n",
        "      rgba_image.paste(image, (0, 0), image)   \n",
        "      rgb_image = rgba_image.convert('RGB')\n",
        "\n",
        "      # Convert the PIL image to a tensor, where each value is in [-1,1].\n",
        "      img_as_tensor = image_to_tensor(rgb_image)\n",
        "      self.img_list.append(img_as_tensor)\n",
        "\n",
        "  def __getitem__(self, index):\n",
        "    \"\"\"Get an image tensor from the dataset with on-the-fly transformation.\n",
        "\n",
        "    Args:\n",
        "        index (int): The index of the image tensor in the dataset.\n",
        "\n",
        "    Returns:\n",
        "        torch.Tensor: The image tensor with on-the-fly transformation.\n",
        "    \"\"\"\n",
        "    img = self.img_list[index]\n",
        "    img = self.on_the_fly_transform(img)\n",
        "\n",
        "    return img\n",
        "  \n",
        "  def get_pil_image(self, index, with_random_augmentation=True):\n",
        "    \"\"\"Get a PIL image from the dataset with or without on-the-fly transformation.\n",
        "\n",
        "    Args:\n",
        "        index (int): The index of the PIL image in the dataset.\n",
        "        with_random_augmentation (bool, optional): Whether to apply on-the-fly transformation. Default is True.\n",
        "\n",
        "    Returns:\n",
        "        PIL.Image: The PIL image with or without on-the-fly transformation.\n",
        "    \"\"\"\n",
        "    if with_random_augmentation:\n",
        "      return tensor_to_img(self.__getitem__(index))\n",
        "    return tensor_to_img(self.img_list[index])\n",
        "\n",
        "  def __len__(self):\n",
        "    return len(self.img_list)\n",
        "\n",
        "\n",
        "dataset = ImageDataset()\n",
        "\n",
        "dataloader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z1JYwUaJaeWM",
        "outputId": "4a1e3974-3b54-49fe-9703-8e42a9a527b7"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(True)"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ],
      "source": [
        "# Note hat just grabbing an image from the dataset adds a random image augmentation.\n",
        "# Generally speaking, this will be False. Try a few times.\n",
        "torch.all(dataset[0] == dataset[0])  # torch.all test if all entries are True"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iD8AuyJSasvX"
      },
      "source": [
        "### Inspecting the Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 960
        },
        "id": "zv13sOvtwkLS",
        "outputId": "0f894114-19ab-43aa-e881-6c91ac928e37"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 4500x1500 with 21 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAADVcAAASACAYAAABBKJzvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAACmcklEQVR4nOzdeZxkdXku8FPdPfu+MAMIDLIvojCAMLIrCARFzFVR4xY1imbRqMEtRo1xwWiiWQANMXohKoqKW8AFUQQHFBBFQHZmgIEZZobZ1+6u+8e9N/fmE+E8NVM91VW/7/fv5/OeM93V9Zxzut+pRrPZrAAAAAAAAAAAAAAAAABK09fpEwAAAAAAAAAAAAAAAADoBMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUKSBFrLNETsLgN7U6PQJwHbQ+wCt0ft0O90P0BrdTzfT+wCt0ft0M70P0Bq9T7fT/QCt0f10M70P0Jra3vfJVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFCkgU6fQLtd8Mo/jHJvuvjfRvhMAACAJ+K6HQDKovuBVnnfAACA0c91OwCURfcDQDlK7H2fXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFCkgU6fQLut37I5yn3vI5fFM099z4u29XQAAKAYrVxjp9ftAMDopfuBkeRZPwAAdIb7fQAoi+4HgHLo/Sfnk6sAAAAAAAAAAAAAAACAIlmuAgAAAAAAAAAAAAAAAIpkuQoAAAAAAAAAAAAAAAAokuUqAAAAAAAAAAAAAAAAoEiWqwAAAAAAAAAAAAAAAIAiWa4CAAAAAAAAAAAAAAAAimS5CgAAAAAAAAAAAAAAACiS5SoAAAAAAAAAAAAAAACgSJarAAAAAAAAAAAAAAAAgCI1ms1mmo2D3eB7H70szk5b95sod/SHP7CNZwP0qEanTwC2Q0/1PrB9rn/vB6Lc6slPi2ee+u4XbePZjFp6n26n+4H/pPsjup9u1lO971k/sAPofbpZT/U+sH3c70f0Pt1O9wP/SfdHdD/dTO8D/0nvR2p73ydXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFKnRbDbTbBzsBu+ef1KcPX7OvCj388bcKPf+K86Ljw10tUanTwC2Q0/1PvDfffD0d8bZZzaXRrlrli2KZ3705qvjbJfQ+3Q73Q89Tve3ne6nm/VU73vWD+wAep9u1lO9D/x37vfbTu/T7XQ/9Djd33a6n26m96HH6f22q+19n1wFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABRpIA1e+6VLo1zfb+6ID75m0sFRrn/FTfHMUz75sSj30Zuvjmf+y9mfjnLjF38vngkAAJ00ftWtcfahPU6Nch+98vPbeDZP7Advf1ecHZp1eJSbuv62eObw0w6Mcse+7Ox4JgB0gu7P6H5K4Fl/Pc/6AQDoFu73M+73AegVuj+j+wHoBXo/087e98lVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARWo0m800GwdTV1z+3Si35TNfjWdumvCUKHfj6lXxzGnr7olyh8zcOco9Nm1+fOwNgxuj3J9d9q54ZupFL/y9OPvWA4+Mcv1jBuKZjaHhKHf037w/ngk7WKPTJwDboe29D+1w/V9+MMo1+/P/Q2Bo62CU+9Qdv4hnXvaN/4izqX940cei3MSBCVFup9U3x8e+deWjUW715H3imUdMmx7lxm98OJ459o0vjnKnn3VGPLMFep9up/sZlXR/Pd1fT/fDf+NZfw3P+ut51k9h9D7dzP0+o5L7/Xru9+u534ffSfczKun+erq/nu6H/0bvMyrp/Xp6v16net8nVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARWo0m800Gwc76aKXfjrK3bHstnjm6qW/inJn7XFglFs6bX5+7GU3R7l9x8Ujq/5wp26oGo5nNuJcmqyqRviSGxg3EOWee/lF8bGhTfIXPIw+XdH79I7vn/X6KDe4eTDKNVt4C26GL/dWfihG4nrr7s1Zbtqc7Fpz7ursOrOqquryxXdkx577jHjmgXMOjnKv//Jb4pkdpvfpdrqfHUr319P9o57up5t1Re971l/Ps37YYfQ+3awrep/e4X6/nvv9UU/v0+10PzuU7q+n+0c93U830/vsUHq/nt4f9WpfdD65CgAAAAAAAAAAAAAAACiS5SoAAAAAAAAAAAAAAACgSJarAAAAAAAAAAAAAAAAgCJZrgIAAAAAAAAAAAAAAACKZLkKAAAAAAAAAAAAAAAAKJLlKgAAAAAAAAAAAAAAAKBIlqsAAAAAAAAAAAAAAACAIlmuAgAAAAAAAAAAAAAAAIpkuQoAAAAAAAAAAAAAAAAoUqPZbKbZONgN/uiZp8TZRphb1z83yk0eWhof+6xZu0W5/nhiVaXfyuFWvuPhF+mLDy2KRz7naf8jys1adWOUm/auP4yPffwJJ8RZeBLp2weMRj3V+3TGNT/5SZxd/bF/i3Irph8R5a76zdfiY798t3lZsIWfir64AfKqGApzl694KMql165VlV+/tvLG8S8//0EL6a6g9+l2up/tpvsTur+H6H66WU/1vmf99Tzrh+2m9+lmPdX7dIb7/YT7/R6i9+l2up/tpvsTur+H6H66md5nu+n9hN7vIbXfTJ9cBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUKRGs9lMs3Gw1xy396FR7sjjnx3l7rnhp/Gx3zDv4Ch30aQV8czhqhHlNq5eG8/8k4E9otxj0+bHM+9ccnOUO2ZSOjH7d1dVVZ11xefjLDyJ/EUHo0+xvU/7XH76a1pIZy+569Zn0/bfNb/m2Gl1ds3xT4OL45kTpk2Jcn0t/Ki9fv2sKPfZRbdFuX2OOi4+9i+u+VGU++m9t8Qze5Dep9vpfrab7q+n+3uK7qebFdv7nvXX86wffie9TzcrtvdpH/f79dzv9xS9T7fT/Ww33V9P9/cU3U830/tsN71fT+/3lNre98lVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRGs1mM83GQZ7cj978jji79r7HotxlO2+OZ37ilXtFuTdceFs887TG8VFuj7W/iWc245dcI0q1skm49ujsa3T2+9/XwlQKlL04YXTS+zyhSz/4oSg35fr74pnDcTJ7aTZaeAtePOVpUe7K5jXxzM+ec3CUe8fF+dfoRY+Oi3JT9topyj37/E/Exyai9+l2up8npPvr6f4i6X66md5vE8/6M5710wP0Pt1M7/OE3O/Xc79fJL1Pt9P9PCHdX0/3F0n30830Pk9I79fT+0WqfdH55CoAAAAAAAAAAAAAAACgSJarAAAAAAAAAAAAAAAAgCJZrgIAAAAAAAAAAAAAAACKZLkKAAAAAAAAAAAAAAAAKJLlKgAAAAAAAAAAAAAAAKBIlqsAAAAAAAAAAAAAAACAIlmuAgAAAAAAAAAAAAAAAIpkuQoAAAAAAAAAAAAAAAAokuUqAAAAAAAAAAAAAAAAoEiWqwAAAAAAAAAAAAAAAIAiNZrNZpqNgzy5K57/ujh74YQVUW7dmrXxzE0bNmTBRiOeuWb1mij36onz4pkHTZsT5ZZOnx/PTD206SdR7n3fuKztx6an5D9EMProfZ7Qh174oii32/gT2n7suatujnK3r14Wz/zChkVRbuq0qfHMKrzGHj9xYjxy8tQpUe6cjbOi3Onf/tf42ET0Pt1O9/OEdH9A95dI99PN9H6beNaf8ayfHqD36WZ6nyfkfj/gfr9Eep9up/t5Qro/oPtLpPvpZnqfJ6T3A3q/RLW975OrAAAAAAAAAAAAAAAAgCJZrgIAAAAAAAAAAAAAAACKZLkKAAAAAAAAAAAAAAAAKJLlKgAAAAAAAAAAAAAAAKBIlqsAAAAAAAAAAAAAAACAIlmuAgAAAAAAAAAAAAAAAIpkuQoAAAAAAAAAAAAAAAAokuUqAAAAAAAAAAAAAAAAoEiWqwAAAAAAAAAAAAAAAIAiNZrNZpqNgzy5Y098Vpy99sc/i3IL9lkQzzz/q+dHuT996x/HM6vwdfS8LdPjkTdu7I9yr911pyh305q18bHfd91lcRaeRKPTJwDbQe+z3T50zIvi7OFTp0S5zy15LModMWEoPvZ3xq7Kgo38bf0fP/XPUe7NL35zPHPhPQujXHqtmV5nEtP7dDvdz3bT/fV0f0/R/XQzvd8mnvVnPOunB+h9upneZ7u536/nfr+n6H26ne5nu+n+erq/p+h+upneZ7vp/Xp6v6fUvkB8chUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRGs1mM83GQUa3P1jwiii3aOy98cwPnP6OKHfz5RfFMw+ZMTfKNatGlLu6WhYf+2+v+G6chSeRvThhdNL7bLe/OP2MOHtSNSfKNcKX5q2PL42PPf+s10e5D1zxiXjmvC17R7l/X3hJPJNRT+/T7XQ/203319P9PUX30830fo/wrL+eZ/20id6nm+l9tpv7/Xru93uK3qfb6X62m+6vp/t7iu6nm+l9tpver6f3e0pt7/vkKgAAAAAAAAAAAAAAAKBIlqsAAAAAAAAAAAAAAACAIlmuAgAAAAAAAAAAAAAAAIpkuQoAAAAAAAAAAAAAAAAokuUqAAAAAAAAAAAAAAAAoEiWqwAAAAAAAAAAAAAAAIAiWa4CAAAAAAAAAAAAAAAAimS5CgAAAAAAAAAAAAAAACiS5SoAAAAAAAAAAAAAAACgSAOdPgF2vMc335MFx+a7dx+48pNR7twZ+8UztzTT5HCUOuvwI+NjAwDb76z5efcuv+n+MNmIUgfMmBsfO72OSY9dVS1cbwFAD9H9ALBjedYPAOwI7vcBoCy6HwDKoffhv/LJVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEUa6PQJ0B6vPvoFcXZ5tTnKzd1p93jmqdUxUa65/vZ45uMzjoxyj664I8odVzXjYwMA7ZB37x3Dk6PczrMOjHIzVv0iPvZLZ2fXUd+rrotnLl37YJRr5RruC9d/M84CQGfo/jq6H4A6nvXX86wfAHY09/t13O8D0Ft0fx3dD0Dv0Pt19H5ZfHIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFCkgU6fAE/urrvuinLLH7s7nrnz/H2j3BE7HxLPvPXH34pyu++2TzxzsDkc5XaasV+UO+bDb4mPTfuc96zT4+w7f3bFCJ7Jk3v+3gfl2T0OiHJvuPrr23o60HGfPen3o9y3F/82nvnte2/f1tPZbt3yXtRrjvnwB+Psb8/+dJRLrw9aceud2XXMkSeeFM+8sdGIcstvzq/h0uvC/fbLro0A/n+6n3bQ/fV0P0C5POuv51n/6NYt19ie9cN/5X6fdnC/X8/9PjBa6H7aQffX0/3AaKD3aQe9X0/vl8UnVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARWo0m800Gwdpn899/O+i3OW/+Ek+NPyeDw8PxiNXrlgZ5c6duH88Mz3PqzYviXL/ePUP82NT66MLToty7154ZduP/aYXnR1nt/72/ig3a+7h8czzrrogjTbioTD6RG/C73zOm+KBK5beFOXGHPDUeOYFl10aZ1OdfH8r2Z+edHKUe864XbOBjfwt+OMb7oxyM2fNjGf29Q1kwRbO86wjT4hyrz33bfFM2krv0+10fw3d3166v57uH/V0P93Ms/4O8Ky/nmf9neFZf0Tv083c79dwv99e7vfrud8f9fQ+3U7319D97aX76+n+UU/30830fg293156v57eH/Vqv5k+uQoAAAAAAAAAAAAAAAAokuUqAAAAAAAAAAAAAAAAoEiWqwAAAAAAAAAAAAAAAIAiWa4CAAAAAAAAAAAAAAAAimS5CgAAAAAAAAAAAAAAACiS5SoAAAAAAAAAAAAAAACgSJarAAAAAAAAAAAAAAAAgCJZrgIAAAAAAAAAAAAAAACKZLkKAAAAAAAAAAAAAAAAKJLlKgAAAAAAAAAAAAAAAKBIA50+gRKd8z9eEmd3W7I6Cz5l/DaezRNr9OUvj3dNPKDtx79jeEKUW9U/o+3HLtVec/aIs2cc9NwRPJMnN+XxmXF2+pTsZ+g9V12wracDRTuvhZ+djyw4LcqtauFnfCQsGbdblEvfM+9btnh7TqcYaZ/fOTwxyh3Yvyk+dnod8y99K+OZsWYeXfKN70W5c264Pspd+LWv5AcH+D90fz3dn9H99XQ/wOjnWX/Gs/4dz7N+oFXu9+u538+436/nfh8YDXR/Pd2f0f31dD/QaXq/nt7P6P16er/7+eQqAAAAAAAAAAAAAAAAoEiWqwAAAAAAAAAAAAAAAIAiWa4CAAAAAAAAAAAAAAAAimS5CgAAAAAAAAAAAAAAACiS5SoAAAAAAAAAAAAAAACgSJarAAAAAAAAAAAAAAAAgCJZrgIAAAAAAAAAAAAAAACKZLkKAAAAAAAAAAAAAAAAKJLlKgAAAAAAAAAAAAAAAKBIjWazmWbjIE/uLUedEmcX7Tk5yrXwfawaVSPK7blkfTzzlClPiXLLpx8ez9xl1Y1RbtGcaVFu69Dq+NhvvuTzcbaTPrrg9DCZvT7uHxqKj33EgXtEuVWNGfHMwTtvy2ZOnBfP/PhVF8bZEZD9sMHo1LHeP/c558TZ6RsWRbmB/Q/OZzYfj3I33rE4yj21vz8+dvq28e6FV7Qws3POf8Vr4uyY/qzP5y3L+vyR6UfEx5696qYo94O1D8czH9h1UpRrtvCj1mhkr495D6yLcp++4QfxsYnofbqd7q+h++vp/nq6v6fofrqZZ/1t4ll/xrP+ep711/OsH7aZ+/0a7vfrud+v536/p+h9up3ur6H76+n+erq/p+h+upner6H36+n9enq/p9R+g3xyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEazWYzzcbBUv3Fc94U5W597L545pz5M6Pc1sFN8cwxA+Oj3HO2HBPPXL3ijig3ubE5ntk349Aot2LpD6LcQeOyr2VVVdWYcQNRbtKBu8Yz19y3LMpN3XtOPHPj0lVR7p7BdVFu12VD8bHHTp8Q5Tat2hjPvHbLuCg3dcMD8cy/XPi9ODsCGp08OGynjvX+3yw4Nc6umbhnlDt2bN4/48P3ty3h+9uSOf3xsfcZmBzlJsydHs9cc2/YP3vl/bP+jiVRbuvmwXjm7ZtXRrlZc0+JcsOP3xIfe10z659psw6MZ1419rooNxLXcMtuzr6Wh+y0V3zsv73qgjhbML1Pt9P9NXR/Pd1fT/f3FN1PN/Osv4Zn/fU866/nWX89z/phh3C/X8P9fj33+/Xc7/cUvU+30/01dH893V9P9/cU3U830/s19H49vV9P7/eU2t73yVUAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEazWYzzcZBntwrX/3SPNxotDP2f9NRasaaKfHE39uwuZUTiPx29fIot/e02VHu0Wnz42PvvPrmts/cdeOvo9wjE54ez1z20Pei3JRp+0a5LYOL4mPvOjwhyn1nefZ9rKqq2nXmU6PclPUPxDPfd332NRohLf1kwijTsd7/0NGnxtm1k/aMcktW3h/PfN7srFeW9G2McmMH5sXHXrv67ig3Z7f8a7RL2D9LWuifkejJdOa94fXBAeH1QSv+Y+K4OPv41LVhMv9Riy/bw+DFX/hyfGwiep9up/vrZur+Wro/oft7iO6nm3nW3yae9Wc866/nWX89z/phm7nfr5vpfr+W+/2E+/0eovfpdrq/bqbur6X7E7q/h+h+upner5up92vp/YTe7yG1ve+TqwAAAAAAAAAAAAAAAIAiWa4CAAAAAAAAAAAAAAAAimS5CgAAAAAAAAAAAAAAACiS5SoAAAAAAAAAAAAAAACgSJarAAAAAAAAAAAAAAAAgCJZrgIAAAAAAAAAAAAAAACKZLkKAAAAAAAAAAAAAAAAKJLlKgAAAAAAAAAAAAAAAKBIlqsAAAAAAAAAAAAAAACAIlmuAgAAAAAAAAAAAAAAAIo00OkTKFGzasbZdPut0cxnrt64Ocv1bYhnnj85O/7hD26KZ86eMCnK/XxTf5Q7onFzfOyrHr03yh007dB45qMTnxHlrrnvunjm+s3ZK+TYidn38rpl6+NjP/OlR0W5S971rnhm6oLzz2/7TGD0mP2qF8TZ9735zW0//nkf+1iU+/mXfxTljpuT9+lN67L39Un3/yyeecJex0S5ZnMonpn25EmNeGTc5zuPGxvlbnj8kfjYN+0+Pkzm/6BG+G2fNmFcPDM9/nAL15oAo4Hur6f76+l+ADrBs/6MZ/31POsHepH7/Xru9+u53wfoHrq/nu6vp/sBuoPer6f36+l9RiOfXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFKnRbDbTbBzkyb3gxWfF2eHmUNuP36gaUW7T5o3xzNUrV0W5M4ZmxjOzs6yqO9aujnK773xYfOzJG+6LctcuXxbPPHTeguzY6++NZ969OcvtMzb78V0zcc/42J/40WfjbMHSlzGMRnq/xjue/YYoN3XDA/HMe7Zkbxv7jotHVusm7R3lblm0MJ557Ow52bEn7hXPfPDRX0a5A6dMi3KtvIC/278yyk2bOT2eOX7chCjXHIEftb5Gf5T75lcvb/uxC6f36Xa6v4buD46t+2vp/p6i++lmer9NPOvPeNZfz7P+UU/v0830fg33+8Gx3e/Xcr/fU/Q+3U7319D9wbF1fy3d31N0P91M79fQ+8Gx9X4tvd9Tan+AfXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFCkgU6fQImWL10aZ/v6sv23/jBXVVW1acuWKNeMJ1ZV1Wi0M/a/s2HuwKnTolzfhvviY9+1ZmWUO3b2nHhmte7eKNbK133L+uy11Ddu5yg3Y8PiFo4OULb0PbPZyDt6y/pHs5lj58YzJ4f900qn3RP25H7xxLzPW7iUyIUXKKsfXxOPXFNl2fFjx8Yzh4aHo9xwmAOgNbq/nu6vp/sBeotn/eHIMOdZfz3P+gHaz/1+Pff79dzvA3QP3V9P99fT/QDdQe/X0/v19H5ZfHIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkQY6fQIlOuO0M+Lsd6/8bpQbGhqOZ/b1ZTt1zWY8sqqa2fH/Y2BVPPJ5W2dkh25kJzrcwr9n36kzo9xAI99PHA7Pc1U1IZ55yMy5Ua4RzmvlW/7hBadFufcuvLKFqQCdl76/pVrZZE/f11c3JsYzp1cbo1xf3BZ5T7bSvenhG80s+N0xj8eH7gtnVi30fiMcuWXrYNtntnKtCYDuT+j+IKr7AYrkWX/Gs/56nvUDtJ/7/Xru94Oo+32ArqH76+n+IKr7AbqC3q+n94Oo3ud38MlVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRGs1mM83GQdrn2BMWhMlG24+dvzTycLOFl1Gjkf2bnj84PcoNt/QPyo7d18KX/dKty6PcrDVj4pnPnjk1P4FASz/kYfi911+5LafSK9r/gwk7TrG9/+GjT8uC4U/4SLwR/Gjlmji7YurWKHf2mNnxzOERuHzsC3v/2wOrsiO30PuN+JuZfzdbiLYg+zdd+5OFI3Fw6ul9up3ur6P7A7q/vXT/KKf76WbF9n4nedZfz7P+9vGsv+30Pt2s2N53v1/P/X5boy1wvz/K6X26ne6vo/sDur+9dP8op/vpZnq/jt4P6P320vujXO133SdXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFKnRbDbTbBxkx5t/5GFxdvz4sVGur6+V3btGC9lMM3zJrV+/Jcpt3rQuPvasWTOj3Ozps+OZl3/z23G2U47aa584O2b3OVHu2p/8bFtPpxe0/wcDdpxie//YE54V5bY+uCzK3XDfPdtzOjvMWS94fpxdvmp5lFuxYmU8c9z4yVFu0qTsOqYxIm/B+Y/F8PBwlNu0KbuOqaqquvkXv4yzdITep9vp/hq6v57ur6f7e4rup5sV2/vdwLP+ep711/Osv+30Pt2s2N53v1/P/X499/tF0vt0O91fQ/fX0/31dH9P0f10M71fQ+/X0/v19H5PqX3R+eQqAAAAAAAAAAAAAAAAoEiWqwAAAAAAAAAAAAAAAIAiWa4CAAAAAAAAAAAAAAAAimS5CgAAAAAAAAAAAAAAACiS5SoAAAAAAAAAAAAAAACgSJarAAAAAAAAAAAAAAAAgCJZrgIAAAAAAAAAAAAAAACKZLkKAAAAAAAAAAAAAAAAKJLlKgAAAAAAAAAAAAAAAKBIA50+AdrjiMbsONvc3Ixy//LzH8YzP/G3H49yM+fuHM98ZNGiKLf0N7+Ncltuvzc+9u5bpkW5937z2/HMbpC9Mv63d/z5uSN2HgCdlL6/feRt7xjhM9mxLm+h0z684LQo92Ajb5axe+8d5eY+7YAot8u8efGxVy59NMq94y/y7vujZ54c5RqNRjwTgJGh++vp/nq6H4B28ay/nmf99TzrB3C/n3C/X8/9PkD30P31dH893Q/QHfR+Pb1fT+/zu/jkKgAAAAAAAAAAAAAAAKBIlqsAAAAAAAAAAAAAAACAIlmuAgAAAAAAAAAAAAAAAIpkuQoAAAAAAAAAAAAAAAAokuUqAAAAAAAAAAAAAAAAoEiWqwAAAAAAAAAAAAAAAIAiWa4CAAAAAAAAAAAAAAAAimS5CgAAAAAAAAAAAAAAACiS5SoAAAAAAAAAAAAAAACgSJarAAAAAAAAAAAAAAAAgCI1ms1mmo2DtM8JJ58Q5Q5cOzaeeeENP9jW0xmVPrLgtLbPfM/CK9s+s5M+88GPRLllV/4knvm+hd/b1tMpSaPTJwDbQe/X+NCCU6PcnNOyLq+qqnrj+9+zraczKunoeuccdUqcvWPKlij3kx/mfU5b6X26ne6vofvr6f56ur+n6H66md7vAM/667mWqOdZf8fofbqZ3q/hfr+ejq7nfr+n6H26ne6vofvr6f56ur+n6H66md6voffr6f16er+n1Pa+T64CAAAAAAAAAAAAAAAAimS5CgAAAAAAAAAAAAAAACiS5SoAAAAAAAAAAAAAAACgSJarAAAAAAAAAAAAAAAAgCJZrgIAAAAAAAAAAAAAAACKZLkKAAAAAAAAAAAAAAAAKJLlKgAAAAAAAAAAAAAAAKBIlqsAAAAAAAAAAAAAAACAIlmuAgAAAAAAAAAAAAAAAIrUaDabaTYOQjvc9Mubotyfv/2tUe6aH/10O86mu913331Rbq+99hrhMylOo9MnANtB77dJ+h5cVWW/Dx//7OOi3N9/8lNR7vDDDt+Os4Ftovfpdrq/TXR/RvfTA3Q/3Uzvs0N51t8+nvV3jN6nm+n9NnG/n3G/Tw/Q+3Q73d8muj+j++kBup9upvfbRO9n9D49oLb3fXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkRrNZjPNxkEAqqqqqkanTwC2g94HaI3ep9vpfoDW6H66md4HaI3ep5vpfYDW6H26ne4HaI3up5vpfYDW1Pa+T64CAAAAAAAAAAAAAAAAimS5CgAAAAAAAAAAAAAAACiS5SoAAAAAAAAAAAAAAACgSJarAAAAAAAAAAAAAAAAgCJZrgIAAAAAAAAAAAAAAACKZLkKAAAAAAAAAAAAAAAAKJLlKgAAAAAAAAAAAAAAAKBIlqsAAAAAAAAAAAAAAACAIlmuAgAAAAAAAAAAAAAAAIrUaDabnT4HAAAAAAAAAAAAAAAAgB3OJ1cBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFGmgh2xyxswBowXNfcVqc/f4lV47gmdRqdPLgsJ061vtd9DMO8P/T+3S7jnX/xy+8MM6ee845I3gmAC3R/XSzrnjWPzw8HOUuueyL8cyb7vxllDtgn/2j3Jte9ob42PSO25b/Nsr94tZfxDMfu+mRKPe6174+ys2cOTM+didd8JvvxNkH1j4a5cb15b/6nDF2QpT788PO1vt0s67ofaD3ddHv//Q+3U73A6OC7ocdwt/3AbSmtvd9chUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUaaDTJwB0p6uv/lGUu37yonjm9HDd8/uXXBnPBLpPKz/jF9z0b1Fu1XB+/KPXzYtyJ5307HwoAPCEzj3nnDh71QM3RLkNLXT/PptnRrkDD9w3HwoA/E4PL10SZ7/0H5dFuUWL8+ePU54yI8rtvO8eUW756hXxsX+7bnGU2zo8GM9srM2yMxqT45nPOPCQONtLbl9+V5z91b23RbmHFz8azxxXNeJsuy288food/WN18Yzn/HcBVFuoBqKZz5lwtQo19/Iv5Zj+vrjLAD0Ar/jB4Cy6H5gpPj7PqBX+eQqAAAAAAAAAAAAAAAAoEiWqwAAAAAAAAAAAAAAAIAiWa4CAAAAAAAAAAAAAAAAimS5CgAAAAAAAAAAAAAAACiS5SoAAAAAAAAAAAAAAACgSJarAAAAAAAAAAAAAAAAgCJZrgIAAAAAAAAAAAAAAACKZLkKAAAAAAAAAAAAAAAAKJLlKgAAAAAAAAAAAAAAAKBIlqsAAAAAAAAAAAAAAACAIjWazWaajYPt1sI5Vo1GYwTP5Mm98i1/EOUu/vS/j/CZsL3++kMfjHJ/9b73j/CZ7FjvXHhRR49/3oLXd/T4I6Bzb0iw/TrW+yOhk+9vPfjeVmxP9pr02rWqOnv92i33ApXep/v1VPdfevfCPJz+9IZfobP3XZAfu0tc/s0ro9xZLzhthM+E7fGZSy6Os298xStH8EyenO6HHaLtvb9s2bIo9/Nbb4pnfumn34py02ZPj2dOGD8+yu216x5R7hkHPT0+9gMbH4lyg8ND8czG+iw7fmP+/+zNHTszyh3x9PnxzMmTJsfZxKbBzXH2nlUPRrl7Vy2KZz68dEmUW7N4ZTxzwrLsx/JVr3pVlJsxI/s+VlVVff+6H0a5r/30O/HMQ08/Nsotvz/7WlZVVU2ZNiXKTZ+T/9tTrzn4BXqfbuZ3/DX8jr93lPq7C7/jbzu9T7fT/TV0f+/Q/Z2h+2FU6anf8fv7vvYqtSd7jb/va7vag/vkKgAAAAAAAAAAAAAAAKBIlqsAAAAAAAAAAAAAAACAIlmuAgAAAAAAAAAAAAAAAIpkuQoAAAAAAAAAAAAAAAAokuUqAAAAAAAAAAAAAAAAoEiWqwAAAAAAAAAAAAAAAIAiWa4CAAAAAAAAAAAAAAAAimS5CgAAAAAAAAAAAAAAACiS5SoAAAAAAAAAAAAAAACgSAOdPoFEo9Fo+8yP//Mn4+yvF/0myl3y6X/f1tNhB/j6nd+Ks81mcwTPZMd758KL2j5z5/FTotyMsePbfmyAVh04dac4+/iWTVHu0U1ro1wr78HnLXh9nO2ktCdb6d7f3//MbT0dttHFLVy7vuLcP4xyT5/3tHjmuX/89ig3EvcCQO/bdcLkOLt+aDDKrd6aXSNces/18bHP3ufoONtJ6S3yjY9kz0+qqqqO2CXvDNrjja94ZZy98MtfjHK7z94lnnnGySdFOd0P3WnxY0ui3K8euiueOWWPOVFu533nxTM33788yq1fsSbKrdya5aqqqtatXR/lxowbE8/sn9Qf5R7blJ/nLTfdGuX233f/eOa4seOi3Pr166LcklXL4mNft+b2KNdo5L8TGDM1u9acu+fEeOb0Cdn/hTgwkL8+UrN3zX7WDjjsoHjm+P7sPB+9/+F45vDuc6Pc9Dkz45nAyPI7ftrB7/jby+/4gZGk+2kH3d9euh/oJv6+r738fV9v8Pd9O55PrgIAAAAAAAAAAAAAAACKZLkKAAAAAAAAAAAAAAAAKJLlKgAAAAAAAAAAAAAAAKBIlqsAAAAAAAAAAAAAAACAIlmuAgAAAAAAAAAAAAAAAIpkuQoAAAAAAAAAAAAAAAAokuUqAAAAAAAAAAAAAAAAoEiWqwAAAAAAAAAAAAAAAIAiWa4CAAAAAAAAAAAAAAAAimS5CgAAAAAAAAAAAAAAACjSQKdPoN1e9OevjHLDg8PxzDPPeUmUW7FiRZT7ztLr4mM3m80o13fn+njmq37/5XG2G3z1zu9EuRuuvimeObXRub3Do884Ls6+/MN/GuUOnLrTtp4OQHFmjB3f1lwr/uGWr0S5L773H+OZ13/3p9t6Ok+o0WhEuZ+10L1D4c7/i/d/XjyzG/zPr38xzg7vPynKpd+f5809Jj72ya8+K8p968LsNVxV+XX7ZX9/cTwTYFtM6s8ejUwamJwNzG7jq6qqqu8vuiXKLbzsmnjm+9/+Z/kJhMJqqe6+48F45nCVDX3mLgfHM7vBtTfm10fNXcZGuUb4tTx02lPjYx987CFR7pdX3xLP/Md/vyTK/ekfvCKeCYys9Nl0VVXV+hnZPd3q/bL7mqqqqqnNiVFuXZU/6z/rlDOi3LPC/lm+ZmV87H+68fNRbtYe+bPcydOmRrn+adnXsqqqasrRe2UzJ2Y9VVVV9fiqx6PcLb/6VZS78Y5b4mP3HTE3yg2MHRPPTO+795qzazzzhQuOj7PtNmFqdp07Y7fsa9mK3fbZI85OnBK+f7RwPR5eRgE7gN/x1/M7/np+xw/QPXR/Pd1fT/cDlMvf99Xz933t4+/76vXS3/f55CoAAAAAAAAAAAAAAACgSJarAAAAAAAAAAAAAAAAgCJZrgIAAAAAAAAAAAAAAACKZLkKAAAAAAAAAAAAAAAAKJLlKgAAAAAAAAAAAAAAAKBIlqsAAAAAAAAAAAAAAACAIlmuAgAAAAAAAAAAAAAAAIpkuQoAAAAAAAAAAAAAAAAokuUqAAAAAAAAAAAAAAAAoEgDnT6BxPnn/3Ocnb7nLlHu4OMPj2d+8aOfzYLvTic24mOn2eH9J8cT/+wv3xbl/uFv/i6eORI+e+vXo9zYvv4o97Tj5sfHXvm9e+Jsuz3/lWfG2aljxkW5b17w5Sj3gje9ND42AJn0Pbiq8vfhVrpiJEyelF137HHcPvHM9YNDUS69PnjDIb8fH3skpNdb8192YtuP3WxmuW8/em08M70ePv3tr4pn3nbNTVGulXuBN7/5j+MswH9Kb9HD99ebf/TL+NDzn31YlDvsmKfFM0fCuHHZvees/WbHMzcPDUe5qx/8dZQ7afenx8ceCRd/7fIot+dR+fVR+pprhq/hX666Lz70wu8sjHJPP/3IeObDdz4Y5a66Kr9Gec5zjo2zQOtuW3Z/nL13xcNRrpUn4+HbYEsz223apKlx9o+e+/Io9+Olv4pnLt6wPMptHh6MZzbT30nEE6vqV+sXRbkbxz8S5TY9JX11VNXUb10W5dY/65h45tad5kS5dYOb45m9ptHIXkcTJ0+MZ44ZP3ZbTwfoEL/jr+d3/PX8jr+e3/EDo4Xur6f76+n+erofoP38fV/G3/e1j7/vG718chUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRBjp9AolFh42PszOb+0W5RzatjWd+/5LvxtnE2z/313H2kKOe0dZjV1VVzTyz/TPvu+++KPflS78Uz+w7Zc8oN7Y/exk3m8342G9/29vjbLs95ZDsNdyKpx97eNtnApAZiffgkeiKVrwt7MlP3vzleGaj0YhyW4YGo9xHPvrh+NgvPftlUW6vvfaKZ+bXW/n1SerWG34V5T752r+KZ77mkhdEuXMXXhTPnHlk9jpeFL42ALZZm9+Kd99vt/YOrKpqxm47tX1mK04/7aQod8UDN8cz0+4fHB6Oct/+9g/iYx911PwoN2fOrHjm5MN2DZPt7/4H710S5V5+/KnxzOPOOSTKXXr3wnjm5Kdmr+Pluh9Gjetv/kWcvWPl/VFu3C5T45nDE8ZGuan9+f8hd93V349yq6bdE+Wec/Ip8bFXP5zNXL3p8XjmuuHNUW7sYP412nXThCh3w0O3xjPv2/hYlNu4fHGUG/j1r+NjL/rN3VFu/NPy35v0z86uEdLrmI4bgepNfx0zYerkeGZf+LO+pTkUz9ywdWucBVrnd/zt5Xf89fyOH6CzdH976f56uh+AdvH3fRl/39c+/r5v9PLJVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFslwFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkQY6efBv3PbjMNlsYWqWbVSNFma21ydf+1dx9iO/uCTKrR/aGs8cbA7F2dRnlv4oC544N54555/+Lsote+Obo1yzpddRd2g0stfx9NkzsoGtfIk69yMEMDqE75nxe3CVv683m93Racs2r4uz6bXZTp85Pzv2G98UHzu9jjlvr73imRvDa7O7166MZ07qHxPlWrnWbLdWLg9G4tosvb944cEntv3YAP/XxCkT42yvdf+awc1xNu3+KVdfmx37xGPiY1+95u4od/acWfHMLUPZs5almzfEM8c2+qPcy48/NZ7ZSemruNHCNcKND98T5Y54yj7xTOD/WbzogTj74EN3Rrm9h/eIZ846YM8oN7U//z/kFj3ycJR7cHU2c2hr3n3LHvx1lFs/Kb+z2hTmpgzn1yeHzXhqlPvlmuw9uKqqauMj90e5SXdlr6P+hxfHx94wL/v3DEyYEM/ctHJNlFuzaUU8szowj7bb4PBwlNswmP8eKjXcwm8ph8PfbW3eOhjPXD8C/yYogd/x1/M7/np+x1/P7/iB0UL319P99XR/Pd0PMAL8fV8tf99Xz9/3tddo//s+n1wFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABRpoJMH/8Tf/32Ue/aZx8czB+dMj3J7jO2PZy545sFRbuHPb4ty3/rKp+Jjr959cpxNHfPYTlHuAzd8ru3HnvvZC+LstXc+FuX2aTazgY340F2jOZz922fsMjub18Kxl2xYE+XWDG5uYSrAyLhjTdYpVVVVUwfGRbldJ06Ncul7cFXl7+vd0mmt9Eoz7PPrwuuDY1u45lj6hjdFuVaujdLrret2yl+bqweHolx6rXnmS94aHzu9Hn7VhX8Rz1y8Jfv3DCxbFc/8xL9m9xcvvOjEeCbQnZZsXB9nJ/Rnj0ZmjM2uESZNmxQfO+2/bun+Vsp/OAzf/Uj2vdz3x9fFx15z4jFR7hv3Xh/P3Hdt9vzm7inr4pkbq+Eod/MNP45y8486MT72X3/gY1HumNc8O565YjD79/Sv3RjPvOInP45yR7xun3gm8P9MmTAxzvavzt6vt9yzOJ55wGH7xtnUnEMOinJPmbRbNnB4Q3zs/onZ++DwlsF4ZrVxSxSbPnlCPPKQg/aOcssfeCie2XfPnVFu6L7fRrnmnFnxseee9vzs2ANj4pmb7loS5bb0r4pndlQj+38Yh1q4KF21OXtP2NrMfi6qqqoGm9lzhK1b85+hrZuynyHgv/I7/np+x1/P7/jr+R0/MFro/nq6v57ur6f7gdL5+77O8Pd99fx9X71e+vs+n1wFAAAAAAAAAAAAAAAAFMlyFQAAAAAAAAAAAAAAAFAky1UAAAAAAAAAAAAAAABAkSxXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQpIFOHnzimP4o99B3ro5nnv4nL41yw81mPPNP/uQtcTax89QtbZ1XVVW17K7FcfbMV78+ym389cXxzEc+/ekoN2lC9j2vqqra9+/+Ksql38nrv/Cd+NjVguxrNBKWbFgTZ9N/++bhwSi3ZXio7cdu5bX5zuqiKHdeB78/wOjyzoXZ+0Yr70XVfntEsbVrHotyY/vy7hvXl12aNeKJndVK9x796udFufT6YMrFn42P3XfRhVFul7fk14RnnvmCKPeNL2T/nqqqqjnha3MkrjXT6+H+/vz1Pmti9nq/ooV7gYljxsZZoDtdes/1UW7N0sfzoTvPiGIbN26NcgN9+f9jM6aRvm/mzzA66Z5rb4+z+xx7UJSb+/LnRrkJ1y2Mj913zc+i3LRTjo9nzp9/SJS76adXxDOn7jI9yk2bkN/Lp04++YQo19eXX5lOHpd1/6+vuTueOba/o482oecduV/23lZVVbV+6aNRbsuGLFdVVXXk5DFRbkIL70WPb8nulxrNh6Pc2sfXxce+dsL4KHfvDb+MZx6505Qod+q8neKZj993ZZQbXL0+njltzHCUG5iaXUdtnpR/zxeHT1Faedby/OOy65MTd3l6C1M754AZ2fOGCQPZa7iqqupzt2evo6GWrnOz7Jpl+b3Aop+H16+nxCOhCH7H3z5+x1/P7/jr+R0/MNJ0f/vo/nq6v57uB7qNv+8b3fx9Xz1/31evl/6+zydXAQAAAAAAAAAAAAAAAEWyXAUAAAAAAAAAAAAAAAAUyXIVAAAAAAAAAAAAAAAAUCTLVQAAAAAAAAAAAAAAAECRLFcBAAAAAAAAAAAAAAAARbJcBQAAAAAAAAAAAAAAABTJchUAAAAAAAAAAAAAAABQJMtVAAAAAAAAAAAAAAAAQJEsVwEAAAAAAAAAAAAAAABFGujkwV932ouj3OXf+lI88+RpY6Lc5P58r+zePddEuS0PfTXKfW3azPjYD3z+u1HuU398Zjzz0Vv/Lco1V22KZ+45uz/KDWSxqqqq6p6qEeUaVTPKXXPh5fnBO+g9R74yzr7zZxdlwUb2tWzFTV/5YZQ7/CWntDA1+16em/67q6r6+LNe38LxgdGglZ/x9O1tzn7z4pk3feUHUe7wl5wc5TYPD8fH3jy0Ocqd1yXvba107zsXpt/37Ju+y/S8+waHsguUTavWxTPT662PHPbUeOZb//lbUe5rrzkjyh0aXrtWVVXN33NrlNt71ox45rqh7Gfj60P5dfvrzsjuL4DR5dK7F7Z95tS5+fvRAzfcGeX2PGq/KDc4nN3XVFVVDVbZ++vZ+y6IZ3bSe//wdXH20nuub+uxp0/Mu39oOMtu3bglnrnqwRui3Iv3zJ8JXfLD30S5G489KMrNW3lLfOw9Zw9GuTmTJ8QzN4U/GzeG35+qqqoTDj00zgKta27O72fn77NblBsf3n9VVVV94dOfj3Iv+4PnxzNnz8yuEW6+6+Eod8WV+XXMoc/YJ8o968gsV1VVtfuMyVFu9tTx8cyhoawDxt+ed3lzxZL/xd6dxktWlvfCXrWnnukBummapgFpEBEQcGBQAQWDIgrRGCecUBPU6ImooCJoQFRQITGvSqKiRlQiahwShUQUAcUBkUEGGYVuBhl6gJ72VHU+nA/v++ZE1r+a2l279nNdn/+/+1lVu2rda7p3Rbm+pcuiXOPJT4vX3nHmtCg3Zzg/ftx5YJsoN2vGzLhmNw32ZbcKt5+1dVzzNbtn183acelNv45yvxm5L6654zOy4yjg/889/nru8ddzjz/gHj8wSej99fT+enp/QO8Heojn++p5vq+e5/vqeb5vy/PLVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABTJcBUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFAkw1UAAAAAAAAAAAAAAABAkQxXAQAAAAAAAAAAAAAAAEVqtFqtNBsHU5/73D9Hude9YF5c87hXvyvKnXf+2XHNqpHFnvX2T0e5c447Il766fsuj7Ox8C950Wc+GZfsa2RF+1799rjm6rFmlFu6ZlmUO+SQQ+O1S/Wqz5wYZ5fuu1sWbGPP0Qi/a/luq6rm/PjeKHfKB07Ni+bCVwSTUsf7/ukfPi3KPfrcJXHNidhvpN/clb+9Jcp97a1ntbF4uX7600uj3Mp5d0e5+QP5/xBofvUfs1wr360//63ZMelEdIpf//a2KPfO8y6Oa17xj2/Lgm1814479oQod95X82PSL/9wTZR785v/Kq7ZBn2fXtfx3v/d72b7mY17bBXXbExI88+suvvBKPeWw17c8bWnoptvzvrVqpmro9ysvnw33Lry8izXxsdor8Ofk4c77I67HopyX7vs5rjmB17zrM3dnD/p8+d+J8q96fhj4ppXXLchyh166EFxzTbo/fSyaA93++3Zvrqqqmpg5A9Rbnxtvi+64Os/jHJ77vvkuObee+4S5W68L+s/5110Vbz2qS8/JMrttP3Wcc3p0wbjbKo5Ph7lVtxwXVxzZOP6KLdx3sIot2bb7O9YVVW1aePMKLfT3CfENZcu2iHKzZs3L65JvW9d/+Mod+mKa+OaM+bPiXJnHfgmfZ9e5h5/Dff4g5x7/JOae/wdp+/T6/T+Gnp/kNP7JzW9v+P0fnqZ5/tqeL6vszzf1zme76vXref7/HIVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABTJcBUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFCkRqvVSrNxsNNGVl4YZ3/4o6uj3FXX3RbXPOWEv4xyR53+9Sj376ceG69dtZppsI2aYa6Rl0xdtW4kzo4/uEOUe/azD97czeG/OfHKz8fZ+OPRzp4jLdpGzTMPelMbG9BxE/Atgi2ma33/pJ/n+6KJ2G+kNdOSZx3Y1f3QlHP55ZdFuf6FK+KaT5s9tLmb86dNyPFWGG5k/z/hqNPOj1f+91NeGeVOP/sbcc2n7b08yr3g8P3imkNLXxZnJ4C+T6/rWu//11uv7NbS7Qm/5S9ffuDEbkdhfv/726Nc31Zr4po7T+vfzK3Z0tLen8XO/s5v4pVPODrrv9+96Jq45k47bBPlnvLkpXHNgQX7xNkJoPfTyzre94cfuTPKrVqZ74tuu+2WKLfingfjmnvtsVOU29g3GOV+fP1d8drHv+DpUW7mUBt9Kr5/kOaqqkrvGTXy3eCGDcNR7pFqWpR7dGhRvHZz3fwot/NOT4hrzp49O87SOb/4481R7sr7b4xr3r9hVZQ788A36fv0Mvf4a7jHX889/snNPf6O0/fpdXp/Db2/nt4/uen9Haf308s839ehkp7v6yzP9yUxz/d1Se0fyC9XAQAAAAAAAAAAAAAAAEUyXAUAAAAAAAAAAAAAAAAUyXAVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABTJcBUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFKnRarXSbBzstNtuuzXOLpt+Tec3oG9aFGv0T+/82s2RKNZqjuY1W2m2EZe87Mobo9zhL/tgXJPJ7aQrPx/l2tlxNMJwOzXPOuhNbaQ7Lv8SweTTtb5/4s+z/UtV5V+yVhvfxjR65oFd3b/QQT+68O+i3MEH7tFG1fAr1BiMKzb6wmzfUFwz1RrflAWbwx1f++5N+8TZ5ct37fj6bdD36XVd6/0X3HplnO3mF+3lux7YxdXppBt+dVGUe+LyxZ1fvNHG/zlq9GexMNeOVnMsDIa5Njw8un2c3XbbhR1fvw16P72s431/zZo1UW7d6rvimosG0/sCbbycxkCWC8+r4vO0drSxbx0fzc7BmuPZfYaqqqqBgXD31sbFltvueiDK9c3aOcrtvu+R8dpMHWNj2XfjuofviGv+622XRrkzn/lX+j69zD3+Gu7x13OPf+pwjz+i79Pr9P4aen89vX/q0Psjej+9zPN9NTzfN3V4vq+e5/sitbsPv1wFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFAkw1UAAAAAAAAAAAAAAABAkQxXAQAAAAAAAAAAAAAAAEUyXAUAAAAAAAAAAAAAAAAUyXAVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABSp0Wq10mwc7KYND18b5QY23hLX7BuaG+XaeC/b0IhSn3j3SXHFEz7yvig3Pj4e15y50yvjLJPX35z19jg7f9l2Ua45NBDXXL1hU5T79KtPiWs2Gtl3aIJ0dXF4nLrW99vpp2/76ulRbv7M6XHNvpGxKLf67vui3P9z4j/GazO5bfjD1+Nsf39/lDv7/R+Na777E2eGyc5/fdN+2hxZG9ccm7FblJu59VPiml2m79PreqL3f/nn/xnlZk3Lz0P6xppRbv3Dj0S5177wpfHaTG7DD14dZ/v7sjbwwwsviWse+cqjolz6DWqrUYXh1lh2Hl9VVTU+uDDKTZuzfVyzy/R+elnH+356LXlsOD9nGF9/a5TrH7k/rtnXF/6/ub6huGY3XXvlL6Pc/XfdGdd83kteEOWazewYqqqqqjlj9yjXP+cJUW76jK3itZk6LvlVdhz1s9//Kq45MjPbJ3z4pSfp+/Qy9/hruMdPr3OPv+P0fXqd3l9D76fX6f0dp/fTy3riHr/n+9iSPN9Xz/N9j80vVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFAkw1UAAAAAAAAAAAAAAABAkQxXAQAAAAAAAAAAAAAAAEUyXAUAAAAAAAAAAAAAAAAUyXAVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABRpoNsb0Gkzt35KlLv76l/FNc/6wClR7pwvfirKNeKVq+q/fvyzKLdppBnX/MznvxflDnj+2+KaB+4UR2M/veynUe6Qgw/p/OKF2mnJojj72yuuiXJPe/Y+cc2Hh0ejXKPRzrcI6DXtfMeb4X5jm8H8kOeqcP+27wF7xTXpnG4eH1x7305x9hcXfTrKtXMM96PwuPB5z31mlGvFK1fV377+HVHuxA+/K665bL/suB2Y+to6vh8bj2JzBvL/JXPnLfdEuR2XbxfXpHNuvvm2KLf77ss7vvaKtQvi7G3XXRHlRsfz3n/DjXdGuSfvsXNcM/XVf/52lHvhXzwnrrn1Tttv7uYAPaC/vz/K9U2fE9cc69slyq275/645vVX/TLKNfoGo9wBBx8Yr52eha1Ymb+eO+9YEeXuvTPLVVVVDf3sd1Fuyc77xTV3WL4wys2asVWUGx4ejte+++67o9ySJUvimrNmzYqzdM54cyTKbVj9cFxzzR/WZcGXxiWBzeQefz33+PlT3OMHepHeX0/v50/R+4HJwPN9PBbP99XzfN/k5ZerAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiDXR7A7rlpoeWxdlzPvfhLNgai2LNZparqqp6wrLFUe43O+8Z13z6fntFuQMPPDCuORHO+cF5Ue6Qgw+Z4C2ZvNauXRvlrrv03Ch3zeW/jdfe9+B9o9z4WP55Xz59KM4CVFW+32hnX7TvgVmfvOaybJ95+Zwz47X3PvT4KDd37ty45lTTzeODdo6Nxh+4LMpdOtyKa6bHhc3xTVGu0ZefCqTHwz++YU5cMz8aB/h/LRrsj3LN8WZcc8fl20W5u39/T5T7/fRL4rV32P2gKDdz5oy45lRz0XW/jHK7776842svX75TnG0+cnuUu2ks7/0Lt8n6aiu8ztRo5P9j6dVvPDLK3bhyelxz6zgJTGWNvsE4OzBtQZR7aH2+L1q/KdsPz56RXkfIjzmqVrb2xvXr45LD4fLD/fl79NCqbP3tdl8S12wM5ueKiXUb8/foJ1dfEeVeMPvP4pqzZs2Ks1NJs5l/3sfCa3GPPHxXXHPtg9nxeHPjcFxzKPxeApOHe/z13OOf/NzjB8jp/fX0/slP7wdK5/m+8ni+r57n+yYvv1wFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFAkw1UAAAAAAAAAAAAAAABAkQxXAQAAAAAAAAAAAAAAAEUyXAUAAAAAAAAAAAAAAAAUyXAVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABRpoNsb0C1H/NkRcfaznzotyr3mRbtGueHhsXjt8fHxKNfX1x/XTF3yH5+Msxfev7bj63/nY1/ueM1ecNbHz4qzB+3WinKNsN7xR+4fr33Bb26Ncvs/+Vlxze0XLouzAFVVVftt98wod8+Dd8c1f3nDFVGunX1m6vpLz41yP78l3bNX1YnvOXFzN2dSSo8Pjv/CqR1f+2WL58bZaWGunWO49Ljw0Uey47Jp0/JTga98P+v7b3lH5993gP+vnebtHOVWP7omrnn7PXdEuec+Zce4ZmrlzT+Pcrfen9d84ZGHbebWTE5/+5evjnJf+ukPOr720+fOiLNpV2008v9z1BzPzvk3bdoY5QYG8uOOn/32wSh3WBvX1wDal537bmgtjisu3zs7l184Z1OUa42Pxms3m9l9gTmz0zPKqpq9zTZRbtZY3n92WrYkym237fy45nAzez/vWZ31tIdWPxyvfcsDd0W5Q0aztaeijRuz177u0Ufims2xDVFuxU2XxTX/eNvvsuDwcFxz8dJt4ywwObjHX889/u5wjx9gYuj99fT+7tD7AXKe76vn+b7O8XxfPc/3PTa/XAUAAAAAAAAAAAAAAAAUyXAVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABTJcBUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFCkRqvVSrNxkM654rtndr5oI4ttt3heXHKHJQs2b1sew4fPuTDKnfLOl0W5CfkAN8I3s6qqqjEYxd51yufjki9/8bOi3Ac/+bUod8ll18ZrE2njAwKTjr7fIYcd/JQ4+3fvelWU+9fvXRHX/OTpb8qCrdG4ZpUfP8bSHebp4fHBB8Ljg3asuHdVnL3v/jVZcAK+ac86+qTOFyWh79Pr9P4O+dgZZ8XZl7zgqVHul1ffEdd85UsPCJPNuOZE9P7Udy++JsodfcQ+HV971eoNcXbN2o0dXz+1236HdW3twun99LKe6PvpvYtmM+9pV17xn1Fu0+pbotwBey+K1x4ZHY9yq9esi2ted+PdUe6+B1bHNffafecoNz40FNf87brhKPeHjdm1icVzt4nXfuvhr45ys2fMimv2902t/1t4zbXXRLlfX/mTuOYe22ff31ZrLK45Pp59h1a08R361V0PRLlPfehz+j69rCf6/lTjHn899/jrucffNfo+vU7v7wK9v57eX0/v7xq9n16m73eI5/synu/rHM/3dU3tx3hq3QECAAAAAAAAAAAAAAAACBmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCI1Wq1Wmo2DdM4V3/1YlBscHIhr9vdlM3V7P3mHuGas0fmSVfwZnoDF+wfjaKN/ZpZrY/mBbf+sjTRdMBGfeNhS9P1JbOyP/xln0z9ka3xDvgHjo3k2Fm5pYwJ2rRPwab/uhhVRbrzZjGuOjo5FuWcd/d64Jh2l79Pr9P5JbHztzR2v2Wq20c9b42GujQ3ohb1mG69nxT1rolwzvw5XjY9n7/tu+x0e16SjeuFTDH9KsX1/9eqHolxzNDtHnjt7KF47vRdz+/WXxjXvXXlHlBsZyc4nq6qq5syekeXmZte7q6qq+mZNi3Kt8D7Hxg35cczNv3sgyj3noL3imtstmhflJuSLFl4XabTxvxWv/PUNUe6yK34T1zz46U+IchdfenVc8+kHPS/K7f+s58Y112wcjnK777KHvk8vK7bvd5N7/AH3+Jm89H16nd7fBXp/QO9n8tL76WX6/iTm+b7uLN0Oz/cVqfbD6ZerAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAijTQ7Q0o0fFfOCXO7jtrepQ7cM7MuObuu20XJltxzVarEeWyVJvrN7KqrVb+evoGZoXBwbhm+npabb5LAJQn72h5utGfH0tUjdEo1hxbn5cM+3n+6vN+Glds5O/83nvuEOVuvuW+uOY1jwxHufPDY81z33h6vDYA3dVe78802jifbbXC/83TzI4RekYbvX+HpfOi3H33PxLXvG1j9n7+/Kc/iHKvP+TIeG2AqWr+/G26vQm1mlXeo6cNZdkZ04fimv39Wd/fZl5+HWGrOTOi3NBQdstqw4zs/LiqqmrDwiw3rVod12xuGomzsfQyRqM/y7VxrLf9ouw+1DP33zOuueMTnxrl9m9l10+qqqp22W2vKLd4yS5xzcVxEsA9/px7/ABMDXp/XDWL6f0AFMbzfVHFeG3P97Gl+OUqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIA93egBLN3WOnOHtHmHvDDltt1rY8tkaejKOtCVk/qpZvZNVqjWU1q8F2tiBdPa549dVXR7n99tsvrglA96T79b22714/rao2+mQbvTfX+X6ab2fnX8/uu20XZ786Y1aUm7u5GwPAFveHP6yIcjvMn+ANqdNqdnkDuqXzvX+7xfn1m58PDUW5GZu7MQA8bsOjI3H29j/eHeX+uOHRuGZf2Kq2mp5fx549a3pWc07egYYG+7NgeCo/c+a0eO2DnrZbnI210msObRxLNML3qBHe1ktzVVXtsHRxlFu28xPjmv3zn5HVfOIz45oA3eYef+fXj6q5xw9Al+j9nV8/qqb3AzDJeb4vqhrmPN/H5OOXqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIo00O0N6AVfu+m7UW6kmdWbPTAYr/3bH/0iC77mOXHNVqsV5RqNRlzz7pUPRblZM6bFNR9dNxzlHnl0Y5QbGR2L137avjtHudb4SFyzauP9TO256JEwuV/H1wag8/ZcdHuUa412vqdU4fFBVVVVFS5/1W/vjEsODWaHpVvNmRHl5szOjznWb8yOOZYt3SauORHHW7de+psot+/hB0S5L92QHeNWVVUNhf+S4VVPOjquCUBVLd3q4SjXGp/gDemQO+/KXk9VVdVAf3+UmzEjO0aYPi2/1jI8kl0f2HrBrLhmlR5KtXEYd/9NK6LcTk/eKcpdvvL6eO3+sPcftGSvuCbAVLR246Nx9ouXfyvKbVONxjX33Co7R1621cy45vZL5ofJNq4jdLxPtrF2rI0mHUfz/2/Y6AuvY/R177Zeeq2jqqpqfCw7gO0fyN/3dq6hAFSVe/wJ9/gD7vED9Ay9v57eH9D7Aajh+b56nu+r5/m+ycsvVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFAkw1UAAAAAAAAAAAAAAABAkQxXAQAAAAAAAAAAAAAAAEUyXAUAAAAAAAAAAAAAAAAUyXAVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARRro9gb0glc96eiurf3xH1/f8ZqNqpEFW3nN+//4SJT78jd+HNf83Fcvzjcg8NGPvTvOfv6bP4ty555xbBtb0MYb2sWSAHRRul9vTEADCA8Pqqqqjj/5/Ci365N2jWu+772fyDcg8OZXHxFnX/eXz41yy7bfJq4ZH2+14cC+WVHuPU9/bcfXBqBsX/rmVVFu2yUL45ovOqqz11q+cO5n4+yznrFblNt6QdZ7q6pq61gqtbxvKMq98AlP7/ziAET6BvNbLLN23DbKrR0bjms2tpoW5badNz2umWuj+U1An+yJxdtYutUaD0v2d37x0KZNm+Lsivt/H+V22nnnuObMmW0cmwFU7vEn3ONPuMcP0Cv0/np6f0LvB6CG5/s6xvN9TEZ+uQoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKFKj1Wql2ThI55x2+mlR7n1veFJcM/1Dfuy8G+Kap576oTjbCz760XdHuVYbX4vjX7JPlJs1c1pc8+FV66LcPfeuiXJPf8EJ8dpEGt3eAHgc9P0O+fUPz46z2y+ZF+W2XjA7rrl+w3CUO/fb18Q1G+Hu7X3v+0RcsxecdtqH4ux7j3tylGunUXz0izdFuVNPObWNqnSQvk+v0/s75I7rfhJn58+bGeVmzxqKaw6PjEW5H191T1yz0ch2cS866ui4Zi/4zncuirNHHby44+v/++V/jHLHHH1Ex9cmovfTy4rt+3esWRHl7lv/QJRbNzoSr/3rB2+Pciv/kG1jVVXVcxdm1weO2SXvU+k17/T4oKqqat36TVFudHQ8yvX35/83cCQ8NhoeznJVVVWjY9l2Tp+eH8MtXjQvCzbC197G3ydtaePNvOajmwaj3PztD4hrDs6YH2cngL5PLyu273eTe/zd4R4/HaLv0+v0/i7Q+7tD76dD9H56mb7fIZ7vmzpOO+1DcdbzfUWq/XP65SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiDXR7A3hsy7efFuVaVSuu2aoaUe7UUz8U15xq0vdzYCCfT1zwxNds7ub8SffecHaUGx4Z7fjaAGTa2Qffe9+aKLfkKcfFNbMjiaoaGLgurjk21oyzU0k7x0bDKy8Mk/kxXHpcCEB3jbbRJ9es2Rjl5i/bP645GOb6+++NazbH8341lRxzzPPj7Niqazq+/qL5LtsBdFp/X3Y9d7Av66hzhvJ99dMX7Rblxm+6J645tG44TOa9PLt7UFVVK6/56LpNUW7FPQ9HuQ2b8uOtvfY9MMoNtnHKfd+KO6PcA3esjGvOvfuBKLffnsui3IzpQ/Haqf42svOmZ5/N/r7xzdsYgEnOPf7ucI8fgG7R+7tD7wegUzzfN3V4vo/Hyy9XAQAAAAAAAAAAAAAAAEUyXAUAAAAAAAAAAAAAAAAUyXAVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABTJcBUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFGuj2BvDYmk/druM1W81Wx2tOOc1mFLvllrsmeEMe26bh0Sh3/kProtyzHs/GAPA/SvfBVVVVx24zewK35LHdcsudcfYJO+0wgVsyNaTHW402/tXBRBwXAtB5Vz46HGcPmjNtArfksd1//6o4u3CbeRO3IVNEqxX2/kYjr7nTVpu7OQD8CTtutX1HcxPh0Rk3xtl51Zos2E7/Cc9nH16bH/NsGBmKcqvWZbes7ns4X/vQZQdFuaFp+XHZAxuy7J2/y+8frLzqlii3YEF2fLDjknnx2tOHBqNcGx+janw8u8cyuu7huOZQNSPKDU6bFdcEmCju8XeJe/wAdIne3yV6PwAd4vm+Mnm+j/+JX64CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAoUqPVaqXZOFiqj/zzmVGu7+k7xDVPWDgY5dY8ujGu+Yk1I1HurAPfFNfsBW957Yvi7Lo//j7KfeXiWzZ3c/6kM888I84+c/eBKDdvlyOj3H9d/pN47Xe+5R1xtmCNbm8APA76fo1zPvupKPe8Zz8nrrnm9h9EuZ/dPBbXPOmkk+Ns6jVH7BblZm/7xLjmZ//l+5u7OZPSiVd+Psq9e95QXHPenBlR7uwHR6Nc89cr4rXf/1cnxdmC6fv0Or2/xkWXXBbl9nzi8rjm+gduinK33tuMax511PPibOqfPp6dp07balFc8/V//ebN3ZxJ6YJbr4xyR87KzuOrqqpmTs+uCV306HiUa92xJl77Rc85LM4WTO+nl+n7k9gFF3w9zi6cuSrKPXu/vEePjGbHHef/x51xzf0Pyo5PnrLPPlEuv61VVX192f8YbDTy3Xqrlb1Ht956Y1zzm9/6YpRLt/O5T1sWr73HzttEub6+/D1a+8imKPfQw+vimot2PijKLd75qXHNNuj79DJ9v4Z7/JObe/z13OPvOH2fXqf319D7Jze9v57e33F6P71M36/h+b56nu+r5/m+KaW27/vlKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSAPd3oCp5P1/dVLHa46svDDKzZszI6657YZpUe6nP700rnnIIYfG2W7Z9NCt3d6EyMBN346zv7wpy73rS9lnc88994rXBijdO9/yjo7X/OQnXh/l2juAO3kztqQzeqX3pto5Ntp29pwoN29O5//XwXv3fVUW3LfjSwNMac8/7OCO1/zhD78e5frbqvq8zdmUjhhd92DX1p4IN998W5ydO216lJs5vbG5m/MnHbXjU7Pgjh1fGoAJsGBuftY/Z7C9o4TEwEC2/otffExcc6sFS6NcX1/nX89EaDSyc/m+vvycPz1C6AuDM7beO157xpI9otzwhtVxzYf+8J9RbsPG4bjmeHM8zgK0wz3+ya1X7jO4xw/QO/T+yU3vr6f3A+Q831evV3pvyvN9PF5+uQoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIA93egBL924nPiLPz5m8d5T72b7+La55w+uei3CFHHBrX7AVf/MHN3d6ESKORZ5utidsOALa8dLfe10avmAhfufiW7m5AlxxyyKFxdtPFF0W5F73lzXHN9/75nlFuzeqPR7k/P+tX8doATIxW2P0bVXeb/1+/5+Surt8tu+++PM6OXn9TlDv7y/8a1zzqqYuj3Ib1P45yT3vFCfHaAHTP0Laz4uxAtT7KtVr5heRGeIF68eLt4pp9g7Pj7FTSzvvebDaj3Nq166LcWGtavPbAjEVRbtNwto1VVVUbNoxEuRvXDcc1h0bGo9z2cUWA9rjH3x3u8QPQLXp/d+j9AEx2nu+b3Dzfx+Pll6sAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCI1Wq1Wmo2DpVqzZk2Uu+Ks58c1G+G7/sKP/iKuSXe8+dUvjnJ7TLs3rvnO867a3M1hy2h0ewPgcdD3J7FzjntanL1xeEmU+9xXv7e5m8MW8h/vOyDKtcLu86wTL4rXnjdvXpwtmL5Pr9P7J7GLPv/JOHvP6Nwo98a3vGlzN4ct5JoLz+lovd1eeHycnTlzRkfXnqL0fnqZvl9j7aOPRLn7Hr4/L7rVtCi2es2Nccmtx1dHuXn9+S7r3vHsf/I9cdkRcc0Z0+bF2V5w78q7otzVV10R17zyih9GucXLnhTljnj+n8drL1y4XZS7566b45pr7ro8yt3QnBXXXLZd9tr32SnLVVVVbbc4e+2Vvk9v0/druMfPY3GPv0j6Pr1O76+h9/NY9P4i6f30Mn1/EvN8X5k83zfp1b7zfrkKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSI1Wq5Vm42Cp3nDYLlFu8bwZcc2Pfut3m7s5QPc1ur0B8Djo+9Cj3vfSPaPc/Ws2xjW/eMntm7s5JdH36XV6P/Sob3zqzCi3dsNoXPPN7/3A5m5OSfR+epm+X+N3t94Q5b7384vimn17LIpyxywYimsuaTSj3O/XD8c1v7sh2739zV4vimsunrkgzvaC733zK1Hu+xeeF9ccbG6Ich/8+29EuW233zFe++rfXBXlrrziP+Oae++Y/W/HOdsfGNe8475VUW5o2rS45lFHHJlG9X16mb5fwz1+4L/R9+l1en8NvR/4b/R+epm+Dz3K831dU9v3/XIVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABTJcBUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFCkRqvV6vY2AAAAAAAAAAAAAAAAAGxxfrkKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEgDbWRbE7YVHfTt874T5V5y3DEdX3vlypVRbunSpR1fGx7L+Ph4lOvv75/gLSlOo9sbAI+Dvl9D32ey0ve7Rt+n1+n9NfR+Jiu9v2v0fnpZT/T9XpDug6vKfpgtKz12raqJOX7t5nH7BNH36WU90fed78P/zfl+1+j79Dq9v4bez2Sl93eN3k8v64m+3wtc62eycq2/42r7vl+uAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCI1Wq1Wmo2D3bRy5coot+p3q+Oaez9/ryj38y9eHuX69xiK195///3jLOX5zW9+E+Uu+dp/RbkTP/nex7M5/N8a3d4AeBz0/Rr6Pluavj/p6fv0Or2/ht7Plqb3T3p6P72sJ/p+LzjrXR+Ls4e96nlR7qlPfermbg4F+OUvfxnlxm8ciWse9IZnR7nrLro+rrlgz/lRbunSpXHNLtP36WU90fed71MS5/uTnr5Pr9P7a+j9bGl6/6Sn99PLeqLv9wLX+tnSXOvvmtq+75erAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAitRotVppNg72gsvP+2mc7e8fiHKtsZEo9x8/uShe+yPnnxlnKc8Pzvh+lJs+MBTlbhy6NV57t+EnRLmZi2bHNZ913MFxtkc0ur0B8Djo+zX0fbY0fX/S0/fpdXp/Db2fLU3vn/T0fnrZlOr7V5x3WZzd8MC6KHfLtDui3B4ju8ZrbwqPJY48+UVxTcrz/mNPinIvfM7z45qN8FhifHwsrvns4w6Jsz1C36eXTam+73yfqcD5/qSn79Pr9P4aej9bmt4/6en99LIp1fdd66ckrvV3TW3f98tVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFAkw1UAAAAAAAAAAAAAAABAkQxXAQAAAAAAAAAAAAAAAEUyXAUAAAAAAAAAAAAAAAAUyXAVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRGq1WK83GwV7wiy//PM42W82O5hp9jXjtJ73oyVFuwYIFcU0mtzPOOCPO7ju2R5RrNrLPXKMvn7ds9Gc1TzrvvXHN62+9Ic72iPzLDpOPvt+hnL7PY9H3pxR9n16n93cop/fzWPT+KUXvp5dNqb6/165ZP62qqjrzuI9FudZ49ha1mtnxQVVVVV94L+a3AzfGNU8++eQ4y+S2atWqKHfT97N+2mrmX/O+RnaMkOaqqqoOeN1BcbZH6Pv0sinV953vM1k5359S9H16nd7foZzez2PR+6cUvZ9eNqX6vmv9TAWu9U96tX3fL1cBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABTJcBUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFAkw1UAAAAAAAAAAAAAAABAkQxXAQAAAAAAAAAAAAAAAEUyXAUAAAAAAAAAAAAAAAAUqdFqtdJsHOymu6+9N8rdf+Pdcc3RTaNRrtHXiHKtZv5W9g1kNRubhuOasw5YFOX22muvuGapznn/J+PsHnN3j3LNNj4frbHxLJfWyz5uVVVVVV+VhR9Yuiqu+frXvz7fgN7QxjsKk46+X0PfL4++X0/fh56m99fQ+8uj99fT+6Fn9UTfT33pS1+Ks4tWLohyzfAtarTxTqY7jcZAf1yzLzw+uXHtzXHNd37kXXG2VNdff32UW/+LB+KarenTolxzLPxshp+NqsqPXwenD8Y1F++xLMote8qSuGaX6fv0sp7o+8736znf7xzn+/Wc70NP0/tr6P3l0fvr6f3Qs3qi76dc66/nWn9nudZfr8Rr/X65CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAoUqPVaqXZODjV3H777VHuD9+5LcrNWDCrjdWzt73ZyCuONcei3LSBaXnN0ZEo12jkGzowbSjKNUfHo1xrrBmvvemRjVFu4/osV1VVNdDfH+WazfyrNtbKXnsjLDljejt/8/B9n5e97qqqql2P2C3KLV++PK7ZZW18M2HS0fdr6Pv19P16+n49fR+2GL2/ht5fT++vp/fX0/thi+iJvn/bbVnvvfXiW+KajTXZ/m1gMNu/bdw0HK/dCvcaA41839rXlxUdG89ed1VV1YxZM6Lc9K2yXFVVVWMg+z9/feH7PjacHZtUVVWl98AGBrNjk6qqquGx7O8+0DcQ1+yLv5XZ33zjqvXx2jsdk/XeXXbZJa45Ben79LKe6PsTwfl+UNP5fi3n+/Wc78Oko/fX0Pvr6f319P56ej9sET3R913rr+dafz3X+uu51h+pfeP9chUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFAkw1UAAAAAAAAAAAAAAABAkQxXAQAAAAAAAAAAAAAAAEUyXAUAAAAAAAAAAAAAAAAUyXAVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRGq1WK83GwVLN32qrKHfhqd+Ia05fMDPK9fX1xzXTP2WjL/+Tj443o1x/I9/O1lhWc839q6JcXxtrV+PjUazVyEs2w/d9fHgsrvm6fzguyp39yr+Lcq8456/jtWfNmhVnC9bGJwQmHX2/hr5fT98Pltb3pxJ9n16n99fQ++vp/cHSev9UovfTy/T9GuvXr49yF7zzn+KaJ3z9g1Huy//rvLhm/7SBKNfXxi6rkX46+vPe22xlvXfe4gVRrjGQ/9/A8XDtwf68ZquZvp/5+95sZtu5adWGKPey0/4yXnv1I4/E2YLp+/Qyfb+G8/16zveDpZ3vTyX6Pr1O76+h99fT+4Ol9f6pRO+nl+n7NVzrTxZ3rb+ea/1TSO0f0y9XAQAAAAAAAAAAAAAAAEUyXAUAAAAAAAAAAAAAAAAUyXAVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABTJcBUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFGuj2BkwlZ73itCj3hk+8Pq557tvOjXKz5s+Oa/aPjUW5kb589q412oxymzZsims2qkaUGxgYjHKjYyPx2n2N7LVveHRtXPNtX/jbKDdtcCiu+Q/HfjTKvf6zfxPXBCCj79fT9+vp+wC9Q++vp/fX0/sBesOsWbOi3Bv/+YS4Zn9/1gPe/vm3xzWHR7P+9+k3/n1cc+acuVGu2cyOOaqqqgYHste+9r7VUa5VteK1p8+cHuVGB/Njo6Fmdmw0PpDfglu/el2UO/7Tx0e59NgVAOf7Cef79ZzvA/QOvb+e3l9P7wfoDa7113Otv55r/WXxy1UAAAAAAAAAAAAAAABAkQxXAQAAAAAAAAAAAAAAAEUyXAUAAAAAAAAAAAAAAAAUyXAVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABTJcBUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEarVYrzcZBHtsO2y3Ow+G7/r6/eH++/rY7RLlGoz+u2ReO6bXG84/RQLMZ5Ub7Glm9gYF47Y+ef0aUu/3hO+Oaqb5G9nqqqqr+9rC3RLkTzj91czfnT/rRpy+Ocoe/7YiOr91D8j8mTD76fofo+xl9v56+P+np+/Q6vb9D9P6M3l9P75/09H56WbF9v5v7t7OPPS3K/f0ln41rNvP7O7Fdtt45yr3v2JPjmmNjY1FusJm9nrH04KSqqkZ/trsOD02qqqqqVms8yq3444q45ke/+ZEsGHafFffdH69NRN+nlxXb9zvN+X7G+X495/uTnr5Pr9P7O0Tvz+j99fT+SU/vp5cV2/dd66/nWn891/qLVPvO++UqAAAAAAAAAAAAAAAAoEiGqwAAAAAAAAAAAAAAAIAiGa4CAAAAAAAAAAAAAAAAimS4CgAAAAAAAAAAAAAAACiS4SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIg10ewNK9OGXnBJnT/7W6VFudOur45of/Jfzotzpr/u7uGZrPMv19efzfGNVK8rdc9dtUe6Vb50br33rObdEub6+wbhmI8x96Oj3xzWPO/ftcTbxlD32jrMfO/aMKHfJJy6Oa44Mj0S5F5z8orgmQLfp+xl9v56+D9Ab9P6M3l9P7wdK98Mzvh/lhqYNxTVHR7J9UbrPvPbG6+K1Tzj/1Cg37/j5cc0PfifbX2dd9/+49cGsTx50xH1xza9/Zm2UW7rj8ijXzjFHc7wZ5RppM6+q6tR/yY6jXveqfeKa6d/ojDaONQHoLOf7Gef79ZzvA/QGvT+j99fT+4HSudZfz7X+eq71s6X45SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAAAAAAAAAAAokuEqAAAAAAAAAAAAAAAAoEgD3d6AEk179jZxdsfLF0W5hbs8Ia551bVvjHKt0eG45ulnXxDlBjZtjGu+4y8OzWrOWRzlpm2zMF77pos+FuWe/9p/iGuuvH9VlPtd/+1xzU4767UfibNjo2NRbtOm/HPU32/eE5h69P2Mvr/l6fsAE0Pvz+j9W57eD/SaRl8jyrWzL6pazSjWzj6z09rqFWPZvnWHxQvikhf9y/+KcrOesCyu+Zr3Phjlxh7Ncp/65qXx2mMDM6LcKSe8Iq75ghP+Mcpd8M2fxDV3XJQdF7ZzrAlAZznfzzjf3/Kc7wNMDL0/o/dveXo/0Gtc6w+41l9f07V+thBHOgAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABTJcBUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFAkw1UAAAAAAAAAAAAAAABAkQxXAQAAAAAAAAAAAAAAAEUa6PYGlOgVr3h5nH3ZkVtHuc///c/jmt+5aCTKHX14XLI65YRX5OHQhz7+syj3nQu+EuWuufrceO1pC2dHuaWLto1rvuXgt0S51376bXHNThts5vOWY41GlOvry2uueuCPcRagV+j7GX1/y9P3ASaG3p/R+7c8vR/oNel+Y/7CfH/dbLaiXDv7zE47+9N/H2f3ae0a5b5/87fjmmmfrPr645r7P/9DUe6YV7wmyn3oxDfEa8ey1ldVVX689egf8pqXXXF2lOvfqo2DOAA6yvl+xvn+lud8H2Bi6P0ZvX/L0/uBXuNafz3X+jvItX4eJ79cBQAAAAAAAAAAAAAAABTJcBUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFAkw1UAAAAAAAAAAAAAAABAkQxXAQAAAAAAAAAAAAAAAEUyXAUAAAAAAAAAAAAAAAAUaaDbGzCVXHPNNVFuz50fyos2stib3vnMuOQznvrWKHf0rz8d10w1Bvvj7Mz1a6JcX/omxbmqGpy7MMp95ctvjmtO3+EVcbZbnvv+I+Ps5/76nCjXaON9bzTMewK9Q9+vp+9Pbvo+QHv0/np6/+Sm9wO9ZuPG9VFuw123xTVbVSvKvfmf3hnX7KbXfuZtUe4vV2wd1xycu02YzHtA2s/T44N2jjlao+NhMC5ZnfHe7HjrV7/5TFyz1co2YGztj6Lc7+5M/45Vtc8++8RZgKnI+X495/uTm/N9gPbo/fX0/slN7wd6jWv99Vzrr+dafz3X+jvDkQ4AAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFAkw1UAAAAAAAAAAAAAAABAkQxXAQAAAAAAAAAAAAAAAEUyXAUAAAAAAAAAAAAAAAAUyXAVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRGq1WK83GQba8dTd/Mc5O326HKNdo408+turBKNe/YFFcM9VoNMJk/nryr0Xuop/8Nsoddcx7Or94F912221x9kc/+lGUO/744zd3c7a09MMJk5G+P4np+wl9vxv0fehpev8kpvcn9P5u0PuhZ/VE3z/33HOj3OGHHx7XXL58+eZuzqT079/5eJR7/nP27fjacYv+P+ko1cb9qtj4qgei3MCChXHNVvh6Nt23Iq45e/c3xFm6Qt+nl/VE3y+V8/2E8/1ucL4PPU3vn8T0/oTe3w16P/Ssnuj7rvXXc62/nmv9dEjtH90vVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFAkw1UAAAAAAAAAAAAAAABAkQxXAQAAAAAAAAAAAAAAAEUyXAUAAAAAAAAAAAAAAAAUyXAVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARRro9gbQGd/4WTPOjt77tSj3qj9/Zlyzb8GsKNfYuDquObp2XZQb3zAW5T7/k0fjtU844YQ4mzrqmMM7XrMXLF++PM5efMEnJ3BLAKYOfb+evt8d+j7AxND76+n93aH3AxNp/KFro9zy5cdP8JZMXkcd856urX322WfH2Tc9Z06U65+Z3bIanDs7XntsWvY/BkdW3B3X/Nq//SzKDS7Jj7eO2z2OAjCFON+v53y/O5zvA0wMvb+e3t8dej8wkVzrr+dafz3X+tlS/HIVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABTJcBUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFAkw1UAAAAAAAAAAAAAAABAkQa6vQE8tmOf+/Io95zlB8Q1Bxp7R7mTT7kkrrnzHv1RbumSreOa37vgvih36JP2j3LzBwbjtc/80Eei3Ekfen9ck3oLFy7s9iYAdJW+X0/fnzr0fQC9P6H3Tx16P9Au+43uSPvkogfmxDUvvPnRKHfpTb+Mci9+xXbx2ivvfTjK3XnjeFzzKYueEeVaKx6Jax771ey48Pwf/2tcE4Ducb5fz/n+1OG4HUDvT+j9U4feD7TLfqM7XOuv51o//xO/XAUAAAAAAAAAAAAAAAAUyXAVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABTJcBUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFKnRarXSbBzksd1zzz1x9sbzr41yoyNjcc2xsZEod+jRa+KaE/HxGBwYiHI/unBWlOufPj1ee+Oj66LcSz/2qrgm9W699dYot+uuu07wlnRMo9sbAI+Dvt8h+n5G3y+Pvg+Tjt7fIXp/Ru8vj94Pk0pP9P0puN/oCd9679ei3Iw5s+Oa45s2RbnDX7Y+yo2O5cdGuXy3ful350W5gYGhuObgUHZstMexT4ly22+/fbw2EX2fXtYTfb8XON/PON8vzxQ8btf36XV6f4fo/Rm9vzx6P0wqPdH3p+B+oye41l/Ptf4i1X5A/HIVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABTJcBUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEMVwEAAAAAAAAAAAAAAABFMlwFAAAAAAAAAAAAAAAAFMlwFQAAAAAAAAAAAAAAAFCkRqvVSrNxkMd2yccvjrMzFs2Ocg/f/UC+AeFf8tCXrMpLjoVFm/nH6MLzm1Fu2XY7RLnxDZvitauhoSj2h8G745LHv/ut+fpTyFvf+OI4+5kvfG8Ct6QrGt3eAHgc9P0O0fcz+v7UoO9DT9P7O0Tvz+j9U4PeDz1rSvX9wvdFkXM/8Zk4u9Posiw4MhLX7J85Pcrdfd+KKPeyY9v4v4F92e66MZDv1i/99oIs2Ean2HrZoii38YF1Ue6w9xyRL05C36eXTam+303O9zPO96eGwo+x9X16nd7fIXp/Ru+fGvR+6FlTqu8Xvi+KuNZfz7V+atT+Nf1yFQAAAAAAAAAAAAAAAFAkw1UAAAAAAAAAAAAAAABAkQxXAQAAAAAAAAAAAAAAAEUyXAUAAAAAAAAAAAAAAAAUyXAVAAAAAAAAAAAAAAAAUCTDVQAAAAAAAAAAAAAAAECRDFcBAAAAAAAAAAAAAAAARTJcBQAAAAAAAAAAAAAAABTJcBUAAAAAAAAAAAAAAABQJMNVAAAAAAAAAAAAAAAAQJEGur0BveDyL1wa5T7yTx+Jcn/3v06L1x7dtDHKzZw9M645smE4yr3rXZfHNT/1ucOi3K++uySuufuTs4/nI398JCs4MBiv3Rwbj3LXXnFVXPNnW2fv5/23r4xrvvTDr4yznXbllVdGuT970XETvCUAnaXv19P36+n7AL1D76+n99fT+wG6p519Ubp/O/DAAzd3cx63b33g63F28S5Lo9y1P8l72g4HbB/l+trovWOjWe/d/cm7R7lrfjYWr/2Mo++Ncu948yVxzT8/+CVRbmjmtLhma2wkys1ZMjfKveAZfxav/f6/fn+Ue/YbD41rAkwGzvfrOd+v53wfoHfo/fX0/np6P0D3uNZfz7X+eq7113Ot/7H55SoAAAAAAAAAAAAAAACgSIarAAAAAAAAAAAAAAAAgCIZrgIAAAAAAAAAAAAAAACKZLgKAAAAAAAAAAAAAAAAKJLhKgAAAAAAAAAAAAAAAKBIhqsAAAAAAAAAAAAAAACAIhmuAgAAAAAAAAAAAAAAAIpkuAoAAAAAAADgf7d3v7+S1XcdwGfuzt7LCruLrEuJkrBSrJE2Zrnpr012LSqNSrcVW6u0Yh9QNj4wpvjAmFixQeoD0wdaf0SaXYzBTbuWWk1Ea+k2tIEEq82CRqg/0F4SVCgI7I/b/Xln/AMMnPfcnTtnznxer8fvfM/J7uW+55zNmwEAAAAAAEoyrgIAAAAAAAAAAAAAAABKGrR9A13w5KlvRLkv/P1DUe7hPzgaX3tp65Yot7g138mdWT0b5d7zlh+Pzzz8qZNR7vrvW4rP7A3Xoli/349yF9Yu5NcOvf66S+Lsm9/+zSh352Nfic98X+8DcTbx4MHfiLNveuftUW7Pnj3rvR2AVuj9Znq/md4H6A7d30z3N9P9AO255ZZb4uzKykqUS39n7j/wm/G1U0e/9aU4+7s/d2OUe+yJvNNGvVGUWwu7vNfr9QaD7J+iwtrvDbbmnzkOf+pMlBvns9Ew+yPqLW7N/9z74Z/R6sunolz62bXX6/Xu/eQfRbl9vRvjMwFmgef9Zp73m3neB+gO3d9M9zfT/QDt8a6/mXf9zbzrb+Zd/2vzzVUAAAAAAAAAAAAAAABAScZVAAAAAAAAAAAAAAAAQEnGVQAAAAAAAAAAAAAAAEBJxlUAAAAAAAAAAAAAAABAScZVAAAAAAAAAAAAAAAAQEnGVQAAAAAAAAAAAAAAAEBJxlUAAAAAAAAAAAAAAABAScZVAAAAAAAAAAAAAAAAQEnGVQAAAAAAAAAAAAAAAEBJxlUAAAAAAAAAAAAAAABASf3RaJRm4yCv7SO3/lKc/ekffl+UO/3KanzmuXPnsjNPnYrPvOK7XxfltmzdEp/ZH2Tbv/995oUot7CQbwmHw+zHfd+7vhWf2Y+TuedeGkS5fzuzM8rt37//Ym6H/28j/tphWvT+hOj9jN5vpvdnnt6n63T/hOj+jO5vpvtnnu6ny/T+hDz44INx9g2XZJ121RUX1ns7r2qcv/BH/vrKKLewkP8aHA6HUW7HNVmnjS5k5/V6vd7pk6ej3Ev//Xx85pbLLotyi4uL+ZmXXxrlPvfwn0e5Tx75/fjaRPQ+Xab3J8TzfsbzfjPP+zNP79N1un9CdH9G9zfT/TNP99Nlen9CvOvPeNcfnOld/6xr/IH3zVUAAAAAAAAAAAAAAABAScZVAAAAAAAAAAAAAAAAQEnGVQAAAAAAAAAAAAAAAEBJxlUAAAAAAAAAAAAAAABAScZVAAAAAAAAAAAAAAAAQEnGVQAAAAAAAAAAAAAAAEBJxlUAAAAAAAAAAAAAAABAScZVAAAAAAAAAAAAAAAAQEnGVQAAAAAAAAAAAAAAAEBJ/dFolGbj4Lw5duxYlFt94mSU23f7O+Jr3/Ohj0W53a/fHZ954eyZKHf5m56Mz7z/yL9Gufe+5YPxmYNRP8oNF8LccBhf+5WtR6Pcru0/E5/5iYO/FeUO/+H74zO3LR+Is7Qi++GE2aT3G+j9Znq/md6fK3qfrtP9DXR/M93fTPfPFd1Pl5Xt/S44cexgnL3tFx+Icr9y4KPxmSvHPxvlLj95U3zmwkL2//lbGGY/mhf6+Y/w5//h01HuQ7d+f3zmK//8xig3WLokPvOJ/3giyt11/91R7pE//mp87Ut3b41yy8vL8ZlzSO/TZWV73/N+M8/7zTzvl6T36Trd30D3N9P9zXT/XNH9dFnZ3u8C7/qbedffzLv+iWvsfd9cBQAAAAAAAAAAAAAAAJRkXAUAAAAAAAAAAAAAAACUZFwFAAAAAAAAAAAAAAAAlGRcBQAAAAAAAAAAAAAAAJRkXAUAAAAAAAAAAAAAAACUZFwFAAAAAAAAAAAAAAAAlGRcBQAAAAAAAAAAAAAAAJRkXAUAAAAAAAAAAAAAAACUZFwFAAAAAAAAAAAAAAAAlGRcBQAAAAAAAAAAAAAAAJQ0aPsGumB5eTnK/cUDRyZ+7bvuvzvKPfQ398dn3rzve7LgcGd85g/tvzHKrZ5djc987zt/J8q9bc+2KPerB94dX7vX2x2lHjqyEp948tT5Ma4PQFv0fjO930zvA3SH7m+m+5vpfgDakPbP8/+yEp/5k7fuDpMvxmf+9sG/inJfe+xElPv8l345vvbNH/mFLDiKj+z13t2PYl9+5L/iI+/6WPa5MPXiv/9PnN13+zsmem2AWeF5v5nn/Wae9wG6Q/c30/3NdD8AbfCuv5l3/c28658M31wFAAAAAAAAAAAAAAAAlGRcBQAAAAAAAAAAAAAAAJRkXAUAAAAAAAAAAAAAAACUZFwFAAAAAAAAAAAAAAAAlGRcBQAAAAAAAAAAAAAAAJRkXAUAAAAAAAAAAAAAAACUZFwFAAAAAAAAAAAAAAAAlGRcBQAAAAAAAAAAAAAAAJRkXAUAAAAAAAAAAAAAAACU1B+NRmk2DjJ9jz76aJzd84Nnolz+o5Hrj5FNL3/+5eez3EvfHuPqmYWFfJ84HA7DZP6ntG35jjhLK8b5kYdZo/dnmN4Pcnqf6dP7dJ3un2G6P8jpfqZP99Nlen+GnTh2aIx09le5MZ2W23zFd2S573xdlNuIzxzj6Ic38Ng/XRKfuXfv3nXeDVOi9+kyvT/DPO8HOc/7TJ/ep+t0/wzT/UFO9zN9up8u0/szzLv+Zt7104LGv3XfXAUAAAAAAAAAAAAAAACUZFwFAAAAAAAAAAAAAAAAlGRcBQAAAAAAAAAAAAAAAJRkXAUAAAAAAAAAAAAAAACUZFwFAAAAAAAAAAAAAAAAlGRcBQAAAAAAAAAAAAAAAJRkXAUAAAAAAAAAAAAAAACUZFwFAAAAAAAAAAAAAAAAlGRcBQAAAAAAAAAAAAAAAJQ0aPsGmIy9e/fG2QvHj0a50ysr8ZnDtSx32XW74jP7YW7T0uYodz6+cq+3bflAlDtx7NAYp6ZGG3AmAPNE7zfT+wDME93fTPcDMD8m3xXDYX5m3pMH4zPTPu+nHxDGsPr0SpRb2JSfuWXXrig3zmc4AGryvN/M8z4A80T3N9P9AMwP7/onybt+psU3VwEAAAAAAAAAAAAAAAAlGVcBAAAAAAAAAAAAAAAAJRlXAQAAAAAAAAAAAAAAACUZVwEAAAAAAAAAAAAAAAAlGVcBAAAAAAAAAAAAAAAAJRlXAQAAAAAAAAAAAAAAACUZVwEAAAAAAAAAAAAAAAAlGVcBAAAAAAAAAAAAAAAAJRlXAQAAAAAAAAAAAAAAACUZVwEAAAAAAAAAAAAAAAAlDdq+AaavH+YGWxfjM8+/cjbKjUaj+Mx+P9v+DdfWotyzL+RbwuvD3Plrfio+c/vg8Sh37oVn4zMBoIneb6b3AZgnur+Z7gdglg22bY6zizuvjnLHL9yw3tt5VeN077VXZn2+KfwkMxoN42v3e9nnk8HWpTHOBIDp87zfzPM+APNE9zfT/QDMMu/6m3nXzyzyzVUAAAAAAAAAAAAAAABAScZVAAAAAAAAAAAAAAAAQEnGVQAAAAAAAAAAAAAAAEBJxlUAAAAAAAAAAAAAAABAScZVAAAAAAAAAAAAAAAAQEnGVQAAAAAAAAAAAAAAAEBJxlUAAAAAAAAAAAAAAABAScZVAAAAAAAAAAAAAAAAQEnGVQAAAAAAAAAAAAAAAEBJg7ZvgOl75rmXotxVm0YTv/Z9n/lqnD3wwR+NcmvfPrPe27loO3bsiLPD05uj3NKVV8dnvv8n3h7lHvjC38VnAjBf9P7k6H0AukD3T47uB2CS0t/rR/7s4/GZ/c1Z/+zYnnfaRkj7fHFb9v8DPPSZh+Nrf+Ct10S50TD/bJR+3rp2e3wkADTyvD85nvcB6ALdPzm6H4BJ8q6/mXf9dJlvrgIAAAAAAAAAAAAAAABKMq4CAAAAAAAAAAAAAAAASjKuAgAAAAAAAAAAAAAAAEoyrgIAAAAAAAAAAAAAAABKMq4CAAAAAAAAAAAAAAAASjKuAgAAAAAAAAAAAAAAAEoyrgIAAAAAAAAAAAAAAABKMq4CAAAAAAAAAAAAAAAASjKuAgAAAAAAAAAAAAAAAEoyrgIAAAAAAAAAAAAAAABK6o9GozQbB5ltZ8+ezXJP/ml8Zr+f5Tb/wG3xmZvPPRrlVp/+ZpR79oV8S3j9j304zk7a2vGjcXb1P1ei3LYb7ljn3XCRwv8yYCbp/Tmh95vpfSZE79N1un9O6P5mup8J0f10md5vwYnHD0W5S6/dFZ+5aftN67ybi/fUF++Ls1fvHEa5S6/73ih3fnFvfO3z3zgc5fJ/Kuv1lt7481luaSk/lFmn9+kyvT8nPO8387zPhOh9uk73zwnd30z3MyG6ny7T+y3wrr+Zd/3MsMbe981VAAAAAAAAAAAAAAAAQEnGVQAAAAAAAAAAAAAAAEBJxlUAAAAAAAAAAAAAAABAScZVAAAAAAAAAAAAAAAAQEnGVQAAAAAAAAAAAAAAAEBJxlUAAAAAAAAAAAAAAABAScZVAAAAAAAAAAAAAAAAQEnGVQAAAAAAAAAAAAAAAEBJxlUAAAAAAAAAAAAAAABASYO2b4DpW1painJn+/mZ9/3l16PcnTfcEZ954qmV/AYCK88+F2evn+iVxzMaKzxWGoCC9H4zvQ/APNH9zXQ/AK0If6935bf/ON179c4ro9zq0ytRbtvyTfG17w0/x9x+y5vjM9PPWwAwSZ73m3neB2Ce6P5muh+AVnjX38i7frrMN1cBAAAAAAAAAAAAAAAAJRlXAQAAAAAAAAAAAAAAACUZVwEAAAAAAAAAAAAAAAAlGVcBAAAAAAAAAAAAAAAAJRlXAQAAAAAAAAAAAAAAACUZVwEAAAAAAAAAAAAAAAAlGVcBAAAAAAAAAAAAAAAAJRlXAQAAAAAAAAAAAAAAACUZVwEAAAAAAAAAAAAAAAAlGVcBAAAAAAAAAAAAAAAAJQ3avgFm2GgUR++8+94NvJHXdu78WpS7+cMf3eA7mYzh6Zfj7Cf+5ItR7p7lA+u9HQCq0Put0PsAtEb3t0L3A9SV/l6/69d+Nj90+zpvZgLG6d4Xv5Z9lljcPPl/sko/x5w4dnDi1waAVnjeb4XnfQBao/tbofsB6vKuv5l3/XSZb64CAAAAAAAAAAAAAAAASjKuAgAAAAAAAAAAAAAAAEoyrgIAAAAAAAAAAAAAAABKMq4CAAAAAAAAAAAAAAAASjKuAgAAAAAAAAAAAAAAAEoyrgIAAAAAAAAAAAAAAABKMq4CAAAAAAAAAAAAAAAASjKuAgAAAAAAAAAAAAAAAEoyrgIAAAAAAAAAAAAAAABKGrR9A8yurz/1TJz9keWNuINRlPrbx1+Ocre97WLuZXrOPH88zt7ze5/bwDsBoBK93w69D0BbdH87dD9AXenv9RP/eCg+c/Gq9d7NdKV9/p63ftcG38mra/+zEQBMRvud5nm/ied9ACZJ97dD9wPU5V1/M+/66TLfXAUAAAAAAAAAAAAAAACUZFwFAAAAAAAAAAAAAAAAlGRcBQAAAAAAAAAAAAAAAJRkXAUAAAAAAAAAAAAAAACUZFwFAAAAAAAAAAAAAAAAlGRcBQAAAAAAAAAAAAAAAJRkXAUAAAAAAAAAAAAAAACUZFwFAAAAAAAAAAAAAAAAlGRcBQAAAAAAAAAAAAAAAJRkXAUAAAAAAAAAAAAAAACU1B+NRmk2DsIkfOXwr0e5G2/7+AbfCaxbv+0bgIug95kqvc8c0Pt0ne5nqnQ/c0D302V6n5nk8wEzTO/TZXqfqdLnzAG9T9fpfqZK9zMHdD9dpveZST4fMMMae983VwEAAAAAAAAAAAAAAAAlGVcBAAAAAAAAAAAAAAAAJRlXAQAAAAAAAAAAAAAAACUZVwEAAAAAAAAAAAAAAAAlGVcBAAAAAAAAAAAAAAAAJRlXAQAAAAAAAAAAAAAAACUZVwEAAAAAAAAAAAAAAAAlGVcBAAAAAAAAAAAAAAAAJRlXAQAAAAAAAAAAAAAAACX1R6NR2/cAAAAAAAAAAAAAAAAAMHW+uQoAAAAAAAAAAAAAAAAoybgKAAAAAAAAAAAAAAAAKMm4CgAAAAAAAAAAAAAAACjJuAoAAAAAAAAAAAAAAAAoybgKAAAAAAAAAAAAAAAAKMm4CgAAAAAAAAAAAAAAACjJuAoAAAAAAAAAAAAAAAAoybgKAAAAAAAAAAAAAAAAKMm4CgAAAAAAAAAAAAAAACjp/wDzBLObaOS/hgAAAABJRU5ErkJggg==\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Visualize the data\n",
        "\n",
        "# Show seven versions of the first three Pokemons. \n",
        "images_per_row = 7\n",
        "fig, axes = plt.subplots(3, images_per_row, figsize=(45, 15))\n",
        "\n",
        "# Plotting each image in a subplot\n",
        "for i, ax in enumerate(axes.flat):\n",
        "    # The leftmost Pokemon is without augmentation (with_random_augmentation is False).\n",
        "    with_random_augmentation = False if i % images_per_row == 0 else True\n",
        "    ax.imshow(dataset.get_pil_image(i//images_per_row, with_random_augmentation=with_random_augmentation))\n",
        "    ax.axis('off')\n",
        "\n",
        "plt.savefig('dataset_summary.png', bbox_inches='tight')\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h_EAqsZ2223C"
      },
      "source": [
        "Next, we visualize the frequency of each RGB value in the image dataset (before augmentation). After the forward process, this should look like three standard normal distributions."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lKvnFiP-b2kz"
      },
      "outputs": [],
      "source": [
        "# Create giant tensor with all images.\n",
        "img_num = len(dataset.img_list)\n",
        "tensor_with_all_images = torch.zeros((img_num, CHANNELS, IMG_SIZE, IMG_SIZE))\n",
        "for i, img in enumerate(dataset.img_list):\n",
        "  tensor_with_all_images[i,:,:,:] = img\n",
        "\n",
        "# Save the pixel values of all images in 1D tensor for each channel. \n",
        "pixels_red = tensor_with_all_images[:,0,:,:].flatten().numpy()\n",
        "pixels_green = tensor_with_all_images[:,1,:,:].flatten().numpy()\n",
        "pixels_blue = tensor_with_all_images[:,2,:,:].flatten().numpy()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 385
        },
        "id": "Xeb-vkqByXfY",
        "outputId": "ae5e51b3-4e7e-4f54-ef70-4894509c7b4d"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x400 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "ax = sns.kdeplot(pixels_red, color=\"red\", alpha=0.5, ls=\"--\", lw=3)\n",
        "sns.kdeplot(pixels_green, color=\"green\", ax=ax, alpha=0.5, lw=3)\n",
        "sns.kdeplot(pixels_blue, color=\"blue\", ax=ax, alpha=0.5, ls=\":\", lw=3)\n",
        "plt.title(\"Color distribution of transformed original images\")\n",
        "plt.savefig('color_distribution_original_images.png', dpi=300, bbox_inches='tight')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AIYzD8DU6AOL"
      },
      "source": [
        "# Visualizing the Forward Process"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 152
        },
        "id": "x6idtCot6Esi",
        "outputId": "79c2ffc5-67d9-44f6-ada8-374f160be99a"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x400 with 0 Axes>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x1500 with 10 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "def one_step_forward(img, t):\n",
        "  #\n",
        "  # This is not correct!!! Fix it.\n",
        "  #\n",
        "  return img + torch.randn_like(img, device=DEVICE)*0.1\n",
        "\n",
        "def create_forward_animation(dataset):\n",
        "  img = dataset.img_list[0].to(DEVICE)\n",
        "  img_list = list()\n",
        "  # if TIMESTEPS is too large, you can use a subset\n",
        "  img_list.append(tensor_to_img(img)) \n",
        "  for t in range(TIMESTEPS):\n",
        "    img = one_step_forward(img, t=t)\n",
        "    img_list.append(tensor_to_img(img)) \n",
        "  return img_list\n",
        "  \n",
        "img_list = create_forward_animation(dataset)\n",
        "\n",
        "# the .gif file can get pretty large\n",
        "imageio.mimsave(\"forward_animate.gif\", img_list, fps=10) \n",
        "# we can also show the images inline\n",
        "show_from_image_list(img_list, filename = 'forward_grid.png')\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyMH1WkqNGnJW5tKJfYpWWnM",
      "include_colab_link": true
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}