diff --git a/01.DQN.ipynb b/01.DQN.ipynb
index 5d0a53d..6ac7b40 100644
--- a/01.DQN.ipynb
+++ b/01.DQN.ipynb
@@ -4,14 +4,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Deep Q Networks"
+    " # Deep Q Networks"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Imports"
+    " ## Imports"
    ]
   },
   {
@@ -20,35 +20,37 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import gym\n",
-    "from gym import wrappers\n",
+    "import gym, random, pickle, os.path, math, glob\n",
+    "import numpy as np\n",
+    "\n",
+    "from timeit import default_timer as timer\n",
+    "from datetime import timedelta\n",
+    "from timeit import default_timer as timer\n",
     "\n",
     "import torch\n",
-    "import torch.nn as nn\n",
     "import torch.optim as optim\n",
-    "import torch.nn.functional as F\n",
-    "\n",
-    "import numpy as np\n",
     "\n",
-    "from IPython.display import clear_output\n",
-    "from matplotlib import pyplot as plt\n",
+    "import matplotlib\n",
     "%matplotlib inline\n",
+    "from IPython.display import clear_output\n",
     "\n",
-    "import random\n",
-    "from timeit import default_timer as timer\n",
-    "from datetime import timedelta\n",
-    "import math\n",
-    "from utils.wrappers import make_atari, wrap_deepmind, wrap_pytorch\n",
+    "import torch\n",
+    "import torch.optim as optim\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
     "\n",
+    "from utils.wrappers import *\n",
     "from utils.hyperparameters import Config\n",
-    "from agents.BaseAgent import BaseAgent"
+    "from utils.plot import plot_reward\n",
+    "\n",
+    "from agents.BaseAgent import BaseAgent\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Hyperparameters"
+    " # Hyperparameters"
    ]
   },
   {
@@ -62,30 +64,31 @@
     "config.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
     "\n",
     "#epsilon variables\n",
-    "config.epsilon_start = 1.0\n",
-    "config.epsilon_final = 0.01\n",
-    "config.epsilon_decay = 30000\n",
+    "config.epsilon_start    = 1.0\n",
+    "config.epsilon_final    = 0.01\n",
+    "config.epsilon_decay    = 30000\n",
     "config.epsilon_by_frame = lambda frame_idx: config.epsilon_final + (config.epsilon_start - config.epsilon_final) * math.exp(-1. * frame_idx / config.epsilon_decay)\n",
     "\n",
     "#misc agent variables\n",
-    "config.GAMMA=0.99\n",
-    "config.LR=1e-4\n",
+    "config.GAMMA = 0.99\n",
+    "config.LR    = 1e-4\n",
     "\n",
     "#memory\n",
     "config.TARGET_NET_UPDATE_FREQ = 1000\n",
-    "config.EXP_REPLAY_SIZE = 100000\n",
-    "config.BATCH_SIZE = 32\n",
+    "config.EXP_REPLAY_SIZE        = 100000\n",
+    "config.BATCH_SIZE             = 32\n",
     "\n",
     "#Learning control variables\n",
     "config.LEARN_START = 10000\n",
-    "config.MAX_FRAMES=1000000"
+    "config.MAX_FRAMES  = 1000000\n",
+    "config.UPDATE_FREQ = 1\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Replay Memory"
+    " ## Replay Memory"
    ]
   },
   {
@@ -105,17 +108,17 @@
     "            del self.memory[0]\n",
     "\n",
     "    def sample(self, batch_size):\n",
-    "        return random.sample(self.memory, batch_size)\n",
+    "        return random.sample(self.memory, batch_size), None, None\n",
     "\n",
     "    def __len__(self):\n",
-    "        return len(self.memory)"
+    "        return len(self.memory)\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Network Declaration"
+    " ## Network Declaration"
    ]
   },
   {
@@ -149,14 +152,14 @@
     "        return x\n",
     "    \n",
     "    def feature_size(self):\n",
-    "        return self.conv3(self.conv2(self.conv1(torch.zeros(1, *self.input_shape)))).view(1, -1).size(1)"
+    "        return self.conv3(self.conv2(self.conv1(torch.zeros(1, *self.input_shape)))).view(1, -1).size(1)\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Agent"
+    " ## Agent"
    ]
   },
   {
@@ -176,6 +179,7 @@
     "        self.experience_replay_size = config.EXP_REPLAY_SIZE\n",
     "        self.batch_size = config.BATCH_SIZE\n",
     "        self.learn_start = config.LEARN_START\n",
+    "        self.update_freq = config.UPDATE_FREQ\n",
     "\n",
     "        self.static_policy = static_policy\n",
     "        self.num_feats = env.observation_space.shape\n",
@@ -201,7 +205,6 @@
     "        self.update_count = 0\n",
     "\n",
     "        self.declare_memory()\n",
-    "        \n",
     "\n",
     "    def declare_networks(self):\n",
     "        self.model = DQN(self.num_feats, self.num_actions)\n",
@@ -213,10 +216,9 @@
     "    def append_to_replay(self, s, a, r, s_):\n",
     "        self.memory.push((s, a, r, s_))\n",
     "\n",
-    "\n",
     "    def prep_minibatch(self):\n",
     "        # random transition batch is taken from experience replay memory\n",
-    "        transitions = self.memory.sample(self.batch_size)\n",
+    "        transitions, indices, weights = self.memory.sample(self.batch_size)\n",
     "        \n",
     "        batch_state, batch_action, batch_reward, batch_next_state = zip(*transitions)\n",
     "\n",
@@ -228,16 +230,16 @@
     "        \n",
     "        non_final_mask = torch.tensor(tuple(map(lambda s: s is not None, batch_next_state)), device=self.device, dtype=torch.uint8)\n",
     "        try: #sometimes all next states are false\n",
-    "            non_final_next_states = torch.tensor([s for s in batch_next_state if s is not None], device=self.sdevice, dtype=torch.float).view(shape)\n",
+    "            non_final_next_states = torch.tensor([s for s in batch_next_state if s is not None], device=self.device, dtype=torch.float).view(shape)\n",
     "            empty_next_state_values = False\n",
     "        except:\n",
     "            non_final_next_states = None\n",
     "            empty_next_state_values = True\n",
     "\n",
-    "        return batch_state, batch_action, batch_reward, non_final_next_states, non_final_mask, empty_next_state_values\n",
+    "        return batch_state, batch_action, batch_reward, non_final_next_states, non_final_mask, empty_next_state_values, indices, weights\n",
     "\n",
     "    def compute_loss(self, batch_vars):\n",
-    "        batch_state, batch_action, batch_reward, non_final_next_states, non_final_mask, empty_next_state_values = batch_vars\n",
+    "        batch_state, batch_action, batch_reward, non_final_next_states, non_final_mask, empty_next_state_values, indices, weights = batch_vars\n",
     "\n",
     "        #estimate\n",
     "        current_q_values = self.model(batch_state).gather(1, batch_action)\n",
@@ -248,10 +250,10 @@
     "            if not empty_next_state_values:\n",
     "                max_next_action = self.get_max_next_state_action(non_final_next_states)\n",
     "                max_next_q_values[non_final_mask] = self.target_model(non_final_next_states).gather(1, max_next_action)\n",
-    "            expected_q_values = batch_reward + (self.gamma*max_next_q_values)\n",
+    "            expected_q_values = batch_reward + self.gamma*max_next_q_values\n",
     "\n",
     "        diff = (expected_q_values - current_q_values)\n",
-    "        loss = self.huber(diff)\n",
+    "        loss = self.MSE(diff)\n",
     "        loss = loss.mean()\n",
     "\n",
     "        return loss\n",
@@ -262,7 +264,7 @@
     "\n",
     "        self.append_to_replay(s, a, r, s_)\n",
     "\n",
-    "        if frame < self.learn_start:\n",
+    "        if frame < self.learn_start or frame % self.update_freq != 0:\n",
     "            return None\n",
     "\n",
     "        batch_vars = self.prep_minibatch()\n",
@@ -280,7 +282,6 @@
     "        self.save_loss(loss.item())\n",
     "        self.save_sigma_param_magnitudes()\n",
     "\n",
-    "\n",
     "    def get_action(self, s, eps=0.1):\n",
     "        with torch.no_grad():\n",
     "            if np.random.random() >= eps or self.static_policy:\n",
@@ -299,58 +300,33 @@
     "    def get_max_next_state_action(self, next_states):\n",
     "        return self.target_model(next_states).max(dim=1)[1].view(-1, 1)\n",
     "\n",
-    "    def huber(self, x):\n",
-    "        cond = (x.abs() < 1.0).to(torch.float)\n",
-    "        return 0.5 * x.pow(2) * cond + (x.abs() - 0.5) * (1 - cond)"
+    "    def finish_nstep(self):\n",
+    "        pass\n",
+    "\n",
+    "    def reset_hx(self):\n",
+    "        pass\n",
+    "    \n",
+    "    def MSE(self, x):\n",
+    "        return 0.5 * x.pow(2)\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Plot Results"
+    " ## Training Loop"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "def plot(frame_idx, rewards, losses, sigma, elapsed_time):\n",
-    "    clear_output(True)\n",
-    "    plt.figure(figsize=(20,5))\n",
-    "    plt.subplot(131)\n",
-    "    plt.title('frame %s. reward: %s. time: %s' % (frame_idx, np.mean(rewards[-10:]), elapsed_time))\n",
-    "    plt.plot(rewards)\n",
-    "    if losses:\n",
-    "        plt.subplot(132)\n",
-    "        plt.title('loss')\n",
-    "        plt.plot(losses)\n",
-    "    if sigma:\n",
-    "        plt.subplot(133)\n",
-    "        plt.title('noisy param magnitude')\n",
-    "        plt.plot(sigma)\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Training Loop"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwAAAAE/CAYAAADxMqTfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsnXmcZGV193/nVlUvM9MzwywMzMAwLAMIohJZRQU3UNRgTIzgGpcQfdW4G1xiEmOUN/F1xQRJJIgY1CjiEgiCLAMKyrAvAwMMA7MvDDPdM71V1T3vH/c+9z53q627qut2/76fz3y6qu6t53nurZruc57zO+eIqoIQQgghhBAyM3CmegGEEEIIIYSQzkEHgBBCCCGEkBkEHQBCCCGEEEJmEHQACCGEEEIImUHQASCEEEIIIWQGQQeAEEIIIYSQGQQdgBqIyFEicq+IDInIX0/1esjUIiI3i8h7p3odE0VEPiMi/zHV6yCEkG5FRNaLyCuneh2EtAs6ALX5FICbVHVAVb851YuJIyIvF5G7RWRQRNaJyPkZ510qIioiR1ivfVBEVovImIhcFjv/FBG5XkR2icgOEflvETnQOv5JEXnQd4yeFJFPxt7/IhH5g3/8fhF58SRfetcjIs8VketEZKeIJJptiMhzRORGEdkjIo+LyJ+0OladdZwhIhvt11T1S6o6JY6MiLze/+7sFZHficgxNc79CxGp+ueaf2dYx9eLyIh17Nd15v6oiGz1/79cKiK91rGb/O/6oIjcJyLnTMoFE0IIIV0IHYDaHALgoayDIlLo4Fric5cA/AzAdwDMA/BmAF8VkefHznsxgMNThtgM4IsALk05th+ASwCsgHcPhgD8pz0sgHf4570awAdF5Fx/vgUAfgngXwDMB/DPAH4pIvu1cI0iIh3/jopIcRKGKQP4MYD3ZIz/cwC/ArAAwPkArhCRI5sdK0+IyEoAPwDwPnjfjV8C+EWd+327qs6x/t0cO/5669iZNeY+C8AFAF4B7zt9GIB/sE75MIADVXUuws/jwMRAhBBCyDSADkAGInIjgJcBuMjfXTxSRC4TkX8TkWtEZB+Al4nIa0XkHn/ncIOI/L01xgp/5/1d/rFnReR9InKivzO+W0Quis37bhFZ4597nYgckrHEBQDmAvi+etwJYA2AY6yxigC+BeBD8Ter6lWqejWAZ1KOXauq/62qg6o6DOAiAKdZx/9ZVe9W1YqqPgrPmDXHXwRgq//+qqpeAWAHgDfWvuPBmm8WkX8Skd8CGAZwmIjME5HvisgWEdkkIl80zpeIPCUiL/Qfv9W/38f6z98jIlf7j08Skdv9e75FRC4SkR5rXhWRD4jIYwAe8197lYg84u/SXwTP8WkIVX1UVb+LdAfyaABLAXzNv0c3AvgtgLe3MFYmIjIbwLUAllq75EtF5O9F5Ar/nHZ+R+OcBeBWVb1NVSsA/i+AZQBOb+a6WuSdAL6rqg+p6rMA/hHAX5iDqnq/vyYAUAAlAAd3YF2EkC5GRHpF5Osistn/93UTPRSRRSLyK//35C4RudVsWonI3/h/r4ZE5FERecXUXgkhUegAZKCqLwdwK4AP+ruLa/1DbwHwTwAGANwGYB+83fD5AF4L4P0i8obYcCcDWAlvl/7rAD4L4JUAjgXw5yJyOgD4soPPwDOWF/vzX5mxvm3+sXeJSEFEToW3s3mbddpHAaxS1ftbvQ8+L0WG8SkiAuAlseNxQ1kAPLeJ+d4Obxd2AMBTAC4DUAFwBIDjAZwJwEhYbgFwhv/4dADr/PWa57f4j6vw7sciAKfC2wn+P7F53wDvszpGRBYBuArA5/z3PAHLCRKR5f4v/eVNXFctmr1HdVHVfQBeA2CztUu+OeP0SfmO+n8ML6ixLIk9Dq5bRF4sIrtj5x8vnvRprYj8bUq04AfiSXd+LVb0K2WsYwHcZz2/D8ASEVkYW/sogN8DuBnA6hrXQQiZGXwWwCkAXgDg+QBOgvd3AQA+DmAjvN+FS+D9blQROQrABwGcqKoD8DY/1nd22YTUhg5A8/xcVX+rqq6qjqrqzar6gP/8fnjGUHxH8x/9c38Nz2G4UlW3q+omeAbU8f557wPwZVVd4+9GfgnAC2rssF4J4PMAxvxxPquqGwBARA4G8Ff+8ZYRkef5Y3wy45S/h/c9MhKh2+HtOJ8nIiUReSc8CdKsJqa9zN+prcCLdJwN4COquk9VtwP4GoBz/XNvQXi/XwLgy9bzwAFQ1btU9Q4/arEennQq/jl9WVV3qeqIP+dDqvoTVS3DM4q3mhNV9WlVna+qTzdxXYZHAWwH8En/Hp3pr6WZezTZTMp3VFVfp6oXZsxxA4DTxctL6IH3x7IH/nX7kYH51vmr4DkH+wP4UwDnIfo9fCtCmdpNAK4TkfkZY80BsMd6bh4PmBdU9XX+87MB/FpV3ezbRQiZIbwVwBf834c74EkHTbS2DOBAAIeoallVb1VVhbfh1AtvM6mkqutV9YkpWT0hGdABaJ4N9hMROVnCBMI98AykRbH3bLMej6Q8n+M/PgTAN/yd5d0AdsHbIV0WX4SIHA3gh/CiDz3wdjg/JSKv9U/5OrxfWnvi720U8ZKGrwXwYVW9NeX4B/35X6uqYwCgqs8AOAfAx/zrfDU8w29j/P01sO/xIfDkGFus+/IdeEYh4Bn4LxFPr12Ap5U/TURWwMuNuNdf65H+Du9WERmEZ7jGPyd73qX2c/+X+gZMAr5D8QZ4EaOt8HaRfozm7tFkM+nf0Tiq+gg8Kc5FALbAu/8PI+O6VXWdqj7pO9cPAPgCgD+zjv9WVUdUdVhVvwxgNzwnMI298CRzBvN4KDZnWVWvBXCmiPxxvWsihEx7lsKLRBue8l8DvFy3xwH8WrxCHBcAgKo+DuAj8DbItovID0VkKQjpIugANE+8Cst/AfgFgINVdR6Ai9GEVjzGBgB/5e8sm3/9qvq7lHOfC2Ctql7nG0iPAvgfeJIPwJO4/Itv8Jqd69tF5C2NLMTf0b0B3s7w91OOvxt+UqWqxqvM3KKqJ6rqAng7JUcD+EMj85ohrMcb4EU4Fln3ZK6qHuvP9Ti8XIEPwZM7DcIzqs8HcJu1i/tvAB4BsFK9RM/PIPk52fNugaUB96VOk6YJ9zXnp6vqQlU9C15SajP3qOGpJnm8Zr6jycV4EZXnqupCAH8Hbwf/zgbnVtT+v1Xr+EPwwveG5wPY5jusaRSRnjxPCJlZbIa38WFY7r8GVR1S1Y+r6mEA/hjAx4zWX1X/S1Vf7L9X4eU8EdI10AGYOAMAdqnqqIicBC9HoFUuBvBpCZNY54nImzLOvQfASvFKgYqIHA7gdQCM3v9IeEbOC/x/APB6eJWDICJFEemDt2teEJE+o68WkWUAbgRwkapeHJ9YRN4Kbwf9Vaq6LuX48b60ZS6ArwDYoKrXNX03AKjqFgC/BvD/RGSuiDgicrjRpPvcAk9vafT+N8eeA97nNAhgrx89eX+dqf8HwLEi8kb/vvw1gAMaXbf/mfTBi87Av7922cnn+a/NEpFPwAsjX9bKWHXYBmChiMxrdO11aOY7mkBEXujnrCyGV2nqF35kIO3c14jIEv/x0QD+Fl7CucnBOE1Eevz78Ul4EYXfZkx9OYD3iMgxvkzoc/Dvt4gc7c/V739v3wYvj+SWjLEIITOHKwF8TkQWi5cb9nkApojC60TkCH+DaA886Y8rXg+hl/u/p0fhRVEpKSRdBR2AifN/AHxBRIbg/WL4casDqerP4O0S/NCXqTyIcEc/fu4TAN4N4JvwDNtbAPwUwH/4x7er6lbzz3/bTl/fDngG0Ai8Xfy3+Y9NYtN74e1I/71YNdit6b8IYCGAO63jtqPwKQA74e0WHwggqHEvIi+JjdUIRub0MIBnAfzEH9dwCzwDf1XGcwD4BDznbAjAvwP4Ua0JVXUngDcBuBBepaSVsIxL3wDdK9lJwIfAu6cmOXoEnvbf8HZ4UYbt8KI1rzIyqpSxa44lIteKyGcyruMReH/A1vmynQmFoet9R2utxecb8KQ6j8L7LP/Sem/8u/EKAPeLV3HrGnhJ2V/yjw3Ai+o8C2ATPKnZa8yOfnwsVf1feCVpbwLwNLww/t+ZqeGH6uFVrPowgDer6t2N3RVCyDTmi/AKAtwP4AEAd/uvAd7fhRvgSQxvB/CvqnoTPP3/hfD+Dm6FJ1n9dGeXTUhtxJM2E0IIIYQQQmYCjAAQQgghhBAyg6ADQAghhBBCyAyCDgAhhBBCCCEzCDoAhBBCCCGEzCDoABBCCCGEEDKDKE71AmwWLVqkK1asmOplEEJI13HXXXftVNXFU72OqYZ/JwghJJ1m/k50lQOwYsUKrF69eqqXQQghXYeIPDXVa2gGETkYXgO2JfA6oV6iqt+InXMGvOZuT/ovXaWqX6g1Lv9OEEJIOs38negqB4AQQsi0oQLg46p6t4gMALhLRK5X1Ydj592qqq+bgvURQsiMhTkAhBBCJh1V3WK6KavqEIA1AJZN7aoIIYQAdAAIIYS0GRFZAeB4AL9POXyqiNwnIteKyLEdXRghhMxQKAEihBDSNkRkDoCfAviIqg7GDt8N4BBV3SsiZwO4GsDKlDHOB3A+ACxfvrzNKyaEkOkPIwCEEELagoiU4Bn/P1DVq+LHVXVQVff6j68BUBKRRSnnXaKqJ6jqCYsXz/hCSIQQMmHoABBCCJl0REQAfBfAGlX9asY5B/jnQUROgvc36ZnOrZIQQmYmlAARQghpB6cBeDuAB0TkXv+1zwBYDgCqejGAPwPwfhGpABgBcK6q6lQslhBCZhJ0AAghhEw6qnobAKlzzkUALurMigghhBgoASKEEEIIIWQGQQeAzGjGKlX87omdDZ27ZssgHt8+hLuffrbNq4qydtsQNu8eafj8StXFz+/dhDvX72rjqrqDZ/aO4cFNewAAT+7ch6ee2Zc4Z3C0jLueau9ndtdTuzA4Wk49tnr9LgxlHCOd4zdrtuE3a7ZN9TIIIaQroANAZjT/+KuH8ZZ//z0e3TpU99zXfONWvPKrq/DGf/0dxituB1bncebXVuFFF97Y8Pl/eHIXPvzDe/Gmi29v46q6g9d+8za87lu3AQBe9pWbcfq/3Jw4568uvwt/+m+/w2i52pY1jFdcnHvJHfjeb9cnjg2NlvFnF9+OD/7XPW2ZmzTOJavW4ZJV66Z6GYQQ0hXQASAzmgc2eWXJ941Xmnrf3rHmzu8ku4bHp3oJHWPr4Gjdc+7dsBsAMFZuj9M2WqmiXFU8tWs4cWzzbm99q2dANIYQQkh+mLADICIHi8hNIvKwiDwkIh/2X18gIteLyGP+z/0mvlxCJpcxf1e45DT3X6GbJR1Do93rnHSCqhstIqPwng+X23NfTDRo07NJmdam3UmngBBCCJlqJiMCUAHwcVU9BsApAD4gIscAuADAb1R1JYDf+M8J6SqM8TZebW53uJuNbNs5iRvD0xW7cuS2jKjAyHh7JEBj/ndo8540B6B+hIIQQgjpNBN2AFR1i6re7T8eArAGwDIA5wD4nn/a9wC8YaJzETLZGOOtWU3/4Ej3RgAGR0LnpNykY5NXKpajk5UwPdLGHAAA2LJ7FG7M4TJRgXJVwfL2hBBCuoVJzQEQkRUAjgfwewBLVHWLf2grgCWTORchk4HZ+R+rNGccDrYYAdg9PI5f3Lc59diufeP4ZcYxm8e2DeH2J5LNUn9532Y8s3csEgEw1/eL+zbj2X3jGC1X8a83P45rHtgSnDM0WsZP7tqI8YqLH935dMKIbZY/PLkLa7YM4sFNexqumLRp9whufCSs0DI8XsGP79wQGM23P/EMbn/imWDda7cN4Y514T2oVDUyVhr/vXojdvv5Eet37sPNj27Hj+/cgNFyFYOjZVx9z6bg3FVrd2Ddjr0Nrd18d8arLnbuHQMA/H7dM7j1sR24+JYngmMPbR7Ev1z3CJ7cmaxURAghhHSSSWsEJiJzAPwUwEdUddDv7g4AUFUVkVSrQkTOB3A+ACxfvnyylkNIQ5gcgLEmIwCt5gB86Mp7cOtjO3H8wfNx8IJZkWOf+sn9uGHNNjx32Twcumh24r3jFRc9RQev+toqAMD6C18bHNsxNIYPXXkPPnv2cyLypHLFxZY9I/jrK+/BqYctxP952eH45/99FADw5JfPhojgb69+EFffuxnXPbQV1z+8Db3FAt5w/LKWrg8A/vw70epD9jqzePXXV2FotBKc+/mfP4Sf3LURh+8/Gy88ZAEuuOp+PPWMp6e/529fhTP9e2CwHbjtg2Opc1z2u/XYsGsY3/2LE3HGV24O1/fMPqzbsQ//+9BWHH3gAI4+YC7ecekfGl67HT3atHsE+8/tw5svuSN4bW5fEYOjFdyydge+fdMTOP3I/VM/X0IIIaRTTEoEQERK8Iz/H6jqVf7L20TkQP/4gQC2p71XVS9R1RNU9YTFixdPxnIIaZhWJUCt5gAYIzZNm793zHMq0pJJvTmznY6Nz3rj7h4Zj0QnylVFueLNtf6ZfZHrfHbYG89Ur3lk62DdedpF/H4+tNlbS8FPzt49HK4pTdZkvz++frGa0T6zL1kh6dnhcWz0k3XNvWqGsZgDYDN/VglXnn8KAC8yAgBL5/c1PQchhBAymUxGFSAB8F0Aa1T1q9ahXwB4p//4nQB+PtG5CJlsjPHWfASgNQfAGP4FRxLH9h/wDMOsJNZasiNTbnJotBIxgMtVN9gdL1cV5Wq2Vn6j73jY0bupwkhpqq6nnbfLrqaZ6HYTrlr3aU5vMuhZdJxAQtRkMSgA0fKi8Xu6dF4/ls3vBwDcuX4XHAEOmEsHgBBCyNQyGRGA0wC8HcDLReRe/9/ZAC4E8CoReQzAK/3nhHQlTScBt7hLXnGz59l/oBcAsG0o3QGotTNvyk0OjVYiBvB41Q2SXyuuG4k8GIPfvGZyVJ0pdACM5t84AGOVKobHq5F1uynJtLZDFv9s1HIZZvUUEu8tFiQYM+6YNVJFabwayo/i0Zs5fUXM6y9hdk8Bw+NVHDC3D8UC268QQgiZWiacA6CqtwHIshheMdHxCWkXdlWWZpOAW5XJGIMyzYjtLXmG4dY9WQ5A/QjA4EgZQ6Nl9JUcjJZdlKtuUP6yUtWIA2J2q+MRh6m0T6uuoliQwBkZr7iJ604rpmNXZap1n2anRABKBSeoIlQQiSRBbxscxVJ/Bz8LEwEoOJJa9lNEsHR+Px7bvrfuWIQQQkgn4FYUyS2uq/jmbx7Dsym67krVxTdueAy7h8exbXAUn77qfvzkro2Rc0Yt6UaaBGjn3jF8+6bH8f07nsLj26MVYX68emOgu28GI8GppOwsGxnK5bc/hSd27MWltz2Jz/7sgeB43OlYs2UQP7rzaQDhbr4nAapg4WwvmlCuaBABKFfdSLWcL/zqYWzdM4rtQ9Gk2WYlQJfe9iSeaKBizsObB/GJ/74Pq9buyDyn4mrEAL/89qfwh1gX3TTnabBGDoBNWgSg4IRG/xV3PIVHtw0Fx4yTdNOj2/HJ/74Pj1nHDKbS0vIFszIrEC3brz/ykxBCCJlKJq0KECGd5rbHd+Kr16/Fo1uH8O23/lHk2DUPbsXXbliLZ/aNYeX+c3DlHzbg2ge34s9eeFBwjpGZAOkSoI//+D7c4huraYbjTY/uwNtPOaSpNQcRgBQHwNbn/8/9W/DV69dGju/YG3V0XvONWwEAbz5xeWCoDo56EQBjjI5XqxgNJEAazL98wSw8vWsY1z20NbGjbjsJ9dgzUsYXfvUwDljVhzs+4wX8RNJ36a+6eyN+ctdGbBscxUuPTE/4d1Wxdzw05m98ZDtufCRaPyBtbGP0z+opJCIA9q1OiwCMld3AIfve7U/h8jueCo7t8J2jy367Hres3YED5/XhY2celXg/ABy6aDbuesore1oqCMpVxedfdwwA4MxjDsC6Hfvw8qP3T71u0hnYiYEQQjwYASC5xVSD2TeelHxs8Cvb9JcKgSwjbjjau7VpEqB9VuLpsNVF9hW+EVdtocmWkeBUU6zYiuti/qwS+kuF1F3srAZXQNiFdtvgKFwFFszuAQCMWxGAqquBofulPzkucl1FS/vejBwqkBFZeQtZOQRGm1/rOqqu1s3HSNPlG6N/ydy+SA6AGxuvt5j8lTdSrkYcMvujMeOae5LWTGysGjoAe0bK2DtWQU/BwXtffCieu2weAOAtJy/Hqk+9DOe8oPXyqmRidEFuOyGEdA10AEhuMX/Q0/6uGx39krl9gaG/b6wS0f3bhmgzScDFgjdjExvlAcZ4TdtlL1cVRcfB3P5iUKLTJstw3jdWwe7hMkTC0p4L5/T4Y7oYGQ+vzTggJt9gxHeezPlAcxWRTNKrbTSnFDgCEBrTm3aPZHbFrbpad/40+ZRxmBYP9EYiAPGx0uRDI+OVVIcMCJ0WM06qA+C/Zmr7b949grKrKBRocRJCCOlO6ACQackW3wGY01cMDOeKqxHdv3m9r+SkGp1ZO4amUkwrHXONzCfNEK1UXZQKgoG+Ep7Zm2xmleUAGAfnEKux2KI5fg6AVQXInr/Hz/Q1x8z5QHPOkIk82GRFAIxhPlp2Ux0cwHcAUoxsm9GU42bs/X0HwDgYcYM9LWgzUq6mvm6Pa2Q+tjNlMDkAh/kOwKbdI6i6ilIrNUUJIYSQDsC/UGRasnXQ7ExrpDSjLa3ZtHsEC2f3YF5/KVLL3SAZxa1Mc6q0nehGSZOxVPwKOAN9Rezcm0xszmoQZuRORx0wELxmJEDlqhsxmI2sqceXwhgJkO0ANCMBstdk3pftAFj3PuNaqq4GBnUWaVV+bAlQ1Q1lT8Pj8XwATUQfRsouqhnlWU0EwKwpzfkw350VxgF41nMA0no9EEIIId0AHQAyrfja9Wvxhyd3Yesebwd9vOJi29BoIM+wq8Vs2u2VeOwtFvCj1RuCBE4A+NGdTyeqzxiMssNVxeeufgDnX7460qgK8ByPL1+zBg9s3JM6xt/89H6ce8nt+MYNjwWvlasuSo6TGgFYOLsHWwdHUUkxjp/2HYCjD5gbvBbkAFQ1KAMKALv8iklGC58WATAGbaXq4nNXP4Bv3/Q4fvD7p3DjI9vwln+/Azf5Sblrtw3hO6vWBe8zsqs0u/frN6zFfRv3BJ/Dt258DD++c0PivEe2DuGzP3swOYDFvrGkA2AMddNL4S8uvRO/X/dMwmBPkxiNxvoM2DSUA1Bx0VN0sGRuH4qOBJ9HkQ4AIYSQLoUOAJlWfOM3j+HPv3N7YBAOjlagChzkl1+0E0T3jJQxf1YpMP7e9h+/D479zU8fQBaOb9gNj1dwxR1P49cPb0uUCR2ruPjOqnW4fs221DHWbtuLO9btwg/9Mp6AlxeQFQE4eMEsuApsTekSvNuX0xy2eHbw2iKTA1CJSoD2xiIAxjlYNBDmAJjd7j+s34Ur7nga/3Ldo/jszx7EtQ9sxe+eeAbXPbQVAIJynieu2A9AKEWKRwCqruLrvqNztB+l+PXD2/Cpn96fuJZ3X3ZnxBFLIy3p20QyXnrkYrxk5SLc+dQu3PTojkDy9bKjFgdrMde8ZG4vRPwk4IxgjolaGFlUPKJgjvUWHBQcwfxZpaC6FBt+EUII6Vb4F4pMS9xYsu38WZ6Ba8tHyhUXvUUnMNj2m1VqaOyCb+DutnTs5djOvNl5rqent0t/VlzXSwLuKyZkMMt9ff/mlEZTZu6DrRyABbPDHAC7gpHZ/U5IgGYnIwDxucyajILG3MsL//R5mWsDgO1WhaDlC2ehr5T9a6eRSi1pEiBzn4/Yfw6+/56T0Vt04KoG9+Ydp67A/FkluBrKgz72qiNx9nMP9HMA6kUATBJw8vMcq1SDpOqeghM4GIwAEEII6VboAJDcYgxRY7rZRpzR55uqN/P7PePe1qGXqy5KhTAB+MAmurQ6EnMAYoa+MTLr6entzrzlqqJUEMztSzoioQOQ1M6baz3IWv/CjByA0XIVBUcCJyaQAKVEALbE5jKOgUlgHhwtY3ZPIYiuGF1/PMHZXvPcvlLQpCyNUgO75mkSIOMAmOiD6egbJD0XHRREIvkBfaUC+koFjIxXU6sA9RSdsAqQf+2j48nPc7ziBknVvaUC9vnnMAeAEEJIt0IHgEwb4rvw3msmAmAcgErkfNvgPHBeX8NzFR0Hzw6HMp34jr3ZBa4VAegpOJFyoBXXRbHgYKAv2azKOABGX25jrttEOQAETkQ8B2C0XEXRkcA4HamRBLx5T0YEwH8+NFrB3P4SeosFLB7oDQz9+Gb6RivhN62hmk0jDoCRMZUKyd4FxuZ2RFC1IgClggPHES8C4F9zf6mA/h4nMwKwcHZP8H0x156VA9Bb8q6rt+hgOGV9hBBCSDdBB4DklngfgLTqMSZpdl5qBEADKQwQNYLrzes4cQlQvLKMiQBkOwC9JSfitJQriqLjlQGNM6eviAWze7B+577EMTOGveFsriteBnSs4qLoSJDHYI4tTJUAxSIAvpFtdviHRsuBs7J0fn9QEjS+m/70M6HTMpyyg27TiGzGGOUH7xdKnsYrLkQA8b8UjiNQDb8TpYIkIgD9PQX0mwhAmgMwx3MAKlU3OJ7mAIz7UjLAu+9hBIC/XgkhhHQn/AtFcotdufHhzYM462urEucYecyc3iIcAQZHwgjAeCwC4Ihgz3AZZ37tlprz9pcKKDoOdlsRgHLVxf8+uAXnXnI7gHBnvZYD0FcqREqJll1vPWkRAEcES+f34ap7NiWOlSsanGMwu8/xJOCxuASoRhLwlj3pEiBYOQDGWTlofj9ufWwnrr5nU6LM5v+7fm3k+aKBbEer2MCuuZEArVwyJ7Jm+/od8SRhRppV8pN0K1YScF/JdwAy+g4smN2LwZFyxLHcMTSGv/lJmLx811PP4n8f2ho4XL1FJ0gUZg4AIYSQboUOAMkt9k7zl69dEzT/shNJze54wRHM6inGmmK56CkIrvzLUwAACsXNa7dj7bZoRR+bgb4iPnHWUV4OwEg0n+B9V9yNO9btglqJpuM1cgD6SwVU3bAufcXPAUiLABQdwftPPyJ1nLLvCYkAV/7lKfjWecej4AhEPMN4rFwNHILRshsYw0BY1WZWTxFfOOdYLJrTExj+ZmO3AAAgAElEQVT68WRbYwiHEYBK4Ky880UrAAC3PrYztaLOW05ejg++7Ai867QV+PZbjgcQluyMXmfjEqBPnnUUzj3xYACec2Lb2wVf7hPJAXC8vAAjy+orFmpW6pnbV0TF1SBqMafXu9YfrQ7Ll672S8W+7eRDgnn2jflJwJQAEUII6VLoAJDcYnfitbX29ga00dg7IugpOpHzyhXPGD718IWY21eEqmeU1+ITZx6Fgb4SCo5E5Cz2uK6mRwDiO+OmGo4xUsvV7ByAQkHw2ucdmLomc40iglMPX4jXP38pRASlguM5ABUXs3qK/nq8CIDZLTfX0Ft08I5TV+DYpfMw5hv68fwF4xiYqxgcLQe5BicdugBHHzCAodFyqpzm/Jcchk+cdRRm9RRx0H6z8LZTlqc2UrMlWVkYB2DB7F5c8Jqj/euKRgBEJFIFyDg9VQ2dwlJRUnsWGIzBv9d3hIyMzGZotIKCI3jTCQcBAHqLhcCpYhJwF9J67z5CCJlW0AEgucWOAGRJbczueMER9BadSFWeclVR8g1OTzOu6KvjABibLq7vtnMAbJ253WE4nidg5jKVgCpudhWgWnKSiuumGrI9BQflirfjPdtPvh0tu5Ek4DFfO2/G7yk6GMsoYRpGALzndgQA8KIjdp8Fm1LMsC86TmrSdiOyGSMB6i8VAglXXALkVQGK5gA44jmN45ZTIDXqjhqnyTgc6Q5AGXN6i8E4ngTIlAHlr9duIquzNyGEzET4F4rklmpGBMAm3B1HJAKgqpEcAEcErqKuA2AMvbhyxDZmXdWwD4D1erwkqJnLOAaVqtcHIDUC4BvGafbqeEVTDdmeomdkj1VczPJ3s0crVRQLTsRh6C06EQPW3KOxajwC4K1f1ZMteUnAoVE8t6+EPSPJEp1AsiJOqSCRCkiGRppnGYO8t+hEZDb2jrsjiFQB6jERAEsC1FNwavYdmN3rfT5GChV3Yswx+/OyIxiUABFCCOlW6ACQ3GI7AFn19iuJCID3PNCG+0aawDPc60lQzC6z2d2d6xt/tgNid5u11xV3UoIIQDVcUzEjAmCSdtMkSuVqegSgVJDAAQgjAF4ZUJEwCtBbDMfsidyjmAMQOE/e43JVExGAPcPRDsbBuDHDvlhwIj0QwvPqG817RyvoLxXgOIKStctuG/Om5Oe4lQQclgbVyGtZmAiAiTik9R8YjDlBvbYDQAkQIYSQLoUOAMktFbcBCZCVA9BbLCSMWxMBEJGG5MFBnXn/f85Cv3ToeCwCYDrG2kb/aNwB8I1Fu2lZyXEwJyUCYHaT0yIUFddNjQCUCt5u/lilGhizo2U3MPyNU2E7PfY9ivfGCqIn0EDqMzfiAJQiidHxtUSeO4JyVbHigv/BVrvfQIZBbs8zNFZBv+/QOI5Eav8bnKARmNH7h0nA5ZgsKAsTAXjv5asBpEuABmtEAJgDQAghpFuhA0ByS1YSsI3ZXY8nAScdgFDaUgu70yyAwPiLSIBcYMRPBLUdk+2D0cZaxog17634EYCCI8GOvcHkHPSlRCjKVU1VNxcdb8d7vOIGxiwQymyME2PvWvf4UYO0+2CuxXXDcqpzLaN4oK+YWec/HlmxpT63Pb4zeFy1ogK//uhL8f33nIQv/clxOPXwhcHr+8YqkUiIGcs2uL0qQLB2+8VPArZkQUWnpi58dk/UEfvQy4/Akrmew6dWJaS5kQhAuK5GmpoRQgghUwH/QpHc0kgSsNlddwSRJOBxa2fYHFdNdrGNYzaZjbFptOW2A1DV9CTgzbtjDkAgAQqrABmj0VQaMhg5SWoEIJYAayg4ns7ergJkj1WwdP/BsYKDStVNrdATdgLWoKHaQCwCkEVcDmPr421pjZ0XcOSSAbxk5WK85eTlEWPay9UIn5f8se0pTA5AIAFyfAlQIgk4c8mJrsVz+0tBuU9zf4ZGy5HoRC8jAIQQQnIAHQCSWxpJAjavF5x4BCCaA+D4ZSPr1QkMIgC+cVcsiFdtJ6MKkC0N2rR7GDZhEnBYBcgYynP7ixHdfKDXT80B0FRDtug4QTKyHQEwY5luwD1FezddUHa1ZgMzV8PE2EgScH9SumSIS5Rs7f7esWhztjTixnR/TzICIBkSoFLB63wc9Aao1M8BKBUkEbXoKTjBXFU3jABkJgHTASCEENKl0AEgucUYYYpaScB2DoCV4FqJSYDgGbZ1FECBoW0Mx1LBQakgsT4EipFxv5KO1XgsHgFIVgHSwMAc6Cuht5R0AOydb0O5RgRgn9Xoy2Aq8oRJwPZuuhcBGMvojutdn+0ANBYBiGNXBTJ18wGk9hAAkLg+WwIUXI9dBtQJ+wCYz7jgRwDKVS8PouBk5wB4n2v0XveVnMCoNzKpeCWk3mLSMSGEEEK6Df6FIrnFNhazpDtBDoCTngRsdmxFBKr1+wQFVYAKphqQBOU2g3VZZUDDhFrFpt0jOGi//uA8Y8ybajhl1w2M2YG+9AhAXzG9ClDaRnbBkaAakZ1TUCsJuFjwtPPxhGUbY/gCiOjf08qXZmEbx6ZzLoDU0qBAMjfYlkKZiky2MS8iqLp+rwcr58F1EUQFzHlppDkAPYVCcO+qrmLfeBWuRq+bVYAIIYTkAToAJLcYB2C0xm51WAUo2gdgPCMJ2K2TBBDkAASOgGcoRhwASwJUcRX3b9yNQz99Da5/eBsO3m9WcF6/FQGougrV0JhdOLs3YlgaY/K5y+Ym1lRx05OA7W7Fpg+AN1bY/AyIRQD8+zGcUvLSoEBQBche49wmHAA7AmA3D0trDgbUjgAUU4z5gpPs9WCSgKP9H7LW56CnmMxbMOuuuBp0CJ7DKkCEEEJyRuN/sQnpMkwScNauMWD1AZBoJ+AwByBsBFY/AyCZA1AqiO8AWNEIF8HOOwDc9MiO4PF+s8Mdc7sPgDF8jTH7ibOOxO7hMl7zjVsj833q1Ufj9CP3R7EguPGR7bhk1TpUqhoY8zZFywGY3ZM0mAuWjMl+DxDV5cdxVTE0WoFItFJOM1Vv7C65u4dDB8BItm76xBmR8+OXF8kBcKKfiXe+X/Gn4kbyPIwEqCclb8BmoK8YuZ7PnH00ls7vD6oxVaoafLfs86LOFB0AQggh3QkdAJJbqr7RXa0h3DfOgeNLdbL6ADjiGbb1cgASScCOnwMQkwANW1GJfZbGfY61Ex9KgKK16QHgwHn9OHBeKBcyBnOp4ODFKxcBAObPKuGSVeswXnVrRACSOQBxg9mWqhhpTlY5TyDMAZjTW4w4Hs3seNtVgHbtC5uHlSsu5vYVceii2ZHz4xEAu0KPWUO0CpApA+oGlZ7sJGA78pPG7N5CxLA/46j9vXU7JgLgBt8Ve23RCAADrIQQQroT/oUiucUY/rVUO2U37AMQyQGoRA1u8Q1GrVsFyPwMcwFKBScYz1uPYtQyoO3ddNsQt6sAVazutKnzprxsJ6SmJQEXC4J947WqACExp7kf9SIAg6PlRMfiYhMGrz3ns1b34Iqrqbvy8dfsHAATyYg2AoNfBSg09u0k4FIx+R6bWaVi6s6+cVyqrvpVoxBxviJJwJQAdR31/n8TQshMgQ4AyS1Gr1/J0I17x7xzCk6YA6CqGIv1AQgbgdWeUyzDH/Cq5sSTgF0rBwCI6ult6Uqf1QfAOCpZlWPSjGtjvFYyyoA6ElYnikQALIPYvhZ7nn01HAAgWf4SaDICYJ27a6/tALipuvyEBKiUXdbUvOaqV840TAIO+wDUywHo6ylEkrB7rCgC4EnIjONpfzR25aYiJUBdRa2eD4QQMtOgA0Byi9GLZyeOhlp/8XMAAC8B2OzYB1pweNKW+hIg8zMaAdg+NBacYxqBGbnPXqvKjW24Bg6Aa0UAMizSNOPaGOteFaD0HAB7LnNKMWYwR3IAfKO1lgPgqmJwJC0C0LiFZc85ZM3l9TRIjlMrCdgJIgDhcYno/cOch33jFezaN2597ulr7i85QZQACHf2zT33krbDErPBeSmVm2YqInKwiNwkIg+LyEMi8uGUc0REvikij4vI/SLyR1OxVkIImWnQASC5xUiAyhlJwH2lQiIJGPBKc5ZjkhsvCVgbkADFk4C9HICHNg+G63I9CZBJ+LUlLrbhalcBMg5AdgQgpc6/VZEmzda0Nei9RSeh/Q+TgMM3hxKg9ByAnqIT5ABMKAJQY3e8oQhASllT2xAv+GVdy7EqQBt2jeB3TzxjlX9NX0N/KZoD0BOTAFVcN4gA2A5Ln7WuEnMAKgA+rqrHADgFwAdE5JjYOa8BsNL/dz6Af+vsEgkhZGYy4/9CkfxikoCzugD3lQphErAdAai4iaRbr3NsGAFIa7gFhHIPY0wXHUnkIKgCI+UqViz0Elkf2zYUrikiAQr7ABjJUH9Kp18gKwIQ6tHTdrJtp6G35ISJxE5UzmLLi4IyoOPpEYDeguNVARorT1AClP2rp9kcACfFAXAcz0G0HQBbImQ7fmn09xQiCb1BDoBJAq7aEYDwfUvm9gWPCzNcAqSqW1T1bv/xEIA1AJbFTjsHwOXqcQeA+SJyYIeXSgghMw46ACS3BGVA3QwHwNLmO04o4xiruKl9AFwNEzuN8R7HGNqhBMjBM3vHIueMVaqouIoj9p8DABgctXIAUiRA5WqYM9Dfk/5fMs24jpa9THmPZYD2FKwIQCF+DckcgKwk4FLRgetHAOb2T0QClH1u2pFaEiAzlO1TeFWAFONVDasAWUOEyd/pa+gvRRuxBQ5fIazcFEQArBUvGehNvIcAIrICwPEAfh87tAzABuv5RiSdBEIIIZMMHQCSW1y3tgSot1QI8gQckWBHd6xcTe8EjLAPQNZudqCjN0nABcGOoagDYOQzy+b3R+rCA+kSoEpVg74BfVkRgDoa/7Rdc/s9vaVCYPiXYlKgtCpAwxkSoFJB/E7AE5UAZf/qSduVb1YC5EV0TB+AZAQg7B6cFQGIdgIOkr+tqIuRi9lrK0acBv56BQARmQPgpwA+oqqD9c7PGON8EVktIqt37NhR/w2EEEJqwr9QJLcEScApEiBHPGPVdAsuOI0kAWvgAWTt3hqD0ez6Fh0nssMPIOgQO6uniGXz+yPH7B3+XksCNFpHApTW6MuJOADJ90QkQMVQAlSIdQJO6wOwN0MCVCo42DdWRdVVDEygDGit3fHUikax820HIEwCjlYBMhIg09HXdohMBKhWDkCtqEul6sIEnrKaiTECAIhICZ7x/wNVvSrllE0ADraeH+S/FkFVL1HVE1T1hMWLF7dnsYQQMoOgA0Byi5HrjKdUASoVnERdeGNwj5WtJOCiMYaBPSNlrNu5z39e2wEwc6cls965fhcAz9hftl/UAbB3+I0kabwS5gDY5TrrUYxIgGpLhHqsJOCwE7A/jh0B8M+5/qFtqXP2FBzsGfE698YjAM1seNfqGpx2LfGXUsuAWueYnI54ErBhzL/fWRGArEiMiZAMjpbx2PahxLyR65jhDoB4ntF3AaxR1a9mnPYLAO/wqwGdAmCPqm7p2CIJIWSGwk7AJLdUa5QBTToAgp6Cb3BXXYxVPAOwx0oGvXP9s7hz/bMA0iU33nneT+MAlAqC049cjFvWhrKEy363HoBnpK7cfwC3PrYzOGYb+CWrio+RAMUjAGcfdwCueWBr6loK9SIAsRyAUPLj/TRyp1JKBCDNqfLe62CHn/MwkQhAzRyA1CpANXIAUiVACPoA9KQ4AKPl2hGAFx6yX+rrJnryvivuzlzb6553IH51P21YAKcBeDuAB0TkXv+1zwBYDgCqejGAawCcDeBxAMMA3jUF6ySEkBkHIwAktxgJkEnG/Ma5L8Bxy+YB8AzAeFKoHQEYGq2gp+iEOQCxsbN2b43cQwOpkIP/eOcJOHLJnMS5faUCPn320bjhYy8NXrMNV2MwV6phBKAvlgT8zXOPx8NfOCt1LbbBXTcCUAgTouf0eoa7uW8R3bplmH/zvOMTBnKpKBjyJU5zJ5ADUCsCkO4ARJ+nSoBSGoENjVYwx1+nvb6RGhGAVZ98GY5fnu4ApMl64kN8/c0vwEP/kP6ZzSRU9TZVFVV9nqq+wP93jape7Bv/8Kv/fEBVD1fV41R19VSvmxBCZgKMAJDc4sbqb/YWC4GB7TgS2cUvOBLsBI9VqhgcrUQM2LiOu34EwPtZ8huBxXfDgbCW/BH7D0ReM5hd8HI1OwJQLDiZCbORxlcpx4NOv47AcSQweo10R60oRrAmy6lYNj8saRmsxzqejADUTpyOnFuzD0BaEnAjEYDo+ZWqYu9YJVinPcZo4AAk5583K/lZ1lp3fG21PjNCCCGkG+BfKZJbKjEHoOBIYGw6IpEdYccJIwDjFRdDo9FOtnGbM2s3Oxwz2rgr7fw0Pb+9wy8iKDgS6QOQpT1Pw7w/bf3emvy6//4ajZNhHIAgjyEiAQof95UKCcfCLo0ZjwDUy5uwSZMLmb4IaaPU7AOQkgTsOILB0XJknVEJkKlyVDtyklx3/QgAIYQQ0u0wAkByizFgDY7YxmBSE273AYiXsYwbqdnGrJnb+2kMwjRNe1pN/8QOv+PtVLtaDaIJzVBwvEpHqUZ2Ibo24zCZ+v2mik0kCdi6jv5SwTO8rftcKobH06IeaaTdyrT75TkFbgtlQM3P6Oe9e9g4AKXE8VG/ClRq/4QaFn0hxXHJSiQm3YemVwwmhJAZByMAJLdUYxEAx4oAiMQkQFYfABMBsA3YuCGYpVAxO9HG+TBjphmGacZ8fIdfBPjR6g0YHCk3tftvKNaMAEhkjYa5sQiAbYzbO/P9PckIgH1Nc/sb2z9Ir+qTvfPeahKwxD5v4/AYR88eYTxwAFKcjRq/FdMiAHQA8gE/JkIICaEDQHJLwgEQCYyxgkjkD75I2AfA5ADYEQCJmbppBr2ZA4gmAXs/k9bFgtk9weMPvOxwAEmnYF5/CbuHy7j+4W2ZPQBqkVYBxxBGJ6JzGscnfg1AVALkRQDiYzqR41m8/vlLg8cfevkRiePmvacctiBxLWnOgX17e4pObLc/mQNgj2Gu15aM/bW/plTHyXrxoP36I2tMywGgYUkIISRvUAJEckvcAbCNfkeiko+CI4HxNtZQDkD6nOa0eB+AuANw+btPikQYPnnW0fjkWUcnxrv6A6fh1C/fiO1DY1ixcFb6pDWo1WwqcIZi58RzAEpFWwIUjwAIwoKhoZHt5Vtkz/22k5fjW+cdn3m8p+hg/YWvxe1PPIM71t0RWW/aJdlzxR0Pc33RpO/wuLneil8F6fOvOwbvfvGhkTnTxgOA2/7m5ZnHwrUl10sIIYR0M4wAkNxSjel5HSc0FMWKBgAmB8BEAJI5AA0nAcckQEY+E98ZbrQL7JKBviCxthUJUCMRgKQDYMqA+tdgJwHHSofGNUC2g9XIuuphy5MCOVNKYq5TywGwPvO0803OQ9lNOjxpxnstx6bEHABCCCHTADoAJLdU3WizKk8C5D92kKgCZAzt4fEKhsersRwASYyVhnk5Lp+JS4YaLQPpOIKlfrlNO7G1UQIHIGW6QtDxN3ots/15NKUPQNQ4TpriToqxnUa944Zea77aOQDh4/h9cgInKPkaEEYAqtWkw9PoOoM1NlAGlBBCCOl26ACQ3JKQADmhwWo7A+a5+InAu/aNA0DNKkBZO/jxCECgs4+d30xTrKXz+wHU1tRnYRyQtF3zrATheCJzMaMPQBqNRgAavXxT+hMInZh6fQDikRLj4MSrABnM51z2Hcas8xqBZUAJIYRMB+gAkNySTAKO1oSPVwECvB3nHUOeA2CkIUDSiMssA+r/jzG755JifAKNS4AAYNkEHIC0JljhMcc/lr6WoJlZRhIwkO081CqVaa+rHj2FZGfkdFlO+Li/FP21ZXblnZTPu6foBOVfKyYCYEU8mt29T+tf0KwTQQghhEw1TAImuSWtCpC9Q23LO8zD3qKDLXtGAAD7zbIdgMYkQPEqQMb4S+QA1Oh0e+6JB2NotBI8P+2IRbj2wa34o0P2y3xPFoGhnZbMGtwL78H5Lz0Mj24dCo6nRQDijks8smBHWGrRqGHda0cAYuvNGu/FRyyKHAtzAKx1+k9mW3Ih830pOMnvRaOkRwDoARBCCMkXdABIbkkkAUtYmcYRiVSCMUZfb7GAJ3fuAxBKb4BkP9hsCZD30xjPZr74znDaTrHhwj99XuT5G45fhjccvyzz/FqERnPyWMG/ASaa8ZmznxM5bpwYuw9A3JhNREZSjO00GrWJ7c7CjeQAvPI5S/CxM4+KHAuqAMWqPgHRJOOyXwUocr2pfYezSYsMMQeAEEJI3pgUCZCIXCoi20XkQeu1BSJyvYg85v9sfnuTkBrEk4ALjkR2kaNVgEKDcHi8CgBYtl+/dTw6dpYEyBjIxvewy2LG19IJbMlTnLAKUPp7wzyG7F8D8VGDCEud62v0+qMRAOMApBjZDZQ7jUiAUnogmAiAfb2T8TFRAkQIISRvTFYOwGUAXh177QIAv1HVlQB+4z8nZNKoRu1/iIQ7uiKxKkCWBAgABnqLkT4AcQM6S+MeTwI2p8UjBqUaEqDJJNg1r3EsOwcgKQGKkyWNmiwJUE+KHr9eH4A4ZoioBCg5vikDalfyqefINEKzUQRCCCFkqpkUB0BVVwHYFXv5HADf8x9/D8AbJmMuQgypEQCrkoxtUBoD0jgAtvwHaKYPgPfTjSUBx8t+dioCIA1EALKMZ+NAxTsFR8bPeD5ZVYDs+2Y+u1RnpoYDYIz4tKRvWwJkGoHZSc+T8SlRAUQIISRvtDMHYImqbvEfbwWwpI1zkRnE8HgFX7luLfZaibSAnwOAUA8eT4IFQoPQlv8ASSM5y4APdnv93XMzdjIC0JkCW8E0aTkANSoEAYDGSpk2Qi2Hw6YVXXyhxti1lpj2PvPY/hwqqUnAE7femQOQH7T+KYQQMiPoiJWinqWR+rtXRM4XkdUisnrHjh2dWA7JOd+99Ulc+tsnsXnPaOT1eBWgoEGUZfCZkpCm+ZYhbsJlOgD+y19643E4/cjFeM6BA4k5ar1/sqklm2lUAhR3Vt592qH4+ptf4D1JJAFH5623rkY476SDcfHbXmh1cW5uvLRmaObzsKVY/3jOc3H6kYtx/PL51rgNLzPgbacsj66NxZRzAaVahBAS0s4/XdtE5EAA8H9uTztJVS9R1RNU9YTFixe3cTlkurBnpJz6ut0HQGISIENPhgSo0U7AxrA8duk8fO/dJwUORdyQbGZXfSIE11ujEViWfMYNOgFHj3/+9ccEVYkyk4DrSoAav/4vv/F5ePVzD7CqACXfW2u4tOThoDyrZZ0fdcAAvvfukyKNxFqJAHzxDcfhq3/+/MT8hBBCSF5opwPwCwDv9B+/E8DP2zgXmUEMl6uprxecaAQg6BBrGWgmB2BZ3AGI/U/IUvBkGb5xAzyeE9Augh35lOkKNRprAbYEqEYOQIZjVM9wbmVXvFZJ00YiAGrFGNO6A9eas1ns9dD8J4QQkjcmqwzolQBuB3CUiGwUkfcAuBDAq0TkMQCv9J8TMmFGx0MHwDbwoom/0YRgQ5YDEDfg61UBSr4efd6pCEAtmU+xjgTIGMw9tZKAJf15PQO/lV3xWtGMWvOlGflBYnBdB6C1zymt6RghhBCSFyYlCVhVz8s49IrJGJ8Qm2HLAegrOtjnP3ccsarUWM6AZQRmJwFH58juA5C+pkarCE02tYzPMAci/bjJASjUKgOaMV87koDDz6u58cJjmnitXZ9DNOG4LVMQQgghbYPpayR32BKgXkvPXbA7ATvpCbK9xQIKjmD/gVgScJN9AOLE39+xCEADBnnWsZLvDNVaaqIzcGzezDlb+M0S9jRIywGoJQFKmV+iY2bRagQgreIQIYQQkhfaWQaUkLYwMh6W/+yz6rx79f7NYwmMP9sIfMPxS3HQfv0Jw7DRTsDZDkD8eYeSgFOaYBncWKnSOD86/1Rc++AWzOrJ/jUQf2eYA1BnXS1cv3lLehWg+nNFcgAalQBZzsPnXvsc7Derp6G12sPSASCEEJI36ACQ3BGRAFkRAMeRSJnK0KAMDbQXHrIALzxkQWLMuBGXtYPfaBJwp6jVmVcDByD9vUcdMICjDhhoaj7bwWpkXc1QK5+h2SRg85nXi1TYn9uZxxyA5QtnNbRW+ztF+58QQkjeoASI5I4RywHoiUQAJLJDnVYFKIv4Gdl9AJpzDNpNrWZfplHyRHaoE7kRDeYANHLPs97TbAQg7bMyaQ218hvi4zaz5FbfRwghhHQDdABI7siKABQijcAkTIJtwEDLKneZPC/r/fXnaAfhOpMLqPpb4hOTIzV3H4LjLfxmqZVgXDPZ2UiA7CRg/0Ovl4vR6k4+cwAIIYTkGToAJHcM2zkApfArLI5tRNpVZRqIAMROiTfHMmQ6BlMuAUoec93aEqBGaDUC0JoEyJ8zbR0135eUAAVVgOquM/meRoh0HaYDQAghJGfQASC5Y8SuAlSMRQDMYysfoJFSkIkk4CalPlMXAciev9d3jhpNbE0jPqw0eE9bkQA12mQs+b6U+RtMApYWd/KZA0AIISTPMAmY5IrRchXlarjVa0cAojkAUjOpNE78nCzDsdEyoJ2i1jWeceT++OzZz8F5Jy9vefxkBCD6s9H3NUIzkq3IXDASoBATDWimE3Az8zp0AHKJ2mEiQgiZwdABILliy57RyPNoFaCogdpoycq0c7J2sDNzAOpP0RZqSXIcR/CXLz1sQuPHpU3S4C79hDoBN/tW/3zbtjP5D830AWjGiSu0GDkgUwc/JkIICaEEiOSKTc+ORJ73xqoA2YmkgUHZwLiJJOAmIwBTVQUoWGeb5k/2N/DnrTNfKx14C8HYzb037exq1W16Hc1FAOzHtCwJIYTkCzoAJFds3h11AGpVAUrrEJtF3ITLem+3SYCcFo3mVjERgfpJwM2P3XIEwMeuAlRtVAJkHW81B2CqnD9CCCGkVegAkDd/tmwAACAASURBVFyxafdIxEC0HQCR0EAVac4ojxt/eUkCLjQR5WiF+LiNOhytOETGGG/2vcH5tgTIb4LQtipA1qlTVQGKEEIIaRU6ACRXbNkzgsVzeoPntgRIJFr5J608ZBZxw77ZRmALZ/emvt5u7LKn7RwfAA5bPNvqrpx+/vIFjXXSTaPVaIY52/6YK34J1HqNwGzjvZneBXbkoJWeB4QQQshUwj9dJFeMVVzM6gl3/e0IAGBXkhEsnO2Vv9y5d6zuuHHD3jSQKhUEv/jgaXXff/ZxB+Bb5x1f97zJxkiV2i0BOnTRbPzo/FPD+voZHsdP3n8qrnjPyS3NYcZsOgc4SAK2JEC+BqiZCEAz8zIHgBBCSJ6hA0ByhatRg8uOAAChEScCLNuvHwAwOFpBPbIaXh2+eA6ed9D8Bt4veP3zl9Y9b7IJ7kWbk4BfsnIRFg/0BtNkGb37D/ThxSsXtThXa9GMFAVQUAWomU7AzAEghBAyU6ADQHKFqxox1ntjEQC7CtCy+f0NjxvXcbdSxWYqsCMe7SDuX4RlQCd/riCfoWkJUPL8qpEAObV/xdlTNZcDwDKghBBC8gsdAJIrVDVicPXFIwBWmcoD5vU1PG6jOQDdRpurgFpJ1e0z/A21uho3QqQPgO8AFOvkALTa0CsnXw9CCCEkFToAJFe4btRQS+QAWEnAvcXosVrE6/43k0A8lRSsiEcncFrcpW9o7BajGakSIN8BaKZcKSMAhBBCZgp0AEiucGMRgHgOQKsGarLcZT6MusBobtP/5EQjsPZMA2ByS5oeumi2/7N2VaJWtfxR6VBTSyOEEEKmnOJUL4CQZlBEjbZ4BCBMUvV+/vaCl7fUCbhV+//WT70MPcXO+dWho9KmHADz00irWqzU0wgTzWewqwC9+cSDsXLJHLzwkAU138McAEIIITMROgAkV3g5AOHzhAMQ7CJ7PxtNBM6qAtSsbXfwBOrgt0IhMJrbM378ftbrAzARWr3nZo0ae62e8W/P2ey8rb6PTC1drugjhJCOQQkQyRV1y4C2aKDGDWgzR7fnALTTIAeSEYB2dr0Nk4AnJt9qZc5m5231fTMJEblURLaLyIMZx88QkT0icq//7/OdXiMhhMxUGAEgucKNRQDiVV6CXeQmx43LOPKi6257EnCsylA7qw7VimZoyqMaJzVMqw4Njf6GuAzARQAur3HOrar6us4shxBCiIERAJIrXI0aX0UnngTs/ZzoLnJeDLxWHZ5GSUQA2nhbWi01GlYBat4DaPV68uIgTiWqugrArqleByGEkCR0AEiuiOcAxOv1t2q4x98XN/COXTq3pXHbTZCU27ZGYNHx21kGtFBjzBULvao+px6e7DJ82KI5AICTD13Y9JytRk6Y+DtpnCoi94nItSJy7FQvhhBCZgqUAJFcES8DWirEHYDWxs1KAjb89P0vwvB4tbXB28hU7US3pQqQ2clP2cg/6oAB/O6Cl+PAlOZuxyydm3msHq1HAOgATAJ3AzhEVfeKyNkArgawMu1EETkfwPkAsHz58s6tkBBCpimMAJBc4bpR4ysRAWjRNE3mAJjKMp412lcqYMHsnpbGbie1ds0ng3iR0VYr9TSCiWZkCXmWzu/PjDzUOlZzzpYjRi29jVio6qCq7vUfXwOgJCLJEI93/BJVPUFVT1i8eHFH10kIIdMROgAkV7iqke3n7ByA5sZN5gA0v7apIDCa21SuKN5moJ33ZSoqL7UaQYl3jibNIyIHiO+1ichJ8P4ePTO1qyKEkJkBJUAkV6hGu97GqwC1Wq4ybnPmReIRRiraQ1D/H/FqQ23IAQg+1855AK3mMtD+r4+IXAngDACLRGQjgL8DUAIAVb0YwJ8BeL+IVACMADhX2+XJEkIIiUAHgOQKhcKR0AMoZkiAmrXr4mZHTuz/mrr5ySBe/We6RQBaJS8O4lSiqufVOX4RvDKhhBBCOgwlQCRXxBuBJasAtTZuvIRkJxpfTQaFQDffXqs5LAfaxhyAHDkAtP8JIYTkGToAJFe4qhHjq1SIfoUn23hst2E9UdptNMcN/vYJgDrnzEwGjAAQQgjJM3QASK6oFwEwTNQ86/adf0MgAWrT+KHBH+8DMPlztVvONJnQASCEEJJn6ACQXBFvBBbPAWh19zgPRmcawa55h9bf1hyAOmVAuwkmAeeTvP4/J4SQyYYOAMkV8UZg8Sou5g9800nAE13YFBFef3vLgJqfQZnVNkRI8pUDQA8gb/AzI4SQEDoAJFe4bmN/yJv+Y58HqzOFdktRktr/9s1nmprlIwdgqldACCGEtA4dAJIrXF8C9OFXrESPnwB82hEL8aLDFwKY/H3wbvcLpM26eYl1AGtnOdA2BzMmFeYAEEIIyTPsA0ByhfpJwB991ZH46KuOBAD84L2nJM6bcBJwTuy7wGZudx+A4Hn7y4DmgTytlRBCCInDCADJFfEyoHFaNYRzsOmcShABaHcfgA7kAITX0v3Q/ieEEJJn6ACQXKGovfsaGMITTAHodumPwRji7V5vqx2Wm5ojkDN1/81nBIAQQkieoQNAckW9CECr5CHxNJUO75o7cU3QJBI4M5M/9KTDJGBCCCF5hg4AyRUmB6DWcWDiEpW8bPC2OwcgmKcD96PdCc2TCSMAhBBC8gwdAJIr3FgjsCwmap8tXzALhy2ejb//42MnNlCHaHsOQFtHj5ID+z83DiIhhBCSBqsAkVwRbwQ2WcR3nftKBdz48TMmfZ7JRjqUORu/5e20f/OQA8CmUoQQQvIMIwAkVzTcCKwDa+kGOlU6P37P22EAmzG73/wnhBBC8g0dAJIrtI4EqNXd47wanY7/P7jTu+btcLCcTnkzhBBCyAyHDgDJFW6jScATLAOaFzpVOacTCbrhteT0wyBdD79ZhBDiQQeA5ApXNdj1rkU7GlV1M53qAxA8b+PtzaszRrqbmfUbgRBCakMHgOQKV4Faf8pbtR3zuuvc6e657bxPeSoDSgghhOQZOgAkV9TLATDMtCIt7c4BiBvn7bi9YQoAPQBCCCGknbTdARCRV4vIoyLyuIhc0O75yPRG0aYmTDm1OTtVOSfecKw9VYCicxBCCCGkPbTVARCRAoBvA3gNgGMAnCcix7RzTjK9qdcIrNUd6rzanMF1Tos+ACwDSgghhHSCdkcATgLwuKquU9VxAD8EcE6b5yTTGNfVmrvPgXxkhmiAOnWZnag2NEM+MkIIIWTKabcDsAzABuv5Rv81QlpCGywD2vy4+dx37lTpzMQtb4OxHpcZEUIIIaQ9THkSsIicLyKrRWT1jh07pno5pMupJwEyzJTN5E7r5tvpKIWRHXoAhBBCSDtptwOwCcDB1vOD/NcCVPUSVT1BVU9YvHhxm5dD8o6rgFPDA2i5DGhObc5O7ZrHk43b0WeBEQBCCCGkM7TbAbgTwEoROVREegCcC+AXbZ6TTGNc1Ya04jNFTx72AehUCCA672TS6Z4GhBBCyEyl2M7BVbUiIh8EcB2AAoBLVfWhds5Jpjf1cgBa3T7Ou9HZ/k7AtZ9PJnnNxyCEEELyQlsdAABQ1WsAXNPuecjMwFWtaXy2KlHJr83ZoT4AHYg0MAJACCGEdIYpTwImpBm8JOBs435ef8n/2Zxvu9+s0oTWNVUM9HnXuXB2T1vnSUQA2hACmN1jrqV38gcnBMizp08IIZNK2yMAhEwmXifg7ON/8aIV6CsVcO6JB2eflMJfnX44XAW+dsPaiS2ww7zo8IW48I3H4Y9fsLSt8wRJwG20n046dAH+758eh9c+r73XEufHf3Uq+kuFjs5JOs9MyQsihJBGYASA5AZVhSpqNgIrFhy87ZRDUCw099XuKTp42ynLJ7rEjiMiOPek5ZjV015fPi7PaUsVIBG8+cTlmNPb2X2Jkw5dgOMOmtfROQkhhJCphA4AyQ1m97lmEvAEaNe404F4iU7eKkIIISS/0AEgucH1rc9GGoG1Ao3axuG9IoQQQvILHQCSG1wTAWiTB1BLWjTjCRqBMYmSEEIIyTt0AEhX867//AO+dM0aAGEEoF12Ou3/bMyt2X+gDwBw8IJZU7cYQgghhEwIVgEiXc3jO/YGCb3MAZg6zK155XP2x3++60S8dOXiqV1QF3DdR16KWT2sHkQIISR/0AEgXc3IuIty1QXQgRyA9gw7LTBVf0QELztq/yleTXdw1AEDU70EQgghpCUoASJdzch4JeEAtKMEJcAIQC14awghhJDpAx0A0rWoKkbKVZQrnuHvtrkEJY3cbHhrCCGEkOkDHQDStYxXXbjq/Rwer2DfWAVA+3bq6QBkw3tDCCGETB+YA0C6ltFxT/pTrrp4/j/8GuVqu3MAaOUSQgghZPrDCADpWkbKVQCeA2CMf6B9fQDa5VhMB+gckWYRkUtFZLuIPJhxXETkmyLyuIjcLyJ/1Ok1EkLITIUOAOlaQgcg2nyqXQ272AisBrw1pHkuA/DqGsdfA2Cl/+98AP/W7gWxjR0hhHjQASBdy8i45wCMV9zI6+3aqWcEIBveGtIsqroKwK4ap5wD4HL1uAPAfBE5sF3r4XeYEEJC6ACQrsWWANm0LwmYJkIWvDekDSwDsMF6vtF/jRBCSJuhA0C6llHfARhPOABTsZqZDW85mUpE5HwRWS0iq3fs2DHVyyGEkNxDB4B0LcO+BKgckwBxN7rz8JaTNrAJwMHW84P81xKo6iWqeoKqnrB48eKOLI4QQqYzdABI12IkQOangR17Ow9vOWkDvwDwDr8a0CkA9qjqlqleFCGEzATYB4B0LaN+BMCNle6gLUpI9yMiVwI4A8AiEdkI4O8AlABAVS8GcA2AswE8DmAYwLumZqWEEDLzoANAupb4zr/BYdyq47APAGkWVT2vznEF8IEOLYcQQogFTSnStWQ6ANSjdBzeckIIIWT6QAeAdC2mD0AcJgETQgghhLQOHQDStYxmRgA6vBBCp4sQQgiZRtABIF0LJUDdA+84IYQQMn2gA0C6liwJECMAnYc+FyGEEDJ9oANAupbhjAgA5SiEkFZQrX8OIYTMBOgAkK5lNDMCQAeg07AMKMk73DgghJAQOgBkyqhUXfznb5/EWCU09IfHK7j89vVwXa2RA9ChBZIA2k6EEELI9IGNwMiUccUdT+Effvkwqq7ivS85DADwlevW4tLfPoklc/swUq7CkZROwDRGOw5vOSGEEDJ9YASATBmP79gLAChaW/pDo2UAwO7hcYyMVzHQV0q8j6H8zsNbTgghhEwf6ACQKWPrnjEAwJK5fcFrPUXvKzlWcTFarmJef9IBYA7AVMB7TgghhEwX6ACQKWPr4AgAwLEiAL3FAgBgvOJipFzF3P6kSo05AJ2HPhchhBAyfaADQKaMrXtGAQCuJfLvLYURgJHxKuamSIAYAeg8vOOEEELI9IEOwAyjUnVx4bWPYNe+8Ukbs1x18eVr1mDPSDnzHNdVfOW6RwOjHwB27vXW4CqwYdcwvn7DWpQKvgNQrmK07KaORfufEEIIIaR1WAVohnHjI9tx8S1PYMueEXzj3OMnZcxf3b8Z31m1DkNjFXzpT45LPefejbtx0U2P494Nu3HFe0+OHKuq4kNX3oN7N+zGmccsAQAMjlYwXnXxR8v3Q6ng4CUrF+GL/7MGQHsjAG89eTmef9D8to2fV5h4TQghhEwf6ADMMMYq3q56pTp5LTFNd82RjMZdgKfpt39G369w/UF2D3tRhB1DXoLw/FklfO/dJ+GOdc8E57fTAfinDAdmpkPznxBCCJk+UAI0w6i4ngFeLEyeSVf0ZTvlarpkBwCqvs4/bd6qq+gvecm/zw57sqDtQ55UqM9/3UiDACYBTwUMABBCCCHTBzoAMwyz81+YRCu65I9VjXfssud1o/Oqhue6CszqMQ6AFwHYNuhFAPoDByBcL+UonYe3nBBCCJk+0AGYYQQ78ZPoABijvlxDVlTxowNp57quYlaPp0bbHYsA9PuOQdEJv6o0RjuPUAREpgGKyZM+EkJInqEDkGMe3LQHH/vRvTV33uOUAylOax99perioz+6F49sHQxeM7KeG9Zsw5su/h3WbBlMvM/kHhQDByCUC7mqgaFvIgWmAlBaBIBlQKcA3nKSc/gVJoSQEDoAOeZ9V9yFq+7ZhM27Rxp+T7UaNcSb5fEde/Gzezbhr6+8J3jNNsjvXP8s7ly/K/E+kyBcSHEAqqqBBCiO6QtQZA7AlMJbTgghhEwf6ADMMOJa/GYxUhBLwp8Iqo+l1O8fKXsOgJHyjEciANEkXxvTGdh2WBgBIIQQQghpHToA0wBtQtY60RwAY3vbU7oxCdJ4SjWg0XI8AhDNAciSMfUWva+o7SDQ/u88TLwmhBBCpg90AHJMKzZZGAFo7aM3U9pVfOLG+1g52Q/ASICCHACrH0DV1aA8aRzjABSZAzCl8I4TQggh0wc6ADMMUwa01GIfAONARCIAsRDEWEoEwEiAzJnxJODsCICfBOzYOQA0RzsNbzkhhBAyfaADMA2IG+C1qPo77XEj+vu3r8ebv3N73fcHHYStKeP2fq0cgPGqizVbBvGqr60KjrmqmZ2Je4wEqGhHAOouk0wyLANKCCGETB+KU70A0jrGKKs24QCYMqAae8/f/vyhBt/vGff2u+Pzj1WycwDKFRcX3/JE5JirYWQhjpEAzeop4oLXHI3BkTIOXTS7obWSyYMRAEIIIWT6QAdgGhBPwq2F2Z1vxmmwMTv1kU6+8STgFAfA5ACUqy6K1ag16eUA1I4AAMD7Tj+8pTWTiUP7nxBCCJk+TEgCJCJvEpGHRMQVkRNixz4tIo+LyKMictbElklqkWU8pzFW8QzxFJl+Y3P5b3QjEqB4BCCZBDwcOACa6BisqoE0KU5vkSo1QgghhJDJZKLW1YMA3ghglf2iiBwD4FwAxwJ4NYB/FZH0Tk+kZYwso5lOwGZ3PsvgrhdNCCRElggoHk1IjQCYHICKGzgRwftdJJwCQ6sdi8kkwxAAIYQQMm2YkHWlqmtU9dGUQ+cA+KGqjqnqkwAeB3DSROYi2TSTBDwWOADpx8sZjoHBGO/2lHGnoVYOwHjVTUQsTBWgVisTkfbDJGBCCCFk+tCu7dVlADZYzzf6r5FJxJhkzUiAzO58ltOQVY3nhC9ej8/87IGgfKd5+99e/SAuuOqByLm1JUBupASoWUvFVRy836yGr4N0FiYBk+lAi6lPhBAy7ajrAIjIDSLyYMq/cyZjASJyvoisFpHVO3bsmIwhZxxNJQH7xnlW460sB2Dn3nH81++fTkh1vn/HU5HnA33FVAnQtsExAJ4DEJ/DKwPqYsHsHnz3nSfg/7d353FylHXixz9PVZ9zT+5kEkgCQRKOcIQjosgKCriIoq7gsYKusuh667qw4IE/5KW76uKFynKIrIKIHJHTgBG5c5AQcp+TO5lJJpM5e/qo5/dHHV3dXT1X5uz5vl+veaW7urqqulIz/Xzr+T7f52cfOb13H0YMGWn/i9FOglghhMjqsQqQ1vqifmx3DzDD93y6syxo+3cAdwAsWLBA7s/0Q1/GAPQnBchf8adY4OCqKQsXpAAlUhkOtrkBgPbGEbgylt2LETIVF86dzIodTT1+DjG0lLSehBBCiJIxWClAi4CrlFJRpdQsYA6wdJD2NWa5jbL+DAIu1msQ1APQnsym9KQCyoD61ZZFCnoA9h1JOMdr77+jK53zunZ6AELObL/u7L9i5JD2vxBCCFE6jrYM6BVKqd3AQuAJpdQzAFrrtcCDwDrgaeDftNaFieFiQPSlpr97d77YuIH8/HyA1kTKe+zNAwC05TXkAarjhT0Ae5s7AZg5vpxUxqI1kfu+jGUPAjadKX4jUvpzxJH2vxBCCFE6jrYK0CNa6+la66jWerLW+mLfa9/TWh+ntX6L1vqpoz9U4bIs7VXVgZ57APzrBg0C9t/NT2WsgkG8/ga7mwKkdbZh72cHALnv3+MFAGWkMhYtvoDCUNmZgN0qQFL7XwghhBBi8EhLaxT65mNrOPGbT3vPuwsAHly+ixO/+TQ7D3UA/kHA2ff479jf8sR63nLT0zlpPP4eAC8FCO2l9vhVx8OFKUDN9nozxpWRSFleRSCw033sQcDSAzCSSQqQEEIIUTqkpTUK3b90JwCHO5JA9wHAE6v3AbClsRXINvz9YwD8PQR/3dAA2PX6XS3+HgBfGdD2vBSgx/7tPOJhs3AQcDpD2FSURULehGCuaNggY2nSlowBGNkkAhBCCCFKhQQAo9CkyhgAzR32nfneDAJ2J3Jy1/W/J79RDrkpQi2d9n6iIcMLIDTQmcx93yl11UTDRkEPgJvfHwmY6CtkKG8isJCkAI1Y0gMghBBClA5paY1Ck6uiOc+7GwTsveI04NwGvD8FKL8hD5DxVQNyxwDEwqZvIjBdEDgYhiJimqQt7fUUgD1wOGwYhM3Cy81QdgCQkhSgEU3a/0IIIUTpkJbWKDTR6QFw9a4HwOam/vjv8HcEBAD++QCyAYDhVQFK5w1EdkXD9iXlTyFKWxamqQgHNOwNpbAs+zOEnADA/VeMHDIPgBBCCFE6JAAYhapiufO3BQUAu5o60Fp7FX4aWrtIpDLenf9D7UmaO5LsauoIbMj7t+kOAg4ZhhcYpNJWYODgpu/sOZytEJR2GvdBPQCmocho7UwEZr8ujc2RR/5HRH8opS5RSm1USm1RSl0f8Po1SqlGpdQq5+fTw3GcQggx1kgAMAoVzqSb+3zzgVbe/l9L+PXft3nLvvHQaj5x91Jv3Td2NXPadxfz9v9awrp9LQX78E8I5tb7T2Usb3kqU5gCBPZEYABffGBV9vgympBhBKb2KGX3RtiDgHObmWccUxPw6YUQo4FSygR+AVwKzAM+opSaF7DqH7TWpzk/dw7pQQohxBglAcAolM6brMvKGwPg1t1/acvBnOVLtzd5dfz9djglQnP2EVAlyA4A7PcnM1bg2IHLTp3K/OnV7DuS2wNgGorKaLbn4vefPocVN12EaSgsS5PxjQEAWHrjhfzu0+cWbF8IMWqcDWzRWm/TWieBB4D3DecB9WHORCGEKGkSAIxCqUzut1j+rL5uOU1L64IvvKB0oeBl2UDBreqTymiSAYODc/ZtGlx88hSaO1JemdC0ZREyFZW+1KVxFRHGV0SdQcDuRGDZy3FSZYx4RMqBCjGK1QG7fM93O8vyfVAptVop9ZBSasbgHY4ksgkhhEsCgFEo/y6+lR8AOOU00xmNpvt0oWLLgiYKS6atnN4H/4y+fnU1cSA7U7A7BqAyFvbWiYftxr2hcMYAWDk9AEKIMeHPwEyt9anAYuDeoJWUUtcqpZYrpZY3NjYO6QEKIUQpkgBgFEpnem7UQ2HPAEDQqkHr+ffh9gAkM1bOuu78APncAMBNRXLHAPh7ALIBgEK7g4AlABCilOwB/Hf0pzvLPFrrQ1rrLufpncCZQRvSWt+htV6gtV4wceLEQTlYIYQYSyQAGAFW7DhMV7own76YVN4YgPwGvL9UZ29yXvPHFORv0z+zrz/vvyUgBQhgmtcDkHC2Zd/dr4pnewBiTnqPaShSGfs43dQlIURJWAbMUUrNUkpFgKuARf4VlFJTfU8vB9YP4fEJIcSYJS2uYba1sY0P/vJlbnm89997+Q3+/EHAboCQsaxeBQDJgADAPwbAH5x0+Cr/FOsBmFwVwzQUe5o7vOMN540BcHsAlFJeD0MoYKZgIcTopLVOA58HnsFu2D+otV6rlPquUupyZ7UvKqXWKqXeAL4IXDM8RyuEEGNLqOdVxGBqak8CBJbiLCb/jn1+QOA26PNThYoJquaTCkgBstfN3vVvSaSImEZBAGEaiilVMa8HIONUAaqIZC83d8CvaWS3LylAQpQWrfWTwJN5y77le3wDcMNQH5cQQox10gMwzNz8fbMPk1/lVwHKHwSc7QEoHAQcJKief6ZICpB/8q/WRJqKWHAMWVcT98YApDIWIdPACGjgG0p5AYQMAhZCCCGEGHwSAAwzt/Hel8lv88cA5GfwuHfUM5YOHPSbL2gmYH+vQrLIGAAgJ63Hr6427s0GnOlmgK/hTwGSAEAIIYQQYtBJADDM+nP3Oz/lJ5NXFtQNEFIBk34FCeoB8KcZdaUt3MPryAsAKqLBAcC0mhj7WxJkLO1NBBbEUL4UIFMuRyGEEEKIwSYtrmGWSNmNX8PpAqg/2M4rWw/x8Ou7SWUsHl+915tQC+zZfesPtedsI6PzxwDYzzMZTS8ygALHADy+eh9HnEG+XemM19Df35LIWa9oD0BNGRlL89iqPWxrbM+Z5MvPrgIkPQBCCCGEEENFBgEPMzf9xs2Pv+CHf/Ne+9vGRha9sZcPnFHHjz98GgAfu/O1gm3kpwClnDvq6V6OAXCDENNQXu7/Iyv3sO9IJw9cu5CutEVlNOSV/ZwzqYLNDW1A8R6AKdVRAL764BvetgHeeeIkb+Az2FWA3B6IYkGCEEIIIYQYONLiGmZu4zfo5veOJruM5r7mROGLPsVSgIpNEBZ0DGFTFdyBX7mzGbBTgPyDfb/7vpO9x/FIcABQ5Zv1F7J39+++5iwe/bfzvOWmUjR32D0NxXoThBBCCCHEwJEAYJi56TdBVYDCTqO5p/EBBT0AbgCgezcRWGcyQ8gwCu7Ad6UttNYk05Z3p980FGFfvf54OPgSqswPALpJAXKDIP9EYUIIMdB6d0tECCFKnwQAw6wzLwXIz50Yy40Nit3Rz58IzB0DkEpbvfrC60xlCJkqcCIud5ByuRMATKyI5jTmy4r0AOTfzS+W3++Pe6QHQAgxWPpSaU0IIUqdtLiGmdsDEHSn3r0j7w4Qzi//6UoXSQFKpK2CScOKCZtGYE+DOwdAWcSeuXdiZTSnMR9zZvTNl9+YL9aL4V+enzYkhBBCCCEGngQAw8ztAcifTReyd/YNZc+6e/uSrYHb+L9Xd1IRDfPFC4/nrhe2Cf+43AAAIABJREFU0+YM1s1YuqBsZzEho3AMAMB9r+wAsuU/J1ZGc1KF4kUCgPK8noFwQO8CZIMbkB4AIYQQQoihIC2uYeYGAF0BtfjdRrdpKL792FoeWbnHey1iGjlBw6+e38re5k4WvbE3ZxuNbV29Oo6waRAJFWaE/WLJFgDedvwEdjZ18LV3n5CTKuT2DOTLT2kqPg9AdnmxikJCCCGEEGLgyBiAYZZwGvld6cIegFbnTr6hFNsO5tb+jwUMvt10oLVgmVthpychUxXcgZ89odwLQiZXxXj+3/+Bk6ZVEzay+44VCQAKtm8EX2puXFAeMWUiMCGEEEKIISAtrmHmpQAFBgB2491QioOtuXfy4wEN7z3NnUDfZhV2hYzCAMD/3N87EA75egCKpAAFbT+Ie6z5VYOEEEIIIcTgkABgmHkpQOkMOm8ksNsDYBqKQ+15AUBAw7vVl/s/oSLSp+MImwaV0dxGuL9RHvUFAP67+cVSgPKZPYwBkPx/IYQQQoihIQHAMHOrACUzFqlMbgDgpt8olZ2t11Ws+o6rtizSp0Z12DQKehWK9gD4GvO9TwEqEgAYEgAIIYQQQgwlCQD66UhHihsefpP2rnTRde58YRsvbG7sdjvZQcCW9zjf46v3FSwLGrDrFzYN6mri3a7jFzJVQVBRldMDYPrW7bkKUMH2exgDIClAQgghhBBDQwKAflqxs4n7l+5kWX1T0XVueWI9/3zX0m630+YEEF1pi4QTAIwv71v6TpBwqHgAcOsVp3Dq9Orc9Q2joDHvvyufmwKUvZvfXSBy19ULAt/j586ALLMACyGEEEIMDQkA+skdtLu3OXFU23Hz9pNpy0v5uemyuZwwuSJnvdkTy3Oe58/+my9qGkwrEgCcNqOGH/7T/JxlIVMRj+ReDv678v5cf/88AJFuKvdcOHcy154/Gyg+BkDJGAAhhBBCiCElAUA/JZ18/T3NHYGv5w/oLcat9NOVztCRtIOBeNgsuLOeP0tuTxP8hkOKutrgACBkqpxGvL2ssAegwtco96cH+asM5W8nn7/OfxD37RIACCGEEEIMDQkA+inVQw+Av65/okhufzJtkUhZREwDS+PN4BsLmzk591DYQLas7gOMcDc9AIZSXuqNt76hiOfN3uufayCo7Ki9n9418Isdrxsg5Ac4Qggx0Hp7Y0YIIUqdBAD9lHJuwbu19/O51X0A9h8JDhLcu/9uyc4jnfbzskgoJ+ceAnoAevgi624QcMhQ5N+YD5mqoAfAH4QUK/fZUw+A6Qz+LdZj4VYBqpIeACHEIOr77ChCCFG6JADoJy8AOFwkAPDd9f/Ub5ahtea+V+r56oOruPrupew81MEHf/kyABMqowB89/F1gH3nPT8FqDya2wAvNqjWFTZV0QDADAwAjIJeBv8xxELBAUBP1YjcnoZiAYtUARrZ3NSvnlK5hBBCCDF6SADQT+4YgP0tCTIB6S3+AGDbwXaSGYtvPraWh1/fw/ObGvmXe5dRf8geP3D5/GkA7HaCiXHlkYIeAP/d+EtOmsK/vsMeXGso+NXHz/Req3aq6dSWRZhcFeXr7z6h4NhCTnDwtXedwEQn+AgbiktPnsJnLzjOt8/sMRhFAo6wafCDD57Cnz67MPD1nlKATBkEPKL99KrT+dKFczi5rmq4D0UIIYQQA0QCgH5yewAyluZAS2GKj5sCdO7scQAkkrk5MP6g4aRp1Vz3DrvhrRRMqYoRCeWn42T/q7713nlUOLP2vvPESVxy8hTvtYqo3ZCuq42jlOLz75xTcGx2D4DiCxfOYdYEu7pQyDQImQb/ccmJgfssJmwqrjzrGM48dlzg627gUKwHIFsFSHoARqIp1TG+8q4TvP8nIYQQQox+EgD0U8o3yHdvwDgAd+DvOKemf/4kX9sOtnuPK2Mh6mpigH1HPGQahT0AvgG5YdPwUmfyb6ynLfu4upsEzD8A2B3EGzSYt6f0HvdYuuOmKgX1kkC2opD0AAghhBBCDA0JAPop5RvVGjQQ2K3pXywA8KuOhwtKduYHABEz2yMQCRleTnb+fABu9aFiFYAgd1Ze93HQTL35lYiCdDcPAGRzx4sFAG4gIxOBCSGEEEIMDQkA+imZ0d5A2qAAwG3wjyuzAwC3xn+QyliooMGef/fd3wMQMQ1v3/kN6+YOu5JQtz0AZmEPQCigB6A3KUDFxgZ4++qhB8CQHgAhhBBCiCFVEq2u6/+0mhU7DrP4q+8Ysn2mMhblkRAhU7G3uZNP37uMNXtaaGpPsvybF3kpQLVOD4DbMA9SEQ15DXY3Jz+WV5LTf6c9bCrKnVz/8c72XRMqohxs62KSM7g3iL+CkBtoBKX79CYA6ElNmX1nv1iZz7BhpzNVREriUhRCCCGEGPFKptXl1tAfKqmMRdhUVMfDtCbSPLu+wXttw75WbxCwmwLkDhQ+a2Yt/3r+cSyrb+LsWeNoT2bsEpymwf9cOZ9zZo0H4MoFM7C05rcv76AzlcnpATANxYJja7n1ilN47/ypADz1pbdzoCXBrAnlrNvbQsgXMDz5xbdzsK2LT9y91Hu/69rzj2NGbRlXLpjhLXvwXxcSMlWvUoB68r75dbQm0nzYt32/K8+awdypVT32JAghxEC57dlNLDh2HG+bM2G4D0UIIYZFSQQAsbDZbY79YLADAMPedzJ33+mMlU0BcgKAhtYuAD5+7rFcNG8yF82bXLDNK06f7j2eOaGcGy6dy6qdzby2vSmnMe5WZPnoOcd4y+ZOrWLuVLtU47Hjy3O2O29abglH/yDg02bUcNqMmpzXz55lV/QpNoFZXxiG4hMLZxZ9fca4MmaMKzvq/QghRG+kMha3PbsZgPrv/+MwH40QQgyPkggA4hHTS7kZKsm0JmwaxCOFwUfSFwDUOmMAGlrsACB/Rt+euIN8e1ORp7d6e7d9IFKAhBBiJPjrhgbSlmbOjU8N96EIIcSwK4kWXjxsksronMo8gy2VsYiEDOJhk9ZE7gDf9q4MiWQGpbITcx1ote+m93Wwqzt2djga4/60IyGEGM3SAYUIXtx8cBiORAghhl9JtPDKInZ6zED3AiTTVtHqPe4YgHjYpNFJ73G1JlJ0pjLEw6Z3bI1OD0BfJ7xyq+cMZA9Ab/VU4lMIIUaza+9bzpo9R4b7MIQQYsiVRAvPrZhzynf+wvL6pm7XfXz1Xs659Vm60t0HC1pr3vr9vzLvW8+wrbGNR1buZv7Nf2Hm9U8w8/oneGrNfiIhg1ikMABoSaRoT7oBgH3Hv789ANpJARqIHoCJ3VQGCuIOJJ49sbyHNYUQYvTpSGa47Gcv0tZVvEyzEEKUotIYA+Armfns+gYWzBxXdN2VO5s50NJFc0eKyVXFq9wc6UxxsM1u2O9s6mDlzuaCSkNh06AsbJLMSz1qTaRpaEkwsTLqNdx3HOrAUH1vhGe8AMDkpevfSVNbsk/v93vii29j9+HCOQu688frFjJ7QmEA8Py/X+BNdiaEEKNZMm1B3/40A7BhfwvpjObkuuqBP6hhtGJHE/FwqKCAhBCidJRED0A80vtylXucBnBrovuyof6Gcmsi7b3Pzx0EnK81kWb34U6m18YxDEXMyaWfXBUj3Me0Gje2iIYM6mrinDK9/180kypjnHFMbZ/ec9bMcYyvKPxmPHZ8uVd1SAghRrPmjuyNlab2JN9+bI0dFHRjycYGLrntBS772YsAPL1mP6d+55khL0gxGD74y1d4z09fOOrtPPz6bpZu775XXggxPI4qAFBK/bdSaoNSarVS6hGlVI3vtRuUUluUUhuVUhcf/aEW5+8B0ATPOOvae8RuyLckuu/y3eub3bclkQqc7dcdA5CvJZFib3OnN7uvu07+bL+94aYAGUrq5AshxGB454+e5zuL1vLm7iPc+uR67n1lByfclK0WpLX2/ha7PnnPspzntz65npZEmkWr9g7Yce1t7uTVbYe6Xee6+1Yw8/onjnpf2xrbeP8vXqKlh5tjffHVB9/gw79+ZcC2J4QYOEfbA7AYOFlrfSqwCbgBQCk1D7gKOAm4BLhdKXX0s0oVkT9rbnfchn1LDxOH+Rv8rYl0TkDgSqV14L73NSdoSaS92X3dAKCuHwGAOwjYlImyhBBi0Pzm5Xre+/MXvb+5YN/lB/jB0xuZdcOTLNnYgNaaQ21dBe/f2dQBwDf+tNqrLqS15ksPrGTp9iZ2NXUw8/on2H6wnYyl2dLQygubG1le30RbV5r//fs2vvXYmpxA410/fp6r7niVv6zdz9Nr9gPw2Ko9/HjxJnY5+3t6rb28oSVREKT0xY8Xb2LVrmb+trHRW3akmxnsR5P0EFYIFGK0OKoxAFrrv/ievgp8yHn8PuABrXUXsF0ptQU4GxiUWwFlvjScdCb7B1BrzdbGNpJpzZzJFWQszUEnh741kSaRypC2NBXREM0dSQ62dXHcxAqaO1LsPtxJNGSQtjT7mjsDewwS6UxgCtCG/S1A9o5/9Ch6ACyvB6DPbxVCCNFHj6zc4z3+5D3LOGFyBZsOtHnP506tYv2+lpz35N+B//hdr3Hu7HH89KrTeWzVXh7z9Qpc+9vlnH5MDQ8u3+0te/9p03jUWeelLQe5/zPn8puX62l3xllde98KAJ758vl86YFVAPz0uc1MqIh42zj71uf4/D8cz9cvfkvRz9aaSFEeCQXOBRMUOsz/7l9Y9PnzmDWhnMpYmJv/vJZ7Xqrv1QRql9z2d+/xA0t3MrUmzhnH1PCF+1dyal01O5s6OGlaNVeePYOqWJjWRMqrkvfg8l1846HVrL35Yh5+fTeWhqvfOpNLf/IC6YzF4q++o8f9u375t6384OkN3HPNWfzDiZN6/T4hSt1ADgL+FPAH53EddkDg2u0sGxT+Rrg/t/+vGxr4l3uXA/CFdx7PFafX+dZL84HbX2bdvhbqv/+PXHH7y2w/2M7/XDmfr/zhDcCuftPUnmTD/tbA/SacUp/5Djt3Tepq7QZ/RdQ+zTPH933G27NnjWdrYzvVZX0rHyqEEOLouY1/V37jv5hXtzVx9q3PFSzf3NDG5obcbT7qCxC2NrYHvg/gYl+jGvBuaLl+vmQLP1+yhdOPqeGRz53Hko0NbNjXyp7mDk6pq+Y//vQm154/m/98z1wOtyfpSltMqY7x0IrdPLF6HwAr8irpXf7zl5g5voyPn3ss97xUD8Bz6w+w70iCmx5dw/TaOLsPd/L2ORNYubOZ1d9+N1fd8WrO9+b1D7+Zs023l+HRVXv53pPr+cjZx3D/0p3cdfUCLpw7mdsWbwJgf0uCbz62FrADAPfcz7z+Cb793nl8YuFMr3f8UFsXZ97yLPdccxYXvGUiSilW7GjiB09vAODZ9QfGVADQmcyw90gnx02sGO5DESNUjwGAUupZYErASzdqrR9z1rkRSAO/6+sBKKWuBa4FOOaYY/r6diB3DIB/Ui73j+zEyihbGtrY25zwrZdinfPHxLI02w+2A+R0f9bVxEllLDYeyA0Avv7uE/jhXzaRSFmBAYD//QC3f+wMNje0ct7xE/r82b5z+Tw+dd5MJlXG+vxeIYQQY8/Knc285aan6AoYyHzH37excX8rz2+yv+t+/+lz+Pof3/Bev/eVHQXvqT/UwS1PrPeeuzfWIFsw4wUn7enGR99kaQ/luPPdv3QnAD95bjMvbz3E3iP2d/WFP3reW+e+V+pz3nPzn9dx85/X8eWL5vDli07gU84xffI3yzhxSiX//aH5fPCX2aQDNyD5zqK1PPHmPpbdeFGvjm3NniN0JDOcPSu4uuCBlgTbGttZeNz4Xm1vqMz91tMAbL31PYOWQrxiRxOn1NUM2TxFGcseixMaxjmKLEujFKgSGJfZYwCgte72t0QpdQ1wGXChziYg7gFm+Fab7iwL2v4dwB0ACxYs6FcCY6xIALC3uZOqWIgTp1Syt7mTPc0dgev578Ysrz/sPa6riXOoLcmuptz8/7cePwH+sonOVIZYNxWIJjrVc2aMK2PGuL7f/Qe7/OecyZX9eq8QQoixKajx73Ib/wAfvfO1Ad3v/Ut39fu9q3cfYfXu4InZ3J6AfLc9u5nbnt2cs2zD/lbe+/MXc5at2HGYrz34Bn963U69WrzuAOURk4/e+RofPecYTphUwXf+vI5zZ4/jgWsXcqAlwTm+npjbP3YGl548BaUUG/e3cvFtf+eW95/MTY+uAWDz9y4lbBp89Q+rmDu1is+cP7vbz9rQkuB/X9jG9ZfOxTQUmw+0UhkL86vnt3LajBqvt6L+YDvzZ9Sw41A7mw+0cdG8yYHb+8L9KzluYjkfPGM6a/dmz+EFP1xCKq2ZXB3jT9ct7HPjWWuNpbPjEPc2dxILmxxs6/ICrFvefzLvP72OaMjIqXRoWZrXtjflBEetiRSRkEE0ZFJ/sJ2ZAWXG87UmUiilOPnbz9jnJC8FbcWOJuZOrfLmXfJLpDIcbOtiem1uG2znoQ4eXL6LhceN57QZNby2/RDnzh4fuA2A9/7sRRYeN56HVuwmbCrec8pUPvP22UyribN+XwtX3P4Sd199FlOqY8x2el201l7q+aTKKC0JO728WNngVbuamT+9esiCi6NKAVJKXQJ8A3iH1rrD99Ii4PdKqR8D04A5wNKj2Vd3/ClA/goGew53UldbxvTaOIv3tbCnOYGhoCwS4lB7tuvUf7fCP/h3Wk2c+kN2z0DYVKSc8QVVTp5isRQgV1CepRBCjBXOd8RPABO4U2v9/bzXo8BvgTOBQ8CVWuv6oT5OMTa4jX+Az/w224vx+9d2eo9f3dbENx9dw32v5vaEfO53rxdsz238A8y58SlMQ9mDyFfuYeFx4/nSAyvZ2tjOecePZ2dTB997/ym0daVztrX9YDvPrm/o9Wf4ykUncM15M6mKhUhmLG54+E0efj17fzU/GHJvYO5vSXDmLc/yP1fOZ0ZtGXMmV9LY2pUzN5H/7va9L9dz5rG13PtyPX9csZul/3khf169j//3+DoAFs7ONupvenSNdy6mVMWoKQvzgTPqWLe3hUdX7WVqdYz//cQCVuw4zLcX2YHc1951Aj9avIkff3g+7z+tjuv+bwVr9hzhSxfNQaHoTGV4+5wJ/P61ndz54vaczzTz+if43hUnc+Mja3KWnzWzlmX1h7lo7iTu+OcFLKtv4so77Gx0pWDxV87HcAK4zzr/Bz9fsiVnGxfNncQHzphOMm0xrjzCqdOr2drYxpt7jvCmb9bwe16q556X6nnkc2/littfBrLBtHcdFFH//X/kxc0H+fhdwcF3XU2cJV+/YNB7VtTRVA1wBvdGsf9wA7yqtb7Oee1G7HEBaeDLWuungreStWDBAr18+fKeViuQzlgcf6O9+VkTylny9QsAexDS9No486fX8KPFm7js1Kms2HEY01BMqYqxfId9t//y+dNY9MZe6mriOQHAD/9pPs+s3c/idQc4ZlyZV+Vh6X9eyNm3PkckZHD31Wfx8bteIxIyCupG92aglBBC9IZSaoXWesFwH0dvOZXfNgHvwh4Htgz4iNZ6nW+dzwGnaq2vU0pdBVyhtb6yu+3293tiIEplCiHEUPjz59/Wr3mf+vI9cVThhdb6eK31DK31ac7Pdb7Xvqe1Pk5r/ZbeNP6Phr9L61BbF4vXHWDxugPsPmzX4ncH4y7d3sS0mjiVsTAbfQOU3DrLZ83MnSRrQkWEypjdSTKtJpuD71YqSKYtOp1JX8aX29UYqmIlMbmyEEIcrbOBLVrrbVrrJPAAdoU4v/cB9zqPHwIuVKWQXCuEEEdh9+GOnlc6SiUxE7BfSyLNZ367nM/8djltXWmOn1TB8ZPsfKyG1i6On1jBtOoYrV1p3K+ZhtYuJlVGOT1vltxZE8qZVm0HD+42KmMhb2bf9502jelOcHH1W2fm/PuhM6cP5scUQoiRrg7wJ4QHVYPz1tFap4EjQMFoSqXUtUqp5Uqp5Y2NjfkvCyFESQkPwUDno0oBGmj97doFO/c/bBhsO9iG+5FMQ3HC5EpMQ7GtsY2OZIbjJ1WQtjT1B9upjoeJhg0aWrqYXBVjXHmETQdamTGujEQqw4SKKKmMxaYDrRw3sQJLaxSKeMTkSGeKsohJ2DQ41NbF+IooTe1JauJhWhIpyqOhIfkPFEKMDaMwBehDwCVa6087z/8ZOEdr/XnfOmucdXY7z7c66xwstt3+fk9orVm/r5XdhzuIR0wMpUhbmpChsLQ9H4yl4biJ5SRSFuVRk5Bh0JJIURUL4++XCBkKQyny+yq0JmeZUsqZRbhwuXtM7vvAHjdmWfZ89hlLewMvu9IZIqY9L00yYxELmd5xaaeCv0KRzFiEDEUqYxEyjJx9NrR0eeWkO5JpyqMhMhkn5xtFezKNpTVV8TDJtEVbIk1tecQbtInGO2+HO5JETAMUdKUsoiGDrrRFPGISC5uk0pb33D2/hlLe52lNpKkpC5OxNK2JNBHToCudoSIWIpm2UChSlkVZxKQ1kSaVsehIZgibhn3uDYWh4EhninRGk0hlvFx2hSISMkhlLEzD3mdbVxqtIW1ZdKUsMlrT0mnPOxB3BrTWltmf1S3jHQvb51thD3yNR0zKIiE6Uxn2NSeoKQsTj5g0tCToSGaIOANg27rsOYYOtycZ7xQCqYiG6EimCZmGPf9QRmMosDREQwYdqQxlYZND7UlSGYuIadCeTBM27cGybV0pauIRQqaiM5mhobWLjKWpKQvTmcpQFjFp6bRvah47voym9iSdyQxV8TAKaE9mSKYtYmGDskiIls4UKUuTds6rfWPTdAasdjGlKkZLIsWMWjv1OWNpKmMh4hGTZFrT1N5FWSRETVnYPr8J94aqIhoyqIiG2NLYRixs0NaVYXJllDbnpmvENCiLZjMlLGefk6tidCYzaOz5j1o6U0ytjtPalSbmzMmUdvLqI07bqittt9O01qQy9u9GNGSwq6mDqniYzmSGZMZiclWM/UcSxMMm02vj7G9JcKgtSVnURGsoj5peCncsbLLvSIKaeJi0Zf8/zRxfTnk05FWOHF8eYX9LgrKI6fz/pFFAbXkEBXSmMrR1pYmGDOe600RMA9NQVMZC3v/z9NoyOrrSpCxNPGxfP4ZSvPukyVxy0pR+VTvqy/dEyeSruANzT5oWnDM1O68Wrn8Utr/E5typVUC2dn/YNAK3WR3P1uV3f8nHOWlANWWRgvWFEGKM6U01OHed3UqpEFBNdkzZgFJKMW9aFfOmVfXpfUGTPRbfR/B+iyU1uYGA/3W3eIS/dKNbmSRkZqveTajIDt50uYMGg2aoP8Y3D43/+8tbljfXjLv9oHXLoz00HQoPLYd7fGHTf6z2fvK/PotVZQGYWt27yTWD6+YIMbbJLWohhBCDYRkwRyk1SykVAa7CrhDntwi42nn8IeCveiR1SwshRIkqmR4AIYQQI4fWOq2U+jzwDHYZ0Lu11muVUt8FlmutFwF3Afc5FeWasIMEIYQQg0wCACGEEINCa/0k8GTesm/5HieAfxrq4xJCiLFOUoCEEEIIIYQYQyQAEEIIIYQQYgyRAEAIIYQQQogxRAIAIYQQQgghxhAJAIQQQgghhBhDJAAQQgghhBBiDJEAQAghhBBCiDFEjaRJF5VSjcCOfr59AnBwAA+nVMh5CSbnJZicl2Aj4bwcq7WeOMzHMOzke2JQyfnpnpyf4uTcdG+ozk+vvydGVABwNJRSy7XWC4b7OEYaOS/B5LwEk/MSTM5LaZD/x+7J+emenJ/i5Nx0bySeH0kBEkIIIYQQYgyRAEAIIYQQQogxpJQCgDuG+wBGKDkvweS8BJPzEkzOS2mQ/8fuyfnpnpyf4uTcdG/EnZ+SGQMghBBCCCGE6Fkp9QAIIYQQQgghelASAYBS6hKl1Eal1Bal1PXDfTxDSSl1t1KqQSm1xrdsnFJqsVJqs/NvrbNcKaV+6pyn1UqpM4bvyAePUmqGUmqJUmqdUmqtUupLzvKxfl5iSqmlSqk3nPNys7N8llLqNefz/0EpFXGWR53nW5zXZw7n8Q82pZSplFqplHrceS7npYSU8vfEQP7NU0pd7ay/WSl1tW/5mUqpN533/FQppbrbx0gzEL/fSqkbnOUblVIX+5YHXlvF9jHSKKVqlFIPKaU2KKXWK6UWyrWTpZT6ivN7tUYpdb+yv0tH//WjtR7VP4AJbAVmAxHgDWDecB/XEH7+84EzgDW+Zf8FXO88vh74gfP4PcBTgALOBV4b7uMfpHMyFTjDeVwJbALmyXlBARXO4zDwmvN5HwSucpb/Cvis8/hzwK+cx1cBfxjuzzDI5+erwO+Bx53ncl5K5KfUvycG6m8eMA7Y5vxb6zyudV5b6qyrnPde6iwP3MdI+zna32/nfL4BRIFZzvVkdndtFdvHSPsB7gU+7TyOADVy7Xjnpg7YDsR9/6fXlML1M+wndwD+cxYCz/ie3wDcMNzHNcTnYCa5AcBGYKrzeCqw0Xn8a+AjQeuV8g/wGPAuOS8556QMeB04B3tykpCz3Pt9Ap4BFjqPQ856ariPfZDOx3TgOeCdwOPOF9WYPy+l8jPWvif6+zcP+Ajwa9/yXzvLpgIbfMu99YrtYyT9DMTvd/41465X7Nrqbh8j6Qeoxm7gqrzlcu1oLwDYhR3YhJzr5+JSuH5KIQXI/c9x7XaWjWWTtdb7nMf7gcnO4zF3rpzut9Ox73aP+fPidIOvAhqAxdh3Hpq11mlnFf9n986L8/oRYPzQHvGQuQ34BmA5z8cj56WUjKXf8Zn0/29ed8t3Byynm32MJAPx+93Xc9bdPkaSWUAjcI+TInWnUqocuXYA0FrvAX4I7AT2YV8PKyiB66cUAgDRDW2HjmOy1JNSqgL4E/BlrXWL/7Wxel601hmt9WnYd8TOBk4c5kMadkqpy4AGrfWK4T4WIY7GcP/NG4l/V+X3u0ch7DTiX2qtTwfasdNxPGP12gFwxiW8DzsWQ7CaAAACj0lEQVRQmgaUA5cM60ENkFIIAPYAM3zPpzvLxrIDSqmpAM6/Dc7yMXOulFJh7C/C32mtH3YWj/nz4tJaNwNLsLsVa5RSIecl/2f3zovzejVwaIgPdSicB1yulKoHHsBOE/gJcl5KScn/jg/Q37zulk8PWN7dPkaKgfr97us5O9TNPkaS3cBurfVrzvOHsAMCuXZsFwHbtdaNWusU8DD2NTXqr59SCACWAXOc0dIR7EEXi4b5mIbbIsAdgX81dj6ou/wTzij+c4Ejvu63kuFUGLgLWK+1/rHvpbF+XiYqpWqcx3HsHOH12IHAh5zV8s+Le74+BPzVuUtTUrTWN2itp2utZ2L//fir1vpjjPHzUmJK+ntiAP/mPQO8WylV69z5fDd23vE+oEUpda6zr08Q/Pvg38eIMIC/34uAq5wqL7OAOdiDWwOvLec9xfYxYmit9wO7lFJvcRZdCKxDrh3XTuBcpVSZc/zu+Rn9189wDKoY6B/sUembsPOZbxzu4xniz34/dl5aCjuS/xfs3LHngM3As8A4Z10F/MI5T28CC4b7+AfpnLwNuytxNbDK+XmPnBdOBVY652UN8C1n+WzsP0RbgD8CUWd5zHm+xXl99nB/hiE4RxeQrRIi56WEfkr5e2Ig/+YBn3Ku7S3AJ33LFzh/N7YCPyc7kWjgPkbiz9H+fgM3Op9/I04lm+6urWL7GGk/wGnAcuf6eRS7io9cO9njvxnY4HyG+7Ar+Yz660dmAhZCCCGEEGIMKYUUICGEEEIIIUQvSQAghBBCCCHEGCIBgBBCCCGEEGOIBABCCCGEEEKMIRIACCGEEEIIMYZIACCEEEIIIcQYIgGAEEIIIYQQY4gEAEIIIYQQQowh/x+RxPuQciEYygAAAABJRU5ErkJggg==\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 1440x360 with 2 Axes>"
+       "<Figure size 1440x360 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -360,11 +336,20 @@
    "source": [
     "start=timer()\n",
     "\n",
+    "log_dir = \"/tmp/gym/\"\n",
+    "try:\n",
+    "    os.makedirs(log_dir)\n",
+    "except OSError:\n",
+    "    files = glob.glob(os.path.join(log_dir, '*.monitor.csv'))\n",
+    "    for f in files:\n",
+    "        os.remove(f)\n",
+    "\n",
     "env_id = \"PongNoFrameskip-v4\"\n",
     "env    = make_atari(env_id)\n",
-    "env    = wrap_deepmind(env, frame_stack=False)\n",
-    "env    = wrap_pytorch(env)\n",
-    "model = Model(env=env, config=config)\n",
+    "env    = bench.Monitor(env, os.path.join(log_dir, env_id))\n",
+    "env    = wrap_deepmind(env, episode_life=True, clip_rewards=True, frame_stack=False, scale=True)\n",
+    "env    = WrapPyTorch(env)\n",
+    "model  = Model(env=env, config=config)\n",
     "\n",
     "episode_reward = 0\n",
     "\n",
@@ -379,21 +364,23 @@
     "\n",
     "    model.update(prev_observation, action, reward, observation, frame_idx)\n",
     "    episode_reward += reward\n",
-    "\n",
+    "    \n",
     "    if done:\n",
+    "        model.finish_nstep()\n",
+    "        model.reset_hx()\n",
     "        observation = env.reset()\n",
     "        model.save_reward(episode_reward)\n",
     "        episode_reward = 0\n",
-    "        \n",
-    "        if np.mean(model.rewards[-10:]) > 19:\n",
-    "            plot(frame_idx, model.rewards, model.losses, model.sigma_parameter_mag, timedelta(seconds=int(timer()-start)))\n",
-    "            break\n",
     "\n",
     "    if frame_idx % 10000 == 0:\n",
-    "        plot(frame_idx, model.rewards, model.losses, model.sigma_parameter_mag, timedelta(seconds=int(timer()-start)))\n",
+    "        try:\n",
+    "            clear_output(True)\n",
+    "            plot_reward(log_dir, env_id, 'DQN', config.MAX_FRAMES, bin_size=10, smooth=1, time=timedelta(seconds=int(timer()-start)), ipynb=True)\n",
+    "        except IOError:\n",
+    "            pass\n",
     "\n",
     "model.save_w()\n",
-    "env.close()"
+    "env.close()\n"
    ]
   },
   {
@@ -405,6 +392,7 @@
   }
  ],
  "metadata": {
+  "file_extension": ".py",
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
@@ -421,7 +409,12 @@
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.6.5"
-  }
+  },
+  "mimetype": "text/x-python",
+  "name": "python",
+  "npconvert_exporter": "python",
+  "pygments_lexer": "ipython3",
+  "version": 3
  },
  "nbformat": 4,
  "nbformat_minor": 2
