{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=top></div>\n",
    "\n",
    "# Reinforcement Learning with Doom - Increasing complexity and monitoring the model\n",
    "\n",
    "Leandro Kieliger\n",
    "contact@lkieliger.ch\n",
    "\n",
    "---\n",
    "## Description\n",
    "\n",
    "In this notebook we are going to build upon the setup introduced in the previous part of this series. We will tackle a more difficult scenario, add useful logging to the learning process and finally start competing against in-game bots in a first attemps at playing a deathmatch game using reinforcement learning.\n",
    "\n",
    "The notebook is structured in 3 parts:\n",
    "\n",
    "\n",
    "### [Part 1 - Increasing complexity](#part_1)\n",
    "* [Defend the center](#defend_the_center)\n",
    "* [Defend the center (harder)](#defend_the_center_hard)\n",
    "\n",
    "    \n",
    "### [Part 2 - Monitoring the model](#part_2)\n",
    "* [Adding hooks](#monitoring)\n",
    "* [Monitoring callback](#callback)\n",
    "* [Adding normalization](#normalization)\n",
    "* [Comparing norms](#norm_comparison)\n",
    "    \n",
    "    \n",
    "### [Part 3 - Playing doom deathmatch](#part_3)\n",
    "* [Scenario presentation](#deathmatch_presentation)\n",
    "* [New environment](#deathmatch_environment)\n",
    "* [Discussion](#deathmatch_discussion)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=part_1></div>\n",
    "\n",
    "# [^](#top) Part 1 - Increasing complexity\n",
    "\n",
    "\n",
    "## Preparations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "import cv2\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch as th\n",
    "import typing as t\n",
    "import vizdoom\n",
    "from stable_baselines3 import ppo\n",
    "from stable_baselines3.common.callbacks import EvalCallback\n",
    "from stable_baselines3.common import evaluation, policies\n",
    "from torch import nn\n",
    "\n",
    "from common import envs, plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=defend_the_center></div>\n",
    "\n",
    "## New scenario: Defend The Center\n",
    "\n",
    "The next scenario we are going to tackle is called \"Defend the center\". In this scenario, the agent is stuck in the center of a circular arena and will be attacked by monsters spawning at random intervals and locations. Here are the rewards for this scenario:\n",
    "\n",
    "* 1 point for each ennemy killed.\n",
    "* -1 point for dying.\n",
    "\n",
    "Since there is a limit on the total ammunition of the agent, 26, the theoretical maximum reward achievable for this scenario is 25. The buttons available are `ATTACK`, `TURN_LEFT` and `TURN_RIGHT`. \n",
    "\n",
    "We are going to define a little helper function that will streamline the training and evaluation process as we will need to repeat it several time in this notebook. The function simply create the environments, instantiate an agent based on the PPO algorithm and start training and optionally evaluating the agent for a given number of steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solve_env(env_args, agent_args, n_envs, timesteps, callbacks, eval_freq=None, init_func=None):\n",
    "    \"\"\"Helper function to streamline the learning and evaluation process.\n",
    "    \n",
    "    Args:\n",
    "         env_args:    A dict containing arguments passed to the environment.\n",
    "         agent_args:  A dict containing arguments passed to the agent.\n",
    "         n_envs:      The number of parallel training envs to instantiate.\n",
    "         timesteps:   The number of timesteps for which to train the model.\n",
    "         callbacks:   A list of callbacks for the training process.\n",
    "         eval_freq:   The frequency (in steps) at which to evaluate the agent.\n",
    "         init_func:   A function to be applied on the agent before training.\n",
    "    \"\"\"\n",
    "    # Create environments.\n",
    "    env = envs.create_vec_env(n_envs, **env_args)\n",
    "\n",
    "    # Build the agent.\n",
    "    agent = ppo.PPO(policies.ActorCriticCnnPolicy, env, tensorboard_log='logs/tensorboard', seed=0, **agent_args)\n",
    "    \n",
    "    # Optional processing on the agent.\n",
    "    if init_func is not None: \n",
    "        init_func(agent)\n",
    "        \n",
    "    # Optional evaluation callback.\n",
    "    if eval_freq is not None:\n",
    "        eval_env = envs.create_eval_vec_env(**env_args)\n",
    "\n",
    "        callbacks.append(EvalCallback(\n",
    "            eval_env, \n",
    "            n_eval_episodes=10, \n",
    "            eval_freq=eval_freq, \n",
    "            log_path=f'logs/evaluations/{env_args[\"scenario\"]}',\n",
    "            best_model_save_path=f'logs/models/{env_args[\"scenario\"]}'))\n",
    "\n",
    "    # Start the training process.\n",
    "    agent.learn(total_timesteps=timesteps, tb_log_name=env_args['scenario'], callback=callbacks)\n",
    "\n",
    "    # Cleanup.\n",
    "    env.close()\n",
    "    if eval_freq is not None: eval_env.close()\n",
    "    \n",
    "    return agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we configure the environments like we have seen in the [previous notebook](https://github.com/lkiel/rl-doom/blob/develop/standalone_examples/Basic%20Scenario.ipynb). We will be training for only 100k steps as this is already enough to reach a good score in this scenario. Don't forget to specify the frame skip parameter as we have seen that this is one of the most efficient way to speed up the learning process along with the learning rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Results in a 100x156 image, no pixel lost due to padding with the default CNN architecture\n",
    "frame_processor = lambda frame: cv2.resize(frame[40:, 4:-4], None, fx=.5, fy=.5, interpolation=cv2.INTER_AREA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eval num_timesteps=4096, episode_reward=-1.00 +/- 0.00\n",
      "Episode length: 72.80 +/- 7.95\n",
      "New best mean reward!\n",
      "Eval num_timesteps=8192, episode_reward=-0.50 +/- 0.81\n",
      "Episode length: 78.10 +/- 15.14\n",
      "New best mean reward!\n",
      "Eval num_timesteps=12288, episode_reward=3.40 +/- 1.91\n",
      "Episode length: 139.10 +/- 43.52\n",
      "New best mean reward!\n",
      "Eval num_timesteps=16384, episode_reward=1.90 +/- 0.70\n",
      "Episode length: 110.20 +/- 6.78\n",
      "Eval num_timesteps=20480, episode_reward=9.40 +/- 7.14\n",
      "Episode length: 248.20 +/- 130.42\n",
      "New best mean reward!\n",
      "Eval num_timesteps=24576, episode_reward=9.30 +/- 4.88\n",
      "Episode length: 227.70 +/- 82.49\n",
      "Eval num_timesteps=28672, episode_reward=17.80 +/- 4.31\n",
      "Episode length: 400.10 +/- 93.08\n",
      "New best mean reward!\n",
      "Eval num_timesteps=32768, episode_reward=18.50 +/- 5.37\n",
      "Episode length: 404.40 +/- 106.92\n",
      "New best mean reward!\n",
      "Eval num_timesteps=36864, episode_reward=16.90 +/- 4.53\n",
      "Episode length: 370.10 +/- 94.13\n",
      "Eval num_timesteps=40960, episode_reward=19.50 +/- 2.01\n",
      "Episode length: 427.40 +/- 28.64\n",
      "New best mean reward!\n",
      "Eval num_timesteps=45056, episode_reward=19.50 +/- 1.20\n",
      "Episode length: 407.80 +/- 23.39\n",
      "Eval num_timesteps=49152, episode_reward=19.70 +/- 1.79\n",
      "Episode length: 406.10 +/- 31.34\n",
      "New best mean reward!\n",
      "Eval num_timesteps=53248, episode_reward=16.30 +/- 1.27\n",
      "Episode length: 342.70 +/- 29.71\n",
      "Eval num_timesteps=57344, episode_reward=18.50 +/- 2.11\n",
      "Episode length: 375.00 +/- 40.77\n",
      "Eval num_timesteps=61440, episode_reward=18.30 +/- 1.79\n",
      "Episode length: 357.50 +/- 24.90\n",
      "Eval num_timesteps=65536, episode_reward=19.40 +/- 2.11\n",
      "Episode length: 363.90 +/- 30.47\n",
      "Eval num_timesteps=69632, episode_reward=18.50 +/- 1.69\n",
      "Episode length: 362.10 +/- 37.28\n",
      "Eval num_timesteps=73728, episode_reward=17.10 +/- 2.21\n",
      "Episode length: 342.00 +/- 33.39\n",
      "Eval num_timesteps=77824, episode_reward=19.00 +/- 2.19\n",
      "Episode length: 346.60 +/- 25.57\n",
      "Eval num_timesteps=81920, episode_reward=18.90 +/- 2.70\n",
      "Episode length: 377.80 +/- 33.54\n",
      "Eval num_timesteps=86016, episode_reward=18.00 +/- 1.73\n",
      "Episode length: 347.80 +/- 23.25\n",
      "Eval num_timesteps=90112, episode_reward=18.80 +/- 2.23\n",
      "Episode length: 367.70 +/- 27.82\n",
      "Eval num_timesteps=94208, episode_reward=18.80 +/- 2.44\n",
      "Episode length: 356.70 +/- 38.54\n",
      "Eval num_timesteps=98304, episode_reward=20.90 +/- 1.64\n",
      "Episode length: 357.10 +/- 31.33\n",
      "New best mean reward!\n",
      "Eval num_timesteps=102400, episode_reward=18.80 +/- 1.89\n",
      "Episode length: 339.60 +/- 21.56\n",
      "Eval num_timesteps=106496, episode_reward=19.50 +/- 1.43\n",
      "Episode length: 342.50 +/- 25.11\n",
      "Eval num_timesteps=110592, episode_reward=19.40 +/- 2.15\n",
      "Episode length: 348.50 +/- 28.62\n",
      "Eval num_timesteps=114688, episode_reward=19.70 +/- 1.19\n",
      "Episode length: 333.40 +/- 16.79\n",
      "Eval num_timesteps=118784, episode_reward=21.60 +/- 2.62\n",
      "Episode length: 355.60 +/- 30.08\n",
      "New best mean reward!\n",
      "Eval num_timesteps=122880, episode_reward=20.10 +/- 1.30\n",
      "Episode length: 339.40 +/- 29.45\n",
      "Eval num_timesteps=126976, episode_reward=20.50 +/- 1.63\n",
      "Episode length: 337.50 +/- 19.14\n",
      "Eval num_timesteps=131072, episode_reward=18.70 +/- 1.27\n",
      "Episode length: 306.70 +/- 14.32\n",
      "Eval num_timesteps=135168, episode_reward=20.60 +/- 1.74\n",
      "Episode length: 329.50 +/- 18.01\n",
      "Eval num_timesteps=139264, episode_reward=18.80 +/- 1.33\n",
      "Episode length: 308.50 +/- 21.88\n",
      "Eval num_timesteps=143360, episode_reward=19.20 +/- 2.14\n",
      "Episode length: 314.00 +/- 22.63\n",
      "Eval num_timesteps=147456, episode_reward=18.20 +/- 1.17\n",
      "Episode length: 299.30 +/- 17.75\n",
      "Eval num_timesteps=151552, episode_reward=19.40 +/- 2.84\n",
      "Episode length: 336.90 +/- 41.69\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<stable_baselines3.ppo.ppo.PPO at 0x7fb2ffe58e20>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env_args = {'scenario': 'defend_the_center', 'frame_skip': 4, 'frame_processor': frame_processor}\n",
    "agent_args = {'n_epochs': 3, 'n_steps': 2048, 'learning_rate': 1e-4, 'batch_size': 32}\n",
    "\n",
    "solve_env(env_args, agent_args, n_envs=2, timesteps=150000, callbacks=[], eval_freq=2048)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that very quickly we reach satisfactory results. This is not surprising since the scenario is not much more difficult than the basic one we have seen in the previous notebook. Let's try to add some complexity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=defend_the_center_hard></div>\n",
    "\n",
    "# Defend the center (difficult version)\n",
    "\n",
    "\n",
    "Remember that our ultimate goal is to train an agent to play Doom deathmatch against bots. We will use the scenario we just solved as a good middle ground to perform some experiments before jumping to the more difficult task of playing against bots. **In general, it is often a good idea to start simple and progressively add complexity to the task.**\n",
    "\n",
    "The increased complexity here will arise from the fact that in a deathmatch environment, we will need to perform more actions than simply turning around and shooting. Here is the list of buttons we will be using:\n",
    "\n",
    "```\n",
    "ATTACK, TURN_LEFT, TURN_RIGHT, MOVE_FORWARD, MOVE_LEFT, MOVE_RIGHT\n",
    "```\n",
    "\n",
    "A simple solution would be to directly add more buttons to the config file. Although this will work, you will notice that the agent will be quite slow in the sense that he can only perform one action at a time. Either shoot, turn or move. Although this is not a big issue in the current scenario, when playing later against bots running all over the place our agent will be unfairly disadvantaged because of the limitations in its actions.\n",
    "\n",
    "![Agent 6 outputs](figures/deathmatch_agent_out=6.gif)\n",
    "\n",
    "VizDoom allows us to provide a list of button states but our model uses a discrete action space. A simple workaround is to generate all possible combination of buttons and use each combination as a single action. However, the number of such possible combination is $2^n$ where $n$ is the number of available buttons. Even is our simple case with only 6 buttons, this would mean having 64 possible outputs. To mitigate the combinatorial explosion of our action space, we are going to forbid certain combination. Indeed, it does not make much sense to allow for example both `TURN_RIGHT` and `TURN_LEFT` to be activated at the same time. Therefore, we will remove the following combinations:\n",
    "\n",
    "* `TURN_RIGHT` and `TURN_LEFT`\n",
    "* `MOVE_RIGHT` and `MOVE_LEFT`\n",
    "\n",
    "And we will also only allow the `ATTACK` button to be used alone. This will not hurt performance as most weapons in Doom have a cooldown period between two attacks anyway. In the end, the total number of different possible actions is given by the cartesian product of:\n",
    "\n",
    "```\n",
    "{ATTACK} + {TURN_RIGHT, TURN_LEFT, NOTHING} x {MOVE_RIGHT, MOVE_LEFT, NOTHING} x {MOVE_FORWARD, NOTHING}\n",
    "\n",
    "```\n",
    "Since we don't want the all-zero state (no button pressed) this will give us a grand total of 18 which is much better than the 64 we could have ended up with. Here is the code to generate the action space given a list of buttons and our exclusion lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Built action space of size 18 from buttons [<Button.ATTACK: 0> <Button.MOVE_FORWARD: 13> <Button.MOVE_LEFT: 11>\n",
      " <Button.MOVE_RIGHT: 10> <Button.TURN_LEFT: 15> <Button.TURN_RIGHT: 14>]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[[0.0, 0.0, 0.0, 0.0, 0.0, 1.0],\n",
       " [0.0, 0.0, 0.0, 0.0, 1.0, 0.0],\n",
       " [0.0, 0.0, 0.0, 1.0, 0.0, 0.0],\n",
       " [0.0, 0.0, 0.0, 1.0, 0.0, 1.0],\n",
       " [0.0, 0.0, 0.0, 1.0, 1.0, 0.0],\n",
       " [0.0, 0.0, 1.0, 0.0, 0.0, 0.0],\n",
       " [0.0, 0.0, 1.0, 0.0, 0.0, 1.0],\n",
       " [0.0, 0.0, 1.0, 0.0, 1.0, 0.0],\n",
       " [0.0, 1.0, 0.0, 0.0, 0.0, 0.0],\n",
       " [0.0, 1.0, 0.0, 0.0, 0.0, 1.0],\n",
       " [0.0, 1.0, 0.0, 0.0, 1.0, 0.0],\n",
       " [0.0, 1.0, 0.0, 1.0, 0.0, 0.0],\n",
       " [0.0, 1.0, 0.0, 1.0, 0.0, 1.0],\n",
       " [0.0, 1.0, 0.0, 1.0, 1.0, 0.0],\n",
       " [0.0, 1.0, 1.0, 0.0, 0.0, 0.0],\n",
       " [0.0, 1.0, 1.0, 0.0, 0.0, 1.0],\n",
       " [0.0, 1.0, 1.0, 0.0, 1.0, 0.0],\n",
       " [1.0, 0.0, 0.0, 0.0, 0.0, 0.0]]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import itertools\n",
    "import typing as t\n",
    "\n",
    "from vizdoom import Button\n",
    "\n",
    "\n",
    "# Buttons that cannot be used together\n",
    "MUTUALLY_EXCLUSIVE_GROUPS = [\n",
    "    [Button.MOVE_RIGHT, Button.MOVE_LEFT],\n",
    "    [Button.TURN_RIGHT, Button.TURN_LEFT],\n",
    "    [Button.MOVE_FORWARD, Button.MOVE_BACKWARD],\n",
    "]\n",
    "\n",
    "# Buttons that can only be used alone.\n",
    "EXCLUSIVE_BUTTONS = [Button.ATTACK]\n",
    "\n",
    "\n",
    "def has_exclusive_button(actions: np.ndarray, buttons: np.array) -> np.array:\n",
    "    exclusion_mask = np.isin(buttons, EXCLUSIVE_BUTTONS)\n",
    "    \n",
    "    # Flag actions that have more than 1 active button among exclusive list.\n",
    "    return (np.any(actions.astype(bool) & exclusion_mask, axis=-1)) & (np.sum(actions, axis=-1) > 1)\n",
    "\n",
    "\n",
    "def has_excluded_pair(actions: np.ndarray, buttons: np.array) -> np.array:\n",
    "    # Create mask of shape (n_mutual_exclusion_groups, n_available_buttons), marking location of excluded pairs.\n",
    "    mutual_exclusion_mask = np.array([np.isin(buttons, excluded_group) \n",
    "                                      for excluded_group in MUTUALLY_EXCLUSIVE_GROUPS])\n",
    "\n",
    "    # Flag actions that have more than 1 button active in any of the mutual exclusion groups.\n",
    "    return np.any(np.sum(\n",
    "        # Resulting shape (n_actions, n_mutual_exclusion_groups, n_available_buttons)\n",
    "        (actions[:, np.newaxis, :] * mutual_exclusion_mask.astype(int)),\n",
    "        axis=-1) > 1, axis=-1)\n",
    "\n",
    "\n",
    "def get_available_actions(buttons: np.array) -> t.List[t.List[float]]:\n",
    "    # Create list of all possible actions of size (2^n_available_buttons x n_available_buttons)\n",
    "    action_combinations = np.array([list(seq) for seq in itertools.product([0., 1.], repeat=len(buttons))])\n",
    "\n",
    "    # Build action mask from action combinations and exclusion mask\n",
    "    illegal_mask = (has_excluded_pair(action_combinations, buttons)\n",
    "                    | has_exclusive_button(action_combinations, buttons))\n",
    "\n",
    "    possible_actions = action_combinations[~illegal_mask]\n",
    "    possible_actions = possible_actions[np.sum(possible_actions, axis=1) > 0]  # Remove no-op\n",
    "\n",
    "    print('Built action space of size {} from buttons {}'.format(len(possible_actions), buttons))\n",
    "    return possible_actions.tolist()\n",
    "\n",
    "possible_actions = get_available_actions(np.array([\n",
    "    Button.ATTACK, Button.MOVE_FORWARD, Button.MOVE_LEFT, \n",
    "    Button.MOVE_RIGHT, Button.TURN_LEFT, Button.TURN_RIGHT]))\n",
    "\n",
    "possible_actions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is what a trained agent the uses the modified 18-output version navigate across the map. It looks much more dynamic and we can expect better results when competing in a deathmatch.\n",
    "\n",
    "![Agent 18 outputs](figures/deathmatch_agent_out=18.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Training the model in this more challenging environment will definitely require more training time. This is a good opportunity to log some metrics to help us monitor the training process."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=part_2></div>\n",
    "\n",
    "# [^](#top) Part 2 - Monitoring the model\n",
    "\n",
    "Stable-baselines already logs several useful metrics for us such as the value, policy or entropy losses, mean episode length and mean episode reward. The next most useful quantity to keep an eye on is the evolution of the model weights and activations. In particular, we'd like to make sure that our activations are well behaved. That is, they are not always zero (which would suggest we have dead neurons) and that the variance of each layer output stays away from zero as well. If this is not the case, we might end up with vanishing gradient issues and ultimately poor learning performance.\n",
    "\n",
    "I already mentioned the amazing course from FastAI's in the previous part of this series. We are going to implement several suggestions from the [10th lesson of the course](https://course19.fast.ai/videos/?lesson=10). Namely:\n",
    "\n",
    "* Activation layer monitoring with hooks\n",
    "* Kaiming initialization\n",
    "* Batch/Layer normalization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=monitoring></div>\n",
    "\n",
    "## Hooks\n",
    "\n",
    "Let's start by tracking neuron activations. This is particularly important for the first layers of our model. To do this, we will use FastAI's approach of defining hook wrappers. A hook is a function that can be attached to a specific layer of our model and that will be called for each forward pass. This is a feature offered by PyTorch and the idea is to build on top of that to keep track of useful statistics.\n",
    "\n",
    "We will combine this approach with Tensorboard ability to log tensors to get the distribution over time of our layer activations. Our hooks will contain a single attribute, `activation_data`, that will store the layer output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "from functools import partial\n",
    "\n",
    "class Hook:\n",
    "    \"\"\"Wrapper for PyTorch forward hook mechanism.\"\"\"\n",
    "    def __init__(self, module: nn.Module, func: t.Callable):\n",
    "        self.hook = None            # PyTorch's hook.\n",
    "        self.module = module        # PyTorch layer to which the hook is attached to.\n",
    "        self.func = func            # Function to call on each forward pass.\n",
    "        self.register()\n",
    "\n",
    "    def register(self):\n",
    "        self.activation_data = deque(maxlen=1024)\n",
    "        self.hook = self.module.register_forward_hook(partial(self.func, self))\n",
    "\n",
    "    def remove(self):\n",
    "        self.hook.remove()\n",
    "\n",
    "def store_activation(hook, module, inp, outp):\n",
    "    \"\"\"Function intented to be called by a hook on a forward pass.\n",
    "    \n",
    "    Args:\n",
    "        hook:    The hook object that generated the call.\n",
    "        module:  The module on which the hook is registered.\n",
    "        inp:     Input of the module.\n",
    "        outp:    Output of the module.\n",
    "    \"\"\"\n",
    "    hook.activation_data.append(outp.data.cpu().numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=callback></div>\n",
    "\n",
    "## Monitoring callback\n",
    "\n",
    "The second step is to define a callback that will periodically log hook data. For simplicity, we will only be logging in Tensorboard the latest activation value of each training phase. \n",
    "\n",
    "Of course, if you need more granularity, you can easily log more values. Keep in mind though that stable-baselines logger implementation aligns everything on the rollout time steps (which do not correspond to forward passes in training) when logging to Tensorboard. So you will need to do some adjustments there to either log to a file yourself or to adapt stable-baseline's implementation. You can also take a look at the [plotting helpers](common/plotting.py) which make use of the complete list of activation to create the diagnostic plots below.\n",
    "\n",
    "The callback will also compute and log some basic statistics:\n",
    "\n",
    "* The mean of each activation layer\n",
    "* The standard deviation of each activation layer\n",
    "* The proportion of activations that are between -0.2 and 0.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from stable_baselines3.common.callbacks import BaseCallback\n",
    "\n",
    "\n",
    "def get_low_act(data, threshold=0.2):\n",
    "    \"\"\"Computes the proportion of activations that have value close to zero.\"\"\"\n",
    "    low_activation = ((-threshold <= data) & (data <= threshold))\n",
    "    return np.count_nonzero(low_activation) / np.size(low_activation)\n",
    "\n",
    "\n",
    "# Callback for periodic logging to tensorboard.\n",
    "class LayerActivationMonitoring(BaseCallback):\n",
    "    \n",
    "    def _on_rollout_start(self) -> None:\n",
    "        \"\"\"Called after the training phase.\"\"\"\n",
    "        \n",
    "        hooks = self.model.policy.features_extractor.hooks\n",
    "        \n",
    "        # Remove the hooks so that they don't get called for rollout collection.\n",
    "        for h in hooks: h.remove() \n",
    "\n",
    "        # Log last datapoint and statistics to tensorboard.\n",
    "        for i, hook in enumerate(hooks):\n",
    "            if len(hook.activation_data) > 0:\n",
    "                data = hook.activation_data[-1]\n",
    "                self.logger.record(f'diagnostics/activation_l{i}', data)\n",
    "                self.logger.record(f'diagnostics/mean_l{i}', np.mean(data))\n",
    "                self.logger.record(f'diagnostics/std_l{i}', np.std(data))\n",
    "                self.logger.record(f'diagnostics/low_act_prop_l{i}', get_low_act(data))\n",
    "\n",
    "    def _on_rollout_end(self) -> None:\n",
    "        \"\"\"Called before the training phase.\"\"\"\n",
    "        for h in self.model.policy.features_extractor.hooks: h.register()\n",
    "\n",
    "    def _on_step(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we define a function that will attach hooks to every activation layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def register_hooks(model):\n",
    "    model.policy.features_extractor.hooks = [\n",
    "        Hook(layer, store_activation)\n",
    "        for layer in model.policy.features_extractor.cnn\n",
    "        if isinstance(layer, nn.ReLU) or isinstance(layer, nn.LeakyReLU)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's observe the behaviour of the model using our new logging mechanism. We train the model for a few steps and let the hook collect the activations during the forward passes. Note that for the PPO algorithm, we first need to collect a rollout sample using the current policy before any training can take place. Logging those activation is not very useful as the layer weights are not being updated yet. This is why we detach and reattach the hooks in the `_on_rollout_start` and `_on_rollout_end` functions respectively from the callback above. \n",
    "\n",
    "The helper function below will simply extract the list of layer outputs collected by the hook, compute and then plot some statistics. Using the idea presented in FastAI's course, it will also plot an histogram of the layer activations. The horizontal axis represents training steps (processing of one minibatch), in chronological order from left to right. The vertical axis represents the histogram bins from -7 to 7 (bottom to top). Brighter regions indicate larger histogram frequencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Train for a few steps to collect the activations.\n",
    "agent = solve_env(env_args, agent_args, 1, 1024, [LayerActivationMonitoring()], init_func=register_hooks)\n",
    "\n",
    "# Plot statistics.\n",
    "plotting.plot_activations(agent.policy.features_extractor.hooks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We notice at the beginning of the training phase several potential issues. First, the variance of the output of each layer is very close to zero and there is a noticeable decrease between the first and the last layer. Also, almost all the outputs are near zero which can be seen both on the graph showing the proportion of small activations over time and the activation histogram.\n",
    "\n",
    "In addition to using LeakyReLU instead of ReLU and following FastAI's recommendation, we will perform two changes:\n",
    "\n",
    "1. Use Kaiming initialization\n",
    "2. Use some normalization (layer norm in our case)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_net(m: nn.Module):\n",
    "    if len(m._modules) > 0:\n",
    "        for subm in m._modules:\n",
    "            init_net(m._modules[subm])\n",
    "    elif isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):\n",
    "        nn.init.kaiming_normal_(\n",
    "            m.weight, \n",
    "            a=0.1,         # Same as the leakiness parameter for LeakyReLu.\n",
    "            mode='fan_in', # Preserves magnitude in the forward pass.\n",
    "            nonlinearity='leaky_relu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=normalization></div>\n",
    "\n",
    "## Normalization\n",
    "\n",
    "To add layer normalization, we need to redefine a model. We will then tell stable-baselines to use our customized model instead of the default one. For the sake of brevity, sizes for the different layers of our model have been hardcoded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from stable_baselines3.common.torch_layers import BaseFeaturesExtractor\n",
    "\n",
    "class CustomCNN(BaseFeaturesExtractor):\n",
    "    def __init__(self, observation_space: gym.spaces.Box, features_dim: int = 128, **kwargs):\n",
    "        super().__init__(observation_space, features_dim)\n",
    "\n",
    "        self.cnn = nn.Sequential(\n",
    "            nn.LayerNorm([3, 100, 156]),\n",
    "            \n",
    "            nn.Conv2d(3, 32, kernel_size=8, stride=4, padding=0, bias=False),\n",
    "            nn.LayerNorm([32, 24, 38]),\n",
    "            nn.LeakyReLU(**kwargs),\n",
    "            \n",
    "            nn.Conv2d(32, 64, kernel_size=4, stride=2, padding=0, bias=False),\n",
    "            nn.LayerNorm([64, 11, 18]),\n",
    "            nn.LeakyReLU(**kwargs),\n",
    "            \n",
    "            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=0, bias=False),\n",
    "            nn.LayerNorm([64, 9, 16]),\n",
    "            nn.LeakyReLU(**kwargs),\n",
    "            \n",
    "            nn.Flatten(),\n",
    "        )\n",
    "\n",
    "        self.linear = nn.Sequential(\n",
    "            nn.Linear(9216, features_dim, bias=False),\n",
    "            nn.LayerNorm(features_dim),\n",
    "            nn.LeakyReLU(**kwargs),\n",
    "        )\n",
    "\n",
    "    def forward(self, observations: th.Tensor) -> th.Tensor:\n",
    "        return self.linear(self.cnn(observations))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's collect some data again but this time using the modified model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAI4CAYAAAB3HEhGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOy9e5wlVXXo/11V55x+TU/3vBgeMzK81IjCKCjK1WQ0KspVMTcaIGIEotzIBZNojP5uREeCCXqNIZHkCrkR8QUYjIrvJ61ilDfiCMhjHGCGAeY9/e5zTu3fH7uqzq59qk53z3T36Zle38/ndFftx9pr713n1F619t4lxhgURVEURVEURVGU/SdotwKKoiiKoiiKoigHC2pgKYqiKIqiKIqizBBqYCmKoiiKoiiKoswQamApiqIoiqIoiqLMEGpgKYqiKIqiKIqizBBqYCmKoiiKoiiKoswQamApijJvEJFPicglsyT71yKybjZkK4qiKJYD8XdcRAZE5O0Fcc8QkSERCWe63PmEiHxGRC5rtx4HC2pgKcoBhIhsEpFXtluPmUBEzhWRW9wwY8yfGWP+dgZkN90ojDHHG2MG9le2oijKwUpsaOwSkY4ppj/of8eNMY8ZYxYZY+qt0uW1hbJviMgfi8ijIjIsIl8VkaXt1mm6qIGlKMqUEZFSu3VQFEVRZh4RWQO8DDDAG9qrjeIiloNuzJ43phCR44GrgLcCK4ER4F/nWLX95qDrLEVZiIjIEhH5hohsi58+fkNEVsVxbxaRO7307xaRr8XHHSLycRF5TESeiqd3dMVx60Rks4i8T0SeBK7JKfsYEfmRiOwQke0i8gUR6XfiV4vIf8a67RCRK0Xkd4BPAS+Jp17sjtOmTyxF5H4ReZ0jpxTLeEF8/h8i8qSI7BGRn8Q/yojIBcBbgL+OZX89Dk+9f3GdrxCRJ+LPFckTW6fO7xGRp0Vkq4ic16LtB0TkMhH5r6Q8EVkWt8NeEbk9Hrgk6Z8tIt8XkZ0i8hsR+SMn7r+LyN1xvsdFZL0Tt0ZEjIi8Le6r7SLyN4UXhaIoyvT4E+AXwGeAt7kRB/vveMyRIvIzERkUke+JyPJYVvLbW4rPzxWRjXG634rIW1q0RZ+IfDau86Mi8gGJDSURCUXkH+Lf8t+KyEVeOQMi8hER+RnWyDhaRM6L23Qw1uF/Om2b1PmvnTq/UUROF5EH43vO/57KhSBtHFPE/f51Y8xPjDFDwCXA/xCR3qnoPl9QA0tRDg4C7A/VkcAzgFHgyjjuJuCo+AaQ8Fbgs/Hx5cAzgbXAscARwAedtIcCS2PZF+SULcDfA4cDvwOsBtaDvYEA3wAeBdbEsq83xtwP/Bnw83jqRX+O3OuAs53z04Dtxpi74vNvA8cBhwB3AV8AMMZcHR9/LJb9+hzZfwO8OK7zicCLgA94de6L9f1T4F9EZEmOnISzsG16BHAM8HNsfywF7gc+FLdHD/B94Iux3mcB/yoiz4nlDGMHOf3AfwfeKSJv9Mp6KfAs4PeBD3r9qiiKsq/8Cfa38wvAaSKyEhbU7/gfA+fFulSAv/ITxL/h/wy81hjTC5wK3NOiLT4Z63A08HvYNk4MvXcAr431fwHwxhyd3oq97/Zi2/9p4HXA4ljOPybGqlPnThr38X8DzgFOwnonLxGRo1q0QUI7xxTHA79MTowxjwATscwDB2OMfvSjnwPkA2wCXjmFdGuBXc75/wU+Eh8fD+wCOrDG0TBwjJP2JcBv4+N12B+2zmno+EbgbkfWNqCUk+5c4BYv7DPAZfHxscAg0B2ffwH4YEGZ/dhpLX2+nLy2Ax4BTnfiTgM2OXUedXXG3tReXFD2APA3zvk/AN92zl+PvQEDnAn81Mt/FfChAtlXAP8YH6+J67jKib8NOKvd16V+9KOfA/uDfXBTBZbH5w8AfxkfL5Tf8Q845xcC34mPk9/eEtAD7Ab+EOhq1RZAiL1/PscJ+5/AQHz8I+B/OnGvTMpxdLp0kn77KvDnXp3D+Lw3lneKk/5O4I0Fspra24lbyxyNKYAfAn/mhW0B1rX7ezKdj3qwFOUgQES6ReSqeArCXuAnQL80dj26FvhjERHsk6YvGWPGgRVAN3CniOyOpzV8Jw5P2GaMGWtR9koRuV5EtsRlfx5YHkevBh41xtSmWydjzMNY78/rRaQbuybgi3GZoYhcLiKPxGVuirMtzxXWzOHYp4EJj8ZhCTs8nUeARS3kPeUcj+acJ3mPBE5J2jpu77dgn+ghIqeIyM3xtIw92Ceifp2enIZeiqIoU+FtwPeMMdvj8y/SmCa4UH7HJ/1tNcYMYx+U/RmwVUS+KSLPLpC3HCjn6HiEo//jTpx7nBsmIq8VkV/E0/12A6eTba8dprEZx2j8v+h+VEg7xxTAENZD57IYa6gfMKiBpSgHB+/BThs7xRizGPjdOFwAjDG/wD41ehl2GsTn4vjt2B/c440x/fGnzxjj/gCbScr+uzjN8+Kyz0nKxd4cniH5m2NMJhca00vOAO6Lb9bEdTgD+8SvD/uEEafcyWQ/gTV2Ep4Rh802jwM/dtq639jpJO+M47+InX6x2hjTh53TL0XCFEVR9pd4fcwfAb8ndj3Uk8BfAieKyIno73gGY8x3jTGvAg7Devr+LYnykm7HegV9HbfEx1uBVU7c6rzikgOx68u+DHwcWGnsNMRvMTv3iHaOKX6NnfJpCxQ5Gusde3D/qjS3qIGlKAceZRHpdD4l7FSAUWC32O1MP5ST77PYOdRVY8wtAMaYCHtz+EcROQRARI4QkdOmoU8v9onTHhE5AnivE3cb9iZyuYj0xPr+tzjuKWCViFRayL4eeDXwTuKnnk6Z48AO7NOyv/PyPYWd817EdcAHRGSF2IXMH8R63mabbwDPFJG3ikg5/rzQmcveC+w0xoyJyIuwNy5FUZTZ5I1AHXgOdirYWux62p9i1wzp73hMPGPjjHgt1jj23hc5+qZtEXuSvgR8RER6ReRI4N2Ojl8C/jy+5/YD75uk+ArW0NgG1ETktdh2nQ3aOab4Atbj+bK4nS8F/tMYox4sRVFmlW9hf/iSz3rsWp0u7NOjX2Bd8j6fA55L8w3ofcDDwC/iqQA/wD65miofxi7Q3QN8E/jPJCK+wbweOw//MWAzdnoF2PnnvwaeFJHt5GCM2YrdMOJU4AYn6rPYqRZbgPuwdXb5d+A58RSFr+aIvgy4A7gX+BV2cfWsv2AxvkG8Gru5xRPYKSkfxd40wc77v1REBrGDhS/Ntk6Koix43gZcY+z7np5MPtjB81uwXgv9HbcEWCPpCWAnduOKZAZCXltcjF2TtBG4BWtgfjqO+zfge7H+d2Pv7TWssdtEfP94F/a+sAv7AO6mmatahito05jCGPNr7BTML2DXzfVi740HFBIvHlMU5SAnngbyNPACY8xD7dZHURRFURRL7JH6lDHmyEkTzwN0TNEa9WApysLhncDt+kOoKIqiKO1FRLrEvqOqFE+v/xDwlXbrNQ10TNGCvAWLiqIcZIjIJuw0jze2VxNFURRFUbD35A9jp02OYqfYf7BljnmCjikmR6cIKoqiKIqiKIqizBA6RVBRFEVRFGUfEJHXiMhvRORhEXl/u/VRFGV+MG89WMuXLzdr1qyZNfnDw8P09PTMmvz5jNZd677QWKh1X6j1Bq37Qq77Aw88sN0Ys2Ly1PtH/NLVB4FXYXfWux042xhzX1GeUmeP6ehd2vwmIOfNT0ZAjA0z2GPjvelIWgzd3LRCtig3X1oOU5DvC/JxdG2FRGCSR/tJWu+tVybIkWOcdEUkaWJd89otk9bRvVBWq7xOWakov8xW7WZy0rQq0083WZ5W5OSVKNY9+USebL9NvPbOxOf1bUE7Czn9lFffvDoUlTcZrnwnj5HkRV/Z70crRnZszv29mbdrsNasWcMdd9wxa/IHBgZYt27drMmfz2jd17VbjbagdV/XbjXmnIVab9C6L+S6v/zlL390jop7EfCwMWYjgIhcT/wy3aIMHb1LefYZf5kaAMkAzzU6TAmk1ggPqhAlo7V4QCu1+NQd3MfGSxSCCe15ZtAMBDWQupVnAgjiDcGjkMxgNaiTMVJMSEZn489/itNIzalXrBPSGECXRyJqnUGsu7GyQrG61Ox5rVMI3PoZkMgQlSQjG6weiUEWVG0aE9p6hhOGWoeVLVGjLvbYpG1fL0vG8AvqtjwTuCPvuH5xHJApK4kvjRnqZUnbJCqR1sU1Amy/GsRAvSIEVRO3k2T6oaGTwYgQ1AwmhCgUgrqJ20DS9nXr6p67hoQRCKvGtl1cngmgNGpl18u2XuGEyegjkXNubBtGoaTtEtRtm0WhlZ/oZq+7uG9cfeJ6SWT7XOo0ZMf9nalj4PRf5FwTSX865SXtJlGjzumlahr6JHVKvl+pcR+3fTjRCEdIdUx0Cepwx7Xvyf29mbcGlqIoiqIoyjzmCOBx53wzcIqfSEQuAC4AqPQsyTwld40P44ytk3MrwPufl6YgnWtcJWWJH5+DaYyjG/kcnQs9BULWKSBZHUwgjTCTDHCTMqUhOwlLDqUhG9ez4LRdmsb5ZOQZV45k20t8WZIdlOO0ndfOaVv5dXX0ENMcntQnPRbJGK6SKaNhCKXHcUdm+tjpAzcu0S+Nz8hxdAjcNnT6CtsmmWvJbcNYx0xfOmX6fSI0wt3rMm3L9DqRTP68/kp18cpLDWrfS5UpW7KyaOjQ6IRsuKtLoYcUNbAURVEURVFmDWPM1cDVAN0rVhuCeGDtTpVzBtxRaBfIJ4O3xCOVIfE4uYZGPR78BdDkYUrShFB3vFXpYNOXH0C6giT2zqQeFUO6gj/RUUxDb0xDrj91q9YpROVGnJiGUZEYfia0s9Ma3gxbUDL4z8h16lkX600xAlE8eHa9ef60M9c7J850uMRLkmmTuA2sh0Oy50FDdq1TMt4+E1pdUk+KU4e6NOTUkaY+y0ynjHUJEk9OUq4nE+J+c9oncx63q2/MIVhvX9i4fuqVfH0yXkzXQEqmRwZx+ztpEg9Uok/SHoTWK2lKUHeNy8Q4cuQTt7MxSd0l6ZoMSb1M0gex/GQaoxiITFzXsOAaiGVFpaxhl1yXGYO0ADWwFEVRFEVRps8WYLVzvioOa0nkDtyTwbczVdAEQpQsTonxB/vp4C71gglBkEyTSjwAppEeGybSkJsZUIaebFfFiHQ6VTpADWPvUyhxmniqlTjWlWsAJnUvkZl6Jyae+lY36WA8CgUJbLgYk53mFdc1yefKISSjT2PalzSmI8Zli7P/gAkknfaXtIFEEJWFZCpc4s2R0GTqZMJGuyBAOZYXT32z0xpNOrUsCiVtFyk5gkoNPZNpnUHGYI7r7Ez5TNJlpjImdXOnI4o0hVEicx0kRkamjZ26igEi239ST+ruFJoYM4lMxwA3Qdy/0lxmcokm11Oqn3GMXMnKgdiAI9tGqVx3Omt87dhpoCY1uBL9E2MyuQZdr3Ly0CDTtoFTzxbeK1ADS1EURVEUZV+4HThORI7CGlZnAX/cMoc/HSkQMMaZeiTpE/80izQbE+nAOsdTkZlCJmQGriaQ1BMAjcF8It81JhoGUmz84Ezp85/gG6fMFgYWgeMRsBrY/8mgVySuS+zxMNmpeml+J9wOmqWhj8G6PhLPTSwvPU4a21E9k17iOscD9bQsNx1xWwfZsGTAHqRWQqOPkYbBIFGj7m7exPVjAsFEjfymZOMy0x7jdO40vrQt3D6QuCynPVxvXtF0N2v0xGmAgNigTtY7hV6bGZNek4bGtWQ9ktK47h19jaujeAo4DxnS6yJy0goYYxoPFJJrNRRrWEWm4fUKk4ITQ9vqEIXS8MY66/TS5gpydFIDS1EURVEUZXYwxtRE5CLgu9hJXJ82xvx6SnmTwaQ/uE2envtx7mAuMVxMNjz1VLjpCsorpCC+sdtgo4zMgDhjkCWFTlLWJGUWpUt0yezYN1UZRbgGiR/ml0VO2rywouNWSLav0jKb5sE10uXqlZO+pR7uNebnLTDA/PIy15hznlkDNdX+cvRx14KJY1w16eTWwTGSxI3PeIqzdct+5wRxvciuRzD573/fPNTAUhRFURRF2QeMMd8CvjWtPP5TcWfglwlL/qdP+JMwOwWtKa1bhuMwSMvzBot2oJqVY1xhppE2eeqf8bx4Bk9mc4B4al1DH8nWM8cIyOyg58glANz1P8THdVLPX2475Jbh6OobHZMZRL6sZH0RDT2yG0k0DINkgVnT2q4ivRMjIPFCum1RYCxlpujlXVM+UYs4R5eGkdeobLKhRcZ4geb+zdE144VzphZmdtUUIPGQ0UiferLi9Gkbp2uhGjsVpl6t2HuY9kmsaLouLDEIA7FeL6eszCsDku+Hq2OLXS7UwFIURVEURZkrvDFZ5km4O/hM4gNnahjxmC4SJ3+c1TMQjD/Idga0GT28fOl23I6RlKy3SrfZTtJ6A+DGmp3G9MNMGa6Rkgxsk4GzZI0ov26JUZWEizOYd9clZfI5xRUZoq6sVN+mqWGe/k65mTU5Tp0yEhLDyPfwSXaM7u5URyCZdkvXGTnnGe9QTr9mDEkvLOOJ9NM6RnMmzjTSuzqnxnbdOTfN/eHqkGuEmWwaN3/iwUrXRUUgQbb8ZOpf0t7plEn8dDk7NgbZhwfJujRcQ979DgotjdQW+18oiqIoiqIoM03Tupei8bw3WM54SVrka5LdIl2GqaaDJsPAD5ttiqZDZhMV5/d1ncq6mtz0/qA7Ltfvu0K8a8CXOyU9imTuC3nG0BR0mFbfe/XLy5t7rU/WZ0WGXE6c+8n9Tvk6ud+/KVzv6sFSFEVRFEWZC9wn8O66nngjhXQra38g6W/FnchI8sTHxNOakviiwXfDa9PwjjW8RQ0PhTHSmJaXbPrgpDWe3MYaF2na+jz17uRMkcvsFgc0rXmKvRKpwyAgfXFt0yC5wMvU2JTCUzxur0xcjryM18UfnLtlJWGpxyfO5m5t77g3fCPA3e7c9Spl9EnqkuhKQ2bmpdW+5yxj+EmmfLftm68rstu9O3XM1N/ZidD1nuYZSkZiD5Rx5CdxQbYc44YnMr1t5t3jVNdER3djD0cHl8zrEeKy3PbLNdbUwFIURVEURWkvRkjfA5VZe+KmcaY3gR0sNr0jyRngJYNxqZM1IiA7qDSk65lSOf7g3dErjfcMLHEHrDl53Hz+lEK/LIh19+pnXL3jotx2MV4e4wy6M2vCCtb3+PUWb8DsOsfSw8SQcdsg1j9XB3dg7k+5y1mblKYhlo9jXHj6iCO3yfBy33PmGk1OW5nQaQNvV8GMAdfCgMgYw7ExmBooOW2XCXD1i9tEnP5qrKNyCiy6fop0NJl/uen9ayN9z1WesZpXzmwbWCLyGuCfsLvo/D9jzOUF6f4QuBF4oTHmjpkoW1EURVEU5YBAyLz01CQbODgGTTLgTQfGOQZW3lN+3+jyDbfU4AkyQdkkrgclLj9dS5UM6HEMJycsKRsaBoQJ7LuKMl4h12BwPBmZ9WE018H3mhWt13KNmTTMfdeYZ/A0GYyeQZPiyPcNwEx8kt2QGrP+1DJfXjYjjQG9eOlMU7KGUULDKMlMD3XzOfIy7Vgn03cZA9JVzzOsU12Td5i54b4nKydfk1fKLSeHlhuE+GXk9affLjjXg5C+wDttv6DRl00PEFroCTNgYIlICPwL8CpgM3C7iNxkjLnPS9cL/Dlw6/6WqSiKoiiKciCSThlzzt0BZhKfTi9rNdjPGeS766EyxpJb3iT6ZY4Tr4s4xbkD/xyDpclL4NXT90b4bZKnS563IM870eQ18XXw6uaPvTP1zNEl0wZevO+VbLWGqEmeK8tJn/EmtmqDnPb1DZcmg01ywt3y3XIK8mb6wKuv2+5plNvgbv/nNURh49Bc1+S4VbynV0ZmwfXZdO3mGKt5zIQH60XAw8aYjQAicj1wBnCfl+5vgY8C752BMhVFURRFUQ48xBvA5hgRvjHSZBR5T9QLn/jnGUvuiNgbNOaFu7Kb5Pnpc8JTj1yrAbSZfMCaS05635BqBDrh7nHOwNmdVufLcr1Gfhrfs+S3dW4beB7DjCDJ0RMvjVdPv7/cKXCZMFrIdtJlplHmGTCOZzCjv1Ne0qZNdXTql/G8OfWZtL5entwHEjl1w6ubfUF0tk0y3xn3Gp8LDxZwBPC4c74ZOMVNICIvAFYbY74pIoUGlohcAFwAsHLlSgYGBmZAvXyGhoZmVf58Rus+0G412oLWfaDdasw5C7XeoHVfyHWfzyTrX3AHvQUDQncQPJmB5Q+sC1+MG5fZNMXJNJeZZHF1b2zV3fCoZKY35hxnPFxeeUUGXu6aLvJluvVztwn38zetDXKNWUeHXCPMKQMaA2wimgfijriM3gXGo7seK5mOlpfPONdL7lb2xjHwXH1y6tF0yXkB7jRVN6xpveAUjD7fUPMNrUy4U790kwmay83TtbAuTlu4hnHkre8yknn7QZO+SbrcBxQ5zPomFyISAJ8Azp0srTHmauBqgJNPPtmsW7du1vQaGBhgNuXPZ7Tu69qtRlvQuq9rtxpzzkKtN2jdF3Ld5ztNU+3c/84gOrM2xEuT63nIG1C7A0bnPVKZPK5unqwmI46s7k1renyjBefcn+LmGWcZr41rgBlPL7/OThmZ9y45A++MPnlT43LarGkjCs+gzNSjwBDI9XR4g3R/s4nUUPK8QG5619hq0jfRScgYXa6cIj0z9XEMkky5ft1dgz3P0HF3CpyiLBPF+YKctL4h66/Fc3avdOtjX5Lt6JnTRqkY45Tt6py3Bq2AmTCwtgCrnfNVcVhCL/BcYEDsBMtDgZtE5A260YWiKIqiKAsKx1BpWgtSZDjhDGRzjJVW63lyZeXlm8qT+cTL4vzPTZvn2ZBseYXeIbeeRfpLVkaeh6toLVUuLdqySWffGHbLLBbb3G85Xqj02sgzDN149zyn7/31Zb5CrfQsmgaa156pl6fF9ef3VUtZSf2SdvXrm6ewV880ry9XMlkyujd5THPk5nohWxhbM2Fg3Q4cJyJHYQ2rs4A/Tss2Zg+wPDkXkQHgr9S4UhRFURRlQeEOHH3vxhSejLdco4LzpD/HW5TJ73gX0lNDY2tsz0uQr0y+Dk1hOd4GX3TTeZ4h4xuVrvfGzVPg+WmJW99kMJ7n5XENGs/rlVmD5NbL95Y4dUu8M01reQyF9ch4dBw9m7yNbp4oJ8ztF0fPvPLSsEmuiVSOp0eTQed64Zyy03LTbdJNQ0COpWXb0qZx3x/WlAbsO7fi9CZnzqQry50GmzEMA4NEXt4C9tvAMsbUROQi4LvYDQ4/bYz5tYhcCtxhjLlpf8tQFEVRFEU5GGgMIu3ozQTGWfifHdlmBu1Fo2MnupWcJFtjLZVk4yLrVjBBNr1fQCa/iyO8cCqa723IGcjmvR/MnZrl1tEEJpOn2e3kuYn8NvXbLkmTTGtz9MzULTaQm8JzjB23rMibdpZZm+YaTe5UR59ca9TBaf9UHnFbOQaoP0WvuQ0b/9I1UTkGVvPrALLXgDsN05fZVA3HYG4YVMa2dZT9rqTpBTAmO/0vo6CVlXpeAxDjKOLEpbLcNsoYWEljNLeDz4yswTLGfAv4lhf2wYK062aizP3htq23sX7Leo773nGs6l1FParz+ODjPD3yNJWwQnepm65yF12lLntc6qK73E09qrN7fDfD1WH6O/o5pPsQOkudjNZGGa+Ps6i8iL6OPmpRjSeGnmDb6Db6O/o5rOcwOkud7J3Yy9DEED3lHvo6+ohMxJahLTw1/BSdpU76O/rpLndjjEFEWNKxhEN7DqUj7ODp0afZNrKNwYlBRmujACztXMqyrmX0lHvoKnUhCLvGdrF7fDflsMyi8iL7qdj/IkItqvHA6AMEmwNqUY26qVOLaozXxxmaGGKwOsjQxBBD1SHqUZ01fWs4pu8Y+jr6COKXZwxVhxiaGMJgKAUlykGZUlCiFJQYqY6wa2wXw9VhFncsZmnnUjrCDgCqUZXNg5t5fPBxeso9/M7S3+Ho/qMZrg6ze2w3BkNPuYeOsIOh6hB7x/diMCyqLKKr1JXqOVGfSP+HEhIGIT3lHpZ3Lae/o5+9E3vZObaTkeoIxtgflEXlRfRWenmy+iS/3fNbAgnorfTSV+kjDELqUZ2JaIJKUCEMQibqEzy691Ee2/sYIkJnqZNF5UUs7VzKks4lRCZitDZKZCIqYYVKUGGoOsTOsZ2M1cboLnfTU+ohIqJarzIRTVCNqtSiWqZft41u48nhJ6mbOp1hJ4EEDFeHGamNEJmIQAIqYYWlnUtZ2rmUclCmFtUYq4+xbWQbO0Z3pHVZ3LGYxRX72T2+m017N7F9dHt6TT82/hi7xnaxqLKIx/c+ziN7HiEyEcu7lrOkcwldYReVsJJeJxP1ibQfRITFlcWUwzJPDj3J44OPEwQBR/cdzZGLj6QclNN8o7VRJuoT9Hf0p9eNMYaR2gibBzfz2OBj1E2doxYfxTMWP4OuUhcAkYnYNbaLXWO7WNG9gr6Ovpbf45HqCOP18fQarps69ahOzdSoR3XKQZlDew6ls9Q5K78jI9URdozuoKfSQ2+ll3JQnpVyFEU5yIhHiHaalGlMg/JGnf40L8GLa5JbkNZ/WWpSHiY7oI5H2JmBrmM0uOmNV0ZSjkQmu4tdjo6ZPK7ekhOWky9TRz9PakCYnGlfjv5uvZLBdF6bOGVm4iQ/PNU5R9/03M/ve2ZcT05OP6f1TwxRnIpKjv6JZybT1wVyXWPIM7RyPZU59fPbqWj6YO61IY6x62cQk23joFi275HMK8O5fKw+juc2bduc9VyFsj1mfZOL+UjPxCjPMj0M7d3MD7fdS4CwurSI5wQd1KojjER7GDV1dmMYpc6IqTMSVQkloD/sojsocX99jB3VIeoYShJQlhKj0USjjKDCIaVudtfH2VUfTcO7pMSYqaV9syiocGjYzTgRu+vjjEbVNG0t+8q2WG4H3UGJyBh210epT8WMzuOHxVFdUqY3rADC12ozvyNTh4RUTUS0r7rvL19tHApCKShRddq9M+ykGlWpG3818MwSSjjrZfj8nxv+D2J//uakvJKUKIdlxmpjhWWGElIJK6kBmrCkYwnLupalDxx6yj30d/RTjao8svsRnhp5ako6LO1cyqJoEV+7+Wv0d/ZTi2rUolpaXtP/epWaafwvB+XU8E/yPjn8JE+PPp0pZ9WiVTxvxfM4uu9ohiaG2D2+m7H6GBP1CUZqIzw1/BRPjTxFNarSEXY0fSphJTXWO8IOymGZjrADQdg+up1to9uoRlUqYYXOsJMlnUtY3rWcnnIPJSmBwODEIHvG91AKShzafSh79u5h50M76Qw76Sp10VnqpBSU2Dayja3DW+3DkNow47Vxlnct57BFh9FX6cNgmKhP8Ns9v+XBXQ8yEU1wdN/RHNV3FIEETNTtA4Pk4cFE3X5EhO5St33AUO6hu9TNaG2UR3Y/wm/3PEIoZXo7elnauZTVvatZ3bua7nI3AQEigiAEEhCIPY9MlD7wGaoOMTwxTN3UOaznMA5fdDiLOxanDyZGaiOMVEcIJKCr1MWu2i72jO+hu9RNzTQM/3JQphyW7f+gjMGwa2wXO8d2Uo/qhEGYPrgpSYnR2ih7xvcwWB2kHtWJTGQfCo3vZrQ2ysqelRyx6Ah6yj3pw59EXiWssGrRKg7tORQgc61FJmJF1woO7TmUQAK2jW5j5+hOeio9LO1YSikoMVQdYqQ6wuKOxfR39FMKGrfsvRN72bh7IyLCc5Y+h3JoDXxjDGPRGLvHdjMRTbBrbBc7RndQCko8d/lz6S53T/qd2TO+h9/u+S39Hf2s6l2VKdfFGEPd1AklRLyX2FSjKiNV+6Cov6O/KX7BIo7B4z4hdz0KTliSzh1Dt5KdmzZvUO2UnXqQAjD+QNwvX7z8ib5u3dxBdZGnqEC3TLx4+XL0STc4mExfyEzJdNeyuXIy0wBd48yJy+gj2fCMYUqObjTHG9OQl5QrRWmd9sl4Wdz7q6dDWk936qdkswDZaYR+3eN2y7uN526YkWMkukZ0XrvkGvaekeduaNHk8XLq6pabOfavCceg8g3nzHfVkWOE9GXdrb6TC9LAOn50iKseviU/MqxAUAZTh9pYSzl1rBc3eW5dA/YGASGwOIrSPhwVYUKERVFEGOcZDOyVujgyuQawiWU9WQoZF+GQWp1l9TruM/II2BMEDAfCiAQYYEkUsaRepyrCUBAwFMT/46uhjCE0UMJQMoZSfFw2ht7IsCiKMhfFoAgbK2WGJaAeK9obRSyKDAGGKkJNoCpCTYSuKGJpPaLbROwNAnaFIRNin3OVjOGIWp0V9TqjIjxYKfNoucyiKKK/HhFiGAoCxuO2StpwKAgYEaFiDB3GxP+hbAyRQA1hOBC2hyG7woDF9YilUURPFKWbCA0FAXtj2Unf7Q0Ddge2fbtMRNnYeoyWRilHdY4eH2NNtUoAjIkwGATsDEN2hSVCE9FpDKExjItQDcssiuosqVXpjAyjcbsHGMqxrhVj235XGLC1o5uRUoVDRwc5rFYlNDAeBERBie7aOD1x2rrAuAg7g4CdXb3UgVJ1jI6ozvK6/UTxtbI3CNjb0cPeSjeLx4dZMzbEylqdCRFGRXiq3MmTi/rZXQo5cmgXx4wOUTawPbT9NB6EjJU6oVQhDDsoS0Dv6G4Wjw1igMHOxYx29HDY0C5Wjw1RE9hY6eTx7j7qYQkkIIwiuqojlGvj7Kl0sa3SxUQY0EWFbmM4YmgXR47uJQB+29HF4z1LGA0M42aMsjEcEkUsieDpSie/jcbZM/4EEkUYEzEYhjwd2EH4i6o1jhqZoKdepRRFhCb+RHVKQGgMY0HIkz39bK2P8qgZYeOWneyhRomAMkLJRJSjiJKpUzb2x7BiDN2Q9lkJmAhCRsIy40FACaED4SXVCdYMDbNiYoyhQNhT7uSh2lbuHHqKb1Olk4A+CekyQgWhC+E4Ay+rRVRqNcajUSZMxHipYj9BwAQwITAC7BbDBDCOIcKwvB7xjAnb7xNhidGwzNNhifsDGCGijiECFhlhsTHUEH4QGKoY/vO//rPwN6wLodsIZYQdElH17p5lA8fW6lQMfLN8B0M505JKxv4GVuLv2ihQ9X7UeiPD0RP2AdS2sMStYcjeFu8PmSk+eH3uRIoZQ4zBzKHh0E1IWQQBdpvGw4guAo7vWMHe+giP14YYxcANzflD4LjKUmomYlttmBFTo0NCKhLQKSEdUmIkqvJU1Lj3lYAVUqEO1EWom4iaqVPDMBFfdyWEPkI6JWSUiGFTZ9x5QNhJwKGlHgKEIVNlOKryozf9kO7upbPVVPMWA3abdml4LzLGQ5IIih/554WLF51nxBTok3fSNOvMKadYQCNxant5ngIzBTEF4/9MuiJ5vuysB45CQ9W4BmOSuOA5pG8H+3r5dcklGcibhmGV2a7dnzKIb1BlbaXcsnxDQibJFGSNoDTvJN6ajH2XZ+DkdJY/9S73ovALCZrbKbcDEq9T3sXitkHSxrEBSVAgy6+Lf60UsCANLNa8jNtP/mde+MIXggiUOqFrCXQshsC569erMDEME0MwPgQmglKHNcJMnbBeJaxXoT4B9SqlqMrS+gSEHbDoECtzfJCukR10RXXoWQZdSwgmhukb2WmNuJ4V0LUUohpUR2yZpQ5EAvr2bKZvx8MwvtfKcj9hhWB8kCVje1gSJV6QxmONMtANHOKEJdx9z92csHZt9goJSrHs/oaBWR2hd3g7Jw49besIEJatzj0rrM5DT8PorrQNqPTAopXQ0Uvf2G5WD2+3ssIOKHdC72HQexjdY7tZ++QG1u7caNs0eapaHYHauG3jUsX2TVixHwlIt4fx/08MWl2Gt0PHItumXUugeylUFtm43Zt45P5fcsxxv2PrUZ+AiRGIqrb+IlCbsDoEJeh/BvSttvUcH7T9MD5or4eww9ZVAns+MQQSNvQOOxrXSlix8kzdyhreDoNbbZ7ew6F3pW27kR3WqO9bDX2rrIz6uC1z7xbYs9mW19lnr9XOPujotXnHdsPo7sb/rn5Ydiz0HmrPR7bT/8DdvHJply139TNgyVFQ7uK45BqvjjSu94kR2z5HrIS+I+y1v3crjO6Eow6zOgYljhh6Eoa3WR3qcTt2Lrb9OTFkr43qGOkv2xFH2HLDMs/a/RjsfcLGSWjrFsQjj/G9cd5xe90EZRjbY8syBpYeBc9YY/s2CGz+IIz7MbRh1TErf+8WRp58iO7qLoin1xKUoHuZvVa7lkBYsvkTOSKxTmK/+6M7YWyvbQcMLD4CjnuFvUYmhq2uuzbBtt8wMbidStI/pYotT0LbVz29VueOXntdjO+FkZ22300dosj+NxFEdXssASw+HA5fba+piWGry9BT9lMbi6+zMnT2Q3c/1MYxux9l5+7NTJTLjJYqjAUlxsISE2GZ5VLmsKBCT1CxMiUgGtnJ9tEdDGEIupYQdvVzWPehlHpWQH0Cs+Mhdu56FCSgEnZQKXVSLncSlLqg3GW/qxJAVKNaG2ekPsZIfZxSWGH50qOQ/mdkrtU9I9t5fGIn4+ODROODGFMj6liM6ViMEYjqEwRRnR4p0SslejqX0tt7OJQqbN31CFuGNjNcH2fMRNRMRE9sLEYijIYBg7Ua1cAwamqEEtAlJSoSUjcRVVOnaqLYkx6xlJAlWE9qLaxQD0Jq9Qlq9XE6gxL9lcUs6uijVOoiDCv0lLroK/dQkTLbxneyeWwHY1GNclCiI6zQ39HPkq7lTAhsHt3OUxN7kPoE5doY5XqdsgRgIraN72ZrdZAIw8pSD0vLPQxFdXaaceoSsqhjMV2VRQyND7JzfDeD0RjVIKAuAUeUejim6xCqUZ3bhx9jw9hjHGqEF5V66K0KfaFQro3TX+llWc+hjJoad+39Lb8e2UKnMZxkAhZJyLiJGBcYJ2IcQ5mA48IejulYym4iNtaH2R5NUKpXCaMqoZQohR2UwgoVrBE+RsRuU2PM1OiJ6vREdboJ6YmnDm+tj7GVYcRELDLQg2BqjZkdCwqJDSyyg//MeC1vWpKbyB0kOwPTzGYZRQPAPK+BmyeWWbjpgi8jzzISR24y7bBx2JyP5vS5hlDk1dHXP0+lMB49J4u/krr5xmTOtn2+vkXroYy0OHeFZc5J9TJ+YYkX0e/DjPuqkc80LViT5vLccnPqgIBxN28I8i7MApy6ZNoxqQdOfFI/I40yplKO205+2W5+IR4XumlydIpy2syvsy8rr01buLAWpoHVuZjhRUfCyue0TheW7UC1q3/fy+peCkuOzIZ1LbED6By9MvQsh8PXFsvuPXSfVNqzqQprXjq1xEvWtI5fftw+6UDnYjs4nWMeHx7gmJesm/Ny5wOP1AZYvW5du9VoC7cNDLDu937PDvDDcvMP8AxSmTXJ00OAX03jfUgBcEj8KZK3bIpll4G++FPEZPGtOCb+tGKu3gV1aPwpYsWsawCvAvtQpNwFIoV1fynYBzZhbFjPJelj99n77h1IpIP6ZM1TjD9VKYM08orzP5sZDFLocUqnA4qXLxbWJNOLz+ifp6ZvXCWKpGu7soU31ts4g1cxGPKMhmwd/Xrl4cpP2yWR7+mNp0eaxtfHFIdnjDVXgbx+iEtJy3eO03i3DzP9mW2vbBqvPNcIz7M9kvLyNilhcjJ1cfVrekiQretk0yhxsjRdgwV50nq4tNSJTFNm2j0jwzN68/rBY2EaWC0wxlCP7JqPMNAbQRETtYhSIAQFbRRFJjfOGMMTe8boKocs7ZndoWg9MuwemWBovMbKxZ10lsNp5TfGsGukSqUU0FNpXmMwXaLIUIsM5VAmlTUyUaMWGSphQCUMCtu5Hk8xnW4/7C+1ul1BVw6nP89rohYRGTPt/piMkYkaO4cnCEToLIf0dIR0lJwyRBoepRlg2+A4m3eN0NtZYnFXmeU9HZO2tTGGat0wVqsTRYZFHSVKOW0YRfZHO5FXrUc8PTiOMYblizpmvO1mm13DEzz41CDlUsDyng6WLqrs03eqVo8YqdZZ3Nn+DUWiyDBarVMOg6bv9OhEnSf2jFKPDP3dZZZ0V/bpuzIZY1U7e6GzHEKleG2ViXfFCgKx3tMpUK1HhFL8Gz9t1LBKSXa+s1PBsgM0k1hOCQWeiSRJml6yg1s78PdkeIPnVAdvRGmQrHch0dn3sEB2qlRefGwsijGNQbGY7HS43MGyPxg23lon3wVGvtcnY6y67WIyaXINS9/4yS3bMyrS9Nn4ommJUnCMOFVKmrWF4ZMX7ob567H8NGmcmMnTJclNC11z8uXVNT1vdiDmrK1zdoD0DMYm9ZwAP09DuKNLwfdCfGPVL6jFz9qCNLBu37STj/xilCvv/y8MMDJRZ+fwOLtHqkzUo/SLXw6FzlJIRzmgoxTSGf/vKAd2UaIxjFUjhsZrjEzUWNpT4bC+LoJAeHLPKNuHJljaU+Hw/i4qofDU3nF2DI3TVbHGhSA8NTjG9sFxIkNqsISBUAqEo1f0cMKqfpb1VNi0Y4RN24d5anCMbYPjjNciVizqYNmiCqVAiGJ9IgORMXSVQ3o6SizqLLGoUqKnw26MMV6rs2nzGF/acidj1Yixap2xap3xWnIcMV6LGI9v3Ics7uDQvk66yiVE7A19045htuwapRQGHLm0m8P6u6jVbf7dI1W2DY4zNFFj+aIODuvrpKdiL7OxWp2HnxpicNyuHTi8r5PjVvZSrds2FOxAoaMcxsZIRK1ujZJ6ZKjWI+rxcS0y1OpRGhcGQm9nie5KicGxKrtGquwdq2Yemh7e10WHGecfN9xivdVxWyW/+8YYOsoh3eWQkYkaj2wbZijWtRQIfV1l+rrK9HaVmahF1giqGzpKAR3lEGMME/WIat3qXa1HTNQiqvFxLR4093aUWLW0myXdZfaOVdkzWqUSBizusoPGx3eOsH2osWFKGAiHLu7kiCV2t729o1UGx2rsGa2m+lXCIL2ulvZUGJmo88TuUfaMVumuhPR1lQnr4xz+wM+plAKe2jvGk3vGqEaRNUYqJZb3dnDo4g46SqGtX7XOk3tG2bp7jCAQDuvrpK+rzNY9Y2zZbQePS3sqLOup0FEOKIcB1XrE7pEqw+ON70NXJWSsWk91enLvGMbA4s4ShyzupKscUg7tr9RE3HZ9XWVW9HbQUylRrUdUI0N3OaS3s8RItc6vn9jLQ08NUo+N0GoUMVZt3hTmkN4OVi3polId49axB+jvKjM8UWd4vMbQWI2hiVrjeNx+hsdrTNQiOsqh7dtSYK/Lkv3+l0vCpu0jbNmdneLUWQ449pBFHNHfxXgtYmS8zvBEjdEJ+z85j7wBQE8lZHFXmd7OEh2lkO1D42wbHKdurAHWUQrZOTyeyddTCVnmfP+Hx+uMTNQYmbDtXCkFrFzcSVgd4/OP3kEpEMLQ/q4k19CukSqjE3X7HQB6O0ss6a5QCQPGalbO9qFxtu0dpxYZVi7uYPmiDgyk1/ZELUr7zH4X7XHdGLorIYs7y4xW62zd07yetVIKWNZTYdmiCkt7Ouguh7adJuoYY7/TIkIgIAhP7h3j8Z0j1CJ7fRy5rJueSokggEAaaYP4/44dY1z/+J2EoRCKpL+v7oMhY6AeXzuj8W/h6ESdaj2iqxLSXSkxXquzY2iCwbGaNVSA0WqdvaPVTJ9USgEdYQACg2O1pvou6ijR312moxRQrRsiY1jSXWFFbweVMHCulTqjE7X4f53xWp1DejtZtaSL3s4y47U6Q+M1tuwa5enBcUqB8JzDF/PcI/rYPjjOw08PsW3vMEtvv5mucsje0SrbhsYJA+E5hy3m+MP7qEWGXcMTjNXq9FRKdFdCArGb3+weqfLQ00Ns2jGMAP3dldRI7O8q25nUkUl/4+rOw4AwfjBpj+1vV5AJkzTsb994PN2VBTgEETLT73x7ypLzBN544ZkBcF548y56uXITnZwwfyfAhrfAZAbV2bg4X8agceSbbNrc6Y6+qr5RMJmnIy/Obe+kDX0dwK7v8Y2zPB39ctw84v3361CgdqpnzkDeDUs3qXDDPX1yDbk83SbRpcjjlSvXTyvY2fReeYV1da8p57o2Xv4mOUXy8s5z8uSm9fUMvPR5BnwBYqayUqsNnHzyyeaOO2bnXcR3PrqTS750K0uWLAGgq1xiaU+Z/u4KHaWAUhBgMKkBkhgciREyXouQ+OZRCQN6O8t0VQJ2DE2wdc8YkTEc1tfJ0p4Odg1PsGX3KNV6xKF9nSzr6WC0WmPXcJXIGFYu7mT5og7CAOqRHfDXI8NYtc6DTw9x/xN7mahHLOkus2Z5D4f1dXJIbyeVUsD2oXG2D02ku6wlgwvBDgCGx2sMxgPG4fE6gUBHOYTaBP29PXSUg9SA7CyFjUFk2RqTxsDTg3YgPlqNMMZQKQUcuayHo5Z1M1aL+O32YZ7eO0alFFApBfR3V1ixqINFHSW2D43zxJ4xxibq2C3d7QD0mYf2MjpRY8OWvWzcPkRnyRqDIvbJ71jsHUsMzVIYpOflUAgDe27jbHi1ZhgcrzIyUae3s8ySeECwpLtMT0eJLbtH2bhtmI1bnmLZ0qWI01YipE+fx2sRY/EA9egVPRy5rId6ZI2GPaNVdsfGTSUM6OkIKQUB4zVrmIaB9ehUQmtslEtCKbDtUgok/b9tcJzHd42ye2QiNdqqdcPesSr1yLB6STfPWNadDsSGxqts2TXKE7vHEIHFXWUWd8bGXmdi+FqDb8fwBDuHJuiuhBze38WSngoj49YY27h5K+WePsaqESsXd3BYXxcdpYDRap2hsRrbhsZ5au8Y1bo1WjrLdpB+eH8XkTFs3TPGruEJDu3r5Mhl3ZTDgG2D4+wYmmAiHnDba6BMdyVkx9AET+wZY7xaTw3Xw/u7rMETG3nJw4Jq/GCjUgoIA2HPSJXtQ+MMT9RsmAgjE3UGx2qUQzugfPahi+koB1RrhkBg2aIOlnRbI3WsWmf3qG23LbtHeeiJnewaJzVyF3WU6Omw111vh30A4R5XSgETtYjxWvZ7P161YUcs6ebEVX2sWdbD8IRt303bR3jo6UGe3DMWD86t4doV/+/usGFdZftdC0QYGq+xd9ReW3vHqoxVI5Yv6mDl4g7CQBgcqzFWrXPI4k4O7+tEBLYPTbBjaIIdw+NsHxoniqCnwxoDPR0hXWVrFDy1d4xHnthOV/ei+KGEHQxHBvq6ymk/hYFgjDUKdo1MMFGzRndXOWR5b4VDejsJA+HpwXG2D44TBKTXeKVkr/dSmP2ehiKMxEZIYgA869DF1KOIHUMT7By2n+1DE+wcHmfn8AQjE3W6O0r0xIP9yFgjJIp/Fw9Z3MGaZT30dZV5fNcIj+0cZSw2EKP44ZL7kGnv4BBd3d3pQ5m6MdRj4y8xCkSsrl2VMK6zfVBRCoL0NzQxBPu6KiTOnK74oUVPR4lafO2Px/+jyNj+6u8kDAL2jEywa6TKrpEJ+xAv/p4IsHNkgqf3jlOtR2nduyvZviyXhKf3jvP4zhGGxmtp/KF9naxe0s14rc5dj+3i10/s5ZDeDo47pJexvdvpX3YIwxPW27eit4OJWsSGLXu4/8m9VMKApT0VOuOHSSNxOwpCT0fIsw7t5dgVizDAzmGrd6I/EP8ON/ociK+tpK2thy8bZmxY3Kff+YuX0TsLnsiBgQFe/vKX32mMOXnGhc8AHc9YbQ5/z180AooG4d5TekkMjCTa2U0tV1bTVKacNGSdTmlZdbIva83zDvmDUsHuQhfH5Xkl/F3wpoKvX6u4PNlNYXkG0nSNNvL7JCVvMJ4np6iPinTJS9tK/1Zp8gwF/5rLMZKmItdu1+/J9sv0wwzZbdf9ti0yavP0y1vD2EqeePX1cXVt8oTBpj//q9zfmwX4+AhOOnIpf/3CLtate3G7VZmUiZp9strXNXM3Ijs///dmTN6BhK37i9qtRlsYGNjFunUvabcabWFgYICX/e7vMVqt010OZ2Xa5HzEXu8va7cabUF/557fbjWUIlxjJc/jA5mBbu5Wg83uqaxhE5fRZGDkPLFvWgvmpRGai8/fyCEbl1mLlbfuqkiOnyVZP+VX2dHbXWflC0rC3PVG7nmRHum4WrLGoVu/XLtJsrLd8Dz5TfloLiuv7X398wzYpqmH5OvmFpKZTlike07bZeS2kO/qW+jBzJGR2655BnVe/qJbfl4a33Ppx7doF5cFaWAdSCSeIUVR9o8wEBZ16E+eoijtxV93BUzuaUp2w3PSmzDfFWTSP3G6qejkyPKn+fnbg+fq66RrQmxkOuXLTK5T85SunDcpCqlSjfeJmeI0yZ/EMJjEg5RxfLltkNM2mQzi9YGriy/fl+eENZXvyfDDTFF4Xhm5J63lZ7Ll6ZMXX5A/kz4nbVH75U66KzJk875TeXjtN6mHbAp1AzWwFEVRFEVR5gYxdvpd3qA1Ng4k4+0xmfOiPM3FSK5MP71EjUf+eeVPRY8iHVohRvYpX5GsVrq4ZSXHRXmmEu7G+bJ9WpXl5inqp1Z9XyR/sjxF8ifr46a41COY3+ZFZeYxFZ2LdMpr08m+F1PRx61z3rUw2fWrBpaiKIqiKMoc4e4imDc9yrgbMeScx4ENGS6ph8hk4tPBYM60JyM55eXIbtKjyGM1BVoOTn2PkB/mxRsxxe3hlZUcF9YxnaMXx/nt6eXJk+3rWVRWUx63Ln7evPypp8uRL2CinPL8tkzq5bVdpvwmz1eOd7Do+ivq34J+zOhRpLt4x+SUI2CStzfn5J1UL7LpCuVPATWwFEVRFEVR5oq8KUx5A9VW563CW8n1wlLjaiblzxRTLdsdrE9Xn1bpi2ROp4zptpVr2LWS1Ur+ZG0xlXoVXaOTTZ9rVe5kZU1V7mTyi2RPtd+mI78FamApiqIoiqLMBcngWXK8DG6aVudFYUn4dDxLyYY/7pP6qRpbUx1IT2cm4FTT53gzpsV0B9H7Y7gVGYWt8k2lHx1PVCas1TqlAi9YU5l55Rfpkxfme52malz6cvP0c8vMkz0VvffD+zpV1MBSFEVRFEWZKwo2p2hJ7q6BXljRHuVFb4mFaRo/sSx/cNpqS8Ci8vPSTLa1YFO+Kcp3y8gbWOe1GxSnzdsfPi++VRlTYV/2tJ8s/WQGnptuH1SeFlPVZbpyknbYlzpMRacpGvdqYCmKoiiKoswV+zJoFmga9eWF5ZXTcr3TFHRxB+7JPtl5+XLDJtExL2+RTkUGhL8veaEuBbo3DZK90XNTet/b1yK+SQevCDe8adBuWg7gm3GMiql6IVsxnSmNeeFTldEqzVS8UU11dtqtqD2m4h1sxRSmK6qBpSiKoiiK0gIR+TTwOuBpY8xz47ClwA3AGmAT8EfGmF2TC5tOwdOYSujHuZsV7A9NG2R4A39/ADxVHd00U5oW6Bk2efVrZTyZnPg8HWUKaSebukZOulZlTiesiCkM+ht1mqJXcaplTjV8umVOZapm3ou9XO/mZO06mVeylZ4tjGk1sBRFURRFUVrzGeBK4LNO2PuBHxpjLheR98fn72spRYC892ABImCM/d+KZBOzJF3epmZFMoo2QPPTu2W4Orn5p6xni1d5TqW++5J2qrSSOaW6TtUQmUsm08nfsW8qadxpnFOZ8pkw3TzGP88xfHINnJwyk/BWb7NuZPIiJ/OiTv5EQA0sRVEURVGUFhhjfiIia7zgM4B18fG1wACTGViAFBhYEA/k87wgfpqi88x0vhz5U1l746Vzdcrkb9LDYJzBrH3HVutpbhnnwyTOlTxHxX5hnLrlTEUrNqqcQzHWEJvOlDhfnNduLZlCG6Q6tUzkGiRJWIs07rm/lX2BDuAYqVOdFpu8n8vPj1evVu+wCqI47+ReJrcsH2Mk0zdTalcHNbAURVEURVGmz0pjzNb4+ElgZV4iEbkAuAAgXNY/pQGyi5nWqL1h0CSDQ1feVGSJmKZ06YDXCW8amAqIYw0azxBp0jSevpUnOy+PwauLM/CdDLcd0oEzzsCZrKxW7eSX57fXZPr4A/eplOPqPGl9nX7IK6upDaU53C/XPway7VfQF1Nti8KqTFNeUdrJymlkIjU4k/RuvumUrwaWoiiKoijKfmCMMVIw+jLGXA1cDdB5zBEmLEVNadxBrB/mh+cxWX5Xjp8277zVgLRIFz9fZKTZKZIZ7BvPCTLZ4HXyaVzNHoeseywvbKqyW2vmDMJz4x0dE13S/9n8eeTn8dM0l+nnK5JbtIGIZOplphw3VaxXct/yzotyWnwvZ8TAEpHXAP8EhMD/M8Zc7sW/G3g7UAO2AecbYx6dibIVRVEURVHawFMicpgxZquIHAY8PVkGEUO5UssYNYEzZdAYiKIAERN/GuFJ+jzDR6RhPBjTSOdOc/PXbiVhyTorX55LUd48gy5JE0XNxlwQmEy+vPrYNolyZU/F0CwyHN0wN7yovMnKyosvWtNVtKYtL02r8qbiQclbL5dnPOfpX+T1cfPk9VdrfYr7bqbX1bVq2yTc/Z7kfReKyGuzVn223waWiITAvwCvAjYDt4vITcaY+5xkdwMnG2NGROSdwMeAM/e3bEVRFEVRlDZxE/A24PL4/9cmyyACpVLd7nUhhroRSt7gvlqHIIjSNGC9Qf5SmcT7E8TGWEI9CjBA6ExxMkaIjGTS+oPFyDkPg6yXrR7ZnSqS/MYIdSe9O/BOyq0HktE1iUvqkjetLM/7lBpusZxWA/rMdC6vXiIm1/OTZ3AEkvUpFZWZN+CezMAqYl8NLD/cNZiT46yexvvfIHttGM8YMWmeIu9qa6NtakZycf5sGdNZu5b0i6uLfQCQNbjsA4DWdcjWt7jMmfBgvQh42Biz0Soh12MXfqYGljHmZif9L4BzZqBcRVEURVGUWUdErsNuaLFcRDYDH8IaVl8SkT8FHgX+aHJJJmP4hPF/d7DoGleu0VLkYUnyBwKRscaRO+hO4nE8Y9m6WVlhZpCeTePKTHWK46I4PJDs4DupW6Jnms45bm5nGxaIITHxAiddUT6ctIkhmUfoGbNRPDUudMpz5RS1Bzh7Q0yy1seGNdLmedim5jErWJeVGlNZI8s9dtNMzQuYPTbGeDKzXtfGcb53NVuP6U3Vcz1yti7F12kReR5dN3/SLtbAal0HN75VW86EgXUE8Lhzvhk4pUX6PwW+nRfhLgRduXIlAwMDM6BePkNDQ7Mqfz6jdR9otxptQes+0G415pyFWm/Qui/kus8GxpizC6J+fzpyRKCjXIuP86dclTxvkS1fPDnNA/WMtyt3el1UMPhvXrfUahrYZNP18jZFSDxoroETefmLjKIiEkPKlePLcL13RWX4erUqyz1P6jUVA8vVx6eoDyYjMhB4Rs9k/dRKdhSr5susR/Z6CgPTVKaf1y2vcV3mp5maYZpnUBZ7Pn3y1hcmDyJabeCRp0NRPYqY000uROQc4GTg9/Li3YWgJ598slm3bt2s6TIwMMBsyp/PaN3XtVuNtqB1X9duNeachVpv0Lov5LrPZwIxdJayBlZyDPGALaxnwtJwh6KBZl76VoPIfUlXlDYvn2/0TWY8tPJItBqUFw26JzMyigzKyeqWnNejINeo88ssql+rNHnTMlsZjP5U0Ly6urr7bZKUBzQZwpGxU1nzdPX1qTl6FxnNtbjdEgM50dm9XvywJI9fd7/MvLZx28Qv0413z/PyuXH+sc9MGFhbgNXO+ao4LIOIvBL4G+D3jDHjM1CuoiiKoijKAYNg0vVNeYPBIm9MKy+NmyYvjz+I9AeWvtxcnQoMp1blAwTxRLpIJFN+q/ICDFHOXnzpIDiRSfNA169/SaI0rWsoTLXMVnXL5HfiXFl++yZxeeX59avlDOzz2iyv3/Pq5babX36AScsDKEmUqUM9CiiH9aayEjmuPr5HtcjLGAbRpAZW2m6STIPNN6DcMuvxVFi/7VxZrnyw01ndOHf6q5vPDfOPfWbCwLodOE5EjsIaVmcBf+wmEJHnA1cBrzHGTLrLjqIoiqIoysGGQZoGZf6AzR+QTiXOl9NK/mQDxOnKh3wDEUh3mnDLLapHei6T6CXeeQsdXSPBLb9IZpGcorDcuFb6JfrkGGDpeY4uRcZ2nqfFPU+Mn+TY12Oyc3eDkFZ1bSq3RVu58lp9F6YS3kp2k7Gf4x2biuw8A9ePy2O/DSxjTE1ELgK+izUCP22M+bWIXArcYYy5Cfg/wCLgP8SuFHvMGPOG/S1bURRFURTlgME0poW5u/C5xxE2TT1n4JcXlhfvTylzw5rKiweObt56FFCP4/PWgtWNNA2686ae1clSzynfReLBedH0P99AbIUxQp3maYNJ+7plul4PmNr0Pmj2zsDkRsJkBkiekZKEuVPh3HBonkKXV16e7MmMt4SaMx1yqkZJkjZvOl5RejfMzVsKoowOrqyMV62Fp3EqurbK55ffihlZg2WM+RbwLS/sg87xK2eiHEVRFEVRlAMVQ7PXwR/UJVOxIDtIdinKa7A7DiY79QWQDsqTqXGTDo5pbAsv8XGy/safuuX+j4yAF583HbDlANWtlz/YhSbDoFX7uOX5Ovpya1GQqWORbk11idfLTWVdWbqmKSd9ZCSdOpoY10WGoW/oJfrmGY9Jea3KT87drfkTIzfRP5l6h2MAQ8PQ9g2cybxsJYmomcaar8mITGO651SMvFxvXgvDM29dlp8mrfckxlwaN+XaKYqiKIqiKPvNdKY8TTfvVNeIJCRGn5vWOP9do9CPn4rs/WUqRmFRnfN0L8pbZBRM1UM1lXi/jKZ2nUp/ufWbpi55uk3nvVT7U/fZxDWip+phmm3mdBdBRVEURVGUhYy7mD5vqlQgBrxtw5NpesZ5Gu8v2HcHmMn7pvLK9s99PUJnEwi//MALA2fNS05Zrp4iBqY4xSovjV++e+56iYry5umY4LffZFPY8nRJ0/plJh6XOC5935nTfm4eP971srierUAMkWQ3fihqC7sGq7n+vnfNleVeb35ZRTslFm1s4eOv+cpLn+f1nM4aKJ88j9V0mep7t0ANLEVRFEVRlDlBIJ2Klexc5k+7cw0n8cIhnk7m5BUjBN7A2xYW74jmDXrdwXypwJhyp4v5g+aQgnU0sSzJMyDijz8VLQ9/2l9Gnj9IzmkbVze//fKmgSXkbTEvBQPyRJc8Oe4Lkv14d+2Z2y4Zz1b8P7OTH1mDKs8YdNsiKpgumORxp/ZFOddOOq0uken4IjPT75qkx2kw6WYlRdNb/fR5uzjmPoBIdmL0DFA/3o/z5eRNL3Xb1d9KfrqogaUoiqIoijIXCJmtw5OBaEIyQLQD3qApPJEBdlBqB92SWXxf9FTfNbzSsESGo0QoUZOrIxm0JrrXaPZEJXXJDMDjAWpJ7EuOaxKkMpI2SPOS9WzkDXzz6uO2TTLw9o3CNE0s3u0DV0/IrjkrKj+V78h01/pkdHD6LZLG5iNumsSY8j1RQbwQrskA968Fr0+T8Lqni1urIm9TnvEhXpsm5OVLdJts6/tW+HW0BmOz7ABDzUzuFW1aW9VCt1aypuMxUwNLURRFURRljki9BaYxiE6MnMS4st4ekzGm3Hy+nKaBd1pY47DJmIvfyRUZSWUCjbI9fUOyA1S/rNQgcCgFUaZOpSDKeIpCsi/6TQyKVN+4Dpmy3Hjx2sYZgKfT7Zw0iXy/LZu8Qp4BE0p2gl0S79Y5NZaS95w5aZKyfK9bU796xnYUhyft2FRft73F6wcB4ndNuX0fiEnDXdx6+wZirsHo1NktIztdcmrGivheMr99vXq7dfev+8x1WHD955bnXXeTGbKT1U8NLEVRFEVRlDkglIjOsEYgEZEJ0v+uJydIvCtBkHnKXhK7Y12Us/ua7wnyw5M4/zwp3yWQiCjIX62U6FYzYVNZebKS8hLdU0MhR26S1/VUFOG+LNdtszy9fHnWE5dtS7f98sp3+2kquiWykrxJWf5LeYv6KzJCJahl8hXp5uctST1Tljttzvey+aQvOXa8Qkn7+oZjUmaed8i/rjN6TnGKoF9O5rvhtEmia8PLWs8t2y2jJHVqJszE+3qVvfNJd8D0UANLURRFURRlDgjEsKg83hTetL7HC3PDk7i8qVp56118mZMNEvMMpWaqk8QX6Vmb1iB1+kxNr8CdpjiF7cKn1iaTk9fPRen2pZ1aXRdF0wDz9Mkvv1q4psrN3yrNZOX7+k7WRnlMta6RqTVk5RiuUzGmW6EGlqIoiqIoyhwQYOgIak3hU1mr4j/RzwvLrEWaxOPREmm9EcVcU2R07q88K7N5vVW+wVp38rRnO/K0/AKP5UzKz5M9He/ivpTnexKTY19uq+9Lnqe2lTcr2Xgk9Iy5urNBTBGtXvytBpaiKIqiKMockbur2hQHpP5GApm4ZMMKI+mxm2wqXgFXpzxdMzrvg5zJ5E7GbHi/Wm2gMVt6THV3vUK8fp1qWXkerdz83royN7yVdyq55iZN4+mS5jFZORkdTPa4iLzr3k/vy881Cv21f0VlFaAGlqIoiqIoyhwgYigH9aZw90m4+9Q8eYruP03PO08oB/nhiRyXIplF+kyml5vXLc+XW+QZmGr66bTLZF6I6aSbCezOfsVtkLA/u/C5ZfnXQ9JueeFF55OVMVdtN1vl511nRdf2VMtSA0tRFEVRFGUOEBobPriUhHTTC5cAG1aS5vR+uvTYkeGHu+dJWLK2qLELXp1aFGbS+CRyGrvINTYfcMMa6aJMvuY8USZvI40pSG9S+VOpr7/mqvncNOmTHDe302Tv8fJ0cjw2fvu0Yipep7ypipl0Oe1T1G7uedP11WJdk593Mv1yr/MWa8Km4k11ZRTpmrfGK6ES5Letr0NJWtfNRQ0sRVEURVGUOSJvoGgHc1FOfPN22vlTyZoH9H64jcsaCjZtjgGVZ1Rl1i01p2klqzEozcsXZf5PRp6x09CtSPbU2sTXo/jY5A7A88oMk/IkyCk7/1rw8/mD/6zMZtz2yL+eGjom117eJhfJ/5CoqayivHm6F13TblwrGZnzmDpBRq/kuEjXvLSZsvxyElmODnl6FaEGlqIoiqIoyhxQtMnF/tLqKX/RU3s3fatd1/Jklj0v3GRykviy1FsajK28AkUenbxd84rKn6y8ybwgvqy8euQZQ3UCSkQtd+7zSQbydZoH8pPFJeFF67ry2m0yXdyy/PPp6DdVfBm+gZXgxidGV5GupVhGURq3DPfcTzuVuqmBpSiKoiiKMgeEEtEXjrZbjQOe6exUl/cerFY7MrbaQc9N56dt9R6nyeQcaIQSUZ+BbesPlHL3BTWwFEVRFEVR5oBQInrDsf2WU/Replbva6ojhPs4qK+TTFsr2JxikviZpqgueeF1x/AJMZk0vt6t6uHL8cN83LJapSsqL6/8qdZ5pplOGVNJm9fuU8kzHR18+e65G+bi65PX50V5fdTAUhRFURRFmQMEu5lC0XQnyJ8SlRcWFqxZCqV5uhPYzQimUq5fTpI3LzzJk+ScTH7R9Kq8qVlFU8Pq3lYdblrftAzJ2dij4Nivh69jrtnqbYjRvElJi7zTpEhGns5F/ZQ3Fc6Nz0uTtPdU8hbp6bdnUbsX6WDTtJ7+VyTPvwaSPK36ZLJ+m0p/qoGlKIqiKIoyB4QSsSwcAoo3dcjbcMH3SvkbPeTtjFeUP29HvSJv2HR0yovP242vqD5+urzjuaIdZe4vRZt1+GFT7cuiPvGv26m00/60Z95uk9ORuy95ZgI1sBRFURRFUeaAstQ5vLyr3Wq0JG8QrSjK9FADS1EURVEUZQ4IiegPGmuw8nZvm87ObwmtdsWbLH9e+VOVqShKPmpgKYqiKIqizAEClJ11JZE071iXF5aEg7PbnTgGVk5YXpy7412YvH8op/ypylQUJZ8ZMbBE5DXAPwEh8P+MMZd78R3AZ4GTgB3AmcaYTTNRtqIoiqIoyoFACUN/oNPvFOVgZ78NLBEJgX8BXgVsBm4XkZuMMfc5yf4U2GWMOVZEzgI+Cpy5v2UriqIoiqIcKIQSsDTsaLcaiqLMMjPhwXoR8LAxZiOAiFwPnAG4BtYZwPr4+EbgShERY4z6mBVFURRFWRAECB1SbrcaiqLMMjNhYB0BPO6cbwZOKUpjjKmJyB5gGbDdTSQiFwAXAKxcuZKBgYEZUC+foaGhWZU/n9G6D7RbjbagdR9otxpzzkKtN2jdF3LdZxoRWY1d5rASMMDVxph/EpGlwA3AGmAT8EfGmJZbBD5V7+ATO4+ecR0VRWkXD+eGzqtNLowxVwNXA5x88slm3bp1s1bWwMAAsyl/PqN1X9duNdqC1n1du9WYcxZqvUHrvpDrPgvUgPcYY+4SkV7gThH5PnAu8ENjzOUi8n7g/cD7WgnatnMx//al18yGjoqitIXv5YbOhIG1BVjtnK+Kw/LSbBaREtCH3exCURRFURRl3mKM2QpsjY8HReR+7MycM4B1cbJrgQEmMbA6dkxw9DWPzZquiqLMLQ8WhM+EgXU7cJyIHIU1pM4C/thLcxPwNuDnwJuAH+n6K0VRFEVRDiREZA3wfOBWYGVsfAE8iZ1CmJcnXf7QSTe1xzfPgaaKorST/Taw4jVVFwHfxW7T/mljzK9F5FLgDmPMTcC/A58TkYeBnVgjTFEURVEU5YBARBYBXwb+whizV5z3QxljjEj+G3jd5Q+LZak+XFaUBcCMrMEyxnwL+JYX9kHneAx480yUpSiKoiiKMpeISBlrXH3BGPOfcfBTInKYMWariBwGPN0+DRVFmU8E7VZAURRFURRlviLWVfXvwP3GmE84UcnyB+L/X5tr3RRFmZ/Mq10EFUVRFEVR5hn/DXgr8CsRuScO+9/A5cCXRORPgUeBP2qPeoqizDfUwFIURVEURSnAGHMLIAXRvz+XuiiKcmCgUwQVRVEURVEURVFmCDWwFEVRFEVRFEVRZgg1sBRFURRFURRFUWYINbAURVEURVEURVFmCDWwFEVRFEVRFEVRZgg1sBRFURRFURRFUWYINbAURVEURVEURVFmCDWwFEVRFEVRFEVRZgg1sBRFURRFURRFUWYINbAURVEURVEURVFmiFK7FZgO1WqVzZs3MzY2tt+y+vr6uP/++2dAqwOPmap7Z2cnq1atolwuz4BWiqIoiqIoinLgc0AZWJs3b6a3t5c1a9YgIvsla3BwkN7e3hnS7MBiJupujGHHjh1s3ryZo446aoY0UxRFURRFUZQDmwNqiuDY2BjLli3bb+NK2X9EhGXLls2IN1FRFEVRFEVRDhYOKAMLUONqHqF9oSiKoiiKoihZDjgDS1EURVEURVEUZb6iBtY0ERHOOeec9LxWq7FixQpe97rXzWq55557LjfeeOOsluFijOFd73oXxx57LCeccAJ33XXXnJWtKIqiKIqiKAcq+2VgichSEfm+iDwU/1+Sk2atiPxcRH4tIveKyJn7U2a76enpYcOGDYyOjgLw/e9/nyOOOKLNWu0/tVotc/7tb3+bhx56iIceeoirr76ad77znW3STFEURVEURVEOHPZ3F8H3Az80xlwuIu+Pz9/npRkB/sQY85CIHA7cKSLfNcbs3p+CP/z1X3PfE3v3OX+9XicMw0zYcw5fzIdef/ykeU8//XS++c1v8qY3vYnrrruOs88+m5/+9KcADA8Pc/HFF7Nhwwaq1Srr16/njDPOYNOmTbz1rW9leHgYgCuvvJJTTz2VgYEB1q9fz/Lly9mwYQMnnXQSn//851uub7r00kv5+te/zujoKKeeeipXXXUVGzdu5M1vfnPqaXrooYc488wzueuuu7jzzjt597vfzdDQEMuXL+fKK6+kt7eXdevWsXbtWm655RbOPvts3vOe96RlfO1rX+NP/uRPEBFe/OIXs3v3brZu3cphhx027bZWFEVRFEVRlIXC/k4RPAO4Nj6+Fnijn8AY86Ax5qH4+AngaWDFfpbbVs466yyuv/56xsbGuPfeeznllFPSuI985CO84hWv4LbbbuPmm2/mve99L8PDwxxyyCF8//vf56677uKGG27gXe96V5rn7rvv5oorruC+++5j48aN/OxnP2tZ/kUXXcTtt9+eetK+8Y1vcMwxx9DX18c999wDwDXXXMN5551HtVrl4osv5sYbb+TOO+/k/PPP59JLL01lTUxMcMcdd2SMK4AtW7awevXq9HzVqlVs2bJlf5pNURRFURRFUQ569teDtdIYszU+fhJY2SqxiLwIqACP7Ge5U/I0tWJ/3gV1wgknsGnTJq677jpOP/30TNz3vvc9brrpJj7+8Y8Ddmv5xx57jMMPP5yLLrqIe+65hzAMefDBB9M8L3rRi1i1ahUAa9euZdOmTbz0pS8tLP/mm2/mYx/7GCMjI+zcuZPjjz+e17/+9bz97W/nmmuu4ROf+AQ33HADt912G7/5zW/YsGEDr3rVqwDruVuxomHfnnnmAT1jU1EURVEURVHmFZMaWCLyA+DQnKi/cU+MMUZETAs5hwGfA95mjIkK0lwAXACwcuVKBgYGMvF9fX0MDg5OpvKUqNfr+yxrcHCQ0047jfe85z1861vfYufOndRqNQYHB6nX63z2s5/luOOOy+T5u7/7O5YsWcItt9xCFEWsWLGCwcFBRkZGCMMw1aVerzM0NNSkW7VaZXR0lG3btvHOd76TH//4x6xatYq/+7u/Y8+ePQwODvLqV7+aD33oQ7zkJS/hxBNPpFKpMDQ0xLOf/Wx++MMfNtW9Xq+n9fE55JBDePDBBznxxBMBeOyxx3Lbf2xsrKmf5jNDQ0MHlL4zidZ9oN1qzDkLtd6gdV/IdVcURWk3kxpYxphXFsWJyFMicpgxZmtsQD1dkG4x8E3gb4wxv2hR1tXA1QAnn3yyWbduXSb+/vvv32evk8/+eLB6e3t55zvfycqVK3nxi1/MwMAApVKJ3t5eXvva1/LpT3+aT37yk4gId999N89//vMZGxvjyCOPpK+vj2uuuYZ6vU5vby/d3d1pXoBKpUJnZ2eTbuVyma6uLsrlMiLCmjVrqNfrfP3rX+dNb3oTvb29afnvfve7+fd//3d6e3t5wQtewM6dO9mwYQMveclLqFar3H333bzoRS8iDEN6enpy2+EP//APufLKKznvvPO49dZbWbJkSZPRCNDZ2cnzn//8fWrHdjAwMIB/XS0UtO7r2q3GnLNQ6w1a94Vcd0VRlHazv2uwbgLeFh+/Dfian0BEKsBXgM8aY+Zun/FZZtWqVZl1VAmXXHIJ1WqVE044geOPP55LLrkEgAsvvJBrr72WE088kQceeICenp59Kre/v593vOMdPPe5z+W0007jhS98YSb+LW95C0EQ8OpXvxqwBtuNN97I+973Pk488UTWrl3LrbfeOmk5p59+OkcffTTHHnss73jHO/jXf/3XfdJXURRFURRFURYS+7sG63LgSyLyp8CjwB8BiMjJwJ8ZY94eh/0usExEzo3znWuMuWc/y24LedMP1q1blz4t7Orq4qqrrmpKc9xxx3Hvvfem5x/96Eeb8oLdXTCPz3zmM+nxZZddxmWXXZab7pZbbuG8887L7JC4du1afvKTn6TnyTS/Vk/6RIR/+Zd/KYxXFEVRFEVRFKWZ/TKwjDE7gN/PCb8DeHt8/Hng8/tTjjI1/uAP/oBHHnmEH/3oR+1WRVEURVEURVEWJPvrwVLmEV/5ylfarYKiKIqiKIqiLGj2dw2WoiiKoiiKoiiKEqMGlqIoiqIoiqIoygyhBpaiKIqiKEoBItIpIreJyC9F5Nci8uE4/CgRuVVEHhaRG+JdkxVFUdTAUhRFURRFacE48ApjzInAWuA1IvJi4KPAPxpjjgV2AX/aPhUVRZlPqIE1TUSEc845Jz2v1WqsWLGC173udbNa7rnnnsuNN87da8QeeOABXvKSl9DR0cHHP/7xOStXURRFUeYTxpK8o6UcfwzwCiC5MV8LvHHutVMUZT6iuwhOk56eHjZs2MDo6ChdXV18//vf54gjjmi3WvtNrVajVGpcDkuXLuWf//mf+epXv9o+pRRFURRlHiAiIXAncCzwL8AjwG5jTC1OshnIHQyIyAXABQCddM++soqitJ0D18D69vvhyV/tc/aueg1Cr/qHPg9ee/mkeU8//XS++c1v8qY3vYnrrruOs88+m5/+9KcADA8Pc/HFF7Nhwwaq1Srr16/njDPOYNOmTbz1rW9leHgYsC8UPvXUUxkYGGD9+vUsX76cDRs2cNJJJ/H5z38eESks/9JLL+XrX/86o6OjnHrqqVx11VVs3LiRN7/5zdx1110APPTQQ5x55pncdddd3Hnnnbz73e9maGiI5cuXc+WVV9Lb28u6detYu3Ytt9xyC2effTbvec970jIOOeQQDjnkEL75zW9Ot2kVRVEU5aDCGFMH1opIP/AV4NnTyHs1cDXAYllqZkVBRVHmFTpFcB8466yzuP766xkbG+Pee+/llFNOSeM+8pGP8IpXvILbbruNm2++mfe+970MDw9zyCGH8P3vf5+77rqLG264gXe9611pnrvvvpsrrriC++67j40bN/Kzn/2sZfkXXXQRt99+e+pJ+8Y3vsExxxxDX18f99xzDwDXXHMN5513HtVqlYsvvpgbb7yRO++8k/PPP59LL700lTUxMcEdd9yRMa4URVEURWnGGLMbuBl4CdAvIsmT2lXAlnbppSjK/OLA9WBNwdPUitHBQXp7e/cp7wknnMCmTZu47rrrOP300zNx3/ve97jpppvSdUtjY2M89thjHH744Vx00UXcc889hGHIgw8+mOZ50YtexKpVqwBYu3YtmzZt4qUvfWlh+TfffDMf+9jHGBkZYefOnRx//PG8/vWv5+1vfzvXXHMNn/jEJ7jhhhu47bbb+M1vfsOGDRt41ateBUC9XmfFihWprDPPPHOf2kBRFEVRFgIisgKoGmN2i0gX8CrsBhc3A28CrgfeBnytfVoqijKfOHANrDbzhje8gb/6q79iYGCAHTt2pOHGGL785S/zrGc9K5N+/fr1rFy5kl/+8pdEUURnZ2ca19HRkR6HYUitVqOIsbExLrzwQu644w5Wr17N+vXrGRsbA+AP//AP+fCHP8wrXvEKTjrpJJYtW8YTTzzB8ccfz89//vNUxuDgYHrc09Oz742gKIqiKAc/hwHXxuuwAuBLxphviMh9wPUichlwN/Dv7VRSUZT5g04R3EfOP/98PvShD/G85z0vE37aaafxyU9+EmPsNOu7774bgD179nDYYYcRBAGf+9znqNfr+1RuYkwtX76coaGhzM6CnZ2dnHbaabzzne/kvPPOA+BZz3oW27ZtSw2sarXK/fffv09lK4qiKMpCwxhzrzHm+caYE4wxzzXGXBqHbzTGvMgYc6wx5s3GmPF266ooyvxADax9ZNWqVZl1VAmXXHIJ1WqVE044geOPP55LLrkEgAsvvJBrr72WE088kQceeGCfPUf9/f284x3v4LnPfS6nnXYaL3zhCzPxb3nLWwiCgFe/+tUAVCoVbrzxRt73vvdx4oknsnbtWm699dZJy3nyySdZtWoVn/jEJ7jssstYtWoVe/fu3SedFUVRFEVRFGWhoFMEp8nQ0FBT2Lp161i3bh0AXV1dXHXVVU1pjjvuOO699970/KMf/WhTXrC7C+bxmc98Jj2+7LLLuOyyy3LT3XLLLZx33nmEYZiGrV27lp/85CfpeTJFcGBgIFcGwKGHHsrmzZsL4xVFURRFURRFaUYNrIOIP/iDP+CRRx7hRz/6UbtVURRFURRFUZQFiRpYBxFf+cpX2q2CoiiKoiiKoixodA2WoiiKoiiKoijKDKEGlqIoiqIoiqIoygyhBpaiKIqiKIqiKMoMoQaWoiiKoiiKoijKDLFfBpaILBWR74vIQ/H/JS3SLhaRzSKSvw/5AYKIcM4556TntVqNFStW8LrXvW5Wyz333HMzLxWebb7whS9wwgkn8LznPY9TTz2VX/7yl3NWtqIoiqIoiqIcqOyvB+v9wA+NMccBP4zPi/hb4Cct4g8Ienp62LBhA6OjowB8//vf54gjjmizVvtPrVbLnB911FH8+Mc/5le/+hWXXHIJF1xwQZs0UxRFURRFUZQDh/3dpv0MYF18fC0wALzPTyQiJwErge8AJ+9nmQB89LaP8sDOB/Y5f71ez7yMF+DZS5/N+17UpH4Tp59+Ot/85jd505vexHXXXcfZZ5/NT3/6UwCGh4e5+OKL2bBhA9VqlfXr13PGGWewadMm3vrWtzI8PAzYFwqfeuqpDAwMsH79epYvX86GDRs46aST+PznP4+IFJZ/6aWX8vWvf53R0VFOPfVUrrrqKjZu3Mib3/xm7rrrLgAeeughzjzzTO666y7uvPNO3v3udzM0NMTy5cu58sor6e3tZd26daxdu5ZbbrmFs88+m/e85z1pGaeeemp6/OIXv1hfOqwoiqIoiqIoU2B/PVgrjTFb4+MnsUZUBhEJgH8A/mo/y5o3nHXWWVx//fWMjY1x7733csopp6RxH/nIR3jFK17Bbbfdxs0338x73/tehoeHOeSQQ/j+97/PXXfdxQ033MC73vWuNM/dd9/NFVdcwX333cfGjRv52c9+1rL8iy66iNtvvz31pH3jG9/gmGOOoa+vj3vuuQeAa665hvPOO49qtcrFF1/MjTfeyJ133sn555/PpZdemsqamJjgjjvuyBhXPv/+7//Oa1/72n1sLUVRFEVRFEVZOEzqwRKRHwCH5kT9jXtijDEiYnLSXQh8yxizuZVXJi7rAuACgJUrVzIwMJCJ7+vrY3Bw0Ar9nQsnU70leR4sIJXfiqOOOoqNGzdyzTXX8MpXvpKRkRFqtRqDg4N85zvf4atf/Sof+9jHABgdHeX+++/n0EMP5a/+6q/41a9+RRiGPPzwwwwODjIyMsJJJ51EX18fw8PDHH/88dx///2ceOKJmTKr1Sqjo6MMDg7yrW99iyuuuILR0VF27drFsccey7p163jLW97CVVddxd///d9z3XXXcfPNN3PXXXexYcMGfv/3fz+t98qVKxkcHKRer/P617++ZZ1/8pOf8G//9m9897vfzU03NjbW1E/zmaGhoQNK35lE6z7QbjXmnIVab9C6L+S6K4qitJtJDSxjzCuL4kTkKRE5zBizVUQOA57OSfYS4GUiciGwCKiIyJAxpmm9ljHmauBqgJNPPtmsW7cuE3///ffT29s7mcpTYnBwcJ9l9fb28sY3vpEPfOADDAwMsGPHDkqlEr29vYgIX/nKV3jWs56VybN+/XpWrVrFF7/4RaIoorOzk97eXrq7u+nu7k516ezspFwuN+lWLpfp6uqiXC7znve8hzvuuIPVq1ezfv16jDH09vZyzjnn8LGPfYwf//jHvPCFL2TNmjUMDg5y/PHH8/Of/7yp7mEYsmLFisJ2uPfee3nXu97Ft7/9bdasWZObprOzk+c///n71I7tYGBgAP+6Wiho3de1W405Z6HWG7TuC7nuiqIo7WZ/pwjeBLwtPn4b8DU/gTHmLcaYZxhj1mCnCX42z7g60Dj//PP50Ic+xPOe97xM+GmnncYnP/lJjLHOvLvvvhuAPXv2cNhhhxEEAZ/73Oeo1+v7VO7Y2BgAy5cvZ2hoKLOzYGdnJ6eddhrvfOc7Oe+88wB41rOexbZt21IDq1qtcv/9909azmOPPcb/+B//g8997nM885nP3CddFUVRFEVRFGWhsb8G1uXAq0TkIeCV8TkicrKI/L/9VW4+s2rVqsw6qoRLLrmEarXKCSecwPHHH88ll1wCwIUXXsi1117LiSeeyAMPPEBPT88+ldvf38873vEOnvvc53Laaafxwhe+MBP/lre8hSAIePWrXw1ApVLhxhtv5H3vex8nnngia9eu5dZbb520nEsvvZQdO3Zw4YUXsnbtWk4+eUb2JlEURVEURVGUgxpJPC3zjZNPPtnccccdmbD777+f3/md35kR+fszRXA+8/GPf5w9e/bwt3/7t4VpZrLuM9knc8FCnzqjdV9YLNR6g9Z9Idf95S9/+Z3GmHn5VHCxLDWnyO+3Ww1FUWaIH5gbc39v9nebdmUe8Qd/8Ac88sgj/OhHP2q3KoqiKIqiKIqyIFED6yDiK1/5SrtVUBRFURRFUZQFzf6uwZpz5uuUxoWI9oWiKIqiKIqiZDmgDKzOzk527NihA/t5gDGGHTt20NnZ2W5VFEVRFEVRFGXecEBNEVy1ahWbN29m27Zt+y1rbGxswRoHM1X3zs5OVq1aNQMaKYqiKIqiKMrBwQFlYJXLZY466qgZkTUwMHBAvSB3JlnIdVcURVEURVGU2eSAmiKoKIqiKIqiKIoyn1EDS1EURVEURVEUZYZQA0tRFEVRFEVRFGWGkPm6I5+IbAMencUilgPbZ1H+fEbrvjDRui88Fmq9Qeu+kOveY4xZ0W5F8ojHNsO0t3/aeX20+9rU8rX8mS7/yLzfm3lrYM02InKHMebkduvRDrTuWveFxkKt+0KtN2jdte7zl3br2M7yF3LdtfyFVb5OEVQURVEURVEURZkh1MBSFEVRFEVRFEWZIRaygXV1uxVoI1r3hYnWfeGxUOsNWveFyoFQ93br2M7yF3LdtfwFVP6CXYOlKIqiKIqiKIoy0yxkD5aiKIqiKIqiKMqMogaWoiiKoiiKoijKDLEgDSwReY2I/EZEHhaR97dbn9lERFaLyM0icp+I/FpE/jwOXy8iW0Tknvhzert1nQ1EZJOI/Cqu4x1x2FIR+b6IPBT/X9JuPWcSEXmW06/3iMheEfmLg7XPReTTIvK0iGxwwnL7WCz/HH/37xWRF7RP8/2noO7/R0QeiOv3FRHpj8PXiMio0/+fapviM0BB3QuvcRH5/+J+/42InNYerWeGgrrf4NR7k4jcE4cfNP3e4n52QHzf53rsMR/u/+28B7fjXtjO+1G77wft/k2ed7+LxpgF9QFC4BHgaKAC/BJ4Trv1msX6Hga8ID7uBR4EngOsB/6q3frNQf03Acu9sI8B74+P3w98tN16zmL9Q+BJ4MiDtc+B3wVeAGyYrI+B04FvAwK8GLi13frPQt1fDZTi4486dV/jpjvQPwV1z73G49+8XwIdwFHxPSBsdx1msu5e/D8AHzzY+r3F/Wzef9/bMfaYD/f/+XIPnqt7YTvvR+2+H7T7N3m+/S4uRA/Wi4CHjTEbjTETwPXAGW3WadYwxmw1xtwVHw8C9wNHtFertnMGcG18fC3wxvapMuv8PvCIMebRdisyWxhjfgLs9IKL+vgM4LPG8gugX0QOmxNFZ4G8uhtjvmeMqcWnvwBWzblic0BBvxdxBnC9MWbcGPNb4GHsveCApFXdRUSAPwKum1Ol5oAW97MD4fs+52OPeXz/b8c9eE7uhe28H7X7ftDu3+T59ru4EA2sI4DHnfPNzI8fnFlHRNYAzwdujYMuit3Gn54tF/08wADfE5E7ReSCOGylMWZrfPwksLI9qs0JZ5H9QVkIfQ7FfbzQvv/nY5+QJhwlIneLyI9F5GXtUmqWybvGF1K/vwx4yhjzkBN20PW7dz87EL7vbdWljff/+XIPbue9cL5cn+26H8yH3+Q5/11ciAbWgkREFgFfBv7CGLMX+L/AMcBaYCvWdXow8lJjzAuA1wL/S0R+14001ld8UL6rQEQqwBuA/4iDFkqfZziY+7gVIvI3QA34Qhy0FXiGMeb5wLuBL4rI4nbpN0ssyGvc42yyA8mDrt9z7mcpC/X73oo23//bfg+eT/fCdl2fbbwfzJff5Dn/XVyIBtYWYLVzvioOO2gRkTL2x/ULxpj/BDDGPGWMqRtjIuDfOICny7TCGLMl/v808BVsPZ9K3PDx/6fbp+Gs8lrgLmPMU7Bw+jymqI8XxPdfRM4FXge8Jb6hE0/F2BEf34md8/7Mtik5C7S4xhdKv5eA/wHckIQdbP2edz/jwPi+t0WXdt//58k9uN33wrZen+28H8yH3+R2/S4uRAPrduA4ETkqfqpxFnBTm3WaNeJ5p/8O3G+M+YQT7s7z/QNgg5/3QEdEekSkNznGLvbcgO3vt8XJ3gZ8rT0azjqZJzYLoc8divr4JuBPxPJiYI8zdeOgQEReA/w18AZjzIgTvkJEwvj4aOA4YGN7tJwdWlzjNwFniUiHiByFrfttc63fHPBK4AFjzOYk4GDq96L7GQfG933Oxx7tvv/Po3twu++Fbbs+230/mCe/ye35XTSzuIPGfP1gd255EGux/k279Znlur4U646+F7gn/pwOfA74VRx+E3BYu3Wdhbofjd2l5pfAr5O+BpYBPwQeAn4ALG23rrNQ9x5gB9DnhB2UfY69cW4Fqth53H9a1MfY3Zr+Jf7u/wo4ud36z0LdH8bObU++75+K0/5h/D24B7gLeH279Z+Fuhde48DfxP3+G+C17dZ/puseh38G+DMv7UHT7y3uZwfE9505Hnu0aK85uRcwD+7BzPG9sOB3aU6uz4Ky5+x+UFD+nP0m55Ufh3+GNvwuSlyQoiiKoiiKoiiKsp8sxCmCiqIoiqIoiqIos4IaWIqiKIqiKIqiKDOEGliKoiiKoiiKoigzhBpYiqIoiqIoiqIoM4QaWIqiKIqiKIqiKDOEGliKoiiKoiiKoigzhBpYiqIoiqIoiqIoM4QaWIqiKIqiKIqiKDOEGliKoiiKoiiKoigzhBpYiqIoiqIoiqIoM4QaWIqiKIqiKIqiKDOEGliKoiiKoiiKoigzhBpYirKAEJFPicglsyT71yKybjZktwMRWScim2dQ3rkicss00m8SkVfOQLlDInL0PuZ9i4h8b391UBRl4XAg3mdEZEBE3l4Q94z4dzSc6XLnEyLyGRG5rN16HCyogaUoDjM1qJ0P5A3ojTF/Zoz52xmQ3fRDbIw53hgzsL+yp6HDtAyWhYoxZpExZuNk6URkjYgYESk5eb9gjHn17GqoKMp8ITY0dolIxxTTH9T3mbjMx+Lf0XqrdHpPmhlE5DARuUlEnojvSWvardO+oAaWoswj3MGtcuCi/agoyoFGPJB9GWCAN7RXG8VFLAfdmL3gXhkB3wH+cI7VmVEOus5SlNlARJaIyDdEZFv8dO8bIrIqjnuziNzppX+3iHwtPu4QkY+LyGMi8lQ8faIrjlsnIptF5H0i8iRwTU7Zx4jIj0Rkh4hsF5EviEi/E79aRP4z1m2HiFwpIr8DfAp4STy1YXecNn0iKCL3i8jrHDmlWMYL4vP/EJEnRWSPiPxERI6Pwy8A3gL8dSz763F46v2L63xF/ATqifi4w6vze0TkaRHZKiLntWj7c0Vko4gMishv42lrRfX77yJyt4jsFZHHRWS9Iyfx0Lwt7ovtIvI3TnxX3D67ROQ+4IWeHu8XkUdiPe4TkT/wdPyZiPyjiOwA1ovIsvgp3F4RuQ04pqiOsYy3isijcR/+jRcXOOXvEJEvicjSOO7bInKRl/6XIvI/4mMjIsdO1j7AT+L/u+M2fYl4T2RF5FQRuT2+Jm4XkVOduAER+du4HQZF5HsisrxVnRVFmVf8CfAL4DPA29yIg/0+E3Nk3u+XeN79ad6T+kTks3GdHxWRD0hsKIlIKCL/EN+LfisiF3nlDIjIR0TkZ8AIcLSInBe36WCsw/902jap8187dX6jiJwuIg+KyE4R+d9TuRCkjWMeY8xTxph/BW6fiq7zFmOMfvSjn/gDbAJemRO+DPs0pRvoBf4D+Goc1wHsBH7HSX838Ifx8T8CNwFL47xfB/4+jlsH1ICPxnK6cso+FnhVHL8COxC+Io4LgV/GZfQAncBL47hzgVs8WZ8BLouPPwh8wYn778D9zvn5sb4dwBXAPXly8toOuBR7oz4k1vm/gL/16nwpUAZOx948luTUvQfYCzwrPj8MOL5F/dYBz8M+PDoBeAp4Yxy3Bvtk9t+ALuBEYDzpN+By4KdxP60GNgCbHdlvBg6PZZ8JDAOHObrUgIuBUiz/euBLcR2eC2zx9XVkPwcYAn43bu9PxPKS9vzzuD1XxfFXAdfFcX8C/MyTtRvoiM8NcOw02qfkyErbOG6XXcBb4zqeHZ8vi+MHgEeAZ8b1HwAub/d3Wj/60c/UPsDDwIXASUAVWBmHH9T3mTh94e+X+9vI9O9JnwW+FtdxDfAg8Kdx3J8B92F/15cAP3B/g2MdHgOOj8sux+13DCDA78V1eoFX5w/Gad8BbAO+GJd/PDAKHFXQBm6/tW3M48gsxe2xpt3fjX36PrVbAf3oZz59KDCwctKtBXY55/8X+Eh8fDx24NkR/wgOA8c4aV8C/DY+XgdMAJ3T0PGNwN2OrG04g2InXd6PvfsDeiwwCHTH518APlhQZn/8Q9fny8lrO+yN6nQn7jRgk1PnUbID+aeBF+eU24M1Fv7Q/yHOq19O/iuAf4yP18R1WOXE3wacFR9vBF7jxF2AY2DlyL4HOMPR5TEnLsQOUJ7thP1dkb7YG+L1Xr0nnPa8H/h9J/6wWH4JewMbBo6M4z4CfNpJmxpYU2yfIgPrrcBtXv6fA+fGxwPAB5y4C4HvTPc7qB/96GfuP8BL49+U5fH5A8BfxscH9X0mjiv8/aLZwNrNFO5J2PvABPAcJ+x/AgPx8Y+A/+nEvZJmA+vSSfrtq8Cfe3UO4/PeWN4pTvo7iR+q5chqam8nbi1zPObhADewdIqgokwBEekWkatiF/9erBepXxq7Cl0L/LGICHYg+iVjzDj2qVo3cKeI7I6nDXwnDk/YZowZa1H2ShG5XkS2xGV/HkimXq0GHjXG1KZbJ2PMw9iB++tFpBs75/6LcZmhiFwudkraXuxNDafcyTgceNQ5fzQOS9jh6TwCLMrRcRjrLfozYKuIfFNEnl1UqIicIiI3x9Ma9sT5fJ2fLCj3cOBxT2dX9p+IyD1OPz7Xk+3mXYG9ORTK88iUHdd7hxN/JPAVp+z7gTr2CfMg8E3grDjt2dhBTBNTbJ9WOvp1eBQ4wjkvaltFUeY3bwO+Z4zZHp9/kcY0wYP6PuMw6e/XNO9Jy7GeJF/H5DfTv+e4x7lhIvJaEflFPN1vN9Yz57bXDtPYjGM0/v+UEz+aVy+fdo55DhbUwFKUqfEe4FnYJ0GLsVO5wD6twRjzC+xTmZcBfwx8Lo7fjv1BO94Y0x9/+owx7g+cmaTsv4vTPC8u+5ykXOyP7zMkf6HoZHIBrsMOyM8A7otvhsR1OAP7RK0P+wQPp9zJZD+BNQoSnhGHTRtjzHeNMa/Cem0ewE7xK9Lhi9ipCauNMX3YOfGSky6PrdiBhKszACJyZFzuRdgpcf3YKYSubFefbdhpELnyJis7Hogsc+IfB17rXEP9xphOY8yWOP464GwReQl2+s7NBeW0ap/p9mlSpy05aRVFOUCI18f8EfB7YtdDPQn8JXCiiJzIArjPTIdp3JO2Y72Cvo7Jb+ZW7PTABPd+kRaXHIhdX/Zl4OPYh2v9wLeY+j1uOrRzzHNQoAaWojRTFpFO55NMwxrFbgCwFPhQTr7PAlcCVWPMLQDGmAj74/uPInIIgIgcISKnTUOfXuz6nD0icgTwXifuNuyP9OUi0hPr+9/iuKeAVSJSaSH7euDVwDuJnyo6ZY5jvSjdWCPP5Smg1buVrgM+ICIrxC4U/iDW8zYtYu/dGSLSE+szhN1hKNHBr18vsNMYMyYiL8L+8E+VLwH/X7y4dxV2PVVCD/amsC3W6zysByuX+Anif2I3u+gWkefgLRr3uBF4nYi8NK7PpWR/nz8FfCQ29Ijb9Qwn/lvYm/ilwA3xdZdHq/bZhm3bon79FvBMEfljsQvVz8Su9/pGi3opijL/eSPWI/4c7FSwtcDvYNek/gkH+X1mOkznnhTfB76E/e3ujX+/3+3o+CXgz+MxQT/wvkmKr2Cn4W0DaiLyWmy7zgbtHPMgIp3YugJ0xOcHFGpgKUoz38L+sCSf9di1Kl3YpzO/wLq8fT6HHXT7P/Dvwy4e/kXsav8B9snQVPkw8AJgD3Yq2H8mEfEP+Oux89wfAzZjpy+And/9a+BJEdlODsaYrdh1NKcCNzhRn8VOZdiCXYT7Cy/rvwPPiacAfDVH9GXAHcC9wK+Au+Kw6RJgb0hPYBfV/h72Jg359bsQuFREBrE32y9No6wPY+v8W+B7NJ7IYYy5D/gHbFs9hd0o4meTyLsIOxXjSezc9muKEhpjfg38L+zgYyt2Prv7kuN/wnqevhfX7RfAKU7+cex18UqyAxifwvYxxoxg12/9LO7XF3s67gBeh32yuQP4a+B1zpQiRVEOTN4GXGPs+56eTD7YwfNbsF6Lg/k+Mx2me0+6GLsmaSNwC/b3+dNx3L9h7zX3YjeJ+BZ25kPu+7bi6eDvwv5u78I+ILtp5qqW4QraN+YBO/Yaio8foDHd8YBB4oVkiqLsJ/E0i6exO/o81G59FEVRFEU5MIg9Up8yxvhTseclOuZpjXqwFGXmeCdwu/7QKIqiKIrSCrHvXjw9nnJ9BHYa3lfardc00DFPC/IWLE4bEfk0durI08aYpnUJ8S4j/0TjPQTnGmPumomyFWU+ICKbsNMo3theTRRFURRFOQAQ7NT0G7BT4L6Jnbo979Exz+TMyBRBEfld7FzJzxYYWKdj56Gejl038E/GmFP8dIqiKIqiKAcKIvIa7APkEPh/xpjL26ySoijzgBmZImiM+Ql2sV8RZ2CNLxNv7dgvIofNRNmKoiiKoihzTfxOoH8BXovdge/seMdQRVEWODMyRXAKHEH2ZWmb47CtbiIRuQC4AKCrq+uk1avzXgkwM0RRRBAszCVoWnet+0JjodZ9odYbtO4Lue4PP/zwdmPMislT7zcvAh42xmwEEJHrid/1VJSh3NFjOnqWNoUb501GYrLhYhr/3bQSYSdpiX2HhORNSDJM6S1JEhkrVyQ/j4kDc8IT/dy8xkvXpFtynr7xytj8k+nt55uKjnE+iWdsWd0kK2yqbRRINqtXf4myZYiJ87j1n8pbq4rq6bST1E0ab0Sc47i9kzb02xY3rhHg1sOIc305eSRqlEkEpiQNeZ7yaZ8bMEEsL66T2wduOhsX18+dYdekrxfedM1lZRu3/k1vWXPq7lY4AKkZTBCHu9eqcz68a3Pu781cGVhTwhhzNXA1wMknn2zuuOOOWStrYGCAdevWzZr8+YzWfV271WgLWvd17VZjzlmo9Qat+0Ku+8tf/vJH56i4vIfHLZc/dPQs5Xmv+vN0AGxCQeqGqCx2IGfsQDSoG6LQhgU1Q1QSgpodKJvADgZLYwYTkqYLq/FgHuzAP4qNs8AxyjzjDWx54XgsqyRIBCbMpgtqNAbwAWk54USE1G36JCwqCVGc34Q2r0RkjJGgntTfxklk62iNEUNQz5bj1ifV3RtwB3Vbf9cYrZcFMRBUDUEyWI4H8WJMPPgXopLXPnHfJDqDlVGvWB3F2H6RutXLBBCVhXDcZOoSVA31Dkn7W0wc59qScR2DuonTNOqV6Au2n0vjEVFoB/el4QhTkrSdkjqY0JYrEUQlCCcSfWy6INbZJa1HfD0ldbF5rE4SQWm4btsFW/+JxWFqjLkyk7aVupUddQjBRKOMeiVIr+30+q7G34NQ4mvOpOUk7SRuGwFBNaLeERCVXQPTHktkGu0YNho8+Z5BrLdzHbj2Vb0iVPbWGzrF36Pke5bI+fmN7839vZkrA2sL2TdUr6LxJmtFURRFUZSDEnd2TqW73waa2CCIB3gZQyj2BFlviKSDWzvwTsJigyHCMdQgqEWpwZV6vuqxSPcJf3ycGDqJFyANTwa1Itb54RgzyaDZ6iuYEumA1hpohjAebEeREFaTAWw8+K+Z2GPWqGfi5UnkQjJgN6lB4zudjEDgDOpTz0cyaAbEOF6loCHD9Y6IMUjkeigS742xdY2SijeMXzcslZO2izR0DxuGXzKQb9Qt1dzRpdEe1kPVMMaCuufRCZw6SWJMS2rs2OtK0rikfSV5y5bryXGNE0j7CLHXVdJmJmx48BLDyjXGxdgHA5jEm2mFRyVJ2zUqS2ogJ4ZKw7BvGDJJm0VliftPkLChs62HNa6iUqPvo1Lcvo7nMArttW6c6yYKYx3SytOECbPGVdLGeQ8sfObKwLoJuCh2n58C7IlfPKcoiqIoinIgMqWHx+7snEVLVpnEYAqqrqvCTr2qVwKikuthsAPigGxYUDNIzQ4NpQ71jtgbUDVIGWqdkg6cJWp4DpKn+1FsgAVVawS4HihIdGt4iuodsQct8UqYxOsmqUEUjhvqlSD17EDsHRuLYhmBLTfxoIR2lC51qJftAFgiQ5QaSrYCiacgMSYa07lwjKfGwF+i2Ihw6u6mcb1OCU3nxmCMNDxfAvXOwBpXtdiQij09BCY1qIKa9XIl7RSVJc1P3FemEhu2aVmJfrH+tThNzVAPG4N/iRLPW7Y+6YA/8Q7WHAPQ4Biy9jyomca1QNbYTIy1pN71wBqo1vsnsVcPJDF8IwOJ0SUgVTAVgdh7ZLAGeuRMJYzK0vBoxnENI4rUqDShgajheWsoGOdNPG5lIQolNU5Tb6/79QoFEzn1JGsope3meEiNkHqW04cThtQ763oa85ipbdqvA9YBy0VkM3Yv/zKAMeZT2LdTn459s/MIcN5MlKsoiqIoitImbgeOE5GjsIbVWcAft8rgThXDWZOSDMKl1PBQJV6AZLDvrkORmudZiT01QTXChM68Mkin4IFAaDLrURJviTvYBFLdREzG8Eq9Q1FsQITZwWcy0E88YJE0vDquB8xf22PdZCYzYJU6GU9B7ljWOP8dI0aMyXom3IF0bGikRlVsMGAkU5dkwC61CAmEujTaXSITbxPX8HxJRGpYWp0bRkim35P+TYuSTB4xDe9epj2ibF8kBqHvmUwM+Ly2SnRPDKUiXK+VRNjrQUindPprokxiYxmTGuVpUwaxUWKsERSFtukkEozY2kdhcl043i3Py5VWI77ewbl2g4ZOblq335vWs7llJB6zpP+kYfC5bW4bRewDkUmYEQPLGHP2JPEG+F8zUZaiKIqizHeq1SqbN29mbGxszsvu6+vj/vvvn/Ny55rOzk5WrVpFuVxuS/nGmJqIXAR8F7tN+6eNMb9umcedipVYDUK6rsZ+kqf2jYGfO30vGeiaKB4Eho2n/FE5sN4CEUwQT+MLGzLSwWg8kE3WCpl0ulk8cC05HgXcQW5jClz6dD9Ze5Wchw2PRRQKgTfNypSS+sd1LDU8BsQDZnDWDaUDYdtmjeljic6OkRFARGOanJXZaDeIp6OlG140LIGmaWDxlEZTCuIybd2SwqKS2POoYWlE5cBOmTRxuNPGGDt9DbFr1PxNS5J6RfGUy0a/xH2RGLCp5dLQMUmQ0TO5VjIGhxAlslP7U5KoTB9Rjz1DYpuw4QFtXAN2ymByrZh0LVRmY4/YO0sS5OrkepmSazTty8Z5GubYzASCCRvrxHC8kHnlJ+v7TGC9Wb4h5/dFU9lJGyXXokk1yWVebXKhKIqiKAcDmzdvpre3lzVr1iD+Dl6zzODgIL29vXNa5lxjjGHHjh1s3ryZo446qp16fAs7S2eKSPovKtspaCYQTNkOXu0mA2S8TFH81NxI4+l6vRIbMcmgPB5Q1yvWmIlCIF73khgj6eYLTYN0yRgqkoQ5l21USgao7pP9JI81WKpBkOqUTNmKQjBBEE8vs7JqHUFmYJusz0nzlkDqznobyRqRiRGRGEKNzmisvwlqdhqeNaZojIMFO/KNvSkmNlaDmjP1K7Keu6StgtjQSze4KJnUuInKEq/TSvqhsQ5NjN1kI7tmJ+6b0NHLNbBCUtlJm5jYS1hPptYlsupOP6SyJZVl279hQKbNJI26p2FxG7h9knr4xHqbEoNVTKOMdBOMCCSwa6HsxiKOJ69u26Bebnj1Up3rjX6sV8hM+UxlGFJj2p3WaKe2JteD4+VyDMVG+bFxGzdGROOaT9okMRyT/FHi5Uu/KxBJoxwDme+pjxpYiqIoijLDjI2NtcW4WiiICMuWLWPbtm3tVmV6uIPpeK2ICeOBeDygS9ZEpV6YMNk22zHOwsZx6oXxvBVRaHeMi8pWbli15TQMqcag1R1sQmJQQTqVLmx4RdIpX7HjxhoKAhVSoyDVPTZM3M0zmo08Z0fEeAfCxG5KpqgZp36JvhKBKZMajxhblsRtyESsd1xG2l7JhhrxAL5eSXbMs4UGyfqq2LhJ2sJuzmA3jkgG78kaK4kk3n0vNg5ioysqWY+UeFPKGm2UnbLpb7ThtondKbJhOASByRpQiTc0uR6S/g0kIzsKvV0hBaIyBFUaRmeyrbpjCIcTVtdkq/a07FhXMcZeX5BpoyBwjFfXQBeQUNINXKISBDVJdSSeZxjUgMhkyjM01xviuhvsVNikPz2jDuyaRndnwaQd0mvM2Xwj7ZrE60XjGnQ3+PBRA0tRFEVRZgE1rmaXA7p9Xe+BNLxIyUYGNo1ppHMMEnfaYMYLETQ8R+ngOspuEpF5ag+pJeOvW8kYQInh5qxxMemAGTsDK9lNzllXlsp1DLokLFOeU2aaPomPxK6PSuIdYzKjl7HpTBCrGa/vabQl6domN4+7eUbTNLFkjVWy1ic1zhpyGwZMUnZiBDTCMkJp9EWiWGadWWx4BI53Km0X5xycvnUNDae/UgPJ79sQu/uk1+7u9uUmpLkPU0+cNOSKa4hld69Mqm1Mtqx0rV6ip3u9utd7kj+xpdx60ahXaoBj28iu3XOMeMmmz7a/0z3uz4mXt3HtS/Z74F/HDmpgKYqiKIqizAFGYo8OxIO3IOP5gMagLd2e3N9QwF135BpDyVN1Guki1wihsb4H4oGpO6D2cQ0OyQ5i3WlSmQGvMyBtMtJIPHVkB7NOeLr+yNXR9zQ409JMGBt4QWxUxfWIYgMqyoxypVHXxPMWy6s771GSZE1ZaOUmI3wTJPZjQ5906plxPCSCXS4WJd4r0nfTpp7DeNqfJO2YhMdtGMVGmgkd40qynsPUq+gaAa4XyzGqxTVqwoYdnPZN3I6m4BqzfRQnd6ZWJjqn10DY0CNTF7dP3WvD2B0tiRy9TKO+2KjUi5u93rNlA413KrvXa9m5DpLvkUiTcVQnO2007Z/U+Zjt9ybj1UMNLEVRFEU5CPnIRz7CF7/4RcIwJAgCrrrqKk455RSuuOIKLrjgArq7u5vyfOYzn+GOO+7gyiuvnFL4bHLttddy2WWXAfCBD3yAt73tbXNW9mxhAqh1NbwW9Uq8JidoDBzdKXHubnfu9K3Uw5EONIWo5ExDiz0KyZoXuz12fBwPaJPpd8m7g6yCzkDfwd3G3CS7HiRZ4il6abhnFGamxzkbXGTbpbF5RVqmswYn9ZQ47YjBbsYRl59MyYN4LVbFZAzTNG/YeDdWQj1syHe9KJmX1oLdH9uAv4YpTZtOq4z1CZ33XyVp8NrEXYeVbGgSQRg0NnBIdiNMDeHYwMpMYXPes9Vop+wLlVOvTLkhx7ZJ1jhK65QYoxHx2jUnLvE+Oe8dS16cnZRt0t0BswZW5mEBDS9YRq+k7+Kpp40d/hptnU5jdS/9mrfbYsk0ptQm+Ws2LHMdSGMdmtvO/jb6hf3ooQaWoiiKohxk/PznP+cb3/gGd911Fx0dHWzfvp2JiQkArrjiCs4555xcA6td1Go1SqXGkGTnzp18+MMf5o477kBEOOmkk3jDG97AkiVL2qjlDCD2nVXJAC1+V2qKCeJ3UyUDSIkHqP40vwmTfaofkK5nyeyKhvOkPln/Eg96JZL0XVjui1qNIevREuy7mRwjLOOtiSDZSS6KB+GpkWYgqEs6MI3cQTqOnt7mDCb2HGXfeeUNdnH0jCRjBLrC08G3Y0wk69mS6XjJi2iBxg5/iZcowG664Ri66YYPkdMnGaPDSe+snUuN6LrjMUtkOJ4ZoqQdnA0hDOl6ujSP2yc478iShk7i6JKuo/ONHceYyq7/itulZtdppUZuUtd0O/fGtRjEFYuStYRhoy3Tfky24He8ke51lRpczouMg2p2441kQ5jGFvhxf4pkyqp7L95OpzsGje+A67VK2yLpm+TaDRt6pevL6t6TAgc1sBRFURRlFvnw13/NfU/snVGZzzl8MR96/fGF8Vu3bmX58uV0dHQAsHz5cgD++Z//mSeeeIKXv/zlLF++nJtvvplrrrmGv//7v6e/v58TTzwxzVPE17/+dS677DImJiZYtmwZX/jCF1ixYgXPetaz+K//+i9WrFhBFEU885nP5Oc//zkAf/Znf8Zjjz0GWAPvv/23/8b69et55JFH2LhxI894xjO47rrr0jK++93v8qpXvYqlS5cC8KpXvYrvfOc7nH12y7fCHBBk1hGR9YS464wyU6GS8Xh6Lpk8eekzeN6W9ON6YpywJvz8zn9/KqA/PTDRvWmdiy8jPjdFclLPWyN9urbL1yHBNdCcMrNeqpywJL3bVr5+jnGbOYd0mlpTPyeGibduqKmvk7VdmfySvQ5orltqS7pT2Jzpia4B67wlILeNMv3n1yVwwslpT0eG46DLGpGOTnj1StvBv2ac8owr3zTL9svz+61VuFsH8eXkfXdyaDF7UFEURVGUA5FXv/rVPP744zzzmc/kwgsv5Mc//jEA73rXuzj88MO5+eabufnmm9m6dSsf+tCH+NnPfsYtt9zCfffdN6nsl770pfziF7/g7rvv5qyzzuJjH/sYQRBwzjnn8IUvfAGAH/zgB5x44omsWLGCP//zP+cv//Ivuf322/nyl7/M29/+9lTWfffdxw9+8IOMcQWwZcsWVq9enZ6vWrWKLVu2zETTtBdpeEUymwu4A0nXI+IN5NP07qCcrIwmg8cpOzNATnRw31EVZMv3DRB/E4KmAauDr3tufZKwuFy/HfDr7OrmysSR4+vkGBuZNU1JP5ScuLC5rNS74ccla8aS45BMHxnv3C0zKjkynbVURfmjkvUg4cXjyk30k+Z0brzbF5nycsrO9J933SANL1VGX39tmHvdJNeq35fO9eV63zIGldPGaT9713ZaJ++6Stsqr439dk76Imz0sfHCcnXwUA+WoiiKoswirTxNs8WiRYu48847+elPf8rNN9/MmWeeyeWXX865556bSXfrrbeybt06VqxYAcCZZ57Jgw8+2FL25s2bOfPMM9m6dSsTExPpe6jOP/98zjjjDP7iL/6CT3/605x33nmANbZcw23v3r0MDQ0B8IY3vIGurq6Zqva8x0BjWlcyDUpo7OpGY0vrZPAWOYPVdOMA50W1uINJ35vjFuwMYCWWJfXGxhLJ0/x06pYztS4dULq7BHrrcXBkp8UK9hXMbtqkHklQ4glw0ogzNSyRYyReI+NMN0unl3mGgLt2Jnk3ljtNzTUUo2Sqm2sAeht3uJ6hZCOFdEqdXzY2v0mn+Tlykv+Jfk7djSMreXdxkj8qYTdcEKe+eNeKxPVI1ue5U95co9yZvpl4sVLPVjLFkEYZqUHlhKV9mVxzaUeRIbmW0imBbv3ES+cZVJnNLtz2dstO6uPkdTc2yXinyKZL+zLph4B0238gu9sijb5IBUfYa7uAoDhKURRFUZQDlTAMWbduHR/+8Ie58sor+fKXvzwjci+++GIuuugifvWrX3HVVVcxNjYGwOrVq1m5ciU/+tGPuO2223jta18LQBRF/OIXv+Cee+7hnnvuYcuWLSxatAiAnp6e3DKOOOIIHn/88fR88+bNHHHEETOif1tJnvq7XgbfIMrzwnhGTK5nKs+wyikfsgPa9Om8I9svw3ijxaZpjUE2zC3PHeRnBtKuJyWnDsbXyfcqefmb0vsGglPXXO9YjpfD9/Tg6xJ6OkmObr7nxK9LnicnxwPWVFaQ1bfJg+bq7ZfXok3z0uVekzSnb/JMkj32r5emvqchwz3P6xM/Pj12dXUMzbz+a/LW+t7lxBvnt6d3jeWhBpaiKIqiHGT85je/4aGHHkrP77nnHo488kgAent7GRwcBOCUU07hxz/+MTt27KBarfIf//Efk8res2dPauxce+21mbi3v/3tnHPOObz5zW8mDO3j3Ve/+tV88pOfzOgyGaeddhrf+9732LVrF7t27eJ73/sep5122qT5Dhj8gZlr8EzRUMobuDbJ8MM8MtPrXD1oHvjmGV8ZmTlluroW1cPVxUiLwXNBvryy8zwurQbDLq10nVLf5OkYH4vJTVmYL7d9C2QXnrdiKvq0wN1UI1P+VHTIS+fJaZJLiz7Iu5bz5ObIb+rzya7XKVwLOkVQURRFUQ4yhoaGuPjii9m9ezelUoljjz2Wq6++GoALLriA17zmNelarPXr1/OSl7yE/v5+1q5dO6ns9evX8+Y3v5klS5bwile8gt/+9rdp3Bve8AbOO++8dHog2I01/tf/+l+ccMIJ1Go1fvd3f5dPfepTLctYunQpl1xyCS984QsB+OAHP5hueHGw4BtH6ak4416BzLQoZ0CYvkPJedqfrpVx87lluNPpIJ12lg4W42l06c5q0LRzWlM5rq4F9Ws5MHUf9SfT+tyt6yHdyCIzLc802sG4GzdIVv/Uq1FkDCT1cXYozGzD7rctIJ4MV89MH/kDcHfHBz/Kb9MCw7hpapyjY9pGvuy8Mp3rQ1rpJZ5h6FyPvuy0HcimaTl9VXLaHK/9kv718ztTX9MdEYNGWzbldeqTfOf86ybPQE+/K4m+8Xkr+1QNLEVRFEU5yDjppJP4r//6r9y4iy++mIsvvjg99w2iPM4999x0/dYZZ5zBGWeckZvul7/8JSeeeCLPfvaz07Dly5dzww03NKVdv359yzLPP/98zj///JZpDlQSI8NdT5MZmJN/nJL39F2cgaVrpDmGQ1DPyknW8KTbUidpIzIGjj/YT7fv9utEQ4dcb43xBr80BrgZ48M3LJJd9xxDqGnL9sBJ5xtTvgErnoxksJ3U0zfuHFmS/ikm7V8/r8kZlDv1zvNI5nopTfO1k673Sq4rt4gpzFfzjcSm/sszoD3d0zZ0DHkcY8YvKykvrWeeoZfEBzStg8psve7q7rRJ5p1bnvyMzk66jBGWE47EL0hugRpYiqIoiqLsN5dffjn/9//+33QnQSWHFgPzjKFUFFeQPjlvegKP453IK9sfJMdhedtetxokZ+Ql8TR7JVLjJMcLIjTCi6acZXTwBveFxmgso8jbkOs5KUi7L2QMtelMyfONTF9mjlGW5EuNd6+8xFhoNVWxqe19g6uFt6uQFu2flJnrRXOvFRr9DK0NwMzDCpOfxk8rkL+JSytatIMaWIqiKIqi7Dfvf//7ef/7399uNeY/zpPvydaTQP44z3jGhT+tyX0C76ZLt7n25XnGWmaalTuN0N/FrRV5g2qTU2cpDvc9aJlpcWFzfEaGO23QrVtBvU2BnNSucGW53r0WdXA9YYnB6RuzGRmubn4bRDTJdvMZTwfj7TDopmkqzy9byBobqUKOrCD7323nzLXhX1t5ZTni0zTxdL+MkR94niy3rwx2Vz9ffnItu169gCZPq4H0mkq8XWk+/3rwr7Uc1MBSFEVRFEWZI6IS2dGkP+gt8hC0SONObcskTwyHeDpVVCYzaPe9N6mh4K3rSqefJYPRZJv4PC+C6+nwpwPm1amoru4gtt5cX/ENALDvtJKGbum0MN+oyDMyPO+fP3UxNU4MmS3Vfb0zBodk0xkcnch6V/x+SLeOT9rQeTlxpn5OnrReznqujB5OeU3rzLxr0vhpkxOn3dOdDJNt8BP9vHV7TTrktHtyjbpt4U51dA1+U+ANTA0vV/d4y3/jh8Xfw2SrdhPQeAF04Bio7pb9TtrJvHhqYCmKoiiKoswBJvEsJANkZ0OCdM1HneaNCpIBN47B4w/wfOMhDksGjtTJbhIBdtDuDSyl7g3cnXSJfBPS8MgUGYuACf05go3zpo0TWhg7zV4JgzGSWYeEu27MxDq7704ia3xl5PremcRg9XUxzifIkUe2nTLePzHeVDtpFGtsnbJKSjyQT6wxabSHZ4i4siUS+54pN2ksI28tWNZok4ys9L+juESStkkUGtLpiJEQhcbGB16dI7H1E+da80jLcfRNKtIwek1Tn2WMVLf50raEqGSy11skRCXTMJiMYEKD1Bv1T3UNJC07TZvokWPkJaiBpSiKoiiKMkdk1vg4T/WNe+57lbz/Bi9N3nkqz5BuoebKcLwJTWt6fIOmSad4wI5k7SK3bskA3RmFuucGadqUwFU7GaAnaZNi03U4YhAjjtyGbgaJd5wzmXLcc7e+6Zjdaaam4yRvpk1MUxv4beMaGmnf4bSDAJE45cVGidsfiSJxRRo2mCPDvS68BUq+oZqJdQ0WX8/UljLN0zUh4ynLeOq8OttrkKZrLaOj3yZ5dcm7Nn1BfhuLZMJ8OWkzimPkOrqm16/TFrneSw81sBRFURRFUeYCwT7dh4ZxE9hBsz9ly/VONDLnP/1P02UsDRqD3MBAKI0BZEKQPI1veA4EG+Z6ApKwRIGMbq5HJjAZrwzOtMK0Xmn6Rlp3elnTuZBmStPHcVGYFd7wLBjSKWxuOU5crPKk5WfLNPF0OKc9xKSD9OwaMNOQ4w7YTSM6LS50dEqzm2zeZGCfWOOGxnQ412BwvTwuzjUl/nouP71bj6TPUv2ajTcRWwfrvTM5OtGYOumtX3Mvb+McY2j2WGUMOC+/rz+JvGaDyCRGbHIeZo3a5NrJrN/zyva/aj76omFFURRFOQj5yEc+wvHHH88JJ5zA2rVrufXWWwG44oorGBkZyc3zmc98hosuumjK4bPJa17zGvr7+3nd6143p+XONlFo7KdkrEES2gFeVDLp/yhM4pL4Rj7z/7P35nF2VVWi/3edc4caUxlBEgJBmWQIBvIEZEpEEfEJ2i1GBAXUpnGg2/YJpunXiP3DX0M/5dEgrdKtBhQHxOeT7h+ipk0kIraMTsxgmBIgc6pSqbrD2b8/9hn2OfecW5VQlSrI+tbnfuqeffZee+29z713r7PW3if7SuULj71EdrSg38oPZZWi/8a+LyUyrG6t+aKyxn3v5EGMXQMVvoJyuKmGn0ywjXucI2PUr0heVJ+rVyg7KGfORxt8eLY+t86g7OQJ30frcEwp/d7KNS15gmxdfibNc/Jndc95xTq5fVfK6OYl45uMT2v+bPtb0sSpx9Uxb+xK6XpceS2ynTI4eaP3uflLyWYsbnrczsjYKSqfaUfg9oeTnu03vEzZyJAquP5iA76AMfFgicipwD9j9+/4N2PMlZnz+wA3AlPDPEuNMbePRd2KoiiKoqS5++67+Y//+A/uv/9+qtUq69evp1arAdbAOuecc+jq6ppgLRMajQalUnpKcvHFFzM4OMhXv/rVCdJqHIgmhiEmWifkLOZv2VhBkqJA691/J1+LZ8L1cEREYV1RPa6XyVgPQ+xlC9Ny2+F6FCKPSjZ0Smwb43C3cEMEKZAT1ZcKWYTWB/ZmVJNsCBiZfnL7JFtflNf1nrihb+CsKUpeBpJ1X1E5h1SIX8aLR07+lJclHEfJ9IGrT1TGRBtKODIlexypEI51qrnS2sdZWSmPqlsmk7fwvys4byzD6zA1BtG1HeVxN5Zw0zPXTsu1kLkexSnv9i+QPEw4rM9kdch+FnOaEvGyDSwR8YHrgbcCzwH3iMhtxpiHnGz/E7jFGPNlETkEuB2Y93LrVhRFUZRJz4+Xwgu/H1uZrzkc3n5l4em1a9cyc+ZMqtUqYB/2C3DttdeyZs0aFi9ezMyZM1mxYgXf+MY3+Md//EemTp3KEUccEZcp4t///d+54oorqNVqzJgxg5tvvplZs2Zx0EEH8atf/YpZs2YRBAEHHnggd999NwAXXnghzzzzDGANvOOOO47LL7+cJ598kqeeeop99tmH73znO6l6Tj75ZFauXLmzPTRpyZ2oZiaU4uaLwqVyJq2piV9mEpzNmy2Tnby7M+Z40mxy/jtlsrLy2ipOuTz9Wya5ee0rEpEKBUuSsgaPa1RkJ+AtqucYial0k+73lr6iNU/KcMj7n6eD2y5xDMNUuF5iAGXb2yKnwIAy7phm20y6b1Plc/IWWh6u3m6evPZnjaiC66VFdlQm29d5fZFVMzuuFOeJ6igauoixCBF8I/CEMeYpY0wN+C5wRo5+U8L3fcCaMahXURRFUZQcTjnlFJ599lkOPPBAPvaxj/GLX/wCgL/6q79i9uzZrFixghUrVrB27Vo++9nPctddd/HLX/6Shx56aATJcPzxx/PrX/+aBx54gPe973380z/9E57ncc4558QPGV6+fDlHHHEEs2bN4q//+q/5m7/5G+655x5+8IMf8JGPfCSW9dBDD7F8+fIW4+rVioGWkK9UmFMUzpcXopUN4coLjSpKKwqHyskX5JX1rbEUr6Vx/kfenbgtzgsxqZArV0a8HbYk71vKZ0LhcvNEZSWtl1tfNj1PVnJs0v3lhosJLf2WrTslyy9uW0punGZS9afK+SQhpZlxSPVrqt9MOl8k24dozVRuiJxfoIOX5M1tj1tfVEcqnDXMI25+Jz0V4tp6/Wf1cNuYd820XOPZ9uZ8dlJ9lwnHTNrk9EUBYxEiOAd41jl+Djg6k+dy4KcichHQDbwlT5CIXABcALDnnnuO652rgYGBV+WdsdGgbV850WpMCNr2lROtxi5nd203THzb+/r66O/vtwfH/934VBLJz9BsNvF9n5UrV/KrX/2KO++8k/e+97187nOf4+yzz8YYw8DAANVqlZUrV3LcccfR0dHB8PAwZ5xxBk888USie8jQ0BC1Wo3+/n4effRRLr30Ul588UVqtRr77rsv/f39vPe97+Wss87iwx/+MF/96ldZsmQJ/f39/OxnP+MPf/hDLGvLli2sXbuW4eFh3va2t9FoNFrqixgcHGx7fmhoKDXOAwMDO9iJuxgJJ2XhrmopD4XYZAKJz0N+euFGF6HoqFxuWnQH3vWKZVxFqbUlpjVPdN59FlVe6J3NG7oG3HDG6LhFeaeurMcl4yGK642OTbrfUjpkymRdWG4Yn7t7YVxecvJDOqzN0b8lXNFpu9vvqedLOXVJdlOPlA62UHxdZD002bY4+W3bjZPfUcAdI8/my27nnnoob7ZfIjWcTUVSYZXGqTvTajEmMZZjPUxafqaj0nU7J91HChQQtStP/1Sfe+nt3d0xCFUsZFftIngWsMwY80URORb4pogcZoxxn6uMMeYG4AaAhQsXmkWLFo2bQitXrmQ85U9mtO2LJlqNCUHbvmii1djl7K7tholv+8MPP0xvb++E1N3f3x/Xfdppp3HaaaexcOFCbrzxRi688EJEhJ6eHnp7e+ns7KRcLsf5Ozo6qFQqLbq76UuXLuVTn/oUp59+OitXruTyyy+nt7eX17/+9ey1117cc889PPDAA9xyyy34vo8xht/85jd0dHSkZFar1ViPIrq6uiiVSoV5Ojo6WLBgQXz8irih4Dm7w7mT49jwMS13xqPtorPbYafOR5PfbIhUUZqjQ8tE1pmg5s6JJf2/aOvtKE8q1Eta7KdERlZ+JikvTDI5HMH4dIybVHOjvi/SNxLtGi1h/5ggR1a2DcbRPZIdGmZF8/OidrbobEg/V8o18PLGOqubc2zc9Xs5xlqqjyKyhoxxykQ6RsZkflPS7Qn/x21qMRZHQV5bswb1SMZ9Nq97weZ9rnIYwcYbFc8Dc53jvcM0lw8Dt1hlzN1ABzBzDOpWFEVRFCXDo48+yuOPPx4fP/jgg+y7774A9Pb2xh6ho48+ml/84hds2LCBer3O97///RFlb9myhTlz5gBw4403ps595CMf4ZxzzuHMM8/E962VcMopp3DdddeldNltibwD0vpyw8VS6V76fByq5rwiivJk01KT0AJdWvLm5fNGzhOFzxWVbanHDfvz0jq1lTUKXdzd30bTvqK2umGNKVnZkMW8Mc3TM3M+r40jXi9ZGU6/ZMc+2+8mU75tvzj6tVyH2foFrFfRjDw2Tt7UdTiKvijs6xwZLZuVZNvS5prLvWYLGAsP1j3AASKyH9aweh/w/kyeZ4CTgWUi8nqsgbVuDOpWFEVRFCXDwMAAF110EZs3b6ZUKrH//vtzww03AHDBBRdw6qmnxmuxLr/8co499limTp3KG97whhFlX3755Zx55plMmzaNN7/5zfzpT3+Kz51++umcf/75nH/++XHatddey8c//nHmz59Po9HgxBNP5Ctf+cqI9Zxwwgk88sgjDAwMsPfee/O1r32Nt73tbTveGZMJAVPKxjqRTOgi75FkyrhepWhilyMm/p+9C5/JWOgtKvJ+5dTXkpaXx0133WztiPJHOhTV2+48bfLk6T1aMp6M2LuRJ6tdf5AzTjtBS/GCtuVuloFzTkh7Y7LHeS5HaLl2cpsjSYaUN7SNvPiZX9JGbhF5siWnD9z68j5L2bpz9G2n18s2sIwxDRH5BPAT7BbsXzfG/FFE/gG41xhzG/A/gH8Vkb8J9TnPmHaONUVRFEVRdpajjjqKX/3qV7nnLrroIi666KL4OGsQ5XHeeedx3nnnAXDGGWdwxhln5Ob77W9/yxFHHMHBBx8cp82cOZPvfe97LXkvv/zytnWuWrWq7flXJnYhv4sYwUR37U0mLZMvluKcy6bHxznGUrswv8Iy5JzPyWPEIIGEd/4TPeL3qa38MuWcvFGb3Pe5qmT6IK+/ovVfefJTMkbo+2ye3ONsXgrOZ5uTZ8CGx3nXRtu688pl9Sga7x0xltvlGQXudRKnueMl+WPQMm456bnjV6R30WdjtPnG2YNF+Eyr2zNplznvHwKOG4u6FEVRFEWZfFx55ZV8+ctfjncSVArIbIyQulufTSOTFuFMnLOTyZQRIZm0yJ3l1Jea5DqVZo0dV15LuehcNGkWR9/wvRDKodW4ybbNbb8pmsWPpr+yMrIeEnswoqy4bNGku0CvUZ0frSdnNHVEXhcpKOeWzXp6dkCvtjoUeacyclIGIJkxKpCRHccoX/Zay9U1c9235GnXHzsx1rtqkwtFURRFUV7FLF26lKVLl060GpObPK9R3vuRJrft0kJS3pkozeRMvLPnC8rEE9ccAyM6ZzxT2MYWOe3aMZrJbbvybtpIBkpW3x0xkAon3m2ssKx3pWgXiHbGQFHdYsDLqzMvb07aSEjGCtlJuVkvbrZc7vk82SN9nuI0p1/cNrhjke23onyp9he78NTAUhRFURRFaYOIfB3478BLxpjDwrTpwPeAecBq4L3GmE0jCstOHkdzx78o/2jDtYru1GfrLgqJyjvO03sk2TvSzrz95ncEA3imuPxInqhs3jzvlWTkx16SjDHqkt33O7UNYIHckUjJzMjI7gsf1ZsnI7UdpbTqkd1XvqUto4wZzOYtOm6nd1FdhXqY/Pfx9ZpTxu1LN20U16YaWIqiKIqiKO1ZBnwJuMlJWwr8pzHmShFZGh5/pq0UwU76o/cwuvUgIxFN/l0jpp38bD3t5vKu0WCk2MDKM/byjJJ29bj5Wh66VFCfW0/W0BQnY5Ex2q5f3ONsmyWTOU+mO2nPbb9J8rUYplljJq+8ez7PqDPp/7HRUnSBufmc/24dLdeZIzPPsMk1ePJuMrjGnGmtG4gfvJY1vPJkufXn5XX0Esm3r1rbnmlnm8/pWGzTriiKoiiK8qrFGHMnsDGTfAZwY/j+RuBdoxboTk5bQsGctJFeWZmpsDiTkWVyXnlynEl2nMdNy/7PkVX4PlN/qr6MnmTLFNSXNXikQFYqLae9eX3Zrg5Xt7xzWTnZ9qSOs2WK2pgp57wXsYZCq15t/reMtYll5Z2TbP9l8qR0gDh/XnpWX0m1O1+vvD7Mk5UiRze3fW5a9tXS1wXtzEM9WIqiKIqiKDvOnsaYteH7F4A98zKJyAXABQD+jKlINkQwO/EFrPdihBlcNoSqKHzK5KS557KhYXnpuedGqKcozKtFAVo9BbnkeD3cMkVhb1HmVF9ly2b0ztZsCibUefLzdMr2SUsDMh6X3Dw5ebPnBSQ3nC0rp42MSFTB5SexJ6/AMI3+mVAf46SbdL5sWsv5bBV56ZLz1qTT3eM8O7iIVF9G7XYKS+G1qgaWoiiKorwq+fznP8+3v/1tfN/H8zy++tWvcvTRR3PNNddwwQUX0NXV1VJm2bJl3HvvvXzpS18aVfp48eCDD/LRj36UrVu34vs+f/d3f8eSJUt2Sd07gzHGSMFsyxhzA3ADQPW1c4z4Qb6QlhmfKZr7OvlNMnnM2aAiVCBJb5mwmiSP5JTJ25EtzpszaXcntq6MogmzW9atxxS8z6svLlfQX6lZd/QvR3dX70xfFU7Gc/vMPZ81QM3IM/uicYxktCmfCnVz29muzhyjZ0Sy10tGhyhLEdk8eSF6RWlZ2XmGYNYgdo/dOneUQkM7BzWwFEVRFOVVxt13381//Md/cP/991OtVlm/fj21Wg2Aa665hnPOOSfXwJooGo0GpVIyJenq6uKmm27igAMOYM2aNRx11FG87W1vY+rUqROnZCsvishexpi1IrIX8NJoConfxjuVt06kSI6E+/FFebyCGW3Ks5WZJGa9Ns5xaiKa8sAU6Bqfz/EEtfEOpRuVV3YU56Lzo9kYot2EPOV1ai/GGBAvp19a6mvT9qI+bHeuyGsSnvOE9HURySr0dhbo3U7/NtdA7OBqZwjm5Mnmlza6SUaVFodWdjhy6tkJ+6pVbhvUwFIURVGUceSq31zFIxsfGVOZB08/mM+8sXg/hbVr1zJz5kyq1SpgH/YLcO2117JmzRoWL17MzJkzWbFiBd/4xjf4x3/8R6ZOncoRRxwRlyni3//937niiiuo1WrMmDGDm2++mVmzZnHQQQfxq1/9ilmzZhEEAQceeCB33303ABdeeCHPPPMMYA284447jssvv5wnn3ySp556in322YfvfOc7cR0HHnhg/H727NnssccerFu3brIZWLcB5wJXhv9/NOqSbUKLUs6eNvmivOnnWLXS8lBWJ15LMnnc43b52tXVLm/uA3xTuhXnG0lGti92BHHj00YpQ5IealvvaNrkkh2L7LmiCb57Lu+6cOXuSD+Nakyc9zJKQzdlG4vBZMqMVk6erKic5BmHbr4dwBg73qMtpwaWoiiKorzKOOWUU/iHf/gHDjzwQN7ylrewZMkSTjrpJP7qr/6Kq6++mhUrVjBz5kzWrl3LZz/7We677z76+vpYvHgxCxYsaCv7+OOP59e//jUiwr/927/xT//0T3zxi1/knHPO4eabb+aTn/wky5cv54gjjmDWrFm8//3v52/+5m84/vjjeeaZZ3jb297Gww8/DMBDDz3EL3/5Szo7Owvr+81vfkOtVuN1r3vdmPbRjiAi3wEWATNF5Dngs1jD6hYR+TDwNPDekeWA5xWECDp5oH2IVV6+Io9BuzCsWFaeTMfjEZXNq2KkUKw8Xd30PP2LQsOyZOvIyhqNDnn6tMvrnsvqNVII2Y6Gp0WT+azxEZ1z04v0ydO5XQjdjpBXrp3ORRQaWI6cKM9I6fl6SqqO0RhJ2bw7UhbUwFIURVGUcaWdp2m86Onp4b777mPVqlWsWLGCJUuWcOWVV3Leeeel8v3Xf/0XixYtYtasWQAsWbKExx57rK3s5557jiVLlrB27VpqtRr77bcfAB/60Ic444wz+OQnP8nXv/51zj//fACWL1/OQw89FJffunUrAwMDAJx++ultjau1a9fygQ98gBtvvBHPm7iNj40xZxWcOnlHZZVK+QZW3gTOnXS6E728PKOd+OVNZLP1mMxW3lnZeXq1TvhbJ70jTYRfDsXtGP+68s5H5BkF2TwuRX3Uru+KjIE8fUfTL3nGyGj7st31W3StikAQvPxro91NhJ2hyKAbDWpgKYqiKMqrEN/3WbRoEYsWLeLwww/nxhtvbDGwdoaLLrqIT33qU5x++umsXLmSyy+/HIC5c+ey55578vOf/5zf/OY33HzzzQAEQcCvf/1rOjo6WmR1d3cX1rN161be8Y538PnPf55jjjnmZes9GRAxqQla2uti4jRIp7sTvdbJaesd/CIPTqtnKC3TGMHzDMakJ8NFE9eszu2MMivDkOdpiku38baNzkOV7YP8PtmRjRjydLP/zag8P+lxGblM0QS+aNzz5ObLcMeq6Fprr3dKWhsvo3tNjqyXTc+7f5JnGBYZiK2fn/ZG5ki0GrRmh7x8+hwsRVEURXmV8eijj/L444/Hxw8++CD77rsvAL29vfT39wNw9NFH84tf/IINGzZQr9f5/ve/P6LsLVu2MGfOHABuvPHG1LmPfOQjnHPOOZx55pn4vg/YcMXrrrsupctI1Go13v3ud/PBD36Q97znPSPmfyXheSZ+2YmlaUlz021YYWu+dq+sjKK60uejeoJceSPVl1+OjE5k2pZ+jdQv7drXWn/QUj4pE4yqTUmZIKNHUj6bL8kftBxny7j58vK7aaOR277MyP2YbUfe+6y8orLZ9hbLCfBG0RdF/Zs63zJmBf2aue7avdz25sktQj1YiqIoivIqY2BggIsuuojNmzdTKpXYf//9ueGGGwC44IILOPXUU5k9ezYrVqzg8ssv59hjj2Xq1Km84Q1vGFH25Zdfzplnnsm0adN485vfzJ/+9Kf43Omnn875558fhweC3Vjj4x//OPPnz6fRaHDiiSfyla98pW0dt9xyC3feeScbNmxg2bJlgN0qfjT6TWZEoOw3W9KLQsd2JEQwL182vSitXUhYXr1FnoCsvs3AiyezebrnsSNrX4rCKkcbxpVXpl2IXpEeI+HKHq2cIk9N0fl2IZlRXnesd6TP8jxJ7crtqO7tvFLt1mCN5JXa0XVU7TxkO4oaWIqiKIryKuOoo47iV7/6Ve65iy66iIsuuig+zhpEeZx33nlxeOEZZ5zBGWeckZvvt7/9LUcccQQHH3xwnDZz5ky+973vteSNQgvzOOecczjnnHPa6vRKRDCUip6DlYM7IfTEEBRM/IoMsVTdOem+F7TIbFePW1+7CW1Un9V7xzYK2FEDq8ioyLYJaNt/I03c3TxRH2X7qqjv3PrzxiqvnJtmjOB7Ac3Ai6+FSF6UL9IvW26ka6eoz/J08Zw8RfJG6uu89haVcfN5Gf2y/Z89n83nyh+5fpNKz8rLlstDDSxFURRFUV42V155JV/+8pfjtVdKDmKNmtHeIY9MscgL5BfcXXdNtniymMmTly5iWtaK5KXl1Zc7+czUZ0TSBkFGlyLZRfq2TLJHmRYbMm3qdOvzxOTqEb2P+ijbV0V959afNy5uucAx7OI0XIM1X4cgT1aB/Kyh5MrNw60r1rtN3nbns20bbVqL0TzC+Ww+V6eicSq6brLyRoMaWIqiKIqivGyWLl3K0qVLJ1qNSY1gKIfrNvLurEP7u/nZcnn5oryxFwOQTFpevnb1Zz0FI3m4Ivywra5fYKSSUct2pEweed6NPG/HaNtSJDv73Ky8Z1XF+cWQnbLHecNzvpseec/CYy8ML20Zz7CsKysq58py5Uek6ovaEB63u3bctuSOlaNTbptzyre0w2lLi9cwamNOf2f1zOosoyhXeN21MURd1MBSFEVRlHHA7pj28mP5lXzMWO7HvIvwxNBZqsfHY7Xeo4ggnCJ6LVPcl1c2GKXJk2fgtPOU5OUZTZlIT1ev7HE2byx/p8y3YooM1ujcSCFtUb6SY4jn9UG7cMQovagvi8LmsvlGqivPCM8L5Wuno1v3aMY6W3a014erS5Hx3a4P2pXNQw2ssWa0T5Eb2gLDA9A9C0qV1vNBABuegOfvhcGNMON1MOMA6JsD5fCZIbVtsOV5COogPngl8Dz7vj5o66gPglcGvxz+L9HT/wQ83oDBDVCqQvdM6NkTps2z+Vwaw7B9U/KqD0LHNOiaZtta2wb17Un+jj6rY7XXtqE+aPPUBsAE6Tr6X4SX/gjiOTqW7H+/krz3yoCBTath41O27PTXwdR9IGiEdQxCfZvVt9wJlR6rQ7XXtnHrGtj4J/Z84dfwu5fCOkvgRf1Wtu+bNSuv1GH7e9q+0KzD4HrYtt6OxfZNUOmGrhm27NbnYOtaq4vnh2MRjkN0XOmCvrkwZTZs3wybn4aBFyFo2n4JmmCatt3T9oPp+1m9m3Xbf/0vwMALtq+DppXbNcNePyJJ+2uDVv+uGTDrYDsW/S/A5mfY48W74N6noFGz+lfDPqr02nZsjvpXrJ69r7HjWe2z47f5aTtmnVOhZw/bR81a+Krb/354PXVMtdfftnXJ2AP07mXHrdJtz7uvoGHHrVS11+bAi7Y9paq9DoYHbN+L2Oto+n5WXtdM6JhixxRgaCts3xiO1UbYto79H/8pPHGFldk10+rfPRO697BtxNjr2QTOe/c4sK/GsNVz+utg3nEw8yDY9pL9HK5/DF56yPZ31/RkbOpDVkbPa2DKXrZvKl22r+rb7bjVt4efpcHW90ETZh4Arznc6g02fd0j8NLD4Wdyqm1H9Bnavgk2reawp34Lz/6z1V18+9kodzn/O+x/v2LHYHCDbaNfsuM7ZY7t60o3DLxkPwfiWd1NAMNbYbjf+cz1QHWKzV/fbmVG4zV1X3uNbFtv63Ff29ZDYyi83sKxNIH9TESfkc6ptg/LnbaP+9dYXaOxMc44mYBD170Ia79qy9cHYWizvYZM0343lSpQ7ra6Vrrsf8SOrwls+8udVm590Mrp6LNj2zkVOqfb46Bh9RjaYvuntg2m7UfHlDey4YXnmNHbgQT18LfBJP8x4W1dJ82Evx3iOS/JlAvTou9MjL3GmsP2uNSJ36jBYD38TirZz1D0m1EfDMcwvFbED/s77GsIr40uILzmo1ezZq+NclcoU4jvT0d9n8UYq0fQCBPE6t853X5P7iTGGDZs2JC79ftkxhNDtdRIjguMgNFM4EbDaOW084q18wQV1TGaSfVozxXlKZrojuQZzGMkL95Ia3iKZGX18mX069B8x8AqWldWpIMviZyoLmMkccm4xSInmCO/abzYCI3SI92zm2MECB7JRhrtNj5JkZfs6NJuXZjbj1k5RWsQs/KzbYyO3b5Kycrps3bsngbW48s57pfnwgPTkklB9L/UmUxshzaHhsVm+75ZTyZ7ftVOSvyyTRPPTkD619ofqd497USuPmgneqZpJ72VHtjynJ2URXRMtRNmd6LQrNkJRx7VPvsjN7hhp5q/EOC+nBNe2Rpy4idtrw/uVB34VfuD35JesRP/4a3WYNrFvB7gkR0pkefcfmVyCMDDE63Fy6TSE05oCz4bBbzG74A5R8LcY+znZuvzsPa31gAMGiMLiCa7fsX+rw3k5/Or1jAd2mwn3FFZxH4H7BASTnJN8ecw0imvPzr66PCnw5Cx+YKG/X6KDLfIkIv08kr2O6pUhWYjMUpGotQZ1r+Tn5PqlLDeDmusDW2xssQPDQkfEKuLO1ZdM61hhGuQSGwwdG4fhM2DNq3SA1P2tkZUdGOlWUtu/gxttTdJMKHRItagqG+35cudoeG6Ofxe3JbfFq9sdRrawt6VqTx35GdY1/daYqMoRpzj6IfbCbKJDPzofeo8jrHl1l0KDaQRxsErhfJHuh5zvvtGW8do6Ns7uSmyk3R0dLD33nu/fF12MdGkzpMgPIbApPvi5RpWOyon1zvierDCyy/2/EhxWTctzwAqMn5GMsBivTIy83QfTRvzzhcZpHn6j4ZcL9BoyotpaXO7thcZnqn1aAUepqh8Oj0oXGOXMhoB39kQomhNXJZ2xnLcrpH6qY0Hr6jedJ4gld8Ykxi1OyCriDExsETkVOCfsaGc/2aMuTInz3uBy7HfzL81xrx/LOreGR7f3sOjHMe+ZZ8ZpRqV2iDB1vVI/WlKQY1SMEzglaiXp1Cv9LHFzGa99zpqUqKnbOjyGkizjqnXKJk6nV6TstTZJPvyp67DGTLCnOZWpm/ZynZvDzZ7r6Um0NXop9zcxrqu+TzfO4t+r0wHW6iYfoaCBgPGMERATQx1DzbTy5pgGluDCr1BP1MZoNMM0mWG8CRgoOdghkod1MTQpIEY6G520NWssh1hqzTZLs3YcPMwCAGBMdS9CjUqGNOkFAzTxTAzS9uZ6m0HCah3z6DW/RqGKTFsSgxg2CZN6gR04tGNhxiPOh4NIzSNITCGqtegy6vTIQ38oIw0qzQoUfcEvIDpDDIjGMCr9LBu1iLW1GfgU6ZDfEpigDpimlQCj2rgU6ZJ4NUJvAb90sdWmYUYj2mNLUxr9lPxq1QqPQwYj+dq29nQGKLLM/T5hqnlgL5qg45Sg/XNKs/VqmysG3o6faplQ6dXpkPKlPEJmk2CZkAt8NgelOigyRyvnz1lK01TZiDoYrPpZH2jyuZmid5ynemV7VR9wxZ66acHr1Smu+xR8mD7cIOhWoOKB10Vnw5qeNs3Uh7axOZGhWeHe9lkupnW08XMng4wVbYNV/DqhtdWNrOvv5ESTRr4DFLiRamwXkoM00nQ7KQU+EzxNtNttrCtUWfdcMDmuuDLdMr+LA7p9FjYtY59S1sY6tyTLZ2zuHv1erZUZrBmoMHe3SVe2yPMLAV0BUOY5jCPDU/j/oFpbK8bZnub2EM20yeD9HnbCfwONlRms60ykylmgGlmMz2lgJ7uLro6O9k0BC9uC6hQY7/OIWaVB3lhuMoT2zrZ2Kjgl8qUxdA9/BJ9Q89TMTUalT6CjimYah9eRx+VaoVer0an1OiXXl4MprFdOuktN+mUBk9v83liQ43ttTqv79nOwdUN7FMdYE+/n85gG9trDYbqDZrlHkzndPq9KTzRX+bhLWV+tw4669Mx6wzVkk9Hp8eee3aw7/QO9uqCZgB1A/VAaATWIOmulumulgmAwVqT7fVmWEfAQR0bWWgeZurwc2yQ6fypPpU13mzW+nvRMB4zeirM6hIE2Fb3qDWaTKOf6cF6ethGt9SomDqDVBgIqjT9KqbcjSl1sqVZZkOtxKZhj83b6wzVG7y+ayuvl2fobPYz3AjY3hTWVfdhTXlfAr+D3lKDKbKdnrKh2zf008Xq7VX+63ePMnPPOWyv1WkEDTw/oFIS9pk6jX1n9LDHlCodXkCHNGj4nQzW62wd3sbW4QGGm8Mc0DOVuWxkcFs/92+ocu86YXpPlf2nV+jtKLGuIWwZrjFv2kz2n+YzvTTM8LYtDG3byjZTYYBumo0aPYPP0T34PD09PUyZsRemazrPDHXyWH+F7U2fpmlSLgW8bsY09pneTSMI2LitxvZ6g+5qma6Kz7TOEh31rVDfxlB1Js8PBDy7cZBnN21nYKjBvjO6eO0s+9DazYN1fvmbB5jz2gPZPFint6PEPtO7mNlTZWC4wdbtdXxf6OssM6WjRF9nhb7OMrVmwMaBGlu216kHAY2moREENAODIMzqrfKaKR1MKTeQ7ZvtjSKvxBAl1gyWeGyzx0sDwxw8pcZh5bXsV/Zg+n4E3a+hZoThekBHxaNasqsehhtN/rhmK/VGwOtnT2FKR5kgMKwbGMYTYWZPJQ4xHBhusGlbzf6ImQBv+0ZK29YA0Jx+AFLpYmanR3nzU9x/90pef/SbeXawyl6lLfRue9Yap3PfCFNmEwSGoeHtNLdtoBpsp9zczrDXzWbpZfvgNkpr7qX60u+Rzil4M/fHm/E66n37YPwO+soBHZsftzfIAuv1qkuJDbUyW2oCnocnQl9XmRndVXy/DF0zqFWngXiUpYk06zZq4mV4sF6peGLocEIEE9IGb7twpaIwrLEyyvJo58EaC9lFYWxunWMlf6Q8ow1RHG0f5IW0Remj1Xlnx3dH182N5Pkby50ER0O7UMLRlinK0wj88H1oVHle/N7W0Xqcyp85n0VebgyziPjAY8BbgeeAe4CzjDEPOXkOAG4B3myM2SQiexhjXsoVGLJw4UJz7733vizdirjz8bVceusveKm2nYYZQrw6EFDyA7zSdsQfpCnbwBtE/EH80iCV6hCCodGoUm+U8P1hvNIgRmoEJgAJEH87Is6XZFAFaYDs6J3rkJT7MztOgmfKQBkxZTwqIA3qbInrE3xKdCHhHVIJbzk1m0H8AEiB+AfcTibsU7c9EXszGMETwZcqVa+HklSpBdupmUGgGZ73EBEE68ZuBoamCTAyRCA2fNCjAsanaRoE1F5ev4wFo72L9ErFCARdBM0OxN+G+MUeH2M8MD4eJXwp4YkP+GCSV0CdQAYx1BHTBc0egsCjaeogDcRr4Hl1wNgvISOAjy8evvgYbB2+6aFk+kAMNdbT9DYTBCWCRhVjKsk179URsZMQE1QhqOD5NSqVGiIBjUaFer2CCTowzQ6rpzQRaWKCsi1jSogY+ro8jNlKuaNGIMOYQGgaGK4bGk0wSFivl/kfvrxhpw+t58A0phDUZkGzG8qb8Mob8Er9SGkAvBqm2YVpdiHSRPxBkDqm0UdQ7wNTBpqxvjgvSb2vg1ez4QrNDkyjB4Mg3hDi1SB1J9m9ltPvRYKWa90YD9PoAVMK+7oW/g9a8gXDe2CCDrzyRrxSP0jO9sWNLppDczDNbrzyRqS8yeooDTBlmsOvIRjeE/G345U32H7C2O9Nbzj8Dg7rDGzYm3gN+9yWsC9Ns5uS6cWXMsNBv+1XPEyzijFlhPCOpzeMeNvteEmT6B4rQRlj/LBfG+H/ejiePZjGFIwJ63b7Me47pw+DKiWm4NNJjU0YfyNIAEEHplm14+c18Lwmhnoyxvb+LiWqlLwKw83tGG/IXrfGx5cSQeATBPZzV5IS1VKFWkOo1e1nyBgf8BBphG2tg9Ts/6BCWboxgUctCGx9xqez3EG1BEPBAHWzjSDwMc1Oq2/QYT8vEI6Xj6lPI6hPtUleLZHv1cB4VP0qHaUqQbNEM/DZVhsGCdtpynYMTQXPVOiulhkK+mmYbeF4dVCSTlZ94qPM6u1mrFm5ciWLFy++zxizcMyFjwEzXz/TvOPG04EkPLDdWiE330jkrSuK0rJrk3aUdvJ2Vo/JQjP8PvPDz3rTSPx+Z8pl0/PKjAa3fDuZWfl55caCbNt2VnZkmLheW/e4ndEyGnlFsrNys17jPLKy8vjOsf+W+30zFh6sNwJPGGOeAhCR7wJnAA85ef4CuN4YswlgJONqvKlV/siW2Z+nClQL8pQQeiq9TCn3Mb1zKlOrr8EXn/56P4P1QaZU9mRqx1Q6S50IHs0AZnROZVrHVHzxGagPMFAfoOyV6Sh10Ol3Ui1V6fA76Cx10lHqsC8//3/Vr+7U4uhm0GTj0EY6Sh30lHtyZaxcuZJFixbtsOyxphE0qDVrDDWH2N6whljZK+OJx0BtgC21LRhj6K300lnqpBk0qQU1as1a/H+4OcxwY5iyX2aPrj2YVp2GwTDcHKZpmlS8ChW/QtkrU/bK3H3X3bz5pDfjiUctqLGtvo1as4YxhoCAwAQYY2iaJo2gkbxMA2MMJa8Uv8peOTQeTFzeLqOwx/FfeBMjLz0qN9QYYqA2wGAjCQWL9tfxxGNqdSp9lT6apkl/rZ/BxiAVr0LVr1L2y1R9eyVv2L6BddvXsX77etZvX8/G7Vvpq05lWmUGm9a8xKEHvx6AelCP+y/677a1ETSoB/X4f8WrxOOwtbaVDUMbaAQNSlJBKNNT6aCr3IEgDNUbbKvVqJTtXaKmacZjt2loE+u2P4UgzOmZw2u6D6Ie1Omv9bO9PkQjCGgETTrLU+gpdyEi9NcG2FbfRk+lj75KH77ns62+ja3D/WwZ3kx/bYB6UKPsVSh7JWrBMNsbgzRMHU88GuLTQQd7TtmTnnKPHecgICCg3mxSbzYxBOFYNDEYgiCgYZo0g4CuUjd91T56K3Oo+GU8gWe3ruXZ/geome30lKYxp2dvZvfsz6yuGXSXu3hp2yZe2raRkldiWsdUOvwqLw6+xIuDL1Br1pHwhkO1VKbqVyh5JWvgemU6S2U6yxWmVLvoq3ZT8kus7d/Ic1tfIjCGnnI3PZUuqqUSlZINP2w0DY2moR4E1JuGsufR21Fm/YtreN2816auV0F4cdtGnt3yIgO1YUpSwaNK1bffP53lTnrK3ZS9Mqu3ruZPWx+jYYbYf/ohHDhjLuCxYWCQ4aZhWkcPHaUKj2x4nEc3Pcxg43mmVfdiZvVgeso9dJarDDW38ey2J1k7+BAdXg+d3h50yP5M6+xgaleV3mo33aUegsBn3bZ+NgwOUPJK9FQ68D3YWtvC1tomtta20F/fRMPUmF7qY2rHbKolocl26maIRlOoNQwd/hT6qnOp9Q+z715z6CyX2d6os3FwgMFajc5yle5yJyWvgglK1BqGjUMb2FzbgKFO2fcp+fbGkoe9eeSF36O1pmG4HjDYGGCwuYZasI1p/nSmVfalu9KB52+nyRC1usf2mhAEfnhd2u+fkucz3KyzZWgbQ41hXtPTw5y+6VT8EusGtrNl+3bKJUNHxdAI6mwdGmJbfZi+DkOl1+B5DZpmiMA08b0yFa+Dikyj7FXxpUL/8CBba/0M1bcxq6ubznKJ7fUa/bWt1APoqfTSU34N4jVpmkHqZpCh5kZqwSCeeJS8Ek1TZ7C5Nfc7OzIFANxbNu1WQTWwE43sZEP8DwNjb2BNdkQMpSg0sM3Er13aaMtkKcqTnSxHx0UT9dFMrl/OBHw0FLUlO7HOy5udMJcyapakeJKelZsnJ/qfV2e2rna49RTJzF5DO2NIjMaIiHD1KCozkrctMEHoZcqMn6P3SGGM6d0Eg1T5rGz3OO19G+HzEn7jsYMGX8RYGFhzgGed4+eAozN5DgQQkbuwYYSXG2PuGIO6d4pDZhzCkulLOOqwo+gp99BR6oh/XKZUpjC1OpUplSn4XnYzy8mP7/nM6po10WqMishQ6Sp3tZyb2TlzXOosSzke16pfjQ2T3YGVK1ey6KBFE63GLsPdwW08bioYYw35jtLkXWS/cuVKFi1YNNFqTAiT5UbSRPBy2z5YH+SFbS+AQFepi85SJ52lTspeGYOhHtRTN2eiG4klKTHUHGKoMRT/D0xAX6WPKdUpNE2TgdoA/fV+pnf2jV2DX0EIUPZs9IaHIRDT4lFqlxYg+NIcVZksRXk8CfAyT/cZaV3TqHb1G2WUSDyRzUmHtPcrfp/VpyAdwBenv8P+G1H3cGzy5BQdt8PNO1oP2Uj1ROnu+by8o9FzR9oyUhm3fVnD3E3zRmls5nkIvdjQyy/jpucZ+25akedsNDct2rGrNrkoAQcAi4C9gTtF5HBjzGY3k4hcAFwAsOeee7Jy5cpxU+gN8gY6n+6kSZNtJAuWN7GJp3l63OqdDAwMDIxr305mtO0rJ1qNCWF3bfvu2m7Qtk+mtq9nfUvaOtaNS10DAwUb0EwSPDH0lnZsk56xYrzXae0sO6PXSNuBj7S99kjsSF4lzcgerNGtBSvaRn1Hx2WixnIsDKzngbnO8d5hmstzwH8ZY+rAn0TkMazBdY+byRhzA3AD2DVY43n3Ue9uLppoNSYEbfuiiVZjQthd2767thu07btz2yczPgG9bdbE7o40jYe/g56CvDJNJ2TNPdccZfjbrqLIYzdSGdi59XNjwc7oPJK8drjrDoveT3bGwsC6BzhARPbDGlbvA7I7BP5f4CzgGyIyExsy+NQY1K0oiqIoivKKQDCUd8EGT5EB0s64GOl8u3yRATOS/NHo5I3QH3l15ZUpkjOS/JdDKmwxM/Ev2sRkZxafjNeCldE+cNkn3R6XnTF4RtMefxTvi8ga4NG1087wzp6LrtV2xn+76/9lG1jGmIaIfAL4CbbdXzfG/FFE/gG41xhzW3juFBF5CLsX6cXGmJ17iJOiKIqiKMorEJFkrUf0/KBmavJtUsdFaSMRP2NrBM/QaNeYFOXbkTUqo9VpR3XYlWR3qhtp4u+3OTfZ2BGjx93kYjK2LXsTw8O0GEp5adnyI90MaXd+TNZgGWNuB27PpF3mvDfAp8KXoiiKoijKbodg6JDkgdl5u7GVc8rlpSkTgBS8f4XRRGIDf6d5Bbd/V7CrNrlQFEVRFEXZrREMVS/zoGFpjrhBQzY9y44+jLVd3qKHuxbVV1SuqJ6deYjwjjz8d6R8L2ezj3Zlx3MTkdHKHqn9Ub9HBnu7h1crLw81sBRFURRFUXYRPpm1SXgtk1ufIDc9K6NJFLKWt/36yBPmonpGKlt0frTlitrbrpzb5ui4iZfuT/Fa8kXys2UjsjJaZDrp2bLZc2578si2sUhWyzlxNvDI6OpS1E95OmbLubJduUVtaatv5vxIMl6NqIGlKIqiKIqyC/AwdGQ9WA55D/gdzTOTomf65OXNnmuXdzTydkS3nW2PouxKioxW1/B3Dfp2NwMi1MBSFEVRFEXZBfgS0O0NT7Qayjjg7WIvjX089O7nGXqloAaWoiiKoijKLsBuclHswVJe+XgEBAUejqxBlJcvyuOei2SmZTdbykTlxsPwaq2/2KiM8uzOBqAaWIqiKIqiKLsAD0PZ2UUwIrujW94ub25atG37y90JLk9OVE/R1vA7U6dbT1Hb8vRw68zmGak/xmSnvJ1mtM/eapcve65ZkL7jdeftXjkyo61/5Dxu/aPVJVsG7Lb5I23fP5o844EaWIqiKIqiKLuAsgTMLW2Nj3d2TZKuZVKUyY0aWIqiKIqiKLuAigh7+/pUK0V5taMGlqIoiqIoyi7AQ+jyKhOthqIo44waWIqiKIqiKLuAF5tVrt742olWQ1GUMeOJ3FQ1sBRFURRFUQoQkbnATcCegAFuMMb8s4hMB74HzANWA+81xmxqJ2vdxin86y2njq/CiqLsQn6am6oGlqIoiqIoSjEN4H8YY+4XkV7gPhH5GXAe8J/GmCtFZCmwFPhMO0HVDTVe+41nxl1hRVF2DY8VpKuBpSiKoiiKUoAxZi2wNnzfLyIPA3OAM4BFYbYbgZWMYGCZWp3Gs8+Nm66KokwO1MBSFEVRFEUZBSIyD1gA/BewZ2h8AbyADSHMK3MBcAFAB127QEtFUSaaHX3KmKIoiqIoym6HiPQAPwA+aYzZ6p4zxhjIf6qtMeYGY8xCY8zCMtVdoKmiKBONGliKoiiKoihtEJEy1ri62Rjzf8LkF0Vkr/D8XsBLE6WfoiiTCzWwFEVRFEVRChARAb4GPGyMudo5dRtwbvj+XOBHu1o3RVEmJ7oGS1EURVEUpZjjgA8AvxeRB8O0S4ErgVtE5MPA08B7J0Y9RVEmG2pgKYqiKIqiFGCM+SUgBadP3pW6KIryykBDBBVFURRFURRFUcaIMTGwRORUEXlURJ4IH7ZXlO/PRcSIyMKxqFdRFEVRFEVRFGUy8bINLBHxgeuBtwOHAGeJyCE5+XqBv8Y+O0JRFEVRFEVRFOVVx1h4sN4IPGGMecoYUwO+i326eZb/B7gKGBqDOhVFURRFURRFUSYdY2FgzQGedY6fC9NiRORIYK4x5v8bg/oURVEURVEURVEmJeO+i6CIeMDVwHmjyHsBcAHAnnvuycqVK8dNr4GBgXGVP5nRtq+caDUmBG37yolWY5ezu7YbtO27c9sVRVEmmrEwsJ4H5jrHe4dpEb3AYcBK+6w+XgPcJiKnG2PudQUZY24AbgBYuHChWbRo0Riol8/KlSsZT/mTGW37oolWY0LQti+aaDV2Obtru0Hbvju3XVEUZaIZixDBe4ADRGQ/EakA78M+3RwAY8wWY8xMY8w8Y8w84NdAi3GlKIqiKIqiKIrySudlG1jGmAbwCeAnwMPALcaYP4rIP4jI6S9XvqIoiqIoiqIoyiuFMVmDZYy5Hbg9k3ZZQd5FY1GnoiiKoiiKoijKZGNMHjSsKIqiKIqiKIqiqIGlKIqiKIqiKIoyZqiBpSiKoiiKoiiKMkaogaUoiqIoiqIoijJGqIGlKIqiKIqiKIoyRqiBpSiKoiiKoiiKMkaogaUoiqIoiqIoijJGqIGlKIqiKIqiKIoyRqiBpSiKoiiKoiiKMkaogaUoiqIoiqIoijJGqIGlKIqiKIqiKIoyRqiBpSiKoiiKoiiKMkaogaUoiqIoiqIoijJGqIGlKIqiKIqiKIoyRqiBpSiKoiiKoiiKMkaogaUoiqIoiqIoijJGqIGlKIqiKIqiKIoyRqiBpSiKoiiKoiiKMkaogaUoiqIoilKAiHSIyG9E5Lci8kcR+VyYvp+I/JeIPCEi3xORykTrqijK5EANLEVRFEVRlGKGgTcbY44A3gCcKiLHAFcB/9sYsz+wCfjwxKmoKMpkYkwMLBE5VUQeDe/iLM05/ykReUhEfici/yki+45FvYqiKIqiKOOJsQyEh+XwZYA3A7eG6TcC79r12imKMhl52QaWiPjA9cDbgUOAs0TkkEy2B4CFxpj52C+jf3q59SqKoiiKouwKRMQXkQeBl4CfAU8Cm40xjTDLc8CcgrIXiMi9InJvneFdoq+iKBPLWHiw3gg8YYx5yhhTA74LnOFmMMasMMYMhoe/BvYeg3oVRVEURVHGHWNM0xjzBuz85Y3AwTtQ9gZjzEJjzMIy1fFSUVGUSURpDGTMAZ51jp8Djm6T/8PAj/NOiMgFwAUAe+65JytXrhwD9fIZGBgYV/mTGW37yolWY0LQtq+caDV2Obtru0Hbvju3fTwxxmwWkRXAscBUESmFXqy9gefHtXJFUV4xjIWBNWpE5BxgIXBS3nljzA3ADQALFy40ixYtGjddVq5cyXjKn8xo2xdNtBoTgrZ90USrscvZXdsN2vbdue1jjYjMAuqhcdUJvBW7wcUK4D3YyJ1zgR+NeeWKorwiGQsD63lgrnOcexdHRN4C/B1wkjFGg5AVRVEURXklsBdwY7jm3ANuMcb8h4g8BHxXRK7ArjX/2kQqqSjK5GEsDKx7gANEZD+sYfU+4P1uBhFZAHwVONUY89IY1KkoiqIoijLuGGN+ByzISX8Kux5LURQlxcve5CKMPf4E8BPgYeydnT+KyD+IyOlhtv8F9ADfF5EHReS2l1uvoiiKoiiKoijKZGNM1mAZY24Hbs+kXea8f8tY1KMoiqIoiqIoijKZGZMHDSuKoiiKoiiKoihqYCmKoiiKoiiKoowZamApiqIoiqIoiqKMEWpgKYqiKIqiKIqijBFqYCmKoiiKoiiKoowRamApiqIoiqIoiqKMEWpgKYqiKIqiKIqijBFqYCmKoiiKoiiKoowRamApiqIoiqIoiqKMEWpgKYqiKIqiKIqijBFqYCmKoiiKoiiKoowRamApiqIoiqIoiqKMEWpgKYqiKIqiKIqijBFqYCmKoiiKoiiKoowRamApiqIoiqIoiqKMEWpgKYqiKIqiKIqijBFqYCmKoiiKoiiKoowRamApiqIoiqIoiqKMEWpgKYqiKIqiKIqijBFqYCmKoiiKoiiKoowRY2JgicipIvKoiDwhIktzzldF5Hvh+f8SkXljUa+iKIqiKIqiKMpk4mUbWCLiA9cDbwcOAc4SkUMy2T4MbDLG7A/8b+Cql1uvoiiKoiiKoijKZGMsPFhvBJ4wxjxljKkB3wXOyOQ5A7gxfH8rcLKIyBjUrSiKoiiKoiiKMmkojYGMOcCzzvFzwNFFeYwxDRHZAswA1ruZROQC4ILwcEBEHh0D/YqYma1/N0Lbvnuibd/92F3bDdr23bnt+060EkX0s2n9cnPrNiZ2fCby+pjoa1Pr1/rHuv7c75uxMLDGDGPMDcANu6IuEbnXGLNwV9Q12dC2a9t3N3bXtu+u7QZt+27e9nkTrUcRxphZEz0+E1n/7tx2rX/3qn8sQgSfB+Y6x3uHabl5RKQE9AEbxqBuRVEURVEURVGUScNYGFj3AAeIyH4iUgHeB9yWyXMbcG74/j3Az40xZgzqVhRFURRFURRFmTS87BDBcE3VJ4CfAD7wdWPMH0XkH4B7jTG3AV8DvikiTwAbsUbYRLNLQhEnKdr23RNt++7H7tpu0LbvrrwS2j7ROk5k/btz27X+3ah+UUeSoiiKoiiKoijK2DAmDxpWFEVRFEVRFEVR1MBSFEVRFEVRFEUZM3ZLA0tEThWRR0XkCRFZOtH6jCciMldEVojIQyLyRxH56zD9chF5XkQeDF+nTbSu44GIrBaR34dtvDdMmy4iPxORx8P/0yZaz7FERA5yxvVBEdkqIp98tY65iHxdRF4SkT84abljLJZrw8/+70TkyInT/OVT0Pb/JSKPhO37oYhMDdPnich2Z/y/MmGKjwEFbS+8xkXkb8Nxf1RE3jYxWo8NBW3/ntPu1SLyYJj+qhn3Nr9nr4jP+66ee0yG3/+J/A2eiN/Cifw9mujfg4n+Tp5034vGmN3qhd2I40ngtUAF+C1wyETrNY7t3Qs4MnzfCzwGHAJcDnx6ovXbBe1fDczMpP0TsDR8vxS4aqL1HMf2+8AL2AfhvSrHHDgROBL4w0hjDJwG/BgQ4BjgvyZa/3Fo+ylAKXx/ldP2eW6+V/qroO2513j4nfdboArsF/4G+BPdhrFse+b8F4HLXm3j3ub3bNJ/3idi7jEZfv8ny2/wrvotnMjfo4n+PZjo7+TJ9r24O3qw3gg8YYx5yhhTA74LnDHBOo0bxpi1xpj7w/f9wMPAnInVasI5A7gxfH8j8K6JU2XcORl40hjz9EQrMl4YY+7E7k7qUjTGZwA3GcuvgakistcuUXQcyGu7MeanxphGePhr7LMJX3UUjHsRZwDfNcYMG2P+BDyB/S14RdKu7SIiwHuB7+xSpXYBbX7PXgmf910+95jEv/8T8Ru8S34LJ/L3aKJ/Dyb6O3myfS/ujgbWHOBZ5/g5JscXzrgjIvOABcB/hUmfCN3GXx8vF/0kwAA/FZH7ROSCMG1PY8za8P0LwJ4To9ou4X2kv1B2hzGH4jHe3T7/H8LeIY3YT0QeEJFfiMgJE6XUOJN3je9O434C8KIx5nEn7VU37pnfs1fC531CdZnA3//J8hs8kb+Fk+X6nKjfg8nwnbzLvxd3RwNrt0REeoAfAJ80xmwFvgy8DngDsBbrOn01crwx5kjg7cDHReRE96SxvuJX5bMKxD74+3Tg+2HS7jLmKV7NY9wOEfk7oAHcHCatBfYxxiwAPgV8W0SmTJR+48RueY1nOIv0RPJVN+45v2cxu+vnvR0T/Ps/4b/Bk+m3cKKuzwn8PZgs38m7/HtxdzSwngfmOsd7h2mvWkSkjP1yvdkY838AjDEvGmOaxpgA+FdeweEy7TDGPB/+fwn4IbadL0Zu+PD/SxOn4bjyduB+Y8yLsPuMeUjRGO8Wn38ROQ/478DZ4Q86YSjGhvD9fdiY9wMnTMlxoM01vruMewn4M+B7Udqrbdzzfs94ZXzeJ0SXif79nyS/wRP9Wzih1+dE/h5Mhu/kifpe3B0NrHuAA0Rkv/CuxvuA2yZYp3EjjDv9GvCwMeZqJ92N83038Ids2Vc6ItItIr3Re+xizz9gx/vcMNu5wI8mRsNxJ3XHZncYc4eiMb4N+KBYjgG2OKEbrwpE5FTgEuB0Y8ygkz5LRPzw/WuBA4CnJkbL8aHNNX4b8D4RqYrIfti2/2ZX67cLeAvwiDHmuSjh1TTuRb9nvDI+77t87jHRv/+T6Dd4on8LJ+z6nOjfg0nynTwx34tmHHfQmKwv7M4tj2Et1r+baH3Gua3HY93RvwMeDF+nAd8Efh+m3wbsNdG6jkPbX4vdpea3wB+jsQZmAP8JPA4sB6ZPtK7j0PZuYAPQ56S9Kscc+8O5Fqhj47g/XDTG2N2arg8/+78HFk60/uPQ9iewse3R5/0rYd4/Dz8HDwL3A++caP3Hoe2F1zjwd+G4Pwq8faL1H+u2h+nLgAszeV81497m9+wV8XlnF8892vTXLvktYBL8BrOLfwsLvpd2yfVZUPcu+z0oqH+XfSfn1R+mL2MCvhclrEhRFEVRFEVRFEV5meyOIYKKoiiKoiiKoijjghpYiqIoiqIoiqIoY4QaWIqiKIqiKIqiKGOEGliKoiiKoiiKoihjhBpYiqIoiqIoiqIoY4QaWIqiKIqiKIqiKGOEGliKoiiKoiiKoihjhBpYiqIoiqIoiqIoY4QaWIqiKIqiKIqiKGOEGliKoiiKoiiKoihjhBpYiqIoiqIoiqIoY4QaWIqiKIqiKIqiKGOEGliKorwsROTHInLuOMkeEJHXjofsVxIi8hUR+fuJ1kNRFGUkxvP7SkT+KCKLxkHuShH5SMG5fcLfIn+s651MiMgyEbliovV4taAGlqJMEkRktYi8ZaL1aIeIXC4i33LTjDFvN8bcOAayW37gjDE9xpinXq7sVxIicp6I/NJNM8ZcaIz5fyZKJ0VRdg/C7+FNIlIdZf5x+77Km/AbYw41xqx8ubJ3BGPMM+FvUbNdvry+UHYcEXmHiPxSRDaLyAsi8m8i0jvReu0oamApiqK0QURKr8a6FEVRXERkHnACYIDTJ1YbxUUsr7o5e8FvXh9wBTAbeD0wB/hfu1KvseBVN1iK8mpDRKoico2IrAlf10R3F0XkFyLy5+H740TEiMg7wuOTReTBAplvFJG7wztEa0XkSyJScc4fKiI/E5GNIvKiiFwqIqcClwJLwnCJ34Z5V4rIR0I9N4vIYY6cWSKyXUT2EJFpIvIfIrIuvEP6HyKyd5jv89gf9i+Fsr8UphsR2T983yciN4XlnxaR/xn94ER3DkXkC6HsP4nI29v06WoR+VsReSjM/w0R6QjPLRKR50TkMyLyAvCNEcYgyn+piKwPZZ/t1DWS3neJyP8WkQ3A94CvAMeG/bA5zJe6kysifyEiT4Tjc5uIzHbOGRG5UEQeD8fjehGR4itMURQFgA8CvwaWAamwbxGZKyL/J/we2xD+ZryeEb6vRORhEfnvjpxSKOPI8Pj7Yr0UW0TkThE5NEy/ADgbuCSU/e9hehzpMcrv5f8hIi+J/Z07f4T27xt+H/eLyE9FZGYoa174vVoKj88TkafCfH8SkbPb9EW7739fRL4Y/m78SUQ+kalnpYh8XkTuAgaB14rI+WGf9oc6/KXTt1GbL3Ha/C4ROU1EHgt/Ly4dzYUg7X+vzxSR+zL5PyUiP3LG5Qsi8ozY+cNXRKQzo2P8+5qt2xjzbWPMHcaYQWPMJuBfgeNGo/dkQg0sRZn8/B1wDPAG4AjgjcD/DM/9AlgUvj8JeAo40Tn+RYHMJvA3wEzgWOBk4GMAYl3xy4E7sHeQ9gf+0xhzB/D/At8LwyWOcAUaY4aB/wOc5SS/F/iFMeYl7PfNN4B9gX2A7cCXwrJ/B6wCPhHK/kSOztdh72y9NmzbBwH3B/No4NGwTf8EfG0Ew+Js4G3A64ADSfoU4DXA9FDXC2g/BlH+mdg7becCN4jIQTug91PAnsA5wIXA3WE/TM0qLSJvBv4R27d7AU8D381k++/AfwPmh/ne1qYfFEVRwH433Ry+3iYie4I1BID/wH7XzMN+z33XGPMwI3xfAd8h/ZvwNmC9Meb+8PjHwAHAHsD9Yd0YY24I3/9TKPudObJH873cF+r7YeB6EZnWpv3vx3437wFUgE9nM4hIN3At8HZjTC/wJuDBNn3R7vv/L4C3h/ofCbwrR6cPYH+DerH9/xL2+31KKOd/R8aq0+aOsM2XYY2Tc4CjsDcx/15E9mvTBxGFv9fAbcB+oVHp6nlT+P5K7G/qG7Dzh0gXV0f393UkTgT+OIp8kwtjjL70pa9J8AJWA2/JSX8SOM05fhuwOnx/MvC78P0dwEeAX4fHvwD+bJR1fxL4Yfj+LOCBgnyXA9/KpK0EPhK+fwvwpHPuLuCDBbLeAGzKk+OkGewXtA/UgEOcc38JrAzfnwc84ZzrCsu+pk1fX+gcnxbpjTVYa0DHKMdgEdAAup3ztwB/P0q9n8nodh7wy0zaMuCK8P3XsJOO6FwPUAfmOX12fEaXpRN9fetLX/qavC/g+PB7ZGZ4/AjwN+H7Y4F1QCmn3EjfV/sD/UBXeHwzcFmBDlPD76++rBwnz2rC38lRfC9vd3XGGifHFNS9EvifzvHHgDvC9/NCvUpAN7AZ+HOgs11fjOL7/+fAXzrn3hLV4+j0DyOM2/8F/jrTZj887g3lHe3kvw94V4Gslv52zr2B9O/1l4HPh+8PBTYBVUCAbcDrnLzHAn9ydEz9vo7QvreGsg+c6M/Ijr7Ug6Uok5/Z2DtXEU+HaQB3AweGdxrfgL2DNDcMbXgjcGeeQBE5MHT5vyAiW7GeqZnh6bnYH66dYQXQJSJHi43nfwPww7DOLhH5ahgmsTXUbaqMbmemmUCZ1n6Y4xy/EL0xxgyGb3vayHw2I2u2c7zOGDPkHLcbA7A/PNtyzo9Gb1eP0ZDSxRgzAGygoC+woSXt+kFRFOVc4KfGmPXh8bdJwgTnAk8bYxo7KtQY8wTwMPBOEenCru36NsQhcleKyJPhb8LqsNjMXGGtjPS9vCGj80jfhSN+b4bf80uw3qq1IvL/icjBBfJG+v6fTfr7P++3IJUmIm8XkV+H4X6bsTcH3f7aYJLNOLaH/190zm/Pa1eWUfxe3wi8P4wS+QBwi7FRLLOwNzjvExuivhl783eWIz77+1qkwzHYa+U9xpjHRso/2VADS1EmP2uwrvSIfcK0yJC4D/hr4A/GmBrwK+BTWI/MevL5MvYO5QHGmCnYtVVRON2z2HCGPEw7RcMv9luwXrCzgP8wxvSHp/8HcBD2btoUklDGqN52stdj765m++H5dvqMwNyMrDXOcVaXwjEImRaGjmTPj0bvbF1t+zirS1jvDF5eXyiKspsSro95L3BSeNPtBWwI+REicgT2N2Efyd+QYKTvK0jCBM8AHgqNLrAheWdgPTd9WE8RjO43AUb+Xh4XjDE/Mca8FRui/Qg2DA9a9R3p+38tsLdzzv1NiquL3ohdX/YD4AvAnsaGId5O0l9jSdvfa2PMr7GeqBOw4/jN8Px6rBF3qDFmavjqM8a4Rt2I14yILMCGIn7IGPOfY9GgXY0aWIoyuSiLSIfzKmF/nP6n2A0jZmJjmd2t0n8BfIJkvdXKzHEevcBWYCC8+/ZR59x/AHuJyCfDxaq9InJ0eO5FYJ60383o29g7fGeH7906twObRWQ68NlMuRcpMOwcw+3zoT77Yo3Ib+XlHyUfF5G9Q13+DrvBRBEjjQHA50SkIiInYGPkv7+Ter8I7C3OpiM5upwvIm8If3D/X+C/jDGr2zdXURQll3dh1+Uego06eAN297ZV2DVDv8EaA1eKSHf42xRtOjDS9xXYNaKnYH9nsr8Jw1gPfBf2u8yl8DchZDTfy2OKiOwpImeEN7aGgQEgcPSN+2IU3/+3AH8tInNEZCrwmRGqr2DD8NYBDbEbOZ0ydq1LMdLvNdiImS8BdWPMLwGMMQHW4PzfIrIHQNi+Ua8DFrtR1h3ARcaYf395zZg41MBSlMnF7dgvteh1OXa70nuB3wG/xy4Edp8N8gvsl+GdBcd5fBp716kf+2UYGxehx+mtwDuxIROPA4vD098P/28QkfvJwRjzX9gY7NnYBcwR1wCd2Dtcv8Z+gbr8M/CecMeia3NEXxTKfQr4JfaH+utt2jgS3wZ+Gsp7knSfZhlpDF7Axomvwa4xuNAY88hO6v1z7ILeF0SkxQNpjFmOXd/1A+yk53XA+9rIUxRFace5wDeMfd7TC9ELO3k+G+u1eCd2PdUzwHPYm2gwwvcVgDFmLTac/U2kb2TdhA2Zex54CPu74PI14JAw1Oz/5oge6Xt5PPCwRtIaYCN244roBmVeX7T7/v9X7G/Q74AHsL//Dayx20L42/xXWMNsE/Y3/Laxa1qKa2j/ew3Wa3UYrUbtZ4AngF+H4YXLsd6w0fI/sCGFXxO7I+OAiLziNrmQcBGZoijKboOIrMZuqLF8DGQtwm78sfcIWRVFURQll9Aj9RVjzL4jZp4EhKGlLwFHGmMen2h9JhvqwVIURVEURVGUXYiIdIp9RlVJROZgw/B+ONF67QAfBe5R4yqfMTGwROTrYh9q9oeC8yIi14p9MObvMnv2K4qiKIqiKMruhACfw4b7PYDdbfGytiUmCWEUyF9jw/mUHMYkRFBETsQu9LvJGHNYzvnTsHGop2EfqvnPxpijs/kURVEURVEURVFeyYyJB8sYcyd2sV8RZ2CNLxNu7ThVRPYai7oVRVEURVEmAhE5VUQeDSN0lk60PoqiTA7ynmkwHswh/bC058K0tW4mEbkAuACgs7PzqLlz8x4JMDYEQYDn7Z5L0LTt2vbdjd217btru0Hbvju3/YknnlhvjJk1cu6XR/jQ1euxu64+B9wjIrcZYx4qKlPxO01nqS95clGzialWkGYAzQCMgXIJ4wnSCCBogu9jfM+ei+oODDSa4HsgVpgp+xAYMAYxYDyJy8T5vTC/J5hIB09sOREQkJqVazybL67XDXgyNr/UG4BgSvZ6k3rD1hFef8a3siWwhU3JQ5rGphurl/EkJVdMWA5s2ah6z+qHsS8xxrbBC2U1g6SfnDZKI0jkh30ltYZtY8mzbSeULWGeZhDXC2AEjO/ZcYrkeILUmyAS9jVIo5n0RWAgMLbN4XuCAErhOEmij/E8JEj0NH4oI6zPeB5ijL1GPIn7zF4jAXhhW0TivsaEdfqe7aeo7fUmpuQjwzUrq1K27XCuMeOJ7aOSH8syJT++ViS8zuLxlOS6NJ7nPMnMWB3D9sTyw35P97HYNob9HV0b8fj74WcibAfG2DEJovqjiyO5JtzrKboO4r4NkrpS14UQf06CaOyMvUYksPXH7TWwdfva3O+bXWVgjQpjzA3ADQALFy40995777jVtXLlShYtWjRu8icz2vZFE63GhKBtXzTRauxydtd2g7Z9d2774sWLn95F1b0ReMIY8xSAiHyX8GG6RQU6S328ac7ZdkLse7BpC83XzsbvH0L6BzHDNcyeMwh6KvgbtyFbBzB9vTSmd+PVk927vf4h2LwVeruhWoEgoPaaXryhJt5QAwkCml0VvFoDAvAGh2HjFqS7E1MpYzrKGN8HD5qdZfyhBqZkdSo/v5Ggp4vmlCpBxQ8nyILUg9iwkXqToFKivGYjiNCc1guAv3Y9pqcL01UFoDGtE39rDW+4DiLUZ3ZR2jxEs6cKxuAPDBN0lO1EOZyMS61BY1on0jB4ww076QWa3dXY4PPqATJcx1RKBNUSGENpw7a4n0zJo9lRIqh4VDYOQdOAl0yuS2s2Yro7aczswRusQ8kjKNv2G18obRlGmkl/m7JPfWoH5c1DAATVEkHVp/LigNWh4iMG/HVb4r7wag1k23aa03rxhuvI4BBm+xBMnYIM16zB4lsDJpjSibdt2BpQvkejrxNpBvhbtsfnZbiO178d01klqJZtf2/qx2wfQro6aU7vwfge3lAdsIaUbB8m6OnClH2CjhIIlNdsojmrD++J55BqhfprX0N5zSaCqT3W0DKGoFrGe+4l2GO6NVKGajRm9tLssteKt72O1BrUZ3RTGqhhRMADb2CYYEpnYoA0A/wN/QRTexJjKwioz+jGH2okBiJgquW4fuN5eIPDBL0ddvwDaPZ1UFo/gOkox7KaPVW8obq9ueB5EBpRQZeVJfUAaTZpTOuk/NIAiNDo67R9N1izxlLJIyjbcSg/u96m9XRiyj7De3RTHqjHhp23dTumXMJUfWvM1hr89LdX5H7f7CoD63nST6jem+RJ1oqiKIqiKK808qJzWtaXu9E5HaXexLgSQUolazR4HvgeUvITR5GInYD7Od5I30NKJYxnDQKJVnwI4AsGL/GQ+CSyS771SoQT4tgbIGInyRB6oIg9WtE5CY9NEDoohNhAiBeclEqJlyzCsx4Yp0OS/3meVpHk0b0iKVlGQBDbZs962WIPhO+0OSvPd469MG/Ur76kvBhxewJHzzzds/0W9Z3veP2i9oVtjXSOvXyhDkZCLxWkPUChp8pEzjt37MJjKZXi6ymu05jQq+VbfTySsSz51kNYKtnxc9OC8OWBlHwCX5BmaJh6mX6NvJQitg5IX6uegLE6mGgcfeNcq851ReJJkqj/PUmukciN5Xpso751rzf3cvKSMZKGScYh0wybHnq0ov4Nr0ExoWctyud76Tqy15rDrjKwbgM+Ed7dORrYEj54TlEURVEU5VWLG53T17mXCbo6EgOm1EdQ9ZFGGZFuG4IUTZ6rJaCLoKtiQ6ckmbgH3VU8EYJKCVP2EIOdDJc9gjCfKXs0owm6J/hMIegsJ6GEhKFavhBUklCwoKcDUy1jSjYUzVRsuFVQSUKrTDMMoZrSlYTkiRBM7cWUfUw5mXwHlRJepJMnNDvLcfhis7Mch50ZEShZ40ACgykJTfHxwsm79bAJBhBPrLfJE0zJnm/2WI9bHHIotk+aVT8JmwvD+YK+bqunkJSJwsSMsecco0KaYb9XfDDEHpqgI5lGB2UPmdIVe/1M2ceUOq0BV/KgowIln6CjgpR960EMjbGo/yWUbcqelVEtY0SsrGaAqXTFIWqm5EFvF165FNZl+yOAJJSvo0RQsZ4rU/bsePR10egq48+cag30kk1rdpbxyn4cwhnsMc16QetNpOQRVBMr1ZSSkMTIMxZdA8ZPxoaSgb4uq4MnYEo2dM8XgrJnx5swvDPqc2cMgrIHZS8OAQ06y0lIpmcNtGaXF3tWkfC6KwkYsXr7Pn7/EMb3MR3280IQhtSG42p8D2+4Zq/n6DoYqttx94Sg7CPG2PoDrPEqQKXYjBoTA0tEvgMsAmaKyHPYvfzLAMaYr2CfTn0a9snOg8D5Y1GvoiiKoijKBLHD0TnG92j2Vp1jodERTq6rdu1VKQoL6ygj1TKNbhuWFSNCfUoFr6NkvUPRHX1faHo+lE08Uads072qT1DxaXbZOvyhJl6tGU/sTcXe5ZeGodnbYSfqJY+gZCfMXsNYww1rbEjdTqAbfVUbyldr2vpndCZraQKskVO13hEJjahmZwmvaU82Kz5eM8AbDqwh4QmUfTuZrpRs+FbFTm6N482h4iVrzGKPhoSeGUGCpH+DyMAKbSxrKHbasr5tp/GsftK0egeh4RmtrfKGbbhgs6Nk80WGbkcZr2bPmbJHo69K4Hv4w00CrEHmDzdDo9N6R6yRVorDEaUREFT8pJ2hl8WLjNHQQJOmb8e9FuDVmjYEsurjDZfi9iNiDanQ+HCXJRmP0PjpoNHl4+3RA01DUPJozugk8AW/FuCFYXb1KRVrbNU8pOLT6CzhDzWt3LJv+8iDZqdjZFY8vKFmGG5px6PZVcKrBzYtDvE01knoexgPvIZdkxZdO9Iw1ggte9ZAbhrKW4ZpdpatTiWPoOLhDzVpdJfwtzdteGBobAe+hxfYS7DZUaJj7SaCab22z8J1VUHZx2vaz5UpCd5Qg/rMLgiwYZD9262RW4o8e4ag6uMPNmIDN+W9zDAmBpYx5qwRzhvg42NRl6IoivLKp16v89xzzzE0NDQu8vv6+nj44YfHRfZkZ3dpe0dHB3vvvTflcnmiVLgHOEBE9sMaVu8D3t+2hICpeHEIXLPTGh9ByUM8Q1D2KG2x54zvEfhiJ5KDdiF/FCnVrHjxBhJAvPFB7N1xNivAg2YYStesehgfvLrEBokExk6uQ8OhGRldoYFhJ+sm2Xgi9iBAs+rjeYHdOEGssSgmNMIiL5kv2Mx2Eh2UBAnD74KyIPGCHWLvjDSD0MiLvErpMMHIcxUZUgDN0HshnkAjQAIwflhf0/Zd1FaqHl7TGl2RISB1Z3OIyPAK+9irhac8q2jk0TIlwdSjc6FXBjB1G4YYVH1rgInEBpUNp0vkW8dOtHFC1N7oGpDY82Q8oVkNN4do2PY3fY8SJB46iOXasQvHwiT91qwKzYrQ6CzZtUWhXOOBmMh9Co0uD2/Y9pHn2b6Mx8CzekWexrhuEbzhZjx2sYcxMAQlseMdCF6jaY2rkljPqwmS9gbgmej6t0Y+vlAOvbJirLHWrHh4w02CkuBFoYyO9xIPjLF1mqFhjEyJvaBxnviaEmg0aVatd9erCwR2o5PACTENSl7sUbWhlRMfIqgoiqIoMc899xy9vb3MmzcvjsEfS/r7++nt7R1zua8Edoe2G2PYsGEDzz33HPvtt99E6dAQkU8AP8FOwb5ujPlj20LRmp1oshruYBfthmf/e7FhE60PMiUbBoWXeDjiXfVIDCmrF0kMW1xvZDCFYXslQZrhRDw8FwQelEIDxJUZGnYmkhPpI8mkPTYenB3WgFi+SBgh5hhtURsC34ZyReFlEhpiUV4riGS3OGcdjbvzHEnW0IhxdsQzYILQSIzaC6ER5ujkE+/AaML2ERs5xLvfGRPqLYKEGyQEsecIpOzhGRMaSH6sRxR2CdbwQ6ycqF32PzaEzU+8aEFJ8Jpe7IVK1o2R6BF6v+Ix8Yg9cHFYo3PdWIMpbFcUIRrJD/sWzxpQxiR6SNN6roKyhzTSu0BG4Y1xeGl0zYVewqjeqI4gXB8WXYPGk/AGQRgyGLZBAhOHHdp+xpaL+jwaozivEBh708J4gnR1YkJPajRGXtnDBH5ovIKpluLxDkoeplqJx1TCsQxK4c0QE127xbu1qoGlKIqi7HKGhobGzbhSXv2ICDNmzGDdunUTqocx5nbsMojR5ZdkcgmJpyII11FFa4KCih9P6EzJhtXFhkfkVfKJDamgnNyVl8AgjUi+E1oXeYTEhnKlDBjA+Mbe7Y/CrMK8RoTyQEBQ9mOjq9Hp40VrdQCv4tEsW++YNXoI13ZZGdKEIPSyBCVBjJ3YB1UJN/1IjC5pGrxGEp5oPGsIefVwch61JzJSG+HW5I6xaXxBfJvW7PBgOECCsD996+WSkhM2WLYuD5HAMXCJ218PDT/rgQHw7PsmsTERjUFQktAAsX1Z7yklE/KoT6NNJwCv7sWGYuT18eqGRqfdFj0ohR6myDgo2XVliCR6RyGR4fjb68bqHkVSRvVGRm2jI/HiNcvOdujhOAQlQDzrvYw8Ut1+vBYvKAtezRBUwj4xYEpQpxSGNRIb68l1a/MFJXttxNvNN6HZEW56EW71Hl37UZ83u8t2LKO+LFvjMagIDfzwmhJK25u23nJiFNb3mkq9t5x4GCOvZUfirY1CY/Gg0V1CTA+Nbh9pQhSKGpSFpinZGyNhPxahBpaiKIoyIahxpbwcXonXTxxGFk7YvFqQTD6xBlFQtduLxwZG6GmIvAV2Qh8ZKqFRFk5CjYDXBC+yHJqOoRB5IAw0OkCCpDxExya+ox95qMRg65YkZI+yQLhuCqBZ9mh2+IkBJKGR0OHF64C8pgnDuIjD95oVO4GnEoXf2XxBg3iCHuWXhon7xF1X5DuhfoATVhiGxMVhaYZmh8R12wZag6RZCcMIxQt3Pcz0my+UtwU0q4I0BYKAZtXDq4dGZjRhD42woOTh10NvY5XQKEg8elGfROvSbP+Hhkcp8tBFnjGh0RFutBCERrA4nppYlq3Dq4fGnR95rZL+SowsaFaEIBDb37HhaKuNrq9ERjJeUklCP0sS0CwLXjPsx7LjoYvCM4NkTKJxCSrWwLMhjHYzw0ZHtOFF1jtrjxudvjU0I32ExKvlQ7TBRbRJR7Mj7EsDQ3tUk+si6udyEnbr1Q313rI1jEuCqdht+xudQmnIOGUE43nW6MIx8nNQA0tRFEVRFGVXEBktYVigG95mPKDphEx5EnuEopAoYsPK2LTAKUtYLsDZcj3ZPCCemEISZhckk0zjgSHydoV5AEP4oNXUhBe7M2A8+Q4NQVcXz/HUGAiw67yMl3ii3DyRoWeMgJ+EQto1XyapK5l7p4jqTUIFE+9J3AfxxhhRocQQs5Zkut/dMMi47kheqHtkXEXeGfs/nPTjGJQe6bQw5tJ44QN3HZmtYXvh5nWRrr6JZcaDKlGfJe2w14RJmptpS9TfqfDByOsZt90ZLz+5LgLHmDZi4nWAAc6Drp3rAYhDTY1ERlHYZ9E1HippPBP3UbxFfRRumA1JFFLb2eO0JfBt31tDPupzY9Oj8TWhhzWyiEKdrZEaXnvGWY/ohxcOaV2yFAcPKoqiKMqrmJ6enolWAYBrrrmGwcHB+Pi0005j8+bNOyxn8+bN/Mu//Et8vGbNGt7znveMhYosWrSIe++9d0xkjYbh4WGWLFnC/vvvz9FHH83q1at3Wd3jTjSJDrcQj++Mh2FVzXANi/WESLJuJc6XCb1y5nh2oh4aCLEnJjFkUgaNl0yQgygcMTIU4rU8Nk+zqxSGrxEbVEE5DJkK7/bHYWShwZGEGBLrGk3KA1/C9xkjxU+8c64RFoVnRR6tVNkwFC8OqYzO+8kEPPCjkLloop70S+B4vqI2ZfssOg+ODGk/wY76ODKeIqPWNThSa+PCsYjHxumTCHdtVaRD1Na47eXMeId9HXnHor5zDdaU0RWtSXLO2evDMbjC8pG8SHZSX9K3ri6Jrs616ROGC4Z5SolxEzjXUrMiKXmB74yzU0ez6tGsOgachPX5UZnkMxVfR6EOQcV6PBNvldWlWY0+jzacMvpsBm3cVOrBUhRFUZQJ5JprruGcc86hq6sLgNtvH/WSnhSRgfWBD3wAgNmzZ3PrrbeOmZ7jSbPZxI8eWgt87WtfY9q0aTzxxBN897vf5TOf+Qzf+973JlDDsSNeqxOGMbnrsqQJ0uHbiV446fRroUchCpkL78pLMwwZdDxLUQhe4NvQLLueJXH52B3bDOGNfCKHRxCu1xFjbAgcpNxEtSm+YyjZSagNywvlVGyoWaOa1CVB4tWJnCym7BoTjtHiJfVbb0FSf+w1Cne6S0IanclxvD13uq+9JnE9sVEQ6hw1MvYule1sPPDttuGxcRfKcde5xUaYb1L6ROF4buimXzNxO1IbTwTG9p8PXjMMpfMTXWJPYOQpMiZ+78XGSJJPwjBBG0KYGEF2fVRi/MTXSoB130TGSYB9TzqkLyjZvmhUBa+RdJ3xgIoJrynicEc7holhlw1FTQxI4k0lpCMxfACCsh2jaBziNWE415OXbYtNb3Q6skLPXjNcJxatM4t2k4w8t7Hha6JrJFyTZiDodMY9/Ox5zSRvEerBUhRFUZSQBx98kGOOOYb58+fz7ne/m02bNvHSSy9x1FFHAfDb3/4WEeGZZ54B4HWve13K+wTwm9/8hmOPPZYFCxbwpje9iUcffRSwRsSnP/1pDjvsMObPn891113Htddey5o1a1i8eDGLFy8GYN68eaxfv56lS5dy/fXXx3Ivv/xyvvCFLzAwMMDJJ5/MkUceyeGHH86PfvQjAJYuXcqTTz7Jcccdx8UXX8zq1as57LDDALupyPnnn8/hhx/OggULWLFiBQDLli3jz/7szzj11FM54IADuOSSS0bso49+9KMsXLiQQw89lM9+9rMA/PznP+dd73pXnOdnP/sZ7373uwH46U9/yrHHHsuRRx7JmWeeycDAQNzOz3zmMxx55JF8//vfT9Xxox/9iHPPPReA97znPfznf/5nvPX4K5nImxJ5jBodyZ1w+0ruokevyINg75yHd9D9RF48MXTqMNGdfV+cO/fJZD21w1vkiSglE/bYgxEaa/XO9Nbf1stgdWlWwzv8oVcr8gDE63FcD1YpaXvibXL6wE+8Bkkem9asJJ4I9xWUknPx2qPIoxMZac5xqo1etJlDKKfsGk9JHYQbUETEhlC4cyLOtSnOWATOerEoTDE2AmPviiTj46U9RnGfRHnd8XTW4sX97hP3fyJHnDzOtSCJDom3MzF+XE9aEF577nnj2bqSMZC4n2NPmeM5ivIFZeKbBybM06gmnscoT1BOPJlBmMf9PAS+k9/xYjWqQrOajKvd1MW5VsphHzvlgpI1IJvhjQ2roy3TrEKzw/4PKvbl5i1CPViKoijKhPK5f/8jD63ZOqYyD5jZyRV//oYdLvfBD36Q6667jpNO3sJpNQAAWF9JREFUOonLLruMz33uc1xzzTUMDQ2xdetWVq1axcKFC1m1ahXHH388e+yxR+x5ijj44INZtWoVpVKJ5cuXc+mll/KDH/yAG264gdWrV/Pggw9SKpXYuHEj06dP5+qrr2bFihXMnDkzJWfJkiV88pOf5OMft4+RvOWWW/jJT35CR0cHP/zhD5kyZQrr16/nmGOO4fTTT+fKK6/kD3/4A3fddRe9vb2psLrrr78eEeH3v/89jzzyCKeccgqPPfYYYI3KBx54gGq1ykEHHcRFF13E3LlzKeLzn/8806dPp9lscvLJJ/O73/2OxYsX87GPfYx169Yxa9YsvvGNb/ChD32I9evXc8UVV7B8+XK6u7u56qqruPrqq7nssssAmDFjBvfff39LHc8//3ysQ6lUoq+vjw0bNrT00SsRd62QEUHE2ehATCp8KwnbSvLH5yD1Pl6bFOcz6fJOntjrkpEVbcUe6+quQ3LLRh6EFv0y9ZCUib0YTt7IO+V6N1w5SXgdybqyOGvkGUoyx5s6RO1xPV5xm5IscTvjsXHWI7l1SuQpEQyOV1CiNkosOyofpWXDJJO+dhRzX7R/H10z2WskHvt4fZerX7rvU23P2giZaybOky3rjDWQ8lJJ5rw4ZUy2bdF/k84jzvuWMgXHqRDG+HpLxialg1PWgHU5udvZ5+WP2pPNk4MaWIqiKIoCbNmyhc2bN3PSSScBcO6553LmmWcC8KY3vYm77rqLO++8k0svvZQ77rgDYwwnnHBCrpxzzz2Xxx9/HBGhXrdPIl2+fDkXXnghpZL96Z0+fXpbfRYsWMBLL73EmjVrWLduHdOmTWPu3LnU63UuvfRS7rzzTjzP4/nnn+fFF19sK+uXv/wlF110EWANwH333Tc2sE4++WT6+voAOOSQQ3j66afbGli33HILN9xwA41Gg7Vr1/LQQw8xf/58PvCBD/Ctb32L888/n7vvvpubbrqJO+64g4ceeojjjjsOgFqtxrHHHhvLWrJkSVu9X3UI8V3veP0JTvhaGGIWryuRZL0KzuQx8AWJPQrOBDLaUtsHMeJshABJ+BPxhNYY+yY2RCTx9MST9Ggrczeczyd6hFecFnklIJlsm3CWHG9uEIbnReuhbJsT3UzYP0EJq3sU0uWEQiZ9KSkDymvacl4zyRKH2oVhe1HfBq6FZSLjibiPI89M1J6mibxriRUR7cgYP1DZMUajuhDr7YjGO/bkuG2OwiOj+qP24GwCQqiTF03uJdY79jZGOiRDlhghoeyoPkj3Q+TJix4AHXuwhFRonbt+zN2Iwz5njNhIiXUTEI9km/jIAMy0NTZunHoxtHj7jGebQlh3FBIb7yopJLF5QmoM4+fERX0Q6uWG2Lptc/sq1Zc4+dXAUhRFUSYrn33noWMus7+/f0zlnXjiiaxatYqnn36aM844g6uuugoR4R3veEdL3r//+79n8eLF/PCHP2T16tUsWrRop+s988wzufXWW3nhhRdiY+Tmm29m3bp13HfffZTLZebNm8fQ0NBO11GtVuP3vu/TaDQK8/7pT3/iC1/4Avfccw/Tpk3jvPPOi+s+//zzeec730lHRwdnnnkmpVIJYwxvfetb+c53vpMrr7u7Ozd9zpw5PPvss+y99940Gg22bNnCjBkzdrqNkwUj0OhIz8pSd8OjED5ncheFXkXbsKd2GYwmedEENgon8+wkPuVViCb9EE8MAwm9Ms7ENIgmr+G6FmnasqkQsXCi7xphzVIyIU+MNfs/fk6TDwTJxFfCSbVXTybskdHo101iFGbagoCJtsp2J9QlCCKDKrBhXm7b7XbbyQQ/0j0og9cgbbQ4xk0cGhkkz3wKKpHM0Lpx8oOtw6vZ5zvF+nlJu6PrAQGJ1rI5YxQQGqLO2qDoRDO7PXh4/UTtiA3daOv2htOesB+ikLnY2PaTcQrKyXsCIFxzFJTSxmNQEQjsWimJjLSmY+A54+N6PqNw35QnyVkPBRB4kjxuwCTXSnL9gxdYw9fDOMZqkte9uRDfWMAag/YmRKKnfYhykmC87LHTJ5GxmB0HB12DpSiKoihAX18f06ZNY9WqVQB885vfjL1ZJ5xwAt/61rc44IAD8DyP6dOnc/vtt3P88ce3yNmyZQtz5swB7BqniLe+9a189atfjQ2YjRs3AtDb21toEC5ZsoTvfve73HrrrbE3bcuWLeyxxx6Uy2VWrFjB008/PaKcE044gZtvvhmAxx57jGeeeYaDDjpoh/oHYOvWrXR3d9PX18eLL77Ij3/84/jc7NmzmT17NldccQXnn38+AMcccwx33XUXTzzxBADbtm2LPWftOP3007nxxhsBuPXWW3nzm9/8inzuVR7R+hITTm7jia+XTHpNiXhbdlNK1h5Fk8soPbseKV5/lPkfvQfitS4pI8LxLkS7FKZ2m8M556yLctdqNcuSDtcK1++0GCzxGh5npzm3TEkcQ8vVKa1fKo+zJiq7w2C0viub312X5u6uF68VCh90a3dvjNY6JWMX7zrorEcLnFcz2syk7IxVaDymd2101kr5mfa469KcHRID55pI95Oztil7zvFSto6nk98nf9xIy4h0IXWNOF63KE1IG1fONROR1CPYRwpIsvmGtNbrPnA6de1Kpl7XoI3rl/Q16qXrj/LlhWbG+jrtKUINLEVRFGW3ZHBwkL333jt+XX311dx4441cfPHFzJ8/nwcffDBeKzRv3jyMMZx44okAHH/88UydOpVp06a1yL3kkkv427/9WxYsWJDyBn3kIx9hn332Yf78+RxxxBF8+9vfBuCCCy7g1FNPjTe5cDn00EPp7+9nzpw57LXXXgCcffbZ3HvvvRx++OHcdNNNHHzwwYBdz3Tcccdx9NFHc/HFF6fkfOxjHyMIAg4//HCWLFnCsmXLUp6r0XLEEUewYMECDj74YN7//vfHoX8RZ599NnPnzuX1r389ALNmzWLZsmWcddZZzJ8/n2OPPZZHHnlkxHo+/OEPs2HDBvbff3+uvvpqrrzyyh3WdVKSnY+5Bomkz2dD4lITVffOP0laeoIp8cTQOKFg2bUzeWmublkjLHUuR+fsq8Xoyuqe1w+QnlC7a6GcULyWtTgZWS206b/cdT1xu9y+zOmnbHuicq7xmqdrO/1ydInX4NEmXzZvS7pjuLjPMsust0uMHVrkuOOY5M/kyaSljJaoL6MNVwp1ldx6k+e8ZetL65wKrU21NflcuJ+PlCGVcx27fdFu/RWATNZdeRYuXGjG85kbK1eufFlhG69ktO2LJlqNCUHbvmii1djlTOZ2P/zww/EkfDzo7++nt7d33ORPZiay7Z/4xCdYsGABH/7wh3dJfdnraOXKlSxevPg+Y8zCXaLADtK1x1xzwHs/ZbdDj7aWhtTkN7UZRBgaFW2v7sZexeucvHDr9WijDGeb7Gjr7ERWGJoVbhXuNUwq/DCWFd2ZD9cYxQ8idie8zvojG94lyYOTQ4Ky2BDDMJ8Nw0raG2/tHZh4Qhxv/R7mizwQ0khvLkGQqgqvaexW6kHSzqCUhPS5/eL2uwQm1jMK9XPXhLl9LcapN8pnnGMXA17dJNu7O+Oc7qScNEjG1Amxi8PzIj3d8qEh7NVNHCoah8A5oW3uf3dNVCo80QkRlCb2kQDu1udxiGB4PgqbdNbAZY1Qd72VVyflwXK3tnf1i8NNQz2yIXnSDMMinTrdEMZUeGykk4A0ElnRuWgLdldnr558fqI1X+55gN9d96nc7xtdg6UoiqIoysvmqKOOoru7my9+8YsTrcrkxTFOouNcL5DnTGYDEy7Il9hQMCIQPePKA4PjaWhK+IwskrVG4SuQ9MYXxoRGUIPYmLELnhwPRSkxSFzjz8qReDIbG2ZRW6K8TjhXtKbIPqPLaXNJUl6C1BoaD0wAvmNwuV6OaHIfGwsQ79CXXu+UeDNSdUcbaEQT/qjfnXGKPTaBbU/U/qxnKOqjSE4QbWjijrFjTIg7npCs4zK2DeK2y9j1ZZExFK9vayT1pcIEXaMmM36mlPSBHXPbx/F5Z/2SCHjO9vKusRKHqzp9F21CkRpLNxww6kcv3WfGMYyivm/xgEYGVpg32hQjcAwz4xqTrhzXMHbGK74lEMl3x899WLYTJhmPY4FxDGpgKYqiKIoyBtx3330TrcKkx0DLhNwNS4on267hZUJvRCxD4nIpz0A0oS2qOzNZjdM9ku3aM+dcPaKdAF15qbpcL4EjJrvux91YwNWhJeTKnaRn0lNpjkGU0jXr+cExCiQlLvXG9SJmPR+psXPyFeFuUJH1hiWZ0m2N2pY1Coy7E6DbD07fujJiYzSsE6feFoPHc8Y3p39ToX5ZAyZzPYukdYk3r3C9te6aMGw7U/W517tjvMXtcTdNMem8qS3qo75MGdppvWOcz1F2TGIjMsgpV4AaWIqiKIqiKLuQyPOT9fqYcMaZMgIyk9V4omgkPZFNTZ4l8WZkJ8Hu+hlnjUr837TKhGTyHRkvEmTTJD1xNZn3Ec5EOcqQraul/mgDhMzan9gQijx87qQ4Eu/UlwpLi+ohkZeaZONMzIvkOnlT/eTIjI2ljMxoPAm9kCm57iSfnHOS7ge3z/KM5RY9s+9NOn9KbuaakBzjLNXezPXjeohcPVuuWTfcUpzmC6mxdnWK+9dpjiszNvCifnH70c8WbNMXnnOdOR6sdqiBpSiKoiiKsgtITbYlbSQB8ZqT2AOTnQgKmIyxQigztVsayQ55cVZ3Uh8SlMM057lUkdw4JCy6ax+FtpGZZDqT6Oxzt0x2XUtEdic5x2iIw9+cNgYeUHG8JNFzlCJj09EltZU4tHhA4rVdrhHi9Le7zXzKAHPGqdD7kQktBMcoIBmjwM2foyNYPbOeqKjvUvVEfRntEumEFaauKy8pkw2JdMtn25c1TlN2hee0JSQbIgikvUcQh1mmvHqu8Oi6drx2Kblh3pRhlr0xELUr0ssxvDyc68Qh67XMbsse5IU1FqAGlqIoiqIoyi4k2mo6XrifubsfhSJFd869JinvTUuYWXSuSXr798jjZazMaMKZnfAaR4ZHesIdP3/IJPLi0Cx3Mo/dvCA2lKJJvUnN19OGnHHqcNY5ufKj9gXu2pfM+hx3Mmx8q6cXbVohiY7GB9+dNEcbQ0TPjsozSEi3JSrr6u8ex4auM/l212u5/WVM2N/uuqDwFdWZ8pq5GKffHM9KXCa71shzdCN5n/J6ZeSnvG2Slhf3YbacKyIas8wmGymD0jH6Wh+2nNQtWZkkZVPXimT6zdE1KhNvY59jILket6zHM/YEGsgpmkINLEVRFEVRlF2FtL6yoWdAei1NZpIdGUSpdU/ZO/eSODnEzUN6Epm985+33iheE2OcY3EmnFkDkbTO2RCu2FAk0ScvRC+7ritWOTvhzynbEp6XZyRkyzlta8nHCO/d9pH0V2G9URNzjKh47N287mCSeZ/XH6T7LeuRyzNSM82IZbjvU8Zk5tj1CBZ6+TLtTOmZ17fSpk2RfpkbDi3tNuk6std0Nq8rN09O3rBnyUajKoqiKMpuQU9Pz0SrAMA111zD4OBgfHzaaaexefPmHZazefNm/uVf/iU+XrNmDe95z3vGQkUWLVrEeD46Jcudd97JkUceSalU4tZbb91l9Y43qbvn8UNusbvrRS8/DN1z8zkPlY3yuw8RjibpQZTubnjgZfK68lwdIk9IyTkW4p3/At/RMdTDPoA3kRE9iDd+FaRFctw8Ub1B2XmYbjmjW6hHVlbgvpw+TeWL+iiri9PfQXZM3DZn+i3I1ltK5KTakncury5Hjisjrsv97yd6x/0VXQeldFviaybyckm6P41A9sHT8Xi7fZ6Tx/UWufJiozGbnsnfcqNhFHql8voF/73W9JT88AHJLXklp2wmT1bPIsbEgyUipwL/jI2q/DdjzJWZ8/sANwJTwzxLjTG3j0XdiqIoivJK5pprruGcc86hq6sLgNtv37mfx8jA+sAHPgDA7NmzXzHGSbPZxPeTRSD77LMPy5Yt4wtf+MIEajUOCDQrJJ6ScPKaFzIXEYfZOWtnTNaz44Z9RduW+xk5We8Hyfs4TNGkvQEtOwe6YViuHGfyHN+6d9Y1uXLzdhGM5bv1RnmzoWq0ysiGl4mBprvVeLgtvPGgWaL1uVAlpw99EKdsiqgtURhj3q5y2T7OekGifnLDN53z2TVPbn637SbSwanThG2N+8UjvR27ONdOpg9T14rkj4Hr4cn2idu+luvCd9oqjjy3PUXewKjeIJPHqSulkiF1DcZy3DDNnM9CvD7PqTcbHtlCm2v5ZXuwRMQHrgfeDhwCnCUih2Sy/U/gFmPMAuB9wL+gKIqiKJOMBx98kGOOOYb58+fz7ne/m02bNvHSSy9x1FFHAfDb3/4WEeGZZ54B4HWve13K+wTwm9/8hmOPPZYFCxbwpje9iUcffRSwRsSnP/1pDjvsMObPn891113Htddey5o1a1i8eDGLFy8GYN68eaxfv56lS5dy/fXXx3Ivv/xyvvCFLzAwMMDJJ5/MkUceyeGHH86PfvQjAJYuXcqTTz7Jcccdx8UXX8zq1as57LDDABgaGuL888/n8MMPZ8GCBaxYsQKAZcuW8Wd/9meceuqpHHDAAVxyySUj9tFHP/pRFi5cyKGHHspnP/tZAH7+85/zrne9K87zs5/9jHe/+90A/PSnP+XYY4/lyCOP5Mwzz2RgYCBu52c+8xmOPPJIvv/976fqmDdvHvPnz8fzXl2BNrEHK3vXfbQerBHTjF2DFRo6sfw8j5kro2QwvknOR3f4/bQXpcWDk/IkGUzskTKJV6hs0q+Ux8dJKxtMyR5HOqXq9BJdszKjdkd6JLoZgopJewDLVk9TTvo81d+ORy07LiP3Y8ZjFeVx6rPtNelxTHkBw/Mpr1amT7xElk2LZJr0eKXG1GA8E/ajSbenZPLbl9IxuUZwrivEud4iuY4XCi8sW3A9RvlTMp3rN+VpStVtCPxIp6jtYXvdtnrY937yPihF58Oyoe6pz01YPl2/K5O2VtRYeLDeCDxhjHkKQES+C5wBPOR+pwBTwvd9wJoxqFdRFEV5NfDjpfDC78dUZHXGQXD61Ttc7oMf/CDXXXcdJ510Epdddhmf+9znuOaaaxgaGmLr1q2sWrWKhQsXsmrVKo4//nj22GOP2PMUcfDBB7Nq1SpKpRLLly/n0ksv5Qc/+AE33HADq1ev5sEHH6RUKrFx40amT5/O1VdfzYoVK5g5c2ZKzpIlS/jkJz/Jxz/+cQBuueUWfvKTn9DR0cEPf/hDpkyZwvr16znmmGM4/fTTufLKK/nDH/7AXXfdRW9vL6tXr45lXX/99YgIv//973nkkUc45ZRTeOyxxwBrVD7wwANUq1UOOuggLrroIubOnVvYR5///OeZPn06zWaTk08+md/97ncsXryYj33sY6xbt45Zs2bxjW98gw996EOsX7+eK664guXLl9Pd3c1VV13F1VdfzWWXXQbAjBkzuP/++3d4nF7JZNeC5K1JSq2JcdeeOGtHsuuSUvJz8sXvxWBIFpJIqv7klnzyvK0ov/3vymlpl9iJaUqW410hU86tN3+NTFI3EupQ5E2I2iZO3ZE3SLLvM4t2Ivlk+s1xm0neOZGctVLpPsyOVbLuySR9HBUXkx5vN81pm/EktWNk3G+k+yxv7VIyLplxcPtEWq+D1FhFYxKlGyePkGyJjjOWjh5xW7N95KSBc2264++2LdO38fXl9EVSp0nlzw5/fp9n9HKvLUfPPMbCwJoDPOscPwccnclzOfBTEbkI6AbekidIRC4ALgDYc889Wbly5Riol8/AwMC4yp/MaNtXTrQaE4K2feVEq7HLmczt7uvro7+/H4BqvYbXbIypfBOYWH473Dxbtmxh06ZNHHnkkfT39/Pnf/7nnHvuufT39/Pf/tt/42c/+xk///nP+Zu/+RuWL1/O4OAgRx99dEs9zz//PJdccglPPvkkIkK9Xqe/v5877riDD33oQ2zfvh2AcrlMf38/xhgGBgaoVqtW9/B4//3354UXXuCxxx5j/fr1TJkyhalTp7J161aWLl3Kr371KzzP4/nnn+fJJ59kaGiIIAhoNpv09/czMDBAEAT09/ezcuVK/vIv/5L+/n7mzJnD3nvvzQMPPMDQ0BAnnnginudRr9c58MADefjhh5k6dWqqTc1mk23bttHf389NN93EsmXLaDQavPDCC9x3333st99+vPe97+Xf/u3fOOecc/jVr37F9ddfz89+9jP++Mc/cuyxxwJQq9V44xvfGLf7He94R9txqtfrbN++vTDP0NBQ6hqPvGOTFrGejJjwbns8CXZD9Px0iJK7fXjLphFR+JVnhcThYOH5OIwqng86k0QnXCu9wD8TXyg2QxRelTtB9ZJJfVw8Cm+LyuXd9c9sQgChpyA8aXfLMymjVLIhY55jfDnhflFC9IBcE4UIOu0zHkjUiCgE0+0rE6aF56IQwUinOGe2T4xpHSsnBNDtYxOVj8MBEwPV+MQhbrZ+K7eoL8EdB5O6jqIwwqxhYq+9tBFi2xG238uR7+aJ9TctDyM2HgSeSa6BVB2mZffAWJ5zrdmHcCf/c20bSfopLu+0L9YpGyIYeatco9GDAJPRK/nkGIk7I5cxWYM1Cs4ClhljvigixwLfFJHDjDGBm8kYcwNwA8DChQvNokWLxk2hlStXMp7yJzPa9kUTrcaEoG1fNNFq7HImc7sffvhhent77cFOeJpGYnt/fyK/DW6eIAgQkTitp6cHz/Po7e3l5JNP5r777uP555/nfe97H9deey2VSoV3vOMdLfVcddVVvPWtb+Xf//3fWb16NYsWLaK3t5dSqURXV1dLfhGhp6cnTnePlyxZwh133MELL7zA+9//fnp7e1m2bBlbtmzhgQceoFwuM2/ePEqlUqyv7/v09vam9M/W7fs+3d3ddHR0pOquVqtUKpUWHaP869ev50tf+hL33HMP06ZN47zzzov77MILL+Sd73wnU6dO5b3vfS/Tpk2js7OTU045he985zstfS8i7Lnnnm3HqVwu09nZWZino6ODBQsWxMeT9YZCjECzEnp4DJkJdYjzLKmUgeSn5bRbChMd46RlPSkxrh0liV7GOZ+VnXhriI2POI+k88Tro6JJbVaH0PjKlk15X4JMG53ws0hGbBQ5k+CU18ox+LI7wbV4uDLEBmRUhYkMJEfvlMCkvtRcPpOvZZvw2Jhw2hIaWPFW6q6xkykby8yOgbP+KKWHIy/1XCfn4smOrckZx5QhE4D4Tj1RurOmzCW+Pty0nOaZ7Dn3+nJvDGT7xunLuFwApmQ7V0zYP15ax8TTlm4bmbQixiK4+XnAjSXYO0xz+TBwC4Ax5m6gA5iJoiiKokwS+vr6mDZtGqtWrQLgm9/8JieddBIAJ5xwAt/61rc44IAD8DyP6dOnc/vtt3P88ce3yNmyZQtz5swB7BqniLe+9a189atfpdGw3rqNGzcC1sgr8tAsWbKE7373u9x6662ceeaZsfw99tiDcrnMihUrePrpp0eUc8IJJ3DzzTcD8Nhjj/HMM89w0EEH7VD/AGzdupXu7m76+vp48cUX+fGPfxyfmz17NrNnz+aKK67g/PPPB+CYY47hrrvu4oknngBg27ZtcWji7krLug7HmMjuspa7+1qU30te0Q5oiHPs1JU8jDa9hsRd14KXqdt31qBIpq5YTjpPeuc1E3p4HI9aLNd9JfJbdItkuHoIiTfLkeGu2Una46yzidf7mERft2/bvZw+j/LHnhi/uE2uMRj3v5s3Pk5kROFvrkcrr7/jlyT/W66tsI7kfHKcPp+zZikzti1ronLbYdK78bl6p/KYTN1F12amj7J1C47uJvW+RTen/qQt7nF2zVZmPVl0zflpPYoYCwPrHuAAEdlPRCrYTSxuy+R5BjgZQERejzWw1o1B3YqiKIqyUwwODrL33nvHr6uvvpobb7yRiy++mPnz5/Pggw/Ga4XmzZuHMYYTTzwRgOOPP56pU6cybdq0FrmXXHIJf/u3f8uCBQtiYwrgIx/5CPvssw/z58/niCOO4Nvf/jYAF1xwAaeeemq8yYXLoYceGof17bXXXgCcffbZ3HvvvRx++OHcdNNNHHzwwYBdz3Tcccdx9NFHc/HFF6fkfOxjHyMIAg4//HCWLFnCsmXL4pDEHeGII45gwYIFHHzwwbz//e/nuOOOS50/++yzmTt3Lq9//esBmDVrFsuWLeOss85i/vz5HHvssTzyyCMj1nPPPfew99578/3vf5+//Mu/5NBDD91hXScjsRfA9dA4xhXORN49l51IuzKSNSqJMYDkGxHJGpX0Kysnu+4nMbxMYZ5W2W4bkhCsbLtj3Z3yaV3S/eUaayn5rr45/evqFRsPmfKmpQ1umYxxFRl+LW112utOzL2kLXn50+PdalS2jEmLQR4Zs6HOTkhlct41FtP929pHpA2vnH5uHYek7XH4ZF7/uJ8Dz9HFy/Q7OePn6B2Hhba0I/+zlftZK2i/rTvTl146LdcjHBfNe4zxDiIipwHXYLdg/7ox5vMi8g/AvcaY28JdBf8V6MF+v1xijPlpO5kLFy404/nMjckcOjPeaNsXTbQaE4K2fdFEq7HLmcztfvjhh+NJ+HjQP8oQwVcjE9n2T3ziEyxYsIAPf/jDu6S+7HW0cuVKFi9efJ8xZuEuUWAHqc6da+Z86pOJe8KdzAHZ7a0hmWdmya6haYkPzIZ75eUztIYouiFghla52XwZvQvz5oSWtZzL09GtywnzK9wifaRpbV6ekcpl2irZML2R2pRpuxvWVogTjmY84nVKqTEpmuA79UBSV2otUcH7Fv2ydYVtyRoX2W3dIdQ7085sSJ9bbwtu3QVtbgkRHOF9JDerWxyqWHSNZ/UJyzz9V5/O/b4ZkzVY4TOtbs+kXea8fwg4LltOURRFUZRXB0cddRTd3d188YtfnGhVJi9iQ4xSmxiE6YRJ8XqYKC1oTUudz0vIm1m2GDxhQrT5gEve7DRvZlxUl9uukQy/PGMnq6PbRmczipQuXs4svUi2ez5PjxEsIJNnHLvyRjIMpPUSaMFL8qa8LNmxy9bv1hWVLchm25Lkz90UwtG5pbCXpMUbUmT0yB4DrWvCiq6RwOnnNkalycr2WuW2dHWOkZw6HsmIHYFdtcmFoiiKoiivYu67776JVuEVQbx4PpMGYbpkQo8y21MDqfdJwRyDLdqhIpXmZM0zErLl4veZNBch3yDJk52nT2EZx6jKq8M4aUXyst6xkfSLCrX1jkX6jKB/u/dZ78hIclL1jdBmp71G7EboRgxSFNM2UjsK8piw7yU6OVKZjOE3cv/l9HORUZuVXUS239vl30njCtTAUhRFURRFaYuIfB3478BLxpjDwrTpwPeAecBq4L3GmE0jCvNMq/fCvZPvkwp/M5jwjrx7O77IMCI9YSy6C+/Ky+bPTv6zXpk8eW5aUZ1ZeSOVi701BcaOWwYwnjUg4kl/ymot0BkSw8M9n/GwpOp1JvQj1WXEIIGkjl1ZUbmsHNcYis95Th1xCF4iL9sG4xie0XsTbXvYZiyiPnT7MtsH8Tn3Gs277uIiaVniSUo/CdJtTew1aenTbPuyemZlt6hvJLd/Iz3yxmJnUANLURRFURSlPcuALwE3OWlLgf80xlwpIkvD48+0lSLGbg/tkp3wRrvDRUVE7G5lRRNjk/kfTXTzDKKiuWKRV6BdOF87j1HUDidcK1detlw2n6tLns4ZfdynTrXsMdDGADTZjvFo376RyrvZ80IX3XJuiJ6rf0ZmuzpGcz4m8gTmuVIdOW3blOfBLDoWkxOimGlbwW58LX3XYhCOLLtFZl77wv5w9ciV0zZON40aWIqiKIqiKG0wxtwpIvMyyWcAi8L3NwIrGdHAImfdjKTP+ybZ4CA6nQ3lc40ocTOGuOuq3BC7wK3LpM+7so174OgcOJPLrMESbZYReWzEgOfkd+W1hDeGZWNdJG0EFK0xc9ve4mnIqattuiMvaNMnRd63PKO2oOoYEyZG/Zs1MnPz58jKM06LdI6M36JN7tq1pcX4da6tIj09IMiM10gGf56sPJ0E0g/qKiC3rHGuZ0dOu/rdhMgbWIAaWIqiKIqiKDvOnsaYteH7F4A98zKJyAXABQD+9Kk5k7iCWVpRGFf2fFZMy0YTzuTW3SiiTZhYku6UNW75nPx5hlHuJD1nsu3qnj3OtiPVtgKZueUzeVva6srNMWjbGUt5Hpxi50amXI4+2f+FZR3yrpM8gya33zPni47bGUZt+1LSedp40EYkKxtpTY+I9c8o1XINtvFGpa5v0sZ8m/DBsXgOlqIoiqK84ujp6ZloFQC45pprGBwcjI9PO+00Nm/evMNyNm/ezL/8y7/Ex2vWrOE973nPWKjIokWLGM9Hp2S5+uqrOeSQQ5g/fz4nn3xy/DDlyYqx8Wi5sy1jzA3GmIXGmIV+b7f1UIUPRcUveJVGkcfLvArz4eRndLI8p2z0nKJs/rx63DokUy5PRm59BfoX6k1aT1eHKD0vb0oHcnRxXlJQd9FYFskp6udsORlFmTwZo+njdvqN1J5seinIl5nXt9m00fRT0bi3XHMj9VPeeJOWUzR+LdeO+774O0E9WIqiKIoygVxzzTWcc845dHV1AXD77bePUCKfyMD6wAc+AMDs2bO59dZbx0zP8aTZbOL7fny8YMEC7r33Xrq6uvjyl7/MJZdcwve+970J1DCXF0VkL2PMWhHZC3hpxBICEq7zMMbe2I/+x2lxuJiEaSY+n0cS6WXiu+uR3Cg5TnM3RYjqDNPcOlrKela2Tc/RR5zzYd7seRHC7blNur2SaUPqf/JWvNb1NrYeJzH2RGQyxt4H8r0ObvooH9TktsE9HimtSM5IZSXbr+22zm+pxJC3diivrrblizw97foOiB/IXJTHM+nw1axcIA5xLWqvm7fdA7Hy8mfJG/e8xxW0QT1YiqIoihLy4IMPcswxxzB//nze/e53s2nTJl566SWOOuooAH77298iIjzzzDMAvO51r0t5nwB+85vfcOyxx7JgwQLe9KY38eijjwLWiPj0pz/NYYcdxvz587nuuuu49tprWbNmDYsXL2bx4sUAzJs3j/Xr17N06VKuv/76WO7ll1/OF77wBQYGBjj55JM58sgjOfzww/nRj34EwNKlS3nyySc57rjjuPjii1m9ejWHHXYYAENDQ5x//vkcfvjhLFiwgBUrVgCwbNky/uzP/oxTTz2VAw44gEsuuWTEPvroRz/KwoULOfTQQ/nsZz8LwM9//nPe9a53xXl+9rOf8e53vxuAn/70pxx77LEceeSRnHnmmQwMDMTt/MxnPsORRx7J97///VQdixcvjg3OY445hueee25EvSaA24Bzw/fnAj8aVanw7rhk/kfvxY/+BzbNt++j45SXIzR+xM0XyfKdc6788ByZNLJ6CIXls56CVvlBWjcvrSvOcapctg+y9fuObhn9WnQO+6LtK8wfGX2FsnLqauk/GUWfFvRrS1kht2x87I5ztk+z10len0vOeGTLOHKS8rTkcfvZHaPcdhW1p0iHlusiKNbZ6deR6kvljz9vJgmHzKk/9zr3ig0t9WApiqIoE8pVv7mKRzY+MqYyX9vzWv7++L/f4XIf/OAHue666zjppJO47LLL+NznPsc111zD0NAQW7duZdWqVSxcuJBVq1Zx/PHHs8cee8SGQMTBBx/MqlWrKJVKLF++nEsvvZQf/OAH3HDDDaxevZoHH3yQUqnExo0bmT59OldffTUrVqxg5syZKTlLlizhk5/8JB//+McBuOWWW/jJT35CR0cHP/zhD5kyZQrr16/nmGOO4fTTT+fKK6/kD3/4A3fddRe9vb2sXr06lnX99dcjIvz+97/nkUce4ZRTTuGxxx4DrFH5wAMPUK1WOeigg7jooouYO3duYR99/vOfZ/r06TSbTU4++WR+97vfsXjxYj72sY+xbt06Zs2axTe+8Q0+9KEPsX79eq644gqWL19Od3c3V111FVdffTWXXXYZADNmzOD+++9vOyZf+9rXePvb3z7qMRwPROQ72A0tZorIc8BngSuBW0Tkw8DTwHtHJ8tOygyCiIn/J2nu0pjIxZA5dtJcTJjoyovutmfrcuUYk053y0V5BJOb19XNOEpJvPYlLC8GEzgeOkeWyTQmlebo36Jb0lH5x5n+K1qfFhs0UZlIdzd71mHi6lOQ1tKnOTrkXQPWS5gdj4LrIfvezefo7p4vaksWcccvd1e97KGJr19Xt7Y6k7lWCuS7nwu3bF7+3H7JKyOZcjmfjWx9krepRw5qYCmKoigKsGXLFjZv3sxJJ50EwLnnnsuZZ54JwJve9Cbuuusu7rzzTi699FLuuOMOjDGccMIJuXLOPfdcHn/8cUSEer0OwPLly7nwwgsplexP7/Tp09vqs2DBAl566SXWrFnDunXrmDZtGnPnzqVer3PppZdy55134nkezz//PC+++GJbWb/85S+56KKLAGsA7rvvvrGBdfLJJ9PX1wfAIYccwtNPP93WwLrlllu44YYbaDQarF27loceeoj58+fzgQ98gG9961ucf/753H333dx0003ccccdPPTQQxx33HEA1Go1jj322FjWkiVL2ur9rW99i3vvvZdf/OIXbfONN8aYswpOnbxDgsTgRSGC8VQ6mdQJBk8MxgllspPVcCLeLgzMkZnkNemNBjOmjJuvVVKkU7bu1oltdL5la2snnEoA47lGSDghz9QXy8ykuG1IyYf8yfmOsJMhZdnxS9KTNsdVOCGceTKiUZDU9ZCUzRt5d2zzzrXKicYhvy3ZcnllR5LvReNrpK0OrgxPDEYklZZtV3SNuddiXt7s5yRPb8lJzxK1pV1d7VADS1EURZlQPvPG9jtb7wz9/f1jKu/EE09k1apVPP3005xxxhlcddVViAjveMc7WvL+/d//PYsXL+aHP/whq1evZtGiRTtd75lnnsmtt97KCy+8EBsjN998M+vWreO+++6jXC4zb948hoaGdrqOarUav/d9n0ajUZj3T3/6E1/4whe45557mDZtGuedd15c9/nnn8873/lOOjo6OPPMMymVShhjeOtb38p3vvOdXHnd3d2FdS1fvpzPf/7z/OIXv0jp+EpGBDw/aGsseZ5da5Q973nRxHXkOrL52qW56SOl5dXfbp1R1AZxJt0pz0zBcYuXrECm20fucbv63PNRWss6uEybsn2QN9nP0ymbnrfurt21UNQOV/ei9Lz6R9KxqKxbV8p4yblG8vo7r65sv41G7/R6vXz5o7kRkVcmklf0vqhMEboGS1EURVGAvr4+pk2bxqpVqwD45je/GXuzTjjhBL71rW9xwAEH4Hke06dP5/bbb+f4449vkbNlyxbmzJkD2DVOEW9961v56le/GhswGzduBKC3t7fQIFyyZAnf/e53ufXWW2Nv2pYtW9hjjz0ol8usWLEi3mGvnZwTTjiBm2++GYDHHnuMZ555hoMOOmiH+gdg69atdHd309fXx4svvsiPf/zj+Nzs2bOZPXs2V1xxBeeffz5g10/dddddPPHEEwBs27Yt9py144EHHuAv//Ivue2229hjjz12WM/JjBeusfE8E75PXslxcj55BeGr6HxrvnZptr5sejBCWmv9+XIMvp/VwWTqz29DlJ53vn278/PF67V2Qp47Jun/ZP7nj1s2/2jORemu7kXtate+9DXl6knqXDo9O675dbbqWdyn6es63U/usZtWPI5510n78cu2Na9/XPmtfUWb/MWfc/VgKYqiKLslg4OD7L333vHxpz71KW688UYuvPBCBgcHee1rX8s3vvENwG7IYIzhxBNPBOD444/nueeeY9q0aS1yL7nkEs4991yuuOKKlIfrIx/5CI899hjz58+nXC7zF3/xF3ziE5/gggsu4NRTT2X27Nnx5hMRhx56KP39/cyZM4e99toLgLPPPpt3vvOdHH744SxcuJCDDz4YsOuZjjvuOI4++mje8Y53xGu3AD72sY/x0Y9+lMMPP5xSqcSyZct2yit0xBFHsGDBAg4++GDmzp0bh/5FnH322axbt47Xv/71AMyaNYtly5Zx1llnMTw8DMAVV1zBgQce2Laeiy++mIGBgdio3Geffbjtttt2WN/JiOcFLWnu3XLPS7wd6XKuB6v47nly1719Wl562vuQpKW9H+TubBidS8sOwveRTJN6755z07LpTo6U1ySbPyvTFLj7EtmJt3C0XrakruR/Ub52HjorZ3ReqSgtSs+2PdsuY/I9a5ERkX8uqyep+oIg6+lJ65onp52nL5KTPXbrLW5fsXcv6ptIVl6deWOQ1d/zaOmTrKx2SNHFN9EsXLjQjOczN1au/P/bu9MYSe7zvuPfp6qvuWf24Ir3IVGyGeugtDoSS/b6DGUkohMbgpRLRogQNkLAhhPHcgQoipwXlg3ZcADBDh3Jlg0nknwTthxZdjQxHESySJmiRFKUVhSPXXJ3ubOzc/VMH1VPXlT1Tk1tdffsTM90787vM2hMd9X/rKquqqfrmt/VaRtXM/X9xLCbMRTq+4lhN2PfjXK/n3zyyUs74XthZWWFqampPSt/lA2z7w888AB333039913377Ul1+O5ufn+Z7v+Z5H3P34vjTgCo294gZ/5a9cPm3idOctyOxEdztVq0i3HfZup8Tly+yVrt8pU73qLCqjyE5P6+p1el63MmO3S9cJFQ3Lv8/bbrp8nji9JsnofT1PJ0227Px1Q53y+tXVka+zaEnKllbUvnzbLw3vBH+ZNPlyutWVr6fomq2s/PTuNx0747Lt6jYPij5vZ5o8fu/PF65vdARLREREdu0Nb3gDExMTfPjDHx52U0aWmVMuRVuG5XeWszv/nZ34oqAgKxugFQ3PjssPy++oF7UnX34UB4UBXz5tPl+/QKSXbtOpqL5ufeum37U33YLFoiAudggKj+4ZccEszKbNjg+DzbKjeOtRmk6eTl2dfPmyerW56MhaJ3+nvm5ty+YrKj/bpu0cESwqL9vHfN/y7ek3rmg65dPkp/FuKcASERGRXXvkkUeG3YSRlz0yAZs7ptkL4rM7eWFmfK+dv27ji8rND+vk3bJzW5AmW0ayA1x0itrWtPl25cvpd+OFfNlhQaATFpRf1I98Wdn6YzIBW+Z99o5/nRM7L0uXD/S4fEc9ME/SFxxr2Tp9cgFkGiSabQ0iNuelpdPl8sAlwIjT4y6XghXS4Idc8JR+zp4SmP2cb1s2X1H5ybS3LcPydRXJlpftY3465dvTb1xnOmXLypebn8a7pQBLRESGIrkeY4BbNDlQRvUSh17MnFLmGqyiozBFtnMEq2j8do5g5dNu5whWYMW3Db/iI1iZ8rZ7ml02z3bb3a+solPI8rLDA3Mit8vSFZ2Wlz+lrN+8zubv5AmD4nnWLV8nRbdpUyRbbqe+ouUjO7xoenfLk69rO0dSe+m2HPdrV/aocDZvOMjoCgVYIiIyBLVajYWFBQ4fPqwgS66Yu7OwsECtVht2U65IYM5EuXnZ8BgjwLu+zw7LDx+GftcxZYdB8XVLg67/StrVK992y+4XTPQLePNpu+WP3S6rq1/w2K2ubqecdj73O5XzSgP9bgH2oAOsbBndyu4VYO3m1NVuDmaAtXaeuQuPwqkpqE5CZRKqU8n/IHNAubUB9QWI2+BRctuSOAKP088xWAClGpSqSfrmKgQhTFwH44eSz/UL0KqDhUn6Sy/b/N/agOZaUldlPCmzvgDLL0BjZbOOyetg6vqkrfXzafuireVhELeg3YD2BrQbeGsd8wjiNjeeegr+3xNJ+6tTSZm1maScuAVRO2lH1Ejqbqwm/bUw6Vun/XEbWutJHa16Ul91GmZvgfHDsHYuab871KahNgszNyXj4zYsPQ8rZ6BZh/Z6Mg3a6xC1kr6Wx9PXWNL/9kZSX1CCsbmk7e10urXqybRurSf9D8J0eqTtjVrQ3uDl3zoJ9T+7NF1obyTpq1PJyz2ZBmEFJo4k/Wg3YGNp89VchaAMlYlkGq6eg7WXks8TR5NpGeTmNXRubZNM0/pCUvfYoaQvUSNZTuIIDt8Bh1+R5KlfgPULsL4I6xchLCfpKxNJ2qiVmWetzc9jczB7a9Ke9Quw+hLf/vRX4NkPJ/Nz+gaYuy2ZJ0GQtGtjCTYuJvPBo2S6TBxJymhvwOKzyTydOJrMx9LY5ny/tCxnXp1p4HGSP2on7Zo4nMyX+vmkT1EzSROUk2nXma+N5WR4bSZZrqJWUl9neapOb/4vj6df2swKuVWH1Zdg7Rx3fPNhuPip9LtUTV+1ze9VqZbM87id9MejZLkrT6Tzz9NbRaX/q5MwfiRpa2s9WSbWzsPqmWSeQZKvMpH0uTaTNs+TPnXaGZSS6dRuwMZyshxM3wAztyTT4MLTybI1eyscuTNZHjvBSGs9Xe7ryf+omUyH6lTSz4WTvPKpv4W1P02/T2Obfb20XFpmvZEuo6SfgxLM3AiH7kjyXHwOlk4l9UaNJE1tNpkHcbz53fV4az9LtWRZm7s1GV9fgGadm0oBp84v89KLz2+uVy+1y9NJFKf/feuy5VFSZ9EjMdM+NNstKuXyZv7O8nHps2X62/mfloGldfvWZbtTx2Xyv1EXJbFMutzydGl8dhmxze9QZzieazNb86TbgY2NjdEKPPLLPaTr5t3t1NRqtS13gbwamEE5jLqOD8xpx8G2g5CioyFXeh3STnYwRzXA2m3ajt0EMNk0+fedYCk/vF8btpunX9u7Hb3Z7nzabpC53WWq1/VY29XvWWBF15wV5et37d2VOpAB1uo3/obXPvaf4LHLx8XlcaLSOBY1KTWXr6jcDTMWg4C2GZNxzGQc0zSjHhgts0un8tYDYzUIaJlRdk9fUEk3tBuBsWFGw5L/bUsOQ5uTeep5es410EzTOjAex4y5sxQEnCuFrFnATBwzE8eUffNQ+LMvJP87i1YITMUxU3FMTNLmuhn1IGA9/V9P2zITR8xGMSHQAtpmbAQlWkGZUtSgTEzZoexOyZPxDYNWOl06bUk2t0bVnZrHBEDLSsQWMh01mYnahOl03TCjERjr6bQYj52aOy3b7H/nf+e9ZaZHDLQsoBGUeGK5SjsoEVnyAqccbxBGzWSaWEgtbnOsWedQHBE4RAZrpTHOVSd5qVSlSUzsTSKMqDyBlyYpN16ivPYMYXudkjuhO+U4JvSkvyUgcGepPMbpcIw6Ibec/xq3NFcpB2XWy1M4MPPs5xhvN2karAUBa2GFZnmSjXCCgIggqmPRBlEQ4kGJOAiJLCSwkFkPmY0CbmhcZGZ9AYAIWKhO8GI4xUk/whoVbn/xCW79xmepRI1Ly28UlFkNp6mXxmiXQyjBofoiExvLuAVsTN7AyvgRZi48TfXxP94MREvJjpx7TDuOiIhpe0ybmCjtd40KQRBSbq9dqs+BpfI4oZUpuxF6a8v4KKjgGKV4s407daOVWHvpMI1wnIq3KXmLMG4Sxg0samDx5oNVHcM6O/FXIAZeLFc5U51hMnZmooixaAPidQDGYqfM5bvnEZvf5dhCAo9oA6tBwEoQUA8rTLcbzMQxIX5pGe8s5xvp/wjjaBTxsnabErAcBCxXpjm9+ggXvUXT24Qky+W4O5NxTMmdltnmi+T71DIjAm5ut3l5s0UZeLZU4rlyidUgYMOMKF1/Vdy5sd3m9laLsdh5tlziVKnERhDQBibjmNc1mhyLkum5ZsbZUshiEHIxDNLrEpL+Bw4ByXUTAWC++X48dqbieMv3vknaVoNSur5ZDQIWwoClMEi+nwYTsXMkipiMY1aDgKV0/QtJvuuiiJe1I8bj5NSt2IyVwFgKQhyoebIeqblTS9c9NU/WxSuBcSEIaZoRpm0P0344RjNd9zXNaGGX2r453ZN+T8TOeLoeNIcyyTwai516YKwESX8m45gJj4mCMq1yjWWcs7RYCENmo4gbSpOMxRXmJmaoBmWqYZlKWKXZ3uDs6hnONRYIPKbqzkQccyhyZtyTZT79Ec0sTH546QzL/iiI4Rak8WiQxqOZYL0ToHfeR43kh7Yod9TmZ5+Fsdkr+o5dCwynZJunCGaPQHWOUJUKbuPeTa8d7uzpfL1+7c+n2Wlw0a0tvdqxnXJ7pR902m55io769Mu3nXlzpW3olz57JKrfPOpXfq/52W969GrDFjuYj/kyt1wzlyv7Uhu7jO9aTi7vTo5wDSTAMrN7gF8l2U//7+7+CwVp3gl8gGS/6svu/s8GUfdOzLdu4teCH6cSrlAKV6lYg5q3GbMWcbhBO9xgNYy5GAashjGNsEUzbBKbU4pLBHGIG1jgxOmfW0wUXNkO2bVpvH+SkdLZkFXTV9Z0lzzpr9+X0reAxc1i2M4vx3H6CjL1pDv5s0e65Gml/2s96ojS1wQezRHGFaJSHbu0Qd/80cDnrgcPk3ZYnPt1J30/M4tH1wGGhQ3gQjKLZ24h2Z1M8kLUc0XpbhDX8KhGGFXB2sSVZSxopuMDiCt4XCXw8ubdfSzGiNP2O27JzwKdYeW4xlhcoxyXaHkS3IVxiapViDCWbJ12eQ0PmhC0MIuSunwcfBIIcA/Bg+SEG988ypDuSqb96/xP+htEY0z7NFNBjeV4nTVWaZdXIGjnej6ZmxAGcQXiMhBA0ICwAW54XMXjMkHQgPDyU4i2zdPWD+BX4i1l7vIMiqmoRtti1oNd9G3EmFu6TI6i3AOHy8BcABy9LGXy411yQXzoxkxc5rBXaRCxZE3Wg82jT2UPqEYBJYcocNqB0zSnZTGOMxOFzMYBk7FRw6A8zgvjr2AhaGFxSLVdpdau8bH6OjcdwAArMKdWavVM0+voUK9rmnpdF9OvTYM4RWoQp+ftNM+VtGE79W1nmvS7vmyQpwhuR9GpcL3afqXTfLvpttuG7ei3zA+i3J2IvdvtUzbtOsAysxD4CPADwCngi2b2kLs/kUlzJ/BzwHe6+6KZDfWx7O3pBZ679dNdxwcETJZnmSjNcKg0w1z1EEfGDlEplVlv1WnE60xWKtTKFUpWIoqNtQ04Oj7HrXPHCAh5ZnGBsytLHJ2c5Ja5GWqlKrHHtCJnrDTGZGWSZhteuLjG2ZU1xqswOx4wWStRCapUgiqHxieolWqUglJyvvlag41WRDuOCQ0OTVYoh0Y5LFMLaxjGSmOVM2vLzFSmuXXmeubGplhprnCxcZEo/UX+4Ycf5o3H3wiAmWEY7bjNcmOFc/WLrDdj2u0KIVVumpnl5rlZZqqTjJfGCSxgubnMYmMRd6cclCkHZQJCljdiltZbLNbXacUt7jg6RhC2KQUlxsIxymGZby2c52++9TytqMUNM2NcN13DadHyBuCUgxJBYNRba6y1V3BiamGNaqnKWDhGtVRlvdnmm+cXOb20RDksM16uMl6uMVGuUStVabZD1htGK4qxoAFBCzDwgOefeY7XfvtdTFQrTFRKjFdCAoO1ZsR6M6IUGtVSyOL6Kk+eO80zF89hOOWwxFR1jNtmj3HHoZcRWpX1BrRjoxIapdBYXm/y0mqDtUaTatkohTGRRzSjVvpq04pa3HH4CG+9/XYOTYzxzQuneezMM7TjiEpYwoHFep3F9TWMEtVgnPHyGEcnaxydGqcVORfWWizVI5ptpxU5RkApCCiFEJRW8HCZM2vnOLV8lqWNFaYrhzhUu45osc4/eM2rmR2r8o2FU5y88DxrrQ0CAsKgxNHJMY5NjxNQZnHVWFhtsxGvsB4vEpoxUZqmEoyxuL7KhfUlmlEbSAITIwTC5L8HlCzkxtlJ7jg6zeQYLK4vcbGxxFJjmeXGEkbIXOVlTJePUC45QdBkqbHKC8sXuVBfYbxaYm68yli5TDuCdgRj5TKT1SQwWVhtsbDaYLW1Qj1epOEbVMIyY0GJZrzOalQHnOsqx7hu7NX4WpNvu/UOxspl6q0m9WaTeqtFvdWg2W7jRMQk361mOyaK4+TMMIwgCChZidBCSkGJwIzz6wucb7zAmXiBscos11fu5GXjN/Dyudu5deZltL3OerzM8nqTi/WI5Y0WrbhBK96g7Q1avkHkbULGCHycWjlgvNYiCFo0mmWW10pUgwlunD3M4fEJnr94gWcXz9OK21TCKrWwyli5Rq1UoxZWCK2CYaxFF1iNzmHmTFdmqS/UeeOrXsOtc9cxXR2j2Y5ZaTR4euEC31o4z+JGgzgKcQ+oBBXGyhVmxsa4dW6aQxMVHj1zksfOfY1G1ODlM3fw9657Oe3WOC8tR9SbMeUQwlIbDxdoBi/SaG/Q2DjEyuo0c7VpbpqdpMkSX134MqdbT2Fxlcn2Yco+x6GxQxwZn+PwxBizYyXGKwHNOKbVblMuGbWKMVYOqJUDKiVYqK/wwvIFlht1Jis1JipVqmGFUlAhiuDC+jqL9Q0OjU1z17EbWH3uBe6++w202oaFG8ThMm2vUwsmKTFBOwpYa0SsNDZ4af0sL62fZSNqEMUxcWyUgwnKTFAJQ8JSm5gG59fWOL+2wuL6Ghc31qg3G4yF00yWZ3nZ1BR3Hhvn2HSVp84u8dUXLhLFcOvcNDfPTRMGJaJ2wIW1iOcWmpxdanPz7DTffv0sU7WQc6tLnK+vEAZOKQjYaDdYWF9mtVnn+qkZXnn0OuYmKlyoL3O+vsLpxQbPLjSI2lXuvuE23njzLZxZW+Cpl57juYXnGZ+s4rSAFm5tSkHIkdoxjo4fxQwaUYNWXMeDFSJbxXHi2FhprnNm7QxPt85TDmrMVg5ztDxFow0bzYiw1KIy1oCgTbsdQrNEhQplqxAYrHORs8Eip71OxAZOzER4hOsq12FBxHp8gdXoAtMTs3u5mR9ZocVMlXofle92tKnfsC1l5K7Z6gwDLhveKavoaFq/8vPXgBVdJ1aUN287+brVn8+bL7Pb9WvZ9N2uf8uPK/qcF7ltubNh0XigME3RuCg3nzvjOvXkx/fTCQ4C2/6R0p3K1rWdoKSTtqiczvBsOVdSbr6OneS7EoM4gvUm4KS7Pw1gZp8A7gWeyKT5N8BH3H0RwN3PDaDeHXvrLW/gJ57+Cd52/G1MV6epBBXa3sbdmanOMFWZIrC9nfA70u3ARs5rc59rpRpHxzd/tTxTOcOrDr1qx82Yq80xV5u7bPixyYLEOUduOsIbb/q2Hdfd8QO37yzffGOeE697y7bS/vBdO6vjShy/YY7jN3zH3ldE+tDZV59IPrxiX6ocGfPz85z4zhPDbsa+m5+f58QbT+w4/4+85vUDask9Aypn++YvznP85lv3vd5RMMoPmD7oDCinZ7t0CyKKgpbtDMvqtaOe37HvlJXdUe+2899v5z5fX9HnbgFBvuxeitraLxDp1Y7s527l9dMJArLBQFGaUo9is+M6ZZWs+MhRJ202z3ZuQkGmbf2uwSo6bbTXjT0uk50OuwnoepWzjXILf3AomE7dgul8Gd1+rMgaRIB1I/B85vMp4M25NK8EMLP/S3Ia4Qfc/X/lCzKz+4H7AY4dO8b8/PwAmlfslugWFh5fYIGFPatjVK2uru7ptB1l6vv8sJsxFAe17we136C+H+S+j7LkGqw0wOp2ylNuB33rzQ42jwhkfwbO79QHXH6UomjY1joLdjgzRw02r6WKM2V1zxMQXJY/m7ebTrqiox/ZsovydSuv6PPW65G2tms77YTcTndaXmjFAXSMXRq3XZ302wk6u6XLBpRFdyIvCno76QK7fFg2z27ubJ4/ErWbcvL5ux3lyqYrOoJ1KUAuCJyyw/odYYX9u8lFCbgTOAHcBPy1mb3a3S9mE7n7g8CDAMePH/e9/AXuIP/Cp76fGHYzhkJ9PzHsZuy7g9pvUN8Pct9HWWDOWJhcgxVSvFMZ5XbsQ+JtD+uVv9vRjaKy9lr+yMgg7iw4DHtxe+9e9fS77qzXnRy72cn1SLu9him7vHX7HvTLm83Xa/nNL9/dvieDNogA6zRwc+bzTemwrFPAF9y9BXzLzL5OEnB9cQD1i4iIiIy8AGc8vdFL2OVX+yjzy3onTZT7tb1b3l4iD7aVryhdp/5e+fuV3xmf70tHUV+vpL5u9Rel61Z3Pt9+2M41aUXD8+N3+ly0YTxPrd8y0C1PfvnptTxl07TisO+pk4MO8gcRYH0RuNPMbicJrN4F5O8Q+MfAu4HfNLMjJKcMPj2AukVERESuGuV+p4lZXHAjiq15inYsuwUo0aXTo7Z3elpRuu3kLUpTVH+/snbazm75tptuJ+0oui7nUv6CIKkomAn71HEl4/ul7VXGdgPwrJ0GodudB9llutvyk/3cLRgtuu4xmza0zTz9AtbtBqS7DrDcvW1mDwCfIZlHH3P3x83sg8DD7v5QOu4HzewJkntI/4y7H7yLn0REROTAMnPKlz3OYWe6XbeSH74fd4vrZdj176Wiu9ttp7+7uYNd9kYag7wTXt/Af0B5YHtHRPP15I9g9Tsq2bGdo1x7YSDXYLn7p4FP54a9P/PegZ9OXyIiIiIHTvYUwZ3Yzg510e2sr2b9AolrOYDbiV53MeyXD/rfJr1bvm52Ewjux+3U98p+3eRCRERE5EALcGq29UHDEUHhhf6FF+ZfySNkdnh0YSTtoi9FN0O40hsrXFV2ejlVr3w7HXclafYi7xApwBIRERHZF375aVFdrq0vCgJ2Ehh0C+D65dltvaPoSvrR6zo3kX4UYImIiIjsA7PLr1vZyXUs3Z531JF9WG65YFgv3R4g3O8Bwfl2dHt473ae5zQqdnqN0XZlbyG+neCv2+3N+92mfDvl9dOvfTsJ5K9lCrBERERE9kGAMxE0gN63qu57UX5RrLObYQPId6nd2XT5PLaZFvrfun0Qut3au+gmCUU3UdjJ3fVkOIKCAC95ZHTcd9igKcASERER2QeGU7bkLoJBl6MHocVdx3Wz3ecBQffbuHcLLnp9zisXBGG9ApRO+qJ8+fy9no9V1Ids2k75nbLy9QVstrFsW9vcq23SW4gTFUTmYbfzYuFS+mzeTvoI25I3P764vLhg/O6PTPYL0BRgiYiIiOyDzk0uIg+6nn4WWnxFp2519DudrRN89DpFsdu4fN5+D4TdUifdA7heZeTr7NW/Xn3IpysMJHPTO19GUUCno1rbUy4Y1i3wyqfP5y3n8ubH5wOpCLuUJz+8V1A2CAqwRERERPZB2SJuCFeG3QyRocpfD7id6wM71/R1S9vt2r5hXfenAEtERERkH1QMbi7t7nqj5OqR4tMIuw0/6OL0dK5e0yabptd03E5Z+bTbTZ/Pq3l59VKAJSIiIrIPQgImg9qwmyEie0wBloiIiEgXZnYz8NvAMZKnVj3o7r9qZoeATwK3Ac8A73T3xV5lnY2q/PKFO/a2wSKyj04WDlWAJSIiItJdG/h37v4lM5sCHjGzzwI/BvyVu/+Cmb0XeC/ws70KeunCNL/xqXv2vMEisl/+onCoAiwRERGRLtz9ReDF9P2KmT0J3AjcC5xIk30cmKdPgFVdaHLHbz63Z20Vkf319S7DFWCJiIiIbIOZ3QbcDXwBOJYGXwBnSE4hLMpzP3A/QI1x2s+f2oeWisgw6fYkIiIiIn2Y2STwB8BPuftydpy7OxQ/WMfdH3T34+5+vEx1H1oqIsOmAEtERESkBzMrkwRXv+vuf5gOPmtm16fjrwfODat9IjJaFGCJiIiIdGFmBnwUeNLdfzkz6iHgPen79wB/st9tE5HRpGuwRERERLr7TuBfAl8xs0fTYf8R+AXgU2Z2H/As8M7hNE9ERo0CLBEREZEu3P1vAOsy+vv2sy0icnXQKYIiIiIiIiIDogBLRERERERkQAYSYJnZPWb2lJmdTJ9m3i3dj5iZm9nxQdQrIiIiIiIySnYdYJlZCHwEeDtwF/BuM7urIN0U8JMkD+cTERERERG55gziCNabgJPu/rS7N4FPAPcWpPt54EPAxgDqFBERERERGTmDuIvgjcDzmc+ngDdnE5jZ64Gb3f3PzOxnuhVkZvcD9wMcO3aM+fn5ATSv2Orq6p6WP8rU9/lhN2Mo1Pf5YTdj3x3UfoP6fpD7LiIybHt+m3YzC4BfBn6sX1p3fxB4EOD48eN+4sSJPWvX/Pw8e1n+KFPfTwy7GUOhvp8YdjP23UHtN6jvB7nvIiLDNohTBE8DN2c+35QO65gCvgOYN7NngLcAD+lGFyIiIiIicq0ZRID1ReBOM7vdzCrAu4CHOiPdfcndj7j7be5+G/B54B3u/vAA6hYRERERERkZuw6w3L0NPAB8BngS+JS7P25mHzSzd+y2fBERERERkavFQK7BcvdPA5/ODXt/l7QnBlGniIiIiIjIqBnIg4ZFREREREREAZaIiIiIiMjAKMASEREREREZEAVYIiIiIiIiA6IAS0REREREZEAUYImIiIiIiAyIAiwREREREZEBUYAlIiIiIiIyIAqwREREREREBkQBloiIiIiIyIAowBIRERERERkQBVgiIiIiIiIDogBLRERERERkQBRgiYiIiIiIDIgCLBERERERkQFRgCUiIiIiIjIgCrBEREREREQGRAGWiIiISBdmVjOzvzWzL5vZ42b2n9Pht5vZF8zspJl90swqw26riIwGBVgiIiIi3TWA73X31wKvA+4xs7cAHwJ+xd1fASwC9w2viSIyShRgiYiIiHThidX0Yzl9OfC9wO+nwz8O/PD+t05ERtFAAiwzu8fMnkoPk7+3YPxPm9kTZvaYmf2Vmd06iHpFRERE9pqZhWb2KHAO+CzwTeCiu7fTJKeAG7vkvd/MHjazh1s09qW9IjJcuw6wzCwEPgK8HbgLeLeZ3ZVL9nfAcXd/DcmvPb+423pFRERE9oO7R+7+OuAm4E3At11B3gfd/bi7Hy9T3asmisgIGcQRrDcBJ939aXdvAp8A7s0mcPfPuXs9/fh5khWUiIiIyFXD3S8CnwP+PjBrZqV01E3A6WG1S0RGS6l/kr5uBJ7PfD4FvLlH+vuAPy8aYWb3A/cDHDt2jPn5+QE0r9jq6uqelj/K1Pf5YTdjKNT3+WE3Y98d1H6D+n6Q+z5oZnYUaLn7RTMbA36A5AYXnwN+lOSH5fcAfzLwykXkqjSIAGvbzOxfAMeB7y4a7+4PAg8CHD9+3E+cOLFnbZmfn2cvyx9l6vuJYTdjKNT3E8Nuxr47qP0G9f0g930PXA98PL0kIgA+5e5/amZPAJ8ws/9CcinER/eichG5+gwiwDoN3Jz5XHiY3My+H3gf8N3urqs8RUREZOS5+2PA3QXDnya5TEJEZItBXIP1ReDO9IF7FeBdwEPZBGZ2N/DfgHe4+7kB1CkiIiIiIjJydh1gpbcofQD4DPAkyaHzx83sg2b2jjTZLwGTwO+Z2aNm9lCX4kRERERERK5aA7kGy90/DXw6N+z9mfffP4h6RERERERERtlAHjQsIiIiIiIiCrBEREREREQGRgGWiIiIiIjIgCjAEhERERERGRAFWCIiIiIiIgOiAEtERERERGRAFGCJiIiIiIgMiAIsERERERGRAVGAJSIiIiIiMiAKsERERERERAZEAZaIiIiIiMiAKMASEREREREZEAVYIiIiIiIiA6IAS0REREREZEAUYImIiIiIiAyIAiwREREREZEBUYAlIiIiIiIyIAqwREREREREBkQBloiIiIiIyIAowBIRERERERmQgQRYZnaPmT1lZifN7L0F46tm9sl0/BfM7LZB1CsiIiIiIjJKdh1gmVkIfAR4O3AX8G4zuyuX7D5g0d1fAfwK8KHd1isiIiIiIjJqBnEE603ASXd/2t2bwCeAe3Np7gU+nr7/feD7zMwGULeIiIiIiMjIKA2gjBuB5zOfTwFv7pbG3dtmtgQcBs5nE5nZ/cD96cdVM3tqAO3r5ki+/gNEfT+Y1PeD56D2G9T3g9z3W4fdiG5WWDz/l/77awx3/gxz+Rj2sqn6Vf+g6y9c3wwiwBoYd38QeHA/6jKzh939+H7UNWrUd/X9oDmofT+o/Qb1/YD3/bZht6Mbdz867PkzzPoPct9V/8GqfxCnCJ4Gbs58vikdVpjGzErADLAwgLpFRERERERGxiACrC8Cd5rZ7WZWAd4FPJRL8xDwnvT9jwL/2919AHWLiIiIiIiMjF2fIpheU/UA8BkgBD7m7o+b2QeBh939IeCjwO+Y2UngAkkQNmz7ciriiFLfDyb1/eA5qP0G9f2guhr6Puw2DrP+g9x31X+A6jcdSBIRERERERmMgTxoWERERERERBRgiYiIiIiIDMyBDLDM7B4ze8rMTprZe4fdnr1kZjeb2efM7Akze9zMfjId/gEzO21mj6avHxp2W/eCmT1jZl9J+/hwOuyQmX3WzL6R/p8bdjsHycxelZmvj5rZspn91LU6z83sY2Z2zsy+mhlWOI8t8V/T7/5jZvb64bV897r0/ZfM7Gtp//7IzGbT4beZ2Xpm/v/60Bo+AF363nUZN7OfS+f7U2b2D4fT6sHo0vdPZvr9jJk9mg6/ZuZ7j+3ZVfF93+99j1HY/g9zGzyMbeEwt0fD3h4Me508cutFdz9QL5IbcXwTuAOoAF8G7hp2u/awv9cDr0/fTwFfB+4CPgD8+2G3bx/6/wxwJDfsF4H3pu/fC3xo2O3cw/6HwBmSB+Fdk/Mc+C7g9cBX+81j4IeAPwcMeAvwhWG3fw/6/oNAKX3/oUzfb8umu9pfXfpeuIyn67wvA1Xg9nQbEA67D4Pse278h4H3X2vzvcf2bOS/78PY9xiF7f+obIP3a1s4zO3RsLcHw14nj9p68SAewXoTcNLdn3b3JvAJ4N4ht2nPuPuL7v6l9P0K8CRw43BbNXT3Ah9P338c+OHhNWXPfR/wTXd/dtgN2Svu/tckdyfN6jaP7wV+2xOfB2bN7Pp9aegeKOq7u/+Fu7fTj58neTbhNafLfO/mXuAT7t5w928BJ0m2BVelXn03MwPeCfzPfW3UPuixPbsavu/7vu8xwtv/YWyD92VbOMzt0bC3B8NeJ4/aevEgBlg3As9nPp9iNFY4e87MbgPuBr6QDnogPWz8sb06RD8CHPgLM3vEzO5Phx1z9xfT92eAY8Np2r54F1tXKAdhnkP3eXzQvv//muQX0o7bzezvzOz/mNnbhtWoPVa0jB+k+f424Ky7fyMz7Jqb77nt2dXwfR9qW4a4/R+VbfAwt4WjsnwOa3swCuvkfV8vHsQA60Ays0ngD4Cfcvdl4NeAlwOvA14kOXR6LXqru78eeDvwb83su7IjPTlWfE0+q8CSB3+/A/i9dNBBmedbXMvzuBczex/QBn43HfQicIu73w38NPA/zGx6WO3bIwdyGc95N1t3JK+5+V6wPbvkoH7fexny9n/o2+BR2hYOa/kc4vZgVNbJ+75ePIgB1mng5sznm9Jh1ywzK5OsXH/X3f8QwN3Punvk7jHwG1zFp8v04u6n0//ngD8i6efZzmH49P+54bVwT70d+JK7n4WDM89T3ebxgfj+m9mPAf8I+OfpBp30VIyF9P0jJOe8v3JojdwDPZbxgzLfS8A/BT7ZGXatzfei7RlXx/d9KG0Z9vZ/RLbBw94WDnX5HOb2YBTWycNaLx7EAOuLwJ1mdnv6q8a7gIeG3KY9k553+lHgSXf/5czw7Hm+/wT4aj7v1c7MJsxsqvOe5GLPr5LM7/ekyd4D/MlwWrjntvxicxDmeUa3efwQ8K8s8RZgKXPqxjXBzO4B/gPwDnevZ4YfNbMwfX8HcCfw9HBauTd6LOMPAe8ys6qZ3U7S97/d7/btg+8HvubupzoDrqX53m17xtXxfd/3fY9hb/9HaBs87G3h0JbPYW8PRmSdPJz1ou/hHTRG9UVy55avk0Ss7xt2e/a4r28lORz9GPBo+voh4HeAr6TDHwKuH3Zb96Dvd5DcpebLwOOdeQ0cBv4K+Abwl8ChYbd1D/o+ASwAM5lh1+Q8J9lwvgi0SM7jvq/bPCa5W9NH0u/+V4Djw27/HvT9JMm57Z3v+6+naX8k/R48CnwJ+MfDbv8e9L3rMg68L53vTwFvH3b7B933dPhvAT+eS3vNzPce27Or4vvOPu979Jhe+7ItYAS2wezztrDLemlfls8ude/b9qBL/fu2Ti6qPx3+WwxhvWhpRSIiIiIiIrJLB/EUQRERERERkT2hAEtERERERGRAFGCJiIiIiIgMiAIsERERERGRAVGAJSIiIiIiMiAKsERERERERAZEAZaIiIiIiMiA/H9Tu16d6K4lmQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 864x576 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def init_model(model):\n",
    "    register_hooks(model)\n",
    "    init_net(model.policy)\n",
    "    \n",
    "agent_args['policy_kwargs'] = {'features_extractor_class': CustomCNN}    \n",
    "agent = solve_env(env_args, agent_args, 1, 1024, [LayerActivationMonitoring()], init_func=init_model)\n",
    "\n",
    "plotting.plot_activations(agent.policy.features_extractor.hooks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We notice now that the variance is better behaved, hovering around 0.6. The proportion of activations that are close to zero is significantly lower at ~65% instead of nearly 90% before. In particular, we can notice that the model is now using the full range of the ReLU activation function. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=norm_comparison></div>\n",
    "\n",
    "## Comparing the models\n",
    "\n",
    "The metrics associated with our model look much better now. But does this translate into better performance? In FastAI example, adding normalization was the most impactful factor in improving the results. To see whether we get similar benefits in our setup, let's solve the more difficult variable variant of \"defend the center\" with different parameters: no normalization, layer normalization and batch normalization. In the plot below, each line is the average of 6 consecutive trials. The coloured region denotes the error mean: $ \\frac{\\sigma}{\\sqrt{n}}$.\n",
    "\n",
    "Unfortunately, although our modified model exhibits nicer telemetry, it seems to have very little impact on the training performance. We will keep the changes nonetheless since we know they help with the fundamentals."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Comparison normalization](figures/comparison_norm.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, here is the final setup to train against the more difficult verion of \"defend the center\". It includes the modified architecture with layer normalization as well as the layer activation monitoring callback that will periodically save to tensorboard. To reach satisfactory results in this more difficult environment, you will need to let the agent train for roughly 500k steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eval num_timesteps=8192, episode_reward=-1.00 +/- 0.00\n",
      "Episode length: 107.00 +/- 24.96\n",
      "New best mean reward!\n",
      "Eval num_timesteps=16384, episode_reward=-1.00 +/- 0.00\n",
      "Episode length: 94.00 +/- 16.63\n",
      "Eval num_timesteps=24576, episode_reward=-0.70 +/- 0.46\n",
      "Episode length: 88.70 +/- 7.28\n",
      "New best mean reward!\n",
      "Eval num_timesteps=32768, episode_reward=-0.70 +/- 0.64\n",
      "Episode length: 91.70 +/- 13.19\n",
      "Eval num_timesteps=40960, episode_reward=0.50 +/- 1.20\n",
      "Episode length: 105.30 +/- 36.72\n",
      "New best mean reward!\n",
      "Eval num_timesteps=49152, episode_reward=1.60 +/- 0.80\n",
      "Episode length: 112.90 +/- 11.49\n",
      "New best mean reward!\n",
      "Eval num_timesteps=57344, episode_reward=8.30 +/- 4.78\n",
      "Episode length: 255.00 +/- 102.23\n",
      "New best mean reward!\n",
      "Eval num_timesteps=65536, episode_reward=3.70 +/- 2.41\n",
      "Episode length: 154.50 +/- 59.59\n",
      "Eval num_timesteps=73728, episode_reward=4.70 +/- 2.53\n",
      "Episode length: 164.20 +/- 45.98\n",
      "Eval num_timesteps=81920, episode_reward=7.40 +/- 5.24\n",
      "Episode length: 212.10 +/- 109.29\n",
      "Eval num_timesteps=90112, episode_reward=21.10 +/- 3.01\n",
      "Episode length: 463.70 +/- 65.06\n",
      "New best mean reward!\n",
      "Eval num_timesteps=98304, episode_reward=16.10 +/- 8.09\n",
      "Episode length: 377.40 +/- 159.12\n",
      "Eval num_timesteps=106496, episode_reward=22.90 +/- 2.59\n",
      "Episode length: 510.60 +/- 32.05\n",
      "New best mean reward!\n",
      "Eval num_timesteps=114688, episode_reward=22.80 +/- 1.08\n",
      "Episode length: 502.20 +/- 38.03\n",
      "Eval num_timesteps=122880, episode_reward=22.40 +/- 1.91\n",
      "Episode length: 489.50 +/- 29.52\n",
      "Eval num_timesteps=131072, episode_reward=23.10 +/- 1.45\n",
      "Episode length: 506.60 +/- 43.25\n",
      "New best mean reward!\n",
      "Eval num_timesteps=139264, episode_reward=20.80 +/- 2.68\n",
      "Episode length: 449.30 +/- 61.72\n",
      "Eval num_timesteps=147456, episode_reward=23.10 +/- 1.45\n",
      "Episode length: 492.70 +/- 32.17\n",
      "Eval num_timesteps=155648, episode_reward=22.70 +/- 1.10\n",
      "Episode length: 492.30 +/- 29.32\n",
      "Eval num_timesteps=163840, episode_reward=24.00 +/- 0.89\n",
      "Episode length: 489.10 +/- 44.19\n",
      "New best mean reward!\n",
      "Eval num_timesteps=172032, episode_reward=23.00 +/- 0.63\n",
      "Episode length: 457.00 +/- 56.27\n",
      "Eval num_timesteps=180224, episode_reward=23.10 +/- 1.45\n",
      "Episode length: 486.70 +/- 47.28\n",
      "Eval num_timesteps=188416, episode_reward=21.90 +/- 1.30\n",
      "Episode length: 478.80 +/- 52.28\n",
      "Eval num_timesteps=196608, episode_reward=23.20 +/- 1.25\n",
      "Episode length: 479.10 +/- 53.99\n",
      "Eval num_timesteps=204800, episode_reward=24.20 +/- 0.75\n",
      "Episode length: 499.60 +/- 45.08\n",
      "New best mean reward!\n",
      "Eval num_timesteps=212992, episode_reward=23.80 +/- 1.47\n",
      "Episode length: 499.50 +/- 44.55\n",
      "Eval num_timesteps=221184, episode_reward=22.70 +/- 1.85\n",
      "Episode length: 458.10 +/- 46.97\n",
      "Eval num_timesteps=229376, episode_reward=22.70 +/- 1.49\n",
      "Episode length: 422.00 +/- 61.13\n",
      "Eval num_timesteps=237568, episode_reward=23.40 +/- 1.50\n",
      "Episode length: 444.30 +/- 66.48\n",
      "Eval num_timesteps=245760, episode_reward=21.70 +/- 2.41\n",
      "Episode length: 438.60 +/- 65.30\n",
      "Eval num_timesteps=253952, episode_reward=23.00 +/- 1.48\n",
      "Episode length: 434.40 +/- 63.06\n",
      "Eval num_timesteps=262144, episode_reward=23.40 +/- 2.29\n",
      "Episode length: 442.10 +/- 85.72\n",
      "Eval num_timesteps=270336, episode_reward=23.10 +/- 1.70\n",
      "Episode length: 487.20 +/- 61.11\n",
      "Eval num_timesteps=278528, episode_reward=22.90 +/- 1.81\n",
      "Episode length: 442.80 +/- 71.75\n",
      "Eval num_timesteps=286720, episode_reward=23.20 +/- 2.23\n",
      "Episode length: 478.10 +/- 71.42\n",
      "Eval num_timesteps=294912, episode_reward=23.20 +/- 1.99\n",
      "Episode length: 470.80 +/- 83.41\n",
      "Eval num_timesteps=303104, episode_reward=22.60 +/- 1.11\n",
      "Episode length: 463.10 +/- 80.52\n"
     ]
    }
   ],
   "source": [
    "env_args = {\n",
    "    'scenario': 'defend_the_center_relaxed', \n",
    "    'frame_skip': 4, \n",
    "    'frame_processor': frame_processor\n",
    "}\n",
    "\n",
    "agent_args = {\n",
    "    'n_epochs': 3,\n",
    "    'n_steps': 4096,\n",
    "    'learning_rate': 1e-4,\n",
    "    'batch_size': 32,\n",
    "    'policy_kwargs': {'features_extractor_class': CustomCNN}\n",
    "}\n",
    "\n",
    "agent = solve_env(env_args, \n",
    "                  agent_args, \n",
    "                  n_envs=2, \n",
    "                  timesteps=300000, \n",
    "                  callbacks=[LayerActivationMonitoring()], \n",
    "                  eval_freq=4096, \n",
    "                  init_func=init_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=part_3></div>\n",
    "\n",
    "# [^](#top) Part 3 - Playing against bots \n",
    "\n",
    "<div id=deathmatch_presentation></div>\n",
    "\n",
    "## Scenario presentation\n",
    "\n",
    "We are now ready to tackle the task of playing Doom deathmatch against programmed bots! To play in deathmatch mode, we need a proper map with items like ammunition, health and respawn points. Using [Slade](https://slade.mancubus.net/index.php?page=about), I created a simple map to train the agent on. It is designed to be easy to navigate through while still requiring some movement to find ennemies. There are 10 spawn points, several ammunition and health items. Players can increase their firepower by picking up one of the four shotguns scattered across the map. The map is contained in the `bots_deathmatch_v1.wad`, next to the corresponding `bots_deathmatch_v1.cfg` scenario config.\n",
    "\n",
    "A game of deatchmatch consists in a session of 2:30 minutes during which 8 bots in addition of our agent will fight against each other in order to get the most frags. A \"frag\" corresponds to an enemy killed. Each player starts with a pistol and a couple of second of invicinbility. As soon as the agent dies, it is respawned at one of the respawn point picked uniformly at random. The actions available are the same as the difficul variant of \"defend the center\". That is, the agent can move, turn and shoot according to the rules we defined earlier. \n",
    "\n",
    "The rewards here will be directly obtained from the frags obtained by the agent: 1 frag = 1 point. Note that in the case of a suicide (which can happen when using rocket launchers for example), the frag count will decrease by one. Conveniently, this will work as a penalty to discourage the agent of ending with such outcomes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Map presentation](figures/flatmap.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=deathmatch_environment></div>\n",
    "\n",
    "## Modified environment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Setting up a deathmatch game requires a slightly different config for VizDoom as we need to tell it to launch a host for the multiplayer game with a couple of multiplayer-specific parameters.\n",
    "\n",
    "We also need to adapt the environment wrapper to handle bots and the deathmatch mechanics. In particular, we need to keep track of the \"frags\" obtained by our agent as this constitutes our reward basis. \n",
    "\n",
    "The cell below shows how we can adapt the environment wrapper developped so far to make it compatible for a deathmatch game. The code is pretty self-explanatory. Notice how we redefine the action space in the constructor using the button combinations. Also, to add and remove bots we use the `send_game_command` from the VizDoom game instance.\n",
    "\n",
    "**Important note: for the following to work, you will need to have the `bots.cfg` file in the same directory as the one used for execution (the notebook in this case). Otherwise, adding bots will have no effect!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gym import spaces\n",
    "from vizdoom.vizdoom import GameVariable\n",
    "\n",
    "class DoomWithBots(envs.DoomEnv):\n",
    "\n",
    "    def __init__(self, game, frame_processor, frame_skip, n_bots):\n",
    "        super().__init__(game, frame_processor, frame_skip)\n",
    "        self.n_bots = n_bots\n",
    "        self.last_frags = 0    \n",
    "        self._reset_bots()\n",
    "        \n",
    "        # Redefine the action space using combinations.\n",
    "        self.possible_actions = get_available_actions(np.array(game.get_available_buttons()))\n",
    "        self.action_space = spaces.Discrete(len(possible_actions))\n",
    "\n",
    "    def step(self, action):\n",
    "        self.game.make_action(self.possible_actions[action], self.frame_skip)\n",
    "       \n",
    "        # Compute rewards.\n",
    "        frags = self.game.get_game_variable(GameVariable.FRAGCOUNT)\n",
    "        reward = frags - self.last_frags\n",
    "        self.last_frags = frags\n",
    "\n",
    "        # Check for episode end.\n",
    "        self._respawn_if_dead()\n",
    "        done = self.game.is_episode_finished()\n",
    "        self.state = self._get_frame(done)\n",
    "\n",
    "        return self.state, reward, done, {}\n",
    "\n",
    "    def reset(self):\n",
    "        self._reset_bots()\n",
    "        self.last_frags = 0\n",
    "\n",
    "        return super().reset()\n",
    "\n",
    "    def _respawn_if_dead(self):\n",
    "        if not self.game.is_episode_finished():\n",
    "            if self.game.is_player_dead():\n",
    "                self.game.respawn_player()\n",
    "                \n",
    "    def _reset_bots(self):\n",
    "        # Make sure you have the bots.cfg file next to the program entry point.\n",
    "        self.game.send_game_command('removebots')\n",
    "        for i in range(self.n_bots):\n",
    "            self.game.send_game_command('addbot')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The other adaptation required is to pass several game arguments via the `add_game_args` function when creating the actual VizDoom game instance. We also redefine the function creating vectorized environments so that it uses the newly defined wrapper. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from stable_baselines3.common.vec_env import VecTransposeImage, DummyVecEnv\n",
    "\n",
    "def env_with_bots(scenario, **kwargs) -> envs.DoomEnv:\n",
    "    # Create a VizDoom instance.\n",
    "    game = vizdoom.DoomGame()\n",
    "    game.load_config(f'scenarios/{scenario}.cfg')\n",
    "    game.add_game_args('-host 1 -deathmatch +viz_nocheat 0 +cl_run 1 +name AGENT +colorset 0' +\n",
    "                       '+sv_forcerespawn 1 +sv_respawnprotect 1 +sv_nocrouch 1 +sv_noexit 1')      # Players can't crouch.\n",
    "    game.init()\n",
    "\n",
    "    return DoomWithBots(game, **kwargs)\n",
    "\n",
    "def vec_env_with_bots(n_envs=1, **kwargs) -> VecTransposeImage:\n",
    "    return VecTransposeImage(DummyVecEnv([lambda: env_with_bots(**kwargs)] * n_envs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And that's it, we have all the elements required to play Doom deathmatch! Let us define one final time the environment and agent arguments and launch the training process using our latest model.\n",
    "\n",
    "Training an agent to play deathmatch is significantly harder than the previous scenarios we have tried so far. We will need to be patient and train for a long time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Built action space of size 18 from buttons [<Button.ATTACK: 0> <Button.MOVE_FORWARD: 13> <Button.MOVE_LEFT: 11>\n",
      " <Button.MOVE_RIGHT: 10> <Button.TURN_RIGHT: 14> <Button.TURN_LEFT: 15>]\n",
      "Built action space of size 18 from buttons [<Button.ATTACK: 0> <Button.MOVE_FORWARD: 13> <Button.MOVE_LEFT: 11>\n",
      " <Button.MOVE_RIGHT: 10> <Button.TURN_RIGHT: 14> <Button.TURN_LEFT: 15>]\n",
      "Built action space of size 18 from buttons [<Button.ATTACK: 0> <Button.MOVE_FORWARD: 13> <Button.MOVE_LEFT: 11>\n",
      " <Button.MOVE_RIGHT: 10> <Button.TURN_RIGHT: 14> <Button.TURN_LEFT: 15>]\n",
      "Built action space of size 18 from buttons [<Button.ATTACK: 0> <Button.MOVE_FORWARD: 13> <Button.MOVE_LEFT: 11>\n",
      " <Button.MOVE_RIGHT: 10> <Button.TURN_RIGHT: 14> <Button.TURN_LEFT: 15>]\n",
      "Built action space of size 18 from buttons [<Button.ATTACK: 0> <Button.MOVE_FORWARD: 13> <Button.MOVE_LEFT: 11>\n",
      " <Button.MOVE_RIGHT: 10> <Button.TURN_RIGHT: 14> <Button.TURN_LEFT: 15>]\n",
      "Eval num_timesteps=65536, episode_reward=0.30 +/- 0.46\n",
      "Episode length: 1257.50 +/- 11.60\n",
      "New best mean reward!\n",
      "Eval num_timesteps=131072, episode_reward=0.30 +/- 0.46\n",
      "Episode length: 1261.40 +/- 5.78\n",
      "Eval num_timesteps=196608, episode_reward=0.10 +/- 0.30\n",
      "Episode length: 1266.40 +/- 11.50\n",
      "Eval num_timesteps=262144, episode_reward=0.50 +/- 0.67\n",
      "Episode length: 1263.20 +/- 17.54\n",
      "New best mean reward!\n",
      "Eval num_timesteps=327680, episode_reward=0.40 +/- 0.49\n",
      "Episode length: 1264.50 +/- 11.59\n",
      "Eval num_timesteps=393216, episode_reward=0.50 +/- 0.92\n",
      "Episode length: 1252.40 +/- 12.31\n",
      "Eval num_timesteps=458752, episode_reward=0.90 +/- 0.70\n",
      "Episode length: 1253.30 +/- 12.44\n",
      "New best mean reward!\n",
      "Eval num_timesteps=524288, episode_reward=0.20 +/- 0.40\n",
      "Episode length: 1253.70 +/- 13.35\n",
      "Eval num_timesteps=589824, episode_reward=0.40 +/- 0.66\n",
      "Episode length: 1257.40 +/- 13.81\n",
      "Eval num_timesteps=655360, episode_reward=1.00 +/- 0.89\n",
      "Episode length: 1257.60 +/- 14.04\n",
      "New best mean reward!\n",
      "Eval num_timesteps=720896, episode_reward=0.50 +/- 0.50\n",
      "Episode length: 1250.30 +/- 15.60\n",
      "Eval num_timesteps=786432, episode_reward=0.50 +/- 0.67\n",
      "Episode length: 1262.00 +/- 15.26\n",
      "Eval num_timesteps=851968, episode_reward=0.70 +/- 0.64\n",
      "Episode length: 1255.10 +/- 18.52\n",
      "Eval num_timesteps=917504, episode_reward=0.60 +/- 0.66\n",
      "Episode length: 1253.70 +/- 14.26\n",
      "Eval num_timesteps=983040, episode_reward=1.10 +/- 0.70\n",
      "Episode length: 1257.00 +/- 10.93\n",
      "New best mean reward!\n",
      "Eval num_timesteps=1048576, episode_reward=0.60 +/- 0.80\n",
      "Episode length: 1260.10 +/- 12.91\n",
      "Eval num_timesteps=1114112, episode_reward=0.50 +/- 0.67\n",
      "Episode length: 1249.00 +/- 15.59\n",
      "Eval num_timesteps=1179648, episode_reward=0.50 +/- 0.50\n",
      "Episode length: 1247.60 +/- 16.48\n",
      "Eval num_timesteps=1245184, episode_reward=0.30 +/- 0.46\n",
      "Episode length: 1249.00 +/- 10.86\n",
      "Eval num_timesteps=1310720, episode_reward=1.10 +/- 1.30\n",
      "Episode length: 1256.90 +/- 11.24\n",
      "Eval num_timesteps=1376256, episode_reward=0.70 +/- 0.90\n",
      "Episode length: 1254.10 +/- 9.33\n",
      "Eval num_timesteps=1441792, episode_reward=1.50 +/- 1.20\n",
      "Episode length: 1258.10 +/- 13.02\n",
      "New best mean reward!\n",
      "Eval num_timesteps=1507328, episode_reward=0.90 +/- 0.83\n",
      "Episode length: 1257.70 +/- 16.12\n",
      "Eval num_timesteps=1572864, episode_reward=1.10 +/- 0.70\n",
      "Episode length: 1261.80 +/- 11.75\n",
      "Eval num_timesteps=1638400, episode_reward=0.90 +/- 1.04\n",
      "Episode length: 1255.10 +/- 10.50\n",
      "Eval num_timesteps=1703936, episode_reward=0.60 +/- 0.80\n",
      "Episode length: 1246.20 +/- 12.46\n",
      "Eval num_timesteps=1769472, episode_reward=1.30 +/- 1.10\n",
      "Episode length: 1256.10 +/- 12.45\n",
      "Eval num_timesteps=1835008, episode_reward=1.60 +/- 1.62\n",
      "Episode length: 1249.80 +/- 9.61\n",
      "New best mean reward!\n",
      "Eval num_timesteps=1900544, episode_reward=1.40 +/- 1.02\n",
      "Episode length: 1258.50 +/- 15.84\n",
      "Eval num_timesteps=1966080, episode_reward=2.10 +/- 0.94\n",
      "Episode length: 1254.70 +/- 13.51\n",
      "New best mean reward!\n",
      "Eval num_timesteps=2031616, episode_reward=1.60 +/- 1.02\n",
      "Episode length: 1251.80 +/- 12.52\n",
      "Eval num_timesteps=2097152, episode_reward=2.70 +/- 1.27\n",
      "Episode length: 1252.60 +/- 11.96\n",
      "New best mean reward!\n",
      "Eval num_timesteps=2162688, episode_reward=1.90 +/- 1.14\n",
      "Episode length: 1253.00 +/- 13.01\n",
      "Eval num_timesteps=2228224, episode_reward=1.90 +/- 1.14\n",
      "Episode length: 1255.30 +/- 10.67\n",
      "Eval num_timesteps=2293760, episode_reward=2.20 +/- 1.33\n",
      "Episode length: 1252.70 +/- 8.01\n",
      "Eval num_timesteps=2359296, episode_reward=2.30 +/- 1.27\n",
      "Episode length: 1262.00 +/- 9.62\n",
      "Eval num_timesteps=2424832, episode_reward=1.60 +/- 1.36\n",
      "Episode length: 1252.70 +/- 12.53\n",
      "Eval num_timesteps=2490368, episode_reward=1.50 +/- 1.43\n",
      "Episode length: 1259.30 +/- 11.29\n",
      "Eval num_timesteps=2555904, episode_reward=3.00 +/- 1.90\n",
      "Episode length: 1255.00 +/- 12.29\n",
      "New best mean reward!\n",
      "Eval num_timesteps=2621440, episode_reward=2.60 +/- 1.50\n",
      "Episode length: 1252.20 +/- 11.53\n",
      "Eval num_timesteps=2686976, episode_reward=2.20 +/- 1.54\n",
      "Episode length: 1258.20 +/- 13.07\n",
      "Eval num_timesteps=2752512, episode_reward=3.90 +/- 1.58\n",
      "Episode length: 1256.80 +/- 8.28\n",
      "New best mean reward!\n",
      "Eval num_timesteps=2818048, episode_reward=2.90 +/- 1.70\n",
      "Episode length: 1250.50 +/- 11.56\n",
      "Eval num_timesteps=2883584, episode_reward=2.30 +/- 1.35\n",
      "Episode length: 1242.40 +/- 14.11\n",
      "Eval num_timesteps=2949120, episode_reward=3.50 +/- 1.36\n",
      "Episode length: 1256.70 +/- 12.78\n",
      "Eval num_timesteps=3014656, episode_reward=2.70 +/- 1.55\n",
      "Episode length: 1248.90 +/- 16.13\n"
     ]
    }
   ],
   "source": [
    "# Define new environment parameters.\n",
    "env_args = {\n",
    "    'scenario': 'deathmatch_simple',\n",
    "    'frame_skip': 4,\n",
    "    'frame_processor': frame_processor,\n",
    "    'n_bots': 8\n",
    "}\n",
    "\n",
    "# Defines new agent parameters.\n",
    "agent_args = {\n",
    "    'n_epochs': 3,\n",
    "    'n_steps': 4096,\n",
    "    'learning_rate': 1e-4,\n",
    "    'batch_size': 32,\n",
    "    'policy_kwargs': {'features_extractor_class': CustomCNN}\n",
    "}\n",
    "\n",
    "# Create environments with bots.\n",
    "env = vec_env_with_bots(4, **env_args)\n",
    "eval_env = vec_env_with_bots(1, **env_args)\n",
    "\n",
    "# Build the agent.\n",
    "agent = ppo.PPO(policies.ActorCriticCnnPolicy, env, tensorboard_log='logs/tensorboard', seed=0, **agent_args)\n",
    "init_model(agent)\n",
    "\n",
    "# Create callbacks.\n",
    "monitoring_callback = LayerActivationMonitoring()\n",
    "\n",
    "eval_callback = EvalCallback(\n",
    "    eval_env, \n",
    "    n_eval_episodes=10, \n",
    "    eval_freq=16384, \n",
    "    log_path=f'logs/evaluations/{env_args[\"scenario\"]}',\n",
    "    best_model_save_path=f'logs/models/{env_args[\"scenario\"]}')\n",
    "\n",
    "# Start the training process.\n",
    "agent.learn(total_timesteps=3000000, tb_log_name=env_args['scenario'], callback=[monitoring_callback, eval_callback])\n",
    "\n",
    "# Cleanup.\n",
    "env.close()\n",
    "eval_env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, how did the agent perform? Plotting the average reward over time depicts a tragic situation: although there seems to be some improvement over time, the performance of our model is really not great. Even after 2 million steps the agent barely reaches 2 frags per match on average. Compare that to the best bot which has around 13 frags at the end of each game and our objective seem still pretty far away."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plotting.plot_evaluation_results('logs/evaluations/deathmatch_simple/evaluations.npz')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=deathmatch_discussion></div>\n",
    "\n",
    "# Discussion\n",
    "\n",
    "So the learning process did not go as smoothly as one could have expected. Why is that?\n",
    "\n",
    "The issue lies in the fact that the rewards are very sparse. In other words, only a few combinations of state and action generate useful signals that our agent can use for learning. Indeed, to obtain a frag, the agent has to perform several steps \"just right\". It has to move and track ennemies, repeatedly shoot them until eventually their health reaches zero.\n",
    "\n",
    "The way to solve this issue is by means of \"reward shaping\". The idea is simple: give small positive reward to action that we believe will help towards our main objective of obtaining frags. For example, we can give rewards proportional to damage inflicted to ennemies or proportional to the ammo and health collected.\n",
    "\n",
    "Another option to help with the learning process is to design some learning curriculum. The idea here is to simplify the task early in the learning process and gradually increase the difficulty. For example, we could reduce the speed and the health of ennemies to make it easier for our agent to obtain positive rewards.\n",
    "\n",
    "We will implement these ideas in the next part of this series to get much better results so stay tuned!"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}