Playing_Pong_with_DQN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Re86M-UQgoHn",
    "outputId": "6f3c39e5-30b5-44a8-ba22-04500cd5c61f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2021-04-29 17:51:11--  https://raw.githubusercontent.com/StefOe/colab-pytorch-utils/master/utils.py\n",
      "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.111.133, 185.199.109.133, 185.199.110.133, ...\n",
      "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.111.133|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 4519 (4.4K) [text/plain]\n",
      "Saving to: ‘utils.py.6’\n",
      "\n",
      "utils.py.6          100%[===================>]   4.41K  --.-KB/s    in 0s      \n",
      "\n",
      "2021-04-29 17:51:11 (79.5 MB/s) - ‘utils.py.6’ saved [4519/4519]\n",
      "\n",
      "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (4.41.1)\n",
      "Requirement already satisfied: torch in /usr/local/lib/python3.7/dist-packages (1.8.1+cu101)\n",
      "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torch) (1.19.5)\n",
      "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch) (3.7.4.3)\n",
      "Requirement already satisfied: gym in /usr/local/lib/python3.7/dist-packages (0.17.3)\n",
      "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from gym) (1.4.1)\n",
      "Requirement already satisfied: cloudpickle<1.7.0,>=1.2.0 in /usr/local/lib/python3.7/dist-packages (from gym) (1.3.0)\n",
      "Requirement already satisfied: pyglet<=1.5.0,>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from gym) (1.5.0)\n",
      "Requirement already satisfied: numpy>=1.10.4 in /usr/local/lib/python3.7/dist-packages (from gym) (1.19.5)\n",
      "Requirement already satisfied: future in /usr/local/lib/python3.7/dist-packages (from pyglet<=1.5.0,>=1.4.0->gym) (0.16.0)\n",
      "Requirement already satisfied: opencv-python in /usr/local/lib/python3.7/dist-packages (4.1.2.30)\n",
      "Requirement already satisfied: numpy>=1.14.5 in /usr/local/lib/python3.7/dist-packages (from opencv-python) (1.19.5)\n",
      "Requirement already satisfied: onnx in /usr/local/lib/python3.7/dist-packages (1.9.0)\n",
      "Requirement already satisfied: onnxruntime in /usr/local/lib/python3.7/dist-packages (1.7.0)\n",
      "Requirement already satisfied: numpy>=1.16.6 in /usr/local/lib/python3.7/dist-packages (from onnx) (1.19.5)\n",
      "Requirement already satisfied: protobuf in /usr/local/lib/python3.7/dist-packages (from onnx) (3.12.4)\n",
      "Requirement already satisfied: typing-extensions>=3.6.2.1 in /usr/local/lib/python3.7/dist-packages (from onnx) (3.7.4.3)\n",
      "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from onnx) (1.15.0)\n",
      "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from protobuf->onnx) (56.0.0)\n",
      "Requirement already satisfied: pyvirtualdisplay in /usr/local/lib/python3.7/dist-packages (2.1)\n",
      "Requirement already satisfied: EasyProcess in /usr/local/lib/python3.7/dist-packages (from pyvirtualdisplay) (0.3)\n",
      "\u001b[31mERROR: Could not find a version that satisfies the requirement xdpyinfo (from versions: none)\u001b[0m\n",
      "\u001b[31mERROR: No matching distribution found for xdpyinfo\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!wget https://raw.githubusercontent.com/StefOe/colab-pytorch-utils/master/utils.py\n",
    "import utils\n",
    "! pip install torch\n",
    "! pip install gym\n",
    "! pip install opencv-python\n",
    "!pip install onnx onnxruntime\n",
    "!pip install pyvirtualdisplay\n",
    "!apt-get install -y xvfb python-opengl ffmpeg > /dev/null 2>&1\n",
    "!pip install xdpyinfo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "qMnj8uofocDr",
    "outputId": "4f48179f-774d-4cf3-a8a5-dc8f9cf44212"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nvcc: NVIDIA (R) Cuda compiler driver\n",
      "Copyright (c) 2005-2020 NVIDIA Corporation\n",
      "Built on Wed_Jul_22_19:09:09_PDT_2020\n",
      "Cuda compilation tools, release 11.0, V11.0.221\n",
      "Build cuda_11.0_bu.TC445_37.28845127_0\n"
     ]
    }
   ],
   "source": [
    "import time \n",
    "import numpy as np\n",
    "from collections import deque, namedtuple\n",
    "import collections\n",
    "import os\n",
    "import time\n",
    "import shutil\n",
    "import random\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "import cv2\n",
    "import gym\n",
    "import gym.spaces\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import copy\n",
    "%matplotlib inline\n",
    "!nvcc --version\n",
    "\n",
    "from matplotlib import animation\n",
    "import seaborn as sns; sns.set()\n",
    "from IPython.display import clear_output, HTML\n",
    "from IPython import display\n",
    "import torch.onnx\n",
    "\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "WZSuAKQ1Wq0s",
    "outputId": "b5bb9aaa-2339-41d0-91e0-666bbff4b0d4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Drive already mounted at drive; to attempt to forcibly remount, call drive.mount(\"drive\", force_remount=True).\n",
      "/content/drive/MyDrive/DQN\n"
     ]
    }
   ],
   "source": [
    "from google.colab import drive\n",
    "drive.mount(\"drive\")\n",
    "%cd drive/MyDrive/DQN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "qJyGPhRfQWrV",
    "outputId": "074258ad-1b40-4264-bef7-1d691df77bf6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "USE_CUDA = torch.cuda.is_available()\n",
    "Transition = namedtuple(\"Transition\", [\"state\", \"action\", \"reward\", \"next_state\", \"done\"])\n",
    "print(USE_CUDA)\n",
    "\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8fncR2vpJK_C"
   },
   "outputs": [],
   "source": [
    "# DO NOT MAKE CHANGES HERE\n",
    "from gym import spaces\n",
    "import cv2\n",
    "cv2.ocl.setUseOpenCL(False)\n",
    "\n",
    "class NoopResetEnv(gym.Wrapper):\n",
    "    def __init__(self, env, noop_max=30):\n",
    "        \"\"\"Sample initial states by taking random number of no-ops on reset.\n",
    "        No-op is assumed to be action 0.\n",
    "        \"\"\"\n",
    "        gym.Wrapper.__init__(self, env)\n",
    "        self.noop_max = noop_max\n",
    "        self.override_num_noops = None\n",
    "        self.noop_action = 0\n",
    "        assert env.unwrapped.get_action_meanings()[0] == 'NOOP'\n",
    "\n",
    "    def reset(self, **kwargs):\n",
    "        \"\"\" Do no-op action for a number of steps in [1, noop_max].\"\"\"\n",
    "        self.env.reset(**kwargs)\n",
    "        if self.override_num_noops is not None:\n",
    "            noops = self.override_num_noops\n",
    "        else:\n",
    "            noops = self.unwrapped.np_random.randint(1, self.noop_max + 1) #pylint: disable=E1101\n",
    "        assert noops > 0\n",
    "        obs = None\n",
    "        for _ in range(noops):\n",
    "            obs, _, done, _ = self.env.step(self.noop_action)\n",
    "            if done:\n",
    "                obs = self.env.reset(**kwargs)\n",
    "        return obs\n",
    "\n",
    "    def step(self, ac):\n",
    "        return self.env.step(ac)\n",
    "\n",
    "class FireResetEnv(gym.Wrapper):\n",
    "    def __init__(self, env):\n",
    "        \"\"\"Take action on reset for environments that are fixed until firing.\"\"\"\n",
    "        gym.Wrapper.__init__(self, env)\n",
    "        assert env.unwrapped.get_action_meanings()[1] == 'FIRE'\n",
    "        assert len(env.unwrapped.get_action_meanings()) >= 3\n",
    "\n",
    "    def reset(self, **kwargs):\n",
    "        self.env.reset(**kwargs)\n",
    "        obs, _, done, _ = self.env.step(1)\n",
    "        if done:\n",
    "            self.env.reset(**kwargs)\n",
    "        obs, _, done, _ = self.env.step(2)\n",
    "        if done:\n",
    "            self.env.reset(**kwargs)\n",
    "        return obs\n",
    "\n",
    "    def step(self, ac):\n",
    "        return self.env.step(ac)\n",
    "\n",
    "class EpisodicLifeEnv(gym.Wrapper):\n",
    "    def __init__(self, env):\n",
    "        \"\"\"Make end-of-life == end-of-episode, but only reset on true game over.\n",
    "        Done by DeepMind for the DQN and co. since it helps value estimation.\n",
    "        \"\"\"\n",
    "        gym.Wrapper.__init__(self, env)\n",
    "        self.lives = 0\n",
    "        self.was_real_done  = True\n",
    "\n",
    "    def step(self, action):\n",
    "        obs, reward, done, info = self.env.step(action)\n",
    "        self.was_real_done = done\n",
    "        # check current lives, make loss of life terminal,\n",
    "        # then update lives to handle bonus lives\n",
    "        lives = self.env.unwrapped.ale.lives()\n",
    "        if lives < self.lives and lives > 0:\n",
    "            # for Qbert sometimes we stay in lives == 0 condtion for a few frames\n",
    "            # so its important to keep lives > 0, so that we only reset once\n",
    "            # the environment advertises done.\n",
    "            done = True\n",
    "        self.lives = lives\n",
    "        return obs, reward, done, info\n",
    "\n",
    "    def reset(self, **kwargs):\n",
    "        \"\"\"Reset only when lives are exhausted.\n",
    "        This way all states are still reachable even though lives are episodic,\n",
    "        and the learner need not know about any of this behind-the-scenes.\n",
    "        \"\"\"\n",
    "        if self.was_real_done:\n",
    "            obs = self.env.reset(**kwargs)\n",
    "        else:\n",
    "            # no-op step to advance from terminal/lost life state\n",
    "            obs, _, _, _ = self.env.step(0)\n",
    "        self.lives = self.env.unwrapped.ale.lives()\n",
    "        return obs\n",
    "\n",
    "class MaxAndSkipEnv(gym.Wrapper):\n",
    "    def __init__(self, env, skip=4):\n",
    "        \"\"\"Return only every `skip`-th frame\"\"\"\n",
    "        gym.Wrapper.__init__(self, env)\n",
    "        # most recent raw observations (for max pooling across time steps)\n",
    "        self._obs_buffer = np.zeros((2,)+env.observation_space.shape, dtype=np.uint8)\n",
    "        self._skip       = skip\n",
    "\n",
    "    def reset(self):\n",
    "        return self.env.reset()\n",
    "\n",
    "    def step(self, action):\n",
    "        \"\"\"Repeat action, sum reward, and max over last observations.\"\"\"\n",
    "        total_reward = 0.0\n",
    "        done = None\n",
    "        for i in range(self._skip):\n",
    "            obs, reward, done, info = self.env.step(action)\n",
    "            if i == self._skip - 2: self._obs_buffer[0] = obs\n",
    "            if i == self._skip - 1: self._obs_buffer[1] = obs\n",
    "            total_reward += reward\n",
    "            if done:\n",
    "                break\n",
    "        # Note that the observation on the done=True frame\n",
    "        # doesn't matter\n",
    "        max_frame = self._obs_buffer.max(axis=0)\n",
    "\n",
    "        return max_frame, total_reward, done, info\n",
    "\n",
    "    def reset(self, **kwargs):\n",
    "        return self.env.reset(**kwargs)\n",
    "\n",
    "class ClipRewardEnv(gym.RewardWrapper):\n",
    "    def __init__(self, env):\n",
    "        gym.RewardWrapper.__init__(self, env)\n",
    "\n",
    "    def reward(self, reward):\n",
    "        \"\"\"Bin reward to {+1, 0, -1} by its sign.\"\"\"\n",
    "        return np.sign(reward)\n",
    "\n",
    "class WarpFrame(gym.ObservationWrapper):\n",
    "    def __init__(self, env):\n",
    "        \"\"\"Warp frames to 84x84 as done in the Nature paper and later work.\"\"\"\n",
    "        gym.ObservationWrapper.__init__(self, env)\n",
    "        self.width = 84\n",
    "        self.height = 84\n",
    "        self.observation_space = spaces.Box(low=0, high=255,\n",
    "            shape=(self.height, self.width, 1), dtype=np.uint8)\n",
    "\n",
    "    def observation(self, frame):\n",
    "        frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)\n",
    "        frame = cv2.resize(frame, (self.width, self.height), interpolation=cv2.INTER_AREA)\n",
    "        return frame[:, :, None]\n",
    "\n",
    "class FrameStack(gym.Wrapper):\n",
    "    def __init__(self, env, k):\n",
    "        \"\"\"Stack k last frames.\n",
    "        Returns lazy array, which is much more memory efficient.\n",
    "        See Also\n",
    "        --------\n",
    "        baselines.common.atari_wrappers.LazyFrames\n",
    "        \"\"\"\n",
    "        gym.Wrapper.__init__(self, env)\n",
    "        self.k = k\n",
    "        self.frames = deque([], maxlen=k)\n",
    "        shp = env.observation_space.shape\n",
    "        self.observation_space = spaces.Box(low=0, high=255, shape=(shp[0], shp[1], shp[2] * k), dtype=np.uint8)\n",
    "\n",
    "    def reset(self):\n",
    "        ob = self.env.reset()\n",
    "        for _ in range(self.k):\n",
    "            self.frames.append(ob)\n",
    "        return self._get_ob()\n",
    "\n",
    "    def step(self, action):\n",
    "        ob, reward, done, info = self.env.step(action)\n",
    "        self.frames.append(ob)\n",
    "        return self._get_ob(), reward, done, info\n",
    "\n",
    "    def _get_ob(self):\n",
    "        assert len(self.frames) == self.k\n",
    "        return LazyFrames(list(self.frames))\n",
    "\n",
    "class ScaledFloatFrame(gym.ObservationWrapper):\n",
    "    def __init__(self, env):\n",
    "        gym.ObservationWrapper.__init__(self, env)\n",
    "\n",
    "    def observation(self, observation):\n",
    "        # careful! This undoes the memory optimization, use\n",
    "        # with smaller replay buffers only.\n",
    "        return np.array(observation).astype(np.float32) / 255.0\n",
    "\n",
    "class LazyFrames(object):\n",
    "    def __init__(self, frames):\n",
    "        \"\"\"This object ensures that common frames between the observations are only stored once.\n",
    "        It exists purely to optimize memory usage which can be huge for DQN's 1M frames replay\n",
    "        buffers.\n",
    "        This object should only be converted to numpy array before being passed to the model.\n",
    "        You'd not believe how complex the previous solution was.\"\"\"\n",
    "        self._frames = frames\n",
    "        self._out = None\n",
    "\n",
    "    def _force(self):\n",
    "        if self._out is None:\n",
    "            self._out = np.concatenate(self._frames, axis=2)\n",
    "            self._frames = None\n",
    "        return self._out\n",
    "\n",
    "    def __array__(self, dtype=None):\n",
    "        out = self._force()\n",
    "        if dtype is not None:\n",
    "            out = out.astype(dtype)\n",
    "        return out\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self._force())\n",
    "\n",
    "    def __getitem__(self, i):\n",
    "        return self._force()[i]\n",
    "\n",
    "def make_atari(env_id):\n",
    "    env = gym.make(env_id)\n",
    "    assert 'NoFrameskip' in env.spec.id\n",
    "    env = NoopResetEnv(env, noop_max=30)\n",
    "    env = MaxAndSkipEnv(env, skip=4)\n",
    "    return env\n",
    "\n",
    "def wrap_deepmind(env, episode_life=True, clip_rewards=True, frame_stack=True, scale=False):\n",
    "    \"\"\"Configure environment for DeepMind-style Atari.\n",
    "    \"\"\"\n",
    "    if episode_life:\n",
    "        env = EpisodicLifeEnv(env)\n",
    "    if 'FIRE' in env.unwrapped.get_action_meanings():\n",
    "        env = FireResetEnv(env)\n",
    "    env = WarpFrame(env)\n",
    "    if scale:\n",
    "        env = ScaledFloatFrame(env)\n",
    "    if clip_rewards:\n",
    "        env = ClipRewardEnv(env)\n",
    "    if frame_stack:\n",
    "        env = FrameStack(env, 4)\n",
    "    return env\n",
    "\n",
    "\n",
    "\n",
    "class ImageToPyTorch(gym.ObservationWrapper):\n",
    "    \"\"\"\n",
    "    Image shape to num_channels x weight x height\n",
    "    \"\"\"\n",
    "    def __init__(self, env):\n",
    "        super(ImageToPyTorch, self).__init__(env)\n",
    "        old_shape = self.observation_space.shape\n",
    "        self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(old_shape[-1], old_shape[0], old_shape[1]), dtype=np.uint8)\n",
    "\n",
    "    def observation(self, observation):\n",
    "        return np.swapaxes(observation, 2, 0)\n",
    "    \n",
    "\n",
    "def wrap_pytorch(env):\n",
    "    return ImageToPyTorch(env)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "n7CPXRg3pzf4"
   },
   "outputs": [],
   "source": [
    "# Replay buffer- stores a transitions - state, action, reward, next_state\n",
    "# DQN network class - neural network - CNN -> linear layers\n",
    "#                   - Add forward should give for a state and action pair, the expected return from t to T\n",
    "# Fill_buffer function - add n samples to the replay buffer\n",
    "# Train function - sample transitions and update network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "k8drE3WQMoVv"
   },
   "outputs": [],
   "source": [
    "# TODO: Implement Prioritized Replay Buffer\n",
    "# Code Block: (a)\n",
    "class ReplayBuffer():\n",
    "  def __init__(self, num_actions, memory_len = 10000):\n",
    "      self.memory_len = memory_len\n",
    "      self.transition = []\n",
    "      self.num_actions = num_actions\n",
    "\n",
    "  def add(self, state, action, reward, next_state, done):\n",
    "      if self.length() > self.memory_len:\n",
    "        self.remove()\n",
    "      self.transition.append(Transition(state, action, reward, next_state, done))\n",
    "\n",
    "  def sample_batch(self, batch_size = 32):\n",
    "      minibatch = random.sample(self.transition, batch_size)\n",
    "\n",
    "      states_mb, a_, reward_mb, next_states_mb, done_mb = map(np.array, zip(*minibatch))\n",
    "\n",
    "      mb_reward = torch.from_numpy(reward_mb).to(device)\n",
    "      mb_done = torch.from_numpy(done_mb.astype(int)).to(device)\n",
    "\n",
    "      a_mb = np.zeros((a_.size, self.num_actions))\n",
    "      a_mb[np.arange(a_.size), a_] = 1\n",
    "      mb_a = torch.from_numpy(a_mb).to(device)\n",
    "\n",
    "      return states_mb, mb_a, mb_reward, next_states_mb, mb_done\n",
    "\n",
    "  def length(self):\n",
    "      return len(self.transition)\n",
    "\n",
    "  def remove(self):\n",
    "      self.transition.pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "g0vAAN8opzeg"
   },
   "outputs": [],
   "source": [
    "# Code Block: (b)\n",
    "class DQNNetwork_atari(nn.Module):\n",
    "\n",
    "    def __init__(self, num_actions = 4):\n",
    "        super().__init__()\n",
    "        # Define your architecture\n",
    "\n",
    "        self.num_actions = num_actions\n",
    "        # Network Architecture\n",
    "        self.features = nn.Sequential(\n",
    "            nn.Conv2d(4, 32, 8, 4),\n",
    "            nn.BatchNorm2d(32),\n",
    "            nn.ReLU(True),\n",
    "            nn.Conv2d(32, 64, 4, 2),\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(True),\n",
    "            nn.Conv2d(64, 64, 3, 1)\n",
    "          )\n",
    "          \n",
    "        self.fc = nn.Sequential(\n",
    "              nn.Linear(3136, 1500),\n",
    "              nn.ReLU(True),\n",
    "              nn.Linear(1500, 512),\n",
    "              nn.ReLU(True),\n",
    "              nn.Linear(512, self.num_actions)\n",
    "          )\n",
    "\n",
    "    def forward(self, x):\n",
    "      # output forward should always be q values for all actions\n",
    "        x = torch.tensor(x, dtype=torch.float).to(device)\n",
    "        if len(x.size()) == 3:\n",
    "          x = x.unsqueeze(dim=0)\n",
    "        x = self.features(x)\n",
    "        x = x.view(x.size(0), -1)\n",
    "        x = self.fc(x)\n",
    "\n",
    "        return x.double()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "QO7RPnP5Hnay"
   },
   "outputs": [],
   "source": [
    "def plot(frame_idx, rewards, losses):\n",
    "    clear_output(True)\n",
    "    plt.figure(figsize=(20,5))\n",
    "    plt.subplot(131)\n",
    "    plt.title('frame %s. reward: %s' % (frame_idx, np.mean(rewards[-10:])))\n",
    "    plt.plot(rewards)\n",
    "    plt.subplot(132)\n",
    "    plt.title('loss')\n",
    "    plt.plot(losses)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Lw8KflTIk4_2"
   },
   "outputs": [],
   "source": [
    "# Update Target network\n",
    "# TODO: Complete this part for soft updating network for DQN\n",
    "# Code Block: (h)\n",
    "def soft_update(local_model, target_model, tau):\n",
    "    \"\"\"Soft update model parameters.\n",
    "    θ_target = τ*θ_local + (1 - τ)*θ_target\n",
    "    \"\"\"\n",
    "    for l, t in zip(local_model.parameters(), target_model.parameters()):\n",
    "      with torch.no_grad():\n",
    "        t *= (1 - tau)\n",
    "        t += tau * l "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xJm0gYFn5OQ_"
   },
   "outputs": [],
   "source": [
    "def set_seed(env, seed=None):\n",
    "    if seed is not None:\n",
    "        random.seed(seed)\n",
    "        env.seed(seed)\n",
    "        np.random.seed(seed)\n",
    "        torch.manual_seed(seed)\n",
    "        if torch.cuda.is_available():\n",
    "            torch.cuda.manual_seed(seed)\n",
    "            torch.cuda.manual_seed_all(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Wei3Fo1bbXa4"
   },
   "outputs": [],
   "source": [
    "# Code Block: (e) Hyperparameters\n",
    "env_id = \"PongNoFrameskip-v4\"\n",
    "num_episodes = 600 # number of episodes to run the algorithm\n",
    "buffer_size = 10 ** 5 * 3 # size of the buffer to use\n",
    "epsilon = 1.0 # initial probablity of selecting random action a, annealed over time\n",
    "timesteps = 0 # counter for number of frames\n",
    "minibatch_size = 128 # size of the minibatch sampled\n",
    "gamma = 0.99 # discount factor\n",
    "eval_episode = 100\n",
    "num_eval = 10\n",
    "tau = 1e-3 # hyperparameter for updating the target network\n",
    "learning_rate = 0.00001 \n",
    "update_after = 2000 # update after num time steps\n",
    "epsilon_decay = 10**5\n",
    "epsilon_ub = 1.0\n",
    "epsilon_lb = 0.02"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Zz2Op79LbiAB"
   },
   "outputs": [],
   "source": [
    "# DO NOT MAKE CHANGES HERE\n",
    "# Initialize environment\n",
    "# Code Block: (c)\n",
    "env_id = \"PongNoFrameskip-v4\"\n",
    "env    = make_atari(env_id)\n",
    "env    = wrap_deepmind(env)\n",
    "env    = wrap_pytorch(env)\n",
    "num_actions = env.action_space.n\n",
    "state_space = env.observation_space.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UwNo-0562-dS"
   },
   "outputs": [],
   "source": [
    "# set seed\n",
    "set_seed(env, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Ln2NOMZygsjY"
   },
   "outputs": [],
   "source": [
    "# Code Block: (b) \n",
    "dqn = DQNNetwork_atari(num_actions=num_actions).to(device)\n",
    "dqn_target = DQNNetwork_atari(num_actions=num_actions).to(device)\n",
    "# load saved weights, if you have already trained the model\n",
    "anchor = 0\n",
    "# dqn.load_state_dict(torch.load(f'checkpoint_save - {anchor}'))\n",
    "# dqn_target.load_state_dict(torch.load(f'checkpoint_save - {anchor}'))\n",
    "# losses = pickle.load(open(f\"losses - {anchor}\", \"rb\"))\n",
    "# returns = pickle.load(open(f\"returns - {anchor}\", \"rb\"))\n",
    "buffer = ReplayBuffer(num_actions=num_actions, memory_len=buffer_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 506
    },
    "id": "-jzQ6Q8rYVKw",
    "outputId": "543bac15-ac75-4329-f721-273d4afc1a89"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode:  591   20.0\n",
      "Episode:  592   21.0\n",
      "Episode:  593   14.0\n",
      "Episode:  594   21.0\n",
      "Episode:  595   18.0\n",
      "Episode:  596   18.0\n",
      "Episode:  597   21.0\n",
      "Episode:  598   20.0\n",
      "Episode:  599   16.0\n"
     ]
    }
   ],
   "source": [
    "# Train the agent using DQN for Pong\n",
    "returns = []\n",
    "returns_50 = deque(maxlen=50)\n",
    "losses = []\n",
    "optimizer = optim.Adam(dqn.parameters(), lr=learning_rate)\n",
    "mse = torch.nn.MSELoss()\n",
    "\n",
    "state = env.reset()\n",
    "timesteps = 0\n",
    "for i in range(num_episodes):\n",
    "  ret = 0\n",
    "  done = False\n",
    "  while not done:\n",
    "    # Decay epsilon :\n",
    "    epsilon = max(epsilon_lb, epsilon_ub - timesteps/ epsilon_decay)\n",
    "    # action selection\n",
    "    if np.random.choice([0,1], p=[1-epsilon,epsilon]) == 1:\n",
    "      a = np.random.randint(low=0, high=num_actions, size=1)[0]\n",
    "    else:\n",
    "      net_out = dqn(state).detach().cpu().numpy()\n",
    "      a = np.argmax(net_out)\n",
    "    next_state, r, done, info = env.step(a)\n",
    "    ret = ret + r\n",
    "    # TODO: store transition in the replay buffer \n",
    "    # Code Block: (a)\n",
    "    buffer.add(state, a, r, next_state, done)\n",
    "    state = next_state\n",
    "    timesteps = timesteps + 1\n",
    "\n",
    "    # update policy using temporal difference\n",
    "    if buffer.length() > minibatch_size and buffer.length() > update_after:\n",
    "      optimizer.zero_grad()\n",
    "      # TODO: Sample a minibatch randomly\n",
    "      # Code Block: (a)\n",
    "      states_mb, mb_a, mb_reward, next_states_mb, mb_done = buffer.sample_batch(minibatch_size)\n",
    "      \n",
    "      # TODO: Compute q values for states\n",
    "      # Code Block: (g)\n",
    "      q = dqn(states_mb)\n",
    "      # TODO: compute the targets for training\n",
    "      # Code Block: (g)\n",
    "      target_q = dqn_target(next_states_mb)\n",
    "      # TODO: compute the predictions for training\n",
    "      # Code Block: (g)\n",
    "      targets = torch.where(mb_done.byte(), mb_reward, mb_reward + gamma * torch.max(target_q, dim=-1).values)\n",
    "      predictions = q[mb_a != 0]\n",
    "      # Update loss: mse = mean squared error\n",
    "      loss = mse(predictions, targets) \n",
    "      loss.backward(retain_graph=False)\n",
    "      optimizer.step()\n",
    "      losses.append(loss.item())\n",
    " \n",
    "      # Update target network\n",
    "      # Code Block: (h)\n",
    "      soft_update(dqn, dqn_target, tau)\n",
    "    if done:\n",
    "      state = env.reset()\n",
    "      print(\"Episode: \",i, \" \",ret)\n",
    "      break\n",
    "  returns.append(ret)\n",
    "  returns_50.append(ret)\n",
    "  if i % 10 == 0:\n",
    "    print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i, np.mean(returns_50)))\n",
    "    plot(timesteps, returns, losses)\n",
    "  if i % 100 == 0 and i != 0:\n",
    "    pickle.dump(losses, open(f\"losses - {i + anchor}\", \"wb\"))\n",
    "    pickle.dump(returns, open(f\"returns - {i + anchor}\", \"wb\"))\n",
    "    torch.save(dqn.state_dict(), f'checkpoint_save - {i + anchor}') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 350
    },
    "id": "SzbwR2RoGWLf",
    "outputId": "798eafc4-10dc-4d9d-b24d-2c2badc0562a"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwEAAAFOCAYAAADejhGFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydeXwU9f3/XzN75A4hIQmBcIMhckgOToNUriAEQb5VEG8RtWJt1WrRn1wqPor6rVYFBVu1FgsWD46IwBcrAha0AeQwisgpJJCLkHvv3x+7M5l7ZzebTXbzfj4eys7M55rZze77/XlfjMvlcoEgCIIgCIIgiA4D29YLIAiCIAiCIAgiuJASQBAEQRAEQRAdDFICCIIgCIIgCKKDQUoAQRAEQRAEQXQwSAkgCIIgCIIgiA4GKQEEQRAEQRAE0cEgJSAMOXXqFGbMmIGsrCy8//77bb0coh2TkZGBs2fPtvUyCIIg2jXjx4/Hf/7zn7ZeBkEEFFICwpC//vWvGDlyJA4dOoQ777yzrZcjY9GiRcjPz8fAgQPxySefiK599tlnyM/PR05ODkaPHo0//vGPqKur469XV1djwYIFGDZsGK6//nps2bJFcY6nnnpKJuCuXbsWs2bNwuDBg7Fw4UJZn8bGRixduhQjR45ETk4ObrvtNv7a66+/jkGDBiErK4v/75dffmnpowgptm7dijlz5uCaa67BHXfcIbu+b98+3HTTTcjOzsaECRPw4Ycfqo513333iZ7l4MGDMX369NZcPkEQBEEQAoxtvQAi8JSUlGDatGmq1x0OBwwGQxBXJGbgwIGYOnUqXnrpJdm17OxsrFu3DomJiaivr8fixYvx6quv4plnngEAPPvsszCZTPj666/xww8/4IEHHsDAgQMxYMAAfoyioiJFAT0lJQUPPfQQ9uzZA4vFIru+aNEiOBwOfP755+jUqRN++OEH0fUbbrgBL7/8cktvH3a7HUZjcP/0AjFnQkIC7rzzTpw6dQrffPON6JrNZsPDDz+MJ554ArNnz8bRo0dx11134ZprrsHAgQNlY/31r38VHd9xxx0YOXJki9ZHEARBEIR+yBIQZtx555345ptv8OyzzyIrKwunT5/GwoULsWTJEsyfPx/Dhg3DN998g127dmHmzJnIzs7GuHHj8Prrr/NjnD9/HhkZGfj4448xbtw4DB8+HOvWrcORI0cwffp05Obm4tlnnxXN+9FHH+GGG27A8OHDMW/ePFy4cEF1jbfddhtGjx6NiIgI2bW0tDQkJibyxwaDgd/Nb2howI4dO/C73/0OMTExyM3Nxfjx47Fp0ya+vd1ux/PPP88rDUImT56MiRMnIiEhQXbt5MmT+Pe//43nnnsOiYmJMBgMGDx4sMaT1s/rr7+ORx55BH/4wx+QnZ2NTz/9FLW1tXj66aeRl5eHsWPH4pVXXoHD4QAAXH/99Th27BgAYPPmzcjIyMCJEycAABs2bMBDDz0EADhy5Ahmz56N3Nxc5OXl4dlnn4XVauXnzcjIwAcffIDJkydj8uTJANzCd15eHvLy8vDRRx/5dB9jxozB1KlTkZqaKrt25coV1NXVYcaMGWAYBkOHDkXfvn3x888/ex33/PnzKCoqwsyZM31aD0EQRLCxWq1Yvnw5/z26fPly/nu3qqoKDzzwAHJzczFixAjMnTsXTqcTALBmzRqMHTsWWVlZyM/Px759+9ryNggCACkBYcf777+P3NxcLF68GIcOHUKfPn0AAIWFhXjwwQdx8OBB5OTkICoqCitWrEBRURFWr16NdevWYefOnaKxDh8+jB07duCVV17BCy+8gLfeegvvvfcePvvsM3z++ef49ttvAQA7d+7E6tWr8cYbb2Dfvn3IycnB448/7vc9FBUVIScnB9nZ2dixYwfuuusuAMCZM2dgMBj4ewLcVgWhoPnee+8hNzdXcfdZi6NHj6J79+547bXXMHLkSEyfPh3bt28Xtfnyyy8xYsQITJs2Df/85z99Gv+LL77AlClTUFRUhOnTp2PhwoUwGo3YsWMHNm7ciK+//hobNmwAAAwfPpx/tv/973/Ro0cP/Pe//+WPR4wYAQBgWRZPPfUU9u/fj/Xr12Pfvn2yde3cuRP/+te/sHXrVuzevRvvvPMO3nnnHezYsUP2I7Rlyxa/XXK6dOmCgoICfPLJJ3A4HDh06BBKSkqQk5Pjte/GjRuRm5uL9PR0v+YmCIIIFm+++SYOHz6MTZs2YfPmzTh69ChWrVoFAHj33XeRmpqKffv24euvv8Zjjz0GhmFw6tQpfPDBB/joo49w6NAh/O1vf0P37t3b+E4IgpSADsOECROQk5MDlmURERGBkSNHIiMjAyzLYuDAgZg2bRoveHIsWLAAERERyMvLQ3R0NAoKCpCUlITU1FTk5uaiuLgYALB+/Xrcf//96NevH4xGIx588EH88MMPmtYALXJzc3HgwAHs3r0b8+bN478sGxoaEBsbK2obFxeH+vp6AEBpaSk+/PBD/O53v/N5zosXL+Knn35CXFwc9uzZg0WLFmHhwoU4efIkALcr0NatW7Fv3z4899xzWLVqFQoLC3WPP2zYMEycOBEsy6Kurg5fffUVnn76aURHRyMpKQl33303PvvsMwBiJaCoqAgPPPCASAkYPnw4AGDw4MEYNmwYjEYj0tPTMXv2bL4dx/3334+EhARERkbi888/x6xZs3DVVVchOjoaDz/8sKjt9OnTVWMs9DBt2jSsXLkSQ4YMwW233YZHH30UaWlpXvtt2rQJN910k9/zEgRBBIstW7ZgwYIFSEpKQmJiIhYsWIDNmzcDAIxGI8rLy1FSUgKTyYTc3FwwDAODwQCr1YqTJ0/CZrMhPT0dPXv2bOM7IQhSAjoMUmHs8OHDuOOOOzBq1Cjk5ORg/fr1uHz5sqhNUlIS/zoiIkJ23NDQAMAdg/DCCy8gNzeXN4O6XC5cunSpRWtOTU3F2LFj8dhjjwEAoqOjRUHCAFBXV4eYmBgAwAsvvIAFCxYgLi7O57kiIyNhMpnwm9/8BmazGSNGjMDIkSOxd+9eAED//v2RmpoKg8GA7Oxs3HnnnTJLgRZdu3blX5eUlMButyMvL49/ZosXL0ZVVRUAYMSIEThw4ADKysrgdDpxww034ODBgzh//jxqa2uRmZkJADh9+jQeeOABXHvttcjOzsYrr7wiew+F73tZWZnoOJA7USdPnsRjjz2GFStW4NixYygsLMRf//pX7Nq1S7NfUVERKioqkJ+fH7C1EARBtBZlZWXo1q0bf9ytWzeUlZUBAObNm4devXrh3nvvxYQJE7BmzRoAQK9evfD000/j9ddfx5gxY/Doo4+2+PeRIAIBKQEdlMcffxwTJkzAV199hQMHDmDOnDlwuVx+jZWWloZly5ahqKiI/+/IkSPIzs5u8TrtdjvOnTsHAOjduzccDgfOnDnDX//xxx/Rv39/AO7sNC+++CKuvfZaXHvttQCA2bNn69rdzsjI8HltvjwvhmH41127doXZbMb+/fv553Xw4EHeEtCrVy9ERkZi7dq1yM3NRWxsLLp06YJ//etfvDUHAJYuXYq+ffti+/btOHjwIB599FHZmoTzpqSkoLS0lD8uKSnx+Z7VOHHiBHr37o2xY8eCZVn07dsX48aNw+7duzX7bdy4EZMmTeIVOYIgiPZMSkqK6LuztLQUKSkpAIDY2FgsXLgQX3zxBd588028++67vNvl9OnTsW7dOnz55ZdgGCYgSSYIoqWQEtBBqa+vR6dOnRAREYEjR4745NoiZc6cOVizZg0fvFpbW4vPP/9ctb3VaoXFYoHL5YLdbofFYuGDpzZv3sx/wV64cAGvvvoqRo8eDcBtCZg0aRJee+01NDQ04MCBA/jiiy8wY8YMAMD27duxadMmbNy4ERs3bgQAvPXWW5g0aRIAiOZyOBywWCyw2+0A3C5IaWlpWL16Nex2Ow4cOIBvvvkGeXl5ANy+9VeuXIHL5cKRI0fwj3/8AxMmTPDreaWkpODaa6/Fn/70J9TV1cHpdOLcuXMid6wRI0Zg7dq1vOuP9Bhwv4cxMTGIiYnByZMnsW7dOs15p0yZgk8//RQ///wzGhsb8cYbb/i0buEzczqdsFgssNlsAICrr74aZ8+exb59++ByuXDu3Dns2rVLU7lqamrC559/Tq5ABEGEDNOmTcObb76JqqoqVFVVYeXKlXws1ZdffomzZ8/C5XIhLi4OBoOBjwnYt28frFYrzGYzIiIi+M0cgmhL6FPYQVmyZAlee+01ZGVlYeXKlbjhhhv8HmvSpEm477778NhjjyE7OxsFBQWaO8Dz5s3D0KFDcejQISxatAhDhw7lfdlPnjyJOXPmYNiwYbj11lvRp08fPPfcc6J1NzU1YcyYMXj88cexdOlSPj1oUlISkpOT+f8AoHPnzoiMjATgDugaOnQo1qxZg82bN2Po0KF48803AQAmkwmrVq3C7t27kZubi0WLFuHFF19Ev379ALhz5E+ePBnZ2dl48sknMX/+fJHwmpWVhaKiIt3P7MUXX4TNZsPUqVMxfPhwPPLIIygvL+evDx8+HPX19SIlQHgMAH/84x9RWFiI7OxsLFq0CFOnTtWcc9y4cbjrrrtw1113YdKkSRg1apTo+ubNmzVTy27atAlDhw7F0qVLUVRUhKFDh2LRokUAgJ49e2L58uVYvnw5srOzcfvtt2Py5Mm4+eabAbjdfrKyskTj7dy5E/Hx8bJ1EARBtFceeughDB48GDfeeCNuvPFGDBo0iM/YdvbsWdxzzz3IysrC7Nmzceutt2LUqFGwWq343//9X4wcORJ5eXmoqqri3VwJoi1hXP76gBAEQRAEQRAEEZKQJYAgCIIgCIIgOhikBBAEQRAEQRBEB4OUAIIgCIIgCILoYJASQBAEQRAEQRAdDFICCIIgCIIgCKKDQUoAQRAEQRAEQXQwjG29AD1cvlwPp9P3TKZJSbGorKxrhRUFF7qP9kM43ANA99He8Oc+WJZB585UaZmjo/1OhOK6Q3HNAK072NC6A4e334mQUAKcTpdfX+5c33CA7qP9EA73ANB9tDfC5T7aio74OxGK6w7FNQO07mBD6w4O5A5EEARBEARBEB0MUgIIgiAIgiAIooNBSgBBEARBEARBdDBICSAIgiAIgiCIDgYpAQRBEARBEATRwSAlgCAIgiAIgiA6GKQEEARBEARBEEQHg5QAgiAIgiAIguhgkBJAEEHkm+JLWPLOt3C5vBcUcTid+H9v78fBn8oVr9vsTix8ax+OnKz0aQ2NFjvueW4HfvqlWrNdXaMNj6/8Gmcu1vg0fmtTUlGPR9/Yi+o6i0/9TpfW4PGVX6O+ySY6/8YnR/HZvjP88WsfHcEbnxzFwtX78NK6Q9j+7TkAwA9nL2Ph6n2w2BwtWv/z7xfh3j/9G298chRL3/kWTh2fBYLQy9b9Z/HqhsNtvQyCIEIAUgIIIois3vw9fimr0yX4NTTZUVrZgPc+/1Hx+uU6C8qqG7F2x3Gf1nD2Yi0qqhvxye5Tmu1+PHsZl2st+Ow/Z30av7X598HzuFJnRdGPZT71K/zPGVyuteDHs2Ll5+BP5fj4q+Zn8d3PFTj4UznKLjfih7OX8eG/fwYAfPjFCZRdbsTFyga/1261OXCqpIaf91xZHeobbV56EYR+Ptp10ueNAYIgOiakBBBEG2B3eFcCGIYBAFWrAeP5t7U2kh2e8ucGA+OlZXAxGw0AAJvD6VM/A+u+D3933pkW9geA2ga5wK90jiAIgiBaG2MgBrl8+TKefPJJnDt3DmazGb169cKzzz6LxMREfPfdd1i8eDEsFgu6d++Ol156CUlJSYGYliBCFofDBZi023DCv1NF5mR42dw3oZTRKdM7PROzbPtSAoxG996FzeabEsDdh8NH5YGDUyIcam+IDmobrfJzDfJzBEEQBNHaBMQSwDAM7rvvPmzfvh1btmxBjx498PLLL8PpdOKJJ57A4sWLsX37duTm5uLll18OxJQEEdLYnd4FUU4IV7cEeCwFPs6tdyObtwTo1RqChMmjBFjtvloC3P38FeJZz3Ow+zivkJp6sgQQgeHHM1W490//9hrbQxAEoUZAlICEhASMHDmSPx42bBhKSkpw7NgxREREIDc3FwAwZ84cbNu2LRBTEkRI49DhDsTJqt6Edn+9U9REe6fTBZfLBYdHUQmGJcDpcul2szHzSoCDV5T0INzJd/kwH+B+JtxzsNp9CwwWzqO0619DlgDCDw55EgZ8f7qqjVdCEESoEhB3ICFOpxPr1q3D+PHjUVpaim7duvHXEhMT4XQ6UV1djYSEhEBPTRBBYdd3F/D+tuN46/FxMJsMfo2h5pJidzhx/0u7cOvEAcga0AWA3BJgtTnw4P9+hYIxvRSva/GP7cfx5aELAIDjv1TjwPEy5GSk8Nc37T2NTXtP45p+SRjaz+22ZzC4he5VG4+h6McydE2Mxgv3j9I9pzcuVTXg6TX7AQZIjItEg8WGRosDz84bgfTkWFHbE+er+UDdnUXnsevQBax4cAz+/OF36JoUjQU3DeHbPr1mP5qsdlTXWfHSb8bAaGh2B3p5/Xc4WXIFf15wLd/+/e3HcfvkqxTXWNdo45WIXYdK8OqGI7h98lVYu+MnAMDk4T3QrUsM3vv8R8yZMADrvzgBAEhLikapJ5C4YExvREfIv3LJEkAQBEG0BQFXAp577jlER0fj9ttvx//93/8FZMykpFjvjVRITo4LyBraGrqP9sPWfe5sOaYoM5I7R/s1RqeEaCQnyz/X3E7x5q/P4PrhvfjzwudWVuUWKgs9WXsYhtH9XDkFgGPX4VJMyevHH5fXNAEASi83YlRMBAAgJtqM5OQ4PhvPxaqGgL6PFy43ul2aXEClZ34A+Lm0FllXp4nafrjrpOjY7nCBMRlwoaIeFyrqReu6WNWcxefC5UbEeu4nKjoCP5y9DABgTM1fgbsOXcAjc7IU1xjfKRqRHgH+u58rAIAX9AFgx39/QUrnKNn5UkEmocL/nMHsSXIlw+hRJMPhb4MgCIIIHQKqBKxYsQJnz57FW2+9BZZlkZaWhpKSEv56VVUVWJb12QpQWVnnk9mfIzk5DuXltT73a2/QfbQfkpPj+J33yso6MD66hnCUVdTBpODNz7mGMAAqKusAuN1JhM+t8kqjqI/D6fL7uVqtdlHf+nr3/DabA1c8ArnFYpONX1ZWw2cvaimXLyun3Kyvt8jmbVBwnamsrOdfc+2lrj5lFXWwWOwAgCs1zc/vkmT8i5eUayJUVNTKYgEiTAbYHXb+WM931OXqRtm5Wk+9A1/fQ5ZlWrRBQhAEQXRsApYi9M9//jOOHTuGlStXwmw2AwAGDx6MpqYmFBUVAQDWr1+PKVOmBGpKgmgjPMJvC1JzqroDeQRNlmkOYJV6+zASb35f3IGkSIVlu2ddDoeTF2oNCjEBjRa77Fyg1sChdFqprVKgb0OTeH2NVgef6lQorFslGYbUUrc6XC7ZczAaxF+fenQipWBmPfEhBEEQBBFoAmIJOHHiBFavXo3evXtjzpw5AID09HSsXLkSL774IpYsWSJKEUoQ4UBLRDe1DDWcEM4wDFxOLkWo9kwtqRMgTVJk8wikDmdzYDCXVUdITYMN0ZFecpzqRO1ZKJ1VSqqkpARJA3AbLXZeiLeLlACxJUdtLU6nSybkSwOm9VhGLFa55cihI1MUQRAEQQSagCgBAwYMwPHjylVLs7OzsWXLlkBMQxAtwu5wgmUYsCzjfs0yYBkGLpcLdocLJiPryYrjku3yVtU0IdLs9t1mdBgCuPG5rDKsREC0q1gCOCGcYQCLx9XI5XILugzjXrdLMnNDkx2NFjuMBhYMA35e4T04ncrZcGx2B+oabTAZWY97i9OzPhcsHgGZG09IZU0TuiY2x0PUNlgRaTbAZDSgpsGKKLMRJiMLu8OJy7UWmE0GdIoxK96zmgxcU2dFeXUjOsdF8PcivXdAeXddGmzbZLEj3jO/0ArTILFoVF5pghJOl9xKIDWQNOmwjkiVDkBf4TiCIAiCCDQBDwwmiPbK/S/tQkaPBPzxtmzc/9IuDOrdGY/PycLOA+exbucJvPLbPOw7dhH/+vJn/OWRPMRFu4XGb4ovYfXm72FgGaxfPrV5QI0t+Ptf2oW8IWnYe7QU113TDXffMFB0Xc0FhHMHqq6zYvn7B/jzn+45hamjeuGhP+9G3hBxsKzT5cKCV3bzxzlXJePAT+V4Z+F4/txfPjqCo6cqZfOdL6/HI3/Zw2f8sXnmt9gcfOCxgWXw7N//K+r3j23H8acHRwMAKqob8eRb+9C3Wzzun341Fq7ej/7dO+HpO3Lw7tYfsO/7SwCARXflok9avGwNau5MXxw8jy8Onseoq1Nx/42DPG3l7ZRck6RKQKPVgc7x8joBb236XtTu+feLFNficrpkipt0579GR5Yfi4ISQJYAgiAIoi0IWEwAQYQCxwWFdb4/484Q859jFwG4d/u/PlYKwC2Ec1yudQduOpwuNDbZdVkCAGDvUfdYuw+XyK6pFQuzqVgIdvz3F97PnRtXjQOe/OHCnX8lBUAIl0lHzUJx7lKd6JgRbINXeZ7PqZIa/ln9fOEKAPfOemyU223oUpVyALCWu5PZxIoyBikF3yopAdL7cDhd/M69Pz74TpdL9t5IrTt6UFICyBJA+EVL/AAJgiBASgBBiPH8rgrFO5sgA5DV7uQDc9WywegpQuXNEiBFGsCqB2lwLCAPZpViU5hf6T6dAiVG6OIiFXItNifvNqS2U66VVScuyiwaU+nZNlrkgrW0nbs4mGe9fmR0crpcsmfjTxE1ZUsACXOE/7Szgt4EQYQQpAQQHQ41odPhEHicC35YbQKB3WZ38NfUZDc9qSLVdn/VduJ9gVu6UnVapUw/3ub3lpHHIlICxP0tNgcS4iJgYBnF9aiNzxETZRQpQHotAdJ2XFyFdL16cTrlz8Y/JUD+fAPxnhMEQRCEr5ASQHQ41IRAi93BC4pC8U4opAl3g11qyoQOJUDND1zNHcgXoiPdoT419XKh21s6USXlRElIF7YTCumcVYDbnbTYHIg0GRAbbVJXAjRuOSbSJHq/FGMCrApKgJIlwPO++GNVcbpcMiuNPzuwSoHBZAkgCIIg2gJSAoiQpa7RpitffU2DFU0CQVEoiNXUW/ljqyB9Y22DjRc+hcLfsZOVvCLACZpcBhwOJVefy7UWkQJReaUJNrsT1XXN/Wx2BypUstMA+l2AuXmkwbHuNav3q7jSCJvdKbMW/FJWJ2tb32jjn39VbfOaL1S4C3dxbkdWmwMRJgPio82oqVdxB9K4sdgoE//+lFc3KrZtErgDlVc3utclcYWqbbDxbkNKSqA3N6krdVbUS8b0p4Ch8HPCoVYzgiAIgiBaE8oORIQsj/xlD2KjTHjtd2M12/3+tb2idJZCIfD3r+8VnefkuhfXHULP1FgsvWeEyBKwZuNR/jW3g/v+tuPYe7QUbz42DhFmg0xQZQA8vvJrZA3owp/bsOskfr5wBYdOVOBvf7weDMNg5afHcOSkegCvnlgDoDllZl2jXOjWsgQ8+eY+AEBMpFEk8B47VSVr63C68Mhf9iDCbBDlvt/2zTkAzUK1xeaE2cQiNsqEuibflYCYKLclYH/xRazZXAyTUS6sCy0Bf3xrn+I4P1+4wgcrNynk6jd70pmqsfJT9/tuNDC8FUQpfsIf7GQJIAiCINoAsgQQIY2SoKvERUFmGiW/bPd5h2i7ncuIoybsccLrQU82Hs6VR+rewR0dOlEhOs8dc+21FABAWXjlSEuKlp1TEmr1uJ5EmvXvDSgVvwLcsQdOT1rNCJPBXTNA5TmquVUBboXE7nDhp3PurE5K74XaGtSwKQQGm03ir8LfzhqCpPgIWbux13TDr3/VT3UtvjB1VC8M7JkQFhWDT58+jdmzZyM/Px+zZ8/GmTNnZG327t2LWbNmYfDgwVixYoXo2sqVKzFt2jRMnz4ds2bNwp49e4K0coIgiI4LKQFEWKMkIKrGBNicimk/1fz0XZ7TDo8ywKWM9NW9Q29g6JU6uSsJR7cuMbJz/rirAEBkhMGvfkJcruZiY2aTAQaWUQ2G1lpmjKcqsVYwr6+BvkrCu9kkvufO8RGycwAQYTLgqh4JquPogbOSXNUjAZFmY1i4Ay1ZsgRz587F9u3bMXfuXCxevFjWpkePHli+fDnmzZsnuzZ06FB89NFH2LJlC1544QU8+uijaGpSd40jWlaxnCAIAiAlgAhzlIJRlYIzAc4SID+vLry6zzfvZLv/9VX41itMCmsXSDEb5QKrvwGnkQrCr684BUpAhNkAg4FVDYbWWmeEp0qzmvXGfc03JUCpwrBZ4mbEMoysGBjgFuA5Zc/fIG4u5IJlAYOBCfnA4MrKShQXF6OgoAAAUFBQgOLiYlRVid3IevXqhczMTBiNckvT2LFjERUVBQDIyMiAy+VCdXW1rB1BEAQROEgJIMIapdz0akKj1eZQyYTjRKRZLhhzwj7Xh5PlHHojePnx9bW/Uq9uCYhQWJ+/wqXSWL7icAgsAUYWRgOj6vaipTRFeNx0alQyCwHaCoISeiwBLpc4QxSHycDwgdN+uwNxSgDDeCwkoW0JKC0tRWpqKgwG9zM0GAxISUlBaal2UTs1Nm7ciJ49e6Jr166BXGbYQbXCCIJoKRQYTIQkly43+/j/fP4K+qd3UmynZAko9lQKlqLkOnS6tAZHTlaic1yEzCefE/45YbvJYkfFlUbFXXkt9O4oH/5ZPWYgwiTX5/12B/IhJkANh9PFP88IjzuQzeHEoZ/K4XS50D05FqdKrqBft06awcoRHuG8orpRtY1aJWI1FJUAiSVAraKzyWjwqz6AEK7YHMswMBrYkLcEBJJvv/0Wf/nLX/DOO+/43DcpKdbveZOT4/zu29bExkQorr+93lN7XZc3aN3BhdYdHEgJIEKSp1bv51+/sPYAnro9GwPSE2Tt6hUy0nxx4LzimFa7U7a79tzfiwAo+/nz7kCePqu3fI+TF2rw1O3Zuu6BQ++OMpfdRokIBRcef7POdOkU6Vc/IU6ni1eaIs0GGFgWl2steBzKrL4AACAASURBVP0Td5YdhnE/t8xenXF1786q43D3peUK5StKFYOlik9iXKSiKcBoYNBCHYCHZcPDEpCWloZLly7B4XDAYDDA4XCgrKwMaWlpPo1z6NAhPPHEE1i1ahX69u3r8zoqK+v8UnyTk+NQXl7rc7/2Qn2DVXH97fGeQvVZ07qDC607cLAso7lBQu5ARFhQVaPsKqNViEre1gW1cDuLgqAuHft0ifuPv75Ru3ZBr67inQK1rDkcz80boXkdUFYC9ApEE7LT+dfzpmXimv5dNFp7Z2DPBLjQXKwsLtoMo0EsOXOKU5PVrrlOoZtOp1izz2t56TdjZFYiJaWLGzsqwoDVfxiHznERiu5ARiOraAno2y1e/6KE7kBhYAlISkpCZmYmCgsLAQCFhYXIzMxEYmKi7jGOHDmCRx99FK+99hoGDRrUWkslCIIgBJASQIQFai4l3irkCnG6XKoZN5QEdWn8gNHolu6aFCrYComOEO86e9sJjorwbrBTymQjjVlQHT+yuW9SfKRMYPcVM79771bM4qJNMLDKXzU2u0szO5BQuUlLlKdB9UZifASMrLICIoR7xizDwKThzmUyKCsBSkqYNxgWMLLqsRKhxNKlS7F27Vrk5+dj7dq1WLZsGQBg/vz5OHrUbf0pKirCddddh3fffRfr16/Hddddx6cCXbZsGZqamrB48WLMmDEDM2bMwPHjx9vsfgiCIDoC5A5EhAVqcq4v4pXT6VIdR2m3VrqDbWRZWOFEo5e89TL/cy9KgLdqtoCaO5CnboGX8YVCr9tFpWV7A9x6ORceJUsAv0aHUzswWBCk3KVTFADfMsYwKll+pHDBvuJqycrZgQwK40mrLOvBbQlgVOMPQol+/fphw4YNsvNvv/02/zo3Nxe7d+9W7P/xxx+32toIgiAIZcgSQIQFarvdeqvsAm5B3yfLgVQJ8Aj33iwB0qq33mIC9ASiKmX04dZns2vfk1ApMbCMX5YAoaLC9a+usyAqwgiTkYVBZUyb3an5HgmVm9gok8/rAtzxB97g0n4ygmet1M+k4g7kT7AwHxgcBpYAgiAIIvQgJYAICk6nC7sO/OKTUO4L3xRfUhTgfZlOyR1ISyCubbRh75HmNIgmT9tPd5/WnEfqbrLlP2dwuVY9/SerQ4rVyg7kLfuQUAngglW1ULouTKHKKQTfnahAXLTJ00e+vphII2x2B/5z7KL62gT3Ja3qqxddlgDPe+etpVHFHcgvS4DnWfuqfBIEQRBEICAlgAgKXx66gP/950Hs/q6kVcY/droKxWflqT993tlXaT5lZE+YjCwSYiP4c//YfhzvbP2BP+aEX2/uPVJLwInzV/DVdxdUBVA9AqZSWlIuO5C3YloGwS4+F6zqK8J74hSnBosd8dFm0TkASE2MBssw6Jkah5oGm6oCNLBngsgSEGE2ILVzlM9r86YDjBncVfEZq9UJULQEaEyiVneBZYD05Fj0TPU/tSVBEARB+AspAURQuOLJFMNljGkN6hvl6UB9sgQ45ZYAlwuYNroXbrm+P1b/4VeYd6N65hKjUf3P6de/6se/lsYEAJ7noiJHttQdSKlWghChAKzHEqBkzREKwULXICVLwLypmVjzxK+8Cr9Pzs0WjWU2GrDsXu+ZkrTWpsR9BVfzz9jbx8VoZBXHU3uP3lk4HiapUuVq7pM7MAVL7xmhy1pBEELU0xgQBEHog5QAIihwIk6wf7Z8iglwyd0yXC7xTrKWQG7UCKgVjmFScGupbbDxRaSk6InTlVoXAIESUC9XjsTj+6YEKD1Soc+/WAkwy64zrHsePQHPQiJMLS/UpQYf7Ovl42I0sIrPRy3mQYvWuheiY0GfIoIg/IWUACIo8DJWK/o+Kwn8PlsCJO2dLpdIONdUAozq14RjyHaGAdQ0WFXdVvTEBCjtJHPuQDU+WAIMrLK7izeEYygFCQvTdHLPQklx0SLCbND1LKTo6cO5QInefoVuLKP8fJQyBgViXQRBEATRWpASQIQNSgJ/S7L9cIgsARqCm5Jw39yv+bVSTv+aBvXdej2uIkotpO5Aajv8wntiGf+DXDmUgqmFcQbcdFrPS4kIE6sr048UXdmBuPXr+Lz44g7k6zgEQRAEESxICSDajGOnK/GjQjAvABw5WYmffqn2vK7Ax1+d5I/V0MoOpGfX2amSpUUorGkJyJrCs2AMpbVcqmoIeOXYMxdr8E3xJWzdfw4mI6tadMxXdyDFMVRiAjhEcQeetv64A/njO+9LnQBRPxVHC0V3IF+eGVcxmNyBCIIgiDaElACizfjzh4fx4rpDitde3XAYf/rgoOf1EXy27yx/rIaWJUAajNutS4ysrZoMrjcmQEuGF8UESITfVIVKuL26xuHuGwaiT1qc+qAeOsdFIDkhEp1izaLzVTUWrN78PRotdkRFGBXX3qVTpOi8gVVOgSkks1dn2Tk1d6AJOenu6wrWAa1Aaq4fAEwe3gMpnaPQVUfF4DGDu8rOKekARgOLYf274KaxfTzH7kYiRUzSz2xk0TUpWnE86TPr3TUOd+RnaK6VdACiRVBcMEEQLYSUACIocLuxrZkOXWlsLk5AKHBen9UdN17bW9bW4XQpCvLCnWRNJcDpUt9tF4zBMM2C8s3X98O1CoLrkruH47prumHRXcNV5+N46vZsmIwGvPJwHhbfnavY5n+u66u4W/3oLdf47A4UF23CLdf3F50TWRM8L6/pl4S0JLeyJQya5qZTq8Fw++SrcNukq/jjORMG4E8PjEYnQXpWKROy3UpDr65xeFaSQUgx1aeRwSO/Horp17qVAC7Fql2jcNerj+Tx1gipK4+0DsLiu4fj+qzuqmMB4sJkBOE39DEiCMJPSAkggoI0O1BrBAg7nOr5+c2iPPasKP88h9uHXr4uvTEBDpdLdXdX2I1hGJiMzS4xUrcYX3/TRQqGaoYhZTcfhmEUUoR6/1qQDiVcA7ebLlS8hJYArq1aTIA/vvKcsueucyDprzCedG4uxaqwxoO0lzCWQ/qIWupCRRAEQRDBhpQAIjhI5J1Gi3YBKzW0lAelXVwnHxMgqGhrZJSVAJc8OxAgCZz1YglQ8z+XnueEUJORlccI+CgbMhIrgxJqWW0YyGMC9Mim0l1soRDMKwECQVukWHCBwSruQP74ynNzGlh5sTOl0aSuSNznQSsuQ0top8BggiAIItQgJYBoE2ob/SsapqU82OxySwCnNAh3fk0GVrW4lpIIqNcdyOF0gWGUhTvhGYZpFkJNBlbmFqO2m6+GHvmTYVWCXxlxf5ZhdAXSSu+RVVICVDIGceOrBQb7IxpzmZBYlhHNq4Z0biWlUOsxSJUFf5QA0gGIlkAhAQRBtBRlB2aC8JOiH8tgdzgxapDcz92NegGrukYb1u44Ltohfv3jI6I2W/efRb/u8Yoj2wSuHJdrLdi67yyiIt0fcWGBLpORVUzTeelyg6I1Qa87EGcJMBoZWG3icUTuQGgulOVrhhwlxJYAFXcgRssdSLhjr08ylQq9ikqAUXlc7qVaYLA/AjXnDqRkCVBC6g5kVijgpqWOSC1G/rgDEUQgoE8eQRD+QpYAIqCs2ngMa7YUy87zMQEe4anJZpe1+XT3KXz7Qxm+PnqRP3foRIWozdb9Z/H6x0cV57YLLAHvbP0BXxw8z6cVnTc1k7/mjgmQu4yoBYUKBWstYc/psQQ8cWsWxg3rpjoGwzQLoUaD3B3I1x1iYftuXaIxelCqrI1aETCGkbsDCbl3aiYKxvSS9ZMOJXwu1w7uipyMZMzI6yO4Lv+q6ZEcq5hpyBc3mR6psbh3aib+Z1w/5FyVjJyMZF0CuZo7kJB50zIxIjNF1zqEz+3RW67RbPuH2cOQNzQNkQrWKIIgCIIIFqQEEMFBItgpFeaqbVQvmCVFKbOMMKiTK5BlMroLTKUmRuNXnmwtSoHBWnUE9KYIdThdYBkG/bp1wl1TBkqCgcWveXcgI+tz0Sz5+oRKCov50wehc5w4k46aJcAdKyA4lrQZNSgVs67rh3umDpT1UzuOijBiwU1DkCDI5sOw8rbxMWY8cWuWwv3ITqkyc1x/5A1NQ+e4CCyYNQSRZqPsPpVUO7XAYCHdusTgwRmDFeeVrlHogjSkb5Lmmvt174R7p2b6VfOAIAiCIAIFKQFEUJCKO0qJfJoscuuAGkoBvEJ3oCZP7IDTI5i7X7uvGwzywGAttxzfAoNV+klcdvjAYAOjmS9fD0pLqpcoVIxG1h+1dQLN96sVAwCILQGKefR1BC+rja2F0udAj4uVVIlUsgRo4e15EARBEER7h5QAIqhwQptTQXprtOpXApT6C92BuLFsdicvdPIZZBhGtvOvJYgL5T0tVxOH06UrqJdBsxBqNCqkCG1BdiAOqyRIWjU7kMp5YT/hv9Lz/DErVnLk86gdqM/pL0qFyaRI329fffql7UkJIAiCIEINCgwm2gQldyBf0oZ6swQ0eqwKVruDF0qFGWTkKTvVhThGY6dciNPlkuyIM+CcUUT9BO5ARgMLRuaw4mt2IB3ZfFSyA+kpDqa0JEaiMykVCxN3F1z3NlUL5Wnp81AaTuoO5KtrjpYlhCAIgiBCAVICiKDAyVhb95/Fj+cuY9TVzcGrG/ecgtlk4AV3f/n66EUc/rkSI69O5YN8FS0BCgKblguJ3piAy7UWdOkUyR9HRRhQ2+CUjyFyB2LBMi1L9qdHftXKDhSIHPfCQGtvlgBvArcvlgB/wym0YkD04Is7UITJgDof4l0IgiAIIhiQOxARdE6V1KCksoE/3vz1GXy062SLlQDAnWb0iwPn+WOrTdkSAAB3Tcng22kJhXpjAgCI7mHhbdn8a5nlQRAYLKsTEAB3oKfvyBFl51F3BwIizb7vBUiF4Juv7696TXpOevnhWUPw21lDmq/rVEqmjOyJcdk9vLZTUrGUlL67bxgoes847pySgadvzxGdk1kCNN60P8wZ5jVYmCAIgiCCDSkBRFCQCqrCTD4cTVb/qghzdOsSIztntTt595RmS4D7Yz9uWHf0794JgBdLgOC1t11q4X2mJcUgNsrkOS8eQ1gnQOqf7uu+vNKS+nfvhAk56c1zsuqWgNgo35UA4Zw5GcmIiTRprofRiBnIvioZWVclN69VpxZ0y/X9/d7RV+p33TXdcFWPBNn5Xw3rjv7pnUTnpM9SKw4hNTEa08f09mudBKGGVvV0giAIPZASQLQJDgUloKUobSBb7U7eH92p4A7E1QgW+uhL0VsxWOu6VPDllYAApAhVE5qlWX/UKgarZQ3SQih/SEdVskwIp/aaHSgI7vUtLdKmVSxNCcoGSrQa9OEiCMJPSAkggoL0Z8qmUpirJSgJwzabPCZAJLB5lsHleVfaIdZbMdg9nkrBMdF4khShUoHUZ3cg5fPC3WmGVRZU9WQzUlqS6C6lgbhKlgChO5C3uYKgBQRa8fKmSFFNAIIgCKK9QUoA0Sa0hiVASXh0uly8AKYVGMydU8oSJI4J0F6DVAXgTPayisHCYmEydyDfBEY1AVN4n1qWAH8QuiJIh1BSlForMNhfWlybQZodyds90TctQRAE0c6gnyYiOEhkJHurWAK0z8dFu/3WIwXVYblVsB4pzaDoDiQYy8sutZqbrtQdxmRkwXjmkwYGS6v9AsoVkr0hXKtBIS2qe12+j8vFOXBIh/BqCVCZMibSHZsQ8HSbCm9KS7MDJcVHio69rdlXxY4g9EKfLIIg/IVShBJBQSoEKQUGt4Qldw/H2h3Hlef2SJ135mdgYM/O6Nstnr/GyYecEKcWPMshdPu46bq++HT3KV3rE7vDMBh7TRrSukS7s/YYDcgbkoa9R0sBAE/cmiXr/9x9I3HgeDlSO0dh5afHdM0pjQlQVCQ8p5beMxzVdVZd4978q/449HO56nXvMQHKYsuDMwfjxC/V6JMWpzn/k7dmweylwu/js4fJlBUhLXUHenDmYBw+UYFNX59GVY3Fa4EyKiZGEARBtDfIEkC0CYFUAjrFmNGra5yqLzknc0ZHmvCrrO7KQqqnr1oaTWk7ABg+MEXWVjVjByN+3aVTFEZd3ZU/NWaw+3VifISiJSC1czSmjuqFnAz5nHpgWAYmg1xw5m6nZ2ochvbznsZyRGYKIswGkd+THn93rRShHIN6J2Lm2L4wGbUF/IG9xIqc4lh9EtGrq7oy0VJLQHy0GWOv6cYfU2AwQRAEEWqQEkC0CYF0B+IELLUPs7aQKo4T8GYJYFUUAn40He5ASvIiN1ZrZf1jGcBk0s58pImkmSg7kI4hpJaQtqalSoAUrToBAAUGE+2TsxdrsWbL94oV3AmCCH9ICSDahEAEBnNiFSdgSYVyLuuOHk8MLZ9u4RWWVVYIONR+SsVCoHpgcmvBsgzMXjIf+YIL6oHBSogDg/2bM5C01B2Ig7sVr6lj28E9tyanT5/G7NmzkZ+fj9mzZ+PMmTOyNnv37sWsWbMwePBgrFixQnTN4XBg2bJlmDhxIiZNmoQNGzYEaeWhSyA2DFZ+ehT7v7+Eipqmlg9GEETIQUoA0SbYA7DzxLvweKRK6W5rhGfnW2sXlvshlY4lRBwTIPazVxhRcR5xmlH59WZLQOvsyLEMo5L+1D/pVLxM72PoCQwOJgG3BHhVAtrBTbciS5Yswdy5c7F9+3bMnTsXixcvlrXp0aMHli9fjnnz5smubdmyBefOncOOHTvw4Ycf4vXXX8f58+dl7Qg5Yf7RIgiiFSElgGh1Fv3tG/zry59F50oq6ls8Lic48+5AEkGMCx7V+pFMS4oGIMh4oySgiwR4YbpQ7+5A3LFI2Facw6MEqC+1RbiVALmvvV75QerCEx9jbr6myx1I+Dq4UovSM+0Ua1Y46w/qsSSiVmEsqFVWVqK4uBgFBQUAgIKCAhQXF6OqqkrUrlevXsjMzITRKM9HsXXrVtx8881gWRaJiYmYOHEitm3bFpT1EwRBdFQoOxDR6lwo1y/wP3lrFl5cd0hXW7klQHydy4ajJXTeOWUgRg3qikaLHQBgsTpkbdQqBivt7qq6A6mMx2HwMybg4VlDdLVTdwdSfjYrHhyNhia76niD+yQiLSkapZUNuhQJUWCwjvatxfVZ3TG0XxIGpCcEdNyObAkoLS1FamoqDJ7Ac4PBgJSUFJSWliIxMVH3GN26NQdap6Wl4eLFiz6tIykp1qf2QpKTtTNStWdiYiIU16/nnriUyEmJMUhOign42pQI1WdN6w4utO7gQEoAETCcAgnW6XL5JfhoZXSRIhX+pfNxMQFaSkCEyYAhfZPw49nLAIB6BcFXbRdbcfdXLTmQFyGYz2zkoxYwIL2TrnYs45sLTHJClOZ1hmEwbEAXlFae0yXV60kRGgwiTAZc079LwMf1WicgjJWA9kJlZZ1fAa7JyXEoL69thRUFh/p6i+L69dwTF5tVWVUPgzPwBRylhOqzpnUHF1p34GBZRnODJGDuQCtWrMD48eORkZGBn376iT+vJ2CMCA+EP8D+ZpvwJUDWwIp3+qVKAJfTX8+QXCExziIgRE2AU9YBlO/bmxDMWwK8LVSlnzcYVjkmoCVwLkJ6sv20l5iAQOfrV3NFa+152xNpaWm4dOkSHA63Fc3hcKCsrAxpaWk+jVFSUsIfl5aWomvXrho9CIIgiJYSMKlgwoQJ+OCDD9C9e3fReT0BY0R4IBT8/Q1wNfqQtUUaEyDFoMMdiCMuRt1HXE1+UxxXGhOg0FZpOD8NAbp3mNUCg31FKTWo7zEBLV6G37CtFAXVkWMCkpKSkJmZicLCQgBAYWEhMjMzdbsCAcCUKVOwYcMGOJ1OVFVVYefOncjPz2+tJRMEQRAIoBKQm5sr2/nRGzBGhAe1DTb+tb+WZV92TFkvu7AGL0qCkNhI9eqyqpYAhXnVDCDehGB/swPptQSwDAOzlyJcWiit2TclgFF8HRQEj7S1fPO93VO4uwMtXboUa9euRX5+PtauXYtly5YBAObPn4+jR48CAIqKinDdddfh3Xffxfr163Hddddhz549AIAZM2YgPT0dkydPxi233IIFCxagR48ebXY/HY7WKlBCEES7plVjAgIRMEaEBj/9Uo0/fXCQP3YG4UeFF/JV3FG8XRfCCeGpidG4VNUguqYkv3VPjlERwFVShEJbCDb4uUWtV2kysAwS4+WViPWSFB8JQBqzwUj+VUfkDuX3KlpOW7nlhLE3EACgX79+irn93377bf51bm4udu/erdjfYDDwigMRPMJcNyUIwgshERjcUbM+CGnv97HnmDiTR2JiDGKjfU/DKL3PSSN64sezVfjlUp2srcmTAtRsMiA5OQ5ms/jjHBlhEl33xttPT0RslAm3LvpcdL5z52hR/zVPTUSnWDMizMp/PsK2nPDXOTGaP5eQEC1bjzGCS1HK+PRep6bE6xJsU1LikN49Aa//4Xr89uUvFdeqRXJyHP6SHIfeac3zxXhcqKKiTKJxlMa0C4rDpaTE65pTL97uwRzR/D7Fx0UG9G+Jy66S2Lk5s4rS+JENVs3rWucJQonWqilCEETHoVWVAGHAmMFg8CtgDOi4WR84QuE+aussouOy8lo0+qEElJfXgkHzfnpqQiRq62IUlQCX5zPhcDhRXl4Lq1Uc1NscqOjU9fwMABrrLbLzNVca+f7JyXEwupyor21CncKPsMslzsrBfWyvVDcqjsdR6xESnU6XT+91ZaX8uai1MxpYxBjFCoMvc8WZWdF8jZ41W5psonGUxhT+/Qbys6znb8MqCPZubLAGdH6nx++tqqr5uSiNL0y3qnTdn79xb1kfCIIgCEKLVi0WFoiAMSI0kO5KtaQgsNRdRs1k7TUwmGU1r/u7Hq3zcr3AJV+DwnAGP2MC9NIabjC++Lm3F7eD1vLN9/autZf7JwiCIAiOgFkCnn/+eezYsQMVFRW45557kJCQgM8++wxLly7FwoULsWrVKsTHx2PFihWBmpJoR0iFfn9ThAIegYmrtCv4vxRpilBfr/u0Hp2opwjVTpHJrbE1KwYHGl9GbC+BsYFehp54EyC8i4URbUt7+dsiCCL0CJgS8Mwzz+CZZ56RnVcLGCPCC+kOdsB2tBlGNajSm2DVXFG4pUvwSQvwPp6C4MhPEUpuviEiewgfaVstubVSkxJEoLFYHXh/+4+YPWEA4v1w6SQIInSgnyYiMEiEV0cLLAFC15WeKbGqkpt3d6DgWAKuElTtVbtrbylCufoIIzJTfFyd7/RMCYwfOX8bIbQTGehd05yMZABAjCfFbGavzkGZlyACifB76+tjpdj3/SVs2nO6zdZDEERwCInsQET7R5oStCUpQk0GFja7E3fmZ6Bf907Y9d0FxXbecuT7UidACy2Lwxu/HwsXgN++ukfxOvcYvLkDGQ0sXvvdWERF6M/l/9rvxupuK+T/3ZmDB17+yq++QnjBtp1nKRGFYwRYFv+fcf1ww6heiI0y4Y3fj4XZpPz+kTsQ0R7R685GEER4QkoAERCkcmBLYgJMRhawAJ00qvgCAONFCWCDYAmIjjTBanP4NIbaD29slHrBMiViIv378zW1oGiYkFCUawO9I8+yDP++RWsWnAvotARBEATRYsgdiAgI0oDYlmQHMhk9WX28FQNjtMKGmy0BLY4J8LJbpiVYuhTaBEogJBcT32mrol30XhEEQRDtDVICiIAgtQS4WmoJQLPApppxh2sQ4JgAqeuGt+56hg9HGZB7Tu3bGUiyvnB8I4gOSTv3wiMIIgQgJYDQ5OipSjicTtG5sssNuFBRj9LKeuw9Ugq7wyn7Qfru5wq/4wKalQB97j7ervsq9xkM4g5e16FxnbsiVETCxj88BG8jXB49QXDQR5ogCH+hmABClaOnKvHKvw5j5tg+uPHaPvz5hav3AwB6pcbh7KVaJMSaZSlBP9l9CjGRRlyfna57vt5d4wDodwdiGe3rzcXCfPuZNBoY2ATFh1tiCXAptQnir3buwBQU/VgmOz/i6q74tvhii8aWPvdeqXGouNKo0rp90NYK2PXZ3dt0foIgCILgICWAUOVyrQUAUFHdpHi9ut59vcFiVzRNV1xR7idkRGYKvv2hDNPH9MZN1/UF4M4OJETNHai1sgO5lYfmYF9vSoQeJUMcExA8QfShmYMVzy+aNxLl5bUBmYO7myX3DA/IeK1JW6oA7ywc34azE4QG5FpEEB0ScgciVOHcedQKHXHCusXqUHT90fO7wgnEQrmYy15jtzuVugj6ao/NerEkqCFVHloks3MpQgWnwsV83xyzETpQgC5BCKA/B4Lo0JASQKiilONeCOe2Y7XLYwLcA3ifgxtZOAc3rs2jBKi7++gNDPa+DlE/g1i6DYgLiZdiYSFJiNyI0FUtRJZMEK3KuUu1qGu0tfUyCIJoY8gdiFCFy/Wvlo+ftwTYHLKYAEDdjUeEwm67VAnwlh3IW4pQXzF6TB/8rAEQHNk2cgdqTULxLsLk0RNEi1j67n+R2jlKs00oWfgIgvAPsgQQ+KWsDj+cqZKd592BVCQnbsfcYnXAoZAS1OUCTl64omsNjJIlwKHtDuQtOxC3Pl+zFEmzAwUCUUxAwEdvI0LwRsJFASOIlnLpsnIQP/2FEETHgZQAAkve+RYvrf9Odp7L9a8mN3GZQy02hyyNKMfyfxxQnTc3I1mQQrP5/PVZ7gwqV/furLlurliYmpLCKQm+Ziq9aaw7QJmvWKyjf1SEslGNs2IwAXQHumlsHyTEaldTDgZ8nYB2vmU4KbcH/5p0AIIgCIJwQ0oAoYrTi088t/tvtTlgdyhbArR46KYh4PadhDu0fdLi8c7C8ejSSdtczQn5JpPyx5hTEpw+Fi7LHZiCdxaOR4TZHaCsp/dfHsnTvM4EUAuYfm0f/Plh7fmIZgb26ozhA1MAtH2KUIIIFO1c9yYIIgSgmABClebsQMqCExcHYLE5VbID6f+Z8kc249YV4ckmJMXgiVlQpeI/4QAAIABJREFUilfQtSbPv3r6e3NNEl4NF807INmTgoS/nwGCaK/wn+kQ+PsjCKJ9QkoAoYrLS0yA0BKg9ENk85LiExAIkn78knmzBPjrDsTjg3TrbYe5rYqFtSZMiLgDAc27pmQJIMINf747pYTAnzBBEK1AuGxKEq2A01tMAG8JcMCh4A5UU2/VPZdfiXw8U0qLi3Fw2YF8DQzmaLYE+NVdPJbgIYaLIBpKd+GrSxhBdARC6W+YIIjAQ5YAQsSPZy/jcp0F58vr8Pn+c/z5j786iRtG9kJ0ZPNHhhOsLCqWgEMnKrzOx3fzQzC2e7IHmU0q7kAttQQEAj6uog3X0FqE0D3xnhNhooARBEEQREshJYAQ8eK6Q7JzRT+W4dLlRjQ02XFHfgZ/nncHsjthVNmNV6JblxjkZiS7D1rgV87J9maj8ty9UuPQPTkGeUPTfB8cwN03DMSGXT8jxUs+bY5h/btg1KBUxWuiFKEkiAadWeP6oqq2yWvGKYIgCILoKJASQHiFE7YtNofoPOdmY3c4veb0F3Ljtb0xItMtLHP+rP64yER6sveYVJSA9JRYPDdvpM/jclzVIwH/745c3e0f+fVQXe1IBwg+6cmxWHrPiLZeBkEQBEG0G0gJILzC7fJLfes5dyC73Qm7Qb8SYLXJ2/ojGHOVfdXcgdoToorBbbgOgiAIgiAIgAKDCR3wAbZOZSXA5nDy/vl6ULIa+OMiw2UfUnMHag/wT0xUJoDUAIIgAkNdo611Bg6FtF8EQbSI9is9Ee0Go4HLsiM+z7sD2Z260oFy2IVtGdE/PmG1u92TQsESwKgeEARB+A4Xk7V1/9kWjyWqo0GbFATRYSAlgPAKV3SrscmGVzcc5s87eEuAyydLgN3Z3JaRvdAPNz8XE9Aef7u4NbnQfIvhkiK0GdoxJIhg4wpE2tuw+y4iCMIXKCaA8IrR4w505mIt6pvs/Hm7XRgYrE+fzBuahl8N684fM35YAoYPTMGIzFT07x4Pk5FFbkYKAOD2yRnoFGNG18RopCZG+zBi6/H07Tn49oeydu2y5C8kPhAcp0+fxsKFC1FdXY2EhASsWLECvXv3FrVxOBx4/vnnsWfPHjAMg/vvvx8333wzAKCyshJPPfUUSktLYbfbMXLkSDzzzDMwGukniiAIorWgb1jCK1zlXaECADS7A9nsTph0BgbfOzWzxevJG5qGIX2TAAB3TRnIn+8cF4E7BcftgZ6pceiZGic6R5tvRLixZMkSzJ07FzNmzMCmTZuwePFivP/++6I2W7Zswblz57Bjxw5UV1dj5syZGD16NNLT0/HWW2+hX79+WLNmDWw2G+bOnYsdO3Zg6tSpbXRHBEEQ4U/4bU8SAUcrkJVzbWmyOlTb6MEXw7ZSdeJQgqE9dCKMqKysRHFxMQoKCgAABQUFKC4uRlVVlajd1q1bcfPNN4NlWSQmJmLixInYtm0bAPd3TH19PZxOJ6xWK2w2G1JTlWtuEARBEIGBLAGEV7RE1ggzi0aLQ5Y+1OfRfejucOqPP2iPkCWACCdKS0uRmpoKg8EdoG8wGJCSkoLS0lIkJiaK2nXr1o0/TktLw8WLFwEADz30EH77298iLy8PjY2NuO2225CTk+PTOpKSYv2+h+TkOO+N2jFK69dzT1zSh8TEGL59XGwEACAyytwqzyVUnzWtO7jQuoMDKQGEV7QsAWajAY0W/60AjO86AB8QHKqQEkAQYrZt24aMjAz8/e9/R319PebPn49t27ZhypQpuseorKyTpTHWQ3JyHMrLa33u155QWr+ee7J7rKpVVfWI8Hwv1dZZAABNjdaAP5dQfda07uBC6w4cLMtobpCQO1CYYLE58NSa/fjpl2qvbRuabFj41j6cuVjT4nkjzC1Lz+mLPMzVKwj17DrkDkSEE2lpabh06RIcDvdmgMPhQFlZGdLS0mTtSkpK+OPS0lJ07doVALB27VrceOONYFkWcXFxGD9+PL755pvg3QQBALDZHfjH9uNtvQyCIIIEKQFhwoXyelyqasCH/z7hte2P56pRVt2IzXvP6BrbpeHqEyHI0T+sfxf8/uZrFNtlDeiCZfeP1prE6zpuGd8fN43tg+yrkr22bc+EuA4jQ68n2ONzhql+PojQJSkpCZmZmSgsLAQAFBYWIjMzU+QKBABTpkzBhg0b4HQ6UVVVhZ07dyI/Px8AkJ6ejt27dwMArFYr9u3bhwEDBgT3RkKMQNhDpV9Fx05XKbYjCCI8ISUgTODdanT8MnBFtkw601Zq+fubTc1jDO2XhKH9khTbDeqTiGxPKk8RPkjEkSYDpl/bh89WFKqEixLga+XjQb0TVT8fRGizdOlSrF27Fvn5+Vi7di2WLVsGAJg/fz6OHj0KAJgxYwbS09MxefJk3HLLLViwYAF69OgBAHj66adx4MABTJ8+HTNnzkTv3r1xyy23tNn9tAculNdhwStfoaqmqa2XQhBEmEIxAWGGnt0hrrqv3tz1Wn62QkuAllLhTTkJbS9/3/BVeCaI9k6/fv2wYcMG2fm3336bf20wGHjlQErPnj3x7rvvttr6QpF/H7qARosDh05UYEJOuux6a3+LdKTvZILoqJAlIExotgR4/+q2e5QAqdCu1lcr1k6oBBgNWkqA8iAMf119Dlljol2g57NGEARBEET7hJSAMIHxIdWm1aMEGGVKgHJ7vZYAbSVA5YIvgn2oy5xcdWRSZgiCIAiCaGNICQgTfEm12ewOZMDfCov582q+/9oxAUJ3IHXplnaNgdTO0QDCJzsQuTURBEEQROhCSkCYoUfWtjua3YG+PnZRsW+XTpG4Y/JVALQtAcK4AoPHErDk7uH47f8MEa9Lpb9PYmSIy5xPzs3Cb/9nSMgHNhMEEV7QHg1BdExICQg7vH+bW3XEBKQnx2LcsO6e8+pjmQTZgYwe4bZX1zj07dZJMraXVXeAX6GE2AhkDQjt9KYEQRAEQYQHpASEGXpkac4dyCDZkZb25bw9tNyBhIW7DIKYAL2eIpxrTPirAOELvXcEEZqQRx9BdGxICQgTOEHdl5gAqXDvEvRmmGafby0loMnq4F8bDc2/KNKqvqo7/fQjRBAEQRAEEXRICQgTOBlbj1sNrwRIfP2VujIK7YQ0We38awOrbgnwuiraTiYIgtANfWUSBNFSSAkIEzhBXZc7kCcwWNpWqEDwmV8Y7ToBiXGR/Guhe5E0A463OgEEQRBEM96+G+m7kyCIlkJKQJjAWwJ8aCx18xEK+9wPDMswcGloARNymytZCt2BZJYAL+mB9K1bTyOCIIjQwe5w8hnbfIK0AIIgWggpAWGCs9kfSH8fmTuQghYA9ZiAIX2TYBIEAwvdgWQxASpraC5yRhI+QRAdj4df2Y3fv7a3rZchg76SCSL8Mbb1AojA4PIhMJhrI3cHan7NifAMw6gqASYjK3IB0rYEBOAXhXa+CIIIM6x2J5+2ua0geZ8gOiZkCQgT+E19Hd/mnDwuyw4k0gIY/h+HijuQycjCaJAXC3P38y0ymNyBQhh6XwiCIAgi5CAlIExwKvj5V9U0Ke7ic8J+k8UhOl/baONfs81xwapmYZOBFVW/FQUGS3QANWsC5akOXeitI4g2hJRvgiBaCCkBYYLU3abscgP+sOo/+GzfWYW27n+/OHhedH7x377lX/fr7q74yzCMKHZAKOgPSBdXBdaqE9AjJU5x3b27us937xKjeF0ESZ3tCpJBCIIgCCJ0oZiAMEEaF1x5pQkA8MOZKkwf01vUVqv4V5dOkegUa8bEHE/WH0asYBgNLBxOB7KvSkbe0DRRX7U6Ac/NG4HuybGK840a1BV90uKRmhitdXtEe4aUM4JoNQIST0UQBKEAWQLCBL5OgGd/lgszk/nmQ1sJcLmArp2j+X4sI27PWQJSO0fJxmZF7kDNr7smaQv4pACEOCSjEETQoT87giBaSlCUgNOnT2P27NnIz8/H7NmzcebMmWBM26GQWgK43P6swi6t1saSCy6JcM/AKUhcwQn6vvwAKSkiROhD7ypBtD5q35/090cQREsJihKwZMkSzJ07F9u3b8fcuXOxePHiYEzboVAr/KX0A6JlXnY4XaJfF6klgPf790ELoB8rgiCIABPIL1ZyOSKIDkmrKwGVlZUoLi5GQUEBAKCgoADFxcWoqqpq7ak7FHydAEmWIFbBFKD1fW+1OWTWA2lRMV8hS0B44yLHBIIISei7mSA6Nq0eGFxaWorU1FQYDAYAgMFgQEpKCkpLS5GYmKhrjKQk5aBSPSQnK2elCTW83UdcSS0At9CfnByHuEt1AIDICJOsr9FoUB2nyepAVJSZ72MwsHC57Px1Th+IjJKPq7ZG4Xl/3o/ISBMAID4usl28n+1hDYGgpfcRHx8JwP3+tOUzofeDaE/Y7E5cqKhD767xbb0U3yF9niA6FCGRHaiyss6v3ejk5DiUl9e2woqCi577qL7SAACwO1woL69FdXUjAMBms8v6Wqx2WX8OlwuwNNn4Pi6XC8JHb7O7aws0NFhl46qtkTvv7/vR1OSuX1BT29Tm72dH+kx5o6bGnYGqSfB5CTYd+f1gWaZFGyRE67Bu50/Y9V0JVjw4GskJUW29nBZAGgFBhDut7g6UlpaGS5cuweFwC48OhwNlZWVIS0vz0pPwBackMphzC5Lm6xe1VUFoIpaaix0O+mEgxDAU9UEQPKdKawAADU3qmy0EQRDtgVZXApKSkpCZmYnCwkIAQGFhITIzM3W7AhH6cHky+HAiOvevksunt7zTwj7S7nZSAggJFBNAEK0H1QkgCKK1CIo70NKlS7Fw4UKsWrUK8fHxWLFiRTCm7VA4eQuA59jjw6OcHUh7LNHOrjRIWDIP0YEhAwBBoNFiR3WdBWlJOqqe+4BXCxt9BxME0UKCogT069cPGzZsCMZUHZaDP5UD0M4OdOB4GQb3TfLJEqDkTgTQ7i9BEAQAvPjPQzh7qRbvLBzf1kvxG/o2J4iOCVUMDgNKK+tx6ESF6FxzTID7+HRpDVZ+egz//L+f4C3GWittXNaALrJzA3smID05sLtgQsYM6goAuKpHQqvNQfgO936M9rw/BNEROXspdAPTyZhHEB2bkMgORGhjsTn4183uQO5/OYG+weIOUqu40iSzBMTHmFFTb+WPGUmxMI6Vj16HPUdK3QqHYIgn52YH4C7UyeydGNK7bOFKaudoel8IgiAIIkQhS0AYIPQd5QODNbIDeY0JEHVhROe5IzIfEwTBcfr0acyePRv5+fmYPXs2zpw5I2vjcDiwbNkyTJw4EZMmTZK5iG7duhXTp09HQUEBpk+fjoqKCtkYIUEIfjm6XIELQD5VUoM3Pjna4iKTBEG0PmQJCAPEQrtL8P/ma7zw7nLJUoRK1QRxilDJedICCIKQsGTJEsydOxczZszApk2bsHjxYrz//vuiNlu2bMG5c+ewY8cOVFdXY+bMmRg9ejTS09Nx9OhRvPHGG/j73/+O5ORk1NbWwmw2t9HdtIxgfTUGcp4l73yL665JwzX95O6evvLWpmOouNKEypqmEK+TQBDhD1kCwgCh0O6UZAfiAoOFgr737EDCscXnyYeUIAghlZWVKC4uRkFBAQCgoKAAxcXFqKqqErXbunUrbr75ZrAsi8TEREycOBHbtm0DALz33nu49957kZycDACIi4tDREREcG8kwGiEVrUbbA4n/3r34dI2XAlBEG0BWQLCDU4J0HQH0l8sTNhUdJ5MAQRBACgtLUVqaioMBgMAwGAwICUlBaWlpaJ6MKWlpejWrRt/nJaWhosXLwIATp48ifT0dNx2221oaGjApEmT8Jvf/EYzSYGUllRPTk6O87uvdAyj0b231rlzjE/jSttGRZkAALGxkV7HUbquZ26HxGUnvlPzzn1kpNmv58Ia3PefmBiDZIW0qYF41m0BrTu40LqDAykBYYDQ95IT/pvrBHguKFgL1BD+7lZcaRKd536USQUgCCJQOBwOHD9+HO+++y6sVivuu+8+dOvWDTNnztQ9RmVlnV9+6MnJcSgvb3mGH24Mu929u375cj3KzfqN7dI1NDbaAAC1dU1e16d0Xc89SZ/XT6crBfNb/XouTo91oaqqHganU3QtUM862NC6gwutO3CwLKO5QULuQGGA0Mef+1J3qBQL0xMAprb5JjpPWgBBEHDv6F+6dAkOhztLmcPhQFlZGdLS0mTtSkpK+OPS0lJ07epOL9utWzdMmTIFZrMZsbGxmDBhAo4cORK8m2iPeKsV1goVGzfsOhnwMQmCaL+QEhAGCHdzOOGfjwlglGICxD8e0mO1SpVeK1gSBNHhSEpKQmZmJgoLCwEAhYWFyMzMFLkCAcCUKVOwYcMGOJ1OVFVVYefOncjPzwfgjiPYu3cvXC4XbDYb9u/fj4EDBwb9XtoVtNFCEEQrQ+5AYYDUr1N4Trqr70JzDQEOaXctSwBXN4B+nwiC4Fi6dCkWLlyIVatWIT4+HitWrAAAzJ8/H4888giGDBmCGTNm4PDhw5g8eTIAYMGCBejRowcAYNq0aTh27BimTp0KlmWRl5eHX//61212P+0J2nohCKK1ICUgDJDu5DucTl4J4LMDNecIlQX1SpUItWC8/9/evYc3VaX7A/826R1aSksprYCMqFgVcAbOoDMjg5WbRxCdIzIHdWYOCp7Rkd+gg9aDXCp4pDgOAoKMqCAjx0sHASlYgSkKyF2g5X5tKaXpLaX3Nk129u+PXLqT7KRJmiY77ffzPDy0+5KsnaQ7613rXWuZpggNkX1OIuq6Bg4c6DDvPwCsWbPG+rNarUZGRobs+SqVCq+99hpee+21DiujvwTTrbEjZjAKpusn6uoYBHQC9pV4g0G02XamsAp7803Tv4lwvEnbDw5z9cXAVikiIiKi4McxAZ2AfSVeLxit20RRxF8/P4FDZ8pMvwMOi4U98cBAm99dTcs34s4kDL4lARN/MaD9BSci6nS6dlN4MKyPQEQm7AnoBOwr9XqDEYI58V+ua1a67bWnfoYmnWCz39U9PCoiFLOeGOptUYmIugRP1jggIgoE9gR0Ag7pQELrmAD7AAF2U4TGRoc7zg7E7y4iIkXoyH4F3uqJujYGAZ2A/Ww/Bpt0INt9IkSb9KGY6DCHY+RWGSYiIj9q523YIBjbPohhAFGXxiCgE5BPBzJvayMdKCoi1LG3gN8LRESK1lYPQfmNJr+Ug4iCF4OAIHT4bBnW55yDQTBi6Zd5KCiptdmvl6YD2X9ViLCZIjQkJMQh/YeLghEReaezDAvuLNdBRM5xYHAQWr3lNADg1/fchJNXtDh5RWuz32Bwng4EmBYH69e7Ox4c1hcAMGRgAsb/vD/2ndSgvklvXRCMiKgz02gb0C0mskMeu6veRrlOAFHwYE9AEHNI4zEzCKJ1n/2gX9G87a4B8Rg5NAUAoFap8ETarejRPdx0EMcEEFEXMGfNIcz9+/5AF8M7Pqhsd+Stnt8iRMrHICCIOWtxsV8nQO48uZu/OsRudWEiok7uQlF1oIvQKbFDgEj5GAQEMdHJbdZgMMIyLrhFbztDhCiaFheTm8M6xJwHxNmBiIi81MVrv/z6IAoeDAKCmKueANEcBTS3CHZ7Rec9ARwMQETkG7ydEpHCMQhQOINgxPNLcvG3L0447JNL9QGAjd9fxo8XKgAAzS0Gm30FmjoYRVG2tV9l7Qlob6mJiMgnOrBnwd1W+wvXqjFtcS4qqzntKFFnwtmBFK6h2YBrZXW4JrPPPgZ4fNRA/PO7y6iq1Vm36Z0sGCN38w9Tq8z7fBMFpD/5M6eBChFRZ+TuHU8URbz92XGn+5XUFrM3vwQAcLboBu6PiwpwaYjIV9gToHAGg/NVH+0r2P92R2+HY6SrA0vJ9QSEh5o/Dj769rm9XxwG9e/pmwcjIgoibd1GRQDn2jEoWanNK2z3IQoe7AlQOGct+YDjzTZU7RjTCYL8HVm2JyBMDYADg4mI2nLoTBnWfXOuwx4/2OvS/BYhUj72BCicJz0BYaEyQYCTngC5lJ9wmfOJiMjRF7kXodPbT7zQATp0Ln8PHzzYIxMissFan8K56gkw2FXwQ9WON3T7YyzkGvstQYCzwIGIqKvLv1yJmnpd2wcGmAjn6aBuP4CZx8ECGC8QBQOmAymcQRIE2M/qs/TLPOvPqpAQ2Sk+BSdBhFzeZlioKR2oxR+tW0REQejdrHwk9XQ+OFYpkyG8v/kUSiob8HF6ml+fl9mkRMGDPQEKp5ekA7lq1VGpQmRTfJy16htkgoPwMNPHocVFChIRUVdXdqPtqTIrqpv9UBLnSiobZLfbBCmssBN1aQwCFE5aWXeVpqNStc7zL+XsHLntljEFegN7AoiIvKHRNgIAlm/M980DKqNjAYCiikJEPsAgQOH0htbbrqueALUqBKqQEIeuWGfpQHJBQLg1HYg9AURErrS3QmzfZCOKIgo0tU73dwS3n4M9BkSdEoMAhbMfE+CMZayA/fSeTnsCZKYOtfQEMB2IiMi/9uZrsPCTozh+sSLQRWkXhQyJICI3MAhQOE/GBABwGBzsPB1IZkyAJR2IA4OJiPzKksNf7sZ4A0A5A5CdYecBkfIxCFA4m54AN4IA+3EBzhYLkwsOkuKjAQApvbp5XE4ioq7uRl1gpg5dsTEf150MBCYicoZBgMLp3RwYHKqSTwdylkIkFxzc3i8Oc38/HONG9LduW/rirzwqLxFRV2B/D62qbcbrHx5q9+N608B//GIlPslxb/Vim4d3cz5PtuoTdU5cJ0Dh3B0ToFaZ4jm5GYLkyKUDAcBPkmNtfu/RLdytxyMi6krs76F/WbU/QCXxXkdW7pWdrEREAHsCFM/dMQFqtfyYAGcMTtKEiIiobU06z8ZOnS2swvJ/5sMoirhUXIN/fHu+g0oWWFwsjCh4sCdA4dxdJ8DzngAGAURE/rJ840no9AJa9ALe2vCj22k/bt+pfXxLF9mWT9TpsSdA4Qo0ddafXdXbQ9XyYwKccbZ+ABGRpwoKCjBlyhSMGzcOU6ZMQWFhocMxgiAgIyMDo0ePxpgxY5CVleVwzJUrVzB06FBkZmb6odQKF6Qt6gqftIiIJBgEKJiuRcDpgirr7+6kA6ncfEdTB8S7XY5ukewwIiLn5s+fj6lTp+Lbb7/F1KlTMW/ePIdjtm7diqKiIuzYsQNffPEFVqxYgeLiYut+QRAwf/58jB492p9FV4z2ptF403Lfkak7QRrDEHUpDAIUTGeer3+AebCu6xWDLelArt/S9/58P5b+6ZcYM7yv2+X46/O/xMpZI90+noi6Dq1WizNnzmDChAkAgAkTJuDMmTOoqqqyOW779u2YPHkyVCoV4uPjMXr0aOTk5Fj3f/DBBxg1ahQGDBjgz+I7tWbraUxbnOv35/U6DYct8ETkITbxKphlPECfhGgUampdzg4U6ubA4OjIMI/LERGu9vgcIuoaNBoNkpKSoFab7hNqtRq9e/eGRqNBfHy8zXEpKSnW35OTk1FaWgoAOHfuHPbt24f169dj1apVXpUjIaG719eQmBjjsO3A6TKn+7x5XEure69eMQiBY509OjoCANAtOgKJiTGIjjLNzNa9e4RsGey/DkLD1LLH2W+TjgdTq503GkVGhlnPjTR/bzgri5SlVzo+oTsSzWvPuCpPsGC5/Yvl9g8GAQpmuVmHh6ltfpdj7QlgHywRBRG9Xo+5c+firbfesgYS3tBq6132lrpSUVHX5j6jUcSJS5VeP66lUWfH/iuyjfZNTS0AgIYGHSoq6tDYaPq9vl7nsnzWx9cLssfZb5O+Rq7GhjU3663n6nR6AEBdXXObZbGsn1ClrYdKsJ1BKTExxq1rURqW279Ybt9RqUJcNpAwCFAwy5dGhDkIcPUFZx0YzCiAiPwoOTkZZWVlEAQBarUagiCgvLwcycnJDseVlJRgyJAhAFp7BioqKlBUVIQZM2YAAGprayGKIurr67Fw4UK/X48zOYeL8M/vLnt9vmVa5g+zz3p0nrt3dGYDEZGnGAQoUG1jCwo1dahtMLUEhUuCgBrzNntqJysGExF1pISEBKSmpiI7OxuTJk1CdnY2UlNTbVKBAGD8+PHIysrC2LFjUV1djV27dmHDhg1ISUnBoUOtK+2uWLECjY2NePXVV/19KS5pa5oDXQSXlDYrj8KKQ0QyGAQo0BvrjqCqVmf93ZoOJIqY/5H8svSW3E7eeInI3xYsWID09HSsWrUKsbGx1ik+p0+fjpkzZ2Lw4MGYNGkS8vLyMHbsWADACy+8gH79+gWy2Iqk5Hu4O2VjOxRR8GAQoEDSAAAAwsPMFXyjiNpGvc2+xLhIVFQ3I5RpQEQUIAMHDpSd93/NmjXWn9VqNTIyMtp8rBdffNGnZfOVjq6cHz5b1s7n7cgSuv/9orQeCSJyjlOEBoEIFwODQ809AJYZGRTdjEREFKw6uHZr3/jTURPt+2slYDZLESlfu4OALVu2YOLEibjzzjvx6aef2uxramrCn//8Z4wZMwbjx4/H7t272/t0XZJ1TIDMl1CYNQiwpAMxCiAiClaiUprSFVIMIuo47Q4CUlNTsXTpUutCMVIfffQRunfvjp07d2L16tV4/fXX0dDQ0N6n7HLCXcwOFBpqDgKYDkRE1GXYBwttxQ56g4D//fRHXLhWY90W4mkCPwMDok6l3UHA7bffjltvvVV2pdpvvvkGU6ZMAQAMGDAAd999N/bs2dPep+xyIsxjAlylA4VaXn/epImIfE4pt9a8S5VoaNY7bG+rfKcKqnCpuAZvf3bco+fTtQjYk1cCAGhuEbDyq5Oorte1cRYRBYMOHRhcUlKCm266yfq7dIVIT/h6JchgY+kJ6N490mFfdJRpJceYGNNKjqKThp2H7huAU1cqA/56BPr5faEzXAPA61CaznIdnZUSsnRqG1uw7J/5uKN/HPr1ifXLcx49X279+eDpUhQUvxgpAAAgAElEQVSV1yMmOgy/G3+HX56fiDpOm0HAY489hpKSEtl9+/fvb9cKj+7ydiVIJa7e5g1LEFBd0+iwz2AwrcioM6/uWFsvv47A4yN/gsm/viWgr0dneD86wzUAvA6l8eY62loJkoKTq2DDYDAtIFl2o8kxCFBAkCKlsOIQkYw2g4BNmzZ5/eApKSm4fv26ddEYjUaDESNGeP14XVVEqPPZgSxfGJa0ILlu4pAQL3I/iYhIQjnV2ht1yk3H4VcNUfDo0ClCx48fjy+++AIAUFhYiJMnT+L+++/vyKfslCw9AaLoeIO19JBYpgi1LE0vxVWEiYi8oze3vgeMEvKQ7LgqkQKLS0ROtDsIyM7OxsiRI5GTk4Nly5Zh5MiRuHTpEgDgmWeeQW1tLcaMGYPnnnsOb7zxBrp3Z/e1p8IlA4PtK/SWGSLUMgOzLVScOYiIyCtNOoNfn89Shw6RmWlf2qPbaFcuEaLTBcfaw+Yrx4OvEn7rEClfuwcGT5gwQXZ6UACIjo7G8uXL2/sUndaOw0W457ZeaNIJ+NexYvz7vTejT3y0w3GWnoBPd5x3aGWx9ASEqp3fcgPekkVEFOSU1sL9Q57tWL2isnqs3nLa6fG7j1/36PELSutwpaRWdp/SXgsi8g5XDA6QxmY9Ps+9hL9+fgK5x4qxL1+D4xcqZI+Ni4kAIH/j1Zkr+JZVhf/w0B346W290DexO36e2rtjCk9E1EWIdv97Q1vT7IuitMupK1UO21y11pdUNmDR+qN2x1vOYBRA1Bl06BSh5JxljG+TzoC6RtNgXrmBv4Cpgj9+RH/kHCoCAHSPCkN9k+mcBvP/MdHhAICRQ1MwcmgKAMAgGHH4bLnMIxIRkTveXH8UcTERsr207vrXsWL3D1ZYM7u2VrmDkImofdgTECDSKU8tM/oYndz81WqVdfYf0++t7TeWc2OiwxzOk55DRESeq6xpxqXimrYPdCH/stbtYzsiBKhrlJ862h3F5fU+LAkRKQlriQFiafUPCQmxtuo7WwtBrQpBWGjrWyUdHNykM60TEGvuCSAiog7Qjtp5SWWDF0/nu3Dg/y3f57PHAjzvrGjRC6jhKsNEisMgIEAMgimXPyQEbaYDAUBYG636cj0BRETkG76slHskwFM8++Lp3/niBGa990P7H4iIfIpBQIBYKvxGo2jN63eWDgS4nv0HaJ1BiIiIlKOsynGld5fsvwYk3wuBXvLlaplpVWt3wqHjlyqh05t6qi+2M52KiDoGBwYHiKUnQC8YrTdUuXSg8SP6AwBCJelAouRL4eUp96CwVH4aNwD4f48PgUbr4ZcQEVEXtvH7y44bvewIWPHVSa/Ok1snQDHceC0+23UR18rqMe3h1I4vDxF5hUFAgAiCpSdAss0uCIiPjcATD9wKwDYdSNphcNdP4nHXT+KdPs/QW3th6K0+KDARURex7cBVh23eJgM5G+vlqeqOyKnv4DijorqpY5+AiNqF6UABIk0HshBdrOklHRhMRETBwdMQYMu+Apy9esNm28HTpXjpvR/aPUuRN0JkcpCKzGlBbVHWZKdEZI81ywCxpANJxwEILscEOL5Vgc4PJSLqKvw1fb8I4O3Pjttsu2Cu/BdX+H+6TrmvmSK7aUOnL9ktn0JFRIrGICBA5GYCsu82lt58pUGA5Si1im8fEZGitTN6sAyuVTLBKMqmUClt4TMissVapB8cPVfu0LIjCI65P/ZBgPQ3m3Qg841V3caMQURE5CuBqdBu2luAkgD0APgCQwAiZePAYD9YtfkUAFPqj2WhL4NMT4C76wRYjgpVMQggIursLOlAcvn5gSYY7Ru0WPUnChbsCfAjg6H1ZinXEyC6GhMQGiI5zvS/mkEAEZFfeFu17ewZMYfOlAW6CETkJQYBfmSQVPzlWv1d9QTYjAmwpgPx7SMiUrJyH06T6etmH7cer42DDIL995akwcrTAhGRX7EW6Ud6yc3S4MaYAOm9V9rqb0klYk8AEZF/FJV5npd/tdS9qTTlyGb+BOCWf/xCpfcnMwogUjQGAX6kN7TO8iA4tJ7YThcKOL9/WtKKGAQQEflHSWWDx+dkrDvSASXxr/bMTiQyCiBSNAYBbtqTV4Jpi3NlW/DdJe02lUv9adELWPDxYdlzpbMD9eoRCQBIjIvyuixERKRcDc16h22l2sYAlISIOivODuSmf35nWgilUWdAbHS4V48hHRgsF0xU1emgkdzkpe38vXpE4blH7kJDsx4/T03C6YIq3H1LvFflICLypYKCAqSnp6O6uhpxcXHIzMzEgAEDbI4RBAGLFi3C3r17ERISghkzZmDy5MkAgJUrV2L79u1QqVQICwvDrFmzcP/99wfgSpTDMdceOMhBuETkQwwCPNWO3k19GwODa+pbXJ4/4s4k2Z+JiAJp/vz5mDp1KiZNmoQtW7Zg3rx5WL9+vc0xW7duRVFREXbs2IHq6mo8+uijuO+++9C3b18MGTIE06ZNQ1RUFM6dO4ennnoK+/btQ2RkZICuKPCUnux54lIlLl6rRp/4aLs9ouyPRKQ8TAfykKsZfNqid9ETEKoOQaPO4PVjExEFglarxZkzZzBhwgQAwIQJE3DmzBlUVVXZHLd9+3ZMnjwZKpUK8fHxGD16NHJycgAA999/P6KiTOmNgwYNgiiKqK6u9u+FdEHFFZ6Pc7BY/s98fHOoCNUNzhuvGAMQKRuDAA85LoziPldThNqsCGzGGygRKZ1Go0FSUhLUajUAQK1Wo3fv3tBoNA7HpaSkWH9PTk5GaWmpw+Nt3rwZ/fv3R58+fTq24OQTLS4GDl8pqfVjSYjIU0wH8pBlVp+6xhZ0jwpzuoKjURQdunMtQYAoig49AWFqFZrg/SwMRETB7vDhw1i2bBk+/vhjj89NSOju9fMmJsZ4fW5H0Rm8b3CSuuLF1KaeiJaMkSsob3BYv8b+tVXia+0Oltu/WG7/YBDgIYNRxL58DT7efha/TbsVY3/e3+EYURTxbOZujBneD0nxrTP46A2mAOLTHRew+/h1m3PkegJuTgquDxMRdT3JyckoKyuDIAhQq9UQBAHl5eVITk52OK6kpARDhgwB4NgzcPz4ccyePRurVq3CLbfc4nE5tNp6h7VW3FVR4f18/h2luq7ZJ4+zaK38jHO+0tjYmg60+qs82HeW27+2Snyt25KYGMNy+xHL7TsqVYjLBhKmA3lIEIyoMK8AWVWnkz/G/EW08+g1aGtab+R6wdTSbx8AAEBoqNrm99v69sD0iXf6pMxERB0lISEBqampyM7OBgBkZ2cjNTUV8fG2s5eNHz8eWVlZMBqNqKqqwq5duzBu3DgAQH5+PmbNmoXly5fjrrvu8vs1KFGBRlmVCSLqfNgT4CHBKKLFvOiXs0HC0gHA0hmBDAbnrVRhdl2oyQndEBnOt4eIlG/BggVIT0/HqlWrEBsbi8zMTADA9OnTMXPmTAwePBiTJk1CXl4exo4dCwB44YUX0K9fPwBARkYGmpubMW/ePOtjLlmyBIMGDfL/xRARdRGsZXpIEETo9KaKvdMgwKbi73ptAAv7dCC5hWKIiJRo4MCByMrKcti+Zs0a689qtRoZGRmy52/cuLHDykbK8dm355D20xSonIylIyL/YjqQhwyCEboWwfqz7DF2PQERYWrrz85YgoCeMREAgIYmBgFERBRsnPd4/9+O8zhbeAPammabVFkiCgwGAW4QjEbUmyvlglG0Tokm2K3oWNvYAoNgtAkODIKIyAhTEGAwGFHjZE5lSxCQnGBaeKW+iWsGEBFR52IQjJj9/n7Mfn+/zbZpi3Oxee+VAJaMqOthEOCGz3ZdtP5sEIzQWYIAu2kQ/rx8Hz74+jT0kuBAbzAiypzb39RiwKwV+2SfwzImwDIj0G19e/juAoiIiDqA6IMFbSwNazuPFrf/wcilbQcK8Wzm7kAXgxSCQYAbfrxQYf1ZMIqtQYCksm+Zmu7o+QqbdKDGZr01Hai6zrYXQK1qzYsMNfcEpPTqhsXP3Yv/HH2bj6+CiIjaUlzesfPqdzVNOttebVcxQ5POgE9yzrVrUU5ybeP3V2D0ReRGnQKDADdIK+sGwYgWmYHB0hQgae5/fZMBYaEqhKpDcKPedkrR8LDWl9/SExATHYbePaMRquZbQ0Tkb/M+7th59TuzEIQAdstkvrB0j0eP8f2JEhSWtk6P+vLKH/CvH9lDQNQRWNN0g3QmA2lPgLTibxMQSHoCGpr1CFWHQK1SodrJugJAa0AQI1l9kYiISMlESdu+6LKd33qQjBCnx9yo02HDzgtelY2IXGMQ4AaVpCfANEWo4zoBznoFGpsNCLX0BLgIAkJVprcilkEAERGRolwsrnb5HU4UjBgEmGm0DU7n5rdJBzIarYOYbGcBav25QNKVqdMLCFOroFaFoFHnfMYfS6AREx3m3QUQEREFkCkdyHVvgLS3oKY+eCrVb316DPM+OuSTxxJFkXn5pAgMAszmrDmERZ8cld3nVk+AZJDwpj2205yFhaqgdpLj//PU3gBM6wP06hGJcPMgYiIi8o+5H/qmckdukNR9q+tNk2UEy9phDc2+mbp76Zd5nKGHFIErBkuU3WiS3S4dE9BiEGAwV/ilFX9XsxmEmnsCAKBH93D8btwgrNh4EqIITJ94J/7roVSEharwwE9v8sVlEBGRB65XNgS6CKRQBsGIqlrfLmx2qqDKp49H5C0GAXBdgQdsgwDpdGcGo+2iYM6Eqlt7Anp0C0dKr27WfWqVCmrzMICIcPYCEBEFyuJPfwx0ETo96Tdldb0OZWcbMfiWBKfHBNra7Wdx4HRZoItBCiSKIr7IvYSfpybhlpTYQBfHK0wHAqBraSMIkKQDNUq6A217ApzftixThAKmgb+W6UCDpQuUiKgruFBcE+giBDVX34MW+ZcrrT8v+2c+Vm85jaPnymWP8bYFvvxGIz7JOQejUcS7WXl4f/Mp2eNa9AJa9AJKXPQESdcJIt+7XlGPnUevBboYXjGKInYcuYY3/yGfSh4MGAQA1hx/Z9ROggBnA4PthUnSgWKiw6wLgxEREQUzUfLVp61thrbW9WDfPXkah21FZbYLtGXvvwoAePuz4y4f62ppHZZl5Tl8/67echrfnyjB1bI65F/W4ohdkGHx3+98j/9+53u8/uEhnLhUKXuMorolvCAYjVifc87nKU2+smDtEXy262Kgi+EVy9juEPspboMIa6NoXbLc4sK11qnAGpr1uHS9tXXIMsNPdEQoqut12Hn0Gm7U6XDaRY5faKhpnQDAtA5AqDkg4OQAREQUzHIOF7X/QWTqUJU1TbLj9KYtzsXfvz4NjbYBH207i7zLWqct+XLfsRptA3YecWx51pgf4/DZMlRWtz6vJ1/TzS0Gp7MMulLT0IKdR69B7IBKwdmrN/DdiRKs3X7WYV9RWZ3LXhB/cKf3SOmCOauDQQAcewIWbziG+eZVI1dvOW2zr6HJ9AceHRkKgyDis10X8a8fi/GV3YxAPbq1zvcfHqqG5VbSPSrMOgPQxF8O8OVlEBERdQqvvH/A6b5DZ8owZ03rjE4bv2/9/tXWNNusOGxxuaQGb392HG98chSf/eui41hAc0Vu9ZbTWLS+Nb2jrXr53vwS1DSYZjl6eeUPePHdva5PkLF68yl8tusiSrSNHp/bFm2NqQfghnkmJqkFa4/g9TZmxioqq8P5ohs+L5c/6A1G6/V3hPbGbC++uwfpqw/AaBRxpaTWN4XyEIMAAC361puBJRKvN1f2r5WbuimTE6IRGx2GusbWIMCirrH1j+vl396DNa+Mwl9f+IV1W2y3cOvA4YhwNULVKnycnoaHRtzcQVdEREQUHNxpSDUIRlx1qNybvldPXtHisrnHXpr6I12T4IOvT+Ps1RvQtZga/ewrcNKUjtpGaWu+85peVW0z1m4/h/c25gMAmnTyqcW7jxXj3FXHirRlohFL74GxA1rFc49dBwCXLf4tegGnC1uzGT74+jTWfXMWh8+WYcHaI8j8P9dpWUr1wdbTmP3+/jYnf3FHgaYWB06X2mz7aNsZAO71BFwtrcOZQtuMkYZmA8qrm7DtQCEWrT+KSwEYk8TZgWDbE+Ast79JZ0B4mBq15gp/t8jWRb3qJDeMyHC1NfXHIiYqzNrlFcF1AIiIFOeTnHOBLgK58GXuJez6sdjp/qo6HW6cK8eXuy9Zt0kr1RXVti3CM97+zuZ3ZxU5V629lsevlmllB4BLxTX4IvciLptbeT9OT7PZ/8LSPfg4Pc2nww4Ony1Dv97dkZzQre2DzT7deQH78jVY+MzPcVNidxw8Y5oNSW78Rls02gZUVDdhyMBeHp8rp7y6Cd0jw2waXt114qJpnIe3LfZ78koAACOHpmCheR2pAX1iEKZWoVdcFA6ftQScbUcBGeuOAAA+fOUBm8lmAKC4whSgVdU1A+jhXWG9xJ4A2AYBOr2TIKBFQES4Gs3mVoToiNYPZK2kJyBU5fiSxnQLh2AOLsLD+JITESnN9ydKAl2ELstV5d7VMZbKEwD8cFKDVXazAH28zTEP3hmjKOK749cdttvnrB+/UGEdAxhijhxEJ9X49d+eswYAzhgEo7WzQa4qqdE2oLDU/VSR1VtO26RKuTPOoLTKlIbki8XQ5qw5hHez8j0+r75Jb62LiaKI1VtO4XzRDaSvPoA3Pjni8tyj58oxbXEuPv+X7QBjy6rMnuTs6/QC9AZTfW3dN+ew7hvbxoE5aw7hldUHbDJAPPHskt3IPVaMl1f+YN1Wa04nq21owTtfnLBmovgDa6SwDQKadfJ/BLoWwaYVP0oSlVreQMB2JiGL2Oiw1nQg9gQQERH5VP5lrcM2ZwuAysnafRnrvz3f5nErvjqJd744AaC1cllVq8Pmva3jEmoaWsxZBW3XPl9674fWEMJ8uK5FsKaOzFlzCG+s83wKSrmBwM5YKoKeDkzW1jQ7Paeypgnl1bavf2OzHtMW58oGWzOX7cUb5tbyJp0Bh8+W491/moKJcpn30SAYIRhNC7lZgr8ddgO+vZm954/vfI+5Hx6yBkYA8L8y64dI14ySCzL+suoHrN5iKld1ve2MWZ/uuGCdfAYAzl+rBgD8366LOF1Qha++v+x2edur06YDHb9YAe3xEtyeEoP+STH48XwFoiPUKNE2Iu1nNyEkJAQ1DS04dr4cR8+3zgOcfaDQ+vMXuRdtKvjhkqk9pT0BlZKBJ2q146chJjrcurAYgwAiIiJl02gbsGbrGZfHVEmmQ/36h0Lrz7NW7AMA6/pAUvatvPVNesREm9KLzxdVY95Hh637lvzxPtnn3ZtfguSEbrj1JuepI3vzNXgFtr0lUl/vK7D+bElPMRpFp/nzh86UYcSdSQBMYyGadAbM/egw0n52E0bcmYTb+sbZHG8Z2D3z8SHoEx+NpJ5R1rpS7rHrGPXTm9DcYtvoqrEbGG0ZvwGYWvX/tHQPpqTdip4xkXg3K8/ptdv7cNsZzJh4F+asOYjIcDXm/v7fXB5fXt1kk78vm6svqfnLhRhVtTocri3Hf09Cm58je9+dMA02f/E/hnh0njc6bRCQtfuyNZL7OD0NKzedtO4bMjABiXFROHi6FF/kXrI5T5oD9+3h1qjy6XGDkCeZR7hH93DIsawMDADPPJyK7QevIjJcbV1YjEEAERGRsklTapxpK03HIDi2kv/DRW/Dhp0XbH6XVoJrGlqQ/UMhpjx4K9ZuN6WoLHp2BD7PvYg/PTbYOuugK9MW51p/3iwJAgrMA67PFVXjlJPpzv/+9WkMvTUBeZe0+PvXpzH23/oBMFXoc49dx1vP3Yv/+eCgw3nLza35g/rFWVu8iyvqUV7dhPTV8jNAyXUubNtfiOYWAZ/ktN1bY+/g6TLMmHiXNcioa2xBbUML+iREY+VXpzDhFwMcVvyVe++cMkcBgmBE7rFi/PqeFJvdehfrSDlz/GIltu4vxL13JiExLsrj893VaYOAKElLvf1g39rGFiTGRdm08veJj7bp/pH6bdqteOCnN+HH86ZBIP85+jZ0czJIJVSSDvTLwcn45eBkALBG1+78oRIREZFyzVy2F7+4u49H5/x4vtwmjcSiuUV+VqEzha0zCll6F+64uad1m2V6z4vFNejbu7tNhoInLMHG1v2FLo97/m97rD8XV9gu8LZ2+zmXA3AtAYCFswDgyLlyjBze32H7pr0FMkfLq2/SY+Yy26laZ723z/rzgrVHcKNOh7eeuxcnLlXiemU9fpt2m80MSV/aNRDbK5CM9bCkG31zoBCf7rhgM+Pk0XPlXufdb9pzBZv2XHEYUO5LnTYIkI7PbbDrfrPM5iOd1adXXKTTICDGPOe/ZexAbHS40yBA2hMg1TomgMMwiIiIgll9k94hB70tKzedkt0uzQ+X+uxfjivpfnPoqsO204VVeOeLE7i9n21KzsSXt3hUPk/UN9rWqy7YVfK99f7mUxg5rJ/X52u0Dbgok75TI5nByfJ65xwyLXTXpBOw4quTNscb2xgf8fevW9eQsiw4a1lkrlHX+trsO6nBhQBM/emudgcBGRkZOHDgAMLDwxEdHY05c+Zg8ODBAIDKykq88soruH79OiIiIrBw4UIMHTq03YX2VK3dh7XOMhJbMrq7Vw/n3S2WfD1diym6i40OQ7RkilApuYHBAJgORERERO0it6iUpTLrq4q4O4rK69s+KADcSeOysMwI1t7ZeETYplpl728N1GqcTB+rFO1ulh45ciS2bt2Kr7/+Gs899xxmzZpl3ffOO+9g+PDh+PbbbzFv3jzMnj27Q5bFbos07QdorfzX2QQBkU7Pj4029QRYor2Y6HBrYGBPbiAQ0BpVMh2IiIiISJ7/a4kd52qZ4+rVnurIFZvbHQQ88MADCAszVYjvuecelJaWwmjOf8/JycFvf/tbAMDw4cMRHh6OkydPOn2sjmKZzsti4/dXsGJjPgo0rW9Oz+4RTs+3LAxmSQfqFhWGmGgnA4Nl1gmQYk8AERERkbycA4WBLoKiZP7fceuYVF/z6ZiADRs2YNSoUVCpVLhx4wZEUUR8fLx1f3JyMkpLSzFkiGfTHiUkdPe4LC8/ORzPL8l1uv/4xUqb3xN7dcekkQOx90SxzbRfo4b1xW239IJaFYK5z4xA9r4C3DogASpVCMbdezN6xUVhpzlH786fJCC5T6x1ARGphc/dh90/FiMpKdZhnzsSE2O8Ok9pOsN1dIZrAHgdStNZroOIqD3We7DGQVeRf1mLYYN6+/xx2wwCHnvsMZSUyK+kuH//fqjVppbtbdu2YevWrdiwYYNvSwhAq623Wf7bHZEq4I0Z92HeB6YR6L8c3Ac/nCx1eryuqQWTfnEzJv3iZvx4vhwrN51CdEQofjfmdlRpTblv8dFh+N3Y26E1/z5l1EAAwIOS6aAqK+Xz5G7qGYWnRt+GigrPu4YSE2O8Ok9pOsN1dIZrAHgdSuPNdahUIV41kBARUXDZm6/Bf/17qs8ft80gYNOmTW0+yM6dO7F06VKsW7cOvXr1AgD07GmaxqqqqsraG6DRaNCnj2dTarVHD0mKj2UZaGekaTqWVB/pSsJERERERJ1Fu9OBdu/ejbfeegtr165F3759bfaNHz8en3/+OZ5//nkcPXoUzc3NuPvuu9v7lG6TLuilczIPr0W4ZOpOy6BfwcPeByKirqigoADp6emorq5GXFwcMjMzMWDAAJtjBEHAokWLsHfvXoSEhGDGjBmYPHlym/uUYszwfoiKUOOO/j0RHqbG5ZIaXK9owJ48+Z5yIiKla3cQ8NprryEsLAwzZ860blu3bh169uyJl19+GbNnz8bmzZsRERGBJUuWQNXGwFlfiu3W2hPQ4kFPQGw3+UG/RETkaP78+Zg6dSomTZqELVu2YN68eVi/fr3NMVu3bkVRURF27NiB6upqPProo7jvvvvQt29fl/sC7aNXH5Ad52VZYfQPD92Bi8XVMBpFXCmpRdZ3l/1dRCIir7Q7CDh40HGZaIvExESsW7euvU/htbBQx4AjJMS0JHWoWmWzkrD0Hu/tqntERF2NVqvFmTNnsHbtWgDAhAkTsHDhQptUUADYvn07Jk+eDJVKhfj4eIwePRo5OTl49tlnXe4LlGGDEvHCY4PdOva2vqZFmgb174mH7r25Q8pjFEVANI0FAdwbR6KtaUZst3Drd2FNQwsamvRI6dUNoiiiodmA6nodKmuaMTAlFiKAmKgwtOiNUKtDoNE24mppHe65rRd0LQKiI0NRXFGPvondUd+kh9EoYt9JDW7U6bD/lPMxd0SkTJ2+tvvkmNuR0qsbEuMikXvsOkbdk4LvTpTg1/ekYM+JEoy8JwV78zRIjGtdLCwkJARPPHArbuvbI4AlJyJSPo1Gg6SkJOskEWq1Gr1794ZGo7EJAjQaDVJSWidRsMwW19Y+d/lqkPSmJRMR6mTld6Vpa0Yp+/2JiZ49fnKfHvjZXck22/r37Wnz+92Dkjx70CDR3GJAk86AuO4RaNIZIBhFdIsMQ0gI0NwiwGgUoVaFoLpeB21NM6rrdIiLiUCfhGjUN+px+Xo1btTqUFxej8SeUQhVq9DcYsCpy1r0S4rBpWvVaG4xQFvbDKNRRFJ8NEoq6hHbLQLV9TpERajRpOO4RGrVETPIdfog4MFhrd3JTzxwq83/k83/P26e5Udq/Ij+figdERH5gjezyH2cnubQon6jqsHXResQwTgzVjCWubJZby13c4POYb8aQO+YcPSOMaURG1sMiA4NweCbezocCwAP/Vu/jiyujWB8vQGW2xlvHrutWeSCo7mDiIgUKTk5GWVlZRAEU6ulIAgoLy9HcnKyw3HS6aals8W52kdERB2DQQAREXktISEBqampyM7OBgBkZ2cjNTXVJhUIMM0Wl5WVBaPRiKqqKuzatQvjxo1rcx8REXWMTp8OREREHWvBggVIT0/HqlWrEIYdqDMAAAwNSURBVBsbi8zMTADA9OnTMXPmTAwePBiTJk1CXl4exo4dCwB44YUX0K+fKTXC1T4iIuoYDAKIiKhdBg4ciKysLIfta9assf6sVquRkZEhe76rfURE1DGYDkRERERE1MUwCCAiIiIi6mIYBBARERERdTEMAoiIiIiIuhgGAUREREREXUxQzA6kUoUE5Fwl4XUoR2e4BoDXoTSeXkdnuW5f6YrfE8FY7mAsM8By+xvL7RttlSdEFEXP1lknIiIiIqKgxnQgIiIiIqIuhkEAEREREVEXwyCAiIiIiKiLYRBARERERNTFMAggIiIiIupiGAQQEREREXUxDAKIiIiIiLoYBgFERERERF0MgwAiIiIioi6mUwYBBQUFmDJlCsaNG4cpU6agsLAw0EWSlZmZibS0NAwaNAgXLlywbndVfiVe240bNzB9+nSMGzcOEydOxJ/+9CdUVVUBAE6cOIFHHnkE48aNw7Rp06DVaq3nudoXKM8//zweeeQRPProo5g6dSrOnj0LIPjeEwB47733bD5bwfZepKWlYfz48Zg0aRImTZqEvXv3Agi+69DpdJg/fz7Gjh2LiRMnYu7cuQCC8zMVrNx5PQVBQEZGBkaPHo0xY8YgKyvL/wW14065V65ciYcffhgTJ07Eb37zG+vfSSB58vm9cuUKhg4diszMTP8VUIa7Zd6+fTsmTpyICRMmYOLEiaisrPRvQe24U26tVosZM2Zg4sSJeOihh7BgwQIYDAb/F9bMWd1HSol/j+6UW4l/jy6JndDTTz8tbt68WRRFUdy8ebP49NNPB7hE8o4cOSKWlJSIDzzwgHj+/HnrdlflV+K13bhxQzx48KD198WLF4uvvfaaKAiCOHr0aPHIkSOiKIriypUrxfT0dFEURZf7Aqm2ttb6886dO8VHH31UFMXge09OnTolPvPMM9bPVjC+F/Z/F6LouqxKvY6FCxeKb775pmg0GkVRFMWKigpRFIPvMxXM3Hk9N23aJE6bNk0UBEHUarXi/fffL167ds3fRbXhTrn37NkjNjY2iqIoimfPnhWHDRsmNjU1+bWc9tz9/BoMBvGpp54SX3rpJXHx4sX+LKIDd8qcn58vPvTQQ2J5ebkoiqbvi+bmZr+W05475V60aJH19W1paREff/xxcdu2bX4tp5Szuo+UEv8e3Sm3Ev8eXel0QUBlZaU4bNgw0WAwiKJouskMGzZM1Gq1AS6Zc9IPlKvyB8u15eTkiL///e/FvLw88eGHH7Zu12q14j333COKouhyn1Js2rRJfOyxx4LuPdHpdOITTzwhXrt2zfrZCsb3Qu5GG2zXUV9fLw4bNkysr6+32R5sn6lg5u7rOX36dPGbb76x/p6RkSGuWbPGr2WV8uZzYDQaxZ/97GeiRqPxVzEdeFLuVatWiR9++KG4fPnygAYB7pb5pZdeErOysgJRRFnulvvNN98U586dKwqCINbX14uTJk0Sjx49Gogi23BVmVba36OUq3JLKeHvsS2dLh1Io9EgKSkJarUaAKBWq9G7d29oNJoAl8w9rsofDNdmNBrx2WefIS0tDRqNBikpKdZ98fHxMBqNqK6udrkv0ObMmYNRo0Zh6dKlyMzMDLr3ZNmyZXjkkUfQt29f67ZgfS/+8pe/YOLEiViwYAFqa2uD7jquXbuGuLg4vPfee/jNb36Dp59+GkePHg26z1Qwc/f1tP/8JCcno7S01K9ltS+Pp5+DzZs3o3///ujTp4+/iunA3XKfO3cO+/btwx/+8IcAlNKWu2W+fPkyrl27hieffBKPPfYYVq1aBVEUA1FkAO6X+/nnn0dBQQF+9atfWf8NGzYsEEV2m9L+Hr2hhL/HtnS6IIACa+HChYiOjsZTTz0V6KJ47c0338R3332HWbNmYcmSJYEujkeOHz+OU6dOYerUqYEuSrtt2LABX3/9NTZu3AhRFPHGG28EukgeEwQB165dw5133omvvvoKf/nLX/Diiy+isbEx0EWjTubw4cNYtmwZ3nnnnUAXpU16vR5z585FRkaGtQIbDARBwPnz57F27Vr84x//wJ49e7Bly5ZAF6tNOTk5GDRoEPbt24c9e/bg6NGjyMnJCXSxOrVg+XvsdEFAcnIyysrKIAgCANMfbXl5OZKTkwNcMve4Kr/Sry0zMxNXr17Fu+++C5VKheTkZJSUlFj3V1VVQaVSIS4uzuU+pXj00Udx6NAh9OnTJ2jekyNHjuDy5ct48MEHkZaWhtLSUjzzzDO4evVq0L0XltcwPDwcU6dOxbFjx4LuM5WcnIzQ0FBMmDABADB06FD07NkTkZGRQfOZCnbuvp72nx+NRhPQFjxPPgfHjx/H7NmzsXLlStxyyy3+LqoNd8pdUVGBoqIizJgxA2lpafjkk0/w5ZdfWgfNK7HMAJCSkoLx48cjPDwc3bt3x4MPPoj8/PxAFBmA++X+9NNP8cgjj0ClUiEmJgZpaWk4dOhQIIrsNqX9PXpCSX+Pbel0QUBCQgJSU1ORnZ0NAMjOzkZqairi4+MDXDL3uCq/kq/tb3/7G06dOoWVK1ciPDwcAHD33XejubkZR48eBQB8/vnnGD9+fJv7AqWhocGmGzU3Nxc9evQIqvdkxowZ2LdvH3Jzc5Gbm4s+ffrgo48+wrPPPhtU70VjYyPq6uoAAKIoYvv27UhNTQ26z1R8fDxGjBiBH374AYBpJg+tVosBAwYEzWcq2Ln7eo4fPx5ZWVkwGo2oqqrCrl27MG7cuEAUGYD75c7Pz8esWbOwfPly3HXXXYEoqg13yp2SkoJDhw5Z71O///3v8cQTT2DhwoWKLTMATJgwAfv27YMoitDr9Th48CDuuOOOQBQZgPvl7tu3L/bs2QMAaGlpwYEDB3Dbbbf5vbyeUNrfo7uU9vfYlhAxkAltHeTy5ctIT09HbW0tYmNjkZmZqchobNGiRdixYwcqKyvRs2dPxMXFYdu2bS7Lr8Rru3jxIiZMmIABAwYgMjISgOmms3LlShw7dgzz58+HTqfDTTfdhLfffhu9evUCAJf7AqGyshLPP/88mpqaoFKp0KNHD7z66qu46667gu49sUhLS8Pq1atx++23B9V7ce3aNbz44osQBAFGoxEDBw7E66+/jt69ewfVdViu5X/+539QXV2N0NBQ/PnPf8avf/3roP1MBSNnr+f06dMxc+ZMDB48GIIg4I033rAGbNOnT8eUKVMUX+7/+I//wPXr15GUlGQ9b8mSJRg0aJCiyy21YsUKNDY24tVXXw1Qid0rs9FoRGZmJvbs2QOVSoVf/epXePXVV6FSBa491Z1yFxUVYf78+aisrIQgCBgxYgTmzJmD0NDQgJTZWd1H6X+P7pRbiX+PrnTKIICIiIiIiJzrdOlARERERETkGoMAIiIiIqIuhkEAEREREVEXwyCAiIiIiKiLYRBARERERKQAmZmZSEtLw6BBg3DhwgW3zqmursZLL72EcePG4eGHH8Z7773n1nmBmR+KiIiIiIhsPPjgg/jd736HJ5980u1z0tPTce+99+Jvf/sbANOCfO5gEEBEREREpADDhw+X3Z6Xl4e//vWvaGhoAADMnDkTo0aNQmFhIS5cuID333/femxiYqJbz8UggIiIiIhIoWprazF//nx88MEH6N27N8rLy/H4448jOzsbly5dQlJSEubMmYOzZ8+iV69eeOWVV9xaFZpBABERERGRQh0/fhzFxcWYPn26dVtISAiuXr0Ko9GIvLw8vPzyyxg+fDh27NiBP/7xj9i1a1ebj8sggIiIiIhIoURRxKBBg7BhwwbZ/cnJydY0orFjx2L27NmoqqpCfHy8y8fl7EBERERERAr105/+FFevXsXBgwet2/Lz8yGKIu6++25ER0fj4sWLAIAjR46gR48e6NmzZ5uPGyKKothhpSYiIiIiIrcsWrQIO3bsQGVlJXr27Im4uDhs27YN+fn5ePvtt1FTUwO9Xo9+/fph9erVUKlUOHnyJDIyMtDS0oKoqCjMmTMHQ4YMafO5GAQQEREREXUxTAciIiIiIupiGAQQEREREXUxDAKIiIiIiLoYBgFERERERF0MgwAiIiIioi6GQQARERERURfDIICIiIiIqIthEEBERERE1MX8f7IG9/ei9KKEAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1440x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(timesteps, returns, losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "x9GHIzcxi6Ei"
   },
   "outputs": [],
   "source": [
    "# save model for reusing, not for submitting\n",
    "torch.save(dqn.state_dict(), f'checkpoint_save - {i}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "83LGjWQWklDG"
   },
   "outputs": [],
   "source": [
    "state = env.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "eB_ks0Q7KYPH",
    "outputId": "998dae9f-5d91-46c1-f75f-3eae70b56e5e"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:30: TracerWarning: torch.tensor results are registered as constants in the trace. You can safely ignore this warning if you use this function to create tensors out of constant variables that would be the same every time you call this function. In any other case, this might cause the trace to be incorrect.\n",
      "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:30: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n"
     ]
    }
   ],
   "source": [
    "# save model parameters for submitting solution using the following line of code\n",
    "torch.onnx.export(dqn, # model\n",
    "                  torch.tensor(state, dtype=torch.float), # example model input\n",
    "                  'submission_onnx.onnx', # name of the submission\n",
    "                  export_params=True, # save trained parameters\n",
    "                  opset_version=10,\n",
    "                  do_constant_folding=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DOTrnK0dmgDL"
   },
   "outputs": [],
   "source": [
    "# test your onnx model using runtime - we are going to use this to test your model\n",
    "# on the server.\n",
    "import onnxruntime\n",
    "\n",
    "ort_session = onnxruntime.InferenceSession('submission_onnx.onnx')\n",
    "\n",
    "def to_numpy(tensor):\n",
    "    return tensor.detach().cpu().numpy() if tensor.requires_grad else tensor.cpu().numpy()\n",
    "\n",
    "ort_inputs = {ort_session.get_inputs()[0].name: to_numpy(torch.tensor(state, dtype=torch.float))}\n",
    "ort_outs = ort_session.run(None, ort_inputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "q3HeGYGom8vd",
    "outputId": "4e524a3f-9e03-409d-ee04-279dbe503820"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([array([[1.39930952, 1.42257619, 1.37839806, 1.38779044, 1.39195919,\n",
       "          1.38726604]])],\n",
       " tensor([[1.4298, 1.4741, 1.4556, 1.4287, 1.4435, 1.4750]], device='cuda:0',\n",
       "        dtype=torch.float64, grad_fn=<CopyBackwards>))"
      ]
     },
     "execution_count": 24,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check if output matches\n",
    "ort_outs, dqn(state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "PCFmc2Dso2fa",
    "outputId": "4d42fc8a-4835-43f4-ad08-b5b1b8708b05"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Return: 19.76\n"
     ]
    }
   ],
   "source": [
    "# test on the env using onnx model\n",
    "# We are going to use this block of code for testing your model on the server.\n",
    "# Make sure your model works in this block of code, before submitting.\n",
    "return_ = []\n",
    "for i in range(50):\n",
    "  state = env.reset()\n",
    "  ret = 0\n",
    "  done = False\n",
    "  while not done:\n",
    "    ort_inputs = {ort_session.get_inputs()[0].name: to_numpy(torch.tensor(state, dtype=torch.float))}\n",
    "    q_actions = ort_session.run(None, ort_inputs)\n",
    "    action = np.argmax(q_actions)\n",
    "    state, r, done, _ = env.step(action)\n",
    "    ret += r\n",
    "  return_.append(ret)\n",
    "\n",
    "print(\"Average Return:\", np.mean(return_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "TFtWyJQYAbAC"
   },
   "outputs": [],
   "source": [
    "from pyvirtualdisplay import Display\n",
    "display = Display(visible=0, size=(600, 400))\n",
    "display.start()\n",
    "from gym.wrappers import Monitor\n",
    "import glob\n",
    "import io\n",
    "import base64\n",
    "from IPython import display as ipythondisplay\n",
    "\n",
    "def show_video():\n",
    "  mp4list = glob.glob('video/*.mp4')\n",
    "  if len(mp4list) > 0:\n",
    "    mp4 = mp4list[0]\n",
    "    video = io.open(mp4, 'r+b').read()\n",
    "    encoded = base64.b64encode(video)\n",
    "    ipythondisplay.display(HTML(data='''<video alt=\"test\" autoplay \n",
    "                loop controls style=\"height: 400px;\">\n",
    "                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n",
    "             </video>'''.format(encoded.decode('ascii'))))\n",
    "  else: \n",
    "    print(\"Could not find video\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 421
    },
    "id": "WVcAixsTv-7t",
    "outputId": "269b3026-97e2-461b-b537-09e6cd586dea"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" autoplay \n",
       "                loop controls style=\"height: 400px;\">\n",
       "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "             </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Render env:\n",
    "env.close()\n",
    "env_id = \"PongNoFrameskip-v4\"\n",
    "env    = make_atari(env_id)\n",
    "env    = wrap_deepmind(env)\n",
    "env    = wrap_pytorch(env)\n",
    "env = Monitor(env, './video', force=True)\n",
    "state = env.reset()\n",
    "done = False\n",
    "while not done:\n",
    "  env.render()\n",
    "  ort_inputs = {ort_session.get_inputs()[0].name: to_numpy(torch.tensor(state, dtype=torch.float))}\n",
    "  q_actions = ort_session.run(None, ort_inputs)\n",
    "  action = np.argmax(q_actions)\n",
    "  state, r, done, _ = env.step(action)\n",
    "  if done:\n",
    "    state = env.reset()\n",
    "show_video()"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "machine_shape": "hm",
   "name": "04_PongPongPong_Exercise.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}