diff --git a/agents/BaseAgent.py b/agents/BaseAgent.py
index 60b4bce..16e10f4 100644
--- a/agents/BaseAgent.py
+++ b/agents/BaseAgent.py
@@ -19,6 +19,9 @@ def huber(self, x):
         cond = (x.abs() < 1.0).float().detach()
         return 0.5 * x.pow(2) * cond + (x.abs() - 0.5) * (1.0 - cond)
 
+    def MSE(self, x):
+        return 0.5 * x.pow(2)
+
     def save_w(self):
         torch.save(self.model.state_dict(), './saved_agents/model.dump')
         torch.save(self.optimizer.state_dict(), './saved_agents/optim.dump')
diff --git a/agents/DQN.py b/agents/DQN.py
index 96e3407..a56d10c 100644
--- a/agents/DQN.py
+++ b/agents/DQN.py
@@ -24,6 +24,7 @@ def __init__(self, static_policy=False, env=None, config=None):
         self.experience_replay_size = config.EXP_REPLAY_SIZE
         self.batch_size = config.BATCH_SIZE
         self.learn_start = config.LEARN_START
+        self.update_freq = config.UPDATE_FREQ
         self.sigma_init= config.SIGMA_INIT
         self.priority_beta_start = config.PRIORITY_BETA_START
         self.priority_beta_frames = config.PRIORITY_BETA_FRAMES
