16_reinforcement_learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Chapter 16 – Reinforcement Learning**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook contains all the sample code and solutions to the exersices in chapter 16.\n",
    "\n",
    "<table align=\"left\">\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/ageron/handson-ml/blob/master/16_reinforcement_learning.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
    "  </td>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Warning**: this is the code for the 1st edition of the book. Please visit https://github.com/ageron/handson-ml2 for the 2nd edition code, with up-to-date notebooks using the latest library versions. In particular, the 1st edition is based on TensorFlow 1, while the 2nd edition uses TensorFlow 2, which is much simpler to use."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, let's make sure this notebook works well in both python 2 and 3, import a few common modules, ensure MatplotLib plots figures inline and prepare a function to save the figures:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "import sklearn\n",
    "import sys\n",
    "\n",
    "try:\n",
    "    # %tensorflow_version only exists in Colab.\n",
    "    %tensorflow_version 1.x\n",
    "    !apt update && apt install -y libpq-dev libsdl2-dev swig xorg-dev xvfb\n",
    "    !pip install -q -U pyvirtualdisplay gym[atari,box2d]\n",
    "    IS_COLAB = True\n",
    "except Exception:\n",
    "    IS_COLAB = False\n",
    "\n",
    "# to make this notebook's output stable across runs\n",
    "def reset_graph(seed=42):\n",
    "    tf.reset_default_graph()\n",
    "    tf.set_random_seed(seed)\n",
    "    np.random.seed(seed)\n",
    "\n",
    "# To plot pretty figures\n",
    "%matplotlib inline\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "mpl.rc('axes', labelsize=14)\n",
    "mpl.rc('xtick', labelsize=12)\n",
    "mpl.rc('ytick', labelsize=12)\n",
    "\n",
    "# To get smooth animations\n",
    "import matplotlib.animation as animation\n",
    "mpl.rc('animation', html='jshtml')\n",
    "\n",
    "# Where to save the figures\n",
    "PROJECT_ROOT_DIR = \".\"\n",
    "CHAPTER_ID = \"rl\"\n",
    "IMAGES_PATH = os.path.join(PROJECT_ROOT_DIR, \"images\", CHAPTER_ID)\n",
    "os.makedirs(IMAGES_PATH, exist_ok=True)\n",
    "\n",
    "def save_fig(fig_id, tight_layout=True, fig_extension=\"png\", resolution=300):\n",
    "    path = os.path.join(IMAGES_PATH, fig_id + \".\" + fig_extension)\n",
    "    print(\"Saving figure\", fig_id)\n",
    "    if tight_layout:\n",
    "        plt.tight_layout()\n",
    "    plt.savefig(path, format=fig_extension, dpi=resolution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: there may be minor differences between the output of this notebook and the examples shown in the book. You can safely ignore these differences. They are mainly due to the fact that most of the environments provided by OpenAI gym have some randomness."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to OpenAI gym"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook we will be using [OpenAI gym](https://gym.openai.com/), a great toolkit for developing and comparing Reinforcement Learning algorithms. It provides many environments for your learning *agents* to interact with. Let's start by importing `gym`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we will load the MsPacman environment, version 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = gym.make('MsPacman-v0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's initialize the environment by calling is `reset()` method. This returns an observation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.seed(42)\n",
    "obs = env.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observations vary depending on the environment. In this case it is an RGB image represented as a 3D NumPy array of shape [width, height, channels] (with 3 channels: Red, Green and Blue). In other environments it may return different objects, as we will see later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(210, 160, 3)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obs.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An environment can be visualized by calling its `render()` method, and you can pick the rendering mode (the rendering options depend on the environment)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Warning**: some environments require access to your display, which opens up a separate window, even if you specify `mode=\"rgb_array\"`. In general you can safely ignore that window. However, if Jupyter is running on a headless server (ie. without a screen) it will raise an exception. One way to avoid this is to install a fake X server like [Xvfb](http://en.wikipedia.org/wiki/Xvfb). On Debian or Ubuntu:\n",
    "\n",
    "```bash\n",
    "$ apt update\n",
    "$ apt install -y xvfb\n",
    "```\n",
    "\n",
    "You can then start Jupyter using the `xvfb-run` command:\n",
    "\n",
    "```bash\n",
    "$ xvfb-run -s \"-screen 0 1400x900x24\" jupyter notebook\n",
    "```\n",
    "\n",
    "Alternatively, you can install the [pyvirtualdisplay](https://github.com/ponty/pyvirtualdisplay) Python library which wraps Xvfb:\n",
    "\n",
    "```bash\n",
    "python3 -m pip install -U pyvirtualdisplay\n",
    "```\n",
    "\n",
    "And run the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    import pyvirtualdisplay\n",
    "    display = pyvirtualdisplay.Display(visible=0, size=(1400, 900)).start()\n",
    "except ImportError:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.render()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example we will set `mode=\"rgb_array\"` to get an image of the environment as a NumPy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(210, 160, 3)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img = env.render(mode=\"rgb_array\")\n",
    "img.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot this image:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving figure MsPacman\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(5,4))\n",
    "plt.imshow(img)\n",
    "plt.axis(\"off\")\n",
    "save_fig(\"MsPacman\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome back to the 1980s! :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this environment, the rendered image is simply equal to the observation (but in many environments this is not the case):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(img == obs).all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a little helper function to plot an environment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_environment(env, figsize=(5,4)):\n",
    "    plt.figure(figsize=figsize)\n",
    "    img = env.render(mode=\"rgb_array\")\n",
    "    plt.imshow(img)\n",
    "    plt.axis(\"off\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how to interact with an environment. Your agent will need to select an action from an \"action space\" (the set of possible actions). Let's see what this environment's action space looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Discrete(9)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.action_space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Discrete(9)` means that the possible actions are integers 0 through 8, which represents the 9 possible positions of the joystick (0=center, 1=up, 2=right, 3=left, 4=down, 5=upper-right, 6=upper-left, 7=lower-right, 8=lower-left)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we need to tell the environment which action to play, and it will compute the next step of the game. Let's go left for 110 steps, then lower left for 40 steps:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.seed(42)\n",
    "env.reset()\n",
    "for step in range(110):\n",
    "    env.step(3) #left\n",
    "for step in range(40):\n",
    "    env.step(8) #lower-left"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Where are we now?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_environment(env)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `step()` function actually returns several important objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs, reward, done, info = env.step(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The observation tells the agent what the environment looks like, as discussed earlier. This is a 210x160 RGB image:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(210, 160, 3)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obs.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The environment also tells the agent how much reward it got during the last step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reward"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the game is over, the environment returns `done=True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, `info` is an environment-specific dictionary that can provide some extra information about the internal state of the environment. This is useful for debugging, but your agent should not use this information for learning (it would be cheating)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ale.lives': 3}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's play one full game (with 3 lives), by moving in random directions for 10 steps at a time, recording each frame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "frames = []\n",
    "\n",
    "n_max_steps = 1000\n",
    "n_change_steps = 10\n",
    "\n",
    "env.seed(42)\n",
    "obs = env.reset()\n",
    "for step in range(n_max_steps):\n",
    "    img = env.render(mode=\"rgb_array\")\n",
    "    frames.append(img)\n",
    "    if step % n_change_steps == 0:\n",
    "        action = env.action_space.sample() # play randomly\n",
    "    obs, reward, done, info = env.step(action)\n",
    "    if done:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now show the animation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_scene(num, frames, patch):\n",
    "    patch.set_data(frames[num])\n",
    "    return patch,\n",
    "\n",
    "def plot_animation(frames, repeat=False, interval=40):\n",
    "    fig = plt.figure()\n",
    "    patch = plt.imshow(frames[0])\n",
    "    plt.axis('off')\n",
    "    anim = animation.FuncAnimation(\n",
    "        fig, update_scene, fargs=(frames, patch),\n",
    "        frames=len(frames), repeat=repeat, interval=interval)\n",
    "    plt.close()\n",
    "    return anim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_animation(frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have finished playing with an environment, you should close it to free up resources:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To code our first learning agent, we will be using a simpler environment: the Cart-Pole. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A simple environment: the Cart-Pole"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Cart-Pole is a very simple environment composed of a cart that can move left or right, and pole placed vertically on top of it. The agent must move the cart left or right to keep the pole upright."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = gym.make(\"CartPole-v0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.seed(42)\n",
    "obs = env.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.01258566, -0.00156614,  0.04207708, -0.00180545])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The observation is a 1D NumPy array composed of 4 floats: they represent the cart's horizontal position, its velocity, the angle of the pole (0 = vertical), and the angular velocity. Let's render the environment..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_environment(env)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's look at the action space:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Discrete(2)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.action_space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yep, just two possible actions: accelerate towards the left or towards the right. Let's push the cart left until the pole falls:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.seed(42)\n",
    "obs = env.reset()\n",
    "while True:\n",
    "    obs, reward, done, info = env.step(0)\n",
    "    if done:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving figure cart_pole_plot\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_environment(env)\n",
    "save_fig(\"cart_pole_plot\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(210, 160, 3)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the game is over when the pole tilts too much, not when it actually falls. Now let's reset the environment and push the cart to right instead:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs = env.reset()\n",
    "while True:\n",
    "    obs, reward, done, info = env.step(1)\n",
    "    if done:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_environment(env)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks like it's doing what we're telling it to do. Now how can we make the poll remain upright? We will need to define a _policy_ for that. This is the strategy that the agent will use to select an action at each step. It can use all the past actions and observations to decide what to do."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A simple hard-coded policy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's hard code a simple strategy: if the pole is tilting to the left, then push the cart to the left, and _vice versa_. Let's see if that works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "frames = []\n",
    "\n",
    "n_max_steps = 1000\n",
    "n_change_steps = 10\n",
    "\n",
    "env.seed(42)\n",
    "obs = env.reset()\n",
    "for step in range(n_max_steps):\n",
    "    img = env.render(mode=\"rgb_array\")\n",
    "    frames.append(img)\n",
    "\n",
    "    # hard-coded policy\n",
    "    position, velocity, angle, angular_velocity = obs\n",
    "    if angle < 0:\n",
    "        action = 0\n",
    "    else:\n",
    "        action = 1\n",
    "\n",
    "    obs, reward, done, info = env.step(action)\n",
    "    if done:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_animation(frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nope, the system is unstable and after just a few wobbles, the pole ends up too tilted: game over. We will need to be smarter than that!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Neural Network Policies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a neural network that will take observations as inputs, and output the action to take for each observation. To choose an action, the network will first estimate a probability for each action, then select an action randomly according to the estimated probabilities. In the case of the Cart-Pole environment, there are just two possible actions (left or right), so we only need one output neuron: it will output the probability `p` of the action 0 (left), and of course the probability of action 1 (right) will be `1 - p`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: instead of using the `fully_connected()` function from the `tensorflow.contrib.layers` module (as in the book), we now use the `dense()` function from the `tf.layers` module, which did not exist when this chapter was written. This is preferable because anything in contrib may change or be deleted without notice, while `tf.layers` is part of the official API. As you will see, the code is mostly the same.\n",
    "\n",
    "The main differences relevant to this chapter are:\n",
    "* the `_fn` suffix was removed in all the parameters that had it (for example the `activation_fn` parameter was renamed to `activation`).\n",
    "* the `weights` parameter was renamed to `kernel`,\n",
    "* the default activation is `None` instead of `tf.nn.relu`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-36-e360db0650cb>:12: dense (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.Dense instead.\n",
      "WARNING:tensorflow:From /Users/ageron/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow_core/python/layers/core.py:187: Layer.apply (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `layer.__call__` method instead.\n",
      "WARNING:tensorflow:From <ipython-input-36-e360db0650cb>:18: multinomial (from tensorflow.python.ops.random_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `tf.random.categorical` instead.\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# 1. Specify the network architecture\n",
    "n_inputs = 4  # == env.observation_space.shape[0]\n",
    "n_hidden = 4  # it's a simple task, we don't need more than this\n",
    "n_outputs = 1 # only outputs the probability of accelerating left\n",
    "initializer = tf.variance_scaling_initializer()\n",
    "\n",
    "# 2. Build the neural network\n",
    "X = tf.placeholder(tf.float32, shape=[None, n_inputs])\n",
    "hidden = tf.layers.dense(X, n_hidden, activation=tf.nn.elu,\n",
    "                         kernel_initializer=initializer)\n",
    "outputs = tf.layers.dense(hidden, n_outputs, activation=tf.nn.sigmoid,\n",
    "                          kernel_initializer=initializer)\n",
    "\n",
    "# 3. Select a random action based on the estimated probabilities\n",
    "p_left_and_right = tf.concat(axis=1, values=[outputs, 1 - outputs])\n",
    "action = tf.multinomial(tf.log(p_left_and_right), num_samples=1)\n",
    "\n",
    "init = tf.global_variables_initializer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this particular environment, the past actions and observations can safely be ignored, since each observation contains the environment's full state. If there were some hidden state then you may need to consider past actions and observations in order to try to infer the hidden state of the environment. For example, if the environment only revealed the position of the cart but not its velocity, you would have to consider not only the current observation but also the previous observation in order to estimate the current velocity. Another example is if the observations are noisy: you may want to use the past few observations to estimate the most likely current state. Our problem is thus as simple as can be: the current observation is noise-free and contains the environment's full state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may wonder why we are picking a random action based on the probability given by the policy network, rather than just picking the action with the highest probability. This approach lets the agent find the right balance between _exploring_ new actions and _exploiting_ the actions that are known to work well. Here's an analogy: suppose you go to a restaurant for the first time, and all the dishes look equally appealing so you randomly pick one. If it turns out to be good, you can increase the probability to order it next time, but you shouldn't increase that probability to 100%, or else you will never try out the other dishes, some of which may be even better than the one you tried."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's randomly initialize this policy neural network and use it to play one game:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_max_steps = 1000\n",
    "frames = []\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    init.run()\n",
    "    env.seed(42)\n",
    "    obs = env.reset()\n",
    "    for step in range(n_max_steps):\n",
    "        img = env.render(mode=\"rgb_array\")\n",
    "        frames.append(img)\n",
    "        action_val = action.eval(feed_dict={X: obs.reshape(1, n_inputs)})\n",
    "        obs, reward, done, info = env.step(action_val[0][0])\n",
    "        if done:\n",
    "            break\n",
    "\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's look at how well this randomly initialized policy network performed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_animation(frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yeah... pretty bad. The neural network will have to learn to do better. First let's see if it is capable of learning the basic policy we used earlier: go left if the pole is tilting left, and go right if it is tilting right. The following code defines the same neural network but we add the target probabilities `y`, and the training operations (`cross_entropy`,  `optimizer` and `training_op`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Users/ageron/miniconda3/envs/tf1/lib/python3.7/site-packages/tensorflow_core/python/ops/nn_impl.py:183: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "reset_graph()\n",
    "\n",
    "n_inputs = 4\n",
    "n_hidden = 4\n",
    "n_outputs = 1\n",
    "\n",
    "learning_rate = 0.01\n",
    "\n",
    "initializer = tf.variance_scaling_initializer()\n",
    "\n",
    "X = tf.placeholder(tf.float32, shape=[None, n_inputs])\n",
    "y = tf.placeholder(tf.float32, shape=[None, n_outputs])\n",
    "\n",
    "hidden = tf.layers.dense(X, n_hidden, activation=tf.nn.elu, kernel_initializer=initializer)\n",
    "logits = tf.layers.dense(hidden, n_outputs)\n",
    "outputs = tf.nn.sigmoid(logits) # probability of action 0 (left)\n",
    "p_left_and_right = tf.concat(axis=1, values=[outputs, 1 - outputs])\n",
    "action = tf.multinomial(tf.log(p_left_and_right), num_samples=1)\n",
    "\n",
    "cross_entropy = tf.nn.sigmoid_cross_entropy_with_logits(labels=y, logits=logits)\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate)\n",
    "training_op = optimizer.minimize(cross_entropy)\n",
    "\n",
    "init = tf.global_variables_initializer()\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can make the same net play in 10 different environments in parallel, and train for 1000 iterations. We also reset environments when they are done."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_environments = 10\n",
    "n_iterations = 1000\n",
    "\n",
    "envs = [gym.make(\"CartPole-v0\") for _ in range(n_environments)]\n",
    "observations = [env.reset() for env in envs]\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    init.run()\n",
    "    for iteration in range(n_iterations):\n",
    "        target_probas = np.array([([1.] if obs[2] < 0 else [0.]) for obs in observations]) # if angle<0 we want proba(left)=1., or else proba(left)=0.\n",
    "        action_val, _ = sess.run([action, training_op], feed_dict={X: np.array(observations), y: target_probas})\n",
    "        for env_index, env in enumerate(envs):\n",
    "            obs, reward, done, info = env.step(action_val[env_index][0])\n",
    "            observations[env_index] = obs if not done else env.reset()\n",
    "    saver.save(sess, \"./my_policy_net_basic.ckpt\")\n",
    "\n",
    "for env in envs:\n",
    "    env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def render_policy_net(model_path, action, X, n_max_steps=1000):\n",
    "    frames = []\n",
    "    env = gym.make(\"CartPole-v0\")\n",
    "    obs = env.reset()\n",
    "    with tf.Session() as sess:\n",
    "        saver.restore(sess, model_path)\n",
    "        for step in range(n_max_steps):\n",
    "            img = env.render(mode=\"rgb_array\")\n",
    "            frames.append(img)\n",
    "            action_val = action.eval(feed_dict={X: obs.reshape(1, n_inputs)})\n",
    "            obs, reward, done, info = env.step(action_val[0][0])\n",
    "            if done:\n",
    "                break\n",
    "    env.close()\n",
    "    return frames        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "frames = render_policy_net(\"./my_policy_net_basic.ckpt\", action, X)\n",
    "plot_animation(frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks like it learned the policy correctly. Now let's see if it can learn a better policy on its own."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Policy Gradients"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To train this neural network we will need to define the target probabilities `y`. If an action is good we should increase its probability, and conversely if it is bad we should reduce it. But how do we know whether an action is good or bad? The problem is that most actions have delayed effects, so when you win or lose points in a game, it is not clear which actions contributed to this result: was it just the last action? Or the last 10? Or just one action 50 steps earlier? This is called the _credit assignment problem_.\n",
    "\n",
    "The _Policy Gradients_ algorithm tackles this problem by first playing multiple games, then making the actions in good games slightly more likely, while actions in bad games are made slightly less likely. First we play, then we go back and think about what we did."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-46-d42d007ce403>:21: to_float (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `tf.cast` instead.\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "reset_graph()\n",
    "\n",
    "n_inputs = 4\n",
    "n_hidden = 4\n",
    "n_outputs = 1\n",
    "\n",
    "learning_rate = 0.01\n",
    "\n",
    "initializer = tf.variance_scaling_initializer()\n",
    "\n",
    "X = tf.placeholder(tf.float32, shape=[None, n_inputs])\n",
    "\n",
    "hidden = tf.layers.dense(X, n_hidden, activation=tf.nn.elu, kernel_initializer=initializer)\n",
    "logits = tf.layers.dense(hidden, n_outputs)\n",
    "outputs = tf.nn.sigmoid(logits)  # probability of action 0 (left)\n",
    "p_left_and_right = tf.concat(axis=1, values=[outputs, 1 - outputs])\n",
    "action = tf.multinomial(tf.log(p_left_and_right), num_samples=1)\n",
    "\n",
    "y = 1. - tf.to_float(action)\n",
    "cross_entropy = tf.nn.sigmoid_cross_entropy_with_logits(labels=y, logits=logits)\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate)\n",
    "grads_and_vars = optimizer.compute_gradients(cross_entropy)\n",
    "gradients = [grad for grad, variable in grads_and_vars]\n",
    "gradient_placeholders = []\n",
    "grads_and_vars_feed = []\n",
    "for grad, variable in grads_and_vars:\n",
    "    gradient_placeholder = tf.placeholder(tf.float32, shape=grad.get_shape())\n",
    "    gradient_placeholders.append(gradient_placeholder)\n",
    "    grads_and_vars_feed.append((gradient_placeholder, variable))\n",
    "training_op = optimizer.apply_gradients(grads_and_vars_feed)\n",
    "\n",
    "init = tf.global_variables_initializer()\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def discount_rewards(rewards, discount_rate):\n",
    "    discounted_rewards = np.zeros(len(rewards))\n",
    "    cumulative_rewards = 0\n",
    "    for step in reversed(range(len(rewards))):\n",
    "        cumulative_rewards = rewards[step] + cumulative_rewards * discount_rate\n",
    "        discounted_rewards[step] = cumulative_rewards\n",
    "    return discounted_rewards\n",
    "\n",
    "def discount_and_normalize_rewards(all_rewards, discount_rate):\n",
    "    all_discounted_rewards = [discount_rewards(rewards, discount_rate) for rewards in all_rewards]\n",
    "    flat_rewards = np.concatenate(all_discounted_rewards)\n",
    "    reward_mean = flat_rewards.mean()\n",
    "    reward_std = flat_rewards.std()\n",
    "    return [(discounted_rewards - reward_mean)/reward_std for discounted_rewards in all_discounted_rewards]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-22., -40., -50.])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "discount_rewards([10, 0, -50], discount_rate=0.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([-0.28435071, -0.86597718, -1.18910299]),\n",
       " array([1.26665318, 1.0727777 ])]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "discount_and_normalize_rewards([[10, 0, -50], [10, 20]], discount_rate=0.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 249"
     ]
    }
   ],
   "source": [
    "env = gym.make(\"CartPole-v0\")\n",
    "\n",
    "n_games_per_update = 10\n",
    "n_max_steps = 1000\n",
    "n_iterations = 250\n",
    "save_iterations = 10\n",
    "discount_rate = 0.95\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    init.run()\n",
    "    for iteration in range(n_iterations):\n",
    "        print(\"\\rIteration: {}\".format(iteration), end=\"\")\n",
    "        all_rewards = []\n",
    "        all_gradients = []\n",
    "        for game in range(n_games_per_update):\n",
    "            current_rewards = []\n",
    "            current_gradients = []\n",
    "            obs = env.reset()\n",
    "            for step in range(n_max_steps):\n",
    "                action_val, gradients_val = sess.run([action, gradients], feed_dict={X: obs.reshape(1, n_inputs)})\n",
    "                obs, reward, done, info = env.step(action_val[0][0])\n",
    "                current_rewards.append(reward)\n",
    "                current_gradients.append(gradients_val)\n",
    "                if done:\n",
    "                    break\n",
    "            all_rewards.append(current_rewards)\n",
    "            all_gradients.append(current_gradients)\n",
    "\n",
    "        all_rewards = discount_and_normalize_rewards(all_rewards, discount_rate=discount_rate)\n",
    "        feed_dict = {}\n",
    "        for var_index, gradient_placeholder in enumerate(gradient_placeholders):\n",
    "            mean_gradients = np.mean([reward * all_gradients[game_index][step][var_index]\n",
    "                                      for game_index, rewards in enumerate(all_rewards)\n",
    "                                          for step, reward in enumerate(rewards)], axis=0)\n",
    "            feed_dict[gradient_placeholder] = mean_gradients\n",
    "        sess.run(training_op, feed_dict=feed_dict)\n",
    "        if iteration % save_iterations == 0:\n",
    "            saver.save(sess, \"./my_policy_net_pg.ckpt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "frames = render_policy_net(\"./my_policy_net_pg.ckpt\", action, X, n_max_steps=1000)\n",
    "plot_animation(frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Markov Chains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "States: 0 0 3 \n",
      "States: 0 1 2 1 2 1 2 1 2 1 3 \n",
      "States: 0 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 3 \n",
      "States: 0 3 \n",
      "States: 0 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 3 \n",
      "States: 0 1 3 \n",
      "States: 0 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 ...\n",
      "States: 0 0 3 \n",
      "States: 0 0 0 1 2 1 2 1 3 \n",
      "States: 0 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 3 \n"
     ]
    }
   ],
   "source": [
    "transition_probabilities = [\n",
    "        [0.7, 0.2, 0.0, 0.1],  # from s0 to s0, s1, s2, s3\n",
    "        [0.0, 0.0, 0.9, 0.1],  # from s1 to ...\n",
    "        [0.0, 1.0, 0.0, 0.0],  # from s2 to ...\n",
    "        [0.0, 0.0, 0.0, 1.0],  # from s3 to ...\n",
    "    ]\n",
    "\n",
    "n_max_steps = 50\n",
    "\n",
    "def print_sequence(start_state=0):\n",
    "    current_state = start_state\n",
    "    print(\"States:\", end=\" \")\n",
    "    for step in range(n_max_steps):\n",
    "        print(current_state, end=\" \")\n",
    "        if current_state == 3:\n",
    "            break\n",
    "        current_state = np.random.choice(range(4), p=transition_probabilities[current_state])\n",
    "    else:\n",
    "        print(\"...\", end=\"\")\n",
    "    print()\n",
    "\n",
    "for _ in range(10):\n",
    "    print_sequence()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Markov Decision Process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "policy_fire\n",
      "States (+rewards): 0 (10) 0 (10) 0 1 (-50) 2 2 2 (40) 0 (10) 0 (10) 0 (10) ... Total rewards = 210\n",
      "States (+rewards): 0 1 (-50) 2 (40) 0 (10) 0 (10) 0 1 (-50) 2 2 (40) 0 (10) ... Total rewards = 70\n",
      "States (+rewards): 0 (10) 0 1 (-50) 2 (40) 0 (10) 0 (10) 0 (10) 0 (10) 0 (10) 0 (10) ... Total rewards = 70\n",
      "States (+rewards): 0 1 (-50) 2 1 (-50) 2 (40) 0 (10) 0 1 (-50) 2 (40) 0 ... Total rewards = -10\n",
      "States (+rewards): 0 1 (-50) 2 (40) 0 (10) 0 (10) 0 1 (-50) 2 (40) 0 (10) 0 (10) ... Total rewards = 290\n",
      "Summary: mean=121.1, std=129.333766, min=-330, max=470\n",
      "\n",
      "policy_random\n",
      "States (+rewards): 0 1 (-50) 2 1 (-50) 2 (40) 0 1 (-50) 2 2 (40) 0 ... Total rewards = -60\n",
      "States (+rewards): 0 (10) 0 0 0 0 0 (10) 0 0 0 (10) 0 ... Total rewards = -30\n",
      "States (+rewards): 0 1 1 (-50) 2 (40) 0 0 1 1 1 1 ... Total rewards = 10\n",
      "States (+rewards): 0 (10) 0 (10) 0 0 0 0 1 (-50) 2 (40) 0 0 ... Total rewards = 0\n",
      "States (+rewards): 0 0 (10) 0 1 (-50) 2 (40) 0 0 0 0 (10) 0 (10) ... Total rewards = 40\n",
      "Summary: mean=-22.1, std=88.152740, min=-380, max=200\n",
      "\n",
      "policy_safe\n",
      "States (+rewards): 0 1 1 1 1 1 1 1 1 1 ... Total rewards = 0\n",
      "States (+rewards): 0 1 1 1 1 1 1 1 1 1 ... Total rewards = 0\n",
      "States (+rewards): 0 (10) 0 (10) 0 (10) 0 1 1 1 1 1 1 ... Total rewards = 30\n",
      "States (+rewards): 0 (10) 0 1 1 1 1 1 1 1 1 ... Total rewards = 10\n",
      "States (+rewards): 0 1 1 1 1 1 1 1 1 1 ... Total rewards = 0\n",
      "Summary: mean=22.3, std=26.244312, min=0, max=170\n",
      "\n"
     ]
    }
   ],
   "source": [
    "transition_probabilities = [\n",
    "        [[0.7, 0.3, 0.0], [1.0, 0.0, 0.0], [0.8, 0.2, 0.0]], # in s0, if action a0 then proba 0.7 to state s0 and 0.3 to state s1, etc.\n",
    "        [[0.0, 1.0, 0.0], None, [0.0, 0.0, 1.0]],\n",
    "        [None, [0.8, 0.1, 0.1], None],\n",
    "    ]\n",
    "\n",
    "rewards = [\n",
    "        [[+10, 0, 0], [0, 0, 0], [0, 0, 0]],\n",
    "        [[0, 0, 0], [0, 0, 0], [0, 0, -50]],\n",
    "        [[0, 0, 0], [+40, 0, 0], [0, 0, 0]],\n",
    "    ]\n",
    "\n",
    "possible_actions = [[0, 1, 2], [0, 2], [1]]\n",
    "\n",
    "def policy_fire(state):\n",
    "    return [0, 2, 1][state]\n",
    "\n",
    "def policy_random(state):\n",
    "    return np.random.choice(possible_actions[state])\n",
    "\n",
    "def policy_safe(state):\n",
    "    return [0, 0, 1][state]\n",
    "\n",
    "class MDPEnvironment(object):\n",
    "    def __init__(self, start_state=0):\n",
    "        self.start_state=start_state\n",
    "        self.reset()\n",
    "    def reset(self):\n",
    "        self.total_rewards = 0\n",
    "        self.state = self.start_state\n",
    "    def step(self, action):\n",
    "        next_state = np.random.choice(range(3), p=transition_probabilities[self.state][action])\n",
    "        reward = rewards[self.state][action][next_state]\n",
    "        self.state = next_state\n",
    "        self.total_rewards += reward\n",
    "        return self.state, reward\n",
    "\n",
    "def run_episode(policy, n_steps, start_state=0, display=True):\n",
    "    env = MDPEnvironment()\n",
    "    if display:\n",
    "        print(\"States (+rewards):\", end=\" \")\n",
    "    for step in range(n_steps):\n",
    "        if display:\n",
    "            if step == 10:\n",
    "                print(\"...\", end=\" \")\n",
    "            elif step < 10:\n",
    "                print(env.state, end=\" \")\n",
    "        action = policy(env.state)\n",
    "        state, reward = env.step(action)\n",
    "        if display and step < 10:\n",
    "            if reward:\n",
    "                print(\"({})\".format(reward), end=\" \")\n",
    "    if display:\n",
    "        print(\"Total rewards =\", env.total_rewards)\n",
    "    return env.total_rewards\n",
    "\n",
    "for policy in (policy_fire, policy_random, policy_safe):\n",
    "    all_totals = []\n",
    "    print(policy.__name__)\n",
    "    for episode in range(1000):\n",
    "        all_totals.append(run_episode(policy, n_steps=100, display=(episode<5)))\n",
    "    print(\"Summary: mean={:.1f}, std={:1f}, min={}, max={}\".format(np.mean(all_totals), np.std(all_totals), np.min(all_totals), np.max(all_totals)))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Q-Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q-Learning works by watching an agent play (e.g., randomly) and gradually improving its estimates of the Q-Values. Once it has accurate Q-Value estimates (or close enough), then the optimal policy consists in choosing the action that has the highest Q-Value (i.e., the greedy policy)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_states = 3\n",
    "n_actions = 3\n",
    "n_steps = 20000\n",
    "alpha = 0.01\n",
    "gamma = 0.99\n",
    "exploration_policy = policy_random\n",
    "q_values = np.full((n_states, n_actions), -np.inf)\n",
    "for state, actions in enumerate(possible_actions):\n",
    "    q_values[state][actions]=0\n",
    "\n",
    "env = MDPEnvironment()\n",
    "for step in range(n_steps):\n",
    "    action = exploration_policy(env.state)\n",
    "    state = env.state\n",
    "    next_state, reward = env.step(action)\n",
    "    next_value = np.max(q_values[next_state]) # greedy policy\n",
    "    q_values[state, action] = (1-alpha)*q_values[state, action] + alpha*(reward + gamma * next_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimal_policy(state):\n",
    "    return np.argmax(q_values[state])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 39.13508139,  38.88079412,  35.23025716],\n",
       "       [ 18.9117071 ,         -inf,  20.54567816],\n",
       "       [        -inf,  72.53192111,         -inf]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "States (+rewards): 0 (10) 0 (10) 0 1 (-50) 2 (40) 0 (10) 0 1 (-50) 2 (40) 0 (10) ... Total rewards = 230\n",
      "States (+rewards): 0 (10) 0 (10) 0 (10) 0 1 (-50) 2 2 1 (-50) 2 (40) 0 (10) ... Total rewards = 90\n",
      "States (+rewards): 0 1 (-50) 2 (40) 0 (10) 0 (10) 0 (10) 0 (10) 0 (10) 0 (10) 0 (10) ... Total rewards = 170\n",
      "States (+rewards): 0 1 (-50) 2 (40) 0 (10) 0 (10) 0 (10) 0 (10) 0 (10) 0 (10) 0 (10) ... Total rewards = 220\n",
      "States (+rewards): 0 1 (-50) 2 (40) 0 (10) 0 1 (-50) 2 (40) 0 (10) 0 (10) 0 (10) ... Total rewards = -50\n",
      "Summary: mean=125.6, std=127.363464, min=-290, max=500\n",
      "\n"
     ]
    }
   ],
   "source": [
    "all_totals = []\n",
    "for episode in range(1000):\n",
    "    all_totals.append(run_episode(optimal_policy, n_steps=100, display=(episode<5)))\n",
    "print(\"Summary: mean={:.1f}, std={:1f}, min={}, max={}\".format(np.mean(all_totals), np.std(all_totals), np.min(all_totals), np.max(all_totals)))\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learning to Play MsPacman Using the DQN Algorithm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Warning**: Unfortunately, the first version of the book contained two important errors in this section.\n",
    "\n",
    "1. The actor DQN and critic DQN should have been named _online DQN_ and _target DQN_ respectively. Actor-critic algorithms are a distinct class of algorithms.\n",
    "2. The online DQN is the one that learns and is copied to the target DQN at regular intervals. The target DQN's only role is to estimate the next state's Q-Values for each possible action. This is needed to compute the target Q-Values for training the online DQN, as shown in this equation:\n",
    "\n",
    "$y(s,a) = \\text{r} + \\gamma . \\underset{a'}{\\max} \\, Q_\\text{target}(s', a')$\n",
    "\n",
    "* $y(s,a)$ is the target Q-Value to train the online DQN for the state-action pair $(s, a)$.\n",
    "* $r$ is the reward actually collected after playing action $a$ in state $s$.\n",
    "* $\\gamma$ is the discount rate.\n",
    "* $s'$ is the state actually reached after played action $a$ in state $s$.\n",
    "* $a'$ is one of the possible actions in state $s'$.\n",
    "* $Q_\\text{target}(s', a')$ is the target DQN's estimate of the Q-Value of playing action $a'$ while in state $s'$.\n",
    "\n",
    "I hope these errors did not affect you, and if they did, I sincerely apologize."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating the MsPacman environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(210, 160, 3)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env = gym.make(\"MsPacman-v0\")\n",
    "obs = env.reset()\n",
    "obs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Discrete(9)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.action_space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocessing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preprocessing the images is optional but greatly speeds up training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "mspacman_color = 210 + 164 + 74\n",
    "\n",
    "def preprocess_observation(obs):\n",
    "    img = obs[1:176:2, ::2] # crop and downsize\n",
    "    img = img.sum(axis=2) # to greyscale\n",
    "    img[img==mspacman_color] = 0 # Improve contrast\n",
    "    img = (img // 3 - 128).astype(np.int8) # normalize from -128 to 127\n",
    "    return img.reshape(88, 80, 1)\n",
    "\n",
    "img = preprocess_observation(obs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: the `preprocess_observation()` function is slightly different from the one in the book: instead of representing pixels as 64-bit floats from -1.0 to 1.0, it represents them as signed bytes (from -128 to 127). The benefit is that the replay memory will take up roughly 8 times less RAM (about 6.5 GB instead of 52 GB). The reduced precision has no visible impact on training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overriden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAACJgAAAV4CAYAAADmffVBAAAgAElEQVR4XuydCfh90Vjv3+tWtwElKpWQsYjIECpdM6WQlCHczJIpNMgQGco8l7lQpmQImV0a6EaUynCjFBFRopKm+3y0lvva9rDOPmf/zvnt83mfx8P/d9Zee63Pmo7zftf7/rfQJCABCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQkMELgv0lHAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQkIAEJSEACYwQUmDg/JCABCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgARGCSgwcYJIQAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEJCABCYwSUGDiBJGABCQgAQlIQAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAISGCWgwMQJIgEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpCABCQwSkCBiRNEAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQkIAEJSGCUgAITJ4gEJCABCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQwCgBBSZOEAlIQAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEJCCBUQIKTJwgEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAKjBBSYOEEkIAEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpCABEYJKDBxgkhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQkIAEJjBJQYOIEkYAEJLAdgb+IiHOVKr4+Ivj3Sdj/ioinlhf9ckTw79NqvxQRNy2N/+GI4N+HZGtifUhcD70t/zMiXlsa+bqI4N/HaHeKiIdHxH9GxKUj4k3HCME+S2CFBJ4VET8YER+OiAtExN+vsI92SQISkIAEJCABCUhAAhKQgAQkIAEJSEACEtgxAQUmOwZqdRKQwIkQQNBxrYi4RkScNyK+KiK+ICL+JiLeHxGvjojfiIjfP4HWKDDZHrICk+0ZWsPuCSgw+a+99V0RceaIwBl9gxHMfKfESX2p9J+LRcQXlWfeGxHn3nKYzhYR14uIa0fE+SPi7BHxLxHxwYh4T0QgBHrNBiKYc0bEzSLieyKC/33GiPjriHhLRPxKRLygCGu2bPYij39jRFwlIr49Ir4pIr42Ir44Ij5WhI6/U8R69GUTQyjJGF6y/PclIuJMqYJt/r8DbYb31SLiHBHxP8qZ/YaIeFo5uzdp61TZLA7sK/upwou5yfcF5vjrpyqd+Pw85bvJFSPiGyKCOXuWiPhkEXAwTxmT34qI34yIf56oL+9DQ0X/tfSDut8YEU9vXAPni4i3R8TnRcSjI+IOW/bdxyUgAQlIQAISkIAEJCABCUhAAhKQgAQkIIEjILDNj8RHgMcuSkACB0YAR83PRMSti0Nkqnkvj4i7RsQfTxXc4nMFJlvAK48qMNmeoTWME5gjFpnzzNrG4XERcdsisrhwcUb39RExAsI+hChDto3AhO+rt4mIB0bEl05A/sciFJkai5tHxCMj4ktGCr4qIm5cBCxT9Z3U54hKiCjDeLTYcwu7j04U/uqIeFtEnHWi3Nz/7/DTEXHviPj8kfqfWc73j7d0rKHMlMCkr4r/HRE3iYi/aqg/F7lg6R8RQc7Q+CxzlT7ffyT6WYvApO91z46IW0bEFEsioNHffyuCmHc3tt1iEpCABCQgAQlIQAISkIAEJCABCUhAAhKQwJESmPsj8ZHistsSkMAeCVwoIl4WEV+X2oBDhNu6OC65xf41EXG5jpOTv98oIp63UNsVmGwPVoHJ9gytYZzAHLHInGfWNA5EGyF6CYIAInlcZ6RzLU7wuQITvqs+ISJukd5PKo/fTcIPIpl8c4ni0SIwIYrGkzv1EfmE6B9EAyGCR7U/iohvi4hPHMjg/mQR2tTmkLqINjJWfxcRX1GimvDf1f4kIr4zIj4y0gfG+88b+jjn/zvcNyLumer+QIngQVQPIqRkscwrIuK7i+ChoTmjRbLABKEFUVKyfWFJccf41kg7fP5nEXGZCV65nutHxFM6dTAucKcuuLOOvrJE+SHKSTYikPDdhihsXeuurcf2lKHtRITh+w9ReKoRxYbn+a40ZHy3op0YUXt+aFvoPi8BCUhAAhKQgAQkIAEJSEACEpCABCQgAQmsm8CcH4nXTcTeSUACh0gAB8hvlzDztA9nzEMi4qE9DiBC7nODmM+rg+0/yg1dnCfa4RFQYHJ4Y7K2Fh27WGTOeJIy40fLg0TNIJrHkFW+CBzeVNKNkHKEqA4/Vx6aKzBhL79LqeNDEXG34gj/957GkJLkuiUixFBbaROROmokDc4FomIhTKlGepNfS2fOU0tqlzkcd/1MFZi8NSKeGBFEqugKR0gZd+fC4b+XBjynnI1D7akCE4Q0fxAR/6eMIyIMolxU2/T/O1ypM3ceHBH3iAjS01Qj9RICDd6FEekEUcq2lgUmY/OPqC1E6/mB9MLHRMTtGxrAGmGtVCNSDHP2SRHx4YHnSUPEPL1jEYZQDIHJ+3rKdwUmY/yJxsN6q+uW6m5X+jbWFaK2IEBiTZF2EFaaBCQgAQlIQAISkIAEJCABCUhAAhKQgAQkIIFeApv+SCxGCUhAAidNAIcTjkpulWP/FBHfFRGvm2gI4f4pc/5SDufht5Rb3ifdB983TkCBiTNkaQIKTDYjTBqa95f0MUS1wOlMRIYhO0tJrUK0hmytDv6her89Il4fEXxf/WBEXD4i/u9mXfmc0ggtrlf+SoQH6kSE2LVrRMRLyx9xvF9kJEVQfhYnfxarbNJcok9MRUr5viIEeGFDxYhMHpbKfWNEvGPgOaJgEFnj7R0emwgc+qpGqFIjwjwrIhCT9BkpkH6hfEC0Edrytw19HCuyyfxDiPOG1FbGkHmNoHVsfr42pex7c0Rcc4OUSoicSEFF6ieET9sKTGo7ifZ2tfIPIv0QoWXMiFry9FIAcQwiLk0CEpCABCQgAQlIQAISkIAEJCABCUhAAhKQQC8BBSZODAlI4NAJdEPrc+v31xsbfa5yU/1MpTyOSm7paodFQIHJYY3HGlujwGSzUb1VRDy+PPKgiPiJzR7/TOlNHPx9r3hLRFysfHDtiGgRVYw19asi4q8j4gylEI53HPBD9sqIuHL58FEl4sRY/d8fEZTjmT/dkNlNI+J+EXGFklZlw8d7iyOa+MuSPo4CRILJgpOWd2wjMEFYgsAEQ8RDlJS/Gngp/5/knUkU+mMR8fCWBo6U2XT+3aQTreWyJQ1f3ytgS3sRX2FE/SBNE2mWNjWEsAioENZ0bQ7/3A/SSSGUGTO+IxFthQhwRAn62h2lKNqUg+UlIAEJSEACEpCABCQgAQlIQAISkIAEJCCBU0BAgckpGCSbKIEjJvDFxRn15YXBCyLiOhvy6N7g/tbk8MpV1RDx/A0HH/8mCsoPRwSOzXOWlDs4gL4sPfgXEYGQBSPsPf8eM1JN3DwiLhcRXxkRpJTg1j83uxFacGv6Z0qKAOq5T/l3t87sOCN9Af/u2pBTnfQPOJAvXRyPvPNPIoKb/TiVx25s13dwE/7qEfEdEXHhUg/RZnBm4Wj7rZK+ocXJuqTAhLbBBocvKQhwpJFO4l0R8ZsljUE3vUQLa26e3zAiuPkNC9Ix4aAjPQjpNFod4aT0uFmJonC+iDhzccT+Q5n7f1Tm4ovKXBmbW7Tp+hHxPRFxydImHOk4DN9Yxpc1NBaJYmjOEDXoxqVe1gVRGlhbOK+fVxoFU27ht9g5yjyhfUSH4N84WLMRRYP30iZEBjhy4fPJwhrH9fNLKpO+CBTUldfSVLu6KTTmiFKIGkCKLiJvnL2kYYE/KUeYE6RjmVpffeuBvZB5zJzDGc0eRL2kDiOVB5E4dmlEfyKyB8ZeRWSHObapgz+/4zLpvUTdYJ1ta7eMiCdsMF9vFBHPKOWZ63Wv72sH8+UVZcz/pszboWgh3efZR9jHWQ+85xI7iN5R34Egs56bpHK5w4YQ5wgc6ivuHxF3L/+ATY2qMdSEny4iGz7nDKlzcMMmf6b4pvPvohHxh+llY4JWIrH8aipL3+jjrm0Of75n1Law35AyacpeUvZbyrHvcj5qEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQ+h4ACEyeFBCRwyAS40Y2ztRrOJpxOmxgpBz4QEfw3Rn2IRrrWFZjg3EYo0L35y+3kOQITHDxPLoKEofaTmgBHII6re5dCuxSYXLU4o3GyDhmOcBxlY6kJcoqJsbFAyPDIiLhrEREMlV1CYPJ55ab+j0QEN82HDEHMnTq31rtlu2KenyqiBhzvQ/YbZRzHUmUgfrjHRPtq/QgTcEIPGU7IJ6Xb9EPlEJoQZYH0J33WFVVcq6yDPmEXAhNSWiAMqWsC0RIprabsxyPi50uhPsczaUBw3nKjfspwCNM+Url07aQEJojFaO+VJhpLehdEIgiRhqy7HhDS/NqEwIJIT3XPmOI19Tl7HmIp1g2COgR+/zb10MDnmzr4czUIZ25X/oBQgbWyrTFGNUULQpNbT1T4NZ21grinmwaoVoH46VUpxQrnDusJ4dWY0R7Sk9R9in7fftuOpucRgLGesMclpq2vmCNwqHUTHYYoIBhCE1LBjBl7ahVLITxDyPYvrQ3tKbfp/GN883ghMMoikvyK/J0BISVixiVsDn/EgE8rjSFiDALZKSO6Delx5s6Tqfr9XAISkIAEJCABCUhAAhKQgAQkIAEJSEACElgJAQUmKxlIuyGBlRLIjtZWJ0kfCm6g4yjCiDBCpJGuZWcRt6hxTBMRgugWpNZBcIET+eKdW+ytEUyyk493f7REpuC/iaxB6h4igLw7IohWgfMe26XAhLYi2iHaw+9FBLfruTFPpIAceYKby9xgHjJECkSCwemMYw2nOUINHIIwIi0CIfarIUJA6DFkuxaY0CciW3xvemGXN1Fq8q1uRCaIYfosOylxNhJJg/7TXwRPjBmRURhDUnBUe21EIOrpc87fMSIekcoyv+CKUxphDk59opsQtQHH85jA5Hrlc+Yr9s+lLsabsb5AcfIiusFYS4wRURa6lp2ZzHsiqVyztAlRBOPNd4dvKg5MmOGor6Il/g3LKUMUQrQADGdojRJRn7tNEa/w7/eV9yJk+aciFoPLt5S21DJEOelGo2Ee8x/mI5GIMFKkMD+6xrNZpNEawYQxxyleU2VQL3OCNYZz/EJlvtT3faJE/xmKOpLXA3vRj5ZoSqwx5hsczhYRRCJCCFeN6DXPngLf8DlRGxC0YKSIYQ7PtU0d/Pk9OT0OAgnGjHnL3GBsEH8wH4j4gbCDfeY9Ew3NdVJPTQM09hi867pmT0E8NmQIrV5d5mada+wLQ6KUHygChiou+cWIuO1c2APPIZhAOIEhjvu5DeufI3CoryBCVxWfEfHq5RPv/qIyprUYe8TbNmxvLr7p/GOs+C5QjchXjGfXarSuKoBj30DktYTN4f/iiPju0hjOrPr9Z6x9iAPZszDOdM4NTQISkIAEJCABCUhAAhKQgAQkIAEJSEACEpDA5xBQYOKkkIAEDpkATrnqtMXhiSN9jnEb/FHpQdJxdCM4ZIEJggAcfvcqURZySgscSvlGdYvAhJQ4RJeo9tCIwHGc60GYgWP5GuXv1XG1K4EJ76JOokvcpIhLans4C0ibkAUPONoQGPQZt9CJdIKzEAFC16gPUQIRW0gdg5FKh3QefbZrgUmOjsH7cKjiAPxUejnpS0hJUZ3njDlpTaqDLbczOympA2EK/cehjyOuGnMGB+7Ppr/13dpH6IGQBJEAxjPMib7UKQhNiCICxwf1wOPWPGOKYxZhCvUQ7QExQrbzlP7SR2xIRJSdmTChrTh4cVB2Hb11LRBZiJQqGKIVxByIb4YMcUqtiwgvOO+7kV5I80PfWPdDznmEYogKatoN5tstBl7aKhbJj7c+89KybnmWftAGUl5lI2UR4g/GAUPkg/O8O058ltdDXbdEe8GBjaCiGnPjuUVowt8QV5BmaSwF0siwfOYj5tndyr+YT0QgmmubOvjre3DgEz2liqIQlhB5h3YhIOsz1g/7JfN/yODHWsHYa1/W0DEiyPB+jL3lwRPPMC6Iy6qACoEU+2lX/IKQh3lS+8j8Rai17fjl5uWIIPydfoxFz+nr2hyBA/VwpmURG6KwlpRBpH6q5wYCHOb4XNt0/j2g7Me8j/nE3oRIpmt5z+OzFvHM3D5swp+5zT5R1yx7OGJIzqsp41nWXBU7MY/7+j5Vj59LQAISkIAEJCABCUhAAhKQgAQkIAEJSEACKyegwGTlA2z3JHDKCeDgqc43IorgPJxjRKt4TXoQJ3s3ekAWmFCUdAxjjspa3ZTABGfNe1NED27Mc3O+zxAuIMKozkzK7EpgQl2IIYj6QASFPsORhxMX28VNehxbROXASKvzgwPv3aXAhDQViIdqSiRC/ldneff1CCSICFF54xQmKkTXspOSz6j/m3uiZdTnEJjUdB4IDoi0kIU4WWDBPKyijzlzm9v1tc0/FhEPH6mEdBM4y4mogRG5piuo6Tozid5wkYmUSXyXID3NuUq9U85WBD8/UcoSuYQIJnONqC04zHHmf7Kw7nOKtopFcjtanunuLQirXjLQmXNHxFtT1JGhqAd5PVAVgi6ESn2GA5xoKYzt0JhuyhbRRRXtIHjI4rhN69rUwV/rRzyUBRmIc+r+QZoy1ippfBAzMQZVNMLzCGTq/Mrt7UbHYC8kosmUEVEKwRPG3EUQNmUIJGhjTZtClBVEJpwXGNF02BNr1CHSmZC6jYhDuzKEOOy/dX9jrbPmN7VNBA65bgQlRDyq1ipY+KOy5/Bca5SZoT5tMv9oL4yIRoWNRf4gXRlpjaqx9zHGS1iX/2N7XsJZhnAWQRFnIMaZg0BnKmpMro69pIrgeG8VDi7RL+uUgAQkIAEJSEACEpCABCQgAQlIQAISkIAETikBBSandOBstgSOgABOEhyJ1UgpkqOQbIKA1BnZkdiX5iALTEihgcOoL7VJ971TAhPC1BOuHkNsgBOoL2pBrbd7M3qXAhNuzP/6CDhu9BONAePG8yU2gTxQFgcjjjvSj9SIHd2iuxSY5NQq3J7HUU3KmCHLaQEoQ1qad3YKdwUmRKR5ykidOPsQXHx1KdN1kuaoAi+IiOvM5IzIBcECxvxmvKaiHxB15ZnlmUeXyDX59V1nJqmNiBIyZYixqghiTDTC9w4EV6SFwqbEKFPv5fMcsWYohUmLWKT7rpZniEBRhQ8IEYg2M2a5rUSxQSDRHbO8HhBRnLOIZ4bqRXyBIxkjEhHjuo0x/2t6jNYoH0Pv28TBn+sgFVlf1AXWHWdBFsnl6E/UAc+r9KQ2QfRBdIxqrRE1Mt/HRAQRsVoM8Q8O+pp+jLMCkQnrlpRpVVyCkAGR1S7FJbQPARPCTIy6efdQFKmx/swVmCBsQdBWDYEPIrApQ+TBvowRiYMoOnNtav6xV3PWs27Zv2o6HyKt0O++NGK0hXWWU6qRqqovmlduN2f5WUc6ggC0L01bl38LC1KqsU66KcOmniVqGdHGMNgR5UuTgAQkIAEJSEACEpCABCQgAQlIQAISkIAEJPBZBBSYOCEkIIFDJYDjldQC1Ug7QQqBOUbaiJzKhNvHOGCyZYEJQhacMy02JTAhnUINVz8WxSO/Cwc8TmVsVwITHHuIdvrSsNR3kzYGpzf20QlnWH0GRzTpP0hlhJMNh10+WxBPEMEDo0+kBunaLgUmMK6plEj5c+eGQcw35m9borfkx7KTkpQlCGWGosDU5x6W3o2DGmFHNcQV9bY7Iiqcqe9qaGe3CJEUSOmAtaTuoFxOW4EohSgO2brOTByizIUpy9EKYINzPadzqc/j5GatYURHQXA1lk6Hcjh9ibxANAjaQ3SanCYFUdCVSp2ktcopiup7W8Qi3T62PIMDGqYYUSleOAEKkQP9ru3vEznk9YCgAkHTmP1kiXJCGebdXaYGa+JzBHCsZYy5SQqmuTbl4B+ql6g+RBfKBlsY9xnRnxAzIN7AcJQz17Lldcff2bO6aWv66ia6SI2yM5aGqe9Z9j5EJpxBGGca84X2YuxXN2xYA5vyJ+IKvOpePBYFZ6ruuQIThAo5zRrRvFpENFnkcM+IuN9UA0c+74oDp6qifYj+blfW6VB5UtzldhFpbWofy98V+uplnsC6a3MEJtTBWcv3mOdPdTp9jgC1Ch7ZV0jNpUlAAhKQgAQkIAEJSEACEpCABCQgAQlIQAIS+CwCCkycEBKQwKES2GcEk5tGBE7FFpsSmLwyIq5cKsLxiwN4ynKqml0JTP4wIojkMmbcqP9UKUD0lnrDvu8ZIrPgyCfSQKsNpaTYpcAEIVF15hLVAZZTRoSOmrboiRFxq84D2UlJOpacwmiobkQuOI8xxCM1ikEt/4aUrgJBBukWcASSMqdPmNH3npy64zcbneWc+0Qlwf42IhA8ZMvOTKKw1HQJUwz5/M1JsHKjkmKi+xx8EYthpPMhrc+QIT4hJQlpmxAutdiQOKxFLNKtf+qZrggO4QARR6bs7SVSDuX6OOX1gEAKodSYkcbmCaUA6Wz49zaWU5ORzulPtqhsrsAE0VpX2NIXXSg3LUeL4u9EEELMU+2kI5jU9zKPEU0QTSkbznyi37REytpkCNifSM9T0ya9KiKIRDP3PXMFJocWwaSFIeISUhWNRRmjnjkRTHYlMOn7/26IdxDfEcWKs4xITtVunfaHKQZEn2JPwjjfEexpEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQ+i4ACEyeEBCRwyASyo3NIaNHS/itExGtSQW7H48jPliOYfFdE4LBvsSmBCSlM6q36VsEDjvc7lZfvSmDSd6O/r385XcfQGUHaBdIvbGpEFMg32uvzuxSY5OgL39pJ0TDU3p8oQgY+R+TxfZ2C2UmOU5hUQ1PGu99YCv1dRHx554ELlTlJpI9sOIGZM3B6eUnzMXQzHrHLNmmMqJeb99myM5mIEPSj1RBDVAEVqZZw+GdDJILDv6ahoO19aVB4BuHSqyPiLK0vL+WeGhE363lmSizS95qpZ3LqLdIwfXFjW9lbSA2E9aX+yuuBvtCnMcvzk5QW/Hsby/vuRSLij7eobK7ABDEJQpxqpNoigs2YMZdJU0IqFqybEoy/Z/HWkOCt+44s5ELwROSgTe0mnXQjREI6/0BEp03rzuXZV9g7aioWRDpXbIi4NPbOuQKTHNWI+tkD2QunLEeU6qYXm3q2+3mefx/vCEeZL0SYYa9BBFSN9xMRCQHekBEFDVFgNdLs1KhUm7Qxn6WtEUxa/r9brpe5dtHGKFlEdiOiDqbAZJORtKwEJCABCUhAAhKQgAQkIAEJSEACEpCABI6IQMuPlEeEw65KQAIHRuDPShoDmvW8EslgThNvHxFENqiGM+n9nYqywARBSk3jMfW+KYFJ7sM1I+IlUxUWx849SrldCUyGnFfd5kwJTK4SEa9IDxGJAwc4jkxC8hONA4dWtRauuxSYINDgNjfWGn3hRyPi0eUZbvvTx2zZSckN75ouY2woeffbSoGhaDCIS0i1gPO5piTp1sk8xVlIZIqu5WgtDdOqt0j3e8CUqGLsPaRYIgUI/Okzztsc0QPhDusYGxMMIERBXFAjPlDH44vghPVEyh4EHXWutggs5vRr6pmcxqUvGswQq19LIiXW+f07BTddDy3932R+HEKKnG60EZjV1FdjfSFSE850jCgTdV3XZxCYVAEKUT1e1gAGoVWNWtSaiipXe/kiWOwKkFgDnDUfamhDSxHWy2+nlGREnuHdLSmuxuqfKzDJ6biovy8dVN974VEjK7WKMofa3yJwQmjCHvzYiPjCUhEiMISmQ9ZN/9M6l7r1LSUwoU/vTqn26Bvn3JSZImeKkJ9LQAISkIAEJCABCUhAAhKQgAQkIAEJSEACn8nNLgoJSEACh0iA2/g4fjAc1183s5E57DuCkG6qAqptEUL0vX5KYDIngglRIIgGgR2awARxSRVgPKWkO8milC6jnDZlSLizqUN9bBqclggmuQ8IKi4TETgtLxcR3xYRpIjKhqMch3m2PLcQbxB9ZVubElVM1Y/D/mqlEMKux6QHEJfU6DB3j4gHDlTGDXpu0mMIbHDuf2DkxVlANhTBY06/pp45iQgmpOtgfYzZrgUm70gpnTaJ5tTXxhYH/1DfPpIi/8AAFlOGwIL1gyHeekDngbekVGGt0TGIulMjDZF65DemGpE+py2siTOWv/G/EVoQ8QIjOgz74li0jJbXka7pt9LZhriA/WRs3bTUS5m5AhOeJWJJjVhE1B6iMo0ZAg/EY9UQC1WhXmt7c7lN5h+pYfiuUI1n2U/6jHZy1tTUXUT0uu+MBi4lMKEpnM91zbCmmXdTxhxCOIeN9X+qHj+XgAQkIAEJSEACEpCABCQgAQlIQAISkIAEVkzACCYrHly7JoEVEMjOIbozlGJlrKs49nCyVQffUAqNpQQmRMQg3D72YxFB+pspe066rX9IAhMiUxAB4Asi4j8i4qsbbt8TfeJspcMnITDJUT2IeEDkgyn7hYjA2Yw9MSJu1Xkgz0PS0tRoBmP1fn9EPLcUoE0XmGpE+vzzy5zBQV6dfXx86RIpphbFWXvV8o8fiQj6sa1NiSqm6s+pI36vCGd4BiczjnocsgiSzj2SUuLJKc3N3SLiIRMv5fO7lDInKTDBqY/wrRpRF1qEAkRnIQUMhlP7Vzv921RwtWuBSU7hwx7mPj4AACAASURBVFpgTcy1TRz83XcQdYkIHNicCCZEbCByQzZY36D8gag4dd0P9Y8oPDnaFWltiKLTYojGEOSdqRQmbdR1SjoW+lbTshB1hTQ2cyONIH6hvguW9zAnEZcgftyFbSMw+d2IuGxpBKmFSDE0Zgjsavo6Unh9SSci1qb92XT+vTAiEBFhRORi3/7kwEtfW8Q3fNySwqmvmiUFJkRGQsiHtabwek8SKTHuzCtNAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkMBnEVBg4oSQgAQOmQDOJZw8ZymNxPlz7Q0bTCQQIoJU+9aIIOVB15YSmGTn97Mj4voN7c9RUQ5JYIIjE5EAxn8jMBmzC0UEaRqqnYTAJItzEPMg6pmynFbjthHxi50HspMSZyOCmX+cqPSh6d2t496tEjEGghbS7WA/GxH3SoW4MX/P8m8ifiDu2Na2FZiwZv+mOIZpy/lKqoZbJKHCVLqmLHBoiXqQU5gMCUwQp9W0V1PvrwxbWNBXUoFg14qIF00MAHOHZ85QyvWlDdm3wOTnI4JUMBjz+K5bTKpNHfz5Vcx19j+sxYFPWpB/SClw+sbjlhHxhFLnO5PQZ6iLiFGqAOgvU+SRKSSI0F6ZUl8hBqM9NX0Y64L5iEgJI7IKQkQifmxiZ40IhA4XKQ+RXgZRDn3blW0jMMkiBxiwnscMEUqNOkM0jSowmtuXTecfIh3OrJpmje8Pjxh4OWf5M9NnRG7K6eNa2rykwITz706lEZxXVWQ71C5SOH087U187yJKiyYBCUhAAhKQgAQkIAEJSEACEpCABCQgAQlI4LMIKDBxQkhAAodO4H4l1UFt5yapQEhDQAqC6lh5fYmC0tfnpQQm10wpFT5Rbq1/bAQ6EStwrFU7JIEJERpwYGL0oaY+GOoOaV2IIlDtJAQmRCSokTyIXHOekRvotOuSnaggRJboOme7kXSm0pYQ4YWb4NV53JqKo49jFqrgGL91KkREE6KEYNxQJ/UT4oVtrEVUMVV/TkmFA5U5nNcXTv4njVTykoggNQs2td4vUUQ4tbohgQnCsjeWQkRVqGlUxvrSwuJZEfGDpRJSFNUUQEP1ItZ4cPnwr8t+0E0xtW+ByXVT5B8iMNWUWFPj3vf5pg7+XAfCqpweBef/u0YawZxh7mBEWELM0xVsIJKDexX4EF2jzou+qnOUoL40VX3PMCfhVvdHhCZExehGwiA6BuuiCvVIJ3blDZz6pNF6TUTwPoy+Mmf/aM5AjTyzjcAEoU0VdBKRhMhFOepP97XsvTXaE1GJsjh0TrfmzL+8fzFXOEOqMCi3AREK7T1v+eN7I+Kby9nY2tYlBSY5AhDrpka4GWpbPk82jbrV2l/LSUACEpCABCQgAQlIQAISkIAEJCABCUhAAisgoMBkBYNoFySwcgLcqv39iCAaBkaKlmtEBGKRMTt7Ce9enVXc4P2WEQflUgITbtXjeCLVAva4iLjdQMMRJtAvnOHVDklgglOWNA5fWho3FkIfBz4OrnoTnEdOQmCC05WUFlVUREoGbsX3GbxpI6ksMCIBkKqia12BCVF1cCQORRvITkPmHWNPZIVq3AxHoIMTfMpyRBbEVjViSX0up2nAkY2g6VNTlZY0R0Qb6fahRVQxVT03+V9WCuGoJDIDa4DvHDjZWZtjIqssTEJsgaCnz9gbEGOxrqsNCUyIGEFbMNqCo3vKWlgwp3HyVxuLuILg7a1JeHDviCAKTdf2LTBhfpLairVLRIMvj4h/m4I18PkcB3+u6tVpTY4JeEgrhdjq4uXhF5R0NH3NInUVKaww5g/RbboiHz4j/RQCEwxxxEVLJJUxFBcr86FG3WJusCYRgPUZgjbOHoQvGGIMBD15v+h7jrlP22oKLcYJcUpfdK6ZQ/eZx7YRmNQ+1bRiY5GWSMdE2iKM/iDsaEk5Nda/OfOPMSGKSRUh9aVaqu+EP3sw5zyGSIjxrpG+ptgvJTBBOMlcqP8/D9EladTGDEFPTUc29j1lqk9+LgEJSEACEpCABCQgAQlIQAISkIAEJCABCaycgAKTlQ+w3ZPASghwk/23k7DhX0sUAG43f6TTR0QDhK4nSkBNXYEj/yYRgXNryJYSmPC+nJaBfz+oCAWyEIDoIE8pziluS5MeBTskgQntIV0EaSMwUvkQvaHr1PyBkg4FsQcCC4QM2EkITHgP6T1I81ENYQbpZTJvHLo48mvKBhzoOAtrRJA8T7KTkjqYY6SuYZ69OxXEIc+7SQtRz9d7lH936+PvpOL5tcKxOy8Zf+bNo1JdiHaIvpGNtfGGJKih/Xcc6AfPIbhizEgFhEP3xZ36WkQVg4uofAAHohQgJMGeFxFExcDo7/UmKsiOfRz/dytpKnDyV0MwwvjBJM+xIYEJbcJpj2Me47Y+wrUxa2Xx0iJ6oy6iFN0sIhAxZCPKBNFOaDeGSAnBQl8Kin0LTGhfjn5wuTLHJnD1fjzHwd/lxpyuQrUnRgRpS3KKKvbOp0bEd5cHWaOML6mv+gwBAVE+EKVgTy/rIdfJXsUYkoIGo37GdcxIU4PYoD4DQ6KqIIocM8STPFfPKyKqsAYQWfQZe8NvpMgyiFfYx6ZEl3PGj2e2FZggMCOiSzX2ZoRynOPVODOY919U/jAkvtq0D3PnH6lvajo71irrdki4hwAFUVw1vpMg1HhyEWr1tZnoNtQPhyo+HUrdtSl/hEbsg7Vezjb2mrdPwMuRo5i3pCrTJCABCUhAAhKQgAQkIAEJSEACEpCABCQgAQl8DgEFJk4KCUjgtBDAkY7D4xypwThOcK4TkQDnD6kGcIbWCBsURaxx4x6Hb7ffSwpM2Gu5fX+t9FKcULyTiCD0CYfmF5bUKi8sTlSKDznasuNsyKne6iDPLPJN/r4zAmco4orqCKQ8Y0AIfoQXpJwgVQuGMxhBAxECsJMSmHDznAgG39PhjROXiB1fV9pSRTwUw2n9iIHFkFkjsMHZiAOb+UcEBEQmZ4qIy6d0F1SFwxfnajf6Qzciyl8Wh3dNP4Qwg6gqRI6oNnbznxvzz07iCZ6hTX9Q5hfzCuc1Tsaatocy8FlCYELdD4+IO/XwZA28qGHTyQIHiv956Q+RT85f1jmiA6LVPLKItig3tBb4DIY3LO/G6U+UFdhX4Qpr8QGpba3rB7HS76RUGVRBtBSEEexLrBmiEtX1hJCBKC8802eHIDDJ0SQQxP1Ew5iR9ojICdmYw6w3DEHBn/bUc4tOmqNuESIvPDb9EVEOa5koK8xn9pUqHGI/Io0Ue8+Y3byTpol9gWgjiJDqeNXnEaMgPhsSfNRyRNxgzdMm9gUibWXRylh7ON/oE2l9iEzCOulLy0IdjAeiq2qsc/bgFuPc4UwZMiLqkM4nG9GgahoY/t4n3LnXxLpG4IeorhqpZ2BERCPEV/S/GpGYEDjMjZqT2z5XYMIcID1TjWLCnCJF2ZAhukRQUs9FyjEXSdH3Z0UIy7/5bsL5gRipCpwoy1j/dESQEq1rXYFJXgu1LHshaw2Weaz4nH2YPXLMOL9YT5yJnEPM4V3wn3itH0tAAhKQgAQkIAEJSEACEpCABCQgAQlIQAKnkYACk9M4arZZAsdLACc5ET1wSNaQ9GM0XhERdy2OoilqSwpMeDeOGxzH9VZ0X3u4YXydEm3l7qXAkPBhXwITmoXzE6FFder29QVn3B2Ks/SkBSa0h/mByIFIHTlNT7etCBZwwDE2Q9ZlzdgQlaOm1ul7jtvgjDURLbpGeg5S37ScwUTfIdIJbcw3/rt1krIHBycOxhYj+gxzjZQt2VpFFVPvoB0IkbLh3EYENtaPWh7RBpFBcvqb7jsRKxANBbEPESawMYEJKWqIDlEjq3Tr66bO2YQF7WVN9KVYyu/B2YzIZSx6yiEITHCEI94h+hDiHpzWfWlkct/yHjo1P/LnQ8KzXAZBCOsZR/iQITy5TRFbtbyfcwRRWY2w1PcMKXoQKH6gpcKIuGBEPLDs4X1rf6waBGBEtCDa1lBKHZ7P86OxWZ8pNpUeam7dpLEa20PZ6xBQIETJwopu+4nyg5hjKkVQa7/nCkyoP6cnYw0glhwTXRAZB/EO0ViqMGWqnYiWeA9RttiT+6wrMJmqs36OYI5oVs9oeOBGqRwiF743aRKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEegm0OLdEJwEJSODQCJw7Iq5d0gJwGxjhCU4rbuCSmoOb6EQBmUqBkfu1tMCkvovUBzg2ifRBu7k5j9MZxxpOcm68/0JxlPLMkONunwIT2kWUkh8rqRzOWRxv3EonKgOOxpquoYXrpg71TebjhUtqCyKJEEkBBzWONyKuIGAg0kE3zVK3/j7WRGv5oYjAMYdjkcgD1MOcYxyJoDJmCBKYC6R4QRxC9APSJmCIXmgfaaGeNhD1Yahu6mRtUC8pEqiT2/GsjXeWqBpESCDiQZ9gYBNRxdQ4IAD5xlSIeU00ilZDlMVaQahDhAMETdyupx9EbCEiCZFIWtZCfSdrjpQWcMJhzHyoYrVtBCa1flKVkIKIiBcIWdiXaPNbypzA2TslsNl0PWzS/1b2lCPtB6wweBFZYsyWFJjwXqIq0FcibHAGnKXsn+8oaxlRG/vpJsbehXiFaD78b6J1ICYhKghjxTqeEtZs8r5dlJ0rAuHd+xKY1H6zH7CmmU/sx6wPeLMfIQ7LqXR2wWobgQlRRojWUv+/EimSqpBtrG3s5URgQWxGf0mZxFxFNMT8JOUO4jvSnRFBaiqFUovAhDmKWIW9BtEgezzfKVpFTkTP4T1Ec+I71ZDYZRdjYh0SkIAEJCABCUhAAhKQgAQkIAEJSEACEpDAKSegwOSUD6DNl4AEVkkAkQapfjCiZJBqQ5OABCRwkgQQcSB0QgSAYA/hkiYBCayLAOmASOXD/yckChOiSU0CEpCABCQgAQlIQAISkIAEJCABCUhAAhKQwCABBSZODglIQAKHRYA0Hu8uaV0+FRGkqvjkYTXR1khAAkdC4HElzRQREogGRBovTQISWA+BGhGH9D9EXCGimiYBCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIYJCAAhMnhwQkIIHDIcCe/PyIuFZpEmlASA+iSUACEtgHAVI5EcXkzCXlxg320QjfKQEJLELgvEU0RpSix0TE7Rd5i5VKQAISkIAEJCABCUhAAhKQgAQkIAEJSEACqyKgwGRVw2lnJCCBAyZw34j4SET8SkT8bU87SUfxiCQu+feSHudNB9wnmyYBCayfwJ0i4uERQRSTS0XEm9ffZXsogaMg8MwiYv1wRFwgIv7+KHptJyUgAQlIQAISkIAEJCABCUhAAhKQgAQkIIGtCCgw2QqfD0tAAhJoJpDD0L8tIt4RER+LiDNGxDdExMVLWpxa4X0i4meaa7egBCQgAQlIQAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpCABCQggQUJKDBZEK5VS0ACEkgEqsBkCso/R8S9IuIhUwX9XAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkMBJEVBgclKkfY8EJHDsBL6spL+5YkRcOCK+IiLOVqKWfDQi3hkRr46IJ0fEB44dlv2XgAQkIAEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQOi4ACk8MaD1sjAQlIQAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEDo6AApODGxIbJAEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpCABA6LgAKTwxoPWyMBCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQOjoACk4MbEhskAQlIQAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEDouAApPDGg9bIwEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpCABA6OgAKTgxsSGyQBCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQOi4ACk8MaD1sjAQlIQAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEDo6AApODGxIbJAEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQkIAEJSEACEpCABA6LgAKTwxoPWyMBCUhAAhKQgAQkIAEJSEACEpCABCQgAQlIQAISkIAEJCABCUhAAhKQgAQOjoACk4MbklkN+s9ZT/mQBCQgAQlIQAISkIAEJCABCUjguAj4O8hxjbe9lYAEJCABCUhAAhKQgAQkIAEJSGCHBPxhZYcw91iVApM9wvfVEpCABCQgAQlIQAISkIAEJHBqCPg7yKkZKhsqAQlIQAISkIAEJCABCUhAAhKQwKER8IeVQxuRee1RYDKPm09JQAISkIAEJCABCUhAAhKQwHER8HeQ4xpveysBCUhAAhKQgAQkIAEJSEACEpDADgn4w8oOYe6xKgUme4TvqyUgAQlIQAISkIAEJCABCUjg1BDwd5BTM1Q2VAISkIAEJCABCUhAAhKQgAQkIIFDI+APK4c2IvPao8BkHjefkoAEJCABCUhAAhKQgAQkIIHjIuDvIMc13vZWAhKQgAQkIAEJSEACEpCABCQggR0S8IeVHcLcY1UKTPYI31dLQAISkIAEJCABCUhAAhKQwKkh4O8gp2aobKgEJCABCUhAAhKQgAQkIAEJSEACh0bAH1YObURmtOd9d7yjApMZ3HxEAhKQgAQkIAEJSEACEpCABI6LwDke+Uh/BzmuIbe3EpCABCQgAQlIQAISkIAEJCABCeyQgD+s7BDmvqpSYLIv8r5XAhKQgAQkIAEJSEACEpCABE4TAQUmp2m0bKsEJCABCUhAAhKQgAQkIAEJSEACh0ZAgcmhjciM9igwmQHNRyQgAQlIQAISkIAEJCABCUjg6AgoMDm6IbfDEpCABCQgAQlIQAISkIAEJCABCeyQgAKTHcLcV1UKTPZF3vdKQAISkIAEJCABCUhAAhKQwGkioMDkNI2WbZWABCQgAQlIQAISkIAEJCABCUjg0AgoMDm0EZnRHgUmM6D5iAQkIAEJSEACEpCABCQgAQkcHQEFJkc35HZYAhKQgAQkIAEJSEACEpCABCQggR0SUGCyQ5j7qkqByb7I+14JSEACEpCABCQgAQlIQAISOE0EFJicptGyrRKQgAQkIAEJSEACEpCABCQgAQkcGgEFJoc2IjPas7TA5BzP++oZrfIRCUhgDoH3XfcDcx5rfsb13IzKghKQgAQkcIoIeH6eosGyqRKYILD4en7kI/0dxFkoAQlIQAISkIAEJCABCUhAAhKQgARmEvCHlZngDukxBSaHNBq2RQLbEVj8B3UFY9sNkE9LQAISkMBBEvD8PMhhsVESmEVg8fWswGTWuPiQBCQgAQlIQAISkIAEJCABCUhAAhKAgAKTFcwDBSYrGES7IIFCYPEf1BWYONckIAEJSGCFBDw/VzioduloCSy+nhWYHO3csuMSkIAEJCABCUhAAhKQgAQkIAEJbE9Agcn2DPdegwKTvQ+BDZDAzggs/oO6ApOdjZUVSUACEpDA4RDw/DycsbAlEtiWwOLrWYHJtkPk8xKQgAQkIAEJSEACEpCABCQgAQkcMQEFJisYfAUmKxhEuyCBQmDxH9QVmDjXJCABCUhghQQ8P1c4qHbpaAksvp4VmBzt3LLjEpCABCQgAQlIQAISkIAEJCABCWxPQIHJ9gz3XoMCk70PgQ2QwM4ILP6DugKTnY2VFUlAAhKQwOEQ8Pw8nLGwJRLYlsDi61mBybZD5PMSkIAEJCABCUhAAhKQgAQkIAEJHDEBBSYrGHwFJisYRLsggUJg8R/UFZg41yQgAQlIYIUEPD9XOKh26WgJLL6eFZgc7dyy4xKQgAQkIAEJSEACEpCABCQgAQlsT0CByfYM916DApO9D4ENkMDOCCz+g7oCk52NlRVJQAISkMDhEPD8PJyxsCUS2JbA4utZgcm2Q+TzEpCABCQgAQlIQAISkIAEJCABCRwxAQUmKxh8BSYrGES7IIFCYPEf1BWYONckIAEJSGCFBDw/VzioduloCSy+nhWYHO3csuMSkIAEJCABCUhAAhKQgAQkIAEJbE9Agcn2DPdegwKTvQ+BDZDAzggs/oO6ApOdjZUVSUACEpDA4RDw/DycsbAlEtiWwOLrWYHJtkPk8xKQgAQkIAEJSEACEpCABCQgAQkcMQEFJisYfAUmKxhEuyCBQmDxH9QVmDjXJCABCUhghQQ8P1c4qHbpaAksvp4VmBzt3LLjEpCABCQgAQlIQAISkIAEJCABCWxPQIHJ9gz3XoMCk70PgQ2QwM4ILP6DugKTnY2VFUlAAhKQwOEQ8Pw8nLGwJRLYlsDi61mBybZD5PMSkIAEJCABCUhAAhKQgAQkIAEJHDEBBSYrGHwFJisYRLsggUJg8R/UFZg41yQgAQlIYIUEPD9XOKh26WgJLL6eFZgc7dyy4xKQgAQkIAEJSEACEpCABCQgAQlsT0CByfYM916DApO9D4ENkMDOCCz+g7oCk52NlRVJQAISkMDhEPD8PJyxsCUS2JbA4utZgcm2Q+TzEpCABCQgAQlIQAISkIAEJCABCRwxAQUmKxh8BSYrGES7IIFCYPEf1BWYONckIAEJSGCFBDw/VzioduloCSy+nhWYHO3csuMSkIAEJCABCUhAAhKQgAQkIAEJbE9Agcn2DPdegwKTvQ+BDZDAzggs/oO6ApOdjZUVSUACEpDA4RDw/DycsbAlEtiWwOLrWYHJtkPk8xKQgAQkIAEJSEACEpCABCQgAQkcMQEFJisYfAUmKxhEuyCBQmDxH9QVmDjXJCABCUhghQQ8P1c4qHbpaAksvp4VmBzt3LLjEpCABCQgAQlIQAISkIAEJCABCWxPQIHJ9gz3XoMCk70PgQ2QwM4ILP6DugKTnY2VFUlAAhKQwOEQ8Pw8nLGwJRLYlsDi61mBybZD5PMSkIAEJCABCUhAAhKQgAQkIAEJHDEBBSYrGHwFJisYRLsggUJg8R/UFZg41yQgAQlIYIUEPD9XOKh26WgJLL6eFZgc7dyy4xKQgAQkIAEJSEACEpCABCQgAQlsT0CByfYM916DApO9D4ENkMDOCCz+g7oCk52NlRVJQAISkMDhEPD8PJyxsCUS2JbA4utZgcm2Q+TzEpCABCQgAQlIQAISkIAEJCABCRwxAQUmKxh8BSYrGES7IIFCYPEf1BWYONckIAEJSGCFBDw/VzioduloCSy+nhWYHO3csuMSkIAEJCABCUhAAhKQgAQkIAEJbE9Agcn2DPdegwKTvQ+BDZDAzggs/oO6ApOdjZUVSUACEpDA4RDw/DycsbAlEtiWwOLrWYHJtkPk8xKQgAQkIAEJSEACEpCABCQgAQkcMQEFJisYfAUmKxhEuyCBQmDxH9QVmDjXJCABCUhghQQ8P1c4qHbpaAksvp4VmBzt3LLjEpCABCQgAQlIQAISkIAEJCABCWxPQIHJ9gz3XoMCk70PgQ2QwM4ILP6DugKTnY2VFUlAAhKQwOEQ8Pw8nLGwJRLYlsDi61mBybZD5PMSkIAEJCABCUhAAhKQgAQkIAEJHDEBBSYrGHwFJisYRLsggUJg8R/UFZg41yQgAQlIYIUEPD9XOKh26WgJLL6eFZgc7dyy4xKQgAQkIAEJSEACEpCABCQgAQlsT0CByfYM916DApO9D4ENkMDOCCz+g7oCk52NlRVJQAISkMDhEPD8PJyxsCUS2JbA4utZgcm2Q+TzEpCABCQgAQlIQAISkIAEJCABCRwxAQUmKxh8BSYrGES7IIFCYPEf1BWYONckIAEJSGCFBDw/VzioduloCSy+nhWYHO3csuMSkIAEJCABCUhAAhKQgAQkIAEJbE9Agcn2DPdegwKTvQ+BDZDAzggs/oO6ApOdjZUVSUACEpDA4RDw/DycsbAlEtiWwOLrWYHJtkPk8xKQgAQkIAEJSEACEpCABCQgAQkcMQEFJisYfAUmKxhEuyCBQmDxH9QVmDjXJCABCUhghQQ8P1c4qHbpaAksvp4VmBzt3LLjEpCABCQgAQlIQAISkIAEJCABCWxPQIHJ9gz3XoMCk70PgQ2QwM4ILP6DugKTnY2VFUlAAhKQwOEQ8Pw8nLGwJRLYlsDi61mBybZD5PMSkIAEJCABCUhAAhKQgAQkIAEJHDEBBSYrGHwFJisYRLsggUJg8R/UFZg41yQgAQlIYIUEPD9XOKh26WgJLL6eFZgc7dyy4xKQgAQkIAEJSEACEpCABCQgAQlsT0CByfYM917DGgQmi/+IeAJO9dPeh6Xbz0I5x8LjYB+mt6Olx4AWLD0O9mF6nJceA9fz9BicRAnHuY3y0nvG0uOwdPvdt49jHrlvt42z63ma0yr2JAUm0wNtCQlIQAISkIAEJCABCUhAAhKQgAQkMEBAgckKpoYCk+lBXMUPoYozJgd6aafAGpwzroXJafTpAkvPpaXHYen2r2EtnEQf2mbb/FKOcxu7077elm7/Gva8NfTB9ex6biMwXWrpubSKPUmByfREsoQEJCABCUhAAhKQgAQkIAEJSEACEhggoMBkBVNDgcn0IK7ih1AFJpMDvfQP6ifhkF66D66FyWn06QKnfRyWbv8a1sJJ9KFtts0v5Ti3sVt631t6HJZu/xr2vDX0Yel5dBJ7nn2Y3pNcz9OMTmQ9KzBpGwhLSUACEpCABCQgAQlIQAISkIAEJCCBHgIKTFYwLRSYTA+iP+ZOM9IpMM1oDc4Z10LbOC+9HpYeh6Xbv4a1cBJ9aJtt80s5zm3sTvt6W7r9J+LMXVgku4Y+uJ5dz20EpkstPZdWsScpMJmeSJaQgAQkIAEJRJZ0mwAAIABJREFUSEACEpCABCQgAQlIQAIDBBSYrGBqKDCZHsRV/BC6sHNm6R+jT8KZax9cC9ME2kosPZeW3pOWbr/ruW0eLV3KcW4jfNrX29LtX4M4Yw19cD27ntsITJdaei6tYk9SYDI9kSwhAQlIQAISkIAEJCABCUhAAhKQgAQGCCgwWcHUUGAyPYir+CFUgcnkQC/9g/oanOquhclp9OkCS8+lpcdh6favYS2cRB/aZtv8Uo5zG7vTvt6Wbv8a9rw19MH17HpuIzBdaum5tIo9SYHJ9ESyhAQkIAEJSEACEpCABCQgAQlIQAISGCCgwGQFU0OByfQgruKHUAUmkwO99A/qJ+GQXroProXJafTpAqd9HJZu/xrWwkn0oW22zS/lOLexW3rfW3oclm7/Gva8NfRh6Xl0EnuefZjek1zP04xOZD0rMGkbCEtJQAISkIAEJCABCUhAAhKQgAQkIIEeAgpMVjAtFJhMD6I/5k4z0ikwzWgNzhnXQts4L70elh6Hpdu/hrVwEn1om23zSznObexO+3pbuv0n4sxdWCS7hj64nl3PbQSmSy09l1axJykwmZ5IlpCABCQgAQlIQAISkIAEJCABCUhAAgMEFJisYGooMJkexFX8ELqwc2bpH6NPwplrH1wL0wTaSiw9l5bek5Zuv+u5bR4tXcpxbiN82tfb0u1fgzhjDX1wPbue2whMl1p6Lq1iT1JgMj2RLCEBCUhAAhKQgAQkIAEJSEACEpCABAYIKDBZwdRQYDI9iKv4IVSByeRAL/2D+hqc6q6FyWn06QJLz6Wlx2Hp9q9hLZxEH9pm2/xSjnMbu9O+3pZu/xr2vDX0wfXsem4jMF1q6bm0ij1Jgcn0RLKEBCQgAQlIQAISkIAEJCABCUhAAhIYIKDAZAVTQ4HJ9CCu4odQBSaTA730D+on4ZBeug+uhclp9OkCp30clm7/GtbCSfShbbbNL+U4t7Fbet9behyWbv8a9rw19GHpeXQSe559mN6TXM/TjE5kPSswaRsIS0lAAhKQgAQkIAEJSEACEpCABCQggR4CCkxWMC0UmEwPoj/mTjPSKTDNaA3OGddC2zgvvR6WHoel27+GtXASfWibbfNLOc5t7E77elu6/SfizF1YJLuGPrieXc9tBKZLLT2XVrEnKTCZnkiWkIAEJCABCUhAAhKQgAQkIAEJSEACAwQUmKxgaqxBYLKCYbALEtgJgTU4BXYCwkokIAEJSEACGxDw/NwAlkUlcOAEFl/PCkwOfAbYPAlIQAISkIAEJCABCUhAAhKQgAQOmYACk0Menca2KTBpBGUxCZwCAov/oH4Ct8hPAWabKAEJSEACKyPg+bmyAbU7R01g8fWswOSo55edl4AEJCABCUhAAhKQgAQkIAEJSGA7AgpMtuN3EE8rMDmIYbAREtgJgcV/UFdgspNxshIJSEACEjgsAp6fhzUetkYC2xBYfD0rMNlmeHxWAhKQgAQkIAEJSEACEpCABCQggSMnoMBkBRNAgckKBtEuSKAQWPwHdQUmzjUJSEACElghAc/PFQ6qXTpaAouvZwUmRzu37LgEJCABCUhAAhKQgAQkIAEJSEAC2xNQYLI9w73XoMBk70NgAySwMwKL/6CuwGRnY2VFEpCABCRwOAQ8Pw9nLGyJBLYlsPh6VmCy7RD5vAQkIAEJSEACEpCABCQgAQlIQAJHTECByQoGX4HJCgbRLkigEFj8B3UFJs41CUhAAhJYIQHPzxUOql06WgKLr2cFJkc7t+y4BCQgAQlIQAISkIAEJCABCUhAAtsTUGCyPcO916DAZO9DYAMksDMCi/+grsBkZ2NlRRKQgAQkcDgEPD8PZyxsiQS2JbD4elZgsu0Q+bwEJCABCZwMgf8dEd9ZXnWFiODfh2S/FBE3LQ364Yjg39r6CfxMRNy7dPM+EcG/j9FeEBHXiogPRsT5IuIfjxGCfZaABD6HwP+KiKeWv/5yRPDvk7A3RMRlIuLtEfHNEfGvJ/FS33HcBBSYrGD8FZisYBDtggQKgcV/UFdg4lyTgAQkIIEVEvD8XOGg2qWjJbD4elZgcrRzy44vQiA7wPte8ImI+EhE/GFEvCoinhYRH1ukJVYqgfURUGCyvjFdQ48UmERcPSJ+swzmbSLi8RMDiw/uKhFx/Yi4dEScIyLOGBGckX8dEW+OiOdGxEsi4t83mCSXjYgbF6fyuSPiTBHxzxHxNxHxlohABPO8iPiXDeo86aIXKQ74bytCnS8t7f3b8t0BJs+MiI9v2LArFQEcDvevLXW+LyJeHhFPjoh3bFifxSXQSmBfAhMEqVWIepeIeFhrgy0ngbkEFJjMJXdAzykwOaDBsCkS2JLA4j+oKzDZcoR8XAISkIAEDpGA5+chjoptksA8AouvZwUm8wbGpyTQT2BKYNJ96h8i4vZFaCJTCUhgnIACE2fI0gTmiEXmPLN0P06y/jNExB9FxIUj4q8i4rwTkQIQfjw9Ir69oZF/EBE/VCIQjBU/axFJEEFlyt5dhBa/M1XwhD//woh4TETcvOG9CGZuFREvaih75oh4QkT84EhZIjsQheeBDfVZRAKbEtiXwIR2vi4iLh8Rfx8RX1/+e9P2W14CzQQUmDSjOtyCCkwOd2xsmQQ2JbD4D+oKTDYdEstLQAISkMApIOD5eQoGySZKoJHA4utZgUnjSFhMAk0EsgP89yPi/6Sn+M3xyyLiUhFx/k5tty4OoKaXWEgCR0pAgcmRDvwJdnuOWGTOMyfYpcVfdaOIeEZ5y50i4pEjbzx7RLwxIs6VyhBFA4HKByLia0oqC/67GpE7vjUi3jNQ7xdFxO9GxMXS5x8uEUuo+yuK+OU86fN/iogrRsTvLU6n7QV8P3hp/FckmGoIUN8UEe+NCKKYfENEXCh9TmSX60XE80de8fkR8bLS11rsjyMC4Q6Clu+IiK9OzyMyuW9bky0lgWYC+xSYXKOsLRp7/4i4R3OrLSiBGQQUmMyAdmiPKDA5tBGxPRKYT2DxH9QVmMwfHJ+UgAQkIIGDJeD5ebBDY8MksDGBxdezApONx8QHJDBCIDvA7xMROB777DolHz1OI4xw/eeLCJxhmgQk0E9AgYkzY2kCxy4WmcMXcQhpXRBtIFZAGDFkv1Sih9Rz7w4R8ZSI+Lf0AKIIonOQzuILyt9/IyK+d6DSPGb/GRH3LM+SGqcaPj8iePxiEWvw97dFxEXndHiBZ7IDnuofVb4//F3nXVeLiCeVlEJ89KEi1vnkQJsQi8ADo8wPR8SzUln43i8i7lb+Br8rlKgPC3TTKo+UwD4FJqx9ohbV6CWk4/rHIx0Hu30CBBSYnADkpV+hwGRpwtYvgZMjsPgP6gpMTm4wfZMEJCABCZwYAc/PE0PtiySwOIHF17MCk8XH0BccFYFWgQlQvjsiXpzoEJr+7kdFy85KYDMCCkw242XpzQkoMNmM2ZUi4lXlkV+OCBzJQ/bFEUE0EiKOYHeOiEeMlL9rRDy4fE60DiKRdAUXfPwXKSIK0VOIojJk3x8Rz00fIjBBaDJmX7KFQ/qMEfGJBqR5b3thRFx75BmioOXoaAhvEOB07StL1Bfaj90mIh4/UC+ik5pC5w0RcbmGNltEAq0E9ikwoY1ELfnZ0tgfjYjHtjbcchLYlIACk02JHWB5BSYHOCg2SQIzCSz+g7oCk5kj42MSkIAEJHDIBDw/D3l0bJsENiOw+HpWYLLZgFhaAuMENhGYUNNbSzoA/jcpdS4tYAlIYJCAAhMnx9IEFJhsRvhXI+IG5ZHviojfHHkcMccfps9Jl/M3I+WJhvLX6fNLRsSbO+XPHBEfS3+7zETam88r5RG7YAhOnjfShgtGxGsi4i6dyB8tlEjZQ3oaorG8aOKBj0bEWUqZ60fEsyfKvzMiLlDKIMR5aE95opI8qPz9XSXFDhFK+uycEfHnEXGG8uG3lBRDLf20jASmCOxbYMJaYc1gpIe6xFSD/VwCcwkoMJlL7oCeU2ByQINhUySwJYHFf1BXYLLlCPm4BCQgAQkcIgHPz0McFdskgXkEFl/PCkzmDYxPSaCfwKYCk8dFxG1LVR+JiLN1qs03swnvzb/PGxE3iwiceYT6PmtEkKIAZ1affV25VX7V8izlCQ/+3oh4dUQ8ISJwPo1ZTmtAiH3+TT23iIjrltDj3NTGGUidv9DgnOpzOPz3iLhecViScgEH4xdGBCmFXtDTQHjRhmsUZ9uXR8THI+Kvyq36p0bEn244Wb+qpHC4SkTgXOTWPPbhiPiTiHhtRDynjMVY1aR5wFH4PRGBY5R6cN6R0uCNpQ76NOTwy3VzY/2m5VY58+BMEfGvEfH3ZRzfUtr1kpGb9rCC+dUj4kIRASt4MxfeHxFvj4jfjYjnF0fjFDYiFzBW31HGiVvyzGGiAXCb/skRkVNUjNUHlxtHxA+VVBtfFhEfLM5oxrCO/ZICE1JPcIP/2yMCxzfjx1jhjCKiwK8U5ie9Tur7rhgRNyoiNNY06+1TEYFjGscwjnciSbyi/H2snazdOhe+ocxN0mewfpnfMH/TxAToE2IQmeKGhSP1Vo4XL3vW7Uud7Dm3nppg5XPqgz3GWr5wz3PnKvvh5cv8gQ8CAlK10Kffjgiia7DuhizPrammdSN1bCpKYW4x168VEbAh0gTr+QOlrUSTeOVUIzqRO+r5wJkAW6JawIV3sR9S30PKftFQdVMR1jz7IuPOvssew5wcMqJi/E768H9MlOfznPoFASZCzGxfU/av+jf27KnzDM7MTewHOhFNct2MC+v/a0sKH4Q0v9ZE5r9SBrGWWGswYb9kHg4ZZRgrjL2IdTxmRBlBTIP9eIr0kp+BdY1EQnQ0oqSNGXPkyqUA0R7u1djXlmKcFTeJCIQrzBPmDWfOM8r6JkVS3/eMbt19ZTgvOB/5LsL3I85wzjYEO5yRXWPe0ha+QyF64mwmQg5nzm+VNiEq6jPWK3MCo26+owylJ8rPc2Yz72o0mW8u39tyGcafM+j7yvc55h/ffzhHEWKR5uX3SuS7HMFmiP95Sj85O+DCXPyP0k++M/JdDSET51yf8X4i7f3Pwon9hH7wnQFWzEH2qpc3TIA5ApNvLN8LmJO8m/FETPae8k7SXWUB2lQz+P7Gdx+M/2b+aRLYOQEFJjtHevIVKjA5eea+UQJLEVj8B3UFJksNnfVKQAISkMAeCXh+7hG+r5bAjgksvp4VmOx4xKzuyAlsKjC5f0qLg4PxCzr8ugITRCKkAMDpkI1b4V2BCU57HJ/cYu6Wz8/i2OGWMyHEh8QOXacON0FxtOHc6zOcNfcr7x+aEl2HAw4wnB04+LvWJzBBZPOwiPjSkTlHOx4dEdzw5n+PGbxg8BPFOT1WFicNDsQh8QoOmScVp85YPTi8uUGPwKPPuG1PKHduwLcY84k+dA1HNqKBekN+rC7agpN6yHDeP604ncbqwfGDwAaH3Zjh6EVA8q0jhRC94EBEuPKdpdwVIoL1tq3hRCMKAw7gMfu/RTwxJrxYYp3gkKR9CAZa7JZl7g2VvV1EME/G1g37APMF8duQYKArqmDtknqkTwCCU5a9DecoRpoTxn1MjFDb/9IiIOPffU5yUqgQXaLFp4Mz9OYR8U89cE5KYMI8RzCDw3fMcPYjriGlzJB1zwfOAObg0NjiqMbRjxBtF8acRHyFEakDod+Ysa8gdqk2FSWDKAN1vXE+IorrppvBKY+QqJ5xOOfZL4YMMQHO8RqpY0qQghO7iqE4KxEA/PpEP1kDiEuqOBFHPKIRRDhD9mdpTvxYRDx8pCznAqKAup/3CVLggRCg9hOhCe0YM9YXewOGOKXvLN503jAX2RcQbA4Z7+Ic/Lmyz1OuClm7z3T3WPblZ0YE51LX+gQmzP9HJYHRUJtIX4gILEfHqWWZkzUCBmWqAG6MDULYJ5YCfdHqiLDBOYioosXOHxHMmT5DmEVEG+Ytc2XMWFcIT7pz8w7l+xVCnSlDjINQC4HpkG0iMKH9fM+F2dj72c8QVz1mqoHlc74Lkh4HGxJlNVZlMQkME2j5MiK/AyegwOTAB8jmSWADAov/oK7AZIPRsKgEJCABCZwWAp6fp2WkbKcEpgksvp4VmEwPgiUk0E5gU4FJjmCCI7E6pOobswORH8RruHuc9zhlcH4g8sDxdtnUTH6Ux+HLjd5qCAe49crNYaIf4OjMTk6cH0NChuzUwbF8x+LcwtmHc4HbtbQDp39NPcB7x25BZ4cDjl8cJjhtcOIRSYPbujgacEL+VCeCCYIRHMvV/iUiXhcRf1naRTtgUg2HIA6sIQENvHCCIWSphvMbhxxjgBMGhzjt48YyhtOcFEddw4GFw6neRscJgpCEehCm4EhirKrjB4crEUr6UkXgZLzTwBjiOMQxxE1cnKRYn8CE6Cn0o74vtwdupJhgHiCYYezGBCY4v7j1XBnAk9vcCG2ol5v+RJHgljNG/Tidcbb2GTfPGevsVCMaB+3lWRy1NW0UaSy4+b5LgQk33VlHeR3UW+K8H7ZZ+MJ8JwJMjsKQ+7XEOsFZfu30EpyKRKwhcglzjD2DsTt3KTMmMHlEWbu1OvYcWONwxyHNnP6m9C5EA9xgZ952LQtMcPAhNiDNBrf5idRAhCT2GaIs0H7WSk7rMRSVKL+HvrHXMXeZa/SRNZ6NvQOnP59TP//B0Vkdp/Qpjy+ClWv27AXsaexBzDfWI4YjuC9SAOuZyAvVWiOYsDZIIVP3SNpM/awfBDiwym0lEgdOfvbsPsvnA+OOGIK9DEaMK8ILIpsgeKvrH3ENY8w629ayw/anI+IBDRWyXzAmGGPBvOkT/9FePq/CBCIi4XDuM/b3undTP1GV+kREPPuUIl7gf7OX1YgdQ03HV4hYEEEjxrxij6/Cmu5z7GV8D0C4hjG+9IGxGDPEkncuBTgTOGuGxp3IIvcpZZnv7JNdhkTIqOcT84w5NxVpg72tpjhif+F82cY4v2FRI61QF+sZ0SF7KXOd+c1YM1+JTEGUJqxFYMJ5h2AAEQsCideX+hGWsNY4F3MEE/givKj+X8aE976vrBs4cl7Wz+H3bT1zie9Jjy/t5GwjQsiU5YgzCD+I4lSN85LoGlUkw37LHk+EDTgxdpytjGmNcjckMGHPJfpN/j7IWuDMYl7RN+piftXx7RPiIPZBbIsxLrSF+cgc4tzmzMliQlgxzpybfdYqMEFQSUQUuFfjTCZCF8JEvtfxWRY3t+49iGBq6ikEfAi2NQnsnIACk50jPfkKFZicPHPfKIGlCCz+g7oCk6WGznolIAEJSGCPBDw/9wjfV0tgxwQWX88KTHY8YlZ35AQ2FZgQeYQQ7VjfrdbsQER4geMBhwoOryyWwJGTf9i/b0Tcs9SL85ioBTiquwILHGUIS+qNdxy1pH/pWnacI7zAGYqI4kc6jjMcFbSNW+QY7cXZh4iga9nhQN9wMiES4e/0O1vuHzexcSTVm604xHBGZYEG5RG3EL2lGlEOcOL1WXam8DkOc5zGfTdycUDDE7EPTqFsOFwYR1JGwBpnFk6wbph+QteTZqPeEKcPhOvPhvOHsYMLzkMiLxA5pE8kg+ADAQ2OJByx2bJAAZEGjmgcNV1DYICjDIfvbXo+x/FD36oYhDaT8gTnTzYEK/CsqZ9IC8AzfTfBaWt13DKveAYHcDZ4MycJkV/nHp/vIoJJjo7BbX8c2AgWsuFwxCnFmGE46VizfakXdr1OspMYRyMOsuoA7g4R7SOFB6kPiPTSNTjXuYFjlfXAHMRhng2uTy9OSP6Ok7EK23K5LKqo65eoRuwJ2TGOEIq1ynuyY5y5yJwdM+YX0QYw9gaEEl1jjfM+Ig4MRftgD2Jena88TDqmLBAZ6hdOfPo5ZS0CE/ZG0kfh3MWIvMB44TjNhoOdPZk9BGMsh6LX5POB/Z9xYO2yN+d9gn0Jp219N9Fp6rqb6tvY54gnqhiHVGCMwZQxhjjAqwAPxzTRruDAfsdeRp1EYsKJjSFYQhTUt4fwOemY2JtwrmPsSez/ONURDyBUYs3+ZNpzEfUgqMgRVYbazhyGGWlVMPYhxJvd/iJo4DtATb+D2IXISH17RfddtJHvA1W8BwtS2sAKwRD7KvsoIglYY4gBOTdY813LznTOxtqmsfFBUJfPNEQyQyKXqXHmc8agRtTiuwAiWUSTWbDGvkUEEvZ55jBnN9YiMKn7DlG+GNsc3Yb5xblZ38U4wJKxZPzYixBIdYVIRAFi/dRUKqT7Y0/LxjzjXOO/WWfsK4gwhixz5ZxhjHPEEMRtiP8w5iXfnxAOdQ2/NecRbJgbfXO3Cu54lv7zXZDvIbw3GxwQa/JuooN11xb7A8IWvj8MRVhjTXGm0CaM75ys5T5rFZhwJtV1hsAOMU43UhnnCSIf5hLzhX6yx09F6EHcW7myJhGrtKQoHBlaP5JA/0KVyyknoMDklA+gzZdAIrD4D+oKTJxvEpCABCSwQgKenyscVLt0tAQWX88KTI52btnxRQhsIjAhMkB2UOGUJ1JHtuxA5O8t4di55U+UA36E5xYyjpuuCCC/A4cyUUgwbqnijOz+6J4d55TDMY+Tqy+yAYIIbodWZzC3lblN3LXscOAznK9EiyASxpjhaK71IVyh/UOpNgizTqh3DKc6KRq6oeBxOtDvmkqAMWAs5hg34utt5qk0Bwg2cNBWRxa3f2sKEd6NQ7UKBXB4MfZzDKc7YhWcd9x+7qaYaK0T5xHOKgynE+KAvvGv9eU5g/Pv5zsvgvs70m1x5gPOpT6jLDe6c3ScbQUmed5X3kOpQ1hTOMKrEOveiUVu767XCWIynKDYUPqjlvHjhjxOam6es1ZYP3mudevAkY1zHNERIisik3QdsVlUwfM4b4lWMzYncCbXvYj5SASZIdEAdRIppEaQQfzTFU+19L2WYQxZ5/SJdTeUkqlFLNJ9b8sziFVwamMIvBAPDYkbiMaR07DgCEZU17V8PrBnIzYg6kyf5fOGPQDBCw76uYazmzlRU9OMpezovoM9kohROcpUXztw4iNYRKjQFUJ1y+PsZr9kro4ZjmUEVEQ9GEtZ062D85TnEAVhzF/GqQq+6D/nf42sgFiEfnIGtxptpw9VdDr0HNwRc7GvwqjPEOsRIQ1DgMJ8mzLGI4sqEe70CR2m6uFz5hfRSur8GDtX2ZfYXxERVmsRmFCW+YFocsw42zlrGCNsKo0SYhzaw/7EvGPfQqiUjQgk9b1TezMCD74PYH3iLsayRpsj2s2rWgD3lCEaD9+9qjFXu4LJmVUPPsaZCFuYMReJwtIXkahFYIJIpO5znBN8JxpLEZbrbEnRxTxg3dZoTpwJRNrSJLBTAkYw2SnO/VSmwGQ/3H2rBJYgsPgP6gpMlhg265SABCQggT0T8Pzc8wD4egnskMDi61mByQ5Hy6ok8GkHU03hMXb7nZQROBpwrGD86I3zo+twzA7EMadoRp/TqpBeBZHFlPHj/NVKIUKn41zOlh3nODJp65hohZvn+VZ1n6OqKzDBOToUnaG2Bcc3N3yrkT4H4cGQIeKAYQ0rz+3+Gtq+PsMN5RqxA4c2EVLm3GrN0SZoExyn6rl+ub1NWxASVDEM/75huUnN/+Z2c02fMDWW3c8RFHCbu4aX3/R5yvM8DjZutDNXcYR+aKIiHK08w2/tiIe6TlMEJ9xox1rmNk68u6d3biswyTe9XxQR15roD22tIhkcaUSDGBNi7WKd0F/6jbWu5b5u5BvyrXOJdCvcHsdwfmbBA3/rCkwQSiHgmDKiSrDGsDHRCFEBiPKBkZYBB+aYGGXqvXxeI9YwNuy9fWlLWsQi3XdNPcMawNleo0hMic9yW/nfzNUqbMjvzufDWKQTnum2gfXIupxrRGGgT9WIuDKVgiW/C9ETHIhwUR2++XOc1ESd4fzqRooaajPRDJhTrFP2/j4jGhF1TkU76HuWdjIWVQzAXkh0Gc5ChI81QgztRWA55hwf6gNCFqKPELmnnlvdskSjYR0PiYkoT2SfGnkIMVlOUzP0bsYwC8mITNGNsNM6X4jyRSQwDCc+63lM0ETUiiwwbBGYMN84Z/oicuV2sre/oPyB/86p8Ib6g3iHKCFYX/QzouzU9FlE+EAc0yes4Ozk85r+kPQu3YhuiPNqKigiqCBOmmN8fyIqD8Y85/vFSVhO9Ti0r7QITHK0Nb4jD6Whyn3izOH7JXs6jPuizuXyCC1rKiLWKOtWk8BOCSgw2SnO/VSmwGQ/3H2rBJYgsPgP6gpMlhg265SABCQggT0T8Pzc8wD4egnskMDi61mByQ5Hy6ok8FkCE0L2VwdERYNTk4gi9SZt/TvOmHrbOGPMDsQWpyTPcuOYiA9Ya4j77DzHGV3TUtS2ZIEJDuKa2mVsyBGpXLwU4DY1Duts2eGAgwjnQJ+DJj9DqHrC4WPcMK71j7WDvpBqA+tzuvx5RHCTFWuJEDP0Lm5oP6B8CM8HN6wHxqem9kGUgmCmWr7Ni1MEh9aUqKPvlTg/a3oXHE4w2NQum5xiOOmJhtBiiIEQBeH84UZ7Fgjk9BqMT3VGDtWbw9tTZluBCdzhj7U4s5ifpK2okW7oFze3s+16nZDKhbRIGOuJOdGNJNIyDjikr1oKsv+wN01ZTrGBaK3ewK/PZVFFa4QEns2RFV6bIv5020OUmJqehhv+pPOaMoRP9I+5wl6Lwzz7ekiTgTMSI4oL0ZW6NiUW6WvD1DM5RQZ7HJERphyhRFkgjRBWU8d0353PBxz0RNgYsywkRBjRl0ppinH9HEd4FfcxJ4cEHX31fX1J28G6Y3wQICDuY39AVIETHkYYEXEQa9boSUPt4zkEFezhOPVhhiMfkQdzgYg1OUIGESg4T6bOnO77qJvoK1WQhsiBKCU1cgkObxzXc/ZqGNJPBI9Ea+JcJD1QTcfC+VDnL+1CGIcQsZv+hM9yxKmhKGLdvrG3ZR7sN7x/jsGopsAJR/ZKAAAgAElEQVRiXEi1NWb0lzVRI560CExahIG8E1EpKVUw9jXaNmXsIzXKE8KHmvYvP8f8Zx1gnImcjV1DjMT+hXEeEiGuazlVHN+Tanq5qTbmzxFXEZ2n8uM7Gt/VdmGckwiUOPM4x5mneV+FVU2VNbQPTQlMEG/RfupG+Ec0nZa1mcUtrEnmxJjl76Vzvw/tgql1rJiAApMVDK4CkxUMol2QQCGw+A/qCkycaxKQgAQksEICnp8rHFS7dLQEFl/PCkyOdm7Z8UUI5AgmLS8gRD+CDqKZ9Fl2IA6lScjPkQql3pomcsUTWxpR0rTgsMceUm4/50ez47zv877XIATBgYfhzKvREGrZ7HAYczTnuukPN9QxHAsIc6bsB1OYeCIiVPENz+HExBFZjRvo+Vb+VN35cxwbpA3CuEn8noaH+R26MmLc6i1nHsWRiTik3rblc+YJTmEcX0Npgbqv5RY2t7ExhB7c4EZkAvNWJyjiAsL8Y4gJ+hzzfd3FKUekA+ybUiQC+o1j9gvKZ6035XFA1rQa2whMGOec8qBViFVvS9PsG0XEr3Y6vet1wnrG+V6d90Q4whlJKh+cmy0OOJqIw46IERgpJYi8MGWkk6pO9D6BRxZV9KV9GKqfPuEwZ34jHsDp300/wbPvSkK8KcchAijSWuEQb/XtDKXJmBKL9PVr6hnmyjPKg0NO5m69LXtTPh8Q2yG6GzNSbSFIwLYR0/E8IpAqPujuXWNtwFGN0IXUGghKOBee04kGhLMZJztnTd0jECjUiBzd+hFskuaNOcvcJuIEooIcMYN5gUMZB/6ZSwVEr6r779R6yJ/TJiL6dIV2zFnEJUNpa8bewd5PH9gn2adJC8Sc7qaMI9IFkT7qvjok+Nt3BBPOWqKWYH0RkPpYIHzjLMBaBCZDqcq6dXNmEVUN4+xriSzD/Kxp6d6UBBS57iyWYz7UyDa5TI2axN/6IqHwd6LH5Wg0cGCMEQaS7rDFEFAh0sIQfNH+bVJgUQ/COKIBkfqMyDotNiSEnhKYIJ6q0XI451tT+9DvOmdIKVcFyENtZc9i78JuXqIktfTLMhJoJtD6JaS5QguePAEFJifP3DdKYCkCi/+grsBkqaGzXglIQAIS2CMBz889wvfVEtgxgcXXswKTHY+Y1R05gSmBySfKLV0cHq8q0Qm4tTlk2YHYkoIC59Q2aQ9oBw7sKuKo7cqOc9K4kM5lynAI4iDD+m4AZ4cDDkaEIFOGOKI6vcccjrme7HjppokhnHsNR49jst7+nWpH3+c4oUiLM9cQC3RTRSAqenFEnLFTKeIM3vf6cmuam/pD6XgQJzDX+lIk4ARELPLqIlxB8NRnOHpxjm1j+TY8EQVyWoNWgUe+Mb6NwCRHX8CBy+35FsspCKYi/exqneAUJ4oJgoxs7CUIjQjxj+hoSFzA3Bka15Y+U4b5ceVO4SyqaIlQkB8n9QERNLC+aD85egDORpzp/zrQ2JsV0cymPp2bpugwueopsUhfM6aeIb0RUWAw5hDpwFqMuVn3JFJw5bRjPJ/PB6IUEY1pzPI+PuTAb2kXZbLAhDEaSueS6yP6AeljqjjiikXoNvROzqEqkkRQd94eMRJ7JvsCZx821S8EGqQkqcb50I001sKAtiA4y+uyNTpGX/05usxYej2epa/s/0StwDg7OUOzZfFDa4QhxHs5sk5farsWNpThew0iB6w1alJOkdIiMEEchEhoyhCUIGybawg9q1gm14FQCUEqZyz7E8LFD6cCCJ4QCBIZhvnL50PilhxpLb+DSFuIIvhuyfefPjEe5dlPa0oZotjlSDdz+o3ohfrqHGutY0j0MyUwueaWEZVoH1F77jfR0JyiTYFJ66habiMCm34Z2ahyC58MAQUmJ8PZt0jgJAgs/oO6ApOTGEbfIQEJSEACJ0zA8/OEgfs6CSxIYPH1rMBkwdGz6iMkkAUmU06iFjzZgUhaAf49Ztnp11J/XxluzuIMyJYdkzj9EKFMGbdJqxAFgQOOvWxTDoe++qmHNBdYy21VymXRDTd6s0NwjpN0qN/5xvYUm6HP+36XxnGM04YUIaT86DNuziO4wQHVZ9y4R/BAxJeaDqhbjlvP3P7lXd1b8zlyzNy+ZUEIjjeicVRDBNGX5qH7rnz7eBuBCekDahSWTaIvEMmj3lK/R0Tcv9PAJdYJr0AQc6+IwAnXFZrUJnD7+8490WW60VrmjB8iFiIzZJsSVYy9h9QZNU1Fn/M7O1vHIhUhukMgVoVZiBeIlvSG4tglcgtirGotAos5/Zp6hrlCRAqsNd0PZbNjvC/lxabnQ0v/W+fHnBQ5WXSIyAMn9pixH+IsrynliMRERIVsOUIVZWtKrrF6X5kEU3NSkiCQ4azP0bB4H0Iu+sT828SyCJKoLtTf3YO79eU9GXEKUSay5RRXiBTO3tCgnMqJ4q3Cv76qOWtr1IscvWqsGaR4qlFDWgQmU2Ki+i7EH13xZgOOzxRBJDJ0bub0NndNkb54OK979jvGZMyuU6KNIcjpM0SkREohSghp87LlKEmcBTWqxyb9rGWJpsP3mSoQov+sE85MIrMhHmJfraLWqf2Peqe+7+X2z2kzz7R85zZFzly6PtdMQIFJM6rDLajA5HDHxpZJYFMCi/+grsBk0yGxvAQkIAEJnAICnp+nYJBsogQaCSy+nhWYNI6ExSTQRGDfApPs9MO5Wh0ETY0fKbR0BJM+UUtfcw45ggkRJIgygA2l39hmHLgljZOZ/yCMISJJV3AyFIK/vpffvYnacvmIuFxJKYIAIRtRMRBvZAfnI0oqJ8rh/Cd6xzZmBJP/T28q0k/mDDfGrs4DnIhZcEIUnBsk8QbPdlkTpSBHj5k7ji1OxaG6uRWP07vuT6Sv+ONSGKc0UQFwbmPM0yGHPWKSW5ZypJPgFv9Y6qjnlbXJI0PO6Tn9mnrmJCKYtAgQdykwQbCQU8EQBWhKFEFaripU6hOL9M0XUt3cqnzQJ84hPVMVRLaKRX4qIh5Q6hxKfzI0d0ldxDlfI0QQ3QKhTxU+cu4iptwkKgqiPuYQ1icW6WsL67ym6OoTyXEW1ahGCAEYnyy26qvz6iXCDp99dMuoH3MimCCeQGQxtj7nzOHcFlKxEPFmV8Y5XPcnItog0sE4a0lvg0AUQ3iUI+eMvf+cZZ3UM7rWWZ8hygyfISyttssIJndP4kkEfJw5zOshI30eohdsSOQxJTC5dol0Rx2tEXfmjCHCVgSuGHsR4klNAjsloMBkpzj3U5kCk/1w960SWILA4j+oKzBZYtisUwISkIAE9kzA83PPA+DrJbBDAouvZwUmOxwtq5LApx1PpDXBWm5TTiHb9IY6N59xzlZDlEBkim0tO3VIl3K3hgofUyJmUJTb1tVJWB+dcjj0vSLf2ibaBlFMpizfcOdWbr51jrPwg6mCr+k4Tafqzp/j4L5q+UNr6P5N6u+WRVzy3SWyBQ56DOc6Dq33b1DxxSPi9sXhXh9jfBnnatkh25rOaKwJ/P6Os5PIKhhCCW5dT1mO6LBNBJNuVA9ubA+lLshtwoFYHcvcuK4O3lpmiXUyxoQUDYiZ2GtwSmL0g/+dnf2wrqkOWlJtTY0Dn0+JKqbqeFJEkKIAIyoFggOMSAwvLf8bB22NXtFXH8796sC9VEkbMvbenMbqJAUm+XY+UVZqOpextiKwQYRTjTmb93b+vun5MMc5P9RG1jBRh6rIjX2V/XXMcIjX8UQYxByYMqIE4fDGiDxS99j6HE77Gh2LskSNmDLejTgJ654JY8+yTyCSuXApREoiznvWHGmqqsgEQQMppVr2NKrKQqlfSVE8xtqSU/0QoaPupfUZUisxPqRnwS4bEW+cAJOFBaQSQcg211i7pBHCWgWXiHJYx9guI5gQ2aae+6SnIk3VLg0RBsJNrAriSP9EajGMCCDsU/8x86VfV3ggRqzp3F5SIlrVKnMUHL7zId4jiswco920HyNyGsKuMcuRveYKTJifpPrDPhQRfDfbtbEWSIVYo9kQlYax0SSwUwIKTHaKcz+VKTDZD3ffKoElCCz+g7oCkyWGzTolIAEJSGDPBDw/9zwAvl4COySw+HpWYLLD0bIqCexdYMIQEDodhwSGE4q0MttadkySpuQ7GirEucZtYey2JcR6fmyOwAThBsISjFvItf6x5jyypIehzLMj4vqdwjgJa/h7wvPj4Jtj942Ie5YHW52Ec97TfYaIFH+aHDI47Z8yo+Is3iEUPreWq2Vn2fuKgKGGx5/xqk8/kp2JLemOcEznG9vbCEx4P877GiXjWhHxoomOnK08Ux22pOJ4R+eZJdZJC18cuQgXqogER/dr0oOvT2u21bE/9d5tBSbcHsdZj7FnsQaZU8+ICAQZ2JRIDxENjnSM/8Z5OGQ4XD+cIr4MObBzNImp99d3TbHIqUeIMsO8I0LEmBHJgYgOGCI4xINd26fAhLYQ7aim8/ieiHjxRJ+yIx5n+YOmJlk5N25dyvWlGXlhiVxDkV+ICM6IKUPM9MBS6PdTH8aeY/2zpqqYD8c04pLqoEZog9OffQkjShDrsCVaRj6jED8ggpgyzrFnlkLM67qX5ecQiSB4wBAJ/txEpVkkSUon0nLNtSw6yAKyofrgR2SOKljapcDkaRFx4/LiVhHSJv3O6QBJmUMaQb4D3LBUwv7AXrKtZaEaoqIzpT2PvR9hU90P+1Jqtb4/CykRVCLQGTIiTvGdoKZgmiswYdxZM/UM47xHpLRLu2A6s2F1ll1Wbl0SqAQUmKxgLigwWcEg2gUJFAKL/6CuwMS5JgEJSEACKyTg+bnCQbVLR0tg8fWswORo55YdX4TAviOY0KnHFUEH//v5KSXENh3OjnOcwDi0EWYMGTe8a8oLyvQ54+cITHB24PyoRhoAwqkPGbd9aWd1vuGorDfX6zOZF6HuST8zRzyBoxWHK4bjm5QVOQLBNvynns2pP7iFXp2nU8/lz3EQV5EFQg6cMdVw+uDkJt0K1iLImHo3TscfL4W4Wc8N5jHD4ZmjE2wrMHlWRBDdBmtZJ3eNiAeX8kSSIMx+d54ssU6mONbPs6ALx2Z1PvM5nOGN/UGJGDNnjue2TIkqptqNDwbnfBXDITghwghrhshL2JSTkQgN9Ub/VOof0kflqDxDDuycsog0Kj891ZGGaC70lTlTnbCkmCLV1Jgh1iBCEcZYVmd1fmbfApNHpyhSrE2c92NGlI9rlgItqWDgxn5f9yL2tRrNpL4ntwHBF2fNlOWoJ0Nscx3MLcQlNQUaaTYQl3TPQOYiApEqzkMwgcgEYc2Y5bmJ4xsx0VQ6mxz1hHOrCknye4hEVUU8iARq9KW+trAO6Q+CAewSZa+YYjn0eRZdUC8RRMYiaiDufHqqbJcCkx8o4lKqJ60T0USm+G7Sb85F1jciiU+UOUhkHMQeRC1BPMec2dYQlORUNd2Ia0R+IgIUxvlGGqU5hlixpuWZSil03U6Ek7kCE9qZ2//wlHZnTh/6nsnzoC8a0q7eYz1HTkCByQomgAKTFQyiXZBAIbD4D+oKTJxrEpCABCSwQgKenyscVLt0tAQWX88KTI52btnxRQgcgsAE8QfOpOooGnLU9AHAAZpTxtQy2XHO33AUIjLoc1LzXhx4NcT6UMSTOQIT3v265MAj0gYOPG7z9tnDIuLO5QMcM6SZwAGUDccXTswamaLlpvfQ5CEiA45yDAcGzlTS1kwZ6Q1wqnODt9pZy43uqWf5PEcD4fY0t6gxhCGf39PnvjpzdJi+McuRHUjBQ0j+1lQ8hLvvim3gnm9Gc8Oc6BV9dr6IeGsSHlBmW4EJz+coH1ePCG7w99m5yvurwAYWRKzp2q7XCVETWlL3sOZwYNYoF6TnqOkZaCPROxAj1Pa3RubgWdrAvCTyRrZtBSbUhWCgpsYhgg5ru86BFtHR21K6GfaTXx4YP4QqCHBw0FYb2hdZP7QFoz7qnbIWFjCvESEQHiBWGFo/3xsRROaohpiBKDRd27fAJLezRTCCsOYRpROcHeyVff3KY5SjMVGeOZKNc+gF6Q836QgVusxyNCY+G5s3fE6UA6KA1WhZjBnjQXqmPjtjRMACoSLG+uWdzNUhYy6wv1VjniCoGzKc/8znGq1iKEIGwsr3pH1zLHoR6b6qIGFIsDLSpM/5CFEOrGobEblVgV63MPsT/a+RxPh8lwIT9kfER5wj2FNLeq4WkR3jSTnEbGOW936EppyPWMu6aN3ncyQkhCsIWvL3C/Z9vndUYzwRmmxqWQg2Fn2FlFHMwyoS5D3bCExYV3yHxhAjIZZpjcA39N019z2L0cbm46a8LC+BzyKgwGQFE0KByQoG0S5IoBBY/Ad1BSbONQlIQAISWCEBz88VDqpdOloCi69nBSZHO7fs+CIEDkFgQseywxPnCEILwuP3OavJR48DDAc/Doq+VAzZeYJDA0EEYee5pfzxRBJn3OMj4nrlb7yb29wIFro2V2DCTW2cklVAgzMEp/CH0gtoH46O6rzmI26Jw6HPuOXNbe9qj4kIRAR9aSyIVIIYA2cZN32zfVNE4JzDKYXhaMKpWiObdN+NyIIoGqQQulUnxQRjeO3CkwgbfcIf3oMgpt7qRwRA5JR6WxqHHSkaEJzgaCJCRJ+RSgkHI44ujKgNRG/Ixrtw+hOdBqM9d4gIoqfg7OoadX1fRNymCDmIANI1HH3VgU96EyLMdEUCl4wIUmPQlzr3qGdbgQl15BvTCI9uVt6V28lNfthV5yRsL1rSEXT7s+t1Ah8EY08q0WWIbtA1hEjMRRyyGEIqnG1E0cmW1xt/Z/2S0on0NF3DP8I6IyUDz+Go7gqzWkQVPVV/1p9ypCNELMzVKkxrSZvEHGX+Y6xVonx0RUII0Ogrt/1xEtfoKEMO7MuUNUydRDsgIsbHJjrSwoK9EZEBIjcMcRVpTrKwgL/zN9ZrjczC/oaQo8/2LTCBJelZcHRzDrDmxwR1CAkQPCA+wBhz9j3SqWTjTGIveGhKmYGIrjrtu2XZh9lLMSJTICpEJJRFUcxpziUif9AOjLWM+GgotdKZi4P7UqU8USoQuRCdYswQMjEPa1QmGPEcqcyGDEFYnfvsp8wp1nU30gbzmT2yziPWJRE5eEef5dRt7Ams5+ekgggQEbMQuadan5Bnosu9HxPRpp5N9IkzmMg9+bxgXyeKDOuOcagpUnYpMKFxfLdB7FG/NxBphvbkiGi5ExcrghvmJykBc0S2vs4iKOr7nvP95Ywc48d8IlUTEVyYB31riPlN2h3OQ2woAgdjW79/Mf8ZfyI3/VOnAQhqEXRwhjMn8h5Hn/kehzEmfL/qij8RXPE39se8r24jMOF93TOUdYAwpHv+UBbxEsJQ5grfW2u6riHWOTILYp2hsZ8z131GAp8hoMBkBZNBgckKBtEuSKAQWPwHdQUmzjUJSEACElghAc/PFQ6qXTpaAouvZwUmRzu37PgiBA5FYMLvmzinb5p6idMCgQE3r3E24DzDuYOzvDpduVlfRQYZUP7RHwcCogmiIeBUJAoE4g6c2jjIal08P5ZiYq7AhHpzupLqBCF6CA5DHLmID3C8V0OgQSj3oRvLODR/PSJIE1MNXohFCO/PbVr6h9igCnAu3uMc5lmiljw7OYj5G8xJTYITHKcIDnu4VychZXg3aTGqdUVC1IGTC5EQTkHagQigill4DodeTiPD+OY0DrwfJz43y3Fc1nbgoKxGehycR303tinHjWJELNVoD8ITBCfMO5zHOG9w3NaoMDiK+wQmjBWMczoeHND8DccWAgScRtTL+DCmOMWwXQhMiKzyO0XEUfuDsw9BEONPP3BqV38BTK5WnkkIPvM/d71Ocn04C7mFj1MMxzxOfeYPjk0EVdVwDtYIHN02Zmczn1EnAgfqxYHHXCL1D87V6oSnHA7zJQQm1M185H3ZiEiEIGQqegvzlzXBTfpqrDMc+ax15nEVROHwZ59CSIcNObCZswg36q185jURmWhL3T9wBrPGq7UITCiL2A7HdhWPUB9zjfYyhjjZq5CJ8v+PvTt2te3btry+fpmRCBr48GKi8AxKTa8oekEw0EDKwMhrUolQCgoG9QcIaiB6E6tMNCgwkQciGGlQClUUmBhckEIjqUBBUVADA3ky9j2n2HXYZ/cx91qtr77m/OykqPfra87ev62NMfcds521lxeXvj8LDzw7YLJ6fP/NF//st/k+Whvf/2/rG0dWKO37i/71f19zrD1kveRez5818/c/J7T++9q31l73/huP3t9jrdH1HPrOdf23FQ76a990W15ebN9/Q8baX1bo4KNQwPdrr736v/z2XFs+WMGLn/Xw48zr+bp8s3pbIa6l/fqTUD/7WUGy1e/3P+f2fe7V35plPVfX8+f9nwBa/lmBpPeBkR+vv54VK1jxPbyy/vsKOq11suZbfb0Plf7s25k+0/Rn/22FRVYY9P2L//XsWd889j0Ys+6/nr9rz197/wq1rZ/1u8sKhv34835PPPLtbOs66xtc/uI77y1+a+2tP7O3gnnLP4vF+kaZ93vKP7wRMFnXX3vR9/1m/f/XfrP20599w9r32d6v4xUCWv0sFqun9Yxcz93vwZL1mVWz/PzRnwdcvlvhk/fM13NrPefW70frWbaeG+t6339HWvd4H15cuq1rfw9trXuu5876U0/r94YVpP3ez/q/rb31+5+7uzdgsu69/lTfP/NO+PX76ton1zpa63b97rnWy+rjeyBpfZPKe0Y/+mb9PrJ+t1k/65nz/RuJvuJrn0HgUwICJicwiIDJDBHTB6Ezpryvi18JN5QA0z6iQSnBW0Fah70uVCGAAAK3m317zwXpfZsOtQ5pDeoO5lfw0Z5GaS/9SsBkTwhVCOwRmBIw+d7tv/btmzzWC4TqZ71s+f6nb36s/fGlzjqoX//q/KNvO1mfXS+u1zemvA87/HjNewIm61p/7ts3kqwXKj/7WX2sbyNZ/1L5xz/x8eNn1ovl9S+5V+33lxafXXe93Fgv5j/6WS+o1rcQrBeCOz/rBdOf/SGwsvpY//J452eFIVa45Mc/27JeJK1gSjXP93ss/66v1f/o21K+16wAyV+63W7rX2bvnKOvF1f/+id/vmQFCdafA/ns5dB64fQvffPnIwMma6YVMlkvyd+/gP2I+f/07RsyVrjgZz+PXifvv9K/8sEKey3P/Cxc8v3z/+Ltdvv3vwU4qmuu/76+OWK9BP7xWx52QxXVPT7y+Wff2vHj9da3RCx/fBSM+167/oTK2m9+9y5099nL6RUSWyGI98Gd9/f98U/nHGGxXgyvbyJ4H+r6iNEKcq1vZPlZuGR9ZkLAZH2jxvc/Y7H7J4XWn75Y++PPnh/veawA1AodfPbtH6t+vVBf3wDx/qX4z7y3QncraLReulc/K9ixgg7rWXb0Gw9WsGUxWR7/2Z/UeX//1fuaofomhvWZ5YsVmHj/p5R+NsvqY31zy1r7P/tZIYjl4x+/uariU/33FQZYa+mz/XUFa1YAdAURl+fXz3oevv/TR9/vc0/AZF1jBRPXt3OswMHOz/rWixV2WN9eU/28/xNQq3Y9v99/M9rPPv/+T31V91jeXc/CxexnPyt8uPa69Y1c74NcH9V/D5q+/ya6Vbe8uMJwn+1Ta/2sb2BbPlzBpPVzb8BkXWP1vK631s370Nhn3l3+Xt969bOf9a1s/9a3/7h+L16/F/pBIEJg5xfjyI1d9HEEBEwex/KeK6UPQu/pbcpnHarXSqR9RINag1WR1mGvC1UIIICAgMmuB9L7tudnrURag7qD+RV8tKdR2ksCJns6qEJgk8C0gMlqe337wHqZtv4Myvd/mbv+5fJ6ofA3v/2Zl9X3+nMh3/+0yo/jfvRSZ/0L3/VtCetF0PqX4evbD9ZLmPUvyf/Db/9C+jNs9wZM1rXXS+X1cmO9sFwvRFb4Yc215lgvPf/jjReTP/a4vrlg9bZ4rW8TWPdY32Cy/jXyetm0vsJ+fXvB+pfY1c96MbX+zM36F/krSLFetq0X9evl4PqX8Otf5a5//bv+9fZH366yuK4+1r/eX/+Kev3/V6Bm/YmBFdxYLzwX7/UC9Gf/On69IF0v99bX/K/Ay5ppabdeni9W63Pfv5Hh+4viaq7131fAZoVR1r/qX99osv419Pe+Vhhj/Qv5db31r6l//DMPP15/vVD6l7+9SF7f7LJeiP6v3/7F9HpBu15QLj7v19cjvsHkfR/rq/bXy7J/4tu3J6x/+b80X//aeb3oXH8OoPqX6Il1sr6xYH3TwgomrH8d//d/W9PLk+sbh5Yn1zclrBfT7/9M1GcarsDR+uaD9W0s689/LD+s9bv+pfvy9fLV+paBtSd8/1ffP17vSKjis15WyGCt1/cvQpcOn30rw4/XW9/6sEJM61uAvr8QXd/6sP5V+9JtBVbWz5GX02u9/flvfljMF5/v743uCZisPtbaWy+J196wvr1l9b+8tYJd6xsr1p8MWZpWPxMCJqvH9W0Hi9f6poG1z1V/Umh9Zr0EX4GHf+52u61vg1pBr/Uyee1J6zmygk1r3S8PfvQnuD5is74JY/05ocV1BdZWL999vfaT5YcVRlrhyGotV+xT/315bK33xWYFTdbzaD3D1x66vkVn7Ufrxf8KKf34Z0+qntZ11zeDrFDWWneLwVp76xm0Aj9HAzTV/d7/9zXP2uPXM2g9p9cs635r31oBv9XLmmvtw+vnZ/v7kTX8s/7WXrM8sry39tX1bTnrubp4Lp+s4OgKcKx+fvwTVp/NvLR6/yfH/qHNb7xZ/aw+1sxL8/WNXsu7az2snta+sPpY3l374s/+pNOPva37L+YrBLZ+d1jcVxh17Y1rza5n8/pd5qM/BbiutZisPXD9qbvV09q3Vi8rELM0W72s4O7Os+Arv++t59Lqf/l2fZvY+l1sPZfXN7us31tWH+ub69Ye8VkQb/AuX90AACAASURBVK2p9TvJejasvWl9q8xHf3LniJ/VIvBTAgImJzCHgMkMEdMHoTOmvK8Lh+o1v7SPaFBrsCrSOux1oQoBBBAQMNn1QHrf9vyslUhrUHcwv4KP9jRKe0nAZE8HVQhcnMAjXupcHKHxEUAAgVMSWN86sQIP6+ffuN1u/8EppzRUmsAKt61gxfpZoY8V9nilnxXeWb8rrZ8VFFuhTj/PJ7ACyCuEsn4++7ONz+9UB6cgIGByAhkFTGaImD4InTHlfV04VK/5pX1Eg1qDVZHWYa8LVQgggICAya4H0vu252etRFqDuoP5FXy0p1HaSwImezqoQuDiBARMLm4A4yOAAAI/IbD+vNj6RoT1DTvrGzH+gcHfEELEmQTWN0etb01aP8tD61uDXu3nv30XKllhk/XNYn6eT+D7N5+tb31b37a2/l8/CMQICJjE0PZdWMCkj/Vnd0ofhM6Y8r4uHKrX/NI+okGtwapI67DXhSoEEEBAwGTXA+l92/OzViKtQd3B/Ao+2tMo7SUBkz0dVCFwcQICJhc3gPERQACBTwisP22y/qTI+vlXbrfbf4QWApsE1p9e+avf/qzR+si/e7vd/sLmZ6eUrT/ztP4s3PpZf3Lm79v403BTej9zH//k7Xb7b74N+G/ebrd/78zDmm0GAQGTGTrc1YWAyV34Hvbh9EHowxp94oUcqtfw0z6iQa3BqkjrsNeFKgQQQEDAZNcD6X3b87NWIq1B3cH8Cj7a0yjtJQGTPR1UIXBxAgImFzeA8RFAAIGCwH9+u93++dvt9r/cbrd/8Ha7/T+IXZ7AX7zdbv/d7Xb7z2632//1AY0/c7vd/tLtdvvHv/23//vbN+H8zy9E7u+43W7/9bsZ/BmWOeL9tdvt9o/dbrf/4Xa7/aO+WWmOMGfuRMDkBOqeIWASP0T8kz+KK52eIT5Aww0cqteQ0z6iQa3BqkjrsNeFKgQQQEDAZNcD6X3b87NWIq1B3cH8Cj7a0yjtJQGTPR1UIXBxAgImFzeA8RFAAAEEEDhI4PufJ/l/b7fbf3+73f7H2+22QiR/5+12+0e+hUm+v4/909vt9udut9t/cvAezyj/V7+FqP6u2+32T99ut199a+J/u91uf/ztW0ye0Zd7IoDAkwkImDxZgEfcXsCkpthxmJs+CK2nnF/RocN8Cp93mPYRDfYcktZhrwtVCCCAgIDJrgfS+7bnZ61EWoO6g/kVfLSnUdpLAiZ7OqhC4OIEBEwubgDjI4AAAgggcJDA94BJ9bH/83a7/fnb7fafVoVD/vtHc/1/t9vtX7jdbv/FkB61gQACTyAgYPIE6I++pYBJTbTjMDd9EFpPOb+iQ4f5FD7vMO0jGuw5JK3DXheqEEAAAQGTXQ+k923Pz1qJtAZ1B/Mr+GhPo7SXBEz2dFCFwMUJCJhc3ADGRwABBBBA4CCBv/d2u/3Z2+32T337Zo+/53a7/d3frvG/3263399ut//qdrv9x7fbbYVMXuXnfcDk/7jdbutPsfzbt9vtr77KAPpEAIEMAQGTDNfWqwqY1Lg7DnPTB6H1lPMrOnSYT+HzDtM+osGeQ9I67HWhCgEEEBAw2fVAet/2/KyVSGtQdzC/go/2NEp7ScBkTwdVCCCAAAIIIIAAAggggAACCCCAwEcEBExO4AsBk1rEjsPc9EFoPeX8ig4d5lP4vMO0j2iw55C0DntdqEIAAQQETHY9kN63PT9rJdIa1B3Mr+CjPY3SXhIw2dNBFQIIIIAAAggggAACCCCAAAIIIPARAQGTE/hCwKQWseMwN30QWk85v6JDh/kUPu8w7SMa7DkkrcNeF6oQQAABAZNdD6T3bc/PWom0BnUH8yv4aE+jtJcETPZ0UIUAAggggAACCCCAAAIIIIAAAgh8REDA5AS+EDCpRew4zE0fhNZTzq/o0GE+hc87TPuIBnsOSeuw14UqBBBAQMBk1wPpfdvzs1YirUHdwfwKPtrTKO0lAZM9HVQhgAACCCCAAAIIIIAAAggggAACHxEQMDmBLwRMahE7DnPTB6H1lPMrOnSYT+HzDtM+osGeQ9I67HWhCgEEEBAw2fVAet/2/KyVSGtQdzC/go/2NEp7ScBkTwdVCCCAAAIIIIAAAggggAACCCCAwEcEBExO4AsBk1rEjsPc9EFoPeX8ig4d5lP4vMO0j2iw55C0DntdqEIAAQQETHY9kN63PT9rJdIa1B3Mr+CjPY3SXhIw2dNBFQIIIIAAAggggAACCCCAAAIIIPARAQGTE/hCwKQWseMwN30QWk85v6JDh/kUPu8w7SMa7DkkrcNeF6oQQAABAZNdD6T3bc/PWom0BnUH8yv4aE+jtJcETPZ0UIUAAggggAACCCCAAAIIIIAAAgh8REDA5AS+EDCpRew4zE0fhNZTzq/o0GE+hc87TPuIBnsOSeuw14UqBBBAQMBk1wPpfdvzs1YirUHdwfwKPtrTKO0lAZM9HVQhgAACCCCAAAIIIIAAAggggAACHxEQMDmBLwRMahE7DnPTB6H1lPMrOnSYT+HzDtM+osGeQ9I67HWhCgEEEBAw2fVAet/2/KyVSGtQdzC/go/2NEp7ScBkTwdVCCCAAAIIIIAAAggggAACCCCAwEcEBExO4AsBk1rEjsPc9EFoPeX8ig4d5lP4vMO0j2iw55C0DntdqEIAAQQETHY9kN63PT9rJdIa1B3Mr+CjPY3SXhIw2dNBFQIIIIAAAggggAACCCCAAAIIIPARAQGTE/hCwKQWseMwN30QWk85v6JDh/kUPu8w7SMa7DkkrcNeF6oQQAABAZNdD6T3bc/PWom0BnUH8yv4aE+jtJcETPZ0SFf96Z/+6Z+m7+H6CCCAAAIIIIAAAggggAACCLw6gV9++WVcnmNcQ68u8jP6FzCpqXcc5qYPQusp51d06DCfwucdpn1Egz2HpHXY60IVAgggIGCy64H0vu35WSuR1qDuYH4FH+1plPaSgMmeDukqAZM0YddHAAEEEEAAAQQQQAABBBA4AwEBkzOoOHAGAZNalI7D3PRBaD3l/IoOHeZT+LzDtI9osOeQtA57XahCAAEEBEx2PZDetz0/ayXSGtQdzK/goz2N0l4SMNnTIV0lYJIm7PoIIIAAAggggAACCCCAAAJnICBgcgYVB84gYFKL0nGYmz4IraecX9Ghw3wKn3eY9hEN9hyS1mGvC1UIIICAgMmuB9L7tudnrURag7qD+RV8tKdR2ksCJns6pKsETNKEXR8BBBBAAAEEEEAAAQQQQOAMBARMzqDiwBkETGpROg5z0weh9ZTzKzp0mE/h8w7TPqLBnkPSOux1oQoBBBAQMNn1QHrf9vyslUhrUHcwv4KP9jRKe0nAZE+HdJWASZqw6yOAAAIIIIAAAggggAACCJyBgIDJGVQcOIOASS1Kx2Fu+iC0nnJ+RYcO8yl83mHaRzTYc0hah70uVCGAAAICJrseSO/bnp+1EmkN6g7mV/DRnkZpLwmY7OmQrhIwSRN2fQQQQAABBBBAAAEEEEAAgTMQEDA5g4oDZxAwqUXpOMxNH4TWU86v6NBhPoXPO0z7iAZ7DknrsNeFKgQQQEDAZNcD6X3b87NWIq1B3cH8Cj7a0yjtJQGTPR3SVQImacKujwACCCCAAAIIIIAAAgggcAYCAiZnUHHgDAImtSgdh7npg9B6yvkVHTrMp/B5h2kf0WDPIWkd9rpQhQACCAiY7HogvW97ftZKpDWoO5hfwUd7GqW9JGCyp0O6SsAkTdj1EUAAAQQQQAABBBBAAAEEzkBAwOQMKg6cQcCkFqXjMDd9EFpPOb+iQ4f5FD7vMO0jGuw5JK3DXheqEEAAAQGTXQ+k923Pz1qJtAZ1B/Mr+GhPo7SXBEz2dEhXCZikCbs+AggggAACCCCAAAIIIIDAGQgImJxBxYEzCJjUonQc5qYPQusp51d06DCfwucdpn1Egz2HpHXY60IVAgggIGCy64H0vu35WSuR1qDuYH4FH+1plPaSgMmeDukqAZM0YddHAAEEEEAAAQQQQAABBBA4AwEBkzOoOHAGAZNalI7D3PRBaD3l/IoOHeZT+LzDtI9osOeQtA57XahCAAEEBEx2PZDetz0/ayXSGtQdzK/goz2N0l4SMNnTIV0lYJIm7PoIIIAAAggggAACCCCAAAJnICBgcgYVB84gYFKL0nGYmz4IraecX9Ghw3wKn3eY9hEN9hyS1mGvC1UIIICAgMmuB9L7tudnrURag7qD+RV8tKdR2ksCJns6pKvSAZPf/va36RFcHwEEvhH4y3/5L0dZWM9RvC6OAAIIIPAkAp6fTwLvtggECKTXs4BJQDSXvN0ETGoXdBzmpg9C6ynnV6R16NDg1WdI979cmNbhDDPMX606RACBKQTOsOeZoXZT+tm5Okjr0DFDTXJ2RVqD2dPvd5f2koDJvhbJSgGTJF3XRqCXQPpAXcCkV093QwABBBDoIeD52cPZXRDoIJBezwImHSpe8B4CJrXoHYe56YPQesr5FWkdOjR49RnS/S8XpnU4wwzzV6sOEUBgCoEz7HlmqN2UfnauDtI6dMxQk5xdkdZg9vT73aW9JGCyr0WyUsAkSde1EeglkD5QFzDp1dPdEEAAAQR6CHh+9nB2FwQ6CKTXs4BJh4oXvIeASS16x2Fu+iC0nnJ+RVqHDg1efYZ0/8uFaR3OMMP81apDBBCYQuAMe54Zajeln52rg7QOHTPUJGdXpDWYPf1+d2kvCZjsa5GsFDBJ0nVtBHoJpA/UBUx69XQ3BBBAAIEeAp6fPZzdBYEOAun1LGDSoeIF7yFgUovecZibPgitp5xfkdahQ4NXnyHd/3JhWoczzDB/teoQAQSmEDjDnmeG2k3pZ+fqIK1Dxww1ydkVaQ1mT7/fXdpLAib7WiQrBUySdF0bgV4C6QN1AZNePd0NAQQQQKCHgOdnD2d3QaCDQHo9C5h0qHjBewiY1KJ3HOamD0LrKedXpHXo0ODVZ0j3v1yY1uEMM8xfrTpEAIEpBM6w55mhdlP62bk6SOvQMUNNcnZFWoPZ0+93l/aSgMm+FslKAZMkXddGoJdA+kBdwKRXT3dDAAEEEOgh4PnZw9ldEOggkF7PAiYdKl7wHgImtegdh7npg9B6yvkVaR06NHj1GdL9LxemdTjDDPNXqw4RQGAKgTPseWao3ZR+dq4O0jp0zFCTnF2R1mD29Pvdpb0kYLKvRbJSwCRJ17UR6CWQPlAXMOnV090QQAABBHoIeH72cHYXBDoIpNezgEmHihe8h4BJLXrHYW76ILSecn5FWocODV59hnT/y4VpHc4ww/zVqkMEEJhC4Ax7nhlqN6WfnauDtA4dM9QkZ1ekNZg9/X53aS8JmOxrkawUMEnSdW0EegmkD9QFTHr1dDcEEEAAgR4Cnp89nN0FgQ4C6fUsYNKh4gXvIWBSi95xmJs+CK2nnF+R1qFDg1efId3/cmFahzPMMH+16hABBKYQOMOeZ4baTeln5+ogrUPHDDXJ2RVpDWZPv99d2ksCJvtaJCsFTJJ0XRuBXgLpA3UBk1493Q0BBBBAoIeA52cPZ3dBoINAej0LmHSoeMF7CJjUoncc5qYPQusp51ekdejQ4NVnSPe/XJjW4QwzzF+tOkQAgSkEzrDnmaF2U/rZuTpI69AxQ01ydkVag9nT73eX9pKAyb4WyUoBkyRd10agl0D6QF3ApFdPd0MAAQQQ6CHg+dnD2V0Q6CCQXs8CJh0qXvAeAia16B2HuemD0HrK+RVpHTo0ePUZ0v0vF6Z1OMMM81erDhFAYAqBM+x5ZqjdlH52rg7SOnTMUJOcXZHWYPb0+92lvSRgsq9FslLAJEnXtRHoJZA+UBcw6dXT3RBAAAEEegh4fvZwdhcEOgik17OASYeKF7yHgEktesdhbvogtJ5yfkVahw4NXn2GdP/LhWkdzjDD/NWqQwQQmELgDHueGWo3pZ+dq4O0Dh0z1CRnV6Q1mD39fndpLwmY7GuRrBQwSdJ1bQR6CaQP1AVMevV0NwQQQACBHgKenz2c3QWBDgLp9Sxg0qHiBe8hYFKL3nGYmz4IraecX5HWoUODV58h3f9yYVqHM8wwf7XqEAEEphA4w55nhtpN6Wfn6iCtQ8cMNcnZFWkNZk+/313aSwIm+1okKwVMknRdG4FeAukDdQGTXj3dDQEEEECgh4DnZw9nd0Ggg0B6PQuYdKh4wXsImNSidxzmpg9C6ynnV3ToMJ/C5x2mfUSDPYekddjrQhUCCCCQDwWchXF63/b8rJ2S1qDuYH4FH+1plPaSgMmeDukqAZM0YddHoI9A+kBdwKRPS3dCAAEEEOgj4PnZx9qdEEgTSK9nAZO0ghe9voBJLXzHYW76ILSecn5Fhw7zKXzeYdpHNNhzSFqHvS5UIYAAAgImux5I79uen7USaQ3qDuZX8NGeRmkvCZjs6ZCuEjBJE3Z9BPoIpA/UBUz6tHQnBBBAAIE+Ap6ffazdCYE0gfR6FjBJK3jR6wuY1MJ3HOamD0LrKedXdOgwn8LnHaZ9RIM9h6R12OtCFQIIICBgsuuB9L7t+Vkrkdag7mB+BR/taZT2koDJng7pKgGTNGHXR6CPQPpAXcCkT0t3QgABBBDoI+D52cfanRBIE0ivZwGTtIIXvb6ASS18x2Fu+iC0nnJ+RYcO8yl83mHaRzTYc0hah70uVCGAAAICJrseSO/bnp+1EmkN6g7mV/DRnkZpLwmY7OmQrhIwSRN2fQT6CKQP1AVM+rR0JwQQQACBPgKen32s3QmBNIH0ehYwSSt40esLmNTCdxzmpg9C6ynnV3ToMJ/C5x2mfUSDPYekddjrQhUCCCAgYLLrgfS+7flZK5HWoO5gfgUf7WmU9pKAyZ4O6SoBkzRh10egj0D6QF3ApE9Ld0IAAQQQ6CPg+dnH2p0QSBNIr2cBk7SCF72+gEktfMdhbvogtJ5yfkWHDvMpfN5h2kc02HNIWoe9LlQhgAACAia7Hkjv256ftRJpDeoO5lfw0Z5GaS8JmOzpkK4SMEkTdn0E+gikD9QFTPq0dCcEEEAAgT4Cnp99rN0JgTSB9HoWMEkreNHrnyFgcgbp0gehZ2DkUL1WMe0jGtQarIq0DntdqEIAAQQETHY9kN63PT9rJdIa1B3Mr+CjPY3SXhIw2dMhXSVgkibs+gj0EUgfqAuY9GnpTggggAACfQQ8P/tYuxMCaQLp9SxgklbwotcXMJkhfPogdMaU93XhUL3ml/YRDWoNVkVah70uVCGAAAICJrseSO/bnp+1EmkN6g7mV/DRnkZpLwmY7OmQrhIwSRN2fQT6CKQP1AVM+rR0JwQQQACBPgKen32s3QmBNIH0ehYwSSt40esLmMwQPn0QOmPK+7pwqF7zS/uIBrUGqyKtw14XqhBAAAEBk10PpPdtz89aibQGdQfzK/hoT6O0lwRM9nRIVwmYpAm7PgJ9BNIH6gImfVq6EwIIIIBAHwHPzz7W7oRAmkB6PQuYpBW86PUFTGYInz4InTHlfV04VK/5pX1Eg1qDVZHWYa8LVQgggICAya4H0vu252etRFqDuoP5FXy0p1HaSwImezqkqwRM0oRdH4E+AukDdQGTPi3dCQEEEECgj4DnZx9rd0IgTSC9ngVM0gpe9PoCJjOETx+Ezpjyvi4cqtf80j6iQa3BqkjrsNeFKgQQQEDAZNcD6X3b87NWIq1B3cH8Cj7a0yjtJQGTPR3SVQImacKuj0AfgfSBuoBJn5buhAACCCDQR8Dzs4+1OyGQJpBezwImaQUven0BkxnCpw9CZ0x5XxcO1Wt+aR/RoNZgVaR12OtCFQIIICBgsuuB9L7t+Vkrkdag7mB+BR/taZT2koDJng7pKgGTNGHXR6CPQPpAXcCkT0t3QgABBBDoI+D52cfanRBIE0ivZwGTtIIXvb6AyQzh0wehM6a8rwuH6jW/tI9oUGuwKtI67HWhCgEEEBAw2fVAet/2/KyVSGtQdzC/go/2NEp7ScBkT4d01RkCJulDxI6X6q8+Q7r/tQ7SOpih3m3SGqwO0jqYodY5rYH1XGvQUUHnPcrpPSOtQ7p/+/Y1fGTf3tPZeq45nWFPEjCpdVbxBQICJl+AFvhI+iA00HL7JR2q18jTPqJBrcGqSOuw14UqBBBAQMBk1wPpfdvzs1YirUHdwfwKPtrTKO0lAZM9HdJVAiY14TMchKZnSB+oe7FR+9RLvj1G6bVwBh2s5zle2uvka1V03uOW3jPSOqT7P8Oed4YZ0j7ye9jefpHWwXqeoYOAyZ4Oqg4SEDA5CCxUnj4IDbXdelmH6jXutI9oUGuwKtI67HWhCgEEEBAw2fVAet/2/KyVSGtQdzC/go/2NEp7ScBkT4d0lYBJTdhhbs0ofaDuxUatwRlekJlhT+f0nmQ9z9Bhr4uvV9F5j92rr7d0//bta/jI72F7Oqf3Vet5hg4CJns6qDpIQMDkILBQefogNNR262Udqte40z6iQa3BqkjrsNeFKgQQQEDAZNcD6X3b87NWIq1B3cH8Cj7a0yjtJQGTPR3SVQImNWGHuTWj9IG6Fxu1Bl7y7TGynmtO1nPNqGNP2uvi61V03mOX3jPSOqT79+y5ho869rz0WjjDDNbz3npLe0nAZE8HVQcJCJgcBBYqTx+EhtpuvaxD9Rp32kc0qDVYFWkd9rpQhQACCAiY7HogvW97ftZKpDWoO5hfwUd7GqW9JGCyp0O6SsCkJuwwt2aUPsg9w0uBM8xgLdRr4QwvW63nPZ071sNeJ1+rovMet7TOaR3S/Z9hzzvDDGkfneF3mDPMYD3v7dvp9SBgsqeDqoMEBEwOAguVpw9CQ223Xtaheo077SMa1BqsirQOe12oQgABBARMdj2Q3rc9P2sl0hrUHcyv4KM9jdJeEjDZ0yFdJWBSE3aYWzNKH+Se4aXAGWawFuq14EXlHqO0l86wJ+2R/HrVGRiZodY/vdbOsOedYQZroV4Lfg/bY5T20hn2JAGTPS+pOkhAwOQgsFB5+iA01HbrZR2q17jTPqJBrcGqSOuw14UqBBBAQMBk1wPpfdvzs1YirUHdwfwKPtrTKO0lAZM9HdJVAiY14TMchKZnSB9Gn+GlwBlmSPvoDC/5zjCD9Vw/FzrW814XX6+i8x679L6X1iHd/xn2vDPMkPZRx55nhnpPsp5rRh3rWcBkTwdVBwkImBwEFipPH4SG2m69rEP1GnfaRzSoNVgVaR32ulCFAAIICJjseiC9b3t+1kqkNag7mF/BR3sapb0kYLKnQ7pKwKQm7DC3ZuSlQM3oDC9nrIU9ndPrIa1Duv8zrIWOGfbc9vUqOu+xe/X1lu5/UUx7yQy1V9MadOx5Zqh1thZqRh17koDJng6qDhIQMDkILFSePggNtd16WYfqNe60j2hQa7Aq0jrsdaEKAQQQEDDZ9UB63/b8rJVIa1B3ML+Cj/Y0SntJwGRPh3SVgElN2GFuzchLgZrRGV7OWAt7OqfXQ1qHdP9nWAsdM+y57etVdN5j9+rrLd3/opj2khlqr6Y16NjzzFDrbC3UjDr2JAGTPR1UHSQgYHIQWKg8fRAaarv1sg7Va9xpH9Gg1mBVpHXY60IVAgggIGCy64H0vu35WSuR1qDuYH4FH+1plPaSgMmeDukqAZOasMPcmpGXAjWjM7ycsRb2dE6vh7QO6f7PsBY6Zthz29er6LzH7tXXW7r/RTHtJTPUXk1r0LHnmaHW2VqoGXXsSQImezqoOkhAwOQgsFB5+iA01HbrZR2q17jTPqJBrcGqSOuw14UqBBBAQMBk1wPpfdvzs1YirUHdwfwKPtrTKO0lAZM9HdJVAiY1YYe5NSMvBWpGZ3g5Yy3s6ZxeD2kd0v2fYS10zLDntq9X0XmP3auvt3T/i2LaS2aovZrWoGPPM0Ots7VQM+rYkwRM9nRQdZCAgMlBYKHy9EFoqO3WyzpUr3GnfUSDWoNVkdZhrwtVCCCAgIDJrgfS+7bnZ61EWoO6g/kVfLSnUdpLAiZ7OqSrBExqwg5za0ZeCtSMzvByxlrY0zm9HtI6pPs/w1romGHPbV+vovMeu1dfb+n+F8W0l8xQezWtQceeZ4ZaZ2uhZtSxJwmY7Omg6iABAZODwELl6YPQUNutl3WoXuNO+4gGtQarIq3DXheqEEAAAQGTXQ+k923Pz1qJtAZ1B/Mr+GhPo7SXBEz2dEhXnSFgkmbk+gi8CoH0y5mOFxuvwlqfCCCAAALnIeD5eR4tTYJAej0LmPBYhICASQTr4YumD0IPNzTwAw7Va1HSPqJBrcGqSOuw14UqBBBAQMBk1wPpfdvzs1YirUHdwfwKPtrTKO0lAZM9HdJVAiZpwq6PQB+B9IG6gEmflu6EAAIIINBHwPOzj7U7IZAmkF7PAiZpBS96fQGTGcKnD0JnTHlfFw7Va35pH9Gg1mBVpHXY60IVAgggIGCy64H0vu35WSuR1qDuYH4FH+1plPaSgMmeDukqAZM0YddHoI9A+kBdwKRPS3dCAAEEEOgj4PnZx9qdEEgTSK9nAZO0ghe9voDJDOHTB6EzpryvC4fqNb+0j2hQa7Aq0jrsdaEKAQQQEDDZ9UB63/b8rJVIa1B3ML+Cj/Y0SntJwGRPh3SVgEmasOsj0EcgfaAuYNKnpTshgAACCPQR8PzsY+1OCKQJpNezgElawYteX8BkhvDpg9AZU97XhUP1ml/aRzSoNVgVaR32ulCFAAIICJjseiC9b3t+1kqkNag7mF/BR3sapb0kYLKnQ7pKwCRN2PUR6COQPlAXMOnT0p0QQAABBPoIeH72sXYnBNIE0utZwCSt4EWvL2AyQ/j0QeiMKe/rwqF6zS/tIxrUGqyKtA57XahCAAEEBEx2PZDetz0/ayXSGtQdzK/goz2N0l4SMNnTIV0lYJIm7PoI9BFIH6gLmPRp6U4IIIAAAn0EPD/7WLsTAmkC6fUsYJJWoKYQwwAAIABJREFU8KLXFzCZIXz6IHTGlPd14VC95pf2EQ1qDVZFWoe9LlQhgAACAia7Hkjv256ftRJpDeoO5lfw0Z5GaS8JmOzpkK4SMEkTdn0E+gikD9QFTPq0dCcEEEAAgT4Cnp99rN0JgTSB9HoWMEkreNHrC5hcVHhjI4AAAggggAACCCCAAAInIyBgcjJBfzKOgMk1dDblNQikD9QFTK7hI1MigAACVyPg+Xk1xc17ZgLp9Sxgcmb3PHE2AZMnwndrBBBAAAEEEEAAAQQQQACBhxEQMHkYytEXEjAZLY/mEDhEIH2gLmBySA7FCCCAAAIvQsDz80WE0iYCGwTS61nAZEMEJccJCJgcZ+YTCCCAAAIIIIAAAggggAAC8wgImMzTJNGRgEmCqmsi8BwC6QN1AZPn6OquCCCAAAJZAp6fWb6ujkAngfR6FjDpVPNC9xIwuZDYRkUAAQQQQAABBBBAAAEETkxAwOTE4r4bTcDkGjqb8hoE0gfqAibX8JEpEUAAgasR8Py8muLmPTOB9HoWMDmze544m4DJE+G7NQIIIIAAAggggAACCCCAwMMICJg8DOXoCwmYjJZHcwgcIpA+UBcwOSSHYgQQQACBFyHg+fkiQmkTgQ0C6fUsYLIhgpLjBARMjjPzCQQQQAABBBBAAAEEEEAAgXkEBEzmaZLoSMAkQdU1EXgOgfSBuoDJc3R1VwQQQACBLAHPzyxfV0egk0B6PQuYdKp5oXsJmFxIbKMigAACCCCAAAIIIIAAAicmIGByYnHfjSZgcg2dTXkNAukDdQGTa/jIlAgggMDVCHh+Xk1x856ZQHo9C5ic2T1PnE3A5Inw3RoBBBBAAAEEEEAAAQQQQOBhBARMHoZy9IUETEbLozkEDhFIH6gLmBySQzECCCCAwIsQ8Px8EaG0icAGgfR6FjDZEEHJcQICJseZ+QQCCCCAAAIIIIAAAggggMA8AgIm8zRJdCRgkqDqmgg8h0D6QF3A5Dm6uisCCCCAQJaA52eWr6sj0EkgvZ4FTDrVvNC9BEwuJLZREUAAAQQQQAABBBBAAIETExAwObG470YTMLmGzqa8BoH0gbqAyTV8ZEoEEEDgagQ8P6+muHnPTCC9ngVMzuyeJ84mYPJE+G6NAAIIIIAAAggggAACCCDwMAICJg9DOfpCAiaj5dEcAocIpA/UBUwOyaEYAQQQQOBFCHh+vohQ2kRgg0B6PQuYbIig5DgBAZPjzHwCAQQQQAABBBBAAAEEEEBgHgEBk3maJDoSMElQdU0EnkMgfaAuYPIcXd0VAQQQQCBLwPMzy9fVEegkkF7PAiadal7oXgImFxLbqAgggAACCCCAAAIIIIDAiQkImJxY3HejCZhcQ2dTXoNA+kBdwOQaPjIlAgggcDUCnp9XU9y8ZyaQXs8CJmd2zxNnEzB5Iny3RgABBBBAAAEEEEAAAQQQeBgBAZOHoRx9IQGT0fJoDoFDBNIH6gImh+RQjAACCCDwIgQ8P19EKG0isEEgvZ4FTDZEUHKcgIDJcWY+gQACCCCAAAIIIIAAAgggMI+AgMk8TRIdCZgkqLomAs8hkD5QFzB5jq7uigACCCCQJeD5meXr6gh0EkivZwGTTjUvdC8BkwuJbVQEEEAAAQQQQAABBBBA4MQEBExOLO670QRMrqGzKa9BIH2gLmByDR+ZEgEEELgaAc/Pqylu3jMTSK9nAZMzu+eJswmYPBG+WyOAAAIIIIAAAggggAACCDyMgIDJw1COvpCAyWh5NIfAIQLpA3UBk0NyKEYAAQQQeBECnp8vIpQ2EdggkF7PAiYbIig5TkDA5Dgzn0AAAQQQQAABBBBAAAEEEJhHQMBkniaJjgRMElRdE4HnEEgfqAuYPEdXd0UAAQQQyBLw/MzydXUEOgmk17OASaeaF7qXgMmFxDYqAggggAACCCCAAAIIIHBiAgImJxb33WgCJtfQ2ZTXIJA+UBcwuYaPTIkAAghcjYDn59UUN++ZCaTXs4DJmd3zxNkETJ4I360RQAABBBBAAAEEEEAAAQQeRkDA5GEoR19IwGS0PJpD4BCB9IG6gMkhORQjgAACCLwIAc/PFxFKmwhsEEivZwGTDRGUHCcgYHKcmU8ggAACCCCAAAIIIIAAAgjMIyBgMk+TREcCJgmqronAcwikD9QFTJ6jq7sigAACCGQJeH5m+bo6Ap0E0utZwKRTzQvdS8DkQmIbFQEEEEAAAQQQQAABBBA4MQEBkxOL+240AZNr6GzKaxBIH6gLmFzDR6ZEAAEErkbA8/Nqipv3zATS61nA5MzueeJsAiZPhO/WCCCAAAIIIIAAAggggAACDyMgYPIwlKMvJGAyWh7NIXCIQPpAXcDkkByKEUAAAQRehIDn54sIpU0ENgik17OAyYYISo4TEDA5zswnEEAAAQQQQAABBBBAAAEE5hEQMJmnSaIjAZMEVddE4DkE0gfqAibP0dVdEUAAAQSyBDw/s3xdHYFOAun1LGDSqeaF7iVgciGxjYoAAggggAACCCCAAAIInJiAgMmJxX03moDJNXQ25TUIpA/UBUyu4SNTIoAAAlcj4Pl5NcXNe2YC6fUsYHJm9zxxNgGTJ8J3awQQQAABBBBAAAEEEEAAgYcREDB5GMrRFxIwGS2P5hA4RCB9oC5gckgOxQgggAACL0LA8/NFhNImAhsE0utZwGRDBCXHCQiYHGfmEwgggAACCCCAAAIIIIAAAvMICJjM0yTRkYBJgqprIvAcAukDdQGT5+jqrggggAACWQKen1m+ro5AJ4H0ehYw6VTzQvcSMLmQ2EZFAAEEEEAAAQQQQAABBE5MQMDkxOK+G03A5Bo6m/IaBNIH6gIm1/CRKRFAAIGrEfD8vJri5j0zgfR6FjA5s3ueOJuAyRPhuzUCCCCAAAIIIIAAAggggMDDCAiYPAzl6AsJmIyWR3MIHCKQPlAXMDkkh2IEEEAAgRch4Pn5IkJpE4ENAun1LGCyIYKS4wQETI4z8wkEEEAAAQQQQAABBBBAAIF5BARM5mmS6OgMAZP0IWLHS/X0DAnvdF+zQ4fumR59v7SPaLCnWFqHvS5UIYAAArebfXvPBel9mw61DmkN6g7mV/DRnkZpLwmY7Omg6iCBMwRM4oeIf/JHB6keL3/1GdL9L6K/Cutghtq3aQ1WB2kdzFDrnNbAeq416Kig8x7l9J6R1iHdv337Gj6yb+/pbD3XnE6xJ/3ud7/Uk6pIExAwqQl3HOamD0LrKedXdOgwn8LnHaZ9RIM9h6R12OtCFQIIICBgsuuB9L7t+Vkrkdag7mB+BR/taZT2koDJng6qDhIQMKmBneIgVDijFDr9UuAML2eshdJGbwVpL6V1SPd/hrXQMcOe275eRec9dq++3tL9n2HPO8MM1rP1vEegrkp76RR7koBJbaSGCgGTGnLHYW76ILSecn5Fhw7zKXzeYdpHNNhzSFqHvS5UIYAAAgImux5I79uen7USaQ3qDuZX8NGeRmkvCZjs6aDqIAEBkxrYKQ5CBUxKodMH6h0vpNMzWAuljd4KXl2HdP9nWAsdM+y57etVdN5jl9730jqk+z/DnneGGdI+6tjzzFDvSdZzzahlPQuY7AkRrhIwqQF3HOamD0LrKedXdOgwn8LnHaZ9RIM9h6R12OtCFQIIICBgsuuB9L7t+Vkrkdag7mB+BR/taZT2koDJng6qDhIQMKmBOcytGXkpUDM6w8sZa2FP5/R6SOuQ7v8Ma6Fjhj23fb2KznvsXn29pftveZkbDsmeYQbr2XreI1BXpb10ij1JwKQ2UkOFgEkNueMwN30QWk85v6JDh/kUPu8w7SMa7DkkrcNeF6oQQAABAZNdD6T3bc/PWom0BnUH8yv4aE+jtJcETPZ0UHWQgIBJDewUB6HhlzPpw+iOl7lmsBZqAnsVaS+l96R0/9bzno/SVXTeI/zq6y3d/6KY9pIZaq+mNbBv1xpYC3uMTrGeBUz2xA5XCZjUgDsOc9MHofWU8ys6dJhP4fMO0z6iwZ5D0jrsdaEKAQQQEDDZ9UB63/b8rJVIa1B3ML+Cj/Y0SntJwGRPB1UHCQiY1MBOcRAqYFIK7eVMiehmLdSMzvCCyVrY07ljPex18rUqOu9xS+uc1iHd/xn2vDPMkPbRYpT2khnqPSmtwRnWQssMAia1WRsqBExqyB2HuemD0HrK+RUdOsyn8HmHaR/RYM8haR32ulCFAAIICJjseiC9b3t+1kqkNag7mF/BR3sapb0kYLKng6qDBARMamAOc2tGXgrUjM7wcsZa2NM5vR7SOqT7P8Na6Jhhz21fr6LzHrtXX2/p/lte5oZDsmeYwXq2nvcI1FVpL51iTxIwqY3UUCFgUkPuOMxNH4TWU86v6NBhPoXPO0z7iAZ7DknrsNeFKgQQQEDAZNcD6X3b87NWIq1B3cH8Cj7a0yjtJQGTPR1UHSQgYFIDO8VBaPjlTPowuuNlrhmshZrAXkXaS+k9Kd2/9bzno3QVnfcIv/p6S/e/KKa9ZIbaq2kN7Nu1BtbCHqNTrGcBkz2xw1UCJjXgjsPc9EFoPeX8ig4d5lP4vMO0j2iw55C0DntdqEIAAQQETHY9kN63PT9rJdIa1B3Mr+CjPY3SXhIw2dNB1UECAiY1sFMchAqYlEJ7OVMiin89vpcztQZe8u0xOsN63pv061VnYGSGWn+/w9SMzvDssRb2dE6vh7QO6f7PsBZaZhAw2Vtw4SoBkxpwx2Fu+iC0nnJ+RYcO8yl83mHaRzTYc0hah70uVCGAAAICJrseSO/bnp+1EmkN6g7mV/DRnkZpLwmY7Omg6iABAZMamMPcmlH6QH11kNbBDLXOaQ1aXgqEw1ZnmMFaqNdCx56018XXq+i8xy6976V1SPd/hj3vDDOkfdSx55mh3pOs55pRy3oWMNkTIlwlYFID7jjMTR+E1lPOr+jQYT6FzztM+4gGew5J67DXhSoEEEBAwGTXA+l92/OzViKtQd3B/Ao+2tMo7SUBkz0dVB0kIGBSA3OYWzPyUqBmdIaXM9bCns7p9ZDWId3/GdZCxwx7bvt6FZ332L36ekv33/IyVzCwNKv1XCJ6K0ivh7QO6f6t500fCZjsgQpXCZjUgDsOc9MHofWU8ys6dJhP4fMO0z6iwZ5D0jrsdaEKAQQQEDDZ9UB63/b8rJVIa1B3ML+Cj/Y0SntJwGRPB1UHCQiY1MAc5taM0gfqZ3gpcIYZrIV6LZzh5Yz1vKdzx3rY6+RrVXTe45bWOa1Duv8z7HlnmCHtozP8DnOGGaznvX07vR5+JWCyJ0S4SsCkBtxxmJs+CK2nnF/RocN8Cp93mPYRDfYcktZhrwtVCCCAgIDJrgfS+7bnZ61EWoO6g/kVfLSnUdpLAiZ7Oqg6SOAMAZODIytHAAEEEEAAAQQQQAABBBA4IQEBkxOK+sFIAia1zh2HuemD0HrK+RUdOsyn8HmHaR/RYM8haR32ulCFAAIICJjseiC9b3t+1kqkNag7mF/BR3sapb0kYLKng6qDBARMDgJTjgACCCCAAAIIIIAAAgggMJKAgMlIWR7elIBJjbTjMDd9EFpPOb+iQ4f5FD7vMO0jGuw5JK3DXheqEEAAAQGTXQ+k923Pz1qJtAZ1B/Mr+GhPo7SXBEz2dFB1kICAyUFgyhFAAAEEEEAAAQQQQAABBEYSEDAZKcvDmxIwqZF2HOamD0LrKedXdOgwn8LnHaZ9RIM9h6R12OtCFQIIICBgsuuB9L7t+Vkrkdag7mB+BR/taZT2koDJng6qDhIQMDkITDkCCCCAAAIIIIAAAggggMBIAgImI2V5eFMCJjXSjsPc9EFoPeX8ig4d5lP4vMO0j2iw55C0DntdqEIAAQQETHY9kN63PT9rJdIa1B3Mr+CjPY3SXhIw2dNB1UECAiYHgSlHAAEEEEAAAQQQQAABBBAYSUDAZKQsD29KwKRG2nGYmz4IraecX9Ghw3wKn3eY9hEN9hyS1mGvC1UIIICAgMmuB9L7tudnrURag7qD+RV8tKdR2ksCJns6qDpIQMDkIDDlCCCAAAIIIIAAAggggAACIwkImIyU5eFNCZjUSDsOc9MHofWU8ys6dJhP4fMO0z6iwZ5D0jrsdaEKAQQQEDDZ9UB63/b8rJVIa1B3ML+Cj/Y0SntJwGRPB1UHCQiYHASmHAEEEEAAAQQQQAABBBBAYCQBAZORsjy8KQGTGmnHYW76ILSecn5Fhw7zKXzeYdpHNNhzSFqHvS5UIYAAAgImux5I79uen7USaQ3qDuZX8NGeRmkvCZjs6aDqIAEBk4PAlCOAAAIIIIAAAggggAACCIwkIGAyUpaHNyVgUiPtOMxNH4TWU86v6NBhPoXPO0z7iAZ7DknrsNeFKgQQQEDAZNcD6X3b87NWIq1B3cH8Cj7a0yjtJQGTPR1UHSQgYHIQmHIEEEAAAQQQQAABBBBAAIGRBARMRsry8KYETGqkHYe56YPQesr5FR06zKfweYdpH9FgzyFpHfa6UIUAAggImOx6IL1ve37WSqQ1qDuYX8FHexqlvSRgsqeDqoMEBEwOAlOOAAIIIIAAAggggAACCCAwkoCAyUhZHt6UgEmNtOMwN30QWk85v6JDh/kUPu8w7SMa7DkkrcNeF6oQQAABAZNdD6T3bc/PWom0BnUH8yv4aE+jtJcETPZ0UHWQgIDJQWDKEUAAAQQQQAABBBBAAAEERhIQMBkpy8ObEjCpkXYc5qYPQusp51d06DCfwucdpn1Egz2HpHXY60IVAgggIGCy64H0vu35WSuR1qDuYH4FH+1plPaSgMmeDqoOEhAwOQhMOQIIIIAAAggggAACCCCAwEgCAiYjZXl4UwImNdKOw9z0QWg95fyKDh3mU/i8w7SPaLDnkLQOe12oQgABBARMdj2Q3rc9P2sl0hrUHcyv4KM9jdJeEjDZ00HVQQICJgeBKUcAAQQQQAABBBBAAAEEEBhJQMBkpCwPb0rApEbacZibPgitp5xfkdahQ4NXnyHd/3JhWoczzDB/teoQAQSmEDjDnmeG2k3pZ+fqIK1Dxww1ydkVaQ1mT7/fXdpLAib7Wqg8QEDA5AAspQgggAACCCCAAAIIIIAAAmMJCJiMleahjQmY1Dg7DnPTB6H1lPMr0jp0aPDqM6T7Xy5M63CGGeavVh0igMAUAmfY88xQuyn97FwdpHXomKEmObsircHs6fe7S3tJwGRfC5UHCAiYHIClFAEEEEAAAQQQQAABBBBAYCwBAZOx0jy0MQGTGmfHYW76ILSecn5FWocODV59hnT/y4VpHc4ww/zVqkMEEJhC4Ax7nhlqN6WfnauDtA4dM9QkZ1ekNZg9/X53aS8JmOxrofIAAQGTA7CUIoAAAggggAACCCCAAAIIjCUgYDJWmoc2JmBS4+w4zE0fhNZTzq9I69ChwavPkO5/uTCtwxlmmL9adYgAAlMInGHPM0PtpvSzc3WQ1qFjhprk7Iq0BrOn3+8u7SUBk30tVB4gIGByAJZSBBBAAAEEEEAAAQQQQACBsQQETMZK89DGBExqnB2HuemD0HrK+RVpHTo0ePUZ0v0vF6Z1OMMM81erDhFAYAqBM+x5ZqjdlH52rg7SOnTMUJOcXZHWYPb0+92lvSRgsq+FygMEBEwOwFKKAAIIIIAAAggggAACCCAwloCAyVhpHtqYgEmNs+MwN30QWk85vyKtQ4cGrz5Duv/lwrQOZ5hh/mrVIQIITCFwhj3PDLWb0s/O1UFah44ZapKzK9IazJ5+v7u0lwRM9rVQeYCAgMkBWEoRQAABBBBAAAEEEEAAAQTGEhAwGSvNQxsTMKlxdhzmpg9C6ynnV6R16NDg1WdI979cmNbhDDPMX606RACBKQTOsOeZoXZT+tm5Okjr0DFDTXJ2RVqD2dPvd5f2koDJvhYqDxAQMDkASykCCCCAAAIIIIAAAggggMBYAgImY6V5aGMCJjXOjsPc9EFoPeX8irQOHRq8+gzp/pcL0zqcYYb5q1WHCCAwhcAZ9jwz1G5KPztXB2kdOmaoSc6uSGswe/r97tJeEjDZ10LlAQICJgdgKUUAAQQQQAABBBBAAAEEEBhLQMBkrDQPbUzApMbZcZibPgitp5xfkdahQ4NXnyHd/3JhWoczzDB/teoQAQSmEDjDnmeG2k3pZ+fqIK1Dxww1ydkVaQ1mT7/fXdpLAib7Wqg8QEDA5AAspQgggAACCCCAAAIIIIAAAmMJCJiMleahjQmY1Dg7DnPTB6H1lPMr0jp0aPDqM6T7Xy5M63CGGeavVh0igMAUAmfY88xQuyn97FwdpHXomKEmObsircHs6fe7S3tJwGRfC5UHCAiYHIClFAEEEEAAAQQQQAABBBBAYCwBAZOx0jy0MQGTGmfHYW76ILSecn5FWocODV59hnT/y4VpHc4ww/zVqkMEEJhC4Ax7nhlqN6WfnauDtA4dM9QkZ1ekNZg9/X53aS8JmOxrofIAAQGTA7CUIoAAAggggAACCCCAAAIIjCUgYDJWmoc2JmBS4+w4zE0fhNZTzq9I69ChwavPkO5/uTCtwxlmmL9adYgAAlMInGHPM0PtpvSzc3WQ1qFjhprk7Iq0BrOn3+8u7SUBk30tVB4gIGByAJZSBBBAAAEEEEAAAQQQQACBsQQETMZK89DGBExqnB2HuemD0HrK+RUdOsyn8HmHaR/RYM8haR32ulCFAAII5EMBZ2Gc3rc9P2unpDWoO5hfwUd7GqW9JGCyp4OqgwQETA4CU44AAggggAACCCCAAAIIIDCSgIDJSFke3pSASY204zA3fRBaTzm/okOH+RQ+7zDtIxrsOSStw14XqhBAAAEBk10PpPdtz89aibQGdQfzK/hoT6O0lwRM9nRQdZCAgMlBYMoRQAABBBBAAAEEEEAAAQRGEhAwGSnLw5sSMKmRdhzmpg9C6ynnV3ToMJ/C5x2mfUSDPYekddjrQhUCCCAgYLLrgfS+7flZK5HWoO5gfgUf7WmU9pKAyZ4Oqg4SEDA5CEw5AggggAACCCCAAAIIIIDASAICJiNleXhTAiY10o7D3PRBaD3l/IoOHeZT+LzDtI9osOeQtA57XahCAAEEBEx2PZDetz0/ayXSGtQdzK/goz2N0l4SMNnTQdVBAgImB4EpRwABBBBAAAEEEEAAAQQQGElAwGSkLA9vSsCkRtpxmJs+CK2nnF/RocN8Cp93mPYRDfYcktZhrwtVCCCAgIDJrgfS+7bnZ61EWoO6g/kVfLSnUdpLAiZ7Oqg6SEDA5CAw5QgggAACCCCAAAIIIIAAAiMJCJiMlOXhTQmY1Eg7DnPTB6H1lPMrOnSYT+HzDtM+osGeQ9I67HWhCgEEEBAw2fVAet/2/KyVSGtQdzC/go/2NEp7ScBkTwdVBwkImBwEphwBBBBAAAEEEEAAAQQQQGAkAQGTkbI8vCkBkxppx2Fu+iC0nnJ+RYcO8yl83mHaRzTYc0hah70uVCGAAAICJrseSO/bnp+1EmkN6g7mV/DRnkZpLwmY7Omg6iCBdMDkYDsjy3/1J380sq9JTaUPctesdKgV79Ch7mJ2BR/V+vBRzUjFdQjYM2qt7Rk1Iz6qGXX4iA4zdKi7mF3xq9/97pfZHV6jOwGTWueOw9z0QWg95fyKDh3mU/i8w7SPaLDnkLQOe12oQgABBARMdj2Q3rc9P2sl0hrUHcyv4KM9jdJeEjDZ00HVQQICJjUwh9E1Iy8FakYdFR06dMyRvIf1XNPlo5qRiusQsGfUWtszakZ8VDPq8BEdZuhQdzG7QsBkhj4CJrUOHYe56YPQesr5FR06zKfweYdpH9FgzyFpHfa6UIUAAggImOx6IL1ve37WSqQ1qDuYX8FHexqlvSRgsqeDqoMEBExqYA6ja0ZeCtSMOio6dOiYI3kP67mmy0c1IxXXIWDPqLW2Z9SM+Khm1OEjOszQoe5idoWAyQx9BExqHToOc9MHofWU8ys6dJhP4fMO0z6iwZ5D0jrsdaEKAQQQEDDZ9UB63/b8rJVIa1B3ML+Cj/Y0SntJwGRPB1UHCQiY1MAcRteMvBSoGXVUdOjQMUfyHtZzTZePakYqrkPAnlFrbc+oGfFRzajDR3SYoUPdxewKAZMZ+giY1Dp0HOamD0LrKedXdOgwn8LnHaZ9RIM9h6R12OtCFQIIICBgsuuB9L7t+Vkrkdag7mB+BR/taZT2koDJng6qDhIQMKmBOYyuGXkpUDPqqOjQoWOO5D2s55ouH9WMVFyHgD2j1tqeUTPio5pRh4/oMEOHuovZFQImM/QRMKl16DjMTR+E1lPOr+jQYT6FzztM+4gGew5J67DXhSoEEEBAwGTXA+l92/OzViKtQd3B/Ao+2tMo7SUBkz0dVB0kIGBSA3MYXTPyUqBm1FHRoUPHHMl7WM81XT6qGam4DgF7Rq21PaNmxEc1ow4f0WGGDnUXsysETGboc4aAyQyS93WRPgi9r7sZn3aoXuuQ9hENag1WRVqHvS5UIYAAAgImux5I79uen7USaQ3qDuZX8NGeRmkvCZjs6aDqIAEBkxqYw+iakZcCNaOOig4dOuZI3sN6runyUc1IxXUI2DNqre0ZNSM+qhl1+IgOM3Sou5hdIWAyQx8Bkxk6pA9CZ0x5XxcO1Wt+aR/RoNZgVaR12OtCFQIIICBgsuuB9L7t+Vkrkdag7mB+BR/taZT2koDJng6qDhIQMKmBOYyuGXkpUDPqqOjQoWOO5D2s55ouH9WMVFyHgD2j1tqeUTPio5pRh4/oMEOHuovZFQImM/QRMJmhQ/ogdMaU93XhUL3ml/YRDWoNVkVah70uVCGAAAICJrseSO/bnp+1EmkN6g7mV/DRnkZpLwmY7Omg6iABAZMamMPompGXAjWjjooOHTrmSN7Deq7p8lHNSMV1CNgzaq3tGTUjPqoZdfiIDjN0qLuYXSFgMkMfAZMZOqQPQmdMeV+QsW6mAAAgAElEQVQXDtVrfmkf0aDWYFWkddjrQhUCCCAgYLLrgfS+7flZK5HWoO5gfgUf7WmU9pKAyZ4Oqg4SEDCpgTmMrhl5KVAz6qjo0KFjjuQ9rOeaLh/VjFRch4A9o9banlEz4qOaUYeP6DBDh7qL2RUCJjP0ETCZoUP6IHTGlPd14VC95pf2EQ1qDVZFWoe9LlQhgAACAia7Hkjv256ftRJpDeoO5lfw0Z5GaS8JmOzpoOogAQGTGpjD6JqRlwI1o46KDh065kjew3qu6fJRzUjFdQjYM2qt7Rk1Iz6qGXX4iA4zdKi7mF0hYDJDHwGTGTqkD0JnTHlfFw7Va35pH9Gg1mBVpHXY60IVAgggIGCy64H0vu35WSuR1qDuYH4FH+1plPaSgMmeDqoOEhAwqYE5jK4ZeSlQM+qo6NChY47kPaznmi4f1YxUXIeAPaPW2p5RM+KjmlGHj+gwQ4e6i9kVAiYz9BEwmaFD+iB0xpT3deFQveaX9hENag1WRVqHvS5UIYAAAgImux5I79uen7USaQ3qDuZX8NGeRmkvCZjs6aDqIAEBkxqYw+iakZcCNaOOig4dOuZI3sN6runyUc1IxXUI2DNqre0ZNSM+qhl1+IgOM3Sou5hdIWAyQx8Bkxk6pA9CZ0x5XxcO1Wt+aR/RoNZgVaR12OtCFQIIICBgsuuB9L7t+Vkrkdag7mB+BR/taZT2koDJng6qDhIQMKmBOYyuGXkpUDPqqOjQoWOO5D2s55ouH9WMVFyHgD2j1tqeUTPio5pRh4/oMEOHuovZFQImM/QRMJmhQ/ogdMaU93XhUL3ml/YRDWoNVkVah70uVCGAAAICJrseSO/bnp+1EmkN6g7mV/DRnkZpLwmY7Omg6iABAZMamMPompGXAjWjjooOHTrmSN7Deq7p8lHNSMV1CNgzaq3tGTUjPqoZdfiIDjN0qLuYXSFgMkMfAZMZOqQPQmdMeV8XDtVrfmkf0aDWYFWkddjrQhUCCCAgYLLrgfS+7flZK5HWoO5gfgUf7WmU9pKAyZ4Oqg4SEDCpgTmMrhl5KVAz6qjo0KFjjuQ9rOeaLh/VjFRch4A9o9banlEz4qOaUYeP6DBDh7qL2RUCJjP0ETCZoUP6IHTGlPd14VC95pf2EQ1qDVZFWoe9LlQhgAACAia7Hkjv256ftRJpDeoO5lfw0Z5GaS8JmOzpoOogAQGTGpjD6JqRlwI1o46KDh065kjew3qu6fJRzUjFdQjYM2qt7Rk1Iz6qGXX4iA4zdKi7mF0hYDJDHwGTGTqkD0JnTHlfFw7Va35pH9Gg1mBVpHXY60IVAgggIGCy64H0vu35WSuR1qDuYH4FH+1plPaSgMmeDqoOEhAwqYE5jK4ZeSlQM+qo6NChY47kPaznmi4f1YxUXIeAPaPW2p5RM+KjmlGHj+gwQ4e6i9kVAiYz9BEwmaFD+iB0xpT3deFQveaX9hENag1WRVqHvS5UIYAAAgImux5I79uen7USaQ3qDuZX8NGeRmkvCZjs6aDqIAEBkxqYw+iakZcCNaOOig4dOuZI3sN6runyUc1IxXUI2DNqre0ZNSM+qhl1+IgOM3Sou5hdIWAyQx8Bkxk6pA9CZ0x5XxcO1Wt+aR/RoNZgVaR12OtCFQIIICBgsuuB9L7t+Vkrkdag7mB+BR/taZT2koDJng6qDhIQMKmBOYyuGXkpUDPqqOjQoWOO5D2s55ouH9WMVFyHgD2j1tqeUTPio5pRh4/oMEOHuovZFQImM/QRMJmhQ/ogdMaU93XhUL3ml/YRDWoNVkVah70uVCGAAAICJrseSO/bnp+1EmkN6g7mV/DRnkZpLwmY7Omg6iABAZMamMPompGXAjWjjooOHTrmSN7Deq7p8lHNSMV1CNgzaq3tGTUjPqoZdfiIDjN0qLuYXSFgMkMfAZMZOqQPQmdMeV8XDtVrfmkf0aDWYFWkddjrQhUCCCAgYLLrgfS+7flZK5HWoO5gfgUf7WmU9pKAyZ4Oqg4SEDCpgTmMrhl5KVAz6qjo0KFjjuQ9rOeaLh/VjFRch4A9o9banlEz4qOaUYeP6DBDh7qL2RUCJjP0ETCZoUP6IHTGlPd14VC95pf2EQ1qDVZFWoe9LlQhgAACAia7Hkjv256ftRJpDeoO5lfw0Z5GaS8JmOzpoOogAQGTGpjD6JqRlwI1o46KDh065kjew3qu6fJRzUjFdQjYM2qt7Rk1Iz6qGXX4iA4zdKi7mF0hYDJDHwGTGTqkD0JnTHlfFw7Va35pH9Gg1mBVpHXY60IVAgggIGCy64H0vu35WSuR1qDuYH4FH+1plPaSgMmeDqoOEhAwqYE5jK4ZeSlQM+qo6NChY47kPaznmi4f1YxUXIeAPaPW2p5RM+KjmlGHj+gwQ4e6i9kVAiYz9BEwmaFD+iB0xpT3deFQveaX9hENag1WRVqHvS5UIYAAAgImux5I79uen7USaQ3qDuZX8NGeRmkvCZjs6aDqIAEBkxqYw+iakZcCNaOOig4dOuZI3sN6runyUc1IxXUI2DNqre0ZNSM+qhl1+IgOM3Sou5hdIWAyQx8Bkxk6pA9CZ0x5XxcO1Wt+aR/RoNZgVaR12OtCFQIIICBgsuuB9L7t+Vkrkdag7mB+BR/taZT2koDJng6qDhIQMKmBOYyuGXkpUDPqqOjQoWOO5D2s55ouH9WMVFyHgD2j1tqeUTPio5pRh4/oMEOHuovZFQImM/QRMJmhQ/ogdMaU93XhUL3ml/YRDWoNVkVah70uVCGAAAICJrseSO/bnp+1EmkN6g7mV/DRnkZpLwmY7Omg6iABAZMamMPompGXAjWjjooOHTrmSN7Deq7p8lHNSMV1CNgzaq3tGTUjPqoZdfiIDjN0qLuYXSFgMkMfAZMZOqQPQmdMeV8XDtVrfmkf0aDWYFWkddjrQhUCCCAgYLLrgfS+7flZK5HWoO5gfgUf7WmU9pKAyZ4Oqg4SEDCpgTmMrhl5KVAz6qjo0KFjjuQ9rOeaLh/VjFRch4A9o9banlEz4qOaUYeP6DBDh7qL2RUCJjP0ETCZoUP6IHTGlPd14VC95pf2EQ1qDVZFWoe9LlQhgAACAia7Hkjv256ftRJpDeoO5lfw0Z5GaS8JmOzpoOogAQGTGpjD6JqRlwI1o46KDh065kjew3qu6fJRzUjFdQjYM2qt7Rk1Iz6qGXX4iA4zdKi7mF0hYDJDHwGTGTqkD0JnTHlfFw7Va35pH9Gg1mBVpHXY60IVAgggIGCy64H0vu35WSuR1qDuYH4FH+1plPaSgMmeDqoOEhAwqYE5jK4ZeSlQM+qo6NChY47kPaznmi4f1YxUXIeAPaPW2p5RM+KjmlGHj+gwQ4e6i9kVAiYz9BEwmaFD+iB0xpT3deFQveaX9hENag1WRVqHvS5UIYAAAgImux5I79uen7USaQ3qDuZX8NGeRmkvCZjs6aDqIAEBkxpYx2F0+lA9PUO6/6WSGWqvduhQdzG7Iu2jNX1ah/QM6f5nO0R3CPztBF59vaX779jzzuDJtA4d+7YZaiemdUhrYD3XGr/9b5Lf/e6XvUpVSQICJkm6ro0AAggggAACCCCAAAIIINBFQMCki7T7PJSAgEmN8wyHuekZ0gfqb4e5f/JHtVh3VJjhDngv9NG0jzpezqRn6FgLL2QZrV6cwKuvt3T/HXveGSyY1qFj3zZD7cS0DmkNrOda47f/TSJgsgcqXCVgEgbs8ggggAACCCCAAAIIIIAAAi0EBExaMLvJowkImNREz3CYm54hfaD+dpgrYFKatUOHsonhBWkfdbycSc/AR8NNrL1WAq++3tL9d+x5rYKHbpbWoWPfNkNtjrQOaQ2s51rjt/9NImCyBypcJWASBuzyCCCAAAIIIIAAAggggAACLQQETFowu8mjCQiY1ETPcJibniF9oP52mCtgUpq1Q4eyieEFaR91vJxJz8BHw02svVYCr77e0v137HmtgodultahY982Q22OtA5pDaznWuO3/00iYLIHKlwlYBIG7PIIIIAAAggggAACCCCAAAItBARMWjC7yaMJCJjURM9wmJueIX2g/naYK2BSmrVDh7KJ4QVpH3W8nEnPwEfDTay9VgKvvt7S/Xfsea2Ch26W1qFj3zZDbY60DmkNrOda47f/TSJgsgcqXCVgEgbs8ggggAACCCCAAAIIIIAAAi0EBExaMLvJowkImNREz3CYm54hfaD+dpgrYFKatUOHsonhBWkfdbycSc/AR8NNrL1WAq++3tL9d+x5rYKHbpbWoWPfNkNtjrQOaQ2s51rjt/9NImCyBypcJWASBuzyCCCAAAIIIIAAAggggAACLQQETFowu8mjCQiY1ETPcJibniF9oP52mCtgUpq1Q4eyieEFaR91vJxJz8BHw02svVYCr77e0v137HmtgodultahY982Q22OtA5pDaznWuO3/00iYLIHKlwlYBIG7PIIIIAAAggggAACCCCAAAItBARMWjC7yaMJCJjURM9wmJueIX2g/naYK2BSmrVDh7KJ4QVpH3W8nEnPwEfDTay9VgKvvt7S/Xfsea2Ch26W1qFj3zZDbY60DmkNrOda47f/TSJgsgcqXCVgEgbs8ggggAACCCCAAAIIIIAAAi0EBExaMLvJowkImNREz3CYm54hfaD+dpgrYFKatUOHsonhBWkfdbycSc/AR8NNrL1WAq++3tL9d+x5rYKHbpbWoWPfNkNtjrQOaQ2s51rjt/9NImCyBypcJWASBuzyCCCAAAIIIIAAAggggAACLQQETFowu8mjCQiY1ETPcJibniF9oP52mCtgUpq1Q4eyieEFaR91vJxJz8BHw02svVYCr77e0v137HmtgodultahY982Q22OtA5pDaznWuO3/00iYLIHKlwlYBIG7PIIIIAAAggggAACCCCAAAItBARMWjC7yaMJCJjURM9wmJueIX2g/naYK2BSmrVDh7KJ4QVpH3W8nEnPwEfDTay9VgKvvt7S/Xfsea2Ch26W1qFj3zZDbY60DmkNrOda47f/TSJgsgcqXCVgEgbs8ggggAACCCCAAAIIIIAAAi0EBExaMLvJowkImNREz3CYm54hfaD+dpgrYFKatUOHsonhBWkfdbycSc/AR8NNrL1WAq++3tL9d+x5rYKHbpbWoWPfNkNtjrQOaQ2s51rjt/9NImCyBypcJWASBuzyCCCAAAIIIIAAAggggAACLQQETFowu8mjCQiY1EQ7DnPrLmZXpA/U3w5zwwGT2YT3uuvQYa+TuVV8VGvDRzUjFdchYM+otbZn1Iz4qGbU4SM6zNCh7mJ2hYDJDH0ETGbooAsEEEAAAQQQQAABBBBAAIH7CAiY3MfPp59EQMCkBu8wumbkpUDNqKOiQ4eOOZL3sJ5runxUM1JxHQL2jFpre0bNiI9qRh0+osMMHeouZlcImMzQR8Bkhg66QAABBBBAAAEEEEAAAQQQuI+AgMl9/Hz6SQQETGrwDqNrRl4K1Iw6Kjp06JgjeQ/ruabLRzUjFdchYM+otbZn1Iz4qGbU4SM6zNCh7mJ2hYDJDH0ETGbooAsEEEAAAQQQQAABBBBAAIH7CAiY3MfPp59EQMCkBu8wumbkpUDNqKOiQ4eOOZL3sJ5runxUM1JxHQL2jFpre0bNiI9qRh0+osMMHeouZlcImMzQR8Bkhg66QAABBBBAAAEEEEAAAQQQuI+AgMl9/Hz6SQQETGrwDqNrRl4K1Iw6Kjp06JgjeQ/ruabLRzUjFdchYM+otbZn1Iz4qGbU4SM6zNCh7mJ2hYDJDH0ETGbooAsEEEAAAQQQQAABBBBAAIH7CAiY3MfPp59EQMCkBu8wumbkpUDNqKOiQ4eOOZL3sJ5runxUM1JxHQL2jFpre0bNiI9qRh0+osMMHeouZlcImMzQR8Bkhg66QAABBBBAAAEEEEAAAQQQuI+AgMl9/Hz6SQQETGrwDqNrRl4K1Iw6Kjp06JgjeQ/ruabLRzUjFdchYM+otbZn1Iz4qGbU4SM6zNCh7mJ2hYDJDH0ETGbooAsEEEAAAQQQQAABBBBAAIH7CAiY3MfPp59EQMCkBu8wumbkpUDNqKOiQ4eOOZL3sJ5runxUM1JxHQL2jFpre0bNiI9qRh0+osMMHeouZlcImMzQR8Bkhg66QAABBBBAAAEEEEAAAQQQuI+AgMl9/Hz6SQQETGrwDqNrRl4K1Iw6Kjp06JgjeQ/ruabLRzUjFdchYM+otbZn1Iz4qGbU4SM6zNCh7mJ2hYDJDH0ETGbooAsEEEAAAQQQQAABBBBAAIH7CAiY3MfPp59EQMCkBu8wumbkpUDNqKOiQ4eOOZL3sJ5runxUM1JxHQL2jFpre0bNiI9qRh0+osMMHeouZlcImMzQR8Bkhg66QAABBBBAAAEEEEAAAQQQuI+AgMl9/Hz6SQQETGrwDqNrRl4K1Iw6Kjp06JgjeQ/ruabLRzUjFdchYM+otbZn1Iz4qGbU4SM6zNCh7mJ2hYDJDH0ETGbooAsEEEAAAQQQQAABBBBAAIH7CAiY3MfPp59EQMCkBu8wumbkpUDNqKOiQ4eOOZL3sJ5runxUM1JxHQL2jFpre0bNiI9qRh0+osMMHeouZlcImMzQR8Bkhg66QAABBBBAAAEEEEAAAQQQuI+AgMl9/Hz6SQQETGrwDqNrRl4K1Iw6Kjp06JgjeQ/ruabLRzUjFdchYM+otbZn1Iz4qGbU4SM6zNCh7mJ2hYDJDH3OEDBJHyL+9re/jYv16jOk+18CpHUwQ23ztAarg7QOZqh1TmtgPdcadFTQeY9yes9I65Du3759DR/Zt/d0tp5rTmfYk3755Zdf6kl7K8Y11Dv+Oe4mYFLr6DC6ZuSlQM2oo6JDh445kvewnmu6fFQzUnEdAvaMWmt7Rs2Ij2pGHT6iwwwd6i5mVwiYzNBHwKTW4QwHoekZ0gfqXmzUPvWSb49Rei2cQQfreY6X9jr5WhWd97il94y0Dun+z7DnnWGGtI/8Hra3X6R1sJ5n6CBgsqeDqoMEBExqYA6ja0ZeCtSMOio6dOiYI3kP67mmy0c1IxXXIWDPqLW2Z9SM+Khm1OEjOszQoe5idoWAyQx9BExqHRzm1ozSB+pebNQanOEFmRn2dE7vSdbzDB32uvh6FZ332L36ekv3b9++ho/8Hranc3pftZ5n6CBgsqeDqoMEBExqYA6ja0ZeCtSMOio6dOiYI3kP67mmy0c1IxXXIWDPqLW2Z9SM+Khm1OEjOszQoe5idoWAyQx9BExqHRzm1ozSB+pebNQaeMm3x8h6rjlZzzWjjj1pr4uvV9F5j116z0jrkO7fs+caPurY89Jr4QwzWM976y3tJQGTPR1UHSQgYFIDcxhdM/JSoGbUUdGhQ8ccyXtYzzVdPqoZqbgOAXtGrbU9o2bERzWjDh/RYYYOdRezKwRMZugjYFLr4DC3ZpQ+yD3DS4EzzGAt1GvhDC9brec9nTvWw14nX6ui8x63tM5pHdL9n2HPO8MMaR+d4XeYM8xgPe/t2+n1IGCyp4OqgwQETGpgDqNrRl4K1Iw6Kjp06JgjeQ/ruabLRzUjFdchYM+otbZn1Iz4qGbU4SM6zNCh7mJ2hYDJDH0ETGodHObWjNIHuWd4KXCGGayFei14UbnHKO2lM+xJeyS/XnUGRmao9U+vtTPseWeYwVqo14Lfw/YYpb10hj1JwGTPS6oOEhAwqYE5jK4ZeSlQM+qo6NChY47kPaznmi4f1YxUXIeAPaPW2p5RM+KjmlGHj+gwQ4e6i9kVAiYz9BEwqXU4w0Foeob0YfQZXgqcYYa0j87wku8MM1jP9XOhYz3vdfH1KjrvsUvve2kd0v2fYc87wwxpH3XseWao9yTruWbUsZ4FTPZ0UHWQgIBJDcxhdM3IS4GaUUdFhw4dcyTvYT3XdPmoZqTiOgTsGbXW9oyaER/VjDp8RIcZOtRdzK4QMJmhj4BJrYPD3JqRlwI1ozO8nLEW9nROr4e0Dun+z7AWOmbYc9vXq+i8x+7V11u6/46XuWaovWo914w69u20DtbCns5pHQRM9nRQdZCAgEkNzGF0zchLgZpRR0WHDh1zJO9hPdd0+ahmpOI6BOwZtdb2jJoRH9WMOnxEhxk61F3MrhAwmaGPgEmtg8PcmlH6IPcMLwXOMIO1UK+FM7xstZ73dO5YD3udfK2Kznvc0jqndUj3f4Y97wwzpH10ht9hzjCD9by3b6fXg4DJng6qDhIQMKmBOYyuGXkpUDPqqOjQoWOO5D2s55ouH9WMVFyHgD2j1tqeUTPio5pRh4/oMEOHuovZFQImM/QRMKl1cJhbM0of5J7hpcAZZrAW6rXgReUeo7SXzrAn7ZH8etUZGJmh1j+91s6w551hBmuhXgt+D9tjlPbSGfYkAZM9L6k6SEDApAbmMLpm5KVAzaijokOHjjmS97Cea7p8VDNScR0C9oxaa3tGzYiPakYdPqLDDB3qLmZXCJjM0EfApNbhDAeh6RnSh9FneClwhhnSPjrDS74zzGA918+FjvW818XXq+i8xy6976V1SPd/hj3vDDOkfdSx55mh3pOs55pRx3oWMNnTQdVBAgImNTCH0TUjLwVqRh0VHTp0zJG8h/Vc0+WjmpGK6xCwZ9Ra2zNqRnxUM+rwER1m6FB3MbtCwGSGPgImtQ4Oc2tGXgrUjM7wcsZa2NM5vR7SOqT7P8Na6Jhhz21fr6LzHrtXX2/p/jte5pqh9qr1XDPq2LfTOlgLezqndRAw2dNB1UECAiY1MIfRNSMvBWpGHRUdOnTMkbyH9VzT5aOakYrrELBn1FrbM2pGfFQz6vARHWboUHcxu0LAZIY+ZwiYzCCpCwQQQAABBBBAAAEEEEAAgWcSEDB5Jn33/jIBAZMancPompGXAjWjjooOHTrmSN7Deq7p8lHNSMV1CNgzaq3tGTUjPqoZdfiIDjN0qLuYXSFgMkMfAZMZOugCAQQQQAABBBBAAAEEEEDgPgICJvfx8+knERAwqcE7jK4ZeSlQM+qo6NChY47kPaznmi4f1YxUXIeAPaPW2p5RM+KjmlGHj+gwQ4e6i9kVAiYz9BEwmaGDLhBAAAEEEEAAAQQQQAABBO4jIGByHz+ffhIBAZMavMPompGXAjWjjooOHTrmSN7Deq7p8lHNSMV1CNgzaq3tGTUjPqoZdfiIDjN0qLuYXSFgMkMfAZMZOugCAQQQQAABBBBAAAEEEEDgPgICJvfx8+knERAwqcE7jK4ZeSlQM+qo6NChY47kPaznmi4f1YxUXIeAPaPW2p5RM+KjmlGHj+gwQ4e6i9kVAiYz9BEwmaGDLhBAAAEEEEAAAQQQQAABBO4jIGByHz+ffhIBAZMavMPompGXAjWjjooOHTrmSN7Deq7p8lHNSMV1CNgzaq3tGTUjPqoZdfiIDjN0qLuYXSFgMkMfAZMZOugCAQQQQAABBBBAAAEEEEDgPgICJvfx8+knERAwqcE7jK4ZeSlQM+qo6NChY47kPaznmi4f1YxUXIeAPaPW2p5RM+KjmlGHj+gwQ4e6i9kVAiYz9BEwmaGDLhBAAAEEEEAAAQQQQAABBO4jIGByHz+ffhaBX/07f/qsW7vveQh4KXAeLU2CAAIIIIAAAgh0E/C7ZDdx9/sygb/5F3758md98GEEBEwehtKFEEAAAQQQQAABBBBAAAEEnkhAwOSJ8N36DgICJnfA89HvBLwU4AUEEEAAAQQQQACBrxLwu+RXyflcOwEBk3bkH91QwGSEDJpAAAEEEEAAAQQQQAABBBC4k4CAyZ0AffxJBARMngT+XLf1UuBcepoGAQQQQAABBBDoJOB3yU7a7nUXAQGTu/A96sMCJo8i6ToIIIAAAggggAACCCCAAALPJCBg8kz67v11AgImX2fnk3+LgJcCzIAAAggggAACCCDwVQJ+l/wqOZ9rJyBg0o78oxsKmIyQQRMIIIAAAggggAACCCCAAAJ3EhAwuROgjz+JgIDJk8Cf67ZeCpxLT9MggAACCCCAAAKdBPwu2Unbve4iIGByF75HfVjA5FEkXQcBBBBAAAEEEEAAAQQQQOCZBARMnknfvb9OQMDk6+x88m8R8FKAGRBAAAEEEEAAAQS+SsDvkl8l53PtBARM2pF/dEMBkxEyaAIBBBBAAAEEEEAAAQQQQOBOAgImdwL08ScREDB5Evhz3dZLgXPpaRoEEHg8gb/+Z/7K4y/67oq//v1votd3cQQQQCBJwO+SSbqu/VACAiYPxfnViwmYfJWczyGAAAIIIIAAAggggAACCEwiIGAySQ297BMQMNlnpfKnBLwUYA4EEEDgcwICJhyCAAII/JyA3yW542UICJiMkErAZIQMmkAAAQQQQAABBBBAAAEEELiTgIDJnQB9/EkEBEyeBP5ct/VS4Fx6mgYBBB5PQMDk8UxdEQEEzkPA75Ln0fL0kwiYjJBYwGSEDJpAAAEEEEAAAQQQQAABBBC4k4CAyZ0AffxJBARMngT+XLf1UuBcepoGAQQeT0DA5PFMXREBBM5DwO+S59Hy9JMImIyQWMBkhAyaQAABBBBAAAEEEEAAAQQQuJOAgMmdAH38SQQETJ4E/ly39VLgXHqaBgEEHk9AwOTxTF0RAQTOQ8DvkufR8vSTCJiMkFjAZIQMmkAAAQQQQAABBBBAAAEEELiTgIDJnQB9/EkEBEyeBP5ct/VS4Fx6mgYBBB5PQMDk8UxdEQEEzkPA75Ln0fL0kwiYjJBYwGSEDJpAAAEEEEAAAQQQQAABBBC4k4CAyZ0AffxJBARMngT+XLf1UuBcepoGAQS+TiAdJDna2a9//5ujH1GPAAIItBPwu2Q7cjf8KgEBk6+Se+jnBEweitPFEEAAAQQQQAABBBBAAAEEnkRAwORJ4N32TgICJncC9PFFwEsBPkAAAQT+QEDAhBMQQACB4wT8LnmcmU88iYCAyZPA//eF52IAACAASURBVO23FTAZIYMmEEAAAQQQQAABBBBAAAEE7iQgYHInQB9/EgEBkyeBP9dtvRQ4l56mQQCBrxMQMPk6O59EAIHrEvC75HW1f7nJBUxGSCZgMkIGTSCAAAIIIIAAAggggAACCNxJQMDkToA+/iQCAiZPAn+u23opcC49TYMAAl8nIGDydXY+iQAC1yXgd8nrav9ykwuYjJBMwGSEDJpAAAEEEEAAAQQQQAABBBC4k4CAyZ0AffxJBARMngT+XLf1UuBcepoGAQS+TkDA5OvsfBIBBK5LwO+S19X+5SYXMBkhmYDJCBk0gQACCCCAAAIIIIAAAgggcCcBAZM7Afr4kwgImDwJ/Llu66XAufQ0DQIIfJ2AgMnX2fkkAghcl4DfJa+r/ctNLmAyQjIBkxEyaAIBBBBAAAEEEEAAAQQQQOBOAgImdwL08ScREDB5Evhz3dZLgXPpaRoEEKgJ/CxI8uvf/6b+8LuK9HV+1szRPg8NpRgBBBA4SMDvkgeBKX8eAQGT57F/d2cBkxEyaAIBBBBAAAEEEEAAAQQQQOBOAgImdwL08ScREDB5Evhz3dZLgXPpaRoEEKgJpIMhRwMgR7855ej1ayIqEEAAga8T8Lvk19n5ZDMBAZNm4B/fTsBkhAyaQAABBBBAAAEEEEAAAQQQuJOAgMmdAH38SQQETJ4E/ly39VLgXHqaBgEEagICJjUjFQgggMAuAb9L7pJS93QCAiZPl2A1IGAyQgZNIIAAAggggAACCCCAAAII3ElAwOROgD7+JAICJk8Cf67beilwLj1NgwACNQEBk5qRCgQQQGCXgN8ld0mpezoBAZOnS7AaEDAZIYMmEEAAAQQQQAABBBBAAAEE7iQgYHInQB9/EgEBkyeBP9dtvRQ4l56mQQCBmoCASc1IBQIIILBLwO+Su6TUPZ2AgMnTJVgNCJiMkEETCCCAAAIIIIAAAggggAACdxIQMLkToI8/iYCAyZPAn+u2XgqcS0/TIIBATUDApGakAgEEENgl4HfJXVLqnk5AwOTpEqwGBExGyKAJBBBAAAEEEEAAAQQQQACBOwkImNwJ0MefREDA5Engz3VbLwXOpadpEECgJvCzgMnPPvnr3//mw/807Tr15CoQQACBxxPwu+TjmbpiiICASQjsscsKmBzjpRoBBBBAAAEEEEAAAQQQQGAmAQGTmbroqiIgYFIR8t83CHgpsAFJCQIInIrAtGDIo/o5lUiGQQCBlyHgd8mXkUqjAiYjPCBgMkIGTSCAAAIIIIAAAggggAACCNxJQMDkToA+/iQCAiZPAn+u23opcC49TYMAAjWBRwU6pl2nnlwFAggg8HgCfpd8PFNXDBEQMAmBPXZZAZNjvFQjgAACCCCAAAIIIIAAAgjMJCBgMlMXXVUEBEwqQv77BgEvBTYgKUEAgVMRmBYMeVQ/pxLJMAgg8DIE/C75MlJpVMBkhAcETEbIoAkEEEAAAQQQQAABBBBAAIE7CQiY3AnQx59EQMDkSeDPdVsvBc6lp2kQQKAm8KhAx7Tr1JOrQAABBB5PwO+Sj2fqiiECAiYhsMcuK2ByjJdqBBBAAAEEEEAAAQQQQACBmQQETGbqoquKgIBJRch/3yDgpcAGJCUIIHAqAtOCIY/q51QiGQYBBF6GgN8lX0YqjQqYjPCAgMkIGTSBAAIIIIAAAggggAACCCBwJwEBkzsB+viTCJwgYJI+kP7Vn/xRXJxXnyHd/xIgrYMZapunNVgdpHUwQ61zWoOzrOe/+Tf+xocwf/3739SQ31X8LBjyqOv8rJlf/fEfH+rzK8Xp9cartSppDezbtQZn2fPSXrKeay+lNTjLeq5J3lkhYHInwMd8PB0weUyXz73Kb3/72+c28AJ3Tx/kLgR0qI3QoUPdxewKPqr14aOakYrrELBn1FrbM2pGfFQz6vARHWboUHcxu+KXX375ZVqH4xqaBugl+hEwKWVymFsiiocCvJypNTjLS4H0CybrufZSWoOzrGcBk9pL6fXGq8/XwLOn1uAse571XGud3pPSGpxlPddK3VkhYHInwMd8XMCk5ugwumbkpUDNqKOiQ4eOOZL3sJ5runxUM1JxHQL2jFpre0bNiI9qRh0+osMMHeouZlcImMzW53W7EzAptXOYWyISMKkRvVWkveTFRi1EWoMzvJxJ++gMa+FNZ99gUi649Hrj1VKC+HPnDHveGWawFuq1cIZnT3pPPcNa2HPCnVUCJncCfMzHBUxqjg6ja0ZeCtSMOio6dOiYI3kP67mmy0c1IxXXIWDPqLW2Z9SM+Khm1OEjOszQoe5idoWAyWx9Xrc7AZNSO4e5JSIBkxrRW0XaS+kXTOn+z/Ji49V1SPd/hrXw5lUBk3LnS+8ZvFpKEH/u2LdrDc6y51nPtdbpPSmtwVnWc63UnRUCJncCfMzHBUxqjg6ja0ZeCtSMOio6dOiYI3kP67mmy0c1IxXXIWDPqLW2Z9SM+Khm1OEjOszQoe5idoWAyWx9Xrc7AZNSO4e5JSIBkxrRW0XaS15s1EKkNTjDy5m0j86wFt50FjApF1x6vfFqKUH8uXOGPe8MM1gL9Vo4w7MnvaeeYS3sOeHOKgGTOwE+5uMCJjVHh9E1Iy8FakYdFR06dMyRvIf1XNPlo5qRiusQsGfUWtszakZ8VDPq8BEdZuhQdzG7QsBktj6v252ASamdw9wSkYBJjeitIu2l9AumdP9nebHx6jqk+z/DWnjzqoBJufOl9wxeLSWIP3fs27UGZ9nzrOda6/SelNbgLOu5VurOCgGTOwE+5uMCJjVHh9E1Iy8FakYdFR06dMyRvIf1XNPlo5qRiusQsGfUWtszakZ8VDPq8BEdZuhQdzG7QsBktj6v252ASamdw9wSkYBJjeitIu0lLzZqIdIanOHlTNpHZ1gLbzoLmJQLLr3eeLWUIP7cOcOed4YZrIV6LZzh2ZPeU8+wFvaccGeVgMmdAB/zcQGTmqPD6JqRlwI1o46KDh065kjew3qu6fJRzUjFdQjYM2qt7Rk1Iz6qGXX4iA4zdKi7mF0hYDJbn9ftTsCk1M5hbolIwKRG9FaR9lL6BVO6/7O82Hh1HdL9n2EtvHn1JwGTze3g6WW/+uM/jveQ3jN4tZYwrYF9u9bgLHte2kvWc+2ltAZnWc81yTsrBEzuBPiYjwuY1BwdRteMvBSoGXVUdOjQMUfyHtZzTZePakYqrkPAnlFrbc+oGfFRzajDR3SYoUPdxewKAZPZ+rxudwImpXYOc0tEAiY1oreKtJfSL2fS/Z/lxcar65Du/wxr4c2rAiblzpfeM3i1lCD+3LFv1xqcZc+znmut03tSWoOzrOdaqTsrBEzuBPiYjwuY1BwdRteMvBSoGXVUdOjQMUfyHtZzTZePakYqrkPAnlFrbc+oGfFRzajDR3SYoUPdxewKAZPZ+rxudwImpXYOc0tEAiY1oreKtJe82KiFSGtwhpczaR+dYS286SxgUi649Hrj1VKC+HPnDHveGWawFuq1cIZnT3pPPcNa2HPCnVUCJncCfMzHBUxqjg6ja0ZeCtSMOio6dOiYI3kP67mmy0c1IxXXIWDPqLW2Z9SM+Khm1OEjOszQoe5idoWAyWx9Xrc7AZNSO4e5JSIBkxrRW0XaS+kXTOn+z/Ji49V1SPd/hrXw5lUBk3LnS+8ZvFpKEH/u2LdrDc6y51nPtdbpPSmtwVnWc63UnRUCJncCfMzHBUxqjg6ja0ZeCtSMOio6dOiYI3kP67mmy0c1IxXXIWDPqLW2Z9SM+Khm1OEjOszQoe5idoWAyWx9Xrc7AZNSO4e5JSIBkxrRW0XaS15s1EKkNTjDy5m0j86wFt50FjApF1x6vfFqKUH8uXOGPe8MM1gL9Vo4w7MnvaeeYS3sOeHOKgGTOwE+5uMCJjVHh9E1Iy8FakYdFR06dMyRvIf1XNPlo5qRiusQsGfUWtszakZ8VDPq8BEdZuhQdzG7QsBktj6v252ASamdw9wSkYBJjeitIu2l9AumdP9nebHx6jqk+z/DWnjzqoBJufOl9wxeLSWIP3fs27UGZ9nzrOda6/SelNbgLOu5VurOCgGTOwE+5uMCJjVHh9E1Iy8FakYdFR06dMyRvIf1XNPlo5qRiusQsGfUWtszakZ8VDPq8BEdZuhQdzG7QsBktj6v290JAiavC/88nacP1DtezpxHDZMggEAHgb/+Z/5Kx21i9/j1738Tu7YLI4AAAkcJ+F3yKDH1TyMgYPI09O9vLGBSy+AwumbkpUDNqKOiQ4eOOZL3sJ5runxUM1JxHQL2jFpre0bNiI9qRh0+osMMHeouZlcImMzW53W7EzB5Xe0Gde6lwCAxtIIAAi0EBExaMLsJAghchIDfJS8i9BnGFDAZoaKASS2Dw+iakZcCNaOOig4dOuZI3sN6runyUc1IxXUI2DNqre0ZNSM+qhl1+IgOM3Sou5hdIWAyW5/X7U7A5HW1G9S5lwKDxNAKAgi0EBAwacHsJgggcBECfpe8iNBnGFPAZISKAia1DA6ja0ZeCtSMOio6dOiYI3kP67mmy0c1IxXXIWDPqLW2Z9SM+Khm1OEjOszQoe5idoWAyWx9Xrc7AZPX1W5Q514KDBJDKwgg0EJAwKQFs5sggMBFCPhd8iJCn2FMAZMRKgqY1DI4jK4ZeSlQM+qo6NChY47kPaznmi4f1YxUXIeAPaPW2p5RM+KjmlGHj+gwQ4e6i9kVAiaz9Xnd7gRMXle7QZ17KTBIDK0ggEALAQGTFsxuggACFyHgd8mLCH2GMQVMRqgoYFLL4DC6ZuSlQM2oo6JDh445kvewnmu6fFQzUnEdAvaMWmt7Rs2Ij2pGHT6iwwwd6i5mVwiYzNbndbsTMHld7QZ17qXAIDG0ggACLQQETFowuwkCCFyEgN8lLyL0GcYUMBmhooBJLYPD6JqRlwI1o46KDh065kjew3qu6fJRzUjFdQjYM2qt7Rk1Iz6qGXX4iA4zdKi7mF0hYDJbn9ftTsDkdbUb1LmXAoPE0AoCCLQQEDBpwewmCCBwEQJ+l7yI0GcYU8BkhIoCJrUMDqNrRl4K1Iw6Kjp06JgjeQ/ruabLRzUjFdchYM+otbZn1Iz4qGbU4SM6zNCh7mJ2hYDJbH1etzsBk9fVblDnXgoMEkMrCCDQQkDApAWzmyCAwEUI+F3yIkKfYUwBkxEqCpjUMjiMrhl5KVAz6qjo0KFjjuQ9rOeaLh/VjFRch4A9o9banlEz4qOaUYeP6DBDh7qL2RUCJrP1ed3uBExeV7tBnXspMEgMrSCAQAsBAZMWzG6CAAIXIeB3yYsIfYYxBUxGqChgUsvgMLpm5KVAzaijokOHjjmS97Cea7p8VDNScR0C9oxaa3tGzYiPakYdPqLDDB3qLmZXCJjM1ud1uxMweV3tBnXupcAgMbSCAAItBARMWjC7CQIIXISA3yUvIvQZxhQwGaGigEktg8PompGXAjWjjooOHTrmSN7Deq7p8lHNSMV1CNgzaq3tGTUjPqoZdfiIDjN0qLuYXSFgMluf1+1OwOR1tRvUuZcCg8TQCgIItBAQMGnB7CYIIHARAn6XvIjQZxhTwGSEigImtQwOo2tGXgrUjDoqOnTomCN5D+u5pstHNSMV1yFgz6i1tmfUjPioZtThIzrM0KHuYnaFgMlsfV63OwGT19VuUOdeCgwSQysIINBCQMCkBbObIIDARQj4XfIiQp9hTAGTESoKmNQydBxGpw/V0zOk+18qmaH2aocOdRezK9I+WtOndUjPkO5/tkN0h8DfTuDV11u6/4497wyeTOvQsW+boXZiWoe0BtZzrfGqEDDZ46TqKAEBk6PE1H9AwEsBtkAAgasREDC5muLmRQCBJAG/SybpuvZDCQiYPBTnVy8mYFKTO8NhbnqG9IH6UskMtVc7dKi7mF2R9lHHy5n0DHw028O66yXw6ust3X/HntereOZuaR069m0z1N5I65DWwHquNV4VAiZ7nFQdJSBgcpSY+g8IeCnAFgggcDUCAiZXU9y8CCCQJOB3ySRd134oAQGTh+L86sUETGpyZzjMTc+QPlBfKpmh9mqHDnUXsyvSPup4OZOegY9me1h3vQRefb2l++/Y83oVz9wtrUPHvm2G2htpHdIaWM+1xqtCwGSPk6qjBARMjhJT/wEBLwXYAgEErkZAwORqipsXAQSSBPwumaTr2g8lIGDyUJxfvZiASU3uDIe56RnSB+pLJTPUXu3Qoe5idkXaRx0vZ9Iz8NFsD+uul8Crr7d0/x17Xq/imbuldejYt81QeyOtQ1oD67nWeFUImOxxUnWUgIDJUWLqPyDgpQBbIIDA1QgImFxNcfMigECSgN8lk3Rd+6EEBEweivOrFxMwqcmd4TA3PUP6QH2pZIbaqx061F3Mrkj7qOPlTHoGPprtYd31Enj19Zbuv2PP61U8c7e0Dh37thlqb6R1SGtgPdcarwoBkz1Oqo4SEDA5Skz9BwS8FGALBBC4GgEBk6spbl4EEEgS8Ltkkq5rP5SAgMlDcX71YgImNbkzHOamZ0gfqC+VzFB7tUOHuovZFWkfdbycSc/AR7M9rLteAq++3tL9d+x5vYpn7pbWoWPfNkPtjbQOaQ2s51rjVSFgssdJ1VECAiZHian/gICXAmyBAAJXIyBgcjXFzYsAAkkCfpdM0nXthxIQMHkozq9eTMCkJneGw9z0DOkD9aWSGWqvduhQdzG7Iu2jjpcz6Rn4aLaHdddL4NXXW7r/jj2vV/HM3dI6dOzbZqi9kdYhrYH1XGu8KgRM9jipOkpAwOQoMfUfEPBSgC0QQACBPxD4WfDk17//zYeIptXTEQEEEHgGAb9LPoO6e36JgIDJl7A9+kMCJjXRMxzmpmdIH6gvlcxQe7VDh7qL2RVpH3W8nEnPwEezPay7XgKvvt7S/Xfseb2KZ+6W1qFj3zZD7Y20DmkNrOda41UhYLLHSdVRAgImR4mp/4CAlwJsgQACCPyBwLTAyNF+6IgAAgg8g4DfJZ9B3T2/REDA5EvYHv0hAZOa6BkOc9MzpA/Ul0pmqL3aoUPdxeyKtI86Xs6kZ+Cj2R7WXS+BV19v6f479rxexTN3S+vQsW+bofZGWoe0BtZzrfGqEDDZ46TqKAEBk6PE1H9AwEsBtkAAAQT+QOBooGNaPR0RQACBZxDwu+QzqLvnlwgImHwJ26M/JGBSEz3DYW56hvSB+lLJDLVXO3Sou5hdkfZRx8uZ9Ax8NNvDuusl8OrrLd1/x57Xq3jmbmkdOvZtM9TeSOuQ1sB6rjVeFQIme5xUHSUgYHKUmPoPCHgpwBYIIIDAHwhMC4wc7YeOCCCAwDMI+F3yGdTd80sEBEy+hO3RHxIwqYme4TA3PUP6QH2pZIbaqx061F3Mrkj7qOPlTHoGPprtYd31Enj19Zbuv2PP61U8c7e0Dh37thlqb6R1SGtgPdcarwoBkz1Oqo4SEDA5Skz9BwS8FGALBBBA4A8EjgY6ptXTEQEEEHgGAb9LPoO6e36JgIDJl7A9+kMCJjXRMxzmpmdIH6gvlcxQe7VDh7qL2RVpH3W8nEnPwEezPay7XgKvvt7S/Xfseb2KZ+6W1qFj3zZD7Y20DmkNrOda41UhYLLHSdVRAgImR4mp/4CAlwJsgQACCPyBwLTAyNF+/n/27hhXmuTI9jxrGQ/gGriD5gqojUKBHLGBllqtJbTaEoESCQqjPG1WML2DWUMDs4x6yMoB7lQNb57IuGF23S1+clmGu/2PmUd85ge36IgAAgh8BwHfkt9B3ZqnCDCYnMJ29Y8YTDLRjmFu3sXaEdUD9Uf2dMg10KFD3sXaEeoo66OOMiMR9yHgzMhaOzMyI3WUGXXUER3W0CHvYu0IBpO19dl3dwwm+2q30M5dCiwkhq0ggAACCCCAAAKbEfAtuZlgd94ug8kS6jOYZBkMozMjlwKZUUdEhw4deVSuoZ8zXXWUGYm4DwFnRtbamZEZqaPMqKOO6LCGDnkXa0cwmKytz767YzDZV7uFdu5SYCExbAUBBBBAAAEEENiMgG/JzQS783YZTJZQn8Eky2AYnRm5FMiMOiI6dOjIo3IN/ZzpqqPMSMR9CDgzstbOjMxIHWVGHXVEhzV0yLtYO4LBZG199t0dg8m+2i20c5cCC4lhKwgggAACCCCAwGYEfEtuJtidt8tgsoT6DCZZBsPozMilQGbUEdGhQ0celWvo50xXHWVGIu5DwJmRtXZmZEbqKDPqqCM6rKFD3sXaEQwma+uz7+4YTPbVbqGduxRYSAxbQQABBBBAAAEENiPgW3Izwe68XQaTJdRnMMkyGEZnRi4FMqOOiA4dOvKoXEM/Z7rqKDMScR8CzoystTMjM1JHmVFHHdFhDR3yLtaOYDBZW599d8dgsq92C+3cpcBCYtgKAggggAACCCCwGQHfkpsJduftMpgsoT6DSZbBMDozcimQGXVEdOjQkUflGvo501VHmZGI+xBwZmStnRmZkTrKjDrqiA5r6JB3sXYEg8na+uy7OwaTfbVbaOcuBRYSw1YQQAABBBBAAIHNCPiW3EywO2+XwWQJ9RlMsgyG0ZmRS4HMqCOiQ4eOPCrX0M+ZrjrKjETch4AzI2vtzMiM1FFm1FFHdFhDh7yLtSMYTNbWZ9vd/fe///vP226+aeO//5//o2mlfZfpuBTYl46dr0RAP2c19HNmJOI+BJwZWWtnRmYkYg0C+jnroJ8zo9//53/+kKNEVBNgMMmEDaMzI5cCmVFHRIcOHXlUrqGfM111lBmJuA8BZ0bW2pmRGamjzKijjuiwhg55F2tHMJisrc+2u2MwydIZRmdGhtGZkYg1COjnrIN+zoxE3IeAMyNr7czIjESsQUA/Zx30c2bEYJIZdUQwmGTKhtGZkUuBzKgjokOHjjwq19DPma46yoxE3IeAMyNr7czIjNRRZtRRR3RYQ4e8i7UjGEzW1mfb3TGYZOkMozMjw+jMSMQaBPRz1kE/Z0Yi7kPAmZG1dmZkRiLWIKCfsw76OTNiMMmMOiIYTDJlw+jMyKVAZtQR0aFDRx6Va+jnTFcdZUYi7kPAmZG1dmZkRuooM+qoIzqsoUPexdoRDCZr67Pt7hhMsnSG0ZmRYXRmJGINAvo566CfMyMR9yHgzMhaOzMyIxFrENDPWQf9nBkxmGRGHREMJpmyYXRm5FIgM+qI6NChI4/KNfRzpquOMiMR9yHgzMhaOzMyI3WUGXXUER3W0CHvYu0IBpO19dl2dwwmWTrD6MzIMDozErEGAf2cddDPmZGI+xBwZmStnRmZkYg1COjnrIN+zowYTDKjjggGk0zZMDozcimQGXVEdOjQkUflGvo501VHmZGI+xBwZmStnRmZkTrKjDrqiA5r6JB3sXYEg8na+my7OwaTLJ1hdGZkGJ0ZiViDgH7OOujnzEjEfQg4M7LWzozMSMQaBPRz1kE/Z0YMJplRRwSDSaZsGJ0ZuRTIjDoiOnToyKNyDf2c6aqjzEjEfQg4M7LWzozMSB1lRh11RIc1dMi7WDuCwWRtfbbdHYNJls4wOjMyjM6MRKxBQD9nHfRzZiTiPgScGVlrZ0ZmJGINAvo566CfMyMGk8yoI4LBJFM2jM6MXApkRh0RHTp05FG5hn7OdNVRZiTiPgScGVlrZ0ZmpI4yo446osMaOuRdrB3BYLK2PtvujsEkS2cYnRkZRmdGItYgoJ+zDvo5MxJxHwLOjKy1MyMzErEGAf2cddDPmRGDSWbUEcFgkikbRmdGLgUyo46IDh068qhcQz9nuuooMxJxHwLOjKy1MyMzUkeZUUcd0WENHfIu1o5gMFlbn213x2CSpTOMzowMozMjEWsQ0M9ZB/2cGYm4DwFnRtbamZEZiViDgH7OOujnzIjBJDPqiGAwyZQNozMjlwKZUUdEhw4deVSuoZ8zXXWUGYm4DwFnRtbamZEZqaPMqKOO6LCGDnkXa0cwmKytz7a7YzDJ0hlGZ0aG0ZmRiDUI6Oesg37OjETch4AzI2vtzMiMRKxBQD9nHfRzZsRgkhl1RDCYZMqG0ZmRS4HMqCOiQ4eOPCrX0M+ZrjrKjETch4AzI2vtzMiM1FFm1FFHdFhDh7yLtSMYTNbWZ9vdMZhk6QyjMyPD6MxIxBoE9HPWQT9nRiLuQ8CZkbV2ZmRGItYgoJ+zDvo5M2IwyYw6IhhMMmXD6MzIpUBm1BHRoUNHHpVr6OdMVx1lRiLuQ8CZkbV2ZmRG6igz6qgjOqyhQ97F2hEMJmvrs+3uGEyydIbRmZFhdGYkYg0C+jnroJ8zIxH3IeDMyFo7MzIjEWsQ0M9ZB/2cGTGYZEYdEQwmmbJhdGbkUiAz6ojo0KEjj8o19HOmq44yIxH3IeDMyFo7MzIjdZQZddQRHdbQIe9i7QgGk7X12XZ3DCZZOsPozMgwOjMSsQYB/Zx10M+ZkYj7EHBmZK2dGZmRiDUI6Oesg37OjBhMMqOOCAaTTNkwOjNyKZAZdUR06NCRR+Ua+jnTVUeZkYj7EHBmZK2dGZmROsqMOuqIDmvokHexdgSDydr6bLs7BpMsnWF0ZmQYnRmJWIOAfs466OfMSMR9CDgzstbOjMxIxBoE9HPWQT9nRgwmmVFHBINJpmwYnRm5FMiMOiI6dOjIo3IN/ZzpqqPMSMR9CDgzstbOjMxIHWVGHXVEhzV0yLtYO4LBZG19tt0dg0mWzjA6MzKMzoxErEFAP2cd9HNmJOI+BJwZWWtnRmYkYg0C+jnroJ8zIwaTzKgjgsEkUzaMzoxcCmRGHREdOnTkUbmGfs501VFmJOI+BJwZWWtnRmakjjKjjjqiwxo65F2sHcFgsrY+2+6OwSRLZxidGRlGZ0Yi1iCgn7MO+jkzEnEfAs6MrLUzIzMSsQYB/Zx10M+ZEYNJZtQRwWCSKRtGZ0YuBTKjjogOHTryqFxDP2e66igzEnEfAs6MrLUzIzNSvcvxTwAAIABJREFUR5lRRx3RYQ0d8i7WjmAwWVufbXfHYJKlM4zOjAyjMyMRaxDQz1kH/ZwZibgPAWdG1tqZkRmJWIOAfs466OfMiMEkM+qIYDDJlA2jMyOXAplRR0SHDh15VK6hnzNddZQZibgPAWdG1tqZkRmpo8yoo47osIYOeRdrRzCYrK3PtrtjMMnSGUZnRobRmZGINQjo56yDfs6MRNyHgDMja+3MyIxErEFAP2cd9HNmxGCSGXVEMJhkyobRmZFLgcyoI6JDh448KtfQz5muOsqMRNyHgDMja+3MyIzUUWbUUUd0WEOHvIu1IxhM1tZn290xmGTpDKMzI8PozEjEGgT0c9ZBP2dGIu5DwJmRtXZmZEYi1iCgn7MO+jkzYjDJjDoiGEwyZcPozMilQGbUEdGhQ0celWvo50xXHWVGIu5DwJmRtXZmZEbqKDPqqCM6rKFD3sXaEQwma+uz7e4YTLJ0htGZkWF0ZiRiDQL6OeugnzMjEfch4MzIWjszMiMRaxDQz1kH/ZwZMZhkRh0RDCaZsmF0ZuRSIDPqiOjQoSOPyjX0c6arjjIjEfch4MzIWjszMiN1lBl11BEd1tAh72LtCAaTtfXZdncMJlk6w+jMyDA6MxKxBgH9nHXQz5mRiPsQcGZkrZ0ZmZGINQjo56yDfs6MGEwyo44IBpNM2TA6M3IpkBl1RHTo0JFH5Rr6OdNVR5mRiPsQcGZkrZ0ZmZE6yow66ogOa+iQd7F2BIPJ2vpsuzsGkyydYXRmZBidGYlYg4B+zjro58xIxH0IODOy1s6MzEjEGgT0c9ZBP2dGDCaZUUcEg0mmbBidGbkUyIw6Ijp06Mijcg39nOmqo8xIxH0IODOy1s6MzEgdZUYddUSHNXTIu1g7gsFkbX223R2DSZbOMDozMozOjESsQUA/Zx30c2Yk4j4EnBlZa2dGZiRiDQL6OeugnzMjBpPMqCOCwSRTNozOjFwKZEYdER06dORRuYZ+znTVUWYk4j4EnBlZa2dGZqSOMqOOOqLDGjrkXawdwWCytj7b7o7BJEtnGJ0ZGUZnRiLWIKCfsw76OTMScR8CzoystTMjMxKxBgH9nHXQz5kRg0lm1BHBYJIpG0ZnRi4FMqOOiA4dOvKoXEM/Z7rqKDMScR8CzoystTMjM1JHmVFHHdFhDR3yLtaOYDBZW59td8dgkqUzjM6MDKMzIxFrENDPWQf9nBmJuA8BZ0bW2pmRGYlYg4B+zjro58yIwSQz6ohgMMmUDaMzI5cCmVFHRIcOHXlUrqGfM111lBmJuA8BZ0bW2pmRGamjzKijjuiwhg55F2tHMJisrc+2u2MwydIZRmdGhtGZkYg1COjnrIN+zoxE3IeAMyNr7czIjESsQUA/Zx30c2bEYJIZdUQwmGTKhtGZkUuBzKgjokOHjjwq19DPma46yoxE3IeAMyNr7czIjNRRZtRRR3RYQ4e8i7UjGEzW1mfb3TGYZOkMozMjw+jMSMQaBPRz1kE/Z0Yi7kPAmZG1dmZkRiLWIKCfsw76OTNiMMmMOiIYTDJlw+jMyKVAZtQR0aFDRx6Va+jnTFcdZUYi7kPAmZG1dmZkRuooM+qoIzqsoUPexdoRDCZr67Pt7hhMsnSG0ZmRYXRmJGINAvo566CfMyMR9yHgzMhaOzMyIxFrENDPWQf9nBkxmGRGHREMJpmyYXRm5FIgM+qI6NChI4/KNfRzpquOMiMR9yHgzMhaOzMyI3WUGXXUER3W0CHvYu0IBpO19dl2dwwmWTrD6MzIMDozErEGAf2cddDPmZGI+xBwZmStnRmZkYg1COjnrIN+zowYTDKjjggGk0zZMDozcimQGXVEdOjQkUflGvo501VHmZGI+xBwZmStnRmZkTrKjDrqiA5r6JB3sXYEg8na+my7OwaTLJ1hdGZkGJ0ZiViDgH7OOujnzEjEfQg4M7LWzozMSMQaBPRz1kE/Z0YMJplRRwSDSaZsGJ0ZuRTIjDoiOnToyKNyDf2c6aqjzEjEfQg4M7LWzozMSB1lRh11RIc1dMi7WDuCwWRtfbbdHYNJls4wOjMyjM6MRKxBQD9nHfRzZiTiPgScGVlrZ0ZmJGINAvo566CfMyMGk8yoI+Ivf/nLzx3rWGM2AZcCs/WVHQIIfJ3Av/7rv379IS+e8NNPP5U+38MRQACBSgK+JSvpevaVBP7xj3/8cOXzrnjWchu6Iqm7PYPBJCveMYyuHuZW51C9/6ySCASOEajuhccuqvuhOofq/T8YVedwrBpE7U5gQq1W59DRa9U57F6n9r8Ogep+qO6F6v13fMOsUw3nd8Jgcp7dlb9kMLmS5n2f5VLgvtrLHAEEjhFgMDnGSRQCCNyTgG/Je+q+Y9YMJjuqtsGeGUyySBOGudU5VA/Us0oiEDhGoLoXOi5nqnPo6OfqHI5Vg6jdCUyo1eocOnqtOofd69T+1yFQ3Q/VvVC9/45vmHWq4fxOGEzOs7vylwwmV9K877NcCtxXe5kjgMAxAgwmxziJQgCBexLwLXlP3XfMmsFkR9U22DODSRZpwjC3OofqgXpWSQQCxwhU90LH5Ux1Dh39XJ3DsWoQtTuBCbVanUNHr1XnsHud2v86BKr7oboXqvff8Q2zTjWc3wmDyXl2V/6SweRKmvd9lkuB+2ovcwQQOEaAweQYJ1EIIHBPAr4l76n7jlkzmOyo2gZ7ZjDJIk0Y5lbnUD1QzyqJQOAYgepe6Licqc6ho5+rczhWDaJ2JzChVqtz6Oi16hx2r1P7X4dAdT9U90L1/ju+YdaphvM7YTA5z+7KXzKYXEnzvs9yKXBf7WWOAALHCDCYHOMkCgEE7knAt+Q9dd8xawaTHVXbYM8MJlmkCcPc6hyqB+pZJREIHCNQ3QsdlzPVOXT0c3UOx6pB1O4EJtRqdQ4dvVadw+51av/rEKjuh+peqN5/xzfMOtVwficMJufZXflLBpMrad73WS4F7qu9zBFA4BgBBpNjnEQhgMA9CfiWvKfuO2bNYLKjahvsmcEkizRhmFudQ/VAPaskAoFjBKp7oeNypjqHjn6uzuFYNYjancCEWq3OoaPXqnPYvU7tfx0C1f1Q3QvV++/4hlmnGs7vhMHkPLsrf8lgciXN+z7LpcB9tZc5AggcI8BgcoyTKAQQuCcB35L31H3HrBlMdlRtgz0zmGSRJgxzq3OoHqhnlUQgcIxAdS90XM5U59DRz9U5HKsGUbsTmFCr1Tl09Fp1DrvXqf2vQ6C6H6p7oXr/Hd8w61TD+Z0wmJxnd+UvGUyupHnfZ7kUuK/2MkcAgWMEGEyOcRKFAAL3JOBb8p6675g1g8mOqm2wZwaTLNKEYW51DtUD9aySCASOEajuhY7LmeocOvq5Oodj1SBqdwITarU6h45eq85h9zq1/3UIVPdDdS9U77/jG2adaji/EwaT8+yu/CWDyZU07/sslwL31V7mCCBwjACDyTFOohBA4J4EfEveU/cds2Yw2VG1DfbMYJJFmjDMrc6heqCeVRKBwDEC1b3QcTlTnUNHP1fncKwaRO1OYEKtVufQ0WvVOexep/a/DoHqfqjuher9d3zDrFMN53fCYHKe3ZW/ZDC5kuZ9n+VS4L7ayxwBBI4RYDA5xkkUAgjck4BvyXvqvmPWDCY7qrbBnhlMskgThrnVOVQP1LNKIhA4RqC6FzouZ6pz6Ojn6hyOVYOo3QlMqNXqHDp6rTqH3evU/tchUN0P1b1Qvf+Ob5h1quH8ThhMzrO78pcMJlfSvO+zXArcV3uZI4DAMQIMJsc4iUIAgXsS8C15T913zJrBZEfVNtgzg0kWacIwtzqH6oF6VkkEAscIVPdCx+VMdQ4d/Vydw7FqELU7gQm1Wp1DR69V57B7ndr/OgSq+6G6F6r33/ENs041nN8Jg8l5dlf+ksHkSpr3fZZLgftqL3MEEDhGgMHkGCdRCCBwTwK+Je+p+45ZM5jsqNoGe2YwySJNGOZW51A9UM8qiUDgGIHqXui4nKnOoaOfq3M4Vg2idicwoVarc+joteocdq9T+1+HQHU/VPdC9f47vmHWqYbzO2EwOc/uyl8ymFxJ877PcilwX+1ljsBdCbxrGPnpp59KUa22n9JkPRwBBMYR8C05TtKxCTGYjJX2exNjMMn8O4a5eRdrR1QP1NfO3u52IqCfs1od/UyHrIOITECtZkYdER06dORhjfkEvHuyxvo5M2IwyYw6IhhMOijPX8OlwHyNZYgAAr8msJqhY7X9qBcEEEDgHQK+Jd+hJfY7CTCYfCf9wWszmGRxDaMzI8PozEjEGgT0c9aho5/pkHUQkQmo1cyoI6JDh448rDGfgHdP1lg/Z0YMJplRRwSDSQfl+Wu4FJivsQwRQODXBFYzdKy2H/WCAAIIvEPAt+Q7tMR+JwEGk++kP3htBpMsrmF0ZmQYnRmJWIOAfs46dPQzHbIOIjIBtZoZdUR06NCRhzXmE/DuyRrr58yIwSQz6ohgMOmgPH8NlwLzNZYhAgj8msBqho7V9qNeEEAAgXcI+JZ8h5bY7yTAYPKd9AevzWCSxTWMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRh0RDCYdlOev4VJgvsYyRACBXxNYzdCx2n7UCwIIIPAOAd+S79AS+50EGEy+k/7gtRlMsriG0ZmRYXRmJGINAvo569DRz3TIOojIBNRqZtQR0aFDRx7WmE/AuydrrJ8zIwaTzKgjgsGkg/L8NVwKzNdYhggg8GsCqxk6VtuPekEAAQTeIeBb8h1aYr+TAIPJd9IfvDaDSRbXMDozMozOjESsQUA/Zx06+pkOWQcRmYBazYw6Ijp06MjDGvMJePdkjfVzZsRgkhl1RDCYdFCev4ZLgfkayxABBH5NYDVDx2r7US8IIIDAOwR8S75DS+x3EmAw+U76g9dmMMniGkZnRobRmZGINQjo56xDRz/TIesgIhNQq5lRR0SHDh15WGM+Ae+erLF+zowYTDKjjggGkw7K89dwKTBfYxkigMCvCaxm6FhtP+oFAQQQeIeAb8l3aIn9TgIMJt9Jf/DaDCZZXMPozMgwOjMSsQYB/Zx16OhnOmQdRGQCajUz6ojo0KEjD2vMJ+DdkzXWz5kRg0lm1BHBYNJBef4aLgXmayxDBBD4NYHVDB2r7Ue9IIAAAu8Q8C35Di2x30mAweQ76Q9em8Eki2sYnRkZRmdGItYgoJ+zDh39TIesg4hMQK1mRh0RHTp05GGN+QS8e7LG+jkzYjDJjDoiGEw6KM9fw6XAfI1liAACvyawmqFjtf2oFwQQQOAdAr4l36El9jsJMJh8J/3BazOYZHENozMjw+jMSMQaBPRz1qGjn+mQdRCRCajVzKgjokOHjjysMZ+Ad0/WWD9nRgwmmVFHBINJB+X5a7gUmK+xDBFA4NcEVjN0rLYf9YIAAgi8Q8C35Du0xH4nAQaT76Q/eG0GkyyuYXRmZBidGYlYg4B+zjp09DMdsg4iMgG1mhl1RHTo0JGHNeYT8O7JGuvnzIjBJDPqiGAw6aA8fw2XAvM1liECCPyawGqGjtX2o14QQACBdwj4lnyHltjvJMBg8p30B6/NYJLFNYzOjAyjMyMRaxDQz1mHjn6mQ9ZBRCagVjOjjogOHTrysMZ8At49WWP9nBkxmGRGHRETDCbVA+m//vWv5VLsnkP1/h8CVOsgh1zm1Ro8dlCtgxyyztUaTOnn//qv/8ow/z8RP/3001vx7wa/azD5l3/5l3eXeDu+ut/UapakWgPndtZgyplXXUv6OddStQZT+jmT/FoEg8nX+Pn1JwQYTHJpGEZnRobRmZGINQjo56xDRz/TIesgIhNQq5lRR0SHDh15WGM+Ae+erLF+zowYTDKjjggGk0zZMDczcimQGU24YNILx3Su7odqHar3P6EXHjkwmOR+UKuZUXW/VWvwyFAOWedqHao1mHJu765D9f6n9HPuyK9FMJh8jZ9ff0KAwSSXhmF0ZmQYnRmJWIOAfs46dPQzHbIOIjIBtZoZdUR06NCRhzXmE/DuyRrr58yIwSQz6ohgMMmUDXMzIxcbmdGEyxm9cEzn6n6o1qF6/xN64ZEDg0nuB7WaGVX3W7UGjwzlkHWu1qFagynn9u46VO9/Sj/njvxaBIPJ1/j59ScEGExyaRhGZ0aG0ZmRiDUI6OesQ0c/0yHrICITUKuZUUdEhw4deVhjPgHvnqyxfs6MGEwyo44IBpNM2TA3M3KxkRlNuJzRC8d0ru6Hah2q9z+hFx45MJjkflCrmVF1v1Vr8MhQDlnnah2qNZhybu+uQ/X+p/Rz7sivRTCYfI2fX39CgMEkl4ZhdGZkGJ0ZiViDgH7OOnT0Mx2yDiIyAbWaGXVEdOjQkYc15hPw7ska6+fMiMEkM+qIYDDJlA1zMyMXG5nRhMsZvXBM5+p+qNahev8TeuGRA4NJ7ge1mhlV91u1Bo8M5ZB1rtahWoMp5/buOlTvf0o/5478WgSDydf4+fUnBBhMcmkYRmdGhtGZkYg1COjnrENHP9Mh6yAiE1CrmVFHRIcOHXlYYz4B756ssX7OjBhMMqOOCAaTTNkwNzNysZEZTbic0QvHdK7uh2odqvc/oRceOTCY5H5Qq5lRdb9Va/DIUA5Z52odqjWYcm7vrkP1/qf0c+7Ir0UwmHyNn19/QoDBJJeGYXRmZBidGYlYg4B+zjp09DMdsg4iMgG1mhl1RHTo0JGHNeYT8O7JGuvnzIjBJDPqiGAwyZQNczMjFxuZ0YTLGb1wTOfqfqjWoXr/E3rhkQODSe4HtZoZVfdbtQaPDOWQda7WoVqDKef27jpU739KP+eO/FoEg8nX+Pn1JwQYTHJpGEZnRobRmZGINQjo56xDRz/TIesgIhNQq5lRR0SHDh15WGM+Ae+erLF+zowYTDKjjggGk0zZMDczcrGRGU24nNELx3Su7odqHar3P6EXHjkwmOR+UKuZUXW/VWvwyFAOWedqHao1mHJu765D9f6n9HPuyK9FMJh8jZ9ff0KAwSSXhmF0ZmQYnRmJWIOAfs46dPQzHbIOIjIBtZoZdUR06NCRhzXmE/DuyRrr58yIwSQz6ohgMMmUDXMzIxcbmdGEyxm9cEzn6n6o1qF6/xN64ZEDg0nuB7WaGVX3W7UGjwzlkHWu1qFagynn9u46VO9/Sj/njvxaBIPJ1/j59ScEGExyaRhGZ0aG0ZmRiDUI6OesQ0c/0yHrICITUKuZUUdEhw4deVhjPgHvnqyxfs6MGEwyo44IBpNM2TA3M3KxkRlNuJzRC8d0ru6Hah2q9z+hFx45MJjkflCrmVF1v1Vr8MhQDlnnah2qNZhybu+uQ/X+p/Rz7sivRTCYfI2fX39CgMEkl4ZhdGZkGJ0ZiViDgH7OOnT0Mx2yDiIyAbWaGXVEdOjQkYc15hPw7ska6+fMiMEkM+qIYDDJlA1zMyMXG5nRhMsZvXBM5+p+qNahev8TeuGRA4NJ7ge1mhlV91u1Bo8M5ZB1rtahWoMp5/buOlTvf0o/5478WgSDydf4+fUnBBhMcmkYRmdGhtGZkYg1COjnrENHP9Mh6yAiE1CrmVFHRIcOHXlYYz4B756ssX7OjBhMMqOOCAaTTNkwNzNysZEZTbic0QvHdK7uh2odqvc/oRceOTCY5H5Qq5lRdb9Va/DIUA5Z52odqjWYcm7vrkP1/qf0c+7Ir0UwmHyNn19/QoDBJJeGYXRmZBidGYlYg4B+zjp09DMdsg4iMgG1mhl1RHTo0JGHNeYT8O7JGuvnzIjBJDPqiGAwyZQNczMjFxuZ0YTLGb1wTOfqfqjWoXr/E3rhkQODSe4HtZoZVfdbtQaPDOWQda7WoVqDKef27jpU739KP+eO/FoEg8nX+Pn1JwQYTHJpGEZnRobRmZGINQjo56xDRz/TIesgIhNQq5lRR0SHDh15WGM+Ae+erLF+zowYTDKjjogJBpMOTtZ4TWDCxQaNEUAAgXcI/Ou//us74cvF/vTTT8vtyYYQQOC+BHxL3lf73TJnMNlNsU32y2CShTKMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRh0RDCYdlOev4VJgvsYyRACBXxNgMFERCCCAwHUEfEtex9KTagkwmNTyve3TGUyy9IbRmZFhdGYkYg0C+jnr0NHPdMg6iMgE1Gpm1BHRoUNHHtaYT8C7J2usnzMjBpPMqCOCwaSD8vw1XArM11iGCCDwawIMJioCAQQQuI6Ab8nrWHpSLQEGk1q+t306g0mW3jA6MzKMzoxErEFAP2cdOvqZDlkHEZmAWs2MOiI6dOjIwxrzCXj3ZI31c2bEYJIZdUQwmHRQnr+GS4H5GssQAQR+TYDBREUggAAC1xHwLXkdS0+qJcBgUsv3tk9nMMnSG0ZnRobRmZGINQjo56xDRz/TIesgIhNQq5lRR0SHDh15WGM+Ae+erLF+zowYTDKjjggGkw7K89dwKTBfYxkigMCvCTCYqAgEEEDgOgK+Ja9j6Um1BBhMavne9ukMJll6w+jMyDA6MxKxBgH9nHXo6Gc6ZB1EZAJqNTPqiOjQoSMPa8wn4N2TNdbPmRGDSWbUEcFg0kF5/houBeZrLEMEEPg1AQYTFYEAAghcR8C35HUsPamWAINJLd/7Pv33//Hz7slXD0INo3evEPtHAIF3CFSfqY+9OFffUUTsZwTUqtpAAAEEriVQfa6OeP//948/XEvd084QYDA5Q81vfkvApYCaQACBuxFgMLmb4vJFAIFKAr4lK+l69pUEGEyupOlZHwQYTGI1jBiExiwFIIAAAk8C1ZdLjzWcq6rtCgJq9QqKnoEAAgh8EKg+V0e8/xlMlmgZBpMlZNh+Ey4FtpdQAggg8CYBBpM3gQlHAAEEXhDwLak8diHAYLKLUrvtk8EkKjZiEBqzFIAAAgg8CVRfLj3WcK6qtisIqNUrKHoGAggg8EGg+lwd8f5nMFmiZRhMlpBh+024FNheQgkggMCbBBhM3gQmHAEEEHhBwLek8tiFAIPJLkrttk8Gk6jYiEFozFIAAggg8CRQfbn0WMO5qtquIKBWr6DoGQgggMAHgepzdcT7n8FkiZZhMFlChu034VJgewklgAACbxJgMHkTmHAEEEDgBQHfkspjFwIMJrsotds+GUyiYiMGoTFLAQgggMCTQPXl0mMN56pqu4KAWr2ComcggAACHwSqz9UR738GkyVahsFkCRm234RLge0llAACCLxJgMHkTWDCEUAAgRcEfEsqj10IMJjsotRu+2QwiYqNGITGLAUggAACTwLVl0uPNZyrqu0KAmr1CoqegQACCHwQqD5XR7z/GUyWaBkGkyVk2H4TLgW2l1ACCCDwJgEGkzeBCUcAAQReEPAtqTx2IcBgsotSu+2TwSQqNmIQGrMUgAACCDwJVF8uPdZwrqq2Kwio1SsoegYCCCDwQaD6XB3x/mcwWaJlGEyWkGH7TbgU2F5CCSCAwJsEGEzeBCYcAQQQeEHAt6Ty2IUAg8kuSu22TwaTqNiIQWjMUgACCCDwJFB9ufRYw7mq2q4goFavoOgZCCCAwAeB6nN1xPufwWSJlmEwWUKG7TfhUmB7CSWAAAJvEmAweROYcAQQQOAFAd+SymMXAgwmuyi12z4ZTKJiIwahMUsBCCCAwJNA9eXSYw3nqmq7goBavYKiZyCAAAIfBKrP1RHvfwaTJVqGwWQJGbbfhEuB7SWUAAIIvEmAweRNYMIRQACBFwR8SyqPXQgwmOyi1G77ZDCJio0YhMYsBSCAAAJPAtWXS481nKuq7QoCavUKip6BAAIIfBCoPldHvP8ZTJZoGQaTJWTYfhMuBbaXUAIIIPAmAQaTN4EJRwABBF4Q8C2pPHYhwGCyi1K77ZPBJCo2YhAasxSAAAIIPAlUXy491nCuqrYrCKjVKyh6BgIIIPBBoPpcHfH+ZzBZomUYTJaQYftNuBTYXkIJIIDAmwQYTN4EJhwBBBB4QcC3pPLYhQCDyS5K7bZPBpOo2IhBaMxSAAIIIPAkUH259FjDuarariCgVq+g6BkIIIDAB4Hqc3XE+5/BZImWYTBZQobtN+FSYHsJJYAAAm8SYDB5E5hwBBBA4AUB35LKYxcCDCa7KLXbPhlMomIjBqExSwEIIIDAk0D15dJjDeeqaruCgFq9gqJnIIAAAh8Eqs/VEe9/BpMlWobBZAkZtt+ES4HtJZQAAgi8SYDB5E1gwhFAAIEXBHxLKo9dCDCY7KLUbvtkMImKjRiExiwFIIAAAk8C1ZdLjzWcq6rtCgJq9QqKnoEAAgh8EKg+V0e8/xlMlmgZBpMlZNh+Ey4FtpdQAggg8CYBBpM3gQlHAAEEXhDwLak8diHAYLKLUrvtk8EkKjZiEBqzFIAAAgg8CVRfLj3WcK6qtisIqNUrKHoGAggg8EGg+lwd8f5nMFmiZRhMlpBh+024FNheQgkggMCbBBhM3gQmHAEEEHhBwLek8tiFAIPJLkrttk8Gk6jYiEFozFIAAggg8CRQfbn0WMO5qtquIKBWr6DoGQgggMAHgepzdcT7n8FkiZZhMFlChu034VJgewklgAACbxJgMHkTmHAEEEDgBQHfkspjFwIMJrsotds+GUyiYiMGoTFLAQgggMCTQPXl0mMN56pqu4KAWr2ComcggAACHwSqz9UR738GkyVahsFkCRm234RLge0llAACCLxJgMHkTWDCEUAAgRcEfEsqj10IMJjsotRu+2QwiYqNGITGLAUggAACTwLVl0uPNZyrqu0KAmr1CoqegQACCHwQqD5XR7z/GUyWaBkGkyVk2H4TLgW2l1ACCCDwJgEGkzeBCUcAAQReEPAtqTx2IcBgsotSu+2TwSQqNmIQGrMUgAACCDwJVF8uPdZwrqq2Kwio1SsoegYCCCDwQaD6XB3x/me+tgoHAAAgAElEQVQwWaJlGEyWkGH7TbgU2F5CCSCAAAIIIIAAAt9GwLfkt6G38JsEGEzeBCb8IAEGkwhqxCA0ZikAAQQQeBKovlx6rOFcVW1XEFCrV1D0DAQQQOCDQPW5OuL9z2CyRMswmCwhw/abcCmwvYQSQAABBBBAAAEEvo2Ab8lvQ2/hNwkwmLwJTPhBAgwmEdSIQWjMUgACCCDwJFB9ufRYw7mq2q4goFavoOgZCCCAwAeB6nN1xPufwWSJlmEwWUKG7TfhUmB7CSWAAAIIIIAAAgh8GwHfkt+G3sJvEmAweROY8IMEGEwiqBGD0JilAAQQQOBJoPpy6bGGc1W1XUFArV5B0TMQQACBDwLV5+qI9z+DyRItw2CyhAzbb8KlwPYSSgABBBBAAAEEEPg2Ar4lvw29hd8kwGDyJjDhBwkwmERQIwahMUsBCCCAwJNA9eXSYw3nqmq7goBavYKiZyCAAAIfBKrP1RHvfwaTJVqGwWQJGbbfhEuB7SWUAAIIIIAAAggg8G0EfEt+G3oLv0mAweRNYMIPEmAwiaBGDEJjlgIQQACBJ4Hqy6XHGs5V1XYFAbV6BUXPQAABBD4IVJ+rI97/DCZLtAyDyRIybL8JlwLbSygBBBBAAAEEEEDg2wj4lvw29BZ+kwCDyZvAhB8kwGASQY0YhMYsBSCAAAJPAtWXS481nKuq7QoCavUKip6BAAIIfBCoPldHvP8ZTJZoGQaTJWTYfhMuBbaXUAIIIIAAAggggMC3EfAt+W3oLfwmAQaTN4EJP0iAwSSCGjEIjVkKQAABBJ4Eqi+XHms4V1XbFQTU6hUUPQMBBBD4IFB9ro54/zOYLNEyDCZLyLD9JlwKbC+hBBBAAAEEEEAAgW8j4Fvy29Bb+E0CDCZvAhN+kACDSQQ1YhAasxSAAAIIPAlUXy491nCuqrYrCKjVKyh6BgIIIPBBoPpcHfH+ZzBZomUYTJaQYftNuBTYXkIJIIAAAggggAAC30bAt+S3obfwmwQYTN4EJvwgAQaTCGrEIDRmKQABBBB4Eqi+XHqs4VxVbVcQUKtXUPQMBBBA4INA9bk64v3PYLJEyzCYLCHD9ptwKbC9hBJAAAEEEEAAAQS+jYBvyW9Db+E3CTCYvAlM+EECDCYR1IhBaMxSAAIIIPAkUH259FjDuarariCgVq+g6BkIIIDAB4Hqc3XE+5/BZImWYTBZQobtN+FSYHsJJYAAAggggAACCHwbAd+S34bewm8SYDB5E5jwgwQYTCKoEYPQmKUABBBA4Emg+nLpsYZzVbVdQUCtXkHRMxBAAIEPAtXn6oj3P4PJEi3DYLKEDNtvwqXA9hJKAAEEEEAAAQQQ+DYCviW/Db2F3yTAYPImMOEHCTCYRFAjBqExSwEIIIDAk0D15dJjDeeqaruCgFq9gqJnIIAAAh8Eqs/VEe9/BpMlWubnn3/+eYmNLLyJv/71rwvvbo2tdVwKrJGpXexOQD9nBfVzZiTiPgScGVlrZ0ZmJGINAvo566CfM6MffvjhhxzVG7HchnrTH7Iag0kUsmMQuvswt3r/HRfScoit0GIKqNZBP2edqzXo6OecpYgJBCbUanUOzrxjlb67DtX77zi35ZBrVT9nRi0RDCYtmNMiDCaJ0O9+ZxidGRlGZ0Yi1iCgn7MO+jkzEnEfAs6MrLUzIzMSsQYB/Zx10M+ZEYNJZiTiDAEGk0jNMDciGvEXD1xsZJ31Qmb0iKiupWodqvffcVF5TClRuxOYUKvVOVSfFxPOvAk5VNdRx7kth3wi6+fMqCWCwaQFc1qEwSQRYjDJhH73O8PoI5TErEDA5VJWQT9nRiLuQ8CZkbV2ZmRGItYgoJ+zDvo5M2IwyYxEnCHAYBKpGeZGROUX6i42sgYTLsjkcEzn6jNpwiXfMZKidicwoVarc6g+L5zbx7qoWofqOvIddkznah2q62hKPx9T6wtRDCZfgHfdTxlMMkvD6MzIMDozErEGAf2cddDPmZGI+xBwZmStnRmZkYg1COjnrIN+zowYTDIjEWcIMJhEaoa5ERGDSUb0S0R1LbnYyEJUazDhcqa6jjp6IVeCiAkEJtRqdQ7OvGOVvrsO1fvvOLflkGtVP2dGLREMJi2Y0yIMJomQv2CSCfkLJkcYiVmDgMulrIPLpcxIxH0IODOy1s6MzEjEGgT0c9ZBP2dGDCaZkYgzBBhMIjXD3IiIwSQj+iWiupaqL2eq9/9gJIdcTNU6VGvQ0QuZoogJBCbUanUO1eeFc/tYJ1XrUF1HHee2HHItVdfRlH7OJL8YwWDyRYDX/JzBJHM0jM6MDKMzIxFrENDPWQf9nBmJuA8BZ0bW2pmRGYlYg4B+zjro58yIwSQzEnGGAINJpGaYGxGVmwJcbGQNplwKVF8w6edcS9UadPRzzlLEBAITarU6B2fesUrfXYfq/Xec23LItaqfM6OWCAaTFsxpEQaTRMhfMMmE/AWTI4zErEHA5VLWweVSZiTiPgScGVlrZ0ZmJGINAvo566CfMyMGk8xIxBkCDCaRmmFuRMRgkhH9ElFdS9WXM9X7fzCSQy6mah2qNejohUxRxAQCE2q1Oofq88K5fayTqnWorqOOc1sOuZaq62hKP2eSX4xgMPkiwGt+zmCSORpGZ0aG0ZmRiDUI6Oesg37OjETch4AzI2vtzMiMRKxBQD9nHfRzZsRgkhmJOEOAwSRSM8yNiMpNAS42sgZTLgWqL5j0c66lag06+jlnKWICgQm1Wp2DM+9Ype+uQ/X+O85tOeRa1c+ZUUsEg0kL5rQIg0ki5C+YZEL+gskRRmLWIOByKevgcikzEnEfAs6MrLUzIzMSsQYB/Zx10M+ZEYNJZiTiDAEGk0jNMDciYjDJiH6JqK6l6suZ6v0/GMkhF1O1DtUadPRCpihiAoEJtVqdQ/V54dw+1knVOlTXUce5LYdcS9V1NKWfM8kvRjCYfBHgNT9nMMkcDaMzI8PozEjEGgT0c9ZBP2dGIu5DwJmRtXZmZEYi1iCgn7MO+jkzYjDJjEScIcBgEqkZ5kZE5aYAFxtZgymXAtUXTPo511K1Bh39nLMUMYHAhFqtzsGZd6zSd9ehev8d57Yccq3q58yoJYLBpAVzWoTBJBHyF0wyIX/B5AgjMWsQcLmUdXC5lBmJuA8BZ0bW2pmRGYlYg4B+zjro58yIwSQzEnGGAINJpGaYGxExmGREv0RU11L15Uz1/h+M5JCLqVqHag06eiFTFDGBwIRarc6h+rxwbh/rpGodquuo49yWQ66l6jqa0s+Z5BcjGEy+CPCanzOYZI6G0ZmRYXRmJGINAvo566CfMyMR9yHgzMhaOzMyIxFrENDPWQf9nBkxmGRGIs4QYDCJ1AxzI6JyU4CLjazBlEuB6gsm/ZxrqVqDjn7OWYqYQGBCrVbn4Mw7Vum761C9/45zWw65VvVzZtQSwWDSgjktwmCSCPkLJpmQv2ByhJGYNQi4XMo6uFzKjETch4AzI2vtzMiMRKxBQD9nHfRzZsRgkhmJOEOAwSRS6xjmxk0IQAABBJoITLjka0L11jL/5//+f7wV/27wn/7+53d/sn28Wt1eQgkggMBiBKrP1RH/rmIwWaJqGUyyDIbRmZFhdGYkYg0C+jnroJ8zIxH3IeDMyFo7MzIjEWsQ0M9ZB/2cGTGYZEYizhBgMInURgxCY5YCEEAAgSeB6sulxxp3PFcZTK7vMLV6PVNPRACBexOoPldHvP8ZTJZoEgaTLINhdGZkGJ0ZiViDgH7OOujnzEjEfQg4M7LWzozMSMQaBPRz1kE/Z0YMJpmRiDMEGEwitRGD0JilAAQQQOBJoPpy6bHGHc9VBpPrO0ytXs/UExFA4N4Eqs/VEe9/BpMlmoTBJMtgGJ0ZGUZnRiLWIKCfsw76OTMScR8CzoystTMjMxKxBgH9nHXQz5kRg0lmJOIMAQaTSG3EIDRmKQABBBB4Eqi+XHqsccdzlcHk+g5Tq9cz9UQEELg3gepzdcT7n8FkiSZhMMkyGEZnRobRmZGINQjo56yDfs6MRNyHgDMja+3MyIxErEFAP2cd9HNmxGCSGYk4Q4DBJFIbMQiNWQpAAAEEngSqL5cea9zxXGUwub7D1Or1TD0RAQTuTaD6XB3x/mcwWaJJGEyyDIbRmZFhdGYkYg0C+jnroJ8zIxH3IeDMyFo7MzIjEWsQ0M9ZB/2cGTGYZEYizhBgMInURgxCY5YCEEAAgSeB6sulxxp3PFcZTK7vMLV6PVNPRACBexOoPldHvP8ZTJZoEgaTLINhdGZkGJ0ZiViDgH7OOujnzEjEfQg4M7LWzozMSMQaBPRz1kE/Z0YMJpmRiDMEGEwitRGD0JilAAQQQOBJoPpy6bHG5HO12kjybp3+6e9/fvcn28Sr1W2kslEEENiEQPW5OuL9z2CyRDUzmGQZDKMzI8PozEjEGgT0c9ZBP2dGIu5DwJmRtXZmZEYi1iCgn7MO+jkzYjDJjEScIcBgEqmNGITGLAUggAACTwLVl0uPNSafqwwmfZ2kVvtYWwkBBO5BoPpcHfH+ZzBZohkYTLIMhtGZkWF0ZiRiDQL6OeugnzMjEfch4MzIWjszMiMRaxDQz1kH/ZwZMZhkRiLOEGAwidRGDEJjlgIQQACBJ4Hqy6XHGpPPVQaTvk5Sq32srYQAAvcgUH2ujnj/M5gs0QwMJlkGw+jMyDA6MxKxBgH9nHXQz5mRiPsQcGZkrZ0ZmZGINQjo56yDfs6MGEwyIxFnCDCYRGojBqExSwEIIIDAk0D15dJjjcnnKoNJXyep1T7WVkIAgXsQqD5XR7z/GUyWaAYGkyyDYXRmZBidGYlYg4B+zjro58xIxH0IODOy1s6MzEjEGgT0c9ZBP2dGDCaZkYgzBBhMIrURg9CYpQAEEEDgSaD6cumxxuRzlcGkr5PUah9rKyGAwD0IVJ+rI97/DCZLNAODSZbBMDozMozOjESsQUA/Zx30c2Yk4j4EnBlZa2dGZiRiDQL6OeugnzMjBpPMSMQZAgwmkdqIQWjMUgACCCDwJFB9ufRYY/K5ymDS10lqtY+1lRBA4B4Eqs/VEe9/BpMlmoHBJMtgGJ0ZGUZnRiLWIKCfsw76OTMScR8CzoystTMjMxKxBgH9nHXQz5kRg0lmJOIMAQaTSG3EIDRmKQABBBB4Eqi+XHqsMeFc/cxI8qe///mtUqp+zmebeXefbyXVFKxWm0BbBgEEbkOg+lyd8P7/HYPJEv3AYJJl6BhGVw9zq3Oo3n9WSQQCxwhU98JjF9X9UJ1D9f4fjKpzOFYNonYnMKFWq3Po6LXqHHavU/tfh0B1P1T3QvX+O75h1qmG8zthMDnPzi9fEWAwifUxYhAasxSAAAIIPAlUXy491phwrlYbQ941gLz7l1Peff6K/aFWV1TFnhBAYGcC1efqhPc/g8kaFc5gknWYMMytzqF6oJ5VEoHAMQLVvdBxOVOdQ0c/V+dwrBpE7U5gQq1W59DRa9U57F6n9r8Ogep+qO6F6v13fMOsUw3nd8Jgcp6dX74iwGAS62PEIDRmKQABBBB4Eqi+XHqsMeFcZTD5/o5Rq9+vgR0ggMAsAtXn6oT3P4PJGjXPYJJ1mDDMrc6heqCeVRKBwDEC1b3QcTlTnUNHP1fncKwaRO1OYEKtVufQ0WvVOexep/a/DoHqfqjuher9d3zDrFMN53fCYHKenV++IsBgEutjxCA0ZikAAQQQeBKovlx6rDHhXGUw+f6OUavfr4EdIIDALALV5+qE9z+DyRo1z2CSdZgwzK3OoXqgnlUSgcAxAtW90HE5U51DRz9X53CsGkTtTmBCrVbn0NFr1TnsXqf2vw6B6n6o7oXq/Xd8w6xTDed3wmBynp1fviLAYBLrY8QgNGYpAAEEEHgSqL5ceqwx4VxlMPn+jlGr36+BHSCAwCwC1efqhPc/g8kaNc9gknWYMMytzqF6oJ5VEoHAMQLVvdBxOVOdQ0c/V+dwrBpE7U5gQq1W59DRa9U57F6n9r8Ogep+qO6F6v13fMOsUw3nd8Jgcp6dX74iwGAS62PEIDRmKQABBBB4Eqi+XHqsMeFcZTD5/o5Rq9+vgR0ggMAsAtXn6oT3P4PJGjXPYJJ1mDDMrc6heqCeVRKBwDEC1b3QcTlTnUNHP1fncKwaRO1OYEKtVufQ0WvVOexep/a/DoHqfqjuher9d3zDrFMN53fCYHKenV++IsBgEutjxCA0ZikAAQQQeBKovlx6rDHhXP3MYPJZHf3p73/+p/9ptefs1AdqdSe17BUBBHYgUH2uTnj/M5isUckMJlmHCcPc6hyqB+pZJREIHCNQ3QsdlzPVOXT0c3UOx6pB1O4EJtRqdQ4dvVadw+51av/rEKjuh+peqN5/xzfMOtVwficMJufZ+eUrAgwmsT5GDEJjlgIQQACBJ4Hqy6XHGhPO1dWMIVftZ6c+UKs7qWWvCCCwA4Hqc3XC+5/BZI1KZjDJOkwY5lbnUD1QzyqJQOAYgepe6Licqc6ho5+rczhWDaJ2JzChVqtz6Oi16hx2r1P7X4dAdT9U90L1/ju+YdaphvM7YTA5z84vXxFgMIn1MWIQGrMUgAACCDwJVF8uPdaYcK5eZehY7Tk79YFa3Ukte0UAgR0IVJ+rE97/DCZrVDKDSdZhwjC3OofqgXpWSQQCxwhU90LH5Ux1Dh39XJ3DsWoQtTuBCbVanUNHr1XnsHud2v86BKr7oboXqvff8Q2zTjWc3wmDyXl2fvmKAINJrI8Rg9CYpQAEEEDgSaD6cumxxoRzdTVjyFX72akP1OpOatkrAgjsQKD6XJ3w/mcwWaOSGUyyDhOGudU5VA/Us0oiEDhGoLoXOi5nqnPo6OfqHI5Vg6jdCUyo1eocOnqtOofd69T+1yFQ3Q/VvVC9/45vmHWq4fxOGEzOs/PLVwQYTGJ9jBiExiwFIIAAAk8C1ZdLjzUmnKtXGTpWe85OfaBWd1LLXhFAYAcC1efqhPc/g8kalcxgknWYMMytzqF6oJ5VEoHAMQLVvdBxOVOdQ0c/V+dwrBpE7U5gQq1W59DRa9U57F6n9r8Ogep+qO6F6v13fMOsUw3nd8Jgcp6dX74iwGAS62PEIDRmKQABBBB4Eqi+XHqsMeFcXc0YctV+duoDtbqTWvaKAAI7EKg+Vye8/xlM1qhkBpOsw4RhbnUO1QP1rJIIBI4RqO6FjsuZ6hw6+rk6h2PVIGp3AhNqtTqHjl6rzmH3OrX/dQhU90N1L1Tvv+MbZp1qOL8TBpPz7PzyFQEGk1gfIwahMUsBCCCAwJNA9eXSY40J5+pnho4//f3Pb5VS9XM+28y7+3wrqaZgtdoE2jIIIHAbAtXn6oT3P4PJGu3AYJJ16Bjm5l2sHVE9UF87e7vbiYB+zmp19DMdsg4iMgG1mhl1RHTo0JGHNeYT8O7JGuvnzIjBJDMScYYAg0mkNmIQGrMUgAACCDwJVF8uPdaYcK5WG0PeNYD4CyY1HTyhVmvIeCoCCEwkUP0NMOJM/e8ff5io/W45MZhkxQyjMyPD6MxIxBoE9HPWoaOf6ZB1EJEJqNXMqCOiQ4eOPKwxn4B3T9ZYP2dGDCaZkYgzBBhMIrURg9CYpQAEEEDgSaD6cumxxoRzlcHk+ztGrX6/BnaAAAKzCFSfqxPe//6CyRo1z2CSdTCMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiLOEGAwidRGDEJjlgIQQACBJ4Hqy6XHGhPOVQaT7+8Ytfr9GtgBAgjMIlB9rk54/zOYrFHzDCZZB8PozMgwOjMSsQYB/Zx16OhnOmQdRGQCajUz6ojo0KEjD2vMJ+DdkzXWz5kRg0lmJOIMAQaTSG3EIDRmKQABBBB4Eqi+XHqsMeFcZTD5/o5Rq9+vgR0ggMAsAtXn6oT3P4PJGjXPYJJ1MIzOjAyjMyMRaxDQz1mHjn6mQ9ZBRCagVjOjjogOHTrysMZ8At49WWP9nBkxmGRGIs4QYDCJ1EYMQmOWAhBAAIEngerLpccaE85VBpPv7xi1+v0a2AECCMwiUH2uTnj/M5isUfMMJlkHw+jMyDA6MxKxBgH9nHXo6Gc6ZB1EZAJqNTPqiOjQoSMPa8wn4N2TNdbPmRGDSWYk4gwBBpNIbcQgNGYpAAEEEHgSqL5ceqwx4VxlMPn+jlGr36+BHSCAwCwC1efqhPc/g8kaNc9gknUwjM6MDKMzIxFrENDPWYeOfqZD1kFEJqBWM6OOiA4dOvKwxnwC3j1ZY/2cGTGYZEYiThD473//959P/OxWPxkxCC1WrHoYXbx9j78RAf2cxe7o5wk6fGYwyYTXiPjT3/+8xka+sAu1+gV4F/60Q4cLt+tRNyYw4d1TLZ9+zoR//5//+UOOElFNgMEkEzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6QmdSe/kAACAASURBVK1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzKgjgsEkUzaMzowMozMjEWsQ0M9Zh45+pkPWQUQmoFYzo46IDh068rDGfALePVlj/ZwZMZhkRiJOEGAwydAMozMjw+jMSMQaBPRz1qGjnyfr8Jnx5E9///M/hb9afK6QdSLU6hpadOiwRqZ2sTuBye+eq7TRz5kkg0lm1BHBYJIpG0ZnRobRmZGINQjo56xDRz/TIesgIhNQq5lRR0SHDh15WGM+Ae+erLF+zowYTDIjEScIMJhkaIbRmZFhdGYkYg0C+jnr0NHPk3VYzTDy7n5yhawToVbX0KJDhzUytYvdCUx+91yljX7OJBlMMqOOCAaTTNkwOjMyjM6MRKxBQD9nHTr6mQ5ZBxGZgFrNjDoiOnToyMMa8wl492SN9XNmxGCSGYk4QYDBJEMzjM6MDKMzIxFrENDPWYeOfp6sw7uGjtXic4WsE6FW19CiQ4c1MrWL3QlMfvdcpY1+ziQZTDKjjggGk0zZMDozMozOjESsQUA/Zx06+pkOWQcRmYBazYw6Ijp06MjDGvMJePdkjfVzZsRgkhmJOEGAwSRDM4zOjAyjMyMRaxDQz1mHjn6erMNqhpF395MrZJ0ItbqGFh06rJGpXexOYPK75ypt9HMmyWCSGXVEMJhkyobRmZFhdGYkYg0C+jnr0NHPdMg6iMgE1Gpm1BHRoUNHHtaYT8C7J2usnzMjBpPMSMQJAgwmGZphdGZkGJ0ZiViDgH7OOnT082Qd3jV0rBafK2SdCLW6hhYdOqyRqV3sTmDyu+cqbfRzJslgkhl1RDCYZMqG0ZmRYXRmJGINAvo569DRz3TIOojIBNRqZtQR0aFDRx7WmE/AuydrrJ8zIwaTzEjECQIMJhmaYXRmZBidGYlYg4B+zjp09PNkHVYzjLy7n1wh60So1TW06NBhjUztYncCk989V2mjnzNJBpPMqCOCwSRTNozOjAyjMyMRaxDQz1mHjn6mQ9ZBRCagVjOjjogOHTrysMZ8At49WWP9nBkxmGRGIk4QYDDJ0DqG0dXD3OocqvefVRKBwDEC1b3w2EV1P1TnUL3/B6PqHI5Vg6jdCUyo1eocOnqtOofd69T+1yFQ3Q/VvVC9/45vmHWq4fxOGEzOs7vyl3/5y19+vvJ53/Gs6kGoYfR3qGpNBBD4LgLVZ+ojL+fqd6k7a121OktP2SCAwPcTqD5XJ7z///GPf/zw/Ur9egfLbWg1QDvsh8EkqzRhmFudQ/VAPaskAoFjBKp7oeNypjqHjn6uzuFYNYjancCEWq3OoaPXqnPYvU7tfx0C1f1Q3QvV++/4hlmnGs7vhMHkPLsrf8lgkmlOGITmLEUggAACTwLVl0uPNZyrqu0KAmr1CoqegQACCHwQqD5XJ7z/GUx0TAkBBpOMdcIwtzqH6oF6VkkEAscIVPdCx+VMdQ4d/Vydw7FqELU7gQm1Wp1DR69V57B7ndr/OgSq+6G6F6r33/ENs041nN8Jg8l5dlf+ksEk05wwCM1ZikAAAQSeBKovlx5rOFdV2xUE1OoVFD0DAQQQ+CBQfa5OeP8zmOiYEgIMJhnrhGFudQ7VA/WskggEjhGo7oWOy5nqHDr6uTqHY9UgancCE2q1OoeOXqvOYfc6tf91CFT3Q3UvVO+/4xtmnWo4vxMGk/Psrvwlg0mmOWEQmrMUgQACCDwJVF8uPdZwrqq2Kwio1SsoegYCCCDwQaD6XJ3w/mcw0TElBBhMMtYJw9zqHKoH6lklEQgcI1DdCx2XM9U5dPRzdQ7HqkHU7gQm1Gp1Dh29Vp3D7nVq/+sQqO6H6l6o3n/HN8w61XB+Jwwm59ld+UsGk0xzwiA0ZykCAQQQeBKovlx6rOFcVW1XEFCrV1D0DAQQQOCDQPW5OuH9z2CiY0oIMJhkrBOGudU5VA/Us0oiEDhGoLoXOi5nqnPo6OfqHI5Vg6jdCUyo1eocOnqtOofd69T+1yFQ3Q/VvVC9/45vmHWq4fxOGEzOs7vylwwmmeaEQWjOUgQCCCDwJFB9ufRYw7mq2q4goFavoOgZCCCAwAeB6nN1wvufwUTHlBBgMMlYJwxzq3OoHqhnlUQgcIxAdS90XM5U59DRz9U5HKsGUbsTmFCr1Tl09Fp1DrvXqf2vQ6C6H6p7oXr/Hd8w61TD+Z0wmJxnd+UvGUwyzQmD0JylCAQQQOBJoPpy6bGGc1W1XUFArV5B0TMQQACBDwLV5+qE9z+DiY4pIcBgkrFOGOZW51A9UM8qiUDgGIHqXui4nKnOoaOfq3M4Vg2idicwoVarc+joteocdq9T+1+HQHU/VPdC9f47vmHWqYbzO2EwOc/uyl8ymGSaEwahOUsRCCCAwJNA9eXSYw3nqmq7goBavYKiZyCAAAIfBKrP1QnvfwYTHVNCgMEkY50wzK3OoXqgnlUSgcAxAtW90HE5U51DRz9X53CsGkTtTmBCrVbn0NFr1TnsXqf2vw6B6n6o7oXq/Xd8w6xTDed3wmBynt2Vv2QwyTQnDEJzliIQQACBJ4Hqy6XHGs5V1XYFAbV6BUXPQAABBD4IVJ+rE97/DCY6poQAg0nGOmGYW51D9UA9qyQCgWMEqnuh43KmOoeOfq7O4Vg1iNqdwIRarc6ho9eqc9i9Tu1/HQLV/VDdC9X77/iGWacazu+EweQ8uyt/yWCSaU4YhOYsRSCAAAJPAtWXS481nKuq7QoCavUKip6BAAIIfBCoPlcnvP8ZTHRMCQEGk4x1wjC3OofqgXpWSQQCxwhU90LH5Ux1Dh39XJ3DsWoQtTuBCbVanUNHr1XnsHud2v86BKr7oboXqvff8Q2zTjWc3wmDyXl2V/6SwSTTnDAIzVmKQAABBJ4Eqi+XHms4V1XbFQTU6hUUPQMBBBD4IFB9rk54/zOY6JgSAgwmGeuEYW51DtUD9aySCASOEajuhY7LmeocOvq5Oodj1SBqdwITarU6h45eq85h9zq1/3UIVPdDdS9U77/jG2adaji/EwaT8+yu/CWDSaY5YRCasxSBAAIIPAlUXy491nCuqrYrCKjVKyh6BgIIIPBBoPpcnfD+ZzDRMSUEGEwy1o5hbt7F2hHVA/W1s7e7nQjo56yWfs6MRNyHgDMja+3MyIxErEFAP2cd9HNmxGCSGXVEMJhkyhMGoTlLEQgggMCTQPXl0mMN56pqu4KAWr2ComcggAACHwSqz9UJ738GEx1TQoDBJGM1jM6MDKMzIxFrENDPWQf9nBmJuA8BZ0bW2pmRGYlYg4B+zjro58yIwSQz6ohgMMmUJwxCc5YiEEAAgSeB6sulxxrOVdV2BQG1egVFz0AAAQQ+CFSfqxPe/wwmOqaEAINJxmoYnRkZRmdGItYgoJ+zDvo5MxJxHwLOjKy1MyMzErEGAf2cddDPmRGDSWbUEcFgkilPGITmLEUggAACTwLVl0uPNZyrqu0KAmr1CoqegQACCHwQqD5XJ7z/GUx0TAkBBpOM1TA6MzKMzoxErEFAP2cd9HNmJOI+BJwZWWtnRmYkYg0C+jnroJ8zIwaTzKgjgsEkU54wCM1ZikAAAQSeBKovlx5rOFdV2xUE1OoVFD0DAQQQ+CBQfa5OeP8zmOiYEgIMJhmrYXRmZBidGYlYg4B+zjro58xIxH0IODOy1s6MzEjEGgT0c9ZBP2dGDCaZUUcEg0mmPGEQmrMUgQACCDwJVF8uPdZwrqq2Kwio1SsoegYCCCDwQaD6XJ3w/mcw0TElBBhMMlbD6MzIMDozErEGAf2cddDPmZGI+xBwZmStnRmZkYg1COjnrIN+zowYTDKjjggGk0x5wiA0ZykCAQQQeBKovlx6rOFcVW1XEFCrV1D0DAQQQOCDQPW5OuH9z2CiY0oIMJhkrIbRmZFhdGYkYg0C+jnroJ8zIxH3IeDMyFo7MzIjEWsQ0M9ZB/2cGTGYZEYdEQwmmfKEQWjOUgQCCCDwJFB9ufRYw7mq2q4goFavoOgZCCCAwAeB6nN1wvufwUTHlBBgMMlYDaMzI8PozEjEGgT0c9ZBP2dGIu5DwJmRtXZmZEYi1iCgn7MO+jkzYjDJjDoiGEwy5QmD0JylCAQQQOBJoPpy6bGGc1W1XUFArV5B0TMQQACBDwLV5+qE9z+DiY4pIcBgkrEaRmdGhtGZkYg1COjnrIN+zoxE3IeAMyNr7czIjESsQUA/Zx30c2bEYJIZdUQwmGTKEwahOUsRCCCAwJNA9eXSYw3nqmq7goBavYKiZyCAAAIfBKrP1QnvfwYTHVNCgMEkYzWMzowMozMjEWsQ0M9ZB/2cGYm4DwFnRtbamZEZiViDgH7OOujnzIjBJDPqiGAwyZQnDEJzliIQQACBJ4Hqy6XHGs5V1XYFAbV6BUXPQAABBD4IVJ+rE97/DCY6poQAg0nGahidGRlGZ0Yi1iCgn7MO+jkzEnEfAs6MrLUzIzMSsQYB/Zx10M+ZEYNJZtQRwWCSKU8YhOYsRSCAAAJPAtWXS481nKuq7QoCavUKip6BAAIIfBCoPlcnvP8ZTHRMCQEGk4zVMDozMozOjESsQUA/Zx30c2Yk4j4EnBlZa2dGZiRiDQL6OeugnzMjBpPMqCOCwSRTnjAIzVmKQAABBJ4Eqi+XHms4V1XbFQTU6hUUPQMBBBD4IFB9rk54/zOY6JgSAgwmGathdGZkGJ0ZiViDgH7OOujnzEjEfQg4M7LWzozMSMQaBPRz1kE/Z0YMJplRRwSDSabcMQjdfZhbvf+OC2k56IVM4FhEdS1Vn0nV++/o52NKidqdwIRarc6h+rx41JAccidV61CtQce5LYfvr6Mp/ZxJfi2CweRr/Pz6EwIMJrk0DKMzI8PozEjEGgT0c9ZBP2dGIu5DwJmRtXZmZEYi1iCgn7MO+jkzYjDJjDoiGEwy5epLgQnDXJcCuY4mXM7ohWM6V/dDtQ7V++/ohWNKidqdwIRarc6h+ryY8A0zIYfqOuo4t+WQT2T9nBl1RDCYdFC+4RoMJll0w+jMyDA6MxKxBgH9nHXQz5mRiPsQcGZkrZ0ZmZGINQjo56yDfs6MGEwyo44IBpNM2TA3M3IpkBlNuJzRC8d0ru6Hah2q99/RC8eUErU7gQm1Wp1D9XnxqCE55E6q1qFag45zWw7fX0dT+jmT/FoEg8nX+Pn1JwQYTHJpGEZnRobRmZGINQjo56yDfs6MRNyHgDMja+3MyIxErEFAP2cd9HNmxGCSGXVEMJhkytWXAhOGuS4Fch1NuJzRC8d0ru6Hah2q99/RC8eUErU7gQm1Wp1D9Xkx4RtmQg7VddRxbsshn8j6OTPqiGAw6aB8wzUYTLLohtGZkWF0ZiRiDQL6OeugnzMjEfch4MzIWjszMiMRaxDQz1kH/ZwZMZhkRh0RDCaZsmFuZuRSIDOacDmjF47pXN0P1TpU77+jF44pJWp3AhNqtTqH6vPiUUNyyJ1UrUO1Bh3nthy+v46m9HMm+bUIBpOv8fPrTwgwmOTSMIzOjAyjMyMRaxDQz1kH/ZwZibgPAWdG1tqZkRmJWIOAfs466OfMiMEkM+qIYDDJlKsvBSYMc10K5DqacDmjF47pXN0P1TpU77+jF44pJWp3AhNqtTqH6vNiwjfMhByq66jj3JZDPpH1c2bUEcFg0kH5hmswmGTRDaMzI8PozEjEGgT0c9ZBP2dGIu5DwJmRtXZmZEYi1iCgn7MO+jkzYjDJjDoiGEwyZcPczMilQGY04XJGLxzTubofqnWo3n9HLxxTStTuBCbUanUO1efFo4bkkDupWodqDTrObTl8fx1N6edM8msRDCZf4+fXnxBgMMmlYRidGRlGZ0Yi1iCgn7MO+jkzEnEfAs6MrLUzIzMSsQYB/Zx10M+ZEYNJZtQRwWCSKVdfCkwY5roUyHU04XJGLxzTubofqnWo3n9HLxxTStTuBCbUanUO1efFhG+YCTlU11HHuS2HfCLr58yoI4LBpIPyDddgMMmiG0ZnRobRmZGINQjo56yDfs6MRNyHgDMja+3MyIxErEFAP2cd9HNmxGCSGXVEMJhkyoa5mZFLgcxowuWMXjimc3U/VOtQvf+OXjimlKjdCUyo1eocqs+LRw3JIXdStQ7VGnSc23L4/jqa0s+Z5NciGEy+xs+vPyHAYJJLwzA6MzKMzoxErEFAP2cd9HNmJOI+BJwZWWtnRmYkYg0C+jnroJ8zIwaTzKgjgsEkU66+FJgwzHUpkOtowuWMXjimc3U/VOtQvf+OXjimlKjdCUyo1eocqs+LCd8wE3KorqOOc1sO+UTWz5lRRwSDSQflG67BYJJFN4zOjAyjMyMRaxDQz1kH/ZwZibgPAWdG1tqZkRmJWIOAfs466OfMiMEkM+qIYDDJlA1zMyOXApnRhMsZvXBM5+p+qNahev8dvXBMKVG7E5hQq9U5VJ8XjxqSQ+6kah2qNeg4t+Xw/XU0pZ8zya9FMJh8jZ9ff0KAwSSXhmF0ZmQYnRmJWIOAfs466OfMSMR9CDgzstbOjMxIxBoE9HPWQT9nRgwmmVFHBINJplx9KTBhmOtSINfRhMsZvXBM5+p+qNahev8dvXBMKVG7E5hQq9U5VJ8XE75hJuRQXUcd57Yc8omsnzOjjggGkw7KN1yDwSSLbhidGRlGZ0Yi1iCgn7MO+jkzEnEfAs6MrLUzIzMSsQYB/Zx10M+ZEYNJZtQRwWCSKXcMc/MuRCCAAAI9BCZc8vWQem+Vf/u3f3vvB29G/+1vf3vzF/uHq9X9NZQBAgisRaD6XJ3w7yoGk7VqdsxuGEyylIbRmZFhdGYkYg0C+jnroJ8zIxH3IeDMyFo7MzIjEWsQ0M9ZB/2cGTGYZEYdEQwmmfKEQWjOUgQCCCDwJFB9ufRY447nKoPJ9R2mVq9n6okIIHBvAtXn6oT3P4PJvXukLHsGk4zWMDozMozOjESsQUA/Zx30c2Yk4j4EnBlZa2dGZiRiDQL6OeugnzMjBpPMqCOCwSRTnjAIzVmKQAABBJ4Eqi+XHmvc8VxlMLm+w9Tq9Uw9EQEE7k2g+lyd8P5nMLl3j5Rlz2CS0RpGZ0aG0ZmRiDUI6Oesg37OjETch4AzI2vtzMiMRKxBQD9nHfRzZsRgkhl1RDCYZMoTBqE5SxEIIIDAk0D15dJjjTueqwwm13eYWr2eqScigMC9CVSfqxPe/wwm9+6RsuwZTDJaw+jMyDA6MxKxBgH9nHXQz5mRiPsQcGZkrZ0ZmZGINQjo56yDfs6MGEwyo44IBpNMecIgNGcpAgEEEHgSqL5ceqxxx3OVweT6DlOr1zP1RAQQuDeB6nN1wvufweTePVKWPYNJRmsYnRkZRmdGItYgoJ+zDvo5MxJxHwLOjKy1MyMzErEGAf2cddDPmRGDSWbUEcFgkilPGITmLEUggAACTwLVl0uPNe54rjKYXN9havV6pp6IAAL3JlB9rk54/zOY3LtHyrJnMMloDaMzI8PozEjEGgT0c9ZBP2dGIu5DwJmRtXZmZEYi1iCgn7MO+jkzYjDJjDoiGEwy5QmD0JylCAQQQOBJoPpy6bHGHc9VBpPrO0ytXs/UExFA4N4Eqs/VCe9/BpN790hd9r//j5/rHu7JdyHQMYx2KXCXapInAggggAACCNyNgG/Juym+cb7//eMPG+9+zNYZTLKUEwahOUsRCCCAwJNA9eXSY407nqsMJtd3mFq9nqknIoDAvQlUn6sT3v8MJvfukbrsGUzq2N7oyS4FbiS2VBFAAAEEEEAAgYsJ+Ja8GKjH1RFgMKlj+8aTGUwyrAmD0JylCAQQQOBJoPpy6bHGHc9VBpPrO0ytXs/UExFA4N4Eqs/VCe9/BpN790hd9gwmdWxv9GSXAjcSW6oIIIAAAggggMDFBHxLXgzU4+oIMJjUsX3jyQwmGdaEQWjOUgQCCCDwJFB9ufRY447nKoPJ9R2mVq9n6okIIHBvAtXn6oT3P4PJvXukLnsGkzq2N3qyS4EbiS1VBBBAAAEEEEDgYgK+JS8G6nF1BBhM6ti+8WQGkwxrwiA0ZykCAQQQeBKovlx6rHHHc5XB5PoOU6vXM/VEBBC4N4Hqc3XC+5/B5N49Upc9g0kd2xs92aXAjcSWKgIIIIAAAgggcDEB35IXA/W4OgIMJnVs33gyg0mGNWEQmrMUgQACCDwJVF8uPda447nKYHJ9h6nV65l6IgII3JtA9bk64f3PYHLvHqnLnsGkju2NnuxS4EZiSxUBBBBAAAEEELiYgG/Ji4F6XB0BBpM6tm88mcEkw5owCM1ZikAAAQSeBKovlx5rTDhX3zWM/O1vfystsdX2U5rs//twtdpB2RoIIHAnAtXn6oT3P4PJnTqiM1cGk07aY9dyKTBWWokhgMBFBP7v//i/LnnSH3784z99zmfP/yz+ks14CAIIIHARAd+SF4H0mHoCDCb1jA+swGCSIU0YhOYsRSCAAAJPAtWXS481Jpyrqxk6VttPRz+p1Q7K1kAAgTsRqD5XJ7z/GUzu1BGduTKYdNIeu5ZLgbHSSgwBBC4iwGByEUiPQQCBkQR8S46UdWZSDCZL6MpgkmWYMAjNWYpAAAEEngSqL5cea0w4V1czdKy2n45+UqsdlK2BAAJ3IlB9rk54/zOY3KkjOnNlMOmkPXYtlwJjpZUYAghcRIDB5CKQHoMAAiMJ+JYcKevMpBhMltCVwSTLMGEQmrMUgQACCDwJVF8uPdaYcK6uZuhYbT8d/aRWOyhbAwEE7kSg+lyd8P5nMLlTR3TmymDSSXvsWi4FxkorMQQQuIgAg8lFID0GAQRGEvAtOVLWmUkxmCyhK4NJlmHCIDRnKQIBBBB4Eqi+XHqsMeFcXc3Qsdp+OvpJrXZQtgYCCNyJQPW5OuH9z2Byp47ozJXBpJP22LVcCoyVVmIIIHARAQaTi0B6DAIIjCTgW3KkrDOTYjBZQlcGkyzDhEFozlIEAggg8CRQfbn0WGPCubqaoWO1/XT0k1rtoGwNBBC4E4Hqc3XC+5/B5E4d0Zkrg0kn7bFruRQYK63EEEDgIgIMJheB9BgEEBhJwLfkSFlnJsVgsoSuDCZZhgmD0JylCAQQQOBJoPpy6bHGhHN1NUPHavvp6Ce12kHZGgggcCcC1efqhPc/g8mdOqIzVwaTTtpj13IpMFZaiSGAwJsErjKSvLns7/7w4x//6U8+289n8e+uKx4BBBC4goBvySsoekYLAQaTFsxpEQaTRGjGRWjOUgQCCCDwJFB9ufRYY8IF02qGjtX209FParWDsjUQQOBOBKrP1QnvfwaTO3VEZ64MJp20x67lUmCstBJDAIE3CTCYvAlMOAIIIPC73/3Ot6Qy2IYAg8kSUjGYZBkmDEJzliIQQACBJ4Hqy6XHGhPO1dUMHavtp6Of1GoHZWsggMCdCFSfqxPe/wwmd+qIzlwZTDppj13LpcBYaSWGAAJvEmAweROYcAQQQIDBRA3sRIDBZAm1GEyyDBMGoTlLEQgggMCTQPXl0mONCefqaoaO1fbT0U9qtYOyNRBA4E4Eqs/VCe9/BpM7dURnrgwmnbTHrsVgMlZaiSGAwJsEGEzeBCYcAQQQYDBRAzsRYDBZQi0GkyzDhEFozlIEAggg8CRQfbn0WGPCubqaoWO1/XT0k1rtoGwNBBC4E4Hqc3XC+5/B5E4d0Zkrg0kn7bFrMZiMlVZiCCDwJgEGkzeBCUcAAQQYTNTATgQYTJZQi8EkyzBhEJqzFIEAAgg8CVRfLj3WmHCurmboWG0/Hf2kVjsoWwMBBO5EoPpcnfD+ZzC5U0d05spg0kl77FoMJmOllRgCCLxJgMHkTWDCEUAAAQYTNbATAQaTJdRiMMkyTBiE5ixFIIAAAk8C1ZdLjzUmnKurGTpW209HP6nVDsrWQACBOxGoPlcnvP8ZTO7UEZ25Mph00h67FoPJWGklhgACbxK4ymDyhx//+E9Xfvf5nz3nzbSEI4AAAqUEfEuW4vXwKwkwmFxJ8/SzGEwyugmD0JylCAQQQOBJoPpy6bHGhHN1NUPHavvp6Ce12kHZGgggcCcC1efqQH/0nwAAIABJREFUhPc/g8mdOqIzVwaTTtpj13IpMFZaiSGAwJsE3jWAfPZ4BpM3wQtHAIGtCfiW3Fq+e22ewWQJvRlMsgwTBqE5SxEIIIDAk0D15dJjjQnn6mqGjtX209FParWDsjUQQOBOBKrP1QnvfwaTO3VEZ64MJp20x67lUmCstBJDAIE3CTCYvAlMOAIIIOB/kaMGdiLAYLKEWgwmWYYJg9CcpQgEEEDgSaD6cumxxoRzdTVDx2r76egntdpB2RoIIHAnAtXn6oT3P4PJnTqiM1cGk07aY9diMBkrrcQQQOBNAgwmbwITjgACCDCYqIGdCDCYLKEWg0mWYcIgNGcpAgEEEHgSqL5ceqwx4VxdzdCx2n46+kmtdlC2BgII3IlA9bk64f3PYHKnjujMlcGkk/bYtRhMxkorMQQQeJMAg8mbwIQjgAACDCZqYCcCDCZLqMVgkmWYMAjNWYpAAAEEngSqL5cea0w4V1czdKy2n45+UqsdlK2BAAJ3IlB9rk54/zOY3KkjOnNlMOmkPXYtBpOx0koMAQTeJMBg8iYw4QgggACDiRrYiQCDyRJqMZhkGSYMQnOWIhBAAIEngerLpccaE87V1Qwdq+2no5/UagdlayCAwJ0IVJ+rE97/DCZ36ojOXBlMOmmPXYvBZKy0EkMAgWICVxlSPtvmH378Y3EGHo8AAgh8nYBvya8z9IQmAgwmTaBfL8NgkmWYMAjNWYpAAAEEngSqL5cea0w4V1czdKy2n45+UqsdlK2BAAJ3IlB9rk54/zOY3KkjOnNlMOmkPXYtlwJjpZUYAggUE2AwKQbs8QggsAUB35JbyGSTDwIMJkvUAYNJlmHCIDRnKQIBBBB4Eqi+XHqsMeFcXc3Qsdp+OvpJrXZQtgYCCNyJQPW5OuH9z2Byp47ozJXBpJP22LVcCoyVVmIIIFBMgMGkGLDHI4DAFgR8S24hk00+CDCYLFEHDCZZhgmD0JylCAQQQOBJoPpy6bHGhHN1NUPHavvp6Ce12kHZGgggcCcC1efqhPc/g8mdOqIzVwaTTtpj13IpMFZaiSGAQDEBBpNiwB6PAAJbEPAtuYVMNvkgwGCyRB0wmGQZJgxCc5YiEEAAgSeB6sulxxoTztXVDB2r7aejn9RqB2VrIIDAnQhUn6sT3v8MJnfqiM5cGUw6aY9dy6XAWGklhgACxQQYTIoBezwCCGxBwLfkFjLZ5IMAg8kSdcBgkmWYMAjNWYpAAAEEngSqL5cea0w4V1czdKy2n45+UqsdlK2BAAJ3IlB9rk54/zOY3KkjOnNlMOmkPXYtlwJjpZUYAggUE2AwKQbs8QggsAUB35JbyGSTDwIMJkvUAYNJlmHCIDRnKQIBBBB4Eqi+XHqsMeFcXc3Qsdp+OvpJrXZQtgYCCNyJQPW5OuH9z2Byp47ozHWAwaR6IP37//k/yhXZPYfq/T8EqNZBDrnMqzX4ZWb/v/0/eSNfiJBDhletgX7OGryKeNeQ8ocf//hPH0fnYzpUnxnVOlTv37l9jzpybh/TWT9nTh1nUt7FFyMYTL4I8Jqf//zzzz9f86S5T5kwCK1Wp3oYXb1/z78PAf2cte7o5wk6vGvoyOR7I/72t7/1LliwmlotgHrikR06nNiWnyDw/yMw4d1TLat+zoR/+OGHH3JUb8RyG+pNf8hqDCZRyI5B6O4D6er9u9iIZfpLQLUOeuEeOlTXkX4+VkefRTGYfJBRq7mWnNuZ0YT3p144pnN1P1TrUL3/Cb1wrBK+GMVg8kWA1/ycwSRzNIzOjAyjMyMRaxDQz1mHjn6eoAODSa6l6gi1Wk342PM7dDi2E1EIvCYw4d1TrbF+zoQZTDIjEWcIMJhEaoa5EVG5seGxg2odqi8FJuRQrcGUi43qWqrWoXr/E3qhI4fPTl4Gkw8yajW/n6vPC+d21qDjvNAL99BBPx/TuTyKwaQc8ZEFGEwyJcPozMgwOjMSsQYB/Zx16OjnCTowmORaqo5Qq9WEjz2/Q4djOxGFwGsCE9491Rrr50yYwSQzEnGGAINJpGaYGxExmGREv0RU11L1BVP1/l1UHiukah2q62hCL3Tk8Fk1MJh8kFGr+cyoPi+c21mDjvNCL9xDB/18TOfyKAaTcsRHFmAwyZQMozMjw+jMSMQaBPRz1qGjnyfowGCSa6k6Qq1WEz72/A4dju1EFAKvCUx491RrrJ8zYQaTzEjEGQIMJpGaYW5ExGCSEf0SUV1L1RdM1ft3UXmskKp1qK6jCb3QkcNn1cBg8kFGreYzo/q8cG5nDTrOC71wDx308zGdy6MYTMoRH1mAwSRTMozOjAyjMyMRaxDQz1mHjn6eoAODSa6l6gi1Wk342PM7dDi2E1EIvCYw4d1TrbF+zoQZTDIjEWcIMJhEaoa5ERGDSUb0S0R1LVVfMFXv30XlsUKq1qG6jib0QkcOn1UDg8kHGbWaz4zq88K5nTXoOC/0wj100M/HdC6PYjApR3xkAQaTTMkwOjMyjM6MRKxBQD9nHTr6eYIODCa5lqoj1Go14WPP79Dh2E5EIfCawIR3T7XG+jkTZjDJjEScIcBgEqkZ5kZEDCYZ0S8R1bVUfcFUvX8XlccKqVqH6jqa0AsdOXxWDQwmH2TUaj4zqs8L53bWoOO80Av30EE/H9O5PIrBpBzxkQUYTDIlw+jMyDA6MxKxBgH9nHXo6OcJOjCY5FqqjlCr1YSPPb9Dh2M7EYXAawIT3j3VGuvnTJjBJDMScYYAg0mkZpgbETGYZES/RFTXUvUFU/X+XVQeK6RqHarraEIvdOTwWTUwmHyQUav5zKg+L5zbWYOO80Iv3EMH/XxM5/IoBpNyxEcWYDDJlAyjMyPD6MxIxBoE9HPWoaOfJ+jAYJJrqTpCrVYTPvb8Dh2O7UQUAq8JTHj3VGusnzNhBpPMSMQZAgwmkZphbkTEYJIR/RJRXUvVF0zV+3dReayQqnWorqMJvdCRw2fVwGDyQUat5jOj+rxwbmcNOs4LvXAPHfTzMZ3LoxhMyhEfWYDBJFMyjM6MDKMzIxFrENDPWYeOfp6gA4NJrqXqCLVaTfjY8zt0OLYTUQi8JjDh3VOtsX7OhBlMMiMRZwgwmERqhrkREYNJRvRLRHUtVV8wVe/fReWxQqrWobqOJvRCRw6fVQODyQcZtZrPjOrzwrmdNeg4L/TCPXTQz8d0Lo9iMClHfGQBBpNMyTA6MzKMzoxErEFAP2cdOvp5gg4MJrmWqiPUajXhY8/v0OHYTkQh8JrAhHdPtcb6ORNmMMmMRJwhwGASqRnmRkQMJhnRLxHVtVR9wVS9fxeVxwqpWofqOprQCx05fFYNDCYfZNRqPjOqzwvndtag47zQC/fQQT8f07k8isGkHPGRBRhMMiXD6MzIMDozErEGAf2cdejo5wk6MJjkWqqOUKvVhI89v0OHYzsRhcBrAhPePdUa6+dMmMEkMxJxhgCDSaRmmBsRMZhkRL9EVNdS9QVT9f5dVB4rpGodqutoQi905PBZNTCYfJBRq/nMqD4vnNtZg47zQi/cQwf9fEzn8igGk3LERxZgMMmUDKMzI8PozEjEGgT0c9aho58n6MBgkmupOkKtVhM+9vwOHY7tRBQCrwlMePdUa6yfM2EGk8xIxBkCAwwmZ9L2m2sJTLjYuJaIpyGAAALHCLxrGDn21I+oP/z4x3d/Ih4BBBBoJ+Bbsh25Bc8SYDA5S+7S3zGYZJyG0ZmRYXRmJGINAvo569DRzxN0YDDJtVQdoVarCR97focOx3YiCoHXBCa8e6o11s+ZMINJZiTiDAEGkzPU/OY3BFwKKAkEEEDgHAEGk3Pc/AoBBGYR8C05S8/R2TCYLCEvg0mWwTA6MzKMzoxErEFAP2cdOvp5gg4MJrmWqiPUajXhY8/v0OHYTkQh8JrAhHdPtcb6ORNmMMmMRJwhwGByhprf/IaASwElgQACCJwjwGByjptfIYDALAK+JWfpOTobBpMl5GUwyTIYRmdGhtGZkYg1COjnrENHP0/QgcEk11J1hFqtJnzs+R06HNuJKAReE5jw7qnWWD9nwgwmmZGIMwQYTM5Q85vfEHApoCQQQACBcwQYTM5x8ysEEJhFwLfkLD1HZ8NgsoS8DCZZBsPozMgwOjMSsQYB/Zx16OjnCTowmORaqo5Qq9WEjz2/Q4djOxGFwGsCE9491Rrr50yYwSQzEnGGAIPJGWp+8xsCLgWUBAIIIHCOAIPJOW5+hQACswj4lpyl5+hsGEyWkJfBJMtgGJ0ZGUZnRiLWIKCfsw4d/TxBBwaTXEvVEWq1mvCx53focGwnohB4TWDCu6daY/2cCTOYZEYizhBgMDlDzW9+Q8ClgJJAAAEEzhFgMDnHza8QQGAWAd+Ss/QcnQ2DyRLyMphkGQyjMyPD6MxIxBoE9HPWoaOfJ+jAYJJrqTpCrVYTPvb8Dh2O7UQUAq8JTHj3VGusnzNhBpPMSMQZAgwmZ6j5zW8IuBRQEggggMA5Agwm57j5FQIIzCLgW3KWnqOzYTBZQl4GkyyDYXRmZBidGYlYg4B+zjp09PMEHRhMci1VR6jVasLHnt+hw7GdiELgNYEJ755qjfVzJsxgkhmJOEOAweQMNb/5DQGXAkoCAQQQeBKoNoy8y/kPP/7x3Z+IRwABBNoJ+JZsR27BswQYTM6Su/R3DCYZp2F0ZmQYnRmJWIOAfs46dPTzBB0YTHItVUeo1WrCx57focOxnYhC4DWBCe+eao31cybMYJIZiThDgMHkDDW/+Q0BlwJKAgEEEHgSYDBRCQgggMD7BHxLvs/ML76JAIPJN4H/9bIMJlkGw+jMyDA6MxKxBgH9nHXo6OcJOjCY5FqqjlCr1YSPPb9Dh2M7EYXAawIT3j3VGuvnTJjBJDMScYYAg8kZan7zGwIuBZQEAggg8CTAYKISEEAAgfcJ+JZ8n5lffBMBBpNvAv/rZRlMsgyG0ZmRYXRmJGINAvo569DRzxN0YDDJtVQdoVarCR97focOx3YiCoHXBCa8e6o11s+ZMINJZiTiDAEGkzPU/OY3BFwKKAkEEEDgSYDBRCUggAAC7xPwLfk+M7/4JgIMJt8E/tfLMphkGQyjMyPD6MxIxBoE9HPWoaOfJ+jAYJJrqTpCrVYTPvb8Dh2O7UQUAq8JTHj3VGusnzNhBpPMSMQZAgwmZ6j5zW8IuBRQEggggMCTAIOJSkAAAQTeJ+Bb8n1mfvFNBBhMvgn8r5dlMMkyGEZnRobRmZGINQjo56xDRz9P0IHBJNdSdYRarSZ87PkdOhzbiSgEXhOY8O6p1lg/Z8IMJpmRiDMEGEzOUPOb3xBwKaAkEEAAgScBBhOVgAACCLxPwLfk+8z84psIMJh8E/hfL8tgkmXoGEZXD3Orc6jef1ZJBALHCFT3wmMX1f1QnUP1/h+MqnM4Vg2idicwoVarc+joteocdq9T+1+HQHU/VPdC9f47vmHWqYbzO2EwOc/OL18RYDBRHxcQcClwAUSPQACBEQS+y2Dyhx//OIKfJBBA4J4EfEveU/cts2YwWUI2BpMsw4RhbnUO1QP1rJIIBI4RqO6FjsuZ6hw6+rk6h2PVIGp3AhNqtTqHjl6rzmH3OrX/dQhU90N1L1Tvv+MbZp1qOL8TBpPz7PzyFQEGE/VxAQGXAhdA9AgEEBhBgMFkhIySQACBZgK+JZuBW+48AQaT8+wu/CWDSYY5YZhbnUP1QD2rJAKBYwSqe6HjcqY6h45+rs7hWDWI2p3AhFqtzqGj16pz2L1O7X8dAtX9UN0L1fvv+IZZpxrO74TB5Dw7v3xFgMFEfVxAwKXABRA9AgEERhBgMBkhoyQQQKCZgG/JZuCWO0+AweQ8uwt/yWCSYU4Y5lbnUD1QzyqJQOAYgepe6Licqc6ho5+rczhWDaJ2JzChVqtz6Oi16hx2r1P7X4dAdT9U90L1/ju+YdaphvM7YTA5z84vXxFgMFEfFxBwKXABRI9AAIERBBhMRsgoCQQQaCbgW7IZuOXOE2AwOc/uwl8ymGSYE4a51TlUD9SzSiIQOEaguhc6Lmeqc+jo5+ocjlWDqN0JTKjV6hw6eq06h93r1P7XIVDdD9W9UL3/jm+Ydarh/E4YTM6z88tXBBhM1McFBFwKXADRIxBAYAQBBpMRMkoCAQSaCfiWbAZuufMEGEzOs7vwlwwmGeaEYW51DtUD9aySCASOEajuhY7LmeocOvq5Oodj1SBqdwITarU6h45eq85h9zq1/3UIVPdDdS9U77/jG2adaji/EwaT8+z88hUBBhP1cQEBlwIXQPQIBBAYQYDBZISMkkAAgWYCviWbgVvuPAEGk/PsLvwlg0mGOWGYW51D9UA9qyQCgWMEqnuh43KmOoeOfq7O4Vg1iNqdwIRarc6ho9eqc9i9Tu1/HQLV/VDdC9X77/iGWacazu+EweQ8O798RYDBRH1cQMClwAUQPQIBBEYTuMp48ocf/ziak+QQQOCeBHxL3lP3LbNmMFlCNgaTLMOEYW51DtUD9aySCASOEajuhY7LmeocOvq5Oodj1SBqdwITarU6h45eq85h9zq1/3UIVPdDdS9U77/jG2adaji/EwaT8+z88hUBBhP1cQEBlwIXQPQIBBAYTYDBZLS8kkMAgS8S8C35RYB+3keAwaSP9YuVGEyyDBOGudU5VA/Us0oiEDhGoLoXOi5nqnPo6OfqHI5Vg6jdCUyo1eocOnqtOofd69T+1yFQ3Q/VvVC9/45vmHWq4fxOGEzOs/PLVwQYTNTHBQRcClwA0SMQQGA0AQaT0fJKDgEEvkjAt+QXAfp5HwEGkz7WL1ZiMMkyTBjmVudQPVDPKolA4BiB6l7ouJypzqGjn6tzOFYNonYnMKFWq3Po6LXqHHavU/tfh0B1P1T3QvX+O75h1qmG8zthMDnPzi9fEWAwUR8XEHApcAFEj0AAgdEEGExGyys5BBD4IgHfkl8E6Od9BBhM+li/WInBJMswYZhbnUP1QD2rJAKBYwSqe6HjcqY6h45+rs7hWDWI2p3AhFqtzqGj16pz2L1O7X8dAtX9UN0L1fvv+IZZpxrO74TB5Dw7v3xFgMFEfVxAwKXABRA9AgEERhNgMBktr+QQQOCLBHxLfhGgn/cRYDDpY/1iJQaTLMOEYW51DtUD9aySCASOEajuhY7LmeocOvq5Oodj1SBqdwITarU6h45eq85h9zq1/3UIVPdDdS9U77/jG2adaji/EwaT8+z88hUBBhP1cQEBlwIXQPQIBBAYTYDBZLS8kkMAgS8S8C35RYB+3keAwaSP9YuVGEyyDB3D3LyLtSOqB+prZ293OxHQz1kt/ZwZibgPAWdG1tqZkRmJWIOAfs466OfMiMEkMxJxhgCDyRlqfvMbAi4FlAQCCCCAAAIIIIDAWQK+Jc+S87t2Agwm7cj/2YIMJlkGw+jMyDA6MxKxBgH9nHX4X+z8UZIkS26tax4O44hwVv1aHMMdC+fAV86qRXoYbPGTV1i3ubP3Qob5UoeZf8+F0ID+P4AMUUNt/ZwZifgeAmZGdm1mZEYidhDQz9mDfs6MLJhkRiJ+QsCCyU+o+Zn/QcBHASWBAAIIIIAAAggg8FMC/pb8KTk/d5yABZPjyH/3Cy2YZA0eozMjj9GZkYgdBPRz9qCfMyMR30PAzMiuzYzMSMQOAvo5e9DPmZEFk8xIxE8IWDD5CTU/8z8I+CigJBBAAAEEEEAAAQR+SsDfkj8l5+eOE7Bgchz5736hBZOswWN0ZuQxOjMSsYOAfs4e9HNmJOJ7CJgZ2bWZkRmJ2EFAP2cP+jkzsmCSGYn4CQELJj+h5mf+BwEfBZQEAggggAACCCCAwE8J+Fvyp+T83HECFkyOI//dL7RgkjV4jM6MPEZnRiJ2ENDP2YN+zoxEfA8BMyO7NjMyIxE7COjn7EE/Z0YWTDIjET8hYMHkJ9T8zP8g4KOAkkAAAQQQQAABBBD4KQF/S/6UnJ87TsCCyXHkv/uFFkyyBo/RmZHH6MxIxA4C+jl70M+ZkYjvIWBmZNdmRmYkYgcB/Zw96OfMyIJJZiTiJwQsmPyEmp/5HwR8FFASCCCAAAIIIIAAAj8l4G/Jn5Lzc8cJWDA5jvx3v9CCSdbgMToz8hidGYnYQUA/Zw/6OTMS8T0EzIzs2szIjETsIKCfswf9nBlZMMmMRPyAwP/7//q//usHP/ZVP/Kv//m/v+q+P7msjwI/ofb+n2l70AszZzzMODWj2g6auT/pbDMj22zXKgfZwSuChxmnZlTbwSt3/ZANnvCQs9gd8a///u//sjvD78jOgkn27DE6M/IYnRmJ2EFAP2cP+jkzEvE9BMyM7NrMyIxE7CCgn7MH/ZwZWTDJjET8gIAFkwzNY3RmdOIxmofPe+AgO/ChcsaoHXViJrXv8ITzzYxssV2rHGQH5vaMUTuq3Quv/PVDtnjCQ85id4QFkx1+LJhkDx6jMyOP0ZmRiB0E9HP2oJ8zIxHfQ8DMyK7NjMxIxA4C+jl70M+ZkQWTzEjEDwhYMMnQPEZnRiceo3n4vAcOsgMfKmeM2lEnZlL7Dk8438zIFtu1ykF2YG7PGLWj2r3wyl8/ZIsnPOQsdkdYMNnhx4JJ9uAxOjPyGJ0ZidhBQD9nD/o5MxLxPQTMjOzazMiMROwgoJ+zB/2cGVkwyYxE/ICABZMMzWN0ZnTiMZqHz3vgIDvwoXLGqB11Yia17/CE882MbLFdqxxkB+b2jFE7qt0Lr/z1Q7Z4wkPOYneEBZMdfiyYZA8eozMjj9GZkYgdBPRz9qCfMyMR30PAzMiuzYzMSMQOAvo5e9DPmZEFk8xIxA8IWDDJ0DxGZ0YnHqN5+LwHDrIDHypnjNpRJ2ZS+w5PON/MyBbbtcpBdmBuzxi1o9q98MpfP2SLJzzkLHZHWDDZ4ceCSfbgMToz8hidGYnYQUA/Zw/6OTMS8T0EzIzs2szIjETsIKCfswf9nBlZMMmMRPyAgAWTDM1jdGZ04jGah8974CA78KFyxqgddWImte/whPPNjGyxXascZAfm9oxRO6rdC6/89UO2eMJDzmJ3hAWTHX4smGQPHqMzI4/RmZGIHQT0c/agnzMjEd9DwMzIrs2MzEjEDgL6OXvQz5mRBZPMSMQPCFgwydA8RmdGJx6jefi8Bw6yAx8qZ4zaUSdmUvsOTzjfzMgW27XKQXZgbs8YtaPavfDKXz9kiyc85Cx2R1gw2eHHgkn24DE6M/IYnRmJ2EFAP2cP+jkzEvE9BMyM7NrMyIxE7CCgn7MH/ZwZWTDJjET8gIAFkwzNY3RmdOIxmofPe+AgO/ChcsaoHXViJrXv8ITzzYxssV2rHGQH5vaMUTuq3Quv/PVDtnjCQ85id4QFkx1+LJhkDx6jMyOP0ZmRiB0E9HP2oJ8zIxHfQ8DMyK7NjMxIxA4C+jl70M+ZkQWTzEjEDwhYMMnQPEZnRiceo3n4vAcOsgMfKmeM2lEnZlL7Dk8438zIFtu1ykF2YG7PGLWj2r3wyl8/ZIsnPOQsdkdYMNnhx4JJ9uAxOjPyGJ0ZidhBQD9nD/o5MxLxPQTMjOzazMiMROwgoJ+zB/2cGVkwyYxE/ICABZMMzWN0ZnTiMZqHz3vgIDvwoXLGqB11Yia17/CE882MbLFdqxxkB+b2jFE7qt0Lr/z1Q7Z4wkPOYneEBZMdfiyYZA8eozMjj9GZkYgdBPRz9qCfMyMR30PAzMiuzYzMSMQOAvo5e9DPmZEFk8xIxA8IWDDJ0DxGZ0YnHqN5+LwHDrIDHypnjNpRJ2ZS+w5PON/MyBbbtcpBdmBuzxi1o9q98MpfP2SLJzzkLHZHWDDZ4ceCSfbgMToz8hidGYnYQUA/Zw/6OTMS8T0EzIzs2szIjETsIKCfswf9nBlZMMmMRPyAgAWTDM1jdGZ04jGah8974CA78KFyxqgddWImte/whPPNjGyxXascZAfm9oxRO6rdC6/89UO2eMJDzmJ3hAWTHX4smGQPHqMzI4/RmZGIHQT0c/agnzMjEd9DwMzIrs2MzEjEDgL6OXvQz5mRBZPMSMQPCFgwydA8RmdGJx6jefi8Bw6yAx8qZ4zaUSdmUvsOTzjfzMgW27XKQXZgbs8YtaPavfDKXz9kiyc85Cx2R1gw2eHHgkn24DE6M/IYnRmJ2EFAP2cP+jkzEvE9BMyM7NrMyIxE7CCgn7MH/ZwZWTDJjET8gIAFkwzNY3RmdOIxmofPe+AgO/ChcsaoHXViJrXv8ITzzYxssV2rHGQH5vaMUTuq3Quv/PVDtnjCQ85id4QFkx1+LJhkDx6jMyOP0ZmRiB0E9HP2oJ8zIxHfQ8DMyK7NjMxIxA4C+jl70M+ZkQWTzEjEDwhYMMnQPEZnRiceo3n4vAcOsgMfKmeM2lEnZlL7Dk8438zIFtu1ykF2YG7PGLWj2r3wyl8/ZIsnPOQsdkdYMNnhx4JJ9uAxOjPyGJ0ZidhBQD9nD/o5MxLxPQTMjOzazMiMROwgoJ+zB/2cGVkwyYxE/ICABZMMzWN0ZnTiMZqHz3vgIDvwoXLGqB11Yia17/CE882MbLFdqxxkB+b2jFE7qt0Lr/z1Q7Z4wkPOYneEBZMdfiyYZA8eozMjj9GZkYgdBPRz9qCfMyMR30PAzMiuzYzMSMQOAvo5e9DPmZEFk8xIxA8IWDDJ0DxGZ0YnHqN5+LwHDrIDHypnjNpRJ2ZS+w5PON/MyBbbtcpBdmBuzxi1o9q98MpfP2SLJzzkLHZHWDDZ4ceCSfbgMToz8hidGYnYQUA/Zw/6OTMS8T0EzIzs2szIjETsIKCfswf9nBlZMMmMRPyAgAWTDM1jdGZ04jGah8974CA78KFyxqgddWImte/whPPNjGyxXascZAfm9oxRO6rdC6/89UO2eMJDzmJ3hAWTHX4smGQPHqMzI4/RmZGIHQT0c/agnzMjEd9DwMzIrs2MzEjEDgL6OXvQz5mRBZNAFBykAAAgAElEQVTMSMQPCFgwydA8RmdGJx6jefi8Bw6yAx8qZ4zaUSdmUvsOTzjfzMgW27XKQXZgbs8YtaPavfDKXz9kiyc85Cx2R1gw2eHHgkn24DE6M/IYnRmJ2EFAP2cP+jkzEvE9BMyM7NrMyIxE7CCgn7MH/ZwZWTDJjET8gIAFkwzNY3RmdOIxmofPe+AgO/ChcsaoHXViJrXv8ITzzYxssV2rHGQH5vaMUTuq3Quv/PVDtnjCQ85id4QFkx1+LJhkDx6jMyOP0ZmRiB0E9HP2oJ8zIxHfQ8DMyK7NjMxIxA4C+jl70M+ZkQWTzEjEDwhYMMnQPEZnRiceo3n4vAcOsgMfKmeM2lEnZlL7Dk8438zIFtu1ykF2YG7PGLWj2r3wyl8/ZIsnPOQsdkdYMNnhx4JJ9uAxOjPyGJ0ZidhBQD9nD/o5MxLxPQTMjOzazMiMROwgoJ+zB/2cGVkwyYxE/ICABZMMzWN0ZnTiMZqHz3vgIDvwoXLGqB11Yia17/CE882MbLFdqxxkB+b2jFE7qt0Lr/z1Q7Z4wkPOYneEBZMdfiyYZA8eozMjj9GZkYgdBPRz9qCfMyMR30PAzMiuzYzMSMQOAvo5e9DPmZEFk8xIxA8IWDDJ0DxGZ0YnHqN5+LwHDrIDHypnjNpRJ2ZS+w5PON/MyBbbtcpBdmBuzxi1o9q98MpfP2SLJzzkLHZHWDDZ4ceCSfbgMToz8hidGYnYQUA/Zw/6OTMS8T0EzIzs2szIjETsIKCfswf9nBlZMMmMRPyAgAWTDM1jdGZ04jGah8974CA78KFyxqgddWImte/whPPNjGyxXascZAfm9oxRO6rdC6/89UO2eMJDzmJ3hAWTHX4smGQPHqMzI4/RmZGIHQT0c/agnzMjEd9DwMzIrs2MzEjEDgL6OXvQz5mRBZPMSMQPCFgwydA8RmdGJx6jefi8Bw6yAx8qZ4zaUSdmUvsOTzjfzMgW27XKQXZgbs8YtaPavfDKXz9kiyc85Cx2R1gw2eHHgkn24DE6M/IYnRmJ2EFAP2cP+jkzEvE9BMyM7NrMyIxE7CCgn7MH/ZwZWTDJjET8gIAFkwzNY3RmdOIxmofPe+AgO/ChcsaoHXViJrXv8ITzzYxssV2rHGQH5vaMUTuq3Quv/PVDtnjCQ85id4QFkx1+LJhkDx6jMyOP0ZmRiB0E9HP2oJ8zIxHfQ8DMyK7NjMxIxA4C+jl70M+ZkQWTzEjEDwhYMMnQPEZnRiceo3n4vAcOsgMfKmeM2lEnZlL7Dk8438zIFtu1ykF2YG7PGLWj2r3wyl8/ZIsnPOQsdkdYMNnhx4JJ9uAxOjPyGJ0ZidhBQD9nD/o5MxLxPQTMjOzazMiMROwgoJ+zB/2cGVkwyYxE/ICABZMMzWN0ZnTiMZqHz3vgIDvwoXLGqB11Yia17/CE882MbLFdqxxkB+b2jFE7qt0Lr/z1Q7Z4wkPOYneEBZMdfiyYZA8eozMjj9GZkYgdBPRz9qCfMyMR30PAzMiuzYzMSMQOAvo5e9DPmZEFk8xIxA8IWDDJ0DxGZ0YnHqN5+LwHDrIDHypnjNpRJ2ZS+w5PON/MyBbbtcpBdmBuzxi1o9q98MpfP2SLJzzkLHZHWDDZ4ceCSfbgMToz8hidGYnYQUA/Zw/6OTMS8T0EzIzs2szIjETsIKCfswf9nBlZMMmMRPyAgAWTDM1jdGZ04jGah8974CA78KFyxqgddWImte/whPPNjGyxXascZAfm9oxRO6rdC6/89UO2eMJDzmJ3hAWTHX4smGQPHqMzI4/RmZGIHQT0c/agnzMjEd9DwMzIrs2MzEjEDgL6OXvQz5mRBZPMSMQPCFgwydBOPEa3H3Pbd2jnf+KjgDvohUxgFtGuJf2cPbQd5AxEmNuzGmjXantevG7pDtl120PbgX7OjvXCjNEToiyY7LD4j3/84792ZCKLOxM48Rjto8CdK0TuCCDwH//xH6sg/OMf/1iVj2QQQOC7Cfhb8rv93+n2//Ef//Ev2/Jdl9A2QHfIx4JJttT+KPCEB2kfNnIdPeHjjF6YeW73Q9tDO/8n9MKsEkSp1VwD7X5rO3jC3zBPuEO7jp4yt9v90PbQzv9EL+SpuD/CgskORxZMdni4exY+CtzdoPwRQKBNwIJJm7DzEUDgzgT8LXlne9+VuwWT7/J97LYWTDLqJzzmtu/QflD3YSPX6YmPAu06coeZ57YH/TzzICoTUKuZUbvf2g7M7ezY3zAzRu1eeIKHJ/TzrBp2R1kw2eHHgskOD3fPwkeBuxuUPwIItAlYMGkTdj4CCNyZgL8l72zvu3K3YPJdvo/d1oJJRv2Ex9z2HXwUyHXkw8aMUbuW2r3whI+tbQdP6IVZNYtq95tazTXWdvCEmfeEO+iF3AtP+LfnCf08M7U7yoLJDj8WTHZ4uHsWPgrc3aD8EUCgTcCCSZuw8xFA4M4E/C15Z3vflbsFk+/yfey2Fkwy6ic85rbv4MNGriMfNmaM2rXU7gUfKmee2x7adTS7pagneL77Hdr5P2HmPeEOJ2Zeu5bcIf+b0XZwohfyLfdHWDDZ4ciCyQ4Pd8/CR4G7G5Q/Agi0CVgwaRN2PgII3JmAvyXvbO+7crdg8l2+j93WgklG/YTH3PYdfBTIdWTBZMaoXUvtXjjxcaZ9h7aDJ/TCrJpFqdVcA+1+azt4wsx7wh3adfSUud3uh7aHdv4neiFPxf0RFkx2OLJgssPD3bPwUeDuBuWPAAJtAhZM2oSdjwACdybgb8k72/uu3C2YfJfvY7e1YJJRP+Ext32H9oO6Dxu5Tk98FGjXkTvMPLc96OeZB1GZgFrNjNr91nZgbmfH/oaZMWr3whM8PKGfZ9WwO8qCyQ4/Fkx2eLh7Fj4K3N2g/BFAoE3AgkmbsPMRQODOBPwteWd735W7BZPv8n3sthZMMuonPOa27+CjQK4jHzZmjNq11O6FJ3xsbTt4Qi/MqllUu9/Uaq6xtoMnzLwn3EEv5F54wr89T+jnmandURZMdvixYLLDw92z8FHg7gbljwACbQIWTNqEnY8AAncm4G/JO9v7rtwtmHyX72O3tWCSUT/hMbd9Bx82ch35sDFj1K6ldi/4UDnz3PbQrqPZLUU9wfPd79DO/wkz7wl3ODHz2rXkDvnfjLaDE72Qb7k/woLJDkcWTHZ4uHsWPgrc3aD8EUCgTcCCSZuw8xFA4M4E/C15Z3vflbsFk+/yfey2Fkwy6ic85rbv4KNAriMLJjNG7Vpq98KJjzPtO7QdPKEXZtUsSq3mGmj3W9vBE2beE+7QrqOnzO12P7Q9tPM/0Qt5Ku6PsGCyw5EFkx0e7p6FjwJ3Nyh/BBBoE7Bg0ibsfAQQuDMBf0ve2d535W7B5Lt8H7utBZOM+gmPue07tB/UfdjIdXrio0C7jtxh5rntQT/PPIjKBNRqZtTut7YDczs79jfMjFG7F57g4Qn9PKuG3VEWTHb4sWCyw8Pds/BR4O4G5Y8AAm0CFkzahJ2PAAJ3JuBvyTvb+67cLZh8l+9jt7VgklE/4TG3fQcfBXId+bAxY9SupXYvPOFja9vBE3phVs2i2v2mVnONtR08YeY94Q56IffCE/7teUI/z0ztjrJgssOPBZMdHu6ehY8CdzcofwQQaBOwYNIm7HwEELgzAX9L3tned+VuweS7fB+7rQWTjPoJj7ntO/iwkevIh40Zo3YttXvBh8qZ57aHdh3NbinqCZ7vfod2/k+YeU+4w4mZ164ld8j/ZrQdnOiFfMv9ERZMdjiyYLLDw92z8FHg7gbljwACbQJ/umDyj3/8449Sap//R8kIRgABBP6QgL8l/xCY8I8RsGDyMfTP/sUWTLLfE4+5OYvdEU/4KLCb8Cy7tge9wMOMwOej2r3w+RveIwMzI3tq1yoH2cErgocZp2ZU28Erd/2QDZ7wkLPYHWHBZIcfCyY7PNw9Cx8F7m5Q/ggg0CbQXgBpn9/m43wEEPhuAv6W/G7/d7q9BZM72bpRrhZMsiyP0ZnRicdoHj7vgYPswIfKGaN21ImZ1L7DE843M7LFdq1ykB2Y2zNG7ah2L7zy1w/Z4gkPOYvdERZMdvixYLLDw92z8FHg7gbljwACbQLtBZD2+W0+zkcAge8m4G/J7/Z/p9tbMLmTrRvlasEky/IYnRmdeIzm4fMeOMgOfKicMWpHnZhJ7Ts84XwzI1ts1yoH2YG5PWPUjmr3wit//ZAtnvCQs9gdYcFkhx8LJjs83D0LHwXublD+CCDQJtBeAGmf3+bjfAQQ+G4C/pb8bv93ur0FkzvZulGuFkyyLI/RmdGJx2gePu+Bg+zAh8oZo3bUiZnUvsMTzjczssV2rXKQHZjbM0btqHYvvPLXD9niCQ85i90RFkx2+LFgssPD3bPwUeDuBuWPAAJtAu0FkPb5bT7ORwCB7ybgb8nv9n+n21swuZOtG+VqwSTL8hidGZ14jObh8x44yA58qJwxakedmEntOzzhfDMjW2zXKgfZgbk9Y9SOavfCK3/9kC2e8JCz2B1hwWSHHwsmOzzcPQsfBe5uUP4IINAm0F4AaZ/f5uN8BBD4bgL+lvxu/3e6vQWTO9m6Ua4WTLIsj9GZ0YnHaB4+74GD7MCHyhmjdtSJmdS+wxPONzOyxXatcpAdmNszRu2odi+88tcP2eIJDzmL3REWTHb4sWCyw8Pds/BR4O4G5Y8AAm0C7QWQ9vltPs5HAIHvJuBvye/2f6fbWzC5k60b5WrBJMvyGJ0ZnXiM5uHzHjjIDnyonDFqR52YSe07POF8MyNbbNcqB9mBuT1j1I5q98Irf/2QLZ7wkLPYHWHBZIcfCyY7PNw9Cx8F7m5Q/ggg0CbQXgBpn9/m43wEEPhuAv6W/G7/d7q9BZM72bpRrhZMsiyP0ZnRicdoHj7vgYPswIfKGaN21ImZ1L7DE843M7LFdq1ykB2Y2zNG7ah2L7zy1w/Z4gkPOYvdERZMdvixYLLDw92z8FHg7gbljwACbQLtBZD2+W0+zkcAge8m4G/J7/Z/p9tbMLmTrRvlasEky/IYnRmdeIzm4fMeOMgOfKicMWpHnZhJ7Ts84XwzI1ts1yoH2YG5PWPUjmr3wit//ZAtnvCQs9gdYcFkhx8LJjs83D0LHwXublD+CCDQJtBeAGmf3+bjfAQQ+G4C/pb8bv93ur0FkzvZulGuFkyyLI/RmdGJx2gePu+Bg+zAh8oZo3bUiZnUvsMTzjczssV2rXKQHZjbM0btqHYvvPLXD9niCQ85i90RFkx2+LFgssPD3bPwUeDuBuWPAAJtAu0FkPb5bT7ORwCB7ybgb8nv9n+n21swuZOtG+VqwSTL8hidGZ14jObh8x44yA58qJwxakedmEntOzzhfDMjW2zXKgfZgbk9Y9SOavfCK3/9kC2e8JCz2B1hwWSHHwsmOzzcPQsfBe5uUP4IINAm0F4AaZ/f5uN8BBD4bgL+lvxu/3e6vQWTO9m6Ua4WTLIsj9GZ0YnHaB4+74GD7MCHyhmjdtSJmdS+wxPONzOyxXatcpAdmNszRu2odi+88tcP2eIJDzmL3REWTHb4ecKCSftB+t/+7d/qsu5+h3b+LwFtD+6Qy7zt4JVB24M7ZM9tB/o5O/hJxJ8umPzXf/3XT37NH/1Mu9/UatbRdmBuZwdm3oyRfs6c9HNmdCLCgskJyl/4OyyYZOkeozOjE4/RPHzeAwfZgQ+VM0btqBMzqX2HJ5xvZmSL7VrlIDswt2eM2lHtXnjlrx+yxRMecha7IyyY7PBjwSR78JibGfkokBk94QOTXph5bvdD20M7/yf0wok7zKrtn1EWTP6U2Cz+7v3Wzv9FsT0z3CHXatvBiZnnDtmzXsiMTkRYMDlB+Qt/hwWTLN1jdGZ04jGah8974CA78KFyxqgddWImte/whPPNjGyxXascZAfm9oxRO6rdC6/89UO2eMJDzmJ3hAWTHX4smGQPHnMzIx8FMqMnfJzRCzPP7X5oe2jn/4ReOHGHWbX9M8qCyZ8Sm8Xfvd/a+b8otmeGO+RabTs4MfPcIXvWC5nRiQgLJicof+HvsGCSpXuMzoxOPEbz8HkPHGQHPlTOGLWjTsyk9h2ecL6ZkS22a5WD7MDcnjFqR7V74ZW/fsgWT3jIWeyOsGCyw48Fk+zBY25m5KNAZvSEjzN6Yea53Q9tD+38n9ALJ+4wq7Z/Rlkw+VNis/i791s7/xfF9sxwh1yrbQcnZp47ZM96ITM6EWHB5ATlL/wdFkyydI/RmdGJx2gePu+Bg+zAh8oZo3bUiZnUvsMTzjczssV2rXKQHZjbM0btqHYvvPLXD9niCQ85i90RFkx2+LFgkj14zM2MfBTIjJ7wcUYvzDy3+6HtoZ3/E3rhxB1m1fbPKAsmf0psFn/3fmvn/6LYnhnukGu17eDEzHOH7FkvZEYnIiyYnKD8hb/DgkmW7jE6MzrxGM3D5z1wkB34UDlj1I46MZPad3jC+WZGttiuVQ6yA3N7xqgd1e6FV/76IVs84SFnsTvCgskOPxZMsgePuZmRjwKZ0RM+zuiFmed2P7Q9tPN/Qi+cuMOs2v4ZZcHkT4nN4u/eb+38XxTbM8Mdcq22HZyYee6QPeuFzOhEhAWTE5S/8HdYMMnSPUZnRiceo3n4vAcOsgMfKmeM2lEnZlL7Dk8438zIFtu1ykF2YG7PGLWj2r3wyl8/ZIsnPOQsdkdYMNnhx4JJ9uAxNzPyUSAzesLHGb0w89zuh7aHdv5P6IUTd5hV2z+jLJj8KbFZ/N37rZ3/i2J7ZrhDrtW2gxMzzx2yZ72QGZ2IsGBygvIX/g4LJlm6x+jM6MRjNA+f98BBduBD5YxRO+rETGrf4QnnmxnZYrtWOcgOzO0Zo3ZUuxde+euHbPGEh5zF7ggLJjv8WDDJHjzmZkY+CmRGT/g4oxdmntv90PbQzv8JvXDiDrNq+2eUBZM/JTaLv3u/tfN/UWzPDHfItdp2cGLmuUP2rBcyoxMRFkxOUP7C32HBJEv3GJ0ZnXiM5uHzHjjIDnyonDFqR52YSe07POF8MyNbbNcqB9mBuT1j1I5q98Irf/2QLZ7wkLPYHWHBZIcfCybZg8fczMhHgczoCR9n9MLMc7sf2h7a+T+hF07cYVZt/4yyYPKnxGbxd++3dv4viu2Z4Q65VtsOTsw8d8ie9UJmdCLCgskJyl/4OyyYZOkeozOjE4/RPHzeAwfZgQ+VM0btqBMzqX2HJ5xvZmSL7VrlIDswt2eM2lHtXnjlrx+yxRMecha7IyyY7PBjwSR78JibGfkokBk94eOMXph5bvdD20M7/yf0wok7zKrtn1EWTP6U2Cz+7v3Wzv9FsT0z3CHXatvBiZnnDtmzXsiMTkRYMDlB+Qt/hwWTLN1jdGZ04jGah8974CA78KFyxqgddWImte/whPPNjGyxXascZAfm9oxRO6rdC6/89UO2eMJDzmJ3hAWTHX4smGQPHnMzIx8FMqMnfJzRCzPP7X5oe2jn/4ReOHGHWbX9M8qCyZ8Sm8Xfvd/a+b8otmeGO+RabTs4MfPcIXvWC5nRiQgLJicof+HvsGCSpXuMzoxOPEbz8HkPHGQHPlTOGLWjTsyk9h2ecL6ZkS22a5WD7MDcnjFqR7V74ZW/fsgWT3jIWeyOsGCyw48Fk+zBY25m5KNAZvSEjzN6Yea53Q9tD+38n9ALJ+4wq7Z/Rlkw+VNis/i791s7/xfF9sxwh1yrbQcnZp47ZM96ITM6EWHB5ATlL/wdFkyydI/RmdGJx2gePu+Bg+zAh8oZo3bUiZnUvsMTzjczssV2rXKQHZjbM0btqHYvvPLXD9niCQ85i90RFkx2+LFgkj14zM2MfBTIjJ7wcUYvzDy3+6HtoZ3/E3rhxB1m1fbPKAsmf0psFn/3fmvn/6LYnhnukGu17eDEzHOH7FkvZEYnIiyYnKD8hb/DgkmW7jE6MzrxGM3D5z1wkB34UDlj1I46MZPad3jC+WZGttiuVQ6yA3N7xqgd1e6FV/76IVs84SFnsTvCgskOP09YMNlB8ruzeMJHge826PYIILCNwJ8ujPxp/v/4xz/+9EfEI4AAAjUC/pasoXXwmwlYMHkzUMf9ImDBJFeCx+jM6MRjNA+f98BBdvB/5ur/6/8zC/xhFA8ZXNtBzkDEi4BazXXQrlUOsgNze8aoHdXuBTNpZvCEh1kme6MsmOxwY8Fkh4e7Z+GjwN0Nyh8BBLYRsGCyzYh8EECgScDfkk26zn4nAQsm76TprP8mYMEkF4OPM5nRicdoHj7vgYPswIfKGaN21ImZ1L7DE843M7LFdq1ykB2Y2zNG7ah2L7zy1w/Z4gkPOYvdERZMdvixYLLDw92z8FHg7gbljwAC2whYMNlmRD4IINAk4G/JJl1nv5OABZN30nTWfxOwYJKLwWN0ZnTiMZqHz3vgIDvwoXLGqB11Yia17/CE882MbLFdqxxkB+b2jFE7qt0Lr/z1Q7Z4wkPOYneEBZMdfiyY7PBw9yx8FLi7QfkjgMA2AhZMthmRDwIINAn4W7JJ19nvJGDB5J00nfXfBCyY5GLwGJ0ZnXiM5uHzHjjIDnyonDFqR52YSe07POF8MyNbbNcqB9mBuT1j1I5q98Irf/2QLZ7wkLPYHWHBZIcfCyY7PNw9Cx8F7m5Q/gggsI2ABZNtRuSDAAJNAv6WbNJ19jsJWDB5J01n/TcBCya5GDxGZ0YnHqN5+LwHDrIDHypnjNpRJ2ZS+w5PON/MyBbbtcpBdmBuzxi1o9q98MpfP2SLJzzkLHZHWDDZ4ceCyQ4Pd8/CR4G7G5Q/AghsI2DBZJsR+SCAQJOAvyWbdJ39TgIWTN5J01n/TaC9YOIhV7EhcI5A+6OAfp655GHGSRQCCPyv/2Ve7KgCHnZ4kAUC7yBQ7+d///d/eUeezrhGwILJNX5++hcBHwVUAgIIIPBeAhZM3svTaQggsJuAvyV3+5HdPwlYMFENFQIWTCpYHYrARwjUH9T/839/5F53+6U83M2YfBH4HAHz4nPs/5+/mYcdHmSBwDsI1PvZgsk7NF0+w4LJZYQOsGCiBhBAAIG3E7Bg8nakDkQAgcUELJgsliO1/x8CFkwURIWABZMKVoci8BEC9Qd1CyYjrzyMMAlCAIH/5b9gsqUIzO0tJuSBwHUC9X62YHJd0htOsGDyBoiO8F8wUQMIIIDAmwlYMHkzUMchgMBqAhZMVuuR3P+DgAUT5VAhYMGkgtWhCHyEQP1B3YLJyCsPI0yCEEDAgsmaGjC316iQCAKXCdT72YLJZUfvOMCCyTsoOsNHATWAAAIIvJeABZP38nQaAgjsJuBvyd1+ZPdPAhZMVEOFgAWTClaHIvARAvUHdQsmI688jDAJQgABCyZrasDcXqNCIghcJlDvZwsmlx294wALJu+g6AwfBdQAAggg8F4CFkzey9NpCCCwm4C/JXf7kd0/CVgwUQ0VAhZMKlgdisBHCNQf1C2YjLzyMMIkCAEELJisqQFze40KiSBwmUC9ny2YXHb0jgMsmLyDojN8FFADCCCAwHsJWDB5L0+nIYDAbgL+ltztR3b/JGDBRDVUCFgwqWB1KAIfIVB/ULdgMvLKwwiTIAQQsGCypgbM7TUqJILAZQL1frZgctnROw6wYPIOis7wUUANIIAAAn9PwMKICkEAAQT+/xPwt6TquAsBCyZ3MXWzPC2Y3EyYdBH4GwL1B3ULJqP642GESRACCFgwWVMD5vYaFRJB4DKBej9bMLns6B0HWDB5B0Vn+CigBhBAAAELJmoAAQQQ+CkBf0v+lJyfO03Agslp4l/y+yyYfIlo1/wKAvUHdQsmozriYYRJEAIIWDBZUwPm9hoVEkHgMoF6P1swuezoHQdYMHkHRWf4KKAGEEAAAQsmagABBBD4KQF/S/6UnJ87TcCCyWniX/L7LJh8iWjX/AoC9Qd1CyajOuJhhEkQAghYMFlTA+b2GhUSQeAygXo/WzC57OgdB1gweQdFZ/gooAYQQAABCyZqAAEEEPgpAX9L/pScnztNwILJaeJf8vssmHyJaNf8CgL1B3ULJqM64mGESRACCFgwWVMD5vYaFRJB4DKBej9bMLns6B0HWDB5B0Vn+CigBhBAAAELJmoAAQQQ+CkBf0v+lJyfO03Agslp4l/y+yyYfIlo1/wKAvUHdQsmozriYYRJEAIIWDBZUwPm9hoVEkHgMoF6P1swuezoHQdYMHkHRWf4KKAGEEAAAQsmagABBBD4KQF/S/6UnJ87TcCCyWniX/L7LJh8iWjX/AoC9Qd1CyajOuJhhEkQAghYMFlTA+b2GhUSQeAygXo/WzC57OgdB1gweQdFZ/gooAYQQAABCyZqAAEEEPgpAX9L/pScnztNwILJaeJf8vssmHyJaNf8CgL1B3ULJqM64mGESRACCFgwWVMD5vYaFRJB4DKBej9bMLns6B0HWDB5B0Vn+CigBhBAAAELJmoAAQQQ+CkBf0v+lJyfO03Agslp4l/y+yyYfIlo1/wKAvUHdQsmozriYYRJEAIIWDBZUwPm9hoVEkHgMoF6P1swuezoHQdYMHkHRWf4KKAGEEAAAQsmagABBBD4KQF/S/6UnJ87TcCCyWniX/L7LJh8iWjX/AoC9Qd1CyajOuJhhEkQAghYMFlTA+b2GhUSQeAygXo/WzC57OgdB1gweQdFZ/gooAYQQAABCyZqAAEEEPgpAX9L/pScnztNwILJaeJf8vssmHyJaNf8CgL1B3ULJqM64mGESRACCFgwWVMD5vYaFRJB4DKBej9bMLns6B0HWDB5B0Vn+CigBhBAAAELJmoAAQQQ+CkBf0v+lJyfO03Agslp4l/y+yyYfIlo1/wKAvUHdQsmozriYYRJEAIIWDBZUwPm9hoVEkHgMoF6P1swuezoHQdYMHkHRWf4KKAGEEAAAQsmagABBBD4KQF/S/6UnJ87TcCCyWniXy04EAAAACAASURBVPL7LJh8iWjX/AoC9Qd1CyajOuJhhEkQAghYMFlTA+b2GhUSQeAygXo/WzC57OgdB1gweQdFZ/gooAYQQAABBBBAAAEEfkrA35I/JefnThOwYHKa+Jf8PgsmXyLaNb+CQP1B3YLJqI54GGEShAACFkzW1IC5vUaFRBC4TKDezxZMLjt6xwEWTN5B0Rk+CqgBBBBAAAEEEEAAgZ8S8LfkT8n5udMELJicJv4lv8+CyZeIds2vIFB/ULdgMqojHkaYBCGAgAWTNTVgbq9RIREELhOo97MFk8uO3nGABZN3UHSGjwJqAAEEEEAAAQQQQOCnBPwt+VNyfu40AQsmp4l/ye+zYPIlol3zKwjUH9QtmIzqiIcRJkEIIGDBZE0NmNtrVEgEgcsE6v1sweSyo3ccYMHkHRSd4aOAGkAAAQQQQAABBBD4KQF/S/6UnJ87TcCCyWniX/L7LJh8iWjX/AoC9Qd1CyajOuJhhEkQAghYMFlTA+b2GhUSQeAygXo/WzC57OgdB1gweQdFZ/gooAYQQAABBBBAAAEEfkrA35I/JefnThOwYHKa+Jf8PgsmXyLaNb+CQP1B3YLJqI54GGEShAACFkzW1IC5vUaFRBC4TKDezxZMLjt6xwEWTN5B0Rk+CqgBBBBAAAEEEEAAgZ8S8LfkT8n5udMELJicJv4lv8+CyZeIds2vIFB/ULdgMqojHkaYBCGAgAWTNTVgbq9RIREELhOo97MFk8uO3nGABZN3UHSGjwJqAAEEEEAAAQQQQOCnBPwt+VNyfu40AQsmp4l/ye+zYPIlol3zKwjUH9QtmIzqiIcRJkEIIGDBZE0NmNtrVEgEgcsE6v1sweSyo3ccYMHkHRSd4aOAGkAAAQQQQAABBBD4KQF/S/6UnJ87TcCCyWniX/L7LJh8iWjX/AoC9Qd1CyajOuJhhEkQAghYMFlTA+b2GhUSQeAygXo/WzC57OgdB1gweQdFZ/gooAYQQAABBBBAAAEEfkrA35I/JefnThOwYHKa+Jf8PgsmXyLaNb+CQP1B3YLJqI54GGEShAACFkzW1IC5vUaFRBC4TKDezxZMLjt6xwEWTN5B0Rk+CqgBBBBAAAEEEEAAgZ8S8LfkT8n5udMELJicJv4lv8+CyZeIds2vIFB/ULdgMqojHkaYBCGAgAWTNTVgbq9RIREELhOo97MFk8uO3nGABZN3UHSGjwJqAAEEEEAAAQQQQOCnBPwt+VNyfu40AQsmp4l/ye+zYPIlol3zKwjUH9QtmIzqiIcRJkEIIGDBZE0NmNtrVEgEgcsE6v1sweSyo3ccYMHkHRSd4aOAGkAAAQQQQAABBBD4KQF/S/6UnJ87TcCCyWniX/L7LJh8iWjX/AoC9Qd1CyajOuJhhEkQAghYMFlTA+b2GhUSQeAygXo/WzC57OgdB/zXf/3Xf73jnCef8W//9m9Pvt5b7uajwFswXj6k7UEvzBTxMOPUjGo7aOb+pLPNjGyzXascZAevCB5mnJpRbQev3PVDNnjCQ85id8S//Mu//Mu2DNcltA3QHfJ5woJJ/RHxwEf1u9+hnf+rl/617MEd8sRqO3hl0PbgDtlz24F+zg5ORPA8o9yeGW0P7fzN7e+oI3N75lk/Z06PmEkWTLLoAxEWTDJkj9GZ0YnHaB4+74GD7MCHyhmjdtSJmdS+wxPONzOyxXatcpAdmNszRu2odi+88tcP2eIJDzmL3REWTHb7uW12Fkyyukc8hFrOiKLbHwWe8HFGL8Qy+j8B7Vpqe2jn/4ReOHGHWbX9PIrnGbu791s7/yfMvCfcQT/r5xmBHNWupUfMJAsmuZAORFgwyZA9RmdGJx6jefi8Bw6yAx8qZ4zaUSdmUvsOTzjfzMgW27XKQXZgbs8YtaPavfDKXz9kiyc85Cx2R1gw2e3nttlZMMnqHvEQasEkim4/qL8SaNdS+w7t/J/wke8Jd2jX0RN64cQd4tC6GMDzDGB77rU9tPN/wsx7wh3adXRi5rlDnkn6OTM60s8WTGYiylEWTDJgj9GZ0YnHaB4+74GD7MCHyhmjdtSJmdS+wxPONzOyxXatcpAdmNszRu2odi+88tcP2eIJDzmL3REWTHb7uW12FkyyOo+5mZGPApnREz7O6IWZ53Y/tD20839CL5y4w6zafh7F84zd3futnf+LYruW3CHXatvBiZnnDtmzXsiMjswkCyYzEeUoCyYZsMfozOjEYzQPn/fAQXbgQ+WMUTvqxExq3+EJ55sZ2WK7VjnIDsztGaN2VLsXXvnrh2zxhIecxe4ICya7/dw2OwsmWZ3H3MzIR4HM6AkfZ/TCzHO7H9oe2vk/oRdO3GFWbT+P4nnG7u791s7/RbFdS+6Qa7Xt4MTMc4fsWS9kRkdmkgWTmYhylAWTDNhjdGZ04jGah8974CA78KFyxqgddWImte/whPPNjGyxXascZAfm9oxRO6rdC6/89UO2eMJDzmJ3hAWT3X5um50Fk6zOY25m5KNAZvSEjzN6Yea53Q9tD+38n9ALJ+4wq7afR/E8Y3f3fmvn/6LYriV3yLXadnBi5rlD9qwXMqMjM8mCyUxEOcqCSQbsMTozOvEYzcPnPXCQHfhQOWPUjjoxk9p3eML5Zka22K5VDrIDc3vGqB3V7oVX/vohWzzhIWexO8KCyW4/t83OgklW5zE3M/JRIDN6wscZvTDz3O6Htod2/k/ohRN3mFXbz6N4nrG7e7+1839RbNeSO+RabTs4MfPcIXvWC5nRkZlkwWQmohxlwSQD9hidGZ14jObh8x44yA58qJwxakedmEntOzzhfDMjW2zXKgfZgbk9Y9SOavfCK3/9kC2e8JCz2B1hwWS3n9tmZ8Ekq/OYmxn5KJAZPeHjjF6YeW73Q9tDO/8n9MKJO8yq7edRPM/Y3b3f2vm/KLZryR1yrbYdnJh57pA964XM6MhMsmAyE1GOsmCSAXuMzoxOPEbz8HkPHGQHPlTOGLWjTsyk9h2ecL6ZkS22a5WD7MDcnjFqR7V74ZW/fsgWT3jIWeyOsGCy289ts7NgktV5zM2MfBTIjJ7wcUYvzDy3+6HtoZ3/E3rhxB1m1fbzKJ5n7O7eb+38XxTbteQOuVbbDk7MPHfInvVCZnRkJlkwmYkoR1kwyYA9RmdGJx6jefi8Bw6yAx8qZ4zaUSdmUvsOTzjfzMgW27XKQXZgbs8YtaPavfDKXz9kiyc85Cx2R1gw2e3nttlZMMnqPOZmRj4KZEZP+DijF2ae2/3Q9tDO/wm9cOIOs2r7eRTPM3Z377d2/i+K7Vpyh1yrbQcnZp47ZM96ITM6MpMsmMxElKMsmGTAHqMzoxOP0Tx83gMH2YEPlTNG7agTM6l9hyecb2Zki+1a5SA7MLdnjNpR7V545a8fssUTHnIWuyMsmOz2c9vsLJhkdR5zMyMfBTKjJ3yc0Qszz+1+aHto5/+EXjhxh1m1/TyK5xm7u/dbO/8XxXYtuUOu1baDEzPPHbJnvZAZHZlJFkxmIspRFkwyYI/RmdGJx2gePu+Bg+zAh8oZo3bUiZnUvsMTzjczssV2rXKQHZjbM0btqHYvvPLXD9niCQ85i90RFkx2+7ltdhZMsjqPuZmRjwKZ0RM+zuiFmed2P7Q9tPN/Qi+cuMOs2n4exfOM3d37rZ3/i2K7ltwh12rbwYmZ5w7Zs17IjI7MJAsmMxHlKAsmGbDH6MzoxGM0D5/3wEF24EPljFE76sRMat/hCeebGdliu1Y5yA7M7RmjdlS7F17564ds8YSHnMXuCAsmu/3cNrsnLJjcFr7EEXgzgfbHmRMfNt6M5CPH8fAR7H4pArckYF7s0MbDDg+yQOAdBOr9bMHkHZoun2HBJCP0GJ0ZnXiM5uHzHjjIDnyonDFqR52YSe07POF8MyNbbNcqB9mBuT1j1I5q98Irf/2QLZ7wkLPYHWHBZLef22ZnweS26iSOwF8I1B/U//N/oz4gwMMAkhAEEPg/BMyLHYXAww4PskDgHQTq/WzB5B2aLp9hwSQj9BidGZ14jObh8x44yA58qJwxakedmEntOzzhfDMjW2zXKgfZgbk9Y9SOavfCK3/9kC2e8JCz2B1hwWS3n9tmZ8HktuokjsBfCNQf1C2YjKqOhxEmQQggYMFkTQ2Y22tUSASBywTq/WzB5LKjdxxgwSRT9BidGZ14jObh8x44yA58qJwxakedmEntOzzhfDMjW2zXKgfZgbk9Y9SOavfCK3/9kC2e8JCz2B1hwWS3n9tmZ8HktuokjsBfCNQf1C2YjKqOhxEmQQggYMFkTQ2Y22tUSASBywTq/WzB5LKjdxxgwSRT9BidGZ14jObh8x44yA58qJwxakedmEntOzzhfDMjW2zXKgfZgbk9Y9SOavfCK3/9kC2e8JCz2B1hwWS3n9tmZ8HktuokjsBfCNQf1C2YjKqOhxEmQQggYMFkTQ2Y22tUSASBywTq/WzB5LKjdxxgwSRT9BidGZ14jObh8x44yA58qJwxakedmEntOzzhfDMjW2zXKgfZgbk9Y9SOavfCK3/9kC2e8JCz2B1hwWS3n9tmZ8HktuokjsBfCNQf1C2YjKqOhxEmQQggYMFkTQ2Y22tUSASBywTq/WzB5LKjdxxgwSRT9BidGZ14jObh8x44yA58qJwxakedmEntOzzhfDMjW2zXKgfZgbk9Y9SOavfCK3/9kC2e8JCz2B1hwWS3n9tmZ8HktuokjsBfCNQf1C2YjKqOhxEmQQggYMFkTQ2Y22tUSASBywTq/WzB5LKjdxxgwSRT9BidGZ14jObh8x44yA58qJwxakedmEntOzzhfDMjW2zXKgfZgbk9Y9SOavfCK3/9kC2e8JCz2B1hwWS3n9tmZ8HktuokjsBfCNQf1C2YjKqOhxEmQQggYMFkTQ2Y22tUSASBywTq/WzB5LKjdxxgwSRT9BidGZ14jObh8x44yA58qJwxakedmEntOzzhfDMjW2zXKgfZgbk9Y9SOavfCK3/9kC2e8JCz2B1hwWS3n9tmZ8HktuokjsBfCNQf1C2YjKqOhxEmQQggYMFkTQ2Y22tUSASBywTq/WzB5LKjdxxgwSRT9BidGZ14jObh8x44yA58qJwxakedmEntOzzhfDMjW2zXKgfZgbk9Y9SOavfCK3/9kC2e8JCz2B1hwWS3n9tmZ8HktuokjsBfCNQf1C2YjKqOhxEmQQggYMFkTQ2Y22tUSASBywTq/WzB5LKjdxxgwSRT9BidGZ14jObh8x44yA58qJwxakedmEntOzzhfDMjW2zXKgfZgbk9Y9SOavfCK3/9kC2e8JCz2B1hwWS3n9tmZ8HktuokjsBfCNQf1C2YjKqOhxEmQQggYMFkTQ2Y22tUSASBywTq/WzB5LKjdxxgwSRT9BidGZ14jObh8x44yA58qJwxakedmEntOzzhfDMjW2zXKgfZgbk9Y9SOavfCK3/9kC2e8JCz2B1hwWS3n9tmZ8HktuokjsBfCNQf1C2YjKqOhxEmQQggYMFkTQ2Y22tUSASBywTq/WzB5LKjdxxgwSRT9BidGZ14jObh8x44yA58qJwxakedmEntOzzhfDMjW2zXKgfZgbk9Y9SOavfCK3/9kC2e8JCz2B1hwWS3n9tmZ8HktuokjsBfCNQf1C2YjKqOhxEmQQggYMFkTQ2Y22tUSASBywTq/WzB5LKjdxxgwSRTPPEY3X7Mbd+hnf+JjwLuoBcygVlEu5b0c/bQdpAzEGFuz2qgXavtefG6pTtk120PbQf6OTvWCzNGT4iyYPIEiwvvYMFkoRQpIfBDAvUHdQsmIzM8jDAJQgABCyZrasDcXqNCIghcJlDvZwsmlx294wALJpli+6PAEx6kfdjIdfSEjzN6Yea53Q9tD+38n9ALs0oQpVZzDbT7re3gCX/DPOEO7Tp6ytxu90PbQzv/E72Qp+L+CAsm+x3dMkMLJrfUJmkEfkug/qBuwWRUeTyMMAlCAAELJmtqwNxeo0IiCFwmUO9nCyaXHb3jAAsmmeITHnPbd2g/qPuwkev0xEeBdh25w8xz24N+nnkQlQmo1cyo3W9tB+Z2duxvmBmjdi88wcMT+nlWDbujLJjs9nPb7CyY3FadxBH4C4H6g7oFk1HV8TDCJAgBBCyYrKkBc3uNCokgcJlAvZ8tmFx29I4DLJhkik94zG3fwUeBXEc+bMwYtWup3QtP+NjadvCEXphVs6h2v6nVXGNtB0+YeU+4g17IvfCEf3ue0M8zU7ujLJjs9nPb7CyY3FadxBH4C4H6g7oFk1HV8TDCJAgBBCyYrKkBc3uNCokgcJlAvZ8tmFx29I4DLJhkik94zG3fwYeNXEc+bMwYtWup3Qs+VM48tz2062h2S1FP8Hz3O7Tzf8LMe8IdTsy8di25Q/43o+3gRC/kW+6PsGCy39EtM7RgckttkkbgtwTqD+oWTEaVx8MIkyAEELBgsqYGzO01KiSCwGUC9X62YHLZ0TsOsGCSKT7hMbd9Bx8Fch1ZMJkxatdSuxdOfJxp36Ht4Am9MKtmUWo110C739oOnjDznnCHdh09ZW63+6HtoZ3/iV7IU3F/hAWT/Y5umaEFk1tqkzQCvyVQf1C3YDKqPB5GmAQhgIAFkzU1YG6vUSERBC4TqPezBZPLjt5xgAWTTPEJj7ntO7Qf1H3YyHV64qNAu47cYea57UE/zzyIygTUambU7re2A3M7O/Y3zIxRuxee4OEJ/Tyrht1RFkx2+7ltdhZMbqtO4gj8hUD9Qd2CyajqeBhhEoQAAhZM1tSAub1GhUQQuEyg3s8WTC47escBFkwyxSc85rbv4KNAriMfNmaM2rXU7oUnfGxtO3hCL8yqWVS739RqrrG2gyfMvCfcQS/kXnjCvz1P6OeZqd1RFkx2+7ltdhZMbqtO4gj8hUD9Qd2CyajqeBhhEoQAAhZM1tSAub1GhUQQuEyg3s8WTC47escBFkwyxSc85rbv4MNGriMfNmaM2rXU7gUfKmee2x7adTS7pagneL77Hdr5P2HmPeEOJ2Zeu5bcIf+b0XZwohfyLfdHWDDZ7+iWGVowuaU2SSPwWwL1B3ULJqPK42GESRACCFgwWVMD5vYaFRJB4DKBej9bMLns6B0HWDDJFJ/wmNu+g48CuY4smMwYtWup3QsnPs6079B28IRemFWzKLWaa6Ddb20HT5h5T7hDu46eMrfb/dD20M7/RC/kqbg/woLJfke3zNCCyS21SRqB3xKoP6hbMBlVHg8jTIIQQMCCyZoaMLfXqJAIApcJ1PvZgsllR+84wIJJpviEx9z2HdoP6j5s5Do98VGgXUfuMPPc9qCfZx5EZQJqNTNq91vbgbmdHfsbZsao3QtP8PCEfp5Vw+4oCya7/dw2Owsmt1UncQT+QqD+oG7BZFR1PIwwCUIAAQsma2rA3F6jQiIIXCZQ72cLJpcdveMACyaZ4hMec9t38FEg15EPGzNG7Vpq98ITPra2HTyhF2bVLKrdb2o111jbwRNm3hPuoBdyLzzh354n9PPM1O4oCya7/dw2Owsmt1UncQT+QqD+oG7BZFR1PIwwCUIAAQsma2rA3F6jQiIIXCZQ72cLJpcdveMACyaZ4onH3JzF7ognfNjYTXiWXduDXuBhRuDzUe1e+PwN75GBmZE9tWuVg+zgFcHDjFMzqu3glbt+yAZPeMhZ7I6wYLLbz22zs2ByW3USR+AvBOoP6hZMRlXHwwiTIAQQsGCypgbM7TUqJILAZQL1frZgctnROw6wYJIpeozOjE48RvPweQ8cZAc+VM4YtaNOzKT2HZ5wvpmRLbZrlYPswNyeMWpHtXvhlb9+yBZPeMhZ7I6wYLLbz22zs2ByW3USR+AvBOoP6hZMRlXHwwiTIAQQsGCypgbM7TUqJILAZQL1frZgctnROw6wYJIpeozOjE48RvPweQ8cZAc+VM4YtaNOzKT2HZ5wvpmRLbZrlYPswNyeMWpHtXvhlb9+yBZPeMhZ7I6wYLLbz22zs2ByW3USR+AvBOoP6hZMRlXHwwiTIAQQsGCypgbM7TUqJILAZQL1frZgctnROw6wYJIpeozOjE48RvPweQ8cZAc+VM4YtaNOzKT2HZ5wvpmRLbZrlYPswNyeMWpHtXvhlb9+yBZPeMhZ7I6wYLLbz22zs2ByW3USR+AvBOoP6hZMRlXHwwiTIAQQsGCypgbM7TUqJILAZQL1frZgctnROw6wYJIpeozOjE48RvPweQ8cZAc+VM4YtaNOzKT2HZ5wvpmRLbZrlYPswNyeMWpHtXvhlb9+yBZPeMhZ7I6wYLLbz22zs2ByW3USR+AvBOoP6hZMRlXHwwiTIAQQsGCypgbM7TUqJILAZQL1frZgctnROw6wYJIpeozOjE48RvPweQ8cZAc+VM4YtaNOzKT2HZ5wvpmRLbZrlYPswNyeMWpHtXvhlb9+yBZPeMhZ7I6wYLLbz22zs2CyQ137IXTHLa9l8a+WGyLAdh1xEBUIWEKg3QtLrrk+DTNjvSIJ/t8E2jNDL+RSazvIGeyPUEczR+1a+lcLJjMR5SgLJhmwx+jM6MRjNA+f98BBduBD5YxRO+rETGrf4QnnmxnZYrtWOcgOzO0Zo3ZUuxde+euHbPGEh5zF7ggLJrv93DY7CyY71LUfQnfc8loWHtUzv3YdcZAdiNhBoN0LO265PwszY78jGf4i0J4ZeiFXWttBzmB/hDqaOWrXkgWTmYd2lAWTTNhjdGZ04jGah8974CA7eEW0+4GH7KHtIGcg4kVAreY6aNcqB9mBuT1j1I5q94KZNDN4wsMsk71RFkz2url1ZhZMduhrP4TuuOW1LDyqZ37tOuIgOxCxg0C7F3bccn8WZsZ+RzL8RaA9M/RCrrS2g5zB/gh1NHPUriULJjMP7SgLJpmwjzOZ0YnHaB4+74GD7OAV0e4HHrKHtoOcgYgXAbWa66BdqxxkB+b2jFE7qt0LZtLM4AkPs0z2Rlkw2evm1plZMNmhr/0QuuOW17LwqJ75teuIg+xAxA4C7V7Yccv9WZgZ+x3J8BeB9szQC7nS2g5yBvsj1NHMUbuWLJjMPLSjLJhkwj7OZEYnHqN5+LwHDrKDV0S7H3jIHtoOcgYiXgTUaq6Ddq1ykB2Y2zNG7ah2L5hJM4MnPMwy2RtlwWSvm1tnZsFkh772Q+iOW17LwqN65teuIw6yAxE7CLR7Ycct92dhZux3JMNfBNozQy/kSms7yBnsj1BHM0ftWrJgMvPQjrJgkgn7OJMZnXiM5uHzHjjIDl4R7X7gIXtoO8gZiHgRUKu5Dtq1ykF2YG7PGLWj2r1gJs0MnvAwy2RvlAWTvW5unZkFkx362g+hO255LQuP6plfu444yA5E7CDQ7oUdt9yfhZmx35EMfxFozwy9kCut7SBnsD9CHc0ctWvJgsnMQzvKgkkm7ONMZnTiMZqHz3vgIDt4RbT7gYfsoe0gZyDiRUCt5jpo1yoH2YG5PWPUjmr3gpk0M3jCwyyTvVEWTPa6uXVmFkx26Gs/hO645bUsPKpnfu064iA7ELGDQLsXdtxyfxZmxn5HMvxFoD0z9EKutLaDnMH+CHU0c9SuJQsmMw/tKAsmmbCPM5nRicdoHj7vgYPs4BXR7gcesoe2g5yBiBcBtZrroF2rHGQH5vaMUTuq3Qtm0szgCQ+zTPZGWTDZ6+bWmVkw2aGv/RC645bXsvConvm164iD7EDEDgLtXthxy/1ZmBn7HcnwF4H2zNALudLaDnIG+yPU0cxRu5YsmMw8tKMsmGTCPs5kRiceo3n4vAcOsoNXRLsfeMge2g5yBiJeBNRqroN2rXKQHZjbM0btqHYvmEkzgyc8zDLZG2XBZK+bW2dmwWSHvvZD6I5bXsvCo3rm164jDrIDETsItHthxy33Z2Fm7Hckw18E2jNDL+RKazvIGeyPUEczR+1asmAy89COsmCSCfs4kxmdeIzm4fMeOMgOXhHtfuAhe2g7yBmIeBFQq7kO2rXKQXZgbs8YtaPavWAmzQye8DDLZG+UBZO9bm6dmQWTHfraD6E7bnktC4/qmV+7jjjIDkTsINDuhR233J+FmbHfkQx/EWjPDL2QK63tIGewP0IdzRy1a8mCycxDO8qCSSbs40xmdOIxmofPe+AgO3hFtPuBh+yh7SBnIOJFQK3mOmjXKgfZgbk9Y9SOaveCmTQzeMLDLJO9URZM9rq5dWYWTHboaz+E7rjltSw8qmd+7TriIDsQsYNAuxd23HJ/FmbGfkcy/EWgPTP0Qq60toOcwf4IdTRz1K4lCyYzD+0oCyaZsI8zmdGJx2gePu+Bg+zgFdHuBx6yh7aDnIGIFwG1muugXascZAfm9oxRO6rdC2bSzOAJD7NM9kZZMNnr5taZWTDZoa/9ELrjltey8Kie+bXriIPsQMQOAu1e2HHL/VmYGfsdyfAXgfbM0Au50toOcgb7I9TRzFG7liyYzDy0oyyYZMI+zmRGJx6jefi8Bw6yg1dEux94yB7aDnIGIl4E1Gqug3atcpAdmNszRu2odi+YSTODJzzMMtkbZcFkr5tbZ2bBZIe+9kPojltey8KjeubXriMOsgMROwi0e2HHLfdnYWbsdyTDXwTaM0Mv5EprO8gZ7I9QRzNH7VqyYDLz0I6yYJIJ+ziTGZ14jObh8x44yA5eEe1+4CF7aDvIGYh4EVCruQ7atcpBdmBuzxi1o9q9YCbNDJ7wMMtkb5QFk71ubp2ZBZMd+toPoTtueS0Lj+qZX7uOOMgOROwg0O6FHbfcn4WZsd+RDH8RaM8MvZArre0gZ7A/Qh3NHLVryYLJzEM7yoJJJuzjTGZ04jGah8974CA7eEW0+4GH7KHtIGcg4kVAreY6aNcqB9mBuT1j1I5q94KZNDN4wsMsk71RFkz2url1ZhZMduhrP4TuuOW1LDyqZ37tOuIgOxCxg0C7F3bccn8WZsZ+RzL8RaA9C0eSpwAAIABJREFUM/RCrrS2g5zB/gh1NHPUriULJjMP7SgLJpmwjzOZ0YnHaB4+74GD7OAV0e4HHrKHtoOcgYgXAbWa66BdqxxkB+b2jFE7qt0LZtLM4AkPs0z2Rlkw2evm1plZMNmhr/0QuuOW17LwqJ75teuIg+xAxA4C7V7Yccv9WZgZ+x3J8BeB9szQC7nS2g5yBvsj1NHMUbuWLJjMPLSjLJhkwj7OZEYnHqN5+LwHDrKDV0S7H3jIHtoOcgYiXgTUaq6Ddq1ykB2Y2zNG7ah2L5hJM4MnPMwy2RtlwWSvm1tnZsFkh772Q+iOW17LwqN65teuIw6yAxE7CLR7Ycct92dhZux3JMNfBNozQy/kSms7yBnsj1BHM0ftWrJgMvPQjrJgkgn7OJMZnXiM5uHzHjjIDl4R7X7gIXtoO8gZiHgRUKu5Dtq1ykF2YG7PGLWj2r1gJs0MnvAwy2RvlAWTvW5unZkFkx362g+hO255LQuP6plfu444yA5E7CDQ7oUdt9yfhZmx35EMfxFozwy9kCut7SBnsD9CHc0ctWvJgsnMQzvKgkkm7ONMZnTiMZqHz3vgIDt4RbT7gYfsoe0gZyDiRUCt5jpo1yoH2YG5PWPUjmr3gpk0M3jCwyyTvVEWTPa6uXVmFkx26Gs/hO645bUsPKpnfu064iA7ELGDQLsXdtxyfxZmxn5HMvxFoD0z9EKutLaDnMH+CHU0c9SuJQsmMw/tKAsmmbCPM5nRicdoHj7vgYPs4BXR7gcesoe2g5yBiBcBtZrroF2rHGQH5vaMUTuq3Qtm0szgCQ+zTPZGWTDZ6+bWmVkw2aGv/RC645bXsvConvm164iD7EDEDgLtXthxy/1ZmBn7HcnwF4H2zNALudLaDnIG+yPU0cxRu5YsmMw8tKMsmGTCPs5kRiceo3n4vAcOsoNXRLsfeMge2g5yBiJeBNRqroN2rXKQHZjbM0btqHYvmEkzgyc8zDLZG2XBZK+bW2dmwWSHvvZD6I5bXsvCo3rm164jDrIDETsItHthxy33Z2Fm7Hckw18E2jNDL+RKazvIGeyPUEczR+1asmAy89COsmCSCfs4kxmdeIzm4fMeOMgOXhHtfuAhe2g7yBmIeBFQq7kO2rXKQXZgbs8YtaPavWAmzQye8DDLZG+UBZO9bm6dmQWTHfraD6E7bnktC4/qmV+7jjjIDkTsINDuhR233J+FmbHfkQx/EWjPDL2QK63tIGewP0IdzRy1a8mCycxDO8qCSSbs40xmdOIxmofPe+AgO3hFtPuBh+yh7SBnIOJFQK3mOmjXKgfZgbk9Y9SOaveCmTQzeMLDLJO9URZM9rq5dWYWTHboaz+E7rjltSw8qmd+7TriIDsQsYNAuxd23HJ/FmbGfkcy/EWgPTP0Qq60toOcwf4IdTRz1K4lCyYzD+0oCyaZsI8zmdGJx2gePu+Bg+zgFdHuBx6yh7aDnIGIFwG1muugXascZAfm9oxRO6rdC2bSzOAJD7NM9kZZMNnr5taZWTDZoa/9ELrjltey8Kie+bXriIPsQMQOAu1e2HHL/VmYGfsdyfAXgfbM0Au50toOcgb7I9TRzFG7liyYzDy0oyyYZMI+zmRGJx6jefi8Bw6yg1dEux94yB7aDnIGIl4E1Gqug3atcpAdmNszRu2odi+YSTODJzzMMtkbZcFkr5tbZ2bBZIe+9kPojltey8KjeubXriMOsgMROwi0e2HHLfdnYWbsdyTDXwTaM0Mv5EprO8gZ7I9QRzNH7VqyYDLz0I6yYJIJ+ziTGZ14jObh8x44yA5eEe1+4CF7aDvIGYh4EVCruQ7atcpBdmBuzxi1o9q9YCbNDJ7wMMtkb5QFk71ubp2ZBZMd+toPoTtueS0Lj+qZX7uOOMgOROwg0O6FHbfcn4WZsd+RDH8RaM8MvZArre0gZ7A/Qh3NHLVryYLJzEM7yoJJJuzjTGZ04jGah8974CA7eEW0+4GH7KHtIGcg4kVAreY6aNcqB9mBuT1j1I5q94KZNDN4wsMsk71RFkz2url1ZhZMduhrP4TuuOW1LDyqZ37tOuIgOxCxg0C7F3bccn8WZsZ+RzL8RaA9M/RCrrS2g5zB/gh1NHPUriULJjMP7SgLJpmwjzOZ0YnHaB4+74GD7OAV0e4HHrKHtoOcgYgXAbWa66BdqxxkB+b2jFE7qt0LZtLM4AkPs0z2Rlkw2evm1plZMNmhr/0QuuOW17LwqJ75teuIg+xAxA4C7V7Yccv9WZgZ+x3J8BeB9szQC7nS2g5yBvsj1NHMUbuWLJjMPLSjLJhkwj7OZEYnHqN5+LwHDrKDV0S7H3jIHtoOcgYiXgTUaq6Ddq1ykB2Y2zNG7ah2L5hJM4MnPMwy2RtlwWSvm1tnZsFkh772Q+iOW17LwqN65teuIw6yAxE7CLR7Ycct92dhZux3JMNfBNozQy/kSms7yBnsj1BHM0ftWrJgMvPQjrJgkgn7OJMZnXiM5uHzHjjIDl4R7X7gIXtoO8gZiHgRUKu5Dtq1ykF2YG7PGLWj2r1gJs0MnvAwy2RvlAWTvW5unZkFkx362g+hO255LQuP6plfu444yA5E7CDQ7oUdt9yfhZmx35EMfxFozwy9kCut7SBnsD9CHc0ctWvJgsnMQzvKgkkm7ONMZnTiMZqHz3vgIDt4RbT7gYfsoe0gZyDiRUCt5jpo1yoH2YG5PWPUjmr3gpk0M3jCwyyTvVEWTPa6uXVmFkx26Gs/hO645bUsPKpnfu064iA7ELGDQLsXdtxyfxZmxn5HMvxFoD0z9EKutLaDnMH+CHU0c9SuJQsmMw/tqPaCiQ8bbYPOR+CfBNofBfTzrNp4mHEShQACFtK21IC5vcWEPBC4TqDdzxZMrjtywm8IPGHBpP6I+J//u1477TvUL3DgF7Qf1U84uPsd2vk/5SNfu5baHtr5vzw/4Q4Hxt7tf8UTPN/9Du38ze1Zm7Y9mNszD3ePateRfp5ViAWTGad2lAWTNmHnI3COQPtB3YLJzCUPM06iEEDAgsmWGjC3t5iQBwLXCbT72YLJdUdOsGDyoxp4wmPujy6+7IfaHnycycLbDnzYyA5eEW0PemHmQVQmoFYzo3a/tR2Y29mxuT1j1O6FWRa7o/TzzE+7liyYzDy0oyyYtAk7H4FzBNoP6hZMZi55mHEShQACFky21IC5vcWEPBC4TqDdzxZMrjtywm8I+C+Y5LJ4wmNuvuX+iLaH9mP0Ez4wtR34UDnrw7YHvTDzICoTUKuZUbvf2g7M7ez4Cf/+P+UOM1t7o/TzzE19rv77v//LLBNRTQIWTJp0nY3AWQLtB3ULJjOfPMw4iUIAAQsmW2rA3N5iQh4IXCfQ7mcLJtcdOeE3BCyY5LJ4wmNuvuX+iLaH9mP0Ez7OtB34UDnrw7YHvTDzICoTUKuZUbvf2g7M7ez4Cf/+P+UOM1t7o/TzzE19rlowmYkoR1kwKQN2PAIHCbQf1C2YzGTyMOMkCgEELJhsqQFze4sJeSBwnUC7ny2YXHfkhN8QsGCSy+IJj7n5lvsj2h7aj9FP+DjTduBD5awP2x70wsyDqExArWZG7X5rOzC3s+Mn/Pv/lDvMbO2N0s8zN/W5asFkJqIcZcGkDNjxCBwk0H5Qt2Ayk8nDjJMoBBCwYLKlBsztLSbkgcB1Au1+tmBy3ZETfkPAgkkuiyc85uZb7o9oe2g/Rj/h40zbgQ+Vsz5se9ALMw+iMgG1mhm1+63twNzOjp/w7/9T7jCztTdKP8/c1OeqBZOZiHKUBZMyYMcjcJBA+0HdgslMJg8zTqIQQMCCyZYaMLe3mJAHAtcJtPvZgsl1R074DQELJrksnvCYm2+5P6Ltof0Y/YSPM20HPlTO+rDtQS/MPIjKBNRqZtTut7YDczs7fsK//0+5w8zW3ij9PHNTn6sWTGYiylEWTMqAHY/AQQLtB3ULJjOZPMw4iUIAAQsmW2rA3N5iQh4IXCfQ7mcLJtcdOeE3BCyY5LJ4wmNuvuX+iLaH9mP0Ez7OtB34UDnrw7YHvTDzICoTUKuZUbvf2g7M7ez4Cf/+P+UOM1t7o/TzzE19rlowmYkoR1kwKQN2PAIHCbQf1C2YzGTyMOMkCgEELJhsqQFze4sJeSBwnUC7ny2YXHfkhN8QsGCSy+IJj7n5lvsj2h7aj9FP+DjTduBD5awP2x70wsyDqExArWZG7X5rOzC3s+Mn/Pv/lDvMbO2N0s8zN/W5asFkJqIcZcGkDNjxCBwk0H5Qt2Ayk8nDjJMoBBCwYLKlBsztLSbkgcB1Au1+tmBy3ZETfkPAgkkuiyc85uZb7o9oe2g/Rj/h40zbgQ+Vsz5se9ALMw+iMgG1mhm1+63twNzOjp/w7/9T7jCztTdKP8/c1OeqBZOZiHKUBZMyYMcjcJBA+0HdgslMJg8zTqIQQMCCyZYaMLe3mJAHAtcJtPvZgsl1R074DQELJrksnvCYm2+5P6Ltof0Y/YSPM20HPlTO+rDtQS/MPIjKBNRqZtTut7YDczs7fsK//0+5w8zW3ij9PHNTn6sWTGYiylEWTMqAHY/AQQLtB3ULJjOZPMw4iUIAAQsmW2rA3N5iQh4IXCfQ7mcLJtcdOeE3BCyY5LJ4wmNuvuX+iLaH9mP0Ez7OtB34UDnrw7YHvTDzICoTUKuZUbvf2g7M7ez4Cf/+P+UOM1t7o/TzzE19rlowmYkoR1kwKQN2PAIHCbQf1C2YzGTyMOMkCgEELJhsqQFze4sJeSBwnUC7ny2YXHfkhN8QeMKCyRPEth9Cn8DoxKP63Tm164iDu1fI9+Tf7oXvIXntpmbGNX5++hyB9szQC9ll20HOYH+EOpo5atfSv1owmYkoR1kwKQN2PAIHCbQf1C2YzGTyMOMkCgEELJhsqQFze4sJeSBwnUC7ny2YXHfkhN8QsGCyoyzaD6E7bnktC4/qmV+7jjjIDkTsINDuhR233J+FmbHfkQx/EWjPDL2QK63tIGewP0IdzRy1a8mCycxDO8qCSZuw8xE4R6D9oG7BZOaShxknUQggYMFkSw2Y21tMyAOB6wTa/WzB5LojJ/yGgAWTHWXRfgjdcctrWXhUz/zadcRBdiBiB4F2L+y45f4szIz9jmT4i0B7ZuiFXGltBzmD/RHqaOaoXUsWTGYe2lEWTNqEnY/AOQLtB3ULJjOXPMw4iUIAAQsmW2rA3N5iQh4IXCfQ7mcLJtcdOeE3BCyY7CiL9kPojltey8KjeubXriMOsgMROwi0e2HHLfdnYWbsdyTDXwTaM0Mv5EprO8gZ7I9QRzNH7VqyYDLz0I6yYNIm7HwEzhFoP6hbMJm55GHGSRQCCFgw2VID5vYWE/JA4DqBdj9bMLnuyAm/IWDBZEdZtB9Cd9zyWhYe1TO/dh1xkB2I2EGg3Qs7brk/CzNjvyMZ/iLQnhl6IVda20HOYH+EOpo5ateSBZOZh3aUBZM2YecjcI5A+0HdgsnMJQ8zTqIQQMCCyZYaMLe3mJAHAtcJtPvZgsl1R074DQELJjvKov0QuuOW17LwqJ75teuIg+xAxA4C7V7Yccv9WZgZ+x3J8BeB9szQC7nS2g5yBvsj1NHMUbuWLJjMPLSjLJi0CTsfgXME2g/qFkxmLnmYcRKFAAIWTLbUgLm9xYQ8ELhOoN3PFkyuO3LCbwhYMNlRFu2H0B23vJaFR/XMr11HHGQHInYQaPfCjlvuz8LM2O9Ihr8ItGeGXsiV1naQM9gfoY5mjtq1ZMFk5qEdZcGkTdj5CJwj0H5Qt2Ayc8nDjJMoBBCwYLKlBsztLSbkgcB1Au1+tmBy3ZETfkPAgsmOsmg/hO645bUsPKpnfu064iA7ELGDQLsXdtxyfxZmxn5HMvxFoD0z9EKutLaDnMH+CHU0c9SuJQsmMw/tKAsmbcLOR+AcgfaDugWTmUseZpxEIYCABZMtNWBubzEhDwSuE2j3swWT646c8BsCFkx2lEX7IXTHLa9l4VE982vXEQfZgYgdBNq9sOOW+7MwM/Y7kuEvAu2ZoRdypbUd5Az2R6ijmaN2LVkwmXloR1kwaRN2PgLnCLQf1C2YzFzyMOMkCgEELJhsqQFze4sJeSBwnUC7ny2YXHfkhN8QsGCyoyzaD6E7bnktC4/qmV+7jjjIDkTsINDuhR233J+FmbHfkQx/EWjPDL2QK63tIGewP0IdzRy1a8mCycxDO8qCSZuw8xE4R6D9oG7BZOaShxknUQggYMFkSw2Y21tMyAOB6wTa/WzB5LojJ/yGgAWTHWXRfgjdcctrWXhUz/zadcRBdiBiB4F2L+y45f4szIz9jmT4i0B7ZuiFXGltBzmD/RHqaOaoXUsWTGYe2lEWTNqEnY/AOQLtB3ULJjOXPMw4iUIAAQsmW2rA3N5iQh4IXCfQ7mcLJtcdOeE3BCyY7CiL9kPojltey8KjeubXriMOsgMROwi0e2HHLfdnYWbsdyTDXwTaM0Mv5EprO8gZ7I9QRzNH7VqyYDLz0I6yYNIm7HwEzhFoP6hbMJm55GHGSRQCCFgw2VID5vYWE/JA4DqBdj9bMLnuyAm/IWDBZEdZtB9Cd9zyWhYe1TO/dh1xkB2I2EGg3Qs7brk/CzNjvyMZ/iLQnhl6IVda20HOYH+EOpo5ateSBZOZh3bUExZM2o+IJz6q3/0O7fxffdD24A552rQdvDJoe3CH7LntQD9nBycieJ5Rbs+Mtod2/ub2d9SRuT3zrJ8zpyfMJAsm2bOIHxCwYPIDaIUfaT+EFlI+fqRH9Yy8XUccZAcidhBo98KOW+7PwszY70iGvwi0Z4ZeyJXWdpAz2B+hjmaO2rVkwWTmoR1lwSQTfsJDaPsO7Qd1HzZynfrIN2PU7oUneNDPe2pplsnPoniecWvPjLaHdv5PmHlPuEO7jvwdNpsXbQ/6eYcHCyYzD6L+kIAFkz8EVgpvP4SW0j56rEf1jLtdRxxkByJ2EGj3wo5b7s/CzNjvSIa/CLRnhl7IldZ2kDPYH6GOZo7atWTBZOahHWXBJBP2mJsZtR/UfdjIDp7wgcwdZp7bM0k/7/Awy+LnUTzP2N2939r5m9vfUUf+Dpt5bs9V/bzDgwWTmQdRf0jAgskfAiuFtx9CS2kfPdajesbdriMOsgMROwi0e2HHLfdnYWbsdyTDXwTaM0Mv5EprO8gZ7I9QRzNH7VqyYDLz0I6yYJIJe8zNjNoP6j5sZAeviLYHvfAdHtp1pJ9nddSO4nlGuD332h7a+fu35zvqyNyeedbPmdMTZpIFk+xZxA8IWDD5AbTCj7QfQgspHz/So3pG3q4jDrIDETsItHthxy33Z2Fm7Hckw18E2jNDL+RKazvIGeyPUEczR+1asmAy89COsmCSCT/hIbR9h/aDug8buU595JsxavfCEzzo5z21NMvkZ1E8z7i1Z0bbQzv/J8y8J9yhXUf+DpvNi7YH/bzDgwWTmQdRf0jAgskfAiuFtx9CS2kfPdajesbdriMOsgMROwi0e2HHLfdnYWbsdyTDXwTaM0Mv5EprO8gZ7I9QRzNH7VqyYDLz0I6yYJIJe8zNjNoP6j5sZAdP+EDmDjPP7Zmkn3d4mGXx8yieZ+zu3m/t/M3t76gjf4fNPLfnqn7e4cGCycyDqD8kYMHkD4GVwtsPoaW0jx7rUT3jbtcRB9mBiB0E2r2w45b7szAz9juS4S8C7ZmhF3KltR3kDPZHqKOZo3YtWTCZeWhHWTDJhD3mZkbtB3UfNrKDV0Tbg174Dg/tOtLPszpqR/E8I9yee20P7fz92/MddWRuzzzr58zpCTPJgkn2LOIHBCyY/ABa4UfaD6GFlI8f6VE9I2/XEQfZgYgdBNq9sOOW+7MwM/Y7kuEvAu2ZoRdypbUd5Az2R6ijmaN2LVkwmXloR1kwyYSf8BDavkP7Qd2HjVynPvLNGLV74Qke9POeWppl8rMonmfc2jOj7aGd/xNm3hPu0K4jf4fN5kXbg37e4cGCycyDqD8kYMHkD4GVwtsPoaW0jx7rUT3jbtcRB9mBiB0E2r2w45b7szAz9juS4S8C7ZmhF3KltR3kDPZHqKOZo3YtWTCZeWhHWTDJhD3mZkbtB3UfNrKDJ3wgc4eZ5/ZM0s87PMyy+HkUzzN2d++3dv7m9nfUkb/DZp7bc1U/7/BgwWTmQdQfErBg8ofASuHth9BS2keP9aiecbfriIPsQMQOAu1e2HHL/VmYGfsdyfAXgfbM0Au50toOcgb7I9TRzFG7liyYzDy0oyyYZMIeczOj9oO6DxvZwSui7UEvfIeHdh3p51kdtaN4nhFuz722h3b+/u35jjoyt2ee9XPm9ISZZMEkexbxAwIWTH4ArfAj7YfQQsrHj/SonpG364iD7EDEDgLtXthxy/1ZmBn7HcnwF4H2zNALudLaDnIG+yPU0cxRu5YsmMw8tKMsmGTCT3gIbd+h/aDuw0auUx/5ZozavfAED/p5Ty3NMvlZFM8zbu2Z0fbQzv8JM+8Jd2jXkb/DZvOi7UE/7/BgwWTmQdQfErBg8ofASuHth9BS2keP9aiecbfriIPsQMQOAu1e2HHL/VmYGfsdyfAXgfbM0Au50toOcgb7I9TRzFG7liyYzDy0oyyYZMIeczOj9oO6DxvZwRM+kLnDzHN7JunnHR5mWfw8iucZu7v3Wzt/c/s76sjfYTPP7bmqn3d4sGAy8yDqDwlYMPlDYKXw9kNoKe2jx3pUz7jbdcRBdiBiB4F2L+y45f4szIz9jmT4i0B7ZuiFXGltBzmD/RHqaOaoXUsWTGYe2lFPWDBpM3I+Anch8IQPG3dh/Xd58vAEi+6AwBkC5sUZzum38JAI+d8RuA+Bdj9bMLlPLdwqUwsmO3S1H0J33PJaFh7VM792HXGQHYjYQaDdCztuuT8LM2O/Ixn+ItCeGXohV1rbQc5gf4Q6mjlq15IFk5mHdpQFkzZh5yNwjkD7Qf3E/3P2HK3eb+Khx9bJCDyNgHmxwygPOzzIAoF3EGj3swWTd1hyxl8IWDDZURTth9Adt7yWhUf1zK9dRxxkByJ2EGj3wo5b7s/CzNjvSIa/CLRnhl7IldZ2kDPYH6GOZo7atWTBZOahHWXBpE3Y+QicI9B+ULdgMnPJw4yTKAQQ+F//y7zYUQU87PAgCwTeQaDdzxZM3mHJGX8hYMFkR1G0H0J33PJaFh7VM792HXGQHYjYQaDdCztuuT8LM2O/Ixn+ItCeGXohV1rbQc5gf4Q6mjlq15IFk5mHdpQFkzZh5yNwjkD7Qd2CycwlDzNOohBAwILJlhowt7eYkAcC1wm0+9mCyXVHTvgNAQsmO8qi/RC645bXsvConvm164iD7EDEDgLtXthxy/1ZmBn7HcnwF4H2zNALudLaDnIG+yPU0cxRu5YsmMw8tKMsmLQJOx+BcwTaD+oWTGYueZhxEoUAAhZMttSAub3FhDwQuE6g3c8WTK47csJvCFgw2VEW7YfQHbe8loVH9cyvXUccZAcidhBo98KOW+7PwszY70iGvwi0Z4ZeyJXWdpAz2B+hjmaO2rVkwWTmoR1lwaRN2PkInCPQflC3YDJzycOMkygEELBgsqUGzO0tJuSBwHUC7X62YHLdkRN+Q8CCyY6yaD+E7rjltSw8qmd+7TriIDsQsYNAuxd23HJ/FmbGfkcy/EWgPTP0Qq60toOcwf4IdTRz1K4lCyYzD+0oCyZtws5H4ByB9oO6BZOZSx5mnEQhgIAFky01YG5vMSEPBK4TaPezBZPrjpzwGwIWTHaURfshdMctr2XhUT3zU0eZ0RMi9EK2qBcyoxMRajVTVquZ0RMi9EK2qBcyI3WUGb0i2rVkwWTmoR1lwaRN2PkInCPQflC3YDJzycOMkygEELBgsqUGzO0tJuSBwHUC7X62YHLdkRN+Q8CCyY6yaD+E7rjltSw8qmd+6igzekKEXsgW9UJmdCJCrWbKajUzekKEXsgW9UJmpI4yo1dEu5YsmMw8tKMsmLQJOx+BcwTaD+oWTGYueZhxEoUAAhZMttSAub3FhDwQuE6g3c8WTK47csJvCFgw2VEW7YfQHbe8loVH9cxPHWVGT4jQC9miXsiMTkSo1UxZrWZGT4jQC9miXsiM1FFm9Ipo15IFk5mHdpQFkzZh5yNwjkD7Qd2CycwlDzNOohBAwILJlhowt7eYkAcC1wm0+9mCyXVHTvgNAQsmO8qi/RC645bXsvConvmpo8zoCRF6IVvUC5nRiQi1mimr1czoCRF6IVvUC5mROsqMXhHtWrJgMvPQjrJg0ibsfATOEWg/qFswmbnkYcZJFAIIWDDZUgPm9hYT8kDgOoF2P1swue7ICb8hYMFkR1m0H0J33PJaFh7VMz91lBk9IUIvZIt6ITM6EaFWM2W1mhk9IUIvZIt6ITNSR5nRK6JdSxZMZh7aURZM2oSdj8A5Au0HdQsmM5c8zDiJQgABCyZbasDc3mJCHghcJ9DuZwsm1x054TcELJjsKIv2Q+iOW17LwqN65qeOMqMnROiFbFEvZEYnItRqpqxWM6MnROiFbFEvZEbqKDN6RbRryYLJzEM7yoJJm7DzEThHoP2gbsFk5pKHGSdRCCBgwWRLDZjbW0zIA4HrBNr9bMHkuiMn/IbAExZM6o+I//m/67XTvkP9Agd+gUf1DFkdZUZPiNAL2aJeyIxORKjVTFmtZkZPiNAL2aJeyIzUUWb0imjXkgWTmYd2lAWTNmHnI3COQPtB3YLJzCUPM06iEEDAgsmWGjC3t5iQBwLXCbT72YLJdUdO+A0BCya5LE485rYfQvMt90ec8LCfwt9nqI7ubnCWv17InPRCZnQiQq1mymo1M3pChF7IFvVCZqSOMqNXRLuWLJjMPLSjLJi0CTsfgXME2g/qFkxmLnmYcRKFAAIWTLbUgLm9xYQ8ELhOoN3PFkyuO3LCbwhYMMllceIxt/0Qmm+5P+KEh/0U/j5DdXSHN4ZeAAAgAElEQVR3g7P89ULmpBcyoxMRajVTVquZ0RMi9EK2qBcyI3WUGb0i2rVkwWTmoR1lwaRN2PkInCPQflC3YDJzycOMkygEELBgsqUGzO0tJuSBwHUC7X62YHLdkRN+Q8CCSS6LE4+57YfQfMv9ESc87Kfw9xmqo7sbnOWvFzInvZAZnYhQq5myWs2MnhChF7JFvZAZqaPM6BXRriULJjMP7SgLJm3CzkfgHIH2g7oFk5lLHmacRCGAgAWTLTVgbm8xIQ8ErhNo97MFk+uOnPAbAhZMclmceMxtP4TmW+6POOFhP4W/z1Ad3d3gLH+9kDnphczoRIRazZTVamb0hAi9kC3qhcxIHWVGr4h2LVkwmXloR1kwaRN2PgLnCLQf1C2YzFzyMOMkCgEELJhsqQFze4sJeSBwnUC7ny2YXHfkhN8QsGCSy+LEY277ITTfcn/ECQ/7Kfx9huro7gZn+euFzEkvZEYnItRqpqxWM6MnROiFbFEvZEbqKDN6RbRryYLJzEM7yoJJm7DzEThHoP2gbsFk5pKHGSdRCCBgwWRLDZjbW0zIA4HrBNr9bMHkuiMn/IaABZNcFicec9sPofmW+yNOeNhP4e8zVEd3NzjLXy9kTnohMzoRoVYzZbWaGT0hQi9ki3ohM1JHmdErol1LFkxmHtpRFkzahJ2PwDkC7Qd1CyYzlzzMOIlCAAELJltqwNzeYkIeCFwn0O5nCybXHTnhNwQsmOSyOPGY234IzbfcH3HCw34Kf5+hOrq7wVn+eiFz0guZ0YkItZopq9XM6AkReiFb1AuZkTrKjF4R7VqyYDLz0I6yYNIm7HwEzhFoP6hbMJm55GHGSRQCCFgw2VID5vYWE/JA4DqBdj9bMLnuyAm/IWDBJJfFicfc9kNovuX+iBMe9lP4+wzV0d0NzvLXC5mTXsiMTkSo1UxZrWZGT4jQC9miXsiM1FFm9Ipo15IFk5mHdpQFkzZh5yNwjkD7Qd2CycwlDzNOohBAwILJlhowt7eYkAcC1wm0+9mCyXVHTvgNAQsmuSxOPOa2H0LzLfdHnPCwn8LfZ6iO7m5wlr9eyJz0QmZ0IkKtZspqNTN6QoReyBb1QmakjjKjV0S7liyYzDy0oyyYtAk7H4FzBNoP6hZMZi55mHEShQACFky21IC5vcWEPBC4TqDdzxZMrjtywm8IWDDJZXHiMbf9EJpvuT/ihIf9FP4+Q3V0d4Oz/PVC5qQXMqMTEWo1U1armdETIvRCtqgXMiN1lBm9Itq1ZMFk5qEdZcGkTdj5CJwj0H5Qt2Ayc8nDjJMoBBCwYLKlBsztLSbkgcB1Au1+tmBy3ZETfkPAgkkuixOPue2H0HzL/REnPOyn8PcZqqO7G5zlrxcyJ72QGZ2IUKuZslrNjJ4QoReyRb2QGamjzOgV0a4lCyYzD+0oCyZtws5H4ByB9oO6BZOZSx5mnEQhgIAFky01YG5vMSEPBK4TaPezBZPrjpzwGwIWTHJZnHjMbT+E5lvujzjhYT+Fv89QHd3d4Cx/vZA56YXM6ESEWs2U1Wpm9IQIvZAt6oXMSB1lRq+Idi1ZMJl5aEdZMGkTdj4C5wi0H9QtmMxc8jDjJAoBBCyYbKkBc3uLCXkgcJ1Au58tmFx35ITfELBgksvixGNu+yE033J/xAkP+yn8fYbq6O4GZ/nrhcxJL2RGJyLUaqasVjOjJ0TohWxRL2RG6igzekW0a8mCycxDO8qCSZuw8xE4R6D9oG7BZOaShxknUQggYMFkSw2Y21tMyAOB6wTa/WzB5LojJ/yGgAWTXBYnHnPbD6H5lvsjTnjYT+HvM1RHdzc4y18vZE56ITM6EaFWM2W1mhk9IUIvZIt6ITNSR5nRK6JdSxZMZh7aURZM2oSdj8A5Au0HdQsmM5c8zDiJQgABCyZbasDc3mJCHghcJ9DuZwsm1x054TcELJjksjjxmNt+CM233B9xwsN+Cn+foTq6u8FZ/nohc9ILmdGJCLWaKavVzOgJEXohW9QLmZE6yoxeEe1asmAy89COsmDSJux8BM4RaD+oWzCZueRhxkkUAghYMNlSA+b2FhPyQOA6gXY/WzC57sgJvyFgwSSXxYnH3PZDaL7l/ogTHvZT+PsM1dHdDc7y1wuZk17IjE5EqNVMWa1mRk+I0AvZol7IjNRRZvSKaNeSBZOZh3aUBZM2YecjcI5A+0HdgsnMJQ8zTqIQQMCCyZYaMLe3mJAHAtcJtPvZgsl1R074DQELJrksTjzmth9C8y33R5zwsJ/C32eoju5ucJa/Xsic9EJmdCJCrWbKajUzekKEXsgW9UJmpI4yo1dEu5YsmMw8tKMsmLQJOx+BcwTaD+oWTGYueZhxEoUAAhZMttSAub3FhDwQuE6g3c8WTK47csJvCFgwyWVx4jG3/RCab7k/4oSH/RT+PkN1dHeDs/z1QuakFzKjExFqNVNWq5nREyL0QraoFzIjdZQZvSLatWTBZOahHWXBpE3Y+QicI9B+ULdgMnPJw4yTKAQQsGCypQbM7S0m5IHAdQLtfrZgct2RE35DwIJJLosTj7nth9B8y/0RJzzsp/D3Gaqjuxuc5a8XMie9kBmdiFCrmbJazYyeEKEXskW9kBmpo8zoFdGuJQsmMw/tKAsmbcLOR+AcgfaDugWTmUseZpxEIYCABZMtNWBubzEhDwSuE2j3swWT646c8BsCFkxyWZx4zG0/hOZb7o844WE/hb/PUB3d3eAsf72QOemFzOhEhFrNlNVqZvSECL2QLeqFzEgdZUaviHYtWTCZeWhHWTBpE3Y+AucItB/ULZjMXPIw4yQKAQQsmGypAXN7iwl5IHCdQLufLZhcd+SE3xCwYJLL4sRjbvshNN9yf8QJD/sp/H2G6ujuBmf564XMSS9kRici1GqmrFYzoydE6IVsUS9kRuooM3pFtGvJgsnMQzvKgkmbsPMROEeg/aBuwWTmkocZJ1EIIGDBZEsNmNtbTMgDgesE2v1sweS6Iyf8hoAFk1wWJx5z2w+h+Zb7I0542E/h7zNUR3c3OMtfL2ROeiEzOhGhVjNltZoZPSFCL2SLeiEzUkeZ0SuiXUsWTGYe2lEWTNqEnY/AOQLtB3ULJjOXPMw4iUIAAQsmW2rA3N5iQh4IXCfQ7mcLJtcdOeE3BCyY5LI48ZjbfgjNt9wfccLDfgp/n6E6urvBWf56IXPSC5nRiQi1mimr1czoCRF6IVvUC5mROsqMXhHtWrJgMvPQjrJg0ibsfATOEWg/qFswmbnkYcZJFAIIWDDZUgPm9hYT8kDgOoF2P1swue7ICb8hYMEkl8WJx9z2Q2i+5f6ItocTDp5wh/2V8vwMn1BHT7jD8yvt+g2f4PkJd7hu0glXCTyhjp5wh6seP/3zbQefvt+7fn/7b3oLJu8yde0cCybX+L3rp9sPoe/K85PnWG7I9Nt1xEF2IGIHgXYv7Ljl/izMjP2OZPiLQHtm6IVcaW0HOYP9Eepo5qhdSxZMZh5E/SEBCyYZ2InH3PZDaL7l/oi2hxMOnnCH/ZXy/AyfUEdPuMPzK+36DZ/g+Ql3uG7SCVcJPKGOnnCHqx4//fNtB5++37t+f/tvegsm7zJ17RwLJtf4veun2w+h78rzk+d4VM/023XEQXYgYgeBdi/suOX+LMyM/Y5k+ItAe2bohVxpbQc5g/0R6mjmqF1LFkxmHkT9IQELJhnYicfc9kNovuX+iLaHEw6ecIf9lfL8DJ9QR0+4w/Mr7foNn+D5CXe4btIJVwk8oY6ecIerHj/9820Hn77fu35/+296CybvMnXtHAsm1/i966fbD6HvyvOT53hUz/TbdcRBdiBiB4F2L+y45f4szIz9jmT4i0B7ZuiFXGltBzmD/RHqaOaoXUsWTGYeRP0hAQsmGdiJx9z2Q2i+5f6ItocTDp5wh/2V8vwMn1BHT7jD8yvt+g2f4PkJd7hu0glXCTyhjp5wh6seP/3zbQefvt+7fn/7b3oLJu8yde0cCybX+L3rp9sPoe/K85PneFTP9Nt1xEF2IGIHgXYv7Ljl/izMjP2OZPiLQHtm6IVcaW0HOYP9Eepo5qhdSxZMZh5E/SEBCyYZ2InH3PZDaL7l/oi2hxMOnnCH/ZXy/AyfUEdPuMPzK+36DZ/g+Ql3uG7SCVcJPKGOnnCHqx4//fNtB5++37t+f/tvegsm7zJ17RwLJtf4veun2w+h78rzk+d4VM/023XEQXYgYgeBdi/suOX+LMyM/Y5k+ItAe2bohVxpbQc5g/0R6mjmqF1LFkxmHkT9IQELJhnYicfc9kNovuX+iLaHEw6ecIf9lfL8DJ9QR0+4w/Mr7foNn+D5CXe4btIJVwk8oY6ecIerHj/9820Hn77fu35/+296CybvMnXtHAsm1/i966fbD6HvyvOT53hUz/TbdcRBdiBiB4F2L+y45f4szIz9jmT4i0B7ZuiFXGltBzmD/RHqaOaoXUsWTGYeRP0hAQsmGdiJx9z2Q2i+5f6ItocTDp5wh/2V8vwMn1BHT7jD8yvt+g2f4PkJd7hu0glXCTyhjp5wh6seP/3zbQefvt+7fn/7b3oLJu8yde0cCybX+L3rp9sPoe/K85PneFTP9Nt1xEF2IGIHgXYv7Ljl/izMjP2OZPiLQHtm6IVcaW0HOYP9Eepo5qhdSxZMZh5E/SEBCyYZ2InH3PZDaL7l/oi2hxMOnnCH/ZXy/AyfUEdPuMPzK+36DZ/g+Ql3uG7SCVcJPKGOnnCHqx4//fNtB5++37t+f/tvegsm7zJ17RwLJtf4veun2w+h78rzk+d4VM/023XEQXYgYgeBdi/suOX+LMyM/Y5k+ItAe2bohVxpbQc5g/0R6mjmqF1LFkxmHkT9IQELJhnYicfc9kNovuX+iLaHEw6ecIf9lfL8DJ9QR0+4w/Mr7foNn+D5CXe4btIJVwk8oY6ecIerHj/9820Hn77fu35/+296CybvMnXtHAsm1/i966fbD6HvyvOT53hUz/TbdcRBdiBiB4F2L+y45f4szIz9jmT4i0B7ZuiFXGltBzmD/RHqaOaoXUsWTGYeRP0hAQsmGdiJx9z2Q2i+5f6ItocTDp5wh/2V8vwMn1BHT7jD8yvt+g2f4PkJd7hu0glXCTyhjp5wh6seP/3zbQefvt+7fn/7b3oLJu8yde0cCybX+L3rp9sPoe/K85PneFTP9Nt1xEF2IGIHgXYv7Ljl/izMjP2OZPiLQHtm6IVcaW0HOYP9Eepo5qhdSxZMZh5E/SEBCyYZ2InH3PZDaL7l/oi2hxMOnnCH/ZXy/AyfUEdPuMPzK+36DZ/g+Ql3uG7SCVcJPKGOnnCHqx4//fNtB5++37t+f/tvegsm7zJ17RwLJtf4veun2w+h78rzk+d4VM/023XEQXYgYgeBdi/suOX+LMyM/Y5k+ItAe2bohVxpbQc5g/0R6mjmqF1LFkxmHkT9IQELJhnYicfc9kNovuX+iLaHEw6ecIf9lfL8DJ9QR0+4w/Mr7foNn+D5CXe4btIJVwk8oY6ecIerHj/9820Hn77fu35/+296CybvMnXtHAsm1/i966fbD6HvyvOT53hUz/TbdcRBdiBiB4F2L+y45f4szIz9jmT4i0B7ZuiFXGltBzmD/RHqaOaoXUsWTGYeRP0hAQsmGdiJx9z2Q2i+5f6IEx72U/j7DNXR3Q3O8tcLmZNeyIxORKjVTFmtZkZPiNAL2aJeyIzUUWb0imjXkgWTmYd2lAWTNuHZ+e2H0FkWu6M8qmc/7TriIDsQsYNAuxd23HJ/FmbGfkcy/EWgPTP0Qq60toOcwf4IdTRz1K4lCyYzD6L+kIAFkwzsxGNu+yE033J/xAkP+yn8fYbq6O4GZ/nrhcxJL2RGJyLUaqasVjOjJ0TohWxRL2RG6igzekW0a8mCycxDO8qCSZvw7Pz2Q+gsi91RHtWzn3YdcZAdiNhBoN0LO265PwszY78jGf4i0J4ZeiFXWttBzmB/hDqaOWrXkgWTmQdRf0jAgkkGduIxt/0Qmm+5P+KEh/0U/j5DdXR3g7P89ULmpBcyoxMRajVTVquZ0RMi9EK2qBcyI3WUGb0i2rVkwWTmoR1lwaRNeHZ++yF0lsXuKI/q2U+7jjjIDkTsINDuhR233J+FmbHfkQx/EWjPDL2QK63tIGewP0IdzRy1a8mCycyDqD8kYMEkAzvxmNt+CM233B9xwsN+Cn+foTq6u8FZ/nohc9ILmdGJCLWaKavVzOgJEXohW9QLmZE6yoxeEe1asmAy89COsmDSJjw7v/0QOstid5RH9eynXUccZAcidhBo98KOW+7PwszY70iGvwi0Z4ZeyJXWdpAz2B+hjmaO2rVkwWTmQdQfErBgkoGdeMxtP4TmW+6POOFhP4W/z1Ad3d3gLH+9kDnphczoRIRazZTVamb0hAi9kC3qhcxIHWVGr4h2LVkwmXloR1kwaROend9+CJ1lsTvKo3r2064jDrIDETsItHthxy33Z2Fm7Hckw18E2jNDL+RKazvIGeyPUEczR+1asmAy8yDqDwlYMMnATjzmth9C8y33R5zwsJ/C32eoju5ucJa/Xsic9EJmdCJCrWbKajUzekKEXsgW9UJmpI4yo1dEu5YsmMw8tKMsmLQJz85vP4TOstgd5VE9+2nXEQfZgYgdBNq9sOOW+7MwM/Y7kuEvAu2ZoRdypbUd5Az2R6ijmaN2LVkwmXkQ9YcEnrBg8odXXhnefghdeek/TMqjegamjjKjJ0TohWxRL2RGJyLUaqasVjOjJ0TohWxRL2RG6igzekW0a8mCycxDO8qCSZvw7Pz2Q+gsi91RHtWzn3YdcZAdiNhBoN0LO265PwszY78jGf4i0J4ZeiFXWttBzmB/hDqaOWrXkgWTmQdRf0jAgskfAiuFtx9CS2kfPdajesatjjKjJ0TohWxRL2RGJyLUaqasVjOjJ0TohWxRL2RG6igzekW0a8mCycxDO8qCSZvw7Pz2Q+gsi91RHtWzn3YdcZAdiNhBoN0LO265PwszY78jGf4i0J4ZeiFXWttBzmB/hDqaOWrXkgWTmQdRf0jAgskfAiuFtx9CS2kfPdajesatjjKjJ0TohWxRL2RGJyLUaqasVjOjJ0TohWxRL2RG6igzekW0a8mCycxDO8qCSZvw7Pz2Q+gsi91RHtWzn3YdcZAdiNhBoN0LO265PwszY78jGf4i0J4ZeiFXWttBzmB/hDqaOWrXkgWTmQdRf0jAgskfAiuFtx9CS2kfPdajesatjjKjJ0TohWxRL2RGJyLUaqasVjOjJ0TohWxRL2RG6igzekW0a8mCycxDO8qCSZvw7Pz2Q+gsi91RHtWzn3YdcZAdiNhBoN0LO265PwszY78jGf4i0J4ZeiFXWttBzmB/hDqaOWrXkgWTmQdRf0jAgskfAiuFtx9CS2kfPdajesatjjKjJ0TohWxRL2RGJyLUaqasVjOjJ0TohWxRL2RG6igzekW0a8mCycxDO8qCSZvw7Pz2Q+gsi91RHtWzn3YdcZAdiNhBoN0LO265PwszY78jGf4i0J4ZeiFXWttBzmB/hDqaOWrXkgWTmQdRf0jAgskfAiuFtx9CS2kfPdajesatjjKjJ0TohWxRL2RGJyLUaqasVjOjJ0TohWxRL2RG6igzekW0a8mCycxDO8qCSZvw7Pz2Q+gsi91RHtWzn3YdcZAdiNhBoN0LO265PwszY78jGf4i0J4ZeiFXWttBzmB/hDqaOWrXkgWTmQdRf0jAgskfAiuFtx9CS2kfPdajesatjjKjJ0TohWxRL2RGJyLUaqasVjOjJ0TohWxRL2RG6igzekW0a8mCycxDO+oJCybtR8QTj7ntO7Tr6MT5bQ8nHNz9Du38n/KRr11LbQ/t/F+en3CHE3Pv7r/jCZ7vfod2/ub2rEvbHsztmYe7R7XrSD/PKsSCyYyTqD8kYMHk/8vOHeTakiNnglZsIOcNaBUF9DCHAnITArQELaW1A22g5g3UMIcFxGK0gW74u6gMRCjeNZJOo5vb+aaSHR7y+40nHngNOQmWVJ79EJq07aPLelSPufVRbNShwl2IU3QXYqMTFXo1VtarsVGHCnchTtFdiI30UWx0VWT3kgGTsRyyqwyYxMIdHnPjU9avyM7BH2fiHsjOwB824gyuiuwc3IWxHFTFAno1Nsq+b9kZ+N2OM/a7PWaUfRfGdlG7yn0eyye7lwyYjOWgalLAgMkkWFJ59kNo0raPLutRPebWR7FRhwp3IU7RXYiNTlTo1VhZr8ZGHSrchThFdyE20kex0VWR3UsGTMZyyK4yYBILd3jMjU9ZvyI7h+zH6A5/YMrO4DLKzsEZ4ruenUGHuxArquiSc/ZvRvZ9y96/3+2xu56dQ3YfdbnPY2nVrcruI/d5LHsDJmNOqiYFDJhMgiWVZz+EJm376LIe1WNufRQbdahwF+IU3YXY6ESFXo2V9Wps1KHCXYhTdBdiI30UG10V2b1kwGQsh+wqAyaxcIfH3PiU9Suyc/DHmbgHsjPwh404g6siOwd3YSwHVbGAXo2Nsu9bdgZ+t+OM/W6PGWXfhbFd1K5yn8fyye4lAyZjOaiaFDBgMgmWVJ79EJq07aPLelSPufVRbNShwl2IU3QXYqMTFXo1VtarsVGHCnchTtFdiI30UWx0VWT3kgGTsRyyqwyYxMIdHnPjU9avyM4h+zG6wx+YsjO4jLJzcIb4rmdn0OEuxIoquuSc/ZuRfd+y9+93e+yuZ+eQ3Udd7vNYWnWrsvvIfR7L3oDJmJOqSQEDJpNgSeXZD6FJ2z66rEf1mFsfxUYdKtyFOEV3ITY6UaFXY2W9Ght1qHAX4hTdhdhIH8VGV0V2LxkwGcshu8qASSzc4TE3PmX9iuwc/HEm7oHsDPxhI87gqsjOwV0Yy0FVLKBXY6Ps+5adgd/tOGO/22NG2XdhbBe1q9znsXyye8mAyVgOqiYFDJhMgiWVZz+EJm376LIe1WNufRQbdahwF+IU3YXY6ESFXo2V9Wps1KHCXYhTdBdiI30UG10V2b1kwGQsh+wqAyaxcIfH3PiU9Suyc8h+jO7wB6bsDC6j7BycIb7r2Rl0uAuxooouOWf/ZmTft+z9+90eu+vZOWT3UZf7PJZW3arsPnKfx7I3YDLmpGpSwIDJJFhSefZDaNK2jy7rUT3m1kexUYcKdyFO0V2IjU5U6NVYWa/GRh0q3IU4RXchNtJHsdFVkd1LBkzGcsiuMmASC3d4zI1PWb8iOwd/nIl7IDsDf9iIM7gqsnNwF8ZyUBUL6NXYKPu+ZWfgdzvO2O/2mFH2XRjbRe0q93ksn+xeMmAyloOqSQEDJpNgSeXZD6FJ2z66rEf1mFsfxUYdKtyFOEV3ITY6UaFXY2W9Ght1qHAX4hTdhdhIH8VGV0V2LxkwGcshu8qASSzc4TE3PmX9iuwcsh+jO/yBKTuDyyg7B2eI73p2Bh3uQqyookvO2b8Z2fcte/9+t8fuenYO2X3U5T6PpVW3KruP3Oex7A2YjDmpmhQwYDIJllSe/RCatO2jy3pUj7n1UWzUocJdiFN0F2KjExV6NVbWq7FRhwp3IU7RXYiN9FFsdFVk95IBk7EcsqsMmMTCHR5z41PWr8jOwR9n4h7IzsAfNuIMrorsHNyFsRxUxQJ6NTbKvm/ZGfjdjjP2uz1mlH0XxnZRu8p9Hssnu5cMmIzloGpSwIDJJFhSefZDaNK2jy7rUT3m1kexUYcKdyFO0V2IjU5U6NVYWa/GRh0q3IU4RXchNtJHsdFVkd1LBkzGcsiuMmASC3d4zI1PWb8iO4fsx+gOf2DKzuAyys7BGeK7np1Bh7sQK6roknP2b0b2fcvev9/tsbuenUN2H3W5z2Np1a3K7iP3eSx7AyZjTqomBQyYTIIllWc/hCZt++iyHtVjbn0UG3WocBfiFN2F2OhEhV6NlfVqbNShwl2IU3QXYiN9FBtdFdm9ZMBkLIfsKgMmsXCHx9z4lPUrsnPwx5m4B7Iz8IeNOIOrIjsHd2EsB1WxgF6NjbLvW3YGfrfjjP1ujxll34WxXdSucp/H8snuJQMmYzmomhQwYDIJllSe/RCatO2jy3pUj7n1UWzUocJdiFN0F2KjExV6NVbWq7FRhwp3IU7RXYiN9FFsdFVk95IBk7Ecsqs6DJhkG51YP/sh9MQZsr/jxKN69hmy18/uIxlkJ2j9XQLZd2HXPruv4zeje8J9zpf9m+EuxL2SnUG8g/oV+mgso+xeMmAyloOqSQEDJpNgSeXZD6FJ2z66rEf1mFsfxUYdKtyFOEV3ITY6UaFXY2W9Ght1qHAX4hTdhdhIH8VGV0V2LxkwGcshu8qASbbw2PrZD6Fju6hd5VE9zie7j2QQZ6CihkD2Xahxyvq78JtRPyM7/BLI/s1wF+JOy84g3kH9Cn00llF2LxkwGctB1aSAAZNJsKTy7IfQpG0fXdajesytj2KjDhXuQpyiuxAbnajQq7GyXo2NOlS4C3GK7kJspI9io6siu5cMmIzlkF1lwCRbeGz97IfQsV3UrvKoHueT3UcyiDNQUUMg+y7UOGX9XfjNqJ+RHX4JZP9muAtxp2VnEO+gfoU+Gssou5cMmIzloGpSwIDJJFhSefZDaNK2jy7rUT3m1kexUYcKdyFO0V2IjU5U6NVYWa/GRh0q3IU4RXchNtJHsdFVkd1LBkzGcsiuMmCSLTy2fvZD6Nguald5VI/zye4jGcQZqKghkH0Xapyy/i78ZtTPyA6/BLJ/M9yFuNOyM4h3UL9CH41llN1LBkzGclA1KWDAZBIsqTz7ITRp20eX9agec+uj2KhDhbsQp+guxEYnKvRqrKxXY6MOFe5CnKK7EBvpo9joqsjuJQMmYzlkVxkwyRYeWz/7IXRsF7WrPKrH+WT3kQziDFTUEMi+CzVOWX8XfjPqZ2SHXwLZvxnuQtxp2RnEO6hfoY/GMnT/1mgAACAASURBVMruJQMmYzmomhQwYDIJllSe/RCatO2jy3pUj7n1UWzUocJdiFN0F2KjExV6NVbWq7FRhwp3IU7RXYiN9FFsdFVk95IBk7EcsqsMmGQLj62f/RA6tovaVR7V43yy+0gGcQYqaghk34Uap6y/C78Z9TOywy+B7N8MdyHutOwM4h3Ur9BHYxll95IBk7EcVE0KGDCZBEsqz34ITdr20WU9qsfc+ig26lDhLsQpugux0YkKvRor69XYqEOFuxCn6C7ERvooNroqsnvJgMlYDtlVBkyyhcfWz34IHdtF7SqP6nE+2X0kgzgDFTUEsu9CjVPW34XfjPoZ2eGXQPZvhrsQd1p2BvEO6lfoo7GMsnvJgMlYDqomBQyYTIIpJ0CAAAECBAgQIECAAIGSAgZMSsayfVMGTLaTLi2Y/RC6tKliH/KoHgeS3UcyiDNQUUMg+y7UOGX9XfjNqJ+RHX4JZP9muAtxp2VnEO+gfoU+Gssou5cMmIzloGpSwIDJJJhyAgQIECBAgAABAgQIECgpYMCkZCzbN2XAZDvp0oLZD6FLmyr2IY/qcSDZfSSDOAMVNQSy70KNU9bfhd+M+hnZ4ZdA9m+GuxB3WnYG8Q7qV+ijsYyye8mAyVgOqiYFDJhMgiknQIAAAQIECBAgQIAAgZICBkxKxrJ9UwZMtpMuLZj9ELq0qWIf8qgeB5LdRzKIM1BRQyD7LtQ4Zf1d+M2on5Edfglk/2a4C3GnZWcQ76B+hT4ayyi7lwyYjOWgalLAgMkkmHICBAgQIECAAAECBAgQKClgwKRkLNs3ZcBkO+nSgtkPoUubKvYhj+pxINl9JIM4AxU1BLLvQo1T1t+F34z6Gdnhl0D2b4a7EHdadgbxDupX6KOxjLJ7yYDJWA6qJgUMmEyCKSdAgAABAgQIECBAgACBkgIGTErGsn1TBky2ky4tmP0QurSpYh/yqB4Hkt1HMogzUFFDIPsu1Dhl/V34zaifkR1+CWT/ZrgLcadlZxDvoH6FPhrLKLuXDJiM5aBqUsCAySSYcgIECBAgQIAAAQIECBAoKWDApGQs2zdlwGQ76dKC2Q+hS5sq9iGP6nEg2X0kgzgDFTUEsu9CjVPW34XfjPoZ2eGXQPZvhrsQd1p2BvEO6lfoo7GMsnvJgMlYDqomBQyYTIIpJ0CAAAECBAgQIECAAIGSAgZMSsayfVMGTLaTLi2Y/RC6tKliH/KoHgeS3UcyiDNQUUMg+y7UOGX9XfjNqJ+RHX4JZP9muAtxp2VnEO+gfoU+Gssou5cMmIzloGpSwIDJJJhyAgQIECBAgAABAgQIECgpYMCkZCzbN2XAZDvp0oLZD6FLmyr2IY/qcSDZfSSDOAMVNQSy70KNU9bfhd+M+hnZ4ZdA9m+GuxB3WnYG8Q7qV+ijsYyye8mAyVgOqiYFDJhMgiknQIAAAQIECBAgQIAAgZICBkxKxrJ9UwZMtpMuLZj9ELq0qWIf8qgeB5LdRzKIM1BRQyD7LtQ4Zf1d+M2on5Edfglk/2a4C3GnZWcQ76B+hT4ayyi7lwyYjOWgalLAgMkkmHICBAgQIECAAAECBAgQKClgwKRkLNs3ZcBkO+nSgtkPoUubKvYhj+pxINl9JIM4AxU1BLLvQo1T1t+F34z6Gdnhl0D2b4a7EHdadgbxDupX6KOxjLJ7yYDJWA6qJgUMmEyCKSdAgAABAgQIECBAgACBkgIGTErGsn1TBky2ky4tmP0QurSpYh/yqB4Hkt1HMogzUFFDIPsu1Dhl/V34zaifkR1+CWT/ZrgLcadlZxDvoH6FPhrLKLuXDJiM5aBqUsCAySSYcgIECBAgQIAAAQIECBAoKWDApGQs2zdlwGQ76dKC2Q+hS5sq9iGP6nEg2X0kgzgDFTUEsu9CjVPW34XfjPoZ2eGXQPZvhrsQd1p2BvEO6lfoo7GMsnvJgMlYDqomBQyYTIIpJ0CAAAECBAgQIECAAIGSAgZMSsayfVMGTLaTLi2Y/RC6tKliH/KoHgeS3UcyiDNQUUMg+y7UOGX9XfjNqJ+RHX4JZP9muAtxp2VnEO+gfoU+Gssou5cMmIzloGpSwIDJJJhyAgQIECBAgAABAgQIECgpYMCkZCzbN2XAZDvp0oLZD6FLmyr2IY/qcSDZfSSDOAMVNQSy70KNU9bfhd+M+hnZ4ZdA9m+GuxB3WnYG8Q7qV+ijsYyye8mAyVgOqiYFDJhMgiknQIAAAQIECBAgQIAAgZICBkxKxrJ9UwZMtpMuLZj9ELq0qWIf8qgeB5LdRzKIM1BRQyD7LtQ4Zf1d+M2on5Edfglk/2a4C3GnZWcQ76B+hT4ayyi7lwyYjOWgalLAgMkkmHICBAgQIECAAAECBAgQKClgwKRkLNs3ZcBkO+nSgtkPoUubKvYhj+pxINl9JIM4AxU1BLLvQo1T1t+F34z6Gdnhl0D2b4a7EHdadgbxDupX6KOxjLJ7yYDJWA6qJgUMmEyCKSdAgAABAgQIECBAgACBkgIGTErGsn1TBky2ky4tmP0QurSpYh/yqB4Hkt1HMogzUFFDIPsu1Dhl/V34zaifkR1+CWT/ZrgLcadlZxDvoH6FPhrLKLuXDJiM5aBqUsCAySSYcgIECBAgQIAAAQIECBAoKWDApGQs2zdlwGQ76dKC2Q+hS5sq9iGP6nEg2X0kgzgDFTUEsu9CjVPW34XfjPoZ2eGXQPZvhrsQd1p2BvEO6lfoo7GMsnvJgMlYDqomBQyYTIIpJ0CAAAECBAgQIECAAIGSAgZMSsayfVMGTLaTLi2Y/RC6tKliH/KoHgeS3UcyiDNQUUMg+y7UOGX9XfjNqJ+RHX4JZP9muAtxp2VnEO+gfoU+Gssou5cMmIzloGpSwIDJJJhyAgQIECBAgAABAgQIECgpYMCkZCzbN2XAZDvp0oLZD6FLmyr2IY/qcSDZfSSDOAMVNQSy70KNU9bfhd+M+hnZ4ZdA9m+GuxB3WnYG8Q7qV+ijsYyye8mAyVgOqiYFDJhMgiknQIAAAQIECBAgQIAAgZICBkxKxrJ9UwZMtpMuLZj9ELq0qWIf8qgeB5LdRzKIM1BRQyD7LtQ4Zf1d+M2on5Edfglk/2a4C3GnZWcQ76B+hT4ayyi7lwyYjOWgalLAgMkkmHICBAgQIECAAAECBAgQKClgwKRkLNs3ZcBkO+nSgtkPoUubKvYhj+pxINl9JIM4AxU1BLLvQo1T1t+F34z6Gdnhl0D2b4a7EHdadgbxDupX6KOxjLJ7yYDJWA6qJgUMmEyCKSdAgAABAgQIECBAgACBkgIGTErGsn1TBky2ky4tmP0QurSpYh/yqB4Hkt1HMogzUFFDIPsu1Dhl/V34zaifkR1+CWT/ZrgLcadlZxDvoH6FPhrLKLuXDJiM5aBqUsCAySSYcgIECBAgQIAAAQIECBAoKWDApGQs2zdlwGQ76dKC2Q+hS5sq9iGP6nEg2X0kgzgDFTUEsu9CjVPW34XfjPoZ2eGXQPZvhrsQd1p2BvEO6lfoo7GMsnvJgMlYDqomBQyYTIIpJ0CAAAECBAgQIECAAIGSAgZMSsayfVMGTLaTLi2Y/RC6tKliH/KoHgeS3UcyiDNQUUMg+y7UOGX9XfjNqJ+RHX4JZP9muAtxp2VnEO+gfoU+Gssou5cMmIzloGpSwIDJJJhyAgQIECBAgAABAgQIECgpYMCkZCzbN2XAZDvp0oLZD6FLmyr2IY/qcSDZfSSDOAMVNQSy70KNU9bfhd+M+hnZ4ZdA9m+GuxB3WnYG8Q7qV+ijsYyye8mAyVgOqiYFDJhMgiknQIAAAQIECBAgQIAAgZICBkxKxrJ9UwZMtpMuLZj9ELq0qWIf8qgeB5LdRzKIM1BRQyD7LtQ4Zf1d+M2on5Edfglk/2a4C3GnZWcQ76B+hT4ayyi7lwyYjOWgalLAgMkkmHICBAgQIECAAAECBAgQKClgwKRkLNs3ZcBkO+nSgtkPoUubKvYhj+pxINl9JIM4AxU1BLLvQo1T1t+F34z6Gdnhl0D2b4a7EHdadgbxDupX6KOxjLJ7yYDJWA6qJgUMmEyCKSdAgAABAgQIECBAgACBkgIGTErGsn1TBky2ky4tmP0QurSpYh/yqB4Hkt1HMogzUFFDIPsu1Dhl/V34zaifkR1+CWT/ZrgLcadlZxDvoH6FPhrLKLuXDJiM5aBqUsCAySSYcgIECBAgQIAAAQIECBAoKWDApGQs2zdlwGQ76dKC2Q+hS5sq9iGP6nEg2X0kgzgDFTUEsu9CjVPW34XfjPoZ2eGXQPZvhrsQd1p2BvEO6lfoo7GMsnvJgMlYDqomBToMmKQ/Iv7P/2tSdb787WfI3v8l+s/JOThD3LfZGVw7yM7BGeKcszNwn+MMTlTIeUw5+zcjO4fs/fvd/ow+8rs9lrP7HDu1+E36j//4JT6pimyBDgMm2Y+IJx5zs8+Q3Ucn1j+Rw4lzZH6HPsrUrbO2uxBn4S7ERicq9GqsrFdjow4V7kKcorsQG+mj2OiqyO4lAyZjOaiaFDBgEoO1eAg1nBEGnf1HgQ5/nHEXwjb6UZDdS9k5ZO+/w104cYaxbluvkvOY3dvvW/b+O/zmdTiD++w+jwnEVdm91OI3yYBJ3EgHKgyYxMgnHnOzH0LjU9avOJFDfYXvd6iP3p7g2P7dhdjJXYiNTlTo1VhZr8ZGHSrchThFdyE20kex0VWR3UsGTMZyUDUpYMAkBmvxEGrAJAw6+0H92kB2L2WfIXv/Hf7I1+EM2X3U4S6cOEP4o3WzQM5jgNm/e9k5ZO+/w29ehzNk99GJ3zxniH+T3OfY6Mh9NmAyFkRylQGTGPjEY272Q2h8yvoVJ3Kor/D9DvXR2xMc27+7EDu5C7HRiQq9Givr1dioQ4W7EKfoLsRG+ig2uiqye8mAyVgOqiYFDJjEYB5zYyN/FIiNOvxxxl0Yyzn7PmTnkL3/DnfhxBnGum29Ss5jdm+/b9n7vxSze8kZ4l7NzuDEb54zxDm7C7HRkd8kAyZjQSRXGTCJgU885mY/hManrF9xIof6Ct/vUB+9PcGx/bsLsZO7EBudqNCrsbJejY06VLgLcYruQmykj2KjqyK7lwyYjOWgalLAgEkM5jE3NvJHgdiowx9n3IWxnLPvQ3YO2fvvcBdOnGGs29ar5Dxm9/b7lr3/SzG7l5wh7tXsDE785jlDnLO7EBsd+U0yYDIWRHKVAZMY+MRjbvZDaHzK+hUncqiv8P0O9dHbExzbv7sQO7kLsdGJCr0aK+vV2KhDhbsQp+guxEb6KDa6KrJ7yYDJWA6qJgUMmMRgHnNjI38UiI06/HHGXRjLOfs+ZOeQvf8Od+HEGca6bb1KzmN2b79v2fu/FLN7yRniXs3O4MRvnjPEObsLsdGR3yQDJmNBJFcZMImBTzzmZj+ExqesX3Eih/oK3+9QH709wbH9uwuxk7sQG52o0Kuxsl6NjTpUuAtxiu5CbKSPYqOrIruXDJiM5aBqUsCASQzmMTc28keB2KjDH2fchbGcs+9Ddg7Z++9wF06cYazb1qvkPGb39vuWvf9LMbuXnCHu1ewMTvzmOUOcs7sQGx35TTJgMhZEcpUBkxj4xGNu9kNofMr6FSdyqK/w/Q710dsTHNu/uxA7uQux0YkKvRor69XYqEOFuxCn6C7ERvooNroqsnvJgMlYDqomBQyYxGAec2MjfxSIjTr8ccZdGMs5+z5k55C9/w534cQZxrptvUrOY3Zvv2/Z+78Us3vJGeJezc7gxG+eM8Q5uwux0ZHfJAMmY0EkVxkwiYFPPOZmP4TGp6xfcSKH+grf71AfvT3Bsf27C7GTuxAbnajQq7GyXo2NOlS4C3GK7kJspI9io6siu5cMmIzloGpSwIBJDOYxNzbyR4HYqMMfZ9yFsZyz70N2Dtn773AXTpxhrNvWq+Q8Zvf2+5a9/0sxu5ecIe7V7AxO/OY5Q5yzuxAbHflNMmAyFkRylQGTGPjEY272Q2h8yvoVJ3Kor/D9DvXR2xMc27+7EDu5C7HRiQq9Givr1dioQ4W7EKfoLsRG+ig2uiqye8mAyVgOqiYFDJjEYB5zYyN/FIiNOvxxxl0Yyzn7PmTnkL3/DnfhxBnGum29Ss5jdm+/b9n7vxSze8kZ4l7NzuDEb54zxDm7C7HRkd8kAyZjQSRXGTCJgU885mY/hManrF9xIof6Ct/vUB+9PcGx/bsLsZO7EBudqNCrsbJejY06VLgLcYruQmykj2KjqyK7lwyYjOWgalLAgEkM5jE3NvJHgdiowx9n3IWxnLPvQ3YO2fvvcBdOnGGs29ar5Dxm9/b7lr3/SzG7l5wh7tXsDE785jlDnLO7EBsd+U0yYDIWRHKVAZMY+MRjbvZDaHzK+hUncqiv8P0O9dHbExzbv7sQO7kLsdGJCr0aK+vV2KhDhbsQp+guxEb6KDa6KrJ7yYDJWA6qJgUMmMRgHnNjI38UiI06/HHGXRjLOfs+ZOeQvf8Od+HEGca6bb1KzmN2b79v2fu/FLN7yRniXs3O4MRvnjPEObsLsdGR3yQDJmNBJFcZMImBTzzmZj+ExqesX3Eih/oK3+9QH709wbH9uwuxk7sQG52o0Kuxsl6NjTpUuAtxiu5CbKSPYqOrIruXDJiM5aBqUqDDgMnkkZUTIECAAAECBAgQIECAQEOB7GGlfzZgUqJrDJjEMZx4zM1+CI1PWb/iRA71Fb7foT56e4Jj+3cXYid3ITY6UaFXY2W9Ght1qHAX4hTdhdhIH8VGV0V2LxkwGctB1aSAAZNJMOUECBAgQIAAAQIECBAgUFLAgEnJWLZvyoBJTHriMTf7ITQ+Zf2KEznUV/h+h/ro7QmO7d9diJ3chdjoRIVejZX1amzUocJdiFN0F2IjfRQbXRXZvWTAZCwHVZMCBkwmwZQTIECAAAECBAgQIECAQEkBAyYlY9m+KQMmMemJx9zsh9D4lPUrTuRQX+H7Heqjtyc4tn93IXZyF2KjExV6NVbWq7FRhwp3IU7RXYiN9FFsdFVk95IBk7EcVE0KGDCZBFNOgAABAgQIECBAgAABAiUFDJiUjGX7pgyYxKQnHnOzH0LjU9avOJFDfYXvd6iP3p7g2P7dhdjJXYiNTlTo1VhZr8ZGHSrchThFdyE20kex0VWR3UsGTMZyUDUpYMBkEkw5AQIECBAgQIAAAQIECJQUMGBSMpbtmzJgEpOeeMzNfgiNT1m/4kQO9RW+36E+enuCY/t3F2IndyE2OlGhV2NlvRobdahwF+IU3YXYSB/FRldFdi8ZMBnLQdWkgAGTSTDlBAgQIECAAAECBAgQIFBSwIBJyVi2b8qASUx64jE3+yE0PmX9ihM51Ff4fof66O0Jju3fXYid3IXY6ESFXo2V9Wps1KHCXYhTdBdiI30UG10V2b1kwGQsB1WTAgZMJsGUEyBAgAABAgQIECBAgEBJAQMmJWPZvikDJjHpicfc7IfQ+JT1K07kUF/h+x3qo7cnOLZ/dyF2chdioxMVejVW1quxUYcKdyFO0V2IjfRRbHRVZPeSAZOxHFRNChgwmQRTToAAAQIECBAgQIAAAQIlBQyYlIxl+6YMmMSkJx5zsx9C41PWrziRQ32F73eoj96e4Nj+3YXYyV2IjU5U6NVYWa/GRh0q3IU4RXchNtJHsdFVkd1LBkzGclA1KWDAZBJMOQECBAgQIECAAAECBAiUFDBgUjKW7ZsyYBKTnnjMzX4IjU9Zv+JEDvUVvt+hPnp7gmP7dxdiJ3chNjpRoVdjZb0aG3WocBfiFN2F2EgfxUZXRXYvGTAZy0HVpIABk0kw5QQIECBAgAABAgQIECBQUsCASclYtm/KgElMeuIxN/shND5l/YoTOdRX+H6H+ujtCY7t312IndyF2OhEhV6NlfVqbNShwl2IU3QXYiN9FBtdFdm9ZMBkLAdVkwIGTCbBlBMgQIAAAQIECBAgQIBASQEDJiVj2b4pAyYx6YnH3OyH0PiU9StO5FBf4fsd6qO3Jzi2f3chdnIXYqMTFXo1VtarsVGHCnchTtFdiI30UWx0VWT3kgGTsRxUTQoYMJkEU06AAAECBAgQIECAAAECJQUMmJSMZfumDJjEpCcec7MfQuNT1q84kUN9he93qI/enuDY/t2F2MldiI1OVOjVWFmvxkYdKtyFOEV3ITbSR7HRVZHdSwZMxnJQNSlgwGQSTDkBAgQIECBAgAABAgQIlBQwYFIylu2bMmASk554zM1+CI1PWb8iO4cTGXQ4Q/1O6b/DDn3U4Qz9O+3+CTvk3OEM95O0wl2BDn3U4Qx3c3z689kZPH2+Xd+f/W96Aya7krLO7wQMmGgIAgQIECBAgAABAgQIEOggYMCkQ4rxGQyYxEYnHnOzH0LjU9avyM7hRAYdzlC/U/rvsEMfdThD/067f8IOOXc4w/0krXBXoEMfdTjD3Ryf/nx2Bk+fb9f3Z/+b3oDJrqSs8zsBAyYaggABAgQIECBAgAABAgQ6CBgw6ZBifAYDJrHRicfc7IfQ+JT1K7JzOJFBhzPU75T+O+zQRx3O0L/T7p+wQ84dznA/SSvcFejQRx3OcDfHpz+fncHT59v1/dn/pjdgsisp6/xOwICJhiBAgAABAgQIECBAgACBDgIGTDqkGJ/BgElsdOIxN/shND5l/YrsHE5k0OEM9Tul/w479FGHM/TvtPsn7JBzhzPcT9IKdwU69FGHM9zN8enPZ2fw9Pl2fX/2v+kNmOxKyjq/EzBgoiEIECBAgAABAgQIECBAoIOAAZMOKcZnMGASG514zM1+CI1PWb8iO4cTGXQ4Q/1O6b/DDn3U4Qz9O+3+CTvk3OEM95O0wl2BDn3U4Qx3c3z689kZPH2+Xd+f/W96Aya7krLO7wQMmGgIAgQIECBAgAABAgQIEOggYMCkQ4rxGQyYxEYnHnOzH0LjU9avyM7hRAYdzlC/U/rvsEMfdThD/067f8IOOXc4w/0krXBXoEMfdTjD3Ryf/nx2Bk+fb9f3Z/+b3oDJrqSs8zsBAyYaggABAgQIECBAgAABAgQ6CBgw6ZBifAYDJrHRicfc7IfQ+JT1K7JzOJFBhzPU75T+O+zQRx3O0L/T7p+wQ84dznA/SSvcFejQRx3OcDfHpz+fncHT59v1/dn/pjdgsisp6/xOwICJhiBAgAABAgQIECBAgACBDgIGTDqkGJ/BgElsdOIxN/shND5l/YrsHE5k0OEM9Tul/w479FGHM/TvtPsn7JBzhzPcT9IKdwU69FGHM9zN8enPZ2fw9Pl2fX/2v+kNmOxKyjq/EzBgoiEIECBAgAABAgQIECBAoIOAAZMOKcZnMGASG514zM1+CI1PWb8iO4cTGXQ4Q/1O6b/DDn3U4Qz9O+3+CTvk3OEM95O0wl2BDn3U4Qx3c3z689kZPH2+Xd+f/W96Aya7krLO7wQMmGgIAgQIECBAgAABAgQIEOggYMCkQ4rxGQyYxEYnHnOzH0LjU9avyM7hRAYdzlC/U/rvsEMfdThD/067f8IOOXc4w/0krXBXoEMfdTjD3Ryf/nx2Bk+fb9f3Z/+b3oDJrqSs8zsBAyYaggABAgQIECBAgAABAgQ6CBgw6ZBifAYDJrHRicfc7IfQ+JT1K7JzOJFBhzPU75T+O+zQRx3O0L/T7p+wQ84dznA/SSvcFejQRx3OcDfHpz+fncHT59v1/dn/pjdgsisp6/xOwICJhiBAgAABAgQIECBAgACBDgIGTDqkGJ/BgElsdOIxN/shND5l/YrsHE5k0OEM9Tul/w479FGHM/TvtPsn7JBzhzPcT9IKdwU69FGHM9zN8enPZ2fw9Pl2fX/2v+kNmOxKyjq/EzBgoiEIECBAgAABAgQIECBAoIOAAZMOKcZnMGASG514zM1+CI1PWb8iO4cTGXQ4Q/1O6b/DDn3U4Qz9O+3+CTvk3OEM95O0wl2BDn3U4Qx3c3z689kZPH2+Xd+f/W96Aya7krLO7wQMmGgIAgQIECBAgAABAgQIEOggYMCkQ4rxGQyYxEYnHnOzH0LjU9avOJFDfYXvd6iP3p7g2P7dhdjJXYiNTlTo1VhZr8ZGHSrchThFdyE20kex0VWR3UsGTMZyUDUpYMBkEkw5AQIECBAgQIAAAQIECJQUMGBSMpbtmzJgEpOeeMzNfgiNT1m/4kQO9RW+36E+enuCY/t3F2IndyE2OlGhV2NlvRobdahwF+IU3YXYSB/FRldFdi8ZMBnLQdWkgAGTSTDlBAgQIECAAAECBAgQIFBSwIBJyVi2b8qASUx64jE3+yE0PmX9ihM51Ff4fof66O0Jju3fXYid3IXY6ESFXo2V9Wps1KHCXYhTdBdiI30UG10V2b1kwGQsB1WTAgZMJsGUEyBAgAABAgQIECBAgEBJAQMmJWPZvikDJjHpicfc7IfQ+JT1K07kUF/h+x3qo7cnOLZ/dyF2chdioxMVejVW1quxUYcKdyFO0V2IjfRRbHRVZPeSAZOxHFRNChgwmQRTToAAAQIECBAgQIAAAQIlBQyYlIxl+6YMmMSkJx5zsx9C41PWrziRQ32F73eoj96e4Nj+3YXYyV2IjU5U6NVYWa/GRh0q3IU4RXchNtJHsdFVkd1LBkzGclA1KWDAZBJMOQECBAgQIECAAAECBAiUFDBgUjKW7ZsyYBKTnnjMzX4IjU9Zv+JEDvUVvt+hPnp7gmP7dxdiJ3chNjpRoVdjZb0aG3WocBfiFN2F2EgfxUZXRXYvGTAZy0HVpED2gMnkdpQTIECAAAECBAgQIECAAIGSAv/8H//xS8mNfdimDJjEgZ94zM1+CI1PWb/iRA71Fb7foT56e4Jj+3cXYid3ITY6UaFXY2W9Ght1qHAX4hTdhdhIH8VGV0V2LxkwGctB1aSAAZNJMOUECBAgQIAAAQIECBAg8JECBkxqxG7AJM7hxGNu9kNofMr6FSdyqK/w/Q71AAr8QAAAIABJREFU0dsTHNu/uxA7uQux0YkKvRor69XYqEOFuxCn6C7ERvooNroqsnvJgMlYDqomBQyYTIIpJ0CAAAECBAgQIECAAIGPFDBgUiN2AyZxDicec7MfQuNT1q84kUN9he93qI/enuDY/t2F2MldiI1OVOjVWFmvxkYdKtyFOEV3ITbSR7HRVZHdSwZMxnJQNSlgwGQSTDkBAgQIECBAgAABAgQIfKSAAZMasRswiXM48Zib/RAan7J+xYkc6it8v0N99PYEx/bvLsRO7kJsdKJCr8bKejU26lDhLsQpuguxkT6Kja6K7F4yYDKWg6pJAQMmk2DKCRAgQIAAAQIECBAgQOAjBQyY1IjdgEmcw4nH3OyH0PiU9StO5FBf4fsd6qO3Jzi2f3chdnIXYqMTFXo1VtarsVGHCnchTtFdiI30UWx0VWT3kgGTsRxUTQoYMJkEU06AAAECBAgQIECAAAECHylgwKRG7AZM4hxOPOZmP4TGp6xfcSKH+grf71AfvT3Bsf27C7GTuxAbnajQq7GyXo2NOlS4C3GK7kJspI9io6siu5cMmIzloGpSwIDJJJhyAgQIECBAgAABAgQIEPhIAQMmNWLvMGBSQ/LeLrIfQu/trsanParHOeij2KhDhbsQp+guxEYnKvRqrKxXY6MOFe5CnKK7EBvpo9joqsjuJQMmYzmomhQwYDIJppwAAQIECBAgQIAAAQIEPlLAgEmN2A2Y1Mgh+yG0xinv7cKjeuynj2KjDhXuQpyiuxAbnajQq7GyXo2NOlS4C3GK7kJspI9io6siu5cMmIzloGpSwIDJJJhyAgQIECBAgAABAgQIEPhIAQMmNWI3YFIjh+yH0BqnvLcLj+qxnz6KjTpUuAtxiu5CbHSiQq/Gyno1NupQ4S7EKboLsZE+io2uiuxeMmAyloOqSQEDJpNgygkQIECAAAECBAgQIEDgIwUMmNSI3YBJjRyyH0JrnPLeLjyqx376KDbqUOEuxCm6C7HRiQq9Givr1dioQ4W7EKfoLsRG+ig2uiqye8mAyVgOqiYFDJhMgiknQIAAAQIECBAgQIAAgY8UMGBSI3YDJjVyyH4IrXHKe7vwqB776aPYqEOFuxCn6C7ERicq9GqsrFdjow4V7kKcorsQG+mj2OiqyO4lAyZjOaiaFDBgMgmmnAABAgQIECBAgAABAgQ+UsCASY3YDZjUyCH7IbTGKe/twqN67KePYqMOFe5CnKK7EBudqNCrsbJejY06VLgLcYruQmykj2KjqyK7lwyYjOWgal7g/5v/iE8QIECAAAECBAgQIECAAIGPE/jl405c8MAGTGqEkv0QWuOU93bhUT3200exUYcKdyFO0V2IjU5U6NVYWa/GRh0q3IU4RXchNtJHsdFVkd1LBkzGclA1L2DAZN7MJwgQIECAAAECBAgQIEDg8wQMmBTI3IBJgRAOPITWOOW9XXhUj/2yH9TjHag4IeAuxMruQmx0okKvxsp6NTbqUOEuxCm6C7GRPoqNrorsXjJgMpaDqnkBAybzZj5BgAABAgQIECBAgAABAp8nYMCkQOYGTAqEcOAhtMYp7+3Co3rsl/2gHu9AxQkBdyFWdhdioxMVejVW1quxUYcKdyFO0V2IjfRRbHRVZPeSAZOxHFTNCxgwmTfzCQIECBAgQIAAAQIECBD4PAEDJgUyN2BSIIQDD6E1TnlvFx7VY7/sB/V4BypOCLgLsbK7EBudqNCrsbJejY06VLgLcYruQmykj2KjqyK7lwyYjOWgal7AgMm8mU8QIECAAAECBAgQIECAwOcJGDApkLkBkwIhHHgIrXHKe7vwqB77ZT+oxztQcULAXYiV3YXY6ESFXo2V9Wps1KHCXYhTdBdiI30UG10V2b1kwGQsB1XzAgZM5s18ggABAgQIECBAgAABAgQ+T8CASYHMDZgUCOHAQ2iNU97bhUf12C/7QT3egYoTAu5CrOwuxEYnKvRqrKxXY6MOFe5CnKK7EBvpo9joqsjuJQMmYzmomhcwYDJv9uMT/+t//d9/+sl/+Zf//af/95/Vr3z9z75jZa23f+apHGTw9s6xfwIECBAgQOCPAv/v//gfUyh/+/XXqXrFBBoIGDApEKIBkwIhHHgIrXHKe7vwqB77ZT+oxztQcULAXYiV3YXY6ESFXo2V9Wps1KHCXYhTdBdiI30UG10V2b1kwGQsB1XzAgZM5s1+fOKpwYbruw03/BbaUznIYPHi+BgBAgQIECBQVsCASdlobKyOgAGTAlkYMCkQwoGH0BqnvLcLj+qxX/aDerwDFScE3IVY2V2IjU5U6NVYWa/GRh0q3IU4RXchNtJHsdFVkd1LBkzGclA1L2DAZN7sxyeeGmy4vttww2+hPZWDDBYvjo8RIECAAAECZQUMmJSNxsbqCBgwKZCFAZMCIRx4CK1xynu78Kge+2U/qMc7UHFCwF2Ild2F2OhEhV6NlfVqbNShwl2IU3QXYiN9FBtdFdm9ZMBkLAdV8wIGTObNfnziqcGG67sNN/wW2lM5yGDx4vgYAQIECBAgUFbAgEnZaGysjoABkwJZGDApEMKBh9Aap7y3C4/qsV/2g3q8AxUnBNyFWNldiI1OVOjVWFmvxkYdKtyFOEV3ITbSR7HRVZHdSwZMxnJQNS9gwGTe7McnnhpsuL7bcMNvoT2VgwwWL46PESBAgAABAmUFDJiUjcbG6ggYMCmQhQGTAiEceAitccp7u/CoHvtlP6jHO1BxQsBdiJXdhdjoRIVejZX1amzUocJdiFN0F2IjfRQbXRXZvWTAZCwHVfMCBkzmzX584qnBhuu7DTf8FtpTOchg8eL4GAECBAgQIFBWwIBJ2WhsrI6AAZMCWRgwKRDCgYfQGqe8twuP6rFf9oN6vAMVJwTchVjZXYiNTlTo1VhZr8ZGHSrchThFdyE20kex0VWR3UsGTMZyUDUvYMAkMHtqgGE+yt6DJ2/JweDJSuf6DAECBAgQIHBS4GeDJH/79depbRhImeJS3EPAgEmBHA2YFAjhwENojVPe24VH9dgv+0E93oGKEwLuQqzsLsRGJyr0aqysV2OjDhXuQpyiuxAb6aPY6KrI7iUDJmM5qJoXMGASmL1lsOE6Rufhhrfk0DmD+Z8XnyBAgAABAgQqChgwqZiKPb1EwIBJgaAMmBQI4cBDaI1T3tuFR/XYL/tBPd6BihMC7kKs7C7ERicq9GqsrFdjow4V7kKcorsQG+mj2OiqyO4lAyZjOaiaFzBgEpi9ZbDhOkbn4Ya35NA5g/mfF58gQIAAAQIEKgoYMKmYij29RMCASYGgDJgUCOHAQ2iNU97bhUf12C/7QT3egYoTAu5CrOwuxEYnKvRqrKxXY6MOFe5CnKK7EBvpo9joqsjuJQMmYzmomhcwYBKYvWWw4TpG5+GGt+TQOYP5nxefIECAAAECBCoKGDCpmIo9vUTAgEmBoAyYFAjhwENojVPe24VH9dgv+0E93oGKEwLuQqzsLsRGJyr0aqysV2OjDhXuQpyiuxAb6aPY6KrI7iUDJmM5qJoXMGASmL1lsOE6Rufhhrfk0DmD+Z8XnyBAgAABAgQqChgwqZiKPb1EwIBJgaAMmBQI4cBDaI1T3tuFR/XYL/tBPd6BihMC7kKs7C7ERicq9GqsrFdjow4V7kKcorsQG+mj2OiqyO4lAyZjOaiaFzBgEpi9ZbDhOkbn4Ya35NA5g/mfF58gQIAAAQIEKgoYMKmYij29RMCASYGgDJgUCOHAQ2iNU97bhUf12C/7QT3egYoTAu5CrOwuxEYnKvRqrKxXY6MOFe5CnKK7EBvpo9joqsjuJQMmYzmomhcwYDJv9uMTPxt4+Nly3w0ezK618h2Lxyz/sVm7n+Uwu44MyreGDRIgQIAAAQLJArODKrP1ydu3PIEVAQMmK2qbP2PAZDOo5QgQIECAAAECBAgQIEDgEQEDJo+w+9INAgZMFhFnBxIMmCxCBx/blcPsOj/blv8Fk5ycrUqAAAECBAjUE5gdGJmtr3diOyLwTwZMCjSBAZMCIdgCAQIECBAgQIAAAQIECNwWMGBym9ACDwkYMFmEnx1IMGCyCB18bFcOs+v8bFsGTHJytioBAgQIECBQT2B2YGS2vt6J7YiAAZMKPWDApEIK9kCAAAECBAgQIECAAAECdwUMmNwV9PmnBAyYLMrPDiQYMFmEDj62K4fZdX62LQMmOTlblQABAgQIEKgnMDswMltf78R2RMCASYUeMGBSIQV7IECAAAECBAgQIECAAIG7AgZM7gr6/FMCBkwW5WcHEgyYLEIHH9uVw+w6P9uWAZOcnK1KgAABAgQI1BOYHRiZra93YjsiYMCkQg8YMKmQgj0QIECAAAECBAgQIECAwF0BAyZ3BX3+KQEDJovyswMJBkwWoYOP7cphdp2fbcuASU7OViVAgAABAgTqCcwOjMzW1zuxHREwYFKhBwyYVEjBHggQIECAAAECBAgQIEDgroABk7uCPv+UgAGTRfnZgQQDJovQwcd25TC7zs+2ZcAkJ2erEiBAgAABAvUEZgdGZuvrndiOCBgwqdADBkwqpGAPBAgQIECAAAECBAgQIHBXwIDJXUGff0rAgMmi/K6BhO++3rBCHE52DjKIM1BBgAABAgQIfKbAroGRXet8ZgpOfVjgl8Pf5+v+RMCAibYgQIAAAQIECBAgQIAAgQ4CBkw6pPiZZzBgsph79mDDtS3DDXE42TnIIM5ABQECBAgQIPCZArsGQ3at85kpOPVhAQMmh8H/7OsMmBQIwRYIECBAgAABAgQIECBA4LaAAZPbhBZ4SMCAySJ89mDDtS3DDXE42TnIIM5ABQECBAgQIPCZArsGQ3at85kpOPVhAQMmh8H/7OsMmBQIwRYIECBAgAABAgQIECBA4LaAAZPbhBZ4SMCAySJ89mDDtS3DDXE42TnIIM5ABQECBAgQIPCZArsGQ3at85kpOPVhAQMmh8H/7OsMmBQIwRYIECBAgAABAgQIECBA4LaAAZPbhBZ4SMCAySJ89mDDtS3DDXE42TnIIM5ABQECBAgQIPCZArsGQ3at85kpOPVhAQMmh8H/7OsMmBQIwRYIECBAgAABAgQIECBA4LaAAZPbhBZ4SMCAySJ89mDDtS3DDXE42TnIIM5ABQECBAgQIPCZArsGQ3at85kpOPVhAQMmh8H/7OsMmBQIwRYIECBAgAABAgQIECBA4LaAAZPbhBZ4SMCAySL87GCDQYVF6OBjcshxtSoBAgQIECBA4P8I7BoA+dk6P5P+26+/CoFANQEDJgUSMWBSIARbIECAAAECBAgQIECAAIHbAgZMbhNa4CEBAyaL8AYbFuE2f0wOm0EtR4AAAQIECBD4g4ABEy1B4B8CBkwKNIMBkwIh2AIBAgQIECBAgAABAgQI3BYwYHKb0AIPCRgwWYQ32LAIt/ljctgMajkCBAgQIECAwB8EDJhoCQL/EDBgUqAZDJgUCMEWCBAgQIAAAQIECBAgQOC2gAGT24QWeEjAgMkivMGGRbjNH5PDZlDLESBAgAABAgT+IGDAREsQ+IeAAZMCzWDApEAItkCAAAECBAgQIECAAAECtwUMmNwmtMBDAgZMFuENNizCbf6YHDaDWo4AAQIECBAg8AcBAyZagsA/BAyYFGgGAyYFQrAFAgQIECBAgAABAgQIELgtYMDkNqEFHhIwYLIIb7BhEW7zx+SwGdRyBAgQIECAAIE/CBgw0RIE/iFgwKRAMxgwKRCCLRAgQIAAAQIECBAgQIDAbQEDJrcJLfCQgAGTRXiDDYtwmz8mh82gliNAgAABAgQ+VuCpQZJZ8L/9+uvsR9QT2CVgwGSX5I11DJjcwPNRAgQIECBAgAABAgQIECgjYMCkTBQ2MilgwGQS7P+UG2xYhNv8MTlsBrUcAQIECBAg8LECBkw+NnoHHxcwYDJulVZpwCSN1sIECBAgQIAAAQIECBAgcFDAgMlBbF+1VcCAySKnwYZFuM0fk8NmUMsRIECAAAECHytgwORjo3fwcQEDJuNWaZUGTNJoLUyAAAECBAgQIECAAAECBwUMmBzE9lVbBQyYLHIabFiE2/wxOWwGtRwBAgQIECDwsQIGTD42egcfFzBgMm6VVmnAJI3WwgQIECBAgAABAgQIECBwUMCAyUFsX7VVwIDJIqfBhkW4zR+Tw2ZQyxEgQIAAAQIfK2DA5GOjd/BxAQMm41ZplQZM0mgtTIAAAQIECBAgQIAAAQIHBQyYHMT2VVsFDJgschpsWITb/DE5bAa1HAECBAgQIPCxAgZMPjZ6Bx8XMGAybpVWacAkjdbCBAgQIECAAAECBAgQIHBQwIDJQWxftVXAgMki5+xgw8rX/Mu//O+Vj33UZ7JzkMFHtZPDEiBAgACBjxb42YDJz1D+9uuvf/r/ml1nFv1n3zu7jnoCCwIGTBbQdn+kw4BJ9iPiv/7rv+5m/2/rvf0M2fu/wLJzcIa4zbMzuHaQnYMzxDlnZ+A+xxmcqJDzmHL2b0Z2Dtn797v9GX3kd3ssZ/c5durwm/TLL7+Ue8cot6G4FVT8iYABk8W2yB5suLZluCEOJzsHGcQZqCBAgAABAgR6CMwOhhgw6ZG7U0wJeAeZ4sopNmASu3Z4CM0+Q/aDuj9sxH3qj3xjRtl3oUMO7nOdXhrbyVqVnMfcsn8zsnPI3n+H37wOZ8juI/8OG/u9yM7Bfa6RgwGTsRxUzQsYMJk3+/GJ7MGG6zsMN8ThZOcggzgDFQQIECBAgEAPAQMmPXJ0ilQBAyapvGOLGzCJnTzmxkbZD+r+sBFn0OEPZM4wlnP2b5L7XCOHsV2sV8l5zO7t9y17/363P6OP/DtsLOfs31X3uUYOBkzGclA1L2DAZN7sxyeyBxuu7zDcEIeTnYMM4gxUECBAgAABAj0EDJj0yNEpUgUMmKTyji1uwCR28pgbG2U/qPvDRpyBP/KNGbnPsZP7HBud+E0a28V6lZzH7LJ/M7JzyN6///Z8Rh+d+M3LvgsdzuA+j9237F4yYDKWg6p5AQMm82Y/PpE92HB9h+GGOJzsHGQQZ6CCAAECBAgQ6CFgwKRHjk6RKmDAJJV3bHEDJrGTx9zYKPsht8MfBTqcwV2I70KHP7a6z2M5n7gPYztZq5LzmFt2ztk5ZO+/w29ehzNk91GHf8N0OIP7PPa7nX0fDJiM5aBqXsCAybzZj09kDzZc32G4IQ4nOwcZxBmoIECAAAECBHoIGDDpkaNTpAoYMEnlHVvcgEns5DE3Nsp+yO3wR4EOZ3AX4rvgD5VjRtm91OE3aUxyvaqDkTPE+WfftQ6/eR3O4C7Ed8G/w8aMsnupw2+SAZOxXlI1L2DAZN7sxyeyBxtWtvWJwxDVcvjEDFZ61WcIECBAgACB5wRmB0lmd/q3X3/904/Mfu/P1pndj3oCGwUMmGzEXF3KgEks1+EhNPsM2Y/RHf4o0OEM2X3U4Y98Hc7gPsf/XThxn8d2sV4l5zG77N+97Byy99/hN6/DGbL76MRvnjPEv0nuc2x04j4bMBnLQdW8gAGTebMfn6g22HDt6ROHG6rl8IkZLF4hHyNAgAABAgQeEpgd9JjdpgGTWTH1LxIwYFIgLAMmcQgec2MjfxSIjTr8ccZdGMs5+z5k55C9/w534cQZxrptvUrOY3Zvv2/Z+z/xx1xniHvVfY6NTvxuZ+fgLozlnJ2DAZOxHFTNCxgwmTf78Ylqgw3Xnj5xuKFaDp+YweIV8jECBAgQIEDgIQEDJg/B+9oOAgZMCqRowCQOwWNubJT9kNvhjwIdzuAuxHehwx9b3eexnE/ch7GdrFXJecwtO+fsHLL33+E3r8MZsvuow79hOpzBfR773c6+DwZMxnJQNS9gwGTe7Mcnqg02XHv6xOGGajl8YgaLV8jHCBAgQIAAgYcEDJg8BO9rOwgYMCmQogGTOASPubFR9kNuhz8KdDiDuxDfBX+oHDPK7qUOv0ljkutVHYycIc4/+651+M3rcAZ3Ib4L/h02ZpTdSx1+kwyYjPWSqnkBAybzZj8+UW2w4drTJw43VMvhEzNYvEI+RoAAAQIECDwkYMDkIXhf20HAgEmBFA2YxCF0eAjNPkP2Y3SHPwp0OEN2H3X4I1+HM7jP8X8XTtznsV2sV8l5zC77dy87h+z9d/jN63CG7D468ZvnDPFvkvscG524zwZMxnJQNS9gwGTe7Mcnqg02XHv6xOGGajl8YgaLV8jHCBAgQIAAgYcEDJg8BO9rOwgYMCmQogGTOASPubGRPwrERh3+OOMujOWcfR+yc8jef4e7cOIMY922XiXnMbu337fs/Z/4Y64zxL3qPsdGJ363s3NwF8Zyzs7BgMlYDqrmBQyYzJt9+4knBx4MN/wWzVM5yGDzhbIcAQIECBAgsF3gqQGT7QexIIHzAgZMzpv/t2/sMGBSgNEWCBAgQIAAAQIECBAgQOBhAQMmDwfg65cFDJgs0/35B58abLh2Y7jht0yeykEGmy+U5QgQIECAAIHtAgZMtpNa8HMEDJgUyNqASYEQbIEAAQIECBAgQIAAAQIEbgsYMLlNaIGHBAyYbIZ/arDhOobhht/CfCoHGWy+UJYjQIAAAQIEtgsYMNlOasHPETBgUiBrAyYFQrAFAgQIECBAgAABAgQIELgtYMDkNqEFHhIwYLIZ/qnBhusYhht+C/OpHGSw+UJZjgABAgQIENguYMBkO6kFP0fAgEmBrA2YFAjBFggQIECAAAECBAgQIEDgtoABk9uEFnhIwIDJZvinBhuuYxhu+C3Mp3KQweYLZTkCBAgQIEBgu4ABk+2kFvwcAQMmBbI2YFIgBFsgQIAAAQIECBAgQIAAgdsCBkxuE1rgIQEDJpvhnxpsuI5huOG3MJ/KQQabL5TlCBAgQIAAge0CBky2k1rwcwQMmBTI2oBJgRBsgQABAgQIECBAgAABAgRuCxgwuU1ogYcEDJgcgt858GCIYT20XTnIYD0DnyRAgAABAgRqCswOnvzt119rHsSuCOQJGDDJsx1e2YDJMJVCAgQIECBAgAABAgQIECgsYMCkcDi29q2AAZNDDbJrsOHaruGG9dB25SCD9Qx8kgABAgQIEKgpYMCkZi52VUrAgEmBOAyYFAjBFggQIECAAAECBAgQIEDgtoABk9uEFnhIwIDJIfhdgw3Xdg03rIe2KwcZrGfgkwQIECBAgEBNAQMmNXOxq1ICBkwKxGHApEAItkCAAAECBAgQIECAAAECtwUMmNwmtMBDAgZMDsHvGmy4tmu4YT20XTnIYD0DnyRAgAABAgRqChgwqZmLXZUSMGBSIA4DJgVCsAUCBAgQIECAAAECBAgQuC1gwOQ2oQUeEjBgcgh+12DDtV3DDeuh7cpBBusZ+CQBAgQIECBQU8CASc1c7KqUgAGTAnEYMCkQgi0QIECAAAECBAgQIECAwG0BAya3CS3wkIABk0PwuwYbru0ablgPbVcOMljPwCcJECBAgACBmgIGTGrmYlelBAyYFIjDgEmBEGyBAAECBAgQIECAAAECBG4LGDC5TWiBhwQMmDwE72sJECBAgAABAgQIECBA4FUCBkwKxGXApEAItkCAAAECBAgQIECAAAECtwUMmNwmtMBDAgZMHoL3tQQIECBAgAABAgQIECDwKgEDJgXiMmBSIARbIECAAAECBAgQIECAAIHbAgZMbhNa4CEBAyYPwftaAgQIECBAgAABAgQIEHiVgAGTAnEZMCkQgi0QIECAAAECBAgQIECAwG0BAya3CS3wkIABk4fgfS0BAgQIECBAgAABAgQIvErAgEmBuAyYFAjBFggQIECAAAECBAgQIEDgtoABk9uEFnhIwIDJQ/C+lgABAgQIECBAgAABAgReJWDApEBcBkwKhGALBAgQIECAAAECBAgQIHBbwIDJbUILPCRgwOQheF9LgAABAgQIECBAgAABAq8SMGBSIC4DJgVCsAUCBAgQIECAAAECBAgQuC1gwOQ2oQUeEjBg8hC8ryVAgAABAgQIECBAgACBVwkYMCkQlwGTAiHYAgECBAgQIECAAAECBAjcFjBgcpvQAg8JGDB5CN7XEiBAgAABAgQIECBAgMCrBAyYFIjLgEmBEGyBAAECBAgQIECAAAECBG4LGDC5TWiBhwQMmDwE72sJECBAgAABAgQIECBA4FUCBkwKxGXApEAItkCAAAECBAgQIECAAAECtwUMmNwmtMBDAgZMHoL3tQQIECBAgAABAgQIECDwKgEDJgXiMmBSIARbIECAAAECBAgQIECAAIHbAgZMbhNa4CEBAyYPwftaAgQIECBAgAABAgQIEHiVgAGTAnEZMCkQgi0QIECAAAECBAgQIECAwG0BAya3CS3wkIABk4fgfS0BAgQIECBAgAABAgQIvErAgEmBuAyYFAjBFggQIECAAAECBAgQIEDgtoABk9uEFnhIwIDJQ/C+lgABAgQIECBAgAABAgReJWDApEBcBkwKhGALBAgQIECAAAECBAgQIHBbwIDJbUILPCRgwOQheF9LgAABAgQIECBAgAABAq8SMGBSIC4DJgVCsAUCBAgQIECAAAECBAgQuC1gwOQ2oQUeEjBg8hC8ryVAgAABAgQIECBAgACBVwkYMCkQlwGTAiHYAgECBAgQIECAAAECBAjcFjBgcpvQAg8JGDB5CN7XEiBAgAABAgQIECBAgMCrBAyYFIjLgEmBEGyBAAECBAgQIECAAAECBG4LGDC5TWiBhwQMmDwE72sJECBAgAABAgQIECBA4FUCBkwKxGXApEAItkCAAAECBAgQIECAAAECtwUMmNwmtMBDAgZMHoL3tQQIECBAgAABAgQIECDwKgEDJgXiMmBSIARbIECAAAECBAgQIECAAIHbAgZMbhNa4CEBAyYPwftaAgQIECBAgAABAgQIEHiVgAGTAnEZMCkQgi0QIECAAAECBAgQIECAwG2p/aREAAAgAElEQVQBAya3CS3wkIABk4fgfS0BAgQIECBAgAABAgQIvErAgEmBuAyYFAjBFggQIECAAAECBAgQIEDgtoABk9uEFnhIwIDJQ/C+lgABAgQIECBAgAABAgReJWDApEBcBkwKhGALBAgQIECAAAECBAgQIHBbwIDJbUILPCRgwOQheF9LgAABAgQIECBAgAABAq8SMGBSIC4DJgVCsAUCBAgQIECAAAECBAgQuC1gwOQ2oQUeEjBg8hC8ryVAgAABAgQIECBAgACBVwkYMCkQlwGTAiHYAgECBAgQIECAAAECBAjcFjBgcpvQAg8JGDB5CN7XEiBAgAABAgQIECBAgMCrBAyYFIjLgEmBEGyBAAECBAgQIECAAAECBG4LGDC5TWiBhwQMmDwE72sJECBAgAABAgQIECBA4FUCBkwKxJU9YFLgiLZAgAABAgQIECBAgAABAgRuC/zyyy/l3jHKbei28mcuYMDkM3N3agIECBAgQGBR4O//z18XP/n7j/313/++ZR2LECBAgMAxAe8gx6h//kUGTAqEYAsECBAgQIAAAQIECBAgUF7AgEn5iF67QQMmr43OxgkQIECAAIEnBAyYPKHuOwkQIFBCwIBJgRgMmBQIwRYIECBAgAABAgQIECBAoLyAAZPyEb12gwZMXhudjRMgQIAAAQJPCBgweULddxIgQKCEgAGTAjEYMCkQgi0QIECAAAECBAgQIECAQHkBAyblI3rtBg2YvDY6GydAgAABAgSeEDBg8oS67yRAgEAJAQMmBWIwYFIgBFsgQIAAAQIECBAgQIAAgfICBkzKR/TaDRoweW10Nk6AAAECBAg8IWDA5Al130mAAIESAgZMCsRgwKRACLZAgAABAgQIECBAgAABAuUFDJiUj+i1GzRg8trobJwAAQIECBB4QsCAyRPqvpMAAQIlBAyYFIjBgEmBEGyBAAECBAgQIECAAAECBMoLGDApH9FrN2jA5LXR2TgBAgQIECCQKTA7SPLXf//7n25n1zqZZ7U2AQIECAwJGDAZYsotMmCS62t1AgQIECBAgAABAgQIEOghYMCkR44VT2HApGIq9kSAAAECBAg8LrBrMGTXOo+D2AABAgQIGDAp0AMGTAqEYAsECBAgQIAAAQIECBAgUF7AgEn5iF67QQMmr43OxgkQIECAAIFMgV2DIbvWyTyrtQkQIEBgSMCAyRBTbpEBk1xfqxMgQIAAAQIECBAgQIBADwEDJj1yrHgKAyYVU7EnAgQIECBA4HGBXYMhu9Z5HMQGCBAgQMCASYEeMGBSIARbIECAAAECBAgQIECAAIHyAgZMykf02g0aMHltdDZOgAABAgQIZArsGgzZtU7mWa1NgAABAkMCBkyGmHKLDJjk+lqdAAECBAgQIECAAAECBHoIGDDpkWPFUxgwqZiKPREgQIAAAQKPC+waDNm1zuMgNkCAAAECBkwK9IABkwIh2AIBAgQIECBAgAABAgQIlBcwYFI+otdu0IDJa6OzcQIECBAgQOCuwOzwx/V9f/33v9/92h+fn/3uXd+7ZfMWIUCAwGcKGDCpkbt3jAI5/Nd//dfULv7yl79M1SuOBWQQG6kgQIAAAQIEPlPgP//zP6cO/m//9m9T9YoJvEig3DtGuQ29KMxKW/UwUykNeyFAgAABAgSOCswOeVyb2zXoMfvdu773KLAvI0CAQC8B7yA18vSOUSAHww3PhyCD5zOwAwIECBAgQKCmgAGTmrnY1SMC5d4xym3okVje/6UeZt6foRMQIECAAAECiwKzQx7X1+wa9Jj97l3fu0jlYwQIECDwT//kHaRGF3jHKJCD4YbnQ5DB8xnYAQECBAgQIFBTwIBJzVzs6hGBcu8Y5Tb0SCzv/1IPM+/P0AkIECBAgACBRYHZIY/ra3YNesx+967vXaTyMQIECBAwYFKlB7xjFEjCcMPzIcjg+QzsgAABAgQIEKgpYMCkZi529YhAuXmOcht6JJb3f6mHmfdn6AQECBAgQIDAosDskMf1NbsGPWa/e9f3LlL5GAECBAgYMKnSA94xCiRhuOH5EGTwfAZ2QIAAAQIECNQUMGBSMxe7ekSg3DxHuQ09Esv7v9TDzPszdAICBAgQIEBgUWB2yOP6ml2DHrPfvet7F6l8jAABAgQMmFTpAe8YBZIw3PB8CDJ4PgM7IECAAAECBGoKGDCpmYtdPSJQbp6j3IYeieX9X+ph5v0ZOgEBAgQIECCwKDA75HF9za5Bj9nv3vW9i1Q+RoAAAQIGTKr0gHeMAkkYbng+BBk8n4EdECBAgAABAjUFDJjUzMWuHhEoN89RbkOPxPL+L/Uw8/4MnYAAAQIECBBYFJgd8ri+Ztegx+x37/reRSofI0CAAAEDJlV6wDtGgSQMNzwfggyez8AOCBAgQIAAgZoCBkxq5mJXjwiUm+cot6FHYnn/l3qYeX+GTkCAAAECBAgsCswOeVxfs2vQY/a7d33vIpWPESBAgIABkyo94B2jQBKGG54PQQbPZ2AHBAgQIECAQE0BAyY1c7GrRwTKzXOU29Ajsbz/Sz3MvD9DJyBAgAABAgQWBWaHPK6v2TXoMfvdu753kcrHCBAgQMCASZUe8I5RIAnDDc+HIIPnM7ADAgQIECBAoKaAAZOaudjVIwLl5jnKbeiRWN7/pR5m3p+hExAgQIAAAQKLArNDHtfX7Br0mP3uXd+7SOVjBAgQIGDApEoPeMcokIThhudDkMHzGdgBAQIECBAgUFPAgEnNXOzqEYFy8xzlNvRILO//Ug8z78/QCQgQIECAAIFFgdkhj+trdg16zH73ru9dpPIxAgQIEDBgUqUHvGMUSMJww/MhyOD5DOyAAAECBAgQqClgwKRmLnb1iEC5eY5yG3oklvd/qYeZ92foBAQIECBAgMCiwOyQx/U1uwY9Zr971/cuUvkYAQIECBgwqdID3jE2JzE7qLD56/90ub/85S8nvqbUd8ihVBw2Q4AAAQIECBAgQKCDQLl5jnIb6pDyA2fwMPMAuq8kQIAAAQIEagjMDnlcu9416DH73bu+t4a8XRAgQOCVAt5BasTmHWNzDgYbNoMuLieHRTgfI0CAAAECBAgQIEDgZwLl3jHKbUjvLAl4mFli8yECBAgQIECgg8DskMd15l2DHrPfvet7O+TmDAQIEHhIwDvIQ/B/+FrvGJtzMNiwGXRxOTkswvkYAQIECBAgQIAAAQI/Eyj3jlFuQ3pnScDDzBKbDxEgQIAAAQIdBGaHPK4z7xr0mP3uXd/bITdnIECAwEMC3kEegv/D13rH2JyDwYbNoIvLyWERzscIECBAgAABAgQIEPiZQLl3jHIb0jtLAh5mlth8iAABAgQIEOggMDvkcZ1516DH7Hfv+t4OuTkDAQIEHhLwDvIQ/B++1jvG5hwMNmwGXVxODotwPkaAAAECBAgQIECAwM8Eyr1jlNuQ3lkS8DCzxOZDBAgQIECAQAeB2SGP68y7Bj1mv3vX93bIzRkIECDwkIB3kIfg//C13jE252CwYTPo4nJyWITzMQIECBAgQIAAAQIEfiZQ7h2j3Ib0zpKAh5klNh8iQIAAAQIEugvsGgDZtU53b+cjQIDACwS8g9QIyTvG5hwMNmwGXVxODotwPkaAAAECBAgQIECAwM8Eyr1jlNuQ3lkS8DCzxOZDBAgQIECAQHeBXYMhu9bp7u18BAgQeIGAd5AaIXnH2JyDwYbNoIvLyWERzscIECBAgAABAgQIEPiZQLl3jHIb0jtLAh5mlth8iAABAgQIEOgusGswZNc63b2djwABAi8Q8A5SIyTvGJtzMNiwGXRxOTkswvkYAQIECBAgQIAAAQI/Eyj3jlFuQ3pnScDDzBKbDxEgQIAAAQLdBXYNhuxap7u38xEgQOAFAt5BaoTkHWNzDgYbNoMuLieHRTgfI0CAAAECBAgQIEDgZwLl3jHKbUjvLAl4mFli8yECBAgQIECgu8CuwZBd63T3dj4CBAi8QMA7SI2QvGNszsFgw2bQxeXksAjnYwQIECBAgAABAgQI/Eyg3DtGuQ3pnSUBDzNLbD5EgAABAgQIdBfYNRiya53u3s5HgACBFwh4B6kRkneMzTkYbNgMuricHBbhfIwAAQIECBAgQIAAgZ8JlHvHKLchvbMk4GFmic2HCBAgQIAAgU8VmB0Y+ZnTX//9759K6NwECBB4q4B3kLcmZ98ECBAgQIAAAQIECBAgQIDA4wIeVh6PYMsGDJhsYbQIAQIECBAg8CkCBkw+JWnnJECAwH8T8A6iKQgQIECAAAECBAgQIECAAAECiwIeVhbhin3MgEmxQGyHAAECBAgQqC1gwKR2PnZHgACBRAHvIIm4liZAgAABAgQIECBAgAABAgR6C3hY6ZGvAZMeOToFAQIECBAgcEjAgMkhaF9DgACBegLeQeplYkcECBAgQIAAAQIECBAgQIDASwQ8rLwkqGCbBkx65OgUBAgQIECAwCEBAyaHoH0NAQIE6gl4B6mXiR0RIECAAAECBAgQIECAAAECLxHwsPKSoIJtGjDpkaNTECBAgAABAocEDJgcgvY1BAgQqCfgHaReJnZEgAABAgQIECBAgAABAgQIvETAw8pLggq2acCkR45OQYAAAQIECBAgQIAAAQK5At5Bcn2tToAAAQIECBAgQIAAAQIECDQW8LDSI1wDJj1ydAoCBAgQIECAAAECBAgQyBXwDpLra3UCBAgQIECAAAECBAgQIECgsYCHlR7hGjDpkaNTECBAgAABAgQIECBAgECugHeQXF+rEyBAgAABAgQIECBAgAABAo0FPKz0CNeASY8cnYIAAQIECBAgQIAAAQIEcgW8g+T6Wp0AAQIECBAgQIAAAQIECBBoLOBhpUe4Bkx65OgUBAgQIECAAAECBAgQIJAr4B0k19fqBAgQIECAAAECBAgQIECAQGMBDys9wjVg0iNHpyBAgAABAgQIECBAgACBXAHvILm+VidAgAABAgQIECBAgAABAgQaC3hY6RGuAZMeOToFAQIECBAgQIAAAQIECOQKeAfJ9bU6AQIECBAgQIAAAQIECBAg0FjAw0qPcA2Y9MjRKQgQIECAAAECBAgQIEAgV8A7SK6v1QkQIECAAAECBAgQIECAAIHGAh5WeoRrwKRHjk5BgAABAgQIECBAgAABArkC3kFyfa1OgAABAgQIECBAgAABAgQINBbwsNIjXAMmPXJ0CgIECBAgQIAAAQIECBDIFfAOkutrdQIECBAgQIAAAQIECBAgQKCxgIeVHuEaMOmRo1MQIECAAAECBAgQIECAQK6Ad5BcX6sTIECAAAECBAgQIECAAAECjQU8rPQI14BJjxydggABAgQIECBAgAABAgRyBbyD5PpanQABAgQIECBAgAABAgQIEGgs4GGlR7gGTHrk6BQECBAgQIAAAQIECBAgkCvgHSTX1+oECBAgQIAAAQIECBAgQIBAYwEPKz3CNWDSI0enIECAAAECBAgQIECAAIFcAe8gub5WJ0CAAAECBAgQIECAAAECBBoLeFjpEa4Bkx45OgUBAgQIECBAgAABAgQI5Ap4B8n1tToBAgQIECBAgAABAgQIECDQWMDDSo9wDZj0yNEpCBAgQIAAAQIECBAgQCBXwDtIrq/VCRAgQIAAAQIECBAgQIAAgcYCHlZ6hGvApEeOTkGAAAECBAgQIECAAAECuQLeQXJ9rU6AAAECBAgQIECAAAECBAg0FvCw0iNcAyY9cnQKAgQIECBAgAABAgQIEMgV8A6S62t1AgQIECBAgAABAgQIECBAoLGAh5Ue4Row6ZGjUxAgQIAAAQIECBAgQIBAroB3kFxfqxMgQIAAAQIECBAgQIAAAQKNBTys9AjXgEmPHJ2CAAECBAgQIECAAAECBHIFvIPk+lqdAAECBAgQIECAAAECBAgQaCzgYaVHuAZMeuToFAQIECBAgAABAgQIECCQK+AdJNfX6gQIECBAgAABAgQIECBAgEBjAQ8rPcI1YNIjR6cgQIAAAQIECBAgQIAAgVwB7yC5vlYnQIAAAQIECBAgQIAAAQIEGgt4WOkRrgGTHjk6BQECBAgQIECAAAECBAjkCngHyfW1OgECBAgQIECAAAECBAgQINBYwMNKj3ANmPTI0SkIECBAgAABAgQIECBAIFfAO0iur9UJECBAgAABAgQIECBAgACBxgIeVnqEa8CkR45OQYAAAQIECBAgQIAAAQK5At5Bcn2tToAAAQIECBAgQIAAAQIECDQW8LDSI1wDJj1ydAoCBAgQIECAAAECBAgQyBXwDpLra3UCBAgQIECAAAECBAgQIECgsYCHlR7hGjDpkaNTECBAgAABAgQIECBAgECugHeQXF+rEyBAgAABAgQIECBAgAABAo0FPKz0CNeASY8cnYIAAQIECBAgQIAAAQIEcgW8g+T6Wp0AAQIECBAgQIAAAQIECBBoLOBhpUe4Bkx65OgUBAgQIECAAAECBAgQIJAr4B0k19fqBAgQIECAAAECBAgQIECAQGMBDys9wjVg0iNHpyBAgAABAgQIECBAgACBXAHvILm+VidAgAABAgQIECBAgAABAgQaC3hY6RGuAZMeOToFAQIECBAgQIAAAQIECOQKeAfJ9bU6AQIECBAgQIAAAQIECBAg0FjAw0qPcA2Y9MjRKQgQIECAAAECBAgQIEAgV8A7SK6v1QkQIECAAAECBAgQIECAAIHGAh5WeoRrwKRHjk5BgAABAgQIECBAgAABArkC3kFyfa1OgAABAgQIECBAgAABAgQINBbwsNIjXAMmPXJ0CgIECBAgQIAAAQIECBDIFfAOkutrdQIECBAgQIAAAQIECBAgQKCxgIeVHuEaMOmRo1MQIECAAAECBAgQIECAQK6Ad5BcX6sTIECAAAECBAgQIECAAAECjQU8rPQI14BJjxydggABAgQIECBAgAABAgRyBbyD5PpanQABAgQIECBAgAABAgQIEGgs4GGlR7gGTHrk6BQECBAgQIAAAQIECBAgkCvgHSTX1+oECBAgQIAAAQIECBAgQIBAYwEPKz3CNWDSI0enIECAAAECBAgQIECAAIFcAe8gub5WJ0CAAAECBAgQIECAAAECBBoLeFjpEa4Bkx45OgUBAgQIECBAgAABAgQI5Ap4B8n1tToBAgQIECBAgAABAgQIECDQWMDDSo9wDZj0yNEpCBAgQIAAAQIECBAgQCBXwDtIrq/VCRAgQIAAAQIECBAgQIAAgcYCHlZ6hGvApEeOTkGAAAECBAgQIECAAAECuQLeQXJ9rU6AAAECBAgQIECAAAECBAg0FvCw0iNcAyY9cnQKAgQIECBAgAABAgQIEMgV8A6S62t1AgQIECBAgAABAgQIECBAoLGAh5Ue4Row6ZGjUxAgQIAAAQIECBAgQIBAroB3kFxfqxMgQIAAAQIECBAgQIAAAQKNBTys9AjXgEmPHJ2CAAECBAgQIECAAAECBHIFvIPk+lqdAAECBAgQIECAAAECBAgQaCzgYaVHuAZMeuToFAQIECBAgAABAgQIECCQK+AdJNfX6gQIECBAgAABAgQIECBAgEBjAQ8rPcI1YNIjR6cgQIAAAQIECBAgQIAAgVwB7yC5vlYnQIAAAQIECBAgQIAAAQIEGgt4WOkRrgGTHjk6BQECBAgQIECAAAECBAjkCngHyfW1OgECBAgQIECAAAECBAgQINBYwMNKj3ANmPTI0SkIECBAgAABAgQIECBAIFfAO0iur9UJECBAgAABAgQIECBAgACBxgIeVnqEa8CkR45OQYAAAQIECBAgQIAAAQK5At5Bcn2tToAAAQIECBAgQIAAAQIECDQW8LDSI1wDJj1ydAoCBAgQIECAAAECBAgQyBXwDpLra3UCBAgQIECAAAECBAgQIECgsYCHlR7hGjDpkaNTECBAgAABAgQIECBAgECugHeQXF+rEyBAgAABAgQIECBAgAABAo0FPKz0CNeASY8cnYIAAQIECBAgQIAAAQIEcgW8g+T6Wp0AAQIECBAgQIAAAQIECBBoLOBhpUe4Bkx65OgUBAgQIECAAAECBAgQIJAr4B0k19fqBAgQIECAAAECBAgQIECAQGMBDys9wjVg0iNHpyBAgAABAgQIECBAgACBXAHvILm+VidAgAABAgQIECBAgAABAgQaC3hY6RGuAZMeOToFAQIECBAgQIAAAQIECOQKeAfJ9bU6AQIECBAgQIAAAQIECBAg0FjAw0qPcA2Y9MjRKQgQIECAAAECBAgQIEAgV8A7SK6v1QkQIECAAAECBAgQIECAAIHGAh5WeoRrwKRHjk5BgAABAgQIECBAgAABArkC3kFyfa1OgAABAgQIECBAgAABAgQINBbwsNIjXAMmPXJ0CgIECBAgQIAAAQIECBDIFfAOkutrdQIECBAgQIAAAQIECBAgQKCxgIeVHuEaMOmRo1MQIECAAAECBAgQIECAQK6Ad5BcX6sTIECAAAECBAgQIECAAAECjQU8rPQI14BJjxydggABAgQIECBAgAABAgRyBbyD5PpanQABAgQIECBAgAABAgQIEGgs4GGlR7gGTHrk6BQECBAgQIAAAQIECBAgkCvgHSTX1+oECBAgQIAAAQIECBAgQIBAYwEPKz3CNWDSI0enIECAAAECBAgQIECAAIFcAe8gub5WJ0CAAAECBAgQIECAAAECBBoLeFjpEa4Bkx45OgUBAgQIECBAgAABAgQI5Ap4B8n1tToBAgQIECBAgAABAgQIECDQWMDDSo9wDZj0yNEpCBAgQIAAAQIECBAgQCBXwDtIrq/VCRAgQIAAAQIECBAgQIAAgcYCHlZ6hGvApEeOTkGAAAECBAgQIECAAAECuQLeQXJ9rU6AAAECBAgQIECAAAECBAg0FvCw0iNcAyY9cnQKAgQIECBAgAABAgQIEMgV8A6S62t1AgQIECBAgAABAgQIECBAoLGAh5Ue4Row6ZGjUxAgQIAAAQIECBAgQIBAroB3kFxfqxMgQIAAAQIECBAgQIAAAQKNBTys9AjXgEmPHJ2CAAECBAgQIECAAAECBHIFvIPk+lqdAAECBAgQIECAAAECBAgQaCzgYaVHuAZMeuToFAQIECBAgAABAgQIECCQK+AdJNfX6gQIECBAgAABAgQIECBAgEBjAQ8rPcI1YNIjR6cgQIAAAQIECBAgQIAAgVwB7yC5vlYnQIAAAQIECBAgQIAAAQIEGgt4WOkRrgGTHjk6BQECBAgQIECAAAECBAjkCngHyfW1OgECBAgQIECAAAECBAgQINBYwMNKj3ANmPTI0SkIECBAgAABAgQIECBAIFfAO0iur9UJECBAgAABAgQIECBAgACBxgIeVnqEa8CkR45OQYAAAQIECBAgQIAAAQK5At5Bcn2tToAAAQIECBAgQIAAAQIECDQW8LDSI1wDJj1ydAoCBAgQIECAAAECBAgQyBXwDpLra3UCBAgQIECAAAECBAgQIECgsYCHlR7hGjDpkaNTECBAgAABAgQIECBAgECugHeQXF+rEyBAgAABAgQIECBAgAABAo0FPKz0CNeASY8cnYIAAQIECBAgQIAAAQIEcgW8g+T6Wp0AAQIECBAgQIAAAQIECBBoLOBhpUe4Bkx65OgUBAgQIECAAAECBAgQIJAr4B0k19fqBAgQIECAAAECBAgQIECAQGMBDys9wjVg0iNHpyBAgAABAgQIECBAgACBXAHvILm+VidAgAABAgQIECBAgAABAgQaC3hY6RGuAZMeOToFAQIECBAgQIAAAQIECOQKeAfJ9bU6AQIECBAgQIAAAQIECBAg0FjAw0qPcA2Y9MjRKQgQIECAAAECBAgQIEAgV8A7SK6v1QkQIECAAAECBAgQIECAAIHGAh5WeoRrwKRHjk5BgAABAgQIECBAgAABArkC3kFyfa1OgAABAgQIECBAgAABAgQINBbwsNIjXAMmPXJ0CgIECBAgQIAAAQIECBDIFfAOkutrdQIECBAgQIAAAQIECBAgQKCxgIeVHuEaMOmRo1MQIECAAAECBAgQIECAQK6Ad5BcX6sTIECAAAECBAgQIECAAAECjQU8rPQI14BJjxydggABAgQIECBAgAABAgRyBbyD5PpanQABAgQIECBAgAABAgQIEGgs4GGlR7gGTHrk6BQECBAgQIAAAQIECBAgkCvgHSTX1+oECBAgQIAAAQIECBAgQIBAYwEPKz3CNWDSI0enIECAAAECBAgQIECAAIFcAe8gub5WJ0CAAAECBAgQIECAAAECBBoLeFjpEa4Bkx45OgUBAgQIECBAgAABAgQI5Ap4B8n1tToBAgQIECBAgAABAgQIECDQWMDDSo9wDZj0yNEpCBAgQIAAAQIECBAgQCBXwDtIrq/VCRAgQIAAAQIECBAgQIAAgcYCHlZ6hGvApEeOTkGAAAECBAgQIECAAAECuQLeQXJ9rU6AAAECBAgQIECAAAECBAg0FvCw0iNcAyY9cnQKAgQIECBAgAABAgQIEMgV8A6S62t1AgQIECBAgAABAgQIECBAoLGAh5Ue4Row6ZGjUxAgQIAAAQIECBAgQIBAroB3kFxfqxMgQIAAAQIECBAgQIAAAQKNBTys9AjXgEmPHJ2CAAECBAgQIECAAAECBHIFvIPk+lqdAAECBAgQIECAAAECBAgQaCzgYaVHuAZMeuToFAQIECBAgAABAgQIECCQK+AdJNfX6gQIECBAgAABAgQIECBAgEBjAQ8rPcI1YNIjR6cgQIAAAQIECBAgQIAAgVwB7yC5vlYnQIAAAQIECBAgQIAAAQIEGgt4WOkRrgGTHjk6BQECBAgQIECAAAECBAjkCngHyfW1OgECBAgQIECAAAECBAgQINBYwMNKj3ANmPTI0SkIECBAgAABAgQIECBAIFfAO0iur9UJECBAgAABAgQIECBAgACBxgIeVnqEa8CkR45OQRG1MusAAAsvSURBVIAAAQIECBAgQIAAAQK5At5Bcn2tToAAAQIECBAgQIAAAQIECDQW8LDSI1wDJj1ydAoCBAgQIECAAAECBAgQyBXwDpLra3UCBAgQIECAAAECBAgQIECgsYCHlcbhOhoBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAYIeAAZMditYgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECDQWMGDSOFxHI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAjsEDBgskPRGgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBxgIGTBqH62gECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgR0CBkx2KFqDAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQINBYwIBJ43AdjQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECCwQ8CAyQ5FaxAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEGgsYMGkcrqMRIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBHYIGDDZoWgNAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBjAQMmjcN1NAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDADgEDJjsUrUGAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQaCxgwKRxuI5GgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIENghYMBkh6I1CBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQKNBQyYNA7X0QgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECOwQMmOxQtAYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAoLGAAZPG4ToaAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQGCHgAGTHYrWIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAg0FjBg0jhcRyNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQI7BAwYLJD0RoECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgcYCBkwah+toBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIEdAgZMdihagwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDQWMCASeNwHY0AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgsEPAgMkORWsQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBBoLGDBpHK6jESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgR2CBgw2aFoDQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAYwEDJo3DdTQCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwA4BAyY7FK1BgACB/79dO6YBAABAGObfNSa4lhogobwQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAQFjAwSQ8rmoECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAgYeAg8lDUQYBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAICzgYBIeVzUCBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAwEPAweShKIMAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgEBZwMAmPqxoBAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBA4CHgYPJQlEGAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQCAs4mITHVY0AAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAg8BBwMHkoyiBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIhAUcTMLjqkaAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQeAg4mDwUZRAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEwgIOJuFxVSNAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIPAQcTB6KMggQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECYQEHk/C4qhEgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIEHgIOJg9FGQQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBsICDSXhc1QgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECDwEHk4eiDAIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIBAWMDBJDyuagQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgACBh4CDyUNRBgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEAgLOBgEh5XNQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIDAQ8DB5KEogwABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECAQFnAwCY+rGgECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIEDgIeBg8lCUQYAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAICziYhMdVjQABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECDwEHAweSjKIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAiEBRxMwuOqRoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBB4CDiYPBRlECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgTCAg4m4XFVI0CAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAg8BBxMHooyCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQJhAQeT8LiqESBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQeAg4mD0UZBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGwgINJeFzVCBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIPAQeTh6IMAgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgEBYwMEkPK5qBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAIGHgIPJQ1EGAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQCAs4GASHlc1AgQIECBAgAABAgQIECBAgAABAgQIECBAgAABAgQIECBAgMBDwMHkoSiDAAECBAgQIECAAAECBAgQIECAAAECBAgQIECAAAECBAgQIBAWcDAJj6saAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQOAhMAiGPOVTOwEWAAAAAElFTkSuQmCC\" width=\"1100\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving figure preprocessing_plot\n"
     ]
    }
   ],
   "source": [
    "plt.figure(figsize=(11, 7))\n",
    "plt.subplot(121)\n",
    "plt.title(\"Original observation (160×210 RGB)\")\n",
    "plt.imshow(obs)\n",
    "plt.axis(\"off\")\n",
    "plt.subplot(122)\n",
    "plt.title(\"Preprocessed observation (88×80 greyscale)\")\n",
    "plt.imshow(img.reshape(88, 80), interpolation=\"nearest\", cmap=\"gray\")\n",
    "plt.axis(\"off\")\n",
    "save_fig(\"preprocessing_plot\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build DQN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: instead of using `tf.contrib.layers.convolution2d()` or `tf.contrib.layers.conv2d()` (as in the first version of the book), we now use the `tf.layers.conv2d()`, which did not exist when this chapter was written. This is preferable because anything in contrib may change or be deleted without notice, while `tf.layers` is part of the official API. As you will see, the code is mostly the same, except that the parameter names have changed slightly:\n",
    "* the `num_outputs` parameter was renamed to `filters`,\n",
    "* the `stride` parameter was renamed to `strides`,\n",
    "* the `_fn` suffix was removed from parameter names that had it (e.g., `activation_fn` was renamed to `activation`),\n",
    "* the `weights_initializer` parameter was renamed to `kernel_initializer`,\n",
    "* the weights variable was renamed to `\"kernel\"` (instead of `\"weights\"`), and the biases variable was renamed from `\"biases\"` to `\"bias\"`,\n",
    "* and the default `activation` is now `None` instead of `tf.nn.relu`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "reset_graph()\n",
    "\n",
    "input_height = 88\n",
    "input_width = 80\n",
    "input_channels = 1\n",
    "conv_n_maps = [32, 64, 64]\n",
    "conv_kernel_sizes = [(8,8), (4,4), (3,3)]\n",
    "conv_strides = [4, 2, 1]\n",
    "conv_paddings = [\"SAME\"] * 3 \n",
    "conv_activation = [tf.nn.relu] * 3\n",
    "n_hidden_in = 64 * 11 * 10  # conv3 has 64 maps of 11x10 each\n",
    "n_hidden = 512\n",
    "hidden_activation = tf.nn.relu\n",
    "n_outputs = env.action_space.n  # 9 discrete actions are available\n",
    "initializer = tf.variance_scaling_initializer()\n",
    "\n",
    "def q_network(X_state, name):\n",
    "    prev_layer = X_state / 128.0 # scale pixel intensities to the [-1.0, 1.0] range.\n",
    "    with tf.variable_scope(name) as scope:\n",
    "        for n_maps, kernel_size, strides, padding, activation in zip(\n",
    "                conv_n_maps, conv_kernel_sizes, conv_strides,\n",
    "                conv_paddings, conv_activation):\n",
    "            prev_layer = tf.layers.conv2d(\n",
    "                prev_layer, filters=n_maps, kernel_size=kernel_size,\n",
    "                strides=strides, padding=padding, activation=activation,\n",
    "                kernel_initializer=initializer)\n",
    "        last_conv_layer_flat = tf.reshape(prev_layer, shape=[-1, n_hidden_in])\n",
    "        hidden = tf.layers.dense(last_conv_layer_flat, n_hidden,\n",
    "                                 activation=hidden_activation,\n",
    "                                 kernel_initializer=initializer)\n",
    "        outputs = tf.layers.dense(hidden, n_outputs,\n",
    "                                  kernel_initializer=initializer)\n",
    "    trainable_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,\n",
    "                                       scope=scope.name)\n",
    "    trainable_vars_by_name = {var.name[len(scope.name):]: var\n",
    "                              for var in trainable_vars}\n",
    "    return outputs, trainable_vars_by_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_state = tf.placeholder(tf.float32, shape=[None, input_height, input_width,\n",
    "                                            input_channels])\n",
    "online_q_values, online_vars = q_network(X_state, name=\"q_networks/online\")\n",
    "target_q_values, target_vars = q_network(X_state, name=\"q_networks/target\")\n",
    "\n",
    "copy_ops = [target_var.assign(online_vars[var_name])\n",
    "            for var_name, target_var in target_vars.items()]\n",
    "copy_online_to_target = tf.group(*copy_ops)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'/conv2d/bias:0': <tf.Variable 'q_networks/online/conv2d/bias:0' shape=(32,) dtype=float32_ref>,\n",
       " '/conv2d/kernel:0': <tf.Variable 'q_networks/online/conv2d/kernel:0' shape=(8, 8, 1, 32) dtype=float32_ref>,\n",
       " '/conv2d_1/bias:0': <tf.Variable 'q_networks/online/conv2d_1/bias:0' shape=(64,) dtype=float32_ref>,\n",
       " '/conv2d_1/kernel:0': <tf.Variable 'q_networks/online/conv2d_1/kernel:0' shape=(4, 4, 32, 64) dtype=float32_ref>,\n",
       " '/conv2d_2/bias:0': <tf.Variable 'q_networks/online/conv2d_2/bias:0' shape=(64,) dtype=float32_ref>,\n",
       " '/conv2d_2/kernel:0': <tf.Variable 'q_networks/online/conv2d_2/kernel:0' shape=(3, 3, 64, 64) dtype=float32_ref>,\n",
       " '/dense/bias:0': <tf.Variable 'q_networks/online/dense/bias:0' shape=(512,) dtype=float32_ref>,\n",
       " '/dense/kernel:0': <tf.Variable 'q_networks/online/dense/kernel:0' shape=(7040, 512) dtype=float32_ref>,\n",
       " '/dense_1/bias:0': <tf.Variable 'q_networks/online/dense_1/bias:0' shape=(9,) dtype=float32_ref>,\n",
       " '/dense_1/kernel:0': <tf.Variable 'q_networks/online/dense_1/kernel:0' shape=(512, 9) dtype=float32_ref>}"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "online_vars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "learning_rate = 0.001\n",
    "momentum = 0.95\n",
    "\n",
    "with tf.variable_scope(\"train\"):\n",
    "    X_action = tf.placeholder(tf.int32, shape=[None])\n",
    "    y = tf.placeholder(tf.float32, shape=[None, 1])\n",
    "    q_value = tf.reduce_sum(online_q_values * tf.one_hot(X_action, n_outputs),\n",
    "                            axis=1, keepdims=True)\n",
    "    error = tf.abs(y - q_value)\n",
    "    clipped_error = tf.clip_by_value(error, 0.0, 1.0)\n",
    "    linear_error = 2 * (error - clipped_error)\n",
    "    loss = tf.reduce_mean(tf.square(clipped_error) + linear_error)\n",
    "\n",
    "    global_step = tf.Variable(0, trainable=False, name='global_step')\n",
    "    optimizer = tf.train.MomentumOptimizer(learning_rate, momentum, use_nesterov=True)\n",
    "    training_op = optimizer.minimize(loss, global_step=global_step)\n",
    "\n",
    "init = tf.global_variables_initializer()\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: in the first version of the book, the loss function was simply the squared error between the target Q-Values (`y`) and the estimated Q-Values (`q_value`). However, because the experiences are very noisy, it is better to use a quadratic loss only for small errors (below 1.0) and a linear loss (twice the absolute error) for larger errors, which is what the code above computes. This way large errors don't push the model parameters around as much. Note that we also tweaked some hyperparameters (using a smaller learning rate, and using Nesterov Accelerated Gradients rather than Adam optimization, since adaptive gradient algorithms may sometimes be bad, according to this [paper](https://arxiv.org/abs/1705.08292)). We also tweaked a few other hyperparameters below (a larger replay memory, longer decay for the $\\epsilon$-greedy policy, larger discount rate, less frequent copies of the online DQN to the target DQN, etc.)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use this `ReplayMemory` class instead of a `deque` because it is much faster for random access (thanks to @NileshPS who contributed it). Moreover, we default to sampling with replacement, which is much faster than sampling without replacement for large replay memories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayMemory:\n",
    "    def __init__(self, maxlen):\n",
    "        self.maxlen = maxlen\n",
    "        self.buf = np.empty(shape=maxlen, dtype=np.object)\n",
    "        self.index = 0\n",
    "        self.length = 0\n",
    "        \n",
    "    def append(self, data):\n",
    "        self.buf[self.index] = data\n",
    "        self.length = min(self.length + 1, self.maxlen)\n",
    "        self.index = (self.index + 1) % self.maxlen\n",
    "    \n",
    "    def sample(self, batch_size, with_replacement=True):\n",
    "        if with_replacement:\n",
    "            indices = np.random.randint(self.length, size=batch_size) # faster\n",
    "        else:\n",
    "            indices = np.random.permutation(self.length)[:batch_size]\n",
    "        return self.buf[indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "replay_memory_size = 500000\n",
    "replay_memory = ReplayMemory(replay_memory_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_memories(batch_size):\n",
    "    cols = [[], [], [], [], []] # state, action, reward, next_state, continue\n",
    "    for memory in replay_memory.sample(batch_size):\n",
    "        for col, value in zip(cols, memory):\n",
    "            col.append(value)\n",
    "    cols = [np.array(col) for col in cols]\n",
    "    return cols[0], cols[1], cols[2].reshape(-1, 1), cols[3], cols[4].reshape(-1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "eps_min = 0.1\n",
    "eps_max = 1.0\n",
    "eps_decay_steps = 2000000\n",
    "\n",
    "def epsilon_greedy(q_values, step):\n",
    "    epsilon = max(eps_min, eps_max - (eps_max-eps_min) * step/eps_decay_steps)\n",
    "    if np.random.rand() < epsilon:\n",
    "        return np.random.randint(n_outputs) # random action\n",
    "    else:\n",
    "        return np.argmax(q_values) # optimal action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_steps = 4000000  # total number of training steps\n",
    "training_start = 10000  # start training after 10,000 game iterations\n",
    "training_interval = 4  # run a training step every 4 game iterations\n",
    "save_steps = 1000  # save the model every 1,000 training steps\n",
    "copy_steps = 10000  # copy online DQN to target DQN every 10,000 training steps\n",
    "discount_rate = 0.99\n",
    "skip_start = 90  # Skip the start of every game (it's just waiting time).\n",
    "batch_size = 50\n",
    "iteration = 0  # game iterations\n",
    "checkpoint_path = \"./my_dqn.ckpt\"\n",
    "done = True # env needs to be reset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A few variables for tracking progress:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_val = np.infty\n",
    "game_length = 0\n",
    "total_max_q = 0\n",
    "mean_max_q = 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now the main training loop!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./my_dqn.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[2017-09-25 13:55:15,610] Restoring parameters from ./my_dqn.ckpt\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r",
      "Iteration 1270171\tTraining step 315001/4000000 (7.9)%\tLoss 2.651937\tMean Max-Q 30.964941   "
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    if os.path.isfile(checkpoint_path + \".index\"):\n",
    "        saver.restore(sess, checkpoint_path)\n",
    "    else:\n",
    "        init.run()\n",
    "        copy_online_to_target.run()\n",
    "    while True:\n",
    "        step = global_step.eval()\n",
    "        if step >= n_steps:\n",
    "            break\n",
    "        iteration += 1\n",
    "        print(\"\\rIteration {}\\tTraining step {}/{} ({:.1f})%\\tLoss {:5f}\\tMean Max-Q {:5f}   \".format(\n",
    "            iteration, step, n_steps, step * 100 / n_steps, loss_val, mean_max_q), end=\"\")\n",
    "        if done: # game over, start again\n",
    "            obs = env.reset()\n",
    "            for skip in range(skip_start): # skip the start of each game\n",
    "                obs, reward, done, info = env.step(0)\n",
    "            state = preprocess_observation(obs)\n",
    "\n",
    "        # Online DQN evaluates what to do\n",
    "        q_values = online_q_values.eval(feed_dict={X_state: [state]})\n",
    "        action = epsilon_greedy(q_values, step)\n",
    "\n",
    "        # Online DQN plays\n",
    "        obs, reward, done, info = env.step(action)\n",
    "        next_state = preprocess_observation(obs)\n",
    "\n",
    "        # Let's memorize what happened\n",
    "        replay_memory.append((state, action, reward, next_state, 1.0 - done))\n",
    "        state = next_state\n",
    "\n",
    "        # Compute statistics for tracking progress (not shown in the book)\n",
    "        total_max_q += q_values.max()\n",
    "        game_length += 1\n",
    "        if done:\n",
    "            mean_max_q = total_max_q / game_length\n",
    "            total_max_q = 0.0\n",
    "            game_length = 0\n",
    "\n",
    "        if iteration < training_start or iteration % training_interval != 0:\n",
    "            continue # only train after warmup period and at regular intervals\n",
    "        \n",
    "        # Sample memories and use the target DQN to produce the target Q-Value\n",
    "        X_state_val, X_action_val, rewards, X_next_state_val, continues = (\n",
    "            sample_memories(batch_size))\n",
    "        next_q_values = target_q_values.eval(\n",
    "            feed_dict={X_state: X_next_state_val})\n",
    "        max_next_q_values = np.max(next_q_values, axis=1, keepdims=True)\n",
    "        y_val = rewards + continues * discount_rate * max_next_q_values\n",
    "\n",
    "        # Train the online DQN\n",
    "        _, loss_val = sess.run([training_op, loss], feed_dict={\n",
    "            X_state: X_state_val, X_action: X_action_val, y: y_val})\n",
    "\n",
    "        # Regularly copy the online DQN to the target DQN\n",
    "        if step % copy_steps == 0:\n",
    "            copy_online_to_target.run()\n",
    "\n",
    "        # And save regularly\n",
    "        if step % save_steps == 0:\n",
    "            saver.save(sess, checkpoint_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can interrupt the cell above at any time to test your agent using the cell below. You can then run the cell above once again, it will load the last parameters saved and resume training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./my_dqn.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[2017-09-25 13:53:39,307] Restoring parameters from ./my_dqn.ckpt\n"
     ]
    }
   ],
   "source": [
    "frames = []\n",
    "n_max_steps = 10000\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    saver.restore(sess, checkpoint_path)\n",
    "\n",
    "    obs = env.reset()\n",
    "    for step in range(n_max_steps):\n",
    "        state = preprocess_observation(obs)\n",
    "\n",
    "        # Online DQN evaluates what to do\n",
    "        q_values = online_q_values.eval(feed_dict={X_state: [state]})\n",
    "        action = np.argmax(q_values)\n",
    "\n",
    "        # Online DQN plays\n",
    "        obs, reward, done, info = env.step(action)\n",
    "\n",
    "        img = env.render(mode=\"rgb_array\")\n",
    "        frames.append(img)\n",
    "\n",
    "        if done:\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plot_animation(frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extra material"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocessing for Breakout"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a preprocessing function you can use to train a DQN for the Breakout-v0 Atari game:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def preprocess_observation(obs):\n",
    "    img = obs[34:194:2, ::2] # crop and downsize\n",
    "    return np.mean(img, axis=2).reshape(80, 80) / 255.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[2017-09-25 13:54:27,989] Making new env: Breakout-v0\n"
     ]
    }
   ],
   "source": [
    "env = gym.make(\"Breakout-v0\")\n",
    "obs = env.reset()\n",
    "for step in range(10):\n",
    "    obs, _, _, _ = env.step(1)\n",
    "\n",
    "img = preprocess_observation(obs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        this.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overriden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"1100\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(11, 7))\n",
    "plt.subplot(121)\n",
    "plt.title(\"Original observation (160×210 RGB)\")\n",
    "plt.imshow(obs)\n",
    "plt.axis(\"off\")\n",
    "plt.subplot(122)\n",
    "plt.title(\"Preprocessed observation (80×80 grayscale)\")\n",
    "plt.imshow(img, interpolation=\"nearest\", cmap=\"gray\")\n",
    "plt.axis(\"off\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, a single image does not give you the direction and speed of the ball, which are crucial informations for playing this game. For this reason, it is best to actually combine several consecutive observations to create the environment's state representation. One way to do that is to create a multi-channel image, with one channel per recent observation. Another is to merge all recent observations into a single-channel image, using `np.max()`. In this case, we need to dim the older images so that the DQN can distinguish the past from the present."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "\n",
    "def combine_observations_multichannel(preprocessed_observations):\n",
    "    return np.array(preprocessed_observations).transpose([1, 2, 0])\n",
    "\n",
    "def combine_observations_singlechannel(preprocessed_observations, dim_factor=0.5):\n",
    "    dimmed_observations = [obs * dim_factor**index\n",
    "                           for index, obs in enumerate(reversed(preprocessed_observations))]\n",
    "    return np.max(np.array(dimmed_observations), axis=0)\n",
    "\n",
    "n_observations_per_state = 3\n",
    "preprocessed_observations = deque([], maxlen=n_observations_per_state)\n",
    "\n",
    "obs = env.reset()\n",
    "for step in range(10):\n",
    "    obs, _, _, _ = env.step(1)\n",
    "    preprocessed_observations.append(preprocess_observation(obs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        this.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overriden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"1100\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "img1 = combine_observations_multichannel(preprocessed_observations)\n",
    "img2 = combine_observations_singlechannel(preprocessed_observations)\n",
    "\n",
    "plt.figure(figsize=(11, 7))\n",
    "plt.subplot(121)\n",
    "plt.title(\"Multichannel state\")\n",
    "plt.imshow(img1, interpolation=\"nearest\")\n",
    "plt.axis(\"off\")\n",
    "plt.subplot(122)\n",
    "plt.title(\"Singlechannel state\")\n",
    "plt.imshow(img2, interpolation=\"nearest\", cmap=\"gray\")\n",
    "plt.axis(\"off\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise solutions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. to 7."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See Appendix A."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. BipedalWalker-v3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercise: _Use policy gradients to tackle OpenAI gym's \"BipedalWalker-v3\"._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "env = gym.make(\"BipedalWalker-v3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs = env.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = env.render(mode=\"rgb_array\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(img)\n",
    "plt.axis(\"off\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2.74730590e-03, -2.55714543e-05,  1.98919237e-03, -1.59998274e-02,\n",
       "        9.17998850e-02, -2.62505747e-03,  8.60360265e-01,  3.34233418e-03,\n",
       "        1.00000000e+00,  3.22045349e-02, -2.62487587e-03,  8.53911370e-01,\n",
       "        1.85646505e-03,  1.00000000e+00,  4.40814108e-01,  4.45820212e-01,\n",
       "        4.61422890e-01,  4.89550292e-01,  5.34102917e-01,  6.02461159e-01,\n",
       "        7.09149063e-01,  8.85932028e-01,  1.00000000e+00,  1.00000000e+00])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find the meaning of each of these 24 numbers in the [documentation](https://github.com/openai/gym/wiki/BipedalWalker-v3)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Box(4,)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.action_space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1., -1., -1., -1.], dtype=float32)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.action_space.low"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1.], dtype=float32)"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.action_space.high"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a 4D continuous action space controling each leg's hip torque and knee torque (from -1 to 1). To deal with a continuous action space, one method is to discretize it. For example, let's limit the possible torque values to these 3 values: -1.0, 0.0, and 1.0. This means that we are left with $3^4=81$ possible actions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(81, 4)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "possible_torques = np.array([-1.0, 0.0, 1.0])\n",
    "possible_actions = np.array(list(product(possible_torques, possible_torques, possible_torques, possible_torques)))\n",
    "possible_actions.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "# 1. Specify the network architecture\n",
    "n_inputs = env.observation_space.shape[0]  # == 24\n",
    "n_hidden = 10\n",
    "n_outputs = len(possible_actions) # == 625\n",
    "initializer = tf.variance_scaling_initializer()\n",
    "\n",
    "# 2. Build the neural network\n",
    "X = tf.placeholder(tf.float32, shape=[None, n_inputs])\n",
    "\n",
    "hidden = tf.layers.dense(X, n_hidden, activation=tf.nn.selu,\n",
    "                         kernel_initializer=initializer)\n",
    "logits = tf.layers.dense(hidden, n_outputs,\n",
    "                         kernel_initializer=initializer)\n",
    "outputs = tf.nn.softmax(logits)\n",
    "\n",
    "# 3. Select a random action based on the estimated probabilities\n",
    "action_index = tf.squeeze(tf.multinomial(logits, num_samples=1), axis=-1)\n",
    "\n",
    "# 4. Training\n",
    "learning_rate = 0.01\n",
    "\n",
    "y = tf.one_hot(action_index, depth=len(possible_actions))\n",
    "cross_entropy = tf.nn.softmax_cross_entropy_with_logits_v2(labels=y, logits=logits)\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate)\n",
    "grads_and_vars = optimizer.compute_gradients(cross_entropy)\n",
    "gradients = [grad for grad, variable in grads_and_vars]\n",
    "gradient_placeholders = []\n",
    "grads_and_vars_feed = []\n",
    "for grad, variable in grads_and_vars:\n",
    "    gradient_placeholder = tf.placeholder(tf.float32, shape=grad.get_shape())\n",
    "    gradient_placeholders.append(gradient_placeholder)\n",
    "    grads_and_vars_feed.append((gradient_placeholder, variable))\n",
    "training_op = optimizer.apply_gradients(grads_and_vars_feed)\n",
    "\n",
    "init = tf.global_variables_initializer()\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try running this policy network, although it is not trained yet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_bipedal_walker(model_path=None, n_max_steps = 1000):\n",
    "    env = gym.make(\"BipedalWalker-v3\")\n",
    "    frames = []\n",
    "    with tf.Session() as sess:\n",
    "        if model_path is None:\n",
    "            init.run()\n",
    "        else:\n",
    "            saver.restore(sess, model_path)\n",
    "        obs = env.reset()\n",
    "        for step in range(n_max_steps):\n",
    "            img = env.render(mode=\"rgb_array\")\n",
    "            frames.append(img)\n",
    "            action_index_val = action_index.eval(feed_dict={X: obs.reshape(1, n_inputs)})\n",
    "            action = possible_actions[action_index_val]\n",
    "            obs, reward, done, info = env.step(action[0])\n",
    "            if done:\n",
    "                break\n",
    "    env.close()\n",
    "    return frames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "frames = run_bipedal_walker()\n",
    "plot_animation(frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nope, it really can't walk. So let's train it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 1000/1000"
     ]
    }
   ],
   "source": [
    "n_games_per_update = 10\n",
    "n_max_steps = 1000\n",
    "n_iterations = 1000\n",
    "save_iterations = 10\n",
    "discount_rate = 0.95\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    init.run()\n",
    "    for iteration in range(n_iterations):\n",
    "        print(\"\\rIteration: {}/{}\".format(iteration + 1, n_iterations), end=\"\")\n",
    "        all_rewards = []\n",
    "        all_gradients = []\n",
    "        for game in range(n_games_per_update):\n",
    "            current_rewards = []\n",
    "            current_gradients = []\n",
    "            obs = env.reset()\n",
    "            for step in range(n_max_steps):\n",
    "                action_index_val, gradients_val = sess.run([action_index, gradients],\n",
    "                                                           feed_dict={X: obs.reshape(1, n_inputs)})\n",
    "                action = possible_actions[action_index_val]\n",
    "                obs, reward, done, info = env.step(action[0])\n",
    "                current_rewards.append(reward)\n",
    "                current_gradients.append(gradients_val)\n",
    "                if done:\n",
    "                    break\n",
    "            all_rewards.append(current_rewards)\n",
    "            all_gradients.append(current_gradients)\n",
    "\n",
    "        all_rewards = discount_and_normalize_rewards(all_rewards, discount_rate=discount_rate)\n",
    "        feed_dict = {}\n",
    "        for var_index, gradient_placeholder in enumerate(gradient_placeholders):\n",
    "            mean_gradients = np.mean([reward * all_gradients[game_index][step][var_index]\n",
    "                                      for game_index, rewards in enumerate(all_rewards)\n",
    "                                          for step, reward in enumerate(rewards)], axis=0)\n",
    "            feed_dict[gradient_placeholder] = mean_gradients\n",
    "        sess.run(training_op, feed_dict=feed_dict)\n",
    "        if iteration % save_iterations == 0:\n",
    "            saver.save(sess, \"./my_bipedal_walker_pg.ckpt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "frames = run_bipedal_walker(\"./my_bipedal_walker_pg.ckpt\")\n",
    "plot_animation(frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not the best walker, but at least it stays up and makes (slow) progress to the right.\n",
    "A better solution for this problem is to use an actor-critic algorithm, as it does not require discretizing the action space, and it converges much faster. Check out this nice [blog post](https://towardsdatascience.com/reinforcement-learning-w-keras-openai-actor-critic-models-f084612cfd69) by Yash Patel for more details."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Pong DQN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's explore the `Pong-v0` OpenAI Gym environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gq8yjOdZx9yS"
   },
   "outputs": [],
   "source": [
    "import gym\n",
    "\n",
    "env = gym.make('Pong-v0')\n",
    "obs = env.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(210, 160, 3)"
      ]
     },
     "execution_count": 95,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Discrete(6)"
      ]
     },
     "execution_count": 96,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.action_space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see the observation space is a 210x160 RGB image. The action space is a `Discrete(6)` space with 6 different actions: actions 0 and 1 do nothing, actions 2 and 4 move the paddle up, and finally actions 3 and 5 move the paddle down. The paddle is free to move immediately but the ball does not appear until after 18 steps into the episode.\n",
    "\n",
    "Let's play a game with a completely random policy and plot the resulting animation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A helper function to run an episode of Pong. It's first argument should be a\n",
    "# function which takes the observation of the environment and the current\n",
    "# iteration and produces an action for the agent to take.\n",
    "\n",
    "def run_episode(policy, n_max_steps=1000, frames_per_action=1):\n",
    "    obs = env.reset()\n",
    "    frames = []\n",
    "    for i in range(n_max_steps):\n",
    "        obs, reward, done, info = env.step(policy(obs, i))\n",
    "        frames.append(env.render(mode='rgb_array'))\n",
    "        if done:\n",
    "            break\n",
    "    return plot_animation(frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANMAAAEACAYAAAAp2kPsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAA8BJREFUeJzt3T1uE1EYQFEGZQMwW6FJ+kggFoPE\nQhAsBlGkTxq2MmxhKCIhEYwtx9f2xHNOF/lHr7n65jlv7GGe51fA4V6fewFwKcQEETFBREwQERNE\nxAQRMUFETBARE0TEBJGrcy9gk2EYtp5x+vr+zamWAn98+vFr2Pb4ImM6Riy3N9d7Pf/u/uGg1296\nDx79/Pxx79e8+/L9CCtpucyDiJggIiaILHLPdAy79i+H7qme8x482rQfes6+6txMJoiICSJigshq\n9kz2MxybyQQRMUFETBBZzZ7pKefmqJlMEBETRMQEETFBZLUfQOz6J259MJb/e4mHWjcxmSAiJoiI\nCSLDEn/s7NuHt8tbFKu369uJTCaIiAkii7zMm6ZpeYti9cZxdJkHpyAmiIgJImKCiJggIiaIiAki\nYoKImCCyyBMQDrpyqKc3HBa/POigK5yImCAiJoiICSJigoiYILLa783jshUfhe/LZIKImCAiJoiI\nCSJigoiYICImiIgJImKCiJggIiaIiAkiYoKImCAiJoiICSJigoiYICImiIgJImKCiJggIiaIiAki\nYoKImCAiJoiICSJigoiYICImiIgJImKCiJggIiaIiAkiYoKImCAiJoiICSJigoiYICImiIgJImKC\niJggIiaIiAkiYoKImCAiJoiICSJigoiYICImiIgJImKCiJggIiaIiAkiYoKImCAiJoiICSJigoiY\nICImiIgJImKCiJggIiaIiAkiYoKImCByde4FHMvtzfVff9/dP5xpJayFyQQRMUFETBARE0TEBBEx\nQURMEBETRMQEETFBREwQERNExAQRMUFETBARE0Qu9uZANwNyaiYTRMQEETFBREwQERNExAQRMUFE\nTBARE0TEBBExQURMEBETRMQEETFBREwQERNExAQRMUFETBARE0TEBBExQURMEBETRMQEETFBREwQ\nERNExAQRMUFETBARE0TEBBExQURMEBETRMQEETFBREwQERNExAQRMUFETBARE0TEBBExQURMEBET\nRMQEETFBREwQERNExAQRMUFETBARE0TEBBExQURMEBETRMQEETFBREwQERNExASRYZ7nc6/hH9M0\nLW9RrN44jsO2x00miIgJImKCiJggIiaIiAkiYoKImCAiJoiICSJigoiYICImiIgJImKCiJggssib\nA+ElMpkgIiaIiAkiYoKImCAiJoiICSJigoiYICImiIgJImKCiJggIiaIiAkiYoKImCAiJoiICSJi\ngoiYICImiIgJImKCiJggIiaI/AbgAEzkApWdfAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "run_episode(lambda obs, i: np.random.randint(0, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The random policy does not fare very well. So let's try to use the DQN and see if we can do better.\n",
    "\n",
    "First let's write a preprocessing function to scale down the input state. Since a single observation does not tell us about the ball's velocity, we will also need to combine multiple observations into a single state. Below is the preprocessing code for this environment. The preprocessing algorithm is two-fold:\n",
    "\n",
    "1. Convert the image in the observation to an image to only black and white and scale it down to 80x80 pixels.\n",
    "\n",
    "2. Combine 3 observations into a single state which depicts the velocity of the paddles and the ball."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "green_paddle_color = (92, 186, 92)\n",
    "red_paddle_color = (213, 130, 74)\n",
    "background_color = (144, 72, 17)\n",
    "ball_color = (236, 236, 236)\n",
    "\n",
    "def preprocess_observation(obs):\n",
    "    img = obs[34:194:2, ::2].reshape(-1, 3)\n",
    "    tmp = np.full(shape=(80 * 80), fill_value=0.0, dtype=np.float32)\n",
    "    for i, c in enumerate(img):\n",
    "        c = tuple(c)\n",
    "        if c in {green_paddle_color, red_paddle_color, ball_color}:\n",
    "            tmp[i] = 1.0\n",
    "        else:\n",
    "            tmp[i] = 0.0\n",
    "    return tmp.reshape(80, 80)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAApIAAAGgCAYAAAAZ0oddAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nMOT/A0y5NVatsS4uAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 792x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "obs = env.reset()\n",
    "for _ in range(25):\n",
    "    obs, _, _, _ = env.step(0)\n",
    "\n",
    "plt.figure(figsize=(11, 7))\n",
    "plt.subplot(121)\n",
    "plt.title('Original Observation (160 x 210 RGB)')\n",
    "plt.imshow(obs)\n",
    "plt.axis('off')\n",
    "plt.subplot(122)\n",
    "plt.title('Preprocessed Observation (80 x 80 Grayscale)')\n",
    "plt.imshow(preprocess_observation(obs), interpolation='nearest', cmap='gray')\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "def combine_observations(preprocess_observations, dim_factor=0.75):\n",
    "    dimmed = [obs * (dim_factor ** idx)\n",
    "              for idx, obs in enumerate(reversed(preprocess_observations))]\n",
    "    return np.max(np.array(dimmed), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAF4CAYAAAB9xrNzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAEWVJREFUeJzt3HuwdXdd3/HPN3kSSMgN5CKRCDao\nhUBbRQ04KM8gCgkqGbHaglDoKIKDNqPSVMZLBAS1ZXhgxJF6i5pELral1U6dGuEJMJJaKB0vWBHJ\nDUgIJAFCSTTAr3+s36krh3POcwk55xvzes2cyd77t87av7323u+19trnSY0xAkBfx+z1BADYmVAD\nNCfUAM0JNUBzQg3QnFADNCfUe6iqLqyqi3cY//Oq2n8X3O/+qvrgnVzHRVX1si/UnHbLXbVN706q\n6r9V1b/4AqznYVU1qmrfF2JebE+ot1BVz6iqd1XVp6rquvnCfvxuz2OMcdYY4+Bu328tXlRVf1VV\nt1bVNVX1iqq6127P5c7YameyV9t0t1XVi6vqyvka/mBVvWFjbIxxzhjjN/Z4fqdV1a9V1fVVdUtV\nva+q/s1qfFTVw49gfQer6nvvmtnuPaHepKp+OMmBJC9P8qAkX5rkF5M8bS/ntctek+R5SZ6d5OQk\n5yT5piRv3M1JOFI7OvNo+VlJnjTGOCnJ1yT5w72d1ed5VZKTkjwiyalJvj3J+/d0Rp2NMfzMnywv\nmE8l+ac7LHOvLCH/8Pw5kORec2x/kg8m+ddJbkhyXZLzkpyb5H1Jbkry4tW6LkzyO0nekOSWJP8r\nyT9ejV+V5c22sewbk/zmXPbPk3zNatnTk/yHJB9NcmWSH1qNnZDkoiQ3J3lvkhcl+eA2j+/Lk3w2\nyddtuv2MJH+T5Inz+kVJfinJH8z5XJ7koXOssrwRb0jyySR/muRRq+3375Jck+Qjcx0nbNp+FyS5\nPslvJfmLJN+6mse++Ri/el5/01z2E0neluSsefvzktye5G/nc/q7W2zTw3kuf2T1XD53NY9z57a8\nJcmHkvzoNtvzzCRvSXJjko8luSTJaavxC+bv35LkL5N80zbreWqS98zteW2SC3d4jf5CkgM7jB9M\n8r3z8nOSvGM+JzfP1845q2W/bG7XW5JcluS1SS6eYw9LMpLsW71/fnVuqw8leVmSY7eZw58lOW+b\nsbfN9f7f+dx9d5L7Jvm9+dzfPC8/ZC7/M1les7fN5X9h3v4Ps7w+b5rb9rv2ujFH3aa9nkCnnyRP\nSfKZjRfeNsu8JMkVSR6Y5AFJ/ijJS+fY/vn7P5nkuCTfN19Yl2Y5Mj0rya1Jvmwuf2GWmHznXP5H\n5xvluDl+Ve4Y6ttmII5N8ookV8yxY5K8e97v8Un+QZIPJHnyHP/ZJG9Pcr8swf2zbB/q5ye5epux\ny5O8Yl6+aL55vzFL8F6d5B1z7MlzPqdlifYjkjx4jr0qyX+Zczk5ye+u1rmx/X5urvOE+ZguWc3h\nqUn+YnX9X871bET3f6/GLkrysk2PYb1ND+e5fMl8bs5N8ukk953j1yX5hnn5vpk7ji222cOTfPOc\n3wOyROjAHPvKLNE9fV5/WJIzt1nP/iSPns/1P8qyk9sudN+TJU4vynI0feym8YO5Y6hvz/JaPTbJ\nC7LstGqOvzNLxI9P8vgsO4rtQv2fkrwuyX3mNv3jJN+/zRx/JcvBxnOTfPkW4yPJw1fXvyjJ05Oc\nOJ/vNyV581aPaV6/z9y2z82yc/+qLDvKR+51Z46qTXs9gU4/SZ6Z5PpDLPPXSc5dXX9ykqvm5f1Z\nQnzsvH7yfMGdvVr+3RtvsCzxvWI1dsymAFyVO4b6stWyj0xy67x8dpJrNs3zx5L8+rz8gSRPWY09\nL9uH+sfXc9o09vokvzwvX5Tk9auxk7Ic1ZyR5IlZPkE8Nskxq2Uqy1HSmavbHpfkytX2+9sk916N\nPzzLDuHEef2SJD+5zfxOm9v71NUcdwr14TyX+1bjNyR57Lx8TZLvT3LKEb7GzkvyntVjuyHJkzJ3\nzkewngNJXnWI1/Jlc3vfmOSC1djB3DHU71+NnTi34RdnOe33mY1tP8cvzhahznKa8G8yPx3N8X+e\n5K3bzO+EJC/O8n64Pctpj/WR/B1CvcXv/5MkN2/1mOb1707y9k2/87okP3Uk27nLj3PUd3Rjkvsf\n4tzo6UmuXl2/et72/9cxxvjsvHzr/O9HVuO3Zonahms3LowxPpfl4/Z6fWvXry5/Osm951wfmuT0\nqvr4xk+WN8GDVnO+dvW76/lv9rEkD95m7MFzfKu5fyrLUdzpY4y3ZPn4/dokN1TVv6+qU7IcUZ6Y\n5N2ref7+vH3DR8cYt63W+/4spz++rapOzHIu89Ikqapjq+pnq+qvq+qTWSKcJPff4fGtHc5z+ZnV\n9U/n7567p2c5yr66qi6vqsdtdQdV9aCqen1VfWjO8eKN+c3Hdn6WnfANc7ktn/uqOruq3lpVH62q\nT2T55LPt4xxjXDLGeFKWndfzk7y0qp68zeLXr37v0/PiSVm2xU2r25I7vo7WHprlk8d1q+f2dVmO\nrLea361jjJePMR6T5Wj5jUneVFX322r5qjqxql5XVVfP7fi2JKdV1bE7zOfsTe+JZ2bZAd3tCPUd\nvTPLUcF5Oyzz4Swvgg1fOm87WmdsXKiqY5I85CjWd22Wo9LTVj8njzHOnePXre9nznk7b0lyRlV9\n3frGqjojyxHy+kup9dxPynI648NJMsZ4zXwTPjLJV2T5GP6xLDuqs1bzPHUsX3htGFvM6bezHJ09\nLcl7Z+CS5BnztidlOT/6sI3p7LCutaN+LscY/3OM8bQsIXpztv+i9eVzHo8eY5yS5bTExvwyxrh0\njPH4OY+R5bTPVi7NcsrojDHGqVnO7dc2y67nefsY401J/iTJow7nsa1cl+R+cwe54Yxtlr02y3vn\n/qvn9pQxxlmHMcdPZtlO98lyTnwrP5LlVNHZczt+47x9u+f62iSXb3pPnDTGeMGh5tORUK+MMT6R\n5Zzoa6vqvLkXP66qzqmqn5+L/XaSH6+qB1TV/efy2/4t9GF4TFV9xzwyPj/Li/2KI1zHHye5paou\nqKoT5pHmo6rqa+f4G5P8WFXdt6oekuQHt1vRGON9WSJwSVU9dq7rrCxfVF42xrhstfi5VfX4qjo+\nyUuznDK5tqq+dh4BHpflo/dtST43PzH8cpJXVdUDk6SqvmSHI70Nr0/yLVnOn166uv3kLNvrxixH\n6i/f9HsfyXK+fjtH9VxW1fFV9cyqOnWMcXuW87af22bxk7N8wfWJqvqSLDusjfV8ZVU9cf7Z421Z\ndmI7reemMcZtcyf6jB3m95yqempVnVxVx1TVOVm+H/kfh3psa2OMq5O8K8mF8zE/Lsm3bbPsdUn+\ne5JXVtUp837PrKonbDPHn5ivk+Or6t5J/lWSj2f50i/5/Ofu5Czb5+PzqPunNq1y8/K/l+QrqupZ\n8z183Ly/RxzJNuhCqDcZY7wyyQ9nOVf70Sx75hdmOWpKlm+y35XlCOVPs/ylxp35hx//Ocv5tJuz\n/EnVd8w3/5HM+bNJvjXLebsrsxy5/kqWo8wk+eksH+uvzPJm+q1DrPKF8/cvzhKZ389yDvDpm5a7\nNMsb5qYkj8lytJgkp2QJ8s3zfm9M8m/n2AVZzkdeMT/CXpblSGmnx3ddlk87X5/lL2Q2/OZc/4ey\n/AXG5h3cryZ55Pzo++Z8vjvzXD4ryVXzMTw/y8fqrfx0kq/O8lcp/zXJf1yN3SvLF70fy3L64YFZ\nvlvYyg8keUlV3ZJlh7LTn0p+Msupr2uyxO/nk7xgjPGOQz+sz/PMLN8j3Jhl27why85xK8/O8qXj\ne7M897+T7U+jjSS/nuWxfzjLF65PnafQkuV00G/M5+67spyTP2Euf0WW1+Taq5N8Z1XdXFWvGWPc\nkmXn/s/m+q/P331Jfbez8c0uwCHNfzjzf8YYm49ouQs5oga2NU8XnDlPZTwly3cCW3064S7kX34B\nO/niLKdrvijLXyS9YIzxnr2d0j2PUx8AzTn1AdCcUAM0tyfnqKvK+RaATcYYW/4jJkfUAM0JNUBz\nQg3QnFADNCfUAM0JNUBzQg3QnFADNCfUAM0JNUBzQg3QnFADNCfUAM0JNUBzQg3QnFADNCfUAM0J\nNUBzQg3QnFADNCfUAM0JNUBzQg3QnFADNCfUAM0JNUBzQg3QnFADNCfUAM0JNUBzQg3Q3L69ngDA\nbhhj7DheVbs0kyPniBqgOaEGaE6oAZoTaoDmhBqgOaEGaE6oAZoTaoDmhBqgOaEGaE6oAZoTaoDm\nhBqgOaEGaE6oAZoTaoDmhBqgOaEGaE6oAZoTaoDmhBqgOaEGaE6oAZoTaoDmhBqgOaEGaE6oAZoT\naoDmhBqgOaEGaE6oAZrbt9cTANgNVbXXUzhqjqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZo\nzj94Ae4RDh48uOP4/v37d2UeR8MRNUBzQg3QnFADNCfUAM0JNUBzQg3QnFADNCfUAM0JNUBzQg3Q\nnFADNCfUAM0JNUBzQg3QnFADNCfUAM0JNUBzQg3QnFADNCfUAM0JNUBzQg3QnFADNCfUAM0JNUBz\nQg3QnFADNCfUAM0JNUBzQg3QnFADNFdjjN2/06rdv1OA5sYYtdXtjqgBmhNqgOaEGqA5oQZoTqgB\nmhNqgOaEGqC5fXs9AYDdcODAgR3Hzz///F2ayZFzRA3QnFADNCfUAM0JNUBzQg3QnFADNCfUAM0J\nNUBzQg3QnFADNCfUAM0JNUBzQg3QnFADNCfUAM0JNUBzQg3QnFADNCfUAM0JNUBzQg3QnFADNCfU\nAM0JNUBzQg3QnFADNCfUAM0JNUBzQg3QnFADNCfUAM0JNUBzNcbY/Tut2v07BWhujFFb3e6IGqA5\noQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaE\nGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNq\ngOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgB\nmhNqgOaEGqA5oQZoTqgBmhNqgOb27fUE9sqBAwd2HD///PN3aSb3LJu3u+0Mh+aIGqA5oQZoTqgB\nmhNqgOaEGqA5oQZoTqgBmqsxxu7fadXu3+kmBw8e3HF8//79uzKPv282b1fbEQ7fGKO2ut0RNUBz\nQg3QnFADNCfUAM3dY/+nTE94whP2egp3e1t9EX355ZfvwUzg7zdH1ADNCTVAc0IN0Nw99h+8HOpx\nV235d+esbLUNbTc4ev7BC8DdlFADNCfUAM3dY/+OmjvP+WjYHY6oAZoTaoDmhBqgOaEGaE6oAZoT\naoDmhBqgOaEGaE6oAZoTaoDmhBqgOaEGaE6oAZoTaoDmhBqgOaEGaE6oAZoTaoDmhBqgOaEGaE6o\nAZoTaoDmhBqguX17PYG9UlV7PQWAw+KIGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5\noQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaE\nGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNq\ngOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgB\nmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZo\nTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqA5oQZoTqgBmhNqgOaEGqC5GmPs9RwA2IEjaoDmhBqg\nOaEGaE6oAZoTaoDmhBqgOaEGaE6oAZoTaoDmhBqgOaEGaE6oAZoTaoDmhBqgOaEGaE6oAZoTaoDm\nhBqgOaEGaE6oAZoTaoDmhBqgOaEGaE6oAZoTaoDmhBqguf8HSNWGQEW2Vh4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_observations_per_state = 3\n",
    "\n",
    "obs = env.reset()\n",
    "for _ in range(20):\n",
    "    obs, _, _, _ = env.step(0)\n",
    "\n",
    "preprocess_observations = []\n",
    "for _ in range(n_observations_per_state):\n",
    "    obs, _, _, _ = env.step(2)\n",
    "    preprocess_observations.append(preprocess_observation(obs))\n",
    "\n",
    "img = combine_observations(preprocess_observations)\n",
    "\n",
    "plt.figure(figsize=(6, 6))\n",
    "plt.title('Combined Observations as a Single State')\n",
    "plt.imshow(img, interpolation='nearest', cmap='gray')\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are going to build the DQN. Like the DQN for Pac-Man, this model will train 3 convolutional layers, then a hidden fully connected layer, then finally a fully connected layer with 6 neurons, one representing each possible output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "reset_graph()\n",
    "\n",
    "input_width = 80\n",
    "input_height = 80\n",
    "input_channels = 1\n",
    "\n",
    "conv_n_maps = [32, 64, 64]\n",
    "conv_kernel_sizes = [9, 5, 3]\n",
    "conv_kernel_strides = [4, 2, 1]\n",
    "conv_paddings = ['VALID'] * 3\n",
    "conv_activation = [tf.nn.relu] * 3\n",
    "\n",
    "n_hidden_in = 5 * 5 * 64\n",
    "n_hidden = 512\n",
    "hidden_activation = tf.nn.relu\n",
    "n_outputs = env.action_space.n\n",
    "\n",
    "he_init = tf.contrib.layers.variance_scaling_initializer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This model will use two DQNs, an online DQN and a target DQN. The online DQN learns new parameters at each training step. The target DQN is used to compute the target Q-Values for the online DQN's loss function during training. The online DQN's parameters are copied to the target DQN at regular intervals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "def q_network(X_state, name):\n",
    "    prev_layer = X_state\n",
    "    with tf.variable_scope(name) as scope:\n",
    "        for n_maps, kernel_size, strides, padding, activation in zip(\n",
    "            conv_n_maps, conv_kernel_sizes, conv_kernel_strides, conv_paddings,\n",
    "            conv_activation):\n",
    "            prev_layer = tf.layers.conv2d(prev_layer, filters=n_maps,\n",
    "                                          kernel_size=kernel_size,\n",
    "                                          strides=strides, padding=padding,\n",
    "                                          activation=activation,\n",
    "                                          kernel_initializer=he_init)\n",
    "        flattened = tf.reshape(prev_layer, [-1, n_hidden_in])\n",
    "        hidden = tf.layers.dense(flattened, n_hidden,\n",
    "                                 activation=hidden_activation,\n",
    "                                 kernel_initializer=he_init)\n",
    "        outputs = tf.layers.dense(hidden, n_outputs, kernel_initializer=he_init)\n",
    "    trainable_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,\n",
    "                                       scope=scope.name)\n",
    "    trainable_vars_by_name = {var.name[len(scope.name):]: var\n",
    "                              for var in trainable_vars}\n",
    "    return outputs, trainable_vars_by_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Starting the DQN definition.\n",
    "\n",
    "X_state = tf.placeholder(tf.float32, shape=(None, input_height, input_width,\n",
    "                                            input_channels))\n",
    "online_q_values, online_vars = q_network(X_state, 'q_networks/online')\n",
    "target_q_values, target_vars = q_network(X_state, 'q_networks/target')\n",
    "copy_ops = [var.assign(online_vars[name]) for name, var in target_vars.items()]\n",
    "copy_online_to_target = tf.group(*copy_ops)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining the training objective.\n",
    "\n",
    "learning_rate = 1e-3\n",
    "momentum = 0.95\n",
    "\n",
    "with tf.variable_scope('training') as scope:\n",
    "    X_action = tf.placeholder(tf.int32, shape=(None,))\n",
    "    y = tf.placeholder(tf.float32, shape=(None, 1))\n",
    "    Q_target = tf.reduce_sum(online_q_values * tf.one_hot(X_action, n_outputs),\n",
    "                             axis=1, keepdims=True)\n",
    "    error = tf.abs(y - Q_target)\n",
    "    loss = tf.reduce_mean(tf.square(error))\n",
    "\n",
    "    global_step = tf.Variable(0, trainable=False, name='global_step')\n",
    "    optimizer = tf.train.MomentumOptimizer(learning_rate, momentum,\n",
    "                                           use_nesterov=True)\n",
    "    training_op = optimizer.minimize(loss, global_step=global_step)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "init = tf.global_variables_initializer()\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This model will sample past experiences from a _Replay Memory_, this will hopefully help the model learn what higher level patterns to pay attention to to find the right action. It also reduces the chance that the model's behavior gets too correlated to it's most recent experiences.\n",
    "\n",
    "The replay memory will store its data in the kernel's memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayMemory(object):\n",
    "    def __init__(self, maxlen):\n",
    "        self.maxlen = maxlen\n",
    "        self.buf = np.empty(shape=maxlen, dtype=np.object)\n",
    "        self.index = 0\n",
    "        self.length = 0\n",
    "\n",
    "    def append(self, data):\n",
    "        self.buf[self.index] = data\n",
    "        self.index += 1\n",
    "        self.index %= self.maxlen\n",
    "        self.length = min(self.length + 1, self.maxlen)\n",
    "\n",
    "    def sample(self, batch_size):\n",
    "        return self.buf[np.random.randint(self.length, size=batch_size)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "replay_size = 200000\n",
    "replay_memory = ReplayMemory(replay_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_memories(batch_size):\n",
    "    cols = [[], [], [], [], []]  # state, action, reward, next_state, continue\n",
    "    for memory in replay_memory.sample(batch_size):\n",
    "        for col, value in zip(cols, memory):\n",
    "            col.append(value)\n",
    "    cols = [np.array(col) for col in cols]\n",
    "    return cols[0], cols[1], cols[2].reshape(-1, 1), cols[3], \\\n",
    "         cols[4].reshape(-1, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's define the model's policy during training. Just like in `MsPacMan.ipynb`, we will use an $\\varepsilon$-greedy policy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "eps_min = 0.1\n",
    "eps_max = 1.0\n",
    "eps_decay_steps = 6000000\n",
    "\n",
    "def epsilon_greedy(q_values, step):\n",
    "    epsilon = min(eps_min,\n",
    "                  eps_max - ((eps_max - eps_min) * (step / eps_decay_steps)))\n",
    "    if np.random.random() < epsilon:\n",
    "        return np.random.randint(n_outputs)\n",
    "    return np.argmax(q_values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will train the model to play some Pong. The model will input an action once every 3 frames. The preprocessing functions defined above will use the 3 frames to compute the state the model will use to "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_steps = 10000000\n",
    "training_start = 100000\n",
    "training_interval = 4\n",
    "save_steps = 1000\n",
    "copy_steps = 10000\n",
    "discount_rate = 0.95\n",
    "skip_start = 20\n",
    "batch_size = 50\n",
    "iteration = 0\n",
    "done = True  # To reset the environment at the start.\n",
    "\n",
    "loss_val = np.infty\n",
    "game_length = 0\n",
    "total_max_q = 0.0\n",
    "mean_max_q = 0.0\n",
    "\n",
    "checkpoint_path = \"./pong_dqn.ckpt\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Utility function to get the environment state for the model.\n",
    "\n",
    "def perform_action(action):\n",
    "    preprocess_observations = []\n",
    "    total_reward = 0.0\n",
    "    for i in range(3):\n",
    "        obs, reward, done, info = env.step(action)\n",
    "        total_reward += reward\n",
    "        if done:\n",
    "            for _ in range(i, 3):\n",
    "                preprocess_observations.append(preprocess_observation(obs))\n",
    "            break\n",
    "        else:\n",
    "            preprocess_observations.append(preprocess_observation(obs))\n",
    "    return combine_observations(preprocess_observations).reshape(80, 80, 1), \\\n",
    "        total_reward, done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from /content/gdrive/My Drive/models/pong_dqn.ckpt\n",
      "Iteration 1056803\tTraining step 9291202/10000000 (92.9)%\tLoss 0.014324\tMean Max-Q 0.036826   "
     ]
    }
   ],
   "source": [
    "# Main training loop\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    if os.path.isfile(checkpoint_path + '.index'):\n",
    "        saver.restore(sess, checkpoint_path)\n",
    "    else:\n",
    "        init.run()\n",
    "        copy_online_to_target.run()\n",
    "    while True:\n",
    "        step = global_step.eval()\n",
    "        if step >= n_steps:\n",
    "            break\n",
    "        iteration += 1\n",
    "        print('\\rIteration {}\\tTraining step {}/{} ({:.1f})%\\tLoss {:5f}'\n",
    "              '\\tMean Max-Q {:5f}   '.format(\n",
    "                  iteration, step, n_steps, 100 * step / n_steps, loss_val,\n",
    "                  mean_max_q),\n",
    "              end='')\n",
    "        if done:\n",
    "            obs = env.reset()\n",
    "            for _ in range(skip_start):\n",
    "                obs, reward, done, info = env.step(0)\n",
    "            state, reward, done = perform_action(0)\n",
    "\n",
    "        # Evaluate the next action for the agent.\n",
    "        q_values = online_q_values.eval(\n",
    "            feed_dict={X_state: [state]})\n",
    "        action = epsilon_greedy(q_values, step)\n",
    "\n",
    "        # The online DQN plays the game.\n",
    "        next_state, reward, done = perform_action(action)\n",
    "\n",
    "        # Save the result in the ReplayMemory.\n",
    "        replay_memory.append((state, action, reward, next_state, 1.0 - done))\n",
    "        state = next_state\n",
    "\n",
    "        # Compute statistics which help us monitor how training is going.\n",
    "        total_max_q += q_values.max()\n",
    "        game_length += 1\n",
    "        if done:\n",
    "            mean_max_q = total_max_q / game_length\n",
    "            total_max_q = 0.0\n",
    "            game_length = 0\n",
    "\n",
    "        # Only train after the warmup rounds and only every few rounds.\n",
    "        if iteration < training_start or iteration % training_interval != 0:\n",
    "            continue\n",
    "\n",
    "        # Sample memories from the reply memory.\n",
    "        X_state_val, X_action_val, rewards, X_next_state_val, continues = \\\n",
    "            sample_memories(batch_size)\n",
    "        next_q_values = target_q_values.eval(\n",
    "            feed_dict={X_state: X_next_state_val})\n",
    "        max_next_q_values = np.max(next_q_values, axis=1, keepdims=True)\n",
    "        y_val = rewards + continues * discount_rate * max_next_q_values\n",
    "\n",
    "        # Train the online DQN.\n",
    "        _, loss_val = sess.run([training_op, loss], feed_dict={\n",
    "            X_state: X_state_val,\n",
    "            X_action: X_action_val,\n",
    "            y: y_val,\n",
    "        })\n",
    "\n",
    "        # Regularly copy the online DQN to the target DQN.\n",
    "        if step % copy_steps == 0:\n",
    "            copy_online_to_target.run()\n",
    "\n",
    "        # Regularly save the model.\n",
    "        if step and step % save_steps == 0:\n",
    "            saver.save(sess, checkpoint_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/training/saver.py:1276: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from /content/gdrive/My Drive/models/pong_dqn.ckpt\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANMAAAEACAYAAAAp2kPsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAA+tJREFUeJzt3cFNG0EAQFFvRAOJa0gHXOCOlIgW\n6CEShaCkB1pAOXCHCx2kBqcF5xAlkomDAX/ba/zebeX1ei5fs2PPwjCfzyfA+t7tegDwVogJImKC\niJggIiaIiAkiYoKImCAiJoiICSJHux7AMsMwPLnH6eun99saCvz15fvP4anXRxnTJmI5Oz150fm3\nd/drvX/ZNd6qh8vzhePjq5sXnf8cq645Bm7zICImiIgJIqNcM23CqvXLumuq11yD35ath16zrto1\nMxNExAQRMUHkYNZM1jPjtY/ro2XMTBARE0TEBJGDWTM9dij75vaB35mABWKCiJggIiaIHOwXEKt+\nxK03xvJ/+/hlwzJmJoiICSJigsgwxn929u3zh/ENioO36q8TmZkgIiaIjPI2bzabjW9QHLzpdOo2\nD7ZBTBARE0TEBBExQURMEBETRMQEETFBZJQ7IGx0ZYxsdIUtERNExAQRMUFETBARE0TEBBExQURM\nEBETRMQEETFBREwQERNExAQRMUFETBARE0TEBBExQURMEBETRMQEETFBREwQERNExAQRMUFETBAR\nE0TEBBExQURMEBETRMQEETFBREwQERNExAQRMUFETBARE0TEBBExQURMEBETRMQEETFBREwQERNE\nxAQRMUFETBARE0TEBBExQURMEBETRMQEETFBREwQERNExAQRMUFETBARE0TEBBExQURMEBETRMQE\nETFB5GjXA4BNeLg8Xzg+vrrZ+GeamSAiJoiICSJigoiYICImiIgJImKCiJggIiaIiAkiYoKImCAi\nJoiICSJigoiHA3mTtvEw4GNmJoiICSJigoiYICImiIgJImKCiJggIiaIiAkiYoKImCAiJoiICSJi\ngoiYICImiIgJImKCiJggIiaIiAkiYoKImCAiJoiICSJigoiYICImiIgJImKCiJggIiaIiAkiYoKI\nmCAiJoiICSJigoiYICImiIgJImKCiJggIiaIiAkiYoKImCAiJoiICSJigoiYICImiIgJImKCiJgg\nIiaIiAkiYoKImCAiJoiICSJigoiYIHK06wFsytnpycLx7d39jkbCvrq4/jGZTCaT64uPzzrfzAQR\nMUFETBB5s2smWNdz10p/mJkgIiaIiAkiYoKImCAiJogM8/l812P4x2w2G9+gOHjT6XR46nUzE0TE\nBBExQURMEBETRMQEETFBREwQERNExAQRMUFETBARE0TEBBExQURMEBnlw4Gwj8xMEBETRMQEETFB\nREwQERNExAQRMUFETBARE0TEBBExQURMEBETRMQEETFBREwQERNExAQRMUFETBARE0TEBBExQURM\nEBETRH4BDcZWTLXJ8XUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "preprocess_observations = []\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    saver.restore(sess, checkpoint_path)\n",
    "\n",
    "    def dqn_policy(obs, i):\n",
    "        if len(preprocess_observations) < 3:\n",
    "            preprocess_observations.append(preprocess_observation(obs))\n",
    "            if len(preprocess_observations) == 3:\n",
    "                state = combine_observations(preprocess_observations)\n",
    "                q_values = online_q_values.eval(\n",
    "                    feed_dict={X_state: [state.reshape(80, 80, 1)]})\n",
    "                dqn_policy.cur_action = np.argmax(q_values)\n",
    "            return dqn_policy.cur_action\n",
    "        preprocess_observations[i % 3] = preprocess_observation(obs)\n",
    "        if i % 3 == 2:\n",
    "            state = combine_observations(preprocess_observations)\n",
    "            q_values = online_q_values.eval(\n",
    "                feed_dict={X_state: [state.reshape(80, 80, 1)]})\n",
    "            dqn_policy.cur_action = np.argmax(q_values)\n",
    "        return dqn_policy.cur_action\n",
    "    dqn_policy.cur_action = 0\n",
    "\n",
    "    html = run_episode(dqn_policy, n_max_steps=10000)\n",
    "html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Special thanks to [Dylan Cutler](https://github.com/DCtheTall) for contributing this solution!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}