Categorical_DQN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Categorical_DQN.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "j8W8DcyP9WbP",
        "colab_type": "code",
        "outputId": "d516909d-a336-464c-b85d-f73199ce1a8c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "import numpy as np\n",
        "import random\n",
        "from collections import namedtuple, deque\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "import gym\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "BUFFER_SIZE = int(1e5)  # replay buffer size\n",
        "BATCH_SIZE = 1         # minibatch size\n",
        "GAMMA = 0.99            # discount factor\n",
        "TAU = 1e-3              # for soft update of target parameters\n",
        "LR = 1e-3               # learning rate \n",
        "UPDATE_EVERY = 1        # how often to update the network\n",
        "\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(\"using: \", device)"
      ],
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "using:  cpu\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o1m7pnUk9fLP",
        "colab_type": "text"
      },
      "source": [
        "# **Regular Dueling DQN**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UNvbfB4R9fm0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Dueling_QNetwork(nn.Module):\n",
        "    \"\"\"Actor (Policy) Model.\"\"\"\n",
        "\n",
        "    def __init__(self, state_size, action_size, seed, fc1_units=64, fc2_units=64):\n",
        "        \"\"\"Initialize parameters and build model.\n",
        "        Params\n",
        "        ======\n",
        "            state_size (int): Dimension of each state\n",
        "            action_size (int): Dimension of each action\n",
        "            seed (int): Random seed\n",
        "            fc1_units (int): Number of nodes in first hidden layer\n",
        "            fc2_units (int): Number of nodes in second hidden layer\n",
        "        \"\"\"\n",
        "        super(Dueling_QNetwork, self).__init__()\n",
        "        self.action_size = action_size\n",
        "        self.seed = torch.manual_seed(seed)\n",
        "        self.network = nn.Sequential(nn.Linear(state_size,fc1_units),\n",
        "                                     nn.ReLU(),\n",
        "                                     nn.Linear(fc1_units,fc2_units),\n",
        "                                     nn.ReLU())\n",
        "        self.advantage = nn.Sequential(nn.Linear(fc2_units,action_size))\n",
        "        self.value = nn.Sequential(nn.Linear(fc2_units,1))\n",
        "\n",
        "    def forward(self, state):\n",
        "        x = self.network(state)\n",
        "        value = self.value(x)\n",
        "        value = value.expand(x.size(0), self.action_size)\n",
        "        advantage = self.advantage(x)\n",
        "        Q = value + advantage - advantage.mean()\n",
        "        return Q\n",
        "\n",
        "class Agent():\n",
        "    \"\"\"Interacts with and learns from the environment.\"\"\"\n",
        "\n",
        "    def __init__(self, state_size, action_size, seed):\n",
        "        \"\"\"Initialize an Agent object.\n",
        "        \n",
        "        Params\n",
        "        ======\n",
        "            state_size (int): dimension of each state\n",
        "            action_size (int): dimension of each action\n",
        "            seed (int): random seed\n",
        "        \"\"\"\n",
        "        self.state_size = state_size\n",
        "        self.action_size = action_size\n",
        "        self.seed = random.seed(seed)\n",
        "        \n",
        "\t    # Q-Network\n",
        "        \n",
        "        self.qnetwork_local = Dueling_QNetwork(state_size, action_size, seed).to(device)\n",
        "        self.qnetwork_target = Dueling_QNetwork(state_size, action_size, seed).to(device)\n",
        "        #if name == \"DoubleDQN\":\n",
        "        #    self.qnetwork_local = DDQN.QNetwork(state_size, action_size, seed).to(device)\n",
        "        #    self.qnetwork_target = DDQN.QNetwork(state_size, action_size, seed).to(device)\n",
        "\n",
        "\n",
        "        self.optimizer = optim.Adam(self.qnetwork_local.parameters(), lr=LR)\n",
        "\n",
        "        # Replay memory\n",
        "        self.memory = ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE, seed)\n",
        "        # Initialize time step (for updating every UPDATE_EVERY steps)\n",
        "        self.t_step = 0\n",
        "    \n",
        "    def step(self, state, action, reward, next_state, done):\n",
        "        # Save experience in replay memory\n",
        "        self.memory.add(state, action, reward, next_state, done)\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 available 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",
        "        \"\"\"Returns 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",
        "        # Epsilon-greedy action selection\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",
        "    def learn(self, experiences, gamma):\n",
        "        \"\"\"Update value parameters using given batch of experience tuples.\n",
        "        Params\n",
        "        ======\n",
        "            experiences (Tuple[torch.Tensor]): tuple of (s, a, r, s', done) tuples \n",
        "            gamma (float): discount factor\n",
        "        \"\"\"\n",
        "        states, actions, rewards, next_states, dones = experiences\n",
        "\n",
        "        # Get max predicted Q values (for next states) from target model\n",
        "        Q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\n",
        "        # Compute Q targets for current states \n",
        "        Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n",
        "\n",
        "        # Get expected Q values from local model\n",
        "        Q_expected = self.qnetwork_local(states).gather(1, actions)\n",
        "\n",
        "        # Compute loss\n",
        "        loss = F.mse_loss(Q_expected, Q_targets)\n",
        "        # Minimize the loss\n",
        "        self.optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        self.optimizer.step()\n",
        "\n",
        "        # ------------------- update target network ------------------- #\n",
        "        self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)                     \n",
        "\n",
        "    def soft_update(self, local_model, target_model, tau):\n",
        "        \"\"\"Soft update model parameters.\n",
        "        θ_target = τ*θ_local + (1 - τ)*θ_target\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",
        "class ReplayBuffer:\n",
        "    \"\"\"Fixed-size buffer to store experience tuples.\"\"\"\n",
        "\n",
        "    def __init__(self, action_size, buffer_size, batch_size, seed):\n",
        "        \"\"\"Initialize a ReplayBuffer object.\n",
        "        Params\n",
        "        ======\n",
        "            action_size (int): dimension of each action\n",
        "            buffer_size (int): maximum size of buffer\n",
        "            batch_size (int): size of each training batch\n",
        "            seed (int): random seed\n",
        "        \"\"\"\n",
        "        self.action_size = action_size\n",
        "        self.memory = deque(maxlen=buffer_size)  \n",
        "        self.batch_size = batch_size\n",
        "        self.experience = namedtuple(\"Experience\", field_names=[\"state\", \"action\", \"reward\", \"next_state\", \"done\"])\n",
        "        self.seed = random.seed(seed)\n",
        "    \n",
        "    def add(self, state, action, reward, next_state, done):\n",
        "        \"\"\"Add a new experience to memory.\"\"\"\n",
        "        e = self.experience(state, action, reward, next_state, done)\n",
        "        self.memory.append(e)\n",
        "    \n",
        "    def sample(self):\n",
        "        \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n",
        "        experiences = random.sample(self.memory, k=self.batch_size)\n",
        "\n",
        "        states = torch.from_numpy(np.vstack([e.state for e in experiences if e is not None])).float().to(device)\n",
        "        actions = torch.from_numpy(np.vstack([e.action for e in experiences if e is not None])).long().to(device)\n",
        "        rewards = torch.from_numpy(np.vstack([e.reward for e in experiences if e is not None])).float().to(device)\n",
        "        next_states = torch.from_numpy(np.vstack([e.next_state for e in experiences if e is not None])).float().to(device)\n",
        "        dones = torch.from_numpy(np.vstack([e.done for e in experiences if e is not None]).astype(np.uint8)).float().to(device)\n",
        "  \n",
        "        return (states, actions, rewards, next_states, dones)\n",
        "\n",
        "    def __len__(self):\n",
        "        \"\"\"Return the current size of internal memory.\"\"\"\n",
        "        return len(self.memory)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tHC_VzdQ9iky",
        "colab_type": "code",
        "outputId": "671a1d83-da45-43bf-f54b-db7857c905f7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 368
        }
      },
      "source": [
        "def dqn(n_episodes=1000, max_t=1000, eps_start=1.0, eps_end=0.01, eps_decay=0.99):\n",
        "    \"\"\"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",
        "    scores = []                        # list containing scores from each episode\n",
        "    scores_window = deque(maxlen=100)  # last 100 scores\n",
        "    eps = eps_start                    # initialize epsilon\n",
        "    for i_episode in range(1, n_episodes+1):\n",
        "        state = env.reset()\n",
        "        score = 0\n",
        "        for t in range(max_t):\n",
        "            action = agent.act(state, eps)\n",
        "            next_state, reward, done, _ = env.step(action)\n",
        "            agent.step(state, action, reward, next_state, done)\n",
        "            state = next_state\n",
        "            score += reward\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",
        "        print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)), end=\"\")\n",
        "        if i_episode % 100 == 0:\n",
        "            print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\n",
        "        if np.mean(scores_window)>=200.0:\n",
        "            print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode-100, np.mean(scores_window)))\n",
        "            torch.save(agent.qnetwork_local.state_dict(), 'checkpoint.pth')\n",
        "            break\n",
        "    return scores\n",
        "\n",
        "\n",
        "env = gym.make(\"CartPole-v0\")\n",
        "action_size = env.action_space.n\n",
        "state_size = env.observation_space.shape[0]\n",
        "\n",
        "agent = Agent(state_size=state_size, action_size=action_size, seed=0)\n",
        "scores = dqn(n_episodes = 500)\n",
        "\n",
        "# plot the scores\n",
        "fig = plt.figure()\n",
        "ax = fig.add_subplot(111)\n",
        "plt.plot(np.arange(len(scores)), scores)\n",
        "plt.ylabel('Score')\n",
        "plt.xlabel('Episode #')\n",
        "plt.show()\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Episode 100\tAverage Score: 15.41\n",
            "Episode 200\tAverage Score: 57.75\n",
            "Episode 300\tAverage Score: 167.59\n",
            "Episode 400\tAverage Score: 191.50\n",
            "Episode 500\tAverage Score: 184.80\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEKCAYAAAAIO8L1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJztvXe8HVW5//95djk9/Zz0SiCQUBLI\nIXSIBKQpKKKADbxcA4qFr14V1IuiV+UiivpTUVQEQUEUCwoXCZGiQIAEQgglpJOek57Td1m/P2bW\n7DUza9ru+5zn/XrldfZes2bmmZ2917Oesp5FQggwDMMwjJNYpQVgGIZhqhNWEAzDMIwWVhAMwzCM\nFlYQDMMwjBZWEAzDMIwWVhAMwzCMFlYQDMMwjBZWEAzDMIwWVhAMwzCMlkSlBSiE1tZWMXXq1EqL\nwTAMU1MsW7ZslxCiLahfTSuIqVOnYunSpZUWg2EYpqYgoo1h+rGLiWEYhtHCCoJhGIbRwgqCYRiG\n0cIKgmEYhtHCCoJhGIbRUjIFQUSTiOgJInqdiF4jos+a7SOJaBERrTb/jjDbiYh+RERriGgFER1X\nKtkYhmGYYEppQaQBfF4IMQvAiQCuJaJZAK4HsFgIcRiAxeZ7ADgPwGHmv4UAbi+hbAzDMEwAJVsH\nIYTYBmCb+fogEb0BYAKAiwDMN7vdDeBJAF8y238jjD1QlxDRcCIaZ16HYQLZuq8HDyzdhMZkHGOH\nNQAA1u7stI7XJ+Noa6nH5r3dRgMRprc1W33OPWoc3th2AL3pDD50whTbdVds3oeDvWlcMnciMlmB\nP728BQuOGI0l6/bggmPG2eR4ctVOTG9rwaSRTXh2zS6MG96Iaa3NeOqtDryx7QCuPHkqGpJxbNrT\njfW7unD6jDZs29+DVzbtx8HeFC6ZOxFEpH3Gl9/ei3iMsLc7hUNam/HS23tx8vRW/HHZZhw5figA\n4LWtB3DJ3Il4Zs0u7O7qx4imJLIC6OpLoy4Rw56ufvSlMp6f44jmOgBAc10CHZ19yGYFxg1vxNu7\nu6w+M8YOAYGwrqMTU1qbURcndPVl0NWfxq6DfbbrTR/dgrU7O9E2pB596SwO9KQAAFNGNePtPd0Q\nQmBqq/E6m7VvgTxpZBN2HOhFfzprtSXjMYwb3og9XX1oqktg54Fe61jb0AY0JGIY0pBEKpPF6h0H\nrWOJeAwfPGEyWlvq8cdlm/H27i5Dto4uQAjUJ+P4QPskPPVWB5JxQkMyjsNGt2Dphr2574wXju9S\nU30CF80Zjz8u3YxUJgsiwrTWZqzr6MSEEY3Y3dWPiSOaQAC27OtBd1/a+qw27OrG5FGNWN/RhSPG\nDcXYYQ148s2dABEunD0OSzfsxdZ9PZgxdgjedcx4f7kKpCwL5YhoKoBjATwPYIwy6G8HMMZ8PQHA\nJuW0zWabTUEQ0UIYFgYmT55cMpmZ2uMPSzfjB4+vdrUTAc6t13Vta3d14eEVxtftnCPHorWlHgBw\nz5KNuP3JtQCAlvoEtuzrwf88/IZ13nFTzsS4YY3W+yt//SIak3G88c1z8cFfPg8A2HDzBbjqrheR\nzgocPWEYTjm0FWd89wlkhXHsPT95BjsOGANrU13CpXQk7/3ps662C44eh4df3Ya6eAwZIZDJCvz0\niTU4aA46Xuh0UNAW9brPze/a+Wx573Wu373DHhvelMSlx0/Cf/3hFW3fe57biO2KwtHJpUN379e2\nHsDfXtnqfVIIWuoTOHrCMDy3bjcAYM3Og3jk1e0AgHfPHl/7CoKIWgA8COA6IcQBdWYkhBBEFOkr\nJIS4A8AdANDe3p7H148ZqBzsTbna3nvsBNx26Rys3nEQZ9/2NABg4emH4Mvnz8TJ31mMrft7ceT4\noehLZ22zVPV1T39utr2vJ4XdXf22e6Qzua/hP14zfrw9mhl62pwdy7/qZFkqB6/nAADhMQLu6zHk\n6c/kZA5SDm9+81w0JOOu9kdXbsM1976kPeey4yfh5vcdg4t/+gxeenuf57Vvff9sXDJ3IgDg7O8/\nhdWKFQcAv/xoO/69ZhfuenYDjp4wDBNHNOL/Vhqf2/rvnG9ZT//9l5W4Z4mx4HfJDQswdlgDdhzo\nxQnfXmy73tffPQtXnjINDyzdhC/+cYXt2LxpI/HA1SfhYG8KR3/9MfSlsshmbV0wZmg9/njNyTjt\nlic8lYO8hxcnfWcxtu3vxVEThuLGdx2JD/z8OcsqeOXGd+KE7zyO3lTW8/wHP3EyvvqXlXhj2wFb\ne28qgz1d/XjnrDFY09GJfd3Gd+MbFx2Jj5401fN6xaKkWUxElIShHH4rhPiT2byDiMaZx8cB2Gm2\nbwEwSTl9otnGMKHo6ncPivUJ4yuuTkzky1jMeBGPEWIEZJQRW33dl85o2yXyOkvW7cbV9ywLlDMb\nMK32mqmqSkSls8/bXeSFTjkAhhvOi7j5nI113n0AIKbIH4+5HyYWA6a1NgMAhjQkkIwb/0d18Zjt\n/0k9V77WfTbyWEJ3L7NJ3iOVzSLj+PxjRFo5bfeI+w+Vceu7FLNkTJnflXicEPMzP0w5dSKkswK7\nu/owoqkOjck4DvamLZnLQSmzmAjArwC8IYT4vnLoIQBXmK+vAPBXpf2jZjbTiQD2c/yBiUJnX8b1\nQ6+zFESujWAfUAwFQdbMHgBSymxcnfkJIVzuBHnLfd12y8ILIQTWdXR6HpfyOVm3S39Od4C1EIVG\nHwUhP6/GpL/jQR28dAMZEWH88JxLLhEn21/n/dTXuuupit51L/OztBREWrgUdIxIq1xUkkEKRMqg\nDPRp8zsUpzAKwrvPrs5+DG9Ooqkujk7z/zpIoRWLUloQpwD4CIAziWi5+e98ADcDOJuIVgM4y3wP\nAI8AWAdgDYBfAPhkCWVjBiDdfWm0mXEDibQg7IOW+df6UROIyBYgTftYEALuAQaAZ2DZSTYLnPm9\np0L1Vdm6z3B/DG2wD9Dd/dEsiAtne/utvSwLwJgdA0BTgAWhfgxaC4IIs8yA+gfaJ6HOHLyTjll6\nXFEY8rVuEI2Tt4IwRbasxFQmC5F190kEWAhBx3NWTAwwlZKcZMRj5Bu/AKSC8D4+oqkOjXWJsiuI\nUmYx/RvwmAoBCzT9BYBrSyUPM/Dp7EujbUi9zY9cnzAGM/WLKH+sdgvC7j5S4wp9igWRFQA0wVPn\nPfwIDJx5XCitDDgqnREsiF9/7HiccZh3lWdfC8IcpIMUhCpfTKsggAnDG7H6W+chGY9h2ca9ANwK\nQm9BuO8XswZnbwtCXj+VzWotiKABNxn3Py6VVCyWkzFlfocSsWALgsh/gjGiKYmmZBydpospXusu\nJoYpN139aYxqqbO11WktCPtsNB4zBgjVN51WIpl9aVVBeA/vYf3CgTEIj3YpX9oRB+mKoCAaEnHt\noG0dT3oPCeFjEMrMXxczILvbRyoe5yAsLRb13rpBNGdBuGVXuyfjsbxdTIExCsWCkDKms1kQGQos\naMIfpKSGN9WhqS5uJT8MBBcTw5SV7r4MWurtRnG9NgZhIAcmwwVAdgvC18XkwGwIO6nzykay5PO4\nkHSBOdcKOBWGH0EzYZ0F4QwCO/tcPs+ebh4UpHY+n5eLyW5BSEXvltkvSK3eKxknpDK6ILU7/uEk\noVE+OhlUZZDOCN/YiU2GmP7ZJIaLKa70ZwXBMKHY1dmH3lQGnX1pl4LQBqnljFOxIPxcTGqQOiOE\na4CX78IqiKDx3NOCME90DnBRCPKl67KY5FgkB0Gni2lEU9LR3z9I7RzbvILUNleVjBtFDFKrTYl4\nDOlsVpNkQIEKIEixJhQlJd1a/Zmsr+XjlMHZR1V4wxqTts89yOIpFjW9oxwz+DjYm0I8Rmiqy311\n2//nccyeNBxdfWk0uywIMwbhk+YqfcQpxa2UzqguppwFIYR7UZSwLAhytOsHcqeLw9nPayyROkuX\nahuWoIFFZ0EYA56wFKozkO2U1+Zi0gaO7W2WqynmrSDkZ+sXpNbHIHLUxWPo93AxBY23QYo1plgK\nUkTDgvC2fOwyuPs0JuPWepaWhgQale98zae5MkwpOPrrj+FEx0IpAHhl0z509WfQ7Jjd5rKYcm0x\nx4ASI0Lc18WkWBAaF5Nscf5ovcZxZ7vzvddvP+tYaJcPTjeO+7j3wOOVSeRMy1Un40GzelUm53X0\nLiONXL4WhN3FlM5mXZ93zHQx+j17kGK1WRCWgshZEMFBancgu0H5LrfUJWwWBMcgGMaDA73eQVmn\nBWG5mJTBR76yFEXc+FHbFYRiQaT8g9SyyWkJeM30nf2CgtbW9cx+BXiYAn3tfq4QOQg6b+8cqwIt\nCMc95MDsVL36+IVbLisGoXk2tX8iHkMqk3XFcJwuNB1BCkJNeMi5mIRv9pXzfOf91YSBpvq4zbor\nl4uJFQQzoGjyCFLbLAjHgCIXKdkXyikxCMXF1Jd2+7DlW+dA7zXwq2U8dP28ZpuFuJYkyQBfux+6\nLCEArlHbnsUURkHor6tfGa1xMVlrHXRZTKoFoXcx2dcw6AleJ6HEs8yu6WyUGIS7j6oQkvEYB6kZ\nplCcPnRpQegiv+qsLxazZwfZSm0oFsTtT67Fnc+s195bDWw7r6HyBUe9oLAWgXPmG5affDC3tUqQ\nBeGH16zV2WoLUoeyIPQuJt2Arw96h41B6F1MRPYJg47AdRCmrKoFkUpncxZEwEiri4M4Yz02FxPH\nIBgmOk4FIYPUuswaZ6kNNTtIroIVQtiC1Dqky8g5Mw2bbeRUJF6n5Zu9dMzEYdbrQhSEnA2PN0up\nS9xBauUczSpnZ3+vwdevtpJOriB3luVi0qS5et3PeQ/P44qbyloolxW+K8BViNx9GhLeCqIAQzAS\nrCCYmmXLvh5Mvf5hW1tDMoZnrj/Tel+flLPTHKT8mIFcrRxdsb50VgSmpcrxJuMo4RB2xu9SLMp5\ndz+7AVOvfxgHe1N5WxDqTLQQF5McQM89aizOO2qs1e4OUrtjEOrgG9bFFGYNBRCQxaQ0Gesg3GnK\nfqU6gmTMyRqzriXvmcpklSym4BiGy4JwJFyoMgSl5RYLVhBMzbJyy35XW2MyjgnDG61ZrlyEpa3F\npLgWYmQf0KW7qC/tXaLZSdpRRzpszMDZTbUUfm26s3Z19uedvaT6rothQRARzjxitNXul+YqlUWd\nMrg5B2Lp33cGqcPK6r8Owh6DSGWyliJ3fQ/8YhCBK6nNv3GCnI4I4V+F1n6+JospYZcnYVtZ7n+9\nYsEKgqlZdAOwc6GXzASxr6QOEaQ2B/ten53XJHI8z9fF5Fp4p7yX14hR/i4mdaAJmgkDwCOfOQ33\nffxEV7s6YKuv3TGI3GvZTe3vHGvrPBRB2FROvyCzq9SG4mKS/Ukjo5Ogzy2hWBC2xXmh01zdfZwl\nTeyfYXliELxQjqlZdArCFaSO+yyUU1wTRGQb4OW1w1gQcubrdjEFnmr0c1oQynlZa7ZLebuYEjbX\nRPDAMmv8UG19J3v6au6aLgtCdSdZGWNq/5BB6pCDoJVsoE1zVS0IQjqTy2JKxAn9Gf8YhiVLUJqr\ncg3dnhZqKq12TxEiV1zBGYPQlR4pNWxBMDWL7ofmLDYnf6u6Uhu5DBNCPGa/nkxz9du7WZKLQThc\nTCFn/H6Wh5TJGFhCXc6XsLPyuoR7aLC5OGwK1xGD0KS5qvspuEtthI9B+PULCmon4jH0Z3Jpys5F\nbH7xmeBaTTkF4WdBeD2TrtRGMuEdqylXkJotCKZm0VoQplneNqQeW/f32txIEsv37Ci1kbYFqY3R\nOJwFIc+xt+cbpM5mBa789QuYPXG4pSziMQq9oM6PsHtW6AZb3Q5vOmwuJo0F4bVQziVDyBiEX5BZ\nbamLx2wWhGW5OJIWdAQF923WKNyfEymKUretVEzjYnK+Vz+Pmt8PgmFKjW6GLs3yOz7ajkWv78C4\nYcbOZerPSb5WLQhnFlMqQpBaxgyc8oQNUjsfI5MVeHJVB55c1YFWs3w5RbheMdApEt3+DID/wCYH\nsqTP4Jb0CFJ7Lsxz4G9B2GU2gtTC1t9vJbZ1bkgLwijbobbbF2p6DexE5CqNTgB+eNkcHGlurqQ+\nX7nWQZRMQRDRnQDeBWCnEOIos+33AA43uwwHsE8IMYeIpgJ4A8Aq89gSIcQ1pZKNGRjoZujSghgz\ntAEfPnGK1a7LrFEHFlepDVNBhAlS3//iJmzf34u5U0bY2vN1MeliISLC9UqFboc3IFyxvmTcO2YR\nZSW1Vi6/GIIapE7IILX9+n4L7XKyhCvWl3AoCJcby+NZdRYEEeGiORO0MgwEC+IuAD8G8BvZIIS4\nVL4mou8BUPMU1woh5pRQHmaAoUv7rNf4zgH9fhCWX9jMYrIPzOFdTHc8vQ4AMHvScFu7qsA+eucL\nnuc7LQOtghD5r6TOl5svPhpHjh+G993+LADvGaxzqFLHUjWV2NkmkdaFeyV1WAUBUz7/ldd18Zht\nHUTCkQLtX2rDXxYpgzOWkHNxyn7hYxAD2sUkhHjatAxckPFJfADAmbrjDBMGncvFy8euC1JbO8vF\nyJVdkpJZTCEsCIlzAFdn/E+/1eF5ntvF5D4mIMrqYgKAyxwbAamDkqosnB95XGNBqIOvl0vKtQ4i\n5CDoFwBWW6SLyW1B2GXVEVaWhCNI7YxBeF1Ht1DO+T7pE8cpFZXKYjoNwA4hxGqlbRoRvUxETxHR\naRWSi6kRhIg2YNqquTp+W9ItoF5O7gcRZaFcvjEIXxeTUsG10i4mLxeHc+avS/NM+qyD8KI4WUy5\ntpyLKZfmqvbxshJkGnQYYo4gtTPOoUvFBfTrIJx1rGwKuoAFj1GoVJD6cgD3Ke+3AZgshNhNRHMB\n/IWIjhRCHHCeSEQLASwEgMmTJzsPM4MEowRG+AFT/a3pfojONum+ChODkKgKIUb5r4NQi/7JZxQo\nv4tJImf2qvvcr7aS7rO2p2g6FYr5N08Xk2oJOnEvlBPW55hQCuwZ7/X3CyOHtfjSw4KQbV5uLGMd\nhP5zseT3SDMuJWW3IIgoAeBiAL+XbUKIPiHEbvP1MgBrAczQnS+EuEMI0S6EaG9rayuHyEwVomaj\nhMG2UM5xzPmjBvIrtaHKQ0R5B6nV4oCqkilko6BiEA8ZJLUHqY2/+bhHoloQOmwL5cx+faZ1KGfh\nuTRX/XAYZvW5TRZFnNxqbW83GCCD1M427xjEQC73fRaAN4UQm2UDEbURUdx8fQiAwwCsq4BsTI2Q\nyohIA6avBUHuzVruWbIR+7r7XQpi6qgmz3vYFASipLkK22xR3QNb1ncSwt9iKmXQUp0dSxK2ldTe\nM39roZyPi+nQthZcOHs8fnCZPUcl7GphfwWhXM8c6OV+HO4MIw8XUwR3jrOmktuC8ItBOCwIHzlq\n3oIgovsAPAfgcCLaTERXmYcug929BACnA1hBRMsB/BHANUKIPaWSjal90o6dwUY11+FL5x7h2d82\niGljEO4f3O1PrXWV+vYbjNQB3IhphC/Wp15V3aBIPqIQ/gpHZm+VctxQn10du523VGXQFdJzftaJ\neAw/uvxYzBw31PN+fvhZJHZ3j/FXWodJh4vJeb8xQ+sN+SIsW44RuQLjqoze6yBCWBCqBVfrMQgh\nxOUe7Vdq2h4E8GCpZGEGHums3YK48uSp+MT86aHO1ccg3P1a6hK2zYIA/8Ei7XQx5Rmk7u3Xxz10\npTYSMWMFeEMyju7+DOJESJcomO1lQfgNbHKmq1vJHuV+fvhaEFDva7yWVpmz0qrzfvIZo2zvSaQP\n0ucC4V5p2Lo0V3sfnWVWanglNVOT9KezDp9/+HN1v3fdLLRtSD3W7+6ytfm5G7IOF1PoUhuOgb9X\ns0GREHqLpLk+gf09qdzWqjFyR70BXH36IZHiKTq8Sm34uZhiMbeCKEZsIWw/XcBYupjcWUz2wVvq\nwKgZQ+o9nXGOKJsS+WVO1fw6CIYpJemssAWBw6YhGn3dbdqtLGOksSC876MqrCgrn7NCGPILmTnl\nHsi91kG0OBREIqav9XPD+TNDyeKHajX4rYPQfb42t1PI/6vQtZhCBqmlzLKMigw+e204lIufRPPE\n62oxhZE1yMUU9jrFhKu5MjWJMwYRBb99je33EK5Zt98PU3UxZbPh12lkhbDHIDSptV4WhNyGUm6t\n6nQ9XNo+KZQMYYh7rOR1fiJBn29YXR7agvC5oC4e4nQxSb3nNZhHHYxJGVWdLkm/CYY7ecL7Huxi\nYhgfUhmRt4tJh+7HmM5m0ZfOWH5+wD8G8eBLVmIeMgFZRypOPaJVEPDaICmGZJysMudq+uO33nsU\nPnTCFNc5+WIrtaF+YE4Xk1ZBqK9DWhAhg8N+3XTxkJwFIY/pLQV1S9ooqL2jWBBOK9jvtgM5zZVh\nCiadzdpm7FFKDzj7CmH/wd188dEADF91Xypr29nL7wd+sDe3yY4Q9gVvThYoW3Y6FUmPzsXksXI8\nEYuhPhHPWRCq/7/Is0xnZVRJVAsi9DqIIvTTDdapjLQg9ApBIuUMI4ZaJsTrc9K9t9/P/j6K27RU\nsIJgahK1ZALgHqT8CPKRy5lkOivQl85YbhwgnF/882fPMGX0VhDqbHXR6ztsx7zqP+kskoZkDPWJ\nGOrl1qrKsWJPMm0lvv1iEJpRhWwKItz9wqZy+vr1NVZPynQbJp2Dd1z/PrKLSRMYz733HnK9FFQl\nYQXB1CTOhXLRspjcndVZqNxNLZ3Joi+dRXNdzhMbZrCIOWaqOtTB6PYn19qeJZKLKRHHzHFDMb2t\nBYBzIC7uAKMO2HYLIpqLqZBNi3T4XU9rQUh3oUMh1DldTAFrF7zv6W1BeC3GA3Q780W6bUlgBcHU\nJOmMQCajWhDhf026nraibuZAkcoI9KYyNhdTmEHLSqf0URB+g3evJh1VLpRz3r4uEcO9/3mCtQYk\nn2yhsHjFINy1mDQKOI/RrhiZOro1CbKyrnM274xBSEUf1dVjtyAcQWqfjKgoWUzlghUEU5OksllH\nmmv4c3XBQHsQ1RhM0tksuvoyGNqQtI6FGbTkzLPfZ92B32X0BQKNtF7nXtFy1jukwbByPnRCroBl\nsfct9lrL4HwUvQsvDwWRxzmNybjtvW2wNt8s37QPgHs271QQViXWiGLYFYT9WJQspirQD6wgmNok\nlc4/zTVoACMiI3MpI9CTyliDLxAus0YOnht2dXn28bUgNApif08K6zu6XIOYVBhNdQms/fb5+OyC\nw0LdIwofNJWOlwURtJey0T/6feUM/rLjw6fqrrzpHIcs7utJnP+XToURVB7DC93uhRK/a1VjDILT\nXJmapJCFckEuEEKuNHRXXxotqoIIMZ2U1/rlv9d7y+AzUOj03vtufw4A0NpSh4NKu99ez8UaYG58\n1yxcf94RNvdIwqcYk24QzFeWN795ris24IdrNbK6aM1VA8oRg0g43UHhXUy2/UaUdmszJMcmRdpr\nkP/7SsAKgqlJUhl7mmuU35I+BqEcJ2NwSGez6O6P7mIKk6Oe70InLwtCK0eRRphYjNAQs7tu5CNe\nNGe8Js21eLI0OFxGUbGV2nAoBOf/pSsGIS2IiLL71Z0KWyZd974SsIuJqUnSysYvQMQspoA0TCJj\nhpzKCHT3p9FSr7qYijP462T4f2fN8C0nDrhnvX5lIEqZBUNEWH7j2bj1/bM1MR33jSs21mkWykmc\naa6eC+UKSHN1V2T1UxD+7ysBKwimJnEulItmQfi7QAiEZJzQ1ZdGVgBN9epCueCfTJgftm4QHdGc\ntM2Ydb73jGNthZ8FUeqFVsOb6pCMx0J99pWaDeuK9eXe+8cg5GAeRvTZk4YDAA4d3eKbauyfxRSs\naMsNu5iYmqTfYUFEKT0gf3dHTTD2H5jW2ozXtyq725oupv09KQBAUzJammtnXzqwj9f+yeogcejo\nFleffqeCqJAFoRJmHKvUbNi/cJ69r/OzjBKkft9xE9A+ZQSmtjY7rmHvF60WEysIhsmLdMaR5hrh\nXDkz+0D7JBw7eQRmjBmCVdtzod8YEZKxWE5B1EdbKLevOxXYxytQrl6/qc7980w7aoP7KYhyVfwM\npyCqz4JwztALqcVERC7lAETLYnKvJwm8bclhFxNTk6QdxfqiOLnlD4+IMGPMEOu1dSkYFsSBXmOg\nV1dSh7Eg9vXoCm47ZdAoCLJvXN9Y5/55Os9LliFIHUSYRYqVcpeon2fQDN35WeY2FMpf9igxCHew\nv/IaopRbjt5JRDuJaKXS9nUi2kJEy81/5yvHbiCiNUS0iojO0V+VYQxS2axrD+iw6GMQynEzSH1A\nWhBqsb4Qaa7jhjUG9tGNE8Z+xsbrRIysAnwqbS31uPs/5uG4yYbP28+CKNf4EuY+VTDWadKA7ced\nMYhckDr/ezoHeb8Yliu7WfOZvfCVBXjqC/PzFygipbQg7gJwrqb9NiHEHPPfIwBARLNg7FV9pHnO\nT4mosPw2ZkAif2+ptLCtVI5Wi0nX5g5S73coiGGNyVAWxNWnH4L7Pn6ibx+dq6GxLp7bvCZO2sG/\nL53BGTParP2bq8KCqIbR3wO/yqrOz6feaUHkuVDOfg/7+yi70+n+/0YPacCUUW5XVqkomYIQQjwN\nYE/I7hcBuF8I0SeEWA9gDYB5pZKNqV3UfYU37+2x2qPUYtJ1dVYnTZgL5QBjW8+/fepULPrc6YFZ\nTE/+13wk4jGcNH2Ubz9dUL2pLm61J2IxbYaS3MBIKsf6aohB+BwbM7QBADDW/Ftu/FJOnf8HXjGI\nYriY5CX89892npv3bYtGJYLUnyKijwJYCuDzQoi9ACYAWKL02Wy2MYwNYQamD/SksP1Ar9UezYII\ncDHBPttsrItb1VKds0wnukClXgZ3W1NdwjZr1SkIWYZj9NB6AEDrkDrPe1SDi+l9x01AS30C75w1\nBl976LWi3vd775+Nw8cO8e3jF6R2u5j0K6kL2b3NXd6jMAui3JQ7SH07gOkA5gDYBuB7US9ARAuJ\naCkRLe3o6Ci2fEwFOfTLj+C2RW/59pF+2tU7O23t0WIQbmw/RrIPFqpSeH/7RNxw3hGh7jNxhHcs\nYnije2Bvqotbg5gRg9ApCMNy+OyCGfjxB4/FOw4f7eojqYYgNRHh3KPGlmQHtKmtTThqwjDfPn5p\nrq4gtUeaayGiR0lzdVIF+qHvEGcNAAAgAElEQVS8CkIIsUMIkRFCZAH8Ajk30hYA6qqgiWab7hp3\nCCHahRDtbW1tpRWYKSvprMAPF6/27SMzW10KIooFoV2DoFwLZPMVqzP50UMacPUZ022Bay/+9ImT\n8R1zdzonZ80aYyusBxiuLNUVoXcxZSyZ3nXMeF/3R/liEGW5jea+YbKncq+DLAjXfhBmh0KUmytI\n7eMSdAapB50FQUTjlLfvBSAznB4CcBkR1RPRNACHAXihnLIx1Y9Q1j3s7bKnkha6H4RzxzO1GJ0u\nWOy3nahk9NAGnHPkWO2xOBEumTvR1hbGghjVUh94X0nZFsqV5zYuwgygtv0gAlYqJxMeWUwFDNTO\nU2vNxVSyGAQR3QdgPoBWItoM4GsA5hPRHBjKcgOAqwFACPEaET0A4HUAaQDXCiH0+y4ygxZ1x820\no+RplN+SbuapDgJEZEt51M3kU1nvvR68rqsSi7nlaFKymOJxQl3cbqWcNXMMvvbuWaHua9xjYFsQ\nYR7Pr1ifU25XkNpyMeX/gO7V2+GD1FWgH0qnIIQQl2uaf+XT/1sAvlUqeZjax2/OHiXTRNfVVr2a\n7DVzdBaEZntoLV7rJmJELjma6hKWa0uXxfT+9omYNNK/mJ/zHuWhMiNZKAtCeR1kCXhlMRXTxeS3\n5aj73LxvWzS41AZTFYgQI65fnyi/JX0Wk2JBIFfpk6iwdFEvl4JOQcRjZA1SzrIbQLTBxbhHpO55\nU7kYRHAf20rqAIe6ZwyiCEFq+dUNU+xRUg3rS1hBMFVBmM3h/C2I8PcKikGQksVUF48V9EP1Ui4x\n0gsi75uIkUshRFrrgXJmMVWG4lsQendQIR+jK87ho20GfZCaYbzIhrIg7O9tmalRspgCYhBQspii\n7GamwzsGQVo55CCViBOGNSYxb9pIVaxIlGuAqVwhvmhB6qDtYr3SYAuKQQQszvOjGlxMrCCYqiAT\nwoQQjjmW6jOOlMWki0E4lI2sg+S330IYvAYEZ2lvScJyMRmWy6fPPDQnV+R7RzwhT6o5SG1bSR3w\neThn+9Z+EFEFU3De08+KcR5hC4JhTMIEfZ191DIT0bKYdG32GISspOq3Y1shxEg/wNUpLiZDFnt2\nVbR7DOwsplAxCDXNNeKUvBhZYM7/syhKuwr0AysIpjrIx8XkV6jOj8BSG0RoNDcJKpWZT0S2weNm\nc0GddDHp/N9RZSnfOojKjGShFsopr8MoiM+oFhuFv48XhewSVw1BalYQTFWQCaMgXC6m/GbXuq7q\n4BEjWFt/OtdbFIuYIzvqsnmTAeRcTDr3RrUGqSsVpfZ6vl9d0a7tE2bB2+feebjr3EI+RqdO8vs/\ncQep879vsWAFwVQFIsS6M6cOUeMDUX5LwWmuhEazlEaY2Eg+qHs/qKhprqYwObmqNEhduSwmffuC\nmWOw4AijRpVfqY18rx8F1+rtSPevvIbgNFemKgjlYnK8V+MDUX5M+jRX+2vpYgpj2eSDl7x+aZCR\ng9Rli0HURhZTVDmlxVbI5+i8p9+lnIeqQD+wBcFUB6FcTI4+dXkHqf0tCEBRECFqLuUDkV5mGVeR\nCtPmVoo4YAxwD1PIILX3sXfOGovxwxpw1alT/e8TTazQ9w8+t/Iagi0IpirIx4LI18WkT3Ml2/GG\nugpZEKbSk7e1WTZRYxADvhZTGAvC+1jbkHo8e8MCz+POmFc+FLNMRyVgBcFUBfmkuSbztCC0MQi1\nFhNyWUwli0EQaYcfGXi3FIQqY8TxopAqpFFQP89zjhxTlns671tIHy90Sjoqhbmn8r9vsWAFwVQF\noRbKCe8spig2hK6n04JoKnGQmkgvh2VBmOqjEB96Jcp9//wj7Z79ik2pn0/+zxeW5locWSoFxyCY\nqiCfdRB1iVw57IItCIeCCApSv9+xl0NUnOsgJFJBZHUupsgxiIEdhAjzfEWxIPK+QoEWRAH3LRas\nIJiqIJSLyfw7oikJwLkLXHgCS22ArHUQXnJ99/2z8Y/rTo9w13DkXEwySK3KFY1qWyh3SFszTj20\ntXj3DXFbrz6jmr338pZYMYgyuZhOPax4n02xYAXBVAVRXEwjzB93T39uT6nC94PINcYI1jqIqNcp\nFN8gddQYRJUFqf/5+fm49z9PKNp9C4lBLPvvswPPzVkQBbiYIoywh44egg03X4C5U0bkfb9iwwqC\nqQqiZDGNbDIURFd/2joWzYII72LyvU6Ee4ZFrqDOfR752xDlcjFV20I5lWLIVswgtfxvPXR0SwES\nlY+SKQgiupOIdhLRSqXtu0T0JhGtIKI/E9Fws30qEfUQ0XLz389KJRdTneh87k7kj0taEF19qgUR\n/l66gcXelnMx+VGs8Vfdm1qug9Cpy6qtxVShdJtQtZgKikG43XxR0VkwG26+AD+4dE4BVy0fpcxi\nugvAjwH8RmlbBOAGIUSaiP4XwA0AvmQeWyuEqI1PjSk62RA/RukTtiyIvpwFEW0ldbAFId0zFx83\nwfdKhbL22+fbBvI63yB11Cym6nIxFZuo5b4lsycOC3X94qS56uUZO6zBajtu8vD8b1BiSrkn9dNE\nNNXR9pjydgmAS0p1f6a2sBSErwlh/JEWRLcSg4gyVusGFvuCNIM3v3mub7nvYgyMzjiBdDEVI0hd\nthhEWe7iJp8YxKr/OTf0+pCck6+QGIRx7oKZo/HvNbsw2dxTvLWlHm9841xj//MqzoWt5DqI/wDw\ne+X9NCJ6GcABAF8VQvxLdxIRLQSwEAAmT55cciGZ8pA1i/X5/VTkrFpmoHT25ReD0HVWB1OppILc\nTKX4WVsuJmv2ardsolC2LNeKWRDRb1yfCHYdSoq5UO7Kk6fi4mMnYpiZgQeES4SoNBUJUhPRVwCk\nAfzWbNoGYLIQ4lgAnwPwOyIaqjtXCHGHEKJdCNHe1tZWHoGZkpOzILz7SBdTS4Mxrzn3yLHWsSju\nl+BqruEohe/dGaS2WxDV6mKqVAyiTPcp4FyrKC+RTTnUCmVXEER0JYB3AfiQMO1oIUSfEGK3+XoZ\ngLUAZpRbNqZyaIvTOVAXLr3wlQX44eW5kFWkLCZNm3PL0XyvUyhyUC9GmuvAL/cdIkhdwPVz6yAK\ncDFVQ72MAiiri4mIzgXwRQBnCCG6lfY2AHuEEBkiOgTAYQDWlVM2prJkdVmdDnKlD4DRQxpsxwpd\nSW3fcjTcxUrx25fX1Pm/oyuI4sgUxEC1ILLKhCRfylUwsVSUTEEQ0X0A5gNoJaLNAL4GI2upHsAi\n80u1RAhxDYDTAXyDiFIAsgCuEULsKZVsTPUhF8r5/Z6Ej5URxf2iG1jUwGV4C6L4P355TaFxuUW9\n38BfB1H9WVo1rh9KmsV0uab5Vx59HwTwYKlkYaofv8E/18d8EZCFFESYhXLFZOlXz0L7/zweqq9c\neatbN1it3opyyzVv2ki8sH5P6RVTiO9kEOxiYpgiEKVoqu4nFykGEZTmGvJHHfa339pSj6a6uD0t\n14OhDUYgc+a4IXnfr9yUwpLy41dXtGPTnp6Su2/CLN4Molr/z8LCCoKpCsK5mGD20Y3w4e+l3w8i\nehZTPnzv/bNx1ATvhVrjhzfij9echCPHG30KcTGVi3IPgkMakpg1vnwZQYU8Xj57chza1oJlG/di\naGPls55YQTBVgQixUM4vFTZSDELTllcWk6Pf9LbmwHuOHlqPw8e6rQOV9qkjlfNK5/pi/CnKjnJ5\n/KfddNGRePfs8Zgxxv97Ug5YQTBVQZiMETWLyUkUb4PuR2sLUofOYsr1+/4HZuOMGcHrcqIHmnOv\nqzXgOVAVl/xOlnvb0IZkvGpKf4deB0FEpxLRx8zXbUQ0rXRiMYONjAjWEL5ZTAWW+85nxbLa7aTp\nozCqpT7wnKhjjV2W6hyJaz0QW0qoxutlhxKfiL4Go6jeDWZTEsC9pRKKGXyEK9ZnEBRkDiJ4w6Do\n1wltGURVEDXgYqpWuQolzCZWQZRrX/BSEVa/vRfAhQC6AEAIsRVA5R1kzIAhTAzC7wcbKYspoJpr\n+LE+1zHIMpDPVYiLqVqHmmoNnhdKbl/w/K9R69ZVWAXRb5bFEABARN7ROIbJg4ws1uf7e/JWIgXv\nB2HbUS6PNNc8A9uB/W3nVudgU6ViFU4RdpSr9c8mrIJ4gIh+DmA4EX0cwOMAflE6sZjBRigXk5Xm\nqjsa/peoL9YX/Upqv9BKJeS1rf41YUEMTGQ134Zk/oGEWrcgQmUxCSFuJaKzYZTiPhzAjUKIRSWV\njBlUhEtzNf7qg9Th76WPQai+/ujxhKAz5PHoVkB0y6bcVKlYBfOJ+dNBBHzohCl5X6Nce3KUikAF\nQURxAI8LId4BY0c4hik60sXku1DOxyccKQZRrHLfiK5UChkvqncgrlrBCqIhGcd1ZxVWVLrG9UOw\ngjArrGaJaJgQYn85hGIGH1m/QksmfpmwhfrnY4oXIZ+FcmEHgnJs+vPA1Sdhzc7O6CfmSfUqrvz4\n1RXtocqihKFa40ZhCbtQrhPAq0S0CGYmEwAIIT5TEqmYQUc2RE6h3w5fhf4M7RZE9HhC+EBmxCwm\n9XXIU+dNG4l500YGdywStT0Eulkwc0ylRagawiqIP5n/GKYkSAURxsWkG5IK9c/nleaqKpWgOCbJ\nc6LJRfnERspMtcZGmMIJG6S+m4jqkNvlbZUQIlU6sZjBRjZEmquvBVHgGFXojnKlsR/yu0e5Yf0w\ncAmlIIhoPoC7AWyA8T2dRERXCCGeLp1ozGAijItJUorxSJ2d5zMjDl8iPP+FctU6Ux+oC+WY8C6m\n7wF4pxBiFQAQ0QwA9wGYWyrBmMFFzsUUHKTWbxlauAzxGCGTFXmV2ggbpI5ci4lLbTAVJOwKkKRU\nDgAghHgLRj0mX4joTiLaSUQrlbaRRLSIiFabf0eY7UREPyKiNUS0goiOi/owTO0Sppprscp9eyEH\n73y2HA0f2M7fguBxmCk3YRXEUiL6JRHNN//9AsDSEOfdBeBcR9v1ABYLIQ4DsNh8DwDnATjM/LcQ\nwO0hZWMGAFmPhXL3LtmInQd7ARSvWJ8XkeslRYhb5BbKRZdLd79qgi2IgUtYBfEJAK8D+Iz573Wz\nzRczRrHH0XwRjHgGzL/vUdp/IwyWwCjrMS6kfEyNk9XsObppTze++peVuOaeZQCCyn0XLkNkCyKP\nwHYhVKuvvxqzqz75jkMxpD6BuVNGVFqUmiZsDCIB4IdCiO8D1urq4OL3esYIIbaZr7cDkEnHEwBs\nUvptNtu2KW0gooUwLAxMnjw5TxGYakO3/6+0Kjo6+wDkLAjdOBlm8Lz+vCPwu+ff9jwetTSz2jso\ngGxZJwUslKvCcRhAdRo2c6eMwKs3nVNpMWqesBbEYgCNyvtGGAX7CkKtEBvhnDuEEO1CiPa2tuAd\nvJjqY29XPx5dud3WposvyEFXpsD6r6QOvu81Z0zH0198h+fxWMRB3LZGIaCvCBGED7pH1WYxVadY\nTBEIqyAahBDW2n3zdVOe99whXUfm351m+xYAk5R+E802ZoBx9T3LcM29y7DLtAwAIJN1u49kobOM\n5X7yKfddBLnkZfNaSZ1PifCo94h2atmoVtcXUzhhFUSXmlVERO0AevK850MArjBfXwHgr0r7R81s\nphMB7FdcUcwAYsNuo1pLOpMzHnWL4ORruR1pKWsxAbk9IUpRi6koGwZV6Thc6wXpGG/CxiCuA/AH\nItpqvh8H4NKgk4joPgDzAbQS0WYAXwNwM4z9Ja4CsBHAB8zujwA4H8AaAN0APhZSNqbG0PkUdftB\nSMtBumfkeaVaByGvG35vh+hlMKJbENFTactOlYrFFI6vgiCi4wFsEkK8SERHALgawMUAHgWwPuji\nQojLPQ4t0PQVAK4NlJgZMKiDZUbjo5cWg1QUMtOpFMX61Hvns1AubN/IpTZqwMdUtYqLKZggF9PP\nAfSbr08C8GUAPwGwF8AdJZSLGQSow4qu2re0KixLQnOeda1iuJgiprnmQ2FbjhZVlKJRrXJVknJW\n0y0lQS6muBBCrmO4FMAdQogHATxIRMtLKxozUNGVXdKtg5BN8q/flhFFtSBK5C6Kcu3cCbmXVZvF\nVGkBqpD7P35ipPpi1UqQBREnIqlEFgD4p3IsbPyCYQLRuZjcFkR5FsqFJR/XygBcSF2VC+UqTSxG\nSMTz38u6Wgga5O8D8BQR7YKRtfQvACCiQwHw7nJMQWSFMfhv298DjQFhBael8pA+ppLVYopRwXtb\nB58TdTGeGgiPfr9yUKViMUXAV0EIIb5FRIthZC09JoRlM8UAfLrUwjEDFTPoLARufWwVbn9yLS4+\nboJxRDHLLRdTqBhE4VLFKJqayadvIUHqag0GV6viYgonzJ7USzRtb5VGHGYwoBoEz6zZBQDYeaDP\ndgxQXEzOdRAlGpFiFO3a+cgxIIPUVaq4mMKpfScZU7OogemsY62Dcdz4K4S9jy5WUAkLIgr5L5Sr\n/sE3cLtVpmbh/1qmYuisBbuLyR6Y8Cv3XYwMH6Jo18nnjoVYEJzFxJQbVhBM2ZEDvaoALGsB6gpq\nx3k+ea7F2lEuymiXX5A6//5Vqh9qwsph8oMVBFMxVAUh4wzb9vdi+pcfwf0vvB3JgijOjnIRg9Ql\n3Lva6m8rtVGdVKtcTOGwgmDKjrQEshoXU3/aMCX+uGyze6FRgeW+gyCKluaa1z0KOKFaZ+pVKhZT\nBFhBMGVHaF719GdsfdJZ4VobIUpc7tvwMJVmtLPSXAu4fLWOw5zFNHBhBcFUDFUBdPWnbccyWWEL\nWAP+5b6LMUbFIy6Uy4foGwbpX1cT1SoXUzisIJiKobqQuvrsFkQqk3VbEOZ7bbnvImgIKmGaq3WP\nAvpXq4uJGbiwgmDKjrWuIZtr6+yzWxCGi8muIXTbkkqKVYup5INw5Cym6lcKNSAikyesIJiKoSoA\nGZyWZLLCVeHVrzZmsaq5lm6hnPk36kK5EshSbDgGMXApe0VWIjocwO+VpkMA3AhgOICPA+gw278s\nhHikzOIxZUAI/ToHlXTW28WktyAKH6TiZchiikq1yaODtxwduJRdQQghVgGYAwBEFAewBcCfYWwx\nepsQ4tZyy8RUBuFjE6QzbhcTfMp9F2OQojK4mPyeWUctzM5rwQ3G5EelXUwLAKwVQmyssBxMGcmt\npPbuk9IoCF8LolgL5apsrKs2eXTUgIhMnlRaQVwGY88JyaeIaAUR3UlEIyolFFMe/HbcymSz7lIb\n5l/toFmMIHWMB7t8qAUlxuRHxRQEEdUBuBDAH8ym2wFMh+F+2gbgex7nLSSipUS0tKOjQ9eFqRGc\n6xxUdC6m3DqIUu0oRyV0lwzcUZRdTAOXSloQ5wF4SQixAwCEEDuEEBkhRBbALwDM050khLhDCNEu\nhGhva2sro7hM0XDsNS1JxnMDzcG+NJ5clZsA/OO17fj502sBeJT7LoJYpcxisoi4TTGPvUwlqeS+\n0pdDcS8R0TghxDbz7XsBrKyIVEzJsWIQDg3RUp/A3u6U9f6eJbnQ1NX3LLNelyqLyVgHUfBltOR7\n3VoIUjMDl4ooCCJqBnA2gKuV5luIaA6M8WOD4xgzABGwz/wbknEAKY/eKqWqxURFulLxYAuCqSQV\nURBCiC4AoxxtH6mELEz5yVVztVsQyXjM8Z6Qyrh9MqVaSU1EJcvp/9mH5+LOf69Ha0t9NJlKIw7D\nhKKSLiZmkOOMUSfM0TkeI0xrbcaanZ3a8/RJTEVYKBcr3Yx97pQRmDslemIeB4CZSlLpNFdmEJMV\n9mVjCTNIXRePWcpCh7bcd7GymKpszl5d0jCDDVYQTNnxWiiXiBlfx2ScUJfw/mqWatDkhXIMY4cV\nBFN2pGtJCGEb7GWaa10iyIJwt0XdZ8HrutU2HrOLiakkrCCYiuGMQcRjOReTM2Ctot0PouoXyjFM\n7cEKgqkYziwmy8WU8FcQOooxrMe5LCnD2OAsJqbsyNC0KwZhupiS8ZhtVbWTUi2UmzluiGtvbIYZ\nzLCCYCqGy4IwrYa6eMx6rUObxVQEeRaePr0IVxm8fOyUqZUWgSkyrCCYsqMGqVWSpovHcDH5WBC6\nNvYOVZQNN19QaRGYEsAxCKZieAWpkzHyjUGUysXEMIwdVhBM2fFaByGVQiJOVsBaR7UtZmOYgQor\nCKZiuGMQuSB1XSJakJphmOLDCoLJi33d/eg42FfQNbzSXOOxAAuCFQTDlAUOUjN5MecbiwDkGZy0\ngtT2ZqtYH5FlTehgFxPDlAe2IJiyk1sHoXcxxWOEuohBaoZhig8rCKZiOC0IGaSOx4IsCIZhygEr\nCKak9PRnkM5kbW1SMfRnsuhN5Y7Flf0g/NJc65Px4gvKMIyLiikIItpARK8S0XIiWmq2jSSiRUS0\n2vwbfYcVpqqYeeOjtv2kVW7406tYteOg9V51MfkpiAalFPhRE4YWSVKGYZxUOkj9DiHELuX99QAW\nCyFuJqLrzfdfqoxoTLFY/ObOUP2SMouJyLfct1qG43cfPxE7DxSWTcUwjJ5qczFdBOBu8/XdAN5T\nQVmYEuHeZdogrAWhMrQhiUNHtxRJMoZhVCqpIASAx4hoGREtNNvGCCG2ma+3AxhTGdGYUuKswSRJ\n2GIQHIpmmEpTSQVxqhDiOADnAbiWiE5XDwpjFHGNJES0kIiWEtHSjo6OMonKROGhV7Zi6vUPR15I\nJ11HsQgWBMMwpaNiv0IhxBbz704AfwYwD8AOIhoHAOZfl/NaCHGHEKJdCNHe1tZWTpGZkNz73EYA\nwJqdnZHOi5sLHBIx8i33zTBMeajIr5CImoloiHwN4J0AVgJ4CMAVZrcrAPy1EvIxhaFbCJdRKvN5\nxSDkArgYsYuJYaqBSmUxjQHwZ7NEcwLA74QQjxLRiwAeIKKrAGwE8IEKyccUAVUp7O9JYWRznW9/\nqU8S7GJimKqgIgpCCLEOwGxN+24AC8ovEVNM5ECfUSyIvd39loLwiFFb/Y1ifWxBMEyl4WkaU3Tk\n+K9mK/Wmgvd6lhZHLEa8WpphqgBWEExBeKWsAoBaYSOd8e6X62/0ScQI9Qn+ajJMpeFfIVMQzl3h\ngJzSSCkaIq3r6MCyIIjQwBYEw1QcVhBMKNZ1dOI/717qchWls1lXX6kK+tK5vs6CfTqySgyCLQiG\nqTz8K2RC8ZU/r8Tjb+zASxv32to1+sEKQvcplVozESwIVhAMUx0M+l9hXzqDL/7xFWzb31NpUaqa\nzr40AKC53p745m9B5I6lIioILxdTnLObGKZsVLqaa8V54s2deGDpZhzsTeP2D8+ttDhVi1QQzgFa\nZ0FIEyKqiykdIkhdbQrimxcdidaW+kqLwTAlYdArCDlu+STjMAAO9hoKIuUY6HUWhER1McnBP+tj\nSYQJUlfb+oiPnDS10iIwTMkY9C4mGRiNDfpPwp/OvhQAdyzh/hc3Ycm63bY2nYtJprk696FWCQpS\nXzh7PH595fGRZWcYJj8GvQVhKQiqrplptSG3Bk051jN89x+rAAAbbr7AalO3FJVIS8MvFKHGIHTF\n+n50+bHRBWcYJm8G/bxZzmxZQYTDz6XkRE2JDWNBqAqCYZjKM+gVRLc5iKlj0oHeFG5/ci360+EH\nw8FCOiN84whArpqrGoPYuLsLDy7bHE5BsLJmmKpg0LuYus3sHNWCuOquF/Hihr04ZuIwnHJoa6VE\nq0pSmSwee327rW3csAbbe52L6Uf/XAMAOGum9yaBGSsexAqCYaoBtiD6TTeIMia9uMFYDLa3u78C\nElUfar2ldFbgmntfsh0f1aIv462muUp6fIr2qbWYGIapPKwg+g0LQmbcPLxim3VsT9fAVhC9qQz+\nunyLb8E9wB6Ydqa5AvaifIB+JbVEZkPpUKu5MgxTeQa9gugyLYi+VAarth/Etb/LzY53dforiMde\n246e/uAy1tXKrf9Yhc/evxz/Wr3Lt58tG0lTlbXPYRXo0lwlcj2FDivNlWMQDFMVDHoFIQf43lQW\nB3rts9vdnX2e5726eT8W3rMMN/3ttYJleH3rAWza013wdaKy7UAvgGBXmhqs1w36ujaj3a085Yps\nHZzFxDDVRdkVBBFNIqIniOh1InqNiD5rtn+diLYQ0XLz3/nlkKfLHLB6UhnX7Hi3jwUhlcmG3V0F\ny3D+j/6F0255ouDrREXO1Pd1p7B80z7PfqpbqUszwDsrvAqr1IbGxeRhQRw5fijeM2cCAOCoCUMD\nJGcYphxUIospDeDzQoiXiGgIgGVEtMg8dpsQ4tZyCtNtWRAZl3/dLwYhvSC1XKJDTtS/9pBhBa37\n9vla/79qQXT1uwd4pyKQriJdDELnYvr4adPwlQtmAbAvuJs1bijWdnR6WigMw5SWsisIIcQ2ANvM\n1weJ6A0AE8oth0QGqXtSGeu1ZLvpgvGjVvXDgd4U1u+2u7V6UhlXtVbArgB0FoR0JW3a0436ZMyy\nxHQupoOO8++5ah5O9UglfvgzpwIApt3wiN+jMAxTIioagyCiqQCOBfC82fQpIlpBRHcS0QiPcxYS\n0VIiWtrR0VGwDN1WkDqLzr7cgDZ6SD227OvRLpbbsKsLB3rMeEWNaohLf74ErzjcSjrrAHC4mDRB\n+VRGIJMVOO2WJzDvW4uRMldbh3ExtdQnQB5BaSLyPMYwTOmpmIIgohYADwK4TghxAMDtAKYDmAPD\nwvie7jwhxB1CiHYhRHtbW1vBcnR5WBBHjBuKTFZg0177LDuVyWL+rU9aawFEDWiIVCaLjY5YyRvb\nDrj6dffpM7JUJdntEWS2l/b2iUE40lyHNIQzYg8d3RKqH8MwxaMiCoKIkjCUw2+FEH8CACHEDiFE\nRgiRBfALAPPKIYvMYurpz9gybGaOHQIAWN9hH1hX7+i0vc8nBrFpT7e1P0JQ2QoA6DjY53J/ReHr\nD72GM777JPYGrOvo9kjZVS2ITg8l0qvEG+S6CWf6q3G+04JI+soEACtvOgd///Spgf0Yhikulchi\nIgC/AvCGEOL7Svs4pdRHevsAABBlSURBVNt7AawstSwdB/uwr9uY0fakMrYA6hHjTAWxy64gVm7Z\nb3sfVT+8teMgTrvlCfz6mQ0A7GsMvDj+W4/jg794PrCfF0+9Zbji/NYgAPBUQjYLwqOPzYLwcTE5\nZWgJYUG01Cc894dgGKZ0VCKL6RQAHwHwKhEtN9u+DOByIpoDY8zdAODqUgrR1ZfG8d96HADQXBdH\nV38Guw7m1j2MGdKAEU1JrNvVhY27uzCsMYnhTXV43eGaCVqF7GTR6zsAAOtMxaPL9JHs6uxDixk0\nVtNQ93T1Y2SzvryFjlxtJP9Ffbr4AgD0BaS5Ao7NgUwLIm1tAJQr8+20IJp44GeYqqUSWUz/hq3y\nkUVZU1WeWZNbPdw2pB5du7uxQ1EQdYkYprU245FXt+G+F97G+GENePaGBdi81753dVQL4uW3jTpP\nI5uTONCbQq8m0wcAHl25Ddf+7mXc6dgg59m1u/DBXzyPX3/seLzj8NGR7u3lQpL0aKyD3lTGFpvw\nUiLqwO+0ihqSceveTguCy2owTPUyaFdSq+UlRg8xqpHuVNJa6xNxTGttwX4zW2nrfuPY1n12BeEX\nQnAuIDPON67z3NrdOPYbi2yWgWqNPPzqdmSyAg8u2wwgt+5ixWbDxfXvgPIYKvK6XR7xA8mBnrQr\nNXXWjY/ayo94WRDycwLc9ZrU3eG8FsoxDFN9DFoFsWZnLtjcNsTYdP7N7QettvpkDIe0NdvOSWey\n2LrfYUF4uJhWbtmPI/77USx+Y4etz86DhoJ46e19yGQFnn4rl6org7upTBZPrdoJAHjola0AgGGN\nRjA3ae60plM+Xsi7BwW6v/jgCsz95uO2NqcC9FIQ2/fnlGsyFkOdsiNcfSLnRnKWM2EYpnoZtApC\nDT5LBaFSn4hhphmolmzb32sFtSXS9y6EsCmCp1cbA/9Vdy/FLea2nOlMFrsdmUTLNu61Xkt307KN\ne3HAMdOW6aAHe3NB9bBIsYJcTIDhKtpspvbqMqycLqaW+gSSccLjb+yw2iaMaMS01pxyrU/mvmbb\n9gcvPmQYpjoYlAqiqy9tWyWtVxBxHDVhmK1Nrh0YpQSI5aD+kyfWYNoNj2Dq9Q/j5bf3YosSq/jZ\nU2sBGNVhnQbHqh05q0VaBU+/1YFEjPC3T52KB64+CYe0NluZRLL8x84D3oUEncjSF2FTZZ9+y3Bf\n7XEU8Wuqi1sF9STDm5KYN20kHn0tt4lQQzKORDwXW1BdTAzD1A6D8pfrLLDnZUHI2IRE+v9njc8V\nk5OD+q2PvWW1LXp9B1ZuzWU7CQFMvf5hnPidxa77qApDWiNv7ejEIW3NOHriMMybNhLzDx9txQ9k\nAUFnLMSLz/1+OXaawfegGIRELqpzKqGmOnfGUTIewxFjh9qeoyEZs236k4wPyq8Zw9Q8g/KXO6q5\nHtefd4SVKjq0wb1YS7pF/vzJk3HLJccAyKWaqpZFT38G3/jb67Zze1IZ7UplyWHmqmBnAo+xPmI9\n1u/qxCGtuZXDLfVxdPWnIYTALrME+ZZ9PZZL61+rOzD1+odtQXbJn17eYpMriAnDG7HZVD47Dtqv\n11TnTnqbOqoJ44c32toaEvFApfDXa0/BE/81P1AeBvj7p0/F4s+fUWkxmEHIoFQQY4c14JozpuPk\n6aMA5ALAADBlVBMAWEHWYyePwJxJwwEYCqK1pc62B3NPKmNLmQWAXz+zAf3pLD5/9gwc7XBT3XDe\nEZg3bSQA4LjJ7nJTN/3tdby9pxvTlAB5U30CQgAPvrQFz6/fA8BYhDbthkfQ1ZfGb57bCACY9+3F\neHHDHs/nlgFmXWxh8sgmPP65MzBlVJNlnTgVjtOCOO+osfjBZcdigkNB1CdjOO/o3LpHXabX7EnD\nbXEKxpujJgzD9DYuNcKUn0GpICTfufho3Pr+2daADQC/X3gSfvbhuUgoM2CpQDr70pjW2mwtXgOM\nzKNVOw7iXceoC8ENzj9mHD5w/CTr/e0fOg5XnzHdKu+x8PRDMKLJbb2kMsI2eMoKq38zM5quO+sw\n69jqnZ02BXfH0+tw419X4gt/eMVVWsMqTKhZ4Xzk+KE4dHQLxg9vtBTEG9sO2vrUOWIJZ80cg2GN\nSZeCaEjE8eETJ3uexzBMbTCof7lDGpK4ZO5E2w5mY4c14Nyjxtr6qQPwhbPH4xRNeerjp460vf/q\nBTNxSGszFhyRW8wmZ9X/7+wZ+N/3HY2zZ41xBcIBIzNIXQTXUm/M3J9fvxvzD2/D2bPGWMfe85Nn\nbFbDv1Z34DfPbcSfX97i2gTormc3YMXmffjM/S8DAE46ZBS+a7rPpEtowvBG7DjQhzO++wQeWLrJ\ndn7C4ROTA/+EEQ4FkYzZUlu/cv5MfHL+dOv9b/6jLGW2GIYpkEqU2qhKfnT5sVaBPicNyTi+9u5Z\n6Etncfm8yUjEY7jrY8cjRoRb/vEmVm45YJvx3/6h4yxlMH54I+68sh118dyAOWlkEy4dacywj5ow\nzLUn9HVnHWYLnDebvv/eVBZHTxjmmrFv3N2NhmQMwxvrsP1Ar1U65GN3vQgA+MI5h+O7Zqrte3/6\nrJWJdMEx43DJ3Ino6kvjQnM3t0vmTsSB3hQeWr4V3f0ZzJk03FI0UomcNXMMTpg2Euebz+gs+zGq\nxZD98c+djhWb92PetJGYN20kfvqkkc11+ozCq/AyDFN6KGotoWqivb1dLF26tKIy7Onqx13PbsC1\n75iOx1/fiXHDG7SxBS+27uvB/63cjtkTh+H59XsghMDVZ0y3BXn396Rw26K3kMpkcfXp0zF5VBPu\nfnaDtRMcAHzkxCm4fN5k/Pb5jbj0+Em4/8VN+N3zbyMRI6z59vl45NVtWL+rC5v3duP/Vm7Hvu4U\nrjvrMFx31gytXC+9vRcPLtuMD584BX9+eQumjGrCtn29+PETa3DtO6bjC+ccYeu/aU83HnplK7JZ\ngatOm6YNaP/tla2YMqoJx0wcHvrzYRim+BDRMiFEe2A/VhC1y8MrtlllMO762PGY76jNdO+SjTik\nrRknT7e7xPrSGfzkn2tw5SnTIhX9601l8P/9czU+cuJUjB3WEHwCwzBVCSuIQcIL6/fgpbf34poz\npgd3ZhiGQXgFwTGIGkf69xmGYYrNoM5iYhiGYbxhBcEwDMNoqToFQUTnEtEqIlpDRNdXWh6GYZjB\nSlUpCCKKA/gJgPMAzIKxDemsykrFMAwzOKkqBQFgHoA1Qoh1Qoh+APcDuKjCMjEMwwxKqk1BTACg\n1nfYbLYxDMMwZabaFEQgRLSQiJYS0dKOjo7gExiGYZi8qDYFsQXAJOX9RLPNQghxhxCiXQjR3tbG\nNX0YhmFKRVWtpCaiBIC3ACyAoRheBPBBIcRrHv07AGws4JatAHYF9hpY8DMPDviZBwf5PvMUIUTg\nDLuqVlILIdJE9CkA/wAQB3Cnl3Iw+xdkQhDR0jDLzQcS/MyDA37mwUGpn7mqFAQACCEeAfBIpeVg\nGIYZ7FRbDIJhGIapEga7grij0gJUAH7mwQE/8+CgpM9cVUFqhmEYpnoY7BYEwzAM48GgVBADtSAg\nEd1JRDuJaKXSNpKIFhHRavPvCLOdiOhH5mewgoiOq5zk+UNEk4joCSJ6nYheI6LPmu0D9rmJqIGI\nXiCiV8xnvslsn0ZEz5vP9nsiqjPb6833a8zjUyspfyEQUZyIXiaiv5vvB/QzE9EGInqViJYT0VKz\nrWzf7UGnIAZ4QcC7AJzraLsewGIhxGEAFpvvAeP5DzP/LQRwe5lkLDZpAJ8XQswCcCKAa83/z4H8\n3H0AzhRCzAYwB8C5RHQigP8FcJsQ4lAAewFcZfa/CsBes/02s1+t8lkAbyjvB8Mzv0MIMUdJZy3f\nd1sIMaj+ATgJwD+U9zcAuKHSchXx+aYCWKm8XwVgnPl6HIBV5uufA7hc16+W/wH4K4CzB8tzA2gC\n8BKAE2AsmEqY7db3HMa6opPM1wmzH1Va9jyedaI5IJ4J4O8AaBA88wYArY62sn23B50FgcFXEHCM\nEGKb+Xo7gDHm6wH3OZhuhGMBPI8B/tymq2U5gJ0AFgFYC2CfECJtdlGfy3pm8/h+AKPKK3FR+AGA\nLwLImu9HYeA/swDwGBEtI6KFZlvZvttVt1COKR1CCEFEAzJtjYhaADwI4DohxAEiso4NxOcWQmQA\nzCGi4QD+DOCICotUUojoXQB2CiGWEdH8SstTRk4VQmwhotEAFhHRm+rBUn+3B6MFEVgQcICxg4jG\nAYD5d6fZPmA+ByJKwlAOvxVC/MlsHvDPDQBCiH0AnoDhXhlu1jMD7M9lPbN5fBiA3WUWtVBOAXAh\nEW2AsU/MmQB+iIH9zBBCbDH/7oQxEZiHMn63B6OCeBHAYWb2Qx2AywA8VGGZSslDAK4wX18Bw0cv\n2z9qZj6cCGC/YrbWDGSYCr8C8IYQ4vvKoQH73ETUZloOIKJGGDGXN2AoikvMbs5nlp/FJQD+KUwn\nda0ghLhBCDFRCDEVxm/2n0KID2EAPzMRNRPREPkawDsBrEQ5v9uVDsJUKPBzPoyqsWsBfKXS8hTx\nue4DsA1ACob/8SoYftfFAFYDeBzASLMvwcjmWgvgVQDtlZY/z2c+FYafdgWA5ea/8wfycwM4BsDL\n5jOvBHCj2X4IgBcArAHwBwD1ZnuD+X6NefyQSj9Dgc8/H8DfB/ozm8/2ivnvNTlWlfO7zSupGYZh\nGC2D0cXEMAzDhIAVBMMwDKOFFQTDMAyjhRUEwzAMo4UVBMMwDKOFFQQzKCGijFkhU/7zrepLRNcQ\n0UeLcN8NRNSax3nnENFNZiXP/ytUDoYJA5faYAYrPUKIOWE7CyF+VkphQnAajEVhpwH4d4VlYQYJ\nbEEwjII5w7/FrMH/AhEdarZ/nYj+y3z9GTL2n1hBRPebbSOJ6C9m2xIiOsZsH0VEj5Gxb8MvYSxm\nkvf6sHmP5UT0c7MUvVOeS82ifJ+BUazuFwA+RkQDefU/UyWwgmAGK40OF9OlyrH9QoijAfwYxqDs\n5HoAxwohjgFwjdl2E4CXzbYvA/iN2f41AP8WQhwJo5bOZAAgopkALgVwimnJZAB8yHkjIcTvYVSo\nXWnK9Kp57wsLeXiGCQO7mJjBip+L6T7l722a4ysA/JaI/gLgL2bbqQDeBwBCiH+alsNQAKcDuNhs\nf5iI9pr9FwCYC+BFs/JsI3JF15zMALDOfN0shDgY4vkYpmBYQTCMG+HxWnIBjIH/3QC+QkRH53EP\nAnC3EOIG307GNpOtABJE9DqAcabL6dNCiH/lcV+GCQ27mBjGzaXK3+fUA0QUAzBJCPEEgC/BKCPd\nAuBfMF1E5n4Fu4QQBwA8DeCDZvt5AEaYl1oM4BKzzr+MYUxxCiKMbSYfBnARgFtgFGybw8qBKQds\nQTCDlUZzJi55VAghU11HENEKGHs/X+44Lw7gXiIaBsMK+JEQYh8RfR3AneZ53ciVY74JwH1E9BqA\nZwG8DQBCiNeJ6KswdguLwajAey2AjRpZj4MRpP4kgO9rjjNMSeBqrgyjYG5I0y6E2FVpWRim0rCL\niWEYhtHCFgTDMAyjhS0IhmEYRgsrCIZhGEYLKwiGYRhGCysIhmEYRgsrCIZhGEYLKwiGYRhGy/8P\nzuYSG0RwaDgAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BzE2ULTm9l3P",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "08od_i7tF6zU",
        "colab_type": "text"
      },
      "source": [
        "# *** Categorical Dueling Double DQN ***\n",
        "C51\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6M_I82IM5HCs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "N_ATOMS = 51\n",
        "VMIN = -10\n",
        "VMAX = 10\n",
        "DZ = (VMAX-VMIN) / (N_ATOMS -1)\n",
        "GAMMA = 0.99"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bxnj4tC1GQrY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "class Dueling_QNetwork(nn.Module):\n",
        "    \"\"\"Actor (Policy) Model.\"\"\"\n",
        "\n",
        "    def __init__(self, state_size, action_size, seed, fc1_units=64, fc2_units=64):\n",
        "        \"\"\"Initialize parameters and build model.\n",
        "        Params\n",
        "        ======\n",
        "            state_size (int): Dimension of each state\n",
        "            action_size (int): Dimension of each action\n",
        "            seed (int): Random seed\n",
        "            fc1_units (int): Number of nodes in first hidden layer\n",
        "            fc2_units (int): Number of nodes in second hidden layer\n",
        "        \"\"\"\n",
        "        super(Dueling_QNetwork, self).__init__()\n",
        "        self.action_size = action_size\n",
        "        self.seed = torch.manual_seed(seed)\n",
        "        self.network = nn.Sequential(nn.Linear(state_size,fc1_units),\n",
        "                                     nn.ReLU(),\n",
        "                                     nn.Linear(fc1_units,fc2_units),\n",
        "                                     nn.ReLU())\n",
        "        self.advantage = nn.Sequential(nn.Linear(fc2_units,action_size*N_ATOMS))\n",
        "        self.value = nn.Sequential(nn.Linear(fc2_units,N_ATOMS))\n",
        "        self.register_buffer(\"supports\", torch.arange(VMIN, VMAX+DZ, DZ)) # basic value vector - shape n_atoms stepsize dz\n",
        "        self.softmax = nn.Softmax(dim = 1)\n",
        "\n",
        "    def forward(self, state):\n",
        "        batch_size = state.size()[0]\n",
        "        x = self.network(state)\n",
        "        value = self.value(x).view(batch_size,1,N_ATOMS)\n",
        "        advantage = self.advantage(x).view(batch_size,-1, N_ATOMS)\n",
        "        \n",
        "        q_distr = value + advantage - advantage.mean(dim = 1, keepdim = True)\n",
        "        prob = F.softmax(q_distr.view(-1, N_ATOMS)).view(-1, self.action_size, N_ATOMS)\n",
        "        return prob\n",
        "      \n",
        "    def act(self,state):\n",
        "      prob = self.forward(state).data.cpu()\n",
        "      expected_value = prob * self.supports\n",
        "      actions = expected_value.sum(2)\n",
        "      return actions\n",
        "      \n",
        "class Agent():\n",
        "    \"\"\"Interacts with and learns from the environment.\"\"\"\n",
        "\n",
        "    def __init__(self, state_size, action_size, seed):\n",
        "        \"\"\"Initialize an Agent object.\n",
        "        \n",
        "        Params\n",
        "        ======\n",
        "            state_size (int): dimension of each state\n",
        "            action_size (int): dimension of each action\n",
        "            seed (int): random seed\n",
        "        \"\"\"\n",
        "        self.state_size = state_size\n",
        "        self.action_size = action_size\n",
        "        self.seed = random.seed(seed)\n",
        "        \n",
        "\t    # Q-Network\n",
        "        \n",
        "        self.qnetwork_local = Dueling_QNetwork(state_size, action_size, seed).to(device)\n",
        "        self.qnetwork_target = Dueling_QNetwork(state_size, action_size, seed).to(device)\n",
        "\n",
        "        self.optimizer = optim.Adam(self.qnetwork_local.parameters(), lr=LR)\n",
        "\n",
        "        # Replay memory\n",
        "        self.memory = ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE, seed)\n",
        "        # Initialize time step (for updating every UPDATE_EVERY steps)\n",
        "        self.t_step = 0\n",
        "        \n",
        "        \n",
        "       \n",
        "      \n",
        "\n",
        "    def projection_distribution(self, next_distr, next_state, rewards, dones, gamma):\n",
        "        batch_size  = next_state.size(0)\n",
        "\n",
        "        delta_z = float(VMAX - VMIN) / (N_ATOMS - 1)\n",
        "        support = torch.linspace(VMIN, VMAX, N_ATOMS)\n",
        "        rewards = rewards.expand_as(next_distr)\n",
        "        dones   = dones.expand_as(next_distr)\n",
        "        support = support.unsqueeze(0).expand_as(next_distr)\n",
        "        ## Compute the projection of T̂ z onto the support {z_i}\n",
        "        Tz = rewards + (1 - dones) * gamma * support\n",
        "        Tz = Tz.clamp(min=VMIN, max=VMAX)\n",
        "        b  = (Tz - VMIN) / delta_z\n",
        "        l  = b.floor().long()\n",
        "        u  = b.ceil().long()\n",
        "\n",
        "        offset = torch.linspace(0, (batch_size - 1) * N_ATOMS, batch_size).long()\\\n",
        "                        .unsqueeze(1).expand(batch_size, N_ATOMS)\n",
        "        # Distribute probability of T̂ z\n",
        "        proj_dist = torch.zeros(next_distr.size())    \n",
        "        proj_dist.view(-1).index_add_(0, (l + offset).view(-1), (next_distr * (u.float() - b)).view(-1))\n",
        "        proj_dist.view(-1).index_add_(0, (u + offset).view(-1), (next_distr * (b - l.float())).view(-1))\n",
        "\n",
        "        return proj_dist\n",
        "  \n",
        "  \n",
        "  \n",
        "  \n",
        "    \n",
        "    def step(self, state, action, reward, next_state, done):\n",
        "        # Save experience in replay memory\n",
        "        self.memory.add(state, action, reward, next_state, done)\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 available 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",
        "        \"\"\"Returns 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 = self.qnetwork_local.act(state)\n",
        "\n",
        "        self.qnetwork_local.train()\n",
        "\n",
        "        # Epsilon-greedy action selection\n",
        "        if random.random() > eps:\n",
        "            return np.argmax(action.cpu().data.numpy())\n",
        "        else:\n",
        "            return random.choice(np.arange(self.action_size))\n",
        "\n",
        "    def learn(self, experiences, gamma):\n",
        "        \"\"\"Update value parameters using given batch of experience tuples.\n",
        "        Params\n",
        "        ======\n",
        "            experiences (Tuple[torch.Tensor]): tuple of (s, a, r, s', done) tuples \n",
        "            gamma (float): discount factor\n",
        "        \"\"\"\n",
        "        states, actions, rewards, next_states, dones = experiences\n",
        "        batch_size = len(states)\n",
        "\n",
        "        # next_state distribution\n",
        "        next_distr = self.qnetwork_target(next_states)\n",
        "        next_actions = self.qnetwork_target.act(next_states)\n",
        "        #chose max action indx\n",
        "        next_actions = next_actions.max(1)[1].data.cpu().numpy()\n",
        "        # gather best \n",
        "        next_best_distr = next_distr[range(batch_size), next_actions]\n",
        "\n",
        "        proj_distr = self.projection_distribution(next_best_distr, next_states, rewards, dones, GAMMA)\n",
        "\n",
        "        # Compute loss\n",
        "        # calculates the prob_distribution for the actions based on the given state\n",
        "        prob_distr = self.qnetwork_local(states)\n",
        "        actions = actions.unsqueeze(1).expand(batch_size, 1, N_ATOMS)\n",
        "        # gathers the the prob_distribution for the chosen action\n",
        "        state_action_prob = prob_distr.gather(1, actions).squeeze(1)\n",
        "        loss = -(state_action_prob.log() * proj_distr.detach()).sum(dim=1).mean()\n",
        "       \n",
        "        # Minimize the loss\n",
        "        self.optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        self.optimizer.step()\n",
        "\n",
        "        # ------------------- update target network ------------------- #\n",
        "        self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)                     \n",
        "\n",
        "    def soft_update(self, local_model, target_model, tau):\n",
        "        \"\"\"Soft update model parameters.\n",
        "        θ_target = τ*θ_local + (1 - τ)*θ_target\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",
        "class ReplayBuffer:\n",
        "    \"\"\"Fixed-size buffer to store experience tuples.\"\"\"\n",
        "\n",
        "    def __init__(self, action_size, buffer_size, batch_size, seed):\n",
        "        \"\"\"Initialize a ReplayBuffer object.\n",
        "        Params\n",
        "        ======\n",
        "            action_size (int): dimension of each action\n",
        "            buffer_size (int): maximum size of buffer\n",
        "            batch_size (int): size of each training batch\n",
        "            seed (int): random seed\n",
        "        \"\"\"\n",
        "        self.action_size = action_size\n",
        "        self.memory = deque(maxlen=buffer_size)  \n",
        "        self.batch_size = batch_size\n",
        "        self.experience = namedtuple(\"Experience\", field_names=[\"state\", \"action\", \"reward\", \"next_state\", \"done\"])\n",
        "        self.seed = random.seed(seed)\n",
        "    \n",
        "    def add(self, state, action, reward, next_state, done):\n",
        "        \"\"\"Add a new experience to memory.\"\"\"\n",
        "        e = self.experience(state, action, reward, next_state, done)\n",
        "        self.memory.append(e)\n",
        "    \n",
        "    def sample(self):\n",
        "        \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n",
        "        experiences = random.sample(self.memory, k=self.batch_size)\n",
        "\n",
        "        states = torch.from_numpy(np.vstack([e.state for e in experiences if e is not None])).float().to(device)\n",
        "        actions = torch.from_numpy(np.vstack([e.action for e in experiences if e is not None])).long().to(device)\n",
        "        rewards = torch.from_numpy(np.vstack([e.reward for e in experiences if e is not None])).float().to(device)\n",
        "        next_states = torch.from_numpy(np.vstack([e.next_state for e in experiences if e is not None])).float().to(device)\n",
        "        dones = torch.from_numpy(np.vstack([e.done for e in experiences if e is not None]).astype(np.uint8)).float().to(device)\n",
        "  \n",
        "        return (states, actions, rewards, next_states, dones)\n",
        "\n",
        "    def __len__(self):\n",
        "        \"\"\"Return the current size of internal memory.\"\"\"\n",
        "        return len(self.memory)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ownyruxACXgH",
        "colab_type": "code",
        "outputId": "829e0c04-5aab-4a41-aa35-43f0cf7a0130",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 402
        }
      },
      "source": [
        "def dqn(n_episodes=1, max_t=1000, eps_start=1.0, eps_end=0.01, eps_decay=0.99):\n",
        "    \"\"\"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",
        "    scores = []                        # list containing scores from each episode\n",
        "    scores_window = deque(maxlen=100)  # last 100 scores\n",
        "    eps = eps_start                    # initialize epsilon\n",
        "    for i_episode in range(1, n_episodes+1):\n",
        "        state = env.reset()\n",
        "        score = 0\n",
        "        for t in range(max_t):\n",
        "            action = agent.act(state, eps)\n",
        "\n",
        "            next_state, reward, done, _ = env.step(action)\n",
        "            agent.step(state, action, reward, next_state, done)\n",
        "            state = next_state\n",
        "            score += reward\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",
        "        print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)), end=\"\")\n",
        "        if i_episode % 100 == 0:\n",
        "            print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\n",
        "        if np.mean(scores_window)>=200.0:\n",
        "            print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode-100, np.mean(scores_window)))\n",
        "            torch.save(agent.qnetwork_local.state_dict(), 'checkpoint.pth')\n",
        "            break\n",
        "    return scores\n",
        "\n",
        "\n",
        "env = gym.make(\"CartPole-v0\") # CartPole-v0\n",
        "action_size = env.action_space.n\n",
        "state_size = env.observation_space.shape[0]\n",
        "\n",
        "agent = Agent(state_size=state_size, action_size=action_size, seed=0)\n",
        "scores = dqn(n_episodes = 600)\n",
        "\n",
        "# plot the scores\n",
        "fig = plt.figure()\n",
        "ax = fig.add_subplot(111)\n",
        "plt.plot(np.arange(len(scores)), scores)\n",
        "plt.ylabel('Score')\n",
        "plt.xlabel('Episode #')\n",
        "plt.show()\n"
      ],
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:34: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Episode 100\tAverage Score: 15.55\n",
            "Episode 200\tAverage Score: 11.29\n",
            "Episode 300\tAverage Score: 10.89\n",
            "Episode 400\tAverage Score: 21.02\n",
            "Episode 500\tAverage Score: 114.03\n",
            "Episode 600\tAverage Score: 190.66\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEKCAYAAAAIO8L1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIAiCEREQgiAIgpH/D1NSaeM+sfKgAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lHKJVAekTACk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}