@@ -58,8 +59,8 @@ def __init__(self, static_policy=False, env=None, config=None):
         self.nstep_buffer = []
 
     def declare_networks(self):
-        self.model = DQN(self.num_feats, self.num_actions, noisy=self.noisy, sigma_init=self.sigma_init, body=SimpleBody)
-        self.target_model = DQN(self.num_feats, self.num_actions, noisy=self.noisy, sigma_init=self.sigma_init, body=SimpleBody)
+        self.model = DQN(self.num_feats, self.num_actions, noisy=self.noisy, sigma_init=self.sigma_init, body=AtariBody)
+        self.target_model = DQN(self.num_feats, self.num_actions, noisy=self.noisy, sigma_init=self.sigma_init, body=AtariBody)
 
     def declare_memory(self):
         self.memory = ExperienceReplayMemory(self.experience_replay_size) if not self.priority_replay else PrioritizedReplayMemory(self.experience_replay_size, self.priority_alpha, self.priority_beta_start, self.priority_beta_frames)
@@ -116,9 +117,9 @@ def compute_loss(self, batch_vars):
         diff = (expected_q_values - current_q_values)
         if self.priority_replay:
             self.memory.update_priorities(indices, diff.detach().squeeze().abs().cpu().numpy().tolist())
-            loss = self.huber(diff).squeeze() * weights
+            loss = self.MSE(diff).squeeze() * weights
         else:
