Mountain Car.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Episodic Mountain Car with function appoximation and control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This Notebook is intended to solve the Episodic Mountain car problem using Semi-gradient sarsa and Tile Coding.\n",
    "\n",
    "The description of the problem is given below:\n",
    "\n",
    "\"A car is on a one-dimensional track, positioned between two \"mountains\". The goal is to drive up the mountain on the right; however, the car's engine is not strong enough to scale the mountain in a single pass. Therefore, the only way to succeed is to drive back and forth to build up momentum.\" \n",
    "\n",
    "<img src=\"./assets/car.png\" width=\"380\" />\n",
    "\n",
    "An extensive description and solution of the problem can be seen here [Section 10.1 Reinforment Learning an Introduction](http://www.incompleteideas.net/book/RLbook2018.pdf#page=267)\n",
    "\n",
    "Image and Text taken from Taken from [Official documentaiton Mountain car](https://gym.openai.com/envs/MountainCar-v0/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D  \n",
    "import tiles3 as tc\n",
    "from tqdm import tqdm\n",
    "\n",
    "import gym\n",
    "from gym.wrappers import Monitor\n",
    "from utils import *\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Undestanding the Workflow of OpenAI\n",
    "\n",
    "The following variables are used at each timestep and they are returned by the Mountain Car environment. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- **observation** (object): an environment-specific object representing your observation of the environment. For example, pixel data from a camera, joint angles and joint velocities of a robot, or the board state in a board game.\n",
    "- **reward** (float): amount of reward achieved by the previous action. The scale varies between environments, but the goal is always to increase your total reward.\n",
    "- **done** (boolean): whether it’s time to reset the environment again. Most (but not all) tasks are divided up into well-defined episodes, and done being True indicates the episode has terminated. (For example, perhaps the pole tipped too far, or you lost your last life.)\n",
    "- **info** (dict): diagnostic information useful for debugging. It can sometimes be useful for learning (for example, it might contain the raw probabilities behind the environment’s last state change). However, official evaluations of your agent are not allowed to use this for learning.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a quick recap, the diagram below explains the workflow of a Markov Decision Process (MDP)\n",
    "\n",
    "<img src=\"./assets/MDP.png\" width=\"380\" />\n",
    "\n",
    "Image taken from [Section 3.1 Reinforment Learning an Introduction](http://www.incompleteideas.net/book/RLbook2018.pdf#page=70)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment and Agent specifications\n",
    "\n",
    "Below are presented the main features of the environment and agent. Overall, the action space of the problem is discrete with three posible actions. The observations or state space is continuios, therefore it is necessary to use a function approximation technique to solve this challenge. The agent receives a reward of -1 at each timestep unless it reaches the goal. The episode ends if the agent reaches the goal or a specific number of iterations are done. Additionally, the agent will always start at a random position between $-0.6$ and $-0.4$ with zero velocity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Observation**: \n",
    "\n",
    "     Type:  Box(2)\n",
    "     Num    Observation               Min            Max\n",
    "     0      Car Position              -1.2           0.6\n",
    "     1      Car Velocity              -0.07          0.07\n",
    "         \n",
    "**Actions**:\n",
    "\n",
    "     Type: Discrete(3)\n",
    "     Num    Action\n",
    "     0      Accelerate to the Left\n",
    "     1      Don't accelerate\n",
    "     2      Accelerate to the Right\n",
    "\n",
    "     Note: This does not affect the amount of velocity affected by the gravitational pull acting on the car\n",
    "        \n",
    "**Reward**:\n",
    "\n",
    "     Reward of 0 is awarded if the agent reached the flag(position = 0.5) on top of the mountain\n",
    "     Reward of -1 is awarded if the position of the agent is less than 0.5\n",
    "        \n",
    "**Starting State**:\n",
    "\n",
    "     The position of the car is assigned a uniform random value in [-0.6 , -0.4]\n",
    "     The velocity of the car is always assigned to 0\n",
    "        \n",
    "**Episode Termination**:\n",
    "\n",
    "     The car position is more than 0.5\n",
    "     Episode length is greater than 200\n",
    "     \n",
    "For further information see [Github source code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/mountain_car.py)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next cell aims to show how to iterate with the action and observation space of the agent and extract relevant information from it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Action Space is an object of type: Discrete(3)\n",
      "\n",
      "The shape of the action space is: 3\n",
      "\n",
      "The Environment Space is an object of type: Box(2,)\n",
      "\n",
      "The Shape of the dimension Space are: (2,)\n",
      "\n",
      "The High values in the observation space are [0.6  0.07], the low values are [-1.2  -0.07]\n",
      "\n",
      "The minimum and maximum car's position are: -1.2000000476837158, 0.6000000238418579\n",
      "\n",
      "The minimum and maximum car's velocity are: -0.07000000029802322, 0.07000000029802322\n",
      "\n",
      "The Observations at a given timestep are [-1.0707569  0.0590123]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "env = gym.make(\"MountainCar-v0\")\n",
    "observation = env.reset() \n",
    "\n",
    "# Object's type in the action Space\n",
    "print(\"The Action Space is an object of type: {0}\\n\".format(env.action_space))\n",
    "# Shape of the action Space\n",
    "print(\"The shape of the action space is: {0}\\n\".format(env.action_space.n))\n",
    "# Object's type in the Observation Space\n",
    "print(\"The Environment Space is an object of type: {0}\\n\".format(env.observation_space))\n",
    "# Shape of the observation space\n",
    "print(\"The Shape of the dimension Space are: {0}\\n\".format(env.observation_space.shape))\n",
    "# The high and low values in the observation space\n",
    "print(\"The High values in the observation space are {0}, the low values are {1}\\n\".format(\n",
    "    env.observation_space.high, env.observation_space.low))\n",
    "# Minimum and Maximum car position\n",
    "print(\"The minimum and maximum car's position are: {0}, {1}\\n\".format(\n",
    "    env.observation_space.low[0], env.observation_space.high[0]))\n",
    "# Minimum and Maximum car velocity\n",
    "print(\"The minimum and maximum car's velocity are: {0}, {1}\\n\".format(\n",
    "    env.observation_space.low[1], env.observation_space.high[1]))\n",
    "# Example of observation\n",
    "print(\"The Observations at a given timestep are {0}\\n\".format(env.observation_space.sample()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tile Coding Class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a complete explanation about what is tile coding and how it works, see [Section 9.5.4 of Reinforment Learning an Introduction](http://www.incompleteideas.net/book/RLbook2018.pdf#page=239). Overall, this is a way to create features that can both provide good generalization and discrimination for value function approximation. Tile coding consists of multiple overlapping tiling, where each tiling is a partitioning of the space into tiles.\n",
    "\n",
    "<img src=\"./assets/tilecoding.png\" width=\"640\" />\n",
    "\n",
    "**Note**: Tile coding can be only be used with 2d observation spaces.\n",
    "\n",
    "This technique is implemented using Tiles3, which is a python library written by Richard S. Sutton. For the full documentation see [Tiles3 documentation](http://incompleteideas.net/tiles/tiles3.html)\n",
    "\n",
    "Image taken from [Section 9.5.4 of Reinforment Learning an Introduction](http://www.incompleteideas.net/book/RLbook2018.pdf#page=239)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tile Coding Class\n",
    "class MountainCarTileCoder:\n",
    "    def __init__(self, iht_size=4096, num_tilings=8, num_tiles=8):\n",
    "        \"\"\"\n",
    "        Initializes the MountainCar Tile Coder\n",
    "        Initializers:\n",
    "        iht_size -- int, the size of the index hash table, typically a power of 2\n",
    "        num_tilings -- int, the number of tilings\n",
    "        num_tiles -- int, the number of tiles. Here both the width and height of the\n",
    "                     tile coder are the same\n",
    "        Class Variables:\n",
    "        self.iht -- tc.IHT, the index hash table that the tile coder will use\n",
    "        self.num_tilings -- int, the number of tilings the tile coder will use\n",
    "        self.num_tiles -- int, the number of tiles the tile coder will use\n",
    "        \"\"\"\n",
    "        self.iht = tc.IHT(iht_size)\n",
    "        self.num_tilings = num_tilings\n",
    "        self.num_tiles = num_tiles\n",
    "    \n",
    "    def get_tiles(self, position, velocity):\n",
    "        \"\"\"\n",
    "        Takes in a position and velocity from the mountaincar environment\n",
    "        and returns a numpy array of active tiles.\n",
    "        \n",
    "        Arguments:\n",
    "        position -- float, the position of the agent between -1.2 and 0.5\n",
    "        velocity -- float, the velocity of the agent between -0.07 and 0.07\n",
    "        returns:\n",
    "        tiles - np.array, active tiles\n",
    "        \"\"\"\n",
    "        # Set the max and min of position and velocity to scale the input\n",
    "        # The max position is set to 0.5 as this is the position to end the experiment\n",
    "        POSITION_MIN = -1.2\n",
    "        POSITION_MAX = 0.5\n",
    "        VELOCITY_MIN = -0.07\n",
    "        VELOCITY_MAX = 0.07\n",
    "        \n",
    "        # Scale position and velocity by multiplying the inputs of each by their scale\n",
    "        position_scale = self.num_tiles / (POSITION_MAX - POSITION_MIN)\n",
    "        velocity_scale = self.num_tiles / (VELOCITY_MAX - VELOCITY_MIN)\n",
    "        \n",
    "        # Obtain active tiles for current position and velocity\n",
    "        tiles = tc.tiles(self.iht, self.num_tilings, [position * position_scale, \n",
    "                                                      velocity * velocity_scale])\n",
    "        \n",
    "        return np.array(tiles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Tiles obtained are: [0 1 2 3 4 5 6 7]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Test the TileCoder class\n",
    "mctc = MountainCarTileCoder(iht_size = 1024, num_tilings = 8, num_tiles = 8)\n",
    "tiles = mctc.get_tiles(position = -1.0, velocity = 0.01)\n",
    "# Tiles obtained at a random pos and vel\n",
    "print(\"The Tiles obtained are: {0}\\n\".format(tiles))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementing Sarsa Agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To solve the Mountain Car problem, Value Function approximation and control will be used (Owing to the continuous state space). As a quick recap, Action-values can be computed using value function approximation giving the following equation.\n",
    "\n",
    "\\begin{equation} \n",
    "q_\\pi(s) \\approx \\hat{q}(s, a, w) \\doteq w^T x(s,a)\n",
    "\\end{equation}\n",
    "\n",
    "Where $w$ are a set of weights and $x(s,a)$ are the features vector which are computed using tile coding.\n",
    "\n",
    "Using the Tile coder implemented above it is possible to compute the action-values $\\hat{q}(s, a, w)$ and solve this RL task. \n",
    "\n",
    "The equation to update the weights using the Sarsa algorithm is given below. Here, $\\nabla \\hat{q}(S_t, A_t, w)$ is the gradient of the action-values approximation but as $x(s,a)$ is a linear function, the gradient is one only for the active features.\n",
    "\n",
    "\\begin{equation} \n",
    "w \\leftarrow w + \\alpha[R_{t+1} + \\gamma \\hat{q}(S_{t+1}, A_{t+1}, w)- \\hat{q}(S_t, A_t, w)]\\nabla \\hat{q}(S_t, A_t, w)\n",
    "\\end{equation}\n",
    "\n",
    "Additionally, the update \"Target\" is composed of the following terms:\n",
    "\n",
    "\\begin{equation} \n",
    "\\delta \\leftarrow R_{t+1} + \\gamma \\hat{q}(S_{t+1}, A_{t+1}, w)\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation} \n",
    "w \\leftarrow w + \\alpha[\\delta - \\hat{q}(S_t, A_t, w)]\\nabla \\hat{q}(S_t, A_t, w)\n",
    "\\end{equation}\n",
    "\n",
    "The Pseudo-code implementation of this algorithm is given below.\n",
    "\n",
    "<img src=\"./assets/pseudocode.png\" width=\"480\" />\n",
    "\n",
    "\n",
    "For further details, see [Section 9.5.4 of Reinforment Learning an Introduction](http://www.incompleteideas.net/book/RLbook2018.pdf#page=266). Image taken from the last reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SARSA\n",
    "class SarsaAgent():\n",
    "    \"\"\"\n",
    "    Initialization of Sarsa Agent. All values are set to None so they can\n",
    "    be initialized in the agent_init method.\n",
    "    \"\"\"\n",
    "    def __init__(self, agent_info={}):\n",
    "        \"\"\"Setup for the agent called when the experiment first starts.\"\"\"\n",
    "        self.last_action = None\n",
    "        self.last_state = None\n",
    "        self.epsilon = None\n",
    "        self.gamma = None\n",
    "        self.iht_size = None\n",
    "        self.w = None\n",
    "        self.alpha = None\n",
    "        self.num_tilings = None\n",
    "        self.num_tiles = None\n",
    "        self.mctc = None\n",
    "        self.initial_weights = None\n",
    "        self.num_actions = None\n",
    "        self.previous_tiles = None\n",
    "\n",
    "    def agent_init(self, agent_info={}):\n",
    "        \"\"\"Setup for the agent called when the experiment first starts.\"\"\"\n",
    "        self.num_tilings = agent_info.get(\"num_tilings\", 8)\n",
    "        self.num_tiles = agent_info.get(\"num_tiles\", 8)\n",
    "        self.iht_size = agent_info.get(\"iht_size\", 4096)\n",
    "        self.epsilon = agent_info.get(\"epsilon\", 0.0)\n",
    "        self.gamma = agent_info.get(\"gamma\", 1.0)\n",
    "        self.alpha = agent_info.get(\"alpha\", 0.5) / self.num_tilings\n",
    "        self.initial_weights = agent_info.get(\"initial_weights\", 0.0)\n",
    "        self.num_actions = agent_info.get(\"num_actions\", 3)\n",
    "        \n",
    "        # Initialize self.w to three times the iht_size. Recall this is because\n",
    "        # we need to have one set of weights for each action (Stacked values).\n",
    "        self.w = np.ones((self.num_actions, self.iht_size)) * self.initial_weights\n",
    "        \n",
    "        # Initialize self.mctc to the mountaincar verions of the  tile coder created\n",
    "        self.mctc = MountainCarTileCoder(iht_size = self.iht_size, \n",
    "                                         num_tilings = self.num_tilings, \n",
    "                                         num_tiles = self.num_tiles)\n",
    "\n",
    "    def select_action(self, tiles):\n",
    "        \"\"\"\n",
    "        Selects an action using epsilon greedy\n",
    "        Args:\n",
    "        tiles - np.array, an array of active tiles\n",
    "        Returns:\n",
    "        (chosen_action, action_value) - (int, float), tuple of the chosen action\n",
    "                                        and it's value\n",
    "        \"\"\"\n",
    "        action_values = []\n",
    "        chosen_action = None\n",
    "        \n",
    "        # Obtain action values for all actions (sum through rows)\n",
    "        action_values = np.sum(self.w[:, tiles], axis = 1)\n",
    "        \n",
    "        # Epsilon Greedy action selecion\n",
    "        if np.random.random() < self.epsilon:\n",
    "            # Select random action among the three posible actions\n",
    "            chosen_action = np.random.randint(self.num_actions)\n",
    "        else:\n",
    "            # Select the greedy action\n",
    "            chosen_action = argmax(action_values)\n",
    "        \n",
    "        return chosen_action, action_values[chosen_action]\n",
    "    \n",
    "    def agent_start(self, state):\n",
    "        \"\"\"The first method called when the experiment starts, called after\n",
    "        the environment starts.\n",
    "        Args:\n",
    "            state (Numpy array): the state observation from the\n",
    "                environment's env.reset() function.\n",
    "        Returns:\n",
    "            The first action the agent takes.\n",
    "        \"\"\"\n",
    "        # Current state\n",
    "        position, velocity = state\n",
    "        \n",
    "        # Obtain tiles activated at state cero\n",
    "        active_tiles = self.mctc.get_tiles(position = position, velocity = velocity)\n",
    "        # Select an action and obtain action values of the state\n",
    "        current_action, action_value = self.select_action(active_tiles)\n",
    "        \n",
    "        # Save action as last action\n",
    "        self.last_action = current_action\n",
    "        # Save tiles as previous tiles\n",
    "        self.previous_tiles = np.copy(active_tiles)\n",
    "        \n",
    "        return self.last_action\n",
    "\n",
    "    def agent_step(self, reward, state):\n",
    "        \"\"\"A step taken by the agent.\n",
    "        Args:\n",
    "            reward (float): the reward received for taking the last action taken\n",
    "            state (Numpy array): the state observation from the\n",
    "                environment's step based, where the agent ended up after the\n",
    "                last step\n",
    "        Returns:\n",
    "            The action the agent is taking.\n",
    "        \"\"\"\n",
    "        # Current state\n",
    "        position, velocity = state\n",
    "\n",
    "        # Compute current tiles\n",
    "        active_tiles = self.mctc.get_tiles(position = position, velocity = velocity)\n",
    "        # Obtain new action and action value before updating actition values\n",
    "        current_action, action_value = self.select_action(active_tiles)\n",
    "        \n",
    "        # Update the Sarsa Target (delta)\n",
    "        target = reward + (self.gamma * action_value)\n",
    "        \n",
    "        # Compute last action values to update weights\n",
    "        last_action_val = np.sum(self.w[self.last_action][self.previous_tiles]) \n",
    "        \n",
    "        # As we are using tile coding, which is a variant of linear function approximation\n",
    "        # The gradient of the active tiles are one, otherwise cero.\n",
    "        grad = 1\n",
    "        self.w[self.last_action][self.previous_tiles] = self.w[self.last_action][self.previous_tiles] + \\\n",
    "            self.alpha * (target - last_action_val) * grad\n",
    "                \n",
    "        self.last_action = current_action\n",
    "        self.previous_tiles = np.copy(active_tiles)\n",
    "        return self.last_action\n",
    "\n",
    "    def agent_end(self, reward):\n",
    "        \"\"\"Run when the agent terminates.\n",
    "        Args:\n",
    "            reward (float): the reward the agent received for entering the\n",
    "                terminal state.\n",
    "        \"\"\"\n",
    "\n",
    "        # There is no action_value used here because this is the end\n",
    "        # of the episode.\n",
    "        \n",
    "        # Compute delta\n",
    "        target = reward \n",
    "        # Compute last action value\n",
    "        last_action_val = np.sum(self.w[self.last_action][self.previous_tiles])\n",
    "        grad = 1\n",
    "        # Update weights\n",
    "        self.w[self.last_action][self.previous_tiles] = self.w[self.last_action][self.previous_tiles] + \\\n",
    "            self.alpha * (target - last_action_val) * grad\n",
    "        \n",
    "    def return_action_value(self, state):\n",
    "        \"\"\"Run to obtain action-values for a given state.\n",
    "        Args:\n",
    "            state (Numpy array): the state observation\n",
    "        Returns:\n",
    "            The max action-value \n",
    "        \"\"\"\n",
    "        \n",
    "        # Current state\n",
    "        position, velocity = state\n",
    "        \n",
    "        # Obtain tiles activated at state cero\n",
    "        active_tiles = self.mctc.get_tiles(position = position, velocity = velocity)\n",
    "        # Obtain action values for all actions (sum through rows)\n",
    "        action_values = np.sum(self.w[:, active_tiles], axis = 1)\n",
    "        # Obtain max action value\n",
    "        max_action_value = np.max(action_values)\n",
    "        \n",
    "        return max_action_value\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running the experiment\n",
    "\n",
    "The following lines solves the Mountain Car problem and plot the average reward obtained over episodes and steps taken to solve the challenge at a specific episode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10/10 [00:47<00:00,  4.74s/it]\n"
     ]
    }
   ],
   "source": [
    "# Test Sarsa Agent \n",
    "num_runs = 10\n",
    "num_episodes = 100\n",
    "agent_info_options = {\"num_tilings\": 8, \"num_tiles\": 8, \"iht_size\": 4096,\n",
    "                      \"epsilon\": 0.0, \"gamma\": 1.0, \"alpha\": 0.5,\n",
    "                      \"initial_weights\": 0.0, \"num_actions\": 3}\n",
    "\n",
    "# Variable to store the amount of steps taken to solve the challeng\n",
    "all_steps = []\n",
    "# Variable to save the rewards in an episode\n",
    "all_rewards = []\n",
    "\n",
    "# Agent\n",
    "agent = SarsaAgent(agent_info_options)\n",
    "\n",
    "# Environment\n",
    "env = gym.make('MountainCar-v0')\n",
    "env.reset()\n",
    "# Maximum number of possible iterations (default was 200)\n",
    "env._max_episode_steps = 10000\n",
    "\n",
    "# Number of runs are the times the experiment will start again (a.k.a episode)\n",
    "for n_runs in tqdm(range(num_runs)):\n",
    "    \n",
    "    # Resets environment\n",
    "    observation = env.reset()\n",
    "    # Reset agent\n",
    "    agent.agent_init(agent_info_options)\n",
    "    # Generate last state and action in the agent\n",
    "    last_action = agent.agent_start(observation)\n",
    "    # Steps taken at each episode to solve the challenge\n",
    "    steps_per_episode = []\n",
    "    rewards_per_episode = []\n",
    "        \n",
    "    # Times the environment will start again without resetting the agent\n",
    "    for t in range(num_episodes):\n",
    "        # Store number of steps taken to solve experiment\n",
    "        n_steps = 0\n",
    "        rewards = 0\n",
    "        # Reset done flag\n",
    "        done = False\n",
    "        # Reset environment\n",
    "        observation = env.reset()\n",
    "        # Run until the experiment is over\n",
    "        while not done:\n",
    "\n",
    "            # Take a step with the environment\n",
    "            observation, reward, done, info = env.step(last_action)\n",
    "            \n",
    "            # Number of steps the agent take to solve the challenge\n",
    "            n_steps += 1\n",
    "            # Accumulate reward\n",
    "            rewards += reward\n",
    "\n",
    "            # If the goal has been reached stop\n",
    "            if done:\n",
    "                # Last step with the agent\n",
    "                agent.agent_end(reward)\n",
    "                \n",
    "            else:\n",
    "                # Take a step with the agent\n",
    "                last_action = agent.agent_step(reward, observation)\n",
    "                \n",
    "        # Save the amount of steps needed to complete the experiment \n",
    "        # Without rebooting the agent\n",
    "        steps_per_episode.append(n_steps)\n",
    "        # Save the amount of award obtained at each episode\n",
    "        rewards_per_episode.append(rewards)\n",
    "        \n",
    "    # Save the list of steeps needed to finish the experiment \n",
    "    # in all the Episodes\n",
    "    all_steps.append(np.array(steps_per_episode))\n",
    "    # Awards obtained in every episode\n",
    "    all_rewards.append(np.array(rewards_per_episode))\n",
    "\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Minimum number of iterations used to solve the experiment were: 3847\n",
      "\n",
      "The Maximum number of iterations used to solve the experiment were: 144\n",
      "\n"
     ]
    }
   ],
   "source": [
    "steps_average = np.mean(np.array(all_steps), axis=0)\n",
    "plt.plot(steps_average, label = 'Steps')\n",
    "plt.xlabel(\"Episodes\")\n",
    "plt.ylabel(\"Iterations\",rotation=0, labelpad=40)\n",
    "plt.xlim(-0.2, num_episodes)\n",
    "plt.ylim(steps_average.min(), steps_average.max())\n",
    "plt.title(\"Average iterations to solve the experiment over runs\")\n",
    "plt.legend()\n",
    "plt.show()\n",
    "print(\"The Minimum number of iterations used to solve the experiment were: {0}\\n\".format(np.array(all_steps).max()))\n",
    "print(\"The Maximum number of iterations used to solve the experiment were: {0}\\n\".format(np.array(all_steps).min()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best reward obtained solving the experiment was: -144.0\n",
      "\n",
      "The Wordt reward obtained solving the experiment was: -3847.0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "rewards_average = np.mean(all_rewards, axis=0)\n",
    "plt.plot(rewards_average, label = 'Average Reward')\n",
    "plt.xlabel(\"Episodes\")\n",
    "plt.ylabel(\"Sum of\\n rewards\\n during\\n episode\" ,rotation=0, labelpad=40)\n",
    "plt.xlim(-0.2, num_episodes)\n",
    "plt.ylim(rewards_average.min(), rewards_average.max())\n",
    "plt.title(\"Average iterations to solve the experiment over runs\")\n",
    "plt.legend()\n",
    "plt.show()\n",
    "print(\"The best reward obtained solving the experiment was: {0}\\n\".format(np.array(all_rewards).max()))\n",
    "print(\"The Wordt reward obtained solving the experiment was: {0}\\n\".format(np.array(all_rewards).min()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using the last trained Agent \n",
    "\n",
    "This lines shows in a video the performance of the last trained agent and save a video with the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/1 [00:00<?, ?it/s]\n",
      "  0%|          | 0/1000 [00:00<?, ?it/s]\u001b[A\n",
      "  1%|▏         | 13/1000 [00:00<00:07, 124.86it/s]\u001b[A\n",
      "  3%|▎         | 26/1000 [00:00<00:07, 123.89it/s]\u001b[A\n",
      "  4%|▍         | 39/1000 [00:00<00:07, 123.81it/s]\u001b[A\n",
      "  5%|▌         | 52/1000 [00:00<00:07, 123.93it/s]\u001b[A\n",
      "  6%|▋         | 65/1000 [00:00<00:07, 123.64it/s]\u001b[A\n",
      "  8%|▊         | 79/1000 [00:00<00:07, 126.19it/s]\u001b[A\n",
      "  9%|▉         | 92/1000 [00:00<00:07, 127.29it/s]\u001b[A\n",
      " 10%|█         | 105/1000 [00:00<00:07, 126.48it/s]\u001b[A\n",
      " 12%|█▏        | 119/1000 [00:00<00:06, 128.02it/s]\u001b[A\n",
      " 13%|█▎        | 132/1000 [00:01<00:06, 128.56it/s]\u001b[A\n",
      " 14%|█▍        | 145/1000 [00:01<00:06, 127.71it/s]\u001b[A\n",
      " 16%|█▌        | 158/1000 [00:01<00:06, 126.67it/s]\u001b[A\n",
      " 17%|█▋        | 171/1000 [00:01<00:06, 125.91it/s]\u001b[A\n",
      " 18%|█▊        | 184/1000 [00:01<00:06, 125.88it/s]\u001b[A\n",
      " 20%|█▉        | 197/1000 [00:01<00:06, 124.24it/s]\u001b[A\n",
      " 22%|██▏       | 221/1000 [00:01<00:06, 125.14it/s]\u001b[A\n",
      "100%|██████████| 1/1 [00:02<00:00,  2.15s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode finished after 222 timesteps\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Test Sarsa Agent \n",
    "num_runs = 1\n",
    "num_episodes = 1000\n",
    "\n",
    "# Environment\n",
    "env_to_wrap = gym.make('MountainCar-v0')\n",
    "# Maximum number of possible iterations (default was 200)\n",
    "env_to_wrap._max_episode_steps = 1500\n",
    "env = Monitor(env_to_wrap, \"./videos/mountainCar\", video_callable=lambda episode_id: True, force=True)\n",
    "\n",
    "\n",
    "# Number of runs are the times the experiment will start again (a.k.a episode)\n",
    "for n_runs in tqdm(range(num_runs)):\n",
    "    \n",
    "    # Resets environment\n",
    "    observation = env.reset()\n",
    "    # Generate last state and action in the agent\n",
    "    last_action = agent.agent_start(observation)\n",
    "        \n",
    "    # Times the environment will start again without resetting the agent\n",
    "    for t in tqdm(range(num_episodes)):\n",
    "\n",
    "        # View environment\n",
    "        env.render()\n",
    "\n",
    "        # Take a step with the environment\n",
    "        observation, reward, done, info = env.step(last_action)\n",
    "\n",
    "        # If the goal has been reached stop\n",
    "        if done:\n",
    "            # Last step with the agent\n",
    "            agent.agent_end(reward)\n",
    "            break\n",
    "\n",
    "        else:\n",
    "            # Take a step with the agent\n",
    "            last_action = agent.agent_step(reward, observation)\n",
    "\n",
    "\n",
    "env.close()\n",
    "env_to_wrap.close()\n",
    "\n",
    "print(\"Episode finished after {} timesteps\".format(t+1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting the Action-Values of the agent\n",
    "\n",
    "This final plot aims to show the action-values learned by the agent with Sarsa. The action value for a given state was calculated using: -$max_a\\hat{q}(s, a, w)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Resolution\n",
    "values = 500\n",
    "# Vector of positions\n",
    "pos_vals = np.linspace(-1.2, 0.5, num = values)\n",
    "# Vector of velocities\n",
    "vel_vals = np.linspace(-0.07, 0.07, num = values)\n",
    "\n",
    "# Z grid values\n",
    "av_grid = np.zeros((values, values))\n",
    "\n",
    "# Compute Action-values for each pos - vel pair\n",
    "for ix in range(len(pos_vals)):\n",
    "    for iy in range(len(vel_vals)):\n",
    "        av_grid[ix][iy] = -1 * agent.return_action_value([pos_vals[ix], vel_vals[iy]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEZCAYAAADCJLEQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOy9aZBkZ3Utur6c56zMGjKruqbuqq6eu6sHSUYP28STH5cLNtgBF/CV7+M6zLPx8C4RYGzsMH7G5sri4sezDQbbgI2MIsAKSyCDZZAtC4PUElarW90t1Vxd85hVOc/D+d6PrP31yawcTg6VXdV9VkSF1FWZZ8z81tl7r70245xDhQoVKlSo2G/Q3OkDUKFChQoVKkpBJSgVKlSoULEvoRKUChUqVKjYl1AJSoUKFSpU7EuoBKVChQoVKvYlVIJSoUKFChX7EipBqVBRAoyxTzHGthhj6y3e718yxj6xB9v9A8bY483ebrPBGHsLY2z5Th+Hiv0BlaBUFIAx9l8ZY1cYY1HG2Bpj7J8ZY29ucJvzjLGfqvKa7zPGPtjIfpoFxlg/gI8COMk59+7hfv47Y+wF+e845x/inP/RXu1ThYqDBJWgVAgwxj4C4E8BPALAA6AfwBcAvOtOHtcdQD+Abc755p0+kP0OxpjuTh+DirsXKkGpAAAwxpwA/hDAr3POn+KcxzjnGc75tznnH9t5jZEx9qeMsdWdnz9ljBl3/tbBGPsOYyzIGPMzxn7IGNMwxr6G/IL/7Z2o7LdK7Pt/AvhxAJ/fec3nd37/IGPsFcZYaOe/D1Y5h/+TMbbAGNtmjH1CHrlVOvaibfwUgH8B0LNzLF8tlXYq2vYfMMaeYIz9HWMswhh7gzF2SfbaPsbYU4wx386xfZ4xdgLAXwJ4085+gjuv/Spj7FOy9/5fjLGZnWv6j4yxHtnfOGPsQ4yx6Z3r/heMMVbpGsne+2OMscs777vOGHuL7G+/yBgb3zmXW4yxX5H97S2MsWXG2G/vpD//VsH59zDGntw5/znG2P+Q/c28c84BxtgYgPuUHL+KewScc/VH/QGAtwHIAtBVeM0fAngZQBeATgCXAfzRzt/+GPkFV7/z8+MA2M7f5gH8VJX9fx/AB2X/dgMIAPhvAHQAfn7n3+1l3n8SQBTAmwEYAPwJgAztt9Kxl9jWWwAsl/t38TkB+AMASQBvB6DduRYv7/xNC+A6gP8PgBWACcCbd/723wG8ULTdrwL41M7//+8AtgBcAGAE8DkAP5C9lgP4DoA25B8CfADeVuac/gDA4zv/fwjA9s7xagD8Hzv/7tz5+zsADAFgAH4SQBzABdm1yAL49M4xmaucvwbAqwB+f+e+HAFwC8B/2vn7owB+uHO/+wC8Xnyt1Z9790eNoFQQ2gFscc6zFV7zMIA/5Jxvcs59AD6JPIEAeTLoBjDA85HXDznnjRg9vgPANOf8a5zzLOf86wAmAPxMmde/B8C3OecvcM7TyC+I8v1XOvZm4AXO+TOc8xyArwE4t/P7+wH0APgYz0elSc75C2W3UoiHAfwN5/wq5zwF4HeQj7gGZa95lHMe5JwvAngewKiC7f4CgGd2jlfinP8LgCvIEww45//EOZ/lefw7gGeRf+AgSAD+H855inOeqHL+9yFPfH/IOU9zzm8B+BKA9+/8/b0A/ifn3M85XwLw5wqvjYp7ACpBqSBsA+ioUlPoAbAg+/fCzu8A4DMAZgA8u5MW+ni5jewo1aI7P7+rcF+0v0M724jKfvp3Xr9EL+Scx3fOScmxNwNytV8cgGnnWvYBWKhC/OVQcMyc8yjy53Sown5tCrY7AOC/7KT3gjvpxTcj/4ABxth/Zoy9vJNWDCJPXB2y9/s458mibZY7/wHk06Xyff0u8jVOOscl2XuL77mKexgqQakgvAQgBeBnK7xmFfkFh9C/8ztwziOc849yzo8AeCeAjzDGHtp5XUEkxfNKNdvOzyOlXlNiX7S/lZ1t2GQ/iwDWAPTSCxljZuSjwqrHrgAxABbZtrXIpwmVYAlAfxnirxZhFhwzY8yK/DmtKNx3pWP6Gue8TfZj5Zw/ulOXexL5FKmHc94G4Bnk031Kj7t4X3NF+7Jzzt++8/c15Emc0F//aam426ASlAoAAOc8hHxa7C8YYz/LGLMwxvQ7T9P/a+dlXwfwe4yxTsZYx87rHwcAxthPM8aGd4r0IQA55FNBALCBfO2hEopf8wyAEZaXvesYY+9Dvs70nTLv/wcAP7MjrDAgXxeRL6plj10BppCPCN7BGNMD+D3k6y9K8B/IL8KPMsasjDETY+x/2/nbBoDeneMtha8D+EXG2OgOcTwC4Eec83mF+y6Hx5G/Vv+JMabdOaa3MMZ6ka8TGZGvZ2UZY/8ZwFsb2Nd/AIjsiCrMO/s7zRgjMcQTAH6HMeba2f//3cC+VNxlUAlKhQDn/P8F8BHkF2Af8k+/vwHgWzsv+RTytYobAG4CuLrzOwA4CuBfkRcqvATgC5zz53f+9sfIk0OQMfabZXb/ZwDes6Pm+nPO+TaAn0a+H2kbwG8B+GnO+VaZY38D+cXtG8gTQhTAJvJRYbVjr3ZdQgB+DcCXkY9eYgAUNZPu1GR+BsAwgMWd971v58//BuANAOuMsV3nxTn/VwCfQD6iWUNeuPD+4tfVip1az7uQT7XRff4YAA3nPALgfyBPHAEA/xXAPzawrxzy93EUwBzyoo8vA3DuvOSTyKf15pCvdX2t3n2puPtAKisVKu4qMMZsAIIAjnLO5+708ahQoaJ2qBGUirsGjLGf2UlNWpGvodxEXg6uQoWKAwiVoFTcTXgX8sKCVeRTju9vUOquQoWKOwg1xadChQoVKvYl1AhKhQoVKlTsS6gEpUKFChUq9iVUglKhQoUKFfsSKkGpUKFChYp9CZWgVKhQoULFvkS1YWOqxE+FChUqVOw1Ss4xUyMoFSpUqFCxL6ESlAoVKlSo2JdQCUqFChUqVOxLqASl4sCCxkKrUKHi7kQ1kYQKFfsSkiQhHo8DAHQ6HbRaLTQaDTSa/DNXfiyVChUqDjJUglJxoMA5RyaTQSKRAOccBkN+1l82e3uiOmNMkJVGowFjTCUsFSoOINQUn4oDA0mSEIvFEIvFBOmEw2FIklRASACQy+Vw5coVRKNRJJNJpFIpZDIZ5HI5NS2oQsUBgRpBqdj34JwjnU4jkUgAALRaLaLRKCYnJ2G1WkWqr62tDW1tbXC5XDCZTJAkCZxzMMbAOd8VZVFakMhOjbJUqNhfqDZuQ33UVHFHQbWmTCYDrVYLzjnm5uYQDAZx/PhxOJ1OaDQaZLNZhEIhBINBBAIBpFIppNNp9PX1obOzE3a7XURX9Jkv/uxTBKbValXCUqGitSj5ZVMJSsW+RHHUpNFoEIlEMDk5CY/Hg76+PjDGoNPpBPEUv//KlStwuVxIJBKIRCLQ6XQiwmpra4Nery94vfy/QGGUpYovVKjYU5T8YqkpPhX7DsVRkyRJuHXrFkKhEE6dOgWLxVJ1G4wxGI1GeDwe2O12AEA6nUYwGITf78etW7eQy+XgcDgEaVksll1Rliq+UKHizkGNoFTsG5SKmsLhMKampuD1etHb27uLEMpFUADw+uuvo7+/Hw6Ho+TfJUlCOBwWacFYLAaz2SwiLKfTCa1WW3B88v8CeTGGRqOB0WgUpKVChYqaoab4VOxf5HI5JBKJgqhpbm4O4XAYx48fLxs1VSKosbEx9PT0oK2tTdExcM6RSCQQDAYRDAYRCoXAGIPT6RSkZTKZCl6/tLQEzjn6+voAqOILFSrqhJriU7H/UEqhR1FTd3c3hoaGKi7wlR6wGGOQJEnxsTDGYLFYYLFY0NPTAwBCfBEIBLC8vIxUKgWbzSbSgvQ+jUZTMi0IqOILFSrqhUpQKu4YKGq6ceMGTp8+DUmSMDMzg2g0itOnT8NsNje0fTlp1AudTof29na0t7cDyBNiNBpFMBjE/Pw8/H4/NBoNUqmUkLkXiy9I4k7EpUZZKlQog0pQKloOzjlSqRSSySQAIJFIIBQKYWpqCocOHcLw8HBTFmyNRlNTBKUEjDHY7XbY7Xb09fUVRFXF4gtKC6riCxUq6oNKUCpailwuh3g8LsQFkiQhlUphfn4eZ86caThqkqPWFF+9+9BqtfB4PPB4PADy4gvqyZqamkI8HofZbBZpQYfDsUt8IUkScrmc+J2csFTxhYp7FSpBqWgJiqMmjUaDYDCI6elpaDQanDt3rumL8F5EUEr363K5RI1KLr5YXV3FxMQEGGMiJUjiCzp/eVqQsLW1Ba/Xq6YFVdxTUAlKxZ6jOGrK5XKYmppCIpHA2bNncfPmzT1ZbJtRg6oGJcddTnxBasGlpSWk02nYbDaRFix2vpiZmUFHR0fBdlXxhYq7HSpBqdgzlIqaAoEAZmZm0Nvbi5GREbGwkuFrPfsoh1ak+KodQznodDp0dHQI0iHxRSAQwPz8PCKRCAwGg0gLcs4Lro8qvlBxL0AlKBV7AoqastkstFotcrkcJicnkUqlcO7cORiNRvFaSsXVQ1CVcKdSfPVALr7o7+8HAKRSKQSDQWxtbSEej+Py5ctwOp2CtMxmsyq+UHFXQyUoFU2FPGoir7zt7W3Mzs6ir68PXq931yJJBKbTNffjqNFokMlkmrrNYpBT+l6ArJo8Hg/8fj8eeOAB4XwxMTGBeDwOi8Ui0oL1iC/oHFSo2I9QCUpF05DNZkWtSR41ZTKZXVGTHHsV6bSiBtVKaLVaIb44fPiwEF8EAgGsrq5ifHwcGo2mwBDXaDRWFF9QlCWvY6mEpWK/QCUoFQ2DoqZEIgGNRlMQNfX398Pj8VRc9IjMakUmk8Hc3JxQzbW1tRXI1FslM79TJCgXXxw6dAhA/pqQ88Xi4iLS6TTsdrsgLZvNtistmMvlxCDHlZUV9Pf3q+ILFfsCKkGpaAgUNV25cgWXLl1CNpvFxMQEcrlcxahJDvLeqwVbW1u4desWBgYGYLFYEAwGsbKyglQqBavVKoQF9RDfQYZer98lvohEIggGg7h16xai0SgMBoMg9La2NpFazeVyWF1dRV9fnyq+ULEvoBKUirrAOUcymUQymRRP5FtbW5ibm8PAwAC6uroUL2IkPVeCTCaD6elp5HI5jI6Owmg0Qq/X77IiCgQC2NzcRCQSQSgUKkh7NbPWtd8XasYYHA4HHA6HEF8kk0khvpiZmQHnHA6HQ4wlAaCKL1TsC6gEpaJmUNQkSRK0Wi2y2SySySTW19cxOjoKg8FQ0/aUpvgobViJAOVqOKvVCp/Ph8HBQQSDQfh8PrEgF6vhGsFBq3OZTCZ4vV54vV4A+cgpHA7D5/MJtaDFYhERFk0tJqjiCxWtgkpQKhSDivKpVErUKHw+H+bm5mA0GnHs2LGayQmoLpLIZrOYnp6uKrYot91SCzLVadbW1pBMJkVasLhOUw13wyJM4guj0YhYLIbR0VHE43GRNh0fH4dWqy1wvlDFFypaAZWgVChCJpNBIpEQUROl2jjnGB0dxdTUFLLZbF0EVSmC8vv9mJmZUSS2KEY5FZ9Wq4Xb7Ybb7Qaw26E8Go1Cr9crTgsetAiqHKgXjTEGq9UKq9VaIL4g54taxRcE1flCRa1QCUpFRVDUlE6nRbF8c3MT8/PzOHz4MDo7OwHUr8QDSkdQ2WwWMzMzSKfTFaOmSuSgVL5e7FAO5JtkA4FAQZ2mmWnB/YhKzdJ6vR6dnZ3ifkuSJGp9JL4wGo0FUZac1IudL+bm5nDkyBFVfKGiIlSCUlEWmUwG8Xhc2OxkMhlMTU2BMYbz588XzD1qhKC0Wi3S6bT4N0VN5Rp7laIRmbnRaFSUFtTr9ZAkaU+cMFqNWs5Bo9EI8cXAwACA2+KLUrU+agGgqHZjYwNHjhxRxRcqKkIlKBW7UBw1aTQabG5uYmFhAUeOHNllWgo0TlC5XA7ZbBazs7NIJpOKa030ZF5qIWtmo265tODS0hJCoRBeeumlAu+8ZqsFW4FGSbZcrS8YDGJ8fByJRAJWqxUOh0PcN1V8oaISDtY3SMWeo1TUNDk5Ca1WuytqkkOn0+0ada4UGo0G8XgcV69eLTCRVYJKr9tLLz5KC3Z1dUGr1eLYsWNV04LykRr7Ec2OAkuRejweh8/nQyaTwcsvvyzEF0TqBoNBkfhCjbLuDagEpQJAfnGiqIm+/BsbG1hcXCwbNclRbwRFzaHhcBgXL16EyWSq9xR2oVVu5gSlaUFakOUjNSqhVSIMEsDsFUh8AQDBYBCjo6NCfEEu7plMBna7XRBWLeILdbjj3QeVoO5xcM5F1HT16lVcunQJ6XQak5OT0Ov1FaMmOagfqhbQxNn29nbodLqmkhPQunlQ5fZRKoKIxWIIBAJYWFhAJBKBXq8Xi7HL5SqZFiyXwmw2WlVHI69GoLT4gpwvZmdnEYvFYDQaxTVyOp1lxRcE1fni7oFKUPcwJElCMpkUfU2SJGF9fR1LS0sYGhoS7gxKoNPpxNynasjlckL5debMGUiShPn5+TrPojz227gNxhhsNhtsNluBWjAYDIomZEmS4HQ6RU+WyWRqGUHRQMlW7KdcfU6j0cDpdMLpdBaIL8gZZGpqCgB2pU7LOV8sLy+jq6tLvEaVuB8sqAR1D4KipkQiAc65UNElk0mEQiFcuHCh5gK/0hRfKBTC1NQUuru7MTw8DMaY6K9qNvbzwEKCfKQGUCgsGBsbQzKZhMViQSqVQigUUpwWrAetiqBoRphSmEwmdHd3o7u7G0Dl1CmNHaHz8Pl86Orq2jXcURVfHAyoBHWPoVStaW1tDcvLyzAYDDh27FhdX9RqBJXL5TA3N4dIJILTp08X9BE1ogCshFY4jTd7USuVFgyHw7h+/bpIC5JakH6UpGCVYK9rUIRGZ3+VS50Gg0EsLy8jHA4L8QUJfuRRkyq+ODhQCeoegTxqooUolUphcnISJpMJFy5cwI0bN+pePCrVoMLhMCYnJ+H1ejE0NFR2YGGz0YoFZq/3QSM1zGYzzp49C2B3WpDMXuUjR+o5LkmSmkZ2lVBrBFUN8tRpb28vACCdTgurpps3byKbzRY4X1itVlV8cQCgEtQ9gOKoSavViqjp6NGjcLlcAG5LxeshKJ1Ot4tkJEnC3NwcQqEQTp06BYvFUvK9jdSKotEo/H5/SfeCVmGvo7Ti7VdKC46Pj9etFmxlim+vidBgMIja0/333y/EF4FAADMzM4jFYjCZTAWGuKr4Yv9BJai7GKVqTclkEpOTk7BYLLtqTY30MhVHQfKo6fz58xW/yPV8yTnnWFxchM/nQ39//67eIxIZ3A2oJpKopBZcXFxEJBKBTqcrmAFViiBameJrtmKzFOTELhdfEBKJBILB4C7xRalItNzYkVKmuCqaB5Wg7lJIkoR4PI5sNiu+RKurq1hZWSmImuRoBkGRIi8YDOLkyZOi76WZiMfjmJiYQFtbGy5cuFDgrJ3NZkUBfWVlBdFoFDdu3CgwNW3mItKKOletKr5qasFbt24hl8vtWozvhMz8Tu7HbDbDbDYL8QV9doLBIFZXV6tGovIoK5FIYH19HQMDA6r4oolQCeouQ3HUpNFokEwmMTExAZvNhosXL5b90jbqBpHNZnH16lV0dXVVjZrqAY0kX1tbw7Fjx+BwOMTvaV86nQ7t7e1CIv/iiy9icHAQgUBA9NWYTCYRYTkcjpYslo2i0WtZKi0YDocRCASEDRHVYHQ63Z6qBetNI+/1foo/O6UiURpNQpEoOV9Qw3F/f78qvmgiVIK6i0BRUyaTESkHWtCPHj2Ktra2iu/X6XTIZDJ17XdhYQGpVApnzpzZk6gpkUgIkr1w4YJiUpFPlB0YGBCTgAOBAFZXVwtmHcntdpRiP0ZQSkALLUXSnHO89tpr0Ol0WFxcRDgc3jVypFl1o0ZVfEqRyWQaOuZSkSiJLwKBAObm5pDL5WC326HX68U9Ko6yVPFF/VAJ6i4A5xzpdBrLy8vIZDLo6elBIpHA5OQk7Ha74gW9lNChGqLRKCYmJtDR0QGz2dwQOZVaiDnnJQUd9YIxJlI7PT09AFBgt0OLDqniaLTGnVxEWmF1RAKA7u5uMfq9UhNxI2rBZqv4yqFRgioFEl90dXUByD+chcNhQeovvvgizGazIHan01lwrqr4ojaoBHXAIY+aGGNIJpNYXl7G+vo6RkZGCorC1aDT6RCLxRTvd3FxEdvb2zh+/DhsNht8Pl/dT/uk5JN/mUkGbzQa62oeJlQ7plJ2O1SLmJiYQDweh81mK1mLaMVCcqesjpSkBeWTiJWmBVtVg9oLgiqGRqNBW1sbQqEQ3G43Dh06JCL09fV1TE5OAoBICRabBqvii8pQCeqAgqKmRCIBIJ+yIasij8dTUxqMoDSCkkdN58+fF4tSKZJRiuL3bmxsYGFhoWbLpWJQCq7WSby06B4+fLikh57BYIDL5YLBYNiTHi459osXX6m0IDXIytWC1dKCrUzxtartIJ1Ow+l0lozQ5eKLlZUVpFIpQextbW0VxRdEXPIo614SX6gEdQCRy+WQSCRErQkAlpaWsLa2BqvViuHh4bq2W60GRVHT1taWiJrkICVfPQRF7+WcY2pqChqNRrFRbSUQ8TVS8C+nigsEAtjY2MDW1hZeeumlgoW5mTLqVhJULfeuXINsIBCA3+8vUAvKJxG3yvOvFf1WhHQ6XbZ2WUp8EY1GyxK70+ncNXaEzgfIq1hTqRQ6OjruevGFSlAHCKWiJrnk+ty5c5iYmKh7+5UiqFgshomJCbjdbly4cKHkAtPo2PetrS2srq4WjJJXgmpj3/eihkOjNaxWKxhjOHnypJC3Ly0tIZ1Oi7ER5FzQyAKyHyIoJTAYDGXTgpQuTSaTWFhY2OWb12xkMpmyzeHNRiWCKgbNErPb7bvEF3JidzgcIjUod74Ih8NIJpNwuVx3vfhCJagDglJREzWqjoyMwOFwQJKkumXiQOkISt4Qe+zYMVFAL4V6Rm4A+SfDSCSCTCaD0dHRmlR01dAqR/Pip+Ri54JoNAqz2SwIy+l0Kl6YD7Kbeam04AsvvACdToelpSXFacF60IoaFKEWgiqFcuKLYDCI6elpxGIx8flJJBK7Pj93q/hCJah9jkpRk8vlKohmGo0WiiMoipqK96P0/Urg9/sxMzMDs9mMgYGBppITsPeO5uVk5sXOBZxzJBIJ0UBcLG93uVxlF9NWDSxsBRHSotnb21sxLdgMFWUrCarZdTUSX7S1tWFwcFB8fqiJ2O/3Y3l5uUBVWU18odFoClKHBwEqQe1jFEdNnHMsLCxga2urajRTDyja4JxjaWkJGxsbBQ2x1VBLii+Xy2FmZgbJZBLnzp3D0tLSnizErRhaqARk+mqxWHDo0CEApXtqSsm4WxVB0XHuJUrdCyVpQbmoQGlasFUNwcDeP0TIPz8bGxsYGRmB0WgUaeXl5WWkUimhNi0WX1CEdZDICVAJal+Cc45UKiUGAGq1WhHNtLe3V41mGqklSJKEa9euwel04uLFizVtRylB0STd3t5ejIyMiKfqvVDD7XWKr5FG3eK0TikZt81mg9FoRCaTOZALTDGUiGgqqQVrSQu2KoJqlUUUIZVKwWQyQavVlhRflJrYTA8+Bw0qQe0z5HI5xONxUQ/gnGN+fr6g36gS9Ho9stlszakyzjmWl5eRTCZx8uRJxVGTHNWskuQzoc6cOVMwE0qj0ezZyI39NFW3EsotzMvLy4hEIrh8+bKQt9Oicyfc2xtBPVFNpXEaldKCrTK/bbT+VCvKnZdcfNHf3w/gdrO13+/fE4eXvcbB+nTfxSALnrm5OfT09ECj0SAajWJychIdHR2KakDAbaFDLV8YshGy2+2wWq11f5AbnQlVL5HcCRUfYS8jGlqYSdF4/PhxJJPJXQ7c8jqW0Wjcs+NpBprVpFtKVFDcXE3fJ/Jc3Ksop5UEVetnmZqtOzs7D9zDDKAS1L6APGpaW1vDoUOHMDc3h0AgoChqkoMiKCWQm6+S68Rrr73WUC9TKpUq+B25mwcCgYru5vVGUKlUCnNzcyKVUbxIt0LF1yorIiA//tzr9cLr9QLIRyRUxyJ5u3x4YaPy9mZjr+pCxc3VkiThxRdfhF6vL5iyS9elkiilVqRSqZYRVDqdrvu499PnQClUgrqDKK410SJ99epVdHZ2Frg0KIVer1dk+FrOfLWeCIxQnOIr5zhRClqttmaj2s3NTczPz2NoaAh6vV64TmcyGbFIZ7PZPXd62GtUIkCdToeOjg50dHQAKJS3kzzZYrEUuLe3sl5SjFbZHHHOodfrd6kFy3kutrW1wWKx1LWItzKCSiaTdTeBqwSlQjEoaiLjTM455ubmkE6ncerUqbpqQEB1guKci7lQIyMjuxzO65GKE+RuENQ7pTQCrEUkkclkMD09DUmScP78eRiNRrFQA7d7SAKBgJAvy+sTDoejaV/W/eZmLpe3y+XJpPSSRxJygYEkSS3rtbpTTuaV0oKTk5NCLUgRllIyT6fTLUutkkCiHqgEpaIq5FETYww6nU7UZzweT83jHopRSahAc6EsFkvZuVD1jtwAbqf4rl27JoYJKn1aV5qKo76pgYEBIUsutS2S2tI4BKvVustLz+12l3Sc3m9oRL1XSd5eLDCgwXty8UqzsZ+czEt5Lsbj8V1kXm0UC7mGtALJZLJuMlQJSkVFZLNZUWsiUcDs7CxCoRBOnToFi8WCWCyGdDpd91OSXq8XTb2EWkZW1BtBcc7h8/kQDAYxOjpacwRYLYLK5XKYnZ1FPB7HuXPnCr6klSIYinCKvfSKHacZYwVRRS22NfspglKCUvL27e1t+P1+jI2NiUmycpfyZu1/P8+CYowJkVAtacFWpvhSqVRNEwqA1jV67wVUgmoBKGpKJBLQaDTQ6XQIhUKYmpqC1+stmD5rMBjqjmCA3Sm+ZDKJyclJmEwmRSMr6omgkskkxsfHYbFYYLPZ6kpPVhJJUITZ3d2No0eP1uxMXioyM5lM6O7uFuO+S82Eot4Rki3fCbSi/0mr1cLhcMBqteLixYsF/TRzc3OIRqMwGo0Fk2TrjYJaZeDaLCdzJWlBeqCUJGnPa3zJZFIcSy04iDZHgEpQe2IUBgcAACAASURBVI5SUdPMzAzC4bCImuTQ6/VIp9N1748IinOO9fV1LC0tYXh4GG63W9H7dTqd4v0XR2ZOpxNXr16t67hLyczlCsBS10oJlKYOi2dCyZtmx8bGkEgkCsxfbTbbnn7pk8kkPvrRj6K/vx8f+MAH9mQfcsibTUv101DEubGxgampKTDGClJfStNOuVyuJWS/V026pdKCL774IkwmU01pwXpRbw3qIJIToBLUnoH6mpLJ5K6oqbu7u2QvEJB/YmuUoFKpFG7evFnXoD+lQwtpmKDBYCjYR73phOIUn9w5ox41I6HeFFypplmKKmZnZ4X5q91uRzqdboqbwNWrV5HL5eDz+fAXf/EXCIVC6OjowA9/+EMcPXq0oW1XQ7XjL4445fL2hYWFAuWky+Uqq4hrVQ2qVZEaDRbs6+urOBaenMkrXRslqDedqBKUCoFMJoNEIiE6viVJwvT0NKLRKE6fPl3xCVKv1yMajda1X845tra2EIlEcPbsWcVRkxxKalDNGiYoh9wHkCYCHz9+vOHic7McKoqjClLHbW1tIZVK4eWXXy6pjquGZDKJW7duweVy4c///M9htVoRi8Wg0+lgNBpx+fJlPP/889DpdOjs7MTf//3fN3wupVCr60IpeTu5b09NTSEWi5VUxLVymm4rRm2U8xYs5UweCAREWpCk/21tbXvubH+QLbJUgmoiSAWUTqfFuGb6wh46dAjDw8NVPyj11qAootHr9bBYLHWRE1C5BpXJZDA5Odm0YYJyUB/Ua6+9BrvdXtNE4GpOEo3U9MqB1HFerxcbGxu47777xJPz9vY2ZmdnwTkvqGOVSs184QtfwD/90z/BYDDA6/UKEvR6vYhEInC5XNjY2MDs7Cx8Ph/W1tZEFNNMNBoBlnLfLlbEUfqYBCt7GeG0yodPCeHKr02xWrCUs325tGAj41DuZO9bI1AJqkmgqOmVV17BfffdB0mSMDU1hXg8vst3rhJqTfFxzrG5uVkQ0fzHf/xHvadRVqa+tbWFW7duYXBwsGqRttYnNs45NjY2hEKvmaaWrXQzL6WOo1TP8vJywRDD69evY3p6GmNjY9BqtbBarQUPFZxz4XbQ09OD2dlZAMDY2NieEFSzZ0GVU8S9+uqrCIfDWF1dhSRJBTZNzZxC3CqCqiflVotaUJ4WbKRJ96BCJagGQamedDotXLn9fj9mZ2dx6NChmlVnSp0ggPyHenJyElqttiCiaWTMeTFBZbNZTE9PI5vNKhomSOasSqMfOgedTifSHrWi0iiBOzUPCsAut2m5y8N3vvMdrK2twWg0QqPRYHBwEBqNBqlUSsz8IsKiOT7pdBqPPPIInnzySbz73e/Gm9/85qY1iLbCkdtgMECn02FkZAQGgwG5XE6Mi1hZWRHjIoqFKPWgVaM2miUxr5QWpJSpXq8H5xyBQKCmtCCg1qDuSWQyGcTjcXDORX49lUphfn4eZ8+eretpR6nqjGx+jhw5IuoABCKZer44cjUdNcX29/fD4/Eo+pBTDUsJQVFURiPeX3nllZqPF6j85WvFuA2l0Gg0uHnzJvx+P9bW1tDZ2Vlw70hMk06n4XQ6EYvFhNPH6OgoAoEA9Ho92tracOPGDXzzm9/E5z//+aacR6tGRsg/G1qtFm63WxCxXIhy69atAnl7rQ3V+zmCUgJ5WhCAmGoQDAZrSgsSVIK6h1AuaqLJsIODg3sWiqfTaUxNTVWsA1EUVq/ah9KTiURiV1NsNSixLKo1KmsErUjx1bL9b3/720KVJ4+s5E/78XgcTqez4LowxtDR0SF8G2/cuNGko4c4hlYQVKX9lJK3k02TvKFanhYs99m520ZtEMF4PB709PSIfQeDQQSDwbJpwYMOlaBqRKmoaWpqCqlUCmfPnsX6+nrDRXla5Iu/YD6fD3NzcyLiKIda0oTFCIVCSCQS6O3trTk9KT/2ciAT076+Pni93paMGN8P86CWl5fR1dWF2dlZ2O12aLVace7hcLikqEWj0SAYDMJmsyGRSMBqtSKVSsFsNsNgMCASiTRNodXKoXu1HK/ZbIbZbBaLsryhemFhAdlstmkS7nqQSqVaNmcpmUwWNMErSQtaLBYMDQ3dsUbzRqESlEJIkoRkMolUKiUUeqTWki+2BoNh18iJWkEEQwSVyWTE7B8l6rl63CDkwwRpQajni15OZCHffqX0Zz0LJXnIlTKB3S8TdX/rt34LZrMZvb29YlQ3kCdsuVQ/l8uJBS+bzSKTyRQ4stNnwuFwQK/X40Mf+hDe9a534dSpUw3ZErV6Kmy9KG6oLiXhJiIPhUIFY8/3Aul0umWTaqs16ZZKC8bj8ZakOvcKKkFVAedcKPQ45yJCmJycRCaT2ZUCMxqNCAaDDe2TCuImk0lETUrUc4RaZkIBQCQSwcTEhBgmeO3atbobHUtFUMXbL7eAUv2rlgWFZPw2mw2xWGxXzaKVKr5S+Ou//msEg0F0dnZie3tbNLTSE21xGiaXyxVcd3piJpI1mUwIh8PCVmprawvf/va3YTAYYLfbkc1m66rbFKcZDwpKSbgjkQiuXbuGxcVFhMPhgllhbW1tTT3PVo/aqCXdzhiD2Ww+kPeVcHCPvAWoFDWVEw406gQB3DZ8XV5ehiRJNddplNolSZKEhYUF+P3+gmGCFAU1SlCSJGFxcRHb29sVhxXK36s02pEkCXNzcwiHwzhz5oyInpLJpBAhTExMiNf6fD64XK6mf1krRVDf+MY38NWvfhW9vb3o6+vDoUOHkEqlYDQaxedGfjySJBVcc/lni0hbp9PBbrcjEolgc3MTyWQSuVwOn/zkJ/HYY4/hyJEjBXWbiYmJgmJ6uUF9rYigWtEwSlkMm82GM2fOAMhHHoFAAFtbW5iZmVHUn6YUrSSoVhnt7ifcW2erEPKoiYqt2WwWExMTyOVyFYUDzSCoTCaDmZkZDA8Plx0pUQl6vb6qXVEsFsP4+HjJYYKVRnZUA12reDyO8fFxuFwuxVZFSl0f6Ni7urowOjpasOiZTCb09PSImgWNAJc3z+71iPREIoEPfehDmJ6ehsfjQVdXVwGJyY+XMSaau0kkAOTrUmazWdSqionbbrcjFoshmUwik8mAMSbueam6Dc3GKmeE2wqCulOjNoxG464pxMXydrvdLj4XtcjbW6UWbITcD0LqthxUgiqCJElCoUeyX5JDDwwMoKurq+IHpRGCInVbNBpFd3d3XeQEVE7xcc6xtLSEzc1NHDt2rKSVUKMEtb29jZWVFRw7dqwmZ/NqAgu5DdKJEycKBiGW+wIbjUYYjUYcP34cwO3Fye/3Y3FxURTZ5Yt1LQtB8Wvn5+fx27/922JmVXd3dwG5EHlrtVrRA0VO2IwxZLNZ4e9mNBpFxGWz2YQoAgA6OzvhdrvF4Euj0YhPfepTeOc734mHH3644Jj0ev2uBmJaoFdXV5FKpcA5h9vtFqnDvYh0WmlzVIk0dDpdQX8apQWLfRblAy4rHXcrRBmNEOFBlZgDKkEJcM6RTqextrYm8vYUNdWSZqvXnFSeOuzq6kIgEKjnNACUF0nE43FMTEzA6XRWHCZYL0GlUiksLy9Do9HUZFVEqCRooGGLVqu15LbLfQmLt1m8OFGR3e/3Y3x8HMlksuZmUWoU/pM/+RNcvnwZiUQCBoMBvb29sFgsyGaz4lprNBqEw2FoNJqCmmIulxOEyzkXxE4ERYRmMpmQSCTAGIPD4RCve/3115FKpfCNb3wDb3rTm3DkyJGyx1uq/+jmzZsAULBA00DHZo2QaFXzbK37kV/LgYEBYfRMBF6u56iVtc170UUCUAkKwO2oKZVKYXZ2Fvfff39d4gQCkZSSJ5dsNouZmRmk02mROoxEIk0ZuUHgnGNlZQVra2sYGRmpOvCsVpEFcNtAtqurq+4n5XIRFG272rDFUqgmMy+lfIpGo8INJBqNCoeLUov1jRs34Pf78ZGPfAQ3b95EKpVCW1sbHnzwQXENkskkIpEItra20NnZKaIj+XWizww9KNECK48S6XWl7g0tlplMBr/0S7+E7373u4rTlzTZubu7Gy6Xq+SYeJ1O17DQoFURVDqdbijtRuKCcvJ2SpPabDZIkoR4PF5z5F0r7rVJuoR7mqCKFXo6nQ6cc7zxxhvgnNfdREppvmofqHJODY0OLZRHQNUij1Kg6FEJig1k4/E41tfX6zru4minFnl9uQeCWmXm8mZReppOJBLw+/1YWlpCOBwWRfh//ud/xrVr10TvjVarhV6vx9GjR3eRTzqdRk9Pj1jIzGazeFKPx+PC+odzjlwuJ2pCkiQJhR0Ro8PhQDwehyRJsFqtYIwJYQwpTcPhMDo6OhQvTsXzoEqNiS8WGtRay2tlBNXsulApefv6+rpQqJK8XT6FuJm1n3rmQB3kSbqEe5ag6MmHcv5arRabm5tIJBIYGBgQBdV6UI2gstksZmdnkUwmSwouGmm0BW4/ja+trWFpaanmyINmSlUDpSXlUaYSJ4lykL+XyHtgYKDuWhzQuJOEfLHu7e1FMBhEPB7HI488ImpDfr9fyJytVisymQxMJhM0Go1oF8hkMrscvGngobxJNxaLweFwiOtAC3pxDYL+nxZjEk1IkoRsNov3v//9eNOb3oRPfepTis6zmvOCwWCAx+MR90IuNFhaWkI6na46D+puGrVBtUO3240TJ06Ac45YLCYaiCORCAwGQ0FasBFyTiaTNY96Bw7uJF3CPUdQlEJJJBIAbo9joCmh7e3tDc8gqiSUkDspjIyMNOWpvxipVArJZBKhUKjmgYVA9Qgql8thZmamJME2SlCZTAbT09OIxWI12yyVQrOdJL7yla/gjTfeEManJC5wOp2IRCLQarWigx8ApqenMTw8DKfTWfKpnvqWCNQfJSeMcDgMp9OJZDJZ8l5KkgS/3y+iSCLllZUVxedVq4qvVC2PhAbyeVDyiKJVMuk74cPHGBNjRGhwIcnbfT4fpqenAaCAsGqJiKgWWSsOMjkB9xhBUdQkd2mgURVkHzQzM9OwfUkpN4lcLofZ2VkkEom6jWSVgExkDQYDRkZG6kozVKpBhUIhTE5Oore3tyTB1pIeLEY6ncbGxgb6+voUzc5SgmZ9QS9fvowXX3wRy8vLcLvdCIfDoimbhApEShaLBalUCvF4HJ2dnYjFYgVuEfJ7UhxR0CIuP24iHoPBIMiP/p5Op8W+gNv3jgjq5s2boh+oEhodt6HRaOB0OuF0OsU8qFgshmAwKCIKSZJgsViENdFeRVOZTGZfOJlXkrdT1EnjV1wul0jXlkI9IglK9x5k3BMEVRw10ZN6qVEVJO1tBEajUSwYwO2oqRZ/u3J+fOVA58MYw/nz5zE2NoZMJlPXU1cpkqHG2FAoVHG+lZKJvMXgnGNxcRGbm5vo6uoST6D7BZlMBn/8x3+MkZERoXCj0QdUOyQH7nPnzonP0szMDLxeb8E9KCYCSgcS5E/+JP+m32m1WpjNZmEEnEwmsbKygmAwuOszRWne3/iN38C73/1uhEIhfOITnyh7js3ug5JHFDTzaHp6GplMBhsbGyJjocT4tVa0atx7KpWqKe1WKeqcmZnZJW+Xj9RoZUPwfsJdT1CloqaNjQ0sLi6WHFVhNBqrNrlWg8FgQDAYFFFTPB6vOWqiNKESk8dSwwRJal4PQRVHUNFoFBMTE+js7MT58+erjreopeaTSCQwMTEBh8OBw4cPC7fu/YBUKoWPfvSjWFpaQn9/v1D86fX6AsNgIN//RI21uVwOmUwGkUgEXq9XGLwC2JVuLL4/dO10Op14UCh+jU6nQzwexxtvvFFQq9JoNKLmIE/3fetb36pag2xFoy6l0KmOJVfGzc/PCzfuenvSCAdl1IY86gRQoJ4sHqlBnoy1ntdBbtIF7mKCKhU10XA8vV5fVhVmMpng9/sb2rfBYEA0GsXVq1fR09NTlys4CSUqEVSlsRX1SMUJtDDKm3qPHz++S/LcCDjnWF9fx9LSEkZGRtDW1obt7e26Hw6arVjinOOLX/wifvSjH+HHfuzHoNPpEAqFChYTqglRj9Lw8DAikYggjbNnz0Kj0SAej4uUICnsiECsVqs4Z4qQCNlsFiaTCdFotCDlnMvlkEwm4fV6EQ6HEYlESj6MUCaAxBqc87KLXCsIqrgGVUoZRykw6kmjScO1ODwc1FEb5dSTfr8fq6uruHr1aoELSFtbW1USV2tQ+xC5XA6JRKIgaqLFkMail0OjKb5cLofl5WVEIhHcf//9ddvcV/PTqzZMsBElIFkOXbt2rWpTbz2Qp1flIo69dh5XgtXVVTzxxBN45plnYLPZcOTIEbEIyCMnIo/JyUl4PB50dHTAYDCIyJdk4BR1McaE2IEWNbI30uv1okE4Go0CyF8L2odOp0MwGIRGo4HD4UA2mxVj30OhEF577bWCczAajcLPMZPJgHOOUCiEn/zJn8Sv/MqvCKeJ2dlZDA0NAWiNT141qyONRiOiJzqm4gGGJpOpZArsTqAVaTeDwSBqdufPn0culxPu7ePj40gkEgWN5fW62e9X3FUEVS5qmpiYgNFoVKRoa8SqKBQKYWpqCt3d3TCZTA3NYCnXC6U0bVgvQZE8PZlM4sSJE3VJWyuBpOmlZlo1ogDMZDIixVUvnnvuOfzjP/4jtra2YLVa0d7eLiTg0WhUTLulp1wAaG9vR0dHhyAW4HYar1q7gV6vF+IHSm1SlBqNRsVCbTKZYDKZxLWRR7IUDZFaUaPRwGazob29HdFoFMvLywX7/Mu//Es8+eSTeOtb34oXX3xRRHGLi4sYGRnByMgIfvVXfxUvvfQSenp6EAqF8Nhjj+Hs2bN461vfKoixHtQqM680wFDu8LBXTuXV0CrZvLxJV36+AArk7fPz8wXydo/Hc+DdJ+4qgvq93/s9vPe978Xhw4cBAGtra1heXsbw8HDJgXClUI9VEc06CofDOHXqFCwWC1ZXVxt6Ki3Vi0QEqCRtqNPpao4EU6kUJicnYTQaYTab6yYn+WJJkKsYy8nH6yEozjkWFhawubkJIK+go5RQLc2S//qv/4rHH38cmUwGS0tL6O7uFosPCRXI3iaRSAg7I1oA5Puhc89mswWpOfn9Kl7cij9z1Dslf0LXarWIRCIFxC7/O0UodN/kizXVBhlj2NrawtNPPw2Px4N4PA6NRgOLxYKJiQmMjY0hGo3iO9/5DiRJEj6B165dw1NPPYWnn35a0fUshWbIzIsdHmiqrN/vx61bt0T6c21trWGnciVoRbRSqUm3lLydbJpyudyBj6buKoKKRqOYn59HT08PJicnYTKZ6uoDohSXkqejcDiMyclJeL3eAgEBqdnq/UJSHQsoVNCdPn1aUWSmxNFcDpKnUwr01VdfbdiyiBZtukbViLXWFF8ikcD4+Dja2trwwAMPQKfTCdcHmgVEKdtAIFA2JbS8vIxnn30WOp0ObW1tsNlsQspNvU2ZTAa5XA7pdBpWq1XUlsgiqZigqo0OKSak4n+TOMLv98NqtYrz2N7eRiAQgNfrLTAxJSeKXC6H9fV19Pb2Qq/Xw2g0iuhMfn1jsRgWFhZgsVjAOUcqlYJer4ckSfjBD34AACJiJJeVeDyO1dVVQQ61Yi/czIunysZiMdy4cQPxeLzAqVyJlLsWkLlvK1CrxNxkMjVkNLCfcFcRVH9/P771rW/hueeew2/+5m/WPenSaDRWVdDJSYOiJjkovdMIQaXTaWGl4vF4qiro5FCa4qPGWEmSCoQjZJdUz4Iify/Nmyp1jYqhNIKSCyyOHTsmiKfY9QHIf7l/9KMfiZRQsafc+vo6Pv3pT0Or1WJrawtmsxnxeFxEIRaLBYlEQhwbERKNYAfyBGy325FOp5FMJoWrgjxVTPUkQjFRFl9nrVYrVF4UCW9ubgorpEAgIGZgDQ8PY3V1tcCUlrYxMDAAjUaDjY0NmM1mrK+vC6cF6p8iv0Hy5ANuL8D0X7qnH/zgBwEAv/zLv4yf/dmfrXqv5GiF1RHZP1FtTZIk4a1IUu5K3opK0epBhbVMBSAcdAUfcBcR1OLiIh5//HE4HA48/vjjYiGpB/TUWY6glJAGNevWa7mi1WoRCoWQSCQUDfsrhhKCqmQnRAtSvX1UNLOp1nlQ1SKocgKLcmlZk8kkxm1QTZLsaJ566im8+uqrYhqv1+tFKBQqULmR8WixfJ7ueSaTgcvlQjabFQMH6V7Rf7VaLWw2GwwGA8LhMCRJwuDgILa3t5FKpQqcJ+TXgmA0GhGNRgtUmUTkZE7b3t4uUsAU9ZCFl8fjQSqVEulrg8Eg+riI/GgEiHz0B7UqyNOD5Ft57dq1mglKLsvfKxRLzElYQgu83FuxESPcVhJUPS4SrRC9tAJ3BUF997vfxe/+7u/i137t1/D88883RE5AflErVb+RJAnz8/MIBAJVSaMRsQUt7hTV1OsGUY6g5EKLcvWgekdukPx6ZmYGJ0+ebOo8KGp4rtVhnohPq9XCYDAIpd4bb7yBo0ePCk9GEh9YLBZhIkxRCudcRC0UCVAEQko7nU5X0KTNGENXVxfMZjMWFxeFAvDIkSNiDtX6+jp6enpgNBoRCASQTCZ33W8qknd0dGBjYwNarVZ8PuUSdCJQxhgWFxcxMDAg+vxosSKjWbvdDpPJhLm5OfG+XC4n0sqkhHU4HKKmduzYMVgsFly/fh1tbW24du0azp49u6/cCqpFaaWi7EqWROWMcFsdQdVTS1MJap/g0qVLeOGFF5BIJPB3f/d3DW9PnrcnRCIRTE5OorOzExcuXKh68ylNWAuKhwmOj4/X/cRZbrGnelB3d3fFelA9BEWKyWw2iyNHjtSclih3LJIkCZlxPf58FAHcuHEDX//61/HCCy+gvb0dw8PDIi3n8/mg0+lw5MgR8QSeSqWQTqdFLdHhcECn0yEajcLhcOxqSSBfvmQyKUZnbG5uFlwHIrulpSXxOypqc84xMDCAhYWFgmuRzWZhNpthtVphNpvFME3aJ8FkMon5U6Ojo9DpdCI6k6corVaraOylWhlth8jc7XbD7/cLsY7ZbEZbWxuy2SwGBwcxNjaGxcVFmM1mnDx5Er/wC79Q0z3ZK9TTpFvKkogaiOVDLdva2uB2u8U92O+j3lWCUohgMIgPfvCDeP3118EYw9/8zd/g2LFjeN/73of5+XkMDg7iiSeeqLtmRE+JZrO5oAmyXhiNRoRCIQD5xZHqKCdOnFCcaiPfNKVQOkxQKYrPXx79Ka0H1UJQ5GYxNDSESCRS1zGXgny8+7lz5+q+r9/4xjdw5coV0Ujr8XgQjUZFxGC329Hd3S22T7UerVaLZDJZcL1oAYxEIrBarSJt1N/fj2g0CoPBgMOHD4tRIS6Xq+CaFJ8DPQzJaz5yyEmIhAuSJGFxcVGIYaxWK0wmE0ZGRgpstii6OXTokOjPooGJFosFo6OjeO2118ScKXqoiUQiMJvNws4nFoshlUqJpuT5+XmRQsxkMnj44Yf3xYLYDBcJnU6Hjo4Osa7QUMtAIICJiQnRxmKz2UT9ca/OvZG1bD/cj0bRkirahz/8YbztbW/DxMQErl+/jhMnTuDRRx/FQw89hOnpaTz00EN49NFHG94PWbvU20tDoCdjcoMgf7ta6kBKIygy9XzjjTcwNDSEoaEhQU6N9AXJEYvFcO3aNTGzSUldTKkTBU0dXltbw+joKNrb25ty3DTefWxsDMePH0d/f39dX7hXXnkFX/rSl3Dt2jXEYjHMzMzgzJkzcDqdWFxcRCQSwerqqnALp2hLkiQYDIZdDwryWgwJM2w2G7xeL7a2tkStiCKrw4cPY3FxUby/ra0NwWAQQP4a08wpglarxeHDh+HxeAS5yO245CKG7u5udHZ2FtynTCaDjo6OgnlgBIPBIMQfkiRhcnISwWAQDz74IC5cuIC2tjZoNBpxDYjQNjc3EY1Gcf36dTidTszPzwPIj53v6upCJpPBo48+iu9973u7+q4IrVK97YXNETVbHz58GBcuXMCDDz4Ih8MBvV6P+fl5XL58GVeuXMHs7Cz8fn9TvrOEe3XUO2HPI6hQKIQf/OAH+OpXvwoAotv+6aefxve//30AwAc+8AG85S1vwac//emG9+f1erG2ttaQ4aher0c4HMbExETdFj9KalA0TNBisZQcJliLH18pMMZEj9Dx48drGiMir3OUAzmb9/X1wev1ii9EI47mQD61Vum6lEKxSOLVV1/Ft771LUQiEaFYGxsbw6VLl5DL5ZDNZpHJZHD69GmEQiHhoydJEmKxmGiOBW5HLSQxN5lMwgXCYDAgHo/D5XIVLAgUPcuvA0XVVBvs7e0Viz3tR5Ikkf7r7u7GysqKmDkF3I7e5At+saBCvl+bzSZShJlMBowxmEwmoQxLJpMIh8MwmUwIhUIYHBzE4uKicMKm95Aa7uWXX8bRo0fR3d2NhYUFJBIJbG9vY3p6Gs8//zwYY/B4PPjkJz+Jvr4+Qah306gNuu69vb0ifUtp2vX1dTHAs3hEfD2oZ5Lu3TCokLDnn5i5uTl0dnbiF3/xF3H9+nVcvHgRf/Znf4aNjQ3Rle71erGxsdGU/fX392NxcbFugorFYpiYmADnvKFUWyWRglwmXWmYoBI/vnJIJpOioVTpIl+873IpSkoXBoPBks7mtKDXg0wmg+vXr9fUXF2Mf/u3f8M//MM/ALgt2ojH42hvbxeKuM3NTTHe3OFwFIwmcDqdCIVCMBqNQk5Ojbf0eTCbzQWKQ6fTiUAgAADo6+sTJBMOh8Vr5L1tpdDe3l4wwykSiUCv1xc8kVMfDxEsDSvMZDKIRqMFaSngdsQlJ0+Px4NwOIyuri74/X5hh3T//ffj9ddfh8vlQiaTgdPphE6nEyRKTb5bW1uw2Wzimo2MjIiIsqurC7Ozs3jxxRcxNDQkHMub1X9UDXdq1IbJZEJ3d7dY00qNiCcPPTLCVYJ6JukCiqXZzAAAIABJREFUB39QIWHP72Q2m8XVq1fxuc99Dg888AA+/OEP70rnNfNiDgwMFBSglYKeXH0+H44dO4aJiYmGjqOcIwUJCQwGQ9Um4nqUgHLys9vt6O3tbaiXqRhE4O3t7WUl9vWk+HK5nDC+vXjxYt2DCr/0pS9hcnJSpKj0ej0mJyeRTCZx8eJFMMZEDQqAIJ14PC7Ii1RrxREK3StqkKVUndvtFot4V1dXQUpPfh7F16r43tL2CJFIBMPDwwgEAnC5XAgEAqLvaXt7W6SidToduru7hZsGHSOJLhYXF8XDUmdnJ1599VW0t7cjEolgamoKR48exRtvvIHjx48LiyWTyYTl5WUkk0mROqfernQ6jVgsBpvNJsbU+3w+PPDAAwiHw9BqtXjhhRdgMpnw0EMPIZvNYmNjA+FwGJcvXxYLtdvtbrrTQ6tGbVQTSRQb4co99MbGxoT3IhFWOSPce1nBB7SAoHp7e9Hb24sHHngAAPCe97wHjz76KDweD9bW1tDd3Y21tbWaZMOVMDg4WDO50KLrcrlE1EQ1pEa+QMWWP8VuDdVQzTC2GOTWrtPpcOHCBczNzdVtGFtMUFQrW1tbq5ourJWgSFl46NAhYb1TKzjn+P3f/30hbiGbICruHz58GBaLRbgtBAIBGAwG8UWmxZYxJhZ3oPCLLo+w5LUWeSpUp9Ohs7MT29vb0Ol0wm6J/P0ikYhoDpW/jzEm0oby30WjUWxvb6Onp0cQFUVhnZ2d4jjoibynpwfr6+vi/VtbW2J7LpcLr776Knw+H3w+HwYHBwHcrlNR/5TFYsHk5CTOnDmDmzdvwmAw4Pjx47h58yaA2z1+kUgEjDFMTExgcHAQCwsLYjtjY2MYHx/Hl7/8ZTz22GPo6+sDYwzHjx8XjuWvv/56050eWjVqo9aerlIeemSEOzs7K9LKxUa49TTptqLfrFXYc4Lyer3o6+vD5OQkjh07hueeew4nT57EyZMn8dhjj+HjH/84HnvsMbzrXe9qyv4GBgbwL//yL4peS3LfjY2NXYsuPZ02QlBk+KrRaISiq9yYj3LvVzofiVR0chPWRhzN5QRVa01IqUSdfPS2t7eFsnBra6suR/P3vOc96OzsFJY/5FtHRsGHDx8uEEDQkz81ZnLOhcMCRfSJREJEQOFwWNQii7/8FJFFIhHodDosLS3h0KFDWFtbw+zsLAAIifrAwIBYRH0+H7xeLzY3N8veK7r/q6ur6O7uhsViQTgcRiqVwtbWFvr7+6HVarG6uipeZ7fb4Xa7sbS0JDwDgXwzOz0Y+Xw+ofYjonE4HDCbzeCc4/Dhw2I8SGdnJ+bm5tDR0SEm4ZKEPRwOi74rSZLgcDjgdruh0Wjg9/sRjUbxV3/1V/j1X/91aLVaaLVauN1ukb6VD+2bnp7eNSqe+tCUolWjNhpFsREuKUGDwWDBLCiKCGt14VAjqBrwuc99Dg8//DDS6TSOHDmCv/3bv4UkSXjve9+Lr3zlKxgYGMATTzzRlH0NDg4qSvHJZd0XL17cteg0Y7KuwWDAxsYG1tfXa24uBW6LNSqh0kwocgKoB0QyFPXVUhNSEkGRj16x00StKsxnn30W3//+92EymWCz2cSMppWVFayurkKv1+PUqVNiuz6fDzabDZIkiUVWfl4U8Ra7gHi9XlGToy9/Z2cnnE4n/H4/fD5fgZy8eJG02Wzic+l2uwWhUGpxYGAAs7OzBWlhl8tVkPaLx+NYX1/H0NAQQqGQKMwTwRDk/+acIxwO4+rVq+LvIyMj8Pl8CIVCOH/+vJi7FI/HcejQIUSjUdhsNty8eRPnz59HNBrF1tYWIpGIqFmR12R7ezv8fj8MBgNcLhdOnjyJQCAAj8eDF154AaFQCM8++yxefvllvP3tb8ehQ4cKHgTLjYont49IJAKj0ShSgnd6xAawN56C8gZiuRHuK6+8glgshitXroBzDqfTCbfbjba2tooPz3f6GjULLSGo0dFRXLlyZdfvn3vuuabvi+S+5UDy5fX1dRw7dqxs+NwoQWWzWUQiEcRisV3EoRTlRm4Q6KmzWEVHoDlD9YDUbJubmzVFfUBlgirlo6f0vcUYHx/HZz7zGfT29gpxACnUKM0xMjIi7HuA/Bc3kUiIybjy66vVaguUiHLQYEGz2QydToe+vj4YjUZMT08LUiFn7VLvl0eUxU/CPT09mJqaEm4RVL9cW1vbJUEHCmtVFFF1dXUVCI3ovrtcLrz22ms4ffo04vE4bt26Jfp4XC4XVldXkcvl0NPTgxs3buDs2bOYnZ3FuXPnkEwmkclkMDExgVOnTmFsbAwXLlxAKpXCzZs30d7ejqGhIaRSKYTDYSwvL+O5556D2+2GwWDAyZMnkU6nMTs7i0wmg+9973sYGRnBW9/61rL3tJQ7d6URGy6Xq6rdVbPRqiZdSkGfPHlS1E5JeLG0tIR0Oi2i5VYKUVqJu8JJQg55Gqf4KaK4GbbSU1Ajo9+JOGw2W8GAulpRTiRB4z0ikUjVmVD1NM3S8Wu1Wpw+fbrm95eTmZfz0ZNDqaP5z/3cz8Hr9YrUbDQaFQv74uIiksmk6PqndJ/VaoXX6xXiiVwuV6CgpEGEOp0OZrMZBoMBwWAQ7e3t2NjYEAsA2eEcPny4YFGUPwwULxTy61FM9nS+qVQKKysr6O3tFaM95HA4HMIOqaenB5xzQUobGxswmUxCCZhOp9HR0YFnnnkGQH70zNGjRwHkF1iPxwObzSaUh/Rdoc8befyZzWYMDQ0J1R6NsfB6vfD5fLhy5YpQ6pHjQldXF1ZWVnD06FFRq6Lr84UvfAEajQYPPfSQ4sW01IiNQCAgZotRqrbZs8vKoZUuEvJGXa1Wi/b2dpGmLZce9Xg8GBgYaMnx7TXuOoJijMHtdmN7e1vUYuQF/pGREUUf5HoiqOJhguFwuG6SA0qn6Kiu4vV6hYy3HGqtQZGlEBHfjRs36jruUiRDxrTVUp3VIqilpSV873vfQ1dXF2KxGPr7+4WYhcxYo9Eouru7YbfbYTAYRH8RCSdyudwukqDpy5IkiQUoHo/D7XaL90ej0YKHHvLa297ehlarRVdXF7a2tsR4CrvdLhZn+YNG8YNR8fkGg0H09PQUXMf+/n4hQojFYojFYhgcHCx4bzKZFCKR9vZ2xGIxvO1tb8Pq6ipu3LiBWCwGl8uFRCKBlZUVuN1uYa0Uj8dx4sQJSJKE++67D/39/RgeHoZer4fb7UYikcBP/MRPIBwOixrS1taWMOD1eDzw+/04evQoXnvtNbjdbiwuLiIQCIjZVtlsFoFAAI8++iiefPJJfPGLXyx7nyvBYDDA4/EUKDGDwSB8Ph8SiQQuX74Mh8NRIOluZmTRKoIq9ZAtR6n0aDwe3yW2Oci46wgKuC017+zsRCKRwMTEBOx2e039QKX8+Cqh1DBBMqGsF3IHbbK22d7eVuxuXoufXjQaxcTEBLq6ujA6OiqEAvVYrchfX6uPXqUa1M2bN/Hxj38cTqcTuVxOWAuZTCYhFaexEl6vV0TSOp0OFotFCABo+/JrSwuBwWCAJEni4cTlcmFubg6MMXR3d2N9fV2QXzabhc/ng9lshsViEfJyk8mEmZkZAPl6U3t7O1KplEh90QBEengoPl+73S7UmNTXR8QjRzabFZ558uut1+uxvb0NxpiIJIG8ivTUqVNIJBLI5XLw+/1iUq3f78fFixcRiUSEcKO3txcrKyuib4oi4B//8R9HJpOB1+tFPB4Xs6nOnDmDUCiES5cuIRgMYnNzE4FAQEwmzuVy2NzcFPZV73vf+/DII4+I0Rj1gqyJjEZjQfM1jUVXKulWilYRVK0Sc6pjNTLJe7/hriQoeto0mUyIxWKKoyY5qAhcDZWGCTbiaC6HXAZfi7u5kghKblBb7JpBBFePbJck0jSWpFq0Ryg36O+b3/wmnnnmGXR1dSGRSODIkSMAIGTjjDH4fD4xA4kWZ7oGlE7UaDSC3Em9Rz09dD3k14Yxhr6+PtHr4/V6IUkSpqamxGtNJhN8Ph+A3a0BdrtdKDiBvG2R3+8X0Zfb7cbc3Jz4u16vFwKKbDYrjGlLfY5SqZQwo+3s7MTi4iISiQR6e3sLZPD0mezr68P169fF/9MibjKZ0NbWJh7IaPGla2Y0GiFJEpxOJy5dugSTyYTt7W2cP38eRqMRzzzzDPR6fcFQyI2NDZw6dUo8pJGJ7uzsLOx2OxKJBKLRKD772c/C7Xbjj/7ojyp+LpSA1JEajaakpNvv92N2drbhmVDpdLruMTq1oJ4xG8Dd06QL3KUEZbPZ8JnPfAbvfOc78bGPfawhxU2lCIIczru6uko2rVK/SCP7zmazoomy1n6IaumyZDKJ8fFxEV0Wf0nrJShqkh0fH8eJEydqsooqdcw0jr27uxtLS0vo7e0VRWPyy/P7/eCcF4x6J3sfcu0G8g8U29vbcLvdBY24JE0n9269Xg+v14tbt24ByNebMpkM1tfXC/qkaJu0nb6+vgL7ouLPBH0eSMQxNTUFrVYLr9crZoAVkxGJFbxeL9bX12EwGNDR0SFcJ8LhsCDd/v5++P1+9PX1CQKLRCJ4xzvegUgkglAoJKb0Anny8ng8QvxB1kYAsLCwILwVSR0J5D8XWq1WkIzRaMTW1hYuXrwIq9WKdDoNm82Gf//3f8fFixexuLiI/v5+2O12PPTQQ3j55ZdhsVhgMBjgdrsRCoUamtRLKCfFlku6yfuQZkItLS0hHA4LFSJZE1VaM8hAd69xrzfpAncZQXHO8eUvfxlf+tKXcP78eXz84x9vaHukoisO55U6nFcb+10J1HtEKp56/ADLuVkAwPr6OhYXFytaLdUzcoOOm3OO0dHRmsmtuH71/PPP4/HHHxemqH19fejo6EAymRR9NZlMRvjp2e12IdKgkRK5XA7xeByMMTE2Qw4iu0gkUjCdV96uQH511MdjMBjEEMK1tTUcOXIEjDGsra2JceuSJBW4OxgMBqGgA26LJXK5HDY2NoQyUC5ssdvtIoVHT9NycpJfdyD/dE8u7aSCI988ID+a5tlnn8XKygouXbqE/v5+rK2tIZlMCof39fV1Ie4hJers7CxOnjwpIpTr16/jwoULWFlZwenTp/HDH/5QzAEbGhrC8vIyHnzwQWxtbSGXy2F5eVkQwOjoKF5//XWhRjQajfjsZz+L0dFR/PzP/3zdD5RKm3RLzYRKJpMIBoPY2NjA1NQUGGMFSsHiIZb1Op3Ugnp9+A5CH5hS3FUE9fTTT+PmzZt46qmn8Du/8zsNb4+EEnKConSb2+1WnG6rtY6zsbGBhYUFDA8Pw+fzNcUZnPZPdQSNRlPVaqlWgvL5fJibm/v/2fvuIDnv8v7P9t7Lbd+9fqdTP8sFd4MpsQGLoRibMRlMTJzMEDww4yRACmEIOGCSCUkIE8NQDXZMsYHENhhbNi6yJKuervfdu+29t98fx/Po3b3T6e4kK0Y/nhmPrbV29923fJ/v8zyfgp6eHl4QNxuUcADgsccewz//8z/D7/djcnISarUag4OD/BAqlUo0m01ks1l0dnby0D6TycBoNLJvUj6fZ2sIsViMXC4Ho9HICxq1wITJQ61WM4zX7XazigNVUST5Q6oO+Xwefr8flUoFoVCIEy1Bx0lMlmZT9FuFkc/nGdwgPBYKUlhf65oVi0V4vV5uDwJngBnC+4cWWlqgCSyRSCR4t14ul6HVarlVRxuwWCwGh8OBXC6Ht7zlLSgWi7Db7Zibm8POnTv5mCl50++nllMsFmPzRrVajXQ6jePHj/Om4uGHH8Ztt922pc0YcH4qEkqlssUTirT0EokEa+mR+GupVLooM6hyubwlq/dLKS6pBHXbbbfhtttuQ7lcxtLS0nl/HiUonU63rurEerGZNpkweRD3KJVKbZlsC5yp4iQSyYaRdO3Hfq4gHb1qtcrHvbi4uKX2IFU8zWYTR44cgdVq5aH0wMAAz5aUSiWSySTEYjEvcARAoE0DCZhS25BmUiQSS4g9qVQKjUbDnJ54PM7cIoPB0JJU3G43VzTtCUaYVJRKJQqFAsrlMreEZmdnodVqWYOuPYlrNBqebRG6TlgBz8/Pw263r7nZMZvNSCaTcDqdrDKRSCTQ2dnJ56tUKiGXy+HWW29Fo9HguRn9jkqlAo/Hg0wmw15QwEripHlTKBRi4AOBPeLxOAwGA4rFIvbs2cNtRIVCgenpaYbEl8tlLCwswGKxIBqNwu12o1QqIRQKcbX73ve+F0ajEe9+97vxwQ9+cFP3DimBXIhYS0uPflcmk8Grr77aghQkBZILGVupoIBLh6QLXOQEFQgEeDGRSqU4dOgQEonEBTMupJDL5ajVahfEuLBcLrPqwdlUJ871GcS7WS+I09GePM4XaEFk3WAwiGKxuClH2o0kKKGOntDwb6Mgk/aQSCR49dVXce+998Lj8cBgMGBhYaEFAUefazabmdXfbDYZTkwWE8VikastlUoFrVaLfD7PorD0GTRUJ7ACgWxIkFUYws0CVQHAikjsWki79iCIuEql4l17sVhELBbjhCASiZDP59HZ2bnq2mcymVXctsDvLDKAFTRpZ2cngJWENzY2BmBlhra4uMjfkclkeKYlEolYtUSn08Fms3F7s7+/H3K5HMvLy1haWoLb7cZLL70Ej8fDiU+n0/E1SSQSvDmJRCJ8zaanp7Fr1y5EIhHmLZFeIbU+xWIxb8oOHDiwpQT1eunwCSWaIpEIrrzySlbWGBsbQ6FQaEEKXggTw/NRMr9U4qJXUL/5zW9aDNjIuPAv//Iv8cUvfhFf/OIXz9sXSiQSQaPRIJfLbcoDqT3kcjlCoRBCodCWkID0GeQjtFbU63VMTk6iVCqtmTxkMtma7Z7NxIkTJ+DxeNa1eF8r1ktQwjncWg69WzUtrNVqOHz4MAYGBrC0tMSwZ5pByWQyqNXqlmOjoXc+n+cdr0gkQrVahc1mYzkhgpzTjMtgMPBiSQKrwJnWWLthodvt5pmS3W5nGSpCEFIoFAoYDIYWZ9t2ySra+GQyGW5PCgE1pJ5AckI0UyPaghAe3k6HoCSq0+n4eJeXlxndSImYFvNIJAKFQsGJWbjIkyqLy+VCNBrl80Eq5zMzMzybs9vtWFpaQiqVYtFcuVyORCIBt9vNun7UxiXlDaEJY61Wg0aj2dLs9mJYbVBFK+QgEWE7n89zS5DoD+3ir5uJzervXYrxf14L/uxnP8OHP/xhACvGhT/96U8vyOcSf2SrUSqVGLa7d+/eLaN21kPypdNpHD58GDqdDjt37lyzsjmX3NHZotlsYnZ2FplMBj6fj5Fvm4mzJahisYijR48CwFkdejeboJrNJiYnJ/EP//APCIVCrCFHMyJS9qjX61AoFKxIXigUkM/nIZPJuJIiPhTtPqn9QmKmBoMBg4ODAM7whoRB18vlcjEYQalUIhgM8rVQqVRMwm7f5ZJpJoXf72/hKrWDZwqFAnp7e1sqMFJeB1aqawKAUMzPz2N+fh5arbYlEQIryairq4uNCoGVa1atVjExMcG8KAKZACsqFfT9VIU5nc41/aS2b9+Ol19+GQcOHEAwGEQymcTx48dx+vRp/p1qtRrxeJyV3Ov1Og4fPoxCoYDDhw8z8lKv1/M9RteIbEA+/vGPIx6PY6NxMaw2zlalUeXu8/mwa9cuXH311di2bRvfNy+//DIOHjyIiYkJxGKxc3YmttL9WUuB//c9Lmp6FolEeOtb3wqRSISPfexjuOeee15348KhoaFNvU+oFUdtkfNBxazVohNyp9Yy/BPGZi03gDNCrEajEW63e8u7sLUsN9bT0RPGZlx1afb28MMPo9lsMlGVVBwkEgm3Suv1OvL5PGq1GhQKBWq1GpRKJYrFIpRKJVcq1CaWSqVQKBQwm82IRqNoNBpcUQErFuyUkMhwj5KLMIm0E7fJTLBarXIreD3EJIVKpYJer2+5zyuVCsbHxyGVSrmF1D6Ep5mbMKiSlEgk8Pl83Cp0u904ffo0gJXW3uzsLCQSCSdUWmBnZ2ehVCrR0dGBaDQKpVLJPC1q8ZHrb71eh8fjwcjICObn52EwGBhhqFKpkEqloFarmYuWy+XYa6ujowMKhQJ79uxBoVDAjh07EIlEuCom/7X2e+bYsWOb2uRcDKuNzZB0zybRFI1GWS5LiBQUfu5Wf8ullJyAi5ygXnjhBW6T3HzzzRgYGGj5///XxoVkJiiTyVh1Qkii3Eq0a/oRedVms53V8E8Ym6mg1kogwl3/ZkOYoDaio9f+3o0sLqQjRoKiarUay8vLUKlUsNvtvAADKwsyWVoQ3LlWq3GyoqRDvXuLxcICm8LdpcVi4daVwWBgsIJKpeLkJNyUUIuGEpRSqYRGo0EsFkMgEEAikeD2FaHshBB/YQVttVpX3ZeksUcuuUajcVVLkAzv3G435HI5k1+Fqugej4fnPRTU2pPJZPy68No5nU6unEqlEpaWliCRSODxeFoQgcFgEIcOHYLdbofNZkM0GmXOFVWQCoWCZ32pVArDw8MYGRlBd3c327WMjY1h586diEQi6O7uxuTkJAqFAmsjClXYAeC//uu/cMcddyDwO++q9eJiWG2cj4rE2SSaSLm9VquxmaNcLt8ylP1SSlIXNUG53W4AK/37/fv34+DBg6+rceFGfaGAM2aCXV1dLTOy8w1q8a2n2LBebFRPj8wKKbnSIiSTyVa1gDYalKA2i/4Dzt3ioyoyk8nglVdewZNPPonu7m5u62k0GiaPNptNxGIx9ieq1+usv0eyNY1Gg+G/AwMDmJ2dhU6nw+zsLJNCgZXkIlS7p7ZfLpeDXC5nB+J8Po+5uTkeeC8vL6NYLLI3D5FxiT8FrCzifr8fExMTUCgUUKvVsNlsjF4DViOsCK1HkUwmYbVakU6n4XQ6EQ6HIZFI+Jip5eh2u1edX4J1C4N8roh0G4/H2UeKOFxCWSv6TcJFTig6SxJI0WiUv0un02HXrl0IhULo7u6GUqmEWq3ma1IsFluMKBOJBPbu3QuVSoV6vQ6lUompqSmG0VP1UKlU8OSTT2JiYgJf/epXYTQaz3o/Xay4kDJHJNFE602j0WB1j9nZWZRKJRw/fnxTZo6XEoIPuIgJKp/Po9FoQKfTIZ/P46mnnsLf/M3f4F3vetfrZly4kQqqWq2uayZIi/RW22QKhQLFYhGvvfYaq6hv5iZaj2xLsZZZofD4t1pBicViZDIZ1Ov1TaH/ALCI6FpRKBTYC+r555/HxMQEOjo6WGBVqVSyuyuh9ki9gVQNVCoVa8o5nU5UKhWunCh50Hmz2+38GplAktozKUeQCgUdC4EeyHmXqmCTybSqPUchrMbK5TI6OjowOTmJZrMJjUbDSERhtCP/CE1H1TCpGrTPYpLJJCqVCiwWC6RSKeLxOPL5PNRqNQKBAMLhMIrFIjo6OngWS9ePfgtpBAJnFstms4lIJIJyuQyVSoXvfve70Gq1CAQCDL+n36BSqeB0OlGv1zEyMgKfz4eTJ08i8Dt3XWqRjo2NoaOjA7VaDddccw0KhQIikQgDbEZGRpjXRooetVqNE+fMzAx+85vfwG63s71EO7T7UrDaEEo0UUVJ9IG1zBxJMYXifFHLb8S4aAkqHA5j//79AFZK2zvuuANvf/vbsW/fvtfNuFCoR7ZWnA3aLQyaL2wlQdHDnsvlsGfPnvOSR1nr5iMEYLlcPqvnFO34Nxu5XI7nGLt27doSwKJ9hy9sQfb19eHf/u3fUCgUUKvV2L7carWiVqu1LD6EviPqgFKpZN6M0CRQqEBPbTOSi+ro6EAqlYLVaoXBYOANEyWiQCDAcwHapBAnK5vNsiqDQqGATCbjxKZQKOD1epmEKkw4ws0FKYmPj49Dr9fDaDSi0Wi0zJWo0hP6PUml0lWJnmZuwEpFQ/duqVRi1B4h8oTvpbZRpVKBzWZrmanVajVuByqVSkQiEZw8eRLbt29HJBLByMgIhoaGWFGD5saRSIRBMtSWpIp9YWEBJpMJV199NTKZDBOYT548iYGBAUYpVqtVNlGMx+OsBk8ivpSshoeHEQwGUavVMD4+zhqK1IK9GItzpVK5KORZ4l/q9Xro9XqWaCoUCi1mjiQXRQnrYtjdX8y4aAmqq6uLhSqFYbFYXhfjQo1Gw8Z1a3nzTE5OolKpnNNMkBa9jaiHC4PmWdSXP5/kRIu9MEkK+Ud9fX1nfTg3a7lBho7hcBiDg4MYGRnZ0oPf3uITzrB2796NkZERnseR8KvL5UKhUIBGo2FEFu1Ym80mK41T20qlUnGCMhqN3PoDwA6xEomEK2mv18ukW5qjUNBibTAYeLBN500qlWJxcRGBQIAt3N1udwv4wel0otFoMJSbKjoKuVzOG6ZMJsN+TZVKhblQarW6Bf1HNhWkUlGv1xGLxaBUKls+W6vVsi4eRTAYhNPpZBNGQnWKRCL09vZiamqKjRez2SxKpRJKpRIajQbUajWef/55/hyPx4OlpSWoVCrYbDY2syS+Gc2qaKOQSqWwb98+JJNJdHd3s0Ek/b3du3ejUqlgcHAQy8vL0Gq1LDZLyZ54UUS8/vrXv45vfvObMBgM+O53v4uAwH03kUiwYv6RI0e2LAK7kbiYSubtowaiz2g0mhaJpmQyieXlZczMzOCKK6543Y/tYsYlC7In8mG7bta5XGjbY7O2G8CZeVZ3dzcsFgsOHTp0Tm+X9YJ+B+0q1+MfrfXejSYo0tFTq9XYs2dPi8PsZkOYoOic+3w+WCwWHD9+HI888gji8Th8Ph8ajQampqYgFouh1+tbZk8EOBCJRHC5XNyyDIVCcDqdmJ+fZ04KVTpk2U5K5xS5XK6lovT5fDxvKhaLDAenJEZEVgphddReUQvNAwldl8/n4XQ6oVAoIBaLW8ALQn28cDgMv9+/ivtjNBr5M6lNR5Wc8FhSqRS3ECORCIrFIsxmM5aXl7m9SFXbxDPaAAAgAElEQVQNJUNgZaNGn0ttOWqvveUtb8HRo0c5IQ4NDWFychLpdJpbv9QqpI0AyQHt27eP4eUqlQrZbBaNRgPDw8NYXl5GIpGA0+nEK6+8gu3bt7O1CLCyQZifn4fb7cbS0hInKQKQCJ9lofuuyWSCRCJBb28vO85SO5IqDIPBcN4ginbps9crNkrSpWqWNkh/aPH9HgXZDnR3d68yE9woQ1upVLbsTNcL4pk0Go2WeRZBzbfCCqf3V6tVnt1YLJYN6wBu1KFWqKNHPBmKrfS2iYw5NTWFTCaD7du3QyqVIpfL4cc//jHK5XLLTJIIszRzqdfr0Gg0EIvFrPRNXkJOpxMymQz5fJ6ljqjCyufzKJVKLFUkPA8ymQxOp5Mrhfn5efaIIrM/4TVqv17rOea2W2xQYgmFQggEAlhYWGDIfzKZXHVNaBEn2HuxWFzzujWbTaTTaXi9XmQyGaTTaeh0Ok52Xq8XCwsL/LuAlRkckXHD4TDUavWq+4LOP4EwCoUC/H4/gzMWFhY4OczOznKi12g0yOfzcLlc8Hq9sNlsSCaTbEtCSaxYLHIlRd9BGxCqoGmzQs/nwsICZDIZy1JJJBLodLo1lc8JWEEagwTIElYYBGU3mUxsk77Z1v3FqqC2mgj/v0pQxGYPBoOYmJjAyMgIE/KWl5eRyWTe0CeEuFBWq3WVmeBGQ6FQbIgsSDtvv9/PMFKK801QUqmUVRX6+/s31QM/12+t1WqYmJhArVZbEyRCC9lmd54ktqnT6TA0NASRSIRCoYAHH3yQZwjbtm1j5Fm9XofVaoVarWalckpM0WiUKwCFQsFIP9KEK5VKDIIIBAI8h1EoFPB4PMjlctw2JNIrtfcI9k278VwuB4PBAI1Gg2q1CrfbzZD2XC6Hjo4OdocNBAI8dxFuYtrPIc1ZgsEg+0vlcjn4/X6Ew2Fur9FniEQibhW2R6FQQDabRTab5bafsJoKBoO8IaOYmZmBwWCAxWJBOp1mZXfiiiWTSSQSCRQKBW4rAiuAkIGBARw9ehTVapXnIplMBgaDAfF4HC6XCyaTCR0dHcjn8zz7y2QyuPzyyxGJRLC0tASXy8V6iR0dHew8/Oqrr7J+Xy6Xw9TUFM/PqHIiVCFB6O+66y782Z/9Gd7znvfwbzwbSVdYYQBnuEixWKyFi0QJ61xJgUAcFyM203G5WCCRix3rJqg9e/ZAp9Ohv78ffX19GBoawl133QWbzXbeenkXI9xuNx566CE8++yzuP/++7ckJHku63dhZXY2pNv5+EKR8KeQm7WVWKsKojmWx+M5a7uTwAkb/V4hEIISBLVbH3vsMa4Et2/fziABWjwJLEHK4bTwGo1GFAoFSKVS2O12LCws8AMZiURW2bBrtVro9XqeeTgcjhZ7Cmr1kCqFQqFgcVen08mEV6qKrFZrCzRd2Cbs6OhgtBzZdLSDQ9r1+2gmRo62wWCwJcGRnYZwBiEWi+F2u1uQqaQ0TvNWqgxJfdtkMjEIQ5h46DolEgn4/X5ks1ksLS3xjGzXrl083xkZGYFGo2HgBiUou92Obdu2wW63I5VKMfCEzkuhUGBoOW1OvF4vnnjiCf4727dvx7Fjx5gisWPHDkSjUVgsFgDgpEXiwXR/1mq1VQCojRJb1+IiJZNJJJPJVarlJpNpzU3l670p32qr7lIyKqRYN0GNjo6ueu1v//ZvsXfvXuzYsQMul2vLVcHrHceOHcNDDz2E/v5+fPazn90yTHw9sVZa4J1O57qVGSGnNhvUdrNarS2yNJsNWoyFmmcbnWNRgtoIxFwIhNi1axcOHTqEYDAIi8WC73znOzh27BhCoRCq1SoGBgYgk8mQy+U48dAcwWKxQCwWI5vNwuVycbuMrNR7enowPz/P0kYEbCATPRI9pZDJZFyRSKVSnruQjQewAtDIZDI89xC2v4RKH4QqE/6/cDjMlRRxjaxWK7RaLaRSaQvZmxIhRTgchl6vh1arRSwWY5BIPB5HOByGTqeD0WiEWCxepX5uMBgQDocRj8e5tSeUWZJIJAgEAhCJRFhcXITZbGZ4PkUikYBarWZLElIoJz8sshUhNfRqtYorrrgCPp8PkUiErwHd3zRXFIlEmJub48QVj8dx8uRJOJ1OJuzmcjmYzWZWAalWq7j88stZyWJgYAAjIyMAwG0+esaeffZZ3HvvvZyUtqq8QJqBa6mWLy4uolKpMHn2YvGwtqpifqklJ+AcCSqZTOLxxx/HyMgIEokE6vU6nnrqKTz66KO488478Sd/8idvyAT1P//zP/j85z+Pz3/+8/jZz352XoKLa130zQIV5HL5hudYwOq2Wy6Xa9nBbzYIWCCVSlkGaaP28Ru13GgHQgDA8PAw0uk0nn32WTz99NMwm82oVqswmUxQKBSQSqWQSqVwOByoVCoolUqYm5uDx+PhpCSXyxkSbTabkclkeFeu1WrZwXVxcREajQaZTAYulwupVAoikQg9PT2o1Wosb0RtHQAtVZWw6nG5XFheXmZ4M20MtFotk3aBlXujXX6IZi6xWAxyuRzz8/Ow2WysgiE0IARW2ktLS0v8GimRU1A7r7u7G0ajkSsZg8HQcl0WFhbQ3d3dUiURwIHmONSqpo0AOevGYjGo1Wr09PRgYmICp0+fZlO/9uOkayf0wQJWgBqkZEHn1eFw4KmnnuKE2NnZiVOnTqGvr485bXQtXS4XRkdHYTKZ0N3dDZ/Px55ULpcL8XgchUKBK6lEItGSlC6U1YZQtRxYedYzmQySySRGRkaQz+dx7NgxBl5shDy72fiDivmZWHfl/vrXv47HHnsMH/zgB9HT08MtJqfTiU9/+tMX6xg3Hddffz3e8pa3IJ1O42tf+9p5fx61bQjxNTo6uimgwkbnWMDKgz4+Pt6CMrwQlhs0E9qIjp4wzpWghIoQBIQQi8WMvvvRj36El19+me0HnE4nDAYDD+xrtRqCwSBcLlfLQN1isXBrcGlpCVarFaOjo9Dr9ZidnYXZbIZarcbU1BSazSasVisDLKLRKAwGA+x2e0t10y6XU6vVoNPp4HK5EAqF0NnZ2XKunU4nVy5GoxFWqxVzc3NwOBxsKU9cqGQyCaPR2AJdJwQazcT8fj8ikQg6OjqYaNteFS8uLsJoNMJgMHCL0+/3Y2ZmBs1mE2q1mlU22sWQS6USFhcXW9671vVLpVIwGo2sVEFB7VOz2cyVi0ql4kRw2WWXwel0trgEFwoFmM1mVssge3WZTIbR0VEEAgFEo1HEYjHEYjG4XC6IRCLs3bsXmUwGuVwOyWQSMpkM119/Pex2O5599lmUSiVec6iSo1Y5PXPve9/78NGPfhT79+9/3XT4xGIxg3csFgvbAq1FnjWbzRfEZmOrTrr/3yUog8GA97///fjkJz/Jr919993MBTmfk1Kv13HZZZfB7Xbj5z//OWZmZnD77bcjHo9jeHgY3/3ud7eMlqGdlNlsRjqdviC+UKVSCYlEAsvLy5syLAQ25um0noDsZrlM7SEWizE5OQmVSrUhHT1hrJeghKhCAkJQK1IkEuH73/8+nnzySdjtdszMzEAul6O3txcWiwUajYarqHQ6zQs7zaK0Wi0ymQwnIFpUC4UC3G43yuUy80K8Xi/i8Tjm5ubQ2dmJXC6HdDrdgrqjas1qtTIQgtBspPZAyDVa+PP5PHK5HEQiEbv0ko27QqFogaD7fD6USiUEAgFks1nWWRNGNpvl2YzJZILf72+prFUqFUqlElfLGo2GqyaauVHybg+n08nnUCQSsZTR7OwsI/R0Oh3i8TiKxSIDbUiXUCQSIZVK4ZprrkE2m+UEpdVqGUTh9Xq59UnIPZlMhmAwyLYgzWaTF26S7aH2mdPpZCBMPp/Hyy+/jMHBQYaKNxoNLC8vo6enBydPnoRUKoXP52MRX6vVikOHDvE8MpfL4d///d+xf//+i2JNQZSVdvJsPp9neaJsNss2G2azeUtcrK1WUJeazBFwjgR1yy23YH5+HqOjo3juueegVCoxODiIO++8E8D5lZT/8i//gsHBQd7d3n///bjvvvtw++2340//9E/x0EMP4d57793y5wPg9sH5ikhKpVKMjIzAaDRuCahwrgSVz+dx+vTpswrInk+CSiQSiEaj6OjoQG9v76bfv1aCajabWFpaQjAYRG9vL7c5CO1WrVbxv//7v3jllVfg8/k4IXR0dDBUmDT+gBXSbCKRYO4T2WgoFAoGHxDHKRqNcnsnlUqhUqnwAkGViUgk4nYXiawajUZMTU0xQo5QfwT2oXMubPUJKQZ2u72lNWcwGFoqCZFI1PJn8j9SKBRIJBItVQ2wsiEhiS2r1cpSTnRcwMoGwOFwcHKlcwSstPRoUa9UKlhaWuIklkqlUC6X4XA4Wl5LpVKw2+3Q6/UtLsEkGOt0OvmY6J5zOByQy+UIBAKoVqstSZ9AKFarlaWW5ufnEQwGkc1mGeRBYAyy1iAU5oc+9CE0Gg3EYjFUq1We3ykUCtx8882siH7kyBG86U1vAnDGhoQ6C3S9/q+UzIVcLOKoFYtFnmHRbyXQBVX560WpVNqy7f2lFusmKL/fj0qlgi984QuQy+V44YUX8IEPfABHjx7FPffcs+XKZHFxEb/4xS/w6U9/Gg8++CCazSaeeeYZ/OAHPwCw4gv1d3/3d+edoIAz3jzEvN5MECItHo/D6XSiu7t7S8dwNi4SqTacqyrbiB5fexD5NZ/Pw+v1bjlBS6XSlkWpHQgBgFt6JA30gx/8AP/xH//B7sMEGJDL5YzOo8W7XC4jl8vB6/VCJpMxfFoqlSIUCqFUKqFQKECn07XAgoXWERqNBjqdjl1NzWYzGo0GI95ICUIonQSszBv0ej1XOgGBM63ZbG7ZVJDaOABOhBQajabF5VYkErXMt0gr0GazIRwOM2eLIhaLcRIShs/n424FsDIbE4vFjGAjhYlKpdLyfcBK0shmswzppoWcXIeFGw+VSgW5XM7JCVhJwLFYDCdOnMC1114Li8WCUCiEfD4Pn8+HcrnM7UESxiVxZrqP4/E4+vr6mBA8OTmJffv2Qa1Wc4uy2WzC5XKxUoXL5WIrE4VCgbm5OUbHvvDCCzxz7OnpYS+v+++/H/v373/DWG2oVCq43W7mYpXLZSSTSYTDYX52hDYb7df9DzOoM7FugiqXy/jrv/5rXHPNNXjPe96DW265BXfddRfuvPNO3HPPPVs+IZ/4xCfwwAMP8EMdj8dbSHMej2fVA7fV8Pl8WFhY2HSCIugrEQnPp8UGnEkydM7K5TJOnz4NjUaz4apsoxsCkhDq6OhAT09PC49osyFcyKjv7vf7eYhMRoHAyjn78Y9/jNHRUfT09PAcql6vo1arMTqvWCxCKpXCZDIx6o7cj0nh+tSpU3zetFott/4KhQLkcjnUajX0ej3K5TJL+ABnyLTC620ymbj95fP5eIH3er2MjCPUGQUpoQMrun7CBETIPeE5ElZXxOOhIHNFAKwY0T6TrNfriEQi0Ol0TDhuh6sTcEEIH0+lUqxJSK+1Pz8ikYilnVKpFAqFAreQs9kscrkcwuFwCwhj+/btGBkZgdfrbamcms0mJ3ESbCUvqLe97W148sknkc1msW3bNohEIszOzqJQKGBwcBAnT57E0aNHMTQ0BK/Xi1qthnQ6jeXlZeh0OlSrVeRyOeapicVijI2NoaenB88//zxkMhl6enowPT3NiZZaoj/84Q9bjChfj1jPGXu9UCgUcDgccDgc/DmpVIq1QKkFS8CLUqn0hwT1u1g3QSkUCoyMjODRRx8FsNLyCAQCLFi4FS7Uz3/+c9jtdgwPD+PZZ5/d0kFvJmimcNVVV234Pe3q4KlUqqV9s5WghV4mkyEcDmNubm5N1Yb13t+ux9ceQh09oaXH+bQICQHYrgghbOkBK+2ehx56iBc4t9sNjUaDYDAIhUIBi8UChULBg+6Ojg6Mjo6is7MT+XweOp0OS0tLXGVRSymZTKKzs5PBDm63G8lkEtVqla0zSEGA2sVOp5OTENm4CM9PvV5nAAOwUhHR+8ViMStYkBAsKTNYLBbIZDI0Gg1u55AWHIXH42lJTtSKopifn+dZFs2rdDodV3vUUqS5mjAKhQK31dRqNev3UTKiJLSWDBMdP50j4klls1lEo1EWajUajRCJRIjFYhgaGoLJZGKeVnubUqvVcmVaLBb5t5K0UigUgtfrxcTEBMbGxnDFFVegs7MTlUqFN42lUgnlchkmk4ktVag6bjQauOmmmxhQQ61ZqVSKiYkJiEQiGAwGnisePnz4dU9QW/VoEoZcLofdbmelk3ZfqHQ6zYadZ+NiCeNSJekCG5A60mq1eOmll3DVVVeh0WjghhtuwI033rjlltFvf/tbPP744/jlL3/JkjR/8Rd/gVQqxYPOxcVFLo/PNwKBQEvrYr0QwruFIrLnIutuJGhXTIvJWqoN53o/6fGtFcKKjHT0KM4nQdVqNUSjUXi93lVACEpOr7zyCp544gk2GyQnXBryVyoV2O12XsisViukUikrNhA3yOVy8UwiHo/DZrPB4/EwiIFEWGk3T7/R4XC0EDcjkQi0Wm2LnTl9TzQaZZg1CaqqVCrMzs7y/VepVDjplMtl/j6aaVFlYzabUa/Xua1Yr9dXXVNCCAqjWCwypJ6QmsJFRi6XMxnZarWiWCwin8+3mBhSG01Y2dGsca1rTXqFpFRO39PT08N8x0ajwUK0brebAR3026vVKlcQlUqF7Tai0SiTaW+77TYkEgmcOnWK6Rh2ux033ngj6xVS8l1cXIRUKm2p3AgZ6fP5mBdWLBbhdrsRDAah0+lQLpdRq9Va7ivhPOr1itdLh0/oC9VsNvHiiy/C5XIhkUggGAyiXC5Dr9cz8IKqR2FciiRdYAMJ6tZbb+UH4+Mf/ziSySTuvPPOLUvO/+M//iP+8R//EcAK2e7LX/4yvv/97+N973sf/vu//xu33377BfeF2oha+noishciQTWbTXYXbZdC2kisl2TW09E713vXO96lpSWuHtxuN88uhMlvdnYWTzzxBKuLKxQKFu+sVqu8kC0uLsLv9yOfz6NcLvMiEw6HmWibSqV4MReLxS2oJLFY3GLuJ5TDaTabsNvtjKAizyitVtuiOkGbA2oV0ms+n4/bmBqNpqUiEgJEqJ1FQZB3YIW0HQgEMDMzA51Oxy034ayKZI6EFZZcLmcQQaFQYE4S3W+xWAx+vx82m63lfZlMhkmyFEqlEqlUas1ns1qtchI3m83I5XIQi8U4evRoS9uK2q5EvhWJRC3k3kKhwEoyJH5Lnmcej4df6+npQX9/P8LhMEPTadO5sLAAq9XK3x8Oh7Fjxw6YTCZUKhVW86D/Xlpagt/vZ8UWEuMl0WBSA3nqqadw1VVXoa+vb9XvvxBxMXT4COxB8ylgZeOQzWaRSCQwOjqKYrHIzxjRLS5FBB+wgQT12c9+FqVSCdlsFtdffz1kMhlisRhqtRr3VC9EfOlLX8Ltt9+Oz3zmM9izZw/uvvvuC/K5gd8JdZ4t6vU6ZmZmkM1mV8G7KTYquLpWEFiBUGhbSU7A2kjAc+noUWyUbEtRrVYxOjoKqVSKnTt34siRI1heXobVauUHtNFo4JlnnsFzzz0Hk8mEeDyOgwcPwuPxoL+/H8888wwcDgdyuRxzmmjXS+2lfD7Pw3xKWr29vSiXy+yjRQnXYDBgcXERarWa51AkE0TXl1BgwEpSFrajDAYDJ5f2h7lSqXBCUSqVDFWXSCSQyWRsoqjT6VoSlPCeEM6wMpkMW7cLva46Ojpakgy1j4mMC6y0RsVi8SoCMFUiVP1YrVaeBdE5kUqlKBQK7Hsll8sRiURWWYvQ36d2ImnzkdZdT08PlEol0uk0J0qDwYBKpbJK8BUAV1zBYJArXYLcE6Q+Eolwu1ev1+PYsWOYn5/H0NAQGo0Gjh8/DpFIhMsuu4y9qWjjIBKJ8Itf/IKvq8FgYAUSoiDUajUolUp84hOfwH/+53/ywn0hqwqy/ng9Yy2ABFW/BoMBnZ2daDabzB+bnJxELpfDvn37Lkj78Y0W50xQx48fx6OPPsqw4JMnT2JychKf+9zn8LGPfey8xBNvuOEG3HDDDQBW/KIOHjy4pc9ZL4T8kPbIZrMYHR2Fw+FAd3f3ujczwdU3c4MKwQo0U9lqkOUGBfWpN2Ibci77dWGsBYTYtWsX0uk0JicnWZbmyJEj3PJqNBo8b5BIJFheXobFYmHNPbK5mJmZwdzcHMscdXR0cFLN5XKsn0cq2jRzCAQCkEql0Ov1XCkSlFnY8iRl7VKpBLVazdbp+XwecrkcUqkUWq0WdrudJZgajQajrCwWC/L5PJaXl9HR0dEydzSbzZienobBYIBWq4VKpeJZCbB6A9HR0cHVFbVICb1G1Qht9oShVqvZfl74edQeM5lMDIygKBQKMBgMjGQk3yhgpcoTekwBKy1QQhbSZxM3ye/3I5VKQSKRwOv1olgsIhqNIp1Ow2azwWq1YmxsDMBKkqQd/09+8hOuovx+P7RaLf/++fl5SKVSdHd3o1Ao4IknnsDAwACcTieDYYaGhjA+Ps5zsBMnTqBer6NYLGJ+fh6dnZ2Ynp6GQqFg9N/Q0BDGxsa4ik4kEjCZTHjggQfwkY98hD2raJaj1Wrf8G2wjZB0iQyt0+ng8/nOOZv+fY5z/qpqtYp4PI7BwUFcdtlleP/7349XX32VeRRv9AtOw3BhciGrhVgshm3btm0ImUN6ehtB1xDSKRqNYnBwEBqNBslkclNyR+0hl8tRKBS4r59MJs9a8W0l1lKEICCEUqmEwWCAz+dDPB7HN7/5TSQSCdhsNvbvKRaLzFsql8ucjEulEuubaTQa1lqbnp6GRCLhwbvX6+WFlPrpVKEQ+ZMgyXTvkRIC8Z5qtRrzTCQSCXtFeTwejI+P84NNM0mtVrsKjUcLe3tLl+ZQVJWFQiF296WWHsGwzxbj4+NQKpVcray1YUkmk7yh0ul0XF1SFItF9PT0rPIoI6ff9rDZbC2zKwBs4ii8l00mE/r6+loQhELIPbkYE2mYgBQejwepVAo33ngjfvnLX7LklNPphNFo5IrR7XZjbm4ONpsN27Ztw9jYGOr1Ovr6+jA+Po50Oo3u7m5ks1mcOHGCJaFmZ2fh8/kwNjYGh8PBnQC6L4FWcdV4PM6fpdVqmSM3NTXFqvZbUX2o1WoXpY22FYi5UI7rUotzJqjh4WEMDw+3vOZyuXD77bfjn/7pn97wCYpsBRKJBKxWK6sfmEwm7N27d8M3Hc2hznXzFItFluQRfv6FkCsqFAo4evQoTCYTdu/evakHph3mLoz1FCGE39FsNnHy5EleEIrFIoLBIIrFIrq6umCxWHDq1ClukdlsNpjNZjYEFFYlXq+3xQySrN9JOVyj0fD8gpyR6TxQFUJq3haLpYV46vV6W6DQNHtpNpsti337Q01VpkgkgtFo5IVdIpG0tPYUCgUfT6lUQkdHB3O0SBKnUqm0tIYpEZZKJbbwaE8c7TJCJpMJDoejhbxbLpcxMTGxahZClROpU8TjcW5rqtVqWCwWTkpkhCg8F4lEgnlh7feJyWTC8ePH+c9qtRoKhYJbdxTvfe970Wg0UCgUWGWDlMGpjRiLxWAwGPC2t70Nv/zlLxGJRLBjxw7E43GcOHECHo+HbXJ8Ph8rqdvtdkilUhb17erqwpEjR3iuR/D5RqOBUqmEz3zmM/jKV74ClUoFtVrNtAMi0QpVH6jCWk/14UIh+M4VfyDptsaG68KlpSUoFAqYzWYMDg7i0KFDAN74FRQAbhXlcjlEo9FNeyoB5wZKCG0m+vr6Vikfn4/lBpnUxWIx7Nq1a0v28e2K5vS5pAjR19fH6CAht0kYP/nJT/Dqq69CJpOxcOrBgwcZLivktZHVdzweZ3dbWnSWlpaQyWT475PidbPZRCwWQ0dHB6uKB4NBuN1uhmSTJBGpnOfz+VWVg3DeRosKLW5ECK3VaqyQQAsVAO7xk+IEfXaxWGQ4cHvlI6xmisUiZmZm0Gg0mK9Vr9eRzWb5WSkUCiiVSgzsIE3AdrRfqVRi2xL6TmoBlstl2O12qNVqSCQSzMzMMP0DWKl6COYPrIBB1Go17HY7J+9ms4nu7m52sCVRVIVCAZ1Oh3Q6DbPZjGg0yqaCBII4cOAA5HI5tm/fzh0IuVyO6elplp+ijcXTTz8Nh8PBUkmVSgXZbBZutxsKhQKvvvoq1Go1+vr6cPr0aezcuRPASpXa3d0NiUSC48ePw+Px4NixY3A4HPwb+vr6UC6XMTc3h46ODp5fnThxAseOHcPg4GBLMlcoFHC5XKsMDdsdeM1mMwwGAyesarV60YwK263eNxK/D+vwVmJDCerw4cP43ve+h3g8jne/+91461vfivvuuw9f+9rX3pBq5u1htVrxqU99CnfccQfuvvvuLZXD6yUoobrC2bTuNgtUaP9sIqxuJTkBZ5B8dGwEhJDJZKwIIZFIWBGiPRqNBo4dO4ZGo8EQ5ImJCajVavT29iKdTjO0nFqqUqkUarWah+2EqtNoNHwcRDwl+Pbs7Cwv+NSGqVQqmJ2dhcPhwNzcHCcYYKXqIGY+sLJILi0twe12M0jA5/NBpVLxIlYsFnleQ+6vwuSg0+la+EhCCLvRaES9XkcgEODjFM6RhBuRSqUCo9HIcHGqhHQ6HXNeSGeOjBiFQZqS5XKZqyuNRsPHFolE4Pf7GUggDK1W2wJBB8AbCWGFlEwmMTQ0BAD8/QRYITknYULu7u7meePCwgKOHDmC3bt3s1wRsMINm5mZQSAQYFmihYUFLCwswG6386xycXERcrkcu3fvxtGjR/m5LJfLuOyyy1AulzEyMoJ6vQ6DwcDnm0AYRP4lKbN4PM68oUqlgvvvvx+33nor7rjjDoZw070svF4OhwNOp5M/N5lMIhQK4fTp05BKpTCbzYxgfb3jD3HyXFwAACAASURBVCTd1tjQGb/vvvtw/fXXY8+ePfjqV7+Km266CYuLi1hYWNiSvtvFjB/96Ed45JFHcOutt+Kee+7Z8ucICYTCIDY4kXrPFlu5gcilt7Ozk4UytxqUoFQq1ZpAiLWkdiiSySR+8IMfwGKxIBwOo16v4+mnn2a+GO34yE4jm83C6XQiFoshn8/jN7/5DT7wgQ+gXC4jm82yKCpxedLpNPsOkbMp6bYJvZRoNqNSqXhI3Gw2eR5kt9s5mRSLRfYaCgaDvJBT60loRy7cGctksha/pPZkTZDfbDbLZn2kVxcMBlclBrFYjHA4jEQiwZsc4Wc2Gg2Ew+FVz1EgEGhB/BHwpJ2USehIIYLRZrPh6NGjSKVSDDARovRMJhNkMhm39YhrRK1w2gzRokyJR6fTceVis9nQ29sLhUKBw4cP48SJExgZGcHu3bvhdrtZ1gkAdu7cCbPZjKeeegrxeBydnZ0YGRlhKDttNiYmJrBr1y7U63WMjo7yfUSIPpqH0/mj6lYoYbV7924cOHCA27WPP/44gBWKDP09+vdaCYvAOwQ8KpfLSKVSmJ+fZ4Tk+VjGnys2y7W6lEm6wAYTlNFoxIc+9CH09/fjpz/9KUqlEmw2G6anp9Hb2/uGlXr/zne+g1/96lf413/9Vzz11FPn9VnCeQlwxkm3WCye1Um3PUir7lwVnFBHT/jZ53MzymQylMtlVoTYsWPHmooQ7TExMYFHHnmEB88ulwtTU1NoNBq88ybJGqVSiXw+D4fDwXyger2OK664ogW9RnI+RP5MJpOQSCTQarWoVqtcaXg8HiZxymQyrqiIFgCsVFC0GLW3+oSVmLA68fv9TH7V6/WQSCQ8qyCxWmDlvm8HtgirYCKHUuIMBAKoVCpcXQCtiyDBsdsrG6/Xi+npabbZmJ+fX7PaJngxJRuxWIxSqcRJl+zNi8Ui+ystLy/j2muvhdFo5PZcMpmEWCxmxXN6HTijIzcyMoLjx48z+GV4eHjVYkyqKH6/H729vUilUmg0GnjhhRcwNDQEm82GSqXC5Os9e/ZgamqKn8UdO3ZgfHwc09PT2Lt3L2q1GkKhEKLRKHp7e5HNZvkzyMXX4XBgeXkZV155JSMz+/v7MTIyArFYjFgsxiK6zWYT9XodTzzxBF5++WV86UtfYgUQABtKWBKJBDabjTUtzWYzUqkUotEoq1kIdfXOVw9wK1D2S5WkC2wwQV1xxRW47777cOONN2JychJXX301rrvuOpYVeaOenDvvvBN33XUXJicn8dBDD53XZwlbfOSk63K51nXSXesziLh6tmjX0RN+9npAh3NFo9HA5OQknE7nukAIinq9jtOnT+OHP/whfD4fc0qCwSBeeeUV7Nu3jw3qGo0GarUaVCoVtFotm9cVCgXe8VarVeTzeXR3d7PIJ83taCdNdhf1ep0lcAqFAux2O3K53Cq5KVKsIGUKiUTC6um0eJGGn1Qq5SRUqVQQDoc58RPAgvyQ7HY7tyRLpRInVyFRGMCqBbtQKLAYLGnuCSkOdP4sFktLws5ms6jX66w47nQ6V7WTPR4PJz2SyiHpJopSqcSOxUJBWLlcvuqeI6Jze9VPSi56vR7XX389IpEIEokEZmZmcOTIEXR1dfHsixI5tWddLhcrjxB83OVycXeBZk3XXXcdDhw4gGAwiP7+fgArDtgAMDg4iGg0ColEwnqO/f39DFq5/PLLcfr0aTgcDnYYoArP6XQyTWFhYYHvPdpE/PEf/zF+9atfnfX5aU9YANjocWlpCTt37mTxYyIaV6tVduCdnp5epau3mWposzSW9uO+FGNDCWrnzp34xS9+gUOHDmH//v0IBAJ417vetaYvzWaiVCrhuuuuY1WB9773vfj7v//7C+YNRZWK1+tdNYDebNDDPjs7i3g8viEn3fYgJN9aCepsOnrCkEgkrOe30SAgRCQSgd1uZ8O4swEhgJUkeejQIRw/fhy1Wg3VahWxWIzNFC+//HJusy0tLSGZTKKnp4fdUun7RCIR7zhrtRqazSZmZma44uns7GQdPEqexMGhSgAASxQR7FosFjOhlRBrNpuNK6/2RCKUEgoIFMsrlUpLImg0GqjX61heXoZYLG5B7nV1dSEej7MFOwmaCoMWSpFIhHw+j1QqBZfLxYmFuEbUiiNQilDIlzYMpVKJEY1qtbqFbE5Gh+3cNqpK6boPDQ0hHA4jHA7jwIED7MVFMyYADEpRKpVsVU9wf0IFUmVHxxoKhfDiiy/C7/czV0poNd/d3Y3du3fj17/+NYu50kaEVNCvu+46FAoFzM/PIxwOM/S8XC5jYGAAwWAQw8PDEIlEqFarfK9StSuTyWC321n8d9++fZicnIRcLmc+pVwuZ44UqW685z3vwa5du7Bz507s3buX/abWimaziYWFBYTDYezdu5fRm1RhEZqVWn5isZi7CeQPVa/XGcloNpvX7bSQ+eVmgn7bpRobSlA33XQTbr755pbh3cLCAh555BF89KMfRSaT2VKyUigUeOaZZ7i1c8011+Ad73gHHnzwwQvqDSWXy3mB3Opug5BXjUZjw066ax3HWlDzdmXzs302LUAbTVBCIERXVxdisRgqlUqLTp0wKEkeOnQIx44dg1gsRldXF2QyGXw+HyYmJqDT6bBjxw5EIhFGxlEFpFKpWry3yJOIOFCk1UeWCpVKBaFQiF1tydY9FAqxKgKBLYCVllupVGJOmFBMVdiKE15jYbtNIpG0JCS3280VSCAQ4AQnpCZQNBoN5kCl02kWa6VZjV6vbzkehUIBsViM5eVl+P1+ZDIZ6HS6ljlmsVhEX19fC0Sefj/9JhKtFb6PEjCJ6haLRdTrdcjl8hYTRb/fzwCM48ePM7/ommuu4WeZNjCBQIDVGUh5gmxBarVai0IHkUPHxsYYjdhOOM5ms7j55ptx8OBBHD16FMCZlq1SqcSLL76Ier3OSZSu8czMDN70pjexCgfd60JOnDCIm+XxeNDd3Y2TJ0/y36dr3Wg0YLVa4fP5cOTIEbz44ovI5XL41re+BYPBgG3btuGGG27AFVdcwfcudRAkEgnbxtC90V5h0T90jJSQenp62I+M/KGq1Sr0ej0jBYVr6lacdC/12FCCUqvVOHjwIL73ve9hbm4Oc3NzCIVCiMfjePDBB/HAAw9g//79m/5yGsYCZ8QoRSLRBfeGIpsCYpZvJoRQbI1GA4/Hs2XC3lpQ83Pp6LW/v1KpbKhyawdC1Ot1VKtVzMzMMIpN+JBUKhWcOnWK0Va1Wg0+nw/NZpPhx3a7HTabDZOTkzCZTJifn4fZbMbS0hIb1InFYlbNpgEzGfFR9UGGevF4HM1mE1KplImZVE1YLBZGHRISj4bkwEpCof8WCrLqdDoezjscjpbKw2638y7f5XK1tMeEhF2qXCgsFktLsgLOzLdyuRy6urrQbDbZfRZobf+FQiH4fL4W8AWwsmAT+tPhcCAej69qG+p0OtY3pCQstD+h7wv8zlpdWD0KbUFuvPFGXvwKhUILzUKo+pBIJJBIJOB2u1k41mg0IplMwu12t1zrQCCAcDiMaDSKkydPwu/3s+Cvz+fj+/rKK6/E448/DpFIhGg0ymTjsbExht+fOnUKPT096OnpafELo99K1WImk8Hg4CBXRPQskjkpPet0rkQiERteHjlyhPUFQ6EQt3u1Wi2efPJJtvYg9Rmv13tOm561EhawkhQpYen1ehgMBm5vU8I6efJkixBsvV7fUoK6VHX4gA0mqHQ6jfvvvx979+7FzTffjO3bt0On0+Hee+/Fq6++el4HUK/XMTw8jMnJSfz5n/85uru7XxdvKCL/bdu2bcPvqVQqGB0dhUKhwN69ezE+Pn5eisZCKPFGdfSEsRHR10ajgenpadYWJCCESqVCZ2cnALQknZGRESbJhkIhnDhxAgCYIEtJNZfLwWq1IhKJwOFwQK/Xs2inRCLBtm3buBVIlUJnZyfvILu7u7l6LJfLkMlkvIhEo1FWZKjVavB6vbxw08bFZrNx0hBWO3a7vaV9q1AoGITQXq0KtfnkcnlLwhe22TQaTUuCot9A0Y6wI0M+iUTCuoPt4AoCx3R0dCAajbZUmvV6HUtLS7Db7ahUKqxrB6wsbnNzc1AqlfB4PEin06u8vejv1+t1tr9o7xaUSiXMzs6y5E8kEoHX62UbFzreRqMBj8fDbVBgJWET4MXlciGXyyGbzWJxcZENFc1mM2ZmZjA1NYV3vOMdLZVcLBbDHXfcgUqlgvn5eRw6dIif7/n5eXR1dWFoaIht4gk5KJVKeUOXz+d5c9hoNLgayWQyuPrqqxEMBrm7QAmYqm86Z2TLctlll+GVV16BSCRi80mJRILZ2VnMz88jEomwCszQ0BB27NiBnp6eDT2j6wEvKGHpdDro9Xp0dXWh0Wggl8uxcnmtVkM+n+cZFrlVb+Q7L8XYUILSarUIhUKr/JtIXuZ8oJYSiYQhsfv372fp/wsdm01Q5AnV1dXFMGoCSpzN+fZcQQviZnT01nr/2WKjihDko0MmcUR+FbL/yTOJHhy5XI5MJsMOu6Rx19XVhUKhALFYjHK5zHOKZrPJCQ44088HVqqO1157DW9+85tRKBQY2SYWixmlRec7n89Do9G0LJjkJ0U+RwRIoDYa8bnkcnnLjpQg3uTKWiqV0N3d3eL3pFQqUa/X4Xa7EQ6HW5TPgTOSPcKg60emgyTzI0TrVavVFpuLdiVyACxrJJTeotZeqVRi5fV2FKBQa494asQpq1QqbAKo1WrZvXl5eRlLS0swmUx4+eWXYbFY4PV6kcvlWNVfpVLBZDIhl8u1WJAoFAq2NCF4ezabxb59+5BOp/Hcc8/BYDCgp6eHrdxDoRCrPhw6dAgzMzPYtm0bz27i8Tj/blKPIA4StdDy+TxzyxqNBnQ6HVeNVqsVlUoF1WoVvb29kMvlOHnyJJLJJCcB2lwS2EOn0+HUqVPcLh4cHIRUKmVZp2PHjqFSqeD73/8+5HI5+vv7cfnll6Orq4tloc4VG0lYGo0GWq0W5XKZOxqJRAITExPc9aEZ1u+DnuCFjA1lFqlUii9/+curXv/hD38IYAWK7Ha7Nw0aEIbRaMSNN96Il1566XXxhiJkz7miVqthcnIS1Wq1xRMKOH/bDblcjmQyiUKhsCUdPdodtsdmFSGAlYXv1KlTMBqNmJycxKFDhyASiRAIBBAKhfh3zs7Oolgs4sorr2RpGzIYtNvtiEajTHCkxYz66tFoFDabDYFAgJMPodX8fj8kEglzmYSVIVU6BO8lCwih5l4mk2HDPFIOJ3g+cMbQD1jtcCv8jng8zlVaoVBoAR+QsjmhwMgJWBgOh2MVWCKXyyEWi8FmsyEej6+qSIjoKzwmAkYQwMLv9wNAS3VosVgwNzcHr9fLyUKtVrNiAyX38fFxlEolFuDVarXc4s1kMojFYpicnGSCr0Qigd1uR6PRgEKhgEajQSQSgdFoxEsvvQSJRMIUA5ofUYhEIigUCtTrdYyMjHD77tSpU0gmk7jyyitbyMVCNY1wOAy73Q6tVssJqlAoQKfTIZPJ8GxJKpXixRdfRFdXF7f/CCAzMzODjo4O6HQ6HD58mNuOsVgMSqWSZ5snT55sqSpJC5Lalz09PVheXub7UKvVMsKwr68PoVAI9Xod3/72t3ltGh4eRiAQwLZt2zAwMLAhgu3ZElYymWRtQ6VSCY1GA7/fz5vHRCLBeoJqtfr3SgD3fGLDpY/BYMCnPvUpTE1NYWZmhod+U1NT+PrXv4477rhjlWbfuSIajUImk8FoNKJYLOLpp5/G/fffjxtvvPGCe0MFAoFz+kJRZePxeJhZLgyFQtHSJtpMFItFjIyMMJlwqyALIbIM2LwiBCWz+fl59Pb24kc/+hHvOom06fF4WBGbxD1pLkXtl2q1yvpzwIqqAfk6kUYe7fSpmgqHw9xGGR4eRjabhUwm49aJUP9OaM1OAqQul6vFfJIQhsDK/Sm0bz8b2VYsFrdcQ5VKxX8mSDKFw+HghAes3EONRoN9rch2RrhpIG+kWq2GpaUlOBwONJtNRiACK4sfQZJJAYP4TxTlcpkrHJ1Oh3g8zhuahYUF5oRJpVKEw2GIxWJuM8rlcoRCIXR1dWFsbIxtMiqVCovlklFhs9lEf38/0uk0FhcXcdlll7HET6FQwNVXX80W8VQdv/nNb0a9Xsezzz6LZrOJrq4uSKVSjIyMAFjZ1PT19TE688CBA7j++uvRaDRQLBbxzne+k+dtQn1LlUoFvV7PflE2m40TEAC2ANHr9cjn8y2CwkRjqNVqOH78OLcCd+3axUmezCjJXBEAP+fj4+PQ6/XweDzQ6XQolUo4ffo0J/C+vj7E43H09vZy9XPq1Cm88sorAFY2Crt374bT6cT27dsxMDCwoQ07zcMWFxexe/fuFgFc+m1KpRJut3uVnuDc3BysViu37i/F2HCCevLJJxEMBvFHf/RHGBgYgMfjgc1mg1arxVe+8pUtffnS0hI+/OEPs2XD+9//ftx6663Ytm3bBfeGWq+CajQamJ2dRSqVWreyEbqRbjSEGn39/f0YGxvb8lCzfQZFShMbVYSoVquMTBoYGMC3v/1t/j1+v58JmyRRlEql0NfXx3pwdrsdmUwGIpEI2WyWd/NkbUEwXKvVCpFIxATb+fl5yGQyLC8vY8eOHdBoNMzNsVqtPMiXy+UtYAVyVg0Gg2yjISSpyuVy/jNVikQ0nZqagslk4srE4/GwlUOtVkOtVmPJJaPRiHQ6Dbvd3jI7aW+lhcPhFrI2iaBSkFW88H1SqZTVMGjGRiaF5XIZL730ErxeL/r7+9HZ2YmZmRk0m02u1ufm5nhmIbz3EokENBoNxsfH0Ww2odfrOYEkk0lMT09jamoKarUaXV1d8Pl8eO6551AqlSCRSDAyMgKv18sVMH12qVSCWCzG4uIi6vU6W2SQogMA/rsulwsqlYpRevSM1Wo1bkf5fD4sLCygUCiwc7LH40E0GoVKpWJUWzqdZhmr/v5+zM3N8fzlbAR1p9PJszq6/mS2SLYwdK+qVCoEAgFMTU2hp6cHp0+fhlarxdzcHORyOUPaAeDo0aPcyu/v74dGo8Hy8jJD9rdt24aJiQlui1J7myrLxx57DDt27ECpVOIZ1lrUkUajgYmJCZTLZQwPD7d0O9YjD5OeoNPpXFc9/1KIDSWoZrOJL3zhCwCA0dFRvPTSS8xQp5O+FZLZzp078dprr616/fXwhgoEAi2oLYp8Po/R0VFYLBbs2bNn3XJ5sy2+tTT6zodsSzOoswEh1lOESCaTGBsbY+7RoUOHuFpwu93c8xeJRJifn0d/fz/6+vrYsqJarfK/6eEnUzyyOp+ammILCmoZNRoNOBwOxGIx7Ny5E5FIBC6Xi3fzwoTUaDTg9Xpb7FEoAdCcicjBCoUC09PTkMlkcDqdmJ6ehsVigdlsxuTkJPR6ParVKtMLKElRq8ZgMLSAb/x+P8rlMgKBANLpNAuHUlAbk4JIv4RaXFhYWNN7SbjoEOpubGwMQ0ND7BpMgBlygp2dncVzzz3HwBBC8V1++eUt9186ncb4+DjsdjsnbLlcDp1Ox5sxpVIJlUrFCgu5XA67du2CxWJhaLxcLodMJsPExAT7YpGyN7UG2w07yVKDqsOXX36Zz09nZycMBgObCAKtNhKxWIzvk0wmwxWhwWBANpvlTVB7YqI/k7huIpFAd3c3EokElEolduzYwdeGQD4ajQZ2ux1OpxPj4+PQarVMIqY5ZjgcRiaT4a6BxWKBy+WCx+PBSy+9xNU4ARvI6TcUCjHgJJ/Pw2KxwOFwQKlUMl9yYmICIyMjWFhYYJL8O9/5TpjNZpw4cQJGoxF9fX0bJg/TOSgWi/jUpz4Fr9eLz33uc2u+91KIDSUoeji/9a1v4dlnn8Xw8DAOHjyIb3zjG7j77rtx++23v97Hed6h1Wp5d0U3fzAYxNLSEgYGBjYEfBDqkp0rhDp6QrY+VUFbQQJSi+LIkSOwWq0bUoQgn6dkMoldu3ZBKpXipz/9KX77298CWFmY6QGTSqU8S6xUKpiZmUGlUkFnZyf774hEIiQSCfT29sJgMLCYqkgkYph5NptFOByGUqlEsVhEMpnkgTYl0kqlwpWez+fjY52enmbxVvKbIn07mrvQThgAI8MAMJEWAAMmhK2+XC7HSVmlUrVUOkTQBcAzGfK3isViMJvNLcg+Ag4BYJRke+XaPvuKRqPQaDTYuXMnt1OpWiE7B2oJUkLo7e3lCiSZTOLEiRPYt28flpaWMDs7ywoZ7e6+BI2n9hgpl9tsNrbbMJlMTNpVqVS45ZZbuBKQy+XsegyAwTS0UNpsNk6C1KYktfnOzs5VYJ7XXnsN27dvR09PD9MDhAAWUk7P5/MsiEyLcaVSQU9PD6uKhEIhVCoVdHd3Y3l5Gdu3b0csFmMC7+DgILfBkskkbr75Zpw6dYrbhqSmTrNuhULBlbVKpWJFk2g0iiuvvJKpDtlslqtFYEWqqVgsIhAIIJPJoFQqIR6P831kMpkYRERt3X379kGlUuHw4cOsyrGZIKj+hz/8Ydxyyy345Cc/uan3/77Fhlt84+Pj+PGPf4zPfvaz6O/vh8FgwPPPP48HHngAt99++xtetFC4MAIrlaBKpcLevXs3zMQW7mLOtuOp1+uYnp5epaNHQVXQZhMUzY6KxSL27NmzISBEsVjEqVOnYDabMTw8jHg8jocffhjNZhM9PT0Qi8W8GyRpnFAohFQqxY6xHR0dPMCmCkomkyGZTPL/o0X1wIEDuPbaa1GtVtHZ2ck7ZGAlIeRyOUbeUcvH6/WiVqthcXERtVqNocGErqP50NnarkJko5Cv1Gw2YTabedEk5CI5w9JuX6VSwWaztYAR9Hp9S6uPZJuIF0aK7JSw6DfF4/EW0VY6Lpp5lMtlnktIJJKWhCcWi3H06NGWe5SG/Gq1GpFIBK+99hpXuGTEKIRkC+Ptb387lpaWYDQacfr0aQArSUZI0m7X+xOJRFzlWK1WZLNZFItF2O12JJNJVKtVWK3WVarrdLyFQgE7d+7E8vIyHA4HKpUK4vE4brvtNgBAKpVit+JwOIzl5WU4nU7uTLRzzWhNoXvAYrHgyJEjLZQFYGVj8utf/xo33XQTGo0GRkZG0Nvby5W10+nka0+VDiVKeq1Wq+GKK65AMBhEKpVCJBJhUJNarWb/KK/XC4PBALlcjpGREb6Purq6WNtxaGgIuVyOhXTpWv7VX/0Vuru7MTIygu3bt2/J9+nEiRO455578IUvfAG33HLLpt//+xYbTlAKhQKxWAzXXXcdv0a7A+D3gyzmdrvxjW98Az6fD9dee+05ibFrBfFG1przrKejR0G8os3cnEIghEqlglKpXBcIAayoX8/OzmJgYIDBB48++igrN1CLjH6TXq9HMpnklk0ymYTVaoVMJoNOp+OFlSDaLpeLYc+lUol3nfTvcrnMQALgjHWE2+1mcqnQVFCv1yOVSnF7pKenBwBY1JTgxdQW8/v9yGazMJvNDKMulUrQ6/XQ6XTQarUoFAqsxwesgAtIo09YXSSTSSaY5vP5VZsKgtvTAupwOFaRbiuVCvL5PBqNBlvP08JKLVG73Y5iscgeTrTICu8TauFpNBp0dXWx7h5dE7FYjNnZWZjNZrhcLgArVflrr72GgYEB9myjuRepk9NiT3JZdF8Jg/hpwAp6UCaTtciEdXR0sKGecB5WLBaxd+9e1Ot11tTT6/X8jJAmodlsRqlU4tdJa7FWq/GcCGhFtnV0dEAul2NhYWFVm3G9aDbPuDBT1Ot1zMzMoKurCyaTiYmyV111FTo7OxEMBlukrGZnZ6HX63kTJ5FIeMOzuLgIsVgMl8sFl8uFdDqNUqmEqakp1oZcWlpimsodd9wBAAwQ2qyobLPZxBNPPIEvfelLePjhhzfF5/x9jg0nqM7OTvT19eEjH/kIent7EYlE8P/Y+/LoNssr/Ue7rH2XZVmyvG8hi+OEJJA2DhAoS4ayFCiHpRQy0wXomXY4TKfzK0yXoR2attMyw2HYOukpMwy0E9pDWZISAikEAokTr4k3eZNtedO+S78/NPfmk+xA7AANtM8/ENuSXn369N733vvc59m9ezd+/OMfAzj7h8UCgQD6+/sxOzuLJ598clnBCTjZhyo2/ns/HT3h45firFtMhBgeHsaRI0eg0WiYakpCrkD+VEzsrNbWVkilUvT09OC///u/IRKJUF5ezk1xEv0knUEiNvj9fjQ1NbGFucFg4I2TehRkgZ1IJDA0NIRgMAiXy4WKigrMzc0hHo9zUKqsrOTB2qmpKQSDQVRUVDAVWqvVoq+vDxaLhd1TieVFWm9C63PaqNxuN5f6ysvLC/pZRqORA6FEIuHeUCqV4j7e1NQUnE4nIpEIl7JIuqmiogLz8/PQarUF2RQAHvoUqjbQSZqo6BaLBcePH2f3WaJjC3sx9JnRQDJ9DiSmKwyUlPVks1nYbDbuVxEuu+wy+Hw+ztKI7UmHCavVitHRURbSpbWSagKNCGSzWXz6058GALz66qvwer28DlICn5mZwfDwMAv7kpRQKBTC5s2b8dprr/F3RKfTFcxPAfmASu/VYDAUZL30GVEmKhT1PRWK+zPFoPm8UCjEDsjRaBQ1NTUoLS1FKpXC8PAwk3aEM3L79+8vYPwB+fJuQ0MDD6ULzVvJLoSsZVQqFb785S8z0Wg5MmnZbBb/8i//gj/+8Y/Ys2fPGWugfpxw2gFKLpdj586deOKJJyCRSFBfX4/f/OY3TG0+m/H666/jzjvvxKpVq3Deeectue4rBNlu0FDh6eroEeRyeUGz/VQ4FRGipqYGtbW1iEQiPMxH0kXEMqysrITD4UAymcSuXbswMjKCXC6HUCjE9G+iHgvZeyUlJcjlcli9ejVSqRRvSOTVJNzYaOg1k8ng0KFDgU+ChwAAIABJREFUuOSSSzA/P4/R0VHW1KMsg7KgWCzGE/oTExNQq9WwWq0FJRwqO1KmQbIwQD77otO8UqnkHpLb7eafy2Qy6PV6ztzo1E7rcLlcHFQWK7Mmk0l+rNFo5IAm/PzpdUm+qbhUZrPZ0NXVhfb2dshkMqxfv55/J9xEhQFKrVazDXwmk8GKFSsKnlNYxi12a6b3QsO/xRu11WqF1+tFeXk5fD4fDyLT+6QgQ/05oecSlSdFIhFvukajkR11yYpdWMoF8grxNTU1UCqVfH3oOYeGhiAWi1FfX4+RkRE+7NHaY7EYYrHY+w6mE5RKJZfwSMKJXovkhSQSCSuwUymbguT8/Dz3qC688EJoNBq+NuvWrYNer+d72+fzwefz8XDt5OQk6uvrIRKJIJfLcfToUb7+l156KT7/+c+ju7sbTqdzWfOc0WgUX/rSl2C32/H888+fsZ3Hxw1LkoCw2Wy49957MTg4yE31F198ERs2bFi20+tHgVwuh927d+PgwYN49913z+i5hEy+pejoEUiR4b0QiUTQ3d0Nq9V6SiKERqNhGm82m0Vvby98Ph+USiW8Xi96e3vxP//zP8xcFIvFaGtrYyWFTCbDthMAWImBVMTp5xUVFSwmumfPHlgsFpSVlfG8z/j4OMxmM5fOaDOKRCK8WYlEIvT09LBt+ODgIM8qUZ9KKpWiv7+fVSVIhobKgELXWwosFLji8ThvrsUyRQA4kypWgRAKs9LvhVkYKXw7nU7IZDIMDQ2xbiEAlqVRKpUsv0QbLAVFkoIiCCsNxS7Ler2e+00TExNc5gQKA5TH41kwe0X3pMlkwjPPPIPKykouAdK1of+SSC9w0jqmeIZRWE6TSqVwu90FhAngpMoFWazQWgBwb4d0FkOhUMGac7kcpqenC/zRKPszGo2YnJx83+CUzWZhNBpx4MABzM7OIhgMYvv27TjnnHOQy+WgUqmQSqVw8OBBXHjhhVixYgVqa2vR0dEBkUiEqqoqGAwGTE9PY+3atVAoFBgdHYVGo0FFRQUfVmZmZnjfIBp8Op3G9PQ0Mz6dTid6enqg1+tRVlaGCy+8EGvXrkVHRwcaGxsXPVS8H8bGxnDTTTfhC1/4Anbs2HHWV6k+DCwpQD311FPYu3cvz1u89dZbSCQSePrpp7F58+Zl+5mMjIzg5ptvxuTkJEQiEXbs2IG7774bs7OzuO666zA0NASPx4Onn36aGUNLwebNmwHk51h279695McLQRtqd3c3MpnMaevoEd6Lqp7L5d1hx8fHT1sRIh6Po7OzE3q9Hueddx5EIhFeeOEFPP7448zKUygUcDgc8Pl8/Hzd3d1cunK73Vi3bh0mJiagUCjg8/lYqdzv97N0EdHYiSzR09ODjo4OrFixAjMzMygrK+MNnkQ5qVcF5DegqqoqDA0Nsebe6Ogo3G43S/yQO65UKuWyIFCY7VB/CThpWaFUKrn/QjNWtMFRuU8ikRT0Y4QzJMKZGgB8Ik6lUlwepCyQMopMJgONRsNUZbPZjL6+PgSDQd7Ei+8N4cZPygn0naHZIVLQGBwc5MMAvdfi3heQ7++RmgX9fnR0FFVVVazSACwkRSgUCl5fsdMvrT2VSsFoNLK1BL0GZfU0SEwByu/3o62tjXtdsViMGZNqtZr7lXq9fkHJFshnDESgKbYTyWazLF9lsVgwPj6Ozs5OJl0QcSEYDGJsbIzNNSUSCQ4ePIimpib2DOvp6cHbb7+NkpISZg+SQgqQ7yeT63AymURzczMfqDo6Ovha2mw2tpN3OBwIh8NYu3YtVCoVOjo6UF9fXyDMe7p46623cNddd+GnP/0p2tralvz4TwqWFKBKS0tx7rnnoqamhm2dH3nkEfT393MQWNYipFL86Ec/QktLC0KhENauXYuLLroITz75JC644ALce++9eOCBB/DAAw/gBz/4wbJfx+PxnJbc0XshlUphfHyc69dLPdWcqmyxVEUIIB9wBwYGUF9fz66xTzzxBNuD+3w+NDY2IplMwu/3s9laMpnEmjVrEI1GkUwmoVarMTo6CrvdjnQ6zbNG1MDu7Oxk5h9tMiKRCHV1ddBoNNBqtVCr1UxdplKjSqXCzMwM5ufnIRKJMDExgZKSEtjtdmbyiUQidtU1GAwcPMjmQaPRIJlMIpfLW7oT3X1qagp2ux2hUIgDbUlJCVtXyGQymM1mTExM8PXu6upCX18fLrnkEs4Aibpc3OcolicCwAczKodR749+HovFeK7JaDRCr9czEWMxuFwumM1mdq2lKgQZ3R0+fJj7cMBJhXTh/SOXywvo8hRwUqkUOjo6UFNTw9ldNBplsVq6XhQcBgcHUVtby+xNem4KUEJCRSaTQU1NDUKhEKampvDb3/4Wf/VXf8WBkHqlRCah7whl87W1tSyAC4CHpunwJwyGQhDDsbu7G+l0mntLx48f5+rCsWPHWPGDxjJkMhmmp6c5QysvL0d7ezsUCgXkcjkfbkiotr+/H/X19YhEIkwvF4lEaGxsRE9PD5xOJwedqakpVtCoqqrC/fffzz1YmmOjeT1y3SWljsWQy+Xw1FNP4ZFHHsHu3bs/0SoRp4MlBaht27Zh27ZtBT+zWq144403cOutty6bau5wOLgBqdVq0djYiLGxMezevZsFam+55RZs2bLljAKU2Wxm+4elBpZsNguv18uUa1rvUiFkURGICOHxeGAwGJjyfSpFCPLiSaVSaG1thUwmQ2dnJ3bu3MnlLZlMhhUrVnB/ihr3wpKW1WrF5OQkD64SvZz6LKQqQBPztKnTl35ychIymQyxWIxLGGazGYODg5xthUIheDweJiTQ9RN6F1F2SPdPLpeD0+lk+RoS0hwfH4fL5eIgRM67BNqcp6amUFdXh2PHjsHv9yMSiSCTyUCpVLKBHm3spL3X0dFRUAEQejsREokE/H4/9wOLg5rwvlIoFFixYsX79hszmQzP5ghBn73Qzr61tRUjIyPMsKTXKi7HEajsTL+nLIHm2sjsccOGDQiHwzhy5AhMJhNL6pCiSCaTgcVi4R4UkA9uwWCQg8xiZWuhhxKB5hGLB3FpbSqVig1MCalUCqWlpTh8+DDGx8eRTqd5iLy0tJRfgx5DWRD1B0lKbXp6Gm63G+l0mvucSqUSPp+Pdfc0Gg3Kysr43gHyJB+LxcK955GRETQ0NKCvr4+Hx9esWYPrrrsOx48fh9ls5r4U9Z0SiQTm5uYwMTGB3t5ezj4pYNG+cN9992FgYAB79+5dtij1JwlLClBzc3P4/e9/j1gshpmZGXi9Xhw8eBC33347gA+Gaj40NITDhw/j3HPPxeTkJAeC0tLSgv7AckCeMUKrg9MB6eiZTCasWbPmjPpYwi8rESHC4fBpK0KEQiF0dnbC5XKhrKwMmUwGu3btwrPPPgulUsmn4EQiweZtRMs+cuQI7HY7LBYL93roWkgkEuj1ema30Sm2p6eHFRJIkywWi2F4eJj7ThSwqBRUXl5eMIwsk8lYhy2dTmN2dpaZjqScDoBlfUpLS1lzr1jqhQKKUqnka+R0Opm+Pzw8DK/XC7fbje7u7oJSn1gsZluFqakpZlwRAUCn0yEcDjOjjQYsSYVbGHiFbDwCSfmQr1nx5/1e/y6mUFPmRWs3mUzwer0wmUywWq147rnnsGLFCpSWlhZs5sLyMfUAhc+tVCoxOjoKl8vFVHEhs0/4XGvWrMHAwABef/115HI5rpJYLJYFdiIk3gucLJ0udg3EYjH/PpPJMCWfQN9LmUyGdDrNdPynnnoKQD77EmpAFl/PxQ51FAxjsRgfeCkglJaWYmBgAO3t7TAYDBgcHOSDU11dHWpraxGPx/GHP/yBJbY2bNjAMlBU0ty2bRs6Ozt5GLoYNIRNAZW80qampvCd73yH7T8aGxuxa9euvwSn/8OSAlQ8HseePXtY1bixsRFf+MIX0NraCuDMqebhcBhXX301fvKTnyyo21Ip5Uxht9sxMTFxWowa0tEbHR0tqCWf6VAyzVP09vayGOv7KULkcjm2xyY9O5/Ph8cffxyRSIR7PTKZDF1dXSwHQzNJfr8fwWAQ4XAYNTU1TM+uqqrC2NhYAdMtm80il8vh4MGDMJvNqKqqYm2ycDhcYKPh8Xhw/PhxLoeRfJFer8fQ0BBEIhFmZmbYJoKGeImsoNfrC2zKyZ2Z1kGWD2TzMTk5ydnD9PQ0symJoDAyMoJkMon9+/czO442ecr2aK1E1CBpHQAcdMRiMVP55XL5AuVxoHAzJBKI8Gc0mEyOt8LelXAjBhYGKCGhAThJlQZOkhSGh4e5f0cQvj6tU9i3UqvVi2Y79PoUoIhQolKpcMUVV+C5555j4ovQCJEC1TvvvAOj0YgtW7ZwliXMJqnfRexMeo+kHEGZuZAyrtfrOWOsrq4uEO6l16VrQZ+l2+1GSUkJ3xcikaiAkdjc3MwzTNPT0/B6vXA6nejq6kJNTQ2rsUejUTQ1NXEWdcEFF8BqtSIUCmH//v0A8geAr3/966ioqEBXVxd/L08HpFJit9tx5513or29HRs3bkQmk8EFF1wAvV6PF1988WMxX/phYsk9qG9+85uQSCQwGo3seZNIJM7YqjiVSuHqq6/GjTfeiKuuugpAPpj4fD5u8J8JPZxA4pXvF6CoJySVSrFmzZoFX3zhJrMU5HI5tiZoaGg4LSJEIpFAZ2cnNBoNWltbIRaLceDAAfz85z9nsoBWq0VdXR1SqRTq6upY+uXtt9/mDaqiooItKvR6PW+YJNVjtVq5KUwWGLOzs8hkMrDZbEilUkgkErxOq9XKFFoKBtTXcTgcnDmRp1MkEoFcLsfQ0BAPN0qlUoyMjHD5rba2lo3xyMa8r6+PmYepVArxeJw9uiKRCDep6foCYAIDMfgA8IyRWCzmsmgkEoHVauXnKz4EjYyMYPXq1fjjH/8It9vNRAs6UFAgcTgcEIvFBYcXiURSMHxK81A0WAzk7/FgMMglNOFa6bMHCvtONHoQjUZZvUAsFmN+fh6pVArbtm2DWq1GIpFAIBDA3Nwc9Hp9QT+z+JAlVAUHCqsh9Ld+v58zaIJw5o/Eds1mMzP4xGIxvF4vs+aoLCZEIBBgeS2C2WxGR0cHRkZGWMcROMkSFGqAAvmeoVqthtFo5M9ZpVKxkzDNtFGQpZKd1WplSS3q21VVVbFcEs3rkUJ8JpPBueeeC4fDga1bt7IKynKGbwFg3759uPfee/Hoo48WjCOQP9qfO5Z0BUQiEV555RXodDoYDAZcddVVaGlpwVe/+tXTmu05FXK5HL74xS+isbERf/u3f8s/3759O37xi18AwAdmu1FRUbGg+V2M2dlZHD58GKWlpWxiJsRyfaHoC0C6aCUlJWyPcKrg5Pf78e6776KiogJ1dXWIx+P40Y9+hB/+8IdMXFi9ejWsViuOHz+OEydOYGBgACaTCfPz82hoaMDGjRuxfv165HI5dHV14fDhw5iamuLGcFlZGfR6PWZmZlhcldTADQYDSktLMTc3x9P+NKwbDofZsRTIy2GNjIxAJBJhcHAQYrGYSxu0SVosFi6z6XQ69PX1sROtx+NBX18fBgYG+JR7/Phx3mxIZqmqqooHeh0OB9vTazSagtNy8UZIpAx6LtoEiPgALF4y6uvr4wxGGKAoGxIiHA5jbGyM9e0IVEqk/ycIg70QRBChEndxluRwOOByuaDVavH888/zc4pEIqZHU18wm80iEAhwf5GuhRDCAFU8S0XBMhAIYHx8HO3t7fzehPctlaXofRILs66uDmazme8TkkwSXmthObCkpARHjx7F0aNHmSpfHFApmK1evRpr165Fc3MzdDodbDYbRCIRZyFkh0JDswDYmmTDhg1YsWIFstks7HY75ufnsWrVKrhcLkQiEYTDYSZzkDeVzWaDy+XCNddcg/n5+WUxeen9PPLII/j+97+PF154oSA4Ca/lnzuWbIX70EMPYd26dVyyeOedd9gJd/Xq1csiIBw4cAC7du3COeecg9WrVwMAvv/97+Pee+/F5z73OTz22GOoqKjA008/vdTlLgBtgouBdPSi0eiiOnoEpVJZoKt2OhASIUhMlRqli52UMpkMD+GuXbsWcrkcvb29+OUvf8kZBlFrScBSq9WipqYG2WwWY2NjCAQCCIfD8Hg8rBpvsViwadMmKJVKpFIpNgzMZrMwmUxcGyc1AyrRkSGgTCZjqnAwGITBYIBer0cymeRMRiaTYWpqihl6JSUlyGQyrCpAmVEgEOCAODY2BrVaXZAJZTIZVFVVIRaLIZvNsr7fwMAA7HY7wuEwJBIJz0GRkyzdf8UHCzpZU3OfXHeJrUW6cARiMkokElZgLykpQTqd5nIvZdLCXpnFYmHDxMV6imRHTmsC8gHD5XLxXE02m0VLSwvi8TicTicPU9PjI5EIH25oHYTy8nKeNRMilUrxPSuknxNEIhGMRiMzQAnz8/O47rrrEIlEcPjwYYyNjWHt2rWIxWKsqEHyXcV0dRqaJkUSWiuRTYSST0C+J0mHrMVA121sbAzbtm3jzFOtVmNubo6vh1arxfj4OCQSCfdTqSzodrt5NosCLckbAfkhY7/fj3POOQcGg4FllkKhEDZt2oTNmzejo6OD+8BLRTKZxDe+8Q3E43G8/PLLSzYu/XPCkgMUffnefvttNDQ0QKfTsfQ8BZel4vzzzz9lX+f9TAaXioqKCrzyyisLfn46OnqEpWRQxUQIIiMEAgFMTk7i+PHjUCqVMJlMPAdDbrdlZWWor69HNpvFb3/7WzzxxBO8EdFJLp1Oc63carWivb2dv8Qejwe5XA7pdBrV1dXw+Xw4//zzuX/gdDr5tK9UKnlAMpFIoLy8HBKJBDqdjtUAZDIZzwrp9XrYbDaMjIywA+zs7CxvDEC+v0JlObI2SCaT3M8iv6mBgQFUVVXxyZ1IEHQC1+l0CAaDCAaDTCGmBr8wOLzzzju8eWezWWZdKRQKpFIpPsHr9XqmHhMxxO/3Y3p6uuAkS8QJoHD2SnhvCDXuSMGdSBIqlYpNGYWECqGaBQUov9/P9uXBYJBp+FQSHRkZwcqVKzE3N1dwWhdmjPTcpMNXnEEK5acWw/r16/HWW29h9+7dEIlEOP/883l9U1NTSCQSqK6uLpgXS6fTPH5AvSdhgBI6Gxevh+4puqZmsxm/+c1vkE6n0dDQgGPHjvH1pWs+PT2N5uZmuN1uzM3NLSCqFH9v5XI5otEoW8NEIhEmapBqB1H5X3jhBQD5Pe6yyy7D1NQUDhw4gFQqhZqaGtxxxx2orKzE0aNH0dTUtCxxgunpadx6663Ytm0b7rnnnr+U8d4HSw5QV199Nb71rW/hzTffxAMPPAAAaGtr4wHas33auXgWaik6egSSO3o/CBUhiokQKpWKyzdkDTA4OMhlA5fLBZPJBL/fj5/+9Kfo6OiASqVCWVkZW1fQBq7X61kVoa6ujrOYY8eO8QCly+VCZWUlJiYm2FpAJBLxBm40GpnUkEwmWZ5obGyMGVoajYbtL0ZGRuB2uzmQJZNJhMNh/tKazWbObmhDI3acxWJBJpPh0h/1bqj0SvNLxSB7c+FnSY+RyWQYHBwsmLsh8dNUKsXZViaTQTQa5WY29cGoVNXf34/KysoCnys6gVNGRqdyInLQZyCXyyEWi2G1WnljtdvtKC0tLbALmZmZgcfj4f6aEPR8Op2Oh3hjsRhGR0dZR1GYGS5WNiTE43E+DJWXl3N/CMgHnPLycmSzWT5QGAwGrFixAiKRCK+99ho/j9COnl6nuNdGflNkiFheXs7zb8X9QSGEVPR4PL6owjq9FyCfGRmNRs66TvXcoVCI+8xUzqZxC6qAkAL/pZdeCr/fj82bN/NMGvVN29raUFJSwhJI/f39aGlpWVbPvbOzE3fccQf+6Z/+Cdu3b1/y4/8cseQA9cUvfhEejwc333wzTzh/EI63HxUcDgefvklHT6PRnJaOHuH9rN+XqghBBAW/3899lUAggN27d+PAgQM8w0SnPyrX6fV61NTU8IwQNclbW1sxPj6OxsZGZqH5fD709vYCyPc7SOySNsRDhw4hGAyirKwMlZWV3F8iSCQSzM7OwmAwwO/3o7S0lPtAVKIjvyggn3H09fXB7XbzTFcmk2Hxz/HxcSgUCmbqCQdByRwxnU7D4XDwumhjcTqdPDBcUlICvV5fcJIWbopUiqaZL1JvKCkpgVwuZzIIkD9tT09PY3p6Ghs3buT3ImxYC6nbpBtIGoaxWAx6vR5Wq5XvMSIyTE9Ps0wSBdH+/v4F80C5XI6DCYH6ESMjI2hpaVmwiQMnMzFhoKI1UFmZrg0APjgQ7Rk4qf5Bnzspu2u1Wmb+UcYjzJYMBgPC4TBfIzqQ1NbWcq+RrkVFRQUPuwshkUgwPj6+gK1H16a/vx+f+tSnYLPZMDo6ekq7GhqbmJ2d5ZIyBbTJyUk2rRRmoaFQCNXV1YhEIti/fz8fHs1mM8xmMy6//HLMz88jEAgsyZ5H+B6ef/55fP/738cvf/nLBTqLf8GpseQAJZfL8ZnPfObDWMtHAioJPfvss3A4HGhoaFiysvl7lfiSySR6enqgUChOWxFiZmYGx48fR01NDXsVvfLKK/j1r3/Nf+NwOKBSqbicFgwGUVpayn4zQL4ZLZVKWaYlk8nAaDTC6/XyoKfdbmclBAoU8/PzkEgkkMlkqK+vx9zcHGpra5FKpVBeXs5ZxMzMDM/n0EzT9PQ0M+AsFgvr6QUCAUgkEsRiMeh0Oni9Xi71kA8USVupVCru9QhJC263m7PERCJREMSE2VN3dzcGBwdhtVrZv4ia4oFAgIVuySQQOKnfR8FRq9Xy72lmi4K3z+dDU1NTwewPlYbMZjOy2WxB9lhcdqLnKWbGkZySMCskcoewHEYb4tjYGKsQNDc3Y3p6mgNOOp1eoO0nxKlO/PQ6wnkkes6jR48W9CspuwBO6u+ZzWb+HIrtO+jzFh4WSE2CAjNdAyrlNzQ0FDzH8PAwGhoaUFdXB7/fz48vzpxisRjsdjsPc8tkMraNf+utt9DY2MjPKWQdy+VyLnUD+XaDXq/Hvn37UF1djQsuuIDnrsiF2Wg08nzc+yGbzWLnzp149dVX8fLLL/N35S84PSw5QBGWQ4Y4GxCJRBCNRvHkk0/iF7/4xbJsN04VoJaqCJHNZtHX14dwOMxlg4GBATz44IPsTUMOt8PDw9zUtlqtkEgkBWUfmUxW0H+yWq3w/J+CA80vkTEfKUV3d3fz5uLxeLBx40bO5gYHB5FOp1mVnE7Q5NVEPRQiJjidTt50EokEi6wSGUKtVvPE/MDAAAuhVlRUQCQSsbup2+3mNQnndUwmE/fOlEplwXAnDdoSSy+Xy7EJnVqtRiqVwvz8PLMKyUUWKDRSpHKoVCrF4OAgC/HOzc0VzNMAYOox/VypVHL/rLj8S5+/Vqvl3y3Wz6LnfS/fo0gkglgshubm5oKfR6NRLt0KUVpaCr/fX8DoEwajbDbLmzWtjZ4jnU4jGAyivb0dbW1tBeXTcDgMpVJZkMlQ3wzIZ1qUZSWTSVYqocfTqIZUKi3IZijg0BqoJOz3+wu0CIVmhg6HA0qlkrX6aN6P3p/wvwRaxxVXXMGHLdL/a2lpYZdwMhc0mUzsajw0NIRwOMzCtqcKWLFYDF/5yldgNBrx+9//flku2n/uWHaA+jgGp4MHD+JLX/oSbDYb7rvvvmV7Qgl7D0D+5u/v70ckEmEiBM3anCprIiKE3W5HbW0tK66/8cYb0Ol0iMfjzCLr6ekBkN+kKysrEY1GMTo6yhphcrkcPT09MJlM0Ol0PPdBGmEqlQoulwsnTpxgDxvqcZ1zzjlMiU6lUjAYDEgmkyx3A+Q3G6LvikQiDk7kNOp0OpFIJPgUajAYWAoJyPdTDhw4wDMntbW1EIlEsNlsLLdDoA2O+nSzs7MFKiLUwxMqlhezoGijlUgkHJho+Fj4edDskFgsZl8qsrwgeSTq1QGF9zxZN2g0Gsjlci6DCct7BNpshRuxWq3G7OwslEplwVxRPB5fkO0IX7d4g45EIrjyyisxNzeHQCAAs9kMg8GA+fl5SKVS+P1+5HI5vtep/0rzgNlsdsG8mJBVV2yqSNdv7969aG5uXnB/ezwe9kMC8p8nHQhkMtkC0gNdx9bWVvZVAvLlyZUrVzL9WzioT7JGFosF09PTSKfTPMaQyWQK1kQkDnosEVEymQx7nwH57/Dhw4fx4IMPoqqqChMTE/B6vVi5ciX3K9VqNdRqdYFWZXHAIlKM0+nErbfeihtvvBFf/vKXz2i/PF3R7F/84hf47ne/CwD41re+hVtuuQVA/jP86le/in379kEsFuN73/serr766mWv56PEsgPUxxFHjx7FM888g8cff5ypsssFSSbFYjF0d3fDZrNxNvB+ihDj4+MYGRlBU1MT18mfeOIJnlAH8uW6YDAItVqN+vp6zMzMwGg0FpT0Vq1axXp1xJayWq3o7OyERCKB3W6H0WiESJQX1CTyxPr163kTFYvF/Fgyr5ufn4dMJoPdbuegQ0KeZWVlnC0Ru49kjYxGI0KhEPr7++FyueDxeBAOh5m67vF4eO3ENBOar5F6OpAPxqOjo1x6BPKBT6lUFkheWa3WAm0+4X/FYjH3FqhkJxRWpcxNoVAwUYJIG+QOKzwZF/ceKIMCTpa3FsusaT3ZbBZOp5OHk+k5hCC3ZCEowHkENhu00cfjcRgMBrZE8fl8TFAg6SV6r0LQAYtEb4WgDbmiomIBFX1+fh6f/exnkcvl4PP5CmzayXW4traWyThC0H1ChwWNRoOhoSE2VQROHlDIQXl+fh46nY4PY/ReqLxMrM75+XkusQo/L2HZkXQpx8fHUV5eDoVCAbPZjKamJszPz+Nv/uZv4HA40NfXx6LVp6p+EMGoOGD94Q9/wMMPP8xMv0wmg2PHjmHFihXLZuw98MAD7yvYmZenAAAgAElEQVSaPTs7i/vvvx+HDh2CSCTC2rVrsX37dhiNRnzve9+DzWbjmULhZ3a246wKULfddht+97vfwWazsY7cB2W5AQB33HEHgNMb1n0/yOVyDA8P83T96ShCpFIpdHd3QyqVYt26dZBIJHjnnXfw05/+FIFAABaLBXa7HQqFAidOnGClbjqVhkIhNDU18QwW2WvTe6JySUNDA4aGhmC1WnHs2DEu47hcLuj1evT29jIbiiRf6EQv9BWi4GQymbg8RYHN7XazXp7NZsP4+DisViuUSiWXW4B8f23//v2w2WzQaDQctIB8cKIvC/lQ0eYlkUhQUVEBIG9fX1ZWBqlUiqmpKV4PCXBSNpVOp/lzAPKbCNk6UGDSaDRwuVz8ORiNRs5K1Go17HY7yyWR2K1Q/kgIpVLJLsAURISZtUgkQkVFBbMjiRgiVJygEjCVIynjUCgUrMxAM1HCkqeQDEFDxLQ+uv+IYk1rEUI4hyUsfdJ9etlll7EGZTGI+i7sIy3G0KNsRnhN6N8KhQJ+v5/fB703oVsyfS7FGWxpaSlkMhl7dLnd7kX/zmQyQalUYmJiAqlUiiWtqBwrEonQ1taG2tpavhbt7e1Qq9VYvXr1krIeYS81HA7jzTffRC6Xw759+/DAAw/gZz/72bKdcE9HNPvFF1/ERRddxJnyRRddhBdeeAE33HADHn/8ca7CkKPBxwVnFQn/1ltv5VkEAp0eTpw4gQsuuICp7WcCj8fDzdblIJlMIhKJIBQKYdWqVaelCDE3N4dDhw7BbrejqakJ2WwWjz32GJ555hnY7Xame5NyBNFkW1paIJVKEY1GMTExgZmZGUSjURaMbW5uxpo1a9h6g1TOyRK8tbUV1dXV3GR+++23ceTIEYyNjeHFF1/EW2+9hWQyCa1Wy8raZWVlCIfDLM1DQU34BROLxfB4PPB4PHzi1mq1zJALBoMsOrtt2zZccMEFPHskVFx3OByoqKjgXhGRI8bGxjA0NASv14t4PI7R0VHWW5uensbg4CByuRwHcuDk0CxBp9OhtLQULpeLLTVWrFiBf/u3f0NzczNuv/121NXVYfPmzZBIJFi5ciUeeeSRgoyK3itQmEHRpiycE6M1EBwOB8v8EEhcl0AOtxUVFcxSBE5S5AlNTU1wOp1s+igMVkLnYlobXV/h5yUEBYJYLIbXXnsNXV1dTIDJ5XKsBL6YvFixQ64wy6ioqOD+ltB4UnjdgPyhRqi3ST8fHx9HQ0MDbDbbAlkmGgGZnZ1lxYvF1Cg0Gg0kEgn8fj9GRkb4cWThIpfLYTAYcPvtt3NwikajeOedd1BaWsol6KUgk8ngvvvuw69//Wvs2bMHtbW1qKurw44dO/CrX/3qjGzaT0c0e2xsjG1ZgPyw9tjYGPdV//Ef/xEtLS249tprz1h0+6PEWZVBfepTnyowqQNO7/SwVHjOwBeKiBB6vZ7LZ+9HhBgYGEAgEMCaNWugVCoxMjKChx56CN3d3fx3TU1NCAQCsFqtPOUukUhYOV0kEmHNmjU80yMSidiJtrOzkyWAaO6FNnCtVouWlha2pqZBa5/Ph5mZmQKtw3Q6zVYeRANuamqCVquFxWJhWw1SLadZktHRUQSDQbz55ptobGzkMtXExASLvNKGK+wx0UBuLpfjbMzpdPI9QOsiOrpQnocU1oWbJckykfePVqvFjh07MDs7i7m5Obz88svYvn073nzzTdx7771wu9247rrrsHv3bhw6dIgtFz71qU+htrYWjz76KOLxOAd7UkOnQEj9KaE0kDBALVbSIbo9MSPps6XS8KlApSrK5ojRCZzsudG/A4EAXC5XwT05NzcHl8vFAZ7WKVSMEILWstiahAGRaN1UvhNaYND1EG6IZN/y3HPPIRqNYtOmTVzKBsD9MuoJhkIhXuvExATkcjkcDgcbXdL1A/JDsKWlpZxR0uiGWCyGyWTi+cVbbrmlQGqJWLQkl7RUBINB3HHHHWhqasL//u//Lkuj88ILL1x09u973/tewb+FvbjTAWkFbtq0CTt37sTOnTvxjW98A7t27VryGv8UOKsC1GL4oC03gPzQavEcxvuhmAgRDAYxODiIcDgMs9kMo9G4QI8rFouho6MDFosFLS0tAIAXXngBjz32GFKpFJxOJw+0dnR0IJVKYWxsDPX19ZyJNDc3s6IAzT8B+R4VlUqcTid7HNHfkDU12ZYTY4pcawGgpaUFZWVlLHUklUoxOzuLlStXsm8OfcmJJq/T6TA6OlpQDiJjuuPHj7OdBzXnacOhgVjg5KwPDa8KSQ60qbtcLkSjUe67UCAgTTliNtIp2mw2Q6/X47bbbkNdXR127tyJv/7rv2aFDgAsGaTX6zE5OYmpqSkYjUaUlZVhx44d+OxnPwsArAe5fv16PPzwwygvL+egKZfLEYvFuCyXTCY5mykudS22kdD7K6aXFxM4hH9fVlbGByra/Mg0U6FQcHAnssPc3BxnaRRQSYmDyqbRaBQ6nW5RSSEqVQnX297ejoaGBpjNZn49CtJksCgSifgzKQZdG5lMhhMnThT0muj3IlHegZkCIL1XofOw2Wzmx1KpWNivGh8fR0VFBaanp/n76Ha7sXXrVhw6dAirV6/mjIrU76emppY9fDs4OIibb74Zd999N2666aZlkyH27Nlzyt+djmi20+nkgzyQN4fcsmULzGYzVCoVC3Bfe+21eOyxx5a1xj8FzvoAJcRSTw+nAknfnC5VnhQh7HY7EyGIkUabLG1gpGUWi8UwMjKCxsZG6PV6BINBPPbYY/D7/XA6nRgZGUFJSQkGBwcRCoUglUpRU1MDvV7PJnvhcJhnnqLRKKqrq5naKwxWZWVlsFqtyGazC2SPaLOorKyERqPhnkosFoPT6cTw8DDS6TTsdjuGhob4tFpdXY2hoSEOSqQOTqdlkqk5fPgwjh07hkQige3bt0On0yGZTHIPi/pM1FsqLS2FSqUqGMbU6XRMOhkeHmZ6+tjYGDvtUqmC3EozmQyOHDkCrVaLqqoqWCwWKJVKnHvuuQCA73znO/z82WwWJ06cQDwex7nnnlvgOjs3N8f282QZIWRDCtUTACzQABSiWM18sXuLMqFiNZLFAlQul4PRaCzI9ulvhoeH2W2Yro/w8RaLhe1XhOunzZ0GnVtbWzE4OIiZmRleu16v59O80MBxamqqgHFI78/n8/EgNQBWmxc+J1UaKMvzePIuvyUlJYjH4/D5fNi2bRsTHki5AgDrJFJAJYYpsTxprUajkT9PWvvGjRuxZcsWiMVinH/++bz2bDaL7u5uiESiJQ3pC7F//37cc889eOSRR7Bhw4YlP/50QaLZ99577ylFsy+++GJ885vfZDbmSy+9hH/+53+GSCTCFVdcgX379mHr1q3Yu3cvmpqaPrS1ftA46wPUh2G5QQ1Ncms9FYSKEJSNFBMhhCf0VCqF6elpdHd3c19ndnYWvb29+I//+I8C/biGhgZEo1G43W4EAgEWMSVGmkqlQkNDA5fH5ubmEAwGWQGAnD81Gg3GxsYK5GrIR8fpdKKkpAQymQz9/f3MnFOr1fB4PBgbG2NrDJVKBY/HwwKxJEZK4p9qtRparZZ7QQqFAl6vF1KpFAqFAhs3bmRWFlGYAfAs1fT0NFKpFHw+H3Q6HVwuFzesfT4f5HI5SktLMTg4iNHRUT7pA4VDplReExoYUtnn3nvvXfAZUhZrs9lQV1dXEDSIPk/3FF3n8fFx9PT08N8Ke0ZDQ0MoLy8vYOYRyDRReJ8JIVRdWMyNd7EAVVw6Fv4NyTgtVlKi9Uml0oI1UYAkKngikYDJZCoIJsIgVKyrJwzANpsN09PT7HdF14KyNaF+oVgshtFoZAklIaMTyPuS0b2l1+sLAhSQ/wyKXYfpsJfNZuHz+Ziynkwm2ZuppqaGv+f0fIlEAkePHkVpaSnPES4FuVwOjz32GP7rv/4Lzz//fMFIxoeBU4lmHzp0CA8//DAeffRRmEwm/OM//iPWrVsHAPh//+//8b70gx/8ADfddBO+9rWvwWq14oknnvhQ1/tB4qwPUKdzelgOXC4XZziLYTmKENFoFF6vF1VVVXA4HAiHw9i1axdefPFFSCQSOBwOaLVaiEQidHZ28uOam5u5di90KxU6965cuZKDBQWtbDbLf2MymeDxeBCPx1mTLplMorKyEl1dXbDZbLBYLMzao9en3hUFOIvFwn0J6tVRUKAsJpPJoKenB01NTWyYp1QqOQCTggWJrQ4ODqKmpobVHkhBPR6PF7Ap/X4/z2z19fWhvLycmWi0GRqNRlZHNxgMqKurg8PhWNTfy+/3o6+vD42NjQsoz4uh2PU0EongxRdfXEAdJ5Yh/T+Bem9ms5nV3IUoKytjcs7ExAQsFgszExfzFxO+DqGYcAGcLIVNTEygvLycXXOFvyOQYSENbwMngxaRTYRD0HSvEztTGLy8Xi/kcjkL/hZ/BsKAQpqCxWsX0uWLWXgk8SQWi3nN9Lw0dzY2NsYtACCfRV111VXcM6XqBs0plZSUwO/3c7lyqUilUrjnnnsQDAaxZ8+eJTkaLBdms3lR0ezW1lY8+uij/O/bbrsNt91224K/q6ioKBhh+TjhrApQN9xwA/bt24fp6WmUl5fj/vvv/1AsNwCwYsFiAWqpihC5XA5DQ0OYnp5mVp/P58MTTzyBUCgEm82GyclJ6HQ69Pf389Q6lbt8Ph9CoRBCoRCbDcrlcpZ9kclkOHr0KL9eZWUleyPV1dVhcnISpaWlBQGtqamJpYboS0kzUkC+Zm0ymaDX6zE7Owu5XM5lH3qNXC7HjWiSiKIGdiaTQTKZREVFBbxeL6umi0Qids4lhW+1Ws2boVarxcDAAKRSaQG7CwDPw/T390OlUmFqagpms5n7jlTGJIKE0WjEzp07F6VQ9/f3IxwOs1XJcqBWqxc9kAjVHsgnaGpqihUnyOG4+MQvVHnI5XLw+/2orKzkNRcjGo3CZDIV9LZoLSqVaoGEUiKR4HLZYsPFBDrkEKiKQPNr1FsC8vfeueeeC71ezx5dQlgslgXvkyB8T3SflZeXFzBofT4fqqqqCq4NvYbX62ULlGAwyNeADkLUk6bXMZlMuP7667mnqVKpoFKpeE7J6/ViZGQEarUax48fZ4NDo9EItVr9vpnUzMwMbr31VmzduhV///d//xcl8o8AZ1WAeuqppxb9+QdtuQHkTxXFTL7lKELE43F0dnZCr9dj7dq1EIvFeP311/Gzn/2MNwG1Wo3GxkY2GCRV6cnJSd64DQYDbDYbz6WQA2g0GsXMzAxsNhusVisUCgV6e3v5lGu323kzJ8fXkpISHD9+nL/0lF0BJzXs5HI5Dh48yGtcv349Tpw4AafTyUwmym7sdnuBOoJWq+XmvTBrMpvNiMfjkMlkLK1EigbJZLJg5ojeJz030YqpP0TW4EL9OyppUbZBh4fiz6OjowNms3nJsyyLgfqVQqhUKojFYszNzSESibBtebECg3DGCVg8CBFolMDj8WB2dpYtN3p7eyGXy1kqKJFI4Nxzz4VareaNXnhvUumQGHbF0kfUyxQOa9I1crlcPPe0atUqfj/xeJz/v1g1XagOUUyOEL5fys5KS0sLApTf70dZWRmi0WgBOYNA1HDgpD1H8VB0NpvFhg0bsHXr1lMOx/f19SEajWLjxo2QSqUshzU3N4f+/n5WuDeZTDAajVCpVAX3TldXF26//XZ8+9vfxpVXXvmxVNL5OOKsClAfJTweT4Ev1GJEiPdShADAs0cNDQ0wGo2IRqN4+OGH8eqrr7IskUwmw8zMDFPKJRIJ6uvrMT09DbfbjVQqhWQyiXg8zuwoIJ/BiEQiLsUQE4sca51OJ+x2O1PKSbKmtLQUvb29KC8v57r78PAwv35JSQk2b97MMy7U2O7q6mIG2MqVK3kj0ul0BRsP+S2pVCouC1qtViSTSaTTaQQCASagKBQKVo/P5XKYm5tDWVkZ23IHg0GEQiG4XC4MDw+jsrKS+2QGg4Ep9UA+YI2Pj0Ov1yMcDrMIrRBEF66vr1+2jFUxSDZKiMVYahRACOl0GjMzMwVZ93sFqHA4zEaQFouFTQuBfLCjwE0GjySEGovFCu5P4exWNpuFXq8vKNnJ5XK+z8rLyzE9PX1K9iCBsjWibwsJHpTJL3ZdiIQkk8lYKZ02dmKVNjU1LWAMqtVqLp1NTU1xedbv9/O9PzY2xgeVTZs24Zxzzln0upKLtU6nw8qVKwsyS7KQcblcHLCoehKNRnHs2DE2WnzkkUewa9cutp5fLs5Utoiwfft2DAwMsKDBJxV/tgGKMiiyivD5fKckQhSDZoXS6TRaW1v5CxoIBOB2u7Fy5Ur09vZCLBaz6ZrD4WDTvp6eHiQSCUxNTaGpqQlerxc2mw3Nzc1IJpOcyRGcTicPGJKMjVqt5pKeVCrFypUrWcYkm81idHQU9fX16OzshEKhQHV1NTQaDbRaLcbGxnizKC0tZZXy+vr6ArdX6vVks1mUlZVBLBZjYmKCTQcHBwdZNok8k0wmE3K5HFQqFdt7UBA0mUxc0jSZTJidnYVIJOINSjh8qtFoCk7aKpUKcrmcTepqa2sL+kADAwOYn59fNl34VGhqakJHRwdmZ2eZjr8Y+7P43yQNRZvoYiKytHZgYb8GKAxownuR3HAp+C02rErPMTExAa1WC7VavSBgCgdtqQ9a/DugUKgXyGcuBoMBZrMZQ0NDfBjw+XysUEJ0c/o3HWZofYODg9i0aROrogudeEdGRuD5P/UUUoBwuVz8nRHKVd1yyy2ndLWNRCI4duwYKisrF5STiyEMWG63G7lcDiUlJfjJT36CN998E1qtFg8++CDa2tpwww03LFCsP12cqWwRAPz6178+Ld+6TwL+bANUZWUlxsfH8fWvfx07duzAqlWrWC7mvYgQwWAQXV1dbPcs3BwcDgeuueYaXHPNNew1dfToUbS3t7N6eCKRgEQiQV1dHW80NExHsizxeByVlZVQq9WQyWQ4cuQIcrkcJicnYbPZIJVKMT8/z19ai8VSQCkvLy+HXq9HLpeD3W5nD6bOzk6k02loNBrU1tayKR5tuDqdjunyTqezIKPzeDzwer0wmUxwOBwYGhpi+SOVSgWlUgmZTIa+vj4eOAbynkAjIyOorq5mySFiUAqb4ULxV6CwUQ+AS4dbtmzB5Zdfzj9PJBLo6OiAwWBAS0vLB1562bp1K7Zu3Yr777+ffyYczBWuQwhhcNFoNAgEAouuLZlMcgAr7hsJy2n0MxoNAE4GkXA4DI/Hw/p4QD5ToqAXiURgMplYkqr4OclKw2q1cumPnptmx4RkABoSJ5JBSUkJ+6NFo1FeNzFI4/E4ysrKMD4+XiDxFI1GEY1GWbaKXpMOj0RWSSQSTMgATvby1q1bd8rgND09jb6+PjQ3NzO5YimIx+N46KGHoNfr0dfXB4lEgqNHj2Lfvn2n7EWfDs5UtigcDmPnzp145JFH8LnPfW7Z6/i44M82QL3xxhvo6enBrbfeiqqqqtMiQni9XkxNTTGF9b2gUCiwevVqrF69GkC+Bn/s2DEcPXoUY2Nj8Hq9HADUajVqa2uZnSQs90xOTkKlUsHpdHL2Q6Ukktmh2RCyFu/r6+PsQ61Wo6GhAdlslvtfJpOJBTGBfF9g7dq1SKVScLlcKCkpQTqdhsfjYZ8h2hR7enqQSqVgs9ngdDpZ1UIkEuHVV19FKpXCmjVr2FQwkUigoqIC2WwWY2NjPMFPmycFULVazaQMkSiv0E69glAoVDDYSQGVKPx1dXVnJCVzOiAihN1ux+DgYIGsDM2JUaABCoPLe5E0yIpC2GujwFGsYUd/L6SQA/nMPRAIsFwV8N4KEMWvU1JSwvcCafIVyyYV956EJ3iad6Osl15bqHYhVNoQiUQFYwT0WkJmIYAF/TNhL/Cqq65aYDlCr+P1ejEzM4OWlpZlEWQmJiZw00034brrrsOdd97J12DNmjVYs2bNkp9PiDORLQLykkVf//rXPxL24NmAP7sAlcvl8Hd/93fo6upCWVkZrrjiivclQiQSCXR2dkKr1aK1tXVZ7B2tVotNmzZh06ZNAPL19Pb2dnR0dMDn8+HIkSP8t0JKOamFp9NpLumRky7NRMXjcUxOTqKsrAxdXV3QarXskRMOh1koUiQS8SCvy+Xi57bb7WzKBpy0ZgdOZk5ms5n12SYnJ1kkla6pXq9HS0sLy9BMTEygoqICo6OjbHkOnCxP0eOIhUWlvrm5OXg8Hg7e09PTaGpqQigUQiKRQDAYxBtvvMGDvc3NzadFIT9TUJ+M5J2EwSMSibBBI3ktCTdXpVIJu92+ICsE8teDSmF+vx/pdJqvlbAkKMx2CML7kK4HQa/XQyqV8rUWiUQLsjx6TuEmTgGKfkbPmUql4HA4MDMzg2w2y6VcwszMTIHhIbEZCVqtloesW1tbuUwstDMZGRnhCgGQZ0iScv7o6ChyuRzMZjOuvvrqAjklQiaTQXd3NyQSCdasWbOs7+m7776LL3/5y3jwwQexbdu2JT8e+PBki44cOYL+/n78+Mc/XiAJ90nFn12AosnqH/7wh1i7di0uvvhitLW1YevWrdi0adOCkwnN0nzQp3Sr1YoLL7wQF154IXK5HIaHh9He3o7x8XG88sorvDlVVVUhkUggk8nA5XIhEAjA6XQW2G40NDSwBA950jgcDrbYMJlMMJvNkMvl6Ovr41p+Q0MD69nZbDbI5XLodDpMTk4il8tBqVTyOiYmJjAxMYFEIoENGzZwA54m/0lOqVgpgCCTyVhxneRqSEopEAic8uRMJnUNDQ2IxWL47Gc/i/7+figUCqjVagwODvK8FQ1NfxjGcEJ2HAA2lDQYDMwGzWQyTEoQvofx8XE4nU7kcrmC90nvlU7HRFrQ6/UcCAjFuntAYe+J+oUE8uyi0zfNnQmxWICi/3/ttddYlQPIB6rx8XGIRCJUVVXB6/XyCAKBVEbIV2wx1QkgH5S9Xi/0ej1CoRBn00qlkkce6NqMjo4WSBZdc801i/Zf4vE4jh07BofDsazB2Vwuh2eeeQb/+q//imeeeYb1F5eDD0u26I033sChQ4e4sjE1NYUtW7YU/O0nDR+LAPXCCy/g7rvvRiaTwe23376oYsBS8OlPfxoAcPjwYQQCAbZjvv/++6HVarFlyxZs2rQJjz/+OD71qU/h85///IfqhkklDyp73H777Thx4gR6e3tx4MABDA0NIZvNsup5IBBgjb5iSrnBYIDH44FIJGJKuclkwsjICA9DlpaWsndTMplk2SWtVovh4WHWtiP3YeojiMViyOVyiMVi3lQ1Gg1vuqRCTkaG9N7S6TQP5w4ODiKTySCXy6G6uppnb4QbdzHbLRAI8HBkV1cXampquMfl+T8/oGAwiNnZWYyOjvIQL1GGz6RnQKDPnzbaXC7HiglCRCIRVFdX8+dBtuijo6MLysI0Q0bPSaUx+qyFfblEIgGHw1FAEBAGHJvNtqgAsjAwFF/XWCwGz/95SBGI0VZeXo6ZmZlFFS+E10AICpBkx6FQKFBZWYm5ubmCv6V1K5VKfj8ulwtisRgjIyMLgjg970UXXbRocJqfn0d3dzezaZeKTCaD7373u+jo6MDevXs/1Iz8TGSLTCYTvvSlLwHIK5pcfvnln+jgBHwMAlQmk8FXvvIVvPzyyygvL8e6deuwffv2D0xPSq/XY/v27di+fTtLGz355JO48cYbUVVVxf48W7duRXV19UcynCeVStHQ0ACFQoHy8nLeyDs7O/Huu+9iaGgI8/PznCWVl5dzD2d0dJRnWaRSKerr6xGLxVBdXY35+Xnkcjn2pQLymc3atWuZkEEyMwcOHOANTafToaGhgdmDwpOxSqVCMBgsaN4LVQJqamq4tCPUtXM6nThx4gTUajWXJ8k8MZlMwuPxYH5+ngd+SdRz9erVCxx0SULIYDCgqqqK3VJnZ2cxODgIkUjEGntkO79UEGuruExX7HdETXWCx+PhDEFYniOm22IMPKKoE92crjcdCghkSmgwGFgmqHg9xEgNBAJMVggEAshkMvD5fAiHwwXZXiQSwerVqzkbPpXwK72+8ICSSqV4PovuL5q/I2NEo9HIowQqlQoajYbntei+ocHc4l5cOBzmXht9D8fHxzE6OrrofXE6CIVC2LFjB2pqarB79+4P5DDzXjhT2aI/N5z1Aeqtt95CTU0N++Bcf/312L1794cieCgSiXD06FE899xz2LdvHxobG9HT04OXXnoJ3/rWtzA0NISWlhZs2bIFW7ZsYRv0DxrC4V8SsmxtbUVraytuueUWzM/Pc7AKBoOsiNHV1YWSkhLU1tZCqVQilUoVGM41NTVhbGwMdrsdVquVxWgnJydZbdxgMCAYDGLjxo0A8tmLTCZjR1ySHnI4HJDJZLxpUnmHlM0tFgt0Ol1Bb0tolEZBgqjE4+PjsFgsTO6IxWLYvHkzJicnYbfbEY/HeRD6/UByQ1SSJVHYqakpHD9+HDKZjMuBws3uvUD9G5VKVeAyW+zvVHw/hMPhAqWH4vcvhFDpPJFIYHx8HJWVlRgeHobRaEQgEFgQMOLxODQaDbPvFrsfzWYz3n77bQD5nl5dXR1nZCMjIws2ZeH7KX49j8fD74OyH5pLkkgknDWVlJQssHC3Wq08d5XNZjE4OAiVSgWbzYbR0VGmgvv9fjZsJPWKiy++mJX0g8EgFAoFGyKSZ9pS4fV6cfPNN+MrX/kKbrnllo9k+PZMZYsIHo/nEz8DBXwMAtRijJaDBw9+aK+3adMmvPrqq3xibmpqQlNTE772ta8hlUrh4MGD2LNnD2655Rb2s9m6dSvOO++892X2nQ6o5/Vew6YGgwHnnXcezjvvPORyOUxMTKC9vR16vR5Hjx6FRCLB8ePHkUgkoNfrWZ+tv7+fGV8ejweBQACdnZ0oLy9HSUkJjOuT/tEAACAASURBVEYjB4hAIAC9Xs/luJqaGi7bicViuN1ueL1eGI1GaLVaZLNZvPLKK7j22mtZtikWi7FvFj0PKW9LJBJYLJaCjES4aafTafj9flxzzTWnNcfyXlhMFJbKgaTYQAGrWPJGOGNVvMbF/l0MoZoDDbkKWXJCLCZPNDg4iKqqqgJbCqEUEfXoCOXl5ZidneXgEQ6HF0gRSSQSlJWVccZLqh4EoVmiMEBpNBouGQtBmaFOp+OyFJVg6fF2u50zS2HWZTQa+R4odgkeGRmBXq/HNddcw3uAw+FAKpXCkSNHeFbx7bff5uxssc9wMbz++uv4xje+gX//93/Heeed955/+xf86XDWB6iPGnq9/pS/k8lkOP/883H++efjvvvuQzAYxP79+/Hyyy/ju9/9LtRqNWdXLS0tC/yh3gtkCRGNRpekHycSieBwOOBwOHDJJZcgk8lgaGgI7e3taG9vRzAYhM/n4xO23W5nL6ZUKsXzOSqVCgcPHoTdbodOp4Pb7ebHkEcP1ebJiwkAmx7q9XpceeWVMBgMUCgUCIVC0Gq1kEgkPKFPG1BVVRX6+voglUpZSZveixCxWAwrV678wCm1pHDhcDiQy+VYVHRgYICVr41GI3Q6Hfr6+qDT6dDY2Ig33nhjwXORrYjw8xCCNAsJRL1/r6ytOGsRMuQAsHwS2Z8I+1LEdrPZbJiamuKgIdTzS6VSCwgTQgmheDzOGcliVHetVlugmkF/I7xni/tUwtcT/p1MJuMAOzc3h/LycojFYgwPD6OsrAzXXXddwXcyHA6jo6MDVVVVfODI5XLMAKXP8FSyRblcDk8++SR27dqF3/3udwuIHn/B2YWzPkCRdxJhdHR0UeXqPwV0Oh0uv/xyXH755ZzJ7NmzB08++STuuusueDwetLW1oa2tDbW1tafclCKRCDo7O2G32xdYQiwVEokE1dXVqK6uxlVXXcWq7O3t7eju7kYsFmMGoFgs5n4DeRzNzc2hrq6OJZUqKioKNuCKigoMDw9DpVJxmWVkZISV3ok95nK5mJFFFGoAzFjUaDSw2+3IZrMoKSlh6rZCoWBJo5aWlg993oOCs1BUNBwOY2xsjMuBCoUCSqUS119/PaampjiTpH4XKeMvBjI1FM4sWa1WaDSaRWdgdDpdQQkRKBSnBU72+IhxWUxkoCwLyPeJYrEYamtr0dfXx9e7uCRGNiAWi4VLb0C+jOd2uzE3N4eSkhKEw2F4vV5YLBao1WpWuxeui9YA5A8ZEomkQGNPo9FAoVCwYG4ul+Osiu41t9uNm266qeCQ5/f70d/fjxUrVhSQJUQiEdRqNdRqNX+GxbJFzz77LA+fx2Ix7N2794wrHmciWxSNRnHttdeiv78fEokEV1xxBR544IEzWs8nEaLFmqACvOcvPwqk02nU1dVh7969cDqdWLduHX71q18tOqR3NiGbzaK3txcvv/wy9u7di4GBAaxevRpbtmxBW1sb7HY7D7cqFAo0NTUty256qaATaHt7O+bn5/HHP/6Rf2e1WmE2m1nuKBgMoqamhoOOSCQqMA+02+08r+TxeLi8Q/9OJBLQaDQs8Do9PQ2LxYKhoSHYbLaCjbi0tJRp7IFAAHfeeecZ654tB0Q08fl8OOecc7hhT7bxfX19XD4VCg5rtVoEAgFUVFQU0OupF6jRaAqyiKqqqoL+HJDf4PV6PVQqFSvE08+p30IzZ6QkMj4+vmiZsbS0FOPj45BKpRwsRkdHkUwmmVAglDYC8v2RbDaLmZkZpoATSDVFqEThcDg4QNrtdoRCIVaUMBgM+N3vfgexWIzNmzdDp9MVzAZR5iIM7DqdjkcGrr/++oIy4dDQELs9L6UyQY/fu3cvfvzjH8Pn80GhUGDt2rW47LLLcPXVVy/puYS45557YDKZWLZobm5uUdmi1tbWAtmid955BwqFAgcPHkRbWxuSySQuuOACfPOb38RnPvOZZa/nY45FT+VnfQYllUrx85//HBdffDEymQxuu+22sz44AfnspLGxEY2NjbjrrruQSqXw9ttvY8+ePbjtttswNzfHpIT//M///EiCE5A/vW7YsIEdQL1eL15++WWEQiF0d3fzUK9Go8H69euRSqXYoC8SifAmS8oQFRUVrFIubKAHg0HMzMxAJpNxv8TlcmFmZgZut5ut6Al0wqa5rT9FcMpkMujq6oJEIsHatWt54yeGIACsXr0av//979HZ2blAO1AsFvMGDeQDOpXNiEASjUYLhGCF0Gq1rA6v1WoRCoVQVlbGNHCpVIpUKsUZk5BoUhykxGIxK4IQSLRVqEBOUCgUkEgkTAKhEi2pekxPTy+Y2aHnTiQSmJ+fRzgcZsIEBdvm5mbEYjHEYjEuTdpsNibrCBEMBtHS0oKLL76YGXmZTIb1JJc7fNvb24tvf/vb+Id/+AdcffXVyGQyePfddxcE6KXiTGWL2traAORLni0tLQXak39BHmd9gAKASy+9FJdeeumfehlnBJlMxkoSl112GW6//XZs2bIF2WwWV155JZRKJfevhAK0HxZIJHdiYgLXX389KxqMjIzg6NGjCIVCLDTq8/nw+uuvc2Pbbrejra0NXq8Xfr8farWaT8c2mw0TExPsLyUs7YTDYYTDYaxZswaTk5Mwm808TS8sAX7YDqWLIRKJoKOjgzUWTwWJRMKbMK0ZyAulUlAwm81M26dsKpFIsFNwMBhEIpFgO5JUKsUK74RwOIy6urqC/hX1icj/S1jas1qtrOWYSqUgEolYSUS4dgAsoyUcpi4pKcHU1BRf+2w2i0AggLKyMshkMl6zELRetVqNUChUUFqcmZnBJZdcglAoxG69CoWCvdCEIwcEj8eD7du3cxCKxWI4duwYnE7nssv6L730Er797W/jySefZJkiqVSK9evXY/369ct6TsKZyhYR5ufn8dvf/hZ33333Ga3nk4iPRYD6pGHXrl14+umnUVtbCyC/KU9NTWHPnj345S9/ia997Wtwu93YsmULtm7divr6+g90/iqdTrMkTGtrK28qIpEIbrd7QeM4nU7juuuuw7Fjx9DT0wOZTMZlP7fbXbBRy+Vy7NixA4ODg2zT3d/fD5lMxqSL6upqWCwWtnDQ6XSoq6vD6OgoYrEY6xd+VJicnMTg4OBpC4uuWrUKpaWlGBgYwP79+xGLxaBUKhGJRDhjKiYvEMRiMXQ6HZ599ln+u09/+tMFxBMgf08kk8mCLE2oXi6TyQqCPx0QLBYL5ubmIJPJFmjb0eMp0FDwE7olF2d2Mpms4HU9Ar+qcDgMvV7PAREAS1UJFflLSkoQjUZhtVpRUlLC91s0GoXT6YTf70cymYTT6eT7fG5uDj09PafthlyMbDaLhx56CM8//zxeeumlZbNAPyzZIkI6ncYNN9yAu+66i0dp/oKT+EuA+hPgJz/5ScG/RSIR7HY7brzxRtx4443M6CN24IkTJ7Bq1SoOWKWlpcsmUpAaQ0VFRYFV9ntBKpWipqYGNTU1AE7K3oyNjcHtdqO/vx/j4+OIxWIIh8OorKxkp1hCNBrF0NAQ24D4fD4MDQ2hoqKCT8pyuRwmk4ntvT/suRS6zjRjdbpZq1gsZhbgyMgIz58JmXbFA80EIsQQqDxXHMzKy8s5EyWQ3T2Q38AXKwtTMKFBXCoV0u+USuUCQVsKrgAWqDgI2W/z8/M8IB4MBmG323lAmJTQQ6EQ5HI5JiYm2ICQZudIHomCIJX+KPMifb3R0VH8//bOPC7qOv/jz2FgGA7B4RAUVFQOEVEOz0wFOiw1zCOlNn+aHWq2edSqZe26VrZaVpp262a5RuquYVoqUKmZSSrigSegnHINhwjDzDDf3x/s97OMICLgPc/Ho0cwfOdi5Pv+ft6f1/v1ys3NJTQ0tFmxFjqdjlmzZmFtbc3OnTtbFL9yvWyLZJ577jn8/PyYNWtWs1/jncwtL5KwUHuVdfDgQSG4KCsrY+DAgURGRnLvvfc2af+q7uZ/UFBQq8xsNYRer29UIl83S6tHjx5myi+dTodWqxUnOlkq7OLigp2dXasWLNm7zd3dXQRUNocTJ06QlJREcXGx2FNTKpV4eHiIvRkZeVBVvto+dOgQ1dXVDB06FAcHB7H/ZG9vL5w3bG1tzQpdu3btcHBwIC8vr0HFX4cOHUTrSX48uTUouzZUVlYK5VtxcTEajUYIXOSTroyPjw9ZWVk4Ojri5uZGTk4Onp6e4jZ5z61bt25iD0XOj5ILlLu7uwgolDPA2rVrh62trciNGjFiBCEhIZw5cwaDwUCPHj2a5fhx4cIFJk2axJgxY5g5c+Z1dX75y1/+gqurqxBJaLVali5danaMVqslPDxcGD2HhYVx8OBBXFxceO211zhx4gQbN25scAbuLqPBN24pULchFRUV/Prrr8THx7Nnzx5UKhVDhgwhMjKSvn371isQsqOESqXC39+/WX/4rYG8epANPRv7Y6wrFdZqtSJBVy5YLbkqlpN3m+vd1hBVVVUYDAays7PJysrit99+E60tmQ4dOpi1i06ePElpaakwDJZP9o6OjqIoyY72MnJ0SWFhIXZ2dvW8AL29vcnLyzPLdpLjPBQKBYmJiYSGhuLs7Cwyo9RqtSikDg4OuLq6UlFRgUqlEmGCULsakCNH5GIkr8I0Go3YU5Rbe3KUCtQW1rpO7TIeHh7cf//9eHl5cfToUVxdXZt9wXD48GGmTZvG0qVLeeihh675/tdKcXEx48ePJzMzU9gWubi4mNkWAaxZs4bFixcDsGDBAp566imys7Pp2LGjsDQDmDp1KtOnT8dkMt0QS7VbDEuBuhORZ0kSExNJTEwkKSkJLy8v4dB+4cIFtm7dyrx581rkxtBS5H2e5srp6xrClpSUYDQar9kQVpYrFxcXCwn59aC8vJxly5bVi8Dw9vY2k2mfPXuWoqIiRo4ciclkMlPw1VU11v2/j48POp1OFBS5TSunQ8uGw3KMCdTKx2X/RdmlpG57V47OqLtyks2D6+4vyunLbm5uaLVas+Lr5OSEUqmkrKzMrLXn5uYm3MtlT0SVSkV+fj52dnaEhoaKkQN/f/8G22RXQ5IkNm/ezHvvvcf69evp3r37NT/Gzaa4uJjRo0ezbt26u3V4uMECdceX6Y0bNxIUFISVlZWZN1hdsrKyiIyMpEePHgQFBbF8+XLxs4ULF+Ll5SXCB3/44Ycb9dKbhNwuefzxx/niiy9ISUlhxYoVODg4MGXKFJ599lm0Wi07d+4UsQs3EpPJxMmTJ7lw4QLh4eHNltPLhrBdu3YlPDycPn36iEyqQ4cO8ccff5CWlkZJSUmDEm7ZHsdgMLR6LPzlyPsmcgCj3E69fFUgD5teXsjq7rvUVcZBbWuyrrIvLy+PvLw8MVhrZWWFQqEw8z2UXeTlk3/d+8su6JdfscvxK3WRX6Ocilz3GNkrEP7nFKHX6ykrKyMtLQ13d3esrKwoKSkhPz8fLy8vpk6dip+fH8XFxTg5OZGens6hQ4fIyMigrKyswc/xckwmE4sXL2bdunUkJibeNsXp8r/DNm3aEBoaKla9N/rv9FbljhdJ9OzZk//85z9MnTr1isdYW1uzbNkywsLCuHjxIuHh4TzwwAPCkHb27Nm8/PLLN+oltwiFQoG3tzc7d+7kvvvuY/HixRw7doz4+HimTZuGVqulf//+REVFiQHK69X3rqqq4tixY7Rr146AgIBWfZ6GDGG1Wi0XLlzg1KlTQnAhD5+eOHHCzB7neiJ7xMkuG5IkiX2Yy4+D2pNR3Tbe5S1YLy8vioqKUKlUQikozxTJWFtb06FDB+F3J0u5L38eMHdkl4/JzMzE2dlZ/D7ltlVdqqur0Wg0nDhxQgxojxw5koKCArPPtm5hc3V1JTMzUyTturu7Y2Njw8iRI8nNzaWsrIz+/fuL16jT6SgpKannk6jRaHB0dDR7noqKCqZNm0anTp3YunXrdXciby3qRpb88MMPDB8+XOS5bdy4kZCQkLt5L8qM2+MTbQGBgYFXPUZWZEHtlUxgYCA5OTnXxTH9RqBWq3nllVfEMG7fvn3p27cvr776KlVVVezZs4f4+HiWLVuGUqkU+1f9+vVrtZVFQUEBaWlpzZYJXys2NjZ4eHiINqbsr5eamkpFRQUajQa9Xi8ytK7nCUCeQaqbMAvUmyOST+T5+fn4+PiIOabLVzPyCsfT01PMLRkMBlxcXKisrKSmpgaj0WjWotPpdDg5OWEwGMTj1Y2tkAeo6xar8vJylEqlUAqeP38eW1tbPD09OX/+PDY2NuzevRs7OzuRZSUX3cvDFTt27Iitra1Z9EhNTQ1dunRhyJAhnDlzRrT46n4WarW6QZ/Ec+fOUVFRIT7TsLAwFi1axLRp05gyZUqzP8+rZc1VV1fzf//3fxw8eBBXV1e+/fZbESHy9ttvs3r1apRKJStWrGDYsGGNPpfBYODkyZP07NkTqFX0vfLKK/zxxx+MHz+eRYsWiRGNy1Wwdyt3fIvvWjl37hzJyclmaaIrV66kV69ewgHiVkehUIjidDl2dnY8+OCDvPPOO/z+++9s2bKF0NBQ/v3vfxMREcGYMWNYsWIFx44da1KL5XJMJhOnT58mJyeH8PDwG1KcGkLe4HdwcGDo0KH4+/sL+6nff/+d48ePc+HChXpO361FQ5lVl0umbWxscHd3R6lUcv78eQoKClCr1Q1ukMuO8HXRarXiMR0dHc1WVFArePDw8BDZTLILSGVlJfv27cPGxsZMWu/g4CAcTmSqq6vJy8sT4wQVFRXk5uaKebEff/xRxK7Iw8mytdX58+fNUqgjIiIYMmSIUE9ezXdS9kn09vYmODiYAQMGEBgYSH5+PjNnzqSkpITdu3fz1VdfmYU7NhU5a+7HH38kNTWVb775xiyeBmD16tVoNBrOnj3L7NmzmTdvHgCpqanExsZy/Phxtm/fzvPPP1/v86mLnMEVFxfH3//+d7p3786ZM2fYunUrTk5OvPbaayxYsECYCUP9mbS7kTuiQN1///307Nmz3n9xcXHX9DgVFRWMHTuWDz74QOyVTJ8+nbS0NA4fPkz79u156aWXrsdbuCnIexUTJkzgs88+4/Dhw6xcuZK2bdvyzjvvMGDAAJ566im++uor4ZLdGDqdjkOHDmFjY0NISMh1TSFujMrKSg4ePCisdqytrXF0dKRTp06EhobSv39/vLy8qKys5MiRI+zfv59Tp05RWFhY7yTfXCIiIswUk9bW1lhbW5s5IrRr147u3bubFQQnJyccHBzw9PQUQZTu7u7ipH85dUP+6qJWqzGZTGRlZQlPO6PRSN++fQkPD6d///5ixSQXRHkfSx6alYufwWDg9OnTFBQUCAuqS5cu4efnR2hoKAcPHiQ5OZm9e/eKeaDc3FwMBgPFxcW0adOGJ554gt69e5OSkkL37t0bdetojF9//ZWDBw/y888/c+rUKWbOnElhYeEVzXobo27WnEqlEllzdYmLi2PSpEkAjBs3jsTERCRJIi4ujpiYGJF/5evrS1JSUoPPc/ToUT766CPUajUeHh689dZb3H///URGRtKxY0dmz57NF198gb29Pb/99hvLli0DuBuVfPW4I1p8jQ3TNRWDwcDYsWP505/+xJgxY8TtdZVvzz77LCNHjmzxc92qKBQKMZA7bdo0ampqOHz4MPHx8Tz//PMUFRUxYMAAcSXs7OwsroBzcnLIzMxsVel2cygoKCA9Pb1RteCVEniLi4tFAq8sZ3d2dm7WicLd3Z1u3bphZ2dHSkoKeXl5osC0b98ek8nEnj17KC0tFanGkiShVqvNBnk7d+4sfAsbSoxVKpUoFAqMRiOenp6iKNSVgssoFAqqqqrEDNKlS5fIzs5GpVKJSBXAzLbK2tpaZDPB/wqi/BynTp2iU6dOtGnTRog+srOzxRiB0Wjk0UcfxWAwkJaW1myBitFo5LXXXiMnJ4fExETxXGFhYYSFhV3z40HTsubqHiP7CxYXF5OTk2PWpWjIwkhGo9Ewa9YskpOT6dmzJ++//z6nTp0iMTGRgQMHiiyrpUuXMnnyZFauXElRUZGQ7d/NWEo0tZuWTz/9NIGBgcyZM8fsZ3X7+ps3bxb947o0RSkItf3ugIAAfH19zaz1MzIy6N+/P76+vkyYMOG6tZ2uFdk0df78+SQkJLBv3z7GjRtHcnIyY8aM4f777+evf/0rU6ZMYf78+YSHh9+04iS7QsitxWtRC8qCC39/f/r160fv3r1xdHTkwoULJCUlcejQIc6dO8fFixevuoqU24j5+flCaWhjY1Nv9VNWVib2OA0Gg8ihkuebZHVmXl6eaPXo9fp6JyylUkm7du3Yu3cvSUlJorhcvq9TFysrK2pqamjfvj329vao1Wpyc3Mb9NpTKpU4OTnRrVs3oHY/bNCgQQwePFhEZmRmZuLu7o7RaBQtQ1kU8eSTT6LVaikrK2t2cSotLeWxxx6jbdu2bNy40Sxq41ZGXo17e3tTWVnJRx99REJCAi+88AKdOnVi8+bNZGdnYzAYSE5Oxs7OTuwzNtc66U7jji9Qmzdvxtvbm3379jFixAixkZmbmysMaPfu3cvXX3/NTz/9VE9OPnfuXIKDg+nVqxc///wz77//fr3nkJWCQ4YMueLraKzfPW/ePGbPns3Zs2fRaDSsXr26tX8NrYKdnR33338/S5YsYd++faxevZqdO3eSlZXF2bNnGT9+PMuXL+fIkSON9uNbm+rqapKTk1EqlYSEhLTYaFelUuHh4UFgYKDY95CNX3///XeOHDlCdna22RxQ3dehUqno1auXCGSsK/mG2nacTqcTJrGSJGEwGNi2bRvbt28nISFBBETWlaCXlZWhUqnw8vISJy+1Wm3m4SdLvetaFl3+Weh0OsrKysjLy8POzg6VSoXRaKxXPKytrSktLTVzMpcHe4uLi3F0dKR///6MGTOG0tJSkSvm6upKREQEMTExnDx5EgcHB4KCgpo1IH769GlGjhzJlClT+Pvf/96qba+mZM3VPcZoNFJWVoarq+tV72symbC2tqakpITFixfj6urKhAkTuHDhAmvXrmXOnDmoVCo+/PBDOnfuzM6dOwHYtm0bnp6eZnt3dzOWQd1WJCIignfffZc+ffrU+9m+fftYuHAhO3bsAGoVQADz58/H3d2dCxcuYG1tXe+4WxW9Xk9ERASLFi0STggZGRkkJCSQkJBAamoqgYGBYmC4Y8eO1+WKUDYV9ff3vyF/1HUdLoqLi9HpdDg7OwsFXkBAgNnrkCSJ4uJi0tPT+fnnn6moqDBzEQeE64OVlRWlpaVC+t+pUyfOnTuHp6enGOKVcXZ2RqlU8vvvv2MwGOjWrZsYAu7SpYuZi4NarUatVlNSUmJ2O9Re3ZtMJvLy8oQLe0lJCaWlpbi4uIiBYEdHR7RaLW3atBE2TPJjK5VK3NzcqKqqoqSkhIcffhh/f3+OHTvWos8lMTGR1157jTVr1hAeHt6sx2iMpmTNrVq1iqNHj/LJJ58QGxvLf/7zHzZs2MDx48d54oknSEpKIjc3l/vuu48zZ86YFeHDhw/z3HPPERkZyZIlS6iurub7779n+/btPPHEEwwePJjff/+d0tJSHnnkEaB2NX29kwxuUW7PPKg7hSv1u4uLi2nbtq3o7TfWy76VUKlU7Nq1S/wxKRQKunbtynPPPcdzzz1HTU0NR44cIT4+npkzZ3LhwgX69etHZGQkQ4YMQaPRtKhgSZIk4j6aayraHBQKBY6OjkJ0UVNTQ1paGtnZ2UJWXVRUZOZw4ebmhpubm5AZX743VFFRIVzQfX19hbO5fPFYXV1tFtkOtRlVp06doqqqikuXLolUY0DkPcmxIDqdDltbWzQaTb2Tn5yEDAg/QUdHR3x8fCgqKhIzO5cuXcJoNJKcnEy7du1wdXUVSr6KigoRsz5x4kRsbW1JTU2lV69ezfJ8NJlMfPzxx3z//ffs2LFDmMi2NlfKmvvrX/9Knz59iI6O5umnn2bixIn4+vri4uJCbGwsAEFBQYwfP174Sa5atareCnHTpk08//zzTJ48GahdOd93332UlZXx8ccf4+joyODBg8XxdVukFmqxFKgm0pjt/qhRo27CK7r5NPbHpFQqCQ0NJTQ0lLlz56LT6fjtt9+Ij49n5cqV1NTUiPmrAQMGXFOBMRqNIsQuPDz8pqmdampqOHHiBAqFgkGDBonh3JKSErRabT3BxcCBAxkwYAC5ubl8+eWXYq+xrhls3ZOc3NqT4zPc3d3Jy8tDoVBQXFzMhQsX8PPz4/Dhw2LFI4ck5uXloVQqxT5TYWEhpaWl2NvbY2dnR1VVFfb29ly6dIni4mIcHBxwc3MjMzMTKysrtmzZAtSu1AICAjCZTBQVFaHX60UxTk1NxdraGg8PD7p06cLIkSOF4W94eHizBmerq6uZM2cOJpOJnTt3XvcLj4ay5hYtWiS+VqvVbNy4scH7LliwgAULFgD126gAKSkpIqhQp9OhVqvRaDSMHj0apVJJQECA2fG3y6DxjcTyG2kiLVUKXqln7erqSmlpKUajEWtr6wb74HcCarWaqKgooqKikCSJkpISfvnlF7Zs2cKrr76Ku7s7ERERREZGEhwcfMX9iosXL3L8+HF8fHyu25V1U5AjQjp06GC2JyS3u+R9J71eT0lJCXl5eZw6dQpbW1tcXFwIDg7m6NGjtG/fnoyMDPG4SqVSrJTqzsEYDAZyc3NxdnbGzs6Oo0ePAv9LIpaTj+V/T1B70pTn0nx8fCgrKxOrc1dXV7RaLZIkYWVlxaVLl6iurkav11NYWIifnx+5ubnCOUI2eXVzc6Nz585UVFRga2tLRUUF3t7ePPbYY5w7d46amhpUKhXp6em4uLiYdQeuRkFBAZMmTeKRRx5hzpw5t43M2mQyiX+vq1evxtPTk0GDBvHnP/+ZTZs2kZKSQu/evSksLGT27Nl8ZjIHTwAAHmpJREFU8MEHYlVV11XCQn0sBeoG0bdvX86cOUNGRgZeXl7Exsayfv16FAoFkZGRbNq0iZiYGNauXXvHr8jkVcWYMWMYM2aMaNclJCSIIeGAgAAiIyOJjIzEx8cHhULBjh07cHZ2pmfPnjdVySW7offo0QNnZ+dGj5UFF5c7XMihjRcvXjQrUPC/wtTQVXm7du0oKCgQJ33ZpVy2QTp06BBBQUG4uLiYqfKKi4vp1KkTOp2O8vJyduzYIVRmnp6eBAcHc/r0abP9qR49elBeXk6nTp2oqqqisLAQjUbDwYMHgVo14LPPPktkZCTHjh2jW7dueHp6YjQaKS0tRavVkpaWhpWV1VVl+0eOHGHq1KksXryYESNGXPUzuBWQXcetrKwoKipi2LBhBAUFUVBQQHx8PD4+PvTr14+YmBhefPFFvvjiC6Kjo81EM5bi1DgWkUQrsHnzZv785z9TWFhI27ZtCQkJYceOHeTm5vLMM88IReAPP/zArFmzRL9bbg+kp6cTExODVqslNDSUdevW1VNUabVaJkyYwLlz5/Dx8WHDhg31JN0///wzs2fPFt+fPHmS2NhYHn30USZPnsyuXbvECfXLL7+84cm1TcVkMnH06FHi4+NJSEggOzsbOzs7bG1tWbt2bYsCG1uCLAQpKSkhODi4xYPIkiRRUVHBd999J9qBarUae3t7kfPk4uKCg4ODCHeUk4ydnZ3FKsrHxwcnJydOnjwpxBcuLi4MHjwYpVJptufVpUsXcnNzadu2LaWlpezZs4egoCDhGejt7Y29vT22trYkJyeL1ZybmxsqlQqVSoWDgwM6nY4nnniCLl26cPr0aYKCgq4o7ZdXkbLcXPZJLCgoICwsjG3btrF06VL+9a9/NdterLmWRfHx8cyfP1/kmL3zzjtERUVd9fl2797N8ePHmTx5MnZ2dnz//ffEx8ezYsUKsrKyhOx/3rx57Nmzh/LyctHeA8vKqQEscRu3M3PnzsXFxUWEo5WUlLBkyZIrHq/VavH19SU7Oxt7e3smT57MyJEjGTdu3A181S3n/PnzPP7444SHh9OmTRt++eUXjEYjgwcPJjIykoEDBzY4wNraGAwGjh8/jr29Pb6+vq3efpIkiUOHDrFt2zYhLKjrkydJEu3btxctOpVKJXzuunbtislkQqVS4eTkRHl5uch40mg0Qpnn6OhotkKysrLCxsaGixcvUlBQQFFREW3atEGj0ZCZmYm9vT1eXl7i/nJx7NChA6+88gpQ25a71ugSnU5HQUEBL730EkePHkWv1/PSSy/xyCOPNMtUuKamBn9/f+Lj4/H29qZv37588803ZsXuo48+4siRI0KNt3nzZr799luSk5Px8PCgQ4cOHDt2jGHDhjVJpPTrr7/y0ksvsWDBAqKjo9m4cSOLFy8WOWCHDx9m/vz5fPrpp/VMdy3FqUEsKr7bmbi4OBEdPWnSJCIiIhotUJs2beLhhx8W9jW3K6tXr2bZsmUMHDgQQAT7/fLLL/z444+8/vrraDQa0Q7s3bt3qwcyVlRUcOzYMSHfvh4oFAphECoXJgcHB/G1SqUSM05Quypxc3PDyckJKysrTCYTer2eoqIi2rdvL2aY5JWLvb09ycnJeHl5YW9vL2Z6Tp48KR4zICBAuKTLhc7GxoYjR45gMplwdnZmwIABPPnkk2RlZaFQKAgLC7vmYq1Wq3F1dcXOzo7o6GimTZvG7t27ee211+oNsTeFupZFgLAsqlug4uLiWLhwIVBrWfTCCy8gSRKhoaHimKCgIKqqqqiurr5iwTWZTCgUCu69915mzpzJhx9+SLt27YiMjGT//v2sWrWKl19+WXQnioqK6hUoS3FqOpYV1G2C3JKB2pO0RqMxixO/nKioKObMmSOsmSZPnsy+ffuE1PUf//jHdc1EulFIkkRWVhYJCQkkJiaSkpKCv7+/EFx07dq1RSeECxcucO7cuRuy7yWHBmZkZLBr1y4hOzYYDLi6upKXl4e1tbVou8lKOl9fX+B/USs5OTmYTCbc3NxQq9UUFRWRlJQk9rTkbCbZuken06FSqUhLSxNyd2trawIDA6mpqUGv15OTk8OwYcOIiYnh2LFjwiuwOb/b7OxsJk6cyNNPP82zzz7b4hP2pk2b2L59u0iw/frrr9m/fz8rV64Ux/Ts2ZPt27fj7e0N1EbU79+/32w/aNOmTXzyySdXFUTJgiaADz74gD179vDGG2+Qk5PD8uXLUavV5Ofn06NHDz799NMWvbe7CMsK6lanMSl7Xa5mg5KXl8fRo0fN7P/ffvttPD090ev1PPfccyxZsoS//vWvrffibxLyQOuUKVOYMmUKJpOJ48ePs3PnTubNm0d2djZ9+vQhMjKSoUOHNtnfTLZO0ul09OnT54ZIgBUKBR06dBDtpvz8fJydncnJyREmpmq1mr59+4o5tJqaGgoLC1Gr1QQGBgpvvaqqKrFCysrKwsbGhs6dO4sLnfT0dKDWUaVHjx6cPHmSjh074uDgQFVVFTU1NWKPy8bGhhkzZhAWFsbhw4cJCAgQ8ulrZf/+/cycOZMVK1YQERHRKr+31uD48ePMmzdPODrU5ezZs+zYsYMZM2Zw+vRp5syZQ3h4OK6ursyaNYuzZ8/y+eef8+qrr/Kvf/2LvXv3YjKZxMXhXRrh3ipYCtQtRGNXbh4eHuTl5dG+fXvhGH0lNmzYwOjRo83mlOS8K1tbW5566inefffd1nvhtxBWVlYEBwcTHBzMSy+9hF6vZ9++fSQkJPDpp59SXV3NvffeS2RkJPfcc0+DLdDq6mqOHTuGi4vLVSMhrhdOTk5UVlaSkpKC0WikR48epKam4ujoSHp6Orm5uXh4eAi3BycnJxGrAbVjDTY2NkKQoNVqsbOzE8IHe3t7OnfujJ2dHVlZWdTU1HDu3Dm8vb25ePEiOp0OX19fnJ2diYmJoU2bNpw8eZLevXs3q20sSRLr16/n888/Jy4urlXzjq7Fssjb29vMskg+fvTo0Xz11VfCc7Du6/7pp59ITU3l/PnzjB49mvfee49Tp07x2WefMWzYMN555x3+7//+j6VLl/LGG2+YzVVZilPLsPzmbhOio6NZu3YtwFWl6N988w2PP/642W2y6a0kSXz33XcNmt5qtVoeeOAB/Pz8eOCBB66YfSV73oWEhBAdHS1uvxVNb1UqFUOHDuWNN97g119/JSEhgcjISHbu3MmDDz7IiBEjeOeddzhw4ABGo5HExETWrl2Lj48PXbp0uWn7BcHBweTl5ZGbm0tWVhapqan07NkTDw8PIQrJz88Xe1TV1dX06NGDbt26ERQUJFqTaWlplJeX07FjRy5duoSPjw8ODg60adOGoqIiDh06JOTjdU12q6urUSqVzJgxA4VCQUFBAeHh4c0qTrIT+bZt20hMTGz1ML66Ixx6vZ7Y2Fizf5dg/vezadMmoqKiUCgUlJaWMmLECP7xj38waNCgeo8tD2H/+OOPJCQk8Oqrr9KlSxfWrFnD66+/TkBAAHZ2dixZsoT8/Px6/+YtxallWPagbhOKi4sZP368iOLesGEDLi4uHDhwgE8++UT038+dO8egQYNECqtMVFQUhYWFSJJESEgIn3zySb09laYqBR0dHc3MSGXGjx/PmDFjiImJYdq0afTu3Zvp06e38m+i9ZAkidzcXCFn/+WXX1CpVEyePJlRo0bRrVu3m3KCKS8vF3tLTk5ObNiwgezsbHbv3o3RaMTKygofHx88PDwoLS3l/PnzSJKEUqnE39+fU6dO4eXlhZOTE3q9nqqqKjOpeYcOHdDr9Tg5OQkfPl9fX7OYj1GjRjFhwgROnz6Nk5NTs/fyysrKePrppwkNDWXRokWtLmCRaWiEo65lkU6nY+LEiSQnJwvLoq5du/Lmm2/y9ttv4+fnJx5r+/btqNVqs7DNN998U2ReaTQaNm/eTPfu3SkpKSE2Npbp06db1HktwyIzt9A4AQEB/PLLL6KNGBERwalTp+od11CBkiTptjS9hdrh2eeffx4rKytmzJjB7t27SUhI4Pz584SHhxMREUFERATu7u7X/QSUl5dHZmYmwcHB9VYrxcXFfPLJJxw5coQuXbqIlp6dnZ0I3cvNzRVS8i5dulBYWIherxcR7CqVipSUFDOhheyo7ujoSHV1NQ8++CD33Xdfi5WLZ86c4amnnuIvf/kLMTExt83Je/bs2VRWVtKvXz+efvppAL799lu2bt1K165dSU9P55NPPiE/P5+YmBiGDx8uFIKWItVsLAXKQuM0VSlobW1NSEgI1tbWzJ8/n0cffVSEGcqzOVlZWTz88MMcO3bshr6H5pCfn8+PP/4o7GdkDAYDv//+OwkJCfz000/odDruueceIiMjGTRoULOMUK+ELMqQW3WNiTLkOPUjR46QkpIiwhZlGbqTkxN+fn5UVlaSl5dHaWkptra2dO7cmdOnT+Po6EiHDh2wtbWlsrKStLQ0oDZRd/z48bi5uWE0GunUqRMdOnRo1pzZzz//zCuvvMLq1avp27dv834pNwmdTkd8fDxz585l9OjRTJo0CR8fH/r3788TTzwBwPfff4/BYOCpp55i6tSpN/kV3xFYCpSFxpWCkyZNMitIGo2mwX2onJwcvLy8SE9PJyoqisTERDEjczsWqKZSXl7O7t272blzJ3v37sXR0VHI2cPCwpqt9NPr9Rw9ehQXFxdh63QtGAwGTp06RUpKCkeOHMHKykpkjcH/HNKrqqrIycmhsrISPz8/MjMzqa6uxsXFhcDAQJ588kkxS9W1a1cuXryIVquluroaJycnXF1d0Wg0jTpoSJLEZ599xr///W82bNjQ7Gj3W4Fz586xdOlStFot99xzD25ubuzfv5/ly5dTWlqKXq8XYiWLGKLFWAqUhcZpaouvLrJDxdixY2/bFl9zkGeW5PyrQ4cO0bVrV1Gw/Pz8mnTCqrvfdHmwYXOprKzk2LFjpKSkkJuby+nTp0VLVqFQEBISgl6vp7KykszMTMLDw3nxxRc5f/68cNmu+9pNJhNlZWVotVq0Wi0mkwmNRiMiReR9Jb1ez8svv4xOp+Pzzz9vtsNHc22LZDIzM+nRowcLFy7k5ZdfbtZrkCkrKyMzM5OJEyeiUCgoKyvj1KlTZgpZS1uvVbAUKAuN85e//AVXV1chktBqtSxdutTsmJKSEuHVVlRUxMCBA8XU/mOPPcbYsWOFSKJXr148//zzN+nd3FjkqPedO3eSmJhIRkYGoaGhYv/Kw8Oj3kmssf2m1kSr1XLkyBEOHz5MeXm5MHuFWteFUaNGcfz4cdq3by8GWRvDaDQKh4qSkhIWLVqEv78/KSkpjBo1ivnz5zd7NdES2yKZcePGoVAo6N+/f4sLlFx8Lly4wNatW9mzZ49QA1poVSwFykLjNEUp+NtvvzF16lRhrzNr1iyxkdxapreHDx9m+vTplJeXo1QqWbBgARMmTAC4bUxvDQYDSUlJYv+qoqJC7F/179+f119/nejoaKKiom5oDpAkSeTk5IisosDAQE6cOEH37t3rfQ5N5ZdffmHx4sXY29tTUFCAt7c348aNq7en1xSulDwte/8BDBs2jIULFzJw4ECMRiOenp4UFhaiUCj47rvv2Lt3Lw4ODjg6Ora4QEHDKyTLqqnVsRQoCzefpkjZT58+jUKhEJlE4eHhnDhxgrZt2962prcXL15kz549xMXF8e9//5vAwEDRDgwPD78pSaq5ublkZ2cTHBzcrHacJEls3bqVt99+m3Xr1onZuoyMDDIzMxk6dOg1P2ZLbIvUajUPPPAA8fHxvPvuu61WoC7HUpyuCxarIwvmrFmzBoCHHnrohm1mN8X01t/fX3zdoUMH2rVrJ6JMblfatGmDt7c3SUlJfPXVV4SFhZGQkMBXX33FzJkz6dy5syhYl+8BtTZ1FYPh4eHNmk0ymUwsW7aMPXv2kJCQYLZ/1qVLl1Yfxm0KCxcuZPbs2dfdM9FSnG4clgJ1F/P8888zduxYPvroI3r27Mnnn39+3a/k8/Pzhe2Sp6enWfxDQyQlJaHX680saBYsWMCiRYtuO9NbGxsbNm7cKMxdn3zySZ588klRMOLj43njjTc4e/YsISEhREREEBUV1eD+VXMxGAwcPXqUtm3bNtvGqbKykhkzZuDq6soPP/zQ4lysurTEtmj//v1s2rSJuXPnUlpaipWVFWq1mhdeeKHVXp+FG4ulxXeXUlRUxAMPPEBycjLFxcVMmjSJRYsWERYWBtReIcvuBNdKa0jZAaEkXLt2LQMGDBC31TW97dat2x1helsXo9HIgQMHiI+PJzExkfLycgYOHEhkZCSDBw+mTZs2zXpcOTaka9eujXo5NkZubi4TJ05k4sSJTJ8+vdVXE0ajEX9/fxITE/Hy8qJv376sX7+eoKAgccyqVas4evSoEEn85z//YcOGDWaPs3DhwuvW4rNwXbC0+Cz8j59++omHHnoIqA2d69y5M2lpaYSFhSFJUoMtpqbOerSG6W15eTkjRozgrbfeEsUJ7g7TW2trawYMGMCAAQN4/fXXqaioYM+ePcTHx7NkyRJsbW0ZOnQokZGR9OnTp0krmMLCQtLS0loUG/LHH3/w5z//mffff5/77ruvWY9xNaytrVm5ciXDhg0TtkVBQUFmtkVPP/00EydOxNfXV9gWWbgzsayg7lLGjh2LnZ0dixcv5sMPP6SyspKoqCjOnj1LbGwsnp6evPnmm4SHh1/xMbKysrCzs7um+Z2mSNn1ej0PP/wwjzzyCLNmzTL7mVzcJEli9uzZqNXqaw64u52RJImCggISExNJSEjgwIEDeHt7i3Zg9+7dzS4iJEni3LlzIqa+OS1cSZKIjY3l448/JjY2VrQoLVhoRRpcQVlGn+9CJEnixx9/xN/fn2eeeQatVssrr7zCv/71LwwGA9u2bSM6Opr169djMpkoKiri3XffZc2aNWamoykpKWzevBmoVd5dvHjxqs89f/584uPj8fPzIyEhQQxhHjhwgGeeeQaojQvZvXu3kJCHhIRw+PBhAP70pz+JOI2ioiJee+018djbt28nICDgiqms1dXVTJgwAV9fX/r378+5c+fEz95++218fX0JCAi4pYeLFQoFHh4ePPHEE6xZs4aUlBSWL1+Og4MDixcvZsCAATzzzDOsW7eOM2fOMGHCBLKzswkJCWlWcaqpqeFvf/sb3333HYmJiZbiZOHGIklSY/9ZuAPJyMiQIiIizG7LzMyUQkJCpIqKCkmSJEmr1UodOnSQTCaT9Kc//UlasmSJNH36dKl79+5SamqqJEmSdOLECUmSJOnYsWPSu+++K2VnZ0uSJEnp6enSli1bpKKiohv2noxGo9S1a1cpLS1Nqq6ulnr16iUdP37c7JhVq1ZJU6dOlSRJkr755htp/PjxkiRJ0vHjx6VevXpJOp1OSk9Pl7p27SoZjcYb9tpbE4PBIO3fv196+eWXJY1GIw0aNEiaNm2a9O2330q5ublSRUWFdOnSpSb9l5eXJ40YMUKaN2/ebfv7sHDb0GANsqyg7kLi4uKEgWdVVRVQu4Lx9/cX+xmHDx/Gx8dHiCV0Oh0fffQRqampBAQEcPLkSe699170ej3PPPMM//znP0lJSQFq94k0Gg1GoxGovQqX48avF0lJSfj6+gpX75iYGJFCW/d9T5o0Cah1G0hMTESSJOLi4oiJicHW1pYuXbrg6+tLUlLSdX291wt56Dc+Pp5t27axY8cORo8eTVJSEqNGjeLBBx8U2ViN5XVlZGQwYsQIJkyYwNtvv33dYjIsWGgMS4G6C5k0aRKvv/46UBshDhAWFoa9vb1opX322Wfce++9KJVK5s+fT2FhIUuXLqW8vBwrKysOHjzIkCFDUKlUBAcH4+7uzpo1a4iLi+PXX3/Fzs5OxDQolcp6Jzip8b3PayYnJ4eOHTuK7729vcnJybniMdbW1jg7O1NcXNyk+95OeHh4sHXrVgYOHIiDgwMPPvgg7777Lvv37+e7776jd+/ebNy4kaFDhzJmzBhWrFjB8ePHMZlMAOzevZvHH3+cVatWCQ+65tCSluuRI0cYOHAgQUFBBAcHo9PpmvUaLNzeWFR8dyF1B17lk0/nzp0JDAxk6tSpWFtbM2TIEObMmUNxcTHBwcF8+OGH9OvXD0mSmDdvHj/99BNDhw6lsrISFxcX5syZwyOPPEJ2djYrVqygTZs2hIeH88cff/DPf/6Tfv368cgjj4iYbfl5JUnCZDJZrtBbkc6dOzd4u0KhwN3dnZiYGGJiYpAkibS0NKEOPHnyJI6OjhgMBn744Ycm+fJdiZqaGmbMmGHmqRcdHW3mqbd69Wo0Go0Q5sybN49vv/0Wo9HIk08+yddff03v3r0pLi6+KU4bFm4+lgJlQTB37lzmzp0rvNkkSWLWrFmkpaURHR2Nv78/7u7ulJWVcfLkSV5++WVOnDhBYWGhWC3l5+dTXl7OpEmTWL9+PXFxcYSEhLBt2zaSk5NZvnw52dnZFBYW0qNHD2xtbVulOLVkwLMp970TUSgU+Pr64uvry/Tp06mpqWHz5s0MHjy42SGFMnVbroBoudYtUHFxcSLob9y4cbzwwgtIksTOnTvp1asXvXv3BhAXNRbuPiwtPgv1CAwMBMDKyor33nuPF198kfT0dHr16sWUKVM4ffo0WVlZBAYGkpGRga2tLf369QNqT+56vZ4ePXqwYsUKxo0bxyuvvML69es5e/Ysqamp7Nu3j1mzZvHss88SHh7Ol19+2eKWX9++fTlz5gwZGRno9XpiY2OJjo42OyY6Olo4UW/atImoqCgUCgXR0dHExsZSXV1NRkYGZ86cEe/nbkKpVDJu3LgWFydoWctV9mIcNmwYYWFh9cYQLNw9WFZQFhpEbsFZW1szbNgwhg0bJn7Wtm1b5s6dC9SmtyYmJrJr1y5CQkLIzs6mffv2mEwmMjIyeOyxxzAYDNjY2JCcnIy7uztnz56lbdu2/O1vfyM3N5dly5YRGRl5xdZUU2jJgGdQUBDjx48XSbarVq1qdFV3tbyi9957jy+++AJra2uxNye/N6VSSXBwMACdOnViy5YtzX7PdypGo5Fff/2VP/74A3t7e+677z7Cw8Ov23CwhVsXS4GycM34+fnh5+eHJEncc889vPjii+zatQuj0UhGRgYdO3akvLycPn36iPTdvXv3Ymdnh7u7O6mpqTzzzDN069aNbt26ER0d3Srx6cOHD2f48OFmty1atEh8rVar2bhxY4P3XbBgAQsWLLjqczRlbyU0NJQDBw5gb2/Pxx9/zNy5c0VekZ2dnRCi3Mm0pOXq7e3NkCFDxAD48OHDOXTokKVA3YVYCpSFZqNQKHB0dGTGjBnitu7du1NTU4NGoyEiIoLHH3+cfv36UVRUxLx580Rqq6enJwC//fYbzs7OuLm53Rax2U3ZW4mMjBRfDxgwgHXr1t3w13mzqdty9fLyIjY2lvXr15sdI7dcBw4caNZyHTZsGEuXLqWyshKVSsWuXbuYPXv2TXonFm4mlgJloVWpe5X80ksvER4ezq5duxgzZgz33HMP77//Pvb29ri7uwO1G+VRUVFA60vPrwcN7a3s37//isevXr2ahx9+WHyv0+no06cP1tbWzJ8/n0cfffS6vt6bRUtarhqNhjlz5tC3b18UCgXDhw9nxIgRN/kdWbgZWLz4LNxQUlJS0Gq19O/fH3t7e9q1a8eqVat47LHHbosguKYE6smsW7eOlStXsmvXLhEJIrc809PTiYqKIjEx0SxKxIKFuxSLm7mFm48sHZZZunQpo0ePBm6PILimStITEhJ46623zIqTfH+Arl27EhERQXJysqVAWbBwBW7thr+FO57JkyffVkO6TZGzJycnM3XqVLZs2WIWJ1JSUkJ1dTVQm8e1d+9es70rCxYsmHO1Fp8FCxYuQ6FQDAc+AJTAGkmS3lIoFIuAA5IkbVEoFAlAMJD337tkSpIUrVAo7gE+BUzUXhx+IEnS6kae5yFg+X+f5wtJkv5x2c8nA+8A8oDRSkmSvvjvzyYBstX7m5IkrW3p+7Zg4UZjKVAWLNyCKBQKJXAaeADIBv4AHpckKbXOMZOBPpIkvXDZfV2AA0AfaveRDwLhkiQ1HF1swcItiqXFZ8HCrUk/4KwkSemSJOmBWGBUE+87DIiXJEn736IUDzx0nV6nBQvXDUuBsmDh1sQLyKrzffZ/b7ucsQqF4ohCodikUChk/XtT72vBwi2NpUBZsHD78j3gI0lSL2pXSZZ9Jgt3FJYCZcHCrUkO0LHO9978TwwBgCRJxZIkVf/32y+A8Kbe14KF2wFLgbJg4dbkD8BPoVB0USgUKiAGMHOWVSgU7et8Gw2c+O/XO4AHFQqFRqFQaIAH/3ubBQu3Ff8PiZ85VnTzj8kAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the 3D surface\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "Px, Vy = np.meshgrid(pos_vals, vel_vals)\n",
    "ax.plot_surface(Vy, Px, av_grid, color = 'gray')\n",
    "ax.set_title(\"Cost-to-go function learned\", y = 1.1)\n",
    "ax.set_xlabel('Velocity')\n",
    "ax.set_ylabel('Position')\n",
    "ax.set_zlabel('Iterations')\n",
    "ax.view_init(45, azim=30)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}