Deep_Q_Learning_for_Lunar_Landing_Partial_Code.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Suhani-s/Lunar_Landing/blob/main/Deep_Q_Learning_for_Lunar_Landing_Partial_Code.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LbZcI9ZXHl3a"
      },
      "source": [
        "# Deep Q-Learning for Lunar Landing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E8yPRjteXgPb"
      },
      "source": [
        "## Part 0 - Installing the required packages and importing the libraries"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "slEm5teGWjWU"
      },
      "source": [
        "### Installing Gymnasium"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dbnq3XpoKa_7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e27b0600-7bf6-4d90-b143-092b36d15743"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting gymnasium\n",
            "  Downloading gymnasium-0.29.1-py3-none-any.whl (953 kB)\n",
            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/953.9 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m174.1/953.9 kB\u001b[0m \u001b[31m5.0 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m532.5/953.9 kB\u001b[0m \u001b[31m7.8 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m952.3/953.9 kB\u001b[0m \u001b[31m9.3 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m953.9/953.9 kB\u001b[0m \u001b[31m8.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium) (1.25.2)\n",
            "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium) (2.2.1)\n",
            "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium) (4.10.0)\n",
            "Collecting farama-notifications>=0.0.1 (from gymnasium)\n",
            "  Downloading Farama_Notifications-0.0.4-py3-none-any.whl (2.5 kB)\n",
            "Installing collected packages: farama-notifications, gymnasium\n",
            "Successfully installed farama-notifications-0.0.4 gymnasium-0.29.1\n",
            "Requirement already satisfied: gymnasium[accept-rom-license,atari] in /usr/local/lib/python3.10/dist-packages (0.29.1)\n",
            "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium[accept-rom-license,atari]) (1.25.2)\n",
            "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium[accept-rom-license,atari]) (2.2.1)\n",
            "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium[accept-rom-license,atari]) (4.10.0)\n",
            "Requirement already satisfied: farama-notifications>=0.0.1 in /usr/local/lib/python3.10/dist-packages (from gymnasium[accept-rom-license,atari]) (0.0.4)\n",
            "Collecting autorom[accept-rom-license]~=0.4.2 (from gymnasium[accept-rom-license,atari])\n",
            "  Downloading AutoROM-0.4.2-py3-none-any.whl (16 kB)\n",
            "Collecting shimmy[atari]<1.0,>=0.1.0 (from gymnasium[accept-rom-license,atari])\n",
            "  Downloading Shimmy-0.2.1-py3-none-any.whl (25 kB)\n",
            "Requirement already satisfied: click in /usr/local/lib/python3.10/dist-packages (from autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari]) (8.1.7)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari]) (2.31.0)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari]) (4.66.2)\n",
            "Collecting AutoROM.accept-rom-license (from autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari])\n",
            "  Downloading AutoROM.accept-rom-license-0.6.1.tar.gz (434 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m434.7/434.7 kB\u001b[0m \u001b[31m8.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
            "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
            "Collecting ale-py~=0.8.1 (from shimmy[atari]<1.0,>=0.1.0->gymnasium[accept-rom-license,atari])\n",
            "  Downloading ale_py-0.8.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.7 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.7/1.7 MB\u001b[0m \u001b[31m39.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: importlib-resources in /usr/local/lib/python3.10/dist-packages (from ale-py~=0.8.1->shimmy[atari]<1.0,>=0.1.0->gymnasium[accept-rom-license,atari]) (6.1.2)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari]) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari]) (3.6)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari]) (2.0.7)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->autorom[accept-rom-license]~=0.4.2->gymnasium[accept-rom-license,atari]) (2024.2.2)\n",
            "Building wheels for collected packages: AutoROM.accept-rom-license\n",
            "  Building wheel for AutoROM.accept-rom-license (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for AutoROM.accept-rom-license: filename=AutoROM.accept_rom_license-0.6.1-py3-none-any.whl size=446660 sha256=b275430752fecb8ba8f74cf08f95156abee0a0153c1918113ec26c0cd8d0cef0\n",
            "  Stored in directory: /root/.cache/pip/wheels/6b/1b/ef/a43ff1a2f1736d5711faa1ba4c1f61be1131b8899e6a057811\n",
            "Successfully built AutoROM.accept-rom-license\n",
            "Installing collected packages: ale-py, shimmy, AutoROM.accept-rom-license, autorom\n",
            "Successfully installed AutoROM.accept-rom-license-0.6.1 ale-py-0.8.1 autorom-0.4.2 shimmy-0.2.1\n",
            "Reading package lists... Done\n",
            "Building dependency tree... Done\n",
            "Reading state information... Done\n",
            "The following additional packages will be installed:\n",
            "  swig4.0\n",
            "Suggested packages:\n",
            "  swig-doc swig-examples swig4.0-examples swig4.0-doc\n",
            "The following NEW packages will be installed:\n",
            "  swig swig4.0\n",
            "0 upgraded, 2 newly installed, 0 to remove and 35 not upgraded.\n",
            "Need to get 1,116 kB of archives.\n",
            "After this operation, 5,542 kB of additional disk space will be used.\n",
            "Get:1 http://archive.ubuntu.com/ubuntu jammy/universe amd64 swig4.0 amd64 4.0.2-1ubuntu1 [1,110 kB]\n",
            "Get:2 http://archive.ubuntu.com/ubuntu jammy/universe amd64 swig all 4.0.2-1ubuntu1 [5,632 B]\n",
            "Fetched 1,116 kB in 0s (3,265 kB/s)\n",
            "Selecting previously unselected package swig4.0.\n",
            "(Reading database ... 121749 files and directories currently installed.)\n",
            "Preparing to unpack .../swig4.0_4.0.2-1ubuntu1_amd64.deb ...\n",
            "Unpacking swig4.0 (4.0.2-1ubuntu1) ...\n",
            "Selecting previously unselected package swig.\n",
            "Preparing to unpack .../swig_4.0.2-1ubuntu1_all.deb ...\n",
            "Unpacking swig (4.0.2-1ubuntu1) ...\n",
            "Setting up swig4.0 (4.0.2-1ubuntu1) ...\n",
            "Setting up swig (4.0.2-1ubuntu1) ...\n",
            "Processing triggers for man-db (2.10.2-1) ...\n",
            "Requirement already satisfied: gymnasium[box2d] in /usr/local/lib/python3.10/dist-packages (0.29.1)\n",
            "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium[box2d]) (1.25.2)\n",
            "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium[box2d]) (2.2.1)\n",
            "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.10/dist-packages (from gymnasium[box2d]) (4.10.0)\n",
            "Requirement already satisfied: farama-notifications>=0.0.1 in /usr/local/lib/python3.10/dist-packages (from gymnasium[box2d]) (0.0.4)\n",
            "Collecting box2d-py==2.3.5 (from gymnasium[box2d])\n",
            "  Downloading box2d-py-2.3.5.tar.gz (374 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m374.4/374.4 kB\u001b[0m \u001b[31m5.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: pygame>=2.1.3 in /usr/local/lib/python3.10/dist-packages (from gymnasium[box2d]) (2.5.2)\n",
            "Collecting swig==4.* (from gymnasium[box2d])\n",
            "  Downloading swig-4.2.1-py2.py3-none-manylinux_2_5_x86_64.manylinux1_x86_64.whl (1.9 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.9/1.9 MB\u001b[0m \u001b[31m12.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hBuilding wheels for collected packages: box2d-py\n",
            "  Building wheel for box2d-py (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for box2d-py: filename=box2d_py-2.3.5-cp310-cp310-linux_x86_64.whl size=2349118 sha256=7b4209c7949707359ef6bdbc398bc0f987ebdc838c9332ba9e7811a0c4f5d051\n",
            "  Stored in directory: /root/.cache/pip/wheels/db/8f/6a/eaaadf056fba10a98d986f6dce954e6201ba3126926fc5ad9e\n",
            "Successfully built box2d-py\n",
            "Installing collected packages: swig, box2d-py\n",
            "Successfully installed box2d-py-2.3.5 swig-4.2.1\n"
          ]
        }
      ],
      "source": [
        "!pip install gymnasium\n",
        "!pip install \"gymnasium[atari, accept-rom-license]\"\n",
        "!apt-get install -y swig\n",
        "!pip install gymnasium[box2d]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "brqiMN3UW9T9"
      },
      "source": [
        "### Importing the libraries"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mZaKXP_aMl9O"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import random\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torch.nn.functional as F\n",
        "import torch.autograd as autograd\n",
        "from torch.autograd import Variable\n",
        "from collections import deque, namedtuple"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EzlDKXvkXzGI"
      },
      "source": [
        "## Part 1 - Building the AI"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UtG6Zc83YYy3"
      },
      "source": [
        "### Creating the architecture of the Neural Network"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Network(nn.Module):\n",
        "  def __init__(self, state_size, action_size, seed = 42):\n",
        "    super(Network, self).__init__()\n",
        "    self.seed = torch.manual_seed(seed)\n",
        "    self.fc1 = nn.Linear(state_size, 64)\n",
        "    self.fc2 = nn.Linear(64, 64)\n",
        "    self.fc3 = nn.Linear(64, action_size)\n",
        "\n",
        "  def forward(self, state):\n",
        "    x = self.fc1(state)\n",
        "    x = F.relu(x)\n",
        "    x = self.fc2(x)\n",
        "    x = F.relu(x)\n",
        "    return self.fc3(x)\n"
      ],
      "metadata": {
        "id": "mqIJiLZi-ofY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UxVrBnFWZKb1"
      },
      "source": [
        "## Part 2 - Training the AI"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T364fz9qZb2j"
      },
      "source": [
        "### Setting up the environment"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import gymnasium as gym\n",
        "env = gym.make('LunarLander-v2')\n",
        "state_shape = env.observation_space.shape\n",
        "state_size = env.observation_space.shape[0]\n",
        "number_actions = env.action_space.n\n",
        "print('State ahape:', state_shape)\n",
        "print('State size:', state_size)\n",
        "print('Number of actions:',number_actions)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TMPufLc3B2tD",
        "outputId": "938ae3dc-c1ba-436f-8efa-01d1ea0231fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "State ahape: (8,)\n",
            "State size: 8\n",
            "Number of actions: 4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c_dZmOIvZgj-"
      },
      "source": [
        "### Initializing the hyperparameters"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "learning_rate = 5e-4\n",
        "minibatch_size = 100\n",
        "discount_factor = 0.99\n",
        "replay_buffer_size = int(1e5)\n",
        "interpolation_parameter = 1e-3\n"
      ],
      "metadata": {
        "id": "boIgPtCeDEir",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0b285e8f-23c5-4f13-ccef-3dd526f1afd4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/ipykernel/ipkernel.py:283: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
            "  and should_run_async(code)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8hD_Vs-bYnip"
      },
      "source": [
        "### Implementing Experience Replay"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class ReplayMemory(object):\n",
        "  def __init__(self, capacity):\n",
        "    self.device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "    self.capacity = capacity\n",
        "    self.memory = []\n",
        "\n",
        "  def push(self, event):\n",
        "    self.memory.append(event)\n",
        "    if len(self.memory) > self.capacity:\n",
        "      del self.memory[0]\n",
        "\n",
        "  def sample(self, batch_size):\n",
        "    experiences = random.sample(self.memory, k = batch_size)\n",
        "    states = torch.from_numpy(np.vstack([e[0]for e in experiences if e is not None])).float().to(self.device)\n",
        "    actions = torch.from_numpy(np.vstack([e[1]for e in experiences if e is not None])).long().to(self.device)\n",
        "    rewards = torch.from_numpy(np.vstack([e[2]for e in experiences if e is not None])).float().to(self.device)\n",
        "    next_states = torch.from_numpy(np.vstack([e[3]for e in experiences if e is not None])).float().to(self.device)\n",
        "    dones = torch.from_numpy(np.vstack([e[4]for e in experiences if e is not None])).float().to(self.device)\n",
        "    return states, next_states, actions, rewards, dones\n"
      ],
      "metadata": {
        "id": "a6ONmQSLD3Ig"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JmEkbFbUY6Jt"
      },
      "source": [
        "### Implementing the DQN class"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Agent():\n",
        "  def __init__(self, state_size, action_size):\n",
        "    self.device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "    self.state_size = state_size\n",
        "    self.action_size = action_size\n",
        "    self.local_qnetwork = Network(state_size, action_size).to(self.device)\n",
        "    self.target_qnetwork = Network(state_size, action_size).to(self.device)\n",
        "    self.optimizer = optim.Adam(self.local_qnetwork.parameters(),lr = learning_rate)\n",
        "    self.memory = ReplayMemory(replay_buffer_size)\n",
        "    self.t_step = 0\n",
        "\n",
        "  def step(self, state, action, reward, next_state, done):\n",
        "    self.memory.push((state, action, reward, next_state, done))\n",
        "    self.t_step = (self.t_step + 1) % 4\n",
        "    if self.t_step == 0:\n",
        "      if len(self.memory.memory) > minibatch_size:\n",
        "        experiences = self.memory.sample(100)\n",
        "        self.learn(experiences, discount_factor)\n",
        "\n",
        "  def act(self, state, epsilon = 0.):\n",
        "    state = torch.from_numpy(state).float().unsqueeze(0).to(self.device)\n",
        "    self.local_qnetwork.eval()\n",
        "    with torch.no_grad():\n",
        "      action_values = self.local_qnetwork(state)\n",
        "    self.local_qnetwork.train()\n",
        "    if random.random() > epsilon:\n",
        "      return np.argmax(action_values.cpu().data.numpy())\n",
        "    else:\n",
        "      return random.choice(np.arange(self.action_size))\n",
        "\n",
        "  def learn(self, experiences, discount_factor):\n",
        "    states, next_states, actions, rewards, dones = experiences\n",
        "    next_q_targets = self.target_qnetwork(next_states).detach().max(1)[0].unsqueeze(1)\n",
        "    q_targets = rewards + (discount_factor * next_q_targets * (1-dones))\n",
        "    q_expected = self.local_qnetwork(states).gather(1, actions)\n",
        "    loss = F.mse_loss(q_expected, q_targets)\n",
        "    self.optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    self.optimizer.step()\n",
        "    self.soft_update(self.local_qnetwork, self.target_qnetwork, interpolation_parameter)\n",
        "\n",
        "  def soft_update(self, local_model, target_model, interpolation_parameter):\n",
        "    for target_param, local_param in zip(target_model.parameters(), local_model.parameters()):\n",
        "      target_param.data.copy_(interpolation_parameter * local_param.data + (1.0 - interpolation_parameter) * target_param.data)\n"
      ],
      "metadata": {
        "id": "q_21exmlH_MF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o1tZElccZmf6"
      },
      "source": [
        "### Initializing the DQN agent"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "agent = Agent(state_size, number_actions)"
      ],
      "metadata": {
        "id": "VvQFUynhQeb1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E8v0PtUfaVQp"
      },
      "source": [
        "### Training the DQN agent"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "number_episodes = 2000\n",
        "maximum_number_timesteps_per_episodes = 1000\n",
        "epsilon_starting_value = 1.0\n",
        "epsilon_ending_value = 0.01\n",
        "epsilon_decay_value = 0.995\n",
        "epsilon = epsilon_starting_value\n",
        "scores_on_100_episodes = deque(maxlen = 100)\n",
        "\n",
        "for episode in range(1, number_episodes + 1):\n",
        "  state, _ = env.reset()\n",
        "  score = 0\n",
        "  for t in range(maximum_number_timesteps_per_episodes):\n",
        "    action = agent.act(state, epsilon)\n",
        "    next_state, reward, done, _, _ = env.step(action)\n",
        "    agent.step(state, action, reward, next_state, done)\n",
        "    state = next_state\n",
        "    score += reward\n",
        "    if done:\n",
        "      break\n",
        "  scores_on_100_episodes.append(score)\n",
        "  epsilon = max(epsilon_ending_value, epsilon_decay_value * epsilon)\n",
        "  print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(episode, np.mean(scores_on_100_episodes)), end = \"\")\n",
        "  if episode % 100 == 0:\n",
        "    print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(episode, np.mean(scores_on_100_episodes)))\n",
        "  if np.mean(scores_on_100_episodes) >= 200.0:\n",
        "    print('\\n Environment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(episode-100, np.mean(scores_on_100_episodes)))\n",
        "    torch.save(agent.local_qnetwork.state_dict(), 'checkpoint.pth')\n",
        "    break\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WAidYuazRBWT",
        "outputId": "d2c82422-776e-41c0-cae4-05a7c3da8ad4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Episode 100\tAverage Score: -179.65\n",
            "Episode 200\tAverage Score: -89.27\n",
            "Episode 300\tAverage Score: -26.98\n",
            "Episode 400\tAverage Score: 41.90\n",
            "Episode 500\tAverage Score: 64.02\n",
            "Episode 600\tAverage Score: 138.76\n",
            "Episode 700\tAverage Score: 180.18\n",
            "Episode 798\tAverage Score: 200.17\n",
            " Environment solved in 698 episodes!\tAverage Score: 200.17\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O8CNwdOTcCoP"
      },
      "source": [
        "## Part 3 - Visualizing the results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cb9nVvU2Okhk",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 458
        },
        "outputId": "8bd6bf5e-13b8-4c92-e812-b338616dadf6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:imageio_ffmpeg:IMAGEIO FFMPEG_WRITER WARNING: input image is not divisible by macro_block_size=16, resizing from (600, 400) to (608, 400) to ensure video compatibility with most codecs and players. To prevent resizing, make your input image divisible by the macro_block_size or set the macro_block_size to 1 (risking incompatibility).\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "<video alt=\"test\" autoplay\n",
              "                loop controls style=\"height: 400px;\">\n",
              "                <source src=\"data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZQAA/YdtZGF0AAACrgYF//+q3EXpvebZSLeWLNgg2SPu73gyNjQgLSBjb3JlIDE1OSByMjk5MSAxNzcxYjU1IC0gSC4yNjQvTVBFRy00IEFWQyBjb2RlYyAtIENvcHlsZWZ0IDIwMDMtMjAxOSAtIGh0dHA6Ly93d3cudmlkZW9sYW4ub3JnL3gyNjQuaHRtbCAtIG9wdGlvbnM6IGNhYmFjPTEgcmVmPTMgZGVibG9jaz0xOjA6MCBhbmFseXNlPTB4MzoweDExMyBtZT1oZXggc3VibWU9NyBwc3k9MSBwc3lfcmQ9MS4wMDowLjAwIG1peGVkX3JlZj0xIG1lX3JhbmdlPTE2IGNocm9tYV9tZT0xIHRyZWxsaXM9MSA4eDhkY3Q9MSBjcW09MCBkZWFkem9uZT0yMSwxMSBmYXN0X3Bza2lwPTEgY2hyb21hX3FwX29mZnNldD0tMiB0aHJlYWRzPTMgbG9va2FoZWFkX3RocmVhZHM9MSBzbGljZWRfdGhyZWFkcz0wIG5yPTAgZGVjaW1hdGU9MSBpbnRlcmxhY2VkPTAgYmx1cmF5X2NvbXBhdD0wIGNvbnN0cmFpbmVkX2ludHJhPTAgYmZyYW1lcz0zIGJfcHlyYW1pZD0yIGJfYWRhcHQ9MSBiX2JpYXM9MCBkaXJlY3Q9MSB3ZWlnaHRiPTEgb3Blbl9nb3A9MCB3ZWlnaHRwPTIga2V5aW50PTI1MCBrZXlpbnRfbWluPTI1IHNjZW5lY3V0PTQwIGludHJhX3JlZnJlc2g9MCByY19sb29rYWhlYWQ9NDAgcmM9Y3JmIG1idHJlZT0xIGNyZj0yMy4wIHFjb21wPTAuNjAgcXBtaW49MCBxcG1heD02OSBxcHN0ZXA9NCBpcF9yYXRpbz0xLjQwIGFxPTE6MS4wMACAAAAHGWWIhAA3//728P4FNlYEUJcRzeidMx+/Fbi6NDe92RHgmdr9AJVvAmuyvIIeFf7qFlgX34mc64hPS70rH45b+I91fbwvSP//UozrSiVAYQdSoNjLcU9HiXIgJ5SMTsftM7YMn/4CpBL5KWRbZQeQoSMzvSu2Lxr7fhO+w83HzokttrMQMmmLY7luHvfEokCckJlD80GFkDIU/3w1KHSrDlKtAoCu+EyGuZdBmcX4Zt5P7+J50fpE/fOkJQzOf0SMdWBFpc5KkyJyALU9i7R4UUjO+eb5qT0svM76oe+gV5DtIkMAAAMAAAyJ/9ukjQI2ZCK/3cDTk7KoAAD7BPguDCQB3B3iHCnFNI+R4tRul2E0Sf6yXa+SbggilRc4A/z1of//LGXEsTWeVrBIZII7OgweJBdwFCrNT7QhwDM1NuJQKdw3U87piNVrJYt4hhuVkfQWvzPJ1MaKlO+Fg7JwjKPWQr3k97iBmmUjw8XTNRSFrYpSvAe2wnXgR7D065Wifd2nW1G7xmJn7dCXKeeVaLYnjujShXkFiQtG1TNzjzaLrL8LI6NKsHDMnQX71xx+wcCKeaH9xNvX4bAR6IUgygIxSXsk2xrIqoZs023ZfEft/Rq5cR8a1+R1RmGmiqZnUGIpR7zwzYm+JCDboxRo6qKBKTkLVPmTZBHf6s45X4afcd7m3Ik6FOgn5DS9bNbv3HreOrOv7b2RL+TgrKhbRTdeTFSqYNpfxKquUAVquCy0Wfpo1biRMftQiLkTHnLI/VUscCeGw2FhcpC8QInS+QmkngMxdwVSDAKvgOkuseMSuXvmG0IcIbtvX8gVtZ31Qdi+bcWIBqRlwXX7GtHpli09wdNqReBuj2Va2k3zmyXxWeWaOipmRy6OIdpIpuFLdkW4cx2gQ745uC+6vEmNQYuU9MkCK6zOzX/oD4JtSMyV+J7HE50J+Hh9o5ZjYYGi29zuaCPz8niAIXiFyEENBIbvcUUy3M85c6Pm5knCCyfEnEQcl0k4v5+KoN2F6ftQ/fAlxtJdwQQIIXKARdtpd01dJuaaIEKOf9JX1naBiqHL8n3E+HtR6n30OUgRVkiaKGpK1Oku2JXMZE9ID9WEF6i1sN0M9VzX0v6moK1g6ThgASJ2UoiugNLwVAaja2oVo5JDWP6uqWqStZaZe5awlh0POsXTrrIW8ITBcdD8ojtdUMh8ILuOlyinZpHcngq3Zme1XOae1GZT5VbsDLtbsftoucPCc1jGWnR48EQaKkK2oQER4WePosmYmuxE65vTei7+AoNpTt8JaRN9g28P3ihEjBOqKcYWVZ2SCN8XsKCkHgpiG7xIcH0kLYknlpaQcfhQEKaXMgfJPTRrVnqTIxe2w6UY35Iwsdccj2biX124PdERn1D27JWvjtTo9ixMa8uzcF5zotHe13TrH0pvLSWEh0TgcBE52ZY34wqW526D5RPFjU9JItieKC1IvLh1MQ6tRvOh4y2QUEE9qZApR7eriGWK2/eJVpiL/Bd9Vv8pYcvq2jHNx6gnEfsmKFko+P4R75FR45BF2f6ORN1Qu+pD/SkhYVNoEG7kjJ8rTRHh8FrPPiHv3W1yiwKiu/crUQmq/MJ/LXVCFCwKAtIMI7lHCjGb+AC5yL/6YdAvpj5pDYoRVcu0D7RUfWeDwtsU1EbKmDLgpgmAKTc+PemtGU8w1u/1t+6fObZ/5lXeYJMyaM/lpHB5DDdafdI9hgnC33KljcARyVnfzOjuO+EbQvP2d9ZuqdaCqtjFSd2Kvl/K8I9ecz5bwZlMgfh9NJXDpxX7ZnTobINY3SR3J5jzbCjfi463Rqdl41mjUOmLku7mmwhMxODyrAxh/MzKdaICFfIT2PAbRqcu/l+Y26O1QcVAp32G5z3idjiIdayPX1QzH+BpknYCvOk5q4slHDu6bvQAGRR/e3V4DV2jDoN/1IlKT1ul1N/Y7SN5oiJuT7bq2UkZpMWuK+q1MGqGP166rclc+uUPHT1ZLlTNd7cgQ8kkDraRYImdlIgsgXUxHm5JtlV03+FRlNbuyNw48fObcXmI/t1c/6VWp5ZNRz+3oF6kYZaolcIFW9rUTcwTQsYkG5Pob5I+mR1yUvhd2MJqnl/0n9ZBfbj7hdeIdBTv3K6i2BMQ9OTpCCrBPfT7A8jEKp8U/R4ftYmtCzU7rb44oXuERgdGXAUrw7a0kNdckwmY6IxfPr52fhSLwjPThRMcWwPpVSi3kt3VRibGAzlhw+C2Rt47iVnWtBg6orHDoEX73nYB2i0HxNovc/rkWM+bozBFutCVGmokbcTWRz+tBa3HOLBKWtu2j9rjpTD6R5AAxKoay9zDdO3o1F3jOJY4xpAloEFEOWekRxHYxyOASnDcDkZj6k2gEuv0hWfge05oABDgArCb9e0MIAiIAAADAAADAAADADZhAAABX0GaJGxDf/6njkKdcEgl/G/9h0U75TdUGWeg9FgUxWlmpkzWCIfM/PiBKC3Blu0KiId4sUgSPAkM8Y0V3djFo/l/aukVDCB6k3k3JCkUyuwOZmKYVaG2fr3FpXrA6oEJTlAFThio8CMSpzG6GkPf82SpocMPuJNGKyhh0P5AAAADAX3RV1zsAq2sr48Dw4yxY/TB0XdiFZtz5dLB752r8KYaWGA7wSCCtpuTh5W4wen6T6E1PZ73A9Zm992tSqcianrYACTOD8HH3C6jFMA6x6nn7OS8EY8+yB564B1yTZQ4Ft9r15vrAvQDK4ZSeffQ0CS6PIe08Mlyma5H79n674YeaKPdcCPPWdrxEaZMpf/u0L+FVmuWUIiLNCvxgcR2KZTQKAGI9iuYkMhL9cqFwYM1Ayqozx1gfPPigmULo2LGcwXA8PyQh0hnl3PDx2wWPirJr9e+i/rMlrR25wrzagAAAFpBnkJ4hX8L7bAwp/BVDNp1AAEnduJeufg8HGOqXHXMFN+0m+ErSRmgMyuRtauPe9h425jrnH4GInO2hTrV0wuTledA4wAQS2vo5d1gWfgvSGgoEIKpLsGwJeEAAAAzAZ5hdEJ/Dd24QVjuf6X4hqmbFHOFcZlsFta/wkBMMAEAwpcW5v7HExUa+Acxc9wxAE3AAAAAPwGeY2pCfw37zMcAcsZweNtcIOoQqNh0Up6UeR5dN9BHf3bGkxrqwgPZe2ACSYkohB30U4v5hWjKGMoyqwDpgQAAAShBmmhJqEFomUwIb//+p49pzngsIuAKme7tnFNiy3RbM2kQrHVxr18XpPnP5Ip1eQv2DGwRotI25ehh3PqRzqN/0z+c0/M69ZVG2ugdY0HgovivT1doyyojKH4EHpGujMkBBea0xRddA1jQOX3m+WJXLHJHZSv0fwTBoMOIAAADAitt8mtUEcPrS97k8x5tFpd/bAadiugACluI2H4QekEPCBluOU38T3Wp4uaVWAGPFD3EsLfz5SwhZyfWNcBJRqpBGw3TQYOeEj5q7auV/H4aKItUrzu97tqmakBoKD777MfdcCs2tdf8NWrGnE45/7ntP7QPYWJ8eZGTgESJ7TCLuJIEVS49faisxQsMY3otFmdlMEBq5xO4jVlflIwMadKb88XHPOAYEQAAAEBBnoZFESwr/wvyQMzxYQJxBGkcf5q2eJ6fmnoS1BirEsFOscIshbhd6AMkB4Z2dhMmZEonhqk7Yourhm9AAAFnAAAAOwGepXRCfw3goCvZgwOmYftAVO1ZsKs5+I9hQMOgRU81+gAez8gW3rqPoEmHmbBrMyWAAzdEIB24IAPnAAAAYgGep2pCfw35lIAUH48QiryBJ5OkEo8rh0QEdxye6bIqMNd3XlazJ1mOChwNin6bZJbnJ5JAm6U63V0J7XBvktJIsNZi05gDoS80Bwfi4uJe/pRXXn0LIl5DY5GhOZ9AAGPAAAABzkGarEmoQWyZTAhv//6n7Wn9VEAKyyX6sGN8OIY6uazg17ySnLoNkPbMwXsRCIsbZIxnDS6EH4Jd8FhpFJnn8n/sCDpHiC5j1sdO3RpGKpmxGXpbghLAwkP4rDAWa3vWzU8llHzpH5MsqZmg+CR88IbFe20AgRtvMiUtKlRkI9kPH9LclVCtIgs00+7NQjfc7p2bQvIIAn+0gvGwYDVU73Wbj0TWCz4NxIHjNqW2ypqDnNJ7gfM/5lualEo4SmdawHnoWIJWLery5nuAwaRCyqLUHGW8uOFArFPdag5xAi13HPP2RdtENlBIsWunu0yww8hAd1vLbwQT0Wmoes/5S/sHerZy+LNz2MqsPxJ1lCPPsyhz36iPfiol8viKcSrOmSE+Z7c04bRMbaPDFy10t8FwYHM0mA9Jrr+scs0aQVFLtilO7bH7wmEaza7c69Ugsy4UBfoEyt+ibeFQvORqn8fUE92geCJ///qduGNgH/u4vFhiMYkxcsmsMcKVWvdDuYfB628oZzEQPvpsm6XaylqOLImS0fSOhs2ds8RiMM0/QBXr/nRZ6BMGADl2ZXR6r8hTuP/tJyccgxyqGr35FdgVcnS6cVLQQ0lPJoAu4AAAAIlBnspFFSwr/xQ6v0/c6Mc4suwAcVht8kEojn+rZSCr3WdLeJC0k1tD4JXXSupCCzimqc6ScybXvU8fOOyN5JXwg17v46TGOwDCK6XGn2t2W8cprt2ScP9oxLhuKkyV9GVWUf3LEe18CL3jhWvi+f6PJ2UHT0+yImRQASFNBPGsRN4AokX1KUBSQQAAAHQBnul0Qn8RrFT98ACHuJ1KITuR0PRoKQtY3E7TEZF4RZ0ATKtMsT+fi/p8Cs9XIJmxBNIsA5/y7HAOZARW/pNfWYwib75GiHMwM2Lr10iKlkhZ9PAJbTIrQUh1X4QEEpJTMLt3nsxH+TCOwoA7Ndc5VlgCPgAAAHQBnutqQn8XdAmcgAQ9oW0ppu2fmAoG6PKEa7I8BfQhiiP+z6c3OEllQHm3UHgPjP5CMjp5XNmIai+50b58VX/NZcf0SEmC22GfUv+tn/Rv0GPWVUENez7MqtDbdS0OaNubgTtooWtnaUTPQZJAB5fuLpQPmAAAAXZBmvBJqEFsmUwIb//+p+08/CGWVwAJauPaMKh6wzKvB6PtpsjFUyWq3n+6R80YdxvqVkNgqNqSKow0ZNkAGK96ZEElY5qocOSU4Dp3OmDqEiViLUYt3HTA987x3iBQm4mm6L93WkcqiKCFJPd/gt7yD0Mo56qppujIefPAcnrbXLDRNizazg1hAXxcS/0I5/k+yQYjHowD/OLULkHEgcN+Dt1DAQN14mdgvBZYTcQ2fd/Jk2dfRAxHSaOdt+9iU+lepxqYTY4MMsfAHK/kvEislrJqNGu5pixAiAykpzAZYJZBsXATWGTj7NnjzbsFAKMXUIO2vZBoqvDHUAggFXPdNze4aNRIYFTEpSO6bmBVA9piZzOaWsA3Kf+z3W8L/vIFDtgU0jOTGNX6RO0laIINHYGtrJmx7MjSikfp9Eryu+uejyEvKaPDqgOr4WBE5tjMmE7WurkcyyVVD6MGfV4vBE704n5/dsj0Xi6x1XGoqFXRKhV0gQAAAJZBnw5FFSwr/xKm7g5PiQRAFMLsr47eb53DgfCOrV3UUSC2Se1D84bLyx8KF6XtvdnlKU0w8pFLhxu2QujUmhKCtyFcTXVIiLxYliqKJgor1BKnVv1eMRr3LDb5oWRdw+zdHMjJK/ehL9UECBKMyHZNC9DDwffeP97hjs7V32gNMbQ3u6xFT76IfAWAAbZDismXVxQAXcEAAACsAZ8tdEJ/FZ5PG5gBHUVf64IVfkwDL7dJKPYT0NwRkPLIJAqDgETXw5fWDcLpFSq/oGF9ygHEz+ljjbK35OHjMEFg16Q67lfeFtaAKGWKqLGkyQhtD/M465vUXdgW8oguHkQpGYF+FKRrQ9TE+xbClN671Kmhr/1wspFH/N5CCku0r54M/8BfWMh83P07FTXABo/tuFy1AzvjuNRfcuifCtHsSh5IAHUGzUNy2wAAALIBny9qQn8Vnk9N5oArfldLlSB1g/tjFwZriokGauvdqwEgVReyUfycXJj3njeVVjia+6NEVLj+44J8RFa8aFWXrY9V7H82COpXM6ZC85rf55zwSD8/h9m99Pz6s6Th6HBTNkAQFNYGuIhSpsy5166Q9txG6kw4PP+Oxywze1E8iXqGx7dCScbG3RS8y4hQXLj/e/uVv2qhsQN58V4XIhxnDQlwnWACCLylIEJFPB7+gAK2AAABfkGbNEmoQWyZTAhv//6n7eKhNXIYFDoUPXgrTMU+2AOD/P1x40AX5kMwpjcgx5U7lzd/vBxRkbAL79GhqiZh1iDS3OhXThS+euJ+qR2s9pSsVHR94D4ePEoKBa8cyf/40/7qK/XUjf7y0WDib7tgy4rSlBWFCEmIRFZi3tGr5nNh9iEtmyJD+SmAdZ543kiiF7+X8ZfI/oSXzqQBW7789noacE8/7dAMgOUCe9iP/LlY4iPu796TsAFwY7dHa6kWEudq8ve6p4h4eFFID22rwsPl5LeKUmXhkWSTIT99RePUHutwomJoFBKb93BbLBy+hZu1x9FG+544/yhk4WyEHUUZZdiOaqM15CRA1+nZDeTZr+bRSt5dWDZj/HiIa/LaCCtnUrdBQ6ceRgOo6SlCe6C3zK5csh9021O0SBhJFeYl7VN6Ob7HeR1t3Oy6DXrDOpx+BZddzU60/f1qi42QC5mq7CFSV8mParSIosYOHgMGvMASqvjqg9/wiXuABWwAAAC5QZ9SRRUsK/8UJX7ewJYaJGKbRRsN0V+S9LkDrt2KADg6gbuVEy+TRwDfE+cX5dAI80AY6/Ck1gJFpac2iNmqGrfCucneFTtWBsiPstLNonze+6h7vrN3+pcZncwfGy/yFPab+9lQ5X+fknm5VNJsnsPA9ZPH4ZfT5HwM2+vWCAIAn490Y+laFuOBNr1gH2fOoAf9CMULv8Ywu3OwmsZZVn7SABX7BFgpcWwIzNNwSAF5rlRKBfhgEzEAAADWAZ9xdEJ/G/+dwDV8r9uYi52+Yck0sW8fSF3rh8oNcgywc8pb8kL0hxqMRDgpJ1dA3Qs8I5d/dQtMRlyt5hqqbQgugUHnKKu3e+LMKW/yWyTREXzPzfjnKTRDZw6aFQaZ5vjLf8fMoKZz9OOZV1gTbHif/Z81DvP5X82q3vPy7PnPKBFHJQ1QxAWvR3mvn+MmvRyeE4wC8b81/bM/qrz6F0m+MPoxURbnv0O3sXquVY4estrfbODxB73H9qersV7rITDDicZOL51do6usTqk7WrpGT0CJgAAAAPIBn3NqQn8HLs4J9UPgmxSc/cYffINpiNEU4AjVJjx7KgPAbaqY/dwBHe2ZqD2wh2I+nma4AMIq6qBOQqNlZPz70IGoID78N0L1NsF7j+wcIMwuiZ6Pj1d/LmEMyQBzsA4G3y0rXqkHGwRq47FAlxaZkfXOjVuJxL85M7c6ssasFEsuus/w7X1ud/HXMWGUY/TT0H+dNJVnlpMa1NbhE3C7M4RMVAR4WebC4h+x20bmPxU+bNyNZKNO9f/o1APOFptHbq6UCBK4Nre1zK74RBJ7hY/4jM6+dTshn6mG+QW1CkCfHq8gR+OgIDXeWoQfiMBHwAAAAVNBm3hJqEFsmUwIb//+p4QCvzz8w+TrwAH8HzOU5rR7BVXB6NGHQPnUCmaMKxaFgkhYrG52jUnnzcB5WGK8Km0SPfQ95INhkZ/3cyd0NV6Dmdp5+Qf7+HyvIrYjfStwcthcC36vr6Ly9WtGYIiDmMtgvHAx6TJbsNi0w2qB3j28LiGP+3o/uIQv0QJlLn4txzVxlPae2h/dwWcrQVWJVSW5vEmbme2zKCEOvGt4ptDP4LyFtN8awLQVQUZxtzHyf9FIV+tVGlCvu2XSCjniBfgWhcQDqCPmRitCejKmtH9SU9cH/0IG6FZKwlRiqW2IHpcrThtTt4vqoE7ZEJbBHmD0UU3zNEhy3Ynl6iyEFMGF3DtTFwu02PX0IBf3Auq1z3QN5vgPirfJX3AE4Vb/AGlMBiRAu3yeRObndRU+jIrVVFTs3neqaXMVpqJZVO1axrgAXcEAAAD+QZ+WRRUsK/8Bp7Ct8J4j4o8MT9dMDnhACrNd4uJ4Q/ysSZ8f6RH/oMkVy9Hicz9zTXbgFjoK/9NZOyShz/Lj06uxyHghJKZsor2f+FPrv2dvCcj+Xvj1jCB1W8LkyDO4sgzAXcK2A6tmOIyw0R5+VuQtKDrr5LYBrzE+wJEL2bKjVtgxk1Pkc5HcfZzBO9OOqZ7L+rXC62R9YHSROsFxttdCDLlRqEpWqjhwX1pTXO2vNuzudeN5odiGRq06inuNmTEAXYLudn9a5pGbFNgctWBgzxt1TSZLw4TwulqjkFR73QQQvaNzYqWbItuZ2rPoF5Aqdkmd2PGMAc8ABVwAAADcAZ+1dEJ/Ae+XCjKffUZff9ADldsp+x01XkUD24iz6EDYdL+WH9FfFNRjLfIi9/UAxIflrgjs77f9PGq6BMpFuaOwAImhywmpIQUqLvdMkkKjmwu/gBwI9A1TCF8vkd1adzuMUZhgmmM++lmKFtdQ3Uqg3IJrbPpcxcc7rEvWZ1RYaSFdlLdCXmfUbv8jcUl1h08U0GH9t1ITG7CSv5/if4k4EGKGFgaGaAdEY4pMpb/vQvQNzlxWvXPTatz13rROrsM8JU40B/9mKdAX3tsfiyo1VWwFjBQpG2iCPwAAAMMBn7dqQn8CCbm5h7lK06hd789AA2vt4mTj4w7kzTtdKyhGgLR9CBVgM3J+9mzq1cJJzCAa5ozCkvIpbR1jTqGyihWyruFnijhhq+WPfMW7oeC0/MInINT3S/6xF6iL1gwBoA2ihPJ8Lvf10GT/WGCNt8LlWIJK0c2xDDVT4e36GveE+Tkx+pke5PJ4gxz3OyRQdjwAASZzBrWumdX4Jycowo0sx0i1RQxWPHfvvcjFKPsCNnqXaq38QdceQWV+dDwgFbEAAAFuQZu8SahBbJlMCG///qeEAr/SjDL8K2dZJnunYmcncXVePgAk55WYgZraA2jsCKaQBsQoDDIjw9fvH7Ll/37m0tU8gPz9jqm88T1A3Kq5vutqnYGeUWLjSO2xRjD1fDKm+GMpbzq80rFv84+MAcklCbVqGGogHQQZq+H+hvK/9AQTzLzzK7UHpkW6Uk4jfC+eNwMQrjDFR8zrdJCMNVDN13eKBM/j2FMm5SdrPJWUdJo4vbj5nlYM1yYsHwA6EwHtKtc+cE8lW5TCPqTrGWOgYJLLIvaJM8P+683yhWEmEWJbODt79QkUGM03z+kGLgFya+euXfZegm0ms8r/QAP5B3mjZmzmP8ldEVYcUfULWv3mchf3qdFdoN2Q2XC9ZcjX6JJm6vJkUJDp4KGlQuzuQCeddZrsST+VOuS3t9JgfZURQasmMpgJSrZxPWwVxkx8j96cgYtxN2CGuh+/jI4f5rAK9HaMPhR5daeQAGBAAAAAykGf2kUVLCv/AbJ24ADi9E0PIi1/xdcb1yiz56NT2hi3kEzkKvTTvO77XI8gGf9bG+rKXL5/VeVrEx5mIEcLOl2+bByg5wHuAMIT8Y0d3N0zg68TJjm6AfFsC/G9w3SZ8xBDxT3rrI/fBHCpkiJp/0X8Es5OvntvqnmbM/3XLmSdw/TJzP8fFTk4OLOShdqkulqkCe+jnfw5A8/qQW7lGiSR/pTgoZ7lkIJZCbZ4YJr8FN9riO+pz15vNVbG4BdhIdMj420p9jIAOmEAAADKAZ/5dEJ/Ainllrio9mmAK1Hzmk4tIiMk2Ki6krqVDSQ2/3fkcx/ZwcPbh03ZOoEkCBEhft7CZdceRnrXgYS9AGE5OtF8iwljYpck5P0NrzqSdQcD+ZxaJ54G2o7ruEFWPpvn8utU20H8pfLJa4VwdynGJkPIm0vm7p0SVDzpkYs6afNa5JqVEgzXl3nJtsGJZ0yguZLn9g62s4Z76PVkq31Can79CspDCwxWW1V/lAv89Drk337JG/6PPfoKUaUroO+CKpAWUAA7oAAAANMBn/tqQn8CMyD23AAZ4D3/B7KxS+uUmazOu4mjLONPgeM4PTBscdhEAJOMPeUhFK+hR8tHOf66WERhAL+I3IvjOcR/hOuraMhS6K+zMZ+lp6uYrMS8+NKQT+e320klTZQTc9njMdVb//6PltK8pD0+TqV4BgjxXiFhbLh+iAUPAmtrq48VxJmRlh72ObI+dhPL0fQoVfaSk/I/PqOmSlWeLkHZMeFbeCIcKPK2nkkgiJP/1+oV2nLT84QTkAvW/qDnHIyoHdV5nPBR8JANVQuAACLhAAABH0Gb/0moQWyZTAhv//6nhACbfI2EiL0uAC6NVw3LFL+E2ysUmjDgN951ngeANib9WApZrSC2fwq3ismaZ+4Y54hr4IPI0adMvz/8S7oNPn7fBDRpqW69ueglwR9OhDMO3Nak6DuJjGUWWkDLMYH9TUQ137EUQobOIIfC4MZkq27m8LsBuQUSSoMNA3/4P+tQ5aENmYo0F2V8X7obiKJHQxfhWeDftJJNhYGod/xR6q4rw1PYRCDC/naWO6x+u1R0YM9CT9NWrwAtM0EXdC2hcXzBk50WkOqrXnO8GLWysNrQVNBdMXzJ1D59zBiqePryyFr0KNktft7ZjnSDEuDLeMJdnot/fTa8Ju1QEdH92o6ihcE1DPcMqE1dHzoN/QVNAAAAyEGeHUUVLCv/Aaew5o5wMcFaDW9RQoAWHi+rx1NvVlSDd3GKRd8QXmP44FsY1JMfY1dVX8cSBfrv5sgIk5XuKpiCoWeHl3gxh/BM0tJsq+TCNKpG5d9TgsYodaw+YB2aXGLjrA6eWNjvu9WfVdYMk9U9WOuwhHuIKuaJQOPfK+i9ATBpdkAICuM3ESx+1YJ8cqQx/BQimixfl4FPskCJWZ/Xx8sLqbMbdZC6J1p7gwteFqab5G8pIIjEChAAhzkzMtKNQNuAABswAAAAswGePmpCfwGkeAplp3j9T2PvTZZNKgagAWunf8vD1oeF8bNtn0coq4TBYI2QFQJXTQNuMaLumCsGjBLN6TBwp7Sip6xA+dMDTeJtaiWd1lGhYq/VZrKUY0Dt43wS/dlKTyxYvKpKwbY/x5dUO8k+WIl9iYFP0lTrO8civXsvyn4aApr3fOo5pRCgs4WExOs5QFEgEwDEhYoPYh8sjH6SEJWsRdJYHsw6EEP+xe6paMTDAHrAAAABM0GaIkmoQWyZTAhv//6nhABNTkuiAEtkdDfLPUs9KMJ6O0+BrH0IxRWSeNsYS+kuNFHZgwxpOUQkUNXYiWo8mG/ZmeU/MQS+kqSobdZRR8SGnYmFzYpBCq8M4FcOdu6lcP2BxbZb8M1ppSV8b7aqoqL70Ofm8dAkm/SUXFGPrQc/HySYhqJF61C4vCV9RmDE+XZZDm0LxjnPR5/EEDU722I+MN46PTnHaD4DeWqcolPaAcXzugf8A7vF0EjyDOzOMo3Z2A3yTbbt7YwKuyPBXNOb+FYUN8l9dfufEtQ3DMzWZAGzhxpZOKvVerzsAhitnZWi1I4G2QCCzAkcNu+viK33CDfHQz2OjODjlGHIQ+KHuVo7ijXmC9Rb9sDyHCjU/s4PgTaPZNUKD8i5d3S5JymAB6UAAADrQZ5ARRUsK/8Bp7DmjnAxwVuRJLvm21gMQjFsANtV05mnPAfiEFDm/hgjNXHHB7lyDaUGteOIbFqH/2PJkVaR1WlG8OXw8PrX1fXOFdEzFTgOrLiwA8ES8mfmXIOavAsG9bNA4zUqo1JcEYdlYGSX9ccV0dNIlPuqXKtEfan3DhQe/u4CQCO1vHU+aq2I47fIBDMfevcwqWJs7llPW+x+M643YVcjZlNToTiarcV5Ol1FIYIWQ4sZ7FJgSo8ovuAxhTXfOmdJ+i+xSaP0rv2tuvM4qZ/Q0LS07cSZ/fw1l5/g/xdyM+aoygAN6AAAANsBnmFqQn8BpHgKdjE1imG+kjNyACNTy+1FXjuKsAt+JbdmmDNmLNBR1pbclBJNkOrAT0KJIXPWw210jZvWWreBiJACZul657IK/NGAKjiYqvhUCoN+5wNO6OHctLWeehB+W03uqCcI36e6dryYGfTHOEQ+QM9F5Klr783/uDghGcB+MRXfsWRNOCJj9nO3sQI4FIqsfnPPoaW9THkkwl6YzyulPRDCv599lVjG41vpplGDuw/VlqD8HsYgbBRROg3YYeYrAtp2yEtDhdVUU6eYsdDDKwF3PACgIeEAAAEmQZpmSahBbJlMCG///qeEAE2+RtRv/hrjXfxjxcLgVRAxFNGAIDsfRilkW94QfyAbuoUs2VUmRLBrabbXTaQ55n/ILogc+98SM2iiulzb/PWb0QegPTG+lIhnjxB9tX0Rk7Bt1wy4A4aQOqeDMEywBfZh4z63aPcV/8kH4FBKo6N4JKPXsGusme9Y1YVWr73JYf4sZ00prxftnQPVigLrTHEqW5Z5j7/DmxpLENigQ/H+Eb0JjTyMnd4OyJAAIADPMfrjHHL+Uhl7wn2OclPegvIzLj+lwBrF+jMOTLLN7vyg9vpBGU9OI0wxu6n2i1vYOw7UrdS+BjwdKUVTFc0S/dbAmpY2gJecBiE4MOYRLVaoMYmh5u4iUusphviuLMGTv7c/gEPAAAAA0EGehEUVLCv/Aaew5o5wM/SmdtCwzRx8qewSjfYumlDr/d6G/ntAFb7rH2XUDHl1zn94FuIcUmPy9S1FhW7zisXi4ZPnlAcozIVk7Ppu9Khp3OSAbq/uRV61vqEjvr0dlHJDl7PewqQgBxmkkVLxlc4dJqnCnCPWMI1Sti2FZ9r7qeEqRpPJNtqorrd/6ILzW5rsbVFsED7M66IK+FEJrgkCXn8wTi/YTs6U/GrZ9cf/zr+Z5aa1ZCnz96OTYV4wEBoIuG4AQLDWg1nay5oADekAAADYAZ6jdEJ/AaPyfP+poQBtIrAEsJsqjCCVqzMAo30htoLVHJrXcWcWFwx3PfLAcuGxjhqPJEuaqOXYx1PXR3gQL2BP4+c1KSyqUl3pSihWTSgFUhDp4eyP7cQ3Dq6czpzYApi2wMkbg5hTtgwSHzsAR+w5V7w3yXSGP0jFwOgazXsmn10Rtg5tN2fXb86zJLNB/1rXEJVskH11AXr1I3jSOeR1rpEclGQApLQxVF0vjtIIzpH4S30198YwplDg1jY4jTKz4BmwWLFoFRETthSlh+bvDgAAAwGBAAAAzgGepWpCfwGkeAplp1k5aSSQJEn53vLjYXRYrKS4PqBxrmgBtiegrZJwTSfhE1+AFlKufIaKz8dKOomGaDR6M50g8n5idJ1Hn3P49BQcoVuj0Ru62PrTGGpxIBXdt9N8kD+Nfn8DYJRyg4UefhGNY3B6VbPX5d0t+u54G5Ps6tOMH5RfrEI8RHqe91sEf/i8iQk76mYoPxjYdF4j8f3HjpNUcz/OfxusmkSoNzl+RYvEKKHROWoBdW1Fo/pLjDTIj4ZAs7oOD0uUETsQYI+BAAABUkGaqkmoQWyZTAhv//6nhAAZwys8uXs6TEQAIynOVmhbwWZNEKyXvy1dxHyfF5ORW9PXcY4LVKQqogb99lu+rMRA0tKFD7X0WMir75z7NIB2QPe3G4tc9u53V6ucfW1EKn7swrKcHQvmRcEETlPB0aTJeyYjngWDjTuraDgoTdTJGlh6aR++8dSsqeTZMm3tGPx4pDWtApjTsFxlTENqvjA5QeYL43lrpTrquSPpIb0JRcIM7F2w4oY0+mjNj2ZOm9K7NAnre6o7LX1v6MelR81e/6MZzL2wCDt/du3NVusyp0selIn2/bSaBiRFuem+05TchpjmtWZa/Ysed+PoGAEcTLIRtNTfCjr9YEiIBPxLA0alHjioU4SPv+7/s4IhHlvrfRzhFOvwx7jopATRw3ry2IFMIDD0ydLvr2llssBuU5O193V1jX8s8xgnVQrkrBIHAAAA2kGeyEUVLCv/Aaew5o5wM/Sma5Fdd6DxqCxIw11Mc7tn/v2gAXPjJF9UFuOlxHZ5R26SrhIioNQPVE8YdlLiLQe+1qs4LI97JJkrK5ula2Hc7U+c/A7duRZhNunpNfAqoNYIXL0LEJFUBKsQ99t6bPLwdJ92qlXyUEW1LgOSg/sEF93Do4orvW0W/v24pPMnYOQawt7r7l484ro56MEydmEOp+1otvmGNV6q7D+HrtNe5vyTWyKfVFqy+xwjqQ5eWwLLjOI6jVtxjn+A01Hrn/CCQ+9sKYYUIAm4AAAAoQGe53RCfwGj8nzlfNS69c7aCKbPjPJa9hKetPBCtv6CmQRsy4jnhKvcZc1swV6ugt67lByY5FMOw8gBasquH6fntuh8DsAzqZ+Z61DkwtkZodmmvXhjZbyg60od8sofIAoOMAh+oBCroQ8TR0iF+GTJMBt3YX7YhWeV7EHSUPgQY7WnFs4xOHPJmwDnRA+uJaecxgk6FmTUm1RmVilLAAH+AAAAqgGe6WpCfwGkeAplp1k9b/JbIkPc406pzBEpZZv83napLY3lrIPpoAE4dpWrd6pPw00aEA53rUi4QaPCavBJhvD0ngyuhD2bJrNFRyDLHjOD82V5kVdxtrQfFYlbKi90T2oou78gE9T8xDqe9DoJ6behCwSWiaHVqmCZziBtpkmSgXFSUP9yp3szwkPYosktWxHFeqD7VJNOKzMhSSKut2nzODXo5/PsAHHBAAABLEGa7kmoQWyZTAhv//6nhAAZwJvYF2PEgP+4Gra153VSfi/OwD+iHJ7OgP1dtSMj59cyksSVK0He38icmiEZVUC1DHq4jzS6TdNvEb8lZxUWUXXtzdLpkjEiTGeugV7yw9uh6vNxKs1oNyb87jkXY/G6sGE9oq40ah57kombdWFi4Lem1CQ87wxZKBY/rhCltiLRXRyEhUZZ6xBrDJdn7DukJjHqxtv+wQEv/mDLoxXVUO/jX+NsClPEc16CIU4XsMzHudosB8K/nniO38RfdHp532qy/HE16m8TKB8Go7+KDnIqQkjrH3BuDho9oWZr1qnA7sXpc8/46zoRnbAxcYLJuRQUUPQx+DwEZhHjLB/sT9Ge2lL8cNQjJ+fAgHGWqOmLiVq/mLbXW3IGfAAAAM1BnwxFFSwr/wGnsOaOcDP0pmuRV1R2lwF9nGHjrz3WDW7FgSZBUDsOLRAkABcdx3ML4QLxwGwvjOVJwe50w7D11wUebQnXzESCcVAjUOxevQSEWf++WomAn8q2iuMdgahThbs0VnpV2VhAyT32YzCkhE2f+8BRfYRRiQTVgG7pug/TSiXh+0HF60hndveefRXyfvDbfFiMUAq+/qjhCZjVQ1h3VX2OjphrCNbZUBR7G+uMUfvvpLuIdduLTISa4O8yg5DXC8ru5nQgACTgAAAA2gGfK3RCfwGj8nzlfNS973MN2bbtDffarnkXf6bKBqV7nnAA/c5qsFLebEvgquLhnIBB6XahpJuZ0QsEiOPntWZxJghjqbz3n9MS2mEKPkFQZa2znN4e3onC1wHAqXNezzrGGiZpFPezFWXVVZx2mFPR2nUuXwFPRuwa9c8pUDGMRF2QuNRCYPEZ49MAxtqbamRFT76viSRCakxs+yTKSGISdiCNQwxT2TE/SGhL+K6QZPuOSAqGrkcpC9A8FeO1wQTE5SHOtJf7aJF8g/N8s5GPAK9S3hiAAFbBAAAA0AGfLWpCfwGkeAplp1k92TvUgektB/a5kCACb2AGLpe1gb/a2wZN5KZ3EvXAY3/UK7S0/SaeGS+OcASFWurPjLUIyqDecroMUuDhcJvkG7GPQL7miRSilkB+/o7TR5mOlZE5AYWzlcoqp3+G8prw0NEKR97KSZ37zPssnvSp9whGlhX8lLp8pxJe2NRm4DRxvXzezjLHQ8WD2PqU/oeYOqaW9FulEH7ShmiWFSVOGVE8gj2FfCIXhrSNDdyG0uwRAnYnj4V7Rr16arZ/uvgAEvEAAAFKQZswSahBbJlMFEw3//6nhAAZ3+j7JUmBvx3FSIxIkMjq9A9we0F8J1y6JMDk+5BBy5u0YXMLfC7DDw9vdOKdu3gBRtNHcjTyy/JTCeGguU7rZxzemvDbrFy00smkQKCa3QAbWiEpx8bXL3fXuD5VLO1Ze+UHZq66NXOihHK7ycGA98Du6o4WdIRbq+un641J3tqyWOCOTngwP3N3pu/9cZjjwpAME7FJJ80NKCs/IgnoxWs8VPZHuptyVwGe5f6HK8HsgSw6oitdkjxshLoa0ER6nni6CFFr67B+nRsAMv6U2ZNsEBRZUd3eXowz9dqxa4jwZhwPQqSw7TBohLsZgz3mtI4o94qm0kmPyIqM6/11Y7pHZpprEo3d2BvEL7Y9kr3brlXAgAmVf+mjklZ0t1nxLG7pdVbFU0opwV0YtAPVZj+vv1vcwAz5AAAAxQGfT2pCfwGavdtE5k3r/bvrQATFlvN2CdgdejWcjf126uFLzv5/1+W+dKVFwuH9/MbIwfXkCtcaAwdzD0ZEEgKLLd3Ta17icBi5QXSKE5w4gZigKnNm+MTGh9C8hBiwi+5di8L2h84AU7vdLdht4BQUOz2Xumv9Urmj2hzfhvLFYmxhYn4Cj9skiCJ3BNW2j6vML2PN0SCXWJP23lXzFwY7By45esZPr7jjG+4LNF7fEvUrpPm7EBBOJEDlq9S2xwOvAAJmAAABlUGbVEnhClJlMCG//qeEAAnsSzrqrRAPVDEnlQgiZ+uingwEK8KpioQMCmsxyzVzt5VrbFov4qLXiDWvgDdZty9aaj1lNJxLC9/S7d72XcnH4nyE1Roi+Dm4KE1ZHIHs7kiGxJGXEnwpdlCsb1JpPcu30J8dMEYlWuA482mX3iYP0Pj65GuAsIg/heXMMBwQT/MwjklTllwMzyJszD1cplPduwiutciumf8usOf+d0mB4bzgrtJ6rPn7JcA+UOkEhCeAQc9dJRPX10gx76JGJWBebtZ0fRasFQhALMjb7Zuc/8f2NFbV+i8CzzpZEH9XU9/JQ25g9QcGM3rKO4BtnX7QFglGnxiLIla1u5gXagaXJJ1Wvo1nTrNRknt/WFOY+zdbCj0dZoJqJ3NWwsuOah762ggmTjiOEZXbIeEl1IIBXNpmEXNSUACohZtpkLC7xagTtyed9aBImaz1SwSwzCsT7Uyngn0x5NJahJzkiY1CcnpSxv2dw8SNkvoUwlMuTPx3NCpN/+xB+bJzC/qPXWRHF7DjgAAAALVBn3JFNEwr/wGnkyaEtH36Uke+oSncrSM5HP/pkALT/u/lL549qz6t9ArpGpuJjHJuFqZxko8u3fsyiOKACTCW/gusrj5z9+f6fTqmZ+GVU5+vELINW2m5Yqu7n4sXM7qMzXGf6uwnB02qGhuaik4IyFrYsc9o/gj//LJEAusn4GU4lg6pBFzJXUgF0vC1BFGjz16z5ksYIqtB5+vDgToQwmEWCl/6WyoAZXa6xtqKwj2SAAXdAAAAmwGfkXRCfwGj8nzlfNQZdTnFy3Q/ELCDjUp2llZb000AHy3g1Q8ZxsBCun00GDEHdJJgzfbVVZMyHDurQBtQWA3QBlNm4lMFJUkE1s1ZF3xc8wRdlBTwhgPzsPAiMjYcmEoHVVPgPdt4mvox/bvCfzO40x48NZAKd+Tw6Favu0E2KcGdG5x37AOLds6gD/GsTEilkX5+CEpLgAFxAAAAqgGfk2pCfwGkeAplp1k9jy/H1UH86D8mJd14D6Cn4NXT3RgBNMXwcHJG1TYXXPkSx56fvSfHIpyeswZckwAgyOU0dt+T7XPfjpzzen+ekJ8LFpkSmGUWD3G7qitrnQWhkyGMsEPXE+sCrPyX+7aDi2z/h1tNsKCIVBqWIpkV3JOWBdUbdMgaqAhKf9+y22JWTLw9sFh4sDHJ7FIK2p7HAw0aoylgxftwACPgAAABRUGbmEmoQWiZTAhv//6nhAAJ7jGZeZAJr7voNegeNoapZbao5NMhFEftD5CAYxDsqlDRQN1FdZwMVrB6EuXUXMdex5XuCjsfp7fHacTcVfxNqOprkkZ6BYhl78v6A38J60vHz7d4YwvMzqOSWkolAQCs7KlTWjJg/A17hzv5nMLyuOJSX78y0Rus1hQ2XpQj4hG2sjYUs0c/0PMXQkcPcGKUK6R0L9t38pgs30RvnwWoxXmZFYss3VxV+W6KaZzdYn3IieShCpdGhhK9FsN3/pODBHcQBO9gTjh886gk2C0vx3KPxIf6HCbMoAwyXmXLeWgdADt1AjDkYTJ9DfZyeN7z/AllclZzYVIRTrY0BIgdNYOTlQcOhMzz+eg6SuaUGvI0qN8NpCOOSAonymgO7L8J550g2FoUefkZMj9EfJDLJcVAEPEAAAC6QZ+2RREsK/8Bp7DmjnAz9KZrjgmzttiXz5gZrX2UJJFI/2W/z5NwkNSq8mrozruTwR2vPWgZ8GB+CSeHjtVu4jCZLk1vU/fD7/cOTbeWyedC4cs7Azvctsn1qvG6+8kXqzrwkqG7M4s3d9GNYkC+EYLrdcN9MTU/4Gsys4Yydbfw9QSgzB7h8ChuwuxMB180xTcokuVHHszRMUSXWme/BQTjtFF7MI/Ic4uxcjKqRDW2rqnkg+0pIATcAAAAkAGf1XRCfwGj8nzlfNS8yxRhnmr9Vc+66amq4M8AE2H1NubaMUVyzqfrPtZkHk8h0yJjWJjm/1T2EhhZXl3VMEgtXA9cjoMfuIbBWyw2RmQh5holFsunBvj9bWCoCeniBF4y2pK7w/E9YpBD0g/OOF5+olMIYWDM8MSCh4HUUnVbAubieJUb1/m/PBBq4AAQcQAAAJsBn9dqQn8BpHgKZadZPY8xGoy9ijgGRLAOIMZABs2HTXd+vOFpFE5LArlD5bME266I3vWuqFwWdLn/XX3m4K77rVpHDDore9wZGZeZDrPkQ4bSMiIL7RvSaW+S7/EacJ1SAxDu9mhxroJ/cBSjzApsyfYmfn7vY1NK2k/jyLu4UB6Vjw4ElDWIez1PsRlzL+Dyo3PvohMewACPgQAAASNBm9xJqEFsmUwIb//+p4QACfrrfph/sigA4npROITX4c6fIBygakZldQEJHSG5JIQ1wxr+JW7PN+KB1WkAuffjUtGs0G1Ot8Mm6q0ukkU1oGkxG3GfeqEgQDPLQj/shBFzscEaHq06tXIaL7zxG8/2J+tpolLqDJ0Q63Q/Wv02t4FbrCMka0g6S7mmzWYJZUunpUdiNVQNjfxyITMcox5xQFV5OL1fqhpTJw6NdzzbTXRvZLizZ5DttyPhv9ErQE+n9PyOy6qwfG2LhWLw70E6Ub/L9+mdnbUwW19SJ29bkrxbd/cCm8uipNdINTSKN8Y6iSyyfLirlhNkNWomNqfQ8GHlgd+gjqsECzvCbqTiIN5oGr43goHx0Gq8crZdAkyADAgAAACxQZ/6RRUsK/8Bp7DmjnAz9KZrr9FdM30XswKEOOdqCjD2nMLA2xcOcsYdHXoyigD/7KCHACVJSeESH3WYAI9p8Gf7NcTCv2/Ze+zwLVO7CRBF7VEVhcqiZEi95z7HvjHvYLfLwFit0/yveFjAw7fS9rDJWXZmyhjNoYTP9wzErL1WCvgSW3WGW9OfAmVpTPz94+8BYhkOFORytfSHetaWrqeHhwva0IJbv5/cZHzWAAu5AAAAzQGeGXRCfwGj8nzlfNS8yxOUjO7iyNVVqMANtHgQkvuOaNz/NnX+B7upOafpBYkNHqaVbctfnVEkt2yjarhlfV8aBRvyuSdHf2Hl8Jd0VhHwggLHx/yUULQ0KGAHu9UxJlfOeaOMjY2iH0sfLA6sULlV/UqUWHjNnWlQ4P/N5Ow7YPMq2PD/ZtzAC640/bwzZklxnI5He1yjKolYNL5UWdXmMz5vosn+yFbGc1KDJQQQ5uXlKKIX6QnO7/ZqBrDcEVU4B/OymPDiLIAAsoAAAACxAZ4bakJ/AaR4CmWnWUWKfSeoPqNrEf/atgAZ7D0PjiAuKTWNrY5jtD4TntABWzdN9yQQ2DkbUXXR2dcfvv43LwPLZ/BYlbIrM+DAN/jWkoR2D/Lr2LPNHBH4NFFf0eaWLw8tqdSdS52X0n0qap6KSWpJvN7+/VOwFscZRgHXsIo3aHgqggsOScq45bFnxq1P1a+OM6gWXxBBPIINVyeKcAsgeSZI/5GuZiSNLrRAAB3RAAABL0GaAEmoQWyZTAhv//6nhAAZ32VE8PWns+gA5l9cFrZsWJsITHyf6dmHhaGlf6cEt+DiBkU6RIKWIooIxFzHjqRA19NchbvyyB068Ak9c54lpsbOvCdWMQqLvzaU74i8XVNTWuZ5j/LsYqjnZx1ExitkZ0j2zYZpGSA2KpTymHemY3zqe2hRYUBToRMOpX4AihT4f5ZFpIWnAU9bPhZbmiCHcfl0k68mCQcmeiKn+0433+nvb2XmPO9EKvvG7+IupqLIBoVzRiR2gYP/qN7cz03+F7yXJFx4KS7KMgDlj1MOu6IwUDxsQnGxR/bqDzQiaUOFiM5VCIX8VhQKZ1bds7ZX0AnWeq739kWCBh6veueDaktunppSAjDO8U9IceRKnCn0o1czBL0BZ9+qBRwN6QAAAKtBnj5FFSwr/wGnsOaOcDP0pmut/Q/PzW8K1V5TkY4utHSpkJfGqujoUlwEAJY/lisAhvzk/WAZU9HIocMQLPYE3+SxT4xqte8vS5LnDp395fQFqlxDdV4FRB4AG30GQJ6miiDdB0jucnK6fjQqCneGddXt1ZnhOoxkm0R/cQqDnFQ0Qiwp6sF+lT1Hs0OcBbeWHJHQlwW2qNcqWwCtwdQpLbaq6FIOEIoAAWUAAAC5AZ5ddEJ/AaPyfOV81MTEUu7L3VIAN1xEP14fvedWFuFIJ41kOOxLxxdyLX3gmLBeMWjyvtToiRHzbVe9MndFGJvzR4pIg7AcvmvZmB/VEDCYcIV9pPCpmUw8xjgslnuxyqtYitI4zd5Vmga2VLlnCRKyscILVlg+FGtSUM7vhuhW3ePBw4JZZ3YcQ+SZx8XIw4ujI6+kGNRXkA77FbSjlFqrRu03M3Ofui+hs98Cy110i02hxJgAFlAAAADOAZ5fakJ/AaR4CmWnWUWKfU+FBBgizPPmgwp//nIAQArWHxxAXFJrG1scx2h8Jz2f+5fvN9ybDjGiob3lv1iYZuzc0ZlwTrNJdebECklvfxOxH5hHsLU4FXlEbbCJzOx8A0/tXS3yVI2vMu67pLjmUFmn1FsL9Sz+GjGgBufphflCpLr8d/DRLsjV9+GF2m27supK/9QZkOgpSZOPuxmJTgxhCQV5IS/v5kGcCBSokiPhkknD3HNMxAeeJcG50grau3yOiiLBiRjGbCAAD/EAAAFFQZpESahBbJlMCG///qeEAAnzPFZwBPmEDIdWpCgE/J4Gfst07r30syiOLFaiAOrfBv6pUZLNKmYchyknWnoo/TXqImtQ7+IeQmUIpQao1MaQSoR/OTmmLmmDOD89D2sqy7XLLwmH4kDFB3zcQkio9brYC7ilTyb/RkXzcJ8x/H4pOq5sTvyVgF0f2eGfs1enjQqZ0LKMitn/WYjLzCOFAdvLOfiJLcuo+JkjGMk6k4nPy8U5O2/IwypNlZiKE0X+c2F3tSsxUZCiWmKAb18DrXKpl4EUQDLxaxMe6e7XcScPq/KerblDhWzinInfs/aHjqXhkWwLIJAxfHZDgbhOY7bqTvsm0ox/8ZIEON2sa+fDyZNi+O6r8+Np4b5x54s5YytMajP44kTQOFtqpnloQMBT68eakHUTZGVERubYcAA+CyNUWAAAAONBnmJFFSwr/wGnsOaOcDP0pmut/Q7WeXAu6e/PQArWqyFEtNcn5r1fFa884a/kt2MAANkWXGxYD/TBRDWbSGfYEk7k6KONMKGBbRwAFzVtNoWTMLlEl77wIlreYSmqbBEqXxBAZ/M2lhrIX2F0PBGv4slTPgWV5xTM46IJOkHZ3IleeVnS/KbPSS3XsFaV334majbia+eE6ZFIMzXNr1jIvlQtF7pciOZld6JRgaq+eaSQa1XCZGspQ2rSnB9wZHfLD3r4085IXR5v1Ic9oNQZsXXAHZ9o+HqJjUOICxWNywACRwAAALEBnoF0Qn8Bo/J85XzUxMRTvxqfhzsBohRRtcAVqQUi+pthgCeI4q32ZOBjff+igwGsy20Nwpnu/67DhX1KLaY3oTwYxSodIhficRvxJoTY/4cLtiYBha30geuJv9pICbcuDBiaBifpMZE6aACgpX3W+P9buyrkjPZP8UxZBWFQ+9oc8ulnaGOczSW8qz9a6gMd05phZCMfNPVMlPaarxmc9QFax5EaGKBcCdUnmAzwRcAAAADJAZ6DakJ/AaR4CmWnWUWKfPmIbOuTAA4rXzZQ/LE92leEw2awVujdE6DDZpafrMsUGNuJW4nan9vpYauQEwO0lfPdvyXIAwIUX0PloNCA/cbuOQyzvvxpcZfI1dzso8JazQ8orFrgDkNVj0QJiiWhMPvWo3SZOa5HTMbUfqCxBNodhtkaW46A1c8IgNlW8d5kTU8bWZPncdVKVYQZKGxZvOSxMHa6MyQ08Ppn2O3CDKs4O5TO7UEZxFtooyfweJVdUtXjokgoAFbBAAABW0GaiEmoQWyZTAhv//6nhAALHzL/yAACQpTlxAt80lB/+Pf9uCaV9fZ1ETPInvUCVPNad1o40Do51+xQxcAPLONqfzXKN2VIMi8iHeD6dSYhgnL95OC5FmDQDhkTgqlefVjKOFHDEQr43Z50Dfz0anrWUURIFcS5X2Cpi4DDRbeDWqHtU8FEQwffwxyDHNs8WWFNBbmMqIYWGKAAC3CkFFVFuGxgnkN4iFVrDx7j86ILMXBIV08L1kEHOIfEQ3IqHNj2l0GsNis+eARmhxdysy+dRE6Nv2F2HpWHu2IhtJY4gynDViPV20VeShHDPgODGlH9t4r7G9iz1LW7MbR6AtPvl7j7mzS0C+oMLfFkel9kXHuKhPkAvIz2camHA6DfLhaTMzCImexGJq5rigvakcY6QBMTjlee4NTChGkRc0wBeQwVGJqif1vJLruc58+Huc9jp7KEBwR6/Y+BAAAAzkGepkUVLCv/Aaew5o5wM/Sma639FH7EpfTkG6jfACWq9Ghxo0ITczOsMKUQ5UmZ/qIX1ysSGb5BP44y6Zsci3htx4Z+3iIyLe1KItdT62EMMy/BI5KnSFr2K3fVMQbb4kWHZwLk5HjPCWah8QrWAwQgXl+84xM2JbVy6bPnqnP+kMctvUJWWESYCdO2+tyhbzepw1pUI1s24cB4KMymxrXOX9BN/oi+5TGy4uxtHNrC+yWMXYohacadAACoMcTTFY9tmsrSqJOEFe0jAAHHAAAArgGexXRCfwGj8nzlfNS6dGuVyGTxADitUD+2zRC52I1RFvTHC7q4ay5vj+g74u1p3lRPdlfTwd+fXzTuthIvTwPlI2Mp5XP+cKMHZqQdL6E8WHY+lbfJhUdkaafvS+eR/A5OrIhrruWQkBohv64NLPIeNzMQ6n4nucIbdjYfMCLN37brX5g0lJm7w/8PyeSuuTHJ//JQQ0RZbRVUDTishXHn83Fi2/rPD03qz0ACywAAAM0BnsdqQn8BpHgKZadZOd56ppCQSrOFHDoAir3KQtQ91l8Fnt4v8vNaoPbcasuRYrI/9OVsgXkGtFc56h2mR/9QNrRdAPzEBNibTblne86ygWV1w3mhMc6WwSz8y+Y/k0zvP25E2BOe7qwG/uAfecR/L46E7ZdffQGuVA7NMeQQzAL9UStXClp1OXDnsYct4Oo/pbPPl0QnpIPkAeGtmN4RLmJHcg4UuPVCjZsNds87V31fGMVZn5a5WlmKiisuTRPWxNutDIk6f5UagAO6AAABFEGazEmoQWyZTAhv//6nhAALECiGW/MIAIbzvXRAk0efZ4NN0dAVf3s+SabR3/lRikuOZaHd6FQeKJr/6QlphL/VmcROpbNjbSb0Ib7/JkmDxSLjKG9WOKjgPhBm/54yo35IVJVa5XvQpndv88ZdVF8rNqApBTgpYJocbdWn/pJPeF+9rzs5qYjbvCoiKq2vTljCFc1HTkHYIgc+/DhpI2hnnBGnddbSTwUbpqQubS1Ju8awo/Hp/dLteltQT4YxLIfuSHLHiAxAb5nNoZIGxw9LgpnkJZRpgq8XLVpUPZCsy+NkB3hZsa0WO5XI5KNUxY7btlnXJZ6ENRx2JEuWYFgaHUgEjHpgn01UsjcWYVQyc0BQQAAAAOdBnupFFSwr/wGnsOaOcDP0pmx7SigCgE0+VxoMBYn+6B2ArZstyrpVsvKYceKS5RXjyLK8KVTlKqXOIHeovsjdf3hpffptI0n9bs6pGtM4k/CLNC+xDi+PBSLuOrQxQUF6AaqJFcWVRlyHpsrllgBW90Ea18R31a9+HH13XgoCuo6Q1+X3ouZfEnBfyWffzdiXpEZleSAJTinUbnekKjx2veJ6OKT8COKgkVEQNrzwWBIUfK4UuRgWrbM37dmThJEaMknGoh1/ssCCbmOsPYP7ughPtmJG8V2URIVOY0Nv1HUIaLqABZUAAACjAZ8JdEJ/AaPyfOV81P+J9einvEL9XVR+AKWDlemzNYc2XOQqsjTtV3rIOXeOV42Z+uvvj1vbMSF9SsbeiSmT95wjA3rOaOuc+xqmOZDJgm1MY8nQ3ACaePsk2QLXOcvc8W4cIleQj3x2A6cCda2OUUDCk9Dic6nBAiOzFYSenZiZN2MKvArJ6f+KMqtUT0yQTo5WW4hhYynPVTC+pqSlGAANSAAAAL8BnwtqQn8BpHgKZadZfmToUU94hEB/9MDv/ocAKtGcRC12MDtwNQzpgsPyOlxFYScjvshJRQl1twlFs0VTuXeoNGr5xG4BnjNxRUygJM+zj2yAN3wH+lqZL0RMgVsXAOAuqjgLi0wLxTcU4WH8YK5mUnqBP+k+Yj9G328QhvdOvLs6HmOV7btpJnrHVnj2DTuPe7zD+NmWn8XK3dV/WcQJpS8hUPiMp9460CQSb8gdZQRoDLyksk5tEn2+7QAHpAAAAQpBmxBJqEFsmUwIb//+p4QACo+8K2ajfutKt0AFQE6M41HtI4LwaG9fMOaxb6MCnL0qQ53mnS3zbfBavdRfRFrQg98ksOby07zAeFgAHEo8WYFbePXjwyZzKDUBcL27Q53RYB6WaKoim0aIaVM3umAfeCsdRuBR2yrDQbNdXC6oNHETFTXqm6kOrbxRNvJSxuhH/QyGkHwdCXLYPtnqMSMDFGrJU0mjRARFVdUuiCLs6Y8PBrJmwV8UP55XJMKJJXC7j+kpgtsxVDPGDB02wdGxX8LU1FmdQXxRJnuwYC9txNdPnJd3HVf2J5COJAxWKGfvU2KHDYU0RZBTFAZuMKHhIwhjpgktqdaMJQAAAKRBny5FFSwr/wGnsOaOcDP0pmw3FLAFannp/F7lVG7ZcftiymVV0IJv/vL/QKqea5ixJ70A+8C6Fa66vRxzEhmX0TBuUZN4//lj1ZKmLB3SIpXvU9UHKFpWeOvq6QPadaEQMukQX/aLS5TPz0S/ddXWeeJOunTqBfWrgEEY6cCQroaJWyopnRXtzIpVoVKlk12Tenw8RzQoLF77FCf4j475cDIWkQAAAHkBn010Qn8Bo/J85XzU4nRksmAKASVGt4vBKHpF67mZ9VxCVuzZflGncXfzZNkkU4JRfrfZ7RG7PUq+bplt9tO6GzriQ2v5mglQ2TTN69J0TLhwUzQpMdumePNWnM62tBvCJMbvpoEfnPq+zPq4lI2+buO3GtIIPYMfAAAAdgGfT2pCfwGkeAplp1luvmgBz+xFDXSOe9Z57XcNyvTICWA5jsepYS2W/VZFUlSadl96PELE7iE0Bv6KaC6wEAWnAjecAGrWcsFc1f+qu+kJ/+Oyy29YIFQopTLKWz052DptDPsL1wZ4SgbXIuTrBRp8zbj3URsAAAEBQZtUSahBbJlMCG///qeEABp+E8zWCaTbwrJl6cM85aGtTjm3VAzwBWhDySsIEcqpBbgRoV5hfRcBCI1fERTkq6yWuajT8aCN1s+5kNIzSqQglmtJVQzYht9IJwkeXs98HOHFe7QtaghNnsGnJmtjcbyGvz91UX5q5jpWIH6dQ9doiZB4hXk5IDfTQU+jZ+LMXrGbm3NucH7AX5blqhKxoxJSBd4l0Qkw/vYkbUzxVS5b/tLpJMuOVninnz3AXoslYL0SsN2TnrOUoqVh8U/nBBFD5CkwnDGayOV/UDxWL18XbfDlGCpAi2dz5baxxPNj561Kmo6YiRQmUgMUK2mPsScAAACZQZ9yRRUsK/8Bp7DmjnAz9KZrscAfpneaTOGKmRvW6HIsAI0BiF5vnHjKN0x6cttAEoocKONk5G+StxBmOA4oaLWwQiIIuU+jwkFECjfR5aOXdYDzIb2rwUrJ6Ji0ggRB+aImI27c6zY5dHRG7aZo/6eNyzO9k0XNTOjPFhRZ/rhB2voJbjzXnL9wLShY+PZL6Otw4TKeACbhAAAAeAGfkXRCfwGj8nzlfNTExFDqYGLlnmJIigATqbHBnNsAoV5JaFNpJvp5ZXQT1VaoK7pR/5h8HHpLvCSgS166aw2Ym+WZ0qXnhnSTPQSiFDo5olaBWpoe6ah/KNowtDDNdziaGV/BqOjv3tFwqUyZTndvF/ZU/AAoYAAAAJoBn5NqQn8BpHgKZadYmYq/Q5NGXco1ijdx4oABYJ7Z52r5N9sWRAnPhcE5lArcSfrgIBYbujTneNehhRcr+ahqSetrtBsXFgm9L/6IlQZ30v0pFDYtnLtqsiafVTwgHibxWc6rJxOxKspSHtXjkAgyiuhu+M+2iMEACHQtHWFG84bwHzB7lRgGyeWcZv2wtig04Iz3HHK4ADUgAAAA/kGbmEmoQWyZTAhv//6nhAAJ7HjpmRd+JFakAOGVZiQ0QPVF96HFaUzq7L0FrjfYOEl90Nev/PZpPUeaGg20mY9h7PdhesvzHUqSGBONEhX+lHqUkWtKmp7ANANtw8AIbeg6ZxC5zoMIyh26CHDdvEjQHx2X0o9CLvNrC0vvyUO/IB7lGLp/fj3ejWLtMybaVQ39Gj5k3MhLAmeGlnAAtMrqNPBtk4l7jVfls3AVzKP+CgHP2P5z5cwmZA2gX6FR3DwSfWKCsMQvcZhxpeZpWY6zG5O9tGAEdKpwtZ0Z6p066CX7zMbKosxknyhDtL3252O2Rn2gvje+byTA41FbAAAAg0GftkUVLCv/Aaew5o5wM/SmaQ1XbqZJ8OjzjaYIAFd+0C7iDrVi1Pvd7YnFnOG1mSKUnImpyp4QPEeRGDCYhf9mrJTlce48d2oLIF0iIYxwWA284FbcDqEqi7oBCBIWmomzR+9yNFY6wQ04V0mbFXTjeNHHo65vIJoK83j7oGILDhzQAAAAnAGf1XRCfwGj8nzlfNQZmdoXasypQAt2xW1uJw46boDZrOhJrZ5Kf+hByXDkQfgRkNz5kXC+xHdtyVFWOxqMnDhM5BgzR5IZqRlu0raCMhFu8b28Irgf20yX6hCOSB3nKN9Xw3X3xQudyIsu+LNjgrT+JiyzfTKVsZFohwzPZGZ/UNOPE4aFBM0TGYX5MAbAhxbTOtzpldgNRbANmQAAAGUBn9dqQn8BpHgKZadYmYoiTlNlv6ZN8u8wB/+FAANFGFlAIVmgxE/1yviLWGwi1/KbhbzP3MsqgRJoGIBINsIatWzrOMk54moJluiTGw4unM9/NzLL79LRG9gr9ZQC4/H31oAFTQAAANlBm9xJqEFsmUwIb//+p4QACfbyOjdgGUQ++q9t6pQHACMNje/4X5MuEKRSf0QCPpc6Q6GsUohla7rcC4rv7o1/ADNTdzJGnrPacnS71+EOo+iRxGo56d86sfj+g4leEwSGdntR34pfnU/b8zyvOaFyAY2DWEMGE8IoTMp8oZPZNFLTD8BzBKpsuO3I5CkdMnMh5iMNbE0CS8J5tvfojD4FpzrAYA0lvy+y23ZukdsX7WyQ0VyjdeFDO9OA3valoN/rPcG0iwQ07bch2n/N/1TZ9S6zK84oQBUwAAAAgUGf+kUVLCv/Aaew5o5wM/SmaQwvUwQCsDPbYW+hACPB8idwvpNPMCoLo6Fws5pDxdkOylwsPlbB/ZaQgvOqFEj1/L453zAsWA1JaCI8ESogsOQxg1R0m7YHoTzSPzK+OY3kq+aeDUvn9bNU0D0OYx3lGYpM0L8jexIdJBEgCGgCTwAAAIYBnhl0Qn8Bo/J85XzUGU3LxupsN1sgAEtNu/V0exPZHGgE3Ym25QcFIEyMvuHsVj9zBlC8Ra/CJ9amg61T3Gem5h0wwnEVn0FsZB0uoyr4cYgh05CB9tnwPSEMNsbgAbByWacoyEncm9dQj62S/i+R3w2AKMGJ3yJ18Y92WpKwjuMFmbABWwAAAHkBnhtqQn8BpHgKZadYhlR/QNeKMUxaAB+2EXRQGYD0L9SJBxboSNC5hWXjk0qbFgUVXucuRvSzJ6CrnJEOXx1cV4dB/S1X6ZiaOOGKXQZrgwUzZgyXVRB8jHz6g5IDqEyA5As72NG7MUgtcutnZVMBrWCfHdKiABlRAAAA90GaAEmoQWyZTAhv//6nhAAJ7ErOZaxTK88AOB0O3o/DVBf94vzgWWWqngF0vxwFbdArzjRnmEhGKU3zUPhADdYwXGNZqgHjQUT8cvHUULDQGVr8Zfz0yPF0s/HUKqRWQ1AOAz2VpoHv7BC0pmsKU5zpeaAeqVF8omkA4wa5kbI6FstOfmSs+V0KvACEkk30PdP4JNI2halWRfm0XJ28Rn8yHMS+qCvric3b/okH2Qcg/b7Y/lP+QE2+zj2rzhNjhD45aH+BDzsQGkcA6yD+XxABjbRxE30PEmZYn+mUdqtEbF+sBHy107QV3Vg22OotJG0IMqi1BSUAAACCQZ4+RRUsK/8Bp7DmjnAz9KZpDCcHIV4MBN8RELOEUG5aYAAFs8DCEXcSqod3hNrTvO8LIaXMCA3iwVHURrAFaQ3YHLi8mNkVnvlCRlo54Ir4IzEVRAk2uaPmC8+m7v+3ICkx+sVA/4AGdqxch9G8D856pOEJuGlo/AbASoC3hzABywAAAHoBnl10Qn8Bo/J85XzUGOjVLGZ6/BgNdx0PMvABdRWlak0vTNOPv8UcvZ52r5f0VAZfccuwDKLOXiKlaYsaUosNiGTUVKo9q3UekMHz8UpHH+uVKdJl5DfsRA5QgExy2kl68TF4llYW7icJArefpDele2X+cCZQQADrgAAAAIgBnl9qQn8BpHgKZadYhlRzrv+onK86rR7LBdnggBaKm0S/mqkfpwI7qr2iquMay1HJx14ga4oAZqy6uQclhHn+ZjsQZT5fdqHSjecDGp8as0xF5ndzKw2FNE8Xs9o0MTZK2+JgNKrqxyIku/PAasPH0hTdRZU+w8XKfHkQXLT0+fiWGmgHAAg5AAAAqUGaREmoQWyZTAhv//6nhAAJ76ySXqwuAAQ2CpSLK/gzlAE4crtoAq3N9O72vqo48JdpOWfV87wUuKRdO/4EMx2e9cstO4GU1by3Z7GnCobL/7c/BZ8NMZCj6LmBQ7oUfYG2B6W2k5nT+4GPhZyatj2RhGQ7mZ8ZjTu9GmTXP274xG1T17AnRIl00DffVrfIVOUyuDa1MXJo2+mOnreR+NiO98Ks5yq0xUwAAACIQZ5iRRUsK/8Bp7DmjnAz9KZpDgVRlTihE45hN6C13NjOhWGneGdbOoAxR2ltYyO/rDTiBe0qbv0ehAr3O8wqWNOxjhYI468FZBlgEy/8XEjJuPJS84i8nYJUoxUzQ8bI69ATMLhO5qoE7ileWKw6AhjMLlA+eLmprWbYN7HSycdFY8lYiIBNwQAAAIUBnoF0Qn8Bo/J85XzUGEmnVyirNL+MHpLgSDGps70OWAAt6YUv/i7rTkXdcCKLUBtbtarYXmIlrm25cvqOdkgKly4wSJwkE+q7YS3rFX8Xm99RnKu7GXaJUJsY9zZBFhzuUgvcsStu+2oTzNeWJbbwi1WlEZn8r/mKcBziHSjUGFCNAAUMAAAAcgGeg2pCfwGkeAplp1iGVHbRwBuRmDdDn3Sh/5GwAKtGjcuDOyPWDRWKLWgYuJarmXqltAhUs3240cHVnpCk0l6ulSgQZ7sUWdlDmmT5qacrma/S6dkXDuRRL92za21XtuZSZ6biCdQTQWyj01DlIAA6YQAAAMRBmohJqEFsmUwIb//+p4QACfOav13ohACMrO6/QXgdDbYTHR7fNFRjd+KwkgkMljUyxZj8V269RYPLlC8NgaakdC1M0f8JPlLx8aE7KolMAeWL3t47eUMhusMAiLX6PRbbQ4JuV7dbZaW+sZi+WqIVZ1lf/aBDxr2LXaBjYJ1crM8mTA6XmZKD5hECxZDK3lhQXE1YryVHZX9rZ4H8z2yW9M5BMUkJE2NQDErRhLGzLXILuhyhv0NBfL8c8VNgq8Yrdfb1AAAAnkGepkUVLCv/Aaew5o5wM/SmaQwood5wNCkyzya9qMxjxhmp65rOPbougAP55sXiyCoWt9VR8W8T771RoYKqS/cG9R4sKj0R4TgsXLQn5F6X0RqbRu4mzD/3hqA8T+nZ3PqkwPJ/z41D1wMIkprHYMjJKq8wB/I09GiMntdSOLfSoAbYr+oiviz3oPqFEZ5rZWnAxdWKbzFkhEQfACBhAAAAZgGexXRCfwGj8nzlfNQZjR0tBqwbvjsKNKgBjZdL4Rff4+MpLl644gARgVfX0Fcy5bXrZwqPX3ZtqpyhGgrxHtkeSrRNI1PivE5J77IJ39Asj+9Pib7RiTnFanR2z8dIKkC7QAA4IQAAAHoBnsdqQn8BpHgKZadYmTYF/y3ahDRcRlruSYcX0S0voVZ8AFoR8skYDHmcfwA/l6f8i638dBuj7NEyaVoiQUQyDU4Swu7TnvI+5KUWqpsuiDOopDdQ0dk4kLEkgFOVggTWqeX4UVxt8kqOkz2h5vEHq7uoIGc3h4AIuAAAAOZBmsxJqEFsmUwIb//+p4QACfa93Y5hQauAIcQzX6G/nR067LDqkj6DVSCR1+YjzXIv4LGraG9m/Vr79an/M892Xx3I8AjpkcXHANa2f+/heXCZzvpSosL3RfzYIah7tLa9RcS5XSor6pdpCxYiPJYcVMxYEiTvUzrd54fsQnZKy6yNUNui57XoHJSH9rW06eU6OuO6xJYWC7lpjZf6axQxn9BVKf/4NdS9cV0R0QKuGbZNjEwg5c9JozMZEiiHw8SO58aG1YHctzJEFsGjIUUfcvV0DiBQS3fxDWGURVOHqSy1fMDegAAAAIZBnupFFSwr/wGnsOaOcDP0pmkOOmL5G7/CAMUnuTHNIo0qzY9JpQwNmRZZetmhSFQM9ct/8P4AFwj1rVxPC3pI9RsjQb/fIg8IwN0VCOUTKri32PfqQOoAnVYYwmJV+VI6b1gVp9Lmg1LYFBSWTXkshOUfwp7vMCMkkVSZEA/FGPBkVfAB3QAAAH8Bnwl0Qn8Bo/J85XzUGElxdx+hImjBegqMLkm0bWvGGIVIc4oABsPj4G4X00/3dfTOZLcaRMDs3/mxRChpouAmMeZ/LbtvTRAKCPYJbQwQfl0gZ/7DprgeAX/E5VwY0a7f++Urb2akJpUYXnvEapif8kfOAXs5HS2ELdOFmgEHAAAAkAGfC2pCfwGkeAplp1iZZnVaKTy5Wu+UBNKDk+vxwDSWJNBoBhTagAf8UAtVr+3ev7nLBBmuKkPC5DkqBKpTjydMPJHe7ZBkWO01SWNzdvcT2o6p9ZRKQjYYBLrozuo+4Yq3a9jY5cEwWmaCud7I3gpzyj8eKpat+2q12bfcx3FLvHNkkvIsxhVfni7BTXAZcAAAARNBmxBJqEFsmUwIb//+p4QACo8y83PAA/vHANUj8SS6+oMfgKANKUUzHiCDEaxLb3j1YSTuEoh6HULrZo3nw8m8dYO9PjcRIMmGrFTZMZPQC3Q/XVWRWIAHgWr8J+Uprn7iKSb038gvu6jZ6Mu6RPmQIPpbLPFryb8WZU08lLoK7zKPS9SVnPThQOCo+nn5gdt1CXSw+TKR2IgH44o9a+07jc6B7tf40nrVvFPXPP8GC3vJiZ+7lmM7OyDAAXVQgzo8OzqasivwQu91Q2XNuMmVAC0YttxTadipoaXRs+KoKnRwfIfPK7Bf8eNNfSc520/XpiyeoTApv4pwrNeuRLaKNKgdmHFfvhqD2QVTT73V9AAxYQAAANNBny5FFSwr/wGnsOaOcDP0pmkicUviAC4R/ZBRuToSJgpH6K4gja2K4GZ3ai86+M1si6WA0mZJ6pFe4gfm/M+y6+3qT4ZENCX8g8WbSTR0BMOWb2wz6h6HRn4UZJ0cBgPsGGS76kHaNCvA9kmYOPUOvXU4FwvFkP0DmzW/xarwImsxYtNVfgF3dYbMmzLKTpsj7pgqhfRNT/xz9L7h8eIFA4wg4g5/gA3uCnMHegItvE2ijT35Sbc/l9HjFdDZh0qx5Mz4tcDxHInwTZcOoKp2IAlZAAAAfAGfTXRCfwGj8nzlfNQcFNK3AkfBU7C+RDJKm7fre/QEZzks5q4fGpaDgA/iN1R6DBhATu9KgWqjJHMuE10pKYYTmoKlGN1EHmzTisDAwe5bllGfHAGp2Ur7pKzirS6ibHnCCJDeAcyFtq4/JZdI8k0Sg0SbUmqeV8AAb0EAAACNAZ9PakJ/AaR4CmWnWJ6NvaAK79M2hX9f6vG1Wyb5JT2FQn2BngCTU5399/rgQZ1ikbq7UAXGD9lZYM8l2zm4TrzuMbcFsl/X1bNL/EfVqrk9chYiDEHEueqP4lJwYFdYUJlwVPDfngpSaba+QVb3cvqLm9qBObFn9uYtsO7VTkZ96ZOgm4dKuhXfgAK+AAABGUGbVEmoQWyZTAhv//6nhAAKj7wrY78aOXn2QDFOwPK0s6Lby1rcn7QIW6etnrQqNtrvfz51HHD/V7AoiNkh/zTWkCEZ2E2csmX+W0DjwB+M4a1Q4jTAl/bP4NVeT4XFo2cnSd4nX16W7qpZoRU3bhhL0u5oqrFYsRV9qSYh2jzKoVy2d96hlDdLjytx+kv3C4vE7fgSaDDBiksaCfUMmTxNDCvIY20sKYt8GmkVNnYYBE92keZimFfIZI7DGdccc0OSoPYi9fMaIed5/aDGYq1h23WyurwOw9JSxqFRfFKGHzCDYRPf51brB9//ie3vy6QwrlO+WS++o6XpZPAO7ah9cUxzkmh9M2jfnc93F5MTkx9lunot0IHLAAAAyUGfckUVLCv/Aaew5o5wM/SmaTmuEAGy8nR2+oneMTvb4YM0/GnCmd1cmx9PmRxeKamAQDiPXGa1MU50UfCtnJ8BEYwadeyyLEy31cX5w444c60jD1HLxegccql6gjk30bflDFeL3LYy0433mZ6pqBONswR0rgMeEtaPrK/AyIsve12CZPFZHmz6gE3I7S3lDF/xdhjBiq0b/qhMnVHu3KhndPAA5fz5/H71l/rcIE4cpP7CrLn2x1ecPowx3cVkjdn+IkD9cUArYQAAAK0Bn5F0Qn8Bo/J85XzUJAaz3FB9sAMAVbI/staq5bZCZNmSmUlEgnxKwWAQctF9I8wFupd20+RFXoENik5HIkIjJ1T+wLGIFX6LROdbqY4vWVfEwzDcXcQXIq2hR33bdmnKW1gIIotIGy+E8pNExllCVeoWTnV2nM6xl2fdmyIbtaV0kWEZK9B4cQKFwle0jKh08fBcq5yu+0qeM0QFNaYy4aC5V4Qm3Xv6e4AG3AAAAHMBn5NqQn8BpHgKZadYpypIAOIXA1MIZIid7+zSWZIsfTylATIDozh7BIMRbIoJr1c3yyb4BPFM1zDDMMhXdxU0Tkqzrli9HJl/fpRd6QEhsty/CQpQBzbC0QZWB50JhHNxnDoXMF7Fok8O4HaZx0k8YD0gAAABNEGbmEmoQWyZTAhv//6nhAAJ/zLtHLh+DTOoUYwJjIACECh8Q5lp/ZKLTkDfTV+MQzZ8DO33o14LIywgE9wxQ2bSkHmBzsPLQiF+n3SWtg/LDFTuj++IHb/2/zWLcsX0nL5eCV51fwWyJRR5oZ0/AfJrlSrHjmARR9FWlJCq5LfJgb9/E0cT65BI7J+BLrFAlzWAEZmIxJiMzqrpOswiaxIQt5G2ox7Vps5s79XrmHRu3gtShoEOBHjqjXLboHZzvnZU04WGjIAZ2E9HLkTwJ/D+ANW9X2DXvBqmJStIjlCl6BvVaBEk7Xm6OwO7AncdudXn/zQhYockmWczP0lFU/DF8y+zrgRLHt9Ck6mpjCsOdnomLs6gbbvHUx+FqMknPrewStzkf9nbtmvvULB2f9gNUAqZAAAA2kGftkUVLCv/Aaew5o5wM/SmaQ71vt6b9QBVrguuIAEarkrR5jg7yXYo9RgEyyidhQ4kEOHXj5jetITtXob07ZMybm0cjJWFdcy5l54zgmRAk3uFJ/sySHct5Nh96F7beGVXnAj5gl0V1LNu66ngEOI0Fuk71HYWI5qDLruQ5cDigxm2kw3PXxMBFcklIuEec5oTK4BoX3zePsSA0hy01DKcg5jem3/hrhmW8oaIlNatShnc0r1ZITk5hiRdzfH1bJd8lqWVsMg0megmRz/fSw9seaFmCiTDgEHAAAAAhwGf1XRCfwGj8nzlfNQZiHRTEz9J+9YcozaTolWcKI9cALRU2einpomjSNklyLO4GyqEaQ4elJiseWOsJembHAWsVY6H7YmQMDanXxTdWngm7dSNOYUZ1Sz4Bwv1mD+EDcR0lsWcU9hIM6b5elkBob4MRgo3omOno5opxLCyG4Kj3dJY9gAW0QAAAMEBn9dqQn8BpHgKZadYmVLRZ4DNgacGAAaKMBXVG7M4J6O+26a7l9SztHq0r0aCxKqNZyVNvchsu0g+OdMOwkf2Mb4CVsXDkW92bj29T5Kue6+u+7zsp8Is5FRXHyu71LjyDXhwtNGA9uz5bOiCgZN6NyFG3sasEvRpy8uepAZXFVbNaX86AWg5r2LbKFc0VlwgfbHVpNa3WIy4D4FbeeX4hNX0+WgOBa0kGl3huz5PX47puwspK6qFLARAgeq6YAEfAAAA+EGb3EmoQWyZTAhv//6nhAAD+6969OH6aYAJ1rNRVWStrHHRo1J/3ks9rOYXOhWDYsGLxXn4iUX5mdjtIr7ywY/wHDteO8/mTBmVGfmj4eEQBtvUmqybnTd6ELlW/AU/SDhccahUNQva4AFlvsDeeMW7ZB8bTDCUoyGUd8l7iq3+zwWecskuRjH6AfL0nP/Rp6ft2bfBPUmywyV+PwuUL6DNR0WrOHiOdEEnm0vScD4gfOGMfDio9L1KYptPcI17qY1hktFOcwXF7BFdnFljgjCfplK/BJ/xrsnXDbCFaaslVJqlRw1lWMXX3VW4SwnEuZW11wthAO6AAAAAx0Gf+kUVLCv/Aaew5o5wM/SmaSHpkJafTBAKCjgbdkPIcUkG2QW42kGlyJkhh5gx+mc8mf9+NK6rGHe9oHAcDSnnLLMaqJPc7XVdKUQmM794mZH1QHTv/A5+rwFKgEv2QG/JTjIoc7EF4xfdUI/n0VyjQEIdDh+4lM0lF08+akZP7DUm2k2bqXuTw/5qxYP4XyqqXAYL9GSJZvnLeZk61oaXZXNPN8wnlk9CqC86utCat+b1pRoLc/7aF+RIMsplXVxKD69MA4MAAADZAZ4ZdEJ/AaPyfOV81AYbDR81BEAK4i7vvweR1h+6QP5A6TrhCaW0JuC6IgGXxFioRZP5JttgzE0TJ+aETA5XtNVyCFPyLO5hc4RWWScWlNBxEBSHnPrKBFfAW41cafXT4fa2F+bMXEVyVUi3iso9ifkhHm0vzsuIrEbmB9RuzlEoRC+PE2nfQ8pUKPGjxttNa9i+A8+QdKf1EE3Mx464oS1VSR4eAgj8rtnF4CcP1jo4ddhfD9Z7sc4GtvGd1zYIlIRam6hGfKNAiioM3b/Ls+6SpR7sswAE3AAAAJQBnhtqQn8BpHgKZadYhlSL/5tAHELZ65ztyIt1HH1FEAgicTj8evEXSUIR3BpkJiASodUZhFUYdqxu84xKXL0huzLDk3Awu4KUANAG1h+0xY22oOSfyZFHiF1puXMl+CeIHz3/rS3xLzWpHUK6rMEpBoTEuaeS2TuEbFFWEP3DOynYQvzPp5fH+yuKWaTkrAEjUAEbAAABE0GaAEmoQWyZTAhv//6nhAAD++ypnEnwjnbAFgJfX4dRzD7SWmVOMRh/GM+vP+8zZ5uCY1n7gDN9XBlzl9kjcX8nQVFhY8mj69uTGKIoUbwAb4okdK9v6+yHllGC1Npg16E7ln3UXqlD6yZlO739RUa6oj869TOgV83IyN8O97glklhiOOpmLLjZ3XyPBVmTutaLhINCqizd7XuTyakdHRO16ydsMuKPWep4jMVC3EDL59YShPJen0MLEXiHdwelw58sBN5VQvRqoEBzNZ8GOf10eYWivm21S0syh0K6T3Klx6f4uQyMK7NTCZHqJsYTCSBMfssMntRSI0zCS8jBarN1awdjwFWiEZOrDDJW6zuSADjhAAAAnEGePkUVLCv/Aaew5o5wM/SmaSHpkJZ1GcgCfIjSN7W4gOn8QpyNhCh/wmctOIbZPf7FpjW1XkFNYLHNc97orEy96SOPK9bQ2UkzcTebIXCsmPLqoPjwlzWW3OiGWdS45pRjZftpGLVaUFkXvp499fYqY1HwdRO6Yc0jQWizdi7oHrjMxwIG4jrLVMgDqKwkiZskRFM3CNBVayAUkAAAAHcBnl10Qn8Bo/J85XzUBhsNNWaAK35VmW+6FSEB83Pd1IYgBJ15MVy3LvbiQNwV5olyxyK9ULLwDrQ88SYO00Na+i5UgycddO4aZ1KEH6EF8HSzUtJn3+tmP+qtcrjCubeJB/34kCiPFb9fUN5rJpojvnKDwnZB3QAAAIQBnl9qQn8BpHgKZadYhlSLSg5wttGux5wL8A8d24UR9lOHdUrSqQOAD8R9WEUet8nORJFObSsAij5pDgFeXqLtHgG5k0Ko39FbPjfKW//igLdMuDjoHJ5cw9Wh3jEhGll1wg87dN01uriYE4MHXg4fMVlshyceDPuoHDkTIxiRW00gFtEAAADQQZpESahBbJlMCG///qeEAAO0r//D0DKHRZu6X6R59BcTT1qSDxeGCaxASFVwXJhP0BgzCQYakR7o/Z+9xkzqYxt3lcoKm/ELnf/m07gCvdrEpftLpP3JkIKtGL5SVoawGMJoDJLH1Q1D/fsHFccU49oHN6be3rRQ30uK5GFZoofq5fwk4uH66xC0mmGW9mfr9Z3/3RotN4g09EeTi/f0k9dfDh+UN9KMzVRqWMDdn9R56vSh3yYpQ3ZFOr6myDxSHqS3EolaI8/QbbRcxdQDQgAAAKhBnmJFFSwr/wGnsOaOcDP0pmkh6ZCUXqcgBYKAcWASrtRdLaIbSawg9uaFQIdYn5CIWQ9aecFEDglRIpqwZXGqDo4gi1xsBFM38ZdkmLEABB7hLgorTEuy5MawcvubKQ0xobXcltrST3yuAjcY74D8jyQj174m67REy3tC5RygjRxr75DRKi5Qsewv7W/CGjFj3z2Ze1pB6F6ErOcix1gqQUMsGMwYBZUAAACeAZ6BdEJ/AaPyfOV81AYa+UbR2mH0zVsGq6mp710glsGjMnKyVtggGcEac+FDNQKaVftdnPfpwZdtewx34bM+8CxRNlLxauVn1PEq3c4JP2gwtZYmvCexzq2w48Y1qd3toW1p+1CB1YAD5n1fizrhEerMn/KDoyQvFqthL/Mquu8cUv0Xz6OhsKLC/82+AICgGlEDXViPwscZfT31ATsAAAC0AZ6DakJ/AaR4CmWnWIZUe0r6CNuMtwt2uXegATqWAfGj074OmNR1yF5VmlO5F9ynP1SbBQewTqRqhcHQ2NPjE1evKWO4yPBR47MysroqLbHf75q2kWsyZVdS6JStvQCm6rVB8c+i3DULsMuNkNxuP3ZM/4OoWgewCkXPc9QAbmhPvqjyqzcdeWMVxP+Tip7TfCGRqmo+EgpAMj6JtCht3+zhsOmvhl7q2IujBONknVRAAKmBAAAA9EGaiEmoQWyZTAhv//6nhAABa4sJCwGiACBL80PSoqgOmwOsbv553tJ24/V+neenFL8w7nvmUzsa3JGqd4VbT+GHjYZYCckdTyAn5lrfvIU89cwGNJW3ZlzcQ5RabARDPqt7GUNlW4fO+0+PdC09CL2CoPkUKfSpv9rhn4mO5mtkwavrNhldSurNui5RAwjyvWSS8XJXz18CI5jcTe0g3d0QZVqQG4JL4RLc42x2fvr//HpZVTniROfsxyStndJV/l6+Uwu59odQywL3yDL5qO2WWd7Jz9JhmT/m/X94mKHK3y8x/WRtU0WCzSwpGdufsPftAYEAAACTQZ6mRRUsK/8Bp7DmjnAz9KZpIemQlFnv7o1R/NHc2BbHF7UivYoASFFfNbUuwngPIgBDSqGNZ2k3HGDRpdZv7k8AUK2PadTWE6w2pPLXhWo5nke37NkRhL2ncPjHKWBx6mbwNVy50feZxgAuIPVX/mYlh4H7LCbGWSnYoLJAcceLJddeKSbPnFN0RKg64czTgFtBAAAAmQGexXRCfwGj8nzlfNQGGtPnMQHuUcIDK159Y/CvQYoYgEd7Fy+9afTxIMnCP5NZ6IARkKULMj+/XHphsTdIk0BQH+C7/1X3b0vloITe3mAf9MOlnZzEYHz3IT+XmSt15dJnQLcHSdrcz8FuobYUnebqMgJLgxxoKwsJAuY07DiOdeIoK4qILiMu5np+l8sTR79YCX3NxAALKQAAAKMBnsdqQn8BpHgKZadYhlRjpTToEW5fPaSySWpypYQwISME2g5tcAJMzlbMufJlHkwUB18ddmxBW4NT1ieoxXMJYBpKZ+1f+YGygWMqjdEMUWNyQ0T/cchtybvbL8NbspRbP5qQzHyiK4o5HWFoduk2vPvpIrfKxXMk0Uw668pDQyr2zbyrt5c23TLDkMZ8EJhU024mLz3iHrwejRXK30r6Gj0gAAAAxEGazEmoQWyZTAhv//6nhAABasjSYUAEZL1gAKgpzjJcWrHic85Z0mRDEobKHxU8M5diXwsa6EvXwLKTV+Bkg38EQbLo/mB+pC5JevOIKHRCocYKI2c/ORnFK5hzRN/xZUMDGKJ30sIjf5h9bckbTiA2k/ziF0at7c/tMU6hizvKNSRib/fqpNVvSF3lTJW+++SNL7dOW0RiP+/p32aqQiP1yGEI5N9vkhz2ogPdu+OTKVEd8V//+Ak5cF6+zFC+K9vWDLgAAACaQZ7qRRUsK/8Bp7DmjnAz9KZpIemQlFnv7pHbltYAh78JFar/zHtMDubDIw0vCrZ7u9dbWQfpYHHm6H7iCexnqcaD21SWhjtVQj9EZ6on9FQswRYNu84DESnuE4O7WZ4ysHxK/wFDNvuOw1VrBsdfnZgytnCC3iIKKYw9fDc0XGSYzVFDb+oXxlr7VfeYQhYMrkGgk4LK9QBWwQAAAG4Bnwl0Qn8Bo/J85XzUBhrT5y8ymPGngyNXZUPmzCob3diSR05TQkJM910AHt05Ub0fwN28xdJPkX9lqf8R9xZArjtgUF6WDoLw3CJcItCsNaIEV+MfXYcqdqTgqN//9NgbWnVSRyNbYwpC8AANSAAAAJUBnwtqQn8BpHgKZadYhlRjpTVYSVTctcNxQWSiPCAE1yh9y36P7u7sVNLwLkXxufEU4dv54FqgHPRqNYi70nZSwxDftfD2v1xZdf84ClTLymGqUfayfPenlbsP3kaqnFoUaoGyUd6Qu5xRZ9Fk8PS026uMTWTwWSOhrA6J9GB2H5XEgNZGYKKVsgLjdlKrStdoqhAGVAAAAOZBmxBJqEFsmUwIb//+p4QAAWzmXaObyh5+fKmC/9fXR0AWJDI2AAIMPIZuPE6wyUlq/gkCqD5E/tGFCjIIImY+BRSJvcHp/nKHEkW2RgyvIsFdCwXuKdgLv21JkYkZm8xRYhnDWABXF2Y6OwSG30gnclWt4kJryvMklVZwD6QKQJ+eUNasYHL4eA3mq+FWAqC/M2GWPOGguDSeNqgn3bdYivSJQ/PY6dxb8B/hBqQqiXbePV5xgePYZ9pyc7XnIpnWTFqDMJVQBv3zHwsZ9hEYX+0IX3l2KNyKNRTPv4Z1/0sH5HRswQAAALNBny5FFSwr/wGnsOaOcDP0pmkh6ZCUWe/ukFPI7AEjG/YAC4rajmovW0AvUD3QRCx3ZqcHiKMaVNt5zfVLBSYyhyQk6NgDluZ3JD9bTt8IEAO00D81X+H9QBOpe+9jXVLYcVQ3I9Gs390t+7qDcGNEO7fFe98EC2KLBQ9l9T5F1GLjvmfnLV72f3kVSejPNOHyfgVw2P6mgPp8ZFyI4SOm35Cn8WUDStJOaL2gacHtrgA34QAAAK0Bn010Qn8Bo/J85XzUBhrT5zEB7yipFgAo6r/lgAB+K2XDfnVoikh2XkvpdskkzePvcrDUev1Wiy1mXx2M3nc4ywwQICvhjlSyy2iacGGevj5RYz+As7so7VFXKbcayNrLo7k/bhdOSiuwfDprU7VgGjBn+ROMkEmNgOGqNAK2vX19jYvScl6C3bkOipz6YtqoOSHhyfb1WIK3Ia7Rh6ED8IBKtGhGiUlIMAAqoQAAAKABn09qQn8BpHgKZadYhlRjpTWxOrOy9gs79ZvWouocRAdy4ATVL+AG4gfK5f3SHHSA2errowaNLTIHp0OsaMpPSUq7JxzkLS+kN5iSlZGdjLVf1LBOsDRey51RKweMKpAZzjIe2WnWY2suIhnkyRO4Blmm27qO0PCMt2wjxcRdKOfNepUr0VQ6a9go/UYfFCCDFeF7f8LYtPlwBydQABxwAAABIEGbVEmoQWyZTAhv//6nhAAAhqV8NkTsgEqcUsJ2rlXKVrZG778j1Xe2puOaX7/3IOPjNJZwwZO+CJWChR2xNZAivCUUL2va4bpfxajEkVbSk6sjjXvr61A9fsc8VLE2/osFn53Go+XdyJiMc0CqQZ2rXnagKaJwR2y/Kb0ZBWxY6wKEQvxnFWei0rAdOpw2w48muVv58nIb6L6cl3OlgRK/sqXr/P72HbwAtm+C1wHjboLLlOfAfUli/NyNcOTnujEoqWuJ6cCraS+eRj1MxDesSnyU7yfCSNueRSPTt4ZAkGMiYkWlR89WQHUaHuhrk3DWkMe3mkgTy6C1lO/2YsBg2M1JIUA0y/E4smhf8OGG7OXx3NGcrVCo43T3dlXhvwAAAJxBn3JFFSwr/wGnsOaOcDP0pmkh6ZCUWe/pZ/7qEaTr4hFFzIXIAC2wH+FhwMbHYcLnR1PwmoexROcKvRJJQNaMAJzp1VQ2+WnchsdgILr7OMJQ/98U15LCNzoGZBjPfR1uXGoXhX2S5MIb3oswGCyvRH94ntnDMZL/J0gbdRf49Z2LMHKj6n0qwRBaRfREvzgGR7+jq5VYhAwAMqEAAACdAZ+RdEJ/AaPyfOV81AYa0+ax3MysGfZ3zvn7UMNFKMmvHVoYwUOnr9MJRL0VEdoYg8ngCTUwBB5sCeQ9lbE7m47SXs87V8nB8tapuiujdhptb//B9BUdUcZ51p8TYOeD5p2734P6w1Yac4aGRZd1mEfzQoUb+SFuGNrIJoRfmkBLluIignt0oriO2SSf5B377OXLYQpAJKtekGgakAAAAHQBn5NqQn8BpHgKZadYhlRjpQiyb36+oZoIgWE10QXZeQyg0v9OgA8vDyonyCvPHsuLteerVFXsjh2P2maaWjmpIjS2x61HQt77U7kcsokgk9Ag/WZdcEJTEHTXW9bsDbNCHWZAT4vQN3mY4MyfRnsEiwDPgAAAAQRBm5hJqEFsmUwIb//+p4QAAId03tCYK9TPmJiq6a1WcrZ8QYjrw7kL4rF6fCiPW9awxhuo2Dyy5l7eS3JEc0VYamusheK87ZQ8YcgHEXVrA9H6KLJf9gT9/9n8Garr9AbuAgDXeSOweGqeeZGgTTDw6nuVpdCFxzVUyRc6L4E7J0xAFihlrlj+lka2U2mswF7u0I5QfouNWfhfPNAgxPWkPy3/9mbChbhC9MnPmEe+PkLOuhdn2WbSG9ENbvn1fZBBWAfoBwVidVm7PGmIkCllBBA9BxcA25kT5ZDG0c75IYR0GZ9zzDTT22iZ0Av3dad/XUtsae4JnsIRxzGkpbg6VIdmbwAAAMFBn7ZFFSwr/wGnsOaOcDP0pmkh6ZCUWe/pacEm54lNaTKAEmlMq+A38zNomd3PRzXW/kncHAXWavnqSEm0OJ/VUY127ZXwscnKy7lChlWtAtATy++SxsJ6gl0dwwVc1eoq1Fh3M8yRon2/VyFzfYOtK+raXkYDD5Bo3tHTAoBzEJfn4spcWs+He8W/i5+eIERYBR/lsjQByXDT+Ohxnh9YrSROA4SoM7PQTR4Z0mFqALrpPm3IIBNs2h2rmyYxQhLwAAAAtQGf1XRCfwGj8nzlfNQGGtPmsbByLa0xdog7BItgAuow8kud6zakmP8DsXewXdOYpmace9SfBKvmE/x17k08HQJ1iuGWrCkwSWXwrdRRCnL3fzKAa/ecxyt7nUIItt/zTTmVt7ONSVDnLO0lFm+D9HG9lBOKI7KMthXwSHDp8aS3yA59fPaD9UzI7LyafeIBEiRzAykjksSr0WvQFc+xT2i8gELAWaCcaM7j7wEDJT0NO89UNSEAAACtAZ/XakJ/AaR4CmWnWIZUY6UIuiaAtf2Ad+gHXBI29MKc/BKp3Q30abh8A2Ofx+1BgBuaUkxy8pWC3w64LnPIsoJVri8U5rFmKSF65uiaiazMs0etxdYdACzbXESyquOzn6Una5F3RtoYEhh446Iri26Wf8PL0QQkrGEHu3/2uVmjFlUcubJk87OAtunJ6sSdI52SBGTCBJ8i71OCaw3e5VYB+aFtjYY4Xa/cYZUAAAD9QZvcSahBbJlMCG///qeEAACDdN7UQT2n3He4A4wD9OwIlic9CW29KI5LBTS5s94eMXKacOxH4k/LTFsNIIbYZ5ZobJAl3FYNJZSCDUoi7UsRhGTiENZemUMtMnMh5vGWfcBkikJoBYqtMH3Y75cMIy2ZQi+XIiVzsAmzjYCrOoEf+s5eweBs9b+QBHqLJAb+2e++f0i3q7aabgvvOEPDQe+wxE9/8KxQU/fOGEmcyp0redw73Q5XjSv+XwlmDsRlZ5skOwpQg64FwPuI+ZHB/fTqyFHRwPyR2Tt9U1DcUoa23HbEZckAJ2aKptlhQ4QaIPKh8EGNmuETQfD+VAAAAL5Bn/pFFSwr/wGnsOaOcDP0pmkh6ZCUWe/pYSa/hPUKOTUfWXXh9dEGiYXM27bzIAFY22u27g9GFmQ074L9pXc/lQsMXJLumqrKDZdHF7wVaXZjBn/dwsTT+2kLnkWF/ajEQ1KULnWR3xEj4nVv0C+8raqxu04XXNyujTE3DI+4vYltHwIzayka/+n74D+P/yyJAVijU7Jcrw9DCfYT4Xbisji8fwoqqZcxq7IWOlbzn7K7th9l+SsZgrlMAGBBAAAAqQGeGXRCfwGj8nzlfNQGGtPmsD0nvr6zYaOW3GkOspZXODrmb/DwAlbFRsZcYN6IO5p/vy+J+BZpgN3iGjm+PXtQJq7dHwibtue/vcBXlnKLr379irf2HKYnZfAcECTHEXOCpwU6KDrdU8NWAYZTWlL1a7SsHw5eNnqpit9o5ywylQbgnU5YnMegw0T2bX8gH1z+3cFu19iOSKqSvXUYlAryVlUVW7dbgUEAAACkAZ4bakJ/AaR4CmWnWIZUY6T7UOKgvenZTdrZlPCKFeACdu2ntg/fCgACEQxQ8kk/XQNJkUXWiDbbGjqRYajTk/kbQE7fmQTSF4YUKSPMz9lXAa3rJ7TOBnnK3MbyFbOWS1lVLq/UV0ocuHG3rMA9sxziGwNB+K0D7/8eETm9l4ulYX2MG62HschVQrIC60oHQa2xS5XwnMeHktN7xBpaWnftAm8AAAEQQZoASahBbJlMCG///qeEAAAzdjJCisAjwK/d7fhEizLrhl5GqH6/RJlCNwWaBAitJRnm4pNBQDHKTWxAe/GvXEI9wz41yPYjfPm62/MhhoxOXvAx/5WkWcVNx7MHsOExkUrJoi668pdn/liE08DTTW8E/fIpMedRg+jJ2SnoH+SyZvqmHAu/Xx1KjSWm57pAtTGf12gj/A7Ww+vQ/V/3+JAKgba+oug5hobE8rhYF0ijuoLs1L0PpnW9SPKH2JmFW7HQ5c/mJJhSYe3k83G4L9XdWP57aT731BxIoo0e+Y3fej/qkJdAjU1NluWSAlyS7Hxs2MlRlwqcTnVSEH7UC5LUcsx3dVONxLy7I+e5T4EAAACvQZ4+RRUsK/8Bp7DmjnAz9KZpIemQlFnv6IaQjYN7Gzm0ky9zH7E4nBEUP/ejAA1i44tUIcpUMmzrqDh2qrHb50zvV1HcFEUBlUvAvdEiUAgy2h9vnci6x362Nu5BiOCEm5c6ixQuCV8t3bjpTfB4aEtrGf2agKEx/J+zuz9ICzc21MRiDJZq8XaeXVSEM6hX7wAzwHUMovI9orG+72a0HTz5wlhv3evHMBC1kpqJOAAAAJUBnl10Qn8Bo/J85XzUBhrT5o4W9nMa+4ftjmnVsk5DCQoW0zgAsu/CGMLvKJK2kiCsMt1gQGsE4uWYPe0x1/g41UNaBqs3jgq5R3A9uCEJufZGgVpg4Jp0yD9X+h4CktuiGo5hE2884Dzx5b8RQMP3e+Fp5O6rNnjq/NXiJEGEagcjkvxdMwou6ifwujjobqCR5XEccAAAAKYBnl9qQn8BpHgKZadYhlRjpPtQ0Gvxp54CQAlcQsUx2AErAKE6gvKiNECINU22ppLYUhQv4hM/qQnk5vBiLePVd2se4l8FttTKzJdIzxbAqG16MFdizv9WuVyz+hvL7iji1uNZ719i5WrPy4R5b7usd6rhJJmAqMz8woheYoktNbT5MmM26rlOrBfsOtHNNeuT3SBQwkuuH/cbKCnhJAsT296rmPKTAAABF0GaREmoQWyZTAhv//6nhAAAM7r34EffyD4hMMwRRKQ95U7ZSuwpwBjW/tpPScceI5QvzUuOLUlUbzEnjACSfMMiLLIRMAaV44w36NEWTbNwWWe3AWQHVpTdiVw3gK3uIUWnEVTzrhzkyaKPZenJgMnStZeZp+Oa/krHePvrPYG99Zbnli37BZgKyhvzg5XWIEuRbVHeRKK3mRavo2Alshm5VPsLYsPDXUynFdknk6Z30nGAUHJmT0ATxIQfnjcaimN5WvM8kaj1luoXOY0+nzwEK0RNDi4WZc5UXnQByz4SK2i4DvwQ5EyEFngM1VEMiyIrjtijiMXSjuySbnQeroXuyTghol1omHJB5uEDKR3P8DZ+aBZXrAAAAMNBnmJFFSwr/wGnsOaOcDP0pmkh6ZCUWe/ohtIIMxgEnbrhQAce0yxMmVCs6mbcXEAf8kEGMuTxNv7vDR3o8X/B6JxFS/xs2SwXl0wYzdwlu/KdUS1JfjnsmJgcWCQ5fDvHiS8eA6r+5CS2KKKxWet9OQnjWxRyT04WQBIczTfhTDQZ21TCC5I4hO6T/0sC4WhwnFV7/uFw467ROrdKhfpmX2pA0IlykZnxI5m6yYvYieEaBQA8R3/vUV7GgBpVbwPqVsEAAACMAZ6BdEJ/AaPyfOV81AYa0+aOHgTa9zcbsadwA3NP4JiHc9RQI8SQygY0tRKBtasg2l+eh46P3jSiiYx/yGk0NkDrEyt5l2pknKoiTJhdSB68ILM4DbrhV6ZQwt4w0RSwtF9hmXKVilLYZ1QnujzYgRHJvB5I9nFWl1/xQe/vqeEPp2PM7diIIceggZcAAACsAZ6DakJ/AaR4CmWnWIZUY6T7JNySwREsKACdyVkMbSToOf8SIgFS/pzQY1FNsYNkCiRE08Ay2MdUmJAx14wVy5RAPk3TWFnLU6xHo6jyFVMo921r/SCZuxXZFvRx2dpGoNj/FWUxIAl4e3ywkmTqaG+U9oHWJ4PMh36jWZzPVriWZiyiSfElNs4BAsOH1/zD1qQYUqok5V7ckNB55W2FyQpDQbonWL8aTOgJ2QAAANhBmohJqEFsmUwIb//+p4QAADO8JuxXekrkC7tINsESX41FV4C/bu+sgkhjDrO+pUN7+o2Gb0bU8M3ZUj90JovI8eDZDN8OQJN9gVtQzmC0TzN10eVuO39F5xRfF38gTVSf0nWR5OViJ30Z+G3rt+RVOqiFs+CXKtgi+BawsdNlXglC0poXRUNvX62WyGnHU+A6PPBm/DS3z02F2d2BOFUqneIDxmZ/baGEzISqjpaujHv4xeA+qjE0q0qGSV/qyfHjin3cssDBAWdUFx6s/F+qBQYGMv/e8cEAAACiQZ6mRRUsK/8Bp7DmjnAz9KZpIemQlFnv6IbUYJHgAvHNaqqH+GgRa6j4QHdN/QfFyKLDnqwISjzHmAu0u0A7tzSyyHEfpnRI56reb20E9aO2LvzkdF56/FPHS8wM1PzfRWmr7mqf6vlNXS5xh1fnH7te2RrpLIsd8QqFWvgolkO9gbU2rk2ypd6nddMjsFu9xmJ8KaImrgMmaz5VAG72QHzBAAAAiAGexXRCfwGj8nzlfNQGGtPmjiN0W2pGLSfLES+REcgQBQPeWQBono3JCzjAOGdOHsNnRXTOb9qBh1dAYqIftVDbbrK/1fp82/zIpEX9VsZlnz4v46tswd+UIkCOKlWyHwJ66Qg2uyFEuQ8ZnXsqa3ppIroceAJdMv6UwSL3Ai/9njoJPN9AELEAAAClAZ7HakJ/AaR4CmWnWIZUY6T7Tu+e8thTbFA3artEKA8AD+SrUlIG6K7Bpi8mvrSUJ+qscU3Wtroy/F5piNPshwImswLUzU7tRKpiJ1XdG7jGss+i3DTp/UppftP6D0N49uAy5TNATRkIIeFOChmBYltNAX1QAyyuNcM3Qop32a1Ikcvy4Hno70VEEJ7p3NbqY/CqCCTPtX3NDeQ68duCXFzoaA9YAAAA6UGazEmoQWyZTAhv//6nhAAAE1P8ivnmVEUwVp7kGLA3wCK/5mqjG4pjo430Zkf/rOxg1pntUDjCEbTeMeH1d+QJ0UhLkUTOYEwh4H7R9GggNnDFSY/0x7epo5+2zmYDbDEi2LwgggULl7ucjnVrAYI27Gu0vJbN8YjVsTT/PvfojG4jZrUo7IgVHDpo13f6Od613nBwq+hJT3HrzHK6YhCfN/g0Nd3YAaRr8arzzNZOmX2CMA61FoIgU7FV3K3ZOT55P9L9/19ycJF6udKM0Py9/tEiF/j+5QsCmrY8ywCtz/ivAcpfIkCAAAAAbEGe6kUVLCv/Aaew5o5wM/SmaSHpkJRZ7+gzNbUOgsHwk6BXBMAm3PYwOBzxHe9S78GVykYMXgvM7RdOFAAWJqA8ByUVpf6czKTX+nJYd4SswSmPwC0BruMPqZkPC6XIigB6O+e64nYSXmkGVQAAAHcBnwl0Qn8Bo/J85XzUBhrT5oAwFTRe7ThXRwuvX8G91dZOIQwBW/JI3sBSbe4FwVcAI1Un0e9XIyYsWUc0ZAb/+iZECBoLwsYU1lVyALPXYyk2xw+PHx1WbTV2tAI/wM1Ie9X436MTwoET45VsPlS+S6NJzCQ7oAAAAGgBnwtqQn8BpHgKZadYhlRjpPZvRN+Bl1rFUBG4odSOr9JKqD6N7lFEdtc7wAbdm01Ng3M8AosuD86Qjh2Vjk27pHAEfHJpOLmyt+vuNZ4J80zlHN2uvtW8G2WNlRtfhFaOpaQXqeBtQAAAAOxBmxBJqEFsmUwIb//+p4QAADJ8J5op9xcGQIBisAM+DTkfpd+ihNFZwDdt55e1+HOy/S3kdB4s42pZvUdIn/z9xOP7LSenvOcWU47BvJYm0h8Tr+e3VhXQyhh1fgtTBoFvPadh+CBqgl6ta+VLxV+K5FOVEQndLUjRGNQu7C1xZgZ4G+5qPVJzaPO9DLuN1zO2R2avnbqexEm6tScRU+vpUzDYYb6WLT0hUKbAZGPbzeTi3n0/TReA7C0Rph3vbjtjkJrws8V0uoO/PNgDVobMrrwt2M2F/ZtSRsoALAu9LcSjEahpP5lFDET5QwAAAJdBny5FFSwr/wGnsOaOcDP0pmkh6ZCUWe/oM42P1adrt/9mMYAVJl0susYsq4gRqZH9Dl6neyFrWFD9ObnMd4Kzt08Y84l/3Oa3TGzxUPDRCxiGW77D6JxcAy2sKNBoQVgoOhAM85ss/1c4ZEPrcSoL5HxnfSdpIN3z6d9TaUyTTjimhEj5piYTROZmaCOY56B5n04TFgd1AAAAYwGfTXRCfwGj8nzlfNQGGtPmgCQhOVRqS6zGKtCL57WbyKwE8Y+cYUZPQ1d/5/hSABbPK7HCvx9TfZUsO2zXnq3fdqPzizEpkioec+WdREURRT8rk6BNClcJn4ef1mrC9Fg5oQAAAKMBn09qQn8BpHgKZadYhlRjpPZs6pjtGCTFHt68l7tvVf+Dmc6T1We9GENACWN5C6np3AvaBmtKTWZlLha4kDbQ9qNK/CumkY3f4yc0sB3u7SR/wDJ/1iN/Mb1n0n/4MCUJDWehWGJElRG2VE99Vhit1wov1hy5fa7jjUvSlFren/JGpOxNzyuzse2aVdaLK1Cj6hICBCV1dHB33FUNx7qYxwR8AAABD0GbVEmoQWyZTAhv//6nhAAAEtTQHo2I5lmKhjg36AE9lyLWf3GwE3cVRfylbT6uG8V7vudVsdKvrUmGplN7hziuk+gJHRF2rPx4VOQ4OpT2qj37IYvgqKmHnsyII0UBbSgbA6/8qQUK7O2qdYxhoaUh2SOo8YD+Jmsst+wPu2kyX4lKhT/eGCu1ZAMIqC1o6INegEvQI0WaHt+9NdQdsD1E04JTRA3PAiuFmmihUP2W0jUj98StXXIEAXSlC0BNGxSTl3jQygI1vLFVKmiLelOf8PS2eN330lH1zEYz0OCCIR0yJ7KgkEqm0FFDSeFCmZzIiTpJnJrPnzoxJesSGL2xc9jXvux/Q2qXNUHArZgAAACuQZ9yRRUsK/8Bp7DmjnAz9KZpIemQlFnv6DM7V2epkD9NIrAxNkAOgLTLIQlOvoWcUFzCCg/GgNdcta8oWi4cIBwcl3M/kNk7yBmm3wCkKRSm5OxnAdfRaaWW1VfFsHIhgjRv4GynQkb8zuwWZJOzS6p+mHf5zu4j/iL7H0Ezq+i24GJ9R4SgJuMMbkVVTSu6jurFuGgtG2slBLbZJ/NWFvGc51L+4N+00OkskhWxAAAAhgGfkXRCfwGj8nzlfNQGGtPmf8XbO8KadFG6Pa3KRjWmT/B45ACaJxkaQQ0AOFJS9rP4WSJXpwAQ7SdEREIOzsSS/50V8t0iSsEB+VXcXYRpna7iZFbb9k4x7KV8r6OksBxrrgzgo4BLAvhlSceCkNdUdbUGdMEjUQBx9mneU2h4EbGY/gFnAAAAkQGfk2pCfwGkeAplp1iGVGOk9nAo/2PD4iqygQXb3PhTfJsemlBt/DMXr2jD+hIJcI0ANr7eb/ddwSS9K3ayYY1aewX4y12PPztPCPtlUgOFFxbtUlOF2GP9traoZ8takQBsg7WF3QMahMk0o9em800dfXoc38W0Y7sMr6NI13hHYIjd56B33VtDIOwbImEAsoAAAADKQZuYSahBbJlMCG///qeEAAAS0/529BnEv004OII/qUD+o0hiIzNdAxNiuafbmhw5O6Xv8Uk/hcabbBB/is/tjWj69dWkjkrLVMNUOJlvHGCBs3jtg8T996DUOQQu+deODptnUB3/JNgcMCFBYO1dodhgR2GbfAjwY4EPaWCyO0KubdHQwmzx99fz6v+otfGYx/MFUzVRZtwNcWpfLQwNfPylViVOhbOns5ljNMnC0SJCpmEbDbseu06AvXBMApTwS1KL2H936ghg4QAAAJFBn7ZFFSwr/wGnsOaOcDP0pmkh6ZCUWe/oMzte7Y34OKmJfJuCZTuQOdH7tv6Y2ABLKk7k7Y1BtUZN4amP0Ryd3fpyWKUKSrmhCikgMlr2gbR89/hbcdjzYSyHCpNjwCaAzqzmTTCAMAAI67adIsQUmXlze9QHwfefQQCbqC005oWwi1CIqGv97w2VKcAOqILiAAAAhQGf1XRCfwGj8nzlfNQGGtPmf+r8u8PQ6ZnpAEahuNS0uaPt85xhCk7OZ0wAE1siMTJPZfvA+bya9g3/iQg3GU0cX5fn8B+7CL9lxhCpI17z+mVl7y69yv+CBTKuG5xjqzcJ3u/1wdfnnz+6M0K0lyoqrcJwX+L7BcAeCpjOADxlqIgAEnEAAACcAZ/XakJ/AaR4CmWnWIZUY6T2b0TH8Z6c86qVNi5VMvfi4UyoAPMU6JFV5O4uQzK6QLv+4bPzUtHLoo/07QADmBgKc1NzjrzgHKsSGiby98bVTextDP7FSlfFRbWj6gfBg2RDi+N6LFrisPvk8p7rXLB1mxdT083ERBzIQ/L6+vt8pm6ghZ2J1PYZgxph7/SfeMUl304VorCiqnehAAAAp0Gb3EmoQWyZTAhv//6nhAAAEu6bdQRunptsI7VhDJudv+R8ilWiACMnlxmDEMOEbAFs5iHrjck/PjKu/bXX+LZxl8X06B0i39rIYXf4aLwCFdDfAI/bEhGlHjL20x3mNW2UlDWTI7Z/QnczgKxeXzecRwWtnDVXXXJKQoEcQaX7itp9oMB1hbewmtw5cAF+L3CGOorNkvARpcPKqi89bVjX7Gd2KMlYAAAAgkGf+kUVLCv/Aaew5o5wM/SmaSHpkJRZ7+gzNoM60Fd3sH1qXI2Kdte53A2KfSnmQp0j6cABLJUDhULAsAk/GczM2cfyCyKc21j9cL5LOmlGi7JHgMkKNqrIOuFMy2j7SLcLYIaaLRSG4bX584DKZZVFPtYsTWEXKdnXVrzK2xbgBJ0AAABfAZ4ZdEJ/AaPyfOV81AYa0+Z7Dgc+Y1/bfni/cQbY0t3VWASrTXHyD0VOXTgAbFhiHl092Qu0+juIlU4J57z5BPKuzPVORu/0zIH+ViLHZit7+AqmW8c8dIGFw7t7LuAAAACCAZ4bakJ/AaR4CmWnWIZUY6T0mNTBRc7oH5QAtcS0Vmxyd74K8oW71h+tsQ8eaMhneHFyQzMHiGGx8yxnL45bgh7JwiUXBikQNrB0c7OagArg8KfME+DU0wEfdRFUDWbDgYIoQlP++/MW12wVBzmP6PAcFjUOLrJ1q1dxyP6iUBwDuwAAAPZBmgBJqEFsmUwIb//+p4QAAAdHhPJtCiKu3IARIg5ZgAyKcmXbD2FUVYj1szU7QqpspN93tQJ4xq8mNT+edx1IkhiuEBWx0QbC7jXSvf+zQFjUMIxS1nAKXmZkkn+RO0JKuwpLpKOIJuSnpp/3RNIQsZ+2OGRKgnwHyKFPz5yPJ9pDRtttZCUancOm9EXeY9B8zMx0oh46DTbiugp4sjqRQp1wfWMaRHQu+rUA8galBWP3UcRpEp/WlZr261MpJ1WxeSMR22yF/Pu/soOAKmCIqAL64RnNoJ+zTfBM7cNEV4w5FSTGI4niVwXKzxyU5mlCM1G81i0AAACeQZ4+RRUsK/8Bp7DmjnAz9KZpIemQlFnv6DM2hHMscz9+bcND5ACzypPp8Od7+mPPD5hU+Mwn+BeCbAcZuKhFBrf3RYt+zgHmJnEF/OUVtxcEmtRmXnpdU/7ZZ9RWkh4qJWZ1m+Mv84u5BgTHsmf2iHWtuwFWVS9WN6mwC59J9kpTVZkjIejq2QaYgzFSLFvfxihbusR1e8H+baoAk4AAAAB1AZ5ddEJ/AaPyfOV81AYa0+Z7DGbUxTIdmcEDTKsxQACyF9EplSSBzwVnoDnVBRZXoPjd9Fnk+EbYxx5WeQUnz+54dxkUW9rCNHns2lq3JSzUhao7ckhTIfRRoRatr4kIe3v+GoRJUk7zfl/8ZCfgVwvBGg7oAAAAkgGeX2pCfwGkeAplp1iGVGOk9JjUu770AAThneRIq3F9Q2F665GlZeogHWPDDl7J0Mqp7v7dKluUb25zOEdlGLYnAUUfy3w8ybad/HtsM9bwmivZvknv+Uk26V6+OXCZ91GroWdcVe8sGYySmZWdELs7nmj7wQp9QOP65WWzbyGKcAhQrY/qXvnzblZQlMgraIu5AAAA8UGaREmoQWyZTAhv//6nhAAABxRRo95qUqC4WAL1wX7VYQLbT6Byfn4Z/MQEsIOcrF/u6brB7ZA4NwUidVlKPz4fsoKkKhjpml/YfNqIL2+E7GSJIuN8ePNM1TlQM+76g3Zmkp+Y0qFww5YTABLCMmT73JcSMnqJgb3x2mDr2b/y5NbSNyVb0+91dxqdp7Qq87AeFRNxWPFaVCW7+Nu8waF81K0LAYKWPxMHGwux6vsp4hck379NmsZ85xkNLQvuYMvWb98CFVcBSQyc3DqKXakYWpew2GVilIFzEYS4XdVPTqKVyev4JWT8vwZF6DvFJeAAAACXQZ5iRRUsK/8Bp7DmjnAz9KZpIemQlFnv6DM2g1AfcoQA+Neso2IChE7JZwjT4FfP1OxsQMrLyQAr2fyVlfk7ouMOt27e8oc28K7P1OerJgDeuSNkn+kMz8IexbDxvEp4uPkDtGl0gVGvX61ZtVhQSVHI/nRyzaRNHAklzSgjKkrOHLERLey9wsXO6UpvMeeJp3zavbfBBwAAAHYBnoF0Qn8Bo/J85XzUBhrT5nsOBz5e/JEgmhB9PgBMqWxcw+Qk0D2T76u8o2bjlMU+4rj9JbTqU+Rud73EI6jcGorYGBe2d9+1FF3fkEwxF6dkRQITTAUgDawovPUkuGYXTNl30Xu4Gra870D5sJ3vBcOOAFlAAAAAXgGeg2pCfwGkeAplp1iGVGOk9JjUu7zXE+JbsQ314p7LgEmmmkL5iQV/HDNgaGaoygyC4AUFECIAOCi7v64XeD09sa8OkT/Ik5SY9hwSoHR9cBB7AH1c0ZCm5tPAVMEAAAD/QZqISahBbJlMCG///qeEAAAHG/o+he4tJLkxH3HZWKJYSKre13+i1EWBv68VinUexTx/Me9I5dLnvH0ijZ3II2cWz5/yw8lJVbMgtYe0nesINa7g0/125rOl3ACluSE+17tm7qDjSw16VG59Ou/peltHsS0wMO6stIb9ZIoScfqEJvDrMbD8saUsns9btMAxqLo1lR44nbyaRXeD7m3XczN0f6xmd2TlsVTmNr24PK9k43s+XxjNQ9cJySzEoM60AhZbErIJuCD1l36TRxpAIBrAMDgI/cpKfB0kfJkKsrEfhpREtNS2vyvmEUamQaHyOLeGikcSXfQKptxt0yU1AAAAsEGepkUVLCv/Aaew5o5wM/SmaSHpkJRZ7+gzNoMV1xwTM7lNbzavKFkKIeu8zYABdSg/IqLXyXkC9t18BAB9bwZ5wW8lFTJFEU6qMv28NfUHAF14MZMMYjY+YttaXgY+3hupH7S2N41D72m6ELoIgMUweosfQLGxVxCVmDo7ALBggVP3LH3O+MEO7wyXpjuKDglf5Hda4VqqkTLep3Rw5UTgl1xR5byAfGUZGD5a+xDxAAAAYgGexXRCfwGj8nzlfNQGGtPmew6drjx6nTRB1zbswAJFC0KMd7niy9YOgbMP5WduHWlFApG3gTEGHAlN+eqf/ZNLg5xcDh12DZTRCQWFctH5nqpTuQ72TMBg6lFjRPhUKFJBAAAAegGex2pCfwGkeAplp1iGVGOk9JiNlFRMGsk5FbVNWyMO0AJlTeYhNwxFglm70bj7oIZ3DSKxhHYK49Cn5xbU/UaguOvchCo1wiOAoc6fsf1kuRQXQ5RA/Ky+TrHz8FvYVv15ViRE5Wm6K+XVoCp6v+b3perEoPBdXIOmAAAA00GazEmoQWyZTAhv//6nhAAAAwKyAyQB5AAHFWzWjxVuv7jUD3OEQAtazzg8sLcD8K6bIohIas6VfkhoacGlKTF6egjOXxaEoGEi/DvUoUHhSeNvv/dsGKlon6Apk6Lzzmj01GazjohalMFe2WsH9f9HepHGSe4QwbTvPGKfBwHVTi3E6CmdC+B1SCJb/6o/FQMk9WzwkWAkTlPZZDgJYoc6pfSvzdtzLDPlg5sEjrpar9KjT1mfHki2RXfoigLMKeVqpB5Gr9psxKZARFu4xaczZYAAAACJQZ7qRRUsK/8Bp7DmjnAz9KZpIemQlFnv6DM2MoiX5noZ3Tyi41BwMABceWsCOhHVzn33LrShY/LeF6VE/xY0GT1ZDatUpeO/P7S1ka712OIEjEu4IZvv8dFAn/bAWErwHyWoRDtLRmYGE9azezeW7blrQxeFDcz4sKDG8SYZGgcnN8k2BSyo2YEAAACXAZ8JdEJ/AaPyfOV81AYa0+Z5JNE7F/sS6nfJKMO5Vdd7YhczEFW5jwA21Jk+8P4yD0GLD4WJ072Xak4v+OSBCeCUvrqi+NC2KxyfE5fFBaQ9yVLUwlp3fMK4KLlRBS36h1shojuim6u14SkPwOks2UvBIE9VUME0Y1db4JLK8pd13A3lAQRVoiRThFOZwkBQfpQwAoRHwAAAAIQBnwtqQn8BpHgKZadYhlRjpPPqVagJKdgVMeKco439YOJ9nIqK/MOC8vQgAON29nQYyg14s3UONGTHIemvElzAkTI3NAmYQTdqcinS8ITeY7fjJIQuOxopu8arvAoOUpp6/4w5LLgFITbq8iRyRr1qi0N1UG7XGNSxJD+VTQ73k95APSAAAADLQZsQSahBbJlMCG///qeEAAADArHnqVd4NxO/T9iUuAEJ0MtTzT6EI1OPz+T6j9rFNMxeDiGnsOEYQT0rNw2UzGu8VoWdpQcOqXL1/DBmy5byFhk7FjNvLVtDlE5DkhU5vxpqQI3JLAHHde3Gp+L2h4VQ/mj2SLhGvkdVQmO46wRK0tsTrw1C5AZjpqpxettrCANu+SXUpaMUr0FLD8Ob+EX+vQ0TooR+BmwRCNx3lKByuyVxZSFTNS1Oc5/H9goDjaqi1NhS5pDMwYEAAAClQZ8uRRUsK/8Bp7DmjnAz9KZpIemQlFnv6DM2MrDlmvzPFU5AB+nKm0NuqBP3f6j+crE4FawdjSl1V1sI1zNzhg7pn3D2Bc41jOUutopiaX1k0bDCOv0hDVoKebcylHca79Eteos/fgqy0IKneLRd1pnr5f4N05HqZ+3jzEAvUjS8WJvBPkIe+8GkaiCE+7NpcoKnnwi5rx+uSK0ruwe2aDF+KAk5AAAAhgGfTXRCfwGj8nzlfNQGGtPmeSTROyt/0YNIBx6CCjGQGOFFWRIlfvT6AFWjRuczPcRuUWzsD/pmooPW0jO7R7bmMU7PDInJvttkXEmKTQ2E5pOLbBD+u7DytERG5wR9dotyPQrMqE7ovXA887IMKVaizUUtBUG+5HCk9wi3BL5whRUVuAKnAAAAhQGfT2pCfwGkeAplp1iGVGOk8+pVpbT0TZ5iIAirtj7Bw/YL4mm/7mZX98K1K3e2WCU76wYlRz/bg93YhcPBI7qJovSbjw9G/uHi9WXzgcQcSmPwmnaiU2O+jzNnqDE6/sCMziYr5XbuS2rPK3a8XhC78xUeZdV6IRpaQyxWdlUT4XTIEfAAAAFfQZtTSahBbJlMCG///qeEAAADArGUC6OyAG5oar6VwvcCnhzG7AlhLIEdOUIQt5y3Uc+8Hv3gmXetiXwRlm7bmyUmWyNLIlEgu+/SH7JZDL9B4TE8YlBNkwxIpJ0RR7BAIZ1wCDiklvrDCRS5GxR30FFhe1YEbEClKyf4tyGgw+ZTxEo6ZMzrDMLyQmDqleSZFLMJyvETkCZAxrIghqevzzXa/86pssc8TyPSUzzl/F0v9S7DI+wZG9ItTDKZDo4FZ1+6aC7Enu3iccu3gXGd3i6z5bRrAMfvmRnl+iIkCLz+y6J2BQ9HYJ10F06RrpC638lwwv6NgaBRxn7Ul3DJoOGnM47lcpIlK5idKimC3ocY8UUGl18Ovqdw0mCgXXs14J8k78rzFlpZAc+oXQVrwrWa8J4DOQdZTBUuRKfxdaaszkWD3ZaRiLwuQHpYfQUOt4Q+2Y4vE91S6nHv+5OAAAAAoUGfcUUVLCv/Aaew5o5wM/SmaSHpkJRZ7+gzNjKw/xZ5JHVhoOPwL3ZFABYJtCIW5/Q1gyOKZMrcg+k8YnZUOG1ScRcpZfFl/CSVeXMXSQThhqi619P99pBa++ZqhnNkACMlqskfoUfQqSenzNMoIw/nKIhdccKIOk/eiFYES7r9FxvW/tT31Be6kSaHcUnAQkF2DBwOEGsWr8HBzPlxOQE3AAAAvgGfkmpCfwGkeAplp1iGVGOk8+pWFLFQ2KhzCAGomzgKYIPoAou9qrCaeBG3b+nS0CQh/aTgIzrjJWl5d5nc5YOSIJLhuaEG15KvLu/bY1yi4pFVl2BpCrC7agR9G83b90tFx2r2+jmaqvZ/cPF7Ldmd91LDocpq010XqoBLsFTmCb6M70rD9/x0enm5DQn5wGCEoCwPrEXeLbVcJUnVKeGF7MD6mtMvHP2lSjHUXRdsLaF6omZYMUP7iYTigUkAAAD8QZuVSahBbJlMFEw3//6nhAAAAwKxYtTCABxUcSNckTA5IkFu9zSFUMJh3YNJOAFD8pz/8d5eKqsKnE1+TnYHLwLbI7ivb2XZAT2xbJ5s2f3ji5mR79ZrL7TatMEOh9WhjKFyK8JV1vL7R3MSA1YWfsNq9WNAiQglUwYc22gXqBlNo0U1yB4oiXnlNU332wggg76lkzxbLDDtj9NjnlrQ4sRNJpig5+59W0dhIkFcOpOESK80wkfIOvK9Yp5r/phBiYlgEbY5AVDHJWcnj5nOqhMg+ZTLZi9bZxUI+768XsZ3CJj75TiiJd1Yq1BDxTaD9zfOc5Swa8FFQepAAAAAogGftGpCfwGavdo6fXy9Wvcm/NRPjjvCA8G/g1GTzhJggAWhHyx2PUuFh/ADqCCPXS3ubLy+uOkAl+gJk/Yqfd5+3esekhB7U8Fjm4RcESgyO+CG+ui+WZY3L4FAemZW8/gS2ReF7EYQX3JjyuGZPUpKojbG4MnmCmcRD8Vi7GT2UPu5TE4MkD2mXSUq8OeWDGxStKtfsVWOzKInpfgwS8QPmQAAAPlBm7lJ4QpSZTAhv/6nhAAAAwK17yQfKzUqGC4OiKk1WkcO4BPN+vwmBwq0tmGW2TaPUtTnvvZE7MGEzrXlvXZJiQYcSxg1mRx6IPNePBNZuZRUVBYPv8yYBk3vIXvECofld/+sIfINPaYrHJFYxKv6ggneX48QCnoEbUmDT+umoP/84U8A7eZaQGJR46izqfrNq/YEdpsoZ+bHIIWJuF3zNiZFqRGfcxVWRyygPbfLEtCsFb7uRUzpQ720ued6e6eja/NWamN1bj8we+0ykxn73porVKGIKgCtru5qSoYtCaeM3zcTMWmwr0DJCQmqZWzd2mrq0Nfil4AAAACiQZ/XRTRMK/8Bp5MmhLR9+lJG4kEOvDYURAq6agfMevjOrJJj3SzOB6sqOTVhK5XMAODHUivoVK7gFXV1PwfdZajiYs1o0DuaR5Hn4PO4JNOe1WQZrpDdtvqXPAi7WFpHOansGDExSiLQZFk34fo0AHIPxIb13xsDAYAc6gU7h0GgpA3ZioI2HFi+FKAjjGgfYtl4AsS1QPTMwqH4k1GhkO6BAAAAlQGf9nRCfwGj8nzlfNQGGtPmeTR1EOH1cx9EOEAv6PiwAEEnqH2TyHTvoZtVbrjLIoUzPCHQ3rpgzC/d/dqrZHsDLB9lWxPJhyhWVjhLOXj6zUeTnTz33NMDQwlApBU5SynSDOajQLcsw/VPUJ4QoF0q6N4/4nBgkgvSuJ8uK3K16vYKN9ZTtV9wYgYIe3iZoL+alAVtAAAAgwGf+GpCfwGkeAplp1iGVGOk8+7fUFzavoFF+cgBYd6zpGPQY1Y2d/qieei9BUS+lglyEU21GFVeTZg2D7T1Xtxqx6lmx+1UcDnchwBmhTwgfJqTYgA7PjFdvS6TFmJo/ZgnGac20m12qWGo1U/CVuIrify99scvdh7FmPC0+bkpwcXcAAAA20Gb/UmoQWiZTAhv//6nhAAAAwKjzLtRY9k+yNXnepmeuTIh7OgAtoUGqK/smfHr3SQqv8itNAtCRu6qaklYwqyDDLHGQHappDNFJJfkmh3TSMQNzRzjEapCk8FFb6nlykLYEtM/rArjVBMDtQ1ZnEMXSXadNgTzu9bXXZDZlOH95AATchV3/VK6XwpoKyjYdSYPD57MpJB4rhUQYYFLQvHXasy7XNTMO0WR4FwtzIVkRZTkHmWG7scd4HSWAHU0cGBOl0Po3ezkzSTMQd2bFvSbuOYEQ7HiKnAZcQAAAIpBnhtFESwr/wGnsOaOcDP0pmkh6ZCUWe/oMzY01RI6F/AsdbWwnhSd0/pUhJRf1t4/HnoF3DAAubjqLcJ+5ZjN9lM6xUpUff6fWlJcfY7wjqXrIvL6INxtbFO/16SfVG3JAScP+4QIKMtoFXJEy7yP/LwVuOGAHE5dZg2NOx+BswMCRvwwIOUAhlQAAABiAZ46dEJ/AaPyfOV81AYa0+Z5NGz+t0wE1FIlypP3OBCw+RK7fxWny8fOt5KDeSrE6BXWfLCjwspzXkUH87ozvK/pqsXSWGfYUq4OlvYScn68yJ0lCMYjZMEkeTkdUZ2AYsEAAACpAZ48akJ/AaR4CmWnWIZUY6Tz7t0/nwngjlSxM6AA4s5tGwlEXX4zAlEm2DbgTVNhiB5hgu9Q4Vi81ruDoYYhZzFQkrsjiocTbjltwtZqIOvlDbxfXpzZhUwX+cTPyKweeQ95HE5AvccYbRHwiV/Dm8Qt63pS3VarohNJBpnoJyTxWnPPjGlWyKZ5DQTTOZYx7pN793EFZmLxwqN5vrW0ofzh8AUmU2QJuQAAALlBmiFJqEFsmUwIb//+p4QAAAMBLTkPSAFvR13GYvNU8JZ/18SPEy826k5aKN7Vaz31ZLxprDaS5dbeZ5UznxXpBXbN3wA6EVeGIWfF0tzaWYSsBmjVbhgfdvZBZ7myE60H9fQqZqJiqCeTRD+ukcp8KY/ZfTgXD3/nmBAKK4nK66BLuJdlusHBup34VCQE1n00lt3fWO4jTSxKTnMTRO+niP2BQn1RvIc95MrSLq4Fu/o70jNJemRQsAAAAJhBnl9FFSwr/wGnsOaOcDP0pmkh6ZCUWe/oMzY01RI6GQHHFxx9RYcoAIyOaEQtIgz1mv5G17Jj4Yf9QijHYVIxLbrLG6kh51yEWjbDD7Pna7g+i7qQ2HE5peiYQoowJNckr7iut09nmMmSe1wM6Cy4ST9z90DXpy7mzplQQYzrOegyHOt/6xl4s4r7Vx17FryN9xYBNTyLgAAAAKcBnn50Qn8Bo/J85XzUBhrT5nk0bP6zFy+mE3CLAQAHHs/jDP+GTQx0pG9BRdjJI4woUTj5BYmlMdYT0ymEJS8Yqb7y5LVnbVUfOmwtD1W6wHh8pVibXgs0yz/oF8iDHMX9mT9EF4wY9y6NpO+gAu+bnVLsyNFv+d7YOWJO4np0Xu5SU4p2WTGAnCsHMu2lZP6Z1FYea4YussDgXW5B3UgJ06OkSIAccQAAAH4BnmBqQn8BpHgKZadYhlRjpPPu3T+qkYIBx6W5g6AK35Vx2lhg+bWbOPzbcEC/6bGRFW5BprfP/i66qSYi12H747VF8fw//zSA/35bxx70C3oHg7yeKl8SgL73lDdWUaVRiCJziR/jlMZzXjXEFxsbnyRhgY/mQs37t1HQNuAAAAEVQZplSahBbJlMCG///qeEAAADAS75G0hsjOh6ApGDRK+nZFOhRPs1wOQgjETs8Sdj/Jsx5EGlU6RbxHqwGjH88plm8xvQjHlq+NtUiTZQ+Z2vOI8XfURFfu7jZRiT4KZtCP2zB+x+vmYiB+4ShbrdOwR8tUPHY88eI4OQdrpwybmWWqfn2c4pT3M30LY8XU7FCnnoLSZ5/Z172l5RuFR1hrr9984VpfQJuSvvW+a18z0Hnd3vy9Z03YyZ/q7HKzbtlMx8ajwtHUiqZ0dH6nPNhmOme/0+dohprDxWQLTK1/mBg+f4ezXpYiRTR36kFzDKeZC9GssA3RAwjf60tNbxnLCd8YnQC6jKdsxas7/aBvawvqQI+QAAAJNBnoNFFSwr/wGnsOaOcDP0pmkh6ZCUWe/oMzY01RI6GR7zxfmNzQfhodqn05r3eBWvQyk0tzmXeyJ5cC/pQSAahqIAJipxIW1iySPAO1mS+ZDEWStZfHUHjhDNL4GTQJVg427x0ECD3Ct6fJUtLmzYF6EcqBgz3CkMooddSwjPu9d5BLaYsY4M8sgO6J4FEKAwi4AAAAB5AZ6idEJ/AaPyfOV81AYa0+Z5NGz+vbWq1FJVWNTSt3EKoaQASlz7BN1WpYvFpSYjgI2LxZKIfW6oWYGS6mBKQPzFEY0LDyM+6j4Hp5G2OFnMlaUMieDNQpIAV3VgFpb/U5xETWnRBvNv5DZnI0BPYJp+uUMH/iAGzQAAAI8BnqRqQn8BpHgKZadYhlRjpPPu3T+Uy8JM4H0I7FloETiEgRE8L10iADZk+WybpD3jngkqHX0OmS47kH5y6gWk1zhplvzHK1haQuLYLSHIhjsCHq3rPkwzuEVpD0ONGBgzzBj+0+AQyhInEER6tuM/0q5kBLYtLGW6aa2MwZaDN+gKZdKTYBR9IcTf2QB6QQAAAW9BmqlJqEFsmUwIb//+p4QAAAMA/vsqDHRHElPstwdUvjAz3cTX0HYRN92Q1Mmo7LHeYlLdQm4B5iDV6DruAZ7wXpx0gsQmRNWvpjCS7NdrU8VthEQOFwnxNoo125Aw85PK/PWkL9Ff8ECavmKdscXfPUhcbPWo0lBnpWMESS31k1nKggHZ7X0NE9LQdNyjXFDLuF6w01pql3isAf7XFQfi7Ztt3P+XcSJvLQGybg/9Ofgxg+PA4QnQPa0gcq4fU1OBfVSHmmOD6j0kMPQtK/orOM3ep6TvHfiuwDC2eShIdMF3/uk2/5noo9WzfKbEi690WlNTuwGmP5fZGE4HtSgYaU/h8Ym8fzrScUJ78/elPokG2GZJPp8Ww2TBtAuq4X9nm3WRtrEZp0xgJP/2Pd5pnRXiyZxf+qP1eHnDSjgOtqCEEHBKjXZnu7OY0pA7fpxXNf/QtJkzoiywaJh7f19AvalViOMM7oHi+OvYfLY9AAAAwEGex0UVLCv/Aaew5o5wM/SmaSHpkJRZ7+gzNjTVEjoNsJoBztRMlIEBOu6rbKK/XgA6AjBMOl3J2ykVCfFB4UdT9WQjU/dZWlziETU/1QDNNnVQ1FhIVr16D2Z7FNyp+U6Yqe4SY+sozo7rYhhdtlK282kVGp7wnXq/OtUxWu3WaqJIkFiclpN3fFGqT69Df9gCmfkTqp7pbwRmmwMwvXrx+3RG0DnTzE5wEMRR8pBX6BPeAEUdFuHML7Sn6NAekQAAAI0BnuZ0Qn8Bo/J85XzUBhrT5nk0bP5WLrwbLs64hLUAK7YRkBoOk5RYMeK1MWMq3LO6lHPm13AtnDfPWw05+amksd+UGOIPS+nncnzAkywyBxYE/bqF+cAIChHZHNoi6Z9uDLIMNY6uvOMlAtztJrkWJttl3+frmEebxLEvPkocCVY0LFn6pBEkBEjwBgQAAACkAZ7oakJ/AaR4CmWnWIZUY6Tz7t0/lEYaZpLUuu2QfPXXedId9t/j1sb7uNdskv6gyHJWqYJ9nABWH3saxoTE/6t56N1qc+3sTtqePYMsrwML0xpx9t/HzOYsbnkN8u9vXFFW1KW40F7twrCJeWHpZvubZDps/a+SiWPOrvjoA4nNDLHgwgKzhkpAhvveA854TjNJvpueS0GgjnC5qTaG2KE4BLwAAAErQZrtSahBbJlMCG///qeEAAADAPlwnmi9zHZNjb5gBMx5m8EYDSxCYvKzQ25gIMJ4LqvW0XVEenu3bRCJrR97z7XD9+Z56/SSsMKtq9SHd0I/oZ5hb+UlI8kWbkmtvKRddQ218rI1DRj+Z5DopZTfHsSBBsJ0rEdVSWSDAYJyJUmW04+N+qSHWwg/rBlBlj+s/7zRbW4PpdMPnSx5Wl2c+9IJtOSPOQWwpU9vPAirht+ZaEi2lwreyZA4KbLbKdlooDW8oHXPVIo5U0iiFOX9YqpJ0NCO6SV2oETlEpnEujFkpe4EOwFnZJBovJdTG/LMz3dqpiRSWLzS4MwwzzXe/A3mOn/UnMorI7MgeTwNuwKvlzpBnSurJNAdfBxm6WC2XhMFqjW4qrgLd38AAAC4QZ8LRRUsK/8Bp7DmjnAz9KZpIemQlFnv6DM2NNUSOgWmzsKRB9ABxspxetpRALmA+4fWvV8Xbum62r7mMgbF6P58Q9Rvh/hoi/Mfyvyxpg4das+WqB42YKrHe35t6TPCt6XZWUCfLEl7R/ixZM6pFHpFKTe35UgbMzySzUyysTDdMHS1qfXrjnENbJfGFWz/3HaMoIvcFKis/E2oNkFV4N9yZHymAOPHHyd3/nZAjsSLinvoEIAM+AAAANIBnyp0Qn8Bo/J85XzUBhrT5nk0bP5UKTkNdlca7I/HHEABxY+BCS/a7nlXPCIC078OSr4Mei7vK4wrmzEM4KLrXXky6ma3f8Dmc1Vi7W9V0gfygc/GfU9FuZpsxBr0guiuZPRwzG+Mb75cHd1sPjeXZbUY5ULV/zILn/D4pv85aRXYHRp3TJe3vcm6O484hW9NVPO5ZlbHL1yG/fQiwjwDPJ927WT0ygVSRUyCiOB+6YGDa68Hjv80b1uirh8OqIK+vc7O2rajv0KOlwVEXQEzAq4AAACCAZ8sakJ/AaR4CmWnWIZUY6Tz7t0/lEXFUf9CBACuJIe/trehjQl1qGYbwSNVzvdQ2RxqL80++MeYvdZLZ8lwbnMTbh/+WS6EGO81jLXG+Y++QjNtRju3i4A9LdolkkBUiWD6l8clMox4FMoG0xivOUOhoEr565k9iQVl42m/oAA/wQAAASpBmzFJqEFsmUwIb//+p4QAAAMAbH2VLaGbpjUINFaKMi17CQBA2pgXE5G/s5O3Hbwn1XKnnJ2yowfiYOGaAT24k/HLVmWBkewvnpSnyJo2UKK34Dec6wxrbBjmPkLJ5SF708/WpPl2IvwxP0FuTRYulL2TPBkClF45BaHoyRZWsYjuIeEq7evrQC33vZOYcAhMVaUkkP1o+rqDOv6wFXJuAL8cFf5JPSYErVA2lqyX0F+vRDCnYogK9AfBWSdCMi4vf8WpdwPkwouQJUWkkzelbiTHotEvAGo5xWf/dkb9VhbfrwOUmcpCnPI1jaEHt/VDivPbQW7SGrxnMIXQBrz548HvfmA0KFT+AYOG5Ymp9bA56Fn3OC7yrOiBvJ6F9DvZ3vGu/L+eN0hZAAAAqEGfT0UVLCv/Aaew5o5wM/SmaSHpkJRZ7+gzNjTVEjoFptUpjmOYm9nUdzxBq2IQ5MAA+5Lrx1/lbmDs9Qc3e7eoe7+dbo805YRNvElOMwtcB+kd+R+rowTpsIKN5yMuFQEUNhTvgvIcnuhnyC8GDvQE3gfhitvNcLcx96ViOLXG981X0H+VGRQsWvD/11zqyCQn3eZlEumjVBVsCvTq2d/tPMcHOMAMGQAAAIIBn250Qn8Bo/J85XzUBhrT5nk0bP4VTPXBAnkAA6RnxLTLkpFTqzQBrNKzDmIBK9rOCzItzuuw0+2UstZBJxzzsbMm8nvGvKXm8dYr8ATkC1H+umWQ0zJFhWiujc0YvHGakScfjGq+NSnKpQKKw+6E23LLXOAxXg/hgejK9df6CAccAAAAgAGfcGpCfwGkeAplp1iGVGOk8+7dP4RdVft3UMZOwATjjMK/BUIvXVZY8UKGk9WXwazJELiypsGzHcGF5grmM21l6MaMenJv5oKhzH/mU26u6Mx45R6GriK5SfGboKEMNlC2u3B4X4j3rpGyAmCyK0fz8LVnEk+60CYipI7ksHdAAAABFUGbdUmoQWyZTAhv//6nhAAAAwBk9e/I5q4cAJmPp+TfP5pE7lzl5t04XU4Yo2RjzFWhvne/oTg23KQI/PaNKB0r+dvo1q7UMWp3/Y/6Cl1uPxZ2W9QXqxNGsWYkLDBhsLmqmx2/fsF5nMlRWu8HLbLOSUYLJRbleN458W8bLyQF3uY5KP0gIb+p8YjZ9GDLzO0orEwKpzW83wxc6U+bR+ot/mNvS8GENAr4HwEkXoWjtm+NV5IqQXNw2WMSm4xRfT9ISwVMnUyxb8yX1bwNqfAMdxMCp9xHQmIwNfIEYQKOqyaQ/gn4AbSCHF4xD3ejcP2OR06e/EOCa5XDLLJgH6b/wXwKQUWZC0bldkwlmUqsOrcwLn0AAADjQZ+TRRUsK/8Bp7DmjnAz9KZpIemQlFnv6DM2NNUSOgWl94Jv9EOAEdFVMVZIPLjIcmzf154InphKuUz867lMyRSGGCsd+1a/frQErC6IRUohScb/DaETzTAFq1EhVnN4s82p+uM1FNzQ+igJqc/5iZ7voHSAaAFhVmkBAmC1w89/PCKY8KTz7RM6UJgCcV5XNzIXpZtj5Wa7ImNY9Q8XIAPSGdu0kyr10M8swi6AMSUnD++Z5BlMpEJ1Ga3i2vPpuBVwnxaE8GnaQyTVGWM0ZM8JmWGtvq1c85/mx8h2bG1gEfAAAACuAZ+ydEJ/AaPyfOV81AYa0+Z5NGz+E1z4jByDY9Fn5gDjQEAFxe4tIlIvu8Al+agcuc6Ar3YVW9dglcwveMuCOF8d7PQ3hXPkw670PbKHwElgru8BBhQQS5yXCiFEB6eI4hxJLGrNdeoRmt1xfr6oNkAJCgWq6Tj34YxI4ACNmtj5Q9BduIPK78rZbO31r8nsqmyP6TuVYxNZm/79DxeTA4LtpLEOWYzGgmqEPcFlAAAAqgGftGpCfwGkeAplp1iGVGOk8+7dP4SA9gP9q2ABUg/cbuO4rkvOuhxb+kOSgL5/5K6foadz/L2WHd1TBPRyQk8GbgG9zf0AUj/8jbfjCQZFFUM/F5xtUlJVsK4IlGsAX2pxTnpX1io6t9ci1jbiwiPB0hFGrb24vvb5WHQs5LDTDT6vMhCx9inEKufuKV4VVshx/uZkW5sfQquiqDoYGRaniKAHAMcP3eGZAAABCEGbuUmoQWyZTAhv//6nhAAAAwBk/ZTgemvQZfcMAAi2nyJjmlKeJYf5TrOl1OFe5vBS2fssuE5b5SrFRhLxLIrnInlo52Yucsc8lbMdfGQ+IVQr0t2ZSOL1FCBT/Ju6sHJrrem3KuqtuJUGfIlCfvpkJw28sl5oz+ynOYT0mkoe/d2nuV9EnCR9B0mb+3yhQhCjlJrsT8qUNbNOAF/bJKCsY+PoiLGn6EZGnSgxx/du7jEbhttaD5geJbH/Dj26kZuWbU0KC+2sEAaV6VQkLEq0glsi8113qpL/37SVR/9NlfzVNW8/T/RvmXpSZaQ9yGX624epg3/6svgFfXMBBU80Y/xGnF83ugAAANtBn9dFFSwr/wGnsOaOcDP0pmkh6ZCUWe/oMzY01RI6BaaPcdACw+U4GZyn6NdOtTIuL2AfiI1wyn9AUB/d2tp0h6vFNmp+JeTUgc3mNMSMgGZZT+NVWNT8xkRTStAc1JwqiofUqqjMU8JnjOrWEo3pEwy+FEExVFogMHVCiXPQTwYClya1cmjc3jw3S+q58vtZziyyFiB84vFXpd/qvTAwfMtNQH3RFzWA3JoSrdWXwgYfC67gOZRBmpY9tdExoKMLZqJS+8d+T6xQSyWeOzHDsZDq1wfBm7Q8TTsAAADAAZ/2dEJ/AaPyfOV81AYa0+Z5NGz+FCFbrEQAsDXzaJs5cVqhlFbd3HlBBAUiYhowqeTt1sJoon/nyJZPagCUgkIJ3TugTfTC2LT4do/2Q3WraUymozVF9IVJf6IC1Tmf9YB/kqLXDuMmfTuFdi6hwpRURJPDIAM5KtKKqR80hSan6u5dhg6vd4rtAEuqg/eVCq9/3P+B861hXsKldfhrjfyf3ebntICuP2Pp9A1oxr1t3W+K/aL+WzY9QkGnsEHBAAAAwQGf+GpCfwGkeAplp1iGVGOk8+7dP4THtcAE0nOLDOPEyGoD6mcXIKNrKm14v7FKzosweK0BriOifKhJjJ3oxKS+Pda9H+8vw7iuy6vubq1NbeU3AkYXo/unE9bXu5HsHQIxVCPcFDcdsz/DaM2xsypduMZ+x8rx7pIyySmqAokUtn9Oxl9dbBVuRtfT3n7jsg+D7CiUmQR3NlHuRgFoOsKAa/pGNh5xd0sU3F9S2yJqAvo6RjF2fm10/TASyAikW0AAAAl8ZYiCAAQ//veBvzLLZD+qyXH5530srM885DxyXYmuuNAAAAMAAAMAAUeHteuN3YNbSdAAABrAA6QfwXkYMdAj4+RwjoHASAcBQ/R/htZogAHW0qO9irfw6X899DGZzLpOI14NNpoLMafN9Yf9bqcLNKpqfTfqFwFSKOgYVgKPj6VLUHRLgD2bKUF1Ck9IcBnmi+B8PTAKHgykR4ckBnvuinc1n2Ppk5aY98/qc1lDHP0k1mg8jQEqUPe3E1TKvT4Lz+ciJtfwdCNpaUaVPptK18z6/nnlAK7YQ+sl+tMfraXVadzcI5AO5Q+u7BbAN6QfdAvVfLqvQ3uyCfwahkI28IHHL7M04s7Av/Xq5lMsppSNVs/CTkqgUNLzwjuHd69pxeSJUuSv226likJOcgWKM7y3hHXherbL5fRWXAvVpEgBUSPKJMc59EJmucAjllRDQmubF+dT98FQeWd4yoKM1Ga7WdZnE/bhQWQ1q6WGQ5hyu0oDgcbAYnXqda8C9x6eLhxCde4U3WcBZgjTJgcmQ77zykh0rrDTXg1on4qXltGkjUMmgEHrx6gfnfxvxSg45sDZ1eTtN12igioG5211oKBb9KmOTT0OC7KovOqzyzCJwAQppvSh7dwjeMaXdA+3u6fAO9xeOVL1ERw74rD8EyRDNhnXItqc64V031HC8TJIko+qzUbxY0pICiODnOElDXhXrcCVr3wmE7m9jOrRKehDuQ3PIP2wq6+L8FXJQCXds6MUIxBhTxRgz50aHE34UiRqoCmgYEywJKeFqyR74nBCMOGGE91GJKEWS42NlCqlF6aiLkO5dRDu50CBh6Gt9HfjJNPd2GQxUnbA/VodSjDrtEhK+PIliOF2FtOxkgsQfX4X7yicHoUrV8DloL2GjVYD9uYyI9VMRpSSgqPomUg0nHT+etZFVdOWL8Nz5ZnSa1/pwD/wV4hBbu24fQjY0vZYrI0XxJuJjTSejf2LvarubUJTb/c98gyEZlkYczkSfMBc5gUZkFXOEYfPYmbShmYr+V6TgziXAWhIrhHyyCdBBF1qXQ5/e1o3DKXEFdkLGmh5hsT3+vNmf46aBv8l3Uai+VPb2Td3PhwSCBAFVsPq+5gEFin111236leJyLkbiQU6rsCe897Ej8cmtHfXPyybiRWF+efcwkTqU8oBDXF0qmh2zSYXoo8xIQz6KvgT6UpswokifSM938P5eC3AZVG1nlRXzCzTb92ak7oYRc4cakYMP3kJD9truSO6YAZAJ6ak+gU5163wmqiPYqOx7UGNHdiGZ6IizgFWbbA5dadwpxFVeXT8NOCAdl8Qw0sL/E3aMvIb/Dph6dzIJ41v0UeOFk6d1Sdf6iI3EWCUR49/JefflsynGi809UHLEeJA5cKZfjD78f/g0x3zbL7odASuv0MUwLrMyooObkeZl+U9lb3js8Q2eb4sE1C4KepyyaxUZp/Aw+85h1y9IgJuW41q20+5wO/RqPBulvIQX7Gpyt2yTZ3eDqp+Ac0gFBBPQkFoSjxXh/tdH/HQq2hmvWAcgSaMP8jACuvPoHZmnus/8LUbhwfqpsPAzzJNXqqDPdLk4uycX557CkyKWBU+9UPBTiubMAlLp9erhQOdpjUzfF6MVsd/BZsaGG4QwVkhkcBRcRAP5+PXb/Q/h/1yEwG2E2FJgAtXDQ6c00GwWKbibDSaL1OkxXZQvZO76Z1xXxBTxibs6zo/CHXWAyDFPntYHJocQEk1Ys/i2sOL8N86WWG3Ay0BfWh79BoRasbgMYhHKR13wXAdcRLq984ekJdbpSTbFC/G0poUK6DnTb+QbFBweYdo/h48fxewK0fWd95zHi3k11GZ+VZ3wpZnYkQ8cYNfpO+12xWavNvtyy2A3WPbj37f9jyA442FRmzIaSJpQIlR9BUwIPW1O69txCpgQXNhq7DqtrTKQngXvjKjK02o2PG/ypixoaQTANFIxyT4N9/PaN2a88aBdVde3lmMIqFeCGTzngOeL2yRvOV+8CHI4YGTnUuUxLDXJ2/p0s5L/ttG1qG3tHpT1WYBnFkxqh3NfFveO8Yib5HXNEvfXfTplPSz3M9MiATkzipyWVR/MLFOxdLW8t1qpOAnw9Vsn/BgPplelaS2Hmo200VNl5LBkuGnJo984P3t02VVD591ewxGq5vbRw6qtqorvQAQfc4qTz+uuna11ar/UDQI7heLVCPYtTGEUBCCKharXUjwEMvkETaEAnrUiSTlf6NPIB9l/ZAc7gnkRbklT4qBzitWbtzqwF5aMl8Ls8x/7J0/lIZmyG7HWaXR6ywAAS6jY3CKgL1wlMxedBHdDcMrk0c9qAHUrkjl+hV8OeYAFSDfnSiQQ9bTqigi8tehQbyOJK/bCOxWkuzyHzRGewDfCVAaU0Znbfy+yh6JpNvd1C3CflTQtwXD43r39OIHvJdUbx+/LYXgvA4iufCVGfMJuKzAy4pkPQo8FrdWip9y18TgoOg9o6Pxo3ehIukRsLWSS3Rvf6h9lhcgUPQqLEOIA4WTMKmw8PgB9Bs98AdY/n2Z7QslPcs+WEL88DqQ09eEDRSinOffIy7RFwAlJov7wElILs0OJHhuRdt5Ge6GkbwyRcQT5Hs7X8Ho6y1ZbpPs7Nfq90APDNix1dKmeMh6I5KLy2Y3Q1C986+ORCsAp6BGxMozpxmlDJOBC0FLZiRvQ9b1VmF+qf8+TC/efzksFvI2mXbVyTh/5vhYuPJSOzwAtnquFKbf/vb/a4seLfMG3ak1pyzzAuyg77GHw6sj7At4d8jPcHzYHt8jBEugRvtnJmQOm5wvIGT/I7oTU2TDMHWfpn1AxWd45MiX6SDRuA9fIfXvXaEi/swbwQl3zrCmE9D3XuSzQGjB2QPdsvx6bYqJO4PV6/+iVJ+KRKz9tAm7sInpDShFwB/3myU4Asavco+o11nYQFdRKe1v+RpKZs/NbaIY2Fm6dgjspkoEUf9wbiMP8qhgTMBDIQR9oQGQWruX/aML+yP+FonFrT43ZV4bQSyrMAylwrR/x3NkqRf9+01ES/VnHaPzvbzlEMQeA2RqoVK/u4ngbW4Kh/WlTiGDEqW1Z24SvlbHu+uQFyi0Fa8c/gs8Vg3eJI70mleN0paQpYzfjIQM4498nVCIkcIC3LVRMfn+kcVSh6Da0uT1PwztMKFPKvyolslOQQu4j3D2QxwGgRwDFh+Bb//8QfW+oJwJgAK/1zQZAAADAAADAAADAACAgQAAAU9BmiRsQ3/+p4QAAAMAX2XKFP3qI7Gv2s/miL/UAN0PfMNbMRiBBaqIvk8gxmkSdM1LQexohsnlVo9bGWm67akT+U9Zq3CVI87o0iWngPpihDtOVBBzrpDvPfqR76pxoeML2M1xRb1oY/q/cS+6TZjBC1fTpSXjLvKlzjqqvZTQyWwPJySQ9TshyAQHNIE42X2081lBCmuKkg5uNtR0Sdu13oMxC1mKpyQrggzwtN1aTRIJsqLk4M7qiVDqFp80nC5UKeR5C/X5Fca9M3zB2tYY3GrK/QhNLnBkXtWPsFbbOt7ejjwi4TtQJ0utCWmYegHt5JH6JI6WQ4kHf0gA3Dtoj7Qnq/2CPqVWn2v1a08QglCMCqUDG/O8htXdwhP1alIDQZSJuNssJRRaAO2MSIhoXjjrv1hPE2Oe5U0XigYWtSIOp0eXD+WynJivujfs8AAAALpBnkJ4hP8AAAMAY107JlStAJ8oALcKuMESoXGkIbNIFnGQLBJUDtKKpM1yaM5/jbn/uHiwMck5TRQpqErYWrZug0wIAChpU0rnAj7HoxU6uV9DgwkjJUZi/dJNzI+LDo7ZmdZA+FQ+nd2UfvJMB5id9gV7pX+hOQvbUQCOhEm1/appNA2uS1TdGk3pMVt9g5/YSHwSx0yZ05IRLNmYynA7CVZ0cec4caWDMXAggS9bXfkgy2CBAro1AZ8AAACnAZ5hdEJ/AAADAGSue2w6HIZfJ5y/z42aaEv+zYAdIzzhCibtvDmFlCmb1jfoxJfQK9uQ/pWFQC/yV+m07SzQUaqnLNc5c5vk5p9OwKuLF9AqAMmWw0SK2s50gZ+0eFOc7OBRo2ivnT7Fu6nzFkaZc1uFWOyLJKYEeQoC22cbdN4lSEmuD9xS6Gh3qvyGofiw8bQE7EZOwVMkkG3FRss8BGtkRZG3NSEAAAC0AZ5jakJ/AAADAGSi2653yfTAA4WXBIiZAARkdMDgfA1h8y48HNoGFdqLDhST1h00lKw02ajC7dr8Zy/txwFK3aGNHDH0HypnWQxzuPtnvvMVOp5BQQOWcRHCZRo802dzw2E+HpSCJAy29iaylYvLN+HX5k1s4xr+2iEmzuUzxFe7PjsiCxk9eEmfkjGKCKpRdbT3g6EUHpub5pjKMuC/QG0THRlmrDt0ihiDenHRpLcTsuHgAAAAq0GaaEmoQWiZTAhv//6nhAAAAwBf+E8xpIX4AKF22wtEs/YY0+3V5QJyF4TvE8vd+713rgoW9VfJno1475DhkslzrfeK3k8P4WhImfW8UD7ChBcLwSQvHKwaNkRbBTpMw//3fREDRb/g1+F17tempnJKUq5zrExRR2JoySurZ3mMpFlnW2n0dS+kqHqeZO5Cw6roLQSZGKPYUPIAT/im/0Nf+oddngFj9qW4gAAAAIRBnoZFESwr/wAAAwBNdAdrgzfbz9LznrH81dKATSc2v4eXqPEUMTuo27zLx+AJdjkg1legPK33neLZVobIBsiQpN2O1DnawUHwcDXxL7bIX8yhoxixSQJESWrY6MYb1CmpImXrqMGimIhVFsy9IDPYJcmWvjttk5dbew/JZzDU9wvTpaEAAAChAZ6ldEJ/AAADAGclwGxLVBjZ4/icA1fK/Vjog/kLraN+okKQBj4XdYEEd3mzpw1f95osfWy+wM76AnuWYG2B4ScurZ9Alt4WsKjkPW5Vc5dXSwcHLZs3c46KeccgwBpGeQs9fq3pCQZ26pacbUWD+w3PKyMh+PtJQSrV+V/Lo3a+LDcdFPFHiLtCwp8wjvbG+kGzDJQIf0CAz3MIXRUAqPgAAAByAZ6nakJ/AAADAGcE0u2GBU6TUFtEB25jQqYAEQcRDAM6asavp+xH+qDCmWfxIDvoOIOk/rcUXMCuZm0OeuzrapQ9WPjOf42KP7cOdNugo6wUoI40NczSlw0KxdKTxZZuQTPtJ6CoeUex5rOYVLvj3TPhAAABGUGarEmoQWyZTAhv//6nhAAAAwBdeZdo5vbtcimewSuwKPgADgm5ezrfSa8+JrgyakaHi7l+/9GgmXO/zeFvmmVX2x62z4zpgmigBnUycPcgmTLXvjvjnDB+9tMRfQNbhvF3Ofg3qtvKw1uNizYyb6kCwN3k4Wi3pfBqqDd47Aa5UjCCvhOmUNA5Fxa8hE2gJF+3F06yvDLZJGaz8Y9zKwp4UeVVVNCJY/QkcvPt9iNfXkG1pIvxr0LQbXqltIUvd3lEwNt35K9I3iHTYOGmUT6TU8/N5LBaOXQ/SSQCBxRzHDeRgU4dp9vJzaH4U1diPTDLbfYPTBTqGem4ZR3LjzdQJ+QS57s3cW5UWjOg/W7yyzzFWb8xxPegAAAAckGeykUVLCv/AAADAEyofV5CpKRudG2GzUzxgwPn6hmDNtHF/hio+AEPzC3FXoOEYmxkXw5MbDRU7FWJwnsrdC90cjCn8hOh2n2K5B6MSmstN8Ovh/z2kbIAG7/qMFXJCtHduRu/eFpnWWK+sO+ft9Il8wAAAIYBnul0Qn8AAAMAYfyiMeFS8ADpHTNihVkrsNLSRAap8vJzRCrMz8N2H+v3djkYsYdCVKEmJixPJ1S2dBJ4d58WMTOGu6BvaBThjPl4vIXD4LwPGDfj+LnYfcwDP9AesdUhIuqEzW8WnE9AYJSkhN21Jwd7EOohkOhNFboMxrJtE0U3HV6TgQAAAFsBnutqQn8AAAMAZJ41UlGY1+3lQpPhgHQ6qgA8VfHQC87zUxfkYTqlRp2kjj++qbCB4VTFxsc2eH6mM+KPt1wpmd3SsBQdT3c7vqkRHTgZIJAG14i1eAfYAzVJAAABTEGa8EmoQWyZTAhv//6nhAAAAwAkpdUQArmdk6dk0pQWl6aauKBmeCqy6PmNXyU5QKahoN/yCsJJfQhbDRgMBcDL7EjzubCkRbUVWPf9mlU48OasqLAcIg58HDoZC2Zg058tbVvOkI+V//na5haoQWmuAd80F6HN9ke0pV8m8hpNYYhZw1CJKbzaJUN/Acvjzo55nv3zdomyQqFyQYiESlNPPyNY5c5r4LAiqLGn76W/YJeagOJk9GaPS1/fHbVg3NndhOe3CHXKy05rQspynkiw09ojC0OUIuBqoBf/Du9vz4S2Txlr/dT0MjLFkNwYEpkEXP2bvBEU++wmBqbjKpz3vUGD369ABJQO10Ii2YP9md1r/EUceJvrpCEac1ijuEuX6nW9jfgU7ckWeyMKHEqc/1g1eEP9P7j+4L7A4D/bDdQr6PEgexno86LBAAAAmUGfDkUVLCv/AAADAE2DM08SkEofob9F9CqugBGDI1rvs7scLivx8vtks5IVuTLmE176ihtLAJmONq8inNpAaVC/vv2hr2+CdGTN6GtCgCZ8gZT2/YLGs9+TNtf2hz0YmAQKe7xRqzQdwu7VkgiE3HWa/qp93GsuhEivS/CyMBXp78AW5TP3BKLL5vB+1MVhsl6/+ydLAkqXgAAAAHcBny10Qn8AAAMAZHzaJXQfQ+ErwTm2wPDTX/rbpACT2qzs5gQ/NbChkIgp937sjFbadzimYGgBzGO9jE8GLLgOvJnn7Zho+tyJNMnvLvUUqisAZe8BHD31iWpogSECnNSdwMn4lp4Wv2H+mdvdZTdjEIMD95qkgAAAAIIBny9qQn8AAAMAZJ4zqk+fJM1rhGetc/+/aagBxZcvtRVxJjuUAphsnpNbA/ivDoVxthrHLAhHn2exJNgFmhIXiDSVWYxGLcwweKSjzy14Ugxf+UG/TPNntQF19Ft3pPm09NtBAmii9T7f/dalchYix5zmoMkesRfDDjC0aHr1KBOLAAAA7kGbNEmoQWyZTAhv//6nhAAAAwAo23JAAuqoeTEmV4nyeB4/hBezrLeBkhkCpTyvCNqSnERs+Cptcxz5J/vAJPeacV9SWj14LigA/az+3ql1TzTw9mpgxbLUIQEsGsq0YpSp1NwtzOfBT0YU/j1Qv4cndvR1pNhm/8FDhXgC+hCVU+rH8oeYxWNGG2X6MIV7h177vQRtaBhBQvKkwhZTsMYk54mo0uEZ797WnkI5E6Qt2YZrSF742Es3bTbmVZywkLaT4/3zx3vbTgMLNBQBxLEanqI0RILZrcXMmMEEHS5ajKlh53YePVrtSnftl9MAAACMQZ9SRRUsK/8AAAMATYMmaKJYHgjoAODp8jTHCeIsfUrOF7BL+onW11US1/pU8vr+qs/wNhNF47NXpsURaPiNETrPiOISJ8KuSslrKJ+O1myQ0NL2/3OdXlafzhRsmBXnu8ysZXWCsVGVaMyD0QucJX+7C+GRdKDq7Y6IDdr2NwTQ7csrpP5nGfrTBWwAAAB6AZ9xdEJ/AAADAGR85M0Rp+ABsXr1Qi7BRfu5jHt8VT32DsD7PebkTuHo3V4INj1PoDrN/6g1CKEszL65JpSTvwgZtSrevzedvoBLQcRbraeqkKQ6M3c5orf2koA+qWiilrEgXREioGJp4EoZD+CSuQnXBYlg1wAjQVsAAACMAZ9zakJ/AAADAGSd8o25BZYQA5XubFCsXgmFpI1s4bujFgyAKamsMmk11ylFwoPeA1TXTaL2r/TmCer/T0vWg9dX3MLGdofbnrcWqiamiYEeIrEUZer+z9EOrrmPaOoe9Jlmh2uqiF3uqZ/pjfI+J5unlsSLX+wUX96+wPCtCRSFKktF/7cHr4YgG9EAAADtQZt4SahBbJlMCG///qeEAAADACke8JbwmV5VGEgqPk1S3udqXmof2njxcKiOPyTPPmJFcH/gsH5hrFNWAL0Y/MXKc+zZZ44p5RYmLeTW2rW4II4Kbu5G0DqzQIOiMwnsdv6h5Cd3uvLAZPQL8Fk+LVwxWEYIsYXkvuEPVWi6xZg9WaKkzbu1PM/1uhNq08ULwKH84QBkiVnaJMho4XB1U+P2/L9/1Xonah9pOLj9M7G2UpP+DhJNA2yeuazAoNNOqYoaubxNAKXVVZumRblnKh/JnLnXAzaLF5O7264y7CM7YmCl4tuKkfkOyRRRAAAAekGflkUVLCv/AAADAE2DM82ZP80oOqytO8cA7ysHtnx4ksALd7N2umh/ii6YVVq7hWumYbS9rzozUIVB8oGGZec5paT647ewktUJPuwYJCIGGlxb9w/yWtBkSJfLyQaJ/q9kbp4UzI9oKtuabJVeGGMQ0zNxURk7JOygAAAAXAGftXRCfwAAAwBkfOanx4BNfIdquDk4yvkhQa+4GP/wKxAABxYqxlD4uyEnIufOJehd0b5k4b5ScyE19u2TGGcZ7Q47MdIvGJC7yRocPrQsYEvMtO6YOghxaWqCAAAATQGft2pCfwAAAwBknjMbTdb0Je2yZfRfoc9Yv8ko0ojaM7ACRLiwWsRVkYtYBe7jrHmo/MzpwMXlXkh7CZOwlde6o7Jx9tHSLv/UFy+ZAAAAw0Gbu0moQWyZTAhv//6nhAAAAwAj3IPoB9xm1Mpw8pUCznbDlnLzwNtzADhlBqSC09hqKxxJRr0Tgs7dEAGhwBaon0DUrU2C13i8vyx4os53Aiy1FdQ+m+XxEUJzg8FX71xF3BIURb4h7jlD8ZaqznOhBC9c9kOVEhvEblzotPcvqjOs7B8bxTR0w+mx5mXEmw517jN5mjo+Px5QUbd9My99RpEv/GVaPpcAMY3hULH23MesAesAqPQFRl8YyfMpabDHwAAAAHtBn9lFFSwr/wAAAwBNgzFlYT2GBuhdDi4wAS1Qvw+cWpzM5/mX5VoffuaIO+ww+SYCYbWyC4lyQBdLsZWYQrc67Wl2lMYbCbwbl1hvdRqg7jL4CQtybHABgDLkR/noWfReF55YB8v2YT3MXPhJaCDyVme9b975ZrIuxtAAAABhAZ/6akJ/AAADAGSeMxWvIWfPN0pGupm8WrTBwYZ/FZjvp6KtBXTl4AJzF2WvcTce+hJR2z0rApmAn78wlCmks4B1sL+GEXfA08jDFdqvoUjdAL0MslEsziiusm6IvwKdxQAAALdBm/9JqEFsmUwIb//+p4QAAAMAJKDbSAQjq4Hza/WAVqLoS257JVE9tXYb48Cjni5rsu23pqudCXwe1VGv712TyvSjvjZC1t90z4X8sPwvkrKj/0Nyk34cWFzLt2VhHBLyUfx4ZVvc5kfhIGQjHdKKKIxX5ChIeSLpxiXRv0EsxFj+rd/H3ocQ+NwRLI3wIrnbpgKVJkwRodx+WSFgsm4mydH7IxOwB6BeEBxrveZDkHRbqulxZVMAAABkQZ4dRRUsK/8AAAMATYMxZWE7iNomB9bil2dULXRUI+/9F5W2zSY317f68AC1RYhHBrV5kweNGQ+zbyvdlI3+ZrlbIE/0bHHKwbgVH1UOXcJm+DJSuoDL/H84+73ET38Lf++RYQAAADkBnjx0Qn8AAAMAZHzjIx16seUtzhQ9BGo0bF3UxnoEk4cjIWNyvwAOzYrjg7M4j+SLbRm0tN/Llx0AAAA+AZ4+akJ/AAADAGSeMvltiRsEiRcxbLu/lFx1acIAJntuUVDeLGIIS48toSmx7Pcl/+1Zzt+OuE9P65UOKkgAAAC1QZojSahBbJlMCG///qeEAAADACKkaadNAAsODpkS7LOq4bwwsvpT3qokdjaBwpYdUZGa2ytPcQfiAM0+1N4QTMQQDqF65Fn7RX9iZ9hT2UUhXNm8UNM/L+uoLiYEfe/XL7bqMGXPjQPpXPjBu7QCLFMxeJV5U85j2JEzn4rdWW0ve5g98+lFT83HRuIyQUC/cmau6Gv+cqdituLccagUnB3tTGSDVLnaeiN+Djv7O+XtuRLEYQAAAFtBnkFFFSwr/wAAAwBNgzMwuPO/AG/1PegB0BrM6AeZrN56qqsv84ZuJwj0wx7uDfN4A/nIxnf63UEcI9FJXB4+26BTLELcAqD4wIpObjBslAP2TzvtGcjsTWYsAAAATQGeYHRCfwAAAwBkfOMg2MmMUjvStaScAP0pyCP4PeG5NwgAnWb8TtFdYUHF4mRfj4qUDbpgXKnP7QTvpD/pjiQV8KNEUigj0CT1SJ4PAAAASgGeYmpCfwAAAwBknjMjG1cOBEgxv4xUnUHprkictAB8FsAImw4vq6/zLznNjFLTRVjYEuWvst306jKfvVDEHCXFEBa7YUKQcdVNAAAAjUGaZ0moQWyZTAhv//6nhAAAAwAi390iOMYJ6rAzhZlTPcfq0K0sphlESA6ow1MWhvPhfvnBE8JFb8TRvPymVRocPWW5D0QgUNKThDjNiBK/hbGjR2ygP0SSqrmI1tFLhsYf5l8Xm1oA3UU3dNSKCmZR5EJt0w+1zwOek3hHIYtqz+Zn4c7InPXkY+3KCAAAAFNBnoVFFSwr/wAAAwBNgzMwUAiAcL7vwvJ5HqN5F21QjK7GIn+TzPyfv8+hjfCj6P4YgfLCkjI6lMJlJzyvvC8DIZz6N4myyqw9tjpyQw+wqNZiwAAAAGIBnqR0Qn8AAAMAZHzjHJs1zguHNMADdeYWCEzLmVvx6S7gZftXVlsW+egnL+4AGlE7EIdeUEyasG9LYU8VkD5WOR0fIgZMQRJO1Bs1KQaCulM+pj6saPyGqealDDEMN83nBwAAAEsBnqZqQn8AAAMAZJ4zH7iHDjMasVK79htqg2v+pACXtEOuQOJJrNm6XKkDrB8PAf5BLnGbvi9j9e/gYHYDQab+CIb+ufkfl8A0m2oAAACmQZqrSahBbJlMCG///qeEAAADACLdN7UQUNkEyUJoqKmRx+F2LVq6+lG6y47vu4KxD3w8jyIoaPO8nEC2c/Oij0KBO5lai2gv1NLs8mWh20+dJzCtpgMst71qLt0cSkcpLdtglQI/gJvKSHy9wUcV4AN2R2S3y3wnouRcMWyGycQVOScYSvo1cqCWAAMEP965P2u6fzciHsU3qqNw3wcN1cvwfE3KCQAAAERBnslFFSwr/wAAAwBNgzMwoDOZaa9XuEl74fTRR8nKKr6JI8s2XICnjnpiT2N1NzXgAqTusV5VOEDA6Ar6uTyOBPNRiwAAAF0Bnuh0Qn8AAAMAZHzi1kUAC+8jHTXYInjf/+9OlgywfpVBhGbYPDtYB79BII35to310gdcNhi7RMBYBlnhXjW0SKdyzD4ieC+SGK6i0uDIDndhtG3h+szT3pA5fSEAAABNAZ7qakJ/AAADAGSeMyHQnO9XZumkh20EG1B8VQrADgmRwAceJzJDLVgDHKxl7JP1exapcICrcy0yILa6agCb3I2wyyZMldP0OTMFDg0AAAC3QZrvSahBbJlMCG///qeEAAADAA0xO7JTP48SAIfmDSl52d5s7l2HFlk2Xz847hSttzhZvMYyP17ovx1Z7fMd3ptzNhYzQT+TazdSQofZFnqqTiQLFNjyTvhgUyXzq+LZf6mpDyfaEFRo/cQus0RifXe6pbdxSr7F7GkU+idyIcVlcy/Iy/0v1dSSMa/i10hP8Qqdh3QcJEDb7Bk6ff6iJnRmFn0kBd0B8uVjNa8vrE/v9yZup0RtAAAAX0GfDUUVLCv/AAADAE2DMzDt+6XvUr31NDQwnE2JUqUteKRbX7CDLCqtjvwsWABba74teHbHFrB9ej3EFUyGGM2L5Dr08mqLRY7ksUxLIaHWdPPN4qxHkT0yjXdmpfZBAAAAOQGfLHRCfwAAAwBkfOMfYvLlEZmDOeY6Nu7BOvytdspTM1nAAvSEdBBpwglXLLjR5xe6KeTW2rGZKgAAAEEBny5qQn8AAAMAZJ4zIc8FHbFx0V7jAoBkqvegR/NfFRAA7Iqung6nyK9tyFpSo4nAJdaX5HB8zKXSP7p3gVm6YAAAAWtBmzNJqEFsmUwIb//+p4QAAAMAHk9ldQqFYAcGW7nZ1vH/K3nH1y1neK2OSP15BZidvNl05rITulqRoit8PDuRrAFRboAJU++mW4q8RrW3zD5Y4jARlfxwxGjrOvIzNhdZTiHuwg57ama2lM0nQTqAsXXQyRPoMMG7VshFGDOILkDT9x0NrbUeCEPDr86BOKSEjNyjRkz/nZsAymP3Zm6Z3zhjbfFN4oxQ/yFhxPIPP7LWkEU5fPM43h90RbyzWea4ezx73JNCSBivZ1aux2HQht7ddrkBWTlEv3EiCLGQtUcFZIPtgx1LNj0F1d1qLC7F+EjClcwfJg8xJu3VRufSUVKoLFq+qHhiuXac3fgixdCg7txL3NSlC93wNSdZhbN9BOSecq+1D/cNGj4NYv9qj4pM/wPUm7/aydSQS2vJXP/DKxZTfw/VAiKArJHS/aKASp4S1OjwpgXdr5DHkeZf0dwdtm15KYxS+Q8AAABnQZ9RRRUsK/8AAAMATYMzMO278MfEa/wftZwWzxiaHAB6TLrBbBgrC058ROvy1j1xVHt+qUS9UhUeWPQ1gsfKqGrrpcmP2W0wluQZhXJNN4FCKp1RnapuLc16SRt1n13e9M4h+OfHLAAAADgBn3B0Qn8AAAMAZHzjH2SdY6uI9oAJx0xOOfAudYHg65Cf0BQ2ZB5YBf0n0zZ6E13xKe/V/GhNgAAAAEgBn3JqQn8AAAMAZJ4zIcnsgeViQxOKSwAzIe1iTqOvALNGf3NBcUJYMkOGke/svOHKUTR4gfwTB5qnb7gyTjdNLB6GNrjJ+VEAAAFDQZt1SahBbJlMFEw3//6nhAAAAwAksUah76IQAFqZ+udoDT5AyecM3q+t7N4RLzm20hxgzC/xpqmWVACRgMXpGHW3EL/s9UT3pAPft44eLJcCzsLdceyOGbG7+0yUkwoNkmZShH5t727pE/1Tt1APF5xHUQjVBKgz1VO5HISds8Eq6hZESkuLvaM0ItLwfCYXllL62V0SVefGdCdzpgVg0bID8pWQQVD5CiVVlrACH/DvKTWGIudjwPA1L75HrHLw4oiiPy+mB9RA33OK5W+sDP0ofE0ArDvh2GCkZcHcFmd6NInF7LaTtMSe1yvS9W/dVF0iekOkOGzXzSglJkdPpV987oaxJYu1pHEuO7eUfiYIfrn1GGuzEG9PpUHByBIWgy6r2Jcfn7UmfCjbV0ALazwM4Y5SyuLFeTunty97VJWax8EAAACBAZ+UakJ/AAADAGSveOH0Fpn79BHgCrKEVA//9DuTO91hGHNV2ObN/8lrlhBiCoDVSbqABv8C9VUG9msPdVjeMtS/PhB7x3fACWXYH6+MgA1sdXibkq+kaUKpylRM2vJqVVq/SQGMC7szt6SOyYSePjl4HfkzuZWe1bNn5zKSQrIfAAABCkGbmUnhClJlMCG//qeEAAADACSqD2xbxqsb910NZriEAEtXHv/IfYQMqMlHEdZuH+viH5NYdx2cU/2OeRMa3TkQ+P0PaGVuinI/1aKLgMg4ECiAGbXC1nfVM4FeumJAReYseGK9R0myxlSq88eUodz3iU+HSZIJXER9r/30mkDqX+vTH5BWaXAa+w/eCUzMWNwPvbdwjTqUAODwurKTXIe0/M0cpEOrVya1iO7cMxNzitqWx0xcmC9f3nX6Cd9txJsMwk7JDdosrOqqa4aO0qjSpJWkeOSeisVnR3/Fmbm7Kje+Zr2b7DYNkAhwY64fX2Qf09LmntPQhnAKMByErRI6v+L+1/cq4DBwAAAAgEGft0U0TCv/AAADAE19Y0bqwvfte8AVvzcBXiBb2rD/WfB685T+YhmjSjrsJJrdkUYw717++oZNwMuVpommxaJztQxU4Nm7C6UGLn7smyDBiZwLbyZnkUBqN2jfwLDHzgP5sMCUm3VDRmI/XGtUa5PVOUU8p6V3/srz6jm79MEvAAAAowGf1nRCfwAAAwBkfOL3ZTU6uBgCt+RDxzAC1E036rrV8pSfoHniCzZwWniutr/rqyZ1Ln6wRYVg3kbaHtenmrCFOf0ZAdSJAEtzrnsOo/S9NtP4dmCkPhAIpKOZSlws+Z7R8WmI0zPvfbe1V/R4w1yBZ7jGoxXTK6jxrjZfNvvvY3Vsrw2PYyvfbHMB/t9E3FYWM5HXuJ6f2/ClT6U3a80Ae0EAAABjAZ/YakJ/AAADAGSeMyHJ7PMdpWJOYAKiDm0TZy4rVDKK3kr6coQNZI7CTpSXEqN5/ZJpIS8xQ0ao4uBxF1Ss5tNPBLfhOYBB53/m7GwoKVoAaQVYaekzQ/YawogfDQj9NeHHAAAA/EGb3UmoQWiZTAhv//6nhAAAAwAltMGSABzPrqvVqCMkYqnUBxfzTrH41Sa0nrCqo4AF1k/atY+zXLdGrWhfqAYNwthqyhpMMs6jD0kNWckx8h5xG8tI555gEPiZSRLspyCvUTs6yq3xhk5b3IN7zmhMdpgGLEMNvveel+tGcy26xmQgVx9mayfgdRlH/A+f4cYj1YP+veTkpjfC0dLa2d+xOyqutubecIuPBLBN4xaflvrMe7ZelMnu0NNokf783rJRz3vDqByk2a4Wxf8PMVI3eJIta+sd6mJDOsYKVG8yCqA54s2dumNyvrBPJ9Lzc9KIPEzDc/oZs6E/wAAAADdBn/tFESwr/wAAAwBNgzG3F0r73aenf6TBl+Ir786sNnCpwBHaRu7v+XYg/MxcNY1OjGpxCA9pAAAARQGeGnRCfwAAAwBkfOMfW0MrcDAHL+lKWFtPlPujuz8AglB8vd38D3BAtrldirx2Beic6Pa8dj2Iayga/xvTn/8Z4gg64AAAACcBnhxqQn8AAAMAZJ4zokwquNvOx7Vc49sVZCNuWWYtGfkkFW01QykAAACsQZoBSahBbJlMCG///qeEAAADAA064IsCQB9MJVUHbFuy6eFxQ5cEH+2ZjVEPxvIFXbdwV4IkTS+/Xgy0BELpM0LekF6m9jnYjSeNV1ayUXsuiiXLKWvVcFaN+OiworlIerSFHFomCiyrraqD8YMjq7D1rdzK/RJeUk73yTkNFWLVeEQL2UGamgOrrP+aQT7s50NzDnwk2y6o0VMEI3MgHP/dEeHu6wHEonI+sQAAACxBnj9FFSwr/wAAAwBNgzGgoseZQMRXN9cn3CvWW7yWkuqaffr0jZPoBOUyoAAAACEBnl50Qn8AAAMAZHzZwLNBRQmhdwgwoIym/2UckLRbNoEAAAAZAZ5AakJ/AAADAGSeK0XiXM+IST6Nlkap/gAAAFpBmkVJqEFsmUwIb//+p4QAAAMADON10zxmNoASzQmCUYZrwU10tQgerUOebl95wf8UKHC1gtbo2/FoZxTYPuW63pV0RKElim4n3Wl3qmTO2vClprFIxSA/KCEAAAAiQZ5jRRUsK/8AAAMATYMxoKLHmYv9jb4NmFYBNxXlRCAVbQAAABsBnoJ0Qn8AAAMAZHzZwLNA+mP5ayq9hhGMPTcAAAAYAZ6EakJ/AAADAGSeK0XiXM+IOhNEWG2fAAAAlkGaiUmoQWyZTAhv//6nhAAAAwANMORhwCQ1UlmhDs8rF82gLjWarlArDcu79enYv9X/gspTy5NBHDq+R7Sa9GndQ6wA95/StQIwZddU1pSEBFiAx1tI05XCxKujQPGdg6xIqTt662+d7qOQ8SrOL/ZFXkKMaPb7zqnkJ4xmZ1EzgmYEnJmYB0898BeM+Uh6IfB/zbwY+QAAACdBnqdFFSwr/wAAAwBNgzGgoseZ49H8bFn8kfVErTdojZJzpGpzUekAAAAaAZ7GdEJ/AAADAGR82cCzQUUJi1mvKzZAJOEAAAApAZ7IakJ/AAADAGSeK0XiXPCHwyHhGT7lupwC9umgA2oDxpU0R1eQFJAAAACfQZrNSahBbJlMCG///qeEAAADAA0ryIPgD9GlFoISjMW81dl16V8L8ry6u6gO/UsKNNM+iX0HMnjj17CK4aRCeSExR11CWyo7dd516JPYoizhTc2bag50oAY+VY09ILd57umduR8uFxAUhvYK9YvV9JASoEQuGphoqzch1dnP6sznxuJUWPNSnVfAtfmG77gH9Q+qkemiz4CvNgNJi/HHAAAAJUGe60UVLCv/AAADAE2DMaCix5eUSe2SIuU0Dj1Ud+YENrUbdgUAAAAkAZ8KdEJ/AAADAGR82cCzP36GGcQAJvy4oucM0j5e7dGxQoVtAAAAHAGfDGpCfwAAAwBknitF4lzSlsApiTg4c3/yIJUAAAB+QZsRSahBbJlMCG///qeEAAADAA0prv+Ol0AFBD1aw8E+kyutfAcNICZWXzgjjTNi+1CcOvuAUHfE0XZTAV31JXIPlEUQD/fgb9smoEcEdo8UQRpnmGAMT2zFo/PNFT4X32gzIoutrpnk/zDbbJfZWSO0UKh0tmHSegcu18fAAAAAKUGfL0UVLCv/AAADAE2DMaCix5dcTyAIBlv/6RuFXcL2A+r3oPyjOwJwAAAAHgGfTnRCfwAAAwBkfNnAs0CBkwWktS1ennfufu9n+QAAAB4Bn1BqQn8AAAMAZJ4rReJcGxUow8bfeten/xmJZswAAACTQZtVSahBbJlMCG///qeEAAADAA0sXJACUdD6kQtqjizrrtNUwkoDi7wyAUNT0kJPTTmhBhp7PLoPeeeRnkpbf1+bthA/WeNTCXXeQHBk32+tKledQ3RpdCJDmievLbsD/W+JYIdPbl7BXoXlqrM5SNyskXOhU3W31C08vwBbqlBisRwXgCHGSCJnypPvh0MFt+XVAAAAJEGfc0UVLCv/AAADAE2DMaCix5mP/cZrz2ezGHpOdwMFWCoCNwAAABsBn5J0Qn8AAAMAZHzZwLNA/h228JmwsjCA2YEAAAAbAZ+UakJ/AAADAGSeK0XiXNIIuGgghvdWxAa1AAAAfEGbmUmoQWyZTAhv//6nhAAAAwANKa7NL9T0EIeDDuUAE0zPahuCD6LZya1L1T6zdlIO6nHjX+/nCu9nZa7arPqilWqAjjhIKMRc2z3mxLh897V7hZp9LKYkpuugzIE+EN0iCQ8pjv21huANsdzgyWNgdNC9W+/1HlAtDSgAAAAgQZ+3RRUsK/8AAAMATYMxoKLHmY0qHKXG30waYLobmTcAAAAaAZ/WdEJ/AAADAGR82cCzQIGD6JUjTV1WpMEAAAAbAZ/YakJ/AAADAGSeK0XiXNIImG/6bF9OQMCAAAAAzkGb3UmoQWyZTAhv//6nhAAAAwANLGS4AoNyXdX+gMWNm8K623sMYtBcT1a3FoALeweqi/pljyFgPH+bJXrURiMhBpiMu2zzWDIOG8pSrV3ZDS3bTF6B7SGYi9nIPe2ONVsqkFmWmcmD7/WilxsqvfZnlwDPpln8XNJj229vy4D0xCpq8+Yg3xdt3EgaM13XZHdXNP/6WdYGiFEIUXjBmDulZVSAFrOQFq6ibeKlvZH+1jf98DKSrQkOJJNjPwz7IqBCoKVGUPlZ35HOHKVsAAAAI0Gf+0UVLCv/AAADAE2DMaCis1G4nmAMLXQrlBPb/CmAuWS9AAAAHQGeGnRCfwAAAwBkfNnAsz7tPwJ9D1SjM5qC8OfAAAAAGQGeHGpCfwAAAwBknitF6BogyjbYfKr/3J8AAACpQZoBSahBbJlMCG///qeEAAADAA0prpQUk0N02sAEs/cJV3bEuUsncDG5HM2xOwyFjPnXjNyENzKjpjAHtGsU1eo7JjT+4GthXiBJOyDsLnKHt6MszqjKVqE86nDzb9cxD8uZKA0tjzJtsFXtbgS89i2dZzj9cGncW96zvshtg8kXYuJjeGKpAXegZKZ8pHfLVw6jlyfhJW7O0Ecu92AfsYlB3Uf8tOiNgQAAACZBnj9FFSwr/wAAAwBNgzGgovGZBpkIJ/z/n57SXhabqrRVjS5JwAAAAB4Bnl50Qn8AAAMAZHzZwMPn61ohLDxFLll5FucOZUEAAAAcAZ5AakJ/AAADAGSeK0Xn80OlejBUjkhJIUQFJwAAAElBmkVJqEFsmUwIb//+p4QAAAMADSmuzTs0A0t2I7AA0jAbjO/QpWE0dtQUsLUpu670fK1WznorZd6oT1wKfbP2vgnC2GbNispfAAAAIEGeY0UVLCv/AAADAE2DMaCi8ZNuZCfrHx6ZsoCdcCghAAAAGgGegnRCfwAAAwBkfNnAw99sF6WShW31ikvAAAAAGAGehGpCfwAAAwBknitF5+/EYJJaepGNnwAAAB5BmolJqEFsmUwIb//+p4QAAAMABLOXE11UBTVcS8EAAAAdQZ6nRRUsK/8AAAMATYMxoKLzflabqt4yb5oFGUAAAAAYAZ7GdEJ/AAADAGR82cDD32v/WAPSaZZ9AAAAGAGeyGpCfwAAAwBknitF5+/EYJJaepGNnwAAABhBms1JqEFsmUwIb//+p4QAAAMAAAMA1IEAAAAdQZ7rRRUsK/8AAAMATYMxoKLzflabqt4yb5oFGUEAAAAYAZ8KdEJ/AAADAGR82cDD32v/WAPSaZZ9AAAAGAGfDGpCfwAAAwBknitF5+/EYJJaepGNnwAAABhBmxFJqEFsmUwIb//+p4QAAAMAAAMA1IAAAAAdQZ8vRRUsK/8AAAMATYMxoKLzflabqt4yb5oFGUAAAAAYAZ9OdEJ/AAADAGR82cDD32v/WAPSaZZ9AAAAGAGfUGpCfwAAAwBknitF5+/EYJJaepGNnwAAABhBm1VJqEFsmUwIb//+p4QAAAMAAAMA1IAAAAAdQZ9zRRUsK/8AAAMATYMxoKLzflabqt4yb5oFGUEAAAAYAZ+SdEJ/AAADAGR82cDD32v/WAPSaZZ9AAAAGAGflGpCfwAAAwBknitF5+/EYJJaepGNnwAAABdBm5lJqEFsmUwIZ//+nhAAAAMAAAMDPgAAAB1Bn7dFFSwr/wAAAwBNgzGgovN+Vpuq3jJvmgUZQAAAABgBn9Z0Qn8AAAMAZHzZwMPfa/9YA9Jpln0AAAAYAZ/YakJ/AAADAGSeK0Xn78Rgklp6kY2fAAAAF0Gb3UmoQWyZTAhP//3xAAADAAADAB6QAAAAHUGf+0UVLCv/AAADAE2DMaCi835Wm6reMm+aBRlBAAAAGAGeGnRCfwAAAwBkfNnAw99r/1gD0mmWfAAAABgBnhxqQn8AAAMAZJ4rRefvxGCSWnqRjZ8AABSWbW9vdgAAAGxtdmhkAAAAAAAAAAAAAAAAAAAD6AAAMPYAAQAAAQAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAE8B0cmFrAAAAXHRraGQAAAADAAAAAAAAAAAAAAABAAAAAAAAMPYAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAAmAAAAGQAAAAAAAkZWR0cwAAABxlbHN0AAAAAAAAAAEAADD2AAAEAAABAAAAABM4bWRpYQAAACBtZGhkAAAAAAAAAAAAAAAAAAA8AAAC8ABVxAAAAAAALWhkbHIAAAAAAAAAAHZpZGUAAAAAAAAAAAAAAABWaWRlb0hhbmRsZXIAAAAS421pbmYAAAAUdm1oZAAAAAEAAAAAAAAAAAAAACRkaW5mAAAAHGRyZWYAAAAAAAAAAQAAAAx1cmwgAAAAAQAAEqNzdGJsAAAAl3N0c2QAAAAAAAAAAQAAAIdhdmMxAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAmABkABIAAAASAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGP//AAAAMWF2Y0MBZAAe/+EAGGdkAB6s2UCYM6EAAAMAAQAAAwA8DxYtlgEABmjr48siwAAAABhzdHRzAAAAAAAAAAEAAAF4AAACAAAAABhzdHNzAAAAAAAAAAIAAAABAAAA+wAAC7BjdHRzAAAAAAAAAXQAAAABAAAEAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACAAAAAACAAACAAAAAAEAAAgAAAAAAgAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAGAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAIAAAAAAIAAAIAAAAAAQAABgAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAQAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACAAAAAACAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAYAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAABAAAKAAAAAAEAAAQAAAAAAQAAAAAAAAABAAACAAAAAAEAAAoAAAAAAQAABAAAAAABAAAAAAAAAAEAAAIAAAAAAQAACgAAAAABAAAEAAAAAAEAAAAAAAAAAQAAAgAAAAAcc3RzYwAAAAAAAAABAAAAAQAAAXgAAAABAAAF9HN0c3oAAAAAAAAAAAAAAXgAAAnPAAABYwAAAF4AAAA3AAAAQwAAASwAAABEAAAAPwAAAGYAAAHSAAAAjQAAAHgAAAB4AAABegAAAJoAAACwAAAAtgAAAYIAAAC9AAAA2gAAAPYAAAFXAAABAgAAAOAAAADHAAABcgAAAM4AAADOAAAA1wAAASMAAADMAAAAtwAAATcAAADvAAAA3wAAASoAAADUAAAA3AAAANIAAAFWAAAA3gAAAKUAAACuAAABMAAAANEAAADeAAAA1AAAAU4AAADJAAABmQAAALkAAACfAAAArgAAAUkAAAC+AAAAlAAAAJ8AAAEnAAAAtQAAANEAAAC1AAABMwAAAK8AAAC9AAAA0gAAAUkAAADnAAAAtQAAAM0AAAFfAAAA0gAAALIAAADRAAABGAAAAOsAAACnAAAAwwAAAQ4AAACoAAAAfQAAAHoAAAEFAAAAnQAAAHwAAACeAAABAgAAAIcAAACgAAAAaQAAAN0AAACFAAAAigAAAH0AAAD7AAAAhgAAAH4AAACMAAAArQAAAIwAAACJAAAAdgAAAMgAAACiAAAAagAAAH4AAADqAAAAigAAAIMAAACUAAABFwAAANcAAACAAAAAkQAAAR0AAADNAAAAsQAAAHcAAAE4AAAA3gAAAIsAAADFAAAA/AAAAMsAAADdAAAAmAAAARcAAACgAAAAewAAAIgAAADUAAAArAAAAKIAAAC4AAAA+AAAAJcAAACdAAAApwAAAMgAAACeAAAAcgAAAJkAAADqAAAAtwAAALEAAACkAAABJAAAAKAAAAChAAAAeAAAAQgAAADFAAAAuQAAALEAAAEBAAAAwgAAAK0AAACoAAABFAAAALMAAACZAAAAqgAAARsAAADHAAAAkAAAALAAAADcAAAApgAAAIwAAACpAAAA7QAAAHAAAAB7AAAAbAAAAPAAAACbAAAAZwAAAKcAAAETAAAAsgAAAIoAAACVAAAAzgAAAJUAAACJAAAAoAAAAKsAAACGAAAAYwAAAIYAAAD6AAAAogAAAHkAAACWAAAA9QAAAJsAAAB6AAAAYgAAAQMAAAC0AAAAZgAAAH4AAADXAAAAjQAAAJsAAACIAAAAzwAAAKkAAACKAAAAiQAAAWMAAAClAAAAwgAAAQAAAACmAAAA/QAAAKYAAACZAAAAhwAAAN8AAACOAAAAZgAAAK0AAAC9AAAAnAAAAKsAAACCAAABGQAAAJcAAAB9AAAAkwAAAXMAAADEAAAAkQAAAKgAAAEvAAAAvAAAANYAAACGAAABLgAAAKwAAACGAAAAhAAAARkAAADnAAAAsgAAAK4AAAEMAAAA3wAAAMQAAADFAAAJgAAAAVMAAAC+AAAAqwAAALgAAACvAAAAiAAAAKUAAAB2AAABHQAAAHYAAACKAAAAXwAAAVAAAACdAAAAewAAAIYAAADyAAAAkAAAAH4AAACQAAAA8QAAAH4AAABgAAAAUQAAAMcAAAB/AAAAZQAAALsAAABoAAAAPQAAAEIAAAC5AAAAXwAAAFEAAABOAAAAkQAAAFcAAABmAAAATwAAAKoAAABIAAAAYQAAAFEAAAC7AAAAYwAAAD0AAABFAAABbwAAAGsAAAA8AAAATAAAAUcAAACFAAABDgAAAIQAAACnAAAAZwAAAQAAAAA7AAAASQAAACsAAACwAAAAMAAAACUAAAAdAAAAXgAAACYAAAAfAAAAHAAAAJoAAAArAAAAHgAAAC0AAACjAAAAKQAAACgAAAAgAAAAggAAAC0AAAAiAAAAIgAAAJcAAAAoAAAAHwAAAB8AAACAAAAAJAAAAB4AAAAfAAAA0gAAACcAAAAhAAAAHQAAAK0AAAAqAAAAIgAAACAAAABNAAAAJAAAAB4AAAAcAAAAIgAAACEAAAAcAAAAHAAAABwAAAAhAAAAHAAAABwAAAAcAAAAIQAAABwAAAAcAAAAHAAAACEAAAAcAAAAHAAAABsAAAAhAAAAHAAAABwAAAAbAAAAIQAAABwAAAAcAAAAFHN0Y28AAAAAAAAAAQAAADAAAABidWR0YQAAAFptZXRhAAAAAAAAACFoZGxyAAAAAAAAAABtZGlyYXBwbAAAAAAAAAAAAAAAAC1pbHN0AAAAJal0b28AAAAdZGF0YQAAAAEAAAAATGF2ZjU4LjI5LjEwMA==\" type=\"video/mp4\" />\n",
              "             </video>"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "import glob\n",
        "import io\n",
        "import base64\n",
        "import imageio\n",
        "from IPython.display import HTML, display\n",
        "from gym.wrappers.monitoring.video_recorder import VideoRecorder\n",
        "\n",
        "def show_video_of_model(agent, env_name):\n",
        "    env = gym.make(env_name, render_mode='rgb_array')\n",
        "    state, _ = env.reset()\n",
        "    done = False\n",
        "    frames = []\n",
        "    while not done:\n",
        "        frame = env.render()\n",
        "        frames.append(frame)\n",
        "        action = agent.act(state)\n",
        "        state, reward, done, _, _ = env.step(action.item())\n",
        "    env.close()\n",
        "    imageio.mimsave('video.mp4', frames, fps=30)\n",
        "\n",
        "show_video_of_model(agent, 'LunarLander-v2')\n",
        "\n",
        "def show_video():\n",
        "    mp4list = glob.glob('*.mp4')\n",
        "    if len(mp4list) > 0:\n",
        "        mp4 = mp4list[0]\n",
        "        video = io.open(mp4, 'r+b').read()\n",
        "        encoded = base64.b64encode(video)\n",
        "        display(HTML(data='''<video alt=\"test\" autoplay\n",
        "                loop controls style=\"height: 400px;\">\n",
        "                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n",
        "             </video>'''.format(encoded.decode('ascii'))))\n",
        "    else:\n",
        "        print(\"Could not find video\")\n",
        "\n",
        "show_video()"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}