Tennis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Collaboration and Competition\n",
    "\n",
    "---\n",
    "\n",
    "You are welcome to use this coding environment to train your agent for the project.  Follow the instructions below to get started!\n",
    "\n",
    "### 1. Start the Environment\n",
    "\n",
    "Run the next code cell to install a few packages.  This line will take a few minutes to run!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[31mtensorflow 1.7.1 has requirement numpy>=1.13.3, but you'll have numpy 1.12.1 which is incompatible.\u001b[0m\r\n",
      "\u001b[31mipython 6.5.0 has requirement prompt-toolkit<2.0.0,>=1.0.15, but you'll have prompt-toolkit 3.0.5 which is incompatible.\u001b[0m\r\n"
     ]
    }
   ],
   "source": [
    "!pip -q install ./python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The environment is already saved in the Workspace and can be accessed at the file path provided below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:unityagents:\n",
      "'Academy' started successfully!\n",
      "Unity Academy name: Academy\n",
      "        Number of Brains: 1\n",
      "        Number of External Brains : 1\n",
      "        Lesson number : 0\n",
      "        Reset Parameters :\n",
      "\t\t\n",
      "Unity brain name: TennisBrain\n",
      "        Number of Visual Observations (per agent): 0\n",
      "        Vector Observation space type: continuous\n",
      "        Vector Observation space size (per agent): 8\n",
      "        Number of stacked Vector Observation: 3\n",
      "        Vector Action space type: continuous\n",
      "        Vector Action space size (per agent): 2\n",
      "        Vector Action descriptions: , \n"
     ]
    }
   ],
   "source": [
    "from unityagents import UnityEnvironment\n",
    "import numpy as np\n",
    "\n",
    "env = UnityEnvironment(file_name=\"/data/Tennis_Linux_NoVis/Tennis\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Environments contain **_brains_** which are responsible for deciding the actions of their associated agents. Here we check for the first brain available, and set it as the default brain we will be controlling from Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the default brain\n",
    "brain_name = env.brain_names[0]\n",
    "brain = env.brains[brain_name]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Examine the State and Action Spaces\n",
    "\n",
    "Run the code cell below to print some information about the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of agents: 2\n",
      "Size of each action: 2\n",
      "There are 2 agents. Each observes a state with length: 24\n",
      "The state for the first agent looks like: [ 0.          0.          0.          0.          0.          0.          0.\n",
      "  0.          0.          0.          0.          0.          0.          0.\n",
      "  0.          0.         -6.65278625 -1.5        -0.          0.\n",
      "  6.83172083  6.         -0.          0.        ]\n"
     ]
    }
   ],
   "source": [
    "# reset the environment\n",
    "env_info = env.reset(train_mode=True)[brain_name]\n",
    "\n",
    "# number of agents \n",
    "num_agents = len(env_info.agents)\n",
    "print('Number of agents:', num_agents)\n",
    "\n",
    "# size of each action\n",
    "action_size = brain.vector_action_space_size\n",
    "print('Size of each action:', action_size)\n",
    "\n",
    "# examine the state space \n",
    "states = env_info.vector_observations\n",
    "state_size = states.shape[1]\n",
    "print('There are {} agents. Each observes a state with length: {}'.format(states.shape[0], state_size))\n",
    "print('The state for the first agent looks like:', states[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Take Random Actions in the Environment\n",
    "\n",
    "In the next code cell, you will learn how to use the Python API to control the agent and receive feedback from the environment.\n",
    "\n",
    "Note that **in this coding environment, you will not be able to watch the agents while they are training**, and you should set `train_mode=True` to restart the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total score (averaged over agents) this episode: 0.04500000085681677\n",
      "Total score (averaged over agents) this episode: -0.004999999888241291\n",
      "Total score (averaged over agents) this episode: 0.04500000085681677\n",
      "Total score (averaged over agents) this episode: -0.004999999888241291\n",
      "Total score (averaged over agents) this episode: -0.004999999888241291\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):                                         # play game for 5 episodes\n",
    "    env_info = env.reset(train_mode=False)[brain_name]     # reset the environment    \n",
    "    states = env_info.vector_observations                  # get the current state (for each agent)\n",
    "    scores = np.zeros(num_agents)                          # initialize the score (for each agent)\n",
    "    while True:\n",
    "        actions = np.random.randn(num_agents, action_size) # select an action (for each agent)\n",
    "        actions = np.clip(actions, -1, 1)                  # all actions between -1 and 1\n",
    "        env_info = env.step(actions)[brain_name]           # send all actions to tne environment\n",
    "        next_states = env_info.vector_observations         # get next state (for each agent)\n",
    "        rewards = env_info.rewards                         # get reward (for each agent)\n",
    "        dones = env_info.local_done                        # see if episode finished\n",
    "        scores += env_info.rewards                         # update the score (for each agent)\n",
    "        states = next_states                               # roll over states to next time step\n",
    "        if np.any(dones):                                  # exit loop if episode finished\n",
    "            break\n",
    "    print('Total score (averaged over agents) this episode: {}'.format(np.mean(scores)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When finished, you can close the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. It's Your Turn!\n",
    "\n",
    "Now it's your turn to train your own agent to solve the environment!  A few **important notes**:\n",
    "- When training the environment, set `train_mode=True`, so that the line for resetting the environment looks like the following:\n",
    "```python\n",
    "env_info = env.reset(train_mode=True)[brain_name]\n",
    "```\n",
    "- To structure your work, you're welcome to work directly in this Jupyter notebook, or you might like to start over with a new file!  You can see the list of files in the workspace by clicking on **_Jupyter_** in the top left corner of the notebook.\n",
    "- In this coding environment, you will not be able to watch the agents while they are training.  However, **_after training the agents_**, you can download the saved model weights to watch the agents on your own machine! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import Resources"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "import random\n",
    "import torch\n",
    "\n",
    "import os\n",
    "import numpy as np\n",
    "from collections import deque\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Set plotting options\n",
    "%matplotlib inline\n",
    "plt.style.use('ggplot')\n",
    "np.set_printoptions(precision=3, linewidth=120)\n",
    "\n",
    "# Hide Matplotlib deprecate warnings\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "# High resolution plot outputs for retina display\n",
    "%config InlineBackend.figure_format = 'retina'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Path to save the mdoels and collect the Tensorboard logs\n",
    "model_dir= os.getcwd()+\"/model_dir\"\n",
    "os.makedirs(model_dir, exist_ok=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Instantiate Unity Environment and Agents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 2 agents. Each observes a state with length: 24 and act within an action space of length: 2\n"
     ]
    }
   ],
   "source": [
    "# Reset the environment    \n",
    "env_info = env.reset(train_mode=True)[brain_name]     \n",
    "\n",
    "# number of agents\n",
    "num_agents = len(env_info.agents)\n",
    "\n",
    "# size of each action\n",
    "ENV_ACTION_SIZE = brain.vector_action_space_size\n",
    "\n",
    "# size of the state space \n",
    "states = env_info.vector_observations  # Array of states for all agents in teh enviroonments\n",
    "ENV_STATE_SIZE = states.shape[1]\n",
    "\n",
    "print('There are {} agents. Each observes a state with length: {} and act within an action space of length: {}'.format(states.shape[0], \n",
    "                                                                                                                       ENV_STATE_SIZE, \n",
    "                                                                                                                       ENV_ACTION_SIZE))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Take Random Actions of the environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score (max over agents) from episode 1: 0.0\n",
      "Score (max over agents) from episode 2: 0.10000000149011612\n",
      "Score (max over agents) from episode 3: 0.0\n",
      "Score (max over agents) from episode 4: 0.0\n",
      "Score (max over agents) from episode 5: 0.0\n"
     ]
    }
   ],
   "source": [
    "def random_agents():    \n",
    "    for i_episode in range(1, 6):                              # play game for 5 episodes\n",
    "        env_info = env.reset(train_mode=False)[brain_name]     # reset the environment\n",
    "        states = env_info.vector_observations                  # get the current state (for each agent)\n",
    "        scores = np.zeros(num_agents)                          # initialize the score (for each agent)\n",
    "        t=0                                                    # Initialize a counter for the nb of steps performed\n",
    "\n",
    "        while True:\n",
    "            t+=1\n",
    "            actions = np.random.randn(num_agents, ENV_ACTION_SIZE) # select an action (for each agent)\n",
    "            actions = np.clip(actions, -1, 1)                      # all actions between -1 and 1         \n",
    "            env_info = env.step(actions)[brain_name]               # send all actions to tne environment\n",
    "            next_states = env_info.vector_observations             # get next state (for each agent)\n",
    "            rewards = env_info.rewards                             # get reward (for each agent)\n",
    "            dones = env_info.local_done                            # see if episode finished\n",
    "\n",
    "            scores += env_info.rewards                         # update the score (for each agent)\n",
    "            states = next_states                               # roll over states to next time step\n",
    "            if np.any(dones):                                  # exit loop if episode finished\n",
    "                #print(\"   ** Debug: episode= {} steps={} rewards={} dones={}\".format(i_episode, t,rewards,dones))\n",
    "                break\n",
    "        print('Score (max over agents) from episode {}: {}'.format(i_episode, np.max(scores)))\n",
    "\n",
    "random_agents()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper function to plot the scores\n",
    "def plot_training(scores):\n",
    "    # Plot the Score evolution during the training\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    ax.tick_params(axis='x', colors='deepskyblue')\n",
    "    ax.tick_params(axis='y', colors='deepskyblue')\n",
    "    plt.plot(np.arange(1, len(scores)+1), scores, color='deepskyblue')\n",
    "    plt.ylabel('Score', color='deepskyblue')\n",
    "    plt.xlabel('Episode #', color='deepskyblue')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train Multi Agent Deep Deterministic Policy Gradient (MADDPG) Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from maddpg_agents import Maddpg\n",
    "from hyperparameters import *\n",
    "\n",
    "def train():\n",
    "    \n",
    "    # Seeding\n",
    "    np.random.seed(SEED)\n",
    "    torch.manual_seed(SEED)\n",
    "\n",
    "    # Instantiate the MADDPG agents\n",
    "    maddpg = Maddpg(ENV_STATE_SIZE, ENV_ACTION_SIZE, num_agents, SEED)\n",
    "\n",
    "    # Monitor the score    \n",
    "    scores_deque = deque(maxlen=100)\n",
    "    all_scores = []\n",
    "    all_avg_score = []\n",
    "    \n",
    "    \n",
    "    # Intialize amplitude OU noise (will decay during training)\n",
    "    noise = NOISE\n",
    "    \n",
    "    all_steps =0   # Monitor total number of steps performed\n",
    "    \n",
    "    # Training Loop\n",
    "    for i_episode in range(NB_EPISODES+1):  \n",
    "             \n",
    "        env_info = env.reset(train_mode=True)[brain_name]          # reset the environment  \n",
    "        maddpg.reset()                                             # reset the agents \n",
    "            \n",
    "        states = env_info.vector_observations                      # get the current state for each agent \n",
    "        scores = np.zeros(num_agents)                              # initialize the score (for each agent)\n",
    "\n",
    "        for steps in range(NB_STEPS):\n",
    "            \n",
    "            all_steps+=1\n",
    "\n",
    "            actions = maddpg.act(states, noise)                    # retrieve actions to performe for each agents \n",
    "            noise *= NOISE_REDUCTION                               # Decrease action noise\n",
    "            env_info = env.step(actions)[brain_name]               # send all actions to tne environment\n",
    "            next_states = env_info.vector_observations             # get next state for each agent\n",
    "            rewards = env_info.rewards                             # get reward (for each agent)\n",
    "            dones = env_info.local_done                            # see if episode finished\n",
    "            \n",
    "            # Save experience in replay memory, and use random sample from buffer to learn\n",
    "            maddpg.step(states, actions, rewards, next_states, dones, i_episode)  \n",
    "\n",
    "            scores += env_info.rewards                             # update the score (for each agent)\n",
    "            states = next_states                                   # roll over states to next time step\n",
    "            if np.any(dones):                                      # exit loop if episode finished\n",
    "                #print(\"   ** Debug: episode= {} steps={} rewards={} dones={}\".format(i_episode, steps,rewards,dones))\n",
    "                break\n",
    "        \n",
    "        # Save scores and compute average score over last 100 episodes       \n",
    "        episode_score  = np.max(scores)  # Consider the maximum score amongs all Agents\n",
    "        all_scores.append(episode_score)\n",
    "        scores_deque.append(episode_score)\n",
    "        avg_score = np.mean(scores_deque)\n",
    "\n",
    "        # Display statistics \n",
    "        print('\\rEpisode {}\\tAverage Score: {:.2f}\\tEpisode score (max over agents): {:.2f}'.format(i_episode, avg_score, episode_score), end=\"\")\n",
    "        if i_episode>0 and i_episode % 100 == 0:\n",
    "            print('\\rEpisode {}\\tAverage Score: {:.2f} (nb of total steps={}   noise={:.4f})'.format(i_episode, avg_score, all_steps, noise))\n",
    "            maddpg.checkpoints()\n",
    "            all_avg_score.append(avg_score)\n",
    "        \n",
    "        # Early stop\n",
    "        if (i_episode > 99) and (avg_score >=0.5):\n",
    "            print('\\rEnvironment solved in {} episodes with an Average Score of {:.2f}'.format(i_episode, avg_score))\n",
    "            maddpg.checkpoints()\n",
    "            return all_scores\n",
    "\n",
    "    return all_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 100\tAverage Score: 0.00 (nb of total steps=1558   noise=1.0000)\n",
      "Episode 200\tAverage Score: 0.00 (nb of total steps=3121   noise=1.0000)\n",
      "Episode 300\tAverage Score: 0.04 (nb of total steps=5198   noise=1.0000)\n",
      "Episode 400\tAverage Score: 0.00 (nb of total steps=6635   noise=1.0000)\n",
      "Episode 500\tAverage Score: 0.00 (nb of total steps=8070   noise=1.0000)\n",
      "Episode 600\tAverage Score: 0.00 (nb of total steps=9498   noise=1.0000)\n",
      "Episode 700\tAverage Score: 0.01 (nb of total steps=11066   noise=1.0000)\n",
      "Episode 800\tAverage Score: 0.01 (nb of total steps=12753   noise=1.0000)\n",
      "Episode 900\tAverage Score: 0.02 (nb of total steps=14682   noise=1.0000)\n",
      "Episode 1000\tAverage Score: 0.04 (nb of total steps=17038   noise=1.0000)\n",
      "Episode 1100\tAverage Score: 0.04 (nb of total steps=19243   noise=1.0000)\n",
      "Episode 1200\tAverage Score: 0.04 (nb of total steps=21568   noise=1.0000)\n",
      "Episode 1300\tAverage Score: 0.06 (nb of total steps=24455   noise=1.0000)\n",
      "Episode 1400\tAverage Score: 0.05 (nb of total steps=27161   noise=1.0000)\n",
      "Episode 1500\tAverage Score: 0.08 (nb of total steps=30595   noise=1.0000)\n",
      "Episode 1600\tAverage Score: 0.08 (nb of total steps=33894   noise=1.0000)\n",
      "Episode 1700\tAverage Score: 0.11 (nb of total steps=37826   noise=1.0000)\n",
      "Episode 1800\tAverage Score: 0.11 (nb of total steps=42440   noise=1.0000)\n",
      "Episode 1900\tAverage Score: 0.10 (nb of total steps=46197   noise=1.0000)\n",
      "Episode 2000\tAverage Score: 0.09 (nb of total steps=50130   noise=1.0000)\n",
      "Episode 2100\tAverage Score: 0.12 (nb of total steps=54678   noise=1.0000)\n",
      "Episode 2200\tAverage Score: 0.15 (nb of total steps=60458   noise=1.0000)\n",
      "Episode 2300\tAverage Score: 0.13 (nb of total steps=65953   noise=1.0000)\n",
      "Episode 2400\tAverage Score: 0.13 (nb of total steps=71453   noise=1.0000)\n",
      "Episode 2500\tAverage Score: 0.16 (nb of total steps=78070   noise=1.0000)\n",
      "Episode 2600\tAverage Score: 0.13 (nb of total steps=83669   noise=1.0000)\n",
      "Episode 2700\tAverage Score: 0.15 (nb of total steps=89850   noise=1.0000)\n",
      "Episode 2800\tAverage Score: 0.19 (nb of total steps=97708   noise=1.0000)\n",
      "Episode 2900\tAverage Score: 0.23 (nb of total steps=107231   noise=1.0000)\n",
      "Episode 3000\tAverage Score: 0.21 (nb of total steps=115463   noise=1.0000)\n",
      "Episode 3100\tAverage Score: 0.18 (nb of total steps=122983   noise=1.0000)\n",
      "Episode 3200\tAverage Score: 0.18 (nb of total steps=130365   noise=1.0000)\n",
      "Episode 3300\tAverage Score: 0.21 (nb of total steps=139153   noise=1.0000)\n",
      "Episode 3400\tAverage Score: 0.19 (nb of total steps=147159   noise=1.0000)\n",
      "Episode 3500\tAverage Score: 0.22 (nb of total steps=156135   noise=1.0000)\n",
      "Episode 3600\tAverage Score: 0.19 (nb of total steps=164039   noise=1.0000)\n",
      "Episode 3700\tAverage Score: 0.29 (nb of total steps=175532   noise=1.0000)\n",
      "Episode 3800\tAverage Score: 0.19 (nb of total steps=183552   noise=1.0000)\n",
      "Episode 3900\tAverage Score: 0.17 (nb of total steps=190530   noise=1.0000)\n",
      "Episode 4000\tAverage Score: 0.26 (nb of total steps=200851   noise=1.0000)\n",
      "Episode 4100\tAverage Score: 0.20 (nb of total steps=209129   noise=1.0000)\n",
      "Episode 4200\tAverage Score: 0.27 (nb of total steps=220373   noise=1.0000)\n",
      "Episode 4300\tAverage Score: 0.24 (nb of total steps=230596   noise=1.0000)\n",
      "Episode 4400\tAverage Score: 0.26 (nb of total steps=241111   noise=1.0000)\n",
      "Episode 4500\tAverage Score: 0.26 (nb of total steps=251545   noise=1.0000)\n",
      "Episode 4600\tAverage Score: 0.31 (nb of total steps=263892   noise=1.0000)\n",
      "Episode 4700\tAverage Score: 0.37 (nb of total steps=278775   noise=1.0000)\n",
      "Episode 4800\tAverage Score: 0.32 (nb of total steps=291790   noise=1.0000)\n",
      "Episode 4900\tAverage Score: 0.41 (nb of total steps=308255   noise=1.0000)\n",
      "Episode 5000\tAverage Score: 0.34 (nb of total steps=321711   noise=1.0000)\n",
      "Episode 5100\tAverage Score: 0.33 (nb of total steps=335081   noise=1.0000)\n",
      "Episode 5200\tAverage Score: 0.27 (nb of total steps=346050   noise=1.0000)\n",
      "Episode 5300\tAverage Score: 0.45 (nb of total steps=363716   noise=1.0000)\n",
      "Episode 5400\tAverage Score: 0.34 (nb of total steps=377338   noise=1.0000)\n",
      "Episode 5500\tAverage Score: 0.44 (nb of total steps=394648   noise=1.0000)\n",
      "Environment solved in 5529 episodes with an Average Score of 0.50 0.70\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwsAAAIUCAYAAABVUbBAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzs3XmcZHdd7//X6W26p6enZ6Z7ZpIJIRggREQBAwoiUCRcjHCFKKAoIIvCD9kRLruSgLixBDBsirIEFCIgCEQMQiosAQmBAIGsM5nJ7Jme3velzu+Pqpnp7qnqWvpU1TmnXs/Hox/VVWf71Dmnqr7vswZhGCJJkiRJq7U1uwBJkiRJ8WRYkCRJklSUYUGSJElSUYYFSZIkSUUZFiRJkiQVZViQJEmSVJRhQZIkSVJRhgVJkiRJRRkWJEmSJBVlWJAkSZJUlGFBkiRJUlGGBUmSJElFGRYkSZIkFWVYkCRJklSUYUGSJElSUYYFSZIkSUV1NLuAFhM2uwBJkiS1lGA9A7tnQZIkSVJR7llogkOHDjV8moODgwAMDQ01fNqqncstmVxuyeRySyaXWzK53Opv165dkYzHPQuSJEmSijIsSJIkSSrKsCBJkiSpKMOCJEmSpKIMC5IkSZKKMixIkiRJKsqwIEmSJKkow4IkSZKkogwLkiRJkooyLEiSJEkqyrAgSZIkqSjDgiRJkqSiDAuSJEmSijIsSJIkSSrKsCBJkiSpKMOCJEmSVKUwbHYFjWFYkCRJkqrw90N9PGTPTj4xurHZpdSdYUGSJEmq0PBSG+8d7mNoqZ033LOl2eXUnWFBkiRJqtD4UtDsEhrKsCBJkiSpKMOCJEmSpKIMC5IkSZKKMixIkiRJKsqwIEmSJKkow4IkSZKkogwLkiRJUoVa68Kp0NHsAtYryDIA/C7wJOCXgbOAeeCnwEeBj4YZchWOay9wTonOR8MMZ6y7YEmSJCkhEh8WgKcDHwQOA9cCdwM7gd8DPgL8dpDl6WGGsMLxjQHvKfL6ZAS1SpIkSYmRhrBwO/Bk4CvL9yAEWd4IfB94Kvng8LkKxzcaZrg06iIlSZKUfJVufU6LxJ+zEGb4RpjhS6sPNQozHAE+VHiaaXhhkiRJUsKlYc/CWhYKj4tVDLMhyPIs4N7AFPAT4JthhqWoi5MkSZLiLLVhIcjSAfxx4elXqxj0DODKVa/dFWR5XpjhukiKkyRJUiIVuxrSgYV2/urYZs7pWuT1AxMEKbpkUhCG6TzyKsjyTuDVwNVhhidVOMxbgG8BPwMmgHOBlwIvBGaBR4YZflzBeG4s9nqY4VcB5ufnKyknUh0d+Vy4uFjNThY1m8stmVxuyeRySyaXWzIlebntmYVf/GHXyedzvzHP437awfUT+aP7P3H/Rf5ge0UX4qyrrq6TNa4ruqRyz0KQ5eXkg8KtwLMrHS7McNmql24GXhRkmSyM71Lyl2mVJEmSAE4GBYDPH2+LRViISurCQpDlJcB7gZ8DF4UZhiMY7YfIh4XHVNJzmOGCUp0AhoaGIiipOoODgzRr2qqdyy2ZXG7J5HJLJpdbMiV5uY3Mt5O/Sn9e/j3sOvl8fn6OoaGRxhe2yq5du8r3VIHEXw1puSDLK4EryO8ReFzhikhRuKfw2BvR+CRJkqTYS01YCLK8DrgcuIl8ULinzCDVeGThcU+E45QkSZJiLRWHIQVZ/gJ4K3Aj8IS1Dj0KsnQC9wUWwgy7l73+S8Dh1cMGWc4hv7cC4JNR1y5JkiTFVeLDQpDlOeSDwhL5Kxm9PMie1tveMMPHCv+fBdwC7APus6yfpwOvD7JcC9xF/mpI9wWeBHQDVwPvrMNbkCRJUkKUuyxq2q4zmviwAPxC4bEdeGWJfq6Dk2GhlGuBBwAPJX/YUS8wCnyb/H0XrgwzqVv+kiRJqkJK7zpQUuLDQpjhUvKXNK20/70Uud5s4YZr3nRNkiRJKkjNCc6SJEmSomVYkCRJklSUYUGSJElSUYYFSZIkKSJpOwHasCBJkiRVqNylU9PGsCBJkqRUCkP49/Ee/mWkl5lcY6aZtjCR+EunSpIkScV8bWoDrzyyFYDpMOCl2yabXFHyuGdBkiRJqXTZsf6T///N0OYmVpJchgVJkiQpIp7gLEmSJKklGBYkSZIkFWVYkCRJklSUYUGSJElSUYYFSZIkSUUZFiRJkqSIpOxiSIYFSZIkScUZFiRJkiQVZViQJEmSKhQ0u4AGMyxIkiRJEUlbmDAsSJIkSRVK2wnM5XQ0uwBJkiQpSmEI35/pYu9C45u6aQsT7lmQJElSqlw13sPvHRhsdhmpYFiQJElSqvz50a3NLiE1DAuSJEmSijIsSJIkSRVK29WOyjEsSJIkSRHxBGdJkiRJLcGwIEmSJKkow4IkSZKkogwLkiRJkooyLEiSJEkqyrAgSZIkqSjDgiRJkqSiDAuSJEmSijIsSJIkSSrKsCBJkiStYXwpYDbX7Cqaw7AgSZIklXDDTBe/umcnD9uzk8MLrdd0br13LEmSJFXoGQe2MRO2MZJr5w33bCEo039Yto9kMSxIkiRJJcyGp5rLdy20N7GS5jAsSJIkSSrKsCBJkiSpKMOCJEmSVKGw2QU0mGFBkiRJUlGGBUmSJCkiadvzYFiQJEmSKpSuC6OWZ1iQJEmSIpK2MGFYkCRJklSUYUGSJElSUYYFSZIkKSKe4CxJkiSpJRgWJEmSpAql7QTmcgwLkiRJkooyLEiSJEkVKndOQq4hVTSOYUGSJEmKSsrOcDYsSJIkSRFJWVYwLEiSJEkqzrAgSZIkqSjDgiRJklQhL50qSZIkSRgWJEmSJJVgWJAkSZIikrarIXU0u4D1CrIMAL8LPAn4ZeAsYB74KfBR4KNhpvL7YwRZ7gW8FbgYGAAOA18ALgszjERbvSRJkhRfadiz8HTgn4BfB/4XeA/wOeBBwEeAq4JsZeeiBFnuC9wIPA/4PnA5sAd4BfDdQjCRJEmSWkLi9ywAtwNPBr6yfA9CkOWN5Bv8TwV+j3yAKOcDwA7g5WGGf1g2rncDrwLeDrwoutIlSZKk+Er8noUwwzfCDF9afahRmOEI8KHC00y58QRZzgWeAOwF3r+q81uAKeDZQZbe9dYsSZIkJUHiw0IZC4XHxQr6vbDweE2R4DEBfAfYCDwiuvIkSZKUJmk7wTm1YSHI0gH8ceHpVysY5AGFx9tLdL+j8HjeeuqSJEm1G15q47VH+3nbsc0spK1VlkBLIfzNsT5efaSfY4vxb1Z+fryHFxzayg9nOptdSmKk4ZyFUv6W/EnOV4cZ/ruC/vsLj2Mlup94fUu5EQVZbiz2epjJPw4ODlZQTrQ6OjqaNm3VzuWWTC63ZHK5JcNr72jnU2PtANyvv5tXdeQbqC635vjno21cMZL/7Mx19PDp8ys5mKMBn7cSm35fdmQrAFdP9jD3G/NVj6u9vYOt27bCXadeGxwcXNFPZ1dXqtbH+EfAGgRZXg68GrgVeHZUoy08uh1DkqQm+dSx9pP//9PR9jX6VCN89OippuR/DKeyWdnyUrdnIcjyEuC9wM+Bi8IMwxUOemLPQX+J7ptX9VdSmOGCUp0AhoaGKiwpOicSbjOmrdq53JLJ5ZZMLrek2HXyv6WlRRYX89vwXG7Nsbg4CHSdfF7pcqj/521X2T4qn/bKdW5keATYuWo8p/qZn59naKjS5mf97NpVfh5UIlURMMjySuAK4GbgcYUrIlXqtsJjqXMS7l94LHVOgyRJklKvtQ4ySU1YCLK8jvxN1G4iHxTuqXIU1xYenxBkV86XIEsf8ChgBvjeemuVJEmSkiAVYSHI8hfkT2i+kfyhRyX3KwVZOoMs5xfu1nxSmGE3cA1wH+Alqwa7DOgFPhFmmIqydkmSJCVXmPIdDYk/ZyHI8hzgrcAS8C3g5UH2tN72hhk+Vvj/LOAWYB/5YLDci4HrgfcFWS4q9PfrwOPIH370pqjrlyRJtQnK9yJpnRIfFoBfKDy2A68s0c91cDIslBRm2B1keRj58HEx8ETgMPA+4LIqTpaWJElSKrVWTE18WAgzXApcWkX/e1ljKYcZ9gPPW29dkiRJaj1hysJEKs5ZkCRJkhQ9w4IkSZJUsbXPaE7b+c6GBUmSJElFGRYkSZIkFWVYkCRJklSUYUGSJEmq0epzFNJ2kzbDgiRJkhSRlGUFw4IkSUqmdF3NXoonw4IkSZJUoXIhNW0h1rAgSZIkVShthxmVY1iQJEmSIpK2MGFYkCRJklSUYUGSJEmKiHsWJEmSJLUEw4IkSZJUobRd7agcw4IkSZJUo7QddrSaYUGSJElSUYYFSZKUSK12OIjUDIYFSZIkKSJpOyzJsCBJkiRVKG1hoBzDgiRJklSjtIcHw4IkSZJUo1vnOlY8T9u5NIYFSZIkVWT3fDvPPriNy45tJkz7JvUKveLI1hXP0zZbOsr3IkmSJMGfHNrGHfOdfGMKHtI93+xyYmEsl+5t7+l+d5IkSYrMHfOdJ///xlR3EyuJr7TtWTAsSJIkSTVKWzhYzbAgSZISKW0nkkpxZFiQJEmSahWu+TTxDAuSJEmqmldDag2GBUmSJCkiaQtRhgVJkiSpYq11toxhQZIkJVJrNdmk5jAsSJKkRErZ0R5SLBkWJEmSpBqlPbQaFiRJkiQVZViQJElqAWNLAbnCZvD5EKZzzTvrY3SRk7U0S1RXLVo9mjBlZ9MYFiRJUiKlq0lWX18Y7+HBu8/gCfu2c/dCOw/fs5Nf3bOTH892NryW/5zo5uwbOrngpg7mmxgYnrJ/sOmBJQkMC5IkSSn3kiNbWSDglvlOHnnXToaW2pnItfHHB7fVPM5a29l/dngb82HAz2fauHK0t+bpr9eNs118baq7adNPCsOCJElSixpaam/q9A8tNnf6Q4s2hctxDkmSJEkRSduRTYYFSZIkVc1zRvLSFg5WMyxIkiSpKZLY0C5XcxLf01oMC5IkSapa2hrFKs6wIEmSJKkow4IkSZJUo9NvypYuhgVJkiRJRRkWJEmSpBqlbU/CaoYFSZIkSUUZFiRJkiQVZViQJEmSVJRhQZIkSU2R9uP908CwIEmSKvL2Y308+q4dXDO5odmlABAEza4g/Q4ttPGUuwf5/f0DjCytnOEh8KPZrhWvPX7vdm6a7WxghaebyVW/YlwzuYFH37WDtx/rW/f0fzTbxaPu2sEnRzeue1xxYFiQJEll3TLXwQdG+tiz0MHzDg00uxw1yGuObuEHs118Z2YDbzvWv6Lblyd6Tuv/lvlOnrp/sFHlFfWe4U1VD/O8QwPsWciv47fOdazZ7+q9IceX2k/rZ+9CB6+7Z0vVdcSRYUGSJJW1d37tBlQzhB7DUnfXTXef/P+/J7tXdFug+Bb82bC5u3yum1rfnq99C/Fb15vJsCBJkqSmMPDFn2FBkiSV5fkBUmsyLEiSpLLimBUMMMkXx2Xozo6VDAuSJEmSijIsSJKksgK3t0otybAgSZKkpvAE5/gzLEiSJCk1zB/RSsWFZIMsTwMeCzwEeDDQB3wqzPCsKsezFzinROejYYYz1lOnJEmKTgzPjZVSJxVhAXgz+ZAwCRwAzl/HuMaA9xR5fXId45QkSVIDGCKjlZaw8CryIeFO8nsYrl3HuEbDDJdGUZQkSWkRxwaYh5skXxyXYbnzKOJYcz2lIiyEmVPhIMg2sRBJklIqjmFBKqaaxnwc7/MQN6kICxHbEGR5FnBvYAr4CfDNMMNSc8uSJElKl2a31b0aU3mGhdOdAVy56rW7gizPCzNc14yCJEnS6Zrd0FT83DDTxc1zXc0uI1UMCyt9FPgW8DNgAjgXeCnwQuC/giyPDDP8uNxIgiw3Fns9zOQfBwcHo6m2Ch0dHU2btmrncksml1syudzWtrktgEOnnjdtPt1+6t+OjnYKi63py20phANzcE53U8so7fbSndacd8uGC9oCyFU2uUrH2d3Tw+BgdI37S66vblyb+jYxOLhxRU2bN/cxOLDp1AvLurW3d7B161a4q7LxN3u9jELdwkKQJQB+F/g/wNlAT5jhomXde4ELgDDM8K161VGNMMNlq166GXhRkGUSeDVwKfn3JElSS/HY7tLCEB770w5umGzjL85e5M1nV9iilhKgLmEhyHJ/4PPAAzm1l3D1UWGzwEeA+wZZHh5m+GE9aonIh8iHhcdU0nOY4YJSnQCGhoYiKqtyJ5JtM6at2rncksnllkwut7VNTG0ABk4+b9582nXyv8XFJRYXwybXA/873cUNk/n15237O3hRz6EyQzTDrpJd1p53p4YLcyGVHvxV6ThnZmYYGhqvaJyVKf0+i5mcmGSofXrFcOPjEwyFs0XHubS0yMjICLCzovE3c73ctau6eVFK5HdwDrJsBf4H+CXyJwf/BXDaWlA4YfgD5Ne6p0ZdR8TuKTz2NrUKSZJ0UhCTi1hO5NztovSKPCyQ3wJ/NvBfwMPDDG8HZkr0+6XC4+PrUEeUHll43NPUKiRJahKbw2oV8Yig8VGPsPAU8vP5NWGGxbV6DDPsBuaA+9WhjqKCLJ1BlvODLPdd9fovBVm2Fen/HOCKwtNPNqJGSZIkKQ7qcc7CLwAzYYZbKux/EuhfzwSDLJcAlxSenlF4fGSQ5WOF/4fCDK8p/H8WcAuwD7jPstE8HXh9kOVa8ue4TwD3BZ4EdANXA+9cT52SJEmKj2In7rsXbaV6hIWw0vEGWbrIB4X1ntnyEOA5q147t/AH+WDwGtZ2LfAA4KHkDzvqBUaBb5O/78KVYcY9U5Kk1mQDqjTnTXLVclO2VruRWz3Cwl3ALwVZ7h9muKNMv08s1FDpXoiiwgyXkr+saSX97qXI57pwwzVvuiZJktTCWiwLlFWPcxa+Qr4x/uq1egqybCd/WE8IfLEOdUiSpIi49Vz1kPaGeRr2QtRjz8K7yN/x+AVBlmng8uUdgyw7gN8D3kz+wrUHgQ/WoQ5JkhQRw4LUmiLfsxBmGCJ/RaRx4BXAXmAHQJBlCDgMvJ98UBgGLgkzTEVdhyRJkqT1qcdhSIQZvg08GPg3YIH8BokA2FZ4XAI+A1wQZrixHjVIkiRJWp96HIYEQJjhbuBZQZY/BR4GnEk+nBwFfhBmmKzXtCVJUvp5aFRjpeDwe9Ug8rAQZPmVwr97wgyTYYZZ8pcflSQlWBjCNVPdjC0FXLJ5hi5bai1mZVPxY6MbeeCGRX6tZ75J9cBP57r48vACT9ra3GZssWv1r9e3prvYO9/B0zbP0NNW2fv75lQXdy908NQqhgHIhfCVyW4Ww4Df6Zuho4U+26WW3dhSwOfGN/Lg7vWt3yHJD7X12LNwE5Ajf3M09x5IUkpcP9PF8w/lb3Q/HQY8d8t0kytSI61uVL3pni0A3PALR9jVmWtCRXlPvbWTbzxogQc0rYLo3THXwTMODAJwaLGd1w1OlB3mtrkO/vBgfpgji+28poJhTvjaVDcvOpz/bC8BT9s8U7S/pDd6KxUClx7r56rxjc0uJRbqcc7CGDBWONFZkpQSrz+65eT/JxqK0sdHe5tdAq++q73ZJUTqXcf7Tv7/vuG+Nfo85Z3Lhrm8wmFOeNnhU5/nVxzZWtWwSVfq0qYGhVPqERZuB/qCLN11GLckSWqCVtmqrNI8Z6E11SMsXEn+8KY/rsO4JUmSVrARq0aqZn1Lw7pZj3MW3g9cBLwnyLIEfDTM0LyDGSVJ0rq5Z0FqTfUIC/8MjAKLwD8CfxNk+QFwjPx5M8WEYYY/qUMtkqSIBKnYRiZptSAgHZvAVRf1CAvPZeWVogaBi8sME4JhQZIkSYqTeoSFy+owTkmS1ERxPgyp2RvF4zxv4q7Zy67e0vD+Ig8LYcawIEmSVKt63ORNxRWb12lo4EepHldDkiRJKWP7VfXgehV/hgVJklSWjbrGKXWjMEXPeV1ePc5ZACDI0gk8E/h94FeBgUKn48APgc8A/xpmWKhXDZIkSYqvtLfV0/D+6rJnIchyX+BG8pdRvRjYAbQX/nYUXvsX4AeFfiVJMedx1FJj1PJZW8/H04+21hL5noUgy2bg68C9gQXgs8A3gAOFXu4FXAg8Dfhl4GtBlgeHGSairkWSJEUjzg1KDyVRI7Xa6laPw5D+nHxQ2Ac8Kczw8yL9/HOQ5a+BrwDnFIbxKkqSJKnh7pzvoCsIuXdnqXvHri3qIPWz2WibZ8NL1R1IcsNMJ7+4YZFNbSubxdO5+kbGMIQfznZyv65F+ttDJnMBt8x1ckH3PG0VTHoxhq34yVzAnfOVv4c4qsdhSL9LPnQ9v0RQACDM8DPyN2ILgN+rQx2SJCkiaT0M7ZtTXTx27w5+464d3BxxI70W/z7ew+6FznWP55tTXQCMLwX88u4zqhr2kv3buWjv9tMa3wt13r/0ruN9PHn/dh6zdwczuYAn7NvOJfsHufTY5oqGf8WRLXWtrxaP37eDS/YPclmF7yGO6hEWzgWmwwzXlusxzPB1YLowjCRJUkP90cH89VdCAl58eGuTq4FXHommhhPv64Mjm2oa/sBiB9+Y2hBJLWtZnkcuH+4DYGipnVcc2cK+hXx4++fRyt7DFyY2Rl7Teh1ZbAfgIxW+hzjy0qmSJKmslO5YIFz2zkZy6WkWnXhfU+s4dGgubN5SH2vQskjrHrMo1WNJ7AY2BlkuLNdjkOUiYCOwpw51SJKkiMTwcPDYsL1ZO+dd/NUjLHyB/LL/lyDLL5bqKcjyYPKXVg2Bz9ehDklShPxRl4qLQ5Dy0qm18Upa5dXjTJ53Ac8lf0Wkm4IsXwCuBQ4CG8hf/ehxwG+TXz/3Au+uQx2SJCkicW5Q2t5LLpdd/EUeFsIME0GWxwOfI38fhacV/pY78Z3zE+Cp3mNBkiRJip+6nD0SZrgTeBjwx8CXyO9VmC/8HQT+s9Dt4WGG3fWoQZIkqRHivNdlPdzqL6jPYUgAhBkWgE8W/iRJUqLZdFRrcE1fKT3XCJMkSS3Jxl19NGKPSdjEy7PWqtXWt8j3LARZ2oGzgMUww6Ey/e4q1HAgzJCLuhZJkiTVphUaxd5nobx67Fn4A+Au4K0V9PuuQr9PrUMdkqQI+ZsqFReHz4aXTo2O82OleoUFgH+poN8Pk18mz6hDHZIkSXWX1i3wjWg0B0HxudfMBntal2et6hEWHlR4/HEF/d5QePyVOtQhSZKkGjWz0WyDPT7qERZ2AaNhhqlyPRb6GS0MI0mSYqrVDs2YztX/HZ+YxnyY/6vnNOKq2Sc4ewfn8uoRFqaBTUG2/MnTQZZOoJf8/RckSZKa7o1H+3nAnWfw18f6Kup/dXN3eKl88+r1hWm84NBWHr5nJ7+2Zyd75ttrqDbvS5M9p7327uOb+Lfx3rLDNrO5/rGx8vWpueoRFm4lf4Wjiyvo92KgE7i9DnVIknRSGMJnxnr4x5FeZrz+XqpEuXF4Jhfw8bFecgS8f6SysLDaW+7ZvGb3yVzAlYVpXD3Zw9BSO8eW2nnZ4a01Te/OEiHjXcfXruOEUvPvZ3OdNdVTrR/MNGY6qk09wsJ/kA+plwdZzijVU5DlTOA95NfRL9ShDkmSTvra1Ab+/OhWLjvWz4dHNjW7HMXUQgTJ47b5tRu/pQ45ummuq6bpjVewJ6MWVwzXFpaqVWxPTLwPnmot9biD8weAlwDnAj8OsrwD+C/g7kL3c4AnAq8GtgP7gX+oQx2SpAgl/cf77UOntrK+4/hmXjkw2cRqlC7JPvA96Z9t1VfkYSHMMB1keRLwVeBewN8V/lYLgIPAk8IMfmNLkqRUaHR0SHZUaW5Y8aZs5dVlv1WY4efAg4F3AkfJrwfL/44C7wAeHGa4uR41SJKk6MS5TdX8K9rEee4kU5wv29r01a3B6nEYEgBhhhHgtcBrgyznADvJf5qOhBn21Wu6kiQVY3NOjdLo8JL0xqufzXirW1hYrhAODAiSJCmFkt5cl0prSFgACLK8DHg+cB75+yrcBLwnzPDFRtUgSZJUb40+Dj6NW+Yb9Z6afwhb/K37nIUgy8OCLMNBlt1Blg0l+vk0+cuk/grQA/QDjwU+H2R53XprkCRJigsPQ1KaRHGC84XAFuDqMMPc6o5Blj8Cfp98SLwH+EfgcuCuwmtvC7L8YgR1SJLqKI1bLyU1n98t8RZFWHgM+VD7HyW6v6LweDfwoDDDi8IMrwYeBPwIaAf+JII6JElSnbRCg67W9+jlN6Pn3pL4iCIsnEt+mf7v6g5BlkHg4YXubw0zHD/RLcwwA1xK/rP52AjqkCSpJNtz6RVVwzKpDdSk1n1C7MJW0mdoxKIIC2cA42GGqSLdfqPwGAJfKtL964XHcyOoQ5Kkkvz9V714kmz0GpUfYhdUYiiKsNALxU9sJr9XAeDOMMOx1R3DDNPAGNAXQR2SJKlObFOlV2CU1hqiCAvHge4gy44i3R5BfmPOD9YYvov8pVQlSaobG7vrU4/m5NUT3Vy0dztXDG9ieCngmQe28YwDAxxbjKJ5UtrfDPXx+L3buW6q1LbO6qzeOn3LfCcAuRBecWQLT9o3yM2z9bta/dcmu+s27vW6cnQjF+7dzqfHekr2c2SxnafvH2hgVadcN7WBs27fteK13BrfFncWlm0rieLT+OPC47OWv1g4X+HRhafXFRswyHIG+UupHoygDkmSlCAvOLyNW+c7+Zuhzbz48Day0918a3oDb76nv27TvHm2gyuG+7hlvpM/OljfBuq/j/fw2fGN3DTXxTMO1D6tb093kVsjrb1/JJ4HaCyF8Pp7tnDbfCevPrq1ZH+vPdrP9TPRBLdqfXny9BDzb2Mb1xym1fbDRBEWPkN+g81fBll+N8jSFWT5BeATnNprUOpKSSfCxM0R1CFJqiO3zLe2ei//b02faiwWa8BFZa0tw1G/x+8tawCP5NprHs8fHBjkyjIN2DharLBVHcbs2+U7TQoucRVFWLgSuBHYDHwWmAHuBH6LfPi6IswwVGLYZxT6+XYEdUiSVFK8miOKUlSNzThvMX7jPVuaXYJa1LrDQphhCfht4Gvkv4uX/10JvKHYcEGWc4EnF54Wu1KSJEmRiXNDUMlmEFWaRXK2TWHPwW8FWR4A/HLh5RvDDHetMVgOuARYCDPcGUUdkiSpPtJyiUmv/NM4zul0iPRm4+6xAAAgAElEQVTU/DDDbcBtFfa7F9gb5fQlSSolJW1dJUipxnLc1sW0BEHVR32vTSZJklRnbsGOJzNIOhgWJEmSiL5xW2p8hhsliWFBkiQlWlWNfDd3N4yhKB3qdzvBBgqyPA14LPAQ4MFAH/CpMLPyRnEVjutewFuBi4EB4DDwBeCyMMNIZEVLkqRIRNUotXErnS4VYQF4M/mQMAkcAM6vZSRBlvsC1wM7gC8CtwK/BrwCuDjI8qgww/FIKpYkSbFTy46Hag83cueGkiQtYeFV5EPCneT3MFxb43g+QD4ovDzM8A8nXgyyvLswjbcDL1pfqZKkZrCBpkq4d0Hltda3SSrOWQgzXBtmuCPM1P4ZL9wk7gnkL+f6/lWd3wJMAc8OsvTWXKgkSYqtRjUB4xZIWqvpq2qlIixE5MLC4zVhhtzyDmGGCeA7wEbgEY0uTJKkZgvj1sJdpprSGtkwthFeO2+eFx9pOQwpCg8oPN5eovsd5Pc8nAd8vSEVSVKMpPHGTV+d7OaayW7+dOskj2l2MTGXK/H6voUOXnu0nwu65/mD/pmG1tRoHxvdyM/nOgmA3raQV26bYHN75Y3aPfPtnNu1FEktXxzv5lvTG3jRtqlIxhe1Vx3ZwpP7Tl8fhpcq+yL55nR32X5unu3gX0Y38dDueW6Z66y6xlq96siWhk0rDgwLp/QXHsdKdD/xetk1JMhyY7HXw0z+cXBwsLrKItDR0dG0aat2LrdkSuty6zjQvuJ50t5f+4F2mF/2Qv8gf3J7FwBXT/Uwek6+0Ze099UoX7+rvejrX5rsAeBTY7089oxNPKi3ii3CpTbPscZyKDJMsFb/q2ymLX+dwyKCoI2BgQHYfXod140FvOmelQ3Stg09vOfcJfrHgvyZk8vc0bWdDRtWHsDxJ0d38NOHLtC2wIppVOpELftm4cWFdfc7sxurH9EqbUH0B5pcNb6Rq8ZX1jY4OMgb7ii+HpWzcesgG1cN+uTvdjIXBnxmfP3zoBo/nO2qabikfrd4GFLlTkRh94tJUgrcPH1qC+dEhVs7W9kHj5RvMlw9kvz5WOodfPrY6e//g0dKN3z//fjp/d8+E838+fb4qXHfPZ+sef6JY7WFhcMLp782FybrvSeVexZOObHnoL9E982r+ispzHBBqU4AQ0ND1VUWgRNpthnTVu1cbsmU1uW2uLSd5duYkvb+cosr6x8bGwNObelbXFwEkve+GufMsn1MTU8zNDRZxTh3lexSejmcPkwurHy5jU90A9uKdsuFOYaOH2f5ez0x3tnZfihyjZOhoSHGprtYvi4BzM7MMJtrI3+648r+84filJ+fxaYFMDHZA2ytevhScmEOqK0RX418/aWX+VpGhkcYOu0QrtrG1SyN/m7ZtSua+eOehVNuKzyeV6L7/QuPa+w0lSRJcbbWtuhat1MXG87DEJQWhoVTTtyb4QlBduV8CbL0AY8CZoDvNbowSVL0PIBB9ZaUdSwpdao5Wi4sBFk6gyznF+7WfFKYYTdwDXAf4CWrBruM/L7HT4QZ4nnZAUmS6ijOl06NowDv4Lya61AypeKchSDLJcAlhadnFB4fGWT5WOH/oTDDawr/nwXcAuwjHwyWezFwPfC+IMtFhf5+HXgc+cOP3lSP+iUpCVq1gSPVwnax0iIVYQF4CPCcVa+dW/iDfDB4DWWEGXYHWR4GvBW4GHgi+QusvQ+4LMwwHFnFkiQpVkJKh+I03mdEqkQqwkKY4VLg0gr73csaG8jCDPuB50VRlyRJipc4tPnd66AkablzFiRJUvXivGU9qsb3WucZqLlcLs1jWJAkSWV5cmpp1eaoGOeuunIVSibDgiSpJbVqg61WNvSqk6T5lYTPQhJqTCvDgiRJkqSiDAuSpIoEidpWqqjFectuNWvmWu9jrashVavcdOo17rTy26d5DAuSJImRpYCPj27k9rn8hRInlgI+ObqRm2dTceHEiv1krnPF8/kQPj/ew7enN5QcZmjp9OZUSP0auEltOCe17lbXWt8AkiSpqNce3cLVkz30t+X44blHeNvQZj411ktXEPKjc480u7zIrLVVfmSpjd8/MLjitU+O9vIXx/pLDjMfwssOb42sBilu3LMgSWpJNthWunqyB4CxXBvXz2zgU2O9AMyHAZ8d39jM0homLLJWrBUUAH4008VCibXp56v2UkSlFdfdVnzPcWFYkCS1hDjfJyBuvExqNOoVFqRGMixIkqSyzA/plYQc7frXPIYFSZKkBlpvwzepDeek1t3qDAuSpIokYeujWlNUl06VdDrDgiSpJdloLM0twPHWiutuK77nuDAsSJIkRSwMk9O8TUKlBtjmMSxIklpCEhpEUjPYENdaDAuSJKksw1aUWnNuGkqSybAgSZJWKNaoS0tDz/ttnM5ZorUYFiRJUllxDgveRE6qH8OCJKkibn2UpNZjWJAktSQPR6mOs0tqTYYFSVJLCGJwIM0tcx2MLcW/2f3j2a4Vz+djcBnQ4aWA2+Y66tZ/Kzu61N6Q6aznE7h/oYODC42pUysZFiRJaoCPj27k8ft28Ii7djIR88Bw+XDfiudvH9rc1Kh1fLGNX9uzkwv37SjafXVtw0un+v/MWM+Kbo2a82vNr1Y9x+JvhzbXPOwfHhzgEXft4KbZzggrUiUMC5IkNcAb79kCwHiujQ+MbGpyNdVbauKBSH93vI+ZsPImy98Pner/z49urVdZTfGvYxt5+ZFkvqcPr3O9zxHwp4e2RVSNKmVYkCSpwSZy8d6zEDejS2s3V1bPzXL9J9XdC+38v6Nbml1GUx1bTOeyjTPnuCSpJTWzuR7G4ByAJCl31E6rHNXzUw/BaZllHSeGBUlSRWzeKilsUKaXy7bxDAuSpJZg2BHE46pYza9AqpxhQZKkBrOxKCkpDAuSJCnRDF9S/RgWJEktyiamlDR+ahvPsCBJkiSpKMOCJKklxOkEZ7eOpt+ad3CucZxxWofVOgwLkqSKJL2hYgNdkqpnWJAkSS0j6aG31YUuwYYzLEiSWsLqJoZNjtbkHiapOoYFSWqwMIS5XLOrqF7QxNZ1sfk1l8vPy9UmloKir8dJ1OXN5WAphMWYv+9ahCHMhUY7nZILYT6B63ougTWDYUGSGmo2B0+4ezsP2XMG35zqanY5VWlWA/xFh7byi7vP5GOjG0++dsNMF7+65wwy+7YzsXSqIfn4vds5f/eZ3OuOXcwmMJDV4oPDvZx75y7ufccufn3PTnbPtze7pMjM5uDiuwf5+lR3ZOOMOna8+MjWiMdY2gsOb2vYtOLsN/fu4OF7dja7jKpN5JIZeg0LktRAHxrZxM/nOhnPtfGHBwebXU7s3TzbwZcme5gLA950z5aTrz9t/wCjuTbunO/kHcf7mMvBv4z0cst858l+/nFk04pxJfNnury/Guo/+f+RpXYu3LuD9xzfxL4UhIZ/Gt3EzXPxDtVHFqubz58f76FFcmzd7FvoYGgp+et3UhgWJKmB7pzvaHYJiVKqQbC4rOl/61wnV4718hfH+lf0s3th5byO0xEA9axlkYB3HN/MMw8O1HEqjVHr52Wt+dvs0PiyI1u5ZjK6PSVSvRkWJEkVaeY5C2sJgbesCgqCuxZaJ5hWc4hco0LjWtP5S9dXJYhhQZIaKKbt7ZYQp3kfp70cary4n4Cv+ojTd1A1DAuSpJaU1B9urY/LXaqOYUGSlEpuvVVcuWoqSQwLkqREs+GlasRhz4LrbGuKw7pXC8OCJCmV4npCtiQliWFBkpRKHobUOlzUUv0YFiRJqbS6Abl6R4M7HtQshpvWlNS9nYYFSZKkiBkIlBaGBUmS1DLisHXXIKEkMSxIUgPFoJ1Ss6TVboNMzbTW5yVM3KdJUUjqUjcsSJIqEtfGd6m64lovePJ1K3ARKy0MC5JSJQzhDUf7ueTuAW6e7Wh2OSv8x3gPn5vYWPVwRxbbeNaBbbzg0FYmc+vbNrVvvp3f3z/ASw9vYT7lrZlyb+81R7es2f0dQ33837sH+e50F3fMdfDU/QO86sgWlpaN+ObZDp5y9yDPPLCNp+0f4GWHt7AQo/l6yd0D/Gxu5edgbCng+Qe38ri927lo73b+7PBWZnPRTO9vhzavmD/rlZ3aUFF/++cD3n6sj7Nu38VZt+/ilrnOFd1fcGgr07mA+RCefXAgugKlFhCvX1JJWqcvT3bzibFeAJ5xYICb73e0yRWd8tIjW2sa7nVHt3DtdDcAZw0tcemO8ZpreMmRrfxotguA8zcs8tJtkzWPKy6+P9NVUX+rj1W/bb6zeI/AT2c7ec9wHwBPOzDIfToX2bvQwfdm4ILueZ61ZRqA3z8wyFhu5Xa3B3Uv8P9tnariHdTPDbMb+KMDA/z4vqc+B383tJn/nuo5+fzW+U7O61qIbJr/OraRZxfmz3oNLbVX3O8HRvpO/r9nYWXz5urJHu5zfJEt7TFKcmo5HoYkSTHw3elTWyJHcpU3NOLsf6a6T/7/nxM9a/RZ3omgAPC1ye41+jxdXH/ociUqW89x4T9ftTV+77LG53XL1rHVQQHg6xXM10Y2WVc3uD9fZB367yrXhbUsnz9x8pXJHq6J8H1KrcKwIElKpfWcF5Dm7c9xDX31FgJBqpesVB+GBUmSGqyZTdZiYcEmdPScp0oLw4IkqSJJ2yJtY605vNKTVFzSvkNPMCxIkqSW0MgbsiW1YSitZliQlCpp/4Fu5kbbpG0wbla9SZtPqg/XA6WFYUGSlEpxbqw18w6+9Z5yXOe7h0ep+ZK5EhoWJClB4nZirNIhyvAS5+aQ67BUvdTclC3Ici/grcDFwABwGPgCcFmYYaTCcWSBx67RS0+YYXadpUqSpCYwLEjVS0VYCLLcF7ge2AF8EbgV+DXgFcDFQZZHhRmOVzHKy0q8vriuQiVJDVOvLdxx3nJeiVa910BrvmvFSVLDairCAvAB8kHh5WGGfzjxYpDl3cCrgLcDL6p0ZGGGS6MuUFJjBIFNgnpJ6g9dHDX1cLI6L8hmno8hKXqJP2chyHIu8ARgL/D+VZ3fAkwBzw6y9Da4NEmKnFGocqtPaI2qCeuJsmuLavbUYz4bY6TqpWHPwoWFx2vCDLnlHcIME0GW75APE48Avl7JCIMsfwD8AjAP3AJ8I8wwF13JkpQ8SWsjr663mvrTvHU8ve9MirekfvbSEBYeUHi8vUT3O8iHhfOoMCwAn171/J4gy0vCDJ+toT5JSryDC23cONu14rU337OZh3fP85TN+es+jC0FfGB4E1vbc7xw6xRtdfhl/PuhPo4vVb5T/PrpLr440cMf9k/zo1X1r/b6ve2c3xPynaF+NrXlSvb31akepnKj/GS2c83xfWu6i2ccGATgP88+tqLbVeMbuWp8Ixf2zrK9PcfFm2Y4u3OJj4/2cvGmWTK9pbdPTeUC3j+8ialc5WcfXLh3O+d2LfLqgYmi3X82t/Z7aYafRFzTgcUODiw2rtnzqTEPaFA6pCEs9Bcex0p0P/H6lgrG9UXgncCPgOPAOcBzgFcDnwmy/N8ww3+VG0mQ5cZir4eZ/OPg4GAFpUSro6OjadNW7Vxu1eseb1/xPFaftyKbNCqqb9lwbW1t63tPy8bV2dlR8biecfPpPxcfHd3ER4FHnznPeT1w6e52/mkkP/8fsK2Xpw+WbnBXanN7AAdPPX/vcF/Fw4adG3j6gR4APllBw+3yQyfWnfI/jR+a3sG7D7UX7dbV2cng4CDPuP5UOHny/u1F+/3GVDcAnxnfePK1K8d6OfZr82wuUcb79rXz3uHi0y7ltvlObpvv5PqZbja0AUtVDV6Vzq4uBgYGGV6EgXLt/VKb+YAn3l18nklJNTg4mP/8JUwCS67aiW1bZTfAhBkuDzN8OcxwMMwwG2a4LczwRvJhoQ3463oWKknlNOt4+W+Nl/65uHok3+2fjp5qwL73UPN/Xo4t1G/cpYJCVG6bKb1b5u8O1j7tsaWg/jdlC+GJP+/grBs6eefB5q8HUlx4GFLznNhz0F+i++ZV/dXiI8DlwEOCLH1hhuL7cQvCDBeU6gQwNDS0jlJqc2LrYTOmrdq53Ko3O7sZ2HTyebw+b7tO67ey+k4Nlwtz63xPp8a1sLBYxbhOr/2EqakphoamVvSzuFjNuEsbn9pA/tY51VtYXATWPvSoHuYXFhgaOs5a86yc0dFRhuZKpZ3axwuQy+WA+oWdGyZCji/lx/+mfR08d8OhNfpe33uRkmTo+BBdDUwMu3ZF8/lKQ+S/rfB4Xonu9y88rrGzc22FG7GdCAgehChJUgmjVZxTIin+0vCJvrbw+IQgu/L9BFn6gEcBM8D3ap1AkOUBwFbygcFNvFKMJXU3b6XieEWiYodGxWE5NOuKRlEsozgu50oluXZJp0t8WAgz7AauAe4DvGRV58vI7wn4RJhh6sSLQZbzgyznL+8xyHJukOWs1eMPsgwCHy08/XSY8S7OkpQEOVutRdX9nIU6j19KqjhsRKlFGs5ZAHgxcD3wviDLReTvjfDrwOPIH370plX931J4XL7cHgN8JMhyHbAbGAbuDTyR/PkQPwBeW683IElpktQfxShE8d7r2eCuf1ho5aUvpU8qwkKYYXeQ5WHAW4GLyTfwDwPvAy4LMwxXMJobgU8CFwAPIX9i9ATwU+Aq4MNhhvk6lC9JShG3rEtKk1SEBYAww37geRX2e9pmjzDDT4HnRlyWJAHRXfK0WZdOXUsMSwJg/Xd5aJ4k71mQVFxSP3uJP2dBkpZL6pdx2rTycoj9e499gZLixLAgSVoXj1FfqdWvhiQpXQwLktQArdb4C2LwjptfQTwZ7aTmSOpnz7AgSQkSx634cW2Ux7WuysRvOUtqTYYFSVIqJTss1E8c9vpISo7UXA1Jkprl9rkObprt5MzOJa6f3sADl9r4g8GV1+KppHm2f6Gdp9w9yAU987zvjBF6Ktics3u+nR/MdPHETbP0tRefymII10x2c8f8yq/8pQpqqkSxqQYBzOQCvjLZzQM3LPDADfn7Wd4408mBxXZ+e9MsXYWN5zM5uHKsl6vGNjKaa+OZ/VM8euMc29tzvGOor+a67pzvrHnY9RhdauNPDm5d1ziuGN7ED2c7edPgONvbc/xkrpPrpjZwawTvqdH7LGZyAT1tBhQpqfsLDQuStA4TSwFPunuQ6XBZy34Ybple4rVVtHPDEB5x104Arp7sYeFwwMfOGmZiqfTPy0wOnnz3dkZzbXxvZprLzxgt2t/nxnv486OnN15/NNtVeYE1eOfxPj40sonuIOSGc48wstTGk/dvB+At28d44dYpAN4z3McVw33LhtvMO4/XtbS6umW+k1vW2aj/n6luAF5dZLmtV6Ob7Zcf38Qbt080eKqSouJhSJK0Dp8d71kZFAree7i9qvHcs7RyHF8rNBY/O95TcpivT3UzmssPd9X4xpL9FQsKjfChkU0AzIYBHxvt5a+ObT7Z7bJj/Sf/Xx4UVH8Tucb+9L9/xOUrJZlhQZLWIaoTjpN8kEbRw5CK9pfUnfCStH5J/QY0LEhSA5QLA3G8M7MkSYYFSYqBUlkhWLUpanl/cdlKVSzoFKvNq/DEQ1zWG0nJYFiQlCpJbQilrRmd1OUgSVrJsCBJDVCPMBCXBnml7y0u9bY6l4PUHKv3FCeFYUGSYmyt35ak/e4krd60cjlIqoZhQZJiobImXBwPV4pjTZKkaBgWJKkByl4NqcTra+5ZiPEm4qInOMe4XklScYYFSYqBmsJCPQqpgecsSFJ6GRYkKQY8lEeN4iVsJVXDsCBJDVDupmuluq/eGr/yPgvxbfS5FyG+PBxMUjUMC5JSpdHtoKia67mIxhNntlElKXkMC1IThSHcOtfBXCu0FCOwEMLP5zrKbqVf7ra5jrL9TOYC7pxvX0dlxQ0vtZ0c/+6F0nXcNtfB/iLdb5zp5GtT3UWHmc4F7J5fOczEUsA1kxu4frqLm2fLv2+AW+Y6mM3B1yY3cM9iG2EIN8928L3pLm6a7eTaqQ0ML63dzA+Bn5WZz5cf7+Onc50rXtsz387hBX+GGm14Kfp1vZwwzK9rc7n8/9+e7mJ3HT5zkqJX2a+JpLr4++N9vG+4j/t1LXDtOcdoc9Prmp62f5AfzHbxrP4p/m7nWEXDXLhvB/9vYJxXDkwW7T6ZC3jEnh2M5Nr5+x2jPHPLdGT1PmzPTq6+9zGefmCgZAPtPcc38Y7jm4t2e/L+7ae9FgIzuYDfuGsHx1aN8/zdZ654/vrBcV62rfj7PuHx+3aseP7Injm+O7NhzWFWe9fxzbxr1XtYfahLjoC7VwWiR+/dWdV0lFxvvqefj431cl7XAmd3LvH1EiFYUvy4SUdqovcN9wFw53x+C+77hzfxqiNbOLjgFrfVds+384PZLgA+OdZb1bClGuMAHx7exEguP79fe8+W2gssYi4MuGjfjjW35K5VWykfH914WlAo5m+Hqh93tUFBqsTHCp/Z2+c7DQpSwrhnQYqJqye7+fR4/gd130I7nz/7eJMripf5sD67XUZzydudM5qL/3ae5M1VSVIx8f/FkVrEFyd6Tv7/v27drVm1V3pJYqM2iTVLkpLJsCBJCVLNyd2SJK2XYUGSFLk43wNCklQ5w4KkluYhPfXhfJWkdDAsSEqEem2nTmKjNok1S5KSybAgqaVVe0L0acNHU0bFknJwj4FGktLBsCCppdmolSSpNMOCpJZmWKgP56skpYNhQVKqpP2woBAb4pKkxjEsSEqEejWQk9jwTmLNkqRkMixIamlJux9AUqo10EhSOhgWVNJi6N1iK7UYw/m0uqbFcOVrq5/P5mAhXDnsiX7CEJbC4sOtFoYwl1s5jtVmc+VrX13rWtNbDPPjDEOYL9HviXEuf0+zOVha1aydzgUr+pnOBSc/ByfmUTOX92zYxkxYeVO8WZ/hxeZMVpIUsY5mF6B4+u50Fy88vJV7dyzxubOH6DZWlvQf4z287mg/v7lxjn/eNVLzpThnwuhm8ufGe3jD0X4e0zvHB88c4en7B7hhdgMAv9c3zWiujW9MdQPwym0TzIQBHx7ZdHL4/rYcY7mV9ZzZscTztkzx10ObAbjqXkM8auP8in6Gl9r45d1nrHitry3Hu3eO8sS+WQDud8cZJ9/r3fc/RPuq+fWF8R5ecmQrAM/pn+Ki3lledmTrySBzwhcnunlC7xyX7B/g5rmusvPknDt2le0H4P53nln09d/cOMe3pzecfP6nWyZ54+A4f3msv6LxRulDy5ZVOfeq8H1H7ZvT3U2ZriQpWkHopuNGCgEOHTrU8AkPDg4CMDQ0VFH/Z91+qoHx/wbGeeXAZF3qSoPl8+pfzzrOY3vnahp2tYPnHap6uRUb7xM3zXD1ZE9Vw1fq4Hkr1+WXHd7C5yc2luz3+zNd/O7+wZOvvWPnKH/UP72iv7XmyWq/smGen1QQFOrlpdsmuGK4r2nTlyQlx+rfzHrbtevk7+m6jgx1e7HKum2+s9klJMaBhfZml3Ca66Y2lO8pIj+cXbvhfmjV/Nk9v76dm80MCgA3lXm/kiQlnWFBZbnzqXJlDsVPvVZ//5IkpY1hQWWZFSoXx8ZyredQ1KJcsFzd2XVLkqR4MyyoLBt0lYvjvIrTJSxXz59cHGeYJEk6ybCgsmzPVS6Oh2w1MiyUe/sxnD2SJGkNhgUpQrlYbcfPi3NYMDxIkhRvhgWVZYOucrE8Z6GB0zIsSJKULoYFlRXHQ2viqtVnVbk9K6vPUUj6/PKzIUlKO8OCyrI9VLk4nrAbuATrJo57kiRJipJhQWXZ1Kxcy8+rFrt0atLrlySpHMOCygpjeNJuXMXyBOdG3mehbPeVxYRh/OZXNdyzIElKO8OCynLraeXi2Hhs5Ie82hOc4zi/qpFLeNiRJKkcw4LKMixULp7nLDRODN9+XS01uwBJkuosCL2cRyOFAIcOHWroRN94tJ/s7EaWQvjrwWEu2jRXtL+3HtvMh0c2nfb6Rb2zfOKs4aLDzOQC7nfnmVXV89KtE7xh+0TF/b9rqI/rZ7p44+A4F/QsVDWtevr8eA8vO7L1tNfbCLl35xJ7FzqaUJUkSYqjg+c1tv23a9euE/+ua7uhexZawNBSG/vmAg7MB0yVOGxieCkoGhTy3dq4Yaaz6GUi33Jsc9X1XDHSx7enuyrq90cznbx7uI/vzWzgyfu3Vz2t1cIQfjDTya1zHbz3+Ca+PNHNz+Y62DvfDuTnQ6n3utxCSNGgAPnzFgwKkiQpDWzRtICO4FTLt9Qx1kcX20sO/6PZLi7Zv53XDYzz8oHJFd0+NdZbU03fn+niNzfOl+3vptnOmsZfyodHennbUH/Rbl84e4jnHtzGaK6N1wyM86pV73W5Zx8ciLQuSZKkOHLPQgtYHgMW1zGevzte/V6EUio9MTTqK/mUCgoAl+wfZDSX/0i8s8x7/db0hkjrksr5wJnFDwWMyk/OPcJFvbN1nUaj7b3/IX507pFmlyGlztM2Tze7hJp1Bc05/P6BG+JzGHW1DAstoGNZg3spJqeoVFqGK6iKaWu5U6lhoL2+144a6MhxTud6NifET2cAOzqSfs0tKX4evXGOfzpzmPt3Ja8BvKFJYSHJbIu1gPZlDavFmFzqsdKfb1dQFfPM/uRu1YqzeHw7SOn28m2VXeDjYd0rD9X91FnH61FOTdqBJ/bN8rqByi9WEhfN+p5L8verbbEW0L58z0Lzylih0kuMJvnDpfpxW3F9+IMg1V+ln7Ng1R7UOG0Pb0/w1nnbFdXzt6EFLD+LvdRhSI3+2Fe8Z8FPtdQwft6k+qv1Yxan5vmJcyHjVJPqx7DQApZvAVgs8TXV6JuJhRV+XbbisekqL443v0sDfxCk+qs0LKy+wEecbovld0VrcXm3gPYKTnBeavCOuUr3LLihU8XkWnDNaEQ7wXAu1V9bhYfwxPlb7sRGyDjXWErzzllI7verYaEFdHSD1m0AAB5+SURBVCxbQUuFgsUGr8OVbhn2sAgV4zkL9eHHTYqvODU1TzQe41ST6ic1N2ULstwLeCtwMTAAHAa+AFwWZhipYjzbgL8ELgHOBI4DXwX+MsxwIOq6G2F5g7tUKGj0llovnar18DCk+oj6viaSTlfxYUirnsfpa689wd8VSd7C3yypaIsFWe4L3Ag8D/g+cDmwB3gF8N0gS0W32y30993CcLsL4/l+Ybw3BlnOjb76+lueCEttkW34noUK+0vw95HqqBW/6htxvHIqfhCkmEtDWPC7orWkZc/CB4AdwMvDDP9w4sUgy7uBVwFvB15UwXj+GjgPuDzM8OfLxvNy4L2F6VwcYd0N0bH8BOcS91lo9K2YKr2Ds8dQqxjXivqwASDVXxo2gp0478Lv4taQ+N+Gwtb+JwB7gfev6vwWYAp4dpClt8x4eoFnF/p/y6rOVxTG/1tJ3LvQvuz/UqFgqcE3a6t4z0IavlUVudY8Z6H+HwY/blL9NeJcvPY6N+Pby/cSW7YrqpeGPQsXFh6vCTMr2xBhhokgy3fIh4lHAF9fYzyPBHoK41lxS8IwQy7Icg3wQuBx5A9xSozlxxZePdHDXfOnL/Z7FivLjS88tDWSmq4a7+H4UvlpHlxY+ZUU1fQr0chpqTqV7plSdSq9Souk2tV6GFI12oPSVz+MQqLDQotNNwppCAsPKDzeXqL7HeTDwnmsHRYqGQ+F8awpyHJjsdfDTP5xcHCw3Cgi1T/fBkP5//csdLBnofbF/pXJnkhqmg3bahpXVNOP27RUnR29XTDZ7Coaa3DLZjhYx/EPDrJzvi1/SYeUOPldW+pbXWqCHX0bT/4mr+XMjR0wc+r59i2b4VBl0zizC/bN1VZfJXZu7WewL2R7W5C/nEyC7OwKOD5Tvr+obe/uaHj7LyqJPwwJ6C88jpXofuL1LQ0aT+z8n/7QY/8VC7+yMcevb1rfQURXPWCBS89eOu31nZ3haVe5eGhvLlHr/p+dscTf36f4wYK/uTnkf39loWi3MztPf4+fP3+BD9y3srORnrk9Pz//dGeOjW21z68H9uR4/o7Tlw3A585f4Bd7Tl/2m9vrs3w+ed6p9/6Th85XNMzvDIQ8anN09fzOtsrX9d/akqO7zLzvWaN7T1vIm+9VfN5H4be3pv/gv6dUsbxqNdgR8twduZOfuYf25jhnw+nL9X7dIR+53xLbO/Ld3nL2Ihf2V75u/sf5izxmc/3ezwWb8rX81tbGfL9+/P4rv8seXeN7Cwj5+HlLPH9n/T4ryz288HvXEYS8v8Lv4zhKw56Fck7s+VnvGl3xeMIMF5TqBDA0VMEmhQjtBG67YJAbJgLGJyZK9pcDfjzbxbmdi+xd6CAH3K9rkQ1ByOHFds7pLL6ijy618cGRTWwIQh7WPc9P5jqZCwPO6ljirP+/vTuPk6uq8z7+OVW3lu5OurORkA0SQhDDkgiEJSHkBn2ijgvOGFBGEXQe53EExCWK4zLCuDwoIoqgM6+ZkXUUAQUEQZgxXBCBYZU1JCwBgRBC1k56qfXMH+dUulLe7lS2Xqq/79erX7fr3nPuUqeW+6uzpUoEwLR0kZfzAWODEpOD0k7dkBSt4dVikmm9HH9nrS4myRrLy4WAlLFMDNyHxthkmYI1rO7jWqstz6V4vDvF6GSZA9IufcEaJgUlEkB72bCsI8sj3WmmBEVmZws8lw8oWsOJLd28kA+YlSnyWHeKjLGc0JJjeS7FplKCmeki17U3MSmb4KSxZf7c3s3z+YAmYxmbLPNCIaC7bJgQlBgflBibLHPLlibWlRIsbukmMHBPZ4Y3iknAMjNdJGcNR2TzFDFsLCWYFJRYXUyyqZQggeWgTJGShf1TJSYEJZ7oTjMmWWZT2fBULsWUoMSrxSQjE5ZHutJMTxc5uinP1rJhVqbAuqJrJXt/V5pDMwXGB2WmpYrcvjXL7GyBmekixzXlMMATuTSr8knWFJMUgQc6M0wIShyeLfBqIckxTXkKFmakixgDD3ammZwqMS1V4iBbhHZ4/IAEyzoyLGjO8WoxYE42z+pCkjIwMSjxZC7NEdk8a4oJNpSSdFs4LFPgB+tH8nQuxZLWLp7NB+ybLPFELs2Xx7WTNpZLNoxkXlOOzrKhOWGZkS7SWTYsz6dYnkuRtzAlKHFAukjeGm7d0sTcpjwPdKU5uinPlKDEunQrs1ssj7zZQc4aWhKW8UGZX2xuZp9kiQMzRaanikwKStzflWFmusiIRJkjsgUMcNh+KaamimwoJXiyO83iEd1sWG+ZAkT7BzzWneL9I7v47dYmZmfzTEuVeKgrTRl3bnlrmFkuQhJm7BewqhDQbCwzM0Xu60zTkrCMTpbJW0PWWI5pylP5WHp4uuHx7jRtyTKHZwpc397EzVuamJwq8bdtnRT883jTliaOacozOVXi+s3NJI3llFb3c93CIMNj3Wn2CUqsKyZ598guDikXuWWy4alcQMa4z42NJcP7R3bzTD7guVyKk0Z2sTwfkMCN0GYMTEiW2VhKsKqQZFyyzCPdaeZk87w1U+TSDSMYnyxjgeOac8xMF/neupEsaskxj55rGgvcPS3Jw11pTm7t4rHuFOD6am0uGw7LFHi1GPCOya2UgWWvtTMtVeTOrVlmZQq0JcusLyWZnc2zMhcwPiizKh+Q859Nc7J5OsouLF3nm3SOD0ocmS3wtbYkbxYTGANtiTJ/7MwwOllmYlDioEyRJ7tTBAaOyObZOCbBG6UEaaA5Uaa9nODx7hTrS0lOH9VB3uJf44YV+YCJQYkkkDKW6akSY5Jljt8vxeRUiae6UxhjaTKWezoznNrayV2dWR7qSvO1ce2syAcY4Pl8wNymPKOSZVbkUkz0nyevFJMUrOEt6QIr8wFHZAu8PirJHVuzHNWUJ2UsRWtoSZT5yYYRfH7sFu7syPKOlhx/7ExjgaOaCvxmS5b3jOim2xp+tqmFtcUE72jJEXVmOL2tg46yYVamyKPdKZIGmv1nYYDl2vZmxiTL7BuUWVd0z0Vb0nJKaycJY/nimlEsae0iPaKVRzsMpruTBc05lnVk2FhOcMaoDnJlQ1uyTGfZ0GUTrC4keD6fYlxQ4m3ZAmuKCV4pBMxvznFwpsgnWlLc2N7MCS05usqGw7LuPX3TliYe6U5zbFOelwtJOsuGn29u4bBsgQXNOZa0drIil6IpUea5fIo7t2b55OitPJ1LMSdb4InuFLMyBQ7JFOjYaPn/o+DkbIpDMwWyBn7R3syjXSkWtOSYHJSYlSnSudFy9/6GF/MBc7IFNq6HlQcabmxvYlM5wTtbukkYu+0z4s1igms2N/ORtk4mdJW4cgI83pbmz4UkB2cKNPsyW9aZYWJQ2vY9+FCXy/9SPiBpLK8VkkxNlZieLvL7jiyHZwosHtHNqnySp3MpPjaqk/Xre77DVx5o+MXmZiYFJeZk89y0pZk/daeY15zjkEyBlwoBHWXD1KDE8c05Hs+lsRY6m0exOg9TC5t5S6bArVuamJPNMyEo82YxQWuyzP90ZXj/yC5GGMvv9w94o+iuZXyyzG9asqwpuu+LSUGJP3ZmSBiLtYZVhSSvFZLMbXLvzY+O6uCVQpKMgUldJb7ZBvMSWV4sBGwsJZjfnGN6qsivtzRxdFOe5/MBp7R2YYB/XNvGUdk8gX++pqeKvFZ031//OK6dO7a6/Uzy5Vay7v3fXk4wO+O+90cmyrRuLbOun2vEJ02atEf2Y+xgmj98F5iIC4GlwFIbclHM9kuBM4FP25Cf9rGfM3EdmS+1IWfHbF8KXAh8z4acu4unawFWr66zHnEPqlR99XegIrtH5TY0qdyGJpXb0KRyG5pUbntfVbCwW10mGqEZ0gq/7K0vwUy/3FGr1T21HxERERGRhtAIwcJdfrnYRNtfj4kYCczHdRF6YAf7ecCnm+/zVe8ngeskXX08EREREZGGNuSDBRvyAnAnMA3X3Kja+UALcJUN6aisNBEHm4iDa/azFbjapz+vZj9n+f3fYcOhNWyqiIiIiMiuapQOzp8G7gMuMRFvB5YDx+DmRFgJfLUm/XK/rG3D9RUgBD5vIuYADwJvBU4C1vKXwYiIiIiISMMa8jULsK124SjgClyQ8AVgBnAJcJwN6xs53Kc7zuc70O/nGOBy4Eh/HBERERGRYaFRahawIa8AH68zba+9wm3IBuAc/yciIiIiMmw1RM2CiIiIiIjseQoWREREREQkloIFERERERGJpWBBRERERERiKVgQEREREZFYChZERERERCSWggUREREREYmlYEFERERERGIpWBARERERkVgKFkREREREJJax1g70OQwnerJFREREpD+Z3cmsmgUREREREYkVDPQJDDO7Fdnt1oEjHgGwIUcO1DnIzlO5DU0qt6FJ5TY0qdyGJpXb0KGaBRERERERiaVgQUREREREYilYEBERERGRWAoWREREREQkloIFERERERGJpXkWREREREQklmoWREREREQkloIFERERERGJpWBBRERERERiKVgQEREREZFYChZERERERCSWggUREREREYmlYEFERERERGIFA30CsneZiCnAPwPvAsYCrwM3AefbkI0DeW6NwkQsARYCc4DZwEjgP23IR/vIMw/4GnAskAWeB34G/NiGlHrJ815gKfA2IAk8DfzEhlzZx3FOB84EZgEl4DHg+zbk1p28zIZjIsYCfw28BzgMmAzkgSeBy4HLbUg5Jp/KboCZiO8CRwEHAeOALuBl3GfbpTZkfUweldsgYyJOA67yDz9pQ/49Js1eLwMTkQTOBj4BzMS9nh4AvmVD7tu1q2scJuIlYP9eNr9hQ/aNyaP3WwPRpGwNzETMAO4DxgM3A88CRwOLgBXA/LgvVdk5JuJPuCBhK/AqcDB9BAsm4iTgV0A38EtgA/A+4C3ADTbk5Jg8ZwE/Btb7PHlgCTAFuMiGLI3J833gC/6cbgDSwIeBMcDZNuTSXb/qoc9EfAr4KS6Avgv4MzAB+BugDVdGJ9sQW5VHZTcImIg88CjwDLAWaMHdlBwFrAaOtSGvVKVXuQ0yJmIqLjBPAiOICRb6owxMhAGu8/tdAdzi034Id5P7QRty85656qHJBwujgB/GbN5qQ75fk17vtwajYKGBmYg7gMXAZ2zIj6vW/wD4HPCvNuRTA3V+jcJELMJ9WD2Pq2G4i16CBRPR6tO14YK1h/36LLAMOA441YZcW5VnGi7Q6wCOtCEv+fWjgYeAGcA8G3J/VZ55wB+BF4C5lVokv69HcDdXB1f2NRyZiBNxz8Nvq2sQTMS+wIPAVGCJDfmVX6+yGyRMRNaGdMes/zbwFeCnNuTTfp3KbZDxN+j/BUwHfo37NXm7YKG/ysBEnAr8HPfD2tsrrysTMRe4F9gMzLAhW/bw0zBk+GABGzKtjrR6vzUg9VloUCbiAFyg8BJwWc3mb+DelKeZiJZ+PrWGY0PusiHPVf8C3YclwD7AtZUPUb+PblyVLcA/1OT5BJDBNa94qSrPRuA7/mFt0Fd5/O3q5mY+/2V+fx+v43wblg1ZZkNuqW1qZEPWAP/iH4ZVm1R2g0RcoOBd55czq9ap3AafzwAn4p6Pjl7S9FcZVMr+a9WvKxvyEO4X7n1wryGpj95vDUjBQuM60S/vjLkZ2oKLyJtxVffSfyrl8ruYbfcAncA8E5GpM8/tNWl2J4/0KPhlsWqdym7we59fPlG1TuU2iJiItwIXAD+yIff0kXSvl4Ev83m418AfduI4w1HGRHzURHzFRJxjIhb5vh619H5rQAoWGtdb/HJlL9uf88uD+uFcpEev5WJDisAq3MADB9SZ53XcL3NTTEQzgK8tmoxrS/p6zDmo7PtgIgLgY/5h9ReRym6QMRFLTcR5JuJiE/EH4Ju4QOGCqmQqt0HCv7euxvUP+soOkvdHGRyI6zPxon8t1JNnuNoXV3bfxvVdWAY8ZyIW1qTT+60BKVhoXG1+ubmX7ZX1o/rhXKTHrpRLvXnaapYq+11zAXAocJsNuaNqvcpu8FmKa1b5WeB4XHC32Ia8WZVG5TZ4/BNupJszbEjXDtL2Rxmo3OpzOfB2XMDQghs97l+BacDtJmJ2VVq93xqQhk4dvoxfqof74LIr5bKrZamyr2EiPoMbXeNZ4LSdze6XKrt+Yv2QjSZiAq45yQXAYybivTbk0Tp3o3LrBybiaFxtwkXVHVV3Z5d+uTfLQN+TgA05v2bVU8CnTMRW3OflebhhqOuh99sQpJqFxlUbiddqrUkn/WNXyqXePO11pt/RrzLDkok4E/gRbjjORTZkQ00Sld0gZUPesCE34gZ1GEvP2P2gchtwVc2PVgJfrzNbf5SBvid3T2UgiBOq1un91oAULDSuFX7ZW5u9ymghvfVpkL2j13LxX6jTcZ1qX6wzz0RctfCrNqQTwIZ0AK8BI/z2Wir7Gibis8CluF/MFvkRkWqp7AY5G/IyLtg7xESM86tVbgNvBO65fCvQbSJs5Q/XjAzg3/y6ylj+/VEGz+Mm8jrAvxbqySM91vpl9aiKer81IAULjesuv1xsou3L2USMBObTM0ul9J9lfvmumG0n4Eaous+G5OrM8+6aNLuTZ1gyEecCFwN/wgUKa3tJqrIbGib5ZckvVW4DLwf8Ry9/j/k09/rHlSZKe70MfJnfh3sNLNiJ44hznF9W3/jr/daAFCw0KBvyAnAnrgPSmTWbz8dF6lf5CF36zw3AOuDDJuKoyko/Yc23/MOf1uS5HPdle5afcKaSZzQ9I4r8S02eyuOv+nSVPNNwr4ec3++wZiK+jmvn/ghuQqZ1fSRX2Q0CJuJg4ybOq12fMG5StvG4m5HK2OsqtwFmQ7psyP+N+wN+45Nd6df90j/urzKolP23/GuikmcubhbnN3GzEQ9LJuIQEzEmZv3+sG2G5GuqNun91oA0g3MDMxEzcL+ajAduBpYDxwCLcNVz82zI+oE7w8ZgIj4AfMA/3Bd4J+6Xlsq43ets1VT1Pv0NQDdwLbABeD9u+LgbgFNqJ3gzEWcDlwDrcRMF5XGT30zBdRhcSg0TcRHwedzs0jcAadyX31jgbBtu+6AflkzE6cAVuF+gf0x8+9aXbMgVVXlUdgPMNxm7EDdm+wu453UCbvb0A4A1uMDvmao8KrdBykSch2uKtN0Mzn7bXi8D42aTvs7v91ngFp/2Q0AW+KANuXkPXe6Q48vny7jWCquALbgZld+De35uA/7ahuSr8uj91mAULDQ4EzEV+GdcVd1Y4HXgJuD8mA6csguqvux687INe34t8XnmA1/FVeNmcW1nfwZcYsNtzSdqj/M+3FCRR+BqBZ/BzXh5ZR/ndjpwFjALKAOPAhfakFvrubZGVke5Adxtw+1mcVbZDTATcShuBtj5uBuJUbhx2FcCv8WVw198tqncBqe+ggW/fa+XgW9LfzZuJuEDcTe59wPfsiH37fLFNQA/j8KncEPeVoZO3YRrtnk1cHXtjb/Pp/dbA1GwICIiIiIisdRnQUREREREYilYEBERERGRWAoWREREREQkloIFERERERGJpWBBRERERERiKVgQEREREZFYChZERERERCSWggUREREREYmlYEFERERERGIpWBARERERkVgKFkREREREJJaCBRER2Skm4gwTYU1ENNDnsiMmIvLnesZAn4uIyFAUDPQJiIjIrjERVwCn15n8czbkh3vxdGQHTMTFwGeBU2zI9X7dfOBe4Oc25CMDeX4iInEULIiIDH0FYMMO0nTsweNtBlYAf96D+xwOjvfLP8Ssu7efz0VEpC4KFkREhr77bEjYXwezITcCN/bX8RqBiWgB5gDP25A1VZsW+KWCBREZlNRnQUREZO87FvcD3bZaBRORAOYDm4CnBui8RET6pJoFEZFhyHdOXgh8HLgZ+CfgJGASsA64DfiGDXk9Ju8ZwOXA3bU1GiYiDfwD8CFgFtCCayK1Bvfr+TU25P6YfU4AvgS8B9gP17RqBfBL4FIbkuvjWt7l8x4JGOAZ4DIbcnUdz0Ma+Ht/vof4810D/B640IYs39E+6hTXBOlQYBRwmw2xe+g4IiJ7lIIFEZHhbSzwEDAD6AKKwGTgk8AHTMTCem+YTUQA3IkLQgAsrn/DWGA8cLj///6afEcDtwNj/KotQBqY6/9OMxGLbcjamGN+EfhezfHmAleZiDk7ON+J/riz/aoyrm/Hfrgg6lQT8REb8ut6rr9m3/cCU6pWjfPL75iIb/j/m/1ygYl4qSrth23IAzt7TBGRvUHNkEREhrevAyOB9wEjbMgIIARWAfsA15uIVJ37+ltcoNAJnAY025DRQAbYHzgLeLw6g4kYDdyECxSeBI62Ia3ACOBkYCPuZv4/aw9mIo4HvusfXgNM8scbiwsgPg/xAYO/ppv9vu8BTgCa/LH3BS4CssDVJmJGnddfbYq/5spfi1+/b9W6ffy6kTVps7twPBGRvUI1CyIiQ988E23XaTbOQTakPWZ9K7DQhj3NY2zI3Sbi3cATuKY5H8LdjO/IsX55lQ170tuQEm7kpMti8pwFTMS1219c6fzr89xgItqBO4B3mIgTbciyqrzn45od3QV8rNKUx4ZsAs41EWOBv+vlXE/H1UA85I+7rZmTDXkDWGoimnFNqj7nz7NuNmRa5X8TcQzwAPArG7Kkav1qYDTQZkPyO7N/EZH+opoFEZGhLwVM2MFfb5/3f6gOFCpsyArgBv9wSe32XlSCkYl1pq/e97/XjBJUOY876Wm2dEplvYkYAyzyD7/bS5v/7/Rx3Mr8FJf10R/i5375f/rYTz1O8Mvqzs0zcM/T/yhQEJHBTDULIiJD3190NN4JUV/7xTUtOqLOfd0OnAucZCJ+A1zhz219XGLfufhQ//CuPva7DDiu5jzehqtVKNPLsKM25EUT8Qowtea4AXC0f/gDE21rylQr6ZdTe9ler8rwqPfErNOQqSIyqKlmQURkeHutjm379JFmGxtyN25UpSKuD8SvgHUmYrmJ+L6JmFmTZQw930N9ncerMedR+X+zDfuccC5uv2NwHagr//dWG1PplNzUx/77ZCIMbnjUdlyzroq40ZFERAYd1SyIiEhvzM5msCHfNBHX4Po5hLgagYP93zkm4u9syFUxWTO7c6J9iLuG6h/KZttwu5v43TtYxDzYbvQkgwtIisBrJtq2frRfXmMiSv7/V2zI3D11LiIie4JqFkREhrdJfWyr9D14c2d2aENW2ZALbMi7YFvfgntwP1D9xESM90k34JoRgRsFqDeVIUirz6Pyf5vviNybuP4T62HbDfqsPvLuijTb105UrjWoWV+p2RhXta6uGhwRkf6kYEFEZHhbWMe2R3d15zakZEMi4L24idZagKP8tjw9Mxcvit2Bc2LMeTyGm1chQU+Tnu2YiOm4ORNqz6kAPOwf/k0911EvGxLZEFP5o2fI1wVV6yqdun9UnbZ6BCURkcFCwYKIyPC20Ded2Y7vX1C5qb2+nh35Dsu9ydPza351k6PKiEtn+EnSave5GNeUCeC6ynobsgG2DaP6Jd83oNaX+zifK/zygybqM1CpzAWxqxYA3bghWisqoyPd85fJRUQGFwULIiLDWzvwaxPxV5UbbhOxADeyUQZ4mqqb9B24ykRcbiLeaSJGVlaaiGnAlbjJxrrYvlPvpcDruE7EvzORq3UwEUkT8UHgWp/uv2vmWAA4D1e78HbgChMxwedtMxHfAf4eYueWAPgP3NwHCeBWE3GOH461cs7jTcSpJiICzqnz+rfjr3s/4MGa4VkX+PNW52YRGfTUwVlEZOirZ1K2X9ow9qb3m7iJx34LdPnOtiP8tjeBU3yznXpkcR2bzwCsidiMa5tf6VNQAv6fDVlXyWBDNpqIDwC/Aw4HHjIRW3BzR1RmMn4C+EjtwWzIvSbiXNxszR8DTjMRm3ATzSWBHwBHEtPUyoYUTMRJuM7I84EfAhf7/Kmq5wD6Hta1L5XjVs+v0IqbNXq5DXeuL4iIyEBQzYKIyNBXz6Rsbb3kXY+byfiHwBu4m/vVwL8Bc2zIMztxHl8GvoS78X/R7ysJvABcDhxhQ66uzWRDHsR1NL4YWOmvp4jrV/BF4BgbsjbugDbkQuDduBv6rbgfwR7Gzej8hb5O1u9zIS4QuQ1YiwsSDPAsrvbhr+h7cre+xDU3mo/77lUTJBEZEoy1cZNeiohII/PNaxYCH7fhtvb7IiIi21HNgoiIiIiIxFKwICIiIiIisRQsiIiIiIhILAULIiIiIiISSx2cRUREREQklmoWREREREQkloIFERERERGJpWBBRERERERiKVgQEREREZFYChZERERERCSWggUREREREYmlYEFERERERGIpWBARERERkVgKFkREREREJJaCBRERERERiaVgQUREREREYilYEBERERGRWAoWREREREQk1v8CvFfLdaXsAA4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7ff5a66e0b00>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 266,
       "width": 389
      },
      "needs_background": "dark"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Launch training\n",
    "scores = train()\n",
    "plot_training(scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.close()"
   ]
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}