{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "ctpoSTL9oGq7" }, "source": [ "# Gym environments" ] }, { "cell_type": "markdown", "metadata": { "id": "PsWSoHfooGrJ" }, "source": [ "## Installing gym\n", "\n", "In this course, we will mostly address RL environments available in the **OpenAI Gym** framework:\n", "\n", "\n", "\n", "It provides a multitude of RL problems, from simple text-based problems with a few dozens of states (Gridworld, Taxi) to continuous control problems (Cartpole, Pendulum) to Atari games (Breakout, Space Invaders) to complex robotics simulators (Mujoco):\n", "\n", "\n", "\n", "However, `gym` is not maintained by OpenAI anymore since September 2022. We will use instead the `gymnasium` library maintained by the Farama foundation, which will keep on maintaining and improving the library.\n", "\n", "\n", "\n", "You can install gymnasium and its dependencies using:\n", "\n", "```bash\n", "pip install -U gymnasium pygame moviepy\n", "pip install gymnasium[classic_control]\n", "pip install gymnasium[box2d]\n", "```\n", "\n", "For this exercise and the following, we will focus on simple environments whose installation is straightforward: toy text, classic control and box2d. More complex environments based on Atari games or the Mujoco physics simulator are described in the last (optional) section of this notebook, as they require additional dependencies. \n", "\n", "On colab, `gym` cannot open graphical windows for visualizing the environments, as it is not possible in the browser. We will see a workaround allowing to produce videos. Running that cell in colab should allow you to run the simplest environments:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "id": "YxLOmLKIoGrN" }, "outputs": [], "source": [ "try:\n", " import google.colab\n", " IN_COLAB = True\n", "except:\n", " IN_COLAB = False\n", "\n", "if IN_COLAB:\n", " !pip install -U gymnasium pygame moviepy\n", " !pip install gymnasium[box2d]\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "gym version: 0.26.3\n" ] } ], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import os\n", "\n", "import gymnasium as gym\n", "print(\"gym version:\", gym.__version__)\n", "\n", "from moviepy.editor import ImageSequenceClip, ipython_display\n", "\n", "class GymRecorder(object):\n", " \"\"\"\n", " Simple wrapper over moviepy to generate a .gif with the frames of a gym environment.\n", " \n", " The environment must have the render_mode `rgb_array_list`.\n", " \"\"\"\n", " def __init__(self, env):\n", " self.env = env\n", " self._frames = []\n", "\n", " def record(self, frames):\n", " \"To be called at the end of an episode.\"\n", " for frame in frames:\n", " self._frames.append(np.array(frame))\n", "\n", " def make_video(self, filename):\n", " \"Generates the gif video.\"\n", " directory = os.path.dirname(os.path.abspath(filename))\n", " if not os.path.exists(directory):\n", " os.mkdir(directory)\n", " self.clip = ImageSequenceClip(list(self._frames), fps=self.env.metadata[\"render_fps\"])\n", " self.clip.write_gif(filename, fps=self.env.metadata[\"render_fps\"], loop=0)\n", " del self._frames\n", " self._frames = []" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Interacting with an environment\n", "\n", "A gym environment is created using:\n", "\n", "```python\n", "env = gym.make('CartPole-v1', render_mode=\"human\")\n", "```\n", "\n", "where 'CartPole-v1' should be replaced by the environment you want to interact with. The following cell lists the environments available to you (including the different versions)." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CartPole-v0\n", "CartPole-v1\n", "MountainCar-v0\n", "MountainCarContinuous-v0\n", "Pendulum-v1\n", "Acrobot-v1\n", "LunarLander-v2\n", "LunarLanderContinuous-v2\n", "BipedalWalker-v3\n", "BipedalWalkerHardcore-v3\n", "CarRacing-v2\n", "Blackjack-v1\n", "FrozenLake-v1\n", "FrozenLake8x8-v1\n", "CliffWalking-v0\n", "Taxi-v3\n", "Reacher-v2\n", "Reacher-v4\n", "Pusher-v2\n", "Pusher-v4\n", "InvertedPendulum-v2\n", "InvertedPendulum-v4\n", "InvertedDoublePendulum-v2\n", "InvertedDoublePendulum-v4\n", "HalfCheetah-v2\n", "HalfCheetah-v3\n", "HalfCheetah-v4\n", "Hopper-v2\n", "Hopper-v3\n", "Hopper-v4\n", "Swimmer-v2\n", "Swimmer-v3\n", "Swimmer-v4\n", "Walker2d-v2\n", "Walker2d-v3\n", "Walker2d-v4\n", "Ant-v2\n", "Ant-v3\n", "Ant-v4\n", "Humanoid-v2\n", "Humanoid-v3\n", "Humanoid-v4\n", "HumanoidStandup-v2\n", "HumanoidStandup-v4\n", "GymV26Environment-v0\n" ] } ], "source": [ "for env in gym.envs.registry.items():\n", " print(env[0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `render_mode` argument defines how you will see the environment:\n", "\n", "* `None` (default): allows to train a DRL algorithm without wasting computational resources rendering it.\n", "* `rgb_array_list`: allows to get numpy arrays corresponding to each frame. Will be useful when generating videos.\n", "* `ansi`: string representation of each state. Only available for the \"Toy text\" environments.\n", "* `human`: graphical window displaying the environment live." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The main interest of gym(nasium) is that all problems have a common interface defined by the class `gym.Env`. There are only three methods that have to be used when interacting with an environment:\n", "\n", "* `state, info = env.reset()` restarts the environment and returns an initial state $s_0$.\n", "\n", "* `state, reward, terminal, truncated, info = env.step(action)` takes an action $a_t$ and returns:\n", " * the new state $s_{t+1}$, \n", " * the reward $r_{t+1}$, \n", " * two boolean flags indicating whether the current state is terminal (won/lost) or truncated (timeout),\n", " * a dictionary containing additional info for debugging (you can ignore it most of the time).\n", "\n", "* `env.render()` displays the current state of the MDP. When the render mode is set to `rgb_array_list` or `human`, it does not even have to called explicitly (since gym 0.25)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "With this interface, we can interact with the environment in a standardized way:\n", "\n", "* We first create the environment.\n", "* For a fixed number of episodes:\n", " * We pick an initial state with `reset()`.\n", " * Until the episode is terminated:\n", " * We select an action using our RL algorithm or randomly.\n", " * We take that action (`step()`), observe the new state and the reward.\n", " * We go into the new state.\n", "\n", "The following cell shows how to interact with the CartPole environment using a random policy. Note that it will only work on your computer, not in colab." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "env = gym.make('CartPole-v1', render_mode=\"human\")\n", "\n", "for episode in range(10):\n", " state, info = env.reset()\n", " done = False\n", " while not done:\n", " # Select an action randomly\n", " action = env.action_space.sample()\n", " \n", " # Sample a single transition\n", " next_state, reward, terminal, truncated, info = env.step(action)\n", " \n", " # Go in the next state\n", " state = next_state\n", "\n", " # End of the episode\n", " done = terminal or truncated\n", "\n", "env.close()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On colab (or whenever you want to record videos of the episodes instead of watching them live), you need to create the environment with the rendering mode `rgb_array_list`. \n", "\n", "You then create a `GymRecorder` object (defined in the first cell of this notebook). \n", "\n", "```python\n", "recorder = GymRecorder(env)\n", "```\n", "\n", "At the end of each episode, you tell the recorder to record all frames generated during the episode. The frames returned by `env.render()` are (width, height, 3) numpy arrays which are accumulated by the environment during the episode and flushed when `env.reset()` is called.\n", "\n", "```python\n", "recorder.record(env.render())\n", "```\n", "\n", "You can then generate a gif at the end of the simulation with:\n", "\n", "```python\n", "recorder.make_video('videos/CartPole-v1.gif')\n", "```\n", "\n", "Finally, you can render the gif in the notebook by calling **at the very last line of the cell**:\n", "\n", "```python\n", "ipython_display('videos/CartPole-v1.gif')\n", "```" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MoviePy - Building file videos/CartPole-v1.gif with imageio.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " \r" ] }, { "data": { "text/html": [ "
" ], "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "env = gym.make('CartPole-v1', render_mode=\"rgb_array_list\")\n", "recorder = GymRecorder(env)\n", "\n", "for episode in range(10):\n", " state, info = env.reset()\n", "\n", " done = False\n", " while not done:\n", " # Select an action randomly\n", " action = env.action_space.sample()\n", " \n", " # Sample a single transition\n", " next_state, reward, terminal, truncated, info = env.step(action)\n", " \n", " # Go in the next state\n", " state = next_state\n", "\n", " # End of the episode\n", " done = terminal or truncated\n", "\n", " # Record at the end of the episode \n", " recorder.record(env.render())\n", "\n", "recorder.make_video('videos/CartPole-v1.gif')\n", "ipython_display('videos/CartPole-v1.gif', autoplay=1, loop=0)" ] }, { "cell_type": "markdown", "metadata": { "id": "WENOr5atoGr1" }, "source": [ "Each environment defines its state space (`env.observation_space`) and action space (`env.action_space`). \n", "\n", "State and action spaces can either be :\n", "\n", "* discrete (`gym.spaces.Discrete(nb_states)`), with states being an integer between 0 and `nb_states` -1.\n", "\n", "* feature-based (`gym.spaces.Box(low=0, high=255, shape=(SCREEN_HEIGHT, SCREEN_WIDTH, 3))`) for pixel frames.\n", "\n", "* continuous. Example for two joints of a robotic arm limited between -180 and 180 degrees:\n", "\n", "```python\n", "gym.spaces.Box(-180.0, 180.0, (2, ))\n", "```\n", "\n", "You can sample a state or action randomly from these spaces:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[-113.33049 83.84796]\n" ] } ], "source": [ "action_space = gym.spaces.Box(-180.0, 180.0, (2, ))\n", "action = action_space.sample()\n", "print(action)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "Sampling the action space is particularly useful for exploration. We use it here to perform random (but valid) actions:\n", "\n", "```python\n", "action = env.action_space.sample()\n", "```\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Q:** Create a method `random_interaction(env, number_episodes, recorder=None)` that takes as arguments:\n", "\n", "* The environment.\n", "* The number of episodes to be performed.\n", "* An optional `GymRecorder` object that may record the frames of the environment if it is not None (`if renderer is not None:`). Otherwise, do not nothing.\n", "\n", "The method should return the list of undiscounted returns ($\\gamma=1$, i.e. just the sum of rewards obtained during each episode) for all episodes." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def random_interaction(env, number_episodes, recorder=None):\n", "\n", " returns = []\n", "\n", " # Sample episodes\n", " for episode in range(number_episodes):\n", "\n", " # Sample the initial state\n", " state, info = env.reset()\n", "\n", " return_episode = 0.0\n", " done = False\n", " while not done:\n", "\n", " # Select an action randomly\n", " action = env.action_space.sample()\n", " \n", " # Sample a single transition\n", " next_state, reward, terminal, truncated, info = env.step(action)\n", "\n", " # Update the return\n", " return_episode += reward\n", " \n", " # Go in the next state\n", " state = next_state\n", "\n", " # End of the episode\n", " done = terminal or truncated\n", "\n", " # Record at the end of the episode\n", " if recorder is not None:\n", " recorder.record(env.render())\n", "\n", " returns.append(return_episode)\n", "\n", " return returns\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Q:** Use that method to visualize all the available simple environments for a few episodes:\n", "\n", "* CartPole-v1\n", "* MountainCar-v0\n", "* Pendulum-v1\n", "* Acrobot-v1\n", "* LunarLander-v2\n", "* BipedalWalker-v3\n", "* CarRacing-v2\n", "* Blackjack-v1\n", "* FrozenLake-v1\n", "* CliffWalking-v0\n", "* Taxi-v3\n", "\n", "If you do many episodes (CarRacing or Taxi have very long episodes with a random policy), plot the obtained returns to see how they vary. \n", "\n", "If you managed to install the mujoco and atari dependencies, feel free to visualize them too. " ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0oAAAINCAYAAAAA8I+NAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACHQElEQVR4nO3deXiU5dU/8O8za7aZBLIPREhIgCwQECyKIm7wSq3VutatWGvfWqUutC5UfUtfW+hPK1JFrVpr1Za6vW7VYsUNUUFByR6WsGbfSDKTSWYmM/P8/sg8kxAWs8zMPfPM93NduS6ZJDNHDbnn3Pc555ZkWZZBREREREREfhrRARAREREREYUbJkpERERERERDMFEiIiIiIiIagokSERERERHREEyUiIiIiIiIhmCiRERERERENAQTJSIiIiIioiGYKBEREREREQ2hEx1AsHm9XjQ0NMBkMkGSJNHhEBERERGRILIsw2azwWKxQKM58ZmR6hOlhoYGZGVliQ6DiIiIiIjCRG1tLSZOnHjCrxGaKE2ePBkHDx486vGbb74Zjz/+OGRZxm9/+1s8/fTT6OjowLx58/D444+jsLBw2K9hMpkA9P/HMJvNAYudiIiIiIgii9VqRVZWlj9HOBGhidK2bdvg8Xj8f66oqMCiRYtw+eWXAwAefPBBrFmzBn/7298wdepU/O53v8OiRYuwa9euYf3LAfCX25nNZiZKREREREQ0rJYcocMcUlNTkZGR4f945513MGXKFCxcuBCyLGPt2rW49957cckll6CoqAjPP/88enp6sH79epFhExERERGRyoXN1DuXy4W///3vuOGGGyBJEvbv34+mpiYsXrzY/zVGoxELFy7EF198cdzncTqdsFqtR3wQERERERGNRNgkSm+++SY6Oztx/fXXAwCampoAAOnp6Ud8XXp6uv9zx7J69WokJib6PzjIgYiIiIiIRipsEqVnn30WS5YsgcViOeLxofWDsiyfsKZwxYoV6Orq8n/U1tYGJV4iIiIiIlKvsBgPfvDgQXzwwQd4/fXX/Y9lZGQA6D9ZyszM9D/e0tJy1CnTYEajEUajMXjBEhERERGR6oXFidJzzz2HtLQ0XHDBBf7HsrOzkZGRgY0bN/ofc7lc2LRpE+bPny8iTCIiIiIiihLCT5S8Xi+ee+45LF26FDrdQDiSJOH222/HqlWrkJeXh7y8PKxatQpxcXG4+uqrBUZMRERERERqJzxR+uCDD3Do0CHccMMNR33urrvuQm9vL26++Wb/hbPvv//+sO9QIiIiIiIiGg1JlmVZdBDBZLVakZiYiK6uLl44S0REREQUxUaSG4RFjxIREREREVE4YaJEREREREQ0BBMlIiIiIiKiIZgoERERERERDcFEiYiIiIiIaAgmSkREREREREMwUSIiIiIiIhqCiRIR0RAtVgcOtttFh0FERGHE65VRUtsJt8crOhQKESZKRESDyLKMq57ZiiV/2owWm0N0OEREFCae33IAFz/+OZ79bL/oUChEmCgREQ3S2OXA3lY7elwelBzqFB0OERGFiU27WwEAn9W0CY6EQoWJEhHRIOX1Xf5/rmq0CoyEiIjChSzLKKvrXx+quTZEDSZKRESDVAxKlLgYEhERANR19OKw3QUAaOt2sTQ7SjBRIiIapIInSkRENMTgagMAqGrg+hANmCgREfnIsozy+oHFr/ZwL6yOPoERERFROCit6zziz9xIiw5MlIiIfJqtTrR1O6GRgJQEIwBgZ6NNcFRERCRaWW3/idLk5DgAQDXXhqjARImIyEcpu8tLM2FWViIAoKqh60TfQkREKuf1yv714cpTTgLAtSFaMFEiIvJRatALJ5hRkGkGwPIKIqJot6/NDpvTjRi9BhfNsvgf63G5BUdGwcZEiYjIR9kxnDEhEQUWJkpERASU13cCAAotichMjEFKggGyDOxqYvmd2jFRIiLyqWgYSJTyfSdKu5u70efxigyLiIgEKvX1J82cmAhJkvzrA/uU1I+JEhERgBabA81WJyQJyM80I2tcHBKMOrjcXuxrtYsOj4iIBCnzTbwrnpgEAIMqDtinpHZMlIiIAFT6xoJPSU1AvFEHjUZCfqYJABdDIqJo1efxotJ3Z9KMif1Dfvw9rLxLSfWYKBERYWCQQ5FvpxAAyyuIiKLc7mYbnG4vTEYdspPjAQwkSjubbPB6ZZHhUZAxUSIiwqBEaUKi/zHuGhIRRbfyOl/v6sREaDQSACA7JR5GnQY9Lg8OHu4RGR4FGRMlIiIAlYMm3ikGT76TZe4aEhFFm9I6ZZBDkv8xnVaD6Rm+0mxupKkaEyUiinrt3U40dDkADCRHADA13QStRsJhuwvNVqeo8IiISJCBQQ6JRzyen8mBDtGAiRIRRT2l7C4nJR6mGL3/8Ri9Fjkp/TXp1bxPiYgoqjj6PP67kmYMSZSUTTX2sKobEyUiinrKRKPB/UkKXjxLRBSdqhqtcHtlJMcbMCEp9ojPsYc1OjBRIqKopzTrFk0wH/U5LoZERNGpvO7Ii2YHm+5bG5qsDhy2u0IeG4UGEyUiinrHmninGBgRzkSJiCialPr6kwYPclAkGHWYlBwHgOuDmjFRIqKo1mF3ob6zFwBQaDl+orS/3Q670x3S2IiISJwy34lScdbRawPAioNowESJiKJaRUP/QjgpOQ6JsfqjPp9qMiLNZIQs918uSERE6tftdGNvazcAYMaEpGN+jT9R4omSajFRIqKoVlF//EEOCg50ICKKLhX1XZBlwJIYg1ST8Zhfk88TJdVjokREUa1C6U86Rtmdgn1KRETRpewE/UkKZRNtb2s3HH2eEERFocZEiYiimjLIYcaJTpS4a0hEFFVKlYl3x+lPAoDMxBgkxenh9sqoaekOVWgUQkyUiChqdfX04dDhHgDHHg2uUHYNdzZZ4fHKIYmNiIjEUU6Uik9woiRJEvIzuJGmZkyUiChqVfoGOUwcF4ukOMNxv25ycjxi9Bo4+rw40G4PVXhERCTAYbsLtYf7p6GeqH8VYA+r2jFRIqKoNZyyOwDQaiRM564hEVFUUNaG7JT4Y05DHYyT79SNiRIRRa2Khm+feKfgriERUXQoq+0EAMycOPy1obrBCllmabbaMFEioqjln3g3nESJAx2IiKKCf5DDCfqTFFNSE6DXSrA53ajr6A1yZBRqTJSIKCpZHX3Y39bfb/RtpXcAR4QTEUWLgdHg3742GHQa5KWZALDiQI2YKBFRVFJOhiYkxWJ8/PEHOSimZ5ggSUCLzYlWmzPY4RERkQBNXQ602JzQSECh5fjTUAfzl2az4kB1mCgRUVRSyu6GuxDGG3XITo4HwFMlIiK1Uk6TpqabEGfQDet78jnQQbWYKBFRVKoY5sS7wfItLL8jIlKzMn9/0vDXhgKWZqsWEyUiikrlIxjkoOAYWCIidSv19yclDft7lLWhrqMXXb19QYiKRGGiRERRp9vpxj7fIIdRJUqsQyciUh1Zlv2baCM5UUqM02NCUiwAniqpDRMlIoo61Y1WyDKQYY5Bqsk47O9TGnb3tnbD0ecJVnhERCTAocM96Ozpg0Gr8V8yPlz53EhTJSZKRBR1yuuUsruRLYRpJiPGxxvglYHdzbZghEZERIIo/Un5mSYYdCN7i1zAHlZVYqJERFFnJBfNDiZJEsvviIhUqmwU/UkK9rCqExMlIoo6FQ0jn3in8N+XwcWQiEhVSkcx8U6hJEp7mrvR5/EGNC4Sh4kSEUWVHpcbNS3dAEZ+ogRwDCwRkRp5vLK/2mA0J0oTx8XCZNTB5fFib2t3gKMjUZgoEVFUqW60wisDqSYj0s0xI/7+fH+iZIPXKwc6PCIiEmBfazd6XB7EGbTITUsY8fdrNBIHOqgQEyUiiioV9f0L2GjK7gAgJzUeBp0G3U43ajt6AhkaEREJopTdFVkSodVIo3oOf2k2EyXVYKJERFHFf9GsZWQT7xR6rQbT0k0AuBgSEanFwCCH0W2iAf3T8gD2sKoJEyUiiiqjnXg3mLIYsk+JiEgd/IMcspJG/RwFmf3rSv9dfSzNVgMmSkQUNRx9HuzxDXKYMYZdQ46BJSJSD5fbi2pfhcDMMWyi5aUnQKuR0NHThyarI1DhkUBMlIgoalQ3WuHxykiONyBjFIMcFAWW/oWUpXdERJFvd7MNLo8XibF6TEqOG/XzxOi1mJIaD4Drg1owUSKiqFHhW7iKJiRCkkbXrAsA032ldw1dDnT2uAISGxERiVE6qD9pLGsDwCsk1IaJEhFFjQplqtGE0Q1yUJhj9MgaHwuA5XdERJGurHb0F80OxUvJ1YWJEhFFDWXi3WhHgw9WwPsyiIhUYeBEKWnMz6UMdODaoA5MlIgoKjjdHuxutgEY28Q7hX8x5K4hEVHE6nUNDPkJxImSMhX1QHsPup3uMT8ficVEiYiiwq4mG9xeGUlxekxIih3z8w2MCLeN+bmIiEiMqsYueLwyUk3GMQ35USQnGJFuNgIAdjVxIy3SMVEioqgwuOxurM26wEAdek2LDS63d8zPR0REoVfq608qDsAgBwVLs9WDiRIRRYWK+oGJd4EwISkW5hgd+jwy9rTwVImIKBKVBbA/SZHPu/ZUg4kSEUWFCt+JUpElMImSJEn+UyWW3xERRaYy3zTUsVxCPtTA5DuuDZGOiRIRqZ7L7cWupv4FKxAT7xT5LK8gIopYXb192NdmBwAUB/BESSm929lohdvD0uxIxkSJiFRPuXXdHKPz338UCP469MaugD0nERGFRqWv0mDiuFiMjzcE7HknJccjzqCF0+3FgXZ7wJ6XQo+JEhGpnr/sLkCDHBT+8ooGK2RZDtjzEhFR8JXWKYMckgL6vFqNhGkZ/ZNRK1lxENGYKBGR6lU0BO6i2cFy0xKg00iwOtxo6HIE9LmJiCi4BgY5BHZtAAYqDtjDGtmYKBGR6pX7Jt4VBjhRMuq0yE1LAMA+JSKiSBOMQQ6KgYEOXBsiGRMlIlK1Po8X1b6FKtAnSsCR5XdERBQZ2rqdqO/shSQFZ23gsB91EJ4o1dfX49prr0VycjLi4uIwa9YsfP311/7Py7KMlStXwmKxIDY2FmeddRYqKysFRkxEkaSmpRsutxcmow6TxscF/PkHyiu4GBIRRYpy32lSTko8TDH6gD//9AwTJKk/IWuxsTQ7UglNlDo6OnD66adDr9djw4YNqKqqwsMPP4ykpCT/1zz44INYs2YN1q1bh23btiEjIwOLFi2CzcaaTyL6duW+QQ4FFjM0msANclAU8GJBIqKIU+rrTwr0IAdFnEGH7JR4AOxTimQ6kS/+//7f/0NWVhaee+45/2OTJ0/2/7Msy1i7di3uvfdeXHLJJQCA559/Hunp6Vi/fj1+9rOfHfWcTqcTTqfT/2erlW9eiKKZMvEuGKUVwEB5xaHDPbA6+mAOws4kEREFltKfFIxBDoqCTDP2tdpR1WDFwqmpQXsdCh6hJ0pvv/025s6di8svvxxpaWmYPXs2nnnmGf/n9+/fj6amJixevNj/mNFoxMKFC/HFF18c8zlXr16NxMRE/0dWVlbQ/z2IKHz5E6UgLYbj4g2wJMYAAHZy15CIKOzJsuyfeDcjSCdKwKA+JVYcRCyhidK+ffvw5JNPIi8vD//5z39w00034dZbb8ULL7wAAGhqagIApKenH/F96enp/s8NtWLFCnR1dfk/amtrg/svQURhy+3x+heoQkvwdg3z2adERBQxGrscaOt2QaeRUOgbyBMMyrAfrg2RS2jpndfrxdy5c7Fq1SoAwOzZs1FZWYknn3wSP/rRj/xfN/SCSFmWj3tppNFohNFoDF7QRBQx9rXZ4ejzIt6gRY6vVjwYCixmfLizhdONiIgigHKaNDXdhBi9NmivU+jbRNvX2o1elwexhuC9FgWH0BOlzMxMFBQUHPFYfn4+Dh06BADIyMgAgKNOj1paWo46ZSIiGkqZalRoSQzKIAcFBzoQEUWOUt/aUJwVvEoDAEg1GZEcb4BXBnY1szQ7EglNlE4//XTs2rXriMd2796NSZMmAQCys7ORkZGBjRs3+j/vcrmwadMmzJ8/P6SxElHkUSbeFU4IXmkFMFBesavZBrfHG9TXIiKisVFOlGYGsT8J6K+IYvldZBOaKN1xxx3YunUrVq1ahZqaGqxfvx5PP/00brnlFgD9P2C33347Vq1ahTfeeAMVFRW4/vrrERcXh6uvvlpk6EQUASobgjvxTpE1Lg7xBi1cbi/2tdmD+lpERDR6Xq/sn3gX7LUBGFRxwNLsiCS0R+mUU07BG2+8gRUrVuB///d/kZ2djbVr1+Kaa67xf81dd92F3t5e3Hzzzejo6MC8efPw/vvvw2QyCYyciMKdxyuj0rcwFQV5MdRoJORnmrH9YAeqGqyYms7fT0RE4ejg4R7YHG4YdRpMywj+72rlRIml2ZFJaKIEAN/73vfwve9977iflyQJK1euxMqVK0MXFBFFvP1t3ehxeRCr12JKakLQX6/A4kuUGq24ePaEoL8eERGNnFJ2V2AxQ68NfmHV4KmoXq8c1H5ZCjyhpXdERMFSUd+/e1dgMUMbgoWJI8KJiMJfaa1vkEOQ+5MUOSnxMOg06HF5cOhwT0hekwKHiRIRqZIyyKEoiHdkDDa4Dl2W5ZC8JhERjczAIIfg9ycBgE6rwXRfiR/L7yIPEyUiUiV/ohSCZl0AmJZhgkYC2u0utNicIXlNIiIaPrfHiwrfkJ9QJUoABzpEMiZKRKQ6Xq/sX5BmhGgxjBnUC8VdQyKi8FPT2g1HnxcJRh1yUoLfu6pgaXbkYqJERKpzoN2Obmf/VKPcEAxyUORz15CIKGyV1SqVBuaQDlXg5LvIxUSJiFRHKbvLzzRDF4KpRgouhkRE4avU158UqkEOCqVHqbHLgcN2V0hfm8aGiRIRqY5yf1IoLhMcTKlDr+aJEhFR2PFfNBvC/iQAMMXocdL4OAAsv4s0TJSISHXK6wbKK0JJKb3b325Hj8sd0tcmIqLjc7o92NnUn6SE+kQJGLSRxkQpojBRIiJVkWXZP9UoVBPvFKkmI1JNRsgysLPJFtLXJiKi49vZaEOfR8a4OD0mjosN+ev7S7NZcRBRmCgRkaocOtwDm8MNg1aDvDRTyF+fY2CJiMLPwP1JSZCk0A1yUPjXBp4oRRQmSkSkKsogh+mZJhh0of8Vp+wasryCiCh8lPpKsotD3J+kyPetDTUt3XC6PUJioJFjokREqlJR35+ghLrsTpHPXUMiorCjnCjNENCfBACWxBgkxurh9srY09wtJAYaOSZKRKQqFb4TpSKLmERJKa/Y2WiDxysLiYGIiAbYnW7UtPQnJ6JOlCRJYvldBGKiRESqIcuyv/Qu1KPBFdkp8YjRa9Db58GBdruQGIiIaEBlgxVeGcgwxyDNHCMsDl5KHnmYKBGRatR19KKrtw96rYSpGQlCYtBqJEzLYJ8SEVG4GBjkIGYDTcEe1sjDRImIVEMpu5uaboJRpxUWByffERGFD/8gh6wkoXEMLr2TZZZmRwImSkSkGqLL7hT++zK4a0hEJJx/kIPgtSE3LQF6rQSbw426jl6hsdDwMFEiItWoaBA78U7BG9iJiMJDV08fDrb3ABBfemfQaZDru9+P60NkYKJERKogy/LAxDvBidL0DBMkCWi2OtHW7RQaCxFRNCur7wQATEqOQ1KcQWww4MWzkYaJEhGpQmOXA4ftLmg1EqZnmITGEm/UYXJyPADuGhIRiVTm60+aKej+pKH8pdnsYY0ITJSISBWU/qS8tATE6MUNclBwoAMRkXiltZ0AxN2fNFR+Zv9GHk+UIgMTJSJShYowGeSgUBZDnigREYmjnCiFy9qgbKIp11lQeGOiRESq4E+UwmTXkJPviIjEarE60GR1QCOJ711VJMUZMCEpFgCwk+tD2GOiREQRT5ZllNf3LziFlvBYDAsy++PY22qHo88jOBoiouijnCblpiUg3qgTHM2AfA50iBhMlIgo4inT5TTSQFmDaOlmI8bHG+DxytjT3C06HCKiqKPcnxQugxwUBSzNjhhMlIgo4lX4BzmYEGsQP8gBACRJGtS02yU4GiKi6FPqn3gXHpUGCpZmRw4mSkQU8ZSJd4UTwuM0ScHJd0REYsiyHMYnSv2J2+6mbvR5vIKjoRNhokREES/cJt4puGtIRCRGXUcvOnr6oNcOnO6Hi4njYpFg1MHl8WJvK0uzwxkTJSKKeBUN4ZkoKQ271Y02eL2y4GiIiKKHMshheoYZRl14lGQrNBqJV0hECCZKRBTRWmwONFudkKSBxCRcTElNgEGrQbfTjbqOXtHhEBFFjYGyu/DaQFOwNDsyMFEioohW6RsLPiU1vMa/AoBeq8HUjAQAHOhARBRKpeGeKLE0OyIwUSKiiKYMciiyhNdpksK/a9hoExwJEVF08HplVPg20cJtkINicGm2LLM0O1wxUSKiiOZPlMKsP0mRz/IKIqKQ2tdmR7fTjRi9BnlpCaLDOaap6SZoNRIO211otjpFh0PHwUSJiCJaZZhOvFMU+HcNmSgREYWC0p9UZEmEThueb3Vj9FpMSY0HwNLscBaePz1ERMPQ3u1EQ5cDwEC9d7jJ98VV39mLzh6X4GiIiNSvzH/RbJLYQL4FKw7CHxMlIopYStldTko8TDF6wdEcmzlGj4njYgH016ITEVFwhfsgB0XBoD4lCk9MlIgoYlX6duHCtT9JMTDQgbuGRETB1Ofx+k9owj5R4uS7sMdEiYgiVnmdMsghPMvuFP7FkOUVRERBtbvZBqfbC1OMDpOT40WHc0JK6d2BdjvsTrfgaOhYmCgRUcQK94l3Cg50ICIKjYH+pERoNJLgaE4sJcGINJMRsgzsbGL5XThiokREEanD7kJ9Zy8AoNAS3omSsmu4p8UGl9srOBoiIvUq8/cnJQmNY7hYfhfemCgRUUSqaOjfNZyUHIfE2PAc5KCYOC4Wphgd+jwyalq6RYdDRKRapbW+E6UwrzRQFHDyXVhjokREEUm5dT3cy+4AQJIkDnQgIgoyR58Hu5v7S9hmZiWJDWaY8rk2hDUmSkQUkSqU/qQwL7tT5LNPiYgoqKoarXB7ZaQkGGBJjBEdzrAopXe7mqzweGXB0dBQTJSIKCIpgxxmRMCJEsDJd0REwVZW2wmgvz9JksJ7kINicnI8YvVaOPq82N9mFx0ODcFEiYgiTldPHw4d7gEQ/qPBFYNL72SZu4ZERIE2eOJdpNBqJEzPNAFg+V04YqJERBGn0jfIYeK4WCTFGQRHMzx56QnQaSR09fahocshOhwiItUp9U+8i5xECWBpdjhjokREESfSyu4AwKjTIjctAQBQzfI7IqKAsjn6sM9XuhYpo8EVnHwXvpgoEVHEqWiInIl3g3HyHRFRcFTUWyHLwISkWKQkGEWHMyK8Syl8MVEioojjn3gXaYkSBzoQEQVFWYSW3QHA9AwTJAlotTnRanOKDocGYaJERBHF6ujzTwaKpNI7YFAdehMTJSKiQFIGOcyIwEQpzqBDdnI8APYphRsmSkQUUZTTmAlJsRgfHxmDHBRKonSwvQc2R5/gaIiI1KOsvhMAUBxh/UmKfJbfhSUmSkQUUZSyu0JLZIwFH2x8vAGZvksQdzbZBEdDRKQOh+0u1B7uBRB5JdkKDnQIT0yUiCiiVETgxLvBuBgSEQWW0p+UkxKPxFi92GBGqYAjwsMSEyUiiijlETrIQcH7MoiIAisSL5odShn2s7e1G44+j+BoSMFEiYgiRrfT7b8nI1ITJY6BJSIKLOVEaUaE9icBQJrJiOR4A7wysIul2WGDiRIRRYzqxv57MjLMMUg1RdY9GQqlvGJnkw1uj1dwNEREkU85USqO4BMlSZL8FQfcSAsfTJSIKGKU1ylld5E3yEFx0vg4xBu0cLm9/jHnREQ0Ok1dDrTYnNBqJBRaIjdRAgYqDliaHT6YKBFRxIjUi2YH02gkTOeuIRFRQJT6yu7y0hIQa9CKDWaMOOwn/DBRIqKIUdEQ2RPvFFwMiYgCQ+lPitT7kwYbfKLk9cqCoyGAiRIRRYgelxs1Ld0AIvtECeBAByKiQFH6k2ZEcH+SIiclHgadBnaXB7UdPaLDITBRIqIIUd1ohVcGUk1GpJtjRIczJvmDTpRkmbuGRESjIcvyoEEOSWKDCQCdVoNp6SYArDgIF0yUiCgiVNT3LxqRXnYHANPSTdBIQLvdhVabU3Q4REQR6dDhHnT19sGg1WBahkl0OAFRwB7WsMJEiYgigv+iWUvkTrxTxBq0yElNAABUcjEkIhqVUt9pUr7FDINOHW9p/aXZPFEKC+r4qSIi1VPDxLvBlPI7joElIhqdstpOAJF9f9JQXBvCCxMlIgp7jj4P9qhkkIOCk++IiMbGP8hBJesCAEzP7C8hbOhyoMPuEhwNMVEiorBX3WiFxysjOd6AzMTIHuSg4OQ7IqLR83hl/5URxVlJYoMJIHOMHieNjwPAU6VwwESJiMJehe/UpWhCIiRJEhxNYCgnSvvb7OhxuQVHQ0QUWfa2dqPH5UGcQYspvp5Ptcj3nSpxI008JkpEFPYq6pT+pMgf5KBINRmRkmCELAO7mmyiwyEiiiilvv6kogmJ0GrUsYGmKMjsLyVkoiQeEyUiCnvKxDs11aEDLL8jIhqtgfuT1LUuAJx8F06YKBFRWHO6Pdjd3H/iopZBDgoOdCAiGp2yuk4AwAwVXDQ7lJIo1bR0w+n2CI4muglNlFauXAlJko74yMjI8H9elmWsXLkSFosFsbGxOOuss1BZWSkwYiIKtV1NNri9MpLi9JiQFCs6nIBS6tDZsEtENHwutxfVjf0baGo8UbIkxsAco4PbK6PGN/GVxBB+olRYWIjGxkb/R3l5uf9zDz74INasWYN169Zh27ZtyMjIwKJFi2CzsZ6fKFoMLrtTyyAHRaFv13Bnkw0eryw4GiKiyLCryQaXx4ukuIEJcWoiSRLL78KE8ERJp9MhIyPD/5Gamgqg/zRp7dq1uPfee3HJJZegqKgIzz//PHp6erB+/frjPp/T6YTVaj3ig4giV0X9wMQ7tclOSUCMXoMelwcH2+2iwyEiigilStmdCjfQFBzoEB6EJ0p79uyBxWJBdnY2fvjDH2Lfvn0AgP3796OpqQmLFy/2f63RaMTChQvxxRdfHPf5Vq9ejcTERP9HVlZW0P8diCh4KnwnSkUW9SVKWo2EaRkc6EBENBJKf9JMFZbdKViaHR6EJkrz5s3DCy+8gP/85z945pln0NTUhPnz56O9vR1NTU0AgPT09CO+Jz093f+5Y1mxYgW6urr8H7W1tUH9dyCi4HG5vf7R2WqbeKco4GJIRDQiysS7mSoc5KAYXHonyyzNFkUn8sWXLFni/+cZM2bgtNNOw5QpU/D888/j1FNPBYCjjlRlWT7hMavRaITRaAxOwEQUUrub++vQzTE6ZI1X1yAHBSffERENX6/Lgz2+AQfFKk6U8tJM0GslWB1u1Hf2YuI49fViRQLhpXeDxcfHY8aMGdizZ49/+t3Q06OWlpajTpmISJ38ZXdqrkPnXUpERMNW2dAFj1dGmsmIjMQY0eEEjUGnQW5af8UBN9LECatEyel0orq6GpmZmcjOzkZGRgY2btzo/7zL5cKmTZswf/58gVESUahUNKjzotnBlB6lZqsT7d1OwdEQEYW30igou1MM9Clx2rMoQhOlX/3qV9i0aRP279+PL7/8EpdddhmsViuWLl0KSZJw++23Y9WqVXjjjTdQUVGB66+/HnFxcbj66qtFhk1EIVLum3hXqOJEKcGow+Tk/pIKLoZERCcWDYMcFP7S7MYuwZFEL6E9SnV1dbjqqqvQ1taG1NRUnHrqqdi6dSsmTZoEALjrrrvQ29uLm2++GR0dHZg3bx7ef/99mEwmkWETUQj0ebz+AQdqPlEC+svvDrT3oKqxC2fkpYgOh4gobJX7T5TUvS4ALM0OB0ITpZdeeumEn5ckCStXrsTKlStDExARhY2alm643F6YjDpMUuGFgoMVZJrx7/Im1qETEZ1AV28f9rX13zkXDaV3yolS7eFeWB19MMfoBUcUfcKqR4mISFHuG+RQYDFDo1HnIAdFvm8xZOkdEdHxKQN+ssbHYny8QXA0wZcUZ4DFN7BiJ9cHIZgoEVFYUhZEtZfdAQPlFTWt3XD0eQRHQ0QUnkr9/UlJQuMIpYH7lNinJAITJSIKS/5EKQrq0DPMMRgXp4fHK2NPc7focIiIwlJZra8/KQo20BQDAx1Ymi0CEyUiCjtuj9e/KBRa1L8gSpI0qPyOiyER0bEoJdnRdKLE0myxmCgRUdjZ12aHo8+LeIMWOSnxosMJCe4aEhEdX1u3E/WdvZCk6Kg0UCild7uabejzeAVHE32YKBFR2FHGv0bDIAfFQB06EyUioqGU+5OmpCYgwSh0aHNIZY2LQ4JRB5fbi32tdtHhRB0mSkQUdpTyiqJoqkO3DJTeybIsOBoiovBSWhs99ycNptFImJ7Rf38oL54NPSZKRBR2KhuiZ+KdYkpqAgxaDWxON+o6ekWHQ0QUVpQTpWga5KAY2Ehjn1KoMVEiorDi8cqo9JWfRdOJkl6rQV56AgD4//2JiAiQZXlgkENWkthgBPD3sHJtCDkmSkQUVva3daPH5UGsXospqQmiwwkpDnQgIjpaQ5cDbd0u6DSS//dkNPH3sLI0O+SYKBFRWKmo708SCixmaKNkkIOCI8KJiI5WVtsJAJiWYUKMXis2GAGmppugkYDDdhdabE7R4UQVJkpEFFb8gxwsUbxryPIKIiK/0rrouz9psJhBFRZcH0KLiRIRhZVonHinUE6U6jt70dXTJzgaIqLwUF7fCSD6Jt4NNrj8jkKHiRIRhQ2vV/bvlkXThYKKxFg9Jo6LBcDFkIgI6F8XyuqiczT4YPkc6CAEEyUiChsH2u3odrph1GmQG2WDHBTsUyIiGnCg3Q6bo39dmJpuEh2OMAVcG4RgokREYaPCt1OWn2mGThudv544+Y6IaIBymlRoMUMfpesCMLCJtr/dDrvTLTia6BG9P3FEFHYq/P1J0TfIQcGBDkREA0qVi2ajdJCDItVkRJrJCFkGdjbx4tlQYaJERGGj3LdzOCMKBzkolBOlmpZuuNxewdEQEYlVzv4kP5Zmhx4TJSIKC7Iso6IheifeKSaOi4XJqIPL48Xe1m7R4RARCeP2eP3rQrSfKAGcfCcCEyUiCguHDvfA5nDDoNUgLy16G3YlSUI+y++IiLCnpRuOPi9MRh1yUuJFhyNcASffhRwTJSIKC8r9SdMzTTDoovtXEwc6EBEBZb7+pKIJidBoJLHBhAGl9G5nkxUeryw4mugQ3e9GiChsVNT3JwXRXHan4BhYIiKglP1JR8hOiUeMXgNHnxcH2u2iw4kKTJSIKCz4J95ZuCAOrkOXZe4aElF0GhjkkCQ2kDCh1UiYnsHyu1BiokREwsmy7C+9i+aJd4rctAToNBI6e/rQ2OUQHQ4RUcg53R7sbOpPBniiNIADHUKLiRIRCVfX0Yuu3j7otRKmZiSIDke4GL0WuWn9/x1YfkdE0ai60YY+j4zx8QZMHBcrOpywwRHhocVEiYiEU8rupqabYNRpBUcTHvI53YiIoliZ/6LZREgSBzkoOPkutJgoEZFwyj0ZLLsbwMl3RBTNSmt9/UlcF44wPcMESQJabE602pyiw1E9JkpEJFy5b+JdIRdEP9ahE1E0K6/vBMBBDkPFG3WYnNx/pxTL74KPiRIRCSXLsr/0jidKA5TSu4PtPeh2ugVHQ0QUOnanGzUt3QCAmVlcF4biFRKhw0SJiIRq7HLgsN3lG3tqEh1O2Bgfb0CGOQYAsJOLIRFFkYr6LnhlIDMxBmmmGNHhhB1WHIQOEyUiEkoZC56XloAYPQc5DMbFkIiiURkvmj0hDnQIHSZKRCQUy+6Oj+UVRBSNyup50eyJKKXZ+9rscPR5BEejbkyUiEgof6LEncOjcEQ4EUWjwaPB6WjpZiPGxxvg8crY3WwTHY6qMVEiImFkWR6YeGfhgjiUUnq3s8kGt8crOBoiouDr7HHhYHsPAGDmhCSxwYQpSZJYfhciTJSISJhmqxNt3U5opIEyMxowaXwc4gxaON1e7G+ziw6HiCjolP6kyclxSIzTC44mfOVn9g8/Yg9rcDFRIiJhKvyDHEyINXCQw1CaQZMAuRgSUTRQyu5msD/phJSKA/awBhcTJSISRpl4VziBp0nHw8l3RBRNlBOlYvYnnVBBZv9/n+pGG7xeWXA06sVEiYiEqWzgxLtvoyyGrEMnomgwMBo8SWwgYS4nNR4GnQbdTjdqO3pEh6NaTJSISBjlRKmIidJxDZRXcLIREalbi9WBJqsDGgkoYqXBCem1GkxNTwDA8rtgGlWi1NzcjOuuuw4WiwU6nQ5arfaIDyKib9Nic6DZ6oTEQQ4nNC3dBI0EtHU70WJziA6HiChoSusG+lbjDDrB0YQ/Tr4LvlH9FF5//fU4dOgQ7r//fmRmZkKSpEDHRUQqV+kbCz4lNQHxRi6IxxNr0CI7JR57W+2oarAibVqM6JCIiIJiYJADqwyGw58o8UQpaEb17uSzzz7D5s2bMWvWrACHQ0TRwl92Z+Fp0rcpsCT2J0qNVpw1LU10OEREQcFBDiNTYGEPa7CNqvQuKysLsswJG0Q0euxPGj7lvgz2KRGRWsmy7D9R4iCH4ZnuWxsauhzo7HEJjkadRpUorV27Fvfccw8OHDgQ4HCIKFpU1nPi3XAN1KF3CY6EiCg46jp60dHTB71W8icAdGLmGD2yxscCYPldsIyq9O7KK69ET08PpkyZgri4OOj1R96cfPjw4YAER0Tq1N7tRENX/2CCApbefSvlv9H+Njt6XR5ezktEqlPqO03KzzTDqOPvuOEqyDSj9nAvqhqsmD8lRXQ4qjOqRGnt2rUBDoOIoolSdpeTEg9TjP5bvprSTDFISTCirduJXc02zMpKEh0SEVFAKf1JrDIYmfxMM/5T2czS7CAZcaLU19eHTz75BPfffz9ycnKCERMRqVylr/GU/UnDl59pwuY9TlQ1WJkoEZHqKP1JxexPGhFOvguuEfco6fV6vPHGG8GIhYiiRHmdMsiBZXfDpZTfVTWyT4mI1MXrlVHhuzJiZhY30EZCWRtqWmxwub2Co1GfUQ1z+MEPfoA333wzwKEQUbSoaODEu5HixYJEpFb72rrR7XQjVq9FbmqC6HAiyoSkWJhjdOjzyNjTwvK7QBtVj1Jubi4eeOABfPHFF5gzZw7i4+OP+Pytt94akOCISH067C7UdfQCAAotTJSGS0mUdjbZ4PXK0Gh40TcRqUNp7UCVgU47qj38qCVJEvIzzfhy/2FUN9q4rgbYqBKlv/zlL0hKSsLXX3+Nr7/++ojPSZLERImIjks5TZqUHIfEWA5yGK7slHgYdRr0uDw4eLgH2Snx3/5NREQRQOlPmjEhSWgckarA0p8oVTVYgTmio1GXUSVK+/fvD3QcRBQllDp0lt2NjE6rwfQME0rrulDVYGWiRESqUeabhFrM/qRRGRjowB7WQOP5JhGFVIVvQSxiecCIKU271ZxuREQq0efx+nsvZ3Li3ajkZyprgw2yLAuORl1GdaJ0ww03nPDzf/3rX0cVDBGpn3KHEu/KGLl8joElIpXZ1WSD0+2FOUaHyclxosOJSHnpCdBpJHT19qGhy4EJSbGiQ1KNUSVKHR0dR/y5r68PFRUV6OzsxDnnnBOQwIhIfbp6+nDocA8AjgYfDU6+IyK1US6anTkxCZLEITWjYdRpkZuWgJ1NNlQ1WJkoBdCoEqVj3aPk9Xpx88038xJaIjquSt8gh4njYpEUZxAcTeSZ7kuUmqwOHLa7MD6e/w2JKLKV13cCAGZMZJXBWBRYzP5EaVFBuuhwVCNgPUoajQZ33HEHHnnkkUA9JRGpDMvuxibBqMMkX2kK+5SISA2U0eDFTJTGpCCTPazBENBhDnv37oXb7Q7kUxKRilQ0cOLdWLH8jojUwtHnwa7m/ktSOchhbArYwxoUoyq9W758+RF/lmUZjY2NePfdd7F06dKABEZE6uOfeMdEadQKMs3YUNHExZCIIl5lgxUer4yUBCMyE2NEhxPRlGE/hw73wObogymG9xQGwqgSpR07dhzxZ41Gg9TUVDz88MPfOhGPiKKTzdGH/W12AECRhYMcRosjwolILZSLZmdOTOQghzEaF29AZmIMGrsc2NlkwymTx4sOSRVGlSh9/PHHgY6DiFSu0lcqZkmMQXKCUXA0kUvZNaxp6Yajz4MYvVZwREREo1Pun3jHKoNAKMg0o7HLgaoGKxOlABlVj9I555yDzs7Oox63Wq0cD05Ex8Syu8DITIxBUpwebq+MmpZu0eEQEY1aqe9EqZj9SQGhVBywhzVwRpUoffLJJ3C5XEc97nA4sHnz5jEHRUTqU8GJdwEhSRIHOhBRxLM5+rDPV47NE6XA4ECHwBtR6V1ZWZn/n6uqqtDU1OT/s8fjwXvvvYcJEyYELjoiUo1ynigFTH6mGV/sbediSEQRq7y+C7IMTEiKZTl2gCil2buabXB7vNBpAzrcOiqNKFGaNWsWJEmCJEnHLLGLjY3FY489FrDgiEgdup1u/84hE6Wx464hEUW6MvYnBdxJ4+MQb9DC7vJgX5sdU9NNokOKeCNKlPbv3w9ZlpGTk4OvvvoKqamp/s8ZDAakpaVBq2VjMREdqbrRClkGMswxSDVx53CsBk++k2WZ06KIKOIMDHJIEhuIimg0EvIzzdh+sANVDVYmSgEwokRp0qRJAACv1xuUYIhInZQFsWgCx4IHwpTUBBi0GtgcbtR19CJrfJzokIiIRmRgkANPlAJJSZSqG624eDbbYcZq1MWLL774Ik4//XRYLBYcPHgQAPDII4/grbfeClhwRKQOnHgXWAadBrlpCQBYfkdEkae924m6jl4AQBETpYDyT77j2hAQo0qUnnzySSxfvhzf/e530dnZCY/HAwAYN24c1q5dG8j4iEgFKho48S7QOAaWiCJVmW/zLCc1HuYYveBo1GXwVFRZlgVHE/lGlSg99thjeOaZZ3Dvvfce0ZM0d+5clJeXjyqQ1atXQ5Ik3H777f7HZFnGypUrYbFYEBsbi7POOguVlZWjen4iEqPH5fbf98MTpcDhQAciilRltb7+JK4JATctwwSNBLTbXWixOUWHE/FGlSjt378fs2fPPupxo9EIu90+4ufbtm0bnn76acycOfOIxx988EGsWbMG69atw7Zt25CRkYFFixbBZrONJmwiEqC60QavDKSajEg3x4gORzWUMbDVTJSIKMKU13cC4CCHYIjRa5GTytLsQBlVopSdnY2SkpKjHt+wYQPy8/NH9Fzd3d245ppr8Mwzz2DcuHH+x2VZxtq1a3HvvffikksuQVFREZ5//nn09PRg/fr1owmbiATw9ydZOMghkJQTpbqOXnT19gmOhohoeGRZRqlvwE9xFk+UgoGXkgfOqBKlO++8E7fccgtefvllyLKMr776Cr///e+xYsUK3HXXXSN6rltuuQUXXHABzjvvvCMe379/P5qamrB48WL/Y0ajEQsXLsQXX3xx3OdzOp2wWq1HfBCROMpFs+xPCqzEOD0mJMUC4KkSEUWOJqsDrTYntBoJBZlcF4KBAx0CZ0TjwRU//vGP4Xa7cdddd6GnpwdXX301JkyYgMceewwLFiwY9vO89NJL+Oabb7Bt27ajPtfU1AQASE9PP+Lx9PR0/5S9Y1m9ejV++9vfDjsGIgouTrwLngKLGfWdvahutOLUnGTR4RARfatSX3/S1HQTYg28ezMYWJodOKMeD/7Tn/4UBw8eREtLC5qamvDVV19hx44dyM3NHdb319bW4rbbbsPf//53xMQcv29h6EWK33a54ooVK9DV1eX/qK2tHd6/EBEFnKPPgz0c5BA0+SyvIKII4+9P4poQNErp3f42O3pcbsHRRLYRJUqdnZ245pprkJqaCovFgkcffRTjx4/H448/jtzcXGzduhV//etfh/VcX3/9NVpaWjBnzhzodDrodDps2rQJjz76KHQ6nf8kSTlZUrS0tBx1yjSY0WiE2Ww+4oOIxKhutMLjlZEcb0BmIgc5BBon3xFRpCnz9SfNZH9S0KSajEg1GSHLwM4mDkAbixElSr/+9a/x6aefYunSpRg/fjzuuOMOfO9738PmzZvx73//G9u2bcNVV101rOc699xzUV5ejpKSEv/H3Llzcc0116CkpAQ5OTnIyMjAxo0b/d/jcrmwadMmzJ8/f2T/lkQkRIXvpKNoQuIJT4JpdAp9deh7mrvR5/EKjoaI6MRkWfYnSsWceBdUHOgQGCPqUXr33Xfx3HPP4bzzzsPNN9+M3NxcTJ06dVSXzJpMJhQVFR3xWHx8PJKTk/2P33777Vi1ahXy8vKQl5eHVatWIS4uDldfffWIX4+IQq+iTulP4sluMEwcFwuTUQeb0429rd2YnsH/zkQUvg6296Crtw8GnQbTMkyiw1G1/EwzNu1uZZ/SGI0oUWpoaEBBQQEAICcnBzExMbjxxhuDEhgA3HXXXejt7cXNN9+Mjo4OzJs3D++//z5MJv7lIooEnHgXXJIkIT/TjK8OHEZVg5WJEhGFtdK6TgD9px167ajb5GkYOPkuMEaUKHm9Xuj1ev+ftVot4uPjAxbMJ598csSfJUnCypUrsXLlyoC9BhGFhtPtwe7m/tpoDnIIngLLQKJ0ycmioyEiOr5ypT9pIteEYFNK73Y22uDxytBqWP4+GiNKlGRZxvXXXw+j0QgAcDgcuOmmm45Kll5//fXARUhEEWlXkw1ur4ykQff9UOApi2F1E3cNiSi8+Qc5sD8p6LJT4hGj16C3z4OD7XbkpCaIDikijShRWrp06RF/vvbaawMaDBGpR0V9/xv3GRzkEFSDR4R/2/UJRESieLwyKhqUQQ48UQo2rUbCtAwzSms7UdVoZaI0SiNKlJ577rlgxUFEKqP0JxVauCAGU156ArQaCR09fWiyOpCZyNM7Igo/NS3d6HF5EG/Q8k17iBRk+hKlBiu+N9MiOpyIxE46IgqKCg5yCIkYvRa5vjcdHANLROFKGeRQOCGR/TIhwoEOY8dEiYgCzuX2YpfvkjsmSsGXn9k/CZRjYIkoXJXXsewu1Aq4NowZEyUiCrjdzTa4PF6YY3TIGs9SsGDjriERhbsy34kSBzmEzrQMMyQJaLY60dbtFB1ORGKiREQBp5TdFXGQQ0gUZPbv0LL0jojCkcvtRXVjf5VBMROlkEkw6jA5uX8yNU+VRoeJEhEFnDLZiGV3oaGU3h083INup1twNERER9rZZIXL40VSnJ5VBiHG0uyxYaJERAFX7hsNXshEKSSSE4xINxshy8Au3qdERGGmtG5g84xVBqFVMOgKCRo5JkpEFFB9Hq9/54onSqHDxZCIwlW5rz+JZXehxx7WsWGiREQBVdPSDZfbC5NRh0nj40SHEzW4GBJRuCrznSjN5MS7kFN6WPe22uHo8wiOJvIwUSKigFIumi2wmKHhXRkhk6+cKPkapomIwkGPy43dzb5BDllJYoOJQulmI8bF6eHxytjT3C06nIjDRImIAqqSF80KoZTe7Wy0wu3xCo6GiKhfZYMVXrn/DXu6OUZ0OFFHkqRBFQddgqOJPEyUiCigygeNBqfQmZQcjziDFk63Fwfa7aLDISICMFB2N2NCkthAohh7WEePiRIRBYzb4/X3yDBRCi2tRsL0jP4xsCy/I6JwUeYf5MA1QRSlNLuaa8OIMVEiooDZ12aHo8+LeIMWOSnxosOJOvncNSSiMOMf5MD+JGEGD/vxemXB0UQWJkpEFDDldRzkIBIn3xFROOnq7cP+tv5S4JmsMhBmSmoCDFoNup1u1HX0ig4nojBRIqKAYX+SWKxDJ6JwomyenTQ+DuPiDYKjiV56rQZTMxIAcKDDSDFRIqKAqWzgxDuRpmWYIElAW7cTLTaH6HCIKMqV1XcCAGawP0m4/AxeITEaTJSIKCA8XhmVDRzkIFKcQYdsX28Ym3aJSLSy2v7NMw5yEM9fms2KgxFhokREAbG/rRs9Lg9i9VpMSU0QHU7UYvkdEYULZeLdzIlJQuOggbWhmj2sI8JEiYgCoqK+/5dvgcUMLQc5CKPsGnIxJCKRWm1ONHQ5IEmsMggH+b61ob6zF109fYKjiRxMlIgoIPyDHHy/jEkM/4hwJkpEJJBympSbmoAEo05sMARzjB4Tx8UC4PowEkyUiCggKjjxLiwU+hKlfa3d6HV5BEdDRNFKuT+JgxzCRwE30kaMiRIRjZmXgxzCRqrJiJQEA7wysKuZAx2ISAzlRKmY/UlhgwMdRo6JEhGN2YF2O7qdbhh1GuSlcZCDSJIk+cvv2KdERCLIsuw/UZrJE6WwwbVh5JgoEdGYVfh2p/IzzdBp+WtFNE6+IyKR6jt70W53QacZ2Lgh8ZS1YU+LDS63V3A0kYHvaIhozAb6k7gghgN/eQV3DYlIAOU0aVqGCTF6reBoSDFxXCxMMTr0eWTUtHSLDiciMFEiojErV5p22Z8UFpRdw52NVni9suBoiCjaDJTdJYkNhI4gSRLvUxohJkpENCayLKOigRPvwkl2SjwMOg3sLg8OHe4RHQ4RRZmBQQ5cE8INr5AYGSZKRDQmhw73wOZww6DVIC/NJDocAqDTajA9o///BRdDIgolr1f2VxnwRCn8cPLdyDBRIqIxUS6anZ5pgkHHXynhggMdiEiE/e122HxTUKemcwpquBl8l5IsszT72/BdDRGNSUU9708KRxwDS0QiKGV3hRZOQQ1HeekJ0GkkdPX2obHLITqcsMefYCIaE//EOwsTpXDCyXdEJAIHOYQ3o06LXN99h6w4+HZMlIho1AYPcuDEu/Ci9Cg1djnQYXcJjoaIooWSKBVncU0IVwUc6DBsTJSIaNTqOnrR2dMHvVbC1AzWoocTU4wek5LjALD8johCw+3xorKBJ0rhTqk44Nrw7ZgoEdGoKWV3U9NNMOp4qWC4yc/griERhc7u5m44+rwwGXXITo4XHQ4dB0eEDx8TJSIaNZbdhTeOgSWiUCqv7wTQP9xHo5HEBkPHpSRKB9t7YHP0CY4mvDFRIqJRK/dNvCtkohSWWIdORKFUqgxyYH9SWBsfb0BmYgwAYGeTTXA04Y2JEhGNiizL/tI7niiFp3zfiVJNSzecbo/gaIhI7ZTR4MXsTwp7vEJieJgoEdGoNHY5cNjuglYj+SesUXixJMYgMVYPt1fGnuZu0eEQkYo5+jzY2dh/OjFzIjfPwh0vJR8eJkpENCrlvtOkvLQExOg5yCEcSZLE8jsiConqRivcXhnJ8QZMSIoVHQ59C961NzxMlIhoVFh2Fxk4BpaIQkHZPJsxMRGSxEEO4U7ZRNvVZIPb4xUcTfhiokREo1IxaFGk8JXP8goiCoHSWt6fFElOGh+HeIMWTrcX+9vsosMJW0yUiGjEZFkemHhnYaIUzgaX3smyLDgaIlKrgUEOXBMigUYjYTpLs78VEyUiGrEWmxNt3U5opIE34hSectMSoNdKsDncqOvoFR0OEalQt9ONmtb+gTE8UYocHOjw7ZgoEdGIlfvuyshNS0CsgYMcwplBp0FuWv9UQvYpEVEwVNR3QZb7J22mmoyiw6FhyueJ0rdiokREI6Y07RZxkENE4OQ7IgomZfOMPauRxT/5roGl2cfDRImIRqyygRPvIsngxZCIKNBKff1JLLuLLNPSTdBIQLvdhVabU3Q4YYmJEhGNGE+UIotyolTdxESJiAKvzHeiVMxEKaLEGrTISU0AwIqD42GiREQj0mJzoNnqhMRBDhFD+f9Ue7gXXb19gqMhIjXpsLtw6HAPAFYZRCL2KZ0YEyUiGpFK31jwKakJiDfqBEdDw5EYp8eEpFgAwE4uhkQUQGW+CoPJyXFIjNMLjoZGipPvToyJEhGNiL/szsLTpEjCXUMiCoZy9idFNH8PK9eGY2KiREQjwv6kyFSQyRHhRBR4pb7+pJmceBeR8n1rw/42O3pcbsHRhB8mSkQ0IpX1nHgXibhrSETBUOY7USrOShIaB41OmikGKQlGyDKwq8kmOpyww0SJiIatvduJhi4HgIE33hQZCjL7E9vdTd3o83gFR0NEatBs7R/uo5GAQq4JEYsbacfHRInCXovNgb9s3ocWq0N0KFFPKbvLSYmHKYZNu5Fk4rhYmIw6uDxe7Gu1iw6HiFRAGQuel2ZCnIHDfSKV/woJJkpHYaJEYe1Amx2XPPEFfvduNZY+tw2OPo/okKJapW8qTiHL7iKORiNhuq8WvaqxS3A0RKQGZf5BDlwTIpnSp8TJd0djokRhq6rBisv+vAV1Hb0A+nc6HninSnBU0a28TulPYolFJOIYWCIKJP8gB/YnRTSlbHJnkw0eryw4mvDCRInC0vYDh3Hl01vQ1u1EfqYZa64oBgD848tDeKesQXB00auigRPvIhnr0IkoUGRZHhjkwBOliJadkoAYvQY9Lg8OtrM0ezAmShR2PtnVgmuf/RI2hxtzJ43DS/99Ki45eSJuPmsKAOCe/yvnX2QBOuwu/+leoYWLYiTK99eh2yDL3DUkotGrPdyLzp4+GLQaTMswiQ6HxkCrkTAtXblCgpPvBmOiRGHlX6UNuPH57XD0eXHWtFS8+JN5SIztHxqwfNFUnDJ5HLqdbtyy/hs43exXCiXlNGlScpz//wlFlqnpJmg1Eg7bXWi2OkWHQ0QRrKy+EwAwPdMEo04rNhgas4GKA/awDsZEicLGP748iFtf2gG3V8aFxRY8fd1cxBoGfvnqtBo8etVsjIvTo6LeitX/3ikw2uhTUd9frsWyu8gVo9diSmo8AC6GRDQ2ZbxoVlXYw3psTJRIOFmW8fjHNbj3jQrIMnDtqSdh7ZWzYNAd/eOZmRiLNVfMAgD87YsDeK+iMcTRRq8K32jwIpbdRbSCQeV3RESjVVrbCQCYOTFJaBwUGMqJEteGIzFRIqFkWcbqDTvx0H92AQB+cU4uHrioCFqNdNzvOXt6Gn52Zg4A4M7XylB7uCcksUY75Q6lGTxRimj53DUkojHyeGX/5lkxEyVVmJbRvzY0WR1o72ZptoKJEgnj9nhx9/+V4elP9wEA7rsgH79cPA2SdPwkSfGr/5qG2SclweZwY9n6b+Bye4MdblTr6unDIV9CWsTR4BGNk++IaKz2tXbD7vIgVq9FblqC6HAoABKMOkxOjgPAU6XBmCiREE63B8vW78Ar2+ugkYAHL5uJGxfkDPv79VoNHrtqNhJj9Sit68KD77FfKZgqfYMcJo6LRVKcQXA0NBbKidKBdjvsTrfgaIgoEin9SUUTzCesAKHIwoEOR2OiRCFnd7pxw9+24b3KJhi0GjxxzRxcMTdrxM8zcVwcHrpsJgDgL5/txwdVzYEOlXxYdqceKQlGpJmMkOX+ywWJiEZKuT+J/Unqkp/BPqWhmChRSHXYXbjmL1/i85p2xBm0eO7Hp+D8ooxRP9/iwgzccHo2AOCXr5aivrM3UKHSIBUNnHinJiy/I6KxKOXEO1Xyrw3sYfVjokQh09TlwBVPbUFJbSeS4vRY/9NTcXpuypif954l01E8MRFdvX34xfpv0Odhv1Kg+SfeMVFSBY6BJaLRcrm9/k0WDnJQFyVRqmnthqOPd1UCghOlJ598EjNnzoTZbIbZbMZpp52GDRs2+D8vyzJWrlwJi8WC2NhYnHXWWaisrBQYMY3WgTY7LvvzF9jT0o0Mcwxe/dlpmJWVFJDnNug0WHf1yTDF6PDNoU788f1dAXle6mdz9GF/mx0AUGThIAc1GBgDy0SJiEZmd7MNLrcX5hgdJvma/0kdMswxGBenh8cro6alW3Q4YUFoojRx4kT84Q9/wPbt27F9+3acc845uOiii/zJ0IMPPog1a9Zg3bp12LZtGzIyMrBo0SLYbKydjCTVjVZc9uctqOvoxeTkOLx602nISzcF9DWyxsfhwUv7+5We2rQPH+9sCejzR7NK36mDJTEGyQlGwdFQICgDHXY2WeHxyoKjIaJIMnDRbNKwptRS5JAkiVdIDCE0Ubrwwgvx3e9+F1OnTsXUqVPx+9//HgkJCdi6dStkWcbatWtx77334pJLLkFRURGef/559PT0YP369SLDphHYfuAwrnhqC9q6ncjPNOPVm+Yja3xwdqCWzMjEj06bBABY/koJGrvYrxQILLtTn8nJ8YjVa+Ho8/pPC0kcr1fGxqpmVNR3QZaZuFJ4GxjkwDVBjfyl2aw4ABBGPUoejwcvvfQS7HY7TjvtNOzfvx9NTU1YvHix/2uMRiMWLlyIL7744rjP43Q6YbVaj/ggMT7Z1YJrn/0SNocbcyeNw0v/fSpSTcE9kfj1d/NRaDGjo6cPt/5zB9zsVxqzCk68Ux2tRsL0zP5TXS6G4v3pwz346Qvb8b3HPsMZ/+9j/OatCnxe08Z+SwpLpYNOlEh9ONDhSMITpfLyciQkJMBoNOKmm27CG2+8gYKCAjQ1NQEA0tPTj/j69PR0/+eOZfXq1UhMTPR/ZGWNfOw0jd2/Shtw4/Pb4ejz4qxpqXjxJ/OQGKsP+uvG6LV4/OqTkWDUYduBDqz9YE/QX1PtynmipEpKeQX7lMQqqe3Euo9rAPT3W9Z39uL5LQdxzV++xJwHNuK2l3bgnbIG2Bx9giMlAnpdHuxu7m9/KM7imqBGg9cGnnCHQaI0bdo0lJSUYOvWrfj5z3+OpUuXoqqqyv/5ofWvsiyfsCZ2xYoV6Orq8n/U1tYGLXY6tn98eRC3vrQDbq+MC4stePq6uYg1aEP2+pNT4rH6khkAgMc/qcHmPa0he2216Xa6sU8Z5MBESVU4+U68XpcHy18ugcf3u7L0fxbjmR/NxRVzJyI53gCrw423ShqwbP0OzHngAyz961f4+9aDaLY6RIdOUaqqsb+vMSXBiAxzjOhwKAimpCbAoNXA5nSjroMtDDrRARgMBuTm5gIA5s6di23btuFPf/oT7r77bgBAU1MTMjMz/V/f0tJy1CnTYEajEUYjG85FkGUZT3yyFw/9p3/q3LWnnoTffr9IyK3dFxZbsGVfO9Z/eQi3v1SCDbctQBp/qY9Y/45S/yScYJdNUmjxLiXxVm+oxr42O9LNRjxwUSFiDVosKkjHooJ0eLwyvjnUgY1VzdhY1Yz9bXZs2t2KTbtbcd+bFSjOSsJi39fmpSWwqZ5CQulPKp6YyJ85lTLoNMhLT0BlgxWVDdag9ZVHCuEnSkPJsgyn04ns7GxkZGRg48aN/s+5XC5s2rQJ8+fPFxghHYssy1i9Yac/SfrFObl44CIxSZLif75XgOkZJrTbXbjtpRJO9xqF8jql7I5jwdVmeoYJkgS02pxotTlFhxN1Nu1uxQtbDgIA/nh5MZLiDEd8XquRcMrk8fj1d/Px0S8X4oPlZ+Ku86f5r1Uore3EQ//ZhcWPfIqz/vgJfv9uFb7af5i/5yioytifFBUKWJrtJ/RE6de//jWWLFmCrKws2Gw2vPTSS/jkk0/w3nvvQZIk3H777Vi1ahXy8vKQl5eHVatWIS4uDldffbXIsGkIt8eLX79Rjle21wEA7rsgHzcuyBEcla9f6ZqTceFjn2HLvnY8+uEe3LFoquiwIgon3qlXnEGH7OR47Guzo7rRilRTquiQokZnjwt3vloKAFh62iQsyDvxf3tJkpCbZkJumgk3n5WLFqsDH1S3YGNVEz6vacfB9h48s3k/ntm8H+PjDThnehoWFaTjzLzUkJY9k/qVKhPv2J+kavmcfOcnNFFqbm7Gddddh8bGRiQmJmLmzJl47733sGjRIgDAXXfdhd7eXtx8883o6OjAvHnz8P7778NkCuwdPDR6TrcHt/2zBO9VNkEjAX+4dCaumBs+AzSmpCZg1Q9m4PaXS/DoR3swL3s85uemiA4rYlQ0+BIlCxdFNcq3mLGvzY6qRivOnMpEKVTue7MCLTYnclLjcc+S/BF/f5o5BlfPOwlXzzsJ3U43Pt3dio1VzfhoZwsO21147es6vPZ1HWL0GpyRm4rFBek4Nz+N96DRmFgdfdjX2t+zOpObZ6rGyXcDhCZKzz777Ak/L0kSVq5ciZUrV4YmIBoRu9ON/35xOz6vaYdBq8GjV83G+UUZosM6ysWzJ+CLvW14ZXsdbnu5BP++dQH7bYahx+X238w9g/dlqFJBphnvljVyMQyht0rq8U5ZI7QaCY9cMWvMJz4JRh2+OyMT352RiT6PF9v2H8b7vr6m+s5efFDdjA+qmyFJwNxJ43w9UBnITokP0L8RRQulwmBCUiyTbpVTTpTqO3vR1dOHxLjgTy0OV8KHOVBk6rC78OO/bUNJbSfiDFo886O5OD2MT2p++/0ilNR2YndzN+54uQQv3PAdaAT2T0WC6kYbvDKQajIinYMwVIl16KHV2NWL+9+sANDfx1ns6zcKFL1Wg/m5KZifm4LfXFiA6kYbNlY14/2qJlQ2WLHtQAe2HejAqn/vRG5agn8YRPHEJP4+pG+l9CdxLLj6JcbqMXFcLOo6elHdZMWpOcmiQxKGiRKNWFOXA9c9+yX2tHQjKU6Pv/34O/4G43AVa+i/X+n76z7HZzVteOKTGiw7J090WGHN359k4SAHtVLKK/a2dsPR50GMnv0sweL1yrjz1TJYHW4UT0zELWfnBvX1JElCgcWMAosZt52X13+65Dtp2rqvHTUt3ahp6cYTn+xFmsmIc/PTsbgwHfOnJMOo488BHU2ZeMdBDtEhP9OMuo5eVDUwUSIatgNtdlz77Jeo6+hFhjkGL/7kO8hLj4yesbx0E/73okLc+VoZ1mzcjVMmj8e8KP7L/22Ui2ZnsBZdtdJMRiTHG9Bud2FXky3gJxw04IUtB/BZTRti9BqsuXIW9NrQDp2dkBSLpfMnY+n8yejq7cMnu1rwflUzNu1qRYvNiX9+dQj//OoQ4g1aLJyWikUF6ThnWnpUl9zQkUprlYl3XBOiQUGmGRurmqN+oAMTJRq26kYrrnv2K7R1OzE5OQ4v/mRexM3Xv3xuFrbsa8fr39Tj1pd24N+3LmCt9XFw4p36KacOm/e0obrRykQpSGpaurF6w04AwIol+ZiSmiA0nsRYPS6aNQEXzZoAp9uDLXvbsbGqv5ep2erEv8ub8O/yJmg1EuZlj/ff7TRxXGT9vqfAae92or6z//JRbp5FB6XiINpLs5ko0bBsP3AYP/7bNtgcbuRnmvHCDd+J2IEID1xUhNLaTuxttWP5K6V47vpTWJ8/hKPPgz2+QQ5MlNQtP7M/UYr2XcNg6fN4sfyVEjjdXizIS8F1p04SHdIRjDotzpqWhrOmpeGBi4pQXt+F96uasLGqGbubu/HF3nZ8sbcdv/1XFQoyzf6kqdBi5oWjUaTMt3GWkxoPUwxPGaOB0sO6p7kbLrcXBl3YXb0aEkyU6Ft9sqsFN/39azj6vJg7aRyevf4UJMZG7i/KeKMOj19zMi5a9zk27W7FU5/uw8/PmiI6rLBS3WiFxysjOd6AzEQOclAzZTHk5LvgWPdRDcrqupAYq8dDlxWH9aaMRiOhOCsJxVlJuPO/puNgu71/GERlM7YfPIyqRiuqGq3404d7MCEp1p80fSd7fMhLCSm0ynxld8XsT4oaE8fFwmTUweZ0Y29rt38SXrRhokQn9K/SBix/pQR9HhlnTUvFk9fMUcUFhtMzzFj5/UKseL0cf3x/F06ZPA5zJ48XHVbYqPC9aS6akMhdY5UbXF7h9cph/UY+0pTUdmLdxzUAgAcuLkJGhG06TEqOx40LcnDjghy0dzvx0c4WbKxqxqd7WlHf2Yu/fXEAf/viAMwxOpw9PQ2LCzKwcFoqEox8a6E2A4McWGEQLSRJQr7FjK/2H0ZVg5WJEtFQ//jyIO57swKyDFxYbMHDlxer6uj1h6dkYcvedrxd2oBb/7kD7966AOPiDaLDCgsVdUp/UnT+YowmOSnxMOg0sLs8qO3owaRk3q8TCL0uD5a/XAKPV8aFxRZ8v9giOqQxSU4w4vK5Wbh8bhZ6XR58VtOGjVVN+LC6Be12F94qacBbJQ0waDU4bUqy/7SJVwtEPlmWUVqnDHJIEhsMhVRBZn+iFM19SkyU6CiyLOOJT/biof/sAgBce+pJ+O33i6BV2U6zJElYdckMlNd3YX+bHXe+VopnfjSXJyjgxLtootNqMC3dhPL6LlQ1WJkoBcjqDdXY12ZHutmIBy4qFB1OQMUatP5EyOOVseNQh/+S2/1tdmza3YpNu1tx35sVKM5K8t/XlJeWwN+vEaixy4G2bie0GgmFvC4iqvhLs6M4UVLP8QAFhCzLWL1hpz9JWnZ2Lh64SH1JkiLBqMO6q2fDoNPgg+oWPPvZftEhCed0e7C72QYAKLQwUYoGXAwDa9PuVryw5SAA4I+XFyMpTr0n1VqNhLmTx+PX383HR79ciA+Wn4m7zp/mv1uvtLYTD/1nFxY/8inO/uMn+P27Vfhq/2F4vLLYwGnYlItmp6abeNdalFFKs6sarZDl6Pw7yxMl8nN7vPj1G+V4ZXsdAOC+C/Jx44IcwVEFX6ElEfd/rwD3v1mBP2zYiTmTxmH2SeNEhyXMriYb3F4ZSXH9N3OT+nEMbOB09rhw56ulAIClp03CgrxUwRGFjiRJyE0zITfNhJvPykWL1YEPqluwsaoJn9e040B7D57ZvB/PbN6P8fEGnDs9DYsK0rEgL1UVva9qpfQnFbM/KerkpiVAp5HQ2dOHJqsDmYnR956AiRIB6D9FuO2fJXivsgkaCfjDpTNxxdws0WGFzLXzTsLWve14t7wRy9b3368UrRctVtT3v1mewUEOUSOfk+8C5r43K9BicyInNR73LMkXHY5QaeYYXD3vJFw97yR0O934dHcrNlY146OdLThsd+HVr+vw6td1iNFrcEZuKhYXpuPc6Wm82y7MlLE/KWrF6LWYkpqAXc02VDVYmShRdLI73fjvF7fj85p2GLQaPHrVbJxflCE6rJCSJAmrL+3vVzp0uAd3vlaKp66bE5WJgtKfxLK76DE90wQAaOhyoMPu4lCTUXqrpB7vlDVCq5HwyBWzeEoySIJRh+/OyMR3Z2Siz+PFtv2H/X1N9Z29+KC6/8JbjQTMmTTO1wOVgewU9syJJMsyJ95FuQKL2Z8onZufLjqckGOPUpTrsLtwzV++xOc17YgzaPHcj0+JuiRJYY7RY93Vs6HXSni/qhl/++KA6JCEqOAgh6hjjtHjpPFxAFh+N1qNXb24/80KAMAvzslFsa9Hh46m12owPzcFK79fiM/uPhv/vnUB7jhvKgotZnhlYNuBDqz6906c/cdPsGjNJjz43k6U1HbCy76mkDvQ3gOrww2DToNpGSbR4ZAA0d7DyhOlKNbU5cB1z36JPS3dSIrT428//o6/ATdazZyYhF9/Nx+//VcVVv27GnMmjYuqcgOX24tdTf2DHJgoRZeCTDMOHe5BVaMV83NTRIcTUbxeGXe9Vgarw43iiYm45exc0SFFDEmSUGAxo8Bixm3n5fWfLvlOmrbua8eelm7saenGE5/sRZrJiPN8E/TmT0mGUccTu2BTTpMKMs28VDhKRXsPKxOlKHWgzY5rn/0SdR29SDcb8fefzENeOneLAOD6+ZOxdV87/lPZjGXrd+CdW8+AOSY6+pV2N9vg8nhhjtEha3z01SJHs/xMM96rbIraXcOxeGHLAWze04YYvQZrrpzFN5RjMCEpFkvnT8bS+ZPR1duHT3a14P2qZmza1YoWmxPrvzyE9V8eQrxBi7Om9Q+DOCc/LWp+R4ea0p/EQQ7RS+lhPdDeg26nO+oulI6uf1sC0L8rcN2zX6Gt24nJyXF48SfzkOUru6H+Hc4HLy1GZcNmHDrcgxX/V451V8+Oin4lpeyuiIMcoo5/DCwHOoxITUs3Vm/YCQBYsSQfU1ITBEekHomxelw0awIumjUBTrcHW/a2Y2NVfy9Ts9WJd8sb8W55IxJj9VixZDqumJsFjUqvshBloD8pSWgcJM74eAMyzDFosjqws9GKuZPHiw4ppLjtFWW2HziMK57agrZuJ/IzzXj1pvlMko4hMU6Px66aDZ1Gwrvljfj7l4dEhxQSFQ3sT4pWSqK0t7UbLrdXcDSRoc/jxfJXSuB0e7EgLwXXnTpJdEiqZdT1nyD9/gczsOWec/HWLafjlrOnIDslHl29fbjn9XJc8dQWf+kwjZ3b4/VPQS3O4poQzaK5/I6JUhT5ZFcLrn32S9gcbsydNA4v/fepSDVxDOvxzD5pHO5ZMh0A8MA7Vaj0JRFqVu5bFAuZKEUdS2IMzDE69Hlk7Gnhm83hWPdRDcrqupAYq8dDlxXzNCNENBoJxVlJuPO/pmPjHWfivgvyEWfQYvvBDlzw6Gas3lCNHpdbdJgRb2+rHb19HsQbtMhO4UlpNMv3TUaNxtJsJkpR4l+lDfjpC9vh6PPirGmpePEn85AYy5rub/OTM7Jx7vQ0uNxeLFu/A91O9S6+fR6vf7eIJ0rRR2mqB1h+NxwltZ1Y93ENAOCBi4uQkRgjOKLopNNqcOOCHHywfCH+qzAdbq+Mpzbtw6I1n+Kjnc2iw4topb6yu6IJidByEyCqFWT2vyeIxrWBiVIU+MeXB3HrSzvQ55FxYbEFT183l/d7DJMkSfjj5cWwJMZgf5sdv369HLKszhG1NS39JVcJRh0msRwzKvkXwyjcNRyJXpcHy18ugcfb/zv1+8UW0SFFPUtSLJ66bi7+8qO5mJAUi/rOXtzwt+246cWv0djVKzq8iKT0J3HUPSmbaDubbHB7oqs0m4mSismyjMc/rsG9b1RAloFrTz0Ja6+cBYOO/9tHYly8AY9dPRtajYS3Sxvw0rZa0SEFxcBFs2aWEEWpaK5DH4nVG6qxr82OdLMRD1xUKDocGuS8gnRsXH4mfrYwB1qNhPcqm3Dew5vw7Gf7o+4N3lgpE+940SxNGh+HOIMWTrcXB9rtosMJKb5jVilZlrF6w0489J9dAIBlZ+figYuKeHw+SnMmjcevFk8DAKx8uxI7m9T3RrKSF81GPX8deoNVtSenY/Xp7la8sOUgAOCPlxcjKc4gOCIaKs6gw4ol+Xj31jMwZ9I42F0ePPBOFS56/HOU1HaKDi8iON0e/4ZJMSfeRT2NRsJ034XDlVFWfsdESYXcHi/u/r8yPP3pPgDAfRfk41f/NY3jnsfoZ2fm4KxpqXC6vbjlH9/ArrJ+pfJBo8EpOuWlmaDXSrA63KjvZLnSUJ09Ltz5WikAYOlpk7AgL1VwRHQi0zPMePVnp2H1JTOQGKtHZYMVP3jic9z/ZgWsjj7R4YW1XU029HlkjIvTY+I43qlHg66QiLKKAyZKKuN0e7Bs/Q68sr0OGgl48LKZuHFBjuiwVEGjkfDw5cVINxuxt9WO+9+qEB1SwLg9Xv8vPyZK0cug0yA3rX/XsLqRk++Guu/NCjRbnchJjcc9S/JFh0PDoNFIuOo7J+HDXy7EJbMnQJaBF7cexLkPb8LbpQ08OT2OUl/Z3YyJSdxkJQADPazRtjYwUVIRu9ONn/xtO96rbIJBq8ET18zBFXOzRIelKskJRjz6w9nQSMDr39Tj1e3q6Ffa12aHo8+LeIMWOSnxosMhgQaX39GAt0rq8U5ZI7QaCY9cMYsDcSJMSoIRa66chfU/nYeclHi02py49Z878KO/foUDbdHVczEcZb4SxWL2J5FPtK4NTJRUosPuwjV/+RKf1bQhzqDFcz8+BecXZYgOS5Xm5SRj+aKpAID/easSe5ojf3el3Ld7WMBBDlGvIFMpr1D/vWHD1djVi/vf7D9B/sU5uZwCFsHmT0nBhtsXYPmiqTDoNNi8pw2L136Kxz7cA6fbIzq8sDEwyCFJbCAUNqZnmKGRgLZuJ1psDtHhhAwTJRVo6nLgiqe2oKS2E0lxeqz/6ak4PTdFdFiqdvNZuViQl4LePg9uWf8Nel2RvcCyP4kU0VqHfjxer4y7XiuD1eFG8cRE3HJ2ruiQaIyMOi1uPTcP/7n9TJyRmwKX24uHN+7Gkj9txpa97aLDE67H5fZfOs2Jd6SINWiR7as4iaZTJSZKEe5Amx2X/fkL7GnpRrrZiFd/dhpmcbcz6DQaCWuumIVUkxG7m7vxm7cju1+psoET76ifcqJUe7iXDe8AXthyAJv3tCFGr8GaK2dBr+WyqRbZKfF48SffwZ9+OAspCUbsa7Xjqme2YvkrJWjvdooOT5jKBiu8MpBuNiLdzIuUaUCBJfr6lPgbP4JVN1px2Z+3oK6jF5OT4/DaTfORl24SHVbUSDUZ8acrZ0GSgFe21+GNHXWiQxoVj1f2j/vkiRIlxRlgSex/c7QzihbDY6lp6cbqDTsBACuW5GNKaoLgiCjQJEnCRbMm4MNfLsR1p06C5Os/PefhTXjpq0PweqNv2EOprz+JZXc0lL9PKYoqDpgoRajtBw7jiqe2oK3bifxMM169aT6yxseJDivqzM9Nwa3n5AEA7n2jAntbuwVHNHL727rR4/IgRq/hG0ECMKj8riF6+5T6PF4sf6UETrcXC/JScN2pk0SHREGUGKvHAxcX4fWfz0dBphldvX245/VyXPHUFuxqiq4NA6U/iYMcaCh/D2sUrQ1MlCLQJ7tacO2zX8LmcGPupHF46b9PRarJKDqsqHXruXk4LScZPS4PbvnHN3D0RVa/UkV9/85QQaaZFxITgIHFMJrKK4Za91ENyuq6kBirx0OXFXPISZSYfdI4vL3sdNx3QT7iDFpsP9iBCx7djNUbqtHjUtfdecdTVtcJgCdKdDRlE21/mz3ie7OHi4lShPlXaQN++sJ2OPq8OGtaKl78yTwkxupFhxXVtBrJV+NuwM4mG/73nSrRIY2IMsiB/UmkyM+M7oEOJbWdWPdxDQDggYuLkJHIPo1ootNqcOOCHHywfCH+qzAdbq+Mpzbtw6I1n+Kjnc2iwwuqrp4+HGjvAcBBDnS0NFMMUhIM8MrALhVM/B0OJkoR5B9fHsStL+1An0fGhcUWPH3dXN7lESbSzDF4xNevtP7LQ/hXaYPokIatghPvaAhl13BXsw19Hq/gaEKr1+XB8pdL4PH2/579frFFdEgkiCUpFk9dNxd/+dFcTEiKRX1nL27423bc9OLXaOzqFR1eUCgbZyeNj0NSnEFwNBSO/BtpUTL5jolSBJBlGY9/XIN736iALAPXzDsJa6+cBYOO//vCyYK8VNxyVv/o4BWvl0fEJYZeDnKgY8gaF4cEow4utxf7WsP/5ziQVm+oxr42O9LNRjxwUaHocCgMnFeQjo3Lz8TPFuZAq5HwXmUTznt4E579bD/cKttIKPWX3XE9oGMbuEIiOvqU+E47zMmyjNUbduKh/+wCACw7Oxe/u7iIvSRh6vbz8vCdyePR7XTjlvXh3690oN2ObqcbRp0GeWkc5ED9NBrJP92oOorK7z7d3YoXthwEAPzx8mLuqJNfnEGHFUvy8e6tZ2DOpHGwuzx44J0qXPT45yjxTYlTA6U/qZj9SXQc0dbDykQpjLk9Xtz9f2V4+tN9AID7LsjHr/5rGiSJSVK40mk1+NNVszAuTo/KBitW/7tadEgnVOE7TcrPNEPH+2FokGjrU+rsceHO10oBAEtPm4QFeamCI6JwND3DjFd/dhpWXzIDibH9v+d/8MTnuP/NClXcO6ZMvOOJEh3PQKJkjYrx+XxnFKacbg+Wrd+BV7bXQSMBD146EzcuyBEdFg1DZmIs1lw5CwDw/JaD2FDeKDagExjoTzILjoTCTUGU1aHf92YFmq1O5KTG454l+aLDoTCm0Ui46jsn4cNfLsQlsydAloEXtx7EuQ9vwtulDZDlyHzz2GJzoLHLAUkCClmKTceRnRIPo06DHpcHBw/3iA4n6JgohSG7042f/G073qtsgkGrwRPXnIwrTskSHRaNwNnT0vCzhf2J7V3/V4ZD7eH5y6S8jhPv6NiUOvTqRmvEvvEbrrdK6vFOWSO0GgmPXDGLQ3JoWFISjFhz5Sys/+k85KTGo9XmxK3/3IEf/fWriOhRHUpZD3JTE5Bg1AmOhsKVTqvB9IzoKc1mohRmOuwuXPOXL/FZTRviDFo89+NTcH5RpuiwaBR+tXga5kwaB5vDjV/88xu43OHV9CvLMioaOPGOjm1qugkaCWi3u9Bic4oOJ2gau3px/5sVAPp7QIuzksQGRBFn/pQUbLhtAZYvmgqDToPNe9qweO2neOzDPXC6w7tPdbBSf9ldkthAKOxF0+Q7JkphpNnqwJVPb0FJbSeS4vRY/9NTcXpuiuiwaJT0Wg0evWo2EmP1KK3rwh827BQd0hEOHe6BzeGGQatBXppJdDgUZmL0WkxJ7R/wodbF0OuVcddrZbA63CiemIhl5+SKDokilFGnxa3n5uH928/EgrwUuNxePLxxN5b8aTO27G0XHd6w+Ac5ZHHjjE5sYPKdOteGwZgohYkDbXZc+uQX2N3cjXSzEa/87DTM4s5mxJuQFIuHLy8GAPz18/14v7JJcEQDlPsypmeaOGqejknti+GLWw9i8542xOg1WHPlLOg50ITGaHJKPF644Tt49KrZSEkwYl+rHVc9sxXLXylBe3f4nszKsjxokEOS2GAo7EVTDytXhTBQ3WjFZX/egrqOXkxOjsNrN83H1HTu8KvFeQXp+MkZ2QCAX71airqO8OhXqqjv/wVXaOHuIR1bgYon39W0dGOVbyrliiX5/tMzorGSJAnfL7bgw18uxHWnToIkAa9/U49zHt6El746FJaTwuo7e3HY7oJOI/n7T4iOZ7pvbWiyOnDY7hIcTXAxURJs+4HDuOKpLWjrdiI/04xXb5qPrPFxosOiALv7/OkozkqC1eHGL/65A31hcEmhMvGOgxzoeJQ69GqV7Rr2ebxY/koJnG4vFuSl4LpTJ4kOiVQoMVaPBy4uwus/n4+CTDO6evtwz+vluOKpLdjVFF530CinSdMzTYjRc5gJnViCUYdJyf3vVdU+0IGJkkCf7GrBtc9+CZvDjbmTxuGl/z4VqSaj6LAoCAw6DdZdNRumGB12HOrEH30XCIsyeJADEyU6HiVR2t9uR4/LLTiawFn3UQ3K6rqQGKvHQ5cVQ8MLvCmIZp80Dm8vOx33XZCPOIMW2w924IJHN2P1huqw+XtV6utPYtkdDVe0lN8xURLkX6UN+OkL2+Ho8+Ksaal48SfzkBirFx0WBVHW+Dg8dFl/v9JTn+7DRzubhcVS19GLzp4+6LUSpmaw5IiOLdVkRJrJCFkGdobZDvholdR2Yt3HNQCABy4uQkZijOCIKBrotBrcuCAHHyxfiP8qTIfbK+OpTfuwaM2nQtcCRVlt/8ZZMS+apWEafPGsmjFREuAfXx7ErS/tQJ9HxoXFFjx93Vze2xElzi/KwPXzJwMAfvlKKRq7eoXEoZTdTU03wajjzx4dn5rGwPa6PFj+cgk83v7fvd8vtogOiaKMJSkWT103F3/50VxMSIpFfWcvbvjbdtz04tfC1gOvV/avCTxRouHKV3EP62BMlEJIlmU8/nEN7n2jArIMXDPvJKy9chYnjkWZFd+djhkTEtHR04db/7kDbgH9Siy7o+FS0+S71Ruqsa/NjnSzEQ9cVCg6HIpi5xWkY+PyM/GzhTnQaiS8V9mE8x7ehGc/2x/yNWF/ux02pxsxeg3y0lhhQMOjrA01Ld1w9EXOfWEjxXfoISLLMlZv2ImHfL0py87Oxe8uLoKWtfFRx6jTYt3Vs5Fg1GHbgQ6s2bg75DGUKxPvmCjRt1BLHfqnu1vxwpaDAIA/Xl6MpDiD4Igo2sUZdFixJB/v3noG5kwaB7vLgwfeqcJFj3+OktrOkMWh3J9UaEmEjiPyaZgyE2OQFKeH2yujpqVbdDhBw78RIdLj8mDznjYAwH0X5ONX/zUNksQkKVpNSo7HHy6dAQB44pO92LS7NWSvLcsyJ97RsCm7hruabPCE4Vjj4ejsceHO10oBAEtPm4QFeamCIyIaMD3DjFd/dhr+cMkMJMbqUdlgxQ+e+Bz3v1kBq6Mv6K9fWquU3XE9oOGTJEnVV0gomCiFSLxRh+dvOAWPXjUbNy7IER0OhYHvzbTgmnknAQCWv1yCZqsjJK/b2NV/74GW92XQMExOjkeMXoPePg8OtNtFhzMq979ViWarEzmp8bhnSb7ocIiOotFI+OF3TsKHv1yIS2ZPgCz3X4h87sOb8HZpA2Q5eJsUyolSMfuTaITU1MN6PEyUQijNFMPmYTrC/d8rQH6mGe12F279546Q7NiX+06T8tISeF8Gfav+hDpyF8O3Surxr9IGaDUSHrliFgfnUFhLSTBizZWzsP6n85CTGo9WmxO3/nMHfvTXr3CgLfAbFX0eLyp9f695okQjxRMlIgqqGL0Wj189G/EGLb7cfxh/+nBP0F+TZXc0UpE60KGxqxf3v1kBoL8vtDgrSWxARMM0f0oKNty2AMsXTYVBp8HmPW1YvPZTPPbhHjjdgWuc39PcDafbC5NRh8nJ8QF7XooOytpQ3WgN6qmnSEyUiATLSU3Aqkv6+5Ue+2gPPq9pC+rrKYlSERMlGqb8CLwvw+uVcddrZbA63CiemIhl5+SKDoloRIw6LW49Nw/v334mFuSlwOX24uGNu7HkT5uxZW97QF5DKbubMTGRFy/TiE1JTYBeK8HmcKOuQ8x4+2BjokQUBi6aNQE/PCULsgzc9lIJWmzB6VeSZdk/8Y6JEg1XJE6+e3HrQWze04YYvQZrrpwFPad5UYSanBKPF274Dh69ajZSEozY12rHVc9sxfJXStDe7RzTc5fW8f4kGj2DToO8tP5e50irOBgurhxEYeI3FxZiWroJbd1O3OG7FDPQWmxOtHU7oZEG3vwSfZvpGSZI0sDPT7iraenGqn9XAwBWLMnHlFTeDUORTZIkfL/Ygg9/uRDXnToJkgS8/k09znl4E1766hC8o1wvBgY5cOOMRsdfmh1BG2kjwUSJKEzEGrR4/JrZiNVr8XlNOx7/uCbgr1Hu2z3MTUtgUzsNW7xRh2xf/0K4l9/1ebxY/koJnG4vFuSl4LpTJ4kOiShgEmP1eODiIrz+8/koyDSjq7cP97xejiue2oJdTbYRPZejz+P/npns36NRKojA0uyRYKJEFEZy00x44OIiAMDaD3Zj677A1KErytmfRKMUKWNg131Ug7K6LiTG6vHQZcXsuyBVmn3SOLy97HTcd0E+4gxabD/YgQse3YzVG6rR43IP6zmqG61we2UkxxtgSYwJcsSkVvkqn3zHRIkozFw2ZyIuPXkivDJw6z93jLkGfbDKBk68o9GJhMl3JbWdWOc7iX3g4iJk8M0fqZhOq8GNC3LwwfKFOL8wA26vjKc27cOiNZ/iw+rmb/3+srqBi2YliRsKNDrKiVJdRy+6eoN/QXKoMVEiCkMPXFyI3LQEtNicuOOV0lHXnw/FEyUarXAf6NDr8mC5r7fvwmIL76yjqGFJisWfr5uDZ5fOxYSkWNR39uInz2/HTS9+jcau408iK/X1J3GQA41FYpweE5JiAQA7w3gjbbSYKBGFoTiDDo9ffTJi9Bp8ursVf/5075ifs8XmQLPVCYmDHGgUlPKKfW12OPoCd49LoKzeUI19bXakm4144KJC0eEQhdy5+enYuPxM/GxhDnQaCe9VNuG8hzfh2c/2w+3xHvX1yolScRY3zmhsIqHiYLSYKBGFqWkZJvz2+/1v+B5+fze2HTg8puer9I0Fn5KagHijbszxUXRJNxsxPt4Aj1fG7uaRNY0H26e7W/HCloMAgIcuK0ZSnEFwRERixBl0WLEkH+/cegbmTBoHu8uDB96pwkWPf46S2k7/13U73djb2g0AmDEhSUywpBqR0sM6GkyUiMLYFXOzcPEsCzxeGbf+cwc67K5RP5e/7M7C0yQaOUmSwrL8rrPHhTtfKwUALD1tEs6cmio4IiLxpmeY8erPTsMfLpmBxFg9Khus+METn+P+NytgdfShor4LsgxYEmOQajKKDpciXIGKBzowUSIKY5Ik4Xc/mIGclHg0djnwy1dH36/E/iQaK6W8IpzGwN7/ViWarU7kpMbjniX5osMhChsajYQffuckfPjLhbhk9gTIcv9FzOc+vAl/2bwPAPuTKDAKfWvDnuZu9B2jzDOSMVEiCnMJRh3WXX0yDDoNPtrZgr98tm9Uz1PJRInGKD8zvG5gf6ukHv8qbYBWI+GRK2bxbjCiY0hJMGLNlbOw/qfzkJMaj1abEx9UtwAAZrI/iQJg4rhYmIw6uDxef0mnWjBRIooABRYz/ud7BQCAB9/bhW8OdYzo+9u7nWjocgAY2PkhGqmCzP43VdWNtoBNYhytxq5e3P9mBQBg2dm5KOaFmUQnNH9KCjbctgDLF02FQdf/9m9e9njBUZEaSJKk2j4lJkpEEeKaeSfhgpmZcHtl/GL9DnT1DP++ggrfL66clHiYYvTBCpFULic1HgadBt1ON2o7eoTF4fXKuOu1MlgdbhRPTMSyc3KFxUIUSYw6LW49Nw8fLl+If9w4D3MmMVGiwAjH0uxAYKJEFCEkScIfLpmBSclxqO/sxa9eK4UsD29Xv8JXdlfIsjsaA71Wg6npCQDELoYvbj2IzXvaEKPXYM2Vs6DXcikjGoms8XE4PTdFdBikImod6MDVhSiCmGL0ePzqk2HQarCxqhnPfX5gWN9X7rsvY8YElt3R2IiefFfT0o1V/64GAKxYko8pqQlC4iAiogGDS++Gu4kbCZgoEUWYogmJuPeC/uleqzdUo3TQ3RjHU9HAQQ4UGCJ3Dfs8Xix/pQROtxcL8lJw3amTQh4DEREdLS89AVqNhI6ePjRZHaLDCRihidLq1atxyimnwGQyIS0tDRdffDF27dp1xNfIsoyVK1fCYrEgNjYWZ511FiorKwVFTBQefnTaJJxfmIE+j4xl//wGXb3H71fqsLtQ19ELACi0MFGisSmwDAx0CLV1H9WgrK4L5hgdHrqsGBqNFPIYiIjoaDF6LXJTxZdmB5rQRGnTpk245ZZbsHXrVmzcuBFutxuLFy+G3W73f82DDz6INWvWYN26ddi2bRsyMjKwaNEi2GzhdTM8UShJkoT/d9lMTBwXi9rDvbjn/8qOe9StnCZNSo5DYiwHOdDYTPeNCK/v7EVnz+gvQB6pktpOrPu4BgDwux/MQEZiTMhem4iIvp3/CgkVTb4Tmii99957uP7661FYWIji4mI899xzOHToEL7++msA/adJa9euxb333otLLrkERUVFeP7559HT04P169cf8zmdTiesVusRH0RqlBirx7qrT4ZeK2FDRRNe3HrwmF9XUd//d4BldxQI5hg9ssbHAghd+V2vy4PlL5fA45VxYbEF3y+2hOR1iYho+JTJd2oa6BBWPUpdXf073+PH94+r3L9/P5qamrB48WL/1xiNRixcuBBffPHFMZ9j9erVSExM9H9kZWUFP3AiQWZlJeHu86cDAH73TrV/ut1gymNFLLujAAn1QIfVG6qxr82OdLMRD1xUGJLXJCKikRl8155ahE2iJMsyli9fjjPOOANFRUUAgKamJgBAenr6EV+bnp7u/9xQK1asQFdXl/+jtrY2uIETCfaTM7JxXn46XB4vlq3/BjbHkf1K5fXKxDsmShQYynSjUCyGn+5uxQtb+k9LH7qsGElxhqC/JhERjZxSeneg3Y5up1twNIERNonSsmXLUFZWhn/+859HfU6SjmzYlWX5qMcURqMRZrP5iA8iNZMkCX+8fCYmJMXiQHsPfv1Ghb9fqaunD4cO918MWmjh3wUKjFBNvuvsceHO10oBAEtPm4Qzp6YG9fWIiGj0khOMSDcbIcvAriZ1lN+FRaL0i1/8Am+//TY+/vhjTJw40f94RkYGABx1etTS0nLUKRNRNEuKM+DRq2ZDp5Hwr9IG/POr/pPUSt8gh4njYjEunjvxFBhKHXpNiw0utzdor3P/W5VotjqRkxqPe5bkB+11iIgoMETftRdoQhMlWZaxbNkyvP766/joo4+QnZ19xOezs7ORkZGBjRs3+h9zuVzYtGkT5s+fH+pwicLanEnjcOd/TQMA/PZflahutPon3rHsjgJpQlIszDE69Hlk1LR0B+U13iqpx79KG6DVSHjkilmINWiD8jpERBQ4AwMd1NGnJDRRuuWWW/D3v/8d69evh8lkQlNTE5qamtDb23/niyRJuP3227Fq1Sq88cYbqKiowPXXX4+4uDhcffXVIkMnCks/XZCDs6alwun24pZ/fIMv9x0GwIl3FFiSJA3cwh6E8rvGrl7c/2YFAGDZ2bkozkoK+GsQEVHgBXNtEEFoovTkk0+iq6sLZ511FjIzM/0fL7/8sv9r7rrrLtx+++24+eabMXfuXNTX1+P999+HyWQSGDlReNJoJKy5YhYyzDHY12bHhztbADBRosDz7xoGuLzC65Vx12tlsDrcKJ6YiGXn5Ab0+YmIKHiU0rtdTVZ4vMe+3zGS6ES++PEuyBxMkiSsXLkSK1euDH5ARCowPr6/X+mqZ7b6f0kVcZADBdjAQIejR9KPxYtbD2LznjbE6DVYc+Us6LVh0UpLRETDMCk5HnEGLXpcHuxvsyM3LUF0SGPCFYhIhb6TPR7LF00FAJw0Pg7JCUbBEZHaDB4RPpxNr+GoaenG6g3VAIAVS/IxJTWyF1giomij1UiYntFf9aWG8juhJ0pEFDw/XzgFqSaj/xcWUSDlpSdAp5HQ1duHhi4HJiTFjun5+jxeLH+lBI4+LxbkpeC6UycFKFIiIgql/EwzvjnUiaoGK75fbBEdzpjwRIlIpTQaCVfMzcLMiUmiQyEVMuq0/pKKQPQprfuoBmV1XTDH6PDQZcXQaI59Vx4REYW3gcl3kX+ixESJiIhGRVkMq8e4GJbUdmLdxzUAgN/9YAYyEmPGHBsREYlRkBmYtSEcMFEiIqJRCcTFgr0uD5a/XAKPV8aFxZaIL9MgIop20zJMkCSg1eZEi80hOpwxYaJERESjUhCA+zJWb6jGvjY70s1GPHBRYaBCIyIiQeIMOmSnxAPoH/gTyZgoERHRqCiT7w4d7oHN0Tfi7/90dyte2HIQAPDQZcVIijMEND4iIhJDLeV3TJSIiGhUxsUbkOnrJ9rZNLJdw84eF+58rRQAsPS0SThzamrA4yMiIjGCdSl5qDFRIiKiURttn9L9b1Wi2epETmo87lmSH4zQiIhIkPwAlGaHAyZKREQ0aqPZNXyrpB7/Km2AViPhkStmIdagDVZ4REQkQKEvUdrX2g1Hn0dwNKPHRImIiEbNX4feNLxEqbGrF/e/WQEAWHZ2LoqzkoIVGhERCZJqMiIlwQCvDOwaYWl2OGGiREREo6aUV+xsssHt8Z7wa71eGXe9Vgarw42ZExOx7JzcUIRIREQhJkmSKsrvmCgREdGonTQ+DvEGLVxuL/a12U/4tS9uPYjNe9oQo9fgkStnQa/lEkREpFaBuGtPNK5SREQ0ahrNoF3DEyyGNS3dWL2hGgCwYkk+pqQmhCQ+IiISQ+lhjeQR4UyUiIhoTPK/5b6MPo8Xy18pgaPPiwV5Kbju1EmhDI+IiAQYfJeS1ysLjmZ0mCgREdGY+CffHSdRWvdRDcrqumCO0eGhy4qh0UihDI+IiATITomHQaeB3eXBocM9osMZFSZKREQ0JoPr0GX5yF3DktpOrPu4BgDwux/MQIbvgloiIlI3nVaD6RkmAJE70IGJEhERjcm0DBM0EtBud6HV5vQ/3uvyYPnLJfB4ZVxYbMH3iy0CoyQiolAr+JbS7HDHRImIiMYkRq9Fjm84Q+WgxfAPG6qxr82OdLMRD1xUKCo8IiISZDjDfsIZEyUiIhqzoWNgP93diue3HAQAPHRZMZLiDMJiIyIiMb6thzXcMVEiIqIxG7wYdva4cOdrpQCApadNwplTU0WGRkREgig9So1dDnTYXYKjGTkmSkRENGaDR4Tf/1Ylmq1O5KTG454l+YIjIyIiUUwxekxKjgMQmX1KTJSIiGjMlNK7fa12/Ku0AVqNhEeumIVYg1ZwZEREJFJ+RuSW3zFRIiKiMUs1GZFqMvr/vOzsXBRnJYkLiIiIwoK/NDsCBzowUSIiooBQTpVmTkzEsnNyBUdDREThwD/sJwJPlHSiAyAiInVYdk4uzLF63Ll4GvRa7sMREVH/iVJuWgIKLGbIsgxJkkSHNGySPPQadZWxWq1ITExEV1cXzGaz6HCIiIiIiEiQkeQG3PIjIiIiIiIagokSERERERHREEyUiIiIiIiIhmCiRERERERENAQTJSIiIiIioiGYKBEREREREQ3BRImIiIiIiGgIJkpERERERERDMFEiIiIiIiIagokSERERERHREEyUiIiIiIiIhmCiRERERERENAQTJSIiIiIioiGYKBEREREREQ3BRImIiIiIiGgIJkpERERERERDMFEiIiIiIiIagokSERERERHREDrRAQSbLMsAAKvVKjgSIiIiIiISSckJlBzhRFSfKNlsNgBAVlaW4EiIiIiIiCgc2Gw2JCYmnvBrJHk46VQE83q9aGhogMlkgiRJQmOxWq3IyspCbW0tzGaz0FgoOvBnjkKJP28UavyZo1Djz1zkk2UZNpsNFosFGs2Ju5BUf6Kk0WgwceJE0WEcwWw28y8XhRR/5iiU+PNGocafOQo1/sxFtm87SVJwmAMREREREdEQTJSIiIiIiIiGYKIUQkajEb/5zW9gNBpFh0JRgj9zFEr8eaNQ488chRp/5qKL6oc5EBERERERjRRPlIiIiIiIiIZgokRERERERDQEEyUiIiIiIqIhmCgRERERERENwUQphJ544glkZ2cjJiYGc+bMwebNm0WHRCq0evVqnHLKKTCZTEhLS8PFF1+MXbt2iQ6Losjq1ashSRJuv/120aGQitXX1+Paa69FcnIy4uLiMGvWLHz99deiwyIVcrvduO+++5CdnY3Y2Fjk5OTgf//3f+H1ekWHRkHGRClEXn75Zdx+++249957sWPHDixYsABLlizBoUOHRIdGKrNp0ybccsst2Lp1KzZu3Ai3243FixfDbreLDo2iwLZt2/D0009j5syZokMhFevo6MDpp58OvV6PDRs2oKqqCg8//DCSkpJEh0Yq9P/+3//Dn//8Z6xbtw7V1dV48MEH8dBDD+Gxxx4THRoFGceDh8i8efNw8skn48knn/Q/lp+fj4svvhirV68WGBmpXWtrK9LS0rBp0yaceeaZosMhFevu7sbJJ5+MJ554Ar/73e8wa9YsrF27VnRYpEL33HMPPv/8c1ZmUEh873vfQ3p6Op599ln/Y5deeini4uLw4osvCoyMgo0nSiHgcrnw9ddfY/HixUc8vnjxYnzxxReCoqJo0dXVBQAYP3684EhI7W655RZccMEFOO+880SHQir39ttvY+7cubj88suRlpaG2bNn45lnnhEdFqnUGWecgQ8//BC7d+8GAJSWluKzzz7Dd7/7XcGRUbDpRAcQDdra2uDxeJCenn7E4+np6WhqahIUFUUDWZaxfPlynHHGGSgqKhIdDqnYSy+9hG+++Qbbtm0THQpFgX379uHJJ5/E8uXL8etf/xpfffUVbr31VhiNRvzoRz8SHR6pzN13342uri5Mnz4dWq0WHo8Hv//973HVVVeJDo2CjIlSCEmSdMSfZVk+6jGiQFq2bBnKysrw2WefiQ6FVKy2tha33XYb3n//fcTExIgOh6KA1+vF3LlzsWrVKgDA7NmzUVlZiSeffJKJEgXcyy+/jL///e9Yv349CgsLUVJSgttvvx0WiwVLly4VHR4FEROlEEhJSYFWqz3q9KilpeWoUyaiQPnFL36Bt99+G59++ikmTpwoOhxSsa+//hotLS2YM2eO/zGPx4NPP/0U69atg9PphFarFRghqU1mZiYKCgqOeCw/Px//93//JygiUrM777wT99xzD374wx8CAGbMmIGDBw9i9erVTJRUjj1KIWAwGDBnzhxs3LjxiMc3btyI+fPnC4qK1EqWZSxbtgyvv/46PvroI2RnZ4sOiVTu3HPPRXl5OUpKSvwfc+fOxTXXXIOSkhImSRRwp59++lHXHuzevRuTJk0SFBGpWU9PDzSaI98ya7VajgePAjxRCpHly5fjuuuuw9y5c3Haaafh6aefxqFDh3DTTTeJDo1U5pZbbsH69evx1ltvwWQy+U8yExMTERsbKzg6UiOTyXRUD1x8fDySk5PZG0dBcccdd2D+/PlYtWoVrrjiCnz11Vd4+umn8fTTT4sOjVTowgsvxO9//3ucdNJJKCwsxI4dO7BmzRrccMMNokOjION48BB64okn8OCDD6KxsRFFRUV45JFHOK6ZAu54fW/PPfccrr/++tAGQ1HrrLPO4nhwCqp33nkHK1aswJ49e5CdnY3ly5fjpz/9qeiwSIVsNhvuv/9+vPHGG2hpaYHFYsFVV12F//mf/4HBYBAdHgUREyUiIiIiIqIh2KNEREREREQ0BBMlIiIiIiKiIZgoERERERERDcFEiYiIiIiIaAgmSkREREREREMwUSIiIiIiIhqCiRIREREREdEQTJSIiIiIiIiGYKJEREQR58CBA5AkCSUlJUF7jeuvvx4XX3xx0J6fiIjCGxMlIiIKueuvvx6SJB31cf755w/r+7OystDY2IiioqIgR0pERNFKJzoAIiKKTueffz6ee+65Ix4zGo3D+l6tVouMjIxghEVERASAJ0pERCSI0WhERkbGER/jxo0DAEiShCeffBJLlixBbGwssrOz8eqrr/q/d2jpXUdHB6655hqkpqYiNjYWeXl5RyRh5eXlOOeccxAbG4vk5GT893//N7q7u/2f93g8WL58OZKSkpCcnIy77roLsiwfEa8sy3jwwQeRk5OD2NhYFBcX47XXXvN//ttiICKiyMJEiYiIwtL999+PSy+9FKWlpbj22mtx1VVXobq6+rhfW1VVhQ0bNqC6uhpPPvkkUlJSAAA9PT04//zzMW7cOGzbtg2vvvoqPvjgAyxbtsz//Q8//DD++te/4tlnn8Vnn32Gw4cP44033jjiNe677z4899xzePLJJ1FZWYk77rgD1157LTZt2vStMRARUeSR5KFbZkREREF2/fXX4+9//ztiYmKOePzuu+/G/fffD0mScNNNN+HJJ5/0f+7UU0/FySefjCeeeAIHDhxAdnY2duzYgVmzZuH73/8+UlJS8Ne//vWo13rmmWdw9913o7a2FvHx8QCAf//737jwwgvR0NCA9PR0WCwW3Hbbbbj77rsBAG63G9nZ2ZgzZw7efPNN2O12pKSk4KOPPsJpp53mf+4bb7wRPT09WL9+/QljICKiyMMeJSIiEuLss88+IhECgPHjx/v/eXBCovz5eFPufv7zn+PSSy/FN998g8WLF+Piiy/G/PnzAQDV1dUoLi72J0kAcPrpp8Pr9WLXrl2IiYlBY2PjEa+n0+kwd+5cf/ldVVUVHA4HFi1adMTrulwuzJ49+1tjICKiyMNEiYiIhIiPj0dubu6IvkeSpGM+vmTJEhw8eBDvvvsuPvjgA5x77rm45ZZb8Mc//hGyLB/3+473+FBerxcA8O6772LChAlHfE4ZQHGiGIiIKPKwR4mIiMLS1q1bj/rz9OnTj/v1qamp/pK+tWvX4umnnwYAFBQUoKSkBHa73f+1n3/+OTQaDaZOnYrExERkZmYe8Xputxtff/21/88FBQUwGo04dOgQcnNzj/jIysr61hiIiCjy8ESJiIiEcDqdaGpqOuIxnU7nH4Dw6quvYu7cuTjjjDPwj3/8A1999RWeffbZYz7X//zP/2DOnDkoLCyE0+nEO++8g/z8fADANddcg9/85jdYunQpVq5cidbWVvziF7/Addddh/T0dADAbbfdhj/84Q/Iy8tDfn4+1qxZg87OTv/zm0wm/OpXv8Idd9wBr9eLM844A1arFV988QUSEhKwdOnSE8ZARESRh4kSEREJ8d577yEzM/OIx6ZNm4adO3cCAH7729/ipZdews0334yMjAz84x//QEFBwTGfy2AwYMWKFThw4ABiY2OxYMECvPTSSwCAuLg4/Oc//8Ftt92GU045BXFxcbj00kuxZs0a//f/8pe/RGNjI66//npoNBrccMMN+MEPfoCuri7/1zzwwANIS0vD6tWrsW/fPiQlJeHkk0/Gr3/962+NgYiIIg+n3hERUdiRJAlvvPEGLr74YtGhEBFRlGKPEhERERER0RBMlIiIiIiIiIZgjxIREYUdVoUTEZFoPFEiIiIiIiIagokSERERERHREEyUiIiIiIiIhmCiRERERERENAQTJSIiIiIioiGYKBEREREREQ3BRImIiIiIiGgIJkpERERERERD/H8vJO0sAA9LcgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "MoviePy - Building file videos/CartPole-v1.gif with imageio.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ " \r" ] }, { "data": { "text/html": [ "