PH-LSVI.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "from tqdm.notebook import tqdm\n",
    "import copy\n",
    "from scipy.stats import bernoulli\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Environment(object):\n",
    "    '''General RL environment'''\n",
    "\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "    def reset(self):\n",
    "        pass\n",
    "\n",
    "    def advance(self, action):\n",
    "        '''\n",
    "        Moves one step in the environment.\n",
    "        Args:\n",
    "            action\n",
    "        Returns:\n",
    "            reward - double - reward\n",
    "            newState - int - new state\n",
    "            pContinue - 0/1 - flag for end of the episode\n",
    "        '''\n",
    "        return 0, 0, 0\n",
    "\n",
    "\n",
    "def make_riverSwim(epLen=20, nState=5):\n",
    "    '''\n",
    "    Makes the benchmark RiverSwim MDP code by Ian Osband.\n",
    "    Args:\n",
    "        NULL - works for default implementation\n",
    "    Returns:\n",
    "        riverSwim - Tabular MDP environment '''\n",
    "    nAction = 2\n",
    "    R_true = {}\n",
    "    P_true = {}\n",
    "    states = {}\n",
    "    for s in range(nState):\n",
    "        states[(s)] = 0.0\n",
    "        for a in range(nAction):\n",
    "            R_true[s, a] = (0, 0)\n",
    "            P_true[s, a] = np.zeros(nState)\n",
    "\n",
    "    # Rewards\n",
    "    R_true[0, 0] = (5/1000, 0)\n",
    "    R_true[nState - 1, 1] = (1, 0)\n",
    "\n",
    "    # Transitions\n",
    "    for s in range(nState):\n",
    "        P_true[s, 0][max(0, s-1)] = 1.\n",
    "\n",
    "    for s in range(1, nState - 1):\n",
    "        P_true[s, 1][min(nState - 1, s + 1)] = 0.3\n",
    "        P_true[s, 1][s] = 0.6\n",
    "        P_true[s, 1][max(0, s-1)] = 0.1\n",
    "\n",
    "    P_true[0, 1][0] = 0.3\n",
    "    P_true[0, 1][1] = 0.7\n",
    "    P_true[nState - 1, 1][nState - 1] = 0.9\n",
    "    P_true[nState - 1, 1][nState - 2] = 0.1\n",
    "\n",
    "    riverSwim = TabularMDP(nState, nAction, epLen)\n",
    "    riverSwim.R = R_true\n",
    "    riverSwim.P = P_true\n",
    "    riverSwim.states = states\n",
    "    riverSwim.reset()\n",
    "\n",
    "    return riverSwim\n",
    "\n",
    "\n",
    "\n",
    "class TabularMDP(Environment):\n",
    "    '''\n",
    "    Tabular MDP\n",
    "    R - dict by (s,a) - each R[s,a] = (meanReward, sdReward)\n",
    "    P - dict by (s,a) - each P[s,a] = transition vector size S\n",
    "    '''\n",
    "\n",
    "    def __init__(self, nState, nAction, epLen):\n",
    "        '''\n",
    "        Initialize a tabular episodic MDP\n",
    "        Args:\n",
    "            nState  - int - number of states\n",
    "            nAction - int - number of actions\n",
    "            epLen   - int - episode length\n",
    "        Returns:\n",
    "            Environment object\n",
    "        '''\n",
    "\n",
    "        self.nState = nState\n",
    "        self.nAction = nAction\n",
    "        self.epLen = epLen\n",
    "\n",
    "        self.timestep = 0\n",
    "        self.state = 0\n",
    "\n",
    "        # Now initialize R and P\n",
    "        self.R = {}\n",
    "        self.P = {}\n",
    "        self.states = {}\n",
    "        for state in range(nState):\n",
    "            for action in range(nAction):\n",
    "                self.R[state, action] = (1, 1)\n",
    "                self.P[state, action] = np.ones(nState) / nState\n",
    "\n",
    "    def reset(self):\n",
    "        \"Resets the Environment\"\n",
    "        self.timestep = 0\n",
    "        self.state = 0\n",
    "\n",
    "    def advance(self,action):\n",
    "        '''\n",
    "        Move one step in the environment\n",
    "        Args:\n",
    "        action - int - chosen action\n",
    "        Returns:\n",
    "        reward - double - reward\n",
    "        newState - int - new state\n",
    "        episodeEnd - 0/1 - flag for end of the episode\n",
    "        '''\n",
    "        if self.R[self.state, action][1] < 1e-9:\n",
    "            # Hack for no noise\n",
    "            reward = self.R[self.state, action][0]\n",
    "        else:\n",
    "            reward = np.random.normal(loc=self.R[self.state, action][0],\n",
    "                                      scale=self.R[self.state, action][1])\n",
    "        #print(self.state, action, self.P[self.state, action])\n",
    "        newState = np.random.choice(self.nState, p=self.P[self.state, action])\n",
    "\n",
    "        # Update the environment\n",
    "        self.state = newState\n",
    "        self.timestep += 1\n",
    "\n",
    "        episodeEnd = 0\n",
    "        if self.timestep == self.epLen:\n",
    "            episodeEnd = 1\n",
    "            #newState = None\n",
    "            self.reset()\n",
    "\n",
    "        return reward, newState, episodeEnd\n",
    "\n",
    "    def argmax(self,b):\n",
    "        #print(b)\n",
    "        return np.random.choice(np.where(b == b.max())[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Opt_Policy(object):\n",
    "    '''\n",
    "    For Computing Q*, the optimal q_values. This code was written with RiverSwim in mind.\n",
    "    '''\n",
    "    def __init__(self,env):\n",
    "        self.env = env\n",
    "        self.Q = np.zeros((self.env.epLen+1,self.env.nState,self.env.nAction))\n",
    "        self.V = np.zeros((self.env.epLen+1,self.env.nState))\n",
    "    \n",
    "    def update(self):\n",
    "        Q = np.zeros((self.env.epLen + 1,self.env.nState,self.env.nAction))\n",
    "        V = np.zeros((self.env.epLen + 1,self.env.nState))\n",
    "        for h in range(self.env.epLen-1,-1,-1):\n",
    "            for s in range(self.env.nState):\n",
    "                for a in range(self.env.nAction):\n",
    "                    reward = env.R[s,a][0]\n",
    "                    '''\n",
    "                    for s_ in range(self.env.nState):\n",
    "                        #print(s,a,s_)\n",
    "                        reward += self.env.R[s,a,s_][0]*self.env.P[s,a][s_]\n",
    "                    '''\n",
    "                    p = env.P[s,a]\n",
    "                    Q[h,s,a] = reward + np.inner(p,V[h+1,:])\n",
    "                V[h,s] = max(Q[h,s,:])\n",
    "        self.Q = Q.copy()\n",
    "        self.V = V.copy()\n",
    "    \n",
    "    def act(self,s,h):\n",
    "        return env.argmax(self.Q[h,s,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LSVI_UCB(object):\n",
    "    def __init__(self,env,K,delta):\n",
    "        self.env = env\n",
    "        self.K = K\n",
    "        self.p = delta\n",
    "        self.d = self.env.nState * self.env.nAction\n",
    "        self.lam = 1.0\n",
    "        self.Lambda = {h: self.lam*np.identity(self.d) for h in range(self.env.epLen)}\n",
    "        self.L = {h: (self.lam)*np.identity(self.d) for h in range(self.env.epLen)}\n",
    "        self.Linv = {h: (1/self.lam)*np.identity(self.d) for h in range(self.env.epLen)}\n",
    "        self.w = {h: np.zeros(self.d) for h in range(self.env.epLen)}\n",
    "        self.Q = {(h,s,a): 0.0 for h in range(self.env.epLen+1) for s in self.env.states.keys() \\\n",
    "                   for a in range(self.env.nAction)}\n",
    "        self.features_state_action = {(s,a): np.zeros(self.d) for s in self.env.states.keys() \\\n",
    "                                      for a in range(self.env.nAction)}\n",
    "        self.createIdentity()\n",
    "        self.buffer = {h: [] for h in range(self.env.epLen)}\n",
    "        self.sums = {h: np.zeros(self.d) for h in range(self.env.epLen)}\n",
    "        self.c = 1.0\n",
    "        self.m_2 = np.sqrt(self.d) #choosing this is constant is very important, how to do so is not simple though...\n",
    "        \n",
    "    \n",
    "    def createIdentity(self):\n",
    "        '''\n",
    "            A function that creates the Identity Matrix for a Dictionary\n",
    "        '''\n",
    "        i = 0\n",
    "        for key in self.features_state_action.keys():\n",
    "            self.features_state_action[key][i] = 1\n",
    "            i += 1\n",
    "        j = 0\n",
    "    \n",
    "    def update_buffer(self,s,a,r,s_,h):\n",
    "        self.buffer[h].append((s,a,r,s_))\n",
    "    \n",
    "    def reset_buffer(self):\n",
    "        self.buffer = {h: [] for h in range(self.env.epLen)}\n",
    "    \n",
    "    def update(self):\n",
    "        \n",
    "        Q = {(h,s,a): 0.0 for h in range(self.env.epLen+1) for s in self.env.states.keys() \\\n",
    "                   for a in range(self.env.nAction)}\n",
    "        for h in range(self.env.epLen-1,-1,-1):\n",
    "            d = self.buffer[h]\n",
    "            s,a,r,s_ = d[0][0],d[0][1],d[0][2],d[0][3]\n",
    "            \n",
    "            self.L[h] = self.L[h] + np.outer(self.features_state_action[s,a],self.features_state_action[s,a])\n",
    "            \n",
    "            self.Linv[h] = self.Linv[h] - np.dot((np.outer(np.dot(self.Linv[h],self.features_state_action[s,a]) \\\n",
    "                 ,self.features_state_action[s,a])),self.Linv[h]) / \\\n",
    "                    (1 + np.dot(np.dot(self.features_state_action[s,a],self.Linv[h]),self.features_state_action[s,a]))\n",
    "            \n",
    "            self.sums[h] = self.sums[h] + self.features_state_action[s,a]*(env.R[s,a][0] + \\\n",
    "                                             max(np.array([Q[(h+1,s_,a)] for a in range(self.env.nAction)])))\n",
    "            \n",
    "            self.w[h] = np.matmul(self.Linv[h],self.sums[h])\n",
    "            for ss in self.env.states.keys():\n",
    "                for aa in range(env.nAction):\n",
    "                    feature = self.features_state_action[ss,aa]\n",
    "                    Q[h,ss,aa] = min(np.inner(self.w[h],feature) + self.Beta(h) \\\n",
    "                                    * np.sqrt(np.dot(np.dot(feature,self.Linv[h]),feature)),self.env.epLen)\n",
    "        self.Q = Q.copy()\n",
    "    \n",
    "    def act(self,s,h):\n",
    "        '''\n",
    "        A function that returns the argmax of Q given the state and timestep\n",
    "        '''\n",
    "        return self.env.argmax(np.array([self.Q[(h,s,a)] for a in range(self.env.nAction)]))\n",
    "                    \n",
    "    \n",
    "    def Beta(self,h):\n",
    "        '''\n",
    "        iota = np.log(2*self.d*self.K*self.env.epLen/self.p)\n",
    "        return self.c * self.d * (self.env.epLen-h)/2 * np.sqrt(iota)\n",
    "        '''\n",
    "        \n",
    "        first = self.m_2 * np.sqrt(self.lam)\n",
    "        second = np.sqrt(2*np.log(1/self.p) + np.log(np.linalg.det(self.L[h])/self.lam))\n",
    "        return first + second\n",
    "        \n",
    "    \n",
    "    def run(self):\n",
    "        print(\"LSVI-UCB\")\n",
    "        R = 0\n",
    "        Rvec = []\n",
    "        for k in tqdm(range(1,self.K+1)):\n",
    "            self.env.reset()\n",
    "            done = 0\n",
    "            while not done:\n",
    "                s = self.env.state\n",
    "                h = self.env.timestep\n",
    "                a = self.act(s,h)\n",
    "                r,s_,done = self.env.advance(a)\n",
    "                self.update_buffer(s,a,r,s_,h)\n",
    "                R += r\n",
    "            Rvec.append(R)\n",
    "            self.update()\n",
    "            self.reset_buffer()\n",
    "        return Rvec\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LSVI_PHE(object):\n",
    "    def __init__(self,env,K,M,sigma):\n",
    "        self.env = env\n",
    "        self.K = K\n",
    "        self.M = M\n",
    "        self.sigma = sigma\n",
    "        self.S = self.env.nState\n",
    "        self.A = self.env.nAction\n",
    "        self.H = self.env.epLen\n",
    "        self.d = self.S * self.A\n",
    "        self.Q = np.zeros((self.H+1,self.S,self.A)) \n",
    "        self.theta_tilde = np.zeros((self.H,self.M,self.d))\n",
    "        self.lam = 1.0\n",
    "        self.Sigma = np.zeros((self.H,self.d,self.d))\n",
    "        self.target = np.zeros((self.H,self.d))\n",
    "        for h in range(self.H):\n",
    "            self.Sigma[h] = self.lam * np.identity(self.d)\n",
    "        self.T = np.ones((self.H,self.d),dtype=int)\n",
    "        self.buffer = np.zeros((self.H,4),dtype=int)\n",
    "        self.b = np.zeros((self.K,self.H,4),dtype=int)\n",
    "        self.V = np.zeros((self.H,self.S,self.A))\n",
    "        self.phi = np.identity(self.d)\n",
    "        self.Z = np.zeros((self.H,self.M,self.d))\n",
    "        self.init_rand = np.zeros(self.d)\n",
    "        self.det = 0\n",
    "        \n",
    "        \n",
    "    \n",
    "    def act(self,s,h):\n",
    "        return self.env.argmax(self.Q[h,s,:])\n",
    "    \n",
    "    def init_perturb(self):\n",
    "        for s in range(self.S):\n",
    "            for a in range(self.A):\n",
    "                row = int(s*self.A + a)\n",
    "                self.init_rand = self.init_rand + self.phi[row,:]*np.random.normal(0.0,self.sigma**2)\n",
    "    \n",
    "    def update_buffer(self,s,a,r,s_,h,k):\n",
    "        '''\n",
    "        Stores all the data observed for use in LSVI\n",
    "        '''\n",
    "        if s_ == None:\n",
    "            s_ = -1\n",
    "        #This buffer is for the sample covariance matrix Sigma\n",
    "        self.buffer[h,0] = s\n",
    "        self.buffer[h,1] = a\n",
    "        self.buffer[h,2] = r\n",
    "        self.buffer[h,3] = s_\n",
    "        '''\n",
    "        #This buffer is for computing the targets in LSVI\n",
    "        self.b[k,h,0] = s\n",
    "        self.b[k,h,1] = a\n",
    "        self.b[k,h,2] = r\n",
    "        self.b[k,h,3] = s_\n",
    "        '''\n",
    "    '''\n",
    "    def get_Noise(self,h,k):\n",
    "        Z = np.zeros(self.d)\n",
    "        for i in range(k):\n",
    "            s,a = self.b[i,h,0], self.b[i,h,1]\n",
    "            row = int(s*self.A + a)\n",
    "            Z = Z + self.phi[row]*(np.random.normal(0.0,self.sigma**2))\n",
    "        return Z\n",
    "    '''\n",
    "    \n",
    "    def update(self,k):\n",
    "        #Step 4 of PH-RLSVI\n",
    "        for h in range(self.H-1,-1,-1):\n",
    "            #Gets data from the buffer for computing Sigma\n",
    "            s,a,r,s_ = self.buffer[h,0],self.buffer[h,1],self.buffer[h,2],self.buffer[h,3]\n",
    "            if self.buffer[h,3] == -1:\n",
    "                s_ = None\n",
    "            #print(s,a,r,s_)\n",
    "            \n",
    "            #For getting the feature associated with (s,a)\n",
    "            row = s*self.A + a\n",
    "            #self.T[h,s,a] = int(self.T[h,s,a] + 1)\n",
    "            self.T[h,row] = self.T[h,row] + 1\n",
    "            #Step 6: Iteratively updates Sigma \n",
    "            self.Sigma[h] = np.add(self.Sigma[h] , np.outer(self.phi[row,:],self.phi[row,:]))\n",
    "            \n",
    "            #For use in step 7: computes Sigma^(-1)\n",
    "            Sigma_inv = np.linalg.inv(self.Sigma[h])\n",
    "            \n",
    "            #Step 7: Computing theta_tilde\n",
    "            self.target[h] = np.add(self.target[h] , self.phi[row,:]*(r + max(self.Q[h+1,s_,:])))\n",
    "            \n",
    "            for m in range(self.M):\n",
    "                #self.Z[h,m,:] = self.Z[h,m,:] + self.phi[row,:]*np.random.normal(0.0,self.sigma**2)\n",
    "                #self.init_perturb()\n",
    "                Z = np.zeros(self.d)\n",
    "                for i in range(self.d):\n",
    "                    #Z = np.add(Z , self.phi[i,:]*np.sum(np.random.normal(0.0,self.sigma,size=self.T[h,i])))\n",
    "                    Z = np.add(Z , self.phi[i,:]*np.random.normal(0.0,np.sqrt(self.T[h,i])*self.sigma))\n",
    "                self.theta_tilde[h,m,:] = np.dot(1/self.sigma**2 * Sigma_inv,np.add(self.target[h],Z))\n",
    "\n",
    "\n",
    "\n",
    "            #Step 8: Compute Q_optimistic\n",
    "            for s_ in range(self.S):\n",
    "                for a_ in range(self.A):\n",
    "                    maxs = -9999999\n",
    "                    row = s_*self.A + a_\n",
    "\n",
    "                    #Iterates through all the theta_tilde's picking the optimistic one\n",
    "                    for m in range(self.M):\n",
    "                        temps = np.inner(self.phi[row,:],self.theta_tilde[h,m,:])\n",
    "                        if temps > maxs:\n",
    "                            maxs = temps\n",
    "                    #Computes Q_optimistic given the optimistic theta_tilde\n",
    "                    self.Q[h,s_,a_] = max(0,min(maxs,self.H-h))\n",
    "                \n",
    "             \n",
    "            \n",
    "    \n",
    "    \n",
    "    def run(self):\n",
    "        '''\n",
    "        This function runs the agent until episode K is reached\n",
    "        '''\n",
    "        print(\"PHE-LSVI\")\n",
    "        #Stores the rewards for plotting\n",
    "        Rvec = []\n",
    "        R = 0\n",
    "        for k in tqdm(range(self.K)):\n",
    "            self.env.reset()\n",
    "            done = 0\n",
    "            while not done:\n",
    "                s = self.env.state\n",
    "                h = self.env.timestep\n",
    "                a = self.act(s,h)\n",
    "                r,s_,done = self.env.advance(a)\n",
    "                self.update_buffer(s,a,r,s_,h,k)\n",
    "                R += r\n",
    "                \n",
    "            #updates Q\n",
    "            self.update(k)\n",
    "            Rvec.append(R)\n",
    "        return Rvec\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RLSVI(object):\n",
    "    def __init__(self,env,K,M,sigma):\n",
    "        self.env = env\n",
    "        self.K = K\n",
    "        self.M = M\n",
    "        self.sigma = sigma\n",
    "        self.S = self.env.nState\n",
    "        self.A = self.env.nAction\n",
    "        self.H = self.env.epLen\n",
    "        self.d = self.S * self.A\n",
    "        self.Q = np.zeros((self.H+1,self.S,self.A)) \n",
    "        self.theta_tilde = np.zeros((self.H,self.d))\n",
    "        self.lam = 1.0\n",
    "        self.Sigma = np.zeros((self.H,self.d,self.d))\n",
    "        self.target = np.zeros((self.H,self.d))\n",
    "        for h in range(self.H):\n",
    "            self.Sigma[h] = self.lam * np.identity(self.d)\n",
    "        self.T = np.ones((self.H,self.d),dtype=int)\n",
    "        self.buffer = np.zeros((self.H,4),dtype=int)\n",
    "        self.b = np.zeros((self.K,self.H,4),dtype=int)\n",
    "        self.V = np.zeros((self.H,self.S,self.A))\n",
    "        self.phi = np.identity(self.d)\n",
    "        \n",
    "        \n",
    "    \n",
    "    def act(self,s,h):\n",
    "        return self.env.argmax(self.Q[h,s,:])\n",
    "    \n",
    "    \n",
    "    \n",
    "    def update_buffer(self,s,a,r,s_,h,k):\n",
    "        '''\n",
    "        Stores all the data observed for use in LSVI\n",
    "        '''\n",
    "        if s_ == None:\n",
    "            s_ = -1\n",
    "        #This buffer is for the sample covariance matrix Sigma\n",
    "        self.buffer[h,0] = s\n",
    "        self.buffer[h,1] = a\n",
    "        self.buffer[h,2] = r\n",
    "        self.buffer[h,3] = s_\n",
    "\n",
    "    \n",
    "    \n",
    "    def update(self,k):\n",
    "        #Step 4 of PH-RLSVI\n",
    "        for h in range(self.H-1,-1,-1):\n",
    "            #Gets data from the buffer for computing Sigma\n",
    "            s,a,r,s_ = self.buffer[h,0],self.buffer[h,1],self.buffer[h,2],self.buffer[h,3]\n",
    "            if self.buffer[h,3] == -1:\n",
    "                s_ = None\n",
    "            #print(s,a,r,s_)\n",
    "            \n",
    "            #For getting the feature associated with (s,a)\n",
    "            row = s*self.A + a\n",
    "            #Step 6: Iteratively updates Sigma \n",
    "            self.Sigma[h] = np.add(self.Sigma[h] , np.outer(self.phi[row,:],self.phi[row,:]))\n",
    "            \n",
    "            #For use in step 7: computes Sigma^(-1)\n",
    "            Sigma_inv = np.linalg.inv(self.Sigma[h])\n",
    "            \n",
    "            #Step 7: Computing theta_tilde\n",
    "            self.target[h] = np.add(self.target[h] , self.phi[row,:]*(r + max(self.Q[h+1,s_,:])))\n",
    "            \n",
    "            temp = np.dot(Sigma_inv,self.target[h])\n",
    "            \n",
    "            self.theta_tilde[h,:] = np.random.multivariate_normal(temp,Sigma_inv)\n",
    "            \n",
    "            for s_ in range(self.S):\n",
    "                for a_ in range(self.A):\n",
    "                    row = s_*self.A + a_\n",
    "                    Q = np.inner(self.phi[row,:],self.theta_tilde[h,:])\n",
    "                    self.Q[h,s_,a_] = max(0,min(Q,self.H-h))\n",
    "                \n",
    "             \n",
    "            \n",
    "    \n",
    "    \n",
    "    def run(self):\n",
    "        '''\n",
    "        This function runs the agent until episode K is reached\n",
    "        '''\n",
    "        print(\"RLSVI\")\n",
    "        #Stores the rewards for plotting\n",
    "        Rvec = []\n",
    "        R = 0\n",
    "        for k in tqdm(range(self.K)):\n",
    "            self.env.reset()\n",
    "            done = 0\n",
    "            while not done:\n",
    "                s = self.env.state\n",
    "                h = self.env.timestep\n",
    "                a = self.act(s,h)\n",
    "                r,s_,done = self.env.advance(a)\n",
    "                self.update_buffer(s,a,r,s_,h,k)\n",
    "                R += r\n",
    "                \n",
    "            #updates Q\n",
    "            self.update(k)\n",
    "            Rvec.append(R)\n",
    "        return Rvec\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "02f5f3825f3c400fb266a403c8acf624",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=10.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RLSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f93e0f8f37404b8bb6d4216f9221a147",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "LSVI-UCB\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4e3d5f6516544e0c8f3bfbe597bf154d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PHE-LSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "03c473639d9c4dd8a2fc2e746c6b8839",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "RLSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "40928c940b374d87ae9f873f32093283",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "LSVI-UCB\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2c48599bb0344fcf9a1285523e63c2bd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PHE-LSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "035b3ae15be040e5adf6f0e4c28941da",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "RLSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "18a5a197d58d4cc19f6865701b343640",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "LSVI-UCB\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "26385067773c4a8eb2a65a3c5518335c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PHE-LSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "503807506f4e40579b485d40fe96926a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "RLSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6fe9e12227de4418a6379270b8d77e52",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "LSVI-UCB\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "36fba3e3ee2e4906ab9c593f02b338e2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PHE-LSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bebed441590748738c735da964586bce",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "RLSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3b12250b85624d9ca5febb6550836d34",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "LSVI-UCB\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d5ee59b29a0f40d798883c3a5995b942",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PHE-LSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a2357d1f932242a39c9791522d8079c7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "RLSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0ccbed6eb7544385969aa7bad2adef53",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "LSVI-UCB\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0800fcee9ddb470a99fd0cb2f459dd7a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PHE-LSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0e1da90d6d304fa08674c3dacc0bce60",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "RLSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0ccff7bce3e346d1a8e6fa6db3fd3c1f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "LSVI-UCB\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "337321533fe34b3a972b55a07a4e3fc0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PHE-LSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c4eb99817e7c44229a3ce160365cc5b8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "RLSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "870bf1a10db6416b9f9ebd4407a52a6a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "LSVI-UCB\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "46932d4a92994fef9e37ab46fe787b5a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PHE-LSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "53396fb1bb2c46ec9d8992ec39f880e7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "RLSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2645d461e5224cdd89cdb66d490ea523",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "LSVI-UCB\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dffdb58c7278425384eec539833e367d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PHE-LSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a5c38e8d687540daa94a30ab3b621ccb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "RLSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a702fb695de8483a841ce09e12d51171",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "LSVI-UCB\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6087744518d84a32a7b2daec1d13cfca",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "PHE-LSVI\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d74a5207d31041e1911090b9dc1ad36a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=20000.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "K = 20000\n",
    "S = 5\n",
    "H = 17\n",
    "env = make_riverSwim(epLen = H,nState = S)\n",
    "M = 1\n",
    "runs = 10\n",
    "\n",
    "R_PHE = np.zeros((runs,K))\n",
    "R_UCB = np.zeros((runs,K))\n",
    "R_RAN = np.zeros((runs,K))\n",
    "\n",
    "\n",
    "opt = Opt_Policy(env)\n",
    "opt.update()\n",
    "Opt_Reward = opt.V[0,0]*range(1,K+1)\n",
    "for r in tqdm(range(runs)):\n",
    "    \n",
    "    agent2 = RLSVI(env,K,M,1.0)\n",
    "    R_RAN[r,:] = agent2.run()\n",
    "    \n",
    "    agent1 = LSVI_UCB(env,K,1.0/K)\n",
    "    R_UCB[r,:] = agent1.run()\n",
    "    \n",
    "    agent3 = LSVI_PHE(env,K,M,1.0)\n",
    "    R_PHE[r,:] = agent3.run()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZUAAAEWCAYAAACufwpNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi40LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcv7US4rQAAIABJREFUeJzs3Xd4VFX6wPHvS3oPCQEiIXQBQUEJgh0VERQF3NW17Aquu7h2XfuCNNG1oFgWuytlVWxr2f2JiCjoCoiAiBSRKoROeq/v7497A0MMyQCZTMr7eZ55Zubcc++cmUzmvafcc0RVMcYYY2pDM38XwBhjTONhQcUYY0ytsaBijDGm1lhQMcYYU2ssqBhjjKk1FlSMMcbUGgsqVRCRF0XkQX+X43BE5BoR+czf5TDGmMqaZFARka0iUiAiuSKyW0Smi0hkxXZV/YuqPuSj1+4hIp+JSIaIZIrIchG56EiOoapvqOogX5TvSIjIKBH5n7/LcTgi8pCI/CgipSIyodK2v7l//4pbgYiUi0gLH5QjSUTeF5H9IpLllmmUu629iKiIBB7B8baKyMDaLqeXr1vg8Zkd9YmN+573eL5vEQkUkb0iUusXz1X3XTiKY1X7+1GfiUiwiLznvgcVkQGVtouIPCYiae7tcRGRI3mNJhlUXJeoaiTQGzgZeMCXL+b+sZoB/wHmAa2AlsBtQLYvX7sJ2wjcC/xf5Q2q+oiqRlbcgMeABaq63wflmAVsB9oB8cC1wB4fvE5duMTjczvWE5tMYIjH84uAjGM85uEc9rtwlOr096OW/Q/4PbC7im2jgeFAL+AkYChww5EcvCkHFQBUdTcwF+fLAYB75jHZfbxORIZ6bAt0zzhPcZ/3F5FFbq3jB8/ILyILRORhEfkGyAdOAToAr6hqsXv7RlX/5+ZfKCK/cR+f6Z5JXOQ+HygiK93Hh9QQ3Hw3icgGEclxz8o6ichiEckWkXdEJPhwn4GI/NF9nxkiMldE2lU69m0istl930+4wbFaIhIjIq+JyC4R2SEik0UkwLP8IjLFfc0tIjKkpmMeKVWdoapzgJwayirAH4AZR/M6IjJARFJF5C73THuXiFznkaUvMF1V81S1VFW/d8sF8JV7n+me+Z7m/u2+cM8U94vIGyIS677WLCAZ+I+b/143/bDfw3psFk6ArXAtMNMXL+Ttd+EojlvV78cCEfmTx/Oq/l//4v6/ZojItIragIh0dn8Hsty//du1XN5iVX3a/c0pqyLLSOBJVU1V1R3Ak8CoI3mNJh9URCQJ52xp42GyvAVc5fH8QmC/qq4QkTY4Zz6TgTjgbuB9EUnwyP8HnOgfBfzgvs6/RGS4iLSq9FoLgQHu47OBzcA5Hs8XVvNWBgN9gP44Z2QvA9cAbYGeld7DASIyHPgbcBmQAHztvmdPI4AUnKA4DPhjNeWoMAMoBTrjnMkNAv7ksb0fsB5oATwOvHa4araI/Nf9sazq9l8vylKTs3Bqju8fwzFaAzFAG+B6YJqINHe3LXGfXykiyZX2O9u9j3XP/hcDAvwdOA7ojvM3nACgqn8AtnGwxvC4l9/DA47x83xDRPaJ04Tby8vP5nA+BM4WkVg3aJ4FfFTdDnXwXTgiXvx+HM5QnJONXsAVOL8rAA8BnwHNgSTguWpe+3CfQ6aI3H+k78XVA+d3qsIPbpr3VLXJ3YCtQC7OWYsC83H+qSu2Twcmu487u/nC3edvAOPcx/cBsyodey4w0n28AJhUaXsS8A9gE1COc6baxd12PrDKffwpzo/wEvf5QuAy9/Eo4H8ex1TgDI/ny4H7PJ4/CTx9mM9iDnC9x/NmOLWqdh7HHuyx/SZgflXl8MjTCigCwjzSrgK+9Nhvo8e2cPd1Wvvo7/0vYEI121/DqUkc7fEHAAVAoEfaXqC/+7g58CiwBufscCXQ193W3n3vgdUcfzjwfaXv70CP59V+D2vxczwDCHP/Xg/gNJ/EHuWx1P3fehWneeUvwCtumvrie+DNd8HLY2yl+t+PBcCfPJ5X9f96psfzd4D73cczcU4Ik3z1GXi8biowoFJaGdDN43kXt7zi7XGbck1luKpG4fwgdMM5Y/4VVd0IrAMuEZFw4FLgTXdzO+ByzzME4Ewg0eMQ2ysdL1VVb1HVTu7+eRys8i8GjndrML3d9LbidB6fysGmkqp4ttEXVPH8cB2J7YBnPMqfjnOm3OYw7+EXnDPo6rQDgoBdHsd9CacPqcKB9lxVzXcf1nlnp4iEAZdzlE1fHtJUtdTjeT7u+1HVDFW9X1V74ATclcCH1dTMWorIbLfZMBvnh7C6AQTefA+PmTpNtQWqmq+qf8fpEznrGA87E6fZy2dNXz7i1e9HNTz7Mw58V3BaGQRYKiJrRMSbVoHalAtEezyPBnLVjTDeaMpBBQBVXYhTM5lSTbaKJrBhwFo30IDzYztLVWM9bhGq+qjnS1Tz2tuBaTjNUxU/rsuB24HVqloMLAL+CmxS33QibwduqPQewlR1kUeeth6Pk4GdXhyzCGjhccxo90f1iInIHDl0pJbnbU7NR6jWZTiBdMExHscr7t9wCk5gjqPq78ff3fSTVDUap1PVMwBV3seb7+EBtfh5aqVyHY2vcYJfK5wO5Gr5+LtwxA7z+5GHU5ur0PoIjrdbVf+sqsfh1OCeF5HOVeWt5nPIFZG/Hfm7AZzatGezZi83zWtNPqi4ngYuEJHeh9k+G6dP4EYO1lLAOYO8REQuFJEAEQkVp9M2qaqDiEhzEZnodsY1c2sgf8Rpc6+wELiFg/0nCyo9r20vAg+ISA+3jDEicnmlPPe4ZW+LE/A8Ow/Ffd8Hbqq6C6dd+EkRiXbfaycROYejoKpD1GOkVqXbYTv4RSRIREJxvueBbvkCKmUbCcys6UxMnMEb04+m/OIM0ewpziCPKJzv0UZVTQP24TSDdvTYJQrnjDHT7S+5p9Ih91TKf0Tfw6P5PEUkWUTOEGdIaqiI3INzdv7NYfKPEpGtNX027ud+CXCpN2fDPv4uVOQdIEc2rLny78dK4DIRCXcDwvXeHkhELvf4u2XgBO6qOtSp5nOIVNVHqnmNEPezAKj4e1acHMwE/ioibUTkOOAunKDpNQsqgKruw/kwq7zg0f2RXAycjscPqlvTGIbT0b0P54zxHg7/uRbjtKF/jjOMeDXOGf0ojzwLcX5UvjrM81qlqh/gDKed7Ta1rObQYZ7gdJ4ux/ln+T+cPogKp+M0rx24iXPtwbVAMLAW55/jPWq5OcYLr7hlugoY4z7+Q8VG9wf7PLxrdmnLYX5AvRAOfIDTXLQZp7nqUjhQO30Y+MZtuuoPTMQZFJGF83n/u9Lx/g6MdfPffRTfw6MRBbyA87fcgTMwZIgbGKvi9eelqmtU9YjOho9Ctd+FStri/L97pYrfj6k4/+t7cJpV3ziCcvYFvhWRXOBj4HZV3XIE+3tjPc77b4PT91aA850Ep5n6P8CPOL8F/+emeU2OoKnMNEHuGVsXjya/Jkec4dg/4DRHlfi7PA2BOBdG3q6q6/xdliMlIq8C76rqXH+XpSGyoGKqZUHFGHMkrPnLGGNMrbGaijHGmFpjNRVjjDG1xuuZURuLFi1aaPv27f1dDGOMaTCWL1++X1WrnPansiYXVNq3b8+yZcv8XQxjjGkwROQXb/Na85cxxphaY0HFGGNMrbGgYowxptY0uT6VqpSUlJCamkphYaG/i+IToaGhJCUlERQU5O+iGGMaOQsqQGpqKlFRUbRv357DzEbeYKkqaWlppKam0qFDB38XxxjTyFnzF1BYWEh8fHyjCygAIkJ8fHyjrYUZY+oXCyquxhhQKjTm92aMqV8sqBhjTCO3fM9yXl/9ep28lgWVeiIgIIDevXvTs2dPLr/8cvLznRV2IyMPXWF3+vTp3HLLLQBMmDCBNm3a0Lt37wO3zMzMOi+7MaZ+yirKYsKiCYz6dBTvrH+H/JL8mnc6Rj4LKiLSVURWetyyReQOEYkTkXkissG9b+7mFxF5VkQ2isgqETnF41gj3fwbRGSkR3ofEfnR3edZacDtPGFhYaxcuZLVq1cTHBzMiy++6NV+d955JytXrjxwi42N9XFJjTH1nary383/5dIPL+XDjR9yXc/reP/S9wkPCq9552Pks6CiqutVtbeq9gb6APk4q9/dD8xX1S7AfPc5OKsNdnFvo3FWmUNE4oDxQD/gVGB8RSBy84z22G+wr95PXTrrrLPYuNGWLzHGHLlt2dsYPW80D3z9AEmRSbw99G3+2uevdRJQoO6GFJ8PbFLVX0RkGDDATZ+Bswb7fTjLoVasFb5ERGJFJNHNO09V0wFEZB4wWEQWANGquthNnwkMB+YcS0En/mcNa3dmH8shfuWE46IZf0kPr/KWlpYyZ84cBg924mNBQQG9e/c+sD09PZ1LL730wPOpU6fyr3/9C4DmzZvz5Zdf1mLJjTENRUlZCa+veZ2XfniJ4IBgxvYby2+P/y0BzQLqtBx1FVSuBN5yH7dy13xHVXeJSEs3vQ3O2toVUt206tJTq0j/FREZjVOjITk5+ZjeiK94Bo+zzjqL66+/HjjYLFZh+vTph0yIeeedd3L33XfXbWGNMfXKij0rmLR4EpuyNjGo3SDuO/U+Woa3rHlHH/B5UHHX974UeKCmrFWk6VGk/zpR9WXgZYCUlJRqVyXztkZR2yoHD2OMqUlWURZTl0/l/Q3vc1zEcUw7fxpnJ53t1zLVRU1lCLBCVfe4z/eISKJbS0kE9rrpqUBbj/2SgJ1u+oBK6Qvc9KQq8htjTKOmqszZMofHvnuMrKIsRvUYxY29bqyzfpPq1MWQ4qs42PQF8DFQMYJrJPCRR/q17iiw/kCW20w2FxgkIs3dDvpBwFx3W46I9HdHfV3rcawmY+rUqYcMKd66dau/i2SM8aHt2du58fMbue/r+0iMSGT20NnclXJXvQgo4OM16kUkHKc/pKOqZrlp8cA7QDKwDbhcVdPdwPAPnBFc+cB1qrrM3eePwN/cwz6sqq+76SnAdCAMp4P+Vq3hDaWkpGjlRbrWrVtH9+7dj/0N12NN4T0a05iVlJUwfc10Xlr1EoHNArn15Fu5suuVddIRLyLLVTXFm7w+bf5S1XwgvlJaGs5osMp5Fbj5MMf5J/DPKtKXAT1rpbDGGFNPrdy7komLJ7IxcyMXtLuA+/reR6uIVv4uVpVslmJjjKmnsoqyeGbFM7z787u0jmjNc+c9x4C2A/xdrGpZUDHGmHpGVZm7dS6PLn2UjKIM/nDCH7i5981EBEX4u2g1sqBijDH1SGpOKpO/ncw3O77hhPgTeH7g85wQf4K/i+U1CyrGGFMPlJSXMGvtLF5Y+QLNpBn39b2Pq7pdVedXxB8rCyrGGONnq/atYtLiSazPWM+AtgMY028MrSNa+7tYR8Wmvq8nPKe+v+SSS341hf3UqVMJDQ0lKyvrQNqCBQsQEf7zn/8cSBs6dCgLFiyoq2IbY45BTnEODy95mN9/8nsyijKYOmAqz577bIMNKGBBpd7wnPo+Li6OadOmHbL9rbfeom/fvnzwwQeHpCclJfHwww/XZVGNMcdIVfls62cM+3AYb69/m6u7X81Hwz5iYLuBDX6lVgsq9dBpp53Gjh07DjzftGkTubm5TJ48mbfeeuuQvL169SImJoZ58+bVdTGNMUdhV+4ubv3iVu5aeBctwlrw5sVvcv+p9xMZHFnzzg2A9alUNud+2P1j7R6z9Ykw5FGvspaVlTF//vwDsxSDU0u56qqrOOuss1i/fj179+6lZcuDM5COHTuWsWPHcsEFF9RuuY0xtaasvIzZ62fz7IpnUZS7U+7mmu7XENiscf0MW02lnqiY+j4+Pp709PRDAsTs2bO58soradasGZdddhnvvvvuIfueddZZAHz99dd1WmZjjHfWpa3jmk+u4dGlj3Jyq5P5YNgHjOwxstEFFLCayq95WaOobRV9KllZWQwdOpRp06Zx2223sWrVKjZs2HAgyBQXF9OxY0duvvnQGW3GjBnDww8/TGCg/UmNqS/yS/J54YcXmLV2FrEhsTxx9hNc2P7CBt9vUh2rqdQzMTExPPvss0yZMoWSkhLeeustJkyYwNatW9m6dSs7d+5kx44d/PLLL4fsN2jQIDIyMvjhhx/8VHJjjKevUr9ixEcjmL5mOiO6jOCj4R8xuMPgRh1QwIJKvXTyySfTq1cvZs+ezezZsxkxYsQh20eMGMHs2bN/td+YMWNITU39Vboxpu7sydvDXxf8lZvn30xYYBgzBs9g/GnjiQmJ8XfR6oRPp76vj2zqe2OML5SVl/HOz+/wzIpnKC0vZfRJo7mux3UEBQT5u2jHrN5MfW+MMU3B+vT1TFo8iVX7V9E/sT8P9n+Q5OhkfxfLLyyoGGPMUSoqK+LFH15k+urpRAVH8ciZjzC049BG329SHQsqxhhzFJbtXsbExRPZmr2VYZ2GcXfK3cSGxvq7WH5nQcUYY45AVlEWU5dP5f0N79Mmsg0vDXyJ09uc7u9i1Rs+Hf0lIrEi8p6I/CQi60TkNBGJE5F5IrLBvW/u5hUReVZENorIKhE5xeM4I938G0RkpEd6HxH50d3nWWnKdU5jjE+pKnO2zOHSDy/lw40fMqrHKP596b8toFTi6yHFzwCfqmo3oBewDrgfmK+qXYD57nOAIUAX9zYaeAFAROKA8UA/4FRgfEUgcvOM9thvsI/fjzGmCdqRu4Mb59/IvV/dS2JEIrOHzuaulLsIDwr3d9HqHZ8FFRGJBs4GXgNQ1WJVzQSGATPcbDOA4e7jYcBMdSwBYkUkEbgQmKeq6aqaAcwDBrvbolV1sTrjomd6HKtB2bp1Kz179jwkbcKECUyZMgWAKVOm0K1bN3r27EmvXr2YOXMmAAMGDKBr16707t2b7t278/LLL9d52Y1pzErLS5m+ejojPhrBij0ruK/vfbxx0Rt0i+vm76LVW77sU+kI7ANeF5FewHLgdqCVqu4CUNVdIlIxM2IbYLvH/qluWnXpqVWk/4qIjMap0ZCc3LCG+b344ovMmzePpUuXEh0dTVZWFh9++OGB7W+88QYpKSmkp6fTqVMnRo0aRXBwsB9LbEzjsGb/GiYunsi69HUMSBrA3/r9jcTIRH8Xq97zZVAJBE4BblXVb0XkGQ42dVWlqv4QPYr0Xyeqvgy8DM7Fj9UVur555JFH+PLLL4mOjgacaVxGjhz5q3y5ublEREQQENCwlh41pr7JLs7muRXP8fb6t2kR1oKnBjzFwOSGv85JXfFlUEkFUlX1W/f5ezhBZY+IJLq1lERgr0f+th77JwE73fQBldIXuOlJVeQ/Jo8tfYyf0n861sMcoltcN+479b4j3q+goICcnBw6dep02DzXXHMNISEhbNiwgaefftqCijFHSVWZ+8tcHlv6GOmF6VzV7SpuOfkWooKj/F20BsVnfSqquhvYLiJd3aTzgbXAx0DFqfZI4CP38cfAte4osP5AlttMNhcYJCLN3Q76QcBcd1uOiPR3R31d63GsBuVwZ0Dl5eU1nh298cYbrFq1im3btjFlypRfTTRpjKnZztyd3PLFLdyz8B4SwhJ486I3eaDfAxZQjoKvr1O5FXhDRIKBzcB1OIHsHRG5HtgGXO7m/QS4CNgI5Lt5UdV0EXkI+M7NN0lV093HNwLTgTBgjns7JkdTozhW8fHxZGRkHJKWnp5Onz59iIiIYPPmzXTs2LHaYyQkJHDKKafw7bff0q5dO18W15hGo7S8lDfXvck/Vv4DgHtS7uHq7lc3ynVO6opPhxSr6kpVTVHVk1R1uKpmqGqaqp6vql3c+3Q3r6rqzaraSVVPVNVlHsf5p6p2dm+ve6QvU9We7j63aAOdHTMyMpLExETmz58POAHl008/5cwzz+SBBx7g5ptvJjs7G4Ds7OwqR3nl5+fz/fffV9tUZow5qGLhrCeWPUHf1n35cNiHXNvjWgsox8g+vXpi5syZ3Hzzzdx1110AjB8/nk6dOnHjjTeSm5tL3759CQoKIigo6EAecPpUwsLCKCoqYtSoUfTp08dfb8GYBiG/JJ/nVz7PrHWzaB7SnCfOeYIL2zXuhbPqkk19T9OYFr4pvEdjavJ16tdMXjKZnXk7+e3xv+WOU+5oMuucHAub+t4YYzzsL9jP40sfZ87WOXSM6cj0wdPp08pq9b5gQcUY02iVazkfbPiAJ5c/SWFpITf1vonre15PcIBdIOwrFlRcqtpo21SbWhOnMQCbszYzafEklu9ZTp9WfRh32jg6xlQ/itIcOwsqQGhoKGlpacTHxze6wKKqpKWlERoa6u+iGFMnisuKee3H13jlx1cIDQxl4ukTGd55OM3E1/PnGrCgAkBSUhKpqans27fP30XxidDQUJKSkmrOaEwDt3zPciYunsiWrC0M6TCEe/veS4uwFv4uVpNiQQUICgqiQ4cO/i6GMeYoVV4464WBL3BmmzP9XawmyYKKMabBUlXmbp3Lo0sfJbMok1E9RnFjrxttnRM/sqBijGmQdubuZPKSyXy942tOiD+BFwa+QPd4uxbL3yyoGGMalNLyUt5Y9wbTVk4D4N6+93JVt6tsepV6wv4KxpgGY23aWiYsmsC69HWcnXQ2Y/uNtYWz6hkLKsaYei+/JJ9pK6fxr3X/onlIc6acM4VB7QY1uksAGgMLKsaYeu2r1K94eMnD7MzbyeXHX84dfe4gOjja38Uyh2FBxRhTL+0v2M9jSx/j062f0jGmIzMGz+CUVqf4u1imBhZUjDH1SuX5um7ufTN/7PlHm6+rgbCgYoypNzZnbmbi4oms2LuClFYpjDttHB1i7MLkhqTGoCIil6vquzWlGWPM0SouK+bVH1/l1R9fJSwwjEmnT2J45+HWEd8AeVNTeQCoHECqSjPGmCO2bPcyJi2ZxJasLVzU4SLu7Xsv8WHx/i6WOUqHDSoiMgS4CGgjIs96bIoGSr05uIhsBXKAMqBUVVNEJA54G2gPbAWuUNUMcU5JnnFfMx8Ypaor3OOMBMa6h52sqjPc9D7AdCAM+AS4vaGuU29MU2PzdTVO1dVUdgLLgEuB5R7pOcCdR/Aa56rqfo/n9wPzVfVREbnffX4fMATo4t76AS8A/dwgNB5IARRYLiIfq2qGm2c0sAQnqAwG5hxB2YwxdUxV+XTrpzy29DEyizK5rsd1/KXXX2y+rkbisEFFVX8AfhCRN918yaq6vhZecxgwwH08A1iAE1SGATPdmsYSEYkVkUQ37zxVTQcQkXnAYBFZAESr6mI3fSYwHAsqxtRbO3J3MHnJZP6343/0iO/Bixe8SLe4bv4ulqlF3vSpDAamAMFABxHpDUxS1Uu92FeBz0REgZdU9WWglaruAlDVXSLS0s3bBtjusW+qm1ZdemoV6b8iIqNxajQkJyd7UWxjTG2qPF/XfX3v46puVxHQLMDPJTO1zZugMgE4FadGgaquFJH2Xh7/DFXd6QaOeSLyUzV5qxrmoUeR/utEJ5i9DJCSkmJ9LsbUoTVpa5i4aCLr0tdxTtI5jOk3xubrasS8CSqlqpp1NEP7VHWne79XRD7ACU57RCTRraUkAnvd7KlAW4/dk3D6dVI52FxWkb7ATU+qIr8xph7IL8nnHyv/wRvr3iAuNI4nz3mSC9pdYMOEGzlvFm1eLSJXAwEi0kVEngMW1bSTiESISFTFY2AQsBr4GBjpZhsJfOQ+/hi4Vhz9gSy3mWwuMEhEmotIc/c4c91tOSLS3x05dq3HsYwxfvRV6lcM/2g4s9bO4rddfstHwz9iUHubALIp8KamciswBigC3sT5kZ/sxX6tgA/cL1Eg8Kaqfioi3wHviMj1wDbgcjf/JzjDiTfiDCm+DkBV00XkIeA7N9+kik574EYODimeg3XSG+NX+wv28+jSR5m7dS6dYjrZfF1NkFR3WYeIBACPquo9dVck30pJSdFly5b5uxjGNCrlWs77G95n6vKpFJYWcsNJN/DHnn8kKCDI30UztUBElqtqijd5q62pqGqZe4GhMcZUyXO+rr6t+zKu/zjax7T3d7GMn3jT/PW9iHyMMy1LXkWiqv7bZ6UyxtR7RWVFB+brCg8Mt/m6DOBdUIkD0oDzPNIUsKBiTBP13e7vmLR4Eluzt3Jxx4u5J+Uem6/LAF4EFVW9ri4KYoyp/yrP1/XiwBc5o80Z/i6WqUe8mfr+2SqSs4BlqmpDeI1pAlSVuVvn8velfyerKIvrel7Hjb1uJCwwzN9FM/WMN81foUA3Dk51/xtgDXC9iJyrqnf4qnDGGP/bnbebyUsmszB1IT3ie/DSBS/ZfF3msLwJKp2B81S1FEBEXgA+Ay4AfvRh2YwxflRWXsbs9bN5dsWzKMo9KfdwTfdrbL4uUy1vgkobIAKnyQv38XHucOMin5XMGOM3GzM2Mn7xeFbtW8UZx53Bg6c9SJvIKudrNeYQ3gSVx4GV7lTzApwNPOJOvfK5D8tmjKljxWXFvPLjK7z646tEBkXyyJmPMLTjUBsmbLzmzeiv10TkE5zJIAX4W8VEkUCjudLemKZu5d6VjF80ns1Zm7m448Xc2/de4kLj/F0s08B4M/pLgPOBjqo6SUSSReRUVV3q++IZY3wtvySfZ1Y8w1s/vUWriFZMO38aZyed7e9imQbKm+av54FynIsfJ+EsJ/w+0NeH5TLG1IGvU7/moSUPsTtvN1d1u4rbTrmNiKAIfxfLNGDeBJV+qnqKiHwPoKoZIhLs43IZY3worSCNx797nE+2fELHmI7MHDKT3i17+7tYphHwJqiUuLMVK4CIJODUXIwxDYyq8p/N/+Hx7x4nrySPm3rdxPUnXk9wgJ0nmtrhTVB5FvgAaCkiDwO/Bcb6tFTGmFq3I3cHkxZPYtHORfRO6M2E0yfQKbaTv4tlGhlvRn+9ISLLcTrrBRiuqut8XjJjTK2ouIjxmRXPIAgPnPoAV3a7kmbizcKvxhwZb2oqqOpPwE8AIhIrImNU9WGflswYc8w2ZW5i3KJxrNq3ijPbnMm4/uNIjEz0d7FMI3bYoCIibYEHgeOAD3GWEn4I+APwVp2UzhhzVErKSnh19au8suoVIoIi7CJGU2eqq6nMBBbiDB8eDCy/H0oRAAAgAElEQVTBmUjyJFXdXQdlM8YchdX7V/PgNw+yMXMjQ9oP4b5T77O1Tkydqa5RNU5VJ6jqXFW9E2gFjDrSgCIiASLyvYj8133eQUS+FZENIvJ2xfBkEQlxn290t7f3OMYDbvp6EbnQI32wm7ZRRO4/knIZ09gUlBYw5bspXPPJNWQXZ/Pcec/x+DmPW0AxdaranjoRaS4icSISB+wGwj2ee+t2wLNj/zFgqqp2ATKA693064EMVe0MTHXzISInAFcCPXBqTM+7gSoAmAYMAU4ArnLzGtPkfLvrWy776DJmrJ3Bb7r8hg+HfciAtgP8XSzTBFXX/BUDLMcZ8VVhhXuvQMeaDi4iScDFwMPAX90pX84DrnazzAAmAC8Aw9zHAO8B/3DzDwNmq2oRsEVENuLMQwawUVU3u6812827tqZyGdNYZBdn89Syp3h/w/skRyXzzwv/Sd/WNtmF8Z/DBhVVbV8Lx38auBeIcp/HA5kVa7MAqThT6+Peb3dfu1REstz8bXD6c6hin+2V0vtVVQgRGQ2MBkhOTj6Gt2NM/TF/23weXvIw6YXpXNfzOm7qdROhgaH+LpZp4rwaUnw0RGQosFdVl4vIgIrkKrJqDdsOl15V051WkYaqvgy8DJCSklJlHmMaiv0F+/n7t3/ns18+o2vzrjx3/nP0iO/h72IZA/gwqABnAJeKyEU4SxJH49RcYkUk0K2tJAEV0+inAm2BVBEJxGl+S/dIr+C5z+HSjWl0VJWPN33M4989TmFpIbefcjsje4wkqFmQv4tmzAE+u6RWVR9Q1SS3Ge1K4AtVvQb4EmeqF4CRwEfu44/d57jbv1BVddOvdEeHdQC6AEuB74Au7miyYPc1PvbV+zHGn3bk7uAvn/+Fsd+MpVNsJ9699F3+dOKfLKCYesermoqInAl0UdXX3QklI1V1y1G+5n3AbBGZDHwPvOamvwbMcjvi03GCBKq6RkTewemALwVuVtUyt1y3AHOBAOCfqrrmKMtkTL1UeYqVMf3GcEXXK2yKFVNviVMZqCaDyHggBeiqqseLyHHAu6p6Rl0UsLalpKTosmXL/F0MY2q0KXMT4xeN54d9P9gUK8avRGS5qqZ4k9ebmsoI4GTc4cSqulNEoqrfxRhztErKSnht9Wu8vOplm2LFNDjeBJViVVURqVhPxZaFM8ZHVu9fzbhF49iQscGmWDENkjdB5R0ReQln1NafgT8Cr/i2WMY0LQWlBUz7fhqz1s2iRVgLnjvvObsi3jRI3qynMkVELgCyga7AOFWd5/OSGdNELN21lPGLxpOam8rlx1/OnX3uJCrYWphNw1RjUBGRO3E65i2QGFOLcotzeWr5U7z787s2xYppNLxp/ooG5opIOjAbeE9V9/i2WMY0bl+nfs2kJZPYm7+XUT1GcVPvmwgLDPN3sYw5Zt40f00EJorIScDvgIUikqqqA31eOmMamayiLB7/7nE+3vQxnWI6MWvILE5KOMnfxTKm1hzJNC17caa/TwNa+qY4xjRe83+Zz0NLHiKzKJPRJ43mhpNuIDgg2N/FMqZWedOnciNODSUBZ0r6P6uqTS9vjJfSCtJ45NtH+OyXz+gW140XBr5A9/ju/i6WMT7hTU2lHXCHqq70dWGMaUxUlU+2fMKjSx8lrySP206+jVE9R9l8XaZRO2xQEZFoVc0GHnefH7Lao6qm+7hsxjRYe/L28NCSh1iYupCTEk5i0umT6BTbyd/FMsbnqqupvAkMxVn9sfK6Jl6t/GhMU6OqfLDxA5747glKy0u5J+Uerul+DQHNAvxdNGPqRHUrPw517zvUXXGMabh25O5gwqIJLNm1hJRWKUw8fSLJ0bbSqGlavOmon6+q59eUZkxTVa7lzP5pNk+veBpBeLD/g/z2+N/a9PSmSaquTyUUCAdaiEhzDjZ/RQPH1UHZjKn3tmZtZfyi8azYu4IzjjuD8aeNt+npTZNWXU3lBuAOnACynINBJRuY5uNyGVOvlZaXMmvtLKatnEZwQDCTz5jMpZ0utenpTZNXXZ/KM8AzInKrqj5Xh2Uypl7bkLGBcd+MY3Xaas5rex5j+48lITzB38UyBspKoKwYVJ37omwoKYDSIigvg6Q+Pi+CN9O0PCciPYETgFCP9Jm+LJgx9U1JWQmvrn6Vl1e9TFRQFE+c8wQXtrvQaifm2KhCcR4U5ThBoCjXvc859FaY6aQXZkFhNhTnQnG+c19SACXu48OJaAn3bPD52/Gmo348MAAnqHwCDAH+B1hQMU3GmrQ1jPtmHD9n/MyQDkO4/9T7iQuNq3lH0zSUFrs/9lmQn+YEgMJs574gAwoyncc5u508RdlOQCjKgeIc0PKaXyMoHEKiITQaQmMgONIJFMEREBwOQRFOemAIiECzICdvULiTFhLt+88B766o/y3QC/heVa8TkVbAqzXt5Hb0fwWEuK/znqqOF5EOOLMdx+EsUfwHVS0WkRCcQNUHZ36x36nqVvdYDwDXA2XAbao6100fDDwDBACvquqjXr9zY7xQVFbEiz+8yOurXycuNI5nz32Wc5PP9XexjC+UFDo/8mXFzhl/Qcaht/x0KEiv9DjrYA2iOkEREBYLEQkQ1hxikpwf+9BoCIlyb9GV7ivdAhrGTAzeBJUCVS0XkVIRicaZWNKbCx+LgPNUNVdEgoD/icgc4K/AVFWdLSIv4gSLF9z7DFXtLCJXAo8BvxORE4ArgR44gwY+F5Hj3deYBlwApALficjHNi+ZqS0r965k3KJxbMnawojOI7i7791EB9fN2Z45BmWlkLcX8vY7QSJvn1N7KEh3g0GGk5a3z2k2qqhRlBZWf1xp5gSEsOYQFgfRbaBlD+d5RDyExjo1hbA4J4CExhxMC2w6E4d6E1SWiUgszhLCy4FcYGlNO6mqunkBgtybAucBV7vpM4AJOEFlmPsYnIkr/yFOY/UwYLaqFgFbRGQjcKqbb6OqbgYQkdluXgsq5pjkl+Tz3PfP8ca6N2gd0ZqXBr7E6W1O93exmjZVp9moIMMJDtk7IXsXZKdCXpoTRLJ3Qe5uJ5igVR8nONINAi0gspXbpBTlBgE3AAQEOTWL8Dg3gMQ69yEx0MyuPaqJNx31N7kPXxSRT4FoVV3lzcFFJAAnEHXGqVVsAjJVtdTNkgq0cR+3Aba7r1kqIllAvJu+xOOwnvtsr5Te7zDlGA2MBkhOtiuczeF9u+tbJiyaQGpuKld2vZI7+txBRFCEv4vVeKk6TU3ZuyCnIlDsgJxdkJXqPM7b79Q0yop/vX9AMIS3cIJETBtocwpEtXYCRkSCEzAiEiA83gkSgSF1/x6bmOoufjylum2quqKmg6tqGdDbrel8AFQ133fFKUVVQ2gqzznmmV7VKUOVpyeq+jLwMkBKSsphTmFMU1Z5ad/XL3ydlNYp/i5Ww1eQ6QSHrFTI/AX2b3Ae5+93ahu5e6C89Nf7hcY6/Q4xSdC6l9O8FNHSqTGEx0FUonOLSLDaQz1TXU3lyWq2VTRjeUVVM0VkAdAfiBWRQLe2kgTsdLOlAm2BVBEJBGKAdI/0Cp77HC7dGK99nfo1ExdPZF/BPlva90iUlzk1isxtkPGLc5/5i1O7yN7lbKvcgR0SDbHtnMDQ4WynVhEaC9HHOUGi4j443D/vyRyz6i5+PKYhLiKSAJS4ASUMGIjT+f4lzoiy2cBI4CN3l4/d54vd7V+oqorIx8CbIvIUTkd9F5w+HQG6uKPJduB05lf01RhTI8+lfTvHdmbqgKmcmHCiv4tVvxRkQPoWyNji3Gdth/TNTgDJSv11LSMq0enATjgeOp4DMW0hti1EJ0FsMkS2dIa7mkbLm+tUrq0q3YuLHxOBGW6/SjPgHVX9r4isBWaLyGTge+A1N/9rwCy3Iz4dJ0igqmtE5B2cDvhS4Ga3WQ0RuQWYizOk+J+quqam92MMwOe/fM7kJZPJKsrihpNuYPRJo5vm0r6qzsintE1O01TaBue+otZRkHFo/vB4iOsIbVKgx2VOoIhNdmofMUkQFFr165gmQ5xBWtVkEPGcoiUUOB9Yoaq/9WXBfCUlJUWXLVvm72IYP/Fc2rd7XHcmnTGJbnHd/F0s31J1mqL2/wx7f3ICR+a2g7UNz6uwmwVC8/bOLTbZCSDNO0BcByct2AYtNEUislxVvepk9Gb0162VDh4DzDrKshnjF5WX9r39lNsZ2WNk41rat7wMMrbCvvWwf70TQPatg30/Q2nBwXyhMU7NIr4zdDrP6ceI6wQtujiBo4FcZGfqJ2+uU6ksH6dfw5gGofLSvg+d/hAdYxv4wqVFubB3Lez+EfasgT2rnXvPWkfUcdCyG6T80alptOgCCd2tX6OBKitXcotKySsqJb+4jILiMvKKnee5FbfCiudlFJaWkV9USmm5UlhSRkhQANOuPuyg3lrjTZ/Kfzg4VLcZzhxg7/iyUMbUBlXl3xv+zZRlUygtL+XevvdydberG97SvkU5sHMl7FwBqcucQJKx5eD2kGho1QN6XQWJvSChm9NRHhrjvzKbA1SVotJy8ovLyC92AkJuUSn5RWVkFZSQWVBMVkEJWfklZOaXkF1YQm5RKdmFpWQXlJDjBoqCkjKvXk8EwoMCCA0KICIkkMBmQmhQAK1j6qa/y5uayhSPx6XAL6qa6qPyGFMrPJf27du6LxNPm0jb6LY17+hvpcWwdw3sWA47vnfu9/3EgfO65u2dwNH7amjV0wkmsclW86gDZeVKVkEJ2QXOj35hSRk5haVkF5awL6eI1IwCJxgUlJCRX0xGfgk5hSVkF3gXEIIDm9E8PIjo0CDCQwKJDg2kbfMwokIDiQgOJCIkkKjQQCJDAgkLDiA8OJCI4AAiQ91tIc59WFAAzZr57/vgTZ/KQgB33q9A93Gcqqb7uGzGHDHPpX2bSbP6vbRvebkzPHfH8oO33T9CWZGzPbwFtOkDPUY4V4ofd4pzEaA5amXlSk5hiVMzKHB+8LMKnNrBwTSPxx61hcz8YkrLDz+wKdL90Y8JCyI2PIjjW0USFRJEZGggcRHBhAcHEBHsBITIkEDCgwOICQ8iNiyY2PAgQoMaWA36MLxp/hoNPAQUAOU414co3k0qaUyd2ZK1hQmLJjhL+7Y5g/H969nSvtm7nMCxc8XBmkhRlrMtKByOOxn6jXaCR5s+VgOpQmlZ+YEf+zy3tpBbVEp6XjE5haVVBIUSsgqcwJBdUEJOURVX73sIaCbEhAURExZEdGgg0WFBJDUPIzo0iLiIIFpEhhAd6gSK0KAAokMDiQoNokVkMLHhTXBIehW8af66B+ihqvt9XRhjjkZpeSkz1szg+ZXPExoYWj+W9i3KgV2rYPu3bgBZ4cxtBSABTrNVz8uc4NHmFGjRFQKOZtxMw1VaVk5GfgnpecWk5RWRnlfsPM4tJjO/mL05RWTkFx+oTeQVO/c1XAVBWFDAwcAQFkib2FC6t44i+kBa0CGBI8ZtcooJCyI8OMAWXTtG3nyLN+GM+DKm3lmfvp4Hv3mQdenrGJg8kDH9x9AirEXdF6S02Akgm+bD5oWwa+XBhZfiOkL7M9wA0gdanwhBjW8amNKyctLznGBwIEDkFZPuBoy03OJD0rMKSg57rOjQQBKiQoiLCCYxJpRuiVFEBAfSPDyI+MgQosMCCQ92mpDCgwNoHh5MdJgTHIID62FTZxPiTVB5AFgkIt/irJECgKre5rNSGVODkrISXvnxFV5Z9QrRIdE8ec6TDGo/qO4KoOoM4d30BWxZCL8shpI85+LBpFPhrLuc+zZ9GnQ/iKqSke90RO/MKmBHRgF7swvZm1N0IDBkFzjb0/OLq6xFBDQTmocHEx8RTFxEMN2PiyYu3HkcH+ncx0UEEx/hBJHm4UEEBlhgaKi8CSovAV8AP+L0qRjjV2vT1vLgNw/yc8bPXNzxYu7vez+xobG+f+G8NNj8JWyc7wST3N1OeovjofdVzoWE7c9yVvNrAMrLlf15RezOKmRnZiG7swrYlVVIamYBqRkF7MsuZF9uESVlh0YKEYiPCKFFZDAxYUG0jQvn5OTmJESFkBAZTEJU6IFgER8RTHRokF9HI5m65U1QKVXVv/q8JMbUoM6X9i0rgdTv3CAy37lWBHVm1e10LnQ63wkkMW1qPJQ/lJcre3OK2Lw/l9T0ArZn5LM9PZ9t6fnsyipkfxUBIzigGYmxoSTHhdM5oQUto0NIiAyhZXQIraNDadM8jITIEKtJmMPyJqh86Y4A+w+HNn/ZkGJTZ37Y9wPjvhnH5qzNDO88nLtT7iYmxAcX92Vuhw2fOTWRzQuhOMfpWE9KgQEPQOfznVFa9eACSlUlPa+YTfvy2Lo/jz1us9TOzAK27M8jNaOA4rKDjQvNBBJjwkiOC+f0Ti1IiAohMSbUvYWRGBtKfESwdVSbY+JNUKmYTv4BjzQbUmzqREFpAf/4/h/MWjvLN0v7qjrTnaz5EH6e41wnAs6U7T0vc4JIh3OcJWX9oKC4jG1u7WJ3diGp6fn8kpbPL+n5bEvLI6/40IvqYsKCSIwJ5fhWUVzQoxVJsWF0TIikbfNwEmNDCbIahvExby5+7FAXBTGmsmW7lzF+0Xi25WzjiuOv4K8pf62dpX09A8naD53Ze6UZtO0PAydA14ucfpI6OmMvKSvnl7R81u7KZtPeXLa7zVNb9uexO7vwkLzBAc1IigujXVw4/TrEkRwXToeECDonRJIQFdJoLqAzDZcv11Mx5qjkl+Tz9Iqneeunt0iKTOKfF/6Tvq37HvuB0zbB6vfhx/ecWXylGbQ7A/rdAN0vdSZa9LG03CJ+2p3D2p3ZrNuVzdpd2Wzcm3vgSu1mAq2jQ0mMDeO0TvF0SoigbVw47eIjSIwJpUVkCAHW6W3qMW+avzz/mw+spwJYUDG1bsmuJUxYNIGduTv5ffffc+vJtxIedAxLy2alwup/w+r3YNcPTlq7M+DUPzuBJKpV7RS8kqLSMjbtzWPdLid4/LQ7h59257A/90C3JK2jQ+meGMW53VrSKSGSHsdF06FFhNU2TINm66mYeiGnOIenlj/Fez+/R/vo9swYMoOTW558dAfLT3dqJKvfh22LnbTjToZBDzvzaNXyaK2i0jI27s1l/e4cvt+WyfJfMvh5T86B2kdIYDO6to5iQNcEurWOolvraLonRhEfGVKr5TCmPrD1VIzffZ36NRMXT2RfwT6u63kdN/W6idDAI5ymu6wUNn4OK/8FP3/mTMqY0A3OHet0uMd3qpWyZuYXsyo1ix93ZLFuVzbrd+eweX8eZW4AiQgO4OTk5vz57I50T4zmhMQo2sdH2BBc02T4bD0VEWmL00TWGueiyZdV9RkRiQPeBtoDW4ErVDVDnHGMzwAX4QSuUaq6wj3WSGCse+jJqjrDTe8DTAfCgE+A27Wm9ZFNvZFVlMXj3z3Ox5s+pnNsZ6YOmMqJCSce2UH2/Qzfz4RV7zoXI0a0hJTr4OTfO1PDH0Nne1ZBCT+mZrFqRyardziBZHv6wRUUk5qH0a11FBf2aE3X1lF0ax1FhxYWQEzT5sv1VEqBu1R1hYhEActFZB4wCpivqo+KyP3A/cB9wBCcGlAXoB/wAtDPDULjgRSc4LZcRD5W1Qw3z2hgCU5QGQzM8aJsxs++2PYFDy15iIzCDEafNJobTrqB4AAvZ3ktLYK1H8HyGfDL/5ypUbpc6FzVfvzgo1oOV1VJzShgxbYMlm3NYMnmNDbsPbiKYnJcOCe1ieXqU9vRKymGHm1iiAmzZXeNqeywQUVEOgOtKtZT8Ug/S0RCVHVTdQdW1V3ALvdxjoisA9oAw4ABbrYZwAKcoDIMmOnWNJaISKyIJLp551VcbOkGpsEisgCIVtXFbvpMYDgWVOq1jMIM/v7t35mzdQ5dm3fl+fOfp3t8d+92zt4Fy/4Jy6dD3l5nosbzx8PJf4DIhCMqR3FpOat3ZrF0SzrLtmbw/bYM0vKKAQgPDqBv+ziGn9yGE9vEcFJSjE1rboyXqqupPA38rYr0AnfbJd6+iIi0B04GvsUJVBXBZpeIVIzjbANs99gt1U2rLj21ivSqXn80To2G5ORkb4ttatncrXN55NtHyC7O5ubeN3P9idcT1KyGs31VZ/bfb1+CdR9DeRkcfyGcOho6ngvNvGtqKitXfkjNZPGmNL7ZuJ8V2zIoLHGuNu/YIoJzuiZwSnJzereNpVvrKGvCMuYoVRdU2qvqqsqJqrrMDRJeEZFI4H3gDlXNrmYKiKo26FGk/zpR9WXgZYCUlBTrc6lj+wv288i3jzDvl3n0iO/Bq4NepUvzGsZ6lBQ4o7e+fQl2r3LWW+/3F+h7vVNDqUF5ufLz3hwWb0pj0aY0vt2cRnahs0BTt9ZRXHVqMqe2jyOlfRwJUTYKy5jaUl1QqW74jVeLQYhIEE5AeUNV/+0m7xGRRLeWkgjsddNTAc9FxJOAnW76gErpC9z0pCrym3pCVfnv5v/y2HePUVBSwJ197uTaE64lsFk1X7vM7bDsNae/pCAdErrD0Klw0u8guPqr6XMKS1i8KY0v1+/j83V72JfjXBPSLj6ci09K5LROLTizcwviIqwpyxhfqS6ofCcif1bVVzwTReR6YHlNB3ZHc70GrFPVpzw2fQyMBB517z/ySL9FRGbjdNRnuYFnLvCIiDR38w0CHlDVdBHJEZH+OM1q1wLP1VQuUzf25O3hoSUPsTB1Ib0SejHpjEl0jDlMDUMVtn7t1ErWf+KkdbvYaeJqf1a1I7i27M9jwfq9zFu7h6Vb0iktVyJDAjn7+Bac27Ulp3WKJ6n5MVw8aYw5ItUFlTuAD0TkGg4GkRQgGBjhxbHPAP4A/CgiK920v+EEk3fc4LQNuNzd9gnOcOKNOEOKrwNnNmQReQj4zs03yWOG5Bs5OKR4DtZJ73eqyocbP+SJ756gpLyEe/vey9Xdriagqll9i/Ng1duw9BVnLq6wODjjdki5HmLb/jo/Tgf7sl/Smb9uL1/+tJfN+/MA6Nwykj+d1ZFzjk+gT7vmtvqfMX4iNV3WISLnAj3dp2tU9Qufl8qHUlJSdNmyZf4uRqO0M3cnExdPZNHORaS0SmHi6RNJjq5iYETmNqdW8v0sKMyC1ic582/1/E2Vy+xm5hfz+bq9zF+3h6837Ce3qJTgwGb06xDHwO6tOLdrS5LjrTZijK+IyHJVTfEmrzfTtHwJfHnMpTKNVrmW8+76d3lq+VMoyph+Y7ii6xU0k0q1hZ3fwzfPwNqPnecnDHOCSdt+v2riyiooYe6a3fx31S4WbdxPabnSOjqUS3olcm7XlpzRuQURIUczIYQxxpfsv9Ick+3Z2xm/eDzf7f6O0xJPY/zp42kT6TGyu6K/5OunnKV4Q6LhtJudYBKTdMixcotK+XztHj7+YSdfb9hHSZnSNi6MP53VkSE9W3NSUowtIGVMPWdBxRyVsvIy3vrpLZ79/lkCJICJp09kROcRB3/0VZ0leBc+7lxnEtHSWask5Y/O8GBXTmEJn6/bw/+t2s1XG/ZRXFpOm9gwRp7WnotPSqR321gLJMY0IBZUzBHbkrWFcd+MY+W+lZyddDbj+o+jVYQ7hbwqbJgHCx+DHcsgOgkumuLMxeX2lxSWlLFg/V4+WrmT+T/tpbi0nMSYUK7pl8yQnomktGtOM1szxJgGyYKK8VpZeRkz185k2spphASE8MiZjzC041CnJqEKP3/qBJOd30NMMgx9GnpfA4HBqCrfbk7j3ytSmbN6NzmFpbSIDObqU5O5pFciJ7e1QGJMY2BBxXhlc+ZmHvzmQVbtX8V5bc9jbP+xJIQnQHk5/PR/TjDZvQpi28Glz0GvqyAgiJ2ZBby7bAPvr0hlW3o+kSGBDOrRiuG923B6p3ibDsWYRsaCiqlWaXmpUzv5fhrhQeE8fvbjDG4/GFF1Zgpe+DjsWe1MnTL8BTjxcoo1gC/W7eWdZdtZsH4vCvTvEM8dA7swpGciYcG2sqExjZUFFXNYmzM3M/absfy4/0cGJg9kTP8xtAhpDms+gK+ecC5YjO8CI16Gnr9he1Yxb83bxDvLtrM/t5iWUSHcNKAzv+vblrZxdh2JMU2BBRXzK6XlpcxYM4PnVz5PeFA4T5z9BBe2G4T8PAe+mOwEkxZd4bJXKe0+nPk/p/HmjBV8tWEfApzXrRVXndqWc45PsOYtY5oYCyrmEJsyN/HgNw8erJ30G0OLHSvh1fOcDvi4jvCb18hofzGzl+9k5pSv2JVVSOvoUG47rwu/69uW42K9mm/UGNMIWVAxwMHaybSV04gIinBqJ+UhyBtXwI7lENMWhj3P2oQhzFiSyodvL6CotJzTO8Uz8dIenNetpdVKjDEWVAxszNjIg988yOq01U7tpMMIWnw9FTZ9AdFJlF38NJ8Fn8frS3aydMtiQoOacdkpSYw8vR3dWkf7u/jGmHrEgkoTVlpeyvQ103l+5fNEBkXyRJ97ufCnhcjCSyCsOQXnTmJm6UCmf76bXVmrSWoext8u6sYVKW1teV1jTJUsqDRRGzM2MvabsaxJW8OgpAGMKQoi7oO/gjQj/eSbea54KG99nkVhydYDTVznd29FgF2gaIyphgWVJsazdhIVFMmTLc9h0NIPoTiX/V0u59GCEby3uJyQwCxGnNyGUWe0tyYuY4zXLKg0IZ59J4Oij2fM5tXE/TSLtKSBPFx4Of9eFUVseAC3n9+JUae3p7ktu2uMOUIWVJqAQ/pOmgUzpTCUC7d8Tk7CKTwYdDezNh5Hq+gQHhzaiSv7trV1SowxR81+PRq5TZmbGPu/saxOW80FEs2YTWsJDzuOJ6L/xrTtPWgZFcqkYc5V7yGBNn2KMebYWFBppDyvO4lU4Yl9GQwsTONfoSP5e9o5tIiNYdKwjlyR0pbQIAsmxpja4bOgIiL/BIYCe1W1p5sWB7wNtAe2AleoaoY4qzA9A1wE5AOjVHWFu89IYAPiwWUAAA5USURBVKx72MmqOsNN7wNMB8KAT4DbVVV99X4aki1ZWxj7vzGs2v8j5xf+f3v3HiRFee5x/PvswiIEEBCICCygGG8YkWwpetBDjAkXRYzRCCJCMIdCodQYKi5qCGppgMSIUQ8GTqGgBPCSGFJClCJejij3cFGIh0tQV2C5mgVBYOE5f/S75wybnV12t2dml/19qqam55135n367d5+tvvt6S7mwcJCVuVczWX7+5PTrA0P/6AzN3RrR339WFFEYpbKPZXngaeBGQll+cBCdx9vZvnh9X1AH+Ds8LgUmAxcGpLQL4A8wIEVZjbX3feGOsOBxURJpTcwP4XzU+MdPXaUF9e/yFMrn+SUo8VM3LmLDoc7MuTgKHbXO5e7r+/MD/Pak1NPyUREUiNlScXd3zWzjqWK+wM9w/R04G2ipNIfmBH2NBabWTMzaxPqLnD3PQBmtgDobWZvA03d/YNQPgO4njqcVD4p+oSx/z2GlbvW0vPLA9yzx3nqwFAWNbqKkdd2ZsAluTrMJSIpl+4xla+7+zYAd99mZq1DeVvgs4R6BaGsvPKCMsrLZGbDifZqyM3NreYs1CzH/Biz1s1k0orfUP/oER7ZvZfCL65kaM5AhvTpwvjuHZRMRCRtaspAfVk/0/YqlJfJ3acAUwDy8vJOmnGXgn0FjH3rXpbtXU+PAwf5/o5mTGUc37762/zlso46NVhE0i7dW51CM2sT9lLaADtCeQHQPqFeO2BrKO9ZqvztUN6ujPp1grvzyroX+fXyx7FjR/jZ7oOsL7qRdVcMY9oVZ9HklPqZDlFE6qh0J5W5wBBgfHj+U0L5KDObTTRQ/8+QeN4AHjOz5qHe94Ax7r7HzPaZWXdgCXAb8FQ6ZyRTtu/fxrgFI1lUtIFLD35Ft8Jz2XTOfdxzTR6tm5yS6fBEpI5L5SnFs4j2MlqaWQHRWVzjgZfM7HbgU+CmUH0e0enEG4lOKf4RQEgejwDLQr2HSwbtgTv4/1OK53OSD9K7O3PXPs/4lZM46sUM253Fzpz7uPLHN9Gl7amZDk9EBACraz/tyMvL8+XLl2c6jErZtX87D867nUUHP+Wig4c5Z28PLuo1ln4X5xL9xEdEJHXMbIW7551IXY3k1mDuzusrnuWXa/+TQxzj+3sac8ZZk7ht2L/TKEeLTkRqHm2Zaqg9+7bywGu38d6xQs47XEzXYzdy65B8clt+LdOhiYgkpaRSA73+/pNM+PtU9mVBr3+24tqek+l50bmZDktEpEJKKjVIUVEBY/8wmIW2izOLnZua/pj/GHSXfrwoIrWGkkoNseC9Sfzy46nsyTau3HcGI66dxoUd21X8QRGRGkRJJcO+LPqch18dzLysnbQ9ZgxtNoKRg+/UFYRFpFZSUsmgdxc9zaPrJ7OtntH9yzO4u99zdGmf9BJmIiI1npJKBny1v5BHXx7En2w7rTGGNh3OXYNHUU97JyJSyymppNn7H0zhsY+e5JP6WeQdOJ2f9nuOLu3aV/xBEZFaQEklTQ4f2M3EObfwin1OMzOGNB3KTwbfS3aWfhEvIicPJZU0WLr0BcavHs+GnCy6HmxF/jXPcUH7jpkOS0QkdkoqKVR8aD+/nj2Il3wTjbKNwU1vYfTgfLK0dyIiJykllRRZsfp1JizJZ30DuPDQqdzfdzpd2nfOdFgiIimlpBKzo8WHeXz27bx8ZCX16hmDG/dj9OBHycrSmV0icvJTUonRuo2LeXThHaw5pZguRxpx/3encmGnrpkOS0QkbZRU4uDO5Fd/ygtFb3AkxxiY04P8W58hK1vX7BKRukVJpZoKtm3goT8PZnGDLzm7uB6jL3+Cy7tclemwREQyQkmlGma9MZEpBdPZm2P08/P4+ZAZNGzQMNNhiYhkjJJKFXxRtJNxcwawMGcH7TyLx75xP30vH5jpsEREMq7WJxUz6w08CWQD/+Xu41PZ3vxFM/jt+okU5BhXHWnDuJtn0bzJaalsUkSk1qjVScXMsoFngO8CBcAyM5vr7uvibuurQwd45PeDmGcbaG7OmNOHcUuve+NuRkSkVqvVSQW4BNjo7psBzGw20B+INal8tn0zd8+9ng0NnO6HmjL2upm0P71TnE2IiJwUantSaQt8lvC6ALi0dCUzGw4MB8jNza18I606cBqNubpJD+4cMrGKoYqInPxqe1Ip6yJa/i8F7lOAKQB5eXn/8n5FsrKzmTr8/cpHJyJSx9T2a4cUAIk3I2kHbM1QLCIidV5tTyrLgLPNrJOZ5QADgLkZjklEpM6q1Ye/3L3YzEYBbxCdUjzN3T/KcFgiInVWrU4qAO4+D5iX6ThERKT2H/4SEZEaRElFRERio6QiIiKxUVIREZHYmHulfwtYq5nZTuCTKn68JbArxnDiorgqR3FVjuKqnJMxrg7u3upEKta5pFIdZrbc3fMyHUdpiqtyFFflKK7Kqetx6fCXiIjERklFRERio6RSOVMyHUASiqtyFFflKK7KqdNxaUxFRERioz0VERGJjZKKiIjERknlBJhZbzP72Mw2mll+Gtprb2Zvmdl6M/vIzO4O5ePM7HMzWxUefRM+MybE97GZ9UpV7Ga2xczWhvaXh7IWZrbAzDaE5+ah3Mzst6HtNWbWLeF7hoT6G8xsSDVjOiehT1aZWZGZ3ZOJ/jKzaWa2w8w+TCiLrX/M7Fuh/zeGz5Z1o7oTjetXZvb30PYfzaxZKO9oZgcT+u3ZitpPNo9VjCu25WbRbTGWhLjmWHSLjKrGNSchpi1mtioD/ZVs25Dxdez/uLse5TyILqm/CTgTyAFWA+enuM02QLcw3QT4H+B8YBwwuoz654e4GgCdQrzZqYgd2AK0LFU2EcgP0/nAhDDdF5hPdIfO7sCSUN4C2Byem4fp5jEur+1Ah0z0F3Al0A34MBX9AywFLgufmQ/0qUZc3wPqhekJCXF1TKxX6nvKbD/ZPFYxrtiWG/ASMCBMPwvcUdW4Sr3/ODA2A/2VbNuQ8XWs5KE9lYpdAmx0983ufhiYDfRPZYPuvs3dV4bpfcB6oG05H+kPzHb3Q+7+D2BjiDtdsfcHpofp6cD1CeUzPLIYaGZmbYBewAJ33+Pue4EFQO+YYvkOsMndy7tqQsr6y93fBfaU0V61+ye819TdP/Dor39GwndVOi53f9Pdi8PLxUR3Tk2qgvaTzWOl4ypHpZZb+A/7KuCVOOMK3/tDYFZ535Gi/kq2bcj4OlZCSaVibYHPEl4XUP4GPlZm1hG4GFgSikaF3dhpCbvMyWJMRewOvGlmK8xseCj7urtvg2ilB1pnIK4SAzj+jz3T/QXx9U/bMB13fADDiP4rLdHJzP5mZu+Y2RUJ8SZrP9k8VlUcy+004IuExBlXf10BFLr7hoSytPdXqW1DjVnHlFQqVtbxxLSch21mjYFXgXvcvQiYDJwFdAW2Ee2ClxdjKmL/N3fvBvQBRprZleXUTWdchOPl1wEvh6Ka0F/lqWwcqeq3B4BiYGYo2gbkuvvFwL3A782saaraL0Ncyy1V8Q7k+H9c0t5fZWwbklZNEkPK+kxJpWIFQPuE1+2Aralu1MzqE600M939DwDuXujuR939GDCVaLe/vBhjj93dt4bnHcAfQwyFYbe5ZJd/R7rjCvoAK929MMSY8f4K4uqfAo4/RFXt+MIA7bXAoHC4g3B4aXeYXkE0XvGNCtpPNo+VFuNy20V0uKdeqfIqC991AzAnId609ldZ24Zyvi/961hlBmDq4oPolsubiQYGSwYBL0hxm0Z0LHNSqfI2CdM/ITq+DHABxw9gbiYavIw1duBrQJOE6feJxkJ+xfGDhBPD9DUcP0i4NJS3AP5BNEDYPEy3iKHfZgM/ynR/UWrgNs7+AZaFuiWDqH2rEVdvYB3QqlS9VkB2mD4T+Lyi9pPNYxXjim25Ee21Jg7U31nVuBL67J1M9RfJtw01Yh1zdyWVE1yQfYnOstgEPJCG9noQ7XKuAVaFR1/gBWBtKJ9b6o/vgRDfxyScrRFn7OEPZnV4fFTyfUTHrhcCG8JzycppwDOh7bVAXsJ3DSMaaN1IQiKoRmyNgN3AqQllae8vosMi24AjRP/13R5n/wB5wIfhM08TropRxbg2Eh1XL1nHng11fxCW72pgJdCvovaTzWMV44ptuYV1dmmY15eBBlWNK5Q/D4woVTed/ZVs25Dxdazkocu0iIhIbDSmIiIisVFSERGR2CipiIhIbJRUREQkNkoqIiISGyUVkWows6N2/BWSy72ysZmNMLPbYmh3i5m1rO73iMRNpxSLVIOZ7Xf3xhlodwvRbw52pbttkfJoT0UkBcKexAQzWxoenUP5ODMbHabvMrN14cKJs0NZCzN7LZQtNrNvhvLTzOzNcNHC35FwjSYzuzW0scrMfmdm2RmYZRFASUWkuhqWOvx1c8J7Re5+CdGvkieV8dl84GJ3/yYwIpQ9BPwtlN1PdEkOgF8A73l00cK5QC6AmZ0H3Ex0oc+uwFFgULyzKHLi6lVcRUTKcTBszMsyK+H5iTLeXwPMNLPXgNdCWQ+iy37g7n8NeyinEt006oZQ/rqZ7Q31vwN8C1gWbtDXkGpczFGkupRURFLHk0yXuIYoWVwH/NzMLqD8S4+X9R0GTHf3MdUJVCQuOvwlkjo3Jzx/kPiGmWUB7d39LeBnQDOgMfAu4fCVmfUEdnl0v4zE8j5EV5aF6OKBN5pZ6/BeCzPrkMJ5EimX9lREqqehma1KeP0Xdy85rbiBmS0h+udtYKnPZQMvhkNbBjzh7l+Y2TjgOTNbAxwAhoT6DwGzzGwl8A7wKYC7rzOzB4nuxplFdFXdkUB5t1MWSRmdUiySAjrlV+oqHf4SEZHYaE9FRERioz0VERGJjZKKiIjERklFRERio6QiIiKxUVIREZHY/C8O/H5EmT6OZAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "R_PHE_avg = np.mean(R_PHE,axis=0)\n",
    "R_RAN_avg = np.mean(R_RAN,axis=0)\n",
    "R_UCB_avg = np.mean(R_UCB,axis=0)\n",
    "\n",
    "\n",
    "plt.plot(Opt_Reward - R_PHE_avg,label = 'PHE')\n",
    "plt.plot(Opt_Reward - R_RAN_avg,label = 'RAN')\n",
    "plt.plot(Opt_Reward - R_UCB_avg,label = 'UCB')\n",
    "\n",
    "plt.legend()\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Cumulative Regret')\n",
    "plt.title('RiverSwim epLen = '+str(H)+' , nState = '+str(S)+' , M = '+str(M)+' , Runs = '+str(runs))\n",
    "plt.savefig('PHE_' +str(S)+'_'+str(K)+'.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(x=range(runs),y=Opt_Reward[-1] - R_PHE[:,-1],label = 'PHE')\n",
    "plt.scatter(x=range(runs),y=Opt_Reward[-1] - R_RAN[:,-1],label = 'RAN')\n",
    "plt.scatter(x=range(runs),y=Opt_Reward[-1] - R_UCB[:,-1],label = 'UCB')\n",
    "\n",
    "plt.legend()\n",
    "plt.xlabel('Run')\n",
    "plt.ylabel('Cumulative Regret')\n",
    "plt.title('RiverSwim epLen = '+str(H)+' , nState = '+str(S)+' , M = '+str(M)+' , Runs = '+str(runs))\n",
    "plt.savefig('PHE_scatter_' +str(S)+'_'+str(K)+'.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i_phe = np.argmin(R_PHE[:,-1])\n",
    "i_ran = np.argmin(R_RAN[:,-1])\n",
    "i_ucb = np.argmin(R_UCB[:,-1])\n",
    "\n",
    "R_phe_min = R_PHE[i_phe,:]\n",
    "R_ran_min = R_RAN[i_ran,:]\n",
    "R_ucb_min = R_UCB[i_ucb,:]\n",
    "\n",
    "plt.plot(Opt_Reward - R_phe_min,label = 'PHE')\n",
    "plt.plot(Opt_Reward - R_ran_min,label = 'RAN')\n",
    "plt.plot(Opt_Reward - R_ucb_min,label = 'UCB')\n",
    "\n",
    "plt.legend()\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Cumulative Regret')\n",
    "plt.title('Worst Performing Run on RiverSwim epLen = '+str(H)+' , nState = '+str(S)+' , M = '+str(M))\n",
    "plt.savefig('PHE_min_' +str(S)+'_'+str(K)+'.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20010.0"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(sum(agent.Sigma[-1,:,:]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.89232841e+00, 7.78465683e+00, 1.16769852e+01, ...,\n",
       "       7.78387836e+04, 7.78426759e+04, 7.78465683e+04])"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Opt_Reward - R_avg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}