-            loss = self.huber(diff)
+            loss = self.MSE(diff)
         loss = loss.mean()
 
         return loss
@@ -129,7 +130,7 @@ def update(self, s, a, r, s_, frame=0):
 
         self.append_to_replay(s, a, r, s_)
 
-        if frame < self.learn_start:
+        if frame < self.learn_start or frame % self.update_freq != 0:
             return None
 
         batch_vars = self.prep_minibatch()
diff --git a/dqn_devel.py b/dqn_devel.py
index a89883f..cbde06d 100644
--- a/dqn_devel.py
+++ b/dqn_devel.py
@@ -1,53 +1,51 @@
 import gym
 import numpy as np
 
-from IPython.display import clear_output
-import matplotlib
-#matplotlib.use("agg")
-from matplotlib import pyplot as plt
-#%matplotlib inline
-
 from timeit import default_timer as timer
 from datetime import timedelta
 import math
+import glob
 
 from utils.wrappers import *
 from utils.hyperparameters import Config
 from agents.DQN import Model
+from utils.plot import plot_reward
 
 config = Config()
 
 #algorithm control
-config.USE_NOISY_NETS=False
-config.USE_PRIORITY_REPLAY=False
+config.USE_NOISY_NETS      = False
+config.USE_PRIORITY_REPLAY = False
 
 #Multi-step returns
 config.N_STEPS = 1
 
 #epsilon variables
