easy-rl/projects/notebooks/MonteCarlo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1、定义算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "import numpy as np\n",
    "class FisrtVisitMC:\n",
    "    ''' On-Policy First-Visit MC Control\n",
    "    '''\n",
    "    def __init__(self,cfg):\n",
    "        self.n_actions = cfg.n_actions\n",
    "        self.epsilon = cfg.epsilon\n",
    "        self.gamma = cfg.gamma \n",
    "        self.Q_table = defaultdict(lambda: np.zeros(cfg.n_actions))\n",
    "        self.returns_sum = defaultdict(float) # 保存return之和\n",
    "        self.returns_count = defaultdict(float)\n",
    "        \n",
    "    def sample_action(self,state):\n",
    "        state = str(state)\n",
    "        if np.random.uniform(0, 1) > self.epsilon:\n",
    "            action = np.argmax(self.Q_table[str(state)]) # 选择Q(s,a)最大对应的动作\n",
    "        else:\n",
    "            action = np.random.choice(self.n_actions) # 随机选择动作\n",
    "        return action\n",
    "        # if state in self.Q_table.keys():\n",
    "        #     best_action = np.argmax(self.Q_table[state])\n",
    "        #     action_probs = np.ones(self.n_actions, dtype=float) * self.epsilon / self.n_actions\n",
    "        #     action_probs[best_action] += (1.0 - self.epsilon)\n",
    "        #     action = np.random.choice(np.arange(len(action_probs)), p=action_probs)\n",
    "        # else:\n",
    "        #     action = np.random.randint(0,self.n_actions)\n",
    "        # return action\n",
    "    def predict_action(self,state):\n",
    "        state = str(state)\n",
    "        state = str(state)\n",
    "        if np.random.uniform(0, 1) > self.epsilon:\n",
    "            action = np.argmax(self.Q_table[str(state)]) # 选择Q(s,a)最大对应的动作\n",
    "        else:\n",
    "            action = np.random.choice(self.n_actions) # 随机选择动作\n",
    "        return action\n",
    "        # if state in self.Q_table.keys():\n",
    "        #     best_action = np.argmax(self.Q_table[state])\n",
    "        #     action_probs = np.ones(self.n_actions, dtype=float) * self.epsilon / self.n_actions\n",
    "        #     action_probs[best_action] += (1.0 - self.epsilon)\n",
    "        #     action = np.argmax(self.Q_table[state])\n",
    "        # else:\n",
    "        #     action = np.random.randint(0,self.n_actions)\n",
    "        # return action\n",
    "    def update(self,one_ep_transition):\n",
    "        # Find all (state, action) pairs we've visited in this one_ep_transition\n",
    "        # We convert each state to a tuple so that we can use it as a dict key\n",
    "        sa_in_episode = set([(str(x[0]), x[1]) for x in one_ep_transition])\n",
    "        for state, action in sa_in_episode:\n",
    "            sa_pair = (state, action)\n",
    "            # Find the first occurence of the (state, action) pair in the one_ep_transition\n",
    "\n",
    "            first_occurence_idx = next(i for i,x in enumerate(one_ep_transition)\n",
    "                                       if str(x[0]) == state and x[1] == action)\n",
    "            # Sum up all rewards since the first occurance\n",
    "            G = sum([x[2]*(self.gamma**i) for i,x in enumerate(one_ep_transition[first_occurence_idx:])])\n",
    "            # Calculate average return for this state over all sampled episodes\n",
    "            self.returns_sum[sa_pair] += G\n",
    "            self.returns_count[sa_pair] += 1.0\n",
    "            self.Q_table[state][action] = self.returns_sum[sa_pair] / self.returns_count[sa_pair]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2、定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(cfg,env,agent):\n",
    "    print('开始训练！')\n",
    "    print(f'环境:{cfg.env_name}, 算法:{cfg.algo_name}, 设备:{cfg.device}')\n",
    "    rewards = []  # 记录奖励\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # 记录每个回合的奖励\n",
    "        one_ep_transition = []\n",
    "        state = env.reset(seed=cfg.seed) # 重置环境,即开始新的回合\n",
    "        for _ in range(cfg.max_steps):\n",
    "            action = agent.sample_action(state)  # 根据算法采样一个动作\n",
    "            next_state, reward, terminated, info = env.step(action)   # 与环境进行一次动作交互\n",
    "            one_ep_transition.append((state, action, reward))  # 保存transitions\n",
    "            agent.update(one_ep_transition)  # 更新智能体\n",
    "            state = next_state  # 更新状态\n",
    "            ep_reward += reward  \n",
    "            if terminated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        if (i_ep+1)%10==0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.1f}\")\n",
    "    print('完成训练！')\n",
    "    return {\"rewards\":rewards}\n",
    "def test(cfg,env,agent):\n",
    "    print('开始测试！')\n",
    "    print(f'环境：{cfg.env_name}, 算法：{cfg.algo_name}, 设备：{cfg.device}')\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    for i_ep in range(cfg.test_eps):\n",
    "        ep_reward = 0  # 记录每个episode的reward\n",
    "        state = env.reset(seed=cfg.seed)  # 重置环境, 重新开一局（即开始新的一个回合）\n",
    "        for _ in range(cfg.max_steps):\n",
    "            action = agent.predict_action(state)  # 根据算法选择一个动作\n",
    "            next_state, reward, terminated, info = env.step(action)  # 与环境进行一个交互\n",
    "            state = next_state  # 更新状态\n",
    "            ep_reward += reward\n",
    "            if terminated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        print(f\"回合数：{i_ep+1}/{cfg.test_eps}, 奖励：{ep_reward:.1f}\")\n",
    "    print('完成测试！')\n",
    "    return {\"rewards\":rewards}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3、定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import turtle\n",
    "import numpy as np\n",
    "\n",
    "# turtle tutorial : https://docs.python.org/3.3/library/turtle.html\n",
    "\n",
    "class CliffWalkingWapper(gym.Wrapper):\n",
    "    def __init__(self, env):\n",
    "        gym.Wrapper.__init__(self, env)\n",
    "        self.t = None\n",
    "        self.unit = 50\n",
    "        self.max_x = 12\n",
    "        self.max_y = 4\n",
    "\n",
    "    def draw_x_line(self, y, x0, x1, color='gray'):\n",
    "        assert x1 > x0\n",
    "        self.t.color(color)\n",
    "        self.t.setheading(0)\n",
    "        self.t.up()\n",
    "        self.t.goto(x0, y)\n",
    "        self.t.down()\n",
    "        self.t.forward(x1 - x0)\n",
    "\n",
    "    def draw_y_line(self, x, y0, y1, color='gray'):\n",
    "        assert y1 > y0\n",
    "        self.t.color(color)\n",
    "        self.t.setheading(90)\n",
    "        self.t.up()\n",
    "        self.t.goto(x, y0)\n",
    "        self.t.down()\n",
    "        self.t.forward(y1 - y0)\n",
    "\n",
    "    def draw_box(self, x, y, fillcolor='', line_color='gray'):\n",
    "        self.t.up()\n",
    "        self.t.goto(x * self.unit, y * self.unit)\n",
    "        self.t.color(line_color)\n",
    "        self.t.fillcolor(fillcolor)\n",
    "        self.t.setheading(90)\n",
    "        self.t.down()\n",
    "        self.t.begin_fill()\n",
    "        for i in range(4):\n",
    "            self.t.forward(self.unit)\n",
    "            self.t.right(90)\n",
    "        self.t.end_fill()\n",
    "\n",
    "    def move_player(self, x, y):\n",
    "        self.t.up()\n",
    "        self.t.setheading(90)\n",
    "        self.t.fillcolor('red')\n",
    "        self.t.goto((x + 0.5) * self.unit, (y + 0.5) * self.unit)\n",
    "\n",
    "    def render(self):\n",
    "        if self.t == None:\n",
    "            self.t = turtle.Turtle()\n",
    "            self.wn = turtle.Screen()\n",
    "            self.wn.setup(self.unit * self.max_x + 100,\n",
    "                          self.unit * self.max_y + 100)\n",
    "            self.wn.setworldcoordinates(0, 0, self.unit * self.max_x,\n",
    "                                        self.unit * self.max_y)\n",
    "            self.t.shape('circle')\n",
    "            self.t.width(2)\n",
    "            self.t.speed(0)\n",
    "            self.t.color('gray')\n",
    "            for _ in range(2):\n",
    "                self.t.forward(self.max_x * self.unit)\n",
    "                self.t.left(90)\n",
    "                self.t.forward(self.max_y * self.unit)\n",
    "                self.t.left(90)\n",
    "            for i in range(1, self.max_y):\n",
    "                self.draw_x_line(\n",
    "                    y=i * self.unit, x0=0, x1=self.max_x * self.unit)\n",
    "            for i in range(1, self.max_x):\n",
    "                self.draw_y_line(\n",
    "                    x=i * self.unit, y0=0, y1=self.max_y * self.unit)\n",
    "\n",
    "            for i in range(1, self.max_x - 1):\n",
    "                self.draw_box(i, 0, 'black')\n",
    "            self.draw_box(self.max_x - 1, 0, 'yellow')\n",
    "            self.t.shape('turtle')\n",
    "\n",
    "        x_pos = self.s % self.max_x\n",
    "        y_pos = self.max_y - 1 - int(self.s / self.max_x)\n",
    "        self.move_player(x_pos, y_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import os\n",
    "def all_seed(env,seed = 1):\n",
    "    ''' omnipotent seed for RL, attention the position of seed function, you'd better put it just following the env create function\n",
    "    Args:\n",
    "        env (_type_): \n",
    "        seed (int, optional): _description_. Defaults to 1.\n",
    "    '''\n",
    "    import torch\n",
    "    import numpy as np\n",
    "    import random\n",
    "    # print(f\"seed = {seed}\")\n",
    "    env.seed(seed) # env config\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False\n",
    "    \n",
    "def env_agent_config(cfg):\n",
    "    '''创建环境和智能体\n",
    "    '''    \n",
    "    env = gym.make(cfg.env_name,new_step_api=True)  # 创建环境\n",
    "    env = CliffWalkingWapper(env)\n",
    "    if cfg.seed !=0: # set random seed\n",
    "        all_seed(env,seed=cfg.seed) \n",
    "    try:  # 状态维度\n",
    "        n_states = env.observation_space.n # print(hasattr(env.observation_space, 'n'))\n",
    "    except AttributeError:\n",
    "        n_states = env.observation_space.shape[0]\n",
    "    n_actions = env.action_space.n # 动作维度\n",
    "    setattr(cfg, 'n_states', n_states) # 将状态维度添加到配置参数中\n",
    "    setattr(cfg, 'n_actions', n_actions) # 将动作维度添加到配置参数中\n",
    "    agent = FisrtVisitMC(cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4、设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "class Config:\n",
    "    '''配置参数\n",
    "    '''\n",
    "    def __init__(self):\n",
    "        self.env_name = 'CliffWalking-v0' # 环境名称\n",
    "        self.algo_name = \"FirstVisitMC\" # 算法名称\n",
    "        self.train_eps = 400 # 训练回合数\n",
    "        self.test_eps = 20 # 测试回合数\n",
    "        self.max_steps = 200 # 每个回合最大步数\n",
    "        self.epsilon = 0.1 # 贪婪度\n",
    "        self.gamma = 0.9 # 折扣因子\n",
    "        self.lr = 0.5 # 学习率\n",
    "        self.seed = 1 # 随机种子\n",
    "        # if torch.cuda.is_available(): # 是否使用GPUs\n",
    "        #     self.device = torch.device('cuda')\n",
    "        # else:\n",
    "        #     self.device = torch.device('cpu')\n",
    "        self.device = torch.device('cpu')\n",
    "def smooth(data, weight=0.9):  \n",
    "    '''用于平滑曲线\n",
    "    '''\n",
    "    last = data[0]  # First value in the plot (first timestep)\n",
    "    smoothed = list()\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(rewards,title=\"learning curve\"):\n",
    "    sns.set()\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{title}\")\n",
    "    plt.xlim(0, len(rewards), 10)  # 设置x轴的范围\n",
    "    plt.xlabel('epsiodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5、我准备好了！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始训练！\n",
      "环境:CliffWalking-v0, 算法:FirstVisitMC, 设备:cpu\n",
      "回合：10/400，奖励：-200.0\n",
      "回合：20/400，奖励：-200.0\n",
      "回合：30/400，奖励：-200.0\n",
      "回合：40/400，奖励：-200.0\n",
      "回合：50/400，奖励：-200.0\n",
      "回合：60/400，奖励：-200.0\n",
      "回合：70/400，奖励：-200.0\n",
      "回合：80/400，奖励：-200.0\n",
      "回合：90/400，奖励：-200.0\n",
      "回合：100/400，奖励：-200.0\n",
      "回合：110/400，奖励：-200.0\n",
      "回合：120/400，奖励：-200.0\n",
      "回合：130/400，奖励：-200.0\n",
      "回合：140/400，奖励：-200.0\n",
      "回合：150/400，奖励：-200.0\n",
      "回合：160/400，奖励：-200.0\n",
      "回合：170/400，奖励：-200.0\n",
      "回合：180/400，奖励：-200.0\n",
      "回合：190/400，奖励：-200.0\n",
      "回合：200/400，奖励：-200.0\n",
      "回合：210/400，奖励：-200.0\n",
      "回合：220/400，奖励：-200.0\n",
      "回合：230/400，奖励：-200.0\n",
      "回合：240/400，奖励：-200.0\n",
      "回合：250/400，奖励：-200.0\n",
      "回合：260/400，奖励：-200.0\n",
      "回合：270/400，奖励：-299.0\n",
      "回合：280/400，奖励：-200.0\n",
      "回合：290/400，奖励：-200.0\n",
      "回合：300/400，奖励：-200.0\n",
      "回合：310/400，奖励：-200.0\n",
      "回合：320/400，奖励：-200.0\n",
      "回合：330/400，奖励：-200.0\n",
      "回合：340/400，奖励：-200.0\n",
      "回合：350/400，奖励：-200.0\n",
      "回合：360/400，奖励：-200.0\n",
      "回合：370/400，奖励：-200.0\n",
      "回合：380/400，奖励：-200.0\n",
      "回合：390/400，奖励：-200.0\n",
      "回合：400/400，奖励：-200.0\n",
      "完成训练！\n",
      "开始测试！\n",
      "环境：CliffWalking-v0, 算法：FirstVisitMC, 设备：cpu\n",
      "回合数：1/20, 奖励：-200.0\n",
      "回合数：2/20, 奖励：-200.0\n",
      "回合数：3/20, 奖励：-200.0\n",
      "回合数：4/20, 奖励：-200.0\n",
      "回合数：5/20, 奖励：-200.0\n",
      "回合数：6/20, 奖励：-200.0\n",
      "回合数：7/20, 奖励：-200.0\n",
      "回合数：8/20, 奖励：-200.0\n",
      "回合数：9/20, 奖励：-200.0\n",
      "回合数：10/20, 奖励：-299.0\n",
      "回合数：11/20, 奖励：-200.0\n",
      "回合数：12/20, 奖励：-200.0\n",
      "回合数：13/20, 奖励：-200.0\n",
      "回合数：14/20, 奖励：-200.0\n",
      "回合数：15/20, 奖励：-200.0\n",
      "回合数：16/20, 奖励：-200.0\n",
      "回合数：17/20, 奖励：-200.0\n",
      "回合数：18/20, 奖励：-200.0\n",
      "回合数：19/20, 奖励：-200.0\n",
      "回合数：20/20, 奖励：-200.0\n",
      "完成测试！\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHJCAYAAABpOFaGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB5j0lEQVR4nO3deXzL9+MH8FeSJk3vS7XOGasabVFaurptmGuGbb6oumaYY9iUzVwdcxRzX3XMOZthB7PZZmx+rpYxw9ymQ5W2qmea5PP7I/LRSHonbSqv5+Phof3kk0/e73ya5JX39ZEIgiCAiIiIyAZJy7sAREREROWFQYiIiIhsFoMQERER2SwGISIiIrJZDEJERERksxiEiIiIyGYxCBEREZHNYhAiIiIim8UgVIFYau1LrqlJz4Ly/Dvma4io4mIQqiB++eUXREVFmf248fHxGDZsmPh7QkIC/P39sWvXLrM/Fj0bjh07ho4dOyIgIABDhw41uc+kSZPg7++f77/9+/cDACIiIhAREVHqMq1YsQLr1q0DAHz77bfw9/fHDz/8kO/+69evR7169fDvv/9i0qRJaNeuXZEf6+n9n35t6l9D/v7+2LFjh8ljPHr0CIGBgfD398fx48cNbsvJycHGjRvRq1cvNGnSBKGhoejTpw/27NlTaOBKT0/H8OHD0bBhQ4SEhODGjRtFrldxJCYmYt68eejUqRMaNmyIFi1aYPjw4YiLizPY7+nz6+/vj6VLl4q/7927F23btkVAQACmTp2Ku3fvol+/fggMDERoaCjq1auHOXPmGD3+zJkz4e/vj2nTphndFh0djUaNGkGlUhWpLnnLdPz4cZPnJK927dph0qRJRTp2Wfnrr78QERGBxo0bo0WLFli4cGGR60+AXXkXgIpm48aNFjnuV199hatXr4q/V65cGTt27EDNmjUt8nhU8c2bNw9arRZr1qyBl5dXvvt5e3tj2bJlJm+rVasWAJj8ICuJxYsXY9SoUQCADh06YObMmfjuu+/w6quvmtx/9+7dCA0NRc2aNTFy5EgMGDCgyI/19P75vTalUin279+Pt956y+i2AwcOmPygun//PoYOHYo7d+4gIiICQUFB0Gq1OHjwICZNmoS4uDhER0dDIpGYfMw9e/bg4MGDmDp1Kvz8/FC9evUi16uo4uPj8e6778LDwwMDBgzA888/j9TUVOzYsQMRERH49NNP0aNHD5P33bFjB3x9fcXfZ86ciVq1amHOnDnw8fHB559/jj///BPz58+Hj48P5s2bh9OnTxsd5/fff4e7uzv++OMPo9tOnjyJpk2bQqFQmK3OeS1btgzOzs4WOXZJ3Lp1C4MGDUKjRo3w2Wef4erVq1i0aBFSU1Mxc+bM8i5ehcAgRAYUCgUaNWpU3sUgK5aamoqQkBC89NJLBe5XlL+lF154wYwl01EqlejatSt27tyJhw8fws3NzeD28+fP49KlS5g/fz4AFDv0F3X/4OBgHD9+HMnJyfD09DS4be/evXjxxRdx4cIFg+1RUVG4e/cuduzYIYZFAGjTpg2qVq2KhQsXom3btmjfvr3Jx0xNTQUA9O3bN9+wVBqpqal47733UKtWLWzYsAEODg7ibR07dsSwYcMwdepUtGjRApUqVTK6/9N/D6mpqQgPD0ezZs3E3ytXrozOnTsDAJo3b45169YhJycH9vb2AIB///0X//77LyZMmIAFCxbg2rVrqF27NgAgLS0Nly9fxuuvv272uuvVr1/fYscuibVr18LJyQkrVqyAQqFA69atoVQqER0djeHDh6Nq1arlXUSrx66xCiAiIgInTpzAiRMnDJptU1NTMXXqVLz00ksIDAzEm2++iaNHjxrc98iRI3jzzTfRuHFjhISEYMSIEWIL0KRJk7B79278999/YnfY011ju3btQv369XHmzBm89dZbCAwMRNu2bcVuCL179+5h3LhxCA0NRUhICKZOnYpFixYV2uVw7949REVFISwsDI0bN0b//v3Fb4D5ddM93TURERGB999/H2PGjEGjRo0waNAgdOzYEWPGjDF6vNdeew0jRowQf//555/Rs2dPBAYGIjw8HJ988gkyMzMLLLNGo8HWrVvRrVs3BAUFoU2bNoiJiUFOTo5BGQcOHIivv/5a7EZ67bXXcPjw4QKPDei+1b/++uto2LAh2rRpgwULFoitB0uXLkW7du1w8OBBsVvizTffNGjK37VrF/z9/ZGQkGBw3KI06d+4cQNjxoxBeHg4GjVqhIiICMTHxwN4cj7+++8/7Nmzp9AuhKIw1XWybNky9OzZE0FBQVi2bBm0Wq34txQQEIB27dphwYIFyM3NFe8D6L6p63/u1asXcnNzxS64vHbv3g1XV1d07NgRgPHf07lz5xAZGYkmTZqgcePGGDhwIP7880/x9rz75/faBIBXXnkFUqkUBw4cMHj8lJQUHDt2DF26dDHYfuHCBfzxxx8YMmSIQQjSGzhwIPr16wdHR8d8n0t9F0+9evXEc/3o0SN8+umnePnllxEYGCiGxLzatWuH2bNnIzIyEkFBQfjoo49MPsaePXtw7949fPjhhwYhCNC1gL3//vvo168f0tPTTd5f3w2l74ICgOXLl8Pf3x/t2rXDrl27cPv2bXG/l156Cbm5ufjrr7/EY/z+++9wdXVF//794eDgYNAqFB8fD61WK4b0hIQETJw4ES1atECDBg0QFhaGiRMnIiUlxWT5nqZSqTB48GA0a9ZMDK15X0f618QPP/yAMWPGoHHjxggNDcWUKVMM3kdyc3MRExODVq1aISgoCEOGDBFfQ0+/TvMqyvvYH3/8gdatWxu0gHXq1AlardZkixkZYxCqAKZNm4b69eujfv362LFjBxo0aICcnBxERkbil19+wbhx47Bs2TL4+vpi6NChYhi6desWRo4ciYCAAKxcuRKzZs3C9evXMWzYMGi1WowcORKtW7eGt7c3duzYgTZt2ph8fK1Wi/feew+dO3fGmjVrEBwcjHnz5uH3338HoHuziIyMxKlTp/Dhhx/i008/xcWLF7F+/foC65WRkYH//e9/OH78OD744AMsW7YM9vb2GDx4cLHHNvzwww9wcnLCypUrMXToUHTv3h2HDh0yeEO+evUqLl68iNdeew0A8N133+Hdd99F7dq1sXz5cowaNQrffvstRo4cWeBYjKlTp4ofLCtXrkS/fv2wZcsWo/udO3cO69atw5gxY7B8+XLIZDKMHj0aDx8+zPfYW7duRVRUFBo0aIBly5Zh2LBh2Lx5Mz755BNxn+TkZERFRaFv375YvHgxlEolhgwZYtS6UFxXrlxBz549kZCQgClTpiAmJgYSiQSRkZE4ceKE2G3q7e2N1q1bi3+LBVGr1Ub/ChvnsmrVKnTr1g1LlixBx44dsXbtWmzfvh3vvvsu1q9fj//9739Yt24dVq5cCQDiOJzevXuLP+vH33z33XdG5dm7dy+6desmtjDklZ6ejqFDh8LDwwNLly7FokWLkJWVhSFDhuDRo0dG+5t6beq5uroiPDzcKIz9+OOPqFq1KoKCggy2619P+X15sLe3x9SpUxEWFmby9mnTpqF3797iczJy5EhkZ2ejb9+++O677zB06FCsWLECTZo0wUcffYRVq1YZ3H/r1q0IDAzEihUrxOM87ffff0elSpWMyq5Xr149REVFmQxyeTVo0MDovC1atMjg/eiNN95A48aNoVQqcerUKYMyhIWFwdHRESEhIeLzBui6xby9veHv74+srCwMGDAAV69exbRp07Bu3ToMGDAAe/fuxaJFiwosH6D7Wxk3bhzOnTuH9evX48UXX8x332nTpqFatWpYsWIFhgwZgp07d4p/n4DuPePzzz9H//79sXz5clSqVAkff/xxoWUo7H0sOzsb//33H55//nmD+3l6esLZ2RnXr18v9DGIXWMVwgsvvCD2Seublr/88ktcvHgRX375JRo2bAgAaNWqFSIiIhATE4Ovv/4aZ8+eRXZ2Nt555x34+PgAAHx9ffHLL78gMzMTNWvWhKenp0EXhqnWEEEQMHLkSLzxxhsAgCZNmuDAgQP47bff0LJlS3z77be4du0avv76awQEBADQNWm//PLLBdZL3xq1e/du8U0mODgYPXr0wMmTJ/N9wzdFLpdjxowZ4reimjVrYunSpfj555/F8Qrff/89XF1d0a5dOwiCgJiYGLRs2RIxMTHicWrVqoWBAwfi0KFDJoPhlStXsHPnTkyYMEEcZB4eHo7KlStj4sSJOHz4MFq3bg1A9018165dYleKo6Mj+vfvLw42fppWq8Xy5cvx8ssvGwSfrKws7N27V2wBycrKwvTp08V66Z/rNWvWFOkNPj/Lli2DQqHApk2bxL+3Nm3aoGvXrpg3bx527tyJRo0aQaFQwNPTs9Bur//++89kUMr73JnStGlTDBo0SPx9zpw5CAgIQK9evQAAoaGhcHBwgIuLC4AnrwlfX1+DMvXq1Quffvopbt++LXYPHD58GA8ePMj3g/7KlStISUnBgAEDEBwcDACoXbs2duzYgYyMDPEx9Uy9NvXdUwDw6quv4sMPPzToHtu7d6/Y9ZPXnTt3AKDE43peeOEFcfyNvizbtm3DpUuX8MUXX6Bx48YAgJYtW0KtVmPFihXo06cP3N3dAQBVq1bF+++/X+Bj3L17F9WqVStR+fJydnY2ed6efj8CdO83+iCkUqlw/PhxTJ48GYDutffZZ59BpVJBoVAgLi5ObA26ceMGfH19MXfuXNSoUQOA7rVy5swZnDhxosDyabVaTJo0CcePH8eGDRsKDfytW7cWB8yHhYXhyJEj+O233zBhwgT8+++/2L17N6KiosS/65YtW+L+/fuFtth07969wPcx/ZcqU2OWnJyc8m2ZI0NsEaqgjh49Cm9vbzRo0ED8pq3RaNC2bVucO3cODx8+RMOGDWFvb4/evXtj1qxZ+P3331GvXj2MGzeu2IP99G+iAMQPQn1oOnbsGGrUqCGGIED3wmzbtm2Bx4yPj0f16tUNvmk5ODjgxx9/FENXUdWuXdugabhGjRoIDg7Gvn37xG179+5Fp06doFAocO3aNdy9exft2rUzaK0ICQmBs7Mzjhw5YvJx9G+gT3drdOnSBTKZzKBrxNPT02A8if5DKisry+Sxr1+/jgcPHuCVV14x2D5kyBDs2rULcrkcAGBnZ4euXbuKtyuVSrRq1QonT57M/wkqghMnTqBt27YGfxt2dnbo0qULzp07h4yMjGIdz9vbGzt37jT6V9j4jae/eTdr1gxHjhxB3759ERsbiytXrqB///5iy15+unfvDjs7O3z//ffitj179ogtOKb4+fnB09MTw4cPx9SpU3HgwAFUqlQJH3zwgcEg36J6+eWXIZPJxO6xe/fuIS4uzuD86clkMgC6rldzOXHiBKpVq2bw+gV0z01OTg7OnDkjbiuoxSNvGc1ZvqIICwvD6dOnIQgCTp06hczMTLRo0QIA0KJFC2RlZSE+Ph5ZWVk4f/68GIRefPFFbNu2DdWqVcONGzdw6NAhrFu3DteuXSt0RlVMTAy+++47DBgwAIGBgYWW8ekvBb6+vuL74/HjxyEIAjp16mSwT96/AUEQTLacFvY+ptVqCyyXJcaJPYsYhCqo1NRUJCUloUGDBgb/5s2bBwBISkpC9erVsWXLFjRs2BA7d+7E0KFDER4ejkWLFhV73ROlUmnwu1QqFY+RkpJicvZQQTOK9HUobJ+icnJyMtr22muv4f/+7/+QkpKCv/76Czdv3hQ/PPXf2mfMmGH0HKanp+PevXsmH0f/Dczb29tgu52dHTw8PAy6T54eQ6F/U8rvzUtfpsKek0qVKsHOzrAx18vLy6AloiQePnxocoBrpUqVIAhCsb9dKhQKBAYGGv17+rl72tNjYIYOHYqpU6ciOzsbMTEx6NKlC7p27Ypjx44VeBwPDw+0a9dO7B57+PAhDh48mG9rEKD7O9q6dStat26NH374AaNGjUJYWBimTp1aounIzs7OaNWqldg9tn//frzwwgvw8/Mz2lff0nL79u18j5eYmFis1+7Dhw9NPt/685yWliZuy2/sUV5Vq1YVW67yU9jtxRUWFobU1FRcu3YNv//+O2rXri228OlbwY4fP44///wTubm5CA8PF++7YcMGhIWFoWPHjvjwww9x4sQJo9elKdevX0dISAg+//xzJCYmFrq/qfFS+vOUnJwMwPh1nff3EydOGL0P6b90FfQ+pv/SYupLSnp6ulELJpnGrrEKysXFBbVq1TLo1slL37yuH3CqUqkQHx+PHTt2YNWqVahXr16+U4uLy8fHx+SYngcPHhR4PxcXF5MDBU+dOgU3NzcxfD39DbSwwcx6r776Kj755BP8/PPPuHbtGqpVq4YmTZoA0I3fAICJEyciNDTU6L5PzzR6entSUpJBF0Fubi5SUlLg4eFRpLKZoi+T/o1TLyUlBefPnxe/1ZsKPPfv3xffWPMLXIW16Li5ueH+/ftG25OSkgCgVHUrDalUin79+qFfv3548OABDh06hFWrVmH06NE4cuRIgdOke/fujbfffhuXLl1CfHw8JBIJunXrVuDj1a5dG/Pnz4dGo8HZs2fxzTffYPv27ahZs2a+6yYVpHPnzvjggw+QnJyMffv2GbUm6ulbOQ4dOmRyNp1arcZrr72G4OBgrFixokiP7ebmhps3bxptL+k5bdmyJQ4ePIi//vrLZEvJhQsX0KNHD0yePBkDBw4s1rHzU79+fbi7u+PPP//E0aNHxedJ76WXXkJ8fDykUinq1q0rBr/vvvsOc+bMwQcffICePXuKXZNjx441GHxtSnR0NEJDQ/Hqq69ixowZRX6+TdEPS7h//77BDK68r/MGDRoYDWDXj/sp6H3MyckJPj4+Ruf4wYMHyMjIQJ06dUpcblvCFqEKQio1PFWhoaG4c+cOvLy8DL5tHzlyBLGxsZDJZNi4cSPatm0r9p+HhYUhOjoawJNvnU8ftyRCQ0ORkJBgMFg3OzvbYBCjKU2bNsWtW7dw+fJlcVtOTg5Gjx6NnTt3it928n4jy83NxdmzZ4tULldXV7Rt2xa//PILfvzxR3Tv3l0MCbVr14aXlxcSEhIMnj8fHx8sWLAA58+fz7eugK55Oq+9e/dCo9GIb1AlUbt2bXh4eODgwYMG27/55hsMGzZMHCP09HObnZ2Nw4cPi2Oq9M/b3bt3xX2uXr1aaItRSEgIDh48aNDyo9FosHfvXgQGBlpsXZbC9OnTRxwz5eXlhZ49e6Jfv35IS0sTy5rf33GLFi3g6+uLn376CT/88AM6dOggBk5T9u/fj+bNmyMpKQkymQyNGzfG9OnT4erqmm9LTWGvobZt20KhUGDLli34888/8w1Cfn5+aNWqFdauXYtbt24Z3b569WqkpKSge/fuBT5eXiEhIfjvv/+M1uL59ttvIZfL8x30nJ/u3bvD29sbn376KbKzsw1u02g0iImJgVwuN9uXLED3/DZr1gxHjx7FxYsXjYJQixYtcPHiRZw6dcqgNSg+Ph6urq4YOnSoGIIyMjLEmWUFqVSpEry9vTF+/Hj88ssvBS7OWZgmTZoYdI/q/fTTT+LPzs7ORi2n+tdxQe9jgG6c1G+//WbQYvnjjz9CJpOhefPmJS63LWGLUAXh6uqK06dP4+jRo6hfvz569uyJLVu2YNCgQRg+fDiqVKmC//u//8PatWvRv39/yOVyNG/eHDExMXj33XfRv39/yGQyfPHFF1AoFOL4HVdXV9y/fx+HDh0q0hgBU7p27Yo1a9bg3XffxdixY+Hq6ooNGzbgwYMHBa5h0bNnT2zevBkjRozAmDFj4OHhgU2bNiE3Nxd9+/aFm5sbGjdujM2bN+O5556Dm5sbNm3ahOzs7CI14wO6N+4xY8ZAo9EYjCmRyWQYN24cpk6dCplMhrZt2yItLQ0rVqxAYmJivoMjX3jhBbz++utYsmQJsrKyEBISggsXLmDZsmVo1qwZWrZsWbwnLw/9rLKZM2fCy8sL7dq1w/Xr17FkyRL069fPoJVq8uTJeO+99+Dl5YV169YhMzNTnE7brFkzKJVKzJkzB2PHjkVGRgaWLFkiDorNz6hRo3D48GEMGDAAw4YNg1wux5YtW3Dr1i3ExsaWuF6lFRISgvXr16NSpUpo3LgxEhMTsWHDBoSGhoofcK6urjh16pS4mJ7+g0IqlaJHjx7Ys2cPbt++jQ0bNhT4WMHBwdBqtXj33XcxbNgwODk54YcffsCjR4/QoUMHk/d5+rX5NEdHR7Ru3Rpr1qxBUFCQOHDXlBkzZiAyMhJvvvkmBgwYgIYNGyIjIwP79+/H3r170adPH6OxJgXp2bMntm3bhnfffRdjxoxB9erV8euvv+Lrr7/GqFGjCgyFpri4uGDOnDkYNWoU3njjDfTv3x+1atXC3bt3sXXrVpw9exYLFiwQW0HMpXnz5pg9ezZkMplRC25YWBjS09MRFxeHIUOGiNuDgoKwfft2zJkzB23btsW9e/ewbt063L9/P98W36fpV/SeNWsWXnrppSLfL68aNWqgV69eWLhwIXJzc1GvXj0cOHBA/MJTlC+j+b2PAbqu471792Lo0KEYNGgQbty4gYULF+LNN9/kGkJFxCBUQfTr1w/nzp3D22+/jU8//RTdunXD1q1bsWDBAsyfPx+PHj1CtWrVMGHCBAwePBiAbirrqlWrsHz5cowfPx4ajQYBAQFYv369uABZz549cejQIfGN0tRslsLY2dlh3bp1mDVrFqZPnw47Ozt0794d7u7uBU7fdHZ2xpYtWzBv3jxER0dDq9WiUaNG2LRpk/hhMWfOHERHR2PKlClwdnZG79690aRJE3z11VdFKlvr1q3h4uKCGjVqGE0xfeONN+Dk5ITY2Fjs2LEDjo6OCA4ORkxMTIEfVrNmzcJzzz2Hr7/+GmvXrkXlypUxYMAAjBw5stQtbPp1YtatWyeuwvv222/j7bffNthv+vTpmD17NpKTkxEcHIzt27fjueeeA6D7YF66dCkWLFiAd999F9WqVcOoUaOwZ8+eAh/bz88P27Ztw8KFCzF58mRIJBIEBQVh06ZNaNq0aanqVRpjx46FQqHA119/jeXLl8PFxQXt2rXDhAkTxH2GDx+OFStW4O2338a+ffsMPgB69+6N1atXo0aNGia7QfOqXLkyYmNjsXjxYnz00UfIysqCn58fli5dmu+366dfm08PTAZ03WP79+8v9PVVtWpV7NixA59//jm+//57rFmzBgqFArVr18aCBQuK/fp0cHDA5s2bsWDBAixevBjp6emoXbs2Zs2aVeBYqYK0aNECX331FdavX4/Vq1fj/v37cHd3R0BAAHbs2CHOYjWnsLAw5Obm4qWXXjIaj+Pp6Yn69evj0qVLCAkJEbe//vrrSEhIwNdff41t27bBx8cHrVu3Rt++ffHxxx/j6tWrhXYdSaVSzJw5E7169cLcuXMxe/bsEpX/448/hqOjI9avX4/09HSEhYVhxIgRWL58eZG+1BX0PlanTh2sX78e8+bNE79QDhw40OT6Q2SaRODVAqmULl++jGvXrqFDhw4GTba9e/eGr69vvpdZoOJbunQpli1bhn/++ae8i0JERZCamorDhw+jZcuWBmOy5s6di127dpV6UVIqPbYIUallZmZi7Nix6Nu3L1555RVoNBrs27cP586dK3RdEiKiZ5mDgwNmzZqFF198EZGRkXB0dMSff/6JLVu24J133inv4hHYIkRmsn//fqxbtw5Xr16FIAioX78+RowYYTSwkUqHLUJEFc+FCxfw2Wef4c8//0RWVhZq1qyJPn36oF+/flzrxwowCBEREZHN4vR5IiIislkMQkRERGSzGISIiIjIZjEIERERkc2ymenzgiBAq7W9ceFSqYT1tiGst21hvW2LLdZbKpVYfGadzQQhiUSCtLRMqNUFX2PmWWJnJ4WHhxPrbSNYb9bbFrDetlVvT08nyGSWDULsGiMiIiKbxSBERERENotBiIiIiGwWgxARERHZLAYhIiIislkMQkRERGSzGISIiIjIZjEIERERkc1iECIiIiKbxSBERERENsvsQejOnTsYP348wsPDERISgiFDhuDy5csG+/zwww/o3LkzgoKC0KNHDxw9etTg9pSUFEyYMAEhISEIDQ3FjBkzkJWVZe6iEhERkY0zaxBSqVQYNmwYkpKSsGrVKmzbtg1OTk6IjIxEcnIyAODYsWP44IMP0KdPH+zevRthYWEYNmwYrl69Kh5nzJgxuHnzJjZu3IjFixfj0KFDmD59ujmLSkRERGTeIBQXF4dLly4hJiYGgYGB8PPzw/z585GZmYlff/0VALB27Vq8/PLLGDBgAOrUqYOoqCg0aNAAn3/+OQDg9OnTOHHiBObOnYsGDRogLCwMM2fOxDfffIPExERzFpeIiIhsnFmvPu/n54c1a9bAx8dH3CaV6rJWWloatFotTp06hUmTJhncr1mzZvjpp58A6MKUt7c36tSpI94eGhoKiUSC+Ph4dO7cuURly3qYgtObl0Mo0b0rJgl0z79Wq2W9bUBJ6u1QvS5ebNvFksWyqEeZKuz//V+otYBKpYYg2M4Zl0gkUCjsWG8bYY31lkgkCA+sghequ1nwMSx2aJFZg5C3tzdat25tsG3z5s3Izs5GeHg40tLSkJmZCV9fX4N9KleujLt37wIAEhMTUaVKFYPbFQoF3N3dcefOnRKXzU6rQq1Hp0t8f6Jn0oXTkNV/Dq71mpV3SUrk4J938N2RG+VdDCKb9TAzF9MCm5d3MUqlWEEoISEB7du3z/f2o0ePwtPTU/z9wIEDWLBgAQYOHAh/f38x7CgUCoP72dvbIycnBwCQlZVldPvT+5SE2k6JGz5tAStJ0mVCIoGdTAq1Rst624Ji1vthwjU0VPyL+98tR65jFUhdvMqgkOZ1O+kRAKBBbS/Uq+kOQWs751silcDeXo6cnFzW2wZYY70lEiDkRR+kpGRY7DHc3BzEniVLKVYQ8vHxwb59+/K93c3tSfPY9u3bER0dje7du2PixIkAdGEG0A2qzisnJwcODg4AAKVSaXS7fh9HR8fiFNeAg4sbGvcaBLVaW+JjVDR2dlJ4eDghJSWD9bYBxa33e58dhIf0e9TEA6T/tAIO3SZBIpWVQUnN51GG7r0i5EUftGtclefbBrDe1ldvS5anLL7LFisIyeVyg7E7+Zk/fz5iY2MxaNAgREVFQfK4k8/d3R2Ojo64d++ewf737t0TxxX5+vri559/NrhdpVIhNTUVlStXLk5xiagASgclNj5shSle+4DEy1DF74F9SK/yLlaxpGflAgBcnIxbkYmIisLs7U36EBQVFYVJkyaJIQjQDawKDg7GiRMnDO5z/PhxNG3aFAAQEhKCu3fv4ubNm+Lt+v2bNGli7uIS2SxnBzkeaF2Q6N8bAKA6/T3UCX+Xc6mKJ0MfhBwZhIioZMwahI4fP47Y2FhERESgW7duSEpKEv9lZOj6EAcNGoS9e/diw4YNuHr1KubNm4cLFy4gMjISANCwYUMEBwdj3LhxOHv2LI4dO4apU6eiR48eBrPRiKh0nB3kAIC7Lg0gr9cagIDsg6uhzXxYvgUrBn2LkCtbhIiohMwahL7//nsAupliLVq0MPi3fv16AECLFi0we/ZsbN++Ha+//jqOHTuGVatWiV1uEokEy5YtQ/Xq1REZGYn33nsPrVq14oKKRGbmpNQFoYysXNi/1BdSj2oQstKQ/dtaCIJ1jUHIj9g15igv55IQUUVl1unz0dHRiI6OLnS/Hj16oEePHvne7uXlhSVLlpixZET0NH2LUHpWLiR29lC+PBKZu2ZAk3AOqjP7YN+oazmXsGBarYDMbDWAx2OE1JpyLhERVUS86CqRjXJy0H0PysjWtarIPKrBPrwfAEB1chc0dy/ne19rkJmjFheOdHZg1xgRlQyDEJGNetIipBa3yf1bwa5Oc0DQIuvXVRCy08ureIXSD5RWKmSQ2/GtjIhKhu8eRDYqb9eYnkQigbJlJCSulSGkP0D24fVWs5z/0/Tl1teDiKgkzDpGiIgqDieHJ4Ol85IoHODQfiQyv4mG+sYp5P79CxQBL5dHEQskBiEOlCYqEUGTC0GVBeRmQ8jNfvKzKgtCbjaQmwVBlW3i52wIuVkQ1CooAjpA0SD/K05UBAxCRDbKWWncIqQn864F+2ZvIefoNuQc+wIyXz/IKj1X1kUsEFuEyFaJAUaVqQstqiwIqkzg8f/6bXgcaITcLOBxiHnycxagLf0EA83dSwCDEBFVRHm7xgRBMFj8FADkAa9Ac/sC1DdPI+uXFXB6fTokCofyKKpJGQxCVAEJGjWEnIw8ISbzqSDzZJsuyGSJoSdNnQ1NdiagMf7yUip2CkjkSkDhAIlcCYncAZArIVHk/fnxbYrHvz/+Wer9vHnLUg4YhIhslD5AaLQCslUaONgbvh1IJBIoWw9BxtdTITxMRPYfm6BsO8woMJWX9GwGISp7giA87j7KhJCTASEnE4IqA8jJFH8Wch7fpsrUbRe3ZQIa42tplphcCYnCURdOFA6Pw4oDJArHJ78/DjB5wwzkDo9DzuPtFewag+bGIERkoxRyqXi1+oysXKMgBAASpTOU7Ycj67s5UF85CnW1+pD7tyyH0hrTz3ZjEKKSENSqx0EmHUJ2uu7nx/8jJ0MMMrpwow89upac0l8JVAIonoQYw+Di+Lh1xvFJkFE4QubgBLdKnniUI4FWaq8LMxa+KrutYBAislESiQTODnZITVchPTsXlWC628vOty4UTXpAFbcL2Uc2Q1q5DmQeVcu4tMY4WJoAfVdTOoTsx6EmJx0Qf87Isz3DIPCUumVGageJvSMk9k660GLvpAsx9o6P/3cC8vys2677vyQhxs5OCnsPJ2SmZECwsqvPV3QMQkQ2zNlBrgtCJgZM56Vo1BWa2xeguX0B2b+sgGOPqZDYle8ihuIYISWD0LNC0Kp1YSX7ke7/rEdPfs5O0wWYnEfIyM2COiMN2pwMIDe75A8okepCitIZsHeCxN4ZEuXj/58KMVA4GYYcmdxquompdBiEiGzYk+uNqQvcTyKVQtnuHWTu/Bja5ATkHN0OZcvIsihivjLYImTVxLE02Y+e/Mt6lCfoPII265GuteZx4IEqs2QPJpFAonAClM6Pg4su3Bj8b+/8+Gf9diddywzDjM1jECKyYaYWVcyP1NEdyrbDkPXDAuReOAhZtRchrx1q6SLmi4Oly56gyYWQlaYLLlkPIWSlQZv1MM/vj3QtN48DD7QFB2yTJJLHocUFEgcX3c8OLrrflS6QObnCtVIlZOTKoJU7Pe6acoBEwvEyVDIMQkQ2LL9FFfNjVyMQioadoTqzD9mHN0BW6XlIXb0tWcR8cR0h8xBysx+Hm8ehJjNN/F0fdnS3pZWsxcZOIYaYJ8HGVdc6k3e70hlSpatuvE0B42fs7KRw9HBCTkoG1BwrQ2bAIERkw4rTIqSnCOkJ9d1L0CZeQdavK+HY/UNIpGX7VpKr1kCVq/sQ5AVXjQlaNYTMhxAyU6HNTBV/FjKNW3GgLuagYanscZBxhcTRFRIHV0gd3HRhxsEtT7DRhRuJnb1lKklkJgxCRDZMDELZRQ9CEqkdHNoNR8bXU6G9dw05J76GsvlbliqiSfqp8zKpBA72trMGiqDJFQONNvshHgqZyLp/D+r0lCdBJzNVN96mOGSKp0KNa55/T36XOrjqBhVzXA09QxiEiGyYk4PuLaA4LUIAIHWpBGXrwcg+sAy5Z3+AXdUXYVczyBJFNElfXiel3TPxoSyoVU9abzJSH4caw9YcbWYqkJNhcL8M04fTkcp0IcbRHVInd0gc3Y1CjcTx8e9ypSWrR2TVGISIbJhzMccI5SV/vik09dsj9/wvyP5tLRx7zYTUycPcRTRJDEIVYHyQkJsDISMZ2owU3f/pyRAyUqDNSIaQkQwhPUW39k1Ryex04cbRHUqPSlDLnSEo3SB1fBx2HN11AUfpzAHEREXAIERkw0oyRigv++ZvQZN4GdoH/yL74Bo4dP6gTFa7tZbrjAmqrMeBJgVCerIYbrQZKRDSdWGnyAOMZQpInNzzBBo3MfDoA47U0U3smrKzk8LDwwkpHDRMVCoMQkQ27EkQKsE0ZwASOwUc2o9Exq5p0Ny+ANXp72Df5DVzFtGkspgxJqhzoE1/AOHR/cetOMnQputadfQtOkVezE/uAKmzByROnpA66f6XOHlA6uwpboPC8Zno5iOqaBiEiGyYvmspK0cNjVYLWQlac6TuvlC2GIDs39ZCdWoPZFX8YVe1nrmLaiAjWz9GqORBSMjJeBx0HkCbfj9P6NH9X+QBx/ZOYriROnlC4uyh+98pT/BRmL58CRGVPwYhIhvmpHzyFpCRrYarY8mmosvrhkN9+zzUl44g+9dVcOwdDanSxVzFNFJYi5AgCLrVix/lDTj3oX30AEK6LvhAlVX4A8kdIHXxgsTZC1JnL10rjr41Rx925JweTlSRMQgR2TCZVAoHeztk5aiRkZVb4iAEAMrwCGQmXoX24V1k/xYLh47vWayrJz1TBWdJFnyFO1Bduo8UdRoy7t2BJi1J7MoqykU1JUoXXchxqWT0v9TZS7dqMRE90xiEiGycs4MuCJV0wLSeRK6E8uWRyNwzE5p/zyD3rx+hCOpU4uMJWrVuAHLaPfGfkJYE7aN7eP3BXbzpkQtcBTKu5jeNXKIbcOxSCVLnSk9adlwqQeL8OOiwNYfI5jEIEdk4Zwc5klKzSx2EAEDmVRP2zf+HnCObkXPiK8h860JWuXa++wuqrDxBJwnCI93/2rR7ENIfAILp2VByAFoB0Cjd4OBVBcpKvlAr3AFHT13wcamkG5As41scERWM7xJENs6plFPonyav3w6a2xegvh6HrF9WwvHVCbpLOuQJPNpHutadQgcky+SQunpD4uINqWvlx/+88dn+O7iUYocJfZuiQW0vTiMnohJjECKycU8WVSzZFPqnSSQSKFsNQkbSdQiPkpDx5aSC91e6QOL6OOg8DjySx6FH4uhmclHAf7MeQY3cCrGgIhFZNwYhIhvnrDRvixAASOyd4PDySGR+Pw/Q5OrG5jxuzZG46P7Xt/AUd2q5VhDE6fPlvaAiEVV8DEJENq60q0vnR1a5DpwHLAWkUrNenT4rRw1B0P1cmnWEiIgABiEim+dUiuuNFUZiV/Lp+PnRBzZ7uQxyO15Li4hKh+8iRDZOfwV6fXeTtdOPZXJ24Pc4Iio9BiEiG2eprjFLqUhXnici68cgRGTjKloQspYrzxPRs4FBiMjGPZk1poagH4VsxcriyvNEZDsYhIhsnL6LSa3RQpVr/QsSsmuMiMyJQYjIxikVMsikuoujVoTusXT9GkKcOk9EZsAgRGTjJBJJhRonxDFCRGRODEJE9CQIVYAp9BwjRETmxCBERBZdVNHcOEaIiMyJQYiIKmTXmBMXVCQiM2AQIiI4KR+vLl0BglB6tn5labYIEVHpMQgRUZ4WIXU5l6Rgao0WOSoNAAYhIjIPBiEiqjBdY/rySSSAgz27xoio9BiEiOjJYGkrnzUmDpRWyiGVSMq5NET0LGAQIqIK0yLENYSIyNwYhIiowgQhriFERObGIEREFWYdIQYhIjI3BiEiEoNFZrYaWq31XoE+nWsIEZGZMQgRkbiOkADrHjCd8Xh6vxMvuEpEZsIgRESwk0nhYC8DAGRkW+9aQuKV59k1RkRmwiBERACetLJY84BpzhojInNjECIiAE8GTFtzEOJgaSIyNwYhIgLwJFxY88wxXnmeiMyNQYiIAFSMtYTYNUZE5sYgREQAAGcrHyMkCII4kJtBiIjMhUGIiAA8WZvHWrvGsnI00Dxe48iZ6wgRkZkwCBERAOvvGtNPnVfIpZDbycq5NET0rDB7ELpz5w7Gjx+P8PBwhISEYMiQIbh8+bJ4u1arRWxsLDp27IhGjRqhS5cu+OqrrwyOkZCQgHfeeQfBwcFo0aIFPvvsM2g0GnMXlYjysPYglJHnyvNEROZi1iCkUqkwbNgwJCUlYdWqVdi2bRucnJwQGRmJ5ORkAMDq1auxevVqjB07Ft9++y0GDBiA6dOnY8+ePQCA3NxcDBkyBADwxRdfYPr06di+fTuWL19uzqIS0VOeBCHrXFCRU+eJyBLM2tEeFxeHS5cu4fDhw/Dx8QEAzJ8/H82aNcOvv/6K3r17Y/v27Rg8eDA6d+4MAKhZsybOnDmDr776Cj169MCPP/6I27dv48svv4Sbmxvq1q2LBw8eYN68eRg+fDgUCoU5i0xEj4kXXrXSS2xwxhgRWYJZg5Cfnx/WrFkjhiAAkEp1jU5paWnQarWYO3cunn/+eYP7SaVSpKWlAdCFqQYNGsDNzU28vXnz5khPT8eFCxfQsGHDEpdPJrOtIVH6+rLetqG09XZz1n3JyMjKhZ2d9T13mSpdS5WLo9ygfDzfrLctsNV6SySWfwyzBiFvb2+0bt3aYNvmzZuRnZ2N8PBwSKVShIWFGdx++/Zt7N27F3369AEA3L17F76+vgb7VK5cGYBu/FFpgpCrq0OJ71uRsd62paT1Vih1QUil1sLRWQl7uXUNSNYIundEL3dHeHg4Gd3O821bWG8yl2IFoYSEBLRv3z7f248ePQpPT0/x9wMHDmDBggUYOHAg/P39jfa/f/8+3n77bXh5eWHEiBEAgOzsbLi6uhrsZ29vDwDIyckpTnGNpKVlQaPRluoYFYlMJoWrqwPrbSNKW29BECCTSqDRCki4nQpPV6UFSllySckZAAC5FEhJyRC383yz3rbAVuvt5uYg9ixZSrGCkI+PD/bt25fv7Xm7s7Zv347o6Gh0794dEydONNr32rVrGDZsGDQaDTZt2iSGH6VSCZVKZbCvPgA5OjoWp7hGNBot1Grb+QPSY71tS2nq7aS0Q1pmLlIf5cDV0brG4z3K1I0RcrS3M1k/nm/bwnrbBkGw/GMUKwjJ5XLUqVOn0P3mz5+P2NhYDBo0CFFRUZA81ckXHx+PESNGwMfHB7GxsQZjinx9fXHp0iWD/e/duwcABvsRkfk5OciRlplrlYsq8jpjRGQJZm9v0oegqKgoTJo0ySgEnT17FkOHDoWfnx+2bt1qFG5CQkJw/vx5pKeni9uOHTsGJycn1KtXz9zFJaI8xCn02dY3hZ7T54nIEswahI4fP47Y2FhERESgW7duSEpKEv9lZGRArVbj/fffh5eXF+bMmYOcnBzxdv06Qy+//DK8vb3x3nvv4eLFi/j555+xcOFCDB48mFPniSzMmhdV5PR5IrIEs84a+/777wHoZopt3rzZ4LZRo0YhPDwcN2/eBKALPHlVq1YNv/76K+zt7REbG4sZM2bgzTffhJubG/r27YuRI0eas6hEZIKTFQchdo0RkSWYNQhFR0cjOjq6wH3++eefQo/z3HPPYf369eYqFhEVkb61xdrGCKk1WmSrdJfZYYsQEZmTba3MREQFclJa5xXoMx6PWZJAN2uMiMhcGISISGStY4T05XFU2kEqLYOlZonIZjAIEZHoyawx6wpCHChNRJbCIEREImu9Aj2nzhORpTAIEZHIyUoHS3PGGBFZCoMQEYnEWWPZudCWxdr2RcSuMSKyFAYhIhLpg4YgAJlWtLo0u8aIyFIYhIhIZCeTwl4hA2Bd3WNi15iSU+eJyLwYhIjIgLPS+qbQs0WIiCyFQYiIDOQdJ2Qt9AsqcrA0EZkbgxARGXBy0HU/WVOLEAdLE5GlMAgRkQFrXEuIXWNEZCkMQkRkwNquQC8IAoMQEVkMgxARGdAPlraWWWPZKg00Wt2aRhwjRETmxiBERAas7cKr+kAmt5PCXi4r59IQ0bOGQYiIDFhbENJfAJbdYkRkCQxCRGTA2q439mQxRQYhIjI/BiEiMiC2CFnJOkJPBkpzVWkiMj8GISIy4Gxl6whlZHExRSKyHAYhIjKgDxyqXC1y1ZpyLg0XUyQiy2IQIiIDDvZ2kEh0P1vDoopcQ4iILIlBiIgMSCUScWCyNQyY1o9V4mBpIrIEBiEiMmJNU+jZIkRElsQgRERGrCkIcYwQEVkSgxARGbGmKfRsESIiS2IQIiIjTo+n0FvFGCFx+jzXESIi82MQIiIj1tI1ptFqkZXDdYSIyHIYhIjIiLUEoYw80/edlGwRIiLzYxAiIiNPrjdWvusIZTweo+RobweZlG9XRGR+fGchIiPOSusYLM2B0kRkaQxCRGTEWq5AL155nkGIiCyEQYiIjFjLGCG2CBGRpTEIEZER5zxjhARBKLdy6McoOXPqPBFZCIMQERnRBw+tIIjT18sDu8aIyNIYhIjIiNxOBoVc9/ZQnt1j7BojIktjECIik56MEyq/FiH9YG1eeZ6ILIVBiIhMEqfQs0WIiJ5hDEJEZJI1TKHXr2PEIERElsIgREQmWcMV6DPYIkREFsYgREQmlXeLkCAIvPI8EVkcgxARmaSfQl9eY4RUuVqoNdrHZWGLEBFZBoMQEZlU3oOl9Y9rJ5PAXi4rlzIQ0bOPQYiITCrvrrG8iylKJJJyKQMRPfsYhIjIpPJeR4gzxoioLDAIEZFJ5X3hVXHGGBdTJCILYhAiIpPKe/o8rzNGRGWBQYiITNIHkByVRpy9VZaerCrNqfNEZDkMQkRkkqPSDvohyuXRPcYWISIqCwxCRGSSVCKBo1LXGlMeM8cyHg/S5mBpIrIkBiEiyld5DpjOyOZgaSKyPAYhIspXeU6h55XniagsMAgRUb7ERRXLYeYYxwgRUVlgECKifJVr1xhbhIioDDAIEVG+yisIabUCMrM5WJqILI9BiIjy5VROQSgjOxfC45/1M9eIiCzB7EHozp07GD9+PMLDwxESEoIhQ4bg8uXLJvdVqVTo1q0bJk2aZLA9JSUFEyZMQEhICEJDQzFjxgxkZWWZu6hEVAjncrrwqj54OdjLYCfj9zUishyzvsOoVCoMGzYMSUlJWLVqFbZt2wYnJydERkYiOTnZaP958+bh0qVLRtvHjBmDmzdvYuPGjVi8eDEOHTqE6dOnm7OoRFQE5dU1pl9DyIlT54nIwswahOLi4nDp0iXExMQgMDAQfn5+mD9/PjIzM/Hrr78a7Pv777/jhx9+gJ+fn8H206dP48SJE5g7dy4aNGiAsLAwzJw5E9988w0SExPNWVwiKoSzfkHF7LKdPs8rzxNRWTFrEPLz88OaNWvg4+Pz5AGkuodIS0sTtyUnJ2Py5MmIjo6Gh4eHwTHi4uLg7e2NOnXqiNtCQ0MhkUgQHx9vzuISUSHKbYwQZ4wRURkx6yhEb29vtG7d2mDb5s2bkZ2djfDwcHHbRx99hLZt26Jdu3bYsGGDwf6JiYmoUqWKwTaFQgF3d3fcuXOnVOWT2dhYA319WW/bYIl6uznbA9AFE5lMAolEUsg9zCMzR9cC5eKogJ1dwfXh+Wa9bYGt1rss3nKKFYQSEhLQvn37fG8/evQoPD09xd8PHDiABQsWYODAgfD39wcAfPHFF7h69SoWLFhg8hhZWVlQKBRG2+3t7ZGTk1Oc4hpxdXUo1f0rKtbbtpiz3g5OuiCk0QpQOtrDsYzG7KgfTxnz8nCAh4dTke7D821bWG8yl2IFIR8fH+zbty/f293c3MSft2/fjujoaHTv3h0TJ04EAFy7dg3z58/HunXr4OjoaPIYSqUSKpXKaHtOTk6+9ymqtLQsaDTaUh2jIpHJpHB1dWC9bYSl6i23kyJXrUXC7Yfw9iibN+H7KZm6x5ZKkJKSUeC+PN+sty2w1Xq7uTmIQ2wspVhBSC6XG4zdyc/8+fMRGxuLQYMGISoqSmxO37dvHzIyMjBo0CBx3+zsbJw6dQo//vgjTp8+DV9fX/z8888Gx1OpVEhNTUXlypWLU1wjGo0WarXt/AHpsd62xdz1dnaQI+VRDlLTc+DhYm+24xbkUYbuy5CjvV2R68LzbVtYb9sgCIXvU1pmX6lMH4KioqIwePBgg9v69++Pbt26GWx7//334evri/fffx8AEBISgpiYGNy8eRPPPfccAODEiRMAgCZNmpi7uERUCCelLgiV5VpCT64zxsUUiciyzPouc/z4ccTGxiIiIgLdunVDUlKSeJujoyPc3d3h7u5ucB+lUgknJycx9DRs2BDBwcEYN24cpk+fjszMTEydOhU9evQwmI1GRGXD+XEYKcuZY/qr3TtzHSEisjCzBqHvv/8egG6m2ObNmw1uGzVqFEaPHl3oMSQSCZYtW4YZM2YgMjIS9vb26NSpEyZPnmzOohJREZXHoor6q93zyvNEZGlmDULR0dGIjo4u1n2eDkwA4OXlhSVLlpirWERUCuURhNK5jhARlRHbWpCAiIpN3ypTVqtLq3I1yH08GJRBiIgsjUGIiAqkv95XWQ2W1rcGyaQSKBWyMnlMIrJdDEJEVKCy7hp7MmNMXmYrWROR7WIQIqIClXUQ4nXGiKgsMQgRUYHKvEUoWz91nmsIEZHlMQgRUYH0ixrqp7RbWt6uMSIiS2MQIqIC6VuEsnI0UJfBNY4YhIioLDEIEVGBnJRy6Icsl8UUeo4RIqKyxCBERAWSSiVwVJbdZTa4mCIRlSUGISIqlLioYhkEIbYIEVFZYhAiokKV5aKK6frrjPGCq0RUBhiEiKhQZTmFXrzyvAOnzxOR5TEIEVGh9KEkvQym0LNrjIjKEoMQERXKqYxahLSCIK5XxCBERGWBQYiICuVcRoOlM7PVEATdz1xHiIjKAoMQERXqyRghy64jpA9a9goZ7GR8eyIiy+M7DREVqqwGS4trCHHGGBGVEQYhIipUWa0jxMUUiaisMQgRUaH0LTRl1iLEqfNEVEYYhIioUOJg6excCPrRzBagv5YZB0oTUVlhECKiQjk9bqFRawTk5Gos9jjsGiOissYgRESFspfLYCfTXYPekt1jXEyRiMoagxARFUoikeQZMG25KfT6kMWuMSIqKwxCRFQkZTGFnl1jRFTWGISIqEjKYuYYu8aIqKwxCBFRkZRJi9Dj64w5cUFFIiojDEJEVCRlsagi1xEiorLGIERERWLpFqFctQaqXK3BYxERWRqDEBEViRiEsi0ThPQXdJVKJHCwZ4sQEZUNBiEiKhL9ooqWmj6fIU6dt4NEIrHIYxARPY1BiIiKxNKzxjh1nojKA4MQERWJpQdLczFFIioPDEJEVCSWHiytH3vkzKnzRFSGGISIqEj0QSgzRw2NVmv243MxRSIqDwxCRFQkTnnW9snINv+A6fQ8g6WJiMoKgxARFYlMKhWntVtinBAHSxNReWAQIqIi06/4bIlxQvpp+RwsTURliUGIiIrMkgOmxRYhDpYmojLEIERERfZkCr35xwhlZLNrjIjKHoMQERWZJRdV5BghIioPDEJEVGRii5CZrzcmCALHCBFRuWAQIqIis9QYoawcNbSCYPAYRERlgUGIiIrMUkFIfzx7uQxyO74tEVHZ4TsOERXZkyvQmzsI6brFnLmYIhGVMQYhIioyS7cIOXHqPBGVMQYhIioySwWhDF55nojKCYMQERXZk+nzagiPBzebA6fOE1F5YRAioiLTt9ioNVqocs13BXoGISIqLwxCRFRkSoUMMqkEgHnXEtIfi11jRFTWGISIqMgkEokYVsw5TogtQkRUXhiEiKhYLDFgOkMMQpw+T0Rli0GIiIrFWakLK+ZtEdKvI8QWISIqWwxCRFQsT65Ab/6uMY4RIqKyxiBERMViia6x9MeDpZ25oCIRlTEGISIqlidBSG2W46k1WuSoNADYIkREZY9BiIiKxdwtQvrjSCSAo5KDpYmobJk9CN25cwfjx49HeHg4QkJCMGTIEFy+fNlgn7Nnz6Jfv34ICgpC69atsWTJEmi1TxZny8nJwYwZMxAWFobGjRtjwoQJSE5ONndRiagExDFCZlpHKO91xqQSiVmOSURUVGYNQiqVCsOGDUNSUhJWrVqFbdu2wcnJCZGRkWKQuX79OgYMGIA6derg22+/xYcffoiNGzdi3bp14nGmT5+OP/74A0uXLsXnn3+Oa9euYcyYMeYsKhGVkLOZB0vzOmNEVJ7M2g4dFxeHS5cu4fDhw/Dx8QEAzJ8/H82aNcOvv/6K3r17Y/Xq1XjhhRcwY8YMSCQS1KpVC//88w9OnToFAEhMTMSePXuwatUqNG3aFACwcOFCdOrUCadPn0bjxo3NWWQiKibzd43pp86zW4yIyp5Z33n8/PywZs0aMQQBgFSqa3RKS0sDAPzxxx8YOnQoJHmawPO29sTHxwMAmjdvLm57/vnn4ePjg5MnTzIIEZUzJzOvI5TBGWNEVI7MGoS8vb3RunVrg22bN29GdnY2wsPDkZ6ejqSkJLi4uODDDz/E4cOH4erqih49emDIkCGQyWRITEyEh4cH7O3tDY5TuXJl3L17t1Tlk8lsa2y4vr6st20oq3q7uehem5nZakilEkilpRvXk5mjaxFycVLAzq74Zef5Zr1tga3WuyyGDRYrCCUkJKB9+/b53n706FF4enqKvx84cAALFizAwIED4e/vLwaZuXPnYsCAAVi7di0uXLiAWbNmITMzE++99x6ysrKgUCiMjm1vb4+cnJziFNeIq6tDqe5fUbHetsXS9XZ20R1fACBXKuDqZPx6LQ7143kSlTwc4eHhVOLj8HzbFtabzKVYQcjHxwf79u3L93Y3Nzfx5+3btyM6Ohrdu3fHxIkTdQ9mp3u4l156CaNGjQIAvPjii0hOTsby5csxduxYKJVKqFQqo2Pn5OTAwaF0fwBpaVnQaLSF7/iMkMmkcHV1YL1tRFnWW6mQIVulQcKdVFTxKnl4AYD7KZkAADsJkJKSUez783yz3rbAVuvt5uYgDrGxlGIFIblcjjp16hS63/z58xEbG4tBgwYhKipKHA+k7/KqW7euwf5+fn7IzMxEcnIyfH19kZqaCpVKZdAydO/ePYOxRyWh0WihVtvOH5Ae621byqLezg5yZKs0eJiugrdb6b6gPMrUffFxsLcrVbl5vm0L620bBMHyj2H2mKUPQVFRUZg0aZLBoGiZTIbg4GCcOXPG4D7//PMPXF1d4e7ujiZNmkCr1YqDpgHdlPvExESEhISYu7hEVAJOZpw5li5eeZ6DpYmo7Jk1CB0/fhyxsbGIiIhAt27dkJSUJP7LyNA1eY8YMQK///47li5din///Rf79u3DmjVrEBkZCZlMBh8fH3Tp0gVTpkzB8ePHcfbsWYwfPx6hoaFo1KiROYtLRCVkzrWExCDEVaWJqByY9Z3n+++/B6CbKbZ582aD20aNGoXRo0ejWbNmWL16NRYtWoTVq1fD29sbw4YNw9ChQ8V9o6OjMXv2bHEcUatWrTBlyhRzFpWISsGcawlxQUUiKk9mDULR0dGIjo4udL+WLVuiZcuW+d7u6OiITz75BJ988ok5i0dEZqJf86e0l9kQBAEZ2foFFRmEiKjs2daCBERkFk4O+kUVS3cF+myVBhqtbjQkgxARlQcGISIqNnMNltbfX2EnhUIuK3W5iIiKi0GIiIrNXIOl0zk+iIjKGYMQERWbuQZLZ3DqPBGVMwYhIio2cwUhsUWIU+eJqJwwCBFRsTmZuWuMLUJEVF4YhIio2PTT51VqLVS5mhIfh0GIiMobgxARFZuDvQwyqe7yOaXpHst4PP2eg6WJqLwwCBFRsUkkEnFcT2mCUHo2W4SIqHwxCBFRiYjjhLJLvqgiZ40RUXljECKiEjHHgGmuI0RE5Y1BiIhKRD9gulRdY2wRIqJyxiBERCVijrWEMjhGiIjKGYMQEZVIaYOQWqNFVo5u6j0XVCSi8sIgREQlor8CfUnHCOkHWUsAOCnZIkRE5YNBiIhKpLQtQvr7OSrtIH28JhERUVljECKiEhGDUHYJW4Q4Y4yIrACDEBGVyJMWoZKtI8QZY0RkDRiEiKhESruOEBdTJCJrwCBERCXiLK4snQutIBT7/vouNQ6UJqLyxCBERCWiDzCCAGTlFL97jF1jRGQNGISIqETkdlLYy2UASjZz7EnXGNcQIqLywyBERCWmDzElCUL6QdZsESKi8sQgREQlVpoB07zgKhFZAwYhIiqx0iyqyHWEiMgaMAgRUYmVZi0hcbA0Z40RUTliECKiEnMqYYuQIAicNUZEVoFBiIhKTN+aU9wxQtkqDTRa3dpDDEJEVJ4YhIioxPIuqlgc+v3tZFIo5HwbIqLyw3cgIioxpxJOn88Qp87bQSLhleeJqPwwCBFRiZV01hjHBxGRtWAQIqISK+k6QgxCRGQtGISIqMRKOn1eXEyRU+eJqJwxCBFRiemDUE6uBrlqbZHvx8UUichaMAgRUYk52NtBP9a5OOOE2DVGRNaCQYiISkwqkYjdW8UZJ5SezSBERNaBQYiISqUkM8eeXHDVziJlIiIqKgYhIiqVkiyq+GQdIbYIEVH5YhAiolIpSYtQBscIEZGVYBAiolJxUhZ/dWkOliYia8EgRESl8mRRxaKtJaTRapGZoza4LxFReWEQIqJSKW7XWEb2k8Ckb00iIiovDEJEVCrFDkKP93Owt4NMyrcgIipffBciolIRg1ARZ409GR/E1iAiKn8MQkRUKsW98CoHShORNWEQIqJSKW7XWDqvM0ZEVoRBiIhKxTnPrDFBEArdn4spEpE1YRAiolLRj/XRCgKycjSF7q9fgdpZySBEROWPQYiISkVuJ4NCrnsrKcqAaY4RIiJrwiBERKVWnCvQc4wQEVkTBiEiKrXiDJjmdcaIyJowCBFRqRUnCD1pEeI6QkRU/hiEiKjUnEoQhNgiRETWgEGIiErNuYiLKgqCgHT99HnOGiMiK8AgRESlpp9CX1iLkCpXC7VGC4CDpYnIOjAIEVGp6Vt3CgtC+ttlUgmUCpnFy0VEVBizB6E7d+5g/PjxCA8PR0hICIYMGYLLly8b7LN371507doVDRs2ROfOnbFnzx6D21NSUjBhwgSEhIQgNDQUM2bMQFZWlrmLSkRmUtTrjeUdHySRSCxeLiKiwpg1CKlUKgwbNgxJSUlYtWoVtm3bBicnJ0RGRiI5ORkAcOzYMUycOBH9+/fH999/j379+mHy5Mk4dOiQeJwxY8bg5s2b2LhxIxYvXoxDhw5h+vTp5iwqEZnRkyvQqwvcT1xVmt1iRGQlzBqE4uLicOnSJcTExCAwMBB+fn6YP38+MjMz8euvvwIAfvnlF/j7+6NPnz6oUaMG+vXrh3r16uH3338HAJw+fRonTpzA3Llz0aBBA4SFhWHmzJn45ptvkJiYaM7iEpGZFLdFiOODiMhamDUI+fn5Yc2aNfDx8XnyAFLdQ6SlpQEAvLy8cPnyZRw7dgyCIOD48eO4evUqgoKCAOjClLe3N+rUqSMeIzQ0FBKJBPHx8eYsLhGZSVHXEeJiikRkbcy6opm3tzdat25tsG3z5s3Izs5GeHg4ACAiIgJnz55FZGQkZDIZNBoNhg8fju7duwMAEhMTUaVKFYNjKBQKuLu7486dO6Uqn0xmW2PD9fVlvW1DedbbzVkBAMhWaQAJYJdPGTJzdF1nLo5y2NmZp5w836y3LbDVepfFUMJiBaGEhAS0b98+39uPHj0KT09P8fcDBw5gwYIFGDhwIPz9/QHoBlOnpKRg6tSpCA4OxrFjx7Bo0SLUqFEDvXv3RlZWFhQKhdGx7e3tkZOTU5ziGnF1dSjV/Ssq1tu2lEe9Xd0cIZEAggDYKeTwcFWa3C9X0P1fycMRHh5O5i0Dz7dNYb3JXIoVhHx8fLBv3758b3dzcxN/3r59O6Kjo9G9e3dMnDhR3D569Gh07doV/fr1AwC8+OKLePjwIebPn4+ePXtCqVRCpVIZHTsnJweOjo7FKa6RtLQsaB6vYWILZDIpXF0dWG8bUd71dlTKkZGVi4S7DwGNxuQ+D1IyAQB2EiAlJcMsj1ve9S4vrDfrbQvc3BzEITaWUqwgJJfLDcbu5Gf+/PmIjY3FoEGDEBUVJU6TTU5OxrVr1xAYGGiwf6NGjbBy5UqkpqbC19cXP//8s8HtKpUKqampqFy5cnGKa0Sj0UKttp0/ID3W27aUV72dlXbIyMrFw0c58PUw/aXlUaZujJCDvZ3Zy8jzbVtYb9sgCJZ/DLPHLH0IioqKwqRJkwzWCnFzc4ODgwP++ecfg/v8888/cHV1haenJ0JCQnD37l3cvHlTvP3EiRMAgCZNmpi7uERkJk8GTOc/hZ7XGSMia2PWwdLHjx9HbGwsIiIi0K1bNyQlJYm3OTo6wsnJCQMGDMDKlSvh7e2NJk2aID4+HqtXr8a7774LAGjYsCGCg4Mxbtw4TJ8+HZmZmZg6dSp69OhhMBuNiKyLOIU+O/+ZYwxCRGRtzBqEvv/+ewC6mWKbN282uG3UqFEYPXo0xo4dCw8PD6xevRp37txB9erV8cEHH6BPnz4AAIlEgmXLlmHGjBmIjIyEvb09OnXqhMmTJ5uzqERkZkW58GoG1xEiIitj1iAUHR2N6OjoAveRyWQYNGgQBg0alO8+Xl5eWLJkiTmLRkQWVthaQlqtgMzHK0+zRYiIrIVtLUhARBbjpCz4CvSZOWoIT+1LRFTeGISIyCwKaxHSb1cqZPkuuEhEVNb4bkREZlHY9cY4UJqIrBGDEBGZRWFXoOcFV4nIGjEIEZFZFNY1xguuEpE1YhAiIrPIO31eMLEcLLvGiMgaMQgRkVnou7w0WkF3FfqniEFIySBERNaDQYiIzMJeLoPcTveWYqp77Mliipw6T0TWg0GIiMzGuYDLbKRzMUUiskIMQkRkNk7K/AdMc7A0EVkjBiEiMhtnh/xXl+ZgaSKyRgxCRGQ2TxZVNF5LiOsIEZE1YhAiIrMpaC0hXnmeiKwRgxARmU1+QUiVq4FKrdXtw+nzRGRFGISIyGz0g6Wfvt6YPhjJpBI42MvKvFxERPlhECIis8mvRUgcH6S0g0QiKfNyERHlh0GIiMwmvyDE8UFEZK0YhIjIbPJbUDGDiykSkZXiWvd5aLVaaDTG034rKq1WguxsGVSqHGg0xhfBfFY9XW+ZzA5SKTN/WXAS1xEyfB1xDSEislYMQgAEQUBaWjKystLLuyhmd/++FFqttryLUeaerreDgzNcXT05PsXC9F1fWTlqaLRayKSG1x5j1xgRWRsGIUAMQc7OHlAo7J+pD0uZTGJTrUF6+noLggCVKgfp6SkAADc3r3Iu2bPNSfnkLSUjSw1XJwUAXnmeiKyXzQchrVYjhiBnZ9fyLo7Z2dlJoVbbXotQ3norFPYAgPT0FLi4eLCbzIJkUikc7e2QmaNGelauGIR45XkislY2/4mg0WgAPPmwpGeT/vw+S2PArJWpmWMcI0RE1srmg5Des9QdRsZ4fsvOk+uN5QlC2QxCRGSdGISIyKxMtwhx+jwRWScGISIyK2f9FPo8awlxQUUislYMQlQuRo0ahlmzppd3McgCnJ5qEdIKgrjAIluEiMjaMAgRkVmJq0s/7g7LylFDEAxvIyKyFgxCRGRWzk8Nlta3DNkrZLCT8S2HiKwLF/XIhyAIUOWW3/o7Crm02DOdWrRoikGD3sa+fd9Brc7FsmVrUb16NaxcuRw//fQDMjLS8fzzdTB06HCEhjbH1atXEBnZB+vWbYG/fz0AwOTJ7+PUqZPYt+9XyGQyaLVadO/eAaNHj0fHjp3x3Xd7sHPnF7h16xakUgnq1q2HMWPGo169+gCA3r27oU2b9jh27AhSUpLxySfz0KBBIFatWoqfftqP3FwVXnutFwTBcJHHbds2Y8+enUhKuodKlbzRpUt3REYO4WyvCshJadg1xsUUiciaMQiZIAgCPt1yClf+e1huZXihuhsm9wsudhDYvfsrxMQsgVqtQY0aNTFz5hRcv34NU6dGw9u7Mo4cOYyJE9/D7NkxeOmlFqhSpSpOnjwGf/960Gg0OH06DpmZmbh06SJefLEBzp//G48ePUJYWAscOnQQixbNQ1TUFDRs2Bj379/HZ5/Nx5w5n2Djxm1iGXbt+hJz5y6Ci4sLatd+AZ99Nh9HjvyOjz6aBh+fKti0aT3OnDmNqlWrAQD++OMwNm/egJkzZ6NGjVr4+++z+OSTaahSpSo6duxs1ueVLE+cNfZ4XBAXUyQia8Z3pvxU0IaIjh07i60zCQm38NNP+7Fhw1b4+fkDAPr06Y8rVy5j27ZNeOmlFggPb4mTJ4+jf/+BuHDhb9jZyREQEIhTp+Lw4osNcPToH2jYsDFcXV3h5uaGSZM+RocOrwIAfH2roGvX7li4cJ5BGZo3D0dISDMAQGZmBn744XtMmBCFsLAWAIDJk6fi1Kk4cf/btxOgUMjh61sVvr6+8PX1RaVKleHj42vx54vM7+np81xMkYisGYOQCRKJBJP7BVe4rjEAqF69pvjzpUv/AABGjhxqsI9arYazswsAIDy8Jb79djdycrJx8uRxNGnSFL6+VREfH4d+/SJx9Ogf6NSpKwCgUaNg3LhxHRs3xuLmzRtISPgXV69eMbqoa/XqNcSf//33JnJzc1GvXgNxm729PerW9Rd/79ChM/bu/Rb/+19P1KpVGyEhzdCmTXv4+jIIVUT6lp+MrFwIgsA1hIjIqjEI5UMikcBeISvvYhSbvf2TS4UIgi6gLF++Fo6OTgb76a+31bhxU8jlcpw+fQpxcSfQsWNnVKlSBbt2fYm7d+/g8uVLmDWrNQDgp5/2Y9asaejQ4VUEBAThtdd64tq1q1i4cG6+ZdA3renLomdn9+RPz93dHRs2bMO5c2dx8uRxHD9+FF99tR1DhryDQYPeLt0TQmVOH3jUGgE5uRpeeZ6IrBqncDzDnn++DgDgwYP7qF69hvhv795vsW/fdwB0gSQ0NAx//HEI58+fQ5MmIQgKagSNRoN161ajdu0XUKVKVQDA1q0b0a1bD3z00XT06vUmGjUKxn//JQCA0eBnvZo1n4NCYY+zZ8+I29RqNS5fviT+/tNPP2D37p0ICmqEIUPewZo1usf55ZefLPK8kGXZy2Wwk+kCcHpWrjhGiIOlicgaMQg9w2rXroPw8JaYP/9T/PHHYfz3XwK2bv0cW7ZsRLVq1cX9WrRohX37vkOlSt6oVq067O2VCAgIwo8/7kPLlq3F/SpX9sFff53BP/9cxH//JWDHjq3YtetLAIBKpTJZBkdHR/Tu/SbWr1+NQ4d+xc2bNxAT8ynu308S91GpcrB8+WLs378Xd+7cxpkzf+L06VMICAiy0DNDliSRSPJcb0zNMUJEZNXYNfaMmzVrDlasWIb582fj0aM0VK1aHZMmfYxXX+0q7hMWFg6NRoPg4KbitqZNQ3HqVBxatHgShMaNm4h582Zh1KhhUCjkeOGFupgyZQamTfsQFy+eR8OGjU2W4Z13RkGhsMfChXORmZmJdu1eQXh4K/H2rl174OHDh9i4MRb37iXCxcUFbdq0x4gRYyzwjFBZcHaQ42G6CulZuQxCRGTVJEJ+fRrPoJSUDKjVhmNVcnNVePDgDry8qkAuV5RTySzHzk5qVGdb8HS9n/XzDOjq7OHhZPLvvKzN3XoK/9xKxfDXGmDfsZv4NzEd773REEF1vMz+WNZU77LEerPetsDT0wkyCy/Eyq4xIjK7vFPoM9giRERWjEGIiMxOP4Ve1zWmNthGRGRNGISIyOz0g6VT01XIydUAYIsQEVknBiEiMjt96ElMzgQASCSAgz1bhIjI+jAIEZHZ6dcMSkzRBSEnpRxSXkCXiKwQgxARmZ2+RSg5LcfgdyIia8MgRERm9/TlNBiEiMhaMQgRkdk9HXwYhIjIWjEIEZHZPR18OHWeiKwVgxBZlFqtxo4dW8Xf161bjd69u5n9cSx1XCqZp4MPW4SIyFoxCJFFHTiwH0uXLirvYlAZk0mlcLCXib878crzRGSlGITIomzoUnb0lLzhhy1CRGSt2HGfD0EQALWq/Apgp4CkBOuuHD16BLGxq3DjxjU4ODjipZdaYNSocbhy5RLGjXsXM2fOwapVS5GYmIiAgEB89NF0bN++Gfv374WdnRxvvNEHkZFDxOP98MP3+OKLrbh16194enqia9fXEBExCDKZ7tt+YuJdrF69HHFxJ5CZmYGgoEYYOXIsXnjBD/v2fYfZs2cAAFq0aIolS1aJx92yZSO+/vpLPHz4EA0aBGDixI9Qo0ZNAEB6ejqWL1+M338/iNzcXPj7v4iRI8egXr364v2/+WYXtm3bhKSkJISEhKJKlaoleprJcpwd5Lj/MFv8mYjIGjEImSAIAjK/nQVt4pVyK4PMxw8O3T8sVhhKTU3FRx99gFGjxuGll1rg3r1EfPLJNKxYsRgdOrwKjUaDTZvWY9q0T6BWq/HBB+9h4MC+6Nr1NaxZ8zl++ukHrF27Ei1atEadOi/gyy+3YdWqZRg1ahxCQprh/PlzWLhwLh4+fIixYycgMzMDI0YMQdWq1TBnzgLI5QqsX78Go0a9jY0bt6N9+1eQnp6OJUsW4Jtv9sPV1Q2nT8fj7t07+OuvM5g/fzFyc1WIjp6KOXOisXz5WgiCgA8+GAOFQom5cz+Ds7Mz9u/fixEjhmD16g2oW7ceDhzYj4UL52Ls2PfRtGkoDh8+iDVrVqByZR8LnhEqrrzh5+np9ERE1oJdY/mQoOKtgpuUlAiVSgUfH1/4+lZBUFAjxMR8hl693hL3GTp0OOrVq4+AgCA0aRICBwcHjBw5BjVrPoeIiIEAgGvXrkAQBGzZ8jl69nwTPXu+gRo1aqJjx84YMmQ4du/+Cunp6fjxxx/w8GEqoqPnon79APj51cX06Z/A3l6JXbu+hL29Es7OzgAAL69KkMt1H4Z2dnaYOjUaL7zghxdfbIDXXuuJixfPAwDi40/i3Lm/EB39KRo0CMBzz9XCO++8iwYNAvHVV18AAHbu3IGXX+6Anj3fQM2az6F//4EID29Zhs80FUXeIMQWISKyVmwRMkEikcCh+4cVrmvMz88fL7/cEVFR4+DlVQkhIc3QsmUrhIe3xtmzfwIAqlevIe7v4OCAKlWqio9jb68EAOTm5iI1NQXJyQ8QFNTI4DEaNw6GWq3GzZs3cPXqFdSo8Rw8PDzE2+3tlahfvwGuXr2abzk9Pb3g5OQs/u7i4oqcHN0KxJcuXYQgCOjVq6vBfVQqlbjPtWtX8PLLHQ1uDwgIwuXLl4ryNFEZcWIQIqIKgEEoHxKJBJDbl3cxim369FkYPPhtHDv2fzh58jimT5+CoKBG4rgfOzvDU55f2MpvkLNWK+Q5Tn77aGFnJzN5GwBIpfk3RGq1Wjg5OWHdui1Gt+lblAAJBEFrcNvT9aLyZ9gixPNDRNaJXWPPkL//PoclSxagZs1aePPNvpg/fzE++mga4uNPIiUlpVjH8vT0gqenl9iSpHfmzGnI5XJUq1Ydder44datm0hJSRZvz8nJwcWLF1CrVm0A+Qet/NSu/QIyMjKQm5uL6tVriP+2bv0cf/xxCADg51cXZ8+eMbjfxYsXivU4ZHn6IKSQSyEvIBgTEZUnswehf//9FyNGjEDTpk3RtGlTjB8/HomJiQb7HD16FD179kTDhg3RqVMn7N271+D2nJwczJgxA2FhYWjcuDEmTJiA5ORkUMGcnJywa9dXWLFiCRISbuHatSv4+eefUL16Tbi7uxf7eP/7XwR27foSu3fvRELCLfz0036sX78G3bu/DmdnZ7zySie4ubnj448n4cKFv3HlymXMnDkFWVlZeO21ngB03W+ALqjk5GQX+pjNmoXBz68upk2bjFOn4pCQcAtLly7Evn3fieGqf/+BOHz4ILZt24Rbt/7Fzp1f4Lfffil2/ciy9IsqsluMiKyZWYOQSqXCwIEDodVqsW3bNmzevBn37t3D8OHDxa6Wq1ev4p133kHLli2xa9cuvPHGG5g4cSKOHj0qHmf69On4448/sHTpUnz++ee4du0axowZY86iPpNq1Xoes2bNx6lTcRg0qC9GjBgCmUyGBQuWlGgq/v/+1x/vvjsWO3ZsQ//+byA2diX69YvEmDETAADOzs5YunQ1XFxcMXbsSIwcORQ5OTlYuXIdqlatBgAIDg5B/foBGDFiMI4c+aPQx5TJZFi0aAXq1auPqVMnITKyD/788zRmzZqPJk1CAAAvvdQC06Z9gr17v0VkZB8cOnQQffr0L3b9yLK8XHVjzjwf/09EZI0kghlXvLt58yYWLlyIadOmwdPTEwDw888/491338XRo0fh6emJqVOn4sKFC/jqq6/E+02YMAGpqalYt24dEhMT0aZNG6xatQqtW7cGAFy/fh2dOnXCF198gcaNG5e4fCkpGVCrDceW5Oaq8ODBHXh5VYFcrijxsa2VnZ3UqM624Ol6P+vnGdDV2cPDyeTfeXkQBAFH/76LWr6uqFrJyWKPY231LiusN+ttCzw9nSCTWXYUj1mP/txzz2Hx4sViCLp9+za2b9+OBg0aiDOL4uLiEBYWZnC/5s2bIz4+HoIgID4+Xtym9/zzz8PHxwcnT540Z3GJyIIkEgleCqhi0RBERFRaFpvKMXjwYBw5cgRubm74/PPPxa6Zu3fvwtfX12DfypUrIysrCykpKUhMTISHhwfs7e2N9rl7926pymQqVWq1FW+9oKLS94ZJJIAtXemioHrLZBLY2T2bcwT0f9+W/vZkbVhv1tsW2Gq9SzCqo9iKFYQSEhLQvn37fG/Xd38BwAcffICxY8di+fLlGDhwIPbs2YMqVaogOzsbCoVh14T+d5VKhaysLKPbAcDe3l5cR6akXF0djLZlZ8tw/77UJj4gbU3eemu1EkilUri5OUKpfLbHrJj6O7cFrLdtYb3JXIoVhHx8fLBv3758b3dzcxN/fvHFFwEAn332Gdq2bYuvv/4ao0aNgr29PVQqw4UK9b87ODhAqVQa3Q7oZpLpZyCVVFpaFjQaw75VlSoHWq0WGo3wzPW7SiS6MKDRaG2uRejpems0ArRaLR4+zERWlqZ8C2ghMpkUrq4OJv/On2WsN+ttC2y13m5uDgWuPWcOxQpCcrkcderUyff2O3fu4MyZM+jUqZO4zdHREdWrV8e9e/cAAFWqVBF/1rt37x4cHR3h4uICX19fpKamQqVSGbQM3bt3Dz4+pbuWlEajNQo7Gs2zmxD0IcCWQhBQcL2fxcD7NFN/57aA9bYtrLdtKIvPL7PGrIsXL2Ls2LG4du2auC0tLQ3Xr18XA1TTpk1x4sQJg/sdO3YMwcHBkEqlaNKkCbRarThoGtDNGktMTERISIg5i2vAjJPnyArx/BIRkSlmDULh4eGoV68eoqKicO7cOfz9998YM2YMPDw80KtXLwBAREQEzp49i5iYGFy9ehXr16/H/v37MXToUAC67rcuXbpgypQpOH78OM6ePYvx48cjNDQUjRo1MmdxAejWrQF0XWT07NKfX5mMl3ogIqInzLqOEKDrwpo7dy6OHDkClUqFFi1aYPLkyahSpYq4z+HDhzF//nzcuHED1atXx+jRo9G5c2fx9szMTMyePRs//vgjAKBVq1aYMmWKwcU9SyK/9RcePnyArKx0ODt7QKGwL9Hig9ZKJpM8091/+dHXWxAEqFQ5SE9PgYODM9zcvMq7aBZjq+uMsN6sty2w1XqXxTpCZg9C1iy/PyBBEJCWloysrPRyKJVlSaVSaLW286LRe7reDg7OcHX1fKZC7tNs9Y2S9Wa9bYGt1rssghD7CaBb+M3NzQsuLh7QaNTlXRyzkckkcHNzxMOHmTbVKvR0vWUyO4vPOiAiooqJQSgPqVQKqfTZufyCnZ0USqUSWVkam/oGYav1JiKi4uPXZCIiIrJZDEJERERksxiEiIiIyGbZ1KwxW1qWXE9/qQlbw3rbFtbbtrDetkMqlVh8tq9NBSEiIiKivNg1RkRERDaLQYiIiIhsFoMQERER2SwGISIiIrJZDEJERERksxiEiIiIyGYxCBEREZHNYhAiIiIim8UgRERERDaLQYiIiIhsFoMQERER2SwGISIiIrJZDEJERERks56JIKTVarFkyRK0bNkSjRo1wttvv41bt27lu39KSgomTJiAkJAQhIaGYsaMGcjKyirDEpdeamoqpk6dilatWiE4OBj/+9//EBcXl+/+K1euhL+/v9G/iigxMdFkXXbt2mVy/2fhfB8/ftxknf39/dG+fXuT94mPjze5//Hjx8u49CWzevVqREREGGy7cOEC+vfvj0aNGqFdu3bYtGlTocf54Ycf0LlzZwQFBaFHjx44evSopYpsFqbq/euvv6JXr15o3Lgx2rVrh7lz5yI7OzvfY2g0GgQFBRmd+6VLl1q6+CVmqt5TpkwxqkO7du0KPE5FP98RERH5vtb37NmT73EGDRpktP/Tz2d5K+xz6+jRo+jZsycaNmyITp06Ye/evYUec+vWrWjfvj2CgoLQt29fnD9/vvgFE54BS5cuFZo1ayYcPHhQuHDhgjB48GChQ4cOQk5Ojsn9+/fvL/Tq1Us4d+6c8H//939C27ZthYkTJ5ZxqUtn0KBBQteuXYWTJ08K165dE2bMmCEEBQUJV69eNbn/2LFjhQ8++EC4d++ewb+K6LfffhMCAwOFxMREg7pkZWWZ3P9ZON85OTlG5+6nn34S/P39hZ07d5q8z9atW4WXX37Z6H75vS6syZYtW4R69eoJ/fv3F7clJycLzZo1EyZPnixcuXJF2LlzpxAYGJhv/QVBEI4ePSo0aNBA+Pzzz4UrV64Ic+bMEQICAoQrV66URTWKzVS9T548Kbz44ovCypUrhevXrwu//fab0KpVK2HSpEn5HufKlStC3bp1hQsXLhic+/T09LKoRrGZqrcgCELv3r2FhQsXGtThwYMH+R7nWTjfKSkpBvVNTEwU+vbtK3Tp0qXA8xcWFiZs27bN4L4pKSllUIuiK+hz68qVK0JgYKCwcOFC4cqVK0JsbKxQv3594f/+7//yPd6uXbuEoKAg4ZtvvhEuX74sfPDBB0JoaGiBfyOmVPgglJOTIzRu3FjYunWruO3hw4dCUFCQ8N133xntf+rUKaFu3boGL4zff/9d8Pf3F+7evVsmZS6tGzduCHXr1hXi4uLEbVqtVnj55ZeFzz77zOR9Xn31VWHDhg1lVELLWrNmjdCtW7ci7fssnG9TMjIyhLZt2xb4YTht2jRh+PDhZViq0rt7967wzjvvCI0aNRI6depk8AGxatUqoUWLFkJubq64bcGCBUKHDh3yPd7gwYOFsWPHGmx76623hI8//tjsZS+Nguo9YcIEYeDAgQb77969W2jQoEG+oXbv3r1CcHCwRctsDgXVW6vVCo0aNRJ++umnIh/vWTjfT9u8ebMQEBCQ75dcQRCE+/fvC3Xr1hX+/vtvSxTXLAr73Pr444+F3r17G9xn/PjxwuDBg/M9ZocOHYR58+aJv+fm5gqtW7cWVq1aVayyVfiusYsXLyIjIwNhYWHiNldXV9SvXx8nT5402j8uLg7e3t6oU6eOuC00NBQSiQTx8fFlUubS8vDwwJo1axAYGChuk0gkkEgkSEtLM9pfpVLhxo0bqF27dlkW02L++ecfg/NXkGfhfJuyatUqZGVlISoqKt99ivM8WYu///4bcrkc3377LRo2bGhwW1xcHEJDQ2FnZydua968OW7cuIH79+8bHUur1eLUqVMG7w0A0KxZM5PvDeWpoHoPHjzY6DxLpVLk5uYiPT3d5PEqyrkvqN7//vsvMjMzi/y+9ayc77ySk5Px2WefYcSIEQU+D//88w8kEgmef/55SxTXLAr73IqLizM6d82bN0d8fDwEQTA63oMHD3Djxg2D+9jZ2aFp06bFPt92he9i3e7evQsAqFKlisH2ypUri7fllZiYaLSvQqGAu7s77ty5Y7mCmpGrqytat25tsO3HH3/EzZs38eGHHxrtf+XKFWg0Gvz444+YNWsWcnJyEBISgg8++ACVK1cuq2KbzaVLl+Dh4YF+/frh+vXreO655zBixAi0atXKaN9n4Xw/LTk5GRs3bsSECRPg7u6e736XL1+Gh4cHevbsicTERNStWxfjxo1DUFBQ2RW2mNq1a5fvGJC7d++ibt26Btv0f7937txBpUqVDG5LS0tDZmYmfH19je5j6r2hPBVU7/r16xv8npubi40bNyIgIACenp4m73Pp0iWo1WoMGTIEFy9ehI+PDyIjI/Haa6+ZveylUVC9L126BADYvHkzDh8+DKlUilatWmHcuHFwcXEx2v9ZOd95rV27FkqlEkOGDClwv0uXLsHFxQUzZ87EkSNH4OjoiE6dOmHkyJFQKBTmKnapFPa5tXv3bpPnLisrCykpKUZ/6wV99l+8eLFYZavwLUL6Qa9Pn2x7e3vk5OSY3N/UH0Z++1cEp06dwuTJk9GhQwe0adPG6Hb9G4qDgwMWL16MWbNm4dq1axgwYECBAy6tkVqtxrVr1/Dw4UOMHj0aa9asQaNGjTBs2DCTgyKfxfO9bds2uLi44K233sp3nzt37uDRo0fIzMzElClTsGLFClSqVAn9+/fHlStXyrC05pOdnW3ydQ7A5LnU/20X9b2hIlCr1Zg4cSIuX76MadOm5bvf5cuXkZqaioiICKxbtw4dO3bE5MmTsXPnzjIsbelcunQJUqkUlStXxqpVqzBp0iT88ccfGDlyJLRardH+z9r5Tk9Px5dffokhQ4aIf+f5uXTpEnJychAUFITY2FiMGDECX331FaZMmVJGpS2+pz+3TL2+9b+rVCqj+xf3s78gFb5FSKlUAtA9UfqfAd0bo4ODg8n9TT2pOTk5cHR0tFxBLeTnn3/G+++/j+DgYMTExJjcp0ePHmjVqpVBovbz80OrVq3w66+/onPnzmVV3FKzs7PD8ePHIZPJxPMdEBCAy5cvY926dUZNq8/a+QaAPXv2oEePHgZ/70+rUqUKTp48CQcHB8jlcgBAYGAgzp8/j82bN2PGjBllVVyzMXUu9W94ps6l/sPD1H1MvTdYu/T0dLz33ns4ceIEli1bVmDL3vfffw+NRgMnJycAQL169XD79m2sW7cOvXv3Lqsil8qIESPQt29feHh4AADq1q0Lb29vvPnmm/jrr7+MupSetfP9888/Q6VSoVevXoXuO3PmTERFRcHNzQ2A7rmSy+UYN24cJk6caNRaWt5MfW7Z29sbnTv97/l9lufdR68k57vCtwjpm8Xu3btnsP3evXvw8fEx2t/X19doX5VKhdTU1ArXTbRlyxaMHj0abdu2xapVqwr81vB0s2LlypXh7u5udU3GReHk5GQUAvz8/JCYmGi077N0vgHdmLhbt26hW7duhe7r6uoqhiBAN66kTp06Jp+nisDUudT/buq17u7uDkdHxyK/N1ize/fuoV+/fvjzzz+xbt06oy6GpymVSjEE6dWtW7dCvd6lUqkYgvT8/PwAwGQ9nqXzDejCQuvWreHq6lrovnZ2dmII0ivouSpP+X1uValSxeS5c3R0NNkVWtzP/oJU+CBUr149ODs7G6yNkpaWhvPnzyMkJMRo/5CQENy9exc3b94Ut504cQIA0KRJE8sX2Ey2bduG6Oho9OvXDwsXLiywH3jRokXo2LGjwYCzhIQEpKSk4IUXXiiL4prN5cuXERwcbLQWzrlz50zW5Vk533pxcXHw8vJCvXr1Ctzv8OHDaNy4scF6Wmq1GhcvXqxw51wvJCQE8fHx0Gg04rZjx47h+eefh5eXl9H+EokEwcHB4vnWO378OJo2bWrx8prLw4cPERkZieTkZGzdutXk+1peaWlpCA0NNVpX66+//hI/HCuCiRMnYuDAgQbb/vrrLwAw+Tf8rJxvPVODh/MTERGByZMnG2z766+/IJfLUatWLQuUrmQK+txq2rSp0bk7duwYgoODIZUaRxUvLy88//zzBp8FarUacXFxhb5Gnlbhg5BCoUD//v0RExODX375BRcvXsS4cePg6+uLDh06QKPRICkpSew/btiwIYKDgzFu3DicPXsWx44dw9SpU9GjR48K863h+vXrmD17Nl555RW88847uH//PpKSkpCUlIRHjx5BpVIhKSlJbDJ85ZVX8N9//2H69Om4fv06Tp48idGjRyM4OBgtW7Ys59oUT506dVC7dm3MnDkTcXFxuHr1Kj799FP8+eefGDFixDN5vvM6f/58vgthJiUlISMjAwAQHBwMDw8PREVF4dy5c/jnn38QFRWF1NRUow+XiqJXr15IT0/HRx99hCtXrmDXrl3YuHEj3nnnHXGfR48eITk5Wfx90KBB2Lt3LzZs2ICrV69i3rx5uHDhAiIjI8ujCiXy6aef4tatW5g/fz48PT3F13pSUpIYClNTU5GamgpA1xLYvHlzLFq0CIcOHcKNGzewZs0afPvttxg9enQ51qR4OnbsiKNHj2LZsmX4999/cejQIXz44Yfo2rWrOCPuWTzfgG6MX0pKSr5feDIyMpCUlCT+3rFjR3zzzTfYvn07bt26hX379mHevHkYMmQInJ2dy6rYBSrscysiIgJnz55FTEwMrl69ivXr12P//v0YOnSoeIy8f+eAbkblhg0bsHv3bly5cgUffvghsrOzi9/9W6zJ9lZKrVYL8+bNE5o3by40atRIePvtt4Vbt24JgiAIt27dEurWrSt8/fXX4v73798XRo8eLTRq1Eho1qyZMG3aNCE7O7u8il9sK1euFOrWrWvyX1RUlHDs2DGhbt26wrFjx8T7/N///Z/w1ltvCY0aNRJCQ0OFyZMnC6mpqeVYi5JLSkoSJk2aJISHhwuBgYHCW2+9JZw8eVIQhGfzfOc1dOhQ4b333jN5W926dYUlS5aIv9+8eVMYPXq0EBoaKjRs2FAYPHiw8M8//5RVUUstKirKaH2VM2fOCG+++aYQEBAgtG3bVti8ebPRfdq2bWuwbffu3cIrr7wiBAYGCq+//nqBC7RZg7z1VqvVQmBgYL6vd/37XP/+/Q2eq0ePHgmzZ88WWrduLQQEBAivvfaacODAgXKpT1GZOt/79u0TevToIQQFBQnh4eHCnDlzDF67z9r51jtz5ozR+md5LVmyRKhbt67Bti1btgivvvqq+NpYuXKloNFoLFbu4irsc0sQBOHQoUNC165dhYCAAKFTp07C3r17DY7x9N+5IAhCbGys0KpVKyEoKEjo27evcP78+WKXTSIIJiboExEREdmACt81RkRERFRSDEJERERksxiEiIiIyGYxCBEREZHNYhAiIiIim8UgRERERDaLQYiIiIhsFoMQERER2SwGISKqEBISEuDv7290Da2SmDRpEtq1a2eGUhFRRWdX3gUgIiqKypUrY8eOHahZs2Z5F4WIniEMQkRUISgUCjRq1Ki8i0FEzxh2jRGRWXz11Vfo0qULAgIC0KZNGyxdulS8OvqkSZMQERGBnTt3om3btmjcuDEiIyNx8eJF8f5arRaLFi1Cu3btEBAQgHbt2mHBggXIzc0FYLpr7MaNGxgzZgzCw8PRqFEjREREID4+3qBcDx8+xOTJkxEaGoqQkBDMnz8fWq3WqPw///wzevbsicDAQISHh+OTTz5BZmameHt2djamT5+OVq1aISAgAJ06dcK6devM+hwSUdljixARldrq1auxaNEi9O/fH5MnT8aFCxewdOlS3LlzB7NnzwYAXLhwAdeuXcP48ePh5uaGJUuWoH///ti3bx8qV66MtWvXYvv27YiKikKNGjVw5swZLFq0CHK5HGPGjDF6zCtXruDNN99ErVq1MGXKFMjlcmzatAmRkZFYv349QkNDodVqMXToUPz333+IioqCu7s7YmNj8ddff6Fy5crisb777ju8//776NatG9577z38999/WLRoEa5cuYINGzZAIpFg9uzZ+OOPPxAVFYVKlSrh8OHDmDdvHtzd3dGrV68ye66JyLwYhIioVB49eoQVK1bgrbfewpQpUwAALVq0gLu7O6ZMmYJBgwaJ+61atQpNmzYFAAQFBeHll1/Gpk2b8P777+PEiRMICAgQQ0VoaCgcHBzg4uJi8nGXLVsGhUKBTZs2wdnZGQDQpk0bdO3aFfPmzcPOnTtx+PBhnD17FmvXrkWrVq0AAGFhYQYDpQVBQExMDFq2bImYmBhxe61atTBw4EAcOnQIbdq0wYkTJxAeHo4uXboAAJo1awZHR0d4eXmZ8+kkojLGrjEiKpXTp08jOzsb7dq1g1qtFv/pw8aRI0cAANWrVxdDEKAb/Ny4cWOcPHkSgC5YHDlyBH379kVsbCyuXLmC/v3747XXXjP5uCdOnEDbtm3FEAQAdnZ26NKlC86dO4eMjAzExcVBLpejZcuW4j6Ojo5o3bq1+Pu1a9dw9+5do/KHhITA2dlZLH+zZs3w5Zdf4u2338aWLVtw69YtvPvuu2jTpo15nkgiKhdsESKiUklNTQUADBs2zOTt9+7dAwD4+PgY3ebl5YW///4bADB06FA4OTnh66+/RkxMDObPnw8/Pz9MmTIFzZs3N7rvw4cPUalSJaPtlSpVgiAISE9Px8OHD+Hu7g6JRGKwj7e3t1H5Z8yYgRkzZuRb/o8++gi+vr749ttvER0djejoaDRu3BjTp09HvXr1TNadiKwfgxARlYqrqysAICYmBrVq1TK6vVKlSli8eDFSUlKMbrt//77YtSSVStGvXz/069cPDx48wKFDh7Bq1SqMHj1abJXJy83NDffv3zfanpSUBADw8PCAh4cHUlJSoNFoIJPJxH304Sdv+SdOnIjQ0FCTjwPoZq2NGDECI0aMwO3bt3Hw4EGsWLECEyZMwN69e/N7eojIyrFrjIhKpWHDhpDL5UhMTERgYKD4z87ODgsXLkRCQgIA3Qyvq1evivdLTEzE6dOnERYWBgDo06cPPvnkEwC6lqKePXuiX79+SEtLQ3p6utHjhoSE4ODBgwa3aTQa7N27F4GBgVAoFAgLC4NarcbPP/8s7qNSqQyCVe3ateHl5YWEhASD8vv4+GDBggU4f/48srOz0bFjR6xfvx4AULVqVfTr1w9dunTB7du3zfhsElFZY4sQEZWKh4cHhg4disWLFyM9PR3NmjVDYmIiFi9eDIlEInYbCYKA4cOHY9y4cZDJZFi2bBnc3NwQEREBQBds1q9fj0qVKqFx48ZITEzEhg0bEBoaCk9PT4Op7AAwatQoHD58GAMGDMCwYcMgl8vFsTuxsbEAdAOjW7RogSlTpuDBgweoVq0aNm3ahOTkZLElSiaTYdy4cZg6dSpkMhnatm2LtLQ0rFixAomJiWjQoAGUSiUaNGiAZcuWQS6Xw9/fH9evX8fu3bvRsWPHMny2icjcJIIgCOVdCCKq+LZu3Ypt27bh5s2bcHNzQ1hYGMaPH4+qVati0qRJOHHiBN5++20sX74cWVlZeOmllxAVFYXq1asDANRqNVauXIlvv/0Wd+/ehYuLC9q1a4cJEybAw8MDCQkJaN++PT799FP07NkTgG5K/sKFCxEXFweJRIKgoCCMGjXKYFB2VlYWYmJisHfvXuTk5KBz585wdHTEL7/8gl9//VXcb9++fYiNjcXly5fh6OiI4OBgvPfee/D39wcApKen47PPPsMvv/yCpKQkeHl5oXPnzhg7diyUSmUZPtNEZE4MQkRkcfoglDd4EBFZA44RIiIiIpvFIEREREQ2i11jREREZLPYIkREREQ2i0GIiIiIbBaDEBEREdksBiEiIiKyWQxCREREZLMYhIiIiMhmMQgRERGRzWIQIiIiIpv1/2Po3UtxEkgJAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = Config() \n",
    "# 训练\n",
    "env, agent = env_agent_config(cfg)\n",
    "res_dic = train(cfg, env, agent)\n",
    " \n",
    "plot_rewards(res_dic['rewards'], title=f\"training curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")  \n",
    "# 测试\n",
    "res_dic = test(cfg, env, agent)\n",
    "plot_rewards(res_dic['rewards'], title=f\"testing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")  # 画出结果"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.12 ('easyrl')",
   "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.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "f5a9629e9f3b9957bf68a43815f911e93447d47b3d065b6a8a04975e44c504d9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}