From 5b22ddd5fcc03136a27b1fd5d808dfe28c7efdd7 Mon Sep 17 00:00:00 2001
From: Elay Sason <89357293+elaysason@users.noreply.github.com>
Date: Sun, 3 Apr 2022 14:19:33 +0300
Subject: [PATCH] Created using Colaboratory

---
 Exp3_and_it's_expansions.ipynb | 405 +++++++++++++++++++++++++++++++++
 1 file changed, 405 insertions(+)
 create mode 100644 Exp3_and_it's_expansions.ipynb

diff --git a/Exp3_and_it's_expansions.ipynb b/Exp3_and_it's_expansions.ipynb
new file mode 100644
index 0000000..fde4cf6
--- /dev/null
+++ b/Exp3_and_it's_expansions.ipynb
@@ -0,0 +1,405 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/elaysason/Crypto-Exp3/blob/main/Exp3_and_it's_expansions.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "qe1D58r-O7VJ"
+      },
+      "outputs": [],
+      "source": [
+        "import datetime\n",
+        "import random\n",
+        "from operator import itemgetter\n",
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "import math\n",
+        "import matplotlib.pyplot as plt\n",
+        "from collections import defaultdict"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "maXpbBKWkCRh"
+      },
+      "outputs": [],
+      "source": [
+        "coins_list = [\"BinanceCoin\", \"Bitcoin\", \"Cardano\", \"ChainLink\", \"CryptocomCoin\", \"Dogecoin\", \"EOS\",\n",
+        "              \"Ethereum\", \"Iota\", \"Litecoin\", \"Monero\", \"NEM\", \"Stellar\", \"Tether\",\n",
+        "              \"Tron\", \"USDCoin\", \"WrappedBitcoin\", \"XRP\"]\n",
+        "K = 18\n",
+        "epsilon = [1 / K]\n",
+        "t = 0\n",
+        "T = 2991\n",
+        "\n",
+        "reward_sum = dict()\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "zh7faJkFkZ4W"
+      },
+      "outputs": [],
+      "source": [
+        "crypto_datasets = dict()\n",
+        "for c in coins_list:\n",
+        "    file = \"coin_\" + c + \".csv\"\n",
+        "    crypto = pd.read_csv(file)\n",
+        "    crypto['Date'] = pd.to_datetime(crypto['Date']).dt.date\n",
+        "    crypto_datasets[c] = crypto\n",
+        "    reward_sum[c] = 0"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "qiY-VkoTkppC"
+      },
+      "outputs": [],
+      "source": [
+        "def get_date(start_date, days):\n",
+        "    return start_date + datetime.timedelta(days=days)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "dkhs96IzkeLL"
+      },
+      "outputs": [],
+      "source": [
+        "def payoff(coin, start_date, t, amountToInvest=1.0):\n",
+        "    date = get_date(start_date, t).date()\n",
+        "    on_date = crypto_datasets[coin].loc[crypto_datasets[coin][\"Date\"] == date]\n",
+        "    if len(on_date) == 0:\n",
+        "        before_date = crypto_datasets[coin].loc[crypto_datasets[coin][\"Date\"] < date].sort_values(by=[\"Date\"],ascending=False)\n",
+        "        open = before_date['Open'].head(20).mean()\n",
+        "        close = before_date['Close'].head(20).mean()\n",
+        "        return amountToInvest*close/open - amountToInvest\n",
+        "\n",
+        "    sharesBought = amountToInvest / pd.to_numeric(on_date['Open'])\n",
+        "    amountAfterSale = list(pd.to_numeric(sharesBought) * pd.to_numeric(on_date['Close']))[0]\n",
+        "\n",
+        "    return amountAfterSale - amountToInvest"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "KcFnRwkTks6n"
+      },
+      "outputs": [],
+      "source": [
+        "def get_existing_coins(start_date, days):\n",
+        "    existing = []\n",
+        "    new = []\n",
+        "    for i, key in enumerate(crypto_datasets.keys()):\n",
+        "        if min(crypto_datasets[key][\"Date\"]) <= get_date(start_date, days).date():\n",
+        "            existing.append(i)\n",
+        "    return existing"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "pXxyzjl6kv_d"
+      },
+      "outputs": [],
+      "source": [
+        "def choose_coin(coin_value_list):\n",
+        "    coins = [tup[0] for tup in coin_value_list]\n",
+        "    probs = [float(tup[1]) for tup in coin_value_list]\n",
+        "    return random.choices(coins, weights=probs)[0]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "JQ3UukuKk2mU"
+      },
+      "outputs": [],
+      "source": [
+        "def exp3_base(date, days):\n",
+        "    eta = np.sqrt(np.log(K) / (days* K))\n",
+        "    start_date = datetime.datetime.strptime(date, \"%Y-%m-%d\")\n",
+        "    scores = [0] * K\n",
+        "    reward_sum = 0\n",
+        "    for t in range(1, days):\n",
+        "        cur_distribution = []\n",
+        "        sum_scores = np.sum([np.exp(s * eta) for s in scores])\n",
+        "        for i in range(K):\n",
+        "            cur_distribution.append(\n",
+        "                np.exp(eta * scores[i]) / sum_scores)\n",
+        "        coins_values = [(coin, cur_distribution[coin]) for coin in range(K)]\n",
+        "        chosen_coin = choose_coin(coins_values)\n",
+        "        cur_reward = payoff(coins_list[chosen_coin], start_date, t)\n",
+        "        for i in range(K):\n",
+        "            scores[i] = scores[i] + 1\n",
+        "            if chosen_coin == i:\n",
+        "                scores[i] -= (1 - cur_reward) / cur_distribution[i]\n",
+        "        reward_sum += cur_reward * cur_distribution[chosen_coin]\n",
+        "    return reward_sum\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "gKUV2JhztlaL"
+      },
+      "outputs": [],
+      "source": [
+        "def exp3_extension1(date, days):\n",
+        "    epsilon = [1 / K]\n",
+        "    start_date = datetime.datetime.strptime(date, \"%Y-%m-%d\")\n",
+        "    rewards = []\n",
+        "    scores = [0] * K\n",
+        "    reward_sum = 0\n",
+        "    for t in range(1, days):\n",
+        "        epsilon.append(min([epsilon[0], math.sqrt(np.log(K) / (K * t))]))\n",
+        "        cur_distribution = []\n",
+        "        sum_scores = sum([math.exp(epsilon[t - 1] * s) for s in scores])\n",
+        "        for i in range(K):\n",
+        "            cur_distribution.append(1 - K * epsilon[t])\n",
+        "            val = math.exp(epsilon[t - 1] * scores[i]) / sum_scores\n",
+        "            cur_distribution[i] *= val\n",
+        "            cur_distribution[i] += epsilon[t]\n",
+        "            \n",
+        "        coins_values = [(coin, cur_distribution[coin]) for coin in range(K)]\n",
+        "        chosen_coin = choose_coin(coins_values)\n",
+        "        cur_reward = payoff(coins_list[chosen_coin], start_date, t)\n",
+        "        scores[chosen_coin] += (cur_reward) / cur_distribution[chosen_coin]\n",
+        "        reward_sum += cur_reward * cur_distribution[chosen_coin]\n",
+        "    return reward_sum\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "K8RNKISkC583"
+      },
+      "outputs": [],
+      "source": [
+        "def exp3_extension2(date, days, conf_param):\n",
+        "    epsilon = [1 / K]\n",
+        "    reward_sum = defaultdict(int)\n",
+        "    start_date = datetime.datetime.strptime(date, \"%Y-%m-%d\")\n",
+        "    epsilon[0] = 1 / K\n",
+        "    rho = dict()\n",
+        "    rewards = []\n",
+        "    to_remove = set()  #every coin that once was removed\n",
+        "    A = coins_list\n",
+        "    B = 4*(math.exp(1)-2)*(2*math.log(K)+math.log(2/conf_param))\n",
+        "    V = defaultdict(lambda: 1/K)  #1/K\n",
+        "    for t in range(1, days):\n",
+        "        epsilon.append(min([epsilon[0], math.sqrt(np.log(K) / (K * t))]))\n",
+        "        for coin in A:\n",
+        "            rho[coin] = (1-len(A)*epsilon[t])\n",
+        "            rho[coin] *= math.exp(epsilon[t-1]*reward_sum[coin]) / sum(math.exp(epsilon[t-1]*reward_sum[c]) for c in A)\n",
+        "            rho[coin] += epsilon[t]\n",
+        "            V[coin] += 1/rho[coin]\n",
+        "        coins_values = [(coin, rho[coin]) for coin in A]\n",
+        "        chosen_coin = choose_coin(coins_values)\n",
+        "        reward = payoff(chosen_coin, start_date, t) * rho[chosen_coin]\n",
+        "        reward_sum[chosen_coin] += reward / rho[chosen_coin]\n",
+        "        rewards.append(reward)\n",
+        "        best_coin = max(reward_sum, key=reward_sum.get)\n",
+        "        for c in A:\n",
+        "            if reward_sum[best_coin] - reward_sum[c] > math.sqrt(B*(V[best_coin] + V[c])):\n",
+        "                to_remove.add(c)\n",
+        "                reward_sum.pop(c)\n",
+        "                rho.pop(c)\n",
+        "        A = list(set(A) - set(to_remove))  #making sure that none of the coins that were removed remain in A\n",
+        "    return sum(rewards)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "YVOqYqmBQRpE"
+      },
+      "outputs": [],
+      "source": [
+        "def payoff_to_day(coin,start_date,day):\n",
+        "    return sum([payoff(coin,start_date,i) for i in range(day)])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "3iuPz6fm7c7s"
+      },
+      "outputs": [],
+      "source": [
+        "def get_best_coin_sum(date, days):\n",
+        "    start_date = datetime.datetime.strptime(date, \"%Y-%m-%d\")\n",
+        "    best_sum = -float(\"inf\")\n",
+        "    best_coin = list(crypto_datasets.keys())[0]\n",
+        "    for coin in crypto_datasets.keys():\n",
+        "        reward_sum = 0\n",
+        "        for t in range(days):\n",
+        "            reward_sum += payoff(coin, start_date, t)\n",
+        "        if reward_sum >= best_sum:\n",
+        "            best_coin = coin\n",
+        "            best_sum = reward_sum\n",
+        "    return best_coin, best_sum"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "background_save": true
+        },
+        "id": "JGRyo4-kudbW"
+      },
+      "outputs": [],
+      "source": [
+        "days = range(1, 885, 5)\n",
+        "rewards_extended = [exp3_extension1('2019-02-1', i) for i in days]\n",
+        "rewards_basis = [exp3_base('2019-02-1', i) for i in days]\n",
+        "rewards_extended2 = [exp3_extension2('2019-02-1', i,0.3) for i in days]\n",
+        "best_coin_rewards = [get_best_coin_sum(\"2019-02-1\", i) for i in days]\n",
+        "best_rewards = [r[1] for r in best_coin_rewards]\n",
+        "\n",
+        "regrets_extended = [best_rewards[i] - rewards_extended[i] for i in range(len(days))]\n",
+        "regrets_basis = [best_rewards[i] - rewards_basis[i] for i in range(len(days))]\n",
+        "regrets_extended2 = [best_rewards[i] - rewards_extended2[i] for i in range(len(days))]\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "print('The best coin from 2019-02-1 to 2021-7-1 is ' + best_coin_rewards[-1][0])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "nNqAzixZIXMR",
+        "outputId": "4eb58522-bf2d-4fb0-f19d-be2bcf560aef"
+      },
+      "execution_count": 27,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "The best coin from 2019-02-1 to 2021-7-1 is Dogecoin\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {
+        "id": "GnRFGnFF37nS",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 295
+        },
+        "outputId": "6f802980-4efe-4d15-b591-851892d5205b"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd3xV9f348dc7OxACJMywwhTZIyDgruJWnChfB46qtdW21tbRuvX3rd9KW60dlqJ1b7Eioqg4kIqyZO+dBSEJJCEhyU3y/v3xOQmXECBgkntz7/v5eNxHzrrnvs+5J+f9OZ/PuZ8jqooxxhgDEBHoAIwxxgQPSwrGGGNqWFIwxhhTw5KCMcaYGpYUjDHG1LCkYIwxpoYlBWOOQERWichpTfyZIiL/FpHdIrKgKT/7EPGkioiKSFSAPv9EEdkgIntF5OJAxBAuLCkEkIhsFZF93oG+Q0ReEJGEAMWiItKnHsud5i17TxPF9bCI+Lx9VP26uxE/7wURedx/mqoOVNUvG+szD+EkYDzQVVVH154pItd738PdtaZnNHUCayKPAn9V1QRV/U/tmX7/S0UiskdEvhGRn4iIneOOku2wwLtQVROAYcBw4L6G/oAGLt1NBvKB6xpwnUfypncyqH79oQk/O1B6AFtVtfgwy+QDd4tIqyaKqUEc4/HYA1h1hGUuVNVW3rJPAPcAzx3DZ4U1SwpBQlV3ALNxyQEAERnjlXj2iMgy/xKgiPQUkbleyegzEfmbiLzizau+1L9JRLYDn3vTbxSRNV6VxGwR6eFNn+utdplXEr+yrhhFpCVwOfAzoK+IpPnNixORV0Qkz4t3oYh0PMR67hWRTV7sq0XkkqPdX94VxCt+4wdUb4jIlyLymIj81/ucT0Sknd/yJ/nt23Sv5H0LcDXuRLtXRD7wlt0qImd6w7Ei8pSIZHmvp0Qk1pt3mldSv0tEckQkW0RuOMw2pIjIDBHJF5GNInKzN/0mYBow1ovjkUOsYg0wH/jVIdZ/wFVPdXx+41tF5DcislxEikXkORHpKCIf+R1XbWut9kZvu7NF5Nd+64rw+17zROQtEUmq9d0ccDzWEe/N3n7I9/ZLijd9E9AL+MDbH7GH2qcAqlqgqjOAK4HJIjLIW8/5IvK9iBR63/nDfp/9oYjcUSue5SJyiTh/9r7TQhFZUb3OkKSq9grQC9gKnOkNdwVWAE97412APOA8XPIe74239+bPB6YAMbiqhkLgFW9eKqDAS0BLIB6YAGwEjgeigPuBb/xiUaDPEeK9FsgGIoEPgGf85t3qTWvhzR8JJB5iPVcAKd52XQkUA50PsezD1dt1uOl+2xzljX8JbAL6edv/JfCEN68HUARMAqKBZGCYN+8F4PHDfE+PAt8CHYD2wDfAY96804AKb5lo77srAdoeYtvmAn8H4nCFgV3Aj7x51wPzDvNdXA/M8963G0jypmcAp9W1LV58GbW261ugI+54ywGW4K5Y43An74dq7d/XccfUYC/e6v3yC29dXYFY4J/A64c6HuvYnh8BucAI7/3PAHPr+g6O9L9Ua/p24Da/7R+MO+6GADuBi715E4Hv/N43FPf/FgOcDSwG2gCC+x+q83gNhZddKQTef0SkCEjH/VM+5E2/BpilqrNUtUpVPwUWAeeJSHdgFPCgqpar6jxgRh3rflhVi1V1H/AT4PequkZVK4D/BYZVXy3U02RcVU4l8BpwlYhEe/N8uJNrH1WtVNXFqlpY10pU9W1VzfK2601gA3BQvbmfiV6JvvqVUs94/62q673tf4v9V2H/A3ymqq+rqk9V81R1aT3XeTXwqKrmqOou4BFcsqzm8+b7VHUWsBc4rvZKRKQbcCJwj6qWep8/jaOslvPe9ymuquRYPKOqO1U1E/gad2L8XlVLgfdwCcLfI94xtQL4Ny6xgju+fqeqGapahkval8uBVUX+x2NtVwPPq+oS7/334a6UUo9xu6plAUkAqvqlqq7wjrvluAR3qrfcDKCfiPT1xq/FHevluO+0FdAfEO9/KPsHxhW0LCkE3sXq6kFPwx101VUcPYAr/E+GuCuCzrhSdr6qlvitJ72OdftP6wE87beufFypp0t9gvROYqcDr3qT3seVJs/3xl/GVX+94VUv/MEvYdRe13UistQvlkF+212Xt1S1jd8rqz4xAzv8hkuA6kb8bririGORAmzzG9/mTauW5yXduj639nryVbWo1rrq9X3U8iBw26Gq645gp9/wvjrGa8fuf0z5b3sP4D2/73QNUIm7CqnrvbUdsF9VdS+upH4s+8NfF9yxjoicICJfiMguESnAJbJ23ueVAm8C14hrnJ6EO6ZR1c+BvwJ/A3JEZKqIJP7AuIKWJYUgoapf4S73p3iT0oGXa50MW6rqE7gqnCQRaeG3im51rdZvOB24tdb64lX1m3qGeC3uePlARHYAm3FJYbIXv09VH1HVAcA44ALqKPV6Vyb/Am4HklW1DbASl6CORjGuqqpap6N4bzrQ+xDzjtRtcBbuBFituzftaGXhvkP/RuLuQObRrkhV1wLTgd/VmvVD9tGh+B9n/tueDpxb6/iK865AakI9zHoP2K/i2q+SOYb94beOUbikMM+b9BruiqCbqrYGnuXA4+5F3BXLGUCJqs6vCVz1L6o6EhiAq5L8zbHGFewsKQSXp4DxIjIUeAW4UETOFpFIcQ25p4lIV1XdhqtKelhEYkRkLHDhEdb9LHCfiAwEEJHWInKF3/yduMa8Q5mMqyoZ5ve6DFedlSwip4vIYBGJxLVv+ICqOtbTEndy2OXFcQPuSuFoLQVOEZHuItKao7tr61XgTBGZKCJRXvzVVUtH2g+vA/eLSHtxDdcP4r6ro6Kq6bj2iN973+0Q4KZjWZfnEeAGXL13taW47ydJRDoBvzzGdft7QERaeMfRDbjSNbjj6//J/psX2ovIhKNY7+vADSIyzGtI/l9cVdbWow1QRBJF5ALgDVy70wpvVivc1VmpiIzGVSPW8JJAFfBHvKsEb32jvKuMaFyiLaXuYzskWFIIIl4d9Uu4toJ0XOPwb3En0HRc6aT6O7saGIu7xH4c989Zdph1vwf8H656pxBXOj/Xb5GHgRe9y/+J/u8VkTG4UtzfVHWH32sGrvF6Eq4U+g4uIawBvsLvH8svjtW4f7r5uBPwYOC/9dk/tdbzqbfNy3GNgDOP4r3bcY3Ad+GqFpbiGhbB3cI4wNsPB90Pj9vXi7zPXYFrmH28juXqYxKuETYLV3//kKp+diwrUtUtuP3d0m/yy8AyXCPsJ+w/gf8QX+G+8znAFFX9xJv+NK4U/onXRvYtcEJ9V+pt9wPAu7gr4d7AVUcZ2wd+7XO/A/6ES1zVfgo86i3zIK6dqbaXcMekf3JOxF3d7sZVceUBTx5lbM2GqNpDdkKBiLwJrFXVh464sDGmTiJyHXCLqp4U6FgCxa4Uminvkra3uPvDz8FdVdRVsjXG1IPXRvdTYGqgYwkkSwrNVyfcvfd7gb/g7sX+PqARGdNMicjZuGranbgG6bBl1UfGGGNq2JWCMcaYGgHpBrehtGvXTlNTUwMdhjHGNCuLFy/OVdX2dc1r1kkhNTWVRYsWBToMY4xpVkRk26HmWfWRMcaYGpYUjDHG1LCkYIwxpkazblOoi8/nIyMjg9LS0kCHEnBxcXF07dqV6Og6Oys1xpiDhFxSyMjIoFWrVqSmpiJytB1vhg5VJS8vj4yMDHr27BnocIwxzUTIVR+VlpaSnJwc1gkBQERITk62KyZjzFEJuaQAhH1CqGb7wRhztEIyKRhjTKjanlfCP7/axDebchtl/SHXphAMIiMjGTx4MKpKZGQkf/3rXxk3blyjfmb1D/natTvcUy2NMc3RltxiZq3I5qOV2azMdI8+v+203ozr3fD/75YUGkF8fDxLl7rnwM+ePZv77ruPr776KsBRGWOak405e/loRTazVu5gTbZLBMO7t+F35x3POYM60S2pxRHWcGwsKTSywsJC2rZtC7g7gu6++24++ugjRIT777+fK6+8ki+//JIpU6Ywc6Z7eNjtt99OWloa119/PampqUyePJkPPvgAn8/H22+/Tf/+/cnLy2PSpElkZmYyduxYrLdbY5o3VWX9zr01VwTrd+5FBNJ6tOXBCwZwzqBOpLSJb/Q4QjopPPLBKlZnFTboOgekJPLQhQMPu8y+ffsYNmwYpaWlZGdn8/nnnwMwffp0li5dyrJly8jNzWXUqFGccsopR/zMdu3asWTJEv7+978zZcoUpk2bxiOPPMJJJ53Egw8+yIcffshzzz3XINtnjGk6qsrq7EI+WrGDWSuz2byrGBEYnZrEoxMGcvbATnRMjGvSmEI6KQSKf/XR/Pnzue6661i5ciXz5s1j0qRJREZG0rFjR0499VQWLlxIYmLiYdd36aWXAjBy5EimT58OwNy5c2uGzz///JqrEWNMcFNV1mQX8eGKLD5cns3WvBIiI4QxvZK48cSenD2wE+1bxQYsvpBOCkcq0TeFsWPHkpuby65duw65TFRUFFVVVTXjtX9bEBvrDpDIyEgqKioaJ1BjTKNat6OID5dnMXOFuyKIjBDG9U7m1lN7c9aAjiQnBC4R+AvppBAM1q5dS2VlJcnJyZx88sn885//ZPLkyeTn5zN37lyefPJJfD4fq1evpqysjH379jFnzhxOOunwzw0/5ZRTeO2117j//vv56KOP2L17dxNtkTGmvjbm7GXmcndFsCFnLxECY3olc9NJPTlnYKegSQT+LCk0guo2BXCXii+++CKRkZFccsklzJ8/n6FDhyIi/OEPf6BTp04ATJw4kUGDBtGzZ0+GDx9+xM946KGHmDRpEgMHDmTcuHF07969UbfJGFM/W3KL3RXB8mzW7iiqaSN4bMJAzhnUOaBVQ/XRrJ/RnJaWprUfsrNmzRqOP/74AEUUfGx/GNP4tueVMNNrI1jl3dyS1qMtFwzpzLmDOzd5Y/GRiMhiVU2ra55dKRhjzDHI2F3Ch8uz+XBFNsszCgD3O4L7zz+e84d0pnPrxr99tDE0WlIQkW7AS0BHQIGpqvq0iCQBbwKpwFZgoqruFtdRz9PAeUAJcL2qLmms+Iwx5mjtLCzlg2Wuamhp+h4AhnZtzW/P6895gzvTtW3j/KCsKTXmlUIFcJeqLhGRVsBiEfkUuB6Yo6pPiMi9wL3APcC5QF/vdQLwD++vMcYETEGJj49WZvP+0iy+3ZKHKgxMSeSec/pz/uDOdE9u/onAX6MlBVXNBrK94SIRWQN0ASYAp3mLvQh8iUsKE4CX1DVyfCsibUSks7ceY4xpMvvKK/lszU7eX5rFV+tz8FUqPdu15Oc/6stFw1Lo3T4h0CE2miZpUxCRVGA48B3Q0e9EvwNXvQQuYaT7vS3Dm3ZAUhCRW4BbALvjxhjTYHyVVXy9YRczlmbxyeqdlJRX0jExlsljU5kwrAuDuiSGRXf0jZ4URCQBeBf4paoW+u9UVVUROarbn1R1KjAV3N1HDRmrMSa8VFUpC7fm8/6yLD5akc3uEh+t46OZMKwLFw1NYXTPJCIjQj8R+GvUpCAi0biE8KqqTvcm76yuFhKRzkCONz0T6Ob39q7etGanobrO/vGPf8yvfvUrBgwY0AhRGhOeVJVVWYXMWJbFB8uyyC4oJT46kvEDOjJhWAon921PTFT4PmqmMe8+EuA5YI2q/slv1gxgMvCE9/d9v+m3i8gbuAbmgubantBQXWdPmzatoUMzJmxt3rWXGcuymLEsi827iomKEE7t1557z+3P+AEdaRFjd+hD414pnAhcC6wQkaXetN/iksFbInITsA2Y6M2bhbsddSPultQbGjG2JuPfdfbevXuZMGECu3fvxufz8fjjjzNhwgSKi4uZOHEiGRkZVFZW8sADD3DllVdy2mmnMWXKFIYPH85NN93EokWLEBFuvPFG7rzzzgBvmTHBL3dvGR8sy+K97zNZnlGACJzQM4kfn9SLcwd1om3LmECHGHQa8+6jecChKuPOqGN5BX7WoEF8dC/sWNGgq6TTYDj3icMucqius+Pi4njvvfdITEwkNzeXMWPGcNFFF/Hxxx+TkpLChx9+CEBBQcEB61u6dCmZmZmsXLkSgD179jTsNhkTQkp9lXyyeifvLclg7oZcKquUgSmJ/O6847lgaPP9UVlTseulRnCorrNVld/+9rfMnTuXiIgIMjMz2blzJ4MHD+auu+7innvu4YILLuDkk08+YH29evVi8+bN3HHHHZx//vmcddZZgdgsY4JWVZXy7ZY83luSyUcrd7C3rILOreO4+eReXDqiC/06tgp0iM1GaCeFI5Tom4J/19mzZs1i165dLF68mOjoaFJTUyktLaVfv34sWbKEWbNmcf/993PGGWfw4IMP1qyjbdu2LFu2jNmzZ/Pss8/y1ltv8fzzzwdwq4wJDut3FjF9SSbvL80ku6CUhNgozh3UiUuGd2FMr2QiwuzOoYYQ2kkhCPh3nV1QUECHDh2Ijo7miy++YNu2bQBkZWWRlJTENddcQ5s2bQ5qYM7NzSUmJobLLruM4447jmuuuSYQm2JMUMgpKmXGUtdOsCqrkMgI4ZS+7bjvvOMZf3xH4mMiAx1is2ZJoREcquvsq6++mgsvvJDBgweTlpZG//79AVixYgW/+c1viIiIIDo6mn/84x8HrC8zM5Mbbrih5kE8v//975t2g4wJsJLyCj5ZtZPp32cyb8MuqhSGdG3NQxcO4MKhKbQLwucSNFfWdXaIs/1hmqvqdoJ3Fmcwe+UOissr6dImnouHp3DJ8K706RC6XU00Nus62xjTbGzPK+GdJRm8uziDzD37aBUbxYVDU7hkeBdGpSZZO0Ejs6RgjAm44rIKZq3I5p3FGXy3JR8ROKlPO+4+5zjOHtiJuGhrJ2gqIZkUVDUsOq46kuZcNWhCX1WVsmBrPu8szmDWimxKyivp2a4lvzn7OC4Z3oWUNvZ7gkAIuaQQFxdHXl4eycnJYZ0YVJW8vDzi4oLrMYDGpOeXMH1JJu8uyWB7fgkJsVFcNDSFK9K6MqJ727D+vw0GIZcUunbtSkZGBrt27Qp0KAEXFxdH165dAx2GMZSUV/Dxyh28vSiD+ZvzEIFxvZP51fh+nD2wk91GGkRCLilER0fTs2fPQIdhTNhTVRZt283bi9L5cHk2xeWV9EhuwV3j+3HJiC4h8ejKUBRyScEYE1i7isp4d0kGby1MZ3NuMS1jIjl/SGcuH9mNUalWPRTsLCkYY36wyipl7vpdvLFwO3PW5FBRpYxOTeKnp/fhvMGdrFvqZsS+KWPMMUvPL+HtRem8tSiDHYWltEuI4aaTezIxrVtIP8c4lFlSMMYclbKKSj5ZtZM3F6Yzb2MuEQKn9mvPwxcN4Ef9O4b1U8tCgSUFY0y9rNtRxJsL03nv+wx2l/jo0iaeX43vx+Uju9pvCkKIJQVjzCEVl1Uwc3kWbyxM5/vte4iOFM4a2ImrRnXjxN7trMuJEGRJwRhzkFVZBbz63Xbe/z6T4vJK+nZI4P7zj+eS4V1Ith5JQ5olBWMMAPvKK5m5PItXv9vO0vQ9xEZFcOHQFCaN7ma/NA4jlhSMCXMbc4p49bvtvLs4g8LSCnq3b8mDFwzgshFdad0iOtDhmSZmScGYMFRWUcnHK3fw2nfb+W5LPtGRwjmDOnP1Cd05oWeSXRWEMUsKxoSRbXnFvLZgO28vyiC/uJzuSS2499z+XD6yqz29zACWFIwJeb7KKuasyeHV77bx9YZcIiOEM4/vwNUn9OCkPnYHkTmQJQVjQlROYSmvLdjO6wu2s7OwjM6t47jzzH5cOaobnVpbl+qmbpYUjAkh1T2TvvjNVj5euYOKKuXUfu15/OIenH5ce6Ii7dfG5vAsKRgTAvaVVzJjWSYvfrON1dmFtIqLYvK4VK4d04PUdi0DHZ5pRiwpGNOMbc8r4ZXvtvHmwnQK9vno36kV/3vJYC4enmI9k5pjYkeNMc1MVZXy9cZcXvpmK5+vyyFChHMGduK6sT0YbbeTmh/IkoIxzURhqY93FmXw8rfb2JJbTLuEGO44vQ//c0IPazg2DcaSgjFBbvOuvbzwzVbeWZxBSXklI7q34ZdXDeOcQZ2IjbJnG5uGZUnBmCCkqnyzKY/n521hztocYiJdP0TXj0tlcNfWgQ7PhDBLCsYEkVJfJTOWZvH8f7ewdkcRyS1j+MUZfbl6THc6tLIqItP4LCkYEwRyikp55dvtvPrtNvKKy+nfqRV/uHwIFw1NIS7aqohM07GkYEwArcoq4Pl5W/lgWRa+qirO6N+BG0/sydjeyXYXkQkISwrGNLHKKmXOmp08/98tfLs5nxYxkUwa3Y3rT+xJT/uhmQkwSwrGNJF95ZW8vTid5+ZtYVteCV3axPPb8/pz5ajutI635xaY4GBJwZhGlre3jBfnb+Pl+VvZXeJjePc23H12f84e2NH6IjJBp9GSgog8D1wA5KjqIG/aw8DNwC5vsd+q6ixv3n3ATUAl8HNVnd1YsRnTFLbmFjNt3mbeXpRBWUUVZx7fkVtP7UVaD3u0pQlejXml8ALwV+ClWtP/rKpT/CeIyADgKmAgkAJ8JiL9VLWyEeMzplF8v303U+du5uNVO4iOiODSEV348cm96NMhIdChGXNEjZYUVHWuiKTWc/EJwBuqWgZsEZGNwGhgfiOFZ0yDqqpSPl+bw9S5m1mwNZ/EuChuO7U3149LpUOi/b7ANB+BaFO4XUSuAxYBd6nqbqAL8K3fMhnetIOIyC3ALQDdu3dv5FCNObyyikre/z6LqV9vZmPOXrq0ieeBCwZw5ahuJMRak51pfpr6qP0H8Big3t8/AjcezQpUdSowFSAtLU0bOkBj6qOkvILXF6Tzr7mb2VFYyvGdE3nqymGcP6Qz0dZ4bJqxJk0KqrqzelhE/gXM9EYzgW5+i3b1phkTVApKfLw0fyvP/3cLu0t8jOmVxB8uH8LJfdtZ47EJCU2aFESks6pme6OXACu94RnAayLyJ1xDc19gQVPGZszh7Coq47l5W3jl223sLavgjP4d+OnpvRnZIynQoRnToBrzltTXgdOAdiKSATwEnCYiw3DVR1uBWwFUdZWIvAWsBiqAn9mdRyYYpOeXMHXuZt5alI6vsorzh6Rw26m9GZCSGOjQjGkUotp8q+XT0tJ00aJFgQ7DhKCNOUX8/ctNvL80iwiBy0Z05dZTe1s3FCYkiMhiVU2ra57dHmGMn5WZBfz1843MXr2D2KgIJo9N5eZTetK5dXygQzOmSVhSMAaXDJ6es4FPV++kVVwUt5/eh+vHpZKcEBvo0IxpUpYUTFhbmVnAU59t4LM1O0mMi+JX4/tx/YmpJMZZB3UmPFlSMGFpRUYBT89Zz2drciwZGOPHkoIJK/7JoHV8NHeN78dkSwbG1LCkYMLC8ow9PP3ZBuasdcng12f1Y/K4VFpZMjDmAJYUTEhbkVHAU5+tt2RgTD1ZUjAhacPOIv706Xo+WrmD1vHR/Obs47hubA9LBsYcgSUFE1K255Xw1Jz1/Of7TFrERPGLM/ry45N7WjIwpp4sKZiQsLOwlGc+38AbC9KJjBB+fHIvfnJqb5JaxgQ6NGOaFUsKplnLLy7n2a828eI3W6msUq4a3Y07ftSXjvZgG2OOiSUF0ywVlfqY9vUWnpu3heLyCi4Z3oVfntGP7sktAh2aMc2aJQXTrJRXVPHKt9t45vMN7C7xce6gTvxqfD/6dmwV6NCMCQmWFEyzUFWlfLgimydnr2N7fgkn9knmnnP6M6Rrm0CHZkxIsaRggt78TXk88dEalmUU0L9TK168cTSn2JPOjGkUlhRM0Fq/s4gnPlrL52tz6Nw6jilXDOWS4V2IjLBkYExjsaRggs6OglL+/Ol63l6cTsvYKO45pz83nJhKXHRkoEMzJuRZUjBBY29ZBc9+uYlp8zZTWaXccGJPbj+9D23ttwbGNBlLCibgKquUdxdn8IfZ68jdW8ZFQ1P4zdnH0S3Jbi81pqlZUjAB9d3mPB6duZpVWYWM6N6GaZPTGNbN7igyJlDqlRRE5Beq+vSRphlTX+n5Jfz+ozXMWrGDlNZxPH3VMC4ammJ3FBkTYPW9UpgM1E4A19cxzZjD2ltWwd+/2Mi0eVuIFOHOM/txyym9iI+xRmRjgsFhk4KITAL+B+gpIjP8ZrUC8hszMBNaqqqUd5Zk8OTsdewqKuOS4V24+5zj6Nw6PtChGWP8HOlK4RsgG2gH/NFvehGwvLGCMqFlZWYBD7y/ku+372F49zZMvXYkw7u3DXRYxpg6HDYpqOo2YBswVkR6AH1V9TMRiQficcnBmDoVlPiY8sk6XvluG8ktY/jjFUO5dEQXazcwJojVt6H5ZuAWIAnoDXQFngXOaLzQTHNVVaW8sziDJz5ey56SciaPTeXO8f1oHW8PujEm2NW3oflnwGjgOwBV3SAiHRotKtNsrchwVUVL0/eQ1qMtj044gQEpiYEOyxhTT/VNCmWqWl592S8iUYA2WlSm2dlTUs6UT9bx6nfbSW4Za1VFxjRT9U0KX4nIb4F4ERkP/BT4oPHCMs2FqjJjWRaPzVxNfnE5149zVUWJ9kxkY5ql+iaFe4AfAyuAW4FZwLTGCso0D+n5JfzuPyuZu34XQ7u25sUbRzMwpXWgwzLG/ABHTAoiEgmsUtX+wL8aPyQT7HyVVTw/bwt//mw9kSI8fOEArh2bal1aGxMCjpgUVLVSRNaJSHdV3d4UQZngtSx9D/dOX8Ga7ELGD+jIIxcNJKWN/QDNmFBR3+qjtsAqEVkAFFdPVNWLGiUqE3T2llUwZfY6Xpq/lfatYnn2mpGcM6hToMMyxjSw+iaFBxo1ChPUvliXw++mryC7sJRrx/Tg12cfZw3JxoSoeiUFVf2qsQMxwaegxMdjH67mncUZ9O2QwLu3jWOEdU9hTEir7y+aizj4dwkFwCLgLlXd3NCBmcD6fO1O7pu+gty95dx+eh/uOKMPsVHWk6kxoa6+1UdPARnAa4AAV+G6u1gCPA+c1hjBmaZXUOLjkZmrmL4kk/6dWjHtulEM7mq3mRoTLiLqudxFqvpPVS1S1UJVnQqcrapv4hqhDzx3iXcAABldSURBVCIiz4tIjois9JuWJCKfisgG729bb7qIyF9EZKOILBeRET94y8xR+3T1Tsb/+StmLM3i52f0ZcbtJ1lCMCbM1DcplIjIRBGJ8F4TgVJv3qG6u3gBOKfWtHuBOaraF5jjjQOcC/T1XrcA/6hnXKYBFJX6+M3by7j5pUUkJ8Tyn5+dyK/G9yMmqr6HhzEmVNS3+uhq3FPW/o5LAt8C13hdaN9e1xtUda6IpNaaPIH9VU0vAl/ifi09AXhJVRX4VkTaiEhnVc2u95aYY7Jwaz53vrmUrD37uONHfbjjR30tGRgTxup799Fm4MJDzJ53FJ/X0e9EvwPo6A13AdL9lsvwpllSaCTlFVX8+bP1PPvVJronteDtn4xjZA+7s8iYcFffu4/64ap0OqrqIBEZgmtnePxYP1hVVUSOuqdVEbkFV8VE9+7dj/Xjw9r6nUX88o2lrM4u5KpR3XjgggG0jK3vRaMxJpTVt57gX8B9gA9AVZfj7kA6WjtFpDOA9zfHm54JdPNbrqs37SCqOlVV01Q1rX379scQQviqqlKen7eFC56Zx87CUv51XRpPXDbEEoIxpkZ9k0ILVV1Qa1rFMXzeDGCyNzwZeN9v+nXeXUhjgAJrT2hYeXvLuOnFhTw6czUn92nHx788hfEDOh75jcaYsFLfImKuiPTGu9NIRC7nCPX9IvI6rlG5nYhkAA8BTwBvichNuGc/T/QWnwWcB2wESoAbjm4zzOHM35THL9/8nt3FPh6dMJBrx/Swh98YY+p0NI/jnAr0F5FMYAvujqRDUtVJh5h10HOdvbuOflbPWEw9VVYpf5mzgWc+30Bqckuev36UPe/AGHNYR3P30Zki0hJX5VSCa1PY1oixmR9gR0EpP3/jexZsyefSEV14bMIgazswxhzRYc8SIpKIK8F3wdX/f+aN3wUsB15t7ADN0ft87U7uemsZZRVV/PGKoVw2smugQzLGNBNHKjq+DOwG5gM3A7/D9X10iaoubeTYzFGqrFKe+mw9z3y+keM7J/LX/xlO7/YJgQ7LGNOMHCkp9FLVwQAiMg3XuNxdVUsP/zbT1HYXl/PzN77n6w25TEzryqMTBhEXbb2aGmOOzpGSgq96wHssZ4YlhOCzMrOAW19ezK6iMn5/6WAmjbYf9Rljjs2RksJQESn0hgWI98YFd9NQYqNGZ47orUXp3P+flbRrGcNbPxnLsG5tAh2SMaYZO2xSUFWrfwhSZRWVPDxjNa8v2M643sk8M2k4yQmxgQ7LGNPM2T2KzVBOYSm3vLyYpel7+Mmpvfn1Wf2IirSeTY0xP5wlhWZmZWYBN7+0iD0lPv5x9QjOHdw50CEZY0KIJYVm5OOV2dz55jLatojmndvG2q+TjTENzpJCM6Cq/O2LjUz5ZD3DurVh6nUj6dAqLtBhGWNCkCWFIFfqq+Sed5fz/tIsLh6WwhOXDbHfHxhjGo0lhSBWUOLj5pcXsWBLPr8+qx8/O72P9W5qjGlUlhSCVOaefVz//AK25hXz9FXDmDCsS6BDMsaEAUsKQWh1ViE3vLCAkrJKXrxxNON6twt0SMaYMGFJIcj8d2Mut768mITYKN6+bSz9O9mPxo0xTceSQhCZuTyLO99cSq92Cbxw4yg6t44PdEjGmDBjSSFIvLUwnXunLyetRxLTrk8jMS460CEZY8KQJYUg8Py8LTw6czWn9GvPP68ZSXyM3XJqjAkMSwoBpKr89fON/PHT9ZwzsBNPTxpGbJQlBGNM4FhSCBBV5YmP1/LPrzZz6fAu/OHyIdapnTEm4CwpBICq8sgHq3nhm61cM6Y7j140iIgI+1GaMSbwLCk0MVXlf2et4YVvtnLjiT154ILj7VfKxpigYfUVTUhVeXL2Ov719RauG9vDEoIxJuhYUmhCT8/ZwN+/3MSk0d15+MKBlhCMMUHHkkIT+dsXG3nqsw1cPrIr/+9ia0MwxgQnSwpNYNrXm3ly9jouHpbC/102xBKCMSZoWVJoZNOXZPD4h2s4d1AnplwxlEhLCMaYIGZJoRF9uS6Hu99ZzrjeyTx11TD7HYIxJujZWaqRLE3fw22vLKFfx1b889qR9ktlY0yzYEmhEWzNLebGFxbSrlUML9w4ilbWuZ0xppmwpNDACvb5uOnFhVSp8uINo+nQKi7QIRljTL1ZUmhAvsoqbn9tCdvzS3j2mpH0ap8Q6JCMMeaoWDcXDURVeXjGKr7ekMsfLh/CmF7JgQ7JGGOOml0pNJCX5m/j1e+2c+upvZiY1i3Q4RhjzDGxpNAAFm/L57GZqzmjfwfuObt/oMMxxphjZknhB9pVVMZPX11CSpt4/nTlMPu1sjGmWbM2hR+gorKKn7/+PXtKfEz/6Shax9utp8aY5i0gSUFEtgJFQCVQoappIpIEvAmkAluBiaq6OxDx1deUT9Yzf3MeU64YysCU1oEOxxhjfrBAVh+drqrDVDXNG78XmKOqfYE53njQmrt+F89+5brBvnxk10CHY4wxDSKY2hQmAC96wy8CFwcwlsPaXVzOr99eRt8OCTx04YBAh2OMMQ0mUElBgU9EZLGI3OJN66iq2d7wDqBjXW8UkVtEZJGILNq1a1dTxHoAVeW+6SvYXVLOU1cNIy7a+jQyxoSOQDU0n6SqmSLSAfhURNb6z1RVFRGt642qOhWYCpCWllbnMo3pncUZfLxqB/ed29/aEYwxIScgVwqqmun9zQHeA0YDO0WkM4D3NycQsR3O9rwSHp6xijG9kvjxyb0CHY4xxjS4Jk8KItJSRFpVDwNnASuBGcBkb7HJwPtNHdvhqCr3Tl9OhAh/nDjMHpZjjAlJgag+6gi85z20Pgp4TVU/FpGFwFsichOwDZgYgNgO6T9LM/lmUx6PXTyILm3iAx2OMcY0iiZPCqq6GRhax/Q84Iymjqc+9pSU8/jMNQzr1oarR3cPdDjGGNNo7BfN9fB/H69lzz4fL18y2LqxMMaEtGD6nUJQWrQ1n9cXpHPjiakMSEkMdDjGGNOoLCkcRkVlFb97byUpreP45Zn9Ah2OMcY0OksKh/HWogzW7SziwQsH0DLWatqMMaHPksIh7C2r4E+frmdUalvOHtgp0OEYY0yTsKRwCFPnbiZ3bxm/Pe94vNtnjTEm5FlSqMPu4nKe+3oz5w3uxPDubQMdjjHGNBlLCnX419ebKfFVWuOyMSbsWFKoJb+4nBe/2cr5gzvTr2OrQIdjjDFNypJCLS98s5USXyW/OKNvoEMxxpgmZ0nBT6mvkle+3cYZ/TvS164SjDFhyJKCn/e+zyS/uJwfn9wz0KEYY0xAWFLwVFUpz83bwqAuiZzQMynQ4RhjTEBYUvB8uzmPjTl7ufHEnva7BGNM2LKk4Hl7cQat4qI4b3DnQIdijDEBY0kBKCz1MWtFNhcNTSEuOjLQ4RhjTMBYUgBmLsumrKKKiWndAh2KMcYElCUF4J3F6fTrmMCQrq0DHYoxxgRU2CeFnMJSlmzfw4RhXayB2RgT9sI+KXyxLgeAM47vEOBIjDEm8MI+KXy2JocubeI5zn7BbIwx4Z0USn2VzNuQyxnHd7CqI2OMIcyTwvzNeezzVfKj/lZ1ZIwxEOZJ4at1u4iPjmRMr+RAh2KMMUEhrJPCyswCBnVJtB+sGWOMJ2yTgqqybkcR/TslBjoUY4wJGmGbFDL37KOorIL+ne2uI2OMqRa2SWFtdhGAXSkYY4yf8E0KOwoBOK6TXSkYY0y1sE0Ka3YU0T2pBQmxUYEOxRhjgkbYnhHXZhfS364SjDENSdX9rf4xrCoUZUPW95C9DEryoWIf+EohKg5ShkFMAhTnQKsUaN0F8rfAvt0Q2woqy6GsEBI6QmIXiIwGiYSISGjVGdo0fM/OYZkUSn2VbMkt5vwhKYEOxRgTKgqz4eWLIXe9O9HHJECVD4p3ufkSAXGtISoeouOgrAiWvnLsn3fiL2H8Iw0Tu5+wTAobdu6lSrErBWPMD1d9NfDKZVCQASf+Anz7oGyvm99pMHQZAR0HQUyLA99XkOGuBlq2g4JMKMyEtj3dePleiIxxyaUoG4p2QFUFaCVUVUHbHo2yOWGZFNbvrL7zyJKCMSGvosyV3nPWwq41kLPGnWCTekFcohvWKohu4appYlq4Kpy9Oa7qBly1TWQMRES54YhoV4VTmAn5W6GswM2/+h3odWr94hI5sPonrjV0HLB/PL7N/uHk3u7VBMIyKVw6ogsn9W1Hu4TYQIdiTNOrrIC8ja6UWlZ44EmufC9UVboTUMsOXt24uHmxrVw9+JE6j/SVQkmuW08NdeNVFX5/K6DS50rKleUHDoP7vJgEiGnpSscV5VBZ5pWWq7elHPZsg+JciG/r6uJzVrtSuAjkboD8ze794E7qyX3cyT99gdvexBS3fWVFULTT1fm36e7q8BO9KuZKn6sKqqxwVwFVPrcdCR2h6yhXuu95CnQe0oBfVGCEZVIQETomxgU6DGOOrKrSnfAqy1xpVqtc1YFWuRNdpe/AE+2ebZC93NVZt2wPpYXgK3al2H173AkyY+H+EvDRiklwJ9WqCreu6BauRLtvN5QXA+JOqk1OAHWNsO36uURX6YP2x8HAi6F9f+gwwMUeFXPo1ai6fRsRvl3fhGVS+MEqfV59XyxExx9ccqr0uRJKebEryVT5AHHLRsV5pS3vbuDa760Zl0OPR7eEFkngK4Hd2/bXM5YWwu4tsHO1uzTuO979E/tK3GVuVaW7RI1v4/7GtnbrKy8G1MUVEXXkkuDhFOe5fVO9rZHR7vK9shwqSr0SXIR7VZZDSZ6LP6al90pwJ5roFhBxDHdMq7rPKS9x2+0rcdvnK3ElvJrhErdMSR7s2e5ijIyGhA4Qn+ROmqUF7tVlBAy50sXn2+e9SlyJuHr9JbmuTjhvo3tvdUm4qspvuMLtW4n09oHUKj1Xl5Qr9g/v27O/lFtfUfFeSbbCjUfGunXFJkLb7jDoMug+BtqmuuOguhRcVeW2EYW8TbAv37ubxivllxXB3p3u2I6IciVj3z4o3eNK6TEJ7vNiEyGhvbv68BcZ7bY7Isp7RbpkVfPyqmiiYt2JuWyv25flxW75qBi3LTXHqLhjpE0P7zsr2N+Ie6yqv58wJlp9C1WQEJFzgKeBSGCaqj5xqGXT0tJ00aJFTROYKqydCQumQvrC/aWhuDaQ1NOdxFTdSSR/kzsxNabIWFd6rEtUfD1La+L+Sf1POhLhJa7Y/X8jY90/a5Vv/wk+Isr988e2cv+E5SWuOqIwo0E2D3DJL6alSzDVJ8/4tu7zKsrcPq6scI1y0S0gb4OrB+YojumIaGjd1X1ORZlXj1zgTnBxbdxn5W2s58q8OuL4pANPfBGR3onMO9lopVfS11onSK8aJzIGIqPccHxbaNXJS9iR+xOqROxfr/86Ejq50jG4YzG2lVtvdXWKMYCILFbVtLrmBdWVgohEAn8DxgMZwEIRmaGqqxvtQ32l7h7hSp/7xyordCWiyFh3Yi3Mcie7bf+FjZ9BUm8Yeb2rc6wodaXM6pJmRIQrffU6DVKGu3/o6n9u1H1WxT63bHUJDPbf21zf8bIiV/KPbQ3JvVysIu4knZji6jd3b4Gt89yJPCreqzeN2l/6Ld3j/lb6XGkxItJtT/XJtvbf6v1TnSSqKlwcZYXuCiWmhSt9pgxz2+3btz+BRMXuf59E7K8GiYh0VRwRUftL3OV7vb9+L1+J24ciLm5fqTtZR8W5E21xjluuz5luO6NbeMmkhUsoNcMtXJwHDLc8+IqkqvLA6oO8TbD+Yxd7dLx7b1Sc3/pbQItkVwf/Q0qpDa1F0v5hSwimnoIqKQCjgY2quhlARN4AJgANmxQ2fAof3wt7d7lSYX20SIazHocTbnMn+mDXhHcrhJza9cnJvWHszwITizFNLNjObl2AdL/xDOAE/wVE5BbgFoDu3bsf26fEJ7l7hxM6upJqQgd3yV7pc7eoxSa6Em5kjKtaaNUZYhOO7bOMMaYZCbakcESqOhWYCq5N4ZhW0nUkXPFCA0ZljDGhIdg6xMsE/Dvz6OpNM8YY0wSCLSksBPqKSE8RiQGuAmYEOCZjjAkbQVV9pKoVInI7MBt3S+rzqroqwGEZY0zYCKqkAKCqs4BZgY7DGGPCUbBVHxljjAkgSwrGGGNqWFIwxhhTw5KCMcaYGkHXId7REJFdwLZjfHs7ILcBwwkFtk8OZvukbrZfDtac9kkPVW1f14xmnRR+CBFZdKheAsOV7ZOD2T6pm+2Xg4XKPrHqI2OMMTUsKRhjjKkRzklhaqADCEK2Tw5m+6Rutl8OFhL7JGzbFIwxxhwsnK8UjDHG1GJJwRhjTI2wTAoico6IrBORjSJyb6DjaSoi0k1EvhCR1SKySkR+4U1PEpFPRWSD97etN11E5C/eflouIiMCuwWNQ0QiReR7EZnpjfcUke+87X7T68YdEYn1xjd681MDGXdjEpE2IvKOiKwVkTUiMtaOE7nT+79ZKSKvi0hcKB4rYZcURCQS+BtwLjAAmCQiAwIbVZOpAO5S1QHAGOBn3rbfC8xR1b7AHG8c3D7q671uAf7R9CE3iV8Aa/zG/w/4s6r2AXYDN3nTbwJ2e9P/7C0Xqp4GPlbV/sBQ3P4J2+NERLoAPwfSVHUQrmv/qwjFY0VVw+oFjAVm+43fB9wX6LgCtC/eB8YD64DO3rTOwDpv+J/AJL/la5YLlRfu6X5zgB8BMwHB/So1qvbxgnvOx1hvOMpbTgK9DY2wT1oDW2pvW5gfJ9XPj0/yvvuZwNmheKyE3ZUC+7/cahnetLDiXc4OB74DOqpqtjdrB9DRGw6HffUUcDdQ5Y0nA3tUtcIb99/mmv3hzS/wlg81PYFdwL+9arVpItKSMD5OVDUTmAJsB7Jx3/1iQvBYCcekEPZEJAF4F/ilqhb6z1NXtAmL+5RF5AIgR1UXBzqWIBMFjAD+oarDgWL2VxUB4XWcAHjtJxNwCTMFaAmcE9CgGkk4JoVMoJvfeFdvWlgQkWhcQnhVVad7k3eKSGdvfmcgx5se6vvqROAiEdkKvIGrQnoaaCMi1U8l9N/mmv3hzW8N5DVlwE0kA8hQ1e+88XdwSSJcjxOAM4EtqrpLVX3AdNzxE3LHSjgmhYVAX++ugRhcY9GMAMfUJEREgOeANar6J79ZM4DJ3vBkXFtD9fTrvLtLxgAFftUHzZ6q3qeqXVU1FXccfK6qVwNfAJd7i9XeH9X76XJv+ZArLavqDiBdRI7zJp0BrCZMjxPPdmCMiLTw/o+q90noHSuBbtQIxAs4D1gPbAJ+F+h4mnC7T8Jd8i8Hlnqv83B1nXOADcBnQJK3vODu1NoErMDdeRHw7WikfXMaMNMb7gUsADYCbwOx3vQ4b3yjN79XoONuxP0xDFjkHSv/AdqG+3ECPAKsBVYCLwOxoXisWDcXxhhjaoRj9ZExxphDsKRgjDGmhiUFY4wxNSwpGGOMqWFJwRhjTA1LCqZZEhEVkT/6jf9aRB5uoHW/ICKXH3nJeq+vtYi85PWYuckbbu03/0mv980na73vehHZ5XU1sUFEZovIuIaKy5i6WFIwzVUZcKmItAt0IP78ft3q7zlgs6r2UdXeuM7mpvnNvwUYoqq/qeO9b6rqcHU9kz4BTBeR4xs8cGM8lhRMc1WBeybunbVn1C7pi8he7+9pIvKViLwvIptF5AkRuVpEFojIChHp7beaM0VkkYis9/pIqn7uwpMistB7bsCtfuv9WkRm4H7l6h9LH2Ak8Jjf5EeBNBHp7b0nAVgsIlceboNV9Qtvm2/x1n2zF8syEXnX+7VtKxHZ4nVngogkVo+LyM/FPUtjuYi8UZ+dbMKPJQXTnP0NuNq/KqYehgI/AY4HrgX6qepoXMn9Dr/lUoHRwPnAsyISh+sjv0BVRwGjgJtFpKe3/AjgF6rar9bnDQCWqmpl9QRveCkwUFUvAvap6jBVfbMe8S8B+nvD01V1lKpWP+/gJlUtAr704gbXfcd0df313AsMV9Uh3j4w5iCWFEyzpa6H15dwDz+pr4Wqmq2qZbhuGT7xpq/AJYJqb6lqlapuADbjTsRn4fr4WYrrcjwZ92AZgAWquuWYN6b+xG94kHeFsgK4GhjoTZ8G3OAN3wD82xteDrwqItfgrrSMOYglBdPcPYUrwbf0m1aBd2yLSAQQ4zevzG+4ym+8CtdldLXa/b8o7oR8h1eqH6aqPVW1OqkUHyK+1cAwLw78YhpGraqmehrO/qfEvQDcrqqDcf3yxAGo6n+BVBE5DYhU1ZXe8ufjrq5GAAsP0f5hwpwlBdOsqWo+8Bb7H4MIsBVXjw9wERB9DKu+QkQivHaGXrinic0GbvOrr+/nPXzmcPFtBL4H7vebfD+wxJtXbyJyKq494V/epFZAthfP1bUWfwl4De8qwUtE3bx2iXtwXTknHM3nm/BgJQUTCv4I3O43/i/gfRFZBnzMoUvxh7Md17tlIvATVS0VkWm4KqYlXvfJu4CL67Gum4BnRGSTNz6fA5PY4VwpIicBLXB3LV2mqtVXCg/gqrF2eX9b+b3vVeBx4HVvPBJ4xWt/EeAvqrqnnjGYMGK9pBoTgry7ryao6rWBjsU0L3alYEyIEZFngHNxz8ow5qjYlYIxxpga1tBsjDGmhiUFY4wxNSwpGGOMqWFJwRhjTA1LCsYYY2r8f1bzl0t/3e+bAAAAAElFTkSuQmCC\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ],
+      "source": [
+        "plt.plot(days,[np.sqrt(np.log(K) * (day* K)) for day in days],label='Bound')\n",
+        "plt.plot(days, regrets_extended, label='Basis')\n",
+        "plt.ylabel('Regret')\n",
+        "plt.xlabel('Number Of Days')\n",
+        "plt.title('Regret As a Function of Number of Days')\n",
+        "plt.legend()\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {
+        "id": "XdXNFrrVJLtm",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 295
+        },
+        "outputId": "98b4e225-91c2-44b0-8517-ba5c3dbdf0f4"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEWCAYAAABhffzLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3gU1frA8e/Zkl4ghZAQSugtECBEOqEJ0hRFkCICiuX6Q7wqFxVFxY7iBcWroqKgXi5KsSAiIr2TQOggHdIgCSSkbbLl/P6YJSaQkISUTeB8nidPsjOzZ96Znbx75szMOUJKiaIoinL70Dk6AEVRFKVyqcSvKIpym1GJX1EU5TajEr+iKMptRiV+RVGU24xK/IqiKLcZlfgVxU4IcUgIEVnJ6xRCiK+EEJeFELsqc91FxNNACCGFEAYHrb+rEOK4ECJDCHGPI2K4HajEXwmEEGeEENn2gzlRCPG1EMLDQbFIIUTjEiwXaV92WiXF9aoQwmzfR1d//lWB6/taCPFG/mlSylZSyg0Vtc4idAP6AcFSyohrZwohxts/h39dMz22sr+kKslMYJ6U0kNK+eO1M/P9L6ULIVKFENuEEI8LIVQuKwW1syrPECmlBxAGtANeKO8VlHMt7SHgEjCuHMsszhL7P/zVn1mVuG5HqQ+ckVJm3mCZS8C/hBCelRRTubjJ47E+cKiYZYZIKT3ty74DTAO+vIl13bZU4q9kUspE4He0LwAAhBCd7DWXVCHEvvw1OSFEiBBik72Gs1YI8bEQ4lv7vKun5Q8LIc4B6+zTJwohjtibD34XQtS3T99kL3afvUY9srAYhRDuwHDgSaCJECI83zwXIcS3QogUe7y7hRABRZTzvBDipD32w0KIYaXdX/YzgW/zvS7QFCGE2CCEeF0IsdW+njVCCL98y3fLt2/P22vQjwJj0JJphhDiF/uyZ4QQfe1/Owsh5ggh4u0/c4QQzvZ5kfYa97NCiItCiAQhxIQbbEOQEOJnIcQlIcQJIcQk+/SHgS+AzvY4XiuiiCPAduCZIsovcPZyNb58r88IIaYKIfYLITKFEF8KIQKEEL/lO65qXlPsRPt2JwghnstXli7f55oihPheCOFzzWdT4HgsJN5J9v1wyb5fguzTTwINgV/s+8O5qH0KIKVMk1L+DIwEHhJCtLaXM0gIsVcIccX+mb+ab92/CiEmXxPPfiHEMKH5t/0zvSKEOHC1zFuOlFL9VPAPcAboa/87GDgAzLW/rgOkAAPRvoj72V/72+dvB94HnNCaBa4A39rnNQAksAhwB1yBu4ETQAvAALwEbMsXiwQaFxPvg0ACoAd+AT7KN+8x+zQ3+/wOgFcR5dwPBNm3aySQCQQWseyrV7frRtPzbbPB/noDcBJoat/+DcA79nn1gXRgFGAEfIEw+7yvgTdu8DnNBHYAtQB/YBvwun1eJGCxL2O0f3ZZQM0itm0T8B/ABe0LPwnobZ83Hthyg89iPLDF/r7LgI99eiwQWdi22OOLvWa7dgABaMfbRWAP2pmnC1qCfuWa/bsY7ZgKtcd7db9MsZcVDDgDnwGLizoeC9me3kAy0N7+/o+ATYV9BsX9L10z/RzwRL7tD0U77toAF4B77PNGADvzva8t2v+bE9AfiAZqAALtf6jQ47W6/6gaf+X5UQiRDpxH+8d7xT59LLBKSrlKSmmTUv4BRAEDhRD1gI7ADCllrpRyC/BzIWW/KqXMlFJmA48Db0spj0gpLcBbQNjVWn8JPYTW7GIF/gs8IIQw2ueZ0RJoYymlVUoZLaW8UlghUsofpJTx9u1aAhwHrmvHzmeEvWZ+9SeohPF+JaX8y7793/P32dRoYK2UcrGU0iylTJFSxpSwzDHATCnlRSllEvAa2hfiVWb7fLOUchWQATS7thAhRF2gKzBNSmmyr/8LStmEZn/fH2jNGjfjIynlBSllHLAZLfntlVKagBVoXwL5vWY/pg4AX6F9eYJ2fE2XUsZKKXPQvpiHi4LNOvmPx2uNARZIKffY3/8C2hlPg5vcrqviAR8AKeUGKeUB+3G3H+1LrKd9uZ+BpkKIJvbXD6Id67lon6kn0BwQ9v+hhDLGVSWpxF957pFau2Qk2oF1tTmiPnB//oSHVrMPRKstX5JSZuUr53whZeefVh+Ym6+sS2i1lzolCdKeqHoB39kn/YRWKxxkf/0NWlPV/+xNAbPyfSlcW9Y4IURMvlha59vuwnwvpayR7ye+JDEDifn+zgKuXjivi3Y2cDOCgLP5Xp+1T7sqxf7FWth6ry3nkpQy/ZqySvR5XGMG8ERRTWvFuJDv7+xCXl8be/5jKv+21wdW5PtMjwBWtLOJwt57rQL7VUqZgVbjvpn9kV8dtGMdIcQdQoj1QogkIUQa2peVn319JmAJMFZoF4RHoR3TSCnXAfOAj4GLQoj5QgivMsZVJanEX8mklBvRTs3ft086D3xzTcJzl1K+g9bc4iOEcMtXRN3Cis3393ngsWvKc5VSbithiA+iHRe/CCESgVNoif8he/xmKeVrUsqWQBdgMIXUXu1nGJ8D/wf4SilrAAfRvoRKIxOtWemq2qV473mgURHziuuWNh4tyV1Vzz6ttOLRPsP8F2brAXGlLUhKeRRYDky/ZlZZ9lFR8h9n+bf9PHDXNceXi/1MIi/UG5RbYL8K7XqSLzexP/KV0REt8W+xT/ovWs2+rpTSG/iUgsfdQrQzjz5AlpRye17gUn4opewAtERrPpx6s3FVZSrxO8YcoJ8Qoi3wLTBECNFfCKEX2sXTSCFEsJTyLFqzz6tCCCchRGdgSDFlfwq8IIRoBSCE8BZC3J9v/gW0C2hFeQitWSMs3899aE1PvkKIXkKIUCGEHu16gxmwFVKOO1oCSLLHMQGtxl9aMUAPIUQ9IYQ3pbsb6jugrxBihBDCYI//ajNQcfthMfCSEMJfaBeLZ6B9VqUipTyPdn3gbftn2wZ4+GbKsnsNmIDWDn1VDNrn4yOEqA08fZNl5/eyEMLNfhxNQKslg3Z8vSn+vmHAXwhxdynKXQxMEEKE2S/evoXW7HSmtAEKIbyEEIOB/6FdBzpgn+WJdpZlEkJEoDX55bEnehswG3tt315eR/vZghHty9RE4cd2tacSvwPY24wXobXdn0e7IPsiWpI8j1bLuPrZjAE6o50Ov4H2D5hzg7JXAO+iNcVcQatl35VvkVeBhfZT9RH53yuE6IRWG/tYSpmY7+dntAvGo9Bqk0vRkv4RYCP5/nnyxXEY7R9rO1qSDQW2lmT/XFPOH/Zt3o924W1lKd57Du3C67NozQAxaBfzQLv9r6V9P1x3vzjavo6yr/cA2sXQNwpZriRGoV34jEdrT39FSrn2ZgqSUp5G29/u+SZ/A+xDu/C5hr+TdFlsRPvM/wTel1KusU+fi1abXmO/ZrUDuKOkhdq3+2VgGdoZbSPggVLG9ku+62XTgQ/Qvpyu+gcw077MDLTrPtdahHZM5v8C9kI7S72M1hyVArxXytiqBSGlGoilOhFCLAGOSilfKXZhRVEKJYQYBzwqpezm6FgcQdX4qzj76Wcjod0/PQDt7KCwGqqiKCVgv2b2D2C+o2NxFJX4q77aaPemZwAfot2rvNehESlKNSWE6I/WpHoB7SLwbUk19SiKotxmVI1fURTlNuOQrldLy8/PTzZo0MDRYSiKolQr0dHRyVJK/2unV4vE36BBA6KiohwdhqIoSrUihDhb2PQKa+oRQiyw93J3MN80HyHEH0IbaOEPcX2PgIqiKEoFq8g2/q+BAddMex74U0rZBO3BkOcrcP2KoihKISos8UspN2HvNCmfu9H6ycD+Ww2tpiiKUskqu40/IF83p4kU7NGvAKENlvEoQL169a6bbzabiY2NxWQyVUScShXi4uJCcHAwRmOhnYAqilJKDru4K6WUQogiHyKQUs7H/mRdeHj4dcvFxsbi6elJgwYNEKK0HT4q1YWUkpSUFGJjYwkJCXF0OIpyS6js+/gvCCECAey/L95sQSaTCV9fX5X0b3FCCHx9fdWZnaKUo8pO/D9j79fd/vunshSmkv7tQX3OilK+KvJ2zsVoXfI2E9rA1A8D76D1Q38c6Gt/rSiKckvIyLGwLDqWqt4VTkXe1TNKShkopTRKKYOllF/axzztI6VsIqXsK6W89q6fakWv1xMWFpb3c+bMGbp06VKqMubMmUNWVlah8yIjI2nWrFle+cOHD79hWV9//TXx8TczSNSNlXabFOV29ev+eJ79YR/HLqQXv7ADVYsnd6sqV1dXYmIKjt29bdv1IxxaLBYMhsJ39Zw5cxg7dixubm6Fzv/uu+8IDw8vUTxff/01rVu3JiiopGOUl0xh26QoyvWS0rUxkk4nZdK8thdkXwajGxicHRxZQaqTtnLm4aGNWb1hwwa6d+/O0KFDadmyJZmZmQwaNIi2bdvSunVrlixZwocffkh8fDy9evWiV69eJV7H3XffzaJFiwD47LPPGDNmDEuXLiUqKooxY8YQFhZGdnY20dHR9OzZkw4dOtC/f38SErQ7aSMjI5k2bRoRERE0bdqUzZs3A3Do0CEiIiIICwujTZs2HD9+vMA2SSmZOnUqrVu3JjQ0lCVLluRta2RkJMOHD6d58+aMGTOmyp/qKkpFSM7IBeB0SiaknmPxF3cQvWqyg6O63i1R43/tl0Mcjr9SrmW2DPLilSGtbrhMdnY2YWHaEK4hISGsWLGiwPw9e/Zw8OBBQkJCWLZsGUFBQfz6668ApKWl4e3tzQcffMD69evx8/MrdB1jxozB1dUVgH79+vHee+8xf/58unbtSkhICLNnz2bHjh34+Pgwb9483n//fcLDwzGbzUyePJmffvoJf39/lixZwvTp01mwYAGgnYXs2rWLVatW8dprr7F27Vo+/fRTpkyZwpgxY8jNzcVqtRaIZfny5cTExLBv3z6Sk5Pp2LEjPXr0AGDv3r0cOnSIoKAgunbtytatW+nW7bYc3Ei5jSVlaDX+8xdTOb70Gd7ycqZJyk6WSVmlblK4JRK/oxTW1JNfRERE3r3noaGhPPvss0ybNo3BgwfTvXv3Eq2jsKaegIAAZs6cSa9evVixYgU+Pj7Xve/YsWMcPHiQfv36AWC1WgkMDMybf++99wLQoUMHzpw5A0Dnzp158803iY2N5d5776VJkyYFytyyZQujRo1Cr9cTEBBAz5492b17N15eXkRERBAcHAyQd71DJX7ldnMp/Sjt6nzK8BPpfOWVBkZ3jutsRMVtpWNw1fl/uCUSf3E1c0dxd/97POymTZuyZ88eVq1axUsvvUSfPn2YMWPGTZd94MABfH19i7yYK6WkVatWbN++vdD5zs5am6Ner8disQAwevRo7rjjDn799VcGDhzIZ599Ru/evUsUz9Xyri1TUW4nbrnLOOh1mekuggtOntxfK4I1CVtZvP/zGyZ+aTZhy0hEX7NBpcSp2vgrSXx8PG5ubowdO5apU6eyZ88eADw9PUlPL90dALt27eK3335j7969vP/++5w+ffq6spo1a0ZSUlJe4jebzRw6dOiG5Z46dYqGDRvy1FNPcffdd7N///4C87t3786SJUuwWq0kJSWxadMmIiIiShW7otzKTLp43GySWIMOKXQ8Gv5P7k3PZF3SXhKiPoe5bSE3E6SEP2fCWe3GiXnfD+Wu5QMxZ12ulDhV4q8kBw4cyLtw+tprr/HSSy8B8OijjzJgwIAiL+5evVgbFhZG3759ycnJYdKkSSxYsICgoCBmz57NxIkTkVIyfvx4Hn/8ccLCwrBarSxdupRp06bRtm1bwsLCir075/vvv6d169aEhYVx8OBBxo0bV2D+sGHDaNOmDW3btqV3797MmjWL2rVrl88OUpRqzmy1kWrMoFGOE9nnJjG59SvU9m/JA8ILI/D8vg8xXz4D57bDpVOweTb8bzTnts5mgTmeBIOebXs+rZRYq8WYu+Hh4fLagViOHDlCixYtHBSRUtnU561UdfHJKQxa2ZNIcz1WnHySeaPbMbhNECydyK9nVvO8vy9D0zMYVK8fCc6ubD25koZWOGwQRLm6YpSSbkYf3h27qdxiEkJESymvux/8lmjjVxRFcbS/Tv6JRQjq+7SEk3AmOVObUSecQQeXEePszf+8PPj5stb86u/qxlqdQCIZV3sgcXFRrDcnkp2Vgqubb4XGqhK/oihKOTgdpzWlNqrTndrHXDidbH8iv94dABiS+jA8OZW7XP/AW2ekaYvhxEY+y66EnfyyLYiUOAvZ9dbw6ZJn+GdoTy4FRbLosIUJXUPwdi3fLslVG7+iKEo5OH/lKHopadagOw383Nj4VxLjv9rFrylB7OqxkPm5d+JRtx8RJhPNstL536UmXLzkTrfag9l07DKhLcfgZ7ERk7sN28p/4rIgkuh1y/OeBi5PKvEriqKUg1jzBWqZddSu4UnfFgEYdIKjCek8vWQvbxz2w8vNhcdGjyATFyxSx1tHavF//93L19vOYJPwaM9mjAkZzR4XFyY3fJQtwpPadT6nbvaBco9VJX5FUZSyslo4L0x45nri6Wzgke4N2fFiH1Y/3Z1ani7sj02jf6vaeLi5klH/ThL8u/DxxEguXDHxyYaTRIT40MDPnYd7vYg3rdhoXcszdQzs8PLhjEfNcg9XJX5FUZQyyozbRazRgMEaXKBrhhpuTnwytj1B3i7cH14XgICHFlL3H7/Qo6k/D3fTnuy/v4P21LsQgufDZyAtHtQxdOWX+/+gmW/zco9XXdwtA71eT2hoKFJK9Ho98+bNu6kujB955BGeeeYZWrZsWQFRKopS0XYc+R4As77zdfPaBNdg2wt9/p6g+7u+/Vz/ZrQM8mJIm7971B3UsgVW8//o3sSfGi5OFRKvSvxlkL+vnt9//50XXniBjRs3lrqcL774orxDUxSloqSeg5+ehLtmQS3t2ZINibtxt4GnW+meZHc26BnWLrjANCEEd4fVKbdwC6OaesrJlStXqFlTa4vLyMigT58+tG/fntDQUH76SRthsrCumUHrJjkqKgqr1cr48ePzuj3+97//7bDtURSlcBmxu/nkcgwp3w2HKwlYc7PZZE0lJNubWh7uxRdQBdwaNf7fnofEcr7yXTsU7rrxyJBXu2U2mUwkJCSwbt06AFxcXFixYgVeXl4kJyfTqVMnhg4dyurVq6/rmjm/mJgY4uLiOHjwIACpqanlu02KopRZ9OWj/KdmDZZbLMxdfC854RO4pNfhf6U5viFVa8CVoqgafxlcbeo5evQoq1evZty4cUgpkVLy4osv0qZNG/r27UtcXBwXLlwgNDSUP/74g2nTprF582a8vb0LlNewYUNOnTrF5MmTWb16NV5eXg7aMkVRipKeo439keHkzhjndGbu/TcGKTl2pTt+HhXTJl/ebo0afzE188rQuXNnkpOTSUpKYtWqVSQlJREdHY3RaKRBgwaYTKZiu2auWbMm+/bt4/fff+fTTz/l+++/zxs4RVGUqiHustaD5sjaL5Oa9T+WXz5Ah1wD621+dGlU+IBKVc2tkfirgKNHj2K1WvH19SUtLY1atWphNBpZv349Z8+eBbSumX18fBg7diw1atS47qJucnIyTk5O3HfffTRr1oyxY8c6YlMURbmBLLPWFcPiXWbWPfcNI3fM5Z0NmQwMrU3LoOpxlq4SfxnkH3pRSsnChQvR6/WMGTOGIUOGEBoaSnh4OM2ba/fhHjhwgKlTp6LT6TAajXzyyScFyouLi2PChAnYbDYA3n777crdIEVRimWyZANwIUPP278d4Up2bzaZ4vm9b1MHR1ZyKvGXwbVj0l7l5+dX6MhXDRo0oH///tdN37BhQ97fVwdoURSlajJZsxFC0r5eLb7dcQ6AcZ3r0zTA08GRlZxK/IqiKKWQY8vBRQcfj27PmeQsGtfyqDYXda9SiV9RFKUUcqUZZxvU8nQh0NvV0eHcFJX4FUVRSiFH5uKMQK8TxS9cRanEryiKUgq50oKR6pv0QT3ApSiKUio5WHCS1Tt1Vu/oFUVRKlkONoxS7+gwykQl/jJ48803adWqFW3atCEsLIydO3dWegwbNmxg8ODBhU739vYmLCws72ft2rWlLj8mJoZVq1bddHyPPPIIhw8fvun3K0pVkytsGGX1biWv3tE70Pbt21m5ciV79uzB2dmZ5ORkcnNzHR1WAd27d2flypVlKiMmJoaoqCgGDhx4U+9XXU4rt5ocIfGs5qlT1fhvUkJCAn5+fjg7a73x+fn5ERSkDaYQHR1Nz5496dChA/379ychIQGAEydO0LdvX9q2bUv79u05efIkUkqmTp2a1xXz1a6aN2zYQGRkJMOHD6d58+aMGTMGKSUAq1evpnnz5rRv357ly5eXKu7du3fTpk0bTCYTmZmZtGrVioMHD5KZmcnEiROJiIigXbt2/PTTT+Tm5jJjxgyWLFlCWFgYS5Ys4dVXX2XixIlERkbSsGFDPvzwQ6D4LqcBFi9eTGhoKK1bt2batGl5MXl4eDB9+nTatm1Lp06duHDhws1+LIpS4UxCYsTo6DDKxCFfW0KIfwKPABI4AEyQUpputrx3d73L0UtHyys8AJr7NGdaxLQi5995553MnDmTpk2b0rdvX0aOHEnPnj0xm81MnjyZn376CX9/f5YsWcL06dNZsGABY8aM4fnnn2fYsGGYTCZsNhvLly8nJiaGffv2kZycTMeOHenRowcAe/fu5dChQwQFBdG1a1e2bt1KeHg4kyZNYt26dTRu3JiRI0cWGePmzZvzupQAWLZsGR07dmTo0KG89NJLZGdnM3bsWFq3bs2LL75I7969WbBgAampqURERNC3b19mzpxJVFQU8+bNA+DVV1/l6NGjrF+/nvT0dJo1a8YTTzxRbJfT8fHxTJs2jejoaGrWrMmdd97Jjz/+yD333ENmZiadOnXizTff5F//+heff/45L7300k1/dopSkUxCYBDV64Gta1V64hdC1AGeAlpKKbOFEN8DDwBfV3YsZeHh4UF0dDSbN29m/fr1jBw5knfeeYfw8HAOHjxIv379AK1bh8DAQNLT04mLi2PYsGGA1mc/wJYtWxg1ahR6vZ6AgAB69uzJ7t278fLyIiIiguBgbXSesLAwzpw5g4eHByEhITRp0gSAsWPHMn/+/EJjLKqpZ8aMGXTs2BEXF5e8GvuaNWv4+eefef/99wEwmUycO3eu0HIHDRqEs7Mzzs7O1KpVK6/L6WeffZZp06YxePBgunfvXuA9u3fvJjIyEn9/fwDGjBnDpk2buOeee3Bycsq7TtGhQwf++OOPEn4KilLJrGaydQKjqB797hfFUQ1VBsBVCGEG3ID4shR2o5p5RdLr9URGRhIZGUloaCgLFy6kQ4cOtGrV6rq+etLT00td/tVmpKvrslgsZY4ZICUlhYyMDMxmMyaTCXd3d6SULFu2jGbNmhVYtrAL1oXFVVyX0zdiNBrzBqguz+1UlPJmNqVhEQKjzsXRoZRJpbfxSynjgPeBc0ACkCalXHPtckKIR4UQUUKIqKSkpMoOs1jHjh3j+PHjea9jYmKoX78+zZo1IykpKS/xm81mDh06hKenJ8HBwfz4448A5OTkkJWVRffu3VmyZAlWq5WkpCQ2bdpERETR43Y2b96cM2fOcPLkSUBrNy+txx57jNdff50xY8bktbX379+fjz76KO86wt69ewHw9PQs0ZdWfHw8bm5ujB07lqlTp17X2VxERAQbN24kOTkZq9XK4sWL6dmzZ6ljVxRHMpm0UfGc9NU78TuiqacmcDcQAqQCPwghxkopv82/nJRyPjAfIDw8XFZ2nMXJyMhg8uTJpKamYjAYaNy4MfPnz8fJyYmlS5fy1FNPkZaWhsVi4emnn6ZVq1Z88803PPbYY8yYMQOj0cgPP/zAsGHD2L59O23btkUIwaxZs6hduzZHjxZ+zcLFxYX58+czaNAg3Nzc6N69e5GJ+do2/pdeeomsrCyMRiOjR4/GarXSpUsX1q1bx8svv8zTTz9NmzZtsNlshISEsHLlSnr16sU777xDWFgYL7zwQpH7o7gupwMDA3nnnXfo1asXUkoGDRrE3XfffRN7XlEcJ9ukDcJi1Ls5OJKyEVdreJW2QiHuBwZIKR+2vx4HdJJS/qOo94SHh8urd4ZcdeTIEVq0aFGhsSpVh/q8larg5PHfuWfbc4ww9uPl0R84OpxiCSGipZTh1053xO2c54BOQgg3oTXs9gGOOCAORVGUUknP0pp6nA0eDo6kbBzRxr8TWArsQbuVU4e9SUdRFKUqy0v8TtU78Tvkrh4p5SvAK+VQTt7dIMqtq7KbIxWlKBnZ2vMprs7eDo6kbKrtk7suLi6kpKSopHCLk1KSkpKS99yDojhSZq52I4Wrc/UYVL0o1bbDieDgYGJjY6mKt3oq5cvFxSXvQTZFcaTMnAwAPFxrOjiSsqm2id9oNBISEuLoMBRFuY1km7XE7+bq6+BIyqbaNvUoiqJUtmxzFgCe7tW7xq8Sv6IoSgmZrNkAeLmpxK8oinJbMFlN6KXE29XV0aGUSbVt41cURalsOdYcXAAXY/UeelElfkVRlBLKkbk4A65OKvEriqLcFnJsZpwQuBiqdyt59Y5eURSlEuVgwUkKDPrqnTqrd/SKoiiVKAcLRln902b13wJFUZRKkosNo6ze7fugEr+iKEqJ5WDDoBK/oijK7SNHSIwYHR1GmanEryiKUkImAQaV+BVFUW4fJh0YhZOjwygzlfgVRVFKQF5JxCQEQlTvgdZBJX5FUZQS2bN3PlYhMDu3cnQoZaYSv6IoSgksOPMr3lZJDbe7HR1KmanEryiKUozjiXvZRBatrgTi4ayaehRFUaqkhTuO8M2OY2UuR0rJf3a8havNRsqlvrg6Vf8uzlTiVxTlljTv0AxmxbxArsVWpnK+PPgla9OO8kimlejclng4qwe4FEVRqhwpJTm60+Bygt8OnyhuYci6hMVmIdOcWWDW1ritzN0zl7syTTS33oHRYODusDoVGHnlUIlfUZRbTmJmIlKXA0Ly3f411823SRsms5XHvoki+deZ5LwXwriv2zPqhwFYrZa85T7b/xnBTjWYmZTEnMQwJnUPoX+7lGAAACAASURBVK6PauNXFEWpco4nHwZASMnRtC1k5VrApjX5pOWkMeKXETy+5iksR1biF/UBbzVoxQG95LQ5lU8WPkpalpnDKYfZe3Ev92bpuCz9OO/emiciGztys8pN9b9KoSiKco2j57YA0C8zi7Vux9ixfhm99zyHud/rPJOymROpJ7DKYwwOzGayvgEbSMcpvTdObhs4mrOJvV//k7Wt3HHWOTP8/AFW6u/m84c64uF8a6RMVeNXFOWWc/ziPmpZLAzONGHTWTi57yPIucJ/ts5gV+IuXu/6Ot1oyUovVza6Cu5vNI6U2L6E+t7LJldX4rNX8NvpXxmSlkZNrNwz7mnC6tZw9GaVG5X4FUW55ZzKjKNeLjT0bIenTbLPI5F1dcayuEZNBmRmMcQ3jIcT03juYg7pp57FcGUwoOPB0FEgdLzt50Og3p06V0L53n8ynvXbOnqTypVK/Iqi3FKsNitnZBZuOV7kBPVkQmoaG91dec50kUxsjE9Lh+0fE5odjY81Amn24b87z+HlYqBrgyY81vxVss5NYGTj//HGlYfJCnvY0ZtU7lTiVxTllnI+6SC5AnJzgsipH8mYK+n4YMDsdRRjbhOa1e+D3PkpzuSS0+gufNydyMixEBHig04nGB82BJnVjM83nwEgIsTXsRtUAVTiVxTllnLi9FoAkkxNcQpojlvfmUxq+RAAVy505cucfggkqdIdl8bdaGdvu7/DnuDdnQ20CPTi3KUsvFwMNKvt6ZgNqUC3xiVqRVEUuyPxO9FJyXFTWzxdjdD1KUZLG20b9OHXKCNvbzzBUN+WrEmrQ0TtmrRPNfPn0Yt0DPHJK6ND/Zocir9CxwY+6HXCgVtTMRyS+IUQNYAvgNaABCZKKbc7IhZFUW4tO9L+oqnNwG7pjaeLluJ0Qkeofyj1epr5dsdZelyejlXCYT93HuhYFzcnPW3qeOeV0aF+TRZtP0tEvi+DW4mjmnrmAqullM2BtsARB8WhKMotJC3lLw4KCw11DREC3K/pUM3bzci4zvUx2wR1fdxxMerx9XBmQtcQdPlq9j2a+BPZzJ+BoYGVvQmVotITvxDCG+gBfAkgpcyVUqZWdhyKotx6duxfhE0InJ0j8XA2FEjmVz3cLQQXo44mtYpuu6/p7sTXEyJuie4ZCuOIpp4QIAn4SgjRFogGpkgpC/SOJIR4FHgUoF69epUepKIo1c+2uC142iRXdF3wcrlS6DK+Hs4snBCBn6dzJUdXdTiiqccAtAc+kVK2AzKB569dSEo5X0oZLqUM9/f3r+wYFUWpZqQll625SXRy9iczl7z2/cLc0dCXRv4elRhd1eKIxB8LxEopd9pfL0X7IlAURblpJ4+u4IJeR5c63Uk3mfFyMTo6pCqr0hO/lDIROC+EaGaf1Ac4XNlxKIpya1n/1zIAurV5iCvZlhvW+G93jtozk4HvhBBOwClggoPiUBTlFrEu9Rihemdq12xEes5Zmrrcvk05xXFI4pdSxgDhjli3oii3nsSEPRzU25jiq3Wmlm6y4KmaeoqkumxQFKXaW7f/KwD6tBqLlJJ0kwUvV9XUUxSV+BVFqfbWXdhFAws8vdLAkYR0rDapavw3UKLEL4SYUpJpiqIolS3u8il22zKpn+XPvrgrLN8TC9z4ds7bXUlr/A8VMm18OcahKIpyU76L+gAdcCm5M54uBtYduwigavw3cMOvRCHEKGA0ECKE+DnfLE/gUkUGpiiKUpz03HSWx2+hb4YJnw73EWjSs0zV+ItV3J7ZBiQAfsDsfNPTgf0VFZSiKMqNLNm/hQ+i3yXEz4NMrLRODaDdPQ05knAlL/F7qcRfpBvuGSnlWeAs0FkIUR9oIqVcK4RwBVzRvgAURVEq1R8xH2IWp7l4yYP+GZkk2O7kwSBv3J3/Tmnqyd2ilfTi7iS0rhU+s08KBn6sqKAURVFu5Jz5BJ2yTaw7fYT3k1KwNOyLTido6OeOr7sToNr4b6SkF3efBLoCVwCklMeBWhUVlKIoSlEuZl0kwWCmVlYNTtiC2G8LoU2o9uCWEILwBjUB1cZ/IyXdMzlSylwhtL6thRAGtJGzFEVRKsXak9EEefpx4sIGAAI8u3DP5X7orSY2NvHLW25Yu2DSTRbcnPQOirTqK2ni3yiEeBFwFUL0A/4B/FJxYSmKovzNarPy4saHcRIuhHkF42W10iBkIKPq1CMhzUQNN6e8ZQe0rs2A1rUdGG3VV9LEPw14BDgAPAasQhszV1EUpcJtO7aFbL2VbDLZmHGMHiYLfo06ML2hGqvjZhSb+IUQeuCQfXzczys+JEVRlIK2718MwIi0DL739qBWVg0a1vJycFTVV7EXd6WUVuCYEEKNf6got4rMZMipendjf7jnQ2ZHzcZqsxaYfiJtL34WG14XuzP3QhJemW3wcXcqohSlOCVt6qkJHBJC7EIbKhEAKeXQColKUZTyc3QV+DcD30ZczLrInjN/EvT7DFoE3YFx5LeVFsaKPZ/yy18/8ErECwRbbPy2eSa6kO50uONpAtwDOJ9+ni8OfIFEkpiZyFvd38KoMyJzsziuT6eexY9VXqPxvJLDoYDBXL3ZRCm9kib+lys0CkVRKoS8cIjNP03AXRo4FjSS+U5RpORcBh8Xhqbs5E2zCYwuFR7HF7veY+6RRQgpGbfhKeqZLcS4OMP5lejOr2JWz1nsS9qHTuho5tyf1WdWsTfxL97v9Rou5/aRbNDT2bUjQf5BzNw1jvsCgis85ltZiRK/lHJjRQeiKEr5O7plLk/W1h65EbY11Mq08nlSCh/5N2KHswV5ZjOiSb8yrePYpWMY9UYaejcsdP7C3R8x98gi7so2M6n76zwZ8wEnjLm81eZJGv4xkzd9fXl568voENyRAZ+d+pTf3dx5yxce/O1BGpitYNTToeVwjMKPxbvO09DfvUwx3+5KlPiFEOlcf99+GhAFPCulPFXegSmKUka5mayJX4fwdOWBxv/HhoN/0juzDv5dO7F36170gb8Sd+xngsuQ+M02M4/+8ShZ5ize7fEuvev1BiA+I57oxCgyLhzgg+OL6ZaVS1zSZBKMkSwbPgCT1czBcxY2cIo5sf/hvuB6pOqs/CP1AqebPUKdHAtvnd5CjG8qi7w8MJjduLN5OFabpGWgF93z3bevlF5Jm3rmALHAfwEBPAA0AvYAC4DIighOUZSbZzuwlFWuRtyygniq48PUNQzg5R8P8vtOd0zZTXAHos9tJFhKKGV7udlmxqgzsvn0Gi6ZLlEDN6asf5pRTR7m7qZ9mbRqHOkyF4CGuZLQ2rNYYarJuAW78HV3wmKTpGWbCfKKxNs9m0/jF3HAxYlTbqMYNmo2adlm7ntzLW2dapByIoEeTWvmdcGwakr38t5Vt52SJv6hUsq2+V7PF0LESCmn2R/sUhSliok+8A3xRgMeWX3xcDZwb7s6zPrtKKeTM+nauCWHrQb2WlMZvPNTjspsGteLxLl2G9DfOC3sTNjJlPVTeL3RKH7c8wm+TjpWxh7jed86LD7+BYuPf0Fti4XHL9YkWrQmuOWDPDGkG+NyrfyyL56oM5cRAvq1DCCymT/Qi7f/0wT3pBjuf+oNALxdjQwKDWT53jga+vswZ0TXSthjt4+SJv4sIcQItI7aAIYDJvvfqusGRalqpOSXrPM4u7rQ1rcbAO7OBkZ3qsfPMfHMvr8dA76ty16XbP696x0WenvhfPRL7jM788L4zeBUeBu6lJKP9n5EpjmTlw9/gcnVQGtdF4z3DWHWn2+w/kIsqzxcCUjtw6DJcxnn+feFYw9nA6Mi6jEq4vo7w1/4xySSM3KpU8M1b9qkHg2JS83mrXtDVU+b5ayknbSNAR4ELgIX7H+PtXfP/H8VFJuiKDcrLZZtzjp8M/0JDfr76dZp/Zuz/rlIanu74CpCOeVkZKGXNy5XGuOTVYv/Ops5uuKJvOUtNgtxGXF5r3cm7mRf0j4eDuqFQVqxCsHMoc/j3HoIblN2khW5hX0pcxj64Lv4epb8biFng75A0gdoEejFksc608jfoww7QilMiRK/lPKUlHKIlNJPSulv//uElDJbSrmlooNUFKV0Es9t5YLBgDkrhFZBfz/hqtMJXIxa52WtfcMAsOX6ck/jV5h1zyJ0UvDzhY1wQDu5/2rbewxYNoBZu97lQNIB5u6eTS0XXyadPsQriWY6e42nYY2/7+a5PyKEzS8NIqxujUrcWqW0Stoff1MhxJ9CiIP2122EEC9VbGiKotysvbGbALiQ1YZWQd6FLtMrpAO5lyOwXhjLY91bEFanLnWc7mCFhyeXtmu9s6w/+gsuNhvfHPmW0atGc+TSEZ4+fwz3+Cg2ZQ7ksfYTritXPVhV9ZW0qedz4AXADCCl3I92Z4+iKFXQ3stHcbFJXI1N8fd0LnSZiAb+5CTey6iwTvh5aMs812UiGXrB+iuHyEhL4pTuCkMyMnkrycgL+sasOZuI2W0CvwRN4RfDnbQJVjX76qikF3fdpJS7rvkmt1RAPIqilIOYnGTq5TpTM9i3yGUa1/Lk83HhdGn09zK96nfCT+fHz54msv47lUw3QYA1gCEZR+HESb6y3sVr57riatTTtbEfRn1J645KVVLSTy1ZCNEI+x08QojhaIOwK4pSxWRlJvOXzoZbli+9m994oLx+LQMKjFMrhGBEq5HscXEhIVd7YL/XPR9ykZpckW6EjnqD5rU9yTZb6da46C8VpWorzdCLnwHNhRBxwNPA4xUWlaIoN23/qd+wCkFOVkixib8w9zS9G4DF3u74WQVN6kcQ3/9zjvX+gvCWjflgRBhhdWvQXw12Um2VtK+eU0BfIYQ72pdFFlob/9kKjE1RlJsQHbsZISWu7l2o7V36DtgCPQIJd69HVOY52nsEI4QgrPPf3Tq0DPLixyfVA1XV2Q1r/EIILyHEC0KIefYhF7OAh4ATwIjKCFBRlNLZlBRDyxwrbVpG3HQZQ1uMBqB9o4HlFZZShRRX4/8GuAxsByYB09H66hkmpYyp4NgURSmCzWrjQlIcgbXrFpiefPkUh2U2XTMC6d3i5ptiBjS7l9OmCwxsNaasoSpVUHGJv6GUMhRACPEF2gXdelJK043fpihKRfp0+TS+zljFP5vMYFS3kXnTN+/5FIDk3J60LcOtlq4GV57p8EyZ41SqpuISv/nqH1JKqxAitrySvn0s3yggTko5uDzKVJTbxb7LO8h21vHvv96haYN2NFj/Nh7+wWxM3ICvVRJYbzA6nXqQSilccYm/rRDiiv1vAbjaXwtASinLMtrxFOAIoEZMVpRSOqlLJdSUw2mjZNKaB3ggI4UWF3LZ7utDvcxa9Ghb+rt5lNvHDRO/lFJfESsVQgQDg4A3AXU+qSilcCT2MBeMMDzHk5dTzvJZjRos9vLCYq/gn0rrRY+m/jcuRLmtlfTJ3fI2B/gX4FnUAkKIR4FHAerVu74bV0W5Xa2N+QGAkGbjaREzjzkXEzl131LuXJqA1QZNfRoQ4FXx4+gq1VelJ34hxGDgopQyWggRWdRyUsr5wHyA8PBw1ee/otgdTNqJp7TRreMICAiE1HM0DO3HXQf38su+eHo0VcMSKjfmiBp/V2CoEGIg4AJ4CSG+lVKOdUAsilLtnLIm0NIC7t4BEDo8b/pjPRqy5lAiA1oHOjA6pTqo9MQvpXwBradP7DX+51TSV5Qbk1Ly5s43WXv2T1KMFnpZrr9Hv3Udbw7PHIBe3c2jFMNRbfyKopTChvMbWHJsCWHZRkaaUunUqPC6kkr6Skk4NPFLKTcAGxwZg6JUWZZcOLcNs5MHszZMIyTXzJuJ2dhCJ9Dgrn86OjqlGlM1fkWpCnKzIOkI1GoFRhcSTh8g6ffHOJB1ls2ursS6uTIytQmGyd8R5KsefVHKRiV+RakCTq9+jm0nfmJ4ppkjRjee9XfloqsBXH1wMrsSlNaMUeM/IchXDTyulJ1K/IriYFnpiUxO2sBZXx8WeLmSpsvBVefEiFrj8Ha9g/DghrSpWwMPZ/XvqpQPdSQpioO98+cUzul1tMrtxkHdXvzdavPt4AXU8ajj6NCUW5RK/IriQDEXY1iRdpgx2U58enYwrwydwsiO9XAzujk6NOUWphK/ojiAzSZ57Nto3Fw+xskmken9aV+vBhO6NHd0aMptoKRj7iqKcgNSSn488SOJmYmFL2CzkZydzPpz6zmWfIgtJ+JZf/g8+9J309kiWHCpE/e0U007SuVQNX5FKQe/HfkfL+9+i/pGbxa1m4pP00Gg1/69Lscs4r1tb/Cbm3NeD5qNcq087lWbhQZBZlo3bDojA0NVVwtK5VCJX1FKKddi43+7z+HuZKCG6Tye++Yx23kv9aWNRNtlntg8lQfXv0y9+j1Jykri3Sv7SHJzpmu6O/dhI6F2A96RR0gIvIBe6lif2IfujXzx83B29KYptwmV+JXbgk3a2JWwk3YB7XHWawnWZpN8s+MsHep509r1Evg2KlFZ645e4NufV/Ok4Sci9Dt437cmFw3ueJ99AKvOxrGgn3jB2QLJGwDwls50dHqR87o6TDifSq0rzpicViNr/U5Tt7ZE21wZ2jaoojZdUa6jEn81ZbHa2BebRof6NR0dSrWwdOdsXj+2iFpSx3Mhw7ir56us3B/Pm5vnc6fTBrrYzvHAxK3oatYvtqyEozuZ6fUqv3t58I5HAzKwMKLpCF588CUyTBYmfdOXI4l/cUcTA+uPpDKxay+e7t0agJ/3xfP6ysM0chrKve2aEVG7E/HN/ejXMqCC94Ci/E1IWfW7ug8PD5dRUVGODqNK+XrLDn7Y+T4fj/+KBr5FjmejABabhSHfdcbZlIFeGDhlkKwbsIShi6NJ9Xkvb7m5IVPo3eORYsv7cM4IPq95BFe9C5H1ejG6+WjCaoXlzT+VlMGAuZvJtdgYFVGXt4aFIsTfnadl51qxSqkeyFIqnBAiWkoZfu10dVdPNbX/6GzO+R0j6vAvjg6lylt7ahWxNhPtUwI5Hz8SixB8uHgGXtbVALynbwLA8YuHiy3LZpNc4hB6CX+OWMesHrMKJH2Ahv4evHFPa+7vEMxrQ1sXSPoArk56lfQVh1KJv5qKt5wB4GxijGMDqQY+3jmXBrlmAgPHsPypKbhIgVl/EB+PAzSyCjoO/hiAuPSzxZZ17uRBjruaaaj3w9Op6DOtEeF1ee/+tjgZ1L+YUvWoo7IayjDlcNYpG4ALGSccHE3VdjYtnjOWi9yVYePBBx4kuIYnETWbE+Wm44izjc6BnfCtEUhNi42L5qRiy0vYu5xDzk60C+pWCdErSsVQib8a2rTvDzL0WvPBRfNFB0dTtf0U/SsATQK64+LsBEDnxoOJMxrI0eno3Fob0KS21UAy6cWWdz7xD6xC0Lv5wIoLWlEqmEr81VDMyZUA1DVbSRLFJ6vb2ekTP2CUks59ns+b1rlOVwAMwkB4be26VwBuXNSbueHNDiknOS9j0UtB+4CwopdTlCpOJf5q6HTGYWpYbTS3+pNosGKTNkeHVCVZrlwkxXaWYKsrHgFN8qY39G5IbffatAtol9cZWoDRj8sGwfnLl4os78qqGWx3dcHf2AhXg2uFx68oFUXdWlAOzNZchJQYDJXz5OU53SUamV3xdwomV3eJ88nHqO/fQpuZmwVOqmdHgLjf3+eIs4FOPp0LTBdC8HGfjwsk73oedSHrDNFn9lLPp2/e9DVHTvL+jq9pH5BCdO4eEp2NPNL0rkrbBkWpCKrGX0apaee4f2EEvRe1Z86CTqSf2VRh65JS8tqvrxFvFIQ4N6K2VzMA9p/cqi1w4RC8Wx/2/1BhMdysvdE7ycnNrZR1ZZmzWLNnORnHF2HS6ejdou91yzSt2ZS6nnX/fl1L6xXzeOzevGlWm+SFzS+ToPuRrYkbqZsrudP7Kf6vw8MVvxGKUoFU4i+DjKxkJi27h/PCQk2TOwt0GTy15nGsmcXfHVIaZquNr3Zto+eikSxNXkqXLDMT+r5GSGBHAE4k7gcgfsdHjAqoyc8bpkNW0U0WlW39hoV8vmsMby4cSFx6bLmXn5hm4pGFUXy19TRSSu5f/iTPHniFd3xqANChdvHt8a3ra239cWnHtQlWC9//bzK5zgd46lIqX50TWFL+ycy7JqDX6ct9GxSlMqnEXwafr57CX7pc7rjchel3rSbMMogoZz1vLx5G3LmtZGVfAnN23vI/Rscw/N9PkJCWoU2w2WD3l1jmdYTzu4pcz1sLJzHn8KPkWg8zPfkS83p/SL3g5tQPCcfLauVc+inIyeCzuD856OzMdG9nZv08mozcjArZbikl+5L2FbgQajJb6fneer6POl9g2QNJ+5lx6n2iXJz50ZjI3SuGcPZK8ffLl9ShvdtZPedhep54DX6byjufjeCcKYq6ZjMxrkZqONcoULMviodvI2pZLCTnaF9Mpu2fsDzjD/wsgrERU/Gcso23/28c7urBK+UWoLpsKIMHPw8nVZqYM2wHjfw9MJmtTFgwmIMuWvKoabXyZcJFmrS4D8vQ/zDyy8785ZLNA6IbL4ycxezF/fnTcpl4g54+Fj19e87kz7iNZJjSaO1Uk9EdnsLoFMB934VTU9r4zFgfn5bDIGISoCXbBxeEgtGTOy29+I/TStxTW9DUKYXd7kl4CgOT2j7BuNCHy7WWuipmBdP2zWCAcSjT73mFGm5ObDkRy/NrH8BmzMLLyYCfVwipllzOZpwg0GKhd8YAQtJ2837dy/QO7MS7A74scxyX0q7w0dcRLK1hBMDVJrECjc2CBQ3v522XHPxc/Xm6w9PFF2azMX5+cxKED7MjF3J4ZX9e9/NkQpPpPNPlgTLHqiiOUFSXDar6cgPmw79gqNMB4X19z4nSZuOUPptWOT408vcAwMWo56Mxy3jzx9kkJR7lr5pHGRcYzId/rWDPojP85ZKNu83GButGAv47kEW6dBoSjF+qB9u8/2LttpfwQU+tXBMLjAb2xu2mmd9ELhhhgnsXfIZ/XiAGF6OeBjmurHbJIpZfEOh4sMPzfL7uIsMvf8lFnxg+iPmIrYk7ebfHLHxtEtz9yrxfdh/6CYCjmct5ck5jvp72EGu3P0+aaxr907MRJkjMSsVJuvF0dgbt0pwR419k0YbDDE57gmViJ+PObqFV/YIPQUkpr+veoChSShZ/+zzLvA1EeLSga7MBJKRfJDr2FC/3eB73gIa8UZqN0uloJZ3Z45LJryseYbW/G3WdGvDPziNLU4qiVAuqqacIsSc30nXn83Ra3o/R3/Ymx2IqMP/U2S1c0esIcmtWYLqfhxv/Hvsynz+1iIkt5pEt3JgYGMA8fTyhJsk/Gj1HolHPXF0qTa1B7DsxhZa1XuaZM4EsjL/AirhMhiZEcG+yK1G2S/wc/zHeVivDOz1WaJx1cwcw6SIYMTCubl8e696BVf/sRUK9FwiIvZOZSSnEXNjDB2uehPcawdrXoIxneXGZ2tPCZ5wMjNK/RuwPT7POvIcW2U7oA5ax8fyrjElqxdxLAteUMD7xmE5YfT+eGdqRi7pncJOSd377B7uPnc4r84vNp7jjrT/JyLEUu36bTfKf36LYL/7EDR0fDP6cia0nMr3z8yy/fz6tAxre1HY96VqXprm5fBuYSrJBz1t9Xi/xF5GiVCcq8Rdh9f4fydbpaJxt4IA1iV93LSowf/NBrXO0lvV6Ffp+Vyc9j3fpzPoHVnGv/5P0SvPkwWavMLbbQ/ib6+FkdmHPyYd5rGcj5o1uz8XOs3k7fRrhVz5gqe9j9A9/iSa5uaQbsrkrW+Jcp0Oh6zlT934+S3+P/w7bztN9/g1ALS8XPn2wA63ueY7wK27clW7ht8sHiXepiXXLB6SunFKm5J8oUmmV40xtFz/m+tTgPykruazX4+n6JC8MasEjAzvT+dnvqfP8HuSQOTx+/yCEENT1cWPe/z3McJ8BxLhKlqy+l/9uOUK6ycxH605wMT2Hn2Pib7huq03y6oJleBwYzzZ3Jx5ucj/ezt43vS35udVuy9zL2fgY3BnScMh1na8pyq1CtfEXYcqCfuwU8XzZ/XvGbx5BFxHC3PEr8+b/a8GdrBPx/DpsGwE1vEpV9pmUNI5dTOWO+oHUcHPKm55rsWHUC62WKSVR/+nAiy7ZfFqzCw3vLbxNPCk9hysmc15z07X++O+/aXrqDYYEB2JIuYNmfn9x0naJz4KH0q7f26WKGyDl4jn6rhpIH9GUO3s+ztQNL2MTWegyGvFk6Gwe7VH8YCZSSmb+OpGlKVG0yJaYnVpyIKEDPqIt/h7urJzcrcia9q5Dx4j5fQDzfNxp6VmPr+5eVn4PU1lywGYlS4CLwQWdUPUipXpT3TKX0nFbEo1z9LRq3IqWOQYOWc8WuIvlrOUCdc2GUid9gAa+3vRvUb9A0v//9u48OqoqT+D491dZyUJISAjpgIBssskyQREZRUVAbbTdWjho2zaKzFHcxvWMtjo6trZLq4zHEXFBm1YcxZaDINpAOzYtW5BVRFlsdogIIUAgS/3mj3cjRViMdKpeUu/3OadO3lbv/d7l8atb9726FyA5MXQo4YlQ1GcUH2/cwsldLj3mvvIyU46Z9AEGXTWW8paX0TW5I5W5C1ihpWQmpHDTxqlMmfbEUd/z2dc7WLV0ASyd7P0gLMK8xe9TJUKHln0Z3HYwo9tMomz1w5Ru/A29WtdtUBgR4f4LJzCy5UBConzPCpq0+iPh1g8iiXfz9LvXMH/rfDbs2UBZRRkc2AN7vG8Cny0cz7jmGZyTV1S/SR8gMQWS00hLSrOkb+Ka3dw9itLy3WxKrKJ3lTf4defUbiyW5Xyxdi59Ogyg8mAZ65KqOK2yMLqBFI2C1CzofOK/FJWERE65/mXu3LaI0Z+MoWzzRXRudRorw/fy8HdvMmtyMTed9yiJ1QW0z8tg+txims2+DpK2siUcJmfDYlKHHfqAWLv54AJqVwAADwtJREFU75AI/bp7MZ3dKY8nZ6aQEBK6F9b9QzAhlMC9Q8bx1cbtbJ90AyLzmd0slyVJVUzcv5eJH3sDoiQgTNxeRocDlSTftZK/VPyV/IQwvx/8IinWbYIxJ8SqNUcxZ9VMVIROTb3h8gb28HpwnL7wVaqqw0yc+jgHQiHaZfeMbiBJqdD7aqiHRzGLWhYxd/hc8uVspq+A9jzGBWUpzN+/kqs+vJxbpgxizLNXsrT4am5po/yysIAhrQt5fv076I6vftjP9gNrSVToXuCVTdeCpuRmJNMpP5O05J9ejzildT5n3/0+Z3UdwUOl5dzZ/FamfbubO7Ymc3NZNk3C1byQlkF6uIwn3rqbTSkVDKctKUmW9I05UVbjP4rP180mUZW+Hc8D4IzeQzlp8V18VrGQ4mduo6T5LFqGE7jynDt8jvSnaZKUwkPDuvHnJZt54vJT2b//LHq+fgdbkpYxJ3UP89JWM48kLmjRjyHdhnP/h2/yZlYxpTN+w/7sG9n25SbSs0ppGc4hMeRdOqGQ8F+X9iA16Z/4cAolwLBn4aJnGBAKsSs3xHWz76GqPMRHlf2Zl7OJ6eUnMVv/RseKKi7rObKeSsSYYLLEfxSry1bRpaKCjt2858wlFOLSZkOZWDaDLS3m0KwaJgx5iTa5BT5H+tMN6prPIDewd3pKFiNu924a3xEO883WhWhCMp1b9gbgw5zmbNl+P1Oz/gG7noICgFTOye932D6HdGtZP8GFvC+g2QNugIrt7Cvoz4iKlvxu+a+4r4WSXg2PlOwip/vQ+jmeMQEV88QvIq2BN4B8QIHxqvpcrOM4nhIt5cyqRJLSmv2w7Porn2bEdzfy/mcP0rfjJbRpfcZx9tD4SChEp8LTD1t2+sk53PPFGMYXfk32V8+wLj2VVadezGU9fh3dYEIJMOhBsoBfAiv2D+Oj9TMYt20LbZp1g7Sc6B7fmDgX88c5RaQAKFDVxSKSCRQDv1DVY450HcvHOVWVPhN7cMGBLB4bMzcmx2yo1pXs5dynPyUvM4XQ/p3Mvr0/6bk/3u9NfasMV7K3Yi/Z334OGfnQ6ui/aTDGHK7BdNmgqluBrW66TERWAYXAMRN/LJVXlVMlQkpi/fwoqDFrl5tObkYyJWUHGdi5nS9JHyAplER2ajbYcIfG1Atfn+oRkbZAb2D+UdaNFpFFIrKopKR+uzk+nu17vGOlJ/705/PjjYhQ1MZrVhnctZ7a8Y0xvvMt8YtIBvAecJuq7qm9XlXHq2qRqhbl5eXFLK6tOzcAkJFStx8jxbuzOuWRkhhiUJcWfodijKknvjzVIyJJeEl/kqpO8SOGY9mxy+tPPrNJc58jaRiG923N+V3zycuMzbCSxpjoi3mNX7w+CV4BVqnqM7E+/o/5fs82AJqlW9MGeM/pW9I3Jr740dRzJnANcK6ILHGvBnPXrnTfDgByshrfM/rGGFMXfjzV8zegwXZyXnbAG6u2RU4bnyMxxpjosL56atl3cBchVfJzT/I7FGOMiQrrsqGWfdVlZBImvand3DXGxCdL/LWUh/eTAUg9Dk5ujDENiSX+Wsr1AGlqLWDGmPhlGa6WcipJU6vtG2PilyX+WvZJFU00+cc3NMaYRsoSfy37Q0qqpPodhjHGRI0l/giqyt4QNAml+x2KMcZEjSX+CLv376RahPTETL9DMcaYqLHEH2FLybcApCc3O/6GxhjTiFnij7CjpkvmVPvxljEmflnij7CzdAsAWemx6//fGGNizRJ/hF17twOQ0/RnPkdijDHRY4k/wp7ynQDkNWvlcyTGGBM9lvgj7Du4C4D8vHY+R2KMMdFjiT/Cvqo9JKqSn22DsBhj4pcl/gh7q3aTEVYSE62vHmNM/LLE71Qe3MvyxN20rWzqdyjGGBNVlvidD2aPY1dCiL4tBvsdijHGRJUlfuf/NkyjSVi5ZtDtfodijDFRZYkf+H53CYuTdtO9OofsTOuuwRgT32wELuCdGY9RmhDivDaX+B2KMcZEXeBr/FUVB5lX+jHZ1XDl2Tf7HY4xxkRdMGv8qvzpxQtJqj5IWvOeFDcJcUXmWSQnpvgdmTHGRF0gE//MT/6bp9I2UilC230zSE5MYuzQR/wOyxhjYiIwif+LL2fwwN/voV9GDxaWLSU9Adpn9aF472LOzuhHTlqO3yEaY0xMBCbxj5v7WzYnhZl8cBkkC7dkX8H1w37L3C1z6dOij9/hGWNMzAQi8X/6+assTD7A+ZWdKGrRn5LdX3P9zx9ARBhQOMDv8IwxJqbiP/Gr8tqy58lMUsYOe552+dblsjEm2OL+cc7Zc1+lOLWaf03oaUnfGGMIQOJ/a+VLpIeVsRf93u9QjDGmQfAl8YvIUBFZLSJrROTeaB1n4bKZLEjZT/9wO1rlFkbrMMYY06jEPPGLSALwAnAB0BUYISJdo3GsifN+RwJww6BHo7F7Y4xplPyo8Z8GrFHVdapaAbwNRKWTnNyUlpxX3YYubXpGY/fGGNMo+fFUTyGwMWJ+E3B6NA700LVvR2O3xhjTqDXYm7siMlpEFonIopKSEr/DMcaYuOFH4t8MtI6Yb+WWHUZVx6tqkaoW5eXlxSw4Y4yJd34k/oVARxFpJyLJwHBgqg9xGGNMIMW8jV9Vq0TkZmAmkAC8qqorYx2HMcYElS9dNqjqdGC6H8c2xpiga7A3d40xxkSHJX5jjAkYS/zGGBMwoqp+x/CjRKQE+McJvj0X+K4ew4kHViZHsjI5kpXJkRpbmbRR1SOeh28Uif+fISKLVLXI7zgaEiuTI1mZHMnK5EjxUibW1GOMMQFjid8YYwImCIl/vN8BNEBWJkeyMjmSlcmR4qJM4r6N3xhjzOGCUOM3xhgTwRK/McYETNwm/liN69vQiEhrEZkjIl+KyEoRudUtzxGRT0TkG/c32y0XEXneldMyEenj7xlEj4gkiMgXIjLNzbcTkfnu3Ce73mIRkRQ3v8atb+tn3NEkIs1E5F0R+UpEVonIGUG/VkTkdvd/Z4WIvCUiqfF2rcRl4o/luL4NUBXw76raFegH3OTO/V5glqp2BGa5efDKqKN7jQZejH3IMXMrsCpi/gngD6raAdgFjHLLRwG73PI/uO3i1XPAR6p6CtATr3wCe62ISCFwC1Ckqt3xehAeTrxdK6oady/gDGBmxPx9wH1+x+VTWXwAnA+sBgrcsgJgtZt+CRgRsf0P28XTC2/An1nAucA0QPB+gZlY+5rB6zL8DDed6LYTv88hCmWSBayvfW5BvlY4NDRsjvu3nwYMibdrJS5r/Bx9XN9Cn2Lxjfva2RuYD+Sr6la3ahuQ76aDUlbPAncDYTffHNitqlVuPvK8fygTt77UbR9v2gElwGuuCWyCiKQT4GtFVTcDTwEbgK14//bFxNm1Eq+JP/BEJAN4D7hNVfdErlOvehKY53hF5OfADlUt9juWBiYR6AO8qKq9gX0catYBAnmtZAOX4H0o/gxIB4b6GlQUxGvir9O4vvFKRJLwkv4kVZ3iFm8XkQK3vgDY4ZYHoazOBC4WkW+Bt/Gae54DmolIzWBEkef9Q5m49VnAzlgGHCObgE2qOt/Nv4v3QRDka2UQsF5VS1S1EpiCd/3E1bUSr4k/sOP6iogArwCrVPWZiFVTgWvd9LV4bf81y3/lntjoB5RGfM2PC6p6n6q2UtW2eNfCbFUdCcwBrnCb1S6TmrK6wm0fd7VeVd0GbBSRzm7RecCXBPhawWvi6Sciae7/Uk2ZxNe14vdNhijepLkQ+BpYC/yH3/HE8LwH4H01XwYsca8L8dodZwHfAH8Bctz2gvcE1FpgOd7TDL6fRxTLZyAwzU2fDCwA1gD/C6S45alufo1bf7LfcUexPHoBi9z18mcgO+jXCvAw8BWwAngTSIm3a8W6bDDGmICJ16YeY4wxx2CJ3xhjAsYSvzHGBIwlfmOMCRhL/MYYEzCW+E2DJiIqIk9HzN8pIg/V075fF5ErfnzLOu8vS0TecD01rnXTWRHrn3S9Pj5Z632/FpES123CNyIyU0T611dcxtRmid80dAeBy0Qk1+9AIkX8ijPSK8A6Ve2gqu3xOkCbELF+NHCqqt51lPdOVtXe6vWI+TgwRUS61HvgxmCJ3zR8VXjjnN5ee0XtGruI7HV/B4rIpyLygYisE5HHRWSkiCwQkeUi0j5iN4NEZJGIfO369Knpt/9JEVno+p2/MWK/n4nIVLxfc0bG0gH4F+CRiMX/CRSJSHv3ngygWESuOt4Jq+ocd86j3b5vcLEsFZH33K9KM0VkveueAxFpWjMvIreINx7DMhF5uy6FbILFEr9pDF4ARkY2m9RBT2AM0AW4Buikqqfh1cDHRmzXFjgNuAj4HxFJxetjvVRV+wJ9gRtEpJ3bvg9wq6p2qnW8rsASVa2uWeCmlwDdVPVioFxVe6nq5DrEvxg4xU1PUdW+qlrTX/4oVS0D/uriBq8riinq9S9zL9BbVU91ZWDMYSzxmwZPvd5F38AbIKOuFqrqVlU9iNfFwMdu+XK8ZF/jHVUNq+o3wDq8ZDsYr0+aJXhdWjfHG3wEYIGqrj/hk6k7iZju7r5pLAdGAt3c8gnAdW76OuA1N70MmCQiV+N9YzLmMJb4TWPxLF5NPD1iWRXuGhaREJAcse5gxHQ4Yj6M1x1xjdp9lihe0h3raue9VLWdqtZ8cOw7RnxfAr1cHETE1ItazUJ11JtDo4W9Dtysqj3w+pFJBVDVuUBbERkIJKjqCrf9RXjfkvoAC49xP8IEmCV+0yio6vfAOxwa8g7gW7x2dYCLgaQT2PWVIhJy7f4n440qNRP4t4j2805ugJLjxbcG+AK4P2Lx/cBit67ORORsvPb9l92iTGCri2dkrc3fAP6Eq+27D5vW7j7BPXjdBGf8lOOb+Gc1AdOYPA3cHDH/MvCBiCwFPuLYtfHj2YDXq2JTYIyqHhCRCXjNQYtd17wlwC/qsK9RwDgRWevmP+fwD6rjuUpEBgBpeE8DXa6qNTX+B/CanErc38yI900CHgXecvMJwB/d/RABnlfV3XWMwQSE9c5pTCPmnmq6RFWv8TsW03hYjd+YRkpExgEX4I23YEydWY3fGGMCxm7uGmNMwFjiN8aYgLHEb4wxAWOJ3xhjAsYSvzHGBMz/A7b0qC+7U6foAAAAAElFTkSuQmCC\n"
+          },
+          "metadata": {
+            "needs_background": "light"
+          }
+        }
+      ],
+      "source": [
+        "plt.title('Regret As a Function of Number of Days')\n",
+        "plt.plot(days, regrets_basis, label='First Extension')\n",
+        "plt.plot(days, regrets_extended, label='Basis')\n",
+        "plt.plot(days, regrets_extended2, label ='Second Exetnsion')\n",
+        "plt.xlabel('Number Of Days')\n",
+        "plt.legend()\n",
+        "plt.ylabel('Regret')\n",
+        "plt.show()"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "name": "Exp3 and it's expansions.ipynb",
+      "provenance": [],
+      "authorship_tag": "ABX9TyMOqOukAo49HmM64G15RJuy",
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file