-config.epsilon_start = 1.0
-config.epsilon_final = 0.01
-config.epsilon_decay = 500
+config.epsilon_start    = 1.0
+config.epsilon_final    = 0.01
+config.epsilon_decay    = 30000
 config.epsilon_by_frame = lambda frame_idx: config.epsilon_final + (config.epsilon_start - config.epsilon_final) * math.exp(-1. * frame_idx / config.epsilon_decay)
 
 #misc agent variables
-config.GAMMA=0.99
-config.LR=1e-4
+config.GAMMA = 0.99
+config.LR    = 1e-4
 
 #memory
-config.TARGET_NET_UPDATE_FREQ = 128
-config.EXP_REPLAY_SIZE = 10000
-config.BATCH_SIZE = 32
-config.PRIORITY_ALPHA=0.6
-config.PRIORITY_BETA_START=0.4
+config.TARGET_NET_UPDATE_FREQ = 1000
+config.EXP_REPLAY_SIZE        = 100000
+config.BATCH_SIZE             = 32
+
+config.PRIORITY_ALPHA       = 0.6
+config.PRIORITY_BETA_START  = 0.4
 config.PRIORITY_BETA_FRAMES = 100000
 
 #Noisy Nets
-config.SIGMA_INIT=0.5
+config.SIGMA_INIT = 0.5
 
 #Learning control variables
