Navigation-DDQN-Dueling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Navigation Double DQN-Dueling\n",
    "\n",
    "---\n",
    "\n",
    "You are welcome to use this coding environment to train your agent for the project.  Follow the instructions below to get started!\n",
    "\n",
    "### 1. Start the Environment\n",
    "\n",
    "Run the next code cell to install a few packages.  This line will take a few minutes to run!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip -q install ./python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The environment is already saved in the Workspace and can be accessed at the file path provided below.  Please run the next code cell without making any changes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:unityagents:\n",
      "'Academy' started successfully!\n",
      "Unity Academy name: Academy\n",
      "        Number of Brains: 1\n",
      "        Number of External Brains : 1\n",
      "        Lesson number : 0\n",
      "        Reset Parameters :\n",
      "\t\t\n",
      "Unity brain name: BananaBrain\n",
      "        Number of Visual Observations (per agent): 0\n",
      "        Vector Observation space type: continuous\n",
      "        Vector Observation space size (per agent): 37\n",
      "        Number of stacked Vector Observation: 1\n",
      "        Vector Action space type: discrete\n",
      "        Vector Action space size (per agent): 4\n",
      "        Vector Action descriptions: , , , \n"
     ]
    }
   ],
   "source": [
    "from unityagents import UnityEnvironment\n",
    "import numpy as np\n",
    "\n",
    "## Additional Package\n",
    "import torch\n",
    "import numpy as np\n",
    "from collections import deque\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "# please do not modify the line below\n",
    "env = UnityEnvironment(file_name=\"Banana_Linux/Banana.x86_64\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Environments contain **_brains_** which are responsible for deciding the actions of their associated agents. Here we check for the first brain available, and set it as the default brain we will be controlling from Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the default brain\n",
    "brain_name = env.brain_names[0]\n",
    "brain = env.brains[brain_name]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Examine the State and Action Spaces\n",
    "\n",
    "The simulation contains a single agent that navigates a large environment.  At each time step, it has four actions at its disposal:\n",
    "- `0` - walk forward \n",
    "- `1` - walk backward\n",
    "- `2` - turn left\n",
    "- `3` - turn right\n",
    "\n",
    "The state space has `37` dimensions and contains the agent's velocity, along with ray-based perception of objects around agent's forward direction.  A reward of `+1` is provided for collecting a yellow banana, and a reward of `-1` is provided for collecting a blue banana. \n",
    "\n",
    "Run the code cell below to print some information about the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of agents: 1\n",
      "Number of actions: 4\n",
      "States look like: [1.         0.         0.         0.         0.84408134 0.\n",
      " 0.         1.         0.         0.0748472  0.         1.\n",
      " 0.         0.         0.25755    1.         0.         0.\n",
      " 0.         0.74177343 0.         1.         0.         0.\n",
      " 0.25854847 0.         0.         1.         0.         0.09355672\n",
      " 0.         1.         0.         0.         0.31969345 0.\n",
      " 0.        ]\n",
      "States have length: 37\n"
     ]
    }
   ],
   "source": [
    "# reset the environment\n",
    "env_info = env.reset(train_mode=True)[brain_name]\n",
    "\n",
    "# number of agents in the environment\n",
    "print('Number of agents:', len(env_info.agents))\n",
    "\n",
    "# number of actions\n",
    "action_size = brain.vector_action_space_size\n",
    "print('Number of actions:', action_size)\n",
    "\n",
    "# examine the state space \n",
    "state = env_info.vector_observations[0]\n",
    "print('States look like:', state)\n",
    "state_size = len(state)\n",
    "print('States have length:', state_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Take Random Actions in the Environment\n",
    "\n",
    "In the next code cell, you will learn how to use the Python API to control the agent and receive feedback from the environment.\n",
    "\n",
    "Note that **in this coding environment, you will not be able to watch the agent while it is training**, and you should set `train_mode=True` to restart the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# env_info = env.reset(train_mode=True)[brain_name] # reset the environment\n",
    "# state = env_info.vector_observations[0]            # get the current state\n",
    "# score = 0                                          # initialize the score\n",
    "# while True:\n",
    "#     action = np.random.randint(action_size)        # select an action\n",
    "#     env_info = env.step(action)[brain_name]        # send the action to the environment\n",
    "#     next_state = env_info.vector_observations[0]   # get the next state\n",
    "#     reward = env_info.rewards[0]                   # get the reward\n",
    "#     done = env_info.local_done[0]                  # see if episode has finished\n",
    "#     score += reward                                # update the score\n",
    "#     state = next_state                             # roll over the state to next time step\n",
    "#     if done:                                       # exit loop if episode finished\n",
    "#         break\n",
    "    \n",
    "# print(\"Score: {}\".format(score))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When finished, you can close the environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. It's Your Turn!\n",
    "\n",
    "Now it's your turn to train your own agent to solve the environment!  A few **important notes**:\n",
    "- When training the environment, set `train_mode=True`, so that the line for resetting the environment looks like the following:\n",
    "```python\n",
    "env_info = env.reset(train_mode=True)[brain_name]\n",
    "```\n",
    "- To structure your work, you're welcome to work directly in this Jupyter notebook, or you might like to start over with a new file!  You can see the list of files in the workspace by clicking on **_Jupyter_** in the top left corner of the notebook.\n",
    "- In this coding environment, you will not be able to watch the agent while it is training.  However, **_after training the agent_**, you can download the saved model weights to watch the agent on your own machine! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building a Dueling Networks\n",
    "#### Dueling\n",
    "Actor(policy) Model: \n",
    "* input_size = state_size\n",
    "* output_size = action_size\n",
    "Hidden layers [fc1, fc2, fc3]\n",
    "\n",
    "Dueling:\n",
    "* Estimates the state value function\n",
    "* Estimates the advantage for each action\n",
    "* Combine the state and advantage values to get Q-values\n",
    "\n",
    "State values: V(s)\n",
    "\n",
    "Advantage values: A(s,a)\n",
    "\n",
    "Q-values = Q(s,a) = V(s) + A(s,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Necessary Packages\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "#Build model\n",
    "# Dueling\n",
    "class QNetwork(nn.Module):\n",
    "    def __init__(self, state_size, action_size, seed, fc1_units=128, fc2_units=64):\n",
    "        '''\n",
    "        Builds a feedforward nework with two hidden layers\n",
    "        Initialize parameters\n",
    "        \n",
    "        Params\n",
    "        =========\n",
    "        state_size (int): Dimension of each state (input_size)\n",
    "        action_size (int): dimension of each action (output_size)\n",
    "        seed (int): Random seed(using 0)\n",
    "        fc1_units (int): Size of the first hidden layer\n",
    "        fc2_units (int): Size of the second hidden layer\n",
    "        '''\n",
    "        super(QNetwork, self).__init__()\n",
    "        self.seed = torch.manual_seed(seed)\n",
    "        # Add the first laer, input to hidden layer\n",
    "        self.fc1 = nn.Linear(state_size, fc1_units)\n",
    "        # Add more hidden layer\n",
    "        self.fc2 = nn.Linear(fc1_units, fc2_units)\n",
    "        self.fc3 = nn.Linear(fc2_units, fc2_units)\n",
    "\n",
    "        # State-value V\n",
    "        self.V = nn.Linear(fc2_units, 1)\n",
    "        \n",
    "        # Advantage function A\n",
    "        self.A = nn.Linear(fc2_units, action_size)\n",
    "        \n",
    "        \n",
    "    def forward(self, state):\n",
    "        \"\"\"\n",
    "        Forward pass through the network. Build a network that mps state -> action values.\n",
    "        \n",
    "        return Q function\n",
    "        \"\"\"\n",
    "        x = F.relu(self.fc1(state))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = F.relu(self.fc3(x))\n",
    "        V = self.V(x)\n",
    "        A = self.A(x)\n",
    "        \n",
    "        return V + (A - A.mean(dim=1, keepdim=True))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Experience Replay\n",
    "Replay buffer: It conains a collection of experience tuples (S,A,R,S'). The tuples are gradually added to the buffer as we are interacting with the environment. The purpose of using replay buffer is to prevent high correlation from the sequence of experience tuples while agent interacts with the environment.\n",
    "\n",
    "<S,A,R,S'> --learn-->  Agent     <=>    Environment\n",
    "\n",
    "Highly correlated.\n",
    "\n",
    "\n",
    "\n",
    "<S,A,R,S'> --store as memory-->  ReplayBuffer --sample-->  Agent     <=>    Environment\n",
    "\n",
    "It helps break the correlation and ultimately prevents\n",
    "\n",
    "We want to equally update value function\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Necessary Packages\n",
    "import numpy as np\n",
    "import random\n",
    "from collections import namedtuple, deque\n",
    "\n",
    "class ReplayBuffer:\n",
    "    def __init__(self, action_size, buffer_size, batch_size, seed, device):\n",
    "        \"\"\"\n",
    "        Only stores the last N experience tuples in the replay memory\n",
    "        \n",
    "        Params\n",
    "        ======\n",
    "            action_size (int): Dimension of each action (output_size)\n",
    "            buffer_size (int): Maximum size of buffer\n",
    "            batch_size (int): Size of each training batch\n",
    "            seed (int): Random seed\n",
    "        \"\"\"\n",
    "        \n",
    "        self.action_size = action_size\n",
    "        self.memory = deque(maxlen=buffer_size)                                # initialize replay memory D with capacity N\n",
    "        self.batch_size = batch_size\n",
    "        self.experience = namedtuple(\"Experience\", field_names=[\"state\",\n",
    "                                                                \"action\",\n",
    "                                                                \"reward\",\n",
    "                                                                \"next_state\",\n",
    "                                                                \"done\"])       # initialize acollection of experience tuple\n",
    "        self.seed = random.seed(seed)\n",
    "        self.device = device\n",
    "        \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        \"\"\"\n",
    "        Store the agent's experiences to the memory at eatch time-step.\n",
    "        e_t = (s_t, a_t, r_t, s_(t+1))\n",
    "        \"\"\"\n",
    "        \n",
    "        e = self.experience(state, action, reward, next_state, done)\n",
    "        self.memory.append(e)\n",
    "        \n",
    "    def sample(self):\n",
    "        \"\"\"\n",
    "        Samples uniformly at random from D(D_t = {e_1, ..., e_t}) when performing update\n",
    "        This is where we prevent correlation\n",
    "        \"\"\"\n",
    "        \n",
    "        # D\n",
    "        experiences = random.sample(self.memory, k=self.batch_size)\n",
    "        # Store in\n",
    "        states = torch.from_numpy(np.vstack([e.state for e in experiences if e is not None])).float().to(self.device)\n",
    "        actions = torch.from_numpy(np.vstack([e.action for e in experiences if e is not None])).long().to(self.device)\n",
    "        rewards = torch.from_numpy(np.vstack([e.reward for e in experiences if e is not None])).float().to(self.device)\n",
    "        next_states = torch.from_numpy(np.vstack([e.next_state for e in experiences if e is not None])).float().to(self.device)\n",
    "        dones = torch.from_numpy(np.vstack([e.done for e in experiences if e is not None]).astype(np.uint8)).float().to(self.device)\n",
    "        # return D\n",
    "        return (states, actions, rewards, next_states, dones)\n",
    "    \n",
    "    def __len__(self):\n",
    "        '''\n",
    "        Return the current size of internal memory\n",
    "        '''\n",
    "        return len(self.memory)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implement Agent\n",
    "* Agent(state_size=37, action_size=4, seed=0)\n",
    "\n",
    "The standard Q-learning update for the parameter after taking action A_t in state S_t and observing the immediate reward R_(t+1) and resulting state S_(t+1) is:\n",
    "* γ: gamma\n",
    "* θ_t: weights\n",
    "* R_(t+1): immediate reward\n",
    "* S_(t+1): next state(resulting state)\n",
    "* Q: Q-alue\n",
    "\n",
    "TD target = R_(t+1) + γmaxQ(S_(t+1), a; θ-_t)\n",
    "\n",
    "\n",
    "θ_(t+1) = θ_t + α(TD target - Q(S_t, A_t; θ_t))∇_(Q_t)Q(S_t, A_t; Q_t)\n",
    "\n",
    "### DQN\n",
    "\n",
    "* θ-_t: θ-_t is the same as the online network except that its parameters are copied every t steps from the online network that its parameters are copied every t steps from the online network, so that then θ-_t = θ_t, and kept fixed on all other steps.\n",
    "\n",
    "TD target = R_(t+1) + γmaxQ(S_(t+1), a; θ-_t)\n",
    "\n",
    "### DDQN\n",
    "Expand the max operation from TD target in DQN\n",
    "\n",
    "* θ_t: Second set of weights (select best action\n",
    "* argmaxQ: action with max Q-value\n",
    "* θ'_t: evaluate that action\n",
    "\n",
    "TD target = R_(t+1) + γQ(S_(t+1), argmaxQ(S_(t+1), a; θ_t); θ'_t)\n",
    "\n",
    "This θ'_t can be updated symmetrically by switching the toles of θ_t and θ'_t\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Necessary Packages\n",
    "import numpy as np\n",
    "import random\n",
    "from collections import namedtuple, deque\n",
    "\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "# Hyperparameters\n",
    "LR = 5e-4                # learning rate\n",
    "BUFFER_SIZE = int(1e5)   # replay buffer size N\n",
    "BATCH_SIZE = 64          # minibatch size\n",
    "UPDATE_EVERY = 4         # how often to update the network\n",
    "GAMMA = 0.99             # Discount factor\n",
    "TAU = 1e-3               # for soft update of target parameters\n",
    "\n",
    "\n",
    "# Setup Gpu\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Builed Agent(): Evaluate ddqn agent on unmodified game\n",
    "class Agent():\n",
    "    def __init__(self, state_size, action_size, seed):\n",
    "        \"\"\"\n",
    "        Setup Agent object\n",
    "        Implement DDQN parameter updates\n",
    "        \n",
    "        Params\n",
    "        ======\n",
    "            state_size (int): Dimension of each state (input_size)\n",
    "            action_size (int): Dimension of each action (output_size)\n",
    "            seed (int): Random seed\n",
    "        \n",
    "        \"\"\"\n",
    "        \n",
    "        self.state_size = state_size\n",
    "        self.action_size = action_size\n",
    "        self.seed = random.seed(seed)\n",
    "        \n",
    "        # Q-Network: Neural network function approximate with weights theta θ as a Q-Network.\n",
    "        # A Q-Network can be trained by adjusting the parameters θ_i at iteration i to reduce the mse in the Bellman equation\n",
    "        # The outputs correspond to the predicted Q-values of the individual action for input state\n",
    "        self.qnetwork_local = QNetwork(state_size, action_size, seed).to(device)\n",
    "        self.qnetwork_target = QNetwork(state_size, action_size, seed).to(device)\n",
    "        # specify optimizer(Adam)\n",
    "        # optim.Adam(Qnet.parameters(), small learning rate)\n",
    "        self.optimizer = optim.Adam(self.qnetwork_local.parameters(), lr=LR) ###\n",
    "        \n",
    "        # First, use a technique known as experience replay in which we stre the agent's experience at each time-step,\n",
    "        # e_t= (s_t, a_t, r_t, s_(t_1)), in a data set D_t ={e_1,...,e_t},pooled over many episodes(where the end of an episode occurs when\n",
    "        # a terminal state is reached) into a replay memory.\n",
    "        #Initialize replay memory\n",
    "        self.memory = ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE, seed, device) ###\n",
    "        self.t_step = 0                                                 # Initialize time step (update every UPDATE_EVERY steps)\n",
    "        \n",
    "    def step(self, state, action, reward, next_state, done):\n",
    "        self.memory.add(state, action, reward, next_state, done)        # save experience in replay memory\n",
    "        \n",
    "        # Learn every UPDATE_EVERY time steps\n",
    "        self.t_step =(self.t_step + 1) % UPDATE_EVERY\n",
    "        if self.t_step == 0:\n",
    "            # if enough samples are availabe in memory, get random subset and learn\n",
    "            if len(self.memory) > BATCH_SIZE: ###\n",
    "                experiences = self.memory.sample()\n",
    "                self.learn(experiences, GAMMA) ###\n",
    "                \n",
    "    def act(self, state, eps=0):\n",
    "        '''\n",
    "        Choose action A from state S using policy pi <- epsilon-Greedt(q^hat (S,A,w))\n",
    "        Return actions for given state as per current policy.\n",
    "        \n",
    "        Params\n",
    "        ======\n",
    "            state (array_like): Current state\n",
    "            eps (float): Epsilon, for epsilon-greedy action selection        \n",
    "        '''\n",
    "        state = torch.from_numpy(state).float().unsqueeze(0).to(device)\n",
    "        self.qnetwork_local.eval()\n",
    "        with torch.no_grad():\n",
    "            action_values = self.qnetwork_local(state)\n",
    "        self.qnetwork_local.train()\n",
    "        \n",
    "        # It is off-policy: it learns about the greedy policy a = argmax Q(s,a';θ),\n",
    "        # while following a behaviour distribution is often selected by an eps-greedy policy\n",
    "        # that follows the greey policy with probability 1-eps and selects a random action\n",
    "        # with probability eps.\n",
    "        # Epsilon-greedy action selection\n",
    "        # with probability epsilon select a random action a_t\n",
    "        # otherwise select a_t = argmax_a Q (phi(s_t),a; θ)\n",
    "        if random.random() > eps:\n",
    "            return np.argmax(action_values.cpu().data.numpy())\n",
    "        else:\n",
    "            return random.choice(np.arange(self.action_size))\n",
    "        \n",
    "    #DDQN\n",
    "    def learn(self, experiences, gamma): # only use the local and target Q-networks to compute the loss before taking a step towards minimizing the loss\n",
    "        '''\n",
    "        Update value parameters using given batch of experience tuples\n",
    "        Use DDQN methods\n",
    "        \n",
    "        Params\n",
    "        ======\n",
    "            experiences (Tuple[torch.Variable]): tuple of (s, a, r, s', done) tuples\n",
    "            gamma (float): discount factor\n",
    "        \n",
    "        '''\n",
    "        states, actions, rewards, next_states, dones = experiences\n",
    "        #### Double DQN\n",
    "        self.qnetwork_local.eval()\n",
    "        with torch.no_grad():\n",
    "            Q_pred = self.qnetwork_local(next_states)                      \n",
    "            max_actions = torch.argmax(Q_pred, dim=1).long().unsqueeze(1)  # # Fetch max action arguemnt to pass\n",
    "            Q_next = self.qnetwork_target(next_states)                     # Q_targets over next statesfrom actions will be taken based on Q_pred's max_action\n",
    "        self.qnetwork_local.train()\n",
    "        Q_targets = rewards + (gamma * Q_next.gather(1, max_actions) * (1.0 - dones))\n",
    "        Q_expected = self.qnetwork_local(states).gather(1, actions)        # Get expected Q values from local model\n",
    "\n",
    "\n",
    "        loss = F.mse_loss(Q_expected, Q_targets)                           # calculate the loss        \n",
    "        self.optimizer.zero_grad()                                         # zero the parameter (weight) gradients\n",
    "        loss.backward()                                                    # backward pass to calculate the parameter gradients\n",
    "        self.optimizer.step()                                              # update the parameters\n",
    "        self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)   ###,#Update target network\n",
    "        \n",
    "    def soft_update(self, local_model, target_model, tau):\n",
    "        \"\"\"Soft update model parameters.\n",
    "        θ_target = τ*θ_local + (1 - τ)*θ_target\n",
    "\n",
    "        Params\n",
    "        ======\n",
    "            local_model (PyTorch model): weights will be copied from\n",
    "            target_model (PyTorch model): weights will be copied to\n",
    "            tau (float): interpolation parameter \n",
    "        \"\"\"\n",
    "        for target_param, local_param in zip(target_model.parameters(), local_model.parameters()):\n",
    "            target_param.data.copy_(tau * local_param.data + (1.0 - tau) * target_param.data)\n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train the DDQN Agent\n",
    "### Train Double Deep Q-Learning with\n",
    "\n",
    "* maximum number of training episodes: 2000\n",
    "* maximum number of timesteps per episode: 1000\n",
    "* starting value of epsilon for epsilon-greedy action selection: 1.0\n",
    "* minimum value of epsilon: 0.01\n",
    "* multiplacative factor (per episode for decreasing epsilon: 0.995"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 100\t Average Score:0.700\n",
      "Episode 200\t Average Score:3.477\n",
      "Episode 300\t Average Score:7.022\n",
      "Episode 400\t Average Score:12.066\n",
      "Episode 500\t Average Score:13.222\n",
      "Episode 533\t Average Score: 14.04\n",
      "Environment solved in 433 episodes!\tAverage Score: 14.04\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEWCAYAAABhffzLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAB1vElEQVR4nO2dZ5gUVdqG79NpEkPOjggqGckgCioCKuac87rL7ipr+DaIrnHNeRczZtc1Z8UIioqYyBlEco7DMLm763w/qqu6urqqu3qYYdK5r2uu6a54qqfnqbee8573CCklCoVCoWg8+Gq7AQqFQqHYtyjhVygUikaGEn6FQqFoZCjhVygUikaGEn6FQqFoZCjhVygUikaGEn6Fog4ihLhNCPFK7HUnIUSxEMJf2+1SNAyU8CvqJEKI1UKIMiHEHiFEoRBihhDiT0IIX2z9i0KIytj6PUKIhUKIe4QQzWzHKRBC/E8IsUMIUSKE+FkIcYJtGymEWGAcO7bsTiHEiynaN00IUR47d5EQYpYQYoIQIquaPwqklGullE2klNHqPraicaKEX1GXOVlKmQ8cANwLXA88Z1l/f2x9G+ByYBjwvRAiD0AI0RKYDlQCvYHWwCPA60KI02zn6gicl2H7xsfO3wH4a2z/T4QQIsPjKBT7FCX8ijqPlHK3lPJD4FzgUiFEH9v6cinlL8ApQCv0mwDAdUAxcIWUcrOUskxK+RpwF/CwTaDvB24XQgSq0L4SKeW02PkPA04E86nkTmM7IcRIIcR6y/uOQoh3hBDbhBCrhBBXOx1fCNE59lQSiL2fJoS4QwjxfeyJ4wshRGvL9pcIIdbEnnJujj09jcn0uhQNFyX8inqDlPJnYD1whMv6PcCXlvXHAO9IKTXbpm8CXYCDLcveBYqAy/aifWuBmW7tsxKzlT4C5gH7AaOBa4UQx3k83QXoN7i2QAj4W+y4vYAngAvRn0SaxY6vUJgo4VfUNzYCLT2ubw1sctjGWNbGskwCNwM3CyFCNdg+gyFAGynlv6SUlVLKlcAzeLebXpBSLpdSlqHfyPrHlp8FfCSlnC6lrARuQb82hcJECb+ivrEfsNPj+u3oUa+dDpb1JlLKT9CfKP5oXS6EeCqWVVMshLhxL9tncADQMdZxXSiEKARuBNp52Bdgs+V1KdAk9rojsM5YIaUsBXZ4PKaikaCEX1FvEEIMQRfW6S7rmwBjgO9ii6YAZ1izdWKcgy7wKxwO8090Ac41Fkgp/xTLqmkipbw7Rfv2BwZZzl9iPQ7Q3vJ6HbBKStnc8pMvpUzIOKoCm4ACS5ty0Ps9FAoTJfyKOo8QoqkQ4iTgdeAVKeUC2/osIcQg4H1gF/BCbNUj6B73c0KI9kKIbCHE+eiWzq0O3j+xTtqFwKUZtC9XCHEU8AHwM/BJbNVc4AQhREshRHvgWstuPwN7hBDXCyFyhBB+IUSf2M1tb3gbOFkIcXjMsroNUFlGigSU8CvqMh8JIfagR8f/BB4mnrED8I/Y+h3Ay8As4HApZQmAlHIHMALIBhajZ/i8DFwlpXw+xXlvwptP/1js/FuAfwPvAGMtN5T/onferga+AN4wdozl5J+E7s2vQrednkW/UVUZKeUi4C/oN8lN6Ne8FajYm+MqGhZCTcSiaCwIIZoC3wPvSSlvqe327Ati9lch0FVKuaqWm6OoI6iIX9FokFIWAScA0Zj10iARQpwcs5/ygAeBBehPHQoFoCJ+haLBIYR4Fj2tU6CPK7hSSrmsdlulqEso4VcoFIpGhrJ6FAqFopGRcV2S2qB169ayc+fOtd0MhUKhqFfMmjVru5SyjX15vRD+zp07M3PmzNpuhkKhUNQrhBBrnJYrq0ehUCgaGUr4FQqFopGhhF+hUCgaGfXC43ciHA6zfv16ysvLa7spijpGdnY2BQUFBIPB2m6KQlEnqbfCv379evLz8+ncuTNqpjuFgZSSHTt2sH79erp06VLbzVEo6iT11uopLy+nVatWSvQVCQghaNWqlXoSVChSUG+FH1Cir3BEfS8UitTUa+FXKBSKhsrGwjIe/mIZq7aXVPuxlfDvBX6/n/79+9O7d2/69evHQw89hKbppdinTZtGs2bNGDBgAN27d+fII4/k448/Tth/0qRJ9OjRgx49ejB48GCmTZtmrhs5ciSDBw8238+cOZORI0c6tuOyyy6jS5cu9OvXj27dunHJJZewfv36Kl/Xiy++yPjx4wF46qmnePnll6t8LCsjR46ke/fu9O3blx49ejB+/HgKCwvT7nf33a6TXikUDZZNu8uY+NUK1u4srfZjK+HfC3Jycpg7dy6LFi3iyy+/5NNPP+X222831x9xxBHMmTOHZcuWMXHiRMaPH8/UqVMB+Pjjj3n66aeZPn06S5cuZdKkSVx00UVs2LDB3H/r1q18+umnntrywAMPMG/ePJYtW8aAAQMYNWoUlZWVe32Nf/rTn7jkkkv2+jgG//vf/5g/fz7z588nKyuLU089Ne0+SvgVjZFobDoffw1Yl0r4q4m2bdsyadIkHnvsMZwqnvbv359bbrmFxx57DID77ruPBx54gNatWwMwcOBALr/8ch5//HFzn7///e/cddddGbVDCMF1111H+/btzZtGkyZNzPVvv/02l112GQDbtm3jzDPPZMiQIQwZMoTvv/8+6Xi33XYbDz74IKBH7Ndffz1Dhw6lW7dufPedPrVsaWkp55xzDr169eL000/n0EMPTVtiIxQKcf/997N27VrmzZsHwGmnncagQYPo3bs3kyZNAmDChAmUlZXRv39/LrzwQtftFIqGRlTTdcRXAypdb9M5rdz+0SIWbyyq1mP26tiUW0/undE+Bx54INFolK1btzquHzhwIA888AAAixYtYtCgQQnrBw8ezAsvvGC+P+yww3jvvff4+uuvyc/Pz6gtAwcOZOnSpSkj6muuuYbrrruOESNGsHbtWo477jiWLFmS8riRSISff/6ZTz75hNtvv50pU6bwxBNP0KJFCxYvXszChQvp37+/pzb6/X769evH0qVL6devH88//zwtW7akrKyMIUOGcOaZZ3Lvvffy2GOPMXfuXHM/p+1atVLziSsaFlosgKyJiL9BCH99oSpzH9x0003ceeed3HfffdV+rilTprB48WLzfVFREcXFxSn3OeOMMwAYNGgQq1evBmD69Olcc801APTp04e+fftWqZ0TJ07kvffeA2DdunX8+uuvjoLudTuFoj5jRPx+nxJ+RzKNzGuKlStX4vf7adu2rWPkPGfOHHr27AlAr169mDVrFqNGjTLXz5o1K6FDF2DUqFHcdNNN/Pjjj+ayyy+/nDlz5tCxY0c++eQTx7bMmTOH0aNHA4npjdb8dk3T+PHHH8nOzvZ8jVlZWYAerUciEc/7ORGNRlmwYAE9e/Zk2rRpTJkyhR9++IHc3FxGjhzpmIvvdTuFor4TlYbVozz+Osu2bdv405/+xPjx4x3zyOfPn88dd9zBVVddBcA//vEPrr/+enbs2AHA3Llzee+99/jjH/+YtO9NN93E/fffb75/4YUXmDt3rqPoSymZOHEimzZtYuzYsQC0a9eOJUuWoGmaGSkDHHvssTz66KPme6udkgnDhw/nzTffBGDx4sUsWLAg7T7hcJgbbriB/fffn759+7J7925atGhBbm4uS5cuTbjRBYNBwuEwQMrtFIqGRDSqC39ARfx1C6PTMRwOEwgEuPjii/m///s/c/13333HgAEDKC0tpW3btkycONGMwk855RQ2btzI8OHDiUQibN68mXnz5tGmTdKcCZxwwgmOy638/e9/54477qC0tJRhw4bx9ddfEwqFALj33ns56aSTaNOmDYMHDzbtnIkTJ3LVVVfRt29fIpEIRx55JE899VTGn8OVV17JpZdeSq9evejRowe9e/emWbNmjtteeOGFZGVlUVFRwZgxY/jggw8AGDt2LE899RQ9e/ake/fuDBs2zNxn3Lhx9O3bl4EDB/L888+7bqdQNCTMiL8GPP56Mefu4MGDpT1LZMmSJaZtUt+JRCJcfvnlaJrGK6+8Uu9GnkajUcLhMNnZ2fz222+MGTOGZcuWmTee2qAhfT8UjZNPF2ziz/+bzafXHEHPDk2rdAwhxCwp5WD7chXx1wECgQD//e9/a7sZVaa0tJSjjz6acDiMlJInnniiVkVfoWgIGBG/6txV1Eny8/PV1JgKRTVj5vGrAVwKhULRONBqMOJXwq9QKBR1EFWyQaFQKBoZWg2WbFDCr1AoFHWQmuzcVcK/FxhlmY2f1atXc/jhhwOwevVq+vTpA+A62Kq6GDlypGPnqiqDrFDUPgs37Oapb35Lu937czYwdckW871ZskFZPXULoyyz8dO5c2dmzJiRtF1VhH9vyyEYqDLICkXtctKj07n306Vpt7v2jblc8VI8gNNUyYb6g7UEMkBlZSW33HILb7zxBv379+eNN96gpKSE3/3udwwdOpQBAwaYo1dffPFFTjnlFEaNGsXo0aNdtysrK+O8886jZ8+enH766ZSVlaVtlyqDrFDULpkOlq3JiL9h5PF/OgE2p68PkxHtD4Hj7025iSGQAF26dEmog2MQCoX417/+xcyZM81a/DfeeCOjRo3i+eefp7CwkKFDhzJmzBgAZs+ezfz582nZsqXrdk8//TS5ubksWbKE+fPnM3DgQE+XpMogKxS1hybBn4GGx+vxK+GvUxhWT6Z88cUXfPjhh+YEJ+Xl5axduxaAY445hpYtW6bc7ttvv+Xqq68GoG/fvqoMskJRD4hqMqOO2prM428Ywp8mMq9rSCl555136N69e8Lyn376iby8vLTbVRVVBlmhqD20DK2eiFZz1TlrzOMXQuwvhPhaCLFYCLFICHFNbHlLIcSXQohfY79b1FQb6gr5+fns2bPHfH/cccfx6KOPmtH3nDlzHPdz2+7II4/k1VdfBWDhwoXMnz8/bRtUGWSFonYxrBuvaPW0ZEME+KuUshcwDLhKCNELmABMlVJ2BabG3jdojj76aBYvXmx27t58882Ew2H69u1L7969ufnmmx33c9vuz3/+M8XFxfTs2ZNbbrklaQpHKxdeeCF9+/alT58+lJSUJJRBjkQi9OzZkwkTJjiWQb7wwgtTbqdQKLwTzbhzV/9dE1YPUsp98gN8ABwDLAM6xJZ1AJal23fQoEHSzuLFi5OWKRQG6vtR/azfVSrHvfyLLK2IJCzXNE3+9c25cvaanbXUsurjrZnr5JPTVjiu21lcIX//0i9yV0lFRsc84PqP5QHXf5x2P2M7g4e+WCYPuP5jqWlaRuezAsyUDpq6T9I5hRCdgQHAT0A7KeWm2KrNQDuXfcYJIWYKIWZu27ZtXzRToVCk4O5PlvD5oi18aRlkBFBYGubtWeu5/MVfaqll1cff3prnmnP/3PRVfLl4Cy//sKZKx66K1eMT1Mj8HDUu/EKIJsA7wLVSyiLrutgdyfHTkFJOklIOllIOTjf7lEKhqHkM+ZH1YPKmmsDsbM0kJ9NCxlaPzCwLKBNqVPiFEEF00f+flPLd2OItQogOsfUdgK012QaFQlE91LeZ4aqbqKab7lXNsontnsH2skY6dqFms3oE8BywREr5sGXVh8ClsdeXonv/CoVCUacJR428+qrJZuaduzUX8ddkHv9w4GJggRBibmzZjcC9wJtCiCuANcA5NdgGhUJRTcStnlptRq0R3cu8ei1Djz8qZY2Ua4AaFH4p5XTi3xU7o2vqvAqFomZw06DGch/Ya4+/Kp279dHjbwy8//77CCFYujR99b1M0TSNq6++mj59+nDIIYcwZMgQVq1aVe3nqQ4ee+wxDj74YIQQbN++3Vz+wQcf0LdvX/r378/gwYOZPn16LbZSsTeYEb9N6o0RqQ39SSAS3TuPv9F07jYGXnvtNUaMGMFrr71W7cd+44032LhxI/Pnz2fBggW89957NG/efK+OWV3lnu0MHz6cKVOmcMABByQsHz16NPPmzWPu3Lk8//zz/P73v6+R8yv2HXb9yrQUQX3FrJbp4PHPWrOTUQ9No7QywvtzNnDOUz8kbfP3t+bx8JfLzfcT3pnPQ18sS9pu7L+/5fsV24lqNTNqF5Tw7xXFxcVMnz6d5557jtdffx2Azz77jLPPPtvcZtq0aZx00kkAPPfcc3Tr1o2hQ4fyhz/8gfHjx6c8/qZNm+jQoQO+2BetoKCAFi1amOcZOHAg/fr1Y/Ro3TnbuXMnp512Gn379mXYsGFmKYfbbruNiy++mOHDh3PxxRezbds2zjzzTIYMGcKQIUP4/vvv9/qzGDBgAJ07d05a3qRJEzMbpKSkpNFnhtRnjL9dks5LY/2+bc++JhwT/qCD1XPX5CWs3FbC4o1FXPvGXH5evTNpm9lrC5k49Vfz/eu/rOPRr1Ykbbd08x5ufG8Bmibx15BCN4wibQAjRyYvO+ccuPJKKC2FE05IXn/ZZfrP9u1w1lmJ66ZNS3vKDz74gLFjx9KtWzdatWrFrFmzGDNmDOPGjaOkpIS8vDzeeOMNzjvvPDZu3Mgdd9zB7Nmzyc/PZ9SoUfTr1y/l8c855xxGjBjBd999x+jRo7nooosYMGAA27Zt4w9/+APffvstXbp0YedO/Ut26623MmDAAN5//32++uorLrnkErN66OLFi5k+fTo5OTlccMEFXHfddYwYMYK1a9dy3HHHsWTJkoRzL1u2jHPPPdexXdOmTcvoyeO9997jhhtuYOvWrUyePNnzfoq6hZuuZ2hd11uMdE4n+8WIzKvrswhHtPrZudsYeO2117jmmmsAOO+883jttdcYNGgQY8eO5aOPPuKss85i8uTJ3H///UydOpWjjjrKLLl89tlns3z58lSHp6CggGXLlvHVV1/x1VdfMXr0aN566y1KS0s58sgj6dKlC4B5zOnTp/POO+8AMGrUKHbs2EFRkT5m7pRTTiEnJweAKVOmsHjxYvM8RUVFFBcXJ0wi07179yqVnHbi9NNP5/TTT+fbb7/l5ptvZsqUKdVyXEXtYNe2hmj1SCmTnk4jUfeiaT7zaSj+WTgdwyuVUY1oDXbuNhzhTxWh5+amXt+6tacI38rOnTv56quvWLBgAUIIotEoQggeeOABzjvvPB577DFatmzJ4MGDyc/Pz+jYVrKysjj++OM5/vjjadeuHe+//z7HHntsxsexlnvWNI0ff/yR7Oxs1+2rM+I3OPLII1m5ciXbt2+ndevWGe+vqF2Eg7hBwxT+iCaTLB3D43e6XEPfrR24UU16zgCyf6YVEV34a6IkMyiPv8q8/fbbXHzxxaxZs4bVq1ezbt06unTpwnfffcdRRx3F7NmzeeaZZzjvvPMAGDJkCN988w27du0iEomYkXkqZs+ezcaNGwFdrOfPn88BBxzAsGHD+Pbbb80MH8PqOeKII/jf//4H6OLcunVrmjZtmnTcY489lkcffdR87xTZGxG/008mor9ixQrzSz179mwqKirUJC71FEPckiz+hqf7ZnSfsCwm/E43Op9D/0cmWTx2iygc1a0elc5Zx3jttdc4/fTTE5adeeaZvPbaa/j9fk466SQ+/fRTs2N3v/3248Ybb2To0KEMHz6czp0706xZMwA+/PBDbrnllqRzbN26lZNPPpk+ffrQt29fAoEA48ePp02bNkyaNIkzzjiDfv36mZH5bbfdxqxZs+jbty8TJkzgpZdecmz7xIkTmTlzJn379qVXr1489dRTe/15TJw4kYKCAtavX0/fvn3N7J133nmHPn360L9/f6666ireeOMN1cFb32kEWT0Rh/oKxjJH4Y8pqXVVJiUa7McMR6Xeuas8/rrF119/nbTMmA4R9Lx2Y45dgwsuuIBx48YRiUQ4/fTTOe200wDdfz/llFOSjjd27FjGjh3reH7D/rHSsmVL3n///aRtb7vttoT3rVu35o033nA8blW5+uqrE67f4Prrr+f666+v1nMpage3PP4GqPuOEX/YYZmBEfFbo3z9RuH3dD774K6oJmu0ZIOK+Pcht912G/3796dPnz506dLFFH6Fwo1znv6Ba153nqEtFf/9YTXdbvq0WitpugWfXiP+S5//mb63fc62PRWO64995Btu/2hRVZvnymNf/cqQu6Zw8qPTufG9BZ72CWsapz/xPde/radET12yhZ9X6Zaq9XqLysN0njCZ737dnrRO0+Dm9xd6Op/TZ6jJmivSpiL+fYgxabpC4RVDbP5z3oCM9rvto8VENenYSbm3JA/g8rbfN8v1eTU2FpbRJj8raf3yLcUs31LMrSf33tsmJvDgF3r23LY9FSzYsJu7Tz8k7T5RTTJnbSFz1hZy31l9efzreL691cJZua0kcUebx//fH73V7nf6DFXE70JjrQuuSI36XmB6w+FohrWAUyBiZk9y525mn3d1tqmmsFs9OaG4ZZMQ1ctki8bpdTqcto1KVOeunezsbHbs2KH+yRUJSCnZsWNHylTVxoARKYYj1W/1VDXiN6isD8Jvu6jsQFz4rdefqnxFJp3eTpU79c5dz4fIiHpr9RgZJGpaRoWd7OxsCgoKarsZtYqR/10RjQLBajmmIfx2Qcu0SFtlpB4Iv+3mlB10jvjtgWdVI36nm0R9rcdfowSDQXPkqkKhSMTvN6ye6n8idhN+r9REm6obexsThT++3H4l4apaPU7CX4Odu/XW6lEoFO4ETKunOqPrWMqiTdAMzfKqUfva469K0Gy/RusIWms6q12vo5ae38ysHqdlqnNXoWjUFFdkVk7b9Pirs3PXKEvgIvxeqc42SSkpSfPZhAKZy1zYpsTlkaj52nr5TgOvDPba6lH1+BWKxk2fWz/ny8VbzPcPfL6UzhMmuyY3GFk99o7U5Vv20HnCZL5fsd1pN0+ksnrW7Syl84TJCW0NRzU6T4hXZb3ujbkJ773w/PRVdJ4wOUnk//bWfHrf+jkzUlxPsAq1ja1ZPZ0nTOaDuRvN98Zn3v9fX3D+Mz8m7PePWN4/6J9Ls5z0/Ss9b/6Mw+/9Kml5vZxsXaFQVC8bdpWarx//+jfA3S938/h/io0LmLxgU8bn95kRf+Jyq/Av3bwHgNd+XmsuK62M2rbXf2eSkffc9FhdqpLKhOWLNu4GYMW2Ytd9Q1UR/hT1FowMnMLScMqnnYgmOaBVbtpzlYWjjstLK6NkB2tGopXwKxT1BGuKYVbMvrBaEFYCseIx9gyavYkfhenxJx7T6mgYEW5RWTi+0EUcy8PeLR/jJmEPgPOy9PyUXSVh+y4mXiN+643IKfOoR3u9yq5XByeqSSJRSc8OyYUSvVBSEUnoVK5OlPArFPUEa2Rt+NblLtGiEZ3XREeq/ZBWwTQi1N0W4Xfr5NxVWum43AnjCG7WR2GZ+7G8evxWQa9wEH5jEJfXTltN08U/VMVk/D0VkYTxA9WJEn6Fop5gFVwz4q90FnYz4q8J4bcJn/WdsaqoPOy43kphqXuUbsdNbCMW28UNryUrrJ2xTjfU3FBmIhyVkqiUjjcepwFbdvSIX1k9CkWjJiHi96exevyp0zmrMuDdOL9dtKzvjW28RPyFlog/nRAaq+2ZMsZAq8IUTw9erR5rO52EPycYSNouFUaFTUfh93AMTUJ2hjcbryjhVyjqCVbRy4p5v25WTzydM1Fg9iZJxBTfpKye5NdW/95N1HeVpr85GBir7dsZ2Te7UkT8Xq2eSELEn3zDzMsyrB5Ph0OTkoimOXYue52kpaasnno7clehaGxYhd+M+C0CVVYZJegXBPw+1zz+qkT6kahGRJOml7+nPFFkrR6/XZiLKyKuIldYVmmmZ7pNUVgZ0ZDEz50U8cc6mpdt3oOmSUrDUQS6LVMR0fD7RFLEX1IRITfkT5oQyKvV4zXiLy6PoGnJTxwlFRHPN+Ca6txVwq9Q1BOsghMM6MphTQXsectnjOnZlmcvHWKONK0Oj/+CZ37i59U7OWewXv/olR/XcmiXVpzcr2OsXZY2Wt58MHcD17w+l+cuHex43Nd+Xss/39Pr1d9xqnMp5sPumUpReZgmWc42ixGll4WjXPz8T3y/Yod+vNP6cPP7C+nZoSn52Yky1/vWz7nt5F5cNjyx5IuWJuI3RFhKb4OzLn/xFwAGdGqedP4/jzwo7f76OZXHr1A0apwj/sTIdMqSrUA8+yUpnbMKVs/Pq3fGzh9fZtTWh8QibVY9/HzRZiCe229n4YYi8/UXlgFfVnaUVBKOxosk2O9jkahkdI+2AKboA3wRO/eSTUWOVtOnCzcnLbM+mTj1nRiWkabJjLKlnKymt2et97RvjkrnVCgaN1Zhygqk9vjNzt1qLo9gHt9SSsCtWqURNWd58NjTRdCGeDtZPa2bZKXMuHGympzOZr1BlFUmf67GNWsysycpJ4/f7e9mpT072H/XT1C60/O5vKKsHoWinmAVJnsevz2qNdI53YU/c7PfKqC+hKJlOkIkRvxG27xY4umEP1XnbsBv+PhxMbX6946dyw6LrNdX4RDxG5+pRGZU/M7pxlfhMngtSITT/NO5wv8pPXzr4AfgwLeh6zGez+cFJfwKRT3BquFx4dcX2ouKuWb17MXYXatYWWuHuXXuGv0PJZXpC8yluznErZ5kjz/o96VM2XSO+B2KoqXx+K0RfyalpZ3a5vTE0F+s4IHg03T1bWCxdgD/Cl/Myccdx4CCIZ7P5ZUaE34hxPPAScBWKWWf2LLbgD8AhkF4o5Tyk5pqg0LRkEg1ctcuRG4e/95gFXAj+oXEksKag9WTrnompE9vNI5r3y4S1TN3UtlJTg89Tg8B1utwsnp8PoFP6De6TD5Xf5oBZFlUcl3gbf7gn8wWWvD7yr8yRRsICI4tGAY5zT2fyys1GfG/CDwGvGxb/oiUUs06rlBkiLVwWJYtnTPZetCVzc3qqUpap1UMraUTEj1+6/a64Jc4iKgdr1aPfbuwZlg9ieJqfedk9TgViEvXuev3CXxCoEmZkccfSFFaeaBYzgPBpznIt4lXI6O4O3IBxcQLu9W7dE4p5bdCiM41dXyFojYpD0cpKgvTtqn3uX2jmmTT7jIKWrhXbNxVUonfL2ianVzON0FrYlpi2Cmrd5QkbGtonTUylVKyobAUJyojGjtLKskO+hBC0CwniJSS9bvKzG2sAm51L9bujB/TehMortC3L/UQ8afLjTeu0y78UU0S9FXF6klkS1E5pZYnGqfOV78whD+zTnO/L7ltLSji6sB7XOr/go204qLKG5iuHZK0XU2lc9aGxz9eCHEJMBP4q5Ryl9NGQohxwDiATp067cPmKRTpueyFn/lx5U5W33ui533+PWU5j361gu/+cTT7t3QW/wF3fEnI72P5XccnrbNGroaWlYej7Cyp5PQnZiRsawikVaAmfbvSLOds5/Vf1vLAZ8vYExPp1feeyEszVnPbR4vNbazCaHTuzlm7izsnL4m30aKohsVT1YjfaVniZyDNeWlTCb9zxG99LTn07ql0tpRQdvL4fT4BQr9JZSL8RsQv0BggVnCy/wfO9H9LHuW8Eh3DfZHzKCHHcd+GMnL3SeAO9BvuHcBDwO+cNpRSTgImAQwePLgKD6YKRc3x48rMU+ymxyYL2bqnwlX4wT1VMOrQieo2A5Wx3joH7IzfdiRtZ7ClqNwUfYOZaxJjMmtdfaOTePmWxBx9zSEzxpPH7yDOTlG39TMwBm8F/YKgzePXHLazYl1izG62ekf8ycU54o91artE/F1a51FaGWFLUUXCmdqXLOGGwOuc6P+JArGdChnkS20Q/46cwQpZwP4tcwjvrnD8u+fUUK2efSr8UkpzlIYQ4hng4315foWiPpNYDC3+22mAkOmJu0wFaHc/yhyqfNqn/bN6/IbwVdo6lRMzfPTfXiJ+J6vHaYIS6zUYdXr8Pl9S6eNIuikQLedzquzpKPxWjz+SfMxWeSGyg362FFVQILZxtn8ap/pm0Hn2Fir9fr7T+vJg9BymaAMTfPxubfPJCwUcB7o1iIhfCNFBSmlM/XM6sHBfnl+hqE2q0qFqxSnij0rpeFzT6rF0CKfqQHXszLQN87Vm9RjCH7FFqU6n8OLxe434rTcI49qC/mSrJ6olf1ZWrEuchd/pRuhL6fH7hKC/togJwf9xhG8BAN9rvVnb84/8ZU4Bu2mStA/oYw7c5hnIqm8evxDiNWAk0FoIsR64FRgphOiP/rmvBv5YU+dXKOoqVa2QGbX528ZvJ2EzbwyWfVKlTDqJrM8W8Vt3N4TPLoBObbFPveiEU9OcxNd6OuNpJuATSU89kTQ3POv5nCaEcc7qMQapJadzDhLLuHnnBxxSOZetvub8O3Imb0ePZCOtuWW/XhTPW+Ja1tMnkp+uQD+Xl1HPVaEms3rOd1j8XE2dT6GoDTRNJglkjZ3LGvFr8d+OEW1skZvlYR/A5DSS1B7xWzGsDvv4ASdtK65iHr+jx68lR/x+hwFc6SN+i9VTlhzxO+bxxyJzaYn4+4sVXBd4m6P889kdac7LTf/IXVsPo4KQuV/AL2iSFUiYo8B+XCfhzw4kVxCtLtTIXYViL4hKic/jaNi9zVBwErOolDjNC24IqTUiT2X1OPnpDlmIJk4Rv5TO+fHV2bmb0Gkbu+kEfSKpHk44jcdvbaYxiUt20Gc+ZThNvej3CTPiz9mxgOeCDzDaP4cdMp+7w+ezsvN5VPpzqdi6LWm//OwUwu9zzvWvqVROUMKvUOwVa3aU0jQnQNt87/n8VcXQ2Nlrd5kCuG5nKZt2lyVst3l3ubPVY3ldUhll6eYierRvyuy1u5IiXCmlYxRqMH99IWWV0YQnCnCOrp2yauxYO643FJaxX/Mc5q3fnbTdzNW7OOGQDsxZu4uV2/SxC3o6p3ttfXsbIX6TmrOu0JyoPSfoTzkBvN8n6M4azls5kV67v6PQl8f94XN5MXocpWRzlD/XsSBbwCfIzw4CZckHRff4HSP+Ghq8Bao6p0KxV1z5v1nc++nSjPap6sO7JiWLNu7mjCdm8PMqPZ30p1U7OXfSjwnbDbtnqmm5WNM5rQI8ef4mxv77O75eupUznpjBDysTUz3DUZnS6lm9o5S/vT0vIeIXAsenDy9YrZ7h934FwONfr0ja7vnvV7Fo425Of2IGf31rHoBjrR6rx+/k10vgrVnrOeOJGbw5cx2Quv7OwWI9Q36+jje0v9Flzxzmd72KERX/4YnoqZSi3/T9PkEokPyZ+YTg7EEFrsf2CcGJfTskLa+pksygIn6FYq/YVRpmT3l6K6M6iGrSjE6L0pzTiKCtWTdOA5l+3epcK78sHHXsuxjapSVLNhaxpyLC/PWFtLM96dgjfiG8Vud0aINLp7B1NDHoHro9j996k3MSdCklv8bGIGwo1I9n9EWEAj6z87YJpVwXeIdL/Z8jt+bwrO8sNvT4HQd2KqB4QWJSok9gThhjb9/lwzvrg5c+Xpy03ifg4mEH0Covi6tenW0uz1IRv0JRNykPR9NOFG6yl/mcmpSOXrzbtpAogE4dqE75+wAV4ahjxJ8V8JnHyQsF0mb1tMgN4QX7fpURjbJwlI7Nki207cUVCe8DDh6/k71jx23wbZsmWYDkZN8Mpmb9jcv9n/FG9Gi+PX4KzwTOp8yf7/g39wnnUht+n14Gwz4TmHU/IQRNbOtr0uNXwq9Q7AXl4agnD9tKVTM1IlHpaQIPiGfXRNJ07jrZIKCnUjr5zn6fMNMzc0P+BEvFel6D5rnJQuiEvW1GimXr/KykbbfvSUy/DPh8SemcXoq+udUH6pu9hf8F7+bR0GNskS04rfJf/DNyBVpOK3MAl9Pf3G96+bblsb+3m3VmLLZ/3DU1eAuU1aNQ7BXhqPQ0/2p1EJXehb8yJugRl85dA7fjlUecrR7rQKO8rEDSCFa7mDbPSRRCv0+krcED8cJvrZs4CL894neozmm/IdmRJI9/yKaCv2Z9wOWFH1PqC3FT+HJejY5Gi8XHfh/mAK6ow/F9LlG9cQN1y5Iybgj2QVw1Va4BlPArFHtNOpExMGTGKeXRjlF8zIqmSco91oE3RqOmK13glsVSVhl1TDG0LsoLBZLqyyRH/IlWT8BF+O021KpYxk7rJslW0bY9dqvHqXM3k4hfcoxvFrcGX6ZAbOfbnDH8364z0fLaoJXEny4MYXaL+H0+QdOc5Ijf+BzdRuf6HITfJ1Q6p0JRp8k0k8XLA0I4quH3JUZ8USkp9zAKFvRJyiHxpuR0g6pwi/jDUUdLyipOuVn+pI5t+03NbvUE/T7HHHn7zWBVrMx0G5vV05w99Ng2l6GB+RwsNtBGFNLlQx+9oj6GBHNZI9vym+zI6uhB/EIBRS5lEiT6jXSgWM7fAm9yuH8xy7QCJjS7jw3NBrB913a65oXYaRF+v0/oUbt07ij3CZwj/tjTiFt6rPEkYF0d8Ptq1OoRXqKP2mZwfr6cOWhQ4sJzzoErr4TSUjjhhOSdLrtM/9m+Hc46K3n9n/8M554L69bBxRcnr//rX+Hkk2HZMvijQ2WJm26CMWNg7ly49trk9XffDYcfDjNmwI03Jq//97+hf3+YMgXuvDN5/dNPQ/fu8NFH8NBDyev/+1/Yf3944w148snk9W+/Da1bw4sv6j92PvkEcnPhiSfgzTeT10+bpv9+8EH42FZLLycHPv1Uf33HHTB1auL6Vq3gnXf01zfcAD/8QEVEIxzV9KyHggJ45RV9/bXX6p+hlW7dYNIk/fW4cbB8eeL6/v31zw/YdcY55G7dnDi0/bDD4J579Ndnngk7bFUpR4+Gm2/WXx9/PJTFs0QksHzwUXR74DZd+EaOTPpoOOccOq89gOxwOS++dRtNsgP06dgsvt7lu7dgw25KKiK0+ce1HDT+Csfv3o8rd/DM0NN55JWbabpmJT8eE98/LytAi9wQ1/c8he8796fXlpXcMnVSUvPuP/JSZhf0ZOD6Jdzywyv03785ALPW7CIc1fjX6HEsbncgw1fP5dZ57yaIG8CNx43niJOGc/BPX9P1lcTjt8wLcenRf2FT0zb8bsNPnDLjQ9MuyvJpdMoXPDh6DDl5EQbPX8Dhy1dSWK4Rxk+5zKLSl82FZ95GeTCbi2ZP5qSl3wF6v4ehReddcC85QT8XTX+L3xUuYtOO3bQQe2hJEfnBMnwX5VImQxR+EyBrVTn5uVlEIlEi4XJCOVGyzo3dbKaUU7HeR4nMpgT9Z2t+S14+5VQOz1nL6ZM/oMXmXYTxs162YatsTmmXg/nv5f/kq6Vbee77Z8hbEy9j3bNDU74Itef7q26ic+s8Drjmj3TYs91c37pJFtlHDmdE82MBePK9u2lRVkSPDk1pnhNkR0klL2YfyKPD9aIGL755K9mRCto2zebA1nkUlUd4NKc7zxx6BrkhPx+/ezMHts5L+u5lonvim29mSSkH2zdTEb9inzBn7S4Ahh3YqlqPO23ZNjrs2VVtx928u5y3Z62n99yNnDZgP0/7ZBo7eckCcpvMO92EJXaky+v48Zz3e+mHNYxduYOuDuvG9m7PC+uiFBftpklkJwWimCaijGzCsAfuCa2BoA/8lVARprkRyQq9DR+EbmauvyvZvmJyKaeU7IS2ZVFJj8gajvDPp82e5XTw6dF/KVmsk225Xt7ILxX7c2X0TYbLefRu3oxwRGP5lj3s0ppyU/lV9A2sZZz2Bl3lGvJEOS3YgwB6+DZwZGgF0YhgpwyyUrZnu2xm+vhBv898qrFbLULo5ah1jz/5gxMCWjn0SRgZR+m69K0Rf7d2+TWax18/Iv7Bg+XMmTNruxmKvaDzhMkAGU1cUhvHvf2jRbzw/WpuPqkXV4zokva8AH32a8rHfzki7bFPeWw689fv5rU/DOOwg5xvVMZxf7xhNO2bZSecp2eHphx+UCuem77Kcd9OLXMTZsMC6Ngsmxk3jAag722fJ+X/D+ncgl9W70pYdmr/jnwwd6PjOU46pD2PHbaHGa/ezdDwLwSExlbZnF+0bvwa6EbPvkN54OdytsrmlJPFLaccwoMf/kJrsZuDxUYOzVlP58pf6e/7jRaiGIByGWQ7zSiVWTQRZbRjF34h0fCxp80AntrYlXXtRvHxRmfb5sPxw+lb0JzC0kr6/+tLID5+oFVeiB0lleRSTg+xlhxRQYnMYbksMAdeWTlrUAGbd5czfcV2Lju8My/OWG2ue/tPh/GPd+bTq0NT9m+Zy5PTEie1OWdwAfef1c98H9X0Ym5GJ+0XizYz7r+zks55/tBO3HPGIazeXsLIB6cB1fd9FkKoiF+hSIcRyaWZHzsBLznjVrwEW05lfzUtdR6/UxRqHbnrFN07DT7LDTnLwhCxlH+svQ1+XU5v0ZRnoyfySXQoC2QXJD6aB4Nc1epgVsj4jFyhUIhC8imU+ayQBSzOGsnaklJA0klspb9YQR/falqJ3eRSQbGWw0ZasVg7gGEjT6Zrl848+dxPDA21BJwnvzEidOvgKeMj7tg8hx0llZSSzWzZLW3BpOygz5yQplVeYseyzxcv0ub01Gb38P0+kZCZk6oEBnhPfa0OlPArFBZM4U8xlZ/bPukwxMjL5k6zMaVL53SygRJq1jh07hY5FA6zT2pSILYxIfAqJ/l/Yle0DZzyKFd8X8DMDYkjaJ1y4+31ZgL+uO+zVrZjrWzHh9pwx+sZlN3CPF4gxZ3YEFQnYW2R520AmdnegJ/icv0zsY8h8At93jHXrJ404zPcqrgauzkN/qoplPArFBYilhrvXklV594JLz69vd476FGmU/nkVMdNV53TKeIPxG56uZTz58CHjPNPRkPwSPhMNvcYx30Dh1H+/Xc4FR2znyLbNrAqmKrkpw1jsBSkjpYNwXXKQmqZYRSdHfRTEpsk3h7xW2fgcvos0wp/FW8MNYESfoXCghHJpXsst5LpAC4vwu9k9aSP+FO3zVH4HUomB4TGef6vuS7wFu1EIe9HD+e+8PlsohVn+XNix0o+l1Gy2Ip9EFKqyN2OYatA6r9HqoezTCP+nJDfrNlj76jVSyvoTzZOn2W670yqonf7GiX8CoUF01rIQPgz9/jTb+Mo/Gk8fqe+A2vb0t2fgkQ4yfcDv194E22CK5mldeXPldfq3ngM42NxGrnq1IZkqyeTiD8+YUqqaDlVCYyWHmsFGWQFfKbw2wePxSN+5wFi6SN65+W1cTtQwq9QxNhVUsl7czYAmUX8XlMsDRHzZvXIJBHVtNQRvzUKDRChOSXkaeWs/G0Z8zZXkE0FYQJE8QGCbCroIHbSW6xmuG8hx/pn0krsYTtduDp6LR+Gh2CXJeNzcXvKsS4O+ETSICR7/0Eq/L54xJ9qr1SRdMYev+VG1TLJ6tHFW0rpUrIh9bHT3Rj2JUr4FYoY170513ydifBnWqTNbXOr0IejWsKTQb+CZmzaXZ5yopDrB2oU//hfDvMtprtYR0DEtv0vHAicnm2cXxDBR0jEbyJ7ZA5faQN4N3oEhww7gykzVgNO884aZQvcrk1fkRvyc8tJvcjNShT+TD5Xn0/QLzb47IoRXZi6dKvjdqmOebhL2qwb2UE//zyhJ5O+W5lU+M2YetHeuXtg6zxWbi9J+zTj5SnyomGdWLLJuVR2deJZ+IUQOUAnKeWyGmyPQlFrWIt/pYoi7ZF4dXn81sURTTMzD68b040te8rZUFjmWE2zFbu5Nfgyp8z8ARkKMT3cjae1k9gkW1EmswiJMFmEyaaSAFGCIkKQKMUyh600Z4l2AMtlAeGYHPTzCdfrNyJ445pf/t1QLnn+Z7P9xkex+F9jAdhhK6gmMjA2fELQuklW2pz2VIF0x+Y5rL73RA6/Zyobd5enPWdO0M9ZRx7IH448MOnvqk+9qFs9miY5oFUu3/z9aP7031ms3F6StraO2w3K2v47TzskbRurA0/CL4Q4GXgQCAFdhBD9gX9JKU+pwbYpFPsUa033VGJij/AjboXdbRjC7pbHb59P1thOCP1GFNWSa/UMFMt5OvQwTSlj64CrCQ/9Exf/Z66n9rghhHDNMDGsEEMUrZ23mtTbbN21mUN1Tq947QxNJahZgcwKnVnF235Yny2d0ziv0R+TbqpEeyG52sRrS24DhgKFAFLKuYD7sEaFoh5i/cdMFcTbI8FMqzK72yTx1xFNmhG/IF7O2Fqdc7hvAa+G7qJY5nBy5Z3sGPp3RE5Lc73dWvBaAsDvc54DFuLCaNykEjz8WB6/1cu22x+ZpCx63dbtBpEV8GU894HV3rHvq3fu6q+jWnxqSmPMhT11Namd+zBdMx1ehT8spdxtW1b3az0oFBlg/adPZd/YM268lmU2cLN6NBePX4h4HXijc7eXWM1TwX+zSrbnzMrbWS73Nz1op+txeu+GT7h3RNojfmuErEmJJlN3YmaifV63dRN3643O6w0glTgHbHn8xrZGtdF09fPtcwaYbauFvB6vwr9ICHEB4BdCdBVCPArMqMF2KRT7HKstkCrzxp6+WV0jd62njGrSzAISQuD3xdM5W7Ob50MPsIccLq/8BztpCsQE2/IfbRd6rxGncT4nkoXfavXon1sqjc0kl91re92fTjIvcpbKjjFKNmiafv3GmARjsF268wUyGLxW03htyV+A3kAF8CqwG7i2htqkUNQK1n/6VBmXdo8/485d11RIu8cfX+fzCcojUaSU3B98mhYUc0Xl39lMq4RtEiJ+u83iUXP9qTp3DeGPNS7LHvFrsso593a8pj+ma2smpMq88ccGcJkev0gU/qw09fPrldUjhPADk6WU/5RSDon93CSlTN9FrlDsQzYWlvHsdyurvL/d6nn1p7Ws2FqctJ3TPLNuYv7Zws38tHKHbXt92zd+WcuC9bt55MvllIejvP7LOss54sczOnelhIv8Uxjln8vdkQtYIg9IOG46q8er6PpEfPIQO4a1Y9zsrDeXiojG3HWFVR5lm9wOj08oLsfMtGMXvEX8y7bs4Zvl28zrNDz+9FaP87FrI70/bVaPlDIqhNCEEM0cfH6FIiOklFWebNzpWFZ+/9JMFm8qYmyf9hS0yM34eCF/YvR643sLyAr4WHbn8QnbOdXRiUqJz8Gr/dMrehlea0qioenXv7PAXBbwCR76Mj7hTESLe/w+IQj4BK3ZzfWB1/k2eggvRY9NOpdPJEa/fTo2Y/2ueD0d98jYR7+C5vy0aqd5vnTpnP85rz8Tp65Imlz8l9W7kmahuuPU3tz8wSLz2Klok59lTq1o18lT+nXkkP2acdcnSxKWu7XVKsTpvnIHtckj6PdxcFvn0s96e/SI35jW0rBuTKsnzY3GrVxFbTwHeL0lFgMLhBDPCSEmGj812TBFw6Q6p3+wH6soVlWxqucIOnTuOk0T6DSIKhO7x6nIlz0/PxyNTwYu0LNj/i/wJtlUcmvkMpzkwidEQvTbq2NTju3VznzvFomPO/IgHr9wYMJx3DJqDDEd1aMd71813PGYdnG/+LDONI3dDNIJ/4wJo8zX9gBh4vkD+MORB6Y9n4E148hpk47Nss3J3A87qBWfXXtkSnvIb3uiMvDu8dcdq8frAK53Yz8KxV5Rnalgmc5GlQ5rxO9UFtnAqWxCJsIvpaTCYSBW4vHiA7iEgLalv3KOfxovRMeySnZw3Mfu8etzwKavThnyJ0b49icHK14mAE+lb+lSNK3i6LUj2K3PNF1bfT5BQBrn9XBdvsQbSDhm+VV6zOPPpE5RTeNJ+KWULwkhQoBRrWmZlDK5kLdCkQZNSvzV9HCbaf58OqyeeKryx07Cn0nZBj0tM/H49ntY2DqAS8IRKx9mN3n8J3K663Htgu3zCXJC6QelBf2+BEH2pcjjT9eBqbcjVQep+34hf2LeveesHg+du04pkz5L9pKX/gR7xG+k9RoRf7pxEm4Rf3VZn5ng6RYkhBgJ/Ao8DjwBLBdCHFlzzVI0VKozSvdS+qCqpIz4XWrlp8PYQpOpq2xCLKsn9vqAHd+w365feCRyJkU0cc0HN8oGW99b7Q63zyXo9yWIrHCxNMBbpkwqIUslsPbr8qqHbsdMzONPXi+J5+J7KRdtHcAFEI7oH2jc6tn7Wj37Cq/PHg8Bx0opj5JSHgkcBzySagchxPNCiK1CiIWWZS2FEF8KIX6N/W5R9aYr6iM16fHvLVa7xqkD16Cssjoifg9Wj9RLJR/66yMU5nXh1ag+d651ikEr9qwen/Am1KGALyFq9ov0I3dT4bSrcTNIdVMIVnHcgZt9lJXm2jUtLsZezmW/IdqtnnTnq1fpnDGC1uJsUsrlQDrz8EVgrG3ZBGCqlLIrMDX2XtGIqE6xdov4M50Ry9zPIt5OnbrxdXvv8acT/rAmQcLF/i9pVraWuT3+RiTmzDbJdhP+RHHxCeFJqEN+X4JPrg8Eq3rEn9LqSdEc+7iDvZ24xHrtTkeSUprX6fVcwsHqMUhn9dSGpeOGV+GfKYR4VggxMvbzDDAz1Q5Sym9Jnh35VOCl2OuXgNMyaayibrN0cxH3f7Y05WTinmvXS8lDXyxj6eYiJs/fxPuxOvkAH8/fyHtz1icc693Z683Xhgiv3FbMPZ8s8TS5uXFOA+s/9Y3vLaDEMlOVs8efKAJz1u7i0am/mu/v+Hgx63eWAnDLB4vYXlyZsL39vhHVJJTt4JrAO6xvdThb28Wd1SZZzjGXHvEnvs9OYXcYee7BgL1zV7h68V4KjaUKbFNFvfZj761QZqcp2SCJC773Uc3x1/YR3G4WXF3Ea1bPn4GrgKtj779D9/ozpZ2UclPs9WagnduGQohxwDiATp06VeFUin3NmU/MoKQyyvhRB5Mbcv5qeY2Ly8JRHv1qBS9+v9qcHvC0AfsBMP7VOQDMuzWey/5/b86joIU+LaBxQ/j9yzNZua2E84d2onPrvLTntD4pWK2eV39aS8dm2Ywf1RVwTue0l+s5/YnEiibPTV+V8N56U7C22SAc1ciafj8Byvmq2/8RsNgg+W5WT6xssPlewNmD92f22l2UhzX+emw3Tpw43VyflxWgIlKZ5PE7de4e3b0N7ZvlmGmZVp6+eBCv/byWacu2AakFe0zPduwuC3NS3448P30VM9fsMtd5LTHxwuVDeGvmOj5ZsNn1PJA+AreWl0jnv18+vDOQKO7hmPC/9odhfL5oc52K6NPhVfgDwH+klA+DOZo3K/UuqZFSSiGEqw5IKScBkwAGDx6sCsLVA0pi3ncq2yPTzt1U3rlbJG+c3/jt9YxRDfJCfkoqo0kef5FlUnKnjll7xB/wiZRtL7bNdWvvHG5RsoqsZS/ySnQU0SYH09ISDdsHSBnYtSvg95GfHeSJCwc5bp8b8rOzRI+07TcMu10zoFMLrh7d1fE4x/Vuz3G923Pa498zd12ha3ol6GJstOeEQzrQecJkc509YnZ7uDi6e1sOat0krfCnt3os50oTrd96cu/YMeM3E+Op8LCDWnFYhhO+WKmN+4VXq2cqkGN5nwNMqcL5tgghOgDEfjtPqaOo16QSfumxkKWX+4PbaYzzG/9PmVg9Rq61PasnndVjv+amOam7wOw3D/u1HLvhMWQoj0ciZyFiI3fTHdsu1unsi7zYU5nTTFP2fb1ok7FPVWv1ZGL1eKl3ltAf4ZjVE8erx+8k/PURr8KfLaU0i5bEXmc+Jh4+BC6Nvb4U+KAKx1DUccIpJh+XHuNvtw5aq4inK29sCIf3iF+aAmuP+EstmTyOI3dtbXGyRKzYM4OsTwxH++bQY88PlA27jp00xScSrQi3Y9vFOq3wx6ZFDNpU1Mnq8fIZGuKZWvjd97cLfyox9pJ3n64j2vpd8urxW9Nj7R5/fcKr8JcIIcwx3UKIwUBZiu0RQrwG/AB0F0KsF0JcAdwLHCOE+BUYE3uvaGCkqk/vNfnFLS/eapG4ZvUkRfzezhmV0hQfe1ZP2s5dmwjYZ56yU2oTfmPAWBaV3Bp4mS2hTpQM+L2+UogEUXQbjWvXwnS+tVF+wX4ztmcHgTeLzrh/pNLkVC1KyupJ0f5MhT+d1eM1x95qH4UznIfBjdqox+/V478WeEsIsTH2vgNwbqodpJTnu6wa7fGcinpKqkjIq8fvdoMwCmSBu6Cb5xCZnVPK+EAeu9WTGPFHkzz8TK2e0spEj9+o1fN7/yd09m3hsbYPco4vZF6GVQTd0zkzi/iN7e19EU5F2rzcsL1YPalKNiRXE3U/lyerJ03RNK0KEb+1w7i6x5HsS1J+MkKIIUKI9lLKX4AewBtAGPgMWJVqX0XjJXWHrLdjuPUTWIXfPeLXfxv/yl692ESrJzEiL7ZF/Lm2ErxJVk8a4bdfXkVYYz+2MT7wPp9Eh7Ioe2BCrR7ryFK3bBW7WKcTM2O9vQ/EqUibl34Sn2n1uG+TqkXJnbs1a/VY/wZ+j5OkVKXGf10k3dU+DRgJx4cBN6KXbdhFLONGoYBEcU01+biTgDz73Uqe+Taxjr6bqBeWxfPf7TcHQwv+++MaHv96henxGxOX/+2teXwwdwMXPvsjhaWJefQQK60cK71r9/gNq+fBz5fx/tyNZrqqcc5IVPL3t+bx9TI9X6GJSzqrG5XhMPcFJ6EhuCt8oT7nrvngkmj1uE2hmKnVY795GTgVafNyw04V8RuLMuncTT2FY3rht5ZldhJsKeMlG7zWT/MyIK4+kO7b6ZdSGoOwzgUmSSnfAd4RQsyt0ZYp6hVWT9we8Sd2yCbve+dkvb66teSum/BbO0XdxOijeRv5aB5mbfWIJikPa7w9az1vz9IHer07ewO/G9ElqZ3+mM1ht3qMG9tjX68A4gKQFwpQXBEhomm8NWs9b81az+p7T8w4Re/I3R8wwr+IG8NXsIE2dItqlqkXE6NfuxdukDw5uLtI3X36IRzTqx0dm+VwZNc2Ceucsnq82GXGzSKVuKfs3HXILnLD7Z727CWD+f3L+thSa0fsUxcN4vVf1jKwUws+X7SZN2euR0r4y6iufDRvI4cf1NrxeC9cPoRdJfEgwXoD+Wj8CPeLyYC6OBGLXwgRkFJG0L35cRnsq2hEWKNvu8dvFXvPWT0uVo91uV2M7NrkM6NxjV22CN/p6NHYtIE+IZIifruVY0SnuSE/xRWRpEymTMYr9BBrOX/3c0yL9uPVqF6PPjHiT8y88Tppeqoo9oJD9UGRN53UK2mdz5fsxXvx+H1mxO++TbV17rqsG9OrHTlBP2XhaEJ0vn/LXP5+XA9Ar3X05sz1SGBsn/aM7dPe9TxHd2+b8N4Q/lE92nJIQbMUV1O3SSferwHfCCG2o2fxfAcghDgYfd5dhQJIzMKxZzskirW347npZjTN04MTEU0m9A3ox0/eOarhavXYyzQb4puXFYA9FVSkyct3ozl7mBR8iD0ij7+Hx2FIo7U6p93j9y78VbMlrKUfsgI+KiKapxt2wEvnbgbVOVPW9U9xHKOWkpsfb4zVqEqlWOOYmRTlS0dtjPdNKfxSyruEEFPRs3i+kPH/Fh/6BOwKBZD4T2SP1q3rvJQvdjqG0/J0/7hGvr0u/Mmevh3d89UjTbvw21M4DfE1fHJ7qWYvopJFJU+F/k07sYu/5tzDtrIW5jp96kUjLTVxAJdX4a9qGWCfEOZTW27Irwt/JhF/ivOmsjWcBpK5t9H9OMZXxFX4YztXRfiN+kZeBwV6oS5aPUgpf3RYttxpW0XjxRqJ27NoMqlc6XQ8K1Ybyf7PZ99ld1k4to9GcXn6zJ6otFg9UbvwJ743rJ68WN0c+40hnS6ECDMp+DBDxVKuDV/JPA7GOjTGavUgEmdvyvLYE+l1snIDv0+Ydpdx/bmhALtKw55u2PEBXFVrU9IArr3O6nH+nIynp6pot3HTqMp3ui7RMLqoFbWO1d2x/1Mk2jPeyyc4kcrqsQ8cM4VfkwnZQPrxHY4dEz0hkgdwVUa1hOsybAmjNn6y1eN+nc0o5sXgfRzln8+EyO/5UBueYCUF/SLhBiegahF/htUiDY/d50ueXKS68vi9nN9gb7N63CN+I2rPoHHGeRuI8KsOWkW1YBW6pM7dKnj8bhmhqawet3/GSNTB43fwrKU0ZlkSjqNzrXX4Az4fPmGxesJ2q8e5/X3ESh4NPkpHsYNrK6/kfW1E7Njx/UN+H+Fo3F4RQlTR489Q+AM+ysJRfEKYT21G2qoXj99LHn8mEX+qLgovl+ZWQtqM+KswA7S/BoS/zk69qFA8/vUKOk+YzOiHprG1qJyBd3zJ0s1F5nrrP0Iqq0dKyY7iCgbf+SULN+x2HFx1ywcLmfDufMd2WDvV7CPm3WoE7S4L88DnyxKWSQnfLN/GEfd/ZYq8HvHHPH6HdhVbKnT6fYKAz2dG/PYbhf2m1IRS/h54nfdDt5AjKjm/8iZT9I02GgQDPt3qiQmTXqsn/q/qVvLaTqYTmRg3FKvwm2UdPEX8+u9UJQiqq1bP3sxmFdyLiN8YPJdugF4muI2nqElUxK/whCGcv20r4dOFm9lZUsnz01dx/1n9gNSdu/asnukrtrO9uJJnvlvJnaf1STrXyz+scW1H1CLIXiP+DYWljstv/WAh63aWsbGwjAPbNLF4/M6iUFQeF2e/T3D3GYfQvV0+r/+yLqnapmFVdRJbONP/LZf4v6SFKOad6BHcHr6YIpq4XmNO0E9lRDOfGoRItHoOapPHbSf34vVf1rF08x7X4ziJ48u/G+r6xGBYLX5f/Caaawq/B48/xfy1xhI3Lb/ksAM4pX/HhGVVrfL5xXVHsmRTket6owRzVTp3e3dsyk0n9uT02NwQmfLelYezvbiSkooI3dvn8/WyrfxueJf0O1YzSvgVVcb6f2PV3HAKj18mvHaubZ8Ka1Bv/791Kw5n+OdG5yXoefyGuBmRplGW2U1UynasY6zvZ7qJ9QzYEeXoDflEN4W4MbCJXqtbkRUoJiJ98MWPXL5pAf8ILaazbwuaFHyt9eeRyJkslAcmHffQLi35aVV8srqckJ/i8khiVo9FTIUQXDa8C1OXbk0p/E4CfGS3Ng5b6hgZK8IyjsGIcL1IpCHUqawoNzH/16nJAUCq7KBUdGuXT7d2+a7rg0apiiocWwjB749I/ht6ZUCnFgnve3ZoWuVj7Q1K+BUZ4xQpJQ7gSmH12Paz58enI6q5R/xuxeGMAmi5IT97LHaNYecYWhTVJFm2aQiDRDjD/x3n+r/mkDdW8FQINCko35MHy5vgi1Zwob+U7M0RRgRiN7GfsugiWjBTduK/4TFMjg5jM8kTdQT9gnBUJgllXijAtj0VCXn8XqY8tJNpOmcqq8fTyN3Y+VK1NZMW1dTc5AF/1a2ehoISfkXGODkqCZ279jx+zXk7IZxLHKcikqJz121QjXFzaZIVSBB+4wZltC8q9ShTFxzJKb4f+EfwdQrEdpZo+7Ok1//xjzktWS4LGNu/M/85bwAC6HfjJ5zSryPvzlmPH43f7jmZCS/PYsqSLSmvpUVuiK17KpIEOjfkpyKcmDtfFU870+waq2DHO3cN4fd+PreSEpBZR+be+Pi1cdz6hBJ+RcYYFoRVC1Jl9SSkYFpuAlI6T2qSiqpkCBmDq/Isc9VKGbd6DItIr9UDbdjF3cGJjPTPY77WhRvDV/Ct1pe7D+jLgtkLAFvtnIAv9lQhiOIHITxFyC3zdOG3R8i5IT+VUS1hQpmqDMYKZDhy17B6wlHN4vHHsnoyivir1rlrp6ppoemoT5Oi1xRK+BUZ49SJmmD1pCzZkLhvph5/xJYh5AUjxz5B+JGm1WOdo7dv2S9cVnEfWb5ybg1fyn+jxxAIBEDTEjp3rUIc9PuSZtRKJ/w+EZ+sxV6czBBb45gC50g53eWnm0fWjmH1VEY0M73U9PgzyONPZfVkIuY1JfyZ3hAbIkr4FRljaG9C565F65OLtLmrRqZWj/Um4jWX2hCxJlmJk2gYVk9USoiGuaTkBc6teIffxAGMqxjPb1LP3MgN6Vk2e2xZPQZBv89zHr9Bs5yg2flqt0YMe8W4KVZV/6qazlkZ0ark8Xvp3M2kRTVlyVS1lEVDQgl/I+X6t+fzy+qdfPW3kRnvq5lWj3Mk7zXi/3DeRj6ctzFh21STpnSeMJk8S86z10JZxs2liSXit+b13/zSZ1xf8gDn+pbzbdMTubH0QtZbDt0iN0RhaZiissQ8foOQX5gdyAB/eW0O3y7flrJNLfNCplDahcgQ2/Mm6dVSrHnxWRZRbd8sO+U5MhXO/VvkmucoaJHD7rIw7ZpmAdCqSVba/QMpIn7jiSUzq8f7tplgZAt1TPP5NWSU8DdS3pi5rsr7Ola2TKjV455tk06r0z0BlFgsFUP42+RnsW1Phes+FWb5geSBMmN8s3ig9GkCIsr4yr+gtTudDQs3A3DYga0YfnArenZoyhUvzUywpax2QTCQGPF/FLuZ9Wifz37Nc5i6dGvSee89sy+PfqXX9renXdqfAAyxfPHyIRzUJp7//69TezP84FYcsl8zdhQnF6HLNLL954k96b9/cw47qBUvXj6U2Wt3cWyvdkQ1OLlfh7T7+zx4/Hb75uO/jHC9gdfkiNbnLh1Mr461k0pZF1DCr8gY8/80wepxt2Cso2DT+fKZdPYaVs35QzsxceqvrtsZwm+NlttQyE3BVzjVP4NF2gFcFb6a1bIDJyJMC+uy4Z05rnd7thaVA4mTwNitHnutHoCm2UFOH7ifo/AP6dzSjOPtYphlKy5mrB1pqw2fGwpw+oACAA5OXKUfN0Phzw76OXOQfrw2+Vkc11uvU39WbFk6DGspk3LQffZrllEbq4vRPdvVynnrCkr4FRnj5Pdatd6ex28tcazJ1JOxpyt9YMV4sshKU7vGEOXsoJ8CsZWL/V9yif9L/ER5OHwWT0ZPIRz7V7DepIwnBENArRG/fUasXRXJEbcQqX124xBJwh9IfDKpauC7r71so52pzlvVQVmK6kUJvyJjnEr0JtTqsa0P2yJ+txG2kFgITd/evR3GcVLljbehkEMr5nFOYDEn/rqaf2UtQJOC97Xh/CdyBmtk4uxL1rYaGS2GkLlG/AGfo0XlNIWhfb39WJDcOVpVy2Nf56sb34GU9fj3VWMUKVHCr8gYM6vHssxq4ditngThx7mYmt8U19RTHloxnhysQtmBHYzwL+Aw32KG+pZSILZDGCr9fnbQgwfDZ/Nu9Ag24jzHqvXpxChJbLStPKE6p61z18Gi8vlSl0Y2BD054ne2ejJlXwu/8XTm9JSTrlaPYt+ihF+RMY4lG1JMxGJ9r2nSMQ3T0INyW8SfKmXTOG7ILzjGN5NL/Z9zuG8xPiHZJpvys9aDF7TjWBroycyKAv5yVB8e+yL1HEJhB6vH7xDxW8U66PcltdvYxsssUnZ9TrZ6qhjx72OVNf5WqapL1FRuviIzlPArMsZJi1Pl11fasnqcUjaNG0cmef1RTTJA/MrYGXdyfmgx67Q2/DtyJp9oQ1kh98O4nQQRhJFJguqENeLPsQt/2DniD/p9jpaUPuI2/WCmtFZP2la7HH9fWz1SWT31BSX8irTYhdws2WCrtGlgt3KsYjp1yRaenb4q6RxS6nn6z1wy2FObQoTps+QRzg69QGVle/6v8k98oA3XSybYMDuBXabis2KdEMXY3hDvhIjfJvxO+IT79H/6MZKPBdA2PzFnvr4EyUbfT6rOXS9PL02zAxRZaiopqh8l/Iq02CN0p7zrxIjf3er5ZMGmlOeyT3LuRB+xkoeCT9F91Xpeix5Np5Me5t3/Lkm7X7rsH3tbzayemFaVVjo/jVjF/exBBXy2aDN7yiP4hKD//s155Nx+tMzLoml2gCZZAfO4xsAsq05eN6YbfQsSUxzri/Ab34vUdfTTH2fKX49iy273cRkGn15zhFn2QpEZSvgbOVLKtFFYKs/eIJrQueu+f7r6MalG7gaJMD7wPlf532c7zfis36Pc8FMrPm6eXPLYCbc5WBPPH7+O7Jg1JGLZOSWVzlGo9bjnDe1EXlaAF2es1mfO8vvMXHs7xsdu9eKP6NbaweqpH8qvmR7/3rW3bX42bfPTj6qtrVr2DQFVraiR46Xejd26Md67Z/W45/GnK5BlT+c06CdW8H7oZq4JvMsH2nCOrbiPVS2GA3okn+dh+jovEb+1rdYRqH6fcE0ttUb8fl88hTPdDdXM6rEIpU+IZOuofui+efNXZY/rPirib+REpUz7JbDbL8YALasQWgN1uxVkvXGk04Q9Nm+3JUVcG3iHi/xT2Epz/lD5f3ypDY6d05hIRdA8N0RJZVnKY3vq3LVciFW4Az5B8hAtnRxLxO+35O6nu1bjZmm1RvT5dRN3rC8yanx0qayexjz5SV2iVoRfCLEa2ANEgYiU0luPnqLa8Rbxe7d6hEidx59uJimjU+8gsYHz/V9xgf8rsqjkpeixPBQ5m2JyLcc1hBOa5wbZUJhG+D107oZd+hhSpUZarR6fD4vwe5Nsvy3itz8p1GTNmupES+Hx15NLaDTUZsR/tJRyey2eX4G3CpeVduHX3K2ekN+XnM5pEVM3GyCfUob6lnDYrx9wfGgGPX3riEgfH2mH8VjkNLNEcmLb9eP6hKBFbijtdXiJ+Ctc+hhS9U1Yhd/vi0/dmE74jU8pMeJ3H/xU1zFu/qrscd1HWT0NgLLKKEK4d17a1yf48bGoubC0kua5IaSUFJVFaJYbz5ZIyuqxvC+uiBDy+8zqkFbhj2qS4opIwv5GZoyfKP3FCo70L+AI33z6id/wC0l4W4ifZFfuCF/IB9ERbMe9iJc1i8TaXjcy9fitpBIz63H9QsQ9+3T6F/szWA/t1AVSXwY9aR5KNijqBrUl/BL4QgghgaellJNqqR0Ngp63fEbrJlnMvGmM6/oWuUHm3HIskOi5R6Vk1ppdnPnkDJ64cCA7Syq56f2FTP3rUWYJYLsYWvfvc+vndGyWzcbdegXLUMBnCvKdkxfzwverueDQTub2cscKrg9M4wz/d7QThUSlYJ48iMejpzJD60OLbsP5dOkuT9dtlGwQAtrZskD8PpH05OElq2f4wa34fsWOpOWpxDcnZLV6hOcRs8Z8Bnarx06mup8X8ieUr95X9OrYlHfnbOCAVrlJ6w49sBWT529KOa5Bse+oLeEfIaXcIIRoC3wphFgqpfzWuoEQYhwwDqBTp05Ox1BY2F6cOu95V2l89ihrBB7VJAvWFwLw48odbNil++SrtpWYwm+vQxM2O3d14TJEH3QP3yjp8PbM9QBs21NBN7GOvwTe40TfT2gIvtb68350BOeffwnztgsejk2MMqzSu8oZTx4+n+Ca0V05/KBWtG+WTVFZmFs/XMSvW4sTtk8V8X/8lxFkB310aJZDWTia9JSTKuLPDtg7d721X5oRf2Lnrp1M4+fp149yTT2tSX43vAvDDmzlWGr5obP7ce3oruRnq7z7ukCtCL+UckPs91YhxHvAUOBb2zaTgEkAgwcPVrkA1YhV1CKaNEswWAXI+oHbyyikKqscDIiE9a3YzdkbX2JM6AtKyeLp6Ek8HxnLNloA8M/9C1hbGp+typ7Vk4q41QPNcoOM6dUuaZ0xClSI1B3LVrGyzs1rkInHb1odab610sHqcezIzVD5W+SFaJGXvs+juvH5hGt9/eygn67t8vdxixRu7HPhF0LkAT4p5Z7Y62OBf+3rdjRmKm1F0zRLRo4TduFPNcjK9PijYS5iMn/Oeovc8gqeix7P45FTKSTxnz876E+IkDMS/mjc47djtLFFXoii8ghSpq6UmY5U4w9yQvF1VqtHplP+GGmtnnrTvauoL9RGxN8OeC8W2QSAV6WUn9VCOxotVo8+oklHy8EqNeV2j98hq8cg6PfRuXIZTPob14uFfBPty93aJSyLdnRsS3bQl3DeIsuE5ukwonqnG5Yh/M1zgqyJLdubbJNUuyZbPTHhTxfxk9wZ6mj1KN1XVDP7XPillCuBfvv6vIo41lz1qKbF66i7qFt5pd3qcY74s6lgXMU7nFr2HuS34xr5Nz4IDwAEAZ9wTB3NDvgThb8sE+GPp3PaMW5uzS1pngGv5rsDqSL+LLvVI7wJv0FDSedU1B9UF3sjpNLF43e1eiIuHr9F2AaLpXwamsAZZe/wZdYxcOWPfMVQDNly61j1+RJnqUo1rMBekMuL1dPckua5NxF/qjIEbiUb0lk9xo3BmgXkaPGrkF9RzSjhr6Os3FacfiMXthdXUFjqVmAgMT0zavH47ZbLt8u38euWPa4e/8rtJfiJcm3gbd4I3YEPyZ2t7uM/uX+hSOSxpyLu12elSKX0mvdtL15mtMNpd9Pjt0b8NST8biUb0ls9OvZaPXaU7iuqGyX8dZAvFm1m1EPfpC1h7MZV/5vNLR8scl1faUvnjNeMiW9z/2fLuOT5nznp0ekU2zpcwzGLpXDTKl4L3cm1gXd5XxvBCZX3sDxvIFFN475PlybskyqV0qse27czrsNJlONWTzzi35viYca+3drpKa6HWLJXEvP449umGxTtlNWjrB7FvkCN3K2DLN28B4Alm4o44ZAOGe+/fldZytRFawTvls5ZWKY/MVRENDYXlSfsH4nqM19NCj1MNpVcU3klH2gjAD2rJ6JJthRVEAr4aJUXYtPu8iThn3nTGNPi8DrgSSCYe8sxLNxQxEXP/cSukkr8PkETh/RLY/BW+6bxgV17Y5kYTwsn9+3I2YP3p32z+HGtFpS1ZEPafE7HAVzJW6mIX1HdKOFvgOwuCyfV17FSEXZL54wrjDXzZ9PuROE/Ovwtt4YeZ7Nswfnhf7JCxuvNhwL6iNndZZUM6tSCLUXxEb1WWjeJzzLl1erRi7GFyM3SI+wdJZU0ywmmFHSrQO8NRhuzg/6kY1qtHp+lZENaq8cpm8rxWpTyK6oXZfXUc6RNXSojWlJ9HDvuEX98G2u5gy2WiP8U3/fcqf2HufIgTq28I0H0QU/njGqSXaVhmucGzSePVAXSvNaiMevXx37vLKlMsHKc6NAsx9Ox0xEwhT/5X8Yq1nrnrv7a66jDdCN3VekbRXWjhL8OYmi5l3RAez2a3bF0yJTCb8nSSfT4ExXGiNI37S7H7xMc7/uJh4NPMlP25NLK65MGY0F8AFdhaZjmuSGCAXfBNMg0y9KwUkorozRPM/Weff7aquK3RPzp2hZP50yT1WMeO77MuXNXKb+ielHCX8+x58Yb2Typ5q4tq7SncyZ37kJcNPeURzg+MIuJwceYIw9mXOQflOMsqAG/nq+vV/uMR/x2q8eKXdjcOmHjk5PHl6Urx5zjYWYuL3gVfmt6alqH38FiU527in2BEv46SCYBnj2yLzQjfnfZsVo9WkIef+KJ28SEf6RvDo/4/s1C2YXLK//Bbs1dbP0+we6yMBFN0sKj1WPv3M12uUnEJyePb5+uHLOXUsxeCHgUfohfj9cBXAl5/A7NVQG/orppdMJfVhll3rpCT9vuKqlk6eaijI6/eGORabfsLg2zZJO+/6bdZazaXqKvLw3z48odZsS3ansJm3Ynzx4lhJ7Zkyon32717CpJjPiXxTKEQM/NX7hhd4LVE3HJ4wc9mj7Kv4Cng//mN9GJSyuvp5jclIIW8PnMczfPCREyhd/7V80t59+cnNzyRJAu4q8um8SfwuO34/Ma8duODapWj2Lf0OiE/+9vz+PUx79PW8YY4JTHpzP2399ldPwTJn7Hhc/+CMAZT37P8f/R9z/snq84+sFpnDDxO/r96wvOm/Qj783ZAMDRD07jsHu+cjze8f/5jrOf+sH1fPbIvtDm8R/373jR0z++PIuTHp1OiWVgVVTTTCG3a06fyvlMCj7EStmBJ/d/gCLy0l1+gnA1zQmaFk8q4ddsdxJrCqbTsZvnBs0IvLND7XeA4/u0N18XtMhJSPkc0Kl5wrb99k9874RRsiHH5aZ0Wv94LSK/V4/f4XM37gHnD42XIlcRv6K6aXTpnHPWFgJQWhGFJqm3Xbcz9Ryudox/9IUb9Cj/t20lKbdftT31ekMQ7XXlrRj1agyMpwOnzt056/QJTrYUxW96US0+c5JVgAeJZVy16T6CrbuQf+rbPNixgJvLwgy+c0rSce8/qy//eHs+kFgBMyfkJ+g3Sja4WyTGaY/q1oZ7zjiE1dtLuODZnwBYfufxvDt7PRPeXWDGvW3zs/n5n2MorYywX3PnrJ3HLxhoTgU47W8jzeW/3nU8PiE46MZP9M/k5mNomqaDGBLTOZ14+Jz+PHC2XoLK60Ax49N28vjvOq0P3y7flnYeYYWiKjQ64a9J3OavdYv8rBk1idvrvyvC7h205jltEb8x4YqTx58d9FMe1thsycuPaJrp8Rvn7S9W8GLofnYH29D20o8oyNfr3LtF7Xmh+NfIKnrZAZ9ZGC3VROfWzuWOzXNYvysudqGAzxRba+TbMi9EyxQ1530+gS92q7AWZ7MPbMsK+jwJdap0Tvv54iN300X8sc5d63GMlFWfMJ+WVMSvqG4andVj/BOl+6esCna/3cBt6H5USnMOWitGFF8aTj99XnJWjy78Tlk9Rvlga3+CtVZPVJMcXL6Ql0P3sFPm89xB/4H8+OQmbgJp1VJrR2VOKF55M5QiZ9O4BOP4xqY5NsGviblnU1XdtOI1qwcg0+qcifvGXxuXqzx+RXXT6ITfIFWeux03Qfd6TLflmibZ5dBxa4y69TIpib1EspnOGdWS2m2kNm7eXW5aMBHLU0fHXTO5bssEtstmnFt5M2XZ7RL2dxNev0U8EyJ+i0h6ifixZe00zdGfJAwrpCYiX6+F24wbmhfhz7SdiR5/su2jIn5FddNohT9VSQM7Xm8SblMSullAUS0eoSecL6Jvv8fDpCTWY2uxgVMGZbYnBsOqKamMmtMLapokoklO9s3gtMXXsCPQnnMrb2EzrZJsETfht4pnIMHqsQh/So8/cRyBcfMw5mf11WDk67VchDH1ohfhN/BassF6XU4dvUr4FdVNo/X4Uw1wsuM14ncVeJcbQlTTnIU/dqPxMimJ9WYTlYlPEGU2G8k6mCkvFKCwNIwWqeSYjU8yMvQ/1uX158HmN7Ntj975axd+94FVwvF1tmVKwlQDuOxF4ozrz88OJCyvTQE0PX4PaalGM9PW43dYb+3oNW4INeBKKho5jTbiNzo/v/t1GzvSpHZaxXX6r9tNYVy/q5Rnv1tpdpZaM2xWWDJxwprzTWZDYbmZ0mnFuCnNjmUgWY9XVhnls4WbAZiyeItZRRPgkwWbzMqexrZWghZLpklWgB5iLYd9fS4jt/2PVyOjeL3nY5QE4uWG7WLtFhy7RvyW6DiVpWJ27sZOVxSzuIyI39izNksX+IQg6BfeZvGKNdN7kTaXw3g8jkKRKY1Y+DU0TXL5C7/w8g9rUm5rCLqUkoue+4mzn5oBwHPTV3Hn5CW88qO+v/UGMebhb8zXbk8MU5Zs4Z3Z6x3bZsc43j/fX8CfXpnFt8u38fuXZ/Lu7PiN45rX5wJwYBs9395u9RgDtwrEVq4PP8Hk0A00rdzC0x1u58bI74kQSBCZkG1ycjfh9fsEZwzYj7yQ35bVExf+ptnuKZP9Y3n0Zw/eH4Du7fQaQJcedkDCeatT9i87vHNG23drl08fSw3+VJiReprtrF0b448+OGm98aRTE4kIisZNoxX+yqhGZVQjokl2lKSJ+LV41gvA6h2lgF4dEqCkMpKwnR37DFZWmucGuXqU/k9vdNSm6n8wRuIaTxn2zuFmOUH+eOSBAJRWxjuHfWj0KJvNY8H/8E3oOo4q/YKlB1zA0RUPMZVDzeuLWkQmVU1/K36f4OFz+7PoX2MTIvug5caRFfSx4q7jHfcvaJHL6ntP5OjubQE9pXP1vScyuqfeuVwTXvdtp/Rm9b0net7+gkM78d6Vwz1t67kcv4W/Hdc9qT3GE5DSfUV102g9/nBEMyPrXQ4+e8K2LoJs7GcIu9sk5Kmyc3KDfrOjtTyi0cTv81RS2RB8++xYrZqETMEuKy9nqFjCCf6fONH/E21KdlPky+WZ6Ems63oxw/ofQtHyOeYoZk0mPp1kIvxOr4UQCeMUqjoDlr0cc10nU4/frdNaRfyKmqLRCn9lVDN9/t1phN8QQyPbxsBInSyPDbRyi/iLK9yFPzvoN73w8nCUJlmBNAXW9HMZk6PYj91ebufgdXN5MvgxQ99awptZxZTLIFO1AXwTOpIPSvpQQYjTs9uZdW6MPgtNykTh91hfJ5Ag/N6rcHqlvmW3GNfpVa/drss4TlQJv6KaabTCH45qZieqUy594rb6P5494i9MivhdhD9FxJ8V9JsDlYzjpIr4K2I+vT45iiS/bAOn++YxxLeMob6lHFy8EeZAK18r1u93PPcs34/p2iGUkEO+P0AFeluCfmFOYmI8kURjqZ0Gdo/fDWskbtwEzMFH1aDW8aye+qH8xo0q/cjd1McxPv50NX8UikxpdMJvaEc4Ik2BdUqptGJG/ElWjxHxx4TfJXvHLeIPEKGL2MT+O9dzhm8uWbNXQVaYk3b9xuBACX6iBNDwoREgCpO/5u/hVYSCZfRevY37stbRtKIMQlAkc5mtdeXLrLEMHHUW5763i/t79+PzpfPN81lLQAT9voS5YiE54k+VgplwHZYbhJHO6dUm8oQ5crf6DlmTmNk4abYz1rtZWHGrp3rapVAYNDrhN4Ino3MXSFn2GCwevyX3PxLVzEi5zBT+1FaPQGOwWM4x/lkM9i2jj1hFaGcUfoDDQkCsEOi5AAGISB9R/ETQf7Mwi9FEKfeF2BjtyIzoEfxGAT9Hu7FcFiDx0TWrCYe07A78lNC5a1yzQSjgo4Wt1k2S1ZNGvIXQP0+ndM5gNaq0rwayemoWj1aPS1VUA1P4lfIrqpkGL/yv/LiGyohGv/2bJ0Ts4Wi8c7ekMso9ny7BJwTt8rMIBnxmiiHogj5n7S7mr99tLps49VfzteG7O1s0kq+nTWVC4CtO9s9gP7GDChlknjyQ56PHE2jfi0H9B3Lt5I3830kDWbpD8s68rWwtiWCXutuP682tHy5Ke81GNs2LM1a7bhPy+8gL+Qn4hHnDeuOXdbSzlET23rmbXLLBU767R3zVaBvtC7xH/Km3iNeV2vs2KRRWGrTwl4ej3PT+woRlBS30Mr6VES2hs/bpb1a6HieqaZz5ZGJN/IlfrQCgVV7ItHqs0fL+Ygun+H7gVP/3dCvfQNjv5xutL/dFz+dLbSBl6AJ7Qov2DNi/C2vkDzz+cxHLtxTHascni5wX0Z9wfA9zhK6RdupE0O9DCMHhB7dm9ppdFFdE0GS80xicyxP0LWjG/PW7OWdwAe/M3kBUyoTCbAe2yaN5bpAzBuiTsP9ueGcmz9/IYQe2AqDPfk3NtE2vxGfeymi3WqNr2yaE/D6uHdM15XZ/GdWVK176he7tk+cuNtbPeuFnenVoWhPNVDRiGrTwp+q0DVusnnS4ZdmM7N6G/OwgC9YXAuAr3sql/s851f89A336jeEnrQf/DP+OT6JD2UXyP3B2wE+zHN1yWbW9hP2a5/D9hFHm+nEvz+SLxVvM981yguYMX3aO6dWO0T3bsdZB8FvlhdhREv88jGj+5d8NBeCgGz9JGmjWwmFaww/HjzBfG4PH/BaPv3fHZsy95Vjz/YBOLVh5Tzw//eO/HOHY9lTUZK2emiA/O8hylzELVo7s1oZf7zrBdf2Irq1Zcbf7eoWiqjRo4XfqtI17/NJzvR63bJ0WuSFaRHdyYvkn8MKDHL7me4YHJYu1A7gnfD5HnvFHLnxrY8pjZwV9ZnZNOCrN1wb2zJA2+Vmuwm9YPE7z0OZm+dlhmfclGLCNynU4XvOc1NMaGnitcFllhO23QqHYKxq08DtF/EbmjdXjT4c1WydIhAHiV0b4F3DGml/pWLoYHxJKurOi55+5cm5nfpUFCAFj23QGUgt/OCppbsmusQu/vcM44NNrxjg9hRhRfNPs5D+rdbIUSK6P79Qx3Twv9cxUNVkn34n6YvUoFHWdBi38TgOzjCjfOnLXiQAROogd7C+20Xr5b9wamE5f30p6iTXkiEqiUrDV34fvO/6O+9b14OPx41gybyO/zpkD6EXQUpUiNigPRwn4feRnBdhTEaG5bfJwpzo/2QE/4Whyiqgh/E6doNY5Z63bpiI/K/XXQ7deZI1H/E7lixUKRdWpFeEXQowF/gP4gWellPfWxHnKd26gt1hNFpVkiTBZhGkZDZPlL2LoxhBd9kS4O/AbTUUJzSihuSimGSU0EyXkU4ZPxBRnFnTxZ7FQduHV6Gh+1nrwg9aLPw8aRFllhIUrVyClJGp5MsgLBRJq1bi2MZYR1DwvqAu/Q269HbeBQanOl2sTcS85+mmzaIz6+R4HelUVt8ngFQpF1djnwi+E8AOPA8cA64FfhBAfSikXV/e5ui57kslZbyevCAIbQRNB8v05FMk8dpPHdtmM3+jIbi2PQvJZL1uzXrbhmMOHcuf0PWgONe2yYpkvFREtwX7Jy/J7qk1jZAQ1ywmyjjKzjIKBU8RvjBvIDvrMGwekjuLzQolPH9UxwMq4On8NK3J8Tl6l/ApFdVAbEf9QYIWUciWAEOJ14FSg2oX/pxYn85/VnaggSIUMUUGQMkLsjgl9Xl4+2z1MdjL3p3JH0Yd4yuN1b8w1i50B5GUFPImrIfzG3K9JnbsObpRxL+jQLIdV2+M9tqnmj81Lsnr2XkTjZRn2+lApMYRf6b5CUT3UhvDvB6yzvF8PsbrAFoQQ44BxAJ06darSifa06MXM7FzX6ptlJfryY3u146hYauZDXyxjjS0d0l7XPuATdG+fz1mDCthQWEa3dk34dvk2SmITn7TMC3HWoIKkiP/xCwZy9ydLyA35OXtwAVMWb+Wmk3oCcMbA/SitjDCkc8uEfW4+qRdXvjrLFPV7z+zL54s2M23ZNi48tBMvfL+Ky4Z34fWf1/K7EZ3N/e44rQ83W8Yw5Noi/lSTnwP83zHdUq4HePKiQTzz7cqEuvs1gVm2Xim/QlEtiH1dAEoIcRYwVkr5+9j7i4FDpZTj3fYZPHiwnDlzZpXOt3l3OcPumWq+z88O8Owlgzl30o/mslk3jaFVkyzz/czVOznrqcQBWxcN68QrP64F4OcbR9PWMsIV4IZ3F/Daz/r6ubccQ/PcEFv3lDP0rvi5M6n/Xh10njDZfP37EV14dvoq8/2zlwxmTK92jtv+7dhujB+VevDRvuTrpVu5/MVfGNm9DS9ePrS2m6NQ1BuEELOklIPty2tjIpYNwP6W9wWxZTVCjm30qbUMsoG9/LDTiNX2TbPJDurbOVk41sFORrmCYArrZV+TFfQ2fy5As1xv+fv7CtPqqeV2KBQNhdpQpl+ArkKILkKIEHAe8GFNncwueDkOwm+3PbKDyR9Ls9yQ2fHqVKfe6s0b6Y01ne2SCUmppSma5jRitzaJZ/XUnc9ToajP7HPhl1JGgPHA58AS4E0pZfoiNFUkKyma9yU9BdgjeKf8+xa5QbOMsZM/bs2/j1eorDsRfyazX3kdsbuviJcvrtVmKBQNhlrJ45dSfgJ8si/OZY8Sdasnte2RE3ISfkvE7xDJW9Mw4xUq645SZST8dSzi16yzkisUir2m7oSk+4jsoN/MvU+1jZ1mOUGa5wYJ+oWj5WAVS2N9jdewyYBM2lLXhF8N4FIoqpdGJ/y5IX+S1WMn28HDb5EXonluyDU338kXr0uedFJbUiRz2ctG1D7GAK5aboZC0UBo0LV6DK4d05VZa3aRFwpw88m9EqyaPxzRJWl76yQiLfNCDD+4Ne2bZnNyvw60aeIsip1a5nF8n/Z0aJaTsPzKkQexZmcpJx7SoZquxjvvXXk4z01fRW7Iz0XDOrFqezHH9GrP5PkbGX5wa8d9Lji0U9Io39rm6B5tOWtQAX87tnttN0WhaBDs8zz+qrA3efxuGHnrK+463nG2KGP9q78/lMNdRLIhke7zUCgU9Y+6lMdfp0gncnXP9qhZMukEVigU9ZNGL/zpqGsdnTVNXeqXUCgUNYMS/jQ0NuFXKBQNHyX8aUiXAaRQKBT1DSX8aVDWh0KhaGgo4VcoFIpGRqPI43fi+csGJ8xeZeeFy4ZQUpk8r21D5fVxw1i/q6y2m6FQKPYBjVb4R/Vol3L90T3a7qOW1A2GHdiqtpugUCj2EcrqUSgUikaGEn6FQqFoZCjhVygUikaGEn6FQqFoZCjhVygUikaGEn6FQqFoZCjhVygUikaGEn6FQqFoZNSLiViEENuANVXcvTWwvRqbUxdpDNcIjeM61TU2DOrKNR4gpWxjX1gvhH9vEELMdJqBpiHRGK4RGsd1qmtsGNT1a1RWj0KhUDQylPArFApFI6MxCP+k2m7APqAxXCM0jutU19gwqNPX2OA9foVCoVAk0hgifoVCoVBYUMKvUCgUjYwGLfxCiLFCiGVCiBVCiAm13Z6qIoR4XgixVQix0LKspRDiSyHEr7HfLWLLhRBiYuya5wshBtZey70jhNhfCPG1EGKxEGKREOKa2PIGc51CiGwhxM9CiHmxa7w9tryLEOKn2LW8IYQIxZZnxd6viK3vXKsXkAFCCL8QYo4Q4uPY+4Z4jauFEAuEEHOFEDNjy+rF97XBCr8Qwg88DhwP9ALOF0L0qt1WVZkXgbG2ZROAqVLKrsDU2HvQr7dr7Gcc8OQ+auPeEgH+KqXsBQwDror9vRrSdVYAo6SU/YD+wFghxDDgPuARKeXBwC7gitj2VwC7YssfiW1XX7gGWGJ53xCvEeBoKWV/S85+/fi+Sikb5A9wGPC55f0NwA213a69uJ7OwELL+2VAh9jrDsCy2OungfOdtqtPP8AHwDEN9TqBXGA2cCj6CM9AbLn5vQU+Bw6LvQ7EthO13XYP11aALnqjgI8B0dCuMdbe1UBr27J68X1tsBE/sB+wzvJ+fWxZQ6GdlHJT7PVmwJhEuN5fd+xxfwDwEw3sOmMWyFxgK/Al8BtQKKWMxDaxXod5jbH1u4H6MDnyv4F/AFrsfSsa3jUCSOALIcQsIcS42LJ68X1ttJOtNySklFII0SDycoUQTYB3gGullEVCCHNdQ7hOKWUU6C+EaA68B/So3RZVL0KIk4CtUspZQoiRtdycmmaElHKDEKIt8KUQYql1ZV3+vjbkiH8DsL/lfUFsWUNhixCiA0Ds99bY8np73UKIILro/09K+W5scYO7TgApZSHwNbrt0VwIYQRh1uswrzG2vhmwY9+2NGOGA6cIIVYDr6PbPf+hYV0jAFLKDbHfW9Fv4kOpJ9/Xhiz8vwBdY9kEIeA84MNablN18iFwaez1peieuLH8klgWwTBgt+XRs84i9ND+OWCJlPJhy6oGc51CiDaxSB8hRA56H8YS9BvAWbHN7NdoXPtZwFcyZhDXVaSUN0gpC6SUndH/576SUl5IA7pGACFEnhAi33gNHAsspL58X2u7g6SGO19OAJaj+6j/rO327MV1vAZsAsLo3uAV6D7oVOBXYArQMratQM9m+g1YAAyu7fZ7vMYR6J7pfGBu7OeEhnSdQF9gTuwaFwK3xJYfCPwMrADeArJiy7Nj71fE1h9Y29eQ4fWOBD5uiNcYu555sZ9Fhr7Ul++rKtmgUCgUjYyGbPUoFAqFwgEl/AqFQtHIUMKvUCgUjQwl/AqFQtHIUMKvUCgUjQwl/IoGjRAiGqueaPykrNIqhPiTEOKSajjvaiFE6yrsd5wQ4vZYlcdP97YdCoUTqmSDoqFTJqXs73VjKeVTNdgWLxyBPtjpCGB6LbdF0UBREb+iURKLyO+P1VP/WQhxcGz5bUKIv8VeXy30+QHmCyFejy1rKYR4P7bsRyFE39jyVkKIL4ReZ/9Z9AE7xrkuip1jrhDi6VjJcHt7zo0Vb7savcjZM8DlQoiGNNpcUUdQwq9o6OTYrJ5zLet2SykPAR5DF1s7E4ABUsq+wJ9iy24H5sSW3Qi8HFt+KzBdStkbvW5LJwAhRE/gXGB47MkjClxoP5GU8g30iqQLY21aEDv3KVW/dIXCGWX1KBo6qaye1yy/H3FYPx/4nxDifeD92LIRwJkAUsqvYpF+U+BI4IzY8slCiF2x7UcDg4BfYpVGc4gX7rLTDVgZe50npdyT7uIUiqqghF/RmJEurw1ORBf0k4F/CiEOqcI5BPCSlPKGlBvpU/e1BgJCiMVAh5j18xcp5XdVOK9C4YqyehSNmXMtv3+wrhBC+ID9pZRfA9ejlwtuAnxHzKqJ1ZvfLqUsAr4FLogtPx5oETvUVOCsWM12o4/gAHtDpD5132TgVOB+9KJf/ZXoK2oCFfErGjo5scjZ4DMppZHS2UIIMR99Ltzzbfv5gVeEEM3Qo/aJUspCIcRtwPOx/UqJl+C9HXhNCLEImAGsBZBSLhZC3IQ+U5MPvcLqVcAah7YORO/cvRJ42GG9QlEtqOqcikZJbKKQwVLK7bXdFoViX6OsHoVCoWhkqIhfoVAoGhkq4lcoFIpGhhJ+hUKhaGQo4VcoFIpGhhJ+hUKhaGQo4VcoFIpGxv8DqkC0weCJJj4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Setting the environment\n",
    "agent = Agent(state_size=37, action_size=4, seed=0)\n",
    "\n",
    "from collections import deque\n",
    "import numpy as np\n",
    "import torch\n",
    "\n",
    "def dqn(n_episodes = 2000, max_t=1000, eps_start=1.0, eps_end=0.01, eps_decay=0.995):\n",
    "    \"\"\"\n",
    "    Train the Agent with Deep Q-Learning\n",
    "    \n",
    "    Params\n",
    "    ======\n",
    "        n_episodes (int): maximum number of training episodes\n",
    "        max_t (int): maximum number of timesteps per episode\n",
    "        eps_start (float): starting value of epsilon, for epsilon-greedy action selection\n",
    "        eps_end (float): minimum value of epsilon\n",
    "        eps_decay (float): multiplicative factor (per episode) for decreasing epsilon\n",
    "    \"\"\"\n",
    "    \n",
    "    scores = []                                                 # Initialize collecting scores from each episode\n",
    "    scores_window = deque(maxlen=100)                           # Initialize collecting maxlen(100) scores\n",
    "    eps = eps_start                                             # initialize starting value of epsilon\n",
    "    \n",
    "    # for each episode\n",
    "    for i_episode in range(1, n_episodes+1):\n",
    "        env_info = env.reset(train_mode=True)[brain_name]       # begin the episode\n",
    "        state = env_info.vector_observations[0]  \n",
    "        score = 0                                               # initialize the sampled score(reward)\n",
    "        \n",
    "        # Set constrain maximum number of time step per episode\n",
    "        for t in range(max_t):\n",
    "            action = agent.act(state, eps)                      # agent select an action\n",
    "            env_info = env.step(action)[brain_name]             # send the action to the environment\n",
    "            \n",
    "            # agent performs the selected action\n",
    "            #next_state, reward, done, _ = env.step(action)\n",
    "            next_state = env_info.vector_observations[0]        # get the next state\n",
    "            reward = env_info.rewards[0]                        # get the reward\n",
    "            done = env_info.local_done[0]                       # see if episode has finished\n",
    "    \n",
    "            agent.step(state, action, reward, next_state, done) # agent performs internal updates based on sampled experience\n",
    "            # update the sampled reward\n",
    "            score += reward\n",
    "            # update the state (s <- s') to next time step\n",
    "            state = next_state\n",
    "            if done:\n",
    "                break\n",
    "        scores_window.append(score)                              # Save most recent score\n",
    "        scores.append(score)                                     # Save most recent score\n",
    "        eps = max(eps_end, eps_decay*eps)                        # Decrease epsilon\n",
    "        \n",
    "        # monitor progress\n",
    "        print('\\rEpisode {}\\t Average Score: {:.2f}'.format(i_episode, np.mean(scores_window)), end=\"\")\n",
    "        # get average reward from last 100 episodes\n",
    "        if i_episode % 100 == 0:\n",
    "            print('\\rEpisode {}\\t Average Score:{:.2f}'.format(i_episode, np.mean(scores_window)))\n",
    "        if np.mean(scores_window)>=14.0:\n",
    "            print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode-100,\n",
    "                                                                                         np.mean(scores_window)))\n",
    "            # save model\n",
    "            torch.save(agent.qnetwork_local.state_dict(), 'checkpoint.pth')\n",
    "            break\n",
    "    return scores\n",
    "\n",
    "scores = dqn()\n",
    "\n",
    "\n",
    "# plot the scores\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "from scipy.ndimage.filters import gaussian_filter1d\n",
    "ysmoothed = gaussian_filter1d(scores, sigma=12)\n",
    "\n",
    "# plot the scores\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "plt.plot(np.arange(len(scores)), scores, label='DDQN-Dueling Data')\n",
    "plt.plot(np.arange(len(scores)), ysmoothed, label='Filtered Data')\n",
    "plt.title(\"DDQN-Dueling\")\n",
    "plt.ylabel('Score')\n",
    "plt.xlabel('Episode #')\n",
    "plt.axhline(y=13, color='r', linestyle='--', label='Avg. Score = 13')\n",
    "plt.legend(loc='best')\n",
    "plt.savefig('DDQN-Dueling.png')\n",
    "plt.savefig('DDQN-Dueling.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Environment solved in 433 episodes!\tAverage Score: 14.04\n"
     ]
    }
   ],
   "source": [
    "print(\"Environment solved in 433 episodes!\tAverage Score: 14.04\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run Environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score: 19.0\n"
     ]
    }
   ],
   "source": [
    "agent = Agent(state_size=state_size, action_size=action_size, seed=0)\n",
    "agent.qnetwork_local.load_state_dict(torch.load('checkpoint.pth'))\n",
    "\n",
    "import time\n",
    "time.sleep(5)\n",
    "env_info = env.reset(train_mode=False)[brain_name] # reset the environment\n",
    "state = env_info.vector_observations[0]            # get the current state\n",
    "score = 0                                          # initialize the score\n",
    "while True:\n",
    "    action = np.int16(agent.act(state)).item()     # select an action\n",
    "    env_info = env.step(action)[brain_name]        # send the action to the environment\n",
    "    next_state = env_info.vector_observations[0]   # get the next state\n",
    "    reward = env_info.rewards[0]                   # get the reward\n",
    "    done = env_info.local_done[0]                  # see if episode has finished\n",
    "    score += reward                                # update the score\n",
    "    state = next_state                             # roll over the state to next time step\n",
    "    time.sleep(0.05)\n",
    "    if done:                                       # exit loop if episode finished\n",
    "        break\n",
    "    \n",
    "print(\"Score: {}\".format(score))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.close()"
   ]
  },
  {
   "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.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}