第13章-DDPG算法.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "executionInfo": {
     "elapsed": 7745,
     "status": "ok",
     "timestamp": 1649956114018,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "ADCfIvzwCn3R"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import gym\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "import torch\n",
    "from torch import nn\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "import rl_utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "executionInfo": {
     "elapsed": 11,
     "status": "ok",
     "timestamp": 1649956114020,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "7lLH6nSFCn3U"
   },
   "outputs": [],
   "source": [
    "class PolicyNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, action_bound):\n",
    "        super(PolicyNet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)\n",
    "        self.action_bound = action_bound  # action_bound是环境可以接受的动作最大值\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return torch.tanh(self.fc2(x)) * self.action_bound\n",
    "\n",
    "\n",
    "class QValueNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(QValueNet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim + action_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, 1)\n",
    "\n",
    "    def forward(self, x, a):\n",
    "        cat = torch.cat([x, a], dim=1)  # 拼接状态和动作\n",
    "        x = F.relu(self.fc1(cat))\n",
    "        return self.fc2(x)\n",
    "\n",
    "\n",
    "class TwoLayerFC(torch.nn.Module):\n",
    "    # 这是一个简单的两层神经网络\n",
    "    def __init__(self,\n",
    "                 num_in,\n",
    "                 num_out,\n",
    "                 hidden_dim,\n",
    "                 activation=F.relu,\n",
    "                 out_fn=lambda x: x):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(num_in, hidden_dim)\n",
    "        self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.fc3 = nn.Linear(hidden_dim, num_out)\n",
    "\n",
    "        self.activation = activation\n",
    "        self.out_fn = out_fn\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.activation(self.fc1(x))\n",
    "        x = self.activation(self.fc2(x))\n",
    "        x = self.out_fn(self.fc3(x))\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1649956263275,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "0WpTJOW2Cn3W"
   },
   "outputs": [],
   "source": [
    "class DDPG:\n",
    "    ''' DDPG算法 '''\n",
    "    def __init__(self, num_in_actor, num_out_actor, num_in_critic, hidden_dim,\n",
    "                 discrete, action_bound, sigma, actor_lr, critic_lr, tau,\n",
    "                 gamma, device):\n",
    "        # self.actor = PolicyNet(state_dim, hidden_dim, action_dim, action_bound).to(device)\n",
    "        # self.critic = QValueNet(state_dim, hidden_dim, action_dim).to(device)\n",
    "        # self.target_actor = PolicyNet(state_dim, hidden_dim, action_dim, action_bound).to(device)\n",
    "        # self.target_critic = QValueNet(state_dim, hidden_dim, action_dim).to(device)\n",
    "        out_fn = (lambda x: x) if discrete else (\n",
    "            lambda x: torch.tanh(x) * action_bound)\n",
    "        self.actor = TwoLayerFC(num_in_actor,\n",
    "                                num_out_actor,\n",
    "                                hidden_dim,\n",
    "                                activation=F.relu,\n",
    "                                out_fn=out_fn).to(device)\n",
    "        self.target_actor = TwoLayerFC(num_in_actor,\n",
    "                                       num_out_actor,\n",
    "                                       hidden_dim,\n",
    "                                       activation=F.relu,\n",
    "                                       out_fn=out_fn).to(device)\n",
    "        self.critic = TwoLayerFC(num_in_critic, 1, hidden_dim).to(device)\n",
    "        self.target_critic = TwoLayerFC(num_in_critic, 1,\n",
    "                                        hidden_dim).to(device)\n",
    "        # 初始化目标价值网络并设置和价值网络相同的参数\n",
    "        self.target_critic.load_state_dict(self.critic.state_dict())\n",
    "        # 初始化目标策略网络并设置和策略相同的参数\n",
    "        self.target_actor.load_state_dict(self.actor.state_dict())\n",
    "        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(),\n",
    "                                                lr=actor_lr)\n",
    "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(),\n",
    "                                                 lr=critic_lr)\n",
    "        self.gamma = gamma\n",
    "        self.sigma = sigma  # 高斯噪声的标准差,均值直接设为0\n",
    "        self.action_bound = action_bound  # action_bound是环境可以接受的动作最大值\n",
    "        self.tau = tau  # 目标网络软更新参数\n",
    "        self.action_dim = num_out_actor\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state):\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        action = self.actor(state).item()\n",
    "        # 给动作添加噪声，增加探索\n",
    "        action = action + self.sigma * np.random.randn(self.action_dim)\n",
    "        return action\n",
    "\n",
    "    def soft_update(self, net, target_net):\n",
    "        for param_target, param in zip(target_net.parameters(),\n",
    "                                       net.parameters()):\n",
    "            param_target.data.copy_(param_target.data * (1.0 - self.tau) +\n",
    "                                    param.data * self.tau)\n",
    "\n",
    "    def update(self, transition_dict):\n",
    "        states = torch.tensor(transition_dict['states'],\n",
    "                              dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions'],\n",
    "                               dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'],\n",
    "                               dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'],\n",
    "                                   dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'],\n",
    "                             dtype=torch.float).view(-1, 1).to(self.device)\n",
    "\n",
    "        next_q_values = self.target_critic(\n",
    "            torch.cat(\n",
    "                [next_states, self.target_actor(next_states)], dim=1))\n",
    "        q_targets = rewards + self.gamma * next_q_values * (1 - dones)\n",
    "        critic_loss = torch.mean(\n",
    "            F.mse_loss(\n",
    "                # MSE损失函数\n",
    "                self.critic(torch.cat([states, actions], dim=1)),\n",
    "                q_targets))\n",
    "        self.critic_optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        self.critic_optimizer.step()\n",
    "\n",
    "        actor_loss = -torch.mean(\n",
    "            self.critic(\n",
    "                # 策略网络就是为了使得Q值最大化\n",
    "                torch.cat([states, self.actor(states)], dim=1)))\n",
    "        self.actor_optimizer.zero_grad()\n",
    "        actor_loss.backward()\n",
    "        self.actor_optimizer.step()\n",
    "\n",
    "        self.soft_update(self.actor, self.target_actor)  # 软更新策略网络\n",
    "        self.soft_update(self.critic, self.target_critic)  # 软更新价值网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 142752,
     "status": "ok",
     "timestamp": 1649956407730,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "-OjAWgKJCn3X",
    "outputId": "d2b245bd-7d68-4776-bf18-2c1f54a0ba22"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0:   0%|          | 0/20 [00:00<?, ?it/s]/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:34: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at  ../torch/csrc/utils/tensor_new.cpp:201.)\n",
      "Iteration 0: 100%|██████████| 20/20 [00:11<00:00,  1.78it/s, episode=20, return=-1266.015]\n",
      "Iteration 1: 100%|██████████| 20/20 [00:14<00:00,  1.39it/s, episode=40, return=-610.296]\n",
      "Iteration 2: 100%|██████████| 20/20 [00:14<00:00,  1.37it/s, episode=60, return=-185.336]\n",
      "Iteration 3: 100%|██████████| 20/20 [00:14<00:00,  1.36it/s, episode=80, return=-201.593]\n",
      "Iteration 4: 100%|██████████| 20/20 [00:14<00:00,  1.37it/s, episode=100, return=-157.392]\n",
      "Iteration 5: 100%|██████████| 20/20 [00:14<00:00,  1.39it/s, episode=120, return=-156.995]\n",
      "Iteration 6: 100%|██████████| 20/20 [00:14<00:00,  1.39it/s, episode=140, return=-175.051]\n",
      "Iteration 7: 100%|██████████| 20/20 [00:14<00:00,  1.36it/s, episode=160, return=-191.872]\n",
      "Iteration 8: 100%|██████████| 20/20 [00:14<00:00,  1.38it/s, episode=180, return=-192.037]\n",
      "Iteration 9: 100%|██████████| 20/20 [00:14<00:00,  1.36it/s, episode=200, return=-204.490]\n"
     ]
    }
   ],
   "source": [
    "actor_lr = 5e-4\n",
    "critic_lr = 5e-3\n",
    "num_episodes = 200\n",
    "hidden_dim = 64\n",
    "gamma = 0.98\n",
    "tau = 0.005  # 软更新参数\n",
    "buffer_size = 10000\n",
    "minimal_size = 1000\n",
    "batch_size = 64\n",
    "sigma = 0.01  # 高斯噪声标准差\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\n",
    "    \"cpu\")\n",
    "\n",
    "env_name = 'Pendulum-v0'\n",
    "env = gym.make(env_name)\n",
    "random.seed(0)\n",
    "np.random.seed(0)\n",
    "env.seed(0)\n",
    "torch.manual_seed(0)\n",
    "replay_buffer = rl_utils.ReplayBuffer(buffer_size)\n",
    "state_dim = env.observation_space.shape[0]\n",
    "action_dim = env.action_space.shape[0]\n",
    "action_bound = env.action_space.high[0]  # 动作最大值\n",
    "agent = DDPG(state_dim, action_dim, state_dim + action_dim, hidden_dim, False,\n",
    "             action_bound, sigma, actor_lr, critic_lr, tau, gamma, device)\n",
    "\n",
    "return_list = rl_utils.train_off_policy_agent(env, agent, num_episodes,\n",
    "                                              replay_buffer, minimal_size,\n",
    "                                              batch_size)\n",
    "\n",
    "# Iteration 0: 100%|██████████| 20/20 [02:42<00:00,  8.11s/it, episode=20,\n",
    "# return=-1269.365]\n",
    "# Iteration 1: 100%|██████████| 20/20 [03:38<00:00, 10.94s/it, episode=40,\n",
    "# return=-916.439]\n",
    "# Iteration 2: 100%|██████████| 20/20 [03:38<00:00, 10.93s/it, episode=60,\n",
    "# return=-450.922]\n",
    "# Iteration 3: 100%|██████████| 20/20 [03:36<00:00, 10.81s/it, episode=80,\n",
    "# return=-239.596]\n",
    "# Iteration 4: 100%|██████████| 20/20 [03:37<00:00, 10.86s/it, episode=100,\n",
    "# return=-173.360]\n",
    "# Iteration 5: 100%|██████████| 20/20 [03:38<00:00, 10.91s/it, episode=120,\n",
    "# return=-239.450]\n",
    "# Iteration 6: 100%|██████████| 20/20 [03:38<00:00, 10.91s/it, episode=140,\n",
    "# return=-184.360]\n",
    "# Iteration 7: 100%|██████████| 20/20 [03:37<00:00, 10.88s/it, episode=160,\n",
    "# return=-172.832]\n",
    "# Iteration 8: 100%|██████████| 20/20 [03:38<00:00, 10.90s/it, episode=180,\n",
    "# return=-178.041]\n",
    "# Iteration 9: 100%|██████████| 20/20 [03:38<00:00, 10.91s/it, episode=200,\n",
    "# return=-190.356]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 573
    },
    "executionInfo": {
     "elapsed": 565,
     "status": "ok",
     "timestamp": 1649956408280,
     "user": {
      "displayName": "Sam Lu",
      "userId": "15789059763790170725"
     },
     "user_tz": -480
    },
    "id": "LtGxw6PBCn3Y",
    "outputId": "45eab045-71ae-4055-b9dd-e3930449eddd"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZMAAAEWCAYAAACjYXoKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydeXxcV3n3v8/sI2k02iVLsi1vieM4C7FJICGBLJCwJuyhtGUrgVLa0lIovLSlC7TQl6VvWwqEpYS27FtCCZCFNoHsceIkXmLHuyVLXrRLs8+c9497z507o5E0sjTySD7fz2c+Gt17Z+6ZO3PP7zzLeY4opTAYDAaDYT54znQDDAaDwbD0MWJiMBgMhnljxMRgMBgM88aIicFgMBjmjRETg8FgMMwbIyYGg8FgmDdGTAyGZYaIvF1EfrPQxxoMM2HExFAViMghEYmLyLiIjIjIgyLyXhHxuI75hoik7GPGRWSHiPyDiERdx7xdRLIiMiEiYyKyXURe5dofEZHP2eebFJEjIvIDEblsET7jjG072xGRPxGRAfvafF1Egme6TYbyMWJiqCZerZSKAKuBTwF/Dnyt6Jh/tI9pBd4BvAB4QERqXcc8pJSqAxrs139PRBrtzulXwAXAq4B64DzgO8DLK/exCijZtkU6d9UiItcDHwGuxfr+1wJ/c0YbZZgTRkwMVYdSalQpdQfwZuBtIrK5xDEJpdRjwGuAZixhKT4mB3wdCAPrgN8BuoGblFI7lFJZpdSkUuoHSqm/nq49IvIaEdlpW0z/KyLnufYdEpE/E5GnRWRURL4rIqEyPmNB20QkKCKfsS2l4yLyJREJ2+d4iYj0isgHReSEiPSLiPN5RaRZRO6wR/SP2p9V7+sRESUiPte2/xWR3yvxOWc81rasHhCRz9vX4oCIXG5vP2q37W3TXMPLbKvD69r2WhF52v73bcDXlFI7lVLDwN8Bb5/tOhqqByMmhqpFKfUo0AtcOcMx48DdpY6xO8XfAyaA54DrgF8qpSbLbYOInAN8G/gAljV0J/BTEQm4DnsTcAOwBriQMjrBEm37FHAOcDGwHugC/sr1kg4gam9/F/AFl0XzBSABrADeaT8qxWXA01gC/i0sq+75dpt/G/hXEakrfpFS6hFgErjGtfm37PcAOB94yrXvKaBdRJoX+gMYKoMRE0O1cwxomuMxLxCREWAAeAvwWqXUKNBibwNARC62R9hjIrJnmvd+M/AzpdTdSqk08Bksa+Jy1zH/rJQ6ppQaAn6KJQjTMaVtwBhwC/AnSqkhWyD/HrjZ9bo08LdKqbRS6k4sETrXHum/Hvgr28raAdw2w/nny0Gl1L8rpbLAd4GVdruSSqm7gBSWsJTi21ifGRGJAK+wtwHUAaOuY/XzyAK331AhfLMfYjCcUbqAoTke87BS6kUljhvEGr0DoJTaDjSIyHXAV6d5707gsOs1ORE5ap9TM+B6HrNfMx1T2iYibUANsE1EnM2A13XYoFIqU3SeOixryQccde07TOU47noeB1BKFW+rE5FVwC690Y4TfQt4UER+H3gd8IRSSrd1AiuGpdHPxxe2+YZKYSwTQ9UiIs/H6rSnTV21XSrXAb8u4y3vBV5WFKyfjWNYAWF9PsEajffN4T1m4xRWJ3y+UqrBfkTtDng2TgIZu02aVa7n2qVX49rWMc17zeXYGVFKHVFK1emHvW0XltC9nEIXF8BO4CLX/xcBx5VSg6dzfsPiY8TEUHWISL2dMvsd4D+VUs+UOCYoIluAnwDDwL+X8dbfBPqBH4vIZhHx2sHyrTO85nvAK0XkWhHxAx8EksCDc/tU02MH478CfN62UhCRLjvDabbXZoEfAX8tIjUisgkrmK33n8QSvt+2P+87cQXoi96r7GPnwbeAPwauAr7v2v5N4F0isklEGoC/AL6xwOc2VBAjJoZq4qciMo7lsvkY8DmmZml92D5mEKsD2gZcXk5QXSmVAK7Gcr/8DCtWsQcrgPymaV6zByuw/C9YFsSrsVKYU3P+dDPz58A+4GERGQPuAc4t87Xvx3J5DWB1wMXC+m7gQ1jX7HxmFsK5HHs6fBt4MfArpdQpvVEp9QvgH4H/AY5gWTAfX+BzGyqImMWxDAaDwTBfjGViMBgMhnljxMRgMBgM88aIicFgMBjmjRETg8FgMMybs3bSYktLi+rp6TnTzTAYDIYlxbZt204ppVqLt5+1YtLT08Pjjz9+ppthMBgMSwoRKVlhwbi5DAaDwTBvjJgYDAaDYd4YMTEYDAbDvDFiYjAYDIZ5Y8TEYDAYDPNm2YiJiNwgIntEZJ+IfORMt8dgMBjOJpaFmNirzX0Ba52ETcBb7FLcBoPBYFgEloWYAJcC+5RSB+zS4N8BbjzDbVrWPHZoiN39Y2e6GXPmqaMjnBxPArBnYJwTY4lFPf9oPE0slZn9wCXI3uPj7D1uFkY8W1kuYtJF4bKlvRQuqwqAiNwiIo+LyOMnT55ctMYtR/7yJzv49C+ePdPNmDPv+MZj/OuvngPgnd94jE/N8hke3HeKX+wYmPGYufDu2x7n47fvXLD3qyb+8ic7Fu2zpbM5vvrrAyTS2YLt8VSWl37uPh45sHwXaExlcgxOJM90M6awXMSkLJRStyqltiqltra2TqkGYJgDI7E0fcPxM92MOZHNKYYmUxwajJFIZ+kbiXN4MDbja750/wH+6Z69C9aGvSfG6R9dXGtosRiOpRiOLfSaYaV55MAQn/jZbh7cf6pg+8BYgudOTPDwgaFFaceZ4LYHD3Hd5+4jm6uutaiWi5j0UbgGdjcLu0a3oYiJZIZjI3GW0uJqEwnLvdQ7HOPYSNx5PvNr0lNGv6dLPJVlJLZ83Vxj8QzjicX5bH0jMeecbvR3rPcvR3qHYwzH0pwYr65ByXIRk8eADSKyRkQCwM3AHWe4TcuWbE4xkcwwmcoytkidx0IwlkgD0Dsc56htVR0fS5LMTC8WE8kMiXRuQc7fP2qdM5ZaGHGqNsYSaecaVxptFY8XnU//3zeytKzmuaAF++hQdX3GZSEmSqkM1jrYvwR2A99TSi1Px3QVMOkaWesOcikwGrc6mmQmx1NHR5zt/SPTj/AmEhkSM4jNXBiw3VvLUUzS2RyxVJaJZIbcIrhfem2xKB7MjCdty2SJuWDnQn5QVF3W17IQEwCl1J1KqXOUUuuUUp880+1ZzrhdGTN1xNWGu90PuwK0vTN0POPJDPEF6vyPLWMx0ddWqcLBRqXIWyal3VzHRhKLImpngjHHXVtdgrlsxMSweEy4buBjS8gycbtgth0eJuizfv7T+deVUkwmMyQzuQWJDQ3Y1yq+DGMmY/H8tV2MuIl2YxW7uSZsyySVzXGyCjOeFoJxV+yvmjBiYpgz7hv42BLyTbs7vGQmx0XdDXhk+hFePJ1FD26TmfnHTXQWVyydXVKJC+XgFupKi0k2pxyX4RTLJJn/v9pG7gvFuCv2V00YMTHMmaXu5gp4rZ99T0sNK6LhaW9KtwW2EBldugNUigUL6lcL7qyqYmthoTk+liBjq/zUAHy+Hcs1CD9u3FyG5YIOcjbU+Jekm2tdWx0A3Y01dDWGpw3WjifdYjL/zv+Ya37JcksPXkzLRIuER0pZJmnCfi9QfW6ghUApxXgijYjlFaimuSZGTAxzRo8Gz2mPLKkJeGPxDHVBHz3NNQB0N4bpbghP2+m4LZP4glgmcUJ+65ZbbkF4twux0unBWvzXtNSWDMC31QdprPEvy4yuyZTlel3dVEMmpzi+yOWAZsKIiWHO6E72nPY6+iuYNVMcVxiJpZwyEslMds5ZVuOJNJGQj+7GMABdDWG6G8MMjCVIZ6daHhPJhXNzJdJZhmNp1rZYVtGyE5OEW0wWxzLZ2FFfMgBfF/RZFucydHPpz7upsx6oLleX70w3wLD0GE9k8Aisb60jlc3x9QcO8vyeJi5a2cCegXH2HB/nxRtaidb4nddkc4rbt/dx20OH6YyGuHJDKxva67hkVSNejxS8/z/f+xw/fKKXU+NJbrlqHa++aAUP7h/kH+7cTSqb4yXntvHIgUHSWcWrL1rBWy9bzYXdUUSs98nlFB/7yQ7eetkqNndFnfcdS6SpD/lZ21qHCPS01HJ4MEZOwV07j3PJ6gb+d89Jbrq4i3DAWzDqnUlM9p+c4Bc7Brj5+SvZMzDOY4eG2drTyGVrmvB5PQyMJhx34NrWWnb1jy2om+voUIzbHjzE/3nFeXjsazmZzOD1CCG/l/93z3N857EjKAXfevdlrG2tc173/cePsvPYGC9c18xbLl1FbdDH8bEEX//NQR4+OMQfXbOea89r5+5dx1nfVsealloydqbU/hOT3LP7OJeva54SMzk2EudffrWP/91zgq/87lbne3ju+Dh7j0/wygtXcGI8wZ6Bca7c0MqzA2P8cFsv/+cV5znfo27j072jnJpIcmF3lOetaqR3OE5TbYDWSHCKZTKesMSksSbAcyfGUUoVvJ/m+48fJZ1VvOqiFdSH/ORyiudOTHBuR4RjI3H+8NtPsrmznus2tXPRygbu2XWc9voQV6xvcd5juvcGODIY4xc7+3n3lWunPUYzMJrgB9uOsv3oKL912Uqu2dg+7bH6857XUc+dzwzQOxzj0jVNM7633ys01wVnbMNCYMTEUJJth4f5r0cO85k3XOR0UBo9+lvdXAvAJ362my2rG/nh71/OJ+/czf17rSKaXo9w9bltfPVtW7n1/gN8+hfPsqGtjieODPNzu3jiR1++kfe8eB2fvWsPl65p4soNrXztNwdprw9y+foWPn/PXj5v18Z64dpm1rTWcucz/Vx5TiuRoI/btx/je4/38oYt3XzmjRcBVrrytx89wurmGjZ3RfnmQ4ecDq8+7ON1l3SxaUU97fUhrt/cwX8+cpj3f/sJ/B4PqWyO2x48xK2/s7XIMsmRyuT476eP8YNtvZwYT3JhV5TPvflivv94L1+6bz//dM9e0tm8NfWH16zngy87l7d+9WEO2TXAdEceT2X53F17+PZjR8nmFBd2R3nrZat56aZ29h4f598fOMTTvSN88rUXcPHKhhm/q5/v6OervznI26/ooTMa5usPHOTzd+/lhs0r+OybLuK/nz5GNqc4MZ5k2+Fhpw2fuWsPP33qGN2NNdz77Al++tQxbn//i/j6Awe59dcHEOD+vSe5ZmMbf/TtJ7nx4k4+9foLectXHuaxQ8PO+Xf1j3FeR4Ro2M9k0iqp8td37OR/9pwgnVU8eXTEEZOvP3CQHz3Rx8s3d/C1Xx/kq785yK6/vZ6fPnWMr/z6IO960Vo6oiEAfu+2x7ln93HnPCJw08VdPLj/FJ0NIepDPiZS1iRJ/RudSGZYEQ1x0coGfrFzgP/z4x38zWvOJ+DLO2GUUvzFT3aQzOT4p3v28qs/ewkP7DvFe/5jG7/+8NXsPDbKtsPDPHV0hNseOuy8bmNHhF984Cr+8+HDfPauPUwkM3zld7fy4nNa+fQv9vDEkWFaI0G+8FuXcPv2Pj57915uvLiL1rogA2MJOhvC7Dw2yp98dzvfe88LaagJAPChHzzFr587RXNtgHt2H+d9L1nHh2/YyDcfOsQ3HzrMxo4Iv3XpKi5f3+K4EzeusCyTUrPgv3Tffta21PKy8zt4739uY0U0xBd/ewtgDbREmFXgTgcjJoaS3LVrgB890ceHrj+XFdFwwb6xRJpIyM9V57Tyld/dyncePcIuuxx973CMrasbueqcVu7aNcB2e6b5c8fH6YyG+OUHrkLEuglu+H/3c3zMclt95dcH6BuJ8/yeJkbjaW65ai1/cPV6Hj80xJGhGO31IV64thmPR/j7117gtOVjrzyPD37vKX65Y8ARE+0rz+YUSik+fsdO3vbCHsYSadrrQwR9Xi6yO+ho2M/33vNCPvGzXQBsXd3EX96+g7+8fQfXbGxzzpNIZ/n7O3fzjQcPsba1lmxOcdeu486+sN/LG7Z0s661lhsv7uK1//YAzx2fIJtTHBqMUR/yEUtluajb6lRjqSy/2nOCkN/D5WtbuPfZE/z9nbt56aZ2Pn/3Xu599gSpTI4H9p0qEBOlFG/+8sP0jcTZ1FnPl397Sz7lOJXlvr0n+cTPdhPweth5bBSlFH0jcd6wpZv/fPgwR4fy8aG+4TiXrmniO7e8kH/4+W6+fN8BkpksfcNxVjfV4PUIJyeSTCQzxO3CmLmc4qmjo1y7sY3ffsFqvr/tKNuPjNDVECYa9ttB8TQHT03y4nPa+NWzxwvK/J+aSJHMWJbNocFJsjnF8dEkx+yswN7hGB3REEopHtx/ims2tvGnLz2H5roA//Y/+/mvRw5zfmeUP7h6HUeH4s4kyUjIsoL1QOeWq9Yylkjzxf/dz6bOen7nBavzv9+4NXfoopUNPHV0hP0nJth3YgKAE+MJx0338z++kiNDMZ48MsKjB4cct5kuLplT1qDr3I4IX7pvPzUBL7FUls++MetUW+gdjvPQ/kE+/IOnefCj1/DowSH2Hp9gV/8Yl69rca7Jdee18W9v3cLvffNxfvxkHx++YSN37zrO8bEEI7E0//10P2/c0s0rLlgBQHNdgI76EEeGpsb7vvrrg1zUHeVl53dw4OQEk65B0a7+MV7/xQe51RbBhcTETAwl0Sm/pYKYE4kMkZAPr0d46aZ2NnXWW+ma2Rz9Iwku7G7gj67dwBXrWhwf71giTbQmgMcjiAirmmuoD/mZSKZJZ3Mk0jmOjcSd9Nn2emt0urWniddd0s0V61umWEgAkZCfrT2NjCczjt9e3/SZrCKnrFTcw4OTjCcy1Iemjp9Cfi+fuOkCPnHTBdz0vC5efE4rR4ZiU2ImfSNx1rfVce+fvphXXrDCcX0l0lkiIR9/d9Nm3n7FGhprA6xsquHYaJwT4wmyOcUHX3Yuz/z19Y41N5nKMDyZ5vk9TXz6DRfypq3d9A7HyGRzHDw1yZXrW4iG/VPK1QxOpnj00BDJTJa7dx1nYCzhBGEnkxkG7OdXb2ylbzhuF5bMsrq5ls6GMIddnc/AWMIZKKyzrZXjo0kGRq3tLXVBTo2nnPVf+kbinJpIksrmePG5rVy9sY31bRH6xxKcmkgSCfmIhPyMJ6wioCubwrRGggVB4qFJq6rw0aEYR+xRdd9I3FV40y6TEs8QS2W5fF0zm7uirIiG+bubNrP3Ey/np3/4Im7YvIKI/V26XV0TiQx19m/zw9efS23Ay4GTEwXX8LhdIPFF65uttgzHnCSMsUS+WGVrJMi157XzZ9efy6bOfHxmPJGhp6WWroYwhwZjHDw1CcBLzm212552iUmMXf1jpOzvVd9Px1wp9eOJNPVhPwGfh0tWNTAwliCZyXJ0KMZV57Tymz+/mtdc1MmPnuxzqjLXh/ysaq7h8OBkwWdTSjEaT9E3EmcimWEskaF3OF+QtW8kTjKTo8m2ihYSIyaGkuhOvVSAb9wWE82KaJicgudOTBBPZ+lssISgPuwnmcmRzFgFISNFHXldyMdEMuME9PtHE05n2GGLSTl0Nlgdou6QHMtEKTI5K7B+eChmxUzC/tJv4qK9PsTxsURBUDmRyTKRyNAQ9iNixSIyOUUmmyORzhKy01GdNkXDHBtJOFZDZ0OIgM9DTcA6Lp6yRq8NYeumXt1cQzqrODaS4PBgjFXNNayIhqbM49GWxSvtEWrvcF6AJ5NZZxR6bkc948mMYzF2NYRZ1VTjjGRzdiaQdil12dewbyRO/2iCFQ0hWiNBTk4kHTE5NhJ3amLpJIaVjWGUgmcHxqkP+YmEfPQOx5lMZelqCNNeH+LEeH4muiMmwzF67bYcG4k7MSXdqev/i61inzffZWlrxC0m48kMdUFru4jQHg1NyXg6YVvDW1Y32tc07vzOxxMZRzTqgvnfa13Q+q1aqbnazVvDkcFJDp2y2nxRt2VBjhaISZxDttgcHYo5Ax33IG0sbsXyAFY11aBU/tiVjTWE/F4uX9dMNqfYe9wSxvqQlZV4uMgyiaWypLOWNdpvnyuezjrXXX/OrsbC67oQGDExlETfzKUyYsaT6YIbbYUtHtsOW3503QG4R46WVVDYkdcFfYwnMo4F0D+acDrGjmj5AcNiMdFtz+ZyTh5+71B8ighOR3t9kFgq67QFrJjJZCpDrf25dYpvImNZVfp/zYqGEKcmkhyxYyX6mmgxGUukmUhmaLSTFLTF8vjhIeLpLD22JXGsKPVaVzt+4TprVN03EsuLSSp/LTd2RIB8DbLuxrDd+VntGZxMkc4qR7RX2KLSOxyzLRZLTE6NJ52yJIl0jh19owB0NVjp1SubrL8nx5PUh31EQj72Dozbx4RpiwQdVybkxeSZ3jFnHo9bEHVnpy0yLXalyP++dAHPLKlMruA77qgPTUlf16Xb17TU0Vjjty0TbRGlGU9kqAl4C4SrLuQjp6yOedxO5FjdXMOhwRiHBicJ+jyca1/zkSIx0Wvm9A7nLTBdwkcpqwK3brO+no8dGiadVaxssn433Y3Wdr26aSTkZ3VzLSfHkwXJHCPxvPX07EB+1Uv9u+kbjlMT8Dq/u4XEiIlhCjlX/nqpORiWmyv/Y+y0O8ontJjY4lIoJukpLqaIbZnokWUqk3Nulva5WCZRLSaFHVImp5yZ0qmsJSzFglYKfe79JyecNsdTWceFAjiWSCKdJZEpbZkAPHlkuOD/moCvoK0N9k3dY4uJTl5YrS2TIjeXtkwuW2OJyeHBmDPyj6UyTCYzhP1eVtmdkhaTroYwK5tqGJxMMZHMON+v7qy1ID/dO0o2pxw313gyU+CXf/SgteiUHtnqzg+wLRO/IxKdDWHa6kNOzCSdzTmd7EOuQpvP9I04iQu9RW4gbeWWotjNNZm03I7ugU5HNMTxIjHR4tYWCbKyqcayAoosk+JBh/5/wh78WPOVahmNp9l+ZITVzTU01VpW5mgsLyZHhyyx0c8dy8T+q+eN6PfX39sD+04V/K8twV39Y/g8Qsjvcfa5F3gbcS1Opgd3kL+Pe4djdDWEKxKAN2JimMKpieSUm9vNuKtTBZdlUtRx6o57LJ5mLD71Bq0L+pybU/PkkRFqA94CsZqN1kgQn0dcoz7bMskqstnCuSrlurkADpycpCViWUiJjFVePaItE59LTNJZ53+N7py3HRmmJuClPmy9LuDzFLQ1avuu2yJBgj4Pv37O6kS0ZVK8mNbRoRgtdQEaawO01AV56uiII5gTySwTySy1QZ/TyW8/OkJNwEtDjZ/VTZZgHRmMOaN1bZGE/F6aagMu69KyTAB29+dHuI8dGiIa9jsddkd9CL9XnGvr/o47G8K0R0IMTqZIZXIFqzDqQUPY7+Vx+5y1Aa/T6fWPxvF6hLbITGJi/76cWMZU91SH7WZzzxQ/MZ6gLuijNmjNOdp+dISUPc9oPJG2LdipVjRYbjQdM9TW5LYjw/Q01xK1f1sj9u9dX39d123fyQlOTVjXoHg9Fn2vtNYFCfg8PLTfEtuVtkWyoiGEiGUBRkI+RMQZgLjFZDSWd80+dmgIrRn6Pu4biTvCtNAYMTFMQbtWagLeadxche6iSNBHbcDL4cEYPo84nZD7ZrdM+ak36GQyw0QyfwM83TdC+wyujVJ4PUJHNOSs/Kg7ardl4rS1LDeXdf5YKkuzPdpMpHNMJPNurqB2c6UtN1ewhJsLrI64IxoqGAmGA16nM2+wOyCPR1jdbFkOXo/Q1Rh2Onp3sPbIUMwRiu7GME8cya/LEktmiKUy1AW9RO2OPZ1VzkhUj2SPDMWcCsbu2FRnQ4hnB6xOfkU0TKs9N2HXsVGnRMnxsaQTXwHr2mvhrA/5nU4x4PPQXBugvd56j1MTScfFFXZZcVt7GhmxO8AtPU1O6fj+kQTtkeCUOUhu6ossE/23YKATDZHJqYI100+MJWmzf6MrG2sKYi5jjpiUtkxG42kmU1nqQlbMBKyswTUttU78yx0z0QOllrogz/RaLsK2SND5nHp+jr43PB5hZWOYwckUIvlBSdDnpT2Sj0UCrGrW32c+CD/iqkSwu3+MjvoQDTV+R6T7RuIViZeAERNDCXTg7pJVjfQNFy7N6/ilXaM/EWGF/aNvrw85HYC+AQdGE+QUzuhcUxfyMZ4sXOo1kc7NKfiu6WywAt6DkymnjlY2p6bULirPzZWP10RCfoI+D/GUlV1UF5zq5kpmcgSLLRPbOsvmlPNcUxPwOu6rRldWzSrbcuhqCOP3epyOxO3qOjocc0ar3Y1hp9MCy2Uymcw4rjR9nO483J1P/2gCn6dwMptOpABLWPSg4OCpSda31Tkl+4s7I32e+rDP6eC7GsJ4PEKbfS2PjyUYskflm7usORINNX7OaY8473NpT6NTOt5KApi50ysOwOuO2y0EemAw4ArCnxhPOO3qdrnpdK2vcTv13Y0O6muXWV3Q54gzWBNgLYvBEs7JVJYW17W9ckOLM7C5dE0TqWyOUxNJxzJxt1m/b2c0XDA/RlsU+tho2E9jjd+ZwwQ4wgxW6vKKaIjuxjBHh6zsrpFY2om/LDRGTAxT0JbJ1p5GkpmcY5pDvpRK8c2mR9ErXFaFHkFp66b4NRE7Q6a4/MbpiElXQ5hjo/GCLBnLMiksk1KOm6sm4HNu2Lqgj3DAy6B9DYrFJJnJkkxnpwTgw7ZrCQqvCUBtwOdc0wZXIFTXDNMjXi1COqMrk81xbCThdDbFnXosmffnA07wVlsS0bCfaNhvWSZjiQLht86nXV4eomG/IyY5ZY2m9ft0FXXy2lLSMRPIxzq0m+r4WJJB2zLRWU+rmmocwawJeDm/05qD0zsco380PuW6FRPyWy5D3SE7v81g/prqmJA7meLEeNJp10rXNVzTUusE4Eu5ZCF/b9SH/IT8XqeNPc21eDxCfcjvxLXOt0ueBLwent+Tn6WuZ6z3jsQdIXSfb2VRnETjiInr861qrnWSKgBG4tY11vdQZ0OY7oYaeofzcaHi72+hMGJimEL/SJygz8Nm++Z2u7ocV0Kw8GbTHZ97NKlvEP0jLpUarBSctEeNeiQ3UwbPdHQ2hBgYTXDUlTDgzuYqbtNs6BFtXchHyOd1MpqcALzP7eaaGoCHfAZX8Qg7HMgf6y45o0VE+8Lb7Yw2nQQZYVoAACAASURBVJ3WP2rNWSnO8PF5hJa6AJOpDJPJLLVBb8F+t+isbq7h8KCVAVZ8nXXH3hm13GI6oAxWXErvL+7kdHvcMRP9e9DX8cR4wnFzXWhPwlzZWENXQ77T0+9zdMhKT+6cpdMTESIh3xTLxO3mcsRkTJf/t5JLtPWpO+6WugBtkRDjCWtwUypZBPJWuz6HFvY1LdZ3Fg1PFZOVTWHnu/WIZfGDlX2o4z3uQY5+T3dyA+S/T/dveHVTDYddbq7RWJqgz8O6Nqs9+rr2Dseddp01bi4R+b8i8qyIPC0iPxaRBnt7j4jERWS7/fiS6zVbROQZEdknIv8slUhVOIvQN3K3fXO7M7pKuRIgHyPodHVQdQHL7NedYbGLSccf+kcTeD3C2lbrBjg9MQmTySmetGMIkaCvIGaig6PluLkgP7KLBH2E/B7HMqkt4eZKZKamBkP+WnQWfR6dHuz1SIG7UAd0dccT9HlpqQs6lonuDNxuLrA67EjI78wz0W3Uo273SHRzV5THDg2x78TEFAtQi57+Lv1ejyMobZGgY21MsUxcnZy2THSH1VwbwOsRTrgskwvt0irdTWFHMFZEQwUZZclMblbLxDqnPz+ZMDl1oNNSayVnOItpJTMk0jnHMulqyAtzfdg3g5sr/1vVnxWs8jh1QZ8jTg01fif7TRdj7Gmuda5RR33I+X77huOOVe6+n7RorGwsFpO8aGt6mmvoc81lGYmlaawJ5Ad30RDdjTUkMzme7h0peJ+FpurEBLgb2KyUuhDYC3zUtW+/Uupi+/Fe1/YvAu8GNtiPGxattcuQY7aLwZnI5p5gpTNmQtNYJq4OwOMR6oI+J4A8netgYMzKrtGd7lzSgp3z22392dP9REI+GmsDBTGTK9Y3090YLnArzYT2qdcFfYT8Xk7ZlklkipjkSmZzQb5TLrZMdExDT4DUbO6Ksra1lhesbXZ9rpAjxtrqctwgTpwqaJfyyDCZyru5NtjxCD27HeAdl/eQSOc4MZ6cItraSuioz7dXB+HdlknxyPbqjW287yXreN6qhrxlYh/r8QitddYs+KHJJA01flY21XDTxZ1cf35H/j0bwtQErIl4P9h21Lpu0dk7vQLLpETH7PEIbZGgY5noNGX9/Yb8XjqjVgcfCfkZnEySLIoJgnvgY1sm9v9/fO0Gbnvn853vMRr2M2zHLTrqQ2zsiHDJ6kZWNITw2AH1SMhPfchH30h8SjYXwDp7UKUHV5pSlslrL+mmoSbAzbc+zOHBSYZjKRpq/M531NkQpse2mn74RB8Bn4eW2soUfaw6MVFK3aWU0k70h4HumY4XkRVAvVLqYWVFir8J3FThZi5r+keschoRe0aze9KXvmGLR/jOCLOo46wP+aePmYTyo726oM957WkF4O2O59REkr95zfn4vGLPULfE5DUXdfGbP78Gv7e8n3yBm8vvdUbV+Xkm2s2VndbNlXcblbZMokXC1lQb4FcffElBpWNrrom2TKx0WS3YusNYEQ1TG7DiT5PJrCNWl69r5hcfuLLg/Ta0R7juvDbnvd3ozts9t6MlYlkmrZEgW1c30d0YdgpFauqCPj58w0aCPi9rWmqpDXi5sDt/zvb6IMfHrWyuJttS+aebn8clqxpprg2wsSPizEb/1OsvdKzfmeaYaArdXGl8HnESBTQd0RDPHZ/gDV98kM/80ioa6k45/uJvb+HPXnYukVA+llU88An4PAR9HsfC0fs7oiG2rM7HQ6IuqyEa9vPzP76S971kHX6vh56WWkfYOxusRdnGExn83sI2b2iP8J1bXsDLN3cUtCEfgM+fY01LLd9692WMJdJ86b79jMTTRMP+vIuzIcwV65q57rx2Ky3YToyoBNVe6PGdwHdd/68RkSeBMeAvlFK/BrqAXtcxvfa2KYjILcAtAKtWrapIg5c6SilOTiQds72pNlAwP2DSnvNQEyjsPC9b28RfvmqTU59IE7FHYMAUP7TOkBkYTdDdGGZDWx1+r0zxFZfDutZa3nnFGq7b1Mbl61r40n37rXkmtmXim+MNpAWtznZz6fepDRRaJhPJDDlFSTfXtRvb2d0/7rivNDpm0lBGMkBnQ5jfPHcKpRT9o1a6rJ6ZXRPwcW57hM1dUR45OMjgRMq2TKz3FxE2dtRPec/3vngd9z57YsrIt6M+xDuu6HGKCUKhZbJldRO/+fNrZmzvyqYadv5toWOgrT7E4cFJGmsCTqq1RkT4xQeucv5/wdpm/uz6c/mXe/c582JmIhr2O7Wx9KTSYi93RzTEnc8MFLUpPzrXRT/dA6RS85wiIR/H7Qmi082DKhYTd1v+812XOb+f7kYrjtERtVyUxW12W6eazoYw53fWO8VCNRs76rmwO8qzA+PEkll6Wmp4xQUdZLI5zu+sR0T41996Hu/+5uMVc3HBGRITEbkH6Cix62NKqdvtYz4GZID/svf1A6uUUoMisgX4iYicP5fzKqVuBW4F2Lp1a/Wsd1lFaNeQngvQEPYXpBvGU1Z2VLhITPxeD+960Zop7+e+QYszqbSrQGcg3XhxF8/vaSoI/JaLz+vhr169yfnf6/EUZHN5vXMTEy2mEdsy0egRqXZraaEtTg0GOLcjwr+85XlTtmshbiij2F5nNMxkKstYPMPAWHzKHJxffOBKRIQdfaPsmRhHqbxLZjq29jRx/4eunhL78HiEj7+68JbSSRGtdXO3FjUXdkW5e9dxGmv8M669oXnfS9bzzivWlLT2ilkRDfPgPmuC31giMyUxBPJuu4+8fCP37TnJY4eGSlq/BXOnSiRq1AXzlkup80Bhdl7x792dUNDVEOaRA0Oc0x4pWXy0FAGfh5/90ZUl921oi/CTJ/sIB7xcHG6gJuDj5kvzA+aQ38t/vOuyss5zupwRMVFKXTfTfhF5O/Aq4FrbdYVSKgkk7efbRGQ/cA7QR6ErrNveZjgN9Mx3PfptqAkUlGjQlXLDZdzokL8pi0159z7AqfR6OlZJKXweKcjmmqtlsqE9gs8jrGqqLYiHFE9a1EJbyjKZDj06LSd+o+Mux0at+lW6/pNGj2hrg16nIONsYgJTM4WmY31bHZGQr2AkP1det6Wbz92zl+FYmqYy/fXlCAlYnbKuGN03HC+ZAXbzpSvpbAjxrhet4W0v7GH/yYmS18jd+ZeyPLSL0yNTLXONtkyCPs+Mn6Gr0Wr3sZH4nKo9TMeG9jprzlYyU3ZccKGpupiJiNwAfBh4jVIq5treKiJe+/larED7AaVUPzAmIi+ws7h+F7j9DDR9WZC2R/K6REZDjb9gVm0iY4lJuTe7vkFLmfLFVVkXEq9HCrK5ZppJXYp1rXXs+Jvr2dRZX2CF6bTboM+DCM6kwWCZ1wPcbq7ZLRMdx+i3xWS65ISagM/5rAt5Ld+4dSX3f+jqsr/vUnQ1hHmRvUJhU+3CdnTuIp/uCZ1uzmmP8Hv2iofhgLcghuTGbSEUT7CF/HWtC051pWn0dxqdxYWpC2U+OzBedrr6TKxvy8eximNxi0XViQnwr0AEuLsoBfgq4GkR2Q78AHivUmrI3vc+4KvAPmA/8PNFbvOyIZ3RYmL9NBprAgxPuiwTe+3yYitjOvSNUuqGcY8OF+KGcmNZJu6Yydx/6roD1VZHwOtx3FkilqWlxWQunW3ezVVOzMQSj73HJ5hMZadNl9UiZz1fuGvp9QiNp+F2LObNz18JULZlUi76+hw6NcnAWMKZq3I6uC2EUinkOsY3kyWhB0+ziokdu5hIllfJejY2tOUt1sYKrFVSDlUXgFdKrZ9m+w+BH06z73FgcyXbdbag3VxaTKJhP2OJDNmcwusRZ05FuVN59I1S6ubUGTLJTK7qLBM3WkCK06HDfq/jAgyVKa4A4Tm4udoi1ix1XZG5Y5p0WZ3BBVbBxGrjZZs6eMcVPU4m2UKh4z6PHRpGqalzM+ZCYQB+6u9xpoGRRn+ns1sm+e+x3LlPM9FSF6CxxkpLLiexoxJUo2ViOIOk7eqpPtvNpdc90CPweKp0Gux06BtluhswX7ZkYW8An1dbJvbnmYeY6M9bLHghv9dxAc7lmtTOIQDv9QjtkaBT0HG6tGl32xbSMlkoAj4PH3/1+VMy2+ZLS10Qv1d45KBdZXceMbeCGF6Ja+h2c01HtEzLpLk24NTdWoiYiYg41olxcxmqAi0mAVcAHvLrJOj1zsslMouY6I6veNQ/X7weK51XzzOZj2Wi3VzFnXTI73VKfp+Wm6vMEWRnQ9iZNDmdm6smUBk3V7Xj8QgromF2HrOqHc/PzWVdt+KFsTR1C2iZeDziWCcL5eJd327FTcqJxVUCIyaGArRbyOcKwAPOrF7LzTUXMZnezQX5UV7xjOP5MiVmMsfUYDdaPIvbGPR5XJZJ+bfS+rY6mmoDBUHTmXBPBJ0uq6q2gskM1U5nQwilrAFQ+wzrn8zGbAMfxzKZwZLQHXk5BUUXWkzOW1GPSH6i6WJzdv3qDLOSKgrAa8tk1K5GOmc3V3jmoGVdxSyTwpjJQri53EFuvV2L1Vyuyfq2CE/85UvLPl7PoG+uDZSczwLFlkn1xUwqibvMy3xmdwd8HkJ+z7S/1XJiJiG/h+f3NHKJPaN/JrSYlCM85fCmrd2c1xGZcUGxSmLExFCA7nwDTjaXbZlM5tfZnssofLYb0F3qfSGZOs/k9I1w/XmLR6Tu61BudtvpoF1bMxXAdFsm7mD82UC+WOP8Z3frEkKlKMeKFhG+/97LyzqXzugqd9LibAR9Xrb2zD4ptFIYN5ehgOIAvDbbR1wB+LnETOpnERPnBq2wZTK/mIkOwE+1TEo9X2jKqVmmJ0KG/d55fdaliLZMFmLCa72r8nEx5QTg50LezXVmAuYLzdk1hDHMihYT7eaKhHx4xBWAz2TnZJZ3RMN0RkNsWjG1RhSUF9Q8HfIxk0JxPB2mzeZyuZxKVQ1eKHQRy5ktE+2KO/tuaUdMFmAFwd9/yfppEyNmi6nMlUvXNLG5q75gtcmlzNn3yzPMSH6eidX5ejxC1FWfK5EuvXbHdNQFfTz40Wtn2O8v+LtQeD0eMtmFtUymZnO53FxzuCZzxV1OfDq0a6vYejobWN9Wh88jzmJU8+ENW6YvUu64ZBfIkljZVMN//2HpWltLESMmhgKKZ8CDFYTXBQ3nGoCfjYYaPyLVOQNeoycklppnAiBS2ZhJU22AL771khmLJJ7NlklXQ5jHPnbdgszUn4m1rbVcfW4rz++ZPbh+NnL2/fIMM5JxJvm5xcTvTFq0AvALJyZv2rqSDW11C94JeovWM1kIy6RY8PR2q05XZeMUL3eVhS9F2O9F5OwUE6DiQgKW9ffv77i04udZqpgAvKGAlN35Bnz5zrEh7C+wTOYSgJ+NptoA157XvmDvp/HK/KoGu8kvXVsYs9CurUoG38tFRKgN+M66OSaG6sH88gwFZLJTLZPGmgDPnZgAmHa982pjIbO5VjbVcNefXMX6ohUGddC9ksH3uVAT8E5bGt1gqDRGTAwFONlcrhhAtMYKwKez1ki/WjrPmdAxk7w4zs8NVSrjxnFzVYm43nLVWtaVOaveYFhojJgYCijO5gLLMplIZpy1totXWaxGnJjJAlgm06EttGoR19+7cu2ZboLhLKY6hlSGqsGxTIoC8GCt1Q5zWwjqTOHO5vJ6pCIB8uL1TgyGsxlzFxgK0NlPbjeXrs81MBYHyl+y90yiqwanc7mKzQjXIrIUxNVgqDRGTAwFpErEGPSM4IFRqwz6UhiJ6/anMrl5x0umI+xYJkZMDIbq7xUMi0qmaKVFyC8DOjC6lCwTS0CSmcpZJtoimcsqiwbDcqXq7gIR+WsR6bPXf98uIq9w7fuoiOwTkT0icr1r+w32tn0i8pEz0/LlQTqbwyOFAWsdM+m3YyZLYSS+GJaJkxq8BK6HwVBpqjWb6/NKqc+4N4jIJuBm4HygE7hHRM6xd38BeCnQCzwmIncopXYtZoOXC+lsrsAqAVcAfkyLSdWNQaZQaJlUpr1ONtcSuB4GQ6WpVjEpxY3Ad5RSSeCgiOwDdG2DfUqpAwAi8h37WCMmp0E6q6aISV3Qh88jS9IySaazlbNMnHIq1X89DIZKU61DqveLyNMi8nUR0VXVuoCjrmN67W3TbZ+CiNwiIo+LyOMnT56sRLuXPJZlUtj5iggNNX4nNXgpiInXFsRKxkxMarDBkOeM3AUico+I7CjxuBH4IrAOuBjoBz67UOdVSt2qlNqqlNra2tq6UG+7rMjkcvi8U38W0bCfiaQ9aXEJiIljmWSy81rLZCZCVVSby2A405wRN5dS6rpyjhORrwD/bf/bB6x07e62tzHDdsMcSWWUs2SvGyujaxJYGp3nYmRzmQC8wZCn6uxzEXHX2n4tsMN+fgdws4gERWQNsAF4FHgM2CAia0QkgBWkv2Mx27ycyOSmurkgH4SHpeHWycdMKpfNVR/285JzW9my2qxvYTBUYwD+H0XkYkABh4D3ACildorI97AC6xngD5RSWQAReT/wS8ALfF0ptfNMNHw5kM6WdnPpWfBQPbWoZsLrcnMFKtRer0f4hlnfwmAAqlBMlFK/M8O+TwKfLLH9TuDOSrbrbKFUNhfkZ8EHfB48FRrpLyS6hH4yk3OWtDUYDJWj+v0VhkWlVDYX5FeyWwrBd1icmInBYMhjxMRQQKlJi2Blc8HSiJfA4swzMRgMeZZGz2BYNNJZVbLz1fW5loxl4jWWicGwmBgxMRSQzuYIlChcqLO5lkoarM/l5qrUPBODwZDHiImhgMw0lokWk6WydofbGqlUbS6DwZDH3GWGAqaLmTQ4bq6l8ZPxuQTExEwMhsqzNHoGw6KRzuYKVlnUNC4xN1ehZWLExGCoNEZMDAWkswp/ic437PcS8HqWTgDe9RmMZWIwVB4zm+ss5HuPHeVL9+8n4PXwf99wERd0R519mWncXCJCY62fcGBpiInPWCYGw6JixOQs5L69Jzk5lmQ8meH+504WiEkqq0qWUwH4h9ddQGdDeLGaOS+MZWIwLC5GTM5C4uksPS21HBuJ0zscK9iXyeUITJNKe83G9sVo3oLgM9lcBsOiYu6ys5BEOkvI76G7qYajQ/GCfelM6UKPSw1jmRgMi8vS7zUMcyaezhLye1nVVMPRIstkukKPSw13arDXTFo0GCrO0u81DHMmnsoS9ntZ2RimbzhONqcAUEqRnmY9k6WGW0CMZWIwVB4jJmchiXSWcMDLyqYaMjlF/6jl6srmFEqxTCwTk81lMCwmS7/XMMyZRDpHyOdlZWMNgBM3ydgWynIQExMzMRgWl6XfaxjmTNyxTKw0Xx03SWVzAMvCzWWyuQyGxcXcZWchOgDf2RDGI9A7ZIlJJmssE4PBcHpUXa8hIt8Vke3245CIbLe394hI3LXvS67XbBGRZ0Rkn4j8s4iY3mMasjlFKpMj7Pfi93pYEQ1zxBaTtG2ZLIeS7QXZXEZMDIaKU3WTFpVSb9bPReSzwKhr936l1MUlXvZF4N3AI1hrwd8A/LyS7VyqJNJZAMIBq7Nd2RTm6LAVM0k7bq6qG2PMGWOZGAyLS9X2GrZ18Sbg27MctwKoV0o9rJRSwDeBmxahiUsSLSa6+u+qphoOnpokl1OkHTfX0u98C2Imy+DzGAzVTtWKCXAlcFwp9Zxr2xoReVJE7hORK+1tXUCv65hee9sUROQWEXlcRB4/efJkZVpd5cSLxORFG1oZmkzx8IHBZWWZeDyCdnYay8RgqDxnpNcQkXtEZEeJx42uw95CoVXSD6xSSj0P+FPgWyJSP5fzKqVuVUptVUptbW1tnf8HWULsOzHOjr7RvJvLFpOXbWqnLujjR0/25WMmyyT7SYuIyeYyGCpPWXeZiPyxiNSLxddE5AkRednpnlQpdZ1SanOJx+32+XzA64Dvul6TVEoN2s+3AfuBc4A+oNv19t32NoOLv/3v3XzkR08TT1mCocUk5Pfy8s0d/PyZfsbiGQACvuUxktdxE2OZGAyVp9wh2zuVUmPAy4BG4HeAT1WsVXAd8KxSynFfiUiriHjt52uBDcABpVQ/MCYiL7DjLL8L3F7Bti1JjgxOMjyZnuLmAnjdJd1MprL8cucAsDzcXJC3sEw2l8FQecrN5tJ34yuA/1BK7axw+u3NTA28XwX8rYikgRzwXqXUkL3vfcA3gDBWFpfJ5HKRyymOjSQI+T1TsrkALl3ThM8jPNU7AiwfN5exTAyGxaNcMdkmIncBa4CPikgEq0OvCEqpt5fY9kPgh9Mc/ziwuVLtWeqcnEiSyuZI53LEUpYry22ZeD1CRzTEkUFrvslycXPlYybL4/MYDNVMuWLyLuBiLLdSTESagXdUrlmGhUQvgKUUnJpIAUxZy72zIcyjBy1Db9lZJiY12GCoOGWJiVIqJyLHgU12cNywhOgdzi+AdWI8CTBlLfcu13K8yydmYrK5DIbFoixhEJFPA28GdgFZe7MC7q9QuwwLiFtMTo4nAAj5ii2TkPN8OUxahPxkRRMzMRgqT7lWxk3AuUqpZCUbY6gMBZbJWGnLpHNZWiYmm8tgWCzK7TUOAP5KNsRQOXqHY461od1cQV/hV+8Wk+USYzDZXAbD4lGuZRIDtovIvYBjnSil/qgirTIsKH3Dcda11vHswDgnxhOE/V6KM7vdMZPAMrFMvGKyuQyGxaJcMbnDfhiqiGQmy3PHJ9jcFZ32mFxO0TsS51UXrODZgXFOTaSoD0392ldE3TGTZSImjmWyPD6PwVDNzCom9qzztyulrl6E9hhKsP3oCP/2P/sQgT+4ej0XdjcA8NOn+vnwD57ioY9eS3t9qORrT00mSWVynLeiHp7sI5tTU9KCASIhP/UhH2OJzLJxc+nPYSwTg6HyzDpkU0plgZyITD/8NVSUnz19jHt2H+eXO4/z8x0DzvZTE0lyCvafnJj2tX128H1ta60TNwkFpooJ5OMmy84yWSbiaDBUM+W6uSaAZ0TkbmBSbzQxk8VhIpmlqTZIMp11yqEATCat2eyHB2Ncvq70a4cmrUmKLXVB6kN+BidTJS0TsOImzw6MLxsxMTPgDYbFo1wx+ZH9MJwBJpIZ6oJeRCgQkwlbTA4NTk73UkdMGmsCREI+BidTBaVU3HQ2hBFZPp2vyeYyGBaPcmfA31bphhimZzKZoS7kI6cgniphmZyKOdvu3X2cuqCPy9Y2AzASSwPQUOsnErKyu6ezTN60dSUd0dKxl6WImWdiMCwe5c6AP4g1470ApdTaBW+RYQoTyQy1AR/pjHJKyANMJq3nbsvk43fsJJHOcd+HXkJt0MdwLIXPI0SCPurD1tc9nWVyQXeUC7qXT2jMZHMZDItHuW6ura7nIeCNQNPCN8dQislkho76EIlMjng6X6xZu7mODMVQSpHM5OgbiaMU/PsDB3n/NRsYjqVpqAkgIkSCtmUyTQB+uWFiJgbD4lHWkE0pNeh69Cml/gl4ZYXbZrCZSGaoDfoI+z0kSri5YqksJyeStqhAfcjHl+87wGgszfBkisYaS0Qi9vySsP/sGKmbmInBsHiUu2zvJa7HVhF5L+VbNYZ5omMmYb+3wM01kcw48Y/DgzEOnLTcXe+7ej3jyQzP9I0yHEvRWBMAcGIm07m5lhtmnonBsHiUKwifdT3PAAeBNy18cwylsLK5fIQDhWIymcqwcUWEJ4+McOjUpLNWyZUbWvjUz6F/NM5ILM3q5hoAJ2YyXQB+uaFLz5t5JgZD5Sl7cSyl1AH3BhFZU4H2GIrIZHMk0jlqAz5Cfm/RPJMsV6yL8HTvKIcHY5wYT9BSF2Rdax0AA6MJhmIpLl5pzZg/6ywTEzMxGBaNcp3nPyhzW9mIyBtFZKeI5ERka9G+j4rIPhHZIyLXu7bfYG/bJyIfcW1fIyKP2Nu/KyKB+bStmtAZW7VBL+EpYpIhGvaztqWWbYeHOXhqkrUttYT8XpprAxwbTTASS9FYq91ctmVylgTgTTaXwbB4zHiXichGEXk9EBWR17keb8fK6poPO4DXUbTAlohsAm4GzgduAP5NRLx2jbAvAC8HNgFvsY8F+DTweaXUemAYa5nhZcGEvWZ7RMdM7AB8JpsjmclRG/TxygtX8PDBQXYeG2NNSy0AHdEQ+09OkM4qJwCvCzyGfGdH52osE4Nh8ZitVzkXeBXQALza9bgEePd8TqyU2q2U2lNi143Ad5RSSaXUQWAfcKn92KeUOqCUSgHfAW4Uq5b6NeQtpduwFvNaFuiMrVpXzEQp5bJYfLz2eV0oZWV1rWm1xGRFNMTu/jEAJwBfHzq7UoNNNpfBsHjMGDNRSt0O3C4iL1RKPbRIbeoCHnb932tvAzhatP0yoBkYUUplShxfgIjcAtwCsGrVqgVscuWYcIlJyO8lpyCVzTkWS13Qy+rmWrasbmTb4eECy2Q8YR3T4KQGm5iJwWCoDOX6OwZF5F4R2QEgIheKyF/M9iIRuUdEdpR43DivVp8mSqlblVJblVJbW1tbz0QT5sxEQouGz8nCSqRyBRYLwJu2dgNwbnsEgBXR/GJXTXbMZOOKCO+5ai1Xblgan32+ONlcRkwMhopTbjbXV4APAV8GUEo9LSLfAj4x04uUUtedRpv6gJWu/7vtbUyzfRBoEBGfbZ24j18SKKW4ffsxbtjcMcVqcEQj4HPcU/F0tsBiAauu1pbVTfRoy8S1vkmD7ebyez189BXnVfbDVBFmnonBsHiUa5nUKKUeLdqWKXnk/LkDuFlEgnb68QbgUeAxYIOduRXACtLfoZRSwP8Ab7Bf/zbg9gq1rSI8d2KCD3x3O/fuPjFlnxYNHYAHS0zcIgMgIqxvq3Ne5145UQfgzza8HsEjTFmi2GAwLDzlWianRGQddrFHEXkD0D+fE4vIa4F/AVqBn4nIdqXU9UqpnSLyPWAXlmD9gb1AFyLyfuCXgBf4ulJqp/12fw58R0Q+ATwJfG0+tq0v2QAAFztJREFUbVtsxhNWZd+ReGrKvsmimAlYlYPz20vHP1a41nSPhs9OMXnlBSvO2s9uMCw25YrJHwC3AhtFpA9rBvxb53NipdSPgR9Ps++TwCdLbL8TuLPE9gNY2V5LknjKKt6o4yNuJlyiEbJralluLiubqy5Y+ivUbq76kA/fMlnsaq5s7oqyuWv5VEE2GKqZctczOQBcJyK1WK6xGJab6XAF23bWELMzs8ZLikkWv1cI+rz5ALzbzTWNmIQDXhpq/DSYkbnBYFgEZpu0WG/PRv9XEXkploi8DWvuh6nNtUDoelvaCnEzadflgvz8kHgqy2Qqn+U1HR31ISf4bjAYDJVkNsvkP7BmlD+ENUnxY4AAr1VKba9w284aYvas9jE7duJm0i4/D0wJwHs9QnCG2ezvvnKtyWQyGAyLwmxislYpdQGAiHwVK+i+SimVqHjLziJ0iZRSbq5xl2USKnBzZakNeGfMVHr9lu4KtNZgMBimMltk1hkq2xlVvUZIFh7HzVVCTAosk0BeTCZcImMwGAxnmtl6o4tEZMx+LkDY/l8ApZSqr2jrzhKcAHyytJtLxz2K3VzTBd8NBoNhsZmtNtfZUcTpDBMr4ea6a+cADx8YYiKZobvRWtwqP88k5yzlazAYDNWA6Y2qgEQJN9eX7z/AtsPD+DzCltWNgDWjO+DzuCwTo/UGg6E6ODtns1UZxZbJ8GSKJ48MA5DJqQILRC+QZQXgzVjAYDBUB0ZMqgAtJqlsjmQmy317T5JTcJG93G5dkZjEUyYAbzAYqgsjJlWATg0Gyzq599kTtNQF+IfXXgDkF7cCnAWyTMzEYDBUE6Y3qgLirnXdR2Jp7t97kuvOa2dTZz3fveUFbOrMJ82F/F6OjyUYjafpagyXejuDwWBYdIyYVAGxVBavR8jmFM/0jTAaT3P5umYALlvbXHBs2O9h1zErW3t9a92U9zIYDIYzgXFzVQHxVIaWOsuVtbt/HICelpqSx4YDXsbtGl7r2oyYGAyG6sCISRUQS2Vpi1gl47XVsbJxGjGx55oEvB5WGjeXwWCoEoyYVAHxVJb2+iAAu/rHCPo8tEaCJY/VExd7WmrO2nVKDAZD9WF6oyogns7SalsmQ5MpuhvD0xZw1JbJOhMvMRgMVYQRkzNMKpMjk1O0uSyRlU2lXVyQL/ZoxMRgMFQTZ0RMROSNIrJTRHIistW1/aUisk1EnrH/XuPa978iskdEttuPNnt7UES+KyL7ROQREelZ/E80Pb3DMf7o2086JVOK0XNMIiGfsyzvdPESyLu51pvgu8FgqCLOlGWyA3gdcH/R9lPAq+01VN6GtTiXm7cqpS62Hyfsbe8ChpVS64HPA5+uYLvnzKMHh7jjqWMcHYqV3B9LW5lZNQEfkZC1xO7KpukD6yHj5jIYDFXIGRETpdRupdSeEtufVEods//diVXyvnQkOs+NwG328x8A18pMK0YtMulsDrBKpZRCWyY1AS8Re0b7TJZJR32I2oCXta21C9xSg8FgOH2qedLi64EnlFJJ17Z/F5Es8EPgE0opBXQBRwGUUhkRGQWasaycAkTkFuAWgFWrVlW4+RapjCUi6awquV/X5QoHvERC1tfRPYOYvHFrN9ed12ZKqRgMhqqiYpaJiNwjIjtKPG4s47XnY7mr3uPa/Fbb/XWl/fidubZJKXWrUmqrUmpra2vrXF9+WqRsEUlPZ5nYsZSw31uWm8vv9dBWH1rgVhoMBsP8qNjwVil13em8TkS6gR8Dv6uU2u96vz7777iIfAu4FPgm0AesBHpFxAdEgcF5Nn/B0CKSzpQWk5jLzVUX9BEJ+oiG/YvWPoPBYFgIqspXIiINwM+AjyilHnBt9wENSqlTIuIHXgXcY+++AytY/xDwBuBXtvurKtBurtliJuGAl5df0MGG9rpp55gYDAZDtXJGxEREXgv8C9AK/ExEtiulrgfeD6wH/kpE/so+/GXAJPBLW0i8WELyFXv/14D/EJF9wBBw8+J9ktlxLJNpYiZxVzbXjRd3LVq7DAaDYSE5I2KilPoxliurePsngE9M87It07xXAnjjwrVuYUk5YjKzm0vPbDcYDIaliJkBX2HSmVkC8C43l8FgMCxVjJjMg4lkhmd6R2c8JpW1l+QtIwBvMBgMSxUjJvPgc3ft5dX/+hs++L2nmLTXGCkmb5lMFzPJ4vcKflMB2GAwLGFMDzYP7tt7gtZIkB8+0cs3Hzpc8pj0LDGTeCrrlEgxGAyGpYoRk9NkYDTB/pOT3HLlWqJhPwOj8ZLHzR6AzxgXl8FgWPIYMTlNHthnVWu5Yn0L9WEfo/F0yeNmm2cSS2WpCVTVdB+DwWCYM0ZMTpMH9p2iuTbAxo4I0bB/WjHJz4CfJmaSypq0YIPBsOQxYnIaKKX4zb5TXL6+BY9HiIb9jCWmCcDPUptrPJlxCjwaDAbDUsWIyWlwaiLFifEkl6xqAJjRMslXDS4tJmPxNPWmFpfBYFjiGDE5DU6OW1XxO+zqvTOKySzrmYwnMtSHjJgYDIaljRGT0+DkhCUmrfa67fWhMmImM1gmxs1lMBiWOkZMTgNtmThiEvaTyuRKrvM+UwA+m1OMJzPGzWUwGJY8RkxOAy0mLXWWmOj1R8ZKWCczxUwm7Fnz9cYyMRgMSxwjJqfBqYkktQGvs3SuFpNSri6dzVUqZqLFx1gmBoNhqWPE5DQ4OZ50XFwws5jMNAN+LGGLiQnAGwyGJY4Rk9OgWEzqZ7RM7GyuElWDx+K2myts3FwGg2FpY8TkNDg5MQfLJDP9SovGMjEYDMsFIyanwcnxJK11U8WkVAA+PcM8E3181MRMDAbDEueMiImIvFFEdopITkS2urb3iEhcRLbbjy+59m0RkWdEZJ+I/LOIiL29SUTuFpHn7L+NlWx7MpNlNJ4udHPZ2Vij8cKSKkqpGcupjCd0NpcRE4PBsLQ5U5bJDuB1wP0l9u1XSl1sP97r2v5F4N3ABvtxg739I8C9SqkNwL32/xXj1EQKoEBMfF4PdcGplYPd1shMAfg6kxpsMBiWOGdETJRSu5VSe8o9XkRWAPVKqYeVUgr4JnCTvftG4Db7+W2u7RWheI6Jpj40VUzccZJSkxbH4hnqgj68HqlASw0Gg2HxqMYh8RoReRIYA/5CKfVroAvodR3Ta28DaFdK9dvPB4D26d5YRG4BbgFYtWrVaTWuePa7pr5Efa50prRl8qHvP4XPK6SzykxYNBgMy4KK9WQicg/QUWLXx5RSt0/zsn5glVJqUES2AD8RkfPLPadSSolI6YVDrP23wv9v796D7KzvOo6/P+ec3U2yuwmEbGLklgTSji1gSDMVh8vowMjF2gi2QI0Fp8xUFEerdpRK1bQzzkgdrVN0rLTlVinQSoNxGBRpS9FRaIEuIZRLAk0LMckGEnK/79c/nt85ebLZE9icy3Ny+Lxmzuyzv+c8e777O88+3/1dzu/hVoBFixbVfd6R1Esm2TL0WTIZHQ0279zLgdGDL5Hv8vruSxvpKZd4709P9QcWzawrtCyZRMRFR3HMHmBP2n5K0svAu4C1wEm5p56UygA2SJodEetSd9hIY5EfWTWZnNB/eDL5yaadADy0cj1/9I1hvvnb5wJQLqnWMtmycx8jta6yXg++m1lX6KipwZKGJJXT9jyygfZXUjfWVknnpFlc1wDV1s1y4Nq0fW2uvCU2bt/N8VN66K0cWnX5Zehf27yT3ftGWb81uy98f2+5Nn6yamRb7Zjn123zBxbNrCsUciWTdDlwCzAEPChpOCIuBi4APitpHzAKXB8Rm9JhvwPcAUwGHkoPgL8Cvi7pOuDHwJWtjP1j587lsjNmH1aeHzOpLuC4eUf2fX9fhe1pGvCqke21Y/YeGHXLxMy6QiHJJCKWAcvGKb8fuL/OMU8CZ4xT/gZwYbNjrGfe0ADzhgYOK582uYedew+w78BoLZm8uetgMtm0I5tSvGrDdib1lNh3IDgwGh4zMbOu0FHdXMey6qysbbv311ohb+7MEkjWzZWNmawa2cb8mYOcMn3KIceZmR3LnEyaZDB1V23bvY8de7NkUm2NTOmtMBrZzbBWbdjO/JkDnDbUD3j5eTPrDk4mTTKYa5lsq7VMqt1cZQDe2LGH9Vt3M3/WIKfNHDjkODOzY5mvZE1SbZls3bWPHdUB+Go3V7qJ1vPrsplc82cO1PZ5AN7MuoGTSZNUp/hu3b2/NgCf7+aCbMowwOzjJjF3qJ/eSmncwXwzs2ONk0mTTM2NmVQH4KtThft7UzfX9oOtkZOnT+GFz15CyetymVkX8JhJk+THTLbX6eaqtlSqiceJxMy6hZNJkwz0HZ5Mdu/LpgMfHIDPkomXnDezbuNk0iSVcokpvWVGtu1mdMwSktUxk0079tDfW/aS82bWdZxMmmjqpB7Wbdl9WHmtZbJ9b23Wl5lZN3EyaaLBSRX+781dh5X39x4cM/HnSsysGzmZNNHgpArrt2Ytk77cqsJTnEzMrMs5mTTR4KSe2qfeZ02dBGT3MpnUk1Xz/tFwN5eZdSUnkybKtzpmTc1untVTFj3l0rjPMTPrFk4mTZRvdcxMLZPecumQZOKFHc2sGzmZNFH+romzBlMyqZTorRycCuyWiZl1IyeTJsov2niwm2tMy8RjJmbWhZxMmqja6igJZgxkyaS3UvKYiZl1vUKSiaQPS3pO0qikRbnyJZKGc49RSQvSvkclvZjbNzOV90m6T9JqSU9ImlPE7wQHE0V/X6W2ZMrYlomTiZl1o6JaJiuBK4DH8oURcXdELIiIBcBHgR9FxHDuKUuq+yNiJJVdB2yOiNOBzwM3tyH+cQ32ZV1YA32V2lpdPeUSvbnPnFSfY2bWTQpJJhHxfES8+BZP+whw79v4cYuBO9P2vwAXSipk8avqTK2BvgpT0rLzvWXR65aJmXW5Th4zuQq4Z0zZ7amL689yCeNE4FWAiNgPbAFOGO8HSvq4pCclPblx48amB3xIN1dqmWRjJvnZXG6ZmFn3aVkykfSIpJXjPBa/jWN/DtgZEStzxUsi4kzg/PT46ERjiohbI2JRRCwaGhqa6OFvqZpMBvoqtXuY9JRLlEuimvrcMjGzbtSyK1tEXNTA4VczplUSEWvT122Svga8H7gLWAucDLwmqQJMA95o4LWPWrXVMTaZSNmn4PfuH/XUYDPrSh3XzSWpBFxJbrxEUkXSjLTdA3yAbBAfYDlwbdr+EPDtiBhzR5H2qHZt9fdVarfqrQ6+V8dNfGMsM+tGhVzZJF0O3AIMAQ9KGo6Ii9PuC4BXI+KV3CF9wH+kRFIGHgG+lPZ9BfiqpNXAJrJWTSHKJTFzsI+ZU/uolEv0VUq1JNJTFgN9Fd8Yy8y6UiHJJCKWAcvq7HsUOGdM2Q7gfXWevxv4cJNDPGpf/62fZ/pAL5C1VKqD7z3lEpN6nEjMrDu5z6XJ5szor21fcsZPcdZJ04AsmVTvuGhm1m2cTFroLy8/s7bdWyl5WrCZda2OG4DvVj1leVqwmXUtX93a5IZfPJ3jp/QWHYaZWUs4mbTJ4gUnFh2CmVnLuJvLzMwa5mRiZmYNczIxM7OGOZmYmVnDnEzMzKxhTiZmZtYwJxMzM2uYk4mZmTVMBd36o3CSNgI/PsrDZwCvNzGcZunUuKBzY3NcE9OpcUHnxtZtcZ0aEYfdqvYdm0waIenJiFhUdBxjdWpc0LmxOa6J6dS4oHNje6fE5W4uMzNrmJOJmZk1zMnk6NxadAB1dGpc0LmxOa6J6dS4oHNje0fE5TETMzNrmFsmZmbWMCcTMzNrmJPJBEm6RNKLklZLurHAOE6W9B1JP5T0nKTfT+VLJa2VNJwelxUQ2xpJz6bXfzKVTZf0n5JWpa/Htzmmd+fqZFjSVkmfKKq+JN0maUTSylzZuHWkzBfSObdC0sI2x/XXkl5Ir71M0nGpfI6kXbm6+2Kb46r73kn6VKqvFyVd3Oa47svFtEbScCpvZ33Vuz607hyLCD/e5gMoAy8D84Be4BngPQXFMhtYmLYHgZeA9wBLgU8WXE9rgBljyj4H3Ji2bwRuLvh9XA+cWlR9ARcAC4GVb1VHwGXAQ4CAc4An2hzXLwGVtH1zLq45+ecVUF/jvnfp7+AZoA+Ym/5my+2Ka8z+vwH+vID6qnd9aNk55pbJxLwfWB0Rr0TEXuBeYHERgUTEuoh4Om1vA54HOvnewIuBO9P2ncCvFhjLhcDLEXG0KyA0LCIeAzaNKa5XR4uBuyLzOHCcpNntiisiHo6I/enbx4GTWvHaE43rCBYD90bEnoj4EbCa7G+3rXFJEnAlcE8rXvtIjnB9aNk55mQyMScCr+a+f40OuIBLmgOcDTyRin43NVVva3d3UhLAw5KekvTxVDYrItal7fXArALiqrqaQ//Ai66vqnp11Enn3cfI/oOtmivpB5K+K+n8AuIZ773rlPo6H9gQEatyZW2vrzHXh5adY04mxzhJA8D9wCciYivwj8BpwAJgHVkzu93Oi4iFwKXADZIuyO+MrF1dyJx0Sb3AB4FvpKJOqK/DFFlH9Ui6CdgP3J2K1gGnRMTZwB8CX5M0tY0hdeR7l/MRDv2npe31Nc71oabZ55iTycSsBU7OfX9SKiuEpB6yE+XuiPgmQERsiIgDETEKfIkWNe+PJCLWpq8jwLIUw4Zqszl9HWl3XMmlwNMRsSHFWHh95dSro8LPO0m/CXwAWJIuQqRupDfS9lNkYxPvaldMR3jvOqG+KsAVwH3VsnbX13jXB1p4jjmZTMz3gfmS5qb/cK8GlhcRSOqP/QrwfET8ba483895ObBy7LEtjqtf0mB1m2zwdiVZPV2bnnYt8K/tjCvnkP8Wi66vMerV0XLgmjTj5hxgS66rouUkXQL8MfDBiNiZKx+SVE7b84D5wCttjKvee7ccuFpSn6S5Ka7vtSuu5CLghYh4rVrQzvqqd32gledYO2YWdNODbNbDS2T/VdxUYBznkTVRVwDD6XEZ8FXg2VS+HJjd5rjmkc2keQZ4rlpHwAnAt4BVwCPA9ALqrB94A5iWKyukvsgS2jpgH1n/9HX16ohshs0/pHPuWWBRm+NaTdafXj3Pvpie+2vpPR4GngZ+pc1x1X3vgJtSfb0IXNrOuFL5HcD1Y57bzvqqd31o2Tnm5VTMzKxh7uYyM7OGOZmYmVnDnEzMzKxhTiZmZtYwJxMzM2uYk4lZAyQd0KGrER9xJWlJ10u6pgmvu0bSjEZ/jlmzeGqwWQMkbY+IgQJedw3ZZwFeb/drm43HLROzFkgth88pu6/L9ySdnsqXSvpk2v69dL+JFZLuTWXTJT2Qyh6XdFYqP0HSw+neFF8m+5BZ9bV+I73GsKR/klROjzskrUwx/EEB1WDvIE4mZo2ZPKab66rcvi0RcSbw98DfjXPsjcDZEXEWcH0q+wzwg1T2p8BdqfwvgP+OiPeSrXd2CoCknwGuAs6NiAXAAWAJ2eKHJ0bEGSmG25v4O5sdplJ0AGbHuF3pIj6ee3JfPz/O/hXA3ZIeAB5IZeeRLbtBRHw7tUimkt2E6YpU/qCkzen5FwLvA76fLcfEZLLF+/4NmCfpFuBB4OGj/xXN3ppbJmatE3W2q36ZbD2khWTJ4Gj+uRNwZ0QsSI93R8TSiNgM/CzwKFmr58tH8bPN3jYnE7PWuSr39X/zOySVgJMj4jvAnwDTgAHgv8i6qZD0C8Drkd2H4jHg11P5pUD1RlDfAj4kaWbaN13SqWmmVyki7gc+TZawzFrG3VxmjZksaTj3/b9HRHV68PGSVgB7yJa+zysD/yxpGlnr4gsR8aakpcBt6bidHFwu/DPAPZKeA/4H+AlARPxQ0qfJ7mxZIlu99gZgF3B7KgP4VPN+ZbPDeWqwWQt46q6907iby8zMGuaWiZmZNcwtEzMza5iTiZmZNczJxMzMGuZkYmZmDXMyMTOzhv0/3t/71LZhhT0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "episodes_list = list(range(len(return_list)))\n",
    "plt.plot(episodes_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('DDPG on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "mv_return = rl_utils.moving_average(return_list, 9)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('DDPG on {}'.format(env_name))\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "第13章-DDPG算法.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}