notebooks/po_lunar_lander.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Lunar Lander : train an agent to land (safely) on the moon.\"\"\"\n",
    "\n",
    "import json\n",
    "from pprint import pprint\n",
    "from typing import NamedTuple\n",
    "\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "from dotenv import dotenv_values\n",
    "from stable_baselines3.common.env_util import VecEnv, make_vec_env\n",
    "from stable_baselines3.common.evaluation import evaluate_policy\n",
    "from stable_baselines3.common.monitor import Monitor\n",
    "from torch import Tensor\n",
    "from torch.optim import AdamW\n",
    "\n",
    "from r2seedo.io import load_keypair, load_n_verify_model, sign_n_save_model\n",
    "from r2seedo.models.simple_policy_net import (\n",
    "    SimplePolicyNet,\n",
    "    compute_loss,\n",
    "    get_reward_to_go_weights,\n",
    ")\n",
    "from r2seedo.utils.environment import capture_replay"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How Gymnasium Works\n",
    "\n",
    "- We create our environment using `gym.make()`\n",
    "- We reset the environment to its initial state with `env.reset()`\n",
    "\n",
    "Then, at each step\n",
    "- Get an action using our model\n",
    "- Using `env.step(action)`, we perform this action in the environment and get:\n",
    "    - `observation` : The new state (st+1)\n",
    "    - `reward` : The reward we get after executing the action\n",
    "    - `terminated` : Indicates if the episode terminated (agent reach the terminal state)\n",
    "    - `truncated` : Indicates a time limit or if an agent go out of bounds of the environment\n",
    "    - `info` : A dictionary that provides additional information (depends on the environment)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Observation Space Shape (8,)\n",
      "Sample observation: \n",
      "{'x': -0.9211345,\n",
      " 'y': -0.94538844,\n",
      " 'x_velocity': -4.2603164,\n",
      " 'y_velocity': -1.254043,\n",
      " 'angle': -2.1278644,\n",
      " 'angular_velocity': 4.855233,\n",
      " 'left_leg_contact': 0.6755799,\n",
      " 'right_leg_contact': 0.4546319}\n",
      "\n",
      "Action Space Shape 4\n",
      "Step  0 : Fire left orientation engine\n",
      "Step  1 : Fire left orientation engine\n",
      "Step  2 : Fire left orientation engine\n",
      "Step  3 : Fire left orientation engine\n",
      "Step  4 : Fire main engine\n",
      "Step  5 : Fire right orientation engine\n",
      "Step  6 : Fire main engine\n",
      "Step  7 : Fire right orientation engine\n",
      "Step  8 : Do nothing\n",
      "Step  9 : Fire main engine\n",
      "Step 10 : Fire left orientation engine\n",
      "Step 11 : Fire left orientation engine\n",
      "Step 12 : Fire left orientation engine\n",
      "Step 13 : Fire main engine\n",
      "Step 14 : Fire main engine\n",
      "Step 15 : Fire right orientation engine\n",
      "Step 16 : Fire left orientation engine\n",
      "Step 17 : Fire left orientation engine\n",
      "Step 18 : Fire main engine\n",
      "Step 19 : Fire left orientation engine\n"
     ]
    }
   ],
   "source": [
    "# First, we create our environment called LunarLander-v2\n",
    "env = gym.make(\"LunarLander-v2\")\n",
    "\n",
    "# Then we reset this environment\n",
    "observation, info = env.reset()\n",
    "\n",
    "# see what the Environment looks like\n",
    "# The observation is a vector of size 8\n",
    "# each value contains different information about the lander\n",
    "print(\"Observation Space Shape\", env.observation_space.shape)\n",
    "\n",
    "# Get a random observation\n",
    "observations = env.observation_space.sample()\n",
    "obs_fields = [\n",
    "    \"x\",\n",
    "    \"y\",\n",
    "    \"x_velocity\",\n",
    "    \"y_velocity\",\n",
    "    \"angle\",\n",
    "    \"angular_velocity\",\n",
    "    \"left_leg_contact\",\n",
    "    \"right_leg_contact\",\n",
    "]\n",
    "print(\"Sample observation: \")\n",
    "pprint(\n",
    "    dict(zip(obs_fields, env.observation_space.sample(), strict=True)), sort_dicts=False\n",
    ")\n",
    "\n",
    "# The action space is a discrete space of 4 possible actions\n",
    "print(\"\\nAction Space Shape\", env.action_space.n)\n",
    "actions = [\n",
    "    \"Do nothing\",\n",
    "    \"Fire left orientation engine\",\n",
    "    \"Fire main engine\",\n",
    "    \"Fire right orientation engine\",\n",
    "]\n",
    "for i in range(20):\n",
    "    # Get a random action\n",
    "    action = env.action_space.sample()\n",
    "\n",
    "    # Perform the action\n",
    "    print(f\"Step {i:>2} : {actions[action]}\")\n",
    "    observation, reward, terminated, truncated, info = env.step(action)\n",
    "\n",
    "    # If the game is terminated (in our case we land, crashed) or truncated (timeout)\n",
    "    if terminated or truncated:\n",
    "        # Reset the environment\n",
    "        print(\"Environment is reset\")\n",
    "        observation, info = env.reset()\n",
    "\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reward function\n",
    "\n",
    "After every step a reward is granted. The total reward of an episode is the sum of the rewards for all the steps within that episode.\n",
    "\n",
    "For each step, the reward:\n",
    "- Is increased/decreased the closer/further the lander is to the landing pad.\n",
    "- Is increased/decreased the slower/faster the lander is moving.\n",
    "- Is decreased the more the lander is tilted (angle not horizontal).\n",
    "- Is increased by 10 points for each leg that is in contact with the ground.\n",
    "- Is decreased by 0.03 points each frame a side engine is firing.\n",
    "- Is decreased by 0.3 points each frame the main engine is firing.\n",
    "- The episode receive an additional reward of -100 or +100 points for crashing or landing safely respectively.\n",
    "\n",
    "An episode is considered a solution if it scores at least 200 points."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectorized Environment\n",
    "We create a vectorized environment (stack multiple independent environments into a single environment), this way, we’ll have more diverse experiences during training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Observations shape: torch.Size([64, 10, 8])\n",
      "Actions shape: torch.Size([64, 10])\n",
      "Rewards shape: torch.Size([64, 10])\n"
     ]
    }
   ],
   "source": [
    "n_envs = 10\n",
    "vec_env = make_vec_env(\"LunarLander-v2\", n_envs=n_envs)\n",
    "\n",
    "observations = []\n",
    "actions = []\n",
    "rewards = []\n",
    "\n",
    "# Restart the environment and get initial observation\n",
    "observations.append(vec_env.reset())\n",
    "while True:\n",
    "    # Sample random actions\n",
    "    acts_i = torch.randint(0, 4, (n_envs,)).numpy()\n",
    "    actions.append(acts_i)\n",
    "\n",
    "    # Perform the actions\n",
    "    next_obs, rewards_i, done_i, info = vec_env.step(acts_i)\n",
    "    rewards.append(rewards_i)\n",
    "\n",
    "    if done_i.any():\n",
    "        break\n",
    "\n",
    "    observations.append(next_obs)\n",
    "\n",
    "observations = torch.from_numpy(np.array(observations))\n",
    "actions = torch.from_numpy(np.array(actions))\n",
    "rewards = torch.from_numpy(np.array(rewards))\n",
    "\n",
    "vec_env.close()\n",
    "\n",
    "print(\"Observations shape:\", observations.shape)\n",
    "print(\"Actions shape:\", actions.shape)\n",
    "print(\"Rewards shape:\", rewards.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple Policy Network\n",
    "\n",
    "Lessons learned:\n",
    "1. Training with a vectorized environment helps stabilize learning\n",
    "    - Without multiple environments to average observation-action decision over, the learning\n",
    "    signal is very noisy and the agent struggles to learn\n",
    "    - 20+ \"parallel\" environments seems to make the difference\n",
    "    - 60 - 120 parallel environments were even better\n",
    "2. Normalizing the observation vector significantly improves learning\n",
    "    - Using a batch of random episodes to calculate a starting mean, std for each environment\n",
    "    variable and then allowing the model to learn these parameters was a big improvement\n",
    "    - Conversely, Using a `BatchNorm` layer over a full episode was destructive\n",
    "3. Switching from a densely connected feed-forward network to a parallel sub-policy network\n",
    "was an improvement\n",
    "    - Each sub-policy can independently learn a simple action rule\n",
    "    - Then, a policy selector can pick and choose which rule to apply\n",
    "    - This seems to make learning easier and more robust than trying to coordinate a \n",
    "    set of fully connected weights\n",
    "4. Getting the actor to learn to land, rather than hover just over the landing site is\n",
    "very difficult\n",
    "    - The reward difference between landing (+100) and crashing (-100) is a high variance\n",
    "    proposition\n",
    "    - The actor seems to favor the lower variance actions of hovering over the landing site\n",
    "    - Trying to augment the rewards during training (e.g. dropping out some of penalties \n",
    "    for crashing) to improve exploration, did not seem to help\n",
    "5. Training runs were fairly unpredictable\n",
    "    - Sometimes the model would learn quickly and then cycle into catastrophic forgetting towards \n",
    "    the end of the run\n",
    "    - Other runs, the model would learn slowly and the peak at mid run\n",
    "    - And sometimes the model would tank early on and never recover\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Policy Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SimplePolicyNet(\n",
       "  (parallel_sub_policies): ParallelMLP(\n",
       "    (blocks): Sequential(\n",
       "      (0): Sequential(\n",
       "        (0): Conv2d(32, 64, kernel_size=(1, 1), stride=(1, 1), groups=4)\n",
       "        (1): GroupNorm(4, 64, eps=1e-05, affine=True)\n",
       "        (2): ELU(alpha=1.0)\n",
       "      )\n",
       "      (1): Sequential(\n",
       "        (0): Conv2d(64, 16, kernel_size=(1, 1), stride=(1, 1), groups=4)\n",
       "        (1): GroupNorm(4, 16, eps=1e-05, affine=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (policy_selector): Sequential(\n",
       "    (0): Linear(in_features=8, out_features=8, bias=True)\n",
       "    (1): ELU(alpha=1.0)\n",
       "    (2): Linear(in_features=8, out_features=4, bias=True)\n",
       "    (3): Softmax(dim=-1)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a policy network\n",
    "model = SimplePolicyNet(\n",
    "    obs_dim=vec_env.observation_space.shape[0],\n",
    "    act_dim=vec_env.action_space.n,\n",
    "    hidden_dim=16,\n",
    "    num_sub_policies=4,\n",
    "    depth=2,\n",
    ")\n",
    "\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mean_reward=-291.05 +/- 69.16226743562059\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "eval_env = Monitor(gym.make(\"LunarLander-v2\"))\n",
    "mean_reward, std_reward = evaluate_policy(\n",
    "    model, eval_env, n_eval_episodes=10, deterministic=True\n",
    ")\n",
    "print(f\"mean_reward={mean_reward:.2f} +/- {std_reward}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Observations shape: torch.Size([64, 10, 8])\n",
      "Actions shape: torch.Size([64, 10])\n",
      "Action counts: (array([0, 1, 2, 3]), array([158, 230, 139, 113]))\n",
      "Action distribution: Categorical(logits: torch.Size([64, 10, 4]))\n",
      "Action log-probability shape: torch.Size([64, 10])\n"
     ]
    }
   ],
   "source": [
    "# Test model on a batch of observations\n",
    "print(f\"Observations shape: {observations.shape}\")\n",
    "\n",
    "# Get a sample of actions | observations\n",
    "actions = model.get_action(observations)\n",
    "print(f\"Actions shape: {actions.shape}\")\n",
    "print(\"Action counts:\", np.unique(actions.flatten().numpy(), return_counts=True))\n",
    "\n",
    "# Get the action distribution\n",
    "action_dist = model.get_policy(observations)\n",
    "print(f\"Action distribution: {action_dist}\")\n",
    "\n",
    "# Get the log probability of the actions taken\n",
    "logp: Tensor = action_dist.log_prob(value=actions)\n",
    "print(f\"Action log-probability shape: {logp.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Policy gradient loss: -47.88704299926758\n"
     ]
    }
   ],
   "source": [
    "# Compute the reward-to-go weights\n",
    "weights = get_reward_to_go_weights(rewards)\n",
    "\n",
    "# Compute the policy gradient loss\n",
    "loss = compute_loss(model, observations, actions, weights)\n",
    "print(f\"Policy gradient loss: {loss}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train the policy network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EpisodeData(NamedTuple):\n",
    "    \"\"\"Sequence of observations, actions, and rewards from an episode.\n",
    "\n",
    "    Attributes\n",
    "    ----------\n",
    "    num_steps: np.ndarray[n_envs, dtype=int64]\n",
    "        Number of steps in the episode for each environment.\n",
    "    observations: Tensor[n_steps, n_envs, obs_dim, dtype=float32]\n",
    "        Sequence of observations from the episode.\n",
    "    actions: Tensor[n_steps, n_envs, dtype=int64]\n",
    "        Sequence of actions from the episode.\n",
    "    rewards: Tensor[n_steps, n_envs, dtype=float32]\n",
    "        Sequence of rewards from the episode.\n",
    "    \"\"\"\n",
    "\n",
    "    num_steps: np.ndarray\n",
    "    observations: Tensor\n",
    "    actions: Tensor\n",
    "    rewards: Tensor\n",
    "\n",
    "\n",
    "class EpisodeSummary(NamedTuple):\n",
    "    \"\"\"Summary of an episode.\n",
    "\n",
    "    Attributes\n",
    "    ----------\n",
    "    num_steps: np.ndarray\n",
    "        Number of steps in the episode for each environment.\n",
    "    total_rewards: np.ndarray\n",
    "        Total rewards for each environment in the episode.\n",
    "    action_frequency: np.ndarray\n",
    "        Frequency each action was taken in the episode.\n",
    "    result_frequency: dict[str, int]\n",
    "        Frequency of each result in the episode.\n",
    "    \"\"\"\n",
    "\n",
    "    num_steps: np.ndarray\n",
    "    total_rewards: np.ndarray\n",
    "    action_frequency: np.ndarray\n",
    "    result_frequency: dict[str, int]\n",
    "\n",
    "\n",
    "def collect_episode_data(\n",
    "    env: VecEnv,\n",
    "    model: SimplePolicyNet | None,\n",
    "    max_steps: int | None,\n",
    "    device: torch.device,\n",
    ") -> EpisodeData:\n",
    "    \"\"\"Collect observations, actions, and rewards over an episode.\"\"\"\n",
    "    # Reset environment and get initial observation\n",
    "    obs = env.reset()\n",
    "\n",
    "    # Collect observations, actions, and rewards over the episode\n",
    "    num_steps = np.zeros(env.num_envs)\n",
    "    completed = np.zeros(env.num_envs, dtype=bool)\n",
    "    observations = []\n",
    "    actions = []\n",
    "    rewards = []\n",
    "    while not completed.all():\n",
    "        num_steps[~completed] += 1\n",
    "\n",
    "        # Convert observation to tensor and move to device\n",
    "        obs = torch.from_numpy(obs).to(device)\n",
    "        observations.append(obs)\n",
    "\n",
    "        if model is None:\n",
    "            # sample random actions\n",
    "            act = torch.randint(\n",
    "                low=0,\n",
    "                high=vec_env.action_space.n,\n",
    "                size=(vec_env.num_envs,),\n",
    "                dtype=torch.int64,\n",
    "                device=device,\n",
    "            )\n",
    "        else:\n",
    "            # get actions given observations\n",
    "            act = model.get_action(obs)\n",
    "        actions.append(act)\n",
    "\n",
    "        # Perform the actions\n",
    "        obs, reward, done, _ = env.step(act.cpu().numpy())\n",
    "\n",
    "        # Zero out rewards for completed environments\n",
    "        reward[completed] = 0\n",
    "\n",
    "        # Store the rewards\n",
    "        rewards.append(torch.from_numpy(reward).to(device))\n",
    "\n",
    "        # Update the completed environments\n",
    "        completed = np.logical_or(completed, done)\n",
    "\n",
    "        if max_steps is not None and num_steps.max() >= max_steps:\n",
    "            break\n",
    "\n",
    "    # Stack episode steps together into a batch\n",
    "    return EpisodeData(\n",
    "        num_steps=num_steps,\n",
    "        observations=torch.stack(observations, dim=0),\n",
    "        actions=torch.stack(actions, dim=0),\n",
    "        rewards=torch.stack(rewards, dim=0),\n",
    "    )\n",
    "\n",
    "\n",
    "def train_for_one_episode(\n",
    "    env: VecEnv,\n",
    "    model: SimplePolicyNet,\n",
    "    optimizer: torch.optim.Optimizer,\n",
    "    *,\n",
    "    max_steps: int = 300,\n",
    "    device: torch.device | None = None,\n",
    ") -> EpisodeSummary:\n",
    "    \"\"\"Train the policy network for one episode.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    env: VecEnv\n",
    "        The environment\n",
    "    model: SimplePolicyNet\n",
    "        The policy network\n",
    "    optimizer: torch.optim.Optimizer\n",
    "        The optimizer\n",
    "    device: torch.device, optional\n",
    "        The device to run the training on.\n",
    "        (default = \"cpu\")\n",
    "    max_steps: int, optional\n",
    "        Maximum number of steps to run the episode.\n",
    "        (default = 300)\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    EpisodeSummary\n",
    "        Summary of the episode.\n",
    "    \"\"\"\n",
    "    if device is None:\n",
    "        device = torch.device(\"cpu\")\n",
    "\n",
    "    # Collect episode data\n",
    "    episode_data = collect_episode_data(env, model, max_steps, device)\n",
    "\n",
    "    # Compute the reward-to-go weights\n",
    "    weights = get_reward_to_go_weights(episode_data.rewards)\n",
    "\n",
    "    # Optimize the policy network\n",
    "    optimizer.zero_grad()\n",
    "    loss = compute_loss(model, episode_data.observations, episode_data.actions, weights)\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "\n",
    "    # Compute action counts\n",
    "    action_counts = np.unique(episode_data.actions.cpu().numpy(), return_counts=True)[1]\n",
    "\n",
    "    # Compute result frequency\n",
    "    min_rewards = episode_data.rewards.min(0).values.cpu().numpy()\n",
    "    crashed = min_rewards == -100  # noqa: PLR2004\n",
    "    timed_out = (episode_data.num_steps == max_steps) & ~crashed\n",
    "    landed = ~(crashed | timed_out)\n",
    "    result_freq = {\n",
    "        \"crashed\": crashed.sum() / env.num_envs,\n",
    "        \"timed_out\": timed_out.sum() / env.num_envs,\n",
    "        \"landed\": landed.sum() / env.num_envs,\n",
    "    }\n",
    "\n",
    "    # Return the episode summary\n",
    "    return EpisodeSummary(\n",
    "        num_steps=episode_data.num_steps,\n",
    "        total_rewards=episode_data.rewards.sum(0).cpu().numpy(),\n",
    "        action_frequency=action_counts / action_counts.sum(),\n",
    "        result_frequency=result_freq,\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cuda\n"
     ]
    }
   ],
   "source": [
    "n_envs = 128  # Number of parallel environments\n",
    "num_episodes = 300  # Number of episodes to train for\n",
    "max_steps = 300  # Maximum number of steps per episode\n",
    "save_freq = 30  # Frequency to save model\n",
    "\n",
    "# Initialize vectorized environment\n",
    "vec_env = make_vec_env(\"LunarLander-v2\", n_envs=n_envs)\n",
    "\n",
    "# Collect episode data from a random policy\n",
    "episode_data = collect_episode_data(\n",
    "    env=vec_env, model=None, max_steps=100, device=torch.device(\"cpu\")\n",
    ")\n",
    "\n",
    "# Create a policy network\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "simple_model = SimplePolicyNet(\n",
    "    obs_dim=vec_env.observation_space.shape[0],\n",
    "    act_dim=vec_env.action_space.n,\n",
    "    hidden_dim=16,\n",
    "    num_sub_policies=256,\n",
    "    depth=3,\n",
    "    # Initialize with mean and std of observations from random policy episode\n",
    "    obs_mean=episode_data.observations.mean(dim=(0, 1)),\n",
    "    obs_std=episode_data.observations.std(dim=(0, 1)),\n",
    ")\n",
    "simple_model.to(device)\n",
    "\n",
    "# Create an optimizer\n",
    "init_learning_rate = 2e-3\n",
    "learning_rate_schedule = np.linspace(init_learning_rate, 1e-4, num=num_episodes)\n",
    "optimizer = AdamW(simple_model.parameters(), lr=init_learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 30 | avg steps: 103 | avg reward:  -71.4 | crashed:  91%, timed_out:   9%, landed:   0%\n",
      " 60 | avg steps: 239 | avg reward:   64.8 | crashed:  13%, timed_out:  87%, landed:   0%\n",
      " 90 | avg steps: 293 | avg reward:  124.0 | crashed:   2%, timed_out:  98%, landed:   0%\n",
      "120 | avg steps: 294 | avg reward:  137.4 | crashed:   2%, timed_out:  98%, landed:   0%\n",
      "150 | avg steps: 294 | avg reward:  140.0 | crashed:   4%, timed_out:  96%, landed:   0%\n",
      "180 | avg steps: 296 | avg reward:  147.0 | crashed:   5%, timed_out:  95%, landed:   0%\n",
      "210 | avg steps: 295 | avg reward:  146.9 | crashed:   2%, timed_out:  98%, landed:   0%\n",
      "240 | avg steps: 297 | avg reward:  151.8 | crashed:   2%, timed_out:  98%, landed:   0%\n",
      "270 | avg steps: 296 | avg reward:  155.2 | crashed:   0%, timed_out:  99%, landed:   1%\n",
      "300 | avg steps: 299 | avg reward:  158.7 | crashed:   0%, timed_out: 100%, landed:   0%\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9oAAAF2CAYAAACRVuD7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAACjMUlEQVR4nOzdd3hT5dsH8G+SNulM994DKGVToBTZIGXIkPEDB4IiqICKOBAHggv3QgTxVUAEARUHKHuPsimbQumC7p3OtEnO+0eaQ0NboNA2tP1+riuXyVl5EmrOuc/9PPcjEQRBABERERERERHVCampG0BERERERETUlDDQJiIiIiIiIqpDDLSJiIiIiIiI6hADbSIiIiIiIqI6xECbiIiIiIiIqA4x0CYiIiIiIiKqQwy0iYiIiIiIiOoQA20iIiIiIiKiOsRAm4iIiIiIiKgOMdAmuo/s2bMHEokEv//+u6mbckfS09MxduxYODk5QSKR4KuvvjJ1k4iIiKgeTJ48Gf7+/qZuhkn07dsXffv2NXUzqJFhoE3NzooVKyCRSGBhYYHk5OQq6/v27Yu2bduaoGWNz0svvYStW7di7ty5WLVqFQYPHnzXx7pw4QLmz5+PhISEumsgERE1Gt999x0kEgnCw8NN3ZT7zocffoi//vrrrvfnOZao4THQpmZLrVbjo48+MnUzGrVdu3Zh5MiReOWVV/D4448jJCTkro914cIFLFiwgBcBRETN1OrVq+Hv74+jR48iNjbW1M25r9RFoM1zLFHDYqBNzVbHjh3xww8/ICUlxdRNaXBFRUV1cpyMjAzY29vXybGIiKj5io+Px6FDh/DFF1/AxcUFq1evbvA26HQ6lJaWNvj7NnWCIKCkpMTUzbilurouIqqMgTY1W2+88Qa0Wu1ts9oJCQmQSCRYsWJFlXUSiQTz588XX8+fPx8SiQSXL1/G448/Djs7O7i4uODtt9+GIAi4du0aRo4cCaVSCXd3d3z++efVvqdWq8Ubb7wBd3d3WFtbY8SIEbh27VqV7Y4cOYLBgwfDzs4OVlZW6NOnDw4ePGi0jaFNFy5cwKOPPgoHBwf07Nnzlp85Li4O48aNg6OjI6ysrNC9e3f8+++/4npD93tBELB48WJIJBJIJJJbHnPt2rUICwuDra0tlEol2rVrh6+//lo83rhx4wAA/fr1E4+3Z88ecf/NmzejV69esLa2hq2tLYYNG4bz588bvcfkyZNhY2ODuLg4REZGwtraGp6ennj33XchCMIdt4eIiBrW6tWr4eDggGHDhmHs2LFGgXZ5eTkcHR3x5JNPVtlPpVLBwsICr7zyirhMrVbjnXfeQXBwMBQKBXx8fPDaa69BrVYb7SuRSDBz5kysXr0abdq0gUKhwJYtWwAAn332GXr06AEnJydYWloiLCys2vopJSUleOGFF+Ds7AxbW1uMGDECycnJVa4PACA5ORlPPfUU3NzcoFAo0KZNG/z000+3/W4kEgmKioqwcuVK8fw4efJkcf2pU6cwZMgQKJVK2NjYYMCAATh8+LC4/nbn2L///hvDhg2Dp6cnFAoFgoKC8N5770Gr1d62bdXx9/fHQw89hK1bt6JLly6wtLTE999/DwDIy8vDrFmz4OPjA4VCgeDgYHz88cfQ6XTi/p07d8bo0aONjtmuXTtIJBKcOXNGXLZu3TpIJBJcvHgRAJCYmIjp06ejVatWsLS0hJOTE8aNG1cli2+4htm7dy+mT58OV1dXeHt7i+uXLVuGoKAgWFpaolu3bti/f3+1n3PRokVo06YNrKys4ODggC5dumDNmjV39Z1R02Rm6gYQmUpAQACeeOIJ/PDDD3j99dfh6elZZ8ceP348WrdujY8++gj//vsv3n//fTg6OuL7779H//798fHHH2P16tV45ZVX0LVrV/Tu3dto/w8++AASiQRz5sxBRkYGvvrqKwwcOBDR0dGwtLQEoO+2PWTIEISFheGdd96BVCrF8uXL0b9/f+zfvx/dunUzOua4cePQokULfPjhh1WCzsrS09PRo0cPFBcX44UXXoCTkxNWrlyJESNG4Pfff8fDDz+M3r17Y9WqVZg4cSIefPBBPPHEE7f8PrZv345HHnkEAwYMwMcffwwAuHjxIg4ePIgXX3wRvXv3xgsvvIBvvvkGb7zxBlq3bg0A4n9XrVqFSZMmITIyEh9//DGKi4uxZMkS9OzZE6dOnTIqzqLVajF48GB0794dn3zyCbZs2YJ33nkHGo0G77777h21h4iIGtbq1asxevRoyOVyPPLII1iyZAmOHTuGrl27wtzcHA8//DA2bNiA77//HnK5XNzvr7/+glqtxoQJEwDos9IjRozAgQMHMG3aNLRu3Rpnz57Fl19+icuXL1fpfr1r1y6sX78eM2fOhLOzs3g++frrrzFixAg89thjKCsrw9q1azFu3Dhs2rQJw4YNE/efPHky1q9fj4kTJ6J79+7Yu3ev0XqD9PR0dO/eXQzuXVxcsHnzZkyZMgUqlQqzZs2q8btZtWoVnn76aXTr1g3Tpk0DAAQFBQEAzp8/j169ekGpVOK1116Dubk5vv/+e/Tt2xd79+5FeHj4bc+xK1asgI2NDWbPng0bGxvs2rUL8+bNg0qlwqefflq7f8gKMTExeOSRR/DMM89g6tSpaNWqFYqLi9GnTx8kJyfjmWeega+vLw4dOoS5c+ciNTVVLKjaq1cv/Prrr+KxcnJycP78eUilUuzfvx/t27cHAOzfvx8uLi7i5zh27BgOHTqECRMmwNvbGwkJCViyZAn69u2LCxcuwMrKyqiN06dPh4uLC+bNmydmtH/88Uc888wz6NGjB2bNmoW4uDiMGDECjo6O8PHxEff94Ycf8MILL2Ds2LF48cUXUVpaijNnzuDIkSN49NFH7+o7oyZIIGpmli9fLgAQjh07Jly9elUwMzMTXnjhBXF9nz59hDZt2oiv4+PjBQDC8uXLqxwLgPDOO++Ir9955x0BgDBt2jRxmUajEby9vQWJRCJ89NFH4vLc3FzB0tJSmDRpkrhs9+7dAgDBy8tLUKlU4vL169cLAISvv/5aEARB0Ol0QosWLYTIyEhBp9OJ2xUXFwsBAQHCgw8+WKVNjzzyyB19P7NmzRIACPv37xeXFRQUCAEBAYK/v7+g1WqNPv+MGTNue8wXX3xRUCqVgkajqXGb3377TQAg7N6922h5QUGBYG9vL0ydOtVoeVpammBnZ2e0fNKkSQIA4fnnnxeX6XQ6YdiwYYJcLhcyMzPvuD1ERNQwjh8/LgAQtm/fLgiC/nfb29tbePHFF8Vttm7dKgAQNm7caLTv0KFDhcDAQPH1qlWrBKlUanQOEwRBWLp0qQBAOHjwoLgMgCCVSoXz589XaVNxcbHR67KyMqFt27ZC//79xWUnTpwQAAizZs0y2nby5MlVrg+mTJkieHh4CFlZWUbbTpgwQbCzs6vyfjeztrY2ul4wGDVqlCCXy4WrV6+Ky1JSUgRbW1uhd+/e4rKazrHVfVZBEIRnnnlGsLKyEkpLS8VlkyZNEvz8/G7ZTkEQBD8/PwGAsGXLFqPl7733nmBtbS1cvnzZaPnrr78uyGQyISkpyaitFy5cEARBEP755x9BoVAII0aMEMaPHy/u1759e+Hhhx++5eeIiooSAAg///yzuMxwHdizZ0+j64CysjLB1dVV6Nixo6BWq8Xly5YtEwAIffr0EZeNHDnS6FqRqDrsOk7NWmBgICZOnIhly5YhNTW1zo779NNPi89lMhm6dOkCQRAwZcoUcbm9vT1atWqFuLi4Kvs/8cQTsLW1FV+PHTsWHh4e+O+//wAA0dHRuHLlCh599FFkZ2cjKysLWVlZKCoqwoABA7Bv3z6jblgA8Oyzz95R2//77z9069bNqHu5jY0Npk2bhoSEBFy4cOHOvoRK7O3tUVRUhO3bt9d63+3btyMvLw+PPPKI+DmzsrIgk8kQHh6O3bt3V9ln5syZ4nND9qCsrAw7duy45/YQEVHdWr16Ndzc3NCvXz8A+t/t8ePHY+3atWL35f79+8PZ2Rnr1q0T98vNzcX27dsxfvx4cdlvv/2G1q1bIyQkxOic0b9/fwCocs7o06cPQkNDq7TJ0HvM8D75+fno1asXTp48KS43dDOfPn260b7PP/+80WtBEPDHH39g+PDhEATBqF2RkZHIz883Ou6d0mq12LZtG0aNGoXAwEBxuYeHBx599FEcOHAAKpXqtsep/FkLCgqQlZWFXr16obi4GJcuXap1uwB9r8HIyEijZb/99ht69eoFBwcHo+9g4MCB0Gq12LdvHwB9RhuA+Hr//v3o2rUrHnzwQbEbd15eHs6dOydue/PnKC8vR3Z2NoKDg2Fvb1/t9zt16lTIZDLx9fHjx5GRkYFnn33WqNfE5MmTYWdnZ7Svvb09rl+/jmPHjt3V90PNAwNtavbeeustaDSaOq1A7uvra/Tazs4OFhYWcHZ2rrI8Nze3yv4tWrQwei2RSBAcHCyOM7py5QoAYNKkSXBxcTF6/N///R/UajXy8/ONjhEQEHBHbU9MTESrVq2qLDd0zUpMTLyj41Q2ffp0tGzZEkOGDIG3tzeeeuop8QLldgyftX///lU+67Zt25CRkWG0vVQqNbrgAICWLVsCgPj93Ut7iIio7mi1Wqxduxb9+vVDfHw8YmNjERsbi/DwcKSnp2Pnzp0AADMzM4wZMwZ///23ONZ6w4YNKC8vNwq0r1y5gvPnz1c5XxjOAzefM2o6N27atAndu3eHhYUFHB0d4eLigiVLlhidWxMTEyGVSqscIzg42Oh1ZmYm8vLysGzZsirtMow7v7lddyIzMxPFxcU1nrN1Ol219V1udv78eTz88MOws7ODUqmEi4sLHn/8cQCoci1xp6r7Xq9cuYItW7ZU+Q4GDhwI4MZ34ObmhhYtWohB9f79+9GrVy/07t0bKSkpiIuLw8GDB6HT6YwC7ZKSEsybN08c/+3s7AwXFxfk5eVV+zlubqPh+ubmazBzc/Mq1xVz5syBjY0NunXrhhYtWmDGjBlVauQQcYw2NXuBgYF4/PHHsWzZMrz++utV1tdU5OtWRUIq3yG91TIAtxwvXRNDtvrTTz9Fx44dq93GxsbG6HXlO70NzdXVFdHR0di6dSs2b96MzZs3Y/ny5XjiiSewcuXKW+5r+KyrVq2Cu7t7lfVmZrX/GbuX9hARUd3ZtWsXUlNTsXbtWqxdu7bK+tWrV2PQoEEAgAkTJuD777/H5s2bMWrUKKxfvx4hISHo0KGDuL1Op0O7du3wxRdfVPt+lcfZAtWfG/fv348RI0agd+/e+O677+Dh4QFzc3MsX778ropdGc5jjz/+OCZNmlTtNoZxxw0tLy8Pffr0gVKpxLvvvougoCBYWFjg5MmTmDNnTpXecXequu9Vp9PhwQcfxGuvvVbtPoabIQDQs2dP7Ny5EyUlJThx4gTmzZuHtm3bwt7eHvv378fFixdhY2ODTp06ifs8//zzWL58OWbNmoWIiAjY2dlBIpFgwoQJ1X6Oe7kuat26NWJiYrBp0yZs2bIFf/zxB7777jvMmzcPCxYsuOvjUtPCQJsI+qz2L7/8IhbGqszBwQGA/mRU2d1kdu+UIYtrIAgCYmNjxROxoQiKUqkU7wTXFT8/P8TExFRZbug+5ufnd1fHlcvlGD58OIYPHw6dTofp06fj+++/x9tvv43g4OAab2gYPqurq+sdfVadToe4uDijE/bly5cBwKho2u3aQ0RE9W/16tVwdXXF4sWLq6zbsGED/vzzTyxduhSWlpbo3bs3PDw8sG7dOvTs2RO7du3Cm2++abRPUFAQTp8+jQEDBtx2Noya/PHHH7CwsMDWrVuhUCjE5cuXLzfazs/PDzqdDvHx8UZZ0JvnAHdxcYGtrS20Wu1dn7Or+ywuLi6wsrKq8ZwtlUrFGws1fRd79uxBdnY2NmzYYFSYNT4+/q7aeStBQUEoLCy8o++gV69eWL58uTh8oEePHpBKpejZs6cYaPfo0cMoifH7779j0qRJRjO6lJaWVrl+q4nh+ubKlSviUANA3w09Pj7e6IYOAFhbW2P8+PEYP348ysrKMHr0aHzwwQeYO3cuLCws7ug9qWlj13Ei6H/8H3/8cXz//fdIS0szWqdUKuHs7CyOFTL47rvv6q09P//8MwoKCsTXv//+O1JTUzFkyBAAQFhYGIKCgvDZZ5+hsLCwyv6ZmZl3/d5Dhw7F0aNHERUVJS4rKirCsmXL4O/vX+1YttvJzs42ei2VSsWbBoYugNbW1gCq3tCIjIyEUqnEhx9+iPLy8irHru6zfvvtt+JzQRDw7bffwtzcHAMGDLjj9hARUf0qKSnBhg0b8NBDD2Hs2LFVHjNnzkRBQQH++ecfAPrf6rFjx2Ljxo1YtWoVNBqNUbdxAPjf//6H5ORk/PDDD9W+353MlyyTySCRSIx6riUkJFSpWG4Yg3zz9cCiRYuqHG/MmDH4448/cO7cuSrvdyfnbGtr6yrnR5lMhkGDBuHvv/82msIqPT0da9asQc+ePaFUKsX9garnWEOgWrl3XVlZWb1c4/zvf/9DVFQUtm7dWmVdXl4eNBqN+NrQJfzjjz9G+/btxTHSvXr1ws6dO3H8+HGjbuOGz3JzL8FFixbd8TRlXbp0gYuLC5YuXYqysjJx+YoVK6p8bzdfR8jlcoSGhkIQhGqvVah5YkabqMKbb76JVatWISYmBm3atDFa9/TTT+Ojjz7C008/jS5dumDfvn1ilrQ+ODo6omfPnnjyySeRnp6Or776CsHBwZg6dSoA/cXG//3f/2HIkCFo06YNnnzySXh5eSE5ORm7d++GUqnExo0b7+q9X3/9dfz6668YMmQIXnjhBTg6OmLlypWIj4/HH3/8Aam09vfnnn76aeTk5KB///7w9vZGYmIiFi1ahI4dO4pjvzt27AiZTIaPP/4Y+fn5UCgU6N+/P1xdXbFkyRJMnDgRnTt3xoQJE+Di4oKkpCT8+++/eOCBB4wCawsLC2zZsgWTJk1CeHg4Nm/ejH///RdvvPEGXFxc7rg9RERUv/755x8UFBRgxIgR1a7v3r07XFxcsHr1ajGgHj9+PBYtWoR33nkH7dq1q/KbPXHiRKxfvx7PPvssdu/ejQceeABarRaXLl3C+vXrxbmdb2XYsGH44osvMHjwYDz66KPIyMjA4sWLERwcbDSPc1hYGMaMGYOvvvoK2dnZ4vRehuuDylnkjz76CLt370Z4eDimTp2K0NBQ5OTk4OTJk9ixYwdycnJu2aawsDDs2LEDX3zxBTw9PREQEIDw8HC8//772L59O3r27Inp06fDzMwM33//PdRqNT755BNx/5rOsT169ICDgwMmTZqEF154ARKJBKtWrbqrYW238+qrr+Kff/7BQw89hMmTJyMsLAxFRUU4e/Ysfv/9dyQkJIi1bIKDg+Hu7o6YmBij4nK9e/fGnDlzAKBKoP3QQw9h1apVsLOzQ2hoKKKiorBjxw44OTndUfvMzc3x/vvv45lnnkH//v0xfvx4xMfHY/ny5VXGaA8aNAju7u544IEH4ObmhosXL+Lbb7/FsGHDjIrZUjNnqnLnRKZSeXqvmxmmh7p5yobi4mJhypQpgp2dnWBrayv873//EzIyMmqc3sswjVTl41pbW1d5v5unEjNM7/Xrr78Kc+fOFVxdXQVLS0th2LBhQmJiYpX9T506JYwePVpwcnISFAqF4OfnJ/zvf/8Tdu7ceds23crVq1eFsWPHCvb29oKFhYXQrVs3YdOmTVW2wx1O7/X7778LgwYNElxdXQW5XC74+voKzzzzjJCammq03Q8//CAEBgYKMpmsyjQku3fvFiIjIwU7OzvBwsJCCAoKEiZPniwcP35c3MbwPV+9elUYNGiQYGVlJbi5uQnvvPOO0bRkd9oeIiKqP8OHDxcsLCyEoqKiGreZPHmyYG5uLk6LpdPpBB8fHwGA8P7771e7T1lZmfDxxx8Lbdq0ERQKheDg4CCEhYUJCxYsEPLz88XtbnUO+/HHH4UWLVoICoVCCAkJEZYvXy6eTysrKioSZsyYITg6Ogo2NjbCqFGjhJiYGAGA0ZSegiAI6enpwowZMwQfHx/B3NxccHd3FwYMGCAsW7bstt/VpUuXhN69ewuWlpYCAKOpvk6ePClERkYKNjY2gpWVldCvXz/h0KFDVY5R0zn24MGDQvfu3QVLS0vB09NTeO2118Tp1Cqfh2szvdewYcOqXVdQUCDMnTtXCA4OFuRyueDs7Cz06NFD+Oyzz4SysjKjbceNGycAENatWycuKysrE6ysrAS5XC6UlJQYbZ+bmys8+eSTgrOzs2BjYyNERkYKly5dEvz8/Iy+r1tdBwqCIHz33XdCQECAoFAohC5dugj79u0T+vTpYzS91/fffy/07t1bvP4KCgoSXn31VaO/LyKJINTDLSsiIhOYPHkyfv/992q70xMRETWE6OhodOrUCb/88gsee+wxUzeHiEyEY7SJiIiIiO5CSUlJlWVfffUVpFKpUXExImp+OEabiIiIiOgufPLJJzhx4gT69esHMzMzccrIadOmVZlKjIiaFwbaRERERER3oUePHti+fTvee+89FBYWwtfXF/Pnz68y7RgRNT8co01ERERERERUhzhGm4iIiIiIiKgOMdAmIiIiIiIiqkONMtAWBAEqlQrs9U5ERNQ08VxPRESNWaMMtAsKCmBnZ4eCggJTN4WIiIjqAc/1RETUmDXKQJuIiIiIiIjofsVAm4iIiIiIiKgOMdAmIiIiIiIiqkMMtImIiIiIiIjqEANtIiIiIiIiojrEQJuIiIiIiIioDjHQJiIiIiIiIqpDDLSJiIiIiIiI6hADbSIiIiIiIqI6VKtAe8mSJWjfvj2USiWUSiUiIiKwefNmcX1paSlmzJgBJycn2NjYYMyYMUhPTzc6RlJSEoYNGwYrKyu4urri1VdfhUajqZtPQ0RERERERGRitQq0vb298dFHH+HEiRM4fvw4+vfvj5EjR+L8+fMAgJdeegkbN27Eb7/9hr179yIlJQWjR48W99dqtRg2bBjKyspw6NAhrFy5EitWrMC8efPq9lMRERERERERmYhEEAThXg7g6OiITz/9FGPHjoWLiwvWrFmDsWPHAgAuXbqE1q1bIyoqCt27d8fmzZvx0EMPISUlBW5ubgCApUuXYs6cOcjMzIRcLr+j91SpVLCzs0N+fj6USuW9NJ+IiJopQRAgkUhM3QyqAc/1RETUmN31GG2tVou1a9eiqKgIEREROHHiBMrLyzFw4EBxm5CQEPj6+iIqKgoAEBUVhXbt2olBNgBERkZCpVKJWfHqqNVqqFQqowdRY5OSV4J7vK9FdF8pKdPiYqoKOUVlNW5TptHh56gErDyUUOXv/2RSLh794TD+tzQKP0dVXX87WYVqFKnvfujR4bgc9P98D77ddeWuj0FERET3r9JyLfp8uhsvrj11T9cMd8OstjucPXsWERERKC0thY2NDf7880+EhoYiOjoacrkc9vb2Rtu7ubkhLS0NAJCWlmYUZBvWG9bVZOHChViwYEFtm0rNhCErlZJXAmcbBeRm90+Nv4upKpjLJDgYm413/jmPqb0C8Oaw0Hp7P1VpOTJUpQh2ta2397iVgtJy7InJRLlWh76tXOFoLcehq1mYu+Es5g4JQRtPO+SXlKOtl524z/pj17D5XCpcbBWY2a8FfJ2sTNL2e3UuOR9/nkrG9L5BcLJRGK3LUJXiw/8uQicAn43rcF/9jd7Kws0XkaFS48OH28FSLjNat+lMCub8fgZFZVrIzaT4ZEx7jOrkhauZhcgqUMPdzgJp+aV4++9zuJxeCACQm0nxSDdfAEBuURme++UE0lVqAMDRhBxsPZ+GUA8lnukThPXHr+FQbDayi8pgJZch0NkaR+JzoLQ0w4onu+HzbTFYf/w6HKzMMbqzN04k5mJqrwAMbusBADhzPQ9TVh7H0z0D8EyfIABAdqEajtZyMYu9OyYDcZlFiMsqapDvk4iIqLESBAGX0wsR4Gxd5TqmpEwLnSDAWlHr0LKK2IxC7InJwOQe/jCT6d9HrdHiYGwWugc6IbNADa1OQKCLDQD9ta9cJoWFuaza40Vfy0NidjFKyrSwkle/TX2p9bfRqlUrREdHIz8/H7///jsmTZqEvXv31kfbRHPnzsXs2bPF1yqVCj4+PvX6nlQ3ErOL4Ka0qPaP/1xyPlYfScLsB1vCxVZRzd63N2P1SZy+nod5D4XimV9OYGg7Dyx+tPO9NlsUk1aA134/jdeHtEZEkFOt9j1wJQtP/HQEMqkECjP95/9hfzyCXW3wQLAzvB3qPqB8ef1p7LyYjg3TH4CdpTkcreSwszKv8/epyYf/XcSvR68BACLbuOH7iV3w2dYYJGYX45XfzkAnCCgu0+LlB1tiZv9gLNoViy+2Xxb3L9cK+HJ8xzt6r8TsImw6k4opPQPwz+kUKC3MxCCrJlvPp2Hb+XQMbeeO/iGute42XFquxet/nIG7nSVeHxJitO7djRdwNCEHuy5lYNfLfcRjJ+eVYMSiA8iuyPoODHXDiA6eAIALKSqcuZ6HsWHeMJNJ8fL600hTleDHSV1rPGHUJENViv87EI+newXA1daiVvtWJyatAN/vjQMAFJRq8MKAYMRnFSHY1QaxGYV4cW00AMBKLkNxmRaz1kXjQqoKyw/Go1xrnJm2MJeitFyHBRvPIyLQCTKpBLPXRyNdpUagizVGdfTCVzsu42BsNg7GZmPtsWsoKDW+63wiMVd8PnzRAaTmlwIAsgrLsGxfnLjN8/2DMfvBllgVlYjMAjUWbr4EPydrxGcV4eMtlzAo1A0fjm4HZxsFdl7UF+vsH+J6z98XERFRY5VVqMaSPVcxuK07uvo7AtAH1rsuZaCVuy2cbRSY88cZ/B2dgqceCICFuRQHY7PwwxNdIDeTYvi3B1BSpsNfM3rU6vr2//bH4XBcNj7/X0fYWeqvV9/882zFjXVzRF3Nho+jFVLzSvDbiesIcLZGQnYRrOVmOPLGAOSXlGPoN/sBAK9GtsKgUHdM+ukoHurggel9gwEAh+OyAQDdA50afLhYrQNtuVyO4GB9w8PCwnDs2DF8/fXXGD9+PMrKypCXl2eU1U5PT4e7uzsAwN3dHUePHjU6nqEquWGb6igUCigUdxeIkemsPpKIN/88h0Ghblj2RBejdTlFZXho0QEAgL2VOeYMDqnuELdUWq7Fv2dTAQDTVp0AAPx7JhUz+qoQ6lk34/nWHkvC6ev5+PFA/G0D7UK1BonZRfqMGSSY+etJ6ARApxVQrtVAJpVAqxMw54+zUJhJsWVWbwQ4W9dJOwFAqxNwMDYLOgH4bncsdl3KQJCLDTa90BPmsht3HgVBQGaBGpAAztYKSKV196Nz6Gq2+Hz/lSxEX8vDyaQ8APrvx+Dz7ZcRn12EDSeTAQDD2nvg3zOp2HkxHeVanVF7q6PR6tDn0z0A9AHmyqhEmEklOPGW8y1vLCz45zxS8kvxx8nrGBvmjU/GtK/V55//z3n8FZ0CAHiovQdOJeVieAdP2FvJcTQhBwAQn1WE9cevYXxXfeb2u92xYpANAG/9eRYnE3MxNswbM9acRGJ2Mf49m4p3R7bFHyevAwA2nUlFkVqD/iGuiLqajUNXs/DBw+1grTDD6Wt5KFJr0CPY2ahtX+64gl+PJqG0XIt3R7a9489Uk3XHronPd1xMx46KoNRKLoN9xcnw8e6+eGd4G3zw70WsOJQgBrwOVuYoKdeiXCtgbGdvzBkSgumrT+BwXA6W7r2KbRfSkVNUBktzGb6Z0AltvezQt5ULjsbnYPHuWOQWl0MiAV6LDEFrD1uoSjW4mKrCqaRcHI7LEYPspY93RtTVbJxPUcHf2Rq/n7iORbtiUVKmxfFKgfkrv52GVqcP/rddSMeuSxno4GOPq5lFMJNK0KuFyz1/X0RERI3V23+dw+ZzaVgVlYj3R7XF6M5e2HAqGa/9fgYutgoEOFvjaLz+OuePk9eRX1IOAHhxbTQcrM1xLadEfP3r1O6Qm0lRpNYgo0ANWwszrDt2DS3dbDEgxNXouuv9fy8CAOb9fQ4PtfdEKzdbnKq4bvzpQDwupRUYtTO+ogdaoVqDKxmF+PdMCvKK9W15889zOBKXgwupKlxIVWFMZ2+4KS3EQDs80LGevr2a3XN+X6fTQa1WIywsDObm5ti5cyfGjBkDAIiJiUFSUhIiIiIAABEREfjggw+QkZEBV1d9BmH79u1QKpUIDa2/7rTU8A7FZmHe3/px99supCMmrQCt3G90Z37773Pi8+MVAUptxWYUVrv8062X8NGY9nC0luODfy+irZcdxoZ539N7RF/Lu2XhpGs5xRjy9X4UqjWwNJdhdGcv5BWXI9RDCYW5FGeu52PZxDDsuJiOnRczkFGgxpfbL+ObRzrVqj3nU/Lx2u9n8Naw0CqBf3xWEYrLtAD03zkAxKQXYO2xa5jY3U/c7o0/z4pZZ4WZVAz2c4rK8MMTXXAmOR+2CjOM6uR1y7ZsO5+Gk0l5eGFAMKzkZsgtKkNidjEAwEwqQXGZFi+tiwYAdPN3RHpBKUI9lAj1UOLz7ZfFIPt/XbyxcHR7HInLRlZhGY7G5+CBm4LID/+7iE2nU/D7cz3gaW+J9cevi+tWRiUCADQ6AQevZmFoO+OsdkZBKRb8cwF9W7kgpSJAA4DfT1yHnaU5RnTwxN/RKXi2TyBclTVngg9cycLaSsHnhGWHUajW4O/oFPw4uavRtvP+Po89MZk4dDVbPBl9+2gnzFxzCqpSDVYcSsCmMynIKtQH4PuvZOHplcfE/V//4ww0OgHrj1/D1cxClJbr0MbTDqM7e2HCssMo0+qw55W+8HG8cdf4WMX/RyeTcnGnNFodMgrU8LS3NFqerirFn6f03/HkHv44m5yP+KwiaHUC8kvKUVymhZO1HG8ODYW5TIq3HwpFbEYhDsRmwcPOAlte7A2lpRk0OkG8afJouB8Ox+WI32GAszV+nNRF7PrV3tse7b3t0S3AER9vuYRxYT5Gf4MjOniiXKtD/8/34FpOCcaFeWNwWw+jXgwdfOzx9l/n8H8H4sVlIe62Rifq9t52OHM9X8yQh/k5iHfRiYiI7mdanYCfoxLQ2dcBHXzs7/l42YVq/HcuDZvP6Yfwlml1eO2PM/h65xUUl+kTJJkFan2CpoLhugYAoiqCWDOpBBbmMpxIzMXwRQfw/cQwzN1wFlFx2ZBIAEMJlnZedvhyfEcEu9ogt1IS4u/oFPwdre+dWKbVAUCVINvbwRKdfB2w8bQ+4XEqKVe8njXYcu7GUOSxSw9hygMBOBynvz7qHli7nql1oVaB9ty5czFkyBD4+vqioKAAa9aswZ49e7B161bY2dlhypQpmD17NhwdHaFUKvH8888jIiIC3bt3BwAMGjQIoaGhmDhxIj755BOkpaXhrbfewowZM5ixbkIEQcB7/16EVifA0lyGknIt/m9/HD4d1wGA/kdi+4Ub86tfySi8q+q/l9ON/wc0dGHdHZOJAZ/vxdRegVhxKAHWchke7uQF2R1kLss0OvywPw79Wrki1FOJqxWBdlahGsl5JVW6w2w9n4at59Ig4EbGtqRci9VHkgAAj3f3w9gwb2QV6oOZAa3dcD4lH8O+OYB/Tqfgub5BaO1x59n3dceu4XyKCisPJVQJtM+n5Fe7z9c7LuPhTl6wUZhBEATxxxQA1Bqd0Q/Zq7+fxuX0QkglQK8WzlXGGhv8ejQJczec1X/eMg26BTghTaUPYgOdrdHGyw4bT6eIdx5fG9wKYX4OkEj0Wf0dlzJw+loeLMyleHlQK8ikEgxs7Ya1x67hjxPX0S3AUQzQBEHAumPXkF9Sjn/PpOKpngH4euflatu1JyajSqC9eFcs/j2bis3n9L0fQtxt8VzfILy4Nho/HojH+mPXUKDW4GhCNtY/EwErefU/i4euZhm9Nvx7H0/Mxcw1JwHoe2d08rHH7phMo++5W4AjHmrviYOxWeJJwRBkG1zNvDFOWFORfT2fcqPw46rDiShQa1BSrr+ZsvNiOiY/EABAf5PEcFPoYmoBSsq0VcZUV+f9ikz0hw+3w6Ph+gz8tvNpmL76JDQ6Ae5KC7z9UKj4/875lHwMX3QAOgF4qmeA+B4yqQSLHumEZfvjMKKDp9irwFx24/+5/iGukMuk4gn06V4BYpBdWXtve6x+unu17TWXSbHokc7YfC4VM/oFV1k/sbsfLqWqxP//OvrYY9EjnTD06/0oUGuw9PHOGNzWA/suZ+KJn/S9qwa0ZrdxIiJTOhSbBWuFWZ0EjnXleEIOTl/Px1MP+N9Xs1OsP34NCzZeQKCzNXa90veujyMIAsq0Ogz9Zr9YK+WRbr7wsLPAykMJSM7TZ6gDnK1RUqZFUZkGK57sivn/XMDZZOPrTXelBV6JbAVXWwVmrYtGTHoBXv39NI4l5Fa8l/7a63puCc4m668jlk4Mg61F1estVWnNxcreG9kW/UJcYW9pjlWHE/HtrlgUqjVo4WqDkR098dm2y+I1BgBcyynB/I0XAOivzwLrsBfpnapVoJ2RkYEnnngCqampsLOzQ/v27bF161Y8+OCDAIAvv/wSUqkUY8aMgVqtRmRkJL777jtxf5lMhk2bNuG5555DREQErK2tMWnSJLz77rt1+6nIpPZezsTFVBWs5TJ8+1hnPLn8GP44eR3tve0wMcIfKXklKNPoIJEAUokEecXluJZTUusiWDE3BdoPtfdA75Yu+GL7ZcRlFonBWFGZFjFpBXfUnfyzbTFYti8OP+yPw8E5/Y0yoKev5VcJtN/88xyyCm/c5RvS1t0owBrQ2hVyM6lRxrCNpx0Ghbph24V0bDmXVqtA+0pFUambf+QA46AM0N9d9LC3wLWcEny5/TLclRZo6W6LvOJymEklODs/EhkFpYjNKMTZ5Hx8teOKWLRKJwD7rmTi4U5VewJkFJTi7b9u9EhYGZUoZpUBfVYxItBJvOM4sLUbuvjf6K4jk0rw8Zh2ePHXaDze3RduFVnkyLbuWHvsGjacSkZUXDb6hbhix4V0DO/gKd493XclE+287ZCuUhvdITVYf/w6ApxtYGthhrXHkpBbVC6eLCpiV3T0scfIjl44Gp+D1UeSUFARMJ9LVuHD/y7i/VHtjI457efjSM0vhU1FgY9XBrXEVzuuQKMTEORijauZRdh/RR+Et3S1xVcTOmH66hOQSaXo09IFp5JyMWtgCwD6k8SzfYLw+bbL+Kfi+3lvZBt8vCVGDNwNN4wM/zVIyinGd7tjxde7YjIxoZuveAfZQKsTcDY5HxkFpfg5KhGfjGkP/xpOLisOJQDQ93JYtOsKWrnbIjWvFBqdgA7edpg/oo3RDao2nnZ4+6FQHE/IxaQe/kbHcrCW33IIiI3CDL1aOGPnpQxYmsvEceq11dHHHh1vcTH2woAWYqDdwdsOPo5WWPtMd8RlFiGyjX6IUu+WLljzdDi2nE/Do+F+NR6LiIjqXm5RGcq0OrgpLfSzT/zfEViay3Bm/qDbDh1rCIIg4MW10UjOK4G/kxUGtHa7/U4V4rOKsOVcGqb0DKh14dPKSafkvBIcjM3CyI6e+GbnFXg7WGF8Fx/8WNFjKy6rCNdyio16tt2p/86mYs7vZ/BgqBvSVfqu3ePCfDB7UEvYKMwwrXcgfo5KwK5LGXhjaGsEu9pAJ+jP490CHMVr0E/Gtkefli5wsbkxDHHlk90w/NsDYpDt62iFX6aEw8fREpkFasxaF41DV7Mx9efjGNNZ32vN38kKwzt4ikMObzZ/eCjclBboV1FPJdhVf5PeMCxvVCcvdPK1N9qni58Disq0SMsvQW5xOfq1qn1dnrpQq0D7xx9/vOV6CwsLLF68GIsXL65xGz8/P/z333+1eVu6j3276wpKy3WY/WBLSKUSXEhRieMtHg33Rb9Wrni8uy9+OZyEt/8+j7ZedmLQ1MLVBpbmMpy+no/RSw5iYGs3zOgXfMsfDUEQUK4VIDeT4nJFJnZwG3dkF6kxrXcQgl1tYGdpjok/HhUDK0DfndbZVo43/zyHMZ29qhTNev2PM7iYVoCz1/MAAHnF5biaadw1fcaakziRGIDXh4RAbiZFSZnWKMgOdrXBhw+3w/YL6dDoBLTzshODyJt1C3DEtgvpuJCqwotrT8FKboYPH25b7Y+AIAhYcSgBSgtzxFa0KTmvBDlFZYjPKsSGk8mY/WBLnKv44bNRmKGwYgzvhK4+mL76pPjDrKj40W/pZgtLuQx+Ttbwc7JG/xBXbDmXZpTd3n2p+kD7UGw2NDoBrT2UaOlmg78rxiwbdPC2Q6+WzmIg/Oaw1lWOEeKuxNaXehst69vSBXMGh+DHA/FIzS/Fmopg6cdK3YCPxufA007f5XxsZ2+cSMpFXEUm2PB+H2+5VO13bmAI0l4fEoJ9VzKRW1SOlwe1xIKNF/Db8esY1dEL6So1hrZzR3JeidgN36B7oBMe716GHRfT8eOkrhi7NEr8OwhytYadpflNGdkA8ZmZTAo/J2tM6OaDf06nQCoBhrbzwKmkPGw4pf9ca6Z2x8nEXHT2c8Do7w7CWq7vxr/qcCI0OgF2lubILynHvsuZCHl7C14a2FLs3mVwIjEXvxxORHJeCRZsPI/lT3ar8j2UlmuNblak5peKY58VZlL8PCW82i7VTz4QgCcfCKiy/E6M6+KDnZcyML6rD2wt6qe7tpvSAgtGtMHPUQl4qqe+nW087dDG085oux7BzlXGuRMRUf0qLddixOIDyCsqx7bZvfH1Dv30iiXlWhyJy8GlNBVGdvS66yK5dSEhu1i8Sb/pTCpWH0lCv1YumBjhf9t9H/xiLzQ6AWZSCab2Drzj99x8NhVz/jiD14e0xqPhvnh5fTQOx+VgxcEEXEjVJ1KUFuZGwyb/b38cnGwUmNor8I56sRl8uf0yCtQa8brj8e5+RjfKLcxlmNY7CNN6B1XZt1uAo3hd1iPIqcp1blsvJVxsFWJX854tnMVEmqvSAiue7Ibpq09ix8V0sYdfRJATXh7UCj2DnTF+2WEAgK2FGQpKNZBK9NcOlauZt3A17g33QLAzgl1tIJXokyrONgr89mwEJBIJ8kvKsflsKvqbqPfavddgp2Yru1CNz7bps8YSif6O0sPfHYRao4O9lTme7qX/gXlvZFsk5ZRg3+VMscABAAQ628DZVo7T1/ORVViGtceuYePpFGyZ1bvGYPv1P85i45kULH6ss5h9ndIrQKyQCAA9gpyN/icH9IH21vNp2H8lC9svpCPho2HiusTsIqOxtwaGog+V/XQwHl4OlpjSM8Aoo97aQ4nXIlvBwVqOvq1csONiBgaF1nwH1JDF3huTKXZzeenBFtVWi15zNAkLKrq+VPbd7lhxLKqNwkwMtN8f1Ra/nbiG2Q+2RAdvO3TytRe/d7VG/15tvYyz6BKJBGPDvPH+vxehtDCDqlSDfVcyUVymwUvrotHV3xHjuvjgRGIO9l3JBAD0buGMlx5sKVbvfuHXUwCAjr4O8LCzxC9TwmFhLr3jgm8SiQTP9Q3Ckw/4Y+WhBOy8mCEWGDNQa3RYd1z/bzW0nQc0OgFxmUWwVZjhkXBf/HHiOsL8HJBfUo5QTyV2XsxAUk6x0TjdjhV3PW0tzPHvC71QrtHB0VqOP05ex7lkFcYujQIA/DIlHOmqUtyslbstuvg7Yv6INgCAASGuYpuCqukKXZ2IQCe8GtkKLjYKONkoMCbMGxtOJaO9t51RxnbttAjYKMwQ5GqNni2ckZJXgl4tnDH++8PindzVRxLFHhOGz/ntrisoqsiG747JxPrj1zCig6dRJfMr6YUQBH337hf6t0ByXon4/8FD7T3rZdzy4Lbu2PtqX3jdNCa8rk3q4V8l4061s2/fPnz66ac4ceIEUlNT8eeff2LUqFHi+smTJ2PlypVG+0RGRmLLli3i65ycHDz//PPYuHGj2Nvt66+/ho3Nnf1/QkRNS3GZBptOp4qFs17/4yz2Xs4U1z//60nkFpfjxwPx2DKrd52eh1Sl5Vi8KxYjO3rdtofjwdgbQ8X+rAhGd13KwOPd/aDVCfg7OgU9WzjDTWmBXZfS8dHmS3hvZFtYK8zEoV9Rcdm1CrT/ik6GqlSDt/46i9JyrTiu2BBkA8C7m/S1jwxBqKE3YUm5Fp72lvBQWmDgLa49E7OLYGkuQ6lGa7R8TOc7r2PUI8gJ3g6WCHC2rra6uEQiQe8WLmJx1/AA4wJkcjMpXh8SIhZYBSBeJ3YLcMSIDp5Qa7Swt5Rj3XF9AbWbpwwLrhRo2yrM0NZTCTOZFC3d9NdA7byUYuLKztIcEyqmFTUFBtp01xJzisXni3bFYtv5dKg1OoT5OWDxo53Fu1wSiQShHkrsu5yJpJxiaHT6YC/QxRpBLjb45bA+c+ntYInruSXYE5NR7V3DU0m5YkDz5PIbhaNa3jRntEwqwaiOnvhhfzzclRZIU5Vib0ymUeXn0nKtGHTcnJE12Hpe3wW8f4grDsRmiQW+DGOeL1b8+PVq4YxVU8LF/T54uB26B6bg8e41d0kNqSgMV3ksyeW0wiqB9qU0Fd6tJsgGYFTwaWVUAkrLdbAwl2JoOw+jIlLLJnbBtgtp+L/98eKY6crzWBs8UfGd92npgjFLDiGvuByfbInB1vPp2Ho+HUfjc4yyuz2CnWFhLsPIjvr3Ss0rQZqqFO0rjn1zQbM7ZWEuwzN9gvBMnyA8ufwodsfoT8KGTD2gP8n0CHbC9dxi/HkqGR187PHG0NZ4Y6hx9nx632AcupqF8AAnDPh8D+wszdGi0t+LslJW9ckeAXj5t9Pi6x0X06tkin0cLatkYgeGuol/l8GudxZASCQSozHGDwQ745cp4fC7afhEt0onKEO3ZwCY3i8YH2++hLKKYmaZFRn12Q+2xLRVJ8Qg2zCt1mu/n8FPB+Lx3wu9xO5dF9P0f79d/R3x/IAWKNPocCopD7GZhXgiov66U/s5NfwYKaq9oqIidOjQAU899RRGjx5d7TaDBw/G8uXLxdc311p57LHHkJqaiu3bt6O8vBxPPvkkpk2bhjVr1tRr24no/vPHietG51gARkE2AORWVI9OzS/F63+cwZLHw+rs/b/YdhkrDiXg4NUsbHq+1y23jao0g0plVzOLsOVcKj7bdhle9pb45pGOeGrFcQDAN7uuGJ3frlW6Rj6VlIvPtsVg1sCWRomhys5e1ydLdALw7qbqr/sMY6lnP9jSKAGzdO9VCIJ+yOB/L/ZCSzfbKvtmFJRiyNf74WyjQHJuibi8e6DjHV+7APokxYE5/W+5Te+WzpUC7aoFyIJcrOFpZyEOz/Sv+N4kEolYJHj7hXSsO34ND1Zz48DFViHebAgPdBTn2o4IcsKltAJ0DWj46uI1YaBNd83wI2KYtsqQ4Z0/vA3c7YwDRv+KACIhuwhlGkOgbYOHOnggLqsQfVq6YtelDCzdexVXaqgm/tFmfZfgymNXfR2tqp3OadZA/dzc/UNcMfCLfUZBNqCfI7iDjz0EQcBf0fq7lQ5W5uKPPABxfEmvFs74eEx7WMllGLs0ChdTVXj1t9PiZ7x5jLWb0kLM5tfEyUZRJesek16Ani1uBKfFZRrMXHMKao0OcjOp+L1V1tZLiUupBSgt1697uJN3lTFBLrYKPBbuB1WJRuxW3aaau7lyM6nY7i7+jth1KcPojuPNXai7+jsYvX6mT9UuRveqf4irGGh/8HBbbDqTitJyLcZ09obCTIb/dfVBdlFZlQJoBi62CvFGwH8v9oLcTFpjUbyHOnjgr+hkcbz13suZ4pRQBq3dq35vPSvdUKhcWb+2Kv/b386UngGY0jMADy3aj3PJKgiC/m9hUBt3vDigBb7eqe+Kt2xiF+y6lIG1x5JwKa0AxxNzxeD9Uqr+/9eQis8kN5Ni/TMRyCwsRbDr3X8OahqGDBmCIUOG3HIbhUJR49ScFy9exJYtW3Ds2DF06aKf3nHRokUYOnQoPvvsM3h63t0YfSJqOIfjsnEoNguTevjXWBz1Tv2wP058bi2XwcbCDOkqNQKcrfHCgGC8tM44CN95MQNXMwsRdTUb/+viU+vxzgCg0wl46+9zOJecjzMVgey5ZBXOXM9De2/7GvcxVNK2lsvEG9eAvuCqIcmRnFeCMUuixHUxaYU4fe1G/ZzYzEIUlJbDRmGG+Rsv4PS1PJy9fgwbpj9QJbDNLlQjJb8UEok+A2zIZr8woAUOxWbB3socOy5mAADclAo83t0PPx2MR25ROVyVCnEInUYn4K2/zmHdtO5VhiIeT8hFcZkWSRXX7g5W5vh1Wnd4KOu+h1nfVq7wsrdEoIt1lXgA0AfUvVq4iEmK6no+Phjqhv2v9YNHDfu3dLPFicRcRATduHZ6eVArtPe2q/Ga0BQYaNNdS6qYymlkR09kFqix/0oWBoS4op131Wyp4S5fYnYxSip+tAJdrKEwk+HVSP24EEPgfuZ6Pp5acQwdfezxwgB9EamsQjWOxOdAIgH+e6EXTl3LRVq+Gr1qCE6sFWbi2JL+IfogvrKzyfno4GOPi6kFiMssgsJMis0v9sbJpFwcS8jB8oMJ4rZtPO3EsUKfjm2P0UsOYWel47X2uLugpLWHEpkFN+7mxqSpkFFQihGLDqJHsBPclRaIzSiEq60C84aHYuaaiq7ZPvZisYjvHg3DR1su4r+z+uz7lJ7+Nb5fZBs3fLzlEuQy6W0LsLX2sMWuSxm4XumuZ2U9gpxqrM5dl/qFuMJs4wVYymUY0tZDDJoNFGYyzBrY8o6OdbtMqsJMhlVTwlFQWo5O724Xs/9SCeDlYIlrOSXVfm+Wchn+nvEACko18LCr3y7RN+se4IRzyfrM9IOt9QHPrIEtYG9ljuIyLXq1cEbvli4oLtNg/fHr+PPUdTHQNvTICKn092tnZX7LeciJKtuzZw9cXV3h4OCA/v374/3334eTkz57ERUVBXt7ezHIBoCBAwdCKpXiyJEjePjhh6scT61WQ62+cfNRpVJV2Yaoudh6Pg1BLtYNfuOzrGKIVt+WLnjjz7OIyyzCN7ti0dpDidGdvMTu0LEZBfB2sDIaklSTi6kqcfjW6E5eGNzWHVqdvv7MuyPbwqHSeWdIW3ecSspDmqoU45ZGIaeoDFmF6js+11e2+kiiWO+lsjVHkqoE2iVlWlzNLITcTIqcojJYVoxT/nLHjVlODDWI/JysYGdpjjPX88VaJ4ZaLe5KC0gk+qx8u/nbjGbbUJVqMHPNSfz7Qi/xpv/JpFycrChoGuBsjR+e6IKnVhxDSbkW0/sGYfaDLXE9t1gMtAeFusNcJsWmmb1QrtMhNqMQT604hlGdvPDnyWQcjc/ByaQ8hPkZJ0NOV9QgMmjpZiveaK9rdpbmODCn3y2Lj7X3sRMD7ZqGi96qZtNrka2w8UwKJnT1EZfZKMyqrS1kSgy06a4Zuo4HOFnjvZFt8Xd0CiLbVD82xNAl1hC8AECQs/EdPcMdPkMQeTA2Cz6Olvjwv0uY0VcfNHsoLeDvbF1jFeXq/DipCzIL1ZBKJPjpQDy+23NVHM+8O0b/w9WrhTPc7SwwtJ0HVJXmB/R1tEKXSj9Wbb3s8NHodpi9/sad11CPqjcW7kRrd1vsq9RtKia9EJvPpiFNVYqNp1PE8b5zBocYdZ3p1cIZj3bzRbCbDXydrDAuzAf/nU3D4DbutzwhB7rY4NtHO8HSXHbbILmmH9+pvQLgaW+JPi1davNR75q3gxVWPx0OS7nsru5m3w1bC3N09nMQx+j3CHLGw5288N2eWIzsWH0WzlRTknQPdBLvrg8M1Rf6kEgkVYqVjerkhfXHr+PXo9dwNjkfbw4NFcd9VZelJ7qdwYMHY/To0QgICMDVq1fxxhtvYMiQIYiKioJMJkNaWhpcXY2Lz5iZmcHR0RFpaWnVHnPhwoVYsGBBQzSfqEFodQL+PZuKbv6O1Wb2anI8IQfPrDoBAIhfOLRBqyV/8O8FrIxKRFsvpZgpBfTB8odpKnT2c8ClNBXe/PMcRnf2whf/6whAP7fyzDUn8UCwM569qYeboedgZBs3fDG+o7h8SKXMo5e9JZLzSvBgqBsszWXYcCoZORW9EVceSsC03oG1usGfkleChRU9IQOdrZGcV4LpfYPx5Y7L2Hg6Be+NamtU4fzNP89iw6lk8fqmk689ZvQLQq+WzsgvLseTK24MWXxxQAuM7uwNdcVY51GLD4k3rwe1cUNKXolYXNQQZA9t546Dsdm4lFaA345fw4RuvriUpsLYJYfE4r3tvOxga2GO357tYfRZvB2sEOhijbjMIgxpp7+pbrgp7myjwPkFkZBIJEjNK8HumExcSMmvEmifqZRtB+6tB96duN3f7IgOnlh+MAGt3Gzv6GbNzcIDnRBugnmxa4uBNt01Q/cTXycrWCvMxHl4q+OutDDq/uxsI6+SOQu6qSuNWqPDx5tjkFmgxnd7rgK49d2tmkgkEnHsc7uK8cPnKuac3lvRLblPqxsXhJW79Izv6iOOaTUY3dkbUokEr/1xBnaW5gh0ubsxp5189T+CAc7WiM8qwpX0AjFTXq4VxLu/XfwdoDCTYUrPAGw4eR0TuvkaFZPqF+KKrbN6VxnfW52H2t9Zd83qsvSSisqP1Y39qU+m+CEd01k//degUDd8NKY9HK3lGBN2f90lBYDuQU7wsreEu50FQm/RS6F7gJN4EXMuWYWJPx6BRifA1VZR7ydbapomTJggPm/Xrh3at2+PoKAg7NmzBwMGDLirY86dOxezZ88WX6tUKvj4+NxiD6L725ZzaXjh11OIbOMGDztL/HHyOja/2KvaIlKVVS4cey5ZBVelAgv/u4ixYT61GmZUW3nFZWKBLUNvKQ87C3zzSCesOJiAf8+mYvb6aHHY28bTKXhjaGt9lefj17D/ShaOxOXgka6+Rtd4WyumPb25V1pl749qi8Nx2RjewRManSBWxAb0Y7fXHbtWqxkvlu2LQ3GZFmF+DvjtmQixEvjyQ/HIKy7H2eR8eNtbQlWqgZO1HJvOpAK4MW48zM8BZjIpOvs6QFV6IwEzLswbD1fUwVGYySq2tb8RaIe643xKvpiB7uRrj2s5JZgzOATbL6Tj/X8v4v1/LyL6Wh4Ss4uNZshpV039HIPvHw9DXFYRegRV/fc3BLWt3JXYHZNpNIMMoO8Of/O0sKY+99tamGPH7D4mbUNDYKBNd83Q1dv3DoJfqVQCP0crcfz1wGrmJLRRmBkVRwCAtIqqzxkVP+p3E2hXZigCdiFFhYWbL4pVrftWytC2qBRIjqshuBrVyQvdA50gk0rues7HyDZu+O6xzujgY49+n+5BcZnWKMMNAEoLM/H7ffuhULz9UGi1x6rrH0x/J2vxxoiZVIIN03ugsFTT4EG2qYzv6otBoe5wsJabuim3ZKMww77X+gG49d1jqVSCH57ogqi4bPx0IF6ctuS1wSEN1lOAmrbAwEA4OzsjNjYWAwYMgLu7OzIyjIfsaDQa5OTk1DiuW6FQVCmoRnQ/EAQBWYVltZ5y6kxyHgB90Ho8IRcFpRrsv5KFR25TBTk++0Ymeev5NGw4eR0p+aU4mZQn/ubXtQUbz2PDyeQqyzv7OqCrvyOCXWxwJD4Hidk3inyVawVsOHkd03oH4Y+Kfcu0OvxzJgUTKwrCpqtKkZBdDKnk1rVI+oW4ivMk9wi6cYM9zM8BJxJzsf1COkZ29EK6qvS2w99yisqw9pi+y/isgS0glUogr0iadPPXT6/64tpTYvXz6lTOCCstzPH+qLZIyy/FrIEtqpxvw/wc8MvhJCgtzBAe6Ih23nZIzS/Fw5280MHHHlqdAJlUgici/LHxdApOX8+vdrabLjUUSgP016YtbnMNZii0G5NWgNJyLd766xzKtTpM7xuMQrUGluYyuNtZID6rCB1qGKNOdYuBNt3WicRczF4fjblDWmNwW/0FUmm5VgyC7yTQBvSFqQyB9tgaAliz2wStd/peNfFxtMKErj5Ye+wavt+rL8wR6GJtFMDbWZpj3bTuMJNJ4FrDPNgAatUNrDoSiUQs2NDK3bbK3UZAf2OgIbuMGeinSbDBuWQVApytaywa0pTd70G2QU3F3W4W6qlEqKcSwa42eHL5UXT0scfoTjVnF4hq4/r168jOzoaHh/43LSIiAnl5eThx4gTCwvSVg3ft2gWdTofw8PBbHYrIpDIKSrHjQgbGhHmJGcvfT1zHq7+fwaiOnvh0XIc7vsF+pWIaUsPNTUAfBN1O5W2+3R0rPk+qVMm6LmSoSnHmej5autmKtWlkUgkUZlKx6Gz7iro7DtZybHz+Afx69BquZhYi0Nkai3bFYu2xa+gZ7CJmdAFg3bEkjO7kBWuFGY5UDMMK9VQazfRxK94OVhjWzgMp+SV4LbIVxi87jJi0AsxYfRJH4rPxx3M9xF6B1Vm2Lw6l5Tq087IzKlgK6Gfz2HYhXQyyDXMvVyaRoMrxbzWTzOA2HtjdIRO9W7rAXCaFnaVUnAIUuHGelptJ8duzPXAkPhsf/ncJF1NV6NPSBe8MD0VsRqE4tefdMiRdziTnY/Lyo2JRNUOh33ZedvhoTDskZhdXO/sM1T0G2nRbY5YcAgC8vuEMBrd1x44L6Zi26jgEQf+j4XgXAcnNY0cMnG3ktzyR3GugDQALR7dDmJ8Dvtx+GSn5pRjZoWqw0dDdleeP0Bc7S80vRQtXG/GGxK26EdW3EHclziWr0MKNc942JX1aumDvq/3gaC2vMiyCyKCwsBCxsTcu8OPj4xEdHQ1HR0c4OjpiwYIFGDNmDNzd3XH16lW89tprCA4ORmRkJACgdevWGDx4MKZOnYqlS5eivLwcM2fOxIQJE1hxnEwqp6gMb/11FqM7eRvNOZySVwKZVIJJPx3FpbQCXE4vEIOllVEJAIC/olMgkUjwZaVxxrdSXVB9Of3WgbYgCDUG4+YyCXQ6ATpBgKpUU+vrr9JyLf5vfxw2nUlFan4pVKXlEAT98D5AX2/k56e6YcPJ6+L0UZUL3HrYWWL2g/qiZIVqDX7YH4e4zCK88885APqK2ScSc3EuWYUOC7bBxVaB7EL9OOtu/rW7rlr8WGcA+iJlEgmQXVSGw/HZEATgr1PJNQba8VlF+PGAPpHy4oCq2efula7vHKzM8ePkrpj001FotAK6Bzpid0wmWrra1moOb0u5TJyW6nbkZlL0auGCP6c7Yu/lTPQIcoKthTkCXe79WivIxQZmUgnKNDoxyAYg9pYc1MYNgS42dfJedGcYaFON/jmdgvMpN7Kshp+qz7bFiHf/fB2t7jjj+kpkK0z7+QTmDQ+tcZ+PxrTHy+tPY0BrV3y140qV9T6O917VWSKRYFwXH4zq5IW4zKJazR9YX8L8HLHz5T44mZgHbwdL9P1sDwBUW8G9oYzq6IWt59MwopobEdS43esQDGr6jh8/jn79bnRRNYydnjRpEpYsWYIzZ85g5cqVyMvLg6enJwYNGoT33nvPqOv36tWrMXPmTAwYMABSqRRjxozBN9980+Cfhaiyn6MS8N/ZNJxKykO/EFfIpBKcTMrFhO8Pi4WrAGDV4URM6OYDa7mZOF4ZAP48lQwfB0vsvZyJL8Z3FAuX3qxIrTHKZBtcTq9+ClOD67klKFRrYC6T4MOH2+HUtTx08rHHa3+cQblWwLubLmDN0SSUaXT44OG2eCy85kxrZSVlWkxZeQyHqpkj2tBDcUhbd9hZmotzH0skqDHzaaMww6BQd/xzOkWcDnV6v2AUlmrw2bYYxGcViQXBAIgzXtSWpVwGfyd9LRuh4tpz87k0vDO8TbU3iz/49wLKtQL6tHTBgNauVdZX7nY+tJ0HOvs6YMfsPigt1yKvuBxH43Mwrkv912SxMJchsk31w2jultxMCldbhTgE87XBrfDl9sso1wrwc7LCxIg7+1uhusNAm6pVUFqOl9ZFV5lHOCatQCyy4GyjwGO3KIB2s86+Djj+1sBbbtPSzRYbn++JQrVGDLQNUycAdRsgmMukJi8GUZmV3Aw9WzhDEAT4O1khNb+0xsx/Q+jZwhln50ea7P2JyHT69u0LQRBqXL9169bbHsPR0RFr1qypy2YR3bMtFYW5UvNLse9KJnoFO+OtP88ZBdmtPZS4mKrCGxvOon/FuOEHgp2gtDDH5nNp+GaXvrfHioMJeG9U22rfx9Az7WZZhWqEztuCIW098Pn/Ohit23DyujirSZCLDcZ18cG4LvqCgF/tuILkvBKsOJQgbv9PdEqVQLu4TAMzqRTpqlJ8tycWj4X7oa2XHd7ddB6HrmbDWi7DO8PboLOfPZSW5pj+y0kcr5heylA/p7WHLV4c0AIOVua37O49qpMn/jmdAkA/DK9XsDOkUgmGtnNHan4pPtsaIxY16+p/99czLd1sjGatyShQ42RSrjimuVCtwaVUFco0Ouy4mAGZVFJjUkcmleDNoa2x93ImXhnUCgDgVpHR93MCzr87+K7beT9wtJGLgfYzvYOQnl+K1UeSMH9EG3EoBDUcBtpUrYSs4ipBdm5xOX49qi8u8WCoG354okt1u9YJG4UZegQ54WKqCl38HbH9QjoszKVwsWn6hXIkEglWT+2OQhPMy0xERNRUxWcVGVVkXn/sGtLzS3EhVQU7S3N891hnWCvM4GKrQOSX+3AyKU+ccvSh9p4IcbfF5nM3pqcz1FYxZK8rFwy9VRfx4jIt/jh5HY9190Xnii7QGq0O7226IG4TclMiwNPeokqG/FRSHiYvP4qsQjXWTotASZkWw77ZDwcrOcIDHfHr0WvYeDoVn41rjz9O6APepRPD0KvFjQKwM/sHY/LyY2jlZougillUJBIJXnrw9vNW92rhAkdrOXKKyjApwl/MMEskEnjaW+LD0e0gk0rgYW8Jp3u4fmvlrsTW8+kAIM5LveFUMsL8HPDtrlgs2h0rzmoDACM7etbY0wAApvYOFOcDb2reGNoa7268gPkj2kAmleCd4W3wcmSrOx4fT3WLgTZVy1DxsrWHEkse64yRiw8iv6RcvJNa03zCdemnyV2h0QlYezQJ2y+kw8fhzrupN3aVp+8iIiKie7f5nH4KJ38nKyRkF2P7hXQx8zy9bxAeqFQ4a97wULz2+xnoBH02++FOXrAwl+GxcF/su5KJazklOJecj+S8Ekz88Qjis4rwy5Rw8RiXUvWBdqiHEhcqFQqr7OsdV7DyqW4A9IVnDUWrwvwcMPmmqay87C1xDLli+0vKtUhXqbGnYprStUeTEJNWgIwCNTIK1Mgs1M/WUqjW4NlfTgLQj8GuHGQDQN9WrlgzNfyurrHMZVJ8Pq4DDsdlY3zXqlPxWZjL8Om4DtXsWTuVbzpM7xeEr3ZcwR8nrkOj1WH98esAAEtzGUrKtZBKgOf7t7jn92ysegQ5Y8us3uJrqVTCINuEGGhTtRIruui08VTC39ka3g6WyC/RnwCkEn1BpfpmmMD+gWBnmMsk9Tp3JBEREd3/BEFARoEa+SXl8HGwgqX8zrrDFpdpxMraz/UNwu8nruNYQi5iMwohlUCcG9lgXJg3Cko1kEqAJyL8xcrRHzzcDoIgIGLhLqSpSvHw4oPiFKSfb4tBjyAnxGYUij0AJ3Tzwfv/XoTCTIonHwjANzuvwMveEmmqUuy9nIkz1/Pw69FrOBKvHzs9upMXvqim2JpnpRvwoZ5KyGVS/BWdIi57/9+LRtvnFOmLkHX2tcfJinm5n+zhX+13U93czHeq8rRc9cUQaMukEkztFYgdF9NxLlmF9cevQyIB3h3RBuO6+OCXw4nwsrdEgLN1vbaH6E4x0KZqGTLa/k76MdHeDpY4n6K/I9vKXQnbBrw71tpDidPvDIKlOceWEBERNVflWh0e/u6gWJzMTCrBx2Pa42pmIRKzi/HVhI41Tr314/54ZBao4eNoiYc7ecNGYS4W8eoR5FxlOk+JRIIpPQOqOxQkEgm6Bjhi4+kUZBSo4WBljuIyLU4m5WHdsWtYti8OJeVa9Ax2xmPhfmjjaQeFmRQBztbwtrfE0PYemLLiGI7E52DW2mjEVRp/XLkSemVeDpUCbQ8l7KzkYqBtqzBDgVpTZR9Hazl+ndYd7268gLzicnFK0cYm0MUGbw5tDUdrOawVZni6ZyBmrYuGuUyCL/7XEcM76HtZPt2raXYHp8aLgTZVKzFbP8WWf8VdQS/7G0XIwvzsG7w9VnL+qRIRETVnB2OzcC5ZBakEsJbrg8sP/7uI7Irs7cQIP3QPdEJidhFkUgm8HfTXLoIgiEPfXhnUCnIzKQa1cYOHnQVS80vvajhceEWgbSWXYcWT3fBXdDKWH0zA6xvOAgA87Szw1YSOkEklRoVN/1fRxbp7oBOOxOcYBdmW5jL0rqHHYOUhZa09lOjk64DlB+IREeSEbgGOWLQrFo9084WvoxWm/nwcANDB2w4KMxk+eLhdrT/f/abymOoRHTxRUFqOUE87kxaNJbodRi9UrYQsQ0ZbH2h7V7qTyh81IiIiqi8arQ4HYrPQPdBJHEYGAP+e0Y+xfizcD3OHhiD8w51ikA3oZ0YJcrHBsG8OQGEmxYE5/WEplyGrsAzZRWWQSCBOqWQuk2Lp42E4Ep+N0Z1rP53T2DBvpOaX4MFQd3TwsUdLN1sUlGrw+4nrcLZR4Jenw+F8iwJgEUFO+HrnjWlMP3y4HVq528BGUf2luddNXccdreXY9UpfcdnIjvqu7/nF5eJsLR187Gv9uRoDqVSCiRH+pm4G0W0x0KYqVKXl4onLkNF2sb1xsgjzvbu5EImIiIhuZ2VUIt7bdAFP9wzAWw+F4tejSfhm5xVxXuZh7T1gJTfD2DBvcdw1AFxIUaGkXItCtQaFamD/lUwMauOO2IqCZz4OVkaBewcf+7sORi3MZXg1MkR8bSmX4bNxHTApwh+e9ha3rbLdydceCjMp1BodQtxt8ehtpkv1c7JGkIs17K3kcL+pm3tldlbmaOdlhzPX8+967moiqhsMtKmKxCx9t3FnG4V4Z7XyfNM+jqyITURERPVj32V9Je3/zqZieAdPvP3XOWgqphx1tpGja8X8yZMi/LH+2DUUlWkBAOdT88WiYgCw7UK6PtDO1Afawa41T/lUV9p5293RdgozGcL8HHDoavYdFROTm0mx7aU+kEpw2+rg30zohEtpqnsqckZE946BNlWRUFEIzc/pxrjslm62+GVKONztFM1mii0iIiKqO9dyinE0Pgf9QlzhaC1HQlYRcovL0NHHHtsvpKOjrz2crRU4maQvUpaSX4qRiw8C0A9bK9PoMLG7n1gB3N/ZGofmDkC6qhSDvtwnFkkzdJ3eeTEdGq0OVzMaLtCujdeHhOCXw4mYeodFvAyf+3b8na3FHolEZDoMtKmK67klAABfRyuj5Zxei4iIiO7WC2tP4VRSHmRSCZZP7oq5G84iTVWKFwe0wBfbL+OBYCfMe6gNCkqNK2i72Crw06SusLOqOuOJnaU5bBVmkMukKNPqAOgz3X9HJyO3uBzzN57H5XR9oB3kcn8Fn+297fHJWHtTN4OI6kn1cyBQs3Y9V991vHIBNCIiImqesgrVOByXXe26q5mFuJiqQmm59pbHyCgoxamK+Zy1OgFzN5xFcl4JtDoBi3bpi4IdupqN/87qC55V7jz31rDW1QbZBlKpBNJKV7SzB7XE8/1bAAB+OZyEo/E5AO6/jDYRNW0MtKmKaxUZbR8Hq9tsSURERE3dS+uiMWHZYRyMzTJafjwhBwM+34shX+9H5Ff7UKbR1XiMvTH6cdeG2i/JeSXiunKtfvy1IECsxP1oN1942VtiSFt3jOhw++m3Xo0MgbyikrjSwhxP9QzAsolhRtsEu9jWsDcRUd1joE1VMKNNREREgH4mkkNX9dnsXZcyjNZVznInZhdj58X0Go+zpyLQfuoBf3ja1Vw122BEB08cfL0/vnus8x3VhpnSMwDnFkRicFt3cdmgNu4YG3Zj6q5bZcWJiOoaA20yIggCkisy2t7MaBMRETVrh69mQ1tR8btyRW8A4thnQxy87vi1ao9RUqbFviv6QLtviKtRzReFmf5StEeQk1js69XIVggPdKo49p0XYJWbVb2sfX9UW0zrHYjvHut8x8chIqoLLIZGRjIL1VBrdJBKAA/7299xJiIioqbrQKXu4udTVMgvKYedpT4zfDm9AADw5tDWeP/fi9h3ORMpeSXwtDfuEffNrisoKNXA28ESHbztkZxbgvXHr0NuJsVbD4Xii20xeCWyFYrVWkgkwAPBdVd81cJchjeGtq6z4xER3SlmtJuRxOwifLzlEvKLy6tdf/paHpbtjQMAeNhZwlzGPw8iIqLm7MAVfaBtmDLrWEVhMY1Wh7hM/XSgkW3c0T3QEToBYmEzg6uZhfhhn/7a4p3hbSCTSjCgtSv6tXLB8/2CMbG7H07NG4TOvg7o2cK5ToNsIiJTYiTVjLz62xks2XMVj/94pMq63TEZGLPkEP7vQDwAwIvjs4mIiJoFtUaLv6OTUaQ2nlbrRGIu4rKKYCaVYGg7DwAQx2snZBejTKuDpbkMXvaWeHlQKwDAumPXEJNWIB5jxcEEaHQC+rVywYOhbgAAK7kZlj/ZDc8PaNEQH4+IyCQYaDcjJ5NyAQBnk/MhCIK4PK+4DNN/OQmN7sYyBxYMISIiahZWH07Ci2ujq9yIN1QAH93ZC0Pb6gPtPZf1BdGuVHQbb+lmA6lUgq7+jhjcxh06AVhxKAEAUKTW4M9TyQCAp3sFNsRHISK6bzDQbkY6+NiLz89czxefX04vREm5Fh6VqoD6OVk3ZNOIiIjIRP6K1gfDp5LyxAD6eEIO9l3OhEwqwcx+LdCrpTPMpBLEZRZhzu9n8NzqkwCAFm43pswa1cmr4jj6G/t/R6egUK1BgLM1IiqKmxERNRcMtJsRtUYrPt98Lk18nlOkBgB42Vvivxd6YUJXHzzdM6DB20dEREQNr3Jd78W7Y1Gu1eGtv84BAMaFecPXyQpKC3N0C3AEYFxdvIO3nfi8k689AH2RtNT8Eny54zIA4LFwX0ild149nIioKWDV8WakoPTG2KvKc19mFZYBAByt5Qj1VOKjMe0bvG1ERETU8ARBwNWKomYAsO1COtpHJeJSWgHsrczx2uAQcV3/EFdxjPaojp7o08pFHLsNAG5KC7grLZCmKsVjPxxBZoEagc7WeLy7X8N9ICKi+wQz2s1I5UA7Ja9EfJ5dEWg72SgavE1ERERkOpkFahRWFEGTSSUoLtNiWUWV8Of7t4CjtVzcdkg7D1jJZWjtob8p/3AnbyjMZEbH61gxTC0uSx+8LxzdDhbmxtsQETUHzGg3E4IgQFVyY1qvjAI11BotFGYyZFd0HXe2kde0OxERETVBsZmFAAA/Jys4WctxMikPaapSAECflsZTbXnZW+LAnP6wkstqDJ47+Nhjy3n98LQRHTwRzrHZRNRMMaPdTJSW64yqigNAWr7+RCpmtK0ZaBMRETUnhrmwg1xs0M7rxnhrO0tzBDrbVNne0Vp+ywy1YZw2ALw2uFXdNZSIqJFhRruZUJXqs9kyqQR+jlaIyypCcl4J/JyskVWoz2iz6zgREVHzcrUiox3obI2W7jcqiHf2tb+rAmbhAY54fUgIWrjawNvBqs7aSUTU2DDQbiYKKgJtWwszeDlYIi6rCCl5+ox2ThEz2kRERM2RoRBa4E0Z7TA/h7s6nkQiwbN9guqkbUREjRm7jjcT+SX6Qie2FmbwtLMEcKMgWnYRi6ERERE1N2qNFicScgAA7bzsEOxqA4WZ/tKws+/dBdpERKTHjHYzIWa0FebwctAH2sm5JdBodcgtNgTazGgTERE1F8fic1FUpoWzjQJtPJWQSiV466FQXEkvYBEzIqJ7xIx2M2GY2ktpaQZP+4qMdn4JcovLIQiARAI4WDHQJiIiYN++fRg+fDg8PT0hkUjw119/Ga0XBAHz5s2Dh4cHLC0tMXDgQFy5csVom5ycHDz22GNQKpWwt7fHlClTUFhY2ICfgm5nd0wGAKBvKxdxPPbE7n54d2RbyO5ifDYREd3AQLuZUIljtM3haW8BAEjOKxGn9nK0kvOkSkREAICioiJ06NABixcvrnb9J598gm+++QZLly7FkSNHYG1tjcjISJSWlorbPPbYYzh//jy2b9+OTZs2Yd++fZg2bVpDfQS6A4ZAu3+Iq4lbQkTU9LDreDMhZrQtzOFVkdG+nluCDSeTAein6yAiIgKAIUOGYMiQIdWuEwQBX331Fd566y2MHDkSAPDzzz/Dzc0Nf/31FyZMmICLFy9iy5YtOHbsGLp06QIAWLRoEYYOHYrPPvsMnp6eDfZZqHqZBWrEZRZBIgF6tnC+/Q5ERFQrzGg3E6qSG1XHPewsYaswQ5lGh2X74gAw0CYiojsTHx+PtLQ0DBw4UFxmZ2eH8PBwREVFAQCioqJgb28vBtkAMHDgQEilUhw5cqTB20xVXUkvAAD4OlpBaWFu4tYQETU9DLSbiRtjtM0hN5Pizxk98ESEn7heYS4zVdOIiKgRSUtLAwC4ubkZLXdzcxPXpaWlwdXVuDuymZkZHB0dxW1uplaroVKpjB5Uf65k6MfLt3C1vc2WRER0NxhoNxOGMdpKC/1ogWBXW7w7si0+HtMODlbmGNWR3fiIiMh0Fi5cCDs7O/Hh4+Nj6iY1aVcy9BntFm42Jm4JEVHTxEC7mTBktG0tjIflj+/qi5NvP4jRnb1N0SwiImpk3N3dAQDp6elGy9PT08V17u7uyMjIMFqv0WiQk5MjbnOzuXPnIj8/X3xcu3atHlpPBpfT9Rntlgy0iYjqBQPtZqJAzGhXHYclkbDaOBER3ZmAgAC4u7tj586d4jKVSoUjR44gIiICABAREYG8vDycOHFC3GbXrl3Q6XQIDw+v9rgKhQJKpdLoQfcmJa8Ef566jtiK7HVlsew6TkRUr1h1vJlQlRgy2ix4QkREt1ZYWIjY2FjxdXx8PKKjo+Ho6AhfX1/MmjUL77//Plq0aIGAgAC8/fbb8PT0xKhRowAArVu3xuDBgzF16lQsXboU5eXlmDlzJiZMmMCK4w2kSK3BIz8cRmJ2MQDg7YdCMaVnAAAgq1CNnKIySCRAkAsz2kRE9YGBdjOwJyYDCdlFAAA7SwbaRER0a8ePH0e/fv3E17NnzwYATJo0CStWrMBrr72GoqIiTJs2DXl5eejZsye2bNkCCwsLcZ/Vq1dj5syZGDBgAKRSKcaMGYNvvvmmwT9Lc/XhfxeRmF0MiQQQBGDz2VQEulgjMasIrdz1vQV8HKxgKWcxVCKi+iARBEEwdSNqS6VSwc7ODvn5+exadhsZBaXo+fFulGl06B7oiDVPd4dUyq7iRER0f+O5/u7ticnA5OXHAADvj2qLt/46B7mZFGUaHQBgfBcfrDt+Df1DXPHT5K6mbCoRUZPFMdpN3IUUFco0Ovg7WeHnp8IZZBMRETVh+SXlmPPHGQDA5B7+eCzcF47WcjHIBoC9lzMBAP5O1iZpIxFRc8BAu4m7nlsCQD+dl9yM/9xERERN2d7LmUhXqeHjaIk5g0MgkUjQ2dfBaJs0VSkAwN/ZyhRNJCJqFhh5NXHXcvVFULwdLE3cEiIiIqpv6fn6ILqzr4M4/rqLv0O12/oxo01EVG8YaDdx13P0GW0fR961JiIiauoyCvSBtqutQlwWHuBY7bb+Trw2ICKqLwy0m7jrzGgTERE1GxkFagCAS6VAu5OvAz4d2x7vjWorLjOTSuBlz2sDIqL6wkC7ibtWMUbbx4F3rYmIiJq6zIpA29XWwmj5uC4+GNvZW3zt7WAJMxkvA4mI6kutfmEXLlyIrl27wtbWFq6urhg1ahRiYmKMtunbty8kEonR49lnnzXaJikpCcOGDYOVlRVcXV3x6quvQqPR3PunISNFag1yisoAAN6OvGtNRETU1GWIgbaiyjpLuQzuSn0A7u/M8dlERPXJrDYb7927FzNmzEDXrl2h0WjwxhtvYNCgQbhw4QKsrW/8YE+dOhXvvvuu+NrK6kY2VavVYtiwYXB3d8ehQ4eQmpqKJ554Aubm5vjwww/r4CORgaHiuJ2lOZQW5iZuDREREdW3jIqK4i7VBNoAEOBsjTRVKaf2IiKqZ7UKtLds2WL0esWKFXB1dcWJEyfQu3dvcbmVlRXc3d2rPca2bdtw4cIF7NixA25ubujYsSPee+89zJkzB/Pnz4dcLr+Lj0HVuZbD8dlERETNRWm5FqpSfQ/Bm7uOG3T2s0dUXDY6+do3YMuIiJqfexqck5+fDwBwdDSuZrl69Wo4Ozujbdu2mDt3LoqLi8V1UVFRaNeuHdzc3MRlkZGRUKlUOH/+fLXvo1aroVKpjB50e4kVgTbHZxMRETV9hvHZcjMplJbV51JmDWyJrbN6Y0QHz4ZsGhFRs1OrjHZlOp0Os2bNwgMPPIC2bW9UsXz00Ufh5+cHT09PnDlzBnPmzEFMTAw2bNgAAEhLSzMKsgGIr9PS0qp9r4ULF2LBggV329Rm60hcNgCgjafSxC0hIiKi+iZWHLdRQCKRVLuNuUyKVu62DdksIqJm6a4D7RkzZuDcuXM4cOCA0fJp06aJz9u1awcPDw8MGDAAV69eRVBQ0F2919y5czF79mzxtUqlgo+Pz901vJko0+hw6Ko+0O7bytXErSEiIqL6lmmYQ1tZ/fhsIiJqOHfVdXzmzJnYtGkTdu/eDW9v71tuGx4eDgCIjY0FALi7uyM9Pd1oG8PrmsZ1KxQKKJVKowfd2smkXBSqNXCyljOjTURE1AzcquI4ERE1rFoF2oIgYObMmfjzzz+xa9cuBAQE3Haf6OhoAICHhwcAICIiAmfPnkVGRoa4zfbt26FUKhEaGlqb5tAt7L2cCQDo3dIFUmn13ceIiIio6TCM0a6p4jgRETWcWnUdnzFjBtasWYO///4btra24phqOzs7WFpa4urVq1izZg2GDh0KJycnnDlzBi+99BJ69+6N9u3bAwAGDRqE0NBQTJw4EZ988gnS0tLw1ltvYcaMGVAoeGKoK6eScgEAEUFOJm4JERERNQTDtJ41VRwnIqKGU6uM9pIlS5Cfn4++ffvCw8NDfKxbtw4AIJfLsWPHDgwaNAghISF4+eWXMWbMGGzcuFE8hkwmw6ZNmyCTyRAREYHHH38cTzzxhNG823TvCiqm9+BdbSIioqZPpxOw/0oWAKCzr4OJW0NERLXKaAuCcMv1Pj4+2Lt3722P4+fnh//++682b021VFymBQDYKO663h0RERE1Eqev5yGrUA1bhRm6BTjefgciIqpX9zSPNt2/CtX6jLa1nIE2ERFRU7fjor6wbO9WLpCb8fKOiMjU+EvcRBUZAm2FzMQtISIiovq265K+COrA1pzSk4jofsBAuwnS6QSx67g1u44TERE1SQWl5Vh+MB7Xc4txOb0AANA9kEVQiYjuB4zCmqDicq34nGO0iYiImqY1R5KwcPMlbD6bBq1OgLVcBnclK44TEd0PmNFugooruo1LJYCC47SIiIiapCsZhQCAowk5AIAAF2tIJBJTNomIiCowCmuCxEJoCjOecImIiJqopOxio9cBzjYmagkREd2MgXYTVKSuGJ/NiuNERERNVmJOkdHrQGdrE7WEiIhuxkC7CSoqY8VxIiKipqy0XIt0ldpoWaALA20iovsFA+0myDC1FwuhERERNU3XcoqrLAtyYddxIqL7BQPtJqioYmovK3YdJyIiapISs6sG2gHsOk5EdN9goN0EFVUqhkZERERNT2JFRrulmz6L7e9kxfM+EdF9hIF2E3Sj6zjHaBMRUd2bP38+JBKJ0SMkJERcX1paihkzZsDJyQk2NjYYM2YM0tPTTdjipsfQdbx/iBt+mtwFy57oYuIWERFRZQy0myBD1XEr3tkmIqJ60qZNG6SmpoqPAwcOiOteeuklbNy4Eb/99hv27t2LlJQUjB492oStbVqyCtU4GJsFAPBzskL/EDe0dLM1cauIiKgyRmJNkKHqOIuhERFRfTEzM4O7u3uV5fn5+fjxxx+xZs0a9O/fHwCwfPlytG7dGocPH0b37t0buqlNSk5RGUZ+exDJeSWwlsvQq4WzqZtERETVYEa7CTJ0HbeSs+s4ERHVjytXrsDT0xOBgYF47LHHkJSUBAA4ceIEysvLMXDgQHHbkJAQ+Pr6IioqylTNbRJ0OgGv/HYayXkl8HW0wt8zH4C3g5Wpm0VERNVgyrMJ4vReRERUn8LDw7FixQq0atUKqampWLBgAXr16oVz584hLS0Ncrkc9vb2Rvu4ubkhLS2txmOq1Wqo1TfmhVapVPXV/EbrQGwWdl3KgNxMiu8nhiHYld3FiYjuV4zEmoh/z6Ri/sbz+PaRTiisGKPN6qNERFQfhgwZIj5v3749wsPD4efnh/Xr18PS0vKujrlw4UIsWLCgrprYJF1OLwAAPNjaDa09lCZuDRER3Qq7jjcRL649hcwCNcYvO4ziMnYdJyKihmNvb4+WLVsiNjYW7u7uKCsrQ15entE26enp1Y7pNpg7dy7y8/PFx7Vr1+q51Y1Pcl4JAMDb4e5uZhARUcNhoN1EWJjfCKrZdZyIiBpSYWEhrl69Cg8PD4SFhcHc3Bw7d+4U18fExCApKQkRERE1HkOhUECpVBo9yFhyrj7Q9mKgTUR032Mk1kSEuNvieGIuAOBCqn5cG7uOExFRfXjllVcwfPhw+Pn5ISUlBe+88w5kMhkeeeQR2NnZYcqUKZg9ezYcHR2hVCrx/PPPIyIighXH75Eho+1lz0CbiOh+x0isidDoBPF5uVb/3FrOf14iIqp7169fxyOPPILs7Gy4uLigZ8+eOHz4MFxcXAAAX375JaRSKcaMGQO1Wo3IyEh89913Jm5143edGW0iokaDkVgTYeguXpm1gmO0iYio7q1du/aW6y0sLLB48WIsXry4gVrU9BWqNcgvKQfAjDYRUWPAMdpNRPWBNu+jEBERNQWG8dl2luawtTA3cWuIiOh2GGg3EYUVgfbkHv7iMiVPxERERE1Ccl4xAGaziYgaC6Y8mwBBEFBUpp87+9k+Qejkaw+ZVAJLTu9FRETUJLDiOBFR48JAuwlQa3TQVhRDs1bIMLKjl4lbRERERHXpOiuOExE1Kuw63gQUVhqfzUrjRERETU9cZhEAwNfRysQtISKiO8FAuwkwFEKzkssglUpM3BoiIiKqa+eS8wEAbTyVJm4JERHdCQbaTYAho80q40RERE1PVqEaqfmlkEiANl52pm4OERHdAQbaTUCRWl8IzYaBNhERUZNztiKbHeBszXM9EVEjwUC7CSgqM2S0WWWciIioKUnKLsah2CwAQDtms4mIGg3eFm0CDGO0WQiNiIio6UjJK8GAL/agXKufWYSBNhFR48GMdhNQxDHaRERETc7JpFwxyAaAtgy0iYgaDQbaTUBhxRhtBtpERERNR0xagfh8bJg3uvg5mLA1RERUG4zMmgBDRtuGY7SJiIiajEsVgfa8h0LxVM8AE7eGiIhqgxntJoBjtImIiJoeQ0Y7xMPWxC0hIqLaYqDdBHAebSIioqalSK1BUk4xACDEXWni1hARUW0x0G4CbnQdZ6BNRETUFFxO12ezXWwVcLSWm7g1RERUWwy0mwAWQyMiImpaxG7j7uw2TkTUGDHQbgJuTO/FYmhERERNwdXMQgBAsKuNiVtCRER3g4F2E1BUxq7jRERETUlCtn58doCztYlbQkREd4OBdhNgKIZmxarjRERETUJidhEAwM+JgTYRUWPEQLsJKCjVB9q2Fgy0iYiIGjudTkBiRUbb38nKxK0hIqK7wUC7kSvT6JBVqAYAuNtZmLg1REREdK/SC0qh1uhgJpXAy97S1M0hIqK7wEC7kUvLL4UgAAozKZw4/QcREVGjl5Clz2Z7O1jCTMZLNSKixoi/3o3c9Tz9ydjL3hISicTErSEiIqJ7xfHZRESNHwPtRi45twQA4OXArmVERERNQQLHZxMRNXoMtBu5lLxSAICnHQNtIiKixu6bnVewdO9VAMxoExE1Zgy0G7lkQ9dxZrSJiIgatWs5xfhi+2XxdSdfe9M1hoiI7gnng2rkkvMquo6zKikREVGjFnU1GwAQ6qHEN490QrCrjYlbREREd4sZ7UbOMEbbk4E2ERFRo3bwahYAYGBrVwbZRESNHAPtRkynE5CSrx+j7c2u40REdB9avHgx/P39YWFhgfDwcBw9etTUTbrvlJZrcSIxB7suZQAAIoKcTdwiIiK6Vwy0G6m84jLMXh+NMo0OEgngbmdh6iYREREZWbduHWbPno133nkHJ0+eRIcOHRAZGYmMjAxTN+2+snh3LMYsiUJBqQZymRSd/exN3SQiIrpHDLQbqXXHruGv6BQAQAtXG5jL+E9JRET3ly+++AJTp07Fk08+idDQUCxduhRWVlb46aefTN20+8rJpFzx+YDWrlCYyUzYGiIiqgsshtZIxWUWAQACna3xy5RwE7eGiIjIWFlZGU6cOIG5c+eKy6RSKQYOHIioqKgq26vVaqjVavG1SqVqkHbeDxIr5s1++6FQ/K+Lt4lbQ0REdaFWadCFCxeia9eusLW1haurK0aNGoWYmBijbUpLSzFjxgw4OTnBxsYGY8aMQXp6utE2SUlJGDZsGKysrODq6opXX30VGo3m3j9NM5KUoz8pPz8gGK5KdhsnIqL7S1ZWFrRaLdzc3IyWu7m5IS0trcr2CxcuhJ2dnfjw8fFpqKY2uPyScny85RKu5RSjTKNDSsUMIg+194CthbmJW0dERHWhVoH23r17MWPGDBw+fBjbt29HeXk5Bg0ahKKiInGbl156CRs3bsRvv/2GvXv3IiUlBaNHjxbXa7VaDBs2DGVlZTh06BBWrlyJFStWYN68eXX3qZoBQ6Dt62hl4pYQERHdu7lz5yI/P198XLt2zdRNqjcfb7mEJXuuYvi3B5CSVwKdAFiYS+FqqzB104iIqI7Uquv4li1bjF6vWLECrq6uOHHiBHr37o38/Hz8+OOPWLNmDfr37w8AWL58OVq3bo3Dhw+je/fu2LZtGy5cuIAdO3bAzc0NHTt2xHvvvYc5c+Zg/vz5kMvldffpmqgyjQ6p+fq73z4MtImI6D7k7OwMmUxWpVdbeno63N3dq2yvUCigUDSPQPN4Qg4AIK+4HBdT9V3kfR2tIJFITNksIiKqQ/dUQSs/Px8A4OjoCAA4ceIEysvLMXDgQHGbkJAQ+Pr6iuOxoqKi0K5dO6OuZJGRkVCpVDh//vy9NKfZqHz328WmeVyUEBFR4yKXyxEWFoadO3eKy3Q6HXbu3ImIiAgTtsz0pJUC6pVRCQDYQ42IqKm562JoOp0Os2bNwgMPPIC2bdsCANLS0iCXy2Fvb2+0beXxWGlpadWO1zKsq05zLpBSncrdxnn3m4iI7lezZ8/GpEmT0KVLF3Tr1g1fffUVioqK8OSTT5q6aSaj1QmIz7ox5O5wnD677etobaomERFRPbjrQHvGjBk4d+4cDhw4UJftqdbChQuxYMGCen+fxoLjs4mIqDEYP348MjMzMW/ePKSlpaFjx47YsmVLlRvuzUlKXgnUGl2V5X5OPKcTETUld9V1fObMmdi0aRN2794Nb+8b01C4u7ujrKwMeXl5RttXHo/l7u5e7Xgtw7rqNKcCKXfiWkWgzfHZRER0v5s5cyYSExOhVqtx5MgRhIc37ykpYzMLAQCt3GwxooOnuNyXgTYRUZNSq0BbEATMnDkTf/75J3bt2oWAgACj9WFhYTA3NzcajxUTE4OkpCRxPFZERATOnj2LjIwMcZvt27dDqVQiNDS02vdVKBRQKpVGj+aMGW0iIqLG6WqGPtAOdrXBBw+3RaCzNSzMpWjraWfilhERUV2qVdfxGTNmYM2aNfj7779ha2srjqm2s7ODpaUl7OzsMGXKFMyePRuOjo5QKpV4/vnnERERge7duwMABg0ahNDQUEycOBGffPIJ0tLS8NZbb2HGjBnNptrovcoq1I9Xd+P82URERI3K1YqMdpCLNWwtzLHphZ4oLtPCmcVNiYialFoF2kuWLAEA9O3b12j58uXLMXnyZADAl19+CalUijFjxkCtViMyMhLfffeduK1MJsOmTZvw3HPPISIiAtbW1pg0aRLefffde/skzYhhbJeF+T0VjSciIqIGJAgCjiXkAgCCXG0AAFZyM1jJ77pkDhER3adq9csuCMJtt7GwsMDixYuxePHiGrfx8/PDf//9V5u3pkpKy7UAAIWZzMQtISIioju153ImYjMKYaMwQ78QV1M3h4iI6hFToo0QM9pERESNzw/74gAAE7r6QGlhbuLWEBFRfWKk1gipy/WBNjPaREREjUN+cTkOXc0GADzZM+A2WxMRUWPHQLsRKtUYuo7zn4+IiKgxiMvSF0FzUyrgZW9p4tYQEVF9Y6TWCBky2hbmzGgTERE1BgnZRQAAfydrE7eEiIgaAgPtRkYQBKiZ0SYiImpU4rOKAQABzgy0iYiaA0ZqjUy5VoCuovg7x2gTERE1DglZFRltBtpERM0CA+1GxpDNBgAFq44TERE1Coau48xoExE1D4zUGhnD1F4Au44TERE1BoIgID6LgTYRUXPCSK2RMQTacjMpJBKJiVtDREREt5NTVIaCUg0kEsDX0crUzSEiogbAQLuRKS3Xdx23YDabiIioUTB0G/e0s+SMIUREzQSjtUbGMLWXgidqIiKiRuG349cBACHutiZuCRERNRQG2o0Mp/YiIiJqPC6lqbD++DUAwPR+QSZuDRERNRRGa41MaUVGm13PiIiI7n/L9sZBJwBD27kjzM/R1M0hIqIGwkC7kWFGm4iIqHEo0+iw/WI6AODJBwJM3BoiImpIjNYaGUPVcQbaRERE97cj8dkoKNXA2UaOzr4Opm4OERE1IEZrjYxYdZxdx4mIiO5rW8+nAQAeDHWDTMopOYmImhMG2o0MM9pERESNw56YTADAoFB3E7eEiIgaGqO1RuZGoM2MNhER0f2qtFyL67klAICOPvambQwRETU4BtqNjLqi67jCnP90RERE96uknGIAgNLCDPZW5iZuDRERNTRGa42MIaNtwYw2ERHRfSshqwgA4O9sDYmE47OJiJobM1M3gGqHGW0iIqL714UUFWauOQlnGwUAwM/J2sQtIiIiU2Cg3ciUshgaERHRfWve3+cQl1WEuIqMtp+jlYlbREREpsBorZFRc3ovIiKi+1ZJxXnawM+JgTYRUXPEQLuR4fReRERE9y+NVjB67e/MruNERM0Ro7VGhtN7ERGRqfn7+0MikRg9PvroI6Ntzpw5g169esHCwgI+Pj745JNPTNTahqPTCUjILjJaxow2EVHzxDHajUyp2HWc90iIiMh03n33XUydOlV8bWtrKz5XqVQYNGgQBg4ciKVLl+Ls2bN46qmnYG9vj2nTppmiuQ0ivaBUvCFu4FJRFI2IiJoXBtqNDDPaRER0P7C1tYW7u3u161avXo2ysjL89NNPkMvlaNOmDaKjo/HFF1806UA7IUs/d7aXvSW6BTiijaeSU3sRETVTTIs2MmoNp/ciIiLT++ijj+Dk5IROnTrh008/hUajEddFRUWhd+/ekMvl4rLIyEjExMQgNze32uOp1WqoVCqjR2Nj6Dbews0GX47viKd7BZq4RUREZCrMaDcypeXMaBMRkWm98MIL6Ny5MxwdHXHo0CHMnTsXqamp+OKLLwAAaWlpCAgIMNrHzc1NXOfg4FDlmAsXLsSCBQvqv/H1yBBo+3PubCKiZo9p0UaGGW0iIqoPr7/+epUCZzc/Ll26BACYPXs2+vbti/bt2+PZZ5/F559/jkWLFkGtVt/1+8+dOxf5+fni49q1a3X10RpMfKYh0GYBNCKi5o4Z7UZGXc7pvYiIqO69/PLLmDx58i23CQysvit0eHg4NBoNEhIS0KpVK7i7uyM9Pd1oG8PrmsZ1KxQKKBSNt3BYZoEaey9nAgDaedubtjFERGRyDLQbmVKNoeo4u44TEVHdcXFxgYuLy13tGx0dDalUCldXVwBAREQE3nzzTZSXl8Pc3BwAsH37drRq1arabuNNwU8H46HW6NDRxx6dfe1N3RwiIjIxpkUbGWa0iYjIlKKiovDVV1/h9OnTiIuLw+rVq/HSSy/h8ccfF4PoRx99FHK5HFOmTMH58+exbt06fP3115g9e7aJW18/VKXl+CUqEQAwvW8QK40TEREz2o1FblEZJi8/iowC/fg3FkMjIiJTUCgUWLt2LebPnw+1Wo2AgAC89NJLRkG0nZ0dtm3bhhkzZiAsLAzOzs6YN29ek53aa1VUIgrUGrRwtcHA1m6mbg4REd0HGGg3EtsvpOP09XzxtQWLoRERkQl07twZhw8fvu127du3x/79+xugRaZVWq7F8oPxAIDn+gZBKmU2m4iI2HW88bjpvM2MNhERken9eCAeWYVl8LK3xPAOnqZuDhER3ScYaDcSJWVao9eWcgbaREREppScV4JFu64AAF6JbAlzGS+riIhIj2eERqK4UqD92uBWsFGw1z8REZEpfbn9MkrLdejm74hRHb1M3RwiIrqPMNBuJErK9YH2xO5+mN432MStISIiat7SVaX4OzoZAPDGsNasNE5EREaYFm0kSso0ANhlnIiIyFTOXM/DM6tO4M1hrXExVYVyrYCu/g7o6GNv6qYREdF9hoF2I2HoOm5pzkCbiIjIFDacTEZqfil+PZqEK+mFAIApPQNN3CoiIrofMdBuJAxdx62Y0SYiIjKJCykqAMCxhFyUaXQwk0rQt5WLiVtFRET3I47RbiQMVccZaBMRETU8nU7AhVR9oF2m0QEAWnsoYcGeZkREVA0G2o2Eoes4T+hEREQN71puMQrVGqNlHXzsTNQaIiK63zHQbiRuZLTZ25+IiKihGbqNV9bRx8EELSEiosaAgXYjwTHaREREpmPoNq4wu3HpxGrjRERUEwbajURxxfRe7DpORETU8E4l5QEAhnfwBADYW5kj0NnahC0iIqL7GfshNxIshkZERGQaMWkFOBCbBYkEeK5vEDr7OsDPyQpSqcTUTSMiovsUA+1Ggl3HiYiITGPJnlgAwOA27ghysUGQi42JW0RERPc7dh1vJAxVxy0ZaBMRETWY6Gt5+Od0CgBget9gE7eGiIgaCwba9ymdTsBbf53F6iOJ0OoEqCvm7LTkGG0iIqJ6JwgCYjMKMOf3M9AJwMiOnmjnzem8iIjozrDr+H3qSkYhfjmcBAtzKR5q7yku5/ReRERE9euHfXFYtj8OmQVqAICjtRzvDG9j4lYREVFjwqjtPlWo1lcZLy3XiXN3SiSAhTk7IRAREdUXjVaHL7ZfRkm5FuYyCR4IdsasgS3haC03ddOIiKgRYaB9nyqtKH4GACcScwDou41LJKxwSkREVF8upxeipFwLW4UZjr45kLVRiIjorjA9ep8yTOcFAMcScgFwfDYREVF9O309DwDQ3seOQTYREd01Btr3qZJKGe2TiRWBNk/4RERE9So6KQ8A0MHb3qTtICKixq3Wgfa+ffswfPhweHp6QiKR4K+//jJaP3nyZEgkEqPH4MGDjbbJycnBY489BqVSCXt7e0yZMgWFhYX39EGamspdxwsqxmtzDm0iIqL6Zchod/CxN2k7iIiocat1oF1UVIQOHTpg8eLFNW4zePBgpKamio9ff/3VaP1jjz2G8+fPY/v27di0aRP27duHadOm1b71TVjlQNuAXceJiIjqT5Fag8vpBQCATgy0iYjoHtS6GNqQIUMwZMiQW26jUCjg7u5e7bqLFy9iy5YtOHbsGLp06QIAWLRoEYYOHYrPPvsMnp6e1e7X3JRUF2gzo01ERFRvYtILoBMAV1sFXJUWpm4OERE1YvUyRnvPnj1wdXVFq1at8NxzzyE7O1tcFxUVBXt7ezHIBoCBAwdCKpXiyJEj1R5PrVZDpVIZPZq6kjJdlWWcQ5uIiKj+xGcWAQACXaxN3BIiImrs6jzQHjx4MH7++Wfs3LkTH3/8Mfbu3YshQ4ZAq9VnaNPS0uDq6mq0j5mZGRwdHZGWllbtMRcuXAg7Ozvx4ePjU9fNvu8YMtpysxv/RMxoExER1Z+EbH2gHeBsY+KWEBFRY1fnKdIJEyaIz9u1a4f27dsjKCgIe/bswYABA+7qmHPnzsXs2bPF1yqVqskH24Yx2u297HA8kdN7ERER1bf4LEOgbWXilhARUWNX79N7BQYGwtnZGbGxsQAAd3d3ZGRkGG2j0WiQk5NT47huhUIBpVJp9GjqDPNoh/k5iMtYdZyIiKj+GDLa/k7sOk5ERPem3gPt69evIzs7Gx4eHgCAiIgI5OXl4cSJE+I2u3btgk6nQ3h4eH03p9Eo1egDbRdbBXwcLQGw6zgREdW/Dz74AD169ICVlRXs7e2r3SYpKQnDhg2DlZUVXF1d8eqrr0Kj0Rhts2fPHnTu3BkKhQLBwcFYsWJF/Tf+Li3eHYsHPtqFc8n6GjABzgy0iYjo3tQ60C4sLER0dDSio6MBAPHx8YiOjkZSUhIKCwvx6quv4vDhw0hISMDOnTsxcuRIBAcHIzIyEgDQunVrDB48GFOnTsXRo0dx8OBBzJw5ExMmTGDFcQD/tz8OD3y0C5fT9fOKW8plaONhBwCwZjE0IiKqZ2VlZRg3bhyee+65atdrtVoMGzYMZWVlOHToEFauXIkVK1Zg3rx54jbx8fEYNmwY+vXrh+joaMyaNQtPP/00tm7d2lAf446pNVos3XsVyXklAACJBPBxZNdxIiK6N7WO3I4fP45+/fqJrw1jpydNmoQlS5bgzJkzWLlyJfLy8uDp6YlBgwbhvffeg0KhEPdZvXo1Zs6ciQEDBkAqlWLMmDH45ptv6uDjNH7/nU1Fcl6JeMK3NJfhyQf8UajWYGi76rvWExER1ZUFCxYAQI0Z6G3btuHChQvYsWMH3Nzc0LFjR7z33nuYM2cO5s+fD7lcjqVLlyIgIACff/45AP1N9gMHDuDLL78Ub7zfLw5cyUJB6Y1svI3cDBasiUJERPeo1oF23759IQhCjevv5G61o6Mj1qxZU9u3bhbyS8qNXluayxAe6ITwQCcTtYiIiOiGqKgotGvXDm5ubuKyyMhIPPfcczh//jw6deqEqKgoDBw40Gi/yMhIzJo1q4Fbe3v/nkk1el2g1tSwJRER0Z2r9zHaVDuqUuMTvAXHZRMR0X0kLS3NKMgGIL42TNNZ0zYqlQolJSXVHletVkOlUhk96ptGq8P2C+kAgMk9/AEAc4eE1Pv7EhFR08dA+z5TXUabiIjoXrz++uuQSCS3fFy6dMmkbVy4cCHs7OzER0NM45mUU4wCtQYW5lLMeygUJ99+EFN7Bdb7+xIRUdPH6lr3kdJyLco0OqNlDLSJiOhevfzyy5g8efIttwkMvLMA093dHUePHjValp6eLq4z/NewrPI2SqUSlpaW1R537ty5Yt0XAFCpVPUebMdm6AuPBrnYQCqVwNFaXq/vR0REzQcD7fuI6qZsNgAWZCEionvm4uICFxeXOjlWREQEPvjgA2RkZMDV1RUAsH37diiVSoSGhorb/Pfff0b7bd++HRERETUeV6FQGBVObQixmfpAO9jVpkHfl4iImj52Hb+P3NxtHGBGm4iIGlZSUpI4badWqxWn9Cws1AelgwYNQmhoKCZOnIjTp09j69ateOuttzBjxgwxUH722WcRFxeH1157DZcuXcJ3332H9evX46WXXjLlR6sitmIqzWAXBtpERFS3mNG+j6hKq8loy3kvhIiIGs68efOwcuVK8XWnTp0AALt370bfvn0hk8mwadMmPPfcc4iIiIC1tTUmTZqEd999V9wnICAA//77L1566SV8/fXX8Pb2xv/93//dd1N7GTLaLdwYaBMRUd1ioH0fYUabiIhMbcWKFTXOoW3g5+dXpWv4zfr27YtTp07VYcvqliAIuJrBruNERFQ/mC69j6hKqs7dyTHaREREdS81vxRFZVqYSSXwc7I2dXOIiKiJYaB9H6kuo20u4z8RERFRXTNUHPdzsuK5loiI6hzPLPeR6qqOExERUd1LyC4CAAQ4s9s4ERHVPQba95HqMtpERERU9xKziwEA/k5WJm4JERE1RQy07yPVVR0nIiKiupdYkdH2Y6BNRP/f3p1HR1Wm+x7/VSBVCYRKCAmpREgMg6CCiNjGolsEySGhvR5Qr8eBXhdahFZhtQwO4ABKD9jg0Gpzoft4W+yzcOxucYmKpBmvbUwLkgui5BCMBjEVlJhUEsj83j9CNpbMUFOqvp+1aq3s2m9V3uetvfLkqXfvdwMBQKEdRpjRBgAgODpmtDNZCA0AEAAU2mGEQhsAgMBrazMqr+LUcQBA4FBoh5Hj3d4LAAD414HaRjW2tKlLjE0ZSfGh7g4AIAJRaIcRZrQBAAi8jhXHz0uK59ZeAICAILuEERZDAwAg8MqPXJ/NQmgAgECh0A4TrW1GtQ3tp45fmO6UJNn5lh0AAL/7sooVxwEAgdU11B1Au+8ONUmSbDbp+cmXa9nGUv0sJyvEvQIAIPLsPdBeaJ/PiuMAgACh0A4T39Q2SpKSu9l1XlK8fnv90BD3CACAyFRSWStJGuxyhrgnAIBIxbnJYaKj0E7t4QhxTwAAiFyHmlqsxdAGuXqEuDcAgEhFoR0mKLQBAAi8PZV1MkZKSbCTcwEAAUOhHSa+qTtSaCeQ9AEACJTdHq8kZrMBAIFFoR0mmNEGACDwdnu4PhsAEHgU2mGCQhsAgMArOVJoM6MNAAgkCu0wQaENAEDglX3bvhDawN4JIe4JACCSUWiHiW+PXKOdwjXaAAAEjPdwsyQpubs9xD0BAEQyCu0wYS2Gxow2AAAB0dpmVN/UKknqERcb4t4AACIZhXYYaGxpVfWh9m/YWXUcAIDAqGtosX5OcHQNYU8AAJGOQjsMHKxrkiTFdrEpMZ5v2AEACITaxvYvtR1dY2Tvyr9AAIDAIcuEgY6F0FISHIqJsYW4NwAARKbaIzPanDYOAAg0Cu0wcKCWhdAAAAi0o4U2p40DAAKLQjsMVHobJElpzrgQ9wQAgMhV29B+6jiFNgAg0Ci0w0BHoe1KZEYbAIBAqWtkRhsAEBwU2mHAU3NkRrsHM9oAAASK98ip46w4DgAINArtMFB55BrttEQKbQBAaP3mN7/RyJEj1a1bNyUlJR23jc1mO+bxyiuv+LTZtGmTLrvsMjkcDg0YMEArV64MfOdP4eip4yyGBgAILArtMFB5ZEbbxTXaAIAQa2pq0k033aS77rrrpO1eeOEFVVRUWI+JEyda+8rKynTttddqzJgxKi4u1qxZs3THHXfovffeC3DvT66OxdAAAEFCpgkDHhZDAwCEiccee0ySTjkDnZSUJJfLddx9K1asUHZ2tp588klJ0oUXXqj3339fTz/9tPLy8vza3zNhrTrOqeMAgABjRjvEGppbVXO4/VQ2ZrQBAJ3FjBkzlJKSoiuuuEJ//vOfZYyx9hUWFio3N9enfV5engoLC4PdTR+cOg4ACBa+0g2h7eXfact/fytJiouNkTOejwMAEP4WLVqka665Rt26ddO6det09913q66uTr/85S8lSR6PR2lpaT6vSUtLk9fr1eHDhxUfH3/MezY2NqqxsdHa9nq9fu8399EGAAQLmSaErv/fH1g/u5xxstlsIewNACBSzZs3T7/73e9O2uazzz7T4MGDT+v9HnnkEevn4cOHq76+XkuXLrUK7bOxePFi67T1QKk9cnuvBAptAECAkWlC5HBTq892b04bBwAEyNy5czVlypSTtunXr99Zv39OTo5+9atfqbGxUQ6HQy6XS5WVlT5tKisr5XQ6jzubLUnz58/XnDlzrG2v16u+ffuedZ+O5+iMNqeOAwACi0I7RMqrDvlsO/l2HQAQIKmpqUpNTQ3Y+xcXF6tnz55yOBySJLfbrXfeecenTUFBgdxu9wnfw+FwWK8PlKPXaJNzAQCBRaYJkS8P1vtsd3zLDgBAKJWXl6uqqkrl5eVqbW1VcXGxJGnAgAFKSEjQW2+9pcrKSl155ZWKi4tTQUGBfvvb3+ree++13uPOO+/UH/7wB91///26/fbbtWHDBr322mt6++23QxRVu7pGVh0HAAQHmSZEvj+j3cPRVbP/7YIQ9gYAgHYLFizQiy++aG0PHz5ckrRx40aNHj1asbGxWrZsmWbPni1jjAYMGKCnnnpK06ZNs16TnZ2tt99+W7Nnz9YzzzyjPn366Pnnnw/prb2MMZw6DgAIGpv5/v04Ogmv16vExETV1NTI6XSGujtn5ZHVn+i/PvxSd43urwfyT2/xGQAAooW/c/2hphZdtOA9SdKux/LUnVltAEAAcR/tEPnyyIx2VnK3EPcEAIDIV3dkNjvGJnWzdwlxbwAAkY5CO0TKj1yjndmLQhsAgEDzHim0uzu6cjtNAEDAUWiHQEtrm7767rAkKatX9xD3BgCAyMdCaACAYKLQDoE9B+rU0mZk7xIjF/fPBgAg4Oobj85oAwAQaBTaQWaM0WNv7ZIkXTUwRV1iOH0NAIBAq6PQBgAEEYV2kL29s0Iffl6l+NguevTfLw51dwAAiAodM9oJFNoAgCAg2wRJfWOLWo3Re7sqJUlTfny++rLiOAAAQXH01HFWHAcABB6FdhC0thn99Nn/q8bmNjW0tEqSxgzqHeJeAQAQPeqb2vMvp44DAIKBbBMEX1cf1pcHD1nb3e1dNDwzKXQdAgAgynDqOAAgmLhGOwi+X2RLUk6/XortwtADABAsLIYGAAimM672tmzZouuuu04ZGRmy2WxavXq1z35jjBYsWKD09HTFx8crNzdXe/bs8WlTVVWlSZMmyel0KikpSVOnTlVdXd05BRLOvqyq99n+8YCUEPUEAIDoxIw2ACCYzrjQrq+v17Bhw7Rs2bLj7l+yZImeffZZrVixQkVFRerevbvy8vLU0NBgtZk0aZJ27dqlgoICrVmzRlu2bNH06dPPPoowV35kRrtfSnf9zxF99B+X9wlxjwAAiC71jUeu0bazGBoAIPDO+Gvd8ePHa/z48cfdZ4zR73//ez388MOaMGGCJOkvf/mL0tLStHr1at1yyy367LPPtHbtWn300Ue6/PLLJUnPPfecfvrTn+qJJ55QRkbGOYQTnjpOHf/ZlVm6/SfZIe4NAADRh1PHAQDB5NcLhcvKyuTxeJSbm2s9l5iYqJycHBUWFkqSCgsLlZSUZBXZkpSbm6uYmBgVFRUd930bGxvl9Xp9Hp1BW5vRf1fW6suq9kI7qxe38wIAIBQ4dRwAEEx+LbQ9Ho8kKS0tzef5tLQ0a5/H41Hv3r63turatauSk5OtNj+0ePFiJSYmWo++ffv6s9tnbFPJAS3bWCpjzAnbGGN071//n8Y9vUWfVbR/MUChDQBAaDCjDQAIpk6x9PX8+fNVU1NjPfbt2xfS/sz7204tfa9EO/fXWM+t2LxXly5ap7tXbVPZt/VaVVSuv3+83+d1fXpSaAMAEAr1TRTaAIDg8Wu2cblckqTKykqlp6dbz1dWVurSSy+12hw4cMDndS0tLaqqqrJe/0MOh0MOh8OfXT1r3oZmebztC7t99d1heQ+36IK0BL22dZ+qDzXrnZ0ebS+v1sG6pmNeGxfLAiwAAISCtRiag1wMAAg8v85oZ2dny+Vyaf369dZzXq9XRUVFcrvdkiS3263q6mpt27bNarNhwwa1tbUpJyfHn90JiLJvjt6q67Wt+/Sz/1Ok3Kc264tv25+Pi41RRU2DmlrbNO6iNP3n/7pcNpt03bDIW+QNAIDOwjp13M6MNgAg8M4429TV1am0tNTaLisrU3FxsZKTk5WZmalZs2bp17/+tQYOHKjs7Gw98sgjysjI0MSJEyVJF154ofLz8zVt2jStWLFCzc3Nmjlzpm655ZaQrTi+86sa3fGXj3R/3mDdOOLkt94q+/Zoob2p5BtJkrehPXn36m7Xyp9fodv+80OlJ8Vp6U3DlBgfq033jlZqj/CYkQcAINo0t7apqaVNEouhAQCC44yzzdatWzVmzBhre86cOZKkyZMna+XKlbr//vtVX1+v6dOnq7q6Wj/5yU+0du1axcXFWa9ZtWqVZs6cqbFjxyomJkY33nijnn32WT+Ec3Ze3VquSm+jlm0s1Q2XnSebzXbCtp9/U3fCfRemOzW0T6L+Of8axcd2UWyX9hMGsnp193ufAQDA6elYcVziGm0AQHCccbYZPXr0SVfbttlsWrRokRYtWnTCNsnJyXrppZfO9FcHzEdl30mSPv+2Xp9WeHVxRqLP/v8q/EJrd3k0L/9Cff69Ge0fujC9hyTJGRcbuM4CAIAz0nHauL1LjOxdO8U6sACATi7qv9b9rr5JJZW11vbbOyqU3N2uv237Sj+7MkuvfLRPj7+7W5L0H38s1OHm1hO+12CXM+D9BQAAZ+ZQEwuhAQCCK+oL7Y++qJIk2WySMdLfPv5Km0q+0acVXm3YfUDb91VLkvqldD/pbLbUfuo4AAAIL9xDGwAQbFF//lRHoX39pecpM7mbKr2N+rTCK0n6uLxaxkj/45J0rZ01StkpR6+1/v5l3INdPXRBWoIGpiUEte8AAODUOq7RZiE0AECwRH2h/a+y9kJ71AWp+vOUy9Ujrj0JD+jdXjTbu8TogfzBsneN0ao7ctQ/tbtuGH6eUhLaVxHv0zNe795zldbNvtpa/AwAAISPema0AQBBFvUZ54H8wfrw84O6sl8vuRLj9O49V2n/d4d1fkp3zXmtWHkXu9Q3uZskKSMpXv+Yc7VsNpv+/Q/v65vaRmUmdzvpKuUAACC06ho7rtGO+n97AABBEvUZZ+SAFI0ckGJt9+nZTX16thfWq+648pj2HUW1yxmnHapR5pEiHAAAhKejp46zGBoAIDg41/ksDT6y8NmQ8xJP0RIAAISStRiaPernFwAAQULGOUszxvTX1RekaFifpFB3BQAAnMS1Q9PVPzVB6Ylxoe4KACBKMKN9lhxdu2hEVrK6sgAaACBCfPHFF5o6daqys7MVHx+v/v37a+HChWpqavJpt2PHDl111VWKi4tT3759tWTJkmPe6/XXX9fgwYMVFxenoUOH6p133glWGMc4P6W78oe4NKxvUsj6AACILlSJAABAkrR79261tbXpj3/8o3bt2qWnn35aK1as0IMPPmi18Xq9GjdunLKysrRt2zYtXbpUjz76qP70pz9ZbT744APdeuutmjp1qrZv366JEydq4sSJ+uSTT0IRFgAAQWczxphQd+JMeb1eJSYmqqamRk6nM9TdAQAgYi1dulTLly/X559/Lklavny5HnroIXk8HtntdknSvHnztHr1au3evVuSdPPNN6u+vl5r1qyx3ufKK6/UpZdeqhUrVpzW7yXXAwA6M2a0AQDACdXU1Cg5OdnaLiws1KhRo6wiW5Ly8vJUUlKi7777zmqTm5vr8z55eXkqLCw84e9pbGyU1+v1eQAA0FlRaAMAgOMqLS3Vc889p1/84hfWcx6PR2lpaT7tOrY9Hs9J23TsP57FixcrMTHRevTt29dfYQAAEHQU2gAARLh58+bJZrOd9NFx2neH/fv3Kz8/XzfddJOmTZsW8D7Onz9fNTU11mPfvn0B/50AAAQKt/cCACDCzZ07V1OmTDlpm379+lk/f/311xozZoxGjhzps8iZJLlcLlVWVvo817HtcrlO2qZj//E4HA45HI5TxgIAQGdAoQ0AQIRLTU1VamrqabXdv3+/xowZoxEjRuiFF15QTIzvyW9ut1sPPfSQmpubFRsbK0kqKCjQoEGD1LNnT6vN+vXrNWvWLOt1BQUFcrvd/gkIAIAwx6njAABAUnuRPXr0aGVmZuqJJ57QN998I4/H43Nt9W233Sa73a6pU6dq165devXVV/XMM89ozpw5Vpt77rlHa9eu1ZNPPqndu3fr0Ucf1datWzVz5sxQhAUAQNAxow0AACS1zzqXlpaqtLRUffr08dnXcTfQxMRErVu3TjNmzNCIESOUkpKiBQsWaPr06VbbkSNH6qWXXtLDDz+sBx98UAMHDtTq1as1ZMiQoMYDAECocB9tAAAQdsj1AIDOrFPOaHd8N8A9NgEA4aZHjx6y2Wyh7kanR64HAISr08n1nbLQrq2tlSTusQkACDvMwPoHuR4AEK5OJ9d3ylPH29ra9PXXX/tl1sDr9apv377at29f1P5jFO1jQPzEH83xS4yBv+NnRts//JnrJY5z4if+aI5fYgyIP/i5vlPOaMfExByzSMu5cjqdUXnQfV+0jwHxE380xy8xBtEef7gJRK6X+JyJn/ijOX6JMSD+4MXP7b0AAAAAAPAjCm0AAAAAAPwo6gtth8OhhQsXyuFwhLorIRPtY0D8xB/N8UuMQbTHHy2i/XMmfuKP5vglxoD4gx9/p1wMDQAAAACAcBX1M9oAAAAAAPgThTYAAAAAAH5EoQ0AAAAAgB9RaAMAAAAA4EdRX2gvW7ZM559/vuLi4pSTk6N//etfoe5SQDz66KOy2Ww+j8GDB1v7GxoaNGPGDPXq1UsJCQm68cYbVVlZGcIen5stW7bouuuuU0ZGhmw2m1avXu2z3xijBQsWKD09XfHx8crNzdWePXt82lRVVWnSpElyOp1KSkrS1KlTVVdXF8Qozt6p4p8yZcoxx0N+fr5Pm84c/+LFi/WjH/1IPXr0UO/evTVx4kSVlJT4tDmdY768vFzXXnutunXrpt69e+u+++5TS0tLMEM5a6czBqNHjz7mOLjzzjt92nTWMVi+fLkuueQSOZ1OOZ1Oud1uvfvuu9b+SP/84Ytc345cH1m5XiLfR3u+J9eHd66P6kL71Vdf1Zw5c7Rw4UJ9/PHHGjZsmPLy8nTgwIFQdy0gLr74YlVUVFiP999/39o3e/ZsvfXWW3r99de1efNmff3117rhhhtC2NtzU19fr2HDhmnZsmXH3b9kyRI9++yzWrFihYqKitS9e3fl5eWpoaHBajNp0iTt2rVLBQUFWrNmjbZs2aLp06cHK4Rzcqr4JSk/P9/neHj55Zd99nfm+Ddv3qwZM2boww8/VEFBgZqbmzVu3DjV19dbbU51zLe2turaa69VU1OTPvjgA7344otauXKlFixYEIqQztjpjIEkTZs2zec4WLJkibWvM49Bnz599Pjjj2vbtm3aunWrrrnmGk2YMEG7du2SFPmfP44i15PrIzXXS+T7aM/35Powz/Umil1xxRVmxowZ1nZra6vJyMgwixcvDmGvAmPhwoVm2LBhx91XXV1tYmNjzeuvv24999lnnxlJprCwMEg9DBxJ5o033rC229rajMvlMkuXLrWeq66uNg6Hw7z88svGGGM+/fRTI8l89NFHVpt3333X2Gw2s3///qD13R9+GL8xxkyePNlMmDDhhK+JpPiNMebAgQNGktm8ebMx5vSO+XfeecfExMQYj8djtVm+fLlxOp2msbExuAH4wQ/HwBhjrr76anPPPfec8DWRNgY9e/Y0zz//fFR+/tGMXN+OXB/Zud4Y8r0x5HtyfXjl+qid0W5qatK2bduUm5trPRcTE6Pc3FwVFhaGsGeBs2fPHmVkZKhfv36aNGmSysvLJUnbtm1Tc3Ozz1gMHjxYmZmZETkWZWVl8ng8PvEmJiYqJyfHirewsFBJSUm6/PLLrTa5ubmKiYlRUVFR0PscCJs2bVLv3r01aNAg3XXXXTp48KC1L9Lir6mpkSQlJydLOr1jvrCwUEOHDlVaWprVJi8vT16v1/qmtDP54Rh0WLVqlVJSUjRkyBDNnz9fhw4dsvZFyhi0trbqlVdeUX19vdxud1R+/tGKXE+uj/ZcL5Hvo+nvPbk+vHJ913N+h07q22+/VWtrq8/ASlJaWpp2794dol4FTk5OjlauXKlBgwapoqJCjz32mK666ip98skn8ng8stvtSkpK8nlNWlqaPB5PaDocQB0xHe+z79jn8XjUu3dvn/1du3ZVcnJyRIxJfn6+brjhBmVnZ2vv3r168MEHNX78eBUWFqpLly4RFX9bW5tmzZqlH//4xxoyZIgkndYx7/F4jnuMdOzrTI43BpJ02223KSsrSxkZGdqxY4ceeOABlZSU6O9//7ukzj8GO3fulNvtVkNDgxISEvTGG2/ooosuUnFxcVR9/tGMXE+uj+ZcL5Hvoynfk+vDL9dHbaEdbcaPH2/9fMkllygnJ0dZWVl67bXXFB8fH8KeIRRuueUW6+ehQ4fqkksuUf/+/bVp0yaNHTs2hD3zvxkzZuiTTz7xuU4x2pxoDL5/Dd7QoUOVnp6usWPHau/everfv3+wu+l3gwYNUnFxsWpqavTXv/5VkydP1ubNm0PdLSBgyPX4IfJ99CDXh1+uj9pTx1NSUtSlS5djVp6rrKyUy+UKUa+CJykpSRdccIFKS0vlcrnU1NSk6upqnzaROhYdMZ3ss3e5XMcslNPS0qKqqqqIHJN+/fopJSVFpaWlkiIn/pkzZ2rNmjXauHGj+vTpYz1/Ose8y+U67jHSsa+zONEYHE9OTo4k+RwHnXkM7Ha7BgwYoBEjRmjx4sUaNmyYnnnmmaj6/KMduZ5cT673Rb5vF2l/78n14Znro7bQttvtGjFihNavX28919bWpvXr18vtdoewZ8FRV1envXv3Kj09XSNGjFBsbKzPWJSUlKi8vDwixyI7O1sul8snXq/Xq6KiIitet9ut6upqbdu2zWqzYcMGtbW1WX+gIslXX32lgwcPKj09XVLnj98Yo5kzZ+qNN97Qhg0blJ2d7bP/dI55t9utnTt3+vwDUlBQIKfTqYsuuig4gZyDU43B8RQXF0uSz3HQmcfgh9ra2tTY2BgVnz/akevJ9eR6X+T7yPp7T64/Vljl+nNeTq0Te+WVV4zD4TArV640n376qZk+fbpJSkryWXkuUsydO9ds2rTJlJWVmX/+858mNzfXpKSkmAMHDhhjjLnzzjtNZmam2bBhg9m6datxu93G7XaHuNdnr7a21mzfvt1s377dSDJPPfWU2b59u/nyyy+NMcY8/vjjJikpybz55ptmx44dZsKECSY7O9scPnzYeo/8/HwzfPhwU1RUZN5//30zcOBAc+utt4YqpDNysvhra2vNvffeawoLC01ZWZn5xz/+YS677DIzcOBA09DQYL1HZ47/rrvuMomJiWbTpk2moqLCehw6dMhqc6pjvqWlxQwZMsSMGzfOFBcXm7Vr15rU1FQzf/78UIR0xk41BqWlpWbRokVm69atpqyszLz55pumX79+ZtSoUdZ7dOYxmDdvntm8ebMpKyszO3bsMPPmzTM2m82sW7fOGBP5nz+OIteT6yM11xtDvo/2fE+uD+9cH9WFtjHGPPfccyYzM9PY7XZzxRVXmA8//DDUXQqIm2++2aSnpxu73W7OO+88c/PNN5vS0lJr/+HDh83dd99tevbsabp162auv/56U1FREcIen5uNGzcaScc8Jk+ebIxpv+3HI488YtLS0ozD4TBjx441JSUlPu9x8OBBc+utt5qEhATjdDrNz3/+c1NbWxuCaM7cyeI/dOiQGTdunElNTTWxsbEmKyvLTJs27Zh/Ojtz/MeLXZJ54YUXrDanc8x/8cUXZvz48SY+Pt6kpKSYuXPnmubm5iBHc3ZONQbl5eVm1KhRJjk52TgcDjNgwABz3333mZqaGp/36axjcPvtt5usrCxjt9tNamqqGTt2rJV4jYn8zx++yPXtyPWRleuNId9He74n14d3rrcZY8y5z4sDAAAAAAApiq/RBgAAAAAgECi0AQAAAADwIwptAAAAAAD8iEIbAAAAAAA/otAGAAAAAMCPKLQBAAAAAPAjCm0AAAAAAPyIQhsAAAAAAD+i0AYAAAAAwI8otAEAAAAA8CMKbQAAAAAA/IhCGwAAAAAAP/r/JFcTBjv1uYYAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_steps = []\n",
    "total_rewards = []\n",
    "for episode in range(num_episodes):\n",
    "    # Train for one episode\n",
    "    simple_model.train()\n",
    "    episode_summary = train_for_one_episode(\n",
    "        vec_env,\n",
    "        model=simple_model,\n",
    "        optimizer=optimizer,\n",
    "        max_steps=max_steps,\n",
    "        device=device,\n",
    "    )\n",
    "    num_steps.append(episode_summary.num_steps.mean())\n",
    "    total_rewards.append(episode_summary.total_rewards.mean())\n",
    "\n",
    "    # Decay learning rate\n",
    "    for param_group in optimizer.param_groups:\n",
    "        param_group[\"lr\"] = learning_rate_schedule[episode]\n",
    "\n",
    "    # Report progress\n",
    "    result_frequency = \", \".join(\n",
    "        f\"{k}: {v:>4.0%}\" for k, v in episode_summary.result_frequency.items()\n",
    "    )\n",
    "    print(\n",
    "        f\"{episode + 1:>3} | \"\n",
    "        f\"avg steps: {np.mean(num_steps[-save_freq:]):>3.0f} | \"\n",
    "        f\"avg reward: {np.mean(total_rewards[-save_freq:]):>6.1f} | \"\n",
    "        f\"{result_frequency}\",\n",
    "        flush=True,\n",
    "        end=\"\\r\",\n",
    "    )\n",
    "    if (episode + 1) % save_freq == 0:\n",
    "        print()\n",
    "\n",
    "# Plot the training progress\n",
    "_, axs = plt.subplots(1, 2, figsize=(12, 4))\n",
    "axs[0].plot(num_steps)\n",
    "axs[0].set_title(\"Number of steps\")\n",
    "axs[0].spines[\"right\"].set_visible(False)\n",
    "axs[0].spines[\"top\"].set_visible(False)\n",
    "\n",
    "axs[1].plot(total_rewards)\n",
    "axs[1].set_title(\"Average total rewards\")\n",
    "axs[1].spines[\"right\"].set_visible(False)\n",
    "axs[1].spines[\"top\"].set_visible(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Save Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sign and save the model to local directory\n",
    "env_config = dotenv_values()\n",
    "\n",
    "sign_n_save_model(\n",
    "    model=simple_model.cpu(),\n",
    "    destination=\"../models/lunar-lander\",\n",
    "    keypair=load_keypair(\"../models/private.pem\", env_config[\"MODEL_KEY_PASSWORD\"]),\n",
    "    overwrite=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load and evaluate model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mean_reward=252.82 +/- 16.283324630001893\n"
     ]
    }
   ],
   "source": [
    "# Load model\n",
    "lunar_lander: SimplePolicyNet = load_n_verify_model(\"../models/lunar-lander\")\n",
    "lunar_lander.eval()\n",
    "\n",
    "# Evaluate the model\n",
    "env_id = \"LunarLander-v2\"\n",
    "num_episodes = 30\n",
    "eval_env = Monitor(gym.make(\"LunarLander-v2\"))\n",
    "mean_reward, std_reward = evaluate_policy(\n",
    "    lunar_lander, eval_env, n_eval_episodes=num_episodes, deterministic=True\n",
    ")\n",
    "print(f\"mean_reward={mean_reward:.2f} +/- {std_reward}\")\n",
    "\n",
    "eval_stats = {\n",
    "    \"env_id\": env_id,\n",
    "    \"num_episodes\": num_episodes,\n",
    "    \"mean_reward\": mean_reward,\n",
    "    \"std_reward\": std_reward,\n",
    "}\n",
    "\n",
    "with open(\"../models/lunar-lander/eval_results.json\", \"w\") as f:\n",
    "    json.dump(eval_stats, f, indent=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Capture replay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "rewards = capture_replay(\n",
    "    env=gym.make(\"LunarLander-v2\", render_mode=\"rgb_array\"),\n",
    "    action_func=lunar_lander.get_action,\n",
    "    video_folder=\"../models/lunar-lander\",\n",
    "    max_steps=500,\n",
    ")\n",
    "print(f\"Total steps: {len(rewards)}\\nTotal reward: {sum(rewards)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "r2seedo_default_3.10",
   "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.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}