-config.LEARN_START = config.BATCH_SIZE*2
-config.MAX_FRAMES=100000
+config.LEARN_START = 10000
+config.MAX_FRAMES  = 1000000
+config.UPDATE_FREQ = 1
 
 #Categorical Params
 config.ATOMS = 51
@@ -55,40 +53,28 @@
 config.V_MIN = 0
 
 #Quantile Regression Parameters
-config.QUANTILES=21
+config.QUANTILES = 21
 
 #DRQN Parameters
-config.SEQUENCE_LENGTH=8
-
-
-def plot(frame_idx, rewards, losses, sigma, elapsed_time):
-    clear_output(True)
-    plt.figure(figsize=(20,5))
-    plt.subplot(131)
-    plt.title('frame %s. reward: %s. time: %s' % (frame_idx, np.mean(rewards[-10:]), elapsed_time))
-    plt.plot(rewards)
-    if losses:
-        plt.subplot(132)
-        plt.title('loss')
-        plt.plot(losses)
-    if sigma:
-        plt.subplot(133)
-        plt.title('noisy param magnitude')
-        plt.plot(sigma)
-    plt.show()
-    print('frame %s. reward: %s. time: %s' % (frame_idx, np.mean(rewards[-10:]), elapsed_time))
-
+config.SEQUENCE_LENGTH = 8
 
 if __name__=='__main__':
     start=timer()
 
