Files
easy-rl/projects/parl_tutorials/DDPG.ipynb
2022-11-06 12:15:36 +08:00

466 lines
146 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. 定义算法"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\u001b[32m[09-28 00:38:01 MainThread @utils.py:73]\u001b[0m paddlepaddle version: 2.3.2.\n"
]
}
],
"source": [
"import parl\n",
"import paddle\n",
"import paddle.nn as nn\n",
"import paddle.nn.functional as F\n",
"class Actor(parl.Model):\n",
" def __init__(self, n_states, n_actions):\n",
" super(Actor, self).__init__()\n",
"\n",
" self.l1 = nn.Linear(n_states, 400)\n",
" self.l2 = nn.Linear(400, 300)\n",
" self.l3 = nn.Linear(300, n_actions)\n",
"\n",
" def forward(self, state):\n",
" x = F.relu(self.l1(state))\n",
" x = F.relu(self.l2(x))\n",
" return paddle.tanh(self.l3(x))\n",
"\n",
"class Critic(parl.Model):\n",
" def __init__(self, n_states, n_actions):\n",
" super(Critic, self).__init__()\n",
"\n",
" self.l1 = nn.Linear(n_states, 400)\n",
" self.l2 = nn.Linear(400 + n_actions, 300)\n",
" self.l3 = nn.Linear(300, 1)\n",
"\n",
" def forward(self, state, action):\n",
" x = F.relu(self.l1(state))\n",
" x = F.relu(self.l2(paddle.concat([x, action], 1)))\n",
" return self.l3(x)\n",
"class ActorCritic(parl.Model):\n",
" def __init__(self, n_states, n_actions):\n",
" super(ActorCritic, self).__init__()\n",
" self.actor_model = Actor(n_states, n_actions)\n",
" self.critic_model = Critic(n_states, n_actions)\n",
"\n",
" def policy(self, state):\n",
" return self.actor_model(state)\n",
"\n",
" def value(self, state, action):\n",
" return self.critic_model(state, action)\n",
"\n",
" def get_actor_params(self):\n",
" return self.actor_model.parameters()\n",
"\n",
" def get_critic_params(self):\n",
" return self.critic_model.parameters()"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"from collections import deque\n",
"import random\n",
"class ReplayBuffer:\n",
" def __init__(self, capacity: int) -> None:\n",
" self.capacity = capacity\n",
" self.buffer = deque(maxlen=self.capacity)\n",
" def push(self,transitions):\n",
" '''_summary_\n",
" Args:\n",
" trainsitions (tuple): _description_\n",
" '''\n",
" self.buffer.append(transitions)\n",
" def sample(self, batch_size: int, sequential: bool = False):\n",
" if batch_size > len(self.buffer):\n",
" batch_size = len(self.buffer)\n",
" if sequential: # sequential sampling\n",
" rand = random.randint(0, len(self.buffer) - batch_size)\n",
" batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
" return zip(*batch)\n",
" else:\n",
" batch = random.sample(self.buffer, batch_size)\n",
" return zip(*batch)\n",
" def clear(self):\n",
" self.buffer.clear()\n",
" def __len__(self):\n",
" return len(self.buffer)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"import parl\n",
"import paddle\n",
"import numpy as np\n",
"\n",
"\n",
"class DDPGAgent(parl.Agent):\n",
" def __init__(self, algorithm,memory,cfg):\n",
" super(DDPGAgent, self).__init__(algorithm)\n",
" self.n_actions = cfg['n_actions']\n",
" self.expl_noise = cfg['expl_noise']\n",
" self.batch_size = cfg['batch_size'] \n",
" self.memory = memory\n",
" self.alg.sync_target(decay=0)\n",
"\n",
" def sample_action(self, state):\n",
" action_numpy = self.predict_action(state)\n",
" action_noise = np.random.normal(0, self.expl_noise, size=self.n_actions)\n",
" action = (action_numpy + action_noise).clip(-1, 1)\n",
" return action\n",
"\n",
" def predict_action(self, state):\n",
" state = paddle.to_tensor(state.reshape(1, -1), dtype='float32')\n",
" action = self.alg.predict(state)\n",
" action_numpy = action.cpu().numpy()[0]\n",
" return action_numpy\n",
"\n",
" def update(self):\n",
" if len(self.memory) < self.batch_size: \n",
" return\n",
" state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.memory.sample(\n",
" self.batch_size)\n",
" done_batch = np.expand_dims(done_batch , -1)\n",
" reward_batch = np.expand_dims(reward_batch, -1)\n",
" state_batch = paddle.to_tensor(state_batch, dtype='float32')\n",
" action_batch = paddle.to_tensor(action_batch, dtype='float32')\n",
" reward_batch = paddle.to_tensor(reward_batch, dtype='float32')\n",
" next_state_batch = paddle.to_tensor(next_state_batch, dtype='float32')\n",
" done_batch = paddle.to_tensor(done_batch, dtype='float32')\n",
" critic_loss, actor_loss = self.alg.learn(state_batch, action_batch, reward_batch, next_state_batch,\n",
" done_batch)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"def train(cfg, env, agent):\n",
" ''' 训练\n",
" '''\n",
" print(f\"开始训练!\")\n",
" rewards = [] # 记录所有回合的奖励\n",
" for i_ep in range(cfg[\"train_eps\"]):\n",
" ep_reward = 0 \n",
" state = env.reset() \n",
" for i_step in range(cfg['max_steps']):\n",
" action = agent.sample_action(state) # 采样动作\n",
" next_state, reward, done, _ = env.step(action) \n",
" agent.memory.push((state, action, reward,next_state, done)) \n",
" state = next_state \n",
" agent.update() \n",
" ep_reward += reward \n",
" if done:\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:.2f}\")\n",
" print(\"完成训练!\")\n",
" env.close()\n",
" res_dic = {'episodes':range(len(rewards)),'rewards':rewards}\n",
" return res_dic\n",
"\n",
"def test(cfg, env, agent):\n",
" print(\"开始测试!\")\n",
" rewards = [] # 记录所有回合的奖励\n",
" for i_ep in range(cfg['test_eps']):\n",
" ep_reward = 0 \n",
" state = env.reset() \n",
" for i_step in range(cfg['max_steps']):\n",
" action = agent.predict_action(state) \n",
" next_state, reward, done, _ = env.step(action) \n",
" state = next_state \n",
" ep_reward += reward \n",
" if done:\n",
" break\n",
" rewards.append(ep_reward)\n",
" print(f\"回合:{i_ep+1}/{cfg['test_eps']},奖励:{ep_reward:.2f}\")\n",
" print(\"完成测试!\")\n",
" env.close()\n",
" return {'episodes':range(len(rewards)),'rewards':rewards}\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"import gym\n",
"import os\n",
"import paddle\n",
"import numpy as np\n",
"import random\n",
"from parl.algorithms import DDPG\n",
"class NormalizedActions(gym.ActionWrapper):\n",
" ''' 将action范围重定在[0.1]之间\n",
" '''\n",
" def action(self, action):\n",
" low_bound = self.action_space.low\n",
" upper_bound = self.action_space.high\n",
" action = low_bound + (action + 1.0) * 0.5 * (upper_bound - low_bound)\n",
" action = np.clip(action, low_bound, upper_bound)\n",
" return action\n",
"\n",
" def reverse_action(self, action):\n",
" low_bound = self.action_space.low\n",
" upper_bound = self.action_space.high\n",
" action = 2 * (action - low_bound) / (upper_bound - low_bound) - 1\n",
" action = np.clip(action, low_bound, upper_bound)\n",
" return action\n",
"def all_seed(env,seed = 1):\n",
" ''' 万能的seed函数\n",
" '''\n",
" env.seed(seed) # env config\n",
" np.random.seed(seed)\n",
" random.seed(seed)\n",
" paddle.seed(seed)\n",
"def env_agent_config(cfg):\n",
" env = NormalizedActions(gym.make(cfg['env_name'])) # 装饰action噪声\n",
" if cfg['seed'] !=0:\n",
" all_seed(env,seed=cfg['seed'])\n",
" n_states = env.observation_space.shape[0]\n",
" n_actions = env.action_space.shape[0]\n",
" print(f\"状态维度:{n_states},动作维度:{n_actions}\")\n",
" cfg.update({\"n_states\":n_states,\"n_actions\":n_actions}) # 更新n_states和n_actions到cfg参数中\n",
" memory = ReplayBuffer(cfg['memory_capacity'])\n",
" model = ActorCritic(n_states, n_actions)\n",
" algorithm = DDPG(model, gamma=cfg['gamma'], tau=cfg['tau'], actor_lr=cfg['actor_lr'], critic_lr=cfg['critic_lr'])\n",
" agent = DDPGAgent(algorithm,memory,cfg)\n",
" return env,agent"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"\n",
"import argparse\n",
"import matplotlib.pyplot as plt\n",
"import seaborn as sns\n",
"def get_args():\n",
" \"\"\" 超参数\n",
" \"\"\"\n",
" parser = argparse.ArgumentParser(description=\"hyperparameters\") \n",
" parser.add_argument('--algo_name',default='DDPG',type=str,help=\"name of algorithm\")\n",
" parser.add_argument('--env_name',default='Pendulum-v0',type=str,help=\"name of environment\")\n",
" parser.add_argument('--train_eps',default=200,type=int,help=\"episodes of training\")\n",
" parser.add_argument('--test_eps',default=20,type=int,help=\"episodes of testing\")\n",
" parser.add_argument('--max_steps',default=100000,type=int,help=\"steps per episode, much larger value can simulate infinite steps\")\n",
" parser.add_argument('--gamma',default=0.99,type=float,help=\"discounted factor\")\n",
" parser.add_argument('--critic_lr',default=1e-3,type=float,help=\"learning rate of critic\")\n",
" parser.add_argument('--actor_lr',default=1e-4,type=float,help=\"learning rate of actor\")\n",
" parser.add_argument('--memory_capacity',default=80000,type=int,help=\"memory capacity\")\n",
" parser.add_argument('--expl_noise',default=0.1,type=float)\n",
" parser.add_argument('--batch_size',default=128,type=int)\n",
" parser.add_argument('--target_update',default=2,type=int)\n",
" parser.add_argument('--tau',default=1e-2,type=float)\n",
" parser.add_argument('--critic_hidden_dim',default=256,type=int)\n",
" parser.add_argument('--actor_hidden_dim',default=256,type=int)\n",
" parser.add_argument('--device',default='cpu',type=str,help=\"cpu or cuda\") \n",
" parser.add_argument('--seed',default=1,type=int,help=\"random seed\")\n",
" args = parser.parse_args([]) \n",
" args = {**vars(args)} # 将args转换为字典 \n",
" # 打印参数\n",
" print(\"训练参数如下:\")\n",
" print(''.join(['=']*80))\n",
" tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
" print(tplt.format(\"参数名\",\"参数值\",\"参数类型\"))\n",
" for k,v in args.items():\n",
" print(tplt.format(k,v,str(type(v)))) \n",
" print(''.join(['=']*80)) \n",
" return args\n",
"def smooth(data, weight=0.9): \n",
" '''用于平滑曲线类似于Tensorboard中的smooth\n",
"\n",
" Args:\n",
" data (List):输入数据\n",
" weight (Float): 平滑权重处于0-1之间数值越高说明越平滑一般取0.9\n",
"\n",
" Returns:\n",
" smoothed (List): 平滑后的数据\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,cfg,path=None,tag='train'):\n",
" sns.set()\n",
" plt.figure() # 创建一个图形实例,方便同时多画几个图\n",
" plt.title(f\"{tag}ing curve on {cfg['device']} of {cfg['algo_name']} for {cfg['env_name']}\")\n",
" plt.xlabel('epsiodes')\n",
" plt.plot(rewards, label='rewards')\n",
" plt.plot(smooth(rewards), label='smoothed')\n",
" plt.legend()\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"训练参数如下:\n",
"================================================================================\n",
" 参数名 \t 参数值 \t 参数类型 \n",
" algo_name \t DDPG \t <class 'str'> \n",
" env_name \t Pendulum-v0 \t <class 'str'> \n",
" train_eps \t 200 \t <class 'int'> \n",
" test_eps \t 20 \t <class 'int'> \n",
" max_steps \t 100000 \t <class 'int'> \n",
" gamma \t 0.99 \t <class 'float'> \n",
" critic_lr \t 0.001 \t <class 'float'> \n",
" actor_lr \t 0.0001 \t <class 'float'> \n",
" memory_capacity \t 80000 \t <class 'int'> \n",
" expl_noise \t 0.1 \t <class 'float'> \n",
" batch_size \t 128 \t <class 'int'> \n",
" target_update \t 2 \t <class 'int'> \n",
" tau \t 0.01 \t <class 'float'> \n",
" critic_hidden_dim \t 256 \t <class 'int'> \n",
" actor_hidden_dim \t 256 \t <class 'int'> \n",
" device \t cpu \t <class 'str'> \n",
" seed \t 1 \t <class 'int'> \n",
"================================================================================\n",
"状态维度3动作维度1\n",
"开始训练!\n",
"回合10/200奖励-945.22\n",
"回合20/200奖励-700.56\n",
"回合30/200奖励-128.48\n",
"回合40/200奖励-266.74\n",
"回合50/200奖励-387.26\n",
"回合60/200奖励-133.07\n",
"回合70/200奖励-243.47\n",
"回合80/200奖励-383.76\n",
"回合90/200奖励-130.47\n",
"回合100/200奖励-385.78\n",
"回合110/200奖励-128.11\n",
"回合120/200奖励-245.72\n",
"回合130/200奖励-3.26\n",
"回合140/200奖励-231.93\n",
"回合150/200奖励-122.84\n",
"回合160/200奖励-370.19\n",
"回合170/200奖励-126.60\n",
"回合180/200奖励-118.99\n",
"回合190/200奖励-115.58\n",
"回合200/200奖励-246.70\n",
"完成训练!\n",
"开始测试!\n",
"回合1/20奖励-122.76\n",
"回合2/20奖励-1.78\n",
"回合3/20奖励-128.77\n",
"回合4/20奖励-124.03\n",
"回合5/20奖励-125.87\n",
"回合6/20奖励-130.87\n",
"回合7/20奖励-127.97\n",
"回合8/20奖励-134.63\n",
"回合9/20奖励-126.38\n",
"回合10/20奖励-1.42\n",
"回合11/20奖励-126.13\n",
"回合12/20奖励-1.88\n",
"回合13/20奖励-133.22\n",
"回合14/20奖励-132.14\n",
"回合15/20奖励-245.42\n",
"回合16/20奖励-123.41\n",
"回合17/20奖励-127.20\n",
"回合18/20奖励-130.53\n",
"回合19/20奖励-129.29\n",
"回合20/20奖励-288.72\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": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAHJCAYAAABws7ggAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAACdY0lEQVR4nOzdd3xT5f4H8M/JHm3adC/2KEIZLVsEBRW4qIi4rgLi9rpQ4CfjykUQcYE4AEUEFUG8KKL3KrgXV2SDIrJ3927TNjvn/P5Iz2nSmaQZJ+33/XrxKk1OkudJTtJvnuf7fR6G4zgOhBBCCCFhShLqBhBCCCGEtAYFM4QQQggJaxTMEEIIISSsUTBDCCGEkLBGwQwhhBBCwhoFM4QQQggJaxTMEEIIISSsUTBDCCGEkLBGwQxpVKDWUqQ1GgkhhPgbBTOkgR9++AFz5871+/0ePHgQDz74oPB7Tk4O0tPTsW3bNr8/Fmkb9uzZg3HjxiEjIwP3339/o8dMmzYN6enpwr9evXohMzMTkydPxgcffAC73e7X49PT05GRkYGrrroKixcvRmVlZYM2FRQUYPny5bj++uuRmZmJzMxM3HTTTVi7di1MJlOL/d6+fTtGjx6NjIwMLFy40ItnzDP1+5Oeno5+/frhuuuuwzvvvAOWZf3+mM21ZeXKlQG/TShs2LAB1157Lfr164ebbroJv/zyS6ib1GbJQt0AIj7vv/9+QO73k08+wdmzZ4XfExISsGXLFnTs2DEgj0fC38svvwyWZbF27VrExsY2eVzv3r3xzDPPAAAcDgcqKyuxc+dOvPDCCzhw4ABee+01SCQSvxwPADabDX/99RdWrFiB48eP46OPPgLDMACAvXv3YsaMGYiKisKdd96J9PR0sCyLvXv34q233sK3336LDz/8EEqlssn+PPvss+jcuTNefPFFJCYm+vbkteCWW27BrbfeKvxuMpnw7bffYvny5TAYDJg9e3ZAHre9eO+997Bs2TI8+uijyMjIwKeffoqHH34YH3zwAQYNGhTq5rU5FMyQkFEoFBgwYECom0FErKKiAoMHD8bll1/e7HERERENzqUxY8aga9euWLp0Kb788ktMnDjRr8cPHjwYNTU1eOONN/DHH39gwIABKCsrw8yZM9G5c2e899570Gg0wvEjRozA1VdfjTvuuAMbNmxwG6VsrN8jRozA0KFDm+13ayQlJTXo0/Dhw3Hu3Dl8+OGHmDFjBuRyecAevy0zm8148803cc899+DRRx8FAIwaNQp///vfsXr1arz33nshbmHbQ9NMxM20adOwb98+7Nu3D+np6di7dy8A54frwoULcfnll6Nv37647bbbsHv3brfb7tq1C7fddhsyMzMxePBgPPzww8JIzLx58/DZZ58hNzdXmFqqP820bds29O7dG3/88Qduv/129O3bF6NHj8b69evdHqeoqAgzZ87EkCFDMHjwYCxcuBCvvvoqxowZ02zfioqKMHfuXAwfPhyZmZmYOnUqDh8+DKDpKa958+a53e+0adPwf//3f5gxYwYGDBiAe+65B+PGjcOMGTMaPN6NN96Ihx9+WPj9+++/x+TJk9G3b1+MGDECzz33HIxGY7Ntdjgc+PDDD3HDDTegX79+uOqqq7B8+XJYLBa3Nt5999349NNPhSmZG2+8ETt37mz2vgHg888/x0033YT+/fvjqquuwiuvvAKr1QoAWLlyJcaMGYOffvoJ48ePR//+/XHbbbcJ5wTgfM3S09ORk5Pjdr9jxozBvHnzmn3sCxcuYMaMGRgxYgQGDBiAadOm4eDBgwDqXo/c3Fx8/vnnbueiN6ZOnYrExET8+9//DsjxGRkZAIC8vDwAwObNm1FaWornnnvOLZDh9e/fH9OnT2/0OsA5qpOeng4AWL16tdtzu2vXLtx5550YOHAghg4ditmzZyM/P1+4Lf/++eSTTzBixAgMGTIEZ86c8agf9ftUU1MjTJ/xI2PXXnstMjIyMG7cOGzcuNHtNtOmTcPTTz+NtWvX4qqrrkLfvn3x97//HUeOHHE7bt++fbj99tvRv39/jBs3Dr/99luj/a//Wk+bNg3Tpk1rtL2enoPp6en46KOPMG/ePAwcOBBDhgzBc889B7PZjJdeegnDhg3D0KFD8fTTT7u9v+o7dOgQ0tPT8dNPP7ldfvz4caSnp+O7777DH3/8AYPBgGuvvVa4nmEYXHvttdi7dy/MZnOT9098Q8EMcfPMM8+gd+/e6N27N7Zs2YI+ffrAYrFg+vTp+OGHHzBz5kysWrUKSUlJuP/++4WAJjs7G4888ggyMjLw1ltvYenSpTh//jwefPBBsCyLRx55BFdeeSXi4+OxZcsWXHXVVY0+PsuyePLJJzFhwgSsXbsWWVlZePnll/G///0PAGC1WjF9+nQcOnQI//znP/HCCy/gxIkTePfdd5vtV01NDe644w7s3bsXTz31FFatWgWlUol7770XFy5c8Oo5+uqrr6DVavHWW2/h/vvvx8SJE/HLL7+gurpaOObs2bM4ceIEbrzxRgDAF198gUcffRRdu3bF6tWr8dhjj+G///0vHnnkkWaTohcuXIgXXngB11xzDd566y1MmTIFmzZtanC7o0ePYv369ZgxYwZWr14NqVSKxx9/vNF8Dt6HH36IuXPnok+fPli1ahUefPBBbNy4Ec8995xwTFlZGebOnYs777wTr7/+OlQqFe677z4cP37cq+esvjNnzmDy5MnIycnBggULsHz5cjAMg+nTp2Pfvn3CFGR8fDyuvPJK4Vz0lkQiwfDhw3HkyJEGuTD+OP78+fMAgA4dOgBw5pulp6ejR48eTd5m7ty5mDp1aqPX9enTB1u2bAHgnAbasmULEhIS8Pnnn+Pee+9FcnIyVqxYgfnz5+Pw4cO4/fbbUVpaKtze4XDg3XffxdKlSzF//nx069atxT401ietVitM6y1atAhvvPEGJk6ciDVr1mD8+PF4/vnnsXr1arfbffPNN/jhhx+wYMECrFixAiUlJXj88cfhcDgAAH/99RfuvfdeREZG4o033sBdd92FWbNmed2+1li2bBkUCgVWrVqFSZMmYePGjZg0aRLy8/OxfPlyTJs2DVu3bm0QrLnKyspCx44dsX37drfLv/zyS0RHR+PKK68UvsR17tzZ7ZhOnTrB4XDg0qVLfu9be0fTTMRN9+7dERERAQDCEPTHH3+MEydO4OOPP0b//v0BOIdMp02bhuXLl+PTTz/FkSNHYDab8dBDDwlz/ElJSfjhhx9gNBrRsWNHxMTEuE0tNTYqwXEcHnnkEWEuf+DAgfjuu+/w888/Y+TIkfjvf/+Lc+fO4dNPPxW+FQ8bNgzXXHNNs/3iR4U+++wzXHbZZQCcH0qTJk3C/v37MXz4cI+fI7lcjsWLF0OhUAAAOnbsiJUrV+L777/HpEmTADg/2HQ6HcaMGQOO47B8+XKMHDkSy5cvF+6nc+fOuPvuu/HLL780GtydOXMGW7duxezZs4UpiREjRiAhIQFz5szBzp07ceWVVwIAqqqqsG3bNiH/SKPRYOrUqUICbX0sy2L16tW45ppr3IIXk8mE7du3w2azCb8vWrRI6Bf/XK9duxavvvqqx89ZfatWrYJCocAHH3wgnG9XXXUVrr/+erz88svYunUrBgwYAIVCgZiYmFZNR8bFxcFms6GiogJxcXE+Hc9xnFtwU1lZiX379uGtt95CZmamcC5eunQJI0aMaHCfjQVGMlnDj1/X6Sx+GohlWSxfvhxXXHEFXnnlFeHYrKwsTJgwAevXr8ecOXOEy//xj380+WXBFcuyQrs4jkNJSQm++OIL/Pjjj7j//vvBMAzOnz+Pjz/+GLNmzRLOwSuuuAIMw+Dtt9/GnXfeCb1eL/Rx/fr1wutZU1ODuXPn4vjx48jIyMDbb7+N2NhYvPXWW8L0lV6vx8yZM1tsq790794dzz77LABgyJAh+OSTT2Cz2bB8+XLIZDJcccUV+Oabb3Do0KFm72fixIl49913YTaboVKpwHEcduzYgfHjx0OhUAhfbPjngqfVagHA7YsP8Q8amSEt2r17N+Lj49GnTx/Y7XbY7XY4HA6MHj0aR48eRWVlJfr37w+lUolbbrkFS5cuxf/+9z/06tULM2fObPCGbklmZqbwf/6PGR/47NmzBx06dBD+eADOD4zRo0c3e58HDx5EWlqaEMgAgFqtxjfffOOWBOmJrl27CoEM4PxWnpWVhR07dgiXbd++XfhgO3fuHAoKCjBmzBjh+bPb7Rg8eDAiIiKwa9euRh9n3759AIDrrrvO7fLrrrsOUqnUbSg+JibGLZE6KSkJAJqsnDl//jxKS0vdhsEB4L777sO2bduEPzYymQzXX3+9cL1KpcKoUaOwf//+pp8gD+zbtw+jR492OzdkMhmuu+46HD16FDU1Na26f1f8CBafoOvL8fv370efPn2Ef5dffjlmzZqFjIwMvPLKK8KxjVUB2e12t9vy/zx1/vx5FBcXu70OgDOIzszMFM4Tnus53pw333xTaAtfnbV69WrcfvvtePzxxwE4328cxzU4d8eMGQOLxSJMCwLuX4QACF9q+HPw4MGDGDlypFseztixYyGVSj1+LlrL9bNFKpVCr9ejT58+boFldHQ0qqqqANQFfK6fe4AzmDEajcJU06FDh5CXlyeMxLZUDeaaXE78g0ZmSIsqKipQXFzc5AdwcXExunfvjk2bNmHt2rXYunUrPvjgA+h0Otx555148sknPf5DAjj/YLqSSCTCH5jy8vJGq1qaq3Th+9DSMZ7iv125uvHGG7FkyRKUl5cjJycHFy9exPPPPy88NgAsXrwYixcvbnDboqKiRh+HnyKKj493u1wmk0Gv1wsfuIAzMHPV3B9X1za19JzExcU1GEGIjY0Vbu+rysrKRkdJ4uLiwHEcqqurG32efVFYWAiVSoXo6Gifj+/Tp4/w2jEMA6VSieTk5AaBempqKnJzc90uk8lk2Lp1q/D7xx9/jI8//tjj9vPPdVPP17Fjx9wuayofp77bbrsNt912GwBnn7RaLdLS0tyCDf6x6wfUvMLCQuH/9c9B/g82fw5WVlYKozg8/lwOlsa+WDX3fP3zn//EZ599JvyempqKH3/8EZ06dUJmZia2b9+Ov/3tb9i+fTs6duyIrKwsAEBkZCQA5+hUVFSUcHt+RIa/nvgPBTOkRZGRkejcubPbFImrtLQ0AEC/fv2watUqWK1WHDx4EFu2bMGaNWvQq1cv/O1vf/NLWxITExvNcXHNG2hMZGRkgwRBwPmNKioqSgig+G9evJYSdHl/+9vf8Nxzz+H777/HuXPnkJqaioEDBwIAdDodAGDOnDkYMmRIg9u6ftg1dnlxcTFSU1OFy202G8rLy1v1R4BvU1lZmdvl5eXlOHbsmPANtrGgpaSkRAiCmgqaWhpZiYqKQklJSYPLi4uLAcBvf+Dsdjv27t2LrKwsj0YAmjpeq9Wib9++Ld5+zJgxWLt2LbKzs4U8GgBut/3555+96gMfVDX1fPn6XCUkJLTYJ/482bBhQ6PBZUpKisePFx0d3aAPHMe55XU1dz41Fdz6eg564rHHHsOUKVOE311HZCdOnIgXXngBVVVV+Prrr3HHHXcI13Xp0gUAcPHiRfTr10+4/OLFi5DL5W7nBvEPGusiDdQfAh0yZAjy8/MRGxuLvn37Cv927dqFdevWQSqV4v3338fo0aNhtVqhUCgwfPhwLFmyBEBdpYc/hlaHDBmCnJwctwRUs9ksJAg3ZdCgQcjOzsbp06eFyywWCx5//HFs3bpV+Mbm+k3TZrM1qMZoik6nw+jRo/HDDz/gm2++wcSJE4UP2a5duyI2NhY5OTluz19iYiJeeeWVBt+sXfsKoEGi4fbt2+FwOIRgyRddu3aFXq9vUJHxn//8Bw8++KCQM1P/uTWbzdi5c6eQY8Q/bwUFBcIxZ8+ebXHkZvDgwfjpp5/ccgccDge2b9+Ovn37uv3RaI0tW7aguLjY7Q+NP4+vb8qUKYiOjsa8efMazYtwOBw4d+6cV/fZpUsXxMfH48svv3S7PDs7G7///rswGhAI/Hoo5eXlbuduWVkZXn/9da9G6IYPH46dO3e6TX3+73//E841oPHzqbKy0m19qvp8PQc9kZaW5tZvvtIMACZMmACO4/D666+jtLTUrZQ/MzMTGo0G33zzjXAZx3H47rvvMGTIEL+d36QOjcyQBnQ6HQ4fPozdu3ejd+/emDx5MjZt2oR77rkH//jHP5CcnIzffvsN77zzDqZOnQq5XI5hw4Zh+fLlePTRRzF16lRIpVL8+9//hkKhEPJZdDodSkpK8Msvv3g8r1/f9ddfj7Vr1+LRRx/FE088AZ1Oh/feew+lpaXNfkucPHkyNm7ciIcffhgzZsyAXq/HBx98AJvNhjvvvBNRUVHIzMzExo0b0alTJ0RFReGDDz6A2Wz2eNh+4sSJmDFjBhwOhzB3Djjn5mfOnImFCxdCKpVi9OjRMBgMePPNN1FYWNjk9F337t1x00034Y033oDJZMLgwYNx/PhxrFq1CkOHDsXIkSO9e/Jc8NVOzz77LGJjYzFmzBicP38eb7zxBqZMmeI2WjR//nw8+eSTiI2Nxfr162E0GoWS86FDh0KlUuHFF1/EE088Iay70tKUzmOPPYadO3firrvuwoMPPgi5XI5NmzYhOzsb69at87o/1dXV+P333wE4v6GXl5fj119/xZYtWzBx4kSMHTu2Vcd7KjExEatWrcITTzyBiRMn4vbbb0efPn0gkUhw9OhRfPrpp7hw4YLbH76WSCQSzJo1C/Pnz8fs2bMxceJElJeXY9WqVYiKisI999zjU1s9kZ6ejokTJ+Jf//oXcnNzkZGRgfPnz+PVV19FWlpag2qd5jz66KP4/vvvcd999+H+++9HWVkZXnvtNbdprfT0dCQnJ2P16tWIiIgQEo3rT2G58vUcbC2+cmnz5s3IzMxEp06dhOvUajXuvfderF69GnK5HJmZmfj000/x119/4YMPPghou9orCmZIA1OmTMHRo0fxwAMP4IUXXsANN9yADz/8EK+88gqWLVuGqqoqpKamYvbs2bj33nsBAL169cKaNWuwevVqzJo1Cw6HAxkZGXj33XfRtWtXAM6A4pdffsGjjz6KGTNmYMKECV63TSaTYf369Vi6dCkWLVoEmUyGiRMnIjo6WiiTbUxERAQ2bdqEl19+GUuWLAHLshgwYAA++OADYcj3xRdfxJIlS7BgwQJERETglltuwcCBA/HJJ5941LYrr7wSkZGR6NChgzDMzLv11luh1Wqxbt06bNmyBRqNBllZWVi+fHmzQ85Lly5Fp06d8Omnn+Kdd95BQkIC7rrrLjzyyCOtHumaMmUKNBoN1q9fjy1btiApKQkPPPAAHnjgAbfjFi1ahOeffx5lZWXIysrCRx99JHxw63Q6rFy5Eq+88goeffRRpKam4rHHHsPnn3/e7GP36NEDmzdvFsqMGYZBv379fF4d9dixY7j99tsB1OV/9OzZE4sWLWo0wdvb470xaNAgfPHFF/joo4/w9ddf45133oHVakVycjKGDRuGV199Fb179/bqPidPngytVou3334bjz76KCIiIjBy5EjMmjWrQU6Vv73wwgt4++238e9//xsFBQWIjY3FhAkT8OSTT3qVvNu5c2ds2rQJL774ImbOnInY2FjMnTsXL774onCMVCrFG2+8geeffx6zZs1CXFwcpk+fjnPnzjX5/vb1HPSHG2+8Ed9//z1uuOGGBtc9+uijkEql+Pjjj/Huu++ie/fuePPNN1s1okqaxnC08x8JI6dPn8a5c+cwduxYt6TiW265BUlJSVi1alUIW9e2rFy5EqtWrcLJkydD3RRCCGkWjcyQsGI0GvHEE0/gzjvvxLXXXguHw4EdO3bg6NGj+L//+79QN48QQkgIUDBDwkr//v3x2muvYf369fj888/BcRx69+6NdevWYdiwYaFuHiGEkBCgaSZCCCGEhDUqzSaEEEJIWKNghhBCCCFhjYIZQgghhIQ1CmYIIYQQEtbaTTUTx3FgWf/nOkskTEDuV4zaU1+B9tVf6mvb1Z76S31teyQSxqONittNMMOyHMrKWr/xmCuZTAK9XguDwQi7vfkt38Nde+or0L76S31tu9pTf6mvbVNMjBZSacvBDE0zEUIIISSsUTBDCCGEkLBGwQwhhBBCwhoFM4QQQggJa+0mAZgQQkh4YlkWDoe9hWMYmM1SWK0WOBxtu8qnrfRVKpVBIvHPmAoFM4QQQkSJ4zgYDGUwmao9Or6kRAKWbdvVPby20le1OgI6XYxH5dfNoWCGEEKIKPGBTESEHgqFssU/eFIpE9YjFd4I975yHAer1YLq6nIAQFRUbKvuj4IZQgghosOyDiGQiYjQeXQbmUzS5tdd4bWFvioUSgBAdXU5IiP1rZpyEmUCMMuyeOONNzBy5EgMGDAADzzwALKzs0PdLEIIIUHicDgA1P3BI20T//q2lBPVElEGM2+++SY2b96MJUuW4N///jdYlsX9998Pq9Ua6qYRQggJotbmUhBx89frK7pgxmq14t1338WMGTNw1VVXoVevXnj11VdRUFCAb7/9NtTNI4QQQojIiC6YOXHiBGpqajB8+HDhMp1Oh969e2P//v0hbBkhhBBCxEh0CcAFBQUAgOTkZLfLExIShOt8JZP5N3aTSiVuP9uy9tRXoH31l/radoVzf1nWu+kHfraCYQAufIt8PBLIvj722INITk7B008v8u8dt0AqZVr1N1p0wYzJZAIAKBQKt8uVSiUqKyt9vl+JhIFer21V25qi06kDcr9VRitUChnkfg7CWiNQfRWr9tRfMfTVZndg209nMOiyRHRLiw7Y4wSyrw6Wg1QirjwPMby23jKbpSgpkXj9Ry4cAzdfBaKvDMOAYVoXWHiDZRlIJBJERWmgUql8vh/RBTN8Z6xWq1vHLBYL1Grf35Asy8FgMLa6fa6kUgl0OjUMBhMcDv+WyFVUW/B/q3ehW0oU5k8b6Nf79kUg+ypG7am/Yurr7qMF2PT1CRw4VoB/3jXI7/cf6L6u+fwo/rpQhucfHIZIjaLlGwSYmF5bb1mtltqVfzmPSpAZxtlfh4NtFyMzgeorx3HgOM+ec39wODiwLIvKSiNMJkeD63U6tUdBm+iCGX56qaioCB07dhQuLyoqQnp6eqvuO1AvjsPB+v2+T14sh9XG4uSlCpgtdshE8m0jEH0Vs/bUXzH09VJhFQAgu6gaNpsjYJUsgegry3LYf6IINjuLkxcrMKBHnF/vvzXE8Np6q6kF4TiOg9XWeF9kssD/EVbIJV6fl1dcMQj33PMAduz4Ana7DatWvYOkpGS8885b+Pbbr1BTU40uXbrh/vv/gSFDhuHs2TOYPv3vWL9+E9LTewEA5s//Pxw6tB87dvwIqVQKlmVx3XXX4PHHZ2HcuAn44ovPsXXrv5GdnQ2JhEHPnr0wY8Ys9OrVGwBwyy034KqrrsaePbtQXl6G5557GX369MWaNSvx7bdfw2az4sYbbwZXLzravHkjPv98K4qLixAXF4/rrpuI6dPv8/t709OgtSmiC2Z69eqFiIgI7N27VwhmDAYDjh07hqlTp4a4dcGTW1IDAGA5DoXlJqTGBWaKjBAxyas972vMdhiMNkRpQz+64amSShNstR/GBWX+HQUmThzH4YVNh3Am1/eUg9bqnhaF+VOyvP5j/tlnn2D58jdgtzvQoUNHLFr0NC5ePI+FC5cgPj4Bu3btxJw5T+L555fj8suvQHJyCvbv34P09F5wOBw4fPgAjEYjTp06gcsu64Njx46iqqoKw4dfgV9++Qmvvvoy5s5dgP79M1FSUoLXXluGF198Du+/v1low7ZtH+Oll15FZGQkunbtjtdeW4Zdu/6Hp59+BomJyfjgg3fxxx+HkZKSCgD49ded2LjxPTz77PPo0KEz/vrrCJ577hkkJ6dg3LgJfn1eW0t0wYxCocDUqVOxfPlyxMTEIDU1FcuWLUNSUhLGjh0b6uYFDf+hDgD5JTUUzJB2wfW8zyupCatgJq+kLoDJL61p5kjSKuJKR/LYuHEThFGSnJxsfP/9N3jvvQ/Ro4dzxuHvf5+KM2dOY/PmD3D55VdgxIiR2L9/L6ZOvRvHj/8FmUyOjIy+OHToAC67rA927foV/ftnQqfTISoqCvPm/Qtjx/4NAJCUlIzrr5+IFStedmvDsGEjMHjwUACA0ViDr776ErNnz8Xw4VcAAObPX4hDhw4Ix+fl5UChkCMpKQVJSUlISkpCXFwCEhOTAv58eUt0wQwAzJgxA3a7HQsWLIDZbMbgwYOxfv16yOXyUDctaHJdgxn6lkfaAZudRVGFSfg9v7QGl3XSh7BF3slzCWBoZCYwGIbB/ClZzUwzBX6Jf1+mmQAgLa0ubeLUqZMAgEceud/tGLvdjoiISADAiBEj8d//fgaLxYz9+/di4MBBSEpKwcGDBzBlynTs2vUrxo+/DgAwYEAWLlw4j/ffX4eLFy8gJ+cSzp4902AjyrS0DsL/L126CJvNhl69+giXKZVK9OxZl84xduwEbN/+X9xxx2R07twVgwcPxVVXXY2kJApmPCKVSvHUU0/hqaeeCnVTQsLBsigopW95pH0pLDO6JTO6jtKEA7fR1FIKZgKFYRgoFdJGr5PJJKKrJOMplXXbMnCcM8hYvfodaDTuo+78/kSZmYMgl8tx+PAhHDiwD+PGTUBycjK2bfsYBQX5OH36JJYudY68fPvt11i69BmMHfs3ZGT0w403Tsa5c2exYsVLTbaBH+Li28KTyerCgujoaLz33mYcPXoE+/fvxd69u/HJJx/hvvsewj33PNC6J8TPxJFVStwUlZvgYOs+1fNL6IORtH159YL2cAtmXL90VJtsqDbZQtgaImZdunQDAJSWliAtrYPwb/v2/2LHji8AOIOKIUOG49dff8GxY0cxcOBg9Os3AA6HA+vXv41u3bojOTkFAPDhh+/jhhsm4emnF+Hmm2/DgAFZyM3NAYAGCb28jh07QaFQ4siRP4TL7HY7Tp8+Jfz+7bdf4bPPtqJfvwG4776HsHat83F++EF8q/FTMCNCucXOD8UItXNaLb+sBmxbrzUk7R4fvKTFRwAIr9ENjuOEnBl+ZKAgjNpPgqtr1264/PKRWLbsBfz6607k5ubgww83YNOm95GamiYcd8UVo7BjxxeIi4tHamoalEoVMjL64ZtvdmDUqKuE4xISEvHnn3/g5MkTyM3NwZYtH2Lbto8BoMk9DTUaDW655Ta8++7b+OWXH3Hx4gUsX/4CSkqKhWOsVgtWr34dX3+9Hfn5efjjj99x+PAhZGT0C8wT0wqinGZq7/gP9b5dY7DveBGsNhZlBjPiosJv4StCPMUHLwPT45FTXI3KGiuqTTYhqBezMoMFFpsDUgmDHmlROHGpAvllNeieFhXqphGRevbZF7B27WosW/Y8qqoMSElJw7x5/8Lf/na9cMzw4SPgcDiQlVW35tKgQUNw6NABjBp1pXDZzJlz8PLLS/HYYw9CoZCje/eeWLBgMZ555p84ceIY+vfPbLQNDz30GBQKJVaseAlGoxFjxlyLESNGCddff/0kVFZW4v3316GoqBCRkZG46qqr8fDDMwLwjLQOwzU1BtXGOBwsysr8O2wtk0mg12tRXl7j16Sztz4/iv0ninDb6O749c985JXUYOZt/dG3a6zfHsNbgeqrWLWn/oqlr/9avxe5xTV48tb++OCbEygzWDB/ahZ6+HEl4ED19c9zpXj14z+QEqfFZZ30+OFgDv42tCNuHd3db4/hC7G8tr6w2awoLc1HbGwy5HLPqtqCkQAsFm2lry29zjExWo8WzaNpJhHiR2ZS4rRIjtUAcJZnE9JWuSa9p8RqkBLrTIoMl6km4T0bq0FSTO17NkzaTkhbQMGMyNgdrFDWmRqnRXLth3oefTCSNqy4wgwHy0EhlyAmSlV33odJEM8n/7p+AaHybEKCh4IZkSmsrWRSKaSI0SnrRmaoPJu0YXzQkhyjhYRhkBKncbtc7Pjk35Q4rTAyU1xhgj3M9kMiJFxRMCMyrlNMDMOE3XA7Ib6oG9nQ1P7Uul0uZs5KptpgLFYLfaQSSrkUDpZDscsigISQwKFgRmRyi6sB1H2Y89/yqk02VBkbL7EjJNy5BgOuP0sNFpgs9pC1yxOVNVYYLXYwDJAUowbDMML7lsqzCQkOCmZEhv9Q5/diUiqkiNWpANDoDGm7+JwwPoiPUMuhq92XSey5J/x7NiFaDbnMuTIt5c0QElwUzIhMbr1gBgCS+fyBMBhyJ8RbLMe5JdDyUmLDI28mv14gBgBJsVTRREgwUTAjInYHi6Jy5xy7+4d6bf4AbWtA2qCySjOsNhYyKYP4aJVweXIcX8kn7mDGNc+NJ0wz0cgMIUFBwYyIFJQZ4WA5qJVS6CPrNgSjiibSlvFTTIkxGkgldR9J4RLE1+X7aITLkmPrEpjbybqkhIQUBTMiUr+Sief6wUhIW1M/+ZcnTDOJ/LzPa2SKLFGvBgOgxmxHFW04SUjAUTAjIvwGkyn1P9Tj6io7zFZxV3YQ4i0hX8ZlZAOoO++LK0yw2hxBb5cnDEYrqozOYCU5pu59q5BLERvlnDKjiiYiNna7HVu2fCj8vn7927jllhv8/jiBut/GUDAjIvUrmXgRajkiNc7N9mgOnrQ1jY1sAIBOq4BWJQPHife857cZiYtSQamQul1HeTNErL777musXPlqqJvhVxTMiAhfyZQSr21wXXKY5A8Q4g2O44Rzuv6IJMMwLlOs4jzvG6tk4vEVTTQyQ8SmLeZxyULdAOJks9dVMqXGRTS4PjlWg1PZFaLPHyDEG64LziXGaBpcnxKnwZncStGWZzeW/MtLjqHE/UDgOA6wN76AKMdJwAV6J2mZwi2n0RO7d+/CunVrcOHCOajVGgwfPgKPPz4LZ86cwsyZj+LZZ1/EmjUrUVhYiIyMvnj66UX46KON+Prr7ZDJ5Lj11r9j+vT7hPv76qsvsWXLh7h06RJiYmJw/fU3Ytq0eyCVOkcHCwsL8Pbbq3HgwD4YjTXo128AHnnkCXTv3gM7dnyB559fDAC44opBeOONNcL9btr0Pj799GNUVlaiT58MzJnzNDp06AgAqK6uxurVr+N///sJNpsN6emX4ZFHZqBXr97C7f/zn23YvPkDFBcXY/DgIUhOTvH5afYWBTMiUVhmBMtxUCtliI5ouA262L+hEuIL9wXnGg4Up8SKuzxbmCKLbWxkxnkZTTP5D8dxMP53KdjCMyFrgzSxB9QT/+lxQFNRUYGnn34Kjz02E5dffgWKigqxZMkzePPN1zF27N/gcDjwwQfv4plnnoPdbsdTTz2Ju+++E9dffyPWrt2Ab7/9Cu+88xauuOJKdOvWHR9/vBlr1qzCjBmzMHDgEBw7dhQrVryEyspKPPHEbBiNNXj44fuQkpKKF198BXK5Au++uxaPPfYA3n//I1x99bWorq7GG2+8gv/852vodFE4fPggCgry8eeff2DZstdhs1mxZMlCvPjiEqxe/Q44jsNTT82AQqHCSy+9hoiICHz99XY8/PB9ePvt99CzZy98993XWLHiJTzxxP9h0KAh2LnzJ6xd+yYSEhID/Io40TSTSLgultfYmySFyrNJG9TcNA1Qt9aMWIP4xtaY4fGjNcUVZtpw0o8YeDcqEmrFxYWwWq1ITExCUlIy+vUbgJdeWoGbb75dOOb++/+BXr16IyOjHwYOHAy1Wo1HHpmBjh07Ydq0uwEA586dAcdx2LRpAyZPvg233HIbOnToiHHjJuC++/6Bzz77BNXV1fjmm69QWVmBJUteQu/eGejRoycWLXoOSqUK27Z9DKVShYgI5+h/bGwc5HJnPqZMJsPChUvQvXsPXHZZH9x442ScOHEMAHDw4H4cPfonlix5AX36ZKBTp8546KFH0adPX3zyyb8BAFu3bsE114zF5Mm3omPHTpg69W6MGDEyaM8zjcyIRG4zH4pA3chMUblzJ16ZlOJQEv6aKsvm8SMehWVG0Z33RrMdFdXO6Y7G2h+lVUClkMJsdaCo3NTke5t4jmEYqCf+s8lpJplMArvIppl69EjHNdeMw9y5MxEbG4fBg4fi8stHYtSoq3DkyO8AgLS0DsLxarUayckpwmMolc6qOJvNhoqKcpSVlaJfvwFuj5GZmQW73Y6LFy/g7Nkz6NChE/R6vXC9UqlC7959cPbs2SbbGRMTC622LsUhMlIHi8UCADh16gQ4jsPNN1/vdhur1Socc+7cGVxzzTi36zMy+uH06VOePE2tRsGMSDRVycSL0Tl34rXYHCiuMDX54U9IOKm/W3Z9MTollAopLCIMCPi26yOV0KgafpQ6E5g1OJ9fhfxSo6jaHs4YhgHkysavk0nAMOIbBVu0aCnuvfcB7NnzG/bv34slS/6Ffv0GCHkwMpn7+dNUsNRU4i7Lci7309QxLGQyaaPXAYBE0vQXBZZlodVqsX79pgbX8SM7AAOOc3/u6/crkMTzNaeda66SCXCe3EnCXjXiHHInxFstjcwwDCPaRNrmkn95deXZ4mo7CZ6//jqKN954BR07dsZtt92JZctex/z5C3Hw4H6Ul5d7dV8xMbGIiYkVRnR4f/xxGHK5HKmpaejWrQeysy+ivLxMuN5iseDEiePo3LkrgKaDpaZ07dodNTU1sNlsSEvrIPz78MMN+PXXXwAAPXr0xJEjf7jd7sSJ4149TmtQMCMCNrsDReXOAKWpkRmA8mZI21JtssHALzjXTEDAj2iIraKpueRfnpAELNKcHxJ4Wq0W27Z9gjfffAM5Odk4d+4MfvjhW6SldUR0dLTX93fHHdOwbdvH+PTTT5CTk41vv/0a7767FhMn3oSIiAhce+14REVF41//mofjx//CmTOn8eyzC2AymXDjjZMBOKeyAGewYbGYW3zMoUOHo0ePnnjmmfk4dOgAcnKysXLlCuzY8YUQIE2dejd27vwJmzd/gOzsS9i69d/4+ecfvO6fr2iaSQTyS43gOECrkiFK27CSiUfbGpC2hA9OYnUqqBRNfxQJwYzIAgJ+hLS56SNhVIkqmtqtzp27YOnSZXjvvXfw2WefQCKRICtrMF555Q0UFhZ4fX933DEVCoUc//73h3j11WVISEjElCnTceed0wAAERERWLnybaxa9RqeeOIRAEC/fv3x1lvrkZKSCgDIyhqM3r0z8PDD9+Jf/1rS4mNKpVK8+uqbePPN17Fw4TyYTCZ07twVS5cuw8CBgwEAl19+BZ555jm8++5arFu3Bn369MXf/z4V3333tdd99AUFMyLQ1J5M9SXHivNDnRBf8CMbyU3ky/CEjVbFNjLTQtI+4L5wHsdxXg/vk7ZhxIiRjVb2pKam4ddfD7hd9vTTixocV/+Ym2++HbfffkeTyc6pqWl44YXlTbZHp9Nh7dr3XS65Bvfd95DbMRMm3IAJE+q2IoiOjsY///lMk/cJAFdfPRZXXz3W7bKHHnq02dv4C00ziUBuC8m/PD5JsqDUuSYNIeGsqZV/6+ODhfwyo5DoGGoWqwOlBufwfHPBDL/hpNFiF6bUCCH+R8GMCHjyDQ8A4qPVkEoYWGwOlBsswWgaIQHT1J5M9cVHqSGTSmCzsygxtDy/Hwz5tQm9kRo5ItTyJo+Ty6SIi+Y3nBTXyBIhbQkFMyLg6ciMTCpBgt6ZuEV5MyTc5XuQQAsAEgkjVAWJJQlY+ALiwRIJSTF1I0uEkMCgYCbErDYHimv3ZEqJb7gnU320rQFpC0wWO8pqRxdbypkB6qZYxZI340nyLy+ZNpwkJOAomAmx/FIjODgrmXSapoereclUnk3aAD4Yj9IqoFW1fN7XVTSJ47z3dGoYcEkCppEZn7TFHZ5JHX+9vhTMhFheC3sy1ZdCFU2kDcj3MF+GJ5z3Ilkwsm6KrOVRJbEu+id2/A7QVivlB7Zl/OsrlbauuJpKs0OsbuXflqeYgLohefpgJOHMk9VzXdVtOFkT8hJnm92BooraqWGPRmacx5RUmmGzOyBvZkl5UkcikUKtjkB1tXOVXIVC2eLrzrIMHI72MZIT7n3lOA5WqwXV1eVQqyOa3U7BExTMhFhLezLVl1ybTFhltKHaZGu2koIQsWppt+z6EvXOSj6z1YHyKgtidKpANq9ZBWUmcBygUcqga2aRS55OI4daKYPJYkdhuQlpHn5xIYBOFwMAQkDTEolEApYV395MgdBW+qpWRwivc2tQMBNi3sy9A4BSIUWsTolSgwV5JTXo2SE6gK0jJDBa2pOpPr6SL7/UiLzSmpAGM54ucsnjN5w8l2dAQamRghkvMAyDqKhYREbq4XDYmz1WKmUQFaVBZaUxrEcsPNFW+iqVylo9IsOjYCaE+B2wAc9HZgDnH4BSgwX5pRTMkPBjtTlQXOn5NA0vJVbrDGZKjMjoEhuo5rWoLpjxbIoMcG44eS7PQOXZPpJIJJBImh8Fk8kkUKlUMJkcTa6M21a0p756ihKAQ6igtpIpQi33aLiaR+XZJJwVlNXtReZJBR/PNW8mlDzZYLI+Ks8mJLAomAmh3JJqAN6NygB1ScBiKVMlxBt1ezJ5Nk3D4yuHQr1wnrf5PgCERf8Kyug9S0ggUDATQnWVTN4FM/w3wnyRlKkS4g1P92SqT1hrpqQmZGuP2B0sCmunijzN9wHqKpqco1Lhm+NAiFhRMBNCecXeVTLx+EW4Sg1mWGwOv7eLkEDK82KNFldJMRowAGrMdlSFaNPGonITHCwHpUKKGJ3S49slRKshYRiYLA5U1lgD2EJC2icKZkLI0z2Z6tNpFEJJNs3Bk3DjyzQNACjkdZs2hmqqqW5PJo1XU2RymURoO+W6EeJ/FMyEiMXqQEmlcwdgbz/UAdrWgIQnX6dpeHUrYIcomPEh+ZeXHEPbGhASKBTMhAj/oajTyBGp8bySiZdM2xqQMFRc4ds0DU+oaApRvpivo0pA3fQwfQEhxP8omAkRbxfLqy+FPhhJGBIWy4vxbpqGF/KRGS8X+3OV7JIETAjxLwpmQqQuX8a31UDr1tygD0YSPlodxLtUNAUby3IuIzPeJS8DLuXZ9J4lxO8omAmRPB/Lsnl8zkxhmRGONrA/B2kfWjNNA9Sd95U1VtSYg1vRVFxpgt3BOpN5o9Re316oQqw0w0pViIT4FQUzIZLrY1k2L0angkIugYPlUFRu8mfTCAkYb3fLrk+tlEEf6cy1CXbejOsUmUTi/RRZpFoOrUoGDkAhvWcJ8augBzMHDx5Eenp6g3979+4Vjtm9ezcmT56M/v37Y/z48di+fXuwmxlQZqsdpQbfK5kAQMIwwg7aNNVEwgHLcsLeRL6e9663DXbeTGtHlRiGEUZnKG+GEP8K+kaTJ0+eRMeOHbF582a3y6OiogAAZ8+exUMPPYR77rkHy5Ytw88//4w5c+YgJiYGw4cPD3ZzAyKv9hulTlu3XowvkuM0uFhYVZsEHO+n1hESGCUGM2x2FjKpBPE+TNPwkmM1+Ot8WdDzZlo7qgQAyTFanM01UOI+IX4W9GDm1KlT6N69O+LjG//ju2HDBqSnp2PmzJkAgG7duuHYsWNYt25dmwlmfN2TqT6hPJu2NSBhgA8GknycpuGFamSmtcnLQF3eDCUBE+JfIRmZGThwYJPXHzhwANdcc43bZcOGDcPSpUvBcZxP5Zw8mcy/s2pSqcTtp6f4Iea0hIhWtSmtNnm4sNzo977V52tfw1V76m+w+lpY7jzvU+O1rTpfOyREAnDmzHh7P772leXqKpk6JEb63P7U2vdsQRDeswCdx21Ve+qrp4IezJw+fRp6vR6TJ09GYWEhevbsiZkzZ6Jfv34AgIKCAiQlJbndJiEhASaTCeXl5YiJifHpcSUSBnp960ZCmqLTeTdkXljhzJfp0SmmVW3q1TUOgHMuPzrat3U7vOVtX8Nde+pvoPtaYrAAALp10LfqvO+tcE7NlhrMUGmUUCu9/xjztq9FZUZYbA7IpAzSu8ZB5uMfkfQuzvdsYVnw3rMAncdtVXvqa0v8Gszk5OTg6quvbvL6n3/+GVVVVTAajViwYAGkUik2bdqEqVOnYtu2bejevTvMZjMUCvcVcfnfrVbfN2hjWQ4Gg3+HdqVSCXQ6NQwGExwOz8ujL+YZAAB6jRzl5b4PlatlTO3mdXacu1SGGJ3K5/tqia99DVftqb/B6uuFvEoAQExE6857wJlvZqix4tiZYnRN0Xl8O1/7evxcCQAgMUaDKoPvlUgqKSCVODecDPR7FqDzuK1qT33V6dQejUD5NZhJTEzEjh07mrw+ISEB+/fvh1qthlzu/HbVt29fHDt2DBs3bsTixYuhVCobBC3872p166JQuz0wL7rDwXp83yZLXSVTUoy61W1K0KtRUGZEdmE1dD5si+Atb/raFrSn/gayrxzHCcsRJEa3/rxPidXAUGNFdmEVOiZ4v/Ckt33NLnTmuSXHaFrd9rhoNQrLjMgpCs57FqDzuK1qT31tiV+DGblcjm7dujV7jE7n/i1KIpGgW7duKCwsBAAkJyejqKjI7ZiioiJoNBpERkb6s7khwSctRkUooFX5XsnES47VoKDMiLzSGvTp4tsUHCGBVlFthdnqgIRhkBjjezUQLzlWixOXKoK2LIE/kn95yTEaFJYZUVBmRO/O9J4lxB+Cmj20c+dOZGZmIjs7W7jMbrfjxIkT6N69OwBg0KBB2Ldvn9vt9uzZg6ysLEgk4Z/slNfKxfLqS6FtDUgY4IOBBL3a53wTV8He1kDYLdsP79u6DSfpPUuIvwQ1OsjKyoJer8fcuXNx9OhRnDx5EnPnzkVFRQXuvvtuAMC0adNw5MgRLF++HGfPnsW7776Lr7/+Gvfff38wmxowuX78hgfUrXmRH4K9agjxlD9HNoC6jVaDUZ7NcZyw/EGKDxtM1pccQwvnEeJvQQ1mIiIi8P777yMuLg733Xcfbr/9dlRUVGDTpk2Ii3Nm+ffo0QNvvvkmfvnlF0yaNAmffPIJli1b1mbWmMkr8e/IDL/WDC3CRcSMPz9bs+CcK36j1eIKE2z2wO5zVFFthcliB8PAL1NkdWvN0HuWEH8Jeml2x44d8cYbbzR7zKhRozBq1KggtSi4Wrtbdn38HweD0YZqk61VKwoTEij+HpmJ0iqgUcpgtNhRUGZCBx+SgD3FB2IJeg3kflgbhv8CUmqwwGJ1QKmQtvo+CWnvwj8JJYwYzXaUVznX2kiJ8883VJVChhhd7cZ79E2PiFReqf+maQDnPkfBypsRAjE/jSpFqOXClw5+IUFCSOtQMBNE/Py+PlIJjR8qmXh1U030wUjEx2C0otpkA4O6KRZ/EPLFAhzE57Vyg8nGUBIwIf5FwUwQ+XuonccnFNLIDBEjPjk9NkoFpdx/UyrBH5nx3/uWkoAJ8S8KZoIo189l2bxkKs8mIhaIkQ3X+wv0eR+ILyFJQRpVIqS9oGAmiPJqd8v2+4c6X6ZK5dlEhAIxsgHUTTMVlBlhD9CS7gGbIoup3XCSRmYI8QsKZoLI32vM8ITqiEozrLbAlqkS4i1/l2XzYnTOaSsHy6G4wvf9kpoTqCmyJJdAjOU4v90vIe0VBTNBYjTbUFHt3GPK399QIzVyaFUycKBvekR8ApUrJmEYIUDiF7Xzt0BNkcVFqSCVMLDaWFTUVjgSQnxHwUyQ8KMyzkom/y7vwzCMkDcTjBVRCfGU0WwXgvhkPwfxrvcZqPM+UFNkMqkECXrnxrmU60ZI61EwEyS5fl75t74UYVsD+mAk4sFPMUVHKPwexAN16zUFajsPPphJ9tO6UK6SqAqREL+hYCZI+A0m/T1czaNtDYgY+XODxsakBHhkJj+A7effszQ1TEjrUTATJIEemaGF84gY8SOFgZhiAtzLs1nWv4m0rnlufPWRP9WNzNB7lpDWomAmSIRvqPGBnWYqKDPCwQamTJUQbwV6ZCYuWgWZVAKbnUWJwezX++aTfwOR5wa4l5YTQlqHgpkgqDHbUBmgSiZeTJQKCpkEDpZDSYV/P9QJ8ZW/9zWqTyqRICmmNpHWz3kzgW47X55dXmWB2WoPyGMQ0l5QMBME/Mq/sTol1MrAbFQuYRhh2JoqmogYWGwOlFY6A+vkAI3MAC7bGvj5vK9L/g1M27UqOXSa2g0nywKzTg4h7QUFM0FQt85GREAfh7Y1IGJSUGoEB+cu0TqNImCPIyQB+3lkJj9Aa8y4ooomQvyDgpkgCHTyL0/YRZi2NSAiIOTLBGiahheoID5Qa8y4SqKKJkL8goKZIAjUCqj11ZWp0gcjCb3gnfd1e5NxftoawGy1o7Q2oTg4IzP0niWkNSiYCQJhZCZAlUy8ZJedeP31oU6Ir/g/0IEqy+YlxmggYRiYrQ6U+2lrAL7tOo0cEWq5X+6zMXXvWQpmCGkNCmYCrNpkg6GGX849sMPtrh/q/PoYhIRKsEZmArE1QLDazlc0FZbThpOEtAYFMwGWW1wNwLmxnEoRmEomnkwqQXzthzpVNJFQsjtYFJU7K3QCHcQDLhVNfsoX498/gazCApyfCzIpA5udRVklLalAiK8omAmwYH3D46VQEjARgcIy50iDSiGFPlIZ8Mfj92jyVxDPr1wcyORfwLlOTqKeFs8jpLUomAmw3CAHM7StARED13wZhmEC/njCee/nkZlAV2IBlARMiD9QMBNgeUEqy+a5JgETEip1I5KBDwaAuhGUXD9UNFltDhRXOKfIgvElJIm2NSCk1SiYCbBgj8yk0MJ5RAQCvSdTfUmxGjAAasx2VBltrbqvgjIjOA7QqmTQaQO32B+PFs4jpPUomAkgg9EqfLAGeu6dx38wVtZYYTS37kOdEF/lBXi37PqUcilio1QAWh8UuCb/BnOKjEZmCPEdBTMBlFe7J1NclApKhTQoj6lWyoSES1o8j4QCy3LCH+Zgjcy4PlZrK5qClfzL47+AVFRbYbLQhpOE+IKCmQAK1jYG9dG2BiSUiitNsDtYyGUSxOlUQXvcumCmdUF8MJN/AUCjkiGqdjqLRmcI8Q0FMwEkJEEGeOXf+qiiiYSSsNt0jAYSSeCnaXh8EN/a8uxgL6cA1I3OFNB7lhCfUDATQMGuZOKl+OlDnRBfCGXZwT7v+ZGZVpz3rov9BTOYEUZTy+g9S4gvKJgJoLpppoigPm7dyAx9MJLgq9ttOjjTNDw+x6Wy2vfk98JyExwsB2WQFvvjCbtn08gMIT6hYCZADDVWVJtsYFC3jkSw8N+ISyrMsNocQX1sQkIxTQP4J/k9XwjEglPJxBPKsylnhhCfUDATIPyoTHy0Gkp5cCqZeDqNHFqVDBwooZAEF8dxQdstuzHCFKuPye/BTv7l8dNMhWUmsCxtOEmItyiYCZBQfTsFAIZhKAmYhESZwQKLzQGphBF2sg6m5FaWZ4fqfRurU0EmlcDuYFFioA0nCfEWBTMBIuTLBLmSiUfbGpBQ4M+3BL0aMmnwP15SWhnEC4v9BTmYkUgYJMU4gz/KmyHEexTMBEhecTWA0IzMAFSeTUIjlCOSro/ry8hMqBb749WVZ9MXEEK8RcFMAHAcF7IF83g0MkNCIS+E+TJAXRBSajDDbPVuNV1+sT9FkBf74yXRtgaE+IyCmQAw1FhRY7aDYeq+bQUbP0xeQAmFJIjqNpgMzXkfoZYjUiMH4H1QwI/mJAV5sT9esrDhJAUzhHiLgpkAcK1kUgS5kokXp1NBLnMmFBZXmkLSBtK+cBznVtocKvxjezvVFOopsqRYKs8mxFcUzARAqKeYAD6hkN+jiT4cSeAZjDbniCRCNyIJ1I1KejvCEarkXx7/nBlox3tCvEbBTACE+hsej/JmSDDliWBEEvB9rZm6NWZC875VK2WIjnBuOEmjM4R4h4KZABDDyAzgMtxOwQwJAj5oTg7ygnP1+VLRxHKc0P5Q5fsAdYnTVJ5NiHcomPEzjuOQVyySkRkfh9sJ8YV4RiSdj19UYYLNznp0mzKDGVYbG7LF/nhCeTaNzBDiFQpm/Kyi2gqjxVnJFOpvqK7TTBxHFU0ksPhgJlRl2bzoCAXUShk4Dij0MCjg82WSYjSQSkL3scgnAdPIDCHeoWDGz/gP9AS9BnJZ6PIGACBRrwHDACaLA5U11pC2hbR9/AhgqEdmGIYRpoo8nWIVArFQjyrRhpOE+ISCGT8TS74MAMhlEiREO4fM833cq4YQT9SYbULAHOoRSWcbvMubCdUGk/XxIzNF5UY4WM+myAghFMz4XV5JaLcxqE/4UKdhaxJAfPm/PlIJtVIW4ta4Jr97dt7niyTfJ0angkImgd3BoaSSNpwkxFMBDWYWLlyIefPmNbh89+7dmDx5Mvr374/x48dj+/btbtdbLBYsXrwYw4cPR2ZmJmbPno2ysrJANtVv+Ll3MYzMAFSeTYKjbuVfcZz3fDs8GZHkOE4IekK52B8ASBgGibQSMCFeC0gww7IsVqxYgS1btjS47uzZs3jooYcwcuRIbNu2DbfeeivmzJmD3bt3C8csWrQIv/76K1auXIkNGzbg3LlzmDFjRiCa6ldi2JOpPtpwkgRDXfJv6KeYgLrpooKylqdrKqqtMNUm7SeGcLE/Xt2Gk/SeJcRTfh8PPnv2LJ5++mlcvHgRKSkpDa7fsGED0tPTMXPmTABAt27dcOzYMaxbtw7Dhw9HYWEhPv/8c6xZswaDBg0CAKxYsQLjx4/H4cOHkZmZ6e8m+w3/oej67SrUkr1MhCTEF2IbmYmJUkEhl8BqY1FUbmq2wopvuzNpv3Xf71hjBdiKAkiik8Coo8Aw3u/xlCwEYvSeJcRTfg9m9uzZg27dumH16tV48sknG1x/4MABXHPNNW6XDRs2DEuXLgXHcTh48KBwGa9Lly5ITEzE/v37RR3M5NbmyyTGqFv9oegvyTHOD/HKaiuMZjs0qtDnM5C2Rwx7MrmSMAySY7W4WFCFvBJj88FMSeuTf1lzFayHv4Ttrx8Atna3bqUWUn0qJPoUSPSpwj9GrWs2yKHybEK85/e/bFOmTGn2+oKCAiQlJbldlpCQAJPJhPLychQWFkKv10OpVDY4pqCgoFVtk/k5wJBKJW4/+YWu0uIj/P5YvtJFKKCPVKK8yoKiChO6p0X5dD/1+9rWtaf+travZqsdpQYLAKBDonjO/dQ4ZzBTWG4U2tRYX4X3bYL3bedsZph//xrm33cANmfCLqPVgzNWAJYaOApOwVFwyu02jCoC0phUZ6ATk+b8f0wqJGqdsx3xEQCc5dmtfS7pPG6b2lNfPeVVMJOTk4Orr766yet3796NmJiYZu/DbDZDoVC4Xcb/brVaYTKZGlwPAEqlEhaLxZvmupFIGOj1gfnWqNM5y5+LK53t69ZBH7DH8kXHpEiUV1lQabK1ul18X9uL9tRfX/t6OrscABAdoUTHVL0/m9Qq3Tvq8dvRApQYLA3Oe9e+FlU4g5AenWI8fn9wDhsMh75Dxa6tcNRUAgAUSV0RM3oq1F36gXPYYCvJhbUkG7bibFiLs2EtyYa9vBCcuRr2vJOw5510u0+JRgdFfAck69MwQlmBAms0JKwZUbGxrXkaGvS3raO+tk9eBTOJiYnYsWNHk9dHRbX8rV+pVMJqdV/Ajf9drVZDpVI1uB5wVjip1b6/cCzLwWDw77CtVCqBTqeGwWCCw8HiXK7zQy02UoHycvHMd8dHqQAApy+VY2CPOJ/uo35f27r21N/W9vXkuVIAQFKMWlTnvV4rBwCcz6sU2tVYXy8VGAAA0WpZi+3nWBbW07th3vcp2KoSAIAkKhHqobdA3m0wLIwElorazxllApCaACZ1IJQAlAA4mwWOinw4ynLhKMsBW5YLR3kuWEMxWKMB5ot/ARf/wm21MVXpmm9Qpo4SRm+kMamQRKdAGp0ERtNyTg6dx21Te+qrTqf2aATKq2BGLpejW7duPjcKAJKTk1FUVOR2WVFRETQaDSIjI5GUlISKigpYrVa3EZqioiIkJia26rHtHu7T4i2Hg4XN5hDWmEnUqwP2WL7gqyPyimta3S6HgxVV3wKtPfXX175mFznP++RYraieq0R9bYlzSQ2sNgckLn/4+b4ajFZUGW1g4Nztu6n2cxwHx6U/YNm/FWxZDgCA0URDkXUj5L1GgpHI4HAAQAv9Z+SAviOk+o6QunyUcjYL2Io8sOW5cJTl4syx44iwFCNWWgPOVAl7biXsucfc70uugkSXAElUEiRRibX/ksBEJYJRRrgFOnQet03tqa8tCXo26KBBg7Bv3z63y/bs2YOsrCxIJBIMHDgQLMvi4MGDGD58OADg/PnzKCwsxODBg4PdXI+VV1lgsjgglTBC8CAWybR7NgkgseyWXV98tAoyKQOrnUVppRnx0Q1HdvnE5dgoFZTyxrcfsRecgnXf1rrcF4UGigHXQZFxDRiZstHbeIuRKyGN7wJpfBfIAfxuOIkfD+Xi+iFJuDFD5QxyynPBlueCrSgAV10C2MxgSy+BLb3U8A4VGkiikiCLTgKSOsCqigEXkQBJVCIYhbheJ0L8IejBzLRp03DTTTdh+fLluOmmm/DLL7/g66+/xrp16wA4p7Kuu+46LFiwAM8//zzUajWeeeYZDBkyBAMGDAh2cz2WK+zJpIZMZElZfJVGcYUJNrsj5HtGkbZFLLtl1yeVSJAUo0FOcQ3ySmoaDWaaa7ujLBuWfVvhuPRH7R3Koci4FooB14FRBrav/BeQ3HI7pAldIU3oCrnL9ZzDBraqGFxlIdjKArCVhcI/rqYMsBrBFp+DtfgcrKfd75tRRQojOPxojiQqERJdIhi5f4IzQoIt6MFMjx498Oabb2LZsmXYsGED0tLSsGzZMmEUBgCWLFmC559/Ho899hgAYNSoUViwYEGwm+qV3GJxLZbnSqdVQKOUwWixo7DMhLSEiFA3ibQRNrsDRRUmAKHfLbsxybFa5BTXIL/UiP7dG16f18jmmKyhGJaDn8F+ejcADmAkkKePgmLgjZBog5PgLCyc18SGk4xUDml0ChDdcC0vzm4BaygCW1kIpqoQMlMpTEW5cFTkgzMZwJmr4DBXAYWnG96vNgby3qOh6D8BjIS+9JDwEdBgZuPGjY1ePmrUKIwaNarJ22k0Gjz33HN47rnnAtU0vxPrt1PAuYtwcqwGZ/MMyCutoWCG+E1hmQkcB6iVMkRHNKxCDDX+/djUhpOuKxezJgOsh7+A7diPAOsAAMi6DoFy0GRIopMavX2gJAsbTppgd7BejfYyMiWkMR0gjekAmUwCvV6L8nJnvhxnNYE1FIKtKHD+dBnZgaUGXE0ZrPs/hf3i71CPfgCSqOD2mxBf0QpqfiJsYxAvzkAhOVaLs3kG2taA+JXrbtO+rHYbaEIw00S+WF5pDZSwokfpL6g58DNgdy6vIE3tA+WQWyCN7xKsprqJjlQKKxiXVJr9lofHKNSQxnWGNK5zg+s4czXsFw/DvHsz2KKzqPl0IZRDb4e89xhRvraEuKJgxg+cG9WJd2QGqNvWgDacJP4kjGz46by3F5yC7Y+vwHEsJGqdc7Vctc65NYDr76oIMEzLoxWuG61yHOd2XXWNEQNsv2Ns9J/QnnYGMZL4LlAOuRWy1N5+6Y+vJIyzkOBSYTXyS2uCUlTAqCIgTx8JaWpvmH9ZD0fuMVh2bYT94mGorrwvaFNshPiCghk/KK00w2J1VjIl6sW5iJFQ0VRCIzPEf/y12zRbXQbL3o9hP7tHuMzR3A0YBowqsmGQo46CRF17uUaHBEUE5AwLk8W5d1q8Xg2OdcBy4n+w/7YVk7XOBf8kUUlQDL4Zsi6DRDMKkRyrxaXC6ibzZgJFEhEL9YT/g+2vH2DZ+zEcOUdRs3UBVCOmQd59WMt3QEgIUDDjB/wUU1KMRnSVTDzXXYRZloNEIo4PbBLe8oURSd9GDji7FdY/v4H18BeA3QqAgbzXKEgSuoIzVjoTVuv/s1QDHCf83pLleqCGVYD7z9eoitaj2lIFW2kepAAqWA3+0F6O6269Q3QJr/xoTCimhhlGAkXGtZCm9YH5p3fAFp+H+cc1sF84BNUVd4FRiXM6nbRfFMz4QU6xc9Ewf04xOQrPwHLwc3AWIxi1rm7IXRNV71uoDlBqW/w2GRflLBm3O1iUVJqQoKe1JkjrOFhW2AzR25EZjuNgv3gYlt0fgasqBgBIErtDNWJqo/kcbrdl7eBMVQ2CHNbUePADjoVWYgWMRbAbnQt2MkotjmmHYv2ZJFzZvbPoAhnAdffs0I2mSqNToLnxaVgPfwnrof/Cfm4fagpOQXXlvZB16BeydhFSHwUzfuDPsmzWZIB13yewnfyf2+XND7lLwbgMrTMqZ7Aj0bjnGnTTA6dKWOSVGimYIa1WVG6Cg+WgkEsQU7tlhicc5Xmw7N4MR85RAM6VdJXDboes2zCPpngYiQyMVg94kMPBcSy++Okv7D5wGiN7ajG+vx4alRTWhN749dOTsKFMtHluQnl2iJP2GYkMyoGTIOvYH+af1oKtyIfpqxWQXzYaymF/p7VpiChQMOMH/ijL5lgHbMd+guXANsDq/PCS9bwCss5ZLt8yK+t9EzUAlhqAc4AzVjh36i1t+jEeAcDqAfvOz1BzWO8MgJRaQK4Go6j7B+H/GjBylXM1UbUGrFbSIImStF/89EdyjNZtq4CmcFYjLAf/A9vR7wHOAUhkUPQbD0Xm9c7zLAAYRoL4hHgUssU4Uh2FiT0GI7K2VJlf/be1+T6BklgbzFSbbKgyWhGpCW3puzS+CzSTF8Oy7xPYjn4H2/GfYM89BvXoByBNbGQRH0KCiIKZVmJZrm5kJt63D0V7wSlYdm0EW5oNAJDEdoLqimkefUBwDnuDYIetH/wYnf9nzVWQMIDCXgO2vAYo966dlQDAMPWCH40z+JHXC4b435UaQKFxBkau13tQiULEra6SqflRPo5jYTv5P1j3bQVnrgIAyDplQjn8Dkh0CQFvZ115dt0Ih8liR6nB4na92CjlUsTqlCg1WFBQZgx5MAMAjEwB1eVTIOuUCfPP68AZCmH871Io+l8HxcBJYKT0J4WEBp15rVRcYYLF5oBMyiDBy0om1lgBy54tsJ/Z7bxAqYVy8M2Q97oKjMSzP/aMVAYmIgaIiGnx2H3H8vHhF4dwWZIU91+d5gx0rCZwVhNgNYKzmcFZjbW/Oy/nbHXXg+Oc/6xG53Fe9dat1YBcBUapcQ+I+KCn9nK3IEjpfgykctFUnbRXQvJvMyMbjsIzMP/2Idji8wAASXQylJdPgSwtIyhtBICkWA0YOEc4DDVW6PVaoe06rQIRannzdxBCSbFalBosyC81okdadKibI5Cl9ob2liUw/7YZ9tO7YP39S9izj0A1+kFIY9JC3TzSDlEw00qXCpzVFEkxGkg9DEA41g7b0R9gOfgZYDODr+BQDLkFElVkwNqaEheJKk6No2UySFP7eBUMSKUMoiNkKC8qgc1UUxfsWE3grEbA6hII2dyvc15vAmcxAqwdAOc8xmbyPSCSyJxBjyqy9l9E3U9+HRK3yyPByEL/zbYt4cv8GxvZYGvKYdn3Ceynf3NeIFdDOXAS5BlXg5EE92NHKZciNkqFkkoz8kpq0ClNXzc1LLLNMetLitHgr/NlIU0Cbgqj1EI9+gHYOg2A5X8bwJZegnHbIiiH3Ax5xjiPv5AR4g8UzLTSpQLnsLmnQ9X2vOOw7NoEtjwXACCJ7+qs4EjoGrA28hJj1GAYwGixw1BjRVSE54l7DMNAolBBotVDqozyuQ2c3Vo3EuQS7HBWE2Axuv3OWYy1gZERnKVuxAjgANbucWmuQKZoGOA0FvSoIiGJ0IHTUfDTFJbjkF/WcLdszmGD9c9vnaXWfKCePhKKwTdDovH9vGmtlDitEMwAdcsp+Guxv0ARKppEvHK3vOtgSJN6wLzzPTgu/eEcbb74O1RX3Q9JZHyom0faCQpmWulSoTOYaamSia0ph2XPv2E/uxcAwCgjoBh6K+TpI4OWPyKXSREfpUZRhQl5pUavghl/YWQK5wiJj3/YOI4FbJbaAKfGWaJrrgJnrq730/3/YB2A3QquuhRcdTNZ0i4qAed0lkLdMEm6QdK0M1m6bsrM9VhVm8sRKqs0w2pjIZXUTa/aL/0O828fgTMUAgAkCd2gunxKUAL1lqTEanHkbKkQxOQVizv5l5fMrzUjwpEZVxJNNNTjnoTt5E5Ydn8ER/5J1Gz9F1TD74QsfSRNCZOAo2CmlfhppqZGZjiH3flN9dB/nPu+MIyzpHHQ5JAsPJUcq0FRhQn5pTW4rFP4LU/OMBIhWEBErEe34TgOsJldAhxDw+DHVC8gstQA4ACHDZzJBpgMrcgRgjOgcQ18FGowytopMXXtaJBaV7uqrfOnMwgS5x8BfvuOpBgNGEMhjLs/giP7CACAUUdBOfQ2yHoMF00Qx49w8Mn6uSLeGNZVUm2wVezDhpPBxjAMFL2uhCzlMph/XgdHwSmYd74L2cXDUI68O6Qjc6Tto2CmFViOQ3ZR0wvm2XOOOqeUKgsA8IuCTYM0rlNQ2+kqOU6LP86WIr8dbWvAMExdAORh9YxUAkRpJSgvKoHdVOMyNcbnBplrk6ZNTSRM1/5k7c47tJmdCdY1XpSQSeV1wU1twMMHOvUDH0atC+p6H3klRihhxXWqY6jZutY58iWRQtF3HBSZNzifaxHh35/5pTWw2BwoLje5XS5W0REKKBVSWKwOFFeYhG1JxEyiS4D6+nmw/fk1LPu3wX7xMByFZ6AcdTfknQeGunmkjaJgphVKKkywWBtWMrHVpbDs/gj28wcAAIxaV/tN9fKQf1Plv6E2tYswcWIkEkhVWkgjAU7dcqVYUzi7FZzN7B4I2Wrzg8xVYE1VzpEifrrM5Pw/HFbnqFBNGbiaMs8eTKqoXTxRB0apdU7nSRVgZHJAqgBkcjBSuTN3iP9dpgCrUKImKhI2MwsHIxeOr/8TEikYhgHHsZBf2oMF0T9CZzQ7H7pjf6iG3wFJVJLPz1Ug8UFAeZUFpy6VgwOgVcmg04i3kglwBuJJMRpcLKhCfqkxLIIZwPn+UfSfAGmHvs6F9kqzYf52Jexdh0AS28G54rLwT+b8nZEIlzESmcv10kaOl9S7XgZOIQdnV9BaWO0UBTOtwA9ZJ8dqIZVInMmPf3wF6+EvnX+MGAnkfa6GcuAk5+J0IsDnCNDu2cEh5AipdV7djrNZnIENH+A0CHwMdUv6mw2Aww44vMsJcuXR2cAwtUGNBEOsJkACWNRxiL5yGmQd+3v9mMGkUckQHaFARbUVvx3JA+AcpRTrNJ6r5Fg+mKkBEF4JtdKYDtBMWgjrwf/A+sd22M/tA87tC9jjVQAAmNrAXQHInP/qAvPa3xsE9UqX29T+zh8jUzhHSWVKQK5wrqElVwIyFVVsiQgFM62Q47JYnv3SHzD/tllIfpQmp0N5+VRIYzuEsokN8N/sKqqtMFnsUCvpFBAjRq4EI48HdC3/8XLLCeIDIEsNOLsVsNvAOazO5GeHDbDbnEGP8NMKhrVByjlgs5hrb8Mf6xwdcnkgZ94XADMnx9emfhg9cRpkSdEBehb8KyVOi4pqK3b/me/8PUxGOYRtDUSeBNwURiqHcsgtkHUaANuZ3c7zi2WdU5OsHWAd4FhH7e+Out+5er+7XW93+90d53wMuxWwCJcEhlQBRqECZEowChUYmQpQqGoDH3Xt+1jlzH+Tq5xBkPD/usvBH0frZ/mM/pK1Qm5xNWIkVRhbsxemr08C8H6fmWDTqGSIilCgstqK/FIjuqZ4N2JAxMeXnCBXMpkE+tol/u121u06jnMmQcNhc/5xcNhQWVmNhR+egpVR4O9x4XP+pMRqcexCOUornVNjYs+X4fFfQMRcnu0JaWL3gG17wLEsZBIW0ZEKlJdWwG621J6vVuG85ewWZzBvt9YG+Db3Y+y1x7ic6/xthC8ENotzyQGu9n3isIIzWZ1t8EtPmLrRINefUvffJXIlHBFaWOwMOIncGUzJ+JEkZcP7kCog0USJZoYgECiYaQV94X7Mj9oJhcEBMFLI+14LZdaNokt+rC8lVlsbzNRQMEOaxTBM3VB97QdhfpkMFiiQGK2GXBY+w+z115RJaWEbBrFwHZnhOE6UX5JCjZFIwMhkkKi0kGgAiYJt+UY+4gN8zm5xLhZqN9f+tDiT/u0WZ36c2+VmwO4sAoDNUlsoYBaOhcPK37vzstoR0OYCJGsz1zWKkUI59FbI+45rk+cQBTOtkOn4HQrGAS6xF7SjpkGqTw11kzySHKvB8YvlAU0Cdu59Y0aEWo5Ijdzj1ZGJ+Al7MoXJNA2v/mq/4TLNlKhXgwFQY7ajymiDTkuLOTZm4zcncfR8GZJjNEiL16JjYiQ6JkQgNsq/SxzwAT4jUwB+WrGdY1lnsMNP87r+dFgbXM6wNqjkHExVNWBtFpfrXUaW7BbndDJ/uaUGlj3/hqMsG6orpre5FdEpmGmFqOtmwmatQnz3DDgc4ZNBz/8R8md5dnmVBadzKnA6pxKncyqQXVQNvqiAARChkUOnVUCnUSBKq3D+n/89wvlTp1UgUiMX9VoapG637HCZpuG5tlelkEIfGfxFI32hcNmOoaDMSMFMIyw2B77fnw0OQH5JDQ6dKhauUytl6JgQgQ6JEeiQEIGOCZFIidOKalSRkUiEveg80dzUcGM4joPtr+9h2b0Z9lO7YKwogHrs45BoolvZcvGgYKYVEjt1Fk6oAKaY+R1fnu1rRRPLccgvqRECl9M5lSipzUNwpVHKYLLawXFAldGGKqMNuR7UzUSo+cBHjqgIZW2g47wsql4QRCM+wVc3MhMe0zS8SI0zWK4y2pASJpVMvKRYDUoqzcgvrUHPDtGhbo7oFJQ6N76NUMtx48guuJBvQHZhNXJLamCy2HEyuwInsyuE46USBsmxWnRMjKgNdCLRISFC1JuOtgbDMFBkXAtJdDJM378JtugsjJ8thnrsDEjju4S6eX5BwUw7xI/MFFWYYLOzLX5DsdkdOJtnQPahXPxxqhhncipQY7a7HcMwQMeESHRPi0KPtCj0SIuGPlIJluVQVbtbMf+v0vWnse7yKqMNLMeh2mRDtcmGvBb6oZBL0D01Cukd9UjvEI0uyTpRfdtqi2x2VpieDLeRGcDZ5pOXKlrcfkRskmO0OHpOnBtOikFuiXPx0k7JOowb0lEYrbA7WOSXGnGpsArZRdXCzxqzHTnF1cgprsZvLvcTo1OiY4IzsOmY6Axy4qJUkIRR4NscWVoGtDcthOmbN8BW5MH43+ehuvI+yLsPC3XTWo2CmXYoOkIBtVIKk8WBwnIj0uLdt1WoNtlwxmXU5UKBAfZ602gKuQTdUuoCl64pukbLvCUSBlG1Iyot4QOZ+kGP8Hu9wMdqY3HsQjmOXXCuqiuXSdAtRYf0jnr06uhsk1wmbcUzRXhF5Ub88nse/nckH9UmGxgm/EZmAKB7ahROXqpAt9TwWlo/SRhNpWCmMfwO7h2T3HNYZFIJOiQ4p5d4HMehzGDBpSJnYJNdWI1LRVUorjCjzGBBmcGC38+UCMerFFJheio1QYuUWC1S4rRhO4ojiUqCZtICmH58G45Lf8D84xqwZTlQDJ4c8kVdW4OCmXaIYZxDrOfyDMgvNUIhk9ROGTkDmMY+MKMiFMjoGodOiRHolqJDh4QIv+e2SBjGOaWkUbS4NhjLccgrrnEOH18qx8nsClQZbThxqQInLlXgP3B+kHVN0SG9QzTSO0ajW2oUlPLQBDf8EvqF5UYUlZtQWWNFj7QoZHSNDVmbWuJgWfx+uhQ//56Lv87XrUKsj1Ti+uGdoFKE38fHTaO6YsSANCTrlUJ1bTjgN5wM9/LsQOGnPjsmtpyQyzAMYqNUiI1SIbNH3QeNsXa0RhjFKapGbnENzFaH8PnoSqdVIDWOD240SInTIjlO6/z8EjlGoYF67BOw7t8K6x87YP39SzjKcqAe85Doq3GbEn6fRsQvkmM1OJdnwDtf/NVg1IW/vkdadO3ISxSS47SIiYnwOOEs0CQMg7SECKQlRODqgWngOA75pUYhsDl5qQKVNVacyq7AqewKfPGbc568i0tw0z01yq9/kOsCFhOKyo1C4FJYbkJ5laXB8d/uz4ZCLkG/bnEYlB6Pft1iRREglBnM2PlHHnb+kYeKamcBKAOgT9cYjB6Qin7dY8M2V0khl6Jv9zjnecyG/jz2FD8yU1zp2dRweyMEM0m+VxdpVDL07BDtlpNkd7AoKDMKozd5JUbkldSg1GAWRomPX3Tfby1CLUdKnHP0JiVWI/w/SqsIWZ6Wo/Zcd33fMhIJlENvgyQmDead78Fx6XcY/7ME6rFPQBKVGJJ2tkboPzlJSHRN1mHXnwWwOzjnH/lkHXqkRaF7WhS6p0Yhst63C7EnSzIMI3xojM5yBjeF5Sa34Ka8yoIzOZU4k1OJ7bsvQiph0CkpEukdo5HeQY8eaVEtrohstTlQVGFCYRkfsNT9bCxgcaVRypAYo0aiXgO1UoY/z5WipNKMAyeKcOBEEeQyCfp2jcWg9Hj07x4X1NWZWZbDkbMl+OFADn4/UyJUokVq5LiiXzKuHJCKhOjw/MbWFkRp66aGi8qNSK03NdyeWWzOTTgBoENiJGCvvyKw72RSCdLiI5AWH4HhqNt3zGSxo6DMGdgI/0prUFJhRrXJJnyJcqVRymo/ozTCVFVKnBb6SGWLn692Bwuj2Q6jxQ6TxQ6LzQFGVoGikhrUmGwwWmx119f+NFrsMJqdx5utDqiVMiycPgiJMe7Tw/Iel0MSlQTTt2+ALc9DzefPQn3No5Cl9vbb8xgMFMy0UyP7p0CrliM6QonOSZFQiHSqw1f8Bn1JMRpcOSAVHMehuMKEk5cqhOCm1GDGuTwDzuUZ8NWeS2AYoFOiM7i5rHMMNBoDzmaXIb/E6FPAkqB3+RmjaTDHznEcLhZW4cCJYhw4WYSichMOnSrGoVPFkEkZZHSJxcD0eGT2iINGFZj5+coaK347WoCdf+Sh0CW5NL1DNK7KTEVWz3gaBRAB/nw+n1+FgjIKZly5VjJFRyhRURH4qTi1UoYuyTp0SXZfdNRic6Cg1Ii8Utcgx/n5YbTYcSa3Emdy3aerVAopUuK0SNSr4WA594CkNhix+mE03GSx49jF8gbBDABIE7pCM3mRM6ApOgfTjuVQDr8D8j7XiP6LLI+CmXZKJpVgyGXhN5ToK4ZhkKDXIEGvwcj+KQCAksra4OZSBU5ml6O4wowLBVW4UFCFb/ZlN3lffMCSoNcgsV7AolXJPH7zMwyDzkk6dE7S4eYruyK7qBoHThbjwIkiFJQZ8fuZEvx+pgRSCYPenWMwKD0emT3jW514yHEcTl6qwM+/5+LgyWI4WOcwjEYlw+UZSbhqQGpYViq1dUkxWpzPr6Ik4Hr4KaZUEZTbK+VSdEqKRKd60102uwMFZSa3UZy8khoUlZtgtjqEL1UtUSul0Chl0Kjk0EUooZAyUClk0ChlUKtktdfV+10pw1d7L2LnH/koqTQ1ed8STTQ018+D+X8bYD+9C5bfPgRblg3liLvASMUfKoi/hYQESFyUGnF91RjRNxmAM1eEH7U5m1cJtUqOOJ0SCdFqt1GWCLX/N4NjGMa5YmliJG4a2QV5JTXOwOZkEXKLa/DnuVL8ea4UG74+ics6RWNgrwRk9Yj3agG1GrMNu/4swM+Hc91KfLul6nD9Fd2Q0Tka0jD5FtYe8XkznpZn2x0sTFY7rByDgqIq1JhsMFkcMFud0w5mix0mq/N3/nIHy2H8kI5hVe2VW1K34a9YyWXSBlVVgPM1Kiw3Ib+kBoXlRihk0rpgxCUw0ahkUClkkEic709vF83jV7suqWi4HpgrRqaA6qr7YYvtAMveLbCd2Am2PB+qsY9Dohb31jcUzBBSK0anwvA+SRjeJ8nrDwt/YhgGqfERSI2PwI1XdEF+qTOwOXiiCJeKqvHXhXL8daEcG785ifQO0RjUKwFZPeMRHdFwRVuO43Au34CfD+di3/Ei2Gr7opRLMbxPIq4ckIpuaVEh6yvxHF/RdPJSOT7+8QxMtUEJnxPhDE74yxywO3x7LS02B2bdNsCPLQ8sYWQmDKfeZFIJUuO0AV/3KK42362xxU3rYxgGin7jIdGnwPTDW3AUnoZx2yKoxz0BaVyngLazNSiYIUTkkmO1uOFyLW64vDMKy404WDsVdaGgSihF//DbU+iRFoWBvRIwsGc81EoZ9h4rxM+Hc3GpqFq4r7R4LUZnpmJYn6SgJhiT1uNHHkoNFny975LHt1PIJFApZVDJpVAppVApZFArpFAp636qFFKYLQ58ve8Ssl3Ol3DgOs1EGhcXpQKAZqeZ6pN16AftpIUwfvM6uMoCGP+7FKqr7oe865BANbNV6NOMkDCSqNdgwrBOmDCsE0oqTM4Rm5NFOJtnwKmcSpzKqcRH35+GQiYRkgad+VEJuCozFd1SdCHPKyC+SY7V4u9juiO/zAiVQgq1whmE8MGImv+pkAlBS4RGjvi4SI9G3cxWO77edwmV1VZUGa0NKhrFyOpSySTmaaZQ44OZKqMNZqvd4yUgJNHJ0E76l3OEJucozN+/CTYrB4qBk0S3wB4FM4SEqbhoNcYP7YjxQzuizGB2jticLMKZnEpY7SwSYzQYPSAFl/dNDtvVSom7sUM6enW8NwtbqhQyJESrUVRhQk5xDS7rJP5gJr+2kkmrktEGnM3QqOTQKGUwWuworTR7NSXHKLVQj58Fy76PYTvyNayH/gu2LAeq0Q+CkasC2GrvUDBDSBsQo1Ph2sEdcO3gDqiotsBQY0WHhAgahSFeSUuIcAYzRdW4rJM+1M1pkZgqmcQuLlqFS4XVKPYymAGcC+yphv0d0pgOMO98D/YLh2D8z3POBfZ0LSzXHiTiGicihLRadIQSHRMj6cOdeC2tdqomuzg88mbCedPTYIuPciYBl3qQBNwUec8R0NwwD4w6CmxZDoyfLYY977i/mtgqFMwQQggBAGHT2ZwwSQLOLaZgxlOxtXkzfI6Rr6SJ3aGZvAiS+C7gLNUwbV8O67Ef/dDC1qFghhBCCAAI66DkltSAZRvu2SY2/MgMVTK1LN6L8uyWSLR6aG6YD1n3YQDngOXXD2De8+9W32+r2hTSRyeEECIa8dFqKOQS2OwsCsvFvdKwtXZjV4BGZjwR60N5dnMYmQKq0Q9BMeRWAAxsx34CF8LNWykBmBBCCABAImGQGheB8/kG5BbXIDlWvEFCQRlVMnkjng9mWlgF2BsMw0A54DrI0jIAjgUjCd34CI3MEEIIEXRIqE0CFnneDL+NQQpVMnkkrjYB2LmBpc2v9y2N6wRpfBe/3qe3KJghhBAiEJKARV7RRCv/ekepkCJS41xvyh95M2JDwQwhhBABH8yIfWSGD2aSKZjxGD86Q8EMIYSQNi2ttqKppNIMk8Ue4tY0LZdGZrwm7NHUyvJsMaJghhBCiCBCLYc+0rkDO7+Oi9i47clEwYzH4qJr15qhkRlCCCFtnTDVJNK8mYIyIziOKpm8FeeHVYDFKqDBzMKFCzFv3rwGl99zzz1IT093+zdt2jTheovFgsWLF2P48OHIzMzE7NmzUVZWFsimEkIIqZVWW9Ek1iTgPKpk8glfnl3sp7VmxCQg68ywLIvXXnsNW7ZswU033dTg+pMnT2LRokW45pprhMvk8rpdfRctWoQDBw5g5cqVUCgUeOaZZzBjxgxs2rQpEM0lhBDiooPItzVwLcsmnotzWQWY47g2FQj6PZg5e/Ysnn76aVy8eBEpKSkNri8tLUVpaSn69++P+PiGu20WFhbi888/x5o1azBo0CAAwIoVKzB+/HgcPnwYmZmZ/m4yIYQQF3wScE5xtSj/6OVRMOOTWJ0zF8pidaDaZEOkpu1M0fl9mmnPnj3o1q0bvvzyS6SlpTW4/uTJk2AYBl26NL7AzsGDBwEAw4YNEy7r0qULEhMTsX//fn83lxBCSD1JMRpIJQxMFgdKDeLLr6BgxjdymRTREc4Apq2VZ/t9ZGbKlCnNXn/q1ClERkbi2Wefxa5du6DRaDB+/Hg88sgjUCgUKCwshF6vh1KpdLtdQkICCgoKWtU2mcy/sZtUKnH72Za1p74C7au/1Ne2y9f+ymQSpMRpkV1UjfxSI5JEtK2B1e5AUW0lU6fESOFzvT29tq3pa3y0GhXVVpRXWdCjQ9t5rrwKZnJycnD11Vc3ef3u3bsRExPT7H2cOnUKFosF/fr1wz333IPjx4/j5ZdfRl5eHl5++WWYTCYoFA2HvpRKJSwWizfNdSORMNDrA/OG1OnUAblfMWpPfQXaV3+pr22XL/3t1iEa2UXVKK6yBOyz0xfn8yrBcc4S8s4d9A2mwNrTa+tLX1MTInE6pxLVFoeoXtfW8iqYSUxMxI4dO5q8PioqqsX7ePbZZzF37lzh2J49e0Iul2PmzJmYM2cOVCoVrFZrg9tZLBao1b6fpCzLwWDw7y6wUqkEOp0aBoMJDkfodgsNhvbUV6B99Zf62na1pr+JtWuSnLpYjvJy8aw3c+xsCQAgOVaDioq6z/T29Nq2pq+62i0NLhUYRPW6NkWnU3s0AuVVMCOXy9GtWzefGwUAMpmsQdDTo0cPAEBBQQGSkpJQUVEBq9XqNkJTVFSExMTEVj223R6YE9zhYAN232LTnvoKtK/+Ul/bLl/6m1o7tZRdWCWq5yq7sAqAM1+msXa1p9fWl77G1C6IWFRubFPPU9AnzKZNm4b58+e7Xfbnn39CLpejc+fOGDhwIFiWFRKBAeD8+fMoLCzE4MGDg91cQghpl/iKpoIyI2x2R4hbU0dI/hVRHk844deaaWsL5wU9mBk3bhz+85//4KOPPkJ2djZ27NiBl19+Gffddx8iIiKQmJiI6667DgsWLMDevXtx5MgRzJo1C0OGDMGAAQOC3VxCCGmXorQKRKjl4Dggr8S/U/StIQQz8RTM+CK23lozbUVAFs1rztSpU8EwDDZu3Ijnn38e8fHxuPvuu/Hggw8KxyxZsgTPP/88HnvsMQDAqFGjsGDBgmA3lRBC2i2GYdAhIQLHL5Yju6ganZIiQ90k2FwqmWhPJt/ERCrBMIDNzqKyxoroCGXLNwoDAQ1mNm7c2OjlU6ZMabaEW6PR4LnnnsNzzz0XqKYRQghpQWq8FscvlotmW4P8UueeTBqlDFG0J5NPZFIJYiKVKDVYUFJpbjPBTNspMieEEOJX/LYG2SLZ1iCvtG6KSWyrEocTfsPJkoq2s0cTBTOEEEIa5bqtgRhQ8q9/xNWW3belVYApmCGEENIo567UQJXRhsqahut/BVtusTOYoXyZ1hFGZtrQ7tkUzBBCCGmUUi5Fol4DQBw7aOeVOquqaE+m1omrLc8urqCRGUIIIe0AP9UU6rwZm92BonIKZvwhrg2uNUPBDCGEkCZ1qF3PJdR5MwVlJqGSid/5mfgmvnatmVKDGSzbNtaaoWCGEEJIk9JqK5pCPc2UW+J8fGceD1UytUZ0hBJSCQMHy6Gi2vcNnMWEghlCCCFN4qeZ8kprYA/hBo78KsQ0xdR6EgmDWB2fN9M2koApmCGEENKk2CgVVAop7A4OhWWh29ZAKMumYMYv2lp5NgUzhBBCmiRhmLqpptrS6FDILaGybH/ik4ApmCGEENIuhHrxPJudpUomP2trqwBTMEMIIaRZfEVTqMqzC8qcezKpqZLJb2hkhhBCSLsS6pGZPJcpJqpk8o+46La1CjAFM4QQQpqVGucMZsoMFtSYbUF//Fwh+VcT9Mduq+JrR2bKqiwhrVLzFwpmCCGENEujkgmlvKFYbyZfCGYigv7YbZVOq4BcJgHHOQOacEfBDCGEkBZ1SAhdRRONzPgfwzB1eTNtIAmYghlCCCEtSksIzbYGzkom5x/bVBqZ8avYNpQETMEMIYSQFoVqW4PCMiNYjoNaKaVKJj+Lj2o7ScAUzBBCCGmR6zQTywVvc8Jcl5V/qZLJv9rSKsAUzBBCCGlRgl4NuUwCi80R1ByLPFr5N2DqFs6jYIYQQkg7IJVIkBLLL54XvCRgYU+mWApm/I1PAC6maSZCCCHtRSiSgPNKa4OZeApm/I0PZiqrrbDZHSFuTetQMEMIIcQjHYKcBGyzsygsc44a0MiM/0Wo5VAqpADCP2+GghlCCCEeCfa2Bq6VTPpIZVAesz1hGEZYCbiUghlCCCHtAR/MFJWbYLEGflpCmGKiSqaA4ZOAiymYIYQQ0h7oNApEaRXgUFcyHUi5xZT8G2h1u2eHdxIwBTOEEEI8FsypJn5khsqyA6duSwMamSGEENJOpMXz5dlBCGZcFswjgREX3TZWAaZghhBCiMeCta2B3eFSyUTBTMDEtZH9mSiYIYQQ4rEOLtNMXAC3NSigSqag4BOAq4w2mK32ELfGdxTMEEII8VhyrBYShkGN2Y6KamvAHsd15V+qZAocjUoGrUoGILzLsymYIYQQ4jG5TILkWA2AwObNUL5M8MQK2xpQMEMIIaSdCEZFUy4FM0ETL2w4Gb5JwBTMEEII8Qpf0RTIJGDaLTt4YttAEjAFM4QQQrzCVzRlB2hkxu5gUVROlUzBEi+UZ1MwQwghpJ3gK5oKSo2w2Vm/339hmREOloNKQZVMwdAWVgGmYIYQQohX9JFKaJQyOFgO+aX+39bANV+GKpkCry2sAkzBDCGEEK8wDCMkAfP7J/kTVTIFF7/WjNFih9FsC3FrfEPBDCGEEK91CGDeDCX/BpdSIUWkRg4gfPNmKJghhBDitbSEwFU0UVl28PGjM8VhOtVEwQwhhBCv8dNM/h6Zca1kopGZ4OHzZkrDNAmYghlCCCFe4wONymorDEb/bWtAlUyhERcd3qsAUzBDCCHEayqFDAm165Pk+nGqKa/UCIAqmYKNXwU4XPdnomCGEEKIT+qmmvxX0ZRbO22VEktTTMEUJ+zPRNNMhBBC2hFhWwM/5s1QWXZoxPGrAFeYwXFciFvjPQpmCCGE+IRfCdifFU38NFNqPAUzwRSrc+YnWWwOVJvCb60ZCmYIIYT4RFg4r6QGLNv6b/N2B4vCstqcGZpmCiq5TIroCAWA8Fxrxu/BTH5+PmbNmoURI0Zg8ODBuO+++3D69Gm3Y7766itMmDAB/fr1w6RJk7B7926368vLyzF79mwMHjwYQ4YMweLFi2Eyhec8HiGEtFXx0Woo5BLY7CwKy42tvr/CchMcLAelQooYHVUyBVtcGG846ddgxmq14sEHH0RxcTHWrFmDzZs3Q6vVYvr06SgrKwMA7NmzB0899RT+/ve/47PPPsPw4cPx4IMP4uzZs8L9zJgxAxcvXsT777+P119/Hb/88gsWLVrkz6YSQghpJQnDCDto5/ghCVjIl4mlSqZQqNujKfwGD/wazBw4cACnTp3C8uXL0bdvX/To0QPLli2D0WjEjz/+CAB45513cM011+Cuu+5Ct27dMHfuXPTp0wcbNmwAABw+fBj79u3DSy+9hD59+mD48OF49tln8Z///AeFhYX+bC4hhJBW4pOAs/2QN8NXMtFieaEhrALc3kdmevTogbVr1yIxMbHuASTOhzAYDGBZFocOHcLw4cPdbjd06FDs378fgDMgio+PR7du3YTrhwwZAoZhcPDgQX82lxBCSCsJIzN+CGZc15ghwSeMzIRhebbMn3cWHx+PK6+80u2yjRs3wmw2Y8SIETAYDDAajUhKSnI7JiEhAQUFBQCAwsJCJCcnu12vUCgQHR2N/Pz8VrVPJvNvipBUKnH72Za1p74C7au/1Ne2Kxj97ZysA+BMAm7tZ2x+7TRTh8QIr++rPb22geprUowGgHPhPH//vQw0r4KZnJwcXH311U1ev3v3bsTExAi/f/fdd3jllVdw9913Iz09XQhYFAqF2+2USiUsFgsAwGQyNbi+/jG+kEgY6PWBifZ1OnVA7leM2lNfgfbVX+pr2xXI/mYonbstF1eYoFQroFHJfbofu4NFQW0lU+/u8dDrNT7dT3t6bf3d126s82dppRnR0ZqwylvyKphJTEzEjh07mrw+KipK+P9HH32EJUuWYOLEiZgzZw4AZ0ACOBOFXVksFqjVzhdFpVI1uJ4/RqPx7eQGAJblYDC0PtvelVQqgU6nhsFggsPB+vW+xaY99RVoX/2lvrZdwepvTKQSZVUWHD1VhB4don26j9ziamFPJhnHorzcu4Ti9vTaBqqvUo4FwwBWO4sL2eWIFsHeWDqd2qMRKK+CGblc7pbL0pRly5Zh3bp1uOeeezB37lwhuouOjoZGo0FRUZHb8UVFRUKeTVJSEr7//nu3661WKyoqKpCQkOBNcxuw2wNzgjscbMDuW2zaU1+B9tVf6mvbFej+piVEoKzKggsFVehSO+3krexCZ85NcqwWDgcHwLd1a9rTaxuIvsZEqlBqMKOgzIgItW+jbKHg90kxPpCZO3cu5s2b5zZMxTAMsrKysG/fPrfb7N27F4MGDQIADB48GAUFBbh48aJwPX/8wIED/d1cQgghreSPJOBcYRsD30fgSeuFa3m2X4OZvXv3Yt26dZg2bRpuuOEGFBcXC/9qapwn6j333IPt27fjvffew9mzZ/Hyyy/j+PHjmD59OgCgf//+yMrKwsyZM3HkyBHs2bMHCxcuxKRJk9yqpAghhIiDUJ7dij2a+GAmNS7CL20ivomL5jecDK/ybL9WM3355ZcAnBVMGzdudLvusccew+OPP44rrrgCzz//PN588028+uqr6N69O9asWSNMXzEMg1WrVmHx4sWYPn06lEolxo8fj/nz5/uzqYQQQvxE2NaguBocx/mUOJpPG0yKAr/WTGmYlWf7NZhZsmQJlixZ0uJxkyZNwqRJk5q8PjY2Fm+88YYfW0YIISRQkmI0kEoYmCwOlBrMwh9ET7lWMtE0U2jx00zFFeE1MhNeheSEEEJERyaVCCMqOUXeb2tQ5LInU6xO5e/mES/ER/MjMxTMEEIIaWf4JGBf8mbq9mQKr7VN2iJ+ZKbUYPbLTujBQsEMIYSQVuuQ4HtFUx7ly4hGdIQSUgkDB8uhvMr3hWqDjYIZQgghrZaWUDvN5MPITC4FM6IhkTDCVF847dFEwQwhhJBW46eZCsqMsNocXt02TyjLpmBGDPjy7JIwypuhYIYQQkirRWkViFDLwXFAXqnnScDulUwUzIhB3e7ZFMwQQghpRxiGccmb8TyYESqZ5FLEUCWTKPCl9eG0CjAFM4QQQvxC2NbAi7yZPJdtDCRUySQK4bgKMAUzhBBC/IJPAs72oqKpriybppjEIhxXAaZghhBCiF/w00zZRc5tDTzB59ekxFMwIxbxtTkzZVUW2B3hsQM5BTOEEEL8IiVWC4YBqk02GGqsHt0ml0ZmREenVUAuk4DjnAFNOKBghhBCiF8o5FIk6p17K3myErDdwaKg1FnJRGXZ4sEwTF1FU5gkAVMwQwghxG/SvKhoKq5wqWSKokomMREqmsIkCZiCGUIIIX7TId7zlYBzi50BT3IsVTKJTd1aMzQyQwghpJ1J82KPJj75l6aYxEdYBbiCRmYIIYS0Mx1q15rJK61psRKGNpgUL5pmIoQQ0m7FRqmgUkhhd3AorN2moCkUzIgXP81UTNNMhBBC2huGYYSppuYqmhws7ckkZnwwU1lthc3u3cahoUDBDCGEEL8StjVopqKpqNwEu4ODQi5BLFUyiU6EWg6lQgogPKaaKJghhBDiV55UNLluY0CVTOLDMIywEjAFM4QQQtodoaKpmWAml/JlRC+ckoApmCGEEOJXqXHOYKbMYEGN2dboMfzIDJVli1c4rQJMwQwhhBC/0qhkwh/Cptab4YOZZApmRCuOppkIIYS0Z0IScHHDJGDXSiYamRGvuGh+molGZgghhLRDQnl2IyMzVMkUHmhkhhBCSLuW1kxFkzDFRJVMosYnAFcZbTBb7SFuTfMomCGEEOJ3HWpHZnKLa8BynNt1lPwbHjQqGbQqGQDxj85QMEMIIcTvEvRqyGUSWGyOBtUwVJYdPmLDZKqJghlCCCF+J5VIhGAlu95KwHkltI1BuIjn15oReXk2BTOEEEICokN8w8XznJVMNDITLmhkhhBCSLsmrATsUtFUXGEWKpniqJJJ9OKjw2MVYApmCCGEBAS/R5Pr7tm5xVTJFE7CZRVgCmYIIYQERGrtyExxuUko7c0rcQY2KbE0xRQOwmWtGQpmCCGEBIROo0CUVgEOdRVMeaW1K//GUzATDvi1ZowWO4xN7LMlBhTMEEIICZj6eTP8NBONzIQHpUKKSI0cgLhHZyiYIYQQEjAdXPZoct2TKYVGZsIGPzpTXEHBDCGEkHYoLaF2W4Oi6tpKJhYKGVUyhZP4aOdrVSriDScpmCGEEBIwaS5rzVAlU3ji15oppmkmQggh7VFyrBZSCYMasx1/XSgDQIvlhZtwWAWYghlCCCEBI5dJkBSrAQAcOFEEAEiJ04SyScRLQnm2gUZmCCGEtFP8VFO1yVnamxoXEcrmEC/F8asAV5jB1dsBXSwomCGEEBJQafUql2hkJrzE6pQAAIvNIQSkYkPBDCGEkIDqkFA3EuOsZFKHsDXEW3KZFNERCgDiXWuGghlCCCEBxU8zAUBSrAYSCVUyhRt+qqlYpEnAFMwQQggJKH2kElqVDACQSpVMYYlPAi6lkRlCCCHtEcMwwugMlWWHJ2EVYJEGMzJ/32F+fj6WLVuGvXv3wmq1ol+/fpg3bx569OghHDN27FhcvHjR7XY33XQTXnzxRQBAeXk5nnvuOezcuRMMw+C6667DnDlzoFbTPCshhISjvw3rBJlMgsszkkPdFOKDut2zxTnN5Ndgxmq14sEHH0R0dDTWrFkDlUqFlStXYvr06fjyyy8RExMDo9GI7OxsvP322+jTp49wW5WqbmnrGTNmwGQy4f3334fBYMDTTz8No9GIl156yZ/NJYQQEiT9usWiX7fYUDeD+CieD2ZEuj+TX4OZAwcO4NSpU9i5cycSExMBAMuWLcPQoUPx448/4pZbbsGZM2fAsiwyMzMRFRXV4D4OHz6Mffv2YceOHejWrRsA4Nlnn8X999+PWbNmCfdLCCGEkOAQ1pqpNIPlONFtR+HXnJkePXpg7dq1bgGHROJ8CIPBAAA4efIk4uLiGg1kAGdAFB8fLwQyADBkyBAwDIODBw/6s7mEEEII8YA+UgmGAewOFoYaa6ib04BfR2bi4+Nx5ZVXul22ceNGmM1mjBgxAoAzmNFoNJgxYwYOHToEvV6Pm2++GXfddRckEgkKCwuRnOw+p6pQKBAdHY38/PxWtU8m82++s1QqcfvZlrWnvgLtq7/U17arPfWX+hpYMpkEsToVSirNKK+yCCM1YuFVMJOTk4Orr766yet3796NmJgY4ffvvvsOr7zyCu6++26kp6cDAE6fPg2DwYBx48bh0UcfxcGDB7Fs2TJUVlbiiSeegMlkgkKhaHDfSqUSFovFm+a6kUgY6PWByaLX6cT1ogZSe+or0L76S31tu9pTf6mvgZMUp0VJpRlGOxewv6e+8iqYSUxMxI4dO5q83nXq6KOPPsKSJUswceJEzJkzR7j8nXfegcViQWRkJAAgPT0d1dXVeOutt/D4449DpVLBam04hGWxWKDR+L4ENstyMBiMPt++MVKpBDqdGgaDCQ4H69f7Fpv21FegffWX+tp2taf+Ul8DT691DjRczK1AeRd9UB5Tp1N7NALlVTAjl8vdclmasmzZMqxbtw733HMP5s6dC8YlUUihUDQYeenZsyeMRiMqKyuRlJSE77//3u16q9WKiooKJCQkeNPcBuz2wLzoDgcbsPsWm/bUV6B99Zf62na1p/5SXwMnRuesaCoqN4ruOfb7hBsfyMydOxfz5s1zC2Q4jsM111yDVatWud3mzz//RHx8PPR6PQYPHoyCggK3dWj27dsHABg4cKC/m0sIIYQQD/BrzRSLsDzbrwnAe/fuxbp16zBt2jTccMMNKC4uFq7TaDTQarW49tprsX79enTt2hUZGRnYvXs31q1bh6effhoA0L9/f2RlZWHmzJlYtGgRjEYjFi5ciEmTJlFZNiGEEBIi8UJ5tvgWzvNrMPPll18CcFYwbdy40e26xx57DI8//jhmz56NiIgIrFixAgUFBUhLS8PTTz+N2267DYBz2etVq1Zh8eLFmD59OpRKJcaPH4/58+f7s6mEEEII8QI/MlNmsIBlOVFtGMpwHMeFuhHB4HCwKCur8et9ymQS6PValJfXiG7+0N/aU1+B9tVf6mvb1Z76S30NPJbl8NDyn+FgOSx7+HLERqlavlErxcRoPUoAbvsF+YQQQghpNYmEQaxOnHs0UTBDCCGEEI/ERfPBjLiSgCmYIYQQQohH4qKcScDFFTQyQwghhJAwxCcBl9LIDCGEEELCET/NVEzBDCGEEELCET/NVEoJwIQQQggJR/H8WjNVFthFtAcWBTOEEEII8YhOq4BcJgHHOQMasaBghhBCCCEeYRhGSAIuEVFFEwUzhBBCCPEYnzcjprVmKJghhBBCiMeEkRkRJQFTMEMIIYQQjwmrAFfQyAwhhBBCwhBNMxFCCCEkrPHTTMU0zUQIIYSQcBQf7RyZqay2wmpzhLg1ThTMEEIIIcRjWpUMSoUUAFBqEMdUEwUzhBBCCPEYwzDCSsBiyZuhYIYQQgghXhFbEjAFM4QQQgjxithWAaZghhBCCCFeqatoopEZQgghhIShuNqKplKRlGdTMEMIIYQQrwgjMyJZBZiCGUIIIYR4hU8ArjbZYLbaQ9waCmYIIYQQ4iWNSgatSgZAHBVNFMwQQgghxGuxIlprhoIZQgghhHgtnl9rRgTl2RTMEEIIIcRrcdE0MkMIIYSQMCamVYApmCGEEEKI18S0CjAFM4QQQgjxWhwlABNCCCEknPHTTEaLHUazLaRtoWCGEEIIIV5TKqSI1MgBhH4lYApmCCGEEOITsSQBUzBDCCGEEJ/EC+XZoU0CpmCGEEIIIT4RyyrAFMwQQgghxCdiWQWYghlCCCGE+EQozzbQyAwhhBBCwlBcND8yYwbHcSFrBwUzhBBCCPFJrE4FhVwCB8vCwYYumJGF7JEJIYQQEtbkMglm3tofNgcLmTR04yMUzBBCCCHEZ+kd9aFuAk0zEUIIISS8UTBDCCGEkLBGwQwhhBBCwhoFM4QQQggJaxTMEEIIISSsUTBDCCGEkLDm92Dm0qVLePjhhzFo0CAMGjQIs2bNQmFhodsxu3fvxuTJk9G/f3+MHz8e27dvd7veYrFg8eLFGD58ODIzMzF79myUlZX5u6mEEEIIaQP8GsxYrVbcfffdYFkWmzdvxsaNG1FUVIR//OMfwjLHZ8+exUMPPYSRI0di27ZtuPXWWzFnzhzs3r1buJ9Fixbh119/xcqVK7FhwwacO3cOM2bM8GdTCSGEENJG+HXRvPz8fPTt2xfPPPMMYmJiAAB33303Hn30UZSXlyMmJgYbNmxAeno6Zs6cCQDo1q0bjh07hnXr1mH48OEoLCzE559/jjVr1mDQoEEAgBUrVmD8+PE4fPgwMjMz/dlkQgghhIQ5v47MdOrUCa+//roQyOTl5eGjjz5Cnz59oNc7Vwg8cOAAhg8f7na7YcOG4eDBg+A4DgcPHhQu43Xp0gWJiYnYv3+/P5tLCCGEkDYgYNsZ3Hvvvdi1axeioqKwYcMGMAwDACgoKEBSUpLbsQkJCTCZTCgvL0dhYSH0ej2USmWDYwoKClrVJpnMvylC0tp9KKQh3I8iWNpTX4H21V/qa9vVnvpLfW3fvApmcnJycPXVVzd5/e7du4VRmaeeegpPPPEEVq9ejbvvvhuff/45kpOTYTaboVAo3G7H/261WmEymRpcDwBKpRIWi8Wb5rqRSBjo9Vqfb98cnU4dkPsVo/bUV6B99Zf62na1p/5SX9snr4KZxMRE7Nixo8nro6KihP9fdtllAIDXXnsNo0ePxqefforHHnsMSqUSVqvV7Xb872q1GiqVqsH1gLPCSa32/YVjWQ4Gg9Hn2zdGKpVAp1PDYDDB4WD9et9i0576CrSv/lJf26721F/qa9uk06k9GoHyKpiRy+Xo1q1bk9fn5+fjjz/+wPjx44XLNBoN0tLSUFRUBABITk4W/s8rKiqCRqNBZGQkkpKSUFFRAavV6jZCU1RUhMTERG+a60YiYQIWxWq1ypYPaiPaU1+B9tVf6mvb1Z76S31tWyQSxqPj/Jozc+LECTzxxBP46quv0LVrVwCAwWDA+fPnMXHiRADAoEGDsG/fPrfb7dmzB1lZWZBIJBg4cCBYlsXBgweFROHz58+jsLAQgwcP9rltDMNAKvXsSfFWe5q3bE99BdpXf6mvbVd76i/1tX3y6zMxYsQI9OrVC3PnzsXRo0fx119/YcaMGdDr9bj55psBANOmTcORI0ewfPlynD17Fu+++y6+/vpr3H///QCcU1nXXXcdFixYgL179+LIkSOYNWsWhgwZggEDBvizuYQQQghpAxiOX83OT4qKivDSSy9h165dsFqtuOKKKzB//nwkJycLx+zcuRPLli3DhQsXkJaWhscffxwTJkwQrjcajXj++efxzTffAABGjRqFBQsWCOXdhBBCCCE8vwczhBBCCCHBRBNuhBBCCAlrFMwQQgghJKxRMEMIIYSQsEbBDCGEEELCGgUzhBBCCAlrFMwQQgghJKxRMEMIIYSQsEbBDCGEEELCGgUzhBBCCAlrFMwQQgghJKxRMNMMlmXxxhtvYOTIkRgwYAAeeOABZGdnN3l8eXk5Zs+ejcGDB2PIkCFYvHgxTCZTEFvsu4qKCixcuBCjRo1CVlYW7rjjDhw4cKDJ49966y2kp6c3+BcuCgsLG23/tm3bGj0+XF/bvXv3NtrP9PR0XH311Y3e5uDBg40ev3fv3iC33jtvv/02pk2b5nbZ8ePHMXXqVAwYMABjxozBBx980OL9fPXVV5gwYQL69euHSZMmYffu3YFqcqs01t8ff/wRN998MzIzMzFmzBi89NJLMJvNTd6Hw+FAv379GrzWK1euDHTzvdJYXxcsWNCg3WPGjGn2fsLhta3f12nTpjX5Hv7888+bvJ977rmnwfH1n8M2hSNNWrlyJTd06FDup59+4o4fP87de++93NixYzmLxdLo8VOnTuVuvvlm7ujRo9xvv/3GjR49mpszZ06QW+2be+65h7v++uu5/fv3c+fOneMWL17M9evXjzt79myjxz/xxBPcU089xRUVFbn9Cxc///wz17dvX66wsNCt/SaTqdHjw/W1tVgsDV6jb7/9lktPT+e2bt3a6G0+/PBD7pprrmlwu6bOezHYtGkT16tXL27q1KnCZWVlZdzQoUO5+fPnc2fOnOG2bt3K9e3bt8l+cxzH7d69m+vTpw+3YcMG7syZM9yLL77IZWRkcGfOnAlGNzzWWH/379/PXXbZZdxbb73FnT9/nvv555+5UaNGcfPmzWvyfs6cOcP17NmTO378uNtrXV1dHYxueKSxvnIcx91yyy3cihUr3NpdWlra5P2Ew2vbWF/Ly8vd+lhYWMjdeeed3HXXXdfs6zR8+HBu8+bNbrctLy8PQi9Cg4KZJlgsFi4zM5P78MMPhcsqKyu5fv36cV988UWD4w8dOsT17NnT7Y3xv//9j0tPT+cKCgqC0mZfXbhwgevZsyd34MAB4TKWZblrrrmGe+211xq9zd/+9jfuvffeC1IL/W/t2rXcDTfc4NGx4fza1ldTU8ONHj262T9wzzzzDPePf/wjiK3yXUFBAffQQw9xAwYM4MaPH+/2R2DNmjXcFVdcwdlsNuGyV155hRs7dmyT93fvvfdyTzzxhNtlt99+O/evf/3L7233RXP9nT17Nnf33Xe7Hf/ZZ59xffr0aTIQ3b59O5eVlRXQNvuqub6yLMsNGDCA+/bbbz2+PzG/ts31tb6NGzdyGRkZTX7R5DiOKykp4Xr27Mn99ddfgWiuKNE0UxNOnDiBmpoaDB8+XLhMp9Ohd+/e2L9/f4PjDxw4gPj4eHTr1k24bMiQIWAYBgcPHgxKm32l1+uxdu1a9O3bV7iMYRgwDAODwdDgeKvVigsXLqBr167BbKZfnTx50u21ak44v7b1rVmzBiaTCXPnzm3yGG+em1D766+/IJfL8d///hf9+/d3u+7AgQMYMmQIZDKZcNmwYcNw4cIFlJSUNLgvlmVx6NAht/c8AAwdOrTR93woNNffe++9t8HrKpFIYLPZUF1d3ej9ifm1bq6vly5dgtFo9PgzSOyvbXN9dVVWVobXXnsNDz/8cLN9P3nyJBiGQZcuXQLRXFGStXxI+1RQUAAASE5Odrs8ISFBuM5VYWFhg2MVCgWio6ORn58fuIb6gU6nw5VXXul22TfffIOLFy/in//8Z4Pjz5w5A4fDgW+++QZLly6FxWLB4MGD8dRTTyEhISFYzW6VU6dOQa/XY8qUKTh//jw6deqEhx9+GKNGjWpwbDi/tq7Kysrw/vvvY/bs2YiOjm7yuNOnT0Ov12Py5MkoLCxEz549MXPmTPTr1y94jfXQmDFjmsyTKCgoQM+ePd0u48/P/Px8xMXFuV1nMBhgNBqRlJTU4DaNvedDobn+9u7d2+13m82G999/HxkZGYiJiWn0NqdOnYLdbsd9992HEydOIDExEdOnT8eNN97o97Z7q7m+njp1CgCwceNG7Ny5ExKJBKNGjcLMmTMRGRnZ4Hixv7bN9dXVO++8A5VKhfvuu6/Z406dOoXIyEg8++yz2LVrFzQaDcaPH49HHnkECoXCX80WFRqZaQKf3Fn/hVcqlbBYLI0e39hJ0tTxYnbo0CHMnz8fY8eOxVVXXdXgev6DRK1W4/XXX8fSpUtx7tw53HXXXc0mG4qF3W7HuXPnUFlZiccffxxr167FgAED8OCDDzaaENhWXtvNmzcjMjISt99+e5PH5Ofno6qqCkajEQsWLMCbb76JuLg4TJ06FWfOnAlia1vPbDY3+v4F0Ojrxp+7nr7nxcxut2POnDk4ffo0nnnmmSaPO336NCoqKjBt2jSsX78e48aNw/z587F169YgttZ7p06dgkQiQUJCAtasWYN58+bh119/xSOPPAKWZRsc3xZe2+rqanz88ce47777hPO4KadOnYLFYkG/fv2wbt06PPzww/jkk0+wYMGCILU2+GhkpgkqlQqAc0qF/z/g/BBUq9WNHm+1WhtcbrFYoNFoAtdQP/v+++/xf//3f8jKysLy5csbPWbSpEkYNWqU27e9Hj16YNSoUfjxxx8xYcKEYDXXJzKZDHv37oVUKhVe24yMDJw+fRrr169vMBTdVl7bzz//HJMmTXI7n+tLTk7G/v37oVarIZfLAQB9+/bFsWPHsHHjRixevDhYzW21xl43/g9XY68b/weisds09p4Xq+rqajz55JPYt28fVq1a1eyI2pdffgmHwwGtVgsA6NWrF/Ly8rB+/XrccsstwWqy1x5++GHceeed0Ov1AICePXsiPj4et912G/78888GUzVt4bX9/vvvYbVacfPNN7d47LPPPou5c+ciKioKgPP5kcvlmDlzJubMmdNgVLItoJGZJvDTCkVFRW6XFxUVITExscHxSUlJDY61Wq2oqKgIm6mXTZs24fHHH8fo0aOxZs2aZqP/+sPWCQkJiI6OFsWQrSe0Wm2DP+o9evRAYWFhg2Pbwmt74sQJZGdn44YbbmjxWJ1OJwQygDPvolu3bo0+N2LW2OvG/97Yezg6Ohoajcbj97wYFRUVYcqUKfj999+xfv36BtPH9alUKiGQ4fXs2VP072OJRCIEMrwePXoAQKNtbwuv7ffff48rr7wSOp2uxWNlMpkQyPCae37aAgpmmtCrVy9ERES4ra1hMBhw7NgxDB48uMHxgwcPRkFBAS5evChctm/fPgDAwIEDA9/gVtq8eTOWLFmCKVOmYMWKFc3Oq7766qsYN24cOI4TLsvJyUF5eTm6d+8ejOa2yunTp5GVldVg3ZSjR4822v5wf20BZzJsbGwsevXq1exxO3fuRGZmptt6Sna7HSdOnAiL19bV4MGDcfDgQTgcDuGyPXv2oEuXLoiNjW1wPMMwyMrKEl5b3t69ezFo0KCAt7e1KisrMX36dJSVleHDDz9s9HPKlcFgwJAhQxqsrfTnn38Kf/jEas6cObj77rvdLvvzzz8BoNHzNNxfW8D5Hq4/atyUadOmYf78+W6X/fnnn5DL5ejcuXMAWhd6FMw0QaFQYOrUqVi+fDl++OEHnDhxAjNnzkRSUhLGjh0Lh8OB4uJiYS62f//+yMrKwsyZM3HkyBHs2bMHCxcuxKRJk0Qf+Z8/fx7PP/88rr32Wjz00EMoKSlBcXExiouLUVVVBavViuLiYmGI9tprr0Vubi4WLVqE8+fPY//+/Xj88ceRlZWFkSNHhrg3LevWrRu6du2KZ599FgcOHMDZs2fxwgsv4Pfff8fDDz/cpl5b3rFjx5pc1LC4uBg1NTXA/7d3/zFVlv8fx5+EhxlhgBA2s8bagjbPQXBxgPAHUI0Sm4WbtIDIAsslhj/WgWSl02EDlEACS4JGlqs0Fw3+SXOwNIc2Z1nkQtPAHwQKCCYVcH3+YJ7JB/x+Px818Xz2emznj3Pf1839vq/7HHhxXfd9DjB9+nR8fX1xOBwcOXKEo0eP4nA46OrqGvHH41Y3f/58ent7WbVqFc3NzXz++ed88MEHvPTSS842PT09nD9/3vl84cKF1NbWUlVVxbFjx8jPz6epqYm0tLSxOIT/yvr162lpaaGgoICJEyc638Pt7e3OQNfV1UVXVxcwNAIXGRlJUVER9fX1nDhxgvfee4+amhoyMzPH8Ej+f/Hx8Xz77beUlpby22+/UV9fz+uvv87cuXOdd2f9L53bM2fO0NnZedV/Ri5evEh7e7vzeXx8PF988QXbtm2jpaWFuro68vPzefHFF/Hy8rpZZd9cY31v+K2sv7/f5Ofnm8jISBMaGmoyMjJMS0uLMcaYlpYWExQUZHbs2OFs39HRYTIzM01oaKiJiIgwb775punr6xur8v9j5eXlJigoaNSHw+Ew+/fvN0FBQWb//v3Obfbt22eSkpJMaGiosdvtJicnx3R1dY3hUfx32tvbTXZ2tomOjjY2m80kJSWZAwcOGGP+t87tZenp6SYrK2vUdUFBQaakpMT5/OTJkyYzM9PY7XYzbdo088ILL5ijR4/erFKvmcPhGPH5HIcPHzYLFiwwVqvVxMbGmg8//HDENrGxscOW7dy50zz22GPGZrOZp59+2uzbt+8fr/1aXHm8/f39xmazXfV9fPn3VkpKyrA+6unpMXl5eWb27NnGarWaefPmma+++mpMjuf/Mtq5raurM0899ZQJCQkx0dHR5q233hr2nnTVc3u11/G/f9bVlUpKSkxQUNCwZVu3bjVPPPGE87VfXl5uBgYG/rG6x5qbMVfMFYiIiIi4GE0ziYiIiEtTmBERERGXpjAjIiIiLk1hRkRERFyawoyIiIi4NIUZERERcWkKMyIiIuLSFGZERETEpSnMiIhLaG1tJTg4eMR3CV2L7Oxs4uLibkBVInIrGDfWBYiI/CcCAgL45JNPuO+++8a6FBG5xSjMiIhL8PDwIDQ0dKzLEJFbkKaZROSG+Oyzz0hISMBqtRITE8OmTZuc39acnZ1Namoq27dvJzY2lrCwMNLS0vj555+d2w8ODlJUVERcXBxWq5W4uDg2bNjA33//DYw+zXTixAmWLl1KdHQ0oaGhpKam8t133w2rq7u7m5ycHOx2O+Hh4RQUFDA4ODii/l27dpGYmIjNZiM6Opp169bxxx9/ONf39fWxevVqZs2ahdVq5fHHH+f999+/oX0oItdGIzMict3effddioqKSElJIScnh6amJjZt2sSZM2fIy8sDoKmpiePHj7N8+XK8vb0pKSkhJSWFuro6AgIC2LJlC9u2bcPhcHDvvfdy+PBhioqKsFgsLF26dMQ+m5ubWbBgAYGBgeTm5mKxWKiuriYtLY3KykrsdjuDg4Okp6dz6tQpHA4HPj4+VFRU8MMPPxAQEOD8WV9++SUrV67kySefJCsri1OnTlFUVERzczNVVVW4ubmRl5fHN998g8PhwN/fn4aGBvLz8/Hx8WH+/Pk3ra9FZCSFGRG5Lj09PZSVlZGUlERubi4AM2bMwMfHh9zcXBYuXOhst3nzZh566CEAQkJCePTRR6murmblypU0NjZitVqdwcBut3P77bczYcKEUfdbWlqKh4cH1dXVeHl5ARATE8PcuXPJz89n+/btNDQ08P3337NlyxZmzZoFQFRU1LCLf40xFBYWMnPmTAoLC53LAwMDef7556mvrycmJobGxkaio6NJSEgAICIiAk9PT/z8/G5kd4rINdA0k4hcl0OHDtHX10dcXBz9/f3Ox+XAsHfvXgCmTJniDDIwdEFvWFgYBw4cAIbCwd69e3n22WepqKigubmZlJQU5s2bN+p+GxsbiY2NdQYZgHHjxpGQkMCRI0e4ePEiBw8exGKxMHPmTGcbT09PZs+e7Xx+/Phxzp49O6L+8PBwvLy8nPVHRETw6aefkpGRwdatW2lpaeGVV14hJibmxnSkiFwzjcyIyHXp6uoCYNGiRaOu//333wGYNGnSiHV+fn78+OOPAKSnp3PHHXewY8cOCgsLKSgo4IEHHiA3N5fIyMgR23Z3d+Pv7z9iub+/P8YYent76e7uxsfHBzc3t2Ft7rrrrhH1r1mzhjVr1ly1/lWrVnH33XdTU1PD2rVrWbt2LWFhYaxevZoHH3xw1GMXkZtDYUZErsudd94JQGFhIYGBgSPW+/v7U1xcTGdn54h1HR0dzmma2267jeTkZJKTkzl37hz19fVs3ryZzMxM5+jIlby9veno6BixvL29HQBfX198fX3p7OxkYGAAd3d3Z5vLAebK+l977TXsdvuo+4Ghu6kWL17M4sWLOX36NHv27KGsrIwVK1ZQW1t7te4RkZtA00wicl2mTZuGxWKhra0Nm83mfIwbN46NGzfS2toKDN15dOzYMed2bW1tHDp0iKioKACeeeYZ1q1bBwyN2CQmJpKcnMyFCxfo7e0dsd/w8HD27NkzbN3AwAC1tbXYbDY8PDyIioqiv7+fXbt2Odv89ddfw8LR/fffj5+fH62trcPqnzRpEhs2bOCnn36ir6+P+Ph4KisrAZg8eTLJyckkJCRw+vTpG9ibInItNDIjItfF19eX9PR0iouL6e3tJSIigra2NoqLi3Fzc3NOwRhjePnll1m2bBnu7u6Ulpbi7e1NamoqMBROKisr8ff3JywsjLa2NqqqqrDb7UycOHHYbdIAS5YsoaGhgeeee45FixZhsVic17JUVFQAQxf7zpgxg9zcXM6dO8c999xDdXU158+fd44Iubu7s2zZMt544w3c3d2JjY3lwoULlJWV0dbWxtSpUxk/fjxTp06ltLQUi8VCcHAwv/76Kzt37iQ+Pv4m9raIjMbNGGPGuggRcX0fffQRH3/8MSdPnsTb25uoqCiWL1/O5MmTyc7OprGxkYyMDN555x0uXbrEww8/jMPhYMqUKQD09/dTXl5OTU0NZ8+eZcKECcTFxbFixQp8fX1pbW3lkUceYf369SQmJgJDt3tv3LiRgwcP4ubmRkhICEuWLBl2ofGlS5coLCyktraWP//8kzlz5uDp6cnu3bv5+uuvne3q6uqoqKjgl19+wdPTk+nTp5OVlUVwcDAAvb29vP322+zevZv29nb8/PyYM2cOr776KuPHj7+JPS0i/05hRkT+cZfDzJXhQUTkRtE1MyIiIuLSFGZERETEpWmaSURERFyaRmZERETEpSnMiIiIiEtTmBERERGXpjAjIiIiLk1hRkRERFyawoyIiIi4NIUZERERcWkKMyIiIuLS/gVm3uHj07uzGwAAAABJRU5ErkJggg==",
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# 获取参数\n",
"cfg = get_args() \n",
"# 训练\n",
"env, agent = env_agent_config(cfg)\n",
"res_dic = train(cfg, env, agent)\n",
" \n",
"plot_rewards(res_dic['rewards'], cfg, tag=\"train\") \n",
"# 测试\n",
"res_dic = test(cfg, env, agent)\n",
"plot_rewards(res_dic['rewards'], cfg, tag=\"test\") # 画出结果"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3.7.13 ('parl')",
"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.13"
},
"orig_nbformat": 4,
"vscode": {
"interpreter": {
"hash": "29c8e495d55843cb894bac6655c13e4a65f834e86169d4dce1750654c48fe628"
}
}
},
"nbformat": 4,
"nbformat_minor": 2
}