Navigation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Navigation\n",
    "\n",
    "---\n",
    "\n",
    "In this notebook, you will learn how to use the Unity ML-Agents environment for the first project of the [Deep Reinforcement Learning Nanodegree](https://www.udacity.com/course/deep-reinforcement-learning-nanodegree--nd893).\n",
    "\n",
    "### 1. Start the Environment\n",
    "\n",
    "We begin by importing some necessary packages.  If the code cell below returns an error, please revisit the project instructions to double-check that you have installed [Unity ML-Agents](https://github.com/Unity-Technologies/ml-agents/blob/master/docs/Installation.md) and [NumPy](http://www.numpy.org/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from unityagents import UnityEnvironment\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will start the environment!  **_Before running the code cell below_**, change the `file_name` parameter to match the location of the Unity environment that you downloaded.\n",
    "\n",
    "- **Mac**: `\"path/to/Banana.app\"`\n",
    "- **Windows** (x86): `\"path/to/Banana_Windows_x86/Banana.exe\"`\n",
    "- **Windows** (x86_64): `\"path/to/Banana_Windows_x86_64/Banana.exe\"`\n",
    "- **Linux** (x86): `\"path/to/Banana_Linux/Banana.x86\"`\n",
    "- **Linux** (x86_64): `\"path/to/Banana_Linux/Banana.x86_64\"`\n",
    "- **Linux** (x86, headless): `\"path/to/Banana_Linux_NoVis/Banana.x86\"`\n",
    "- **Linux** (x86_64, headless): `\"path/to/Banana_Linux_NoVis/Banana.x86_64\"`\n",
    "\n",
    "For instance, if you are using a Mac, then you downloaded `Banana.app`.  If this file is in the same folder as the notebook, then the line below should appear as follows:\n",
    "```\n",
    "env = UnityEnvironment(file_name=\"Banana.app\")\n",
    "```"
   ]
  },
  {
   "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: BananaBrain\n",
      "        Number of Visual Observations (per agent): 0\n",
      "        Vector Observation space type: continuous\n",
      "        Vector Observation space size (per agent): 37\n",
      "        Number of stacked Vector Observation: 1\n",
      "        Vector Action space type: discrete\n",
      "        Vector Action space size (per agent): 4\n",
      "        Vector Action descriptions: , , , \n"
     ]
    }
   ],
   "source": [
    "env = UnityEnvironment(file_name=\"./Banana_Linux/Banana.x86_64\")\n",
    "\n"
   ]
  },
  {
   "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",
    "The simulation contains a single agent that navigates a large environment.  At each time step, it has four actions at its disposal:\n",
    "- `0` - walk forward \n",
    "- `1` - walk backward\n",
    "- `2` - turn left\n",
    "- `3` - turn right\n",
    "\n",
    "The state space has `37` dimensions and contains the agent's velocity, along with ray-based perception of objects around agent's forward direction.  A reward of `+1` is provided for collecting a yellow banana, and a reward of `-1` is provided for collecting a blue banana. \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: 1\n",
      "Number of actions: 4\n",
      "States look like: [1.         0.         0.         0.         0.84408134 0.\n",
      " 0.         1.         0.         0.0748472  0.         1.\n",
      " 0.         0.         0.25755    1.         0.         0.\n",
      " 0.         0.74177343 0.         1.         0.         0.\n",
      " 0.25854847 0.         0.         1.         0.         0.09355672\n",
      " 0.         1.         0.         0.         0.31969345 0.\n",
      " 0.        ]\n",
      "States have length: 37\n"
     ]
    }
   ],
   "source": [
    "# reset the environment\n",
    "env_info = env.reset(train_mode=True)[brain_name]\n",
    "\n",
    "# number of agents in the environment\n",
    "print('Number of agents:', len(env_info.agents))\n",
    "\n",
    "# number of actions\n",
    "action_size = brain.vector_action_space_size\n",
    "print('Number of actions:', action_size)\n",
    "\n",
    "# examine the state space \n",
    "state = env_info.vector_observations[0]\n",
    "print('States look like:', state)\n",
    "state_size = len(state)\n",
    "print('States have length:', state_size)"
   ]
  },
  {
   "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",
    "Once this cell is executed, you will watch the agent's performance, if it selects an action (uniformly) at random with each time step.  A window should pop up that allows you to observe the agent, as it moves through the environment.  \n",
    "\n",
    "Of course, as part of the project, you'll have to change the code so that the agent is able to use its experience to gradually choose better actions when interacting with the environment!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score: 0.0\n"
     ]
    }
   ],
   "source": [
    "env_info = env.reset(train_mode=False)[brain_name]  # reset the environment\n",
    "state = env_info.vector_observations[0]  # get the current state\n",
    "score = 0  # initialize the score\n",
    "while True:\n",
    "    action = np.random.randint(action_size)  # select an action\n",
    "    env_info = env.step(action)[brain_name]  # send the action to the environment\n",
    "    next_state = env_info.vector_observations[0]  # get the next state\n",
    "    reward = env_info.rewards[0]  # get the reward\n",
    "    done = env_info.local_done[0]  # see if episode has finished\n",
    "    score += reward  # update the score\n",
    "    state = next_state  # roll over the state to next time step\n",
    "    if done:  # exit loop if episode finished\n",
    "        break\n",
    "\n",
    "print(\"Score: {}\".format(score))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When finished, you can close the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "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!  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",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QNetwork(\n",
      "  (layers): ModuleList(\n",
      "    (0): Linear(in_features=37, out_features=70, bias=True)\n",
      "    (1): Linear(in_features=70, out_features=64, bias=True)\n",
      "    (2): Linear(in_features=64, out_features=4, bias=True)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "from agent import Agent\n",
    "import torch\n",
    "from collections import deque\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "\n",
    "# create the agent\n",
    "agent = Agent(state_size, action_size, hidden_sizes=[70, 64],\n",
    "                   gamma=0.992, lr=0.0005, tau=0.002,\n",
    "                   buffer_size=100000, batch_size=64, update_rate=10,\n",
    "                   seed=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Train the trained agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "is_executing": true,
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 10:\n",
      "            Epsilon: 0.951\n",
      "            Average Score: 0.20\n",
      "            \n",
      "Episode 20:\n",
      "            Epsilon: 0.905\n",
      "            Average Score: 0.05\n",
      "            \n",
      "Episode 30:\n",
      "            Epsilon: 0.860\n",
      "            Average Score: 0.03\n",
      "            \n",
      "Episode 40:\n",
      "            Epsilon: 0.818\n",
      "            Average Score: 0.10\n",
      "            \n",
      "Episode 50:\n",
      "            Epsilon: 0.778\n",
      "            Average Score: 0.10\n",
      "            \n",
      "Episode 60:\n",
      "            Epsilon: 0.740\n",
      "            Average Score: 0.07\n",
      "            \n",
      "Episode 70:\n",
      "            Epsilon: 0.704\n",
      "            Average Score: 0.26\n",
      "            \n",
      "Episode 80:\n",
      "            Epsilon: 0.670\n",
      "            Average Score: 0.36\n",
      "            \n",
      "Episode 90:\n",
      "            Epsilon: 0.637\n",
      "            Average Score: 0.36\n",
      "            \n",
      "Episode 100:\n",
      "            Epsilon: 0.606\n",
      "            Average Score: 0.58\n",
      "            \n",
      "Episode 110:\n",
      "            Epsilon: 0.576\n",
      "            Average Score: 0.83\n",
      "            \n",
      "Episode 120:\n",
      "            Epsilon: 0.548\n",
      "            Average Score: 1.08\n",
      "            \n",
      "Episode 130:\n",
      "            Epsilon: 0.521\n",
      "            Average Score: 1.48\n",
      "            \n",
      "Episode 140:\n",
      "            Epsilon: 0.496\n",
      "            Average Score: 1.84\n",
      "            \n",
      "Episode 150:\n",
      "            Epsilon: 0.471\n",
      "            Average Score: 2.26\n",
      "            \n",
      "Episode 160:\n",
      "            Epsilon: 0.448\n",
      "            Average Score: 2.70\n",
      "            \n",
      "Episode 170:\n",
      "            Epsilon: 0.427\n",
      "            Average Score: 3.03\n",
      "            \n",
      "Episode 180:\n",
      "            Epsilon: 0.406\n",
      "            Average Score: 3.39\n",
      "            \n",
      "Episode 190:\n",
      "            Epsilon: 0.386\n",
      "            Average Score: 3.81\n",
      "            \n",
      "Episode 200:\n",
      "            Epsilon: 0.367\n",
      "            Average Score: 4.31\n",
      "            \n",
      "Episode 210:\n",
      "            Epsilon: 0.349\n",
      "            Average Score: 4.71\n",
      "            \n",
      "Episode 220:\n",
      "            Epsilon: 0.332\n",
      "            Average Score: 5.05\n",
      "            \n",
      "Episode 230:\n",
      "            Epsilon: 0.316\n",
      "            Average Score: 5.26\n",
      "            \n",
      "Episode 240:\n",
      "            Epsilon: 0.300\n",
      "            Average Score: 5.45\n",
      "            \n",
      "Episode 250:\n",
      "            Epsilon: 0.286\n",
      "            Average Score: 5.57\n",
      "            \n",
      "Episode 260:\n",
      "            Epsilon: 0.272\n",
      "            Average Score: 6.03\n",
      "            \n",
      "Episode 270:\n",
      "            Epsilon: 0.258\n",
      "            Average Score: 6.37\n",
      "            \n",
      "Episode 280:\n",
      "            Epsilon: 0.246\n",
      "            Average Score: 6.62\n",
      "            \n",
      "Episode 290:\n",
      "            Epsilon: 0.234\n",
      "            Average Score: 6.86\n",
      "            \n",
      "Episode 300:\n",
      "            Epsilon: 0.222\n",
      "            Average Score: 7.04\n",
      "            \n",
      "Episode 310:\n",
      "            Epsilon: 0.211\n",
      "            Average Score: 7.39\n",
      "            \n",
      "Episode 320:\n",
      "            Epsilon: 0.201\n",
      "            Average Score: 7.85\n",
      "            \n",
      "Episode 330:\n",
      "            Epsilon: 0.191\n",
      "            Average Score: 8.14\n",
      "            \n",
      "Episode 340:\n",
      "            Epsilon: 0.182\n",
      "            Average Score: 8.38\n",
      "            \n",
      "Episode 350:\n",
      "            Epsilon: 0.173\n",
      "            Average Score: 8.82\n",
      "            \n",
      "Episode 360:\n",
      "            Epsilon: 0.165\n",
      "            Average Score: 8.78\n",
      "            \n",
      "Episode 370:\n",
      "            Epsilon: 0.157\n",
      "            Average Score: 8.86\n",
      "            \n",
      "Episode 380:\n",
      "            Epsilon: 0.149\n",
      "            Average Score: 9.16\n",
      "            \n",
      "Episode 390:\n",
      "            Epsilon: 0.142\n",
      "            Average Score: 9.64\n",
      "            \n",
      "Episode 400:\n",
      "            Epsilon: 0.135\n",
      "            Average Score: 9.94\n",
      "            \n",
      "Episode 410:\n",
      "            Epsilon: 0.128\n",
      "            Average Score: 10.09\n",
      "            \n",
      "Episode 420:\n",
      "            Epsilon: 0.010\n",
      "            Average Score: 10.24\n",
      "            \n",
      "Episode 430:\n",
      "            Epsilon: 0.010\n",
      "            Average Score: 10.24\n",
      "            \n",
      "Episode 440:\n",
      "            Epsilon: 0.010\n",
      "            Average Score: 10.34\n",
      "            \n",
      "Episode 450:\n",
      "            Epsilon: 0.010\n",
      "            Average Score: 10.64\n",
      "            \n",
      "Episode 460:\n",
      "            Epsilon: 0.010\n",
      "            Average Score: 11.02\n",
      "            \n",
      "Episode 470:\n",
      "            Epsilon: 0.010\n",
      "            Average Score: 11.10\n",
      "            \n",
      "Episode 480:\n",
      "            Epsilon: 0.010\n",
      "            Average Score: 11.42\n",
      "            \n",
      "Episode 490:\n",
      "            Epsilon: 0.010\n",
      "            Average Score: 11.51\n",
      "            \n",
      "Episode 500:\n",
      "            Epsilon: 0.010\n",
      "            Average Score: 11.64\n",
      "            \n",
      "Episode 510:\n",
      "            Epsilon: 0.010\n",
      "            Average Score: 12.01\n",
      "            \n",
      "Episode 520:\n",
      "            Epsilon: 0.010\n",
      "            Average Score: 12.38\n",
      "            \n",
      "\n",
      "Environment solved in 527 episodes!\tAverage Score: 13.06\n"
     ]
    }
   ],
   "source": [
    "def train_agent(env: UnityEnvironment, brain_name: str, agent: Agent, n_episodes: int,\n",
    "                eps_start=1.0, eps_cutoff: int = 2000, eps_end=0.01, eps_decay=0.995) -> []:\n",
    "    \"\"\"\n",
    "    Trans the agent for n episodes\n",
    "    :param env:\n",
    "    :param brain_name:\n",
    "    :param agent:\n",
    "    :param n_episodes: number of episodes to train\n",
    "    :param eps_start: epsilon start value\n",
    "    :param eps_cutoff: after x episodes, immediately decrease epsilon to eps_end\n",
    "    :param eps_end: epsilon decay per episode\n",
    "    :param eps_decay: minimum value for epsilon (never stop exploring)\n",
    "    :return: returns an array containing the score of every episode\n",
    "    \"\"\"\n",
    "    scores: [int] = []\n",
    "    eps = eps_start\n",
    "    # store the last 100 scores into a queue to check if the agent reached the goal\n",
    "    scores_window = deque(maxlen=100)\n",
    "\n",
    "    for i_episode in range(1, n_episodes + 1):\n",
    "        # reset the environment\n",
    "        env_info = env.reset(train_mode=True)[brain_name]\n",
    "        state = env_info.vector_observations[0]\n",
    "        score = 0\n",
    "\n",
    "        # the environment will end the episode after n steps, thus no manual termination of the episode is needed\n",
    "        while True:\n",
    "            action: int = agent.act(state, eps)\n",
    "            env_info = env.step(action)[brain_name]\n",
    "            next_state = env_info.vector_observations[0]\n",
    "            reward = env_info.rewards[0]\n",
    "            done = env_info.local_done[0]\n",
    "            score += reward\n",
    "\n",
    "            agent.step(state, action, reward, next_state, done)\n",
    "\n",
    "            state = next_state\n",
    "            if done:\n",
    "                break\n",
    "\n",
    "        scores_window.append(score)  # save most recent score\n",
    "        scores.append(score)  # save most recent score\n",
    "\n",
    "        if i_episode >= eps_cutoff:\n",
    "            eps = eps_end\n",
    "        else:\n",
    "            eps = max(eps_end, eps_decay * eps)  # decrease epsilon\n",
    "\n",
    "        if i_episode % 10 == 0:\n",
    "            print(f\"\"\"Episode {i_episode}:\n",
    "            Epsilon: {eps:.3f}\n",
    "            Average Score: {np.mean(scores_window):.2f}\n",
    "            \"\"\")\n",
    "\n",
    "        if np.mean(scores_window) >= 13.0:\n",
    "            print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode,\n",
    "                                                                                         np.mean(scores_window)))\n",
    "            torch.save(agent.local_network.state_dict(), 'checkpoint.pth')\n",
    "            break\n",
    "    return scores\n",
    "\n",
    "\n",
    "\n",
    "scores = train_agent(env, brain_name, agent, n_episodes=1000,\n",
    "                             eps_start=1, eps_decay=0.995, eps_cutoff=420, eps_end=0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Watch the trained agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "is_executing": true,
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent achieved a score of 17.0\n"
     ]
    }
   ],
   "source": [
    "def watch_agent(env: UnityEnvironment, brain_name: str, agent: Agent) -> None:\n",
    "    \"\"\"\n",
    "    Shows agent simulation\n",
    "    :param env:\n",
    "    :param brain_name:\n",
    "    :param agent:\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    env_info = env.reset(train_mode=False)[brain_name]  # reset the environment\n",
    "    state = env_info.vector_observations[0]  # get the current state\n",
    "    score = 0  # initialize the score\n",
    "\n",
    "    while True:\n",
    "        action = agent.act(state, epsilon=0.05)\n",
    "        env_info = env.step(action)[brain_name]  # send the action to the environment\n",
    "        next_state = env_info.vector_observations[0]  # get the next state\n",
    "        reward = env_info.rewards[0]  # get the reward\n",
    "        done = env_info.local_done[0]  # see if episode has finished\n",
    "        score += reward  # update the score\n",
    "        state = next_state  # roll over the state to next time step\n",
    "        if done:  # exit loop if episode finished\n",
    "            break\n",
    "    print(f\"Agent achieved a score of {score}\")\n",
    "\n",
    "\n",
    "watch_agent(env, brain_name, agent)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot the scores of the agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "is_executing": true,
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAs8AAAFNCAYAAAD/4oL5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAACLo0lEQVR4nO2dd5gb5dX27yNtL67r3nsFG2xMB4PB9EA+egkkIQESQkJC3lCTQELekLyU9NBDJ5DQe7fB2Ni4997rrtt6+6o83x8zI41GM6PRrrRaae/fdflaacozZ7Tr0T1n7uccUUqBEEIIIYQQkhhfpgMghBBCCCEkW6B4JoQQQgghxCMUz4QQQgghhHiE4pkQQgghhBCPUDwTQgghhBDiEYpnQgghhBBCPELxTAghhGQpInKiiKzJdBztGREpFJGVItInyf3eE5FrWnjMu0XkuZbsmyn0z2m1iPTIdCztHYpn0i4Qkc0i0iAitSKyW0SeEpGyTMdFCCGtQb+2NYtIhWX5IhFRIjK4NeMrpb5QSo1qVZAJ0K/HwWTFZzviOgCfK6V2JbOTUuospdTTaYopbVi+T2tF5EPL+p/q37OHRORJESkEAKVUE4AnAdyWibizCYpn0p44TylVBmAigCMA3J7ZcFqHiORlOgZCSLtgE4DLjTcichiAksyF4x0RKQVwIYBqAFelYXwRkXRrkRsAPJvmY7Q3zlNKlen/phsLReQMaOJ4GoBBAIYCuMe03wsArjEENbGH4pm0O5RSuwF8AE1EAwBE5DYR2SAiNfrjt2+a1m0RkUn66yv1bM44/f21IvK63XFE5Gx9rBoR2SEiPzetO19EFut35htE5Ex9eV8ReVNE9ovIehH5vmmfu0XkvyLynIgcAvBtEeksIk+IyC79GPeKiF/ffriIzBSRahHZKyIvpfBjJIS0H54FcLXp/TUAnjFvoF8rnhGRKv2adpeI+PRH6QdFZLxp2x56ZrGniEwVke2mdZtF5OcislS/trwkIkWm9b/Qr0c7ReR7+vVyuEvsFwI4COA3etzGOKtE5FzT+zw99iP198eIyGw99iUiMtW07QwR+Z2IfAmgHsBQEfmOPmaNiGwUkestn49j3PpndL+IbBWRPSLysIgU6+sGQhOIc/X3Q/SYfPr7x0Sk0nScZ0XkZlOc39Nff1tEZunHOSAim0TkLNN+Q/TreY2IfATA+qThGyKyQj/2DBEZoy//joi8ZdpunYj8x/R+m4hMdPn9JMs1AJ5QSq1QSh0A8FsA3zZWKqW2AzgA4JgUHjPnoHgm7Q4R6Q/gLADrTYs3ADgRQGdod8nPSfQR4kwAU/XXJwPYCOAk0/uZDod6AsD1SqlyAOMBfKoffwq0L7b/AdBFH2uzvs+/AWwH0BfARQD+V0RONY15PoD/6vs9D+ApAEEAw6Fl06cD+J6+7W8BfAigK4D+AP7q9JkQQrKarwB0EpEx+s3zZQCsfti/Qru+DYV23boawHf0R+mvwpS5BnAJgJlKqUrYcwmAMwEMAXA4dHGkJwF+BuA0aNekqR5ivwbAi9CufaNFT1Toy8wxnQFgr1JqoYj0A/AOgHsBdAPwcwCvSKyX9lvQ7BTlALYAqARwLoBOAL4D4CGTEE8U930ARkJLuAwH0A/Ar/R1hwHYqJQKAoBSahOAQ9Cux4B2fa81xCzcvzOOBrAGmjD+I4AnRET0dS8AWKCv+y1ibzRG6p/XzQB6AHgXwFsiUqAf60T9RqkvgAIAx+r7DQVQBmCp/n6pLr7t/v3DEuvz+s3MhyIywbR8HIAlpvdLAPQSke6mZasAmPchFiieSXvidRGpAbAN2oX018YKpdR/lFI7lVJhpdRLANYBmKKvngntggdoAvv3pvduF8IAgLEi0kkpdUAptVBffi2AJ5VSH+nH26GUWi0iAwAcD+BWpVSjUmoxgMcRm1Gao5R6XSkVhvYlcDaAm5VSdfoX3UPQvjiN4w8C0Fcfb1ZyHxchJIswss+nQxMnO4wVJkF9u1KqRim1GcAD0AQmoAmzy0xjXaEvc+Iv+vVyP4C3EH2KdwmAf+lZx3oAd7sFrGdtTwHwglJqD4BPEL3evQDgGyJi2E+ugCYQAc3e8a5S6l39GvoRgPnQrocGT+lxBJVSAaXUO0qpDUpjJrTEwomJ4tbF63UAfqqU2q+UqgHwv6bPqwuAGsupzQRwsoj01t//V38/BNp1ewns2aKUekwpFQLwNIA+0ITnQABHAfilUqpJKfU5tM/d4FIA7+jfKQEA9wMoBnCcUmqjHt9EaEL+AwA7RWQ0tO+vL/TvEyilDldKdXH490PT8a4EMBja98tnAD4QkS76ujJoFhwD43W5aVmN/rkRByieSXviAj0LPBXAaJgee4nI1aLZKA6KyEFomWJjvXHn3geAH8DLAI4XbSJOZwCLHY53IbSL+Rb9cdux+vIB0DLdVvoCMC7OBlugZTkMtpleDwKQD2CXKe5HAPTU1/8CgACYpz/O+65DnISQ7OdZaALz27BYNqBdy/KhXU8MzNeWzwCUiMjR+nVtIoDXXI612/S6HppgArRrmPkaZX5tx7cArNITBYD2NO0KEclXSq2HdhNwni6gv4GooB8E4GJzZhTACdDEpu2xReQsEflKNEvcQWjXZuMa7xZ3D2j+8QWmY72vLwc0C4JZGALRp5UnAfgcwAxoQjVGrNoQ+Vx1EQ9on21fAAeUUnWmbc2/y77m9/r42xD9/ZrjmWmJxyn544hS6kulVINSql4p9XtothvjRqQW2g2CgfHa/L1Wru9DHKB4Ju0OPevwFLS7c4jIIACPAfgRgO5KqS4AlkMTntAv4vUAboI2o/oQtIvcdQBmOV0IlVJfK6XOhyZmX4cmugHtojbMZpedALqJiPlCPBCmDBIAZXq9DUATgApTdqCTUmqcfvzdSqnvK6X6ArgewD/E3XtICMlSlFJboE0cPBuaDcPMXkSfRBlEri16pvNlaDaJywG8bbmJ98ouaBYxgwEJtr8amh95t4jsBvAgNEFrZJAN68b5AFbq12JAu/Y9a8mMliql7jONHblWijY57RVo1/xe+jX+XejX+ARx7wXQAGCc6Vid9cnngGZ5GCKxE7hnQhOTU/XXs6A9VWyRWNXj6yra5EqDgabXO2H63erZ8gGIfncY4vlE/bXxNDUmHj3JUuvw72GX+BSin+UKxFoyJgDYo5TaZ1o2Bs7ZdwKKZ9J++ROA03WvVim0//xVgDbBAlrm2cxMaOLauNDMsLyPQUQKRJtc2Fl/jHYIgCGynwDwHRGZpvvQ+onIaKXUNgCzAfxeRIpE5HBoFg/bWp56WaQPATwgIp30sYaJyMl6DBfr/m5Ay44oUwyEkNzjWgCnWjKUZnH8OxEp1xMGP0PsteUFaI//r4S7ZcONl6Fd28bo2eJfOm2oP4kbBs0eN1H/N14/tmHd+De0eRw/sMT0HLSM9Bki4tevl1NN1zsrBQAKoV3jg6JNxJtuWu8Yt54ceQyaR7qnHns/0apKGBPg1iNq84NSah00wX0VNO/4IQB7oD2NbEmmdws0W8o9+nfLCQDOs8R/jv6dkg/gFmiJldn6+pnQ7DHFerxfQPOsdwewyHSccSpaQcP67wb93AeKyPF6HEUi8j/Qbni+1Id5BsC1IjJWt3LcBS1ZBeOzg+ZT/yrZz6EjQfFM2iVKqSpo/8l/pZRaCc3/NwfaBe4wRC8EBjOhPWr63OG9Hd8CsFm0yhg3QPtSglJqHvQJK9D8YDMRzRpcDs1LthPaY9NfK6U+djnG1dC+GFZCE8j/RfTR5VEA5opILYA3AfxE978RQnIQ3dM732H1TQDqoE14ngVNjD5p2neuvr4vgPdaePz3APwFmg1kPaICqclm82sAvKGUWqY/JduttEpIfwZwroh00xMEcwAcByBSLUhPNJwP4A5ogngbtAnYtppDz6L/GJrIPADN3vJmEnHfaizXr+cfAzDXvn4EUf+4wUwA+/RYjfcCYCFaxhXQJhTuhzZfJ2LNUUqtgSbU/wotU34etFJyzfr6tdDsFF/o7w9B+zv4Ur+xSoZyAP+E9jnugCbCzzIyy0qp96FNdvwMwFZodpJfm/a/AsDTSpuoShwQpVTirQghhBCSU4hWYWI5gEKlV6PIBpKNW7eFLAIwTSXZKKUjoX9OSwCcpJwruRBQPBNCCCEdBtFq5L8LbZLd0wDCSqkLMhqUB7I1bpKb0LZBCCGEdByuh1YKdAOAEDS/cjaQrXGTHISZZ0IIIYQQQjzCzDMhhBBCCCEeoXgmhBBCCCHEI3mJN2k/VFRUqMGDB2c6DEIISZoFCxbsVUr1SLxl7sBrNiEkm3G6bmeVeB48eDDmz3cqkUkIIe0XEdmSeKvcgtdsQkg243Tdpm2DEEIIIYQQj1A8E0IIIYQQ4hGKZ0IIIYQQQjxC8UwIIYQQQohHKJ4JIYQQQgjxCMUzIYQQQgghHqF4JoQQQgghxCMUz4QQQgghhHiE4pkQQgghhBCPUDwTQjo8Sil8sa4KSikAQFVNE1bsrM5wVIQQQlrLM3M2Y31lTUrHpHgmhHR4np+7Fd96Yh7eWroLADD9oZk45y+zMhwVIYSQ1rDzYAN+9cYKfLq6MqXjUjwTQjo8m/fWAQB2VzcAAA7UBzIZDiGEkBQwY00VAGDqqJ4pHZfimRDS4Qlrbg34RDIbCCGEkJQxY00l+nUpxoieZSkdl+KZENLhCeteZ4pnQgjJDZqDYXy5fi9OHtUDkuJrO8UzIaTDE9JTz34fxTMhhOQCf/p4LeqaQzh9TK+Uj03xTAjp8ISMzDPFMyGEZD2fra7EP2ZswOVTBmLqqB4pH5/imRDS4QkbmWfaNgghJKsJhxX+MWM9+nUpxm/OH5dyywZA8UwIISbbRoYDIYQQ0ir+NXszvt58AD88ZRjy03RR51cFIaTDw2obsYjIkyJSKSLLbdbdIiJKRCoyERshhDgRDIXx+BcbcezQ7rhiysC0HYfimRDS4WG1jTieAnCmdaGIDAAwHcDWtg6IEEIS8eHKPdhV3YjvnjAkLXYNA4pnQkiHx6nahtGuu6OhlPocwH6bVQ8B+AWAjvnBEELaNa8s2I5+XYpx6ujUNkWxQvFMCOnwhB2qbXRQ7WyLiJwPYIdSakmC7a4TkfkiMr+qqqqNoiOEdHTCYYX5Ww7gxBEVaS87SvFMCOnwGOLZWm0jTPUMABCREgB3APhVom2VUo8qpSYrpSb36JH6ElGEEGLHhqpaVDcEMGlQ17Qfi+KZENLhCYbsq22EqZ0NhgEYAmCJiGwG0B/AQhHpndGoCCFEZ/6WAwDQJuI5L+1HIISQdo7ThEFmnjWUUssAREyEuoCerJTam7GgCCFEZ1d1A25/dRmK8n0YUlGa9uMx80wI6fA4larrqNpZRF4EMAfAKBHZLiLXZjomQghx4vZXlwEApo3pldYqGwbMPBNCOjxO1TY6auZZKXV5gvWD2ygUQghxpbKmETPWVOHyKQNw21lj2uSYzDwTQjo8hkhWlgpsHVU8E0JItvDVRq2q5mVHDUTn4vw2OSbFMyEkaQbf9g6ufnJepsNoNf+Zvw2Db3sHOw82ANBsGlc9PjeyPhyO3f6wuz/AOX/5oi1DJIQQ4kBdUxC/e2clOhfnY1zfTm12XIpnQkiL+Hxt9tfwfWXhdgDAhqo6AJp4nrU+OgfOmnmuaQxixc5DbRcgIYQQR9bsqcGeQ0346WkjkGctl5RGKJ4JIR0WgfvEEto2CCGk/VJ5qAkAMHlwtzY9LsUzIYToWKUy6zwTQkj7papWE889ywvb9LgUz4QQoqMsmWbre0IIIe2DxkAIT3yxEQDQrbSgTY9N8UwIITrMPBNCSHbw4ryt2LyvHgDa1O8MtIF4FpEBIvKZiKwUkRUi8hN9eTcR+UhE1uk/099PkRBCTFhr6VsTzfQ8E0JI+6QxEE68UZpoC6keBHCLUmosgGMA3CgiYwHcBuATpdQIAJ/o7wkhJIM413mmhYMQQtoHn62pxJZ9WpWkBy6e0ObHT3uHQaXULgC79Nc1IrIKQD8A5wOYqm/2NIAZAG5NdzyEEGKQKPNsft8cylyWgxBCiMaBumZ8519fAwAGdS/BhZP6t3kMbWoSEZHBAI4AMBdAL11YA8BuAL3aMhZC0k1zMIzD7v4Aby3ZmelQOgyvLtyOCfd8iGCKhK4589wcpHgmhJBMs/tQY+R1r/KijMTQZuJZRMoAvALgZqVUTJcBpT0PtX0mKiLXich8EZlfVZX9TRlIx2FfXRNqGoO4952VmQ6lw/DrN1aguiGAuuZQi/Z3mzDYRPFMCCEZZ49JPHcuaZt23FbaRDyLSD404fy8UupVffEeEemjr+8DoNJuX6XUo0qpyUqpyT169GiLcAlJKYkacZDUEbFheLQnW383VttGKMzMMyGEtCeMxignjeyBK6YMzEgMbVFtQwA8AWCVUupB06o3AVyjv74GwBvpjoUQktuIrp5bWiVDwbnOM8UzIYRkHiPz/NjVk3DK6J4ZiSHtEwYBHA/gWwCWichifdkdAO4D8LKIXAtgC4BL2iAWQkgOY2SevUrnxKXqoq9p2yCEkMyz+1AjupbkozDPn7EY2qLaxizA8bn1tHQfn5BMwcpmbU/EtdHizHMsnDBICCHti3V7ajGoe2lGY2CHQULShCG7rNlNkj58+ofd0vsWq+iOEc+hlk1CJIQQkhqCoTCW7ajGxAFdMhoHxTMhaYbaue0wblRS1RnQPEyTqZtVmH27CSGkzVm1qwYNgRCOGNglo3FQPBNCcgh9wmCKHBZmEd5kqh0dpHgmhJA2573lu+D3CU4YXpHROCieCUkT2dbO+ffvrsJHK/fELQ+Gwvjxi4uwcuchm73aF63NPLtNGPznjA2R18FUqXNCCCGe2LKvDs9+tQUnjahA97LCjMZC8UxImpEsMT0/8vlGfP+Z+XHLN+6tw5tLduIn/16UgaiSw6d/1CGPmWHr78Zaqs4swrfuq4+8DoSy68aIEEKynTcX70RNYxC/OX98pkOheCaEuBPUhaLf1/5vAoymJy1N+lv3Mz89qGsKIk//DFLV/psQQoiW8PjrJ+uwbX99zPL1lTWY/tBMPDtnMx74aC2G9ijFgG4lGYoyCsUzIWkiy1wbjhjZV18WZNDTZdsIhxVqm4PoUlIAgJ5nQghJJXM27MMDH63Fb95eGVn26eo9OO3Bz7F2Ty1++cYKAMDAdiCcAYpnQkgCDAtEnj8LxLP+M+RRPFvPyLqXce61zUEoBXQrzQcABJh5JoSQlPHaoh0AtCd8Bk/N3hK33V3njG2zmNygeCaEuGJkWSM1lNtxSl1aGaNTnefaRu2C3tXIPOe451lEnhSRShFZblr2fyKyWkSWishrItIlgyESQnKAHQcb8MLcrXh10XYAwOwN+/Dnj9ehORjG7uoGAMBz1x6NyYO64tUfHofhPcsyGW4EimdC0kwWuB1cMQSk4fdtz44FiUwYTG57A+upGVq6xiqec7/axlMAzrQs+wjAeKXU4QDWAri9rYMihOQOgVAYx9/3Ke54bRkGdSvBAxdPAAA89PFaTPzNh1i7pxY/PW0kThhRgf/+4DgcObBrhiOOQvFMSJpoxwnapDCyrD5fNmSetZ+papJijFPTGAAAdI3YNtrvZ5AKlFKfA9hvWfahUsp4pvoVgP5tHhghJGfYvLcu8vqCI/rhwkn9Me+OaRjYrQT1zVpH1+njemUqPFfyMh0AIbkOM89th1Ftw2upujgcJgxaM88tHj93+C6AlzIdBCEke1mzpybyekhFKQCgZ6civH7j8Xh45gZsrKrF6N7lmQrPFWaeCengPDlrU0wGwGDWur34cMXuiOfZKFVnrYWcDHM37sM7S3dF3m/dV4/HPt8IAHhn6S58tXGf7X5b99Xj8S82JhzfuFF5ZeF2LN52MLJ89oa9eG/ZLvudTFjP7V9fbsKGqlrUNMWK5448YVBE7gQQBPC8w/rrRGS+iMyvqqpq2+AIIVnD6l1R8dyvS3HkdbfSAtxx9hg8fs1R7bZPAsUzIWmiNSKzrWgMhPCbt1fioofnxK276om5uO7ZBQhbxXMrTuvSR7/CjS8sjLy//LGv8Lt3V+FQYwA3vrAQlz36le1+lz/2Fe59ZxWqGwKu4xuTGv/15WZc8PcvI8uveGwufvD8wrjt46ptWM5txpoq/L9/zEa9Lp57dirEoO4lyPN1zEuniHwbwLkArlQO/h2l1KNKqclKqck9evRo0/gIIdnDzLXazXWfzkUY3adThqNJDto2CEkT7dgaHMehRmdRalgU/NJ68Wxl96FGT9sZnuNE9yOtzVHYDV/TGECznmk+fngFzp/Yr5VHyU5E5EwAvwBwslKqPtH2hBDixM6DDVi2oxq3nTUaN5w8LNPhJE3HTJ8Q0gYYQkxaLenaABdRatRMToVtI25sXZiHU+UhTvKjjmvPbROGiKApoInnwryOcckUkRcBzAEwSkS2i8i1AP4GoBzARyKyWEQezmiQhJCs5aOVewAAp49tnxMCE8HMMyFpwpho104tWwCiYtFNEIcsto10zJVL1QS81mee7eMwMs8FHUQ8K6Uut1n8RJsHQgjJSWaurcLQilIM69E+6jYnS8f4JiAkA2SDbcMQi27a1RC26SxV57UjYKKsd7KTS7xsLQCagrp49vOSSQjJPg7WN+OjlXvws5cWZzSOcFihpjGA9ZW1GNs3u3zOZph5JiRttH/1bGhWt7rIRkMQw/Ocjsxzop4jXkWxr5WpZ3vbBtAUDKEgz9duZ34TQogTs9fvxRWPz428//V549C5JD8jsfz10/V46OO1AIDzJ/bNSAypgGkUQtKEIcTas9wytKJb4tdoCGLUeU7HPYHXzHMiWusvd4qiORhGIbPOhJAsQymFJ2Ztilm2aV98adK24tmvtkReD+pemrE4Wgu/DQhJE+0/7+zNgmHtMJiq7n1mUjVhMNnEcNz2NucmEDQFwx3G70wIyR1enr8Nn6yuxBnjeuEvlx8BALZ1/dsK8zV3eM/s9DsDtG0Qkjayw/OcmNcX7wAQzTyb93lt0XZcMLFfq+0MLZ0wqJTCc3O3YmC3EjQHwzhY714HOhHmjldmmoPhDlNpgxCSO7yxeCcGdivBP6+cFJn4fPNLizF9XC+UFORh7sZ96NWpCIMr0p8F3rqvHlU1TbhoUn9MH9sLE/p3Tvsx0wXFMyFpIhuapHgR+PM27Qdgn3n+6UtLkOfz4bwJrfOutTSbvWlvHX75+vJWHdvMc19tjV8omnhm5pkQkk0crG/G3E37cf1JQ+HzCYp8fpwxrhc+WLEHM9dU4YxxvXGp3phq/e/OQl6arWlvLd0JALjxlOGRdtzZCr8NCEkTEc9ze55kloRmzXPoMHiwvrlFhzZnm72KZ+tmRhWMdNMUDKEwz98mxyKEkFTwyapKhMIKZ4zrHVn2p0s168YPnl+ICfd8GFl+1O8+trVzVNcH8KMXFuKFuVtxoK5l13pAS3Q8+NFajOnTKeuFM0DxTEjaiNR5znAcbiSTHfeJfam6lubXA6Go8A0lrLZhfyzDj51OBMw8E0Kyi4P1zXjgwzUY2K0Eh/WL2iOKC/w4dXRPAEBNUzCy/EB9AI98viHSMtvgyS834e2lu3DHa8vwP/9d2uJ4Zm/Yi1BY4cFLJrR4jPYEbRuEpIms8DwnEaPfxvOc7BhmgqbMs1fPs1W4BxLVuEs4nrftmkMUz4SQ7CAQCuPWV5Zi96FGvH7j8RHLncHjV08GACzadgD/XbADVTWN+HhVJV6ctw0vztuG5793NI4fXoFDjQE8Z6qO8fGqPXh/+W6cOb431u2pwb3vrIJPgCMHdsVN00a4xrR460F0Ky3A6N7lqT/hDMBvA0I6MMnoXuPya7VYtLRpStCUbvZs24gbI7ljW6t6eD1uU4ATBgkh2cE7S3fhgxV78IOpw3B4/y5x630+gc8nmDSoG37//w7DY1dPxqRBXSPrX56/DQDw0Yo92FfXjL9efgSuPHogAOCP76+GUgq3vboMM9dW4bM1VXjk840JY1qx8xDG9+vcvm2MScBvA0LSRESXteNrRTLC16kmdMttGy3JPMe+Dybye1gIxonnxPuIMPNMCMkelm6vRnG+Hz87fZSn7UUEI3tFy8bNWFOFYCiMTXvr4PcJzhzfG/deMB4/nz4SG/fW4a7Xl2PBlgPI8wkGditBbVMQv39vFT63WD4MlFLYtr8eQ7qXpOT82gP8NiAkTWRFtY0ktjWytKmq8xw0WS5a2p7bKoYTYY09mcwzW3MTQto7Siks31mN0X3KI1Y7L0w3TSqsbghgyfZqbNpXh/5di5Hv17qrThvTCwDw/NytOHFEBdbcexZuPk2zazwycyNuf3WZ7dgH6wOoaQpiQDeKZ0JIAnLN82xsG5d5bqnn2ZR5TtQkJfIVYM08J+l5toptL7ELBM2hMArzWW2DENJ+aWgOYcSd72Hepv2YYGPXcOPkET1w6eQBeOBibULf8h3V2Ly3DoNNXQDNfuWbTxsBv0/Qt0txZFmvToW2Y2/dXw8AGEjxTAhJRDpcG6t2HUJjIJSy8ZLJjiul0BgIYdWuQ5YxNA7UNWNLEm1fY6ttxMaxZNtBW0vJ5n31MeWSAgk8z3trm2Leh/Tt1+6pQV1T0HPmuTnIzDMhpH2zvrI2kiC4ZPKApPb1+QR/uOhw/L8j+6FbaQG+XL8X6yprY+wcIoLfnj8OPzplOCYN6gYA6Ns5Kp4PODSpWqs3n2LmmRCSkEipuhRNkNhf14yz/vwFbn2l5eWC4kgm8wzglv8swXXPLrBdP+3BmTj5/2Z4Hs8smM22jS/WVeH8v3+Jp2Zvjtvnkkfm4NQHosdINGFw8r0fx7wPhsMIhsKY/tDn+MHzCz2JZxGgMRBCYT4vl4SQ9suGqloAWlZ4bN9OLRpDRDCubyd8uHIPmoNhXDQpVoR/69jB+PkZUS913y5FOPfwPjhyYBds2luHN5dojVCe/WoLPlm1BwDwn/nbMaBbMUb2yo1KGwDFMyFpI9W2jTq9JueCLQdSNmaynuf5m/fHj6Gf6P4kC+gHYmwb0eXbDzQAAFbvsm+Vbc5uJGvbCCmFuiYtc79g83543b2mKYjyIlb2JIS0XzZU1cLvE/xg6rBWjWM0VendqQijEpSWy/P78LcrjsRpYzU/9I9fXISt++rxy9eX49qn5yMYCmPB1gM49/C+SXmw2zv8NiAkbbR/07OdwA+HVVxdUGNbXwrLDDlNGPTrx/AyiTCRbcNKKKxwKKCJ7+KCPE+Z50AojEBIobyQl0tCSPtl7qb9GFJR2upuqP/vyH74ZNUe/PCU4Z73yfdFc7Hn/W1W5PXHepfDQTlk2QCYeSYkbUTac2c2DFfsxKNTBYuwg3huaYY94DBh0BDu5mVO1pekS9WFFGoatQx+aaHfo3jWtikvyk/qWIQQ0lYs216NeZv246JJ/Vs9VklBHv71nSk4anA3z/tcdcwgTNezz9UNAfztiiOQ5xPc+MJCAEC/rsVuu2cdFM+EpIn2n3e2j9FZUKb2jIIOEwaNeXmeMs8tKFVX06hnnvP9nuo8G9C2QQhpr9z/4Rp0Ly3AFXozk7amuMCP+y+ZgBOGV+B33xyPcw/vi1NG94xc2/t3ZeaZEOKB7ChVl0TmOQz4bK4YLa1nbT6OWbAb2W0vjVNCLWiSUqt7x0sK/Ek1iWHmmRDSHmkMhDBnwz5cOKk/OmXwOtWpKB/Pfe9oXHn0IADAny6dGFnXp3NRhqJKD2kXzyLypIhUishy07K7RWSHiCzW/52d7jgIaWtUpNpGhgNxwU47hhx8xAoqxbYN+/bcxqQSL5aKZJukhMJm20ZeUpnnMnqeCSHtkDteW4bmUBhHD/Fus2gLSgvzMOPnU/HQpRNQlGN18tsi8/wUgDNtlj+klJqo/3u3DeIgpE0xhJmkyPXcVplsJ7tEWKXWvx2Mac8dXe5PIvPckgmDhm2jpMCb59mAtg1CSHsiEArjzteW4dWFO1CU78PRQ7tnOqQ4BleU4ptHtN6H3d5Iu3hWSn0OIL6+FSE5TqraczcGQmhoDkWEXmtFtDGe01jBcNi2EUswFEZtU/xy6xCHGgMxwre+OYimoM14DtU2jAmDjYEw6pqC2nH1bLFdTIk4WB8toRcKKxzSxyrK9+OgQ1F/OzL5OJQQQqw8O2cLnp+7FQDwyS1T+XSsDcmk5/lHIrJUt3V0zWAchKSHFGWKT/rjZxjzq/c9TaDzwvH3fYoxv3ofgL3AD4ZUZL2Z1xfvjOvYB8TbKw6/+0Pc89aKyPuxv/oA0x6YGbefU7UNI/M8c20Vxv36A/z05SVodhDJXiYMTvzNR5HXwbCK1Mt+Y/FO7Dio1ZT2Un60SynFMyGk/fDOsl0o8Pvw0KUT0K9LblWzaO9kSjz/E8AwABMB7ALwgNOGInKdiMwXkflVVVVtFB4hrSdVLovKGk2wJjO5zY19pmYmdkPWNQWTym7beaSNLlMGRuMTMzGZ55hSdbHbvWUZK2aMJCcMhsIKzcHYfUSAr+6Y5rrfccO6M/NMCGk3KKWwvrIWF03un5O2iPZORsSzUmqPUiqklAoDeAzAFJdtH1VKTVZKTe7Ro0fbBUlIK4nUeU6RUThJnegJO418yMEi4YRdRtzv4aTNmeeWZtVbMmHQuk/XkgJ0Kylw3W/SoI71cMxhonc3EflIRNbpPzvWh0JIO2J/XTOqGwIY1qMs06F0SDIinkWkj+ntNwEsd9qWkGwlVZ5ng3AaqnfYZbONCXVesZvY59TUxGm/cMxr78cOhMJJtXwNhsNxLb0bmkMJ482zq9GX2zyF+InetwH4RCk1AsAn+ntCSAZYX1kLABjaozTDkXRM0u4uF5EXAUwFUCEi2wH8GsBUEZkILfG1GcD16Y6DkLYm1dUxvFSfSBa7EY06yF6xy/76PWjNmCYppg8rmQoYwZBCUZ4Pdc3xExLtCIdjq3wAQEMglLCKSJ6/HdcbTANKqc9FZLBl8fnQruUA8DSAGQBubbuoCCEGczbugwgwoX+XTIfSIUm7eFZKXW6z+Il0H5eQTJNqqZuOUnV2Y9YkadsI24nnJG0bMZnnJM4zGFYoyvd7Fs/BcNi2vF2icPM7mHh2oJdSapf+ejeAXpkMhpCOzMy1VZjQvwu6lbpbzkh66HDPIglpK6I2i9QIr1RV24il9bYNu8yzl3N2mjCYzMTIYCiMgjzvlzHN8xzvC6FtIzmU9kuy/UVxkjch6UUphdW7anDkQE47yBT8RiAkXaRY6yZjZ/CK18yzm7a0s5N48SHHThiMLk8285yMpSIYVnG2DS8w8wwA2GPMV9F/VtptxEnehKSWqpombKiqjVjd9hxqQkMghCEVJRmOrOPCitqEpIlUTxhUKWqSEjOmzTI78ZznE8dufi0Vz0FH24b3E2wMhJCfRFY4GFIxbcG9kufFxJ37vAngGgD36T/fyGw4hOQ+e2ubcPwfPkVzMIzvHD8Y3z1+CF76ehsArXsfyQz8RiBEpykYwuDb3sETszZ53ufl+dsw+LZ34qwOB+ub8d2n5gOIb2m9eNtBDL7tHazceSip+FJdqq6uKYjpD30et9xOPPtcUs92tg2fAK8s2I7Bt73jsl/LJwz+8PkF2FXdgPeW707qFuXGFxbiw5V7kthDIy+Jih65gD7Rew6AUSKyXUSuhSaaTxeRdQBO098TQtLIVxv3oTkYxpCKUryxeCeufnIe/vbZegDA4O4Uz5mC4pkQHaMF9N8+Xed5n8c+3wgA2FXdGLN88756x30+XLEbAPDp6uREXKptG9aYDUI2nmA38Wi3vU8Ejye4CQk6ZJu9nOa7y3Zj50Et/rMP6514Bxe++MUpCbfJ72CZZ6XU5UqpPkqpfKVUf6XUE0qpfUqpaUqpEUqp05RS+zMdJyG5TFVNE370wiKUFPjx6/PGYn9dMzbtrQMAXHPsIHYVzCAd6xuBEBeMSWOpkKhuk94MC0CyDT7sqlq0BqfSd3aLfS7i2b5UnSSc+BcOq4i9w3xuXkvyGf6/44ZVeNreyUoyoFti32BHK1VHCIlnQ1UtFm090GbHm7tpHwDgwiP7Y+qonnj9xuNx2VEDMPeOabjn/PGu12WSXiieCdExLkPJJHidNjUvtzoejCxushPXUl3m2Vk8xy93yzzbiXo3m4dBMKxQoN9ImC0pXjPshmj3aqkosMkeey2EwmobhJBv/v1LfPMfs1FnqoX/+doq7KttwsaqWtz04iIsTKG43qxnmW8/ezQAYOKALrjvwsPRq1NRyo5BWgYnDBKSBsz6L04861nMpFtLp9i24SSe7Q7jNgHQ1vPsA0IJykWHjEoZgdhz83qaxsQ/r5P58v2CBksVPi8i39iXENKxOaRb+15btANXHTMIszfsxdVPzovZ5t1lu/CnSyfivAl9W328zfvq0bO8ECUFlGrtDaZTCNEJR6pZJC9Sk/EjG5lSO69wqo7hBScxblclxE0821bbEHGNVymFUFgh3++DT1pWbcPI3HvOPOf545Z5feqZTAtwQkhuUdsUxMcr90SuNf+Zvw27qhvw05cWx2x365mjEQor3PTiIlzw9y9Rech+XokXwmGFTXvrWFGjnULxTIiOod9aIlHjLRjOo/h1C4BT6Tcn2szzbKPp3WwLduP4fOL6OSqlZax9IvD7xDJ50GVHExHbhsescKFNMxWvDWw62oRBQgiwvrIGry3ajoc+WovvPTMfwbDC6N7lWLK9Guf8ZRbqmkJ448bjAQCdivJww8lDMWVwNwBaVaXfv7e6RcdtDIQw4q73sGDLARw1mI1Q2iN8FkCITiTjnIRGNaSXtXawW/LUsAB4nRhnkGrPs1OG1255splnn7hPGFTQMu95PoFPJCYL793zrO3jVdjaWS+8JpQ7Wqk6Qghw+6vL8PXmqIdZBPjVuWNxxeNzsb+uGXedMwYTBnTB6zcej+6lBRARPHbNZEy450MAwNyN+xAIhZO++Z6xpipyXb3y6EGpOyGSMphOIUSnVZlni4CMmTBoqfRsCFG7NtFupNq24TRh0U6kJ+t59kuizLNCKKyNa808e7XNJG/biL/cefU8s0kKIR0LowW2wXHDumPxr6bjuOEV+OeVR+Lcw/vg0qMGANAm8hlVezoX50f22VndiL984l76VCmFPYcasWpXtO7/5+uqUF6Uh9W/PRN9WY6uXcLMMyE6rfE8u2Wel+2oxoX/nI2Xrz8Wfp/EVdsIhMI476+zcOSgrli6/SCG9SjDhqpa/Of641BcEPXpGraNHQcb8N6yXTjrsD5Jx2nGSYzbnb+beN5b24Sp//dZzDKfD653Idc/uwDlRXnw+zRv9L++3BxZ5/VRp/GZe88829g2PO3JCYOEdDR2VTeipimIO88eg1W7DuHCSf0jwvisw/q4Xn/vOHs0upYUYN6m/fjrp+tx2phemDCgS9x2M9dW4aYXFkYmIl57whD8zxmjsHlvHYb3LENRfvw8DdI+oHgmRCcinluwrzWLaxWgC7YcQE1jAF1KCiKZaOOx3N7aJqzeXYPVu7Usx/IdWgaiqqYJA7tHaxCbE7w//vcirGuleHaq9mFr23DJ0K6w6ZToS5B5/mR1Jc49vA/yfIIxfTph0daDkXX1zSGXPTUGdS9J2vNsJ57dMs/dSwuwr65ZOwZL1RHSoVi6vRoAMGFAF3z/pKFJ7XvdScMAaCL7szWVOP/vX+Lm00bgR6cMj3mK9dHK3RHhDABPzNqEF+ZuRUMghG8e0S8FZ0HSBb8RCNGJWJ5bUOfZasGwG6JWrw1qVLkI6OLPScBZq2GY33u1G7jhNAHRbmmy1SaMjLLr8ZXWJOUy/dGnlf/95mGO+wZDKtIkxauwtcse232MPzplOABgeM8y9OpU6LgvIST3aAyEcOr9M3DDcwvQs7wQE20yxl4pK8zD5VMGAgD+9PE6vL54Z2RddX0A7y/fg7F9OuGwfp0jyxsCWvKgS0k+SPuFmWdCdFrjKbZWzrAbqkbPMBjHMcSfkw62TsRTKRbPzpnn+GXJimdtwmCC44eU7nm2F79ugjUYDkc+c6/C1k5k23XoMi8zPgt6ngnpGKyvrMVGvTnJz88YZTtXIhluPGU4hvcsw12vL8ecDftw0aT+AIC/z1iPvbVNuPeC8ThzfG+8u2wXjh7SDat21eCqJ+ZGqnaQ9gnFMyE6hli1q3PsdV8DuzEi4lnfNpgg82wV8+ZjpKLusFOd6WQ9z3b4JPHnGNLbcztN+HP70gqFVSTb71XY2tk77D57s0XF+F2x2gYhHYM1un3u45+djOE9y1o9XlG+H+dP7If3l+/GW0t34toThmBs305YvO0gjhjYBWeO7w0AOFu34Z0wohBL756O8kLKs/YM0ymE6LSmFJx1wqCdLq1p1NrbGSI4GHKvtmEV5Oa3KUg8O9aZTrZUnR1+X+LMc0gprVSdw9hOEwHzfIJASEXi9yps7T3P8duZNzM+C9Z5JiS3aAyEsHxHdcwypRQ+XLkbBX4fBpvmm6SCW6aPRDAUxrNfbUE4rLBq5yGM69vJdttORfmea9CTzMBbG0J0VKTaRvL7WicM2nXvi3qe9X3C7seLF8+pzTw7lcqzW9wS20YiQmEFn0vm2UmwFuT5EAyFI5+5V2Frdxy7LyhDzCtEfwdeJyUSQrKDx7/YiPs/XIs8n+C2s0bjeycOxd8+XY8PVuzBhUf2T7lVa3jPchw/vAKLtx3E7A37UNMUxIT+XVJ6DNJ2UDwTotO6Os/WzHP8KIcsto2ITcRjsxLzmKnwPCeTeU7WtuAp8xzWMs9OwtxJsOb7fWgIhBAMhyHiXdjbjWe3p9m2YZxDPqttEJJTzN6wDwDQrbQA976zCve+swoAMH1sL9x/8eFpOeYRA7rgL5+ux80vLcKAbsU4b0LftByHpB9+IxCiExGNLVDPViFq13UvYtuITBh0L43nZttIhQXXqUmKnehNOvPsYfug7nl2KoNXkCDzHAippES97YRBO8+zMaaK/q6onQnJHWoaA1iy7SCuOmYgvrzt1Jh1Vx4zKG2WifP18nN7a5tx59ljWMc5i+FXAskYlTWNuOO1ZWgOJtdprzWsr6zFd5/6Gp+u3hO3LlrnOXn1fNfry3Gwvhm3v7oUtU1B2+ztQx+txax1e6OeZz1b7ZShtepvr6XqlFK49+2V2FBVCwDYtr8ev3pjOZ77agveX74rst1TszfF7SsOE/2cjlfscPH3S+JSdcaEQb9LhtmOAr8PYaX5zJOpv2w/YTB+O/O5GueQCpsMIaR98OSszahrDuHiSQNirjNXHTMQJwyvSNtxh/Uow8NXTcIT10zGmeNbV6efZBaKZ5Ixfv3GCrwwd6utkE0XczbsxaerK/HsnC1x61pS59ksqX7w3EK8OG8bnpy1yVY4BkIKVz0xN8624SQy46ptmCYYuonnbfsb8PisTbj2qa8BADe/tBjPzNmCu15fjpe+3hbZbu2e2rh983xiO3HS6XClhQ7i2aNtw+/zOWaPnQSrUYWjMRCKCOJnvjslsn5oj1Lb/czWi6mjegCw9zybj/vSdcfi6mMHOd4kEEKyjy/X78XEAV0iXf/+fsWROG1MT/z2/PFpv1E+c3xvTBvTK63HIOmH4plkDMPq0JaziiOT9GzWtaTDoHlbQ0g2B8NwK6QRaZKSpG3DXJfZywXe2L6uKdrBqjlBhQ+fQ8bYSaw7ZX6dMthmEnqeHScSassbAqFI1uikkT0ignhUr3JMHxv/5WQI7Qn9O0dmuduFb7acTBjQBb85fzxnvhOSIwRDYSzerpWJMzjn8D54/Jqj+P+ceIbimWQMQ6SlYvKbV0IuFS4iEwZb2CylVK/LGQiHbattRI4TNsRzOOa903YGZvHs9pEZ64wQzII5kUXG75R5dtg+P88ha+ylSUpYwSfOnmcnUW0I5sZAKEZgG39HTp+N+fGs0ZhFbM7MrRU5ISS7ufO15WgOhnH0EDYhIS2H4plkjKh4brtj2k3kM2hR5tlcPk4XXcGQchTEQDTznCgLHNeeO8nMsxFbUyB6nCYP4tnu5sEpI+NUhcLvk7jP0TpuWM88O1XVSGzbCMcIYmNzQfyxAVMm20Wwm8chhOQWOw424L8Lt+PCI/vjjHG9Mx0OyWIonknGMLSgl8oMqcLI3tppJzfB60QoJhusDRoIhV1FuqGZjSywk+c5zrZhqo7hPmFQ/6m/Nwtmb5lnO/Fsv73TpD6xyTxbP5JgOAy/37k9t2PnQf2YDc2hGOEtCTLPkbqtSkUaobg1hGnJxFFCSPvl2TlboJTCz6aPpEWDtAqKZ5IxjExkWz4m92bb8D6euUSdcRqBkHK3bRgZ4WCiahvWzLN5wqBzTNYqHs3BUGRdIvHsc7BbOB3PKWssEp9ptr4PhhX8LbBtGJnnhjjbhnFsd6+0NrZPj8n7cQkh2UtDcwj//norzhjXG/26FGc6HJLlUDyTjJFJz7MdiUqr2RG0EbSBUNjdtqGvS5x5jn0f8GjbiNwgIN4e4sW2Ye95dmpkYn8JUSre/hKXeQ65Txh0FM8mz3OsbUPPPNvuZRpPBNEktHPmmRCSOzz31RYcrA/g28cNznQoJAegeCYZwxB5mfA82wnWFonnULygDYQSTBhUseLZa7UN83u3Gw7j2MbmZsGcUDyLvefZqZxyvuMvT8Vnni1n2hwKw98Cz7MhmBsCsbYNzxMGlYpsa/fZt+XNHCEk/VTWNOIP76/GKaN6YAonCpIUQPFMMoYh7p78cpNrRtjM/M37MWvd3hYdb1d1A16YtxWAfXe9ZLXztv312FfXHHn/4rxtkbHdMs//+nIzAE08hsMKz8zebLudVcwHPNZ5jnQutLGh7K1tctwPcPE8O2ae7ZfbZZ6twwZ08ZxsGTzDtrFlX33sNvowTtaTWNuG2MZk7E+cEZGfisgKEVkuIi+KSFGmYyLE4PO1VXhi1iY0BjS72oMfrcW1T81HMKxwy/RR9DqTlEDxTDKGkZn8eFUl/rtgW4KtNS56eA6uemJui4531eNzsV8Xu3ZiPdnM81tLd9out5sweNyw7rbbLtp2AE/bNGyxizEm8+zyPze6XfKZdDvbhojLJDyHQJSKF6Zx4jmoZ54dMsxO52gW7J2K86PbJ7Rt6ANK9Jj23RQdBiAQkX4AfgxgslJqPAA/gMsyGxUhGhuqanHNv+bht2+vxD1vrQAA/OWTdVi2oxo9ygsj9d0JaS0UzyRjmMVgXVPIZcvUsG1/Q/TYtraN5MYzssv/ueHYmOWabSN221NG9cTlUwbGjVHTGIxbFo3Huc5zMraNZLDLPAviJ+H99LSRAFwyzza2jfhMegLPs2NGOrr8plOHR15HFjvaNqIFsI0KL/bdFKmeE5AHoFhE8gCUALC/iySkjXllwXb4RXDq6J54e8kuvLpwe2TdySN78P82SRmexbOIFIvIqHQGQzoWLRF3rcE8cS6YgsyzMYS1XFswHG/bEAEK8+L/u7lVv4jLPMdU9kg8YbAlaFUyrMskLhtrHN4pa2ybebZs0xwKw9eCCYPm0nbmTaKZZ7E5WuxnZghzW3+3pclMtpPKa7dSageA+wFsBbALQLVS6sNUjE1Ia9iyrw7/mLEBo/uU4/yJfVHTFMTPXl4CAOhRXojbzxqd4QhJLuFJPIvIeQAWA3hffz9RRN5MY1ykA2AWLm2tU8xl3yIxJC2ete2tArI5aD9h0FY8uzRKsYrggClmh4QvALPnWSUtpPNsmqQI4pO5EtnewbZhs8zu5iTP1baROPNsFsTGS6f7imhmWiJj53qpulRfu0WkK4DzAQwB0BdAqYhcZdnmOhGZLyLzq6qqWhw7IV4JhMI4/+9fAgCG9SjD8cMr0LO8MLL+X98+Ct3LCp12JyRpvGae7wYwBcBBAFBKLYZ28SSkxZgFZktbYrf42DaaNUHDvzgMXWq1Lth5nn0ikYluZszd/+LHb1m1jbDJtpGorrMVn9iXqrMez3jrT2LCYMhmkqbf50vatmHe3ryNEaOT9jVPeox6nuPJsQmDdyO11+7TAGxSSlUppQIAXgVwnHkDpdSjSqnJSqnJPXr0aMWhCPHG3I37cbA+gIqyQnz/xKGoKCvEvDtPw4yfT8W3jxuM0b3LMx0iyTHyPG4XUEpVWx4V58hDTZIpbJK/bYZd5jnpUnVKQSQ++5qUbcM18xz7Psbz7JIdNbZTSiUtnv0+iRP+YpN6Nq4FTqXq7DzPdtl4v8/NnpF4uVnoRi3Pzo1brGPY/s5zSjun/Nq9FcAxIlICoAHANADzWzEeIa1m7qZ98PsEM/5nKsoKo7JmcEUp7v7GuAxGRnIVr5nnFSJyBQC/iIwQkb8CmO1lRxF5UkQqRWS5aVk3EflIRNbpP7u2IHaS5ZiFS0tqLLcGO89z8rYNTbxZRZ5dh0EBbDPPrp5nFStAgyGzbcPN8xytH90UTG4iZp7dhEFxLifn1Fobdplnm8/cLfPsXMIu3qph3t7pozEvjtR5zv1SdS2+dtuhlJoL4L8AFgJYBu075NGUREpIC5m1fi/G9+0UI5wJSSdexfNNAMYBaALwAoBqADd73PcpAGdalt0G4BOl1AgAn+jvSQcjHGPbSG7f1to87OowJ11tQyn4JN7zbNdhUERQmOePG8NNPIfDKiYms/h003eGxlYqcVMUKz6fxN1Y2HmeDRwnDCL+d2onnjXPs/1lKNnMs6kSXUJR7JZ5ziHLM9C6a7ctSqlfK6VGK6XGK6W+pZRyLx5OSBrZcbABi7YexOlje2U6FNKBSHibJiJ+AO8opU4BcGeyB1BKfS4igy2LzwcwVX/9NIAZAG5NdmzS9qzdU4PCPB8GdS9Nar/d1Y3Yc6gRjYEQRvfuhM4l+THCcPO+Ony6eg96dSrCgboAjhjYBaUuWYTmUNhWjHolGNayup+sqsS0MT0hEptx3V/XjG6lBa5jhJUmiq0iL2jTYVAkviqHcR5OhMKxmeePV1VGXs/fcgCfrt6DsX0642BDM4ry/BjUvQRvLN6JlbsOAdBtG0kauf0iqKqJ1UIi8dlY4+bAqVTd/C370RCIzXrbZ56dq204idgY8WzukRLJPCdOPXeEJimtvXYTkg28o9fbP29C3wxHQjoSCcWzUiokImER6ayUqk7RcXsppXbpr3cDcLxlFJHrAFwHAAMHxtfJJW3L9Ic+BwBsvu+cpPabev9naNQnxx05sAte/eHxMdnZF+dti3ToA4DTxvTE49cc5Thec7B14jkUVnjp62247dVl+MOFh+HSowbGiPkrH5+L935yousYSikI4jOkgZCK8yuLCAZ0LYkbozHgbKsIK+WYDW8OhvHdp+ajIM8XyV5//LOTcPNLi6PxIXZC4pQh3TBv037Xc7LzUgskLtMdmSzpoHDNNbUN7MRzvy7FjuLZSQQ7Zp6Nahu2ewGD9Ru+y48a4Fqqzhgy2yd1pOnaTUi74u2luzChf+ekEzqEtAavto1aAMtE5AkR+YvxLxUBKO3by/F7ijO3c4NGk4hbsVPLjLr5nBdvc/+uT9aOYBVJwbDCzupGAMAu/ad5m1V69tZ1TNh7nu2OJwBOGFGBRb88PWZ5oiYp1s/oDxceFtOt0Gz7aGiO/UzCpszzk9+ejJevPxbfSJCdsfNS+yTeJhIp02fKpr/yg+Pghp3P/IIj+sVkmB+4eILrGECsYLet8yz2F5RupQXYfN85uGzKwGjm2Wa7XMk866Tt2k1IpmkOhrF8RzVOGkltQNoWr+76V/V/qWKPiPRRSu0SkT4AKhPuQXIGQ7C4eYxrmwKuYyRbRcKq081Zb2Nd0k1SwvaeZyA+y2rosS4l+THL3cRzKBwfd2Ge31HcBSwVRJQCmvTMtpGlT+TntbNhiEhcFti4OTCfu1MW2sCp5rRdrWY3zNlxkfgstFO1DXN4HcG2oZPqazch7YZtB+oRVsCQCmadSdviSTwrpZ4WkQIAI/VFa/Qany3lTQDXALhP//lGK8Yi2YYuWNwaeDS61D8GkhfPVg9yMBzfAi/Z0nlO1TaUsqu2Ye/HdbtJsMs825WSMwha6igrRD3VRqWPRMLQbr1IvBXCrsZ1ouYiQQ8fsBfhmudg24gus98vpsOgy4TBXNLOabh2E9Ju2Ly3DoBWko6QtsRrh8GpANYB+DuAfwBYKyInedz3RQBzAIwSke0ici000Xy6iKyDVnT/vuRDJ9mKIVhaUzEjWduGW8ORyLIWdBgUsReN1mobdoIu3y8JMs/x4tmulJxBnDg1NUkpMOwVCYSh3bn4bErVGTGYS9U5TR6M7OPhV+ZFuJqPadckxckrbVuqLsF22U5rrt2EtEeWba/GoUbt/m+TIZ7pdyZtjFfbxgMApiul1gCAiIwE8CKASYl2VEpd7rBqmsdjkxzDi20jEa21bYS0UhmWbZILSCkFn0O1CLtqG1bKi/I9iOfYZT6fOJb1C8RlnlXkJqMwv+WZZ3vPs/YzGduGl8yzF5zrPEdfu00EBMy2jWyfFpiQFl+7CWlvrNp1COf9bRbOOawP/n7lkXh/+W4M7l6CrhY7HCHpxuuEwXzj4gsASqm1APjXSlqEIViSzfSaaQ4l1/zDmmm2q5mcfJ1nLUtprVOsEN8d0M6HW1aYh9om9wmD1tSoW+a5uiH2abyyyTwn8jzbVNOzzTwrGJlndwuFGS+ecscyczExmkvVxb92rlQXb9vIfe3MazfJHf715SYAwDvLdmHwbe9g/pYDuPrYwZ6uG4SkEq+Z5/ki8jiA5/T3V4ItWUkLMfRKq2wbCTzRVqzCzS4LmuyEQQWlC0vLcmXThMU285yH3XqlDzvsbBt+nzjedByoa7bEZxLPuuc5kS/Zbr3tF5MeglkwJ7r5sHqy7fDyFRgr2E37RkrVOZW+ix+jrTtbZgBeu0nO8NXG/agoK8ChhmBkPsdFk/tnOCrSEfEqnn8A4EYAP9bffwHNP0c6MIcaA2gMhNCzvAjb9tejR3khivL9qKxpRFG+H52K7BNc0eoWLT92U5LNP6xaOWxpgbdpb11cdrquKYiSAj827a1Dp+J8bNpbh5E9y7Fq9yFMGtQ10iQlrhIF7NtzWykrzIvLFpsJKYUNVbUxy/w+cfzcZm/YazlHFWnPHa2JnUg8x6eefWLTJCXieY5f5oSXJw3ePM9OdZ5F/+ngZTaLZxfPs0GOWDp47SZZz/Id1Tj3r7MAAL88dywumtQfq3cdQmMw7Pg9Q0g68Sqe8wD8WSn1IBDpXFWYtqhIVnDK/83AvrpmrP/dWTjxj5/hzHG98fC3JmHK7z5BRVkB5t91uuv+btU2EtHk0lzEDjthZ4i5NbtrcMr9M9C7U1HM+r99th79uhTjrteXR5b16VyEXdWN+NOlEzXPs4PYi58wGLthcb4f5UV5trWPDV5buAOPzNwYs8zvE9vW4gDwwYo9Me/N7bmj1TYcD6eNb7Ne6zAYfX/amJ4RAW8+r64lCToyWm5g7GIRaJl8tz8NJ8+zIYgdbRs2rbzt9HGOPQHmtZtkPS/O2woAqCgrxAUT+6JzcT6OHto9wV6EpA+vnudPABSb3hcD+Dj14ZBsYp9uEzBE6Cero+Jtb22z7T5mWvPIvLYpSc+zzbEM4brtQD0AYPchzULxwc1aMYL6piAWbDkQs4/RUKW2KYhw2N7nq5T7hMGld0/H/LtOQ2F+bIfEu88bG3ntE6DS0iYb0PzVdp/b8J5lcctEoueY7zeysgkmDJqE6aDuJZF9jGzvlMHd8I8rJ0ViMAvSirICzLtjGvp3NV8qolitMk5l8ZbefQaW3T3dMUanzLPRzt1c5vCPFx0eHds0htWnnsPw2k2yipe+3opLH5kTefKjlMKnqytx4ogKzPifqehexns/knm8foMUKaUiz4/11/G9hkmHxNBEyWrhlmjnkgJNcNY0Jleq1k5wGhlcqwOkd6cidCstQEgpx8yw0mswO2VynZqkAECnonyUFuah0DI7r0d5NPNdUmD/UMipzvOYPp1stw/qJ2eIxURZVXNWt09nLR6zeO5eVoCCPF/kdxfrORb07FTkKNCtcduKZ2h2lnKXR7FO4rm8SPvM6pqCkfjMj3TN29pNjMxReO0mWcWtryzD3E37I5a1ZTuqsau6EedP7IeyQq8PywlJL16/QupE5EjjjYhMBtCQnpBIttFSL2tLbBuGqHQr8WaHXYiGMLbaIMSnCa1QOCo+rYQVIp7nuGMhXqzbTWIzrBQGZlGY71Az2e9QbaOs0B+3TKlo+TqvmWc7YWquZW0sM2JIphtf3I2Ig0UkEbG1naPLDfFcY6pgIjHiPvo6x7oIusFrN8ka3li8I/J6zsb9aAyE8MqC7RABpo3umcHICInF623czQD+IyI79fd9AFyalohI1mGIYDcpnO/zRWZHR/ZLILrDYRVjIwCiYsmtxJtbjHbLrHFomVbt+NbayZHYlIKCshV7Srlnng0KLeLZnPV1qoqR5zBh0ClTHQiF4fdFJzUmFo3xMdh1UYyK5/gRlMNfQtxNSoLjO+GP8TzbZ57z9dSyeTTz60RVR3KIm8FrN8kSHv18I8b26YS65iAembkBv393FeqbQxjeswxdS93nVBDSlrhmnkXkKBHprZT6GsBoAC8BCAB4H8CmNoiPZAGGKHKrTmAnVhJVM7AT14b+SoVtwyh3Z2244hMtu6nZNpwzz0o5iVEVX+fZZru4zLPfnFF1yTzbqOfSgvjMM6BNGHSaYJeIqOCOCnvjczRCSKa+qjXz7OR5TkS+yXNh/rsyrB51TcGIfI85hk2pulyF126SbVQ3BLBy1yGcPrYXfv/NwxAOK9Q3a3NbOkBJSZJlJLJtPALAmPl1LIA7oLV5PQDg0TTGRbIIL7YNu9bNiVwbdtliQ3AfStK2YaeBG/UybkY5NwOfCHy6SHWqTezmeVbKzrYRj1U8e8k8O9k2Shy8gE3BUMy4yWhG41emZZ61WK2t1ZOxP8R9JrbVNhLjczgfww/pZNuI9TwnPlKWf13z2k2yikVbD0Ap4Ogh3XDc8ArMvn0aVv3mTEwc0AW/Onds4gEIaUMS2Tb8Sqn9+utLATyqlHoFwCsisjitkZGsIezFtmEzQyuR59lusp4hwJL1PNsJzka93F185lkizUgCjp5nrXW2nXgMK+XRthGbLfbSrc+pSYpT5rk5GEae6bNPLHajY0e2legEO+O0jJsRp5sHO6w3IvaZ58SiNs/hczJsG7WNDp5n0xh+1+PkRFaa126SVazZXQMAGNs3Ovm5uMCP1288PlMhEeJIosyzX0QMgT0NwKemdZz2mqUEQmFPDSCUUthzqNF2W7M4DEWykc5jteQxeSisoJRCczAcEbHGYWsbA7bnYRW7WvY4bCs4Dd90XZM186zbNsIKDQ71pI3ssp0GC4bjRbeXCYPm8mmunmcbPV/s4Hmuaw7FTj5M4tfgi/E865lnY5JlCzLPVbWxpffsJvN5Gc3vYEOJsW3YlNKTJDPPWQ6v3SSrWLOnBr06FaJLgnrxhLQHEonnFwHMFJE3oM3Q/gIARGQ4gOo0x0bSQH1zECPufA9/+nhdwm0f/2ITjv7fT/CCXqDezFG/i5aK9VI1I7+F4vnp2Zsx8q73MOLO97BlX11EtG3d34ARd76HJ2ZF7ZuvLNiOEXe+h6376iPLrvnXPAy/8z3bG4Av1+8DgLiJjIZt4+2lu7B0u/2fueZ5VraZ0prGIGZv2GcZM34M64RBvwfbhk/E9lycqnO8s3SXbRc+LxjZWXfPc/x+TjdR9723Oua9eVdzZY+EcTlkng3bxrh+nW2P4XXCYJcSTYQ7lf/LEnjtJlnBwXrNXbRmdw1G9irPcDSEeMNVPCulfgfgFgBPAThBRb+1fQBuSm9oJB0YEzCenrM54bZGQ5Aqm2Yd++uiTVDMmVCnjHYyE8sMguEwXlkYLV20oao2Isz26lnMN5fsjKx/a6n2en1VTWTZF+u0ltWGPr7p1OG494LxrscVSfRYX6+2oaKi+D83HJtwTCtunucCh0LEeX77ahvmrPW/vn0UvnlEP1Os0e0SnZfZSmKutuGLiGdtXbKe5zvOHh23zM673Brx7PcJ3r7pBDx+zWTb/WL8zy7ieViPMrzyg2Px6/Oy12fJazdpK+5+cwXO/vMX2LKvLiKE3VixsxqfranEC3O34qjffYyJv/kID8/cgJW7DuGIgV3bIGJCWk/Cx3dKqa9slq1NTzikrTBEtBuhcKxVwglz5tZr7WYvthGrPSHfH99dr9RkV3CrAGHsN7ZPJ1v/tYGItr+buALMEwa17Yb3iO/wZxk5bolVIJtFoVVYm7exs6CYJ2SeMronth2ox2uLdkRijUSRQJw61UWOzzzr4tljpfjpY3vjf9+NzTz74iwVytbeYsWpzjMAjDdlnaPjxr9OdBMxaVC3hHG0d3jtJunmUGMAT83eDAA4+f9mAADW3nuW4/WrvjmIyx79KjJnxfj/azyVOmVUj7TGS0iq6Dh9tgiAqGfVOknOjoCHEnRArM/YqSOflSYPxw+GwzECzlY8m6pMGHHaCaOo2BPHCzsQFXSJXCbWJimJMrC2EwbznScMOopnsS9VZ7VtmOMJx4jnRDcF8WOY6zzH2TY8mqjLiuLv02NtGzYLHXCq85wI86YdwPNMSEqpbw7i+8/Mx/zN+yPLHp6xAQAwunfUbrF69yHb/d9YvANjf/VBRDhfPKk/1tx7Fr74xSkY2K0EF0zsiwn9u6TvBAhJIZw40sHwKm6BaHe9RDU2Ax4yz1aN46VahnWsfL82Wa4gzxcR/+bOesb2dkLWvM7qNTZjaKpE4kqzbURL1UmC21C70ayZZ7NtwynGPF/8DYSx3Iw5fvPnmEgzmm+UIrYNX/SGxHgaYMRg73mOj6/cTjybs8LwdhMC2Jc99IJXzzMhJJ5HP9+Ij1bugU+AyYO7Yc+hRvxjxgYcN6w7nv7uFLy9dCd++tISPDxzA64/aRgmDOgSs7/Zgvf41ZNx2theAIAB3Urw+S9OactTIaTVMPPcwUimJbZRWiyhbcOURfZS8xnw1uQkXjxrwrFzcX5kmTnz7Nb1zsh0+33OWV3AeyZZ6ZlnY7tENgC78awC2ecl8+wX29+hVVD6YzLP7nGYMW9rbOoTiYwfqfMc2cabCLWW5dPGjX/tZbS8JIRvzITBJGwbhJAojYEQnpmzBQBwoE67dr+lzzf55bljke/34YKJ/TC6dzneXbYbt76yNGb/NbtrMG/TPlw6eQBeuu4YTBvDVtsku6F47mAkI56jtg337WLEs2NTkdj3Lck8+0RrENLJlMUsK4z3PNudolHTWSSRbUP7mSgzaXiezQLTDS/tuc2bOE0Y9IvY/j6sPm6zEDdnqhPbUUyZZ6MCBqKfR2S1ch7P61+YXQMTbxMGW3bZihHrzDy3GBHpIiL/FZHVIrJKRNxny5Ks580lO7G/rhkjepZh0bYDmPK7j3HvO6swqld5xLIhInj3xyfi1jNHY/XuGlz1+FxU1miTzv/33VUoLcjDT08fiaOHdm/RBHJC2hMUzx2Mltg2Enmemzx4nq1CuLYpsXi2jmVkex0zz/r2AZtCyA36BEm/iG0W1MDvMZNstOcWj6LPS7UNswC3+qEj8TlNGLSIQbOWNn/2ib60Yipz+Ixzk6htwzphsBVfgma/dLTOswfbhpfugDZ/hl792SQhfwbwvlJqNIAJAFZlOB6SZl6YuxWjepXjgUsm4OSRPVCU78ekQV3xnx8cG3NN8fkEZx/WG2WFeZi1fi/+7/012La/HjPXVuHqYwejd+eiDJ4FIamDnucORlK2DUtDDCcCpsyz07ZWwdcS24Yxhlk8+20yrHYttY1mJ4k9z1GfrxthS3vuhJlnG+FmFfHmIRxL1Tm0547LPJsGs5sE6IT5RinaJCX6OYfixLPdGK6HMMVieu3zdhNi3tYLTtVDSMsQkc4ATgLwbQBQSjUj2gac5CBVNU1YvO0gbjl9JA7v3wWPX3MUlFGq0+b/4qDupVh+zxm46/VleO6rrVi2oxoAcN6EPm0dOiFpg5nnHOTtpTsx+LZ3UN8cn901C9I3l2jbGVnZ7z8zH9c9Mz+yPhhKvlSdU+bZWiHixhcWuQ8K4Ny/zoppUnLNk/MAIKYDlVnsGYf42cuLcdivP8Dlj0Yrdf3k34sBaKLYzbZhaNxEto1/zNiAL9bt9VydI5nMc1G+zzFGn0/Qt0tx3PI4z7ODbcNoAGJHeWGeRWhH44p6nrVl3csKAcRm/pMlJmNlsogkwotfuWe5Fl+xQwbfoCifl8AkGQKgCsC/RGSRiDwuIqXmDUTkOhGZLyLzq6qqMhMlSRmfrNoDAJg6KupT9lLO8+JJAwAAq3fXoGd5IYZUlLpuT0g2wW+OHOShj7RSrjsONMStM4vnP76v1dbcVa1t99HKPfhw5Z7Ieq+ZZy+eZ2vmedKgrrjh5GGu41qpbtCy1UMrSnH7WaP12KLrjThrGoOoaQpizsZ9cWNYM8+/tTRMKSnwR7bzglvm+fD+pk53NuvtBPrjV0/GRz892TU7/uL3j4lbVpKfh7dvOgEvX6/ZT80C0/zZXzJ5AI4f3j1u//svnoD3bj7R9nftE4mcn3Gzctc5Y/CHCw/DCcMrHOO08saNx+OW00dG3sd6no2Ficdx6qZo5jcXjMcfLzwckwZ1tT0eoH3WH958cuIDEjN5AI4E8E+l1BEA6gDcZt5AKfWoUmqyUmpyjx6s25ttVNcH8MGK3QiGwjjUGMATszZhVK9yjO+XXMfNw/t3xpg+nTCyVxme/97R9DmTnILiOQcxLlJ2MjZo8gPXJfAdByKeZ/fjxdZ5tq/fbM08nzGuN649YYj7wA74fILvnzhUG9cUnBdLis8yYfBbxwyKWV9epGVmDWFb7jGzave9MLSiNDK50e5rwyqefT7BaWN7YUC3Elfx3KtTEQZ2K7HEnYfx/TpjypBukbEMzL8/v09wxRTtnM8a3zuyfPq4XujftcT2KYNItBSe8XmXFOTh0qMG2n4hKocpgxMGdMHkwdHmI/FNUjx6nl2a3BiUFebhkqMG2Ga3DU4b2wsDu5dYdyXubAewXSk1V3//X2himuQA4bDCd56ah+ufXYCbX1qMSb/9COsqa/HT00ckLX5FtI6f7//kJIxg222SY1A85yBulziz2ExU8cLwDieaMNjswfNsFWXlRXkt9qD6RCL7qpjMc+J9/T5nP7ERFxDN3DpN3DMwjm/3xWIWsHbnarUfmN+5iWc7rE1I3KwNhriN8QNb1gHRzzOmSUri3jau2GabTa+Tbc+d1LFbtBcxo5TaDWCbiIzSF00DsDKDIZEUsnDrASzcehAA8PbSXQiEFG47azTOHN8yv7Lfl9jeQUg2QvGcw9jpWPNkOsOW4aQ5AxHbhjGe/ZbmboFeq210KsprcaUGn2hiVcTiefagnkXENXNpZJ6NC35xgft/ETdLi08kWg/ZRrpZJyWaP49kv3CsEwbdBGZE8MdUu7CUokP0sxVBXJ1nN9w2MUdl1yTFy1knU+c55th8bJwqbgLwvIgsBTARwP9mNhySCv67YDsufmQOCvN8+O354yLLv9fCJ4SE5DKstpGDRLKyNrLYydpgtl4YWDsMOomigFmQe/Q8lxXmtzgTGOl8J2LreXbdN4GAMmwaxnaJJpwl1Osu9ZCtAtccmpf26W64nWYkZJvMs50Nxux59vIZu8dln42PZp4T/1Uw85xZlFKLAUzOdBwkdSzfUY2f/2cJAOB/zhiFS48aiC376lFRXujJJkVIR4PiOQdx8406ZYbtLBzWDoNOwsmTbcNy3NbYNqJdAGOP50XYJcp2R2wbPqPyRSLbhvMxY1Z5sW2kUDx7EZixWWDtp/nXZPytaJ5niVvvhFd5bet59mLbaOEfDhPPhMRzoK4Z5/51FgDgjrNH43v6fJK7zh2bybAIadfwljKHsdN1Tu2za23Es9FsxBCITqKoORSKvHa0bSg78dxy2wagCa7YzLOHfRP8xRvi2edVPCc+JAAn24bV8xx932zzJCAZXD3PETtGvG0ibGODifE8tzLzbMYcofF78fIX0VIPJW0bhMTzysLtkddnjOvtsiUhxICZ5xzE0Ah2Fg27UnJKAYdsmpaELKXqnIST2bZhd0yjoL6Z8qL8Vk0Y1H5a6zynIvOsV9vQN0ts23DJPJuMM14mDJo1YVOgdeLZi8C0yzzDJvNsbpLiRTu7bWP+fbW0PTchJHV8tHIPxvTphJeuPwadipzrwBNCojDznIVs21+Pyx6dYyt4zRhC9uGZG3D/B2twxWNfYX1Vrc2WKsa28aBeJ9ps21i9+1CkSYmVmDrPJvF82aNzcKCu2VZQlxXmtdiDGsk8Q+u29/Xm/Tjpj59hy776hPsmsjOUFcZmnhOJZ9cEsYqKRTvRHpd5jpkw6HrYhLidpxGLdZIhENtsxdyCOy9FmWfz3uasfvTzoXompC1YX1mDUXe9h7mb9mPqqB4UzoQkATPPWcifPl6HrzbuxwfLd+PiyQMctzOsEve9tzqybPaG+MYhYQU0BaPWi798sg4/O31kTJ3n215ZhsXbDtoep8lBPH+1cT9eWbgd3zo2tpby5VMGorjAj7qmxELsnm+Mw/Nzt2Dtnqjol5jMM3DtU1/jUIKyewaGpnzwkgmo0LvkPfPdKbhavzEo1pukRCYMFrTc82zGNvNsrfNsevuLM0ajrDAPj32xCQDw58sm2majrztpKE4eGd+IwizW377phJh1Z47vje+fOAQ3njI88sjW2PzX543DG4t3AojePEkC28YT10xGfXPItCS6zTeP6IfLjrL/G/3HldHywMbxrZ/T6zcej+e+2oL/LtiOdPPotyYl1b6ekGzmmTlbItfuCyb2y3A0hGQXzDxnIXaeVTPGcq9CIKyU7baRUnZKoTEQiltvEHBpzx1WKq428I9OHa7HGbvc6Bpo5prjBuMPFx4esyxq29A8z7HCzR3js/l/R/bHSbroPGlkj0gsRobV+4RBl3Xm49qsj6/zHH3ftbQAd54TnbBz4ogeuMRGhGodA+O7/JmF+fh+nWPW5ft9uPOcsTFtzo1jdystwMWT+gMwZ57hWud52pheOG9CX5sz1G6Ujh4a7WhofF5ThnRD/67RBiVO7bknDuiCbx832HbsVDN9XG+cdVjL6tkSkk0opfDJqkoAwNXHDsKo3mxiQkgyMPOchURrB9tjLHcqG2clFLYXzwFTqboGF/EcU20jTjzHTxb0R4RS7Bk4lUSy3iSYG2qElXKcpGiH00Q6I0TDthCdMNjyOs9KuXuerdYMcTlUnkNLaid7RrIVKWIaplg882IWz0nWebb+SiMNWiz7JFOqjhDSOlbuOoQdBxvwhwsPw6VHDcx0OIRkHRTPWYi5eYUbXv2pSsVnqQOhcIznucElu9vs0iTFTpg7dZPLdxCIVn0YyTz7xLNtwrqvE0YbauOYrZswaCb+uG4dBq3kW5S2IUKdrM3JeqZjJg/q74x7L4HEted2w7yF10Y4bk1SqKcJSQ1VNU1YV1mD2ev3wSfAaWN6ZTokQrISiucsxC2bCUSFk9eMbFipuOxwbWMQwbC3zLPZthGyPNcPh1VcNtrI6lrjd8qiWgWY8dbaJMULiUSlIeCNj6M1peqUio5jd2rx5+WsEp0yz04k20gktruh9tP4Xfp85mWJxzLf0HiNw/w7JYSkh5/8e1Fk3suUwd3QXZ/3QQhJjoyKZxHZDKAGQAhAUCnFrlUesGuvbCaSObQzqNpglx2uaQxGStApBVfPc7Or5znetuFzsG14tRqYbSvJVn/wmnk2su6FeQlsGy7qXcFkU/BQbcNNZybbkro1tg0j/2v8+Yipw2CqMv3WxW6l6tya/hBCvLH9QH3MhPGLJvfPYDSEZDftIfN8ilJqb6aDyCYSZZ4NvPbZCKt4f3R1Q7QMnoKKqeVsxalUHaAJZ6vANYRdnB3DQUxaBVg4HBWkydZGSJQJNTK8xk1AQvHsMQAv8s9NJFrFdyJBmWwjkZgyeYbn2VSqzvidJXuzEvd5O+xuZLbthmcympDWc8r9MwAAt545Gt1K8yMTgwkhydMexDNJkrByzmZqy7WfbplnkahQsbNtHKhvjh4vgQhvDjmLZ2VTbcOYGBc/EdCSiXawd0RFXfKZ0ERCzKh9bHx2BXmJbBvuEwa9HtfrNl5paQtrcxzG79In0d9Nsu25rb/T6FMD+9+9nTineCakdeytbUIgpNC9tADXnjAEBQmSAoQQdzL9P0gB+FBEFojIdRmOpd2hlMKDH63FruoGywrtx2erK/H+8l1x+xla4z/zt+PL9fZJ/QJTGYSwjW3DLJ7fX7HbNc6YUnWWDHVzMIz/fXdVzLJotY1YrJUZDPHslHn2iSQU9lYS2za09QH9GIm+ZNyOr2D2PCdWgCkVzy1sYQ1EYw2ZPmfjhif5zLP9cuu5Gm9txTNtG4S0ihU7DwEA/nbFkRTOhKSATP8vOkEpdSSAswDcKCInWTcQketEZL6IzK+qqmr7CDPIyl2H8JdP1uGmFxbFLDeyna8t2oEbnlvouP8nqytx5eNzbdeZxXPIptzbvtpm6y6O1DdF/dCNwVhv9HvLd+PNJTtjljn5W80Cc3TvcjxxzVH68tjtzBlRa8b8h1OH4c6zxzjGmigja5TLC3n0PCfKfCcjNZOZLPfgJRNwwvAK9OtSbLveqemIF64/eRiOGNgFf7nsCBw5sAt+Mm0EygryMG10Tzx81aSE+5s/krjMs8MHYjyFsFvNzDMhrePTVXvgE2Bs306ZDoWQnCCjtg2l1A79Z6WIvAZgCoDPLds8CuBRAJg8eXKHav9lZDWtgjRhttWD2ijI8wFN2mul4ie+7atr8hpmjD+6rik21qCN8Toq7JyrTTx+zeRIE41420Z0+4Bl/F+cORqBUBi/s2S7DRIJ1PyI59mwbbTC82xa58m2kXiTCJMHd8Nz3zvacX3E8pLEmAb9uhTjtR8eDwB4Vf8JAE98+6ikx7JmwKMTKGO3Mzazuxmhdiak5Tz2+UY8PWcLLp8yAJ2L2YKbkFSQMfEsIqUAfEqpGv31dAC/yVQ82YSbz9YrZlEYCrcu83zQJJ7rm2PbZNuJSy+NPcThNWCeMGhff9otu5yoVJ0Rm/F5ONWejsTiWufZ5Hn2IAFTWaYtYo3JQNrWLIAdq204ep5ttqV6JiRpDtQ149ZXluLDlXtwyqge+NW54zIdEiE5QyYzz70AvKZ/uecBeEEp9X4G48kaEtlOvWiNfLPnWam4yYV7kxDPZr90bVOseA7apMmdBJVZU8e+jt3eXAWiMWgzvovfN3Hm2ZgwqB0jL4Ha9lxto40nDCZbbSNdxGWenaptGOLZ9gNtH+dCSDbxz5kb8OHKPbjsqAH4+RmjUFzgPvmZEOKdjIlnpdRGABMydfxsJpFgSyTC/D6JETWaeI7dZm+tZtvI94trmTor9Rbbht2+TrpOHASzdfOwqdqGW/1pOxKWqjMmDOofSOL6ym7VNqKrvU0YTEPmOWUjesf8icTbNjTiJgzq75l5JqT1BENhvDx/G845rA/uu/DwTIdDSM6R6QmDJAP4fRIjYMPh+LJ2hue5tDC5+6s6i23D3vNsr4YaA9FtzVu4VdtoSlI8ey9Vpx0jkdh2u5FRytnjm26cuji2NV4P79aEhdqZkOT4aOUeHKwP4JzD+2Q6FEJyEornrMQ9E5xIbPglNvNsV21jv27bKEtWPFtsG8lkrc3CO9bzHLtdKBxdbhbcXkhcbSPW85znVGtNx2vptrYWgNEJgxmQnq43FPYrfZFSePHrMuHbJiRbqaxpxA+e16owHT+8IsPREJKbsElKFpLYtpHYmmDO5mqNTGIHrdMn4iUtni0T+Jq9tjlErPA2n4JzkxRBQ5KZ52Tbcyeybbi3506uSUoqaU2TlJTiaNFJoklKyoMiJPvZV9uE1xbtwFcb92PKkK647qRhAIA5egvu35w/jtU1CEkTFM9ppLohgM9WV+KCI/q1aH9DfC3fcQgvztsKADhheEVc9m7epv3o1akQG/fW4ZRRPT2Nbc48f7q6Eq8v2hm3TXG+P6HYLPD7YgSyXfULr5jL3JmPG18rOCqet+6vT+oYiW0bsZnnRLYNt8SzUtH1bZ09jRwuw4lna+bb6eMSN/FM9Uw6MI2BEPL9Pvh9gl3VDZi3aT/OO7wvbn5pMb5YpzXB+njVHlxwRD/0LC/CvE37UVaYhyumDMxw5ITkLhTPaeRnLy3GJ6srMb5fZwzvWZb0/uak5u2vLgMAFOX7cMzQ7jHbXfLInMjrzfedk1Avje/XOcYi8fL87bbblRb6ExbF61ScH5lcCMTbNsycMa4XZutZETvOHN8bf/5kHYDYSYVW8XT2YZqPrymYnFDP90virLxu0/jRKcNx4wsLMbii1HV7s9g7ekg31DQGsXKX1s3rmuMG45PVldo5JBVplGmje0a6HSaD4d2+6xznhjEA8LPTR+Kxzze2KDYvWDNfh/XrDAD47vGDY5Zfe8IQfL62CuP19WbsrCdHD+mGLiXMqpHc55v/mI1Vuw7hR6cMxwvztmJ/XTMe+2Ijlu84hB9PG4GuJfm4562VeGfpLnzn+CFYur0aEwd0SWg5I4S0HIrnNLLjoNZWO1mRZ2CXhWsMhJOqtvHQpROwobIOf/tsPQBg6d3T0akoHxf8/UvbfTffdw5O/OOn2La/AYV5/oQd9LqUWMRzs7N4vvm0kXjkW/Ydrjbfd07sOcA+8/zwVUdiTB9tDK+acvrYXnj06smetjVsGucc3gfnHH5Ogq1jY3jp+mMdt2tp5rkljUkALWNu/Uzt+PG0EfjxtBEtOkYi3vrRCXFNZirKCm3jOnlkD8d47T46t8+akFxh+4F6rNJvxo1reEmBH8t3HMLAbiW46dThyPf78OycLZixpgpj+3TCsh3VuP6koZkMm5Cch7embUBLJ205+WkTtoQ2rS7w+2Nq/hri0M2OYLTuTtSaGgC6WrJ/dU0hx8fsiRqOmBHToc3j+X2x9alTTeLSdLF4bVjTkZwHxt8n7Ra5iYj4RWSRiLyd6VhyndnrtSd1r/zgOEwZ3A2Dupfg01um4vIpA/D0d6dEnjBNHdUTM9dW4dJHvwLANtyEpBtmntOIoe0SdbVzIuQonhPsZ9qgMM8XM3nMyOK6TSgrzNOK6Rfk+RIeq0tJQcz7uuYgupcWxmSjDRI1HDETW+c5+tr8JDIN2jmhx9lKoux3RxaSqTrnjvjZtXN+AmAVACq0NDNr/V70KC/EkQO74OUbjoVSCiKC3/+/2NrNU0f1wJNfbgIAnDq6J04a0SMT4RLSYWDmOY0YmdGWZp5DDurQrmtf5Jjh2MoZBXm+GMFpZFbddKzxqL0gz5cws9rF4mlVCqgoK7DdNi+ZzLPptc8h85woA98SkrVXJHwKoP9MZevt9k6qz5ml6toPItIfwDkAHs90LLnOtv31+GjlHhw/rHvk/4DT/4UpQ7qhIM+Hm04djie/fRS6ltpfgwkhqYGZ5zSiIj9bJvKcNHLQpXZyIByOEd0Feb4Y24aRWXUTNoZ4LszzJayeYTdpq7uDeM5PYgJLTObZ9DovpjOit7HSkKBOOoaOSMoyz6kZhqSGPwH4BYDyDMeR04TDCj98fiFEgKuOGZRw+6J8P1bec0bST84IIS2Dmec0YmQlnewXiXDOPDuPFwypGNFdmOezFaJuF9nCmMyzO8UF8fdf5YX2VRCS8RPHtuo2v45tK55pEsUQLVXXBsG0EyJ2pZRlnlMyDGklInIugEql1IIE210nIvNFZH5VVVUbRZc7BEJh/PmTdVi2oxp3f2McJg/u5mm/PL+PT2kIaSMontOIISJcXBauOE0YdLNtBMMqRtAVWDzPBm7CpjCSefYnFId2grgw3/7PKpnSSbFNUkyZZ3/ymed04lW/d8QvtVSdcUa6JBI7jgfwDRHZDODfAE4VkeesGymlHlVKTVZKTe7Rg97bZHli1qZIyc7pY3tlOBpCiB0Uzy7sPNiArfu0JhwH65uxZndNUvsbuspJ7B5qDGDBlv1Ytr3adr1TxtponW1HMBSO2a8wL7bahoFrtQ0j8+z3JfQ82I3jVKUjmWobsdly++N59Ty3gwQ1OtLTVMOmlKobhg5439EuUUrdrpTqr5QaDOAyAJ8qpa7KcFg5RVVNE56dsyXy3johmxDSPqDn2YXj7vsUgFaD+Jv/mI1Ne+s81c41SGTb+Nbjc7FEF87L7p6O8qJYu4OTbWNndaPjMYNhFbNft9IC2GlWt8xzkbnahuNWWtbZTjw7TVZpabUN82t/mmwbxw7tjjkb7Ru4FOT5UFFagPKifKzZE3sDdeXR3rp4dcTsaTo8z2cf1js1gxLSzli9+xAueXgODjUG0adzER7zWJueENL2UDx7ZNPeuqT3MaSdk3heYso4NzSH4sSzk23jsqMG4MOVe7C/Lj4DHQiFEQ4rnDamF/540eGaeLbNPDvHXVak/VkU5vkcs7s/njYCN506HE/P3gxAy6wa4f7P9FH4+fRRuPftlXjalEVJyvNseu1zyjzrP/9w4WG49ZVlLqMlFtnPfe9oRzG+8p4ztJhEEFYKI+58DwDw5W2nok+nooRja/u6r1/3u7M8jZMNpNrzbP5j+NvlR6ZmTNIqlFIzAMzIcBg5w4vztuL2V5ehoqwAt581Gmcf1gcDupVkOixCiAMUz2nEEBFeJgw2h+KtHU6Z5z6dix2tEcGQlnkuL8pDNz0DnKxto1wXz26Z53yfIN8fnYyY5/ehORiOvAaAwnx/zD52cTgR43k2qacYz7P+uZYWtv7P2O8T+B2yw2avtnmbIkslEzcSbZVMJZJsIR2e52T+hghp74TCCn94fzUe/XwjAODiyQNw/cnDMhwVISQRufeNnWaSqS1seD/dqmMY2JWfcxLd5UV5jlm9YDiMcNjZ6mDglhU0MuBhpRL6hQ0xW2Aj/pLt1mdGnDzPpjdGbHbHbguSyqx2IM2X+jrPKRmGkHbHwzM3RIRzvl8828AIIZmFmeckCYQUCvK8fZsb8wSdMshm7CYVOtkIyovyHBuOBEIKobCKsWUkm3ku0zO5TcFwwhrVxjh28SRTXcMNpwmDxudT4KGNeDpIJgvakZqkGLDOMyHOKKXw8vxtGNmrDDeeMhzfmNC3Q1blISQboXhOkmA4jIIkE/Yhl6YmBk1BG9uGQ0W68qI8x/bahm3DLDLttnVrz23YNpqD4YRl9oxx7LLM+Sl6xG4WnuZJh0ZiPpHlIV3VNpI5vQ71lZji2tYUFCSXWF9Zg9cW7UAwrLBlXz3+76LDcf7EfpkOixCSBBTPSRLwIIQNDIuHF9tGs414dso8lxXmO6qxQFibMBhj27BReW5Z00K92oadoDcwhjfGthOwqco8x1TeMA1pfD6Zyuom082rIwrAlJWqS8kohGSeQCiMn728BEv1yeLnTeiL/3dk/wxHRQhJFornJAk6pYNtMDSzl5JqtuLZQXQXOTQhATSftDXzbGvb8NAkxS4mK4Zdw05IJlPX2Q3zKObMs/HpOFlY0k0yor0jCsCUTRjsiB8eyTmUUvj1myuwdHs17jpnDE4c0QMje5V1yBtrQrIdiuck8ZJFNjBPGFRKYX1lLWqbgujduShObO6sboi8rmsKQsHZK12Q53MUJpWHmtAUCCeeMOihSUpzMOw4QdK44BvHsbv+t2bCYOyxoq/tmqQkErHp6pGSzHdeR/I8G3/3KZsw2CFvPUiu8f7y3Xhh7lbccPIwfO/EoZkOhxDSCiiekyTQgsxzKBzGip2HcO5fZzlu+9OXluDEET1QUVaII377EZqDYfz2/HG22/YsL3LMVtz4wkIAsSLTzj3h5qjo16UYAHDkoC7YvC9a37q8MA81TcGYba2NTyYN6hpdl7IJgwIRzbscO2HQiEFbNrp3eUqO5xW37H0cDptWlBVgr0vHyGwmZfcL1M4ky9lV3YD7P1yDkb3K8PPpIzMdDiGklVA8J4ldSblEhMLAPr2hSc/yQlTWNNluV9MYREVZYcQuYS5V948rj8So3uXwiaB356KYrO7QHqX46WkjcdOLiyLLzOuNDGBJQbTuslX4/d9Fh+O0Mb0AAIMrSvHJLSdjULcSvLJgBwDgoUsn4O+fbUBNZW3MfmYx+8UvTkH3smh3QbNtY+4d02zP2SsCLYNsV23D7xPMvu1UdC6ONplZ+MvT8fHKPfjFK0uTKi+YDEnZNhw2/fTnU1HfFEpRRO0DlfIJg6kZh5BMcKgxgGN/r3Wrve2s0SlLKhBCMgfFc5LYlZRzQpkyz4YgrihzFs9Wm4NZp4/oWYZhPcoi780icmL/LhhSURqzb2zmOV48W20bfToXx7TVNo5lCNShFWW2NgzzcawdscxZ6V4eO/E54dO7++XF2DaiMfTVs+UG3UoLUFFu3yY8VSTV9MVheaeifHSydJbMFVJlt6B2JtnMv+dtjbyeNrpnBiMhhKQKiuckaWm1jaagll00Wl/bjx0rzM0TBq0e6ZjshcRXu7CbMFhSED22NfPsNOnOiMDvE9t6ym6+5lRO5LNW9/AaA5A+z3MydKRJQdEmKakZryN9diR3qG8O4tZXluGtJTtxwvAK/Pq8sRjRq22tZYSQ9EDxnCTJ2DaMLcNhFck8d3IRz9bJiOYJg3Hi2fReIHFC1a7Oc4xtwzKeU2UMIwSfiG05OrdybVY/dGvQBJSyPV4yJeMyRRaEmHJYqo50ZF5ZuANvLdmJb0zoi1vPGh2ZS0IIyX4onpMkOduGOfOs7Vfu8ojeKsxDLpnnOPFrEap5NraN0sLor9tqOXAWulFfcYxgd8kER8ZMYebZOIxtw5csUKYdqWJEtApKasZj4plkG2t21+BfX27CiJ5l+PNlE/n0hJAcg+I5SZIpVRetthHNPJcVumWenW0bVnFrzhSLAH6LUDWLY8MO4jZh0EmARn3F9m2w3YRrquo8A5r4FEm+1Xh7oSN+d6bO89wBPzyStRxqDODCf85Gnl/w4CUTKJwJyUEonpMkmVJ1RgYuFFZQysg8u3menW0b1sSw37RAEN8K25wlrm/W/NYxEwYt13OnFtdR/2qsbcMQNK6e5xTaNnzifCyn41B0ZQbjb0ZS9Oun9iDZxIcr9qC2KYhXfnAsJg3qlulwCCFpgDVzksSr5zkQCkeytjWNwciEQXfbRqwwr2mM1lSOyzy7TSBErLiu02szlxa42DYcPc9R24ZdJtmt4kRqbRvimGFOpNHTVKkuKTqiAOyAp0wIPltTid6dinDkwK6JNyaEZCU5n3l+6stNuPutlfjr5UdE6iB3Ls5Hp+I8fPGLU5Me7+on50Ven3N4H/z9iiOxoaoW0x6YiWevnYITR/SAUgqn3D8j0lDkb5+tj+xTVuiPG9NgxtoqXProV5H3T8zaFHkdX20j1rZRaLFUmHWrIdiH9YyWurNmcYvz7eMKmyYMDqkoA7AnNg63ToUtqGfqk+gxYxDnpiROmecuJdp5D+peYru+pXQqysOhxmDiDU10qA6Dpr+ZVNCBPjqS5SilsGDzARw1pBvtGoTkMDkvnh/5fCMA4Mkvo0K0uiGA6oaA5zHCDj7nd5buwt+vAOZs2AcAeG/5bpw4ogeagmFsP9CA08b0wseromKzMM8X8Q37BDhrfB+8s2xXZP0rC7Y7xmAVqXm+WAtFaWEeHr5qEm54bgEAwG8SrmeM64VHvjUp0gQFiJatKy/Kw70XjI+rk2xgzjzfMn0kPly5Gxur6uImDNpZJMyl8Zx498cnxthJZt16qm0dbJ+Iow3AKSN9xMCueOKayTh+eEXCOJLho5+djO0HGhJvaKIjfo2mrElKKz+9j392cqReOSHpZMfBBuw+1IjJg5h1JiSXyXnbhvG1m8Q8PwCI6UoXSvDFa0wGNDKtht3i5JGxoq0gz4fCPE0onjSyB6aP6xWz3m0yYqLMMwCcOb43SnUhGlsZQ3DGuN4xYxj1pg/r1xnnT+znen7G8fP9vhgBbo5L2VRTdvN3G4zt2wmDTQ1e+nYpxsQBXeK2E3Fu9+02YXDamF4ocsiqt5RenYpi2pB7oSNmoVI2YbCVwwzvWYaRrK9L2oAFWw4AQNLXB0JIdpHz4tmgKZBcC2RzmbhQAuVtlKErzDfEs5bVtjZEMWeegfjH2m6TEd1K1dmJCyeLg4FRb7qu2f1ziUz+sgxnvHWzbXgRz17xiTjaABI1SWkPtP8IU0/qMs+EZAfzNx9AaYEfo3vzZo2QXCbnxbMh/ozssBnrBL2YdSbBnOiRrzF2oSXzXF4YOzmwMM8f4wO2ikG3yYhxHQFjBGNslhlIXL7N8EEbkwkdMUrV6eMqy2dhTEy0yzK6leVLFrdqGyxV1z5JmXjuiB8eyTqUUvhiXRUmDe7m+JSMEJIbdJj/4U024rnWRTiaBXOizHNzSMveGlllY1xr5rUgzxfbNtuiCdwasMRXxzB5nk2rDHGbqNKFEVsi8Wxuz20bl8thUvsF4lxtI1GWvT3QEQVgyiYMpmQUQtLL15sPYPO+epxzWO9Mh0IISTMZFc8icqaIrBGR9SJyW1qOof80SsWZqXGpmGDOPNtlrc00BbT1hkAybBvWsnTWzKlVUFnrPLuRyKqQSLgYWeFE4tm4iXArSdcW+MRFwGdB5rkjkqrfSge87yBZRkNzCD99aTH6di7CWYf1yXQ4hJA0kzHxLCJ+AH8HcBaAsQAuF5Gx6Tregfr46hpu4jlkErJ2WWuD5mAYjbowN7YzyphZM89WT3NrNF+M59lmfSJxbQj7+kSeZ4ttI3LMNhY0PpGs8DaTKKkrVcffO2nfPDxzA3YcbMCfLjsCnVxq+RNCcoNMZp6nAFivlNqolGoG8G8A56f6IEYG2c56YWSI7TBX2HATz7VNQdTqYtnIbtc6iGfrOK0RF/kOtg2DxJ5nLbZE7caNKhrGMTJV8UtcMs+kfULNSzoChxoDeOTzDTjn8D6YMoQdBQnpCGSyznM/ANtM77cDODrVB3GzJXzvmfmR7HPP8sKIRaFzcT66lxZGtjvl/hmOY0x7YAbqmjTR/MjMjXhk5kYcNVgrU2SdMFeY54tU5OhSnJ+wM54bnYuj2Y2ywvhMRyLPs1G+rSDPPYjupYXYcbAhIvRL9XMq1ms4G77mrqUFHiNvGW4dBtszxfl+NCRZ6SXb6VqSjwP1gZRnjDulsHoLaRkiMgDAMwB6QZsS8ahS6s+ZjSpzVDcEcPqDM9EYCOPbxw3OdDiEkDai3X8bich1AK4DgIEDBya1r1IKF08egKdmb44su/GUYahvDkEp4KuN+7B6dw0AYF9dMy47agB2HmzAZ2uqsKGqLmasbx83GJ2K8rBhbx3eWao1NrloUv9IZ7/n526NbPv15gMoKfAjz+/Dw1cdiU7F+fh0VSVOGtkDxw7tjrvOGYOLJw/Awq0HHGPv37UYD106EV9t2IdBpjrIBt87cUjkHL934tC49V6y2n+6dCLG9+vkus2/rzsGszfsjYjtH0wdhuICPy4/agAAoF+XYvz2/HGYPs5+ksx/bjg2cUUPj1jF88c/Owkrdh5Kydjp4t2fnIhFLr/nXOSNG0/AvM37Uzrm/RdPiNyUkowSBHCLUmqhiJQDWCAiHymlVmY6sEzw6sLtkaZOR9jUpyeE5CaZFM87AAwwve+vL4tBKfUogEcBYPLkyUmZBkQEd39jHE4cUYFrn54PAPifM0ZH1j/44ZqIeC7M8+F33zwMX23ch8/WVMWM0720AHd/YxwAYLNJPP/hwsMjgs4snoFo1vnM8drkkeOGRRumGGLXTuAO7VGKjVV1+NEpw3HU4G44arD9Y8DCPD9uPGW447k7taw2c8ERiZujDOhWgku7RW9aivL9uOHkYTHbfOvYwY77O8WfLD5fvI97eM9yDO/ZvuupDqkoxRCbm59cZmD3EgxMcUv0iyb1T+l4pGUopXYB2KW/rhGRVdCeInY48VzXFMTzc7eiMM+Hf193DMvTEdKByOT/9q8BjBCRISJSAOAyAG+m40DWqhcG1iYmgH1tYnPG07A5lBb4XW0EXhqE2O3erUSzP7T2QpyNFgc3fCKsqkFIO0JEBgM4AsDcDIeSER74cC02VNXi0asn44iBfCpCSEciY5lnpVRQRH4E4AMAfgBPKqVWpONYTs067ES13Uxpc8bTsGk4CXK3sa3Y1Scu1ttr5yfwLCccO8eEpiA7OgkS0hEQkTIArwC4WSl1yLKuxVa7bOGLdVV4avYmXHbUQJw8skemwyGEtDEZ9Twrpd4F8G66j+OUBbZbbrfMnAUuiIhn94/OS+bZbkJVse4tbq34zTXxnK0TBgnJNUQkH5pwfl4p9ap1fWusdtnCwzM3oG+XYvzy3DGZDoUQkgE6hEnLqe6mXUbazsqRZ2PbsNvOTEttG0bm2a1VtxdyLUvLUnWEZB7R7vifALBKKfVgpuNpa5RSePyLjZizYR++eUQ/lBS0+zn3hJA00CH+5zsJXTtrRb6N1zjG8+z3aNuwKR9nxc7DW5SniefWljfLNaEpIvC3prYfISQVHA/gWwCWichifdkd+lPEnGZ9ZQ0Wb6vGve+swskje+C7xw/JdEiEkAzRIcSzk5D0kh0GYm0bIoKCPF9KbBtumeeGBJ3/EpFr4tknuZdNJyTbUErNQuo6r2cFby3ZiY9X7cEbi3cCAHp3KsK/vn0UJzAT0oHpEOLZCbPAdBNm1nWFfh/KHSYhGiSydQD2nucSXTy7dTX0Qq4JTZ9Iyto9E0JIImoaA3jsi034yyfrIsmQ3p2KcP3JQymcCengdBjxfNc5YzC0R2y93SHdS3HNsYOw7UADfnb6yJhtP1tTiYVbDqIhEIrL4t4wdRiOGNglZtmj35qEl77ehoDe7vrU0T0TxmQWg3eePQYjepXhyEFdUVXThKuOad0s9Vy7uF91zCBUlKW3iyEhhADA3tomnPfXWdhV3QgAeO7aozGBTVAIITodRjzbduHzCe45f7zttt87cShmrq3CNU/OiysbZ9ecZPq43o5d9pww69vvnxSN7/8unpDUOHbkWub5qmMGZToEQkgHYMu+Opz6wEwAwEvXHYN+XYvRv2tqm/4QQrKbDiOeW4JRh9lLt76WkE4bQq55ngkhpC14Z9kuhMIKf7zwcBw9tHumwyGEtENYvsCFkNIsGHmtbFjiRDotvBTPhBCSHNv21+OZ2Vswrm8nXHLUgEyHQwhpp1A8uxAKa5P20mWBYOaZEELaB+Gwwnef+hr1zUHceuboTIdDCGnHUDy7YDQqSVd94XQK3HRZTQghJBdZV1mLdZW1uP3sMTiJLbcJIS5QYbkQ1CtnpC/znJZhATDzTAghyTB30z4AwPHDKjIcCSGkvUPx7EJEPKfN85w+gUvtTAgh3giGwnh2zhYMrSjFgG7FmQ6HENLOoXh2IRjKXs9zOoU5IYTkEh+s2IN1lbW4ZfooXjsJIQmheHbh5JE90KdzEW6YOiwt46dDkz9wyQSM6lWO4nx/6gcnhJAco7o+gAc+WoMB3Ypx5vjkavUTQjomrPPsQveyQsy5fVraxk9H5vnM8X1w5vg+KR+XEEJykZtfWqSVqPvu0ZwrQgjxBDPPGYRPBwkhJHMs3X4Qn62pws+nj8Kxw9gQhRDiDYrnDJJOzzMhhBBnmoNh3PLyEnQpycflRw/MdDiEkCyCto0MQvFMCCGZ4d1lu7CushaPfGsSOhXlZzocQkgWwcxzBqG9jhBC2p6qmib89u2VGNmrDKeP6ZXpcAghWQYzzxmEJZEIIaRt2VBVi2kPzAQAvPD9Y+BjFoMQkiQUzxmEM7sJIST1BEJhCIAD9QF8vXk/fIJIFaInZ20CAJx9WG+M6l2ewSgJIdkKxXMGoXYmhJDUsXVfPVbtPoR73lyBndWNMet6lhdieM8yfLVxH86b0Bd/vnRiZoIkhGQ9FM8ZhLYNQghJHd/4+ywcrA8AAE4YXoGpo3qgR3khfvLvxaisaUIgFMY5h/fFHWePpl2DENJiKJ4zCK/dhBDSepRSuO+91RHhfPd5Y/Ht44dE1g+tKEOn4jwM6l6aqRAJITkExXMGYak6QghpHY2BEH7x36V4c8lOXDSpP35z/jiUFMR+tR3Wv3OGoiOE5CIUzxmE4pkQQlrOwq0HcMVjX6ExEMaPp43AzdNG0I5BCEk7FM8ZhNqZEEJaxq7qBnz/6fnoUlyAuy8dhzPH9850SISQDgLFcwZh5pkQQpJHKYXfvLUStU1BvPuTEzGsR1mmQyKEdCDYYTCD8OkiISTbEJEzRWSNiKwXkdtSPf7B+mYEQ2HbdcFQGM/P3YJLH/0K7y3fjZ+cNoLCmRDS5jDznEGYeSaEZBMi4gfwdwCnA9gO4GsReVMptTJVx7jl5SXYcbABvzpvLI4bVhFZPmNNJX7w3EI0BELo37UYt5w+Ej84eViqDksIIZ6heM4g1M6EkCxjCoD1SqmNACAi/wZwPoCUiGelFC6a1B/3vrMKVzw2F3k+wXkT+uLoId1w/4drke8X/PmySTh9bC/WySeEZAyK5wxiXPy/MaFvhiMhhBBP9AOwzfR+O4CjzRuIyHUArgOAgQMHJjW4iOCsw/rglNE98dLX27B0ezVeWbgdry3agTF9OuHBSyZgTJ9OrTwFQghpHRTPGWbJr6ejpMCf6TAIISQlKKUeBfAoAEyePFm1ZIyifD+uOW4wAOCmU4ejIRDCyF7l8HOiCCGkHUDxnGE6F+dnOgRCCPHKDgADTO/768vSxuAKdgUkhLQvWG2DEEKIV74GMEJEhohIAYDLALyZ4ZgIIaRNYeaZEEKIJ5RSQRH5EYAPAPgBPKmUWpHhsAghpE2heCaEEOIZpdS7AN7NdByEEJIpMmLbEJG7RWSHiCzW/52diTgIIYQQQghJhkxmnh9SSt2fweMTQgghhBCSFJwwSAghhBBCiEcyKZ5/JCJLReRJEemawTgIIYQQQgjxRNrEs4h8LCLLbf6dD+CfAIYBmAhgF4AHXMa5TkTmi8j8qqqqdIVLCCGEEEJIQtLmeVZKneZlOxF5DMDbLuO0ulsVIYQQQgghqSBT1Tb6mN5+E8DyTMRBCCGEEEJIMohSbZ/MFZFnoVk2FIDNAK5XSu3ysF8VgC0tOGQFgL0t2K+9kmvnA/CcsoFcOx+gbc9pkFKqRxsdq13Qimt2psjFv3E7eJ65Bc8zfdhetzMintsaEZmvlJqc6ThSRa6dD8BzygZy7XyA3Dwn0nI6yt8DzzO34Hm2PSxVRwghhBBCiEcongkhhBBCCPFIRxHPj2Y6gBSTa+cD8JyygVw7HyA3z4m0nI7y98DzzC14nm1Mh/A8E0IIIYQQkgo6SuaZEEIIIYSQVpPT4llEzhSRNSKyXkRuy3Q8XtFblleKyHLTsm4i8pGIrNN/dtWXi4j8RT/HpSJyZOYit0dEBojIZyKyUkRWiMhP9OXZfE5FIjJPRJbo53SPvnyIiMzVY39JRAr05YX6+/X6+sEZPQEHRMQvIotE5G39fbafz2YRWSYii0Vkvr4sa//uSMvJteuqE7l4vbUjV6/BTuTatdmObLpe56x4FhE/gL8DOAvAWACXi8jYzEblmacAnGlZdhuAT5RSIwB8or8HtPMbof+7Dlrr8/ZGEMAtSqmxAI4BcKP+u8jmc2oCcKpSagK0muVnisgxAP4A4CGl1HAABwBcq29/LYAD+vKH9O3aIz8BsMr0PtvPBwBOUUpNNJU4yua/O9JynkJuXVedyMXrrR25eg12IhevzXZkx/VaKZWT/wAcC+AD0/vbAdye6biSiH8wgOWm92sA9NFf9wGwRn/9CIDL7bZrr/8AvAHg9Fw5JwAlABYCOBpaAfc8fXnkbxDABwCO1V/n6dtJpmO3nEd/aBenUwG8DUCy+Xz02DYDqLAsy4m/O/5r0d9Dzl5XXc45p663DueYE9dgl/PLuWuzw3lmzfU6ZzPPAPoB2GZ6v11flq30UtEujLsB9NJfZ9V56o+QjgAwF1l+TvpjtMUAKgF8BGADgINKqaC+iTnuyDnp66sBdG/TgBPzJwC/ABDW33dHdp8PoHUx/VBEFojIdfqyrP67Iyklp/8Wcul6a0cOXoOd+BNy79psR9Zcr/Pa6kAkdSillIhkXZkUESkD8AqAm5VSh0Qksi4bz0kpFQIwUUS6AHgNwOjMRtRyRORcAJVKqQUiMjXD4aSSE5RSO0SkJ4CPRGS1eWU2/t2R9JBrfwu5dr21I5euwU7k8LXZjqy5Xudy5nkHgAGm9/31ZdnKHhHpAwD6z0p9eVacp4jkQ7uQP6+UelVfnNXnZKCUOgjgM2iPzrqIiHFTao47ck76+s4A9rVtpK4cD+AbIrIZwL+hPR78M7L3fAAASqkd+s9KaF+uU5Ajf3ckJeTk30IuX2/tyJFrsBM5eW22I5uu17ksnr8GMEKfkVoA4DIAb2Y4ptbwJoBr9NfXQPOxGcuv1meeHgOg2vSIo10gWsrjCQCrlFIPmlZl8zn10LMdEJFiaJ7CVdAu4Bfpm1nPyTjXiwB8qnSjVntAKXW7Uqq/UmowtP8rnyqlrkSWng8AiEipiJQbrwFMB7AcWfx3R1JOzv0t5OL11o5cuwY7kYvXZjuy7nqdCVN4W/0DcDaAtdB8UHdmOp4k4n4RwC4AAWg+nmuheZY+AbAOwMcAuunbCrSqIhsALAMwOdPx25zPCdC8TEsBLNb/nZ3l53Q4gEX6OS0H8Ct9+VAA8wCsB/AfAIX68iL9/Xp9/dBMn4PLuU0F8Ha2n48e+xL93wrjGpDNf3f816q/h5y6rrqcZ85dbx3OM2evwS7nnBPXZodzy6rrNTsMEkIIIYQQ4pFctm0QQgghhBCSUiieCSGEEEII8QjFMyGEEEIIIR6heCaEEEIIIcQjFM+EEEIIIYR4hOKZZA0iEhKRxaZ/tyXY/gYRuToFx90sIhUt2O8MEblHRLqJyHutjYMQQrIJXrNJrsL23CSbaFBKTfS6sVLq4TTG4oUToRWyPxHArAzHQgghbQ2v2SQnYeaZZD16luGPIrJMROaJyHB9+d0i8nP99Y9FZKWILBWRf+vLuonI6/qyr0TkcH15dxH5UERWiMjj0IqxG8e6Sj/GYhF5RET8NvFcKiKLAfwYwJ8APAbgOyKSzR0uCSEkJfCaTbIdimeSTRRbHgFealpXrZQ6DMDfoF38rNwG4Ail1OEAbtCX3QNgkb7sDgDP6Mt/DWCWUmocgNcADAQAERkD4FIAx+vZlBCAK60HUkq9BOAIAMv1mJbpx/5Gy0+dEEKyDl6zSU5C2wbJJtweAb5o+vmQzfqlAJ4XkdcBvK4vOwHAhQCglPpUz150AnASgP+nL39HRA7o208DMAnA1yICAMUAKh3iGQlgo/66VClVk+jkCCEkx+A1m+QkFM8kV1AOrw3OgXaBPQ/AnSJyWAuOIQCeVkrd7rqRyHwAFQDyRGQlgD76I8GblFJftOC4hBCSa/CaTbIW2jZIrnCp6ecc8woR8QEYoJT6DMCtADoDKAPwBfRHeCIyFcBepdQhAJ8DuEJffhaArvpQnwC4SER66uu6icggayBKqckA3gFwPoA/ArhTKTWRF2FCCInAazbJWph5JtlEsZ4NMHhfKWWUPuoqIksBNAG43LKfH8BzItIZWibiL0qpgyJyN4An9f3qAVyjb38PgBdFZAWA2QC2AoBSaqWI3AXgQ/3iHgBwI4AtNrEeCW3yyQ8BPNiKcyaEkGyF12ySk4hSdk9LCMkeRGQzgMlKqb2ZjoUQQog7vGaTbIe2DUIIIYQQQjzCzDMhhBBCCCEeYeaZEEIIIYQQj1A8E0IIIYQQ4hGKZ0IIIYQQQjxC8UwIIYQQQohHKJ4JIYQQQgjxCMUzIYQQQgghHvn/sXDtrQjYNmIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_scores(scores: [int], sma_window: int = 50) -> None:\n",
    "    \"\"\"\n",
    "    Plots a line plot of the scores.\n",
    "    The function expects the score of the first episode at scores[0] and the last episode at scores[-1]\n",
    "    :param scores:\n",
    "    :param sma_window: Simple Moving Average rolling window\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    # calculate moving average of the scores\n",
    "    series: pd.Series = pd.Series(scores)\n",
    "    window = series.rolling(window=sma_window)\n",
    "    scores_sma: pd.Series = window.mean()\n",
    "\n",
    "    # plot the scores\n",
    "    fig = plt.figure(figsize=(12, 5))\n",
    "\n",
    "    plot1 = fig.add_subplot(121)\n",
    "    plot1.plot(np.arange(len(scores)), scores)\n",
    "    plot1.set_ylabel('Score')\n",
    "    plot1.set_xlabel('Episode #')\n",
    "    plot1.set_title(\"Raw scores\")\n",
    "\n",
    "    plot2 = fig.add_subplot(122)\n",
    "    plot2.plot(np.arange(len(scores_sma)), scores_sma)\n",
    "    plot2.set_ylabel('Score')\n",
    "    plot2.set_xlabel('Episode #')\n",
    "    plot2.set_title(f\"Moving Average(window={sma_window})\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_scores(scores=scores)\n",
    "\n",
    "env.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "drlnd",
   "language": "python",
   "name": "drlnd"
  },
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}