-    '''env_id = "PongNoFrameskip-v4"
+    log_dir = "/tmp/gym/"
+    try:
+        os.makedirs(log_dir)
+    except OSError:
+        files = glob.glob(os.path.join(log_dir, '*.monitor.csv'))
+        for f in files:
+            os.remove(f)
+
+    env_id = "PongNoFrameskip-v4"
     env    = make_atari(env_id)
-    env    = wrap_deepmind(env, frame_stack=False)
-    env    = wrap_pytorch(env)'''
-    env = gym.make('CartPole-v0')
-    #env = wrappers.Monitor(env, 'Delete', force=True)
-    model = Model(env=env, config=config)
+    env    = bench.Monitor(env, os.path.join(log_dir, env_id))
+    env    = wrap_deepmind(env, episode_life=True, clip_rewards=True, frame_stack=False, scale=True)
+    env    = WrapPyTorch(env)
+    model  = Model(env=env, config=config)
 
     episode_reward = 0
 
@@ -111,9 +97,12 @@ def plot(frame_idx, rewards, losses, sigma, elapsed_time):
             model.save_reward(episode_reward)
             episode_reward = 0
             
-            
         if frame_idx % 10000 == 0:
-            plot(frame_idx, model.rewards, model.losses, model.sigma_parameter_mag, timedelta(seconds=int(timer()-start)))
+            try:
+                print('frame %s. time: %s' % (frame_idx, timedelta(seconds=int(timer()-start))))
+                plot_reward(log_dir, env_id, 'DRQN', config.MAX_FRAMES, bin_size=10, smooth=1, time=timedelta(seconds=int(timer()-start)), ipynb=False)
+            except IOError:
+                pass
 
     model.save_w()
     env.close()
\ No newline at end of file
diff --git a/results.png b/results.png
new file mode 100644
index 0000000..0d08c8f
Binary files /dev/null and b/results.png differ
diff --git a/saved_agents/model.dump b/saved_agents/model.dump
index e961fe7..e00ab60 100644
Binary files a/saved_agents/model.dump and b/saved_agents/model.dump differ
diff --git a/saved_agents/optim.dump b/saved_agents/optim.dump
index e8da186..0eabc11 100644
Binary files a/saved_agents/optim.dump and b/saved_agents/optim.dump differ
diff --git a/utils/hyperparameters.py b/utils/hyperparameters.py
index 48ca329..e0b818a 100644
--- a/utils/hyperparameters.py
+++ b/utils/hyperparameters.py
@@ -51,6 +51,7 @@ def __init__(self):
         #Learning control variables
         self.LEARN_START = 10000
         self.MAX_FRAMES=100000
+        self.UPDATE_FREQ = 1
 
         #Categorical Params
         self.ATOMS = 51
diff --git a/utils/plot.py b/utils/plot.py
index 63c3d3b..48de7a5 100644
--- a/utils/plot.py
+++ b/utils/plot.py
@@ -132,4 +132,37 @@ def plot(folder, game, name, num_steps, bin_size=100, smooth=1):
 
     plt.title(game)
     plt.legend(loc=4)
-    plt.show()
\ No newline at end of file
+    plt.show()
+
+def plot_reward(folder, game, name, num_steps, bin_size=10, smooth=1, time=None, save_filename='results.png', ipynb=False):
+    matplotlib.rcParams.update({'font.size': 20})
+    tx, ty = load_data(folder, smooth, bin_size)
+
+    if tx is None or ty is None:
+        return
+
+    fig = plt.figure(figsize=(20,5))
+    plt.plot(tx, ty, label="{}".format(name))
+
+    tick_fractions = np.array([0.1, 0.2, 0.4, 0.6, 0.8, 1.0])
+    ticks = tick_fractions * num_steps
+    tick_names = ["{:.0e}".format(tick) for tick in ticks]
+    plt.xticks(ticks, tick_names)
+    plt.xlim(0, num_steps * 1.01)
+
+    plt.xlabel('Number of Timesteps')
+    plt.ylabel('Rewards')
+
+    if time is not None:
+        plt.title(game + ' || Last 10: ' + str(np.round(np.mean(ty[-10]))) + ' || Elapsed Time: ' + str(time))
+    else:
+        plt.title(game + ' || Last 10: ' + str(np.round(np.mean(ty[-10]))))
+    plt.legend(loc=4)
+    if ipynb:
+        plt.show()
+    else:
+        plt.savefig(save_filename)
+    plt.clf()
+    plt.close()
+    
+    return np.round(np.mean(ty[-10]))
\ No newline at end of file